func()

in pkg/controller/pvtz/actuator.go [228:290]

• 63 lines of code
• 20 McCabe index (conditional complexity)

func (a *Actuator) desiredPTR(svc *corev1.Service) ([]*model.PvtzEndpoint, error) {
	epb := model.NewPvtzEndpointBuilder()
	epb.WithTtl(ctrlCfg.CloudCFG.Global.PrivateZoneRecordTTL)
	epb.WithType(model.RecordTypePTR)
	epb.WithValueData(serviceRr(svc))
	switch svc.Spec.Type {
	case corev1.ServiceTypeLoadBalancer:
		for _, ingress := range svc.Status.LoadBalancer.Ingress {
			if IsIPv4(ingress.IP) {
				epb.WithRr(reverseIPv4(ingress.IP))
			} else if IsIPv6(ingress.IP) {
				epb.WithRr(reverseIPv6(ingress.IP))
			} else {
				return nil, fmt.Errorf("ingress ip %s is invalid", ingress.IP)
			}
		}
	case corev1.ServiceTypeClusterIP:
		if svc.Spec.ClusterIP == corev1.ClusterIPNone {
			rawEps, err := a.getEndpoints(types.NamespacedName{Namespace: svc.Namespace, Name: svc.Name})
			if err != nil {
				return nil, fmt.Errorf("getting endpoints error: %s", err)
			}
			for _, rawSubnet := range rawEps.Subsets {
				for _, addr := range rawSubnet.Addresses {
					if IsIPv4(addr.IP) {
						epb.WithRr(reverseIPv4(addr.IP))
					} else if IsIPv6(addr.IP) {
						epb.WithRr(reverseIPv6(addr.IP))
					} else {
						return nil, fmt.Errorf("pod ip %s is invalid", addr.IP)
					}
				}
			}
		} else {
			ips := append(svc.Spec.ClusterIPs, svc.Spec.ClusterIP)
			for _, ip := range ips {
				if IsIPv4(ip) {
					epb.WithRr(reverseIPv4(ip))
				} else if IsIPv6(ip) {
					epb.WithRr(reverseIPv6(ip))
				} else {
					return nil, fmt.Errorf("cluster ip %s is invalid", ip)
				}
			}
		}
	case corev1.ServiceTypeNodePort:
		ips := append(svc.Spec.ClusterIPs, svc.Spec.ClusterIP)
		for _, ip := range ips {
			if IsIPv4(ip) {
				epb.WithRr(reverseIPv4(ip))
			} else if IsIPv6(ip) {
				epb.WithRr(reverseIPv6(ip))
			} else {
				return nil, fmt.Errorf("cluster ip %s is invalid", ip)
			}
		}
	}
	eps := make([]*model.PvtzEndpoint, 0)
	if ep := epb.Build(); ep != nil {
		eps = append(eps, ep)
	}
	return eps, nil
}