hyperkit driver should be happy with current minimum verison

pkg/minikube/driver/install.go

@@ -41,30 +41,37 @@ func InstallOrUpdate(name string, directory string, v semver.Version, interactiv
 	if name != KVM2 && name != HyperKit {
 		return nil
 	}
+	path, err := AssureDriverBinary(name, directory, v, autoUpdate)
+	if err != nil {
+		return err
+	}
+	return fixDriverPermissions(name, path, interactive)
+}
 
+// AssureDriverBinary does the same as InstallOrUpdate
+// but doesn't set root permissions in case the driver is downloaded
+func AssureDriverBinary(name string, directory string, v semver.Version, autoUpdate bool) (string, error) {
 	executable := fmt.Sprintf("docker-machine-driver-%s", name)
 
-	// Lock before we check for existence to avoid thundering herd issues
 	spec := lock.PathMutexSpec(executable)
 	spec.Timeout = 10 * time.Minute
 	glog.Infof("acquiring lock: %+v", spec)
 	releaser, err := mutex.Acquire(spec)
 	if err != nil {
-		return errors.Wrapf(err, "unable to acquire lock for %+v", spec)
+		return "", errors.Wrapf(err, "unable to acquire lock for %+v", spec)
 	}
 	defer releaser.Release()
 
 	exists := driverExists(executable)
-	path, err := validateDriver(executable, v)
+	path, err := validateDriver(executable, minAcceptableDriverVersion(name, v))
 	if !exists || (err != nil && autoUpdate) {
 		glog.Warningf("%s: %v", executable, err)
 		path = filepath.Join(directory, executable)
-		derr := download.Driver(executable, path, v)
-		if derr != nil {
-			return derr
+		if err := download.Driver(executable, path, v); err != nil {
+			return "", err
 		}
 	}
-	return fixDriverPermissions(name, path, interactive)
+	return path, nil
 }
 
 // fixDriverPermissions fixes the permissions on a driver
@@ -133,6 +140,7 @@ func validateDriver(executable string, v semver.Version) (string, error) {
 	if err != nil {
 		return path, errors.Wrap(err, "can't parse driver version")
 	}
+
 	if driverVersion.LT(v) {
 		return path, fmt.Errorf("%s is version %s, want %s", executable, driverVersion, v)
 	}

pkg/minikube/driver/version.go

@@ -0,0 +1,52 @@
+/*
+Copyright 2020 The Kubernetes Authors All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package driver
+
+import (
+	"github.com/blang/semver"
+	"github.com/golang/glog"
+)
+
+// minHyperkitVersion is the minimum version of the minikube hyperkit driver compatible with the current minikube code
+var minHyperkitVersion *semver.Version
+
+const minHyperkitVersionStr = "1.11.0"
+
+func init() {
+	v, err := semver.New(minHyperkitVersionStr)
+	if err != nil {
+		glog.Errorf("Failed to parse the hyperkit driver version: %v", err)
+	} else {
+		minHyperkitVersion = v
+	}
+}
+
+// minAcceptableDriverVersion is the minimum version of driver supported by current version of minikube
+func minAcceptableDriverVersion(driver string, mkVer semver.Version) semver.Version {
+	switch driver {
+	case HyperKit:
+		if minHyperkitVersion != nil {
+			return *minHyperkitVersion
+		}
+		return mkVer
+	case KVM2:
+		return mkVer
+	default:
+		glog.Warningf("Unexpected driver: %v", driver)
+		return mkVer
+	}
+}

pkg/minikube/driver/version_test.go

@@ -0,0 +1,52 @@
+/*
+Copyright 2020 The Kubernetes Authors All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package driver
+
+import (
+	"testing"
+
+	"github.com/blang/semver"
+)
+
+func Test_minDriverVersion(t *testing.T) {
+
+	tests := []struct {
+		desc   string
+		driver string
+		mkV    string
+		want   semver.Version
+	}{
+		{"Hyperkit", HyperKit, "1.1.1", *minHyperkitVersion},
+		{"Invalid", "_invalid_", "1.1.1", v("1.1.1")},
+		{"KVM2", KVM2, "1.1.1", v("1.1.1")},
+	}
+	for _, tt := range tests {
+		t.Run(tt.desc, func(t *testing.T) {
+			if got := minAcceptableDriverVersion(tt.driver, v(tt.mkV)); !got.EQ(tt.want) {
+				t.Errorf("Invalid min supported version, got: %v, want: %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func v(s string) semver.Version {
+	r, err := semver.New(s)
+	if err != nil {
+		panic(err)
+	}
+	return *r
+}

test/integration/driver_install_or_update_test.go

@@ -28,6 +28,7 @@ import (
 	"github.com/blang/semver"
 
 	"k8s.io/minikube/pkg/minikube/driver"
+	"k8s.io/minikube/pkg/version"
 )
 
 func TestKVMDriverInstallOrUpdate(t *testing.T) {
@@ -173,3 +174,85 @@ func TestHyperKitDriverInstallOrUpdate(t *testing.T) {
 		}
 	}
 }
+
+func TestHyperKitDriverSkipUpgrade(t *testing.T) {
+	if runtime.GOOS != "darwin" {
+		t.Skip("Skip if not darwin.")
+	}
+	MaybeParallel(t)
+	tests := []struct {
+		name             string
+		path             string
+		downloadExpected bool
+	}{
+		{
+			name:             "upgrade-v1.11.0-to-current",
+			path:             filepath.Join(*testdataDir, "hyperkit-driver-version-1.11.0"),
+			downloadExpected: false,
+		},
+		{
+			name:             "upgrade-v1.2.0-to-current",
+			path:             filepath.Join(*testdataDir, "hyperkit-driver-older-version"),
+			downloadExpected: true,
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			originalPath := os.Getenv("PATH")
+			defer func() {
+				if err := os.Setenv("PATH", originalPath); err != nil {
+					t.Errorf("failed to restore PATH: %v", err)
+				}
+			}()
+
+			dir, err := ioutil.TempDir("", tc.name)
+			if err != nil {
+				t.Fatalf("Expected to create tempdir. test: %s, got: %v", tc.name, err)
+			}
+			defer func() {
+				if err := os.RemoveAll(dir); err != nil {
+					t.Errorf("Failed to remove dir %q: %v", dir, err)
+				}
+			}()
+
+			pwd, err := os.Getwd()
+			if err != nil {
+				t.Fatalf("Error not expected when getting working directory. test: %s, got: %v", tc.name, err)
+			}
+
+			driverPath := filepath.Join(pwd, tc.path, "docker-machine-driver-hyperkit")
+			if _, err = os.Stat(driverPath); err != nil {
+				t.Fatalf("Expected driver to exist. test: %s, got: %v", tc.name, err)
+			}
+
+			// change permission to allow driver to be executable
+			if err = os.Chmod(driverPath, 0700); err != nil {
+				t.Fatalf("Expected not expected when changing driver permission. test: %s, got: %v", tc.name, err)
+			}
+
+			if err = os.Setenv("PATH", filepath.Dir(driverPath)); err != nil {
+				t.Fatalf("Unexpected error on SetEn, got: %v", err)
+			}
+			curVersion, err := version.GetSemverVersion()
+			if err != nil {
+				t.Fatalf("Expected new semver. test: %v, got: %v", tc.name, err)
+			}
+
+			if _, err = driver.AssureDriverBinary("hyperkit", dir, curVersion, true); err != nil {
+				t.Fatalf("Failed to update driver to %v. test: %s, got: %v", curVersion, tc.name, err)
+			}
+
+			_, err = os.Stat(filepath.Join(dir, "docker-machine-driver-hyperkit"))
+			if tc.downloadExpected {
+				if err != nil {
+					t.Fatalf("driver downlad expected. test: %s, got: %v", tc.name, err)
+				}
+			} else {
+				if err == nil {
+					t.Fatalf("driver downlad NOT expected. test: %s", tc.name)
+				}
+			}
+		})
+	}
+}

test/integration/testdata/hyperkit-driver-version-1.11.0/README

@@ -0,0 +1,2 @@
+Starting minikube version 1.13.1 we do not update the installed hyperkit driver if its version is 1.11.0 or higher.
+Have the hyperkit driver v1.11.0 here to test this behaviour.