in pkg/fuzz/gcp.go [436:691]
func GCLBForVIP(ctx context.Context, c cloud.Cloud, params *GCLBForVIPParams) (*GCLB, error) {
gclb := NewGCLB(params.VIP)
if params.Region != "" {
err := RegionalGCLBForVIP(ctx, c, gclb, params)
return gclb, err
}
allGFRs, err := c.GlobalForwardingRules().List(ctx, filter.None)
if err != nil {
klog.Warningf("Error listing forwarding rules: %v", err)
return nil, err
}
var gfrs []*compute.ForwardingRule
for _, gfr := range allGFRs {
if gfr.IPAddress == params.VIP {
gfrs = append(gfrs, gfr)
}
}
// Return immediately if there are no forwarding rules exist.
if len(gfrs) == 0 {
klog.Warningf("No global forwarding rules found, can't get all GCLB resources")
return gclb, nil
}
var urlMapKey *meta.Key
for _, gfr := range gfrs {
frKey := meta.GlobalKey(gfr.Name)
gclb.ForwardingRule[*frKey] = &ForwardingRule{GA: gfr}
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 nil, err
}
gclb.ForwardingRule[*frKey].Alpha = fr
}
if hasBetaResource("forwardingRule", params.Validators) {
return nil, errors.New("unsupported forwardingRule version")
}
// ForwardingRule => TargetProxy
resID, err := cloud.ParseResourceURL(gfr.Target)
if err != nil {
klog.Warningf("Error parsing Target (%q): %v", gfr.Target, err)
return nil, err
}
switch resID.Resource {
case targetHTTPProxyResource:
p, err := c.TargetHttpProxies().Get(ctx, resID.Key)
if err != nil {
klog.Warningf("Error getting TargetHttpProxy %s: %v", resID.Key, err)
return nil, err
}
gclb.TargetHTTPProxy[*resID.Key] = &TargetHTTPProxy{GA: p}
if hasAlphaResource("targetHttpProxy", params.Validators) || hasBetaResource("targetHttpProxy", params.Validators) {
return nil, 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 nil, 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 nil, fmt.Errorf("targetHttpProxy references are not the same: %+v != %+v", *urlMapKey, *urlMapResID.Key)
}
case targetHTTPSProxyResource:
p, err := c.TargetHttpsProxies().Get(ctx, resID.Key)
if err != nil {
klog.Warningf("Error getting targetHttpsProxy (%s): %v", resID.Key, err)
return nil, err
}
gclb.TargetHTTPSProxy[*resID.Key] = &TargetHTTPSProxy{GA: p}
if hasAlphaResource("targetHttpsProxy", params.Validators) || hasBetaResource("targetHttpsProxy", params.Validators) {
return nil, 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 nil, err
}
if urlMapKey == nil {
urlMapKey = urlMapResID.Key
}
// Ignore redirect urlmaps since they will not have backends, but add them to the gclb map
if strings.Contains(urlMapKey.Name, "-rm-") {
urlMap, err := c.UrlMaps().Get(ctx, urlMapKey)
if err != nil {
return nil, err
}
gclb.URLMap[*urlMapKey] = &URLMap{GA: urlMap}
urlMapKey = urlMapResID.Key
}
if *urlMapKey != *urlMapResID.Key {
klog.Warningf("Error targetHttpsProxy references are not the same (%s != %s)", *urlMapKey, *urlMapResID.Key)
return nil, fmt.Errorf("targetHttpsProxy references are not the same: %+v != %+v", *urlMapKey, *urlMapResID.Key)
}
default:
klog.Errorf("Unhandled resource: %q, grf = %+v", resID.Resource, gfr)
return nil, fmt.Errorf("unhandled resource %q", resID.Resource)
}
}
// TargetProxy => URLMap
urlMap, err := c.UrlMaps().Get(ctx, urlMapKey)
if err != nil {
return nil, err
}
gclb.URLMap[*urlMapKey] = &URLMap{GA: urlMap}
if hasAlphaResource("urlMap", params.Validators) || hasBetaResource("urlMap", params.Validators) {
return nil, errors.New("unsupported urlMap version")
}
// URLMap => BackendService(s)
var bsKeys []*meta.Key
resID, err := cloud.ParseResourceURL(urlMap.DefaultService)
if err != nil {
return nil, err
}
bsKeys = append(bsKeys, resID.Key)
for _, pm := range urlMap.PathMatchers {
resID, err := cloud.ParseResourceURL(pm.DefaultService)
if err != nil {
return nil, err
}
bsKeys = append(bsKeys, resID.Key)
for _, pr := range pm.PathRules {
resID, err := cloud.ParseResourceURL(pr.Service)
if err != nil {
return nil, err
}
bsKeys = append(bsKeys, resID.Key)
}
}
for _, bsKey := range bsKeys {
bs, err := c.BackendServices().Get(ctx, bsKey)
if err != nil {
return nil, err
}
gclb.BackendService[*bsKey] = &BackendService{GA: bs}
if hasAlphaResource("backendService", params.Validators) {
bs, err := c.AlphaBackendServices().Get(ctx, bsKey)
if err != nil {
return nil, err
}
gclb.BackendService[*bsKey].Alpha = bs
}
if hasBetaResource("backendService", params.Validators) {
bs, err := c.BetaBackendServices().Get(ctx, bsKey)
if err != nil {
return nil, err
}
gclb.BackendService[*bsKey].Beta = bs
}
for _, hcURL := range bs.HealthChecks {
rID, err := cloud.ParseResourceURL(hcURL)
if err != nil {
return nil, err
}
hc, err := c.HealthChecks().Get(ctx, rID.Key)
if err != nil {
return nil, 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.AlphaBackendServices().Get(ctx, bsKey)
if err != nil {
return nil, err
}
for _, be := range bs.Backends {
beGroups = append(beGroups, be.Group)
}
} else {
bs, err := c.BetaBackendServices().Get(ctx, bsKey)
if err != nil {
return nil, 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 nil, err
}
negKeys = append(negKeys, resourceId.Key)
}
if strings.Contains(group, IgResourceType) {
resourceId, err := cloud.ParseResourceURL(group)
if err != nil {
return nil, err
}
igKeys = append(igKeys, resourceId.Key)
}
}
}
for _, negKey := range negKeys {
neg, err := c.NetworkEndpointGroups().Get(ctx, negKey)
if err != nil {
return nil, err
}
gclb.NetworkEndpointGroup[*negKey] = &NetworkEndpointGroup{GA: neg}
if hasAlphaResource(NegResourceType, params.Validators) {
neg, err := c.AlphaNetworkEndpointGroups().Get(ctx, negKey)
if err != nil {
return nil, err
}
gclb.NetworkEndpointGroup[*negKey].Alpha = neg
}
if hasBetaResource(NegResourceType, params.Validators) {
neg, err := c.BetaNetworkEndpointGroups().Get(ctx, negKey)
if err != nil {
return nil, err
}
gclb.NetworkEndpointGroup[*negKey].Beta = neg
}
}
for _, igKey := range igKeys {
ig, err := c.InstanceGroups().Get(ctx, igKey)
if err != nil {
return nil, err
}
gclb.InstanceGroup[*igKey] = &InstanceGroup{GA: ig}
}
return gclb, err
}