Provider obfuscation in command line

cmd/podman/machine/cp.go

@@ -14,7 +14,7 @@ import (
 	"github.com/containers/podman/v5/pkg/copy"
 	"github.com/containers/podman/v5/pkg/machine"
 	"github.com/containers/podman/v5/pkg/machine/define"
-	"github.com/containers/podman/v5/pkg/machine/env"
+	"github.com/containers/podman/v5/pkg/machine/shim"
 	"github.com/containers/podman/v5/pkg/machine/vmconfigs"
 	"github.com/containers/podman/v5/pkg/specgen"
 	"github.com/spf13/cobra"
@@ -78,12 +78,16 @@ func cp(_ *cobra.Command, args []string) error {
 		destPath = args[1]
 	}
 
-	mc, err := resolveMachine(srcMachine, destMachine)
+	vmName, err := resolveMachineName(srcMachine, destMachine)
+	if err != nil {
+		return err
+	}
+	mc, vmProvider, err := shim.VMExists(vmName)
 	if err != nil {
 		return err
 	}
 
-	state, err := provider.State(mc, false)
+	state, err := vmProvider.State(mc, false)
 	if err != nil {
 		return err
 	}
@@ -135,25 +139,18 @@ func localhostSSHCopy(opts *cpOptions) error {
 	return cmd.Run()
 }
 
-func resolveMachine(srcMachine, destMachine string) (*vmconfigs.MachineConfig, error) {
+func resolveMachineName(srcMachine, destMachine string) (string, error) {
 	if len(srcMachine) > 0 && len(destMachine) > 0 {
-		return nil, errors.New("copying between two machines is unsupported")
+		return "", errors.New("copying between two machines is unsupported")
 	}
 
 	if len(srcMachine) == 0 && len(destMachine) == 0 {
-		return nil, errors.New("a machine name must prefix either the source path or destination path")
-	}
-
-	dirs, err := env.GetMachineDirs(provider.VMType())
-	if err != nil {
-		return nil, err
+		return "", errors.New("a machine name must prefix either the source path or destination path")
 	}
-
 	name := destMachine
 	if len(srcMachine) > 0 {
 		cpOpts.IsSrc = true
 		name = srcMachine
 	}
-
-	return vmconfigs.LoadMachineByName(name, dirs)
+	return name, nil
 }

cmd/podman/machine/init.go

@@ -12,7 +12,6 @@ import (
 	"github.com/containers/podman/v5/libpod/events"
 	"github.com/containers/podman/v5/pkg/machine/define"
 	"github.com/containers/podman/v5/pkg/machine/shim"
-	"github.com/containers/podman/v5/pkg/machine/vmconfigs"
 	"github.com/shirou/gopsutil/v4/mem"
 	"github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
@@ -183,17 +182,15 @@ func initMachine(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("invalid username %q: %w", initOpts.Username, ldefine.RegexError)
 	}
 
+	// TODO: When the providers comes back and we get a no such vm error, we need to check the hypervisor for
+	// the same name and error
 	// Check if machine already exists
-	_, exists, err := shim.VMExists(initOpts.Name, []vmconfigs.VMProvider{provider})
-	if err != nil {
+	var errNotExists *define.ErrVMDoesNotExist
+	_, _, err := shim.VMExists(initOpts.Name)
+	if err != nil && !errors.As(err, &errNotExists) {
 		return err
 	}
 
-	// machine exists, return error
-	if exists {
-		return fmt.Errorf("%s: %w", initOpts.Name, define.ErrVMAlreadyExists)
-	}
-
 	// check if a system connection already exists
 	cons, err := registry.PodmanConfig().ContainersConfDefaultsRO.GetAllConnections()
 	if err != nil {

cmd/podman/machine/inspect.go

@@ -10,7 +10,7 @@ import (
 	"github.com/containers/podman/v5/cmd/podman/utils"
 	"github.com/containers/podman/v5/pkg/machine"
 	"github.com/containers/podman/v5/pkg/machine/env"
-	"github.com/containers/podman/v5/pkg/machine/vmconfigs"
+	"github.com/containers/podman/v5/pkg/machine/shim"
 	"github.com/spf13/cobra"
 	"go.podman.io/common/pkg/report"
 )
@@ -48,33 +48,34 @@ func inspect(cmd *cobra.Command, args []string) error {
 	var (
 		errs utils.OutputErrors
 	)
-	dirs, err := env.GetMachineDirs(provider.VMType())
-	if err != nil {
-		return err
-	}
 	if len(args) < 1 {
 		args = append(args, defaultMachineName)
 	}
 
 	vms := make([]machine.InspectInfo, 0, len(args))
 	for _, name := range args {
-		mc, err := vmconfigs.LoadMachineByName(name, dirs)
+		mc, vmProvider, err := shim.VMExists(name)
 		if err != nil {
 			errs = append(errs, err)
 			continue
 		}
 
-		state, err := provider.State(mc, false)
+		dirs, err := env.GetMachineDirs(provider.VMType())
+		if err != nil {
+			return err
+		}
+
+		state, err := vmProvider.State(mc, false)
 		if err != nil {
 			return err
 		}
 
-		podmanSocket, podmanPipe, err := mc.ConnectionInfo(provider.VMType())
+		podmanSocket, podmanPipe, err := mc.ConnectionInfo(vmProvider.VMType())
 		if err != nil {
 			return err
 		}
 
-		rosetta, err := provider.GetRosetta(mc)
+		rosetta, err := vmProvider.GetRosetta(mc)
 		if err != nil {
 			return err
 		}
@@ -91,7 +92,7 @@ func inspect(cmd *cobra.Command, args []string) error {
 			Resources:          mc.Resources,
 			SSHConfig:          mc.SSH,
 			State:              state,
-			UserModeNetworking: provider.UserModeNetworkEnabled(mc),
+			UserModeNetworking: vmProvider.UserModeNetworkEnabled(mc),
 			Rootful:            mc.HostUser.Rootful,
 			Rosetta:            rosetta,
 		}

cmd/podman/machine/list.go

@@ -17,7 +17,6 @@ import (
 	"github.com/containers/podman/v5/pkg/machine"
 	provider2 "github.com/containers/podman/v5/pkg/machine/provider"
 	"github.com/containers/podman/v5/pkg/machine/shim"
-	"github.com/containers/podman/v5/pkg/machine/vmconfigs"
 	"github.com/docker/go-units"
 	"github.com/spf13/cobra"
 	"go.podman.io/common/pkg/completion"
@@ -44,10 +43,9 @@ var (
 )
 
 type listFlagType struct {
-	format       string
-	noHeading    bool
-	quiet        bool
-	allProviders bool
+	format    string
+	noHeading bool
+	quiet     bool
 }
 
 func init() {
@@ -62,25 +60,14 @@ func init() {
 	_ = lsCmd.RegisterFlagCompletionFunc(formatFlagName, common.AutocompleteFormat(&entities.ListReporter{}))
 	flags.BoolVarP(&listFlag.noHeading, "noheading", "n", false, "Do not print headers")
 	flags.BoolVarP(&listFlag.quiet, "quiet", "q", false, "Show only machine names")
-	flags.BoolVar(&listFlag.allProviders, "all-providers", false, "Show machines from all providers")
 }
 
 func list(cmd *cobra.Command, _ []string) error {
 	var (
 		opts machine.ListOptions
 		err  error
 	)
-	var providers []vmconfigs.VMProvider
-	if listFlag.allProviders {
-		providers = provider2.GetAll()
-	} else {
-		provider, err = provider2.Get()
-		if err != nil {
-			return err
-		}
-		providers = []vmconfigs.VMProvider{provider}
-	}
-
+	providers := provider2.GetAll()
 	listResponse, err := shim.List(providers, opts)
 	if err != nil {
 		return err

cmd/podman/machine/machine.go

@@ -42,6 +42,7 @@ var (
 )
 
 var (
+	// TODO This needs to be deleted!
 	provider vmconfigs.VMProvider
 )
 

cmd/podman/machine/os/apply.go

@@ -8,7 +8,6 @@ import (
 	"github.com/containers/podman/v5/cmd/podman/registry"
 	"github.com/containers/podman/v5/cmd/podman/validate"
 	"github.com/containers/podman/v5/pkg/machine/os"
-	provider2 "github.com/containers/podman/v5/pkg/machine/provider"
 	"github.com/spf13/cobra"
 )
 
@@ -49,11 +48,7 @@ func apply(_ *cobra.Command, args []string) error {
 		Restart: restart,
 	}
 
-	provider, err := provider2.Get()
-	if err != nil {
-		return err
-	}
-	osManager, err := NewOSManager(managerOpts, provider)
+	osManager, err := NewOSManager(managerOpts)
 	if err != nil {
 		return err
 	}

cmd/podman/machine/os/manager.go

@@ -9,10 +9,8 @@ import (
 	"strings"
 
 	"github.com/containers/podman/v5/pkg/machine/define"
-	"github.com/containers/podman/v5/pkg/machine/env"
 	pkgOS "github.com/containers/podman/v5/pkg/machine/os"
-	"github.com/containers/podman/v5/pkg/machine/provider"
-	"github.com/containers/podman/v5/pkg/machine/vmconfigs"
+	"github.com/containers/podman/v5/pkg/machine/shim"
 	machineconfig "go.podman.io/common/pkg/machine"
 )
 
@@ -23,53 +21,43 @@ type ManagerOpts struct {
 }
 
 // NewOSManager creates a new OSManager depending on the mode of the call
-func NewOSManager(opts ManagerOpts, p vmconfigs.VMProvider) (pkgOS.Manager, error) {
+func NewOSManager(opts ManagerOpts) (pkgOS.Manager, error) {
 	// If a VM name is specified, then we know that we are not inside a
 	// Podman VM, but rather outside of it.
 	if machineconfig.IsPodmanMachine() && opts.VMName == "" {
 		return guestOSManager()
 	}
-	return machineOSManager(opts, p)
-}
-
-// guestOSManager returns an OSmanager for inside-VM operations
-func guestOSManager() (pkgOS.Manager, error) {
-	dist := GetDistribution()
-	switch {
-	case dist.Name == "fedora" && dist.Variant == "coreos":
-		return &pkgOS.OSTree{}, nil
-	default:
-		return nil, errors.New("unsupported OS")
-	}
-}
 
-// machineOSManager returns an os manager that manages outside the VM.
-func machineOSManager(opts ManagerOpts, _ vmconfigs.VMProvider) (pkgOS.Manager, error) {
-	vmName := opts.VMName
+	// Set to the default name if no VM was provided
 	if opts.VMName == "" {
-		vmName = define.DefaultMachineName
+		opts.VMName = define.DefaultMachineName
 	}
-	p, err := provider.Get()
-	if err != nil {
-		return nil, err
-	}
-	dirs, err := env.GetMachineDirs(p.VMType())
-	if err != nil {
-		return nil, err
-	}
-	mc, err := vmconfigs.LoadMachineByName(vmName, dirs)
+
+	mc, vmProvider, err := shim.VMExists(opts.VMName)
 	if err != nil {
 		return nil, err
 	}
+
 	return &pkgOS.MachineOS{
 		VM:       mc,
-		Provider: p,
+		Provider: vmProvider,
 		Args:     opts.CLIArgs,
-		VMName:   vmName,
+		VMName:   opts.VMName,
 		Restart:  opts.Restart,
 	}, nil
 }
 
+// guestOSManager returns an OSmanager for inside-VM operations
+func guestOSManager() (pkgOS.Manager, error) {
+	dist := GetDistribution()
+	switch {
+	case dist.Name == "fedora" && dist.Variant == "coreos":
+		return &pkgOS.OSTree{}, nil
+	default:
+		return nil, errors.New("unsupported OS")
+	}
+}
+
 type Distribution struct {
 	Name    string
 	Variant string

cmd/podman/machine/rm.go

@@ -6,9 +6,7 @@ import (
 	"github.com/containers/podman/v5/cmd/podman/registry"
 	"github.com/containers/podman/v5/libpod/events"
 	"github.com/containers/podman/v5/pkg/machine"
-	"github.com/containers/podman/v5/pkg/machine/env"
 	"github.com/containers/podman/v5/pkg/machine/shim"
-	"github.com/containers/podman/v5/pkg/machine/vmconfigs"
 	"github.com/spf13/cobra"
 )
 
@@ -55,17 +53,12 @@ func rm(_ *cobra.Command, args []string) error {
 		vmName = args[0]
 	}
 
-	dirs, err := env.GetMachineDirs(provider.VMType())
+	mc, vmProvider, err := shim.VMExists(vmName)
 	if err != nil {
 		return err
 	}
 
-	mc, err := vmconfigs.LoadMachineByName(vmName, dirs)
-	if err != nil {
-		return err
-	}
-
-	if err := shim.Remove(mc, provider, dirs, destroyOptions); err != nil {
+	if err := shim.Remove(mc, vmProvider, destroyOptions); err != nil {
 		return err
 	}
 	newMachineEvent(events.Remove, events.Event{Name: vmName})

cmd/podman/machine/set.go

@@ -5,9 +5,7 @@ package machine
 import (
 	"github.com/containers/podman/v5/cmd/podman/registry"
 	"github.com/containers/podman/v5/pkg/machine/define"
-	"github.com/containers/podman/v5/pkg/machine/env"
 	"github.com/containers/podman/v5/pkg/machine/shim"
-	"github.com/containers/podman/v5/pkg/machine/vmconfigs"
 	"github.com/spf13/cobra"
 	"go.podman.io/common/pkg/completion"
 	"go.podman.io/common/pkg/strongunits"
@@ -93,12 +91,7 @@ func setMachine(cmd *cobra.Command, args []string) error {
 		vmName = args[0]
 	}
 
-	dirs, err := env.GetMachineDirs(provider.VMType())
-	if err != nil {
-		return err
-	}
-
-	mc, err := vmconfigs.LoadMachineByName(vmName, dirs)
+	mc, vmProvider, err := shim.VMExists(vmName)
 	if err != nil {
 		return err
 	}
@@ -129,5 +122,5 @@ func setMachine(cmd *cobra.Command, args []string) error {
 
 	// At this point, we have the known changed information, etc
 	// Walk through changes to the providers if they need them
-	return shim.Set(mc, provider, setOpts)
+	return shim.Set(mc, vmProvider, setOpts)
 }