Fix docker/containerd caching, improve msgs, add tests

cmd/minikube/cmd/start.go

@@ -237,7 +237,7 @@ func beginCacheImages(g *errgroup.Group, kVersion string) {
 	if !viper.GetBool(cacheImages) {
 		return
 	}
-	console.OutStyle("caching", "Caching images in the background ...")
+	console.OutStyle("caching", "Downloading Kubernetes %s images in the background ...", kVersion)
 	g.Go(func() error {
 		return machine.CacheImagesForBootstrapper(kVersion, viper.GetString(cmdcfg.Bootstrapper))
 	})
@@ -487,7 +487,7 @@ func waitCacheImages(g *errgroup.Group) {
 	if !viper.GetBool(cacheImages) {
 		return
 	}
-	console.OutStyle("waiting", "Waiting for image caching to complete ...")
+	console.OutStyle("waiting", "Waiting for image downloads to complete ...")
 	if err := g.Wait(); err != nil {
 		glog.Errorln("Error caching images: ", err)
 	}

pkg/minikube/bootstrapper/kubeadm/kubeadm.go

@@ -313,9 +313,8 @@ func NewKubeletConfig(k8s config.KubernetesConfig, r cruntime.Manager) (string,
 
 func (k *KubeadmBootstrapper) UpdateCluster(cfg config.KubernetesConfig) error {
 	if cfg.ShouldLoadCachedImages {
-		err := machine.LoadImages(k.c, constants.GetKubeadmCachedImages(cfg.KubernetesVersion), constants.ImageCacheDir)
-		if err != nil {
-			return errors.Wrap(err, "loading cached images")
+		if err := machine.LoadImages(k.c, constants.GetKubeadmCachedImages(cfg.KubernetesVersion), constants.ImageCacheDir); err != nil {
+			console.Failure("Unable to load cached images: %v", err)
 		}
 	}
 	r, err := cruntime.New(cruntime.Config{Type: cfg.ContainerRuntime, Socket: cfg.CRISocket})

pkg/minikube/cruntime/containerd.go

@@ -80,7 +80,7 @@ func (r *Containerd) Disable() error {
 // LoadImage loads an image into this runtime
 func (r *Containerd) LoadImage(path string) error {
 	glog.Infof("Loading image: %s", path)
-	return r.Runner.Run(fmt.Sprintf("sudo ctr cri load %s", path))
+	return r.Runner.Run(fmt.Sprintf("sudo ctr images import %s", path))
 }
 
 // KubeletOptions returns kubelet options for a containerd

pkg/minikube/cruntime/docker.go

@@ -73,7 +73,7 @@ func (r *Docker) Disable() error {
 // LoadImage loads an image into this runtime
 func (r *Docker) LoadImage(path string) error {
 	glog.Infof("Loading image: %s", path)
-	return r.Runner.Run(fmt.Sprintf("docker load -i %s", path))
+	return r.Runner.Run(fmt.Sprintf("sudo docker load -i %s", path))
 }
 
 // KubeletOptions returns kubelet options for a runtime.

test/integration/start_stop_delete_test.go

@@ -30,48 +30,47 @@ import (
 
 func TestStartStop(t *testing.T) {
 	tests := []struct {
-		runtime string
+		name string
+		args []string
 	}{
-		{runtime: "docker"},
-		{runtime: "containerd"},
-		{runtime: "crio"},
+		{"docker+cache", []string{"--container-runtime=docker", "--cache-images"}},
+		{"containerd+cache", []string{"--container-runtime=containerd", "--docker-opt containerd=/var/run/containerd/containerd.sock", "--cache-images"}},
+		{"crio+cache", []string{"--container-runtime=crio", "--cache-images"}},
 	}
 
 	for _, test := range tests {
-		t.Run(test.runtime, func(t *testing.T) {
-			runner := NewMinikubeRunner(t)
-			if test.runtime != "docker" && usingNoneDriver(runner) {
-				t.Skipf("skipping, can't use %s with none driver", test.runtime)
+		t.Run(test.name, func(t *testing.T) {
+			r := NewMinikubeRunner(t)
+			if !strings.Contains(test.name, "docker") && usingNoneDriver(r) {
+				t.Skipf("skipping %s - incompatible with none driver", test.name)
 			}
 
-			runner.RunCommand("config set WantReportErrorPrompt false", true)
-			runner.RunCommand("delete", false)
-			runner.CheckStatus(state.None.String())
+			r.RunCommand("config set WantReportErrorPrompt false", true)
+			r.RunCommand("delete", false)
+			r.CheckStatus(state.None.String())
+			r.Start(test.args...)
+			r.CheckStatus(state.Running.String())
 
-			runner.SetRuntime(test.runtime)
-			runner.Start()
-			runner.CheckStatus(state.Running.String())
-
-			ip := runner.RunCommand("ip", true)
+			ip := r.RunCommand("ip", true)
 			ip = strings.TrimRight(ip, "\n")
 			if net.ParseIP(ip) == nil {
 				t.Fatalf("IP command returned an invalid address: %s", ip)
 			}
 
 			checkStop := func() error {
-				runner.RunCommand("stop", true)
-				return runner.CheckStatusNoFail(state.Stopped.String())
+				r.RunCommand("stop", true)
+				return r.CheckStatusNoFail(state.Stopped.String())
 			}
 
 			if err := util.Retry(t, checkStop, 5*time.Second, 6); err != nil {
 				t.Fatalf("timed out while checking stopped status: %v", err)
 			}
 
-			runner.Start()
-			runner.CheckStatus(state.Running.String())
+			r.Start()
+			r.CheckStatus(state.Running.String())
 
-			runner.RunCommand("delete", true)
-			runner.CheckStatus(state.None.String())
+			r.RunCommand("delete", true)
+			r.CheckStatus(state.None.String())
 		})
 	}
 }

test/integration/util/util.go

@@ -202,17 +202,9 @@ func (m *MinikubeRunner) SSH(command string) (string, error) {
 	return string(stdout), nil
 }
 
-func (m *MinikubeRunner) Start() {
-	opts := ""
-	// TODO(tstromberg): Deprecate this in favor of making it possible for tests to define explicit flags.
-	switch r := m.Runtime; r {
-	case "containerd":
-		opts = "--container-runtime=containerd --docker-opt containerd=/var/run/containerd/containerd.sock"
-	case "crio":
-		opts = "--container-runtime=cri-o"
-	}
-	m.RunCommand(fmt.Sprintf("start %s %s %s --alsologtostderr --v=5", m.StartArgs, m.Args, opts), true)
-
+func (m *MinikubeRunner) Start(opts ...string) {
+	cmd := fmt.Sprintf("start %s %s %s --alsologtostderr --v=2", m.StartArgs, m.Args, strings.Join(opts, " "))
+	m.RunCommand(cmd, true)
 }
 
 func (m *MinikubeRunner) EnsureRunning() {