func main()

in cmd/ndb-operator/main.go [26:107]
55 lines of code
11 McCabe index (conditional complexity)

func main() {
	flag.Parse()
	config.ValidateFlags()

	// set up signal handlers
	ctx := signals.SetupSignalHandler(context.Background())

	klog.Infof("Starting ndb-operator with build version %s", config.GetBuildVersion())

	// K8s client configuration
	var cfg *restclient.Config
	var err error

	runningInsideK8s := helpers.IsAppRunningInsideK8s()
	if runningInsideK8s {
		// Operator is running inside K8s Pods
		cfg, err = restclient.InClusterConfig()

		// First, we check if the namespace to watch is available from the environment.
		// Only if it could not be found, the command flags will be used.
		watchNamespace := helpers.GetWatchNamespaceFromEnvironment()
		if watchNamespace != "" {
			// Operator is in Single Namespace install mode
			klog.Infof("Getting watch namespace from environment: %s", watchNamespace)
			config.ClusterScoped = false
			config.WatchNamespace = watchNamespace
		} else {
			klog.Info("No namespace to watch found in environment. Using flags.")
			if !config.ClusterScoped && config.WatchNamespace == "" {
				// Operator is namespace-scoped.
				// If no namespace is specified
				// Use the namespace it is deployed in to watch for changes.
				config.WatchNamespace, err = helpers.GetCurrentNamespace()
				if err != nil {
					klog.Fatalf("Could not get current namespace : %s", err)
				}
			}
		}
	} else {
		// Operator is running outside K8s cluster
		cfg, err = clientcmd.BuildConfigFromFlags(config.MasterURL, config.Kubeconfig)
	}
	if err != nil {
		klog.Fatalf("Error getting kubeconfig: %s", err.Error())
	}

	kubeClient, err := kubernetes.NewForConfig(cfg)
	if err != nil {
		klog.Fatalf("Error building kubernetes clientset: %s", err.Error())
	}

	ndbClient, err := clientset.NewForConfig(cfg)
	if err != nil {
		klog.Fatalf("Error building ndb clientset: %s", err.Error())
	}

	if config.ClusterScoped {
		klog.Info("Running NDB Operator with cluster-scope")
	} else {
		klog.Info("Running NDB Operator with namespace-scope")
		klog.Infof("Watching for changes in namespace %q", config.WatchNamespace)
	}

	// Create a SharedInformerFactory and limit it to config.WatchNamespace.
	// For cluster-scoped mode, config.WatchNamespace will be empty
	// and the SharedInformer will not be limited to any namespace.
	k8If := kubeinformers.NewSharedInformerFactoryWithOptions(
		kubeClient, time.Second*30, kubeinformers.WithNamespace(config.WatchNamespace))
	ndbIf := ndbinformers.NewSharedInformerFactoryWithOptions(
		ndbClient, time.Second*30, ndbinformers.WithNamespace(config.WatchNamespace))

	controller := controllers.NewController(kubeClient, ndbClient, k8If, ndbIf)

	// notice that there is no need to run Start methods in a separate goroutine. (i.e. go kubeInformerFactory.Start(stopCh)
	// Start method is non-blocking and runs all registered informers in a dedicated goroutine.
	k8If.Start(ctx.Done())
	ndbIf.Start(ctx.Done())

	if err = controller.Run(ctx, 2); err != nil {
		klog.Fatalf("Error running controller: %s", err.Error())
	}
}