def vm_recover_check(guest_name, option, libvirtd, check_shutdown=False):
"""
Check if the vm can be recovered correctly.
:param guest_name : Checked vm's name.
:param option : managedsave command option.
"""
# This time vm not be shut down
if vm.is_alive():
raise error.TestFail("Guest should be inactive")
# Check vm managed save state.
ret = virsh.dom_list("--managed-save --inactive")
vm_state1 = re.findall(r".*%s.*" % guest_name,
ret.stdout.strip())[0].split()[2]
ret = virsh.dom_list("--managed-save --all")
vm_state2 = re.findall(r".*%s.*" % guest_name,
ret.stdout.strip())[0].split()[2]
if vm_state1 != "saved" or vm_state2 != "saved":
raise error.TestFail("Guest state should be saved")
virsh.start(guest_name)
# This time vm should be in the list
if vm.is_dead():
raise error.TestFail("Guest should be active")
# Restart libvirtd and check vm status again.
libvirtd.restart()
if vm.is_dead():
raise error.TestFail("Guest should be active after"
" restarting libvirtd")
# Check managed save file:
if os.path.exists(managed_save_file):
raise error.TestFail("Managed save image exist "
"after starting the domain")
if option:
if option.count("running"):
if vm.is_dead() or vm.is_paused():
raise error.TestFail("Guest state should be"
" running after started"
" because of '--running' option")
elif option.count("paused"):
if not vm.is_paused():
raise error.TestFail("Guest state should be"
" paused after started"
" because of '--paused' option")
else:
if params.get("paused_after_start_vm") == "yes":
if not vm.is_paused():
raise error.TestFail("Guest state should be"
" paused after started"
" because of initia guest state")
if check_shutdown:
# Resume the domain.
if vm.is_paused():
vm.resume()
vm.wait_for_login()
# Shutdown and start the domain, it should be in runing state and can be login.
vm.shutdown()
vm.wait_for_shutdown()
vm.start()
vm.wait_for_login()
def persistent_test(vm, vm_xml):
"""
Test for vtpm with persistent_state.
"""
vm.undefine("--nvram")
virsh.create(vm_xml.xml, **virsh_dargs)
domuuid = vm.get_uuid()
state_file = "/var/lib/libvirt/swtpm/%s/tpm2/tpm2-00.permall" % domuuid
process.run("ls -Z %s" % state_file)
session = vm.wait_for_login()
test_guest_tpm("2.0", session, False)
session.close()
virsh.dom_list("--transient", debug=True)
vm.destroy()
if not os.path.exists(state_file):
test.fail("Swtpm state file: %s does not exist after destroy vm'" % state_file)
process.run("ls -Z %s" % state_file)
def vm_recover_check(guest_name):
"""
Check if the vm can be recovered correctly.
:param guest_name : Checked vm's name.
"""
ret = virsh.dom_list()
# This time vm should not be in the list
if re.search(guest_name, ret.stdout):
raise error.TestFail("virsh list output invalid")
virsh.start(guest_name)
if params.get("paused_after_start_vm") == "yes":
virsh.resume(guest_name, ignore_status=True)
# This time vm should be in the list
ret = virsh.dom_list()
if not re.search(guest_name, ret.stdout):
raise error.TestFail("virsh list output invalid")
def vm_recover_check(guest_name):
"""
Check if the vm can be recovered correctly.
@param: guest_name : Checked vm's name.
"""
ret = virsh.dom_list()
#This time vm should not be in the list
if re.search(guest_name, ret.stdout):
raise error.TestFail("virsh list output invalid")
virsh.start(guest_name)
if params.get("paused_after_start_vm") == "yes":
virsh.resume(guest_name)
#This time vm should be in the list
ret = virsh.dom_list()
if not re.search(guest_name, ret.stdout):
raise error.TestFail("virsh list output invalid")
def check_vm_exist(test, vm_name, state):
dom_output = virsh.dom_list("--all", debug=True).stdout.strip()
search_res = re.search(r"-.*%s.*%s" % (vm_name, state), dom_output)
if not search_res:
test.fail("VM '{}' with the state '{}' is not "
"found".format(vm_name, state))
else:
logging.debug("VM '{}' with the state '{}' is "
"found".format(vm_name, state))
def run(test, params, env):
"""
Test command: virsh qemu-attach.
"""
pid = params.get("pid", None)
options = params.get("options", "")
status_error = "yes" == params.get("status_error", "no")
libvirtd_inst = utils_libvirtd.Libvirtd()
new_vm = None
try:
# Prepare qemu-kvm process
if pid is None:
params_b = params.copy()
new_vm = qemu_vm.VM('attach_dom', params_b, test.bindir,
env['address_cache'])
new_vm.create()
pid = new_vm.get_pid()
# Run virsh command
logging.debug("The qemu-kvm pid for attach is %s" % pid)
cmd_result = virsh.qemu_attach(pid,
options,
ignore_status=True,
debug=True)
status = cmd_result.exit_status
# Check result
if not libvirtd_inst.is_running():
test.fail("Libvirtd is not running after run command.")
if status_error:
if not status:
test.fail("Expect fail, run succeed.")
else:
logging.debug("Command failed as expected.")
else:
if status:
err_msg = "error: Failed to attach to pid"
if err_msg in cmd_result.stderr:
test.fail("Command failed: %s" % cmd_result.stderr)
list_output = virsh.dom_list().stdout.strip()
if re.search('attach_dom', list_output):
test.fail("Command failed but domain found "
"in virsh list.")
err_msg = "No worry, the command is explicitly unsupported, "
err_msg += "it's a development crutch and not highly reliable"
err_msg += " mechanism."
test.cancel(err_msg)
finally:
# Cleanup
if new_vm:
if new_vm.is_alive():
new_vm.destroy(gracefully=False)
if not libvirtd_inst.is_running():
libvirtd_inst.restart()
def run(test, params, env):
"""
Test command: virsh qemu-attach.
"""
pid = params.get("pid", None)
options = params.get("options", "")
status_error = "yes" == params.get("status_error", "no")
libvirtd_inst = utils_libvirtd.Libvirtd()
new_vm = None
try:
# Prepare qemu-kvm process
if pid is None:
params_b = params.copy()
new_vm = qemu_vm.VM('attach_dom', params_b, test.bindir,
env['address_cache'])
new_vm.create()
pid = new_vm.get_pid()
# Run virsh command
logging.debug("The qemu-kvm pid for attach is %s" % pid)
cmd_result = virsh.qemu_attach(pid, options,
ignore_status=True,
debug=True)
status = cmd_result.exit_status
# Check result
if not libvirtd_inst.is_running():
test.fail("Libvirtd is not running after run command.")
if status_error:
if not status:
test.fail("Expect fail, run succeed.")
else:
logging.debug("Command failed as expected.")
else:
if status:
err_msg = "error: Failed to attach to pid"
if err_msg in cmd_result.stderr:
test.fail("Command failed: %s" % cmd_result.stderr)
list_output = virsh.dom_list().stdout.strip()
if re.search('attach_dom', list_output):
test.fail("Command failed but domain found "
"in virsh list.")
err_msg = "No worry, the command is explicitly unsupported, "
err_msg += "it's a development crutch and not highly reliable"
err_msg += " mechanism."
test.cancel(err_msg)
finally:
# Cleanup
if new_vm:
if new_vm.is_alive():
new_vm.destroy(gracefully=False)
if not libvirtd_inst.is_running():
libvirtd_inst.restart()
def check_unix_sock(group, perms, path):
"""
Check the validity of one libvirt socket file, including existance,
group name, access permission and usability of virsh command.
:param group: Expected group of the file.
:param perms: Expected permission string of the file.
:param path: Absolute path of the target file.
:return : True if success or False if any test fails.
"""
mode = os.stat(path).st_mode
gid = os.stat(path).st_gid
# Check file exists as a socket file.
if not stat.S_ISSOCK(mode):
logging.error("File %s is not a socket file." % path)
return False
# Check file group ID.
try:
expected_gid = grp.getgrnam(group).gr_gid
logging.debug('Group ID of %s is %s' % (group, expected_gid))
if gid != expected_gid:
logging.error('File group gid expected to be '
' %s, but %s found' % (expected_gid, gid))
return False
except KeyError:
logging.error('Can not find group "%s"' % group)
return False
# Check file permissions.
mode_str = mode_bits_to_str(stat.S_IMODE(mode))
logging.debug('Permission of file %s is %s' % (path, mode_str))
# Zero padding perms to 4 digits.
expected_perms = perms.zfill(4)
if mode_str != expected_perms:
logging.error('Expected file permission is %s, but %s '
'found' % (expected_perms, mode_str))
return False
# Check virsh connection.
uri = 'qemu+unix:///system?socket=%s' % path
result = virsh.dom_list('--all', uri=uri)
logging.debug('Result of virsh test run is:\n %s' % result)
if result.exit_status:
logging.error('Error encountered when running virsh list on '
'socket file %s' % path)
return False
# All success
return True
def run(test, params, env):
"""
Test command: virsh reboot.
Run a reboot command in the target domain.
1.Prepare test environment.
2.When the libvirtd == "off", stop the libvirtd service.
3.Perform virsh reboot operation.
4.Recover test environment.(libvirts service)
5.Confirm the test result.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
# run test case
libvirtd = params.get("libvirtd", "on")
vm_ref = params.get("reboot_vm_ref")
status_error = ("yes" == params.get("status_error"))
extra = params.get("reboot_extra")
remote_ip = params.get("remote_ip", "REMOTE.EXAMPLE.COM")
local_ip = params.get("local_ip", "LOCAL.EXAMPLE.COM")
remote_pwd = params.get("remote_pwd", "password")
agent = ("yes" == params.get("reboot_agent", "no"))
mode = params.get("reboot_mode", "")
pre_domian_status = params.get("reboot_pre_domian_status", "running")
xml_backup = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
try:
# Add or remove qemu-agent from guest before test
if agent:
vm_xml.VMXML.set_agent_channel(vm_name)
else:
vm_xml.VMXML.remove_agent_channel(vm_name)
virsh.start(vm_name)
guest_session = vm.wait_for_login()
if agent:
if guest_session.cmd_status("which qemu-ga"):
raise error.TestNAError("Cannot execute this test for domain"
" doesn't have qemu-ga command!")
# check if the qemu-guest-agent is active or not firstly
stat_ps = guest_session.cmd_status("ps aux |grep [q]emu-ga")
if stat_ps != 0:
s, o = guest_session.cmd_status_output("qemu-ga -d")
if s != 0:
raise error.TestError("'qemu-ga -d' failed.\noutput:%s" % o)
stat_ps = guest_session.cmd_status("ps aux |grep [q]emu-ga")
guest_session.close()
if stat_ps:
raise error.TestError("Fail to start qemu-guest-agent!")
if pre_domian_status == "shutoff":
virsh.destroy(vm_name)
if libvirtd == "off":
utils_libvirtd.libvirtd_stop()
domid = vm.get_id()
domuuid = vm.get_uuid()
if vm_ref == "id":
vm_ref = domid
elif vm_ref == "name":
vm_ref = vm_name
elif vm_ref == "uuid":
vm_ref = domuuid
elif vm_ref == "hex_id":
vm_ref = hex(int(domid))
elif vm_ref.find("invalid") != -1:
vm_ref = params.get(vm_ref)
elif vm_ref == "remote_name":
if remote_ip.count("EXAMPLE.COM") or local_ip.count("EXAMPLE.COM"):
raise error.TestNAError("remote_ip and/or local_ip parameters"
" not changed from default values")
complete_uri = libvirt_vm.complete_uri(local_ip)
try:
session = remote.remote_login("ssh", remote_ip, "22", "root",
remote_pwd, "#")
session.cmd_output('LANG=C')
command = "virsh -c %s reboot %s %s" % (complete_uri, vm_name,
mode)
status, output = session.cmd_status_output(command,
internal_timeout=5)
session.close()
# FIXME: Catch specific exception
except Exception, detail:
logging.error("Exception: %s", str(detail))
status = -1
if vm_ref != "remote_name":
vm_ref = "%s %s" % (vm_ref, extra)
cmdresult = virsh.reboot(vm_ref, mode,
ignore_status=True, debug=True)
status = cmdresult.exit_status
if status:
logging.debug("Error status, cmd error: %s", cmdresult.stderr)
if not virsh.has_command_help_match('reboot', '\s+--mode\s+'):
# old libvirt doesn't support reboot
status = -2
output = virsh.dom_list(ignore_status=True).stdout.strip()
# recover libvirtd service start
if libvirtd == "off":
utils_libvirtd.libvirtd_start()
# check status_error
if status_error:
if not status:
raise error.TestFail("Run successfully with wrong command!")
else:
if status or (not re.search(vm_name, output)):
if status == -2:
raise error.TestNAError(
"Reboot command doesn't work on older libvirt versions")
raise error.TestFail("Run failed with right command")
def run(test, params, env):
"""
Test command: virsh reboot.
Run a reboot command in the target domain.
1.Prepare test environment.
2.When the libvirtd == "off", stop the libvirtd service.
3.Perform virsh reboot operation.
4.Recover test environment.(libvirts service)
5.Confirm the test result.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
# run test case
libvirtd = params.get("libvirtd", "on")
vm_ref = params.get("reboot_vm_ref")
status_error = ("yes" == params.get("status_error"))
extra = params.get("reboot_extra", "")
remote_ip = params.get("remote_ip", "REMOTE.EXAMPLE.COM")
local_ip = params.get("local_ip", "LOCAL.EXAMPLE.COM")
remote_pwd = params.get("remote_pwd", "password")
agent = ("yes" == params.get("reboot_agent", "no"))
mode = params.get("reboot_mode", "")
pre_domian_status = params.get("reboot_pre_domian_status", "running")
reboot_readonly = "yes" == params.get("reboot_readonly", "no")
xml_backup = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
try:
# Add or remove qemu-agent from guest before test
try:
vm.prepare_guest_agent(channel=agent, start=agent)
except virt_vm.VMError as e:
logging.debug(e)
# qemu-guest-agent is not available on REHL5
test.cancel("qemu-guest-agent package is not available")
if pre_domian_status == "shutoff":
virsh.destroy(vm_name)
if libvirtd == "off":
utils_libvirtd.libvirtd_stop()
domid = vm.get_id()
domuuid = vm.get_uuid()
if vm_ref == "id":
vm_ref = domid
elif vm_ref == "name":
vm_ref = vm_name
elif vm_ref == "uuid":
vm_ref = domuuid
elif vm_ref == "hex_id":
vm_ref = hex(int(domid))
elif vm_ref.find("invalid") != -1:
vm_ref = params.get(vm_ref)
elif vm_ref == "remote_name":
if remote_ip.count("EXAMPLE.COM") or local_ip.count("EXAMPLE.COM"):
test.cancel("remote_ip and/or local_ip parameters"
" not changed from default values")
complete_uri = libvirt_vm.complete_uri(local_ip)
try:
session = remote.remote_login("ssh", remote_ip, "22", "root",
remote_pwd, "#")
session.cmd_output('LANG=C')
command = "virsh -c %s reboot %s %s" % (complete_uri, vm_name,
mode)
status, output = session.cmd_status_output(command,
internal_timeout=5)
session.close()
if not status:
# the operation before the end of reboot
# may result in data corruption
vm.wait_for_login().close()
except (remote.LoginError, process.CmdError,
aexpect.ShellError) as e:
logging.error("Exception: %s", str(e))
status = -1
if vm_ref != "remote_name":
vm_ref = "%s" % vm_ref
if extra:
vm_ref += " %s" % extra
cmdresult = virsh.reboot(vm_ref,
mode,
ignore_status=True,
debug=True)
status = cmdresult.exit_status
if status:
logging.debug("Error status, cmd error: %s", cmdresult.stderr)
if not virsh.has_command_help_match('reboot', '\s+--mode\s+'):
# old libvirt doesn't support reboot
status = -2
else:
vm.wait_for_login().close()
output = virsh.dom_list(ignore_status=True).stdout.strip()
# Test the readonly mode
if reboot_readonly:
result = virsh.reboot(vm_ref,
ignore_status=True,
debug=True,
readonly=True)
libvirt.check_exit_status(result, expect_error=True)
# This is for status_error check
status = result.exit_status
# recover libvirtd service start
if libvirtd == "off":
utils_libvirtd.libvirtd_start()
# check status_error
if status_error:
if not status:
test.fail("Run successfully with wrong command!")
else:
if status or (not re.search(vm_name, output)):
if status == -2:
test.cancel("Reboot command doesn't work on older libvirt "
"versions")
test.fail("Run failed with right command")
finally:
xml_backup.sync()
def run(test, params, env):
"""
Test command: virsh restore.
Restore a domain from a saved state in a file
1.Prepare test environment.
2.When the libvirtd == "off", stop the libvirtd service.
3.Run virsh restore command with assigned option.
4.Recover test environment.
5.Confirm the test result.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
session = vm.wait_for_login()
os_type = params.get("os_type")
status_error = ("yes" == params.get("status_error"))
libvirtd = params.get("libvirtd", "on")
extra_param = params.get("restore_extra_param")
pre_status = params.get("restore_pre_status")
vm_ref = params.get("restore_vm_ref")
uri = params.get("virsh_uri")
unprivileged_user = params.get('unprivileged_user')
if unprivileged_user:
if unprivileged_user.count('EXAMPLE'):
unprivileged_user = '******'
if not libvirt_version.version_compare(1, 1, 1):
if params.get('setup_libvirt_polkit') == 'yes':
raise error.TestNAError("API acl test not supported in current"
" libvirt version.")
# run test
if vm_ref == "" or vm_ref == "xyz":
status = virsh.restore(vm_ref, extra_param, debug=True,
unprivileged_user=unprivileged_user,
uri=uri,
ignore_status=True).exit_status
else:
if os_type == "linux":
cmd = "cat /proc/cpuinfo"
try:
status, output = session.cmd_status_output(cmd, timeout=10)
finally:
session.close()
if not re.search("processor", output):
raise error.TestFail("Unable to read /proc/cpuinfo")
tmp_file = os.path.join(test.tmpdir, "save.file")
virsh.save(vm_name, tmp_file)
if vm_ref == "saved_file":
vm_ref = tmp_file
elif vm_ref == "empty_new_file":
tmp_file = os.path.join(test.tmpdir, "new.file")
open(tmp_file, 'w').close()
vm_ref = tmp_file
if vm.is_alive():
vm.destroy()
if pre_status == "start":
virsh.start(vm_name)
if libvirtd == "off":
utils_libvirtd.libvirtd_stop()
status = virsh.restore(vm_ref, extra_param, debug=True,
unprivileged_user=unprivileged_user,
uri=uri,
ignore_status=True).exit_status
if not status_error:
list_output = virsh.dom_list().stdout.strip()
session.close()
# recover libvirtd service start
if libvirtd == "off":
utils_libvirtd.libvirtd_start()
try:
if status_error:
if not status:
raise error.TestFail("Run successfully with wrong command!")
else:
if status:
raise error.TestFail("Run failed with right command")
if not re.search(vm_name, list_output):
raise error.TestFail("Run failed with right command")
if extra_param.count("paused"):
if not vm.is_paused():
raise error.TestFail("Guest state should be"
" paused after restore"
" due to the option --paused")
if extra_param.count("running"):
if vm.is_dead() or vm.is_paused():
raise error.TestFail("Guest state should be"
" running after restore"
" due to the option --running")
finally:
if vm.is_paused():
virsh.resume(vm_name)
def run(test, params, env):
"""
Test start domain with nwfilter rules.
1) Prepare parameters.
2) Prepare nwfilter rule and update domain interface to apply.
3) Start domain and check rule.
4) Clean env
"""
# Prepare parameters
filter_name = params.get("filter_name", "testcase")
exist_filter = params.get("exist_filter", "no-mac-spoofing")
status_error = "yes" == params.get("status_error", "no")
mount_noexec_tmp = "yes" == params.get("mount_noexec_tmp", "no")
kill_libvirtd = "yes" == params.get("kill_libvirtd", "no")
bug_url = params.get("bug_url", "")
ipset_command = params.get("ipset_command")
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
username = params.get("username")
password = params.get("password")
need_vm2 = "yes" == params.get("need_vm2", "no")
add_vm_name = params.get("add_vm_name", "vm2")
vms = [vm]
dst_outside = params.get("dst_outside", "www.google.com")
ping_timeout = int(params.get("ping_timeout", "10"))
# Prepare vm filterref parameters dict list
filter_param_list = []
params_key = []
for i in params.keys():
if 'parameter_name_' in i:
params_key.append(i)
params_key.sort()
for i in range(len(params_key)):
params_dict = {}
params_dict['name'] = params[params_key[i]]
params_dict['value'] = params['parameter_value_%s' % i]
if params_dict['value'] == "MAC_of_virbr0":
virbr0_info = process.run("ip a | grep virbr0: -A1",
shell=True).stdout_text.strip()
virbr0_mac = re.search(
r'link/ether\s+(\w{2}:\w{2}:\w{2}:\w{2}:\w{2}:\w{2})',
virbr0_info, re.M | re.I).group(1)
params_dict['value'] = virbr0_mac
logging.debug("params_dict['value'] is %s " % params_dict['value'])
filter_param_list.append(params_dict)
filterref_dict = {}
filterref_dict['name'] = filter_name
filterref_dict['parameters'] = filter_param_list
params['filter_uuid'] = process.run("uuidgen",
ignore_status=True,
shell=True).stdout_text.strip()
# get all the check commands and corresponding expected results form config file and make a dictionary
cmd_list_ = params.get('check_cmd', '')
if cmd_list_:
cmd_list = cmd_list_.split(',')
expect_res = params.get('expect_match', '').split(',')
logging.debug("cmd_list is %s" % cmd_list)
logging.debug("expect_res is %s" % expect_res)
cmd_result_dict = dict(zip(cmd_list, expect_res))
logging.debug("the check dict is %s" % cmd_result_dict)
# backup vm xml
vmxml_backup = libvirt_xml.VMXML.new_from_inactive_dumpxml(vm_name)
libvirtd = utils_libvirtd.Libvirtd("virtqemud")
device_name = None
def check_nwfilter_rules(check_cmd, expect_match):
""""check the nwfilter corresponding rule is added by iptables commands"""
ret = utils_misc.wait_for(lambda: not process.system(
check_cmd, ignore_status=True, shell=True),
timeout=30)
if not ret:
test.fail("Rum command '%s' failed" % check_cmd)
# This change anchors nwfilter_vm_start.possitive_test.new_filter.variable_notation case
# The matched destination could be ip address or hostname
if "iptables -L" in check_cmd and expect_match and 'ACCEPT' in expect_match:
# ip address that need to be replaced
replace_param = params.get("parameter_value_2")
# Get hostname by ip address.
hostname_info = None
try:
hostname_info = socket.gethostbyaddr(replace_param)
except socket.error as e:
logging.info(
"Failed to get hostname from ip address with error: %s",
str(e))
if hostname_info:
# String is used to replace ip address
replace_with = "%s|%s" % (replace_param, hostname_info[0])
expect_match = r"%s" % expect_match.replace(
replace_param, replace_with)
logging.debug("final iptables match string:%s", expect_match)
out = astring.to_text(
process.system_output(check_cmd, ignore_status=False, shell=True))
if expect_match and not re.search(expect_match, out):
test.fail("'%s' not found in output: %s" % (expect_match, out))
def clean_up_dirty_nwfilter_binding():
cmd_result = virsh.nwfilter_binding_list(debug=True)
binding_list = cmd_result.stdout_text.strip().splitlines()
binding_list = binding_list[2:]
result = []
# If binding list is not empty.
if binding_list:
for line in binding_list:
# Split on whitespace, assume 1 column
linesplit = line.split(None, 1)
result.append(linesplit[0])
logging.info("nwfilter binding list is: %s", result)
for binding_uuid in result:
try:
virsh.nwfilter_binding_delete(binding_uuid)
except Exception as e:
logging.error(
"Exception thrown while undefining nwfilter-binding: %s",
str(e))
raise
try:
# Clean up dirty nwfilter binding if there are.
clean_up_dirty_nwfilter_binding()
rule = params.get("rule")
if rule:
# Add pre-check whether nwfilter exists or not since
# utlv.create_nwfilter_xml will fail if there is no any nwfilter exists
nwfilter_list = libvirt_nwfilter.get_nwfilter_list()
if not nwfilter_list:
test.error("There is no any nwfilter existed on the host")
# Create new filter xml
filterxml = utlv.create_nwfilter_xml(params)
# Define filter xml
virsh.nwfilter_define(filterxml.xml, debug=True)
# Update first vm interface with filter
vmxml = libvirt_xml.VMXML.new_from_inactive_dumpxml(vm_name)
iface_xml = vmxml.get_devices('interface')[0]
vmxml.del_device(iface_xml)
new_iface = interface.Interface('network')
new_iface.xml = iface_xml.xml
new_filterref = new_iface.new_filterref(**filterref_dict)
new_iface.filterref = new_filterref
logging.debug("new interface xml is: %s" % new_iface)
vmxml.add_device(new_iface)
vmxml.sync()
if mount_noexec_tmp:
device_name = utlv.setup_or_cleanup_iscsi(is_setup=True)
utlv.mkfs(device_name, 'ext4')
cmd = "mount %s /tmp -o noexec,nosuid" % device_name
process.run(cmd, shell=True)
if ipset_command:
pkg = "ipset"
if not utils_package.package_install(pkg):
test.cancel("Can't install ipset on host")
process.run(ipset_command, shell=True)
# Run command
try:
vm.start()
if not mount_noexec_tmp:
vm.wait_for_serial_login(username=username, password=password)
vmxml = libvirt_xml.VMXML.new_from_dumpxml(vm_name)
iface_xml = vmxml.get_devices('interface')[0]
iface_target = iface_xml.target['dev']
iface_mac = iface_xml.mac_address
logging.debug("iface target dev name is %s", iface_target)
# Check iptables or ebtables on host
if need_vm2:
# Clone more vm for testing
result = virsh.dom_list('--inactive').stdout_text
if add_vm_name in result:
logging.debug("%s is already exists!" % add_vm_name)
vms.append(env.get_vm(add_vm_name))
else:
vm.destroy()
ret_clone = utils_libguestfs.virt_clone_cmd(vm_name,
add_vm_name,
True,
timeout=360)
if ret_clone.exit_status:
test.fail("Error when clone a second vm!")
vms.append(vm.clone(add_vm_name))
vm.start()
vm2 = vms[1]
logging.debug("Now the vms is: %s", [dom.name for dom in vms])
# update the vm2 interface with the nwfilter
logging.debug("filter_params_list is %s" % filter_param_list)
iface_dict = {
"filter": filter_name,
"filter_parameters": filter_param_list,
"del_mac": True
}
if vm2.is_alive():
vm2.destroy()
utlv.modify_vm_iface(vm2.name, "update_iface", iface_dict)
vmxml = libvirt_xml.VMXML.new_from_inactive_dumpxml(vm2.name)
iface_xml = vmxml.get_devices('interface')[0]
logging.debug("iface_xml for vm2 is %s" % iface_xml)
vm2.start()
vm2_session = vm2.wait_for_serial_login()
vm2_mac = vm2.get_mac_address()
vm2_ip = utils_net.get_guest_ip_addr(vm2_session, vm2_mac)
vm.session = vm.wait_for_serial_login()
# test network functions, the 2 vms can not access to each other
gateway_ip = utils_net.get_ip_address_by_interface("virbr0")
status1, output1 = utils_net.ping(dest=vm2_ip,
count='3',
timeout=ping_timeout,
session=vm.session,
force_ipv4=True)
status2, output2 = utils_net.ping(dest=gateway_ip,
count='3',
timeout=ping_timeout,
session=vm.session,
force_ipv4=True)
status3, output3 = utils_net.ping(dest=dst_outside,
count='3',
timeout=ping_timeout,
session=vm.session,
force_ipv4=True)
if not status1:
test.fail(
"vm with clean-traffic-gateway ping succeed to %s %s, but it is not expected!"
% (vm2.name, vm2_ip))
if status2 or status3:
test.fail("vm ping failed! check %s \n %s" %
(output2, output3))
if cmd_list_:
loop = 0
for check_cmd_, expect_match_ in cmd_result_dict.items():
check_cmd = check_cmd_.strip()
expect_match = expect_match_.strip()
if "DEVNAME" in check_cmd:
check_cmd = check_cmd.replace("DEVNAME", iface_target)
if "VMMAC" in expect_match:
expect_match = expect_match.replace("VMMAC", iface_mac)
logging.debug(
"the check_cmd is %s, and expected result is %s" %
(check_cmd, expect_match))
check_nwfilter_rules(check_cmd, expect_match)
loop += 1
except virt_vm.VMStartError as e:
# Starting VM failed.
if not status_error:
test.fail("Test failed in positive case.\n error:"
" %s\n%s" % (e, bug_url))
if kill_libvirtd:
daemon_name = libvirtd.service_name
pid = process.run('pidof %s' % daemon_name,
shell=True).stdout_text.strip()
cmd = "kill -s TERM %s" % pid
process.run(cmd, shell=True)
ret = utils_misc.wait_for(lambda: not libvirtd.is_running(),
timeout=30)
# After libvirt 5.6.0, libvirtd is using systemd socket activation by default
if not ret and not libvirt_version.version_compare(5, 6, 0):
test.fail("Failed to kill libvirtd. %s" % bug_url)
finally:
if kill_libvirtd:
libvirtd.restart()
# Clean env
if vm.is_alive():
vm.destroy(gracefully=False)
# Recover xml of vm.
vmxml_backup.sync()
# Undefine created filter except clean-traffic as it is built-in nwfilter
if filter_name != exist_filter and filter_name != 'clean-traffic':
virsh.nwfilter_undefine(filter_name, debug=True)
if mount_noexec_tmp:
if device_name:
process.run("umount -l %s" % device_name,
ignore_status=True,
shell=True)
utlv.setup_or_cleanup_iscsi(is_setup=False)
if ipset_command:
process.run("ipset destroy blacklist", shell=True)
# Remove additional vms
if need_vm2:
result = virsh.dom_list("--all").stdout_text
if add_vm_name in result:
virsh.remove_domain(add_vm_name, "--remove-all-storage")
def run(test, params, env):
"""
Test command: virsh rename.
The command can rename a domain.
1.Prepare test environment.
2.Perform virsh rename operation.
3.Recover test environment.
4.Confirm the test result.
"""
# Get specific parameter value
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
domuuid = vm.get_uuid()
vm_ref = params.get("domrename_vm_ref", "name")
status_error = "yes" == params.get("status_error", "no")
new_name = params.get("vm_new_name", "new")
pre_vm_state = params.get("domrename_vm_state", "shutoff")
domain_option = params.get("dom_opt", "")
new_name_option = params.get("newname_opt", "")
add_vm = "yes" == params.get("add_vm", "no")
# Replace the varaiables
if vm_ref == "name":
vm_ref = vm_name
elif vm_ref == "uuid":
vm_ref = domuuid
if new_name == "vm2_name":
vm2_name = ("%s" % vm_name[:-1]) + "2"
new_name = vm2_name
# Build input params
dom_param = ' '.join([domain_option, vm_ref])
new_name_param = ' '.join([new_name_option, new_name])
if vm.is_alive():
vm.destroy()
# Backup for recovery.
vmxml_backup = libvirt_xml.vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
logging.debug("vm xml is %s", vmxml_backup)
# Clone additional vms if needed
if add_vm:
try:
utils_path.find_command("virt-clone")
except utils_path.CmdNotFoundError:
if not utils_package.package_install(["virt-install"]):
test.cancel("Failed to install virt-install on host")
ret_clone = utils_libguestfs.virt_clone_cmd(vm_name,
vm2_name,
True,
timeout=360)
if ret_clone.exit_status:
test.fail("Error occured when clone a second vm!")
vm2 = libvirt_vm.VM(vm2_name, vm.params, vm.root_dir, vm.address_cache)
virsh.dom_list("--name --all", debug=True)
# Create object instance for renamed domain
new_vm = libvirt_vm.VM(new_name, vm.params, vm.root_dir, vm.address_cache)
# Prepare vm state
if pre_vm_state not in ["shutoff", "autostart"]:
vm.start()
if pre_vm_state == "paused":
vm.pause()
logging.debug("Domain state is now: %s", vm.state())
elif pre_vm_state == "managed_saved":
vm.managedsave()
elif pre_vm_state == "with_snapshot":
virsh.snapshot_create_as(vm_name, "snap1 --disk-only", debug=True)
vm.destroy(gracefully=False)
try:
if pre_vm_state == "autostart":
virsh.autostart(dom_param, "", debug=True)
virsh.dom_list("--all --autostart", debug=True)
logging.debug("files under '/etc/libvirt/qemu/autostart/' are %s",
os.listdir('/etc/libvirt/qemu/autostart/'))
result = virsh.domrename(dom_param,
new_name_param,
ignore_status=True,
debug=True)
# Raise unexpected pass or fail
libvirt.check_exit_status(result, status_error)
# Return expected failure for negative tests
if status_error:
logging.debug("Expected failure: %s", result.stderr)
return
# Checkpoints after domrename succeed
else:
list_ret = virsh.dom_list("--name --all",
debug=True).stdout.strip().splitlines()
domname_ret = virsh.domname(domuuid, debug=True).stdout.strip()
if new_name not in list_ret or vm_name in list_ret:
test.fail("New name does not affect in virsh list")
if domname_ret != new_name:
test.fail(
"New domain name does not affect in virsh domname uuid")
if pre_vm_state != "autostart":
# Try to start vm with the new name
new_vm.start()
else:
utils_libvirtd.libvirtd_restart()
list_autostart = virsh.dom_list("--autostart",
debug=True).stdout
logging.debug(
"files under '/etc/libvirt/qemu/autostart/' are %s",
os.listdir('/etc/libvirt/qemu/autostart/'))
process.run("file /etc/libvirt/qemu/autostart/%s.xml" %
vm_name,
verbose=True)
if new_name not in list_autostart:
test.fail(
"Domain isn't autostarted after restart libvirtd,"
"or becomes a never 'autostart' one.")
finally:
# Remove additional vms
if add_vm and vm2.exists() and result.exit_status:
virsh.remove_domain(vm2_name, "--remove-all-storage")
# Undefine newly renamed domain
if new_vm.exists():
if new_vm.is_alive():
new_vm.destroy(gracefully=False)
new_vm.undefine()
# Recover domain state
if pre_vm_state != "shutoff":
if pre_vm_state == "with_snapshot":
libvirt.clean_up_snapshots(vm_name)
else:
if pre_vm_state == "managed_saved":
vm.start()
vm.destroy(gracefully=False)
# Restore VM
vmxml_backup.sync()
def get_names(self):
return virsh.dom_list(options='--all --name').stdout.splitlines()
def run_virsh_restore(test, params, env):
"""
Test command: virsh restore.
Restore a domain from a saved state in a file
1.Prepare test environment.
2.When the libvirtd == "off", stop the libvirtd service.
3.Run virsh restore command with assigned option.
4.Recover test environment.
5.Confirm the test result.
"""
vm_name = params.get("main_vm", "vm1")
vm = env.get_vm(params["main_vm"])
session = vm.wait_for_login()
os_type = params.get("os_type")
status_error = params.get("restore_status_error")
libvirtd = params.get("restore_libvirtd")
extra_param = params.get("restore_extra_param")
pre_status = params.get("restore_pre_status")
vm_ref = params.get("restore_vm_ref")
#run test
if vm_ref == "" or vm_ref == "xyz":
status = virsh.restore(vm_ref, ignore_status=True).exit_status
else:
if os_type == "linux":
cmd = "cat /proc/cpuinfo"
status, output = session.cmd_status_output(cmd,
internal_timeout=10)
session.close()
if not re.search("processor", output):
raise error.TestFail("Unable to read /proc/cpuinfo")
tmp_file = vm_ref
if vm_ref == "/tmp/save.file":
virsh.save(vm_name, vm_ref)
vm_ref = "%s %s" % (vm_ref, extra_param)
elif vm_ref == "/tmp/new.file":
open(vm_ref, 'w').close()
if vm.is_alive():
vm.destroy()
if pre_status == "start":
virsh.start(vm_name)
if libvirtd == "off":
libvirt_vm.libvirtd_stop()
status = virsh.restore(vm_ref, ignore_status=True).exit_status
os.unlink(tmp_file)
if status_error == "no":
list_output = virsh.dom_list().stdout.strip()
session.close()
#recover libvirtd service start
if libvirtd == "off":
libvirt_vm.libvirtd_start()
if vm.is_alive():
vm.destroy()
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")
else:
if not re.search(vm_name, list_output):
raise error.TestFail("Run failed with right command")
def run(test, params, env):
"""
Test steps:
1) Get the params from params.
2) check the environment
3) Strat the VM and check whether the VM been started successfully
4) Compare the Hugepage memory size to the Guest memory setted.
5) Check the hugepage memory usage.
6) Clean up
"""
test_type = params.get("test_type", 'normal')
tlbfs_enable = 'yes' == params.get("hugetlbfs_enable", 'no')
shp_num = int(params.get("static_hugepage_num", 1024))
thp_enable = 'yes' == params.get("trans_hugepage_enable", 'no')
mb_enable = 'yes' == params.get("mb_enable", 'yes')
delay = int(params.get("delay_time", 10))
# backup orignal setting
shp_orig_num = utils_memory.get_num_huge_pages()
thp_orig_status = utils_memory.get_transparent_hugepage()
page_size = utils_memory.get_huge_page_size()
if test_type == "contrast":
range = float(params.get("mem_error_range", 1.25))
elif test_type == "stress":
target_path = params.get("target_path", "/tmp/test.out")
elif test_type == "unixbench":
unixbench_control_file = params.get("unixbench_controle_file",
"unixbench5.control")
vm_names = []
if test_type == "contrast":
vm_names = params.get("vms").split()[:2]
if len(vm_names) < 2:
raise error.TestNAError("Hugepage Stress Test need two VM(s).")
# confirm no VM(s) running
allvms = virsh.dom_list('--name').stdout.strip()
if allvms != '':
raise error.TestNAError("one or more VM(s) is living.")
else:
vm_names.append(params.get("main_vm"))
# mount/umount hugetlbfs
tlbfs_status = utils_misc.is_mounted("hugetlbfs", "/dev/hugepages", "hugetlbfs")
if tlbfs_enable is True:
if tlbfs_status is not True:
utils_misc.mount("hugetlbfs", "/dev/hugepages", "hugetlbfs")
else:
if tlbfs_status is True:
utils_misc.umount("hugetlbfs", "/dev/hugepages", "hugetlbfs")
# set static hugepage
utils_memory.set_num_huge_pages(shp_num)
# enable/disable transparent hugepage
if thp_enable:
utils_memory.set_transparent_hugepage('always')
else:
utils_memory.set_transparent_hugepage('never')
# set/del memoryBacking tag
for vm_name in vm_names:
if mb_enable:
vm_xml.VMXML.set_memoryBacking_tag(vm_name)
else:
vm_xml.VMXML.del_memoryBacking_tag(vm_name)
utils_libvirtd.libvirtd_restart()
non_started_free = utils_memory.get_num_huge_pages_free()
vms = []
sessions = []
for vm_name in vm_names:
# try to start vm and login
try:
vm = env.get_vm(vm_name)
vm.start()
except VMError, e:
if mb_enable and not tlbfs_enable:
# if hugetlbfs not be mounted,
# VM start with memoryBacking tag will fail
logging.debug(e)
pass # jump out of for-loop
else:
error_msg = "Test failed in positive case. error: %s\n" % e
raise error.TestFail(error_msg)
if vm.is_alive() is not True:
break
vms.append(vm)
# try to login and run some program
try:
session = vm.wait_for_login()
except (LoginError, ShellError), e:
error_msg = "Test failed in positive case.\n error: %s\n" % e
raise error.TestFail(error_msg)
def run(test, params, env):
"""
Test pure checkpoint commands
"""
def prepare_checkpoints(disk="vdb", num=1, cp_prefix="test_checkpoint_"):
"""
Create checkpoints for specific disk
:param disk: The disk to create checkpoint.
:param num: How many checkpoints to be created
:param cp_prefix: The prefix to name the checkpoint.
"""
option_pattern = ("{0} --diskspec vda,checkpoint=no "
"--diskspec {1},checkpoint=bitmap,bitmap={0}")
for i in range(num):
# create checkpoints
checkpoint_name = cp_prefix + str(i)
options = option_pattern.format(checkpoint_name, disk)
virsh.checkpoint_create_as(vm_name, options, **virsh_dargs)
current_checkpoints.append(checkpoint_name)
# Cancel the test if libvirt version is too low
if not libvirt_version.version_compare(6, 0, 0):
test.cancel("Current libvirt version doesn't support "
"incremental backup.")
checkpoint_cmd = params.get("checkpoint_cmd")
cmd_flag = params.get("flag")
required_checkpoints = int(params.get("required_checkpoints", 0))
test_disk_size = params.get("test_disk_size", "100M")
test_disk_target = params.get("test_disk_target", "vdb")
status_error = "yes" == params.get("status_error")
tmp_dir = data_dir.get_tmp_dir()
current_checkpoints = []
virsh_dargs = {'debug': True, 'ignore_status': False}
try:
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
# Backup vm xml
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
vmxml_backup = vmxml.copy()
# Enable vm incremental backup capability. This is only a workaround
# to make sure incremental backup can work for the vm. Code needs to
# be removded immediately when the function enabled by default, which
# is tracked by bz1799015
tree = ET.parse(vmxml.xml)
root = tree.getroot()
for elem in root.iter('domain'):
elem.set('xmlns:qemu', 'http://libvirt.org/schemas/domain/qemu/1.0')
qemu_cap = ET.Element("qemu:capabilities")
elem.insert(-1, qemu_cap)
incbackup_cap = ET.Element("qemu:add")
incbackup_cap.set('capability', 'incremental-backup')
qemu_cap.insert(1, incbackup_cap)
vmxml.undefine()
tmp_vm_xml = os.path.join(tmp_dir, "tmp_vm.xml")
tree.write(tmp_vm_xml)
virsh.define(tmp_vm_xml)
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
logging.debug("Script insert xml elements to make sure vm can support "
"incremental backup. This should be removded when "
"bz 1799015 fixed.")
if vm.is_alive():
vm.destroy(gracefully=False)
# Prepare the disk to be used.
disk_params = {}
disk_path = ""
image_name = "{}_image.qcow2".format(test_disk_target)
disk_path = os.path.join(tmp_dir, image_name)
libvirt.create_local_disk("file", disk_path, test_disk_size,
"qcow2")
disk_params = {"device_type": "disk",
"type_name": "file",
"driver_type": "qcow2",
"target_dev": test_disk_target,
"source_file": disk_path}
disk_xml = libvirt.create_disk_xml(disk_params)
virsh.attach_device(vm.name, disk_xml,
flagstr="--config", **virsh_dargs)
vm.start()
session = vm.wait_for_login().close()
if required_checkpoints > 0:
prepare_checkpoints(test_disk_target, required_checkpoints)
if checkpoint_cmd == "checkpoint-create":
if not current_checkpoints:
test.fail("No existing checkpoints prepared.")
if "--redefine" in cmd_flag:
no_domain = "yes" == params.get("no_domain")
cp_dumpxml_options = ""
if no_domain:
cp_dumpxml_options = "--no-domain"
checkpoint_redef = current_checkpoints[0]
cp_xml = checkpoint_xml.CheckpointXML.new_from_checkpoint_dumpxml(
vm_name, checkpoint_redef, cp_dumpxml_options)
logging.debug("Checkpoint XML to be redefined is: %s", cp_xml)
xml_file = cp_xml.xml
virsh.checkpoint_delete(vm_name, checkpoint_redef,
"--metadata", **virsh_dargs)
cmd_options = xml_file + " " + cmd_flag
result = virsh.checkpoint_create(vm_name, cmd_options, debug=True)
libvirt.check_exit_status(result, status_error)
elif checkpoint_cmd == "checkpoint-create-as":
if "--print-xml" in cmd_flag:
checkpoint_name = "test_checkpoint_0"
options = ("{0} --diskspec vda,checkpoint=no --diskspec {1},"
"checkpoint=bitmap,bitmap={0} "
"--print-xml".format(checkpoint_name, test_disk_target))
virsh.checkpoint_create_as(vm_name, options, **virsh_dargs)
# The checkpiont should not be created, so we have following check
cp_list_result = virsh.checkpoint_list(vm_name, checkpoint_name, debug=True)
libvirt.check_exit_status(cp_list_result, True)
elif checkpoint_cmd == "checkpoint-info":
if len(current_checkpoints) != 3:
test.fail("We should prepare 3 checkpoints.")
parent_checkpoint = current_checkpoints[0]
test_checkpoint = current_checkpoints[1]
stdout = virsh.checkpoint_info(vm_name, test_checkpoint,
**virsh_dargs).stdout_text.strip()
if (
not re.search("domain.*%s" % vm_name, stdout, re.IGNORECASE) or
not re.search("parent.*%s" % parent_checkpoint, stdout, re.IGNORECASE) or
not re.search("children.*1", stdout, re.IGNORECASE) or
not re.search("descendants.*1", stdout, re.IGNORECASE)
):
test.fail("checkpoint-info return inaccurate informaion: %s" % stdout)
elif checkpoint_cmd == "checkpoint-list":
logic_error = False
if not cmd_flag:
stdout = virsh.checkpoint_list(vm_name,
**virsh_dargs).stdout_text.strip()
for checkpoint in current_checkpoints:
if checkpoint not in stdout:
logic_error = True
elif cmd_flag == "--parent":
stdout = virsh.checkpoint_list(vm_name, cmd_flag,
**virsh_dargs).stdout_text.strip()
for checkpoint in current_checkpoints:
if checkpoint == current_checkpoints[-1]:
if stdout.count(checkpoint) != 1:
logic_error = True
else:
if stdout.count(checkpoint) != 2:
logic_error = True
elif cmd_flag == "--roots":
stdout = virsh.checkpoint_list(vm_name, cmd_flag,
**virsh_dargs).stdout_text.strip()
for checkpoint in current_checkpoints:
if checkpoint == current_checkpoints[0]:
if stdout.count(checkpoint) != 1:
logic_eror = True
else:
if stdout.count(checkpoint) != 0:
logic_error = True
elif cmd_flag == "--tree":
stdout = virsh.checkpoint_list(vm_name, cmd_flag,
**virsh_dargs).stdout_text.strip()
lines = stdout.splitlines()
prev_indent_num = -1
for line in lines:
for checkpoint in current_checkpoints:
if checkpoint in line:
cur_indent_num = line.rstrip().count(" ")
if cur_indent_num <= prev_indent_num:
logic_error = True
break
prev_indent_num = cur_indent_num
elif cmd_flag == "--name":
stdout = virsh.checkpoint_list(vm_name, cmd_flag,
**virsh_dargs).stdout_text.strip()
checkpoint_names = stdout.splitlines()
if not operator.eq(checkpoint_names, current_checkpoints):
logic_error = True
elif cmd_flag == "--topological":
stdout = virsh.checkpoint_list(vm_name, cmd_flag,
**virsh_dargs).stdout_text.strip()
for checkpoint in current_checkpoints:
if checkpoint not in stdout:
logical_error = True
elif cmd_flag == "--from":
cmd_options = cmd_flag + " " + current_checkpoints[0]
stdout = virsh.checkpoint_list(vm_name, cmd_options,
**virsh_dargs).stdout_text.strip()
if (current_checkpoints[0] in stdout
or current_checkpoints[2] in stdout
or current_checkpoints[1] not in stdout):
logic_error = True
elif cmd_flag == "--descendants":
cmd_options = cmd_flag + " " + current_checkpoints[0]
stdout = virsh.checkpoint_list(vm_name, cmd_options,
**virsh_dargs).stdout_text.strip()
if (current_checkpoints[0] in stdout
or current_checkpoints[1] not in stdout
or current_checkpoints[2] not in stdout):
logic_error = True
elif cmd_flag == "--no-leaves":
stdout = virsh.checkpoint_list(vm_name, cmd_flag,
**virsh_dargs).stdout_text.strip()
if (current_checkpoints[0] not in stdout
or current_checkpoints[1] not in stdout
or current_checkpoints[2] in stdout):
logic_error = True
elif cmd_flag == "--leaves":
stdout = virsh.checkpoint_list(vm_name, cmd_flag,
**virsh_dargs).stdout_text.strip()
if (current_checkpoints[0] in stdout
or current_checkpoints[1] in stdout
or current_checkpoints[2] not in stdout):
logic_error = True
if logic_error:
test.fail("checkpoint-list with '%s' gives wrong output"
% cmd_flag)
elif checkpoint_cmd == "checkpoint-dumpxml":
if "--size" in cmd_flag:
test.cancel("'--size' not supported yet(bz1814573)")
elif "--security-info" in cmd_flag:
if vm.is_alive():
vm.destroy(gracefully=False)
password = "******"
vm_xml.VMXML.set_graphics_attr(vm_name, {'passwd': password})
vm.start()
vm.wait_for_login().close()
prepare_checkpoints()
test_checkpoint = current_checkpoints[0]
stdout = virsh.checkpoint_dumpxml(vm_name,
test_checkpoint,
**virsh_dargs).stdout_text.strip()
if password in stdout:
logging.debug("checkpoint xml is: %s", stdout)
test.fail("Security info displayed in unsecurity dumpxml.")
stdout = virsh.checkpoint_dumpxml(vm_name,
test_checkpoint + " --security-info",
**virsh_dargs).stdout_text.strip()
if password not in stdout:
logging.debug("checkpoint xml is: %s", stdout)
test.fail("Security info not displayed in security dumpxml.")
elif checkpoint_cmd == "virsh_list":
stdout = virsh.dom_list(cmd_flag, **virsh_dargs).stdout_text.strip()
if ((vm_name in stdout and cmd_flag == "--without-checkpoint") or
(vm_name not in stdout and cmd_flag == "--with-checkpoint")):
test.fail("virsh list with '%s' contains wrong data" % cmd_flag)
finally:
# Remove checkpoints
if "current_checkpoints" in locals() and current_checkpoints:
for checkpoint_name in current_checkpoints:
virsh.checkpoint_delete(vm_name, checkpoint_name,
ignore_status=True, debug=True)
if vm.is_alive():
vm.destroy(gracefully=False)
# Restoring vm
vmxml_backup.sync()
def run(test, params, env):
"""
Test steps:
1) Get the params from params.
2) check the environment
3) Strat the VM and check whether the VM been started successfully
4) Compare the Hugepage memory size to the Guest memory setted.
5) Check the hugepage memory usage.
6) Clean up
"""
test_type = params.get("test_type", 'normal')
tlbfs_enable = 'yes' == params.get("hugetlbfs_enable", 'no')
shp_num = int(params.get("static_hugepage_num", 1024))
thp_enable = 'yes' == params.get("trans_hugepage_enable", 'no')
mb_enable = 'yes' == params.get("mb_enable", 'yes')
delay = int(params.get("delay_time", 10))
# Skip cases early
vm_names = []
if test_type == "contrast":
vm_names = params.get("vms").split()[:2]
if len(vm_names) < 2:
test.cancel("This test requires two VMs")
# confirm no VM running
allvms = virsh.dom_list('--name').stdout.strip()
if allvms != '':
test.cancel("one or more VMs are alive")
err_range = float(params.get("mem_error_range", 1.25))
else:
vm_names.append(params.get("main_vm"))
if test_type == "stress":
target_path = params.get("target_path", "/tmp/test.out")
elif test_type == "unixbench":
unixbench_control_file = params.get("unixbench_controle_file",
"unixbench5.control")
# backup orignal setting
shp_orig_num = utils_memory.get_num_huge_pages()
thp_orig_status = utils_memory.get_transparent_hugepage()
page_size = utils_memory.get_huge_page_size()
# mount/umount hugetlbfs
tlbfs_status = utils_misc.is_mounted("hugetlbfs", "/dev/hugepages",
"hugetlbfs")
if tlbfs_enable is True:
if tlbfs_status is not True:
utils_misc.mount("hugetlbfs", "/dev/hugepages", "hugetlbfs")
else:
if tlbfs_status is True:
utils_misc.umount("hugetlbfs", "/dev/hugepages", "hugetlbfs")
# set static hugepage
utils_memory.set_num_huge_pages(shp_num)
# enable/disable transparent hugepage
if thp_enable:
utils_memory.set_transparent_hugepage('always')
else:
utils_memory.set_transparent_hugepage('never')
# set/del memoryBacking tag
for vm_name in vm_names:
if mb_enable:
vm_xml.VMXML.set_memoryBacking_tag(vm_name)
else:
vm_xml.VMXML.del_memoryBacking_tag(vm_name)
utils_libvirtd.libvirtd_restart()
non_started_free = utils_memory.get_num_huge_pages_free()
vms = []
sessions = []
try:
for vm_name in vm_names:
# try to start vm and login
try:
vm = env.get_vm(vm_name)
vm.start()
except VMError as e:
if mb_enable and not tlbfs_enable:
# if hugetlbfs not be mounted,
# VM start with memoryBacking tag will fail
logging.debug(e)
else:
error_msg = "Test failed in positive case. error: %s\n" % e
test.fail(error_msg)
if vm.is_alive() is not True:
break
vms.append(vm)
# try to login and run some program
try:
session = vm.wait_for_login()
except (LoginError, ShellError) as e:
error_msg = "Test failed in positive case.\n error: %s\n" % e
test.fail(error_msg)
sessions.append(session)
if test_type == "stress":
# prepare file for increasing stress
stress_path = prepare_c_file()
remote.scp_to_remote(vm.get_address(), 22,
'root', params.get('password'),
stress_path, "/tmp/")
# Try to install gcc on guest first
utils_package.package_install(["gcc"], session, 360)
# increasing workload
session.cmd("gcc %s -o %s" % (stress_path, target_path))
session.cmd("%s &" % target_path)
if test_type == "unixbench":
params["main_vm"] = vm_name
params["test_control_file"] = unixbench_control_file
control_path = os.path.join(test.virtdir, "control",
unixbench_control_file)
# unixbench test need 'patch' and 'perl' commands installed
utils_package.package_install(["patch", "perl"], session, 360)
command = utils_test.run_autotest(vm, session, control_path,
None, None, params,
copy_only=True)
session.cmd("%s &" % command, ignore_all_errors=True)
# wait for autotest running on vm
time.sleep(delay)
def _is_unixbench_running():
cmd = "ps -ef | grep perl | grep Run"
return not session.cmd_status(cmd)
if not utils_misc.wait_for(_is_unixbench_running, timeout=240):
test.cancel("Failed to run unixbench in guest,"
" please make sure some necessary"
" packages are installed in guest,"
" such as gcc, tar, bzip2")
logging.debug("Unixbench test is running in VM")
if test_type == "contrast":
# wait for vm finish starting completely
time.sleep(delay)
if not (mb_enable and not tlbfs_enable):
logging.debug("starting analyzing the hugepage usage...")
pid = vms[-1].get_pid()
started_free = utils_memory.get_num_huge_pages_free()
# Get the thp usage from /proc/pid/smaps
started_anon = utils_memory.get_num_anon_huge_pages(pid)
static_used = non_started_free - started_free
hugepage_used = static_used * page_size
if test_type == "contrast":
# get qemu-kvm memory consumption by top
cmd = "top -b -n 1|awk '$1 == %s {print $10}'" % pid
rate = process.run(cmd, ignore_status=False,
verbose=True, shell=True).stdout_text.strip()
qemu_kvm_used = (utils_memory.memtotal() * float(rate)) / 100
logging.debug("rate: %s, used-by-qemu-kvm: %f, used-by-vm: %d",
rate, qemu_kvm_used, hugepage_used)
if abs(qemu_kvm_used - hugepage_used) > hugepage_used * (err_range - 1):
test.fail("Error for hugepage usage")
if test_type == "stress":
if non_started_free <= started_free:
logging.debug("hugepage usage:%d -> %d", non_started_free,
started_free)
test.fail("Error for hugepage usage with stress")
if mb_enable is not True:
if static_used > 0:
test.fail("VM use static hugepage without"
" memoryBacking element")
if thp_enable is not True and started_anon > 0:
test.fail("VM use transparent hugepage, while"
" it's disabled")
else:
if tlbfs_enable is not True:
if static_used > 0:
test.fail("VM use static hugepage without tlbfs"
" mounted")
if thp_enable and started_anon <= 0:
test.fail("VM doesn't use transparent"
" hugepage")
else:
if shp_num > 0:
if static_used <= 0:
test.fail("VM doesn't use static"
" hugepage")
else:
if static_used > 0:
test.fail("VM use static hugepage,"
" while it's set to zero")
if thp_enable is not True:
if started_anon > 0:
test.fail("VM use transparent hugepage,"
" while it's disabled")
else:
if shp_num == 0 and started_anon <= 0:
test.fail("VM doesn't use transparent"
" hugepage, while static"
" hugepage is disabled")
finally:
# end up session
for session in sessions:
session.close()
for vm in vms:
if vm.is_alive():
vm.destroy()
for vm_name in vm_names:
if mb_enable:
vm_xml.VMXML.del_memoryBacking_tag(vm_name)
else:
vm_xml.VMXML.set_memoryBacking_tag(vm_name)
utils_libvirtd.libvirtd_restart()
if tlbfs_enable is True:
if tlbfs_status is not True:
utils_misc.umount("hugetlbfs", "/dev/hugepages", "hugetlbfs")
else:
if tlbfs_status is True:
utils_misc.mount("hugetlbfs", "/dev/hugepages", "hugetlbfs")
utils_memory.set_num_huge_pages(shp_orig_num)
utils_memory.set_transparent_hugepage(thp_orig_status)
def run(test, params, env):
"""
Start libvirt daemon with different options.
Check socket files.
"""
log = []
def _logger(line):
"""
Callback function to log libvirtd output.
"""
log.append(line)
def check_help(params):
"""
Check whether the output is help and meets expectation
"""
expected_help = params.get('expected_help', 'no') == 'yes'
is_help = any(line.startswith('Usage:') for line in log)
if expected_help != is_help:
test.fail(
'Expected output help is %s, but get output:\n%s' %
(expected_help, '\n'.join(log)))
def check_version(params):
"""
Check whether the output is libvirtd version.
"""
expected_version = params.get('expected_version', 'no') == 'yes'
is_version = log[0].startswith('{} (libvirt)'.format(daemon_name))
if expected_version != is_version:
test.fail(
'Expected output version is %s, but get output:\n%s' %
(expected_version, '\n'.join(log)))
def check_unix_socket_files():
"""
Check whether the socket file exists.
"""
rw_sock_path = '/var/run/libvirt/libvirt-sock'
ro_sock_path = '/var/run/libvirt/libvirt-sock-ro'
if libvirtd.running or libvirt_version.version_compare(5, 6, 0):
if not os.path.exists(rw_sock_path):
test.fail('RW unix socket file not found at %s' %
rw_sock_path)
if not os.path.exists(ro_sock_path):
test.fail('RO unix socket file not found at %s' %
ro_sock_path)
else:
if os.path.exists(rw_sock_path) or os.path.exists(ro_sock_path):
test.fail('Expect unix socket file do not exists '
'when libvirtd is stopped')
def check_pid_file():
"""
Check whether the pid file exists.
"""
if not os.path.exists(pid_path):
test.fail("PID file not found at %s" % pid_path)
with open(pid_path) as pid_file:
pid = int(pid_file.readline())
result = process.run('pgrep %s' % daemon_name,
ignore_status=True, shell=True)
expected_pid = int(result.stdout_text.strip().split()[0])
if pid != expected_pid:
test.fail("PID file content mismatch. Expected %s "
"but got %s" % (expected_pid, pid))
def check_config_file():
"""
Check whether the config file take effects by checking max_clients.
"""
connect_uri = daemon_name + ":///system"
vp = virt_admin.VirtadminPersistent(uri=connect_uri)
result = vp.srv_clients_info(daemon_name, uri=connect_uri, ignore_status=True, debug=True)
output = result.stdout.strip().splitlines()
out_split = [item.split(':') for item in output]
out_dict = dict([[item[0].strip(), item[1].strip()] for item in out_split])
if int(out_dict["nclients_max"]) != check_max_clients:
test.fail('Expected max_clients is %s, but got %s' %
(check_max_clients, out_dict["nclients_max"]))
MAX_TIMEOUT = 10
arg_str = params.get("libvirtd_arg", "")
time_tolerance = float(params.get("exit_time_tolerance", 1))
expected_exit_time = float(params.get("expected_exit_time", 'inf'))
config_path = params.get('expected_config_path', "")
pid_path = params.get('expected_pid_path', "")
daemon_name = params.get('daemon_name', "")
test_config = params.get('test_config', "no") == "yes"
require_modular_daemon = params.get('require_modular_daemon', "no") == "yes"
utils_split_daemons.daemon_mode_check(require_modular_daemon)
if expected_exit_time == float('inf'):
timeout = MAX_TIMEOUT
else:
if expected_exit_time > 0:
if len(virsh.dom_list('--name').stdout.strip().splitlines()):
test.cancel('Timeout option will be ignore if '
'there exists living domain')
timeout = expected_exit_time + time_tolerance
libvirtd = LibvirtdSession(service_name=daemon_name, logging_handler=_logger)
# Setup config file.
check_max_clients = int(101)
if test_config:
config = utils_config.get_conf_obj(daemon_name)
logging.debug(config.conf_path)
config_path = config.conf_path
config.max_clients = check_max_clients
arg_str = arg_str + config_path
try:
check_unix_socket_files()
Libvirtd(daemon_name).stop()
libvirtd.start(arg_str=arg_str, wait_for_working=False)
start = time.time()
libvirtd_exited = libvirtd.wait_for_stop(timeout=timeout, step=0.1)
wait_time = time.time() - start
if log:
logging.debug("Libvirtd log:")
for line in log:
logging.debug(line)
check_help(params)
check_version(params)
if libvirtd_exited:
if expected_exit_time == float('inf'):
test.fail("Expected never stop, but ran %ss" % wait_time)
elif wait_time < expected_exit_time - time_tolerance:
test.fail("Expected exit in %ss(+-%ss), but ran %ss" %
(expected_exit_time, time_tolerance, wait_time))
else:
if expected_exit_time != float('inf'):
test.fail("Expected exit in %ss(+-%ss), but ran timeout in %ss" %
(expected_exit_time, time_tolerance, wait_time))
not libvirt_version.version_compare(5, 6, 0) and check_unix_socket_files()
if test_config:
check_config_file()
if pid_path:
check_pid_file()
finally:
libvirtd.exit()
Libvirtd(daemon_name).stop()
socket_name = daemon_name + ".socket"
Libvirtd(socket_name).restart()
Libvirtd(daemon_name).start()
# Clean up config file
if test_config:
config.restore()
if os.path.exists(pid_path):
os.remove(pid_path)
def run(test, params, env):
"""
LXC container life cycle testing by virsh command
"""
uri = params.get("connect_uri", "lxc:///")
vm_name = params.get("main_vm")
dom_type = params.get("lxc_domtype", "lxc")
vcpu = int(params.get("lxc_vcpu", 1))
max_mem = int(params.get("lxc_max_mem", 500000))
current_mem = int(params.get("lxc_current_mem", 500000))
os_type = params.get("lxc_ostype", "exe")
os_arch = params.get("lxc_osarch", "x86_64")
os_init = params.get("lxc_osinit", "/bin/sh")
emulator_path = params.get("lxc_emulator",
"/usr/libexec/libvirt_lxc")
interface_type = params.get("lxc_interface_type", "network")
net_name = params.get("lxc_net_name", "default")
full_os = ("yes" == params.get("lxc_full_os", "no"))
install_root = params.get("lxc_install_root", "/")
fs_target = params.get("lxc_fs_target", "/")
fs_accessmode = params.get("lxc_fs_accessmode", "passthrough")
passwd = params.get("lxc_fs_passwd", "redhat")
def generate_container_xml():
"""
Generate container xml
"""
vmxml = vm_xml.VMXML(dom_type)
vmxml.vm_name = vm_name
vmxml.max_mem = max_mem
vmxml.current_mem = current_mem
vmxml.vcpu = vcpu
# Generate os
vm_os = vm_xml.VMOSXML()
vm_os.type = os_type
vm_os.arch = os_arch
vm_os.init = os_init
vmxml.os = vm_os
# Generate emulator
emulator = Emulator()
emulator.path = emulator_path
# Generate console
console = Console()
filesystem = Filesystem()
filesystem.accessmode = fs_accessmode
filesystem.source = {'dir': install_root}
filesystem.target = {'dir': fs_target}
# Add emulator and console in devices
devices = vm_xml.VMXMLDevices()
devices.append(emulator)
devices.append(console)
devices.append(filesystem)
# Add network device
network = Interface(type_name=interface_type)
network.mac_address = utils_net.generate_mac_address_simple()
network.source = {interface_type: net_name}
devices.append(network)
vmxml.set_devices(devices)
return vmxml
def check_state(expected_state):
result = virsh.domstate(vm_name, uri=uri)
utlv.check_exit_status(result)
vm_state = result.stdout.strip()
if vm_state == expected_state:
logging.info("Get expected state: %s", vm_state)
else:
raise TestFail("Get unexpected state: %s", vm_state)
virsh_args = {'uri': uri, 'debug': True}
try:
vmxml = generate_container_xml()
with open(vmxml.xml, 'r') as f:
logging.info("Container XML:\n%s", f.read())
if full_os:
if not os.path.exists(install_root):
os.mkdir(install_root)
# Install core os under installroot
cmd = "yum --releasever=/ --installroot=%s" % install_root
cmd += " --nogpgcheck -y groupinstall core"
process.run(cmd, shell=True)
# Fix root login on console
process.run("echo 'pts/0' >> %s/etc/securetty" % install_root,
shell=True)
for i in ["session required pam_selinux.so close",
"session required pam_selinux.so open",
"session required pam_loginuid.so"]:
process.run('sed -i s/"%s\"/"#%s"/g %s/etc/pam.d/login' %
(i, i, install_root), shell=True)
# Fix root login for sshd
process.run('sed -i s/"%s\"/"#%s"/g %s/etc/pam.d/sshd' %
(i, i, install_root), shell=True)
# Config basic network
net_file = install_root + '/etc/sysconfig/network'
with open(net_file, 'w') as f:
f.write('NETWORKING=yes\nHOSTNAME=%s\n' % vm_name)
net_script = install_root + '/etc/sysconfig/network-scripts/ifcfg-eth0'
with open(net_script, 'w') as f:
f.write('DEVICE=eth0\nBOOTPROTO=dhcp\nONBOOT=yes\n')
# Set root password and enable sshd
session = aexpect.ShellSession("chroot %s" % install_root)
session.sendline('echo %s|passwd root --stdin' % passwd)
session.sendline('chkconfig sshd on')
session.close()
# Create
result = virsh.create(vmxml.xml, **virsh_args)
utlv.check_exit_status(result)
check_state('running')
# Destroy
result = virsh.destroy(vm_name, **virsh_args)
utlv.check_exit_status(result)
if not virsh.domain_exists(vm_name, **virsh_args):
logging.info("Destroy transient LXC domain successfully")
else:
raise TestFail("Transient LXC domain still exist after destroy")
# Define
result = virsh.define(vmxml.xml, **virsh_args)
utlv.check_exit_status(result)
check_state('shut off')
# List
result = virsh.dom_list('--inactive', **virsh_args)
utlv.check_exit_status(result)
if re.findall("(%s)\s+shut off" % vm_name, result.stdout):
logging.info("Find %s in virsh list output", vm_name)
else:
raise TestFail("Not find %s in virsh list output")
# Dumpxml
result = virsh.dumpxml(vm_name, uri=uri, debug=False)
utlv.check_exit_status(result)
# Edit
edit_vcpu = '2'
logging.info("Change vcpu of LXC container to %s", edit_vcpu)
edit_cmd = [r":%s /[0-9]*<\/vcpu>/" + edit_vcpu + r"<\/vcpu>"]
if not utlv.exec_virsh_edit(vm_name, edit_cmd, connect_uri=uri):
raise TestFail("Run edit command fail")
else:
result = virsh.dumpxml(vm_name, **virsh_args)
new_vcpu = re.search(r'(\d*)</vcpu>', result.stdout).group(1)
if new_vcpu == edit_vcpu:
logging.info("vcpu number is expected after do edit")
else:
raise TestFail("vcpu number is unexpected after do edit")
# Start
result = virsh.start(vm_name, **virsh_args)
utlv.check_exit_status(result)
check_state('running')
# Suspend
result = virsh.suspend(vm_name, **virsh_args)
utlv.check_exit_status(result)
check_state('paused')
# Resume
result = virsh.resume(vm_name, **virsh_args)
utlv.check_exit_status(result)
check_state('running')
# Reboot(not supported on RHEL6)
result = virsh.reboot(vm_name, **virsh_args)
supported_err = 'not supported by the connection driver: virDomainReboot'
if supported_err in result.stderr.strip():
logging.info("Reboot is not supported")
else:
utlv.check_exit_status(result)
# Destroy
result = virsh.destroy(vm_name, **virsh_args)
utlv.check_exit_status(result)
check_state('shut off')
# Undefine
result = virsh.undefine(vm_name, **virsh_args)
utlv.check_exit_status(result)
if not virsh.domain_exists(vm_name, **virsh_args):
logging.info("Undefine LXC domain successfully")
else:
raise TestFail("LXC domain still exist after undefine")
finally:
virsh.remove_domain(vm_name, **virsh_args)
if full_os and os.path.exists(install_root):
shutil.rmtree(install_root)
def run(test, params, env):
"""
Test command: virsh rename.
The command can rename a domain.
1.Prepare test environment.
2.Perform virsh rename operation.
3.Recover test environment.
4.Confirm the test result.
"""
# Get specific parameter value
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
domuuid = vm.get_uuid()
vm_ref = params.get("domrename_vm_ref", "name")
status_error = "yes" == params.get("status_error", "no")
new_name = params.get("vm_new_name", "new")
vm_state = params.get("domrename_vm_state", "shutoff")
domain_option = params.get("dom_opt", "")
new_name_option = params.get("newname_opt", "")
# Create object instance for renamed domain
new_vm = libvirt_vm.VM(new_name, vm.params, vm.root_dir, vm.address_cache)
# Replace the varaiables
if vm_ref == "name":
vm_ref = vm_name
else:
vm_ref = domuuid
# Build input params
dom_param = ' '.join([domain_option, vm_ref])
new_name_param = ' '.join([new_name_option, new_name])
# Backup for recovery.
vmxml_backup = libvirt_xml.vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
try:
result = virsh.domrename(dom_param, new_name_param, ignore_status=True, debug=True)
# Raise unexpected pass or fail
libvirt.check_exit_status(result, status_error)
# Return expected failure for negative tests
if status_error:
logging.debug("Expected failure: %s", result.stderr)
return
# Checkpoints after domrename succeed
else:
list_ret = virsh.dom_list("--name --all", debug=True).stdout.strip()
domname_ret = virsh.domname(domuuid, debug=True).stdout.strip()
if list_ret != new_name:
test.fail("New name does not affect in virsh list")
if domname_ret != new_name:
test.fail("New domain name does not affect in virsh domname uuid")
# Try to start vm with the new name
new_vm.start()
finally:
# Restore VM
if new_vm.exists():
if new_vm.is_alive():
new_vm.destroy(gracefully=False)
new_vm.undefine()
vmxml_backup.sync()
if remote_ref == "remote":
if remote_ip.count("EXAMPLE.COM") or local_ip.count("EXAMPLE.COM"):
raise exceptions.TestSkipError(
"Remote test parameters unchanged from default")
logging.info("Execute virsh command on remote host %s.", remote_ip)
status, output = list_local_domains_on_remote(
options_ref, remote_ip, remote_pwd, local_ip, remote_user,
local_user, local_pwd)
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()
except Exception, output:
status = True
logging.error("Exception: %s" % output)
finally:
# Recover libvirtd service status
if libvirtd == "off":
utils_libvirtd.libvirtd_start()
# Recover of domain
if vm_ref == "transient" or list_ref == "--title":
def run(test, params, env):
"""
Test command: virsh reboot.
Run a reboot command in the target domain.
1.Prepare test environment.
2.When the libvirtd == "off", stop the libvirtd service.
3.Perform virsh reboot operation.
4.Recover test environment.(libvirts service)
5.Confirm the test result.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
# run test case
libvirtd = params.get("libvirtd", "on")
vm_ref = params.get("reboot_vm_ref")
status_error = ("yes" == params.get("status_error"))
extra = params.get("reboot_extra")
remote_ip = params.get("remote_ip", "REMOTE.EXAMPLE.COM")
local_ip = params.get("local_ip", "LOCAL.EXAMPLE.COM")
remote_pwd = params.get("remote_pwd", "password")
agent = ("yes" == params.get("reboot_agent", "no"))
mode = params.get("reboot_mode", "")
pre_domian_status = params.get("reboot_pre_domian_status", "running")
xml_backup = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
try:
# Add or remove qemu-agent from guest before test
if agent:
vm_xml.VMXML.set_agent_channel(vm_name)
else:
vm_xml.VMXML.remove_agent_channel(vm_name)
virsh.start(vm_name)
guest_session = vm.wait_for_login()
if agent:
guest_session.cmd("qemu-ga -d")
stat_ps = guest_session.cmd_status("ps aux |grep [q]emu-ga")
guest_session.close()
if stat_ps:
raise error.TestError("Fail to start qemu-guest-agent!")
if pre_domian_status == "shutoff":
virsh.destroy(vm_name)
if libvirtd == "off":
utils_libvirtd.libvirtd_stop()
domid = vm.get_id()
domuuid = vm.get_uuid()
if vm_ref == "id":
vm_ref = domid
elif vm_ref == "name":
vm_ref = vm_name
elif vm_ref == "uuid":
vm_ref = domuuid
elif vm_ref == "hex_id":
vm_ref = hex(int(domid))
elif vm_ref.find("invalid") != -1:
vm_ref = params.get(vm_ref)
elif vm_ref == "remote_name":
if remote_ip.count("EXAMPLE.COM") or local_ip.count("EXAMPLE.COM"):
raise error.TestNAError("remote_ip and/or local_ip parameters"
" not changed from default values")
complete_uri = libvirt_vm.complete_uri(local_ip)
try:
session = remote.remote_login("ssh", remote_ip, "22", "root",
remote_pwd, "#")
session.cmd_output('LANG=C')
command = "virsh -c %s reboot %s %s" % (complete_uri, vm_name,
mode)
status, output = session.cmd_status_output(command,
internal_timeout=5)
session.close()
# FIXME: Catch specific exception
except Exception, detail:
logging.error("Exception: %s", str(detail))
status = -1
if vm_ref != "remote_name":
vm_ref = "%s %s" % (vm_ref, extra)
cmdresult = virsh.reboot(vm_ref,
mode,
ignore_status=True,
debug=True)
status = cmdresult.exit_status
if status:
logging.debug("Error status, cmd error: %s", cmdresult.stderr)
if not virsh.has_command_help_match('reboot', '\s+--mode\s+'):
# old libvirt doesn't support reboot
status = -2
output = virsh.dom_list(ignore_status=True).stdout.strip()
# recover libvirtd service start
if libvirtd == "off":
utils_libvirtd.libvirtd_start()
# check status_error
if status_error:
if not status:
raise error.TestFail("Run successfully with wrong command!")
else:
if status or (not re.search(vm_name, output)):
if status == -2:
raise error.TestNAError(
"Reboot command doesn't work on older libvirt versions"
)
raise error.TestFail("Run failed with right command")
def run(test, params, env):
"""
Test pure checkpoint commands
"""
def prepare_checkpoints(disk="vdb", num=1, cp_prefix="test_checkpoint_"):
"""
Create checkpoints for specific disk
:param disk: The disk to create checkpoint.
:param num: How many checkpoints to be created
:param cp_prefix: The prefix to name the checkpoint.
"""
option_pattern = ("{0} --diskspec vda,checkpoint=no "
"--diskspec {1},checkpoint=bitmap,bitmap={0}")
for i in range(num):
# create checkpoints
checkpoint_name = cp_prefix + str(i)
options = option_pattern.format(checkpoint_name, disk)
virsh.checkpoint_create_as(vm_name, options, **virsh_dargs)
current_checkpoints.append(checkpoint_name)
# Cancel the test if libvirt version is too low
if not libvirt_version.version_compare(6, 0, 0):
test.cancel("Current libvirt version doesn't support "
"incremental backup.")
checkpoint_cmd = params.get("checkpoint_cmd")
cmd_flag = params.get("flag")
required_checkpoints = int(params.get("required_checkpoints", 0))
test_disk_size = params.get("test_disk_size", "100M")
test_disk_target = params.get("test_disk_target", "vdb")
status_error = "yes" == params.get("status_error")
tmp_dir = data_dir.get_tmp_dir()
current_checkpoints = []
virsh_dargs = {'debug': True, 'ignore_status': False}
try:
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
# Make sure there is no checkpoint metadata before test
utils_backup.clean_checkpoints(vm_name)
# Backup vm xml
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
vmxml_backup = vmxml.copy()
utils_backup.enable_inc_backup_for_vm(vm)
if vm.is_alive():
vm.destroy(gracefully=False)
# Prepare the disk to be used.
disk_params = {}
disk_path = ""
image_name = "{}_image.qcow2".format(test_disk_target)
disk_path = os.path.join(tmp_dir, image_name)
libvirt.create_local_disk("file", disk_path, test_disk_size,
"qcow2")
disk_params = {"device_type": "disk",
"type_name": "file",
"driver_type": "qcow2",
"target_dev": test_disk_target,
"source_file": disk_path}
disk_xml = libvirt.create_disk_xml(disk_params)
virsh.attach_device(vm.name, disk_xml,
flagstr="--config", **virsh_dargs)
vm.start()
session = vm.wait_for_login()
new_disks_in_vm = list(utils_disk.get_linux_disks(session).keys())
session.close()
if required_checkpoints > 0:
prepare_checkpoints(test_disk_target, required_checkpoints)
if checkpoint_cmd == "checkpoint-create":
if not current_checkpoints:
test.fail("No existing checkpoints prepared.")
if "--redefine" in cmd_flag:
no_domain = "yes" == params.get("no_domain")
extra_flag = params.get("extra_flag")
image_with_bitmap = "yes" == params.get("image_with_bitmap")
cp_dumpxml_options = ""
if no_domain:
cp_dumpxml_options = "--no-domain"
if libvirt_version.version_compare(6, 6, 0):
# libvirt-6.6.0-9.el8 starts to allow redefine VM
# backup checkpoint without the domain XML (bz1901830)
status_error = False
checkpoint_redef = current_checkpoints[0]
cp_xml = checkpoint_xml.CheckpointXML.new_from_checkpoint_dumpxml(
vm_name, checkpoint_redef, cp_dumpxml_options)
logging.debug("Checkpoint XML to be redefined is: %s", cp_xml)
xml_file = cp_xml.xml
virsh.checkpoint_delete(vm_name, checkpoint_redef,
"--metadata", **virsh_dargs)
cmd_options = xml_file + " " + cmd_flag
if extra_flag:
cmd_options += " " + extra_flag
if "--redefine-validate" in extra_flag:
if not libvirt_version.version_compare(6, 6, 0):
test.cancel("--redefine-validate not supported in "
"current libvirt versoin.")
if not image_with_bitmap:
status_error = True
# replace vdb's image with a new qcow2 file to make sure
# the image has no block dirty bitmap anymore
vm.destroy(gracefully=False)
libvirt.create_local_disk("file", disk_path,
test_disk_size, "qcow2")
vm.start()
vm.wait_for_login().close()
result = virsh.checkpoint_create(vm_name, cmd_options, debug=True)
libvirt.check_exit_status(result, status_error)
elif checkpoint_cmd == "checkpoint-create-as":
if "--print-xml" in cmd_flag:
checkpoint_name = "test_checkpoint_0"
options = ("{0} --diskspec vda,checkpoint=no --diskspec {1},"
"checkpoint=bitmap,bitmap={0} "
"--print-xml".format(checkpoint_name, test_disk_target))
virsh.checkpoint_create_as(vm_name, options, **virsh_dargs)
# The checkpiont should not be created, so we have following check
cp_list_result = virsh.checkpoint_list(vm_name, checkpoint_name, debug=True)
libvirt.check_exit_status(cp_list_result, True)
elif checkpoint_cmd == "checkpoint-info":
if len(current_checkpoints) != 3:
test.fail("We should prepare 3 checkpoints.")
parent_checkpoint = current_checkpoints[0]
test_checkpoint = current_checkpoints[1]
stdout = virsh.checkpoint_info(vm_name, test_checkpoint,
**virsh_dargs).stdout_text.strip()
if (
not re.search("domain.*%s" % vm_name, stdout, re.IGNORECASE) or
not re.search("parent.*%s" % parent_checkpoint, stdout, re.IGNORECASE) or
not re.search("children.*1", stdout, re.IGNORECASE) or
not re.search("descendants.*1", stdout, re.IGNORECASE)
):
test.fail("checkpoint-info return inaccurate informaion: %s" % stdout)
elif checkpoint_cmd == "checkpoint-list":
logic_error = False
if not cmd_flag:
stdout = virsh.checkpoint_list(vm_name,
**virsh_dargs).stdout_text.strip()
for checkpoint in current_checkpoints:
if checkpoint not in stdout:
logic_error = True
elif cmd_flag == "--parent":
stdout = virsh.checkpoint_list(vm_name, cmd_flag,
**virsh_dargs).stdout_text.strip()
for checkpoint in current_checkpoints:
if checkpoint == current_checkpoints[-1]:
if stdout.count(checkpoint) != 1:
logic_error = True
else:
if stdout.count(checkpoint) != 2:
logic_error = True
elif cmd_flag == "--roots":
stdout = virsh.checkpoint_list(vm_name, cmd_flag,
**virsh_dargs).stdout_text.strip()
for checkpoint in current_checkpoints:
if checkpoint == current_checkpoints[0]:
if stdout.count(checkpoint) != 1:
logic_eror = True
else:
if stdout.count(checkpoint) != 0:
logic_error = True
elif cmd_flag == "--tree":
stdout = virsh.checkpoint_list(vm_name, cmd_flag,
**virsh_dargs).stdout_text.strip()
lines = stdout.splitlines()
prev_indent_num = -1
for line in lines:
for checkpoint in current_checkpoints:
if checkpoint in line:
cur_indent_num = line.rstrip().count(" ")
if cur_indent_num <= prev_indent_num:
logic_error = True
break
prev_indent_num = cur_indent_num
elif cmd_flag == "--name":
stdout = virsh.checkpoint_list(vm_name, cmd_flag,
**virsh_dargs).stdout_text.strip()
checkpoint_names = stdout.splitlines()
if not operator.eq(checkpoint_names, current_checkpoints):
logic_error = True
elif cmd_flag == "--topological":
stdout = virsh.checkpoint_list(vm_name, cmd_flag,
**virsh_dargs).stdout_text.strip()
for checkpoint in current_checkpoints:
if checkpoint not in stdout:
logical_error = True
elif cmd_flag == "--from":
cmd_options = cmd_flag + " " + current_checkpoints[0]
stdout = virsh.checkpoint_list(vm_name, cmd_options,
**virsh_dargs).stdout_text.strip()
if (current_checkpoints[0] in stdout
or current_checkpoints[2] in stdout
or current_checkpoints[1] not in stdout):
logic_error = True
elif cmd_flag == "--descendants":
cmd_options = cmd_flag + " " + current_checkpoints[0]
stdout = virsh.checkpoint_list(vm_name, cmd_options,
**virsh_dargs).stdout_text.strip()
if (current_checkpoints[0] in stdout
or current_checkpoints[1] not in stdout
or current_checkpoints[2] not in stdout):
logic_error = True
elif cmd_flag == "--no-leaves":
stdout = virsh.checkpoint_list(vm_name, cmd_flag,
**virsh_dargs).stdout_text.strip()
if (current_checkpoints[0] not in stdout
or current_checkpoints[1] not in stdout
or current_checkpoints[2] in stdout):
logic_error = True
elif cmd_flag == "--leaves":
stdout = virsh.checkpoint_list(vm_name, cmd_flag,
**virsh_dargs).stdout_text.strip()
if (current_checkpoints[0] in stdout
or current_checkpoints[1] in stdout
or current_checkpoints[2] not in stdout):
logic_error = True
if logic_error:
test.fail("checkpoint-list with '%s' gives wrong output"
% cmd_flag)
elif checkpoint_cmd == "checkpoint-dumpxml":
if "--size" in cmd_flag:
if not libvirt_version.version_compare(6, 6, 0):
test.cancel("Current libvirt version doesn't support "
"'--size' for 'checkpoint-dumpxml'.")
test_disk = new_disks_in_vm[-1]
test_disk_path = "/dev/" + test_disk
test_checkpoint = current_checkpoints[-1]
dd_count = 1
dd_bs = "1M"
dd_seek = "10"
dd_size = dd_count * 1024 * 1024
session = vm.wait_for_login()
utils_disk.dd_data_to_vm_disk(session, test_disk_path,
bs=dd_bs, seek=dd_seek,
count=str(dd_count))
session.close()
stdout = virsh.checkpoint_dumpxml(vm_name,
test_checkpoint + " --size",
**virsh_dargs).stdout_text.strip()
re_pattern = ".*%s.*%s.*size.*" % (test_disk, test_checkpoint)
size_info_line = re.search(re_pattern, stdout)
if not size_info_line:
test.fail("There is no size info for disk:%s checkpoint:%s"
% (test_disk, test_checkpoint))
if str(dd_size) not in size_info_line.group(0):
test.fail("Size info incorrect in checkpoint xml, "
"'dd_size' is %s, size info in xml is:%s"
% (dd_size, size_info_line.group(0)))
elif "--security-info" in cmd_flag:
if vm.is_alive():
vm.destroy(gracefully=False)
password = "******"
vm_xml.VMXML.set_graphics_attr(vm_name, {'passwd': password})
vm.start()
vm.wait_for_login().close()
prepare_checkpoints()
test_checkpoint = current_checkpoints[0]
stdout = virsh.checkpoint_dumpxml(vm_name,
test_checkpoint,
**virsh_dargs).stdout_text.strip()
if password in stdout:
logging.debug("checkpoint xml is: %s", stdout)
test.fail("Security info displayed in unsecurity dumpxml.")
stdout = virsh.checkpoint_dumpxml(vm_name,
test_checkpoint + " --security-info",
**virsh_dargs).stdout_text.strip()
if password not in stdout:
logging.debug("checkpoint xml is: %s", stdout)
test.fail("Security info not displayed in security dumpxml.")
elif checkpoint_cmd == "virsh_list":
stdout = virsh.dom_list(cmd_flag, **virsh_dargs).stdout_text.strip()
if ((vm_name in stdout and cmd_flag == "--without-checkpoint") or
(vm_name not in stdout and cmd_flag == "--with-checkpoint")):
test.fail("virsh list with '%s' contains wrong data" % cmd_flag)
# Make sure vm is running and check checkpoints can be normally deleted
if not vm.is_alive():
vm.start()
vm.wait_for_login().close()
utils_backup.clean_checkpoints(vm_name, clean_metadata=False,
ignore_status=False)
finally:
# Remove checkpoints
utils_backup.clean_checkpoints(vm_name,
clean_metadata=not vm.is_alive())
if vm.is_alive():
vm.destroy(gracefully=False)
# Restoring vm
vmxml_backup.sync()
# Remove test image
if "disk_path" in locals():
if os.path.exists(disk_path):
os.remove(disk_path)
def run(test, params, env):
"""
Test command: virsh rename.
The command can rename a domain.
1.Prepare test environment.
2.Perform virsh rename operation.
3.Recover test environment.
4.Confirm the test result.
"""
# Get specific parameter value
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
domuuid = vm.get_uuid()
vm_ref = params.get("domrename_vm_ref", "name")
status_error = "yes" == params.get("status_error", "no")
new_name = params.get("vm_new_name", "new")
pre_vm_state = params.get("domrename_vm_state", "shutoff")
domain_option = params.get("dom_opt", "")
new_name_option = params.get("newname_opt", "")
add_vm = "yes" == params.get("add_vm", "no")
# Replace the varaiables
if vm_ref == "name":
vm_ref = vm_name
elif vm_ref == "uuid":
vm_ref = domuuid
if new_name == "vm2_name":
vm2_name = ("%s" % vm_name[:-1])+"2"
new_name = vm2_name
# Build input params
dom_param = ' '.join([domain_option, vm_ref])
new_name_param = ' '.join([new_name_option, new_name])
# Backup for recovery.
vmxml_backup = libvirt_xml.vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
logging.debug("vm xml is %s", vmxml_backup)
# Clone additional vms if needed
if add_vm:
try:
utils_path.find_command("virt-clone")
except utils_path.CmdNotFoundError:
if not utils_package.package_install(["virt-install"]):
test.cancel("Failed to install virt-install on host")
ret_clone = utils_libguestfs.virt_clone_cmd(vm_name, vm2_name,
True, timeout=360)
if ret_clone.exit_status:
test.fail("Error occured when clone a second vm!")
vm2 = libvirt_vm.VM(vm2_name, vm.params, vm.root_dir, vm.address_cache)
virsh.dom_list("--name --all", debug=True)
# Create object instance for renamed domain
new_vm = libvirt_vm.VM(new_name, vm.params, vm.root_dir, vm.address_cache)
# Prepare vm state
if pre_vm_state != "shutoff":
vm.start()
if pre_vm_state == "paused":
vm.pause()
logging.debug("Domain state is now: %s", vm.state())
elif pre_vm_state == "managed_saved":
vm.managedsave()
elif pre_vm_state == "with_snapshot":
virsh.snapshot_create_as(vm_name, "snap1 --disk-only", debug=True)
vm.destroy(gracefully=False)
try:
result = virsh.domrename(dom_param, new_name_param, ignore_status=True, debug=True)
# Raise unexpected pass or fail
libvirt.check_exit_status(result, status_error)
# Return expected failure for negative tests
if status_error:
logging.debug("Expected failure: %s", result.stderr)
return
# Checkpoints after domrename succeed
else:
list_ret = virsh.dom_list("--name --all", debug=True).stdout
domname_ret = virsh.domname(domuuid, debug=True).stdout.strip()
if new_name not in list_ret or vm_name in list_ret:
test.fail("New name does not affect in virsh list")
if domname_ret != new_name:
test.fail("New domain name does not affect in virsh domname uuid")
# Try to start vm with the new name
new_vm.start()
finally:
# Remove additional vms
if add_vm and vm2.exists() and result.exit_status:
virsh.remove_domain(vm2_name, "--remove-all-storage")
# Undefine newly renamed domain
if new_vm.exists():
if new_vm.is_alive():
new_vm.destroy(gracefully=False)
new_vm.undefine()
# Recover domain state
if pre_vm_state != "shutoff":
if pre_vm_state == "with_snapshot":
libvirt.clean_up_snapshots(vm_name)
else:
if pre_vm_state == "managed_saved":
vm.start()
vm.destroy(gracefully=False)
# Restore VM
vmxml_backup.sync()
def run(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, remote_user, local_user,
local_pwd):
"""
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.
"""
complete_uri = libvirt_vm.complete_uri(local_ip)
command_on_remote = ("virsh -c %s list %s"
% (complete_uri, options_ref))
try:
# setup autologin for ssh from remote machine to execute commands
# remotely
config_opt = ["StrictHostKeyChecking=no"]
ssh_key.setup_remote_ssh_key(remote_ip, remote_user,
remote_passwd, hostname2=local_ip,
user2=local_user,
password2=local_pwd,
config_options=config_opt)
session = remote.remote_login("ssh", remote_ip, "22", remote_user,
remote_passwd, "#")
time.sleep(5)
status, output = session.cmd_status_output(
command_on_remote, internal_timeout=30)
except Exception as info:
logging.error("Shell failed to execute command from"
" remote")
return 1, info
time.sleep(5)
session.close()
return int(status), output
vm_name = params.get("main_vm", "avocado-vt-vm1")
options_ref = params.get("list_options_ref", "")
list_ref = params.get("list_type_ref", "")
vm_ref = params.get("vm_ref", "")
status_error = params.get("status_error", "no")
addition_status_error = params.get("addition_status_error", "no")
desc = params.get("list_desc", "")
libvirtd = params.get("libvirtd", "on")
remote_ref = params.get("remote_ref", "")
remote_ip = params.get("remote_ip")
remote_pwd = params.get("remote_pwd", None)
local_ip = params.get("local_ip")
remote_user = params.get("remote_user", "root")
local_user = params.get("username", "root")
local_pwd = params.get("local_pwd", None)
vm = env.get_vm(vm_name)
domuuid = vm.get_uuid()
domid = vm.get_id()
# Some parameters are not supported on old libvirt, skip them.
help_info = virsh.help("list").stdout.strip()
if vm_ref and not re.search(vm_ref, help_info):
raise exceptions.TestSkipError("This version do not support vm type:%s"
% vm_ref)
if list_ref and not re.search(list_ref, help_info):
raise exceptions.TestSkipError("This version do not support list"
" type:%s" % list_ref)
# 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":
vm_backup = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
vm.undefine()
elif vm_ref == "managed-save":
virsh.managedsave(vm_name, ignore_status=True, print_info=True)
try:
# run test case
if list_ref == "--uuid":
result_expected = domuuid
logging.info("%s's uuid is: %s", vm_name, domuuid)
elif list_ref == "--title":
vm_backup = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
if options_ref == "inactive":
virsh.desc(vm_name, "--config --title", desc)
else:
virsh.desc(vm_name, "--live --title", desc)
result_expected = desc
logging.info("%s's title is: %s", vm_name, desc)
else:
result_expected = vm_name
logging.info("domain's name is: %s", vm_name)
if options_ref == "vm_id":
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
# Prepare libvirtd status
if libvirtd == "off":
utils_libvirtd.libvirtd_stop()
if remote_ref == "remote":
if remote_ip.count("EXAMPLE.COM") or local_ip.count("EXAMPLE.COM"):
raise exceptions.TestSkipError(
"Remote test parameters unchanged from default")
logging.info("Execute virsh command on remote host %s.", remote_ip)
status, output = list_local_domains_on_remote(options_ref,
remote_ip,
remote_pwd,
local_ip,
remote_user,
local_user,
local_pwd)
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()
except Exception as output:
status = True
logging.error("Exception: %s" % output)
finally:
# Recover libvirtd service status
if libvirtd == "off":
utils_libvirtd.libvirtd_start()
# Recover of domain
if vm_ref == "transient" or list_ref == "--title":
vm_backup.sync()
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 not status and re.search(result_expected, output):
raise exceptions.TestFail("Run successful with wrong command!")
else:
if status:
raise exceptions.TestFail("Run failed with right command.")
if not re.search(result_expected, output):
raise exceptions.TestFail("Run successful but result is not"
" expected.")
def run(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, remote_user, local_user,
local_pwd):
"""
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.
"""
complete_uri = libvirt_vm.complete_uri(local_ip)
command_on_remote = ("virsh -c %s list %s"
% (complete_uri, options_ref))
try:
# setup autologin for ssh from remote machine to execute commands
# remotely
config_opt = ["StrictHostKeyChecking=no"]
ssh_key.setup_remote_ssh_key(remote_ip, remote_user,
remote_passwd, hostname2=local_ip,
user2=local_user,
password2=local_pwd,
config_options=config_opt)
session = remote.remote_login("ssh", remote_ip, "22", remote_user,
remote_passwd, "#")
time.sleep(5)
status, output = session.cmd_status_output(
command_on_remote, internal_timeout=30)
except Exception as info:
logging.error("Shell failed to execute command from"
" remote")
return 1, info
time.sleep(5)
session.close()
return int(status), output
vm_name = params.get("main_vm", "avocado-vt-vm1")
options_ref = params.get("list_options_ref", "")
list_ref = params.get("list_type_ref", "")
vm_ref = params.get("vm_ref", "")
status_error = params.get("status_error", "no")
addition_status_error = params.get("addition_status_error", "no")
desc = params.get("list_desc", "")
libvirtd = params.get("libvirtd", "on")
remote_ref = params.get("remote_ref", "")
remote_ip = params.get("remote_ip")
remote_pwd = params.get("remote_pwd", None)
local_ip = params.get("local_ip")
remote_user = params.get("remote_user", "root")
local_user = params.get("username", "root")
local_pwd = params.get("local_pwd", None)
vm = env.get_vm(vm_name)
domuuid = vm.get_uuid()
domid = vm.get_id()
# Some parameters are not supported on old libvirt, skip them.
help_info = virsh.help("list").stdout.strip()
if vm_ref and not re.search(vm_ref, help_info):
raise exceptions.TestSkipError("This version do not support vm type:%s"
% vm_ref)
if list_ref and not re.search(list_ref, help_info):
raise exceptions.TestSkipError("This version do not support list"
" type:%s" % list_ref)
# 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":
vm_backup = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
vm.undefine()
elif vm_ref == "managed-save":
virsh.managedsave(vm_name, ignore_status=True, print_info=True)
try:
# run test case
if list_ref == "--uuid":
result_expected = domuuid
logging.info("%s's uuid is: %s", vm_name, domuuid)
elif list_ref == "--title":
vm_backup = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
if options_ref == "inactive":
virsh.desc(vm_name, "--config --title", desc)
else:
virsh.desc(vm_name, "--live --title", desc)
result_expected = desc
logging.info("%s's title is: %s", vm_name, desc)
else:
result_expected = vm_name
logging.info("domain's name is: %s", vm_name)
if options_ref == "vm_id":
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
# Prepare libvirtd status
if libvirtd == "off":
utils_libvirtd.libvirtd_stop()
if remote_ref == "remote":
if remote_ip.count("EXAMPLE.COM") or local_ip.count("EXAMPLE.COM"):
raise exceptions.TestSkipError(
"Remote test parameters unchanged from default")
logging.info("Execute virsh command on remote host %s.", remote_ip)
status, output = list_local_domains_on_remote(options_ref,
remote_ip,
remote_pwd,
local_ip,
remote_user,
local_user,
local_pwd)
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()
except Exception as output:
status = True
logging.error("Exception: %s" % output)
finally:
# Recover libvirtd service status
if libvirtd == "off":
utils_libvirtd.libvirtd_start()
# Recover of domain
if vm_ref == "transient" or list_ref == "--title":
vm_backup.sync()
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 not status and re.search(result_expected, output):
raise exceptions.TestFail("Run successful with wrong command!")
else:
if status:
raise exceptions.TestFail("Run failed with right command.")
if not re.search(result_expected, output):
raise exceptions.TestFail("Run successful but result is not"
" expected.")
def run(test, params, env):
"""
Start libvirt daemon with different options.
Check socket files.
"""
log = []
def _logger(line):
"""
Callback function to log libvirtd output.
"""
log.append(line)
def check_help(params):
"""
Check whether the output is help and meets expectation
"""
expected_help = params.get('expected_help', 'no') == 'yes'
is_help = any(line.startswith('Usage:') for line in log)
if expected_help != is_help:
raise error.TestFail(
'Expected output help is %s, but get output:\n%s' %
(expected_help, '\n'.join(log)))
def check_version(params):
"""
Check whether the output is libvirtd version.
"""
expected_version = params.get('expected_version', 'no') == 'yes'
is_version = log[0].startswith('libvirtd (libvirt)')
if expected_version != is_version:
raise error.TestFail(
'Expected output version is %s, but get output:\n%s' %
(expected_version, '\n'.join(log)))
def check_unix_socket_files():
"""
Check whether the socket file exists.
"""
rw_sock_path = '/var/run/libvirt/libvirt-sock'
ro_sock_path = '/var/run/libvirt/libvirt-sock-ro'
if libvirtd.running:
if not os.path.exists(rw_sock_path):
raise error.TestFail('RW unix socket file not found at %s' %
rw_sock_path)
if not os.path.exists(ro_sock_path):
raise error.TestFail('RO unix socket file not found at %s' %
ro_sock_path)
else:
if os.path.exists(rw_sock_path) or os.path.exists(ro_sock_path):
raise error.TestFail('Expect unix socket file do not exists '
'when libvirtd is stopped')
def check_pid_file():
"""
Check whether the pid file exists.
"""
if not os.path.exists(pid_path):
raise error.TestFail("PID file not found at %s" % pid_path)
pid_file = open(pid_path)
pid = int(pid_file.readline())
pid_file.close()
result = utils.run('pgrep libvirtd', ignore_status=True)
expected_pid = int(result.stdout.split()[0])
if pid != expected_pid:
raise error.TestFail("PID file content mismatch. Expected %s "
"but got %s" % (expected_pid, pid))
def check_config_file():
"""
Check whether the config file take effects by checking UUID.
"""
cur_uuid = capability_xml.CapabilityXML()['uuid']
if cur_uuid != check_uuid:
raise error.TestFail('Expected host UUID is %s, but got %s' %
(check_uuid, cur_uuid))
MAX_TIMEOUT = 10
arg_str = params.get("libvirtd_arg", "")
time_tolerance = float(params.get("exit_time_tolerance", 1))
expected_exit_time = float(params.get("expected_exit_time", 'inf'))
config_path = params.get('expected_config_path', "")
pid_path = params.get('expected_pid_path', "")
if expected_exit_time == float('inf'):
timeout = MAX_TIMEOUT
else:
if expected_exit_time > 0:
if len(virsh.dom_list('--name').stdout.strip().splitlines()):
raise error.TestNAError('Timeout option will be ignore if '
'there exists living domain')
timeout = expected_exit_time + time_tolerance
libvirtd = LibvirtdSession(
logging_handler=_logger,
)
# Setup config file.
check_uuid = '13371337-1337-1337-1337-133713371337'
if config_path:
open(config_path, 'a').close()
config = utils_config.LibvirtdConfig(config_path)
config.host_uuid = check_uuid
try:
check_unix_socket_files()
libvirtd.start(arg_str=arg_str, wait_for_working=False)
start = time.time()
libvirtd_exited = libvirtd.wait_for_stop(timeout=timeout, step=0.1)
wait_time = time.time() - start
if log:
logging.debug("Libvirtd log:")
for line in log:
logging.debug(line)
check_help(params)
check_version(params)
if libvirtd_exited:
if expected_exit_time == float('inf'):
raise error.TestFail("Expected never stop, but ran %ss" % wait_time)
elif wait_time < expected_exit_time - time_tolerance:
raise error.TestFail("Expected exit in %ss(+-%ss), but ran %ss" %
(expected_exit_time, time_tolerance, wait_time))
else:
if expected_exit_time != float('inf'):
raise error.TestFail("Expected exit in %ss(+-%ss), but ran timeout in %ss" %
(expected_exit_time, time_tolerance, wait_time))
check_unix_socket_files()
if config_path:
check_config_file()
if pid_path:
check_pid_file()
finally:
libvirtd.exit()
# Clean up config file
if config_path:
config.restore()
if os.path.exists(config_path):
os.remove(config_path)
if os.path.exists(pid_path):
os.remove(pid_path)
def run(test, params, env):
"""
Test start domain with nwfilter rules.
1) Prepare parameters.
2) Prepare nwfilter rule and update domain interface to apply.
3) Start domain and check rule.
4) Clean env
"""
# Prepare parameters
filter_name = params.get("filter_name", "testcase")
bug_url = params.get("bug_url", "")
vm_name = params.get("main_vm")
if not libvirt_version.version_compare(1, 2, 6):
test.cancel("Bug %s not fixed on current build" % bug_url)
vm = env.get_vm(vm_name)
# Prepare vm filterref parameters dict list
filterref_dict = {}
filterref_dict['name'] = filter_name
# backup vm and filter xml
vmxml_backup = libvirt_xml.VMXML.new_from_inactive_dumpxml(vm_name)
backup_filter = libvirt_xml.NwfilterXML()
filterxml = backup_filter.new_from_filter_dumpxml(filter_name)
def nwfilter_sync_loop(filter_name, filerxml):
"""
Undefine filter and redefine filter from xml in loop
"""
for i in range(2400):
virsh.nwfilter_undefine(filter_name, ignore_status=True)
time.sleep(0.1)
virsh.nwfilter_define(filterxml.xml, ignore_status=True)
def vm_start_destory_loop(vm):
"""
Start and destroy vm in loop
"""
for i in range(2400):
vm.start()
time.sleep(0.1)
vm.destroy(gracefully=False)
try:
# Update first vm interface with filter
vmxml = libvirt_xml.VMXML.new_from_inactive_dumpxml(vm_name)
iface_xml = vmxml.get_devices('interface')[0]
vmxml.del_device(iface_xml)
new_iface = interface.Interface('network')
new_iface.xml = iface_xml.xml
new_filterref = new_iface.new_filterref(**filterref_dict)
new_iface.filterref = new_filterref
logging.debug("new interface xml is: %s" % new_iface)
vmxml.add_device(new_iface)
vmxml.sync()
filter_thread = threading.Thread(target=nwfilter_sync_loop,
args=(filter_name, filterxml))
vm_thread = threading.Thread(target=vm_start_destory_loop, args=(vm, ))
filter_thread.start()
time.sleep(0.3)
vm_thread.start()
ret = utils_misc.wait_for(lambda: virsh.dom_list(debug=True),
timeout=240,
step=1)
filter_thread.join()
vm_thread.join()
if not ret:
test.fail("Libvirtd hang, %s" % bug_url)
finally:
# Clean env
if vm.is_alive():
vm.destroy(gracefully=False)
# Recover xml of vm and filter.
vmxml_backup.sync()
virsh.nwfilter_undefine(filter_name, ignore_status=True)
virsh.nwfilter_define(filterxml.xml, ignore_status=True)
def run(test, params, env):
"""
LXC container life cycle testing by virsh command
"""
uri = params.get("connect_uri", "lxc:///")
vm_name = params.get("main_vm")
dom_type = params.get("lxc_domtype", "lxc")
vcpu = int(params.get("lxc_vcpu", 1))
max_mem = int(params.get("lxc_max_mem", 500000))
current_mem = int(params.get("lxc_current_mem", 500000))
os_type = params.get("lxc_ostype", "exe")
os_arch = params.get("lxc_osarch", "x86_64")
os_init = params.get("lxc_osinit", "/bin/sh")
emulator_path = params.get("lxc_emulator", "/usr/libexec/libvirt_lxc")
interface_type = params.get("lxc_interface_type", "network")
net_name = params.get("lxc_net_name", "default")
full_os = ("yes" == params.get("lxc_full_os", "no"))
install_root = params.get("lxc_install_root", "/")
fs_target = params.get("lxc_fs_target", "/")
fs_accessmode = params.get("lxc_fs_accessmode", "passthrough")
passwd = params.get("lxc_fs_passwd", "redhat")
def generate_container_xml():
"""
Generate container xml
"""
vmxml = vm_xml.VMXML(dom_type)
vmxml.vm_name = vm_name
vmxml.max_mem = max_mem
vmxml.current_mem = current_mem
vmxml.vcpu = vcpu
# Generate os
vm_os = vm_xml.VMOSXML()
vm_os.type = os_type
vm_os.arch = os_arch
vm_os.init = os_init
vmxml.os = vm_os
# Generate emulator
emulator = Emulator()
emulator.path = emulator_path
# Generate console
console = Console()
filesystem = Filesystem()
filesystem.accessmode = fs_accessmode
filesystem.source = {'dir': install_root}
filesystem.target = {'dir': fs_target}
# Add emulator and console in devices
devices = vm_xml.VMXMLDevices()
devices.append(emulator)
devices.append(console)
devices.append(filesystem)
# Add network device
network = Interface(type_name=interface_type)
network.mac_address = utils_net.generate_mac_address_simple()
network.source = {interface_type: net_name}
devices.append(network)
vmxml.set_devices(devices)
return vmxml
def check_state(expected_state):
result = virsh.domstate(vm_name, uri=uri)
utlv.check_exit_status(result)
vm_state = result.stdout.strip()
if vm_state == expected_state:
logging.info("Get expected state: %s", vm_state)
else:
raise TestFail("Get unexpected state: %s", vm_state)
virsh_args = {'uri': uri, 'debug': True}
try:
vmxml = generate_container_xml()
with open(vmxml.xml, 'r') as f:
logging.info("Container XML:\n%s", f.read())
if full_os:
if not os.path.exists(install_root):
os.mkdir(install_root)
# Install core os under installroot
cmd = "yum --releasever=/ --installroot=%s" % install_root
cmd += " --nogpgcheck -y groupinstall core"
process.run(cmd, shell=True)
# Fix root login on console
process.run("echo 'pts/0' >> %s/etc/securetty" % install_root,
shell=True)
for i in [
"session required pam_selinux.so close",
"session required pam_selinux.so open",
"session required pam_loginuid.so"
]:
process.run('sed -i s/"%s\"/"#%s"/g %s/etc/pam.d/login' %
(i, i, install_root),
shell=True)
# Fix root login for sshd
process.run('sed -i s/"%s\"/"#%s"/g %s/etc/pam.d/sshd' %
(i, i, install_root),
shell=True)
# Config basic network
net_file = install_root + '/etc/sysconfig/network'
with open(net_file, 'w') as f:
f.write('NETWORKING=yes\nHOSTNAME=%s\n' % vm_name)
net_script = install_root + '/etc/sysconfig/network-scripts/ifcfg-eth0'
with open(net_script, 'w') as f:
f.write('DEVICE=eth0\nBOOTPROTO=dhcp\nONBOOT=yes\n')
# Set root password and enable sshd
session = aexpect.ShellSession("chroot %s" % install_root)
session.sendline('echo %s|passwd root --stdin' % passwd)
session.sendline('chkconfig sshd on')
session.close()
# Create
result = virsh.create(vmxml.xml, **virsh_args)
utlv.check_exit_status(result)
check_state('running')
# Destroy
result = virsh.destroy(vm_name, **virsh_args)
utlv.check_exit_status(result)
if not virsh.domain_exists(vm_name, **virsh_args):
logging.info("Destroy transient LXC domain successfully")
else:
raise TestFail("Transient LXC domain still exist after destroy")
# Define
result = virsh.define(vmxml.xml, **virsh_args)
utlv.check_exit_status(result)
check_state('shut off')
# List
result = virsh.dom_list('--inactive', **virsh_args)
utlv.check_exit_status(result)
if re.findall("(%s)\s+shut off" % vm_name, result.stdout):
logging.info("Find %s in virsh list output", vm_name)
else:
raise TestFail("Not find %s in virsh list output")
# Dumpxml
result = virsh.dumpxml(vm_name, uri=uri, debug=False)
utlv.check_exit_status(result)
# Edit
edit_vcpu = '2'
logging.info("Change vcpu of LXC container to %s", edit_vcpu)
edit_cmd = [r":%s /[0-9]*<\/vcpu>/" + edit_vcpu + r"<\/vcpu>"]
if not utlv.exec_virsh_edit(vm_name, edit_cmd, connect_uri=uri):
raise TestFail("Run edit command fail")
else:
result = virsh.dumpxml(vm_name, **virsh_args)
new_vcpu = re.search(r'(\d*)</vcpu>', result.stdout).group(1)
if new_vcpu == edit_vcpu:
logging.info("vcpu number is expected after do edit")
else:
raise TestFail("vcpu number is unexpected after do edit")
# Start
result = virsh.start(vm_name, **virsh_args)
utlv.check_exit_status(result)
check_state('running')
# Suspend
result = virsh.suspend(vm_name, **virsh_args)
utlv.check_exit_status(result)
check_state('paused')
# Resume
result = virsh.resume(vm_name, **virsh_args)
utlv.check_exit_status(result)
check_state('running')
# Reboot(not supported on RHEL6)
result = virsh.reboot(vm_name, **virsh_args)
supported_err = 'not supported by the connection driver: virDomainReboot'
if supported_err in result.stderr.strip():
logging.info("Reboot is not supported")
else:
utlv.check_exit_status(result)
# Destroy
result = virsh.destroy(vm_name, **virsh_args)
utlv.check_exit_status(result)
check_state('shut off')
# Undefine
result = virsh.undefine(vm_name, **virsh_args)
utlv.check_exit_status(result)
if not virsh.domain_exists(vm_name, **virsh_args):
logging.info("Undefine LXC domain successfully")
else:
raise TestFail("LXC domain still exist after undefine")
finally:
virsh.remove_domain(vm_name, **virsh_args)
if full_os and os.path.exists(install_root):
shutil.rmtree(install_root)
def run_virsh_restore(test, params, env):
"""
Test command: virsh restore.
Restore a domain from a saved state in a file
1.Prepare test environment.
2.When the libvirtd == "off", stop the libvirtd service.
3.Run virsh restore command with assigned option.
4.Recover test environment.
5.Confirm the test result.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(params["main_vm"])
session = vm.wait_for_login()
os_type = params.get("os_type")
status_error = params.get("restore_status_error")
libvirtd = params.get("restore_libvirtd")
extra_param = params.get("restore_extra_param")
pre_status = params.get("restore_pre_status")
vm_ref = params.get("restore_vm_ref")
#run test
if vm_ref =="" or vm_ref == "xyz":
status = virsh.restore(vm_ref, ignore_status=True).exit_status
else:
if os_type == "linux":
cmd = "cat /proc/cpuinfo"
status, output = session.cmd_status_output(cmd,
internal_timeout = 10)
session.close()
if not re.search("processor", output):
raise error.TestFail("Unable to read /proc/cpuinfo")
tmp_file = vm_ref
if vm_ref == "/tmp/save.file":
virsh.save(vm_name, vm_ref)
vm_ref = "%s %s" % (vm_ref, extra_param)
elif vm_ref == "/tmp/new.file":
open(vm_ref, 'w').close()
if vm.is_alive():
vm.destroy()
if pre_status == "start":
virsh.start(vm_name)
if libvirtd == "off":
libvirt_vm.libvirtd_stop()
status = virsh.restore(vm_ref, ignore_status=True).exit_status
os.unlink(tmp_file)
if status_error == "no":
list_output = virsh.dom_list().stdout.strip()
session.close()
#recover libvirtd service start
if libvirtd == "off":
libvirt_vm.libvirtd_start()
if vm.is_alive():
vm.destroy()
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")
else:
if not re.search(vm_name, list_output):
raise error.TestFail("Run failed with right command")
def run(test, params, env):
"""
Test command: virsh reboot.
Run a reboot command in the target domain.
1.Prepare test environment.
2.When the libvirtd == "off", stop the libvirtd service.
3.Perform virsh reboot operation.
4.Recover test environment.(libvirts service)
5.Confirm the test result.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
# run test case
libvirtd = params.get("libvirtd", "on")
vm_ref = params.get("reboot_vm_ref")
status_error = ("yes" == params.get("status_error"))
extra = params.get("reboot_extra", "")
remote_ip = params.get("remote_ip", "REMOTE.EXAMPLE.COM")
local_ip = params.get("local_ip", "LOCAL.EXAMPLE.COM")
remote_pwd = params.get("remote_pwd", "password")
agent = ("yes" == params.get("reboot_agent", "no"))
mode = params.get("reboot_mode", "")
pre_domian_status = params.get("reboot_pre_domian_status", "running")
reboot_readonly = "yes" == params.get("reboot_readonly", "no")
xml_backup = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
try:
# Add or remove qemu-agent from guest before test
try:
vm.prepare_guest_agent(channel=agent, start=agent)
except virt_vm.VMError as e:
logging.debug(e)
# qemu-guest-agent is not available on REHL5
test.cancel("qemu-guest-agent package is not available")
if pre_domian_status == "shutoff":
virsh.destroy(vm_name)
if libvirtd == "off":
utils_libvirtd.libvirtd_stop()
domid = vm.get_id()
domuuid = vm.get_uuid()
if vm_ref == "id":
vm_ref = domid
elif vm_ref == "name":
vm_ref = vm_name
elif vm_ref == "uuid":
vm_ref = domuuid
elif vm_ref == "hex_id":
vm_ref = hex(int(domid))
elif vm_ref.find("invalid") != -1:
vm_ref = params.get(vm_ref)
elif vm_ref == "remote_name":
if remote_ip.count("EXAMPLE.COM") or local_ip.count("EXAMPLE.COM"):
test.cancel("remote_ip and/or local_ip parameters"
" not changed from default values")
complete_uri = libvirt_vm.complete_uri(local_ip)
try:
session = remote.remote_login("ssh", remote_ip, "22", "root",
remote_pwd, "#")
session.cmd_output('LANG=C')
command = "virsh -c %s reboot %s %s" % (complete_uri, vm_name,
mode)
status, output = session.cmd_status_output(command,
internal_timeout=5)
session.close()
if not status:
# the operation before the end of reboot
# may result in data corruption
vm.wait_for_login().close()
except (remote.LoginError, process.CmdError, aexpect.ShellError) as e:
logging.error("Exception: %s", str(e))
status = -1
if vm_ref != "remote_name":
vm_ref = "%s" % vm_ref
if extra:
vm_ref += " %s" % extra
cmdresult = virsh.reboot(vm_ref, mode,
ignore_status=True, debug=True)
status = cmdresult.exit_status
if status:
logging.debug("Error status, cmd error: %s", cmdresult.stderr)
if not virsh.has_command_help_match('reboot', '\s+--mode\s+'):
# old libvirt doesn't support reboot
status = -2
time.sleep(5)
# avoid the check if it is negative test
if not status_error:
cmdoutput = virsh.domstate(vm_ref, '--reason',
ignore_status=True, debug=True)
domstate_status = cmdoutput.exit_status
output = "running" in cmdoutput.stdout
if domstate_status or (not output):
test.fail("Cmd error: %s Error status: %s" %
(cmdoutput.stderr, cmdoutput.stdout))
elif pre_domian_status != 'shutoff':
vm.wait_for_login().close()
output = virsh.dom_list(ignore_status=True).stdout.strip()
# Test the readonly mode
if reboot_readonly:
result = virsh.reboot(vm_ref, ignore_status=True, debug=True, readonly=True)
libvirt.check_exit_status(result, expect_error=True)
# This is for status_error check
status = result.exit_status
# recover libvirtd service start
if libvirtd == "off":
utils_libvirtd.libvirtd_start()
# check status_error
if status_error:
if not status:
test.fail("Run successfully with wrong command!")
else:
if status or (not re.search(vm_name, output)):
if status == -2:
test.cancel("Reboot command doesn't work on older libvirt "
"versions")
test.fail("Run failed with right command")
finally:
xml_backup.sync()
def run(test, params, env):
"""
Test steps:
1) Get the params from params.
2) check the environment
3) Strat the VM and check whether the VM been started successfully
4) Compare the Hugepage memory size to the Guest memory setted.
5) Check the hugepage memory usage.
6) Clean up
"""
test_type = params.get("test_type", 'normal')
tlbfs_enable = 'yes' == params.get("hugetlbfs_enable", 'no')
shp_num = int(params.get("static_hugepage_num", 1024))
thp_enable = 'yes' == params.get("trans_hugepage_enable", 'no')
mb_enable = 'yes' == params.get("mb_enable", 'yes')
delay = int(params.get("delay_time", 10))
# backup orignal setting
shp_orig_num = utils_memory.get_num_huge_pages()
thp_orig_status = utils_memory.get_transparent_hugepage()
page_size = utils_memory.get_huge_page_size()
if test_type == "contrast":
range = float(params.get("mem_error_range", 1.25))
elif test_type == "stress":
target_path = params.get("target_path", "/tmp/test.out")
elif test_type == "unixbench":
unixbench_control_file = params.get("unixbench_controle_file",
"unixbench5.control")
vm_names = []
if test_type == "contrast":
vm_names = params.get("vms").split()[:2]
if len(vm_names) < 2:
raise error.TestNAError("Hugepage Stress Test need two VM(s).")
# confirm no VM(s) running
allvms = virsh.dom_list('--name').stdout.strip()
if allvms != '':
raise error.TestNAError("one or more VM(s) is living.")
else:
vm_names.append(params.get("main_vm"))
# mount/umount hugetlbfs
tlbfs_status = utils_misc.is_mounted("hugetlbfs", "/dev/hugepages",
"hugetlbfs")
if tlbfs_enable is True:
if tlbfs_status is not True:
utils_misc.mount("hugetlbfs", "/dev/hugepages", "hugetlbfs")
else:
if tlbfs_status is True:
utils_misc.umount("hugetlbfs", "/dev/hugepages", "hugetlbfs")
# set static hugepage
utils_memory.set_num_huge_pages(shp_num)
# enable/disable transparent hugepage
if thp_enable:
utils_memory.set_transparent_hugepage('always')
else:
utils_memory.set_transparent_hugepage('never')
# set/del memoryBacking tag
for vm_name in vm_names:
if mb_enable:
vm_xml.VMXML.set_memoryBacking_tag(vm_name)
else:
vm_xml.VMXML.del_memoryBacking_tag(vm_name)
utils_libvirtd.libvirtd_restart()
non_started_free = utils_memory.get_num_huge_pages_free()
vms = []
sessions = []
for vm_name in vm_names:
# try to start vm and login
try:
vm = env.get_vm(vm_name)
vm.start()
except VMError, e:
if mb_enable and not tlbfs_enable:
# if hugetlbfs not be mounted,
# VM start with memoryBacking tag will fail
logging.debug(e)
pass # jump out of for-loop
else:
error_msg = "Test failed in positive case. error: %s\n" % e
raise error.TestFail(error_msg)
if vm.is_alive() is not True:
break
vms.append(vm)
# try to login and run some program
try:
session = vm.wait_for_login()
except (LoginError, ShellError), e:
error_msg = "Test failed in positive case.\n error: %s\n" % e
raise error.TestFail(error_msg)
internal_timeout=5)
session.close()
except (remote.LoginError, process.CmdError, aexpect.ShellError), e:
logging.error("Exception: %s", str(e))
status = -1
if vm_ref != "remote_name":
vm_ref = "%s %s" % (vm_ref, extra)
cmdresult = virsh.reboot(vm_ref, mode,
ignore_status=True, debug=True)
status = cmdresult.exit_status
if status:
logging.debug("Error status, cmd error: %s", cmdresult.stderr)
if not virsh.has_command_help_match('reboot', '\s+--mode\s+'):
# old libvirt doesn't support reboot
status = -2
output = virsh.dom_list(ignore_status=True).stdout.strip()
# recover libvirtd service start
if libvirtd == "off":
utils_libvirtd.libvirtd_start()
# check status_error
if status_error:
if not status:
raise error.TestFail("Run successfully with wrong command!")
else:
if status or (not re.search(vm_name, output)):
if status == -2:
raise error.TestNAError(
"Reboot command doesn't work on older libvirt versions")
raise error.TestFail("Run failed with right command")
def run(test, params, env):
"""
Test command: virsh managedsave-xxx
including virsh managedsave-edit
virsh managedsave-dumpxml
virsh managedsave-define
...
"""
vm_name = params.get('main_vm')
checkpoint = params.get('checkpoint', '')
error_msg = params.get('error_msg', '')
ms_extra_options = params.get('ms_extra_options', '')
pre_state = params.get('pre_state', '')
status_error = 'yes' == params.get('status_error', 'no')
vm = env.get_vm(vm_name)
bkxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
virsh_dargs = {'debug': True, 'ignore_status': False}
def start_and_login_vm():
"""
Start vm and login, after which vm is accessible
"""
vm.start()
vm.wait_for_login().close()
try:
if checkpoint == 'dumpxml':
# Check managedsave-dumpxml
start_and_login_vm()
virsh.managedsave(vm_name, **virsh_dargs)
virsh.managedsave_dumpxml(vm_name, **virsh_dargs)
tmp_dir = data_dir.get_tmp_dir()
save_img_xml = os.path.join(tmp_dir, 'save_img.xml')
managed_save_xml = os.path.join(tmp_dir, 'managed_save.xml')
virsh.save_image_dumpxml(MANAGEDSAVE_FILE % vm_name, ' > %s'
% save_img_xml, **virsh_dargs)
virsh.managedsave_dumpxml(vm_name, ' > %s' % managed_save_xml,
**virsh_dargs)
result_need_check = process.run('diff %s %s' %
(save_img_xml, managed_save_xml),
shell=True, verbose=True)
if checkpoint == 'secure_info':
# Check managedsave-dumpxml with option --security-info
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
vm_xml.VMXML.set_graphics_attr(vm_name, {'passwd': '123456'})
start_and_login_vm()
virsh.managedsave(vm_name, **virsh_dargs)
default_xml = virsh.managedsave_dumpxml(vm_name, **virsh_dargs).stdout_text
if 'passwd' in default_xml:
test.fail('Found "passwd" in dumped vm xml. '
'Secure info like "passwd" should not be dumped.')
secure_xml = virsh.managedsave_dumpxml(vm_name, '--security-info',
**virsh_dargs).stdout_text
if 'passwd' not in secure_xml:
test.fail('Not found "passwd" in dumped vm xml.'
'Secure info like "passwd" should be dumped '
'with option "--security-info"')
if checkpoint == 'define':
# Make change to a managedsave-dumped xml and redefine vm
# and check if the change take effect
start_option = '--paused' if pre_state == 'paused' else ''
virsh.start(vm_name, start_option, **virsh_dargs)
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
logging.debug(vmxml.devices)
disk = vmxml.get_devices('disk')[0]
img_path = disk.source.attrs['file']
logging.info('Original image path: %s', img_path)
# Copy old image to new image
new_img_path = os.path.join(data_dir.get_tmp_dir(), 'test.img')
shutil.copyfile(img_path, new_img_path)
virsh.managedsave(vm_name, **virsh_dargs)
xmlfile = os.path.join(data_dir.get_tmp_dir(), 'managedsave.xml')
virsh.managedsave_dumpxml(vm_name, '>%s' % xmlfile, **virsh_dargs)
# Make change to xmlfile and managedsave-define with it
with open(xmlfile) as file_xml:
updated_xml = file_xml.read().replace(img_path, new_img_path)
with open(xmlfile, 'w') as file_xml:
file_xml.write(updated_xml)
virsh.managedsave_define(vm_name, xmlfile, ms_extra_options, **virsh_dargs)
virsh.start(vm_name, **virsh_dargs)
xml_after_define = virsh.dumpxml(vm_name, **virsh_dargs).stdout_text
if 'test.img' not in xml_after_define:
test.fail('Not found "test.img" in vm xml after managedsave-define.'
'Modification to xml did not take effect.')
if checkpoint == 'no_save':
# Start a guest but do not managedsave it
start_and_login_vm()
virsh.dom_list('--all --managed-save', **virsh_dargs)
if checkpoint == 'rm_after_save':
# Remove saved file after managedsave a vm
start_and_login_vm()
virsh.managedsave(vm_name, **virsh_dargs)
os.remove(MANAGEDSAVE_FILE % vm_name)
if checkpoint == 'not_saved_corrupt':
# Do not managedsave a vm, but create a fake managedsaved file by
# 'touch' a file
start_and_login_vm()
virsh.dom_list('--all --managed-save', **virsh_dargs)
process.run('touch %s' % MANAGEDSAVE_FILE % vm_name, verbose=True)
params['clean_managed_save'] = True
if checkpoint == 'exclusive_option':
virsh.managedsave(vm_name, **virsh_dargs)
# Test managedsave-edit, managedsave_dumpxml, managedsave-define
if params.get('check_cmd_error', '') == 'yes':
ms_command = params.get('ms_command', '')
if ms_command == 'edit':
result_need_check = virsh.managedsave_edit(vm_name,
ms_extra_options,
debug=True)
if ms_command == 'dumpxml':
result_need_check = virsh.managedsave_dumpxml(vm_name,
ms_extra_options,
debug=True)
if ms_command == 'define':
result_need_check = virsh.managedsave_define(vm_name,
bkxml.xml,
ms_extra_options,
debug=True)
# If needs to check result, check it
if 'result_need_check' in locals():
logging.info('Check command result.')
libvirt.check_exit_status(result_need_check, status_error)
if error_msg:
libvirt.check_result(result_need_check, [error_msg])
finally:
if params.get('clean_managed_save'):
os.remove(MANAGEDSAVE_FILE % vm_name)
utils_libvirtd.libvirtd_restart()
virsh.managedsave_remove(vm_name, debug=True)
bkxml.sync()
def run(test, params, env):
"""
Test command: virsh restore.
Restore a domain from a saved state in a file
1.Prepare test environment.
2.When the libvirtd == "off", stop the libvirtd service.
3.Run virsh restore command with assigned option.
4.Recover test environment.
5.Confirm the test result.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
session = vm.wait_for_login()
os_type = params.get("os_type")
status_error = ("yes" == params.get("status_error"))
libvirtd = params.get("libvirtd", "on")
extra_param = params.get("restore_extra_param")
pre_status = params.get("restore_pre_status")
vm_ref = params.get("restore_vm_ref")
uri = params.get("virsh_uri")
unprivileged_user = params.get('unprivileged_user')
time_before_save = int(params.get('time_before_save', 0))
if unprivileged_user:
if unprivileged_user.count('EXAMPLE'):
unprivileged_user = '******'
if not libvirt_version.version_compare(1, 1, 1):
if params.get('setup_libvirt_polkit') == 'yes':
test.cancel("API acl test not supported in current"
" libvirt version.")
if "--xml" in extra_param:
vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name, options="--migratable")
backup_xml = vmxml.copy()
# Grant more priveledge on the file in order for un-priveledge user
# to access.
os.chmod(vmxml.xml, stat.S_IRWXU | stat.S_IRGRP | stat.S_IROTH)
extra_param = "--xml %s" % vmxml.xml
dict_os_attrs = {}
if "hd" in vmxml.os.boots:
dict_os_attrs.update({"boots": ["cdrom"]})
vmxml.set_os_attrs(**dict_os_attrs)
else:
test.cancel("Please add 'hd' in boots for --xml testing")
logging.info("vmxml os is %s after update" % vmxml.os.xmltreefile)
# run test
if vm_ref == "" or vm_ref == "xyz":
status = virsh.restore(vm_ref, extra_param, debug=True,
unprivileged_user=unprivileged_user,
uri=uri,
ignore_status=True).exit_status
else:
if os_type == "linux":
cmd = "cat /proc/cpuinfo"
try:
status, output = session.cmd_status_output(cmd, timeout=10)
finally:
session.close()
if not re.search("processor", output):
test.fail("Unable to read /proc/cpuinfo")
tmp_file = os.path.join(data_dir.get_tmp_dir(), "save.file")
time.sleep(time_before_save)
ret = virsh.save(vm_name, tmp_file, debug=True)
libvirt.check_exit_status(ret)
if vm_ref == "saved_file":
vm_ref = tmp_file
elif vm_ref == "empty_new_file":
tmp_file = os.path.join(data_dir.get_tmp_dir(), "new.file")
with open(tmp_file, 'w') as tmp:
pass
vm_ref = tmp_file
if vm.is_alive():
vm.destroy()
if pre_status == "start":
virsh.start(vm_name)
if libvirtd == "off":
utils_libvirtd.libvirtd_stop()
status = virsh.restore(vm_ref, extra_param, debug=True,
unprivileged_user=unprivileged_user,
uri=uri,
ignore_status=True).exit_status
if not status_error:
list_output = virsh.dom_list().stdout.strip()
session.close()
# recover libvirtd service start
if libvirtd == "off":
utils_libvirtd.libvirtd_start()
try:
if status_error:
if not status:
if libvirtd == "off" and libvirt_version.version_compare(5, 6, 0):
logging.info("From libvirt version 5.6.0 libvirtd is restarted "
"and command should succeed")
else:
test.fail("Run successfully with wrong command!")
else:
if status:
test.fail("Run failed with right command")
if not re.search(vm_name, list_output):
test.fail("Run failed with right command")
if extra_param.count("paused"):
if not vm.is_paused():
test.fail("Guest state should be"
" paused after restore"
" due to the option --paused")
if (extra_param.count("running") or
extra_param.count("xml") or
not extra_param):
if vm.is_dead() or vm.is_paused():
test.fail("Guest state should be"
" running after restore")
if extra_param.count("xml"):
aft_vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
boots_list = aft_vmxml.os.boots
if "hd" in boots_list or "cdrom" not in boots_list:
test.fail("Update xml with restore failed")
finally:
if vm.is_paused():
virsh.resume(vm_name)
if "--xml" in extra_param:
backup_xml.sync()
def run(test, params, env):
"""
Start libvirt daemon with different options.
Check socket files.
"""
log = []
def _logger(line):
"""
Callback function to log libvirtd output.
"""
log.append(line)
def check_help(params):
"""
Check whether the output is help and meets expectation
"""
expected_help = params.get('expected_help', 'no') == 'yes'
is_help = any(line.startswith('Usage:') for line in log)
if expected_help != is_help:
raise error.TestFail(
'Expected output help is %s, but get output:\n%s' %
(expected_help, '\n'.join(log)))
def check_version(params):
"""
Check whether the output is libvirtd version.
"""
expected_version = params.get('expected_version', 'no') == 'yes'
is_version = log[0].startswith('libvirtd (libvirt)')
if expected_version != is_version:
raise error.TestFail(
'Expected output version is %s, but get output:\n%s' %
(expected_version, '\n'.join(log)))
def check_unix_socket_files():
"""
Check whether the socket file exists.
"""
rw_sock_path = '/var/run/libvirt/libvirt-sock'
ro_sock_path = '/var/run/libvirt/libvirt-sock-ro'
if libvirtd.running:
if not os.path.exists(rw_sock_path):
raise error.TestFail('RW unix socket file not found at %s' %
rw_sock_path)
if not os.path.exists(ro_sock_path):
raise error.TestFail('RO unix socket file not found at %s' %
ro_sock_path)
else:
if os.path.exists(rw_sock_path) or os.path.exists(ro_sock_path):
raise error.TestFail('Expect unix socket file do not exists '
'when libvirtd is stopped')
def check_pid_file():
"""
Check whether the pid file exists.
"""
if not os.path.exists(pid_path):
raise error.TestFail("PID file not found at %s" % pid_path)
pid_file = open(pid_path)
pid = int(pid_file.readline())
pid_file.close()
result = utils.run('pgrep libvirtd', ignore_status=True)
expected_pid = int(result.stdout.split()[0])
if pid != expected_pid:
raise error.TestFail("PID file content mismatch. Expected %s "
"but got %s" % (expected_pid, pid))
def check_config_file():
"""
Check whether the config file take effects by checking UUID.
"""
cur_uuid = capability_xml.CapabilityXML()['uuid']
if cur_uuid != check_uuid:
raise error.TestFail('Expected host UUID is %s, but got %s' %
(check_uuid, cur_uuid))
MAX_TIMEOUT = 10
arg_str = params.get("libvirtd_arg", "")
time_tolerance = float(params.get("exit_time_tolerance", 1))
expected_exit_time = float(params.get("expected_exit_time", 'inf'))
config_path = params.get('expected_config_path', "")
pid_path = params.get('expected_pid_path', "")
if expected_exit_time == float('inf'):
timeout = MAX_TIMEOUT
else:
if expected_exit_time > 0:
if len(virsh.dom_list('--name').stdout.strip().splitlines()):
raise error.TestNAError('Timeout option will be ignore if '
'there exists living domain')
timeout = expected_exit_time + time_tolerance
libvirtd = LibvirtdSession(logging_handler=_logger, )
# Setup config file.
check_uuid = '13371337-1337-1337-1337-133713371337'
if config_path:
open(config_path, 'a').close()
config = utils_config.LibvirtdConfig(config_path)
config.host_uuid = check_uuid
try:
check_unix_socket_files()
libvirtd.start(arg_str=arg_str, wait_for_working=False)
start = time.time()
libvirtd_exited = libvirtd.wait_for_stop(timeout=timeout, step=0.1)
wait_time = time.time() - start
if log:
logging.debug("Libvirtd log:")
for line in log:
logging.debug(line)
check_help(params)
check_version(params)
if libvirtd_exited:
if expected_exit_time == float('inf'):
raise error.TestFail("Expected never stop, but ran %ss" %
wait_time)
elif wait_time < expected_exit_time - time_tolerance:
raise error.TestFail(
"Expected exit in %ss(+-%ss), but ran %ss" %
(expected_exit_time, time_tolerance, wait_time))
else:
if expected_exit_time != float('inf'):
raise error.TestFail(
"Expected exit in %ss(+-%ss), but ran timeout in %ss" %
(expected_exit_time, time_tolerance, wait_time))
check_unix_socket_files()
if config_path:
check_config_file()
if pid_path:
check_pid_file()
finally:
libvirtd.exit()
# Clean up config file
if config_path:
config.restore()
if os.path.exists(config_path):
os.remove(config_path)
if os.path.exists(pid_path):
os.remove(pid_path)
def run(test, params, env):
"""
Test steps:
1) Get the params from params.
2) check the environment
3) Strat the VM and check whether the VM been started successfully
4) Compare the Hugepage memory size to the Guest memory setted.
5) Check the hugepage memory usage.
6) Clean up
"""
test_type = params.get("test_type", 'normal')
tlbfs_enable = 'yes' == params.get("hugetlbfs_enable", 'no')
shp_num = int(params.get("static_hugepage_num", 1024))
thp_enable = 'yes' == params.get("trans_hugepage_enable", 'no')
mb_enable = 'yes' == params.get("mb_enable", 'yes')
delay = int(params.get("delay_time", 10))
# Skip cases early
vm_names = []
if test_type == "contrast":
vm_names = params.get("vms").split()[:2]
if len(vm_names) < 2:
raise error.TestNAError("This test requires two VMs")
# confirm no VM running
allvms = virsh.dom_list('--name').stdout.strip()
if allvms != '':
raise error.TestNAError("one or more VMs are alive")
err_range = float(params.get("mem_error_range", 1.25))
else:
vm_names.append(params.get("main_vm"))
if test_type == "stress":
target_path = params.get("target_path", "/tmp/test.out")
elif test_type == "unixbench":
unixbench_control_file = params.get("unixbench_controle_file",
"unixbench5.control")
# backup orignal setting
shp_orig_num = utils_memory.get_num_huge_pages()
thp_orig_status = utils_memory.get_transparent_hugepage()
page_size = utils_memory.get_huge_page_size()
# mount/umount hugetlbfs
tlbfs_status = utils_misc.is_mounted("hugetlbfs", "/dev/hugepages",
"hugetlbfs")
if tlbfs_enable is True:
if tlbfs_status is not True:
utils_misc.mount("hugetlbfs", "/dev/hugepages", "hugetlbfs")
else:
if tlbfs_status is True:
utils_misc.umount("hugetlbfs", "/dev/hugepages", "hugetlbfs")
# set static hugepage
utils_memory.set_num_huge_pages(shp_num)
# enable/disable transparent hugepage
if thp_enable:
utils_memory.set_transparent_hugepage('always')
else:
utils_memory.set_transparent_hugepage('never')
# set/del memoryBacking tag
for vm_name in vm_names:
if mb_enable:
vm_xml.VMXML.set_memoryBacking_tag(vm_name)
else:
vm_xml.VMXML.del_memoryBacking_tag(vm_name)
utils_libvirtd.libvirtd_restart()
non_started_free = utils_memory.get_num_huge_pages_free()
vms = []
sessions = []
try:
for vm_name in vm_names:
# try to start vm and login
try:
vm = env.get_vm(vm_name)
vm.start()
except VMError, e:
if mb_enable and not tlbfs_enable:
# if hugetlbfs not be mounted,
# VM start with memoryBacking tag will fail
logging.debug(e)
else:
error_msg = "Test failed in positive case. error: %s\n" % e
raise error.TestFail(error_msg)
if vm.is_alive() is not True:
break
vms.append(vm)
# try to login and run some program
try:
session = vm.wait_for_login()
except (LoginError, ShellError), e:
error_msg = "Test failed in positive case.\n error: %s\n" % e
raise error.TestFail(error_msg)
sessions.append(session)
if test_type == "stress":
# prepare file for increasing stress
stress_path = prepare_c_file()
remote.scp_to_remote(vm.get_address(), 22,
'root', params.get('password'),
stress_path, "/tmp/")
# Try to install gcc on guest first
utils_package.package_install(["gcc"], session, 360)
# increasing workload
session.cmd("gcc %s -o %s" % (stress_path, target_path))
session.cmd("%s &" % target_path)
if test_type == "unixbench":
params["main_vm"] = vm_name
params["test_control_file"] = unixbench_control_file
control_path = os.path.join(test.virtdir, "control",
unixbench_control_file)
# unixbench test need 'patch' and 'perl' commands installed
utils_package.package_install(["patch", "perl"], session, 360)
command = utils_test.run_autotest(vm, session, control_path,
None, None, params,
copy_only=True)
session.cmd("%s &" % command, ignore_all_errors=True)
# wait for autotest running on vm
time.sleep(delay)
def _is_unixbench_running():
cmd = "ps -ef | grep perl | grep Run"
return not session.cmd_status(cmd)
if not utils_misc.wait_for(_is_unixbench_running, timeout=240):
raise error.TestNAError("Failed to run unixbench in guest,"
" please make sure some necessary"
" packages are installed in guest,"
" such as gcc, tar, bzip2")
logging.debug("Unixbench test is running in VM")
raise exceptions.TestSkipError(
"Remote test parameters unchanged from default")
logging.info("Execute virsh command on remote host %s.", remote_ip)
status, output = list_local_domains_on_remote(options_ref,
remote_ip,
remote_pwd,
local_ip,
remote_user,
local_user,
local_pwd)
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()
except Exception, output:
status = True
logging.error("Exception: %s" % output)
finally:
# Recover libvirtd service status
if libvirtd == "off":
utils_libvirtd.libvirtd_start()
# Recover of domain
if vm_ref == "transient" or list_ref == "--title":
vm_backup.sync()
def run(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.
"""
complete_uri = libvirt_vm.complete_uri(local_ip)
command_on_remote = "virsh -c %s list %s" % (complete_uri, 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")
vm = env.get_vm(vm_name)
options_ref = params.get("list_options_ref", "")
list_ref = params.get("list_type_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":
utils_libvirtd.libvirtd_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", "REMOTE.EXAMPLE.COM")
remote_pwd = params.get("remote_pwd", None)
local_ip = params.get("local_ip", "LOCAL.EXAMPLE.COM")
if remote_ip.count("EXAMPLE.COM") or local_ip.count("EXAMPLE.COM"):
raise error.TestNAError(
"Remote test parameters unchanged from default")
logging.info("Execute virsh command on remote host %s.", remote_ip)
status, output = list_local_domains_on_remote(
options_ref, remote_ip, remote_pwd, 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":
utils_libvirtd.libvirtd_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(test, params, env):
"""
Test command: virsh reboot.
Run a reboot command in the target domain.
1.Prepare test environment.
2.When the libvirtd == "off", stop the libvirtd service.
3.Perform virsh reboot operation.
4.Recover test environment.(libvirts service)
5.Confirm the test result.
"""
def boot_time():
"""
Get guest boot time
"""
session = vm.wait_for_login()
def get_boot_time():
"""
Waiting for boot time getting when exception happened
"""
boot_time = None
try:
boot_time = session.cmd_output("uptime --since")
except (aexpect.ShellStatusError,
aexpect.ShellProcessTerminatedError) as e:
logging.error("Get boot_time error:%s" % e)
return boot_time
boot_time = utils_misc.wait_for(get_boot_time, 60)
session.close()
return boot_time
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
# run test case
libvirtd = params.get("libvirtd", "on")
vm_ref = params.get("reboot_vm_ref")
status_error = ("yes" == params.get("status_error"))
extra = params.get("reboot_extra", "")
remote_ip = params.get("remote_ip", "REMOTE.EXAMPLE.COM")
local_ip = params.get("local_ip", "LOCAL.EXAMPLE.COM")
remote_pwd = params.get("remote_pwd", "password")
local_pwd = params.get("local_pwd", "password")
agent = ("yes" == params.get("reboot_agent", "no"))
mode = params.get("reboot_mode", "")
pre_domian_status = params.get("reboot_pre_domian_status", "running")
reboot_readonly = "yes" == params.get("reboot_readonly", "no")
wait_time = int(params.get('wait_time', 5))
xml_backup = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
try:
# Add or remove qemu-agent from guest before test
try:
vm.prepare_guest_agent(channel=agent, start=agent)
except virt_vm.VMError as e:
logging.debug(e)
# qemu-guest-agent is not available on REHL5
test.cancel("qemu-guest-agent package is not available")
if pre_domian_status == "shutoff":
virsh.destroy(vm_name)
if libvirtd == "off":
utils_libvirtd.libvirtd_stop()
domid = vm.get_id()
domuuid = vm.get_uuid()
if vm_ref == "id":
vm_ref = domid
elif vm_ref == "name":
vm_ref = vm_name
elif vm_ref == "uuid":
vm_ref = domuuid
elif vm_ref == "hex_id":
vm_ref = hex(int(domid))
elif vm_ref.find("invalid") != -1:
vm_ref = params.get(vm_ref)
elif vm_ref == "remote_name":
if remote_ip.count("EXAMPLE.COM") or local_ip.count("EXAMPLE.COM"):
test.cancel("remote_ip and/or local_ip parameters"
" not changed from default values")
complete_uri = libvirt_vm.complete_uri(local_ip)
# Setup ssh connection
ssh_connection = utils_conn.SSHConnection(server_ip=local_ip,
server_pwd=local_pwd,
client_ip=remote_ip,
client_pwd=remote_pwd)
try:
ssh_connection.conn_check()
except utils_conn.ConnectionError:
ssh_connection.conn_setup()
ssh_connection.conn_check()
try:
session = remote.remote_login("ssh", remote_ip, "22", "root",
remote_pwd, "#")
session.cmd_output('LANG=C')
command = "virsh -c %s reboot %s %s" % (complete_uri, vm_name,
mode)
status, output = session.cmd_status_output(command,
internal_timeout=5)
session.close()
if not status:
# the operation before the end of reboot
# may result in data corruption
vm.wait_for_login().close()
except (remote.LoginError, process.CmdError,
aexpect.ShellError) as e:
logging.error("Exception: %s", str(e))
status = -1
if vm_ref != "remote_name":
if not status_error:
# Not need to check the boot up time if it is a negative test
first_boot_time = boot_time()
vm_ref = "%s" % vm_ref
if extra:
vm_ref += " %s" % extra
cmdresult = virsh.reboot(vm_ref,
mode,
ignore_status=True,
debug=True)
status = cmdresult.exit_status
if status:
logging.debug("Error status, cmd error: %s", cmdresult.stderr)
if not virsh.has_command_help_match('reboot', '\s+--mode\s+'):
# old libvirt doesn't support reboot
status = -2
# avoid the check if it is negative test
if not status_error:
cmdoutput = ''
def _wait_for_reboot_up():
second_boot_time = boot_time()
is_rebooted = second_boot_time > first_boot_time
cmdoutput = virsh.domstate(vm_ref,
'--reason',
ignore_status=True,
debug=True)
domstate_status = cmdoutput.exit_status
output = "running" in cmdoutput.stdout
return not domstate_status and output and is_rebooted
if not wait.wait_for(
_wait_for_reboot_up, timeout=wait_time, step=1):
test.fail("Cmd error: %s Error status: %s" %
(cmdoutput.stderr, cmdoutput.stdout))
elif pre_domian_status != 'shutoff':
vm.wait_for_login().close()
output = virsh.dom_list(ignore_status=True).stdout.strip()
# Test the readonly mode
if reboot_readonly:
result = virsh.reboot(vm_ref,
ignore_status=True,
debug=True,
readonly=True)
libvirt.check_exit_status(result, expect_error=True)
# This is for status_error check
status = result.exit_status
# recover libvirtd service start
if libvirtd == "off":
utils_libvirtd.libvirtd_start()
# check status_error
if status_error:
if not status:
test.fail("Run successfully with wrong command!")
else:
if status or (not re.search(vm_name, output)):
if status == -2:
test.cancel("Reboot command doesn't work on older libvirt "
"versions")
test.fail("Run failed with right command")
finally:
xml_backup.sync()
if 'ssh_connection' in locals():
ssh_connection.auto_recover = True
