func main()

in cmd/vsphere-cloud-controller-manager/main.go [56:216]
131 lines of code
29 McCabe index (conditional complexity)

func main() {
	loadbalancer.Version = version
	loadbalancer.AppName = AppName

	rand.Seed(time.Now().UTC().UnixNano())

	ccmOptions, err := options.NewCloudControllerManagerOptions()
	if err != nil {
		klog.Fatalf("unable to initialize command options: %v", err)
	}

	var controllerInitializers map[string]app.InitFunc
	command := &cobra.Command{
		Use:  "vsphere-cloud-controller-manager",
		Long: `vsphere-cloud-controller-manager manages vSphere cloud resources for a Kubernetes cluster.`,
		Run: func(cmd *cobra.Command, args []string) {
			verflag.PrintAndExitIfRequested()
			cliflag.PrintFlags(cmd.Flags())

			c, err := ccmOptions.Config(app.ControllerNames(app.DefaultInitFuncConstructors), app.ControllersDisabledByDefault.List())
			if err != nil {
				// explicitly ignore the error by Fprintf, exiting anyway
				_, _ = fmt.Fprintf(os.Stderr, "%v\n", err)
				os.Exit(1)
			}

			klog.Infof("vsphere-cloud-controller-manager version: %s", version)

			// Default to the vsphere cloud provider if not set
			cloudProviderFlag := cmd.Flags().Lookup("cloud-provider")
			if cloudProviderFlag.Value.String() == "" {
				if err := cloudProviderFlag.Value.Set(vsphere.RegisteredProviderName); err != nil {
					klog.Fatalf("cannot set RegisteredProviderName to %s: %v", vsphere.RegisteredProviderName, err)
				}
			}

			cloudProvider := cloudProviderFlag.Value.String()
			if cloudProvider != vsphere.RegisteredProviderName && cloudProvider != vsphereparavirtual.RegisteredProviderName {
				klog.Fatalf("unknown cloud provider %s, only 'vsphere' and 'vsphere-paravirtual' are supported", cloudProvider)
			}

			completedConfig := c.Complete()

			cloud := initializeCloud(completedConfig, cloudProvider)
			controllerInitializers = app.ConstructControllerInitializers(app.DefaultInitFuncConstructors, completedConfig, cloud)

			// initialize a notifier for cloud config update
			cloudConfig := completedConfig.ComponentConfig.KubeCloudShared.CloudProvider.CloudConfigFile
			klog.Infof("initialize notifier on configmap update %s\n", cloudConfig)
			watch, stop, err := initializeWatch(completedConfig, cloudConfig)
			if err != nil {
				klog.Fatalf("fail to initialize watch on config map %s: %v\n", cloudConfig, err)
			}
			defer func(watch *fsnotify.Watcher) {
				_ = watch.Close() // ignore explicitly when the watch closes
			}(watch)

			if err := app.Run(completedConfig, cloud, controllerInitializers, stop); err != nil {
				// explicitly ignore the error by Fprintf, exiting anyway due to app error
				_, _ = fmt.Fprintf(os.Stderr, "%v\n", err)
				os.Exit(1)
			}
		},
		Args: func(cmd *cobra.Command, args []string) error {
			for _, arg := range args {
				if len(arg) > 0 {
					return fmt.Errorf("%q does not take any arguments, got %q", cmd.CommandPath(), args)
				}
			}
			return nil
		},
	}

	fs := command.Flags()
	namedFlagSets := ccmOptions.Flags(app.ControllerNames(app.DefaultInitFuncConstructors), app.ControllersDisabledByDefault.List())
	verflag.AddFlags(namedFlagSets.FlagSet("global"))
	globalflag.AddGlobalFlags(namedFlagSets.FlagSet("global"), command.Name())

	for _, f := range namedFlagSets.FlagSets {
		fs.AddFlagSet(f)
	}

	usageFmt := "Usage:\n  %s\n"
	cols, _, _ := term.TerminalSize(command.OutOrStdout())
	command.SetUsageFunc(func(cmd *cobra.Command) error {
		if _, err := fmt.Fprintf(cmd.OutOrStderr(), usageFmt, cmd.UseLine()); err != nil {
			return err
		}
		cliflag.PrintSections(cmd.OutOrStderr(), namedFlagSets, cols)
		return nil
	})
	command.SetHelpFunc(func(cmd *cobra.Command, args []string) {
		if _, err := fmt.Fprintf(cmd.OutOrStdout(), "%s\n\n"+usageFmt, cmd.Long, cmd.UseLine()); err != nil {
			return
		}
		cliflag.PrintSections(cmd.OutOrStdout(), namedFlagSets, cols)
	})

	// TODO: once we switch everything over to Cobra commands, we can go back to calling
	// utilflag.InitFlags() (by removing its pflag.Parse() call). For now, we have to set the
	// normalize func and add the go flag set by hand.
	pflag.CommandLine.SetNormalizeFunc(cliflag.WordSepNormalizeFunc)
	pflag.CommandLine.AddGoFlagSet(goflag.CommandLine)
	// utilflag.InitFlags()
	logs.InitLogs()
	defer logs.FlushLogs()

	var clusterNameFlag *pflag.Value
	var controllersFlag *pflag.Value
	var cloudProviderFlag *pflag.Value
	command.Flags().VisitAll(func(flag *pflag.Flag) {
		switch flag.Name {
		// Set cloud-provider flag to vsphere
		case "cloud-provider":
			cloudProviderFlag = &flag.Value
			if err := flag.Value.Set(vsphere.RegisteredProviderName); err != nil {
				klog.Fatalf("cannot set RegisteredProviderName to %s: %v", vsphere.RegisteredProviderName, err)
			}
			flag.DefValue = vsphere.RegisteredProviderName
		case "cluster-name":
			clusterNameFlag = &flag.Value
		case "controllers":
			controllersFlag = &flag.Value
		}
	})

	var versionFlag *pflag.Value
	pflag.CommandLine.VisitAll(func(flag *pflag.Flag) {
		switch flag.Name {
		case "version":
			versionFlag = &flag.Value
		}
	})

	command.Use = AppName
	innerRun := command.Run
	command.Run = func(cmd *cobra.Command, args []string) {
		if versionFlag != nil && (*versionFlag).String() != "false" {
			fmt.Printf("%s %s\n", AppName, version)
			os.Exit(0)
		}
		if clusterNameFlag != nil {
			loadbalancer.ClusterName = (*clusterNameFlag).String()
			vsphereparavirtual.ClusterName = (*clusterNameFlag).String()
		}
		// if route controller is enabled in vsphereparavirtual cloud provider, set routeEnabled to true
		if controllersFlag != nil &&
			!strings.Contains((*controllersFlag).String(), "-route") &&
			(strings.Contains((*controllersFlag).String(), "route") || strings.Contains((*controllersFlag).String(), "*")) &&
			vsphereparavirtual.RegisteredProviderName == (*cloudProviderFlag).String() {
			vsphereparavirtual.RouteEnabled = true
		}
		innerRun(cmd, args)
	}

	if err := command.Execute(); err != nil {
		// ignore error by Fprintf, exit anyway due to cmd execute error
		_, _ = fmt.Fprintf(os.Stderr, "error: %v\n", err)
		os.Exit(1)
	}
}