def main(): supportedArgs = [ (["h:", "host="], "localhost", "Host name", "host"), (["u:", "user="******"root", "User name", "user"), (["p:", "pwd="], "ca$hc0w", "Password", "pwd"), (["d:", "d1="], "storage1", "Datastore 1", "ds1"), (["q:", "d2="], "local", "Datastore 2", "ds2"), (["i:", "numiter="], "1", "Number of iterations", "iter"), (["f:", "deltaDiskFormat="], "redoLogFormat", "Delta Disk Format: nativeFormat/seSparseFormat/redoLogFormat", "delta"), (["b:", "backingType="], "flat", "Backing type of disk", "backing"), (["v:", "vmxVersion="], "vmx-08", "The VMX version", "vmx") ] 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.SmartConnect(host=args.GetKeyValue("host"), user=args.GetKeyValue("user"), pwd=args.GetKeyValue("pwd")) atexit.register(connect.Disconnect, si) # Process command line numiter = int(args.GetKeyValue("iter")) ds1 = args.GetKeyValue("ds1") ds2 = args.GetKeyValue("ds2") deltaDiskFormat = args.GetKeyValue("delta") backingType = args.GetKeyValue("backing") vmxVersion = args.GetKeyValue("vmx") status = "PASS" resultsArray = [] testLinkedClone(si, numiter, deltaDiskFormat, backingType, vmxVersion, ds1, ds2, status, resultsArray)
def main(): supportedArgs = [(["h:", "host="], "localhost", "Host name", "host"), (["u:", "user="******"root", "User name", "user"), (["p:", "pwd="], "ca$hc0w", "Password", "pwd"), (["v:", "vmname="], "", "VM prefix (deletes everything by default)", "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(host=args.GetKeyValue("host"), user=args.GetKeyValue("user"), pwd=args.GetKeyValue("pwd")) # Process command line vmname = args.GetKeyValue("vmname") vms = folder.FindPrefix(vmname) if len(vms) != 0: for vm in vms: try: vm.Destroy() except Exception, e: raise
def main(): supportedArgs = [(["h:", "host="], "localhost", "Host name", "host"), (["u:", "user="******"root", "User name", "user"), (["p:", "pwd="], "", "Password", "pwd")] supportedToggles = [(["burn", "use"], False, "Burn the ticket", "burn"), (["usage", "help"], False, "Show usage information", "usage")] args = arguments.Arguments(sys.argv, supportedArgs, supportedToggles) if args.GetKeyValue("usage") == True: args.Usage() return # Connect si = Connect(host=args.GetKeyValue("host"), user=args.GetKeyValue("user"), pwd=args.GetKeyValue("pwd"), version="vim.version.version9") # Obtain a ticket sm = si.GetContent().GetSessionManager() ticket = sm.AcquireCloneTicket() print "Clone Ticket: " + ticket if not args.GetKeyValue("burn") == True: return # Use the ticket try: (host, port) = args.GetKeyValue("host").split(":", 1) port = int(port) except ValueError, ve: host = args.GetKeyValue("host") port = 902
def main(): supportedArgs = [ (["h:", "host="], "10.112.184.217", "Host name", "host"), (["u:", "user="******"root", "User name", "user"), (["p:", "pwd="], "", "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 = connect.SmartConnect(host=args.GetKeyValue("host"), user=args.GetKeyValue("user"), pwd=args.GetKeyValue("pwd")) atexit.register(connect.Disconnect, si) Log("Connected to host " + args.GetKeyValue("host")) vffs = Vffs(si) vffs.__init__(si) fs = vffs.formatVffs("vffs") if fs == None: print("XXX::HostCacheConfig test FAILED") else: if vffs.testHostCache(fs.uuid) == 1: print("***::HostCacheConfig test PASSED") else: print("XXX::HostCacheConfig test FAILED")
def main(): supportedArgs = [ (["h:", "host="], "localhost", "Secondary host name", "host"), (["u:", "user="******"root", "User name", "user"), (["p:", "pwd="], "ca$hc0w", "Password", "pwd"), (["v:", "VM name="], "vmFT", "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) vmname = args.GetKeyValue("vmname") try: si = Connect(host=args.GetKeyValue("host"), user=args.GetKeyValue("user"), pwd=args.GetKeyValue("pwd")) atexit.register(Disconnect, si) Log("Connected to host") CleanupVm(vmname, True) Log("Cleaned up secondary VM") except Exception as e: Log("Caught exception : " + str(e))
def main(): supportedArgs = [(["h:", "host="], "localhost", "Host name", "host"), (["u:", "user="******"root", "User name", "user"), (["p:", "pwd="], "ca$hc0w", "Password", "pwd"), (["i:", "numiter="], "1", "Number of iterations", "iter"), (["t:", "test="], "", "Speciffic test to run", "test")] supportedToggles = [ (["usage", "help"], False, "Show usage information", "usage"), (["runall", "r"], True, "Run all the tests", "runall"), (["nodelete"], False, "Dont delete vm on completion", "nodelete") ] allTests = {'firmware': mainTestFirmware, 'multicore': mainTestMulticore} args = arguments.Arguments(sys.argv, supportedArgs, supportedToggles) if args.GetKeyValue("usage") == True: args.Usage() print("\nTests available:") for k in allTests.keys(): print("\t" + k) 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 numiter = int(args.GetKeyValue("iter")) runall = args.GetKeyValue("runall") noDelete = args.GetKeyValue("nodelete") test = args.GetKeyValue("test") status = "PASS" for i in range(numiter): bigClock = StopWatch() partialStatus = "PASS" if test == "": for k in allTests.keys(): partialStatus = allTests[k]() else: if test in allTests.keys(): partialStatus = allTests[test]() else: Log("Test '" + test + "' not found. Check usage for list of tests.") if partialStatus == "FAIL": status = "FAIL" Log("Tests completed.") bigClock.finish("iteration " + str(i)) Log("TEST RUN COMPLETE: " + status)
def main(): supportedArgs = [ (["h:", "host="], "10.112.184.217", "Host name", "host"), (["u:", "user="******"root", "User name", "user"), (["p:", "pwd="], "", "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 = connect.SmartConnect(host=args.GetKeyValue("host"), user=args.GetKeyValue("user"), pwd=args.GetKeyValue("pwd")) atexit.register(connect.Disconnect, si) qt = QueryTest(si) qt.__init__(si) if qt.test() == 0: print("QueryAvailableDisksForVmfs test PASSED") else: print("QueryAvailableDisksForVmfs test FAILED")
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) reg = GetRegistry(args.GetKeyValue("host"), args.GetKeyValue("user"), args.GetKeyValue("pwd")) if reg == None: print("Stats registry instance is NULL!") sys.exit(0) #get supported stats definition stats = GetStatList(reg) print(stats) #get stat value statValues = GetStatValue(reg, [[1], [2, '1']])
def main(): supportedArgs = [ (["h:", "host="], "localhost", "Host name", "host"), (["u:", "user="******"root", "User name", "user"), (["p:", "pwd="], "", "Password", "pwd"), (["v:", "vmname="], "SATATest", "Name of the virtual machine", "vmname") ] 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") runall = args.GetKeyValue("runall") noDelete = args.GetKeyValue("nodelete") status = "PASS" vm1 = None try: Log("Cleaning up VMs from previous runs...") vm.Delete(vmname, True) ## Positive tests on a hwVersion 10 VM Log("Creating Hw10 VM..") vm1 = vm.CreateQuickDummy(vmname, vmxVersion = "vmx-10", memory = 4, guest = "otherGuest") # Test add of SATA controller TestSataCtlrReconfig(vm1) # Mess with SATA disks TestEditSataDisk(vm1) # Mess with SATA cdroms TestEditSataCdrom(vm1) Log("Tests completed.") except Exception as e: status = "FAIL" Log("Caught exception : " + str(e)) finally: # Delete the vm as cleanup if noDelete == False: if vm1 != None: task = vm1.Destroy() WaitForTask(task) vm1 = None Log("TEST RUN COMPLETE: " + status)
def main(): supportedArgs = [ (["h:", "host="], "10.112.184.217", "Host name", "host"), (["u:", "user="******"root", "User name", "user"), (["p:", "pwd="], "", "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 = connect.SmartConnect(host=args.GetKeyValue("host"), user=args.GetKeyValue("user"), pwd=args.GetKeyValue("pwd")) atexit.register(connect.Disconnect, si) Log("Connected to host " + args.GetKeyValue("host")) pt = PartTest(si) pt.__init__(si) ret = pt.testPart() if ret == 1: Log ("test successful") else: Log ("test failed") return
def main(): supportedArgs = [ (["h:", "host="], "localhost", "Host name", "host"), (["u:", "user="******"root", "User name", "user"), (["p:", "pwd="], None, "Password", "pwd"), (["v:", "vmname="], None, "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 connection = Connection(host=args.GetKeyValue("host"), user=args.GetKeyValue("user"), pwd=args.GetKeyValue("pwd"), namespace="vim25/5.5") with connection as si: # Process command line vmname = args.GetKeyValue("vmname") vm = folder.Find(vmname) if vm == None: print "Could not find VM", vmname sys.exit(1) print SerializeToConfig(vm.config, tag="configInfo")
def main(): supportedArgs = [(["h:", "host="], "localhost", "Host name", "host"), (["u:", "user="******"root", "User name", "user"), (["p:", "pwd="], "", "Password", "pwd"), (["v:", "vmname="], "", "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(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") vm1 = None try: # Find the VM vm1 = folder.Find(vmname) if vm1 == None: raise Exception("VM with name " + vmname + " cannot be found!") instanceId = "0" # Inspired by InternalCommand() in vim/py/tests/vmTestHbr.py!! vprobesMgr = Hostd.VprobesManager("ha-internalsvc-vprobesmgr", si._stub) bad_script = '''0 (vprobe VMXLoad (printf \"Test script loaded\\n\")) (vprobe VMM1Hz (printf \"Hello World\\n\")) (vprobe badProbeName (printf \"Test script unloaded\\n\")) ''' task = vprobesMgr.LoadVprobes(vm1, bad_script) WaitForTask(task) Log("FAILURE: Failed to catch exception") except Vmodl.Fault.SystemError as e: Log("EXPECTED FAILURE: Load failed: " + e.reason) Log("SUCCESS: VProbes tests completed") return except Exception as e: Log("FAILURE: Caught exception : " + str(e)) raise e return
def main(): # Process command line 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 = Connect(host=args.GetKeyValue("host"), user=args.GetKeyValue("user"), pwd=args.GetKeyValue("pwd")) atexit.register(Disconnect, si) # Connect status = "PASS" try: content = si.RetrieveContent() # Gee, getting to hostSystem require quit a bit of works dataCenter = content.GetRootFolder().GetChildEntity()[0] hostFolder = dataCenter.GetHostFolder() computeResource = hostFolder.GetChildEntity()[0] hostSystem = computeResource.GetHost()[0] # Performance manager perfManager = content.GetPerfManager() querySpecs = [] querySpec = Vim.PerformanceManager.QuerySpec() querySpec.entity = hostSystem querySpecs.append(querySpec) for i in range(0, 4): # Query stats entityMetrics = perfManager.QueryStats(querySpecs) # Query composite stats metricIds = perfManager.QueryAvailableMetric(hostSystem) querySpec.metricId = metricIds entityMetrics = perfManager.QueryCompositeStats(querySpecs[0]) except Exception as e: Log("Failed test due to exception: " + str(e)) status = "FAIL" finally: pass Log("TEST RUN COMPLETE: " + status)
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 main(): ssl._create_default_https_context = ssl._create_unverified_context supportedArgs = [(["s:", "server="], "localhost", "Host name", "server")] 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) try: host = args.GetKeyValue("server") stub = SoapStubAdapter(host, 443, "vim25/2.5", "/sdk") si = Vim.ServiceInstance("ServiceInstance", stub) sc = si.RetrieveContent() print sc.about.build except Exception, e: print e sys.exit(1)
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"), (["i:", "numiter="], "1", "Number of iterations", "iter")] supportedToggles = [ (["usage", "help"], False, "Show usage information", "usage"), (["unregister"], False, "Do an unregister of all registered vms", "unregister") ] 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")) # Process command line vmname = args.GetKeyValue("vmname") numiter = int(args.GetKeyValue("iter")) dounreg = int(args.GetKeyValue("unregister")) # The unregister case if (dounreg): for v in folder.GetAll(): v.Unregister() sys.exit(0) # Create vms for i in range(numiter): clock = StopWatch() folder.Register("[storage1] " + vmname + "_" + str(i) + "/" + vmname + "_" + str(i) + ".vmx") clock.finish("Register done")
def main(): supportedArgs = [(["h:", "host="], "localhost", "Host name", "host"), (["u:", "user="******"root", "User name", "user"), (["p:", "pwd="], "", "Password", "pwd"), (["d:", "disk="], "/vmfs/devices/", "Disk", "disk"), (["s:", "ds="], "datastore1", "Datastore 1", "ds")] supportedToggles = [(["usage", "help"], False, "Show usage information", "usage")] args = arguments.Arguments(sys.argv, supportedArgs, supportedToggles) if args.GetKeyValue("usage"): args.Usage() sys.exit(0) options = Options() options.disk = args.GetKeyValue("disk") options.datastore = args.GetKeyValue("ds") options.hostname = args.GetKeyValue("host") options.username = args.GetKeyValue("user") options.password = args.GetKeyValue("pwd") run(options)
def main(): supportedArgs = [(["h:", "host="], "localhost", "Host name", "host"), (["u:", "user="******"root", "User name", "user"), (["p:", "pwd="], "ca$hc0w", "Password", "pwd"), (["i:", "id="], "1", "ID of client", "id"), (["f:", "flag="], None, "Toggle dispatcher flag", "flag")] supportedToggles = [ (["usage", "help"], False, "Show usage information", "usage"), ] args = arguments.Arguments(sys.argv, supportedArgs, supportedToggles) if args.GetKeyValue("usage") == True: args.Usage() os._exit(1) host = args.GetKeyValue("host") status = "PASS" 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"
def main(): supportedArgs = [ (["h:", "host="], "localhost", "Host name", "host"), (["u:", "user="******"root", "User name", "user"), (["p:", "pwd="], "ca$hc0w", "Password", "pwd"), (["v:", "vmname="], "", "Name of the virtual machine", "vmname"), (["d:", "snapshotdesc="], "Quick Dummy", "Snapshot description", "snapshotdesc"), (["s:", "snapshotname="], "TestSnapshot", "Name of the snapshot", "snapshotname")] supportedToggles = [ (["usage", "help"], False, "Show usage information", "usage"), (["dontDelete", "d"], False, "Dont delete created snapshot", "del")] 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")) # Process command line vmname = args.GetKeyValue("vmname") snapshotname = args.GetKeyValue("snapshotname") snapshotdesc = args.GetKeyValue("snapshotdesc") doDelete = not args.GetKeyValue("del") if len(vmname) == 0 or len(snapshotname) == 0: args.Usage() sys.exit(0) aVm = folder.FindPrefix(vmname)[0] task = aVm.CreateSnapshot(snapshotname, snapshotdesc, memory=False, quiesce=False) snap = aVm.GetSnapshot().currentSnapshot print "Snapshot: %s" % repr(snap) if doDelete: print "Waiting for snapshot to be created: %s ..." % repr(snap) WaitForTask(task) print "Snapshot created. Removing ..." vm.RemoveSnapshot(snap)
def main(): supportedArgs = [ (["h:", "host="], "localhost", "Host name", "host"), (["u:", "user="******"root", "User name", "user"), (["p:", "pwd="], "", "password", "pwd"), (("t:", "test="), "lun", "test lun, vmfs, or nas", "test") ] 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) si = Connect(host=args.GetKeyValue("host"), user=args.GetKeyValue("user"), pwd=args.GetKeyValue("pwd"), version=newestVersions.get('vim')) atexit.register(Disconnect, si) global datastoreSystem datastoreSystem = host.GetHostConfigManager(si).GetDatastoreSystem() global storageSystem storageSystem = host.GetHostConfigManager(si).GetStorageSystem() test = args.GetKeyValue("test") if test == "lun": LunVerify() LunSimpleTest() LunNegativeTest() elif test == "vmfs": VmfsVerify() VmfsSimpleTest() VmfsNegativeTest() elif test == "nas": NasVerify() NasSimpleTest() NasNegativeTest() else: raise Exception("Unsupported test = " + test)
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 main(): supportedArgs = [(["h:", "host="], "localhost", "Host name", "host"), (["u:", "user="******"root", "User name", "user"), (["p:", "pwd="], "", "Password", "pwd")] supportedToggles = [(["burn", "use"], False, "Burn the ticket", "burn"), (["usage", "help"], False, "usage", "usage")] args = arguments.Arguments(sys.argv, supportedArgs, supportedToggles) if args.GetKeyValue("usage") == True: args.Usage() return # Connect si = Connect(host=args.GetKeyValue("host"), user=args.GetKeyValue("user"), pwd=args.GetKeyValue("pwd"), version="vim.version.version10") time.sleep(5) print "VMs found:" for vm1 in folder.GetVmAll(): print " " + str(vm1) print "Selecting VM:" + str(vm1) time.sleep(2) PowerOff(vm1) PowerOn(vm1) # Obtain a ticket print "Obtaining ticket from:" + str(vm1) ticket_ = vm1.AcquireTicket('vmconsole') time.sleep(2) print "Ticket: " + ticket_.ticket
import atexit # Process command line supportedArgs = [ (["h:", "host="], "localhost", "Host name", "host"), (["u:", "user="******"root", "User name", "user"), (["p:", "pwd="], "", "Password", "pwd"), (["v:", "vmname="], "VM01", "Virtual Machine Name", "vmname"), (["d:", "diskInstance="], "scsi0:1", "Disk Instance", "diskInstance"), (["m:", "moduleInstance="], "vfc", "Module Instance", "moduleInstance"), ] 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(host=args.GetKeyValue("host"), user=args.GetKeyValue("user"), pwd=args.GetKeyValue("pwd")) atexit.register(Disconnect, si) vmname = args.GetKeyValue("vmname") vm1 = folder.Find(vmname) content = si.RetrieveContent() dataCenter = content.GetRootFolder().GetChildEntity()[0]
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)
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 main(): supportedArgs = [(["h:", "host="], "localhost", "Host name", "host"), (["u:", "user="******"root", "User name", "user"), (["p:", "pwd="], "", "password", "pwd"), (("t:", "test="), "all", "test Options", "test")] 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) ''' si = Connect(host=args.GetKeyValue("host"), #can be VC too user=args.GetKeyValue("user"), pwd=args.GetKeyValue("pwd"), version=newestVersions.Get('vim')) ''' si = SmartConnect(host=args.GetKeyValue("host"), user=args.GetKeyValue("user"), pwd=args.GetKeyValue("pwd")) atexit.register(Disconnect, si) global datastoreSystem datastoreSystem = host.GetHostConfigManager(si).GetDatastoreSystem() global storageSystem storageSystem = host.GetHostConfigManager(si).GetStorageSystem() test = args.GetKeyValue("test") # print(storageSystem.storageDeviceInfo) if test == "printDS": PrintDatastoreNames() if test == "getLuns": getLuns() if test == "getVolumes": getVolumes() if test == "getDisks": getDisks() if test == "getDS": getDS() if test == "getAll": getLuns() getVolumes() getDisks() getDS() if test == "testVMSpec": testVMSpec() if test == "datastoreSystem": getDS() RemoveDatastores() getDisks() CreateDatastores(diskIDs) if debug: PrintDatastoreNames() pass # for Syntax check in case uncommneted all the up function call #separate different API calls, error prone if test them all together. if test == "storageSystem": getLuns() getVolumes() UnmountVolumes() # must run this twice to successfully do detach UnmountVolumes() UnmountVolumes() UnmountVolumes() UnmountVolumes() DetachLuns() AttachLuns() MountVolumes( ) #must run twice for the host really see the mounts, i.e. #i.e. able to see all ls /vmfs/volume MountVolumes() pass if test == "all": getLuns() getVolumes() getDisks() RemoveDatastores() CreateDatastores(diskIDs) UnmountVolumes() # must run this twice to successfully do detach UnmountVolumes() DetachLuns() AttachLuns() MountVolumes() #must run twice for the host really see the mounts MountVolumes() if test == "removeDS": getDS() RemoveDatastores() if test == "createDS": getDisks() CreateDatastores(diskIDs) if test == "unmount": getVolumes() UnmountVolumes() UnmountVolumes() pass if test == "detach": print("Going to detach, make sure the volumes are unmounted first.") getLuns() DetachLuns() pass if test == "attach": getLuns() AttachLuns() pass if test == "mount": getVolumes() MountVolumes() MountVolumes() pass if test == "rescanVmfs": RescanVmfs() if test == "rescanHBA": RescanHBA() if test == "extra": global vols vols = [] QueryUnresolvedVmfsVolume()
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])
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 main(): status = "PASS" supportedArgs = [ (["H:", "primary host="], "localhost", "Host name", "host"), (["u:", "user="******"root", "User name", "user"), (["p:", "pwd="], "", "Password", "pwd"), (["v:", "vc="], "", "VC Server", "vc"), (["d:", "datastore="], None, "Datastore", "datastore"), ] supportedToggles = [ (["usage", "help"], False, "Show usage information", "usage"), (["sim"], False, "Host simulator", "sim"), ] args = arguments.Arguments(sys.argv, supportedArgs, supportedToggles) if args.GetKeyValue("usage") == True: args.Usage() sys.exit(1) # Process command line global user global pwd user = args.GetKeyValue("user") pwd = args.GetKeyValue("pwd") hostname = args.GetKeyValue("host") vc = args.GetKeyValue("vc") datastore = args.GetKeyValue("datastore") si = None global useVc if vc: useVc = True else: useVc = False global connectHost connectHost = vc if useVc else hostname try: # Connect to host si = Connect() if si is None: raise Exception("Failed to connect to %s" % connectHost) Log("Connected to %s" % connectHost) if useVc: configs = [] configs.append( vim.option.OptionValue(key='config.featureCompat.enable', value='true')) configs.append( vim.option.OptionValue(key='config.featureCompat.enableHWv9', value='true')) si.content.setting.UpdateValues(configs) GetHostByName(si, hostname) Test0(si) Test1(si) Test2(si) Test3(si) Test4(si) Test5(si, datastore) Test6(si) Test7(si) Test8(si, datastore, args.GetKeyValue("sim")) Test9(si) Test10(si) Test11(si, datastore, args.GetKeyValue("sim")) Test12(si) Test13(si) Test14(si, datastore, args.GetKeyValue("sim")) Test15(si, datastore, args.GetKeyValue("sim")) Test16(si) Log("ALL TESTS PASSED") except Exception as e: Log("Caught exception : " + str(e)) traceback.print_exc() status = "FAIL" finally: if si: connect.Disconnect(si) if status == "FAIL": sys.exit(1)
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)