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(argv):
si = Connect()
content = si.RetrieveContent()
rootFolder = content.GetRootFolder()
dataCenter = rootFolder.GetChildEntity()[0]
hostFolder = dataCenter.hostFolder
host = hostFolder.childEntity[0]
hostSystem = host.host[0]
configManager = hostSystem.GetConfigManager()
powerSystem = configManager.GetPowerSystem()
hostConfigInfo = hostSystem.config
if len(argv)>0:
for policy in hostConfigInfo.powerSystemCapability.availablePolicy:
if policy.shortName == argv[0]:
r=powerSystem.ConfigurePowerPolicy(policy.key)
if r == None:
return 0
print r
return 1
print 'Policy shortName "{0}" not found.'.format(argv[0])
return 1
else:
print "{0:4} {1:10} {2:10} {3}".format("key", "current", "shortName","name")
for policy in hostConfigInfo.powerSystemCapability.availablePolicy:
print "{0!s:4} {1!r:10} {2:10} {3}".format(policy.key, policy.name == hostConfigInfo.powerSystemInfo.currentPolicy.name, policy.shortName, policy.name)
return 0
class TestCompressedMemoryQuickStats(unittest.TestCase):
def setOptions(self, options):
"""
Command line options
"""
self.options = options
def setUp(self):
"""
Setting test suite
"""
options = get_options()
self.si = Connect(host=self.options.host,
user=self.options.user,
version="vim.version.version9",
pwd=self.options.password)
def tearDown(self):
"""
Reset test suite
"""
Disconnect(self.si)
def runTest(self):
self.TestVMQuickStats()
self.TestRPQuickStats()
def TestVMQuickStats(self):
"""
Check if all the precreated powered-on Vms use compressed
memory.
"""
content = self.si.RetrieveContent()
rootFolder = content.GetRootFolder()
dataCenter = rootFolder.GetChildEntity()[0]
vmFolder = dataCenter.vmFolder
self.assertTrue(len(vmFolder.childEntity) > 0)
for vm in vmFolder.childEntity:
self.assertTrue(vm.summary.quickStats.compressedMemory > 0)
print('compressedMemory: %d' %
vm.summary.quickStats.compressedMemory)
def TestRPQuickStats(self):
"""
This is not being used now as hostd does not
set up resource pool quickstats.
"""
content = self.si.RetrieveContent()
rootFolder = content.GetRootFolder()
dataCenter = rootFolder.GetChildEntity()[0]
hostFolder = dataCenter.hostFolder
for c in hostFolder.childEntity:
print(c)
if isinstance(c, Vim.ComputeResource):
pool = c.resourcePool
def setUp(self):
"""
Setting test suite
"""
options = get_options()
self.si = Connect(host=self.options.host,
user=self.options.user,
version="vim.version.version9",
pwd=self.options.password)
def getHostProfileEngine():
options = get_options()
global _si
if _si:
Disconnect(_si)
_si = Connect(host=options.host,
user=options.user,
version="vim.version.version9",
pwd=options.password)
return _si.RetrieveInternalContent().hostProfileEngine
def main():
si=Connect(host="10.10.225.151",port=443,user="******",pwd="XtremIO123!")
content=si.RetrieveContent()
datacenter=content.rootFolder.childEntity[0]
hostList=datacenter.hostFolder.childEntity
for host in hostList:
print host.host[0].name
esxHostThread = collectVcPerfThread("TestThread",hostList[1].host[0],content)
esxHostThread.start()
time.sleep(300)
esxHostThread.threadStatus = "Halt"
print "stopping VC perfmon collector"
def main():
"""
Simple command-line program for dumping the host config.
"""
options = GetOptions()
serviceInstance = Connect(host=options.host,
user=options.user,
pwd=options.password)
content = serviceInstance.RetrieveContent()
dataCenter = content.GetRootFolder().GetChildEntity()[0]
hostFolder = dataCenter.GetHostFolder()
computeResource = hostFolder.GetChildEntity()[0]
hostSystem = computeResource.GetHost()[0]
hostConfigManager = hostSystem.GetConfigManager()
print(hostConfigManager)
optManager = hostConfigManager.GetAdvancedOption()
print(optManager)
optionValue = []
optionValue = optManager.QueryView("RdmFilter.HbaIsShared")
print("Get OptionValue ")
print(optionValue)
print("Now setting the value to true")
allOptions = []
opt = Vim.Option.OptionValue()
opt.SetKey("RdmFilter.HbaIsShared")
opt.SetValue(True)
allOptions.append(opt)
optManager.UpdateValues(allOptions)
print("validate that value get set to true")
optionValue = optManager.QueryView("RdmFilter.HbaIsShared")
print("Get OptionValue ")
print(optionValue)
print("Now setting the value to false")
allOptions = []
opt = Vim.Option.OptionValue()
opt.SetKey("RdmFilter.HbaIsShared")
opt.SetValue(False)
allOptions.append(opt)
optManager.UpdateValues(allOptions)
print("validate that value get set to false")
optionValue = optManager.QueryView("RdmFilter.HbaIsShared")
print("Get OptionValue ")
print(optionValue)
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 GetParams(hostName, userName, password):
try:
siHost = Connect(host=hostName,
user=userName,
pwd=password,
version="vim.version.version9")
except vim.fault.HostConnectFault:
Log("Failed to connect to %s" % hostName)
raise
atexit.register(Disconnect, siHost)
perfManager = siHost.RetrieveContent().perfManager
hostSystem = host.GetHostSystem(siHost)
hbrManager = siHost.RetrieveInternalContent().hbrManager
return siHost, perfManager, hostSystem, hbrManager
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", "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 setUp(self):
self.host, self.numClients, self.loopLimit = stressutil.processLoopArgs()
si = Connect(self.host)
self.vmList = folder.GetAll()
vm.PowerOffAllVms(self.vmList)
self.setUpArgs()
def main():
"""
Simple command-line program for creating virtual machines on a
system managed by hostd.
"""
options = GetOptions()
Connect(host=options.host, user=options.user, pwd=options.password)
# Create vms
envBrowser = GetEnv()
cfgOption = envBrowser.QueryConfigOption(None, None)
cfgTarget = envBrowser.QueryConfigTarget(None)
for i in range(int(options.num_iterations)):
vm1 = vm.CreateQuickDummy(options.vm_name + "_" + str(i),
options.num_scsi_disks,
options.num_ide_disks,
datastoreName=options.datastore_name,
cfgOption=cfgOption,
cfgTarget=cfgTarget)
for _ in range(int(options.num_power_cycles)):
clock = StopWatch()
vm.PowerOn(vm1)
clock.finish("PowerOn done")
clock = StopWatch()
vm.PowerOff(vm1)
clock.finish("PowerOff done")
# Delete the vm as cleanup
if not options.dont_delete:
task = vm1.Destroy()
WaitForTask(task)
def main():
global options
global si
options, remainingOptions = ParseArguments(sys.argv[1:])
# Connect
try:
si = Connect(host=options.host, port=int(options.port),
user=options.user, pwd=options.pwd,
keyFile=options.keyFile, certFile=options.certFile)
except Exception as err:
print("Login failed: " + str(err))
return
atexit.register(Disconnect, si)
status = "PASS"
# Parallel or serialize operations
global threadPool
threadPool = ThreadPool(maxWorkers=options.workers)
startTime = None
endTime = None
try:
# si content
content = si.RetrieveContent()
startTime = time.time()
# Connection limit Test
TestConnectionLimit(si, Vim.Folder, [content.rootFolder], options)
endTime = time.time()
except Exception as err:
Log("Failed test due to exception: " + str(err))
import traceback
stackTrace = " ".join(traceback.format_exception(
sys.exc_type, sys.exc_value, sys.exc_traceback))
Log(stackTrace)
status = "FAIL"
if threadPool:
threadPool.Shutdown()
if startTime and endTime:
Log("Total test time: %f secs" % (endTime - startTime))
Log("TEST RUN COMPLETE: " + status)
def main():
"""
Simple command-line program for creating virtual machines on a
system managed by hostd.
"""
options = GetOptions()
Connect(host=options.server,
user=options.user,
pwd=options.password)
dsList = {}
vms = folder.FindPrefix(options.vm_name)
print ""
print "---------------------------- "
print "Virtual machine information: "
print "---------------------------- "
for vm1 in vms:
print ""
vm1.RefreshStorageInfo()
name = vm1.GetName()
layoutEx = vm1.GetLayoutEx()
storageInfo = vm1.GetStorage()
storageSummary = vm1.GetSummary().GetStorage()
print "Virtual machine name: " + name
print "Layout: (retrieved at %s)" % (str(layoutEx.GetTimestamp()))
files = layoutEx.GetFile()
print "%-40s %-20s %20s" \
% ("File name", "File type", "File size")
print "%-40s %-20s %20s" \
% ("---------", "---------", "---------")
for file in files:
size = getNiceSize(file.size)
print "%-40s %-20s %20s" \
% (file.name, file.type, size)
print ""
print "Summary: (retrieved at %s)" % str(storageSummary.GetTimestamp())
print "Committed: %s\tUncommitted: %s\tUnshared: %s" \
% (getNiceSize(storageSummary.committed), \
getNiceSize(storageSummary.uncommitted), \
getNiceSize(storageSummary.unshared))
print ""
print "Storage information: (retrieved at %s)" \
% str(storageInfo.GetTimestamp())
usages = storageInfo.GetPerDatastoreUsage()
print "%-30s %25s %25s %20s" % ("Datastore name", "Committed", \
"Uncommitted", "Unshared")
print "%-30s %25s %25s %20s" % ("--------------", "---------", \
"-----------", "--------")
for dsUsage in usages:
print "%-30s %25s %25s %20s" \
% (dsUsage.datastore.summary.name, getNiceSize(dsUsage.committed),
getNiceSize(dsUsage.uncommitted), getNiceSize(dsUsage.unshared))
dsList[dsUsage.datastore.summary.name] = dsUsage.datastore
print ""
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 setUp(self):
"""
Setting test suite
"""
options = get_options()
self.si = Connect(host=self.options.host,
user=self.options.user,
version="vim.version.version9",
pwd=self.options.password)
self.content = self.si.RetrieveContent()
self.internalContent = self.si.RetrieveInternalContent()
rootFolder = self.content.GetRootFolder()
dataCenter = rootFolder.GetChildEntity()[0]
hostFolder = dataCenter.hostFolder
host = hostFolder.childEntity[0]
self.hostSystem = host.host[0]
configManager = self.hostSystem.GetConfigManager()
self.advOptions = configManager.advancedOption
def setUp(self):
"""
Setting test suite
"""
options = get_options()
self.si = Connect(host=self.options.host,
user=self.options.user,
version=newestVersions.get("vim"),
pwd=self.options.password)
content = self.si.RetrieveContent()
rootFolder = content.GetRootFolder()
dataCenter = rootFolder.GetChildEntity()[0]
hostFolder = dataCenter.hostFolder
host = hostFolder.childEntity[0]
self.hostSystem = host.host[0]
configManager = self.hostSystem.GetConfigManager()
self.imageConfigManager = configManager.GetImageConfigManager()
self.hostConfigInfo = self.hostSystem.config
def main():
"""
Simple command-line program for listing the virtual machines on a
system managed by hostd.
"""
options = GetOptions()
Connect(host=options.host, user=options.user, pwd=options.password)
for vm in folder.FindPrefix(options.vmprefix):
PrintVmInfo(vm)
def main():
"""
Simple command-line program for dumping the host config.
"""
options = GetOptions()
serviceInstance = Connect(host=options.host,
user=options.user,
pwd=options.password)
host.DumpHostConfig(serviceInstance)
def setUp(self):
"""
Setting test suite
"""
self.options = get_options()
self.si = Connect(host=self.options.host,
user=self.options.user,
version="vim.version.version9",
pwd=self.options.password)
content = self.si.RetrieveContent()
rootFolder = content.rootFolder
dataCenter = rootFolder.childEntity[0]
hostFolder = dataCenter.hostFolder
host = hostFolder.childEntity[0]
self.hostSystem = host.host[0]
self.assertTrue(self.hostSystem != None,
"hostSystem should not be None.")
self.advancedOption = self.hostSystem.configManager.advancedOption
self.assertTrue(self.advancedOption != None,
"advancedOption should not be None.")
def main():
# Process command line
global options
options = GetOptions()
si = Connect(host=options.host,
user=options.user,
namespace=newestVersions.GetNamespace('vim'),
pwd=options.password)
if not options.keep:
# If we are going to keep the queries we should not disconnect
# because the sessions will be destroyed together with all queries.
atexit.register(Disconnect, si)
hsi = si.RetrieveInternalContent()
srEndpoints = hsi.GetStatsRegistry()
for sr in srEndpoints:
if options.endpoint is None or sr._GetMoId() == options.endpoint:
TestStatsRegistryEndpoint(sr)
if not options.keep:
ClearQueries(sr)
def run(self): si = Connect(_host) print "== Client ", str(self.id), " connected to host" while(1): try: if self.status == "kill": break print "== Client ", str(self.id), " running operation Toggle", str(self.toggle) self.RunToggleOp() except Exception, e: print "Failed test due to exception:", str(e) self.status = "fail" self.CompleteOp()
def GetParams(hostName, userName, password):
try:
siHost = Connect(host=hostName,
user=userName,
pwd=password,
version="vim.version.version9")
except vim.fault.HostConnectFault as e:
Log("Failed to connect to %s" % hostName)
raise
atexit.register(Disconnect, siHost)
hostSystem = host.GetHostSystem(siHost)
advOpts = hostSystem.configManager.advancedOption
return siHost, hostSystem, advOpts
def main():
# Process command line
host = "jairam-esx"
if len(sys.argv) > 1:
host = sys.argv[1]
try:
si = Connect(host)
atexit.register(Disconnect, si)
vm.CreateQuickDummy("CpuIdTest")
v1 = folder.Find("CpuIdTest")
print("Created a dummy")
# Print current.
print(v1.GetConfig().GetCpuFeatureMask())
# Change level 0 and level 80
config = Vim.Vm.ConfigSpec()
lvl0 = Vim.Vm.ConfigSpec.CpuIdInfoSpec()
info = Vim.Host.CpuIdInfo()
info.SetLevel(0)
info.SetEax("XXXX:XXXX:XXXX:XXXX:XXXX:XXXX:XXXX:XXXX")
info.SetEbx("XXXX:XXXX:XXXX:XXXX:XXXX:XXXX:XXXX:XXXX")
info.SetEcx("XXXX:XXXX:XXXX:XXXX:XXXX:XXXX:XXXX:XXXX")
info.SetEdx("XXXX:XXXX:XXXX:XXXX:XXXX:XXXX:XXXX:XXXX")
lvl0.SetOperation("add")
lvl0.SetInfo(info)
lvl1 = Vim.Vm.ConfigSpec.CpuIdInfoSpec()
info2 = Vim.Host.CpuIdInfo()
info2.SetLevel(1)
info2.SetVendor("amd")
info2.SetEax("XXXX:XXXX:XXXX:XXXX:XXXX:XXXX:XXXX:XXXX")
info2.SetEdx("XXXX:XXXX:XXXX:XXXX:XXXX:XXXX:XXXX:XXXX")
lvl1.SetOperation("add")
lvl1.SetInfo(info2)
config.SetCpuFeatureMask([lvl0, lvl1])
print("Assigned features")
task = v1.Reconfigure(config)
if WaitForTask(task) == "error":
raise task.GetInfo().GetError()
vm.Destroy(v1)
except Exception as e:
print("Failed test due to exception: %s" % e)
raise
def CreateSession(self, headers, soapHost, soapPort, namespace):
(username, password) = self._GetHttpCredentials(headers)
if not username:
return None
print "CreateSession: connecting as user '%s'" % username
try:
si = Connect(host=soapHost,
port=soapPort,
user=username,
pwd=password,
namespace=namespace)
sessionCookie = si._stub.cookie
print "CreateSession: using new cookie '%s'" % sessionCookie
return sessionCookie
except Exception, e:
print "CreateSession: connect failed -- '%s'" % str(e)
return None
def main():
"""
Simple command-line program for listing the virtual machines on a
system managed by hostd.
"""
options = GetOptions()
si = Connect(host=options.host,
user=options.user,
pwd=options.password,
port=int(options.port),
namespace="vim25/5.5")
atexit.register(Disconnect, si)
for vm in folder.FindPrefix(options.vmprefix):
PrintVmInfo(vm)
def main():
"""
Simple command-line program for creating virtual machines on a
system managed by hostd.
"""
options = GetOptions()
Connect(host=options.host,
user=options.user,
namespace=newestVersions.GetNamespace('vim'),
pwd=options.password)
# Create vms
envBrowser = GetEnv()
cfgOption = envBrowser.QueryConfigOption(None, None)
cfgTarget = envBrowser.QueryConfigTarget(None)
for i in range(int(options.num_iterations)):
vm1 = vm.CreateQuickDummy(options.vm_name + "_" + str(i),
options.num_scsi_disks,
options.num_ide_disks,
datastoreName=options.datastore_name,
cfgOption=cfgOption,
cfgTarget=cfgTarget)
if options.opaquenetwork_id:
config = Vim.Vm.ConfigSpec()
config = vmconfig.AddOpaqueNetwork(config, cfgOption, opaqueNetworkId=options.opaquenetwork_id, \
opaqueNetworkType=options.opaquenetwork_type, \
externalId=options.externalID)
vm.Reconfigure(vm1, config)
for _ in range(int(options.num_power_cycles)):
clock = StopWatch()
vm.PowerOn(vm1)
clock.finish("PowerOn done")
clock = StopWatch()
vm.PowerOff(vm1)
clock.finish("PowerOff done")
# Delete the vm as cleanup
if not options.dont_delete:
task = vm1.Destroy()
WaitForTask(task)
def main():
options, remainingOptions = ParseArgs(sys.argv[1:])
# Connect
si = Connect(host=options.host,
user=options.user,
pwd=options.pwd,
version="vim.version.version9")
atexit.register(Disconnect, si)
if options.verbose:
logger.setLevel(logging.DEBUG)
status = "PASS"
for i in range(options.iter):
try:
logger.info("Starting iteration %d." % (i + 1))
vm1 = None
logger.debug("Cleaning up VMs from previous runs...")
vm.Delete(options.vmname, True)
logger.debug("Creating Hw7 VM..")
vm1 = vm.CreateQuickDummy(options.vmname,
vmxVersion="vmx-07",
memory=4,
guest="rhel5Guest")
logger.debug("Adding an extra config setting to the VM")
SetExtraConfig(vm1, options.key, options.val1)
logger.debug("Editing an extra config setting on the VM")
SetExtraConfig(vm1, options.key, options.val2)
logger.debug("Adding a bogus extra config setting on the VM")
SetExtraConfig(vm1, options.invalidKey, "", False)
logger.debug("Destroying VM")
vm.Delete(options.vmname, True)
logger.info("End of iteration %d." % (i + 1))
except Exception as e:
logger.error("Caught exception : " + str(e))
status = "FAIL"
logger.info("TEST RUN COMPLETE: " + status)
def main():
# connect to vc, host
vc = "10.161.250.162"
user1 = "*****@*****.**"
pwd1 = "Admin!23"
si = Connect(host=vc,
user=user1,
pwd=pwd1,
version=newestVersions.get('vim'))
print("Connected to VC: " + vc)
host, hostSystem, dc = VerifySetup(si)
vimInternalNs = newestVersions.GetInternalNamespace('vim')
session = CreateSession(vc, '443', user1, pwd1, vimInternalNs)
# ds0 should be a vmfs 6 datastore
ds0 = session.GetDatastore(host, "ds0")
#hwversion test
hwVersionTest(host, hostSystem, ds0, dc, session)
