Split cluster package into multiple files

pkg/minikube/cluster/delete.go

@@ -0,0 +1,60 @@
+package cluster
+
+import (
+	"os/exec"
+
+	"github.com/docker/machine/libmachine"
+	"github.com/docker/machine/libmachine/mcnerror"
+	"github.com/docker/machine/libmachine/state"
+	"github.com/golang/glog"
+	"github.com/pkg/errors"
+	"k8s.io/minikube/pkg/drivers/kic/oci"
+	"k8s.io/minikube/pkg/minikube/driver"
+	"k8s.io/minikube/pkg/minikube/out"
+)
+
+// deleteOrphanedKIC attempts to delete an orphaned docker instance
+func deleteOrphanedKIC(name string) {
+	cmd := exec.Command(oci.Docker, "rm", "-f", "-v", name)
+	err := cmd.Run()
+	if err == nil {
+		glog.Infof("Found stale kic container and successfully cleaned it up!")
+	}
+}
+
+// DeleteHost deletes the host VM.
+func DeleteHost(api libmachine.API, machineName string) error {
+	host, err := api.Load(machineName)
+	if err != nil && host == nil {
+		deleteOrphanedKIC(machineName)
+		// keep going even if minikube  does not know about the host
+	}
+
+	// Get the status of the host. Ensure that it exists before proceeding ahead.
+	status, err := GetHostStatus(api, machineName)
+	if err != nil {
+		// Warn, but proceed
+		out.WarningT("Unable to get the status of the {{.name}} cluster.", out.V{"name": machineName})
+	}
+
+	if status == state.None.String() {
+		return mcnerror.ErrHostDoesNotExist{Name: machineName}
+	}
+
+	// This is slow if SSH is not responding, but HyperV hangs otherwise, See issue #2914
+	if host.Driver.DriverName() == driver.HyperV {
+		if err := trySSHPowerOff(host); err != nil {
+			glog.Infof("Unable to power off minikube because the host was not found.")
+		}
+		out.T(out.DeletingHost, "Successfully powered off Hyper-V. minikube driver -- {{.driver}}", out.V{"driver": host.Driver.DriverName()})
+	}
+
+	out.T(out.DeletingHost, `Deleting "{{.profile_name}}" in {{.driver_name}} ...`, out.V{"profile_name": machineName, "driver_name": host.DriverName})
+	if err := host.Driver.Remove(); err != nil {
+		return errors.Wrap(err, "host remove")
+	}
+	if err := api.Remove(machineName); err != nil {
+		return errors.Wrap(err, "api remove")
+	}
+	return nil
+}

pkg/minikube/cluster/docker_env.go

@@ -0,0 +1,50 @@
+package cluster
+
+import (
+	"fmt"
+	"net"
+
+	"github.com/docker/machine/libmachine"
+	"github.com/pkg/errors"
+	"github.com/spf13/viper"
+	"k8s.io/minikube/pkg/drivers/kic"
+	"k8s.io/minikube/pkg/drivers/kic/oci"
+	"k8s.io/minikube/pkg/minikube/config"
+	"k8s.io/minikube/pkg/minikube/constants"
+	"k8s.io/minikube/pkg/minikube/driver"
+	"k8s.io/minikube/pkg/minikube/localpath"
+)
+
+// GetHostDockerEnv gets the necessary docker env variables to allow the use of docker through minikube's vm
+func GetHostDockerEnv(api libmachine.API) (map[string]string, error) {
+	pName := viper.GetString(config.MachineProfile)
+	host, err := CheckIfHostExistsAndLoad(api, pName)
+	if err != nil {
+		return nil, errors.Wrap(err, "Error checking that api exists and loading it")
+	}
+
+	ip := kic.DefaultBindIPV4
+	if !driver.IsKIC(host.Driver.DriverName()) { // kic externally accessible ip is different that node ip
+		ip, err = host.Driver.GetIP()
+		if err != nil {
+			return nil, errors.Wrap(err, "Error getting ip from host")
+		}
+
+	}
+
+	tcpPrefix := "tcp://"
+	port := constants.DockerDaemonPort
+	if driver.IsKIC(host.Driver.DriverName()) { // for kic we need to find out what port docker allocated during creation
+		port, err = oci.HostPortBinding(host.Driver.DriverName(), pName, constants.DockerDaemonPort)
+		if err != nil {
+			return nil, errors.Wrapf(err, "get hostbind port for %d", constants.DockerDaemonPort)
+		}
+	}
+
+	envMap := map[string]string{
+		"DOCKER_TLS_VERIFY": "1",
+		"DOCKER_HOST":       tcpPrefix + net.JoinHostPort(ip, fmt.Sprint(port)),
+		"DOCKER_CERT_PATH":  localpath.MakeMiniPath("certs"),
+	}
+	return envMap, nil
+}

pkg/minikube/cluster/info.go

@@ -0,0 +1,100 @@
+package cluster
+
+import (
+	"io/ioutil"
+
+	"github.com/docker/machine/libmachine/drivers"
+	"github.com/docker/machine/libmachine/provision"
+	"github.com/golang/glog"
+	"github.com/shirou/gopsutil/cpu"
+	"github.com/shirou/gopsutil/disk"
+	"github.com/shirou/gopsutil/mem"
+	"k8s.io/minikube/pkg/minikube/config"
+	"k8s.io/minikube/pkg/minikube/driver"
+	"k8s.io/minikube/pkg/minikube/out"
+)
+
+type hostInfo struct {
+	Memory   int
+	CPUs     int
+	DiskSize int
+}
+
+func megs(bytes uint64) int {
+	return int(bytes / 1024 / 1024)
+}
+
+func getHostInfo() (*hostInfo, error) {
+	i, err := cpu.Info()
+	if err != nil {
+		glog.Warningf("Unable to get CPU info: %v", err)
+		return nil, err
+	}
+	v, err := mem.VirtualMemory()
+	if err != nil {
+		glog.Warningf("Unable to get mem info: %v", err)
+		return nil, err
+	}
+	d, err := disk.Usage("/")
+	if err != nil {
+		glog.Warningf("Unable to get disk info: %v", err)
+		return nil, err
+	}
+
+	var info hostInfo
+	info.CPUs = len(i)
+	info.Memory = megs(v.Total)
+	info.DiskSize = megs(d.Total)
+	return &info, nil
+}
+
+// showLocalOsRelease shows systemd information about the current linux distribution, on the local host
+func showLocalOsRelease() {
+	osReleaseOut, err := ioutil.ReadFile("/etc/os-release")
+	if err != nil {
+		glog.Errorf("ReadFile: %v", err)
+		return
+	}
+
+	osReleaseInfo, err := provision.NewOsRelease(osReleaseOut)
+	if err != nil {
+		glog.Errorf("NewOsRelease: %v", err)
+		return
+	}
+
+	out.T(out.Provisioner, "OS release is {{.pretty_name}}", out.V{"pretty_name": osReleaseInfo.PrettyName})
+}
+
+// showRemoteOsRelease shows systemd information about the current linux distribution, on the remote VM
+func showRemoteOsRelease(driver drivers.Driver) {
+	provisioner, err := provision.DetectProvisioner(driver)
+	if err != nil {
+		glog.Errorf("DetectProvisioner: %v", err)
+		return
+	}
+
+	osReleaseInfo, err := provisioner.GetOsReleaseInfo()
+	if err != nil {
+		glog.Errorf("GetOsReleaseInfo: %v", err)
+		return
+	}
+
+	glog.Infof("Provisioned with %s", osReleaseInfo.PrettyName)
+}
+
+// showHostInfo shows host information
+func showHostInfo(cfg config.MachineConfig) {
+	if driver.BareMetal(cfg.VMDriver) {
+		info, err := getHostInfo()
+		if err == nil {
+			out.T(out.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})
+		}
+	} else if driver.IsKIC(cfg.VMDriver) {
+		info, err := getHostInfo() // TODO medyagh: get docker-machine info for non linux
+		if err == nil {
+			out.T(out.StartingVM, "Creating Kubernetes in {{.driver_name}} container with (CPUs={{.number_of_cpus}}), Memory={{.memory_size}}MB ({{.host_memory_size}}MB available) ...", out.V{"driver_name": cfg.VMDriver, "number_of_cpus": cfg.CPUs, "number_of_host_cpus": info.CPUs, "memory_size": cfg.Memory, "host_memory_size": info.Memory})
+		}
+	} else {
+		out.T(out.StartingVM, "Creating {{.driver_name}} VM (CPUs={{.number_of_cpus}}, Memory={{.memory_size}}MB, Disk={{.disk_size}}MB) ...", out.V{"driver_name": cfg.VMDriver, "number_of_cpus": cfg.CPUs, "memory_size": cfg.Memory, "disk_size": cfg.DiskSize})
+	}
+}

pkg/minikube/cluster/ip.go

@@ -0,0 +1,92 @@
+package cluster
+
+import (
+	"fmt"
+	"net"
+	"os/exec"
+	"regexp"
+
+	"github.com/docker/machine/libmachine"
+	"github.com/docker/machine/libmachine/host"
+	"github.com/pkg/errors"
+	"k8s.io/minikube/pkg/drivers/kic"
+	"k8s.io/minikube/pkg/minikube/driver"
+)
+
+// GetVMHostIP gets the ip address to be used for mapping host -> VM and VM -> host
+func GetVMHostIP(host *host.Host) (net.IP, error) {
+	switch host.DriverName {
+	case driver.KVM2:
+		return net.ParseIP("192.168.39.1"), nil
+	case driver.HyperV:
+		re := regexp.MustCompile(`"VSwitch": "(.*?)",`)
+		// TODO(aprindle) Change this to deserialize the driver instead
+		hypervVirtualSwitch := re.FindStringSubmatch(string(host.RawDriver))[1]
+		ip, err := getIPForInterface(fmt.Sprintf("vEthernet (%s)", hypervVirtualSwitch))
+		if err != nil {
+			return []byte{}, errors.Wrap(err, fmt.Sprintf("ip for interface (%s)", hypervVirtualSwitch))
+		}
+		return ip, nil
+	case driver.VirtualBox:
+		out, err := exec.Command(driver.VBoxManagePath(), "showvminfo", host.Name, "--machinereadable").Output()
+		if err != nil {
+			return []byte{}, errors.Wrap(err, "vboxmanage")
+		}
+		re := regexp.MustCompile(`hostonlyadapter2="(.*?)"`)
+		iface := re.FindStringSubmatch(string(out))[1]
+		ip, err := getIPForInterface(iface)
+		if err != nil {
+			return []byte{}, errors.Wrap(err, "Error getting VM/Host IP address")
+		}
+		return ip, nil
+	case driver.HyperKit:
+		return net.ParseIP("192.168.64.1"), nil
+	case driver.VMware:
+		vmIPString, err := host.Driver.GetIP()
+		if err != nil {
+			return []byte{}, errors.Wrap(err, "Error getting VM IP address")
+		}
+		vmIP := net.ParseIP(vmIPString).To4()
+		if vmIP == nil {
+			return []byte{}, errors.Wrap(err, "Error converting VM IP address to IPv4 address")
+		}
+		return net.IPv4(vmIP[0], vmIP[1], vmIP[2], byte(1)), nil
+	default:
+		return []byte{}, errors.New("Error, attempted to get host ip address for unsupported driver")
+	}
+}
+
+// GetHostDriverIP gets the ip address of the current minikube cluster
+func GetHostDriverIP(api libmachine.API, machineName string) (net.IP, error) {
+	host, err := CheckIfHostExistsAndLoad(api, machineName)
+	if err != nil {
+		return nil, err
+	}
+
+	ipStr, err := host.Driver.GetIP()
+	if err != nil {
+		return nil, errors.Wrap(err, "getting IP")
+	}
+	if driver.IsKIC(host.DriverName) {
+		ipStr = kic.DefaultBindIPV4
+	}
+	ip := net.ParseIP(ipStr)
+	if ip == nil {
+		return nil, fmt.Errorf("parsing IP: %s", ipStr)
+	}
+	return ip, nil
+}
+
+// Based on code from http://stackoverflow.com/questions/23529663/how-to-get-all-addresses-and-masks-from-local-interfaces-in-go
+func getIPForInterface(name string) (net.IP, error) {
+	i, _ := net.InterfaceByName(name)
+	addrs, _ := i.Addrs()
+	for _, a := range addrs {
+		if ipnet, ok := a.(*net.IPNet); ok {
+			if ip := ipnet.IP.To4(); ip != nil {
+				return ip, nil
+			}
+		}
+	}
+	return nil, errors.Errorf("Error finding IPV4 address for %s", name)
+}

pkg/minikube/cluster/iso.go

@@ -0,0 +1,14 @@
+package cluster
+
+import (
+	"k8s.io/minikube/pkg/minikube/config"
+	"k8s.io/minikube/pkg/minikube/driver"
+)
+
+// CacheISO downloads and caches ISO.
+func CacheISO(cfg config.MachineConfig) error {
+	if driver.BareMetal(cfg.VMDriver) {
+		return nil
+	}
+	return cfg.Downloader.CacheMinikubeISOFromURL(cfg.MinikubeISO)
+}