func main()

in cmd/webhook/main.go [71:167]
72 lines of code
8 McCabe index (conditional complexity)

func main() {
	klog.InitFlags(nil)
	flag.Parse()

	// Thanks to the PR https://github.com/solo-io/gloo/pull/8549
	// This line prevents controller-runtime from complaining about log.SetLogger never being called
	log.SetLogger(logr.New(log.NullLogSink{}))

	klog.Infof("Running Google Cloud Storage FUSE CSI driver admission webhook version %v, sidecar container image %v", webhookVersion, *sidecarImage)

	// Load webhook config
	fuseSideCarConfig := wh.LoadConfig(*sidecarImage, *imagePullPolicy, *cpuRequest, *cpuLimit, *memoryRequest, *memoryLimit, *ephemeralStorageRequest, *ephemeralStorageLimit)
	fuseSideCarConfig.ShouldInjectSAVolume = *injectSAVol
	klog.Infof("Webhook should inject SA volume: %t", fuseSideCarConfig.ShouldInjectSAVolume)

	metadataPrefetchSideCarConfig := wh.LoadConfig(*metadataSidecarImage, *imagePullPolicy, *metadataPrefetchCPURequest, *metadataPrefetchCPULimit, *metadataMemoryRequest, *metadataMemoryLimit, *metadataPrefetchEphemeralStorageRequest, *metadataPrefetchEphemeralStorageLimit)

	// Load config for manager, informers, listers
	kubeConfig := config.GetConfigOrDie()

	// Setup client
	coreKubeConfig := rest.CopyConfig(kubeConfig)
	coreKubeConfig.ContentType = runtime.ContentTypeProtobuf
	client, err := kubernetes.NewForConfig(coreKubeConfig)
	if err != nil {
		klog.Warningf("Unable to get clientset: %v", err)
	}

	var serverVersion *version.Version
	// Get and format sever version.
	v, err := client.DiscoveryClient.ServerVersion()
	if err != nil || v == nil {
		klog.Warningf("Unable to get server version : %v", err)
	} else {
		serverVersion, err = version.ParseGeneric(v.String())
		if err != nil {
			klog.Warningf(`Unable to parse server version "%s": %v`, v.String(), err)
		}
	}

	// Setup stop channel
	context := signals.SetupSignalHandler()

	// Setup Informer
	informerFactory := informers.NewSharedInformerFactory(client, resyncDuration)
	nodeLister := informerFactory.Core().V1().Nodes().Lister()
	pvcLister := informerFactory.Core().V1().PersistentVolumeClaims().Lister()
	pvLister := informerFactory.Core().V1().PersistentVolumes().Lister()

	informerFactory.Start(context.Done())
	informerFactory.WaitForCacheSync(context.Done())

	// Setup a Manager
	klog.Info("Setting up manager.")
	mgr, err := manager.New(kubeConfig, manager.Options{
		HealthProbeBindAddress: *healthProbeBindAddress,
		ReadinessEndpointName:  "/readyz",
		WebhookServer: webhook.NewServer(webhook.Options{
			Port:     *port,
			CertDir:  *certDir,
			CertName: *certName,
			KeyName:  *keyName,
		}),
	})
	if err != nil {
		klog.Fatalf("Unable to set up overall controller manager: %v", err)
	}

	if err = mgr.AddReadyzCheck("readyz", func(_ *http.Request) error {
		return nil
	}); err != nil {
		klog.Errorf("Unable to set up readyz endpoint: %v", err)
	}

	// Setup Webhooks
	klog.Info("Setting up webhook server.")
	hookServer := mgr.GetWebhookServer()

	klog.Info("Registering webhooks to the webhook server.")
	hookServer.Register("/inject", &webhook.Admission{
		Handler: &wh.SidecarInjector{
			Client:                 mgr.GetClient(),
			Config:                 fuseSideCarConfig,
			MetadataPrefetchConfig: metadataPrefetchSideCarConfig,
			Decoder:                admission.NewDecoder(runtime.NewScheme()),
			NodeLister:             nodeLister,
			PvLister:               pvLister,
			PvcLister:              pvcLister,
			ServerVersion:          serverVersion,
		},
	})

	klog.Info("Starting manager.")
	if err := mgr.Start(context); err != nil {
		klog.Fatalf("Unable to run manager: %v", err)
	}
}