func (d *Driver) createSSHKey() error { log.Debug("Creating Key Pair...") if err := ssh.GenerateSSHKey(d.GetSSHKeyPath()); err != nil { return err } return nil }
func (d *Driver) createSSHKey() (*godo.Key, error) { if d.SSHKeyFingerprint != "" { key, resp, err := d.getClient().Keys.GetByFingerprint(d.SSHKeyFingerprint) if err != nil && resp.StatusCode == 404 { return nil, fmt.Errorf("Digital Ocean SSH key with fingerprint %s doesn't exist", d.SSHKeyFingerprint) } return key, err } if err := ssh.GenerateSSHKey(d.GetSSHKeyPath()); err != nil { return nil, err } publicKey, err := ioutil.ReadFile(d.publicSSHKeyPath()) if err != nil { return nil, err } createRequest := &godo.KeyCreateRequest{ Name: d.MachineName, PublicKey: string(publicKey), } key, _, err := d.getClient().Keys.Create(createRequest) if err != nil { return key, err } return key, nil }
func (d *Driver) createSSHKey() (*packngo.SSHKey, error) { sshKeyPath := d.GetSSHKeyPath() log.Debugf("Writing SSH Key to %s", sshKeyPath) if err := ssh.GenerateSSHKey(sshKeyPath); err != nil { return nil, err } publicKey, err := ioutil.ReadFile(sshKeyPath + ".pub") if err != nil { return nil, err } createRequest := &packngo.SSHKeyCreateRequest{ Label: fmt.Sprintf("docker machine: %s", d.MachineName), Key: string(publicKey), } key, _, err := d.getClient().SSHKeys.Create(createRequest) if err != nil { return key, err } return key, nil }
func (d *Driver) generateCertForAzure() error { if err := ssh.GenerateSSHKey(d.GetSSHKeyPath()); err != nil { return err } cmd := exec.Command("openssl", "req", "-x509", "-key", d.GetSSHKeyPath(), "-nodes", "-days", "365", "-newkey", "rsa:2048", "-out", d.azureCertPath(), "-subj", "/C=AU/ST=Some-State/O=InternetWidgitsPtyLtd/CN=\\*") return cmd.Run() }
func (d *Driver) Create() error { b2dutils := mcnutils.NewB2dUtils(d.StorePath) if err := b2dutils.CopyIsoToMachineDir(d.Boot2DockerURL, d.MachineName); err != nil { return err } log.Infof("Creating SSH key...") if err := ssh.GenerateSSHKey(d.GetSSHKeyPath()); err != nil { return err } if err := os.MkdirAll(d.ResolveStorePath("."), 0755); err != nil { return err } // Libvirt typically runs as a deprivileged service account and // needs the execute bit set for directories that contain disks for dir := d.ResolveStorePath("."); dir != "/"; dir = filepath.Dir(dir) { log.Debugf("Verifying executable bit set on %s", dir) info, err := os.Stat(dir) if err != nil { return err } mode := info.Mode() if mode&0001 != 1 { log.Debugf("Setting executable bit set on %s", dir) mode |= 0001 os.Chmod(dir, mode) } } log.Debugf("Creating VM data disk...") if err := d.generateDiskImage(d.DiskSize); err != nil { return err } log.Debugf("Defining VM...") tmpl, err := template.New("domain").Parse(domainXMLTemplate) if err != nil { return err } var xml bytes.Buffer err = tmpl.Execute(&xml, d) if err != nil { return err } vm, err := d.conn.DomainDefineXML(xml.String()) if err != nil { log.Warnf("Failed to create the VM: %s", err) return err } d.VM = &vm d.vmLoaded = true return d.Start() }
// createKeyPair create keypair for ssh to docker-machine func (d *Driver) createKeyPair() error { log.Debugf("SSH key path:%s", d.GetSSHKeyPath()) if err := ssh.GenerateSSHKey(d.GetSSHKeyPath()); err != nil { return err } return nil }
func (d *Driver) Create() error { b2dutils := mcnutils.NewB2dUtils(d.StorePath) if err := b2dutils.CopyIsoToMachineDir(d.Boot2DockerURL, d.MachineName); 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 } log.Infof("Using switch %q", virtualSwitch) diskImage, err := d.generateDiskImage() if err != nil { return err } if err := cmd("New-VM", d.MachineName, "-Path", fmt.Sprintf("'%s'", d.ResolveStorePath(".")), "-SwitchName", quote(virtualSwitch), "-MemoryStartupBytes", toMb(d.MemSize)); err != nil { return err } if d.CPU > 1 { if err := cmd("Set-VMProcessor", d.MachineName, "-Count", fmt.Sprintf("%d", d.CPU)); err != nil { return err } } if err := cmd("Set-VMDvdDrive", "-VMName", d.MachineName, "-Path", quote(d.ResolveStorePath("boot2docker.iso"))); err != nil { return err } if err := cmd("Add-VMHardDiskDrive", "-VMName", d.MachineName, "-Path", quote(diskImage)); err != nil { return err } log.Infof("Starting VM...") return d.Start() }
func (d *Driver) createSSHKey() (string, error) { if err := ssh.GenerateSSHKey(d.GetSSHKeyPath()); err != nil { return "", err } publicKey, err := ioutil.ReadFile(d.publicSSHKeyPath()) if err != nil { return "", err } return string(publicKey), nil }
// createKeyPair - generate key files needed func (d *Driver) createKeyPair() error { if err := ssh.GenerateSSHKey(d.GetSSHKeyPath()); err != nil { return err } publicKey, err := ioutil.ReadFile(d.GetSSHKeyPath() + ".pub") if err != nil { return err } log.Debugf("created keys => %s", string(publicKey)) d.SSHPublicKey = string(publicKey) return nil }
// Create creates a GCE VM instance acting as a docker host. func (d *Driver) Create() error { log.Infof("Generating SSH Key") if err := ssh.GenerateSSHKey(d.GetSSHKeyPath()); err != nil { return err } log.Infof("Creating host...") c, err := newComputeUtil(d) if err != nil { return err } return c.createInstance(d) }
func (d *Driver) createSSHKey() (*vultr.SSHKey, error) { if err := ssh.GenerateSSHKey(d.GetSSHKeyPath()); err != nil { return nil, err } publicKey, err := ioutil.ReadFile(d.publicSSHKeyPath()) if err != nil { return nil, err } key, err := d.getClient().CreateSSHKey(d.MachineName, string(publicKey)) if err != nil { return &key, err } return &key, nil }
func (d *Driver) createKeyPair() error { log.Debugf("%s | SSH key path: %s", d.MachineName, d.GetSSHKeyPath()) if err := ssh.GenerateSSHKey(d.GetSSHKeyPath()); err != nil { return err } publicKey, err := ioutil.ReadFile(d.GetSSHKeyPath() + ".pub") if err != nil { return err } d.PublicKey = publicKey return nil }
// Make a boot2docker userdata.tar key bundle func (d *Driver) generateKeyBundle() (*bytes.Buffer, error) { magicString := "boot2docker, please format-me" log.Infof("Creating SSH key...") if err := ssh.GenerateSSHKey(d.GetSSHKeyPath()); err != nil { return nil, err } buf := new(bytes.Buffer) tw := tar.NewWriter(buf) // magicString first so the automount script knows to format the disk file := &tar.Header{Name: magicString, Size: int64(len(magicString))} if err := tw.WriteHeader(file); err != nil { return nil, err } if _, err := tw.Write([]byte(magicString)); err != nil { return nil, err } // .ssh/key.pub => authorized_keys file = &tar.Header{Name: ".ssh", Typeflag: tar.TypeDir, Mode: 0700} if err := tw.WriteHeader(file); err != nil { return nil, err } pubKey, err := ioutil.ReadFile(d.publicSSHKeyPath()) if err != nil { return nil, err } file = &tar.Header{Name: ".ssh/authorized_keys", Size: int64(len(pubKey)), Mode: 0644} if err := tw.WriteHeader(file); err != nil { return nil, err } if _, err := tw.Write([]byte(pubKey)); err != nil { return nil, err } file = &tar.Header{Name: ".ssh/authorized_keys2", Size: int64(len(pubKey)), Mode: 0644} if err := tw.WriteHeader(file); err != nil { return nil, err } if _, err := tw.Write([]byte(pubKey)); err != nil { return nil, err } if err := tw.Close(); err != nil { return nil, err } return buf, nil }
func (d *Driver) createSSHKey() (*SSHKey, error) { if err := ssh.GenerateSSHKey(d.GetSSHKeyPath()); err != nil { return nil, err } publicKey, err := ioutil.ReadFile(d.publicSSHKeyPath()) if err != nil { return nil, err } key, err := d.getClient().SSHKey().Create(d.deviceConfig.Hostname, string(publicKey)) if err != nil { return nil, err } return key, nil }
func (d *Driver) createSSHKey() (*api.SSHKey, error) { if err := ssh.GenerateSSHKey(d.GetSSHKeyPath()); err != nil { return nil, err } publicKey, err := ioutil.ReadFile(d.publicSSHKeyPath()) if err != nil { return nil, err } createRequest := &api.SSHKeyCreateRequest{ Name: d.MachineName, Key: string(publicKey), } key, _, err := d.getClient().SSHKey.Create(createRequest) return key, err }
// generateSSHKey creates a ssh key pair locally and saves the public key file // contents in OpenSSH format to the DeploymentContext. func (d *Driver) generateSSHKey(ctx *azureutil.DeploymentContext) error { privPath := d.GetSSHKeyPath() pubPath := privPath + ".pub" log.Debug("Creating SSH key...", logutil.Fields{ "pub": pubPath, "priv": privPath, }) if err := ssh.GenerateSSHKey(privPath); err != nil { return err } log.Debug("SSH key pair generated.") publicKey, err := ioutil.ReadFile(pubPath) ctx.SSHPublicKey = string(publicKey) return err }
func (d *Driver) createSSHKey() error { log.WithField("Name", d.KeyPairName).Debug("Creating Key Pair...") if err := ssh.GenerateSSHKey(d.GetSSHKeyPath()); err != nil { return err } publicKey, err := ioutil.ReadFile(d.publicSSHKeyPath()) if err != nil { return err } if err := d.initCompute(); err != nil { return err } if err := d.client.CreateKeyPair(d, d.KeyPairName, string(publicKey)); err != nil { return err } return nil }
// Create creates a GCE VM instance acting as a docker host. func (d *Driver) Create() error { c, err := newComputeUtil(d) if err != nil { return err } log.Infof("Creating host...") // Check if the instance already exists. There will be an error if the instance // doesn't exist, so just check instance for nil. if instance, _ := c.instance(); instance != nil { return fmt.Errorf("Instance %v already exists.", d.MachineName) } log.Infof("Generating SSH Key") if err := ssh.GenerateSSHKey(d.GetSSHKeyPath()); err != nil { return err } return c.createInstance(d) }
// ensureSSHKey makes sure an SSH key for the machine exists with requested name func (d *Driver) ensureSSHKey() error { client, err := d.getClient() if err != nil { return err } // Attempt to get an existing key log.Debug("Checking Key Pair...", map[string]interface{}{"Name": d.KeyPairName}) sshKey, _ := client.GetSshkeyByName(d.ProjectID, d.RegionName, d.KeyPairName) if sshKey != nil { d.KeyPairID = sshKey.ID log.Debug("Found key id ", d.KeyPairID) return nil } // Generate key and parent dir if needed log.Debug("Creating Key Pair...", map[string]interface{}{"Name": d.KeyPairName}) keyfile := d.GetSSHKeyPath() keypath := filepath.Dir(keyfile) err = os.MkdirAll(keypath, 0700) if err != nil { return err } err = ssh.GenerateSSHKey(d.GetSSHKeyPath()) if err != nil { return err } publicKey, err := ioutil.ReadFile(d.publicSSHKeyPath()) if err != nil { return err } // Upload key sshKey, err = client.CreateSshkey(d.ProjectID, d.KeyPairName, string(publicKey)) if err != nil { return err } d.KeyPairID = sshKey.ID log.Debug("Created key id ", d.KeyPairID) return nil }
func (d *Driver) createSSHKey() error { sanitizeKeyPairName(&d.KeyPairName) log.Debug("Creating Key Pair...", map[string]string{"Name": d.KeyPairName}) if err := ssh.GenerateSSHKey(d.GetSSHKeyPath()); err != nil { return err } publicKey, err := ioutil.ReadFile(d.publicSSHKeyPath()) if err != nil { return err } if err := d.initCompute(); err != nil { return err } if err := d.client.CreateKeyPair(d, d.KeyPairName, string(publicKey)); err != nil { return err } return nil }
func (d *Driver) createKeyPair() error { keyPath := "" if d.SSHPrivateKeyPath == "" { log.Debugf("Creating New SSH Key") if err := ssh.GenerateSSHKey(d.GetSSHKeyPath()); err != nil { return err } keyPath = d.GetSSHKeyPath() } else { log.Debugf("Using SSHPrivateKeyPath: %s", d.SSHPrivateKeyPath) if err := mcnutils.CopyFile(d.SSHPrivateKeyPath, d.GetSSHKeyPath()); err != nil { return err } if err := mcnutils.CopyFile(d.SSHPrivateKeyPath+".pub", d.GetSSHKeyPath()+".pub"); err != nil { return err } if d.KeyName != "" { log.Debugf("Using existing EC2 key pair: %s", d.KeyName) return nil } keyPath = d.SSHPrivateKeyPath } publicKey, err := ioutil.ReadFile(keyPath + ".pub") if err != nil { return err } keyName := d.MachineName log.Debugf("creating key pair: %s", keyName) _, err = d.getClient().ImportKeyPair(&ec2.ImportKeyPairInput{ KeyName: &keyName, PublicKeyMaterial: publicKey, }) if err != nil { return err } d.KeyName = keyName return nil }
func (d *Driver) createKeyPair() error { cs := d.getClient() if err := ssh.GenerateSSHKey(d.GetSSHKeyPath()); err != nil { return err } publicKey, err := ioutil.ReadFile(d.GetSSHKeyPath() + ".pub") if err != nil { return err } log.Infof("Registering SSH key pair...") p := cs.SSH.NewRegisterSSHKeyPairParams(d.SSHKeyPair, string(publicKey)) if _, err := cs.SSH.RegisterSSHKeyPair(p); err != nil { return err } return nil }
func (d *Driver) createSSHKey() (int, error) { if err := ssh.GenerateSSHKey(d.GetSSHKeyPath()); err != nil { return 0, err } publicKey, err := ioutil.ReadFile(d.publicSSHKeyPath()) if err != nil { return 0, err } createRequest := &goubi.AddKeyParams{ KeyName: d.MachineName, PubKey: string(publicKey), } key, err := d.getClient().Cloud.AddKey(createRequest) if err != nil { return key, err } return key, nil }
func (d *Driver) createKeyPair() error { if err := ssh.GenerateSSHKey(d.GetSSHKeyPath()); err != nil { return err } publicKey, err := ioutil.ReadFile(d.GetSSHKeyPath() + ".pub") if err != nil { return err } keyName := d.MachineName log.Debugf("creating key pair: %s", keyName) if err := d.getClient().ImportKeyPair(keyName, string(publicKey)); err != nil { return err } d.KeyName = keyName return nil }
func (d *Driver) createSSHKey() (*packngo.SSHKey, error) { if err := ssh.GenerateSSHKey(d.sshKeyPath()); err != nil { return nil, err } publicKey, err := ioutil.ReadFile(d.publicSSHKeyPath()) if err != nil { return nil, err } createRequest := &packngo.SSHKeyCreateRequest{ Label: fmt.Sprintf("docker machine: %s", d.MachineName), Key: string(publicKey), } key, _, err := d.getClient().SSHKeys.Create(createRequest) if err != nil { return key, err } return key, nil }
// Create creates a GCE VM instance acting as a docker host. func (d *Driver) Create() error { log.Infof("Generating SSH Key") if err := ssh.GenerateSSHKey(d.GetSSHKeyPath()); err != nil { return err } log.Infof("Creating host...") c, err := newComputeUtil(d) if err != nil { return err } if err := c.openFirewallPorts(); err != nil { return err } if d.UseExisting { return c.configureInstance(d) } return c.createInstance(d) }
func (d *Driver) Create() error { b2dutils := mcnutils.NewB2dUtils("", "", d.StorePath) if err := b2dutils.CopyIsoToMachineDir(d.Boot2DockerURL, d.MachineName); err != nil { return err } // download cloud-init config drive if d.ConfigDriveURL != "" { log.Infof("Downloading %s from %s", isoConfigDrive, d.ConfigDriveURL) if err := b2dutils.DownloadISO(d.ResolveStorePath("."), isoConfigDrive, d.ConfigDriveURL); err != nil { return err } } log.Infof("Creating SSH key...") if err := ssh.GenerateSSHKey(d.GetSSHKeyPath()); err != nil { return err } log.Infof("Creating VM...") if err := os.MkdirAll(d.ResolveStorePath("."), 0755); err != nil { return err } if _, err := os.Stat(d.vmxPath()); err == nil { return ErrMachineExist } // Generate vmx config file from template vmxt := template.Must(template.New("vmx").Parse(vmx)) vmxfile, err := os.Create(d.vmxPath()) if err != nil { return err } vmxt.Execute(vmxfile, d) // Generate vmdk file diskImg := d.ResolveStorePath(fmt.Sprintf("%s.vmdk", d.MachineName)) if _, err := os.Stat(diskImg); err != nil { if !os.IsNotExist(err) { return err } if err := vdiskmanager(diskImg, d.DiskSize); err != nil { return err } } log.Infof("Starting %s...", d.MachineName) vmrun("start", d.vmxPath(), "nogui") var ip string 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) conn, err := net.DialTimeout("tcp", fmt.Sprintf("%s:%d", ip, 22), time.Duration(2*time.Second)) if err != nil { log.Debugf("SSH Daemon not responding yet: %s", err) time.Sleep(2 * time.Second) continue } conn.Close() break } } if ip == "" { return fmt.Errorf("Machine didn't return an IP after 120 seconds, aborting") } // we got an IP, let's copy ssh keys over d.IPAddress = ip // Do not execute the rest of boot2docker specific configuration // The uplaod of the public ssh key uses a ssh connection, // this works without installed vmware client tools if d.ConfigDriveURL != "" { var keyfh *os.File var keycontent []byte log.Infof("Copy public SSH key to %s [%s]", d.MachineName, d.IPAddress) // create .ssh folder in users home if err := executeSSHCommand(fmt.Sprintf("mkdir -p /home/%s/.ssh", d.SSHUser), d); err != nil { return err } // read generated public ssh key if keyfh, err = os.Open(d.publicSSHKeyPath()); err != nil { return err } defer keyfh.Close() if keycontent, err = ioutil.ReadAll(keyfh); err != nil { return err } // add public ssh key to authorized_keys if err := executeSSHCommand(fmt.Sprintf("echo '%s' > /home/%s/.ssh/authorized_keys", string(keycontent), d.SSHUser), d); err != nil { return err } // make it secure if err := executeSSHCommand(fmt.Sprintf("chmod 600 /home/%s/.ssh/authorized_keys", d.SSHUser), d); err != nil { return err } log.Debugf("Leaving create sequence early, configdrive found") return nil } // Generate a tar keys bundle if err := d.generateKeyBundle(); err != nil { return err } // Test if /var/lib/boot2docker exists vmrun("-gu", B2DUser, "-gp", B2DPass, "directoryExistsInGuest", d.vmxPath(), "/var/lib/boot2docker") // Copy SSH keys bundle vmrun("-gu", B2DUser, "-gp", B2DPass, "CopyFileFromHostToGuest", d.vmxPath(), d.ResolveStorePath("userdata.tar"), "/home/docker/userdata.tar") // Expand tar file. vmrun("-gu", B2DUser, "-gp", B2DPass, "runScriptInGuest", d.vmxPath(), "/bin/sh", "sudo /bin/mv /home/docker/userdata.tar /var/lib/boot2docker/userdata.tar && sudo tar xf /var/lib/boot2docker/userdata.tar -C /home/docker/ > /var/log/userdata.log 2>&1 && sudo chown -R docker:staff /home/docker") // Enable Shared Folders vmrun("-gu", B2DUser, "-gp", B2DPass, "enableSharedFolders", d.vmxPath()) var shareName, shareDir string // TODO configurable at some point switch runtime.GOOS { case "darwin": shareName = "Users" shareDir = "/Users" // TODO "linux" and "windows" } if shareDir != "" { if _, err := os.Stat(shareDir); err != nil && !os.IsNotExist(err) { return err } else if !os.IsNotExist(err) { // add shared folder, create mountpoint and mount it. vmrun("-gu", B2DUser, "-gp", B2DPass, "addSharedFolder", d.vmxPath(), shareName, shareDir) command := "[ ! -d " + shareDir + " ]&& sudo mkdir " + shareDir + "; [ -f /usr/local/bin/vmhgfs-fuse ]&& sudo /usr/local/bin/vmhgfs-fuse -o allow_other .host:/" + shareName + " " + shareDir + " || sudo mount -t vmhgfs .host:/" + shareName + " " + shareDir vmrun("-gu", B2DUser, "-gp", B2DPass, "runScriptInGuest", d.vmxPath(), "/bin/sh", command) } } return nil }
func (d *Driver) Create() error { b2dutils := mcnutils.NewB2dUtils(d.StorePath) if err := b2dutils.CopyIsoToMachineDir(d.Boot2DockerURL, d.MachineName); err != nil { return err } log.Infof("Creating VirtualBox VM...") // import b2d VM if requested if d.Boot2DockerImportVM != "" { name := d.Boot2DockerImportVM // make sure vm is stopped _ = d.vbm("controlvm", name, "poweroff") diskInfo, err := getVMDiskInfo(name, d.VBoxManager) if err != nil { return err } if _, err := os.Stat(diskInfo.Path); err != nil { return err } if err := d.vbm("clonehd", diskInfo.Path, d.diskPath()); err != nil { return err } log.Debugf("Importing VM settings...") vmInfo, err := getVMInfo(name, d.VBoxManager) if err != nil { return err } d.CPU = vmInfo.CPUs d.Memory = vmInfo.Memory log.Debugf("Importing SSH key...") keyPath := filepath.Join(mcnutils.GetHomeDir(), ".ssh", "id_boot2docker") if err := mcnutils.CopyFile(keyPath, d.GetSSHKeyPath()); err != nil { return err } } else { log.Infof("Creating SSH key...") if err := ssh.GenerateSSHKey(d.GetSSHKeyPath()); err != nil { return err } log.Debugf("Creating disk image...") if err := d.generateDiskImage(d.DiskSize); err != nil { return err } } if err := d.vbm("createvm", "--basefolder", d.ResolveStorePath("."), "--name", d.MachineName, "--register"); err != nil { return err } log.Debugf("VM CPUS: %d", d.CPU) log.Debugf("VM Memory: %d", d.Memory) cpus := d.CPU if cpus < 1 { cpus = int(runtime.NumCPU()) } if cpus > 32 { cpus = 32 } if err := d.vbm("modifyvm", d.MachineName, "--firmware", "bios", "--bioslogofadein", "off", "--bioslogofadeout", "off", "--bioslogodisplaytime", "0", "--biosbootmenu", "disabled", "--ostype", "Linux26_64", "--cpus", fmt.Sprintf("%d", cpus), "--memory", fmt.Sprintf("%d", d.Memory), "--acpi", "on", "--ioapic", "on", "--rtcuseutc", "on", "--natdnshostresolver1", "off", "--natdnsproxy1", "off", "--cpuhotplug", "off", "--pae", "on", "--hpet", "on", "--hwvirtex", "on", "--nestedpaging", "on", "--largepages", "on", "--vtxvpid", "on", "--accelerate3d", "off", "--boot1", "dvd"); err != nil { return err } if err := d.vbm("modifyvm", d.MachineName, "--nic1", "nat", "--nictype1", "82540EM", "--cableconnected1", "on"); err != nil { return err } if err := d.setupHostOnlyNetwork(d.MachineName); err != nil { return err } if err := d.vbm("storagectl", d.MachineName, "--name", "SATA", "--add", "sata", "--hostiocache", "on"); err != nil { return err } if err := d.vbm("storageattach", d.MachineName, "--storagectl", "SATA", "--port", "0", "--device", "0", "--type", "dvddrive", "--medium", d.ResolveStorePath("boot2docker.iso")); err != nil { return err } if err := d.vbm("storageattach", d.MachineName, "--storagectl", "SATA", "--port", "1", "--device", "0", "--type", "hdd", "--medium", d.diskPath()); err != nil { return err } // let VBoxService do nice magic automounting (when it's used) if err := d.vbm("guestproperty", "set", d.MachineName, "/VirtualBox/GuestAdd/SharedFolders/MountPrefix", "/"); err != nil { return err } if err := d.vbm("guestproperty", "set", d.MachineName, "/VirtualBox/GuestAdd/SharedFolders/MountDir", "/"); err != nil { return err } shareName, shareDir := getShareDriveAndName() if shareDir != "" && !d.NoShare { log.Debugf("setting up shareDir") if _, err := os.Stat(shareDir); err != nil && !os.IsNotExist(err) { return err } else if !os.IsNotExist(err) { if shareName == "" { // parts of the VBox internal code are buggy with share names that start with "/" shareName = strings.TrimLeft(shareDir, "/") // TODO do some basic Windows -> MSYS path conversion // ie, s!^([a-z]+):[/\\]+!\1/!; s!\\!/!g } // woo, shareDir exists! let's carry on! if err := d.vbm("sharedfolder", "add", d.MachineName, "--name", shareName, "--hostpath", shareDir, "--automount"); err != nil { return err } // enable symlinks if err := d.vbm("setextradata", d.MachineName, "VBoxInternal2/SharedFoldersEnableSymlinksCreate/"+shareName, "1"); err != nil { return err } } } return d.Start() }
func (d *Driver) Create() error { log.Infof("Creating SSH key...") if err := ssh.GenerateSSHKey(d.GetSSHKeyPath()); err != nil { return err } c, err := NewClient("http://localhost:" + strconv.Itoa(d.APIPort)) if err != nil { return err } log.Infof("Creating VM...") _, err = c.CloneVM(d.MachineName, d.MachineName, "photon") if err != nil { return err } // Set memory amount if err = d.setVMXValue("memsize", strconv.Itoa(d.Memory)); err != nil { return err } // Set cpu number if err = d.setVMXValue("numvcpus", strconv.Itoa(d.CPU)); err != nil { return err } log.Infof("Starting %s...", d.MachineName) _, err = c.PowerVM(d.MachineName, "on") if err != nil { return err } if _, err := d.GetIP(); err != nil { return err } // Add SSH Key to photon user log.Infof("Replacing insecure SSH key...") if err := d.replaceInsecureSSHKey(); err != nil { return err } var shareName, shareDir string // TODO configurable at some point switch runtime.GOOS { case "darwin": shareName = "Users" shareDir = "/Users" // TODO "linux" and "windows" } if shareDir != "" { if _, err := os.Stat(shareDir); err != nil && !os.IsNotExist(err) { return err } else if !os.IsNotExist(err) { // add shared folder, create mountpoint and mount it. // Enable Shared Folders if _, err := c.SetVMSharedFolders(d.MachineName, "true"); err != nil { return err } // Add shared folder to VM if _, err := c.AddVMSharedFolder(d.MachineName, shareName, shareDir, 4); err != nil { return err } // create mountpoint and mount shared folder if err := d.mountSharedFolder(shareDir, shareName); err != nil { return err } } } return nil }
// Create has the following implementation: // 1. check whether the docker directory contains the boot2docker ISO // 2. generate an SSH keypair and bundle it in a tar. // 3. create a virtual machine with the boot2docker ISO mounted; // 4. reconfigure the virtual machine network and disk size; func (d *Driver) Create() error { b2dutils := mcnutils.NewB2dUtils(d.StorePath) if err := b2dutils.CopyIsoToMachineDir(d.Boot2DockerURL, d.MachineName); err != nil { return err } log.Infof("Generating SSH Keypair...") if err := ssh.GenerateSSHKey(d.GetSSHKeyPath()); err != nil { return err } // Create context ctx, cancel := context.WithCancel(context.Background()) defer cancel() c, err := d.vsphereLogin(ctx) if err != nil { return err } defer c.Logout(ctx) // Create a new finder f := find.NewFinder(c.Client, true) dc, err := f.DatacenterOrDefault(ctx, d.Datacenter) if err != nil { return err } f.SetDatacenter(dc) dss, err := f.DatastoreOrDefault(ctx, d.Datastore) if err != nil { return err } net, err := f.NetworkOrDefault(ctx, d.Network) if err != nil { return err } hs, err := f.HostSystemOrDefault(ctx, d.HostSystem) if err != nil { return err } var rp *object.ResourcePool if d.Pool != "" { // Find specified Resource Pool rp, err = f.ResourcePool(ctx, d.Pool) if err != nil { return err } } else { // Pick default Resource Pool for Host System rp, err = hs.ResourcePool(ctx) if err != nil { return err } } spec := types.VirtualMachineConfigSpec{ Name: d.MachineName, GuestId: "otherLinux64Guest", Files: &types.VirtualMachineFileInfo{VmPathName: fmt.Sprintf("[%s]", dss.Name())}, NumCPUs: int32(d.CPU), MemoryMB: int64(d.Memory), } scsi, err := object.SCSIControllerTypes().CreateSCSIController("pvscsi") if err != nil { return err } spec.DeviceChange = append(spec.DeviceChange, &types.VirtualDeviceConfigSpec{ Operation: types.VirtualDeviceConfigSpecOperationAdd, Device: scsi, }) log.Infof("Creating VM...") folders, err := dc.Folders(ctx) task, err := folders.VmFolder.CreateVM(ctx, spec, rp, hs) if err != nil { return err } info, err := task.WaitForResult(ctx, nil) if err != nil { return err } log.Infof("Uploading Boot2docker ISO ...") dsurl, err := dss.URL(ctx, dc, fmt.Sprintf("%s/%s", d.MachineName, isoFilename)) if err != nil { return err } p := soap.DefaultUpload if err = c.Client.UploadFile(d.ISO, dsurl, &p); err != nil { return err } // Retrieve the new VM vm := object.NewVirtualMachine(c.Client, info.Result.(types.ManagedObjectReference)) devices, err := vm.Device(ctx) if err != nil { return err } var add []types.BaseVirtualDevice controller, err := devices.FindDiskController("scsi") if err != nil { return err } disk := devices.CreateDisk(controller, dss.Reference(), dss.Path(fmt.Sprintf("%s/%s.vmdk", d.MachineName, d.MachineName))) // Convert MB to KB disk.CapacityInKB = int64(d.DiskSize) * 1024 add = append(add, disk) ide, err := devices.FindIDEController("") if err != nil { return err } cdrom, err := devices.CreateCdrom(ide) if err != nil { return err } add = append(add, devices.InsertIso(cdrom, dss.Path(fmt.Sprintf("%s/%s", d.MachineName, isoFilename)))) backing, err := net.EthernetCardBackingInfo(ctx) if err != nil { return err } netdev, err := object.EthernetCardTypes().CreateEthernetCard("vmxnet3", backing) if err != nil { return err } log.Infof("Reconfiguring VM...") add = append(add, netdev) if vm.AddDevice(ctx, add...); err != nil { return err } if err := d.Start(); err != nil { return err } log.Infof("Provisioning certs and ssh keys...") // Generate a tar keys bundle if err := d.generateKeyBundle(); err != nil { return err } opman := guest.NewOperationsManager(c.Client, vm.Reference()) fileman, err := opman.FileManager(ctx) if err != nil { return err } src := d.ResolveStorePath("userdata.tar") s, err := os.Stat(src) if err != nil { return err } auth := AuthFlag{} flag := FileAttrFlag{} auth.auth.Username = B2DUser auth.auth.Password = B2DPass flag.SetPerms(0, 0, 660) url, err := fileman.InitiateFileTransferToGuest(ctx, auth.Auth(), "/home/docker/userdata.tar", flag.Attr(), s.Size(), true) if err != nil { return err } u, err := c.Client.ParseURL(url) if err != nil { return err } if err = c.Client.UploadFile(src, u, nil); err != nil { return err } procman, err := opman.ProcessManager(ctx) if err != nil { return err } var env []string guestspec := types.GuestProgramSpec{ ProgramPath: "/usr/bin/sudo", Arguments: "/bin/mv /home/docker/userdata.tar /var/lib/boot2docker/userdata.tar && /usr/bin/sudo tar xf /var/lib/boot2docker/userdata.tar -C /home/docker/ > /var/log/userdata.log 2>&1 && /usr/bin/sudo chown -R docker:staff /home/docker", WorkingDirectory: "", EnvVariables: env, } _, err = procman.StartProgram(ctx, auth.Auth(), &guestspec) if err != nil { return err } return nil }