Merge pull request #4240 from thockin/hyperkube

Hyperkube cleanup

cmd/hyperkube/hyperkube.go

@@ -14,32 +14,186 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// A binary that can morph into all of the other kubernetes binaries. You can
-// also soft-link to it busybox style.
 package main
 
 import (
+	"errors"
+	"flag"
+	"fmt"
+	"io"
+	"io/ioutil"
 	"os"
+	"path"
 
-	"github.com/GoogleCloudPlatform/kubernetes/pkg/controllermanager"
-	"github.com/GoogleCloudPlatform/kubernetes/pkg/hyperkube"
-	kubelet "github.com/GoogleCloudPlatform/kubernetes/pkg/kubelet/server"
-	apiserver "github.com/GoogleCloudPlatform/kubernetes/pkg/master/server"
-	proxy "github.com/GoogleCloudPlatform/kubernetes/pkg/proxy/server"
-	sched "github.com/GoogleCloudPlatform/kubernetes/plugin/pkg/scheduler/server"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/util"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/version/verflag"
+
+	"github.com/spf13/pflag"
 )
 
-func main() {
-	hk := hyperkube.HyperKube{
-		Name: "hyperkube",
-		Long: "This is an all-in-one binary that can run any of the various Kubernetes servers.",
+// 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
+	baseFlags   *pflag.FlagSet
+	out         io.Writer
+	helpFlagVal 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
+}
+
+// FindServer will find a specific server named name.
+func (hk *HyperKube) FindServer(name string) (*Server, error) {
+	for _, s := range hk.servers {
+		if s.Name() == name {
+			return &s, nil
+		}
+	}
+	return nil, fmt.Errorf("Server not found: %s", name)
+}
+
+// Servers returns a list of all of the registred 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.BoolVarP(&hk.helpFlagVal, "help", "h", false, "help for "+hk.Name)
+
+		// These will add all of the "global" flags (defined with both the
+		// flag and pflag packages) to the new flag set we have.
+		util.AddFlagSetToPFlagSet(flag.CommandLine, hk.baseFlags)
+		util.AddPFlagSetToPFlagSet(pflag.CommandLine, hk.baseFlags)
+
+	}
+	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) error {
+	// If we are called directly, parse all flags up to the first real
+	// argument.  That should be the server to run.
+	baseCommand := path.Base(args[0])
+	serverName := baseCommand
+	if serverName == hk.Name {
+		args = args[1:]
+
+		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
+		}
+
+		verflag.PrintAndExitIfRequested()
+
+		args = baseFlags.Args()
+		if len(args) > 0 && len(args[0]) > 0 {
+			serverName = args[0]
+			baseCommand = baseCommand + " " + serverName
+			args = args[1:]
+		} else {
+			err = errors.New("No server specified")
+			hk.Printf("Error: %v\n\n", err)
+			hk.Usage()
+			return err
+		}
 	}
 
-	hk.AddServer(apiserver.NewHyperkubeServer())
-	hk.AddServer(controllermanager.NewHyperkubeServer())
-	hk.AddServer(sched.NewHyperkubeServer())
-	hk.AddServer(kubelet.NewHyperkubeServer())
-	hk.AddServer(proxy.NewHyperkubeServer())
+	s, err := hk.FindServer(serverName)
+	if err != nil {
+		hk.Printf("Error: %v\n\n", err)
+		hk.Usage()
+		return err
+	}
 
-	hk.RunToExit(os.Args)
+	util.AddPFlagSetToPFlagSet(hk.Flags(), s.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()
+
+	util.InitLogs()
+	defer util.FlushLogs()
+
+	err = s.Run(s, s.Flags().Args())
+	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) {
+	err := hk.Run(args)
+	if err != nil {
+		os.Exit(1)
+	}
+	os.Exit(0)
+}
+
+// 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}} <server> --help' for help on a specific server.
+`
+	util.ExecuteTemplate(hk.Out(), tt, hk)
 }

cmd/hyperkube/hyperkube_test.go

@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package hyperkube
+package main
 
 import (
 	"bytes"

cmd/hyperkube/kube-apiserver.go

@@ -0,0 +1,37 @@
+/*
+Copyright 2015 Google Inc. 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 (
+	kubeapiserver "github.com/GoogleCloudPlatform/kubernetes/cmd/kube-apiserver/app"
+)
+
+// NewKubeAPIServer creates a new hyperkube Server object that includes the
+// description and flags.
+func NewKubeAPIServer() *Server {
+	s := kubeapiserver.NewAPIServer()
+
+	hks := Server{
+		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) error {
+			return s.Run(args)
+		},
+	}
+	s.AddFlags(hks.Flags())
+	return &hks
+}

cmd/hyperkube/kube-controller-manager.go

@@ -0,0 +1,37 @@
+/*
+Copyright 2015 Google Inc. 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 (
+	controllermgr "github.com/GoogleCloudPlatform/kubernetes/cmd/kube-controller-manager/app"
+)
+
+// NewKubeControllerManager creates a new hyperkube Server object that includes the
+// description and flags.
+func NewKubeControllerManager() *Server {
+	s := controllermgr.NewCMServer()
+
+	hks := Server{
+		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) error {
+			return s.Run(args)
+		},
+	}
+	s.AddFlags(hks.Flags())
+	return &hks
+}

cmd/hyperkube/kube-proxy.go

@@ -0,0 +1,40 @@
+/*
+Copyright 2015 Google Inc. 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 (
+	kubeproxy "github.com/GoogleCloudPlatform/kubernetes/cmd/kube-proxy/app"
+)
+
+// NewKubeProxy creates a new hyperkube Server object that includes the
+// description and flags.
+func NewKubeProxy() *Server {
+	s := kubeproxy.NewProxyServer()
+
+	hks := Server{
+		SimpleUsage: "proxy",
+		Long: `The Kubernetes proxy server is responsible for taking traffic directed at
+		services and forwarding it to the appropriate pods.  It generally runs on
+		nodes next to the Kubelet and proxies traffic from local pods to remote pods.
+		It is also used when handling incoming external traffic.`,
+		Run: func(_ *Server, args []string) error {
+			return s.Run(args)
+		},
+	}
+	s.AddFlags(hks.Flags())
+	return &hks
+}

cmd/hyperkube/kube-scheduler.go

@@ -0,0 +1,37 @@
+/*
+Copyright 2015 Google Inc. 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 (
+	scheduler "github.com/GoogleCloudPlatform/kubernetes/plugin/cmd/kube-scheduler/app"
+)
+
+// NewScheduler creates a new hyperkube Server object that includes the
+// description and flags.
+func NewScheduler() *Server {
+	s := scheduler.NewSchedulerServer()
+
+	hks := Server{
+		SimpleUsage: "scheduler",
+		Long:        "Implements a Kubernetes scheduler.  This will assign pods to kubelets based on capacity and constraints.",
+		Run: func(_ *Server, args []string) error {
+			return s.Run(args)
+		},
+	}
+	s.AddFlags(hks.Flags())
+	return &hks
+}

cmd/hyperkube/kubelet.go

@@ -0,0 +1,41 @@
+/*
+Copyright 2015 Google Inc. 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 (
+	kubelet "github.com/GoogleCloudPlatform/kubernetes/cmd/kubelet/app"
+)
+
+// NewKubelet creates a new hyperkube Server object that includes the
+// description and flags.
+func NewKubelet() *Server {
+	s := kubelet.NewKubeletServer()
+	hks := Server{
+		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, args []string) error {
+			return s.Run(args)
+		},
+	}
+	s.AddFlags(hks.Flags())
+	return &hks
+}

cmd/hyperkube/main.go

@@ -0,0 +1,38 @@
+/*
+Copyright 2014 Google Inc. 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.
+*/
+
+// A binary that can morph into all of the other kubernetes binaries. You can
+// also soft-link to it busybox style.
+package main
+
+import (
+	"os"
+)
+
+func main() {
+	hk := HyperKube{
+		Name: "hyperkube",
+		Long: "This is an all-in-one binary that can run any of the various Kubernetes servers.",
+	}
+
+	hk.AddServer(NewKubeAPIServer())
+	hk.AddServer(NewKubeControllerManager())
+	hk.AddServer(NewScheduler())
+	hk.AddServer(NewKubelet())
+	hk.AddServer(NewKubeProxy())
+
+	hk.RunToExit(os.Args)
+}

cmd/hyperkube/server.go

@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package hyperkube
+package main
 
 import (
 	"io/ioutil"

cmd/integration/integration.go

@@ -32,6 +32,7 @@ import (
 	"sync"
 	"time"
 
+	kubeletapp "github.com/GoogleCloudPlatform/kubernetes/cmd/kubelet/app"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/api"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/api/errors"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/api/latest"
@@ -41,7 +42,6 @@ import (
 	nodeControllerPkg "github.com/GoogleCloudPlatform/kubernetes/pkg/cloudprovider/controller"
 	replicationControllerPkg "github.com/GoogleCloudPlatform/kubernetes/pkg/controller"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/kubelet/dockertools"
-	kubeletServer "github.com/GoogleCloudPlatform/kubernetes/pkg/kubelet/server"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/kubelet/volume/empty_dir"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/labels"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/master"
@@ -211,13 +211,13 @@ func startComponents(manifestURL string) (apiServerURL string) {
 	// Kubelet (localhost)
 	testRootDir := makeTempDirOrDie("kubelet_integ_1.")
 	glog.Infof("Using %s as root dir for kubelet #1", testRootDir)
-	kubeletServer.SimpleRunKubelet(cl, nil, &fakeDocker1, machineList[0], testRootDir, manifestURL, "127.0.0.1", 10250, api.NamespaceDefault, empty_dir.ProbeVolumePlugins())
+	kubeletapp.SimpleRunKubelet(cl, nil, &fakeDocker1, machineList[0], testRootDir, manifestURL, "127.0.0.1", 10250, api.NamespaceDefault, empty_dir.ProbeVolumePlugins())
 	// Kubelet (machine)
 	// Create a second kubelet so that the guestbook example's two redis slaves both
 	// have a place they can schedule.
 	testRootDir = makeTempDirOrDie("kubelet_integ_2.")
 	glog.Infof("Using %s as root dir for kubelet #2", testRootDir)
-	kubeletServer.SimpleRunKubelet(cl, nil, &fakeDocker2, machineList[1], testRootDir, "", "127.0.0.1", 10251, api.NamespaceDefault, empty_dir.ProbeVolumePlugins())
+	kubeletapp.SimpleRunKubelet(cl, nil, &fakeDocker2, machineList[1], testRootDir, "", "127.0.0.1", 10251, api.NamespaceDefault, empty_dir.ProbeVolumePlugins())
 
 	return apiServer.URL
 }

cmd/kube-apiserver/apiserver.go

@@ -23,7 +23,7 @@ import (
 	"os"
 	"runtime"
 
-	"github.com/GoogleCloudPlatform/kubernetes/pkg/master/server"
+	"github.com/GoogleCloudPlatform/kubernetes/cmd/kube-apiserver/app"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/util"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/version/verflag"
 
@@ -32,7 +32,7 @@ import (
 
 func main() {
 	runtime.GOMAXPROCS(runtime.NumCPU())
-	s := server.NewAPIServer()
+	s := app.NewAPIServer()
 	s.AddFlags(pflag.CommandLine)
 
 	util.InitFlags()

cmd/kube-apiserver/app/plugins.go

@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package server
+package app
 
 // This file exists to force the desired plugin implementations to be linked.
 // This should probably be part of some configuration fed into the build for a

cmd/kube-apiserver/app/server.go

@@ -14,10 +14,10 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Package server does all of the work necessary to create a Kubernetes
+// Package app does all of the work necessary to create a Kubernetes
 // APIServer by binding together the API, master and APIServer infrastructure.
 // It can be configured and called directly or via the hyperkube framework.
-package server
+package app
 
 import (
 	"crypto/tls"
@@ -33,7 +33,6 @@ import (
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/capabilities"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/client"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/cloudprovider"
-	"github.com/GoogleCloudPlatform/kubernetes/pkg/hyperkube"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/master"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/tools"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/util"
@@ -102,22 +101,6 @@ func NewAPIServer() *APIServer {
 	return &s
 }
 
-// NewHyperkubeServer creates a new hyperkube Server object that includes the
-// description and flags.
-func NewHyperkubeServer() *hyperkube.Server {
-	s := NewAPIServer()
-
-	hks := hyperkube.Server{
-		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(_ *hyperkube.Server, args []string) error {
-			return s.Run(args)
-		},
-	}
-	s.AddFlags(hks.Flags())
-	return &hks
-}
-
 // 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

@@ -14,10 +14,10 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Package controllermanager implements a server that runs a set of active
+// Package app implements a server that runs a set of active
 // components.  This includes replication controllers, service endpoints and
 // nodes.
-package controllermanager
+package app
 
 import (
 	"net"
@@ -32,7 +32,6 @@ import (
 	nodeControllerPkg "github.com/GoogleCloudPlatform/kubernetes/pkg/cloudprovider/controller"
 	replicationControllerPkg "github.com/GoogleCloudPlatform/kubernetes/pkg/controller"
 	_ "github.com/GoogleCloudPlatform/kubernetes/pkg/healthz"
-	"github.com/GoogleCloudPlatform/kubernetes/pkg/hyperkube"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/master/ports"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/resourcequota"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/service"
@@ -84,22 +83,6 @@ func NewCMServer() *CMServer {
 	return &s
 }
 
-// NewHyperkubeServer creates a new hyperkube Server object that includes the
-// description and flags.
-func NewHyperkubeServer() *hyperkube.Server {
-	s := NewCMServer()
-
-	hks := hyperkube.Server{
-		SimpleUsage: "controller-manager",
-		Long:        "A server that runs a set of active components. This includes replication controllers, service endpoints and nodes.",
-		Run: func(_ *hyperkube.Server, args []string) error {
-			return s.Run(args)
-		},
-	}
-	s.AddFlags(hks.Flags())
-	return &hks
-}
-
 // 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")

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

@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package controllermanager
+package app
 
 import (
 	// This file exists to force the desired plugin implementations to be linked.

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

@@ -25,7 +25,7 @@ import (
 	"os"
 	"runtime"
 
-	"github.com/GoogleCloudPlatform/kubernetes/pkg/controllermanager"
+	"github.com/GoogleCloudPlatform/kubernetes/cmd/kube-controller-manager/app"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/util"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/version/verflag"
 
@@ -34,7 +34,7 @@ import (
 
 func main() {
 	runtime.GOMAXPROCS(runtime.NumCPU())
-	s := controllermanager.NewCMServer()
+	s := app.NewCMServer()
 	s.AddFlags(pflag.CommandLine)
 
 	util.InitFlags()

cmd/kube-proxy/app/server.go

@@ -14,9 +14,9 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Package server does all of the work necessary to configure and run a
-// Kubernetes proxy process.
-package server
+// Package app does all of the work necessary to configure and run a
+// Kubernetes app process.
+package app
 
 import (
 	"net"
@@ -27,7 +27,6 @@ import (
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/api"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/client"
 	_ "github.com/GoogleCloudPlatform/kubernetes/pkg/healthz"
-	"github.com/GoogleCloudPlatform/kubernetes/pkg/hyperkube"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/proxy"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/proxy/config"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/util"
@@ -58,25 +57,6 @@ func NewProxyServer() *ProxyServer {
 	}
 }
 
-// NewHyperkubeServer creates a new hyperkube Server object that includes the
-// description and flags.
-func NewHyperkubeServer() *hyperkube.Server {
-	s := NewProxyServer()
-
-	hks := hyperkube.Server{
-		SimpleUsage: "proxy",
-		Long: `The Kubernetes proxy server is responsible for taking traffic directed at
-services and forwarding it to the appropriate pods.  It generally runs on
-nodes next to the Kubelet and proxies traffic from local pods to remote pods.
-It is also used when handling incoming external traffic.`,
-		Run: func(_ *hyperkube.Server, args []string) error {
-			return s.Run(args)
-		},
-	}
-	s.AddFlags(hks.Flags())
-	return &hks
-}
-
 // AddFlags adds flags for a specific ProxyServer to the specified FlagSet
 func (s *ProxyServer) AddFlags(fs *pflag.FlagSet) {
 	fs.StringVar(&s.EtcdConfigFile, "etcd_config", s.EtcdConfigFile, "The config file for the etcd client. Mutually exclusive with -etcd_servers")

cmd/kube-proxy/proxy.go

@@ -21,7 +21,7 @@ import (
 	"os"
 	"runtime"
 
-	"github.com/GoogleCloudPlatform/kubernetes/pkg/proxy/server"
+	"github.com/GoogleCloudPlatform/kubernetes/cmd/kube-proxy/app"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/util"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/version/verflag"
 
@@ -30,7 +30,7 @@ import (
 
 func main() {
 	runtime.GOMAXPROCS(runtime.NumCPU())
-	s := server.NewProxyServer()
+	s := app.NewProxyServer()
 	s.AddFlags(pflag.CommandLine)
 
 	util.InitFlags()

cmd/kubelet/app/plugins.go

@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package server
+package app
 
 // This file exists to force the desired plugin implementations to be linked.
 import (

cmd/kubelet/app/server.go

@@ -14,8 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Package server makes it easy to create a kubelet server for various contexts.
-package server
+// Package app makes it easy to create a kubelet server for various contexts.
+package app
 
 import (
 	"fmt"
@@ -28,7 +28,6 @@ import (
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/clientauth"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/credentialprovider"
 	_ "github.com/GoogleCloudPlatform/kubernetes/pkg/healthz"
-	"github.com/GoogleCloudPlatform/kubernetes/pkg/hyperkube"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/kubelet"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/kubelet/config"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/kubelet/dockertools"
@@ -99,26 +98,6 @@ func NewKubeletServer() *KubeletServer {
 	}
 }
 
-// NewHyperkubeServer creates a new hyperkube Server object that includes the
-// description and flags.
-func NewHyperkubeServer() *hyperkube.Server {
-	s := NewKubeletServer()
-	hks := hyperkube.Server{
-		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(_ *hyperkube.Server, args []string) error {
-			return s.Run(args)
-		},
-	}
-	s.AddFlags(hks.Flags())
-	return &hks
-}
-
 // 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")

cmd/kubelet/kubelet.go

@@ -25,7 +25,7 @@ import (
 	"os"
 	"runtime"
 
-	"github.com/GoogleCloudPlatform/kubernetes/pkg/kubelet/server"
+	"github.com/GoogleCloudPlatform/kubernetes/cmd/kubelet/app"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/util"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/version/verflag"
 
@@ -34,7 +34,7 @@ import (
 
 func main() {
 	runtime.GOMAXPROCS(runtime.NumCPU())
-	s := server.NewKubeletServer()
+	s := app.NewKubeletServer()
 	s.AddFlags(pflag.CommandLine)
 
 	util.InitFlags()

cmd/kubernetes/kubernetes.go

@@ -28,6 +28,7 @@ import (
 	"runtime"
 	"time"
 
+	kubeletapp "github.com/GoogleCloudPlatform/kubernetes/cmd/kubelet/app"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/api"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/api/resource"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/api/testapi"
@@ -36,7 +37,6 @@ import (
 	nodeControllerPkg "github.com/GoogleCloudPlatform/kubernetes/pkg/cloudprovider/controller"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/controller"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/kubelet/dockertools"
-	kubeletServer "github.com/GoogleCloudPlatform/kubernetes/pkg/kubelet/server"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/master"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/master/ports"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/service"
@@ -144,7 +144,7 @@ func startComponents(etcdClient tools.EtcdClient, cl *client.Client, addr net.IP
 	runControllerManager(machineList, cl, *nodeMilliCPU, *nodeMemory)
 
 	dockerClient := dockertools.ConnectToDockerOrDie(*dockerEndpoint)
-	kubeletServer.SimpleRunKubelet(cl, nil, dockerClient, machineList[0], "/tmp/kubernetes", "", "127.0.0.1", 10250, *masterServiceNamespace, kubeletServer.ProbeVolumePlugins())
+	kubeletapp.SimpleRunKubelet(cl, nil, dockerClient, machineList[0], "/tmp/kubernetes", "", "127.0.0.1", 10250, *masterServiceNamespace, kubeletapp.ProbeVolumePlugins())
 }
 
 func newApiClient(addr net.IP, port int) *client.Client {

hack/lib/golang.sh

@@ -24,6 +24,7 @@ readonly KUBE_SERVER_TARGETS=(
   cmd/kube-apiserver
   cmd/kube-controller-manager
   cmd/kubelet
+  cmd/hyperkube
   plugin/cmd/kube-scheduler
 )
 readonly KUBE_SERVER_BINARIES=("${KUBE_SERVER_TARGETS[@]##*/}")

pkg/hyperkube/hyperkube.go

@@ -1,204 +0,0 @@
-/*
-Copyright 2014 Google Inc. 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 hyperkube
-
-import (
-	"errors"
-	"flag"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"os"
-	"path"
-	"runtime"
-
-	"github.com/GoogleCloudPlatform/kubernetes/pkg/util"
-	"github.com/GoogleCloudPlatform/kubernetes/pkg/version/verflag"
-
-	"github.com/spf13/pflag"
-)
-
-// 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
-	baseFlags   *pflag.FlagSet
-	out         io.Writer
-	helpFlagVal 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
-}
-
-// FindServer will find a specific server named name.
-func (hk *HyperKube) FindServer(name string) (*Server, error) {
-	for _, s := range hk.servers {
-		if s.Name() == name {
-			return &s, nil
-		}
-	}
-	return nil, fmt.Errorf("Server not found: %s", name)
-}
-
-// Servers returns a list of all of the registred 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.BoolVarP(&hk.helpFlagVal, "help", "h", false, "help for "+hk.Name)
-
-		// These will add all of the "global" flags (defined with both the
-		// flag and pflag packages) to the new flag set we have.
-		util.AddFlagSetToPFlagSet(flag.CommandLine, hk.baseFlags)
-		util.AddPFlagSetToPFlagSet(pflag.CommandLine, hk.baseFlags)
-
-	}
-	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{}) {
-	str := fmt.Sprintln(i...)
-	hk.Print(str)
-}
-
-// Printf is a convenience method to Printf to the defined output
-func (hk *HyperKube) Printf(format string, i ...interface{}) {
-	str := fmt.Sprintf(format, i...)
-	hk.Print(str)
-}
-
-// Run the server.  This will pick the appropriate server and run it.
-func (hk *HyperKube) Run(args []string) error {
-	// If we are called directly, parse all flags up to the first real
-	// argument.  That should be the server to run.
-	baseCommand := path.Base(args[0])
-	serverName := baseCommand
-	if serverName == hk.Name {
-		args = args[1:]
-
-		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
-		}
-
-		verflag.PrintAndExitIfRequested()
-
-		args = baseFlags.Args()
-		if len(args) > 0 && len(args[0]) > 0 {
-			serverName = args[0]
-			baseCommand = baseCommand + " " + serverName
-			args = args[1:]
-		} else {
-			err = errors.New("No server specified")
-			hk.Printf("Error: %v\n\n", err)
-			hk.Usage()
-			return err
-		}
-	}
-
-	s, err := hk.FindServer(serverName)
-	if err != nil {
-		hk.Printf("Error: %v\n\n", err)
-		hk.Usage()
-		return err
-	}
-
-	util.AddPFlagSetToPFlagSet(hk.Flags(), s.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()
-
-	util.InitLogs()
-	defer util.FlushLogs()
-
-	err = s.Run(s, s.Flags().Args())
-	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) {
-	runtime.GOMAXPROCS(runtime.NumCPU())
-	err := hk.Run(args)
-	if err != nil {
-		fmt.Fprint(os.Stderr, err.Error())
-		os.Exit(1)
-	}
-	os.Exit(0)
-}
-
-// 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}} <server> --help' for help on a specific server.
-`
-	util.ExecuteTemplate(hk.Out(), tt, hk)
-}

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

@@ -14,8 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Package server implements a Server object for running the scheduler.
-package server
+// Package app implements a Server object for running the scheduler.
+package app
 
 import (
 	"net"
@@ -26,7 +26,6 @@ import (
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/client"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/client/record"
 	_ "github.com/GoogleCloudPlatform/kubernetes/pkg/healthz"
-	"github.com/GoogleCloudPlatform/kubernetes/pkg/hyperkube"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/master/ports"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/util"
 	"github.com/GoogleCloudPlatform/kubernetes/plugin/pkg/scheduler"
@@ -55,22 +54,6 @@ func NewSchedulerServer() *SchedulerServer {
 	return &s
 }
 
-// NewHyperkubeServer creates a new hyperkube Server object that includes the
-// description and flags.
-func NewHyperkubeServer() *hyperkube.Server {
-	s := NewSchedulerServer()
-
-	hks := hyperkube.Server{
-		SimpleUsage: "scheduler",
-		Long:        "Implements a Kubernetes scheduler.  This will assign pods to kubelets based on capacity and constraints.",
-		Run: func(_ *hyperkube.Server, args []string) error {
-			return s.Run(args)
-		},
-	}
-	s.AddFlags(hks.Flags())
-	return &hks
-}
-
 // 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")

plugin/cmd/kube-scheduler/scheduler.go

@@ -19,13 +19,13 @@ package main
 import (
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/util"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/version/verflag"
-	"github.com/GoogleCloudPlatform/kubernetes/plugin/pkg/scheduler/server"
+	"github.com/GoogleCloudPlatform/kubernetes/plugin/cmd/kube-scheduler/app"
 
 	"github.com/spf13/pflag"
 )
 
 func main() {
-	s := server.NewSchedulerServer()
+	s := app.NewSchedulerServer()
 	s.AddFlags(pflag.CommandLine)
 
 	util.InitFlags()