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
}