Remove viper from minikube and driver packages - part 1

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.Options()
 		// 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.Options()
+		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.Options()
 		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.Options()
 		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})
@@ -163,8 +166,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.Options) {
+	_, cfg := mustload.Partial(profile, options)
 
 	validator := func(s string) bool {
 		return net.ParseIP(s) != nil
@@ -179,14 +182,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.Options) {
+	_, cfg := mustload.Partial(profile, options)
 
 	validator := func(s string) bool {
 		format := regexp.MustCompile("^.+/.+$")
@@ -209,8 +212,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.Options) {
+	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 {
@@ -235,11 +238,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
@@ -251,8 +254,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.Options) {
+	_, 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)
@@ -267,7 +270,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.Options()
+		_, 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.Options()
+		_, 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.Options()
 		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.Options()
 		output := strings.ToLower(profileOutput)
 		out.SetJSON(output == "json")
-		go notify.MaybePrintUpdateTextFromGithub()
+		go notify.MaybePrintUpdateTextFromGithub(options)
 
 		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.Options) {
 	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.Options) {
 	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.Options) {
 	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.Options()
 		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 != "" {