kubernetes
/
minikube
mirror of https://github.com/kubernetes/minikube.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

get rid of ExecCmd all the way

pull/5530/head
Medya Gh 2019-10-08 15:13:54 -07:00
parent 927146361c
commit 91618aa38b
4 changed files with 45 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
pkg/drivers/none/none.go
View File

@ -19,6 +19,7 @@ package none
import (
"bytes"
"fmt"
"os/exec"
"strings"
"time"
@ -171,9 +172,9 @@ func (d *Driver) Remove() error {
return errors.Wrap(err, "kill")
}
glog.Infof("Removing: %s", cleanupPaths)
c := command.ExecCmd2(fmt.Sprintf("sudo rm -rf %s", strings.Join(cleanupPaths, " ")))
rr, err := d.exec.RunCmd(c)
if err != nil {
c := exec.Command("/bin/bash", "-c", fmt.Sprintf("sudo rm -rf %s", strings.Join(cleanupPaths, " ")))
if rr, err := d.exec.RunCmd(c); err != nil {
glog.Errorf("cleanup incomplete: %v , output: %s", err, rr.Output())
}
return nil
@ -224,18 +225,15 @@ func (d *Driver) RunSSHCommandFromDriver() error {
func stopKubelet(cr command.Runner) error {
glog.Infof("stopping kubelet.service ...")
stop := func() error {
cmdStop := command.ExecCmd2("sudo systemctl stop kubelet.service")
rr, err := cr.RunCmd(cmdStop)
if err != nil {
cmdStop := exec.Command("/bin/bash", "-c", "sudo systemctl stop kubelet.service")
if rr, err := cr.RunCmd(cmdStop); err != nil {
glog.Errorf("temporary error for %q : %v", rr.Command(), err)
}
var out bytes.Buffer
cmdCheck := command.ExecCmd2("sudo systemctl show -p SubState kubelet")
cmdCheck := exec.Command("/bin/bash", "-c", "sudo systemctl show -p SubState kubelet")
cmdCheck.Stdout = &out
cmdCheck.Stderr = &out
rr, err = cr.RunCmd(cmdCheck)
if err != nil {
if rr, err := cr.RunCmd(cmdCheck); err != nil {
glog.Errorf("temporary error: for %q : %v output: %q", rr.Command(), err, rr.Output())
}
if !strings.Contains(out.String(), "dead") && !strings.Contains(out.String(), "failed") {
@ -252,11 +250,11 @@ func stopKubelet(cr command.Runner) error {
}
// restartKubelet restarts the kubelet
func restartKubelet(exec command.Runner) error {
func restartKubelet(cr command.Runner) error {
glog.Infof("restarting kubelet.service ...")
rr, err := exec.RunCmd(command.ExecCmd2("sudo systemctl restart kubelet.service"))
if err != nil {
return errors.Wrapf(err, "restartKubelet with output: %s", rr.Output())
c := exec.Command("/bin/bash", "-c", "sudo systemctl restart kubelet.service")
if rr, err := cr.RunCmd(c); err != nil {
return errors.Wrapf(err, "restartKubelet output: %s", rr.Output())
}
return nil
}
@ -264,8 +262,8 @@ func restartKubelet(exec command.Runner) error {
// checkKubelet returns an error if the kubelet is not running.
func checkKubelet(cr command.Runner) error {
glog.Infof("checking for running kubelet ...")
rr, err := cr.RunCmd(command.ExecCmd2("systemctl is-active --quiet service kubelet"))
if err != nil {
c := exec.Command("/bin/bash", "-c", "systemctl is-active --quiet service kubelet")
if rr, err := cr.RunCmd(c); err != nil {
return errors.Wrapf(err, "checkKubelet output: %s", rr.Output())
}
return nil

21
pkg/minikube/bootstrapper/certs.go
View File

@ -22,6 +22,7 @@ import (
"io/ioutil"
"net"
"os"
"os/exec"
"path"
"path/filepath"
"strings"
@ -332,7 +333,8 @@ func getSubjectHash(cmd command.Runner, filePath string) (string, error) {
// OpenSSL binary required in minikube ISO
func configureCACerts(cr command.Runner, caCerts map[string]string) error {
hasSSLBinary := true
_, err := cr.RunCmd(command.ExecCmd("which openssl"))
c := exec.Command("/bin/bash", "-c", "which openssl")
_, err := cr.RunCmd(c)
if err != nil {
hasSSLBinary = false
}
@ -345,13 +347,13 @@ func configureCACerts(cr command.Runner, caCerts map[string]string) error {
dstFilename := path.Base(caCertFile)
certStorePath := path.Join(SSLCertStoreDir, dstFilename)
cmd := command.ExecCmd(fmt.Sprintf("sudo test -f '%s'", certStorePath))
_, err := cr.RunCmd(cmd)
c := exec.Command("/bin/bash", "-c", fmt.Sprintf("sudo test -f '%s'", certStorePath))
_, err := cr.RunCmd(c)
if err != nil {
cmd = command.ExecCmd(fmt.Sprintf("sudo ln -s '%s' '%s'", caCertFile, certStorePath))
rr, err := cr.RunCmd(cmd)
if err != nil {
return errors.Wrapf(err, "error making symbol link for certificate %s : %q", caCertFile, rr.Output())
c = exec.Command("/bin/bash", "-c", fmt.Sprintf("sudo ln -s '%s' '%s'", caCertFile, certStorePath))
if rr, err := cr.RunCmd(c); err != nil {
return errors.Wrapf(err, "error making symbol link for certificate %s output: %s", caCertFile, rr.Output())
}
}
if hasSSLBinary {
@ -360,9 +362,10 @@ func configureCACerts(cr command.Runner, caCerts map[string]string) error {
return errors.Wrapf(err, "error calculating subject hash for certificate %s", caCertFile)
}
subjectHashLink := path.Join(SSLCertStoreDir, fmt.Sprintf("%s.0", subjectHash))
_, err = cr.RunCmd(command.ExecCmd(fmt.Sprintf("sudo test -f '%s'", subjectHashLink)))
_, err = cr.RunCmd(exec.Command("/bin/bash", "-c", fmt.Sprintf("sudo test -f '%s'", subjectHashLink)))
if err != nil {
if rr, err := cr.RunCmd(command.ExecCmd(fmt.Sprintf("sudo ln -s '%s' '%s'", certStorePath, subjectHashLink))); err != nil {
if rr, err := cr.RunCmd(exec.Command("/bin/bash", "-c", fmt.Sprintf("sudo ln -s '%s' '%s'", certStorePath, subjectHashLink))); err != nil {
return errors.Wrapf(err, "error making subject hash symbol %s link for certificate %s. cmd: %q output: %q", subjectHash, caCertFile, rr.Command(), rr.Output())
}
}

51
pkg/minikube/bootstrapper/kubeadm/kubeadm.go
View File

@ -19,6 +19,7 @@ package kubeadm
import (
"bytes"
"crypto/tls"
"os/exec"
"fmt"
"net"
@ -136,8 +137,7 @@ func NewKubeadmBootstrapper(api libmachine.API) (*Bootstrapper, error) {
// GetKubeletStatus returns the kubelet status
func (k *Bootstrapper) GetKubeletStatus() (string, error) {
cmd := command.ExecCmd("sudo systemctl is-active kubelet")
rr, err := k.c.RunCmd(cmd)
rr, err := k.c.RunCmd(exec.Command("/bin/bash", "-c", "sudo systemctl is-active kubelet"))
if err != nil {
return "", errors.Wrapf(err, "getting kublet status. command: %q output: %q", rr.Command(), rr.Output())
}
@ -222,18 +222,15 @@ func etcdDataDir() string {
// createCompatSymlinks creates compatibility symlinks to transition running services to new directory structures
func (k *Bootstrapper) createCompatSymlinks() error {
legacyEtcd := "/data/minikube"
cmd := command.ExecCmd(fmt.Sprintf("sudo test -d %s", legacyEtcd))
rr, err := k.c.RunCmd(cmd)
rr, err := k.c.RunCmd(exec.Command(fmt.Sprintf("sudo test -d %s", legacyEtcd)))
if err != nil {
glog.Infof("%s check failed, skipping compat symlinks: %v %q", legacyEtcd, err, rr.Output())
return nil
}
glog.Infof("Found %s, creating compatibility symlinks ...", legacyEtcd)
cmd = command.ExecCmd(fmt.Sprintf("sudo ln -s %s %s", legacyEtcd, etcdDataDir()))
rr, err = k.c.RunCmd(cmd)
if err != nil {
c := exec.Command(fmt.Sprintf("sudo ln -s %s %s", legacyEtcd, etcdDataDir()))
if rr, err = k.c.RunCmd(c); err != nil {
return errors.Wrapf(err, "create symlink failed: %s\n%q\n", rr.Command(), rr.Output())
}
return nil
@ -276,11 +273,10 @@ func (k *Bootstrapper) StartCluster(k8s config.KubernetesConfig) error {
ignore = append(ignore, "SystemVerification")
}
c := fmt.Sprintf("%s init --config %s %s --ignore-preflight-errors=%s",
invokeKubeadm(k8s.KubernetesVersion), yamlConfigPath, extraFlags, strings.Join(ignore, ","))
rr, err := k.c.RunCmd(command.ExecCmd(c))
if err != nil {
return errors.Wrapf(err, "init failed. cmd: %q\noutput:%q\n", rr.Command(), rr.Output())
c := exec.Command("/bin/bash", "-c", fmt.Sprintf("%s init --config %s %s --ignore-preflight-errors=%s",
invokeKubeadm(k8s.KubernetesVersion), yamlConfigPath, extraFlags, strings.Join(ignore, ",")))
if rr, err := k.c.RunCmd(c); err != nil {
return errors.Wrapf(err, "init failed. cmd: %q output:%q", rr.Command(), rr.Output())
}
glog.Infof("Configuring cluster permissions ...")
@ -305,7 +301,7 @@ func (k *Bootstrapper) StartCluster(k8s config.KubernetesConfig) error {
// adjustResourceLimits makes fine adjustments to pod resources that aren't possible via kubeadm config.
func (k *Bootstrapper) adjustResourceLimits() error {
rr, err := k.c.RunCmd(command.ExecCmd("cat /proc/$(pgrep kube-apiserver)/oom_adj"))
rr, err := k.c.RunCmd(exec.Command("/bin/bash", "-c", "cat /proc/$(pgrep kube-apiserver)/oom_adj"))
if err != nil {
return errors.Wrap(err, "oom_adj check. command: %q output: %q")
}
@ -316,10 +312,9 @@ func (k *Bootstrapper) adjustResourceLimits() error {
}
glog.Infof("adjusting apiserver oom_adj to -10")
cmd := command.ExecCmd("echo -10 | sudo tee /proc/$(pgrep kube-apiserver)/oom_adj")
// Prevent the apiserver from OOM'ing before other pods, as it is our gateway into the cluster.
// It'd be preferable to do this via Kubernetes, but kubeadm doesn't have a way to set pod QoS.
rr, err = k.c.RunCmd(cmd)
rr, err = k.c.RunCmd(exec.Command("/bin/bash", "-c", "echo -10 | sudo tee /proc/$(pgrep kube-apiserver)/oom_adj"))
if err != nil {
return errors.Wrap(err, fmt.Sprintf("oom_adj adjust: %s", rr.Output()))
}
@ -441,8 +436,7 @@ func (k *Bootstrapper) RestartCluster(k8s config.KubernetesConfig) error {
// Run commands one at a time so that it is easier to root cause failures.
for _, c := range cmds {
cmd := command.ExecCmd(c)
rr, err := k.c.RunCmd(cmd)
rr, err := k.c.RunCmd(exec.Command("/bin/bash", "-c", c))
if err != nil {
return errors.Wrapf(err, "running cmd: %s , output: %s", rr.Command(), rr.Output())
}
@ -451,11 +445,9 @@ func (k *Bootstrapper) RestartCluster(k8s config.KubernetesConfig) error {
if err := k.waitForAPIServer(k8s); err != nil {
return errors.Wrap(err, "waiting for apiserver")
}
// restart the proxy and coredns
cmd := command.ExecCmd(fmt.Sprintf("%s phase addon all --config %s", baseCmd, yamlConfigPath))
rr, err := k.c.RunCmd(cmd)
if err != nil {
// restart the proxy and coredns
if rr, err := k.c.RunCmd(exec.Command(fmt.Sprintf("%s phase addon all --config %s", baseCmd, yamlConfigPath))); err != nil {
return errors.Wrapf(err, fmt.Sprintf("addon phase cmd:%q output:%q", rr.Command(), rr.Output()))
}
@ -476,8 +468,7 @@ func (k *Bootstrapper) waitForAPIServer(k8s config.KubernetesConfig) error {
// To give a better error message, first check for process existence via ssh
// Needs minutes in case the image isn't cached (such as with v1.10.x)
err := wait.PollImmediate(time.Millisecond*300, time.Minute*3, func() (bool, error) {
cmd := command.ExecCmd("sudo pgrep kube-apiserver")
rr, ierr := k.c.RunCmd(cmd)
rr, ierr := k.c.RunCmd(exec.Command("/bin/bash", "-c", "sudo pgrep kube-apiserver"))
if ierr != nil {
glog.Warningf("pgrep apiserver: %v cmd: %s output: %s", ierr, rr.Command(), rr.Output())
return false, nil
@ -521,8 +512,7 @@ func (k *Bootstrapper) DeleteCluster(k8s config.KubernetesConfig) error {
c = fmt.Sprintf("%s reset", invokeKubeadm(k8s.KubernetesVersion))
}
rr, err := k.c.RunCmd(command.ExecCmd(c))
if err != nil {
if rr, err := k.c.RunCmd(exec.Command("/bin/bash", "-c", c)); err != nil {
return errors.Wrapf(err, "kubeadm reset: cmd: %q\noutput:%q\n", rr.Command(), rr.Output())
}
@ -539,8 +529,7 @@ func (k *Bootstrapper) PullImages(k8s config.KubernetesConfig) error {
return fmt.Errorf("pull command is not supported by kubeadm v%s", version)
}
cmd := command.ExecCmd(fmt.Sprintf("%s config images pull --config %s", invokeKubeadm(k8s.KubernetesVersion), yamlConfigPath))
rr, err := k.c.RunCmd(cmd)
rr, err := k.c.RunCmd(exec.Command("/bin/bash", "-c", fmt.Sprintf("%s config images pull --config %s", invokeKubeadm(k8s.KubernetesVersion), yamlConfigPath)))
if err != nil {
return errors.Wrapf(err, "running cmd: %q output: %q", rr.Command(), rr.Output())
}
@ -637,8 +626,7 @@ func (k *Bootstrapper) UpdateCluster(cfg config.KubernetesConfig) error {
glog.Infof("kubelet %s config:\n%s", cfg.KubernetesVersion, kubeletCfg)
// stop kubelet to avoid "Text File Busy" error
rr, err := k.c.RunCmd(command.ExecCmd("pgrep kubelet && sudo systemctl stop kubelet"))
if err != nil {
if rr, err := k.c.RunCmd(exec.Command("/bin/bash", "-c", "pgrep kubelet && sudo systemctl stop kubelet")); err != nil {
glog.Warningf("unable to stop kubelet: %s command: %q output: %q", err, rr.Command(), rr.Output())
}
if err := transferBinaries(cfg, k.c); err != nil {
@ -654,8 +642,7 @@ func (k *Bootstrapper) UpdateCluster(cfg config.KubernetesConfig) error {
}
}
rr, err = k.c.RunCmd(command.ExecCmd("sudo systemctl daemon-reload && sudo systemctl start kubelet"))
if err != nil {
if rr, err := k.c.RunCmd(exec.Command("/bin/bash", "-c", "sudo systemctl daemon-reload && sudo systemctl start kubelet")); err != nil {
return errors.Wrapf(err, "starting kubelet command: %q output: %q", rr.Command(), rr.Output())
}
return nil

7
pkg/minikube/command/exec_runner.go
View File

@ -24,7 +24,6 @@ import (
"path"
"path/filepath"
"strconv"
"strings"
"time"
"github.com/golang/glog"
@ -32,12 +31,6 @@ import (
"k8s.io/minikube/pkg/minikube/assets"
)
// ExecCmd returns a exec.Cmd from a string
func ExecCmd(c string) *exec.Cmd {
args := strings.Split(c, " ") // maybe alternatively? ("/bin/bash", "-c", c)
return exec.Command(args[0], args[1:]...)
}
// ExecRunner runs commands using the os/exec package.
//
// It implements the CommandRunner interface.