Merge pull request #2088 from dgageot/fix-get-hostname

Fix get hostname

drivers/amazonec2/amazonec2.go

@@ -470,6 +470,12 @@ func (d *Driver) GetState() (state.State, error) {
 	}
 }
 
+// GetSSHHostname -
+func (d *Driver) GetSSHHostname() (string, error) {
+	// TODO: use @nathanleclaire retry func here (ehazlett)
+	return d.GetIP()
+}
+
 func (d *Driver) GetSSHUsername() string {
 	if d.SSHUser == "" {
 		d.SSHUser = "ubuntu"

drivers/azure/azure.go

@@ -119,6 +119,10 @@ func NewDriver(hostName, storePath string) drivers.Driver {
 	return d
 }
 
+func (d *Driver) GetSSHHostname() (string, error) {
+	return d.GetIP()
+}
+
 func (d *Driver) GetSSHUsername() string {
 	if d.SSHUser == "" {
 		d.SSHUser = "ubuntu"

drivers/digitalocean/digitalocean.go

@@ -97,6 +97,10 @@ func NewDriver(hostName, storePath string) *Driver {
 	}
 }
 
+func (d *Driver) GetSSHHostname() (string, error) {
+	return d.GetIP()
+}
+
 func (d *Driver) DriverName() string {
 	return "digitalocean"
 }
@@ -226,6 +230,13 @@ func (d *Driver) GetURL() (string, error) {
 	return fmt.Sprintf("tcp://%s:2376", ip), nil
 }
 
+func (d *Driver) GetIP() (string, error) {
+	if d.IPAddress == "" {
+		return "", fmt.Errorf("IP address is not set")
+	}
+	return d.IPAddress, nil
+}
+
 func (d *Driver) GetState() (state.State, error) {
 	droplet, _, err := d.getClient().Droplets.Get(d.DropletID)
 	if err != nil {

drivers/exoscale/exoscale.go

@@ -103,6 +103,10 @@ func NewDriver(hostName, storePath string) drivers.Driver {
 	}
 }
 
+func (d *Driver) GetSSHHostname() (string, error) {
+	return d.GetIP()
+}
+
 func (d *Driver) GetSSHUsername() string {
 	return "ubuntu"
 }
@@ -146,6 +150,13 @@ func (d *Driver) GetURL() (string, error) {
 	return fmt.Sprintf("tcp://%s:2376", ip), nil
 }
 
+func (d *Driver) GetIP() (string, error) {
+	if d.IPAddress == "" {
+		return "", fmt.Errorf("IP address is not set")
+	}
+	return d.IPAddress, nil
+}
+
 func (d *Driver) GetState() (state.State, error) {
 	client := egoscale.NewClient(d.URL, d.ApiKey, d.ApiSecretKey)
 	vm, err := client.GetVirtualMachine(d.Id)

drivers/generic/generic.go

@@ -1,12 +1,10 @@
 package generic
 
 import (
-	"errors"
 	"fmt"
 	"net"
 	"os"
 	"path/filepath"
-	"strconv"
 	"time"
 
 	"github.com/docker/machine/libmachine/drivers"
@@ -18,50 +16,21 @@ import (
 
 type Driver struct {
 	*drivers.BaseDriver
-	sourceSSHKey string
+	SSHKey string
 }
 
 const (
-	driverName     = "generic"
+	defaultSSHUser = "root"
+	defaultSSHPort = 22
 	defaultTimeout = 1 * time.Second
 )
 
 var (
-	defaultSourceSSHKey = filepath.Join(mcnutils.GetHomeDir(), ".ssh", "id_rsa")
+	defaultSSHKey = filepath.Join(mcnutils.GetHomeDir(), ".ssh", "id_rsa")
 )
 
-// NewDriver creates and returns a new instance of the driver
+// GetCreateFlags registers the flags this driver adds to
-func NewDriver(hostName, storePath string) drivers.Driver {
+// "docker hosts create"
-	return &Driver{
-		BaseDriver: &drivers.BaseDriver{
-			MachineName: hostName,
-			StorePath:   storePath,
-		},
-		sourceSSHKey: defaultSourceSSHKey,
-	}
-}
-
-func (d *Driver) Create() error {
-	log.Info("Importing SSH key...")
-
-	// TODO: validate the key is a valid key
-	if err := mcnutils.CopyFile(d.sourceSSHKey, d.GetSSHKeyPath()); err != nil {
-		return fmt.Errorf("unable to copy ssh key: %s", err)
-	}
-
-	if err := os.Chmod(d.GetSSHKeyPath(), 0600); err != nil {
-		return fmt.Errorf("unable to set permissions on the ssh key: %s", err)
-	}
-
-	log.Debugf("IP: %s", d.IPAddress)
-
-	return nil
-}
-
-func (d *Driver) DriverName() string {
-	return driverName
-}
-
 func (d *Driver) GetCreateFlags() []mcnflag.Flag {
 	return []mcnflag.Flag{
 		mcnflag.StringFlag{
@@ -71,31 +40,81 @@ func (d *Driver) GetCreateFlags() []mcnflag.Flag {
 		mcnflag.StringFlag{
 			Name:  "generic-ssh-user",
 			Usage: "SSH user",
-			Value: drivers.DefaultSSHUser,
+			Value: defaultSSHUser,
 		},
 		mcnflag.StringFlag{
 			Name:  "generic-ssh-key",
 			Usage: "SSH private key path",
-			Value: defaultSourceSSHKey,
+			Value: defaultSSHKey,
 		},
 		mcnflag.IntFlag{
 			Name:  "generic-ssh-port",
 			Usage: "SSH port",
-			Value: drivers.DefaultSSHPort,
+			Value: defaultSSHPort,
 		},
 	}
 }
 
-func (d *Driver) GetState() (state.State, error) {
+// NewDriver creates and returns a new instance of the driver
-	address := net.JoinHostPort(d.IPAddress, strconv.Itoa(d.SSHPort))
+func NewDriver(hostName, storePath string) drivers.Driver {
-	_, err := net.DialTimeout("tcp", address, defaultTimeout)
+	return &Driver{
-	var st state.State
+		SSHKey: defaultSSHKey,
-	if err != nil {
+		BaseDriver: &drivers.BaseDriver{
-		st = state.Stopped
+			SSHUser:     defaultSSHUser,
-	} else {
+			SSHPort:     defaultSSHPort,
-		st = state.Running
+			MachineName: hostName,
+			StorePath:   storePath,
+		},
 	}
-	return st, nil
+}
+
+func (d *Driver) DriverName() string {
+	return "generic"
+}
+
+func (d *Driver) GetSSHHostname() (string, error) {
+	return d.GetIP()
+}
+
+func (d *Driver) GetSSHUsername() string {
+	return d.SSHUser
+}
+
+func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
+	d.IPAddress = flags.String("generic-ip-address")
+	d.SSHUser = flags.String("generic-ssh-user")
+	d.SSHKey = flags.String("generic-ssh-key")
+	d.SSHPort = flags.Int("generic-ssh-port")
+
+	if d.IPAddress == "" {
+		return fmt.Errorf("generic driver requires the --generic-ip-address option")
+	}
+
+	if d.SSHKey == "" {
+		return fmt.Errorf("generic driver requires the --generic-ssh-key option")
+	}
+
+	return nil
+}
+
+func (d *Driver) PreCreateCheck() error {
+	return nil
+}
+
+func (d *Driver) Create() error {
+	log.Infof("Importing SSH key...")
+
+	if err := mcnutils.CopyFile(d.SSHKey, d.GetSSHKeyPath()); err != nil {
+		return fmt.Errorf("unable to copy ssh key: %s", err)
+	}
+
+	if err := os.Chmod(d.GetSSHKeyPath(), 0600); err != nil {
+		return err
+	}
+
+	log.Debugf("IP: %s", d.IPAddress)
+
+	return nil
 }
 
 func (d *Driver) GetURL() (string, error) {
@@ -106,10 +125,31 @@ func (d *Driver) GetURL() (string, error) {
 	return fmt.Sprintf("tcp://%s:2376", ip), nil
 }
 
-func (d *Driver) Kill() error {
+func (d *Driver) GetIP() (string, error) {
-	log.Debug("Killing...")
+	if d.IPAddress == "" {
-	_, err := drivers.RunSSHCommandFromDriver(d, "sudo shutdown -P now")
+		return "", fmt.Errorf("IP address is not set")
-	return err
+	}
+	return d.IPAddress, nil
+}
+
+func (d *Driver) GetState() (state.State, error) {
+	addr := fmt.Sprintf("%s:%d", d.IPAddress, d.SSHPort)
+	_, err := net.DialTimeout("tcp", addr, defaultTimeout)
+	var st state.State
+	if err != nil {
+		st = state.Stopped
+	} else {
+		st = state.Running
+	}
+	return st, nil
+}
+
+func (d *Driver) Start() error {
+	return fmt.Errorf("generic driver does not support start")
+}
+
+func (d *Driver) Stop() error {
+	return fmt.Errorf("generic driver does not support stop")
 }
 
 func (d *Driver) Remove() error {
@@ -118,31 +158,24 @@ func (d *Driver) Remove() error {
 
 func (d *Driver) Restart() error {
 	log.Debug("Restarting...")
-	_, err := drivers.RunSSHCommandFromDriver(d, "sudo shutdown -r now")
+
+	if _, err := drivers.RunSSHCommandFromDriver(d, "sudo shutdown -r now"); err != nil {
 		return err
 	}
 
-func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
-	d.IPAddress = flags.String("generic-ip-address")
-	d.SSHUser = flags.String("generic-ssh-user")
-	d.sourceSSHKey = flags.String("generic-ssh-key")
-	d.SSHPort = flags.Int("generic-ssh-port")
-
-	if d.IPAddress == "" {
-		return errors.New("generic driver requires the --generic-ip-address option")
-	}
-
-	if d.sourceSSHKey == "" {
-		return errors.New("generic driver requires the --generic-ssh-key option")
-	}
-
 	return nil
 }
 
-func (d *Driver) Start() error {
+func (d *Driver) Kill() error {
-	return errors.New("generic driver does not support start")
+	log.Debug("Killing...")
+
+	if _, err := drivers.RunSSHCommandFromDriver(d, "sudo shutdown -P now"); err != nil {
+		return err
 	}
 
-func (d *Driver) Stop() error {
+	return nil
-	return errors.New("generic driver does not support stop")
+}
+
+func (d *Driver) publicSSHKeyPath() string {
+	return d.GetSSHKeyPath() + ".pub"
 }

drivers/google/google.go

@@ -120,6 +120,11 @@ func NewDriver(machineName string, storePath string) *Driver {
 	}
 }
 
+// GetSSHHostname returns hostname for use with ssh
+func (d *Driver) GetSSHHostname() (string, error) {
+	return d.GetIP()
+}
+
 // GetSSHUsername returns username for use with ssh
 func (d *Driver) GetSSHUsername() string {
 	if d.SSHUser == "" {

drivers/hyperv/hyperv.go

@@ -85,6 +85,10 @@ func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
 	return nil
 }
 
+func (d *Driver) GetSSHHostname() (string, error) {
+	return d.GetIP()
+}
+
 func (d *Driver) GetSSHUsername() string {
 	if d.SSHUser == "" {
 		d.SSHUser = "docker"

drivers/openstack/openstack.go

@@ -218,6 +218,10 @@ func NewDerivedDriver(hostName, storePath string) *Driver {
 	}
 }
 
+func (d *Driver) GetSSHHostname() (string, error) {
+	return d.GetIP()
+}
+
 func (d *Driver) DriverName() string {
 	return "openstack"
 }

drivers/softlayer/driver.go

@@ -73,6 +73,10 @@ func NewDriver(hostName, storePath string) drivers.Driver {
 	}
 }
 
+func (d *Driver) GetSSHHostname() (string, error) {
+	return d.GetIP()
+}
+
 func (d *Driver) GetCreateFlags() []mcnflag.Flag {
 	// Set hourly billing to true by default since codegangsta cli doesn't take default bool values
 	if os.Getenv("SOFTLAYER_HOURLY_BILLING") == "" {

drivers/vmwarefusion/fusion.go

@@ -119,6 +119,10 @@ func NewDriver(hostName, storePath string) drivers.Driver {
 	}
 }
 
+func (d *Driver) GetSSHHostname() (string, error) {
+	return d.GetIP()
+}
+
 func (d *Driver) GetSSHUsername() string {
 	if d.SSHUser == "" {
 		d.SSHUser = "docker"

drivers/vmwarevcloudair/vcloudair.go

@@ -138,6 +138,10 @@ func NewDriver(hostName, storePath string) drivers.Driver {
 	}
 }
 
+func (d *Driver) GetSSHHostname() (string, error) {
+	return d.GetIP()
+}
+
 // Driver interface implementation
 func (d *Driver) DriverName() string {
 	return "vmwarevcloudair"

drivers/vmwarevsphere/vsphere.go

@@ -135,6 +135,10 @@ func NewDriver(hostName, storePath string) drivers.Driver {
 	}
 }
 
+func (d *Driver) GetSSHHostname() (string, error) {
+	return d.GetIP()
+}
+
 func (d *Driver) GetSSHUsername() string {
 	if d.SSHUser == "" {
 		d.SSHUser = "docker"

libmachine/drivers/base.go

@@ -1,29 +1,23 @@
 package drivers
 
-import (
+import "path/filepath"
-	"errors"
-	"fmt"
-	"net"
-	"path/filepath"
-)
-
-const (
-	DefaultSSHUser = "root"
-	DefaultSSHPort = 22
-)
 
 // BaseDriver - Embed this struct into drivers to provide the common set
 // of fields and functions.
 type BaseDriver struct {
 	IPAddress      string
-	MachineName    string
-	SSHKeyPath     string
-	SSHPort        int
 	SSHUser        string
-	StorePath      string
+	SSHPort        int
+	MachineName    string
 	SwarmMaster    bool
 	SwarmHost      string
 	SwarmDiscovery string
+	StorePath      string
+}
+
+// GetSSHKeyPath -
+func (d *BaseDriver) GetSSHKeyPath() string {
+	return filepath.Join(d.StorePath, "machines", d.MachineName, "id_rsa")
 }
 
 // DriverName returns the name of the driver
@@ -32,39 +26,19 @@ func (d *BaseDriver) DriverName() string {
 }
 
 // GetIP returns the ip
-func (d *BaseDriver) GetIP() (string, error) {
-	if d.IPAddress == "" {
-		return "", errors.New("IP address is not set")
-	}
-	ip := net.ParseIP(d.IPAddress)
-	if ip == nil {
-		return "", fmt.Errorf("IP address is invalid: %s", d.IPAddress)
-	}
-	return d.IPAddress, nil
-}
-
-// GetMachineName returns the machine name
 func (d *BaseDriver) GetMachineName() string {
 	return d.MachineName
 }
 
-// GetSSHHostname returns hostname for use with ssh
+// ResolveStorePath -
-func (d *BaseDriver) GetSSHHostname() (string, error) {
+func (d *BaseDriver) ResolveStorePath(file string) string {
-	return d.GetIP()
+	return filepath.Join(d.StorePath, "machines", d.MachineName, file)
-}
-
-// GetSSHKeyPath returns the ssh key path
-func (d *BaseDriver) GetSSHKeyPath() string {
-	if d.SSHKeyPath == "" {
-		d.SSHKeyPath = d.ResolveStorePath("id_rsa")
-	}
-	return d.SSHKeyPath
 }
 
 // GetSSHPort returns the ssh port, 22 if not specified
 func (d *BaseDriver) GetSSHPort() (int, error) {
 	if d.SSHPort == 0 {
-		d.SSHPort = DefaultSSHPort
+		d.SSHPort = 22
 	}
 
 	return d.SSHPort, nil
@@ -73,7 +47,7 @@ func (d *BaseDriver) GetSSHPort() (int, error) {
 // GetSSHUsername returns the ssh user name, root if not specified
 func (d *BaseDriver) GetSSHUsername() string {
 	if d.SSHUser == "" {
-		d.SSHUser = DefaultSSHUser
+		d.SSHUser = "root"
 	}
 
 	return d.SSHUser
@@ -83,8 +57,3 @@ func (d *BaseDriver) GetSSHUsername() string {
 func (d *BaseDriver) PreCreateCheck() error {
 	return nil
 }
-
-// ResolveStorePath returns the store path where the machine is
-func (d *BaseDriver) ResolveStorePath(file string) string {
-	return filepath.Join(d.StorePath, "machines", d.MachineName, file)
-}

libmachine/drivers/base_test.go

@@ -1,28 +0,0 @@
-package drivers
-
-import (
-	"errors"
-	"fmt"
-	"github.com/stretchr/testify/assert"
-	"testing"
-)
-
-func TestIP(t *testing.T) {
-	cases := []struct {
-		baseDriver  *BaseDriver
-		expectedIp  string
-		expectedErr error
-	}{
-		{&BaseDriver{}, "", errors.New("IP address is not set")},
-		{&BaseDriver{IPAddress: "2001:4860:0:2001::68"}, "2001:4860:0:2001::68", nil},
-		{&BaseDriver{IPAddress: "192.168.0.1"}, "192.168.0.1", nil},
-		{&BaseDriver{IPAddress: "::1"}, "::1", nil},
-		{&BaseDriver{IPAddress: "whatever"}, "", fmt.Errorf("IP address is invalid: %s", "whatever")},
-	}
-
-	for _, c := range cases {
-		ip, err := c.baseDriver.GetIP()
-		assert.Equal(t, c.expectedIp, ip)
-		assert.Equal(t, c.expectedErr, err)
-	}
-}