Instead of launching kubelet directly, exec

If the only component running on the node is the kubelet, exec with the
necessary args instead of running the code in the current process.

Author: smarterclayton

pkg/cmd/server/kubernetes/node/options/options.go

@@ -201,3 +201,7 @@ func buildKubeProxyConfig(options configapi.NodeConfig) (*componentconfig.KubePr
 
 	return proxyconfig, nil
 }
+
+func ToFlags(config *kubeletoptions.KubeletServer) []string {
+	return cmdflags.AsArgs(config.AddFlags, kubeletoptions.NewKubeletServer().AddFlags)
+}

pkg/cmd/server/start/start_node.go

@@ -5,15 +5,20 @@ import (
 	"fmt"
 	"io"
 	"os"
+	"os/exec"
 	"path/filepath"
 	"strings"
+	"syscall"
 
 	"github.com/coreos/go-systemd/daemon"
 	"github.com/golang/glog"
 	"github.com/spf13/cobra"
 
 	kerrors "k8s.io/apimachinery/pkg/api/errors"
+	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
+	"k8s.io/apimachinery/pkg/util/sets"
 	"k8s.io/apimachinery/pkg/util/wait"
+	kubeletoptions "k8s.io/kubernetes/cmd/kubelet/app/options"
 	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
 	kcmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
 
@@ -328,12 +333,85 @@ func (o NodeOptions) IsRunFromConfig() bool {
 	return (len(o.ConfigFile) > 0)
 }
 
+// execKubelet attempts to call execve() for the kubelet with the configuration defined
+// in server passed as flags. If the binary is not the same as the current file and
+// the environment variable OPENSHIFT_ALLOW_UNSUPPORTED_KUBELET is unset, the method
+// will return an error. The returned boolean indicates whether fallback to in-process
+// is allowed.
+func execKubelet(server *kubeletoptions.KubeletServer) (bool, error) {
+	// verify the Kubelet binary to use
+	path := "kubelet"
+	requireSameBinary := true
+	if newPath := os.Getenv("OPENSHIFT_ALLOW_UNSUPPORTED_KUBELET"); len(newPath) > 0 {
+		requireSameBinary = false
+		path = newPath
+	}
+	kubeletPath, err := exec.LookPath(path)
+	if err != nil {
+		return requireSameBinary, err
+	}
+	kubeletFile, err := os.Stat(kubeletPath)
+	if err != nil {
+		return requireSameBinary, err
+	}
+	thisPath, err := exec.LookPath(os.Args[0])
+	if err != nil {
+		return true, err
+	}
+	thisFile, err := os.Stat(thisPath)
+	if err != nil {
+		return true, err
+	}
+	if !os.SameFile(thisFile, kubeletFile) {
+		if requireSameBinary {
+			return true, fmt.Errorf("binary at %q is not the same file as %q, cannot execute", thisPath, kubeletPath)
+		}
+		glog.Warningf("UNSUPPORTED: Executing a different Kubelet than the current binary is not supported: %s", kubeletPath)
+	}
+
+	// convert current settings to flags
+	args := nodeoptions.ToFlags(server)
+	args = append([]string{kubeletPath}, args...)
+	for i := glog.Level(10); i > 0; i-- {
+		if glog.V(i) {
+			args = append(args, fmt.Sprintf("--v=%d", i))
+			break
+		}
+	}
+	for i, s := range os.Args {
+		if s == "--vmodule" {
+			if i+1 < len(os.Args) {
+				args = append(args, fmt.Sprintf("--vmodule=", os.Args[i+1]))
+				break
+			}
+		}
+		if strings.HasPrefix(s, "--vmodule=") {
+			args = append(args, s)
+			break
+		}
+	}
+	glog.V(3).Infof("Exec %s %s", kubeletPath, strings.Join(args, " "))
+	return false, syscall.Exec(kubeletPath, args, os.Environ())
+}
+
 func StartNode(nodeConfig configapi.NodeConfig, components *utilflags.ComponentFlag) error {
 	server, proxyConfig, err := nodeoptions.Build(nodeConfig)
 	if err != nil {
 		return err
 	}
 
+	// as a step towards decomposing OpenShift into Kubernetes components, perform an execve
+	// to launch the Kubelet instead of loading in-process
+	if components.Calculated().Equal(sets.NewString(ComponentKubelet)) {
+		ok, err := execKubelet(server)
+		if !ok {
+			return err
+		}
+		if err != nil {
+			utilruntime.HandleError(fmt.Errorf("Unable to call exec on kubelet, continuing with normal startup: %v", err))
+		}
+	}
+
 	networkConfig, err := network.New(nodeConfig, server.ClusterDomain, proxyConfig, components.Enabled(ComponentProxy), components.Enabled(ComponentDNS) && len(nodeConfig.DNSBindAddress) > 0)
 	if err != nil {
 		return err

pkg/cmd/util/flags/flags.go

@@ -36,6 +36,33 @@ func Resolve(args map[string][]string, fn func(*pflag.FlagSet)) []error {
 	return Apply(args, fs)
 }
 
+func AsArgs(fn, defaultFn func(*pflag.FlagSet)) []string {
+	fs := pflag.NewFlagSet("extended", pflag.ContinueOnError)
+	fn(fs)
+	defaults := pflag.NewFlagSet("defaults", pflag.ContinueOnError)
+	defaultFn(defaults)
+	var args []string
+	fs.VisitAll(func(flag *pflag.Flag) {
+		defaultFlag := defaults.Lookup(flag.Name)
+		s := flag.Value.String()
+		defaultValue := defaultFlag.Value.String()
+		if s == defaultValue {
+			return
+		}
+		if values, err := fs.GetStringSlice(flag.Name); err == nil {
+			for _, s := range values {
+				args = append(args, fmt.Sprintf("--%s=%s", flag.Name, s))
+			}
+		} else {
+			if len(s) == 0 {
+				s = defaultValue
+			}
+			args = append(args, fmt.Sprintf("--%s=%s", flag.Name, s))
+		}
+	})
+	return args
+}
+
 // ComponentFlag represents a set of enabled components used in a command line.
 type ComponentFlag struct {
 	enabled    string