def read_boot_time(dut, build):
boot_times = None
print 'INFO: sending reboot'
# The first boot time after a fresh install is much slower than the following
wait_to_come_up(dut)
run(['reboot'], host=dut)
with time_limit(600, 'wait for sync up event'):
while 1:
try:
print 'INFO: checking if', dut, 'is still up'
check_up(dut)
except Exception, exc:
print 'INFO:', dut, 'is down', exc
break
else:
print 'INFO:', dut, 'still up'
sleep(1)
print
while 1:
wait_to_come_up(dut, timeout=1200)
log = grep_dut_log(dut, '/var/log/messages', UI_READY)
boot_times = parse_sys_log(log)
print 'INFO: boot times:', ' '.join(['%.2f' % t for t in boot_times])
if len(boot_times) >= 2:
break
sleep(5)
def editfs(machine,vms,steps,build,test_path,caller):
r = run(['mount','-o','rw,remount','/'], host=machine)
tslib.cmdResponse(r, 'cryptsetup luksDump /dev/xenclient/config')
r = run(['touch','/testfolder1'], host=machine)
tslib.cmdResponse(r, 'cryptsetup luksDump /dev/xenclient/config')
power_control.platform_transition(machine, 'reboot')
wait_to_go_down(machine)
tslib.interact(machine, "At the TPM protection screen, choose shutdown. Ensure that machine shutsdown")
power_control.set_s0(machine)
tslib.interact(machine, "At the TPM protection screen, choose continue. Enter the wrong password 3 times. Ensure that machine shutsdown")
power_control.set_s0(machine)
tslib.interact(machine, "At the TPM protection screen, choose continue. Enter the correct password. Choose not to reseal the device")
wait_to_come_up(machine)
power_control.platform_transition(machine, 'reboot')
wait_to_go_down(machine)
tslib.interact(machine, "Ensure that TPM protection screen is shown, enter password and choose to reseal the device")
wait_to_come_up(machine)
print "Rebooting the device to check if reseal has taken effect. TPM screen should not be seen anymore"
power_control.platform_transition(machine, 'reboot')
wait_to_go_down(machine)
wait_to_come_up(machine)
def clean_old_vhds():
"""Clean up old VHDs"""
references = set()
builddir = VHD_WITH_TOOLS_PATTERN[:VHD_WITH_TOOLS_PATTERN.find('%')-1]
builddocs = get_autotest().builds.find(
{}, sort=[('build_time', DESCENDING)], limit=5)
recentbuilds = [bd['_id'] for bd in builddocs]
builds = listdir(builddir)
for name in builds:
if name not in recentbuilds:
fname = builddir + '/'+ name
print 'delete', fname
run(['rm', '-rf', fname], ignore_failure=True)
for (dirpath, dirnames, filenames) in walk('/home/xc_vhds/dev_vhds'):
for name in filenames:
full = dirpath+'/'+name
if not islink(full):
continue
references.add(readlink(full))
print 'INFO: have references to', len(references), 'VHDs'
for (dirpath, dirnames, filenames) in \
walk('/home/xc_bvt_output/archive-vhds'):
for name in filenames:
full = dirpath+'/'+name
if full not in references:
print 'INFO: deleting unreferenced', full
try:
unlink(full)
except OSError:
pass
def disableSnapshot(machine, vms, steps, build, test_path, caller):
dummy = str(random.randint(10000, 20000))
vm_address = str(domain_address(machine, vms))
r = run(['xec-vm', '-n', vms, '--disk', '1', 'get', 'snapshot'],
host=machine)
if 'temporary' in r:
tslib.forcepowerstate(machine, 'off', vms)
r = run(
['xec-vm', '-n', vms, '--disk', '1', 'set', 'snapshot', 'none'],
host=machine)
tslib.cmdResponse(r,
'xec-vm -n ' + vms + ' --disk 1 set snapshot none')
snapshot = run(['xec-vm', '-n', vms, '--disk', '1', 'get', 'snapshot'],
host=machine)
tslib.cmdResponse(r, 'xec-vm -n ' + vms + ' --disk 1 get snapshot')
if 'none' not in snapshot:
tslib.pauseToDebug("xec failed to disable snapshot")
windows_transitions.vm_poweron(machine, vms)
for i in range(2):
windows_transitions.vm_reboot_dom0(machine, vms)
res = run_via_exec_daemon(
['mkdir', 'C:\\Users\\Administrator\\Desktop\\' + dummy],
host=vm_address,
wait=True)
windows_transitions.vm_reboot_dom0(machine, vms)
res = run_via_exec_daemon(['dir', 'C:\\Users\\Administrator\\Desktop\\'],
host=vm_address,
wait=True)
if dummy not in res:
tslib.pauseToDebug("Snapshot disabled: Old folders lost after reboot")
def set_boot_order(host,name,order):
#would check exclusive, but makes an easy check
valid_boot = ['c','d','n']
for letter in order:
if letter not in valid_boot:
raise InvalidBootOption()
run(['xec-vm', '-n', name, 'set', 'boot', order], host=host)
def wait_for_guest(host, guest, method=None, timeout=600):
"""Return address for guest on host, checking that it is responding
and retrying as necessary"""
if method is None:
method = get_default_exec_method(host, guest)
assert method in ['exec_daemon', "ssh"]
print 'WAIT_FOR_SYSTEM: contacting', guest, 'using', method
_, name = name_split(guest)
start = time()
run(['xec-vm', '-n', name, 'switch'], host=host)
def check_running():
"""check VM is running"""
count = 0
while(1):
out = run(['xec-vm', '-n', name, 'get', 'state'], word_split=True, host=host)
print 'WAIT_FOR_SYSTEM: VM', name, 'state', out[0]
if out[0] == 'stopped':
if count > 4: raise SystemStoppedWhileWaitingForSystem(out, guest, host)
else: count+=1
sleep(2)
else: break
def get_address():
"""get address for VM """
check_running()
return domain_address(host, guest, timeout=5)
address = retry(get_address, 'get %s address on %s' % (guest, host),
timeout=timeout, propagate=[SystemStoppedWhileWaitingForSystem])
delta = time() - start
rtimeout = max(30, int(timeout - delta))
print 'WAIT_FOR_SYSTEM: remainining timeout', rtimeout, 'of', timeout
def check_windows_version():
"""Check that VM is still running"""
check_running()
out = call_exec_daemon('windowsVersion', [], host=address, timeout=60)
print 'WAIT_FOR_SYSTEM: windows version returned', out
def check_ssh_access():
"""Check that VM is available over ssh"""
check_running()
run(['echo', 'test succeeded'], host=address, timeout=60, check_host_key=False)
print 'WAIT_FOR_SYSTEM: ssh command execution succeeded'
if method == "exec_daemon":
try:
ver = retry(check_windows_version,
description='run windowsVersion on '+host+' '+guest,
timeout=rtimeout,
propagate=[SystemStoppedWhileWaitingForSystem])
except error:
raise UnableToContactGuestService(host, guest, timeout, error)
print 'WAIT_FOR_SYSTEM:', guest, 'on', host, \
'replied with windows version', ver, 'from address', address
elif method == "ssh":
retry(check_ssh_access,
description='run ssh check on '+host+' '+guest,
timeout=rtimeout,
propagate=[SystemStoppedWhileWaitingForSystem])
print 'WAIT_FOR_SYSTEM:', guest, 'on', host, \
'ssh test succeed on', address
return address
def ensure_stable(vm_address, interval, timeout=600, description=None, method="exec_daemon"):
"""Ensure that vm_address is continuaully up for interval"""
assert method in ['exec_daemon', "ssh"]
last_down = time()
start = time()
last_out = time()
reached = False
while 1:
delta = time() - last_down
run_time = time() - start
if delta > interval:
print 'HEADLINE: VM at', vm_address, description, 'has been stable for', delta
return
if run_time > timeout:
args = (time() - last_out, timeout, vm_address, description)
if reached:
raise SystemUnstable(*args)
else:
raise SystemUnreachable(*args)
try:
if method == "exec_daemon":
call_exec_daemon('windowsVersion', [], host=vm_address, timeout=60)
elif method == "ssh":
run(['true'], host=vm_address, timeout=60, check_host_key=False)
else:
raise Exception("Unkonwn method %s" % method)
except Exception, exc:
last_down = time()
else:
delta = time() - last_down
print 'WAIT_FOR_SYSTEM: stable for', delta, 'of', interval, 'seconds'
last_out = time()
reached = True
sleep(1)
def clean_old_vhds():
"""Clean up old VHDs"""
references = set()
builddir = VHD_WITH_TOOLS_PATTERN[:VHD_WITH_TOOLS_PATTERN.find('%') - 1]
builddocs = get_autotest().builds.find({},
sort=[('build_time', DESCENDING)],
limit=5)
recentbuilds = [bd['_id'] for bd in builddocs]
builds = listdir(builddir)
for name in builds:
if name not in recentbuilds:
fname = builddir + '/' + name
print 'delete', fname
run(['rm', '-rf', fname], ignore_failure=True)
for (dirpath, dirnames, filenames) in walk('/home/xc_vhds/dev_vhds'):
for name in filenames:
full = dirpath + '/' + name
if not islink(full):
continue
references.add(readlink(full))
print 'INFO: have references to', len(references), 'VHDs'
for (dirpath, dirnames, filenames) in \
walk('/home/xc_bvt_output/archive-vhds'):
for name in filenames:
full = dirpath + '/' + name
if full not in references:
print 'INFO: deleting unreferenced', full
try:
unlink(full)
except OSError:
pass
def nilfvm(machine, vms, steps, build, test_path, caller):
tslib.forcepowerstate(machine, 'off', vms)
r = run([
'cd', '/storage/nilfvm', 'nilfvm-create',
'--rootfs=nilfvm-rootfs.i686.cpio.bz2', '--size=256',
'--config=service-nilfvm'
],
host=machine)
tslib.cmdResponse(
r,
'nilfvm-create --rootfs=nilfvm-rootfs.i686.cpio.bz2 --size=256 --config=service-nilfvm'
)
vm_uuid = run(['xec-vm', '-n', vms, 'get', 'uuid'], host=machine)
vm_uuid = vm_uuid.rstrip('\n')
tslib.cmdResponse(vm_uuid, 'xec-vm -n ' + vms + ' get uuid')
r = run(['xec-vm', '-u', vm_uuid, 'set', 'track-dependencies', 'true'],
host=machine)
tslib.cmdResponse(r,
'xec-vm -u ' + vm_uuid + ' set track-dependencies true')
nilfvm_uuid = run(['xec-vm', '-n', nilfvm01, 'get', 'uuid'], host=machine)
r = run([
'xec-vm', '-u', vm_uuid, '--nic', '0', 'set', 'backend-uuid',
nilfvm_uuid
],
host=machine)
tslib.cmdResponse(
r, 'xec-vm -u ' + vm_uuid + ' --nic 0 set backend-uuid ' + nilfvm_uuid)
def test_enforce_encrypted_disks(dut):
vm = create_guest(dut, "enforce_enc_disks", "windows")
try:
SIZE = 1 # size of virtual disk for test, in MB
# 1. Ensure vm is shut-down
guest_shutdown(dut, vm)
# 2. Add an encrypted disk. Start and stop VM
vhd = run(['xec', 'create-vhd', str(SIZE)], host=dut, timeout=600).strip()
vm_disk = run(['xec-vm', '-u', guest_uuid(dut, vm), 'add-disk'], host=dut).strip()
run(['xec', '-o', vm_disk, 'attach-vhd', vhd], host=dut)
run(['xec', '-o', vm_disk, 'generate-crypto-key', '256'], host=dut, timeout=600)
guest_start(dut, vm)
guest_shutdown(dut, vm)
# 3. Replace encrypted disk with an unencrypted one. Verify VM does not start.
run(['rm', '-f', vhd], host = dut)
run(['vhd-util', 'create', '-n', vhd, '-s', str(SIZE)], host = dut)
try:
guest_start(dut, vm)
except:
pass
else:
raise VMStartedAfterTampering
finally:
guest_destroy(dut, vm)
guest_delete(dut, vm)
def set_boot_order(host, name, order):
#would check exclusive, but makes an easy check
valid_boot = ['c', 'd', 'n']
for letter in order:
if letter not in valid_boot:
raise InvalidBootOption()
run(['xec-vm', '-n', name, 'set', 'boot', order], host=host)
def set_iso_0(host, guest, iso):
"""sets what iso is held in the 0 disk slot of a VM"""
run([
'xec-vm', '-n', guest, '--disk', '0', 'set', 'phys-path',
'/storage/isos/' + iso
],
host=host)
def reboot_windows_vm(dut, domain):
"""Triger a reboot of guest"""
_, name = name_split(domain)
domain = find_domain(dut, name)
print 'INFO: rebooting guest', domain
run(['xec-vm', '-n', name, 'reboot'], host=dut)
wait_for_domid_change(dut, name, domain['dom_id'])
print 'INFO: reboot of', domain, 'completed'
def add_vhd(host, name, size=80000):
#returns the path to the disk
run([
'vhd-util', 'create', '-n', '/storage/disks/' + name, '-s',
str(size)
],
host=host)
return '/storage/disks/' + name
def reboot_windows_vm(dut, domain):
"""Triger a reboot of guest"""
_, name = name_split(domain)
domain = find_domain(dut, name)
print 'INFO: rebooting guest', domain
run(['xec-vm', '-n', name, 'reboot'], host=dut)
wait_for_domid_change(dut, name, domain['dom_id'])
print 'INFO: reboot of', domain, 'completed'
def check_ssh_access():
"""Check that VM is available over ssh"""
check_running()
run(['echo', 'test succeeded'],
host=address,
timeout=60,
check_host_key=False)
print 'WAIT_FOR_SYSTEM: ssh command execution succeeded'
def set_disk_snapshot(host, guest, disknum, snapshot):
#should be none or temporary
if snapshot != 'none' and snapshot != 'temporary':
raise BadEnumValue()
run([
'xec-vm', '-n', guest, '--disk', disknum, 'set', 'snapshot', snapshot
],
host=host)
def do_iteration(i, options):
"""Do one iteration of the test loop"""
set_experiment_install_flag(
options.machine,
(options.install_first or not options.soak_power_level) and (i == 1))
try:
mdb = mongodb.get_autotest()
dutdoc = mdb.duts.find_one({'name': options.machine})
except NoMongoHost:
dutdoc = {'write': True}
write = (dutdoc if dutdoc else {}).get('write')
test_parameters = {
'dut': options.machine,
'record': options.record,
#'status_report_mode': STATUS_REPORTS_ALWAYS if
# options.diagnostic_status_report else STATUS_REPORTS_NEVER,
'stash_guests': options.guest,
'verbose': options.verbose,
'stash_on_failure': options.stash_on_failure,
'reinstall_on_failure': options.reinstall_on_failure
}
def trigger_tests(condition, guest=None):
"""Trigger test cases matching condition for guest"""
for test_case in test_cases.TEST_CASES:
if test_case.get('trigger') == condition:
run_test(test_parameters, test_case, options, guest)
trigger_tests('first')
if write:
trigger_tests('platform install')
trigger_tests('build ready')
trigger_tests('soakup')
trigger_tests('platform ready')
trigger_tests('stress')
trigger_tests('regression')
for guest in options.guest if options.guest else []:
try:
find_domain(options.machine, guest)
have_domain = True
except CannotFindDomain:
have_domain = False
print 'check for domain', guest, 'returned', have_domain
write_guest = options.rebuild_vms or write or not have_domain
if write_guest:
trigger_tests('VM install', guest)
domain = find_domain(options.machine, guest)
if domain['status'] == 'stopped':
run(['xec-vm', '-n', domain['name'], 'start'],
host=options.machine,
timeout=600)
if write_guest:
trigger_tests('VM configure', guest)
trigger_tests('VM accelerate', guest)
trigger_tests('VM ready', guest)
trigger_tests('soakdown')
def vm_reboot_dom0(dut, who='all'):
"""reboot vm/vms from dom0"""
domlist = find_guest_vms(dut)
for domain in domlist:
if who == 'all' or domain['name'] == who:
run(['xec-vm', '-n', domain['name'], 'reboot'], host=dut)
vmip = domains.domain_address(dut, domain['name'])
wait_for_windows_to_go_down(vmip)
wait_for_windows_to_come_up(vmip)
def shutdown_domain(dut, vm_uuid):
"""Attempt to cleanly shut down a VM. Requires tools to be installed."""
run(['xec-vm', '-u', vm_uuid, 'shutdown'], host=dut, timeout=600)
for _ in range(30):
sleep(5)
state = run(['xec-vm', '-u', vm_uuid, 'get', 'state'], host=dut, timeout=600)
if state.strip() == 'stopped':
return
raise VMFailedToShutDown
def vm_reboot_dom0(dut, who='all'):
"""reboot vm/vms from dom0"""
domlist = find_guest_vms(dut)
for domain in domlist:
if who == 'all' or domain['name'] == who:
run(['xec-vm', '-n', domain['name'], 'reboot'], host=dut)
vmip = domains.domain_address(dut, domain['name'])
wait_for_windows_to_go_down(vmip)
wait_for_windows_to_come_up(vmip)
def vm_hibernate_dom0(dut, who='all'):
"""hibernate vm/vms from dom0"""
domlist = find_guest_vms(dut)
for domain in domlist:
if who == 'all' or domain['name'] == who:
run(['xec-vm', '-n', domain['name'], 'hibernate'], host=dut)
for domain in domlist:
if who == 'all' or domain['name'] == who:
wait_for_guest_to_go_down(dut, domain['name'])
def get_disk_key(dut, disk_uuid):
key_dir = run(['xec', 'get', 'platform-crypto-key-dirs'],
host=dut, word_split=True)[0]
disk_keys = [join(key_dir, key) for key in
run(['ls', key_dir], word_split=True, host=dut)
if key.startswith(disk_uuid)]
if len(disk_keys) > 1:
raise MultipleDiskKeys(disk_keys, dut, guest, disk_uuid)
return disk_keys[0] if disk_keys else None
def install_python(dut):
_, ec= run(['python', '--version'], host=dut, ignore_failure=True)
if ec == 0:
print 'INFO: python already installed'
return
print 'INFO: copying python files on target'
run(['scp', '-r', abspath(split(split(__file__)[0])[0])+'/pyxc', 'root@'+dut+':/root'])
print 'INFO: launching python installer'
run(['/root/pyxc/pysetup'], host=dut, timeout=3600)
def enableusbPassthrough(machine,vms,steps,build,test_path,caller):
(vendor_id1,device_id1,vendor_id2,device_id2) = getDeviceID(machine,vms,steps,build,test_path,caller)
tslib.forcepowerstate(machine, 'off', vms)
r = run(['xec-vm','-n',vms,'add-pt-rule','0x0c03',vendor_id1,device_id1], host=machine)
tslib.cmdResponse(r, 'xec-vm -n vms add-pt-rule 0x0c03'+vendor_id1+' '+device_id1)
r = run(['xec-vm','-n',vms,'add-pt-rule','0x0c03',vendor_id2,device_id2], host=machine)
tslib.cmdResponse(r, 'xec-vm -n vms add-pt-rule 0x0c03'+vendor_id2+' '+device_id2)
windows_transitions.vm_poweron(machine, vms)
tslib.interact(machine, "Perform VM reboot if required. Plugin a usb device and verify if the device is passed through to the VM")
def vm_poweroff(dut, who='all'):
"""force poweroff a VM from domo"""
domlist = find_guest_vms(dut)
for domain in domlist:
if who == 'all' or domain['name'] == who:
run(['xec-vm', '-n', domain['name'], 'destroy'], host=dut, timeout=20)
for domain in domlist:
if who == 'all' or domain['name'] == who:
wait_for_guest_to_go_down(dut, domain['name'])
def disableusbPassthrough(machine,vms,steps,build,test_path,caller):
(vendor_id1,device_id1,vendor_id2,device_id2) = getDeviceID(machine,vms,steps,build,test_path,caller)
tslib.forcepowerstate(machine, 'off', vms)
r = run(['xec-vm','-n',vms,'delete-pt-rule','0x0c03',vendor_id1,device_id1], host=machine)
tslib.cmdResponse(r, 'xec-vm -n vms delete-pt-rule 0x0c03'+vendor_id1+' '+device_id1)
r = run(['xec-vm','-n',vms,'delete-pt-rule','0x0c03',vendor_id2,device_id2], host=machine)
tslib.cmdResponse(r, 'xec-vm -n vms delete-pt-rule 0x0c03'+vendor_id2+' '+device_id2)
windows_transitions.vm_poweron(machine, vms)
tslib.interact(machine, "Plugin a usb device and verify that it is not passed through to the VM")
def vm_shutdown_dom0(dut, who='all'):
"""shutdown vm/vms from dom0"""
domlist = find_guest_vms(dut)
for domain in domlist:
if who == 'all' or domain['name'] == who:
run(['xec-vm', '-n', domain['name'], 'shutdown'], host=dut)
for domain in domlist:
if who == 'all' or domain['name'] == who:
wait_for_guest_to_go_down(dut, domain['name'])
def disableStartOnBoot(machine,vms,steps,build,test_path,caller):
print "INFO: Disabling autoboot for ",vms," VM"
r = run(['xec-vm','-n',vms,'set','start-on-boot','false'], host=machine)
tslib.cmdResponse(r, 'xec-vm -n '+vms+' set start-on-boot false')
print "INFO: Rebooting host"
power_control.reboot(machine)
r = run(['xec-vm','-n',vms,'get','state'], host=machine)
if 'stopped' not in r: tslib.pauseToDebug("VM started with XC boot and this is not expected")
else: print 'INFO:',vms,'did not start on XC boot'
def audioPassthrough(machine,vms,steps,build,test_path,caller):
tslib.forcepowerstate(machine, 'off', vms)
r = run(['xec-vm','-n',vms,'add-pt-rule','0x0403','any','any'], host=machine)
tslib.cmdResponse(r,'xec-vm -n <vmname> add-pt-rule 0x0403 any any')
windows_transitions.vm_poweron(machine, vms)
r = run(['xec-vm','-n',vms,'list-pt-pci-devices'], host=machine)
tslib.cmdResponse(r,'xec-vm -n '+vms+' list-pt-pci-devices')
tslib.interact(machine, "Verify if the o/p of list-pt-pci-devices is as expected")
tslib.interact(machine, "Verify from the VM that a new audio device is detected. Install driver and proceed")
def one_operation_logged(options, recording):
try:
mdb = mongodb.get_autotest()
dut_document = mdb.duts.find_one({'name':options.machine})
for job in mdb.jobs.find():
control_pid = job.get('control_pid')
if ((control_pid is None or
not os.path.isdir('/proc/'+str(control_pid))) and
job.get('status', '').startswith('running')):
mdb.jobs.update({'_id': job['_id']},
{'$set': {
'status': \
'control process '+str(control_pid)+
' disppeared without clearing up'}})
print 'TESTLAUNCH: experiment override', dut_document.get('experiment')
job = get_job(mdb, options.machine)
if job:
print 'INFO: Doing Job'
def update_job(field, value):
"""Update one field in job"""
mdb.jobs.update({'_id':job['_id']},
{'$set': {field: value}})
def set_status(status):
"""Update mongo status"""
update_job('status', status)
set_status('running')
update_job('launch_time', time.time())
update_job('control_pid', os.getpid())
update_job('control_machine', gethostname())
update_job('dut', options.machine)
print 'I should run', job, 'on', options.machine
command_line = list(job['command']) + [ '-m', options.machine]
print 'running', command_line, 'with', job['timeout'], \
'seconds timeout'
def show(output):
"""show stderr"""
for line in output.splitlines():
print line
make_log_entry(line, job_id=job['_id'],
dut=options.machine)
def finish(status, exc=None):
"""Mark test as finished"""
set_status(status)
if exc:
update_job('failure', str(exc))
update_job('finish_time', time.time())
try:
run(command_line, timeout=job['timeout'],
output_callback=show, error_callback=show)
finish('completed')
except SubprocessError, exc:
finish('failed (non zero exit code)', exc)
except TimeoutError, exc:
finish('failed (timed out)', exc)
def reboot(dut, timeout=600, managed=True):
"""Reboot dut by running shutdown, and wait for it to come back"""
if managed:
platform_transition(dut, 'reboot')
else:
print "INFO: sending reboot"
run(['reboot'], host=dut) #wait=False
wait_to_go_down(dut) # wait for host to go down
wait_to_come_up(dut, timeout=timeout) # wait for host to boot
print "DEBUG: host is up"
def vm_sleep_dom0(dut, who='all'):
"""sleep vm/vms from dom0"""
domlist = find_guest_vms(dut)
for domain in domlist:
if who == 'all' or domain['name'] == who:
run(['xec-vm', '-n', domain['name'], 'sleep'], host=dut)
for domain in domlist:
if who == 'all' or domain['name'] == who:
vmip = domains.domain_address(dut, domain['name'])
wait_for_windows_to_go_down(vmip)
def store_local_artifact(local_file, section, postfix):
"""Copy local_file to artifact storage in specific section with
postifx"""
segments = make_segments(section, postfix)
destination = ARTIFACTS_NFS_PATH + '/'.join(segments)
parent = os.path.split(destination)[0]
os.umask(0000)
run(['mkdir', '-p', parent])
run(['cp', local_file, destination], timeout=3600)
return destination
def store_local_artifact(local_file, section, postfix):
"""Copy local_file to artifact storage in specific section with
postifx"""
segments = make_segments(section, postfix)
destination = ARTIFACTS_NFS_PATH+'/'.join(segments)
parent = os.path.split(destination)[0]
os.umask(0000)
run(['mkdir', '-p', parent])
run(['cp', local_file, destination], timeout=3600)
return destination
def vm_sleep_dom0(dut, who='all'):
"""sleep vm/vms from dom0"""
domlist = find_guest_vms(dut)
for domain in domlist:
if who == 'all' or domain['name'] == who:
run(['xec-vm', '-n', domain['name'], 'sleep'], host=dut)
for domain in domlist:
if who == 'all' or domain['name'] == who:
vmip = domains.domain_address(dut, domain['name'])
wait_for_windows_to_go_down(vmip)
def reboot(dut, timeout=600, managed=True):
"""Reboot dut by running shutdown, and wait for it to come back"""
if managed:
platform_transition(dut, 'reboot')
else:
print "INFO: sending reboot"
run(['reboot'], host=dut) #wait=False
wait_to_go_down(dut) # wait for host to go down
wait_to_come_up(dut, timeout=timeout) # wait for host to boot
print "DEBUG: host is up"
def disableStubdom(machine,vms,steps,build,test_path,caller):
status = run(['xec-vm','-n',vms,'get','stubdom'], host=machine)
if 'false' in status:
print "INFO: stubdom is already disabled, exiting.."
exit()
count = xenopslistcount(machine,vms)
tslib.forcepowerstate(machine, 'off', vms)
r = run(['xec-vm','-n',vms,'set','stubdom','false'], host=machine)
tslib.cmdResponse(r, 'xec-vm -n'+vms+'set stubdom false')
windows_transitions.vm_poweron(machine, vms)
if not checkStubdom(machine,vms,count,1): tslib.pauseToDebug("qemu is either not running in dom0 or service VM have not stopped")
def shutdown_domain(dut, vm_uuid):
"""Attempt to cleanly shut down a VM. Requires tools to be installed."""
run(['xec-vm', '-u', vm_uuid, 'shutdown'], host=dut, timeout=600)
for _ in range(30):
sleep(5)
state = run(['xec-vm', '-u', vm_uuid, 'get', 'state'],
host=dut,
timeout=600)
if state.strip() == 'stopped':
return
raise VMFailedToShutDown
def store_memory_artifact(content, section, postfix):
"""Store content on artifact server in section with postfix"""
# it might be nice to avoid copying in store_local_artifact
segments = make_segments(section, postfix)
destination = ARTIFACTS_NFS_PATH+'/'.join(segments)
parent = os.path.split(destination)[0]
run(['mkdir', '-p', parent])
fileobj = file(destination, 'wb')
fileobj.write(content)
fileobj.close()
return destination
def check_mounts(dut):
"""Check mounts are as expected on dut"""
writefile(FILE_PATH, BASH_SCRIPT, host=dut)
run(['chmod', '+x', FILE_PATH], host=dut)
out = run([FILE_PATH], host=dut)
for line in out.split('\n'):
print 'INFO:', line
print 'INFO: mount checking completed cleanly'
mtab = run(['mount'], host=dut)
found = 'on /config' in mtab
print 'INFO: /config', 'IS' if found else 'NOT', 'mounted'
def store_memory_artifact(content, section, postfix):
"""Store content on artifact server in section with postfix"""
# it might be nice to avoid copying in store_local_artifact
segments = make_segments(section, postfix)
destination = ARTIFACTS_NFS_PATH + '/'.join(segments)
parent = os.path.split(destination)[0]
run(['mkdir', '-p', parent])
fileobj = file(destination, 'wb')
fileobj.write(content)
fileobj.close()
return destination
def check_service(service):
while (not tools_service(service, vm_address)):
sleep(20)
print 'INFO: Found %s service running.' % service
print 'INFO: doing reboot'
reboot_windows(dut, domain, vm_address)
print 'INFO: done reboot, waiting for VM to come back up'
run(['xec-vm', '-n', domain['name'], 'switch'], host=dut)
print 'INFO: waiting for windows to boot'
wait_for_windows(dut, guest)
print 'HEADLINE: done reboot'
def check_service(service):
while (not tools_service(service, vm_address)):
sleep(20)
print 'INFO: Found %s service running.' % service
print 'INFO: doing reboot'
reboot_windows(dut, domain, vm_address)
print 'INFO: done reboot, waiting for VM to come back up'
run(['xec-vm', '-n', domain['name'], 'switch'], host=dut)
print 'INFO: waiting for windows to boot'
wait_for_windows(dut, guest)
print 'HEADLINE: done reboot'
def vm_poweroff(dut, who='all'):
"""force poweroff a VM from domo"""
domlist = find_guest_vms(dut)
for domain in domlist:
if who == 'all' or domain['name'] == who:
run(['xec-vm', '-n', domain['name'], 'destroy'],
host=dut,
timeout=20)
for domain in domlist:
if who == 'all' or domain['name'] == who:
wait_for_guest_to_go_down(dut, domain['name'])
def check_mounts(dut):
"""Check mounts are as expected on dut"""
writefile(FILE_PATH, BASH_SCRIPT, host=dut)
run(['chmod', '+x', FILE_PATH], host=dut)
out = run([FILE_PATH], host=dut)
for line in out.split('\n'):
print 'INFO:', line
print 'INFO: mount checking completed cleanly'
mtab = run(['mount'], host=dut)
found = 'on /config' in mtab
print 'INFO: /config', 'IS' if found else 'NOT', 'mounted'
def get_disk_key(dut, disk_uuid):
key_dir = run(['xec', 'get', 'platform-crypto-key-dirs'],
host=dut,
word_split=True)[0]
disk_keys = [
join(key_dir, key)
for key in run(['ls', key_dir], word_split=True, host=dut)
if key.startswith(disk_uuid)
]
if len(disk_keys) > 1:
raise MultipleDiskKeys(disk_keys, dut, guest, disk_uuid)
return disk_keys[0] if disk_keys else None
def checkTPM(machine, vms, steps, build, test_path, caller):
r = run(['cryptsetup', 'luksDump', '/dev/xenclient/config'], host=machine)
tslib.cmdResponse(r, 'cryptsetup luksDump /dev/xenclient/config')
f = 0
for i in [1, 7]:
if 'Key Slot ' + str(i) + ': ENABLED' not in r: f = 1
for i in [0, 2, 3, 4, 5, 6]:
if 'Key Slot ' + str(i) + ': DISABLED' not in r: f = 1
if f: tslib.pauseToDebug("Command response is not as expected")
r = run(['cat', '$(find', '/sys/', '-name', 'pcrs)'], host=machine)
tslib.cmdResponse(r, 'cat $(find /sys/ -name pcrs)')
def checkTPM(machine,vms,steps,build,test_path,caller):
r = run(['cryptsetup','luksDump','/dev/xenclient/config'], host=machine)
tslib.cmdResponse(r, 'cryptsetup luksDump /dev/xenclient/config')
f=0
for i in [1,7]:
if 'Key Slot '+str(i)+': ENABLED' not in r: f=1
for i in [0,2,3,4,5,6]:
if 'Key Slot '+str(i)+': DISABLED' not in r: f=1
if f: tslib.pauseToDebug("Command response is not as expected")
r = run(['cat','$(find','/sys/','-name','pcrs)'], host=machine)
tslib.cmdResponse(r, 'cat $(find /sys/ -name pcrs)')
def disableStartOnBoot(machine, vms, steps, build, test_path, caller):
print "INFO: Disabling autoboot for ", vms, " VM"
r = run(['xec-vm', '-n', vms, 'set', 'start-on-boot', 'false'],
host=machine)
tslib.cmdResponse(r, 'xec-vm -n ' + vms + ' set start-on-boot false')
print "INFO: Rebooting host"
power_control.reboot(machine)
r = run(['xec-vm', '-n', vms, 'get', 'state'], host=machine)
if 'stopped' not in r:
tslib.pauseToDebug("VM started with XC boot and this is not expected")
else:
print 'INFO:', vms, 'did not start on XC boot'
def policyAudio(machine,vms,steps,build,test_path,caller):
tslib.forcepowerstate(machine, 'off', vms)
r = run(['xec-vm','-n',vms,'set','policy-audio-access','false'], host=machine)
tslib.cmdResponse(r, 'xec-vm -n '+vms+' set policy-audio-access false')
windows_transitions.vm_poweron(machine, vms)
tslib.interact(machine, "Play audio on the test VM and ensure that it fails")
tslib.forcepowerstate(machine, 'off', vms)
r = run(['xec-vm','-n',vms,'set','policy-audio-access','true'], host=machine)
tslib.cmdResponse(r, 'xec-vm -n '+vms+' set policy-audio-access true')
windows_transitions.vm_poweron(machine, vms)
tslib.interact(machine, "Play audio on the test VM and ensure that audio plays")
def stubdomStatusDom(machine,vm): # checks if subdom is running in dom0
domid = run(['xec-vm','-n',vm,'get','domid'], host=machine)
print 'INFO: domid of ',vm,' is ',domid
r = run(['ps','-ef'], host=machine)
r = string.split(r,'\n')
l = []
for line in r:
if 'qemu' in line: l.append(line)
tslib.cmdResponse('\n'.join(l), 'ps aux | grep qemu')
searchStr = ('-d '+domid).rstrip('\n')
if searchStr in ' '.join(l): return 1
else: return 0
def nilfvm(machine,vms,steps,build,test_path,caller):
tslib.forcepowerstate(machine, 'off', vms)
r = run(['cd','/storage/nilfvm','nilfvm-create','--rootfs=nilfvm-rootfs.i686.cpio.bz2','--size=256','--config=service-nilfvm'], host=machine)
tslib.cmdResponse(r, 'nilfvm-create --rootfs=nilfvm-rootfs.i686.cpio.bz2 --size=256 --config=service-nilfvm')
vm_uuid = run(['xec-vm','-n',vms,'get','uuid'], host=machine)
vm_uuid = vm_uuid.rstrip('\n')
tslib.cmdResponse(vm_uuid, 'xec-vm -n '+vms+' get uuid')
r = run(['xec-vm','-u',vm_uuid,'set','track-dependencies','true'], host=machine)
tslib.cmdResponse(r, 'xec-vm -u '+vm_uuid+' set track-dependencies true')
nilfvm_uuid = run(['xec-vm','-n',nilfvm01,'get','uuid'], host=machine)
r = run(['xec-vm','-u',vm_uuid,'--nic','0','set','backend-uuid',nilfvm_uuid], host=machine)
tslib.cmdResponse(r, 'xec-vm -u '+vm_uuid+' --nic 0 set backend-uuid '+nilfvm_uuid)
def stubdomStatusDom(machine, vm): # checks if subdom is running in dom0
domid = run(['xec-vm', '-n', vm, 'get', 'domid'], host=machine)
print 'INFO: domid of ', vm, ' is ', domid
r = run(['ps', '-ef'], host=machine)
r = string.split(r, '\n')
l = []
for line in r:
if 'qemu' in line: l.append(line)
tslib.cmdResponse('\n'.join(l), 'ps aux | grep qemu')
searchStr = ('-d ' + domid).rstrip('\n')
if searchStr in ' '.join(l): return 1
else: return 0
def start_logging(dut):
print 'INFO:', 'kill old dbus monitors'
run(KILL_DBUS_MONITOR, host=dut)
print 'INFO:', 'enable dbus eavesdrop'
run(['echo "'+ALLOW_EAVESDROP+'" > /storage/eaves.sh'], host=dut, shell=True)
run(['/storage/eaves.sh'], host=dut)
print 'INFO:', 'reload dbus config'
run(DBUS_CMD+['ReloadConfig'], host=dut)
print 'INFO:', 'start dbus logging'
run(['dbus-monitor', '--system', '>', '%s&'% DBUS_LOG], host=dut)
def forcepowerstate(machine, reqstate, vm_name='all'):
domlist = find_guest_vms(machine)
for domain in domlist:
if (vm_name == 'all' or vm_name == domain['name']):
pow_state = get_vm_powerstate(machine, domain['name'])
pow_state = pow_state.rstrip('\n')
if (reqstate == 'on'):
if (pow_state != 'running'):
start_vm(machine, domain['name'])
elif (reqstate == 'off'):
if (pow_state == 'running'):
run(['xec-vm', '-n', domain['name'], 'shutdown'],
host=machine)
def enableStubdom(machine, vms, steps, build, test_path, caller):
status = run(['xec-vm', '-n', vms, 'get', 'stubdom'], host=machine)
if 'true' in status:
print "INFO: stubdom is already enabled, exiting.."
exit()
count = xenopslistcount(machine, vms)
tslib.forcepowerstate(machine, 'off', vms)
r = run(['xec-vm', '-n', vms, 'set', 'stubdom', 'true'], host=machine)
tslib.cmdResponse(r, 'xec-vm -n' + vms + 'set stubdom true')
windows_transitions.vm_poweron(machine, vms)
if not checkStubdom(machine, vms, count, 0):
tslib.pauseToDebug(
"qemu is either running in dom0 or service VM have not started")
