func()

in pkg/loadbalancers/forwarding_rules.go [76:150]

• 64 lines of code
• 19 McCabe index (conditional complexity)

func (l *L7) checkForwardingRule(protocol namer.NamerProtocol, name, proxyLink, ip string) (existing *composite.ForwardingRule, err error) {
	key, err := l.CreateKey(name)
	if err != nil {
		return nil, err
	}
	version := l.Versions().ForwardingRule
	description, err := l.description()
	if err != nil {
		return nil, err
	}

	isL7ILB := utils.IsGCEL7ILBIngress(l.runtimeInfo.Ingress)
	tr := translator.NewTranslator(isL7ILB, l.namer)
	env := &translator.Env{VIP: ip, Network: l.cloud.NetworkURL(), Subnetwork: l.cloud.SubnetworkURL()}
	fr := tr.ToCompositeForwardingRule(env, protocol, version, proxyLink, description, l.runtimeInfo.StaticIPSubnet)

	existing, _ = composite.GetForwardingRule(l.cloud, key, version)
	if existing != nil && (fr.IPAddress != "" && existing.IPAddress != fr.IPAddress || existing.PortRange != fr.PortRange) {
		klog.Warningf("Recreating forwarding rule %v(%v), so it has %v(%v)",
			existing.IPAddress, existing.PortRange, fr.IPAddress, fr.PortRange)
		if err = utils.IgnoreHTTPNotFound(composite.DeleteForwardingRule(l.cloud, key, version)); err != nil {
			return nil, err
		}
		existing = nil
		l.recorder.Eventf(l.runtimeInfo.Ingress, corev1.EventTypeNormal, events.SyncIngress, "ForwardingRule %q deleted", key.Name)
	}
	if existing == nil {
		// This is a special case where exactly one of http or https forwarding rule
		// existed before and the existing forwarding rule uses ingress managed static ip address.
		// In this case, the forwarding rule needs to be created with the same static ip.
		// Note that this is not needed when user specifies a static IP.
		if ip == "" {
			managedStaticIPName := l.namer.ForwardingRule(namer.HTTPProtocol)
			// Get static IP address if ingress has static IP annotation.
			// Note that this Static IP annotation is applied by ingress controller.
			if currentIPName, exists := l.ingress.Annotations[annotations.StaticIPKey]; exists && currentIPName == managedStaticIPName {
				currentIP, _ := l.cloud.GetGlobalAddress(managedStaticIPName)
				if currentIP != nil {
					klog.V(3).Infof("Ingress managed static IP %s(%s) exists, using it to create forwarding rule %s", currentIPName, currentIP.Address, name)
					fr.IPAddress = currentIP.Address
				}
			}
		}
		klog.V(3).Infof("Creating forwarding rule for proxy %q and ip %v:%v", proxyLink, ip, protocol)

		if err = composite.CreateForwardingRule(l.cloud, key, fr); err != nil {
			return nil, err
		}
		l.recorder.Eventf(l.runtimeInfo.Ingress, corev1.EventTypeNormal, events.SyncIngress, "ForwardingRule %q created", key.Name)

		key, err = l.CreateKey(name)
		if err != nil {
			return nil, err
		}
		existing, err = composite.GetForwardingRule(l.cloud, key, version)
		if err != nil {
			return nil, err
		}
	}
	// TODO: If the port range and protocol don't match, recreate the rule
	if utils.EqualResourceIDs(existing.Target, proxyLink) {
		klog.V(4).Infof("Forwarding rule %v already exists", existing.Name)
	} else {
		klog.V(3).Infof("Forwarding rule %v has the wrong proxy, setting %v overwriting %v",
			existing.Name, existing.Target, proxyLink)
		key, err := l.CreateKey(existing.Name)
		if err != nil {
			return nil, err
		}
		if err := composite.SetProxyForForwardingRule(l.cloud, key, existing, proxyLink); err != nil {
			return nil, err
		}
	}
	return existing, nil
}