Merge pull request #60158 from cblecker/bump-deps-typing

vendor/bitbucket.org/bertimus9/systemstat/systemstat_ex.go

@@ -7,7 +7,6 @@
 package systemstat
 
 import (
-	"syscall"
 	"time"
 )
 
@@ -30,15 +29,8 @@ func getMemSample(procfile string) (samp MemSample) {
 }
 
 func getProcCPUSample() (s ProcCPUSample) {
-	var processInfo syscall.Rusage
-	syscall.Getrusage(syscall.RUSAGE_SELF, &processInfo)
-
+	notImplemented("getProcCPUSample")
 	s.Time = time.Now()
-	s.ProcMemUsedK = int64(processInfo.Maxrss)
-	s.User = float64(processInfo.Utime.Usec)/1000000 + float64(processInfo.Utime.Sec)
-	s.System = float64(processInfo.Stime.Usec)/1000000 + float64(processInfo.Stime.Sec)
-	s.Total = s.User + s.System
-
 	return
 }
 

vendor/github.com/seccomp/libseccomp-golang/BUILD

@@ -13,7 +13,6 @@ go_library(
     clinkopts = select({
         "@io_bazel_rules_go//go/platform:linux": [
             "-lseccomp",
-            "-lseccomp",
         ],
         "//conditions:default": [],
     }),

vendor/github.com/vmware/govmomi/.travis.yml

@@ -10,3 +10,4 @@ before_install:
 
 script:
   - make check test
+  - GOOS=windows make install

vendor/github.com/vmware/govmomi/object/datacenter.go

@@ -88,3 +88,42 @@ func (d Datacenter) Destroy(ctx context.Context) (*Task, error) {
 
 	return NewTask(d.c, res.Returnval), nil
 }
+
+// PowerOnVM powers on multiple virtual machines with a single vCenter call.
+// If called against ESX, serially powers on the list of VMs and the returned *Task will always be nil.
+func (d Datacenter) PowerOnVM(ctx context.Context, vm []types.ManagedObjectReference, option ...types.BaseOptionValue) (*Task, error) {
+	if d.Client().IsVC() {
+		req := types.PowerOnMultiVM_Task{
+			This:   d.Reference(),
+			Vm:     vm,
+			Option: option,
+		}
+
+		res, err := methods.PowerOnMultiVM_Task(ctx, d.c, &req)
+		if err != nil {
+			return nil, err
+		}
+
+		return NewTask(d.c, res.Returnval), nil
+	}
+
+	for _, ref := range vm {
+		obj := NewVirtualMachine(d.Client(), ref)
+		task, err := obj.PowerOn(ctx)
+		if err != nil {
+			return nil, err
+		}
+
+		err = task.Wait(ctx)
+		if err != nil {
+			// Ignore any InvalidPowerState fault, as it indicates the VM is already powered on
+			if f, ok := err.(types.HasFault); ok {
+				if _, ok = f.Fault().(*types.InvalidPowerState); !ok {
+					return nil, err
+				}
+			}
+		}
+	}
+
+	return nil, nil
+}

vendor/github.com/vmware/govmomi/object/datastore_file_manager.go

 /*
-Copyright (c) 2017 VMware, Inc. All Rights Reserved.
+Copyright (c) 2017-2018 VMware, Inc. All Rights Reserved.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -26,6 +26,7 @@ import (
 	"path"
 	"strings"
 
+	"github.com/vmware/govmomi/vim25/progress"
 	"github.com/vmware/govmomi/vim25/soap"
 )
 
@@ -36,7 +37,8 @@ type DatastoreFileManager struct {
 	FileManager        *FileManager
 	VirtualDiskManager *VirtualDiskManager
 
-	Force bool
+	Force            bool
+	DatacenterTarget *Datacenter
 }
 
 // NewFileManager creates a new instance of DatastoreFileManager
@@ -49,11 +51,25 @@ func (d Datastore) NewFileManager(dc *Datacenter, force bool) *DatastoreFileMana
 		FileManager:        NewFileManager(c),
 		VirtualDiskManager: NewVirtualDiskManager(c),
 		Force:              force,
+		DatacenterTarget:   dc,
 	}
 
 	return m
 }
 
+func (m *DatastoreFileManager) WithProgress(ctx context.Context, s progress.Sinker) context.Context {
+	return context.WithValue(ctx, m, s)
+}
+
+func (m *DatastoreFileManager) wait(ctx context.Context, task *Task) error {
+	var logger progress.Sinker
+	if s, ok := ctx.Value(m).(progress.Sinker); ok {
+		logger = s
+	}
+	_, err := task.WaitForResult(ctx, logger)
+	return err
+}
+
 // Delete dispatches to the appropriate Delete method based on file name extension
 func (m *DatastoreFileManager) Delete(ctx context.Context, name string) error {
 	switch path.Ext(name) {
@@ -73,7 +89,7 @@ func (m *DatastoreFileManager) DeleteFile(ctx context.Context, name string) erro
 		return err
 	}
 
-	return task.Wait(ctx)
+	return m.wait(ctx, task)
 }
 
 // DeleteVirtualDisk calls VirtualDiskManager.DeleteVirtualDisk
@@ -94,10 +110,58 @@ func (m *DatastoreFileManager) DeleteVirtualDisk(ctx context.Context, name strin
 		return err
 	}
 
-	return task.Wait(ctx)
+	return m.wait(ctx, task)
+}
+
+// CopyFile calls FileManager.CopyDatastoreFile
+func (m *DatastoreFileManager) CopyFile(ctx context.Context, src string, dst string) error {
+	srcp := m.Path(src)
+	dstp := m.Path(dst)
+
+	task, err := m.FileManager.CopyDatastoreFile(ctx, srcp.String(), m.Datacenter, dstp.String(), m.DatacenterTarget, m.Force)
+	if err != nil {
+		return err
+	}
+
+	return m.wait(ctx, task)
+}
+
+// Copy dispatches to the appropriate FileManager or VirtualDiskManager Copy method based on file name extension
+func (m *DatastoreFileManager) Copy(ctx context.Context, src string, dst string) error {
+	srcp := m.Path(src)
+	dstp := m.Path(dst)
+
+	f := m.FileManager.CopyDatastoreFile
+
+	if srcp.IsVMDK() {
+		// types.VirtualDiskSpec=nil as it is not implemented by vCenter
+		f = func(ctx context.Context, src string, srcDC *Datacenter, dst string, dstDC *Datacenter, force bool) (*Task, error) {
+			return m.VirtualDiskManager.CopyVirtualDisk(ctx, src, srcDC, dst, dstDC, nil, force)
+		}
+	}
+
+	task, err := f(ctx, srcp.String(), m.Datacenter, dstp.String(), m.DatacenterTarget, m.Force)
+	if err != nil {
+		return err
+	}
+
+	return m.wait(ctx, task)
+}
+
+// MoveFile calls FileManager.MoveDatastoreFile
+func (m *DatastoreFileManager) MoveFile(ctx context.Context, src string, dst string) error {
+	srcp := m.Path(src)
+	dstp := m.Path(dst)
+
+	task, err := m.FileManager.MoveDatastoreFile(ctx, srcp.String(), m.Datacenter, dstp.String(), m.DatacenterTarget, m.Force)
+	if err != nil {
+		return err
+	}
+
+	return m.wait(ctx, task)
 }
 
-// Move dispatches to the appropriate Move method based on file name extension
+// Move dispatches to the appropriate FileManager or VirtualDiskManager Move method based on file name extension
 func (m *DatastoreFileManager) Move(ctx context.Context, src string, dst string) error {
 	srcp := m.Path(src)
 	dstp := m.Path(dst)
@@ -108,12 +172,12 @@ func (m *DatastoreFileManager) Move(ctx context.Context, src string, dst string)
 		f = m.VirtualDiskManager.MoveVirtualDisk
 	}
 
-	task, err := f(ctx, srcp.String(), m.Datacenter, dstp.String(), m.Datacenter, m.Force)
+	task, err := f(ctx, srcp.String(), m.Datacenter, dstp.String(), m.DatacenterTarget, m.Force)
 	if err != nil {
 		return err
 	}
 
-	return task.Wait(ctx)
+	return m.wait(ctx, task)
 }
 
 // Path converts path name to a DatastorePath

vendor/github.com/vmware/govmomi/object/types.go

@@ -47,8 +47,10 @@ func NewReference(c *vim25.Client, e types.ManagedObjectReference) Reference {
 		return NewClusterComputeResource(c, e)
 	case "HostSystem":
 		return NewHostSystem(c, e)
-	case "Network", "OpaqueNetwork":
+	case "Network":
 		return NewNetwork(c, e)
+	case "OpaqueNetwork":
+		return NewOpaqueNetwork(c, e)
 	case "ResourcePool":
 		return NewResourcePool(c, e)
 	case "DistributedVirtualSwitch":

vendor/github.com/vmware/govmomi/simulator/BUILD

@@ -25,7 +25,6 @@ go_library(
         "license_manager.go",
         "model.go",
         "option_manager.go",
-        "os_unix.go",
         "performance_manager.go",
         "portgroup.go",
         "property_collector.go",
@@ -44,6 +43,36 @@ go_library(
         "virtual_disk_manager.go",
         "virtual_machine.go",
     ] + select({
+        "@io_bazel_rules_go//go/platform:android": [
+            "os_unix.go",
+        ],
+        "@io_bazel_rules_go//go/platform:darwin": [
+            "os_unix.go",
+        ],
+        "@io_bazel_rules_go//go/platform:dragonfly": [
+            "os_unix.go",
+        ],
+        "@io_bazel_rules_go//go/platform:freebsd": [
+            "os_unix.go",
+        ],
+        "@io_bazel_rules_go//go/platform:linux": [
+            "os_unix.go",
+        ],
+        "@io_bazel_rules_go//go/platform:nacl": [
+            "os_unix.go",
+        ],
+        "@io_bazel_rules_go//go/platform:netbsd": [
+            "os_unix.go",
+        ],
+        "@io_bazel_rules_go//go/platform:openbsd": [
+            "os_unix.go",
+        ],
+        "@io_bazel_rules_go//go/platform:plan9": [
+            "os_unix.go",
+        ],
+        "@io_bazel_rules_go//go/platform:solaris": [
+            "os_unix.go",
+        ],
         "@io_bazel_rules_go//go/platform:windows": [
             "os_windows.go",
         ],

vendor/github.com/vmware/govmomi/simulator/datacenter.go

@@ -20,15 +20,40 @@ import (
 	"strings"
 
 	"github.com/vmware/govmomi/simulator/esx"
+	"github.com/vmware/govmomi/vim25/methods"
 	"github.com/vmware/govmomi/vim25/mo"
+	"github.com/vmware/govmomi/vim25/soap"
 	"github.com/vmware/govmomi/vim25/types"
 )
 
+type Datacenter struct {
+	mo.Datacenter
+
+	isESX bool
+}
+
+// NewDatacenter creates a Datacenter and its child folders.
+func NewDatacenter(f *Folder) *Datacenter {
+	dc := &Datacenter{
+		isESX: f.Self == esx.RootFolder.Self,
+	}
+
+	if dc.isESX {
+		dc.Datacenter = esx.Datacenter
+	}
+
+	f.putChild(dc)
+
+	dc.createFolders()
+
+	return dc
+}
+
 // Create Datacenter Folders.
 // Every Datacenter has 4 inventory Folders: Vm, Host, Datastore and Network.
 // The ESX folder child types are limited to 1 type.
 // The VC folders have additional child types, including nested folders.
-func createDatacenterFolders(dc *mo.Datacenter, isVC bool) {
+func (dc *Datacenter) createFolders() {
 	folders := []struct {
 		ref   *types.ManagedObjectReference
 		name  string
@@ -44,7 +69,11 @@ func createDatacenterFolders(dc *mo.Datacenter, isVC bool) {
 		folder := &Folder{}
 		folder.Name = f.name
 
-		if isVC {
+		if dc.isESX {
+			folder.ChildType = f.types[:1]
+			folder.Self = *f.ref
+			Map.PutEntity(dc, folder)
+		} else {
 			folder.ChildType = f.types
 			e := Map.PutEntity(dc, folder)
 
@@ -52,10 +81,6 @@ func createDatacenterFolders(dc *mo.Datacenter, isVC bool) {
 			ref := e.Reference()
 			f.ref.Type = ref.Type
 			f.ref.Value = ref.Value
-		} else {
-			folder.ChildType = f.types[:1]
-			folder.Self = *f.ref
-			Map.PutEntity(dc, folder)
 		}
 	}
 
@@ -67,7 +92,7 @@ func createDatacenterFolders(dc *mo.Datacenter, isVC bool) {
 		network.Self = ref
 		network.Name = strings.Split(ref.Value, "-")[1]
 		network.Entity().Name = network.Name
-		if isVC {
+		if !dc.isESX {
 			network.Self.Value = "" // we want a different moid per-DC
 		}
 
@@ -76,7 +101,7 @@ func createDatacenterFolders(dc *mo.Datacenter, isVC bool) {
 }
 
 func datacenterEventArgument(obj mo.Entity) *types.DatacenterEventArgument {
-	dc, ok := obj.(*mo.Datacenter)
+	dc, ok := obj.(*Datacenter)
 	if !ok {
 		dc = Map.getEntityDatacenter(obj)
 	}
@@ -85,3 +110,26 @@ func datacenterEventArgument(obj mo.Entity) *types.DatacenterEventArgument {
 		EntityEventArgument: types.EntityEventArgument{Name: dc.Name},
 	}
 }
+
+func (dc *Datacenter) PowerOnMultiVMTask(ctx *Context, req *types.PowerOnMultiVM_Task) soap.HasFault {
+	task := CreateTask(dc, "powerOnMultiVM", func(_ *Task) (types.AnyType, types.BaseMethodFault) {
+		if dc.isESX {
+			return nil, new(types.NotImplemented)
+		}
+
+		for _, ref := range req.Vm {
+			vm := Map.Get(ref).(*VirtualMachine)
+			Map.WithLock(vm, func() {
+				vm.PowerOnVMTask(ctx, &types.PowerOnVM_Task{})
+			})
+		}
+
+		return nil, nil
+	})
+
+	return &methods.PowerOnMultiVM_TaskBody{
+		Res: &types.PowerOnMultiVM_TaskResponse{
+			Returnval: task.Run(),
+		},
+	}
+}

vendor/github.com/vmware/govmomi/simulator/file_manager.go

@@ -80,7 +80,7 @@ func (f *FileManager) resolve(dc *types.ManagedObjectReference, name string) (st
 		}
 	}
 
-	folder := Map.Get(*dc).(*mo.Datacenter).DatastoreFolder
+	folder := Map.Get(*dc).(*Datacenter).DatastoreFolder
 
 	ds, fault := f.findDatastore(Map.Get(folder), p.Datastore)
 	if fault != nil {

vendor/github.com/vmware/govmomi/simulator/folder.go

@@ -197,14 +197,10 @@ func (f *Folder) CreateDatacenter(ctx *Context, c *types.CreateDatacenter) soap.
 	r := &methods.CreateDatacenterBody{}
 
 	if f.hasChildType("Datacenter") && f.hasChildType("Folder") {
-		dc := &mo.Datacenter{}
+		dc := NewDatacenter(f)
 
 		dc.Name = c.Name
 
-		f.putChild(dc)
-
-		createDatacenterFolders(dc, true)
-
 		r.Res = &types.CreateDatacenterResponse{
 			Returnval: dc.Self,
 		}

vendor/github.com/vmware/govmomi/simulator/host_system.go

@@ -113,9 +113,7 @@ func addComputeResource(s *types.ComputeResourceSummary, h *HostSystem) {
 // CreateDefaultESX creates a standalone ESX
 // Adds objects of type: Datacenter, Network, ComputeResource, ResourcePool and HostSystem
 func CreateDefaultESX(f *Folder) {
-	dc := &esx.Datacenter
-	f.putChild(dc)
-	createDatacenterFolders(dc, false)
+	dc := NewDatacenter(f)
 
 	host := NewHostSystem(esx.HostSystem)
 

vendor/github.com/vmware/govmomi/simulator/model.go

@@ -164,6 +164,8 @@ func (m *Model) Create() error {
 
 	// After all hosts are created, this var is used to mount the host datastores.
 	var hosts []*object.HostSystem
+	hostMap := make(map[string][]*object.HostSystem)
+
 	// We need to defer VM creation until after the datastores are created.
 	var vms []func() error
 	// 1 DVS per DC, added to all hosts
@@ -416,12 +418,14 @@ func (m *Model) Create() error {
 				addMachine(name, nil, vapp.ResourcePool, folders)
 			}
 		}
+
+		hostMap[dcName] = hosts
+		hosts = nil
 	}
 
 	if m.ServiceContent.RootFolder == esx.RootFolder.Reference() {
 		// ESX model
 		host := object.NewHostSystem(client, esx.HostSystem.Reference())
-		hosts = append(hosts, host)
 
 		dc := object.NewDatacenter(client, esx.Datacenter.Reference())
 		folders, err := dc.Folders(ctx)
@@ -429,13 +433,17 @@ func (m *Model) Create() error {
 			return err
 		}
 
+		hostMap[dc.Reference().Value] = append(hosts, host)
+
 		addMachine(host.Reference().Value, host, nil, folders)
 	}
 
-	for i := 0; i < m.Datastore; i++ {
-		err := m.createLocalDatastore(m.fmtName("LocalDS_", i), hosts)
-		if err != nil {
-			return err
+	for dc, dchosts := range hostMap {
+		for i := 0; i < m.Datastore; i++ {
+			err := m.createLocalDatastore(dc, m.fmtName("LocalDS_", i), dchosts)
+			if err != nil {
+				return err
+			}
 		}
 	}
 
@@ -449,13 +457,9 @@ func (m *Model) Create() error {
 	return nil
 }
 
-var tempDir = func() (string, error) {
-	return ioutil.TempDir("", "govcsim-")
-}
-
-func (m *Model) createLocalDatastore(name string, hosts []*object.HostSystem) error {
+func (m *Model) createLocalDatastore(dc string, name string, hosts []*object.HostSystem) error {
 	ctx := context.Background()
-	dir, err := tempDir()
+	dir, err := ioutil.TempDir("", fmt.Sprintf("govcsim-%s-%s-", dc, name))
 	if err != nil {
 		return err
 	}

vendor/github.com/vmware/govmomi/simulator/os_unix.go

+//+build !windows
+
 /*
 Copyright (c) 2017 VMware, Inc. All Rights Reserved.
 

vendor/github.com/vmware/govmomi/simulator/registry.go

@@ -213,8 +213,8 @@ func (r *Registry) getEntityParent(item mo.Entity, kind string) mo.Entity {
 }
 
 // getEntityDatacenter returns the Datacenter containing the given item
-func (r *Registry) getEntityDatacenter(item mo.Entity) *mo.Datacenter {
-	return r.getEntityParent(item, "Datacenter").(*mo.Datacenter)
+func (r *Registry) getEntityDatacenter(item mo.Entity) *Datacenter {
+	return r.getEntityParent(item, "Datacenter").(*Datacenter)
 }
 
 func (r *Registry) getEntityFolder(item mo.Entity, kind string) *Folder {

vendor/github.com/vmware/govmomi/simulator/search_index.go

@@ -94,7 +94,7 @@ func (s *SearchIndex) FindChild(req *types.FindChild) soap.HasFault {
 	var children []types.ManagedObjectReference
 
 	switch e := obj.(type) {
-	case *mo.Datacenter:
+	case *Datacenter:
 		children = []types.ManagedObjectReference{e.VmFolder, e.HostFolder, e.DatastoreFolder, e.NetworkFolder}
 	case *Folder:
 		children = e.ChildEntity

vendor/github.com/vmware/govmomi/simulator/view_manager.go

@@ -153,7 +153,7 @@ func walk(root mo.Reference, f func(child types.ManagedObjectReference)) {
 	var children []types.ManagedObjectReference
 
 	switch e := root.(type) {
-	case *mo.Datacenter:
+	case *Datacenter:
 		children = []types.ManagedObjectReference{e.VmFolder, e.HostFolder, e.DatastoreFolder, e.NetworkFolder}
 	case *Folder:
 		children = e.ChildEntity

vendor/github.com/vmware/govmomi/simulator/virtual_disk_manager.go

@@ -152,6 +152,12 @@ func (m *VirtualDiskManager) MoveVirtualDiskTask(req *types.MoveVirtualDisk_Task
 
 func (m *VirtualDiskManager) CopyVirtualDiskTask(req *types.CopyVirtualDisk_Task) soap.HasFault {
 	task := CreateTask(m, "copyVirtualDisk", func(*Task) (types.AnyType, types.BaseMethodFault) {
+		if req.DestSpec != nil {
+			if Map.IsVPX() {
+				return nil, new(types.NotImplemented)
+			}
+		}
+
 		fm := Map.FileManager()
 
 		dest := m.names(req.DestName)

vendor/github.com/vmware/govmomi/simulator/virtual_machine.go

@@ -513,19 +513,54 @@ func (vm *VirtualMachine) configureDevice(devices object.VirtualDeviceList, spec
 	return nil
 }
 
-func removeDevice(devices object.VirtualDeviceList, device types.BaseVirtualDevice) object.VirtualDeviceList {
-	var result object.VirtualDeviceList
+func (vm *VirtualMachine) removeDevice(devices object.VirtualDeviceList, spec *types.VirtualDeviceConfigSpec) object.VirtualDeviceList {
+	key := spec.Device.GetVirtualDevice().Key
 
 	for i, d := range devices {
-		if d.GetVirtualDevice().Key == device.GetVirtualDevice().Key {
-			result = append(result, devices[i+1:]...)
-			break
+		if d.GetVirtualDevice().Key != key {
+			continue
 		}
 
-		result = append(result, d)
+		devices = append(devices[:i], devices[i+1:]...)
+
+		switch device := spec.Device.(type) {
+		case *types.VirtualDisk:
+			if spec.FileOperation == types.VirtualDeviceConfigSpecFileOperationDestroy {
+				var file string
+
+				switch b := device.Backing.(type) {
+				case types.BaseVirtualDeviceFileBackingInfo:
+					file = b.GetVirtualDeviceFileBackingInfo().FileName
+				}
+
+				if file != "" {
+					dc := Map.getEntityDatacenter(Map.Get(*vm.Parent).(mo.Entity))
+					dm := Map.VirtualDiskManager()
+
+					dm.DeleteVirtualDiskTask(&types.DeleteVirtualDisk_Task{
+						Name:       file,
+						Datacenter: &dc.Self,
+					})
+				}
+			}
+		case types.BaseVirtualEthernetCard:
+			var net types.ManagedObjectReference
+
+			switch b := device.GetVirtualEthernetCard().Backing.(type) {
+			case *types.VirtualEthernetCardNetworkBackingInfo:
+				net = *b.Network
+			case *types.VirtualEthernetCardDistributedVirtualPortBackingInfo:
+				net.Type = "DistributedVirtualPortgroup"
+				net.Value = b.Port.PortgroupKey
+			}
+
+			RemoveReference(&vm.Network, net)
+		}
+
+		break
 	}
 
-	return result
+	return devices
 }
 
 func (vm *VirtualMachine) genVmdkPath() (string, types.BaseMethodFault) {
@@ -559,9 +594,6 @@ func (vm *VirtualMachine) genVmdkPath() (string, types.BaseMethodFault) {
 }
 
 func (vm *VirtualMachine) configureDevices(spec *types.VirtualMachineConfigSpec) types.BaseMethodFault {
-	dc := Map.getEntityDatacenter(Map.Get(*vm.Parent).(mo.Entity))
-	dm := Map.VirtualDiskManager()
-
 	devices := object.VirtualDeviceList(vm.Config.Hardware.Device)
 
 	for i, change := range spec.DeviceChange {
@@ -577,7 +609,7 @@ func (vm *VirtualMachine) configureDevices(spec *types.VirtualMachineConfigSpec)
 				}
 
 				// In this case, the CreateVM() spec included one of the default devices
-				devices = removeDevice(devices, device)
+				devices = vm.removeDevice(devices, dspec)
 			}
 
 			err := vm.configureDevice(devices, dspec)
@@ -586,25 +618,23 @@ func (vm *VirtualMachine) configureDevices(spec *types.VirtualMachineConfigSpec)
 			}
 
 			devices = append(devices, dspec.Device)
-		case types.VirtualDeviceConfigSpecOperationRemove:
-			devices = removeDevice(devices, dspec.Device)
-
-			disk, ok := dspec.Device.(*types.VirtualDisk)
-			if ok && dspec.FileOperation == types.VirtualDeviceConfigSpecFileOperationDestroy {
-				var file string
-
-				switch b := disk.Backing.(type) {
-				case types.BaseVirtualDeviceFileBackingInfo:
-					file = b.GetVirtualDeviceFileBackingInfo().FileName
-				}
+		case types.VirtualDeviceConfigSpecOperationEdit:
+			rspec := *dspec
+			rspec.Device = devices.FindByKey(device.Key)
+			if rspec.Device == nil {
+				return invalid
+			}
+			devices = vm.removeDevice(devices, &rspec)
+			device.DeviceInfo = nil // regenerate summary + label
 
-				if file != "" {
-					dm.DeleteVirtualDiskTask(&types.DeleteVirtualDisk_Task{
-						Name:       file,
-						Datacenter: &dc.Self,
-					})
-				}
+			err := vm.configureDevice(devices, dspec)
+			if err != nil {
+				return err
 			}
+
+			devices = append(devices, dspec.Device)
+		case types.VirtualDeviceConfigSpecOperationRemove:
+			devices = vm.removeDevice(devices, dspec)
 		}
 	}
 
@@ -795,6 +825,30 @@ func (vm *VirtualMachine) CloneVMTask(ctx *Context, req *types.CloneVM_Task) soa
 			},
 		}
 
+		for _, device := range vm.Config.Hardware.Device {
+			var fop types.VirtualDeviceConfigSpecFileOperation
+
+			switch device.(type) {
+			case *types.VirtualDisk:
+				// TODO: consider VirtualMachineCloneSpec.DiskMoveType
+				fop = types.VirtualDeviceConfigSpecFileOperationCreate
+				device = &types.VirtualDisk{
+					VirtualDevice: types.VirtualDevice{
+						Backing: &types.VirtualDiskFlatVer2BackingInfo{
+							DiskMode: string(types.VirtualDiskModePersistent),
+							// Leave FileName empty so CreateVM will just create a new one under VmPathName
+						},
+					},
+				}
+			}
+
+			config.DeviceChange = append(config.DeviceChange, &types.VirtualDeviceConfigSpec{
+				Operation:     types.VirtualDeviceConfigSpecOperationAdd,
+				Device:        device,
+				FileOperation: fop,
+			})
+		}
+
 		res := folder.CreateVMTask(ctx, &types.CreateVM_Task{
 			This:   folder.Self,
 			Config: config,
@@ -809,6 +863,7 @@ func (vm *VirtualMachine) CloneVMTask(ctx *Context, req *types.CloneVM_Task) soa
 
 		ref := ctask.Info.Result.(types.ManagedObjectReference)
 		clone := Map.Get(ref).(*VirtualMachine)
+		clone.configureDevices(&types.VirtualMachineConfigSpec{DeviceChange: req.Spec.Location.DeviceChange})
 
 		ctx.postEvent(&types.VmClonedEvent{
 			VmCloneEvent: types.VmCloneEvent{VmEvent: clone.event()},