From bbd992df138d0b8bca26a6b55e413c7258776663 Mon Sep 17 00:00:00 2001 From: stewart-yu Date: Tue, 15 Jan 2019 08:26:49 +0800 Subject: [PATCH 1/3] add --controller flag for cloud-controller manager --- .../app/controllermanager.go | 32 +++++++++++++++++-- .../app/options/options.go | 17 ++++------ .../app/options/options_test.go | 5 +-- .../app/testing/testserver.go | 5 +-- cmd/controller-manager/app/options/generic.go | 1 - .../app/controllermanager.go | 2 +- 6 files changed, 44 insertions(+), 18 deletions(-) diff --git a/cmd/cloud-controller-manager/app/controllermanager.go b/cmd/cloud-controller-manager/app/controllermanager.go index 3f7909af909..4981e2d3f9d 100644 --- a/cmd/cloud-controller-manager/app/controllermanager.go +++ b/cmd/cloud-controller-manager/app/controllermanager.go @@ -20,12 +20,14 @@ import ( "context" "fmt" "net" + "net/http" "os" "strings" "time" "github.com/spf13/cobra" + "k8s.io/apimachinery/pkg/util/sets" "k8s.io/apimachinery/pkg/util/uuid" "k8s.io/apimachinery/pkg/util/wait" "k8s.io/apiserver/pkg/server" @@ -72,7 +74,7 @@ the cloud specific control loops shipped with Kubernetes.`, verflag.PrintAndExitIfRequested() utilflag.PrintFlags(cmd.Flags()) - c, err := s.Config() + c, err := s.Config(KnownControllers(), ControllersDisabledByDefault.List()) if err != nil { fmt.Fprintf(os.Stderr, "%v\n", err) os.Exit(1) @@ -87,7 +89,7 @@ the cloud specific control loops shipped with Kubernetes.`, } fs := cmd.Flags() - namedFlagSets := s.Flags() + namedFlagSets := s.Flags(KnownControllers(), ControllersDisabledByDefault.List()) verflag.AddFlags(namedFlagSets.FlagSet("global")) globalflag.AddGlobalFlags(namedFlagSets.FlagSet("global"), cmd.Name()) cmoptions.AddCustomGlobalFlags(namedFlagSets.FlagSet("generic")) @@ -297,3 +299,29 @@ func startControllers(c *cloudcontrollerconfig.CompletedConfig, stop <-chan stru select {} } + +// initFunc is used to launch a particular controller. It may run additional "should I activate checks". +// Any error returned will cause the controller process to `Fatal` +// The bool indicates whether the controller was enabled. +type initFunc func(ctx *cloudcontrollerconfig.CompletedConfig, cloud cloudprovider.Interface, stop <-chan struct{}) (debuggingHandler http.Handler, enabled bool, err error) + +// KnownControllers indicate the default controller we are known. +func KnownControllers() []string { + ret := sets.StringKeySet(newControllerInitializers()) + return ret.List() +} + +// ControllersDisabledByDefault is the controller disabled default when starting cloud-controller managers. +var ControllersDisabledByDefault = sets.NewString() + +// newControllerInitializers is a private map of named controller groups (you can start more than one in an init func) +// paired to their initFunc. This allows for structured downstream composition and subdivision. +func newControllerInitializers() map[string]initFunc { + controllers := map[string]initFunc{} + controllers["cloud-node"] = startCloudNodeController + controllers["cloud-node-lifecycle"] = startCloudNodeLifecycleController + controllers["persistentvolume-binder"] = startPersistentVolumeLabelController + controllers["service"] = startServiceController + controllers["route"] = startRouteController + return controllers +} diff --git a/cmd/cloud-controller-manager/app/options/options.go b/cmd/cloud-controller-manager/app/options/options.go index 5e2a5979493..c3eea94ec46 100644 --- a/cmd/cloud-controller-manager/app/options/options.go +++ b/cmd/cloud-controller-manager/app/options/options.go @@ -22,8 +22,6 @@ import ( "net" "time" - "k8s.io/klog" - "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" utilerrors "k8s.io/apimachinery/pkg/util/errors" @@ -36,6 +34,7 @@ import ( restclient "k8s.io/client-go/rest" "k8s.io/client-go/tools/clientcmd" "k8s.io/client-go/tools/record" + "k8s.io/klog" ccmconfig "k8s.io/kubernetes/cmd/cloud-controller-manager/app/apis/config" ccmconfigscheme "k8s.io/kubernetes/cmd/cloud-controller-manager/app/apis/config/scheme" ccmconfigv1alpha1 "k8s.io/kubernetes/cmd/cloud-controller-manager/app/apis/config/v1alpha1" @@ -125,11 +124,9 @@ func NewDefaultComponentConfig(insecurePort int32) (*ccmconfig.CloudControllerMa } // Flags returns flags for a specific APIServer by section name -func (o *CloudControllerManagerOptions) Flags() apiserverflag.NamedFlagSets { +func (o *CloudControllerManagerOptions) Flags(allControllers, disabledByDefaultControllers []string) apiserverflag.NamedFlagSets { fss := apiserverflag.NamedFlagSets{} - o.Generic.AddFlags(&fss, []string{}, []string{}) - // TODO: Implement the --controllers flag fully for the ccm - fss.FlagSet("generic").MarkHidden("controllers") + o.Generic.AddFlags(&fss, allControllers, disabledByDefaultControllers) o.KubeCloudShared.AddFlags(fss.FlagSet("generic")) o.ServiceController.AddFlags(fss.FlagSet("service controller")) @@ -219,10 +216,10 @@ func (o *CloudControllerManagerOptions) ApplyTo(c *cloudcontrollerconfig.Config, } // Validate is used to validate config before launching the cloud controller manager -func (o *CloudControllerManagerOptions) Validate() error { +func (o *CloudControllerManagerOptions) Validate(allControllers, disabledByDefaultControllers []string) error { errors := []error{} - errors = append(errors, o.Generic.Validate(nil, nil)...) + errors = append(errors, o.Generic.Validate(allControllers, disabledByDefaultControllers)...) errors = append(errors, o.KubeCloudShared.Validate()...) errors = append(errors, o.ServiceController.Validate()...) errors = append(errors, o.SecureServing.Validate()...) @@ -246,8 +243,8 @@ func resyncPeriod(c *cloudcontrollerconfig.Config) func() time.Duration { } // Config return a cloud controller manager config objective -func (o *CloudControllerManagerOptions) Config() (*cloudcontrollerconfig.Config, error) { - if err := o.Validate(); err != nil { +func (o *CloudControllerManagerOptions) Config(allControllers, disabledByDefaultControllers []string) (*cloudcontrollerconfig.Config, error) { + if err := o.Validate(allControllers, disabledByDefaultControllers); err != nil { return nil, err } diff --git a/cmd/cloud-controller-manager/app/options/options_test.go b/cmd/cloud-controller-manager/app/options/options_test.go index fce64bb9590..3f78c261731 100644 --- a/cmd/cloud-controller-manager/app/options/options_test.go +++ b/cmd/cloud-controller-manager/app/options/options_test.go @@ -115,7 +115,7 @@ func TestDefaultFlags(t *testing.T) { func TestAddFlags(t *testing.T) { fs := pflag.NewFlagSet("addflagstest", pflag.ContinueOnError) s, _ := NewCloudControllerManagerOptions() - for _, f := range s.Flags().FlagSets { + for _, f := range s.Flags([]string{""}, []string{""}).FlagSets { fs.AddFlagSet(f) } @@ -131,6 +131,7 @@ func TestAddFlags(t *testing.T) { "--configure-cloud-routes=false", "--contention-profiling=true", "--controller-start-interval=2m", + "--controllers=foo,bar", "--http2-max-streams-per-connection=47", "--kube-api-burst=100", "--kube-api-content-type=application/vnd.kubernetes.protobuf", @@ -173,7 +174,7 @@ func TestAddFlags(t *testing.T) { Debugging: &cmoptions.DebuggingOptions{ EnableContentionProfiling: true, }, - Controllers: []string{"*"}, + Controllers: []string{"foo", "bar"}, }, KubeCloudShared: &cmoptions.KubeCloudSharedOptions{ CloudProvider: &cmoptions.CloudProviderOptions{ diff --git a/cmd/cloud-controller-manager/app/testing/testserver.go b/cmd/cloud-controller-manager/app/testing/testserver.go index e5a3e9e5bad..638d9f3d6ff 100644 --- a/cmd/cloud-controller-manager/app/testing/testserver.go +++ b/cmd/cloud-controller-manager/app/testing/testserver.go @@ -83,7 +83,8 @@ func StartTestServer(t Logger, customFlags []string) (result TestServer, err err if err != nil { return TestServer{}, err } - namedFlagSets := s.Flags() + all, disabled := app.KnownControllers(), app.ControllersDisabledByDefault.List() + namedFlagSets := s.Flags(all, disabled) for _, f := range namedFlagSets.FlagSets { fs.AddFlagSet(f) } @@ -108,7 +109,7 @@ func StartTestServer(t Logger, customFlags []string) (result TestServer, err err t.Logf("cloud-controller-manager will listen insecurely on port %d...", s.InsecureServing.BindPort) } - config, err := s.Config() + config, err := s.Config(all, disabled) if err != nil { return result, fmt.Errorf("failed to create config from options: %v", err) } diff --git a/cmd/controller-manager/app/options/generic.go b/cmd/controller-manager/app/options/generic.go index 2089c7179f2..8d0dfc34f18 100644 --- a/cmd/controller-manager/app/options/generic.go +++ b/cmd/controller-manager/app/options/generic.go @@ -71,7 +71,6 @@ func (o *GenericControllerManagerConfigurationOptions) AddFlags(fss *apiserverfl genericfs.Float32Var(&o.ClientConnection.QPS, "kube-api-qps", o.ClientConnection.QPS, "QPS to use while talking with kubernetes apiserver.") genericfs.Int32Var(&o.ClientConnection.Burst, "kube-api-burst", o.ClientConnection.Burst, "Burst to use while talking with kubernetes apiserver.") genericfs.DurationVar(&o.ControllerStartInterval.Duration, "controller-start-interval", o.ControllerStartInterval.Duration, "Interval between starting controller managers.") - // TODO: complete the work of the cloud-controller-manager (and possibly other consumers of this code) respecting the --controllers flag genericfs.StringSliceVar(&o.Controllers, "controllers", o.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", diff --git a/cmd/kube-controller-manager/app/controllermanager.go b/cmd/kube-controller-manager/app/controllermanager.go index 737b7d4e6cd..b840523db41 100644 --- a/cmd/kube-controller-manager/app/controllermanager.go +++ b/cmd/kube-controller-manager/app/controllermanager.go @@ -387,7 +387,7 @@ func NewControllerInitializers(loopMode ControllerLoopMode) map[string]InitFunc if loopMode == IncludeCloudLoops { controllers["service"] = startServiceController controllers["route"] = startRouteController - controllers["cloudnodelifecycle"] = startCloudNodeLifecycleController + controllers["cloud-node-lifecycle"] = startCloudNodeLifecycleController // TODO: volume controller into the IncludeCloudLoops only set. } controllers["persistentvolume-binder"] = startPersistentVolumeBinderController From 72729db87fb710c12fce659450a332da078033ca Mon Sep 17 00:00:00 2001 From: stewart-yu Date: Mon, 14 Jan 2019 19:49:47 +0800 Subject: [PATCH 2/3] refactor code logic for cloud-controller manager --- .../app/controllermanager.go | 99 +++---------- cmd/cloud-controller-manager/app/core.go | 131 ++++++++++++++++++ cmd/controller-manager/app/helper.go | 24 ++++ .../app/helper_test.go} | 6 +- .../app/controllermanager.go | 27 +--- 5 files changed, 180 insertions(+), 107 deletions(-) create mode 100644 cmd/cloud-controller-manager/app/core.go rename cmd/{kube-controller-manager/app/controller_manager_test.go => controller-manager/app/helper_test.go} (92%) diff --git a/cmd/cloud-controller-manager/app/controllermanager.go b/cmd/cloud-controller-manager/app/controllermanager.go index 4981e2d3f9d..06977e29d87 100644 --- a/cmd/cloud-controller-manager/app/controllermanager.go +++ b/cmd/cloud-controller-manager/app/controllermanager.go @@ -19,10 +19,8 @@ package app import ( "context" "fmt" - "net" "net/http" "os" - "strings" "time" "github.com/spf13/cobra" @@ -34,7 +32,6 @@ import ( "k8s.io/apiserver/pkg/server/healthz" apiserverflag "k8s.io/apiserver/pkg/util/flag" "k8s.io/apiserver/pkg/util/globalflag" - "k8s.io/client-go/kubernetes" "k8s.io/client-go/tools/leaderelection" "k8s.io/client-go/tools/leaderelection/resourcelock" cloudprovider "k8s.io/cloud-provider" @@ -43,9 +40,6 @@ import ( "k8s.io/kubernetes/cmd/cloud-controller-manager/app/options" genericcontrollermanager "k8s.io/kubernetes/cmd/controller-manager/app" cmoptions "k8s.io/kubernetes/cmd/controller-manager/app/options" - cloudcontrollers "k8s.io/kubernetes/pkg/controller/cloud" - routecontroller "k8s.io/kubernetes/pkg/controller/route" - servicecontroller "k8s.io/kubernetes/pkg/controller/service" "k8s.io/kubernetes/pkg/util/configz" utilflag "k8s.io/kubernetes/pkg/util/flag" "k8s.io/kubernetes/pkg/version" @@ -165,7 +159,7 @@ func Run(c *cloudcontrollerconfig.CompletedConfig, stopCh <-chan struct{}) error } run := func(ctx context.Context) { - if err := startControllers(c, ctx.Done(), cloud); err != nil { + if err := startControllers(c, ctx.Done(), cloud, newControllerInitializers()); err != nil { klog.Fatalf("error running controllers: %v", err) } } @@ -215,87 +209,40 @@ func Run(c *cloudcontrollerconfig.CompletedConfig, stopCh <-chan struct{}) error } // startControllers starts the cloud specific controller loops. -func startControllers(c *cloudcontrollerconfig.CompletedConfig, stop <-chan struct{}, cloud cloudprovider.Interface) error { - // Function to build the kube client object - client := func(serviceAccountName string) kubernetes.Interface { - return c.ClientBuilder.ClientOrDie(serviceAccountName) - } +func startControllers(c *cloudcontrollerconfig.CompletedConfig, stopCh <-chan struct{}, cloud cloudprovider.Interface, controllers map[string]initFunc) error { if cloud != nil { // Initialize the cloud provider with a reference to the clientBuilder - cloud.Initialize(c.ClientBuilder, stop) - } - // Start the CloudNodeController - nodeController := cloudcontrollers.NewCloudNodeController( - c.SharedInformers.Core().V1().Nodes(), - // cloud node controller uses existing cluster role from node-controller - client("node-controller"), cloud, - c.ComponentConfig.NodeStatusUpdateFrequency.Duration) - - go nodeController.Run(stop) - time.Sleep(wait.Jitter(c.ComponentConfig.Generic.ControllerStartInterval.Duration, ControllerStartJitter)) - - cloudNodeLifecycleController, err := cloudcontrollers.NewCloudNodeLifecycleController( - c.SharedInformers.Core().V1().Nodes(), - // cloud node lifecycle controller uses existing cluster role from node-controller - client("node-controller"), cloud, - c.ComponentConfig.KubeCloudShared.NodeMonitorPeriod.Duration, - ) - if err != nil { - klog.Errorf("failed to start cloud node lifecycle controller: %s", err) - } else { - go cloudNodeLifecycleController.Run(stop) - time.Sleep(wait.Jitter(c.ComponentConfig.Generic.ControllerStartInterval.Duration, ControllerStartJitter)) + cloud.Initialize(c.ClientBuilder, stopCh) } - // Start the PersistentVolumeLabelController - pvlController := cloudcontrollers.NewPersistentVolumeLabelController(client("pvl-controller"), cloud) - go pvlController.Run(5, stop) - time.Sleep(wait.Jitter(c.ComponentConfig.Generic.ControllerStartInterval.Duration, ControllerStartJitter)) - - // Start the service controller - serviceController, err := servicecontroller.New( - cloud, - client("service-controller"), - c.SharedInformers.Core().V1().Services(), - c.SharedInformers.Core().V1().Nodes(), - c.ComponentConfig.KubeCloudShared.ClusterName, - ) - if err != nil { - klog.Errorf("Failed to start service controller: %v", err) - } else { - go serviceController.Run(stop, int(c.ComponentConfig.ServiceController.ConcurrentServiceSyncs)) - time.Sleep(wait.Jitter(c.ComponentConfig.Generic.ControllerStartInterval.Duration, ControllerStartJitter)) - } - - // If CIDRs should be allocated for pods and set on the CloudProvider, then start the route controller - if c.ComponentConfig.KubeCloudShared.AllocateNodeCIDRs && c.ComponentConfig.KubeCloudShared.ConfigureCloudRoutes { - if routes, ok := cloud.Routes(); !ok { - klog.Warning("configure-cloud-routes is set, but cloud provider does not support routes. Will not configure cloud provider routes.") - } else { - var clusterCIDR *net.IPNet - if len(strings.TrimSpace(c.ComponentConfig.KubeCloudShared.ClusterCIDR)) != 0 { - _, clusterCIDR, err = net.ParseCIDR(c.ComponentConfig.KubeCloudShared.ClusterCIDR) - if err != nil { - klog.Warningf("Unsuccessful parsing of cluster CIDR %v: %v", c.ComponentConfig.KubeCloudShared.ClusterCIDR, err) - } - } - - routeController := routecontroller.New(routes, client("route-controller"), c.SharedInformers.Core().V1().Nodes(), c.ComponentConfig.KubeCloudShared.ClusterName, clusterCIDR) - go routeController.Run(stop, c.ComponentConfig.KubeCloudShared.RouteReconciliationPeriod.Duration) - time.Sleep(wait.Jitter(c.ComponentConfig.Generic.ControllerStartInterval.Duration, ControllerStartJitter)) + for controllerName, initFn := range controllers { + if !genericcontrollermanager.IsControllerEnabled(controllerName, ControllersDisabledByDefault, c.ComponentConfig.Generic.Controllers) { + klog.Warningf("%q is disabled", controllerName) + continue } - } else { - klog.Infof("Will not configure cloud provider routes for allocate-node-cidrs: %v, configure-cloud-routes: %v.", c.ComponentConfig.KubeCloudShared.AllocateNodeCIDRs, c.ComponentConfig.KubeCloudShared.ConfigureCloudRoutes) + + klog.V(1).Infof("Starting %q", controllerName) + _, started, err := initFn(c, cloud, stopCh) + if err != nil { + klog.Errorf("Error starting %q", controllerName) + return err + } + if !started { + klog.Warningf("Skipping %q", controllerName) + continue + } + klog.Infof("Started %q", controllerName) + + time.Sleep(wait.Jitter(c.ComponentConfig.Generic.ControllerStartInterval.Duration, ControllerStartJitter)) } // If apiserver is not running we should wait for some time and fail only then. This is particularly // important when we start apiserver and controller manager at the same time. - err = genericcontrollermanager.WaitForAPIServer(c.VersionedClient, 10*time.Second) - if err != nil { + if err := genericcontrollermanager.WaitForAPIServer(c.VersionedClient, 10*time.Second); err != nil { klog.Fatalf("Failed to wait for apiserver being healthy: %v", err) } - c.SharedInformers.Start(stop) + c.SharedInformers.Start(stopCh) select {} } diff --git a/cmd/cloud-controller-manager/app/core.go b/cmd/cloud-controller-manager/app/core.go new file mode 100644 index 00000000000..628237bcb40 --- /dev/null +++ b/cmd/cloud-controller-manager/app/core.go @@ -0,0 +1,131 @@ +/* +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 implements a server that runs a set of active +// components. This includes node controllers, service and +// route controller, and so on. +// +package app + +import ( + "net" + "net/http" + "strings" + + cloudprovider "k8s.io/cloud-provider" + "k8s.io/klog" + cloudcontrollerconfig "k8s.io/kubernetes/cmd/cloud-controller-manager/app/config" + cloudcontrollers "k8s.io/kubernetes/pkg/controller/cloud" + routecontroller "k8s.io/kubernetes/pkg/controller/route" + servicecontroller "k8s.io/kubernetes/pkg/controller/service" +) + +func startCloudNodeController(ctx *cloudcontrollerconfig.CompletedConfig, cloud cloudprovider.Interface, stopCh <-chan struct{}) (http.Handler, bool, error) { + // Start the CloudNodeController + nodeController := cloudcontrollers.NewCloudNodeController( + ctx.SharedInformers.Core().V1().Nodes(), + // cloud node controller uses existing cluster role from node-controller + ctx.ClientBuilder.ClientOrDie("node-controller"), + cloud, + ctx.ComponentConfig.NodeStatusUpdateFrequency.Duration) + + go nodeController.Run(stopCh) + + return nil, true, nil +} + +func startCloudNodeLifecycleController(ctx *cloudcontrollerconfig.CompletedConfig, cloud cloudprovider.Interface, stopCh <-chan struct{}) (http.Handler, bool, error) { + // Start the cloudNodeLifecycleController + cloudNodeLifecycleController, err := cloudcontrollers.NewCloudNodeLifecycleController( + ctx.SharedInformers.Core().V1().Nodes(), + // cloud node lifecycle controller uses existing cluster role from node-controller + ctx.ClientBuilder.ClientOrDie("node-controller"), + cloud, + ctx.ComponentConfig.KubeCloudShared.NodeMonitorPeriod.Duration, + ) + if err != nil { + klog.Warningf("failed to start cloud node lifecycle controller: %s", err) + return nil, false, nil + } + + go cloudNodeLifecycleController.Run(stopCh) + + return nil, true, nil +} + +func startPersistentVolumeLabelController(ctx *cloudcontrollerconfig.CompletedConfig, cloud cloudprovider.Interface, stopCh <-chan struct{}) (http.Handler, bool, error) { + // Start the PersistentVolumeLabelController + pvlController := cloudcontrollers.NewPersistentVolumeLabelController( + ctx.ClientBuilder.ClientOrDie("pvl-controller"), + cloud, + ) + go pvlController.Run(5, stopCh) + + return nil, true, nil +} + +func startServiceController(ctx *cloudcontrollerconfig.CompletedConfig, cloud cloudprovider.Interface, stopCh <-chan struct{}) (http.Handler, bool, error) { + // Start the service controller + serviceController, err := servicecontroller.New( + cloud, + ctx.ClientBuilder.ClientOrDie("service-controller"), + ctx.SharedInformers.Core().V1().Services(), + ctx.SharedInformers.Core().V1().Nodes(), + ctx.ComponentConfig.KubeCloudShared.ClusterName, + ) + if err != nil { + // This error shouldn't fail. It lives like this as a legacy. + klog.Errorf("Failed to start service controller: %v", err) + return nil, false, nil + } + + go serviceController.Run(stopCh, int(ctx.ComponentConfig.ServiceController.ConcurrentServiceSyncs)) + + return nil, true, nil +} + +func startRouteController(ctx *cloudcontrollerconfig.CompletedConfig, cloud cloudprovider.Interface, stopCh <-chan struct{}) (http.Handler, bool, error) { + if !ctx.ComponentConfig.KubeCloudShared.AllocateNodeCIDRs || !ctx.ComponentConfig.KubeCloudShared.ConfigureCloudRoutes { + klog.Infof("Will not configure cloud provider routes for allocate-node-cidrs: %v, configure-cloud-routes: %v.", ctx.ComponentConfig.KubeCloudShared.AllocateNodeCIDRs, ctx.ComponentConfig.KubeCloudShared.ConfigureCloudRoutes) + return nil, false, nil + } + + // If CIDRs should be allocated for pods and set on the CloudProvider, then start the route controller + routes, ok := cloud.Routes() + if !ok { + klog.Warning("configure-cloud-routes is set, but cloud provider does not support routes. Will not configure cloud provider routes.") + return nil, false, nil + } + var clusterCIDR *net.IPNet + var err error + if len(strings.TrimSpace(ctx.ComponentConfig.KubeCloudShared.ClusterCIDR)) != 0 { + _, clusterCIDR, err = net.ParseCIDR(ctx.ComponentConfig.KubeCloudShared.ClusterCIDR) + if err != nil { + klog.Warningf("Unsuccessful parsing of cluster CIDR %v: %v", ctx.ComponentConfig.KubeCloudShared.ClusterCIDR, err) + } + } + + routeController := routecontroller.New( + routes, + ctx.ClientBuilder.ClientOrDie("route-controller"), + ctx.SharedInformers.Core().V1().Nodes(), + ctx.ComponentConfig.KubeCloudShared.ClusterName, + clusterCIDR, + ) + go routeController.Run(stopCh, ctx.ComponentConfig.KubeCloudShared.RouteReconciliationPeriod.Duration) + + return nil, true, nil +} diff --git a/cmd/controller-manager/app/helper.go b/cmd/controller-manager/app/helper.go index 8bf1edee52a..7a156567d6f 100644 --- a/cmd/controller-manager/app/helper.go +++ b/cmd/controller-manager/app/helper.go @@ -21,6 +21,7 @@ import ( "net/http" "time" + "k8s.io/apimachinery/pkg/util/sets" "k8s.io/apimachinery/pkg/util/wait" clientset "k8s.io/client-go/kubernetes" "k8s.io/klog" @@ -53,3 +54,26 @@ func WaitForAPIServer(client clientset.Interface, timeout time.Duration) error { return nil } + +// IsControllerEnabled check if a specified controller enabled or not. +func IsControllerEnabled(name string, disabledByDefaultControllers sets.String, controllers []string) bool { + hasStar := false + for _, ctrl := range controllers { + if ctrl == name { + return true + } + if ctrl == "-"+name { + return false + } + if ctrl == "*" { + hasStar = true + } + } + // if we get here, there was no explicit choice + if !hasStar { + // nothing on by default + return false + } + + return !disabledByDefaultControllers.Has(name) +} diff --git a/cmd/kube-controller-manager/app/controller_manager_test.go b/cmd/controller-manager/app/helper_test.go similarity index 92% rename from cmd/kube-controller-manager/app/controller_manager_test.go rename to cmd/controller-manager/app/helper_test.go index 2c3e3f92596..9bc3eeaba29 100644 --- a/cmd/kube-controller-manager/app/controller_manager_test.go +++ b/cmd/controller-manager/app/helper_test.go @@ -14,10 +14,6 @@ See the License for the specific language governing permissions and limitations under the License. */ -// Package app implements a server that runs a set of active -// components. This includes replication controllers, service endpoints and -// nodes. -// package app import ( @@ -74,7 +70,7 @@ func TestIsControllerEnabled(t *testing.T) { } for _, tc := range tcs { - actual := IsControllerEnabled(tc.controllerName, sets.NewString(tc.disabledByDefaultControllers...), tc.controllers...) + actual := IsControllerEnabled(tc.controllerName, sets.NewString(tc.disabledByDefaultControllers...), tc.controllers) assert.Equal(t, tc.expected, actual, "%v: expected %v, got %v", tc.name, tc.expected, actual) } diff --git a/cmd/kube-controller-manager/app/controllermanager.go b/cmd/kube-controller-manager/app/controllermanager.go index b840523db41..9354d02a370 100644 --- a/cmd/kube-controller-manager/app/controllermanager.go +++ b/cmd/kube-controller-manager/app/controllermanager.go @@ -301,32 +301,7 @@ type ControllerContext struct { } func (c ControllerContext) IsControllerEnabled(name string) bool { - return IsControllerEnabled(name, ControllersDisabledByDefault, c.ComponentConfig.Generic.Controllers...) -} - -func IsControllerEnabled(name string, disabledByDefaultControllers sets.String, controllers ...string) bool { - hasStar := false - for _, ctrl := range controllers { - if ctrl == name { - return true - } - if ctrl == "-"+name { - return false - } - if ctrl == "*" { - hasStar = true - } - } - // if we get here, there was no explicit choice - if !hasStar { - // nothing on by default - return false - } - if disabledByDefaultControllers.Has(name) { - return false - } - - return true + return genericcontrollermanager.IsControllerEnabled(name, ControllersDisabledByDefault, c.ComponentConfig.Generic.Controllers) } // InitFunc is used to launch a particular controller. It may run additional "should I activate checks". From 3820f7400ff2113fa1e8b17551db37018859de97 Mon Sep 17 00:00:00 2001 From: stewart-yu Date: Fri, 7 Dec 2018 17:59:05 +0800 Subject: [PATCH 3/3] auto-generated file --- cmd/cloud-controller-manager/app/BUILD | 7 +++++-- cmd/controller-manager/app/BUILD | 13 ++++++++++++- cmd/kube-controller-manager/app/BUILD | 12 +----------- 3 files changed, 18 insertions(+), 14 deletions(-) diff --git a/cmd/cloud-controller-manager/app/BUILD b/cmd/cloud-controller-manager/app/BUILD index 75d7f8b3351..3070601fd91 100644 --- a/cmd/cloud-controller-manager/app/BUILD +++ b/cmd/cloud-controller-manager/app/BUILD @@ -2,7 +2,10 @@ load("@io_bazel_rules_go//go:def.bzl", "go_library") go_library( name = "go_default_library", - srcs = ["controllermanager.go"], + srcs = [ + "controllermanager.go", + "core.go", + ], importpath = "k8s.io/kubernetes/cmd/cloud-controller-manager/app", visibility = ["//visibility:public"], deps = [ @@ -17,13 +20,13 @@ go_library( "//pkg/util/flag:go_default_library", "//pkg/version:go_default_library", "//pkg/version/verflag:go_default_library", + "//staging/src/k8s.io/apimachinery/pkg/util/sets:go_default_library", "//staging/src/k8s.io/apimachinery/pkg/util/uuid:go_default_library", "//staging/src/k8s.io/apimachinery/pkg/util/wait:go_default_library", "//staging/src/k8s.io/apiserver/pkg/server:go_default_library", "//staging/src/k8s.io/apiserver/pkg/server/healthz:go_default_library", "//staging/src/k8s.io/apiserver/pkg/util/flag:go_default_library", "//staging/src/k8s.io/apiserver/pkg/util/globalflag:go_default_library", - "//staging/src/k8s.io/client-go/kubernetes:go_default_library", "//staging/src/k8s.io/client-go/tools/leaderelection:go_default_library", "//staging/src/k8s.io/client-go/tools/leaderelection/resourcelock:go_default_library", "//staging/src/k8s.io/cloud-provider:go_default_library", diff --git a/cmd/controller-manager/app/BUILD b/cmd/controller-manager/app/BUILD index e88a11f4b7f..f88adc9ef20 100644 --- a/cmd/controller-manager/app/BUILD +++ b/cmd/controller-manager/app/BUILD @@ -1,4 +1,4 @@ -load("@io_bazel_rules_go//go:def.bzl", "go_library") +load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test") go_library( name = "go_default_library", @@ -11,6 +11,7 @@ go_library( deps = [ "//pkg/api/legacyscheme:go_default_library", "//pkg/util/configz:go_default_library", + "//staging/src/k8s.io/apimachinery/pkg/util/sets:go_default_library", "//staging/src/k8s.io/apimachinery/pkg/util/wait:go_default_library", "//staging/src/k8s.io/apiserver/pkg/endpoints/filters:go_default_library", "//staging/src/k8s.io/apiserver/pkg/endpoints/request:go_default_library", @@ -42,3 +43,13 @@ filegroup( tags = ["automanaged"], visibility = ["//visibility:public"], ) + +go_test( + name = "go_default_test", + srcs = ["helper_test.go"], + embed = [":go_default_library"], + deps = [ + "//staging/src/k8s.io/apimachinery/pkg/util/sets:go_default_library", + "//vendor/github.com/stretchr/testify/assert:go_default_library", + ], +) diff --git a/cmd/kube-controller-manager/app/BUILD b/cmd/kube-controller-manager/app/BUILD index 49d8221b345..a7f7c9c1897 100644 --- a/cmd/kube-controller-manager/app/BUILD +++ b/cmd/kube-controller-manager/app/BUILD @@ -1,4 +1,4 @@ -load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test") +load("@io_bazel_rules_go//go:def.bzl", "go_library") go_library( name = "go_default_library", @@ -142,16 +142,6 @@ go_library( ], ) -go_test( - name = "go_default_test", - srcs = ["controller_manager_test.go"], - embed = [":go_default_library"], - deps = [ - "//staging/src/k8s.io/apimachinery/pkg/util/sets:go_default_library", - "//vendor/github.com/stretchr/testify/assert:go_default_library", - ], -) - filegroup( name = "package-srcs", srcs = glob(["**"]),