func resourceVirtualMachineRead(d *schema.ResourceData, meta interface{}) error {
client := meta.(*vim25.Client)
vm_mor := types.ManagedObjectReference{Type: "VirtualMachine", Value: d.Id()}
vm := object.NewVirtualMachine(client, vm_mor)
var vm_mo mo.VirtualMachine
err := vm.Properties(context.TODO(), vm.Reference(), []string{"summary"}, &vm_mo)
if err != nil {
log.Printf("[INFO] Cannot read VM properties: %s", err)
d.SetId("")
return nil
}
d.Set("name", vm_mo.Summary.Config.Name)
d.Set("cpus", vm_mo.Summary.Config.NumCpu)
d.Set("memory", vm_mo.Summary.Config.MemorySizeMB)
if vm_mo.Summary.Runtime.PowerState == "poweredOn" {
d.Set("power_on", true)
} else {
d.Set("power_on", false)
}
if d.Get("power_on").(bool) {
ip, err := vm.WaitForIP(context.TODO())
if err != nil {
log.Printf("[ERROR] Cannot read ip address: %s", err)
} else {
d.Set("ip_address", ip)
}
}
return nil
}
func (cmd *ovfx) Run(ctx context.Context, f *flag.FlagSet) error {
fpath, err := cmd.Prepare(f)
if err != nil {
return err
}
cmd.Archive = &FileArchive{fpath}
moref, err := cmd.Import(fpath)
if err != nil {
return err
}
vm := object.NewVirtualMachine(cmd.Client, *moref)
return cmd.Deploy(vm)
}
func (cmd *vmdk) CreateVM(spec *configSpec) (*object.VirtualMachine, error) {
folders, err := cmd.Datacenter.Folders(context.TODO())
if err != nil {
return nil, err
}
task, err := folders.VmFolder.CreateVM(context.TODO(), spec.ToSpec(), cmd.ResourcePool, nil)
if err != nil {
return nil, err
}
info, err := task.WaitForResult(context.TODO(), nil)
if err != nil {
return nil, err
}
return object.NewVirtualMachine(cmd.Client, info.Result.(types.ManagedObjectReference)), nil
}
// GetSelf gets VirtualMachine reference for the VM this process is running on
func GetSelf(ctx context.Context, s *session.Session) (*object.VirtualMachine, error) {
u, err := sys.UUID()
if err != nil {
return nil, err
}
search := object.NewSearchIndex(s.Vim25())
ref, err := search.FindByUuid(ctx, s.Datacenter, u, true, nil)
if err != nil {
return nil, err
}
if ref == nil {
return nil, fmt.Errorf("can't find the hosting vm")
}
vm := object.NewVirtualMachine(s.Client.Client, ref.Reference())
return vm, nil
}
func resourceVirtualMachineDelete(d *schema.ResourceData, meta interface{}) error {
client := meta.(*vim25.Client)
vm_mor := types.ManagedObjectReference{Type: "VirtualMachine", Value: d.Id()}
vm := object.NewVirtualMachine(client, vm_mor)
task, err := vm.PowerOff(context.TODO())
if err != nil {
return fmt.Errorf("Error powering vm off: %s", err)
}
task.WaitForResult(context.TODO(), nil)
task, err = vm.Destroy(context.TODO())
if err != nil {
return fmt.Errorf("Error deleting vm: %s", err)
}
_, err = task.WaitForResult(context.TODO(), nil)
if err != nil {
return fmt.Errorf("Error deleting vm: %s", err)
}
return nil
}
func (f *Finder) VirtualMachineList(ctx context.Context, path string) ([]*object.VirtualMachine, error) {
es, err := f.find(ctx, f.vmFolder, false, path)
if err != nil {
return nil, err
}
var vms []*object.VirtualMachine
for _, e := range es {
switch o := e.Object.(type) {
case mo.VirtualMachine:
vm := object.NewVirtualMachine(f.client, o.Reference())
vm.InventoryPath = e.Path
vms = append(vms, vm)
}
}
if len(vms) == 0 {
return nil, &NotFoundError{"vm", path}
}
return vms, nil
}
func (cmd *vmdk) CloneVM(vm *object.VirtualMachine, name string) (*object.VirtualMachine, error) {
folders, err := cmd.Datacenter.Folders(context.TODO())
if err != nil {
return nil, err
}
spec := types.VirtualMachineCloneSpec{
Config: &types.VirtualMachineConfigSpec{},
Location: types.VirtualMachineRelocateSpec{},
}
task, err := vm.Clone(context.TODO(), folders.VmFolder, name, spec)
if err != nil {
return nil, err
}
info, err := task.WaitForResult(context.TODO(), nil)
if err != nil {
return nil, err
}
return object.NewVirtualMachine(cmd.Client, info.Result.(types.ManagedObjectReference)), 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
}
func (cmd *create) Run(ctx context.Context, f *flag.FlagSet) error {
var err error
if len(f.Args()) != 1 {
return flag.ErrHelp
}
cmd.name = f.Arg(0)
if cmd.name == "" {
return flag.ErrHelp
}
cmd.Client, err = cmd.ClientFlag.Client()
if err != nil {
return err
}
cmd.Datacenter, err = cmd.DatacenterFlag.Datacenter()
if err != nil {
return err
}
cmd.Datastore, err = cmd.DatastoreFlag.Datastore()
if err != nil {
return err
}
cmd.HostSystem, err = cmd.HostSystemFlag.HostSystemIfSpecified()
if err != nil {
return err
}
if cmd.HostSystem != nil {
if cmd.ResourcePool, err = cmd.HostSystem.ResourcePool(context.TODO()); err != nil {
return err
}
} else {
// -host is optional
if cmd.ResourcePool, err = cmd.ResourcePoolFlag.ResourcePool(); err != nil {
return err
}
}
// Verify ISO exists
if cmd.iso != "" {
_, err = cmd.isoDatastoreFlag.Stat(context.TODO(), cmd.iso)
if err != nil {
return err
}
cmd.isoDatastore, err = cmd.isoDatastoreFlag.Datastore()
if err != nil {
return err
}
}
// Verify disk exists
if cmd.disk != "" {
_, err = cmd.diskDatastoreFlag.Stat(context.TODO(), cmd.disk)
if err != nil {
return err
}
cmd.diskDatastore, err = cmd.diskDatastoreFlag.Datastore()
if err != nil {
return err
}
}
task, err := cmd.createVM(context.TODO())
if err != nil {
return err
}
info, err := task.WaitForResult(context.TODO(), nil)
if err != nil {
return err
}
vm := object.NewVirtualMachine(cmd.Client, info.Result.(types.ManagedObjectReference))
if cmd.on {
task, err := vm.PowerOn(context.TODO())
if err != nil {
return err
}
_, err = task.WaitForResult(context.TODO(), nil)
if err != nil {
return err
}
}
return nil
}
func TestCreateVm(t *testing.T) {
ctx := context.Background()
for _, model := range []*Model{ESX(), VPX()} {
defer model.Remove()
err := model.Create()
if err != nil {
t.Fatal(err)
}
s := model.Service.NewServer()
defer s.Close()
c, err := govmomi.NewClient(ctx, s.URL, true)
if err != nil {
t.Fatal(err)
}
spec := types.VirtualMachineConfigSpec{
// Note: real ESX allows the VM to be created without a GuestId,
// but will power on will fail.
GuestId: string(types.VirtualMachineGuestOsIdentifierOtherGuest),
}
steps := []func(){
func() {
spec.Name = "test"
},
func() {
spec.Files = &types.VirtualMachineFileInfo{
VmPathName: fmt.Sprintf("[LocalDS_0] %s/%s.vmx", spec.Name, spec.Name),
}
},
}
finder := find.NewFinder(c.Client, false)
dc, err := finder.DefaultDatacenter(ctx)
if err != nil {
t.Fatal(err)
}
finder.SetDatacenter(dc)
folders, err := dc.Folders(ctx)
if err != nil {
t.Fatal(err)
}
hosts, err := finder.HostSystemList(ctx, "*/*")
if err != nil {
t.Fatal(err)
}
nhosts := len(hosts)
host := hosts[rand.Intn(nhosts)]
pool, err := host.ResourcePool(ctx)
if err != nil {
t.Fatal(err)
}
if nhosts == 1 {
// test the default path against the ESX model
host = nil
}
vmFolder := folders.VmFolder
// expecting CreateVM to fail until all steps are taken
for _, step := range steps {
task, cerr := vmFolder.CreateVM(ctx, spec, pool, host)
if cerr != nil {
t.Fatal(err)
}
_, cerr = task.WaitForResult(ctx, nil)
if cerr == nil {
t.Error("expected error")
}
step()
}
task, err := vmFolder.CreateVM(ctx, spec, pool, host)
if err != nil {
t.Fatal(err)
}
info, err := task.WaitForResult(ctx, nil)
if err != nil {
t.Fatal(err)
}
vm := object.NewVirtualMachine(c.Client, info.Result.(types.ManagedObjectReference))
name, err := vm.ObjectName(ctx)
if err != nil {
t.Fatal(err)
}
if name != spec.Name {
t.Errorf("name=%s", name)
}
_, err = vm.Device(ctx)
if err != nil {
t.Fatal(err)
}
recreate := func(context.Context) (*object.Task, error) {
return vmFolder.CreateVM(ctx, spec, pool, nil)
}
ops := []struct {
method func(context.Context) (*object.Task, error)
state types.VirtualMachinePowerState
fail bool
}{
// Powered off by default
{nil, types.VirtualMachinePowerStatePoweredOff, false},
// Create with same .vmx path should fail
{recreate, "", true},
// Off -> On == ok
{vm.PowerOn, types.VirtualMachinePowerStatePoweredOn, false},
// On -> On == fail
{vm.PowerOn, types.VirtualMachinePowerStatePoweredOn, true},
// On -> Off == ok
{vm.PowerOff, types.VirtualMachinePowerStatePoweredOff, false},
// Off -> Off == fail
{vm.PowerOff, types.VirtualMachinePowerStatePoweredOff, true},
// Off -> On == ok
{vm.PowerOn, types.VirtualMachinePowerStatePoweredOn, false},
// Destroy == fail (power is On)
{vm.Destroy, types.VirtualMachinePowerStatePoweredOn, true},
// On -> Off == ok
{vm.PowerOff, types.VirtualMachinePowerStatePoweredOff, false},
// Destroy == ok (power is Off)
{vm.Destroy, "", false},
}
for i, op := range ops {
if op.method != nil {
task, err = op.method(ctx)
if err != nil {
t.Fatal(err)
}
err = task.Wait(ctx)
if op.fail {
if err == nil {
t.Errorf("%d: expected error", i)
}
} else {
if err != nil {
t.Errorf("%d: %s", i, err)
}
}
}
if len(op.state) != 0 {
state, err := vm.PowerState(ctx)
if err != nil {
t.Fatal(err)
}
if state != op.state {
t.Errorf("state=%s", state)
}
}
}
}
}
func resourceVirtualMachineCreate(d *schema.ResourceData, meta interface{}) error {
client := meta.(*vim25.Client)
dc_name := d.Get("datacenter").(string)
if dc_name == "" {
finder := find.NewFinder(client, false)
dc, err := finder.DefaultDatacenter(context.TODO())
if err != nil {
return fmt.Errorf("Error reading default datacenter: %s", err)
}
var dc_mo mo.Datacenter
err = dc.Properties(context.TODO(), dc.Reference(), []string{"name"}, &dc_mo)
if err != nil {
return fmt.Errorf("Error reading datacenter name: %s", err)
}
dc_name = dc_mo.Name
d.Set("datacenter", dc_name)
}
image_name := d.Get("image").(string)
image_ref, err := object.NewSearchIndex(client).FindByInventoryPath(context.TODO(), fmt.Sprintf("%s/vm/%s", dc_name, image_name))
if err != nil {
return fmt.Errorf("Error reading vm: %s", err)
}
if image_ref == nil {
return fmt.Errorf("Cannot find image %s", image_name)
}
image := image_ref.(*object.VirtualMachine)
var image_mo mo.VirtualMachine
err = image.Properties(context.TODO(), image.Reference(), []string{"parent", "config.template", "resourcePool", "snapshot", "guest.toolsVersionStatus2", "config.guestFullName"}, &image_mo)
if err != nil {
return fmt.Errorf("Error reading base VM properties: %s", err)
}
var folder_ref object.Reference
var folder *object.Folder
if d.Get("folder").(string) != "" {
folder_ref, err = object.NewSearchIndex(client).FindByInventoryPath(context.TODO(), fmt.Sprintf("%v/vm/%v", dc_name, d.Get("folder").(string)))
if err != nil {
return fmt.Errorf("Error reading folder: %s", err)
}
if folder_ref == nil {
return fmt.Errorf("Cannot find folder %s", d.Get("folder").(string))
}
folder = folder_ref.(*object.Folder)
} else {
folder = object.NewFolder(client, *image_mo.Parent)
}
host_name := d.Get("host").(string)
if host_name == "" {
if image_mo.Config.Template == true {
return fmt.Errorf("Image is a template, 'host' is a required")
} else {
var pool_mo mo.ResourcePool
err = property.DefaultCollector(client).RetrieveOne(context.TODO(), *image_mo.ResourcePool, []string{"owner"}, &pool_mo)
if err != nil {
return fmt.Errorf("Error reading resource pool of base VM: %s", err)
}
if strings.Contains(pool_mo.Owner.Value, "domain-s") {
var host_mo mo.ComputeResource
err = property.DefaultCollector(client).RetrieveOne(context.TODO(), pool_mo.Owner, []string{"name"}, &host_mo)
if err != nil {
return fmt.Errorf("Error reading host of base VM: %s", err)
}
host_name = host_mo.Name
} else if strings.Contains(pool_mo.Owner.Value, "domain-c") {
var cluster_mo mo.ClusterComputeResource
err = property.DefaultCollector(client).RetrieveOne(context.TODO(), pool_mo.Owner, []string{"name"}, &cluster_mo)
if err != nil {
return fmt.Errorf("Error reading cluster of base VM: %s", err)
}
host_name = cluster_mo.Name
} else {
return fmt.Errorf("Unknown compute resource format of base VM: %s", pool_mo.Owner.Value)
}
}
}
pool_name := d.Get("resource_pool").(string)
pool_ref, err := object.NewSearchIndex(client).FindByInventoryPath(context.TODO(), fmt.Sprintf("%v/host/%v/Resources/%v", dc_name, host_name, pool_name))
if err != nil {
return fmt.Errorf("Error reading resource pool: %s", err)
}
if pool_ref == nil {
return fmt.Errorf("Cannot find resource pool %s", pool_name)
}
var relocateSpec types.VirtualMachineRelocateSpec
var pool_mor types.ManagedObjectReference
pool_mor = pool_ref.Reference()
relocateSpec.Pool = &pool_mor
if d.Get("linked_clone").(bool) {
relocateSpec.DiskMoveType = "createNewChildDiskBacking"
}
var confSpec types.VirtualMachineConfigSpec
if d.Get("cpus") != nil {
confSpec.NumCPUs = d.Get("cpus").(int)
}
if d.Get("memory") != nil {
confSpec.MemoryMB = int64(d.Get("memory").(int))
}
params := d.Get("configuration_parameters").(map[string]interface{})
var ov []types.BaseOptionValue
if len(params) > 0 {
for k, v := range params {
key := k
value := v
o := types.OptionValue{
Key: key,
Value: &value,
}
ov = append(ov, &o)
}
confSpec.ExtraConfig = ov
}
cloneSpec := types.VirtualMachineCloneSpec{
Location: relocateSpec,
Config: &confSpec,
PowerOn: d.Get("power_on").(bool),
}
if d.Get("linked_clone").(bool) {
if image_mo.Snapshot == nil {
return fmt.Errorf("`linked_clone=true`, but image VM has no snapshots")
}
cloneSpec.Snapshot = image_mo.Snapshot.CurrentSnapshot
}
domain := d.Get("domain").(string)
ip_address := d.Get("ip_address").(string)
if domain != "" {
if image_mo.Guest.ToolsVersionStatus2 == "guestToolsNotInstalled" {
return fmt.Errorf("VMware tools are not installed in base VM")
}
if !strings.Contains(image_mo.Config.GuestFullName, "Linux") && !strings.Contains(image_mo.Config.GuestFullName, "CentOS") {
return fmt.Errorf("Guest customization is supported only for Linux. Base image OS is: %s", image_mo.Config.GuestFullName)
}
customizationSpec := types.CustomizationSpec{
GlobalIPSettings: types.CustomizationGlobalIPSettings{},
Identity: &types.CustomizationLinuxPrep{
HostName: &types.CustomizationVirtualMachineName{},
Domain: domain,
},
NicSettingMap: []types.CustomizationAdapterMapping{
{
Adapter: types.CustomizationIPSettings{},
},
},
}
if ip_address != "" {
mask := d.Get("subnet_mask").(string)
if mask == "" {
return fmt.Errorf("'subnet_mask' must be set, if static 'ip_address' is specified")
}
customizationSpec.NicSettingMap[0].Adapter.Ip = &types.CustomizationFixedIp{
IpAddress: ip_address,
}
customizationSpec.NicSettingMap[0].Adapter.SubnetMask = d.Get("subnet_mask").(string)
gateway := d.Get("gateway").(string)
if gateway != "" {
customizationSpec.NicSettingMap[0].Adapter.Gateway = []string{gateway}
}
} else {
customizationSpec.NicSettingMap[0].Adapter.Ip = &types.CustomizationDhcpIpGenerator{}
}
cloneSpec.Customization = &customizationSpec
} else if ip_address != "" {
return fmt.Errorf("'domain' must be set, if static 'ip_address' is specified")
}
task, err := image.Clone(context.TODO(), folder, d.Get("name").(string), cloneSpec)
if err != nil {
return fmt.Errorf("Error clonning vm: %s", err)
}
info, err := task.WaitForResult(context.TODO(), nil)
if err != nil {
return fmt.Errorf("Error clonning vm: %s", err)
}
vm_mor := info.Result.(types.ManagedObjectReference)
d.SetId(vm_mor.Value)
vm := object.NewVirtualMachine(client, vm_mor)
// workaround for https://github.com/vmware/govmomi/issues/218
if ip_address == "" && d.Get("power_on").(bool) {
ip, err := vm.WaitForIP(context.TODO())
if err != nil {
log.Printf("[ERROR] Cannot read ip address: %s", err)
} else {
d.Set("ip_address", ip)
d.SetConnInfo(map[string]string{
"type": "ssh",
"host": ip,
})
}
}
return nil
}
// NewVirtualMachine returns a NewVirtualMachine object
func NewVirtualMachine(ctx context.Context, session *session.Session, moref types.ManagedObjectReference) *VirtualMachine {
return NewVirtualMachineFromVM(ctx, session, object.NewVirtualMachine(session.Client.Client, moref))
}
func (i *vSphereInstanceManager) Start(ctx context.Context, baseName string) (*Instance, error) {
client, err := i.client(ctx)
if err != nil {
return nil, err
}
vm, snapshotTree, err := i.findBaseVMAndSnapshot(ctx, baseName)
if err != nil {
return nil, fmt.Errorf("couldn't get base VM and snapshot: %s", err)
}
resourcePool, err := i.resourcePool(ctx)
if err != nil {
return nil, fmt.Errorf("couldn't get resource pool: %s", err)
}
relocateSpec := types.VirtualMachineRelocateSpec{
DiskMoveType: string(types.VirtualMachineRelocateDiskMoveOptionsCreateNewChildDiskBacking),
Pool: resourcePool,
}
cloneSpec := types.VirtualMachineCloneSpec{
Location: relocateSpec,
PowerOn: false,
Template: false,
Snapshot: &snapshotTree.Snapshot,
}
name := uuid.NewRandom()
vmFolder, err := i.vmFolder(ctx)
if err != nil {
return nil, err
}
task, err := vm.Clone(ctx, vmFolder, name.String(), cloneSpec)
if err != nil {
return nil, err
}
err = task.Wait(ctx)
if err != nil {
return nil, err
}
var mt mo.Task
err = task.Properties(ctx, task.Reference(), []string{"info"}, &mt)
if err != nil {
return nil, err
}
if mt.Info.Result == nil {
return nil, fmt.Errorf("expected VM, but got nil")
}
vmManagedRef, ok := mt.Info.Result.(types.ManagedObjectReference)
if !ok {
return nil, fmt.Errorf("expected ManagedObjectReference, but got %T", mt.Info.Result)
}
newVM := object.NewVirtualMachine(client.Client, vmManagedRef)
task, err = newVM.PowerOn(ctx)
if err != nil {
return nil, err
}
err = task.Wait(ctx)
if err != nil {
return nil, err
}
return i.instanceForVirtualMachine(ctx, newVM)
}
func TestIssue242(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
h := NewHelper(t)
defer h.Teardown()
h.RequireVirtualCenter()
df, err := h.Datacenter().Folders(ctx)
if err != nil {
t.Fatal(err)
}
cr := h.ComputeResource()
// Get local datastores for compute resource
dss, err := h.LocalDatastores(ctx, cr)
if err != nil {
t.Fatal(err)
}
if len(dss) == 0 {
t.Fatalf("No local datastores")
}
// Get root resource pool for compute resource
rp, err := cr.ResourcePool(ctx)
if err != nil {
t.Fatal(err)
}
spec := types.VirtualMachineConfigSpec{
Name: fmt.Sprintf("govmomi-test-%s", time.Now().Format(time.RFC3339)),
Files: &types.VirtualMachineFileInfo{VmPathName: fmt.Sprintf("[%s]", dss[0].Name())},
NumCPUs: 1,
MemoryMB: 32,
}
// Create new VM
task, err := df.VmFolder.CreateVM(context.Background(), spec, rp, nil)
if err != nil {
t.Fatal(err)
}
info, err := task.WaitForResult(context.Background(), nil)
if err != nil {
t.Fatal(err)
}
vm := object.NewVirtualMachine(h.c, info.Result.(types.ManagedObjectReference))
defer func() {
task, err := vm.Destroy(context.Background())
if err != nil {
panic(err)
}
err = task.Wait(context.Background())
if err != nil {
panic(err)
}
}()
// Mark VM as template
err = vm.MarkAsTemplate(context.Background())
if err != nil {
t.Fatal(err)
}
// Get "environmentBrowser" property for VM template
var mvm mo.VirtualMachine
err = property.DefaultCollector(h.c).RetrieveOne(ctx, vm.Reference(), []string{"environmentBrowser"}, &mvm)
if err != nil {
t.Fatal(err)
}
}
func (cmd *clone) Run(ctx context.Context, f *flag.FlagSet) error {
var err error
if len(f.Args()) != 1 {
return flag.ErrHelp
}
cmd.name = f.Arg(0)
if cmd.name == "" {
return flag.ErrHelp
}
cmd.Client, err = cmd.ClientFlag.Client()
if err != nil {
return err
}
cmd.Datacenter, err = cmd.DatacenterFlag.Datacenter()
if err != nil {
return err
}
if cmd.StoragePodFlag.Isset() {
cmd.StoragePod, err = cmd.StoragePodFlag.StoragePod()
if err != nil {
return err
}
} else {
cmd.Datastore, err = cmd.DatastoreFlag.Datastore()
if err != nil {
return err
}
}
cmd.HostSystem, err = cmd.HostSystemFlag.HostSystemIfSpecified()
if err != nil {
return err
}
if cmd.HostSystem != nil {
if cmd.ResourcePool, err = cmd.HostSystem.ResourcePool(context.TODO()); err != nil {
return err
}
} else {
// -host is optional
if cmd.ResourcePool, err = cmd.ResourcePoolFlag.ResourcePool(); err != nil {
return err
}
}
if cmd.Folder, err = cmd.FolderFlag.Folder(); err != nil {
return err
}
if cmd.VirtualMachine, err = cmd.VirtualMachineFlag.VirtualMachine(); err != nil {
return err
}
task, err := cmd.cloneVM(context.TODO())
if err != nil {
return err
}
info, err := task.WaitForResult(context.TODO(), nil)
if err != nil {
return err
}
vm := object.NewVirtualMachine(cmd.Client, info.Result.(types.ManagedObjectReference))
if cmd.cpus > 0 || cmd.memory > 0 {
vmConfigSpec := types.VirtualMachineConfigSpec{}
if cmd.cpus > 0 {
vmConfigSpec.NumCPUs = int32(cmd.cpus)
}
if cmd.memory > 0 {
vmConfigSpec.MemoryMB = int64(cmd.memory)
}
task, err := vm.Reconfigure(context.TODO(), vmConfigSpec)
if err != nil {
return err
}
_, err = task.WaitForResult(context.TODO(), nil)
if err != nil {
return err
}
}
if cmd.on {
task, err := vm.PowerOn(context.TODO())
if err != nil {
return err
}
_, err = task.WaitForResult(context.TODO(), nil)
if err != nil {
return err
}
if cmd.waitForIP {
_, err = vm.WaitForIP(ctx)
if err != nil {
return err
}
}
}
return nil
}
//
// Create creates the VM by
// 1. Generating SSH keys
// 2. Logs in to vSphere and gathers dc, datastore, network, resource pool and
// other information
// 3. Clones the VM template
// 4. Powers on the VM
// 5. Uploads the SSH key bundle
//
// Parameters:
// None
// Returns:
// (error): various errors from vSphere
//
func (d *Driver) Create() error {
var relocateSpec types.VirtualMachineRelocateSpec
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()
// Query the inventory
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
}
folders, err := dc.Folders(ctx)
if err != nil {
return err
}
folder := folders.VmFolder
f.SetDatacenter(dc)
dss, err := f.DatastoreOrDefault(ctx, d.Datastore)
if err != nil {
return err
}
rp, err := f.ResourcePoolOrDefault(ctx, d.Pool)
if err != nil {
// Pick default Resource Pool for Host System
hs, err := f.HostSystemOrDefault(ctx, d.HostSystem)
if err != nil {
log.Warnf("Unable to find host system ", err)
}
if hs != nil {
rp, err = hs.ResourcePool(ctx)
if err != nil {
return err
}
if hs != nil {
hostref := hs.Reference()
relocateSpec.Host = &hostref
}
} else {
return err
}
}
dcName, err := d.getDatacenterName(dc)
if err != nil {
return err
}
image, err := d.getVMTemplate(d.VMTemplate, dcName, c.Client)
if err != nil {
return err
}
var imageMoRef mo.VirtualMachine
err = image.Properties(ctx, image.Reference(), []string{"parent", "config.template", "resourcePool", "snapshot", "guest.toolsVersionStatus2", "config.guestFullName"}, &imageMoRef)
if err != nil {
return fmt.Errorf("Error reading base VM properties: %s", err)
}
// Create a CloneSpec to clone the VM
datastoreref := dss.Reference()
folderref := folder.Reference()
poolref := rp.Reference()
relocateSpec.Datastore = &datastoreref
relocateSpec.Folder = &folderref
relocateSpec.Pool = &poolref
spec := types.VirtualMachineConfigSpec{
Name: d.MachineName,
GuestId: "otherLinux64Guest",
Files: &types.VirtualMachineFileInfo{VmPathName: fmt.Sprintf("[%s]", dss.Name())},
NumCPUs: d.CPU,
MemoryMB: int64(d.Memory),
}
cloneSpec := types.VirtualMachineCloneSpec{
Config: &spec,
}
if imageMoRef.Snapshot != nil {
relocateSpec.DiskMoveType = "createNewChildDiskBacking"
cloneSpec.Snapshot = imageMoRef.Snapshot.CurrentSnapshot
} else {
return fmt.Errorf("No snapshots for template, cannot use for cloning")
}
if d.Network != "" {
// search for the first network card of the source
devices, err := image.Device(ctx)
if err != nil {
return fmt.Errorf("Error reading base VM devices: %s", err)
}
var card *types.VirtualEthernetCard
for _, device := range devices {
if c, ok := device.(types.BaseVirtualEthernetCard); ok {
card = c.GetVirtualEthernetCard()
break
}
}
if card == nil {
return fmt.Errorf("No network device found for the template.")
}
// get the new backing information
net, err := f.NetworkOrDefault(ctx, d.Network)
if err != nil {
return fmt.Errorf("Network not found: %s", err)
}
backing, err := net.EthernetCardBackingInfo(ctx)
if err != nil {
return fmt.Errorf("Network backing not found: %s", err)
}
netdev, err := object.EthernetCardTypes().CreateEthernetCard("vmxnet3", backing)
if err != nil {
return fmt.Errorf("Failed to create ethernet card: %s", err)
}
//set backing info
card.Backing = netdev.(types.BaseVirtualEthernetCard).GetVirtualEthernetCard().Backing
// prepare virtual device config spec for network card
configSpecs := []types.BaseVirtualDeviceConfigSpec{
&types.VirtualDeviceConfigSpec{
Operation: types.VirtualDeviceConfigSpecOperationEdit,
Device: card,
},
}
relocateSpec.DeviceChange = configSpecs
}
cloneSpec.Location = relocateSpec
task, err := image.Clone(ctx, folder, d.MachineName, cloneSpec)
if err != nil {
return fmt.Errorf("Error cloning vm: %s", err)
}
info, err := task.WaitForResult(ctx, nil)
if err != nil {
return fmt.Errorf("Error cloning vm: %s", err)
}
vmMoRef := info.Result.(types.ManagedObjectReference)
vm := object.NewVirtualMachine(c.Client, vmMoRef)
// Power On the VM
if err := d.Start(); err != nil {
return err
}
// Upload the bundle
return d.uploadBundle(vm.Reference(), ctx, c.Client)
}
func (cmd *create) Run(ctx context.Context, f *flag.FlagSet) error {
var err error
if len(f.Args()) != 1 {
return flag.ErrHelp
}
cmd.Client, err = cmd.ClientFlag.Client()
if err != nil {
return err
}
cmd.Datacenter, err = cmd.DatacenterFlag.Datacenter()
if err != nil {
return err
}
cmd.Datastore, err = cmd.DatastoreFlag.Datastore()
if err != nil {
return err
}
cmd.HostSystem, err = cmd.HostSystemFlag.HostSystemIfSpecified()
if err != nil {
return err
}
if cmd.HostSystem != nil {
if cmd.ResourcePool, err = cmd.HostSystem.ResourcePool(context.TODO()); err != nil {
return err
}
} else {
// -host is optional
if cmd.ResourcePool, err = cmd.ResourcePoolFlag.ResourcePool(); err != nil {
return err
}
}
for _, file := range []*string{&cmd.iso, &cmd.disk} {
if *file != "" {
_, err = cmd.Datastore.Stat(context.TODO(), *file)
if err != nil {
return err
}
}
}
task, err := cmd.createVM(f.Arg(0))
if err != nil {
return err
}
info, err := task.WaitForResult(context.TODO(), nil)
if err != nil {
return err
}
vm := object.NewVirtualMachine(cmd.Client, info.Result.(types.ManagedObjectReference))
if err := cmd.addDevices(vm); err != nil {
return err
}
if cmd.on {
task, err := vm.PowerOn(context.TODO())
if err != nil {
return err
}
_, err = task.WaitForResult(context.TODO(), nil)
if err != nil {
return err
}
}
return nil
}
func (cmd *create) Run(ctx context.Context, f *flag.FlagSet) error {
var err error
if len(f.Args()) != 1 {
return flag.ErrHelp
}
cmd.name = f.Arg(0)
if cmd.name == "" {
return flag.ErrHelp
}
cmd.Client, err = cmd.ClientFlag.Client()
if err != nil {
return err
}
cmd.Datacenter, err = cmd.DatacenterFlag.Datacenter()
if err != nil {
return err
}
if cmd.StoragePodFlag.Isset() {
cmd.StoragePod, err = cmd.StoragePodFlag.StoragePod()
if err != nil {
return err
}
} else {
cmd.Datastore, err = cmd.DatastoreFlag.Datastore()
if err != nil {
return err
}
}
cmd.HostSystem, err = cmd.HostSystemFlag.HostSystemIfSpecified()
if err != nil {
return err
}
if cmd.HostSystem != nil {
if cmd.ResourcePool, err = cmd.HostSystem.ResourcePool(ctx); err != nil {
return err
}
} else {
// -host is optional
if cmd.ResourcePool, err = cmd.ResourcePoolFlag.ResourcePool(); err != nil {
return err
}
}
if cmd.Folder, err = cmd.FolderFlag.Folder(); err != nil {
return err
}
// Verify ISO exists
if cmd.iso != "" {
_, err = cmd.isoDatastoreFlag.Stat(ctx, cmd.iso)
if err != nil {
return err
}
cmd.isoDatastore, err = cmd.isoDatastoreFlag.Datastore()
if err != nil {
return err
}
}
// Verify disk exists
if cmd.disk != "" {
var b units.ByteSize
// If disk can be parsed as byte units, don't stat
err = b.Set(cmd.disk)
if err == nil {
cmd.diskByteSize = int64(b)
} else {
_, err = cmd.diskDatastoreFlag.Stat(ctx, cmd.disk)
if err != nil {
return err
}
cmd.diskDatastore, err = cmd.diskDatastoreFlag.Datastore()
if err != nil {
return err
}
}
}
task, err := cmd.createVM(ctx)
if err != nil {
return err
}
info, err := task.WaitForResult(ctx, nil)
if err != nil {
return err
}
vm := object.NewVirtualMachine(cmd.Client, info.Result.(types.ManagedObjectReference))
if cmd.on {
task, err := vm.PowerOn(ctx)
if err != nil {
return err
}
_, err = task.WaitForResult(ctx, nil)
if err != nil {
return err
}
}
return nil
}
// addTestVM will add a pseudo VM to the container
func addTestVM(container *Container) {
mo := types.ManagedObjectReference{Type: "vm", Value: "12"}
v := object.NewVirtualMachine(nil, mo)
container.vm = vm.NewVirtualMachineFromVM(nil, nil, v)
}