func (provisioner *Boot2DockerProvisioner) upgradeIso() error { // TODO: Ideally, we should not read from mcndirs directory at all. // The driver should be able to communicate how and where to place the // relevant files. b2dutils := mcnutils.NewB2dUtils(mcndirs.GetBaseDir()) // Check if the driver has specified a custom b2d url jsonDriver, err := json.Marshal(provisioner.GetDriver()) if err != nil { return err } var d struct { Boot2DockerURL string } json.Unmarshal(jsonDriver, &d) log.Info("Downloading latest boot2docker iso...") // Usually we call this implicitly, but call it here explicitly to get // the latest default boot2docker ISO. if d.Boot2DockerURL == "" { if err := b2dutils.DownloadLatestBoot2Docker(d.Boot2DockerURL); err != nil { return err } } log.Info("Stopping machine to do the upgrade...") if err := provisioner.Driver.Stop(); err != nil { return err } if err := mcnutils.WaitFor(drivers.MachineInState(provisioner.Driver, state.Stopped)); err != nil { return err } machineName := provisioner.GetDriver().GetMachineName() log.Infof("Upgrading machine %q...", machineName) // Either download the latest version of the b2d url that was explicitly // specified when creating the VM or copy the (updated) default ISO if err := b2dutils.CopyIsoToMachineDir(d.Boot2DockerURL, machineName); err != nil { return err } log.Infof("Starting machine back up...") if err := provisioner.Driver.Start(); err != nil { return err } return mcnutils.WaitFor(drivers.MachineInState(provisioner.Driver, state.Running)) }
func (h *Host) runActionForState(action func() error, desiredState state.State) error { if drivers.MachineInState(h.Driver, desiredState)() { return fmt.Errorf("Machine %q is already %s.", h.Name, strings.ToLower(desiredState.String())) } if err := action(); err != nil { return err } return mcnutils.WaitFor(drivers.MachineInState(h.Driver, desiredState)) }
func (h *Host) Restart() error { if drivers.MachineInState(h.Driver, state.Stopped)() { return h.Start() } if drivers.MachineInState(h.Driver, state.Running)() { if err := h.Driver.Restart(); err != nil { return err } return mcnutils.WaitFor(drivers.MachineInState(h.Driver, state.Running)) } return nil }
func (h *Host) runActionForState(action func() error, desiredState state.State) error { if drivers.MachineInState(h.Driver, desiredState)() { return mcnerror.ErrHostAlreadyInState{ Name: h.Name, State: desiredState, } } if err := action(); err != nil { return err } return mcnutils.WaitFor(drivers.MachineInState(h.Driver, desiredState)) }
func (h *Host) Restart() error { log.Infof("Restarting %q...", h.Name) if drivers.MachineInState(h.Driver, state.Stopped)() { if err := h.Start(); err != nil { return err } } else if drivers.MachineInState(h.Driver, state.Running)() { if err := h.Driver.Restart(); err != nil { return err } if err := mcnutils.WaitFor(drivers.MachineInState(h.Driver, state.Running)); err != nil { return err } } return h.WaitForDocker() }
func (provisioner *RancherProvisioner) upgradeIso() error { // Largely copied from Boot2Docker provisioner, we should find a way to share this code log.Info("Stopping machine to do the upgrade...") if err := provisioner.Driver.Stop(); err != nil { return err } if err := mcnutils.WaitFor(drivers.MachineInState(provisioner.Driver, state.Stopped)); err != nil { return err } machineName := provisioner.GetDriver().GetMachineName() log.Infof("Upgrading machine %s...", machineName) // TODO: Ideally, we should not read from mcndirs directory at all. // The driver should be able to communicate how and where to place the // relevant files. b2dutils := mcnutils.NewB2dUtils(mcndirs.GetBaseDir()) url, err := provisioner.getLatestISOURL() if err != nil { return err } if err := b2dutils.DownloadISOFromURL(url); err != nil { return err } // Copy the latest version of boot2docker ISO to the machine's directory if err := b2dutils.CopyIsoToMachineDir("", machineName); err != nil { return err } log.Infof("Starting machine back up...") if err := provisioner.Driver.Start(); err != nil { return err } return mcnutils.WaitFor(drivers.MachineInState(provisioner.Driver, state.Running)) }
// 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 (provisioner *Boot2DockerProvisioner) upgradeIso() error { log.Info("Stopping machine to do the upgrade...") if err := provisioner.Driver.Stop(); err != nil { return err } if err := mcnutils.WaitFor(drivers.MachineInState(provisioner.Driver, state.Stopped)); err != nil { return err } machineName := provisioner.GetDriver().GetMachineName() log.Infof("Upgrading machine %s...", machineName) // TODO: Ideally, we should not read from mcndirs directory at all. // The driver should be able to communicate how and where to place the // relevant files. b2dutils := mcnutils.NewB2dUtils("", "", mcndirs.GetBaseDir()) // Usually we call this implicitly, but call it here explicitly to get // the latest boot2docker ISO. if err := b2dutils.DownloadLatestBoot2Docker(); err != nil { return err } // Copy the latest version of boot2docker ISO to the machine's directory if err := b2dutils.CopyIsoToMachineDir("", machineName); err != nil { return err } log.Infof("Starting machine back up...") if err := provisioner.Driver.Start(); err != nil { return err } return mcnutils.WaitFor(drivers.MachineInState(provisioner.Driver, state.Running)) }
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 }
func (d *Driver) Create() error { log.Infof("Create UHost instance...") if d.Password == "" { d.Password = generateRandomPassword(16) log.Infof("password is not set, we use the random password instead, password:%s", d.Password) } // create keypair log.Infof("Creating key pair for instances...") if err := d.createKeyPair(); err != nil { return fmt.Errorf("unable to create key pair: %s", err) } // create uhost instance log.Infof("Creating uhost instance...") if err := d.createUHost(); err != nil { return fmt.Errorf("create UHost failed:%s", err) } // waiting for creating successful if err := mcnutils.WaitForSpecific(drivers.MachineInState(d, state.Running), 120, 3*time.Second); err != nil { return fmt.Errorf("wait for machine running failed: %s", err) } // create networks, like private ip, eip, and security group log.Infof("Creating networks...") //TODO: user the exist eip and security group to configure network if err := d.createUNet(); err != nil { return fmt.Errorf("create networks failed:%s", err) } // upload keypair if err := d.uploadKeyPair(); err != nil { return fmt.Errorf("upload keypair failed:%s", err) } return nil }
func (d *Driver) Create() error { log.Debug("Creating Linode machine instance...") publicKey, err := d.createSSHKey() if err != nil { return err } client := d.getClient() // Create a linode log.Debug("Creating linode instance") linodeResponse, err := client.Linode.Create( d.DataCenterId, d.PlanId, d.PaymentTerm, ) if err != nil { return err } d.LinodeId = linodeResponse.LinodeId.LinodeId log.Debugf("Linode created: %d", d.LinodeId) if d.LinodeLabel != "" { log.Debugf("Updating linode label to %s", d.LinodeLabel) _, err := client.Linode.Update(d.LinodeId, map[string]interface{}{"Label": d.LinodeLabel}) if err != nil { return err } } linodeIPListResponse, err := client.Ip.List(d.LinodeId, -1) if err != nil { return err } for _, fullIpAddress := range linodeIPListResponse.FullIPAddresses { if fullIpAddress.IsPublic == 1 { d.IPAddress = fullIpAddress.IPAddress } } if d.IPAddress == "" { return errors.New("Linode IP Address is not found.") } log.Debugf("Created linode ID %d, IP address %s", d.LinodeId, d.IPAddress) // Deploy distribution args := make(map[string]string) args["rootPass"] = d.RootPassword args["rootSSHKey"] = publicKey distributionId := d.DistributionId log.Debug("Create disk") createDiskJobResponse, err := d.client.Disk.CreateFromDistribution(distributionId, d.LinodeId, "Primary Disk", 24576-256, args) if err != nil { return err } jobId := createDiskJobResponse.DiskJob.JobId diskId := createDiskJobResponse.DiskJob.DiskId log.Debugf("Linode create disk task :%d.", jobId) // wait until the creation is finished err = d.waitForJob(jobId, "Create Disk Task", 60) if err != nil { return err } // create swap log.Debug("Create swap disk") createDiskJobResponse, err = d.client.Disk.Create(d.LinodeId, "swap", "Swap Disk", 256, nil) if err != nil { return err } jobId = createDiskJobResponse.DiskJob.JobId swapDiskId := createDiskJobResponse.DiskJob.DiskId log.Debugf("Linode create swap disk task :%d.", jobId) // wait until the creation is finished err = d.waitForJob(jobId, "Create Swap Disk Task", 60) if err != nil { return err } // create config log.Debug("Create configuration") args2 := make(map[string]string) args2["DiskList"] = fmt.Sprintf("%d,%d", diskId, swapDiskId) args2["RootDeviceNum"] = "1" args2["RootDeviceRO"] = "true" args2["helper_distro"] = "true" kernelId := d.KernelId _, err = d.client.Config.Create(d.LinodeId, kernelId, "My Docker Machine Configuration", args2) if err != nil { return err } log.Debugf("Linode configuration created.") // Boot log.Debug("Booting") jobResponse, err := d.client.Linode.Boot(d.LinodeId, -1) if err != nil { return err } jobId = jobResponse.JobId.JobId log.Debugf("Booting linode, job id: %v", jobId) // wait for boot err = d.waitForJob(jobId, "Booting linode", 60) if err != nil { return err } log.Debug("Waiting for Machine Running...") if err := mcnutils.WaitForSpecific(drivers.MachineInState(d, state.Running), 120, 3*time.Second); err != nil { return fmt.Errorf("wait for machine running failed: %s", err) } return nil }