diff --git a/cmd/kube-controller-manager/app/controllermanager.go b/cmd/kube-controller-manager/app/controllermanager.go index fb19072e496..1a84a025930 100644 --- a/cmd/kube-controller-manager/app/controllermanager.go +++ b/cmd/kube-controller-manager/app/controllermanager.go @@ -174,16 +174,16 @@ func Run(s *options.CMServer) error { func StartControllers(s *options.CMServer, kubeClient *client.Client, kubeconfig *client.Config, stop <-chan struct{}) error { go endpointcontroller.NewEndpointController(clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "endpoint-controller")), ResyncPeriod(s)). - Run(s.ConcurrentEndpointSyncs, util.NeverStop) + Run(s.EndpointControllerOptions.ConcurrentEndpointSyncs, util.NeverStop) go replicationcontroller.NewReplicationManager( clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "replication-controller")), ResyncPeriod(s), replicationcontroller.BurstReplicas, - ).Run(s.ConcurrentRCSyncs, util.NeverStop) + ).Run(s.ReplicationControllerOptions.ConcurrentRCSyncs, util.NeverStop) - if s.TerminatedPodGCThreshold > 0 { - go gc.New(clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "garbage-collector")), ResyncPeriod(s), s.TerminatedPodGCThreshold). + if s.GarbageCollectorOptions.TerminatedPodGCThreshold > 0 { + go gc.New(clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "garbage-collector")), ResyncPeriod(s), s.GarbageCollectorOptions.TerminatedPodGCThreshold). Run(util.NeverStop) } @@ -193,32 +193,40 @@ func StartControllers(s *options.CMServer, kubeClient *client.Client, kubeconfig } nodeController := nodecontroller.NewNodeController(cloud, clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "node-controller")), - s.PodEvictionTimeout, util.NewTokenBucketRateLimiter(s.DeletingPodsQps, s.DeletingPodsBurst), - util.NewTokenBucketRateLimiter(s.DeletingPodsQps, s.DeletingPodsBurst), - s.NodeMonitorGracePeriod, s.NodeStartupGracePeriod, s.NodeMonitorPeriod, &s.ClusterCIDR, s.AllocateNodeCIDRs) + s.NodeControllerOptions.PodEvictionTimeout, util.NewTokenBucketRateLimiter(s.NodeControllerOptions.DeletingPodsQps, s.NodeControllerOptions.DeletingPodsBurst), + util.NewTokenBucketRateLimiter(s.NodeControllerOptions.DeletingPodsQps, s.NodeControllerOptions.DeletingPodsBurst), + s.NodeControllerOptions.NodeMonitorGracePeriod, s.NodeControllerOptions.NodeStartupGracePeriod, s.NodeControllerOptions.NodeMonitorPeriod, + &s.NodeControllerOptions.ClusterCIDR, s.NodeControllerOptions.AllocateNodeCIDRs, + ) nodeController.Run(s.NodeSyncPeriod) serviceController := servicecontroller.New(cloud, clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "service-controller")), s.ClusterName) - if err := serviceController.Run(s.ServiceSyncPeriod, s.NodeSyncPeriod); err != nil { + if err := serviceController.Run(s.ServiceControllerOptions.ServiceSyncPeriod, s.NodeSyncPeriod); err != nil { glog.Errorf("Failed to start service controller: %v", err) } - if s.AllocateNodeCIDRs { + // TODO: Figure out what the relation between route controller and node controller should be. + if s.NodeControllerOptions.AllocateNodeCIDRs { if cloud == nil { glog.Warning("allocate-node-cidrs is set, but no cloud provider specified. Will not manage routes.") } else if routes, ok := cloud.Routes(); !ok { glog.Warning("allocate-node-cidrs is set, but cloud provider does not support routes. Will not manage routes.") } else { - routeController := routecontroller.New(routes, clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "route-controller")), s.ClusterName, &s.ClusterCIDR) + routeController := routecontroller.New( + routes, + clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "route-controller")), + s.ClusterName, + &s.NodeControllerOptions.ClusterCIDR, + ) routeController.Run(s.NodeSyncPeriod) } } else { - glog.Infof("allocate-node-cidrs set to %v, node controller not creating routes", s.AllocateNodeCIDRs) + glog.Infof("allocate-node-cidrs set to %v, node controller not creating routes", s.NodeControllerOptions.AllocateNodeCIDRs) } go resourcequotacontroller.NewResourceQuotaController( clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "resourcequota-controller")), - controller.StaticResyncPeriodFunc(s.ResourceQuotaSyncPeriod)).Run(s.ConcurrentResourceQuotaSyncs, util.NeverStop) + controller.StaticResyncPeriodFunc(s.ResourceQuotaControllerOptions.ResourceQuotaSyncPeriod)).Run(s.ResourceQuotaControllerOptions.ConcurrentResourceQuotaSyncs, util.NeverStop) // 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. @@ -240,7 +248,10 @@ func StartControllers(s *options.CMServer, kubeClient *client.Client, kubeconfig glog.Fatalf("Failed to get supported resources from server: %v", err) } - namespacecontroller.NewNamespaceController(clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "namespace-controller")), versions, s.NamespaceSyncPeriod).Run() + namespacecontroller.NewNamespaceController( + clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "namespace-controller")), + versions, + s.NamespaceControllerOptions.NamespaceSyncPeriod).Run() groupVersion := "extensions/v1beta1" resources, found := resourceMap[groupVersion] @@ -257,46 +268,54 @@ func StartControllers(s *options.CMServer, kubeClient *client.Client, kubeconfig metrics.DefaultHeapsterService, metrics.DefaultHeapsterPort, ) + // TODO: rename controller/podautoscaler into controller/horizontal podautoscaler.NewHorizontalController(hpaClient.Core(), hpaClient.Extensions(), hpaClient, metricsClient). - Run(s.HorizontalPodAutoscalerSyncPeriod) + Run(s.PodAutoscalerOptions.HorizontalPodAutoscalerSyncPeriod) } if containsResource(resources, "daemonsets") { glog.Infof("Starting daemon set controller") go daemon.NewDaemonSetsController(clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "daemon-set-controller")), ResyncPeriod(s)). - Run(s.ConcurrentDSCSyncs, util.NeverStop) + Run(s.DaemonControllerOptions.ConcurrentDSCSyncs, util.NeverStop) } if containsResource(resources, "jobs") { glog.Infof("Starting job controller") go job.NewJobController(clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "job-controller")), ResyncPeriod(s)). - Run(s.ConcurrentJobSyncs, util.NeverStop) + Run(s.JobControllerOptions.ConcurrentJobSyncs, util.NeverStop) } if containsResource(resources, "deployments") { glog.Infof("Starting deployment controller") go deployment.NewDeploymentController(clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "deployment-controller")), ResyncPeriod(s)). - Run(s.ConcurrentDeploymentSyncs, util.NeverStop) + Run(s.DeploymentControllerOptions.ConcurrentDeploymentSyncs, util.NeverStop) } } - volumePlugins := ProbeRecyclableVolumePlugins(s.VolumeConfigFlags) - provisioner, err := NewVolumeProvisioner(cloud, s.VolumeConfigFlags) + volumePlugins := ProbeRecyclableVolumePlugins(s.PersistentVolumeControllerOptions.VolumeConfigFlags) + provisioner, err := NewVolumeProvisioner(cloud, s.PersistentVolumeControllerOptions.VolumeConfigFlags) if err != nil { glog.Fatal("A Provisioner could not be created, but one was expected. Provisioning will not work. This functionality is considered an early Alpha version.") } - pvclaimBinder := persistentvolumecontroller.NewPersistentVolumeClaimBinder(clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "persistent-volume-binder")), s.PVClaimBinderSyncPeriod) + pvclaimBinder := persistentvolumecontroller.NewPersistentVolumeClaimBinder( + clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "persistent-volume-binder")), + s.PersistentVolumeControllerOptions.PVClaimBinderSyncPeriod, + ) pvclaimBinder.Run() - pvRecycler, err := persistentvolumecontroller.NewPersistentVolumeRecycler(clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "persistent-volume-recycler")), s.PVClaimBinderSyncPeriod, ProbeRecyclableVolumePlugins(s.VolumeConfigFlags), cloud) + pvRecycler, err := persistentvolumecontroller.NewPersistentVolumeRecycler( + clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "persistent-volume-recycler")), + s.PersistentVolumeControllerOptions.PVClaimBinderSyncPeriod, ProbeRecyclableVolumePlugins(s.PersistentVolumeControllerOptions.VolumeConfigFlags), + cloud, + ) if err != nil { glog.Fatalf("Failed to start persistent volume recycler: %+v", err) } pvRecycler.Run() if provisioner != nil { - pvController, err := persistentvolumecontroller.NewPersistentVolumeProvisionerController(persistentvolumecontroller.NewControllerClient(clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "persistent-volume-provisioner"))), s.PVClaimBinderSyncPeriod, volumePlugins, provisioner, cloud) + pvController, err := persistentvolumecontroller.NewPersistentVolumeProvisionerController(persistentvolumecontroller.NewControllerClient(clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "persistent-volume-provisioner"))), s.PersistentVolumeControllerOptions.PVClaimBinderSyncPeriod, volumePlugins, provisioner, cloud) if err != nil { glog.Fatalf("Failed to start persistent volume provisioner controller: %+v", err) } @@ -317,8 +336,8 @@ func StartControllers(s *options.CMServer, kubeClient *client.Client, kubeconfig rootCA = kubeconfig.CAData } - if len(s.ServiceAccountKeyFile) > 0 { - privateKey, err := serviceaccount.ReadPrivateKey(s.ServiceAccountKeyFile) + if len(s.ServiceAccountControllerOptions.ServiceAccountKeyFile) > 0 { + privateKey, err := serviceaccount.ReadPrivateKey(s.ServiceAccountControllerOptions.ServiceAccountKeyFile) if err != nil { glog.Errorf("Error reading key for service account token controller: %v", err) } else { diff --git a/cmd/kube-controller-manager/app/options/options.go b/cmd/kube-controller-manager/app/options/options.go index e6e9e8a99b6..0de097df8b0 100644 --- a/cmd/kube-controller-manager/app/options/options.go +++ b/cmd/kube-controller-manager/app/options/options.go @@ -26,6 +26,20 @@ import ( "k8s.io/kubernetes/pkg/apis/componentconfig" "k8s.io/kubernetes/pkg/client/leaderelection" + daemonoptions "k8s.io/kubernetes/pkg/controller/daemon/options" + deploymentoptions "k8s.io/kubernetes/pkg/controller/deployment/options" + endpointoptions "k8s.io/kubernetes/pkg/controller/endpoint/options" + gcoptions "k8s.io/kubernetes/pkg/controller/gc/options" + joboptions "k8s.io/kubernetes/pkg/controller/job/options" + namespaceoptions "k8s.io/kubernetes/pkg/controller/namespace/options" + nodeoptions "k8s.io/kubernetes/pkg/controller/node/options" + pvoptions "k8s.io/kubernetes/pkg/controller/persistentvolume/options" + hpaoptions "k8s.io/kubernetes/pkg/controller/podautoscaler/options" + replicationoptions "k8s.io/kubernetes/pkg/controller/replication/options" + resourcequotaoptions "k8s.io/kubernetes/pkg/controller/resourcequota/options" + serviceoptions "k8s.io/kubernetes/pkg/controller/service/options" + serviceaccountoptions "k8s.io/kubernetes/pkg/controller/serviceaccount/options" + "k8s.io/kubernetes/pkg/master/ports" "github.com/spf13/pflag" @@ -33,156 +47,107 @@ import ( // CMServer is the main context object for the controller manager. type CMServer struct { - Port int - Address net.IP - CloudProvider string - CloudConfigFile string - ConcurrentEndpointSyncs int - ConcurrentRCSyncs int - ConcurrentDSCSyncs int - ConcurrentJobSyncs int - ConcurrentResourceQuotaSyncs int - ConcurrentDeploymentSyncs int - ServiceSyncPeriod time.Duration - NodeSyncPeriod time.Duration - ResourceQuotaSyncPeriod time.Duration - NamespaceSyncPeriod time.Duration - PVClaimBinderSyncPeriod time.Duration - VolumeConfigFlags VolumeConfigFlags - TerminatedPodGCThreshold int - HorizontalPodAutoscalerSyncPeriod time.Duration - DeploymentControllerSyncPeriod time.Duration - MinResyncPeriod time.Duration - RegisterRetryCount int - NodeMonitorGracePeriod time.Duration - NodeStartupGracePeriod time.Duration - NodeMonitorPeriod time.Duration - NodeStatusUpdateRetry int - PodEvictionTimeout time.Duration - DeletingPodsQps float32 - DeletingPodsBurst int - ServiceAccountKeyFile string - RootCAFile string + Address net.IP + CloudConfigFile string + CloudProvider string + ClusterName string + EnableProfiling bool + KubeAPIBurst int + KubeAPIQPS float32 + Kubeconfig string + Master string + MinResyncPeriod time.Duration + Port int + RootCAFile string - ClusterName string - ClusterCIDR net.IPNet - AllocateNodeCIDRs bool - EnableProfiling bool + DaemonControllerOptions daemonoptions.DaemonControllerOptions + DeploymentControllerOptions deploymentoptions.DeploymentControllerOptions + EndpointControllerOptions endpointoptions.EndpointControllerOptions + GarbageCollectorOptions gcoptions.GarbageCollectorOptions + JobControllerOptions joboptions.JobControllerOptions + LeaderElection componentconfig.LeaderElectionConfiguration + NamespaceControllerOptions namespaceoptions.NamespaceControllerOptions + NodeControllerOptions nodeoptions.NodeControllerOptions + PersistentVolumeControllerOptions pvoptions.PersistentVolumeControllerOptions + PodAutoscalerOptions hpaoptions.PodAutoscalerOptions + ReplicationControllerOptions replicationoptions.ReplicationControllerOptions + ResourceQuotaControllerOptions resourcequotaoptions.ResourceQuotaControllerOptions + ServiceControllerOptions serviceoptions.ServiceControllerOptions + ServiceAccountControllerOptions serviceaccountoptions.ServiceAccountControllerOptions - Master string - Kubeconfig string - KubeAPIQPS float32 - KubeAPIBurst int + // TODO: split into different rates for different components (?) + NodeSyncPeriod time.Duration - LeaderElection componentconfig.LeaderElectionConfiguration -} - -// VolumeConfigFlags is used to bind CLI flags to variables. This top-level struct contains *all* enumerated -// CLI flags meant to configure all volume plugins. From this config, the binary will create many instances -// of volume.VolumeConfig which are then passed to the appropriate plugin. The ControllerManager binary is the only -// part of the code which knows what plugins are supported and which CLI flags correspond to each plugin. -type VolumeConfigFlags struct { - PersistentVolumeRecyclerMinimumTimeoutNFS int - PersistentVolumeRecyclerPodTemplateFilePathNFS string - PersistentVolumeRecyclerIncrementTimeoutNFS int - PersistentVolumeRecyclerPodTemplateFilePathHostPath string - PersistentVolumeRecyclerMinimumTimeoutHostPath int - PersistentVolumeRecyclerIncrementTimeoutHostPath int - EnableHostPathProvisioning bool + // deprecated + DeploymentControllerSyncPeriod time.Duration + RegisterRetryCount int } // NewCMServer creates a new CMServer with a default config. func NewCMServer() *CMServer { s := CMServer{ - Port: ports.ControllerManagerPort, - Address: net.ParseIP("0.0.0.0"), - ConcurrentEndpointSyncs: 5, - ConcurrentRCSyncs: 5, - ConcurrentDSCSyncs: 2, - ConcurrentJobSyncs: 5, - ConcurrentResourceQuotaSyncs: 5, - ConcurrentDeploymentSyncs: 5, - ServiceSyncPeriod: 5 * time.Minute, - NodeSyncPeriod: 10 * time.Second, - ResourceQuotaSyncPeriod: 5 * time.Minute, - NamespaceSyncPeriod: 5 * time.Minute, - PVClaimBinderSyncPeriod: 10 * time.Minute, - HorizontalPodAutoscalerSyncPeriod: 30 * time.Second, - DeploymentControllerSyncPeriod: 30 * time.Second, - MinResyncPeriod: 12 * time.Hour, - RegisterRetryCount: 10, - PodEvictionTimeout: 5 * time.Minute, - NodeMonitorGracePeriod: 40 * time.Second, - NodeStartupGracePeriod: 60 * time.Second, - NodeMonitorPeriod: 5 * time.Second, - ClusterName: "kubernetes", - TerminatedPodGCThreshold: 12500, - VolumeConfigFlags: VolumeConfigFlags{ - // default values here - PersistentVolumeRecyclerMinimumTimeoutNFS: 300, - PersistentVolumeRecyclerIncrementTimeoutNFS: 30, - PersistentVolumeRecyclerMinimumTimeoutHostPath: 60, - PersistentVolumeRecyclerIncrementTimeoutHostPath: 30, - EnableHostPathProvisioning: false, - }, - KubeAPIQPS: 20.0, - KubeAPIBurst: 30, - LeaderElection: leaderelection.DefaultLeaderElectionConfiguration(), + Address: net.ParseIP("0.0.0.0"), + ClusterName: "kubernetes", + KubeAPIQPS: 20.0, + KubeAPIBurst: 30, + MinResyncPeriod: 12 * time.Hour, + Port: ports.ControllerManagerPort, + + NodeSyncPeriod: 10 * time.Second, + + LeaderElection: leaderelection.DefaultLeaderElectionConfiguration(), + DeploymentControllerOptions: deploymentoptions.NewDeploymentControllerOptions(), + DaemonControllerOptions: daemonoptions.NewDaemonControllerOptions(), + EndpointControllerOptions: endpointoptions.NewEndpointControllerOptions(), + GarbageCollectorOptions: gcoptions.NewGarbageCollectorOptions(), + JobControllerOptions: joboptions.NewJobControllerOptions(), + NamespaceControllerOptions: namespaceoptions.NewNamespaceControllerOptions(), + NodeControllerOptions: nodeoptions.NewNodeControllerOptions(), + PersistentVolumeControllerOptions: pvoptions.NewPersistentVolumeControllerOptions(), + PodAutoscalerOptions: hpaoptions.NewPodAutoscalerOptions(), + ReplicationControllerOptions: replicationoptions.NewReplicationControllerOptions(), + ResourceQuotaControllerOptions: resourcequotaoptions.NewResourceQuotaControllerOptions(), + ServiceControllerOptions: serviceoptions.NewServiceControllerOptions(), + ServiceAccountControllerOptions: serviceaccountoptions.NewServiceAccountControllerOptions(), } return &s } // AddFlags adds flags for a specific CMServer to the specified FlagSet func (s *CMServer) AddFlags(fs *pflag.FlagSet) { - fs.IntVar(&s.Port, "port", s.Port, "The port that the controller-manager's http service runs on") fs.IPVar(&s.Address, "address", s.Address, "The IP address to serve on (set to 0.0.0.0 for all interfaces)") - fs.StringVar(&s.CloudProvider, "cloud-provider", s.CloudProvider, "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.") - fs.IntVar(&s.ConcurrentEndpointSyncs, "concurrent-endpoint-syncs", s.ConcurrentEndpointSyncs, "The number of endpoint syncing operations that will be done concurrently. Larger number = faster endpoint updating, but more CPU (and network) load") - fs.IntVar(&s.ConcurrentRCSyncs, "concurrent_rc_syncs", s.ConcurrentRCSyncs, "The number of replication controllers that are allowed to sync concurrently. Larger number = more reponsive replica management, but more CPU (and network) load") - fs.IntVar(&s.ConcurrentResourceQuotaSyncs, "concurrent-resource-quota-syncs", s.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.IntVar(&s.ConcurrentDeploymentSyncs, "concurrent-deployment-syncs", s.ConcurrentDeploymentSyncs, "The number of deployment objects that are allowed to sync concurrently. Larger number = more reponsive deployments, but more CPU (and network) load") - fs.DurationVar(&s.ServiceSyncPeriod, "service-sync-period", s.ServiceSyncPeriod, "The period for syncing services with their external load balancers") + fs.StringVar(&s.CloudProvider, "cloud-provider", s.CloudProvider, "The provider for cloud services. Empty string for no provider.") + fs.StringVar(&s.ClusterName, "cluster-name", s.ClusterName, "The instance prefix for the cluster") + fs.BoolVar(&s.EnableProfiling, "profiling", true, "Enable profiling via web interface host:port/debug/pprof/") + fs.IntVar(&s.KubeAPIBurst, "kube-api-burst", s.KubeAPIBurst, "Burst to use while talking with kubernetes apiserver") + fs.Float32Var(&s.KubeAPIQPS, "kube-api-qps", s.KubeAPIQPS, "QPS to use while talking with kubernetes apiserver") + fs.StringVar(&s.Kubeconfig, "kubeconfig", s.Kubeconfig, "Path to kubeconfig file with authorization and master location information.") + fs.StringVar(&s.Master, "master", s.Master, "The address of the Kubernetes API server (overrides any value in kubeconfig)") + fs.DurationVar(&s.MinResyncPeriod, "min-resync-period", s.MinResyncPeriod, "The resync period in reflectors will be random between MinResyncPeriod and 2*MinResyncPeriod") + fs.IntVar(&s.Port, "port", s.Port, "The port that the controller-manager's http service runs on") + fs.StringVar(&s.RootCAFile, "root-ca-file", s.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.DurationVar(&s.NodeSyncPeriod, "node-sync-period", s.NodeSyncPeriod, ""+ "The period for syncing nodes from cloudprovider. Longer periods will result in "+ "fewer calls to cloud provider, but may delay addition of new nodes to cluster.") - fs.DurationVar(&s.ResourceQuotaSyncPeriod, "resource-quota-sync-period", s.ResourceQuotaSyncPeriod, "The period for syncing quota usage status in the system") - fs.DurationVar(&s.NamespaceSyncPeriod, "namespace-sync-period", s.NamespaceSyncPeriod, "The period for syncing namespace life-cycle updates") - fs.DurationVar(&s.PVClaimBinderSyncPeriod, "pvclaimbinder-sync-period", s.PVClaimBinderSyncPeriod, "The period for syncing persistent volumes and persistent volume claims") - fs.DurationVar(&s.MinResyncPeriod, "min-resync-period", s.MinResyncPeriod, "The resync period in reflectors will be random between MinResyncPeriod and 2*MinResyncPeriod") - fs.StringVar(&s.VolumeConfigFlags.PersistentVolumeRecyclerPodTemplateFilePathNFS, "pv-recycler-pod-template-filepath-nfs", s.VolumeConfigFlags.PersistentVolumeRecyclerPodTemplateFilePathNFS, "The file path to a pod definition used as a template for NFS persistent volume recycling") - fs.IntVar(&s.VolumeConfigFlags.PersistentVolumeRecyclerMinimumTimeoutNFS, "pv-recycler-minimum-timeout-nfs", s.VolumeConfigFlags.PersistentVolumeRecyclerMinimumTimeoutNFS, "The minimum ActiveDeadlineSeconds to use for an NFS Recycler pod") - fs.IntVar(&s.VolumeConfigFlags.PersistentVolumeRecyclerIncrementTimeoutNFS, "pv-recycler-increment-timeout-nfs", s.VolumeConfigFlags.PersistentVolumeRecyclerIncrementTimeoutNFS, "the increment of time added per Gi to ActiveDeadlineSeconds for an NFS scrubber pod") - fs.StringVar(&s.VolumeConfigFlags.PersistentVolumeRecyclerPodTemplateFilePathHostPath, "pv-recycler-pod-template-filepath-hostpath", s.VolumeConfigFlags.PersistentVolumeRecyclerPodTemplateFilePathHostPath, "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.IntVar(&s.VolumeConfigFlags.PersistentVolumeRecyclerMinimumTimeoutHostPath, "pv-recycler-minimum-timeout-hostpath", s.VolumeConfigFlags.PersistentVolumeRecyclerMinimumTimeoutHostPath, "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.IntVar(&s.VolumeConfigFlags.PersistentVolumeRecyclerIncrementTimeoutHostPath, "pv-recycler-timeout-increment-hostpath", s.VolumeConfigFlags.PersistentVolumeRecyclerIncrementTimeoutHostPath, "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.VolumeConfigFlags.EnableHostPathProvisioning, "enable-hostpath-provisioner", s.VolumeConfigFlags.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.IntVar(&s.TerminatedPodGCThreshold, "terminated-pod-gc-threshold", s.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.HorizontalPodAutoscalerSyncPeriod, "horizontal-pod-autoscaler-sync-period", s.HorizontalPodAutoscalerSyncPeriod, "The period for syncing the number of pods in horizontal pod autoscaler.") - fs.DurationVar(&s.DeploymentControllerSyncPeriod, "deployment-controller-sync-period", s.DeploymentControllerSyncPeriod, "Period for syncing the deployments.") - fs.DurationVar(&s.PodEvictionTimeout, "pod-eviction-timeout", s.PodEvictionTimeout, "The grace period for deleting pods on failed nodes.") - fs.Float32Var(&s.DeletingPodsQps, "deleting-pods-qps", 0.1, "Number of nodes per second on which pods are deleted in case of node failure.") - fs.IntVar(&s.DeletingPodsBurst, "deleting-pods-burst", 10, "Number of nodes on which pods are bursty deleted in case of node failure. For more details look into RateLimiter.") - fs.IntVar(&s.RegisterRetryCount, "register-retry-count", s.RegisterRetryCount, ""+ + s.LeaderElection.AddFlags(fs) + s.DaemonControllerOptions.AddFlags(fs) + s.DeploymentControllerOptions.AddFlags(fs) + s.EndpointControllerOptions.AddFlags(fs) + s.GarbageCollectorOptions.AddFlags(fs) + s.JobControllerOptions.AddFlags(fs) + s.NamespaceControllerOptions.AddFlags(fs) + s.NodeControllerOptions.AddFlags(fs) + s.PersistentVolumeControllerOptions.AddFlags(fs) + s.PodAutoscalerOptions.AddFlags(fs) + s.ReplicationControllerOptions.AddFlags(fs) + s.ResourceQuotaControllerOptions.AddFlags(fs) + s.ServiceControllerOptions.AddFlags(fs) + s.ServiceAccountControllerOptions.AddFlags(fs) + fs.DurationVar(&s.DeploymentControllerSyncPeriod, "deployment-controller-sync-period", 0, "Period for syncing the deployments.") + fs.MarkDeprecated("deployment-controller-sync-period", "This flag is currently no-op and will be deleted.") + fs.IntVar(&s.RegisterRetryCount, "register-retry-count", 0, ""+ "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.NodeMonitorGracePeriod, "node-monitor-grace-period", s.NodeMonitorGracePeriod, - "Amount of time which we allow running Node to be unresponsive before marking it unhealty. "+ - "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.NodeStartupGracePeriod, "node-startup-grace-period", s.NodeStartupGracePeriod, - "Amount of time which we allow starting Node to be unresponsive before marking it unhealty.") - fs.DurationVar(&s.NodeMonitorPeriod, "node-monitor-period", s.NodeMonitorPeriod, - "The period for syncing NodeStatus in NodeController.") - fs.StringVar(&s.ServiceAccountKeyFile, "service-account-private-key-file", s.ServiceAccountKeyFile, "Filename containing a PEM-encoded private RSA key used to sign service account tokens.") - fs.BoolVar(&s.EnableProfiling, "profiling", true, "Enable profiling via web interface host:port/debug/pprof/") - fs.StringVar(&s.ClusterName, "cluster-name", s.ClusterName, "The instance prefix for the cluster") - fs.IPNetVar(&s.ClusterCIDR, "cluster-cidr", s.ClusterCIDR, "CIDR Range for Pods in cluster.") - fs.BoolVar(&s.AllocateNodeCIDRs, "allocate-node-cidrs", false, "Should CIDRs for Pods be allocated and set on the cloud provider.") - fs.StringVar(&s.Master, "master", s.Master, "The address of the Kubernetes API server (overrides any value in kubeconfig)") - fs.StringVar(&s.Kubeconfig, "kubeconfig", s.Kubeconfig, "Path to kubeconfig file with authorization and master location information.") - fs.StringVar(&s.RootCAFile, "root-ca-file", s.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.Float32Var(&s.KubeAPIQPS, "kube-api-qps", s.KubeAPIQPS, "QPS to use while talking with kubernetes apiserver") - fs.IntVar(&s.KubeAPIBurst, "kube-api-burst", s.KubeAPIBurst, "Burst to use while talking with kubernetes apiserver") - leaderelection.BindFlags(&s.LeaderElection, fs) } diff --git a/cmd/kube-controller-manager/app/plugins.go b/cmd/kube-controller-manager/app/plugins.go index 03c7cafd7f8..7b74e9ad4df 100644 --- a/cmd/kube-controller-manager/app/plugins.go +++ b/cmd/kube-controller-manager/app/plugins.go @@ -23,7 +23,7 @@ import ( "fmt" - "k8s.io/kubernetes/cmd/kube-controller-manager/app/options" + "k8s.io/kubernetes/pkg/controller/persistentvolume/options" // Cloud providers _ "k8s.io/kubernetes/pkg/cloudprovider/providers" diff --git a/contrib/mesos/pkg/controllermanager/controllermanager.go b/contrib/mesos/pkg/controllermanager/controllermanager.go index 85ff50eb434..2c02dd98eee 100644 --- a/contrib/mesos/pkg/controllermanager/controllermanager.go +++ b/contrib/mesos/pkg/controllermanager/controllermanager.go @@ -128,13 +128,13 @@ func (s *CMServer) Run(_ []string) error { }() endpoints := s.createEndpointController(clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "endpoint-controller"))) - go endpoints.Run(s.ConcurrentEndpointSyncs, util.NeverStop) + go endpoints.Run(s.EndpointControllerOptions.ConcurrentEndpointSyncs, util.NeverStop) go replicationcontroller.NewReplicationManager(clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "replication-controller")), s.resyncPeriod, replicationcontroller.BurstReplicas). - Run(s.ConcurrentRCSyncs, util.NeverStop) + Run(s.ReplicationControllerOptions.ConcurrentRCSyncs, util.NeverStop) - if s.TerminatedPodGCThreshold > 0 { - go gc.New(clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "garbage-collector")), s.resyncPeriod, s.TerminatedPodGCThreshold). + if s.GarbageCollectorOptions.TerminatedPodGCThreshold > 0 { + go gc.New(clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "garbage-collector")), s.resyncPeriod, s.GarbageCollectorOptions.TerminatedPodGCThreshold). Run(util.NeverStop) } @@ -148,32 +148,37 @@ func (s *CMServer) Run(_ []string) error { } nodeController := nodecontroller.NewNodeController(cloud, clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "node-controller")), - s.PodEvictionTimeout, util.NewTokenBucketRateLimiter(s.DeletingPodsQps, s.DeletingPodsBurst), - util.NewTokenBucketRateLimiter(s.DeletingPodsQps, s.DeletingPodsBurst), - s.NodeMonitorGracePeriod, s.NodeStartupGracePeriod, s.NodeMonitorPeriod, (*net.IPNet)(&s.ClusterCIDR), s.AllocateNodeCIDRs) + s.NodeControllerOptions.PodEvictionTimeout, util.NewTokenBucketRateLimiter(s.NodeControllerOptions.DeletingPodsQps, s.NodeControllerOptions.DeletingPodsBurst), + util.NewTokenBucketRateLimiter(s.NodeControllerOptions.DeletingPodsQps, s.NodeControllerOptions.DeletingPodsBurst), + s.NodeControllerOptions.NodeMonitorGracePeriod, s.NodeControllerOptions.NodeStartupGracePeriod, s.NodeControllerOptions.NodeMonitorPeriod, + (*net.IPNet)(&s.NodeControllerOptions.ClusterCIDR), s.NodeControllerOptions.AllocateNodeCIDRs) nodeController.Run(s.NodeSyncPeriod) - nodeStatusUpdaterController := node.NewStatusUpdater(clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "node-status-controller")), s.NodeMonitorPeriod, time.Now) + nodeStatusUpdaterController := node.NewStatusUpdater(clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "node-status-controller")), + s.NodeControllerOptions.NodeMonitorPeriod, time.Now) if err := nodeStatusUpdaterController.Run(util.NeverStop); err != nil { glog.Fatalf("Failed to start node status update controller: %v", err) } serviceController := servicecontroller.New(cloud, clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "service-controller")), s.ClusterName) - if err := serviceController.Run(s.ServiceSyncPeriod, s.NodeSyncPeriod); err != nil { + if err := serviceController.Run(s.ServiceControllerOptions.ServiceSyncPeriod, s.NodeSyncPeriod); err != nil { glog.Errorf("Failed to start service controller: %v", err) } - if s.AllocateNodeCIDRs { + if s.NodeControllerOptions.AllocateNodeCIDRs { routes, ok := cloud.Routes() if !ok { glog.Fatal("Cloud provider must support routes if allocate-node-cidrs is set") } - routeController := routecontroller.New(routes, clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "route-controller")), s.ClusterName, (*net.IPNet)(&s.ClusterCIDR)) + routeController := routecontroller.New(routes, clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "route-controller")), s.ClusterName, (*net.IPNet)(&s.NodeControllerOptions.ClusterCIDR)) routeController.Run(s.NodeSyncPeriod) } go resourcequotacontroller.NewResourceQuotaController( - clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "resource-quota-controller")), controller.StaticResyncPeriodFunc(s.ResourceQuotaSyncPeriod)).Run(s.ConcurrentResourceQuotaSyncs, util.NeverStop) + clientset.NewForConfigOrDie( + client.AddUserAgent(kubeconfig, "resource-quota-controller")), + controller.StaticResyncPeriodFunc(s.ResourceQuotaControllerOptions.ResourceQuotaSyncPeriod), + ).Run(s.ResourceQuotaControllerOptions.ConcurrentResourceQuotaSyncs, util.NeverStop) // 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. @@ -195,7 +200,9 @@ func (s *CMServer) Run(_ []string) error { glog.Fatalf("Failed to get supported resources from server: %v", err) } - namespaceController := namespacecontroller.NewNamespaceController(clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "namespace-controller")), &unversioned.APIVersions{}, s.NamespaceSyncPeriod) + namespaceController := namespacecontroller.NewNamespaceController( + clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "namespace-controller")), + &unversioned.APIVersions{}, s.NamespaceControllerOptions.NamespaceSyncPeriod) namespaceController.Run() groupVersion := "extensions/v1beta1" @@ -214,45 +221,51 @@ func (s *CMServer) Run(_ []string) error { metrics.DefaultHeapsterPort, ) podautoscaler.NewHorizontalController(hpaClient.Core(), hpaClient.Extensions(), hpaClient, metricsClient). - Run(s.HorizontalPodAutoscalerSyncPeriod) + Run(s.PodAutoscalerOptions.HorizontalPodAutoscalerSyncPeriod) } if containsResource(resources, "daemonsets") { glog.Infof("Starting daemon set controller") go daemon.NewDaemonSetsController(clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "daemon-set-controller")), s.resyncPeriod). - Run(s.ConcurrentDSCSyncs, util.NeverStop) + Run(s.DaemonControllerOptions.ConcurrentDSCSyncs, util.NeverStop) } if containsResource(resources, "jobs") { glog.Infof("Starting job controller") go job.NewJobController(clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "job-controller")), s.resyncPeriod). - Run(s.ConcurrentJobSyncs, util.NeverStop) + Run(s.JobControllerOptions.ConcurrentJobSyncs, util.NeverStop) } if containsResource(resources, "deployments") { glog.Infof("Starting deployment controller") go deployment.NewDeploymentController(clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "deployment-controller")), s.resyncPeriod). - Run(s.ConcurrentDeploymentSyncs, util.NeverStop) + Run(s.DeploymentControllerOptions.ConcurrentDeploymentSyncs, util.NeverStop) } } - volumePlugins := kubecontrollermanager.ProbeRecyclableVolumePlugins(s.VolumeConfigFlags) - provisioner, err := kubecontrollermanager.NewVolumeProvisioner(cloud, s.VolumeConfigFlags) + volumePlugins := kubecontrollermanager.ProbeRecyclableVolumePlugins(s.PersistentVolumeControllerOptions.VolumeConfigFlags) + provisioner, err := kubecontrollermanager.NewVolumeProvisioner(cloud, s.PersistentVolumeControllerOptions.VolumeConfigFlags) if err != nil { glog.Fatal("A Provisioner could not be created, but one was expected. Provisioning will not work. This functionality is considered an early Alpha version.") } - pvclaimBinder := persistentvolumecontroller.NewPersistentVolumeClaimBinder(clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "persistent-volume-binder")), s.PVClaimBinderSyncPeriod) + pvclaimBinder := persistentvolumecontroller.NewPersistentVolumeClaimBinder( + clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "persistent-volume-binder")), s.PersistentVolumeControllerOptions.PVClaimBinderSyncPeriod) pvclaimBinder.Run() - pvRecycler, err := persistentvolumecontroller.NewPersistentVolumeRecycler(clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "persistent-volume-recycler")), s.PVClaimBinderSyncPeriod, kubecontrollermanager.ProbeRecyclableVolumePlugins(s.VolumeConfigFlags), cloud) + pvRecycler, err := persistentvolumecontroller.NewPersistentVolumeRecycler( + clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "persistent-volume-recycler")), + s.PersistentVolumeControllerOptions.PVClaimBinderSyncPeriod, + kubecontrollermanager.ProbeRecyclableVolumePlugins(s.PersistentVolumeControllerOptions.VolumeConfigFlags), cloud) if err != nil { glog.Fatalf("Failed to start persistent volume recycler: %+v", err) } pvRecycler.Run() if provisioner != nil { - pvController, err := persistentvolumecontroller.NewPersistentVolumeProvisionerController(persistentvolumecontroller.NewControllerClient(clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "persistent-volume-controller"))), s.PVClaimBinderSyncPeriod, volumePlugins, provisioner, cloud) + pvController, err := persistentvolumecontroller.NewPersistentVolumeProvisionerController( + persistentvolumecontroller.NewControllerClient(clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "persistent-volume-controller"))), + s.PersistentVolumeControllerOptions.PVClaimBinderSyncPeriod, volumePlugins, provisioner, cloud) if err != nil { glog.Fatalf("Failed to start persistent volume provisioner controller: %+v", err) } @@ -273,8 +286,8 @@ func (s *CMServer) Run(_ []string) error { rootCA = kubeconfig.CAData } - if len(s.ServiceAccountKeyFile) > 0 { - privateKey, err := serviceaccount.ReadPrivateKey(s.ServiceAccountKeyFile) + if len(s.ServiceAccountControllerOptions.ServiceAccountKeyFile) > 0 { + privateKey, err := serviceaccount.ReadPrivateKey(s.ServiceAccountControllerOptions.ServiceAccountKeyFile) if err != nil { glog.Errorf("Error reading key for service account token controller: %v", err) } else { diff --git a/contrib/mesos/pkg/node/statusupdater_test.go b/contrib/mesos/pkg/node/statusupdater_test.go index aba8fca5b33..d115501e61a 100644 --- a/contrib/mesos/pkg/node/statusupdater_test.go +++ b/contrib/mesos/pkg/node/statusupdater_test.go @@ -48,15 +48,15 @@ func Test_nodeWithUpdatedStatus(t *testing.T) { cm := cmoptions.NewCMServer() kubecfg := kubeletoptions.NewKubeletServer() - assert.True(t, kubecfg.NodeStatusUpdateFrequency.Duration*3 < cm.NodeMonitorGracePeriod) // sanity check for defaults + assert.True(t, kubecfg.NodeStatusUpdateFrequency.Duration*3 < cm.NodeControllerOptions.NodeMonitorGracePeriod) // sanity check for defaults n := testNode(0, api.ConditionTrue, "KubeletReady") - su := NewStatusUpdater(nil, cm.NodeMonitorPeriod, func() time.Time { return now }) + su := NewStatusUpdater(nil, cm.NodeControllerOptions.NodeMonitorPeriod, func() time.Time { return now }) _, updated, err := su.nodeWithUpdatedStatus(n) assert.NoError(t, err) assert.False(t, updated, "no update expected b/c kubelet updated heartbeat just now") - n = testNode(-cm.NodeMonitorGracePeriod, api.ConditionTrue, "KubeletReady") + n = testNode(-cm.NodeControllerOptions.NodeMonitorGracePeriod, api.ConditionTrue, "KubeletReady") n2, updated, err := su.nodeWithUpdatedStatus(n) assert.NoError(t, err) assert.True(t, updated, "update expected b/c kubelet's update is older than DefaultNodeMonitorGracePeriod") diff --git a/docs/admin/kube-controller-manager.md b/docs/admin/kube-controller-manager.md index 8c26647ed0d..c0b62ec11c9 100644 --- a/docs/admin/kube-controller-manager.md +++ b/docs/admin/kube-controller-manager.md @@ -61,14 +61,15 @@ kube-controller-manager --cloud-provider="": The provider for cloud services. Empty string for no provider. --cluster-cidr=: CIDR Range for Pods in cluster. --cluster-name="kubernetes": The instance prefix for the cluster + --concurrent-daemonset-controller-syncs=2: The number of deamon sets that are allowed to sync concurrently. --concurrent-deployment-syncs=5: The number of deployment objects that are allowed to sync concurrently. Larger number = more reponsive deployments, but more CPU (and network) load --concurrent-endpoint-syncs=5: The number of endpoint syncing operations that will be done concurrently. Larger number = faster endpoint updating, but more CPU (and network) load + --concurrent-job-syncs=5: The number of job objects that are allowed to sync concurrently. --concurrent-resource-quota-syncs=5: The number of resource quotas that are allowed to sync concurrently. Larger number = more responsive quota management, but more CPU (and network) load --concurrent_rc_syncs=5: The number of replication controllers that are allowed to sync concurrently. Larger number = more reponsive replica management, but more CPU (and network) load --deleting-pods-burst=10: Number of nodes on which pods are bursty deleted in case of node failure. For more details look into RateLimiter. --deleting-pods-qps=0.1: Number of nodes per second on which pods are deleted in case of node failure. - --deployment-controller-sync-period=30s: Period for syncing the deployments. - --enable-hostpath-provisioner[=false]: 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. + --enable-hostpath-provisioner[=false]: 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. --google-json-key="": The Google Cloud Platform Service Account JSON Key to use for authentication. --horizontal-pod-autoscaler-sync-period=30s: The period for syncing the number of pods in horizontal pod autoscaler. --kube-api-burst=30: Burst to use while talking with kubernetes apiserver @@ -90,11 +91,11 @@ kube-controller-manager --port=10252: The port that the controller-manager's http service runs on --profiling[=true]: Enable profiling via web interface host:port/debug/pprof/ --pv-recycler-increment-timeout-nfs=30: the increment of time added per Gi to ActiveDeadlineSeconds for an NFS scrubber pod - --pv-recycler-minimum-timeout-hostpath=60: 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. + --pv-recycler-minimum-timeout-hostpath=60: 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. --pv-recycler-minimum-timeout-nfs=300: The minimum ActiveDeadlineSeconds to use for an NFS Recycler pod --pv-recycler-pod-template-filepath-hostpath="": 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. --pv-recycler-pod-template-filepath-nfs="": The file path to a pod definition used as a template for NFS persistent volume recycling - --pv-recycler-timeout-increment-hostpath=30: 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. + --pv-recycler-timeout-increment-hostpath=30: 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. --pvclaimbinder-sync-period=10m0s: The period for syncing persistent volumes and persistent volume claims --resource-quota-sync-period=5m0s: The period for syncing quota usage status in the system --root-ca-file="": If set, this root certificate authority will be included in service account's token secret. This must be a valid PEM-encoded CA bundle. @@ -103,7 +104,7 @@ kube-controller-manager --terminated-pod-gc-threshold=12500: 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. ``` -###### Auto generated by spf13/cobra on 18-Jan-2016 +###### Auto generated by spf13/cobra on 5-Feb-2016 diff --git a/hack/verify-flags/known-flags.txt b/hack/verify-flags/known-flags.txt index c31c808c6bf..7372144ed6a 100644 --- a/hack/verify-flags/known-flags.txt +++ b/hack/verify-flags/known-flags.txt @@ -45,8 +45,10 @@ cluster-dns cluster-domain cluster-name cluster-tag +concurrent-daemonset-controller-syncs concurrent-deployment-syncs concurrent-endpoint-syncs +concurrent-job-syncs concurrent-resource-quota-syncs config-sync-period configure-cbr0 diff --git a/pkg/apis/componentconfig/types.go b/pkg/apis/componentconfig/types.go index cee57431e92..09a68f95bb0 100644 --- a/pkg/apis/componentconfig/types.go +++ b/pkg/apis/componentconfig/types.go @@ -16,7 +16,11 @@ limitations under the License. package componentconfig -import "k8s.io/kubernetes/pkg/api/unversioned" +import ( + "k8s.io/kubernetes/pkg/api/unversioned" + + "github.com/spf13/pflag" +) type KubeProxyConfiguration struct { unversioned.TypeMeta @@ -339,3 +343,24 @@ type LeaderElectionConfiguration struct { // leader election is enabled. RetryPeriod unversioned.Duration `json:"retryPeriod"` } + +// AddFlags binds the common LeaderElectionCLIConfig flags to a flagset +func (l *LeaderElectionConfiguration) AddFlags(fs *pflag.FlagSet) { + fs.BoolVar(&l.LeaderElect, "leader-elect", l.LeaderElect, ""+ + "Start a leader election client and gain leadership before "+ + "executing the main loop. Enable this when running replicated "+ + "components for high availability.") + fs.DurationVar(&l.LeaseDuration.Duration, "leader-elect-lease-duration", l.LeaseDuration.Duration, ""+ + "The duration that non-leader candidates will wait after observing a leadership "+ + "renewal until attempting to acquire leadership of a led but unrenewed leader "+ + "slot. This is effectively the maximum duration that a leader can be stopped "+ + "before it is replaced by another candidate. This is only applicable if leader "+ + "election is enabled.") + fs.DurationVar(&l.RenewDeadline.Duration, "leader-elect-renew-deadline", l.RenewDeadline.Duration, ""+ + "The interval between attempts by the acting master to renew a leadership slot "+ + "before it stops leading. This must be less than or equal to the lease duration. "+ + "This is only applicable if leader election is enabled.") + fs.DurationVar(&l.RetryPeriod.Duration, "leader-elect-retry-period", l.RetryPeriod.Duration, ""+ + "The duration the clients should wait between attempting acquisition and renewal "+ + "of a leadership. This is only applicable if leader election is enabled.") +} diff --git a/pkg/client/leaderelection/leaderelection.go b/pkg/client/leaderelection/leaderelection.go index 6c2f52c6634..b6d35408b1c 100644 --- a/pkg/client/leaderelection/leaderelection.go +++ b/pkg/client/leaderelection/leaderelection.go @@ -65,7 +65,6 @@ import ( "k8s.io/kubernetes/pkg/util/wait" "github.com/golang/glog" - "github.com/spf13/pflag" ) const ( @@ -341,24 +340,3 @@ func DefaultLeaderElectionConfiguration() componentconfig.LeaderElectionConfigur RetryPeriod: unversioned.Duration{DefaultRetryPeriod}, } } - -// 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, ""+ - "Start a leader election client and gain leadership before "+ - "executing the main loop. Enable this when running replicated "+ - "components for high availability.") - fs.DurationVar(&l.LeaseDuration.Duration, "leader-elect-lease-duration", l.LeaseDuration.Duration, ""+ - "The duration that non-leader candidates will wait after observing a leadership "+ - "renewal until attempting to acquire leadership of a led but unrenewed leader "+ - "slot. This is effectively the maximum duration that a leader can be stopped "+ - "before it is replaced by another candidate. This is only applicable if leader "+ - "election is enabled.") - fs.DurationVar(&l.RenewDeadline.Duration, "leader-elect-renew-deadline", l.RenewDeadline.Duration, ""+ - "The interval between attempts by the acting master to renew a leadership slot "+ - "before it stops leading. This must be less than or equal to the lease duration. "+ - "This is only applicable if leader election is enabled.") - fs.DurationVar(&l.RetryPeriod.Duration, "leader-elect-retry-period", l.RetryPeriod.Duration, ""+ - "The duration the clients should wait between attempting acquisition and renewal "+ - "of a leadership. This is only applicable if leader election is enabled.") -} diff --git a/pkg/controller/daemon/options/options.go b/pkg/controller/daemon/options/options.go new file mode 100644 index 00000000000..9db43972ddf --- /dev/null +++ b/pkg/controller/daemon/options/options.go @@ -0,0 +1,35 @@ +/* +Copyright 2016 The Kubernetes Authors All rights reserved. + +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" +) + +type DaemonControllerOptions struct { + ConcurrentDSCSyncs int +} + +func NewDaemonControllerOptions() DaemonControllerOptions { + return DaemonControllerOptions{ + ConcurrentDSCSyncs: 2, + } +} + +func (o *DaemonControllerOptions) AddFlags(fs *pflag.FlagSet) { + fs.IntVar(&o.ConcurrentDSCSyncs, "concurrent-daemonset-controller-syncs", o.ConcurrentDSCSyncs, "The number of deamon sets that are allowed to sync concurrently.") +} diff --git a/pkg/controller/deployment/options/options.go b/pkg/controller/deployment/options/options.go new file mode 100644 index 00000000000..d58814cc493 --- /dev/null +++ b/pkg/controller/deployment/options/options.go @@ -0,0 +1,36 @@ +/* +Copyright 2016 The Kubernetes Authors All rights reserved. + +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" +) + +type DeploymentControllerOptions struct { + ConcurrentDeploymentSyncs int +} + +func NewDeploymentControllerOptions() DeploymentControllerOptions { + return DeploymentControllerOptions{ + ConcurrentDeploymentSyncs: 5, + } +} + +func (o *DeploymentControllerOptions) AddFlags(fs *pflag.FlagSet) { + fs.IntVar(&o.ConcurrentDeploymentSyncs, "concurrent-deployment-syncs", o.ConcurrentDeploymentSyncs, + "The number of deployment objects that are allowed to sync concurrently. Larger number = more reponsive deployments, but more CPU (and network) load") +} diff --git a/pkg/controller/endpoint/options/options.go b/pkg/controller/endpoint/options/options.go new file mode 100644 index 00000000000..59e669ff077 --- /dev/null +++ b/pkg/controller/endpoint/options/options.go @@ -0,0 +1,36 @@ +/* +Copyright 2016 The Kubernetes Authors All rights reserved. + +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" +) + +type EndpointControllerOptions struct { + ConcurrentEndpointSyncs int +} + +func NewEndpointControllerOptions() EndpointControllerOptions { + return EndpointControllerOptions{ + ConcurrentEndpointSyncs: 5, + } +} + +func (o *EndpointControllerOptions) AddFlags(fs *pflag.FlagSet) { + fs.IntVar(&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") +} diff --git a/pkg/controller/gc/options/options.go b/pkg/controller/gc/options/options.go new file mode 100644 index 00000000000..9bb2edba7cb --- /dev/null +++ b/pkg/controller/gc/options/options.go @@ -0,0 +1,37 @@ +/* +Copyright 2016 The Kubernetes Authors All rights reserved. + +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" +) + +type GarbageCollectorOptions struct { + TerminatedPodGCThreshold int +} + +func NewGarbageCollectorOptions() GarbageCollectorOptions { + return GarbageCollectorOptions{ + TerminatedPodGCThreshold: 12500, + } +} + +func (o *GarbageCollectorOptions) AddFlags(fs *pflag.FlagSet) { + fs.IntVar(&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.") +} diff --git a/pkg/controller/job/options/options.go b/pkg/controller/job/options/options.go new file mode 100644 index 00000000000..d3a1100ca4c --- /dev/null +++ b/pkg/controller/job/options/options.go @@ -0,0 +1,35 @@ +/* +Copyright 2016 The Kubernetes Authors All rights reserved. + +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" +) + +type JobControllerOptions struct { + ConcurrentJobSyncs int +} + +func NewJobControllerOptions() JobControllerOptions { + return JobControllerOptions{ + ConcurrentJobSyncs: 5, + } +} + +func (o *JobControllerOptions) AddFlags(fs *pflag.FlagSet) { + fs.IntVar(&o.ConcurrentJobSyncs, "concurrent-job-syncs", o.ConcurrentJobSyncs, "The number of job objects that are allowed to sync concurrently.") +} diff --git a/pkg/controller/namespace/options/options.go b/pkg/controller/namespace/options/options.go new file mode 100644 index 00000000000..6078672f06c --- /dev/null +++ b/pkg/controller/namespace/options/options.go @@ -0,0 +1,37 @@ +/* +Copyright 2016 The Kubernetes Authors All rights reserved. + +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 ( + "time" + + "github.com/spf13/pflag" +) + +type NamespaceControllerOptions struct { + NamespaceSyncPeriod time.Duration +} + +func NewNamespaceControllerOptions() NamespaceControllerOptions { + return NamespaceControllerOptions{ + NamespaceSyncPeriod: 5 * time.Minute, + } +} + +func (o *NamespaceControllerOptions) AddFlags(fs *pflag.FlagSet) { + fs.DurationVar(&o.NamespaceSyncPeriod, "namespace-sync-period", o.NamespaceSyncPeriod, "The period for syncing namespace life-cycle updates") +} diff --git a/pkg/controller/node/options/options.go b/pkg/controller/node/options/options.go new file mode 100644 index 00000000000..502224f88fc --- /dev/null +++ b/pkg/controller/node/options/options.go @@ -0,0 +1,67 @@ +/* +Copyright 2016 The Kubernetes Authors All rights reserved. + +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 ( + "net" + "time" + + "github.com/spf13/pflag" +) + +type NodeControllerOptions struct { + AllocateNodeCIDRs bool + ClusterCIDR net.IPNet + DeletingPodsBurst int + DeletingPodsQps float32 + NodeMonitorGracePeriod time.Duration + NodeMonitorPeriod time.Duration + NodeStartupGracePeriod time.Duration + PodEvictionTimeout time.Duration +} + +func NewNodeControllerOptions() NodeControllerOptions { + return NodeControllerOptions{ + AllocateNodeCIDRs: false, + DeletingPodsBurst: 10, + DeletingPodsQps: 0.1, + NodeMonitorGracePeriod: 40 * time.Second, + NodeMonitorPeriod: 5 * time.Second, + NodeStartupGracePeriod: 60 * time.Second, + PodEvictionTimeout: 5 * time.Minute, + } +} + +func (o *NodeControllerOptions) AddFlags(fs *pflag.FlagSet) { + fs.BoolVar(&o.AllocateNodeCIDRs, "allocate-node-cidrs", o.AllocateNodeCIDRs, "Should CIDRs for Pods be allocated and set on the cloud provider.") + fs.IPNetVar(&o.ClusterCIDR, "cluster-cidr", o.ClusterCIDR, "CIDR Range for Pods in cluster.") + fs.IntVar(&o.DeletingPodsBurst, "deleting-pods-burst", o.DeletingPodsBurst, + "Number of nodes on which pods are bursty deleted in case of node failure. For more details look into RateLimiter.") + fs.Float32Var(&o.DeletingPodsQps, "deleting-pods-qps", o.DeletingPodsQps, + "Number of nodes per second on which pods are deleted in case of node failure.") + fs.DurationVar(&o.NodeMonitorGracePeriod, "node-monitor-grace-period", o.NodeMonitorGracePeriod, + "Amount of time which we allow running Node to be unresponsive before marking it unhealty. "+ + "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.NodeMonitorPeriod, "node-monitor-period", o.NodeMonitorPeriod, + "The period for syncing NodeStatus in NodeController.") + fs.DurationVar(&o.NodeStartupGracePeriod, "node-startup-grace-period", o.NodeStartupGracePeriod, + "Amount of time which we allow starting Node to be unresponsive before marking it unhealty.") + fs.DurationVar(&o.PodEvictionTimeout, "pod-eviction-timeout", o.PodEvictionTimeout, + "The grace period for deleting pods on failed nodes.") + +} diff --git a/pkg/controller/persistentvolume/options/options.go b/pkg/controller/persistentvolume/options/options.go new file mode 100644 index 00000000000..ae0702ab21b --- /dev/null +++ b/pkg/controller/persistentvolume/options/options.go @@ -0,0 +1,82 @@ +/* +Copyright 2016 The Kubernetes Authors All rights reserved. + +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 ( + "time" + + "github.com/spf13/pflag" +) + +// VolumeConfigFlags is used to bind CLI flags to variables. This top-level struct contains *all* enumerated +// CLI flags meant to configure all volume plugins. From this config, the binary will create many instances +// of volume.VolumeConfig which are then passed to the appropriate plugin. The ControllerManager binary is the only +// part of the code which knows what plugins are supported and which CLI flags correspond to each plugin. +type VolumeConfigFlags struct { + PersistentVolumeRecyclerMinimumTimeoutNFS int + PersistentVolumeRecyclerPodTemplateFilePathNFS string + PersistentVolumeRecyclerIncrementTimeoutNFS int + PersistentVolumeRecyclerPodTemplateFilePathHostPath string + PersistentVolumeRecyclerMinimumTimeoutHostPath int + PersistentVolumeRecyclerIncrementTimeoutHostPath int + EnableHostPathProvisioning bool +} + +type PersistentVolumeControllerOptions struct { + PVClaimBinderSyncPeriod time.Duration + VolumeConfigFlags VolumeConfigFlags +} + +func NewPersistentVolumeControllerOptions() PersistentVolumeControllerOptions { + return PersistentVolumeControllerOptions{ + PVClaimBinderSyncPeriod: 10 * time.Minute, + VolumeConfigFlags: VolumeConfigFlags{ + // default values here + PersistentVolumeRecyclerMinimumTimeoutNFS: 300, + PersistentVolumeRecyclerIncrementTimeoutNFS: 30, + PersistentVolumeRecyclerMinimumTimeoutHostPath: 60, + PersistentVolumeRecyclerIncrementTimeoutHostPath: 30, + EnableHostPathProvisioning: false, + }, + } +} + +func (o *PersistentVolumeControllerOptions) AddFlags(fs *pflag.FlagSet) { + fs.DurationVar(&o.PVClaimBinderSyncPeriod, "pvclaimbinder-sync-period", o.PVClaimBinderSyncPeriod, + "The period for syncing persistent volumes and persistent volume claims") + fs.StringVar(&o.VolumeConfigFlags.PersistentVolumeRecyclerPodTemplateFilePathNFS, + "pv-recycler-pod-template-filepath-nfs", o.VolumeConfigFlags.PersistentVolumeRecyclerPodTemplateFilePathNFS, + "The file path to a pod definition used as a template for NFS persistent volume recycling") + fs.IntVar(&o.VolumeConfigFlags.PersistentVolumeRecyclerMinimumTimeoutNFS, "pv-recycler-minimum-timeout-nfs", + o.VolumeConfigFlags.PersistentVolumeRecyclerMinimumTimeoutNFS, "The minimum ActiveDeadlineSeconds to use for an NFS Recycler pod") + fs.IntVar(&o.VolumeConfigFlags.PersistentVolumeRecyclerIncrementTimeoutNFS, "pv-recycler-increment-timeout-nfs", + o.VolumeConfigFlags.PersistentVolumeRecyclerIncrementTimeoutNFS, "the increment of time added per Gi to ActiveDeadlineSeconds for an NFS scrubber pod") + fs.StringVar(&o.VolumeConfigFlags.PersistentVolumeRecyclerPodTemplateFilePathHostPath, "pv-recycler-pod-template-filepath-hostpath", + o.VolumeConfigFlags.PersistentVolumeRecyclerPodTemplateFilePathHostPath, + "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.IntVar(&o.VolumeConfigFlags.PersistentVolumeRecyclerMinimumTimeoutHostPath, "pv-recycler-minimum-timeout-hostpath", + o.VolumeConfigFlags.PersistentVolumeRecyclerMinimumTimeoutHostPath, + "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.IntVar(&o.VolumeConfigFlags.PersistentVolumeRecyclerIncrementTimeoutHostPath, "pv-recycler-timeout-increment-hostpath", + o.VolumeConfigFlags.PersistentVolumeRecyclerIncrementTimeoutHostPath, + "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.VolumeConfigFlags.EnableHostPathProvisioning, "enable-hostpath-provisioner", o.VolumeConfigFlags.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.") +} diff --git a/pkg/controller/podautoscaler/options/options.go b/pkg/controller/podautoscaler/options/options.go new file mode 100644 index 00000000000..94d745ef810 --- /dev/null +++ b/pkg/controller/podautoscaler/options/options.go @@ -0,0 +1,39 @@ +/* +Copyright 2016 The Kubernetes Authors All rights reserved. + +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 ( + "time" + + "github.com/spf13/pflag" +) + +type PodAutoscalerOptions struct { + HorizontalPodAutoscalerSyncPeriod time.Duration +} + +func NewPodAutoscalerOptions() PodAutoscalerOptions { + return PodAutoscalerOptions{ + HorizontalPodAutoscalerSyncPeriod: 30 * time.Second, + } +} + +func (o *PodAutoscalerOptions) AddFlags(fs *pflag.FlagSet) { + fs.DurationVar(&o.HorizontalPodAutoscalerSyncPeriod, "horizontal-pod-autoscaler-sync-period", o.HorizontalPodAutoscalerSyncPeriod, + "The period for syncing the number of pods in horizontal pod autoscaler.", + ) +} diff --git a/pkg/controller/replication/options/options.go b/pkg/controller/replication/options/options.go new file mode 100644 index 00000000000..ffe01f5d510 --- /dev/null +++ b/pkg/controller/replication/options/options.go @@ -0,0 +1,35 @@ +/* +Copyright 2016 The Kubernetes Authors All rights reserved. + +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" +) + +type ReplicationControllerOptions struct { + ConcurrentRCSyncs int +} + +func NewReplicationControllerOptions() ReplicationControllerOptions { + return ReplicationControllerOptions{ + ConcurrentRCSyncs: 5, + } +} + +func (o *ReplicationControllerOptions) AddFlags(fs *pflag.FlagSet) { + fs.IntVar(&o.ConcurrentRCSyncs, "concurrent_rc_syncs", o.ConcurrentRCSyncs, "The number of replication controllers that are allowed to sync concurrently. Larger number = more reponsive replica management, but more CPU (and network) load") +} diff --git a/pkg/controller/resourcequota/options/options.go b/pkg/controller/resourcequota/options/options.go new file mode 100644 index 00000000000..16c417402e7 --- /dev/null +++ b/pkg/controller/resourcequota/options/options.go @@ -0,0 +1,41 @@ +/* +Copyright 2016 The Kubernetes Authors All rights reserved. + +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 ( + "time" + + "github.com/spf13/pflag" +) + +type ResourceQuotaControllerOptions struct { + ConcurrentResourceQuotaSyncs int + ResourceQuotaSyncPeriod time.Duration +} + +func NewResourceQuotaControllerOptions() ResourceQuotaControllerOptions { + return ResourceQuotaControllerOptions{ + ConcurrentResourceQuotaSyncs: 5, + ResourceQuotaSyncPeriod: 5 * time.Minute, + } +} + +func (o *ResourceQuotaControllerOptions) AddFlags(fs *pflag.FlagSet) { + fs.IntVar(&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") + fs.DurationVar(&o.ResourceQuotaSyncPeriod, "resource-quota-sync-period", o.ResourceQuotaSyncPeriod, "The period for syncing quota usage status in the system") + +} diff --git a/pkg/controller/service/options/options.go b/pkg/controller/service/options/options.go new file mode 100644 index 00000000000..5bae0be124d --- /dev/null +++ b/pkg/controller/service/options/options.go @@ -0,0 +1,37 @@ +/* +Copyright 2016 The Kubernetes Authors All rights reserved. + +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 ( + "time" + + "github.com/spf13/pflag" +) + +type ServiceControllerOptions struct { + ServiceSyncPeriod time.Duration +} + +func NewServiceControllerOptions() ServiceControllerOptions { + return ServiceControllerOptions{ + ServiceSyncPeriod: 5 * time.Minute, + } +} + +func (o *ServiceControllerOptions) AddFlags(fs *pflag.FlagSet) { + fs.DurationVar(&o.ServiceSyncPeriod, "service-sync-period", o.ServiceSyncPeriod, "The period for syncing services with their external load balancers") +} diff --git a/pkg/controller/serviceaccount/options/options.go b/pkg/controller/serviceaccount/options/options.go new file mode 100644 index 00000000000..af868ad675e --- /dev/null +++ b/pkg/controller/serviceaccount/options/options.go @@ -0,0 +1,33 @@ +/* +Copyright 2016 The Kubernetes Authors All rights reserved. + +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" +) + +type ServiceAccountControllerOptions struct { + ServiceAccountKeyFile string +} + +func NewServiceAccountControllerOptions() ServiceAccountControllerOptions { + return ServiceAccountControllerOptions{} +} + +func (o *ServiceAccountControllerOptions) AddFlags(fs *pflag.FlagSet) { + fs.StringVar(&o.ServiceAccountKeyFile, "service-account-private-key-file", o.ServiceAccountKeyFile, "Filename containing a PEM-encoded private RSA key used to sign service account tokens.") +} diff --git a/plugin/cmd/kube-scheduler/app/options/options.go b/plugin/cmd/kube-scheduler/app/options/options.go index 9696fe03bd8..d3099a3080d 100644 --- a/plugin/cmd/kube-scheduler/app/options/options.go +++ b/plugin/cmd/kube-scheduler/app/options/options.go @@ -21,7 +21,6 @@ import ( "k8s.io/kubernetes/pkg/api" "k8s.io/kubernetes/pkg/apis/componentconfig" "k8s.io/kubernetes/pkg/apis/componentconfig/v1alpha1" - "k8s.io/kubernetes/pkg/client/leaderelection" "k8s.io/kubernetes/plugin/pkg/scheduler/factory" "github.com/spf13/pflag" @@ -66,5 +65,5 @@ func (s *SchedulerServer) AddFlags(fs *pflag.FlagSet) { fs.Float32Var(&s.KubeAPIQPS, "kube-api-qps", s.KubeAPIQPS, "QPS to use while talking with kubernetes apiserver") fs.IntVar(&s.KubeAPIBurst, "kube-api-burst", s.KubeAPIBurst, "Burst to use while talking with kubernetes apiserver") fs.StringVar(&s.SchedulerName, "scheduler-name", s.SchedulerName, "Name of the scheduler, used to select which pods will be processed by this scheduler, based on pod's annotation with key 'scheduler.alpha.kubernetes.io/name'") - leaderelection.BindFlags(&s.LeaderElection, fs) + s.LeaderElection.AddFlags(fs) }