Covert the kubelet binary to hyperkube.

cmd/hyperkube/hyperkube.go

@@ -23,6 +23,7 @@ import (
 
 	"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"
 	sched "github.com/GoogleCloudPlatform/kubernetes/plugin/pkg/scheduler/server"
 )
@@ -36,6 +37,7 @@ func main() {
 	hk.AddServer(apiserver.NewHyperkubeServer())
 	hk.AddServer(controllermanager.NewHyperkubeServer())
 	hk.AddServer(sched.NewHyperkubeServer())
+	hk.AddServer(kubelet.NewHyperkubeServer())
 
 	hk.RunToExit(os.Args)
 }

cmd/kubelet/kubelet.go

@@ -21,145 +21,22 @@ limitations under the License.
 package main
 
 import (
-	"math/rand"
-	"net"
-	"time"
-
-	"github.com/GoogleCloudPlatform/kubernetes/cmd/kubelet/app"
-	"github.com/GoogleCloudPlatform/kubernetes/pkg/api"
-	"github.com/GoogleCloudPlatform/kubernetes/pkg/credentialprovider"
-	_ "github.com/GoogleCloudPlatform/kubernetes/pkg/healthz"
-	"github.com/GoogleCloudPlatform/kubernetes/pkg/kubelet"
-	kubeletServer "github.com/GoogleCloudPlatform/kubernetes/pkg/kubelet/server"
-	"github.com/GoogleCloudPlatform/kubernetes/pkg/master/ports"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/kubelet/server"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/util"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/version/verflag"
 
-	"github.com/golang/glog"
-	flag "github.com/spf13/pflag"
-)
-
-const defaultRootDir = "/var/lib/kubelet"
-
-var (
-	config                  = flag.String("config", "", "Path to the config file or directory of files")
-	syncFrequency           = flag.Duration("sync_frequency", 10*time.Second, "Max period between synchronizing running containers and config")
-	fileCheckFrequency      = flag.Duration("file_check_frequency", 20*time.Second, "Duration between checking config files for new data")
-	httpCheckFrequency      = flag.Duration("http_check_frequency", 20*time.Second, "Duration between checking http for new data")
-	manifestURL             = flag.String("manifest_url", "", "URL for accessing the container manifest")
-	enableServer            = flag.Bool("enable_server", true, "Enable the info server")
-	address                 = util.IP(net.ParseIP("127.0.0.1"))
-	port                    = flag.Uint("port", ports.KubeletPort, "The port for the info server to serve on")
-	hostnameOverride        = flag.String("hostname_override", "", "If non-empty, will use this string as identification instead of the actual hostname.")
-	podInfraContainerImage  = flag.String("pod_infra_container_image", kubelet.PodInfraContainerImage, "The image whose network/ipc namespaces containers in each pod will use.")
-	dockerEndpoint          = flag.String("docker_endpoint", "", "If non-empty, use this for the docker endpoint to communicate with")
-	etcdServerList          util.StringList
-	etcdConfigFile          = flag.String("etcd_config", "", "The config file for the etcd client. Mutually exclusive with -etcd_servers")
-	rootDirectory           = flag.String("root_dir", defaultRootDir, "Directory path for managing kubelet files (volume mounts,etc).")
-	allowPrivileged         = flag.Bool("allow_privileged", false, "If true, allow containers to request privileged mode. [default=false]")
-	registryPullQPS         = flag.Float64("registry_qps", 0.0, "If > 0, limit registry pull QPS to this value.  If 0, unlimited. [default=0.0]")
-	registryBurst           = flag.Int("registry_burst", 10, "Maximum size of a bursty pulls, temporarily allows pulls to burst to this number, while still not exceeding registry_qps.  Only used if --registry_qps > 0")
-	runonce                 = flag.Bool("runonce", false, "If true, exit after spawning pods from local manifests or remote urls. Exclusive with --etcd_servers, --api_servers, and --enable-server")
-	enableDebuggingHandlers = flag.Bool("enable_debugging_handlers", true, "Enables server endpoints for log collection and local running of containers and commands")
-	minimumGCAge            = flag.Duration("minimum_container_ttl_duration", 1*time.Minute, "Minimum age for a finished container before it is garbage collected.  Examples: '300ms', '10s' or '2h45m'")
-	maxContainerCount       = flag.Int("maximum_dead_containers_per_container", 5, "Maximum number of old instances of a container to retain per container.  Each container takes up some disk space.  Default: 5.")
-	authPath                = flag.String("auth_path", "", "Path to .kubernetes_auth file, specifying how to authenticate to API server.")
-	cAdvisorPort            = flag.Uint("cadvisor_port", 4194, "The port of the localhost cAdvisor endpoint")
-	oomScoreAdj             = flag.Int("oom_score_adj", -900, "The oom_score_adj value for kubelet process. Values must be within the range [-1000, 1000]")
-	apiServerList           util.StringList
-	clusterDomain           = flag.String("cluster_domain", "", "Domain for this cluster.  If set, kubelet will configure all containers to search this domain in addition to the host's search domains")
-	masterServiceNamespace  = flag.String("master_service_namespace", api.NamespaceDefault, "The namespace from which the kubernetes master services should be injected into pods")
-	clusterDNS              = util.IP(nil)
-	reallyCrashForTesting   = flag.Bool("really_crash_for_testing", false, "If true, crash with panics more often.")
+	"github.com/spf13/pflag"
 )
 
-func init() {
-	flag.Var(&etcdServerList, "etcd_servers", "List of etcd servers to watch (http://ip:port), comma separated. Mutually exclusive with -etcd_config")
-	flag.Var(&address, "address", "The IP address for the info server to serve on (set to 0.0.0.0 for all interfaces)")
-	flag.Var(&apiServerList, "api_servers", "List of Kubernetes API servers for publishing events, and reading pods and services. (ip:port), comma separated.")
-	flag.Var(&clusterDNS, "cluster_dns", "IP address for a cluster DNS server.  If set, kubelet will configure all containers to use this for DNS resolution in addition to the host's DNS servers")
-}
-
-func setupRunOnce() {
-	if *runonce {
-		// Don't use remote (etcd or apiserver) sources
-		if len(etcdServerList) > 0 {
-			glog.Fatalf("invalid option: --runonce and --etcd_servers are mutually exclusive")
-		}
-		if len(apiServerList) > 0 {
-			glog.Fatalf("invalid option: --runonce and --api_servers are mutually exclusive")
-		}
-		if *enableServer {
-			glog.Infof("--runonce is set, disabling server")
-			*enableServer = false
-		}
-	}
-}
-
 func main() {
+	s := server.NewKubeletServer()
+	s.AddFlags(pflag.CommandLine)
+
 	util.InitFlags()
 	util.InitLogs()
-	util.ReallyCrash = *reallyCrashForTesting
 	defer util.FlushLogs()
-	rand.Seed(time.Now().UTC().UnixNano())
 
 	verflag.PrintAndExitIfRequested()
 
-	// Cluster creation scripts support both kubernetes versions that 1) support kublet watching
-	// apiserver for pods, and 2) ones that don't. So they ca set both --etcd_servers and
-	// --api_servers.  The current code will ignore the --etcd_servers flag, while older kubelet
-	// code will use the --etd_servers flag for pods, and use --api_servers for event publising.
-	//
-	// TODO(erictune): convert all cloud provider scripts and Google Container Engine to
-	// use only --api_servers, then delete --etcd_servers flag and the resulting dead code.
-	if len(etcdServerList) > 0 && len(apiServerList) > 0 {
-		glog.Infof("Both --etcd_servers and --api_servers are set.  Not using etcd source.")
-		etcdServerList = util.StringList{}
-	}
-
-	setupRunOnce()
-
-	if err := util.ApplyOomScoreAdj(*oomScoreAdj); err != nil {
-		glog.Info(err)
-	}
-
-	client, err := kubeletServer.GetAPIServerClient(*authPath, apiServerList)
-	if err != nil && len(apiServerList) > 0 {
-		glog.Warningf("No API client: %v", err)
-	}
-
-	credentialprovider.SetPreferredDockercfgPath(*rootDirectory)
-
-	kcfg := kubeletServer.KubeletConfig{
-		Address:                 address,
-		AllowPrivileged:         *allowPrivileged,
-		HostnameOverride:        *hostnameOverride,
-		RootDirectory:           *rootDirectory,
-		ConfigFile:              *config,
-		ManifestURL:             *manifestURL,
-		FileCheckFrequency:      *fileCheckFrequency,
-		HttpCheckFrequency:      *httpCheckFrequency,
-		PodInfraContainerImage:  *podInfraContainerImage,
-		SyncFrequency:           *syncFrequency,
-		RegistryPullQPS:         *registryPullQPS,
-		RegistryBurst:           *registryBurst,
-		MinimumGCAge:            *minimumGCAge,
-		MaxContainerCount:       *maxContainerCount,
-		ClusterDomain:           *clusterDomain,
-		ClusterDNS:              clusterDNS,
-		Runonce:                 *runonce,
-		Port:                    *port,
-		CAdvisorPort:            *cAdvisorPort,
-		EnableServer:            *enableServer,
-		EnableDebuggingHandlers: *enableDebuggingHandlers,
-		DockerClient:            util.ConnectToDockerOrDie(*dockerEndpoint),
-		KubeClient:              client,
-		EtcdClient:              kubelet.EtcdClientOrDie(etcdServerList, *etcdConfigFile),
-		MasterServiceNamespace:  *masterServiceNamespace,
-		VolumePlugins:           app.ProbeVolumePlugins(),
-	}
-
-	kubeletServer.RunKubelet(&kcfg)
-	// runs forever
-	select {}
+	s.Run(pflag.CommandLine.Args())
 }

cmd/kubernetes/kubernetes.go

@@ -26,7 +26,6 @@ import (
 	"net/http"
 	"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"
@@ -141,7 +140,7 @@ func startComponents(etcdClient tools.EtcdClient, cl *client.Client, addr net.IP
 	runControllerManager(machineList, cl, *nodeMilliCPU, *nodeMemory)
 
 	dockerClient := util.ConnectToDockerOrDie(*dockerEndpoint)
-	kubeletServer.SimpleRunKubelet(cl, nil, dockerClient, machineList[0], "/tmp/kubernetes", "", "127.0.0.1", 10250, *masterServiceNamespace, kubeletapp.ProbeVolumePlugins())
+	kubeletServer.SimpleRunKubelet(cl, nil, dockerClient, machineList[0], "/tmp/kubernetes", "", "127.0.0.1", 10250, *masterServiceNamespace, kubeletServer.ProbeVolumePlugins())
 }
 
 func newApiClient(addr net.IP, port int) *client.Client {

cmd/kubelet/app/plugins.go → pkg/kubelet/server/plugins.go

@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package app
+package server
 
 // This file exists to force the desired plugin implementations to be linked.
 import (
@@ -28,6 +28,7 @@ import (
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/kubelet/volume/host_path"
 )
 
+// ProbeVolumePlugins collects all volume plugins into an easy to use list.
 func ProbeVolumePlugins() []volume.Plugin {
 	allPlugins := []volume.Plugin{}