Group Cluster Failover flags into a single command flagSet

cmd/controller-manager/app/controllermanager.go

@@ -117,6 +117,9 @@ func NewControllerManagerCommand(ctx context.Context) *cobra.Command {
 	opts := options.NewOptions()
 	opts.AddFlags(genericFlagSet, controllers.ControllerNames(), sets.List(controllersDisabledByDefault))
 
+	clusterFailoverFlagSet := fss.FlagSet("cluster failover")
+	opts.ClusterFailoverOptions.AddFlags(clusterFailoverFlagSet)
+
 	cmd := &cobra.Command{
 		Use: names.KarmadaControllerManagerComponentName,
 		Long: "The karmada-controller-manager runs various controllers.\n" +
@@ -149,6 +152,7 @@ func NewControllerManagerCommand(ctx context.Context) *cobra.Command {
 	cmd.AddCommand(sharedcommand.NewCmdVersion(names.KarmadaControllerManagerComponentName))
 	cmd.Flags().AddFlagSet(genericFlagSet)
 	cmd.Flags().AddFlagSet(logsFlagSet)
+	cmd.Flags().AddFlagSet(clusterFailoverFlagSet)
 
 	cols, _, _ := term.TerminalSize(cmd.OutOrStdout())
 	sharedcli.SetUsageAndHelpFunc(cmd, fss, cols)
@@ -297,10 +301,10 @@ func startClusterController(ctx controllerscontext.Context) (enabled bool, err e
 			ClusterTaintEvictionRetryFrequency: 10 * time.Second,
 			ConcurrentReconciles:               3,
 			RateLimiterOptions:                 ctx.Opts.RateLimiterOptions,
-			EnableNoExecuteTaintEviction:       ctx.Opts.FailoverConfiguration.EnableNoExecuteTaintEviction,
-			NoExecuteTaintEvictionPurgeMode:    ctx.Opts.FailoverConfiguration.NoExecuteTaintEvictionPurgeMode,
+			EnableNoExecuteTaintEviction:       ctx.Opts.ClusterFailoverConfiguration.EnableNoExecuteTaintEviction,
+			NoExecuteTaintEvictionPurgeMode:    ctx.Opts.ClusterFailoverConfiguration.NoExecuteTaintEvictionPurgeMode,
 			EvictionQueueOptions: cluster.EvictionQueueOptions{
-				ResourceEvictionRate: ctx.Opts.FailoverConfiguration.ResourceEvictionRate,
+				ResourceEvictionRate: ctx.Opts.ClusterFailoverConfiguration.ResourceEvictionRate,
 			},
 		}
 		if err := taintManager.SetupWithManager(mgr); err != nil {
@@ -926,7 +930,7 @@ func setupControllers(ctx context.Context, mgr controllerruntime.Manager, opts *
 			EnableClusterResourceModeling:     opts.EnableClusterResourceModeling,
 			HPAControllerConfiguration:        opts.HPAControllerConfiguration,
 			FederatedResourceQuotaOptions:     opts.FederatedResourceQuotaOptions,
-			FailoverConfiguration:             opts.FailoverOptions,
+			ClusterFailoverConfiguration:      opts.ClusterFailoverOptions,
 		},
 		Context:                     ctx,
 		DynamicClientSet:            dynamicClientSet,

cmd/controller-manager/app/options/failover.go → cmd/controller-manager/app/options/cluster_failover.go

@@ -19,10 +19,12 @@ package options
 import (
 	"github.com/spf13/pflag"
 	"k8s.io/apimachinery/pkg/util/validation/field"
+
+	policyv1alpha1 "github.com/karmada-io/karmada/pkg/apis/policy/v1alpha1"
 )
 
-// FailoverOptions holds the Failover configurations.
-type FailoverOptions struct {
+// ClusterFailoverOptions holds the Cluster Failover configurations.
+type ClusterFailoverOptions struct {
 	// EnableNoExecuteTaintEviction enables controller response to NoExecute taints on clusters,
 	// which triggers eviction of workloads without explicit tolerations.
 	EnableNoExecuteTaintEviction bool
@@ -39,25 +41,25 @@ type FailoverOptions struct {
 	ResourceEvictionRate float32
 }
 
-// AddFlags adds flags related to FailoverOptions for controller manager to the specified FlagSet.
-func (o *FailoverOptions) AddFlags(flags *pflag.FlagSet) {
+// AddFlags adds flags related to ClusterFailoverOptions for controller manager to the specified FlagSet.
+func (o *ClusterFailoverOptions) AddFlags(flags *pflag.FlagSet) {
 	if o == nil {
 		return
 	}
 
 	flags.BoolVar(&o.EnableNoExecuteTaintEviction, "enable-no-execute-taint-eviction", false, "Enables controller response to NoExecute taints on clusters, which triggers eviction of workloads without explicit tolerations. Given the impact of eviction caused by NoExecute Taint, this parameter is designed to remain disabled by default and requires careful evaluation by administrators before being enabled.\n")
-	flags.StringVar(&o.NoExecuteTaintEvictionPurgeMode, "no-execute-taint-eviction-purge-mode", "Gracefully", "Controls resource cleanup behavior for NoExecute-triggered evictions (only active when --enable-no-execute-taint-eviction=true). Supported values are \"Directly\", and \"Gracefully\". \"Directly\" mode directly evicts workloads first (risking temporary service interruption) and then triggers rescheduling to other clusters, while \"Gracefully\" mode first schedules workloads to new clusters and then cleans up original workloads after successful startup elsewhere to ensure service continuity.")
+	flags.StringVar(&o.NoExecuteTaintEvictionPurgeMode, "no-execute-taint-eviction-purge-mode", string(policyv1alpha1.PurgeModeGracefully), "Controls resource cleanup behavior for NoExecute-triggered evictions (only active when --enable-no-execute-taint-eviction=true). Supported values are \"Directly\", and \"Gracefully\". \"Directly\" mode directly evicts workloads first (risking temporary service interruption) and then triggers rescheduling to other clusters, while \"Gracefully\" mode first schedules workloads to new clusters and then cleans up original workloads after successful startup elsewhere to ensure service continuity.")
 	flags.Float32Var(&o.ResourceEvictionRate, "resource-eviction-rate", 0.5, "This is the number of resources to be evicted per second in a cluster failover scenario.")
 }
 
-// Validate checks FailoverOptions and return a slice of found errs.
-func (o *FailoverOptions) Validate() field.ErrorList {
+// Validate checks ClusterFailoverOptions and return a slice of found errs.
+func (o *ClusterFailoverOptions) Validate() field.ErrorList {
 	errs := field.ErrorList{}
-	rootPath := field.NewPath("FailoverOptions")
+	rootPath := field.NewPath("ClusterFailoverOptions")
 
 	if o.EnableNoExecuteTaintEviction &&
-		o.NoExecuteTaintEvictionPurgeMode != "Gracefully" &&
-		o.NoExecuteTaintEvictionPurgeMode != "Directly" {
+		o.NoExecuteTaintEvictionPurgeMode != string(policyv1alpha1.PurgeModeGracefully) &&
+		o.NoExecuteTaintEvictionPurgeMode != string(policyv1alpha1.PurgeModeDirectly) {
 		errs = append(errs, field.Invalid(rootPath.Child("NoExecuteTaintEvictionPurgeMode"),
 			o.NoExecuteTaintEvictionPurgeMode, "Invalid mode"))
 	}

cmd/controller-manager/app/options/options.go

@@ -146,8 +146,8 @@ type Options struct {
 	EnableClusterResourceModeling bool
 	// FederatedResourceQuotaOptions holds configurations for FederatedResourceQuota reconciliation.
 	FederatedResourceQuotaOptions FederatedResourceQuotaOptions
-	// FailoverOptions holds the Failover configurations.
-	FailoverOptions FailoverOptions
+	// ClusterFailoverOptions holds the cluster failover configurations.
+	ClusterFailoverOptions ClusterFailoverOptions
 }
 
 // NewOptions builds an empty options.
@@ -233,7 +233,6 @@ func (o *Options) AddFlags(flags *pflag.FlagSet, allControllers, disabledByDefau
 	o.ProfileOpts.AddFlags(flags)
 	o.HPAControllerConfiguration.AddFlags(flags)
 	o.FederatedResourceQuotaOptions.AddFlags(flags)
-	o.FailoverOptions.AddFlags(flags)
 	features.FeatureGate.AddFlag(flags)
 }
 

cmd/controller-manager/app/options/validation.go

@@ -56,7 +56,7 @@ func (o *Options) Validate() field.ErrorList {
 	}
 
 	errs = append(errs, o.FederatedResourceQuotaOptions.Validate()...)
-	errs = append(errs, o.FailoverOptions.Validate()...)
+	errs = append(errs, o.ClusterFailoverOptions.Validate()...)
 
 	return errs
 }

cmd/controller-manager/app/options/validation_test.go

@@ -101,13 +101,13 @@ func TestValidateControllerManagerConfiguration(t *testing.T) {
 			}),
 			expectedErrs: field.ErrorList{field.Invalid(newPath.Child("ClusterStartupGracePeriod"), metav1.Duration{Duration: 0 * time.Second}, "must be greater than 0")},
 		},
-		"invalid FailoverOptions": {
+		"invalid ClusterFailoverOptions": {
 			opt: New(func(options *Options) {
-				options.FailoverOptions.EnableNoExecuteTaintEviction = true
-				options.FailoverOptions.NoExecuteTaintEvictionPurgeMode = ""
+				options.ClusterFailoverOptions.EnableNoExecuteTaintEviction = true
+				options.ClusterFailoverOptions.NoExecuteTaintEvictionPurgeMode = ""
 			}),
 			expectedErrs: field.ErrorList{
-				field.Invalid(field.NewPath("FailoverOptions").Child("NoExecuteTaintEvictionPurgeMode"), "", "Invalid mode"),
+				field.Invalid(field.NewPath("ClusterFailoverOptions").Child("NoExecuteTaintEvictionPurgeMode"), "", "Invalid mode"),
 			},
 		},
 	}

pkg/controllers/context/context.go

@@ -98,8 +98,8 @@ type Options struct {
 	HPAControllerConfiguration federatehpaconfig.HPAControllerConfiguration
 	// FederatedResourceQuotaOptions holds configurations for FederatedResourceQuota reconciliation.
 	FederatedResourceQuotaOptions options.FederatedResourceQuotaOptions
-	// FailoverConfiguration is the config of failover function.
-	FailoverConfiguration options.FailoverOptions
+	// ClusterFailoverConfiguration is the config of cluster failover function.
+	ClusterFailoverConfiguration options.ClusterFailoverOptions
 }
 
 // Context defines the context object for controller.