Adding vSphere Volume support for vSphere Cloud Provider

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

@@ -19,6 +19,7 @@ package object
 import (
 	"errors"
 	"fmt"
+	"net"
 
 	"github.com/vmware/govmomi/property"
 	"github.com/vmware/govmomi/vim25"
@@ -245,6 +246,77 @@ func (v VirtualMachine) WaitForIP(ctx context.Context) (string, error) {
 	return ip, nil
 }
 
+// WaitForNetIP waits for the VM guest.net property to report an IP address for all VM NICs.
+// Only consider IPv4 addresses if the v4 param is true.
+// Returns a map with MAC address as the key and IP address list as the value.
+func (v VirtualMachine) WaitForNetIP(ctx context.Context, v4 bool) (map[string][]string, error) {
+	macs := make(map[string][]string)
+
+	p := property.DefaultCollector(v.c)
+
+	// Wait for all NICs to have a MacAddress, which may not be generated yet.
+	err := property.Wait(ctx, p, v.Reference(), []string{"config.hardware.device"}, func(pc []types.PropertyChange) bool {
+		for _, c := range pc {
+			if c.Op != types.PropertyChangeOpAssign {
+				continue
+			}
+
+			devices := c.Val.(types.ArrayOfVirtualDevice).VirtualDevice
+			for _, device := range devices {
+				if nic, ok := device.(types.BaseVirtualEthernetCard); ok {
+					mac := nic.GetVirtualEthernetCard().MacAddress
+					if mac == "" {
+						return false
+					}
+					macs[mac] = nil
+				}
+			}
+		}
+
+		return true
+	})
+
+	err = property.Wait(ctx, p, v.Reference(), []string{"guest.net"}, func(pc []types.PropertyChange) bool {
+		for _, c := range pc {
+			if c.Op != types.PropertyChangeOpAssign {
+				continue
+			}
+
+			nics := c.Val.(types.ArrayOfGuestNicInfo).GuestNicInfo
+			for _, nic := range nics {
+				mac := nic.MacAddress
+				if mac == "" || nic.IpConfig == nil {
+					continue
+				}
+
+				for _, ip := range nic.IpConfig.IpAddress {
+					if _, ok := macs[mac]; !ok {
+						continue // Ignore any that don't correspond to a VM device
+					}
+					if v4 && net.ParseIP(ip.IpAddress).To4() == nil {
+						continue // Ignore non IPv4 address
+					}
+					macs[mac] = append(macs[mac], ip.IpAddress)
+				}
+			}
+		}
+
+		for _, ips := range macs {
+			if len(ips) == 0 {
+				return false
+			}
+		}
+
+		return true
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	return macs, nil
+}
+
 // Device returns the VirtualMachine's config.hardware.device property.
 func (v VirtualMachine) Device(ctx context.Context) (VirtualDeviceList, error) {
 	var o mo.VirtualMachine
@@ -336,8 +408,12 @@ func (v VirtualMachine) EditDevice(ctx context.Context, device ...types.BaseVirt
 }
 
 // RemoveDevice removes the given devices on the VirtualMachine
-func (v VirtualMachine) RemoveDevice(ctx context.Context, device ...types.BaseVirtualDevice) error {
-	return v.configureDevice(ctx, types.VirtualDeviceConfigSpecOperationRemove, types.VirtualDeviceConfigSpecFileOperationDestroy, device...)
+func (v VirtualMachine) RemoveDevice(ctx context.Context, keepFiles bool, device ...types.BaseVirtualDevice) error {
+	fop := types.VirtualDeviceConfigSpecFileOperationDestroy
+	if keepFiles {
+		fop = ""
+	}
+	return v.configureDevice(ctx, types.VirtualDeviceConfigSpecOperationRemove, fop, device...)
 }
 
 // BootOptions returns the VirtualMachine's config.bootOptions property.
@@ -400,6 +476,76 @@ func (v VirtualMachine) CreateSnapshot(ctx context.Context, name string, descrip
 	return NewTask(v.c, res.Returnval), nil
 }
 
+// RemoveAllSnapshot removes all snapshots of a virtual machine
+func (v VirtualMachine) RemoveAllSnapshot(ctx context.Context, consolidate *bool) (*Task, error) {
+	req := types.RemoveAllSnapshots_Task{
+		This:        v.Reference(),
+		Consolidate: consolidate,
+	}
+
+	res, err := methods.RemoveAllSnapshots_Task(ctx, v.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(v.c, res.Returnval), nil
+}
+
+// RevertToSnapshot reverts to a named snapshot
+func (v VirtualMachine) RevertToSnapshot(ctx context.Context, name string, suppressPowerOn bool) (*Task, error) {
+	var o mo.VirtualMachine
+
+	err := v.Properties(ctx, v.Reference(), []string{"snapshot"}, &o)
+
+	snapshotTree := o.Snapshot.RootSnapshotList
+	if len(snapshotTree) < 1 {
+		return nil, errors.New("No snapshots for this VM")
+	}
+
+	snapshot, err := traverseSnapshotInTree(snapshotTree, name)
+	if err != nil {
+		return nil, err
+	}
+
+	req := types.RevertToSnapshot_Task{
+		This:            snapshot,
+		SuppressPowerOn: types.NewBool(suppressPowerOn),
+	}
+
+	res, err := methods.RevertToSnapshot_Task(ctx, v.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(v.c, res.Returnval), nil
+}
+
+// traverseSnapshotInTree is a recursive function that will traverse a snapshot tree to find a given snapshot
+func traverseSnapshotInTree(tree []types.VirtualMachineSnapshotTree, name string) (types.ManagedObjectReference, error) {
+	var o types.ManagedObjectReference
+	if tree == nil {
+		return o, errors.New("Snapshot tree is empty")
+	}
+	for _, s := range tree {
+		if s.Name == name {
+			o = s.Snapshot
+			break
+		} else {
+			childTree := s.ChildSnapshotList
+			var err error
+			o, err = traverseSnapshotInTree(childTree, name)
+			if err != nil {
+				return o, err
+			}
+		}
+	}
+	if o.Value == "" {
+		return o, errors.New("Snapshot not found")
+	}
+
+	return o, nil
+}
+
 // IsToolsRunning returns true if VMware Tools is currently running in the guest OS, and false otherwise.
 func (v VirtualMachine) IsToolsRunning(ctx context.Context) (bool, error) {
 	var o mo.VirtualMachine