WIP: Add minikube support for the "generic" VM driver

cmd/minikube/cmd/delete.go

@@ -309,7 +309,7 @@ func deleteProfile(profile *config.Profile) error {
 		return DeletionError{Err: delErr, Errtype: MissingProfile}
 	}
 
-	if err == nil && driver.BareMetal(cc.Driver) {
+	if err == nil && (driver.BareMetal(cc.Driver) || cc.Driver == driver.Generic) {
 		if err := uninstallKubernetes(api, *cc, cc.Nodes[0], viper.GetString(cmdcfg.Bootstrapper)); err != nil {
 			deletionError, ok := err.(DeletionError)
 			if ok {

cmd/minikube/cmd/start.go

@@ -299,7 +299,7 @@ func provisionWithDriver(cmd *cobra.Command, ds registry.DriverState, existing *
 		os.Exit(0)
 	}
 
-	if driver.IsVM(driverName) {
+	if driver.IsVM(driverName) && driverName != driver.Generic {
 		url, err := download.ISO(viper.GetStringSlice(isoURL), cmd.Flags().Changed(isoURL))
 		if err != nil {
 			return node.Starter{}, errors.Wrap(err, "Failed to cache ISO")
@@ -812,7 +812,7 @@ func validateUser(drvName string) {
 
 // memoryLimits returns the amount of memory allocated to the system and hypervisor, the return value is in MiB
 func memoryLimits(drvName string) (int, int, error) {
-	info, cpuErr, memErr, diskErr := machine.CachedHostInfo()
+	info, cpuErr, memErr, diskErr := machine.LocalHostInfo()
 	if cpuErr != nil {
 		klog.Warningf("could not get system cpu info while verifying memory limits, which might be okay: %v", cpuErr)
 	}

cmd/minikube/cmd/start_flags.go

@@ -22,6 +22,7 @@ import (
 	"time"
 
 	"github.com/blang/semver"
+	"github.com/docker/machine/libmachine/drivers"
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
@@ -108,6 +109,10 @@ const (
 	kicBaseImage            = "base-image"
 	ports                   = "ports"
 	startNamespace          = "namespace"
+	genericIPAddress        = "generic-ip-address"
+	genericSSHUser          = "generic-ssh-user"
+	genericSSHKey           = "generic-ssh-key"
+	genericSSHPort          = "generic-ssh-port"
 )
 
 var (
@@ -217,6 +222,12 @@ func initNetworkingFlags() {
 	startCmd.Flags().String(serviceCIDR, constants.DefaultServiceCIDR, "The CIDR to be used for service cluster IPs.")
 	startCmd.Flags().StringArrayVar(&config.DockerEnv, "docker-env", nil, "Environment variables to pass to the Docker daemon. (format: key=value)")
 	startCmd.Flags().StringArrayVar(&config.DockerOpt, "docker-opt", nil, "Specify arbitrary flags to pass to the Docker daemon. (format: key=value)")
+
+	// generic
+	startCmd.Flags().String(genericIPAddress, "", "IP address (generic)")
+	startCmd.Flags().String(genericSSHUser, drivers.DefaultSSHUser, "SSH user (generic)")
+	startCmd.Flags().String(genericSSHKey, "", "SSH key (generic)")
+	startCmd.Flags().Int(genericSSHPort, drivers.DefaultSSHPort, "SSH port (generic)")
 }
 
 // ClusterFlagValue returns the current cluster name based on flags
@@ -326,6 +337,10 @@ func generateClusterConfig(cmd *cobra.Command, existing *config.ClusterConfig, k
 			NatNicType:              viper.GetString(natNicType),
 			StartHostTimeout:        viper.GetDuration(waitTimeout),
 			ExposedPorts:            viper.GetStringSlice(ports),
+			GenericIPAddress:        viper.GetString(genericIPAddress),
+			GenericSSHUser:          viper.GetString(genericSSHUser),
+			GenericSSHKey:           viper.GetString(genericSSHKey),
+			GenericSSHPort:          viper.GetInt(genericSSHPort),
 			KubernetesConfig: config.KubernetesConfig{
 				KubernetesVersion:      k8sVersion,
 				ClusterName:            ClusterFlagValue(),

pkg/minikube/cluster/ip.go

@@ -40,6 +40,12 @@ func HostIP(host *host.Host, clusterName string) (net.IP, error) {
 		return oci.RoutableHostIPFromInside(oci.Docker, clusterName, host.Name)
 	case driver.Podman:
 		return oci.RoutableHostIPFromInside(oci.Podman, clusterName, host.Name)
+	case driver.Generic:
+		ip, err := host.Driver.GetIP()
+		if err != nil {
+			return []byte{}, errors.Wrap(err, "Error getting VM/Host IP address")
+		}
+		return net.ParseIP(ip), nil
 	case driver.KVM2:
 		return net.ParseIP("192.168.39.1"), nil
 	case driver.HyperV:

pkg/minikube/config/types.go

@@ -66,6 +66,10 @@ type ClusterConfig struct {
 	HostDNSResolver         bool   // Only used by virtualbox
 	HostOnlyNicType         string // Only used by virtualbox
 	NatNicType              string // Only used by virtualbox
+	GenericIPAddress        string // Only used by generic
+	GenericSSHUser          string // Only used by generic
+	GenericSSHKey           string // Only used by generic
+	GenericSSHPort          int    // Only used by generic
 	KubernetesConfig        KubernetesConfig
 	Nodes                   []Node
 	Addons                  map[string]bool

pkg/minikube/driver/driver.go

@@ -39,6 +39,8 @@ const (
 	Mock = "mock"
 	// None driver
 	None = "none"
+	// Generic driver
+	Generic = "generic"
 	// KVM2 driver
 	KVM2 = "kvm2"
 	// VirtualBox driver
@@ -94,6 +96,10 @@ func MachineType(name string) string {
 		return "container"
 	}
 
+	if name == Generic {
+		return "bare metal machine"
+	}
+
 	if IsVM(name) {
 		return "VM"
 	}

pkg/minikube/driver/driver_darwin.go

@@ -26,7 +26,7 @@ var supportedDrivers = []string{
 	HyperKit,
 	VMware,
 	Docker,
-	Podman,
+	Generic,
 }
 
 func VBoxManagePath() string {

pkg/minikube/driver/driver_linux.go

@@ -29,6 +29,7 @@ var supportedDrivers = []string{
 	None,
 	Docker,
 	Podman,
+	Generic,
 }
 
 // VBoxManagePath returns the path to the VBoxManage command

pkg/minikube/driver/driver_test.go

@@ -65,6 +65,7 @@ func TestMachineType(t *testing.T) {
 		Docker:       "container",
 		Mock:         "bare metal machine",
 		None:         "bare metal machine",
+		Generic:      "bare metal machine",
 		KVM2:         "VM",
 		VirtualBox:   "VM",
 		HyperKit:     "VM",

pkg/minikube/driver/driver_windows.go

@@ -33,6 +33,7 @@ var supportedDrivers = []string{
 	HyperV,
 	VMware,
 	Docker,
+	Generic,
 }
 
 // TODO: medyagh add same check for kic docker

pkg/minikube/machine/fix.go

@@ -129,6 +129,15 @@ func recreateIfNeeded(api libmachine.API, cc *config.ClusterConfig, n *config.No
 		}
 	}
 
+	if h.Driver.DriverName() == driver.Generic {
+		if s == state.Running {
+			out.T(style.Running, `Using the {{.driver_name}} "{{.cluster}}" {{.machine_type}} ...`, out.V{"driver_name": cc.Driver, "cluster": cc.Name, "machine_type": machineType})
+		} else {
+			return h, errors.Errorf("not running")
+		}
+		return h, nil
+	}
+
 	if serr != constants.ErrMachineMissing {
 		klog.Warningf("unexpected machine state, will restart: %v", serr)
 	}

pkg/minikube/machine/info.go

@@ -19,6 +19,8 @@ package machine
 import (
 	"io/ioutil"
 	"os/exec"
+	"strconv"
+	"strings"
 
 	"github.com/docker/machine/libmachine/provision"
 	"github.com/shirou/gopsutil/cpu"
@@ -39,8 +41,8 @@ type HostInfo struct {
 	DiskSize int64
 }
 
-// CachedHostInfo returns system information such as memory,CPU, DiskSize
-func CachedHostInfo() (*HostInfo, error, error, error) {
+// LocalHostInfo returns system information such as memory,CPU, DiskSize
+func LocalHostInfo() (*HostInfo, error, error, error) {
 	var cpuErr, memErr, diskErr error
 	i, cpuErr := cachedCPUInfo()
 	if cpuErr != nil {
@@ -63,6 +65,43 @@ func CachedHostInfo() (*HostInfo, error, error, error) {
 	return &info, cpuErr, memErr, diskErr
 }
 
+// RemoteHostInfo returns system information such as memory,CPU, DiskSize
+func RemoteHostInfo(r command.Runner) (*HostInfo, error, error, error) {
+	rr, cpuErr := r.RunCmd(exec.Command("nproc"))
+	if cpuErr != nil {
+		klog.Warningf("Unable to get CPU info: %v", cpuErr)
+	}
+	nproc := rr.Stdout.String()
+	ncpus, err := strconv.Atoi(strings.TrimSpace(nproc))
+	if err != nil {
+		klog.Warningf("Failed to parse CPU info: %v", err)
+	}
+	rr, memErr := r.RunCmd(exec.Command("free", "-m"))
+	if memErr != nil {
+		klog.Warningf("Unable to get mem info: %v", memErr)
+	}
+	free := rr.Stdout.String()
+	memory, _, err := util.ParseMemFree(free)
+	if err != nil {
+		klog.Warningf("Unable to parse mem info: %v", err)
+	}
+	rr, diskErr := r.RunCmd(exec.Command("df", "-m"))
+	if diskErr != nil {
+		klog.Warningf("Unable to get disk info: %v", diskErr)
+	}
+	df := rr.Stdout.String()
+	disksize, _, err := util.ParseDiskFree(df, "/")
+	if err != nil {
+		klog.Warningf("Unable to parse disk info: %v", err)
+	}
+
+	var info HostInfo
+	info.CPUs = ncpus
+	info.Memory = int64(memory)
+	info.DiskSize = int64(disksize)
+	return &info, cpuErr, memErr, diskErr
+}
+
 // showLocalOsRelease shows systemd information about the current linux distribution, on the local host
 func showLocalOsRelease() {
 	osReleaseOut, err := ioutil.ReadFile("/etc/os-release")

pkg/minikube/machine/machine.go

@@ -104,7 +104,7 @@ func fastDetectProvisioner(h *host.Host) (libprovision.Provisioner, error) {
 	switch {
 	case driver.IsKIC(d):
 		return provision.NewUbuntuProvisioner(h.Driver), nil
-	case driver.BareMetal(d):
+	case driver.BareMetal(d), d == driver.Generic:
 		return libprovision.DetectProvisioner(h.Driver)
 	default:
 		return provision.NewBuildrootProvisioner(h.Driver), nil

pkg/minikube/machine/start.go

@@ -136,7 +136,9 @@ func createHost(api libmachine.API, cfg *config.ClusterConfig, n *config.Node) (
 			See https://minikube.sigs.k8s.io/docs/reference/drivers/vmware/ for more information.
 			To disable this message, run [minikube config set ShowDriverDeprecationNotification false]`)
 	}
-	showHostInfo(*cfg)
+	if cfg.Driver != driver.Generic {
+		showHostInfo(nil, *cfg)
+	}
 	def := registry.Driver(cfg.Driver)
 	if def.Empty() {
 		return nil, fmt.Errorf("unsupported/missing driver: %s", cfg.Driver)
@@ -170,11 +172,20 @@ func createHost(api libmachine.API, cfg *config.ClusterConfig, n *config.Node) (
 		return nil, errors.Wrap(err, "creating host")
 	}
 	klog.Infof("duration metric: libmachine.API.Create for %q took %s", cfg.Name, time.Since(cstart))
+	if cfg.Driver == driver.Generic {
+		showHostInfo(h, *cfg)
+	}
 
 	if err := postStartSetup(h, *cfg); err != nil {
 		return h, errors.Wrap(err, "post-start")
 	}
 
+	if h.Driver.DriverName() == driver.Generic {
+		if _, err := h.RunSSHCommand(fmt.Sprintf("sudo usermod -aG docker %s", h.Driver.GetSSHUsername())); err != nil {
+			return h, errors.Wrap(err, "usermod")
+		}
+	}
+
 	if err := saveHost(api, h, cfg, n); err != nil {
 		return h, err
 	}
@@ -290,7 +301,7 @@ func postStartSetup(h *host.Host, mc config.ClusterConfig) error {
 	if driver.BareMetal(mc.Driver) {
 		showLocalOsRelease()
 	}
-	if driver.IsVM(mc.Driver) || driver.IsKIC(mc.Driver) {
+	if driver.IsVM(mc.Driver) || driver.IsKIC(mc.Driver) || mc.Driver == driver.Generic {
 		logRemoteOsRelease(r)
 	}
 	return syncLocalAssets(r)
@@ -321,16 +332,29 @@ func acquireMachinesLock(name string, drv string) (mutex.Releaser, error) {
 }
 
 // showHostInfo shows host information
-func showHostInfo(cfg config.ClusterConfig) {
+func showHostInfo(h *host.Host, cfg config.ClusterConfig) {
 	machineType := driver.MachineType(cfg.Driver)
 	if driver.BareMetal(cfg.Driver) {
-		info, cpuErr, memErr, DiskErr := CachedHostInfo()
+		info, cpuErr, memErr, DiskErr := LocalHostInfo()
 		if cpuErr == nil && memErr == nil && DiskErr == nil {
 			register.Reg.SetStep(register.RunningLocalhost)
 			out.T(style.StartingNone, "Running on localhost (CPUs={{.number_of_cpus}}, Memory={{.memory_size}}MB, Disk={{.disk_size}}MB) ...", out.V{"number_of_cpus": info.CPUs, "memory_size": info.Memory, "disk_size": info.DiskSize})
 		}
 		return
 	}
+	if cfg.Driver == driver.Generic {
+		r, err := CommandRunner(h)
+		if err != nil {
+			klog.Warningf("error getting command runner: %v", err)
+			return
+		}
+		info, cpuErr, memErr, DiskErr := RemoteHostInfo(r)
+		if cpuErr == nil && memErr == nil && DiskErr == nil {
+			register.Reg.SetStep(register.RunningRemotely)
+			out.T(style.StartingGeneric, "Running remotely (CPUs={{.number_of_cpus}}, Memory={{.memory_size}}MB, Disk={{.disk_size}}MB) ...", out.V{"number_of_cpus": info.CPUs, "memory_size": info.Memory, "disk_size": info.DiskSize})
+		}
+		return
+	}
 	if driver.IsKIC(cfg.Driver) { // TODO:medyagh add free disk space on docker machine
 		register.Reg.SetStep(register.CreatingContainer)
 		out.T(style.StartingVM, "Creating {{.driver_name}} {{.machine_type}} (CPUs={{.number_of_cpus}}, Memory={{.memory_size}}MB) ...", out.V{"driver_name": cfg.Driver, "number_of_cpus": cfg.CPUs, "memory_size": cfg.Memory, "machine_type": machineType})

pkg/minikube/machine/stop.go

@@ -55,6 +55,10 @@ func stop(h *host.Host) error {
 		}
 	}
 
+	if h.DriverName == driver.Generic {
+		return nil
+	}
+
 	if err := h.Stop(); err != nil {
 		klog.Infof("stop err: %v", err)
 		st, ok := err.(mcnerror.ErrHostAlreadyInState)

pkg/minikube/out/register/register.go

@@ -29,6 +29,7 @@ const (
 	DownloadingArtifacts RegStep = "Downloading Artifacts"
 	StartingNode         RegStep = "Starting Node"
 	RunningLocalhost     RegStep = "Running on Localhost"
+	RunningRemotely      RegStep = "Running Remotely"
 	LocalOSRelease       RegStep = "Local OS Release"
 	CreatingContainer    RegStep = "Creating Container"
 	CreatingVM           RegStep = "Creating VM"
@@ -72,6 +73,7 @@ func init() {
 				LocalOSRelease,
 				CreatingContainer,
 				CreatingVM,
+				RunningRemotely,
 				PreparingKubernetes,
 				ConfiguringLHEnv,
 				VerifyingKubernetes,

pkg/minikube/registry/drvs/generic/generic.go

@@ -0,0 +1,62 @@
+/*
+Copyright 2019 The Kubernetes Authors All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package generic
+
+import (
+	"fmt"
+
+	"github.com/docker/machine/drivers/generic"
+	"github.com/docker/machine/libmachine/drivers"
+	"github.com/pkg/errors"
+
+	"k8s.io/minikube/pkg/minikube/config"
+	"k8s.io/minikube/pkg/minikube/driver"
+	"k8s.io/minikube/pkg/minikube/localpath"
+	"k8s.io/minikube/pkg/minikube/registry"
+)
+
+func init() {
+	err := registry.Register(registry.DriverDef{
+		Name:     driver.Generic,
+		Config:   configure,
+		Status:   status,
+		Priority: registry.Fallback,
+		Init:     func() drivers.Driver { return generic.NewDriver("", "") },
+	})
+	if err != nil {
+		panic(fmt.Sprintf("unable to register: %v", err))
+	}
+}
+
+func configure(cc config.ClusterConfig, n config.Node) (interface{}, error) {
+	d := generic.NewDriver(driver.MachineName(cc, n), localpath.MiniPath())
+
+	if cc.GenericIPAddress == "" {
+		return nil, errors.Errorf("please provide an IP address")
+	}
+
+	d.(*generic.Driver).IPAddress = cc.GenericIPAddress
+	d.(*generic.Driver).SSHUser = cc.GenericSSHUser
+	d.(*generic.Driver).SSHKey = cc.GenericSSHKey
+	d.(*generic.Driver).SSHPort = cc.GenericSSHPort
+
+	return d, nil
+}
+
+func status() registry.State {
+	return registry.State{Installed: true, Healthy: true}
+}