func (d *Driver) waitForIP() error {
var ip string
var err error
log.Infof("Waiting for VM to come online...")
for i := 1; i <= 60; i++ {
ip, err = d.getIPfromDHCPLease()
if err != nil {
log.Debugf("Not there yet %d/%d, error: %s", i, 60, err)
time.Sleep(2 * time.Second)
continue
}
if ip != "" {
log.Debugf("Got an ip: %s", ip)
d.IPAddress = ip
break
}
}
if ip == "" {
return fmt.Errorf("Machine didn't return an IP after 120 seconds, aborting")
}
// Wait for SSH over NAT to be available before returning to user
if err := drivers.WaitForSSH(d); err != nil {
return err
}
return nil
}
func (detector StandardDetector) DetectProvisioner(d drivers.Driver) (Provisioner, error) {
log.Info("Waiting for SSH to be available...")
if err := drivers.WaitForSSH(d); err != nil {
return nil, err
}
log.Info("Detecting the provisioner...")
osReleaseOut, err := drivers.RunSSHCommandFromDriver(d, "cat /etc/os-release")
if err != nil {
return nil, fmt.Errorf("Error getting SSH command: %s", err)
}
osReleaseInfo, err := NewOsRelease([]byte(osReleaseOut))
if err != nil {
return nil, fmt.Errorf("Error parsing /etc/os-release file: %s", err)
}
for _, p := range provisioners {
provisioner := p.New(d)
provisioner.SetOsReleaseInfo(osReleaseInfo)
if provisioner.CompatibleWithHost() {
log.Debugf("found compatible host: %s", osReleaseInfo.ID)
return provisioner, nil
}
}
return nil, ErrDetectionFailed
}
func (d *Driver) GetURL() (string, error) {
if err := d.PreCommandCheck(); err != nil {
return "", err
}
ip, err := d.GetIP()
if err != nil {
return "", err
}
if ip == "" {
return "", nil
}
// Wait for SSH over NAT to be available before returning to user
for {
err := drivers.WaitForSSH(d)
if err != nil {
time.Sleep(1 * time.Second)
} else {
break
}
}
return fmt.Sprintf("tcp://%s:2376", ip), nil
}
func (d *Driver) Start() error {
s, err := d.GetState()
if err != nil {
return err
}
if s == state.Stopped {
// check network to re-create if needed
if err := d.setupHostOnlyNetwork(d.MachineName); err != nil {
return fmt.Errorf("Error setting up host only network on machine start: %s", err)
}
}
switch s {
case state.Stopped, state.Saved:
d.SSHPort, err = setPortForwarding(d, 1, "ssh", "tcp", 22, d.SSHPort)
if err != nil {
return err
}
if err := d.vbm("startvm", d.MachineName, "--type", "headless"); err != nil {
return err
}
log.Infof("Starting VM...")
case state.Paused:
if err := d.vbm("controlvm", d.MachineName, "resume", "--type", "headless"); err != nil {
return err
}
log.Infof("Resuming VM ...")
default:
log.Infof("VM not in restartable state")
}
// Verify that VT-X is not disabled in the started VM
disabled, err := d.IsVTXDisabledInTheVM()
if err != nil {
return fmt.Errorf("Checking if hardware virtualization is enabled failed: %s", err)
}
if disabled {
return ErrMustEnableVTX
}
// 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
}
d.IPAddress, err = d.GetIP()
return err
}
// Create is the wrapper method which covers all of the boilerplate around
// actually creating, provisioning, and persisting an instance in the store.
func create(store persist.Store, h *host.Host, callback func(*host.Host)) error {
if err := cert.BootstrapCertificates(h.HostOptions.AuthOptions); err != nil {
return fmt.Errorf("Error generating certificates: %s", err)
}
log.Info("Running pre-create checks...")
if err := h.Driver.PreCreateCheck(); err != nil {
return fmt.Errorf("Error with pre-create check: %s", err)
}
if err := store.Save(h); err != nil {
return fmt.Errorf("Error saving host to store before attempting creation: %s", err)
}
log.Info("Creating machine...")
if err := h.Driver.Create(); err != nil {
return fmt.Errorf("Error in driver during machine creation: %s", err)
}
if err := store.Save(h); err != nil {
return fmt.Errorf("Error saving host to store after attempting creation: %s", err)
}
// TODO: Not really a fan of just checking "none" here.
if h.Driver.DriverName() != "none" {
log.Info("Waiting for machine to be running, this may take a few minutes...")
if err := mcnutils.WaitFor(drivers.MachineInState(h.Driver, state.Running)); err != nil {
return fmt.Errorf("Error waiting for machine to be running: %s", err)
}
log.Info("Machine is running, waiting for SSH to be available...")
if err := drivers.WaitForSSH(h.Driver); err != nil {
return fmt.Errorf("Error waiting for SSH: %s", err)
}
log.Info("Detecting operating system of created instance...")
provisioner, err := provision.DetectProvisioner(h.Driver)
if err != nil {
return fmt.Errorf("Error detecting OS: %s", err)
}
callback(h)
log.Info("Provisioning created instance...")
if err := provisioner.Provision(*h.HostOptions.SwarmOptions, *h.HostOptions.AuthOptions, *h.HostOptions.EngineOptions); err != nil {
return fmt.Errorf("Error running provisioning: %s", err)
}
}
log.Debug("Reticulating splines...")
return nil
}
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
}
func (api *Client) performCreate(h *host.Host) error {
if err := h.Driver.Create(); err != nil {
return fmt.Errorf("Error in driver during machine creation: %s", err)
}
if err := api.Save(h); err != nil {
return fmt.Errorf("Error saving host to store after attempting creation: %s", err)
}
// TODO: Not really a fan of just checking "none" here.
if h.Driver.DriverName() != "none" {
log.Info("Waiting for machine to be running, this may take a few minutes...")
if err := mcnutils.WaitFor(drivers.MachineInState(h.Driver, state.Running)); err != nil {
return fmt.Errorf("Error waiting for machine to be running: %s", err)
}
log.Info("Machine is running, waiting for SSH to be available...")
if err := drivers.WaitForSSH(h.Driver); err != nil {
return fmt.Errorf("Error waiting for SSH: %s", err)
}
log.Info("Detecting operating system of created instance...")
provisioner, err := provision.DetectProvisioner(h.Driver)
if err != nil {
return fmt.Errorf("Error detecting OS: %s", err)
}
log.Infof("Provisioning with %s...", provisioner.String())
if err := provisioner.Provision(*h.HostOptions.SwarmOptions, *h.HostOptions.AuthOptions, *h.HostOptions.EngineOptions); err != nil {
return fmt.Errorf("Error running provisioning: %s", err)
}
// We should check the connection to docker here
log.Info("Checking connection to Docker...")
if _, _, err = check.DefaultConnChecker.Check(h, false); err != nil {
return fmt.Errorf("Error checking the host: %s", err)
}
log.Info("Docker is up and running!")
}
return nil
}
// Start a host
func (d *Driver) Start() error {
// Check whether the host is connected to Shared network
ok, err := isSharedConnected()
if err != nil {
return err
}
if !ok {
return errSharedNotConnected
}
s, err := d.GetState()
if err != nil {
return err
}
switch s {
case state.Stopped, state.Saved, state.Paused:
if err = prlctl("start", d.MachineName); err != nil {
return err
}
log.Infof("Waiting for VM to start...")
case state.Running:
break
default:
log.Infof("VM not in restartable state")
}
if err = drivers.WaitForSSH(d); err != nil {
return err
}
d.IPAddress, err = d.GetIP()
if err != nil {
return err
}
// Mount Share Folder
if !d.NoShare {
if err := d.mountShareFolder(shareFolderName, shareFolderPath); err != nil {
return err
}
}
return nil
}
func (d *Driver) Start() error {
vm, err := goca.NewVMFromName(d.MachineName)
if err != nil {
return err
}
vm.Resume()
s := state.None
for retry := 0; retry < 50 && s != state.Running; retry++ {
s, err = d.GetState()
if err != nil {
return err
}
switch s {
case state.Running:
case state.Error:
return errors.New("VM in error state")
default:
time.Sleep(2 * time.Second)
}
}
if d.IPAddress == "" {
if d.IPAddress, err = d.GetIP(); err != nil {
return err
}
}
log.Infof("Waiting for SSH...")
// Wait for SSH over NAT to be available before returning to user
if err := drivers.WaitForSSH(d); err != nil {
return err
}
return nil
}
// Start a host
func (d *Driver) Start() error {
s, err := d.GetState()
if err != nil {
return err
}
switch s {
case state.Stopped, state.Saved, state.Paused:
if err := prlctl("start", d.MachineName); err != nil {
return err
}
log.Infof("Waiting for VM to start...")
case state.Running:
break
default:
log.Infof("VM not in restartable state")
}
if err := drivers.WaitForSSH(d); err != nil {
return err
}
d.IPAddress, err = d.GetIP()
if err != nil {
return err
}
// Mount Share Folder
if !d.NoShare {
if err := d.mountShareFolder(shareFolderName, shareFolderPath); err != nil {
return err
}
}
return nil
}
func (d *Driver) Create() error {
log.Infof("Creating SSH key...")
key, err := d.createSSHKey()
if err != nil {
return err
}
d.SSHKeyID = key.ID
client := d.getClient()
createRequest := &packngo.DeviceCreateRequest{
HostName: d.MachineName,
Plan: d.Plan,
Facility: d.Facility,
OS: d.OperatingSystem,
BillingCycle: d.BillingCycle,
ProjectID: d.ProjectID,
UserData: d.UserData,
Tags: d.Tags,
}
log.Infof("Provisioning Packet server...")
newDevice, _, err := client.Devices.Create(createRequest)
if err != nil {
return err
}
t0 := time.Now()
d.DeviceID = newDevice.ID
for {
newDevice, _, err = client.Devices.Get(d.DeviceID)
if err != nil {
return err
}
for _, ip := range newDevice.Network {
if ip.Public && ip.Family == 4 {
d.IPAddress = ip.Address
}
}
if d.IPAddress != "" {
break
}
time.Sleep(1 * time.Second)
}
log.Infof("Created device ID %s, IP address %s",
newDevice.ID,
d.IPAddress)
log.Infof("Waiting for Provisioning...")
stage := float32(0)
for {
newDevice, _, err = client.Devices.Get(d.DeviceID)
if err != nil {
return err
}
if newDevice.State == "provisioning" && stage != newDevice.ProvisionPer {
stage = newDevice.ProvisionPer
log.Debug("Provisioning %v%% complete", newDevice.ProvisionPer)
}
if newDevice.State == "active" {
log.Debug("Device State: %s", newDevice.State)
break
}
time.Sleep(10 * time.Second)
}
log.Debug("Provision time: %v.\n", time.Since(t0))
log.Debug("Waiting for SSH...")
if err := drivers.WaitForSSH(d); err != nil {
return err
}
return nil
}
