def run_virsh_uri(test, params, env):
"""
Test the command virsh uri
(1) Call virsh uri
(2) Call virsh -c remote_uri uri
(3) Call virsh uri with an unexpected option
(4) Call virsh uri with libvirtd service stop
"""
connect_uri = libvirt_vm.normalize_connect_uri( params.get("connect_uri",
"default") )
option = params.get("options")
target_uri = params.get("target_uri")
if target_uri:
if target_uri.count('EXAMPLE.COM'):
raise error.TestError('target_uri configuration set to sample value')
logging.info("The target_uri: %s", target_uri)
cmd = "virsh -c %s uri" % target_uri
else:
cmd = "virsh uri %s" % option
# Prepare libvirtd service
check_libvirtd = params.has_key("libvirtd")
if check_libvirtd:
libvirtd = params.get("libvirtd")
if libvirtd == "off":
libvirt_vm.service_libvirtd_control("stop")
# Run test case
logging.info("The command: %s", cmd)
try:
uri_test = virsh.canonical_uri(option, uri=connect_uri,
ignore_status=False,
debug=True)
status = 0 # good
except error.CmdError:
status = 1 # bad
uri_test = ''
# Recover libvirtd service start
if libvirtd == "off":
libvirt_vm.service_libvirtd_control("start")
# Check status_error
status_error = params.get("status_error")
if status_error == "yes":
if status == 0:
raise error.TestFail("Command: %s succeeded "
"(incorrect command)" % cmd)
else:
logging.info("command: %s is a expected error", cmd)
elif status_error == "no":
if cmp(target_uri, uri_test) != 0:
raise error.TestFail("Virsh cmd uri %s != %s." %
(uri_test, target_uri))
if status != 0:
raise error.TestFail("Command: %s failed "
"(correct command)" % cmd)
def run_virsh_domuuid(test, params, env):
"""
Test command: virsh domuuid.
"""
vm_name = params.get("main_vm", "vm1")
vm = env.get_vm(vm_name)
vm.verify_alive()
# Get parameters
vm_ref = params.get("domuuid_vm_ref", "domname")
vm_state = params.get("domuuid_vm_state", "running")
addition_arg = params.get("domuuid_addition_arg")
libvirtd = params.get("libvirtd", "on")
status_error = params.get("status_error", "no")
domid = vm.get_id()
vmxml = libvirt_xml.VMXML.new_from_dumpxml(vm_name)
xml_domuuid = vmxml.uuid
logging.debug("UUID in XML is:\n%s", xml_domuuid)
if vm_state == "shutoff":
vm.destroy()
# Prepare options
if vm_ref == "domid":
vm_ref = domid
elif vm_ref == "hex_id":
vm_ref = hex(int(domid))
elif vm_ref == "domname":
vm_ref = vm_name
# Add additional argument
if vm_ref and addition_arg:
vm_ref = "%s %s" % (vm_ref, addition_arg)
# Prepare libvirtd state
if libvirtd == "off":
libvirt_vm.service_libvirtd_control("stop")
result = virsh.domuuid(vm_ref)
logging.debug(result)
status = result.exit_status
output = result.stdout.strip()
# Recover libvirtd service start
if libvirtd == "off":
libvirt_vm.service_libvirtd_control("start")
# Check status_error
if status_error == "yes":
if status == 0:
raise error.TestFail("Run successfully with wrong command!")
elif status_error == "no":
if status != 0:
raise error.TestFail("Run failed with right command.")
elif xml_domuuid != output:
raise error.TestFail("UUID from virsh command is not expected.")
def run_virsh_nodeinfo(test, params, env):
"""
Test the command virsh nodeinfo
(1) Call virsh nodeinfo
(2) Call virsh nodeinfo with an unexpected option
(3) Call virsh nodeinfo with libvirtd service stop
"""
def _check_nodeinfo(nodeinfo_output, verify_str, column):
cmd = "echo \"%s\" | grep \"%s\" | awk '{print $%s}'" % (nodeinfo_output, verify_str, column)
cmd_result = utils.run(cmd, ignore_status=True)
stdout = cmd_result.stdout.strip()
logging.debug("Info %s on nodeinfo output:%s" % (verify_str, stdout))
return stdout
def output_check(nodeinfo_output):
# Check CPU model
cpu_model_nodeinfo = _check_nodeinfo(nodeinfo_output, "CPU model", 3)
cpu_model_os = utils.get_current_kernel_arch()
if not re.match(cpu_model_nodeinfo, cpu_model_os):
raise error.TestFail("Virsh nodeinfo output didn't match CPU model")
# Check number of CPUs
cpus_nodeinfo = _check_nodeinfo(nodeinfo_output, "CPU(s)", 2)
cpus_os = utils.count_cpus()
if int(cpus_nodeinfo) != cpus_os:
raise error.TestFail("Virsh nodeinfo output didn't match number of "
"CPU(s)")
# Check CPU frequency
cpu_frequency_nodeinfo = _check_nodeinfo(nodeinfo_output, 'CPU frequency', 3)
cmd = ("cat /proc/cpuinfo | grep 'cpu MHz' | head -n1 | "
"awk '{print $4}' | awk -F. '{print $1}'")
cmd_result = utils.run(cmd, ignore_status=True)
cpu_frequency_os = cmd_result.stdout.strip()
print cpu_frequency_os
if not re.match(cpu_frequency_nodeinfo, cpu_frequency_os):
raise error.TestFail("Virsh nodeinfo output didn't match CPU "
"frequency")
# Check CPU socket(s)
cpu_sockets_nodeinfo = int(_check_nodeinfo(nodeinfo_output, 'CPU socket(s)', 3))
cmd = "grep 'physical id' /proc/cpuinfo | uniq | sort | uniq |wc -l"
cmd_result = utils.run(cmd, ignore_status=True)
cpu_NUMA_nodeinfo = _check_nodeinfo(nodeinfo_output, 'NUMA cell(s)', 3)
cpu_sockets_os = int(cmd_result.stdout.strip())/int(cpu_NUMA_nodeinfo)
if cpu_sockets_os != cpu_sockets_nodeinfo:
raise error.TestFail("Virsh nodeinfo output didn't match CPU "
"socket(s)")
# Check Core(s) per socket
cores_per_socket_nodeinfo = _check_nodeinfo(nodeinfo_output, 'Core(s) per socket', 4)
cmd = "grep 'cpu cores' /proc/cpuinfo | head -n1 | awk '{print $4}'"
cmd_result = utils.run(cmd, ignore_status=True)
cores_per_socket_os = cmd_result.stdout.strip()
if not re.match(cores_per_socket_nodeinfo, cores_per_socket_os):
raise error.TestFail("Virsh nodeinfo output didn't match Core(s) "
"per socket")
# Check Memory size
memory_size_nodeinfo = int(_check_nodeinfo(nodeinfo_output, 'Memory size', 3))
memory_size_os = utils.memtotal()
if memory_size_nodeinfo != memory_size_os:
raise error.TestFail("Virsh nodeinfo output didn't match "
"Memory size")
# Prepare libvirtd service
check_libvirtd = params.has_key("libvirtd")
if check_libvirtd:
libvirtd = params.get("libvirtd")
if libvirtd == "off":
libvirt_vm.service_libvirtd_control("stop")
# Run test case
option = params.get("virsh_node_options")
cmd_result = virsh.nodeinfo(ignore_status=True, extra=option)
logging.info("Output:\n%s", cmd_result.stdout.strip())
logging.info("Status: %d", cmd_result.exit_status)
logging.error("Error: %s", cmd_result.stderr.strip())
output = cmd_result.stdout.strip()
status = cmd_result.exit_status
# Recover libvirtd service start
if libvirtd == "off":
libvirt_vm.service_libvirtd_control("start")
# Check status_error
status_error = params.get("status_error")
if status_error == "yes":
if status == 0:
if libvirtd == "off":
raise error.TestFail("Command 'virsh nodeinfo' succeeded "
"with libvirtd service stopped, incorrect")
else:
raise error.TestFail("Command 'virsh nodeinfo %s' succeeded"
"(incorrect command)" % option)
elif status_error == "no":
output_check(output)
if status != 0:
raise error.TestFail("Command 'virsh nodeinfo %s' failed "
"(correct command)" % option)
def run_virsh_numatune(test, params, env):
"""
Test numa tuning
1) Positive testing
1.1) get the current numa parameters for a running/shutoff guest
1.2) set the current numa parameters for a running/shutoff guest
1.2.1) set valid 'mode' parameters
1.2.2) set valid 'nodeset' parameters
2) Negative testing
2.1) get numa parameters
2.1.1) invalid options
2.1.2) stop cgroup service
2.2) set numa parameters
2.2.1) invalid 'mode' parameters
2.2.2) invalid 'nodeset' parameters
2.2.3) change 'mode' for a running guest and 'mode' is not 'strict'
2.2.4) change 'nodeset' for running guest with mode of 'interleave'
'interleave' or 'preferred' numa mode
2.2.5) stop cgroup service
"""
# Run test case
vm_name = params.get("vms")
vm = env.get_vm(vm_name)
status_error = params.get("status_error", "no")
libvirtd = params.get("libvirtd", "on")
cgconfig = params.get("cgconfig", "on")
start_vm = params.get("start_vm", "no")
change_parameters = params.get("change_parameters", "no")
########## positive and negative testing #########
if status_error == "no":
if change_parameters == "no":
get_numa_parameter(params)
else:
set_numa_parameter(params)
if cgconfig == "off":
# Need to shutdown a running guest before stopping cgconfig service
# and will start the guest after restarting libvirtd service
if vm.is_alive():
vm.destroy()
if utils_cgroup.service_cgconfig_control("status"):
utils_cgroup.service_cgconfig_control("stop")
# Refresh libvirtd service to get latest cgconfig service change
if libvirtd == "restart":
libvirt_vm.service_libvirtd_control("restart")
# Recover previous running guest
if cgconfig == "off" and libvirtd == "restart" \
and not vm.is_alive() and start_vm == "yes":
vm.start()
if status_error == "yes":
if change_parameters == "no":
get_numa_parameter(params)
else:
set_numa_parameter(params)
# Recover cgconfig and libvirtd service
if not utils_cgroup.service_cgconfig_control("status"):
utils_cgroup.service_cgconfig_control("start")
libvirt_vm.service_libvirtd_control("restart")
def run_virsh_freecell(test, params, env):
"""
Test the command virsh freecell
(1) Call virsh freecell
(2) Call virsh freecell --all
(3) Call virsh freecell with a numeric argument
(4) Call virsh freecell xyz
(5) Call virsh freecell with libvirtd service stop
"""
connect_uri = libvirt_vm.normalize_connect_uri( params.get("connect_uri",
"default") )
option = params.get("virsh_freecell_options")
# Prepare libvirtd service
check_libvirtd = params.has_key("libvirtd")
if check_libvirtd:
libvirtd = params.get("libvirtd")
if libvirtd == "off":
libvirt_vm.service_libvirtd_control("stop")
# Run test case
cmd_result = virsh.freecell(ignore_status=True, extra=option,
uri=connect_uri, debug=True)
output = cmd_result.stdout.strip()
status = cmd_result.exit_status
# Recover libvirtd service start
if libvirtd == "off":
libvirt_vm.service_libvirtd_control("start")
# Check the output
if virsh.has_help_command('numatune'):
OLD_LIBVIRT = False
else:
OLD_LIBVIRT = True
if option == '--all':
raise error.TestNAError("Older libvirt virsh freecell "
"doesn't support --all option")
def output_check(freecell_output):
if not re.search("ki?B", freecell_output, re.IGNORECASE):
raise error.TestFail("virsh freecell output invalid: " + freecell_output)
# Check status_error
status_error = params.get("status_error")
if status_error == "yes":
if status == 0:
if libvirtd == "off":
raise error.TestFail("Command 'virsh freecell' succeeded "
"with libvirtd service stopped, incorrect")
else:
# newer libvirt
if not OLD_LIBVIRT:
raise error.TestFail("Command 'virsh freecell %s' succeeded"
"(incorrect command)" % option)
else: # older libvirt
raise error.TestNAError('Older libvirt virsh freecell '
'incorrectly processes extranious'
'command-line options')
elif status_error == "no":
output_check(output)
if status != 0:
raise error.TestFail("Command 'virsh freecell %s' failed "
"(correct command)" % option)
def run_virsh_list(test, params, env):
"""
Test command: virsh list.
1) Filt parameters according libvirtd's version
2) Prepare domain's exist state:transient,managed-save.
3) Prepare libvirt's status.
4) Execute list command.
5) Result check.
"""
def list_local_domains_on_remote(options_ref, remote_ip, remote_passwd, local_ip):
"""
Create a virsh list command and execute it on remote host.
It will list local domains on remote host.
@param options_ref:options in virsh list command.
@param remote_ip:remote host's ip.
@param remote_passwd:remote host's password.
@param local_ip:local ip, to create uri in virsh list.
@return:return status and output of the virsh list command.
"""
command_on_remote = "virsh -c qemu+ssh://%s/system list %s" % (local_ip, options_ref)
session = remote.remote_login("ssh", remote_ip, "22", "root", remote_passwd, "#")
time.sleep(5)
status, output = session.cmd_status_output(command_on_remote, internal_timeout=5)
time.sleep(5)
session.close()
return int(status), output
vm_name = params.get("main_vm", "vm1")
vm = env.get_vm(params["main_vm"])
options_ref = params.get("options_ref", "")
list_ref = params.get("list_ref", "")
vm_ref = params.get("vm_ref", "")
#Some parameters are not supported on old libvirt, skip them.
help_info = virsh.command("help list").stdout.strip()
if vm_ref and not re.search(vm_ref, help_info):
raise error.TestNAError("This version do not support vm type:%s"
% vm_ref)
if list_ref and not re.search(list_ref, help_info):
raise error.TestNAError("This version do not support list type:%s"
% list_ref)
status_error = params.get("status_error", "no")
addition_status_error = params.get("addition_status_error", "no")
domuuid = vm.get_uuid().strip()
# If a transient domain is destroyed, it will disappear.
if vm_ref == "transient" and options_ref == "inactive":
logging.info("Set addition_status_error to yes")
logging.info("because transient domain will disappear after destroyed.")
addition_status_error = "yes"
if vm_ref == "transient":
tmp_xml = vm.backup_xml()
vm.undefine()
elif vm_ref == "managed-save":
virsh.managedsave(vm_name, ignore_status=True, print_info=True)
#Prepare libvirtd status
libvirtd = params.get("libvirtd", "on")
if libvirtd == "off":
libvirt_vm.service_libvirtd_control("stop")
#run test case
if list_ref == "--uuid":
result_expected = domuuid
logging.info("%s's uuid is: %s", vm_name, domuuid)
else:
result_expected = vm_name
logging.info("domain's name is: %s", vm_name)
if options_ref == "vm_id":
domid = vm.get_id().strip()
logging.info("%s's running-id is: %s", vm_name, domid)
options_ref = "%s %s" % (domid, list_ref)
elif options_ref == "vm_uuid":
logging.info("%s's uuid is: %s", vm_name, domuuid)
options_ref = "%s %s" % (domuuid, list_ref)
elif options_ref == "inactive":
vm.destroy()
options_ref = "--inactive %s" % list_ref
elif options_ref == "vm_name":
options_ref = "%s %s" % (vm_name, list_ref)
elif options_ref == "all":
options_ref = "--all %s" % list_ref
elif options_ref == "":
options_ref = "%s" % list_ref
remote_ref = params.get("remote_ref", "local")
if remote_ref == "remote":
remote_ip = params.get("remote_ip", "none")
remote_passwd = params.get("remote_passwd", "none")
local_ip = params.get("local_ip", "none")
logging.info("Execute virsh command on remote host %s.", remote_ip)
status, output = list_local_domains_on_remote(options_ref, remote_ip, remote_passwd, local_ip)
logging.info("Status:%s", status)
logging.info("Output:\n%s", output)
else:
if vm_ref:
options_ref = "%s --%s" % (options_ref, vm_ref)
result = virsh.dom_list(options_ref, ignore_status=True, print_info=True)
status = result.exit_status
output = result.stdout.strip()
#Recover libvirtd service status
if libvirtd == "off":
libvirt_vm.service_libvirtd_control("start")
#Recover of domain
if vm_ref == "transient":
vm.define(tmp_xml)
elif vm_ref == "managed-save":
#Recover saved guest.
virsh.managedsave_remove(vm_name, ignore_status=True, print_info=True)
#Check result
status_error = (status_error == "no") and (addition_status_error == "no")
if vm_ref == "managed-save":
saved_output = re.search(vm_name+"\s+saved", output)
if saved_output:
output = saved_output.group(0)
else:
output = ""
if not status_error:
if status == 0 and re.search(result_expected, output):
raise error.TestFail("Run successful with wrong command!")
else:
if status != 0:
raise error.TestFail("Run failed with right command.")
if not re.search(result_expected, output):
raise error.TestFail("Run successful but result is not expected.")
def run_virsh_capabilities(test, params, env):
"""
Test the command virsh capabilities
(1) Call virsh capabilities
(2) Call virsh capabilities with an unexpected option
(3) Call virsh capabilities with libvirtd service stop
"""
def compare_capabilities_xml(source):
dom = parseString(source)
host = dom.getElementsByTagName('host')[0]
# check that host has a non-empty UUID tag.
uuid = host.getElementsByTagName('uuid')[0]
host_uuid_output = uuid.firstChild.data
logging.info("Host uuid (capabilities_xml):%s", host_uuid_output)
if host_uuid_output == "":
raise error.TestFail("The host uuid in capabilities_xml is none!")
# check the host arch.
arch = host.getElementsByTagName('arch')[0]
host_arch_output = arch.firstChild.data
logging.info("Host arch (capabilities_xml):%s", host_arch_output)
cmd_result = utils.run("arch", ignore_status=True)
if cmp(host_arch_output, cmd_result.stdout.strip()) != 0:
raise error.TestFail("The host arch in capabilities_xml is wrong!")
# check the host cpus num.
cpus = dom.getElementsByTagName('cpus')[0]
host_cpus_output = cpus.getAttribute('num')
logging.info("Host cpus num (capabilities_xml):%s",
host_cpus_output)
cmd = "less /proc/cpuinfo | grep processor | wc -l"
cmd_result = utils.run(cmd, ignore_status=True)
if cmp(host_cpus_output, cmd_result.stdout.strip()) != 0:
raise error.TestFail("Host cpus num (capabilities_xml) is "
"wrong")
# check the arch of guest supported.
cmd = "/usr/libexec/qemu-kvm --cpu ? | grep qemu"
cmd_result = utils.run(cmd, ignore_status=True)
guest_wordsize_array = dom.getElementsByTagName('wordsize')
length = len(guest_wordsize_array)
for i in range(length):
element = guest_wordsize_array[i]
guest_wordsize = element.firstChild.data
logging.info("Arch of guest supported (capabilities_xml):%s",
guest_wordsize)
if not re.search(guest_wordsize, cmd_result.stdout.strip()):
raise error.TestFail("The capabilities_xml gives an extra arch "
"of guest to support!")
# check the type of hyperviosr.
guest_domain_type = dom.getElementsByTagName('domain')[0]
guest_domain_type_output = guest_domain_type.getAttribute('type')
logging.info("Hypervisor (capabilities_xml):%s",
guest_domain_type_output)
cmd_result = utils.run("virsh uri", ignore_status=True)
if not re.search(guest_domain_type_output, cmd_result.stdout.strip()):
raise error.TestFail("The capabilities_xml gives an different "
"hypervisor")
connect_uri = libvirt_vm.normalize_connect_uri( params.get("connect_uri",
"default") )
# Prepare libvirtd service
if params.has_key("libvirtd"):
libvirtd = params.get("libvirtd")
if libvirtd == "off":
libvirt_vm.service_libvirtd_control("stop")
# Run test case
option = params.get("virsh_cap_options")
try:
output = virsh.capabilities(option, uri=connect_uri,
ignore_status=False, debug=True)
status = 0 # good
except error.CmdError:
status = 1 # bad
output = ''
# Recover libvirtd service start
if libvirtd == "off":
libvirt_vm.service_libvirtd_control("start")
# Check status_error
status_error = params.get("status_error")
if status_error == "yes":
if status == 0:
if libvirtd == "off":
raise error.TestFail("Command 'virsh capabilities' succeeded "
"with libvirtd service stopped, incorrect")
else:
raise error.TestFail("Command 'virsh capabilities %s' succeeded "
"(incorrect command)" % option)
elif status_error == "no":
compare_capabilities_xml(output)
if status != 0:
raise error.TestFail("Command 'virsh capabilities %s' failed "
"(correct command)" % option)
def run_virsh_nodememstats(test, params, env):
"""
Test the command virsh nodememstats
(1) Call the virsh nodememstats command
(2) Get the output
(3) Check the against /proc/meminfo output
(4) Call the virsh nodememstats command with an unexpected option
(5) Call the virsh nodememstats command with libvirtd service stop
"""
# Initialize the variables
expected = {}
actual = {}
deltas = []
name_stats = ['total', 'free', 'buffers', 'cached']
itr = int(params.get("itr"))
def virsh_check_nodememtats(actual_stats, expected_stats, delta):
"""
Check the nodememstats output value with /proc/meminfo value
"""
delta_stats = {}
for name in name_stats:
delta_stats[name] = abs(actual_stats[name] - expected_stats[name])
if 'total' in name:
if not delta_stats[name] == 0:
raise error.TestFail("Command 'virsh nodememstats' not"
" succeeded as the value for %s is "
"deviated by %d\nThe total memory "
"value is deviating-check"
% (name, delta_stats[name]))
else:
if delta_stats[name] > delta:
raise error.TestFail("Command 'virsh nodememstats' not "
"succeeded as the value for %s"
" is deviated by %d"
% (name, delta_stats[name]))
return delta_stats
# Prepare libvirtd service
check_libvirtd = params.has_key("libvirtd")
if check_libvirtd:
libvirtd = params.get("libvirtd")
if libvirtd == "off":
libvirt_vm.service_libvirtd_control("stop")
# Get the option for the test case
option = params.get("virsh_nodememstats_options")
# Run test case for 10 iterations
# (default can be changed in subtests.cfg file)
# and print the final statistics
for i in range(itr):
output = virsh.nodememstats(option)
# Get the status of the virsh command executed
status = output.exit_status
# Get status_error option for the test case
status_error = params.get("status_error")
if status_error == "yes":
if status == 0:
if libvirtd == "off":
libvirt_vm.service_libvirtd_control("start")
raise error.TestFail("Command 'virsh nodememstats' "
"succeeded with libvirtd service"
" stopped, incorrect")
else:
raise error.TestFail("Command 'virsh nodememstats %s' "
"succeeded (incorrect command)"
% option)
elif status_error == "no":
if status == 0:
# From the beginning of a line, group 1 is one or
# more word-characters, followed by zero or more
# whitespace characters and a ':', then one or
# more whitespace characters, followed by group 2,
# which is one or more digit characters,
# then one or more whitespace characters followed by
# a literal 'kB' or 'KiB' sequence, e.g as below
# total : 3809340 kB
# total : 3809340 KiB
# Normalise the value to MBs
regex_obj = re.compile(r"^(\w+)\s*:\s+(\d+)\s\w+")
expected = {}
for line in output.stdout.split('\n'):
match_obj = regex_obj.search(line)
# Due to the extra space in the list
if match_obj is not None:
name = match_obj.group(1)
value = match_obj.group(2)
expected[name] = int(value) / 1024
# Get the actual value from /proc/meminfo and normalise to MBs
actual['total'] = int(utils.memtotal()) / 1024
actual['free'] = int(utils.freememtotal()) / 1024
actual['buffers'] = int(utils.read_from_meminfo('Buffers'))/1024
actual['cached'] = int(utils.read_from_meminfo('Cached')) / 1024
# Currently the delta value is kept at 200 MB this can be
# tuned based on the accuracy
# Check subtests.cfg for more details
delta = int(params.get("delta"))
output = virsh_check_nodememtats(actual, expected, delta)
deltas.append(output)
else:
raise error.TestFail("Command virsh nodememstats %s not "
"succeeded:\n%s" % (option, status))
# Recover libvirtd service start
if libvirtd == "off":
libvirt_vm.service_libvirtd_control("start")
# Print the deviated values for all iterations
if status_error == "no":
logging.debug("The following is the deviations from "
"the actual(/proc/meminfo) and expected"
" value(output of virsh nodememstats)")
for i in range(itr):
logging.debug("iteration %d:", i)
for index, name in enumerate(name_stats):
logging.debug("%19s : %d", name, deltas[i][name])
def run_virsh_dump(test, params, env):
"""
Test command: virsh dump.
This command can dump the core of a domain to a file for analysis.
1. Positive testing
1.1 Dump domain with valid options.
1.2 Avoid file system cache when dumping.
1.3 Compress the dump images to valid/invalid formats.
2. Negative testing
2.1 Dump domain to a non-exist directory.
2.2 Dump domain with invalid option.
2.3 Dump a shut-off domain.
"""
vm_name = params.get("main_vm", "vm1")
vm = env.get_vm(params["main_vm"])
options = params.get("dump_options")
dump_file = params.get("dump_file")
dump_image_format = params.get("dump_image_format")
start_vm = params.get("start_vm")
status_error = params.get("status_error", "no")
qemu_conf = "/etc/libvirt/qemu.conf"
# prepare the vm state
if vm.is_alive() and start_vm == "no":
vm.destroy()
if vm.is_dead() and start_vm == "yes":
vm.start()
def check_domstate(actual, options):
"""
Check the domain status according to dump options.
"""
if options.find('live') >= 0:
domstate = "running"
if options.find('crash') >= 0 or options.find('reset') >0:
domstate = "running"
elif options.find('crash') >=0:
domstate = "shut off"
if options.find('reset') >= 0:
domstate = "running"
elif options.find('reset') >= 0:
domstate = "running"
else:
domstate = "running"
if start_vm == "no":
domstate = "shut off"
logging.debug("Domain should %s after run dump %s", domstate, options)
if domstate == actual:
return True
else:
return False
def check_dump_format(dump_image_format, dump_file):
"""
Check the format of dumped file.
If 'dump_image_format' is not specified or invalid in qemu.conf, then
the file shoule be normal raw file, otherwise it shoud be compress to
specified format, the supported compress format including: lzop, gzip,
bzip2, and xz.
"""
valid_format = ["lzop", "gzip", "bzip2", "xz"]
if len(dump_image_format) == 0 or dump_image_format not in valid_format:
logging.debug("No need check the dumped file format")
return True
else:
file_cmd = "file %s" % dump_file
(status, output) = commands.getstatusoutput(file_cmd)
if status == 0:
logging.debug("Run file %s output: %s", dump_file, output)
actual_format = output.split(" ")[1]
if actual_format == dump_image_format:
if dump_image_format in valid_format:
logging.info("Compress dumped file to %s successfully",
dump_image_format)
return True
else:
logging.error("Compress dumped file to %s fail",
dump_image_format)
return False
else:
logging.error("Fail to check dumped file %s", dump_file)
return False
# Configure dump_image_format in /etc/libvirt/qemu.conf.
if len(dump_image_format) != 0:
conf_cmd = ("echo dump_image_format = \\\"%s\\\" >> %s" %
(dump_image_format, qemu_conf))
if os.system(conf_cmd):
logging.error("Config dump_image_format to %s fail",
dump_image_format)
libvirt_vm.service_libvirtd_control("restart")
# Deal with bypass-cache option
if options.find('bypass-cache') >= 0:
thread.start_new_thread(check_bypass,(dump_file,))
# Guarantee check_bypass function has run before dump
time.sleep(5)
# Run virsh command
cmd_result = virsh.dump(vm_name, dump_file, options,
ignore_status=True, debug=True)
status = cmd_result.exit_status
# Check libvirtd status
if libvirt_vm.service_libvirtd_control("status"):
if check_domstate(vm.state(), options):
if status_error == "yes":
if status == 0:
raise error.TestFail("Expect fail, but run successfully")
if status_error == "no":
if status != 0:
raise error.TestFail("Expect succeed, but run fail")
else:
if os.path.exists(dump_file):
if check_dump_format(dump_image_format, dump_file):
logging.info("Successfully dump domain to %s",
dump_file)
else:
raise error.TestFail("The format of dumped file "
"is wrong.")
else:
raise error.TestFail("Fail to find domain dumped file.")
else:
raise error.TestFail("Domain status check fail.")
else:
raise error.TestFail("Libvirtd service is dead.")
if os.path.exists(dump_file):
os.remove(dump_file)
if len(dump_image_format) != 0:
clean_qemu_conf = "sed -i '$d' %s " % qemu_conf
if os.system(clean_qemu_conf):
raise error.TestFail("Fail to recover %s", qemu_conf)
def run_virsh_numatune(test, params, env):
"""
Test numa tuning
1) Positive testing
1.1) get the current numa parameters for a running/shutoff guest
1.2) set the current numa parameters for a running/shutoff guest
1.2.1) set valid 'mode' parameters
1.2.2) set valid 'nodeset' parameters
2) Negative testing
2.1) get numa parameters
2.1.1) invalid options
2.1.2) stop cgroup service
2.2) set numa parameters
2.2.1) invalid 'mode' parameters
2.2.2) invalid 'nodeset' parameters
2.2.3) change 'mode' for a running guest and 'mode' is not 'strict'
2.2.4) change 'nodeset' for running guest with mode of 'interleave'
'interleave' or 'preferred' numa mode
2.2.5) stop cgroup service
"""
# Run test case
vm_name = params.get("vms")
vm = env.get_vm(vm_name)
original_vm_xml = libvirt_xml.VMXML.new_from_dumpxml(vm_name)
status_error = params.get("status_error", "no")
libvirtd = params.get("libvirtd", "on")
cgconfig = params.get("cgconfig", "on")
start_vm = params.get("start_vm", "no")
change_parameters = params.get("change_parameters", "no")
# Make sure vm is down if start not requested
if start_vm == "no" and vm.is_alive():
vm.destroy()
########## positive and negative testing #########
try:
if status_error == "no":
if change_parameters == "no":
get_numa_parameter(params)
else:
set_numa_parameter(params)
if cgconfig == "off":
# Need to shutdown a running guest before stopping cgconfig service
# and will start the guest after restarting libvirtd service
if vm.is_alive():
vm.destroy()
if utils_cgroup.service_cgconfig_control("status"):
utils_cgroup.service_cgconfig_control("stop")
# Refresh libvirtd service to get latest cgconfig service change
if libvirtd == "restart":
libvirt_vm.service_libvirtd_control("restart")
# Recover previous running guest
if cgconfig == "off" and libvirtd == "restart" \
and not vm.is_alive() and start_vm == "yes":
vm.start()
if status_error == "yes":
if change_parameters == "no":
get_numa_parameter(params)
else:
set_numa_parameter(params)
# Recover cgconfig and libvirtd service
if not utils_cgroup.service_cgconfig_control("status"):
utils_cgroup.service_cgconfig_control("start")
libvirt_vm.service_libvirtd_control("restart")
finally:
vm.destroy()
# Restore guest, first remove existing
original_vm_xml.undefine()
# Recover based on original XML
original_vm_xml.define()
def run_virsh_uri(test, params, env):
"""
Test the command virsh uri
(1) Call virsh uri
(2) Call virsh -c remote_uri uri
(3) Call virsh uri with an unexpected option
(4) Call virsh uri with libvirtd service stop
"""
connect_uri = libvirt_vm.normalize_connect_uri(
params.get("connect_uri", "default"))
option = params.get("options")
target_uri = params.get("target_uri")
if target_uri:
if target_uri.count('EXAMPLE.COM'):
raise error.TestError(
'target_uri configuration set to sample value')
logging.info("The target_uri: %s", target_uri)
cmd = "virsh -c %s uri" % target_uri
else:
cmd = "virsh uri %s" % option
# Prepare libvirtd service
check_libvirtd = params.has_key("libvirtd")
if check_libvirtd:
libvirtd = params.get("libvirtd")
if libvirtd == "off":
libvirt_vm.service_libvirtd_control("stop")
# Run test case
logging.info("The command: %s", cmd)
try:
uri_test = virsh.canonical_uri(option,
uri=connect_uri,
ignore_status=False,
debug=True)
status = 0 # good
except error.CmdError:
status = 1 # bad
uri_test = ''
# Recover libvirtd service start
if libvirtd == "off":
libvirt_vm.service_libvirtd_control("start")
# Check status_error
status_error = params.get("status_error")
if status_error == "yes":
if status == 0:
raise error.TestFail("Command: %s succeeded "
"(incorrect command)" % cmd)
else:
logging.info("command: %s is a expected error", cmd)
elif status_error == "no":
if cmp(target_uri, uri_test) != 0:
raise error.TestFail("Virsh cmd uri %s != %s." %
(uri_test, target_uri))
if status != 0:
raise error.TestFail("Command: %s failed "
"(correct command)" % cmd)
def run_virsh_nodecpustats(test, params, env):
"""
Test the command virsh nodecpustats
(1) Call the virsh nodecpustats command for all cpu host cpus
separately
(2) Get the output
(3) Check the against /proc/stat output(o) for respective cpu
user: o[0] + o[1]
system: o[2] + o[5] + o[6]
idle: o[3]
iowait: o[4]
(4) Call the virsh nodecpustats command with an unexpected option
(5) Call the virsh nodecpustats command with libvirtd service stop
"""
def virsh_check_nodecpustats_percpu(actual_stats):
"""
Check the acual nodecpustats output value
total time <= system uptime
"""
# Normalise to seconds from nano seconds
total = float((actual_stats['system'] + actual_stats['user'] + \
actual_stats['idle'] + actual_stats['iowait'])/(10 ** 9))
uptime = float(utils.get_uptime())
if not total <= uptime:
raise error.TestFail("Commands 'virsh nodecpustats' not succeeded"
" as total time: %f is more"
" than uptime: %f" % (total, uptime))
return True
def virsh_check_nodecpustats(actual_stats, cpu_count):
"""
Check the acual nodecpustats output value
total time <= system uptime
"""
# Normalise to seconds from nano seconds and get for one cpu
total = float(((actual_stats['system'] + actual_stats['user'] + \
actual_stats['idle'] + actual_stats['iowait'])/(10 ** 9))/(
cpu_count))
uptime = float(utils.get_uptime())
if not total <= uptime:
raise error.TestFail("Commands 'virsh nodecpustats' not succeeded"
" as total time: %f is more"
" than uptime: %f" % (total, uptime))
return True
def virsh_check_nodecpustats_percentage(actual_per):
"""
Check the actual nodecpustats percentage adds upto 100%
"""
total = int(round(actual_per['user'] + actual_per['system'] + \
actual_per['idle'] + actual_per['iowait']))
if not total == 100:
raise error.TestFail("Commands 'virsh nodecpustats' not succeeded"
" as the total percentage value: %d"
" is not equal 100" % total)
def parse_output(output):
"""
To get the output parsed into a dictionary
@param: virsh command output
@return: dict of user,system,idle,iowait times
"""
# From the beginning of a line, group 1 is one or more word-characters,
# followed by zero or more whitespace characters and a ':',
# then one or more whitespace characters,
# followed by group 2, which is one or more digit characters,
# e.g as below
# user: 6163690000000
#
regex_obj = re.compile(r"^(\w+)\s*:\s+(\d+)")
actual = {}
for line in output.stdout.split('\n'):
match_obj = regex_obj.search(line)
# Due to the extra space in the list
if match_obj is not None:
name = match_obj.group(1)
value = match_obj.group(2)
actual[name] = int(value)
return actual
def parse_percentage_output(output):
"""
To get the output parsed into a dictionary
@param: virsh command output
@return: dict of user,system,idle,iowait times
"""
# From the beginning of a line, group 1 is one or more word-characters,
# followed by zero or more whitespace characters and a ':',
# then one or more whitespace characters,
# followed by group 2, which is one or more digit characters,
# e.g as below
# user: 1.5%
#
regex_obj = re.compile(r"^(\w+)\s*:\s+(\d+.\d+)")
actual_percentage = {}
for line in output.stdout.split('\n'):
match_obj = regex_obj.search(line)
# Due to the extra space in the list
if match_obj is not None:
name = match_obj.group(1)
value = match_obj.group(2)
actual_percentage[name] = float(value)
return actual_percentage
# Initialize the variables
itr = int(params.get("inner_test_iterations"))
option = params.get("virsh_cpunodestats_options")
status_error = params.get("status_error")
libvirtd = params.get("libvirtd", "on")
# Prepare libvirtd service
if libvirtd == "off":
libvirt_vm.service_libvirtd_control("stop")
# Get the host cpu count
host_cpu_count = utils.count_cpus()
# Run test case for 5 iterations default can be changed in subtests.cfg file
for i in range(itr):
if status_error == "yes":
output = virsh.nodecpustats(ignore_status=True, option=option)
status = output.exit_status
if status == 0:
if libvirtd == "off":
libvirt_vm.service_libvirtd_control("start")
raise error.TestFail("Command 'virsh nodecpustats' "
"succeeded with libvirtd service "
"stopped, incorrect")
else:
raise error.TestFail("Command 'virsh nodecpustats %s' "
"succeeded (incorrect command)" %
option)
elif status_error == "no":
# Run the testcase for each cpu to get the cpu stats
for cpu in range(host_cpu_count):
option = "--cpu %d" % cpu
output = virsh.nodecpustats(ignore_status=True, option=option)
status = output.exit_status
if status == 0:
actual_value = parse_output(output)
virsh_check_nodecpustats_percpu(actual_value)
else:
raise error.TestFail("Command 'virsh nodecpustats %s'"
"not succeeded" % option)
# Run the test case for each cpu to get the cpu stats in percentage
for cpu in range(host_cpu_count):
option = "--cpu %d --percent" % cpu
output = virsh.nodecpustats(ignore_status=True, option=option)
status = output.exit_status
if status == 0:
actual_value = parse_percentage_output(output)
virsh_check_nodecpustats_percentage(actual_value)
else:
raise error.TestFail("Command 'virsh nodecpustats %s'"
" not succeeded" % option)
option = ''
# Run the test case for total cpus to get the cpus stats
output = virsh.nodecpustats(ignore_status=True, option=option)
status = output.exit_status
if status == 0:
actual_value = parse_output(output)
virsh_check_nodecpustats(actual_value, host_cpu_count)
else:
raise error.TestFail("Command 'virsh nodecpustats %s'"
" not succeeded" % option)
# Run the test case for the total cpus to get the stats in percentage
option = "--percent"
output = virsh.nodecpustats(ignore_status=True, option=option)
status = output.exit_status
if status == 0:
actual_value = parse_percentage_output(output)
virsh_check_nodecpustats_percentage(actual_value)
else:
raise error.TestFail("Command 'virsh nodecpustats %s'"
" not succeeded" % option)
# Recover libvirtd service start
if libvirtd == "off":
libvirt_vm.service_libvirtd_control("start")
def run_virsh_freecell(test, params, env):
"""
Test the command virsh freecell
(1) Call virsh freecell
(2) Call virsh freecell --all
(3) Call virsh freecell with a numeric argument
(4) Call virsh freecell xyz
(5) Call virsh freecell with libvirtd service stop
"""
connect_uri = libvirt_vm.normalize_connect_uri( params.get("connect_uri",
"default") )
option = params.get("virsh_freecell_options")
# Prepare libvirtd service
check_libvirtd = params.has_key("libvirtd")
if check_libvirtd:
libvirtd = params.get("libvirtd")
if libvirtd == "off":
libvirt_vm.service_libvirtd_control("stop")
# Run test case
cmd_result = virsh.freecell(ignore_status=True, extra=option,
uri=connect_uri, debug=True)
output = cmd_result.stdout.strip()
status = cmd_result.exit_status
# Recover libvirtd service start
if libvirtd == "off":
libvirt_vm.service_libvirtd_control("start")
# Check the output
if virsh.has_help_command('numatune'):
OLD_LIBVIRT = False
else:
OLD_LIBVIRT = True
if option == '--all':
raise error.TestNAError("Older libvirt virsh freecell "
"doesn't support --all option")
def output_check(freecell_output):
if not re.search("ki?B", freecell_output, re.IGNORECASE):
raise error.TestFail("virsh freecell output invalid: " + freecell_output)
# Check status_error
status_error = params.get("status_error")
if status_error == "yes":
if status == 0:
if libvirtd == "off":
raise error.TestFail("Command 'virsh freecell' succeeded "
"with libvirtd service stopped, incorrect")
else:
# newer libvirt
if not OLD_LIBVIRT:
raise error.TestFail("Command 'virsh freecell %s' succeeded"
"(incorrect command)" % option)
else: # older libvirt
raise error.TestNAError('Older libvirt virsh freecell '
'incorrectly processes extranious'
'command-line options')
elif status_error == "no":
output_check(output)
if status != 0:
raise error.TestFail("Command 'virsh freecell %s' failed "
"(correct command)" % option)
def run_virsh_setmem(test, params, env):
"""
Test command: virsh setmem.
1) Prepare vm environment.
2) Handle params
3) Prepare libvirtd status.
4) Run test command and wait for current memory's stable.
5) Recover environment.
4) Check result.
TODO: support new libvirt with more options.
"""
def vm_proc_meminfo(session):
proc_meminfo = session.cmd_output("cat /proc/meminfo")
# verify format and units are expected
return int(re.search(r'MemTotal:\s+(\d+)\s+kB', proc_meminfo).group(1))
def make_domref(domarg, vm_ref, domid, vm_name, domuuid):
# Specify domain as argument or parameter
if domarg == "yes":
dom_darg_key = "domainarg"
else:
dom_darg_key = "domain"
# How to reference domain
if vm_ref == "domid":
dom_darg_value = domid
elif vm_ref == "domname":
dom_darg_value = vm_name
elif vm_ref == "domuuid":
dom_darg_value = domuuid
elif vm_ref == "none":
dom_darg_value = None
elif vm_ref == "emptystring":
dom_darg_value = '""'
else: # stick in value directly
dom_darg_value = vm_ref
return {dom_darg_key:dom_darg_value}
def make_sizeref(sizearg, mem_ref, original_mem):
if sizearg == "yes":
size_darg_key = "sizearg"
else:
size_darg_key = "size"
if mem_ref == "halfless":
size_darg_value = "%d" % (original_mem / 2)
elif mem_ref == "halfmore":
size_darg_value = "%d" % int(original_mem * 1.5) # no fraction
elif mem_ref == "same":
size_darg_value = "%d" % original_mem
elif mem_ref == "emptystring":
size_darg_value = '""'
elif mem_ref == "zero":
size_darg_value = "0"
elif mem_ref == "toosmall":
size_darg_value = "1024"
elif mem_ref == "toobig":
size_darg_value = "1099511627776" # (KiB) One Petabyte
elif mem_ref == "none":
size_darg_value = None
else: # stick in value directly
size_darg_value = mem_ref
return {size_darg_key:size_darg_value}
def is_in_range(actual, expected, error_percent):
deviation = 100 - (100 * (float(actual) / float(expected)))
logging.debug("Deviation: %0.2f%%" % float(deviation))
return float(deviation) <= float(error_percent)
def is_old_libvirt():
regex = r'\s+\[--size\]\s+'
return bool( not virsh.has_command_help_match('setmem', regex) )
def print_debug_stats(original_inside_mem, original_outside_mem,
test_inside_mem, test_outside_mem,
expected_mem, delta_percentage):
dbgmsg = ("Original inside mem : %d KiB\n"
"Expected inside mem : %d KiB\n"
"Actual inside mem : %d KiB\n"
"Inside mem deviation : %0.2f%%\n"
"Original outside mem : %d KiB\n"
"Expected outside mem : %d KiB\n"
"Actual outside mem : %d KiB\n"
"Outside mem deviation: %0.2f%%\n"
"Acceptable deviation %0.2f%%" % (
original_inside_mem,
expected_mem,
test_inside_mem,
100 - (100 * (float(test_inside_mem) / float(expected_mem))),
original_outside_mem,
expected_mem,
test_outside_mem,
100 - (100 * (float(test_outside_mem) / float(expected_mem))),
float(delta_percentage) ))
for dbgline in dbgmsg.splitlines():
logging.debug(dbgline)
### MAIN TEST CODE ###
# Process cartesian parameters
vm_ref = params.get("setmem_vm_ref", "")
mem_ref = params.get("setmem_mem_ref", "")
flags = params.get("setmem_flags", "")
status_error = params.get("status_error", "no")
old_libvirt_fail = params.get("setmem_old_libvirt_fail", "no")
quiesce_delay = int(params.get("setmem_quiesce_delay", "1"))
domarg = params.get("setmem_domarg", "no")
sizearg = params.get("setmem_sizearg", "no")
libvirt = params.get("libvirt", "on")
delta_percentage = float(params.get("setmem_delta_per", "10"))
start_vm = params.get("start_vm", "yes")
vm_name = params.get("main_vm")
paused_after_start_vm = "yes" == params.get("paused_after_start_vm", "no")
# Gather environment parameters
vm = env.get_vm(params["main_vm"])
if start_vm == "yes":
if paused_after_start_vm:
vm.resume()
session = vm.wait_for_login()
original_inside_mem = vm_proc_meminfo(session)
session.close()
if paused_after_start_vm:
vm.pause()
else:
session = None
# Retrieve known mem value, convert into kilobytes
original_inside_mem = int(params.get("mem", "1024")) * 1024
original_outside_mem = vm.get_used_mem()
domid = vm.get_id()
domuuid = vm.get_uuid()
uri = vm.connect_uri
old_libvirt = is_old_libvirt()
if old_libvirt:
logging.info("Running test on older libvirt")
use_kilobytes = True
else:
logging.info("Running test on newer libvirt")
use_kilobytes = False
# Argument pattern is complex, build with dargs
dargs = {'flagstr':flags,
'use_kilobytes':use_kilobytes,
'uri':uri, 'ignore_status':True, "debug":True}
dargs.update( make_domref(domarg, vm_ref, domid, vm_name, domuuid) )
dargs.update( make_sizeref(sizearg, mem_ref, original_outside_mem) )
# Prepare libvirtd status
if libvirt == "off":
libvirt_vm.service_libvirtd_control("stop")
else: # make sure it's running
libvirt_vm.service_libvirtd_control("restart")
if status_error == "yes" or old_libvirt_fail == "yes":
logging.info("Error Test: Expecting an error to occur!")
result = virsh.setmem(**dargs)
status = result.exit_status
# Recover libvirtd status
if libvirt == "off":
libvirt_vm.service_libvirtd_control("start")
if status is 0:
logging.info("Waiting %d seconds for VM memory to settle", quiesce_delay)
# It takes time for kernel to settle on new memory
# and current clean pages is not predictable. Therefor,
# extremely difficult to determine quiescence, so
# sleep one second per error percent is reasonable option.
time.sleep(quiesce_delay)
# Gather stats if not running error test
if status_error == "no" and old_libvirt_fail == "no":
if vm.state() == "shut off":
vm.start()
# Make sure it's never paused
vm.resume()
session = vm.wait_for_login()
# Actual results
test_inside_mem = vm_proc_meminfo(session)
session.close()
test_outside_mem = vm.get_used_mem()
# Expected results for both inside and outside
if sizearg == "yes":
expected_mem = int(dargs["sizearg"])
else:
expected_mem = int(dargs["size"])
print_debug_stats(original_inside_mem, original_outside_mem,
test_inside_mem, test_outside_mem,
expected_mem, delta_percentage)
if status is 0: # Restore original memory
restore_status = virsh.setmem(domainarg=vm_name,
sizearg=original_inside_mem,
ignore_status=True).exit_status
if restore_status is not 0:
logging.warning("Failed to restore VM's original memory to %s KiB"
% original_inside_mem)
else:
# virsh setmem failed, no need to restore
pass
# Don't care about memory comparison on error test
if status_error == "no" and old_libvirt_fail == "no":
outside_in_range = is_in_range(test_outside_mem, expected_mem,
delta_percentage)
inside_in_range = is_in_range(test_inside_mem, expected_mem,
delta_percentage)
if status is not 0 or not outside_in_range or not inside_in_range:
msg = "test conditions not met: "
if status is not 0:
msg += "Non-zero virsh setmem exit code. " # maybe multiple
if not outside_in_range: # errors
msg += "Outside memory deviated. "
if not inside_in_range:
msg += "Inside memory deviated. "
raise error.TestFail(msg)
return # Normal test passed
else: # Verify an error test resulted in error
if status is 0:
raise error.TestFail("Error test did not result in an error")
else: # status != 0
if not old_libvirt: # new libvirt should not have returnd error
raise error.TestFail("Newer libvirt failed when it should not")
else:
# Test passes for old_libvirt == True
pass
def run_virsh_net_create(test, params, env):
"""
Test command: virsh net-create.
1) Gather test parameters
2) Store current libvirt host network state
3) Call virsh net create on possibly modified network XML
4) Recover original libvirtd and network.
5) Check result.
"""
# Gather test parameters
uri = libvirt_vm.normalize_connect_uri( params.get("connect_uri",
"default"))
status_error = "yes" == params.get("status_error", "no")
# libvirtd also controls use of Virsh or VirshPersistent
libvirtd = "on" == params.get("libvirtd", "on")
net_name = params.get("net_create_net_name", "") # default is tested
net_uuid = params.get("net_create_net_uuid", "") # default is tested
options_ref = params.get("net_create_options_ref", "") # default is tested
extra = params.get("net_create_options_extra", "") # extra cmd-line params.
corrupt = "yes" == params.get("net_create_corrupt_xml", "no")
remove_existing = "yes" == params.get("net_create_remove_existing", "yes")
# Dictionary or None value
bridge = eval(params.get("net_create_bridge", "None"),
{'__builtins__':None}, {})
# make easy to maintain
virsh_dargs = {'uri':uri, 'debug':False, 'ignore_status':False}
vrsh = virsh.VirshPersistent(**virsh_dargs)
# Prepare environment and record current net_state_dict
backup = libvirt_xml.NetworkXML.new_all_networks_dict(vrsh)
backup_state = vrsh.net_state_dict()
logging.debug("Backed up network(s): %s", backup_state)
# Make some XML to use for testing, for now we just copy 'default'
test_xml = xml_utils.TempXMLFile() # temporary file
try:
# LibvirtXMLBase.__str__ returns XML content
test_xml.write(str(backup['default']))
test_xml.flush()
except (KeyError, AttributeError):
raise error.TestNAError("Test requires default network to exist")
if corrupt:
# find file size
test_xml.seek(0, 2) # end
# write garbage at middle of file
test_xml.seek(test_xml.tell() / 2)
test_xml.write('"<network><<<BAD>>><\'XML</network\>'
'!@#$%^&*)>(}>}{CORRUPTE|>!')
test_xml.flush()
# Assume next user might want to read
test_xml.seek(0)
if remove_existing:
for netxml in backup.values():
netxml.orbital_nuclear_strike()
#Run test case
# Prepare libvirtd status
if not libvirtd: # TODO: Support stop on remote system
vrsh.close_session() # all virsh commands will probably fail
libvirt_vm.service_libvirtd_control("stop")
# Be nice to user
if status_error:
logging.info("The following is expected to fail...")
try:
# Determine depth of test - if low-level calls are needed
if (options_ref or extra or corrupt):
logging.debug("Performing low-level net-create test")
# vrsh will act like it's own virsh-dargs, i.e. it is dict-like
test_passed = do_low_level_test(vrsh, test_xml, options_ref, extra)
else: # high-level test
logging.debug("Performing high-level net-create test")
# vrsh will act like it's own virsh-dargs, i.e. it is dict-like
test_passed = do_high_level_test(vrsh, test_xml, net_name,
net_uuid, bridge)
finally:
# Be nice to user
if status_error:
# In case test itself has errors, warn they are real.
logging.info("The following is NOT expected to fail...")
# Recover libvirtd service start
if not libvirtd: # TODO: Support start on remote system
libvirt_vm.service_libvirtd_control("start")
vrsh.new_session() # Virsh instance shared with backup netxml values
# Done with file, cleanup
del test_xml
# Recover environment
leftovers = libvirt_xml.NetworkXML.new_all_networks_dict(vrsh)
for netxml in leftovers.values():
netxml.orbital_nuclear_strike()
# Recover from backup
for netxml in backup.values():
netxml.create()
# autostart = True requires persistent = True first!
for state in ['active', 'persistent', 'autostart']:
netxml[state] = backup_state[netxml.name][state]
# Close down persistent virsh session (including for all netxml copies)
if hasattr(vrsh, 'close_session'):
vrsh.close_session()
# Check Result
if status_error: # An error was expected
if test_passed: # Error was not produced
raise error.TestFail("Error test did not fail!")
else: # no error expected
if not test_passed:
raise error.TestFail("Normal test returned failure")
def run_virsh_setmem(test, params, env):
"""
Test command: virsh setmem.
1) Prepare vm environment.
2) Handle params
3) Prepare libvirtd status.
4) Run test command and wait for current memory's stable.
5) Recover environment.
4) Check result.
TODO: support new libvirt with more options.
"""
def vm_proc_meminfo(session):
proc_meminfo = session.cmd_output("cat /proc/meminfo")
# verify format and units are expected
return int(re.search(r'MemTotal:\s+(\d+)\s+kB', proc_meminfo).group(1))
def make_domref(domarg, vm_ref, domid, vm_name, domuuid):
# Specify domain as argument or parameter
if domarg == "yes":
dom_darg_key = "domainarg"
else:
dom_darg_key = "domain"
# How to reference domain
if vm_ref == "domid":
dom_darg_value = domid
elif vm_ref == "domname":
dom_darg_value = vm_name
elif vm_ref == "domuuid":
dom_darg_value = domuuid
elif vm_ref == "none":
dom_darg_value = None
elif vm_ref == "emptystring":
dom_darg_value = '""'
else: # stick in value directly
dom_darg_value = vm_ref
return {dom_darg_key: dom_darg_value}
def make_sizeref(sizearg, mem_ref, original_mem):
if sizearg == "yes":
size_darg_key = "sizearg"
else:
size_darg_key = "size"
if mem_ref == "halfless":
size_darg_value = "%d" % (original_mem / 2)
elif mem_ref == "halfmore":
size_darg_value = "%d" % int(original_mem * 1.5) # no fraction
elif mem_ref == "same":
size_darg_value = "%d" % original_mem
elif mem_ref == "emptystring":
size_darg_value = '""'
elif mem_ref == "zero":
size_darg_value = "0"
elif mem_ref == "toosmall":
size_darg_value = "1024"
elif mem_ref == "toobig":
size_darg_value = "1099511627776" # (KiB) One Petabyte
elif mem_ref == "none":
size_darg_value = None
else: # stick in value directly
size_darg_value = mem_ref
return {size_darg_key: size_darg_value}
def is_in_range(actual, expected, error_percent):
deviation = 100 - (100 * (float(actual) / float(expected)))
logging.debug("Deviation: %0.2f%%" % float(deviation))
return float(deviation) <= float(error_percent)
def is_old_libvirt():
regex = r'\s+\[--size\]\s+'
return bool(not virsh.has_command_help_match('setmem', regex))
def print_debug_stats(original_inside_mem, original_outside_mem,
test_inside_mem, test_outside_mem, expected_mem,
delta_percentage):
dbgmsg = ("Original inside mem : %d KiB\n"
"Expected inside mem : %d KiB\n"
"Actual inside mem : %d KiB\n"
"Inside mem deviation : %0.2f%%\n"
"Original outside mem : %d KiB\n"
"Expected outside mem : %d KiB\n"
"Actual outside mem : %d KiB\n"
"Outside mem deviation: %0.2f%%\n"
"Acceptable deviation %0.2f%%" %
(original_inside_mem, expected_mem, test_inside_mem, 100 -
(100 * (float(test_inside_mem) / float(expected_mem))),
original_outside_mem, expected_mem, test_outside_mem, 100 -
(100 * (float(test_outside_mem) / float(expected_mem))),
float(delta_percentage)))
for dbgline in dbgmsg.splitlines():
logging.debug(dbgline)
### MAIN TEST CODE ###
# Process cartesian parameters
vm_ref = params.get("setmem_vm_ref", "")
mem_ref = params.get("setmem_mem_ref", "")
flags = params.get("setmem_flags", "")
status_error = params.get("status_error", "no")
old_libvirt_fail = params.get("setmem_old_libvirt_fail", "no")
quiesce_delay = int(params.get("setmem_quiesce_delay", "1"))
domarg = params.get("setmem_domarg", "no")
sizearg = params.get("setmem_sizearg", "no")
libvirt = params.get("libvirt", "on")
delta_percentage = float(params.get("setmem_delta_per", "10"))
start_vm = params.get("start_vm", "yes")
vm_name = params.get("main_vm")
# Gather environment parameters
vm = env.get_vm(params["main_vm"])
if start_vm == "yes":
session = vm.wait_for_login()
original_inside_mem = vm_proc_meminfo(session)
session.close()
else:
session = None
# Retrieve known mem value, convert into kilobytes
original_inside_mem = int(params.get("mem", "1024")) * 1024
original_outside_mem = vm.get_used_mem()
domid = vm.get_id()
domuuid = vm.get_uuid()
uri = vm.connect_uri
old_libvirt = is_old_libvirt()
if old_libvirt:
logging.info("Running test on older libvirt")
use_kilobytes = True
else:
logging.info("Running test on newer libvirt")
use_kilobytes = False
# Argument pattern is complex, build with dargs
dargs = {
'flagstr': flags,
'use_kilobytes': use_kilobytes,
'uri': uri,
'ignore_status': True,
"debug": True
}
dargs.update(make_domref(domarg, vm_ref, domid, vm_name, domuuid))
dargs.update(make_sizeref(sizearg, mem_ref, original_outside_mem))
# Prepare libvirtd status
if libvirt == "off":
libvirt_vm.service_libvirtd_control("stop")
else: # make sure it's running
libvirt_vm.service_libvirtd_control("restart")
if status_error == "yes" or old_libvirt_fail == "yes":
logging.info("Error Test: Expecting an error to occur!")
result = virsh.setmem(**dargs)
status = result.exit_status
# Recover libvirtd status
if libvirt == "off":
libvirt_vm.service_libvirtd_control("start")
if status is 0:
logging.info("Waiting %d seconds for VM memory to settle",
quiesce_delay)
# It takes time for kernel to settle on new memory
# and current clean pages is not predictable. Therefor,
# extremely difficult to determine quiescence, so
# sleep one second per error percent is reasonable option.
time.sleep(quiesce_delay)
# Gather stats if not running error test
if status_error == "no" and old_libvirt_fail == "no":
if vm.state() == "shut off":
vm.start()
elif vm.state() == "paused":
vm.resume()
session = vm.wait_for_login()
# Actual results
test_inside_mem = vm_proc_meminfo(session)
session.close()
test_outside_mem = vm.get_used_mem()
# Expected results for both inside and outside
if sizearg == "yes":
expected_mem = int(dargs["sizearg"])
else:
expected_mem = int(dargs["size"])
print_debug_stats(original_inside_mem, original_outside_mem,
test_inside_mem, test_outside_mem, expected_mem,
delta_percentage)
if status is 0: # Restore original memory
restore_status = virsh.setmem(domainarg=vm_name,
sizearg=original_inside_mem,
ignore_status=True).exit_status
if restore_status is not 0:
logging.warning(
"Failed to restore VM's original memory to %s KiB" %
original_inside_mem)
else:
# virsh setmem failed, no need to restore
pass
# Don't care about memory comparison on error test
if status_error == "no" and old_libvirt_fail == "no":
outside_in_range = is_in_range(test_outside_mem, expected_mem,
delta_percentage)
inside_in_range = is_in_range(test_inside_mem, expected_mem,
delta_percentage)
if status is not 0 or not outside_in_range or not inside_in_range:
msg = "test conditions not met: "
if status is not 0:
msg += "Non-zero virsh setmem exit code. " # maybe multiple
if not outside_in_range: # errors
msg += "Outside memory deviated. "
if not inside_in_range:
msg += "Inside memory deviated. "
raise error.TestFail(msg)
return # Normal test passed
else: # Verify an error test resulted in error
if status is 0:
raise error.TestFail("Error test did not result in an error")
else: # status != 0
if not old_libvirt: # new libvirt should not have returnd error
raise error.TestFail("Newer libvirt failed when it should not")
else:
# Test passes for old_libvirt == True
pass
raise error.TestFail("Command virsh autostart is failed:\n%s" %
result.stdout)
else:
logging.debug("Pool: %s marked for autostart successfully",
pool_name)
# Step (7)
if not check_list_state(pool_name, "active"):
raise error.TestFail("State of pool: %s marked as inactive"
"instead of active" % pool_name)
if not check_list_autostart(pool_name, "yes"):
raise error.TestFail("Autostart of pool: %s marked as no"
"instead of yes" % pool_name)
# Step (7.a)
libvirt_vm.service_libvirtd_control("stop")
# TODO: Add more negative cases after libvirtd stopped
libvirt_vm.service_libvirtd_control("start")
# Step (7.b)
if not check_list_state(pool_name, "active"):
raise error.TestFail("State of pool: %s marked as inactive"
"instead of active" % pool_name)
if not check_list_autostart(pool_name, "yes"):
raise error.TestFail("Autostart of pool: %s marked as no"
"instead of yes" % pool_name)
# Step (8)
result = virsh.pool_undefine(pool_name, ignore_status=True)
if result.exit_status == 0:
raise error.TestFail("Command virsh pool-undefine succeeded"
def run_virsh_capabilities(test, params, env):
"""
Test the command virsh capabilities
(1) Call virsh capabilities
(2) Call virsh capabilities with an unexpected option
(3) Call virsh capabilities with libvirtd service stop
"""
def compare_capabilities_xml(source):
dom = parseString(source)
host = dom.getElementsByTagName('host')[0]
# check that host has a non-empty UUID tag.
uuid = host.getElementsByTagName('uuid')[0]
host_uuid_output = uuid.firstChild.data
logging.info("Host uuid (capabilities_xml):%s", host_uuid_output)
if host_uuid_output == "":
raise error.TestFail("The host uuid in capabilities_xml is none!")
# check the host arch.
arch = host.getElementsByTagName('arch')[0]
host_arch_output = arch.firstChild.data
logging.info("Host arch (capabilities_xml):%s", host_arch_output)
cmd_result = utils.run("arch", ignore_status=True)
if cmp(host_arch_output, cmd_result.stdout.strip()) != 0:
raise error.TestFail("The host arch in capabilities_xml is wrong!")
# check the host cpus num.
cpus = dom.getElementsByTagName('cpus')[0]
host_cpus_output = cpus.getAttribute('num')
logging.info("Host cpus num (capabilities_xml):%s", host_cpus_output)
cmd = "less /proc/cpuinfo | grep processor | wc -l"
cmd_result = utils.run(cmd, ignore_status=True)
if cmp(host_cpus_output, cmd_result.stdout.strip()) != 0:
raise error.TestFail("Host cpus num (capabilities_xml) is "
"wrong")
# check the arch of guest supported.
cmd = "/usr/libexec/qemu-kvm --cpu ? | grep qemu"
cmd_result = utils.run(cmd, ignore_status=True)
guest_wordsize_array = dom.getElementsByTagName('wordsize')
length = len(guest_wordsize_array)
for i in range(length):
element = guest_wordsize_array[i]
guest_wordsize = element.firstChild.data
logging.info("Arch of guest supported (capabilities_xml):%s",
guest_wordsize)
if not re.search(guest_wordsize, cmd_result.stdout.strip()):
raise error.TestFail(
"The capabilities_xml gives an extra arch "
"of guest to support!")
# check the type of hyperviosr.
guest_domain_type = dom.getElementsByTagName('domain')[0]
guest_domain_type_output = guest_domain_type.getAttribute('type')
logging.info("Hypervisor (capabilities_xml):%s",
guest_domain_type_output)
cmd_result = utils.run("virsh uri", ignore_status=True)
if not re.search(guest_domain_type_output, cmd_result.stdout.strip()):
raise error.TestFail("The capabilities_xml gives an different "
"hypervisor")
connect_uri = libvirt_vm.normalize_connect_uri(
params.get("connect_uri", "default"))
# Prepare libvirtd service
if params.has_key("libvirtd"):
libvirtd = params.get("libvirtd")
if libvirtd == "off":
libvirt_vm.service_libvirtd_control("stop")
# Run test case
option = params.get("virsh_cap_options")
try:
output = virsh.capabilities(option,
uri=connect_uri,
ignore_status=False,
debug=True)
status = 0 # good
except error.CmdError:
status = 1 # bad
output = ''
# Recover libvirtd service start
if libvirtd == "off":
libvirt_vm.service_libvirtd_control("start")
# Check status_error
status_error = params.get("status_error")
if status_error == "yes":
if status == 0:
if libvirtd == "off":
raise error.TestFail(
"Command 'virsh capabilities' succeeded "
"with libvirtd service stopped, incorrect")
else:
raise error.TestFail(
"Command 'virsh capabilities %s' succeeded "
"(incorrect command)" % option)
elif status_error == "no":
compare_capabilities_xml(output)
if status != 0:
raise error.TestFail("Command 'virsh capabilities %s' failed "
"(correct command)" % option)
def run_virsh_domname(test, params, env):
"""
Test command: virsh domname <id/uuid>.
1) Prepare libvirtd status and test environment.
2) Try to get domname through valid and invalid command.
3) Recover libvirtd service and test environment.
4) Check result.
"""
vm_name = params.get("main_vm", "vm1")
vm = env.get_vm(params["main_vm"])
domid = vm.get_id()
domuuid = vm.get_uuid()
connect_uri = vm.connect_uri
#run test case
options_ref = params.get("domname_options_ref", "id")
addition_status_error = params.get("addition_status_error", "no")
status_error = params.get("status_error", "no")
options = params.get("domname_options", "%s")
options_suffix = params.get("domname_options_suffix", "")
if options_ref == "id":
options_ref = domid
if options_ref == "-":
options = "%s"
else:
options_ref = int(domid)
elif options_ref == "uuid":
options_ref = domuuid
# UUID can get domain name in any state.
logging.warning("Reset addition_status_error to NO for uuid test!")
addition_status_error = "no"
elif options_ref == "name":
options_ref = vm_name
if options:
options = (options % options_ref)
if options_suffix:
options = options + " " + options_suffix
#Prepare libvirtd status
libvirtd = params.get("libvirtd", "on")
if libvirtd == "off":
libvirt_vm.service_libvirtd_control("stop")
result = virsh.domname(options,
ignore_status=True,
debug=True,
uri=connect_uri)
#Recover libvirtd service to start
if libvirtd == "off":
libvirt_vm.service_libvirtd_control("start")
addition_status_error = "yes"
#check status_error
status_error = (status_error == "no") and (addition_status_error == "no")
if status_error:
if result.exit_status != 0 or result.stdout.strip() != vm_name:
raise error.TestFail("Run failed because unexpected result.")
else:
if result.exit_status == 0 and result.stdout.strip() != vm_name:
raise error.TestFail("Run passed but result is unexpected.")
def run_virsh_nodecpustats(test, params, env):
"""
Test the command virsh nodecpustats
(1) Call the virsh nodecpustats command for all cpu host cpus
separately
(2) Get the output
(3) Check the against /proc/stat output(o) for respective cpu
user: o[0] + o[1]
system: o[2] + o[5] + o[6]
idle: o[3]
iowait: o[4]
(4) Call the virsh nodecpustats command with an unexpected option
(5) Call the virsh nodecpustats command with libvirtd service stop
"""
def virsh_check_nodecpustats_percpu(actual_stats):
"""
Check the acual nodecpustats output value
total time <= system uptime
"""
# Normalise to seconds from nano seconds
total = float((actual_stats['system'] + actual_stats['user'] + \
actual_stats['idle'] + actual_stats['iowait'])/(10 ** 9))
uptime = float(utils.get_uptime())
if not total <= uptime:
raise error.TestFail("Commands 'virsh nodecpustats' not succeeded"
" as total time: %f is more"
" than uptime: %f" % (total, uptime))
return True
def virsh_check_nodecpustats(actual_stats, cpu_count):
"""
Check the acual nodecpustats output value
total time <= system uptime
"""
# Normalise to seconds from nano seconds and get for one cpu
total = float(((actual_stats['system'] + actual_stats['user'] + \
actual_stats['idle'] + actual_stats['iowait'])/(10 ** 9))/(
cpu_count))
uptime = float(utils.get_uptime())
if not total <= uptime:
raise error.TestFail("Commands 'virsh nodecpustats' not succeeded"
" as total time: %f is more"
" than uptime: %f" % (total, uptime))
return True
def virsh_check_nodecpustats_percentage(actual_per):
"""
Check the actual nodecpustats percentage adds upto 100%
"""
total = int(round(actual_per['user'] + actual_per['system'] + \
actual_per['idle'] + actual_per['iowait']))
if not total == 100:
raise error.TestFail("Commands 'virsh nodecpustats' not succeeded"
" as the total percentage value: %d"
" is not equal 100" % total)
def parse_output(output):
"""
To get the output parsed into a dictionary
@param: virsh command output
@return: dict of user,system,idle,iowait times
"""
# From the beginning of a line, group 1 is one or more word-characters,
# followed by zero or more whitespace characters and a ':',
# then one or more whitespace characters,
# followed by group 2, which is one or more digit characters,
# e.g as below
# user: 6163690000000
#
regex_obj = re.compile(r"^(\w+)\s*:\s+(\d+)")
actual = {}
for line in output.stdout.split('\n'):
match_obj = regex_obj.search(line)
# Due to the extra space in the list
if match_obj is not None:
name = match_obj.group(1)
value = match_obj.group(2)
actual[name] = int(value)
return actual
def parse_percentage_output(output):
"""
To get the output parsed into a dictionary
@param: virsh command output
@return: dict of user,system,idle,iowait times
"""
# From the beginning of a line, group 1 is one or more word-characters,
# followed by zero or more whitespace characters and a ':',
# then one or more whitespace characters,
# followed by group 2, which is one or more digit characters,
# e.g as below
# user: 1.5%
#
regex_obj = re.compile(r"^(\w+)\s*:\s+(\d+.\d+)")
actual_percentage = {}
for line in output.stdout.split('\n'):
match_obj = regex_obj.search(line)
# Due to the extra space in the list
if match_obj is not None:
name = match_obj.group(1)
value = match_obj.group(2)
actual_percentage[name] = float(value)
return actual_percentage
# Initialize the variables
itr = int(params.get("inner_test_iterations"))
option = params.get("virsh_cpunodestats_options")
status_error = params.get("status_error")
libvirtd = params.get("libvirtd", "on")
# Prepare libvirtd service
if libvirtd == "off":
libvirt_vm.service_libvirtd_control("stop")
# Get the host cpu count
host_cpu_count = utils.count_cpus()
# Run test case for 5 iterations default can be changed in subtests.cfg file
for i in range(itr):
if status_error == "yes":
output = virsh.nodecpustats(ignore_status=True, option=option)
status = output.exit_status
if status == 0:
if libvirtd == "off":
libvirt_vm.service_libvirtd_control("start")
raise error.TestFail("Command 'virsh nodecpustats' "
"succeeded with libvirtd service "
"stopped, incorrect")
else:
raise error.TestFail("Command 'virsh nodecpustats %s' "
"succeeded (incorrect command)" % option)
elif status_error == "no":
# Run the testcase for each cpu to get the cpu stats
for cpu in range(host_cpu_count):
option = "--cpu %d" % cpu
output = virsh.nodecpustats(ignore_status=True, option=option)
status = output.exit_status
if status == 0:
actual_value = parse_output(output)
virsh_check_nodecpustats_percpu(actual_value)
else:
raise error.TestFail("Command 'virsh nodecpustats %s'"
"not succeeded" % option)
# Run the test case for each cpu to get the cpu stats in percentage
for cpu in range(host_cpu_count):
option = "--cpu %d --percent" % cpu
output = virsh.nodecpustats(ignore_status=True, option=option)
status = output.exit_status
if status == 0:
actual_value = parse_percentage_output(output)
virsh_check_nodecpustats_percentage(actual_value)
else:
raise error.TestFail("Command 'virsh nodecpustats %s'"
" not succeeded" % option)
option = ''
# Run the test case for total cpus to get the cpus stats
output = virsh.nodecpustats(ignore_status=True, option=option)
status = output.exit_status
if status == 0:
actual_value = parse_output(output)
virsh_check_nodecpustats(actual_value, host_cpu_count)
else:
raise error.TestFail("Command 'virsh nodecpustats %s'"
" not succeeded" % option)
# Run the test case for the total cpus to get the stats in percentage
option = "--percent"
output = virsh.nodecpustats(ignore_status=True, option=option)
status = output.exit_status
if status == 0:
actual_value = parse_percentage_output(output)
virsh_check_nodecpustats_percentage(actual_value)
else:
raise error.TestFail("Command 'virsh nodecpustats %s'"
" not succeeded" % option)
# Recover libvirtd service start
if libvirtd == "off":
libvirt_vm.service_libvirtd_control("start")
def run_virsh_domname(test, params, env):
"""
Test command: virsh domname <id/uuid>.
1) Prepare libvirtd status and test environment.
2) Try to get domname through valid and invalid command.
3) Recover libvirtd service and test environment.
4) Check result.
"""
vm_name = params.get("main_vm", "vm1")
vm = env.get_vm(params["main_vm"])
domid = vm.get_id()
domuuid = vm.get_uuid()
connect_uri = vm.connect_uri
#run test case
options_ref = params.get("options_ref", "id")
addition_status_error = params.get("addition_status_error", "no")
status_error = params.get("status_error", "no")
options = params.get("options", "%s")
options_suffix = params.get("options_suffix", "")
if options_ref == "id":
options_ref = domid
if options_ref == "-":
options = "%s"
else:
options_ref = int(domid)
elif options_ref == "uuid":
options_ref = domuuid
# UUID can get domain name in any state.
logging.warning("Reset addition_status_error to NO for uuid test!")
addition_status_error = "no"
elif options_ref == "name":
options_ref = vm_name
if options:
options = (options % options_ref)
if options_suffix:
options = options + " " + options_suffix
#Prepare libvirtd status
libvirtd = params.get("libvirtd", "on")
if libvirtd == "off":
libvirt_vm.service_libvirtd_control("stop")
result = virsh.domname(options, ignore_status=True, debug=True,
uri=connect_uri)
#Recover libvirtd service to start
if libvirtd == "off":
libvirt_vm.service_libvirtd_control("start")
addition_status_error = "yes"
#check status_error
status_error = (status_error == "no") and (addition_status_error == "no")
if status_error:
if result.exit_status != 0 or result.stdout.strip() != vm_name:
raise error.TestFail("Run failed because unexpected result.")
else:
if result.exit_status == 0 and result.stdout.strip() != vm_name:
raise error.TestFail("Run passed but result is unexpected.")
def run_virsh_nodeinfo(test, params, env):
"""
Test the command virsh nodeinfo
(1) Call virsh nodeinfo
(2) Call virsh nodeinfo with an unexpected option
(3) Call virsh nodeinfo with libvirtd service stop
"""
def _check_nodeinfo(nodeinfo_output, verify_str, column):
cmd = "echo \"%s\" | grep \"%s\" | awk '{print $%s}'" % (
nodeinfo_output, verify_str, column)
cmd_result = utils.run(cmd, ignore_status=True)
stdout = cmd_result.stdout.strip()
logging.debug("Info %s on nodeinfo output:%s" % (verify_str, stdout))
return stdout
def output_check(nodeinfo_output):
# Check CPU model
cpu_model_nodeinfo = _check_nodeinfo(nodeinfo_output, "CPU model", 3)
cpu_model_os = utils.get_current_kernel_arch()
if not re.match(cpu_model_nodeinfo, cpu_model_os):
raise error.TestFail(
"Virsh nodeinfo output didn't match CPU model")
# Check number of CPUs
cpus_nodeinfo = _check_nodeinfo(nodeinfo_output, "CPU(s)", 2)
cpus_os = utils.count_cpus()
if int(cpus_nodeinfo) != cpus_os:
raise error.TestFail(
"Virsh nodeinfo output didn't match number of "
"CPU(s)")
# Check CPU frequency
cpu_frequency_nodeinfo = _check_nodeinfo(nodeinfo_output,
'CPU frequency', 3)
cmd = ("cat /proc/cpuinfo | grep 'cpu MHz' | head -n1 | "
"awk '{print $4}' | awk -F. '{print $1}'")
cmd_result = utils.run(cmd, ignore_status=True)
cpu_frequency_os = cmd_result.stdout.strip()
print cpu_frequency_os
if not re.match(cpu_frequency_nodeinfo, cpu_frequency_os):
raise error.TestFail("Virsh nodeinfo output didn't match CPU "
"frequency")
# Check CPU socket(s)
cpu_sockets_nodeinfo = int(
_check_nodeinfo(nodeinfo_output, 'CPU socket(s)', 3))
cmd = "grep 'physical id' /proc/cpuinfo | uniq | sort | uniq |wc -l"
cmd_result = utils.run(cmd, ignore_status=True)
cpu_NUMA_nodeinfo = _check_nodeinfo(nodeinfo_output, 'NUMA cell(s)', 3)
cpu_sockets_os = int(
cmd_result.stdout.strip()) / int(cpu_NUMA_nodeinfo)
if cpu_sockets_os != cpu_sockets_nodeinfo:
raise error.TestFail("Virsh nodeinfo output didn't match CPU "
"socket(s)")
# Check Core(s) per socket
cores_per_socket_nodeinfo = _check_nodeinfo(nodeinfo_output,
'Core(s) per socket', 4)
cmd = "grep 'cpu cores' /proc/cpuinfo | head -n1 | awk '{print $4}'"
cmd_result = utils.run(cmd, ignore_status=True)
cores_per_socket_os = cmd_result.stdout.strip()
if not re.match(cores_per_socket_nodeinfo, cores_per_socket_os):
raise error.TestFail("Virsh nodeinfo output didn't match Core(s) "
"per socket")
# Check Memory size
memory_size_nodeinfo = int(
_check_nodeinfo(nodeinfo_output, 'Memory size', 3))
memory_size_os = utils.memtotal()
if memory_size_nodeinfo != memory_size_os:
raise error.TestFail("Virsh nodeinfo output didn't match "
"Memory size")
# Prepare libvirtd service
check_libvirtd = params.has_key("libvirtd")
if check_libvirtd:
libvirtd = params.get("libvirtd")
if libvirtd == "off":
libvirt_vm.service_libvirtd_control("stop")
# Run test case
option = params.get("virsh_node_options")
cmd_result = virsh.nodeinfo(ignore_status=True, extra=option)
logging.info("Output:\n%s", cmd_result.stdout.strip())
logging.info("Status: %d", cmd_result.exit_status)
logging.error("Error: %s", cmd_result.stderr.strip())
output = cmd_result.stdout.strip()
status = cmd_result.exit_status
# Recover libvirtd service start
if libvirtd == "off":
libvirt_vm.service_libvirtd_control("start")
# Check status_error
status_error = params.get("status_error")
if status_error == "yes":
if status == 0:
if libvirtd == "off":
raise error.TestFail(
"Command 'virsh nodeinfo' succeeded "
"with libvirtd service stopped, incorrect")
else:
raise error.TestFail("Command 'virsh nodeinfo %s' succeeded"
"(incorrect command)" % option)
elif status_error == "no":
output_check(output)
if status != 0:
raise error.TestFail("Command 'virsh nodeinfo %s' failed "
"(correct command)" % option)
