def setUp(self):
"""
Connects to the host and creates test VM.
"""
self._host = vimhost.Host()
connect.SetSi(self._host._si)
# Create dummy test VM
self._vmname = "ttt.%s" % str(self.__class__.__module__)
if (self._vmname is None):
raise self.failureException(
"Test VM name is not a valid path name. %s" % (self._vmname))
try:
self.destroyTestVM(self._vmname)
envBrowser = invt.GetEnv()
cfgTarget = envBrowser.QueryConfigTarget(None)
if len(cfgTarget.GetDatastore()) == 0:
cm = host.GetHostConfigManager(self._si)
dsm = cm.GetDatastoreSystem()
# todo is this going to work on vmkernel
dsm.CreateLocalDatastore("tttds1", "/var/tmp")
# create a quick dummy test VM with one SCSI disk
self._vm = vm.CreateQuickDummy(self._vmname, 1)
vm1 = vm.VM(self._vm, None, None)
if (not vm1.IsPoweredOff()):
raise self.failureException(
"Newly created test VM should be powered off.")
except Exception as msg:
raise self.failureException(
"Failed to create test VM \"%s\" on host=\"%s\": %s" %
(self._vmname, self._host, msg))
print("INFO: created vm %s " % (self._vmname))
def FindDatastoreName(self):
envBrowser = invt.GetEnv()
cfgTarget = envBrowser.QueryConfigTarget(None)
dsList = cfgTarget.GetDatastore()
if not dsList:
raise Exception("No datastore available to create VM.")
dsName = None
for ds in dsList:
if ds.GetDatastore().GetAccessible():
dsName = ds.GetDatastore().GetName()
break
if dsName == None:
raise Exception("No available datastore")
return dsName
def main():
supportedArgs = [(["h:", "host="], "localhost", "Host name", "host"),
(["u:", "user="******"root", "User name", "user"),
(["p:", "pwd="], "ca$hc0w", "Password", "pwd"),
(["v:", "vmname="], "HotPlugTest",
"Name of the virtual machine", "vmname"),
(["i:", "numiter="], "1", "Number of iterations", "iter")]
supportedToggles = [
(["usage", "help"], False, "Show usage information", "usage"),
(["runall", "r"], True, "Run all the tests", "runall"),
(["nodelete"], False, "Dont delete vm on completion", "nodelete")
]
args = arguments.Arguments(sys.argv, supportedArgs, supportedToggles)
if args.GetKeyValue("usage") == True:
args.Usage()
sys.exit(0)
# Connect
si = SmartConnect(host=args.GetKeyValue("host"),
user=args.GetKeyValue("user"),
pwd=args.GetKeyValue("pwd"))
atexit.register(Disconnect, si)
# Process command line
vmname = args.GetKeyValue("vmname")
numiter = int(args.GetKeyValue("iter"))
runall = args.GetKeyValue("runall")
noDelete = args.GetKeyValue("nodelete")
status = "PASS"
# Find a USB device on the host to passthrough
envBrowser = invt.GetEnv()
cfgTarget = envBrowser.QueryConfigTarget(None)
if len(cfgTarget.usb) < 1:
Log("No USB devices available for passthrough on " +
args.GetKeyValue("host"))
return
device = cfgTarget.usb[0]
for i in range(numiter):
bigClock = StopWatch()
vm1 = None
try:
vmname7 = vmname + "_HwV7"
vmname8 = vmname + "_HwV8"
Log("Cleaning up VMs from previous runs...")
vm.Delete(vmname7, True)
vm.Delete(vmname8, True)
## Positive tests on a hwVersion 7 VM
Log("Creating Hw7 VM..")
vm1 = vm.CreateQuickDummy(vmname7,
vmxVersion="vmx-07",
memory=4,
guest="rhel5Guest")
Log("Add a new USB controller to the VM")
cspec = Vim.Vm.ConfigSpec()
cspec = vmconfig.AddUSBCtlr(cspec)
vm.Reconfigure(vm1, cspec)
DoPlugTests(vm1, device, Vim.Vm.Device.VirtualUSBController, True)
vm.Delete(vm1.name, True)
## Positive tests on a hwVersion 8 VM
Log("Creating Hw8 VM..")
vm1 = vm.CreateQuickDummy(vmname8,
vmxVersion="vmx-08",
memory=4,
guest="rhel5Guest")
Log("Add a new xHCI USB controller to the VM")
cspec = Vim.Vm.ConfigSpec()
cspec = vmconfig.AddUSBXHCICtlr(cspec)
vm.Reconfigure(vm1, cspec)
xhciCtlr = CheckDevice(vm1, Vim.Vm.Device.VirtualUSBXHCIController,
"xHCI controller")
DoPlugTests(vm1, device, Vim.Vm.Device.VirtualUSBXHCIController,
True)
Log("Add a new USB controller to the VM")
cspec = Vim.Vm.ConfigSpec()
cspec = vmconfig.AddUSBCtlr(cspec)
vm.Reconfigure(vm1, cspec)
usbCtlr = CheckDevice(vm1, Vim.Vm.Device.VirtualUSBController,
"USB controller")
DoPlugTests(vm1, device, Vim.Vm.Device.VirtualUSBController, True)
Log("Remove xHCI USB controller from the VM")
cspec = vmconfig.RemoveDeviceFromSpec(Vim.Vm.ConfigSpec(),
xhciCtlr)
vm.Reconfigure(vm1, cspec)
CheckNoDevice(vm1, Vim.Vm.Device.VirtualUSBXHCIController,
"xHCI controller")
Log("Remove USB controller from the VM")
cspec = vmconfig.RemoveDeviceFromSpec(Vim.Vm.ConfigSpec(), usbCtlr)
vm.Reconfigure(vm1, cspec)
CheckNoDevice(vm1, Vim.Vm.Device.VirtualUSBController,
"USB controller")
vm.Delete(vm1.name, True)
Log("Tests completed.")
bigClock.finish("iteration " + str(i))
except Exception as e:
status = "FAIL"
Log("Caught exception : " + str(e))
Log("TEST RUN COMPLETE: " + status)
def main():
supportedArgs = [ (["h:", "host="], "localhost", "Host name", "host"),
(["u:", "user="******"root", "User name", "user"),
(["p:", "pwd="], "ca$hc0w", "Password", "pwd"),
(["v:", "vmname="], "CreateTest", "Name of the virtual machine", "vmname")]
supportedToggles = [(["usage", "help"], False, "Show usage information", "usage")]
args = arguments.Arguments(sys.argv, supportedArgs, supportedToggles)
if args.GetKeyValue("usage") == True:
args.Usage()
sys.exit(0)
# Connect
si = Connect(args.GetKeyValue("host"), 443,
args.GetKeyValue("user"), args.GetKeyValue("pwd"))
atexit.register(Disconnect, si)
# Process command line
vmname = args.GetKeyValue("vmname")
# Cleanup from previous runs.
vm1 = folder.Find(vmname)
if vm1 != None:
vm1.Destroy()
# Create vms
envBrowser = invt.GetEnv()
config = vm.CreateQuickDummySpec(vmname)
cfgOption = envBrowser.QueryConfigOption(None, None)
cfgTarget = envBrowser.QueryConfigTarget(None)
NIC_DIFFERENCE = 7
config = vmconfig.AddNic(config, cfgOption, cfgTarget, unitNumber = NIC_DIFFERENCE + 0)
config = vmconfig.AddNic(config, cfgOption, cfgTarget, unitNumber = NIC_DIFFERENCE + 2)
config = vmconfig.AddNic(config, cfgOption, cfgTarget, unitNumber = NIC_DIFFERENCE + 3)
config = vmconfig.AddNic(config, cfgOption, cfgTarget, unitNumber = NIC_DIFFERENCE + 4)
config = vmconfig.AddNic(config, cfgOption, cfgTarget)
config = vmconfig.AddNic(config, cfgOption, cfgTarget, unitNumber = NIC_DIFFERENCE + 6)
config = vmconfig.AddNic(config, cfgOption, cfgTarget, unitNumber = NIC_DIFFERENCE + 7)
config = vmconfig.AddNic(config, cfgOption, cfgTarget, unitNumber = NIC_DIFFERENCE + 8)
config = vmconfig.AddNic(config, cfgOption, cfgTarget, unitNumber = NIC_DIFFERENCE + 9)
config = vmconfig.AddScsiCtlr(config, cfgOption, cfgTarget, unitNumber = 3)
config = vmconfig.AddScsiDisk(config, cfgOption, cfgTarget, unitNumber = 0)
isofile = "[] /usr/lib/vmware/isoimages/linux.iso"
config = vmconfig.AddCdrom(config, cfgOption, cfgTarget, unitNumber = 0, isoFilePath=isofile)
image = "[] /vmimages/floppies/vmscsi.flp"
config = vmconfig.AddFloppy(config, cfgOption, cfgTarget, unitNumber = 0, type="image", backingName=image)
config = vmconfig.AddFloppy(config, cfgOption, cfgTarget, unitNumber = 1, type="image", backingName=image)
backing = Vim.Vm.Device.VirtualSerialPort.FileBackingInfo()
backing.SetFileName("[]")
config = vmconfig.AddSerial(config, backing)
try:
vmFolder = invt.GetVmFolder()
vimutil.InvokeAndTrack(vmFolder.CreateVm, config, invt.GetResourcePool(), None)
except Exception as e:
raise
vm1 = folder.Find(vmname)
printNicUnitNumbers(vm1, "Test 1: Creating a vm with lots of nics")
cspec = Vim.Vm.ConfigSpec()
cspec = vmconfig.AddNic(cspec, cfgOption, cfgTarget)
task = vm1.Reconfigure(cspec)
WaitForTask(task)
printNicUnitNumbers(vm1, "Test 2: Added a nic")
cspec = Vim.Vm.ConfigSpec()
cspec = vmconfig.AddNic(cspec, cfgOption, cfgTarget)
task = vm1.Reconfigure(cspec)
try:
WaitForTask(task)
except Vim.Fault.TooManyDevices as e:
print("Caught too many devices as expected")
nics = printNicUnitNumbers(vm1, "Test 3: Added too many nics")
cspec = Vim.Vm.ConfigSpec()
uni = nics[4].GetUnitNumber()
cspec = vmconfig.RemoveDeviceFromSpec(cspec, nics[0])
cspec = vmconfig.RemoveDeviceFromSpec(cspec, nics[2])
cspec = vmconfig.RemoveDeviceFromSpec(cspec, nics[4])
cspec = vmconfig.RemoveDeviceFromSpec(cspec, nics[5])
cspec = vmconfig.RemoveDeviceFromSpec(cspec, nics[6])
cspec = vmconfig.AddNic(cspec, cfgOption, cfgTarget)
task = vm1.Reconfigure(cspec)
WaitForTask(task)
printNicUnitNumbers(vm1, "Test 4: Removed a bunch of nics")
cspec = Vim.Vm.ConfigSpec()
cspec = vmconfig.AddNic(cspec, cfgOption, cfgTarget, unitNumber = NIC_DIFFERENCE - 2)
task = vm1.Reconfigure(cspec)
WaitForTask(task)
printNicUnitNumbers(vm1, "Test 5: Added a nic with slot incorrectly specified")
cspec = Vim.Vm.ConfigSpec()
cspec = vmconfig.AddNic(cspec, cfgOption, cfgTarget, unitNumber = uni)
cspec = vmconfig.AddScsiCtlr(cspec, cfgOption, cfgTarget, unitNumber = 4)
cspec = vmconfig.AddScsiDisk(cspec, cfgOption, cfgTarget, unitNumber = 1)
task = vm1.Reconfigure(cspec)
WaitForTask(task)
printNicUnitNumbers(vm1, "Test 6: Added a nic with a slot correctly specified")
cspec = Vim.Vm.ConfigSpec()
cspec = vmconfig.AddNic(cspec, cfgOption, cfgTarget, unitNumber = uni)
task = vm1.Reconfigure(cspec)
try:
WaitForTask(task)
except Vim.Fault.InvalidDeviceSpec as e:
print("Exception caught for adding same nic twice")
printNicUnitNumbers(vm1, "Test 7: Added a nic with s slot specified to be an occupied slot")
vm1.Destroy()
def TestEarlyBinding(vmName, uuid):
"""
Test early binding portgroup behaviour
- Create a VM with a nic connecting to an early binding portgroup and start connected to true
fails
- Create a VM with a nic connecting to an early binding portgroup and start connected to false
succeeds
- Poweron the created VM succeds.
- Reconfigure the VM to connect to an invalid port fails.
- Hot add of device connected to an early binding portgroup fails.
- Reconfigure the VM to connect to an early binding portgroup when device is not connected succeeds
- Reconfigure a powered on VM to connect to an early binding portgroup when device is connected fails.
"""
print("Testing early binding portgroup behaviour")
cleanupvm(vmName)
envBrowser = invt.GetEnv()
config = vm.CreateQuickDummySpec(vmName)
cfgOption = envBrowser.QueryConfigOption(None, None)
# Add a earlybinding dvPortgroup backed nic.
config = vmconfig.AddDvPortBacking(config, "", uuid, 0, cfgOption, "pg2")
try:
vmFolder = invt.GetVmFolder()
vimutil.InvokeAndTrack(vmFolder.CreateVm, config, invt.GetResourcePool(), None)
except Vim.Fault.InvalidDeviceSpec:
print("Caught invalid device backing as expected")
print("Test 1: Creating a device backed by an early binding portgroup with"
"startConnected = true fails as expected: PASS")
config = vm.CreateQuickDummySpec(vmName)
cfgOption = envBrowser.QueryConfigOption(None, None)
# Add an earlybinding dvPortgroup backed nic.
config = vmconfig.AddDvPortBacking(config, "", uuid, 0, cfgOption, "pg2", False)
vmFolder = invt.GetVmFolder()
vimutil.InvokeAndTrack(vmFolder.CreateVm, config, invt.GetResourcePool(), None)
myVm = folder.Find(vmName)
devices = vmconfig.CheckDevice(myVm.GetConfig(), Vim.Vm.Device.VirtualEthernetCard)
if not IsBackingPortNotAllocated(devices):
print(devices)
raise Exception ("Nic has a dvPort assigned to it or nic add failed")
print("Test 2: Creating a device backed by and early binding portgroup with"
"startConnected = false succeeds: PASS")
myVm = folder.Find(vmName)
vm.PowerOn(myVm)
devices = vmconfig.CheckDevice(myVm.GetConfig(), Vim.Vm.Device.VirtualEthernetCard)
if len(devices) < 1:
raise Exception("nic not present")
if not IsBackingPortNotAllocated(devices):
print(devices)
raise Exception ("Nic has a dvPort assigned to it or nic add failed")
print("Test 3: Power on VM succeeds: PASS")
# Reconfigure the VM to connect to an invalid port.
for device in devices:
if isinstance(device.GetBacking(),\
Vim.Vm.Device.VirtualEthernetCard.DistributedVirtualPortBackingInfo):
device.GetBacking().GetPort().SetPortKey("100")
cspec = Vim.Vm.ConfigSpec()
vmconfig.AddDeviceToSpec(cspec, device, Vim.Vm.Device.VirtualDeviceSpec.Operation.edit)
break
try:
task = myVm.Reconfigure(cspec)
WaitForTask(task)
except Vim.Fault.InvalidDeviceSpec:
print("Caught invalid device backing")
print("Test 4: Reconfig a VM to connect to an invalid dvPort fails as expected: PASS")
# Add a device to connect to an early binding portgroup with no dvPort specified.
config = Vim.Vm.ConfigSpec()
config = vmconfig.AddDvPortBacking(config, "", uuid, 0, cfgOption, "pg2")
try:
task = myVm.Reconfigure(config)
WaitForTask(task)
except Vim.Fault.InvalidDeviceSpec:
print("Caught invalid device backing")
print("Test 4: Hot add of a device to connect to an earlybinding portgroup fails as expected: PASS")
# Reconfigure device to connect to an early binding portgroup.
for device in devices:
if isinstance(device.GetBacking(),\
Vim.Vm.Device.VirtualEthernetCard.DistributedVirtualPortBackingInfo):
device.GetBacking().GetPort().SetPortgroupKey("pg2")
device.GetBacking().GetPort().SetPortKey(None)
device.GetBacking().GetPort().SetConnectionCookie(None)
device.GetConnectable().SetConnected(True)
cspec = Vim.Vm.ConfigSpec()
vmconfig.AddDeviceToSpec(cspec, device, Vim.Vm.Device.VirtualDeviceSpec.Operation.edit)
break
try:
task = myVm.Reconfigure(cspec)
WaitForTask(task)
except Vim.Fault.InvalidDeviceSpec:
print("Caught invalid device backing")
print("Test 5: Reconfig a VM to connect to an early binding portgroup fails as expected: PASS")
# Reconfigure a device to disconnected state and connect to an early binding dvPortgroup.
for device in devices:
if isinstance(device.GetBacking(),\
Vim.Vm.Device.VirtualEthernetCard.DistributedVirtualPortBackingInfo):
device.GetBacking().GetPort().SetPortgroupKey("pg2")
device.GetBacking().GetPort().SetPortKey(None)
device.GetBacking().GetPort().SetConnectionCookie(None)
device.GetConnectable().SetConnected(False)
cspec = Vim.Vm.ConfigSpec()
vmconfig.AddDeviceToSpec(cspec, device, Vim.Vm.Device.VirtualDeviceSpec.Operation.edit)
break
task = myVm.Reconfigure(cspec)
WaitForTask(task)
if not IsBackingPortNotAllocated(devices):
print(devices)
raise Exception ("Nic has a dvPort assigned to it or nic add failed")
print("Test6 complete: Reconfig powered on VM to connect to a earlybinding backing with device disconnected: PASS")
print("EarlyBinding tests complete")
def TestLateBinding(vmName, uuid):
"""
Create a VM and connect it to a latebinding portgroup.
Poweron the VM. Validate that a dvPort has not been allocated for the VM.
Reconfig the VM to connect to a ephemeral dvPortgroup validate that the VM
has a valid backing.
Reconfigure the VM to connect back to the latebinding portgroup the reconfig
should fail.
Reconfigure the VM to connect back to the latebinding portgroup with the
device disconnected the connect should succeed.
"""
cleanupvm(vmName)
print("Testing latebinding portgroup behaviour")
envBrowser = invt.GetEnv()
config = vm.CreateQuickDummySpec(vmName)
cfgOption = envBrowser.QueryConfigOption(None, None)
# Add a latebinding dvPortgroup backed nic.
config = vmconfig.AddDvPortBacking(config, "", uuid, 0, cfgOption, "pg4",
type = 'vmxnet3')
try:
vmFolder = invt.GetVmFolder()
vimutil.InvokeAndTrack(vmFolder.CreateVm, config, invt.GetResourcePool(), None)
except Exception as e:
raise
myVm = folder.Find(vmName)
devices = vmconfig.CheckDevice(myVm.GetConfig(), Vim.Vm.Device.VirtualEthernetCard)
if len(devices) < 1:
raise Exception("Failed to add nic")
if not IsBackingPortNotAllocated(devices):
raise Exception("dvPort allocated for a latebinding portgroup")
print("Test1: Create VM with a latebinding portgroup backing: PASS")
# power on the VM.
vm.PowerOn(myVm)
devices = vmconfig.CheckDevice(myVm.GetConfig(), Vim.Vm.Device.VirtualEthernetCard)
if len(devices) < 1:
raise Exception("Nic seems to be missing")
if not IsBackingPortNotAllocated(devices):
raise Exception("dvPort allocated for a latebinding portgroup after powerOn")
print("Test2: Powering on a VM with a latebinding portgroup backing: PASS")
# Reconfigure the VM to connect to an ephemeral backing.
for device in devices:
if isinstance(device.GetBacking(),\
Vim.Vm.Device.VirtualEthernetCard.DistributedVirtualPortBackingInfo):
device.GetBacking().GetPort().SetPortgroupKey("pg3")
device.GetBacking().GetPort().SetPortKey(None)
device.GetBacking().GetPort().SetConnectionCookie(None)
device.GetConnectable().SetConnected(True)
cspec = Vim.Vm.ConfigSpec()
vmconfig.AddDeviceToSpec(cspec, device, Vim.Vm.Device.VirtualDeviceSpec.Operation.edit)
break
task = myVm.Reconfigure(cspec)
WaitForTask(task)
devices = vmconfig.CheckDevice(myVm.GetConfig(), Vim.Vm.Device.VirtualEthernetCard)
if len(devices) < 1:
raise Exception("Failed to edit nic")
if not IsBackingValid(devices):
raise Exception("Invalid backing allocated")
print("Test3: Reconfig poweredon with a ephemeral backing from a latebinding backing allocates a port: PASS")
#Reconfig the VM to connect to a latebinding backing.
for device in devices:
if isinstance(device.GetBacking(),\
Vim.Vm.Device.VirtualEthernetCard.DistributedVirtualPortBackingInfo):
device.GetBacking().GetPort().SetPortgroupKey("pg4")
device.GetBacking().GetPort().SetPortKey(None)
device.GetBacking().GetPort().SetConnectionCookie(None)
cspec = Vim.Vm.ConfigSpec()
vmconfig.AddDeviceToSpec(cspec, device, Vim.Vm.Device.VirtualDeviceSpec.Operation.edit)
break
try:
task = myVm.Reconfigure(cspec)
WaitForTask(task)
except Vim.Fault.InvalidDeviceSpec:
print("Caught invalid device backing")
print("Test4: Reconfig powered on VM to connect to a latebinding backing fails as expected: PASS")
# reconfigure the VM to connect to a latebinding portgroup and disconnect the device.
for device in devices:
if isinstance(device.GetBacking(),\
Vim.Vm.Device.VirtualEthernetCard.DistributedVirtualPortBackingInfo):
device.GetBacking().GetPort().SetPortgroupKey("pg4")
device.GetBacking().GetPort().SetPortKey(None)
device.GetBacking().GetPort().SetConnectionCookie(None)
device.GetConnectable().SetConnected(False)
cspec = Vim.Vm.ConfigSpec()
vmconfig.AddDeviceToSpec(cspec, device, Vim.Vm.Device.VirtualDeviceSpec.Operation.edit)
break
task = myVm.Reconfigure(cspec)
WaitForTask(task)
devices = vmconfig.CheckDevice(myVm.GetConfig(), Vim.Vm.Device.VirtualEthernetCard)
if not IsBackingPortNotAllocated(devices):
print(devices)
raise Exception ("Nic has a dvPort assigned to it or nic add failed")
print("Test5: Reconfig powered on VM to connect to a latebinding backing with device disconnected: PASS")
print("Late binding tests complete")
def TestEphemeral(vmName, uuid):
"""
Test epehemeral portgroups.
- Create a VM configure it to connect to an ephemeral portgroup.
- Power on the VM and validate that backing is valid.
- Hot add a nic to connect to an ephemeral portgroup and validate backing.
- Poweroff and destroy the VM
"""
print("Testing Ephemeral portgroup behaviour")
cleanupvm(vmName)
envBrowser = invt.GetEnv()
config = vm.CreateQuickDummySpec(vmName)
cfgOption = envBrowser.QueryConfigOption(None, None)
# Add a latebinding dvPortgroup backed nic.
config = vmconfig.AddDvPortBacking(config, "", uuid, 0, cfgOption, "pg1")
try:
vmFolder = invt.GetVmFolder()
vimutil.InvokeAndTrack(vmFolder.CreateVm, config, invt.GetResourcePool(), None)
except Exception as e:
raise
myVm = folder.Find(vmName)
devices = vmconfig.CheckDevice(myVm.GetConfig(), Vim.Vm.Device.VirtualEthernetCard)
if len(devices) < 1:
raise Exception("Failed to add nic")
if not IsBackingPortNotAllocated(devices):
print(devices)
raise Exception ("Nic has a dvPort assigned to it or nic add failed")
print("Test 1: Create a vm with an ephemeral portgroup backing: PASS")
vm.PowerOn(myVm)
devices = vmconfig.CheckDevice(myVm.GetConfig(), Vim.Vm.Device.VirtualEthernetCard)
if len(devices) < 1:
raise Exception("Failed to add nic")
if not IsBackingValid(devices):
raise Exception("Invalid backing allocated")
print("Test 2: powerOn VM with a ephemeral backing: PASS")
# Remove and add hot add a nic device to a powered on VM.
vm.PowerOff(myVm)
for device in devices:
if isinstance(device.GetBacking(),\
Vim.Vm.Device.VirtualEthernetCard.DistributedVirtualPortBackingInfo):
cspec = Vim.Vm.ConfigSpec()
vmconfig.AddDeviceToSpec(cspec, device, Vim.Vm.Device.VirtualDeviceSpec.Operation.remove)
break
task = myVm.Reconfigure(cspec)
WaitForTask(task)
devices = vmconfig.CheckDevice(myVm.GetConfig(), Vim.Vm.Device.VirtualEthernetCard)
if IsBackingValid(devices):
print(devices)
raise Exception("Remove of device failed.")
# powerOn the VM and hot add the nic.
vm.PowerOn(myVm)
config = Vim.Vm.ConfigSpec()
config = vmconfig.AddDvPortBacking(config, "", uuid, 0, cfgOption, "pg1")
task = myVm.Reconfigure(config)
WaitForTask(task)
devices = vmconfig.CheckDevice(myVm.GetConfig(), Vim.Vm.Device.VirtualEthernetCard)
if len(devices) < 1:
raise Exception("Failed to add nic")
if not IsBackingValid(devices):
raise Exception("Invalid backing allocated")
print("Test 3: remove and hot add nic to VM with a ephemeral backing: PASS")
# Foundry issue wait for fix and then uncomment.
time.sleep(10)
for device in devices:
if isinstance(device.GetBacking(),\
Vim.Vm.Device.VirtualEthernetCard.DistributedVirtualPortBackingInfo):
device.GetBacking().GetPort().SetPortgroupKey("pg3")
device.GetBacking().GetPort().SetPortKey(None)
device.GetBacking().GetPort().SetConnectionCookie(None)
device.GetConnectable().SetConnected(True)
cspec = Vim.Vm.ConfigSpec()
vmconfig.AddDeviceToSpec(cspec, device, Vim.Vm.Device.VirtualDeviceSpec.Operation.edit)
break
#task = myVm.Reconfigure(cspec)
#WaitForTask(task)
#devices = vmconfig.CheckDevice(myVm.GetConfig(), Vim.Vm.Device.VirtualEthernetCard)
#if len(devices) < 1:
# raise Exception("Failed to edit nic")
#if not IsBackingValid(devices):
# raise Exception("Invalid backing allocated")
#print("Test4: Reconfig poweredon with a ephemeral backing: PASS")
print("Ephemeral portgoup tests complete")
def TestSimulatedVcClone(vmName, uuid):
"""
Test the code paths that VC excercises during cloning a VM with
a dvs backing.
"""
print("Testing hostd code corresponding to clone")
cleanupvm(vmName)
envBrowser = invt.GetEnv()
config = vm.CreateQuickDummySpec(vmName)
cfgOption = envBrowser.QueryConfigOption(None, None)
# Add a nic backed by a dvs portgroup pair.
config = vmconfig.AddDvPortBacking(config, "", uuid, 0, cfgOption, "invalidPg")
try:
vmFolder = invt.GetVmFolder()
vimutil.InvokeAndTrack(vmFolder.CreateVm, config, invt.GetResourcePool(), None)
except Vim.Fault.InvalidDeviceSpec:
print("Test1: Caught invalid device spec as expected")
else:
raise "Test1: Create vm with invalid dvPortgroup backing didn't fail as expected"
print("Test1: Create vm with invalid dvPortgroup backing failed as expected: PASS")
config = vm.CreateQuickDummySpec(vmName)
config = vmconfig.AddDvPortBacking(config, "", uuid, 0, cfgOption, "pg1")
try:
vmFolder = invt.GetVmFolder()
vimutil.InvokeAndTrack(vmFolder.CreateVm, config, invt.GetResourcePool(), None)
except Exception:
print("Failed to clone a VM to connect to a dvPortgroup")
raise
print("Test2: Create vm with valid dvPort backing: PASS")
# Create a VM only specifying the dvs uuid in its backing.
vm1 = folder.Find(vmName)
vm.Destroy(vm1)
config = vm.CreateQuickDummySpec(vmName)
config = vmconfig.AddDvPortBacking(config, "", uuid, None, cfgOption, "")
try:
vmFolder = invt.GetVmFolder()
vimutil.InvokeAndTrack(vmFolder.CreateVm, config, invt.GetResourcePool(), None)
except Exception:
print("Failed to clone a VM to connected to a standalone port")
raise
myVm = folder.Find(vmName)
devices = vmconfig.CheckDevice(myVm.GetConfig(), Vim.Vm.Device.VirtualEthernetCard)
if not IsBackingPortNotAllocated(devices):
print(devices)
raise Exception ("Nic has a dvPort assigned to it or nic add failed")
print("Test3: Create vm with valid dvs uuid specified in the dvsbacking (standalone): PASS")
# Reconfigure a VM only specifying a dvs uuid in its backing
for device in devices:
if isinstance(device.GetBacking(),\
Vim.Vm.Device.VirtualEthernetCard.DistributedVirtualPortBackingInfo):
cspec = Vim.Vm.ConfigSpec()
device.GetConnectable().SetConnected(True)
device.SetUnitNumber(9)
vmconfig.AddDeviceToSpec(cspec, device, Vim.Vm.Device.VirtualDeviceSpec.Operation.add)
break
try:
task = myVm.Reconfigure(cspec)
WaitForTask(task)
except Exception:
print("Test4: failed to add a device with only dvs backing specified")
print("Test4: Reconfig VM specifying only the dvsUuid in backing: PASS")
print("Testing simulate vc clone done")