modify kube-controller manager config struct to adapt option change

cmd/controller-manager/app/config.go

@@ -1,64 +0,0 @@
-/*
-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 app
-
-import (
-	apiserver "k8s.io/apiserver/pkg/server"
-	clientset "k8s.io/client-go/kubernetes"
-	restclient "k8s.io/client-go/rest"
-	"k8s.io/client-go/tools/record"
-	"k8s.io/kubernetes/pkg/apis/componentconfig"
-)
-
-// Config is the main context object for the controller manager.
-type Config struct {
-	ComponentConfig componentconfig.KubeControllerManagerConfiguration
-
-	SecureServing *apiserver.SecureServingInfo
-	// TODO: remove deprecated insecure serving
-	InsecureServing *InsecureServingInfo
-	Authentication  apiserver.AuthenticationInfo
-	Authorization   apiserver.AuthorizationInfo
-
-	// the general kube client
-	Client *clientset.Clientset
-
-	// the client only used for leader election
-	LeaderElectionClient *clientset.Clientset
-
-	// the rest config for the master
-	Kubeconfig *restclient.Config
-
-	// the event sink
-	EventRecorder record.EventRecorder
-}
-
-type completedConfig struct {
-	*Config
-}
-
-// CompletedConfig same as Config, just to swap private object.
-type CompletedConfig struct {
-	// Embed a private pointer that cannot be instantiated outside of this package.
-	*completedConfig
-}
-
-// Complete fills in any fields not set that are required to have valid data. It's mutating the receiver.
-func (c *Config) Complete() CompletedConfig {
-	cc := completedConfig{c}
-	return CompletedConfig{&cc}
-}

cmd/controller-manager/app/serve.go

@@ -24,21 +24,23 @@ import (
 
 	genericapifilters "k8s.io/apiserver/pkg/endpoints/filters"
 	apirequest "k8s.io/apiserver/pkg/endpoints/request"
+	apiserver "k8s.io/apiserver/pkg/server"
 	genericfilters "k8s.io/apiserver/pkg/server/filters"
 	"k8s.io/apiserver/pkg/server/healthz"
 	"k8s.io/apiserver/pkg/server/mux"
 	"k8s.io/apiserver/pkg/server/routes"
 	"k8s.io/kubernetes/pkg/api/legacyscheme"
+	"k8s.io/kubernetes/pkg/apis/componentconfig"
 	"k8s.io/kubernetes/pkg/util/configz"
 )
 
 // BuildHandlerChain builds a handler chain with a base handler and CompletedConfig.
-func BuildHandlerChain(apiHandler http.Handler, c *CompletedConfig) http.Handler {
+func BuildHandlerChain(apiHandler http.Handler, authorizationInfo *apiserver.AuthorizationInfo, authenticationInfo *apiserver.AuthenticationInfo) http.Handler {
 	requestInfoResolver := &apirequest.RequestInfoFactory{}
 	failedHandler := genericapifilters.Unauthorized(legacyscheme.Codecs, false)
 
-	handler := genericapifilters.WithAuthorization(apiHandler, c.Authorization.Authorizer, legacyscheme.Codecs)
+	handler := genericapifilters.WithAuthorization(apiHandler, authorizationInfo.Authorizer, legacyscheme.Codecs)
-	handler = genericapifilters.WithAuthentication(handler, c.Authentication.Authenticator, failedHandler)
+	handler = genericapifilters.WithAuthentication(handler, authenticationInfo.Authenticator, failedHandler)
 	handler = genericapifilters.WithRequestInfo(handler, requestInfoResolver)
 	handler = genericfilters.WithPanicRecovery(handler)
 
@@ -46,12 +48,12 @@ func BuildHandlerChain(apiHandler http.Handler, c *CompletedConfig) http.Handler
 }
 
 // NewBaseHandler takes in CompletedConfig and returns a handler.
-func NewBaseHandler(c *CompletedConfig) http.Handler {
+func NewBaseHandler(c *componentconfig.DebuggingConfiguration) http.Handler {
 	mux := mux.NewPathRecorderMux("controller-manager")
 	healthz.InstallHandler(mux)
-	if c.ComponentConfig.Debugging.EnableProfiling {
+	if c.EnableProfiling {
 		routes.Profiling{}.Install(mux)
-		if c.ComponentConfig.Debugging.EnableContentionProfiling {
+		if c.EnableContentionProfiling {
 			goruntime.SetBlockProfileRate(1)
 		}
 	}

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

@@ -17,25 +17,39 @@ limitations under the License.
 package config
 
 import (
-	"time"
+	apiserver "k8s.io/apiserver/pkg/server"
-
+	clientset "k8s.io/client-go/kubernetes"
+	restclient "k8s.io/client-go/rest"
+	"k8s.io/client-go/tools/record"
 	genericcontrollermanager "k8s.io/kubernetes/cmd/controller-manager/app"
+	"k8s.io/kubernetes/pkg/apis/componentconfig"
 )
 
-// ExtraConfig are part of Config, also can place your custom config here.
-type ExtraConfig struct {
-	NodeStatusUpdateFrequency time.Duration
-}
-
 // Config is the main context object for the controller manager.
 type Config struct {
-	Generic genericcontrollermanager.Config
+	ComponentConfig componentconfig.KubeControllerManagerConfiguration
-	Extra   ExtraConfig
+
+	SecureServing *apiserver.SecureServingInfo
+	// TODO: remove deprecated insecure serving
+	InsecureServing *genericcontrollermanager.InsecureServingInfo
+	Authentication  apiserver.AuthenticationInfo
+	Authorization   apiserver.AuthorizationInfo
+
+	// the general kube client
+	Client *clientset.Clientset
+
+	// the client only used for leader election
+	LeaderElectionClient *clientset.Clientset
+
+	// the rest config for the master
+	Kubeconfig *restclient.Config
+
+	// the event sink
+	EventRecorder record.EventRecorder
 }
 
 type completedConfig struct {
-	Generic genericcontrollermanager.CompletedConfig
+	*Config
-	Extra   *ExtraConfig
 }
 
 // CompletedConfig same as Config, just to swap private object.
@@ -46,10 +60,6 @@ type CompletedConfig struct {
 
 // Complete fills in any fields not set that are required to have valid data. It's mutating the receiver.
 func (c *Config) Complete() *CompletedConfig {
-	cc := completedConfig{
+	cc := completedConfig{c}
-		c.Generic.Complete(),
-		&c.Extra,
-	}
-
 	return &CompletedConfig{&cc}
 }

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

@@ -108,7 +108,7 @@ controller, and serviceaccounts controller.`,
 func ResyncPeriod(c *config.CompletedConfig) func() time.Duration {
 	return func() time.Duration {
 		factor := rand.Float64() + 1
-		return time.Duration(float64(c.Generic.ComponentConfig.GenericComponent.MinResyncPeriod.Nanoseconds()) * factor)
+		return time.Duration(float64(c.ComponentConfig.GenericComponent.MinResyncPeriod.Nanoseconds()) * factor)
 	}
 }
 
@@ -118,43 +118,43 @@ func Run(c *config.CompletedConfig) error {
 	glog.Infof("Version: %+v", version.Get())
 
 	if cfgz, err := configz.New("componentconfig"); err == nil {
-		cfgz.Set(c.Generic.ComponentConfig)
+		cfgz.Set(c.ComponentConfig)
 	} else {
 		glog.Errorf("unable to register configz: %c", err)
 	}
 
 	// Start the controller manager HTTP server
 	stopCh := make(chan struct{})
-	if c.Generic.SecureServing != nil {
+	if c.SecureServing != nil {
-		handler := genericcontrollermanager.NewBaseHandler(&c.Generic)
+		handler := genericcontrollermanager.NewBaseHandler(&c.ComponentConfig.Debugging)
-		handler = genericcontrollermanager.BuildHandlerChain(handler, &c.Generic)
+		handler = genericcontrollermanager.BuildHandlerChain(handler, &c.Authorization, &c.Authentication)
-		if err := c.Generic.SecureServing.Serve(handler, 0, stopCh); err != nil {
+		if err := c.SecureServing.Serve(handler, 0, stopCh); err != nil {
 			return err
 		}
 	}
-	if c.Generic.InsecureServing != nil {
+	if c.InsecureServing != nil {
-		handler := genericcontrollermanager.NewBaseHandler(&c.Generic)
+		handler := genericcontrollermanager.NewBaseHandler(&c.ComponentConfig.Debugging)
-		handler = genericcontrollermanager.BuildHandlerChain(handler, &c.Generic)
+		handler = genericcontrollermanager.BuildHandlerChain(handler, &c.Authorization, &c.Authentication)
-		if err := c.Generic.InsecureServing.Serve(handler, 0, stopCh); err != nil {
+		if err := c.InsecureServing.Serve(handler, 0, stopCh); err != nil {
 			return err
 		}
 	}
 
 	run := func(stop <-chan struct{}) {
 		rootClientBuilder := controller.SimpleControllerClientBuilder{
-			ClientConfig: c.Generic.Kubeconfig,
+			ClientConfig: c.Kubeconfig,
 		}
 		var clientBuilder controller.ControllerClientBuilder
-		if c.Generic.ComponentConfig.KubeCloudShared.UseServiceAccountCredentials {
+		if c.ComponentConfig.KubeCloudShared.UseServiceAccountCredentials {
-			if len(c.Generic.ComponentConfig.KubeCloudShared.ServiceAccountKeyFile) == 0 {
+			if len(c.ComponentConfig.KubeCloudShared.ServiceAccountKeyFile) == 0 {
 				// It'c possible another controller process is creating the tokens for us.
 				// If one isn't, we'll timeout and exit when our client builder is unable to create the tokens.
 				glog.Warningf("--use-service-account-credentials was specified without providing a --service-account-private-key-file")
 			}
 			clientBuilder = controller.SAControllerClientBuilder{
-				ClientConfig:         restclient.AnonymousClientConfig(c.Generic.Kubeconfig),
+				ClientConfig:         restclient.AnonymousClientConfig(c.Kubeconfig),
-				CoreClient:           c.Generic.Client.CoreV1(),
+				CoreClient:           c.Client.CoreV1(),
-				AuthenticationClient: c.Generic.Client.AuthenticationV1(),
+				AuthenticationClient: c.Client.AuthenticationV1(),
 				Namespace:            "kube-system",
 			}
 		} else {
@@ -176,7 +176,7 @@ func Run(c *config.CompletedConfig) error {
 		select {}
 	}
 
-	if !c.Generic.ComponentConfig.GenericComponent.LeaderElection.LeaderElect {
+	if !c.ComponentConfig.GenericComponent.LeaderElection.LeaderElect {
 		run(wait.NeverStop)
 		panic("unreachable")
 	}
@@ -188,13 +188,13 @@ func Run(c *config.CompletedConfig) error {
 
 	// add a uniquifier so that two processes on the same host don't accidentally both become active
 	id = id + "_" + string(uuid.NewUUID())
-	rl, err := resourcelock.New(c.Generic.ComponentConfig.GenericComponent.LeaderElection.ResourceLock,
+	rl, err := resourcelock.New(c.ComponentConfig.GenericComponent.LeaderElection.ResourceLock,
 		"kube-system",
 		"kube-controller-manager",
-		c.Generic.LeaderElectionClient.CoreV1(),
+		c.LeaderElectionClient.CoreV1(),
 		resourcelock.ResourceLockConfig{
 			Identity:      id,
-			EventRecorder: c.Generic.EventRecorder,
+			EventRecorder: c.EventRecorder,
 		})
 	if err != nil {
 		glog.Fatalf("error creating lock: %v", err)
@@ -202,9 +202,9 @@ func Run(c *config.CompletedConfig) error {
 
 	leaderelection.RunOrDie(leaderelection.LeaderElectionConfig{
 		Lock:          rl,
-		LeaseDuration: c.Generic.ComponentConfig.GenericComponent.LeaderElection.LeaseDuration.Duration,
+		LeaseDuration: c.ComponentConfig.GenericComponent.LeaderElection.LeaseDuration.Duration,
-		RenewDeadline: c.Generic.ComponentConfig.GenericComponent.LeaderElection.RenewDeadline.Duration,
+		RenewDeadline: c.ComponentConfig.GenericComponent.LeaderElection.RenewDeadline.Duration,
-		RetryPeriod:   c.Generic.ComponentConfig.GenericComponent.LeaderElection.RetryPeriod.Duration,
+		RetryPeriod:   c.ComponentConfig.GenericComponent.LeaderElection.RetryPeriod.Duration,
 		Callbacks: leaderelection.LeaderCallbacks{
 			OnStartedLeading: run,
 			OnStoppedLeading: func() {
@@ -409,8 +409,8 @@ func CreateControllerContext(s *config.CompletedConfig, rootClientBuilder, clien
 		return ControllerContext{}, err
 	}
 
-	cloud, loopMode, err := createCloudProvider(s.Generic.ComponentConfig.CloudProvider.Name, s.Generic.ComponentConfig.ExternalCloudVolumePlugin,
+	cloud, loopMode, err := createCloudProvider(s.ComponentConfig.CloudProvider.Name, s.ComponentConfig.ExternalCloudVolumePlugin,
-		s.Generic.ComponentConfig.CloudProvider.CloudConfigFile, s.Generic.ComponentConfig.KubeCloudShared.AllowUntaggedCloud, sharedInformers)
+		s.ComponentConfig.CloudProvider.CloudConfigFile, s.ComponentConfig.KubeCloudShared.AllowUntaggedCloud, sharedInformers)
 	if err != nil {
 		return ControllerContext{}, err
 	}
@@ -418,7 +418,7 @@ func CreateControllerContext(s *config.CompletedConfig, rootClientBuilder, clien
 	ctx := ControllerContext{
 		ClientBuilder:      clientBuilder,
 		InformerFactory:    sharedInformers,
-		ComponentConfig:    s.Generic.ComponentConfig,
+		ComponentConfig:    s.ComponentConfig,
 		RESTMapper:         restMapper,
 		AvailableResources: availableResources,
 		Cloud:              cloud,