func()

in pkg/cloudprovider/vsphere/loadbalancer/cleanup.go [95:177]
76 lines of code
23 McCabe index (conditional complexity)

func (p *lbProvider) CleanupServices(clusterName string, validServices map[types.NamespacedName]corev1.Service, ensureLBServiceDeleted bool) error {
	ipPoolIds := sets.NewString()
	for _, name := range p.classes.GetClassNames() {
		class := p.classes.GetClass(name)
		ipPoolIds.Insert(class.ipPool.Identifier)
	}

	lbs := map[types.NamespacedName]struct{}{}
	servers, err := p.access.ListVirtualServers(clusterName)
	if err != nil {
		return err
	}
	for _, server := range servers {
		tag := getTag(server.Tags, ScopeService)
		if tag != "" {
			lbs[parseNamespacedName(tag)] = struct{}{}
		}
		ipPoolID := getTag(server.Tags, ScopeIPPoolID)
		ipPoolIds.Insert(ipPoolID)
	}
	ipPoolIds.Delete("")

	pools, err := p.access.ListPools(clusterName)
	if err != nil {
		return err
	}
	for _, pool := range pools {
		tag := getTag(pool.Tags, ScopeService)
		if tag != "" {
			lbs[parseNamespacedName(tag)] = struct{}{}
		}
	}

	monitors, err := p.access.ListTCPMonitorProfiles(clusterName)
	if err != nil {
		return err
	}
	for _, pool := range monitors {
		tag := getTag(pool.Tags, ScopeService)
		if tag != "" {
			lbs[parseNamespacedName(tag)] = struct{}{}
		}
	}

	for ipPoolID := range ipPoolIds {
		ipAddressAllocs, err := p.access.ListExternalIPAddresses(ipPoolID, clusterName)
		if err != nil {
			return err
		}
		for _, ipAddressAlloc := range ipAddressAllocs {
			tag := getTag(ipAddressAlloc.Tags, ScopeService)
			if tag != "" {
				lbs[parseNamespacedName(tag)] = struct{}{}
			}
		}
	}

	klog.Infof("cleanup: %d existing services, artefacts for %d services", len(validServices), len(lbs))
	for lb := range lbs {
		if svc, ok := validServices[lb]; !ok || svc.Spec.Type != corev1.ServiceTypeLoadBalancer {
			service := &corev1.Service{
				ObjectMeta: metav1.ObjectMeta{
					Namespace: lb.Namespace,
					Name:      lb.Name,
				},
			}
			klog.Infof("deleting artefacts for non-existing service %s/%s", lb.Namespace, lb.Name)
			err = p.EnsureLoadBalancerDeleted(context.TODO(), clusterName, service)
			if err != nil {
				return err
			}
		}
	}

	// check for orphan unmanaged load balancer service if there are no virtual servers and flag ensureLBServiceDeleted == true
	if len(lbs) == 0 && ensureLBServiceDeleted {
		err = p.removeLoadBalancerServiceIfUnused(clusterName)
		if err != nil && !isNotFoundError(err) {
			return errors.Wrap(err, "removeLoadBalancerServiceIfUnused failed")
		}
	}
	return nil
}