func run()

in cmd/gcp-controller-manager/main.go [191:271]
73 lines of code
9 McCabe index (conditional complexity)

func run(s *controllerManager) error {
	ctx := context.Background()

	informerClientBuilder := clientbuilder.SimpleControllerClientBuilder{ClientConfig: s.informerKubeconfig}
	informerClient := informerClientBuilder.ClientOrDie("gcp-controller-manager-shared-informer")
	sharedInformers := informers.NewSharedInformerFactory(informerClient, time.Duration(12)*time.Hour)
	s.healthz.Checks["shared informers"] = informersCheck(sharedInformers)

	controllerClientBuilder := clientbuilder.SimpleControllerClientBuilder{ClientConfig: s.controllerKubeconfig}

	eventBroadcaster := record.NewBroadcaster()
	eventBroadcaster.StartLogging(klog.Infof)
	eventBroadcaster.StartRecordingToSink(&v1core.EventSinkImpl{
		Interface: v1core.New(controllerClientBuilder.ClientOrDie("gcp-controller-manager").CoreV1().RESTClient()).Events(""),
	})

	verifiedSAs := newSAMap()

	startControllers := func(ctx context.Context) {
		for name, loop := range loops() {
			if !s.isEnabled(name) {
				continue
			}
			name = "gcp-" + name
			loopClient, err := controllerClientBuilder.Client(name)
			if err != nil {
				klog.Fatalf("failed to start client for %q: %v", name, err)
			}
			if err := loop(&controllerContext{
				client:          loopClient,
				sharedInformers: sharedInformers,
				recorder: eventBroadcaster.NewRecorder(legacyscheme.Scheme, v1.EventSource{
					Component: name,
				}),
				gcpCfg:                             s.gcpConfig,
				clusterSigningGKEKubeconfig:        s.clusterSigningGKEKubeconfig,
				csrApproverVerifyClusterMembership: s.csrApproverVerifyClusterMembership,
				csrApproverAllowLegacyKubelet:      s.csrApproverAllowLegacyKubelet,
				verifiedSAs:                        verifiedSAs,
				done:                               ctx.Done(),
				hmsAuthorizeSAMappingURL:           s.hmsAuthorizeSAMappingURL,
				hmsSyncNodeURL:                     s.hmsSyncNodeURL,
				delayDirectPathGSARemove:           s.delayDirectPathGSARemove,
			}); err != nil {
				klog.Fatalf("Failed to start %q: %v", name, err)
			}
		}
		sharedInformers.Start(ctx.Done())
		<-ctx.Done()
	}

	if s.leaderElectionConfig.LeaderElect {
		leaderElectionClient, err := clientset.NewForConfig(restclient.AddUserAgent(s.informerKubeconfig, "leader-election"))
		if err != nil {
			return err
		}
		leaderElectionConfig, err := makeLeaderElectionConfig(s.leaderElectionConfig, leaderElectionClient, eventBroadcaster.NewRecorder(legacyscheme.Scheme, v1.EventSource{
			Component: "gcp-controller-manager-leader-election",
		}))
		if err != nil {
			return err
		}
		leaderElectionConfig.Callbacks = leaderelection.LeaderCallbacks{
			OnStartedLeading: startControllers,
			OnStoppedLeading: func() {
				klog.Fatalf("lost leader election, exiting")
			},
		}

		leaderElector, err := leaderelection.NewLeaderElector(*leaderElectionConfig)
		if err != nil {
			return err
		}
		s.healthz.Checks["leader election"] = leaderElectorCheck(leaderElector)
		leaderElector.Run(ctx)
		return fmt.Errorf("should never reach this point")
	}

	startControllers(ctx)
	return fmt.Errorf("should never reach this point")
}