Set leader-elect for kube-scheduler to true

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

@@ -52,7 +52,6 @@ func NewCloudControllerManagerOptions() *CloudControllerManagerOptions {
 		Generic:                   cmoptions.NewGenericControllerManagerOptions(componentConfig),
 		NodeStatusUpdateFrequency: metav1.Duration{Duration: 5 * time.Minute},
 	}
-	s.Generic.ComponentConfig.LeaderElection.LeaderElect = true
 
 	s.Generic.SecureServing.ServerCert.CertDirectory = "/var/run/kubernetes"
 	s.Generic.SecureServing.ServerCert.PairName = "cloud-controller-manager"

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

@@ -31,6 +31,106 @@ import (
 	"k8s.io/kubernetes/pkg/apis/componentconfig"
 )
 
+func TestDefaultFlags(t *testing.T) {
+	s := NewCloudControllerManagerOptions()
+
+	expected := &CloudControllerManagerOptions{
+		Generic: cmoptions.GenericControllerManagerOptions{
+			ComponentConfig: componentconfig.KubeControllerManagerConfiguration{
+				CloudProvider:                                   "",
+				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
+				ConcurrentEndpointSyncs:                         5,
+				ConcurrentRSSyncs:                               5,
+				ConcurrentResourceQuotaSyncs:                    5,
+				ConcurrentDeploymentSyncs:                       5,
+				ConcurrentDaemonSetSyncs:                        2,
+				ConcurrentJobSyncs:                              5,
+				ConcurrentNamespaceSyncs:                        10,
+				ConcurrentSATokenSyncs:                          5,
+				ConcurrentServiceSyncs:                          1,
+				ConcurrentGCSyncs:                               20,
+				ConcurrentRCSyncs:                               5,
+				MinResyncPeriod:                                 metav1.Duration{Duration: 12 * time.Hour},
+				NodeMonitorPeriod:                               metav1.Duration{Duration: 5 * time.Second},
+				ResourceQuotaSyncPeriod:                         metav1.Duration{Duration: 5 * time.Minute},
+				NamespaceSyncPeriod:                             metav1.Duration{Duration: 5 * time.Minute},
+				PVClaimBinderSyncPeriod:                         metav1.Duration{Duration: 15 * time.Second},
+				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,
+				VolumeConfiguration: componentconfig.VolumeConfiguration{
+					EnableDynamicProvisioning:  true,
+					EnableHostPathProvisioning: false,
+					FlexVolumePluginDir:        "/usr/libexec/kubernetes/kubelet-plugins/volume/exec/",
+					PersistentVolumeRecyclerConfiguration: componentconfig.PersistentVolumeRecyclerConfiguration{
+						MaximumRetry:             3,
+						MinimumTimeoutNFS:        300,
+						IncrementTimeoutNFS:      30,
+						MinimumTimeoutHostPath:   60,
+						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{"*"},
+			},
+			SecureServing: &apiserveroptions.SecureServingOptions{
+				BindPort:    0,
+				BindAddress: net.ParseIP("0.0.0.0"),
+				ServerCert: apiserveroptions.GeneratableKeyCert{
+					CertDirectory: "/var/run/kubernetes",
+					PairName:      "cloud-controller-manager",
+				},
+				HTTP2MaxStreamsPerConnection: 0,
+			},
+			InsecureServing: &cmoptions.InsecureServingOptions{
+				BindAddress: net.ParseIP("0.0.0.0"),
+				BindPort:    int(10253),
+				BindNetwork: "tcp",
+			},
+			Kubeconfig: "",
+			Master:     "",
+		},
+		NodeStatusUpdateFrequency: metav1.Duration{Duration: 5 * time.Minute},
+	}
+	if !reflect.DeepEqual(expected, s) {
+		t.Errorf("Got different run options than expected.\nDifference detected on:\n%s", diff.ObjectReflectDiff(expected, s))
+	}
+}
+
 func TestAddFlags(t *testing.T) {
 	f := pflag.NewFlagSet("addflagstest", pflag.ContinueOnError)
 	s := NewCloudControllerManagerOptions()

cmd/controller-manager/app/options/BUILD

@@ -12,12 +12,11 @@ go_library(
         "//cmd/controller-manager/app:go_default_library",
         "//pkg/api/legacyscheme:go_default_library",
         "//pkg/apis/componentconfig:go_default_library",
-        "//pkg/client/leaderelectionconfig:go_default_library",
-        "//vendor/github.com/cloudflare/cfssl/helpers:go_default_library",
+        "//pkg/apis/componentconfig/v1alpha1:go_default_library",
         "//vendor/github.com/golang/glog:go_default_library",
         "//vendor/github.com/spf13/pflag:go_default_library",
         "//vendor/k8s.io/api/core/v1:go_default_library",
-        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
         "//vendor/k8s.io/apiserver/pkg/server/options:go_default_library",
         "//vendor/k8s.io/client-go/kubernetes:go_default_library",
         "//vendor/k8s.io/client-go/kubernetes/typed/core/v1:go_default_library",

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

@@ -18,14 +18,12 @@ package options
 
 import (
 	"net"
-	"time"
 
-	"github.com/cloudflare/cfssl/helpers"
 	"github.com/golang/glog"
 
 	"github.com/spf13/pflag"
 	"k8s.io/api/core/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
 	apiserveroptions "k8s.io/apiserver/pkg/server/options"
 	"k8s.io/client-go/kubernetes"
 	clientset "k8s.io/client-go/kubernetes"
@@ -36,7 +34,7 @@ import (
 	genericcontrollermanager "k8s.io/kubernetes/cmd/controller-manager/app"
 	"k8s.io/kubernetes/pkg/api/legacyscheme"
 	"k8s.io/kubernetes/pkg/apis/componentconfig"
-	"k8s.io/kubernetes/pkg/client/leaderelectionconfig"
+	componentconfigv1alpha1 "k8s.io/kubernetes/pkg/apis/componentconfig/v1alpha1"
 )
 
 // GenericControllerManagerOptions is the common structure for a controller manager. It works with NewGenericControllerManagerOptions
@@ -90,65 +88,14 @@ func NewGenericControllerManagerOptions(componentConfig componentconfig.KubeCont
 
 // NewDefaultControllerManagerComponentConfig returns default kube-controller manager configuration object.
 func NewDefaultControllerManagerComponentConfig(insecurePort int32) componentconfig.KubeControllerManagerConfiguration {
-	return componentconfig.KubeControllerManagerConfiguration{
-		Controllers:                                     []string{"*"},
-		Port:                                            insecurePort,
-		Address:                                         "0.0.0.0",
-		ConcurrentEndpointSyncs:                         5,
-		ConcurrentServiceSyncs:                          1,
-		ConcurrentRCSyncs:                               5,
-		ConcurrentRSSyncs:                               5,
-		ConcurrentDaemonSetSyncs:                        2,
-		ConcurrentJobSyncs:                              5,
-		ConcurrentResourceQuotaSyncs:                    5,
-		ConcurrentDeploymentSyncs:                       5,
-		ConcurrentNamespaceSyncs:                        10,
-		ConcurrentSATokenSyncs:                          5,
-		RouteReconciliationPeriod:                       metav1.Duration{Duration: 10 * time.Second},
-		ResourceQuotaSyncPeriod:                         metav1.Duration{Duration: 5 * time.Minute},
-		NamespaceSyncPeriod:                             metav1.Duration{Duration: 5 * time.Minute},
-		PVClaimBinderSyncPeriod:                         metav1.Duration{Duration: 15 * time.Second},
-		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},
-		MinResyncPeriod:                                 metav1.Duration{Duration: 12 * time.Hour},
-		RegisterRetryCount:                              10,
-		PodEvictionTimeout:                              metav1.Duration{Duration: 5 * time.Minute},
-		NodeMonitorGracePeriod:                          metav1.Duration{Duration: 40 * time.Second},
-		NodeStartupGracePeriod:                          metav1.Duration{Duration: 60 * time.Second},
-		NodeMonitorPeriod:                               metav1.Duration{Duration: 5 * time.Second},
-		ClusterName:                                     "kubernetes",
-		NodeCIDRMaskSize:                                24,
-		ConfigureCloudRoutes:                            true,
-		TerminatedPodGCThreshold:                        12500,
-		VolumeConfiguration: componentconfig.VolumeConfiguration{
-			EnableHostPathProvisioning: false,
-			EnableDynamicProvisioning:  true,
-			PersistentVolumeRecyclerConfiguration: componentconfig.PersistentVolumeRecyclerConfiguration{
-				MaximumRetry:             3,
-				MinimumTimeoutNFS:        300,
-				IncrementTimeoutNFS:      30,
-				MinimumTimeoutHostPath:   60,
-				IncrementTimeoutHostPath: 30,
-			},
-			FlexVolumePluginDir: "/usr/libexec/kubernetes/kubelet-plugins/volume/exec/",
-		},
-		ContentType:                           "application/vnd.kubernetes.protobuf",
-		KubeAPIQPS:                            20.0,
-		KubeAPIBurst:                          30,
-		LeaderElection:                        leaderelectionconfig.DefaultLeaderElectionConfiguration(),
-		ControllerStartInterval:               metav1.Duration{Duration: 0 * time.Second},
-		EnableGarbageCollector:                true,
-		ConcurrentGCSyncs:                     20,
-		ClusterSigningCertFile:                DefaultClusterSigningCertFile,
-		ClusterSigningKeyFile:                 DefaultClusterSigningKeyFile,
-		ClusterSigningDuration:                metav1.Duration{Duration: helpers.OneYear},
-		ReconcilerSyncLoopPeriod:              metav1.Duration{Duration: 60 * time.Second},
-		EnableTaintManager:                    true,
-		HorizontalPodAutoscalerUseRESTClients: true,
-	}
+	scheme := runtime.NewScheme()
+	componentconfigv1alpha1.AddToScheme(scheme)
+	versioned := componentconfigv1alpha1.KubeControllerManagerConfiguration{}
+	scheme.Default(&versioned)
+	internal := componentconfig.KubeControllerManagerConfiguration{}
+	scheme.Convert(&versioned, &internal, nil)
+	internal.Port = insecurePort
+	return internal
 }
 
 // AddFlags adds common/default flags for both the kube and cloud Controller Manager Server to the

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

@@ -60,7 +60,6 @@ func NewKubeControllerManagerOptions() *KubeControllerManagerOptions {
 		gcIgnoredResources = append(gcIgnoredResources, componentconfig.GroupResource{Group: r.Group, Resource: r.Resource})
 	}
 	s.Generic.ComponentConfig.GCIgnoredResources = gcIgnoredResources
-	s.Generic.ComponentConfig.LeaderElection.LeaderElect = true
 
 	return &s
 }

cmd/kube-scheduler/app/server.go

@@ -152,8 +152,14 @@ func NewOptions() (*Options, error) {
 		return nil, err
 	}
 
-	// TODO: we should fix this up better (PR 59732)
-	o.config.LeaderElection.LeaderElect = true
+	externalConfig := &componentconfigv1alpha1.KubeSchedulerConfiguration{}
+	// Assume we are starting with an empty external configuration, we apply
+	// defaults and then convert it into an internal data structure. This helps
+	// ensure that all the defaults are applied correctly (example LeaderElect)
+	o.scheme.Default(externalConfig)
+	if err := o.scheme.Convert(externalConfig, o.config, nil); err != nil {
+		return nil, err
+	}
 
 	return o, nil
 }

pkg/apis/componentconfig/types.go

@@ -117,6 +117,7 @@ type KubeSchedulerConfiguration struct {
 // to include scheduler specific configuration.
 type KubeSchedulerLeaderElectionConfiguration struct {
 	LeaderElectionConfiguration
+
 	// LockObjectNamespace defines the namespace of the lock object
 	LockObjectNamespace string
 	// LockObjectName defines the lock object name

pkg/apis/componentconfig/v1alpha1/BUILD

@@ -23,6 +23,7 @@ go_library(
         "//pkg/apis/core:go_default_library",
         "//pkg/kubelet/apis:go_default_library",
         "//pkg/master/ports:go_default_library",
+        "//pkg/util/pointer:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/conversion:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",

pkg/apis/componentconfig/v1alpha1/defaults.go

@@ -26,12 +26,177 @@ import (
 	api "k8s.io/kubernetes/pkg/apis/core"
 	kubeletapis "k8s.io/kubernetes/pkg/kubelet/apis"
 	"k8s.io/kubernetes/pkg/master/ports"
+	utilpointer "k8s.io/kubernetes/pkg/util/pointer"
 )
 
 func addDefaultingFuncs(scheme *kruntime.Scheme) error {
 	return RegisterDefaults(scheme)
 }
 
+func SetDefaults_KubeControllerManagerConfiguration(obj *KubeControllerManagerConfiguration) {
+	zero := metav1.Duration{}
+	if len(obj.Controllers) == 0 {
+		obj.Controllers = []string{"*"}
+	}
+	// Port
+	if obj.Address == "" {
+		obj.Address = "0.0.0.0"
+	}
+	if obj.ConcurrentEndpointSyncs == 0 {
+		obj.ConcurrentEndpointSyncs = 5
+	}
+	if obj.ConcurrentServiceSyncs == 0 {
+		obj.ConcurrentServiceSyncs = 1
+	}
+	if obj.ConcurrentRCSyncs == 0 {
+		obj.ConcurrentRCSyncs = 5
+	}
+	if obj.ConcurrentRSSyncs == 0 {
+		obj.ConcurrentRSSyncs = 5
+	}
+	if obj.ConcurrentDaemonSetSyncs == 0 {
+		obj.ConcurrentDaemonSetSyncs = 2
+	}
+	if obj.ConcurrentJobSyncs == 0 {
+		obj.ConcurrentJobSyncs = 5
+	}
+	if obj.ConcurrentResourceQuotaSyncs == 0 {
+		obj.ConcurrentResourceQuotaSyncs = 5
+	}
+	if obj.ConcurrentDeploymentSyncs == 0 {
+		obj.ConcurrentDeploymentSyncs = 5
+	}
+	if obj.ConcurrentNamespaceSyncs == 0 {
+		obj.ConcurrentNamespaceSyncs = 10
+	}
+	if obj.ConcurrentSATokenSyncs == 0 {
+		obj.ConcurrentSATokenSyncs = 5
+	}
+	if obj.RouteReconciliationPeriod == zero {
+		obj.RouteReconciliationPeriod = metav1.Duration{Duration: 10 * time.Second}
+	}
+	if obj.ResourceQuotaSyncPeriod == zero {
+		obj.ResourceQuotaSyncPeriod = metav1.Duration{Duration: 5 * time.Minute}
+	}
+	if obj.NamespaceSyncPeriod == zero {
+		obj.NamespaceSyncPeriod = metav1.Duration{Duration: 5 * time.Minute}
+	}
+	if obj.PVClaimBinderSyncPeriod == zero {
+		obj.PVClaimBinderSyncPeriod = metav1.Duration{Duration: 15 * time.Second}
+	}
+	if obj.HorizontalPodAutoscalerSyncPeriod == zero {
+		obj.HorizontalPodAutoscalerSyncPeriod = metav1.Duration{Duration: 30 * time.Second}
+	}
+	if obj.HorizontalPodAutoscalerUpscaleForbiddenWindow == zero {
+		obj.HorizontalPodAutoscalerUpscaleForbiddenWindow = metav1.Duration{Duration: 3 * time.Minute}
+	}
+	if obj.HorizontalPodAutoscalerDownscaleForbiddenWindow == zero {
+		obj.HorizontalPodAutoscalerDownscaleForbiddenWindow = metav1.Duration{Duration: 5 * time.Minute}
+	}
+	if obj.HorizontalPodAutoscalerTolerance == 0 {
+		obj.HorizontalPodAutoscalerTolerance = 0.1
+	}
+	if obj.DeploymentControllerSyncPeriod == zero {
+		obj.DeploymentControllerSyncPeriod = metav1.Duration{Duration: 30 * time.Second}
+	}
+	if obj.MinResyncPeriod == zero {
+		obj.MinResyncPeriod = metav1.Duration{Duration: 12 * time.Hour}
+	}
+	if obj.RegisterRetryCount == 0 {
+		obj.RegisterRetryCount = 10
+	}
+	if obj.PodEvictionTimeout == zero {
+		obj.PodEvictionTimeout = metav1.Duration{Duration: 5 * time.Minute}
+	}
+	if obj.NodeMonitorGracePeriod == zero {
+		obj.NodeMonitorGracePeriod = metav1.Duration{Duration: 40 * time.Second}
+	}
+	if obj.NodeStartupGracePeriod == zero {
+		obj.NodeStartupGracePeriod = metav1.Duration{Duration: 60 * time.Second}
+	}
+	if obj.NodeMonitorPeriod == zero {
+		obj.NodeMonitorPeriod = metav1.Duration{Duration: 5 * time.Second}
+	}
+	if obj.ClusterName == "" {
+		obj.ClusterName = "kubernetes"
+	}
+	if obj.NodeCIDRMaskSize == 0 {
+		obj.NodeCIDRMaskSize = 24
+	}
+	if obj.ConfigureCloudRoutes == nil {
+		obj.ConfigureCloudRoutes = utilpointer.BoolPtr(true)
+	}
+	if obj.TerminatedPodGCThreshold == 0 {
+		obj.TerminatedPodGCThreshold = 12500
+	}
+	if obj.ContentType == "" {
+		obj.ContentType = "application/vnd.kubernetes.protobuf"
+	}
+	if obj.KubeAPIQPS == 0 {
+		obj.KubeAPIQPS = 20.0
+	}
+	if obj.KubeAPIBurst == 0 {
+		obj.KubeAPIBurst = 30
+	}
+	if obj.ControllerStartInterval == zero {
+		obj.ControllerStartInterval = metav1.Duration{Duration: 0 * time.Second}
+	}
+	if obj.EnableGarbageCollector == nil {
+		obj.EnableGarbageCollector = utilpointer.BoolPtr(true)
+	}
+	if obj.ConcurrentGCSyncs == 0 {
+		obj.ConcurrentGCSyncs = 20
+	}
+	if obj.ClusterSigningCertFile == "" {
+		obj.ClusterSigningCertFile = "/etc/kubernetes/ca/ca.pem"
+	}
+	if obj.ClusterSigningKeyFile == "" {
+		obj.ClusterSigningKeyFile = "/etc/kubernetes/ca/ca.key"
+	}
+	if obj.ClusterSigningDuration == zero {
+		obj.ClusterSigningDuration = metav1.Duration{Duration: 365 * 24 * time.Hour}
+	}
+	if obj.ReconcilerSyncLoopPeriod == zero {
+		obj.ReconcilerSyncLoopPeriod = metav1.Duration{Duration: 60 * time.Second}
+	}
+	if obj.EnableTaintManager == nil {
+		obj.EnableTaintManager = utilpointer.BoolPtr(true)
+	}
+	if obj.HorizontalPodAutoscalerUseRESTClients == nil {
+		obj.HorizontalPodAutoscalerUseRESTClients = utilpointer.BoolPtr(true)
+	}
+}
+
+func SetDefaults_PersistentVolumeRecyclerConfiguration(obj *PersistentVolumeRecyclerConfiguration) {
+	if obj.MaximumRetry == 0 {
+		obj.MaximumRetry = 3
+	}
+	if obj.MinimumTimeoutNFS == 0 {
+		obj.MinimumTimeoutNFS = 300
+	}
+	if obj.IncrementTimeoutNFS == 0 {
+		obj.IncrementTimeoutNFS = 30
+	}
+	if obj.MinimumTimeoutHostPath == 0 {
+		obj.MinimumTimeoutHostPath = 60
+	}
+	if obj.IncrementTimeoutHostPath == 0 {
+		obj.IncrementTimeoutHostPath = 30
+	}
+}
+
+func SetDefaults_VolumeConfiguration(obj *VolumeConfiguration) {
+	if obj.EnableHostPathProvisioning == nil {
+		obj.EnableHostPathProvisioning = utilpointer.BoolPtr(false)
+	}
+	if obj.EnableDynamicProvisioning == nil {
+		obj.EnableDynamicProvisioning = utilpointer.BoolPtr(true)
+	}
+	if obj.FlexVolumePluginDir == "" {
+		obj.FlexVolumePluginDir = "/usr/libexec/kubernetes/kubelet-plugins/volume/exec/"
+	}
+}
+
 func SetDefaults_KubeSchedulerConfiguration(obj *KubeSchedulerConfiguration) {
 	if len(obj.SchedulerName) == 0 {
 		obj.SchedulerName = api.DefaultSchedulerName
@@ -108,4 +273,7 @@ func SetDefaults_LeaderElectionConfiguration(obj *LeaderElectionConfiguration) {
 		// obj.ResourceLock = rl.EndpointsResourceLock
 		obj.ResourceLock = "endpoints"
 	}
+	if obj.LeaderElect == nil {
+		obj.LeaderElect = utilpointer.BoolPtr(true)
+	}
 }

pkg/apis/componentconfig/v1alpha1/defaults_test.go

@@ -41,3 +41,21 @@ func TestSchedulerDefaults(t *testing.T) {
 		t.Errorf("Expected:\n%#v\n\nGot:\n%#v", ks1, ks2)
 	}
 }
+
+func TestControllerDefaultsRoundTrip(t *testing.T) {
+	ks1 := &KubeControllerManagerConfiguration{}
+	SetDefaults_KubeControllerManagerConfiguration(ks1)
+	cm, err := componentconfig.ConvertObjToConfigMap("KubeControllerManagerConfiguration", ks1)
+	if err != nil {
+		t.Errorf("unexpected ConvertObjToConfigMap error %v", err)
+	}
+
+	ks2 := &KubeControllerManagerConfiguration{}
+	if err = json.Unmarshal([]byte(cm.Data["KubeControllerManagerConfiguration"]), ks2); err != nil {
+		t.Errorf("unexpected error unserializing controller manager config %v", err)
+	}
+
+	if !reflect.DeepEqual(ks2, ks1) {
+		t.Errorf("Expected:\n%#v\n\nGot:\n%#v", ks1, ks2)
+	}
+}

pkg/apis/componentconfig/v1alpha1/zz_generated.deepcopy.go

@@ -41,6 +41,112 @@ func (in *ClientConnectionConfiguration) DeepCopy() *ClientConnectionConfigurati
 }
 
 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *GroupResource) DeepCopyInto(out *GroupResource) {
+	*out = *in
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GroupResource.
+func (in *GroupResource) DeepCopy() *GroupResource {
+	if in == nil {
+		return nil
+	}
+	out := new(GroupResource)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *KubeControllerManagerConfiguration) DeepCopyInto(out *KubeControllerManagerConfiguration) {
+	*out = *in
+	out.TypeMeta = in.TypeMeta
+	if in.Controllers != nil {
+		in, out := &in.Controllers, &out.Controllers
+		*out = make([]string, len(*in))
+		copy(*out, *in)
+	}
+	out.NodeSyncPeriod = in.NodeSyncPeriod
+	out.RouteReconciliationPeriod = in.RouteReconciliationPeriod
+	out.ResourceQuotaSyncPeriod = in.ResourceQuotaSyncPeriod
+	out.NamespaceSyncPeriod = in.NamespaceSyncPeriod
+	out.PVClaimBinderSyncPeriod = in.PVClaimBinderSyncPeriod
+	out.MinResyncPeriod = in.MinResyncPeriod
+	out.HorizontalPodAutoscalerSyncPeriod = in.HorizontalPodAutoscalerSyncPeriod
+	out.HorizontalPodAutoscalerUpscaleForbiddenWindow = in.HorizontalPodAutoscalerUpscaleForbiddenWindow
+	out.HorizontalPodAutoscalerDownscaleForbiddenWindow = in.HorizontalPodAutoscalerDownscaleForbiddenWindow
+	out.DeploymentControllerSyncPeriod = in.DeploymentControllerSyncPeriod
+	out.PodEvictionTimeout = in.PodEvictionTimeout
+	out.NodeMonitorGracePeriod = in.NodeMonitorGracePeriod
+	out.NodeStartupGracePeriod = in.NodeStartupGracePeriod
+	out.NodeMonitorPeriod = in.NodeMonitorPeriod
+	out.ClusterSigningDuration = in.ClusterSigningDuration
+	if in.ConfigureCloudRoutes != nil {
+		in, out := &in.ConfigureCloudRoutes, &out.ConfigureCloudRoutes
+		if *in == nil {
+			*out = nil
+		} else {
+			*out = new(bool)
+			**out = **in
+		}
+	}
+	in.LeaderElection.DeepCopyInto(&out.LeaderElection)
+	in.VolumeConfiguration.DeepCopyInto(&out.VolumeConfiguration)
+	out.ControllerStartInterval = in.ControllerStartInterval
+	if in.EnableGarbageCollector != nil {
+		in, out := &in.EnableGarbageCollector, &out.EnableGarbageCollector
+		if *in == nil {
+			*out = nil
+		} else {
+			*out = new(bool)
+			**out = **in
+		}
+	}
+	if in.GCIgnoredResources != nil {
+		in, out := &in.GCIgnoredResources, &out.GCIgnoredResources
+		*out = make([]GroupResource, len(*in))
+		copy(*out, *in)
+	}
+	out.ReconcilerSyncLoopPeriod = in.ReconcilerSyncLoopPeriod
+	if in.EnableTaintManager != nil {
+		in, out := &in.EnableTaintManager, &out.EnableTaintManager
+		if *in == nil {
+			*out = nil
+		} else {
+			*out = new(bool)
+			**out = **in
+		}
+	}
+	if in.HorizontalPodAutoscalerUseRESTClients != nil {
+		in, out := &in.HorizontalPodAutoscalerUseRESTClients, &out.HorizontalPodAutoscalerUseRESTClients
+		if *in == nil {
+			*out = nil
+		} else {
+			*out = new(bool)
+			**out = **in
+		}
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new KubeControllerManagerConfiguration.
+func (in *KubeControllerManagerConfiguration) DeepCopy() *KubeControllerManagerConfiguration {
+	if in == nil {
+		return nil
+	}
+	out := new(KubeControllerManagerConfiguration)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (in *KubeControllerManagerConfiguration) DeepCopyObject() runtime.Object {
+	if c := in.DeepCopy(); c != nil {
+		return c
+	}
+	return nil
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
 func (in *KubeSchedulerConfiguration) DeepCopyInto(out *KubeSchedulerConfiguration) {
 	*out = *in
 	out.TypeMeta = in.TypeMeta
@@ -114,6 +220,22 @@ func (in *LeaderElectionConfiguration) DeepCopy() *LeaderElectionConfiguration {
 }
 
 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *PersistentVolumeRecyclerConfiguration) DeepCopyInto(out *PersistentVolumeRecyclerConfiguration) {
+	*out = *in
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PersistentVolumeRecyclerConfiguration.
+func (in *PersistentVolumeRecyclerConfiguration) DeepCopy() *PersistentVolumeRecyclerConfiguration {
+	if in == nil {
+		return nil
+	}
+	out := new(PersistentVolumeRecyclerConfiguration)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
 func (in *SchedulerAlgorithmSource) DeepCopyInto(out *SchedulerAlgorithmSource) {
 	*out = *in
 	if in.Policy != nil {
@@ -212,3 +334,38 @@ func (in *SchedulerPolicySource) DeepCopy() *SchedulerPolicySource {
 	in.DeepCopyInto(out)
 	return out
 }
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *VolumeConfiguration) DeepCopyInto(out *VolumeConfiguration) {
+	*out = *in
+	if in.EnableHostPathProvisioning != nil {
+		in, out := &in.EnableHostPathProvisioning, &out.EnableHostPathProvisioning
+		if *in == nil {
+			*out = nil
+		} else {
+			*out = new(bool)
+			**out = **in
+		}
+	}
+	if in.EnableDynamicProvisioning != nil {
+		in, out := &in.EnableDynamicProvisioning, &out.EnableDynamicProvisioning
+		if *in == nil {
+			*out = nil
+		} else {
+			*out = new(bool)
+			**out = **in
+		}
+	}
+	out.PersistentVolumeRecyclerConfiguration = in.PersistentVolumeRecyclerConfiguration
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VolumeConfiguration.
+func (in *VolumeConfiguration) DeepCopy() *VolumeConfiguration {
+	if in == nil {
+		return nil
+	}
+	out := new(VolumeConfiguration)
+	in.DeepCopyInto(out)
+	return out
+}

pkg/apis/componentconfig/v1alpha1/zz_generated.defaults.go

@@ -28,10 +28,20 @@ import (
 // Public to allow building arbitrary schemes.
 // All generated defaulters are covering - they call all nested defaulters.
 func RegisterDefaults(scheme *runtime.Scheme) error {
+	scheme.AddTypeDefaultingFunc(&KubeControllerManagerConfiguration{}, func(obj interface{}) {
+		SetObjectDefaults_KubeControllerManagerConfiguration(obj.(*KubeControllerManagerConfiguration))
+	})
 	scheme.AddTypeDefaultingFunc(&KubeSchedulerConfiguration{}, func(obj interface{}) { SetObjectDefaults_KubeSchedulerConfiguration(obj.(*KubeSchedulerConfiguration)) })
 	return nil
 }
 
+func SetObjectDefaults_KubeControllerManagerConfiguration(in *KubeControllerManagerConfiguration) {
+	SetDefaults_KubeControllerManagerConfiguration(in)
+	SetDefaults_LeaderElectionConfiguration(&in.LeaderElection)
+	SetDefaults_VolumeConfiguration(&in.VolumeConfiguration)
+	SetDefaults_PersistentVolumeRecyclerConfiguration(&in.VolumeConfiguration.PersistentVolumeRecyclerConfiguration)
+}
+
 func SetObjectDefaults_KubeSchedulerConfiguration(in *KubeSchedulerConfiguration) {
 	SetDefaults_KubeSchedulerConfiguration(in)
 	SetDefaults_LeaderElectionConfiguration(&in.LeaderElection.LeaderElectionConfiguration)

pkg/client/leaderelectionconfig/BUILD

@@ -12,8 +12,6 @@ go_library(
     deps = [
         "//pkg/apis/componentconfig:go_default_library",
         "//vendor/github.com/spf13/pflag:go_default_library",
-        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
-        "//vendor/k8s.io/client-go/tools/leaderelection/resourcelock:go_default_library",
     ],
 )
 

pkg/client/leaderelectionconfig/config.go

@@ -20,27 +20,13 @@ import (
 	"time"
 
 	"github.com/spf13/pflag"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	rl "k8s.io/client-go/tools/leaderelection/resourcelock"
 	"k8s.io/kubernetes/pkg/apis/componentconfig"
 )
 
 const (
 	DefaultLeaseDuration = 15 * time.Second
-	DefaultRenewDeadline = 10 * time.Second
-	DefaultRetryPeriod   = 2 * time.Second
 )
 
-func DefaultLeaderElectionConfiguration() componentconfig.LeaderElectionConfiguration {
-	return componentconfig.LeaderElectionConfiguration{
-		LeaderElect:   false,
-		LeaseDuration: metav1.Duration{Duration: DefaultLeaseDuration},
-		RenewDeadline: metav1.Duration{Duration: DefaultRenewDeadline},
-		RetryPeriod:   metav1.Duration{Duration: DefaultRetryPeriod},
-		ResourceLock:  rl.EndpointsResourceLock,
-	}
-}
-
 // BindFlags binds the common LeaderElectionCLIConfig flags to a flagset
 func BindFlags(l *componentconfig.LeaderElectionConfiguration, fs *pflag.FlagSet) {
 	fs.BoolVar(&l.LeaderElect, "leader-elect", l.LeaderElect, ""+