Getting closer to actually mounting a volume...

* Added code to determine the current vitual machine
* Added configuration for storage location root on the host
  (Determining this programmatically would be even more tedious than the rest
  of this code)
* Started adding code to determine storage controller to attach disk to

Author: md5

main.go

@@ -1,12 +1,16 @@
 package main
 
 import (
+	"errors"
 	"flag"
 	"fmt"
 	"log"
+	"net"
 	"path/filepath"
+	"strings"
 	"sync"
 
+	"github.com/appropriate/go-virtualboxclient/vboxwebsrv"
 	"github.com/appropriate/go-virtualboxclient/virtualboxclient"
 	"github.com/calavera/dkvolume"
 )
@@ -18,9 +22,10 @@ const (
 )
 
 var (
-	socketAddress    = filepath.Join("/run/docker/plugins", fmt.Sprintf("%s.sock", pluginId))
-	defaultMountRoot = filepath.Join(dkvolume.DefaultDockerRootDirectory, fmt.Sprintf("_%s", pluginId))
-	mountRoot        = flag.String("mount-root", defaultMountRoot, "VirtualBox volumes root mount directory")
+	socketAddress       = filepath.Join("/run/docker/plugins", fmt.Sprintf("%s.sock", pluginId))
+	defaultMountRoot    = filepath.Join(dkvolume.DefaultDockerRootDirectory, fmt.Sprintf("_%s", pluginId))
+	mountRoot           = flag.String("mount-root", defaultMountRoot, "VirtualBox volumes root mount directory (on VM)")
+	storageLocationRoot = flag.String("storage-location-root", "", "VirtualBox volumes root storage location directory (on host)")
 
 	vboxwebsrvUsername = flag.String("vboxwebsrv-username", "", "Username to connect to vboxwebsrv")
 	vboxwebsrvPassword = flag.String("vboxwebsrv-password", "", "Password to connect to vboxwebsrv")
@@ -31,6 +36,7 @@ type virtualboxDriver struct {
 	sync.Mutex
 
 	virtualbox *virtualboxclient.VirtualBox
+	machine    *virtualboxclient.Machine
 	volumes    map[string]*virtualboxclient.Medium
 }
 
@@ -60,12 +66,25 @@ func (d virtualboxDriver) Create(r dkvolume.Request) dkvolume.Response {
 
 func (d virtualboxDriver) Mount(r dkvolume.Request) dkvolume.Response {
 	fmt.Printf("Mounting volume %#v\n", r)
+
+	scs, err := d.machine.GetStorageControllers()
+	if err != nil {
+		return dkvolume.Response{Err: err.Error()}
+	}
+
+	for _, sc := range scs {
+		fmt.Printf("%#v\n", sc)
+	}
+
 	return dkvolume.Response{}
 }
 
 func (d virtualboxDriver) Path(r dkvolume.Request) dkvolume.Response {
-	fmt.Printf("Pathing volume %#v\n", r)
-	return dkvolume.Response{}
+	mountpoint := d.mountPoint(r.Name)
+
+	fmt.Printf("Path %#v => %s\n", r, mountpoint)
+
+	return dkvolume.Response{Mountpoint: d.mountPoint(r.Name)}
 }
 
 func (d virtualboxDriver) Remove(r dkvolume.Request) dkvolume.Response {
@@ -89,13 +108,87 @@ func (d virtualboxDriver) Unmount(r dkvolume.Request) dkvolume.Response {
 }
 
 func (d virtualboxDriver) storageLocation(name string) string {
-	return filepath.Join("/Users/mike/.docker/machine/machines/dev", fmt.Sprintf("%s.vmdk", name))
+	return filepath.Join(*storageLocationRoot, fmt.Sprintf("%s.vmdk", name))
+}
+
+func (d virtualboxDriver) mountPoint(name string) string {
+	return filepath.Join(*mountRoot, name)
+}
+
+func (d virtualboxDriver) findCurrentMachine() (*virtualboxclient.Machine, error) {
+	var (
+		sp                 *virtualboxclient.SystemProperties
+		machines           []*virtualboxclient.Machine
+		chipset            *vboxwebsrv.ChipsetType
+		maxNetworkAdapters uint32
+		na                 *virtualboxclient.NetworkAdapter
+		mac                string
+		intfMacs           []string
+		interfaces         []net.Interface
+		err                error
+	)
+
+	interfaces, err = net.Interfaces()
+	if err != nil {
+		return nil, err
+	}
+
+	intfMacs = make([]string, len(interfaces))
+	for i, intf := range interfaces {
+		intfMacs[i] = strings.ToUpper(strings.Replace(intf.HardwareAddr.String(), ":", "", -1))
+	}
+
+	sp, err = d.virtualbox.GetSystemProperties()
+	if err != nil {
+		return nil, err
+	}
+
+	machines, err = d.virtualbox.GetMachines()
+	if err != nil {
+		return nil, err
+	}
+
+	for _, m := range machines {
+		chipset, err = m.GetChipsetType()
+		if err != nil {
+			return nil, err
+		}
+
+		maxNetworkAdapters, err = sp.GetMaxNetworkAdapters(chipset)
+		if err != nil {
+			return nil, err
+		}
+
+		for i := uint32(0); i < maxNetworkAdapters; i++ {
+			na, err = m.GetNetworkAdapter(i)
+			if err != nil {
+				return nil, err
+			}
+
+			mac, err = na.GetMACAddress()
+			if err != nil {
+				return nil, err
+			}
+
+			for _, intfMac := range intfMacs {
+				if mac == intfMac {
+					return m, nil
+				}
+			}
+		}
+	}
+
+	return nil, errors.New("Unable to find machine")
 }
 
 // TODO: Figure out why Ctrl+C doesn't immediately terminate
 func main() {
 	flag.Parse()
 
+	if storageLocationRoot == nil || *storageLocationRoot == "" {
+		log.Fatal("Storage location root must be specified with -storage-location-root")
+	}
+
 	virtualbox := virtualboxclient.New(*vboxwebsrvUsername, *vboxwebsrvPassword, *vboxwebsrvUrl)
 
 	if err := virtualbox.Logon(); err != nil {
@@ -106,6 +199,13 @@ func main() {
 		virtualbox: virtualbox,
 		volumes:    map[string]*virtualboxclient.Medium{},
 	}
+
+	if m, err := d.findCurrentMachine(); err != nil {
+		log.Fatal(err)
+	} else {
+		d.machine = m
+	}
+
 	h := dkvolume.NewHandler(d)
 	fmt.Printf("Listening on %s\n", socketAddress)
 	fmt.Println(h.ServeUnix("root", socketAddress))