in pkg/fuzz/gcp.go [694:944]
func RegionalGCLBForVIP(ctx context.Context, c cloud.Cloud, gclb *GCLB, params *GCLBForVIPParams) error {
allRFRs, err := c.ForwardingRules().List(ctx, params.Region, filter.None)
if err != nil {
klog.Warningf("Error listing forwarding rules: %v", err)
return err
}
var rfrs []*compute.ForwardingRule
for _, rfr := range allRFRs {
netResID, err := cloud.ParseResourceURL(rfr.Network)
if err != nil {
klog.Warningf("Error parsing Network (%q): %v", rfr.Network, err)
return err
}
if rfr.IPAddress == params.VIP && netResID.Key.Name == params.Network {
rfrs = append(rfrs, rfr)
}
}
if len(rfrs) == 0 {
klog.Warningf("No regional forwarding rules found, can't get all GCLB resources")
return nil
}
var urlMapKey *meta.Key
for _, rfr := range rfrs {
frKey := meta.RegionalKey(rfr.Name, params.Region)
gclb.ForwardingRule[*frKey] = &ForwardingRule{GA: rfr}
if hasAlphaResource("forwardingRule", params.Validators) {
fr, err := c.AlphaForwardingRules().Get(ctx, frKey)
if err != nil {
klog.Warningf("Error getting alpha forwarding rules: %v", err)
return err
}
gclb.ForwardingRule[*frKey].Alpha = fr
}
if hasBetaResource("forwardingRule", params.Validators) {
fr, err := c.BetaForwardingRules().Get(ctx, frKey)
if err != nil {
klog.Warningf("Error getting alpha forwarding rules: %v", err)
return err
}
gclb.ForwardingRule[*frKey].Beta = fr
}
// ForwardingRule => TargetProxy
resID, err := cloud.ParseResourceURL(rfr.Target)
if err != nil {
klog.Warningf("Error parsing Target (%q): %v", rfr.Target, err)
return err
}
switch resID.Resource {
case "targetHttpProxies":
// Use beta by default since not GA yet
p, err := c.BetaRegionTargetHttpProxies().Get(ctx, resID.Key)
if err != nil {
klog.Warningf("Error getting TargetHttpProxy %s: %v", resID.Key, err)
return err
}
gclb.TargetHTTPProxy[*resID.Key] = &TargetHTTPProxy{Beta: p}
if hasAlphaResource("targetHttpProxy", params.Validators) || hasBetaResource("targetHttpProxy", params.Validators) {
return errors.New("unsupported targetHttpProxy version")
}
urlMapResID, err := cloud.ParseResourceURL(p.UrlMap)
if err != nil {
klog.Warningf("Error parsing urlmap URL (%q): %v", p.UrlMap, err)
return err
}
if urlMapKey == nil {
urlMapKey = urlMapResID.Key
}
if *urlMapKey != *urlMapResID.Key {
klog.Warningf("Error targetHttpProxy references are not the same (%s != %s)", *urlMapKey, *urlMapResID.Key)
return fmt.Errorf("targetHttpProxy references are not the same: %+v != %+v", *urlMapKey, *urlMapResID.Key)
}
case "targetHttpsProxies":
// Use Beta by default since not GA yet
p, err := c.BetaRegionTargetHttpsProxies().Get(ctx, resID.Key)
if err != nil {
klog.Warningf("Error getting targetHttpsProxy (%s): %v", resID.Key, err)
return err
}
gclb.TargetHTTPSProxy[*resID.Key] = &TargetHTTPSProxy{Beta: p}
if hasAlphaResource("targetHttpsProxy", params.Validators) || hasBetaResource("targetHttpsProxy", params.Validators) {
return errors.New("unsupported targetHttpsProxy version")
}
urlMapResID, err := cloud.ParseResourceURL(p.UrlMap)
if err != nil {
klog.Warningf("Error parsing urlmap URL (%q): %v", p.UrlMap, err)
return err
}
if urlMapKey == nil {
urlMapKey = urlMapResID.Key
}
if *urlMapKey != *urlMapResID.Key {
klog.Warningf("Error targetHttpsProxy references are not the same (%s != %s)", *urlMapKey, *urlMapResID.Key)
return fmt.Errorf("targetHttpsProxy references are not the same: %+v != %+v", *urlMapKey, *urlMapResID.Key)
}
default:
klog.Errorf("Unhandled resource: %q, grf = %+v", resID.Resource, rfr)
return fmt.Errorf("unhandled resource %q", resID.Resource)
}
}
// TargetProxy => URLMap
// Use beta since params.Region is not GA yet
urlMap, err := c.BetaRegionUrlMaps().Get(ctx, urlMapKey)
if err != nil {
return err
}
gclb.URLMap[*urlMapKey] = &URLMap{Beta: urlMap}
if hasAlphaResource("urlMap", params.Validators) || hasBetaResource("urlMap", params.Validators) {
return errors.New("unsupported urlMap version")
}
// URLMap => BackendService(s)
var bsKeys []*meta.Key
resID, err := cloud.ParseResourceURL(urlMap.DefaultService)
if err != nil {
return err
}
bsKeys = append(bsKeys, resID.Key)
for _, pm := range urlMap.PathMatchers {
resID, err := cloud.ParseResourceURL(pm.DefaultService)
if err != nil {
return err
}
bsKeys = append(bsKeys, resID.Key)
for _, pr := range pm.PathRules {
resID, err := cloud.ParseResourceURL(pr.Service)
if err != nil {
return err
}
bsKeys = append(bsKeys, resID.Key)
}
}
for _, bsKey := range bsKeys {
bs, err := c.RegionBackendServices().Get(ctx, bsKey)
if err != nil {
return err
}
gclb.BackendService[*bsKey] = &BackendService{GA: bs}
if hasAlphaResource("backendService", params.Validators) {
bs, err := c.AlphaRegionBackendServices().Get(ctx, bsKey)
if err != nil {
return err
}
gclb.BackendService[*bsKey].Alpha = bs
}
if hasBetaResource("backendService", params.Validators) {
bs, err := c.BetaRegionBackendServices().Get(ctx, bsKey)
if err != nil {
return err
}
gclb.BackendService[*bsKey].Beta = bs
}
for _, hcURL := range bs.HealthChecks {
rID, err := cloud.ParseResourceURL(hcURL)
if err != nil {
return err
}
hc, err := c.RegionHealthChecks().Get(ctx, rID.Key)
if err != nil {
return err
}
gclb.HealthCheck[*rID.Key] = &HealthCheck{
GA: hc,
}
}
}
var negKeys []*meta.Key
var igKeys []*meta.Key
// Fetch NEG Backends
for _, bsKey := range bsKeys {
var beGroups []string
if hasAlphaResource("backendService", params.Validators) {
bs, err := c.AlphaRegionBackendServices().Get(ctx, bsKey)
if err != nil {
return err
}
for _, be := range bs.Backends {
beGroups = append(beGroups, be.Group)
}
} else {
bs, err := c.BetaRegionBackendServices().Get(ctx, bsKey)
if err != nil {
return err
}
for _, be := range bs.Backends {
beGroups = append(beGroups, be.Group)
}
}
for _, group := range beGroups {
if strings.Contains(group, NegResourceType) {
resourceId, err := cloud.ParseResourceURL(group)
if err != nil {
return err
}
negKeys = append(negKeys, resourceId.Key)
}
if strings.Contains(group, IgResourceType) {
resourceId, err := cloud.ParseResourceURL(group)
if err != nil {
return err
}
igKeys = append(igKeys, resourceId.Key)
}
}
}
for _, negKey := range negKeys {
neg, err := c.NetworkEndpointGroups().Get(ctx, negKey)
if err != nil {
return err
}
gclb.NetworkEndpointGroup[*negKey] = &NetworkEndpointGroup{GA: neg}
if hasAlphaResource(NegResourceType, params.Validators) {
neg, err := c.AlphaNetworkEndpointGroups().Get(ctx, negKey)
if err != nil {
return err
}
gclb.NetworkEndpointGroup[*negKey].Alpha = neg
}
if hasBetaResource(NegResourceType, params.Validators) {
neg, err := c.BetaNetworkEndpointGroups().Get(ctx, negKey)
if err != nil {
return err
}
gclb.NetworkEndpointGroup[*negKey].Beta = neg
}
}
for _, igKey := range igKeys {
ig, err := c.InstanceGroups().Get(ctx, igKey)
if err != nil {
return err
}
gclb.InstanceGroup[*igKey] = &InstanceGroup{GA: ig}
}
return err
}