func main()

in main.go [59:136]
68 lines of code
7 McCabe index (conditional complexity)

func main() {
	klog.InitFlags(nil)
	flags.Register()

	klog.Infof("managed-certificate-controller %s starting. Latest commit hash: %s",
		version.Version, version.GitCommit)
	for i, a := range os.Args {
		klog.Infof("argv[%d]: %q", i, a)
	}
	klog.Infof("Flags = %+v", flags.F)

	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	config, err := config.New(ctx, flags.F.GCEConfigFilePath, flags.F.ServiceAccount)
	if err != nil {
		klog.Fatal(err)
	}

	clients, err := clients.New(ctx, config)
	if err != nil {
		klog.Fatal(err)
	}

	healthCheck := liveness.NewHealthCheck(flags.F.HealthCheckInterval,
		2*flags.F.ResyncInterval, 2*flags.F.ResyncInterval)
	klog.Infof("Start serving liveness probe")
	healthCheck.StartServing(flags.F.HealthCheckAddress, flags.F.HealthCheckPath)

	leaderElection := componentbaseconfig.LeaderElectionConfiguration{
		LeaderElect:   true,
		LeaseDuration: metav1.Duration{Duration: config.MasterElection.LeaseDuration},
		RenewDeadline: metav1.Duration{Duration: config.MasterElection.RenewDeadline},
		RetryPeriod:   metav1.Duration{Duration: config.MasterElection.RetryPeriod},
		ResourceLock:  resourcelock.LeasesResourceLock,
	}
	id, err := os.Hostname()
	if err != nil {
		klog.Fatalf("Unable to get hostname: %v", err)
	}
	lock, err := resourcelock.New(
		leaderElection.ResourceLock,
		"kube-system",
		"managed-certificate-controller",
		clients.Core,
		clients.Coordination,
		resourcelock.ResourceLockConfig{Identity: id},
	)
	if err != nil {
		klog.Fatalf("Unable to create leader election lock: %v", err)
	}

	leaderelection.RunOrDie(ctx, leaderelection.LeaderElectionConfig{
		Lock:          lock,
		LeaseDuration: leaderElection.LeaseDuration.Duration,
		RenewDeadline: leaderElection.RenewDeadline.Duration,
		RetryPeriod:   leaderElection.RetryPeriod.Duration,
		Callbacks: leaderelection.LeaderCallbacks{
			OnStartedLeading: func(ctx context.Context) {
				params := controller.NewParams(ctx, clients, config, healthCheck)
				controller := controller.New(ctx, params)

				go func() {
					<-setupSignalHandler()
					cancel()
				}()

				if err = controller.Run(ctx); err != nil {
					klog.Fatalf("Error running controller: %s", err)
				}
			},
			OnStoppedLeading: func() {
				// Cancel ctx, shut down and wait for being restarted by kubelet.
				cancel()
			},
		},
	})
}