func main()

in cmd/aws-application-networking-k8s/main.go [142:303]
134 lines of code
21 McCabe index (conditional complexity)

func main() {
	var metricsAddr string
	var enableLeaderElection bool
	var probeAddr string

	flag.StringVar(&metricsAddr, "metrics-bind-address", ":8080", "The address the metric endpoint binds to.")
	flag.StringVar(&probeAddr, "health-probe-bind-address", ":8081", "The address the probe endpoint binds to.")
	flag.BoolVar(&enableLeaderElection, "leader-elect", false,
		"Enable leader election for controller manager. "+
			"Enabling this will ensure there is only one active controller manager.")
	flag.Parse()

	logLevel := logLevel()
	log := gwlog.NewLogger(logLevel)
	ctrl.SetLogger(zapr.NewLogger(log.InnerLogger.Desugar()).WithName("runtime"))

	setupLog := log.InnerLogger.Named("setup")

	err := config.ConfigInit()
	if err != nil {
		setupLog.Fatalf("init config failed: %s", err)
	}
	setupLog.Infow("init config",
		"VpcId", config.VpcID,
		"Region", config.Region,
		"AccountId", config.AccountID,
		"DefaultServiceNetwork", config.DefaultServiceNetwork,
		"ClusterName", config.ClusterName,
		"LogLevel", logLevel,
		"DisableTaggingServiceAPI", config.DisableTaggingServiceAPI,
	)

	cloud, err := aws.NewCloud(log.Named("cloud"), aws.CloudConfig{
		VpcId:                     config.VpcID,
		AccountId:                 config.AccountID,
		Region:                    config.Region,
		ClusterName:               config.ClusterName,
		TaggingServiceAPIDisabled: config.DisableTaggingServiceAPI,
	}, metrics.Registry)
	if err != nil {
		setupLog.Fatal("cloud client setup failed: %s", err)
	}

	// do not create the webhook server when running locally
	var webhookServer k8swebhook.Server
	enableWebhook := strings.ToLower(config.WebhookEnabled) == "true"
	if enableWebhook {
		setupLog.Info("Webhook is enabled, 'webhook-cert' secret must contain a valid TLS key and cert")
		webhookServer = k8swebhook.NewServer(k8swebhook.Options{
			Port:     9443,
			CertDir:  "/etc/webhook-cert/",
			CertName: "tls.crt",
			KeyName:  "tls.key",
		})
	} else {
		setupLog.Infof("Webhook is disabled, value: '%s'", config.WebhookEnabled)
	}

	mgr, err := ctrl.NewManager(ctrl.GetConfigOrDie(), ctrl.Options{
		Scheme: scheme,
		Metrics: metricsserver.Options{
			BindAddress: metricsAddr,
		},
		WebhookServer:          webhookServer,
		HealthProbeBindAddress: probeAddr,
		LeaderElection:         enableLeaderElection,
		LeaderElectionID:       "amazon-vpc-lattice.io",
	})
	if err != nil {
		setupLog.Fatal("manager setup failed:", err)
	}

	if err := checkRequiredCRDs(mgr); err != nil {
		setupLog.Fatal("required CRDs check failed:", err)
	}

	if enableWebhook {
		logger := log.Named("pod-readiness-gate-injector")
		readinessGateInjector := webhook.NewPodReadinessGateInjector(
			mgr.GetClient(),
			logger,
		)
		webhook.NewPodMutator(logger, scheme, readinessGateInjector).SetupWithManager(logger, mgr)
	}

	finalizerManager := k8s.NewDefaultFinalizerManager(mgr.GetClient())

	// parent logging scope for all controllers
	ctrlLog := log.Named("controller")

	err = controllers.RegisterPodController(ctrlLog.Named("pod"), mgr)
	if err != nil {
		setupLog.Fatalf("pod controller setup failed: %s", err)
	}

	err = controllers.RegisterServiceController(ctrlLog.Named("service"), cloud, finalizerManager, mgr)
	if err != nil {
		setupLog.Fatalf("service controller setup failed: %s", err)
	}

	err = controllers.RegisterGatewayClassController(ctrlLog.Named("gateway-class"), mgr)
	if err != nil {
		setupLog.Fatalf("gateway-class controller setup failed: %s", err)
	}

	err = controllers.RegisterGatewayController(ctrlLog.Named("gateway"), cloud, finalizerManager, mgr)
	if err != nil {
		setupLog.Fatalf("gateway controller setup failed: %s", err)
	}

	err = controllers.RegisterAllRouteControllers(ctrlLog.Named("route"), cloud, finalizerManager, mgr)
	if err != nil {
		setupLog.Fatalf("route controller setup failed: %s", err)
	}

	err = controllers.RegisterServiceImportController(ctrlLog.Named("service-import"), mgr, finalizerManager)
	if err != nil {
		setupLog.Fatalf("serviceimport controller setup failed: %s", err)
	}

	err = controllers.RegisterServiceExportController(ctrlLog.Named("service-export"), cloud, finalizerManager, mgr)
	if err != nil {
		setupLog.Fatalf("serviceexport controller setup failed: %s", err)
	}

	err = controllers.RegisterAccessLogPolicyController(ctrlLog.Named("access-log-policy"), cloud, finalizerManager, mgr)
	if err != nil {
		setupLog.Fatalf("accesslogpolicy controller setup failed: %s", err)
	}

	err = controllers.RegisterIAMAuthPolicyController(ctrlLog.Named("iam-auth-policy"), mgr, cloud)
	if err != nil {
		setupLog.Fatalf("iam auth policy controller setup failed: %s", err)
	}

	err = controllers.RegisterTargetGroupPolicyController(ctrlLog.Named("target-group-policy"), mgr)
	if err != nil {
		setupLog.Fatalf("target group policy controller setup failed: %s", err)
	}

	err = controllers.RegisterVpcAssociationPolicyController(ctrlLog.Named("vpc-association-policy"), cloud, finalizerManager, mgr)
	if err != nil {
		setupLog.Fatalf("vpc association policy controller setup failed: %s", err)
	}
	//+kubebuilder:scaffold:builder

	if err := mgr.AddHealthzCheck("healthz", healthz.Ping); err != nil {
		setupLog.Error(err, "unable to set up health check")
		os.Exit(1)
	}
	if err := mgr.AddReadyzCheck("readyz", healthz.Ping); err != nil {
		setupLog.Error(err, "unable to set up ready check")
		os.Exit(1)
	}

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

}