func (d *Driver) configNetwork(instanceId string) error {
err := d.addRouteEntry()
if err != nil {
return fmt.Errorf("Failed to add route entry: %v", err)
}
// Create EIP for virtual private cloud
eipArgs := ecs.AllocateEipAddressArgs{
RegionId: d.Region,
Bandwidth: d.InternetMaxBandwidthOut,
ClientToken: d.getClient().GenerateClientToken(),
}
_, allocationId, err := d.getClient().AllocateEipAddress(&eipArgs)
if err != nil {
return fmt.Errorf("Failed to allocate EIP address: %v", err)
}
err = d.getClient().WaitForEip(d.Region, allocationId, ecs.EipStatusAvailable, 60)
if err != nil {
err2 := d.getClient().ReleaseEipAddress(allocationId)
if err2 != nil {
log.Warnf("Failed to release EIP address: %v", err2)
}
return fmt.Errorf("Failed to wait EIP %s: %v", allocationId, err)
}
err = d.getClient().AssociateEipAddress(allocationId, instanceId)
if err != nil {
return fmt.Errorf("Failed to associate EIP address: %v", err)
}
err = d.getClient().WaitForEip(d.Region, allocationId, ecs.EipStatusInUse, 60)
if err != nil {
return fmt.Errorf("Failed to wait EIP %s: %v", allocationId, err)
}
return nil
}
func (provisioner *DebianProvisioner) dockerDaemonResponding() bool {
if _, err := provisioner.SSHCommand("sudo docker version"); err != nil {
log.Warnf("Error getting SSH command to check if the daemon is up: %s", err)
return false
}
// The daemon is up if the command worked. Carry on.
return true
}
func (d *Driver) Create() error {
err := hypervAvailable()
if err != nil {
return err
}
d.setMachineNameIfNotSet()
var isoURL string
b2dutils := utils.NewB2dUtils("", "")
if d.boot2DockerLoc == "" {
if d.boot2DockerURL != "" {
isoURL = d.boot2DockerURL
log.Infof("Downloading boot2docker.iso from %s...", isoURL)
if err := b2dutils.DownloadISO(d.ResolveStorePath("."), "boot2docker.iso", isoURL); err != nil {
return err
}
} else {
// todo: check latest release URL, download if it's new
// until then always use "latest"
isoURL, err = b2dutils.GetLatestBoot2DockerReleaseURL()
if err != nil {
log.Warnf("Unable to check for the latest release: %s", err)
}
// todo: use real constant for .docker
rootPath := filepath.Join(utils.GetDockerDir())
imgPath := filepath.Join(rootPath, "images")
commonIsoPath := filepath.Join(imgPath, "boot2docker.iso")
if _, err := os.Stat(commonIsoPath); os.IsNotExist(err) {
log.Infof("Downloading boot2docker.iso to %s...", commonIsoPath)
// just in case boot2docker.iso has been manually deleted
if _, err := os.Stat(imgPath); os.IsNotExist(err) {
if err := os.Mkdir(imgPath, 0700); err != nil {
return err
}
}
if err := b2dutils.DownloadISO(imgPath, "boot2docker.iso", isoURL); err != nil {
return err
}
}
isoDest := d.ResolveStorePath("boot2docker.iso")
if err := utils.CopyFile(commonIsoPath, isoDest); err != nil {
return err
}
}
} else {
if err := utils.CopyFile(d.boot2DockerLoc, d.ResolveStorePath("boot2docker.iso")); err != nil {
return err
}
}
log.Infof("Creating SSH key...")
if err := ssh.GenerateSSHKey(d.GetSSHKeyPath()); err != nil {
return err
}
log.Infof("Creating VM...")
virtualSwitch, err := d.chooseVirtualSwitch()
if err != nil {
return err
}
err = d.generateDiskImage()
if err != nil {
return err
}
command := []string{
"New-VM",
"-Name", d.MachineName,
"-Path", fmt.Sprintf("'%s'", d.ResolveStorePath(".")),
"-MemoryStartupBytes", fmt.Sprintf("%dMB", d.memSize)}
_, err = execute(command)
if err != nil {
return err
}
command = []string{
"Set-VMDvdDrive",
"-VMName", d.MachineName,
"-Path", fmt.Sprintf("'%s'", d.ResolveStorePath("boot2docker.iso"))}
_, err = execute(command)
if err != nil {
return err
}
command = []string{
"Add-VMHardDiskDrive",
"-VMName", d.MachineName,
"-Path", fmt.Sprintf("'%s'", d.diskImage)}
_, err = execute(command)
if err != nil {
return err
}
command = []string{
"Connect-VMNetworkAdapter",
"-VMName", d.MachineName,
"-SwitchName", fmt.Sprintf("'%s'", virtualSwitch)}
_, err = execute(command)
if err != nil {
return err
}
log.Infof("Starting VM...")
if err := d.Start(); err != nil {
return err
}
return nil
}
func (d *Driver) Create() error {
var err error
d.setMachineNameIfNotSet()
// Download boot2docker ISO from Internet
b2dutils := utils.NewB2dUtils("", "", isoFilename)
if err := b2dutils.CopyIsoToMachineDir(d.Boot2DockerURL, d.MachineName); err != nil {
return err
}
log.Infof("Logging into XenServer %s...", d.Server)
c, err := d.GetXenAPIClient()
if err != nil {
return err
}
// Generate SSH Keys
log.Infof("Creating SSH key...")
if err := ssh.GenerateSSHKey(d.GetSSHKeyPath()); err != nil {
return err
}
log.Infof("Creating ISO VDI...")
// Get the SR
var sr *xsclient.SR
if d.SR == "" {
sr, err = c.GetDefaultSR()
} else {
sr, err = c.GetUniqueSRByNameLabel(d.SR)
}
if err != nil {
return err
}
isoFileInfo, err := os.Stat(d.ISO)
if err != nil {
return err
}
// Create the VDI
isoVdi, err := sr.CreateVdi(isoFilename, isoFileInfo.Size())
if err != nil {
log.Errorf("Unable to create ISO VDI '%s': %v", isoFilename, err)
return err
}
// Import the VDI
if err = d.importVdi(isoVdi, d.ISO, time.Duration(d.UploadTimeout)*time.Second); err != nil {
return err
}
isoVdiUuid, err := isoVdi.GetUuid()
if err != nil {
return err
}
log.Infof("Creating Disk VDI...")
err = d.generateDiskImage()
if err != nil {
return err
}
// Create the VDI
diskVdi, err := sr.CreateVdi("bootdocker disk", int64(d.DiskSize)*1024*1024)
if err != nil {
log.Errorf("Unable to create ISO VDI '%s': %v", "bootdocker disk", err)
return err
}
if err = d.importVdi(diskVdi, d.TAR, time.Duration(d.UploadTimeout)*time.Second); err != nil {
return err
}
diskVdiUuid, err := diskVdi.GetUuid()
if err != nil {
return err
}
log.Infof("Creating VM...")
vm0, err := c.GetUniqueVMByNameLabel(osTemplateLabelName)
if err != nil {
return err
}
// Clone VM from VM template
vm, err := vm0.Clone(fmt.Sprintf("__gui__%s", d.MachineName))
if err != nil {
return err
}
vmMacSeed, err := pseudoUuid()
if err != nil {
return err
}
hostname, err := os.Hostname()
if err != nil {
log.Errorf("Unable get local hostname")
}
otherConfig := map[string]string{
"base_template_name": osTemplateLabelName,
"install-methods": "cdrom,nfs,http,ftp",
"linux_template": "true",
"mac_seed": vmMacSeed,
"docker-machine-creator": hostname,
}
err = vm.SetOtherConfig(otherConfig)
if err != nil {
return err
}
log.Infof("Provision VM...")
err = vm.Provision()
if err != nil {
return err
}
// Set machine name
err = vm.SetNameLabel(d.MachineName)
if err != nil {
return err
}
// Set vCPU number
err = vm.SetVCPUsMax(d.CPU)
if err != nil {
return err
}
err = vm.SetVCPUsAtStartup(d.CPU)
if err != nil {
return err
}
platform_params := map[string]string{
"acpi": "1",
"apic": "true",
"cores-per-socket": "1",
"device_id": "0001",
"nx": "true",
"pae": "true",
"vga": "std",
"videoram": "8",
"viridian": "false",
}
err = vm.SetPlatform(platform_params)
if err != nil {
return err
}
// Set machine memory size
err = vm.SetStaticMemoryRange(uint64(d.Memory)*1024*1024, uint64(d.Memory)*1024*1024)
if err != nil {
return err
}
log.Infof("Add ISO VDI to VM...")
diskVdi, err = c.GetVdiByUuid(isoVdiUuid)
if err != nil {
return err
}
err = vm.ConnectVdi(diskVdi, xsclient.Disk, "0")
if err != nil {
return err
}
log.Infof("Add Disk VDI to VM...")
diskVdi, err = c.GetVdiByUuid(diskVdiUuid)
if err != nil {
return err
}
err = vm.ConnectVdi(diskVdi, xsclient.Disk, "1")
if err != nil {
return err
}
log.Infof("Add Network to VM...")
var networks []*xsclient.Network
if d.Network == "" {
networks1, err := c.GetNetworks()
if err != nil {
return err
}
for _, network := range networks1 {
otherConfig, err := network.GetOtherConfig()
if err != nil {
return err
}
isInternal, ok := otherConfig["is_host_internal_management_network"]
if ok && isInternal == "true" {
continue
}
automaitc, ok := otherConfig["automatic"]
if ok && automaitc == "false" {
continue
}
networks = append(networks, network)
}
} else {
network, err := c.GetUniqueNetworkByNameLabel(d.Network)
if err != nil {
return err
}
networks = append(networks, network)
}
if len(networks) == 0 {
return fmt.Errorf("Unable get available networks for %v", d.MachineName)
}
vifDevices, err := vm.GetAllowedVIFDevices()
if err != nil {
return err
}
if len(vifDevices) < len(networks) {
log.Warnf("VM(%s) networks number is limited to %d.", d.MachineName, len(vifDevices))
networks = networks[:len(vifDevices)]
}
for i, network := range networks {
_, err = vm.ConnectNetwork(network, vifDevices[i])
if err != nil {
return err
}
}
log.Infof("Starting VM...")
if d.Host == "" {
if err = vm.Start(false, false); err != nil {
return err
}
} else {
host, err := c.GetUniqueHostByNameLabel(d.Host)
if err != nil {
return err
}
if err = vm.StartOn(host, false, false); err != nil {
return err
}
}
if err := d.wait(time.Duration(d.WaitTimeout) * time.Second); err != nil {
return err
}
log.Infof("VM Created.")
return nil
}