def TestSataCtlrReconfig(vm1):
"""
Test add and remove for SATA controller
"""
Log("Adding SATA controller to VM")
cspec = Vim.Vm.ConfigSpec()
cspec = vmconfig.AddSataCtlr(cspec, cfgInfo = vm1.config)
vm.Reconfigure(vm1, cspec)
# Check for controller presence in VM's config
ctlrs = vmconfig.CheckDevice(vm1.config, Vim.Vm.Device.VirtualAHCIController)
if len(ctlrs) != 1:
raise Exception("Failed to find added SATA controller :" + str(len(ctlrs)))
Log("Powering on VM " + vm1.config.GetName())
vm.PowerOn(vm1)
Log("Hot-add SATA controller to VM")
cspec = Vim.Vm.ConfigSpec()
cspec = vmconfig.AddSataCtlr(cspec, cfgInfo = vm1.config)
vm.Reconfigure(vm1, cspec)
ctlrs = vmconfig.CheckDevice(vm1.config, Vim.Vm.Device.VirtualAHCIController)
if len(ctlrs) != 2:
raise Exception("Failed to find added SATA controller :" + str(len(ctlrs)))
vm.PowerOff(vm1)
# Remove SATA controller from VM
Log("Removing SATA controllers from VM")
cspec = Vim.Vm.ConfigSpec()
vmconfig.AddDeviceToSpec(cspec, ctlrs[0], Vim.Vm.Device.VirtualDeviceSpec.Operation.remove)
vmconfig.AddDeviceToSpec(cspec, ctlrs[1], Vim.Vm.Device.VirtualDeviceSpec.Operation.remove)
vm.Reconfigure(vm1, cspec)
def TestVWDTReplaceKey(vm1, key):
Log("Replacing vWDT with new key=%s" % key)
cspec = vim.vm.ConfigSpec()
vmconfig.AddDeviceToSpec(cspec, CreateVWDT(WATCHDOGTIMER_DEV_KEY),
vim.vm.device.VirtualDeviceSpec.Operation.remove)
vmconfig.AddDeviceToSpec(cspec, CreateVWDT(key),
vim.vm.device.VirtualDeviceSpec.Operation.add)
vm.Reconfigure(vm1, cspec)
CheckWDTPresent(vm1)
def TestVTPMMove(vm1, key):
Log("Replacing vTPM device with new key=%s" % key)
cspec = vim.vm.ConfigSpec()
vmconfig.AddDeviceToSpec(cspec, CreateVTPM(TPM_DEV_KEY),
vim.vm.device.VirtualDeviceSpec.Operation.remove)
vmconfig.AddDeviceToSpec(cspec, CreateVTPM(key),
vim.vm.device.VirtualDeviceSpec.Operation.add)
vm.Reconfigure(vm1, cspec)
CheckTPMPresent(vm1)
def TestVQATMove(vm1, key):
Log("Replacing VQAT device with new key=%s" % key)
cspec = vim.vm.ConfigSpec()
vmconfig.AddDeviceToSpec(cspec, CreateVQAT(QAT_DEV_KEY),
vim.vm.device.VirtualDeviceSpec.Operation.remove)
vmconfig.AddDeviceToSpec(cspec, CreateVQAT(key),
vim.vm.device.VirtualDeviceSpec.Operation.add)
vm.Reconfigure(vm1, cspec)
CheckQATPresent(vm1, MAX_QAT_DEV)
def EditFloppySetAndUnsetAutodetect(vm1):
# Test 9. Edit a floppy device and toggle the device autodetect setting
cspec = Vim.Vm.ConfigSpec()
cspec = vmconfig.AddFloppy(cspec, autodetect=True)
task = vm1.Reconfigure(cspec)
WaitForTask(task)
devices = vmconfig.CheckDevice(vm1.GetConfig(),
Vim.Vm.Device.VirtualFloppy,
{"backing.useAutoDetect": True})
if len(devices) != 1:
raise "Failed to find added floppy"
cspec = Vim.Vm.ConfigSpec()
dev = devices[0]
backing = dev.GetBacking()
backing.SetUseAutoDetect(False)
backing.SetDeviceName(
vmconfig.GetDeviceName(None,
vmconfig.GetCfgTarget(None).GetFloppy))
dev.SetBacking(backing)
vmconfig.AddDeviceToSpec(cspec, dev,
Vim.Vm.Device.VirtualDeviceSpec.Operation.edit)
task = vm1.Reconfigure(cspec)
WaitForTask(task)
devices = vmconfig.CheckDevice(vm1.GetConfig(),
Vim.Vm.Device.VirtualFloppy,
{"backing.useAutoDetect": False})
if len(devices) != 1:
raise "Failed to find added floppy"
cspec = Vim.Vm.ConfigSpec()
dev = devices[0]
backing = dev.GetBacking()
backing.SetUseAutoDetect(True)
dev.SetBacking(backing)
vmconfig.AddDeviceToSpec(cspec, dev,
Vim.Vm.Device.VirtualDeviceSpec.Operation.edit)
task = vm1.Reconfigure(cspec)
WaitForTask(task)
devices = vmconfig.CheckDevice(vm1.GetConfig(),
Vim.Vm.Device.VirtualFloppy,
{"backing.useAutoDetect": True})
if len(devices) != 1:
raise "Failed to find added floppy"
print("Toggling floppy autodetect works!")
def EditExistingEnsoniqToSetAndUnsetAutodetect(vm1):
# Test 9. Edit an ensoniq device and toggle the device autodetect setting
cspec = Vim.Vm.ConfigSpec()
cspec = vmconfig.AddSoundCard(cspec, autodetect=True, type="ensoniq")
task = vm1.Reconfigure(cspec)
WaitForTask(task)
devices = vmconfig.CheckDevice(vm1.GetConfig(),
Vim.Vm.Device.VirtualEnsoniq1371,
{"backing.useAutoDetect": True})
if len(devices) != 1:
raise "Failed to find added sound card"
cspec = Vim.Vm.ConfigSpec()
dev = devices[0]
backing = dev.GetBacking()
backing.SetUseAutoDetect(False)
backing.SetDeviceName(
vmconfig.GetDeviceName(None,
vmconfig.GetCfgTarget(None).GetSound))
dev.SetBacking(backing)
vmconfig.AddDeviceToSpec(cspec, dev,
Vim.Vm.Device.VirtualDeviceSpec.Operation.edit)
task = vm1.Reconfigure(cspec)
WaitForTask(task)
devices = vmconfig.CheckDevice(vm1.GetConfig(),
Vim.Vm.Device.VirtualEnsoniq1371,
{"backing.useAutoDetect": False})
if len(devices) != 1:
raise "Failed to find added sound card"
cspec = Vim.Vm.ConfigSpec()
dev = devices[0]
backing = dev.GetBacking()
backing.SetUseAutoDetect(True)
dev.SetBacking(backing)
vmconfig.AddDeviceToSpec(cspec, dev,
Vim.Vm.Device.VirtualDeviceSpec.Operation.edit)
task = vm1.Reconfigure(cspec)
WaitForTask(task)
devices = vmconfig.CheckDevice(vm1.GetConfig(),
Vim.Vm.Device.VirtualEnsoniq1371,
{"backing.useAutoDetect": True})
if len(devices) != 1:
raise "Failed to find added sound card"
print("Toggling soundcard autodetect works!")
def TestWithSnapshot(vm1):
""" Verify that it is not possible to extend delta disk by changing
capacityInBytes.
"""
cspec = Vim.Vm.ConfigSpec()
vmconfig.AddScsiDisk(cspec, cfgInfo = vm1.config)
vm.Reconfigure(vm1, cspec)
devices = vmconfig.CheckDevice(vm1.config, Vim.Vm.Device.VirtualDisk)
if len(devices) != 1:
raise Exception("Failed to find new disk!")
# attempt to extend a disk with a parent
Log("Creating a snapshot on the VM for negative disk extend test.")
vm.CreateSnapshot(vm1, "dummy snapshot", "dummy desc", False, False)
Log("Attempting to extend disk size of delta disk.")
disk = vmconfig.CheckDevice(vm1.config, Vim.Vm.Device.VirtualDisk)[0]
cspec = Vim.Vm.ConfigSpec()
disk.capacityInBytes = disk.capacityInBytes + 1024
vmconfig.AddDeviceToSpec(cspec, disk, Vim.Vm.Device.VirtualDeviceSpec.Operation.edit)
task = vm1.Reconfigure(cspec)
try:
WaitForTask(task)
except Exception as e:
Log("Hit an exception extending delta disk as expected" + str(e))
else:
raise Exception("Error: Extending delta disk was allowed!")
Log("Removing all snapshots on the VM.")
vm.RemoveAllSnapshots(vm1)
def TestVQATDeviceType(vm1):
"""
Test adding QAT devices with various deviceTypes
"""
CheckQATNotPresent(vm1)
Log("Adding VQAT with deviceType")
cspec = vim.vm.ConfigSpec()
# Add VQAT devices with a variety of deviceTypes to VM.
deviceTypes = ["C62XVF", "C62XVF-crypto", "C62XVF-compression"]
for deviceType in deviceTypes:
AddVQAT(cspec, deviceType=deviceType)
vm.Reconfigure(vm1, cspec)
# Iterate through qatDevices and build both a remove spec
# and a list of the QAT backing deviceTypes seen.
qatDevices = vmconfig.CheckDevice(vm1.config, vim.vm.device.VirtualQAT)
backingDeviceTypes = []
cspec = vim.vm.ConfigSpec()
for qat in qatDevices:
deviceType = qat.backing.deviceType
if deviceType is None:
raise Exception("qat device with unset deviceType")
backingDeviceTypes.append(deviceType)
vmconfig.AddDeviceToSpec(
cspec, qat, vim.vm.device.VirtualDeviceSpec.Operation.remove)
# Should see all of the configured deviceTypes in the returned
# backing deviceTypes.
if sorted(deviceTypes) != sorted(backingDeviceTypes):
raise Exception("Invalid device types after reconfiguration: " +
",".join(backingDeviceTypes))
# Remove all QAT device and verify no QAT devices remain on VM.
vm.Reconfigure(vm1, cspec)
CheckQATNotPresent(vm1)
def TestEK(vm1, val, fault, expected=None):
tpm = CreateVTPM(TPM_DEV_KEY)
if val is not None:
val = [VmomiSupport.binary(v) for v in val]
tpm.endorsementKeyCertificate = val
Log("Trying to set EK certificate to '%s'" % val)
cspec = vim.vm.ConfigSpec()
vmconfig.AddDeviceToSpec(cspec, tpm,
vim.vm.device.VirtualDeviceSpec.Operation.edit)
if fault is None:
vm.Reconfigure(vm1, cspec)
else:
try:
vm.Reconfigure(vm1, cspec)
raise Exception("Reconfigure did not fail for %s" % cspec)
except vim.fault.GenericVmConfigFault as e:
ok = False
for m in e.faultMessage:
if m.key == fault:
ok = True
if not ok:
raise
except vmodl.fault.InvalidArgument as e:
if e.invalidProperty != fault:
raise
tpm = CheckTPMPresent(vm1)
if expected is None:
expected = val
ekc = tpm.endorsementKeyCertificate
if len(expected) != len(ekc):
raise Exception("After setting EK to '%s', it is '%s'" % (val, ekc))
for l, r in zip(expected, ekc):
if l != r:
raise Exception("After setting EK to '%s', it is '%s'" %
(val, ekc))
def testKeyOnlyRemove(si, vmxVersion, ds):
"""This test verifies that it is possible to remove devices by passing
a VirtualDevice object with only key specified.
This is a legacy behavior present in Foundry, supported only for compatibility reasons.
It is not recommended to use this functionality in any products."""
suffix = ''.join(
random.choice(string.letters + string.digits) for i in xrange(8))
vm1Name = '-'.join(['KeyOnlyRemove', suffix])
print('Creating %s VM on %s' % (vm1Name, ds))
task.WaitForTasks(
[vm1.Destroy() for vm1 in folder.GetVmAll() if vm1.name == vm1Name])
vm1 = vm.CreateQuickDummy(vm1Name,
numScsiDisks=1,
numIdeDisks=1,
diskSizeInMB=1,
nic=1,
cdrom=1,
datastoreName=ds,
vmxVersion=vmxVersion)
print('Testing device removal via VirtualDevice with key set on VM %s' %
vm1Name)
#gather all the devices we want to remove
devices = [
vim.vm.device.VirtualDevice(key=d.key)
for d in vm1.config.hardware.device
if isinstance(d, (vim.vm.device.VirtualEthernetCard,
vim.vm.device.VirtualDisk,
vim.vm.device.VirtualCdrom))
]
#prepare a config spec containing VirtualDevice "abstract" objects with keys we want
#to remove
cspec = vim.vm.ConfigSpec()
for device in devices:
vmconfig.AddDeviceToSpec(
cspec, device, vim.vm.device.VirtualDeviceSpec.Operation.remove)
#reconfigure the VM
task.WaitForTask(vm1.Reconfigure(cspec))
#verify that the devices are removed
devices = [
vim.vm.device.VirtualDevice(key=d.key)
for d in vm1.config.hardware.device
if isinstance(d, (vim.vm.device.VirtualEthernetCard,
vim.vm.device.VirtualDisk,
vim.vm.device.VirtualCdrom))
]
if len(devices) != 0:
raise Exception("Not all devices were deleted!")
#destroy the vm
print('Done testing, destroying %s VM' % vm1Name)
vm.Destroy(vm1)
def TestNoVTPMRemoveDev(vm1, dev, fault=vim.fault.InvalidDeviceSpec):
cspec = vim.vm.ConfigSpec()
vmconfig.AddDeviceToSpec(cspec, dev,
vim.vm.device.VirtualDeviceSpec.Operation.remove)
try:
vm.Reconfigure(vm1, cspec)
raise Exception("Reconfigure for TPM %s did not raise exception" %
cspec)
except fault as e:
pass
def TestEditDisk(vm1):
""" Test reconfigures of capacityInBytes and capacityInKB when both are set
and differ.
"""
Log("Adding a new disk.")
cspec = Vim.Vm.ConfigSpec()
vmconfig.AddScsiDisk(cspec, cfgInfo = vm1.config)
vm.Reconfigure(vm1, cspec)
devices = vmconfig.CheckDevice(vm1.config, Vim.Vm.Device.VirtualDisk)
if len(devices) != 1:
raise Exception("Failed to find new disk!")
disk = devices[0]
Log("Increase disk size by 4MB setting capacityInBytes")
cspec = Vim.Vm.ConfigSpec()
newCapacity = disk.capacityInBytes + 4 * 1024 * 1024 + SECTOR_SIZE
newCapacityKB = (newCapacity - SECTOR_SIZE) / 1024
disk.capacityInBytes = newCapacity
vmconfig.AddDeviceToSpec(cspec, disk, Vim.Vm.Device.VirtualDeviceSpec.Operation.edit)
vm.Reconfigure(vm1, cspec)
devices = vmconfig.CheckDevice(vm1.config, Vim.Vm.Device.VirtualDisk,
{"capacityInBytes": newCapacity,
"capacityInKB": newCapacityKB})
if len(devices) != 1:
raise Exception("Failed to find the disk with updated capacity: " + str(len(devices)))
Log("Atempt to increase only capacityInKB.")
newCapacityKB = newCapacityKB + 4*1024
disk.capacityInKB = newCapacityKB
cspec = Vim.Vm.ConfigSpec()
vmconfig.AddDeviceToSpec(cspec, disk, Vim.Vm.Device.VirtualDeviceSpec.Operation.edit)
vm.Reconfigure(vm1, cspec)
devices = vmconfig.CheckDevice(vm1.config, Vim.Vm.Device.VirtualDisk,
{"capacityInKB": newCapacityKB})
if len(devices) != 1:
raise Exception("Failed to find the disk with updated capacity: " + str(len(devices)))
Log("Removing virtual disk from VM")
cspec = Vim.Vm.ConfigSpec()
fileOp = Vim.Vm.Device.VirtualDeviceSpec.FileOperation.destroy
vmconfig.RemoveDeviceFromSpec(cspec, devices[0], fileOp)
vm.Reconfigure(vm1, cspec)
def TestVideoCard3D(vm1):
dev = CheckVideoCard3DSupport(vm1, False)
supports3D = False
cspec = Vim.Vm.ConfigSpec()
dev.SetEnable3DSupport(True)
vmconfig.AddDeviceToSpec(cspec, dev,
Vim.Vm.Device.VirtualDeviceSpec.Operation.edit)
task = vm1.Reconfigure(cspec)
WaitForTask(task)
CheckVideoCard3DSupport(vm1, True)
Log("Verified toggling 3d support for video card")
def TestReconfigCdromBacking(vm1):
cdrom = vmconfig.CheckDevice(vm1.config, Vim.Vm.Device.VirtualCdrom)[0]
cspec = Vim.Vm.ConfigSpec()
backing = Vim.Vm.Device.VirtualCdrom.IsoBackingInfo(fileName="[]")
cdrom.backing = backing
vmconfig.AddDeviceToSpec(cspec, cdrom, Vim.Vm.Device.VirtualDeviceSpec.Operation.edit)
vm.Reconfigure(vm1, cspec)
devices = vmconfig.CheckDevice(vm1.config, Vim.Vm.Device.VirtualCdrom,
{"backing.fileName": "[]"})
if len(devices) != 1:
raise Exception("Failed to find edited cdrom!")
def editDisk(options, machine, diskDev, shared):
cspec = Vim.Vm.ConfigSpec()
if shared:
diskDev.backing.sharing = VirtualDisk.Sharing.sharingMultiWriter
else:
diskDev.backing.sharing = VirtualDisk.Sharing.sharingNone
vmconfig.AddDeviceToSpec(cspec, diskDev, VirtualDeviceSpec.Operation.edit)
vm.Reconfigure(machine, cspec)
Log("Reconfigure(%s) - edit disk" % machine.name)
def TestExtendDisk(vm1):
disk = vmconfig.CheckDevice(vm1.config, Vim.Vm.Device.VirtualDisk)[0]
# increase disk size
Log("Increase disk size by 8 MB")
cspec = Vim.Vm.ConfigSpec()
newCapacity = disk.capacityInKB + 8192
disk.capacityInKB = newCapacity
vmconfig.AddDeviceToSpec(cspec, disk, Vim.Vm.Device.VirtualDeviceSpec.Operation.edit)
vm.Reconfigure(vm1, cspec)
devices = vmconfig.CheckDevice(vm1.config, Vim.Vm.Device.VirtualDisk,
{"capacityInKB": newCapacity})
if len(devices) != 1:
raise Exception("Failed to find the disk with updated capacity")
def TestPosVMCIDevice(vm1):
Log("Testing if VMCI device is present by default in the VM")
dev = CheckVMCIDeviceStatus(vm1, False)
Log("Toggling unrestricted communication for VMCI...")
cspec = Vim.Vm.ConfigSpec()
dev.SetAllowUnrestrictedCommunication(True)
vmconfig.AddDeviceToSpec(cspec, dev,
Vim.Vm.Device.VirtualDeviceSpec.Operation.edit)
task = vm1.Reconfigure(cspec)
WaitForTask(task)
CheckVMCIDeviceStatus(vm1, True)
Log("Verified communication settings for VMCI")
def TestMoveDevice(vm1, device, ctlr):
cspec = Vim.Vm.ConfigSpec()
newCtlrKey = ctlr.key
cfgOption = vmconfig.GetCfgOption(None)
unitNumber = vmconfig.GetFreeSlot(cspec, vm1.config, cfgOption, ctlr)
device.unitNumber = unitNumber;
device.controllerKey = newCtlrKey
vmconfig.AddDeviceToSpec(cspec, device, Vim.Vm.Device.VirtualDeviceSpec.Operation.edit)
vm.Reconfigure(vm1, cspec)
devices = vmconfig.CheckDevice(vm1.config, type(device),
{"controllerKey": newCtlrKey})
if len(devices) != 1:
raise Exception("Failed to move device!")
def TestReconfigDeltaDisk(vm1):
# attempt to extend a disk with a parent
Log("Creating a snapshot on the VM for negative disk extend test")
vm.CreateSnapshot(vm1, "dummy snapshot", "dummy desc", False, False)
Log("Attempting to extend disk size of delta disk")
disk = vmconfig.CheckDevice(vm1.config, Vim.Vm.Device.VirtualDisk)[0]
cspec = Vim.Vm.ConfigSpec()
disk.capacityInKB = disk.capacityInKB + 4096
vmconfig.AddDeviceToSpec(cspec, disk, Vim.Vm.Device.VirtualDeviceSpec.Operation.edit)
task = vm1.Reconfigure(cspec)
try:
WaitForTask(task)
except Exception as e:
Log("Hit an exception extending delta disk as expected" + str(e))
else:
raise Exception("Error: Extending delta disk was allowed!")
Log("Removing all snapshots on the VM")
vm.RemoveAllSnapshots(vm1)
def AddEditSerialSymlinkFile(vm1, pathBase, serialDev=None):
serialFilePath = pathBase + '-serial/serial.log'
serialFullPath = ResolveDsPath(vm1, serialFilePath)
serialSymlink = ResolveDsPath(vm1, pathBase + '/serial.log')
os.symlink(serialFullPath, serialSymlink)
cspec = Vim.Vm.ConfigSpec()
if serialDev:
backing = Vim.Vm.Device.VirtualSerialPort.FileBackingInfo()
backing.SetFileName(serialFilePath)
serialDev.SetBacking(backing)
vmconfig.AddDeviceToSpec(
cspec, serialDev, Vim.Vm.Device.VirtualDeviceSpec.Operation.edit)
else:
vmconfig.AddFileBackedSerial(cspec, serialFilePath)
vm.Reconfigure(vm1, cspec)
devices = vmconfig.CheckDevice(vm1.GetConfig(),
Vim.Vm.Device.VirtualSerialPort)
if len(devices) != 1:
raise Exception('Failed to add serial port')
return devices[0], serialFullPath, serialSymlink
def addRdmDisk(options, machine, shared):
cspec = Vim.Vm.ConfigSpec()
diskDev = VirtualDisk()
diskDev.key = vmconfig.GetFreeKey(cspec)
diskDev.controllerKey = 1000
diskDev.capacityInKB = long(1024)
diskDev.unitNumber = -1
diskBacking = VirtualDisk.RawDiskMappingVer1BackingInfo()
diskBacking.fileName = ""
diskBacking.diskMode = VirtualDiskOption.DiskMode.persistent
diskBacking.deviceName = options.disk
if shared:
diskBacking.sharing = VirtualDisk.Sharing.sharingMultiWriter
diskBacking.compatibilityMode = VirtualDiskOption.CompatibilityMode.physicalMode
diskDev.backing = diskBacking
vmconfig.AddDeviceToSpec(cspec, diskDev, VirtualDeviceSpec.Operation.add,
VirtualDeviceSpec.FileOperation.create)
vm.Reconfigure(machine, cspec)
Log("Reconfigure(%s) - add RDM disk" % machine.name)
def addFlatDisk(options, machine, shared):
cspec = Vim.Vm.ConfigSpec()
diskDev = VirtualDisk()
diskDev.key = vmconfig.GetFreeKey(cspec)
diskDev.controllerKey = 1000
diskDev.capacityInKB = long(1024)
diskDev.unitNumber = -1
diskBacking = VirtualDisk.FlatVer2BackingInfo()
diskBacking.fileName = "[" + options.datastore + "]"
diskBacking.diskMode = VirtualDiskOption.DiskMode.persistent
if shared:
diskBacking.sharing = VirtualDisk.Sharing.sharingMultiWriter
diskBacking.thinProvisioned = False
diskBacking.eagerlyScrub = True
diskDev.backing = diskBacking
vmconfig.AddDeviceToSpec(cspec, diskDev, VirtualDeviceSpec.Operation.add,
VirtualDeviceSpec.FileOperation.create)
vm.Reconfigure(machine, cspec)
Log("Reconfigure(%s) -> add flat disk" % machine.name)
def CreateTestVm(si, dsName):
# Create a VM for testing
vmName = "TestStatsVm1"
# Destroy old VMs
for vm1 in si.content.rootFolder.childEntity[0].vmFolder.childEntity:
if vm1.name == vmName:
if vm1.runtime.powerState != vim.VirtualMachine.PowerState.poweredOff:
vm.PowerOff(vm1)
vm1.Destroy()
spec = vm.CreateQuickDummySpec(vmName,
nic=1,
memory=32,
datastoreName=dsName)
resPool = invt.GetResourcePool(si=si)
vmFolder = invt.GetVmFolder(si=si)
t = vmFolder.CreateVm(spec, pool=resPool)
WaitForTask(t)
vm1 = t.info.result
Log("Created VM %s on %s" % (vm1.name, resPool.owner.host[0].name))
devices = vmconfig.CheckDevice(vm1.GetConfig(),
vim.vm.Device.VirtualEthernetCard)
if len(devices) < 1:
raise Exception("Failed to find nic")
# Reconfigure to add network
cspec = vim.vm.ConfigSpec()
devices[0].GetConnectable().SetStartConnected(True)
devices[0].GetConnectable().SetConnected(True)
vmconfig.AddDeviceToSpec(cspec, devices[0],
vim.vm.Device.VirtualDeviceSpec.Operation.edit)
vm.Reconfigure(vm1, cspec)
vm.PowerOn(vm1)
return vm1
def AddVWDT(cspec, key=None, runOnBoot=None):
if key is None:
key = vmconfig.GetFreeKey(cspec)
wdt = CreateVWDT(key, runOnBoot)
vmconfig.AddDeviceToSpec(cspec, wdt,
vim.vm.device.VirtualDeviceSpec.Operation.add)
def AddVQAT(cspec, key=None, deviceType="C62XVF"):
if key is None:
key = vmconfig.GetFreeKey(cspec)
qat = CreateVQAT(key, deviceType)
vmconfig.AddDeviceToSpec(cspec, qat,
vim.vm.device.VirtualDeviceSpec.Operation.add)
def main():
supportedArgs = [ (["h:", "host="], "localhost", "Host name", "host"),
(["u:", "user="******"root", "User name", "user"),
(["p:", "pwd="], "ca$hc0w", "Password", "pwd"),
(["v:", "vmname="], "Hw7ReconfigTest", "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 = Connect(host=args.GetKeyValue("host"),
user=args.GetKeyValue("user"),
pwd=args.GetKeyValue("pwd"),
version="vim.version.version9")
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"
for i in range(numiter):
bigClock = StopWatch()
vm1 = None
try:
## Cleanup old VMs
vm1 = folder.Find(vmname)
if vm1 != None:
vm1.Destroy()
Log("Creating virtual machine")
vm1 = vm.CreateQuickDummy(vmname, 1, diskSizeInMB = 4096)
devices = vmconfig.CheckDevice(vm1.GetConfig(), Vim.Vm.Device.VirtualDisk)
if len(devices) < 1:
raise Exception("Failed to find added disk!")
cspec = Vim.Vm.ConfigSpec()
for i in range(0, len(devices)) :
disk = devices[i]
backing = disk.GetBacking()
backing.SetEagerlyScrub(True)
disk.SetBacking(backing)
vmconfig.AddDeviceToSpec(cspec, disk, Vim.Vm.Device.VirtualDeviceSpec.Operation.edit)
Log("Scrubbing existing disks of the VM")
task = vm1.Reconfigure(cspec)
WaitForTask(task)
Log("Add a new scrubbed disk to the VM")
cspec = Vim.Vm.ConfigSpec()
cspec = vmconfig.AddScsiCtlr(cspec)
vmconfig.AddScsiDisk(cspec, capacity = 128 * 1024, scrub = True)
#task = vm1.Reconfigure(cspec)
#WaitForTask(task)
except Exception as e:
status = "FAIL"
Log("Caught exception : " + str(e))
Log("TEST RUN COMPLETE: " + status)
def RemoveDev(vm1, dev):
cspec = vim.vm.ConfigSpec()
vmconfig.AddDeviceToSpec(cspec, dev,
vim.vm.device.VirtualDeviceSpec.Operation.remove)
vm.Reconfigure(vm1, cspec)
def TestVTPMRemoveDev(vm1, dev):
cspec = vim.vm.ConfigSpec()
vmconfig.AddDeviceToSpec(cspec, dev,
vim.vm.device.VirtualDeviceSpec.Operation.remove)
vm.Reconfigure(vm1, cspec)
CheckTPMNotPresent(vm1)
def main():
supportedArgs = [ (["h:", "host="], "localhost", "Host name", "host"),
(["u:", "user="******"root", "User name", "user"),
(["p:", "pwd="], "ca$hc0w", "Password", "pwd"),
(["d:", "disk="], "/vmfs/devices/", "Disk", "disk"),
(["s:", "ds="], "storage1", "Datastore 1", "ds"),
(["f:", "file="], "[datastore1] rdm/rdm.vmdk", "Virtual Disk", "file"),
(["v:", "vmname="], "RdmVM", "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")
disk = args.GetKeyValue("disk")
ds = args.GetKeyValue("ds")
rdmDiskFile = args.GetKeyValue("file")
status = "PASS"
for i in range(numiter):
bigClock = StopWatch()
vm1 = None
try:
## Cleanup old VMs
vm1 = folder.Find(vmname)
if vm1 != None:
vm1.Destroy()
Log("Creating VM: " + str(vmname))
## Add scsi disk
Log("Adding a new rdm disk to VM: " + str(vmname))
cspec = Vim.Vm.ConfigSpec()
cspec = vmconfig.CreateDefaultSpec(name = vmname, datastoreName = ds)
cspec = vmconfig.AddScsiCtlr(cspec)
# Get config options and targets
cfgOption = vmconfig.GetCfgOption(None)
cfgTarget = vmconfig.GetCfgTarget(None)
rdmBacking = Vim.Vm.Device.VirtualDisk.RawDiskMappingVer1BackingInfo()
rdmBacking.SetFileName("");
rdmBacking.SetDeviceName(disk);
rdmBacking.SetCompatibilityMode("physicalMode");
rdmBacking.SetDiskMode("");
rdmBacking.SetParent(None);
diskDev = Vim.Vm.Device.VirtualDisk()
diskDev.SetKey(vmconfig.GetFreeKey(cspec))
diskDev.SetBacking(rdmBacking)
ctlrs = vmconfig.GetControllers(cfgOption, Vim.Vm.Device.VirtualSCSIController, None, cspec)
# XXX Fix this up
for ctlrIdx in range(len(ctlrs)):
freeSlot = vmconfig.GetFreeSlot(cspec, None, cfgOption, ctlrs[ctlrIdx])
if (freeSlot >= 0):
diskDev.SetControllerKey(ctlrs[ctlrIdx].GetKey())
diskDev.SetUnitNumber(-1)
diskDev.SetCapacityInKB(long(4096))
break
vmconfig.AddDeviceToSpec(cspec, diskDev, \
Vim.Vm.Device.VirtualDeviceSpec.Operation.add, \
Vim.Vm.Device.VirtualDeviceSpec.FileOperation.create)
Log("create VM: " + str(vmname) + " with the RDM disk")
vmFolder = vm.GetVmFolder()
resPool = vm.GetResourcePool()
task = vmFolder.CreateVm(cspec, resPool)
WaitForTask(task)
Log("Finished Reconfiguring VM: " + str(vmname));
vm1 = task.info.result
Log("Now reconfiguring VM: " + str(vmname));
cspec = Vim.Vm.ConfigSpec()
rdmBacking = Vim.Vm.Device.VirtualDisk.RawDiskMappingVer1BackingInfo()
rdmBacking.SetFileName(rdmDiskFile);
rdmBacking.SetCompatibilityMode("physicalMode");
rdmBacking.SetDiskMode("persistent");
rdmBacking.SetParent(None);
diskDev = Vim.Vm.Device.VirtualDisk()
diskDev.SetKey(vmconfig.GetFreeKey(cspec))
diskDev.SetBacking(rdmBacking)
ctlrs = vmconfig.GetControllers(cfgOption, Vim.Vm.Device.VirtualSCSIController, vm1.GetConfig(), cspec)
# XXX Fix this up
for ctlrIdx in range(len(ctlrs)):
freeSlot = vmconfig.GetFreeSlot(cspec, vm1.GetConfig(), cfgOption, ctlrs[ctlrIdx])
if (freeSlot >= 0):
diskDev.SetControllerKey(ctlrs[ctlrIdx].GetKey())
diskDev.SetUnitNumber(-1)
diskDev.SetCapacityInKB(long(4096))
break
vmconfig.AddDeviceToSpec(cspec, diskDev, \
Vim.Vm.Device.VirtualDeviceSpec.Operation.add, \
Vim.Vm.Device.VirtualDeviceSpec.FileOperation.create)
vm.Reconfigure(vm1, cspec)
task = vmFolder.ReconfigVm(cspec, resPool)
WaitForTask(task)
Log("Finished Reconfiguring VM: " + str(vmname));
except Exception as e:
status = "FAIL"
Log("Caught exception : " + str(e))
Log("TEST RUN COMPLETE: " + status)
def AddVTPM(cspec, key=None):
if key is None:
key = vmconfig.GetFreeKey(cspec)
tpm = CreateVTPM(key)
vmconfig.AddDeviceToSpec(cspec, tpm,
vim.vm.device.VirtualDeviceSpec.Operation.add)
