def get_cpu_xml(mode, tmp_file):
"""
Get CPU infomation and put it into a file.
@param: mode: Test mode, decides file's detail.
@param: tmp_file: File saves CPU infomation.
"""
cpu_xml_file = open(tmp_file, 'wb')
domxml = virsh.capabilities()
dom = parseString(domxml)
cpu_node = dom.getElementsByTagName('cpu')[0]
if mode == "modify":
vendor = cpu_node.getElementsByTagName('vendor')[0]
for node in vendor.childNodes:
if node.nodeType == node.TEXT_NODE:
vendor.removeChild(node)
break
text_node = dom.createTextNode('test_vendor')
vendor.appendChild(text_node)
cpu_node.writexml(cpu_xml_file)
elif mode == "clear":
# Clear up file detail
cpu_xml_file.truncate(0)
else:
cpu_node.writexml(cpu_xml_file)
cpu_xml_file.close()
dom.unlink()
def validate_host(to_file, test_feature):
"""
Validate the host meets the test requirement which includes a
certain feature
:param to_file: the output to be written to
:param test_feature: feature name to be searched
:raises: test.cancel if the host does not include the tested feature
"""
output = virsh.capabilities(to_file=to_file,
ignore_status=False,
debug=True)
if not check_xml(output, test_feature):
test.cancel("The capabilities do not include feature '%s'. "
"Skip the test" % test_feature)
def run(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):
cap_xml = capability_xml.CapabilityXML()
cap_xml.xml = source
# Check that host has a non-empty UUID tag.
xml_uuid = cap_xml.uuid
logging.debug("Host UUID (capabilities_xml): %s" % xml_uuid)
if xml_uuid == "":
raise error.TestFail("The host uuid in capabilities_xml is none!")
# Check the host arch.
xml_arch = cap_xml.arch
logging.debug("Host arch (capabilities_xml): %s", xml_arch)
exp_arch = utils.run("arch", ignore_status=True).stdout.strip()
if cmp(xml_arch, exp_arch) != 0:
raise error.TestFail("The host arch in capabilities_xml is expected"
" to be %s, but get %s" % (exp_arch, xml_arch))
# Check the host cpu count.
xml_cpu_count = cap_xml.cpu_count
logging.debug("Host cpus count (capabilities_xml): %s", xml_cpu_count)
cmd = "grep processor /proc/cpuinfo | wc -l"
exp_cpu_count = int(utils.run(cmd, ignore_status=True).stdout.strip())
if xml_cpu_count != exp_cpu_count:
raise error.TestFail("Host cpus count is expected to be %s, but get "
"%s" % (exp_cpu_count, xml_cpu_count))
# Check the arch of guest supported.
guest_capa = cap_xml.get_guest_capabilities()
logging.debug(guest_capa)
try:
img = utils_misc.find_command("qemu-kvm")
except ValueError:
raise error.TestNAError("Cannot find qemu-kvm")
if re.search("ppc", utils.run("arch").stdout):
cmd = img + " --cpu ? | grep ppc"
else:
cmd = img + " --cpu ? | grep qemu"
cmd_result = utils.run(cmd, ignore_status=True)
for guest in cap_xml.xmltreefile.findall('guest'):
guest_wordsize = guest.find('arch').find('wordsize').text
logging.debug("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 hypervisor.
first_guest = cap_xml.xmltreefile.findall('guest')[0]
first_domain = first_guest.find('arch').findall('domain')[0]
guest_domain_type = first_domain.get('type')
logging.debug("Hypervisor (capabilities_xml):%s", guest_domain_type)
cmd_result = utils.run("virsh uri", ignore_status=True)
if not re.search(guest_domain_type, cmd_result.stdout.strip()):
raise error.TestFail("The capabilities_xml gives an different "
"hypervisor")
# check power management support.
try:
pm_cmd = os_dep.command('pm-is-supported')
pm_cap_map = {'suspend': 'suspend_mem',
'hibernate': 'suspend_disk',
'suspend-hybrid': 'suspend_hybrid',
}
exp_pms = []
for opt in pm_cap_map:
cmd = '%s --%s' % (pm_cmd, opt)
res = utils.run(cmd, ignore_status=True)
if res.exit_status == 0:
exp_pms.append(pm_cap_map[opt])
pms = cap_xml.power_management_list
if set(exp_pms) != set(pms):
raise error.TestFail("Expected supported PMs are %s, got %s "
"instead." % (exp_pms, pms))
except ValueError:
logging.debug('Power management checking is skipped, since command '
'pm-is-supported is not found.')
connect_uri = libvirt_vm.normalize_connect_uri(params.get("connect_uri",
"default"))
# Prepare libvirtd service
if "libvirtd" in params:
libvirtd = params.get("libvirtd")
if libvirtd == "off":
utils_libvirtd.libvirtd_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":
utils_libvirtd.libvirtd_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(test, params, env):
"""
Test command: virsh hypervisor-cpu-compare
Compare CPU provided by hypervisor on the host with a CPU described by an XML file
1.Get all parameters from configuration.
2.Prepare temp file saves of CPU information.
3.Perform virsh hypervisor-cpu-compare operation.
4.Confirm the result.
"""
# Get all parameters.
file_type = params.get("compare_file_type", "domxml")
extract_mode = ("yes" == params.get("extract_mode", "no"))
action_mode = params.get("action_mode")
cpu_mode = params.get("cpu_mode", "custom")
illegal_cpu_test = ("yes" == params.get("illegal_cpu_test", "no"))
status_error = ("yes" == params.get("status_error", "no"))
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
option_str = params.get("hypv_cpu_compare_option")
invalid_option = params.get("invalid_option")
invalid_value = params.get("invalid_value")
if invalid_option:
option_str = option_str.replace(invalid_option, "")
if not libvirt_version.version_compare(4, 4, 0):
test.cancel("hypervisor-cpu-compare does not support"
" in this libvirt version")
if not vm.is_alive():
vm.start()
baseline_provider = params.get("baseline_provider", "libvirt")
dom_xml = vm_xml.VMXML.new_from_dumpxml(vm_name)
backup_xml = dom_xml.copy()
compare_file = os.path.join(data_dir.get_tmp_dir(), "cpu.xml")
domcapa_file = os.path.join(data_dir.get_tmp_dir(), "tmp_file")
def get_domain_output(cpu_mode):
"""
Prepare domain xml according cpu mode
:param cpu_mode: The name of cpu mode
:return: The domain xml data
"""
try:
cpuxml = dom_xml.cpu
if not action_mode and cpuxml.mode == cpu_mode:
return dom_xml.xmltreefile.get_element_string("/cpu")
else:
del dom_xml["cpu"]
except LibvirtXMLNotFoundError:
pass # CPU already does not exist
# Create new CPUXML
cpuxml = vm_xml.VMCPUXML()
cpuxml.mode = cpu_mode
if cpu_mode == "custom":
# Customize cpu according domcapabilities xml
domcapa_output = get_domcapa_output(test)
with open(domcapa_file, "w+") as tmp_f:
tmp_f.write(domcapa_output)
if "hypervisor" in baseline_provider:
ret = virsh.hypervisor_cpu_baseline(domcapa_file)
else:
ret = virsh.cpu_baseline(domcapa_file)
if ret.exit_status:
test.fail("Fail to run virsh (hypervisor-)cpu-baseline: %s" %
ret.stderr.strip())
cpuxml.xml = ret.stdout.strip()
if cpu_mode == "host-passthrough":
cpuxml.check = "none"
dom_xml.cpu = cpuxml
dom_xml.sync()
vm.start()
# VM start will change domxml content
v_xml = vm_xml.VMXML.new_from_dumpxml(vm_name)
return v_xml.xmltreefile.get_element_string("/cpu")
def get_options(option_str):
"""
Prepare virsh cmd options according input string
:param option_str: Input option string contains option names
:return: Virsh cmd options
"""
options = ""
emulator = dom_xml.devices.by_device_tag('emulator')[0]
osxml = dom_xml.os
if option_str.count("--virttype"):
options += "--virttype %s " % dom_xml.hypervisor_type
if option_str.count("--emulator"):
options += "--emulator %s " % emulator.path
if option_str.count("--arch"):
options += "--arch %s " % osxml.arch
if option_str.count("--machine"):
options += "--machine %s " % osxml.machine
if option_str.count("--error"):
options += "--error "
return options
try:
# Prepare options
options = get_options(option_str)
if invalid_option:
options += "%s %s " % (invalid_option, invalid_value)
# Prepare cpu compare file.
cpu_data = ""
if file_type == "domxml":
cpu_data = get_domain_output(cpu_mode)
elif file_type == "domcapa_xml":
cpu_data = get_domcapa_output(test)
elif file_type == "capa_xml":
cpu_data = virsh.capabilities()
else:
test.error("The compare file type %s is unsupported" % file_type)
# Extract cpu definition
if extract_mode:
cpu_data = get_cpu_definition(file_type, vm_name, test)
if illegal_cpu_test and file_type == "domxml":
# Make invalid cpu data by adding <host> outside of <cpu>
cpu_data = "<host>{}</host>".format(cpu_data)
with open(compare_file, "w+") as compare_file_f:
compare_file_f.write(cpu_data)
compare_file_f.flush()
compare_file_f.seek(0)
logging.debug("CPU description XML:\n%s", compare_file_f.read())
# Perform virsh cpu-compare operation.
result = virsh.hypervisor_cpu_compare(xml_file=compare_file,
options=options,
ignore_status=True,
debug=True)
msg_pattern = params.get("msg_pattern")
# Check result
if status_error and not result.exit_status:
test.fail("Expect should fail but got:\n%s" % result.stdout)
elif not status_error and result.exit_status:
test.fail("Expect success but got:\n%s" % result.stderr)
if msg_pattern:
logging.debug("Expect key word in comand output: %s", msg_pattern)
output = result.stdout.strip()
if not output:
output = result.stderr.strip()
if not re.findall(msg_pattern, output):
test.fail("Not find expect key word '%s' in command "
"output '%s'" % (msg_pattern, output))
finally:
backup_xml.sync()
if os.path.exists(domcapa_file):
os.remove(domcapa_file)
if os.path.exists(compare_file):
os.remove(compare_file)
def run(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')
host_cpus = 0
for cpu in cpus:
host_cpus += int(cpu.getAttribute('num'))
logging.info("Host cpus num (capabilities_xml):%s", host_cpus)
cmd = "less /proc/cpuinfo | grep processor | wc -l"
cmd_result = utils.run(cmd, ignore_status=True)
if cmp(host_cpus, int(cmd_result.stdout.strip())) != 0:
raise error.TestFail("Host cpus num (capabilities_xml) is "
"wrong")
# check the arch of guest supported.
try:
img = utils_misc.find_command("qemu-kvm")
except ValueError:
raise error.TestNAError("Cannot find qemu-kvm")
cmd = img + " --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":
utils_libvirtd.libvirtd_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":
utils_libvirtd.libvirtd_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(test, params, env):
"""
Test misc tests of virtual cpu features
1) check dumpxml after snapshot-create/revert
2) check vendor_id
3) check maximum vcpus with topology settings
:param test: test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment.
"""
def update_cpu_xml():
"""
Update cpu xml for test
"""
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
# Create cpu xml for test
if vmxml.xmltreefile.find('cpu'):
cpu_xml = vmxml.cpu
else:
cpu_xml = vm_xml.VMCPUXML()
if cpu_mode:
cpu_xml.mode = cpu_mode
if cpu_vendor_id:
cpu_xml.vendor_id = cpu_vendor_id
# Update vm's cpu
vmxml.cpu = cpu_xml
vmxml.sync()
if vcpu_max:
if with_topology:
vm_xml.VMXML.set_vm_vcpus(vm_name,
int(vcpu_max),
cores=int(vcpu_max),
sockets=1,
threads=1,
add_topology=with_topology,
topology_correction=with_topology)
else:
vm_xml.VMXML.set_vm_vcpus(vm_name, int(vcpu_max))
def do_snapshot(vm_name, expected_str):
"""
Run snapshot related commands: snapshot-create-as, snapshot-list
snapshot-dumpxml, snapshot-revert
:param vm_name: vm name
:param expected_str: expected string in snapshot-dumpxml
:raise: test.fail if virsh command failed
"""
snapshot_name = vm_name + "-snap"
virsh_dargs = {'debug': True}
cmd_result = virsh.snapshot_create_as(vm_name, snapshot_name,
**virsh_dargs)
libvirt.check_exit_status(cmd_result)
try:
snapshots = virsh.snapshot_list(vm_name, **virsh_dargs)
except process.CmdError:
test.fail("Failed to get snapshots list for %s" % vm_name)
if snapshot_name not in snapshots:
test.fail("The snapshot '%s' was not in snapshot-list." %
snapshot_name)
cmd_result = virsh.snapshot_dumpxml(vm_name, snapshot_name,
**virsh_dargs)
libvirt.check_result(cmd_result, expected_match=expected_str)
cmd_result = virsh.snapshot_revert(vm_name, "", "--current",
**virsh_dargs)
libvirt.check_exit_status(cmd_result)
libvirt_version.is_libvirt_feature_supported(params)
vm_name = params.get('main_vm')
vm = env.get_vm(vm_name)
cpu_mode = params.get('cpu_mode')
vcpu_max = params.get('vcpu_max')
expected_str_before_startup = params.get("expected_str_before_startup")
expected_str_after_startup = params.get("expected_str_after_startup")
test_operations = params.get("test_operations")
check_vendor_id = "yes" == params.get("check_vendor_id", "no")
virsh_edit_cmd = params.get("virsh_edit_cmd")
with_topology = "yes" == params.get("with_topology", "no")
status_error = "yes" == params.get("status_error", "no")
err_msg = params.get("err_msg")
cpu_vendor_id = None
expected_qemuline = None
cmd_in_guest = params.get("cmd_in_guest")
bkxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
try:
if check_vendor_id:
output = virsh.capabilities(debug=True)
host_vendor = re.findall(r'<vendor>(\w+)<', output)[0]
cpu_vendor_id = 'GenuineIntel'
if host_vendor != "Intel":
cpu_vendor_id = 'AuthenticAMD'
logging.debug("Set cpu vendor_id to %s on this host.",
cpu_vendor_id)
expected_qemuline = "vendor=" + cpu_vendor_id
cmd_in_guest = ("cat /proc/cpuinfo | grep vendor_id | grep {}".
format(cpu_vendor_id))
# Update xml for test
update_cpu_xml()
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
logging.debug("Pre-test xml is %s", vmxml.xmltreefile)
if expected_str_before_startup:
libvirt.check_dumpxml(vm, expected_str_before_startup)
if test_operations:
for action in test_operations.split(","):
if action == "do_snapshot":
do_snapshot(vm_name, expected_str_before_startup)
if virsh_edit_cmd:
status = libvirt.exec_virsh_edit(vm_name,
virsh_edit_cmd.split(","))
if status == status_error:
test.fail("Virsh edit got unexpected result.")
# Check if vm could start successfully
if not status_error:
result = virsh.start(vm_name, debug=True)
libvirt.check_exit_status(result)
if expected_str_after_startup:
libvirt.check_dumpxml(vm, expected_str_after_startup)
if expected_qemuline:
libvirt.check_qemu_cmd_line(expected_qemuline)
if cmd_in_guest:
vm_session = vm.wait_for_login()
status, output = vm_session.cmd_status_output(cmd_in_guest)
if status:
vm_session.close()
test.fail("Failed to run '{}' in vm with "
"messages:\n{}".format(cmd_in_guest, output))
vm_session.close()
if cpu_mode == 'maximum':
check_vm_cpu_model(output.strip(), cmd_in_guest, test)
finally:
logging.debug("Recover test environment")
if vm.is_alive():
vm.destroy()
libvirt.clean_up_snapshots(vm_name, domxml=bkxml)
bkxml.sync()
def capability_validate(file=None, **virsh_dargs):
"""
Test for schema capability
"""
cmd_result = virsh.capabilities(to_file=file, **virsh_dargs)
def run(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):
cap_xml = capability_xml.CapabilityXML()
cap_xml.xml = source
# Check that host has a non-empty UUID tag.
xml_uuid = cap_xml.uuid
logging.debug("Host UUID (capabilities_xml): %s", xml_uuid)
if xml_uuid == "":
raise error.TestFail("The host uuid in capabilities_xml is none!")
# Check the host arch.
xml_arch = cap_xml.arch
logging.debug("Host arch (capabilities_xml): %s", xml_arch)
exp_arch = process.run("arch", shell=True).stdout.strip()
if cmp(xml_arch, exp_arch) != 0:
raise error.TestFail("The host arch in capabilities_xml is "
"expected to be %s, but get %s" %
(exp_arch, xml_arch))
# Check the host cpu count.
xml_cpu_count = cap_xml.cpu_count
logging.debug("Host cpus count (capabilities_xml): %s", xml_cpu_count)
cmd = "grep processor /proc/cpuinfo | wc -l"
exp_cpu_count = int(process.run(cmd, shell=True).stdout.strip())
if xml_cpu_count != exp_cpu_count:
raise error.TestFail("Host cpus count is expected to be %s, "
"but get %s" %
(exp_cpu_count, xml_cpu_count))
# Check the arch of guest supported.
guest_capa = cap_xml.get_guest_capabilities()
logging.debug(guest_capa)
# libvirt track wordsize in hardcode struct virArchData
wordsize = {}
wordsize['64'] = ['alpha', 'aarch64', 'ia64', 'mips64', 'mips64el',
'parisc64', 'ppc64', 'ppc64le', 's390x', 'sh4eb',
'sparc64', 'x86_64']
wordsize['32'] = ['armv6l', 'armv7l', 'armv7b', 'cris', 'i686', 'lm32',
'm68k', 'microblaze', 'microblazeel', 'mips',
'mipsel', 'openrisc', 'parisc', 'ppc', 'ppcle',
'ppcemb', 's390', 'sh4', 'sparc', 'unicore32',
'xtensa', 'xtensaeb']
uri_type = process.run("virsh uri", shell=True).stdout.split(':')[0]
domain_type = "domain_" + uri_type
for arch_dict in guest_capa.values():
for arch, val_dict in arch_dict.items():
# Check wordsize
if arch not in wordsize[val_dict['wordsize']]:
raise error.TestFail("'%s' wordsize '%s' in "
"capabilities_xml not expected" %
(arch, val_dict['wordsize']))
# Check the type of hypervisor
if domain_type not in val_dict.keys():
raise error.TestFail("domain type '%s' is not matched"
" under arch '%s' in "
"capabilities_xml" %
(uri_type, arch))
# check power management support.
try:
pm_cmd = os_dep.command('pm-is-supported')
pm_cap_map = {'suspend': 'suspend_mem',
'hibernate': 'suspend_disk',
'suspend-hybrid': 'suspend_hybrid'}
exp_pms = []
for opt in pm_cap_map:
cmd = '%s --%s' % (pm_cmd, opt)
res = process.run(cmd, ignore_status=True, shell=True)
if res.exit_status == 0:
exp_pms.append(pm_cap_map[opt])
pms = cap_xml.power_management_list
if set(exp_pms) != set(pms):
raise error.TestFail("Expected supported PMs are %s, got %s "
"instead." % (exp_pms, pms))
except ValueError:
logging.debug('Power management checking is skipped, since command'
' pm-is-supported is not found.')
connect_uri = libvirt_vm.normalize_connect_uri(params.get("connect_uri",
"default"))
# Prepare libvirtd service
if "libvirtd" in params:
libvirtd = params.get("libvirtd")
if libvirtd == "off":
utils_libvirtd.libvirtd_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 process.CmdError:
status = 1 # bad
output = ''
# Recover libvirtd service start
if libvirtd == "off":
utils_libvirtd.libvirtd_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(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):
cap_xml = capability_xml.CapabilityXML()
cap_xml.xml = source
# Check that host has a non-empty UUID tag.
xml_uuid = cap_xml.uuid
logging.debug("Host UUID (capabilities_xml): %s", xml_uuid)
if xml_uuid == "":
test.fail("The host uuid in capabilities_xml is none!")
# Check the host arch.
xml_arch = cap_xml.arch
logging.debug("Host arch (capabilities_xml): %s", xml_arch)
exp_arch = process.run("arch", shell=True).stdout.strip()
if cmp(xml_arch, exp_arch) != 0:
test.fail("The host arch in capabilities_xml is "
"expected to be %s, but get %s" %
(exp_arch, xml_arch))
# Check the host cpu count.
xml_cpu_count = cap_xml.cpu_count
logging.debug("Host cpus count (capabilities_xml): %s", xml_cpu_count)
search_str = 'processor'
if platform.machine() == 's390x':
search_str = 'cpu number'
cmd = "grep '%s' /proc/cpuinfo | wc -l" % search_str
exp_cpu_count = int(process.run(cmd, shell=True).stdout.strip())
if xml_cpu_count != exp_cpu_count:
test.fail("Host cpus count is expected to be %s, "
"but get %s" %
(exp_cpu_count, xml_cpu_count))
# Check the arch of guest supported.
guest_capa = cap_xml.get_guest_capabilities()
logging.debug(guest_capa)
# libvirt track wordsize in hardcode struct virArchData
wordsize = {}
wordsize['64'] = ['alpha', 'aarch64', 'ia64', 'mips64', 'mips64el',
'parisc64', 'ppc64', 'ppc64le', 's390x', 'sh4eb',
'sparc64', 'x86_64']
wordsize['32'] = ['armv6l', 'armv7l', 'armv7b', 'cris', 'i686', 'lm32',
'm68k', 'microblaze', 'microblazeel', 'mips',
'mipsel', 'openrisc', 'parisc', 'ppc', 'ppcle',
'ppcemb', 's390', 'sh4', 'sparc', 'unicore32',
'xtensa', 'xtensaeb']
uri_type = process.run("virsh uri", shell=True).stdout.split(':')[0]
domain_type = "domain_" + uri_type
for arch_dict in list(itervalues(guest_capa)):
for arch, val_dict in list(iteritems(arch_dict)):
# Check wordsize
if arch not in wordsize[val_dict['wordsize']]:
test.fail("'%s' wordsize '%s' in "
"capabilities_xml not expected" %
(arch, val_dict['wordsize']))
# Check the type of hypervisor
if domain_type not in list(val_dict.keys()):
test.fail("domain type '%s' is not matched"
" under arch '%s' in "
"capabilities_xml" %
(uri_type, arch))
# check power management support.
try:
pm_cmd = path.find_command('pm-is-supported')
pm_cap_map = {'suspend': 'suspend_mem',
'hibernate': 'suspend_disk',
'suspend-hybrid': 'suspend_hybrid'}
exp_pms = []
for opt in pm_cap_map:
cmd = '%s --%s' % (pm_cmd, opt)
res = process.run(cmd, ignore_status=True, shell=True)
if res.exit_status == 0:
exp_pms.append(pm_cap_map[opt])
pms = cap_xml.power_management_list
if set(exp_pms) != set(pms):
test.fail("Expected supported PMs are %s, got %s "
"instead." % (exp_pms, pms))
except path.CmdNotFoundError:
logging.debug('Power management checking is skipped, since command'
' pm-is-supported is not found.')
connect_uri = libvirt_vm.normalize_connect_uri(params.get("connect_uri",
"default"))
# Prepare libvirtd service
if "libvirtd" in params:
libvirtd = params.get("libvirtd")
if libvirtd == "off":
utils_libvirtd.libvirtd_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 process.CmdError:
status = 1 # bad
output = ''
# Recover libvirtd service start
if libvirtd == "off":
utils_libvirtd.libvirtd_start()
# Check status_error
status_error = params.get("status_error")
if status_error == "yes":
if status == 0:
if libvirtd == "off":
test.fail("Command 'virsh capabilities' succeeded "
"with libvirtd service stopped, "
"incorrect")
else:
test.fail("Command 'virsh capabilities %s' "
"succeeded (incorrect command)" % option)
elif status_error == "no":
compare_capabilities_xml(output)
if status != 0:
test.fail("Command 'virsh capabilities %s' failed "
"(correct command)" % option)
def run(test, params, env):
"""
Test misc tests of virtual cpu features
1) check dumpxml after snapshot-create/revert
:param test: test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment.
"""
def do_snapshot(vm_name, expected_str):
"""
Run snapshot related commands: snapshot-create-as, snapshot-list
snapshot-dumpxml, snapshot-revert
:param vm_name: vm name
:param expected_str: expected string in snapshot-dumpxml
:raise: test.fail if virsh command failed
"""
snapshot_name = vm_name + "-snap"
virsh_dargs = {'debug': True}
cmd_result = virsh.snapshot_create_as(vm_name, snapshot_name,
**virsh_dargs)
libvirt.check_exit_status(cmd_result)
try:
snapshots = virsh.snapshot_list(vm_name, **virsh_dargs)
except process.CmdError:
test.fail("Failed to get snapshots list for %s" % vm_name)
if snapshot_name not in snapshots:
test.fail("The snapshot '%s' was not in snapshot-list."
% snapshot_name)
cmd_result = virsh.snapshot_dumpxml(vm_name, snapshot_name,
**virsh_dargs)
libvirt.check_result(cmd_result, expected_match=expected_str)
cmd_result = virsh.snapshot_revert(vm_name, "", "--current",
**virsh_dargs)
libvirt.check_exit_status(cmd_result)
vm_name = params.get('main_vm')
vm = env.get_vm(vm_name)
cpu_mode = params.get('cpu_mode')
cpu_vendor_id = params.get("vendor_id")
expected_str_before_startup = params.get("expected_str_before_startup")
expected_str_after_startup = params.get("expected_str_after_startup")
expected_qemuline = params.get("expected_qemuline")
cmd_in_guest = params.get("cmd_in_guest")
test_operations = params.get("test_operations")
status_error = "yes" == params.get("status_error", "no")
err_msg = params.get("err_msg")
bkxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
try:
if cpu_vendor_id:
output = virsh.capabilities(debug=True)
host_vendor = re.findall(r'<vendor>(\w+)<', output)[0]
if not re.search(host_vendor, cpu_vendor_id, re.IGNORECASE):
test.cancel("Not supported cpu vendor_id {} on this host."
.format(cpu_vendor_id))
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
# Create cpu xml for test
if vmxml.xmltreefile.find('cpu'):
cpu_xml = vmxml.cpu
else:
cpu_xml = vm_xml.VMCPUXML()
if cpu_mode:
cpu_xml.mode = cpu_mode
if cpu_vendor_id:
cpu_xml.vendor_id = cpu_vendor_id
# Update vm's cpu
vmxml.cpu = cpu_xml
vmxml.sync()
if expected_str_before_startup:
libvirt.check_dumpxml(vm, expected_str_before_startup)
if test_operations:
for action in test_operations.split(","):
if action == "do_snapshot":
do_snapshot(vm_name, expected_str_before_startup)
# Check if vm could start successfully
result = virsh.start(vm_name, debug=True)
libvirt.check_exit_status(result)
if expected_str_after_startup:
libvirt.check_dumpxml(vm, expected_str_after_startup)
if expected_qemuline:
libvirt.check_qemu_cmd_line(expected_qemuline)
if cmd_in_guest:
vm_session = vm.wait_for_login()
if vm_session.cmd_status(cmd_in_guest):
vm_session.close()
test.fail("Failed to run '%s' in vm." % cmd_in_guest)
vm_session.close()
finally:
logging.debug("Recover test environment")
if vm.is_alive():
vm.destroy()
libvirt.clean_up_snapshots(vm_name, domxml=bkxml)
bkxml.sync()
def run(test, params, env):
"""
Test misc tests of virtual cpu features
1) check dumpxml after snapshot-create/revert
2) check vendor_id
3) check maximum vcpus with topology settings
:param test: test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment.
"""
def update_cpu_xml():
"""
Update cpu xml for test
"""
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
# Create cpu xml for test
if vmxml.xmltreefile.find('cpu'):
cpu_xml = vmxml.cpu
else:
cpu_xml = vm_xml.VMCPUXML()
if customize_cpu_features:
for idx in range(len(cpu_xml.get_feature_list()) - 1, -1, -1):
cpu_xml.remove_feature(idx)
domcapa_xml = domcapability_xml.DomCapabilityXML()
features = domcapa_xml.get_additional_feature_list(
'host-model', ignore_features=None)
for feature in features:
for feature_name, feature_policy in feature.items():
# For host-passthrough mode, adding "invtsc" requires
# more settings, so it will be ignored.
if feature_name != "invtsc":
cpu_xml.add_feature(feature_name, feature_policy)
if cpu_mode:
cpu_xml.mode = cpu_mode
if cpu_vendor_id:
cpu_xml.vendor_id = cpu_vendor_id
# Update vm's cpu
vmxml.cpu = cpu_xml
vmxml.sync()
if vcpu_max:
if with_topology:
vm_xml.VMXML.set_vm_vcpus(vm_name,
int(vcpu_max),
cores=int(vcpu_max),
sockets=1,
threads=1,
add_topology=with_topology,
topology_correction=with_topology)
else:
vm_xml.VMXML.set_vm_vcpus(vm_name, int(vcpu_max))
def do_snapshot(vm_name, expected_str):
"""
Run snapshot related commands: snapshot-create-as, snapshot-list
snapshot-dumpxml, snapshot-revert
:param vm_name: vm name
:param expected_str: expected string in snapshot-dumpxml
:raise: test.fail if virsh command failed
"""
snapshot_name = vm_name + "-snap"
virsh_dargs = {'debug': True}
cmd_result = virsh.snapshot_create_as(vm_name, snapshot_name,
**virsh_dargs)
libvirt.check_exit_status(cmd_result)
try:
snapshots = virsh.snapshot_list(vm_name, **virsh_dargs)
except process.CmdError:
test.fail("Failed to get snapshots list for %s" % vm_name)
if snapshot_name not in snapshots:
test.fail("The snapshot '%s' was not in snapshot-list." %
snapshot_name)
cmd_result = virsh.snapshot_dumpxml(vm_name, snapshot_name,
**virsh_dargs)
libvirt.check_result(cmd_result, expected_match=expected_str)
cmd_result = virsh.snapshot_revert(vm_name, "", "--current",
**virsh_dargs)
libvirt.check_exit_status(cmd_result)
def check_feature_list(vm, original_dict):
"""
Compare new cpu feature list and original cpu
:param vm: VM object
:original_dict: Cpu feature dict , {"name1":"policy1","name2":"policy2"}
"""
new_cpu_xml = vm_xml.VMXML.new_from_dumpxml(vm.name).cpu
new_feature_dict = new_cpu_xml.get_dict_type_feature()
if new_feature_dict != original_dict:
test.fail('CPU feature lists are different, original is :%s,'
' new is %s:' % (original_dict, new_feature_dict))
libvirt_version.is_libvirt_feature_supported(params)
vm_name = params.get('main_vm')
vm = env.get_vm(vm_name)
cpu_mode = params.get('cpu_mode')
vcpu_max = params.get('vcpu_max')
expected_str_before_startup = params.get("expected_str_before_startup")
expected_str_after_startup = params.get("expected_str_after_startup")
test_operations = params.get("test_operations")
check_vendor_id = "yes" == params.get("check_vendor_id", "no")
virsh_edit_cmd = params.get("virsh_edit_cmd")
with_topology = "yes" == params.get("with_topology", "no")
status_error = "yes" == params.get("status_error", "no")
err_msg = params.get("err_msg")
cpu_vendor_id = None
expected_qemuline = None
cmd_in_guest = params.get("cmd_in_guest")
customize_cpu_features = "yes" == params.get("customize_cpu_features",
"no")
bkxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
managed_save_file = "/var/lib/libvirt/qemu/save/%s.save" % vm_name
try:
if check_vendor_id:
output = virsh.capabilities(debug=True)
host_vendor = re.findall(r'<vendor>(\w+)<', output)[0]
cpu_vendor_id = 'GenuineIntel'
if host_vendor != "Intel":
cpu_vendor_id = 'AuthenticAMD'
logging.debug("Set cpu vendor_id to %s on this host.",
cpu_vendor_id)
expected_qemuline = "vendor=" + cpu_vendor_id
cmd_in_guest = ("cat /proc/cpuinfo | grep vendor_id | grep {}".
format(cpu_vendor_id))
# Update xml for test
update_cpu_xml()
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
logging.debug("Pre-test xml is %s", vmxml.xmltreefile)
cpu_xml = vmxml.cpu
feature_dict = cpu_xml.get_dict_type_feature()
if expected_str_before_startup:
libvirt.check_dumpxml(vm, expected_str_before_startup)
if test_operations:
for action in test_operations.split(","):
if action == "do_snapshot":
do_snapshot(vm_name, expected_str_before_startup)
if virsh_edit_cmd:
status = libvirt.exec_virsh_edit(vm_name,
virsh_edit_cmd.split(","))
if status == status_error:
test.fail("Virsh edit got unexpected result.")
# Check if vm could start successfully
if not status_error:
result = virsh.start(vm_name, debug=True)
libvirt.check_exit_status(result)
if expected_str_after_startup:
libvirt.check_dumpxml(vm, expected_str_after_startup)
if expected_qemuline:
libvirt.check_qemu_cmd_line(expected_qemuline)
if cmd_in_guest:
vm_session = vm.wait_for_login()
status, output = vm_session.cmd_status_output(cmd_in_guest)
if status:
vm_session.close()
test.fail("Failed to run '{}' in vm with "
"messages:\n{}".format(cmd_in_guest, output))
vm_session.close()
if cpu_mode == 'maximum':
check_vm_cpu_model(output.strip(), cmd_in_guest, test)
# Add case: Check cpu xml after domain Managedsaved and restored
if test_operations:
for item in test_operations.split(','):
if item == "managedsave_restore":
# (1)Domain Manage saved
virsh.managedsave(vm_name,
ignore_status=False,
debug=True)
check_feature_list(vm, feature_dict)
# (2)Domain Restore
virsh.restore(managed_save_file,
ignore_status=False,
debug=True)
# (5)Check mode and feature list here
libvirt.check_dumpxml(vm, cpu_mode)
check_feature_list(vm, feature_dict)
finally:
logging.debug("Recover test environment")
if os.path.exists(managed_save_file):
virsh.managedsave_remove(vm_name, debug=True)
if vm.is_alive():
vm.destroy()
libvirt.clean_up_snapshots(vm_name, domxml=bkxml)
bkxml.sync()
def run(test, params, env):
"""
Test command: virsh hypervisor-cpu-compare
Compare CPU provided by hypervisor on the host with a CPU described by an XML file
1.Get all parameters from configuration.
2.Prepare temp file saves of CPU information.
3.Perform virsh hypervisor-cpu-compare operation.
4.Confirm the result.
"""
# Get all parameters.
file_type = params.get("compare_file_type", "domxml")
extract_mode = ("yes" == params.get("extract_mode", "no"))
action_mode = params.get("action_mode")
cpu_mode = params.get("cpu_mode", "custom")
illegal_cpu_test = ("yes" == params.get("illegal_cpu_test", "no"))
status_error = ("yes" == params.get("status_error", "no"))
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
option_str = params.get("hypv_cpu_compare_option")
invalid_option = params.get("invalid_option")
invalid_value = params.get("invalid_value")
if invalid_option:
option_str = option_str.replace(invalid_option, "")
if not libvirt_version.version_compare(4, 4, 0):
test.cancel("hypervisor-cpu-compare does not support"
" in this libvirt version")
if not vm.is_alive():
vm.start()
dom_xml = vm_xml.VMXML.new_from_dumpxml(vm_name)
backup_xml = dom_xml.copy()
compare_file = os.path.join(data_dir.get_tmp_dir(), "cpu.xml")
domcapa_file = os.path.join(data_dir.get_tmp_dir(), "tmp_file")
def get_domain_output(cpu_mode):
"""
Prepare domain xml according cpu mode
:param cpu_mode: The name of cpu mode
:return: The domain xml data
"""
try:
cpuxml = dom_xml.cpu
if not action_mode and cpuxml.mode == cpu_mode:
return dom_xml.xmltreefile.get_element_string("/")
else:
del dom_xml["cpu"]
except LibvirtXMLNotFoundError:
pass # CPU already does not exist
# Create new CPUXML
cpuxml = vm_xml.VMCPUXML()
cpuxml.mode = cpu_mode
if cpu_mode == "custom":
# Customize cpu according domcapabilities xml
domcapa_output = get_domcapa_output(test)
with open(domcapa_file, "w+") as tmp_f:
tmp_f.write(domcapa_output)
ret = virsh.cpu_baseline(domcapa_file)
if ret.exit_status:
test.fail("Fail to run virsh cpu-baseline: %s"
% ret.stderr.strip())
cpuxml.xml = ret.stdout.strip()
if cpu_mode == "host-passthrough":
cpuxml.check = "none"
dom_xml.cpu = cpuxml
dom_xml.sync()
vm.start()
# VM start will change domxml content
v_xml = vm_xml.VMXML.new_from_dumpxml(vm_name)
return v_xml.xmltreefile.get_element_string("/")
def get_options(option_str):
"""
Prepare virsh cmd options according input string
:param option_str: Input option string contains option names
:return: Virsh cmd options
"""
options = ""
emulator = dom_xml.devices.by_device_tag('emulator')[0]
osxml = dom_xml.os
if option_str.count("--virttype"):
options += "--virttype %s " % dom_xml.hypervisor_type
if option_str.count("--emulator"):
options += "--emulator %s " % emulator.path
if option_str.count("--arch"):
options += "--arch %s " % osxml.arch
if option_str.count("--machine"):
options += "--machine %s " % osxml.machine
if option_str.count("--error"):
options += "--error "
return options
try:
# Prepare options
options = get_options(option_str)
if invalid_option:
options += "%s %s " % (invalid_option, invalid_value)
# Prepare cpu compare file.
cpu_data = ""
if file_type == "domxml":
cpu_data = get_domain_output(cpu_mode)
elif file_type == "domcapa_xml":
cpu_data = get_domcapa_output(test)
elif file_type == "capa_xml":
cpu_data = virsh.capabilities()
else:
test.error("The compare file type %s is unsupported" % file_type)
# Extract cpu definition
if extract_mode:
cpu_data = get_cpu_definition(file_type, vm_name, test)
if illegal_cpu_test and file_type == "domxml":
# Make invalid cpu data by adding <host> outside of <cpu>
cpu_data = "<host>{}</host>".format(cpu_data)
with open(compare_file, "w+") as compare_file_f:
compare_file_f.write(cpu_data)
compare_file_f.flush()
compare_file_f.seek(0)
logging.debug("CPU description XML:\n%s", compare_file_f.read())
# Perform virsh cpu-compare operation.
result = virsh.hypervisor_cpu_compare(xml_file=compare_file, options=options, ignore_status=True, debug=True)
msg_pattern = params.get("msg_pattern")
# Check result
if status_error and not result.exit_status:
test.fail("Expect should fail but got:\n%s" % result.stdout)
elif not status_error and result.exit_status:
test.fail("Expect success but got:\n%s" % result.stderr)
if msg_pattern:
logging.debug("Expect key word in comand output: %s", msg_pattern)
output = result.stdout.strip()
if not output:
output = result.stderr.strip()
if not output.count(msg_pattern):
test.fail("Not find expect key word in command output")
finally:
backup_xml.sync()
if os.path.exists(domcapa_file):
os.remove(domcapa_file)
if os.path.exists(compare_file):
os.remove(compare_file)
def run(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):
cap_xml = capability_xml.CapabilityXML()
cap_xml.xml = source
# Check that host has a non-empty UUID tag.
xml_uuid = cap_xml.uuid
logging.debug("Host UUID (capabilities_xml): %s" % xml_uuid)
if xml_uuid == "":
raise error.TestFail("The host uuid in capabilities_xml is none!")
# Check the host arch.
xml_arch = cap_xml.arch
logging.debug("Host arch (capabilities_xml): %s", xml_arch)
exp_arch = utils.run("arch", ignore_status=True).stdout.strip()
if cmp(xml_arch, exp_arch) != 0:
raise error.TestFail("The host arch in capabilities_xml is expected"
" to be %s, but get %s" % (exp_arch, xml_arch))
# Check the host cpu count.
xml_cpu_count = cap_xml.cpu_count
logging.debug("Host cpus count (capabilities_xml): %s", xml_cpu_count)
cmd = "grep processor /proc/cpuinfo | wc -l"
exp_cpu_count = int(utils.run(cmd, ignore_status=True).stdout.strip())
if xml_cpu_count != exp_cpu_count:
raise error.TestFail("Host cpus count is expected to be %s, but get "
"%s" % (exp_cpu_count, xml_cpu_count))
# Check the arch of guest supported.
xmltreefile = cap_xml.__dict_get__('xml')
xml_os_arch_machine_map = cap_xml.os_arch_machine_map
logging.debug(xml_os_arch_machine_map['hvm'])
try:
img = utils_misc.find_command("qemu-kvm")
except ValueError:
raise error.TestNAError("Cannot find qemu-kvm")
cmd = img + " --cpu ? | grep qemu"
cmd_result = utils.run(cmd, ignore_status=True)
for guest in xmltreefile.findall('guest'):
guest_wordsize = guest.find('arch').find('wordsize').text
logging.debug("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 hypervisor.
first_guest = xmltreefile.findall('guest')[0]
first_domain = first_guest.find('arch').findall('domain')[0]
guest_domain_type = first_domain.get('type')
logging.debug("Hypervisor (capabilities_xml):%s", guest_domain_type)
cmd_result = utils.run("virsh uri", ignore_status=True)
if not re.search(guest_domain_type, cmd_result.stdout.strip()):
raise error.TestFail("The capabilities_xml gives an different "
"hypervisor")
# check power management support.
try:
pm_cmd = os_dep.command('pm-is-supported')
pm_cap_map = {'suspend': 'suspend_mem',
'hibernate': 'suspend_disk',
'suspend-hybrid': 'suspend_hybrid',
}
exp_pms = []
for opt in pm_cap_map:
cmd = '%s --%s' % (pm_cmd, opt)
res = utils.run(cmd, ignore_status=True)
if res.exit_status == 0:
exp_pms.append(pm_cap_map[opt])
pms = cap_xml.power_management_list
if set(exp_pms) != set(pms):
raise error.TestFail("Expected supported PMs are %s, got %s "
"instead." % (exp_pms, pms))
except ValueError:
logging.debug('Power management checking is skipped, since command '
'pm-is-supported is not found.')
connect_uri = libvirt_vm.normalize_connect_uri(params.get("connect_uri",
"default"))
# Prepare libvirtd service
if "libvirtd" in params:
libvirtd = params.get("libvirtd")
if libvirtd == "off":
utils_libvirtd.libvirtd_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":
utils_libvirtd.libvirtd_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 __new__(cls):
if cls._XML is None:
cls._XML = virsh.capabilities()
# older python super doesn't work on class objects
return LibvirtXMLBase.__new__(cls)
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":
utils_libvirtd.libvirtd_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":
utils_libvirtd.libvirtd_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)
