Add VirtualMachine interface to abstract out crc virtual machine interaction

rohanKanojia · rohanKanojia · commit 061d6874b107 · 2024-11-18T13:52:29.000+05:30
Add a VirtualMachine interface and make the CRC `machine` package client use the VirtualMachine interface instead of a concrete implementation. This way we can inject a dummy test FakeVirtualMachine implementation into client tests that can ease writing tests for this package.
  - Add some additional methods in VirtualMachine interface so that we can replace direct usage of struct fields with interface methods
    - `Bundle()`
    - `Driver()`
    - `API()`
    - `Host()`
    - `Kill()`
diff --git a/pkg/crc/machine/console.go b/pkg/crc/machine/console.go
@@ -21,7 +21,7 @@ func (client *client) GetConsoleURL() (*types.ConsoleResult, error) {
 		return nil, errors.Wrap(err, "Error getting the state for virtual machine")
 	}
 
-	clusterConfig, err := getClusterConfig(vm.bundle)
+	clusterConfig, err := getClusterConfig(vm.Bundle())
 	if err != nil {
 		return nil, errors.Wrap(err, "Error loading cluster configuration")
 	}
diff --git a/pkg/crc/machine/generate_bundle.go b/pkg/crc/machine/generate_bundle.go
@@ -111,7 +111,7 @@ func loadVM(client *client) (*bundle.CrcBundleInfo, *crcssh.Runner, error) {
 	}
 	defer vm.Close()
 
-	currentState, err := vm.Driver.GetState()
+	currentState, err := vm.Driver().GetState()
 	if err != nil {
 		return nil, nil, errors.Wrap(err, "Cannot get machine state")
 	}
@@ -124,5 +124,5 @@ func loadVM(client *client) (*bundle.CrcBundleInfo, *crcssh.Runner, error) {
 		return nil, nil, errors.Wrap(err, "Error creating the ssh client")
 	}
 
-	return vm.bundle, sshRunner, nil
+	return vm.Bundle(), sshRunner, nil
 }
diff --git a/pkg/crc/machine/ip.go b/pkg/crc/machine/ip.go
@@ -21,6 +21,6 @@ func (client *client) ConnectionDetails() (*types.ConnectionDetails, error) {
 		IP:          ip,
 		SSHPort:     vm.SSHPort(),
 		SSHUsername: constants.DefaultSSHUser,
-		SSHKeys:     []string{constants.GetPrivateKeyPath(), constants.GetECDSAPrivateKeyPath(), vm.bundle.GetSSHKeyPath()},
+		SSHKeys:     []string{constants.GetPrivateKeyPath(), constants.GetECDSAPrivateKeyPath(), vm.Bundle().GetSSHKeyPath()},
 	}, nil
 }
diff --git a/pkg/crc/machine/start.go b/pkg/crc/machine/start.go
@@ -60,48 +60,48 @@ func getCrcBundleInfo(preset crcPreset.Preset, bundleName, bundlePath string, en
 	return bundle.Use(bundleName)
 }
 
-func (client *client) updateVMConfig(startConfig types.StartConfig, vm *virtualMachine) error {
+func (client *client) updateVMConfig(startConfig types.StartConfig, vm VirtualMachine) error {
 	/* Memory */
 	logging.Debugf("Updating CRC VM configuration")
-	if err := setMemory(vm.Host, startConfig.Memory); err != nil {
+	if err := setMemory(vm.Host(), startConfig.Memory); err != nil {
 		logging.Debugf("Failed to update CRC VM configuration: %v", err)
 		if err == drivers.ErrNotImplemented {
 			logging.Warn("Memory configuration change has been ignored as the machine driver does not support it")
 		} else {
 			return err
 		}
 	}
-	if err := setVcpus(vm.Host, startConfig.CPUs); err != nil {
+	if err := setVcpus(vm.Host(), startConfig.CPUs); err != nil {
 		logging.Debugf("Failed to update CRC VM configuration: %v", err)
 		if err == drivers.ErrNotImplemented {
 			logging.Warn("CPU configuration change has been ignored as the machine driver does not support it")
 		} else {
 			return err
 		}
 	}
-	if err := vm.api.Save(vm.Host); err != nil {
+	if err := vm.API().Save(vm.Host()); err != nil {
 		return err
 	}
 
 	/* Disk size */
 	if startConfig.DiskSize != constants.DefaultDiskSize {
-		if err := setDiskSize(vm.Host, startConfig.DiskSize); err != nil {
+		if err := setDiskSize(vm.Host(), startConfig.DiskSize); err != nil {
 			logging.Debugf("Failed to update CRC disk configuration: %v", err)
 			if err == drivers.ErrNotImplemented {
 				logging.Warn("Disk size configuration change has been ignored as the machine driver does not support it")
 			} else {
 				return err
 			}
 		}
-		if err := vm.api.Save(vm.Host); err != nil {
+		if err := vm.API().Save(vm.Host()); err != nil {
 			return err
 		}
 	}
 
 	// we want to set the shared dir password on-the-fly to be used
 	// we do not want this value to be persisted to disk
 	if startConfig.SharedDirPassword != "" {
-		if err := setSharedDirPassword(vm.Host, startConfig.SharedDirPassword); err != nil {
+		if err := setSharedDirPassword(vm.Host(), startConfig.SharedDirPassword); err != nil {
 			return fmt.Errorf("Failed to set shared dir password: %w", err)
 		}
 	}
@@ -206,9 +206,9 @@ func growLVForMicroshift(sshRunner *crcssh.Runner, lvFullName string, rootPart s
 	return nil
 }
 
-func configureSharedDirs(vm *virtualMachine, sshRunner *crcssh.Runner) error {
+func configureSharedDirs(vm VirtualMachine, sshRunner *crcssh.Runner) error {
 	logging.Debugf("Configuring shared directories")
-	sharedDirs, err := vm.Driver.GetSharedDirs()
+	sharedDirs, err := vm.Driver().GetSharedDirs()
 	if err != nil {
 		// the libvirt machine driver uses net/rpc, which wraps errors
 		// in rpc.ServerError, but without using golang 1.13 error
@@ -334,7 +334,7 @@ func (client *client) Start(ctx context.Context, startConfig types.StartConfig)
 	}
 	defer vm.Close()
 
-	currentBundleName := vm.bundle.GetBundleName()
+	currentBundleName := vm.Bundle().GetBundleName()
 	if currentBundleName != bundleName {
 		logging.Debugf("Bundle '%s' was requested, but the existing VM is using '%s'",
 			bundleName, currentBundleName)
@@ -347,8 +347,8 @@ func (client *client) Start(ctx context.Context, startConfig types.StartConfig)
 		return nil, errors.Wrap(err, "Error getting the machine state")
 	}
 	if vmState == state.Running {
-		logging.Infof("A CRC VM for %s %s is already running", startConfig.Preset.ForDisplay(), vm.bundle.GetVersion())
-		clusterConfig, err := getClusterConfig(vm.bundle)
+		logging.Infof("A CRC VM for %s %s is already running", startConfig.Preset.ForDisplay(), vm.Bundle().GetVersion())
+		clusterConfig, err := getClusterConfig(vm.Bundle())
 		if err != nil {
 			return nil, errors.Wrap(err, "Cannot create cluster configuration")
 		}
@@ -365,7 +365,7 @@ func (client *client) Start(ctx context.Context, startConfig types.StartConfig)
 		return nil, err
 	}
 
-	logging.Infof("Starting CRC VM for %s %s...", startConfig.Preset, vm.bundle.GetVersion())
+	logging.Infof("Starting CRC VM for %s %s...", startConfig.Preset, vm.Bundle().GetVersion())
 
 	if client.useVSock() {
 		if err := exposePorts(startConfig.Preset, startConfig.IngressHTTPPort, startConfig.IngressHTTPSPort); err != nil {
@@ -457,7 +457,7 @@ func (client *client) Start(ctx context.Context, startConfig types.StartConfig)
 		return nil, errors.Wrap(err, "Failed to change permissions to root podman socket")
 	}
 
-	proxyConfig, err := getProxyConfig(vm.bundle)
+	proxyConfig, err := getProxyConfig(vm.Bundle())
 	if err != nil {
 		return nil, errors.Wrap(err, "Error getting proxy configuration")
 	}
@@ -472,7 +472,7 @@ func (client *client) Start(ctx context.Context, startConfig types.StartConfig)
 		SSHRunner: sshRunner,
 		IP:        instanceIP,
 		// TODO: should be more finegrained
-		BundleMetadata: *vm.bundle,
+		BundleMetadata: *vm.Bundle(),
 		NetworkMode:    client.networkMode(),
 	}
 
@@ -502,7 +502,7 @@ func (client *client) Start(ctx context.Context, startConfig types.StartConfig)
 		logging.Warn(fmt.Sprintf("Failed to query DNS from host: %v", err))
 	}
 
-	if vm.bundle.IsMicroshift() {
+	if vm.Bundle().IsMicroshift() {
 		// **************************
 		//  END OF MICROSHIFT START CODE
 		// **************************
@@ -547,7 +547,7 @@ func (client *client) Start(ctx context.Context, startConfig types.StartConfig)
 	ocConfig := oc.UseOCWithSSH(sshRunner)
 
 	if err := cluster.ApproveCSRAndWaitForCertsRenewal(ctx, sshRunner, ocConfig, certsExpired[cluster.KubeletClientCert], certsExpired[cluster.KubeletServerCert], certsExpired[cluster.AggregatorClientCert]); err != nil {
-		logBundleDate(vm.bundle)
+		logBundleDate(vm.Bundle())
 		return nil, errors.Wrap(err, "Failed to renew TLS certificates: please check if a newer CRC release is available")
 	}
 
@@ -596,7 +596,7 @@ func (client *client) Start(ctx context.Context, startConfig types.StartConfig)
 		}
 	}
 
-	if err := updateKubeconfig(ctx, ocConfig, sshRunner, vm.bundle.GetKubeConfigPath()); err != nil {
+	if err := updateKubeconfig(ctx, ocConfig, sshRunner, vm.Bundle().GetKubeConfigPath()); err != nil {
 		return nil, errors.Wrap(err, "Failed to update kubeconfig file")
 	}
 
@@ -607,7 +607,7 @@ func (client *client) Start(ctx context.Context, startConfig types.StartConfig)
 
 	waitForProxyPropagation(ctx, ocConfig, proxyConfig)
 
-	clusterConfig, err := getClusterConfig(vm.bundle)
+	clusterConfig, err := getClusterConfig(vm.Bundle())
 	if err != nil {
 		return nil, errors.Wrap(err, "Cannot get cluster configuration")
 	}
@@ -694,17 +694,17 @@ func createHost(machineConfig config.MachineConfig, preset crcPreset.Preset) err
 	return nil
 }
 
-func startHost(ctx context.Context, vm *virtualMachine) error {
-	if err := vm.Driver.Start(); err != nil {
+func startHost(ctx context.Context, vm VirtualMachine) error {
+	if err := vm.Driver().Start(); err != nil {
 		return fmt.Errorf("Error in driver during machine start: %s", err)
 	}
 
-	if err := vm.api.Save(vm.Host); err != nil {
+	if err := vm.API().Save(vm.Host()); err != nil {
 		return fmt.Errorf("Error saving virtual machine to store after attempting creation: %s", err)
 	}
 
 	logging.Debug("Waiting for machine to be running, this may take a few minutes...")
-	if err := crcerrors.Retry(ctx, 3*time.Minute, host.MachineInState(vm.Driver, libmachinestate.Running), 3*time.Second); err != nil {
+	if err := crcerrors.Retry(ctx, 3*time.Minute, host.MachineInState(vm.Driver(), libmachinestate.Running), 3*time.Second); err != nil {
 		return fmt.Errorf("Error waiting for machine to be running: %s", err)
 	}
 
diff --git a/pkg/crc/machine/status.go b/pkg/crc/machine/status.go
@@ -37,13 +37,13 @@ func (client *client) Status() (*types.ClusterStatusResult, error) {
 		CrcStatus: vmStatus,
 	}
 	switch {
-	case vm.bundle.IsMicroshift():
+	case vm.Bundle().IsMicroshift():
 		clusterStatusResult.OpenshiftStatus = types.OpenshiftStopped
-		clusterStatusResult.OpenshiftVersion = vm.bundle.GetVersion()
+		clusterStatusResult.OpenshiftVersion = vm.Bundle().GetVersion()
 		clusterStatusResult.Preset = preset.Microshift
 	default:
 		clusterStatusResult.OpenshiftStatus = types.OpenshiftStopped
-		clusterStatusResult.OpenshiftVersion = vm.bundle.GetVersion()
+		clusterStatusResult.OpenshiftVersion = vm.Bundle().GetVersion()
 		clusterStatusResult.Preset = preset.OpenShift
 	}
 
@@ -62,10 +62,10 @@ func (client *client) Status() (*types.ClusterStatusResult, error) {
 	clusterStatusResult.DiskSize = diskSize
 
 	switch {
-	case vm.bundle.IsMicroshift():
+	case vm.Bundle().IsMicroshift():
 		clusterStatusResult.OpenshiftStatus = getMicroShiftStatus(context.Background(), ip)
 		clusterStatusResult.PersistentVolumeUse, clusterStatusResult.PersistentVolumeSize = client.getPVCSize(vm)
-	case vm.bundle.IsOpenShift():
+	case vm.Bundle().IsOpenShift():
 		clusterStatusResult.OpenshiftStatus = getOpenShiftStatus(context.Background(), ip)
 	}
 
@@ -112,7 +112,7 @@ func (client *client) GetClusterLoad() (*types.ClusterLoadResult, error) {
 	}, nil
 }
 
-func (client *client) getDiskDetails(vm *virtualMachine) (int64, int64) {
+func (client *client) getDiskDetails(vm VirtualMachine) (int64, int64) {
 	disk, err, _ := client.diskDetails.Memoize("disks", func() (interface{}, error) {
 		sshRunner, err := vm.SSHRunner()
 		if err != nil {
@@ -162,7 +162,7 @@ func getStatus(status *cluster.Status) types.OpenshiftStatus {
 	return types.OpenshiftStopped
 }
 
-func (client *client) getRAMStatus(vm *virtualMachine) (int64, int64) {
+func (client *client) getRAMStatus(vm VirtualMachine) (int64, int64) {
 	ram, err, _ := client.ramDetails.Memoize("ram", func() (interface{}, error) {
 		sshRunner, err := vm.SSHRunner()
 		if err != nil {
@@ -184,7 +184,7 @@ func (client *client) getRAMStatus(vm *virtualMachine) (int64, int64) {
 	return ram.([]int64)[0], ram.([]int64)[1]
 }
 
-func (client *client) getCPUStatus(vm *virtualMachine) []int64 {
+func (client *client) getCPUStatus(vm VirtualMachine) []int64 {
 	sshRunner, err := vm.SSHRunner()
 	if err != nil {
 		logging.Debugf("Cannot get SSH runner: %v", err)
@@ -202,7 +202,7 @@ func (client *client) getCPUStatus(vm *virtualMachine) []int64 {
 
 }
 
-func (client *client) getPVCSize(vm *virtualMachine) (int, int) {
+func (client *client) getPVCSize(vm VirtualMachine) (int, int) {
 	sshRunner, err := vm.SSHRunner()
 	if err != nil {
 		logging.Debugf("Cannot get SSH runner: %v", err)
diff --git a/pkg/crc/machine/stop.go b/pkg/crc/machine/stop.go
@@ -54,7 +54,7 @@ func (client *client) Stop() (state.State, error) {
 // is fixed. We should also ignore the openshift specific errors because stop
 // operation shouldn't depend on the openshift side. Without this graceful shutdown
 // takes around 6-7 mins.
-func stopAllContainers(vm *virtualMachine) error {
+func stopAllContainers(vm VirtualMachine) error {
 	logging.Info("Stopping kubelet and all containers...")
 	sshRunner, err := vm.SSHRunner()
 	if err != nil {
diff --git a/pkg/crc/machine/virtualmachine.go b/pkg/crc/machine/virtualmachine.go
@@ -9,12 +9,28 @@ import (
 	"github.com/crc-org/crc/v2/pkg/crc/ssh"
 	"github.com/crc-org/crc/v2/pkg/libmachine"
 	libmachinehost "github.com/crc-org/crc/v2/pkg/libmachine/host"
+	"github.com/crc-org/machine/libmachine/drivers"
 	"github.com/pkg/errors"
 )
 
+type VirtualMachine interface {
+	Close() error
+	Remove() error
+	State() (state.State, error)
+	IP() (string, error)
+	SSHPort() int
+	SSHRunner() (*ssh.Runner, error)
+	Kill() error
+	Stop() error
+	Bundle() *bundle.CrcBundleInfo
+	Driver() drivers.Driver
+	API() libmachine.API
+	Host() *libmachinehost.Host
+}
+
 type virtualMachine struct {
-	name string
-	*libmachinehost.Host
+	name   string
+	host   *libmachinehost.Host
 	bundle *bundle.CrcBundleInfo
 	api    libmachine.API
 	vsock  bool
@@ -34,7 +50,7 @@ func (err *MissingHostError) Error() string {
 
 var errInvalidBundleMetadata = errors.New("Error loading bundle metadata")
 
-func loadVirtualMachine(name string, useVSock bool) (*virtualMachine, error) {
+func loadVirtualMachine(name string, useVSock bool) (VirtualMachine, error) {
 	apiClient := libmachine.NewClient(constants.MachineBaseDir)
 	exists, err := apiClient.Exists(name)
 	if err != nil {
@@ -56,7 +72,7 @@ func loadVirtualMachine(name string, useVSock bool) (*virtualMachine, error) {
 
 	return &virtualMachine{
 		name:   name,
-		Host:   libmachineHost,
+		host:   libmachineHost,
 		bundle: crcBundleMetadata,
 		api:    apiClient,
 		vsock:  useVSock,
@@ -68,7 +84,7 @@ func (vm *virtualMachine) Close() error {
 }
 
 func (vm *virtualMachine) Remove() error {
-	if err := vm.Driver.Remove(); err != nil {
+	if err := vm.Driver().Remove(); err != nil {
 		return errors.Wrap(err, "Driver cannot remove machine")
 	}
 
@@ -80,7 +96,7 @@ func (vm *virtualMachine) Remove() error {
 }
 
 func (vm *virtualMachine) State() (state.State, error) {
-	vmStatus, err := vm.Driver.GetState()
+	vmStatus, err := vm.Driver().GetState()
 	if err != nil {
 		return state.Error, err
 	}
@@ -91,7 +107,7 @@ func (vm *virtualMachine) IP() (string, error) {
 	if vm.vsock {
 		return "127.0.0.1", nil
 	}
-	return vm.Driver.GetIP()
+	return vm.Driver().GetIP()
 }
 
 func (vm *virtualMachine) SSHPort() int {
@@ -108,3 +124,27 @@ func (vm *virtualMachine) SSHRunner() (*ssh.Runner, error) {
 	}
 	return ssh.CreateRunner(ip, vm.SSHPort(), constants.GetPrivateKeyPath(), constants.GetECDSAPrivateKeyPath(), vm.bundle.GetSSHKeyPath())
 }
+
+func (vm *virtualMachine) Bundle() *bundle.CrcBundleInfo {
+	return vm.bundle
+}
+
+func (vm *virtualMachine) Driver() drivers.Driver {
+	return vm.host.Driver
+}
+
+func (vm *virtualMachine) API() libmachine.API {
+	return vm.api
+}
+
+func (vm *virtualMachine) Host() *libmachinehost.Host {
+	return vm.host
+}
+
+func (vm *virtualMachine) Kill() error {
+	return vm.host.Kill()
+}
+
+func (vm *virtualMachine) Stop() error {
+	return vm.host.Stop()
+}

Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ func (client client) GetConsoleURL() (types.ConsoleResult, error) {`
`21`	`21`	`return nil, errors.Wrap(err, "Error getting the state for virtual machine")`
`22`	`22`	`}`
`23`	`23`
`24`		`- clusterConfig, err := getClusterConfig(vm.bundle)`
	`24`	`+ clusterConfig, err := getClusterConfig(vm.Bundle())`
`25`	`25`	`if err != nil {`
`26`	`26`	`return nil, errors.Wrap(err, "Error loading cluster configuration")`
`27`	`27`	`}`
Original file line number	Diff line number	Diff line change
`@@ -111,7 +111,7 @@ func loadVM(client client) (bundle.CrcBundleInfo, *crcssh.Runner, error) {`
`111`	`111`	`}`
`112`	`112`	`defer vm.Close()`
`113`	`113`
`114`		`- currentState, err := vm.Driver.GetState()`
	`114`	`+ currentState, err := vm.Driver().GetState()`
`115`	`115`	`if err != nil {`
`116`	`116`	`return nil, nil, errors.Wrap(err, "Cannot get machine state")`
`117`	`117`	`}`
`@@ -124,5 +124,5 @@ func loadVM(client client) (bundle.CrcBundleInfo, *crcssh.Runner, error) {`
`124`	`124`	`return nil, nil, errors.Wrap(err, "Error creating the ssh client")`
`125`	`125`	`}`
`126`	`126`
`127`		`- return vm.bundle, sshRunner, nil`
	`127`	`+ return vm.Bundle(), sshRunner, nil`
`128`	`128`	`}`
Original file line number	Diff line number	Diff line change
`@@ -21,6 +21,6 @@ func (client client) ConnectionDetails() (types.ConnectionDetails, error) {`
`21`	`21`	`IP: ip,`
`22`	`22`	`SSHPort: vm.SSHPort(),`
`23`	`23`	`SSHUsername: constants.DefaultSSHUser,`
`24`		`- SSHKeys: []string{constants.GetPrivateKeyPath(), constants.GetECDSAPrivateKeyPath(), vm.bundle.GetSSHKeyPath()},`
	`24`	`+ SSHKeys: []string{constants.GetPrivateKeyPath(), constants.GetECDSAPrivateKeyPath(), vm.Bundle().GetSSHKeyPath()},`
`25`	`25`	`}, nil`
`26`	`26`	`}`
Original file line number	Diff line number	Diff line change
`@@ -60,48 +60,48 @@ func getCrcBundleInfo(preset crcPreset.Preset, bundleName, bundlePath string, en`
`60`	`60`	`return bundle.Use(bundleName)`
`61`	`61`	`}`
`62`	`62`
`63`		`-func (client client) updateVMConfig(startConfig types.StartConfig, vm virtualMachine) error {`
	`63`	`+func (client *client) updateVMConfig(startConfig types.StartConfig, vm VirtualMachine) error {`
`64`	`64`	`/* Memory */`
`65`	`65`	`logging.Debugf("Updating CRC VM configuration")`
`66`		`- if err := setMemory(vm.Host, startConfig.Memory); err != nil {`
	`66`	`+ if err := setMemory(vm.Host(), startConfig.Memory); err != nil {`
`67`	`67`	`logging.Debugf("Failed to update CRC VM configuration: %v", err)`
`68`	`68`	`if err == drivers.ErrNotImplemented {`
`69`	`69`	`logging.Warn("Memory configuration change has been ignored as the machine driver does not support it")`
`70`	`70`	`} else {`
`71`	`71`	`return err`
`72`	`72`	`}`
`73`	`73`	`}`
`74`		`- if err := setVcpus(vm.Host, startConfig.CPUs); err != nil {`
	`74`	`+ if err := setVcpus(vm.Host(), startConfig.CPUs); err != nil {`
`75`	`75`	`logging.Debugf("Failed to update CRC VM configuration: %v", err)`
`76`	`76`	`if err == drivers.ErrNotImplemented {`
`77`	`77`	`logging.Warn("CPU configuration change has been ignored as the machine driver does not support it")`
`78`	`78`	`} else {`
`79`	`79`	`return err`
`80`	`80`	`}`
`81`	`81`	`}`
`82`		`- if err := vm.api.Save(vm.Host); err != nil {`
	`82`	`+ if err := vm.API().Save(vm.Host()); err != nil {`
`83`	`83`	`return err`
`84`	`84`	`}`
`85`	`85`
`86`	`86`	`/* Disk size */`
`87`	`87`	`if startConfig.DiskSize != constants.DefaultDiskSize {`
`88`		`- if err := setDiskSize(vm.Host, startConfig.DiskSize); err != nil {`
	`88`	`+ if err := setDiskSize(vm.Host(), startConfig.DiskSize); err != nil {`
`89`	`89`	`logging.Debugf("Failed to update CRC disk configuration: %v", err)`
`90`	`90`	`if err == drivers.ErrNotImplemented {`
`91`	`91`	`logging.Warn("Disk size configuration change has been ignored as the machine driver does not support it")`
`92`	`92`	`} else {`
`93`	`93`	`return err`
`94`	`94`	`}`
`95`	`95`	`}`
`96`		`- if err := vm.api.Save(vm.Host); err != nil {`
	`96`	`+ if err := vm.API().Save(vm.Host()); err != nil {`
`97`	`97`	`return err`
`98`	`98`	`}`
`99`	`99`	`}`
`100`	`100`
`101`	`101`	`// we want to set the shared dir password on-the-fly to be used`
`102`	`102`	`// we do not want this value to be persisted to disk`
`103`	`103`	`if startConfig.SharedDirPassword != "" {`
`104`		`- if err := setSharedDirPassword(vm.Host, startConfig.SharedDirPassword); err != nil {`
	`104`	`+ if err := setSharedDirPassword(vm.Host(), startConfig.SharedDirPassword); err != nil {`
`105`	`105`	`return fmt.Errorf("Failed to set shared dir password: %w", err)`
`106`	`106`	`}`
`107`	`107`	`}`
`@@ -206,9 +206,9 @@ func growLVForMicroshift(sshRunner *crcssh.Runner, lvFullName string, rootPart s`
`206`	`206`	`return nil`
`207`	`207`	`}`
`208`	`208`
`209`		`-func configureSharedDirs(vm virtualMachine, sshRunner crcssh.Runner) error {`
	`209`	`+func configureSharedDirs(vm VirtualMachine, sshRunner *crcssh.Runner) error {`
`210`	`210`	`logging.Debugf("Configuring shared directories")`
`211`		`- sharedDirs, err := vm.Driver.GetSharedDirs()`
	`211`	`+ sharedDirs, err := vm.Driver().GetSharedDirs()`
`212`	`212`	`if err != nil {`
`213`	`213`	`// the libvirt machine driver uses net/rpc, which wraps errors`
`214`	`214`	`// in rpc.ServerError, but without using golang 1.13 error`
`@@ -334,7 +334,7 @@ func (client *client) Start(ctx context.Context, startConfig types.StartConfig)`
`334`	`334`	`}`
`335`	`335`	`defer vm.Close()`
`336`	`336`
`337`		`- currentBundleName := vm.bundle.GetBundleName()`
	`337`	`+ currentBundleName := vm.Bundle().GetBundleName()`
`338`	`338`	`if currentBundleName != bundleName {`
`339`	`339`	`logging.Debugf("Bundle '%s' was requested, but the existing VM is using '%s'",`
`340`	`340`	`bundleName, currentBundleName)`
`@@ -347,8 +347,8 @@ func (client *client) Start(ctx context.Context, startConfig types.StartConfig)`
`347`	`347`	`return nil, errors.Wrap(err, "Error getting the machine state")`
`348`	`348`	`}`
`349`	`349`	`if vmState == state.Running {`
`350`		`- logging.Infof("A CRC VM for %s %s is already running", startConfig.Preset.ForDisplay(), vm.bundle.GetVersion())`
`351`		`- clusterConfig, err := getClusterConfig(vm.bundle)`
	`350`	`+ logging.Infof("A CRC VM for %s %s is already running", startConfig.Preset.ForDisplay(), vm.Bundle().GetVersion())`
	`351`	`+ clusterConfig, err := getClusterConfig(vm.Bundle())`
`352`	`352`	`if err != nil {`
`353`	`353`	`return nil, errors.Wrap(err, "Cannot create cluster configuration")`
`354`	`354`	`}`
`@@ -365,7 +365,7 @@ func (client *client) Start(ctx context.Context, startConfig types.StartConfig)`
`365`	`365`	`return nil, err`
`366`	`366`	`}`
`367`	`367`
`368`		`- logging.Infof("Starting CRC VM for %s %s...", startConfig.Preset, vm.bundle.GetVersion())`
	`368`	`+ logging.Infof("Starting CRC VM for %s %s...", startConfig.Preset, vm.Bundle().GetVersion())`
`369`	`369`
`370`	`370`	`if client.useVSock() {`
`371`	`371`	`if err := exposePorts(startConfig.Preset, startConfig.IngressHTTPPort, startConfig.IngressHTTPSPort); err != nil {`
`@@ -457,7 +457,7 @@ func (client *client) Start(ctx context.Context, startConfig types.StartConfig)`
`457`	`457`	`return nil, errors.Wrap(err, "Failed to change permissions to root podman socket")`
`458`	`458`	`}`
`459`	`459`
`460`		`- proxyConfig, err := getProxyConfig(vm.bundle)`
	`460`	`+ proxyConfig, err := getProxyConfig(vm.Bundle())`
`461`	`461`	`if err != nil {`
`462`	`462`	`return nil, errors.Wrap(err, "Error getting proxy configuration")`
`463`	`463`	`}`
`@@ -472,7 +472,7 @@ func (client *client) Start(ctx context.Context, startConfig types.StartConfig)`
`472`	`472`	`SSHRunner: sshRunner,`
`473`	`473`	`IP: instanceIP,`
`474`	`474`	`// TODO: should be more finegrained`
`475`		`- BundleMetadata: *vm.bundle,`
	`475`	`+ BundleMetadata: *vm.Bundle(),`
`476`	`476`	`NetworkMode: client.networkMode(),`
`477`	`477`	`}`
`478`	`478`
`@@ -502,7 +502,7 @@ func (client *client) Start(ctx context.Context, startConfig types.StartConfig)`
`502`	`502`	`logging.Warn(fmt.Sprintf("Failed to query DNS from host: %v", err))`
`503`	`503`	`}`
`504`	`504`
`505`		`- if vm.bundle.IsMicroshift() {`
	`505`	`+ if vm.Bundle().IsMicroshift() {`
`506`	`506`	`// **************************`
`507`	`507`	`// END OF MICROSHIFT START CODE`
`508`	`508`	`// **************************`
`@@ -547,7 +547,7 @@ func (client *client) Start(ctx context.Context, startConfig types.StartConfig)`
`547`	`547`	`ocConfig := oc.UseOCWithSSH(sshRunner)`
`548`	`548`
`549`	`549`	`if err := cluster.ApproveCSRAndWaitForCertsRenewal(ctx, sshRunner, ocConfig, certsExpired[cluster.KubeletClientCert], certsExpired[cluster.KubeletServerCert], certsExpired[cluster.AggregatorClientCert]); err != nil {`
`550`		`- logBundleDate(vm.bundle)`
	`550`	`+ logBundleDate(vm.Bundle())`
`551`	`551`	`return nil, errors.Wrap(err, "Failed to renew TLS certificates: please check if a newer CRC release is available")`
`552`	`552`	`}`
`553`	`553`
`@@ -596,7 +596,7 @@ func (client *client) Start(ctx context.Context, startConfig types.StartConfig)`
`596`	`596`	`}`
`597`	`597`	`}`
`598`	`598`
`599`		`- if err := updateKubeconfig(ctx, ocConfig, sshRunner, vm.bundle.GetKubeConfigPath()); err != nil {`
	`599`	`+ if err := updateKubeconfig(ctx, ocConfig, sshRunner, vm.Bundle().GetKubeConfigPath()); err != nil {`
`600`	`600`	`return nil, errors.Wrap(err, "Failed to update kubeconfig file")`
`601`	`601`	`}`
`602`	`602`
`@@ -607,7 +607,7 @@ func (client *client) Start(ctx context.Context, startConfig types.StartConfig)`
`607`	`607`
`608`	`608`	`waitForProxyPropagation(ctx, ocConfig, proxyConfig)`
`609`	`609`
`610`		`- clusterConfig, err := getClusterConfig(vm.bundle)`
	`610`	`+ clusterConfig, err := getClusterConfig(vm.Bundle())`
`611`	`611`	`if err != nil {`
`612`	`612`	`return nil, errors.Wrap(err, "Cannot get cluster configuration")`
`613`	`613`	`}`
`@@ -694,17 +694,17 @@ func createHost(machineConfig config.MachineConfig, preset crcPreset.Preset) err`
`694`	`694`	`return nil`
`695`	`695`	`}`
`696`	`696`
`697`		`-func startHost(ctx context.Context, vm *virtualMachine) error {`
`698`		`- if err := vm.Driver.Start(); err != nil {`
	`697`	`+func startHost(ctx context.Context, vm VirtualMachine) error {`
	`698`	`+ if err := vm.Driver().Start(); err != nil {`
`699`	`699`	`return fmt.Errorf("Error in driver during machine start: %s", err)`
`700`	`700`	`}`
`701`	`701`
`702`		`- if err := vm.api.Save(vm.Host); err != nil {`
	`702`	`+ if err := vm.API().Save(vm.Host()); err != nil {`
`703`	`703`	`return fmt.Errorf("Error saving virtual machine to store after attempting creation: %s", err)`
`704`	`704`	`}`
`705`	`705`
`706`	`706`	`logging.Debug("Waiting for machine to be running, this may take a few minutes...")`
`707`		`- if err := crcerrors.Retry(ctx, 3time.Minute, host.MachineInState(vm.Driver, libmachinestate.Running), 3time.Second); err != nil {`
	`707`	`+ if err := crcerrors.Retry(ctx, 3time.Minute, host.MachineInState(vm.Driver(), libmachinestate.Running), 3time.Second); err != nil {`
`708`	`708`	`return fmt.Errorf("Error waiting for machine to be running: %s", err)`
`709`	`709`	`}`
`710`	`710`