Remove viper calls outside of cmd - part2

cmd/minikube/cmd/cache.go

@@ -29,6 +29,7 @@ import (
 	"k8s.io/minikube/pkg/minikube/node"
 	"k8s.io/minikube/pkg/minikube/out"
 	"k8s.io/minikube/pkg/minikube/reason"
+	"k8s.io/minikube/pkg/minikube/run"
 )
 
 // cacheImageConfigKey is the config field name used to store which images we have previously cached
@@ -52,7 +53,7 @@ var addCacheCmd = &cobra.Command{
 		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, options); err != nil {
+		if err := machine.CacheAndLoadImages(args, cacheAddProfiles(options), false, options); err != nil {
 			exit.Error(reason.InternalCacheLoad, "Failed to cache and load images", err)
 		}
 		// Add images to config file
@@ -66,18 +67,18 @@ func addCacheCmdFlags() {
 	addCacheCmd.Flags().Bool(allFlag, false, "Add image to cache for all running minikube clusters")
 }
 
-func cacheAddProfiles() []*config.Profile {
+func cacheAddProfiles(options *run.CommandOptions) []*config.Profile {
 	if viper.GetBool(allFlag) {
-		validProfiles, _, err := config.ListProfiles() // need to load image to all profiles
+		validProfiles, _, err := config.ListProfiles(options) // need to load image to all profiles
 		if err != nil {
 			klog.Warningf("error listing profiles: %v", err)
 		}
 		return validProfiles
 	}
-	profile := viper.GetString(config.ProfileName)
-	p, err := config.LoadProfile(profile)
+	p, err := config.LoadProfile(options.ProfileName)
 	if err != nil {
-		exit.Message(reason.Usage, "{{.profile}} profile is not valid: {{.err}}", out.V{"profile": profile, "err": err})
+		exit.Message(reason.Usage, "{{.profile}} profile is not valid: {{.err}}",
+			out.V{"profile": options.ProfileName, "err": err})
 	}
 	return []*config.Profile{p}
 }
@@ -106,7 +107,7 @@ var reloadCacheCmd = &cobra.Command{
 	Long:  "reloads images previously added using the 'cache add' subcommand",
 	Run: func(_ *cobra.Command, _ []string) {
 		options := flags.CommandOptions()
-		err := node.CacheAndLoadImagesInConfig(cacheAddProfiles(), options)
+		err := node.CacheAndLoadImagesInConfig(cacheAddProfiles(options), options)
 		if err != nil {
 			exit.Error(reason.GuestCacheLoad, "Failed to reload cached images", err)
 		}

cmd/minikube/cmd/config/addons_list.go

@@ -35,6 +35,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"
 )
 
@@ -63,7 +64,7 @@ var addonsListCmd = &cobra.Command{
 		}
 		switch strings.ToLower(addonListOutput) {
 		case "list":
-			printAddonsList(cc, addonPrintDocs)
+			printAddonsList(cc, addonPrintDocs, options)
 		case "json":
 			printAddonsJSON(cc)
 		default:
@@ -92,7 +93,7 @@ var stringFromStatus = func(addonStatus bool) string {
 	return "disabled"
 }
 
-var printAddonsList = func(cc *config.ClusterConfig, printDocs bool) {
+var printAddonsList = func(cc *config.ClusterConfig, printDocs bool, options *run.CommandOptions) {
 	addonNames := slices.Sorted(maps.Keys(assets.Addons))
 	table := tablewriter.NewWriter(os.Stdout)
 
@@ -142,7 +143,7 @@ var printAddonsList = func(cc *config.ClusterConfig, printDocs bool) {
 	if err := table.Render(); err != nil {
 		klog.Error("Error rendering table", err)
 	}
-	v, _, err := config.ListProfiles()
+	v, _, err := config.ListProfiles(options)
 	if err != nil {
 		klog.Errorf("list profiles returned error: %v", err)
 	}

cmd/minikube/cmd/config/addons_list_test.go

@@ -23,10 +23,14 @@ import (
 	"strings"
 	"testing"
 
+	"k8s.io/minikube/pkg/minikube/constants"
 	"k8s.io/minikube/pkg/minikube/out"
+	"k8s.io/minikube/pkg/minikube/run"
 )
 
 func TestAddonsList(t *testing.T) {
+	options := &run.CommandOptions{ProfileName: constants.DefaultClusterName}
+
 	tests := []struct {
 		name      string
 		printDocs bool
@@ -45,7 +49,7 @@ func TestAddonsList(t *testing.T) {
 			old := os.Stdout
 			defer func() { os.Stdout = old }()
 			os.Stdout = w
-			printAddonsList(nil, tt.printDocs)
+			printAddonsList(nil, tt.printDocs, options)
 			if err := w.Close(); err != nil {
 				t.Fatalf("failed to close pipe: %v", err)
 			}

cmd/minikube/cmd/config/profile.go

@@ -20,6 +20,7 @@ import (
 	"os"
 
 	"github.com/spf13/cobra"
+	"k8s.io/minikube/cmd/minikube/cmd/flags"
 	"k8s.io/minikube/pkg/minikube/config"
 	"k8s.io/minikube/pkg/minikube/exit"
 	"k8s.io/minikube/pkg/minikube/kubeconfig"
@@ -45,6 +46,7 @@ var ProfileCmd = &cobra.Command{
 			exit.Message(reason.Usage, "usage: minikube profile [MINIKUBE_PROFILE_NAME]")
 		}
 
+		options := flags.CommandOptions()
 		profile := args[0]
 		// Check whether the profile name is container friendly
 		if !config.ProfileNameValid(profile) {
@@ -63,7 +65,7 @@ var ProfileCmd = &cobra.Command{
 			profile = "minikube"
 		} else {
 			// not validating when it is default profile
-			errProfile, ok := ValidateProfile(profile)
+			errProfile, ok := ValidateProfile(profile, options)
 			if !ok && errProfile != nil {
 				out.FailureT(errProfile.Msg)
 			}

cmd/minikube/cmd/config/profile_list.go

@@ -70,18 +70,18 @@ var profileListCmd = &cobra.Command{
 	},
 }
 
-func listProfiles() (validProfiles, invalidProfiles []*config.Profile, err error) {
+func listProfiles(options *run.CommandOptions) (validProfiles, invalidProfiles []*config.Profile, err error) {
 	if isLight {
-		validProfiles, err = config.ListValidProfiles()
+		validProfiles, err = config.ListValidProfiles(options)
 	} else {
-		validProfiles, invalidProfiles, err = config.ListProfiles()
+		validProfiles, invalidProfiles, err = config.ListProfiles(options)
 	}
 
 	return validProfiles, invalidProfiles, err
 }
 
 func printProfilesTable(options *run.CommandOptions) {
-	validProfiles, invalidProfiles, err := listProfiles()
+	validProfiles, invalidProfiles, err := listProfiles(options)
 
 	if err != nil {
 		klog.Warningf("error loading profiles: %v", err)
@@ -209,7 +209,7 @@ func warnInvalidProfiles(invalidProfiles []*config.Profile) {
 }
 
 func printProfilesJSON(options *run.CommandOptions) {
-	validProfiles, invalidProfiles, err := listProfiles()
+	validProfiles, invalidProfiles, err := listProfiles(options)
 	updateProfilesStatus(validProfiles, options)
 
 	var body = map[string]interface{}{}

cmd/minikube/cmd/config/util.go

@@ -23,6 +23,7 @@ import (
 
 	"k8s.io/minikube/pkg/minikube/config"
 	"k8s.io/minikube/pkg/minikube/out"
+	"k8s.io/minikube/pkg/minikube/run"
 )
 
 // Invoke all the validation or callback functions and collects errors
@@ -105,9 +106,9 @@ func (e ErrValidateProfile) Error() string {
 }
 
 // ValidateProfile checks if the profile user is trying to switch exists, else throws error
-func ValidateProfile(profile string) (*ErrValidateProfile, bool) {
+func ValidateProfile(profile string, options *run.CommandOptions) (*ErrValidateProfile, bool) {
 
-	validProfiles, invalidProfiles, err := config.ListProfiles()
+	validProfiles, invalidProfiles, err := config.ListProfiles(options)
 	if err != nil {
 		out.FailureT(err.Error())
 	}

cmd/minikube/cmd/config/util_test.go

@@ -21,7 +21,9 @@ import (
 	"testing"
 
 	config "k8s.io/minikube/pkg/minikube/config"
+	"k8s.io/minikube/pkg/minikube/constants"
 	"k8s.io/minikube/pkg/minikube/driver"
+	"k8s.io/minikube/pkg/minikube/run"
 )
 
 var minikubeConfig = config.MinikubeConfig{
@@ -83,10 +85,11 @@ func TestSetBool(t *testing.T) {
 }
 
 func TestValidateProfile(t *testing.T) {
+	options := &run.CommandOptions{ProfileName: constants.DefaultClusterName}
 	testCases := []string{"82374328742_2974224498", "validate_test"}
 	for _, name := range testCases {
 		expected := fmt.Sprintf("profile %q not found", name)
-		err, ok := ValidateProfile(name)
+		err, ok := ValidateProfile(name, options)
 		if !ok && err.Error() != expected {
 			t.Errorf("got error %q, expected %q", err, expected)
 		}

cmd/minikube/cmd/delete.go

@@ -218,7 +218,7 @@ func runDelete(_ *cobra.Command, args []string) {
 	out.SetJSON(outputFormat == "json")
 	register.Reg.SetStep(register.Deleting)
 	download.CleanUpOlderPreloads()
-	validProfiles, invalidProfiles, err := config.ListProfiles()
+	validProfiles, invalidProfiles, err := config.ListProfiles(options)
 	if err != nil {
 		klog.Warningf("'error loading profiles in minikube home %q: %v", localpath.MiniPath(), err)
 	}
@@ -333,7 +333,6 @@ func deleteProfile(ctx context.Context, profile *config.Profile, options *run.Co
 	klog.Infof("Deleting %s", profile.Name)
 	register.Reg.SetStep(register.Deleting)
 
-	viper.Set(config.ProfileName, profile.Name)
 	if profile.Config != nil {
 		klog.Infof("%s configuration: %+v", profile.Name, profile.Config)
 

cmd/minikube/cmd/delete_test.go

@@ -27,10 +27,10 @@ import (
 	"github.com/docker/machine/libmachine"
 	"github.com/google/go-cmp/cmp"
 	"github.com/otiai10/copy"
-	"github.com/spf13/viper"
 
 	cmdcfg "k8s.io/minikube/cmd/minikube/cmd/config"
 	"k8s.io/minikube/pkg/minikube/config"
+	"k8s.io/minikube/pkg/minikube/constants"
 	"k8s.io/minikube/pkg/minikube/localpath"
 	"k8s.io/minikube/pkg/minikube/run"
 )
@@ -87,7 +87,6 @@ func TestDeleteProfile(t *testing.T) {
 		{"partial-mach", "p8_partial_machine_config", []string{"p8_partial_machine_config"}},
 	}
 
-	options := &run.CommandOptions{}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Setenv(localpath.MinikubeHome, td)
@@ -107,6 +106,10 @@ func TestDeleteProfile(t *testing.T) {
 			}
 
 			hostAndDirsDeleter = hostAndDirsDeleterMock
+
+			// Simulate minikube delete --profile PROFILE_NAME
+			options := &run.CommandOptions{ProfileName: profile.Name}
+
 			errs := DeleteProfiles([]*config.Profile{profile}, options)
 			if len(errs) > 0 {
 				HandleDeletionErrors(errs)
@@ -141,8 +144,6 @@ func TestDeleteProfile(t *testing.T) {
 			if diff := cmp.Diff(expectedMachines, afterMachines); diff != "" {
 				t.Errorf("machines mismatch (-want +got):\n%s", diff)
 			}
-
-			viper.Set(config.ProfileName, "")
 		})
 	}
 }
@@ -157,6 +158,8 @@ func deleteContextTest() error {
 }
 
 func TestDeleteAllProfiles(t *testing.T) {
+	options := &run.CommandOptions{ProfileName: constants.DefaultClusterName}
+
 	td := t.TempDir()
 
 	if err := copy.Copy("../../../pkg/minikube/config/testdata/delete-all", td); err != nil {
@@ -186,7 +189,7 @@ func TestDeleteAllProfiles(t *testing.T) {
 	config.DockerContainers = func() ([]string, error) {
 		return []string{}, nil
 	}
-	validProfiles, inValidProfiles, err := config.ListProfiles()
+	validProfiles, inValidProfiles, err := config.ListProfiles(options)
 	if err != nil {
 		t.Error(err)
 	}
@@ -198,7 +201,7 @@ func TestDeleteAllProfiles(t *testing.T) {
 	profiles := validProfiles
 	profiles = append(profiles, inValidProfiles...)
 	hostAndDirsDeleter = hostAndDirsDeleterMock
-	errs := DeleteProfiles(profiles, &run.CommandOptions{})
+	errs := DeleteProfiles(profiles, options)
 
 	if errs != nil {
 		t.Errorf("errors while deleting all profiles: %v", errs)
@@ -219,8 +222,6 @@ func TestDeleteAllProfiles(t *testing.T) {
 	if len(afterMachines) != 0 {
 		t.Errorf("Did not delete all machines, remaining: %v", afterMachines)
 	}
-
-	viper.Set(config.ProfileName, "")
 }
 
 // TestTryKillOne spawns a go child process that waits to be SIGKILLed,

cmd/minikube/cmd/flags/flags.go

@@ -18,13 +18,15 @@ package flags
 
 import (
 	"github.com/spf13/viper"
+	"k8s.io/minikube/pkg/minikube/config"
 	"k8s.io/minikube/pkg/minikube/run"
 )
 
 // Flag names passed to minikube via run.CommandOptions.
 const (
 	Interactive  = "interactive"
 	DownloadOnly = "download-only"
+	Force        = "force"
 )
 
 // CommandOptions returns minikube runtime options from command line flags.
@@ -34,5 +36,7 @@ func CommandOptions() *run.CommandOptions {
 	return &run.CommandOptions{
 		NonInteractive: !viper.GetBool(Interactive),
 		DownloadOnly:   viper.GetBool(DownloadOnly),
+		ProfileName:    viper.GetString(config.ProfileName),
+		Force:          viper.GetBool(Force),
 	}
 }

cmd/minikube/cmd/mount.go

@@ -246,7 +246,7 @@ var mountCmd = &cobra.Command{
 			}
 		}()
 
-		err = cluster.Mount(co.CP.Runner, ip.String(), vmPath, cfg, pid)
+		err = cluster.Mount(co.CP.Runner, ip.String(), vmPath, cfg, pid, options)
 		if err != nil {
 			if rtErr, ok := err.(*cluster.MountError); ok && rtErr.ErrorType == cluster.MountErrorConnect {
 				exit.Error(reason.GuestMountCouldNotConnect, "mount could not connect", rtErr)

cmd/minikube/cmd/root.go

@@ -30,6 +30,7 @@ import (
 	"k8s.io/klog/v2"
 	"k8s.io/kubectl/pkg/util/templates"
 	configCmd "k8s.io/minikube/cmd/minikube/cmd/config"
+	"k8s.io/minikube/cmd/minikube/cmd/flags"
 	"k8s.io/minikube/pkg/drivers/kic/oci"
 	"k8s.io/minikube/pkg/minikube/audit"
 	"k8s.io/minikube/pkg/minikube/config"
@@ -64,6 +65,7 @@ var RootCmd = &cobra.Command{
 	Short: "minikube quickly sets up a local Kubernetes cluster",
 	Long:  `minikube provisions and manages local Kubernetes clusters optimized for development workflows.`,
 	PersistentPreRun: func(_ *cobra.Command, _ []string) {
+		options := flags.CommandOptions()
 		for _, path := range dirs {
 			if err := os.MkdirAll(path, 0777); err != nil {
 				exit.Error(reason.HostHomeMkdir, "Error creating minikube directory", err)
@@ -75,7 +77,7 @@ var RootCmd = &cobra.Command{
 			exit.Message(reason.Usage, "User name must be 60 chars or less.")
 		}
 		var err error
-		auditID, err = audit.LogCommandStart()
+		auditID, err = audit.LogCommandStart(options)
 		if err != nil {
 			klog.Warningf("failed to log command start to audit: %v", err)
 		}