func()

in pkg/fuzz/gcp.go [164:282]
109 lines of code
40 McCabe index (conditional complexity)

func (g *GCLB) CheckResourceDeletion(ctx context.Context, c cloud.Cloud, options *GCLBDeleteOptions) error {
	var resources []meta.Key

	for k := range g.ForwardingRule {
		var err error
		if k.Region != "" {
			_, err = c.ForwardingRules().Get(ctx, &k)
		} else {
			_, err = c.GlobalForwardingRules().Get(ctx, &k)
		}
		if err != nil {
			if err.(*googleapi.Error) == nil || err.(*googleapi.Error).Code != http.StatusNotFound {
				return fmt.Errorf("ForwardingRule %s is not deleted/error to get: %s", k.Name, err)
			}
		} else {
			resources = append(resources, k)
		}
	}
	for k := range g.TargetHTTPProxy {
		var err error
		if k.Region != "" {
			// Use beta since GA isn't available yet
			_, err = c.BetaRegionTargetHttpProxies().Get(ctx, &k)
		} else {
			_, err = c.TargetHttpProxies().Get(ctx, &k)
		}
		if err != nil {
			if err.(*googleapi.Error) == nil || err.(*googleapi.Error).Code != http.StatusNotFound {
				return fmt.Errorf("TargetHTTPProxy %s is not deleted/error to get: %s", k.Name, err)
			}
		} else {
			resources = append(resources, k)
		}
	}
	for k := range g.TargetHTTPSProxy {
		var err error
		if k.Region != "" {
			// Use beta since GA isn't available yet
			_, err = c.BetaRegionTargetHttpsProxies().Get(ctx, &k)
		} else {
			_, err = c.TargetHttpsProxies().Get(ctx, &k)
		}
		if err != nil {
			if err.(*googleapi.Error) == nil || err.(*googleapi.Error).Code != http.StatusNotFound {
				return fmt.Errorf("TargetHTTPSProxy %s is not deleted/error to get: %s", k.Name, err)
			}
		} else {
			resources = append(resources, k)
		}
	}
	for k := range g.URLMap {
		var err error
		if k.Region != "" {
			_, err = c.BetaRegionUrlMaps().Get(ctx, &k)
		} else {
			_, err = c.UrlMaps().Get(ctx, &k)
		}
		if err != nil {
			if err.(*googleapi.Error) == nil || err.(*googleapi.Error).Code != http.StatusNotFound {
				return fmt.Errorf("URLMap %s is not deleted/error to get: %s", k.Name, err)
			}
		} else {
			resources = append(resources, k)
		}
	}
	if options == nil || !options.SkipBackends {
		for k := range g.BackendService {
			var err error
			var bs *compute.BackendService
			if k.Region != "" {
				bs, err = c.RegionBackendServices().Get(ctx, &k)
			} else {
				bs, err = c.BackendServices().Get(ctx, &k)
			}
			if err != nil {
				if err.(*googleapi.Error) == nil || err.(*googleapi.Error).Code != http.StatusNotFound {
					return fmt.Errorf("BackendService %s is not deleted/error to get: %s", k.Name, err)
				}
			} else {
				if options != nil && options.SkipDefaultBackend {
					desc := utils.DescriptionFromString(bs.Description)
					if desc.ServiceName == fmt.Sprintf("%s/%s", kubeSystemNS, defaultHTTPBackend) {
						continue
					}
				}
				resources = append(resources, k)
			}
		}

		for k := range g.NetworkEndpointGroup {
			ns, err := c.BetaNetworkEndpointGroups().Get(ctx, &k)
			if err != nil {
				if err.(*googleapi.Error) == nil || err.(*googleapi.Error).Code != http.StatusNotFound {
					return fmt.Errorf("NetworkEndpointGroup %s is not deleted/error to get: %s", k.Name, err)
				}
			} else {
				// TODO(smatti): Add NEG description to make this less error prone.
				// This is to ensure that ILB tests that use NEGs are not blocked on default NEG deletion.
				// Also, the default NEG may not get recognized here if default http backend name is changed
				// to cause truncation.
				if options != nil && options.SkipDefaultBackend &&
					strings.Contains(ns.Name, fmt.Sprintf("%s-%s", kubeSystemNS, defaultHTTPBackend)) {
					continue
				}
				resources = append(resources, k)
			}
		}
	}

	if len(resources) != 0 {
		var s []string
		for _, r := range resources {
			s = append(s, r.String())
		}
		return fmt.Errorf("resources still exist (%s)", strings.Join(s, ", "))
	}

	return nil
}