func main()

in oracle/main.go [72:254]
162 lines of code
16 McCabe index (conditional complexity)

func main() {
	klog.InitFlags(nil)

	var metricsAddr string
	var enableLeaderElection bool
	flag.StringVar(&metricsAddr, "metrics-addr", ":8080", "The address the metric endpoint binds to.")
	flag.BoolVar(&enableLeaderElection, "enable-leader-election", false,
		"Enable leader election for controller manager. Enabling this will ensure there is only one active controller manager.")
	flag.Parse()

	ctrl.SetLogger(klogr.New())

	images := make(map[string]string)
	images["dbinit"] = *dbInitImage
	images["service"] = *serviceImage
	images["logging_sidecar"] = *loggingSidecarImage
	images["monitoring"] = *monitoringAgentImage

	mgr, err := ctrl.NewManager(ctrl.GetConfigOrDie(), ctrl.Options{
		Scheme:             scheme,
		MetricsBindAddress: metricsAddr,
		LeaderElection:     enableLeaderElection,
		LeaderElectionID:   "controller-leader-election-helper",
		Port:               9443,
		Namespace:          *namespace,
	})
	if err != nil {
		setupLog.Error(err, "unable to start manager")
		os.Exit(1)
	}

	var locker = sync.Map{}

	if err = (&instancecontroller.InstanceReconciler{
		Client:        mgr.GetClient(),
		Log:           ctrl.Log.WithName("controllers").WithName("Instance"),
		SchemeVal:     mgr.GetScheme(),
		Images:        images,
		Recorder:      mgr.GetEventRecorderFor("instance-controller"),
		InstanceLocks: &locker,

		DatabaseClientFactory: &controllers.GRPCDatabaseClientFactory{},
	}).SetupWithManager(mgr); err != nil {
		setupLog.Error(err, "unable to create controller", "controller", "Instance")
		os.Exit(1)
	}
	if err = (&databasecontroller.DatabaseReconciler{
		Client:                mgr.GetClient(),
		Log:                   ctrl.Log.WithName("controllers").WithName("Database"),
		Scheme:                mgr.GetScheme(),
		Recorder:              mgr.GetEventRecorderFor("database-controller"),
		InstanceLocks:         &locker,
		DatabaseClientFactory: &controllers.GRPCDatabaseClientFactory{},
	}).SetupWithManager(mgr); err != nil {
		setupLog.Error(err, "unable to create controller", "controller", "Database")
		os.Exit(1)
	}
	if err = (&backupcontroller.BackupReconciler{
		Client:              mgr.GetClient(),
		Log:                 ctrl.Log.WithName("controllers").WithName("Backup"),
		Scheme:              mgr.GetScheme(),
		Recorder:            mgr.GetEventRecorderFor("backup-controller"),
		InstanceLocks:       &locker,
		OracleBackupFactory: &backupcontroller.RealOracleBackupFactory{},
		BackupCtrl:          &backupcontroller.RealBackupControl{Client: mgr.GetClient()},

		DatabaseClientFactory: &controllers.GRPCDatabaseClientFactory{},
	}).SetupWithManager(mgr); err != nil {
		setupLog.Error(err, "unable to create controller", "controller", "Backup")
		os.Exit(1)
	}
	if err = (&exportcontroller.ExportReconciler{
		Client:        mgr.GetClient(),
		Log:           ctrl.Log.WithName("controllers").WithName("Export"),
		Scheme:        mgr.GetScheme(),
		Recorder:      mgr.GetEventRecorderFor("export-controller"),
		InstanceLocks: &locker,

		DatabaseClientFactory: &controllers.GRPCDatabaseClientFactory{},
	}).SetupWithManager(mgr); err != nil {
		setupLog.Error(err, "unable to create controller", "controller", "Export")
		os.Exit(1)
	}
	if err = (&importcontroller.ImportReconciler{
		Client:        mgr.GetClient(),
		Log:           ctrl.Log.WithName("controllers").WithName("Import"),
		Scheme:        mgr.GetScheme(),
		Recorder:      mgr.GetEventRecorderFor("import-controller"),
		InstanceLocks: &locker,

		DatabaseClientFactory: &controllers.GRPCDatabaseClientFactory{},
	}).SetupWithManager(mgr); err != nil {
		setupLog.Error(err, "unable to create controller", "controller", "Import")
		os.Exit(1)
	}
	if err = (&pitrcontroller.PITRReconciler{
		Client: mgr.GetClient(),
		Log:    ctrl.Log.WithName("controllers").WithName("PITR"),
		Scheme: mgr.GetScheme(),
		BackupCtrl: &pitrcontroller.RealBackupControl{
			Client: mgr.GetClient(),
		},
		PITRCtrl: &pitrcontroller.RealPITRControl{
			Client: mgr.GetClient(),
		},
	}).SetupWithManager(mgr); err != nil {
		setupLog.Error(err, "unable to create controller", "controller", "PITR")
		os.Exit(1)
	}

	if err = backupschedulecontroller.NewBackupScheduleReconciler(
		mgr,
		&backupschedulecontroller.RealBackupScheduleControl{
			Client: mgr.GetClient(),
		},
		&cronanythingcontroller.RealCronAnythingControl{
			Client: mgr.GetClient(),
		},
		&backupschedulecontroller.RealBackupControl{
			Client: mgr.GetClient(),
		}).SetupWithManager(mgr); err != nil {
		setupLog.Error(err, "unable to create controller", "controller", "BackupSchedule")
		os.Exit(1)
	}

	cronAnythingReconciler, err := cronanythingcontroller.NewCronAnythingReconciler(
		mgr,
		ctrl.Log.WithName("controllers").WithName("CronAnything"),
		&cronanythingcontroller.RealCronAnythingControl{
			Client: mgr.GetClient(),
		},
		&locker,
	)
	if err != nil {
		setupLog.Error(err, "unable to init reconciler", "reconciler", "CronAnything")
		os.Exit(1)
	}

	if err = cronAnythingReconciler.SetupWithManager(mgr); err != nil {
		setupLog.Error(err, "unable to create controller", "controller", "CronAnything")
		os.Exit(1)
	}
	// +kubebuilder:scaffold:builder

	// Use the testing namespace if supplied, otherwise deploy to the same namespace as the operator.
	operatorNS := "operator-system"
	if *namespace != "" {
		operatorNS = *namespace
	}

	c := mgr.GetClient()

	ctx := context.Background()
	release := &v1alpha1.Release{
		TypeMeta: metav1.TypeMeta{
			APIVersion: "oracle.db.anthosapis.com/v1alpha1",
			Kind:       "Release",
		},
		ObjectMeta: metav1.ObjectMeta{
			Name:      "release",
			Namespace: operatorNS,
		},
		Spec: v1alpha1.ReleaseSpec{
			Version: version,
		},
	}

	err = c.Create(ctx, release)

	if apierrors.IsAlreadyExists(err) {
		if err := c.Patch(ctx, release, client.Apply, client.ForceOwnership, client.FieldOwner("release-controller")); err != nil {
			setupLog.Error(err, "failed to patch release CRD")
		}
	} else if err != nil {
		setupLog.Error(err, "failed to install release CRD")
	}

	setupLog.Info("starting manager")
	if err := mgr.Start(ctrl.SetupSignalHandler()); err != nil {
		setupLog.Error(err, "problem running manager")
		os.Exit(1)
	}
}