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 }