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 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
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():
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():
# 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():
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)
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]
hostFolder = dataCenter.GetHostFolder()
computeResource = hostFolder.GetChildEntity()[0]
hostSystem = computeResource.GetHost()[0]
diskInstance = args.GetKeyValue("diskInstance")
moduleInstance = args.GetKeyValue("moduleInstance")
perfManager = content.GetPerfManager()
counterInfos = perfManager.perfCounter
def main():
# test vFC disk stats
test1()
class TestImageConfigManager(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=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 tearDown(self):
"""
Reset test suite
"""
Disconnect(self.si)
def runTest(self):
self.test_getacceptance()
self.test_getprofileinfo()
self.test_setacceptance()
self.test_FetchSoftwarePackages()
self.test_InstallDate()
def test_getacceptance(self):
self.assertTrue(self.imageConfigManager != None)
acceptance = self.imageConfigManager.QueryHostAcceptanceLevel()
print("\nHost acceptance level: %s" % acceptance)
def test_getprofileinfo(self):
self.assertTrue(self.imageConfigManager != None)
profile = self.imageConfigManager.QueryHostImageProfile()
print("\nHost profile name: %s" % profile.name)
print("\nHost profile vendor: %s" % profile.vendor)
def test_setacceptance(self):
self.assertTrue(self.imageConfigManager != None)
self.assertRaises(Vim.fault.HostConfigFault,
self.imageConfigManager.UpdateAcceptanceLevel,
"blah - not a valid level")
def test_FetchSoftwarePackages(self):
self.assertTrue(self.imageConfigManager != None)
vibs = self.imageConfigManager.FetchSoftwarePackages()
print("\nHave %d vibs installed" % (len(vibs)))
self.assertTrue(len(vibs) > 0)
print("\nExample entry: %s" % (str(vibs[0])))
def test_InstallDate(self):
self.assertTrue(self.imageConfigManager != None)
when = self.imageConfigManager.InstallDate()
print("\nHost software inception date: %s" % (when))
class TestApplyHostConfig(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)
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.cacheConfigManager = configManager.cacheConfigurationManager
self.hostProfileEngine = self.internalContent.hostProfileEngine
self.profileManager = self.hostProfileEngine.hostProfileManager
def tearDown(self):
"""
Reset test suite
"""
Disconnect(self.si)
def runTest(self):
self.TestApplyEmptyConfig()
def TestApplyEmptyConfig(self):
"""
Applies an empty config and check if property update on
CacheConfigurationManager is fired.
"""
self.assertTrue(self.cacheConfigManager != None,
"cacheConfigManager should not be None")
self.assertTrue(self.profileManager != None,
"profileManager should not be None")
# Prepare property collector
objSpec = Vmodl.Query.PropertyCollector.ObjectSpec(
obj=self.cacheConfigManager, skip=False, selectSet=[])
propSpec = Vmodl.Query.PropertyCollector.PropertySpec(
type=self.cacheConfigManager.__class__,
all=False,
pathSet=["cacheConfigurationInfo"])
filterSpec = Vmodl.Query.PropertyCollector.FilterSpec(
propSet=[propSpec], objectSet=[objSpec])
filter = self.content.propertyCollector.CreateFilter(filterSpec, False)
# First initial call
updateSet = self.content.propertyCollector.WaitForUpdates()
version = updateSet.version
# ApplyHostConfig
spec = Vim.Host.ConfigSpec()
task = self.profileManager.ApplyHostConfig(configSpec=spec)
WaitForTask(task)
self.assertTrue(task.info.state == 'success',
"Reconfiguration task should succeed")
# Set up wait time and trigger update
waitSpec = Vmodl.Query.PropertyCollector.WaitOptions()
waitSpec.maxWaitSeconds = 5
updateSet = self.content.propertyCollector.WaitForUpdatesEx(
version, waitSpec)
self.assertTrue(updateSet != None,
"we should get property collector update")
def main():
# Process command line
options = GetOptions()
serviceInstance = Connect(
host=options.host,
user=options.user,
# namespace = "vim25/dev2",
pwd=options.password)
atexit.register(Disconnect, serviceInstance)
content = serviceInstance.RetrieveContent()
isESX = content.GetAbout().GetApiType() == "HostAgent"
perfMgr = content.perfManager
rootFolder = content.GetRootFolder()
metricIds = []
idToNameMap = {}
nameToIdMap = {}
countersToEnable = []
# Just in case - take all available counters on the server
perfCounters = perfMgr.perfCounter
try:
perfCounters += perfMgr.QueryPerfCounterInt()
print "Counters available on the host (%d):" % (len(perfCounters))
for cntr in perfCounters:
print "%d -> %s.%s [%s]" % (cntr.key, cntr.groupInfo.key,
cntr.nameInfo.key, cntr.unitInfo.key)
except:
pass
STATS_TO_QUERY = []
for cntrInfo in perfCounters:
statGroup = cntrInfo.groupInfo.key
statName = statGroup + "." + cntrInfo.nameInfo.key
enabled = True if cntrInfo.key >= 0 else cntrInfo.enabled
idToNameMap[cntrInfo.key] = (statName, enabled,
cntrInfo.unitInfo.label)
nameToIdMap[statName] = cntrInfo.key
#if statGroup == 'cpu':
if cntrInfo.key < 0:
STATS_TO_QUERY.append(statName)
for statToQuery in STATS_TO_QUERY:
if statToQuery in nameToIdMap:
counterId = nameToIdMap[statToQuery]
metricId = pyVmomi.Vim.PerformanceManager.MetricId()
metricId.counterId = counterId
metricId.instance = "*"
metricIds.append(metricId)
enabled = idToNameMap[counterId][1]
print "Requesting counterID=%12d ('%40s') which %s" % (
counterId, statToQuery,
"is already enabled" if enabled else "must be enabled")
if not isESX or not enabled:
countersToEnable.append(counterId)
# TODO: perfMgr.EnableStat should be used only against HostD.
# Different mechanism is needed for VpxD.
if len(countersToEnable) > 0:
print "Enabling counters '%s'..." % (countersToEnable)
if not isESX:
newLevelMappings = []
for counterToEnable in countersToEnable:
currentLevelMapping = pyVmomi.Vim.PerformanceManager.CounterLevelMapping(
)
currentLevelMapping.counterId = counterToEnable
currentLevelMapping.aggregateLevel = 1
newLevelMappings.append(currentLevelMapping)
perfMgr.UpdateCounterLevelMapping(newLevelMappings)
else:
perfMgr.EnableStat(countersToEnable)
print "...will be available shortly - HostD needs some time to start collecting these!"
summarySpecs = []
hostsNames = {}
virtualMachines = {}
#
# Create queries for all VMs from all available data-centers
# This is working against both: HostD and VpxD
#
dataCenters = rootFolder.GetChildEntity()
for dataCenter in dataCenters:
dataCenterName = dataCenter.GetName()
vmsFolder = dataCenter.GetVmFolder()
vms = vmsFolder.GetChildEntity()
if vms:
for virtualMachine in vms:
if isinstance(virtualMachine, pyVmomi.vim.VirtualMachine):
virtualMachineName = virtualMachine.GetName()
virtualMachines[virtualMachine] = virtualMachineName
print "Requesting for %s ('%s') from %s ('%s')" % (
virtualMachine, virtualMachineName, dataCenter,
dataCenterName)
vmQuerySpec = pyVmomi.Vim.PerformanceManager.QuerySpec()
vmQuerySpec.entity = virtualMachine
vmQuerySpec.intervalId = SUMMARY_INTERVALID
vmQuerySpec.format = pyVmomi.Vim.PerformanceManager.Format.csv
vmQuerySpec.metricId = metricIds
summarySpecs.append(vmQuerySpec)
else:
print "No VMs found for %s ('%s')!" % (dataCenter, dataCenterName)
hostsFolder = dataCenter.GetHostFolder()
computeResources = hostsFolder.GetChildEntity()
for computeResource in computeResources:
hosts = computeResource.GetHost()
for host in hosts:
hostName = host.GetName()
hostsNames[host] = hostName
print "Requesting for %s ('%s') from %s in %s ('%s')" % (
host, hostName, computeResource, dataCenter,
dataCenterName)
hostQuerySpec = pyVmomi.Vim.PerformanceManager.QuerySpec()
hostQuerySpec.entity = host
hostQuerySpec.intervalId = SUMMARY_INTERVALID
hostQuerySpec.format = pyVmomi.Vim.PerformanceManager.Format.csv
hostQuerySpec.metricId = metricIds
summarySpecs.append(hostQuerySpec)
querySpecs = copy.deepcopy(summarySpecs)
for spec in querySpecs:
# real-time interval
spec.intervalId = 20
# we need only one sample - the last one
spec.maxSample = 1
# Request Format.normal - we don't want to convert string to int64
spec.format = pyVmomi.Vim.PerformanceManager.Format.normal
lastSummarized = 0
summaryIteration = 1
queryIteration = 1
prevTime = None
while True:
print "=" * 80
# Query current value of the stats on every QUERY_INTERVAL seconds...
queryResult = perfMgr.QueryStats(querySpecs)
print "Last samples (iteration=%d):" % (queryIteration)
for entityMetric in queryResult:
for series in entityMetric.value:
counterId = series.id.counterId
instanceStr = series.id.instance
statName = idToNameMap[counterId][0]
entity = entityMetric.entity
if isinstance(entity, pyVmomi.vim.VirtualMachine):
entityName = virtualMachines[entity]
else:
entityName = hostsNames[entity]
unit = idToNameMap[counterId][2]
# Last sample
statValue = series.value[-1]
# -1 is special value returned by vim.PerformanceManager indicating unavailable stat
if statValue > -1:
if unit == '%':
# Percent is returned as a 100ths of percent in integer value (e.g. 56.78% == 5678)
print "%12d -> %40s('%s', '%s') = %.2f %s" % (
counterId, statName, entityName, instanceStr,
statValue / 100.0, unit)
else:
# All other values are always positive
print "%12d -> %40s('%s', '%s') = %d %s" % (
counterId, statName, entityName, instanceStr,
statValue, unit)
else:
print "%12d -> %40s('%s', '%s') = N/A" % (
counterId, statName, entityName, instanceStr)
if isESX:
# ...and summarize them on every SUMMARY_INTERVAL seconds.
if lastSummarized == 0:
# Always take the server local time (this is very important for VpxD connection)
nowOnServer = serviceInstance.CurrentTime().replace(tzinfo=utc)
startTime = (nowOnServer - timedelta(seconds=SUMMARY_INTERVAL)
) if not prevTime else prevTime
endTime = nowOnServer
for spec in summarySpecs:
spec.startTime = startTime
spec.endTime = endTime
prevTime = endTime
summaryResult = perfMgr.SummarizeStats(summarySpecs)
print "Summarized stats (iteration=%d) from '%s' to '%s'" % (
summaryIteration, startTime, endTime)
#print summaryResult
summaryIteration = summaryIteration + 1
time.sleep(QUERY_INTERVAL)
queryIteration = queryIteration + 1
lastSummarized = lastSummarized + QUERY_INTERVAL
if lastSummarized >= SUMMARY_INTERVAL:
lastSummarized = 0
def main():
supportedArgs = [(["h:", "VC host="], "localhost", "Host name", "host"),
(["u:", "user="******"root", "User name", "user"),
(["p:", "pwd="], "ca$hc0w", "Password", "pwd"),
(["v:", "vmname="], "VMotionTest",
"Name of the virtual machine", "vmname"),
(["i:", "numiter="], "1", "Number of iterations", "iter"),
(["s:", "source="], "", "Source host", "src"),
(["d:", "dest="], "", "Destination host", "dest")]
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)
logging.basicConfig(level=logging.INFO,
format='%(asctime)s %(levelname)s %(message)s')
# Connect
si = Connect(host=args.GetKeyValue("host"),
user=args.GetKeyValue("user"),
pwd=args.GetKeyValue("pwd"))
if args.GetKeyValue("src") == "" or args.GetKeyValue("dest") == "":
logging.error("Both source and destination hosts must be specified")
args.Usage()
sys.exit(-1)
# Virtual machine name
vmname = args.GetKeyValue("vmname")
# Number of iterations to run
iterations = int(args.GetKeyValue("iter"))
searchIndex = si.RetrieveContent().GetSearchIndex()
# Find the source host
srcName = args.GetKeyValue("src")
src = findHost(srcName, searchIndex)
if src == None:
logging.error("Couldnt find the source host: " + srcName)
sys.exit(-1)
# Find the destination host
destName = args.GetKeyValue("dest")
dest = findHost(destName, searchIndex)
if dest == None:
logging.error("Couldnt find the destination host: " + destName)
sys.exit(-1)
sourceHostName = src.GetSummary().GetConfig().GetName()
destHostName = dest.GetSummary().GetConfig().GetName()
# Find the virtual machine
vmotionVM = None
vms = src.GetVm()
vmotionVM = searchHostForVm(vmname, src)
if vmotionVM == None:
vmotionVM = searchHostForVm(vmname, dest)
if vmotionVM != None:
# Switch up source and destination
temp = src
src = dest
dest = temp
# If the virtual machine doesnt exist, create it.
create = 0
if vmotionVM == None:
vmotionVM = createSuitableVm(src, dest, vmname)
create = 1
else:
# Verify the vm is on a datastore available on both hosts
dsList = vmotionVM.GetDatastore()
for ds in dsList:
if len([a for a in src.GetDatastore() \
if a.GetSummary().GetUrl() == ds.GetSummary().GetUrl() ]) == 0:
logging.error("Part of the virtual machine is on: " \
+ ds.GetSummary().GetName() + " which is not accessible on: " \
+ sourceHostName)
sys.exit(-1)
if len([a for a in dest.GetDatastore() \
if a.GetSummary().GetUrl() == ds.GetSummary().GetUrl() ]) == 0:
logging.error("Part of the virtual machine is on: " \
+ ds.GetSummary().GetName() + " which is not accessible on: " \
+ destHostName)
sys.exit(-1)
# power it on
if vmotionVM.GetRuntime().GetPowerState(
) != Vim.VirtualMachine.PowerState.poweredOn:
vimutil.InvokeAndTrack(vmotionVM.PowerOn)
# resource pools
srcRp = src.GetParent().GetResourcePool()
destRp = dest.GetParent().GetResourcePool()
# All systems are go
logging.info("Ready for vmotion")
timetaken = datetime.timedelta()
backwardsTime = datetime.timedelta()
for i in range(iterations):
# ping
res = doVmotion(vmotionVM, dest, destHostName,
Vim.VirtualMachine.MovePriority.highPriority, destRp)
if res[0] != None:
print "Failure source: " + sourceHostName + ", destination: " + destHostName
break
timetaken = timetaken + res[1]
# pong
res = doVmotion(vmotionVM, src, sourceHostName,
Vim.VirtualMachine.MovePriority.highPriority, srcRp)
if res[0] != None:
print "Failure source: " + destHostName + ", destination: " + sourceHostName
break
backwardsTime = backwardsTime + res[1]
logging.info("Iteration completed: " + str(i))
logging.info("Summary: ")
logging.info("Ping pongs requested (2 vmotions): " + str(iterations))
logging.info("Virtual machine name: " + vmname)
logging.info("Host 1: " + sourceHostName)
logging.info("Host 2: " + destHostName)
logging.info("Successful ping/pongs (2 vmotions): " + str(i + 1))
logging.info("Avg. time going from source to destination (seconds): " + \
str(timetaken.seconds/iterations))
logging.info("Avg. time going from destination to source (seconds): " + \
str(backwardsTime.seconds/iterations))
logging.info("Total time: " + str(timetaken + backwardsTime))
logging.info("Avg. time for vmotion (seconds): " + \
str((backwardsTime + timetaken).seconds/(iterations * 2)))
if create == 1:
# Cleanup behind self
vimutil.InvokeAndTrack(vmotionVM.PowerOff)
vmotionVM.Destroy()
def getVmwServiceContent(vcip, vcuser, vcpwd):
unverified_context = ssl._create_unverified_context
ssl._create_default_https_context = unverified_context
si = Connect(host=vcip, port=443, user=vcuser, pwd=vcpwd)
return si.RetrieveContent()
class TestSyslogAdvancedSettings(unittest.TestCase):
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 tearDown(self):
"""
Reset test suite
"""
Disconnect(self.si)
def runTest(self):
# self.TestDeprecatedOptions()
self.TestGlobalOptions()
self.TestLogDirChange()
def TestDeprecatedOptions(self):
"""
Test the behaviour of deprecated options.
"""
print("\nTest deprecated options")
# save original logHost
ov = self.advancedOption.QueryView("Syslog.global.logHost")
savedLogHost = ov[0].value
# change logHost
ov[0].value = "127.0.0.1:333, localhost"
if len(savedLogHost) > 0:
ov[0].value = ov[0].value + ", " + savedLogHost
self.advancedOption.UpdateValues(ov)
try:
# verify Hostname and Port
ov = self.advancedOption.QueryView("Syslog.Remote.Hostname")
self.assertTrue(ov[0].value == "127.0.0.1",
"Hostname must be '127.0.0.1'.")
ov = self.advancedOption.QueryView("Syslog.Remote.Port")
self.assertTrue(ov[0].value == 333, "Port must be 333.")
finally:
# restore logHost
ov[0].key = "Syslog.global.logHost"
ov[0].value = savedLogHost
self.advancedOption.UpdateValues(ov)
def TestGlobalOptions(self):
"""
Test new global options
"""
print("\nTest global options")
# save original defaultRotate
ov = self.advancedOption.QueryView("Syslog.global.defaultRotate")
savedDefRotate = ov[0].value
# change defaultRotate
ov[0].value = 33
self.advancedOption.UpdateValues(ov)
try:
# verify vmkernel.rotate = new value
ov = self.advancedOption.QueryView(
"Syslog.loggers.vmkernel.rotate")
self.assertTrue(ov[0].value == 33, "vmkernel.rotate must be 33.")
finally:
# restore defaultRotate
ov[0].key = "Syslog.global.defaultRotate"
ov[0].value = savedDefRotate
self.advancedOption.UpdateValues(ov)
def TestLogDirChange(self):
"""
Test changing the location of log output.
"""
print("\nTest logdir option")
# save original logDir
ov = self.advancedOption.QueryView("Syslog.global.logDir")
savedLogDir = ov[0].value
# change logDir
ov[0].key = "Syslog.global.logDir"
testLogDir = "/tmp/log_test_%d" % time.time()
ov[0].value = "[] " + testLogDir
self.advancedOption.UpdateValues(ov)
try:
# Write a message to Vpxa log
message = "TEST_LOG_MESSAGE_%d" % time.time()
retval = os.system("logger -t Vpxa %s" % message)
self.assertTrue(retval == 0, "retval = %d, must be 0." % retval)
# Find the above message in vpxa.log file
vpxaLogFile = testLogDir + "/vpxa.log"
for i in range(3):
time.sleep(1)
retval = os.system("grep -q '%s' %s" % (message, vpxaLogFile))
if retval == 0:
break
self.assertTrue(
retval == 0, "Message '%s' not found in file '%s'." %
(message, vpxaLogFile))
finally:
# restore logDir
ov[0].key = "Syslog.global.logDir"
ov[0].value = savedLogDir
self.advancedOption.UpdateValues(ov)
class TestEsxCLI(unittest.TestCase):
def setOptions(self, options):
"""
Command line options
"""
self.options = options
def run_command(self, cmdLine):
"""
Executes a local shell command.
"""
print("\nRunning " + cmdLine)
p = subprocess.Popen(cmdLine, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
outdata, errdata = p.communicate()
self.assertTrue(errdata != None,
"Error running remote esxcli command (%s):\n%s" % (cmdLine,errdata))
return outdata
def run_remote_command(self, cmd):
"""
Executes a command remotely via ssh.
Assumes you've got password-less login already set up.
"""
return self.run_command("ssh %s@%s 'sh -lc \"%s\"'" % (self.options.user, self.options.host, cmd))
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 tearDown(self):
"""
Reset test suite
"""
Disconnect(self.si)
def runTest(self):
self.test_esx_cli()
def test_esx_cli(self):
"""
Applies an empty config and check if property update on
CacheConfigurationManager is fired.
"""
self.assertTrue(self.advOptions != None,
"cacheConfigManager should not be None")
# Prepare property collector
objSpec = Vmodl.Query.PropertyCollector.ObjectSpec(
obj = self.advOptions,
skip = False,
selectSet = [])
propSpec = Vmodl.Query.PropertyCollector.PropertySpec(
type = self.advOptions.__class__,
all = False,
pathSet = ["setting"])
filterSpec = Vmodl.Query.PropertyCollector.FilterSpec(
propSet = [ propSpec ],
objectSet = [ objSpec ])
pc_filter = self.content.propertyCollector.CreateFilter(filterSpec, False)
# First initial call
updateSet = self.content.propertyCollector.WaitForUpdates()
version = updateSet.version
option_key = "Disk.MaxLUN"
option_value = filter(lambda x: x.key == option_key, self.advOptions.setting)[0]
value =int(option_value.value)
cmd = "esxcli system settings advanced set -o /%s -i %d" %\
(option_key.replace(".","/"), value-1)
self.run_remote_command(cmd)
# Set up wait time and trigger update
waitSpec = Vmodl.Query.PropertyCollector.WaitOptions()
waitSpec.maxWaitSeconds = 5
updateSet = self.content.propertyCollector.WaitForUpdatesEx(version,
waitSpec)
# restores old value regardless of outcome
cmd = "esxcli system settings advanced set -o /%s -i %d" %\
(option_key.replace(".","/"), value)
self.run_remote_command(cmd)
self.assertTrue(updateSet != None,
"we should get property collector update")
object_set = filter(lambda x: x.obj._wsdlName == "OptionManager",
updateSet.filterSet[0].objectSet)[0]
option_value = filter(lambda x: x.key == option_key, object_set.changeSet[0].val)[0]
self.assertTrue(option_value.value == value-1)