none: Add support for OpenRC init (Google CloudShell)

cmd/minikube/cmd/docker-env.go

@@ -24,7 +24,6 @@ import (
 	"io"
 	"net"
 	"os"
-	"os/exec"
 	"strconv"
 	"strings"
 
@@ -38,6 +37,7 @@ import (
 	"k8s.io/minikube/pkg/minikube/mustload"
 	"k8s.io/minikube/pkg/minikube/out"
 	"k8s.io/minikube/pkg/minikube/shell"
+	"k8s.io/minikube/pkg/minikube/sysinit"
 )
 
 var dockerEnvTmpl = fmt.Sprintf("{{ .Prefix }}%s{{ .Delimiter }}{{ .DockerTLSVerify }}{{ .Suffix }}{{ .Prefix }}%s{{ .Delimiter }}{{ .DockerHost }}{{ .Suffix }}{{ .Prefix }}%s{{ .Delimiter }}{{ .DockerCertPath }}{{ .Suffix }}{{ .Prefix }}%s{{ .Delimiter }}{{ .MinikubeDockerdProfile }}{{ .Suffix }}{{ if .NoProxyVar }}{{ .Prefix }}{{ .NoProxyVar }}{{ .Delimiter }}{{ .NoProxyValue }}{{ .Suffix }}{{end}}{{ .UsageHint }}", constants.DockerTLSVerifyEnv, constants.DockerHostEnv, constants.DockerCertPathEnv, constants.MinikubeActiveDockerdEnv)
@@ -116,9 +116,7 @@ func (EnvNoProxyGetter) GetNoProxyVar() (string, string) {
 
 // isDockerActive checks if Docker is active
 func isDockerActive(r command.Runner) bool {
-	c := exec.Command("sudo", "systemctl", "is-active", "--quiet", "service", "docker")
-	_, err := r.RunCmd(c)
-	return err == nil
+	return sysinit.New(r).Active("docker")
 }
 
 // dockerEnvCmd represents the docker-env command

cmd/minikube/cmd/status.go

@@ -208,15 +208,9 @@ func status(api libmachine.API, cc config.ClusterConfig, n config.Node) (*Status
 		return st, err
 	}
 
-	stk, err := kverify.KubeletStatus(cr)
-	glog.Infof("%s kubelet status = %s (err=%v)", name, stk, err)
-
-	if err != nil {
-		glog.Warningf("kubelet err: %v", err)
-		st.Kubelet = state.Error.String()
-	} else {
-		st.Kubelet = stk.String()
-	}
+	stk := kverify.KubeletStatus(cr)
+	glog.Infof("%s kubelet status = %s", name, stk)
+	st.Kubelet = stk.String()
 
 	// Early exit for regular nodes
 	if !controlPlane {

hack/preload-images/generate.go

@@ -31,6 +31,7 @@ import (
 	"k8s.io/minikube/pkg/minikube/config"
 	"k8s.io/minikube/pkg/minikube/driver"
 	"k8s.io/minikube/pkg/minikube/localpath"
+	"k8s.io/minikube/pkg/minikube/sysinit"
 )
 
 func generateTarball(kubernetesVersion, containerRuntime, tarballFilename string) error {
@@ -86,7 +87,9 @@ func generateTarball(kubernetesVersion, containerRuntime, tarballFilename string
 		KubernetesVersion: kubernetesVersion,
 	}
 	runner := command.NewKICRunner(profile, driver.OCIBinary)
-	if err := bsutil.TransferBinaries(kcfg, runner); err != nil {
+	sm := sysinit.New(runner)
+
+	if err := bsutil.TransferBinaries(kcfg, runner, sm); err != nil {
 		return errors.Wrap(err, "transferring k8s binaries")
 	}
 	// Create image tarball

pkg/drivers/kic/kic.go

@@ -37,7 +37,7 @@ import (
 	"k8s.io/minikube/pkg/minikube/constants"
 	"k8s.io/minikube/pkg/minikube/cruntime"
 	"k8s.io/minikube/pkg/minikube/download"
-	"k8s.io/minikube/pkg/minikube/kubelet"
+	"k8s.io/minikube/pkg/minikube/sysinit"
 )
 
 // Driver represents a kic driver https://minikube.sigs.k8s.io/docs/reference/drivers/docker
@@ -245,7 +245,7 @@ func (d *Driver) GetState() (state.State, error) {
 func (d *Driver) Kill() error {
 	// on init this doesn't get filled when called from cmd
 	d.exec = command.NewKICRunner(d.MachineName, d.OCIBinary)
-	if err := kubelet.ForceStop(d.exec); err != nil {
+	if err := sysinit.New(d.exec).ForceStop("kubelet"); err != nil {
 		glog.Warningf("couldn't force stop kubelet. will continue with kill anyways: %v", err)
 	}
 	cmd := exec.Command(d.NodeConfig.OCIBinary, "kill", d.MachineName)
@@ -318,9 +318,9 @@ func (d *Driver) Stop() error {
 	d.exec = command.NewKICRunner(d.MachineName, d.OCIBinary)
 	// docker does not send right SIG for systemd to know to stop the systemd.
 	// to avoid bind address be taken on an upgrade. more info https://github.com/kubernetes/minikube/issues/7171
-	if err := kubelet.Stop(d.exec); err != nil {
+	if err := sysinit.New(d.exec).Stop("kubelet"); err != nil {
 		glog.Warningf("couldn't stop kubelet. will continue with stop anyways: %v", err)
-		if err := kubelet.ForceStop(d.exec); err != nil {
+		if err := sysinit.New(d.exec).ForceStop("kubelet"); err != nil {
 			glog.Warningf("couldn't force stop kubelet. will continue with stop anyways: %v", err)
 		}
 	}

pkg/drivers/none/none.go

@@ -31,7 +31,7 @@ import (
 	"k8s.io/minikube/pkg/minikube/constants"
 	"k8s.io/minikube/pkg/minikube/cruntime"
 	"k8s.io/minikube/pkg/minikube/kubeconfig"
-	"k8s.io/minikube/pkg/minikube/kubelet"
+	"k8s.io/minikube/pkg/minikube/sysinit"
 	"k8s.io/minikube/pkg/minikube/vmpath"
 )
 
@@ -142,12 +142,12 @@ func (d *Driver) GetState() (state.State, error) {
 		return state.Running, nil
 	}
 
-	return kverify.KubeletStatus(d.exec)
+	return kverify.KubeletStatus(d.exec), nil
 }
 
 // Kill stops a host forcefully, including any containers that we are managing.
 func (d *Driver) Kill() error {
-	if err := kubelet.ForceStop(d.exec); err != nil {
+	if err := sysinit.New(d.exec).ForceStop("kubelet"); err != nil {
 		glog.Warningf("couldn't force stop kubelet. will continue with kill anyways: %v", err)
 	}
 
@@ -211,9 +211,9 @@ func (d *Driver) Start() error {
 
 // Stop a host gracefully, including any containers that we are managing.
 func (d *Driver) Stop() error {
-	if err := kubelet.Stop(d.exec); err != nil {
+	if err := sysinit.New(d.exec).Stop("kubelet"); err != nil {
 		glog.Warningf("couldn't stop kubelet. will continue with stop anyways: %v", err)
-		if err := kubelet.ForceStop(d.exec); err != nil {
+		if err := sysinit.New(d.exec).ForceStop("kubelet"); err != nil {
 			glog.Warningf("couldn't force stop kubelet. will continue with stop anyways: %v", err)
 		}
 	}

pkg/minikube/bootstrapper/bootstrapper.go

@@ -45,7 +45,6 @@ type Bootstrapper interface {
 	// LogCommands returns a map of log type to a command which will display that log.
 	LogCommands(config.ClusterConfig, LogOptions) map[string]string
 	SetupCerts(config.KubernetesConfig, config.Node) error
-	GetKubeletStatus() (string, error)
 	GetAPIServerStatus(string, int) (string, error)
 }
 

pkg/minikube/bootstrapper/bsutil/binaries.go

@@ -32,11 +32,12 @@ import (
 	"k8s.io/minikube/pkg/minikube/constants"
 	"k8s.io/minikube/pkg/minikube/download"
 	"k8s.io/minikube/pkg/minikube/machine"
+	"k8s.io/minikube/pkg/minikube/sysinit"
 	"k8s.io/minikube/pkg/minikube/vmpath"
 )
 
 // TransferBinaries transfers all required Kubernetes binaries
-func TransferBinaries(cfg config.KubernetesConfig, c command.Runner) error {
+func TransferBinaries(cfg config.KubernetesConfig, c command.Runner, sm sysinit.Manager) error {
 	ok, err := binariesExist(cfg, c)
 	if err == nil && ok {
 		glog.Info("Found k8s binaries, skipping transfer")
@@ -50,11 +51,6 @@ func TransferBinaries(cfg config.KubernetesConfig, c command.Runner) error {
 		return err
 	}
 
-	// stop kubelet to avoid "Text File Busy" error
-	if _, err := c.RunCmd(exec.Command("/bin/bash", "-c", "pgrep kubelet && sudo systemctl stop kubelet")); err != nil {
-		glog.Warningf("unable to stop kubelet: %s", err)
-	}
-
 	var g errgroup.Group
 	for _, name := range constants.KubernetesReleaseBinaries {
 		name := name
@@ -64,6 +60,12 @@ func TransferBinaries(cfg config.KubernetesConfig, c command.Runner) error {
 				return errors.Wrapf(err, "downloading %s", name)
 			}
 
+			if name == "kubelet" {
+				if err := sm.ForceStop("kubelet"); err != nil {
+					glog.Errorf("unable to stop kubelet: %v", err)
+				}
+			}
+
 			dst := path.Join(dir, name)
 			if err := machine.CopyBinary(c, src, dst); err != nil {
 				return errors.Wrapf(err, "copybinary %s -> %s", src, dst)

pkg/minikube/bootstrapper/bsutil/files.go

@@ -20,8 +20,6 @@ package bsutil
 import (
 	"path"
 
-	"k8s.io/minikube/pkg/minikube/assets"
-	"k8s.io/minikube/pkg/minikube/config"
 	"k8s.io/minikube/pkg/minikube/vmpath"
 )
 
@@ -35,20 +33,8 @@ const (
 	KubeletServiceFile = "/lib/systemd/system/kubelet.service"
 	// KubeletSystemdConfFile is config for the systemd kubelet.service
 	KubeletSystemdConfFile = "/etc/systemd/system/kubelet.service.d/10-kubeadm.conf"
+	// InitRestartWrapper is ...
+	InitRestartWrapper = "/etc/init.d/.restart_wrapper.sh"
+	// KubeletInitPath is where Sys-V style init script is installed
+	KubeletInitPath = "/etc/init.d/kubelet"
 )
-
-// ConfigFileAssets returns configuration file assets
-func ConfigFileAssets(cfg config.KubernetesConfig, kubeadm []byte, kubelet []byte, kubeletSvc []byte, defaultCNIConfig []byte) []assets.CopyableFile {
-	fs := []assets.CopyableFile{
-		assets.NewMemoryAssetTarget(kubeadm, KubeadmYamlPath+".new", "0640"),
-		assets.NewMemoryAssetTarget(kubelet, KubeletSystemdConfFile+".new", "0644"),
-		assets.NewMemoryAssetTarget(kubeletSvc, KubeletServiceFile+".new", "0644"),
-	}
-	// Copy the default CNI config (k8s.conf), so that kubelet can successfully
-	// start a Pod in the case a user hasn't manually installed any CNI plugin
-	// and minikube was started with "--extra-config=kubelet.network-plugin=cni".
-	if defaultCNIConfig != nil {
-		fs = append(fs, assets.NewMemoryAssetTarget(defaultCNIConfig, DefaultCNIConfigPath, "0644"))
-	}
-	return fs
-}

pkg/minikube/bootstrapper/bsutil/kverify/system_pods.go

@@ -19,7 +19,6 @@ package kverify
 
 import (
 	"fmt"
-	"os/exec"
 	"strings"
 	"time"
 
@@ -36,6 +35,7 @@ import (
 	"k8s.io/minikube/pkg/minikube/config"
 	"k8s.io/minikube/pkg/minikube/cruntime"
 	"k8s.io/minikube/pkg/minikube/logs"
+	"k8s.io/minikube/pkg/minikube/sysinit"
 )
 
 // WaitForSystemPods verifies essential pods for running kurnetes is running
@@ -156,22 +156,11 @@ func announceProblems(r cruntime.Manager, bs bootstrapper.Bootstrapper, cfg conf
 }
 
 // KubeletStatus checks the kubelet status
-func KubeletStatus(cr command.Runner) (state.State, error) {
+func KubeletStatus(cr command.Runner) state.State {
 	glog.Infof("Checking kubelet status ...")
-	rr, err := cr.RunCmd(exec.Command("sudo", "systemctl", "is-active", "kubelet"))
-	if err != nil {
-		// Do not return now, as we still have parsing to do!
-		glog.Warningf("%s returned error: %v", rr.Command(), err)
-	}
-	s := strings.TrimSpace(rr.Stdout.String())
-	glog.Infof("kubelet is-active: %s", s)
-	switch s {
-	case "active":
-		return state.Running, nil
-	case "inactive":
-		return state.Stopped, nil
-	case "activating":
-		return state.Starting, nil
+	active := sysinit.New(cr).Active("kubelet")
+	if active {
+		return state.Running
 	}
-	return state.Error, nil
+	return state.Stopped
 }