run: Pass command options to drivers

Some drivers need command line options since they need to pass command
line options back to minikube firewall package. The way to pass command
line options to the driver is via the NewDriver function, called by the
registry Loader function.

The registry Loader function is called by machine.LocalClient.Load,
which is part of the limachine API interface, which is not part of
minikube so we cannot change it. We pass the options to
machine.NewAPIClient(), so the client can pass the options to Load().

Some drivers need to validate vment helper in the registry StatusChecker
function, considering the --interactive and --download-only flags. So we
pas the options to the StatusChecker function.

This change create the options in most commands that call
machine.NewAPIClient or registry StatusChecker function and pass the
options down.

Author: nirs

cmd/minikube/cmd/cache.go

@@ -21,6 +21,7 @@ import (
 	"github.com/spf13/viper"
 	"k8s.io/klog/v2"
 	cmdConfig "k8s.io/minikube/cmd/minikube/cmd/config"
+	"k8s.io/minikube/cmd/minikube/cmd/flags"
 	"k8s.io/minikube/pkg/minikube/config"
 	"k8s.io/minikube/pkg/minikube/exit"
 	"k8s.io/minikube/pkg/minikube/image"
@@ -49,8 +50,9 @@ var addCacheCmd = &cobra.Command{
 	Long:  "Add an image to local cache.",
 	Run: func(_ *cobra.Command, args []string) {
 		out.WarningT("\"minikube cache\" will be deprecated in upcoming versions, please switch to \"minikube image load\"")
+		options := flags.CommandOptions()
 		// Cache and load images into docker daemon
-		if err := machine.CacheAndLoadImages(args, cacheAddProfiles(), false); err != nil {
+		if err := machine.CacheAndLoadImages(args, cacheAddProfiles(), false, options); err != nil {
 			exit.Error(reason.InternalCacheLoad, "Failed to cache and load images", err)
 		}
 		// Add images to config file
@@ -103,7 +105,8 @@ var reloadCacheCmd = &cobra.Command{
 	Short: "reload cached images.",
 	Long:  "reloads images previously added using the 'cache add' subcommand",
 	Run: func(_ *cobra.Command, _ []string) {
-		err := node.CacheAndLoadImagesInConfig(cacheAddProfiles())
+		options := flags.CommandOptions()
+		err := node.CacheAndLoadImagesInConfig(cacheAddProfiles(), options)
 		if err != nil {
 			exit.Error(reason.GuestCacheLoad, "Failed to reload cached images", err)
 		}

cmd/minikube/cmd/config/addons_list.go

@@ -28,6 +28,7 @@ import (
 	"github.com/olekukonko/tablewriter/tw"
 	"github.com/spf13/cobra"
 	"k8s.io/klog/v2"
+	"k8s.io/minikube/cmd/minikube/cmd/flags"
 	"k8s.io/minikube/pkg/minikube/assets"
 	"k8s.io/minikube/pkg/minikube/config"
 	"k8s.io/minikube/pkg/minikube/exit"
@@ -55,9 +56,10 @@ var addonsListCmd = &cobra.Command{
 			exit.Message(reason.Usage, "usage: minikube addons list")
 		}
 
+		options := flags.CommandOptions()
 		var cc *config.ClusterConfig
 		if config.ProfileExists(ClusterFlagValue()) {
-			_, cc = mustload.Partial(ClusterFlagValue())
+			_, cc = mustload.Partial(ClusterFlagValue(), options)
 		}
 		switch strings.ToLower(addonListOutput) {
 		case "list":

cmd/minikube/cmd/config/configure.go

@@ -27,6 +27,7 @@ import (
 
 	"github.com/spf13/cobra"
 	"k8s.io/klog/v2"
+	"k8s.io/minikube/cmd/minikube/cmd/flags"
 	"k8s.io/minikube/pkg/addons"
 	"k8s.io/minikube/pkg/minikube/assets"
 	"k8s.io/minikube/pkg/minikube/cluster"
@@ -37,6 +38,7 @@ import (
 	"k8s.io/minikube/pkg/minikube/mustload"
 	"k8s.io/minikube/pkg/minikube/out"
 	"k8s.io/minikube/pkg/minikube/reason"
+	"k8s.io/minikube/pkg/minikube/run"
 	"k8s.io/minikube/pkg/minikube/style"
 	"k8s.io/minikube/pkg/minikube/sysinit"
 )
@@ -59,6 +61,7 @@ var addonsConfigureCmd = &cobra.Command{
 			exit.Message(reason.Usage, "usage: minikube addons configure ADDON_NAME")
 		}
 
+		options := flags.CommandOptions()
 		profile := ClusterFlagValue()
 		addon := args[0]
 		addonConfig := loadAddonConfigFile(addon, addonConfigFile)
@@ -69,16 +72,16 @@ var addonsConfigureCmd = &cobra.Command{
 			processRegistryCredsConfig(profile, addonConfig)
 
 		case "metallb":
-			processMetalLBConfig(profile, addonConfig)
+			processMetalLBConfig(profile, addonConfig, options)
 
 		case "ingress":
-			processIngressConfig(profile, addonConfig)
+			processIngressConfig(profile, addonConfig, options)
 
 		case "registry-aliases":
-			processRegistryAliasesConfig(profile, addonConfig)
+			processRegistryAliasesConfig(profile, addonConfig, options)
 
 		case "auto-pause":
-			processAutoPauseConfig(profile, addonConfig)
+			processAutoPauseConfig(profile, addonConfig, options)
 
 		default:
 			out.FailureT("{{.name}} has no available configuration options", out.V{"name": addon})
@@ -162,8 +165,8 @@ func loadAddonConfigFile(addon, configFilePath string) (ac *addonConfig) {
 }
 
 // Processes metallb addon config from configFile if it exists otherwise resorts to default behavior
-func processMetalLBConfig(profile string, _ *addonConfig) {
-	_, cfg := mustload.Partial(profile)
+func processMetalLBConfig(profile string, _ *addonConfig, options *run.CommandOptions) {
+	_, cfg := mustload.Partial(profile, options)
 
 	validator := func(s string) bool {
 		return net.ParseIP(s) != nil
@@ -178,14 +181,14 @@ func processMetalLBConfig(profile string, _ *addonConfig) {
 	}
 
 	// Re-enable metallb addon in order to generate template manifest files with Load Balancer Start/End IP
-	if err := addons.EnableOrDisableAddon(cfg, "metallb", "true"); err != nil {
+	if err := addons.EnableOrDisableAddon(cfg, "metallb", "true", options); err != nil {
 		out.ErrT(style.Fatal, "Failed to configure metallb IP {{.profile}}", out.V{"profile": profile})
 	}
 }
 
 // Processes ingress addon config from configFile if it exists otherwise resorts to default behavior
-func processIngressConfig(profile string, _ *addonConfig) {
-	_, cfg := mustload.Partial(profile)
+func processIngressConfig(profile string, _ *addonConfig, options *run.CommandOptions) {
+	_, cfg := mustload.Partial(profile, options)
 
 	validator := func(s string) bool {
 		format := regexp.MustCompile("^.+/.+$")
@@ -208,8 +211,8 @@ func processIngressConfig(profile string, _ *addonConfig) {
 }
 
 // Processes auto-pause addon config from configFile if it exists otherwise resorts to default behavior
-func processAutoPauseConfig(profile string, _ *addonConfig) {
-	lapi, cfg := mustload.Partial(profile)
+func processAutoPauseConfig(profile string, _ *addonConfig, options *run.CommandOptions) {
+	lapi, cfg := mustload.Partial(profile, options)
 	intervalInput := AskForStaticValue("-- Enter interval time of auto-pause-interval (ex. 1m0s): ")
 	intervalTime, err := time.ParseDuration(intervalInput)
 	if err != nil {
@@ -234,11 +237,11 @@ func processAutoPauseConfig(profile string, _ *addonConfig) {
 			out.ErrT(style.Fatal, "failed to load profile: {{.error}}", out.V{"error": err})
 		}
 		if profileStatus(p, lapi).StatusCode/100 == 2 { // 2xx code
-			co := mustload.Running(profile)
+			co := mustload.Running(profile, options)
 			// first unpause all nodes cluster immediately
 			unpauseWholeCluster(co)
 			// Re-enable auto-pause addon in order to update interval time
-			if err := addons.EnableOrDisableAddon(cfg, "auto-pause", "true"); err != nil {
+			if err := addons.EnableOrDisableAddon(cfg, "auto-pause", "true", options); err != nil {
 				out.ErrT(style.Fatal, "Failed to configure auto-pause {{.profile}}", out.V{"profile": profile})
 			}
 			// restart auto-pause service
@@ -250,8 +253,8 @@ func processAutoPauseConfig(profile string, _ *addonConfig) {
 }
 
 // Processes registry-aliases addon config from configFile if it exists otherwise resorts to default behavior
-func processRegistryAliasesConfig(profile string, _ *addonConfig) {
-	_, cfg := mustload.Partial(profile)
+func processRegistryAliasesConfig(profile string, _ *addonConfig, options *run.CommandOptions) {
+	_, cfg := mustload.Partial(profile, options)
 	validator := func(s string) bool {
 		format := regexp.MustCompile(`^([a-zA-Z0-9-_]+\.[a-zA-Z0-9-_]+)+(\ [a-zA-Z0-9-_]+\.[a-zA-Z0-9-_]+)*$`)
 		return format.MatchString(s)
@@ -266,7 +269,7 @@ func processRegistryAliasesConfig(profile string, _ *addonConfig) {
 	addon := assets.Addons["registry-aliases"]
 	if addon.IsEnabled(cfg) {
 		// Re-enable registry-aliases addon in order to generate template manifest files with custom hosts
-		if err := addons.EnableOrDisableAddon(cfg, "registry-aliases", "true"); err != nil {
+		if err := addons.EnableOrDisableAddon(cfg, "registry-aliases", "true", options); err != nil {
 			out.ErrT(style.Fatal, "Failed to configure registry-aliases {{.profile}}", out.V{"profile": profile})
 		}
 	}

cmd/minikube/cmd/config/disable.go

@@ -18,6 +18,7 @@ package config
 
 import (
 	"github.com/spf13/cobra"
+	"k8s.io/minikube/cmd/minikube/cmd/flags"
 	"k8s.io/minikube/pkg/addons"
 	"k8s.io/minikube/pkg/minikube/assets"
 	"k8s.io/minikube/pkg/minikube/exit"
@@ -35,8 +36,10 @@ var addonsDisableCmd = &cobra.Command{
 		if len(args) != 1 {
 			exit.Message(reason.Usage, "usage: minikube addons disable ADDON_NAME")
 		}
-		_, cc := mustload.Partial(ClusterFlagValue())
-		err := addons.VerifyNotPaused(ClusterFlagValue(), false)
+
+		options := flags.CommandOptions()
+		_, cc := mustload.Partial(ClusterFlagValue(), options)
+		err := addons.VerifyNotPaused(ClusterFlagValue(), false, options)
 		if err != nil {
 			exit.Error(reason.InternalAddonDisablePaused, "disable failed", err)
 		}
@@ -49,7 +52,7 @@ var addonsDisableCmd = &cobra.Command{
 			exit.Message(reason.AddonUnsupported, `"'{{.minikube_addon}}' is not a valid minikube addon`, out.V{"minikube_addon": addon})
 		}
 		if validAddon.IsEnabled(cc) {
-			err = addons.SetAndSave(ClusterFlagValue(), addon, "false")
+			err = addons.SetAndSave(ClusterFlagValue(), addon, "false", options)
 			if err != nil {
 				exit.Error(reason.InternalAddonDisable, "disable failed", err)
 			}

cmd/minikube/cmd/config/enable.go

@@ -21,6 +21,7 @@ import (
 
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
+	"k8s.io/minikube/cmd/minikube/cmd/flags"
 	"k8s.io/minikube/pkg/addons"
 	"k8s.io/minikube/pkg/minikube/assets"
 	"k8s.io/minikube/pkg/minikube/config"
@@ -41,12 +42,14 @@ var addonsEnableCmd = &cobra.Command{
 		if len(args) != 1 {
 			exit.Message(reason.Usage, "usage: minikube addons enable ADDON_NAME")
 		}
-		_, cc := mustload.Partial(ClusterFlagValue())
+
+		options := flags.CommandOptions()
+		_, cc := mustload.Partial(ClusterFlagValue(), options)
 		if cc.KubernetesConfig.KubernetesVersion == constants.NoKubernetesVersion {
 			exit.Message(reason.Usage, "You cannot enable addons on a cluster without Kubernetes, to enable Kubernetes on your cluster, run: minikube start --kubernetes-version=stable")
 		}
 
-		err := addons.VerifyNotPaused(ClusterFlagValue(), true)
+		err := addons.VerifyNotPaused(ClusterFlagValue(), true, options)
 		if err != nil {
 			exit.Error(reason.InternalAddonEnablePaused, "enabled failed", err)
 		}
@@ -83,7 +86,7 @@ You can view the list of minikube maintainers at: https://github.com/kubernetes/
 		if registries != "" {
 			viper.Set(config.AddonRegistries, registries)
 		}
-		err = addons.SetAndSave(ClusterFlagValue(), addon, "true")
+		err = addons.SetAndSave(ClusterFlagValue(), addon, "true", options)
 		if err != nil && !errors.Is(err, addons.ErrSkipThisAddon) {
 			exit.Error(reason.InternalAddonEnable, "enable failed", err)
 		}

cmd/minikube/cmd/config/open.go

@@ -21,6 +21,7 @@ import (
 	"text/template"
 
 	"github.com/spf13/cobra"
+	"k8s.io/minikube/cmd/minikube/cmd/flags"
 	"k8s.io/minikube/pkg/minikube/assets"
 	"k8s.io/minikube/pkg/minikube/browser"
 	"k8s.io/minikube/pkg/minikube/exit"
@@ -57,10 +58,12 @@ var addonsOpenCmd = &cobra.Command{
 		if len(args) != 1 {
 			exit.Message(reason.Usage, "usage: minikube addons open ADDON_NAME")
 		}
+
+		options := flags.CommandOptions()
 		addonName := args[0]
 
 		cname := ClusterFlagValue()
-		co := mustload.Healthy(cname)
+		co := mustload.Healthy(cname, options)
 
 		addon, ok := assets.Addons[addonName] // validate addon input
 		if !ok {

cmd/minikube/cmd/config/profile_list.go

@@ -23,6 +23,7 @@ import (
 	"strconv"
 	"strings"
 
+	"k8s.io/minikube/cmd/minikube/cmd/flags"
 	"k8s.io/minikube/pkg/minikube/cluster"
 	"k8s.io/minikube/pkg/minikube/config"
 	"k8s.io/minikube/pkg/minikube/constants"
@@ -31,6 +32,7 @@ import (
 	"k8s.io/minikube/pkg/minikube/notify"
 	"k8s.io/minikube/pkg/minikube/out"
 	"k8s.io/minikube/pkg/minikube/reason"
+	"k8s.io/minikube/pkg/minikube/run"
 	"k8s.io/minikube/pkg/minikube/style"
 
 	"github.com/docker/machine/libmachine"
@@ -52,15 +54,16 @@ var profileListCmd = &cobra.Command{
 	Short: "Lists all minikube profiles.",
 	Long:  "Lists all valid minikube profiles and detects all possible invalid profiles.",
 	Run: func(_ *cobra.Command, _ []string) {
+		options := flags.CommandOptions()
 		output := strings.ToLower(profileOutput)
 		out.SetJSON(output == "json")
 		go notify.MaybePrintUpdateTextFromGithub()
 
 		switch output {
 		case "json":
-			printProfilesJSON()
+			printProfilesJSON(options)
 		case "table":
-			printProfilesTable()
+			printProfilesTable(options)
 		default:
 			exit.Message(reason.Usage, fmt.Sprintf("invalid output format: %s. Valid values: 'table', 'json'", profileOutput))
 		}
@@ -77,7 +80,7 @@ func listProfiles() (validProfiles, invalidProfiles []*config.Profile, err error
 	return validProfiles, invalidProfiles, err
 }
 
-func printProfilesTable() {
+func printProfilesTable(options *run.CommandOptions) {
 	validProfiles, invalidProfiles, err := listProfiles()
 
 	if err != nil {
@@ -88,20 +91,20 @@ func printProfilesTable() {
 		exit.Message(reason.UsageNoProfileRunning, "No minikube profile was found.")
 	}
 
-	updateProfilesStatus(validProfiles)
+	updateProfilesStatus(validProfiles, options)
 	renderProfilesTable(profilesToTableData(validProfiles))
 	warnInvalidProfiles(invalidProfiles)
 }
 
-func updateProfilesStatus(profiles []*config.Profile) {
+func updateProfilesStatus(profiles []*config.Profile, options *run.CommandOptions) {
 	if isLight {
 		for _, p := range profiles {
 			p.Status = "Skipped"
 		}
 		return
 	}
 
-	api, err := machine.NewAPIClient()
+	api, err := machine.NewAPIClient(options)
 	if err != nil {
 		klog.Errorf("failed to get machine api client %v", err)
 	}
@@ -205,9 +208,9 @@ func warnInvalidProfiles(invalidProfiles []*config.Profile) {
 	}
 }
 
-func printProfilesJSON() {
+func printProfilesJSON(options *run.CommandOptions) {
 	validProfiles, invalidProfiles, err := listProfiles()
-	updateProfilesStatus(validProfiles)
+	updateProfilesStatus(validProfiles, options)
 
 	var body = map[string]interface{}{}
 	if err == nil || config.IsNotExist(err) {

cmd/minikube/cmd/config/set.go

@@ -56,7 +56,7 @@ func Set(name string, value string) error {
 		return errors.Wrapf(err, "find settings for %q value of %q", name, value)
 	}
 	// Validate the new value
-	err = run(name, value, s.validations)
+	err = invoke(name, value, s.validations)
 	if err != nil {
 		return errors.Wrapf(err, "run validations for %q with value of %q", name, value)
 	}
@@ -72,7 +72,7 @@ func Set(name string, value string) error {
 	}
 
 	// Run any callbacks for this property
-	err = run(name, value, s.callbacks)
+	err = invoke(name, value, s.callbacks)
 	if err != nil {
 		return errors.Wrapf(err, "run callbacks for %q with value of %q", name, value)
 	}

cmd/minikube/cmd/config/util.go

@@ -25,8 +25,8 @@ import (
 	"k8s.io/minikube/pkg/minikube/out"
 )
 
-// Runs all the validation or callback functions and collects errors
-func run(name string, value string, fns []setFn) error {
+// Invoke all the validation or callback functions and collects errors
+func invoke(name string, value string, fns []setFn) error {
 	var errors []error
 	for _, fn := range fns {
 		err := fn(name, value)

cmd/minikube/cmd/cp.go

@@ -27,6 +27,7 @@ import (
 	pt "path"
 	"strings"
 
+	"k8s.io/minikube/cmd/minikube/cmd/flags"
 	"k8s.io/minikube/pkg/minikube/assets"
 	"k8s.io/minikube/pkg/minikube/command"
 	"k8s.io/minikube/pkg/minikube/exit"
@@ -54,17 +55,18 @@ Example Command : "minikube cp a.txt /home/docker/b.txt" +
                   "minikube cp minikube-m01:a.txt minikube-m02:/home/docker/b.txt"`,
 	Run: func(_ *cobra.Command, args []string) {
 		if len(args) != 2 {
-			exit.Message(reason.Usage, `Please specify the path to copy: 
+			exit.Message(reason.Usage, `Please specify the path to copy:
 	minikube cp <source file path> <target file absolute path> (example: "minikube cp a/b.txt /copied.txt")`)
 		}
 
+		options := flags.CommandOptions()
 		srcPath := args[0]
 		dstPath := setDstFileNameFromSrc(args[1], srcPath)
 		src := newRemotePath(srcPath)
 		dst := newRemotePath(dstPath)
 		validateArgs(src, dst)
 
-		co := mustload.Running(ClusterFlagValue())
+		co := mustload.Running(ClusterFlagValue(), options)
 		var runner command.Runner
 
 		if dst.node != "" {