def RetrieveTests(host): hostSystem = GetHostSystem(host) llpm = GetLLPM(hostSystem) vmxFilePaths = [] folders = BrowseDir(hostSystem, "[%s]" % options.datastore) for folder in folders: vmxFiles = BrowseDir(hostSystem, "[%s] %s" % (options.datastore, folder.path), "*.vmx") vmxFilePaths.extend([ "[%s] %s/%s" % (options.datastore, folder.path, vmxFile.path) for vmxFile in vmxFiles ]) for vmxFilePath in vmxFilePaths: Log("Invoking RetrieveVmRecoveryInfo on %s" % vmxFilePath) task = llpm.RetrieveVmRecoveryInfo(vmxFilePath) WaitForTask(task) Log(str(task.info.result)) Log("Invoking RetrieveLastVmMigrationStatus on %s" % vmxFilePath) task = llpm.RetrieveLastVmMigrationStatus(vmxFilePath) WaitForTask(task) Log(str(task.info.result))
def CheckFTState(vm, state, si=None, isPrimary=True): expRRState = None if isPrimary: expRRState = vim.VirtualMachine.RecordReplayState.recording else: expRRState = vim.VirtualMachine.RecordReplayState.replaying ftState = vm.GetRuntime().GetFaultToleranceState() rrState = vm.GetRuntime().GetRecordReplayState() if ftState != state: raise Exception("Runtime FT state %s not set to %s" % (ftState, state)) Log("Verified runtime fault tolerance state as " + str(state)) if not checkRRState: return # Check record/replay state if ftState == FTState.running: if rrState != expRRState: raise Exception("Runtime recordReplay state %s not set to %s" % (rrState, expRRState)) elif rrState != vim.VirtualMachine.RecordReplayState.inactive: raise Exception("Runtime recordReplay state %s not set to inactive" % rrState) Log("Verified runtime record/replay state as %s" % rrState)
def MountNas(host, localPath, remotePath, accessMode="readWrite"): m = re.match(r"^(.*?):(.*)$", remotePath) if m: remoteHost = m.string[m.start(1):m.end(1)] remotePath = m.string[m.start(2):m.end(2)] spec = vim.host.NasVolume.Specification(accessMode=accessMode, localPath=localPath, remoteHost=remoteHost, remotePath=remotePath) datastoreSystem = host.configManager.datastoreSystem return datastoreSystem.CreateNasDatastore(spec) Log("remotePath %s did not contain serverName:path format" % remotePath) return None
def testDeadProc(): Log("Testing StartProgram") spec = procDef.ProgramSpec(programPath="/bin/ls", arguments="/tmp") pid = procMgr.StartProgram(virtualMachine, guestAuth, spec) Log("Pid %s" % pid) pids = [ pid ] result = procMgr.ListProcesses(virtualMachine, guestAuth, pids) Log("Expected process not to show completion (no endTime or exitCode) yet") Log("Process info %s" % result) Log("Sleeping 3 seconds") time.sleep(3) result = procMgr.ListProcesses(virtualMachine, guestAuth, pids) Log("Expected process to show full results now") Log("Process info %s" % result)
def FindHostByName(name): """ Finds a host specified by its name """ global si idx = si.content.searchIndex host = idx.FindByIp(None, name, False) or idx.FindByDnsName( None, name, False) if not host: from socket import gethostbyaddr, herror try: hostName = gethostbyaddr(name)[0] host = idx.FindByDnsName(None, hostName, False) except herror as err: Log("Cannot find host %s" % name) host = None return host
def test_invalid_login(self): print("test_invalid_login") for i in xrange(self.options.num_bad_logins): try: print("iteration: " + repr(i)) bad_pwd = self.options.pwd + "JUNK" si = SmartConnect(host=self.options.host, user=self.options.user, pwd=bad_pwd, port=self.options.port) Disconnect(si) except Vim.Fault.InvalidLogin as e: Log("Caught InvalidLogin exception") pass else: self.fail('InvalidLogin not thrown')
def GetFeatureReqs(reqs, count=1, val=1): keyValues = {} for op in reqs: if len(keyValues) >= count: break if op.key in excludeKeys: continue m = re.match("(?P<type>)?:?(?P<operation>.*):(?P<value>.*)", op.value) if m: operation = m.group('operation') value = m.group('value') if int(value) == val: keyValues[op.key] = {"operation": operation, "value": value} Log("Mask %s=%s" % (op.key, keyValues[op.key])) continue return keyValues
def test_retrieve_various(self): si = SmartConnect(host=self.options.host, user=self.options.user, pwd=self.options.pwd, port=self.options.port) Disconnect(si) try: internalContent = si.RetrieveInternalContent() content = si.RetrieveContent() except Exception as e: self.fail("Unexpected exception for anon-allowable calls: %s" % e) pass try: uptime = self.hostSystem.RetrieveHardwareUptime() except Vim.Fault.NotAuthenticated as e: Log("Caught NotAuthenticated exception: %s" % e) pass
def main(): supportedArgs = [ (["h:", "host="], "10.20.109.41", "Host name", "host"), (["u:", "user="******"root", "User name", "user"), (["p:", "pwd="], "vmware", "Password", "pwd"), (["vpuser="******"root", "VP User name", "vpuser"), (["vppwd="], "ca$hc0w", " VP Password", "vppwd"), (["n:", "nfs="], "10.20.108.115", "nfs host name", "nfs"), (["m:", "mount="], "/mnt/pes/pepsi_nfs_pe", "Nfs server mount point", "mount"), (["d:", "pe="], "pepsi_nfs_pe", "PE name", "pe"), (["v:", "verbose="], "3", "log level(1-3), the lesser the more verbose", "verbose")] supportedToggles = [(["usage", "help"], False, "Show usage information", "usage")] args = arguments.Arguments(sys.argv, supportedArgs, supportedToggles) if args.GetKeyValue("usage") == True: args.Usage() print('Prerequisite:\n\ 1. VC with minimum of one host configured\n\ 2. VP is registered with SMS\n\ 3. VP is configured with NFS pe') sys.exit(0) global verbose verbose = int(args.GetKeyValue("verbose")) Log("Connected to vc " + args.GetKeyValue("host")) ds = VvolDs(args) ds.CleanupExistingTestDatastores() ds.addPE() ds.TestDummyCreateVvolDs() ds.TestCreateVvolDs() ds.TestDestroyVvolDs() ds.TestBulkCreateVvolDs() ds.TestBulkRemoveVvolDs() ds.TestBulkRemoveNonVvolDs() ds.TestRemoveVvolDsWithVms() ds.TestCreateDir() ds.TestVmMigrate() ds.TestDisconnectedHost() ds.TestUpdateVvolDs()
def TestDatastores(repManager, datastoreConf, dsMgrList): storageManager = repManager.GetStorageManager() Log("Test configured datastores") # Create a group on each datastore for datastoreMgr in dsMgrList: gspec = CreateRandomizedGroupSpec(datastoreMgr=datastoreMgr) newGroup = repManager.CreateGroup(gspec) dsList = storageManager.GetExpectedDatastores() # There should be at least one datastore for each CreateGroup above if len(dsList) != len(dsMgrList): Log("Expected datastores present...") PrintDatastores(dsList) Log("Test provided datastores...") PrintDatastores(dsMgrList) raise TestFailedExc("Expected " + str(len(dsMgrList)) + " datastores. " + "Found " + str(len(dsList)) + ".") PrintDatastores(dsList) numDs = len(dsList) # Test datastore removal (triggered by removal of all groups) Log("Test datastore removal...") for group in repManager.groups: group.Remove() dsList = storageManager.GetExpectedDatastores() newNumDs = len(dsList) if numDs != newNumDs: print("Remaining datastores...") PrintDatastores(dsList) newNumDs = numDs dsList = storageManager.GetExpectedDatastores( ) # Should have no datastores... numDs = len(dsList) if numDs != 0: Log("Groups that still exist") for group in repManager.groups: print(group) Log("Datastores that weren't removed...") PrintDatastores(dsList) raise TestFailedExc("Expected zero datastores. Found " + str(numDs) + ".") return
def main(): global vvolDsName vvolDsName = args.GetKeyValue("dsName") global vvolDs vvolDs = GetDatastore(si, vvolDsName) global vvolId vvolId = vvolDs.info.vvolDS.scId if not isinstance(vvolDs.info, Vim.Host.VvolDatastoreInfo): raise Exception("Datastore must be vvol datastore: %s" % \ (vvolDsName)) global vmRefs vmRefs = [] runTest() Log("Tests passed")
def TestAddDevice(vm1, device, allowVMotion, ctlr): Log("Testing adding of device '" + device.description + "' for VM " + vm1.GetConfig().GetName() + " allowVmotion:" + str(allowVMotion)) cspec = Vim.Vm.ConfigSpec() cspec = vmconfig.AddUSBDev(cspec, cfgInfo=vm1.GetConfig(), devName=device.name, allowVMotion=allowVMotion, ctlr=ctlr) # Hot-add the devices vm.Reconfigure(vm1, cspec) # Check for device presence in VM's config usbDev = CheckDevice(vm1, Vim.Vm.Device.VirtualUSB, "USB device") ctlrDev = vmconfig.GetControllers(vmconfig.GetCfgOption(None), ctlr, vm1.GetConfig(), Vim.Vm.ConfigSpec())[0] if ctlrDev.key != usbDev.controllerKey: raise Exception("Wrong controller for USB device:" + str(usbDev.controllerKey))
def addUnmappedAliases(): Log("adding some unmapped aliases for listing") nSubj = aliasDef.GuestAuthNamedSubject(name="unMappedSubjectName") aInfo = aliasDef.GuestAuthAliasInfo( subject=nSubj, comment="This is a unmapped test comment") nSubj2 = aliasDef.GuestAuthNamedSubject(name="unMappedSubjectName2") aInfo2 = aliasDef.GuestAuthAliasInfo( subject=nSubj2, comment="This is a unmapped test comment2") nSubj3 = aliasDef.GuestAuthAnySubject() aInfo3 = aliasDef.GuestAuthAliasInfo( subject=nSubj3, comment="This is a unmapped test comment3 for an ANY") result = aliasMgr.AddAlias(virtualMachine, guestAuth, gUser, False, caCert, aInfo) result = aliasMgr.AddAlias(virtualMachine, guestAuth, gUser, False, caCert, aInfo2) result = aliasMgr.AddAlias(virtualMachine, guestAuth, gUser, False, caCert, aInfo3) result = aliasMgr.AddAlias(virtualMachine, guestAuth, gUser, False, cert2, aInfo2)
def RunTests(self): Log("VirtualDiskManager: Run tests") if self._dsName == None: self._dsName = self.FindDatastoreName() self.TestCreateFileBacked() self.TestCreateFileBackedWeirdPaths() self.TestMove() self.TestUuid() #self.TestExtend() self.TestCopy() self.TestCopySelf() self.TestCopySpecless() self.TestEagerZero() self.TestOptimizeEagerZero() self.TestInflate() if self._rdm != None: self.TestCreateDeviceBacked() ##self.TestDelete() self.TestQueryDiskInfo() self.TestInsufficientCapacity()
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 TestEditSataDisk(vm1): """ Test reconfigures of SATA disks """ cspec = Vim.Vm.ConfigSpec() cspec = vmconfig.AddSataCtlr(cspec) cspec = vmconfig.AddScsiCtlr(cspec) vm.Reconfigure(vm1, cspec) Log("Add SATA disk.") AddSataDisk(vm1) Log("Reconfigure disk capacity.") TestExtendDisk(vm1) Log("Snapshot and reconfigure delta disk.") TestReconfigDeltaDisk(vm1) Log("Move SATA disk to SCSI controller.") scsiCtlrs = vmconfig.CheckDevice(vm1.config, Vim.Vm.Device.VirtualSCSIController) if len(scsiCtlrs) < 1: raise Exception("Failed to find SCSI controller!") disk = vmconfig.CheckDevice(vm1.config, Vim.Vm.Device.VirtualDisk)[0] TestMoveDevice(vm1, disk, scsiCtlrs[0]) Log("Move SCSI disk to SATA controller.") ctlrs = vmconfig.CheckDevice(vm1.config, Vim.Vm.Device.VirtualSATAController) disk = vmconfig.CheckDevice(vm1.config, Vim.Vm.Device.VirtualDisk)[0] TestMoveDevice(vm1, disk, ctlrs[0]) vm.RemoveDevice(vm1, scsiCtlrs[0]) Log("Remove SATA disk.") RemoveSataDisk(vm1); Log("Testing hot-add and hot-remove of SATA disk.") vm.PowerOn(vm1) AddSataDisk(vm1) RemoveSataDisk(vm1); vm.PowerOff(vm1) vm.RemoveDevice(vm1, ctlrs[0])
def main(): supportedArgs = [(["h:", "host="], "localhost", "Host name", "host"), (["u:", "user="******"root", "User name", "user"), (["p:", "pwd="], "ca$hc0w", "Password", "pwd")] 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 = SmartConnect(host=args.GetKeyValue("host"), user=args.GetKeyValue("user"), pwd=args.GetKeyValue("pwd")) atexit.register(Disconnect, si) Log("Connected to host " + args.GetKeyValue("host")) vmfs5 = Vmfs5(si) vmfs5.TestCreateAndUpgradeVmfsDatastores()
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 waitForLazySnapshot(virtualMachine, snapTask): while snapTask.info.progress != 100 and snapTask.info.state not in [ 'success', 'error' ]: Log(">>> Current snapshot: state='%s', progress='%s'" % (snapTask.info.state, snapTask.info.progress)) if virtualMachine.GetRuntime().GetSnapshotInBackground() is True: Log(">>> Entered lazy phase for snapshot") Log("-----------------------------------") break else: Log(">>> Snapshot still in eager phase...") Log("-----------------------------------") time.sleep(3) # check task status Log(">>> Current snapshot: state='%s', progress='%s'" % (snapTask.info.state, snapTask.info.progress))
def CollectStats(statData): si, perfManager, hostSystem, hbrManager = GetParams( statData.host, statData.user, statData.password) global counterInfoDict global counterSem # Add depot stats counter / name pairs counterSem.acquire() for info in perfManager.perfCounter: counterInfoDict[info.key] = "%s.%s.%s" % ( info.groupInfo.key, info.nameInfo.key, info.rollupType) counterSem.release() statData.hostDepotStats = GetDepotStats(perfManager, hostSystem) statData.vm = CreateTestVm(si, statData.datastore) # Enable hbr replication for real host, don't need to do this for simulator if hbrManager is not None and not statData.sim: EnableReplication(hbrManager, statData.vm) elif not statData.sim: Log("Warning: hbrManager is None!") if statData.enableReg: # Add registry stats counter / name pairs counterInfo = perfManager.QueryPerfCounterInt() counterSem.acquire() for info in counterInfo: counterInfoDict[info.key] = "%s.%s.%s" % ( info.groupInfo.key, info.nameInfo.key, info.rollupType) counterSem.release() statData.regStats = GetRegistryStats(perfManager, hostSystem) time.sleep(40) # Sleep to let stats populate statData.vmDepotStats = GetDepotStats(perfManager, statData.vm) vm.PowerOff(statData.vm) WaitForTask(statData.vm.Destroy())
def AddDisks(vm1, num, ctlrKeys, startingOffset=-1, datastore=None): cspec = Vim.Vm.ConfigSpec() dchange = cspec.GetDeviceChange() cspec.SetDeviceChange(dchange) for z in ctlrKeys: ctlrKey = z thisOffset = startingOffset for i in range(num): devSpec = Vim.Vm.Device.VirtualDeviceSpec() diskDev = Vim.Vm.Device.VirtualDisk() diskDev.SetKey(-i) diskDev.SetControllerKey(ctlrKey) if thisOffset < 0: diskDev.SetUnitNumber(-1) else: if thisOffset + i == 7: thisOffset += 1 diskDev.SetUnitNumber(thisOffset + i) diskDev.capacityInKB = long(1024) devSpec.SetDevice(diskDev) devSpec.SetOperation("add") devSpec.SetFileOperation("create") dchange.append(devSpec) diskBacking = Vim.Vm.Device.VirtualDisk.FlatVer2BackingInfo() diskDev.SetBacking(diskBacking) if datastore != None: diskBacking.SetFileName("[" + datastore + "]") else: diskBacking.SetFileName("") diskBacking.SetDiskMode("persistent") Log("Adding disk " + str(i + 1) + " to spec " + str(diskDev.unitNumber)) task = vm1.Reconfigure(cspec) WaitForTask(task)
def testExplicitListProc(): # explicit pid test -- try some system processes that should be there pids = [0, 1, 2] Log("Testing explicit ListProcesses pid %s" % pids) result = procMgr.ListProcesses(virtualMachine, guestAuth, pids) Log("Note that this may have 0 results on Windows") numResults = len(result) Log("Found %s results" % numResults) if numResults > 0: Log("Explicit processes: %s" % result) for process in result: found = False for pid in pids: if process.pid == pid: Log("Found pid %s" % pid) found = True break if not found: Log("Unwanted pid %s" % process.pid) raise AssertionError("Received unwanted pid %s" % process.pid)
def mainTestFirmware(): Log("---[ TEST " + testName + " ]---") vmname = "HwV8_Firmware" status = "PASS" bigClock = StopWatch() vm1 = None try: macosVmName = vmname + "_MacOS" Log("Cleaning up VMs from previous runs...") vm.Delete(macosVmName, True) Log("Creating Mac OS VM..") vm1 = vm.CreateQuickDummy(macosVmName, vmxVersion="vmx-08", memory=4, guest="darwin11Guest") firmware = "efi" ChangeFirmware(vm1, firmware, True) if firmware != vm1.config.firmware: raise Exception("Firmware don't match set value") firmware = "bios" ChangeFirmware(vm1, firmware, True) if firmware != vm1.config.firmware: raise Exception("Firmware don't match set value") Log("Deleting VM " + macosVmName) vm.Delete(macosVmName, True) bigClock.finish(testName) except Exception as e: status = "FAIL" Log("Caught exception : " + str(e)) Log("TEST [" + testName + "] COMPLETE: " + status) return status
try: # Connect to hosts. si = connect.Connect(host=host, user=args.GetKeyValue("user"), pwd=args.GetKeyValue("pwd"), version="vim.version.version9") atexit.register(Disconnect, si) id = args.GetKeyValue("id") if args.GetKeyValue("flag"): ToggleDispatcherFlag(si, args.GetKeyValue("flag")) Log("TEST RUN %s COMPLETE: %s" % (id, status)) except Exception: (excType, excVal, excTB) = sys.exc_info() Log("Caught exception: ") traceback.print_exception(excType, excVal, excTB) status = "FAIL" # Start program if __name__ == "__main__": try: main() except: (excType, excVal, excTB) = sys.exc_info() Log("Test exiting on unhandled exception: ") traceback.print_exception(excType, excVal, excTB) sys.exit(42)
def main(): supportedArgs = [ (["P:", "primary host="], "localhost", "Primary host name", "primaryHost"), (["S:", "secondary host="], "localhost", "Secondary host name", "secondaryHost"), (["d:", "shared datastore name="], "storage1", "shared datastore name", "dsName"), (["k:", "keep="], "0", "Keep configs", "keep"), (["u:", "user="******"root", "User name", "user"), (["p:", "pwd="], "", "Password", "pwd"), (["v:", "vmname="], "vmFT", "Name of the virtual machine", "vmname"), (["i:", "numiter="], "1", "Number of iterations", "iter"), (["t:", "FT type="], "up", "Type of fault tolerance [up|smp]", "ftType"), ] 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) # Process command line vmname = args.GetKeyValue("vmname") numiter = int(args.GetKeyValue("iter")) keep = int(args.GetKeyValue("keep")) dsName = args.GetKeyValue("dsName") primaryHost = args.GetKeyValue("primaryHost") secondaryHost = args.GetKeyValue("secondaryHost") ftType = args.GetKeyValue("ftType") numCPU = 2 if ftType == "smp" else 1 memSize = 64 for i in range(numiter): primaryVm = None primarySi = None secondarySi = None try: # Connect to primary host primarySi = SmartConnect(host=primaryHost, user=args.GetKeyValue("user"), pwd=args.GetKeyValue("pwd")) Log("Connected to Primary host") # Cleanup from previous runs try: CleanupVm(vmname) except vim.fault.InvalidOperationOnSecondaryVm: pass # Connect to secondary host secondarySi = SmartConnect(host=secondaryHost, user=args.GetKeyValue("user"), pwd=args.GetKeyValue("pwd")) Log("Connected to Secondary host") for si in [primarySi, secondarySi]: if len(FindNicType(si, ftLoggingNicType)) == 0: SelectVnic(si, "vmk0", ftLoggingNicType) if len(FindNicType(si, vmotionNicType)) == 0: SelectVnic(si, "vmk0", vmotionNicType) ftMgrDst = host.GetFaultToleranceMgr(secondarySi) # Cleanup from previous runs CleanupVm(vmname) CleanupVm(vmname, True) connect.SetSi(primarySi) CleanupDir(dsName, vmname) if ftType == "smp": CleanupDir(dsName, "%s_shared" % vmname) # Create new VM Log("Creating primary VM " + vmname) primaryVm = vm.CreateQuickDummy(vmname, guest="winNetEnterpriseGuest", numScsiDisks=2, scrubDisks=True, memory=memSize, datastoreName=dsName) primaryUuid = primaryVm.GetConfig().GetInstanceUuid() primaryCfgPath = primaryVm.GetConfig().GetFiles().GetVmPathName() primaryDir = primaryCfgPath[:primaryCfgPath.rfind("/")] ftMetadataDir = GetSharedPath(primarySi, primaryVm) Log("Using VM : " + primaryVm.GetName() + " with instanceUuid " + primaryUuid) ftMetadataDir = GetSharedPath(primarySi, primaryVm) cSpec = vim.vm.ConfigSpec() if ftType != "smp": # Enable record/replay for the primaryVm # See PR 200254 flags = vim.vm.FlagInfo(recordReplayEnabled=True) cSpec.SetFlags(flags) task = primaryVm.Reconfigure(cSpec) WaitForTask(task) Log("Enabled record/replay for Primary VM.") CheckFTState( primaryVm, vim.VirtualMachine.FaultToleranceState.notConfigured) else: cSpec.files = vim.vm.FileInfo( ftMetadataDirectory=ftMetadataDir) cSpec.numCPUs = numCPU task = primaryVm.Reconfigure(cSpec) WaitForTask(task) # Create secondary VM connect.SetSi(secondarySi) Log("Creating secondary VM " + vmname) secondaryVm = vm.CreateQuickSecondary(vmname, primaryVm, ftType=ftType, scrubDisks=True, numScsiDisks=2, datastoreName=dsName, ftMetadataDir=ftMetadataDir) if secondaryVm == None: raise "Secondary VM creation failed" secondaryUuid = secondaryVm.GetConfig().GetInstanceUuid() secondaryCfgPath = secondaryVm.GetConfig().GetFiles( ).GetVmPathName() Log("Created secondary VM " + secondaryVm.GetName()) Log("Secondry VM: instanceUuid " + secondaryUuid) Log("Secondary cfg path: " + secondaryCfgPath) ## Configure some additional config variables needed for FT ## This should eventually be done automatically at FT Vmotion time Log("Setting up extra config settings for the primary VM...") cSpec = vim.Vm.ConfigSpec() extraCfgs = [] if ftType == "smp": # some of these options are temporary cSpec.flags = vim.vm.FlagInfo( faultToleranceType=FTType.checkpointing) AddExtraConfig(extraCfgs, "ftcpt.maxDiskBufferPages", "0") AddExtraConfig(extraCfgs, "sched.mem.pshare.enable", "FALSE") AddExtraConfig(extraCfgs, "sched.mem.fullreservation", "TRUE") AddExtraConfig(extraCfgs, "monitor_control.disable_mmu_largepages", "TRUE") AddExtraConfig(extraCfgs, "sched.mem.min", memSize) AddExtraConfig(extraCfgs, "migration.dataTimeout", "2000") cSpec.files = vim.vm.FileInfo( ftMetadataDirectory=ftMetadataDir) else: cSpec.flags = vim.vm.FlagInfo( faultToleranceType=FTType.recordReplay) AddExtraConfig(extraCfgs, "replay.allowBTOnly", "TRUE") cSpec.SetExtraConfig(extraCfgs) WaitForTask(primaryVm.Reconfigure(cSpec)) # Register secondary VM Log("Register secondary VM with the primary") ftMgr = host.GetFaultToleranceMgr(primarySi) connect.SetSi(primarySi) task = ftMgr.RegisterSecondary(primaryVm, secondaryUuid, secondaryCfgPath) WaitForTask(task) Log("Secondary VM registered successfully") # Verify FT role & state CheckFTRole(primaryVm, 1) CheckFTState(primaryVm, vim.VirtualMachine.FaultToleranceState.enabled) Log("FT configured successfully.") # PowerOn FT VM Log("Powering on Primary VM") vm.PowerOn(primaryVm) if ftType == "smp": # some of these options are temporary task = primaryVm.CreateSnapshot("snap-early", "before secondary starts", memory=False, quiesce=True) WaitForTask(task) # Perform the FT VMotion Log("Calling StartSecondary on remote host...") primaryThumbprint = GetHostThumbprint(primaryHost) secondaryThumbprint = GetHostThumbprint(secondaryHost) Log("Primary thumbprint: %s" % primaryThumbprint) Log("Secondary thumbprint: %s" % secondaryThumbprint) secondaryHostSystem = secondarySi.content.rootFolder.childEntity[ 0].hostFolder.childEntity[0].host[0] sslThumbprintInfo = vim.host.SslThumbprintInfo( ownerTag='hostd-test', principal='vpxuser') sslThumbprintInfo.sslThumbprints = [primaryThumbprint] secondaryHostSystem.UpdateSslThumbprintInfo( sslThumbprintInfo, "add") sslThumbprintInfo.sslThumbprints = [secondaryThumbprint] primaryHostSystem = primarySi.content.rootFolder.childEntity[ 0].hostFolder.childEntity[0].host[0] primaryHostSystem.UpdateSslThumbprintInfo(sslThumbprintInfo, "add") task = ftMgr.StartSecondaryOnRemoteHost(primaryVm, secondaryCfgPath, secondaryHost, 80, secondaryThumbprint) WaitForTask(task) Log("Start secondary done.") if ftType == "smp": # Verify snapshot is gone if primaryVm.snapshot is not None: raise Exception("Snapshot still exists on primary") task = primaryVm.CreateSnapshot("snap", "without memory snapshot", memory=False, quiesce=True) WaitForTask(task) if not primaryVm.snapshot or not primaryVm.snapshot.currentSnapshot: raise Exception("Snapshot was not created") else: Log("Snapshot %s exists as expected" % primaryVm.snapshot.currentSnapshot) # Retrieve reference to new secondary VM connect.SetSi(secondarySi) secondaryVm = folder.FindCfg(secondaryCfgPath) connect.SetSi(primarySi) # FT state check CheckFTState(primaryVm, vim.VirtualMachine.FaultToleranceState.running) CheckFTState(secondaryVm, vim.VirtualMachine.FaultToleranceState.running) Log("Start secondary done.") # allows some time for FT to run and checkpoint before failing # over. This seems more necessary on nested VM environments # than physical time.sleep(20) Log("Failing over to the secondary.") WaitForTask(ftMgr.MakePrimary(primaryVm, secondaryUuid)) WaitForPowerState(primaryVm, primarySi, vim.VirtualMachine.PowerState.poweredOff) Log("Verified primary power state is off.") WaitForFTState(secondaryVm, FTState.needSecondary) Log("Starting secondary.") task = ftMgrDst.StartSecondaryOnRemoteHost(secondaryVm, primaryCfgPath, primaryHost, 80, primaryThumbprint) WaitForTask(task) # Verify snapshot is gone if primaryVm.snapshot is not None: raise Exception("Snapshot still exists on old primary") Log("Failing over to the old-primary.") WaitForTask(ftMgrDst.MakePrimary(secondaryVm, secondaryUuid)) WaitForPowerState(secondaryVm, secondarySi, vim.VirtualMachine.PowerState.poweredOff) Log("Verified primary power state is off.") WaitForFTState(primaryVm, FTState.needSecondary) task = ftMgr.StartSecondaryOnRemoteHost(primaryVm, secondaryCfgPath, secondaryHost, 80, secondaryThumbprint) WaitForTask(task) # PowerOff FT VMs Log("Power off Primary VM") vm.PowerOff(primaryVm) connect.SetSi(secondarySi) for i in range(10): if secondaryVm.GetRuntime().GetPowerState( ) == vim.VirtualMachine.PowerState.poweredOn: time.sleep(1) if secondaryVm.GetRuntime().GetPowerState( ) == vim.VirtualMachine.PowerState.poweredOn: raise Exception("Secondary VM is still powered on!") Log("Verified secondary power state.") Log("Unregistering secondary VM " + vmname) ftMgrDst.Unregister(secondaryVm) # Cleanup if not keep: connect.SetSi(primarySi) CleanupVm(vmname) CleanupDir(dsName, vmname) if ftType == "smp": CleanupDir(dsName, "%s_shared" % vmname) connect.SetSi(secondarySi) CleanupVm(vmname, True) except Exception as e: Log("Caught exception : %s" % e) stackTrace = " ".join( traceback.format_exception(sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2])) Log(stackTrace) global status status = "FAIL" Disconnect(primarySi) Disconnect(secondarySi) return Disconnect(primarySi) Disconnect(secondarySi)
CleanupDir(dsName, vmname) if ftType == "smp": CleanupDir(dsName, "%s_shared" % vmname) connect.SetSi(secondarySi) CleanupVm(vmname, True) except Exception as e: Log("Caught exception : %s" % e) stackTrace = " ".join( traceback.format_exception(sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2])) Log(stackTrace) global status status = "FAIL" Disconnect(primarySi) Disconnect(secondarySi) return Disconnect(primarySi) Disconnect(secondarySi) # Start program if __name__ == "__main__": main() Log("Test status: " + status) Log("FT Tests completed") if status != "PASS": sys.exit(1)
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)
host = 'localhost' stub = SoapStubAdapter(host=host, version="vim.version.version10") newsi = Vim.ServiceInstance("ServiceInstance", stub) # Try to acquire a clone ticket on a un-authenticated session. Should fail. try: newsi.GetContent().GetSessionManager().AcquireCloneTicket() except: pass newsm = newsi.GetContent().GetSessionManager().CloneSession(ticket) for vm1 in folder.GetVmAll(si=newsi): print vm1 try: Log("Power Off (should pass)") vm1.PowerOff() time.sleep(5) Log("pass\n") except Exception, e: print Exception, e Log("fail\n") pass try: Log("Power On (should pass)") vm1.PowerOn() time.sleep(5) Log("pass\n") except Exception, e: print Exception, e
def main(): supportedArgs = [ (["h:", "host="], "localhost", "Host name", "host"), (["u:", "user="******"root", "User name", "user"), (["p:", "pwd="], "ca$hc0w", "Password", "pwd"), (["d:", "ds="], None, "Datastore name", "ds"), (["r:", "rdm="], None, "Device path used in rdm creation", "rdm"), (["n:", "nas="], None, "Nas datastore creation info format:'host:share:dsname'", "nas"), # (["s:", "subdir="], "testvdm/", "Subdirectory in selected datastore as " # "possible destination for disks'", "subdir"), (["i:", "numiter="], "1", "Number of iterations", "iter") ] supportedToggles = [ (["usage", "help"], False, "Show usage information", "usage"), (["cleanup", "c"], True, "Try to cleanup test vms from previous runs", "cleanup")] 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")) Log("Connected to host " + args.GetKeyValue("host")) # Process command line numiter = int(args.GetKeyValue("iter")) doCleanup = args.GetKeyValue("cleanup") status = "PASS" resultsArray = [] serviceInstanceContent = si.RetrieveContent() vdiskMgr = serviceInstanceContent.GetVirtualDiskManager() hostSystem = host.GetHostSystem(si) hostConfigManager = hostSystem.GetConfigManager() global datastoreSystem datastoreSystem = hostConfigManager.GetDatastoreSystem() if vdiskMgr == None: Log("Virtual Disk Manager not found") sys.exit(0) for i in range(numiter): bigClock = StopWatch() try: try: ph = Phase() vdiskMgrTest = VirtualDiskManagerTest(vdiskMgr, args) vdiskMgrTest.RunTests() ph.SetPhase("Virtual Disk Manager Tests") status = "PASS" finally: bigClock.finish("iteration " + str(i)) # While debugging, uncomment the line below to see backtraces # when an exception occurs. except Exception as e: Log("Caught exception : " + str(e)) status = "FAIL" Log("TEST RUN COMPLETE: " + status) resultsArray.append(status) Log("Results for each iteration: ") for i in range(len(resultsArray)): Log("Iteration " + str(i) + ": " + resultsArray[i])