switch hyper to cobra

cmd/hyperkube/BUILD

@@ -4,7 +4,6 @@ load(
     "@io_bazel_rules_go//go:def.bzl",
     "go_binary",
     "go_library",
-    "go_test",
 )
 load("//pkg/version:def.bzl", "version_x_defs")
 
@@ -15,54 +14,22 @@ go_binary(
     x_defs = version_x_defs(),
 )
 
-go_test(
-    name = "go_default_test",
-    srcs = ["hyperkube_test.go"],
-    embed = [":go_default_library"],
-    importpath = "k8s.io/kubernetes/cmd/hyperkube",
-    deps = [
-        "//vendor/github.com/spf13/cobra:go_default_library",
-        "//vendor/github.com/stretchr/testify/assert:go_default_library",
-        "//vendor/k8s.io/apimachinery/pkg/util/wait:go_default_library",
-    ],
-)
-
 go_library(
     name = "go_default_library",
-    srcs = [
-        "cloud-controller-manager.go",
-        "hyperkube.go",
-        "kube-apiserver.go",
-        "kube-controller-manager.go",
-        "kube-proxy.go",
-        "kube-scheduler.go",
-        "kubectl.go",
-        "kubelet.go",
-        "main.go",
-        "server.go",
-    ],
+    srcs = ["main.go"],
     importpath = "k8s.io/kubernetes/cmd/hyperkube",
     deps = [
         "//cmd/cloud-controller-manager/app:go_default_library",
-        "//cmd/cloud-controller-manager/app/options:go_default_library",
         "//cmd/kube-apiserver/app:go_default_library",
-        "//cmd/kube-apiserver/app/options:go_default_library",
         "//cmd/kube-controller-manager/app:go_default_library",
-        "//cmd/kube-controller-manager/app/options:go_default_library",
         "//cmd/kube-proxy/app:go_default_library",
         "//cmd/kube-scheduler/app:go_default_library",
         "//cmd/kubelet/app:go_default_library",
-        "//cmd/kubelet/app/options:go_default_library",
         "//pkg/client/metrics/prometheus:go_default_library",
         "//pkg/kubectl/cmd:go_default_library",
-        "//pkg/kubectl/cmd/util:go_default_library",
-        "//pkg/util/template:go_default_library",
         "//pkg/version/prometheus:go_default_library",
-        "//pkg/version/verflag:go_default_library",
+        "//vendor/github.com/spf13/cobra:go_default_library",
         "//vendor/github.com/spf13/pflag:go_default_library",
-        "//vendor/k8s.io/apimachinery/pkg/util/wait:go_default_library",
-        "//vendor/k8s.io/apiserver/pkg/server:go_default_library",
-        "//vendor/k8s.io/apiserver/pkg/server/healthz:go_default_library",
         "//vendor/k8s.io/apiserver/pkg/util/flag:go_default_library",
         "//vendor/k8s.io/apiserver/pkg/util/logs:go_default_library",
     ],

cmd/hyperkube/cloud-controller-manager.go

-/*
-Copyright 2017 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package main
-
-import (
-	"k8s.io/kubernetes/cmd/cloud-controller-manager/app"
-	"k8s.io/kubernetes/cmd/cloud-controller-manager/app/options"
-)
-
-// NewCloudControllerManager creates a new hyperkube Server object that includes the
-// description and flags.
-func NewCloudControllerManager() *Server {
-	s := options.NewCloudControllerManagerServer()
-
-	hks := Server{
-		name:        "cloud-controller-manager",
-		SimpleUsage: "cloud-controller-manager",
-		Long:        "A server that acts as an external cloud provider.",
-		Run: func(_ *Server, args []string, stopCh <-chan struct{}) error {
-			return app.Run(s)
-		},
-	}
-	s.AddFlags(hks.Flags())
-	return &hks
-}

cmd/hyperkube/hyperkube.go

-/*
-Copyright 2017 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package main
-
-import (
-	"errors"
-	"flag"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"os"
-	"path"
-
-	"github.com/spf13/pflag"
-
-	"k8s.io/apimachinery/pkg/util/wait"
-	"k8s.io/apiserver/pkg/server"
-	utilflag "k8s.io/apiserver/pkg/util/flag"
-	"k8s.io/apiserver/pkg/util/logs"
-	utiltemplate "k8s.io/kubernetes/pkg/util/template"
-	"k8s.io/kubernetes/pkg/version/verflag"
-)
-
-// HyperKube represents a single binary that can morph/manage into multiple
-// servers.
-type HyperKube struct {
-	Name string // The executable name, used for help and soft-link invocation
-	Long string // A long description of the binary.  It will be world wrapped before output.
-
-	servers             []Server
-	alphaServers        []Server
-	baseFlags           *pflag.FlagSet
-	out                 io.Writer
-	helpFlagVal         bool
-	makeSymlinksFlagVal bool
-}
-
-// AddServer adds a server to the HyperKube object.
-func (hk *HyperKube) AddServer(s *Server) {
-	hk.servers = append(hk.servers, *s)
-	hk.servers[len(hk.servers)-1].hk = hk
-}
-
-// AddServer adds an alpha server to the HyperKube object.
-func (hk *HyperKube) AddAlphaServer(s *Server) {
-	hk.alphaServers = append(hk.alphaServers, *s)
-	hk.alphaServers[len(hk.alphaServers)-1].hk = hk
-}
-
-// FindServer will find a specific server named name.
-func (hk *HyperKube) FindServer(name string) (*Server, error) {
-	return findServer(name, hk.servers)
-}
-
-// FindServer will find a specific alpha server named name.
-func (hk *HyperKube) FindAlphaServer(name string) (*Server, error) {
-	return findServer(name, hk.alphaServers)
-}
-
-func findServer(name string, servers []Server) (*Server, error) {
-	for _, s := range servers {
-		if s.Name() == name || s.AlternativeName == name {
-			return &s, nil
-		}
-	}
-	return nil, fmt.Errorf("Server not found: %s", name)
-}
-
-// Servers returns a list of all of the registered servers
-func (hk *HyperKube) Servers() []Server {
-	return hk.servers
-}
-
-// Flags returns a flagset for "global" flags.
-func (hk *HyperKube) Flags() *pflag.FlagSet {
-	if hk.baseFlags == nil {
-		hk.baseFlags = pflag.NewFlagSet(hk.Name, pflag.ContinueOnError)
-		hk.baseFlags.SetOutput(ioutil.Discard)
-		hk.baseFlags.SetNormalizeFunc(utilflag.WordSepNormalizeFunc)
-		hk.baseFlags.BoolVarP(&hk.helpFlagVal, "help", "h", false, "help for "+hk.Name)
-		hk.baseFlags.BoolVar(&hk.makeSymlinksFlagVal, "make-symlinks", false, "create a symlink for each server in current directory")
-		hk.baseFlags.MarkHidden("make-symlinks") // hide this flag from appearing in servers' usage output
-
-		// These will add all of the "global" flags (defined with both the
-		// flag and pflag packages) to the new flag set we have.
-		hk.baseFlags.AddGoFlagSet(flag.CommandLine)
-		hk.baseFlags.AddFlagSet(pflag.CommandLine)
-
-	}
-	return hk.baseFlags
-}
-
-// Out returns the io.Writer that is used for all usage/error information
-func (hk *HyperKube) Out() io.Writer {
-	if hk.out == nil {
-		hk.out = os.Stderr
-	}
-	return hk.out
-}
-
-// SetOut sets the output writer for all usage/error information
-func (hk *HyperKube) SetOut(w io.Writer) {
-	hk.out = w
-}
-
-// Print is a convenience method to Print to the defined output
-func (hk *HyperKube) Print(i ...interface{}) {
-	fmt.Fprint(hk.Out(), i...)
-}
-
-// Println is a convenience method to Println to the defined output
-func (hk *HyperKube) Println(i ...interface{}) {
-	fmt.Fprintln(hk.Out(), i...)
-}
-
-// Printf is a convenience method to Printf to the defined output
-func (hk *HyperKube) Printf(format string, i ...interface{}) {
-	fmt.Fprintf(hk.Out(), format, i...)
-}
-
-// Run the server.  This will pick the appropriate server and run it.
-func (hk *HyperKube) Run(args []string, stopCh <-chan struct{}) error {
-	// If we are called directly, parse all flags up to the first real
-	// argument.  That should be the server to run.
-	command := args[0]
-	serverName := path.Base(command)
-	args = args[1:]
-	if serverName == hk.Name {
-
-		baseFlags := hk.Flags()
-		baseFlags.SetInterspersed(false) // Only parse flags up to the next real command
-		err := baseFlags.Parse(args)
-		if err != nil || hk.helpFlagVal {
-			if err != nil {
-				hk.Println("Error:", err)
-			}
-			hk.Usage()
-			return err
-		}
-
-		if hk.makeSymlinksFlagVal {
-			return hk.MakeSymlinks(command)
-		}
-
-		verflag.PrintAndExitIfRequested()
-
-		args = baseFlags.Args()
-		if len(args) > 0 && len(args[0]) > 0 {
-			serverName = args[0]
-			args = args[1:]
-		} else {
-			err = errors.New("no server specified")
-			hk.Printf("Error: %v\n\n", err)
-			hk.Usage()
-			return err
-		}
-	}
-
-	var s *Server
-	var err error
-	if serverName == "alpha" {
-		if len(args) > 0 && len(args[0]) > 0 {
-			serverName = args[0]
-			args = args[1:]
-			hk.Printf("Warning: alpha command syntax is unstable!\n\n")
-		} else {
-			err = errors.New("no alpha server specified")
-			hk.Printf("Error: %v\n\n", err)
-			hk.Usage()
-			return err
-		}
-		s, err = hk.FindAlphaServer(serverName)
-	} else {
-		s, err = hk.FindServer(serverName)
-	}
-	if err != nil {
-		hk.Printf("Error: %v\n\n", err)
-		hk.Usage()
-		return err
-	}
-
-	s.Flags().AddFlagSet(hk.Flags())
-	err = s.Flags().Parse(args)
-	if err != nil || hk.helpFlagVal {
-		if err != nil {
-			hk.Printf("Error: %v\n\n", err)
-		}
-		s.Usage()
-		return err
-	}
-
-	verflag.PrintAndExitIfRequested()
-
-	logs.InitLogs()
-	defer logs.FlushLogs()
-
-	if !s.RespectsStopCh {
-		// For commands that do not respect the stopCh, we run them in a go
-		// routine and leave them running when stopCh is closed.
-		errCh := make(chan error)
-		go func() {
-			errCh <- s.Run(s, s.Flags().Args(), wait.NeverStop)
-		}()
-		select {
-		case <-stopCh:
-			return errors.New("interrupted") // This error text is ignored.
-		case err = <-errCh:
-			// fall-through
-		}
-	} else {
-		err = s.Run(s, s.Flags().Args(), stopCh)
-	}
-	if err != nil {
-		hk.Println("Error:", err)
-	}
-
-	return err
-}
-
-// RunToExit will run the hyperkube and then call os.Exit with an appropriate exit code.
-func (hk *HyperKube) RunToExit(args []string) {
-	stopCh := server.SetupSignalHandler()
-	if err := hk.Run(args, stopCh); err != nil {
-		os.Exit(1)
-	}
-}
-
-// Usage will write out a summary for all servers that this binary supports.
-func (hk *HyperKube) Usage() {
-	tt := `{{if .Long}}{{.Long | trim | wrap ""}}
-{{end}}Usage
-
-  {{.Name}} <server> [flags]
-
-Servers
-{{range .Servers}}
-  {{.Name}}
-{{.Long | trim | wrap "    "}}{{end}}
-Call '{{.Name}} --make-symlinks' to create symlinks for each server in the local directory.
-Call '{{.Name}} <server> --help' for help on a specific server.
-`
-	utiltemplate.ExecuteTemplate(hk.Out(), tt, hk)
-}
-
-// MakeSymlinks will create a symlink for each registered hyperkube server in the local directory.
-func (hk *HyperKube) MakeSymlinks(command string) error {
-	wd, err := os.Getwd()
-	if err != nil {
-		return err
-	}
-
-	var errs bool
-	for _, s := range hk.servers {
-		link := path.Join(wd, s.Name())
-
-		err := os.Symlink(command, link)
-		if err != nil {
-			errs = true
-			hk.Println(err)
-		}
-	}
-
-	if errs {
-		return errors.New("Error creating one or more symlinks.")
-	}
-	return nil
-}

cmd/hyperkube/kube-apiserver.go

-/*
-Copyright 2015 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package main
-
-import (
-	"k8s.io/kubernetes/cmd/kube-apiserver/app"
-	"k8s.io/kubernetes/cmd/kube-apiserver/app/options"
-)
-
-// NewKubeAPIServer creates a new hyperkube Server object that includes the
-// description and flags.
-func NewKubeAPIServer() *Server {
-	s := options.NewServerRunOptions()
-
-	hks := Server{
-		name:            "apiserver",
-		AlternativeName: "kube-apiserver",
-		SimpleUsage:     "apiserver",
-		Long:            "The main API entrypoint and interface to the storage system.  The API server is also the focal point for all authorization decisions.",
-		Run: func(_ *Server, args []string, stopCh <-chan struct{}) error {
-			return app.Run(s, stopCh)
-		},
-		RespectsStopCh: true,
-	}
-	s.AddFlags(hks.Flags())
-	return &hks
-}

cmd/hyperkube/kube-controller-manager.go

-/*
-Copyright 2015 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package main
-
-import (
-	"k8s.io/kubernetes/cmd/kube-controller-manager/app"
-	"k8s.io/kubernetes/cmd/kube-controller-manager/app/options"
-)
-
-// NewKubeControllerManager creates a new hyperkube Server object that includes the
-// description and flags.
-func NewKubeControllerManager() *Server {
-	s := options.NewCMServer()
-
-	hks := Server{
-		name:            "controller-manager",
-		AlternativeName: "kube-controller-manager",
-		SimpleUsage:     "controller-manager",
-		Long:            "A server that runs a set of active components. This includes replication controllers, service endpoints and nodes.",
-		Run: func(_ *Server, args []string, stopCh <-chan struct{}) error {
-			return app.Run(s)
-		},
-	}
-	s.AddFlags(hks.Flags(), app.KnownControllers(), app.ControllersDisabledByDefault.List())
-	return &hks
-}

cmd/hyperkube/kube-proxy.go

-/*
-Copyright 2015 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package main
-
-import (
-	"flag"
-
-	"k8s.io/apiserver/pkg/server/healthz"
-	"k8s.io/kubernetes/cmd/kube-proxy/app"
-)
-
-// NewKubeProxy creates a new hyperkube Server object that includes the
-// description and flags.
-func NewKubeProxy() *Server {
-	healthz.DefaultHealthz()
-
-	command := app.NewProxyCommand()
-
-	hks := Server{
-		name:            "proxy",
-		AlternativeName: "kube-proxy",
-		SimpleUsage:     "proxy",
-		Long:            command.Long,
-	}
-
-	serverFlags := hks.Flags()
-	serverFlags.AddFlagSet(command.Flags())
-
-	// FIXME this is here because hyperkube does its own flag parsing, and we need
-	// the command to know about the go flag set. Remove this once hyperkube is
-	// refactored to use cobra throughout.
-	command.Flags().AddGoFlagSet(flag.CommandLine)
-
-	hks.Run = func(_ *Server, args []string, stopCh <-chan struct{}) error {
-		command.SetArgs(args)
-		return command.Execute()
-	}
-
-	return &hks
-}

cmd/hyperkube/kube-scheduler.go

-/*
-Copyright 2015 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package main
-
-import (
-	"flag"
-
-	"k8s.io/apiserver/pkg/server/healthz"
-	"k8s.io/kubernetes/cmd/kube-scheduler/app"
-)
-
-// NewScheduler creates a new hyperkube Server object that includes the
-// description and flags.
-func NewScheduler() *Server {
-	healthz.DefaultHealthz()
-
-	command := app.NewSchedulerCommand()
-
-	hks := Server{
-		name:            "scheduler",
-		AlternativeName: "kube-scheduler",
-		SimpleUsage:     "scheduler",
-		Long:            command.Long,
-	}
-
-	serverFlags := hks.Flags()
-	serverFlags.AddFlagSet(command.Flags())
-
-	// FIXME this is here because hyperkube does its own flag parsing, and we need
-	// the command to know about the go flag set. Remove this once hyperkube is
-	// refactored to use cobra throughout.
-	command.Flags().AddGoFlagSet(flag.CommandLine)
-
-	hks.Run = func(_ *Server, args []string, stopCh <-chan struct{}) error {
-		command.SetArgs(args)
-		return command.Execute()
-	}
-
-	return &hks
-}

cmd/hyperkube/kubectl.go

-/*
-Copyright 2015 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package main
-
-import (
-	"os"
-
-	"k8s.io/kubernetes/pkg/kubectl/cmd"
-	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
-)
-
-// Create a Server that implements the kubectl command
-func NewKubectlServer() *Server {
-	cmd := cmd.NewKubectlCommand(cmdutil.NewFactory(nil), os.Stdin, os.Stdout, os.Stderr)
-	localFlags := cmd.LocalFlags()
-	localFlags.SetInterspersed(false)
-
-	return &Server{
-		name:        "kubectl",
-		SimpleUsage: "Kubernetes command line client",
-		Long:        "Kubernetes command line client",
-		Run: func(s *Server, args []string, stopCh <-chan struct{}) error {
-			cmd.SetArgs(args)
-			return cmd.Execute()
-		},
-		flags: localFlags,
-	}
-}

cmd/hyperkube/kubelet.go

-/*
-Copyright 2015 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package main
-
-import (
-	"k8s.io/kubernetes/cmd/kubelet/app"
-	"k8s.io/kubernetes/cmd/kubelet/app/options"
-)
-
-// NewKubelet creates a new hyperkube Server object that includes the
-// description and flags.
-func NewKubelet() (*Server, error) {
-	s, err := options.NewKubeletServer()
-	if err != nil {
-		return nil, err
-	}
-
-	hks := Server{
-		name:        "kubelet",
-		SimpleUsage: "kubelet",
-		Long: `The kubelet binary is responsible for maintaining a set of containers on a
-		particular node. It syncs data from a variety of sources including a
-		Kubernetes API server, an etcd cluster, HTTP endpoint or local file. It then
-		queries Docker to see what is currently running.  It synchronizes the
-		configuration data, with the running set of containers by starting or stopping
-		Docker containers.`,
-		Run: func(_ *Server, _ []string, stopCh <-chan struct{}) error {
-			if s.ExperimentalDockershim {
-				return app.RunDockershim(&s.KubeletFlags, &s.KubeletConfiguration)
-			}
-			return app.Run(s, nil)
-		},
-	}
-	s.AddFlags(hks.Flags())
-	return &hks, nil
-}

cmd/hyperkube/main.go

@@ -20,33 +20,156 @@ limitations under the License.
 package main
 
 import (
+	"errors"
+	goflag "flag"
 	"fmt"
+	"math/rand"
 	"os"
+	"path"
+	"path/filepath"
+	"time"
 
+	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
+
+	utilflag "k8s.io/apiserver/pkg/util/flag"
+	"k8s.io/apiserver/pkg/util/logs"
+	cloudcontrollermanager "k8s.io/kubernetes/cmd/cloud-controller-manager/app"
+	kubeapiserver "k8s.io/kubernetes/cmd/kube-apiserver/app"
+	kubecontrollermanager "k8s.io/kubernetes/cmd/kube-controller-manager/app"
+	kubeproxy "k8s.io/kubernetes/cmd/kube-proxy/app"
+	kubescheduler "k8s.io/kubernetes/cmd/kube-scheduler/app"
+	kubelet "k8s.io/kubernetes/cmd/kubelet/app"
 	_ "k8s.io/kubernetes/pkg/client/metrics/prometheus" // for client metric registration
-	_ "k8s.io/kubernetes/pkg/version/prometheus"        // for version metric registration
+	kubectl "k8s.io/kubernetes/pkg/kubectl/cmd"
+	_ "k8s.io/kubernetes/pkg/version/prometheus" // for version metric registration
 )
 
 func main() {
-	hk := HyperKube{
-		Name: "hyperkube",
-		Long: "This is an all-in-one binary that can run any of the various Kubernetes servers.",
-	}
+	rand.Seed(time.Now().UTC().UnixNano())
+
+	hyperkubeCommand, allCommandFns := NewHyperKubeCommand()
+
+	// TODO: once we switch everything over to Cobra commands, we can go back to calling
+	// utilflag.InitFlags() (by removing its pflag.Parse() call). For now, we have to set the
+	// normalize func and add the go flag set by hand.
+	pflag.CommandLine.SetNormalizeFunc(utilflag.WordSepNormalizeFunc)
+	pflag.CommandLine.AddGoFlagSet(goflag.CommandLine)
+	// utilflag.InitFlags()
+	logs.InitLogs()
+	defer logs.FlushLogs()
 
-	hk.AddServer(NewKubectlServer())
-	hk.AddServer(NewKubeAPIServer())
-	hk.AddServer(NewKubeControllerManager())
-	hk.AddServer(NewScheduler())
-	if kubelet, err := NewKubelet(); err != nil {
-		fmt.Fprintf(os.Stderr, "error: %v\n", err)
+	basename := filepath.Base(os.Args[0])
+	if err := commandFor(basename, hyperkubeCommand, allCommandFns).Execute(); err != nil {
+		fmt.Fprintf(os.Stderr, "%v\n", err)
 		os.Exit(1)
-	} else {
-		hk.AddServer(kubelet)
 	}
-	hk.AddServer(NewKubeProxy())
+}
+
+func commandFor(basename string, defaultCommand *cobra.Command, commands []func() *cobra.Command) *cobra.Command {
+	for _, commandFn := range commands {
+		command := commandFn()
+		if command.Name() == basename {
+			return command
+		}
+		for _, alias := range command.Aliases {
+			if alias == basename {
+				return command
+			}
+		}
+	}
+
+	return defaultCommand
+}
+
+// NewCmdRequestProject implement the OpenShift cli RequestProject command.
+func NewHyperKubeCommand() (*cobra.Command, []func() *cobra.Command) {
+	// these have to be functions since the command is polymorphic.  Cobra wants you to be  top level
+	// command to get executed
+	apiserver := func() *cobra.Command {
+		ret := kubeapiserver.NewAPIServerCommand()
+		// add back some unfortunate aliases that should be removed
+		ret.Aliases = []string{"apiserver"}
+		return ret
+	}
+	controller := func() *cobra.Command {
+		ret := kubecontrollermanager.NewControllerManagerCommand()
+		// add back some unfortunate aliases that should be removed
+		ret.Aliases = []string{"controller-manager"}
+		return ret
+	}
+	proxy := func() *cobra.Command {
+		ret := kubeproxy.NewProxyCommand()
+		// add back some unfortunate aliases that should be removed
+		ret.Aliases = []string{"proxy"}
+		return ret
+	}
+	scheduler := func() *cobra.Command {
+		ret := kubescheduler.NewSchedulerCommand()
+		// add back some unfortunate aliases that should be removed
+		ret.Aliases = []string{"scheduler"}
+		return ret
+	}
+	kubectlCmd := func() *cobra.Command { return kubectl.NewDefaultKubectlCommand() }
+	kubelet := func() *cobra.Command { return kubelet.NewKubeletCommand() }
+	cloudController := func() *cobra.Command { return cloudcontrollermanager.NewCloudControllerManagerCommand() }
 
-	// Alpha servers
-	hk.AddAlphaServer(NewCloudControllerManager())
+	commandFns := []func() *cobra.Command{
+		apiserver,
+		controller,
+		proxy,
+		scheduler,
+		kubectlCmd,
+		kubelet,
+		cloudController,
+	}
+
+	makeSymlinksFlag := false
+	cmd := &cobra.Command{
+		Use:   "hyperkube",
+		Short: "Request a new project",
+		Run: func(cmd *cobra.Command, args []string) {
+			if len(args) != 0 || !makeSymlinksFlag {
+				cmd.Help()
+				os.Exit(1)
+			}
+
+			if err := makeSymlinks(os.Args[0], commandFns); err != nil {
+				fmt.Fprintf(os.Stderr, "%v\n", err.Error())
+			}
+		},
+	}
+	cmd.Flags().BoolVar(&makeSymlinksFlag, "make-symlinks", makeSymlinksFlag, "create a symlink for each server in current directory")
+	cmd.Flags().MarkHidden("make-symlinks") // hide this flag from appearing in servers' usage output
+
+	for i := range commandFns {
+		cmd.AddCommand(commandFns[i]())
+	}
+
+	return cmd, commandFns
+}
+
+// makeSymlinks will create a symlink for each command in the local directory.
+func makeSymlinks(targetName string, commandFns []func() *cobra.Command) error {
+	wd, err := os.Getwd()
+	if err != nil {
+		return err
+	}
+
+	var errs bool
+	for _, commandFn := range commandFns {
+		command := commandFn()
+		link := path.Join(wd, command.Name())
 
-	hk.RunToExit(os.Args)
+		err := os.Symlink(targetName, link)
+		if err != nil {
+			errs = true
+			fmt.Println(err)
+		}
+	}
+
+	if errs {
+		return errors.New("Error creating one or more symlinks.")
+	}
+	return nil
 }

cmd/hyperkube/server.go

-/*
-Copyright 2014 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package main
-
-import (
-	"io/ioutil"
-	"strings"
-
-	"k8s.io/apiserver/pkg/util/flag"
-	utiltemplate "k8s.io/kubernetes/pkg/util/template"
-
-	"github.com/spf13/pflag"
-)
-
-type serverRunFunc func(s *Server, args []string, stopCh <-chan struct{}) error
-
-// Server describes a server that this binary can morph into.
-type Server struct {
-	SimpleUsage     string        // One line description of the server.
-	Long            string        // Longer free form description of the server
-	Run             serverRunFunc // Run the server.  This is not expected to return.
-	AlternativeName string
-	RespectsStopCh  bool
-
-	flags *pflag.FlagSet // Flags for the command (and all dependents)
-	name  string
-	hk    *HyperKube
-}
-
-// Usage returns the full usage string including all of the flags.
-func (s *Server) Usage() error {
-	tt := `{{if .Long}}{{.Long | trim | wrap ""}}
-{{end}}Usage:
-  {{.SimpleUsage}} [flags]
-
-Available Flags:
-{{.Flags.FlagUsages}}`
-
-	return utiltemplate.ExecuteTemplate(s.hk.Out(), tt, s)
-}
-
-// Name returns the name of the command as derived from the usage line.
-func (s *Server) Name() string {
-	if s.name != "" {
-		return s.name
-	}
-	name := s.SimpleUsage
-	i := strings.Index(name, " ")
-	if i >= 0 {
-		name = name[:i]
-	}
-	return name
-}
-
-// Flags returns a flagset for this server
-func (s *Server) Flags() *pflag.FlagSet {
-	if s.flags == nil {
-		s.flags = pflag.NewFlagSet(s.Name(), pflag.ContinueOnError)
-		s.flags.SetOutput(ioutil.Discard)
-		s.flags.SetNormalizeFunc(flag.WordSepNormalizeFunc)
-	}
-	return s.flags
-}

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

@@ -28,6 +28,8 @@ import (
 
 	"github.com/spf13/pflag"
 
+	"fmt"
+
 	utilflag "k8s.io/apiserver/pkg/util/flag"
 	"k8s.io/apiserver/pkg/util/logs"
 	"k8s.io/kubernetes/cmd/kube-controller-manager/app"
@@ -52,6 +54,7 @@ func main() {
 	defer logs.FlushLogs()
 
 	if err := command.Execute(); err != nil {
+		fmt.Fprintf(os.Stderr, "%v\n", err)
 		os.Exit(1)
 	}
 }

cmd/kube-scheduler/scheduler.go

@@ -18,6 +18,7 @@ package main
 
 import (
 	goflag "flag"
+	"fmt"
 	"math/rand"
 	"os"
 	"time"
@@ -45,6 +46,7 @@ func main() {
 	defer logs.FlushLogs()
 
 	if err := command.Execute(); err != nil {
+		fmt.Fprintf(os.Stderr, "%v\n", err)
 		os.Exit(1)
 	}
 }

cmd/kubectl/kubectl.go

@@ -18,6 +18,7 @@ package main
 
 import (
 	goflag "flag"
+	"fmt"
 	"math/rand"
 	"os"
 	"time"
@@ -44,6 +45,7 @@ func main() {
 	defer logs.FlushLogs()
 
 	if err := command.Execute(); err != nil {
+		fmt.Fprintf(os.Stderr, "%v\n", err)
 		os.Exit(1)
 	}
 }

cmd/kubelet/app/options/globalflags.go

@@ -53,8 +53,9 @@ func normalize(s string) string {
 // register adds a flag to local that targets the Value associated with the Flag named globalName in global
 func register(global *flag.FlagSet, local *pflag.FlagSet, globalName string) {
 	if f := global.Lookup(globalName); f != nil {
-		f.Name = normalize(f.Name)
-		local.AddFlag(pflag.PFlagFromGoFlag(f))
+		pflagFlag := pflag.PFlagFromGoFlag(f)
+		pflagFlag.Name = normalize(pflagFlag.Name)
+		local.AddFlag(pflagFlag)
 	} else {
 		panic(fmt.Sprintf("failed to find flag in global flagset (flag): %s", globalName))
 	}