drivers/virtualbox: Add

Author: rajivr

drivers/virtualbox/disk.go

@@ -0,0 +1,141 @@
+package virtualbox
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+
+	"github.com/docker/machine/libmachine/log"
+	"github.com/docker/machine/libmachine/mcnutils"
+)
+
+type VirtualDisk struct {
+	UUID string
+	Path string
+}
+
+type DiskCreator interface {
+	Create(size int, publicSSHKeyPath, diskPath string) error
+}
+
+func NewDiskCreator() DiskCreator {
+	return &defaultDiskCreator{}
+}
+
+type defaultDiskCreator struct{}
+
+// Make a boot2docker VM disk image.
+func (c *defaultDiskCreator) Create(size int, publicSSHKeyPath, diskPath string) error {
+	log.Debugf("Creating %d MB hard disk image...", size)
+
+	tarBuf, err := mcnutils.MakeDiskImage(publicSSHKeyPath)
+	if err != nil {
+		return err
+	}
+
+	log.Debug("Calling inner createDiskImage")
+
+	return createDiskImage(diskPath, size, tarBuf)
+}
+
+// createDiskImage makes a disk image at dest with the given size in MB. If r is
+// not nil, it will be read as a raw disk image to convert from.
+func createDiskImage(dest string, size int, r io.Reader) error {
+	// Convert a raw image from stdin to the dest VMDK image.
+	sizeBytes := int64(size) << 20 // usually won't fit in 32-bit int (max 2GB)
+	// FIXME: why isn't this just using the vbm*() functions?
+	cmd := exec.Command(vboxManageCmd, "convertfromraw", "stdin", dest,
+		fmt.Sprintf("%d", sizeBytes), "--format", "VMDK")
+
+	log.Debug(cmd)
+
+	if os.Getenv("MACHINE_DEBUG") != "" {
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+	}
+
+	stdin, err := cmd.StdinPipe()
+	if err != nil {
+		return err
+	}
+
+	log.Debug("Starting command")
+
+	if err := cmd.Start(); err != nil {
+		return err
+	}
+
+	log.Debug("Copying to stdin")
+
+	n, err := io.Copy(stdin, r)
+	if err != nil {
+		return err
+	}
+
+	log.Debug("Filling zeroes")
+
+	// The total number of bytes written to stdin must match sizeBytes, or
+	// VBoxManage.exe on Windows will fail. Fill remaining with zeros.
+	if left := sizeBytes - n; left > 0 {
+		if err := zeroFill(stdin, left); err != nil {
+			return err
+		}
+	}
+
+	log.Debug("Closing STDIN")
+
+	// cmd won't exit until the stdin is closed.
+	if err := stdin.Close(); err != nil {
+		return err
+	}
+
+	log.Debug("Waiting on cmd")
+
+	return cmd.Wait()
+}
+
+// zeroFill writes n zero bytes into w.
+func zeroFill(w io.Writer, n int64) error {
+	const blocksize = 32 << 10
+	zeros := make([]byte, blocksize)
+	var k int
+	var err error
+	for n > 0 {
+		if n > blocksize {
+			k, err = w.Write(zeros)
+		} else {
+			k, err = w.Write(zeros[:n])
+		}
+		if err != nil {
+			return err
+		}
+		n -= int64(k)
+	}
+	return nil
+}
+
+func getVMDiskInfo(name string, vbox VBoxManager) (*VirtualDisk, error) {
+	out, err := vbox.vbmOut("showvminfo", name, "--machinereadable")
+	if err != nil {
+		return nil, err
+	}
+
+	disk := &VirtualDisk{}
+
+	err = parseKeyValues(out, reEqualQuoteLine, func(key, val string) error {
+		switch key {
+		case "SATA-1-0":
+			disk.Path = val
+		case "SATA-ImageUUID-1-0":
+			disk.UUID = val
+		}
+
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return disk, nil
+}

drivers/virtualbox/disk_test.go

@@ -0,0 +1,55 @@
+package virtualbox
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+const stdOutDiskInfo = `
+storagecontrollerbootable0="on"
+"SATA-0-0"="/home/ehazlett/.boot2docker/boot2docker.iso"
+"SATA-IsEjected"="off"
+"SATA-1-0"="/home/ehazlett/vm/test/disk.vmdk"
+"SATA-ImageUUID-1-0"="12345-abcdefg"
+"SATA-2-0"="none"
+nic1="nat"`
+
+func TestVMDiskInfo(t *testing.T) {
+	vbox := &VBoxManagerMock{
+		args:   "showvminfo default --machinereadable",
+		stdOut: stdOutDiskInfo,
+	}
+
+	disk, err := getVMDiskInfo("default", vbox)
+
+	assert.Equal(t, "/home/ehazlett/vm/test/disk.vmdk", disk.Path)
+	assert.Equal(t, "12345-abcdefg", disk.UUID)
+	assert.NoError(t, err)
+}
+
+func TestVMDiskInfoError(t *testing.T) {
+	vbox := &VBoxManagerMock{
+		args: "showvminfo default --machinereadable",
+		err:  errors.New("BUG"),
+	}
+
+	disk, err := getVMDiskInfo("default", vbox)
+
+	assert.Nil(t, disk)
+	assert.EqualError(t, err, "BUG")
+}
+
+func TestVMDiskInfoInvalidOutput(t *testing.T) {
+	vbox := &VBoxManagerMock{
+		args:   "showvminfo default --machinereadable",
+		stdOut: "INVALID",
+	}
+
+	disk, err := getVMDiskInfo("default", vbox)
+
+	assert.Empty(t, disk.Path)
+	assert.Empty(t, disk.UUID)
+	assert.NoError(t, err)
+}

drivers/virtualbox/ip.go

@@ -0,0 +1,36 @@
+package virtualbox
+
+import (
+	"time"
+
+	"github.com/docker/machine/libmachine/drivers"
+	"github.com/docker/machine/libmachine/mcnutils"
+)
+
+// IPWaiter waits for an IP to be configured.
+type IPWaiter interface {
+	Wait(d *Driver) error
+}
+
+func NewIPWaiter() IPWaiter {
+	return &sshIPWaiter{}
+}
+
+type sshIPWaiter struct{}
+
+func (w *sshIPWaiter) Wait(d *Driver) error {
+	// Wait for SSH over NAT to be available before returning to user
+	if err := drivers.WaitForSSH(d); err != nil {
+		return err
+	}
+
+	// Bail if we don't get an IP from DHCP after a given number of seconds.
+	if err := mcnutils.WaitForSpecific(d.hostOnlyIPAvailable, 5, 4*time.Second); err != nil {
+		return err
+	}
+
+	var err error
+	d.IPAddress, err = d.GetIP()
+
+	return err
+}

drivers/virtualbox/misc.go

@@ -0,0 +1,106 @@
+package virtualbox
+
+import (
+	"bufio"
+	"math/rand"
+	"os"
+
+	"time"
+
+	"github.com/docker/machine/libmachine/mcnutils"
+	"github.com/docker/machine/libmachine/ssh"
+)
+
+// B2DUpdater describes the interactions with b2d.
+type B2DUpdater interface {
+	UpdateISOCache(storePath, isoURL string) error
+	CopyIsoToMachineDir(storePath, machineName, isoURL string) error
+}
+
+func NewB2DUpdater() B2DUpdater {
+	return &b2dUtilsUpdater{}
+}
+
+type b2dUtilsUpdater struct{}
+
+func (u *b2dUtilsUpdater) CopyIsoToMachineDir(storePath, machineName, isoURL string) error {
+	return mcnutils.NewB2dUtils(storePath).CopyIsoToMachineDir(isoURL, machineName)
+}
+
+func (u *b2dUtilsUpdater) UpdateISOCache(storePath, isoURL string) error {
+	return mcnutils.NewB2dUtils(storePath).UpdateISOCache(isoURL)
+}
+
+// SSHKeyGenerator describes the generation of ssh keys.
+type SSHKeyGenerator interface {
+	Generate(path string) error
+}
+
+func NewSSHKeyGenerator() SSHKeyGenerator {
+	return &defaultSSHKeyGenerator{}
+}
+
+type defaultSSHKeyGenerator struct{}
+
+func (g *defaultSSHKeyGenerator) Generate(path string) error {
+	return ssh.GenerateSSHKey(path)
+}
+
+// LogsReader describes the reading of VBox.log
+type LogsReader interface {
+	Read(path string) ([]string, error)
+}
+
+func NewLogsReader() LogsReader {
+	return &vBoxLogsReader{}
+}
+
+type vBoxLogsReader struct{}
+
+func (c *vBoxLogsReader) Read(path string) ([]string, error) {
+	file, err := os.Open(path)
+	if err != nil {
+		return []string{}, err
+	}
+
+	defer file.Close()
+
+	lines := []string{}
+
+	scanner := bufio.NewScanner(file)
+	for scanner.Scan() {
+		lines = append(lines, scanner.Text())
+	}
+
+	return lines, nil
+}
+
+// RandomInter returns random int values.
+type RandomInter interface {
+	RandomInt(n int) int
+}
+
+func NewRandomInter() RandomInter {
+	return &defaultRandomInter{}
+}
+
+type defaultRandomInter struct{}
+
+func (d *defaultRandomInter) RandomInt(n int) int {
+	return rand.Intn(n)
+}
+
+// Sleeper sleeps for given duration.
+type Sleeper interface {
+	Sleep(d time.Duration)
+}
+
+func NewSleeper() Sleeper {
+	return &defaultSleeper{}
+}
+
+type defaultSleeper struct{}
+
+func (s *defaultSleeper) Sleep(d time.Duration) {
+	time.Sleep(d)
+}