func registerDefaultController()

in pkg/controller/registration/registration_controller.go [187:300]
96 lines of code
29 McCabe index (conditional complexity)

func registerDefaultController(r *ReconcileRegistration, config *config.ControllerConfig, crd *apiextensions.CustomResourceDefinition, gvk schema.GroupVersionKind) (k8s.SchemaReferenceUpdater, error) {
	if _, ok := k8s.IgnoredKindList[crd.Spec.Names.Kind]; ok {
		return nil, nil
	}
	cds := controller.Deps{
		TfProvider:   r.provider,
		TfLoader:     r.smLoader,
		DclConfig:    r.dclConfig,
		DclConverter: r.dclConverter,
		JitterGen:    r.jitterGenerator,
		Defaulters:   r.defaulters,
	}
	var schemaUpdater k8s.SchemaReferenceUpdater
	if kccfeatureflags.UseDirectReconciler(gvk.GroupKind()) {
		groupKind := gvk.GroupKind()

		model, err := registry.GetModel(groupKind)
		if err != nil {
			return nil, err
		}

		if err := directbase.AddController(r.mgr, gvk, model, directbase.Deps{JitterGenerator: r.jitterGenerator}); err != nil {
			return nil, fmt.Errorf("error adding direct controller for %v to a manager: %w", crd.Spec.Names.Kind, err)
		}
		return schemaUpdater, nil
	}

	// Depending on which resource it is, we need to register a different controller.
	switch gvk.Kind {
	case "IAMPolicy":
		if err := policy.Add(r.mgr, &cds); err != nil {
			return nil, err
		}
	case "IAMPartialPolicy":
		if err := partialpolicy.Add(r.mgr, &cds); err != nil {
			return nil, err
		}
	case "IAMPolicyMember":
		if err := policymember.Add(r.mgr, &cds); err != nil {
			return nil, err
		}
	case "IAMAuditConfig":
		if err := auditconfig.Add(r.mgr, &cds); err != nil {
			return nil, err
		}

	default:
		// register the controller to automatically create secrets for GSA keys
		if isServiceAccountKeyCRD(crd) {
			logger.Info("registering the GSA-Key-to-Secret generation controller")
			if err := gsakeysecretgenerator.Add(r.mgr, crd, &controller.Deps{JitterGen: r.jitterGenerator}); err != nil {
				return nil, fmt.Errorf("error adding the gsa-to-secret generator for %v to a manager: %w", crd.Spec.Names.Kind, err)
			}
		}

		hasDirectController := registry.IsDirectByGK(gvk.GroupKind())
		hasTerraformController := crd.Labels[crdgeneration.TF2CRDLabel] == "true"
		hasDCLController := crd.Labels[k8s.DCL2CRDLabel] == "true"

		var useDirectReconcilerPredicate predicate.Predicate
		var useLegacyPredicate predicate.Predicate

		// If we have a choice of controllers, construct predicates to choose between them
		if hasDirectController && (hasTerraformController || hasDCLController) {
			if reconcileGate := registry.GetReconcileGate(gvk.GroupKind()); reconcileGate != nil {
				// If reconcile gate is enabled for this gvk, generate a controller-runtime predicate that will
				// run the direct reconciler only when the reconcile gate returns true.
				useDirectReconcilerPredicate = kccpredicate.NewReconcilePredicate(r.mgr.GetClient(), gvk, reconcileGate)
				useLegacyPredicate = kccpredicate.NewInverseReconcilePredicate(r.mgr.GetClient(), gvk, reconcileGate)
			} else {
				logger.Error(fmt.Errorf("no predicate where we have multiple controllers"), "skipping direct controller registration", "group", gvk.Group, "version", gvk.Version, "kind", gvk.Kind)
				hasDirectController = false
			}
		}

		// register controllers for direct CRDs
		if hasDirectController {
			model, err := registry.GetModel(gvk.GroupKind())
			if err != nil {
				return nil, err
			}
			deps := directbase.Deps{
				JitterGenerator:    r.jitterGenerator,
				ReconcilePredicate: useDirectReconcilerPredicate,
			}
			if err := directbase.AddController(r.mgr, gvk, model, deps); err != nil {
				return nil, fmt.Errorf("error adding direct controller for %v to a manager: %w", crd.Spec.Names.Kind, err)
			}
		}
		// register controllers for dcl-based CRDs
		if hasDCLController {
			su, err := dclcontroller.Add(r.mgr, crd, r.dclConverter, r.dclConfig, r.smLoader, r.defaulters, r.jitterGenerator, useLegacyPredicate)
			if err != nil {
				return nil, fmt.Errorf("error adding dcl controller for %v to a manager: %w", crd.Spec.Names.Kind, err)
			}
			return su, nil
		}
		// register controllers for tf-based CRDs
		if hasTerraformController {
			su, err := tf.Add(r.mgr, crd, r.provider, r.smLoader, r.defaulters, r.jitterGenerator, useLegacyPredicate)
			if err != nil {
				return nil, fmt.Errorf("error adding terraform controller for %v to a manager: %w", crd.Spec.Names.Kind, err)
			}
			return su, nil
		}

		if !hasDCLController && !hasTerraformController && !hasDirectController {
			logger.Error(fmt.Errorf("unrecognized CRD: %v", crd.Spec.Names.Kind), "skipping controller registration", "group", gvk.Group, "version", gvk.Version, "kind", gvk.Kind)
			return nil, nil
		}

	}
	return schemaUpdater, nil
}