Gendocs for docs/admin/kube-*

.generated_docs

 .generated_docs
 contrib/completions/bash/kubectl
+docs/admin/kube-apiserver.md
+docs/admin/kube-controller-manager.md
+docs/admin/kube-proxy.md
+docs/admin/kube-scheduler.md
+docs/admin/kubelet.md
 docs/man/man1/kubectl-annotate.1
 docs/man/man1/kubectl-api-versions.1
 docs/man/man1/kubectl-apply.1

cmd/genkubedocs/gen_kube_docs.go

+/*
+Copyright 2014 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 main
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/spf13/cobra"
+	"k8s.io/kubernetes/cmd/genutils"
+	apiservapp "k8s.io/kubernetes/cmd/kube-apiserver/app"
+	cmapp "k8s.io/kubernetes/cmd/kube-controller-manager/app"
+	proxyapp "k8s.io/kubernetes/cmd/kube-proxy/app"
+	klapp "k8s.io/kubernetes/cmd/kubelet/app"
+	schapp "k8s.io/kubernetes/plugin/cmd/kube-scheduler/app"
+)
+
+func main() {
+	// use os.Args instead of "flags" because "flags" will mess up the man pages!
+	path := ""
+	module := ""
+	if len(os.Args) == 3 {
+		path = os.Args[1]
+		module = os.Args[2]
+	} else {
+		fmt.Fprintf(os.Stderr, "usage: %s [output directory] [module] \n", os.Args[0])
+		os.Exit(1)
+	}
+
+	outDir, err := genutils.OutDir(path)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "failed to get output directory: %v\n", err)
+		os.Exit(1)
+	}
+
+	switch module {
+	case "kube-apiserver":
+		// generate docs for kube-apiserver
+		apiserver := apiservapp.NewAPIServerCommand()
+		cobra.GenMarkdownTree(apiserver, outDir)
+	case "kube-controller-manager":
+		// generate docs for kube-controller-manager
+		controllermanager := cmapp.NewControllerManagerCommand()
+		cobra.GenMarkdownTree(controllermanager, outDir)
+	case "kube-proxy":
+		// generate docs for kube-proxy
+		proxy := proxyapp.NewProxyCommand()
+		cobra.GenMarkdownTree(proxy, outDir)
+	case "kube-scheduler":
+		// generate docs for kube-scheduler
+		scheduler := schapp.NewSchedulerCommand()
+		cobra.GenMarkdownTree(scheduler, outDir)
+	case "kubelet":
+		// generate docs for kubelet
+		kubelet := klapp.NewKubeletCommand()
+		cobra.GenMarkdownTree(kubelet, outDir)
+	default:
+		fmt.Fprintf(os.Stderr, "Module %s is not supported", module)
+		os.Exit(1)
+	}
+}

cmd/kube-apiserver/app/server.go

@@ -51,6 +51,7 @@ import (
 
 	"github.com/coreos/go-etcd/etcd"
 	"github.com/golang/glog"
+	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
 )
 
@@ -148,6 +149,23 @@ func NewAPIServer() *APIServer {
 	return &s
 }
 
+// NewAPIServerCommand creates a *cobra.Command object with default parameters
+func NewAPIServerCommand() *cobra.Command {
+	s := NewAPIServer()
+	s.AddFlags(pflag.CommandLine)
+	cmd := &cobra.Command{
+		Use: "kube-apiserver",
+		Long: `The Kubernetes API server validates and configures data
+for the api objects which include pods, services, replicationcontrollers, and
+others. The API Server services REST operations and provides the frontend to the
+cluster's shared state through which all other components interact.`,
+		Run: func(cmd *cobra.Command, args []string) {
+		},
+	}
+
+	return cmd
+}
+
 // AddFlags adds flags for a specific APIServer to the specified FlagSet
 func (s *APIServer) AddFlags(fs *pflag.FlagSet) {
 	// Note: the weird ""+ in below lines seems to be the only way to get gofmt to

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

@@ -58,6 +58,7 @@ import (
 
 	"github.com/golang/glog"
 	"github.com/prometheus/client_golang/prometheus"
+	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
 )
 
@@ -137,6 +138,27 @@ func NewCMServer() *CMServer {
 	return &s
 }
 
+// NewControllerManagerCommand creates a *cobra.Command object with default parameters
+func NewControllerManagerCommand() *cobra.Command {
+	s := NewCMServer()
+	s.AddFlags(pflag.CommandLine)
+	cmd := &cobra.Command{
+		Use: "kube-controller-manager",
+		Long: `The Kubernetes controller manager is a daemon that embeds
+the core control loops shipped with Kubernetes. In applications of robotics and
+automation, a control loop is a non-terminating loop that regulates the state of
+the system. In Kubernetes, a controller is a control loop that watches the shared
+state of the cluster through the apiserver and makes changes attempting to move the
+current state towards the desired state. Examples of controllers that ship with
+Kubernetes today are the replication controller, endpoints controller, namespace
+controller, and serviceaccounts controller.`,
+		Run: func(cmd *cobra.Command, args []string) {
+		},
+	}
+
+	return cmd
+}
+
 // 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

cmd/kube-proxy/app/server.go

@@ -45,6 +45,7 @@ import (
 	"k8s.io/kubernetes/pkg/util/oom"
 
 	"github.com/golang/glog"
+	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
 )
 
@@ -142,6 +143,26 @@ func NewProxyServer(
 	}, nil
 }
 
+// NewProxyCommand creates a *cobra.Command object with default parameters
+func NewProxyCommand() *cobra.Command {
+	s := NewProxyConfig()
+	s.AddFlags(pflag.CommandLine)
+	cmd := &cobra.Command{
+		Use: "kube-proxy",
+		Long: `The Kubernetes network proxy runs on each node. This
+reflects services as defined in the Kubernetes API on each node and can do simple
+TCP,UDP stream forwarding or round robin TCP,UDP forwarding across a set of backends.
+Service cluster ips and ports are currently found through Docker-links-compatible
+environment variables specifying ports opened by the service proxy. There is an optional
+addon that provides cluster DNS for these cluster IPs. The user must create a service
+with the apiserver API to configure the proxy.`,
+		Run: func(cmd *cobra.Command, args []string) {
+		},
+	}
+
+	return cmd
+}
+
 // NewProxyServerDefault creates a new ProxyServer object with default parameters.
 func NewProxyServerDefault(config *ProxyServerConfig) (*ProxyServer, error) {
 	protocol := utiliptables.ProtocolIpv4

cmd/kubelet/app/server.go

@@ -61,6 +61,7 @@ import (
 	"k8s.io/kubernetes/pkg/volume"
 
 	"github.com/golang/glog"
+	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
 	"k8s.io/kubernetes/pkg/cloudprovider"
 )
@@ -219,6 +220,36 @@ func NewKubeletServer() *KubeletServer {
 	}
 }
 
+// NewKubeletCommand creates a *cobra.Command object with default parameters
+func NewKubeletCommand() *cobra.Command {
+	s := NewKubeletServer()
+	s.AddFlags(pflag.CommandLine)
+	cmd := &cobra.Command{
+		Use: "kubelet",
+		Long: `The kubelet is the primary "node agent" that runs on each
+node. The kubelet works in terms of a PodSpec. A PodSpec is a YAML or JSON object
+that describes a pod. The kubelet takes a set of PodSpecs that are provided through
+various mechanisms (primarily through the apiserver) and ensures that the containers
+described in those PodSpecs are running and healthy.
+
+Other than from an PodSpec from the apiserver, there are three ways that a container
+manifest can be provided to the Kubelet.
+
+File: Path passed as a flag on the command line. This file is rechecked every 20
+seconds (configurable with a flag).
+
+HTTP endpoint: HTTP endpoint passed as a parameter on the command line. This endpoint
+is checked every 20 seconds (also configurable with a flag).
+
+HTTP server: The kubelet can also listen for HTTP and respond to a simple API
+(underspec'd currently) to submit a new manifest.`,
+		Run: func(cmd *cobra.Command, args []string) {
+		},
+	}
+
+	return cmd
+}
+
 // AddFlags adds flags for a specific KubeletServer to the specified FlagSet
 func (s *KubeletServer) AddFlags(fs *pflag.FlagSet) {
 	fs.StringVar(&s.Config, "config", s.Config, "Path to the config file or directory of files")

docs/admin/kube-controller-manager.md

@@ -47,38 +47,55 @@ current state towards the desired state. Examples of controllers that ship with
 Kubernetes today are the replication controller, endpoints controller, namespace
 controller, and serviceaccounts controller.
 
+```
+kube-controller-manager
+```
 
 ### Options
 
 ```
-      --address=<nil>: The IP address to serve on (set to 0.0.0.0 for all interfaces)
-      --allocate-node-cidrs=false: Should CIDRs for Pods be allocated and set on the cloud provider.
+      --address=127.0.0.1: The IP address to serve on (set to 0.0.0.0 for all interfaces)
+      --allocate-node-cidrs[=false]: Should CIDRs for Pods be allocated and set on the cloud provider.
       --cloud-config="": The path to the cloud provider configuration file.  Empty string for no configuration file.
       --cloud-provider="": The provider for cloud services.  Empty string for no provider.
       --cluster-cidr=<nil>: CIDR Range for Pods in cluster.
-      --cluster-name="": The instance prefix for the cluster
-      --concurrent-endpoint-syncs=0: The number of endpoint syncing operations that will be done concurrently. Larger number = faster endpoint updating, but more CPU (and network) load
-      --concurrent-rc-syncs=0: The number of replication controllers that are allowed to sync concurrently. Larger number = more responsive replica management, but more CPU (and network) load
+      --cluster-name="kubernetes": The instance prefix for the cluster
+      --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_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.
-  -h, --help=false: help for kube-controller-manager
+      --deployment-controller-sync-period=30s: Period for syncing the deployments.
+      --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
+      --kube-api-qps=20: QPS to use while talking with kubernetes apiserver
       --kubeconfig="": Path to kubeconfig file with authorization and master location information.
+      --log-flush-frequency=5s: Maximum number of seconds between log flushes
       --master="": The address of the Kubernetes API server (overrides any value in kubeconfig)
-      --namespace-sync-period=0: The period for syncing namespace life-cycle updates
-      --node-monitor-grace-period=40s: Amount of time which we allow running Node to be unresponsive before marking it unhealthy. Must be N times more than kubelet's nodeStatusUpdateFrequency, where N means number of retries allowed for kubelet to post node status.
+      --min-resync-period=12h0m0s: The resync period in reflectors will be random between MinResyncPeriod and 2*MinResyncPeriod
+      --namespace-sync-period=5m0s: The period for syncing namespace life-cycle updates
+      --node-monitor-grace-period=40s: 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.
       --node-monitor-period=5s: The period for syncing NodeStatus in NodeController.
-      --node-startup-grace-period=1m0s: Amount of time which we allow starting Node to be unresponsive before marking it unhealthy.
-      --node-sync-period=0: 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.
-      --pod-eviction-timeout=0: The grace period for deleting pods on failed nodes.
-      --port=0: The port that the controller-manager's http service runs on
-      --profiling=true: Enable profiling via web interface host:port/debug/pprof/
-      --pvclaimbinder-sync-period=0: The period for syncing persistent volumes and persistent volume claims
-      --resource-quota-sync-period=0: The period for syncing quota usage status in the system
+      --node-startup-grace-period=1m0s: Amount of time which we allow starting Node to be unresponsive before marking it unhealty.
+      --node-sync-period=10s: 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.
+      --pod-eviction-timeout=5m0s: The grace period for deleting pods on failed nodes.
+      --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-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.
+      --pvclaimbinder-sync-period=10s: The period for syncing persistent volumes and persistent volume claims
+      --resource-quota-sync-period=10s: 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.
       --service-account-private-key-file="": Filename containing a PEM-encoded private RSA key used to sign service account tokens.
+      --service-sync-period=5m0s: The period for syncing services with their external load balancers
+      --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 at 2015-07-06 18:03:31.507732064 +0000 UTC
+###### Auto generated by spf13/cobra on 18-Oct-2015
 
 
 <!-- BEGIN MUNGE: GENERATED_ANALYTICS -->

docs/admin/kube-proxy.md

@@ -46,22 +46,35 @@ environment variables specifying ports opened by the service proxy. There is an
 addon that provides cluster DNS for these cluster IPs. The user must create a service
 with the apiserver API to configure the proxy.
 
+```
+kube-proxy
+```
 
 ### Options
 
 ```
-      --bind-address=<nil>: The IP address for the proxy server to serve on (set to 0.0.0.0 for all interfaces)
-      --healthz-bind-address=<nil>: The IP address for the health check server to serve on, defaulting to 127.0.0.1 (set to 0.0.0.0 for all interfaces)
-      --healthz-port=0: The port to bind the health check server. Use 0 to disable.
-  -h, --help=false: help for kube-proxy
+      --bind-address=0.0.0.0: The IP address for the proxy server to serve on (set to 0.0.0.0 for all interfaces)
+      --cleanup-iptables[=false]: If true cleanup iptables rules and exit.
+      --config-sync-period=15m0s: How often configuration from the apiserver is refreshed.  Must be greater than 0.
+      --google-json-key="": The Google Cloud Platform Service Account JSON Key to use for authentication.
+      --healthz-bind-address=127.0.0.1: The IP address for the health check server to serve on, defaulting to 127.0.0.1 (set to 0.0.0.0 for all interfaces)
+      --healthz-port=10249: The port to bind the health check server. Use 0 to disable.
+      --hostname-override="": If non-empty, will use this string as identification instead of the actual hostname.
+      --iptables-sync-period=30s: How often iptables rules are refreshed (e.g. '5s', '1m', '2h22m').  Must be greater than 0.
+      --kube-api-burst=10: Burst to use while talking with kubernetes apiserver
+      --kube-api-qps=5: QPS to use while talking with kubernetes apiserver
       --kubeconfig="": Path to kubeconfig file with authorization information (the master location is set by the master flag).
+      --log-flush-frequency=5s: Maximum number of seconds between log flushes
+      --masquerade-all[=false]: If using the pure iptables proxy, SNAT everything
       --master="": The address of the Kubernetes API server (overrides any value in kubeconfig)
-      --oom-score-adj=0: The oom-score-adj value for kube-proxy process. Values must be within the range [-1000, 1000]
+      --oom-score-adj=-999: The oom-score-adj value for kube-proxy process. Values must be within the range [-1000, 1000]
+      --proxy-mode="": Which proxy mode to use: 'userspace' (older, stable) or 'iptables' (experimental). If blank, look at the Node object on the Kubernetes API and respect the 'net.experimental.kubernetes.io/proxy-mode' annotation if provided.  Otherwise use the best-available proxy (currently userspace, but may change in future versions).  If the iptables proxy is selected, regardless of how, but the system's kernel or iptables versions are insufficient, this always falls back to the userspace proxy.
       --proxy-port-range=: Range of host ports (beginPort-endPort, inclusive) that may be consumed in order to proxy service traffic. If unspecified (0-0) then ports will be randomly chosen.
-      --resource-container="": Absolute name of the resource-only container to create and run the Kube-proxy in (Default: /kube-proxy).
+      --resource-container="/kube-proxy": Absolute name of the resource-only container to create and run the Kube-proxy in (Default: /kube-proxy).
+      --udp-timeout=250ms: How long an idle UDP connection will be kept open (e.g. '250ms', '2s').  Must be greater than 0. Only applicable for proxy-mode=userspace
 ```
 
-###### Auto generated by spf13/cobra at 2015-07-06 18:03:37.657112759 +0000 UTC
+###### Auto generated by spf13/cobra on 23-Oct-2015
 
 
 <!-- BEGIN MUNGE: GENERATED_ANALYTICS -->

docs/admin/kube-scheduler.md

@@ -46,21 +46,29 @@ constraints, affinity and anti-affinity specifications, data locality, inter-wor
 interference, deadlines, and so on. Workload-specific requirements will be exposed
 through the API as necessary.
 
+```
+kube-scheduler
+```
 
 ### Options
 
 ```
-      --address=<nil>: The IP address to serve on (set to 0.0.0.0 for all interfaces)
-      --algorithm-provider="": The scheduling algorithm provider to use, one of: DefaultProvider
-  -h, --help=false: help for kube-scheduler
+      --address=127.0.0.1: The IP address to serve on (set to 0.0.0.0 for all interfaces)
+      --algorithm-provider="DefaultProvider": The scheduling algorithm provider to use, one of: DefaultProvider
+      --bind-pods-burst=100: Number of bindings per second scheduler is allowed to make during bursts
+      --bind-pods-qps=50: Number of bindings per second scheduler is allowed to continuously make
+      --google-json-key="": The Google Cloud Platform Service Account JSON Key to use for authentication.
+      --kube-api-burst=100: Burst to use while talking with kubernetes apiserver
+      --kube-api-qps=50: QPS to use while talking with kubernetes apiserver
       --kubeconfig="": Path to kubeconfig file with authorization and master location information.
+      --log-flush-frequency=5s: Maximum number of seconds between log flushes
       --master="": The address of the Kubernetes API server (overrides any value in kubeconfig)
       --policy-config-file="": File with scheduler policy configuration
-      --port=0: The port that the scheduler's http service runs on
-      --profiling=true: Enable profiling via web interface host:port/debug/pprof/
+      --port=10251: The port that the scheduler's http service runs on
+      --profiling[=true]: Enable profiling via web interface host:port/debug/pprof/
 ```
 
-###### Auto generated by spf13/cobra at 2015-07-06 18:03:39.24859096 +0000 UTC
+###### Auto generated by spf13/cobra on 13-Oct-2015
 
 
 <!-- BEGIN MUNGE: GENERATED_ANALYTICS -->

hack/after-build/verify-generated-docs.sh

@@ -25,6 +25,7 @@ kube::golang::setup_env
 
 # Find binary
 gendocs=$(kube::util::find-binary "gendocs")
+genkubedocs=$(kube::util::find-binary "genkubedocs")
 genman=$(kube::util::find-binary "genman")
 genbashcomp=$(kube::util::find-binary "genbashcomp")
 mungedocs=$(kube::util::find-binary "mungedocs")

hack/lib/golang.sh

@@ -64,6 +64,7 @@ kube::golang::test_targets() {
   local targets=(
     cmd/integration
     cmd/gendocs
+    cmd/genkubedocs
     cmd/genman
     cmd/mungedocs
     cmd/genbashcomp

hack/lib/util.sh

@@ -188,11 +188,18 @@ kube::util::gen-docs() {
 
   # Find binary
   gendocs=$(kube::util::find-binary "gendocs")
+  genkubedocs=$(kube::util::find-binary "genkubedocs")
   genman=$(kube::util::find-binary "genman")
   genbashcomp=$(kube::util::find-binary "genbashcomp")
 
   mkdir -p "${dest}/docs/user-guide/kubectl/"
   "${gendocs}" "${dest}/docs/user-guide/kubectl/"
+  mkdir -p "${dest}/docs/admin/"
+  "${genkubedocs}" "${dest}/docs/admin/" "kube-apiserver"
+  "${genkubedocs}" "${dest}/docs/admin/" "kube-controller-manager"
+  "${genkubedocs}" "${dest}/docs/admin/" "kube-proxy"
+  "${genkubedocs}" "${dest}/docs/admin/" "kube-scheduler"
+  "${genkubedocs}" "${dest}/docs/admin/" "kubelet"
   mkdir -p "${dest}/docs/man/man1/"
   "${genman}" "${dest}/docs/man/man1/"
   mkdir -p "${dest}/contrib/completions/bash/"

hack/update-generated-docs.sh

@@ -23,7 +23,7 @@ source "${KUBE_ROOT}/hack/lib/init.sh"
 
 kube::golang::setup_env
 
-"${KUBE_ROOT}/hack/build-go.sh" cmd/gendocs cmd/genman cmd/genbashcomp cmd/mungedocs
+"${KUBE_ROOT}/hack/build-go.sh" cmd/gendocs cmd/genkubedocs cmd/genman cmd/genbashcomp cmd/mungedocs
 
 "${KUBE_ROOT}/hack/after-build/update-generated-docs.sh" "$@"
 

hack/verify-generated-docs.sh

@@ -23,7 +23,7 @@ source "${KUBE_ROOT}/hack/lib/init.sh"
 
 kube::golang::setup_env
 
-"${KUBE_ROOT}/hack/build-go.sh" cmd/gendocs cmd/genman cmd/genbashcomp cmd/mungedocs
+"${KUBE_ROOT}/hack/build-go.sh" cmd/gendocs cmd/genkubedocs cmd/genman cmd/genbashcomp cmd/mungedocs
 
 "${KUBE_ROOT}/hack/after-build/verify-generated-docs.sh" "$@"
 

pkg/admission/plugins.go

@@ -19,6 +19,7 @@ package admission
 import (
 	"io"
 	"os"
+	"sort"
 	"sync"
 
 	"github.com/golang/glog"
@@ -45,6 +46,7 @@ func GetPlugins() []string {
 	for k := range plugins {
 		keys = append(keys, k)
 	}
+	sort.Strings(keys)
 	return keys
 }
 

plugin/cmd/kube-scheduler/app/server.go

@@ -42,6 +42,7 @@ import (
 
 	"github.com/golang/glog"
 	"github.com/prometheus/client_golang/prometheus"
+	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
 )
 
@@ -74,6 +75,26 @@ func NewSchedulerServer() *SchedulerServer {
 	return &s
 }
 
+// NewSchedulerCommand creates a *cobra.Command object with default parameters
+func NewSchedulerCommand() *cobra.Command {
+	s := NewSchedulerServer()
+	s.AddFlags(pflag.CommandLine)
+	cmd := &cobra.Command{
+		Use: "kube-scheduler",
+		Long: `The Kubernetes scheduler is a policy-rich, topology-aware,
+workload-specific function that significantly impacts availability, performance,
+and capacity. The scheduler needs to take into account individual and collective
+resource requirements, quality of service requirements, hardware/software/policy
+constraints, affinity and anti-affinity specifications, data locality, inter-workload
+interference, deadlines, and so on. Workload-specific requirements will be exposed
+through the API as necessary.`,
+		Run: func(cmd *cobra.Command, args []string) {
+		},
+	}
+
+	return cmd
+}
+
 // AddFlags adds flags for a specific SchedulerServer to the specified FlagSet
 func (s *SchedulerServer) AddFlags(fs *pflag.FlagSet) {
 	fs.IntVar(&s.Port, "port", s.Port, "The port that the scheduler's http service runs on")