func newMgr()

in internal/manager/manager.go [70:183]
99 lines of code
15 McCabe index (conditional complexity)

func newMgr(logger logr.Logger, opts *Options, isController, isReconciler bool) (ctrl.Manager, error) {
	opts.Rest.QPS = float32(opts.qps)

	scheme := runtime.NewScheme()
	err := apiv1.SchemeBuilder.AddToScheme(scheme)
	if err != nil {
		return nil, err
	}
	err = corev1.SchemeBuilder.AddToScheme(scheme)
	if err != nil {
		return nil, err
	}

	mgrOpts := manager.Options{
		Logger:                 logger,
		HealthProbeBindAddress: opts.HealthProbeAddr,
		Scheme:                 scheme,
		Metrics: server.Options{
			BindAddress: opts.MetricsAddr,
		},
		BaseContext: func() context.Context {
			return logr.NewContext(context.Background(), logger)
		},
		Cache: cache.Options{
			ByObject: make(map[client.Object]cache.ByObject),
		},
		LeaderElection:                opts.LeaderElection,
		LeaderElectionNamespace:       opts.LeaderElectionNamespace,
		LeaderElectionResourceLock:    opts.LeaderElectionResourceLock,
		LeaderElectionID:              opts.LeaderElectionID,
		LeaseDuration:                 &opts.ElectionLeaseDuration,
		RenewDeadline:                 &opts.ElectionLeaseRenewDeadline,
		RetryPeriod:                   &opts.ElectionLeaseRetryPeriod,
		LeaderElectionReleaseOnCancel: true,
		Controller:                    config.Controller{SkipNameValidation: ptr.To(true)},
	}

	if ratioStr := os.Getenv("CHAOS_RATIO"); ratioStr != "" {
		mgrOpts.NewClient = func(config *rest.Config, options client.Options) (client.Client, error) {
			base, err := client.New(config, options)
			if err != nil {
				return nil, err
			}

			ratio, err := strconv.ParseFloat(ratioStr, 64)
			if err != nil {
				return nil, err
			}

			return &chaosClient{Client: base, ratio: ratio}, nil
		}
	}

	if isController {
		// Only cache pods in the synthesizer pod namespace and owned by this controller
		mgrOpts.Cache.ByObject[&corev1.Pod{}] = cache.ByObject{
			Namespaces: map[string]cache.Config{
				opts.SynthesizerPodNamespace: {
					LabelSelector: labels.SelectorFromSet(labels.Set{ManagerLabelKey: ManagerLabelValue}),
				},
			},
		}
	}

	mgrOpts.Cache.ByObject[&apiv1.Composition{}] = newCacheOptions(opts.CompositionNamespace, opts.CompositionSelector)

	sliceCacheOpts := newCacheOptions(opts.CompositionNamespace, labels.Everything())
	sliceCacheOpts.UnsafeDisableDeepCopy = ptr.To(true)
	sliceCacheOpts.Transform = func(obj any) (any, error) {
		slice, ok := obj.(*apiv1.ResourceSlice)
		if !ok {
			return obj, nil
		}
		for i := range slice.Spec.Resources {
			slice.Spec.Resources[i].Manifest = "" // remove big manifest that we don't need
		}
		return slice, nil
	}
	mgrOpts.Cache.ByObject[&apiv1.ResourceSlice{}] = sliceCacheOpts

	mgr, err := ctrl.NewManager(opts.Rest, mgrOpts)
	if err != nil {
		return nil, err
	}

	if isController {
		err = mgr.GetFieldIndexer().IndexField(context.Background(), &apiv1.Composition{}, IdxCompositionsBySynthesizer, func(o client.Object) []string {
			comp := o.(*apiv1.Composition)
			return []string{comp.Spec.Synthesizer.Name}
		})
		if err != nil {
			return nil, err
		}

		err = mgr.GetFieldIndexer().IndexField(context.Background(), &apiv1.Composition{}, IdxCompositionsBySymphony, indexController())
		if err != nil {
			return nil, err
		}

		err = mgr.GetFieldIndexer().IndexField(context.Background(), &apiv1.Composition{}, IdxCompositionsByBinding, indexResourceBindings())
		if err != nil {
			return nil, err
		}

		err = mgr.GetFieldIndexer().IndexField(context.Background(), &apiv1.Synthesizer{}, IdxSynthesizersByRef, indexSynthRefs())
		if err != nil {
			return nil, err
		}
	}

	mgr.AddHealthzCheck("ping", healthz.Ping)
	mgr.AddReadyzCheck("ping", healthz.Ping)
	return mgr, nil
}