From f26bd5da81f9e57711595b36306332d221a5f0a9 Mon Sep 17 00:00:00 2001 From: Justin Kulikauskas Date: Thu, 20 Apr 2023 15:25:36 -0400 Subject: [PATCH] Refactor flags to a separate function This should help keep things a little bit more clear as we add more options. Signed-off-by: Justin Kulikauskas --- main.go | 229 ++++++++++++++++++++++++++++++++++++-------------------- 1 file changed, 149 insertions(+), 80 deletions(-) diff --git a/main.go b/main.go index 4a6f7bcc..c3f57123 100644 --- a/main.go +++ b/main.go @@ -67,61 +67,55 @@ func init() { utilruntime.Must(extensionsv1beta1.AddToScheme(scheme)) } +type ctrlOpts struct { + clusterName string + hubConfigPath string + targetKubeConfig string + metricsAddr string + probeAddr string + frequency uint + decryptionConcurrency uint8 + evaluationConcurrency uint8 + enableLease bool + enableLeaderElection bool + legacyLeaderElection bool + enableMetrics bool +} + func main() { klog.InitFlags(nil) + subcommand := "" + if len(os.Args) >= 2 { + subcommand = os.Args[1] + } + + switch subcommand { + case "controller": + break // normal mode - just continue execution + case "trigger-uninstall": + handleTriggerUninstall() + + return + default: + fmt.Fprintln(os.Stderr, "expected 'controller' or 'trigger-uninstall' subcommands") + os.Exit(1) + } + zflags := zaputil.FlagConfig{ LevelName: "log-level", EncoderName: "log-encoder", } + controllerFlagSet := pflag.NewFlagSet("controller", pflag.ExitOnError) + zflags.Bind(flag.CommandLine) + klog.InitFlags(flag.CommandLine) + controllerFlagSet.AddGoFlagSet(flag.CommandLine) - controllerFlagSet := pflag.NewFlagSet("controller", pflag.ExitOnError) + opts := setupOpts(controllerFlagSet) - var clusterName, hubConfigPath, targetKubeConfig, metricsAddr, probeAddr string - var frequency uint - var decryptionConcurrency, evaluationConcurrency uint8 - var enableLease, enableLeaderElection, legacyLeaderElection, enableMetrics bool - - controllerFlagSet.UintVar(&frequency, "update-frequency", 10, - "The status update frequency (in seconds) of a mutation policy") - controllerFlagSet.BoolVar(&enableLease, "enable-lease", false, - "If enabled, the controller will start the lease controller to report its status") - controllerFlagSet.StringVar(&clusterName, "cluster-name", "acm-managed-cluster", "Name of the cluster") - controllerFlagSet.StringVar(&hubConfigPath, "hub-kubeconfig-path", "/var/run/klusterlet/kubeconfig", - "Path to the hub kubeconfig") - controllerFlagSet.StringVar( - &targetKubeConfig, - "target-kubeconfig-path", - "", - "A path to an alternative kubeconfig for policy evaluation and enforcement.", - ) - controllerFlagSet.StringVar( - &metricsAddr, "metrics-bind-address", "localhost:8383", "The address the metrics endpoint binds to.", - ) - controllerFlagSet.StringVar( - &probeAddr, "health-probe-bind-address", ":8081", "The address the probe endpoint binds to.", - ) - controllerFlagSet.BoolVar(&enableLeaderElection, "leader-elect", true, - "Enable leader election for controller manager. "+ - "Enabling this will ensure there is only one active controller manager.") - controllerFlagSet.BoolVar(&legacyLeaderElection, "legacy-leader-elect", false, - "Use a legacy leader election method for controller manager instead of the lease API.") - controllerFlagSet.Uint8Var( - &decryptionConcurrency, - "decryption-concurrency", - 5, - "The max number of concurrent policy template decryptions", - ) - controllerFlagSet.Uint8Var( - &evaluationConcurrency, - "evaluation-concurrency", - // Set a low default to not add too much load to the Kubernetes API server in resource constrained deployments. - 2, - "The max number of concurrent configuration policy evaluations", - ) - controllerFlagSet.BoolVar(&enableMetrics, "enable-metrics", true, "Disable custom metrics collection") + _ = controllerFlagSet.Parse(os.Args[2:]) ctrlZap, err := zflags.BuildForCtrl() if err != nil { @@ -145,25 +139,7 @@ func main() { klog.SetLogger(zapr.NewLogger(klogZap).WithName("klog")) } - subcommand := "" - if len(os.Args) >= 2 { - subcommand = os.Args[1] - } - - switch subcommand { - case "controller": - controllerFlagSet.AddGoFlagSet(flag.CommandLine) - _ = controllerFlagSet.Parse(os.Args[2:]) - case "trigger-uninstall": - handleTriggerUninstall() - - return - default: - fmt.Fprintln(os.Stderr, "expected 'controller' or 'trigger-uninstall' subcommands") - os.Exit(1) - } - - if evaluationConcurrency < 1 { + if opts.evaluationConcurrency < 1 { panic("The --evaluation-concurrency option cannot be less than 1") } @@ -229,11 +205,11 @@ func main() { // Set default manager options options := manager.Options{ - MetricsBindAddress: metricsAddr, + MetricsBindAddress: opts.metricsAddr, Scheme: scheme, Port: 9443, - HealthProbeBindAddress: probeAddr, - LeaderElection: enableLeaderElection, + HealthProbeBindAddress: opts.probeAddr, + LeaderElection: opts.enableLeaderElection, LeaderElectionID: "config-policy-controller.open-cluster-management.io", NewCache: cache.BuilderWithOptions(cache.Options{SelectorsByObject: cacheSelectors}), // Disable the cache for Secrets to avoid a watch getting created when the `policy-encryption-key` @@ -267,7 +243,7 @@ func main() { ), } - if legacyLeaderElection { + if opts.legacyLeaderElection { // If legacyLeaderElection is enabled, then that means the lease API is not available. // In this case, use the legacy leader election method of a ConfigMap. log.Info("Using the legacy leader election of configmaps") @@ -290,16 +266,16 @@ func main() { var targetK8sDynamicClient dynamic.Interface var targetK8sConfig *rest.Config - if targetKubeConfig == "" { + if opts.targetKubeConfig == "" { targetK8sConfig = cfg targetK8sClient = kubernetes.NewForConfigOrDie(targetK8sConfig) targetK8sDynamicClient = dynamic.NewForConfigOrDie(targetK8sConfig) } else { var err error - targetK8sConfig, err = clientcmd.BuildConfigFromFlags("", targetKubeConfig) + targetK8sConfig, err = clientcmd.BuildConfigFromFlags("", opts.targetKubeConfig) if err != nil { - log.Error(err, "Failed to load the target kubeconfig", "path", targetKubeConfig) + log.Error(err, "Failed to load the target kubeconfig", "path", opts.targetKubeConfig) os.Exit(1) } @@ -307,7 +283,8 @@ func main() { targetK8sDynamicClient = dynamic.NewForConfigOrDie(targetK8sConfig) log.Info( - "Overrode the target Kubernetes cluster for policy evaluation and enforcement", "path", targetKubeConfig, + "Overrode the target Kubernetes cluster for policy evaluation and enforcement", + "path", opts.targetKubeConfig, ) } @@ -315,15 +292,15 @@ func main() { reconciler := controllers.ConfigurationPolicyReconciler{ Client: mgr.GetClient(), - DecryptionConcurrency: decryptionConcurrency, - EvaluationConcurrency: evaluationConcurrency, + DecryptionConcurrency: opts.decryptionConcurrency, + EvaluationConcurrency: opts.evaluationConcurrency, Scheme: mgr.GetScheme(), Recorder: mgr.GetEventRecorderFor(controllers.ControllerName), InstanceName: instanceName, TargetK8sClient: targetK8sClient, TargetK8sDynamicClient: targetK8sDynamicClient, TargetK8sConfig: targetK8sConfig, - EnableMetrics: enableMetrics, + EnableMetrics: opts.enableMetrics, } if err = reconciler.SetupWithManager(mgr); err != nil { log.Error(err, "Unable to create controller", "controller", "ConfigurationPolicy") @@ -345,17 +322,17 @@ func main() { managerCtx, managerCancel := context.WithCancel(context.Background()) // PeriodicallyExecConfigPolicies is the go-routine that periodically checks the policies - log.V(1).Info("Perodically processing Configuration Policies", "frequency", frequency) + log.V(1).Info("Perodically processing Configuration Policies", "frequency", opts.frequency) go func() { - reconciler.PeriodicallyExecConfigPolicies(terminatingCtx, frequency, mgr.Elected()) + reconciler.PeriodicallyExecConfigPolicies(terminatingCtx, opts.frequency, mgr.Elected()) managerCancel() }() // This lease is not related to leader election. This is to report the status of the controller // to the addon framework. This can be seen in the "status" section of the ManagedClusterAddOn // resource objects. - if enableLease { + if opts.enableLease { operatorNs, err := common.GetOperatorNamespace() if err != nil { if errors.Is(err, common.ErrNoNamespace) || errors.Is(err, common.ErrRunLocal) { @@ -373,11 +350,11 @@ func main() { kubernetes.NewForConfigOrDie(cfg), "config-policy-controller", operatorNs, ) - hubCfg, err := clientcmd.BuildConfigFromFlags("", hubConfigPath) + hubCfg, err := clientcmd.BuildConfigFromFlags("", opts.hubConfigPath) if err != nil { log.Error(err, "Could not load hub config, lease updater not set with config") } else { - leaseUpdater = leaseUpdater.WithHubLeaseConfig(hubCfg, clusterName) + leaseUpdater = leaseUpdater.WithHubLeaseConfig(hubCfg, opts.clusterName) } go leaseUpdater.Start(context.TODO()) @@ -437,7 +414,7 @@ func handleTriggerUninstall() { // Get a config to talk to the apiserver cfg, err := config.GetConfig() if err != nil { - log.Error(err, "Failed to get config") + klog.Errorf("Failed to get config: %s", err) os.Exit(1) } @@ -447,3 +424,95 @@ func handleTriggerUninstall() { os.Exit(1) } } + +func setupOpts(flags *pflag.FlagSet) *ctrlOpts { + opts := &ctrlOpts{} + + flags.UintVar( + &opts.frequency, + "update-frequency", + 10, + "The status update frequency (in seconds) of a mutation policy", + ) + + flags.BoolVar( + &opts.enableLease, + "enable-lease", + false, + "If enabled, the controller will start the lease controller to report its status", + ) + + flags.StringVar( + &opts.clusterName, + "cluster-name", + "acm-managed-cluster", + "Name of the cluster", + ) + + flags.StringVar( + &opts.hubConfigPath, + "hub-kubeconfig-path", + "/var/run/klusterlet/kubeconfig", + "Path to the hub kubeconfig", + ) + + flags.StringVar( + &opts.targetKubeConfig, + "target-kubeconfig-path", + "", + "A path to an alternative kubeconfig for policy evaluation and enforcement.", + ) + + flags.StringVar( + &opts.metricsAddr, + "metrics-bind-address", + "localhost:8383", + "The address the metrics endpoint binds to.", + ) + + flags.StringVar( + &opts.probeAddr, + "health-probe-bind-address", + ":8081", + "The address the probe endpoint binds to.", + ) + + flags.BoolVar( + &opts.enableLeaderElection, + "leader-elect", + true, + "Enable leader election for controller manager. "+ + "Enabling this will ensure there is only one active controller manager.", + ) + + flags.BoolVar( + &opts.legacyLeaderElection, + "legacy-leader-elect", + false, + "Use a legacy leader election method for controller manager instead of the lease API.", + ) + + flags.Uint8Var( + &opts.decryptionConcurrency, + "decryption-concurrency", + 5, + "The max number of concurrent policy template decryptions", + ) + + flags.Uint8Var( + &opts.evaluationConcurrency, + "evaluation-concurrency", + // Set a low default to not add too much load to the Kubernetes API server in resource constrained deployments. + 2, + "The max number of concurrent configuration policy evaluations", + ) + + flags.BoolVar( + &opts.enableMetrics, + "enable-metrics", + true, + "Disable custom metrics collection", + ) + + return opts +}