func main()

in cmd/hub-net-controller-manager/main.go [90:243]
132 lines of code
19 McCabe index (conditional complexity)

func main() {
	flag.Parse()
	rand.Seed(time.Now().UnixNano())

	handleExitFunc := func() {
		klog.Flush()
	}

	exitWithErrorFunc := func() {
		handleExitFunc()
		os.Exit(1)
	}

	defer handleExitFunc()

	flag.VisitAll(func(f *flag.Flag) {
		klog.InfoS("flag:", "name", f.Name, "value", f.Value)
	})

	// Set up controller-runtime logger
	ctrl.SetLogger(zap.New(zap.UseDevMode(true)))

	hubConfig := ctrl.GetConfigOrDie()
	mgr, err := ctrl.NewManager(hubConfig, ctrl.Options{
		Scheme: scheme,
		Metrics: metricsserver.Options{
			BindAddress: *metricsAddr,
		},
		WebhookServer: webhook.NewServer(webhook.Options{
			Port: 9443,
		}),
		HealthProbeBindAddress:  *probeAddr,
		LeaderElection:          *enableLeaderElection,
		LeaderElectionNamespace: *leaderElectionNamespace,
		LeaderElectionID:        "2bf2b407.hub.networking.fleet.azure.com",
	})
	if err != nil {
		klog.ErrorS(err, "Unable to start manager")
		exitWithErrorFunc()
	}

	//+kubebuilder:scaffold:builder

	if err := mgr.AddHealthzCheck("healthz", healthz.Ping); err != nil {
		klog.ErrorS(err, "Unable to set up health check")
		exitWithErrorFunc()
	}
	if err := mgr.AddReadyzCheck("readyz", healthz.Ping); err != nil {
		klog.ErrorS(err, "Unable to set up ready check")
		exitWithErrorFunc()
	}

	ctx := ctrl.SetupSignalHandler()

	klog.V(1).InfoS("Start to setup EndpointsliceExport controller")
	if err := (&endpointsliceexport.Reconciler{
		HubClient: mgr.GetClient(),
	}).SetupWithManager(ctx, mgr); err != nil {
		klog.ErrorS(err, "Unable to create EndpointsliceExport controller")
		exitWithErrorFunc()
	}

	klog.V(1).InfoS("Start to setup InternalServiceExport controller")
	if err := (&internalserviceexport.Reconciler{
		Client:        mgr.GetClient(),
		RetryInternal: *internalServiceExportRetryInterval,
	}).SetupWithManager(mgr); err != nil {
		klog.ErrorS(err, "Unable to create InternalServiceExport controller")
		exitWithErrorFunc()
	}

	klog.V(1).InfoS("Start to setup InternalServiceImport controller")
	if err := (&internalserviceimport.Reconciler{
		HubClient: mgr.GetClient(),
	}).SetupWithManager(ctx, mgr); err != nil {
		klog.ErrorS(err, "Unable to create InternalServiceImport controller")
		exitWithErrorFunc()
	}

	klog.V(1).InfoS("Start to setup ServiceImport controller")
	if err := (&serviceimport.Reconciler{
		Client:   mgr.GetClient(),
		Recorder: mgr.GetEventRecorderFor(serviceimport.ControllerName),
	}).SetupWithManager(ctx, mgr); err != nil {
		klog.ErrorS(err, "Unable to create ServiceImport controller")
		exitWithErrorFunc()
	}

	discoverClient := discovery.NewDiscoveryClientForConfigOrDie(hubConfig)
	if *enableV1Beta1APIs {
		gvk := clusterv1beta1.GroupVersion.WithKind(clusterv1beta1.MemberClusterKind)
		if utils.CheckCRDInstalled(discoverClient, gvk) == nil {
			klog.V(1).InfoS("Start to setup MemberCluster controller")
			if err := (&membercluster.Reconciler{
				Client:              mgr.GetClient(),
				Recorder:            mgr.GetEventRecorderFor(membercluster.ControllerName),
				ForceDeleteWaitTime: *forceDeleteWaitTime,
			}).SetupWithManager(mgr); err != nil {
				klog.ErrorS(err, "Unable to create MemberCluster controller")
				exitWithErrorFunc()
			}
		}
	}
	if *enableTrafficManagerFeature {
		klog.V(1).InfoS("Traffic manager feature is enabled, checking the required CRDs")
		for _, gvk := range trafficManagerFeatureRequiredGVKs {
			if err = utils.CheckCRDInstalled(discoverClient, gvk); err != nil {
				klog.ErrorS(err, "Unable to find the required CRD", "GVK", gvk)
				exitWithErrorFunc()
			}
		}

		klog.V(1).InfoS("Traffic manager feature is enabled, loading cloud config and creating azure clients", "cloudConfigFile", *cloudConfigFile)
		cloudConfig, err := azure.NewCloudConfigFromFile(*cloudConfigFile)
		if err != nil {
			klog.ErrorS(err, "Unable to load cloud config", "file name", *cloudConfigFile)
			exitWithErrorFunc()
		}
		cloudConfig.SetUserAgent("fleet-hub-net-controller-manager")
		klog.V(1).InfoS("Cloud config loaded", "cloudConfig", cloudConfig)

		profilesClient, endpointsClient, err := initAzureTrafficManagerClients(cloudConfig)
		if err != nil {
			klog.ErrorS(err, "Unable to create Azure Traffic Manager clients")
			exitWithErrorFunc()
		}
		klog.V(1).InfoS("Start to setup TrafficManagerProfile controller")
		if err := (&trafficmanagerprofile.Reconciler{
			Client:         mgr.GetClient(),
			ProfilesClient: profilesClient,
		}).SetupWithManager(mgr); err != nil {
			klog.ErrorS(err, "Unable to create TrafficManagerProfile controller")
			exitWithErrorFunc()
		}

		klog.V(1).InfoS("Start to setup TrafficManagerBackend controller")
		if err := (&trafficmanagerbackend.Reconciler{
			Client:          mgr.GetClient(),
			ProfilesClient:  profilesClient,
			EndpointsClient: endpointsClient,
			// serviceImport controller has already enabled the internalServiceExportIndexer.
			// Therefore, no need to setup it again.
		}).SetupWithManager(ctx, mgr, true); err != nil {
			klog.ErrorS(err, "Unable to create TrafficManagerProfile controller")
			exitWithErrorFunc()
		}
	}

	klog.V(1).InfoS("Starting ServiceExportImport controller manager")
	if err := mgr.Start(ctx); err != nil {
		klog.ErrorS(err, "Problem running manager")
		exitWithErrorFunc()
	}
}