split KubeControllerManagerConfiguration into fewer options struct

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

@@ -25,7 +25,6 @@ import (
 	utilfeature "k8s.io/apiserver/pkg/util/feature"
 	cloudcontrollerconfig "k8s.io/kubernetes/cmd/cloud-controller-manager/app/config"
 	cmoptions "k8s.io/kubernetes/cmd/controller-manager/app/options"
-	"k8s.io/kubernetes/pkg/client/leaderelectionconfig"
 	"k8s.io/kubernetes/pkg/master/ports"
 
 	// add the kubernetes feature gates
@@ -36,7 +35,7 @@ import (
 
 // CloudControllerManagerOptions is the main context object for the controller manager.
 type CloudControllerManagerOptions struct {
-	Generic cmoptions.GenericControllerManagerOptions
+	Generic *cmoptions.GenericControllerManagerOptions
 
 	// NodeStatusUpdateFrequency is the frequency at which the controller updates nodes' status
 	NodeStatusUpdateFrequency metav1.Duration
@@ -63,11 +62,7 @@ func NewCloudControllerManagerOptions() *CloudControllerManagerOptions {
 func (o *CloudControllerManagerOptions) AddFlags(fs *pflag.FlagSet) {
 	o.Generic.AddFlags(fs)
 
-	fs.StringVar(&o.Generic.ComponentConfig.CloudProvider, "cloud-provider", o.Generic.ComponentConfig.CloudProvider, "The provider of cloud services. Cannot be empty.")
 	fs.DurationVar(&o.NodeStatusUpdateFrequency.Duration, "node-status-update-frequency", o.NodeStatusUpdateFrequency.Duration, "Specifies how often the controller updates nodes' status.")
-	fs.Int32Var(&o.Generic.ComponentConfig.ConcurrentServiceSyncs, "concurrent-service-syncs", o.Generic.ComponentConfig.ConcurrentServiceSyncs, "The number of services that are allowed to sync concurrently. Larger number = more responsive service management, but more CPU (and network) load")
-
-	leaderelectionconfig.BindFlags(&o.Generic.ComponentConfig.LeaderElection, fs)
 
 	utilfeature.DefaultFeatureGate.AddFlag(fs)
 }
@@ -88,7 +83,7 @@ func (o *CloudControllerManagerOptions) Validate() error {
 	errors := []error{}
 	errors = append(errors, o.Generic.Validate()...)
 
-	if len(o.Generic.ComponentConfig.CloudProvider) == 0 {
+	if len(o.Generic.CloudProvider.Name) == 0 {
 		errors = append(errors, fmt.Errorf("--cloud-provider cannot be empty"))
 	}
 

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

@@ -35,46 +35,89 @@ func TestDefaultFlags(t *testing.T) {
 	s := NewCloudControllerManagerOptions()
 
 	expected := &CloudControllerManagerOptions{
-		Generic: cmoptions.GenericControllerManagerOptions{
+		Generic: &cmoptions.GenericControllerManagerOptions{
-			ComponentConfig: componentconfig.KubeControllerManagerConfiguration{
+			CloudProvider: &cmoptions.CloudProviderOptions{
-				CloudProvider:                                   "",
+				Name:            "",
-				CloudConfigFile:                                 "",
+				CloudConfigFile: "",
-				Port:                                            10253,     // Note: InsecureServingOptions.ApplyTo will write the flag value back into the component config
+			},
-				Address:                                         "0.0.0.0", // Note: InsecureServingOptions.ApplyTo will write the flag value back into the component config
+			Debugging: &cmoptions.DebuggingOptions{
-				ConcurrentEndpointSyncs:                         5,
+				EnableContentionProfiling: false,
-				ConcurrentRSSyncs:                               5,
+			},
-				ConcurrentResourceQuotaSyncs:                    5,
+			GenericComponent: &cmoptions.GenericComponentConfigOptions{
-				ConcurrentDeploymentSyncs:                       5,
+				MinResyncPeriod:         metav1.Duration{Duration: 12 * time.Hour},
-				ConcurrentDaemonSetSyncs:                        2,
+				ContentType:             "application/vnd.kubernetes.protobuf",
-				ConcurrentJobSyncs:                              5,
+				KubeAPIQPS:              20.0,
-				ConcurrentNamespaceSyncs:                        10,
+				KubeAPIBurst:            30,
-				ConcurrentSATokenSyncs:                          5,
+				ControllerStartInterval: metav1.Duration{Duration: 0},
-				ConcurrentServiceSyncs:                          1,
+				LeaderElection: componentconfig.LeaderElectionConfiguration{
-				ConcurrentGCSyncs:                               20,
+					ResourceLock:  "endpoints",
-				ConcurrentRCSyncs:                               5,
+					LeaderElect:   true,
-				MinResyncPeriod:                                 metav1.Duration{Duration: 12 * time.Hour},
+					LeaseDuration: metav1.Duration{Duration: 15 * time.Second},
-				NodeMonitorPeriod:                               metav1.Duration{Duration: 5 * time.Second},
+					RenewDeadline: metav1.Duration{Duration: 10 * time.Second},
-				ResourceQuotaSyncPeriod:                         metav1.Duration{Duration: 5 * time.Minute},
+					RetryPeriod:   metav1.Duration{Duration: 2 * time.Second},
-				NamespaceSyncPeriod:                             metav1.Duration{Duration: 5 * time.Minute},
+				},
-				PVClaimBinderSyncPeriod:                         metav1.Duration{Duration: 15 * time.Second},
+			},
+			KubeCloudShared: &cmoptions.KubeCloudSharedOptions{
+				Port:                      10253,     // Note: InsecureServingOptions.ApplyTo will write the flag value back into the component config
+				Address:                   "0.0.0.0", // Note: InsecureServingOptions.ApplyTo will write the flag value back into the component config
+				RouteReconciliationPeriod: metav1.Duration{Duration: 10 * time.Second},
+				NodeMonitorPeriod:         metav1.Duration{Duration: 5 * time.Second},
+				ClusterName:               "kubernetes",
+				ClusterCIDR:               "",
+				AllocateNodeCIDRs:         false,
+				CIDRAllocatorType:         "",
+				ConfigureCloudRoutes:      true,
+			},
+			AttachDetachController: &cmoptions.AttachDetachControllerOptions{
+				ReconcilerSyncLoopPeriod: metav1.Duration{Duration: 1 * time.Minute},
+			},
+			CSRSigningController: &cmoptions.CSRSigningControllerOptions{
+				ClusterSigningCertFile: "/etc/kubernetes/ca/ca.pem",
+				ClusterSigningKeyFile:  "/etc/kubernetes/ca/ca.key",
+				ClusterSigningDuration: metav1.Duration{Duration: 8760 * time.Hour},
+			},
+			DaemonSetController: &cmoptions.DaemonSetControllerOptions{
+				ConcurrentDaemonSetSyncs: 2,
+			},
+			DeploymentController: &cmoptions.DeploymentControllerOptions{
+				ConcurrentDeploymentSyncs:      5,
+				DeploymentControllerSyncPeriod: metav1.Duration{Duration: 30 * time.Second},
+			},
+			DeprecatedFlags: &cmoptions.DeprecatedControllerOptions{
+				RegisterRetryCount: 10,
+			},
+			EndPointController: &cmoptions.EndPointControllerOptions{
+				ConcurrentEndpointSyncs: 5,
+			},
+			GarbageCollectorController: &cmoptions.GarbageCollectorControllerOptions{
+				EnableGarbageCollector: true,
+				ConcurrentGCSyncs:      20,
+			},
+			HPAController: &cmoptions.HPAControllerOptions{
 				HorizontalPodAutoscalerSyncPeriod:               metav1.Duration{Duration: 30 * time.Second},
 				HorizontalPodAutoscalerUpscaleForbiddenWindow:   metav1.Duration{Duration: 3 * time.Minute},
 				HorizontalPodAutoscalerDownscaleForbiddenWindow: metav1.Duration{Duration: 5 * time.Minute},
 				HorizontalPodAutoscalerTolerance:                0.1,
-				DeploymentControllerSyncPeriod:                  metav1.Duration{Duration: 30 * time.Second},
-				PodEvictionTimeout:                              metav1.Duration{Duration: 5 * time.Minute},
-				NodeMonitorGracePeriod:                          metav1.Duration{Duration: 40 * time.Second},
-				NodeStartupGracePeriod:                          metav1.Duration{Duration: 1 * time.Minute},
-				ClusterSigningDuration:                          metav1.Duration{Duration: 8760 * time.Hour},
-				ReconcilerSyncLoopPeriod:                        metav1.Duration{Duration: 1 * time.Minute},
-				TerminatedPodGCThreshold:                        12500,
-				RegisterRetryCount:                              10,
-				ClusterName:                                     "kubernetes",
-				ConfigureCloudRoutes:                            true,
-				AllocateNodeCIDRs:                               false,
-				EnableGarbageCollector:                          true,
-				EnableTaintManager:                              true,
 				HorizontalPodAutoscalerUseRESTClients:           true,
+			},
+			JobController: &cmoptions.JobControllerOptions{
+				ConcurrentJobSyncs: 5,
+			},
+			NamespaceController: &cmoptions.NamespaceControllerOptions{
+				ConcurrentNamespaceSyncs: 10,
+				NamespaceSyncPeriod:      metav1.Duration{Duration: 5 * time.Minute},
+			},
+			NodeIpamController: &cmoptions.NodeIpamControllerOptions{
+				NodeCIDRMaskSize: 24,
+			},
+			NodeLifecycleController: &cmoptions.NodeLifecycleControllerOptions{
+				EnableTaintManager:     true,
+				NodeMonitorGracePeriod: metav1.Duration{Duration: 40 * time.Second},
+				NodeStartupGracePeriod: metav1.Duration{Duration: 1 * time.Minute},
+				PodEvictionTimeout:     metav1.Duration{Duration: 5 * time.Minute},
+			},
+			PersistentVolumeBinderController: &cmoptions.PersistentVolumeBinderControllerOptions{
+				PVClaimBinderSyncPeriod: metav1.Duration{Duration: 15 * time.Second},
 				VolumeConfiguration: componentconfig.VolumeConfiguration{
 					EnableDynamicProvisioning:  true,
 					EnableHostPathProvisioning: false,
@@ -87,26 +130,27 @@ func TestDefaultFlags(t *testing.T) {
 						IncrementTimeoutHostPath: 30,
 					},
 				},
-				ContentType:               "application/vnd.kubernetes.protobuf",
-				ClusterSigningCertFile:    "/etc/kubernetes/ca/ca.pem",
-				ClusterSigningKeyFile:     "/etc/kubernetes/ca/ca.key",
-				EnableContentionProfiling: false,
-				KubeAPIQPS:                20.0,
-				KubeAPIBurst:              30,
-				LeaderElection: componentconfig.LeaderElectionConfiguration{
-					ResourceLock:  "endpoints",
-					LeaderElect:   true,
-					LeaseDuration: metav1.Duration{Duration: 15 * time.Second},
-					RenewDeadline: metav1.Duration{Duration: 10 * time.Second},
-					RetryPeriod:   metav1.Duration{Duration: 2 * time.Second},
-				},
-				ControllerStartInterval:   metav1.Duration{Duration: 0},
-				RouteReconciliationPeriod: metav1.Duration{Duration: 10 * time.Second},
-				ClusterCIDR:               "",
-				NodeCIDRMaskSize:          24,
-				CIDRAllocatorType:         "",
-				Controllers:               []string{"*"},
 			},
+			PodGCController: &cmoptions.PodGCControllerOptions{
+				TerminatedPodGCThreshold: 12500,
+			},
+			ReplicaSetController: &cmoptions.ReplicaSetControllerOptions{
+				ConcurrentRSSyncs: 5,
+			},
+			ReplicationController: &cmoptions.ReplicationControllerOptions{
+				ConcurrentRCSyncs: 5,
+			},
+			ResourceQuotaController: &cmoptions.ResourceQuotaControllerOptions{
+				ResourceQuotaSyncPeriod:      metav1.Duration{Duration: 5 * time.Minute},
+				ConcurrentResourceQuotaSyncs: 5,
+			},
+			SAController: &cmoptions.SAControllerOptions{
+				ConcurrentSATokenSyncs: 5,
+			},
+			ServiceController: &cmoptions.ServiceControllerOptions{
+				ConcurrentServiceSyncs: 1,
+			},
+			Controllers: []string{"*"},
 			SecureServing: &apiserveroptions.SecureServingOptions{
 				BindPort:    0,
 				BindAddress: net.ParseIP("0.0.0.0"),
@@ -139,6 +183,8 @@ func TestAddFlags(t *testing.T) {
 	args := []string{
 		"--address=192.168.4.10",
 		"--allocate-node-cidrs=true",
+		"--bind-address=192.168.4.21",
+		"--cert-dir=/a/b/c",
 		"--cloud-config=/cloud-config",
 		"--cloud-provider=gce",
 		"--cluster-cidr=1.2.3.4/24",
@@ -163,55 +209,96 @@ func TestAddFlags(t *testing.T) {
 		"--profiling=false",
 		"--node-status-update-frequency=10m",
 		"--route-reconciliation-period=30s",
+		"--secure-port=10001",
 		"--min-resync-period=100m",
 		"--use-service-account-credentials=false",
-		"--cert-dir=/a/b/c",
-		"--bind-address=192.168.4.21",
-		"--secure-port=10001",
 	}
 	f.Parse(args)
 
 	expected := &CloudControllerManagerOptions{
-		Generic: cmoptions.GenericControllerManagerOptions{
+		Generic: &cmoptions.GenericControllerManagerOptions{
-			ComponentConfig: componentconfig.KubeControllerManagerConfiguration{
+			CloudProvider: &cmoptions.CloudProviderOptions{
-				CloudProvider:                                   "gce",
+				Name:            "gce",
-				CloudConfigFile:                                 "/cloud-config",
+				CloudConfigFile: "/cloud-config",
-				Port:                                            10253,     // Note: InsecureServingOptions.ApplyTo will write the flag value back into the component config
+			},
-				Address:                                         "0.0.0.0", // Note: InsecureServingOptions.ApplyTo will write the flag value back into the component config
+			Debugging: &cmoptions.DebuggingOptions{
-				ConcurrentEndpointSyncs:                         5,
+				EnableContentionProfiling: true,
-				ConcurrentRSSyncs:                               5,
+			},
-				ConcurrentResourceQuotaSyncs:                    5,
+			GenericComponent: &cmoptions.GenericComponentConfigOptions{
-				ConcurrentDeploymentSyncs:                       5,
+				MinResyncPeriod:         metav1.Duration{Duration: 100 * time.Minute},
-				ConcurrentDaemonSetSyncs:                        2,
+				ContentType:             "application/vnd.kubernetes.protobuf",
-				ConcurrentJobSyncs:                              5,
+				KubeAPIQPS:              50.0,
-				ConcurrentNamespaceSyncs:                        10,
+				KubeAPIBurst:            100,
-				ConcurrentSATokenSyncs:                          5,
+				ControllerStartInterval: metav1.Duration{Duration: 2 * time.Minute},
-				ConcurrentServiceSyncs:                          1,
+				LeaderElection: componentconfig.LeaderElectionConfiguration{
-				ConcurrentGCSyncs:                               20,
+					ResourceLock:  "configmap",
-				ConcurrentRCSyncs:                               5,
+					LeaderElect:   false,
-				MinResyncPeriod:                                 metav1.Duration{Duration: 100 * time.Minute},
+					LeaseDuration: metav1.Duration{Duration: 30 * time.Second},
-				NodeMonitorPeriod:                               metav1.Duration{Duration: 5 * time.Second},
+					RenewDeadline: metav1.Duration{Duration: 15 * time.Second},
-				ResourceQuotaSyncPeriod:                         metav1.Duration{Duration: 5 * time.Minute},
+					RetryPeriod:   metav1.Duration{Duration: 5 * time.Second},
-				NamespaceSyncPeriod:                             metav1.Duration{Duration: 5 * time.Minute},
+				},
-				PVClaimBinderSyncPeriod:                         metav1.Duration{Duration: 15 * time.Second},
+			},
+			KubeCloudShared: &cmoptions.KubeCloudSharedOptions{
+				Port:                      10253,     // Note: InsecureServingOptions.ApplyTo will write the flag value back into the component config
+				Address:                   "0.0.0.0", // Note: InsecureServingOptions.ApplyTo will write the flag value back into the component config
+				RouteReconciliationPeriod: metav1.Duration{Duration: 30 * time.Second},
+				NodeMonitorPeriod:         metav1.Duration{Duration: 5 * time.Second},
+				ClusterName:               "k8s",
+				ClusterCIDR:               "1.2.3.4/24",
+				AllocateNodeCIDRs:         true,
+				CIDRAllocatorType:         "RangeAllocator",
+				ConfigureCloudRoutes:      false,
+			},
+			AttachDetachController: &cmoptions.AttachDetachControllerOptions{
+				ReconcilerSyncLoopPeriod: metav1.Duration{Duration: 1 * time.Minute},
+			},
+			CSRSigningController: &cmoptions.CSRSigningControllerOptions{
+				ClusterSigningCertFile: "/etc/kubernetes/ca/ca.pem",
+				ClusterSigningKeyFile:  "/etc/kubernetes/ca/ca.key",
+				ClusterSigningDuration: metav1.Duration{Duration: 8760 * time.Hour},
+			},
+			DaemonSetController: &cmoptions.DaemonSetControllerOptions{
+				ConcurrentDaemonSetSyncs: 2,
+			},
+			DeploymentController: &cmoptions.DeploymentControllerOptions{
+				ConcurrentDeploymentSyncs:      5,
+				DeploymentControllerSyncPeriod: metav1.Duration{Duration: 30 * time.Second},
+			},
+			DeprecatedFlags: &cmoptions.DeprecatedControllerOptions{
+				RegisterRetryCount: 10,
+			},
+			EndPointController: &cmoptions.EndPointControllerOptions{
+				ConcurrentEndpointSyncs: 5,
+			},
+			GarbageCollectorController: &cmoptions.GarbageCollectorControllerOptions{
+				ConcurrentGCSyncs:      20,
+				EnableGarbageCollector: true,
+			},
+			HPAController: &cmoptions.HPAControllerOptions{
 				HorizontalPodAutoscalerSyncPeriod:               metav1.Duration{Duration: 30 * time.Second},
 				HorizontalPodAutoscalerUpscaleForbiddenWindow:   metav1.Duration{Duration: 3 * time.Minute},
 				HorizontalPodAutoscalerDownscaleForbiddenWindow: metav1.Duration{Duration: 5 * time.Minute},
 				HorizontalPodAutoscalerTolerance:                0.1,
-				DeploymentControllerSyncPeriod:                  metav1.Duration{Duration: 30 * time.Second},
-				PodEvictionTimeout:                              metav1.Duration{Duration: 5 * time.Minute},
-				NodeMonitorGracePeriod:                          metav1.Duration{Duration: 40 * time.Second},
-				NodeStartupGracePeriod:                          metav1.Duration{Duration: 1 * time.Minute},
-				ClusterSigningDuration:                          metav1.Duration{Duration: 8760 * time.Hour},
-				ReconcilerSyncLoopPeriod:                        metav1.Duration{Duration: 1 * time.Minute},
-				TerminatedPodGCThreshold:                        12500,
-				RegisterRetryCount:                              10,
-				ClusterName:                                     "k8s",
-				ConfigureCloudRoutes:                            false,
-				AllocateNodeCIDRs:                               true,
-				EnableGarbageCollector:                          true,
-				EnableTaintManager:                              true,
 				HorizontalPodAutoscalerUseRESTClients:           true,
+			},
+			JobController: &cmoptions.JobControllerOptions{
+				ConcurrentJobSyncs: 5,
+			},
+			NamespaceController: &cmoptions.NamespaceControllerOptions{
+				NamespaceSyncPeriod:      metav1.Duration{Duration: 5 * time.Minute},
+				ConcurrentNamespaceSyncs: 10,
+			},
+			NodeIpamController: &cmoptions.NodeIpamControllerOptions{
+				NodeCIDRMaskSize: 24,
+			},
+			NodeLifecycleController: &cmoptions.NodeLifecycleControllerOptions{
+				EnableTaintManager:     true,
+				NodeMonitorGracePeriod: metav1.Duration{Duration: 40 * time.Second},
+				NodeStartupGracePeriod: metav1.Duration{Duration: 1 * time.Minute},
+				PodEvictionTimeout:     metav1.Duration{Duration: 5 * time.Minute},
+			},
+			PersistentVolumeBinderController: &cmoptions.PersistentVolumeBinderControllerOptions{
+				PVClaimBinderSyncPeriod: metav1.Duration{Duration: 15 * time.Second},
 				VolumeConfiguration: componentconfig.VolumeConfiguration{
 					EnableDynamicProvisioning:  true,
 					EnableHostPathProvisioning: false,
@@ -224,26 +311,27 @@ func TestAddFlags(t *testing.T) {
 						IncrementTimeoutHostPath: 30,
 					},
 				},
-				ContentType:               "application/vnd.kubernetes.protobuf",
-				ClusterSigningCertFile:    "/etc/kubernetes/ca/ca.pem",
-				ClusterSigningKeyFile:     "/etc/kubernetes/ca/ca.key",
-				EnableContentionProfiling: true,
-				KubeAPIQPS:                50.0,
-				KubeAPIBurst:              100,
-				LeaderElection: componentconfig.LeaderElectionConfiguration{
-					ResourceLock:  "configmap",
-					LeaderElect:   false,
-					LeaseDuration: metav1.Duration{Duration: 30 * time.Second},
-					RenewDeadline: metav1.Duration{Duration: 15 * time.Second},
-					RetryPeriod:   metav1.Duration{Duration: 5 * time.Second},
-				},
-				ControllerStartInterval:   metav1.Duration{Duration: 2 * time.Minute},
-				RouteReconciliationPeriod: metav1.Duration{Duration: 30 * time.Second},
-				ClusterCIDR:               "1.2.3.4/24",
-				NodeCIDRMaskSize:          24,
-				CIDRAllocatorType:         "RangeAllocator",
-				Controllers:               []string{"*"},
 			},
+			PodGCController: &cmoptions.PodGCControllerOptions{
+				TerminatedPodGCThreshold: 12500,
+			},
+			ReplicaSetController: &cmoptions.ReplicaSetControllerOptions{
+				ConcurrentRSSyncs: 5,
+			},
+			ReplicationController: &cmoptions.ReplicationControllerOptions{
+				ConcurrentRCSyncs: 5,
+			},
+			ResourceQuotaController: &cmoptions.ResourceQuotaControllerOptions{
+				ResourceQuotaSyncPeriod:      metav1.Duration{Duration: 5 * time.Minute},
+				ConcurrentResourceQuotaSyncs: 5,
+			},
+			SAController: &cmoptions.SAControllerOptions{
+				ConcurrentSATokenSyncs: 5,
+			},
+			ServiceController: &cmoptions.ServiceControllerOptions{
+				ConcurrentServiceSyncs: 1,
+			},
+			Controllers: []string{"*"},
 			SecureServing: &apiserveroptions.SecureServingOptions{
 				BindPort:    10001,
 				BindAddress: net.ParseIP("192.168.4.21"),

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

@@ -0,0 +1,61 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package options
+
+import (
+	"github.com/spf13/pflag"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/kubernetes/pkg/apis/componentconfig"
+)
+
+// AttachDetachControllerOptions holds the AttachDetachController options.
+type AttachDetachControllerOptions struct {
+	ReconcilerSyncLoopPeriod          metav1.Duration
+	DisableAttachDetachReconcilerSync bool
+}
+
+// AddFlags adds flags related to AttachDetachController for controller manager to the specified FlagSet.
+func (o *AttachDetachControllerOptions) AddFlags(fs *pflag.FlagSet) {
+	if o == nil {
+		return
+	}
+
+	fs.BoolVar(&o.DisableAttachDetachReconcilerSync, "disable-attach-detach-reconcile-sync", false, "Disable volume attach detach reconciler sync. Disabling this may cause volumes to be mismatched with pods. Use wisely.")
+	fs.DurationVar(&o.ReconcilerSyncLoopPeriod.Duration, "attach-detach-reconcile-sync-period", o.ReconcilerSyncLoopPeriod.Duration, "The reconciler sync wait time between volume attach detach. This duration must be larger than one second, and increasing this value from the default may allow for volumes to be mismatched with pods.")
+}
+
+// ApplyTo fills up AttachDetachController config with options.
+func (o *AttachDetachControllerOptions) ApplyTo(cfg *componentconfig.AttachDetachControllerConfiguration) error {
+	if o == nil {
+		return nil
+	}
+
+	cfg.DisableAttachDetachReconcilerSync = o.DisableAttachDetachReconcilerSync
+	cfg.ReconcilerSyncLoopPeriod = o.ReconcilerSyncLoopPeriod
+
+	return nil
+}
+
+// Validate checks validation of AttachDetachControllerOptions.
+func (o *AttachDetachControllerOptions) Validate() []error {
+	if o == nil {
+		return nil
+	}
+
+	errs := []error{}
+	return errs
+}

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

@@ -0,0 +1,55 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package options
+
+import (
+	"github.com/spf13/pflag"
+	"k8s.io/kubernetes/pkg/apis/componentconfig"
+)
+
+// CloudProviderOptions holds the cloudprovider options.
+type CloudProviderOptions struct {
+	CloudConfigFile string
+	Name            string
+}
+
+// Validate checks validation of cloudprovider options.
+func (s *CloudProviderOptions) Validate() []error {
+	allErrors := []error{}
+	return allErrors
+}
+
+// AddFlags adds flags related to cloudprovider for controller manager to the specified FlagSet.
+func (s *CloudProviderOptions) AddFlags(fs *pflag.FlagSet) {
+	fs.StringVar(&s.Name, "cloud-provider", s.Name,
+		"The provider for cloud services. Empty string for no provider.")
+
+	fs.StringVar(&s.CloudConfigFile, "cloud-config", s.CloudConfigFile,
+		"The path to the cloud provider configuration file. Empty string for no configuration file.")
+}
+
+// ApplyTo fills up cloudprovider config with options.
+func (s *CloudProviderOptions) ApplyTo(cfg *componentconfig.CloudProviderConfiguration) error {
+	if s == nil {
+		return nil
+	}
+
+	cfg.Name = s.Name
+	cfg.CloudConfigFile = s.CloudConfigFile
+
+	return nil
+}

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

@@ -0,0 +1,64 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package options
+
+import (
+	"github.com/spf13/pflag"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/kubernetes/pkg/apis/componentconfig"
+)
+
+// CSRSigningControllerOptions holds the CSRSigningController options.
+type CSRSigningControllerOptions struct {
+	ClusterSigningDuration metav1.Duration
+	ClusterSigningKeyFile  string
+	ClusterSigningCertFile string
+}
+
+// AddFlags adds flags related to CSRSigningController for controller manager to the specified FlagSet.
+func (o *CSRSigningControllerOptions) AddFlags(fs *pflag.FlagSet) {
+	if o == nil {
+		return
+	}
+
+	fs.StringVar(&o.ClusterSigningCertFile, "cluster-signing-cert-file", o.ClusterSigningCertFile, "Filename containing a PEM-encoded X509 CA certificate used to issue cluster-scoped certificates")
+	fs.StringVar(&o.ClusterSigningKeyFile, "cluster-signing-key-file", o.ClusterSigningKeyFile, "Filename containing a PEM-encoded RSA or ECDSA private key used to sign cluster-scoped certificates")
+	fs.DurationVar(&o.ClusterSigningDuration.Duration, "experimental-cluster-signing-duration", o.ClusterSigningDuration.Duration, "The length of duration signed certificates will be given.")
+}
+
+// ApplyTo fills up CSRSigningController config with options.
+func (o *CSRSigningControllerOptions) ApplyTo(cfg *componentconfig.CSRSigningControllerConfiguration) error {
+	if o == nil {
+		return nil
+	}
+
+	cfg.ClusterSigningCertFile = o.ClusterSigningCertFile
+	cfg.ClusterSigningKeyFile = o.ClusterSigningKeyFile
+	cfg.ClusterSigningDuration = o.ClusterSigningDuration
+
+	return nil
+}
+
+// Validate checks validation of CSRSigningControllerOptions.
+func (o *CSRSigningControllerOptions) Validate() []error {
+	if o == nil {
+		return nil
+	}
+
+	errs := []error{}
+	return errs
+}

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

@@ -0,0 +1,55 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package options
+
+import (
+	"github.com/spf13/pflag"
+	"k8s.io/kubernetes/pkg/apis/componentconfig"
+)
+
+// DaemonSetControllerOptions holds the DaemonSetController options.
+type DaemonSetControllerOptions struct {
+	ConcurrentDaemonSetSyncs int32
+}
+
+// AddFlags adds flags related to DaemonSetController for controller manager to the specified FlagSet.
+func (o *DaemonSetControllerOptions) AddFlags(fs *pflag.FlagSet) {
+	if o == nil {
+		return
+	}
+}
+
+// ApplyTo fills up DaemonSetController config with options.
+func (o *DaemonSetControllerOptions) ApplyTo(cfg *componentconfig.DaemonSetControllerConfiguration) error {
+	if o == nil {
+		return nil
+	}
+
+	cfg.ConcurrentDaemonSetSyncs = o.ConcurrentDaemonSetSyncs
+
+	return nil
+}
+
+// Validate checks validation of DaemonSetControllerOptions.
+func (o *DaemonSetControllerOptions) Validate() []error {
+	if o == nil {
+		return nil
+	}
+
+	errs := []error{}
+	return errs
+}

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

@@ -0,0 +1,62 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package options
+
+import (
+	"github.com/spf13/pflag"
+	"k8s.io/kubernetes/pkg/apis/componentconfig"
+)
+
+// DebuggingOptions holds the Debugging options.
+type DebuggingOptions struct {
+	EnableProfiling           bool
+	EnableContentionProfiling bool
+}
+
+// AddFlags adds flags related to debugging for controller manager to the specified FlagSet.
+func (o *DebuggingOptions) AddFlags(fs *pflag.FlagSet) {
+	if o == nil {
+		return
+	}
+
+	fs.BoolVar(&o.EnableProfiling, "profiling", o.EnableProfiling,
+		"Enable profiling via web interface host:port/debug/pprof/")
+	fs.BoolVar(&o.EnableContentionProfiling, "contention-profiling", o.EnableContentionProfiling,
+		"Enable lock contention profiling, if profiling is enabled")
+}
+
+// ApplyTo fills up Debugging config with options.
+func (o *DebuggingOptions) ApplyTo(cfg *componentconfig.DebuggingConfiguration) error {
+	if o == nil {
+		return nil
+	}
+
+	cfg.EnableProfiling = o.EnableProfiling
+	cfg.EnableContentionProfiling = o.EnableContentionProfiling
+
+	return nil
+}
+
+// Validate checks validation of DebuggingOptions.
+func (o *DebuggingOptions) Validate() []error {
+	if o == nil {
+		return nil
+	}
+
+	errs := []error{}
+	return errs
+}

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

@@ -0,0 +1,61 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package options
+
+import (
+	"github.com/spf13/pflag"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/kubernetes/pkg/apis/componentconfig"
+)
+
+// DeploymentControllerOptions holds the DeploymentController options.
+type DeploymentControllerOptions struct {
+	ConcurrentDeploymentSyncs      int32
+	DeploymentControllerSyncPeriod metav1.Duration
+}
+
+// AddFlags adds flags related to DeploymentController for controller manager to the specified FlagSet.
+func (o *DeploymentControllerOptions) AddFlags(fs *pflag.FlagSet) {
+	if o == nil {
+		return
+	}
+
+	fs.Int32Var(&o.ConcurrentDeploymentSyncs, "concurrent-deployment-syncs", o.ConcurrentDeploymentSyncs, "The number of deployment objects that are allowed to sync concurrently. Larger number = more responsive deployments, but more CPU (and network) load")
+	fs.DurationVar(&o.DeploymentControllerSyncPeriod.Duration, "deployment-controller-sync-period", o.DeploymentControllerSyncPeriod.Duration, "Period for syncing the deployments.")
+}
+
+// ApplyTo fills up DeploymentController config with options.
+func (o *DeploymentControllerOptions) ApplyTo(cfg *componentconfig.DeploymentControllerConfiguration) error {
+	if o == nil {
+		return nil
+	}
+
+	cfg.ConcurrentDeploymentSyncs = o.ConcurrentDeploymentSyncs
+	cfg.DeploymentControllerSyncPeriod = o.DeploymentControllerSyncPeriod
+
+	return nil
+}
+
+// Validate checks validation of DeploymentControllerOptions.
+func (o *DeploymentControllerOptions) Validate() []error {
+	if o == nil {
+		return nil
+	}
+
+	errs := []error{}
+	return errs
+}

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

@@ -0,0 +1,67 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package options
+
+import (
+	"github.com/spf13/pflag"
+	"k8s.io/kubernetes/pkg/apis/componentconfig"
+)
+
+// DeprecatedControllerOptions holds the DeprecatedController options, those option are deprecated.
+type DeprecatedControllerOptions struct {
+	DeletingPodsQPS    float32
+	DeletingPodsBurst  int32
+	RegisterRetryCount int32
+}
+
+// AddFlags adds flags related to DeprecatedController for controller manager to the specified FlagSet.
+func (o *DeprecatedControllerOptions) AddFlags(fs *pflag.FlagSet) {
+	if o == nil {
+		return
+	}
+
+	fs.Float32Var(&o.DeletingPodsQPS, "deleting-pods-qps", 0.1, "Number of nodes per second on which pods are deleted in case of node failure.")
+	fs.MarkDeprecated("deleting-pods-qps", "This flag is currently no-op and will be deleted.")
+	fs.Int32Var(&o.DeletingPodsBurst, "deleting-pods-burst", 0, "Number of nodes on which pods are bursty deleted in case of node failure. For more details look into RateLimiter.")
+	fs.MarkDeprecated("deleting-pods-burst", "This flag is currently no-op and will be deleted.")
+	fs.Int32Var(&o.RegisterRetryCount, "register-retry-count", o.RegisterRetryCount, ""+
+		"The number of retries for initial node registration.  Retry interval equals node-sync-period.")
+	fs.MarkDeprecated("register-retry-count", "This flag is currently no-op and will be deleted.")
+}
+
+// ApplyTo fills up DeprecatedController config with options.
+func (o *DeprecatedControllerOptions) ApplyTo(cfg *componentconfig.DeprecatedControllerConfiguration) error {
+	if o == nil {
+		return nil
+	}
+
+	cfg.DeletingPodsQps = o.DeletingPodsQPS
+	cfg.DeletingPodsBurst = o.DeletingPodsBurst
+	cfg.RegisterRetryCount = o.RegisterRetryCount
+
+	return nil
+}
+
+// Validate checks validation of DeprecatedControllerOptions.
+func (o *DeprecatedControllerOptions) Validate() []error {
+	if o == nil {
+		return nil
+	}
+
+	errs := []error{}
+	return errs
+}

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

@@ -0,0 +1,57 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package options
+
+import (
+	"github.com/spf13/pflag"
+	"k8s.io/kubernetes/pkg/apis/componentconfig"
+)
+
+// EndPointControllerOptions holds the EndPointController options.
+type EndPointControllerOptions struct {
+	ConcurrentEndpointSyncs int32
+}
+
+// AddFlags adds flags related to EndPointController for controller manager to the specified FlagSet.
+func (o *EndPointControllerOptions) AddFlags(fs *pflag.FlagSet) {
+	if o == nil {
+		return
+	}
+
+	fs.Int32Var(&o.ConcurrentEndpointSyncs, "concurrent-endpoint-syncs", o.ConcurrentEndpointSyncs, "The number of endpoint syncing operations that will be done concurrently. Larger number = faster endpoint updating, but more CPU (and network) load")
+}
+
+// ApplyTo fills up EndPointController config with options.
+func (o *EndPointControllerOptions) ApplyTo(cfg *componentconfig.EndPointControllerConfiguration) error {
+	if o == nil {
+		return nil
+	}
+
+	cfg.ConcurrentEndpointSyncs = o.ConcurrentEndpointSyncs
+
+	return nil
+}
+
+// Validate checks validation of EndPointControllerOptions.
+func (o *EndPointControllerOptions) Validate() []error {
+	if o == nil {
+		return nil
+	}
+
+	errs := []error{}
+	return errs
+}

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

@@ -0,0 +1,62 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package options
+
+import (
+	"github.com/spf13/pflag"
+	"k8s.io/kubernetes/pkg/apis/componentconfig"
+)
+
+// GarbageCollectorControllerOptions holds the GarbageCollectorController options.
+type GarbageCollectorControllerOptions struct {
+	ConcurrentGCSyncs      int32
+	GCIgnoredResources     []componentconfig.GroupResource
+	EnableGarbageCollector bool
+}
+
+// AddFlags adds flags related to GarbageCollectorController for controller manager to the specified FlagSet.
+func (o *GarbageCollectorControllerOptions) AddFlags(fs *pflag.FlagSet) {
+	if o == nil {
+		return
+	}
+
+	fs.Int32Var(&o.ConcurrentGCSyncs, "concurrent-gc-syncs", o.ConcurrentGCSyncs, "The number of garbage collector workers that are allowed to sync concurrently.")
+	fs.BoolVar(&o.EnableGarbageCollector, "enable-garbage-collector", o.EnableGarbageCollector, "Enables the generic garbage collector. MUST be synced with the corresponding flag of the kube-apiserver.")
+}
+
+// ApplyTo fills up GarbageCollectorController config with options.
+func (o *GarbageCollectorControllerOptions) ApplyTo(cfg *componentconfig.GarbageCollectorControllerConfiguration) error {
+	if o == nil {
+		return nil
+	}
+
+	cfg.ConcurrentGCSyncs = o.ConcurrentGCSyncs
+	cfg.GCIgnoredResources = o.GCIgnoredResources
+	cfg.EnableGarbageCollector = o.EnableGarbageCollector
+
+	return nil
+}
+
+// Validate checks validation of GarbageCollectorController.
+func (o *GarbageCollectorControllerOptions) Validate() []error {
+	if o == nil {
+		return nil
+	}
+
+	errs := []error{}
+	return errs
+}

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

@@ -0,0 +1,75 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package options
+
+import (
+	"github.com/spf13/pflag"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/kubernetes/pkg/apis/componentconfig"
+	"k8s.io/kubernetes/pkg/client/leaderelectionconfig"
+)
+
+// GenericComponentConfigOptions holds the options which are generic.
+type GenericComponentConfigOptions struct {
+	MinResyncPeriod         metav1.Duration
+	ContentType             string
+	KubeAPIQPS              float32
+	KubeAPIBurst            int32
+	ControllerStartInterval metav1.Duration
+	LeaderElection          componentconfig.LeaderElectionConfiguration
+}
+
+// AddFlags adds flags related to generic for controller manager to the specified FlagSet.
+func (o *GenericComponentConfigOptions) AddFlags(fs *pflag.FlagSet) {
+	if o == nil {
+		return
+	}
+
+	fs.DurationVar(&o.MinResyncPeriod.Duration, "min-resync-period", o.MinResyncPeriod.Duration, "The resync period in reflectors will be random between MinResyncPeriod and 2*MinResyncPeriod.")
+	fs.StringVar(&o.ContentType, "kube-api-content-type", o.ContentType, "Content type of requests sent to apiserver.")
+	fs.Float32Var(&o.KubeAPIQPS, "kube-api-qps", o.KubeAPIQPS, "QPS to use while talking with kubernetes apiserver.")
+	fs.Int32Var(&o.KubeAPIBurst, "kube-api-burst", o.KubeAPIBurst, "Burst to use while talking with kubernetes apiserver.")
+	fs.DurationVar(&o.ControllerStartInterval.Duration, "controller-start-interval", o.ControllerStartInterval.Duration, "Interval between starting controller managers.")
+
+	leaderelectionconfig.BindFlags(&o.LeaderElection, fs)
+}
+
+// ApplyTo fills up generic config with options.
+func (o *GenericComponentConfigOptions) ApplyTo(cfg *componentconfig.GenericComponentConfiguration) error {
+	if o == nil {
+		return nil
+	}
+
+	cfg.MinResyncPeriod = o.MinResyncPeriod
+	cfg.ContentType = o.ContentType
+	cfg.KubeAPIQPS = o.KubeAPIQPS
+	cfg.KubeAPIBurst = o.KubeAPIBurst
+	cfg.ControllerStartInterval = o.ControllerStartInterval
+	cfg.LeaderElection = o.LeaderElection
+
+	return nil
+}
+
+// Validate checks validation of GenericOptions.
+func (o *GenericComponentConfigOptions) Validate() []error {
+	if o == nil {
+		return nil
+	}
+
+	errs := []error{}
+	return errs
+}

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

@@ -0,0 +1,70 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package options
+
+import (
+	"github.com/spf13/pflag"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/kubernetes/pkg/apis/componentconfig"
+)
+
+// HPAControllerOptions holds the HPAController options.
+type HPAControllerOptions struct {
+	HorizontalPodAutoscalerUseRESTClients           bool
+	HorizontalPodAutoscalerTolerance                float64
+	HorizontalPodAutoscalerDownscaleForbiddenWindow metav1.Duration
+	HorizontalPodAutoscalerUpscaleForbiddenWindow   metav1.Duration
+	HorizontalPodAutoscalerSyncPeriod               metav1.Duration
+}
+
+// AddFlags adds flags related to HPAController for controller manager to the specified FlagSet.
+func (o *HPAControllerOptions) AddFlags(fs *pflag.FlagSet) {
+	if o == nil {
+		return
+	}
+
+	fs.DurationVar(&o.HorizontalPodAutoscalerSyncPeriod.Duration, "horizontal-pod-autoscaler-sync-period", o.HorizontalPodAutoscalerSyncPeriod.Duration, "The period for syncing the number of pods in horizontal pod autoscaler.")
+	fs.DurationVar(&o.HorizontalPodAutoscalerUpscaleForbiddenWindow.Duration, "horizontal-pod-autoscaler-upscale-delay", o.HorizontalPodAutoscalerUpscaleForbiddenWindow.Duration, "The period since last upscale, before another upscale can be performed in horizontal pod autoscaler.")
+	fs.DurationVar(&o.HorizontalPodAutoscalerDownscaleForbiddenWindow.Duration, "horizontal-pod-autoscaler-downscale-delay", o.HorizontalPodAutoscalerDownscaleForbiddenWindow.Duration, "The period since last downscale, before another downscale can be performed in horizontal pod autoscaler.")
+	fs.Float64Var(&o.HorizontalPodAutoscalerTolerance, "horizontal-pod-autoscaler-tolerance", o.HorizontalPodAutoscalerTolerance, "The minimum change (from 1.0) in the desired-to-actual metrics ratio for the horizontal pod autoscaler to consider scaling.")
+	fs.BoolVar(&o.HorizontalPodAutoscalerUseRESTClients, "horizontal-pod-autoscaler-use-rest-clients", o.HorizontalPodAutoscalerUseRESTClients, "WARNING: alpha feature.  If set to true, causes the horizontal pod autoscaler controller to use REST clients through the kube-aggregator, instead of using the legacy metrics client through the API server proxy.  This is required for custom metrics support in the horizontal pod autoscaler.")
+}
+
+// ApplyTo fills up HPAController config with options.
+func (o *HPAControllerOptions) ApplyTo(cfg *componentconfig.HPAControllerConfiguration) error {
+	if o == nil {
+		return nil
+	}
+
+	cfg.HorizontalPodAutoscalerSyncPeriod = o.HorizontalPodAutoscalerSyncPeriod
+	cfg.HorizontalPodAutoscalerUpscaleForbiddenWindow = o.HorizontalPodAutoscalerUpscaleForbiddenWindow
+	cfg.HorizontalPodAutoscalerDownscaleForbiddenWindow = o.HorizontalPodAutoscalerDownscaleForbiddenWindow
+	cfg.HorizontalPodAutoscalerTolerance = o.HorizontalPodAutoscalerTolerance
+	cfg.HorizontalPodAutoscalerUseRESTClients = o.HorizontalPodAutoscalerUseRESTClients
+
+	return nil
+}
+
+// Validate checks validation of HPAControllerOptions.
+func (o *HPAControllerOptions) Validate() []error {
+	if o == nil {
+		return nil
+	}
+
+	errs := []error{}
+	return errs
+}

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

@@ -82,7 +82,7 @@ func (s *InsecureServingOptions) AddDeprecatedFlags(fs *pflag.FlagSet) {
 
 // ApplyTo adds InsecureServingOptions to the insecureserverinfo amd kube-controller manager configuration.
 // Note: the double pointer allows to set the *InsecureServingInfo to nil without referencing the struct hosting this pointer.
-func (s *InsecureServingOptions) ApplyTo(c **genericcontrollermanager.InsecureServingInfo, cfg *componentconfig.KubeControllerManagerConfiguration) error {
+func (s *InsecureServingOptions) ApplyTo(c **genericcontrollermanager.InsecureServingInfo, cfg *componentconfig.KubeCloudSharedConfiguration) error {
 	if s == nil {
 		return nil
 	}

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

@@ -0,0 +1,55 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package options
+
+import (
+	"github.com/spf13/pflag"
+	"k8s.io/kubernetes/pkg/apis/componentconfig"
+)
+
+// JobControllerOptions holds the JobController options.
+type JobControllerOptions struct {
+	ConcurrentJobSyncs int32
+}
+
+// AddFlags adds flags related to JobController for controller manager to the specified FlagSet.
+func (o *JobControllerOptions) AddFlags(fs *pflag.FlagSet) {
+	if o == nil {
+		return
+	}
+}
+
+// ApplyTo fills up JobController config with options.
+func (o *JobControllerOptions) ApplyTo(cfg *componentconfig.JobControllerConfiguration) error {
+	if o == nil {
+		return nil
+	}
+
+	cfg.ConcurrentJobSyncs = o.ConcurrentJobSyncs
+
+	return nil
+}
+
+// Validate checks validation of JobControllerOptions.
+func (o *JobControllerOptions) Validate() []error {
+	if o == nil {
+		return nil
+	}
+
+	errs := []error{}
+	return errs
+}

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

@@ -0,0 +1,101 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package options
+
+import (
+	"github.com/spf13/pflag"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/kubernetes/pkg/apis/componentconfig"
+)
+
+// KubeCloudSharedOptions holds the options shared between kube-controller-manager
+// and cloud-controller-manager.
+type KubeCloudSharedOptions struct {
+	Port                         int32
+	Address                      string
+	UseServiceAccountCredentials bool
+	AllowUntaggedCloud           bool
+	RouteReconciliationPeriod    metav1.Duration
+	NodeMonitorPeriod            metav1.Duration
+	ClusterName                  string
+	ClusterCIDR                  string
+	AllocateNodeCIDRs            bool
+	CIDRAllocatorType            string
+	ConfigureCloudRoutes         bool
+	ServiceAccountKeyFile        string
+	NodeSyncPeriod               metav1.Duration
+}
+
+// AddFlags adds flags related to shared variable for controller manager to the specified FlagSet.
+func (o *KubeCloudSharedOptions) AddFlags(fs *pflag.FlagSet) {
+	if o == nil {
+		return
+	}
+
+	fs.BoolVar(&o.UseServiceAccountCredentials, "use-service-account-credentials", o.UseServiceAccountCredentials, "If true, use individual service account credentials for each controller.")
+	fs.BoolVar(&o.AllowUntaggedCloud, "allow-untagged-cloud", false, "Allow the cluster to run without the cluster-id on cloud instances. This is a legacy mode of operation and a cluster-id will be required in the future.")
+	fs.MarkDeprecated("allow-untagged-cloud", "This flag is deprecated and will be removed in a future release. A cluster-id will be required on cloud instances.")
+	fs.DurationVar(&o.RouteReconciliationPeriod.Duration, "route-reconciliation-period", o.RouteReconciliationPeriod.Duration, "The period for reconciling routes created for Nodes by cloud provider.")
+	fs.DurationVar(&o.NodeMonitorPeriod.Duration, "node-monitor-period", o.NodeMonitorPeriod.Duration,
+		"The period for syncing NodeStatus in NodeController.")
+	fs.StringVar(&o.ClusterName, "cluster-name", o.ClusterName, "The instance prefix for the cluster.")
+	fs.StringVar(&o.ClusterCIDR, "cluster-cidr", o.ClusterCIDR, "CIDR Range for Pods in cluster. Requires --allocate-node-cidrs to be true")
+	fs.BoolVar(&o.AllocateNodeCIDRs, "allocate-node-cidrs", false, "Should CIDRs for Pods be allocated and set on the cloud provider.")
+	fs.StringVar(&o.CIDRAllocatorType, "cidr-allocator-type", "RangeAllocator", "Type of CIDR allocator to use")
+	fs.BoolVar(&o.ConfigureCloudRoutes, "configure-cloud-routes", true, "Should CIDRs allocated by allocate-node-cidrs be configured on the cloud provider.")
+
+	// TODO: remove --service-account-private-key-file 6 months after 1.8 is released (~1.10)
+	fs.StringVar(&o.ServiceAccountKeyFile, "service-account-private-key-file", o.ServiceAccountKeyFile, "Filename containing a PEM-encoded private RSA or ECDSA key used to sign service account tokens.")
+	fs.MarkDeprecated("service-account-private-key-file", "This flag is currently no-op and will be deleted.")
+	fs.DurationVar(&o.NodeSyncPeriod.Duration, "node-sync-period", 0, ""+
+		"This flag is deprecated and will be removed in future releases. See node-monitor-period for Node health checking or "+
+		"route-reconciliation-period for cloud provider's route configuration settings.")
+	fs.MarkDeprecated("node-sync-period", "This flag is currently no-op and will be deleted.")
+}
+
+// ApplyTo fills up KubeCloudShared config with options.
+func (o *KubeCloudSharedOptions) ApplyTo(cfg *componentconfig.KubeCloudSharedConfiguration) error {
+	if o == nil {
+		return nil
+	}
+
+	cfg.Port = o.Port
+	cfg.Address = o.Address
+	cfg.UseServiceAccountCredentials = o.UseServiceAccountCredentials
+	cfg.AllowUntaggedCloud = o.AllowUntaggedCloud
+	cfg.RouteReconciliationPeriod = o.RouteReconciliationPeriod
+	cfg.NodeMonitorPeriod = o.NodeMonitorPeriod
+	cfg.ClusterName = o.ClusterName
+	cfg.ClusterCIDR = o.ClusterCIDR
+	cfg.AllocateNodeCIDRs = o.AllocateNodeCIDRs
+	cfg.CIDRAllocatorType = o.CIDRAllocatorType
+	cfg.ConfigureCloudRoutes = o.ConfigureCloudRoutes
+	cfg.ServiceAccountKeyFile = o.ServiceAccountKeyFile
+	cfg.NodeSyncPeriod = o.NodeSyncPeriod
+
+	return nil
+}
+
+// Validate checks validation of KubeCloudSharedOptions.
+func (o *KubeCloudSharedOptions) Validate() []error {
+	if o == nil {
+		return nil
+	}
+
+	errs := []error{}
+	return errs
+}

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

@@ -0,0 +1,61 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package options
+
+import (
+	"github.com/spf13/pflag"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/kubernetes/pkg/apis/componentconfig"
+)
+
+// NamespaceControllerOptions holds the NamespaceController options.
+type NamespaceControllerOptions struct {
+	NamespaceSyncPeriod      metav1.Duration
+	ConcurrentNamespaceSyncs int32
+}
+
+// AddFlags adds flags related to NamespaceController for controller manager to the specified FlagSet.
+func (o *NamespaceControllerOptions) AddFlags(fs *pflag.FlagSet) {
+	if o == nil {
+		return
+	}
+
+	fs.DurationVar(&o.NamespaceSyncPeriod.Duration, "namespace-sync-period", o.NamespaceSyncPeriod.Duration, "The period for syncing namespace life-cycle updates")
+	fs.Int32Var(&o.ConcurrentNamespaceSyncs, "concurrent-namespace-syncs", o.ConcurrentNamespaceSyncs, "The number of namespace objects that are allowed to sync concurrently. Larger number = more responsive namespace termination, but more CPU (and network) load")
+}
+
+// ApplyTo fills up NamespaceController config with options.
+func (o *NamespaceControllerOptions) ApplyTo(cfg *componentconfig.NamespaceControllerConfiguration) error {
+	if o == nil {
+		return nil
+	}
+
+	cfg.NamespaceSyncPeriod = o.NamespaceSyncPeriod
+	cfg.ConcurrentNamespaceSyncs = o.ConcurrentNamespaceSyncs
+
+	return nil
+}
+
+// Validate checks validation of NamespaceControllerOptions.
+func (o *NamespaceControllerOptions) Validate() []error {
+	if o == nil {
+		return nil
+	}
+
+	errs := []error{}
+	return errs
+}

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

@@ -0,0 +1,60 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package options
+
+import (
+	"github.com/spf13/pflag"
+	"k8s.io/kubernetes/pkg/apis/componentconfig"
+)
+
+// NodeIpamControllerOptions holds the NodeIpamController options.
+type NodeIpamControllerOptions struct {
+	ServiceCIDR      string
+	NodeCIDRMaskSize int32
+}
+
+// AddFlags adds flags related to NodeIpamController for controller manager to the specified FlagSet.
+func (o *NodeIpamControllerOptions) AddFlags(fs *pflag.FlagSet) {
+	if o == nil {
+		return
+	}
+
+	fs.StringVar(&o.ServiceCIDR, "service-cluster-ip-range", o.ServiceCIDR, "CIDR Range for Services in cluster. Requires --allocate-node-cidrs to be true")
+	fs.Int32Var(&o.NodeCIDRMaskSize, "node-cidr-mask-size", o.NodeCIDRMaskSize, "Mask size for node cidr in cluster.")
+}
+
+// ApplyTo fills up NodeIpamController config with options.
+func (o *NodeIpamControllerOptions) ApplyTo(cfg *componentconfig.NodeIpamControllerConfiguration) error {
+	if o == nil {
+		return nil
+	}
+
+	cfg.ServiceCIDR = o.ServiceCIDR
+	cfg.NodeCIDRMaskSize = o.NodeCIDRMaskSize
+
+	return nil
+}
+
+// Validate checks validation of NodeIpamControllerOptions.
+func (o *NodeIpamControllerOptions) Validate() []error {
+	if o == nil {
+		return nil
+	}
+
+	errs := []error{}
+	return errs
+}

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

@@ -0,0 +1,83 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package options
+
+import (
+	"github.com/spf13/pflag"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/kubernetes/pkg/apis/componentconfig"
+)
+
+// NodeLifecycleControllerOptions holds the NodeLifecycleController options.
+type NodeLifecycleControllerOptions struct {
+	EnableTaintManager        bool
+	NodeEvictionRate          float32
+	SecondaryNodeEvictionRate float32
+	NodeStartupGracePeriod    metav1.Duration
+	NodeMonitorGracePeriod    metav1.Duration
+	PodEvictionTimeout        metav1.Duration
+	LargeClusterSizeThreshold int32
+	UnhealthyZoneThreshold    float32
+}
+
+// AddFlags adds flags related to NodeLifecycleController for controller manager to the specified FlagSet.
+func (o *NodeLifecycleControllerOptions) AddFlags(fs *pflag.FlagSet) {
+	if o == nil {
+		return
+	}
+
+	fs.DurationVar(&o.NodeStartupGracePeriod.Duration, "node-startup-grace-period", o.NodeStartupGracePeriod.Duration,
+		"Amount of time which we allow starting Node to be unresponsive before marking it unhealthy.")
+	fs.DurationVar(&o.NodeMonitorGracePeriod.Duration, "node-monitor-grace-period", o.NodeMonitorGracePeriod.Duration,
+		"Amount of time which we allow running Node to be unresponsive before marking it unhealthy. "+
+			"Must be N times more than kubelet's nodeStatusUpdateFrequency, "+
+			"where N means number of retries allowed for kubelet to post node status.")
+	fs.DurationVar(&o.PodEvictionTimeout.Duration, "pod-eviction-timeout", o.PodEvictionTimeout.Duration, "The grace period for deleting pods on failed nodes.")
+	fs.Float32Var(&o.NodeEvictionRate, "node-eviction-rate", 0.1, "Number of nodes per second on which pods are deleted in case of node failure when a zone is healthy (see --unhealthy-zone-threshold for definition of healthy/unhealthy). Zone refers to entire cluster in non-multizone clusters.")
+	fs.Float32Var(&o.SecondaryNodeEvictionRate, "secondary-node-eviction-rate", 0.01, "Number of nodes per second on which pods are deleted in case of node failure when a zone is unhealthy (see --unhealthy-zone-threshold for definition of healthy/unhealthy). Zone refers to entire cluster in non-multizone clusters. This value is implicitly overridden to 0 if the cluster size is smaller than --large-cluster-size-threshold.")
+	fs.Int32Var(&o.LargeClusterSizeThreshold, "large-cluster-size-threshold", 50, "Number of nodes from which NodeController treats the cluster as large for the eviction logic purposes. --secondary-node-eviction-rate is implicitly overridden to 0 for clusters this size or smaller.")
+	fs.Float32Var(&o.UnhealthyZoneThreshold, "unhealthy-zone-threshold", 0.55, "Fraction of Nodes in a zone which needs to be not Ready (minimum 3) for zone to be treated as unhealthy. ")
+	fs.BoolVar(&o.EnableTaintManager, "enable-taint-manager", o.EnableTaintManager, "WARNING: Beta feature. If set to true enables NoExecute Taints and will evict all not-tolerating Pod running on Nodes tainted with this kind of Taints.")
+}
+
+// ApplyTo fills up NodeLifecycleController config with options.
+func (o *NodeLifecycleControllerOptions) ApplyTo(cfg *componentconfig.NodeLifecycleControllerConfiguration) error {
+	if o == nil {
+		return nil
+	}
+
+	cfg.EnableTaintManager = o.EnableTaintManager
+	cfg.NodeStartupGracePeriod = o.NodeStartupGracePeriod
+	cfg.NodeMonitorGracePeriod = o.NodeMonitorGracePeriod
+	cfg.PodEvictionTimeout = o.PodEvictionTimeout
+	cfg.NodeEvictionRate = o.NodeEvictionRate
+	cfg.SecondaryNodeEvictionRate = o.SecondaryNodeEvictionRate
+	cfg.LargeClusterSizeThreshold = o.LargeClusterSizeThreshold
+	cfg.UnhealthyZoneThreshold = o.UnhealthyZoneThreshold
+
+	return nil
+}
+
+// Validate checks validation of NodeLifecycleControllerOptions.
+func (o *NodeLifecycleControllerOptions) Validate() []error {
+	if o == nil {
+		return nil
+	}
+
+	errs := []error{}
+	return errs
+}

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

@@ -40,8 +40,33 @@ import (
 // GenericControllerManagerOptions is the common structure for a controller manager. It works with NewGenericControllerManagerOptions
 // and AddDefaultControllerFlags to create the common components of kube-controller-manager and cloud-controller-manager.
 type GenericControllerManagerOptions struct {
-	// TODO: turn ComponentConfig into modular option structs. This is not generic.
+	CloudProvider    *CloudProviderOptions
-	ComponentConfig componentconfig.KubeControllerManagerConfiguration
+	Debugging        *DebuggingOptions
+	GenericComponent *GenericComponentConfigOptions
+	KubeCloudShared  *KubeCloudSharedOptions
+
+	AttachDetachController           *AttachDetachControllerOptions
+	CSRSigningController             *CSRSigningControllerOptions
+	DaemonSetController              *DaemonSetControllerOptions
+	DeploymentController             *DeploymentControllerOptions
+	DeprecatedFlags                  *DeprecatedControllerOptions
+	EndPointController               *EndPointControllerOptions
+	GarbageCollectorController       *GarbageCollectorControllerOptions
+	HPAController                    *HPAControllerOptions
+	JobController                    *JobControllerOptions
+	NamespaceController              *NamespaceControllerOptions
+	NodeIpamController               *NodeIpamControllerOptions
+	NodeLifecycleController          *NodeLifecycleControllerOptions
+	PersistentVolumeBinderController *PersistentVolumeBinderControllerOptions
+	PodGCController                  *PodGCControllerOptions
+	ReplicaSetController             *ReplicaSetControllerOptions
+	ReplicationController            *ReplicationControllerOptions
+	ResourceQuotaController          *ResourceQuotaControllerOptions
+	SAController                     *SAControllerOptions
+	ServiceController                *ServiceControllerOptions
+
+	Controllers               []string
+	ExternalCloudVolumePlugin string
 
 	SecureServing *apiserveroptions.SecureServingOptions
 	// TODO: remove insecure serving mode
@@ -66,13 +91,102 @@ const (
 // NewGenericControllerManagerOptions returns common/default configuration values for both
 // the kube-controller-manager and the cloud-contoller-manager. Any common changes should
 // be made here. Any individual changes should be made in that controller.
-func NewGenericControllerManagerOptions(componentConfig componentconfig.KubeControllerManagerConfiguration) GenericControllerManagerOptions {
+func NewGenericControllerManagerOptions(componentConfig componentconfig.KubeControllerManagerConfiguration) *GenericControllerManagerOptions {
-	o := GenericControllerManagerOptions{
+	o := &GenericControllerManagerOptions{
-		ComponentConfig: componentConfig,
+		CloudProvider: &CloudProviderOptions{},
-		SecureServing:   apiserveroptions.NewSecureServingOptions(),
+		Debugging:     &DebuggingOptions{},
+		GenericComponent: &GenericComponentConfigOptions{
+			MinResyncPeriod:         componentConfig.GenericComponent.MinResyncPeriod,
+			ContentType:             componentConfig.GenericComponent.ContentType,
+			KubeAPIQPS:              componentConfig.GenericComponent.KubeAPIQPS,
+			KubeAPIBurst:            componentConfig.GenericComponent.KubeAPIBurst,
+			ControllerStartInterval: componentConfig.GenericComponent.ControllerStartInterval,
+			LeaderElection:          componentConfig.GenericComponent.LeaderElection,
+		},
+		KubeCloudShared: &KubeCloudSharedOptions{
+			Port:                      componentConfig.KubeCloudShared.Port,
+			Address:                   componentConfig.KubeCloudShared.Address,
+			RouteReconciliationPeriod: componentConfig.KubeCloudShared.RouteReconciliationPeriod,
+			NodeMonitorPeriod:         componentConfig.KubeCloudShared.NodeMonitorPeriod,
+			ClusterName:               componentConfig.KubeCloudShared.ClusterName,
+			ConfigureCloudRoutes:      componentConfig.KubeCloudShared.ConfigureCloudRoutes,
+		},
+		AttachDetachController: &AttachDetachControllerOptions{
+			ReconcilerSyncLoopPeriod: componentConfig.AttachDetachController.ReconcilerSyncLoopPeriod,
+		},
+		CSRSigningController: &CSRSigningControllerOptions{
+			ClusterSigningCertFile: componentConfig.CSRSigningController.ClusterSigningCertFile,
+			ClusterSigningKeyFile:  componentConfig.CSRSigningController.ClusterSigningKeyFile,
+			ClusterSigningDuration: componentConfig.CSRSigningController.ClusterSigningDuration,
+		},
+		DaemonSetController: &DaemonSetControllerOptions{
+			ConcurrentDaemonSetSyncs: componentConfig.DaemonSetController.ConcurrentDaemonSetSyncs,
+		},
+		DeploymentController: &DeploymentControllerOptions{
+			ConcurrentDeploymentSyncs:      componentConfig.DeploymentController.ConcurrentDeploymentSyncs,
+			DeploymentControllerSyncPeriod: componentConfig.DeploymentController.DeploymentControllerSyncPeriod,
+		},
+		DeprecatedFlags: &DeprecatedControllerOptions{
+			RegisterRetryCount: componentConfig.DeprecatedController.RegisterRetryCount,
+		},
+		EndPointController: &EndPointControllerOptions{
+			ConcurrentEndpointSyncs: componentConfig.EndPointController.ConcurrentEndpointSyncs,
+		},
+		GarbageCollectorController: &GarbageCollectorControllerOptions{
+			ConcurrentGCSyncs:      componentConfig.GarbageCollectorController.ConcurrentGCSyncs,
+			EnableGarbageCollector: componentConfig.GarbageCollectorController.EnableGarbageCollector,
+		},
+		HPAController: &HPAControllerOptions{
+			HorizontalPodAutoscalerSyncPeriod:               componentConfig.HPAController.HorizontalPodAutoscalerSyncPeriod,
+			HorizontalPodAutoscalerUpscaleForbiddenWindow:   componentConfig.HPAController.HorizontalPodAutoscalerUpscaleForbiddenWindow,
+			HorizontalPodAutoscalerDownscaleForbiddenWindow: componentConfig.HPAController.HorizontalPodAutoscalerDownscaleForbiddenWindow,
+			HorizontalPodAutoscalerTolerance:                componentConfig.HPAController.HorizontalPodAutoscalerTolerance,
+			HorizontalPodAutoscalerUseRESTClients:           componentConfig.HPAController.HorizontalPodAutoscalerUseRESTClients,
+		},
+		JobController: &JobControllerOptions{
+			ConcurrentJobSyncs: componentConfig.JobController.ConcurrentJobSyncs,
+		},
+		NamespaceController: &NamespaceControllerOptions{
+			NamespaceSyncPeriod:      componentConfig.NamespaceController.NamespaceSyncPeriod,
+			ConcurrentNamespaceSyncs: componentConfig.NamespaceController.ConcurrentNamespaceSyncs,
+		},
+		NodeIpamController: &NodeIpamControllerOptions{
+			NodeCIDRMaskSize: componentConfig.NodeIpamController.NodeCIDRMaskSize,
+		},
+		NodeLifecycleController: &NodeLifecycleControllerOptions{
+			EnableTaintManager:     componentConfig.NodeLifecycleController.EnableTaintManager,
+			NodeMonitorGracePeriod: componentConfig.NodeLifecycleController.NodeMonitorGracePeriod,
+			NodeStartupGracePeriod: componentConfig.NodeLifecycleController.NodeStartupGracePeriod,
+			PodEvictionTimeout:     componentConfig.NodeLifecycleController.PodEvictionTimeout,
+		},
+		PersistentVolumeBinderController: &PersistentVolumeBinderControllerOptions{
+			PVClaimBinderSyncPeriod: componentConfig.PersistentVolumeBinderController.PVClaimBinderSyncPeriod,
+			VolumeConfiguration:     componentConfig.PersistentVolumeBinderController.VolumeConfiguration,
+		},
+		PodGCController: &PodGCControllerOptions{
+			TerminatedPodGCThreshold: componentConfig.PodGCController.TerminatedPodGCThreshold,
+		},
+		ReplicaSetController: &ReplicaSetControllerOptions{
+			ConcurrentRSSyncs: componentConfig.ReplicaSetController.ConcurrentRSSyncs,
+		},
+		ReplicationController: &ReplicationControllerOptions{
+			ConcurrentRCSyncs: componentConfig.ReplicationController.ConcurrentRCSyncs,
+		},
+		ResourceQuotaController: &ResourceQuotaControllerOptions{
+			ResourceQuotaSyncPeriod:      componentConfig.ResourceQuotaController.ResourceQuotaSyncPeriod,
+			ConcurrentResourceQuotaSyncs: componentConfig.ResourceQuotaController.ConcurrentResourceQuotaSyncs,
+		},
+		SAController: &SAControllerOptions{
+			ConcurrentSATokenSyncs: componentConfig.SAController.ConcurrentSATokenSyncs,
+		},
+		ServiceController: &ServiceControllerOptions{
+			ConcurrentServiceSyncs: componentConfig.ServiceController.ConcurrentServiceSyncs,
+		},
+		Controllers:   componentConfig.Controllers,
+		SecureServing: apiserveroptions.NewSecureServingOptions(),
 		InsecureServing: &InsecureServingOptions{
-			BindAddress: net.ParseIP(componentConfig.Address),
+			BindAddress: net.ParseIP(componentConfig.KubeCloudShared.Address),
-			BindPort:    int(componentConfig.Port),
+			BindPort:    int(componentConfig.KubeCloudShared.Port),
 			BindNetwork: "tcp",
 		},
 		Authentication: nil, // TODO: enable with apiserveroptions.NewDelegatingAuthenticationOptions()
@@ -94,35 +208,21 @@ func NewDefaultControllerManagerComponentConfig(insecurePort int32) componentcon
 	scheme.Default(&versioned)
 	internal := componentconfig.KubeControllerManagerConfiguration{}
 	scheme.Convert(&versioned, &internal, nil)
-	internal.Port = insecurePort
+	internal.KubeCloudShared.Port = insecurePort
 	return internal
 }
 
 // AddFlags adds common/default flags for both the kube and cloud Controller Manager Server to the
 // specified FlagSet. Any common changes should be made here. Any individual changes should be made in that controller.
 func (o *GenericControllerManagerOptions) AddFlags(fs *pflag.FlagSet) {
-	fs.BoolVar(&o.ComponentConfig.UseServiceAccountCredentials, "use-service-account-credentials", o.ComponentConfig.UseServiceAccountCredentials, "If true, use individual service account credentials for each controller.")
+
-	fs.StringVar(&o.ComponentConfig.CloudConfigFile, "cloud-config", o.ComponentConfig.CloudConfigFile, "The path to the cloud provider configuration file. Empty string for no configuration file.")
-	fs.BoolVar(&o.ComponentConfig.AllowUntaggedCloud, "allow-untagged-cloud", false, "Allow the cluster to run without the cluster-id on cloud instances. This is a legacy mode of operation and a cluster-id will be required in the future.")
-	fs.MarkDeprecated("allow-untagged-cloud", "This flag is deprecated and will be removed in a future release. A cluster-id will be required on cloud instances.")
-	fs.DurationVar(&o.ComponentConfig.RouteReconciliationPeriod.Duration, "route-reconciliation-period", o.ComponentConfig.RouteReconciliationPeriod.Duration, "The period for reconciling routes created for Nodes by cloud provider.")
-	fs.DurationVar(&o.ComponentConfig.MinResyncPeriod.Duration, "min-resync-period", o.ComponentConfig.MinResyncPeriod.Duration, "The resync period in reflectors will be random between MinResyncPeriod and 2*MinResyncPeriod.")
-	fs.DurationVar(&o.ComponentConfig.NodeMonitorPeriod.Duration, "node-monitor-period", o.ComponentConfig.NodeMonitorPeriod.Duration,
-		"The period for syncing NodeStatus in NodeController.")
-	fs.BoolVar(&o.ComponentConfig.EnableProfiling, "profiling", true, "Enable profiling via web interface host:port/debug/pprof/")
-	fs.BoolVar(&o.ComponentConfig.EnableContentionProfiling, "contention-profiling", false, "Enable lock contention profiling, if profiling is enabled.")
-	fs.StringVar(&o.ComponentConfig.ClusterName, "cluster-name", o.ComponentConfig.ClusterName, "The instance prefix for the cluster.")
-	fs.StringVar(&o.ComponentConfig.ClusterCIDR, "cluster-cidr", o.ComponentConfig.ClusterCIDR, "CIDR Range for Pods in cluster. Requires --allocate-node-cidrs to be true")
-	fs.BoolVar(&o.ComponentConfig.AllocateNodeCIDRs, "allocate-node-cidrs", false, "Should CIDRs for Pods be allocated and set on the cloud provider.")
-	fs.StringVar(&o.ComponentConfig.CIDRAllocatorType, "cidr-allocator-type", "RangeAllocator", "Type of CIDR allocator to use")
-	fs.BoolVar(&o.ComponentConfig.ConfigureCloudRoutes, "configure-cloud-routes", true, "Should CIDRs allocated by allocate-node-cidrs be configured on the cloud provider.")
 	fs.StringVar(&o.Master, "master", o.Master, "The address of the Kubernetes API server (overrides any value in kubeconfig).")
 	fs.StringVar(&o.Kubeconfig, "kubeconfig", o.Kubeconfig, "Path to kubeconfig file with authorization and master location information.")
-	fs.StringVar(&o.ComponentConfig.ContentType, "kube-api-content-type", o.ComponentConfig.ContentType, "Content type of requests sent to apiserver.")
+	o.CloudProvider.AddFlags(fs)
-	fs.Float32Var(&o.ComponentConfig.KubeAPIQPS, "kube-api-qps", o.ComponentConfig.KubeAPIQPS, "QPS to use while talking with kubernetes apiserver.")
+	o.Debugging.AddFlags(fs)
-	fs.Int32Var(&o.ComponentConfig.KubeAPIBurst, "kube-api-burst", o.ComponentConfig.KubeAPIBurst, "Burst to use while talking with kubernetes apiserver.")
+	o.GenericComponent.AddFlags(fs)
-	fs.DurationVar(&o.ComponentConfig.ControllerStartInterval.Duration, "controller-start-interval", o.ComponentConfig.ControllerStartInterval.Duration, "Interval between starting controller managers.")
+	o.KubeCloudShared.AddFlags(fs)
-
+	o.ServiceController.AddFlags(fs)
 	o.SecureServing.AddFlags(fs)
 	o.InsecureServing.AddFlags(fs)
 	o.InsecureServing.AddDeprecatedFlags(fs)
@@ -132,12 +232,79 @@ func (o *GenericControllerManagerOptions) AddFlags(fs *pflag.FlagSet) {
 
 // ApplyTo fills up controller manager config with options and userAgent
 func (o *GenericControllerManagerOptions) ApplyTo(c *genericcontrollermanager.Config, userAgent string) error {
-	c.ComponentConfig = o.ComponentConfig
+	if err := o.CloudProvider.ApplyTo(&c.ComponentConfig.CloudProvider); err != nil {
-
+		return err
+	}
+	if err := o.Debugging.ApplyTo(&c.ComponentConfig.Debugging); err != nil {
+		return err
+	}
+	if err := o.GenericComponent.ApplyTo(&c.ComponentConfig.GenericComponent); err != nil {
+		return err
+	}
+	if err := o.KubeCloudShared.ApplyTo(&c.ComponentConfig.KubeCloudShared); err != nil {
+		return err
+	}
+	if err := o.AttachDetachController.ApplyTo(&c.ComponentConfig.AttachDetachController); err != nil {
+		return err
+	}
+	if err := o.CSRSigningController.ApplyTo(&c.ComponentConfig.CSRSigningController); err != nil {
+		return err
+	}
+	if err := o.DaemonSetController.ApplyTo(&c.ComponentConfig.DaemonSetController); err != nil {
+		return err
+	}
+	if err := o.DeploymentController.ApplyTo(&c.ComponentConfig.DeploymentController); err != nil {
+		return err
+	}
+	if err := o.DeprecatedFlags.ApplyTo(&c.ComponentConfig.DeprecatedController); err != nil {
+		return err
+	}
+	if err := o.EndPointController.ApplyTo(&c.ComponentConfig.EndPointController); err != nil {
+		return err
+	}
+	if err := o.GarbageCollectorController.ApplyTo(&c.ComponentConfig.GarbageCollectorController); err != nil {
+		return err
+	}
+	if err := o.HPAController.ApplyTo(&c.ComponentConfig.HPAController); err != nil {
+		return err
+	}
+	if err := o.JobController.ApplyTo(&c.ComponentConfig.JobController); err != nil {
+		return err
+	}
+	if err := o.NamespaceController.ApplyTo(&c.ComponentConfig.NamespaceController); err != nil {
+		return err
+	}
+	if err := o.NodeIpamController.ApplyTo(&c.ComponentConfig.NodeIpamController); err != nil {
+		return err
+	}
+	if err := o.NodeLifecycleController.ApplyTo(&c.ComponentConfig.NodeLifecycleController); err != nil {
+		return err
+	}
+	if err := o.PersistentVolumeBinderController.ApplyTo(&c.ComponentConfig.PersistentVolumeBinderController); err != nil {
+		return err
+	}
+	if err := o.PodGCController.ApplyTo(&c.ComponentConfig.PodGCController); err != nil {
+		return err
+	}
+	if err := o.ReplicaSetController.ApplyTo(&c.ComponentConfig.ReplicaSetController); err != nil {
+		return err
+	}
+	if err := o.ReplicationController.ApplyTo(&c.ComponentConfig.ReplicationController); err != nil {
+		return err
+	}
+	if err := o.ResourceQuotaController.ApplyTo(&c.ComponentConfig.ResourceQuotaController); err != nil {
+		return err
+	}
+	if err := o.SAController.ApplyTo(&c.ComponentConfig.SAController); err != nil {
+		return err
+	}
+	if err := o.ServiceController.ApplyTo(&c.ComponentConfig.ServiceController); err != nil {
+		return err
+	}
 	if err := o.SecureServing.ApplyTo(&c.SecureServing); err != nil {
 		return err
 	}
-	if err := o.InsecureServing.ApplyTo(&c.InsecureServing, &c.ComponentConfig); err != nil {
+	if err := o.InsecureServing.ApplyTo(&c.InsecureServing, &c.ComponentConfig.KubeCloudShared); err != nil {
 		return err
 	}
 	if err := o.Authentication.ApplyTo(&c.Authentication, c.SecureServing, nil); err != nil {
@@ -152,9 +319,9 @@ func (o *GenericControllerManagerOptions) ApplyTo(c *genericcontrollermanager.Co
 	if err != nil {
 		return err
 	}
-	c.Kubeconfig.ContentConfig.ContentType = o.ComponentConfig.ContentType
+	c.Kubeconfig.ContentConfig.ContentType = o.GenericComponent.ContentType
-	c.Kubeconfig.QPS = o.ComponentConfig.KubeAPIQPS
+	c.Kubeconfig.QPS = o.GenericComponent.KubeAPIQPS
-	c.Kubeconfig.Burst = int(o.ComponentConfig.KubeAPIBurst)
+	c.Kubeconfig.Burst = int(o.GenericComponent.KubeAPIBurst)
 
 	c.Client, err = clientset.NewForConfig(restclient.AddUserAgent(c.Kubeconfig, userAgent))
 	if err != nil {
@@ -171,6 +338,29 @@ func (o *GenericControllerManagerOptions) ApplyTo(c *genericcontrollermanager.Co
 // Validate checks GenericControllerManagerOptions and return a slice of found errors.
 func (o *GenericControllerManagerOptions) Validate() []error {
 	errors := []error{}
+	errors = append(errors, o.CloudProvider.Validate()...)
+	errors = append(errors, o.Debugging.Validate()...)
+	errors = append(errors, o.GenericComponent.Validate()...)
+	errors = append(errors, o.KubeCloudShared.Validate()...)
+	errors = append(errors, o.AttachDetachController.Validate()...)
+	errors = append(errors, o.CSRSigningController.Validate()...)
+	errors = append(errors, o.DaemonSetController.Validate()...)
+	errors = append(errors, o.DeploymentController.Validate()...)
+	errors = append(errors, o.DeprecatedFlags.Validate()...)
+	errors = append(errors, o.EndPointController.Validate()...)
+	errors = append(errors, o.GarbageCollectorController.Validate()...)
+	errors = append(errors, o.HPAController.Validate()...)
+	errors = append(errors, o.JobController.Validate()...)
+	errors = append(errors, o.NamespaceController.Validate()...)
+	errors = append(errors, o.NodeIpamController.Validate()...)
+	errors = append(errors, o.NodeLifecycleController.Validate()...)
+	errors = append(errors, o.PersistentVolumeBinderController.Validate()...)
+	errors = append(errors, o.PodGCController.Validate()...)
+	errors = append(errors, o.ReplicaSetController.Validate()...)
+	errors = append(errors, o.ReplicationController.Validate()...)
+	errors = append(errors, o.ResourceQuotaController.Validate()...)
+	errors = append(errors, o.SAController.Validate()...)
+	errors = append(errors, o.ServiceController.Validate()...)
 	errors = append(errors, o.SecureServing.Validate()...)
 	errors = append(errors, o.InsecureServing.Validate()...)
 	errors = append(errors, o.Authentication.Validate()...)

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

@@ -0,0 +1,69 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package options
+
+import (
+	"github.com/spf13/pflag"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/kubernetes/pkg/apis/componentconfig"
+)
+
+// PersistentVolumeBinderControllerOptions holds the PersistentVolumeBinderController options.
+type PersistentVolumeBinderControllerOptions struct {
+	PVClaimBinderSyncPeriod metav1.Duration
+	VolumeConfiguration     componentconfig.VolumeConfiguration
+}
+
+// AddFlags adds flags related to PersistentVolumeBinderController for controller manager to the specified FlagSet.
+func (o *PersistentVolumeBinderControllerOptions) AddFlags(fs *pflag.FlagSet) {
+	if o == nil {
+		return
+	}
+
+	fs.DurationVar(&o.PVClaimBinderSyncPeriod.Duration, "pvclaimbinder-sync-period", o.PVClaimBinderSyncPeriod.Duration, "The period for syncing persistent volumes and persistent volume claims")
+	fs.StringVar(&o.VolumeConfiguration.PersistentVolumeRecyclerConfiguration.PodTemplateFilePathNFS, "pv-recycler-pod-template-filepath-nfs", o.VolumeConfiguration.PersistentVolumeRecyclerConfiguration.PodTemplateFilePathNFS, "The file path to a pod definition used as a template for NFS persistent volume recycling")
+	fs.Int32Var(&o.VolumeConfiguration.PersistentVolumeRecyclerConfiguration.MinimumTimeoutNFS, "pv-recycler-minimum-timeout-nfs", o.VolumeConfiguration.PersistentVolumeRecyclerConfiguration.MinimumTimeoutNFS, "The minimum ActiveDeadlineSeconds to use for an NFS Recycler pod")
+	fs.Int32Var(&o.VolumeConfiguration.PersistentVolumeRecyclerConfiguration.IncrementTimeoutNFS, "pv-recycler-increment-timeout-nfs", o.VolumeConfiguration.PersistentVolumeRecyclerConfiguration.IncrementTimeoutNFS, "the increment of time added per Gi to ActiveDeadlineSeconds for an NFS scrubber pod")
+	fs.StringVar(&o.VolumeConfiguration.PersistentVolumeRecyclerConfiguration.PodTemplateFilePathHostPath, "pv-recycler-pod-template-filepath-hostpath", o.VolumeConfiguration.PersistentVolumeRecyclerConfiguration.PodTemplateFilePathHostPath, "The file path to a pod definition used as a template for HostPath persistent volume recycling. This is for development and testing only and will not work in a multi-node cluster.")
+	fs.Int32Var(&o.VolumeConfiguration.PersistentVolumeRecyclerConfiguration.MinimumTimeoutHostPath, "pv-recycler-minimum-timeout-hostpath", o.VolumeConfiguration.PersistentVolumeRecyclerConfiguration.MinimumTimeoutHostPath, "The minimum ActiveDeadlineSeconds to use for a HostPath Recycler pod.  This is for development and testing only and will not work in a multi-node cluster.")
+	fs.Int32Var(&o.VolumeConfiguration.PersistentVolumeRecyclerConfiguration.IncrementTimeoutHostPath, "pv-recycler-timeout-increment-hostpath", o.VolumeConfiguration.PersistentVolumeRecyclerConfiguration.IncrementTimeoutHostPath, "the increment of time added per Gi to ActiveDeadlineSeconds for a HostPath scrubber pod.  This is for development and testing only and will not work in a multi-node cluster.")
+	fs.BoolVar(&o.VolumeConfiguration.EnableHostPathProvisioning, "enable-hostpath-provisioner", o.VolumeConfiguration.EnableHostPathProvisioning, "Enable HostPath PV provisioning when running without a cloud provider. This allows testing and development of provisioning features.  HostPath provisioning is not supported in any way, won't work in a multi-node cluster, and should not be used for anything other than testing or development.")
+	fs.BoolVar(&o.VolumeConfiguration.EnableDynamicProvisioning, "enable-dynamic-provisioning", o.VolumeConfiguration.EnableDynamicProvisioning, "Enable dynamic provisioning for environments that support it.")
+	fs.StringVar(&o.VolumeConfiguration.FlexVolumePluginDir, "flex-volume-plugin-dir", o.VolumeConfiguration.FlexVolumePluginDir, "Full path of the directory in which the flex volume plugin should search for additional third party volume plugins.")
+}
+
+// ApplyTo fills up PersistentVolumeBinderController config with options.
+func (o *PersistentVolumeBinderControllerOptions) ApplyTo(cfg *componentconfig.PersistentVolumeBinderControllerConfiguration) error {
+	if o == nil {
+		return nil
+	}
+
+	cfg.PVClaimBinderSyncPeriod = o.PVClaimBinderSyncPeriod
+	cfg.VolumeConfiguration = o.VolumeConfiguration
+
+	return nil
+}
+
+// Validate checks validation of PersistentVolumeBinderControllerOptions.
+func (o *PersistentVolumeBinderControllerOptions) Validate() []error {
+	if o == nil {
+		return nil
+	}
+
+	errs := []error{}
+	return errs
+}

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

@@ -0,0 +1,57 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package options
+
+import (
+	"github.com/spf13/pflag"
+	"k8s.io/kubernetes/pkg/apis/componentconfig"
+)
+
+// PodGCControllerOptions holds the PodGCController options.
+type PodGCControllerOptions struct {
+	TerminatedPodGCThreshold int32
+}
+
+// AddFlags adds flags related to PodGCController for controller manager to the specified FlagSet.
+func (o *PodGCControllerOptions) AddFlags(fs *pflag.FlagSet) {
+	if o == nil {
+		return
+	}
+
+	fs.Int32Var(&o.TerminatedPodGCThreshold, "terminated-pod-gc-threshold", o.TerminatedPodGCThreshold, "Number of terminated pods that can exist before the terminated pod garbage collector starts deleting terminated pods. If <= 0, the terminated pod garbage collector is disabled.")
+}
+
+// ApplyTo fills up PodGCController config with options.
+func (o *PodGCControllerOptions) ApplyTo(cfg *componentconfig.PodGCControllerConfiguration) error {
+	if o == nil {
+		return nil
+	}
+
+	cfg.TerminatedPodGCThreshold = o.TerminatedPodGCThreshold
+
+	return nil
+}
+
+// Validate checks validation of PodGCControllerOptions.
+func (o *PodGCControllerOptions) Validate() []error {
+	if o == nil {
+		return nil
+	}
+
+	errs := []error{}
+	return errs
+}

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

@@ -0,0 +1,57 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package options
+
+import (
+	"github.com/spf13/pflag"
+	"k8s.io/kubernetes/pkg/apis/componentconfig"
+)
+
+// ReplicaSetControllerOptions holds the ReplicaSetController options.
+type ReplicaSetControllerOptions struct {
+	ConcurrentRSSyncs int32
+}
+
+// AddFlags adds flags related to ReplicaSetController for controller manager to the specified FlagSet.
+func (o *ReplicaSetControllerOptions) AddFlags(fs *pflag.FlagSet) {
+	if o == nil {
+		return
+	}
+
+	fs.Int32Var(&o.ConcurrentRSSyncs, "concurrent-replicaset-syncs", o.ConcurrentRSSyncs, "The number of replica sets that are allowed to sync concurrently. Larger number = more responsive replica management, but more CPU (and network) load")
+}
+
+// ApplyTo fills up ReplicaSetController config with options.
+func (o *ReplicaSetControllerOptions) ApplyTo(cfg *componentconfig.ReplicaSetControllerConfiguration) error {
+	if o == nil {
+		return nil
+	}
+
+	cfg.ConcurrentRSSyncs = o.ConcurrentRSSyncs
+
+	return nil
+}
+
+// Validate checks validation of ReplicaSetControllerOptions.
+func (o *ReplicaSetControllerOptions) Validate() []error {
+	if o == nil {
+		return nil
+	}
+
+	errs := []error{}
+	return errs
+}

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

@@ -0,0 +1,57 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package options
+
+import (
+	"github.com/spf13/pflag"
+	"k8s.io/kubernetes/pkg/apis/componentconfig"
+)
+
+// ReplicationControllerOptions holds the ReplicationController options.
+type ReplicationControllerOptions struct {
+	ConcurrentRCSyncs int32
+}
+
+// AddFlags adds flags related to ReplicationController for controller manager to the specified FlagSet.
+func (o *ReplicationControllerOptions) AddFlags(fs *pflag.FlagSet) {
+	if o == nil {
+		return
+	}
+
+	fs.Int32Var(&o.ConcurrentRCSyncs, "concurrent_rc_syncs", o.ConcurrentRCSyncs, "The number of replication controllers that are allowed to sync concurrently. Larger number = more responsive replica management, but more CPU (and network) load")
+}
+
+// ApplyTo fills up ReplicationController config with options.
+func (o *ReplicationControllerOptions) ApplyTo(cfg *componentconfig.ReplicationControllerConfiguration) error {
+	if o == nil {
+		return nil
+	}
+
+	cfg.ConcurrentRCSyncs = o.ConcurrentRCSyncs
+
+	return nil
+}
+
+// Validate checks validation of ReplicationControllerOptions.
+func (o *ReplicationControllerOptions) Validate() []error {
+	if o == nil {
+		return nil
+	}
+
+	errs := []error{}
+	return errs
+}

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

@@ -0,0 +1,61 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package options
+
+import (
+	"github.com/spf13/pflag"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/kubernetes/pkg/apis/componentconfig"
+)
+
+// ResourceQuotaControllerOptions holds the ResourceQuotaController options.
+type ResourceQuotaControllerOptions struct {
+	ResourceQuotaSyncPeriod      metav1.Duration
+	ConcurrentResourceQuotaSyncs int32
+}
+
+// AddFlags adds flags related to ResourceQuotaController for controller manager to the specified FlagSet.
+func (o *ResourceQuotaControllerOptions) AddFlags(fs *pflag.FlagSet) {
+	if o == nil {
+		return
+	}
+
+	fs.DurationVar(&o.ResourceQuotaSyncPeriod.Duration, "resource-quota-sync-period", o.ResourceQuotaSyncPeriod.Duration, "The period for syncing quota usage status in the system")
+	fs.Int32Var(&o.ConcurrentResourceQuotaSyncs, "concurrent-resource-quota-syncs", o.ConcurrentResourceQuotaSyncs, "The number of resource quotas that are allowed to sync concurrently. Larger number = more responsive quota management, but more CPU (and network) load")
+}
+
+// ApplyTo fills up ResourceQuotaController config with options.
+func (o *ResourceQuotaControllerOptions) ApplyTo(cfg *componentconfig.ResourceQuotaControllerConfiguration) error {
+	if o == nil {
+		return nil
+	}
+
+	cfg.ResourceQuotaSyncPeriod = o.ResourceQuotaSyncPeriod
+	cfg.ConcurrentResourceQuotaSyncs = o.ConcurrentResourceQuotaSyncs
+
+	return nil
+}
+
+// Validate checks validation of ResourceQuotaControllerOptions.
+func (o *ResourceQuotaControllerOptions) Validate() []error {
+	if o == nil {
+		return nil
+	}
+
+	errs := []error{}
+	return errs
+}

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

@@ -0,0 +1,60 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package options
+
+import (
+	"github.com/spf13/pflag"
+	"k8s.io/kubernetes/pkg/apis/componentconfig"
+)
+
+// SAControllerOptions holds the ServiceAccountController options.
+type SAControllerOptions struct {
+	ConcurrentSATokenSyncs int32
+	RootCAFile             string
+}
+
+// AddFlags adds flags related to ServiceAccountController for controller manager to the specified FlagSet
+func (o *SAControllerOptions) AddFlags(fs *pflag.FlagSet) {
+	if o == nil {
+		return
+	}
+
+	fs.Int32Var(&o.ConcurrentSATokenSyncs, "concurrent-serviceaccount-token-syncs", o.ConcurrentSATokenSyncs, "The number of service account token objects that are allowed to sync concurrently. Larger number = more responsive token generation, but more CPU (and network) load")
+	fs.StringVar(&o.RootCAFile, "root-ca-file", o.RootCAFile, "If set, this root certificate authority will be included in service account's token secret. This must be a valid PEM-encoded CA bundle.")
+}
+
+// ApplyTo fills up ServiceAccountController config with options.
+func (o *SAControllerOptions) ApplyTo(cfg *componentconfig.SAControllerConfiguration) error {
+	if o == nil {
+		return nil
+	}
+
+	cfg.ConcurrentSATokenSyncs = o.ConcurrentSATokenSyncs
+	cfg.RootCAFile = o.RootCAFile
+
+	return nil
+}
+
+// Validate checks validation of ServiceAccountControllerOptions.
+func (o *SAControllerOptions) Validate() []error {
+	if o == nil {
+		return nil
+	}
+
+	errs := []error{}
+	return errs
+}

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

@@ -0,0 +1,57 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package options
+
+import (
+	"github.com/spf13/pflag"
+	"k8s.io/kubernetes/pkg/apis/componentconfig"
+)
+
+// ServiceControllerOptions holds the ServiceController options.
+type ServiceControllerOptions struct {
+	ConcurrentServiceSyncs int32
+}
+
+// AddFlags adds flags related to ServiceController for controller manager to the specified FlagSet.
+func (o *ServiceControllerOptions) AddFlags(fs *pflag.FlagSet) {
+	if o == nil {
+		return
+	}
+
+	fs.Int32Var(&o.ConcurrentServiceSyncs, "concurrent-service-syncs", o.ConcurrentServiceSyncs, "The number of services that are allowed to sync concurrently. Larger number = more responsive service management, but more CPU (and network) load")
+}
+
+// ApplyTo fills up ServiceController config with options.
+func (o *ServiceControllerOptions) ApplyTo(cfg *componentconfig.ServiceControllerConfiguration) error {
+	if o == nil {
+		return nil
+	}
+
+	cfg.ConcurrentServiceSyncs = o.ConcurrentServiceSyncs
+
+	return nil
+}
+
+// Validate checks validation of ServiceControllerOptions.
+func (o *ServiceControllerOptions) Validate() []error {
+	if o == nil {
+		return nil
+	}
+
+	errs := []error{}
+	return errs
+}

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

@@ -28,7 +28,6 @@ import (
 	cmoptions "k8s.io/kubernetes/cmd/controller-manager/app/options"
 	kubecontrollerconfig "k8s.io/kubernetes/cmd/kube-controller-manager/app/config"
 	"k8s.io/kubernetes/pkg/apis/componentconfig"
-	"k8s.io/kubernetes/pkg/client/leaderelectionconfig"
 	"k8s.io/kubernetes/pkg/controller/garbagecollector"
 	"k8s.io/kubernetes/pkg/master/ports"
 
@@ -40,7 +39,7 @@ import (
 
 // KubeControllerManagerOptions is the main context object for the controller manager.
 type KubeControllerManagerOptions struct {
-	Generic cmoptions.GenericControllerManagerOptions
+	Generic *cmoptions.GenericControllerManagerOptions
 }
 
 // NewKubeControllerManagerOptions creates a new KubeControllerManagerOptions with a default config.
@@ -59,7 +58,8 @@ func NewKubeControllerManagerOptions() *KubeControllerManagerOptions {
 	for r := range garbagecollector.DefaultIgnoredResources() {
 		gcIgnoredResources = append(gcIgnoredResources, componentconfig.GroupResource{Group: r.Group, Resource: r.Resource})
 	}
-	s.Generic.ComponentConfig.GCIgnoredResources = gcIgnoredResources
+
+	s.Generic.GarbageCollectorController.GCIgnoredResources = gcIgnoredResources
 
 	return &s
 }
@@ -67,81 +67,33 @@ func NewKubeControllerManagerOptions() *KubeControllerManagerOptions {
 // AddFlags adds flags for a specific KubeControllerManagerOptions to the specified FlagSet
 func (s *KubeControllerManagerOptions) AddFlags(fs *pflag.FlagSet, allControllers []string, disabledByDefaultControllers []string) {
 	s.Generic.AddFlags(fs)
+	s.Generic.AttachDetachController.AddFlags(fs)
+	s.Generic.CSRSigningController.AddFlags(fs)
+	s.Generic.DeploymentController.AddFlags(fs)
+	s.Generic.DaemonSetController.AddFlags(fs)
+	s.Generic.DeprecatedFlags.AddFlags(fs)
+	s.Generic.EndPointController.AddFlags(fs)
+	s.Generic.GarbageCollectorController.AddFlags(fs)
+	s.Generic.HPAController.AddFlags(fs)
+	s.Generic.JobController.AddFlags(fs)
+	s.Generic.NamespaceController.AddFlags(fs)
+	s.Generic.NodeIpamController.AddFlags(fs)
+	s.Generic.NodeLifecycleController.AddFlags(fs)
+	s.Generic.PersistentVolumeBinderController.AddFlags(fs)
+	s.Generic.PodGCController.AddFlags(fs)
+	s.Generic.ReplicaSetController.AddFlags(fs)
+	s.Generic.ReplicationController.AddFlags(fs)
+	s.Generic.ResourceQuotaController.AddFlags(fs)
+	s.Generic.SAController.AddFlags(fs)
 
-	fs.StringSliceVar(&s.Generic.ComponentConfig.Controllers, "controllers", s.Generic.ComponentConfig.Controllers, fmt.Sprintf(""+
+	fs.StringSliceVar(&s.Generic.Controllers, "controllers", s.Generic.Controllers, fmt.Sprintf(""+
 		"A list of controllers to enable.  '*' enables all on-by-default controllers, 'foo' enables the controller "+
 		"named 'foo', '-foo' disables the controller named 'foo'.\nAll controllers: %s\nDisabled-by-default controllers: %s",
 		strings.Join(allControllers, ", "), strings.Join(disabledByDefaultControllers, ", ")))
-	fs.StringVar(&s.Generic.ComponentConfig.CloudProvider, "cloud-provider", s.Generic.ComponentConfig.CloudProvider, "The provider for cloud services.  Empty string for no provider.")
+	fs.StringVar(&s.Generic.ExternalCloudVolumePlugin, "external-cloud-volume-plugin", s.Generic.ExternalCloudVolumePlugin, "The plugin to use when cloud provider is set to external. Can be empty, should only be set when cloud-provider is external. Currently used to allow node and volume controllers to work for in tree cloud providers.")
-	fs.StringVar(&s.Generic.ComponentConfig.ExternalCloudVolumePlugin, "external-cloud-volume-plugin", s.Generic.ComponentConfig.ExternalCloudVolumePlugin, "The plugin to use when cloud provider is set to external. Can be empty, should only be set when cloud-provider is external. Currently used to allow node and volume controllers to work for in tree cloud providers.")
-	fs.Int32Var(&s.Generic.ComponentConfig.ConcurrentEndpointSyncs, "concurrent-endpoint-syncs", s.Generic.ComponentConfig.ConcurrentEndpointSyncs, "The number of endpoint syncing operations that will be done concurrently. Larger number = faster endpoint updating, but more CPU (and network) load")
-	fs.Int32Var(&s.Generic.ComponentConfig.ConcurrentServiceSyncs, "concurrent-service-syncs", s.Generic.ComponentConfig.ConcurrentServiceSyncs, "The number of services that are allowed to sync concurrently. Larger number = more responsive service management, but more CPU (and network) load")
-	fs.Int32Var(&s.Generic.ComponentConfig.ConcurrentRCSyncs, "concurrent_rc_syncs", s.Generic.ComponentConfig.ConcurrentRCSyncs, "The number of replication controllers that are allowed to sync concurrently. Larger number = more responsive replica management, but more CPU (and network) load")
-	fs.Int32Var(&s.Generic.ComponentConfig.ConcurrentRSSyncs, "concurrent-replicaset-syncs", s.Generic.ComponentConfig.ConcurrentRSSyncs, "The number of replica sets that are allowed to sync concurrently. Larger number = more responsive replica management, but more CPU (and network) load")
-
-	fs.Int32Var(&s.Generic.ComponentConfig.ConcurrentResourceQuotaSyncs, "concurrent-resource-quota-syncs", s.Generic.ComponentConfig.ConcurrentResourceQuotaSyncs, "The number of resource quotas that are allowed to sync concurrently. Larger number = more responsive quota management, but more CPU (and network) load")
-	fs.Int32Var(&s.Generic.ComponentConfig.ConcurrentDeploymentSyncs, "concurrent-deployment-syncs", s.Generic.ComponentConfig.ConcurrentDeploymentSyncs, "The number of deployment objects that are allowed to sync concurrently. Larger number = more responsive deployments, but more CPU (and network) load")
-	fs.Int32Var(&s.Generic.ComponentConfig.ConcurrentNamespaceSyncs, "concurrent-namespace-syncs", s.Generic.ComponentConfig.ConcurrentNamespaceSyncs, "The number of namespace objects that are allowed to sync concurrently. Larger number = more responsive namespace termination, but more CPU (and network) load")
-	fs.Int32Var(&s.Generic.ComponentConfig.ConcurrentSATokenSyncs, "concurrent-serviceaccount-token-syncs", s.Generic.ComponentConfig.ConcurrentSATokenSyncs, "The number of service account token objects that are allowed to sync concurrently. Larger number = more responsive token generation, but more CPU (and network) load")
-	fs.DurationVar(&s.Generic.ComponentConfig.NodeSyncPeriod.Duration, "node-sync-period", 0, ""+
-		"This flag is deprecated and will be removed in future releases. See node-monitor-period for Node health checking or "+
-		"route-reconciliation-period for cloud provider's route configuration settings.")
-	fs.MarkDeprecated("node-sync-period", "This flag is currently no-op and will be deleted.")
-	fs.DurationVar(&s.Generic.ComponentConfig.ResourceQuotaSyncPeriod.Duration, "resource-quota-sync-period", s.Generic.ComponentConfig.ResourceQuotaSyncPeriod.Duration, "The period for syncing quota usage status in the system")
-	fs.DurationVar(&s.Generic.ComponentConfig.NamespaceSyncPeriod.Duration, "namespace-sync-period", s.Generic.ComponentConfig.NamespaceSyncPeriod.Duration, "The period for syncing namespace life-cycle updates")
-	fs.DurationVar(&s.Generic.ComponentConfig.PVClaimBinderSyncPeriod.Duration, "pvclaimbinder-sync-period", s.Generic.ComponentConfig.PVClaimBinderSyncPeriod.Duration, "The period for syncing persistent volumes and persistent volume claims")
-	fs.StringVar(&s.Generic.ComponentConfig.VolumeConfiguration.PersistentVolumeRecyclerConfiguration.PodTemplateFilePathNFS, "pv-recycler-pod-template-filepath-nfs", s.Generic.ComponentConfig.VolumeConfiguration.PersistentVolumeRecyclerConfiguration.PodTemplateFilePathNFS, "The file path to a pod definition used as a template for NFS persistent volume recycling")
-	fs.Int32Var(&s.Generic.ComponentConfig.VolumeConfiguration.PersistentVolumeRecyclerConfiguration.MinimumTimeoutNFS, "pv-recycler-minimum-timeout-nfs", s.Generic.ComponentConfig.VolumeConfiguration.PersistentVolumeRecyclerConfiguration.MinimumTimeoutNFS, "The minimum ActiveDeadlineSeconds to use for an NFS Recycler pod")
-	fs.Int32Var(&s.Generic.ComponentConfig.VolumeConfiguration.PersistentVolumeRecyclerConfiguration.IncrementTimeoutNFS, "pv-recycler-increment-timeout-nfs", s.Generic.ComponentConfig.VolumeConfiguration.PersistentVolumeRecyclerConfiguration.IncrementTimeoutNFS, "the increment of time added per Gi to ActiveDeadlineSeconds for an NFS scrubber pod")
-	fs.StringVar(&s.Generic.ComponentConfig.VolumeConfiguration.PersistentVolumeRecyclerConfiguration.PodTemplateFilePathHostPath, "pv-recycler-pod-template-filepath-hostpath", s.Generic.ComponentConfig.VolumeConfiguration.PersistentVolumeRecyclerConfiguration.PodTemplateFilePathHostPath, "The file path to a pod definition used as a template for HostPath persistent volume recycling. This is for development and testing only and will not work in a multi-node cluster.")
-	fs.Int32Var(&s.Generic.ComponentConfig.VolumeConfiguration.PersistentVolumeRecyclerConfiguration.MinimumTimeoutHostPath, "pv-recycler-minimum-timeout-hostpath", s.Generic.ComponentConfig.VolumeConfiguration.PersistentVolumeRecyclerConfiguration.MinimumTimeoutHostPath, "The minimum ActiveDeadlineSeconds to use for a HostPath Recycler pod.  This is for development and testing only and will not work in a multi-node cluster.")
-	fs.Int32Var(&s.Generic.ComponentConfig.VolumeConfiguration.PersistentVolumeRecyclerConfiguration.IncrementTimeoutHostPath, "pv-recycler-timeout-increment-hostpath", s.Generic.ComponentConfig.VolumeConfiguration.PersistentVolumeRecyclerConfiguration.IncrementTimeoutHostPath, "the increment of time added per Gi to ActiveDeadlineSeconds for a HostPath scrubber pod.  This is for development and testing only and will not work in a multi-node cluster.")
-	fs.BoolVar(&s.Generic.ComponentConfig.VolumeConfiguration.EnableHostPathProvisioning, "enable-hostpath-provisioner", s.Generic.ComponentConfig.VolumeConfiguration.EnableHostPathProvisioning, "Enable HostPath PV provisioning when running without a cloud provider. This allows testing and development of provisioning features.  HostPath provisioning is not supported in any way, won't work in a multi-node cluster, and should not be used for anything other than testing or development.")
-	fs.BoolVar(&s.Generic.ComponentConfig.VolumeConfiguration.EnableDynamicProvisioning, "enable-dynamic-provisioning", s.Generic.ComponentConfig.VolumeConfiguration.EnableDynamicProvisioning, "Enable dynamic provisioning for environments that support it.")
-	fs.StringVar(&s.Generic.ComponentConfig.VolumeConfiguration.FlexVolumePluginDir, "flex-volume-plugin-dir", s.Generic.ComponentConfig.VolumeConfiguration.FlexVolumePluginDir, "Full path of the directory in which the flex volume plugin should search for additional third party volume plugins.")
-	fs.Int32Var(&s.Generic.ComponentConfig.TerminatedPodGCThreshold, "terminated-pod-gc-threshold", s.Generic.ComponentConfig.TerminatedPodGCThreshold, "Number of terminated pods that can exist before the terminated pod garbage collector starts deleting terminated pods. If <= 0, the terminated pod garbage collector is disabled.")
-	fs.DurationVar(&s.Generic.ComponentConfig.HorizontalPodAutoscalerSyncPeriod.Duration, "horizontal-pod-autoscaler-sync-period", s.Generic.ComponentConfig.HorizontalPodAutoscalerSyncPeriod.Duration, "The period for syncing the number of pods in horizontal pod autoscaler.")
-	fs.DurationVar(&s.Generic.ComponentConfig.HorizontalPodAutoscalerUpscaleForbiddenWindow.Duration, "horizontal-pod-autoscaler-upscale-delay", s.Generic.ComponentConfig.HorizontalPodAutoscalerUpscaleForbiddenWindow.Duration, "The period since last upscale, before another upscale can be performed in horizontal pod autoscaler.")
-	fs.DurationVar(&s.Generic.ComponentConfig.HorizontalPodAutoscalerDownscaleForbiddenWindow.Duration, "horizontal-pod-autoscaler-downscale-delay", s.Generic.ComponentConfig.HorizontalPodAutoscalerDownscaleForbiddenWindow.Duration, "The period since last downscale, before another downscale can be performed in horizontal pod autoscaler.")
-	fs.Float64Var(&s.Generic.ComponentConfig.HorizontalPodAutoscalerTolerance, "horizontal-pod-autoscaler-tolerance", s.Generic.ComponentConfig.HorizontalPodAutoscalerTolerance, "The minimum change (from 1.0) in the desired-to-actual metrics ratio for the horizontal pod autoscaler to consider scaling.")
-	fs.DurationVar(&s.Generic.ComponentConfig.DeploymentControllerSyncPeriod.Duration, "deployment-controller-sync-period", s.Generic.ComponentConfig.DeploymentControllerSyncPeriod.Duration, "Period for syncing the deployments.")
-	fs.DurationVar(&s.Generic.ComponentConfig.PodEvictionTimeout.Duration, "pod-eviction-timeout", s.Generic.ComponentConfig.PodEvictionTimeout.Duration, "The grace period for deleting pods on failed nodes.")
-	fs.Float32Var(&s.Generic.ComponentConfig.DeletingPodsQps, "deleting-pods-qps", 0.1, "Number of nodes per second on which pods are deleted in case of node failure.")
-	fs.MarkDeprecated("deleting-pods-qps", "This flag is currently no-op and will be deleted.")
-	fs.Int32Var(&s.Generic.ComponentConfig.DeletingPodsBurst, "deleting-pods-burst", 0, "Number of nodes on which pods are bursty deleted in case of node failure. For more details look into RateLimiter.")
-	fs.MarkDeprecated("deleting-pods-burst", "This flag is currently no-op and will be deleted.")
-	fs.Int32Var(&s.Generic.ComponentConfig.RegisterRetryCount, "register-retry-count", s.Generic.ComponentConfig.RegisterRetryCount, ""+
-		"The number of retries for initial node registration.  Retry interval equals node-sync-period.")
-	fs.MarkDeprecated("register-retry-count", "This flag is currently no-op and will be deleted.")
-	fs.DurationVar(&s.Generic.ComponentConfig.NodeMonitorGracePeriod.Duration, "node-monitor-grace-period", s.Generic.ComponentConfig.NodeMonitorGracePeriod.Duration,
-		"Amount of time which we allow running Node to be unresponsive before marking it unhealthy. "+
-			"Must be N times more than kubelet's nodeStatusUpdateFrequency, "+
-			"where N means number of retries allowed for kubelet to post node status.")
-	fs.DurationVar(&s.Generic.ComponentConfig.NodeStartupGracePeriod.Duration, "node-startup-grace-period", s.Generic.ComponentConfig.NodeStartupGracePeriod.Duration,
-		"Amount of time which we allow starting Node to be unresponsive before marking it unhealthy.")
-	fs.StringVar(&s.Generic.ComponentConfig.ServiceAccountKeyFile, "service-account-private-key-file", s.Generic.ComponentConfig.ServiceAccountKeyFile, "Filename containing a PEM-encoded private RSA or ECDSA key used to sign service account tokens.")
-	fs.StringVar(&s.Generic.ComponentConfig.ClusterSigningCertFile, "cluster-signing-cert-file", s.Generic.ComponentConfig.ClusterSigningCertFile, "Filename containing a PEM-encoded X509 CA certificate used to issue cluster-scoped certificates")
-	fs.StringVar(&s.Generic.ComponentConfig.ClusterSigningKeyFile, "cluster-signing-key-file", s.Generic.ComponentConfig.ClusterSigningKeyFile, "Filename containing a PEM-encoded RSA or ECDSA private key used to sign cluster-scoped certificates")
-	fs.DurationVar(&s.Generic.ComponentConfig.ClusterSigningDuration.Duration, "experimental-cluster-signing-duration", s.Generic.ComponentConfig.ClusterSigningDuration.Duration, "The length of duration signed certificates will be given.")
 	var dummy string
 	fs.MarkDeprecated("insecure-experimental-approve-all-kubelet-csrs-for-group", "This flag does nothing.")
 	fs.StringVar(&dummy, "insecure-experimental-approve-all-kubelet-csrs-for-group", "", "This flag does nothing.")
-	fs.StringVar(&s.Generic.ComponentConfig.ServiceCIDR, "service-cluster-ip-range", s.Generic.ComponentConfig.ServiceCIDR, "CIDR Range for Services in cluster. Requires --allocate-node-cidrs to be true")
-	fs.Int32Var(&s.Generic.ComponentConfig.NodeCIDRMaskSize, "node-cidr-mask-size", s.Generic.ComponentConfig.NodeCIDRMaskSize, "Mask size for node cidr in cluster.")
-	fs.StringVar(&s.Generic.ComponentConfig.RootCAFile, "root-ca-file", s.Generic.ComponentConfig.RootCAFile, "If set, this root certificate authority will be included in service account's token secret. This must be a valid PEM-encoded CA bundle.")
-	fs.BoolVar(&s.Generic.ComponentConfig.EnableGarbageCollector, "enable-garbage-collector", s.Generic.ComponentConfig.EnableGarbageCollector, "Enables the generic garbage collector. MUST be synced with the corresponding flag of the kube-apiserver.")
-	fs.Int32Var(&s.Generic.ComponentConfig.ConcurrentGCSyncs, "concurrent-gc-syncs", s.Generic.ComponentConfig.ConcurrentGCSyncs, "The number of garbage collector workers that are allowed to sync concurrently.")
-	fs.Int32Var(&s.Generic.ComponentConfig.LargeClusterSizeThreshold, "large-cluster-size-threshold", 50, "Number of nodes from which NodeController treats the cluster as large for the eviction logic purposes. --secondary-node-eviction-rate is implicitly overridden to 0 for clusters this size or smaller.")
-	fs.Float32Var(&s.Generic.ComponentConfig.UnhealthyZoneThreshold, "unhealthy-zone-threshold", 0.55, "Fraction of Nodes in a zone which needs to be not Ready (minimum 3) for zone to be treated as unhealthy. ")
-	fs.BoolVar(&s.Generic.ComponentConfig.DisableAttachDetachReconcilerSync, "disable-attach-detach-reconcile-sync", false, "Disable volume attach detach reconciler sync. Disabling this may cause volumes to be mismatched with pods. Use wisely.")
-	fs.DurationVar(&s.Generic.ComponentConfig.ReconcilerSyncLoopPeriod.Duration, "attach-detach-reconcile-sync-period", s.Generic.ComponentConfig.ReconcilerSyncLoopPeriod.Duration, "The reconciler sync wait time between volume attach detach. This duration must be larger than one second, and increasing this value from the default may allow for volumes to be mismatched with pods.")
-	fs.BoolVar(&s.Generic.ComponentConfig.EnableTaintManager, "enable-taint-manager", s.Generic.ComponentConfig.EnableTaintManager, "WARNING: Beta feature. If set to true enables NoExecute Taints and will evict all not-tolerating Pod running on Nodes tainted with this kind of Taints.")
-	fs.BoolVar(&s.Generic.ComponentConfig.HorizontalPodAutoscalerUseRESTClients, "horizontal-pod-autoscaler-use-rest-clients", s.Generic.ComponentConfig.HorizontalPodAutoscalerUseRESTClients, "WARNING: alpha feature.  If set to true, causes the horizontal pod autoscaler controller to use REST clients through the kube-aggregator, instead of using the legacy metrics client through the API server proxy.  This is required for custom metrics support in the horizontal pod autoscaler.")
-	fs.Float32Var(&s.Generic.ComponentConfig.NodeEvictionRate, "node-eviction-rate", 0.1, "Number of nodes per second on which pods are deleted in case of node failure when a zone is healthy (see --unhealthy-zone-threshold for definition of healthy/unhealthy). Zone refers to entire cluster in non-multizone clusters.")
-	fs.Float32Var(&s.Generic.ComponentConfig.SecondaryNodeEvictionRate, "secondary-node-eviction-rate", 0.01, "Number of nodes per second on which pods are deleted in case of node failure when a zone is unhealthy (see --unhealthy-zone-threshold for definition of healthy/unhealthy). Zone refers to entire cluster in non-multizone clusters. This value is implicitly overridden to 0 if the cluster size is smaller than --large-cluster-size-threshold.")
-
-	leaderelectionconfig.BindFlags(&s.Generic.ComponentConfig.LeaderElection, fs)
-
 	utilfeature.DefaultFeatureGate.AddFlag(fs)
 }
 
@@ -149,6 +101,9 @@ func (s *KubeControllerManagerOptions) AddFlags(fs *pflag.FlagSet, allController
 func (s *KubeControllerManagerOptions) ApplyTo(c *kubecontrollerconfig.Config) error {
 	err := s.Generic.ApplyTo(&c.Generic, "controller-manager")
 
+	c.Generic.ComponentConfig.Controllers = s.Generic.Controllers
+	c.Generic.ComponentConfig.ExternalCloudVolumePlugin = s.Generic.ExternalCloudVolumePlugin
+
 	return err
 }
 
@@ -157,7 +112,7 @@ func (s *KubeControllerManagerOptions) Validate(allControllers []string, disable
 	var errs []error
 
 	allControllersSet := sets.NewString(allControllers...)
-	for _, controller := range s.Generic.ComponentConfig.Controllers {
+	for _, controller := range s.Generic.Controllers {
 		if controller == "*" {
 			continue
 		}

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

@@ -113,67 +113,24 @@ func TestAddFlags(t *testing.T) {
 	f.Parse(args)
 	// Sort GCIgnoredResources because it's built from a map, which means the
 	// insertion order is random.
-	sort.Sort(sortedGCIgnoredResources(s.Generic.ComponentConfig.GCIgnoredResources))
+	sort.Sort(sortedGCIgnoredResources(s.Generic.GarbageCollectorController.GCIgnoredResources))
 
 	expected := &KubeControllerManagerOptions{
-		Generic: cmoptions.GenericControllerManagerOptions{
+		Generic: &cmoptions.GenericControllerManagerOptions{
-			ComponentConfig: componentconfig.KubeControllerManagerConfiguration{
+			CloudProvider: &cmoptions.CloudProviderOptions{
-				Port:                                            10252,     // Note: InsecureServingOptions.ApplyTo will write the flag value back into the component config
+				Name:            "gce",
-				Address:                                         "0.0.0.0", // Note: InsecureServingOptions.ApplyTo will write the flag value back into the component config
+				CloudConfigFile: "/cloud-config",
-				AllocateNodeCIDRs:                               true,
+			},
-				CloudConfigFile:                                 "/cloud-config",
+			Debugging: &cmoptions.DebuggingOptions{
-				CloudProvider:                                   "gce",
+				EnableProfiling:           false,
-				ClusterCIDR:                                     "1.2.3.4/24",
+				EnableContentionProfiling: true,
-				ClusterName:                                     "k8s",
+			},
-				ConcurrentDeploymentSyncs:                       10,
+			GenericComponent: &cmoptions.GenericComponentConfigOptions{
-				ConcurrentEndpointSyncs:                         10,
+				MinResyncPeriod:         metav1.Duration{Duration: 8 * time.Hour},
-				ConcurrentGCSyncs:                               30,
+				ContentType:             "application/json",
-				ConcurrentNamespaceSyncs:                        20,
+				KubeAPIQPS:              50.0,
-				ConcurrentRSSyncs:                               10,
+				KubeAPIBurst:            100,
-				ConcurrentResourceQuotaSyncs:                    10,
+				ControllerStartInterval: metav1.Duration{Duration: 2 * time.Minute},
-				ConcurrentServiceSyncs:                          2,
-				ConcurrentSATokenSyncs:                          10,
-				ConcurrentRCSyncs:                               10,
-				ConfigureCloudRoutes:                            false,
-				EnableContentionProfiling:                       true,
-				ControllerStartInterval:                         metav1.Duration{Duration: 2 * time.Minute},
-				ConcurrentDaemonSetSyncs:                        2,
-				ConcurrentJobSyncs:                              5,
-				DeletingPodsQps:                                 0.1,
-				EnableProfiling:                                 false,
-				CIDRAllocatorType:                               "CloudAllocator",
-				NodeCIDRMaskSize:                                48,
-				ResourceQuotaSyncPeriod:                         metav1.Duration{Duration: 10 * time.Minute},
-				NamespaceSyncPeriod:                             metav1.Duration{Duration: 10 * time.Minute},
-				PVClaimBinderSyncPeriod:                         metav1.Duration{Duration: 30 * time.Second},
-				HorizontalPodAutoscalerSyncPeriod:               metav1.Duration{Duration: 45 * time.Second},
-				DeploymentControllerSyncPeriod:                  metav1.Duration{Duration: 45 * time.Second},
-				MinResyncPeriod:                                 metav1.Duration{Duration: 8 * time.Hour},
-				RegisterRetryCount:                              10,
-				RouteReconciliationPeriod:                       metav1.Duration{Duration: 30 * time.Second},
-				PodEvictionTimeout:                              metav1.Duration{Duration: 2 * time.Minute},
-				NodeMonitorGracePeriod:                          metav1.Duration{Duration: 30 * time.Second},
-				NodeStartupGracePeriod:                          metav1.Duration{Duration: 30 * time.Second},
-				NodeMonitorPeriod:                               metav1.Duration{Duration: 10 * time.Second},
-				HorizontalPodAutoscalerUpscaleForbiddenWindow:   metav1.Duration{Duration: 1 * time.Minute},
-				HorizontalPodAutoscalerDownscaleForbiddenWindow: metav1.Duration{Duration: 2 * time.Minute},
-				HorizontalPodAutoscalerTolerance:                0.1,
-				TerminatedPodGCThreshold:                        12000,
-				VolumeConfiguration: componentconfig.VolumeConfiguration{
-					EnableDynamicProvisioning:  false,
-					EnableHostPathProvisioning: true,
-					FlexVolumePluginDir:        "/flex-volume-plugin",
-					PersistentVolumeRecyclerConfiguration: componentconfig.PersistentVolumeRecyclerConfiguration{
-						MaximumRetry:             3,
-						MinimumTimeoutNFS:        200,
-						IncrementTimeoutNFS:      45,
-						MinimumTimeoutHostPath:   45,
-						IncrementTimeoutHostPath: 45,
-					},
-				},
-				ContentType:  "application/json",
-				KubeAPIQPS:   50.0,
-				KubeAPIBurst: 100,
 				LeaderElection: componentconfig.LeaderElectionConfiguration{
 					ResourceLock:  "configmap",
 					LeaderElect:   false,
@@ -181,11 +138,45 @@ func TestAddFlags(t *testing.T) {
 					RenewDeadline: metav1.Duration{Duration: 15 * time.Second},
 					RetryPeriod:   metav1.Duration{Duration: 5 * time.Second},
 				},
+			},
+			KubeCloudShared: &cmoptions.KubeCloudSharedOptions{
+				Port:    10252,     // Note: InsecureServingOptions.ApplyTo will write the flag value back into the component config		 +				AllocateNodeCIDRs:         true,
+				Address: "0.0.0.0", // Note: InsecureServingOptions.ApplyTo will write the flag value back into the component config
+				UseServiceAccountCredentials: true,
+				RouteReconciliationPeriod:    metav1.Duration{Duration: 30 * time.Second},
+				NodeMonitorPeriod:            metav1.Duration{Duration: 10 * time.Second},
+				ClusterName:                  "k8s",
+				ClusterCIDR:                  "1.2.3.4/24",
+				AllocateNodeCIDRs:            true,
+				CIDRAllocatorType:            "CloudAllocator",
+				ConfigureCloudRoutes:         false,
+				ServiceAccountKeyFile:        "/service-account-private-key",
+			},
+			AttachDetachController: &cmoptions.AttachDetachControllerOptions{
+				ReconcilerSyncLoopPeriod:          metav1.Duration{Duration: 30 * time.Second},
+				DisableAttachDetachReconcilerSync: true,
+			},
+			CSRSigningController: &cmoptions.CSRSigningControllerOptions{
 				ClusterSigningCertFile: "/cluster-signing-cert",
 				ClusterSigningKeyFile:  "/cluster-signing-key",
-				ServiceAccountKeyFile:  "/service-account-private-key",
 				ClusterSigningDuration: metav1.Duration{Duration: 10 * time.Hour},
-				EnableGarbageCollector: false,
+			},
+			DaemonSetController: &cmoptions.DaemonSetControllerOptions{
+				ConcurrentDaemonSetSyncs: 2,
+			},
+			DeploymentController: &cmoptions.DeploymentControllerOptions{
+				ConcurrentDeploymentSyncs:      10,
+				DeploymentControllerSyncPeriod: metav1.Duration{Duration: 45 * time.Second},
+			},
+			DeprecatedFlags: &cmoptions.DeprecatedControllerOptions{
+				DeletingPodsQPS:    0.1,
+				RegisterRetryCount: 10,
+			},
+			EndPointController: &cmoptions.EndPointControllerOptions{
+				ConcurrentEndpointSyncs: 10,
+			},
+			GarbageCollectorController: &cmoptions.GarbageCollectorControllerOptions{
+				ConcurrentGCSyncs: 30,
 				GCIgnoredResources: []componentconfig.GroupResource{
 					{Group: "extensions", Resource: "replicationcontrollers"},
 					{Group: "", Resource: "bindings"},
@@ -199,17 +190,70 @@ func TestAddFlags(t *testing.T) {
 					{Group: "apiregistration.k8s.io", Resource: "apiservices"},
 					{Group: "apiextensions.k8s.io", Resource: "customresourcedefinitions"},
 				},
-				NodeEvictionRate:                      0.2,
+				EnableGarbageCollector: false,
-				SecondaryNodeEvictionRate:             0.05,
-				LargeClusterSizeThreshold:             100,
-				UnhealthyZoneThreshold:                0.6,
-				DisableAttachDetachReconcilerSync:     true,
-				ReconcilerSyncLoopPeriod:              metav1.Duration{Duration: 30 * time.Second},
-				Controllers:                           []string{"foo", "bar"},
-				EnableTaintManager:                    false,
-				HorizontalPodAutoscalerUseRESTClients: true,
-				UseServiceAccountCredentials:          true,
 			},
+			HPAController: &cmoptions.HPAControllerOptions{
+				HorizontalPodAutoscalerSyncPeriod:               metav1.Duration{Duration: 45 * time.Second},
+				HorizontalPodAutoscalerUpscaleForbiddenWindow:   metav1.Duration{Duration: 1 * time.Minute},
+				HorizontalPodAutoscalerDownscaleForbiddenWindow: metav1.Duration{Duration: 2 * time.Minute},
+				HorizontalPodAutoscalerTolerance:                0.1,
+				HorizontalPodAutoscalerUseRESTClients:           true,
+			},
+			JobController: &cmoptions.JobControllerOptions{
+				ConcurrentJobSyncs: 5,
+			},
+			NamespaceController: &cmoptions.NamespaceControllerOptions{
+				NamespaceSyncPeriod:      metav1.Duration{Duration: 10 * time.Minute},
+				ConcurrentNamespaceSyncs: 20,
+			},
+			NodeIpamController: &cmoptions.NodeIpamControllerOptions{
+				NodeCIDRMaskSize: 48,
+			},
+			NodeLifecycleController: &cmoptions.NodeLifecycleControllerOptions{
+				EnableTaintManager:        false,
+				NodeEvictionRate:          0.2,
+				SecondaryNodeEvictionRate: 0.05,
+				NodeMonitorGracePeriod:    metav1.Duration{Duration: 30 * time.Second},
+				NodeStartupGracePeriod:    metav1.Duration{Duration: 30 * time.Second},
+				PodEvictionTimeout:        metav1.Duration{Duration: 2 * time.Minute},
+				LargeClusterSizeThreshold: 100,
+				UnhealthyZoneThreshold:    0.6,
+			},
+			PersistentVolumeBinderController: &cmoptions.PersistentVolumeBinderControllerOptions{
+				PVClaimBinderSyncPeriod: metav1.Duration{Duration: 30 * time.Second},
+				VolumeConfiguration: componentconfig.VolumeConfiguration{
+					EnableDynamicProvisioning:  false,
+					EnableHostPathProvisioning: true,
+					FlexVolumePluginDir:        "/flex-volume-plugin",
+					PersistentVolumeRecyclerConfiguration: componentconfig.PersistentVolumeRecyclerConfiguration{
+						MaximumRetry:             3,
+						MinimumTimeoutNFS:        200,
+						IncrementTimeoutNFS:      45,
+						MinimumTimeoutHostPath:   45,
+						IncrementTimeoutHostPath: 45,
+					},
+				},
+			},
+			PodGCController: &cmoptions.PodGCControllerOptions{
+				TerminatedPodGCThreshold: 12000,
+			},
+			ReplicaSetController: &cmoptions.ReplicaSetControllerOptions{
+				ConcurrentRSSyncs: 10,
+			},
+			ReplicationController: &cmoptions.ReplicationControllerOptions{
+				ConcurrentRCSyncs: 10,
+			},
+			ResourceQuotaController: &cmoptions.ResourceQuotaControllerOptions{
+				ResourceQuotaSyncPeriod:      metav1.Duration{Duration: 10 * time.Minute},
+				ConcurrentResourceQuotaSyncs: 10,
+			},
+			SAController: &cmoptions.SAControllerOptions{
+				ConcurrentSATokenSyncs: 10,
+			},
+			ServiceController: &cmoptions.ServiceControllerOptions{
+				ConcurrentServiceSyncs: 2,
+			},
+			Controllers: []string{"foo", "bar"},
 			SecureServing: &apiserveroptions.SecureServingOptions{
 				BindPort:    10001,
 				BindAddress: net.ParseIP("192.168.4.21"),
@@ -231,7 +275,7 @@ func TestAddFlags(t *testing.T) {
 
 	// Sort GCIgnoredResources because it's built from a map, which means the
 	// insertion order is random.
-	sort.Sort(sortedGCIgnoredResources(expected.Generic.ComponentConfig.GCIgnoredResources))
+	sort.Sort(sortedGCIgnoredResources(expected.Generic.GarbageCollectorController.GCIgnoredResources))
 
 	if !reflect.DeepEqual(expected, s) {
 		t.Errorf("Got different run options than expected.\nDifference detected on:\n%s", diff.ObjectReflectDiff(expected, s))

pkg/apis/componentconfig/v1alpha1/defaults.go

@@ -39,131 +39,131 @@ func SetDefaults_KubeControllerManagerConfiguration(obj *KubeControllerManagerCo
 		obj.Controllers = []string{"*"}
 	}
 	// Port
-	if obj.Address == "" {
+	if obj.KubeCloudShared.Address == "" {
-		obj.Address = "0.0.0.0"
+		obj.KubeCloudShared.Address = "0.0.0.0"
 	}
-	if obj.ConcurrentEndpointSyncs == 0 {
+	if obj.EndPointController.ConcurrentEndpointSyncs == 0 {
-		obj.ConcurrentEndpointSyncs = 5
+		obj.EndPointController.ConcurrentEndpointSyncs = 5
 	}
-	if obj.ConcurrentServiceSyncs == 0 {
+	if obj.ServiceController.ConcurrentServiceSyncs == 0 {
-		obj.ConcurrentServiceSyncs = 1
+		obj.ServiceController.ConcurrentServiceSyncs = 1
 	}
-	if obj.ConcurrentRCSyncs == 0 {
+	if obj.ReplicationController.ConcurrentRCSyncs == 0 {
-		obj.ConcurrentRCSyncs = 5
+		obj.ReplicationController.ConcurrentRCSyncs = 5
 	}
-	if obj.ConcurrentRSSyncs == 0 {
+	if obj.ReplicaSetController.ConcurrentRSSyncs == 0 {
-		obj.ConcurrentRSSyncs = 5
+		obj.ReplicaSetController.ConcurrentRSSyncs = 5
 	}
-	if obj.ConcurrentDaemonSetSyncs == 0 {
+	if obj.DaemonSetController.ConcurrentDaemonSetSyncs == 0 {
-		obj.ConcurrentDaemonSetSyncs = 2
+		obj.DaemonSetController.ConcurrentDaemonSetSyncs = 2
 	}
-	if obj.ConcurrentJobSyncs == 0 {
+	if obj.JobController.ConcurrentJobSyncs == 0 {
-		obj.ConcurrentJobSyncs = 5
+		obj.JobController.ConcurrentJobSyncs = 5
 	}
-	if obj.ConcurrentResourceQuotaSyncs == 0 {
+	if obj.ResourceQuotaController.ConcurrentResourceQuotaSyncs == 0 {
-		obj.ConcurrentResourceQuotaSyncs = 5
+		obj.ResourceQuotaController.ConcurrentResourceQuotaSyncs = 5
 	}
-	if obj.ConcurrentDeploymentSyncs == 0 {
+	if obj.DeploymentController.ConcurrentDeploymentSyncs == 0 {
-		obj.ConcurrentDeploymentSyncs = 5
+		obj.DeploymentController.ConcurrentDeploymentSyncs = 5
 	}
-	if obj.ConcurrentNamespaceSyncs == 0 {
+	if obj.NamespaceController.ConcurrentNamespaceSyncs == 0 {
-		obj.ConcurrentNamespaceSyncs = 10
+		obj.NamespaceController.ConcurrentNamespaceSyncs = 10
 	}
-	if obj.ConcurrentSATokenSyncs == 0 {
+	if obj.SAController.ConcurrentSATokenSyncs == 0 {
-		obj.ConcurrentSATokenSyncs = 5
+		obj.SAController.ConcurrentSATokenSyncs = 5
 	}
-	if obj.RouteReconciliationPeriod == zero {
+	if obj.KubeCloudShared.RouteReconciliationPeriod == zero {
-		obj.RouteReconciliationPeriod = metav1.Duration{Duration: 10 * time.Second}
+		obj.KubeCloudShared.RouteReconciliationPeriod = metav1.Duration{Duration: 10 * time.Second}
 	}
-	if obj.ResourceQuotaSyncPeriod == zero {
+	if obj.ResourceQuotaController.ResourceQuotaSyncPeriod == zero {
-		obj.ResourceQuotaSyncPeriod = metav1.Duration{Duration: 5 * time.Minute}
+		obj.ResourceQuotaController.ResourceQuotaSyncPeriod = metav1.Duration{Duration: 5 * time.Minute}
 	}
-	if obj.NamespaceSyncPeriod == zero {
+	if obj.NamespaceController.NamespaceSyncPeriod == zero {
-		obj.NamespaceSyncPeriod = metav1.Duration{Duration: 5 * time.Minute}
+		obj.NamespaceController.NamespaceSyncPeriod = metav1.Duration{Duration: 5 * time.Minute}
 	}
-	if obj.PVClaimBinderSyncPeriod == zero {
+	if obj.PersistentVolumeBinderController.PVClaimBinderSyncPeriod == zero {
-		obj.PVClaimBinderSyncPeriod = metav1.Duration{Duration: 15 * time.Second}
+		obj.PersistentVolumeBinderController.PVClaimBinderSyncPeriod = metav1.Duration{Duration: 15 * time.Second}
 	}
-	if obj.HorizontalPodAutoscalerSyncPeriod == zero {
+	if obj.HPAController.HorizontalPodAutoscalerSyncPeriod == zero {
-		obj.HorizontalPodAutoscalerSyncPeriod = metav1.Duration{Duration: 30 * time.Second}
+		obj.HPAController.HorizontalPodAutoscalerSyncPeriod = metav1.Duration{Duration: 30 * time.Second}
 	}
-	if obj.HorizontalPodAutoscalerUpscaleForbiddenWindow == zero {
+	if obj.HPAController.HorizontalPodAutoscalerUpscaleForbiddenWindow == zero {
-		obj.HorizontalPodAutoscalerUpscaleForbiddenWindow = metav1.Duration{Duration: 3 * time.Minute}
+		obj.HPAController.HorizontalPodAutoscalerUpscaleForbiddenWindow = metav1.Duration{Duration: 3 * time.Minute}
 	}
-	if obj.HorizontalPodAutoscalerDownscaleForbiddenWindow == zero {
+	if obj.HPAController.HorizontalPodAutoscalerDownscaleForbiddenWindow == zero {
-		obj.HorizontalPodAutoscalerDownscaleForbiddenWindow = metav1.Duration{Duration: 5 * time.Minute}
+		obj.HPAController.HorizontalPodAutoscalerDownscaleForbiddenWindow = metav1.Duration{Duration: 5 * time.Minute}
 	}
-	if obj.HorizontalPodAutoscalerTolerance == 0 {
+	if obj.HPAController.HorizontalPodAutoscalerTolerance == 0 {
-		obj.HorizontalPodAutoscalerTolerance = 0.1
+		obj.HPAController.HorizontalPodAutoscalerTolerance = 0.1
 	}
-	if obj.DeploymentControllerSyncPeriod == zero {
+	if obj.DeploymentController.DeploymentControllerSyncPeriod == zero {
-		obj.DeploymentControllerSyncPeriod = metav1.Duration{Duration: 30 * time.Second}
+		obj.DeploymentController.DeploymentControllerSyncPeriod = metav1.Duration{Duration: 30 * time.Second}
 	}
-	if obj.MinResyncPeriod == zero {
+	if obj.GenericComponent.MinResyncPeriod == zero {
-		obj.MinResyncPeriod = metav1.Duration{Duration: 12 * time.Hour}
+		obj.GenericComponent.MinResyncPeriod = metav1.Duration{Duration: 12 * time.Hour}
 	}
-	if obj.RegisterRetryCount == 0 {
+	if obj.DeprecatedController.RegisterRetryCount == 0 {
-		obj.RegisterRetryCount = 10
+		obj.DeprecatedController.RegisterRetryCount = 10
 	}
-	if obj.PodEvictionTimeout == zero {
+	if obj.NodeLifecycleController.PodEvictionTimeout == zero {
-		obj.PodEvictionTimeout = metav1.Duration{Duration: 5 * time.Minute}
+		obj.NodeLifecycleController.PodEvictionTimeout = metav1.Duration{Duration: 5 * time.Minute}
 	}
-	if obj.NodeMonitorGracePeriod == zero {
+	if obj.NodeLifecycleController.NodeMonitorGracePeriod == zero {
-		obj.NodeMonitorGracePeriod = metav1.Duration{Duration: 40 * time.Second}
+		obj.NodeLifecycleController.NodeMonitorGracePeriod = metav1.Duration{Duration: 40 * time.Second}
 	}
-	if obj.NodeStartupGracePeriod == zero {
+	if obj.NodeLifecycleController.NodeStartupGracePeriod == zero {
-		obj.NodeStartupGracePeriod = metav1.Duration{Duration: 60 * time.Second}
+		obj.NodeLifecycleController.NodeStartupGracePeriod = metav1.Duration{Duration: 60 * time.Second}
 	}
-	if obj.NodeMonitorPeriod == zero {
+	if obj.KubeCloudShared.NodeMonitorPeriod == zero {
-		obj.NodeMonitorPeriod = metav1.Duration{Duration: 5 * time.Second}
+		obj.KubeCloudShared.NodeMonitorPeriod = metav1.Duration{Duration: 5 * time.Second}
 	}
-	if obj.ClusterName == "" {
+	if obj.KubeCloudShared.ClusterName == "" {
-		obj.ClusterName = "kubernetes"
+		obj.KubeCloudShared.ClusterName = "kubernetes"
 	}
-	if obj.NodeCIDRMaskSize == 0 {
+	if obj.NodeIpamController.NodeCIDRMaskSize == 0 {
-		obj.NodeCIDRMaskSize = 24
+		obj.NodeIpamController.NodeCIDRMaskSize = 24
 	}
-	if obj.ConfigureCloudRoutes == nil {
+	if obj.KubeCloudShared.ConfigureCloudRoutes == nil {
-		obj.ConfigureCloudRoutes = utilpointer.BoolPtr(true)
+		obj.KubeCloudShared.ConfigureCloudRoutes = utilpointer.BoolPtr(true)
 	}
-	if obj.TerminatedPodGCThreshold == 0 {
+	if obj.PodGCController.TerminatedPodGCThreshold == 0 {
-		obj.TerminatedPodGCThreshold = 12500
+		obj.PodGCController.TerminatedPodGCThreshold = 12500
 	}
-	if obj.ContentType == "" {
+	if obj.GenericComponent.ContentType == "" {
-		obj.ContentType = "application/vnd.kubernetes.protobuf"
+		obj.GenericComponent.ContentType = "application/vnd.kubernetes.protobuf"
 	}
-	if obj.KubeAPIQPS == 0 {
+	if obj.GenericComponent.KubeAPIQPS == 0 {
-		obj.KubeAPIQPS = 20.0
+		obj.GenericComponent.KubeAPIQPS = 20.0
 	}
-	if obj.KubeAPIBurst == 0 {
+	if obj.GenericComponent.KubeAPIBurst == 0 {
-		obj.KubeAPIBurst = 30
+		obj.GenericComponent.KubeAPIBurst = 30
 	}
-	if obj.ControllerStartInterval == zero {
+	if obj.GenericComponent.ControllerStartInterval == zero {
-		obj.ControllerStartInterval = metav1.Duration{Duration: 0 * time.Second}
+		obj.GenericComponent.ControllerStartInterval = metav1.Duration{Duration: 0 * time.Second}
 	}
-	if obj.EnableGarbageCollector == nil {
+	if obj.GarbageCollectorController.EnableGarbageCollector == nil {
-		obj.EnableGarbageCollector = utilpointer.BoolPtr(true)
+		obj.GarbageCollectorController.EnableGarbageCollector = utilpointer.BoolPtr(true)
 	}
-	if obj.ConcurrentGCSyncs == 0 {
+	if obj.GarbageCollectorController.ConcurrentGCSyncs == 0 {
-		obj.ConcurrentGCSyncs = 20
+		obj.GarbageCollectorController.ConcurrentGCSyncs = 20
 	}
-	if obj.ClusterSigningCertFile == "" {
+	if obj.CSRSigningController.ClusterSigningCertFile == "" {
-		obj.ClusterSigningCertFile = "/etc/kubernetes/ca/ca.pem"
+		obj.CSRSigningController.ClusterSigningCertFile = "/etc/kubernetes/ca/ca.pem"
 	}
-	if obj.ClusterSigningKeyFile == "" {
+	if obj.CSRSigningController.ClusterSigningKeyFile == "" {
-		obj.ClusterSigningKeyFile = "/etc/kubernetes/ca/ca.key"
+		obj.CSRSigningController.ClusterSigningKeyFile = "/etc/kubernetes/ca/ca.key"
 	}
-	if obj.ClusterSigningDuration == zero {
+	if obj.CSRSigningController.ClusterSigningDuration == zero {
-		obj.ClusterSigningDuration = metav1.Duration{Duration: 365 * 24 * time.Hour}
+		obj.CSRSigningController.ClusterSigningDuration = metav1.Duration{Duration: 365 * 24 * time.Hour}
 	}
-	if obj.ReconcilerSyncLoopPeriod == zero {
+	if obj.AttachDetachController.ReconcilerSyncLoopPeriod == zero {
-		obj.ReconcilerSyncLoopPeriod = metav1.Duration{Duration: 60 * time.Second}
+		obj.AttachDetachController.ReconcilerSyncLoopPeriod = metav1.Duration{Duration: 60 * time.Second}
 	}
-	if obj.EnableTaintManager == nil {
+	if obj.NodeLifecycleController.EnableTaintManager == nil {
-		obj.EnableTaintManager = utilpointer.BoolPtr(true)
+		obj.NodeLifecycleController.EnableTaintManager = utilpointer.BoolPtr(true)
 	}
-	if obj.HorizontalPodAutoscalerUseRESTClients == nil {
+	if obj.HPAController.HorizontalPodAutoscalerUseRESTClients == nil {
-		obj.HorizontalPodAutoscalerUseRESTClients = utilpointer.BoolPtr(true)
+		obj.HPAController.HorizontalPodAutoscalerUseRESTClients = utilpointer.BoolPtr(true)
 	}
 }