def parseFile(self, filename):
"""Parse a results file into this object."""
# See whether we need to work around xm-test's dodgy XML
count = 0
f = file(filename, "r")
line = f.readline()
try:
line2 = f.readline()
except:
line2 = ""
f.close()
if re.search(r"<results>", line) or \
(re.search(r"<\?xml version", line) and
re.search(r"<results>", line2)):
# Well formed XML, well, maybe...
fn = xenrt.TEC().tempFile()
fin = file(filename, "r")
fout = file(fn, "w")
while True:
line = fin.readline()
if not line:
break
line = re.sub(r"(&[^\s&<>]*)", encodeAmpersand, line)
fout.write(line)
fout.close()
fin.close()
x = xml.dom.minidom.parse(fn)
for n in x.childNodes:
if n.nodeType == n.ELEMENT_NODE and n.localName == "results":
count = count + self.processResultsNode(n)
else:
# Read the whole file in and wrap
text = "<wrapper>\n"
tr = ""
for i in range(256):
if i < 32:
tr = tr + " "
elif i < 128:
tr = tr + chr(i)
else:
tr = tr + " "
f = file(filename, "r")
data = f.read()
f.close()
# Remove any control characters (from log files mainly)
text = text + string.translate(data, tr)
text = text + "</wrapper>\n"
x = xml.dom.minidom.parseString(text)
for n in x.childNodes:
if n.nodeType == n.ELEMENT_NODE and n.localName == "wrapper":
for i in n.childNodes:
if i.nodeType == i.ELEMENT_NODE and \
i.localName == "results":
count = count + self.processResultsNode(i)
return count
def run(self, arglist=None):
# Create the clones, recording how long it takes to do so
self.clones = self.createMPSVMs(self.numdesktops, self.goldvm)
self.configureAllVMs()
# Set up log files for REQ226
bootwatcherLogfile = libperf.createLogName("bootwatcher")
starterLogfile = libperf.createLogName("starter")
shutdownwatcherLogfile = libperf.createLogName("shutdownwatcher")
xenrt.TEC().comment("bootwatcher logfile: %s" % bootwatcherLogfile)
xenrt.TEC().comment("starter logfile: %s" % starterLogfile)
xenrt.TEC().comment("shutdownwatcher logfile: %s" %
shutdownwatcherLogfile)
# Begin to collect stats from NetApp, for REQ246,248
self.startNetAppStatGather()
# Start watching for shutdowns
sdw = ShutdownWatcher(self, len(self.clones), shutdownwatcherLogfile)
sdw.start()
xenrt.TEC().logverbose("started shutdownwatcher")
# Now start the VMs, for REQ226
numthreads = len(self.normalHosts)
self.timeStartVMs(
numthreads,
self.clones,
starterLogfile,
bootwatcherLogfile,
awaitParam=None) # awaitParam=None -> don't use a BootWatcher
# Wait for all the VMs to shut down
# TODO this is broken
sdw.join()
xenrt.TEC().logverbose("shutdownwatcher has completed")
if sdw.error:
raise xenrt.XRTError("shutdownwatcher completed with error")
# Now gather the final stats from the NetApp, for REQ246,248
stats = self.finishNetAppStatGather()
netappLogFile = libperf.createLogName("netapp")
libperf.outputToResultsFile(netappLogFile, stats)
def run(self):
# create guest
if self.vm_type == "win7":
xenrt.TEC().logverbose("Creating a Windows 7 guest on host %s" %
self.host.getName())
self.guest = self.host.createGenericWindowsGuest(
distro="win7-x64", vcpus=self.num_vm_vcpus)
# added for Boston MS3
self.guest.unenlightenedShutdown()
self.guest.poll('DOWN')
else:
xenrt.TEC().logverbose(
"Creating a generic Linux guest on bridge %s on host %s" %
(self.comm_bridge, self.host.getName()))
self.guest = self.host.createGenericLinuxGuest(
start=False, bridge=self.comm_bridge, vcpus=self.num_vm_vcpus)
# setup networking
trans_vif_uuid = self.createVif(self.trans_bridge, "1")
dummy_vif_uuid = self.createVif(self.dummy_bridge, "2")
self.guest.start()
if self.vm_type == "win7":
self.guest.xmlrpcExec("netsh firewall set opmode disable")
ipconfig_all = self.guest.xmlrpcExec("ipconfig /all",
returndata=True)
trans_mac = self.host.execdom0(
"xe vif-param-get param-name=MAC uuid=%s" %
trans_vif_uuid).strip().upper().replace(":", "-")
trans_lan = self.host.execdom0(
"echo \"%s\" | grep -i -B 4 \"%s\" | grep -o \"Local Area Connection [0-9]*\""
% (ipconfig_all, trans_mac)).strip()
self.guest.xmlrpcExec(
"netsh interface ip set address \"%s\" static %s" %
(trans_lan, self.ip))
self.guest.xmlrpcSendFile(self.winIperfFile, "c:\\iperf.exe")
self.guest.xmlrpcSendFile(self.winFpingFile, "c:\\fping.exe")
else:
self.guest.execguest(
"sed -i 's/http:\/\/.*\//http:\/\/archive.debian.org\//' /etc/apt/sources.list"
)
self.guest.execguest("apt-get update")
self.guest.execguest("apt-get install --force-yes -y iperf")
self.guest.shutdown()
def generateMarvinTestConfig(self):
self.marvinCfg = {}
self.marvinCfg['dbSvr'] = {}
self.marvinCfg['dbSvr']['dbSvr'] = self.marvinApi.mgtSvrDetails.dbSvr
self.marvinCfg['dbSvr']['passwd'] = 'cloud'
self.marvinCfg['dbSvr']['db'] = 'cloud'
self.marvinCfg['dbSvr']['port'] = 3306
self.marvinCfg['dbSvr']['user'] = '******'
self.marvinCfg['mgtSvr'] = []
self.marvinCfg['mgtSvr'].append({
'mgtSvrIp':
self.marvinApi.mgtSvrDetails.mgtSvrIp,
'port':
self.marvinApi.mgtSvrDetails.port
})
self.marvinCfg['zones'] = map(lambda x: x.__dict__,
self.marvinApi.cloudApi.listZones())
for zone in self.marvinCfg['zones']:
zone['pods'] = map(
lambda x: x.__dict__,
self.marvinApi.cloudApi.listPods(zoneid=zone['id']))
for pod in zone['pods']:
pod['clusters'] = map(
lambda x: x.__dict__,
self.marvinApi.cloudApi.listClusters(podid=pod['id']))
for cluster in pod['clusters']:
cluster['hosts'] = map(
lambda x: x.__dict__,
self.marvinApi.cloudApi.listHosts(
clusterid=cluster['id']))
for host in cluster['hosts']:
host['username'] = '******'
host['password'] = xenrt.TEC().lookup("ROOT_PASSWORD")
host['url'] = host['ipaddress']
fn = xenrt.TEC().tempFile()
fh = open(fn, 'w')
json.dump(self.marvinCfg, fh)
fh.close()
return fn
def cleanup(self, entities):
"""Remove all the specified entities from this Context."""
xenrt.TEC().logverbose("Cleaning %s." % (entities))
# We sometimes have entities == self.entities so it's
# best to take a copy of whatever we're cleaning up.
entities = copy.copy(entities)
for entityname in entities:
if entityname in self.entities:
entity = self.entities[entityname]
xenrt.TEC().logverbose(
"Destroying entities which depend on %s." % (entityname))
dependents = filter(
lambda x: entityname in self.entities[x].DEPENDS,
self.entities)
self.cleanup(dependents)
xenrt.TEC().logverbose("Destroying entities which taint %s." %
(entityname))
tainters = filter(
lambda x: entityname in self.entities[x].TAINTS,
self.entities)
self.cleanup(tainters)
if entityname in self.entities:
xenrt.TEC().logverbose("Destroying %s." % (entityname))
try:
entity.destroy()
except Exception, e:
xenrt.TEC().logverbose("Exception destroying %s: %s" %
(entityname, e))
xenrt.TEC().logverbose("Purging '%s' from cache." %
(entityname))
for entry in self.cache.keys():
if re.search("(^|=)%s" % (entityname), entry):
del self.cache[entry]
xenrt.TEC().logverbose("Removing '%s' from context." %
(entityname))
if self.entities.has_key(entityname):
del self.entities[entityname]
xenrt.TEC().logverbose(
"Destroying entities which are tainted by '%s'." %
(entityname))
self.cleanup(entity.TAINTS)
if not "Pool" in self.entities:
self.entities["Pool"] = Pool(self.pool, self)
if not "Host" in self.entities:
self.entities["Host"] = Host(self.pool.master, self)
def run(self, arglist=[]):
for sku in self.skus:
if sku == XenServerLicenseSKU.Free:
# Free license does not require grace license test.
xenrt.TEC().logverbose(
"Free license does not require grace license test")
continue
license = self.licenseFactory.licenseForPool(self.systemObj, sku)
self.runSubcase("licenseGraceTest", license,
"Grace - %s" % license, "Grace")
def run(self, arglist=None):
for sku in self.skus:
xenrt.TEC().logverbose("Testing SKU: %s" % sku)
self.confirmLicenseServerUp()
self.license = self.licenseFactory.licenseForHost(
self.systemObj.master, sku)
# Apply the currrent license.
licenseinUse = self.licenseManager.addLicensesToServer(
self.v6, self.license)
self.licenseManager.applyLicense(self.v6, self.systemObj,
self.license, licenseinUse)
self.systemObj.checkLicenseState(edition=self.license.getEdition())
self.checkFeature(sku)
self.licenseManager.releaseLicense(self.systemObj)
xenrt.TEC().logverbose("Finished testing SKU: %s" % sku)
def waitForResultsToAppear(self, rundirpath, sessionnum, expectedlines, latestTime):
filename = "%s/VSI_log.%04d" % (rundirpath, sessionnum)
numlines = 0
interattemptsleep = 5 # seconds
while numlines < expectedlines and time.time() < latestTime:
time.sleep(interattemptsleep)
wc = self.guest.execguest("wc -l %s || true" % filename)
try:
numlines = int(wc.split(" ")[0])
except ValueError:
numlines = 0
xenrt.TEC().logverbose("attempt (with %.0f secs remaining): file %s, lines %d of %d expected" % (latestTime-time.time(), filename, numlines, expectedlines))
if numlines >= expectedlines:
xenrt.TEC().logverbose("session %d has completed" % sessionnum)
return True
else:
xenrt.TEC().logverbose("timeout! it looks like session %d was stuck" % sessionnum)
return False
def getVMIP(self, h, uuid):
host = self.tec.gec.registry.hostGet(h)
# Note: self.clones[i].getDomid() is not reliable because it assumes that the host in self.clones[i] is accurate, but it's not. So we look up the domid ourselves.
domid = int(host.execdom0("list_domains | grep '%s' | awk -F\\| '{print $1}'" % uuid).strip())
xenrt.TEC().logverbose("domid of VM with uuid %s is %d" % (uuid, domid))
ip = host.xenstoreRead("/local/domain/%d/attr/eth0/ip" % domid)
#ip = self.clones[i].getIP() # -- seems to return None?
return ip
def checkpoint(self):
self.workloads = self.guest.startWorkloads(self.WORKLOADS)
self.processes = self.guest.xmlrpcPS()
xenrt.TEC().logverbose("Processes before snapshot: %s" %
(self.processes))
self.guest.xmlrpcCreateFile("c:\\before_snapshot", "")
_SnappointRollback.checkpoint(self)
self.guest.xmlrpcCreateFile("c:\\after_snapshot", "")
for w in self.workloads:
w.stop()
w.stopped = False
def physicalDeviceOf(self, guest, endpointdev):
assert isinstance(guest, xenrt.GenericGuest)
if endpointdev is None:
return None
else:
# Get the bridge this VIF is on
br = [
b for (dev, b, _, _) in guest.vifs
if dev == ('eth%d' % endpointdev)
][0]
xenrt.TEC().logverbose(
"physicalDeviceOf(%s, %s): guest.vifs = %s, so device %d is bridged on %s"
% (guest, endpointdev, guest.vifs, endpointdev, br))
# Convert bridge into the assumed id of the PIF
assumedid = self.convertNetworkToAssumedid(guest.host, br)
xenrt.TEC().logverbose(
"physicalDeviceOf(%s, %s): bridge '%s' corresponds to assumedid %d"
% (guest, endpointdev, br, assumedid))
return assumedid
def __init__(self, hosts, iscsiHost=None):
self.hosts = hosts
for host in self.hosts:
host.melioHelper = self
self.lun = None
self._scsiid = None
self.guid = None
self._iscsiHost = iscsiHost
self.logNames = []
# Get a checkout of the Melio Python library
if not xenrt.TEC().lookup("MELIO_PYTHON_LOCAL_PATH", None):
d = xenrt.TempDirectory()
xenrt.util.command("cd %s && git clone %s melio-python" % (d.path(), xenrt.TEC().lookup("MELIO_PYTHON_REPO", "https://gitlab.citrite.net/xs-melio/python-melio-linux.git")))
xenrt.util.command("cd %s/melio-python && git checkout %s" % (d.path(), xenrt.TEC().lookup("MELIO_PYTHON_BRANCH", "master")))
xenrt.GEC().config.setVariable("MELIO_PYTHON_LOCAL_PATH", "%s/melio-python" % d.path())
sys.path.append("%s/melio-python/lib" % d.path())
xenrt.setupLogging("sanbolic")
import sanbolic
self._MelioClient = sanbolic.Client
def __get_sdk_location(self):
"""
Look for the SDK location in a named flag otherwise provide the default
"""
log("Look for override in %s" % self.SDK_OVERRIDE)
try:
location = xenrt.TEC().lookup(self.SDK_OVERRIDE)
log("Found override.....")
return location
except:
return "xe-phase-2/%s" % self._packageName
def install(self):
if not self.guest.xmlrpcDirExists(self.__location()):
self.guest.xmlrpcUnpackTarball("%s/redway3dturbine.tgz" % (xenrt.TEC().lookup("TEST_TARBALL_BASE")), "c:\\")
ref = self.guest.xmlrpcStart("c:\\redway3dturbine\\turbineDemo.exe /S")
deadline = xenrt.util.timenow() + 600
while xenrt.util.timenow() < deadline:
self.guest.xmlrpcKillAll("REDSystemCheckUtility.exe")
if self.guest.xmlrpcPoll(ref):
break
xenrt.sleep(10)
def waitForVMBoot(self, vm):
# Thread (called by PTask) Waiting for a VM to boot
try:
vm.os.waitForBoot(3600)
self.addTiming("TIME_VM_VMAVAILABLE_%s:%.3f" %
(vm.name, xenrt.util.timenow(float=True)))
except Exception, e:
# If it failed, continue, but mark it as failed for now.
xenrt.TEC().reason("VM %s failed to boot - %s" % (vm.name, str(e)))
with self.lock:
self.failedVMs.append(vm.name)
def run(self, arglist=None):
host = self.getDefaultHost()
url = "http://%s/" % (host.getIP())
localtemp = xenrt.TEC().tempFile()
# Check whether XenCenter.msi or XenCenterSetup.exe exists
try:
xenrt.command("curl '%s' -o %s" % (url, localtemp))
except Exception, e:
raise xenrt.XRTFailure("Unable to retrieve web page from the host",
str(e))
def getDockerPS(self):
"""Returns an ordered list of dictionary of containers"""
dockerPS = self.dockerGeneralInfo('docker_ps')
if not dockerPS.has_key('item'):
xenrt.TEC().logverbose(
"getDockerPS: Failed to find key =item= in docker_ps xml")
return []
dockerContainerInfo = dockerPS['item']
if isinstance(dockerContainerInfo, dict):
return [dockerContainerInfo] # one container -> retruns a dict.
elif isinstance(dockerContainerInfo, list):
return dockerContainerInfo # more than one container returns a list of ordered dicts.
else:
xenrt.TEC().logverbose(
"getDockerPS: dockerContainerInfo instance is not recognised")
return []
def prepare(self, environment):
"""Create the necessary entities for this Context
to conform to environment."""
for entity in environment:
xenrt.TEC().logverbose("Preparing a '%s'." % (entity))
if not entity in self.entities:
if not entity in self.classes:
xenrt.TEC().logverbose(
"No concept of a '%s' exists, using default." %
(entity))
entityclass = self.classes["Default"]
self.entities[entity] = entityclass(self, entity)
else:
entityclass = self.classes[entity]
xenrt.TEC().logverbose(
"Preparing all dependencies of '%s'." % (entity))
self.prepare(entityclass.DEPENDS)
self.entities[entity] = entityclass(self)
else:
xenrt.TEC().logverbose("A '%s' already exists." % (entity))
def run(self, arglist=None):
uuid = self.goldvm.getUUID()
# Now repeatedly clone the VM
clonerLogfile = libperf.createLogName("cloner")
xenrt.TEC().comment("cloner logfile: %s" % clonerLogfile)
t = libperf.Cloner(self, self.host, self.goldvm, self.numclones,
clonerLogfile)
t.start()
t.join()
def sampleDom0State(self, numRunningVMs):
xenrt.TEC().logverbose("Waiting for dom0 to settle...")
# Wait for the system to settle
time.sleep(30)
xenrt.TEC().logverbose("Sampling dom0 state (with %d running VMs)" % numRunningVMs)
cmds = [
# Sample dom0 memory usage
("cat /proc/meminfo", "meminfo-%d"),
# See what processes are running in dom0
("ps axuwww", "ps-axuwww-%d"),
# list_domains
("list_domains -all", "list_domains-%d"),
]
for cmd, logfile in cmds:
output = self.host.execdom0(cmd)
self.log(logfile % numRunningVMs, output)
def run(self, arglist):
# Retrieving iSCSI LUN from registry for SR creation.
self.lun = xenrt.TEC().registry.resourceGet("ISCSISRLUN")
# Creating multipathed iSCSI SR.
iscsiSR = xenrt.lib.xenserver.ISCSIStorageRepository(
self.host, "multipathed-iscsi-sr-on-same-storage-as-boot-disk")
iscsiSR.create(self.lun,
subtype="lvm",
multipathing=True,
noiqnset=True)
def exportSnapshot(self):
xenrt.TEC().logverbose("Trying to export snapshot.")
command = ["xe"]
command.append("snapshot-export-to-template")
command.append("snapshot-uuid=%s" % (self.snappoint))
command.append("filename=%s" % (self.image))
command = string.join(command)
command = xenrt.lib.xenserver.cli.buildCommandLine(self.host, command)
result = self.cliguest.execguest(command, timeout=3600).strip()
if not result == "Export succeeded":
raise xenrt.XRTFailure("Export failed. (%s)" % (result))
def _getSdk(self):
self.removePackage()
step("Getting SDK....")
target = self.__get_sdk_location()
sdkfile = xenrt.TEC().getFile(target)
sftp = self._runner.sftpClient()
targetLocation = os.path.join(self.TARGET_ROOT, self._packageName)
sftp.copyTo(sdkfile, targetLocation)
log("Target location: %s" % targetLocation)
sftp.close()
return targetLocation
def run(self, arglist):
cli = self.pool.getCLIInstance()
statefilevdi = self.pool.master.parseListForUUID(
"vdi-list", "name-label", "Statefile for HA")
statefilesr = self.pool.master.getVDISR(statefilevdi)
try:
self.pool.master.destroyVDI(statefilevdi)
except xenrt.XRTFailure, e:
xenrt.TEC().logverbose(
"Expected failure to delete state file VDI.")
def getGuestOrHostFromName(self, name):
for guest in self.guests:
if guest.getName() == name:
self.log(None, "name=%s -> guest=%s" % (name, guest))
return guest
host = xenrt.TEC().registry.hostGet(name)
self.log(None, "name=%s -> host=%s" % (name, host))
if host:
return host
raise xenrt.XRTError("Failed to find guest or host with name %s" %
(name, ))
def getVmWareDc(self, key, ref):
if ref.has_key("XRT_VMWareDC"):
vc = xenrt.TEC().lookup("VCENTER")
return {
"name": ref['XRT_VMWareDC'],
"vcenter": vc['ADDRESS'],
"username": vc['USERNAME'],
"password": vc['PASSWORD']
}
else:
return None
def run(self, arglist=None):
vm = self.host.execdom0(
"xe vm-install new-name-label=vm template-name=\"Other install media\""
).strip()
self.host.execdom0(
"xe vm-cd-add uuid=%s cd-name=\"win7-x86.iso\" device=3" % vm)
self.host.execdom0("xe vm-start uuid=%s" % vm, timeout=30)
self.checkHost()
xenrt.TEC().logverbose("Expected output: Host didn't crash")
def _installPackage(self):
if self._os.windowsVersion() == "5.1":
# CA-41364 need a newer version of windows installer
self._os.installPackage("WindowsInstaller")
self._os.unpackTarball("%s/dotnet.tgz" %
(xenrt.TEC().lookup("TEST_TARBALL_BASE")),
"c:\\")
exe = self._os._os.getArch() == "amd64" and "NetFx20SP2_x64.exe" or "NetFx20SP2_x86.exe"
self._os.cmdExec("c:\\dotnet\\%s /q /norestart" % exe,
timeout=3600, returnerror=False)
def paramGet(self, param, isVMkernelAdvCfg=False):
try:
if isVMkernelAdvCfg:
return self.execdom0("esxcfg-advcfg --get %s" %
(param)).strip().split(" is ")[-1]
# User defined config
return self.execdom0("esxcfg-advcfg --get-user-var --user-var %s" %
(param)).strip()
except xenrt.XRTFailure, e:
xenrt.TEC().logverbose("advance config '%s' doesn't exist." %
param)
def joinADDomain(self, arglist=None):
self.authguest = self.getGuest(self.ADNAME)
self.adIP = self.authguest.getIP()
self.authserver = self.authguest.getActiveDirectoryServer()
xenrt.TEC().logverbose(self.authserver.domainname)
xenrt.TEC().logverbose(self.authserver.place.password)
xenrt.TEC().logverbose(self.adIP)
self.targetGuest.xmlrpcExec(
"netsh interface ip set dns \"Local Area Connection\" static %s" %
(self.adIP))
self.targetGuest.xmlrpcExec(
"netsh firewall set opmode mode=DISABLE profile=ALL")
self.targetGuest.xmlrpcExec(
"netdom join %%computername%% /domain:%s /userd:%s /passwordd:%s" %
(self.authserver.domainname, "Administrator",
self.authserver.place.password))
self.targetGuest.waitForDaemon(90, desc="Guest check")
self.targetGuest.reboot()
