def remote_test(remote_ip, local_ip, remote_pwd, remote_prompt,
vm_name, status_error_test):
"""
Test remote case
"""
err = ""
status = 1
status_error = status_error_test
try:
remote_uri = libvirt_vm.complete_uri(local_ip)
session = remote.remote_login("ssh", remote_ip, "22",
"root", remote_pwd, remote_prompt)
session.cmd_output('LANG=C')
command = "virsh -c %s setvcpus %s 1 --live" % (remote_uri, vm_name)
if virsh.has_command_help_match("setvcpus", "--live") is None:
raise error.TestNAError("The current libvirt doesn't support"
" '--live' option for setvcpus")
status, output = session.cmd_status_output(command, internal_timeout=5)
session.close()
if status != 0:
err = output
except error.CmdError:
status = 1
err = "remote test failed"
return status, status_error, err
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, info:
logging.error("Shell failed to execute command from" " remote")
return 1, info
def remote_case(params, vm_name):
"""
Test remote case.
"""
remote_ip = params.get("remote_ip", "REMOTE.EXAMPLE.COM")
local_ip = params.get("local_ip", "LOCAL.EXAMPLE.COM")
remote_pwd = params.get("remote_pwd", "")
local_pwd = params.get("local_pwd", "")
remote_user = params.get("remote_user", "root")
local_user = params.get("local_user", "root")
status = 0
output = ""
try:
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.")
uri = libvirt_vm.complete_uri(local_ip)
# setup ssh auto login
ssh_key.setup_ssh_key(remote_ip, remote_user, remote_pwd)
ssh_key.setup_remote_ssh_key(remote_ip, remote_user, remote_pwd,
local_ip, local_user, local_pwd)
session = remote.remote_login("ssh", remote_ip, "22", "root",
remote_pwd, "#")
session.cmd_output('LANG=C')
command = "virsh -c %s vncdisplay %s" % (uri, vm_name)
status, output = session.cmd_status_output(command,
internal_timeout=5)
session.close()
except process.CmdError:
status = 1
output = "remote test failed"
return status, output
def remote_test(remote_ip, local_ip, remote_pwd, remote_prompt, vm_name,
status_error_test):
"""
Test remote case
"""
err = ""
status = 1
status_error = status_error_test
try:
remote_uri = libvirt_vm.complete_uri(local_ip)
session = remote.remote_login("ssh", remote_ip, "22", "root",
remote_pwd, remote_prompt)
session.cmd_output('LANG=C')
command = "virsh -c %s setvcpus %s 1 --live" % (remote_uri, vm_name)
if virsh.has_command_help_match("setvcpus", "--live") is None:
raise error.TestNAError("The current libvirt doesn't support"
" '--live' option for setvcpus")
status, output = session.cmd_status_output(command, internal_timeout=5)
session.close()
if status != 0:
err = output
except process.CmdError:
status = 1
err = "remote test failed"
return status, status_error, err
def remote_test(params, vm_name):
"""
Test remote case.
"""
remote_ip = params.get("remote_ip", "REMOTE.EXAMPLE.COM")
local_ip = params.get("local_ip", "LOCAL.EXAMPLE.COM")
remote_pwd = params.get("remote_pwd", "")
status = 0
output = ""
err = ""
try:
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.")
uri = libvirt_vm.complete_uri(local_ip)
session = remote.remote_login("ssh", remote_ip, "22", "root",
remote_pwd, "#")
session.cmd_output('LANG=C')
command = "virsh -c %s dominfo %s" % (uri, vm_name)
status, output = session.cmd_status_output(command,
internal_timeout=5)
if status != 0:
err = output
session.close()
except error.CmdError:
status = 1
output = ""
err = "remote test failed"
return status, output, err
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, info:
logging.error("Shell failed to execute command from"
" remote")
return 1, info
def run(test, params, env):
"""
Test KVM migration scenarios
"""
migrate_options = params.get("migrate_options", "")
migrate_postcopy = params.get("migrate_postcopy", "")
migrate_dest_ip = params.get("migrate_dest_host")
nfs_mount_path = params.get("nfs_mount_dir")
migrate_start_state = params.get("migrate_start_state", "paused")
postcopy_func = None
if migrate_postcopy:
postcopy_func = virsh.migrate_postcopy
migrate_type = params.get("migrate_type", "orderly")
vm_state = params.get("migrate_vm_state", "running")
ping_count = int(params.get("ping_count", 15))
vms = params.get("vms").split()
vm_list = env.get_all_vms()
# Params to update disk using shared storage
params["disk_type"] = "file"
params["disk_source_protocol"] = "netfs"
params["mnt_path_name"] = nfs_mount_path
src_uri = "qemu:///system"
dest_uri = libvirt_vm.complete_uri(params["server_ip"])
vmxml_dict = {}
migrate_setup = libvirt.MigrationTest()
try:
for vm in vm_list:
vmxml_dict[vm.name] = vm_xml.VMXML.new_from_dumpxml(vm.name)
params["source_dist_img"] = "%s-nfs-img" % vm.name
if vm.is_alive():
vm.destroy()
libvirt.set_vm_disk(vm, params)
migrate_setup.ping_vm(vm, test, params, ping_count=ping_count)
try:
migrate_setup.do_migration(vm_list,
src_uri,
dest_uri,
migrate_type,
migrate_options,
func=postcopy_func,
migrate_start_state=migrate_start_state)
except Exception, info:
test.fail(info)
for vm in vm_list:
if not migrate_setup.check_vm_state(vm, vm_state, dest_uri):
test.fail("Migrated VMs failed to be in %s state at "
"destination" % vm_state)
logging.info("Guest state is '%s' at destination is as expected",
vm_state)
migrate_setup.ping_vm(vm,
test,
params,
uri=dest_uri,
ping_count=ping_count)
def run_virsh_reboot(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 = 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")
domid = vm.get_id()
domuuid = vm.get_uuid()
if libvirtd == "off":
libvirt_vm.libvirtd_stop()
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" % (complete_uri, vm_name)
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
def run(test, params, env):
"""
Test migration under stress.
"""
vm_names = params.get("vms").split()
if len(vm_names) < 2:
test.cancel("Provide enough vms for migration")
src_uri = "qemu:///system"
dest_uri = libvirt_vm.complete_uri(params.get("migrate_dest_host",
"EXAMPLE"))
if dest_uri.count('///') or dest_uri.count('EXAMPLE'):
test.cancel("The dest_uri '%s' is invalid" % dest_uri)
# Migrated vms' instance
vms = env.get_all_vms()
params["load_vms"] = list(vms)
cpu = int(params.get("smp", 1))
memory = int(params.get("mem")) * 1024
stress_tool = params.get("stress_tool", "")
remote_stress = params.get("migration_stress_remote", "no") == "yes"
host_stress = params.get("migration_stress_host", "no") == "yes"
vms_stress = params.get("migration_stress_vms", "no") == "yes"
vm_bytes = params.get("stress_vm_bytes", "128M")
stress_args = params.get("%s_args" % stress_tool)
migration_type = params.get("migration_type")
start_migration_vms = params.get("start_migration_vms", "yes") == "yes"
thread_timeout = int(params.get("thread_timeout", 120))
ubuntu_dep = ['build-essential', 'git']
hstress = rstress = None
vstress = {}
# Set vm_bytes for start_cmd
mem_total = utils_memory.memtotal()
vm_reserved = len(vms) * memory
if vm_bytes == "half":
vm_bytes = (mem_total - vm_reserved) / 2
elif vm_bytes == "shortage":
vm_bytes = mem_total - vm_reserved + 524288
if "vm-bytes" in stress_args:
params["%s_args" % stress_tool] = stress_args % vm_bytes
# Ensure stress tool is available in host
if host_stress:
# remove package manager installed tool to avoid conflict
if not utils_package.package_remove(stress_tool):
logging.error("Existing %s is not removed")
if "stress-ng" in stress_tool and 'Ubuntu' in utils_misc.get_distro():
params['stress-ng_dependency_packages_list'] = ubuntu_dep
try:
hstress = utils_test.HostStress(stress_tool, params)
hstress.load_stress_tool()
except utils_test.StressError, info:
test.error(info)
def run_virsh_reboot(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 = 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")
domid = vm.get_id()
domuuid = vm.get_uuid()
if libvirtd == "off":
utils_libvirtd.libvirtd_stop()
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" % (complete_uri, vm_name)
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
def run(test, params, env):
"""
Test migration under stress.
"""
vm_names = params.get("vms").split()
if len(vm_names) < 2:
test.cancel("Provide enough vms for migration")
src_uri = "qemu:///system"
dest_uri = libvirt_vm.complete_uri(params.get("migrate_dest_host",
"EXAMPLE"))
if dest_uri.count('///') or dest_uri.count('EXAMPLE'):
test.cancel("The dest_uri '%s' is invalid" % dest_uri)
# Migrated vms' instance
vms = env.get_all_vms()
params["load_vms"] = list(vms)
cpu = int(params.get("smp", 1))
memory = int(params.get("mem")) * 1024
stress_tool = params.get("stress_tool", "")
remote_stress = params.get("migration_stress_remote", "no") == "yes"
host_stress = params.get("migration_stress_host", "no") == "yes"
vms_stress = params.get("migration_stress_vms", "no") == "yes"
vm_bytes = params.get("stress_vm_bytes", "128M")
stress_args = params.get("%s_args" % stress_tool)
migration_type = params.get("migration_type")
start_migration_vms = params.get("start_migration_vms", "yes") == "yes"
thread_timeout = int(params.get("thread_timeout", 120))
ubuntu_dep = ['build-essential', 'git']
hstress = rstress = None
vstress = {}
# Set vm_bytes for start_cmd
mem_total = utils_memory.memtotal()
vm_reserved = len(vms) * memory
if vm_bytes == "half":
vm_bytes = (mem_total - vm_reserved) / 2
elif vm_bytes == "shortage":
vm_bytes = mem_total - vm_reserved + 524288
if "vm-bytes" in stress_args:
params["%s_args" % stress_tool] = stress_args % vm_bytes
# Ensure stress tool is available in host
if host_stress:
# remove package manager installed tool to avoid conflict
if not utils_package.package_remove(stress_tool):
logging.error("Existing %s is not removed")
if "stress-ng" in stress_tool and 'Ubuntu' in utils_misc.get_distro():
params['stress-ng_dependency_packages_list'] = ubuntu_dep
try:
hstress = utils_test.HostStress(stress_tool, params)
hstress.load_stress_tool()
except utils_test.StressError, info:
test.error(info)
def run_migration_back(params, test):
"""
Execute migration back from target host to source host
:param params: dict, test parameters
:param test: test object
"""
migrate_vm_back = "yes" == params.get("migrate_vm_back", "no")
vm_name = params.get("migrate_main_vm")
options = params.get("virsh_migrate_options", "--live --verbose")
if migrate_vm_back:
ssh_connection = utils_conn.SSHConnection(
server_ip=params.get("client_ip"),
server_pwd=params.get("local_pwd"),
client_ip=params.get("server_ip"),
client_pwd=params.get("server_pwd"))
try:
ssh_connection.conn_check()
except utils_conn.ConnectionError:
ssh_connection.conn_setup()
ssh_connection.conn_check()
# Pre migration setup for local machine
src_full_uri = libvirt_vm.complete_uri(
params.get("migrate_source_host"))
migration_test = migration.MigrationTest()
migration_test.migrate_pre_setup(src_full_uri, params)
cmd = "virsh migrate %s %s %s" % (vm_name, options, src_full_uri)
test.log.debug("Start migration: %s", cmd)
runner_on_target = remote.RemoteRunner(
host=params.get("remote_ip"),
username=params.get("remote_user"),
password=params.get("remote_pwd"))
cmd_result = remote.run_remote_cmd(cmd, params, runner_on_target)
test.log.info(cmd_result)
if cmd_result.exit_status:
destroy_cmd = "virsh destroy %s" % vm_name
remote.run_remote_cmd(destroy_cmd,
params,
runner_on_target,
ignore_status=False)
test.fail("Failed to run '%s' on remote: %s" % (cmd, cmd_result))
else:
test.log.debug("No need to migrate back")
def run(test, params, env):
"""
Test command virsh cpu-models
"""
cpu_arch = params.get("cpu_arch", "")
option = params.get("option", "")
status_error = "yes" == params.get("status_error", "no")
remote_ref = params.get("remote_ref", "")
connect_uri = libvirt_vm.normalize_connect_uri(
params.get("connect_uri", "default"))
if remote_ref == "remote":
remote_ip = params.get("remote_ip", "REMOTE.EXAMPLE.COM")
remote_pwd = params.get("remote_pwd", None)
if 'EXAMPLE.COM' in remote_ip:
test.cancel("Please replace '%s' with valid remote ip" % remote_ip)
ssh_key.setup_ssh_key(remote_ip, "root", remote_pwd)
connect_uri = libvirt_vm.complete_uri(remote_ip)
arch_list = []
if not cpu_arch:
try:
capa = capability_xml.CapabilityXML()
guest_map = capa.get_guest_capabilities()
guest_arch = []
for v in list(itervalues(guest_map)):
guest_arch += list(v.keys())
for arch in set(guest_arch):
arch_list.append(arch)
except Exception as e:
test.error("Fail to get guest arch list of the host"
" supported:\n%s" % e)
else:
arch_list.append(cpu_arch)
for arch in arch_list:
logging.debug("Get the CPU models for arch: %s" % arch)
result = virsh.cpu_models(arch,
options=option,
uri=connect_uri,
ignore_status=True,
debug=True)
utlv.check_exit_status(result, expect_error=status_error)
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
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
def run(test, params, env):
"""
Test command virsh cpu-models
"""
cpu_arch = params.get("cpu_arch", "")
option = params.get("option", "")
status_error = "yes" == params.get("status_error", "no")
remote_ref = params.get("remote_ref", "")
connect_uri = libvirt_vm.normalize_connect_uri(params.get("connect_uri",
"default"))
if remote_ref == "remote":
remote_ip = params.get("remote_ip", "REMOTE.EXAMPLE.COM")
remote_pwd = params.get("remote_pwd", None)
if 'EXAMPLE.COM' in remote_ip:
test.cancel("Please replace '%s' with valid remote ip" % remote_ip)
ssh_key.setup_ssh_key(remote_ip, "root", remote_pwd)
connect_uri = libvirt_vm.complete_uri(remote_ip)
arch_list = []
if not cpu_arch:
try:
capa = capability_xml.CapabilityXML()
guest_map = capa.get_guest_capabilities()
guest_arch = []
for v in list(itervalues(guest_map)):
guest_arch += list(v.keys())
for arch in set(guest_arch):
arch_list.append(arch)
except Exception as e:
test.error("Fail to get guest arch list of the host"
" supported:\n%s" % e)
else:
arch_list.append(cpu_arch)
for arch in arch_list:
logging.debug("Get the CPU models for arch: %s" % arch)
result = virsh.cpu_models(arch, options=option, uri=connect_uri,
ignore_status=True, debug=True)
utlv.check_exit_status(result, expect_error=status_error)
def remote_test(remote_ip, local_ip, remote_pwd, remote_prompt, vm_name,
status_error_test):
"""
Test remote case
"""
err = ""
status = 1
status_error = status_error_test
try:
remote_uri = libvirt_vm.complete_uri(local_ip)
session = remote.remote_login("ssh", remote_ip, "22", "root",
remote_pwd, remote_prompt)
session.cmd_output('LANG=C')
command = "virsh -c %s setvcpus %s 1 --live" % (remote_uri, vm_name)
status, output = session.cmd_status_output(command, internal_timeout=5)
session.close()
if status != 0:
err = output
except process.CmdError:
status = 1
err = "remote test failed"
return status, status_error, err
def remote_test(remote_ip, local_ip, remote_pwd, remote_prompt, vm_name):
"""
Test remote case
"""
err = ""
try:
remote_uri = libvirt_vm.complete_uri(local_ip)
session = remote.remote_login("ssh", remote_ip, "22",
"root", remote_pwd, remote_prompt)
session.cmd_output('LANG=C')
command = "virsh -c %s setvcpus %s 1 --live" % (remote_uri, vm_name)
if virsh.has_command_help_match(command, "--live") is None:
status_error = "yes"
status, output = session.cmd_status_output(command, internal_timeout=5)
session.close()
if status != 0:
err = output
except error.CmdError:
status = 1
status_error = "yes"
err = "remote test failed"
return status, status_error, err
def run(test, params, env):
"""
Test virsh migrate command.
"""
def set_feature(vmxml, feature, value):
"""
Set guest features for PPC
:param state: the htm status
:param vmxml: guest xml
"""
features_xml = vm_xml.VMFeaturesXML()
if feature == 'hpt':
features_xml.hpt_resizing = value
elif feature == 'htm':
features_xml.htm = value
vmxml.features = features_xml
vmxml.sync()
def trigger_hpt_resize(session):
"""
Check the HPT order file and dmesg
:param session: the session to guest
:raise: test.fail if required message is not found
"""
hpt_order_path = "/sys/kernel/debug/powerpc/hpt_order"
hpt_order = session.cmd_output('cat %s' % hpt_order_path).strip()
hpt_order = int(hpt_order)
logging.info('Current hpt_order is %d', hpt_order)
hpt_order += 1
cmd = 'echo %d > %s' % (hpt_order, hpt_order_path)
cmd_result = session.cmd_status_output(cmd)
result = process.CmdResult(stderr=cmd_result[1],
stdout=cmd_result[1],
exit_status=cmd_result[0])
libvirt.check_exit_status(result)
dmesg = session.cmd('dmesg')
dmesg_content = params.get('dmesg_content').split('|')
for content in dmesg_content:
if content % hpt_order not in dmesg:
test.fail("'%s' is missing in dmesg" % (content % hpt_order))
else:
logging.info("'%s' is found in dmesg", content % hpt_order)
def check_qemu_cmd_line(content, err_ignore=False):
"""
Check the specified content in the qemu command line
:param content: the desired string to search
:param err_ignore: True to return False when fail
False to raise exception when fail
:return: True if exist, False otherwise
"""
cmd = 'ps -ef|grep qemu|grep -v grep'
qemu_line = results_stdout_52lts(process.run(cmd, shell=True))
if content not in qemu_line:
if err_ignore:
return False
else:
test.fail("Expected '%s' was not found in "
"qemu command line" % content)
return True
def check_vm_network_accessed(session=None):
"""
The operations to the VM need to be done before or after
migration happens
:param session: The session object to the host
:raise: test.error when ping fails
"""
# Confirm local/remote VM can be accessed through network.
logging.info("Check VM network connectivity")
s_ping, _ = utils_test.ping(vm.get_address(),
count=10,
timeout=20,
output_func=logging.debug,
session=session)
if s_ping != 0:
if session:
session.close()
test.fail("%s did not respond after %d sec." % (vm.name, 20))
def check_virsh_command_and_option(command, option=None):
"""
Check if virsh command exists
:param command: the command to be checked
:param option: the command option to be checked
"""
msg = "This version of libvirt does not support "
if not virsh.has_help_command(command):
test.cancel(msg + "virsh command '%s'" % command)
if option and not virsh.has_command_help_match(command, option):
test.cancel(msg + "virsh command '%s' with option '%s'" %
(command, option))
def add_ctrls(vm_xml, dev_type="pci", dev_index="0", dev_model="pci-root"):
"""
Add multiple devices
:param dev_type: the type of the device to be added
:param dev_index: the maximum index of the device to be added
:param dev_model: the model of the device to be added
"""
for inx in range(0, int(dev_index) + 1):
newcontroller = Controller("controller")
newcontroller.type = dev_type
newcontroller.index = inx
newcontroller.model = dev_model
logging.debug("New device is added:\n%s", newcontroller)
vm_xml.add_device(newcontroller)
vm_xml.sync()
def do_migration(vm, dest_uri, options, extra):
"""
Execute the migration with given parameters
:param vm: the guest to be migrated
:param dest_uri: the destination uri for migration
:param options: options next to 'migrate' command
:param extra: options in the end of the migrate command line
:return: CmdResult object
"""
logging.info("Sleeping 10 seconds before migration")
time.sleep(10)
# Migrate the guest.
migration_res = vm.migrate(dest_uri, options, extra, **virsh_args)
logging.info("Migration out: %s",
results_stdout_52lts(migration_res).strip())
logging.info("Migration error: %s",
results_stderr_52lts(migration_res).strip())
if int(migration_res.exit_status) != 0:
logging.error("Migration failed for %s.", vm_name)
return migration_res
if vm.is_alive(): # vm.connect_uri was updated
logging.info("VM is alive on destination %s.", dest_uri)
else:
test.fail("VM is not alive on destination %s" % dest_uri)
# Throws exception if console shows panic message
vm.verify_kernel_crash()
return migration_res
def cleanup_libvirtd_log(log_file):
"""
Remove existing libvirtd log file on source and target host.
:param log_file: log file with absolute path
"""
if os.path.exists(log_file):
logging.debug("Delete local libvirt log file '%s'", log_file)
os.remove(log_file)
cmd = "rm -f %s" % log_file
logging.debug("Delete remote libvirt log file '%s'", log_file)
run_remote_cmd(cmd)
def cleanup_dest(vm):
"""
Clean up the destination host environment
when doing the uni-direction migration.
:param vm: the guest to be cleaned up
"""
logging.info("Cleaning up VMs on %s", vm.connect_uri)
try:
if virsh.domain_exists(vm.name, uri=vm.connect_uri):
vm_state = vm.state()
if vm_state == "paused":
vm.resume()
elif vm_state == "shut off":
vm.start()
vm.destroy(gracefully=False)
if vm.is_persistent():
vm.undefine()
except Exception as detail:
logging.error("Cleaning up destination failed.\n%s", detail)
def run_remote_cmd(cmd):
"""
A function to run a command on remote host.
:param cmd: the command to be executed
:return: CmdResult object
"""
remote_runner = remote.RemoteRunner(host=server_ip,
username=server_user,
password=server_pwd)
cmdResult = remote_runner.run(cmd, ignore_status=True)
if cmdResult.exit_status:
test.fail("Failed to run '%s' on remote: %s" %
(cmd, results_stderr_52lts(cmdResult).strip()))
return cmdResult
def run_stress_in_vm():
"""
The function to load stress in VM
"""
stress_args = params.get(
"stress_args", "--cpu 8 --io 4 "
"--vm 2 --vm-bytes 128M "
"--timeout 20s")
try:
vm_session.cmd('stress %s' % stress_args)
except Exception as detail:
logging.debug(detail)
def check_timeout_postcopy(params):
"""
Check the vm state on target host after timeout
when --postcopy and --timeout-postcopy are used.
The vm state is expected as running.
:param params: the parameters used
"""
timeout = int(params.get("timeout_postcopy", 10))
time.sleep(timeout + 1)
remote_virsh_session = virsh.VirshPersistent(**remote_virsh_dargs)
vm_state = results_stdout_52lts(
remote_virsh_session.domstate(vm_name)).strip()
if vm_state != "running":
remote_virsh_session.close_session()
test.fail(
"After timeout '%s' seconds, "
"the vm state on target host should "
"be 'running', but '%s' found", timeout, vm_state)
remote_virsh_session.close_session()
def get_usable_compress_cache(pagesize):
"""
Get a number which is bigger than pagesize and is power of two.
:param pagesize: the given integer
:return: an integer satisfying the criteria
"""
def calculate(num):
result = num & (num - 1)
return (result == 0)
item = pagesize
found = False
while (not found):
item += 1
found = calculate(item)
logging.debug(
"%d is smallest one that is bigger than '%s' and "
"is power of 2", item, pagesize)
return item
check_parameters(test, params)
# Params for NFS shared storage
shared_storage = params.get("migrate_shared_storage", "")
if shared_storage == "":
default_guest_asset = defaults.get_default_guest_os_info()['asset']
default_guest_asset = "%s.qcow2" % default_guest_asset
shared_storage = os.path.join(params.get("nfs_mount_dir"),
default_guest_asset)
logging.debug("shared_storage:%s", shared_storage)
# params for migration connection
params["virsh_migrate_desturi"] = libvirt_vm.complete_uri(
params.get("migrate_dest_host"))
# Params to update disk using shared storage
params["disk_type"] = "file"
params["disk_source_protocol"] = "netfs"
params["mnt_path_name"] = params.get("nfs_mount_dir")
# Local variables
virsh_args = {"ignore_status": True, "debug": True}
server_ip = params.get("server_ip")
server_user = params.get("server_user", "root")
server_pwd = params.get("server_pwd")
extra = params.get("virsh_migrate_extra")
options = params.get("virsh_migrate_options")
src_uri = params.get("virsh_migrate_connect_uri")
dest_uri = params.get("virsh_migrate_desturi")
log_file = params.get("libvirt_log", "/var/log/libvirt/libvirtd.log")
check_complete_job = "yes" == params.get("check_complete_job", "no")
config_libvirtd = "yes" == params.get("config_libvirtd", "no")
contrl_index = params.get("new_contrl_index", None)
grep_str_remote_log = params.get("grep_str_remote_log", "")
grep_str_local_log = params.get("grep_str_local_log", "")
stress_in_vm = "yes" == params.get("stress_in_vm", "no")
remote_virsh_dargs = {
'remote_ip': server_ip,
'remote_user': server_user,
'remote_pwd': server_pwd,
'unprivileged_user': None,
'ssh_remote_auth': True
}
hpt_resize = params.get("hpt_resize", None)
htm_state = params.get("htm_state", None)
qemu_check = params.get("qemu_check", None)
xml_check_after_mig = params.get("guest_xml_check_after_mig", None)
arch = platform.machine()
if any([hpt_resize, contrl_index, htm_state]) and 'ppc64' not in arch:
test.cancel("The case is PPC only.")
# For TLS
tls_recovery = params.get("tls_auto_recovery", "yes")
# qemu config
qemu_conf_dict = None
# libvirtd config
libvirtd_conf_dict = None
remote_virsh_session = None
vm = None
vm_session = None
libvirtd_conf = None
qemu_conf = None
mig_result = None
test_exception = None
is_TestError = False
is_TestFail = False
is_TestSkip = False
asynch_migration = False
# Objects to be cleaned up in the end
objs_list = []
tls_obj = None
# Local variables
vm_name = params.get("migrate_main_vm")
vm = env.get_vm(vm_name)
vm.verify_alive()
# For safety reasons, we'd better back up xmlfile.
new_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
orig_config_xml = new_xml.copy()
if not orig_config_xml:
test.error("Backing up xmlfile failed.")
try:
# Change VM xml in below part
if contrl_index:
new_xml.remove_all_device_by_type('controller')
logging.debug("After removing controllers, current XML:\n%s\n",
new_xml)
add_ctrls(new_xml, dev_index=contrl_index)
if extra.count("--tls"):
qemu_conf_dict = {"migrate_tls_x509_verify": "1"}
# Setup TLS
tls_obj = TLSConnection(params)
if tls_recovery == "yes":
objs_list.append(tls_obj)
tls_obj.auto_recover = True
tls_obj.conn_setup()
# Setup qemu configure
logging.debug("Configure the qemu")
cleanup_libvirtd_log(log_file)
qemu_conf = libvirt.customize_libvirt_config(qemu_conf_dict,
config_type="qemu",
remote_host=True,
extra_params=params)
# Setup libvirtd
if config_libvirtd:
logging.debug("Configure the libvirtd")
cleanup_libvirtd_log(log_file)
libvirtd_conf_dict = setup_libvirtd_conf_dict(params)
libvirtd_conf = libvirt.customize_libvirt_config(
libvirtd_conf_dict, remote_host=True, extra_params=params)
if hpt_resize:
set_feature(new_xml, 'hpt', hpt_resize)
if htm_state:
set_feature(new_xml, 'htm', htm_state)
# Change the disk of the vm to shared disk and then start VM
libvirt.set_vm_disk(vm, params)
if not vm.is_alive():
vm.start()
logging.debug("Guest xml after starting:\n%s",
vm_xml.VMXML.new_from_dumpxml(vm_name))
if qemu_check:
check_content = qemu_check
if hpt_resize:
check_content = "%s%s" % (qemu_check, hpt_resize)
if htm_state:
check_content = "%s%s" % (qemu_check, htm_state)
check_qemu_cmd_line(check_content)
vm_session = vm.wait_for_login()
check_vm_network_accessed()
if hpt_resize and hpt_resize != 'disabled':
trigger_hpt_resize(vm_session)
if stress_in_vm:
pkg_name = 'stress'
logging.debug("Check if stress tool is installed")
pkg_mgr = utils_package.package_manager(vm_session, pkg_name)
if not pkg_mgr.is_installed(pkg_name):
logging.debug("Stress tool will be installed")
if not pkg_mgr.install():
test.error("Package '%s' installation fails" % pkg_name)
stress_thread = threading.Thread(target=run_stress_in_vm, args=())
stress_thread.start()
if extra.count("timeout-postcopy"):
asynch_migration = True
func_name = check_timeout_postcopy
if extra.count("comp-xbzrle-cache"):
cache = get_usable_compress_cache(memory.get_page_size())
extra = "%s %s" % (extra, cache)
# For --postcopy enable
postcopy_options = params.get("postcopy_options")
if postcopy_options and not extra.count(postcopy_options):
extra = "%s %s" % (extra, postcopy_options)
if not asynch_migration:
mig_result = do_migration(vm, dest_uri, options, extra)
else:
migration_test = libvirt.MigrationTest()
logging.debug("vm.connect_uri=%s", vm.connect_uri)
vms = [vm]
try:
migration_test.do_migration(vms,
None,
dest_uri,
'orderly',
options,
thread_timeout=900,
ignore_status=True,
func=func_name,
extra_opts=extra,
func_params=params)
mig_result = migration_test.ret
except exceptions.TestFail as fail_detail:
test.fail(fail_detail)
except exceptions.TestSkipError as skip_detail:
test.cancel(skip_detail)
except exceptions.TestError as error_detail:
test.error(error_detail)
except Exception as details:
mig_result = migration_test.ret
logging.error(details)
if int(mig_result.exit_status) != 0:
test.fail(results_stderr_52lts(mig_result).strip())
if check_complete_job:
search_str_domjobinfo = params.get("search_str_domjobinfo", None)
opts = "--completed"
args = vm_name + " " + opts
check_virsh_command_and_option("domjobinfo", opts)
jobinfo = results_stdout_52lts(
virsh.domjobinfo(args, debug=True,
ignore_status=True)).strip()
logging.debug("Local job info on completion:\n%s", jobinfo)
if extra.count("comp-xbzrle-cache") and search_str_domjobinfo:
search_str_domjobinfo = "%s %s" % (search_str_domjobinfo,
cache // 1024)
if search_str_domjobinfo:
if not re.search(search_str_domjobinfo, jobinfo):
test.fail("Fail to search '%s' on local:\n%s" %
(search_str_domjobinfo, jobinfo))
# Check remote host
if not remote_virsh_session:
remote_virsh_session = virsh.VirshPersistent(
**remote_virsh_dargs)
jobinfo = results_stdout_52lts(
remote_virsh_session.domjobinfo(args,
debug=True,
ignore_status=True)).strip()
logging.debug("Remote job info on completion:\n%s", jobinfo)
if search_str_domjobinfo:
if not re.search(search_str_domjobinfo, jobinfo):
remote_virsh_session.close_session()
test.fail("Fail to search '%s' on remote:\n%s" %
(search_str_domjobinfo, jobinfo))
remote_virsh_session.close_session()
if grep_str_local_log:
cmd = "grep -E '%s' %s" % (grep_str_local_log, log_file)
cmdRes = process.run(cmd, shell=True, ignore_status=True)
if cmdRes.exit_status:
test.fail(results_stderr_52lts(cmdRes).strip())
if grep_str_remote_log:
cmd = "grep -E '%s' %s" % (grep_str_remote_log, log_file)
run_remote_cmd(cmd)
if xml_check_after_mig:
if not remote_virsh_session:
remote_virsh_session = virsh.VirshPersistent(
**remote_virsh_dargs)
target_guest_dumpxml = results_stdout_52lts(
remote_virsh_session.dumpxml(vm_name,
debug=True,
ignore_status=True)).strip()
if hpt_resize:
check_str = hpt_resize
elif htm_state:
check_str = htm_state
if hpt_resize or htm_state:
xml_check_after_mig = "%s'%s'" % (xml_check_after_mig,
check_str)
if not re.search(xml_check_after_mig, target_guest_dumpxml):
remote_virsh_session.close_session()
test.fail("Fail to search '%s' in target guest XML:\n%s" %
(xml_check_after_mig, target_guest_dumpxml))
if contrl_index:
all_ctrls = re.findall(xml_check_after_mig,
target_guest_dumpxml)
if len(all_ctrls) != int(contrl_index) + 1:
remote_virsh_session.close_session()
test.fail(
"%s pci-root controllers are expected in guest XML, "
"but found %s" %
(int(contrl_index) + 1, len(all_ctrls)))
remote_virsh_session.close_session()
server_session = remote.wait_for_login('ssh', server_ip, '22',
server_user, server_pwd,
r"[\#\$]\s*$")
check_vm_network_accessed(server_session)
server_session.close()
except exceptions.TestFail as details:
is_TestFail = True
test_exception = details
except exceptions.TestSkipError as details:
is_TestSkip = True
test_exception = details
except exceptions.TestError as details:
is_TestError = True
test_exception = details
except Exception as details:
test_exception = details
finally:
logging.debug("Recover test environment")
try:
# Clean VM on destination
vm.connect_uri = dest_uri
cleanup_dest(vm)
vm.connect_uri = src_uri
logging.info("Recovery VM XML configration")
orig_config_xml.sync()
logging.debug("The current VM XML:\n%s",
orig_config_xml.xmltreefile)
if remote_virsh_session:
remote_virsh_session.close_session()
if extra.count("--tls"):
logging.debug("Recover the qemu configuration")
libvirt.customize_libvirt_config(None,
config_type="qemu",
remote_host=True,
extra_params=params,
is_recover=True,
config_object=qemu_conf)
if config_libvirtd:
logging.debug("Recover the libvirtd configuration")
libvirt.customize_libvirt_config(None,
remote_host=True,
extra_params=params,
is_recover=True,
config_object=libvirtd_conf)
logging.info("Remove local NFS image")
source_file = params.get("source_file")
libvirt.delete_local_disk("file", path=source_file)
if objs_list:
for obj in objs_list:
logging.debug("Clean up local objs")
del obj
except Exception as exception_detail:
if (not test_exception and not is_TestError and not is_TestFail
and not is_TestSkip):
raise exception_detail
else:
# if any of above exceptions has been raised, only print
# error log here to avoid of hiding the original issue
logging.error(exception_detail)
# Check result
if is_TestFail:
test.fail(test_exception)
if is_TestSkip:
test.cancel(test_exception)
if is_TestError:
test.error(test_exception)
if not test_exception:
logging.info("Case execution is done.")
else:
test.error(test_exception)
def run(test, params, env):
"""
Test migration with glusterfs.
"""
def create_or_clean_backend_dir(g_uri,
params,
session=None,
is_clean=False):
"""
Create/cleanup backend directory
:params g_uri: glusterfs uri
:params params: the parameters to be checked
:params session: VM/remote session object
:params is_cleanup: True for cleanup backend directory;
False for create one.
:return: gluster_img if is_clean is equal to True
"""
mount_point = params.get("gluster_mount_dir")
is_symlink = params.get("gluster_create_symlink") == "yes"
symlink_name = params.get("gluster_symlink")
gluster_img = None
if not is_clean:
if not utils_misc.check_exists(mount_point, session):
utils_misc.make_dirs(mount_point, session)
if gluster.glusterfs_is_mounted(mount_point, session):
gluster.glusterfs_umount(g_uri, mount_point, session)
gluster.glusterfs_mount(g_uri, mount_point, session)
gluster_img = os.path.join(mount_point, disk_img)
if is_symlink:
utils_misc.make_symlink(mount_point, symlink_name)
utils_misc.make_symlink(mount_point, symlink_name,
remote_session)
gluster_img = os.path.join(symlink_name, disk_img)
return gluster_img
else:
if is_symlink:
utils_misc.rm_link(symlink_name, session)
gluster.glusterfs_umount(g_uri, mount_point, session)
if utils_misc.check_exists(mount_point, session):
utils_misc.safe_rmdir(gluster_mount_dir, session=session)
# Local variables
virsh_args = {"debug": True}
server_ip = params["server_ip"] = params.get("remote_ip")
server_user = params["server_user"] = params.get("remote_user", "root")
server_pwd = params["server_pwd"] = params.get("remote_pwd")
client_ip = params["client_ip"] = params.get("local_ip")
client_pwd = params["client_pwd"] = params.get("local_pwd")
extra = params.get("virsh_migrate_extra")
options = params.get("virsh_migrate_options", "--live --p2p --verbose")
virsh_options = params.get("virsh_options", "")
vol_name = params.get("vol_name")
disk_format = params.get("disk_format", "qcow2")
gluster_mount_dir = params.get("gluster_mount_dir")
status_error = "yes" == params.get("status_error", "no")
err_msg = params.get("err_msg")
host_ip = params.get("gluster_server_ip", "")
migrate_vm_back = params.get("migrate_vm_back", "no") == "yes"
selinux_local = params.get('set_sebool_local', 'yes') == "yes"
selinux_remote = params.get('set_sebool_remote', 'no') == "yes"
sebool_fusefs_local = params.get('set_sebool_fusefs_local', 'yes')
sebool_fusefs_remote = params.get('set_sebool_fusefs_remote', 'yes')
test_dict = dict(params)
test_dict["local_boolean_varible"] = "virt_use_fusefs"
test_dict["remote_boolean_varible"] = "virt_use_fusefs"
remote_dargs = {
'server_ip': server_ip,
'server_user': server_user,
'server_pwd': server_pwd,
'file_path': "/etc/libvirt/libvirt.conf"
}
remove_pkg = False
seLinuxBool = None
seLinuxfusefs = None
gluster_uri = None
mig_result = None
remove_dict = {}
remote_libvirt_file = None
src_libvirt_file = None
# Make sure all of parameters are assigned a valid value
migrate_test = migration.MigrationTest()
migrate_test.check_parameters(params)
extra_args = migrate_test.update_virsh_migrate_extra_args(params)
# params for migration connection
params["virsh_migrate_desturi"] = libvirt_vm.complete_uri(
params.get("migrate_dest_host"))
params["virsh_migrate_connect_uri"] = libvirt_vm.complete_uri(
params.get("migrate_source_host"))
src_uri = params.get("virsh_migrate_connect_uri")
dest_uri = params.get("virsh_migrate_desturi")
# For --postcopy enable
postcopy_options = params.get("postcopy_options")
if postcopy_options:
extra = "%s %s" % (virsh_options, postcopy_options)
func_name = virsh.migrate_postcopy
vm_name = params.get("migrate_main_vm")
vm = env.get_vm(vm_name)
vm.verify_alive()
# Back up xml file.
new_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
orig_config_xml = new_xml.copy()
try:
# Create a remote runner for later use
runner_on_target = remote.RemoteRunner(host=server_ip,
username=server_user,
password=server_pwd)
# Configure selinux
if selinux_local or selinux_remote:
seLinuxBool = utils_misc.SELinuxBoolean(params)
seLinuxBool.setup()
if sebool_fusefs_local or sebool_fusefs_remote:
seLinuxfusefs = utils_misc.SELinuxBoolean(test_dict)
seLinuxfusefs.setup()
# Setup glusterfs
disk_img = "gluster.%s" % disk_format
params['disk_img'] = disk_img
host_ip = gluster.setup_or_cleanup_gluster(is_setup=True, **params)
logging.debug("host ip: %s ", host_ip)
# Check if gluster server is deployed locally
if not host_ip:
logging.debug("Enable port 24007 and 49152:49216")
migrate_test.migrate_pre_setup(src_uri, params, ports="24007")
migrate_test.migrate_pre_setup(src_uri, params)
gluster_uri = "{}:{}".format(client_ip, vol_name)
else:
gluster_uri = "{}:{}".format(host_ip, vol_name)
remote_session = remote.wait_for_login('ssh', server_ip, '22',
server_user, server_pwd,
r"[\#\$]\s*$")
if gluster_mount_dir:
# The package 'glusterfs-fuse' is not installed on target
# which makes issue when trying to 'mount -t glusterfs'
pkg_name = 'glusterfs-fuse'
logging.debug("Check if glusterfs-fuse is installed")
pkg_mgr = utils_package.package_manager(remote_session, pkg_name)
if not pkg_mgr.is_installed(pkg_name):
logging.debug("glusterfs-fuse will be installed")
if not pkg_mgr.install():
test.error("Package '%s' installation fails" % pkg_name)
else:
remove_pkg = True
gluster_img = create_or_clean_backend_dir(gluster_uri, params)
create_or_clean_backend_dir(gluster_uri, params, remote_session)
# Get the image path
image_source = vm.get_first_disk_devices()['source']
image_info = utils_misc.get_image_info(image_source)
if image_info["format"] == disk_format:
disk_cmd = "cp -f %s %s" % (image_source, gluster_img)
else:
# Convert the disk format
disk_cmd = ("qemu-img convert -f %s -O %s %s %s" %
(image_info["format"], disk_format, image_source,
gluster_img))
process.run("%s; chmod a+rw %s" % (disk_cmd, gluster_mount_dir),
shell=True)
logging.debug("Gluster Image is %s", gluster_img)
gluster_backend_disk = {'disk_source_name': gluster_img}
# Update disk xml with gluster image in backend dir
libvirt.set_vm_disk(vm, gluster_backend_disk)
remote_session.close()
vm_xml_cxt = virsh.dumpxml(vm_name).stdout_text.strip()
logging.debug("The VM XML with gluster disk source: \n%s", vm_xml_cxt)
vm.wait_for_login().close()
migrate_test.ping_vm(vm, params)
remove_dict = {"do_search": '{"%s": "ssh:/"}' % dest_uri}
src_libvirt_file = libvirt_config.remove_key_for_modular_daemon(
remove_dict)
vms = [vm]
migrate_test.do_migration(vms,
None,
dest_uri,
'orderly',
options,
thread_timeout=900,
ignore_status=True,
virsh_opt=virsh_options,
extra_opts=extra,
**extra_args)
migrate_test.ping_vm(vm, params, dest_uri)
if migrate_vm_back:
ssh_connection = utils_conn.SSHConnection(server_ip=client_ip,
server_pwd=client_pwd,
client_ip=server_ip,
client_pwd=server_pwd)
try:
ssh_connection.conn_check()
except utils_conn.ConnectionError:
ssh_connection.conn_setup()
ssh_connection.conn_check()
# Pre migration setup for local machine
migrate_test.migrate_pre_setup(src_uri, params)
remove_dict = {"do_search": ('{"%s": "ssh:/"}' % src_uri)}
remote_libvirt_file = libvirt_config\
.remove_key_for_modular_daemon(remove_dict, remote_dargs)
cmd = "virsh migrate %s %s %s %s" % (vm_name, options,
virsh_options, src_uri)
logging.debug("Start migrating: %s", cmd)
cmd_result = remote.run_remote_cmd(cmd, params, runner_on_target)
logging.info(cmd_result)
if cmd_result.exit_status:
destroy_cmd = "virsh destroy %s" % vm_name
remote.run_remote_cmd(destroy_cmd,
params,
runner_on_target,
ignore_status=False)
test.fail("Failed to run '%s' on remote: %s" %
(cmd, cmd_result))
finally:
logging.info("Recover test environment")
migrate_test.cleanup_vm(vm, dest_uri)
orig_config_xml.sync()
if src_libvirt_file:
src_libvirt_file.restore()
if remote_libvirt_file:
del remote_libvirt_file
# Clean up of pre migration setup for local machine
if migrate_vm_back:
if 'ssh_connection' in locals():
ssh_connection.auto_recover = True
migrate_test.migrate_pre_setup(src_uri, params, cleanup=True)
# Cleanup selinu configuration
if seLinuxBool:
seLinuxBool.cleanup()
if seLinuxfusefs:
seLinuxfusefs.cleanup()
# Disable ports 24007 and 49152:49216
if not host_ip:
logging.debug("Disable 24007 and 49152:49216 in Firewall")
migrate_test.migrate_pre_setup(src_uri,
params,
cleanup=True,
ports="24007")
migrate_test.migrate_pre_setup(src_uri, params, cleanup=True)
gluster.setup_or_cleanup_gluster(False, **params)
# Cleanup backend directory/symlink
if gluster_mount_dir and gluster_uri:
remote_session = remote.wait_for_login('ssh', server_ip, '22',
server_user, server_pwd,
r"[\#\$]\s*$")
create_or_clean_backend_dir(gluster_uri, params, is_clean=True)
create_or_clean_backend_dir(gluster_uri, params, remote_session,
True)
if remove_pkg:
pkg_mgr = utils_package.package_manager(
remote_session, pkg_name)
if pkg_mgr.is_installed(pkg_name):
logging.debug("glusterfs-fuse will be uninstalled")
if not pkg_mgr.remove():
logging.error("Package '%s' un-installation fails",
pkg_name)
remote_session.close()
def run(test, params, env):
"""
Test virsh undefine command.
Undefine an inactive domain, or convert persistent to transient.
1.Prepare test environment.
2.Backup the VM's information to a xml file.
3.When the libvirtd == "off", stop the libvirtd service.
4.Perform virsh undefine operation.
5.Recover test environment.(libvirts service,VM)
6.Confirm the test result.
"""
vm_ref = params.get("undefine_vm_ref", "vm_name")
extra = params.get("undefine_extra", "")
option = params.get("undefine_option", "")
libvirtd_state = params.get("libvirtd", "on")
status_error = ("yes" == params.get("status_error", "no"))
undefine_twice = ("yes" == params.get("undefine_twice", 'no'))
local_ip = params.get("local_ip", "LOCAL.EXAMPLE.COM")
local_pwd = params.get("local_pwd", "password")
remote_ip = params.get("remote_ip", "REMOTE.EXAMPLE.COM")
remote_user = params.get("remote_user", "user")
remote_pwd = params.get("remote_pwd", "password")
remote_prompt = params.get("remote_prompt", "#")
pool_type = params.get("pool_type")
pool_name = params.get("pool_name", "test")
pool_target = params.get("pool_target")
volume_size = params.get("volume_size", "1G")
vol_name = params.get("vol_name", "test_vol")
emulated_img = params.get("emulated_img", "emulated_img")
emulated_size = "%sG" % (int(volume_size[:-1]) + 1)
disk_target = params.get("disk_target", "vdb")
wipe_data = "yes" == params.get("wipe_data", "no")
if wipe_data:
option += " --wipe-storage"
nvram_o = None
if platform.machine() == 'aarch64':
nvram_o = " --nvram"
option += nvram_o
vm_name = params.get("main_vm", "avocado-vt-vm1")
vm = env.get_vm(vm_name)
vm_id = vm.get_id()
vm_uuid = vm.get_uuid()
# polkit acl related params
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':
test.cancel("API acl test not supported in current"
" libvirt version.")
# Back up xml file.Xen host has no guest xml file to define a guset.
backup_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
# Confirm how to reference a VM.
if vm_ref == "vm_name":
vm_ref = vm_name
elif vm_ref == "id":
vm_ref = vm_id
elif vm_ref == "hex_vm_id":
vm_ref = hex(int(vm_id))
elif vm_ref == "uuid":
vm_ref = vm_uuid
elif vm_ref.find("invalid") != -1:
vm_ref = params.get(vm_ref)
volume = None
pvtest = None
status3 = None
elems = backup_xml.xmltreefile.findall('/devices/disk/source')
existing_images = [elem.get('file') for elem in elems]
# Backup images since remove-all-storage could remove existing libvirt
# managed guest images
if existing_images and option.count("remove-all-storage"):
for img in existing_images:
backup_img = img + '.bak'
logging.info('Backup %s to %s', img, backup_img)
shutil.copyfile(img, backup_img)
try:
save_file = "/var/lib/libvirt/qemu/save/%s.save" % vm_name
if option.count("managedsave") and vm.is_alive():
virsh.managedsave(vm_name)
if not vm.is_lxc():
snp_list = virsh.snapshot_list(vm_name)
if option.count("snapshot"):
snp_file_list = []
if not len(snp_list):
virsh.snapshot_create(vm_name)
logging.debug("Create a snapshot for test!")
else:
# Backup snapshots for domain
for snp_item in snp_list:
tmp_file = os.path.join(data_dir.get_tmp_dir(), snp_item + ".xml")
virsh.snapshot_dumpxml(vm_name, snp_item, to_file=tmp_file)
snp_file_list.append(tmp_file)
else:
if len(snp_list):
test.cancel("This domain has snapshot(s), "
"cannot be undefined!")
if option.count("remove-all-storage"):
pvtest = utlv.PoolVolumeTest(test, params)
pvtest.pre_pool(pool_name, pool_type, pool_target, emulated_img,
emulated_size=emulated_size)
new_pool = libvirt_storage.PoolVolume(pool_name)
if not new_pool.create_volume(vol_name, volume_size):
test.fail("Creation of volume %s failed." % vol_name)
volumes = new_pool.list_volumes()
volume = volumes[vol_name]
virsh.attach_disk(vm_name, volume, disk_target, "--config")
# Turn libvirtd into certain state.
if libvirtd_state == "off":
utils_libvirtd.libvirtd_stop()
# Test virsh undefine command.
output = ""
if vm_ref != "remote":
vm_ref = "%s %s" % (vm_ref, extra)
cmdresult = virsh.undefine(vm_ref, option,
unprivileged_user=unprivileged_user,
uri=uri,
ignore_status=True, debug=True)
status = cmdresult.exit_status
output = cmdresult.stdout.strip()
if status:
logging.debug("Error status, command output: %s",
cmdresult.stderr.strip())
if undefine_twice:
status2 = virsh.undefine(vm_ref, nvram_o,
ignore_status=True).exit_status
else:
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")
try:
local_user = params.get("username", "root")
uri = libvirt_vm.complete_uri(local_ip)
# setup ssh auto login from remote machine to test machine
# for the command to execute remotely
ssh_key.setup_remote_ssh_key(remote_ip, remote_user,
remote_pwd, hostname2=local_ip,
user2=local_user,
password2=local_pwd)
session = remote.remote_login("ssh", remote_ip, "22",
remote_user, remote_pwd,
remote_prompt)
cmd_undefine = "virsh -c %s undefine %s" % (uri, vm_name)
status, output = session.cmd_status_output(cmd_undefine)
logging.info("Undefine output: %s", output)
except (process.CmdError, remote.LoginError, aexpect.ShellError) as de:
logging.error("Detail: %s", de)
status = 1
# Recover libvirtd state.
if libvirtd_state == "off":
utils_libvirtd.libvirtd_start()
# Shutdown VM.
if virsh.domain_exists(vm.name):
try:
if vm.is_alive():
vm.destroy(gracefully=False)
except process.CmdError as detail:
logging.error("Detail: %s", detail)
# After vm.destroy, virsh.domain_exists returns True due to
# timing issue and tests fails.
time.sleep(2)
# Check if VM exists.
vm_exist = virsh.domain_exists(vm_name)
# Check if xml file exists.
xml_exist = False
if vm.is_qemu() and os.path.exists("/etc/libvirt/qemu/%s.xml" % vm_name):
xml_exist = True
if vm.is_lxc() and os.path.exists("/etc/libvirt/lxc/%s.xml" % vm_name):
xml_exist = True
if vm.is_xen() and os.path.exists("/etc/xen/%s" % vm_name):
xml_exist = True
# Check if save file exists if use --managed-save
save_exist = os.path.exists(save_file)
# Check if save file exists if use --managed-save
volume_exist = volume and os.path.exists(volume)
# Test define with acl control and recover domain.
if params.get('setup_libvirt_polkit') == 'yes':
if virsh.domain_exists(vm.name):
virsh.undefine(vm_ref, nvram_o, ignore_status=True)
cmd = "chmod 666 %s" % backup_xml.xml
process.run(cmd, ignore_status=False, shell=True)
s_define = virsh.define(backup_xml.xml,
unprivileged_user=unprivileged_user,
uri=uri, ignore_status=True, debug=True)
status3 = s_define.exit_status
finally:
# Recover main VM.
try:
backup_xml.sync()
except LibvirtXMLError:
# sync() tries to undefines and define the xml to sync
# but virsh_undefine test would have undefined already
# may lead to error out
backup_xml.define()
# Recover existing guest images
if existing_images and option.count("remove-all-storage"):
for img in existing_images:
backup_img = img + '.bak'
logging.info('Recover image %s to %s', backup_img, img)
shutil.move(backup_img, img)
# Clean up pool
if pvtest:
pvtest.cleanup_pool(pool_name, pool_type,
pool_target, emulated_img)
# Recover VM snapshots.
if option.count("snapshot") and (not vm.is_lxc()):
logging.debug("Recover snapshots for domain!")
for file_item in snp_file_list:
virsh.snapshot_create(vm_name, file_item)
# Check results.
if status_error:
if not status:
test.fail("virsh undefine return unexpected result.")
if params.get('setup_libvirt_polkit') == 'yes':
if status3 == 0:
test.fail("virsh define with false acl permission" +
" should failed.")
else:
if status:
test.fail("virsh undefine failed.")
if undefine_twice:
if not status2:
test.fail("Undefine the same VM twice succeeded.")
if vm_exist:
test.fail("VM still exists after undefine.")
if xml_exist:
test.fail("Xml file still exists after undefine.")
if option.count("managedsave") and save_exist:
test.fail("Save file still exists after undefine.")
if option.count("remove-all-storage") and volume_exist:
test.fail("Volume file '%s' still exists after"
" undefine." % volume)
if wipe_data and option.count("remove-all-storage"):
if not output.count("Wiping volume '%s'" % disk_target):
test.fail("Command didn't wipe volume storage!")
if params.get('setup_libvirt_polkit') == 'yes':
if status3:
test.fail("virsh define with right acl permission" +
" should succeeded")
def run(test, params, env):
"""
Test virsh migrate command.
"""
def check_vm_network_accessed(session=None, ping_dest="www.baidu.com"):
"""
The operations to the VM need to be done before or after
migration happens
:param session: The session object to the host
:param ping_dest: The destination to be ping
:raise: test.fail when ping fails
"""
# Confirm local/remote VM can be accessed through network.
logging.info("Check VM network connectivity")
status, output = utils_test.ping(ping_dest,
count=10,
timeout=20,
output_func=logging.debug,
session=session)
if status != 0:
test.fail("Ping failed, status: %s,"
" output: %s" % (status, output))
def get_vm_ifaces(session=None):
"""
Get interfaces of vm
:param session: The session object to the host
:return: interfaces
"""
p_iface, v_iface = utils_net.get_remote_host_net_ifs(session)
return p_iface
def check_vm_iface_num(iface_list, exp_num=3):
"""
Check he number of interfaces
:param iface_list: The interface list
:param exp_num: The expected number
:raise: test.fail when interfaces' number is not equal to exp_num
"""
if len(iface_list) != exp_num:
test.fail("%d interfaces should be found on the vm, "
"but find %s." % (exp_num, iface_list))
def create_or_del_networks(pf_name, params, remote_virsh_session=None,
is_del=False):
"""
Create or delete network on local or remote
:param params: Dictionary with the test parameters
:param pf_name: The name of PF
:param remote_virsh_session: The virsh session object to the remote host
:param is_del: Whether the networks should be deleted
:raise: test.fail when fails to define/start network
"""
net_hostdev_name = params.get("net_hostdev_name", "hostdev-net")
net_hostdev_fwd = params.get("net_hostdev_fwd",
'{"mode": "hostdev", "managed": "yes"}')
net_bridge_name = params.get("net_bridge_name", "host-bridge")
net_bridge_fwd = params.get("net_bridge_fwd", '{"mode": "bridge"}')
bridge_name = params.get("bridge_name", "br0")
net_dict = {"net_name": net_hostdev_name,
"net_forward": net_hostdev_fwd,
"net_forward_pf": '{"dev": "%s"}' % pf_name}
bridge_dict = {"net_name": net_bridge_name,
"net_forward": net_bridge_fwd,
"net_bridge": '{"name": "%s"}' % bridge_name}
if not is_del:
for net_params in (net_dict, bridge_dict):
net_dev = libvirt.create_net_xml(net_params.get("net_name"),
net_params)
if not remote_virsh_session:
if net_dev.get_active():
net_dev.undefine()
net_dev.define()
net_dev.start()
else:
remote.scp_to_remote(server_ip, '22', server_user, server_pwd,
net_dev.xml, net_dev.xml, limit="",
log_filename=None, timeout=600,
interface=None)
remote_virsh_session.net_define(net_dev.xml, **virsh_args)
remote_virsh_session.net_start(net_params.get("net_name"),
**virsh_args)
else:
virsh_session = virsh
if remote_virsh_session:
virsh_session = remote_virsh_session
for nname in (net_hostdev_name, net_bridge_name):
if nname not in virsh_session.net_state_dict():
continue
virsh_session.net_destroy(nname, debug=True, ignore_status=True)
virsh_session.net_undefine(nname, debug=True, ignore_status=True)
def check_vm_network_connection(net_name, expected_conn=0):
"""
Check network connections in network xml
:param net_name: The network to be checked
:param expected_conn: The expected value
:raise: test.fail when fails
"""
output = virsh.net_dumpxml(net_name, debug=True).stdout_text
if expected_conn == 0:
reg_pattern = r"<network>"
else:
reg_pattern = r"<network connections='(\d)'>"
res = re.findall(reg_pattern, output, re.I)
if not res:
test.fail("Unable to find expected connection in %s." % net_name)
if expected_conn != 0:
if expected_conn != int(res[0]):
test.fail("Unable to get expected connection number."
"Expected: %s, Actual %s" % (expected_conn, int(res[0])))
def get_hostdev_addr_from_xml():
"""
Get VM hostdev address
:return: pci driver id
"""
address_dict = {}
for ifac in vm_xml.VMXML.new_from_dumpxml(vm_name).devices.by_device_tag("interface"):
if ifac.type_name == "hostdev":
address_dict = ifac.hostdev_address.attrs
return libvirt.pci_info_from_address(address_dict, 16, "id")
def check_vfio_pci(pci_path, status_error=False):
"""
Check if vf driver is vfio-pci
:param pci_path: The absolute path of pci device
:param status_error: Whether the driver should be vfio-pci
"""
cmd = "readlink %s/driver | awk -F '/' '{print $NF}'" % pci_path
output = process.run(cmd, shell=True, verbose=True).stdout_text.strip()
if (output == "vfio-pci") == status_error:
test.fail("Get incorrect dirver %s, it should%s be vfio-pci."
% (output, ' not' if status_error else ''))
def update_iface_xml(vmxml):
"""
Update interfaces for guest
:param vmxml: vm_xml.VMXML object
"""
vmxml.remove_all_device_by_type('interface')
vmxml.sync()
iface_dict = {"type": "network", "source": "{'network': 'host-bridge'}",
"mac": mac_addr, "model": "virtio",
"teaming": '{"type":"persistent"}',
"alias": '{"name": "ua-backup0"}',
"inbound": '{"average":"5"}',
"outbound": '{"average":"5"}'}
iface_dict2 = {"type": "network", "source": "{'network': 'hostdev-net'}",
"mac": mac_addr, "model": "virtio",
"teaming": '{"type":"transient", "persistent": "ua-backup0"}'}
iface = interface.Interface('network')
for ifc in (iface_dict, iface_dict2):
iface.xml = libvirt.modify_vm_iface(vm.name, "get_xml", ifc)
vmxml.add_device(iface)
vmxml.sync()
migration_test = migration.MigrationTest()
migration_test.check_parameters(params)
# Params for NFS shared storage
shared_storage = params.get("migrate_shared_storage", "")
if shared_storage == "":
default_guest_asset = defaults.get_default_guest_os_info()['asset']
default_guest_asset = "%s.qcow2" % default_guest_asset
shared_storage = os.path.join(params.get("nfs_mount_dir"),
default_guest_asset)
logging.debug("shared_storage:%s", shared_storage)
# Params to update disk using shared storage
params["disk_type"] = "file"
params["disk_source_protocol"] = "netfs"
params["mnt_path_name"] = params.get("nfs_mount_dir")
# Local variables
virsh_args = {"debug": True}
virsh_options = params.get("virsh_options", "")
server_ip = params.get("server_ip")
server_user = params.get("server_user", "root")
server_pwd = params.get("server_pwd")
client_ip = params.get("client_ip")
client_pwd = params.get("client_pwd")
extra = params.get("virsh_migrate_extra")
options = params.get("virsh_migrate_options")
bridge_name = params.get("bridge_name", "br0")
net_hostdev_name = params.get("net_hostdev_name", "hostdev-net")
net_bridge_name = params.get("net_bridge_name", "host-bridge")
driver = params.get("driver", "ixgbe")
vm_tmp_file = params.get("vm_tmp_file", "/tmp/test.txt")
cmd_during_mig = params.get("cmd_during_mig")
net_failover_test = "yes" == params.get("net_failover_test", "no")
cancel_migration = "yes" == params.get("cancel_migration", "no")
try:
vf_no = int(params.get("vf_no", "4"))
except ValueError as e:
test.error(e)
migr_vm_back = "yes" == params.get("migrate_vm_back", "no")
err_msg = params.get("err_msg")
status_error = "yes" == params.get("status_error", "no")
cmd_parms = {'server_ip': server_ip, 'server_user': server_user,
'server_pwd': server_pwd}
remote_virsh_dargs = {'remote_ip': server_ip, 'remote_user': server_user,
'remote_pwd': server_pwd, 'unprivileged_user': None,
'ssh_remote_auth': True}
destparams_dict = copy.deepcopy(params)
remote_virsh_session = None
vm_session = None
vm = None
mig_result = None
func_name = None
extra_args = {}
default_src_vf = 0
default_dest_vf = 0
default_src_rp_filter = 1
default_dest_rp_filer = 1
if not libvirt_version.version_compare(6, 0, 0):
test.cancel("This libvirt version doesn't support migration with "
"net failover devices.")
# params for migration connection
params["virsh_migrate_desturi"] = libvirt_vm.complete_uri(
params.get("migrate_dest_host"))
params["virsh_migrate_connect_uri"] = libvirt_vm.complete_uri(
params.get("migrate_source_host"))
src_uri = params.get("virsh_migrate_connect_uri")
dest_uri = params.get("virsh_migrate_desturi")
vm_name = params.get("migrate_main_vm")
vm = env.get_vm(vm_name)
vm.verify_alive()
# For safety reasons, we'd better back up xmlfile.
new_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
orig_config_xml = new_xml.copy()
try:
# Create a remote runner for later use
runner_on_target = remote.RemoteRunner(host=server_ip,
username=server_user,
password=server_pwd)
server_session = remote.wait_for_login('ssh', server_ip, '22',
server_user, server_pwd,
r"[\#\$]\s*$")
if net_failover_test:
src_pf, src_pf_pci = utils_sriov.find_pf(driver)
logging.debug("src_pf is %s. src_pf_pci: %s", src_pf, src_pf_pci)
params['pf_name'] = src_pf
dest_pf, dest_pf_pci = utils_sriov.find_pf(driver, server_session)
logging.debug("dest_pf is %s. dest_pf_pci: %s", dest_pf, dest_pf_pci)
destparams_dict['pf_name'] = dest_pf
src_pf_pci_path = utils_misc.get_pci_path(src_pf_pci)
dest_pf_pci_path = utils_misc.get_pci_path(dest_pf_pci, server_session)
cmd = "cat %s/sriov_numvfs" % (src_pf_pci_path)
default_src_vf = process.run(cmd, shell=True,
verbose=True).stdout_text
cmd = "cat %s/sriov_numvfs" % (dest_pf_pci_path)
status, default_dest_vf = utils_misc.cmd_status_output(cmd,
shell=True,
session=server_session)
if status:
test.error("Unable to get default sriov_numvfs on target!"
"status: %s, output: %s" % (status, default_dest_vf))
if not utils_sriov.set_vf(src_pf_pci_path, vf_no):
test.error("Failed to set vf on source.")
if not utils_sriov.set_vf(dest_pf_pci_path, vf_no, session=server_session):
test.error("Failed to set vf on target.")
# Create PF and bridge connection on source and target host
cmd = 'cat /proc/sys/net/ipv4/conf/all/rp_filter'
default_src_rp_filter = process.run(cmd, shell=True,
verbose=True).stdout_text
status, default_dest_rp_filter = utils_misc.cmd_status_output(cmd,
shell=True,
session=server_session)
if status:
test.error("Unable to get default rp_filter on target!"
"status: %s, output: %s" % (status, default_dest_rp_filter))
cmd = 'echo 0 >/proc/sys/net/ipv4/conf/all/rp_filter'
process.run(cmd, shell=True, verbose=True)
utils_misc.cmd_status_output(cmd, shell=True, session=server_session)
utils_sriov.add_or_del_connection(params, is_del=False)
utils_sriov.add_or_del_connection(destparams_dict, is_del=False,
session=server_session)
if not remote_virsh_session:
remote_virsh_session = virsh.VirshPersistent(**remote_virsh_dargs)
create_or_del_networks(dest_pf, params,
remote_virsh_session=remote_virsh_session)
remote_virsh_session.close_session()
create_or_del_networks(src_pf, params)
# Change network interface xml
mac_addr = utils_net.generate_mac_address_simple()
update_iface_xml(new_xml)
# Change the disk of the vm
libvirt.set_vm_disk(vm, params)
if not vm.is_alive():
vm.start()
# Check local guest network connection before migration
if vm.serial_console is not None:
vm.cleanup_serial_console()
vm.create_serial_console()
vm_session = vm.wait_for_serial_login(timeout=240)
if net_failover_test:
utils_net.restart_guest_network(vm_session)
iface_list = get_vm_ifaces(vm_session)
vm_ipv4, vm_ipv6 = utils_net.get_linux_ipaddr(vm_session, iface_list[0])
check_vm_network_accessed(ping_dest=vm_ipv4)
if net_failover_test:
check_vm_iface_num(iface_list)
check_vm_network_connection(net_hostdev_name, 1)
check_vm_network_connection(net_bridge_name, 1)
hostdev_pci_id = get_hostdev_addr_from_xml()
vf_path = utils_misc.get_pci_path(hostdev_pci_id)
check_vfio_pci(vf_path)
if cmd_during_mig:
s, o = utils_misc.cmd_status_output(cmd_during_mig, shell=True,
session=vm_session)
if s:
test.fail("Failed to run %s in vm." % cmd_during_mig)
if extra.count("--postcopy"):
func_name = virsh.migrate_postcopy
extra_args.update({'func_params': params})
if cancel_migration:
func_name = migration_test.do_cancel
# Execute migration process
vms = [vm]
migration_test.do_migration(vms, None, dest_uri, 'orderly',
options, thread_timeout=900,
ignore_status=True, virsh_opt=virsh_options,
func=func_name, extra_opts=extra,
**extra_args)
mig_result = migration_test.ret
migration_test.check_result(mig_result, params)
if int(mig_result.exit_status) == 0:
server_session = remote.wait_for_login('ssh', server_ip, '22',
server_user, server_pwd,
r"[\#\$]\s*$")
check_vm_network_accessed(server_session, vm_ipv4)
server_session.close()
if net_failover_test:
# Check network connection
check_vm_network_connection(net_hostdev_name)
check_vm_network_connection(net_bridge_name)
# VF driver should not be vfio-pci
check_vfio_pci(vf_path, True)
cmd_parms.update({'vm_ip': vm_ipv4,
'vm_pwd': params.get("password")})
vm_after_mig = remote.VMManager(cmd_parms)
vm_after_mig.setup_ssh_auth()
cmd = "ip link"
cmd_result = vm_after_mig.run_command(cmd)
libvirt.check_result(cmd_result)
p_iface = re.findall(r"\d+:\s+(\w+):\s+.*", cmd_result.stdout_text)
p_iface = [x for x in p_iface if x != 'lo']
check_vm_iface_num(p_iface)
# Check the output of ping command
cmd = 'cat %s' % vm_tmp_file
cmd_result = vm_after_mig.run_command(cmd)
libvirt.check_result(cmd_result)
if re.findall('Destination Host Unreachable', cmd_result.stdout_text, re.M):
test.fail("The network does not work well during "
"the migration peirod. ping output: %s"
% cmd_result.stdout_text)
# Execute migration from remote
if migr_vm_back:
ssh_connection = utils_conn.SSHConnection(server_ip=client_ip,
server_pwd=client_pwd,
client_ip=server_ip,
client_pwd=server_pwd)
try:
ssh_connection.conn_check()
except utils_conn.ConnectionError:
ssh_connection.conn_setup()
ssh_connection.conn_check()
# Pre migration setup for local machine
migration_test.migrate_pre_setup(src_uri, params)
cmd = "virsh migrate %s %s %s" % (vm_name,
virsh_options, src_uri)
logging.debug("Start migration: %s", cmd)
cmd_result = remote.run_remote_cmd(cmd, params, runner_on_target)
logging.info(cmd_result)
if cmd_result.exit_status:
test.fail("Failed to run '%s' on remote: %s"
% (cmd, cmd_result))
logging.debug("migration back done")
check_vm_network_accessed(ping_dest=vm_ipv4)
if net_failover_test:
if vm_session:
vm_session.close()
vm_session = vm.wait_for_login()
iface_list = get_vm_ifaces(vm_session)
check_vm_iface_num(iface_list)
else:
check_vm_network_accessed(ping_dest=vm_ipv4)
if net_failover_test:
iface_list = get_vm_ifaces(vm_session)
check_vm_iface_num(iface_list)
finally:
logging.debug("Recover test environment")
# Clean VM on destination
migration_test.cleanup_dest_vm(vm, vm.connect_uri, dest_uri)
if vm.is_alive():
vm.destroy(gracefully=False)
logging.info("Recovery VM XML configration")
orig_config_xml.sync()
logging.debug("The current VM XML:\n%s", orig_config_xml.xmltreefile)
server_session = remote.wait_for_login('ssh', server_ip, '22',
server_user, server_pwd,
r"[\#\$]\s*$")
if 'src_pf' in locals():
cmd = 'echo %s >/proc/sys/net/ipv4/conf/all/rp_filter' % default_src_rp_filter
process.run(cmd, shell=True, verbose=True)
utils_sriov.add_or_del_connection(params, is_del=True)
create_or_del_networks(src_pf, params, is_del=True)
if 'dest_pf' in locals():
cmd = 'echo %s >/proc/sys/net/ipv4/conf/all/rp_filter' % default_dest_rp_filter
utils_misc.cmd_status_output(cmd, shell=True, session=server_session)
utils_sriov.add_or_del_connection(destparams_dict, session=server_session,
is_del=True)
remote_virsh_session = virsh.VirshPersistent(**remote_virsh_dargs)
create_or_del_networks(dest_pf, params,
remote_virsh_session,
is_del=True)
remote_virsh_session.close_session()
if 'dest_pf_pci_path' in locals() and default_dest_vf != vf_no:
utils_sriov.set_vf(dest_pf_pci_path, default_dest_vf, server_session)
if 'src_pf_pci_path' in locals() and default_src_vf != vf_no:
utils_sriov.set_vf(src_pf_pci_path, default_src_vf)
# Clean up of pre migration setup for local machine
if migr_vm_back:
if 'ssh_connection' in locals():
ssh_connection.auto_recover = True
migration_test.migrate_pre_setup(src_uri, params,
cleanup=True)
server_session.close()
if remote_virsh_session:
remote_virsh_session.close_session()
logging.info("Remove local NFS image")
source_file = params.get("source_file")
if source_file:
libvirt.delete_local_disk("file", path=source_file)
def run(test, params, env):
"""
Test command: virsh dommemstat.
The command gets memory statistics for a domain
1.Prepare test environment.
2.When the ibvirtd == "off", stop the libvirtd service.
3.Perform virsh dommemstat operation.
4.Recover test environment.
5.Confirm the test result.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(params["main_vm"])
domid = vm.get_id()
domuuid = vm.get_uuid()
status_error = params.get("status_error", "no")
vm_ref = params.get("dommemstat_vm_ref", "name")
libvirtd = params.get("libvirtd", "on")
extra = params.get("dommemstat_extra", "")
if libvirtd == "off":
utils_libvirtd.libvirtd_stop()
# run test case
if vm_ref == "id":
vm_ref = domid
elif vm_ref == "hex_id":
vm_ref = hex(int(domid))
elif vm_ref == "uuid":
vm_ref = domuuid
elif vm_ref.count("_invalid_"):
# vm_ref names parameter to fetch
vm_ref = params.get(vm_ref)
elif vm_ref == "name":
vm_ref = "%s" % vm_name
if libvirtd == "off":
utils_libvirtd.libvirtd_stop()
if vm_ref != "remote":
status = virsh.dommemstat(vm_ref, extra, ignore_status=True,
debug=True).exit_status
else:
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"):
test.cancel("local/remote ip parameters not set.")
status = 0
try:
remote_uri = libvirt_vm.complete_uri(local_ip)
session = remote.remote_login("ssh", remote_ip, "22", "root",
remote_pwd, "#")
session.cmd_output('LANG=C')
command = "virsh -c %s dommemstat %s %s" % (remote_uri, vm_name,
extra)
status = session.cmd_status(command, internal_timeout=5)
session.close()
except process.CmdError:
status = 1
# recover libvirtd service start
if libvirtd == "off":
utils_libvirtd.libvirtd_start()
# check status_error
if status_error == "yes":
if status == 0:
test.fail("Run successfully with wrong command!")
elif status_error == "no":
if status != 0:
test.fail("Run failed with right command")
def run(test, params, env):
"""
Test command: virsh domstate.
1.Prepare test environment.
2.When the libvirtd == "off", stop the libvirtd service.
3.Perform virsh domstate operation.
4.Recover test environment.
5.Confirm the test result.
"""
vm_name = params.get("main_vm", "avocado-vt-vm1")
vm = env.get_vm(vm_name)
libvirtd = params.get("libvirtd", "on")
vm_ref = params.get("domstate_vm_ref")
status_error = (params.get("status_error", "no") == "yes")
extra = params.get("domstate_extra", "")
vm_action = params.get("domstate_vm_action", "")
vm_oncrash_action = params.get("domstate_vm_oncrash")
domid = vm.get_id()
domuuid = vm.get_uuid()
libvirtd_service = utils_libvirtd.Libvirtd()
if vm_ref == "id":
vm_ref = domid
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 == "name":
vm_ref = vm_name
elif vm_ref == "uuid":
vm_ref = domuuid
# Back up xml file.
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
backup_xml = vmxml.copy()
# Back up qemu.conf
process.run("cp %s %s" % (QEMU_CONF, QEMU_CONF_BK), shell=True)
dump_path = os.path.join(test.tmpdir, "dump/")
dump_file = ""
try:
if vm_action == "crash":
if vm.is_alive():
vm.destroy(gracefully=False)
vmxml.on_crash = vm_oncrash_action
if not vmxml.xmltreefile.find('devices').findall('panic'):
# Add <panic> device to domain
panic_dev = Panic()
panic_dev.addr_type = "isa"
panic_dev.addr_iobase = "0x505"
vmxml.add_device(panic_dev)
vmxml.sync()
# Config auto_dump_path in qemu.conf
cmd = "echo auto_dump_path = \\\"%s\\\" >> %s" % (dump_path,
QEMU_CONF)
process.run(cmd, shell=True)
libvirtd_service.restart()
if vm_oncrash_action in ['coredump-destroy', 'coredump-restart']:
dump_file = dump_path + vm_name + "-*"
# Start VM and check the panic device
virsh.start(vm_name, ignore_status=False)
vmxml_new = vm_xml.VMXML.new_from_dumpxml(vm_name)
# Skip this test if no panic device find
if not vmxml_new.xmltreefile.find('devices').findall('panic'):
raise error.TestNAError("No 'panic' device in the guest,"
" maybe your libvirt version doesn't"
" support it.")
try:
if vm_action == "suspend":
virsh.suspend(vm_name, ignore_status=False)
elif vm_action == "resume":
virsh.suspend(vm_name, ignore_status=False)
virsh.resume(vm_name, ignore_status=False)
elif vm_action == "destroy":
virsh.destroy(vm_name, ignore_status=False)
elif vm_action == "start":
virsh.destroy(vm_name, ignore_status=False)
virsh.start(vm_name, ignore_status=False)
elif vm_action == "kill":
libvirtd_service.stop()
kill_process_by_pattern(vm_name)
libvirtd_service.restart()
elif vm_action == "crash":
session = vm.wait_for_login()
session.cmd("service kdump stop", ignore_all_errors=True)
# Enable sysRq
session.cmd("echo 1 > /proc/sys/kernel/sysrq")
# Send key ALT-SysRq-c to crash VM, and command will not
# return as vm crashed, so fail early for 'destroy' and
# 'preserve' action. For 'restart', 'coredump-restart'
# and 'coredump-destroy' actions, they all need more time
# to dump core file or restart OS, so using the default
# session command timeout(60s)
try:
if vm_oncrash_action in ['destroy', 'preserve']:
timeout = 3
else:
timeout = 60
session.cmd("echo c > /proc/sysrq-trigger", timeout=timeout)
except (ShellTimeoutError, ShellProcessTerminatedError):
pass
session.close()
except process.CmdError, e:
raise error.TestError("Guest prepare action error: %s" % e)
if libvirtd == "off":
libvirtd_service.stop()
if vm_ref == "remote":
remote_ip = params.get("remote_ip", "REMOTE.EXAMPLE.COM")
local_ip = params.get("local_ip", "LOCAL.EXAMPLE.COM")
remote_pwd = params.get("remote_pwd", None)
if remote_ip.count("EXAMPLE.COM") or local_ip.count("EXAMPLE.COM"):
raise error.TestNAError("Test 'remote' parameters not setup")
status = 0
try:
remote_uri = libvirt_vm.complete_uri(local_ip)
session = remote.remote_login("ssh", remote_ip, "22", "root",
remote_pwd, "#")
session.cmd_output('LANG=C')
command = "virsh -c %s domstate %s" % (remote_uri, vm_name)
status, output = session.cmd_status_output(command,
internal_timeout=5)
session.close()
except process.CmdError:
status = 1
else:
result = virsh.domstate(vm_ref, extra, ignore_status=True,
debug=True)
status = result.exit_status
output = result.stdout.strip()
# check status_error
if status_error:
if not status:
raise error.TestFail("Run successfully with wrong command!")
else:
if status or not output:
raise error.TestFail("Run failed with right command")
if extra.count("reason"):
if vm_action == "suspend":
# If not, will cost long time to destroy vm
virsh.destroy(vm_name)
if not output.count("user"):
raise ActionError(vm_action)
elif vm_action == "resume":
if not output.count("unpaused"):
raise ActionError(vm_action)
elif vm_action == "destroy":
if not output.count("destroyed"):
raise ActionError(vm_action)
elif vm_action == "start":
if not output.count("booted"):
raise ActionError(vm_action)
elif vm_action == "kill":
if not output.count("crashed"):
raise ActionError(vm_action)
elif vm_action == "crash":
if not check_crash_state(output, vm_oncrash_action,
dump_file):
raise ActionError(vm_action)
if vm_ref == "remote":
if not (re.search("running", output) or
re.search("blocked", output) or
re.search("idle", output)):
raise error.TestFail("Run failed with right command")
def run_virsh_shutdown(test, params, env):
"""
Test command: virsh shutdown.
The conmand can gracefully shutdown a domain.
1.Prepare test environment.
2.When the libvirtd == "off", stop the libvirtd service.
3.Perform virsh setvcpus operation.
4.Recover test environment.
5.Confirm the test result.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
domid = vm.get_id()
domuuid = vm.get_uuid()
vm_ref = params.get("shutdown_vm_ref")
libvirtd = params.get("libvirtd", "on")
#run test case
if vm_ref == "id":
vm_ref = domid
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 == "name":
vm_ref = "%s %s" % (vm_name, params.get("shutdown_extra"))
elif vm_ref == "uuid":
vm_ref = domuuid
if libvirtd == "off":
libvirt_vm.libvirtd_stop()
if vm_ref != "remote":
status = virsh.shutdown(vm_ref, ignore_status=True).exit_status
else:
remote_ip = params.get("remote_ip", None)
remote_pwd = params.get("remote_pwd", None)
local_ip = params.get("local_ip", None)
status = 0
try:
remote_uri = libvirt_vm.complete_uri(local_ip)
session = remote.remote_login("ssh", remote_ip, "22", "root",
remote_pwd, "#")
session.cmd_output('LANG=C')
command = "virsh -c %s shutdown %s" % (remote_uri, vm_name)
status = session.cmd_status(command, internal_timeout=5)
session.close()
except error.CmdError:
status = 1
#recover libvirtd service start
if libvirtd == "off":
libvirt_vm.libvirtd_start()
#check status_error
status_error = params.get("status_error")
if status_error == "yes":
if status == 0:
raise error.TestFail("Run successfully with wrong command!")
elif status_error == "no":
if status != 0:
raise error.TestFail("Run failed with right command")
def run(test, params, env):
"""
Test virsh undefine command.
Undefine an inactive domain, or convert persistent to transient.
1.Prepare test environment.
2.Backup the VM's information to a xml file.
3.When the libvirtd == "off", stop the libvirtd service.
4.Perform virsh undefine operation.
5.Recover test environment.(libvirts service,VM)
6.Confirm the test result.
"""
vm_ref = params.get("undefine_vm_ref", "vm_name")
extra = params.get("undefine_extra", "")
option = params.get("undefine_option", "")
libvirtd_state = params.get("libvirtd", "on")
status_error = ("yes" == params.get("status_error", "no"))
undefine_twice = ("yes" == params.get("undefine_twice", 'no'))
local_ip = params.get("local_ip", "LOCAL.EXAMPLE.COM")
remote_ip = params.get("remote_ip", "REMOTE.EXAMPLE.COM")
remote_user = params.get("remote_user", "user")
remote_pwd = params.get("remote_pwd", "password")
remote_prompt = params.get("remote_prompt", "#")
vm_name = params.get("main_vm", "virt-tests-vm1")
vm = env.get_vm(vm_name)
vm_id = vm.get_id()
vm_uuid = vm.get_uuid()
# Back up xml file.Xen host has no guest xml file to define a guset.
backup_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
# Confirm how to reference a VM.
if vm_ref == "vm_name":
vm_ref = vm_name
elif vm_ref == "id":
vm_ref = vm_id
elif vm_ref == "hex_vm_id":
vm_ref = hex(int(vm_id))
elif vm_ref == "uuid":
vm_ref = vm_uuid
elif vm_ref.find("invalid") != -1:
vm_ref = params.get(vm_ref)
save_file = "/var/lib/libvirt/qemu/save/%s.save" % vm_name
if option.count("managedsave") and vm.is_alive():
virsh.managedsave(vm_name)
snp_list = virsh.snapshot_list(vm_name)
if option.count("snapshot"):
snp_file_list = []
if not len(snp_list):
virsh.snapshot_create(vm_name)
logging.debug("Create a snapshot for test!")
else:
# Backup snapshots for domain
for snp_item in snp_list:
tmp_file = os.path.join(test.tmpdir, snp_item+".xml")
virsh.snapshot_dumpxml(vm_name, snp_item, to_file=tmp_file)
snp_file_list.append(tmp_file)
else:
if len(snp_list):
raise error.TestNAError("This domain has snapshot(s), "
"cannot be undefined!")
# Turn libvirtd into certain state.
if libvirtd_state == "off":
utils_libvirtd.libvirtd_stop()
# Test virsh undefine command.
if vm_ref != "remote":
vm_ref = "%s %s" % (vm_ref, extra)
cmdresult = virsh.undefine(vm_ref, option,
ignore_status=True, debug=True)
status = cmdresult.exit_status
if status:
logging.debug("Error status, command output: %s", cmdresult.stdout)
if undefine_twice:
status2 = virsh.undefine(vm_ref,
ignore_status=True).exit_status
else:
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")
try:
uri = libvirt_vm.complete_uri(local_ip)
session = remote.remote_login("ssh", remote_ip, "22", remote_user,
remote_pwd, remote_prompt)
cmd_undefine = "virsh -c %s undefine %s" % (uri, vm_name)
status, output = session.cmd_status_output(cmd_undefine)
logging.info("Undefine output: %s", output)
except (error.CmdError, remote.LoginError, aexpect.ShellError), detail:
logging.error("Detail: %s", detail)
status = 1
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
try:
vm.prepare_guest_agent(channel=agent, start=agent)
except virt_vm.VMError, e:
logging.debug(e)
# qemu-guest-agent is not available on REHL5
raise error.TestNAError("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"):
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()
except (remote.LoginError, process.CmdError, aexpect.ShellError), e:
logging.error("Exception: %s", str(e))
status = -1
def run(test, params, env):
"""
Test command: virsh domstate.
1.Prepare test environment.
2.When the libvirtd == "off", stop the libvirtd service.
3.Perform virsh domstate operation.
4.Recover test environment.
5.Confirm the test result.
"""
vm_name = params.get("main_vm", "virt-tests-vm1")
vm = env.get_vm(vm_name)
libvirtd = params.get("libvirtd", "on")
vm_ref = params.get("domstate_vm_ref")
status_error = (params.get("status_error", "no") == "yes")
extra = params.get("domstate_extra", "")
vm_action = params.get("domstate_vm_action", "")
domid = vm.get_id()
domuuid = vm.get_uuid()
if vm_ref == "id":
vm_ref = domid
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 == "name":
vm_ref = vm_name
elif vm_ref == "uuid":
vm_ref = domuuid
try:
if vm_action == "suspend":
virsh.suspend(vm_name, ignore_status=False)
elif vm_action == "resume":
virsh.suspend(vm_name, ignore_status=False)
virsh.resume(vm_name, ignore_status=False)
elif vm_action == "destroy":
virsh.destroy(vm_name, ignore_status=False)
elif vm_action == "start":
virsh.destroy(vm_name, ignore_status=False)
virsh.start(vm_name, ignore_status=False)
except error.CmdError:
raise error.TestError("Guest prepare action error!")
if libvirtd == "off":
utils_libvirtd.libvirtd_stop()
if vm_ref == "remote":
remote_ip = params.get("remote_ip", "REMOTE.EXAMPLE.COM")
local_ip = params.get("local_ip", "LOCAL.EXAMPLE.COM")
remote_pwd = params.get("remote_pwd", None)
if remote_ip.count("EXAMPLE.COM") or local_ip.count("EXAMPLE.COM"):
raise error.TestNAError("Test 'remote' parameters not setup")
status = 0
try:
remote_uri = libvirt_vm.complete_uri(local_ip)
session = remote.remote_login("ssh", remote_ip, "22", "root",
remote_pwd, "#")
session.cmd_output('LANG=C')
command = "virsh -c %s domstate %s" % (remote_uri, vm_name)
status, output = session.cmd_status_output(command,
internal_timeout=5)
session.close()
except error.CmdError:
status = 1
else:
result = virsh.domstate(vm_ref, extra, ignore_status=True)
status = result.exit_status
output = result.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 output:
raise error.TestFail("Run failed with right command")
if extra.count("reason"):
if vm_action == "suspend":
# If not, will cost long time to destroy vm
virsh.destroy(vm_name)
if not output.count("user"):
raise ActionError(vm_action)
elif vm_action == "resume":
if not output.count("unpaused"):
raise ActionError(vm_action)
elif vm_action == "destroy":
if not output.count("destroyed"):
raise ActionError(vm_action)
elif vm_action == "start":
if not output.count("booted"):
raise ActionError(vm_action)
if vm_ref == "remote":
if not (re.search("running", output) or re.search(
"blocked", output) or re.search("idle", output)):
raise error.TestFail("Run failed with right command")
def run(test, params, env):
"""
Test command: virsh domstate.
1.Prepare test environment.
2.When the libvirtd == "off", stop the libvirtd service.
3.Perform virsh domstate operation.
4.Recover test environment.
5.Confirm the test result.
"""
vm_name = params.get("main_vm", "virt-tests-vm1")
vm = env.get_vm(vm_name)
libvirtd = params.get("libvirtd", "on")
vm_ref = params.get("domstate_vm_ref")
status_error = params.get("status_error", "no") == "yes"
extra = params.get("domstate_extra", "")
vm_action = params.get("domstate_vm_action", "")
domid = vm.get_id()
domuuid = vm.get_uuid()
if vm_ref == "id":
vm_ref = domid
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 == "name":
vm_ref = vm_name
elif vm_ref == "uuid":
vm_ref = domuuid
try:
if vm_action == "suspend":
virsh.suspend(vm_name, ignore_status=False)
elif vm_action == "resume":
virsh.suspend(vm_name, ignore_status=False)
virsh.resume(vm_name, ignore_status=False)
elif vm_action == "destroy":
virsh.destroy(vm_name, ignore_status=False)
elif vm_action == "start":
virsh.destroy(vm_name, ignore_status=False)
virsh.start(vm_name, ignore_status=False)
except error.CmdError:
raise error.TestError("Guest prepare action error!")
if libvirtd == "off":
utils_libvirtd.libvirtd_stop()
if vm_ref == "remote":
remote_ip = params.get("remote_ip", "REMOTE.EXAMPLE.COM")
local_ip = params.get("local_ip", "LOCAL.EXAMPLE.COM")
remote_pwd = params.get("remote_pwd", None)
if remote_ip.count("EXAMPLE.COM") or local_ip.count("EXAMPLE.COM"):
raise error.TestNAError("Test 'remote' parameters not setup")
status = 0
try:
remote_uri = libvirt_vm.complete_uri(local_ip)
session = remote.remote_login("ssh", remote_ip, "22", "root", remote_pwd, "#")
session.cmd_output("LANG=C")
command = "virsh -c %s domstate %s" % (remote_uri, vm_name)
status, output = session.cmd_status_output(command, internal_timeout=5)
session.close()
except error.CmdError:
status = 1
else:
result = virsh.domstate(vm_ref, extra, ignore_status=True)
status = result.exit_status
output = result.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 output:
raise error.TestFail("Run failed with right command")
if extra.count("reason"):
if vm_action == "suspend":
# If not, will cost long time to destroy vm
virsh.destroy(vm_name)
if not output.count("user"):
raise ActionError(vm_action)
elif vm_action == "resume":
if not output.count("unpaused"):
raise ActionError(vm_action)
elif vm_action == "destroy":
if not output.count("destroyed"):
raise ActionError(vm_action)
elif vm_action == "start":
if not output.count("booted"):
raise ActionError(vm_action)
if vm_ref == "remote":
if not (re.search("running", output) or re.search("blocked", output) or re.search("idle", output)):
raise error.TestFail("Run failed with right command")
def run(test, params, env):
"""
Test KVM migration scenarios
"""
migrate_options = params.get("migrate_options", "")
migrate_postcopy = params.get("migrate_postcopy", "")
migrate_dest_ip = params.get("migrate_dest_host")
nfs_mount_path = params.get("nfs_mount_dir")
migrate_start_state = params.get("migrate_start_state", "paused")
postcopy_func = None
if migrate_postcopy:
postcopy_func = virsh.migrate_postcopy
migrate_type = params.get("migrate_type", "orderly")
vm_state = params.get("migrate_vm_state", "running")
ping_count = int(params.get("ping_count", 15))
vms = params.get("vms").split()
vm_list = env.get_all_vms()
# Params to update disk using shared storage
params["disk_type"] = "file"
params["disk_source_protocol"] = "netfs"
params["mnt_path_name"] = nfs_mount_path
src_uri = "qemu:///system"
dest_uri = libvirt_vm.complete_uri(params["server_ip"])
vmxml_dict = {}
migrate_setup = libvirt.MigrationTest()
try:
for vm in vm_list:
vmxml_dict[vm.name] = vm_xml.VMXML.new_from_dumpxml(vm.name)
params["source_dist_img"] = "%s-nfs-img" % vm.name
if vm.is_alive():
vm.destroy()
libvirt.set_vm_disk(vm, params)
migrate_setup.ping_vm(vm, test, params, ping_count=ping_count)
try:
migrate_setup.do_migration(vm_list, src_uri, dest_uri,
migrate_type, migrate_options,
func=postcopy_func,
migrate_start_state=migrate_start_state)
except Exception as info:
test.fail(info)
for vm in vm_list:
if not migrate_setup.check_vm_state(vm.name, vm_state, dest_uri):
test.fail("Migrated VMs failed to be in %s state at "
"destination" % vm_state)
logging.info("Guest state is '%s' at destination is as expected",
vm_state)
migrate_setup.ping_vm(vm, test, params, uri=dest_uri, ping_count=ping_count)
finally:
logging.debug("cleanup the migration setup in source/destination")
for vm in vm_list:
if migrate_setup:
migrate_setup.cleanup_dest_vm(vm, src_uri, dest_uri)
if vm.exists() and vm.is_persistent():
vm.undefine()
if vm.is_alive():
vm.destroy()
for source_file in params.get("source_file_list", []):
libvirt.delete_local_disk("file", path=source_file)
if vmxml_dict:
for key in vmxml_dict.keys():
vmxml_dict[key].define()
def run(test, params, env):
"""
Test command: virsh shutdown.
The conmand can gracefully shutdown a domain.
1.Prepare test environment.
2.When the libvirtd == "off", stop the libvirtd service.
3.Perform virsh setvcpus operation.
4.Recover test environment.
5.Confirm the test result.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
vm_ref = params.get("shutdown_vm_ref")
status_error = ("yes" == params.get("status_error"))
agent = ("yes" == params.get("shutdown_agent", "no"))
mode = params.get("shutdown_mode", "")
pre_domian_status = params.get("reboot_pre_domian_status", "running")
libvirtd = params.get("libvirtd", "on")
xml_backup = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
# Libvirt acl test related params
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.")
try:
# Add or remove qemu-agent from guest before test
vm.prepare_guest_agent(channel=agent, start=agent)
if pre_domian_status == "shutoff":
virsh.destroy(vm_name)
domid = vm.get_id()
domuuid = vm.get_uuid()
# run test case
if vm_ref == "id":
vm_ref = domid
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 == "name":
vm_ref = "%s %s" % (vm_name, params.get("shutdown_extra"))
elif vm_ref == "uuid":
vm_ref = domuuid
if libvirtd == "off":
utils_libvirtd.libvirtd_stop()
if vm_ref != "remote":
status = virsh.shutdown(vm_ref, mode,
unprivileged_user=unprivileged_user,
uri=uri, debug=True,
ignore_status=True).exit_status
else:
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")
status = 0
try:
remote_uri = libvirt_vm.complete_uri(local_ip)
session = remote.remote_login("ssh", remote_ip, "22", "root",
remote_pwd, "#")
session.cmd_output('LANG=C')
command = ("virsh -c %s shutdown %s %s"
% (remote_uri, vm_name, mode))
status = session.cmd_status(command, internal_timeout=5)
session.close()
except error.CmdError:
status = 1
# 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:
raise error.TestFail("Run failed with right command")
finally:
xml_backup.sync()
def run(test, params, env):
"""
Test command: virsh shutdown.
The conmand can gracefully shutdown a domain.
1.Prepare test environment.
2.When the libvirtd == "off", stop the libvirtd service.
3.Perform virsh setvcpus operation.
4.Recover test environment.
5.Confirm the test result.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
vm_ref = params.get("shutdown_vm_ref")
status_error = ("yes" == params.get("status_error"))
agent = ("yes" == params.get("shutdown_agent", "no"))
mode = params.get("shutdown_mode", "")
pre_domian_status = params.get("reboot_pre_domian_status", "running")
libvirtd = params.get("libvirtd", "on")
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("service qemu-guest-agent start")
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)
domid = vm.get_id()
domuuid = vm.get_uuid()
# run test case
if vm_ref == "id":
vm_ref = domid
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 == "name":
vm_ref = "%s %s" % (vm_name, params.get("shutdown_extra"))
elif vm_ref == "uuid":
vm_ref = domuuid
if libvirtd == "off":
utils_libvirtd.libvirtd_stop()
if vm_ref != "remote":
status = virsh.shutdown(vm_ref, mode,
ignore_status=True).exit_status
else:
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")
status = 0
try:
remote_uri = libvirt_vm.complete_uri(local_ip)
session = remote.remote_login("ssh", remote_ip, "22", "root",
remote_pwd, "#")
session.cmd_output('LANG=C')
command = ("virsh -c %s shutdown %s %s"
% (remote_uri, vm_name, mode))
status = session.cmd_status(command, internal_timeout=5)
session.close()
except error.CmdError:
status = 1
# 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:
raise error.TestFail("Run failed with right command")
finally:
xml_backup.sync()
def run_virsh_domstate(test, params, env):
"""
Test command: virsh domstate.
1.Prepare test environment.
2.When the libvirtd == "off", stop the libvirtd service.
3.Perform virsh domstate operation.
4.Recover test environment.
5.Confirm the test result.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
libvirtd = params.get("libvirtd", "on")
vm_ref = params.get("domstate_vm_ref")
status_error = params.get("status_error", "no")
domid = vm.get_id()
domuuid = vm.get_uuid()
if vm_ref == "id":
vm_ref = domid
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 == "name":
vm_ref = "%s %s" % (vm_name, params.get("domstate_extra"))
elif vm_ref == "uuid":
vm_ref = domuuid
if libvirtd == "off":
libvirt_vm.libvirtd_stop()
if vm_ref == "remote":
remote_ip = params.get("remote_ip", "REMOTE.EXAMPLE.COM")
local_ip = params.get("local_ip", "LOCAL.EXAMPLE.COM")
remote_pwd = params.get("remote_pwd", None)
if remote_ip.count("EXAMPLE.COM") or local_ip.count("EXAMPLE.COM"):
raise error.TestNAError("Test 'remote' parameters not setup")
status = 0
try:
remote_uri = libvirt_vm.complete_uri(local_ip)
session = remote.remote_login("ssh", remote_ip, "22", "root",
remote_pwd, "#")
session.cmd_output('LANG=C')
command = "virsh -c %s domstate %s" % (remote_uri, vm_name)
status, output = session.cmd_status_output(command,
internal_timeout=5)
session.close()
except error.CmdError:
status = 1
else:
result = virsh.domstate(vm_ref, ignore_status=True)
status = result.exit_status
output = result.stdout
#recover libvirtd service start
if libvirtd == "off":
libvirt_vm.libvirtd_start()
#check status_error
if status_error == "yes":
if status == 0:
raise error.TestFail("Run successfully with wrong command!")
elif status_error == "no":
if status != 0 or output == "":
raise error.TestFail("Run failed with right command")
if vm_ref == "remote":
if not (re.match("running", output) or re.match("blocked", output)
or re.match("idle", 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
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_virsh_undefine(test, params, env):
"""
Test virsh undefine command.
Undefine an inactive domain, or convert persistent to transient.
1.Prepare test environment.
2.Backup the VM's information to a xml file.
3.When the libvirtd == "off", stop the libvirtd service.
4.Perform virsh undefine operation.
5.Recover test environment.(libvirts service,VM)
6.Confirm the test result.
"""
vm_ref = params.get("undefine_vm_ref", "vm_name")
extra = params.get("undefine_extra", "")
libvirtd_state = params.get("libvirtd", "on")
status_error = params.get("status_error")
undefine_twice = params.get("undefine_twice", 'no')
local_ip = params.get("local_ip", "LOCAL.EXAMPLE.COM")
remote_ip = params.get("remote_ip", "REMOTE.EXAMPLE.COM")
xml_file = os.path.join(test.tmpdir, 'tmp.xml')
remote_user = params.get("remote_user", "user")
remote_password = params.get("remote_password", "password")
remote_prompt = params.get("remote_prompt", "#")
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
vm_id = vm.get_id()
vm_uuid = vm.get_uuid()
# Back up xml file.Xen host has no guest xml file to define a guset.
virsh.dumpxml(vm_name, extra="", to_file=xml_file)
# Confirm how to reference a VM.
if vm_ref == "vm_name":
vm_ref = vm_name
elif vm_ref == "id":
vm_ref = vm_id
elif vm_ref == "hex_vm_id":
vm_ref = hex(int(vm_id))
elif vm_ref == "uuid":
vm_ref = vm_uuid
elif vm_ref.find("invalid") != -1:
vm_ref = params.get(vm_ref)
# Turn libvirtd into certain state.
if libvirtd_state == "off":
utils_libvirtd.libvirtd_stop()
# Test virsh undefine command.
status = 0
try:
uri = libvirt_vm.complete_uri(local_ip)
except error.CmdError:
status = 1
uri = None
if vm_ref != "remote":
vm_ref = "%s %s" % (vm_ref, extra)
cmdresult = virsh.undefine(vm_ref, uri=uri,
ignore_status=True, debug=True)
status = cmdresult.exit_status
if status:
logging.debug("Error status, command output: %s", cmdresult.stdout)
if undefine_twice == "yes":
status2 = virsh.undefine(vm_ref, uri=uri,
ignore_status=True).exit_status
else:
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")
session = remote.remote_login("ssh", remote_ip, "22", remote_user,
remote_password, remote_prompt)
cmd_undefine = "virsh -c %s undefine %s" % (uri, vm_name)
status, output = session.cmd_status_output(cmd_undefine)
logging.info("Undefine output: %s", output)
# Recover libvirtd state.
if libvirtd_state == "off":
utils_libvirtd.libvirtd_start()
# Shutdown VM.
if virsh.domain_exists(vm.name, uri=uri):
try:
if vm.is_alive():
vm.destroy()
except error.CmdError, detail:
logging.error("Detail: %s", detail)
except error.CmdError, e:
raise error.TestError("Guest prepare action error: %s" % e)
if libvirtd == "off":
libvirtd_service.stop()
try:
if vm_ref == "remote":
remote_ip = params.get("remote_ip", "REMOTE.EXAMPLE.COM")
local_ip = params.get("local_ip", "LOCAL.EXAMPLE.COM")
remote_pwd = params.get("remote_pwd", None)
if remote_ip.count("EXAMPLE.COM") or local_ip.count("EXAMPLE.COM"):
raise error.TestNAError("Test 'remote' parameters not setup")
status = 0
try:
remote_uri = libvirt_vm.complete_uri(local_ip)
session = remote.remote_login("ssh", remote_ip, "22", "root",
remote_pwd, "#")
session.cmd_output('LANG=C')
command = "virsh -c %s domstate %s" % (remote_uri, vm_name)
status, output = session.cmd_status_output(command,
internal_timeout=5)
session.close()
except error.CmdError:
status = 1
else:
result = virsh.domstate(vm_ref, extra, ignore_status=True,
debug=True)
status = result.exit_status
output = result.stdout.strip()
def run_virsh_domstate(test, params, env):
"""
Test command: virsh domstate.
1.Prepare test environment.
2.When the libvirtd == "off", stop the libvirtd service.
3.Perform virsh domstate operation.
4.Recover test environment.
5.Confirm the test result.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
libvirtd = params.get("libvirtd", "on")
vm_ref = params.get("domstate_vm_ref")
status_error = params.get("status_error", "no")
domid = vm.get_id()
domuuid = vm.get_uuid()
if vm_ref == "id":
vm_ref = domid
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 == "name":
vm_ref = "%s %s" % (vm_name, params.get("domstate_extra"))
elif vm_ref == "uuid":
vm_ref = domuuid
if libvirtd == "off":
utils_libvirtd.libvirtd_stop()
if vm_ref == "remote":
remote_ip = params.get("remote_ip", "REMOTE.EXAMPLE.COM")
local_ip = params.get("local_ip", "LOCAL.EXAMPLE.COM")
remote_pwd = params.get("remote_pwd", None)
if remote_ip.count("EXAMPLE.COM") or local_ip.count("EXAMPLE.COM"):
raise error.TestNAError("Test 'remote' parameters not setup")
status = 0
try:
remote_uri = libvirt_vm.complete_uri(local_ip)
session = remote.remote_login("ssh", remote_ip, "22", "root",
remote_pwd, "#")
session.cmd_output('LANG=C')
command = "virsh -c %s domstate %s" % (remote_uri, vm_name)
status, output = session.cmd_status_output(command,
internal_timeout=5)
session.close()
except error.CmdError:
status = 1
else:
result = virsh.domstate(vm_ref, ignore_status=True)
status = result.exit_status
output = result.stdout
#recover libvirtd service start
if libvirtd == "off":
utils_libvirtd.libvirtd_start()
#check status_error
if status_error == "yes":
if status == 0:
raise error.TestFail("Run successfully with wrong command!")
elif status_error == "no":
if status != 0 or output == "":
raise error.TestFail("Run failed with right command")
if vm_ref == "remote":
if not (re.match("running", output) or re.match("blocked", output)
or re.match("idle", output)):
raise error.TestFail("Run failed with right command")
def run(test, params, env):
"""
Test migration under stress.
"""
vm_names = params.get("migration_vms").split()
if len(vm_names) < 2:
raise exceptions.TestSkipError("Provide enough vms for migration")
src_uri = libvirt_vm.complete_uri(params.get("migrate_source_host",
"EXAMPLE"))
if src_uri.count('///') or src_uri.count('EXAMPLE'):
raise exceptions.TestSkipError("The src_uri '%s' is invalid" % src_uri)
dest_uri = libvirt_vm.complete_uri(params.get("migrate_dest_host",
"EXAMPLE"))
if dest_uri.count('///') or dest_uri.count('EXAMPLE'):
raise exceptions.TestSkipError("The dest_uri '%s' is invalid" %
dest_uri)
# Params for NFS and SSH setup
params["server_ip"] = params.get("migrate_dest_host")
params["server_user"] = "******"
params["server_pwd"] = params.get("migrate_dest_pwd")
params["client_ip"] = params.get("migrate_source_host")
params["client_user"] = "******"
params["client_pwd"] = params.get("migrate_source_pwd")
params["nfs_client_ip"] = params.get("migrate_dest_host")
params["nfs_server_ip"] = params.get("migrate_source_host")
# Configure NFS client on remote host
nfs_client = nfs.NFSClient(params)
nfs_client.setup()
# Migrated vms' instance
vms = []
for vm_name in vm_names:
vms.append(libvirt_vm.VM(vm_name, params, test.bindir,
env.get("address_cache")))
load_vm_names = params.get("load_vms").split()
# vms for load
load_vms = []
for vm_name in load_vm_names:
load_vms.append(libvirt_vm.VM(vm_name, params, test.bindir,
env.get("address_cache")))
params['load_vms'] = load_vms
cpu = int(params.get("smp", 1))
memory = int(params.get("mem")) * 1024
stress_type = params.get("migration_stress_type")
vm_bytes = params.get("stress_vm_bytes")
stress_args = params.get("stress_args")
migration_type = params.get("migration_type")
start_migration_vms = "yes" == params.get("start_migration_vms", "yes")
thread_timeout = int(params.get("thread_timeout", 120))
remote_host = params.get("migrate_dest_host")
username = params.get("migrate_dest_user", "root")
password = params.get("migrate_dest_pwd")
prompt = params.get("shell_prompt", r"[\#\$]")
# Set vm_bytes for start_cmd
mem_total = utils_memory.memtotal()
vm_reserved = len(vms) * memory
if vm_bytes == "half":
vm_bytes = (mem_total - vm_reserved) / 2
elif vm_bytes == "shortage":
vm_bytes = mem_total - vm_reserved + 524288
if vm_bytes is not None:
params["stress_args"] = stress_args % vm_bytes
for vm in vms:
# Keep vm dead for edit
if vm.is_alive():
vm.destroy()
set_cpu_memory(vm.name, cpu, memory)
try:
vm_ipaddr = {}
if start_migration_vms:
for vm in vms:
vm.start()
vm.wait_for_login()
vm_ipaddr[vm.name] = vm.get_address()
# TODO: recover vm if start failed?
# Config ssh autologin for remote host
ssh_key.setup_ssh_key(remote_host, username, password, port=22)
do_stress_migration(vms, src_uri, dest_uri, stress_type,
migration_type, params, thread_timeout)
# Check network of vms on destination
if start_migration_vms and migration_type != "cross":
for vm in vms:
utils_test.check_dest_vm_network(vm, vm_ipaddr[vm.name],
remote_host,
username, password, prompt)
finally:
logging.debug("Cleanup vms...")
for vm_name in vm_names:
vm = libvirt_vm.VM(vm_name, params, test.bindir,
env.get("address_cache"))
utlv.MigrationTest().cleanup_dest_vm(vm, None, dest_uri)
if vm.is_alive():
vm.destroy(gracefully=False)
if nfs_client:
logging.info("Cleanup NFS client environment...")
nfs_client.cleanup()
env.clean_objects()
def run(test, params, env):
"""
Run the test
:param test: test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment.
"""
libvirt_version.is_libvirt_feature_supported(params)
vm_name = params.get("migrate_main_vm")
vm = env.get_vm(vm_name)
vm.verify_alive()
bk_uri = vm.connect_uri
migration_test = migration.MigrationTest()
migration_test.check_parameters(params)
extra_args = migration_test.update_virsh_migrate_extra_args(params)
extra = params.get("virsh_migrate_extra")
postcopy_options = params.get("postcopy_options")
if postcopy_options:
extra = "%s %s" % (extra, postcopy_options)
params["virsh_migrate_desturi"] = libvirt_vm.complete_uri(
params.get("migrate_dest_host"))
dest_uri = params.get("virsh_migrate_desturi")
options = params.get("virsh_migrate_options",
"--live --p2p --persistent --verbose")
virsh_options = params.get("virsh_options", "")
stress_package = params.get("stress_package")
action_during_mig = params.get("action_during_mig")
migrate_speed = params.get("migrate_speed")
migrate_speed_again = params.get("migrate_speed_again")
migrate_again = "yes" == params.get("migrate_again", "no")
vm_state_after_abort = params.get("vm_state_after_abort")
return_port = "yes" == params.get("return_port", "no")
params['server_pwd'] = params.get("migrate_dest_pwd")
params['server_ip'] = params.get("migrate_dest_host")
params['server_user'] = params.get("remote_user", "root")
is_storage_migration = True if extra.count('--copy-storage-all') else False
setup_tls = "yes" == params.get("setup_tls", "no")
qemu_conf_dest = params.get("qemu_conf_dest", "{}")
migrate_tls_force_default = "yes" == params.get("migrate_tls_force_default", "no")
poweroff_src_vm = "yes" == params.get("poweroff_src_vm", "no")
check_port = "yes" == params.get("check_port", "no")
server_ip = params.get("migrate_dest_host")
server_user = params.get("remote_user", "root")
server_pwd = params.get("migrate_dest_pwd")
server_params = {'server_ip': server_ip,
'server_user': server_user,
'server_pwd': server_pwd}
qemu_conf_list = eval(params.get("qemu_conf_list", "[]"))
qemu_conf_path = params.get("qemu_conf_path")
min_port = params.get("min_port")
vm_session = None
qemu_conf_remote = None
(remove_key_local, remove_key_remote) = (None, None)
# For safety reasons, we'd better back up xmlfile.
new_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
orig_config_xml = new_xml.copy()
local_both_conf_obj = None
remote_file_list = []
conn_obj_list = []
try:
# Setup default value for migrate_tls_force
if migrate_tls_force_default:
value_list = ["migrate_tls_force"]
# Setup migrate_tls_force default value on remote
server_params['file_path'] = "/etc/libvirt/qemu.conf"
remove_key_remote = libvirt_config.remove_key_in_conf(value_list,
"qemu",
remote_params=server_params)
# Setup migrate_tls_force default value on local
remove_key_local = libvirt_config.remove_key_in_conf(value_list,
"qemu")
if check_port:
server_params['file_path'] = qemu_conf_path
remove_key_remote = libvirt_config.remove_key_in_conf(qemu_conf_list,
"qemu",
remote_params=server_params)
# Update only remote qemu conf
if qemu_conf_dest:
qemu_conf_remote = libvirt_remote.update_remote_file(
server_params, qemu_conf_dest, "/etc/libvirt/qemu.conf")
# Update local or both sides configuration files
local_both_conf_obj = update_local_or_both_conf_file(params)
# Setup TLS
if setup_tls:
conn_obj_list.append(migration_base.setup_conn_obj('tls',
params,
test))
# Update guest disk xml
if not is_storage_migration:
libvirt.set_vm_disk(vm, params)
else:
remote_file_list.append(libvirt_disk.create_remote_disk_by_same_metadata(vm,
params))
if check_port:
# Create a remote runner
runner_on_target = remote_old.RemoteRunner(host=server_ip,
username=server_user,
password=server_pwd)
cmd = "nc -l -p %s &" % min_port
remote_old.run_remote_cmd(cmd, params, runner_on_target, ignore_status=False)
if not vm.is_alive():
vm.start()
logging.debug("Guest xml after starting:\n%s",
vm_xml.VMXML.new_from_dumpxml(vm_name))
vm_session = vm.wait_for_login()
if action_during_mig:
if poweroff_src_vm:
params.update({'vm_session': vm_session})
action_during_mig = migration_base.parse_funcs(action_during_mig,
test, params)
if stress_package:
migration_test.run_stress_in_vm(vm, params)
mode = 'both' if '--postcopy' in postcopy_options else 'precopy'
if migrate_speed:
migration_test.control_migrate_speed(vm_name,
int(migrate_speed),
mode)
# Execute migration process
migration_base.do_migration(vm, migration_test, None, dest_uri,
options, virsh_options, extra,
action_during_mig,
extra_args)
func_returns = dict(migration_test.func_ret)
migration_test.func_ret.clear()
logging.debug("Migration returns function results:%s", func_returns)
if return_port:
port_used = get_used_port(func_returns)
if check_port:
port_used = get_used_port(func_returns)
if int(port_used) != int(min_port) + 1:
test.fail("Wrong port for migration.")
if vm_state_after_abort:
check_vm_state_after_abort(vm_name, vm_state_after_abort,
bk_uri, dest_uri, test)
if migrate_again:
if not vm.is_alive():
vm.start()
vm_session = vm.wait_for_login()
action_during_mig = migration_base.parse_funcs(params.get('action_during_mig_again'),
test, params)
extra_args['status_error'] = params.get("migrate_again_status_error", "no")
if params.get("virsh_migrate_extra_mig_again"):
extra = params.get("virsh_migrate_extra_mig_again")
if params.get('scp_list_client_again'):
params['scp_list_client'] = params.get('scp_list_client_again')
# Recreate tlsconnection object using new parameter values
conn_obj_list.append(migration_base.setup_conn_obj('tls',
params,
test))
if migrate_speed_again:
migration_test.control_migrate_speed(vm_name,
int(migrate_speed_again),
mode)
migration_base.do_migration(vm, migration_test, None, dest_uri,
options, virsh_options,
extra, action_during_mig,
extra_args)
if return_port:
func_returns = dict(migration_test.func_ret)
logging.debug("Migration returns function "
"results:%s", func_returns)
port_second = get_used_port(func_returns)
if port_used != port_second:
test.fail("Expect same port '{}' is used as previous one, "
"but found new one '{}'".format(port_used,
port_second))
else:
logging.debug("Same port '%s' was used as "
"expected", port_second)
if int(migration_test.ret.exit_status) == 0:
migration_test.post_migration_check([vm], params, uri=dest_uri)
finally:
logging.info("Recover test environment")
vm.connect_uri = bk_uri
if vm_session:
vm_session.close()
# Clean VM on destination and source
migration_test.cleanup_vm(vm, dest_uri)
# Restore remote qemu conf and restart libvirtd
if qemu_conf_remote:
logging.debug("Recover remote qemu configurations")
del qemu_conf_remote
# Restore local or both sides conf and restart libvirtd
recover_config_file(local_both_conf_obj, params)
if remove_key_remote:
del remove_key_remote
if remove_key_local:
libvirt.customize_libvirt_config(None,
config_object=remove_key_local,
config_type='qemu')
# Clean up connection object, like TLS
migration_base.cleanup_conn_obj(conn_obj_list, test)
for one_file in remote_file_list:
if one_file:
remote_old.run_remote_cmd("rm -rf %s" % one_file, params)
orig_config_xml.sync()
def run(test, params, env):
"""
Test command: virsh start.
1) Get the params from params.
2) Prepare libvirtd's status.
3) Do the start operation.
4) Result check.
5) clean up.
"""
# get the params from params
vm_name = params.get("main_vm", "virt-tests-vm1")
vm_ref = params.get("vm_ref", "vm1")
opt = params.get("vs_opt", "")
# Backup for recovery.
vmxml_backup = libvirt_xml.vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
backup_name = vm_ref
vm = None
if vm_ref is not "":
vm = env.get_vm(vm_ref)
vmxml = libvirt_xml.VMXML()
libvirtd_state = params.get("libvirtd", "on")
pre_operation = params.get("vs_pre_operation", "")
status_error = params.get("status_error", "no")
# get the params for remote test
remote_ip = params.get("remote_ip", "ENTER.YOUR.REMOTE.IP")
remote_pwd = params.get("remote_pwd", "ENTER.YOUR.REMOTE.PASSWORD")
local_ip = params.get("local_ip", "ENTER.YOUR.LOCAL.IP")
if pre_operation == "remote" and (remote_ip.count("ENTER.YOUR.") or
local_ip.count("ENTER.YOUR.")):
raise error.TestNAError("Remote test parameters not configured")
try:
# prepare before start vm
if libvirtd_state == "on":
utils_libvirtd.libvirtd_start()
elif libvirtd_state == "off":
utils_libvirtd.libvirtd_stop()
if pre_operation == "rename":
new_vm_name = params.get("vs_new_vm_name", "virsh_start_vm1")
vm = libvirt_xml.VMXML.vm_rename(vm, new_vm_name)
vm_ref = new_vm_name
elif pre_operation == "undefine":
vmxml = vmxml.new_from_dumpxml(vm_ref)
vmxml.undefine()
# do the start operation
try:
if pre_operation == "remote":
# get remote session
session = remote.wait_for_login("ssh", remote_ip, "22", "root",
remote_pwd, "#")
# get uri of local
uri = libvirt_vm.complete_uri(local_ip)
cmd = "virsh -c %s start %s" % (uri, vm_ref)
status, output = session.cmd_status_output(cmd)
if status:
raise error.TestError(vm_ref, output)
elif opt.count("console"):
# With --console, start command will print the
# dmesg of guest in starting and turn into the
# login prompt. In this case, we start it with
# --console and login vm in console by
# remote.handle_prompts().
cmd = "start %s --console" % vm_ref
virsh_session = virsh.VirshSession(virsh_exec=virsh.VIRSH_EXEC, auto_close=True)
virsh_session.sendline(cmd)
remote.handle_prompts(virsh_session, params.get("username", ""),
params.get("password", ""), r"[\#\$]\s*$",
timeout=60, debug=True)
elif opt.count("autodestroy"):
# With --autodestroy, vm will be destroyed when
# virsh session closed. Then we execute start
# command in a virsh session and start vm with
# --autodestroy. Then we closed the virsh session,
# and check the vm is destroyed or not.
virsh_session = virsh.VirshSession(virsh_exec=virsh.VIRSH_EXEC, auto_close=True)
cmd = "start %s --autodestroy" % vm_ref
status = virsh_session.cmd_status(cmd)
if status:
raise error.TestFail("Failed to start vm with --autodestroy.")
# Close the session, then the vm shoud be destroyed.
virsh_session.close()
elif opt.count("force-boot"):
# With --force-boot, VM will be stared from boot
# even we have saved it with virsh managedsave.
# In this case, we start vm and execute sleep 1000&,
# then save it with virsh managedsave. At last, we
# start vm with --force-boot. To verify the result,
# we check the sleep process. If the process exists,
# force-boot failed, else case pass.
vm.start()
session = vm.wait_for_login()
status = session.cmd_status("sleep 1000&")
if status:
raise error.TestError("Can not execute command in guest.")
sleep_pid = session.cmd_output("echo $!").strip()
virsh.managedsave(vm_ref)
virsh.start(vm_ref, options=opt)
else:
cmd_result = virsh.start(vm_ref, options=opt)
if cmd_result.exit_status:
if status_error == "no":
raise error.TestFail("Start vm failed.\n Detail: %s"
% cmd_result)
else:
# start vm successfully
if status_error == "yes":
raise error.TestFail("Run successfully with wrong "
"command!\n Detail:%s"
% cmd_result)
if opt.count("paused"):
if not (vm.state() == "paused"):
raise error.TestFail("VM is not paused when started with "
"--paused.")
elif opt.count("autodestroy"):
if vm.is_alive():
raise error.TestFail("VM was started with --autodestroy,"
"but not destroyed when virsh session "
"closed.")
elif opt.count("force-boot"):
session = vm.wait_for_login()
status = session.cmd_status("ps %s |grep '[s]leep 1000'"
% sleep_pid)
if not status:
raise error.TestFail("VM was started with --force-boot,"
"but it is restored from a"
" managedsave.")
else:
if status_error == "no" and not vm.is_alive():
raise error.TestFail("VM was started but it is not alive.")
except remote.LoginError, detail:
raise error.TestFail("Failed to login guest.")
finally:
# clean up
if libvirtd_state == "off":
utils_libvirtd.libvirtd_start()
elif pre_operation == "rename":
libvirt_xml.VMXML.vm_rename(vm, backup_name)
if vm and vm.is_paused():
vm.resume()
# Restore VM
vmxml_backup.sync()
def run(test, params, env):
"""
Test command: virsh shutdown.
The conmand can gracefully shutdown a domain.
1.Prepare test environment.
2.When the libvirtd == "off", stop the libvirtd service.
3.Perform virsh setvcpus operation.
4.Recover test environment.
5.Confirm the test result.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
vm_ref = params.get("shutdown_vm_ref")
status_error = ("yes" == params.get("status_error"))
agent = ("yes" == params.get("shutdown_agent", "no"))
mode = params.get("shutdown_mode", "")
pre_domian_status = params.get("reboot_pre_domian_status", "running")
libvirtd = params.get("libvirtd", "on")
xml_backup = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
timeout = eval(params.get("shutdown_timeout", "60"))
readonly = "yes" == params.get("shutdown_readonly", "no")
expect_msg = params.get("shutdown_err_msg")
# Libvirt acl test related params
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':
test.cancel("API acl test not supported in"
" current libvirt version.")
try:
# Add or remove qemu-agent from guest before test
vm.prepare_guest_agent(channel=agent, start=agent)
if pre_domian_status == "shutoff":
virsh.destroy(vm_name)
domid = vm.get_id()
domuuid = vm.get_uuid()
# run test case
if vm_ref == "id":
vm_ref = domid
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 == "name":
vm_ref = "%s %s" % (vm_name, params.get("shutdown_extra"))
elif vm_ref == "uuid":
vm_ref = domuuid
if libvirtd == "off":
utils_libvirtd.libvirtd_stop()
if vm_ref != "remote":
result = virsh.shutdown(vm_ref, mode,
unprivileged_user=unprivileged_user,
uri=uri, debug=True,
ignore_status=True,
readonly=readonly)
status = result.exit_status
else:
remote_ip = params.get("remote_ip", "REMOTE.EXAMPLE.COM")
remote_pwd = params.get("remote_pwd", None)
remote_user = params.get("remote_user", "root")
local_ip = params.get("local_ip", "LOCAL.EXAMPLE.COM")
local_pwd = params.get("local_pwd", "password")
local_user = params.get("username", "root")
if remote_ip.count("EXAMPLE.COM") or local_ip.count("EXAMPLE.COM"):
test.cancel("Remote test parameters"
" unchanged from default")
status = 0
try:
remote_uri = libvirt_vm.complete_uri(local_ip)
# set up auto ssh login from remote machine to
# execute commands
config_opt = ["StrictHostKeyChecking=no"]
ssh_key.setup_remote_ssh_key(remote_ip, remote_user,
remote_pwd, hostname2=local_ip,
user2=local_user,
password2=local_pwd,
config_options=config_opt)
session = remote.remote_login("ssh", remote_ip, "22", "root",
remote_pwd, "#")
session.cmd_output('LANG=C')
command = ("virsh -c %s shutdown %s %s"
% (remote_uri, vm_name, mode))
status = session.cmd_status(command, internal_timeout=5)
session.close()
except process.CmdError:
status = 1
# 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!")
if expect_msg:
libvirt.check_result(result, expect_msg.split(';'))
else:
if status:
test.fail("Run failed with right command")
if not vm.wait_for_shutdown(timeout):
test.fail("Failed to shutdown in timeout %s" % timeout)
finally:
if utils_misc.wait_for(utils_libvirtd.libvirtd_is_running, 60):
xml_backup.sync()
def run_virsh_start(test, params, env):
"""
Test command: virsh start.
1) Get the params from params.
2) Prepare libvirtd's status.
3) Do the start operation.
4) Result check.
5) clean up.
"""
#get the params from params
vm_name = params.get("vm_name", "vm1")
backup_name = vm_name
if vm_name is not "":
vm = env.get_vm(vm_name)
vmxml = libvirt_xml.VMXML()
libvirtd_state = params.get("libvirtd", "on")
pre_operation = params.get("vs_pre_operation", "")
status_error = params.get("status_error", "no")
#get the params for remote test
remote_ip = params.get("remote_ip", "ENTER.YOUR.REMOTE.IP")
remote_password = params.get("remote_password", "ENTER.YOUR.REMOTE.PASSWORD")
local_ip = params.get("local_ip", "ENTER.YOUR.LOCAL.IP")
if pre_operation == "remote" and ( remote_ip.count("ENTER.YOUR.") or
local_ip.count("ENTER.YOUR.")):
raise error.TestNAError("Remote test parameters not configured")
try:
#prepare before start vm
if libvirtd_state == "on":
libvirt_vm.libvirtd_start()
elif libvirtd_state == "off":
libvirt_vm.libvirtd_stop()
if pre_operation == "rename":
new_vm_name = params.get("vs_new_vm_name", "virsh_start_vm1")
vm = libvirt_xml.VMXML.vm_rename(vm, new_vm_name)
vm_name = new_vm_name
elif pre_operation == "undefine":
vmxml = vmxml.new_from_dumpxml(vm_name)
vmxml.undefine()
#do the start operation
try:
if pre_operation == "remote":
#get remote session
session = remote.wait_for_login("ssh", remote_ip, "22", "root",
remote_password, "#")
#get uri of local
uri = libvirt_vm.complete_uri(local_ip)
cmd = "virsh -c %s start %s" % (uri, vm_name)
status, output = session.cmd_status_output(cmd)
if status:
raise StartError(vm_name, output)
else:
do_virsh_start(vm_name)
#start vm successfully
if status_error == "yes":
raise error.TestFail("Run successfully with wrong command!")
except StartError, excpt:
#start vm failed
if status_error == "no":
raise error.TestFail("Run failed with right command: %s",
str(excpt))
finally:
#clean up
if libvirtd_state == "off":
libvirt_vm.libvirtd_start()
if (pre_operation == "undefine") and (not vmxml.xml == None):
vmxml.define()
elif pre_operation == "rename":
libvirt_xml.VMXML.vm_rename(vm, backup_name)
def run(test, params, env):
"""
Test command: virsh shutdown.
The conmand can gracefully shutdown a domain.
1.Prepare test environment.
2.When the libvirtd == "off", stop the libvirtd service.
3.Perform virsh setvcpus operation.
4.Recover test environment.
5.Confirm the test result.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
vm_ref = params.get("shutdown_vm_ref")
status_error = ("yes" == params.get("status_error"))
agent = ("yes" == params.get("shutdown_agent", "no"))
mode = params.get("shutdown_mode", "")
pre_domian_status = params.get("reboot_pre_domian_status", "running")
libvirtd = params.get("libvirtd", "on")
xml_backup = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
# Libvirt acl test related params
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.")
try:
# Add or remove qemu-agent from guest before test
vm.prepare_guest_agent(channel=agent, start=agent)
if pre_domian_status == "shutoff":
virsh.destroy(vm_name)
domid = vm.get_id()
domuuid = vm.get_uuid()
# run test case
if vm_ref == "id":
vm_ref = domid
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 == "name":
vm_ref = "%s %s" % (vm_name, params.get("shutdown_extra"))
elif vm_ref == "uuid":
vm_ref = domuuid
if libvirtd == "off":
utils_libvirtd.libvirtd_stop()
if vm_ref != "remote":
status = virsh.shutdown(vm_ref,
mode,
unprivileged_user=unprivileged_user,
uri=uri,
debug=True,
ignore_status=True).exit_status
else:
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")
status = 0
try:
remote_uri = libvirt_vm.complete_uri(local_ip)
session = remote.remote_login("ssh", remote_ip, "22", "root",
remote_pwd, "#")
session.cmd_output('LANG=C')
command = ("virsh -c %s shutdown %s %s" %
(remote_uri, vm_name, mode))
status = session.cmd_status(command, internal_timeout=5)
session.close()
except process.CmdError:
status = 1
# 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:
raise error.TestFail("Run failed with right command")
finally:
xml_backup.sync()
def run_virsh_dommemstat(test, params, env):
"""
Test command: virsh dommemstat.
The command gets memory statistics for a domain
1.Prepare test environment.
2.When the ibvirtd == "off", stop the libvirtd service.
3.Perform virsh dommemstat operation.
4.Recover test environment.
5.Confirm the test result.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(params["main_vm"])
domid = vm.get_id()
domuuid = vm.get_uuid()
status_error = params.get("status_error", "no")
vm_ref = params.get("dommemstat_vm_ref", "name")
libvirtd = params.get("libvirtd", "on")
extra = params.get("dommemstat_extra", "")
if libvirtd == "off":
libvirt_vm.libvirtd_stop()
#run test case
if vm_ref == "id":
vm_ref = domid
elif vm_ref == "hex_id":
vm_ref = hex(int(domid))
elif vm_ref == "uuid":
vm_ref = domuuid
elif vm_ref.count("_invalid_"):
# vm_ref names parameter to fetch
vm_ref = params.get(vm_ref)
elif vm_ref == "name":
vm_ref = "%s" % vm_name
if libvirtd == "off":
libvirt_vm.libvirtd_stop()
if vm_ref != "remote":
status = virsh.dommemstat(vm_ref, extra, ignore_status=True,
debug=True).exit_status
else:
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("local/remote ip parameters not set.")
status = 0
try:
remote_uri = libvirt_vm.complete_uri(local_ip)
session = remote.remote_login("ssh", remote_ip, "22", "root",
remote_pwd, "#")
session.cmd_output('LANG=C')
command = "virsh -c %s dommemstat %s %s" % (remote_uri, vm_name,
extra)
status = session.cmd_status(command, internal_timeout=5)
session.close()
except error.CmdError:
status = 1
#recover libvirtd service start
if libvirtd == "off":
libvirt_vm.libvirtd_start()
#check status_error
if status_error == "yes":
if status == 0:
raise error.TestFail("Run successfully with wrong command!")
elif status_error == "no":
if status != 0:
raise error.TestFail("Run failed with right command")
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
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 virsh undefine command.
Undefine an inactive domain, or convert persistent to transient.
1.Prepare test environment.
2.Backup the VM's information to a xml file.
3.When the libvirtd == "off", stop the libvirtd service.
4.Perform virsh undefine operation.
5.Recover test environment.(libvirts service,VM)
6.Confirm the test result.
"""
vm_ref = params.get("undefine_vm_ref", "vm_name")
extra = params.get("undefine_extra", "")
option = params.get("undefine_option", "")
libvirtd_state = params.get("libvirtd", "on")
status_error = ("yes" == params.get("status_error", "no"))
undefine_twice = ("yes" == params.get("undefine_twice", 'no'))
local_ip = params.get("local_ip", "LOCAL.EXAMPLE.COM")
remote_ip = params.get("remote_ip", "REMOTE.EXAMPLE.COM")
remote_user = params.get("remote_user", "user")
remote_pwd = params.get("remote_pwd", "password")
remote_prompt = params.get("remote_prompt", "#")
pool_type = params.get("pool_type")
pool_name = params.get("pool_name", "test")
pool_target = params.get("pool_target")
volume_size = params.get("volume_size", "1G")
vol_name = params.get("vol_name", "test_vol")
emulated_img = params.get("emulated_img", "emulated_img")
emulated_size = "%sG" % (int(volume_size[:-1]) + 1)
disk_target = params.get("disk_target", "vdb")
wipe_data = "yes" == params.get("wipe_data", "no")
if wipe_data:
option += " --wipe-storage"
vm_name = params.get("main_vm", "virt-tests-vm1")
vm = env.get_vm(vm_name)
vm_id = vm.get_id()
vm_uuid = vm.get_uuid()
# polkit acl related params
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.")
# Back up xml file.Xen host has no guest xml file to define a guset.
backup_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
# Confirm how to reference a VM.
if vm_ref == "vm_name":
vm_ref = vm_name
elif vm_ref == "id":
vm_ref = vm_id
elif vm_ref == "hex_vm_id":
vm_ref = hex(int(vm_id))
elif vm_ref == "uuid":
vm_ref = vm_uuid
elif vm_ref.find("invalid") != -1:
vm_ref = params.get(vm_ref)
volume = None
pvtest = None
status3 = None
try:
save_file = "/var/lib/libvirt/qemu/save/%s.save" % vm_name
if option.count("managedsave") and vm.is_alive():
virsh.managedsave(vm_name)
if not vm.is_lxc():
snp_list = virsh.snapshot_list(vm_name)
if option.count("snapshot"):
snp_file_list = []
if not len(snp_list):
virsh.snapshot_create(vm_name)
logging.debug("Create a snapshot for test!")
else:
# Backup snapshots for domain
for snp_item in snp_list:
tmp_file = os.path.join(test.tmpdir, snp_item + ".xml")
virsh.snapshot_dumpxml(vm_name, snp_item, to_file=tmp_file)
snp_file_list.append(tmp_file)
else:
if len(snp_list):
raise error.TestNAError("This domain has snapshot(s), "
"cannot be undefined!")
if option.count("remove-all-storage"):
pvtest = utlv.PoolVolumeTest(test, params)
pvtest.pre_pool(pool_name, pool_type, pool_target, emulated_img,
emulated_size=emulated_size)
new_pool = libvirt_storage.PoolVolume(pool_name)
if not new_pool.create_volume(vol_name, volume_size):
raise error.TestFail("Creation of volume %s failed." % vol_name)
volumes = new_pool.list_volumes()
volume = volumes[vol_name]
virsh.attach_disk(vm_name, volume, disk_target, "--config")
# Turn libvirtd into certain state.
if libvirtd_state == "off":
utils_libvirtd.libvirtd_stop()
# Test virsh undefine command.
output = ""
if vm_ref != "remote":
vm_ref = "%s %s" % (vm_ref, extra)
cmdresult = virsh.undefine(vm_ref, option,
unprivileged_user=unprivileged_user,
uri=uri,
ignore_status=True, debug=True)
status = cmdresult.exit_status
output = cmdresult.stdout.strip()
if status:
logging.debug("Error status, command output: %s",
cmdresult.stderr.strip())
if undefine_twice:
status2 = virsh.undefine(vm_ref,
ignore_status=True).exit_status
else:
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")
try:
uri = libvirt_vm.complete_uri(local_ip)
session = remote.remote_login("ssh", remote_ip, "22",
remote_user, remote_pwd,
remote_prompt)
cmd_undefine = "virsh -c %s undefine %s" % (uri, vm_name)
status, output = session.cmd_status_output(cmd_undefine)
logging.info("Undefine output: %s", output)
except (error.CmdError, remote.LoginError, aexpect.ShellError), de:
logging.error("Detail: %s", de)
status = 1
# Recover libvirtd state.
if libvirtd_state == "off":
utils_libvirtd.libvirtd_start()
# Shutdown VM.
if virsh.domain_exists(vm.name):
try:
if vm.is_alive():
vm.destroy(gracefully=False)
except error.CmdError, detail:
logging.error("Detail: %s", detail)
def run(test, params, env):
"""
Test virsh undefine command.
Undefine an inactive domain, or convert persistent to transient.
1.Prepare test environment.
2.Backup the VM's information to a xml file.
3.When the libvirtd == "off", stop the libvirtd service.
4.Perform virsh undefine operation.
5.Recover test environment.(libvirts service,VM)
6.Confirm the test result.
"""
vm_ref = params.get("undefine_vm_ref", "vm_name")
extra = params.get("undefine_extra", "")
option = params.get("undefine_option", "")
libvirtd_state = params.get("libvirtd", "on")
status_error = ("yes" == params.get("status_error", "no"))
undefine_twice = ("yes" == params.get("undefine_twice", 'no'))
local_ip = params.get("local_ip", "LOCAL.EXAMPLE.COM")
remote_ip = params.get("remote_ip", "REMOTE.EXAMPLE.COM")
remote_user = params.get("remote_user", "user")
remote_pwd = params.get("remote_pwd", "password")
remote_prompt = params.get("remote_prompt", "#")
pool_type = params.get("pool_type")
pool_name = params.get("pool_name", "test")
pool_target = params.get("pool_target")
volume_size = params.get("volume_size", "1G")
vol_name = params.get("vol_name", "test_vol")
emulated_img = params.get("emulated_img", "emulated_img")
emulated_size = "%sG" % (int(volume_size[:-1]) + 1)
disk_target = params.get("disk_target", "vdb")
wipe_data = "yes" == params.get("wipe_data", "no")
if wipe_data:
option += " --wipe-storage"
vm_name = params.get("main_vm", "virt-tests-vm1")
vm = env.get_vm(vm_name)
vm_id = vm.get_id()
vm_uuid = vm.get_uuid()
# polkit acl related params
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.")
# Back up xml file.Xen host has no guest xml file to define a guset.
backup_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
# Confirm how to reference a VM.
if vm_ref == "vm_name":
vm_ref = vm_name
elif vm_ref == "id":
vm_ref = vm_id
elif vm_ref == "hex_vm_id":
vm_ref = hex(int(vm_id))
elif vm_ref == "uuid":
vm_ref = vm_uuid
elif vm_ref.find("invalid") != -1:
vm_ref = params.get(vm_ref)
volume = None
pvtest = None
status3 = None
try:
save_file = "/var/lib/libvirt/qemu/save/%s.save" % vm_name
if option.count("managedsave") and vm.is_alive():
virsh.managedsave(vm_name)
if not vm.is_lxc():
snp_list = virsh.snapshot_list(vm_name)
if option.count("snapshot"):
snp_file_list = []
if not len(snp_list):
virsh.snapshot_create(vm_name)
logging.debug("Create a snapshot for test!")
else:
# Backup snapshots for domain
for snp_item in snp_list:
tmp_file = os.path.join(test.tmpdir, snp_item + ".xml")
virsh.snapshot_dumpxml(vm_name, snp_item, to_file=tmp_file)
snp_file_list.append(tmp_file)
else:
if len(snp_list):
raise error.TestNAError("This domain has snapshot(s), "
"cannot be undefined!")
if option.count("remove-all-storage"):
pvtest = utlv.PoolVolumeTest(test, params)
pvtest.pre_pool(pool_name, pool_type, pool_target, emulated_img,
emulated_size=emulated_size)
new_pool = libvirt_storage.PoolVolume(pool_name)
if not new_pool.create_volume(vol_name, volume_size):
raise error.TestFail("Creation of volume %s failed." % vol_name)
volumes = new_pool.list_volumes()
volume = volumes[vol_name]
virsh.attach_disk(vm_name, volume, disk_target, "--config")
# Turn libvirtd into certain state.
if libvirtd_state == "off":
utils_libvirtd.libvirtd_stop()
# Test virsh undefine command.
output = ""
if vm_ref != "remote":
vm_ref = "%s %s" % (vm_ref, extra)
cmdresult = virsh.undefine(vm_ref, option,
unprivileged_user=unprivileged_user,
uri=uri,
ignore_status=True, debug=True)
status = cmdresult.exit_status
output = cmdresult.stdout.strip()
if status:
logging.debug("Error status, command output: %s",
cmdresult.stderr.strip())
if undefine_twice:
status2 = virsh.undefine(vm_ref,
ignore_status=True).exit_status
else:
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")
try:
uri = libvirt_vm.complete_uri(local_ip)
session = remote.remote_login("ssh", remote_ip, "22",
remote_user, remote_pwd,
remote_prompt)
cmd_undefine = "virsh -c %s undefine %s" % (uri, vm_name)
status, output = session.cmd_status_output(cmd_undefine)
logging.info("Undefine output: %s", output)
except (error.CmdError, remote.LoginError, aexpect.ShellError), de:
logging.error("Detail: %s", de)
status = 1
# Recover libvirtd state.
if libvirtd_state == "off":
utils_libvirtd.libvirtd_start()
# Shutdown VM.
if virsh.domain_exists(vm.name):
try:
if vm.is_alive():
vm.destroy(gracefully=False)
except error.CmdError, detail:
logging.error("Detail: %s", detail)
def run(test, params, env):
"""
Test storage migration
1) Do storage migration(copy-storage-all/copy-storage-inc) with
TLS encryption - NBD transport
2) Cancel storage migration with TLS encryption
3) Copy only the top image for storage migration with backing chain
:param test: test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment.
"""
def prepare_nfs_backingfile(vm, params):
"""
Create an image using nfs type backing_file
:param vm: The guest
:param params: the parameters used
"""
mnt_path_name = params.get("nfs_mount_dir", "nfs-mount")
exp_opt = params.get("export_options", "rw,no_root_squash,fsid=0")
exp_dir = params.get("export_dir", "nfs-export")
backingfile_img = params.get("source_dist_img", "nfs-img")
disk_format = params.get("disk_format", "qcow2")
img_name = params.get("img_name", "test.img")
precreation = "yes" == params.get("precreation", "yes")
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm.name)
disk_xml = vmxml.devices.by_device_tag('disk')[0]
src_disk_format = disk_xml.xmltreefile.find('driver').get('type')
first_disk = vm.get_first_disk_devices()
blk_source = first_disk['source']
disk_img = os.path.join(os.path.dirname(blk_source), img_name)
res = libvirt.setup_or_cleanup_nfs(True, mnt_path_name, is_mount=True,
export_options=exp_opt,
export_dir=exp_dir)
mnt_path = res["mount_dir"]
params["selinux_status_bak"] = res["selinux_status_bak"]
if vm.is_alive():
vm.destroy(gracefully=False)
disk_cmd = ("qemu-img convert -f %s -O %s %s %s/%s" %
(src_disk_format, disk_format,
blk_source, mnt_path, backingfile_img))
process.run(disk_cmd, ignore_status=False, verbose=True)
local_image_list.append("%s/%s" % (mnt_path, backingfile_img))
logging.debug("Create a local image backing on NFS.")
disk_cmd = ("qemu-img create -f %s -b %s/%s %s" %
(disk_format, mnt_path, backingfile_img, disk_img))
process.run(disk_cmd, ignore_status=False, verbose=True)
local_image_list.append(disk_img)
if precreation:
logging.debug("Create an image backing on NFS on remote host.")
remote_session = remote.remote_login("ssh", server_ip, "22",
server_user, server_pwd,
r'[$#%]')
utils_misc.make_dirs(os.path.dirname(blk_source), remote_session)
status, stdout = utils_misc.cmd_status_output(
disk_cmd, session=remote_session)
logging.debug("status: {}, stdout: {}".format(status, stdout))
remote_image_list.append("%s/%s" % (mnt_path, backingfile_img))
remote_image_list.append(disk_img)
remote_session.close()
params.update({'disk_source_name': disk_img,
'disk_type': 'file',
'disk_source_protocol': 'file'})
libvirt.set_vm_disk(vm, params)
migration_test = migration.MigrationTest()
migration_test.check_parameters(params)
# Local variables
server_ip = params["server_ip"] = params.get("remote_ip")
server_user = params["server_user"] = params.get("remote_user", "root")
server_pwd = params["server_pwd"] = params.get("remote_pwd")
client_ip = params["client_ip"] = params.get("local_ip")
client_pwd = params["client_pwd"] = params.get("local_pwd")
virsh_options = params.get("virsh_options", "")
copy_storage_option = params.get("copy_storage_option")
extra = params.get("virsh_migrate_extra", "")
options = params.get("virsh_migrate_options", "--live --verbose")
backingfile_type = params.get("backingfile_type")
check_str_local_log = params.get("check_str_local_log", "")
disk_format = params.get("disk_format", "qcow2")
log_file = params.get("log_outputs", "/var/log/libvirt/libvirtd.log")
daemon_conf_dict = eval(params.get("daemon_conf_dict", '{}'))
cancel_migration = "yes" == params.get("cancel_migration", "no")
migrate_again = "yes" == params.get("migrate_again", "no")
precreation = "yes" == params.get("precreation", "yes")
tls_recovery = "yes" == params.get("tls_auto_recovery", "yes")
func_params_exists = "yes" == params.get("func_params_exists", "no")
status_error = "yes" == params.get("status_error", "no")
local_image_list = []
remote_image_list = []
tls_obj = None
func_name = None
daemon_conf = None
mig_result = None
remote_session = None
vm_session = None
# params for migration connection
params["virsh_migrate_desturi"] = libvirt_vm.complete_uri(
params.get("migrate_dest_host"))
dest_uri = params.get("virsh_migrate_desturi")
vm_name = params.get("migrate_main_vm")
vm = env.get_vm(vm_name)
vm.verify_alive()
extra = "{} {}".format(extra, copy_storage_option)
extra_args = {}
if func_params_exists:
extra_args.update({'func_params': params})
if cancel_migration:
func_name = migration_test.do_cancel
# For safety reasons, we'd better back up xmlfile.
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
orig_config_xml = vmxml.copy()
try:
if backingfile_type:
if backingfile_type == "nfs":
prepare_nfs_backingfile(vm, params)
if extra.count("copy-storage-all") and precreation:
blk_source = vm.get_first_disk_devices()['source']
vsize = utils_misc.get_image_info(blk_source).get("vsize")
remote_session = remote.remote_login("ssh", server_ip, "22",
server_user, server_pwd,
r'[$#%]')
utils_misc.make_dirs(os.path.dirname(blk_source), remote_session)
disk_cmd = ("qemu-img create -f %s %s %s" %
(disk_format, blk_source, vsize))
status, stdout = utils_misc.cmd_status_output(
disk_cmd, session=remote_session)
logging.debug("status: {}, stdout: {}".format(status, stdout))
remote_image_list.append(blk_source)
remote_session.close()
# Update libvirtd configuration
if daemon_conf_dict:
if os.path.exists(log_file):
os.remove(log_file)
daemon_conf = libvirt.customize_libvirt_config(daemon_conf_dict)
if extra.count("--tls"):
tls_obj = TLSConnection(params)
if tls_recovery:
tls_obj.auto_recover = True
tls_obj.conn_setup()
if not vm.is_alive():
vm.start()
logging.debug("Guest xml after starting:\n%s",
vm_xml.VMXML.new_from_dumpxml(vm_name))
# Check local guest network connection before migration
vm_session = vm.wait_for_login(restart_network=True)
migration_test.ping_vm(vm, params)
# Execute migration process
vms = [vm]
migration_test.do_migration(vms, None, dest_uri, 'orderly',
options, thread_timeout=900,
ignore_status=True, virsh_opt=virsh_options,
extra_opts=extra, func=func_name,
**extra_args)
mig_result = migration_test.ret
migration_test.check_result(mig_result, params)
if migrate_again and status_error:
logging.debug("Sleeping 10 seconds before rerun migration")
time.sleep(10)
if cancel_migration:
func_name = None
params["status_error"] = "no"
migration_test.do_migration(vms, None, dest_uri, 'orderly',
options, thread_timeout=900,
ignore_status=True,
virsh_opt=virsh_options,
extra_opts=extra, func=func_name,
**extra_args)
mig_result = migration_test.ret
migration_test.check_result(mig_result, params)
if int(mig_result.exit_status) == 0:
migration_test.ping_vm(vm, params, uri=dest_uri)
if check_str_local_log:
libvirt.check_logfile(check_str_local_log, log_file)
finally:
logging.debug("Recover test environment")
# Clean VM on destination and source
try:
migration_test.cleanup_dest_vm(vm, vm.connect_uri, dest_uri)
if vm.is_alive():
vm.destroy(gracefully=False)
except Exception as err:
logging.error(err)
logging.info("Recovery VM XML configration")
orig_config_xml.sync()
if daemon_conf:
logging.debug("Recover the configurations")
libvirt.customize_libvirt_config(None, is_recover=True,
config_object=daemon_conf)
if tls_obj:
logging.debug("Clean up local objs")
del tls_obj
for source_file in local_image_list:
libvirt.delete_local_disk("file", path=source_file)
for img in remote_image_list:
remote.run_remote_cmd("rm -rf %s" % img, params)
if remote_session:
remote_session.close()
def run(test, params, env):
"""
Test command: virsh start.
1) Get the params from params.
2) Prepare libvirtd's status.
3) Do the start operation.
4) Result check.
5) clean up.
"""
# get the params from params
vm_name = params.get("main_vm", "virt-tests-vm1")
vm_ref = params.get("vm_ref", "vm1")
opt = params.get("vs_opt", "")
# Backup for recovery.
vmxml_backup = libvirt_xml.vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
backup_name = vm_ref
vm = None
if vm_ref is not "":
vm = env.get_vm(vm_ref)
vmxml = libvirt_xml.VMXML()
libvirtd_state = params.get("libvirtd", "on")
pre_operation = params.get("vs_pre_operation", "")
status_error = params.get("status_error", "no")
# get the params for remote test
remote_ip = params.get("remote_ip", "ENTER.YOUR.REMOTE.IP")
remote_pwd = params.get("remote_pwd", "ENTER.YOUR.REMOTE.PASSWORD")
local_ip = params.get("local_ip", "ENTER.YOUR.LOCAL.IP")
if pre_operation == "remote" and (remote_ip.count("ENTER.YOUR.")
or local_ip.count("ENTER.YOUR.")):
raise error.TestNAError("Remote test parameters not configured")
try:
# prepare before start vm
if libvirtd_state == "on":
utils_libvirtd.libvirtd_start()
elif libvirtd_state == "off":
utils_libvirtd.libvirtd_stop()
if pre_operation == "rename":
new_vm_name = params.get("vs_new_vm_name", "virsh_start_vm1")
vm = libvirt_xml.VMXML.vm_rename(vm, new_vm_name)
vm_ref = new_vm_name
elif pre_operation == "undefine":
vmxml = vmxml.new_from_dumpxml(vm_ref)
vmxml.undefine()
# do the start operation
try:
if pre_operation == "remote":
# get remote session
session = remote.wait_for_login("ssh", remote_ip, "22", "root",
remote_pwd, "#")
# get uri of local
uri = libvirt_vm.complete_uri(local_ip)
cmd = "virsh -c %s start %s" % (uri, vm_ref)
status, output = session.cmd_status_output(cmd)
if status:
raise error.TestError(vm_ref, output)
elif opt.count("console"):
# With --console, start command will print the
# dmesg of guest in starting and turn into the
# login prompt. In this case, we start it with
# --console and login vm in console by
# remote.handle_prompts().
cmd = "start %s --console" % vm_ref
virsh_session = virsh.VirshSession(auto_close=True)
virsh_session.sendline(cmd)
remote.handle_prompts(virsh_session,
params.get("username", ""),
params.get("password", ""),
r"[\#\$]\s*$",
timeout=60,
debug=True)
elif opt.count("autodestroy"):
# With --autodestroy, vm will be destroyed when
# virsh session closed. Then we execute start
# command in a virsh session and start vm with
# --autodestroy. Then we closed the virsh session,
# and check the vm is destroyed or not.
virsh_session = virsh.VirshSession(auto_close=True)
cmd = "start %s --autodestroy" % vm_ref
status = virsh_session.cmd_status(cmd)
if status:
raise error.TestFail(
"Failed to start vm with --autodestroy.")
# Close the session, then the vm shoud be destroyed.
virsh_session.close()
elif opt.count("force-boot"):
# With --force-boot, VM will be stared from boot
# even we have saved it with virsh managedsave.
# In this case, we start vm and execute sleep 1000&,
# then save it with virsh managedsave. At last, we
# start vm with --force-boot. To verify the result,
# we check the sleep process. If the process exists,
# force-boot failed, else case pass.
vm.start()
session = vm.wait_for_login()
status = session.cmd_status("sleep 1000&")
if status:
raise error.TestError("Can not execute command in guest.")
virsh.managedsave(vm_ref)
virsh.start(vm_ref, options=opt)
else:
cmd_result = virsh.start(vm_ref, options=opt)
if cmd_result.exit_status:
if status_error == "no":
raise error.TestFail("Start vm failed.\n Detail: %s" %
cmd_result)
else:
# start vm successfully
if status_error == "yes":
raise error.TestFail("Run successfully with wrong "
"command!\n Detail:%s" %
cmd_result)
if opt.count("paused"):
if not (vm.state() == "paused"):
raise error.TestFail("VM is not paused when started with "
"--paused.")
elif opt.count("autodestroy"):
if vm.is_alive():
raise error.TestFail(
"VM was started with --autodestroy,"
"but not destroyed when virsh session "
"closed.")
elif opt.count("force-boot"):
session = vm.wait_for_login()
status = session.cmd_status("ps -ef|grep sleep|grep -v grep")
if not status:
raise error.TestFail("VM was started with --force-boot,"
"but it is restored from a"
" managedsave.")
else:
if status_error == "no" and not vm.is_alive():
raise error.TestFail("VM was started but it is not alive.")
except remote.LoginError, detail:
raise error.TestFail("Failed to login guest.")
finally:
# clean up
if libvirtd_state == "off":
utils_libvirtd.libvirtd_start()
elif pre_operation == "rename":
libvirt_xml.VMXML.vm_rename(vm, backup_name)
if vm and vm.is_paused():
vm.resume()
# Restore VM
vmxml_backup.sync()
def run(test, params, env):
"""
Test command: virsh domstate.
1.Prepare test environment.
2.When the libvirtd == "off", stop the libvirtd service.
3.Perform virsh domstate operation.
4.Recover test environment.
5.Confirm the test result.
"""
vm_name = params.get("main_vm", "avocado-vt-vm1")
vm = env.get_vm(vm_name)
libvirtd_state = params.get("libvirtd", "on")
vm_ref = params.get("domstate_vm_ref")
status_error = (params.get("status_error", "no") == "yes")
extra = params.get("domstate_extra", "")
vm_action = params.get("domstate_vm_action", "")
vm_oncrash_action = params.get("domstate_vm_oncrash")
domid = vm.get_id()
domuuid = vm.get_uuid()
libvirtd_service = utils_libvirtd.Libvirtd()
if vm_ref == "id":
vm_ref = domid
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 == "name":
vm_ref = vm_name
elif vm_ref == "uuid":
vm_ref = domuuid
# Back up xml file.
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
backup_xml = vmxml.copy()
# Back up qemu.conf
qemu_conf = utils_config.LibvirtQemuConfig()
libvirtd = utils_libvirtd.Libvirtd()
dump_path = os.path.join(test.tmpdir, "dump/")
os.mkdir(dump_path)
dump_file = ""
try:
if vm_action == "crash":
if vm.is_alive():
vm.destroy(gracefully=False)
vmxml.on_crash = vm_oncrash_action
if not vmxml.xmltreefile.find('devices').findall('panic'):
# Add <panic> device to domain
panic_dev = Panic()
panic_dev.addr_type = "isa"
panic_dev.addr_iobase = "0x505"
vmxml.add_device(panic_dev)
vmxml.sync()
# Config auto_dump_path in qemu.conf
qemu_conf.auto_dump_path = dump_path
libvirtd_service.restart()
if vm_oncrash_action in ['coredump-destroy', 'coredump-restart']:
dump_file = dump_path + "*" + vm_name + "-*"
# Start VM and check the panic device
virsh.start(vm_name, ignore_status=False)
vmxml_new = vm_xml.VMXML.new_from_dumpxml(vm_name)
# Skip this test if no panic device find
if not vmxml_new.xmltreefile.find('devices').findall('panic'):
raise exceptions.TestSkipError(
"No 'panic' device in the guest. Maybe your libvirt "
"version doesn't support it.")
try:
if vm_action == "suspend":
virsh.suspend(vm_name, ignore_status=False)
elif vm_action == "resume":
virsh.suspend(vm_name, ignore_status=False)
virsh.resume(vm_name, ignore_status=False)
elif vm_action == "destroy":
virsh.destroy(vm_name, ignore_status=False)
elif vm_action == "start":
virsh.destroy(vm_name, ignore_status=False)
virsh.start(vm_name, ignore_status=False)
elif vm_action == "kill":
libvirtd_service.stop()
utils_misc.kill_process_by_pattern(vm_name)
libvirtd_service.restart()
elif vm_action == "crash":
session = vm.wait_for_login()
session.cmd("service kdump stop", ignore_all_errors=True)
# Enable sysRq
session.cmd("echo 1 > /proc/sys/kernel/sysrq")
# Send key ALT-SysRq-c to crash VM, and command will not
# return as vm crashed, so fail early for 'destroy' and
# 'preserve' action. For 'restart', 'coredump-restart'
# and 'coredump-destroy' actions, they all need more time
# to dump core file or restart OS, so using the default
# session command timeout(60s)
try:
if vm_oncrash_action in ['destroy', 'preserve']:
timeout = 3
else:
timeout = 60
session.cmd("echo c > /proc/sysrq-trigger",
timeout=timeout)
except (ShellTimeoutError, ShellProcessTerminatedError):
pass
session.close()
except process.CmdError, detail:
raise exceptions.TestError("Guest prepare action error: %s" %
detail)
if libvirtd_state == "off":
libvirtd_service.stop()
if vm_ref == "remote":
remote_ip = params.get("remote_ip", "REMOTE.EXAMPLE.COM")
local_ip = params.get("local_ip", "LOCAL.EXAMPLE.COM")
remote_pwd = params.get("remote_pwd", None)
if remote_ip.count("EXAMPLE.COM") or local_ip.count("EXAMPLE.COM"):
raise exceptions.TestSkipError(
"Test 'remote' parameters not setup")
status = 0
try:
remote_uri = libvirt_vm.complete_uri(local_ip)
session = remote.remote_login("ssh", remote_ip, "22", "root",
remote_pwd, "#")
session.cmd_output('LANG=C')
command = "virsh -c %s domstate %s" % (remote_uri, vm_name)
status, output = session.cmd_status_output(command,
internal_timeout=5)
session.close()
except process.CmdError:
status = 1
else:
result = virsh.domstate(vm_ref,
extra,
ignore_status=True,
debug=True)
status = result.exit_status
output = result.stdout.strip()
# check status_error
if status_error:
if not status:
raise exceptions.TestFail(
"Run successfully with wrong command!")
else:
if status or not output:
raise exceptions.TestFail("Run failed with right command")
if extra.count("reason"):
if vm_action == "suspend":
# If not, will cost long time to destroy vm
virsh.destroy(vm_name)
if not output.count("user"):
raise ActionError(vm_action)
elif vm_action == "resume":
if not output.count("unpaused"):
raise ActionError(vm_action)
elif vm_action == "destroy":
if not output.count("destroyed"):
raise ActionError(vm_action)
elif vm_action == "start":
if not output.count("booted"):
raise ActionError(vm_action)
elif vm_action == "kill":
if not output.count("crashed"):
raise ActionError(vm_action)
elif vm_action == "crash":
if not check_crash_state(output, vm_oncrash_action,
vm_name, dump_file):
raise ActionError(vm_action)
if vm_ref == "remote":
if not (re.search("running", output) or re.search(
"blocked", output) or re.search("idle", output)):
raise exceptions.TestFail("Run failed with right command")
def run(test, params, env):
"""
Test command: virsh shutdown.
The conmand can gracefully shutdown a domain.
1.Prepare test environment.
2.When the libvirtd == "off", stop the libvirtd service.
3.Perform virsh setvcpus operation.
4.Recover test environment.
5.Confirm the test result.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
domid = vm.get_id()
domuuid = vm.get_uuid()
vm_ref = params.get("shutdown_vm_ref")
libvirtd = params.get("libvirtd", "on")
# run test case
if vm_ref == "id":
vm_ref = domid
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 == "name":
vm_ref = "%s %s" % (vm_name, params.get("shutdown_extra"))
elif vm_ref == "uuid":
vm_ref = domuuid
if libvirtd == "off":
utils_libvirtd.libvirtd_stop()
if vm_ref != "remote":
status = virsh.shutdown(vm_ref, ignore_status=True).exit_status
else:
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")
status = 0
try:
remote_uri = libvirt_vm.complete_uri(local_ip)
session = remote.remote_login("ssh", remote_ip, "22", "root",
remote_pwd, "#")
session.cmd_output('LANG=C')
command = "virsh -c %s shutdown %s" % (remote_uri, vm_name)
status = session.cmd_status(command, internal_timeout=5)
session.close()
except error.CmdError:
status = 1
# recover libvirtd service start
if libvirtd == "off":
utils_libvirtd.libvirtd_start()
# check status_error
status_error = params.get("status_error")
if status_error == "yes":
if status == 0:
raise error.TestFail("Run successfully with wrong command!")
elif status_error == "no":
if status != 0:
raise error.TestFail("Run failed with right command")
def run(test, params, env):
"""
Test command: virsh destroy.
The command can destroy (stop) a domain.
1.Prepare test environment.
2.When the ibvirtd == "off", stop the libvirtd service.
3.Perform virsh destroy operation.
4.Recover test environment.
5.Confirm the test result.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
domid = vm.get_id()
domuuid = vm.get_uuid()
vm_ref = params.get("destroy_vm_ref")
status_error = params.get("status_error", "no")
libvirtd = params.get("libvirtd", "on")
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")
local_pwd = params.get("local_pwd", "LOCAL.EXAMPLE.COM")
if vm_ref == "remote" and (remote_ip.count("EXAMPLE.COM") or
local_ip.count("EXAMPLE.COM")):
raise error.TestNAError(
"Remote test parameters unchanged from default")
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.")
if vm_ref == "id":
vm_ref = domid
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 == "name":
vm_ref = "%s %s" % (vm_name, params.get("destroy_extra"))
elif vm_ref == "uuid":
vm_ref = domuuid
if libvirtd == "off":
utils_libvirtd.libvirtd_stop()
if vm_ref != "remote":
status = virsh.destroy(vm_ref, ignore_status=True,
unprivileged_user=unprivileged_user,
uri=uri, debug=True).exit_status
output = ""
else:
status = 0
try:
remote_uri = libvirt_vm.complete_uri(local_ip)
session = remote.remote_login("ssh", remote_ip, "22",
"root", remote_pwd, "#")
session.cmd_output('LANG=C')
# Setup up remote to remote login in local host
ssh_key.setup_remote_ssh_key(remote_ip, "root", remote_pwd,
local_ip, "root", local_pwd)
command = "virsh -c %s destroy %s" % (remote_uri, vm_name)
status, output = session.cmd_status_output(command,
internal_timeout=5)
session.close()
except error.CmdError:
status = 1
if libvirtd == "off":
utils_libvirtd.libvirtd_start()
# check status_error
if status_error == "yes":
if status == 0:
raise error.TestFail("Run successfully with wrong command! "
"Output:\n%s" % output)
elif status_error == "no":
if status != 0:
raise error.TestFail("Run failed with right command! Output:\n%s"
% output)
def run(test, params, env):
"""
Test virsh undefine command.
Undefine an inactive domain, or convert persistent to transient.
1.Prepare test environment.
2.Backup the VM's information to a xml file.
3.When the libvirtd == "off", stop the libvirtd service.
4.Perform virsh undefine operation.
5.Recover test environment.(libvirts service,VM)
6.Confirm the test result.
"""
vm_ref = params.get("undefine_vm_ref", "vm_name")
extra = params.get("undefine_extra", "")
option = params.get("undefine_option", "")
libvirtd_state = params.get("libvirtd", "on")
status_error = ("yes" == params.get("status_error", "no"))
undefine_twice = ("yes" == params.get("undefine_twice", 'no'))
local_ip = params.get("local_ip", "LOCAL.EXAMPLE.COM")
local_pwd = params.get("local_pwd", "password")
remote_ip = params.get("remote_ip", "REMOTE.EXAMPLE.COM")
remote_user = params.get("remote_user", "user")
remote_pwd = params.get("remote_pwd", "password")
remote_prompt = params.get("remote_prompt", "#")
pool_type = params.get("pool_type")
pool_name = params.get("pool_name", "test")
pool_target = params.get("pool_target")
volume_size = params.get("volume_size", "1G")
vol_name = params.get("vol_name", "test_vol")
emulated_img = params.get("emulated_img", "emulated_img")
emulated_size = "%sG" % (int(volume_size[:-1]) + 1)
disk_target = params.get("disk_target", "vdb")
wipe_data = "yes" == params.get("wipe_data", "no")
if wipe_data:
option += " --wipe-storage"
nvram_o = None
if platform.machine() == 'aarch64':
nvram_o = " --nvram"
option += nvram_o
vm_name = params.get("main_vm", "avocado-vt-vm1")
vm = env.get_vm(vm_name)
vm_id = vm.get_id()
vm_uuid = vm.get_uuid()
# polkit acl related params
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':
test.cancel("API acl test not supported in current"
" libvirt version.")
# Back up xml file.Xen host has no guest xml file to define a guset.
backup_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
# Confirm how to reference a VM.
if vm_ref == "vm_name":
vm_ref = vm_name
elif vm_ref == "id":
vm_ref = vm_id
elif vm_ref == "hex_vm_id":
vm_ref = hex(int(vm_id))
elif vm_ref == "uuid":
vm_ref = vm_uuid
elif vm_ref.find("invalid") != -1:
vm_ref = params.get(vm_ref)
volume = None
pvtest = None
status3 = None
elems = backup_xml.xmltreefile.findall('/devices/disk/source')
existing_images = [elem.get('file') for elem in elems]
# Backup images since remove-all-storage could remove existing libvirt
# managed guest images
if existing_images and option.count("remove-all-storage"):
for img in existing_images:
backup_img = img + '.bak'
logging.info('Backup %s to %s', img, backup_img)
shutil.copyfile(img, backup_img)
try:
save_file = "/var/lib/libvirt/qemu/save/%s.save" % vm_name
if option.count("managedsave") and vm.is_alive():
virsh.managedsave(vm_name)
if not vm.is_lxc():
snp_list = virsh.snapshot_list(vm_name)
if option.count("snapshot"):
snp_file_list = []
if not len(snp_list):
virsh.snapshot_create(vm_name)
logging.debug("Create a snapshot for test!")
else:
# Backup snapshots for domain
for snp_item in snp_list:
tmp_file = os.path.join(data_dir.get_tmp_dir(),
snp_item + ".xml")
virsh.snapshot_dumpxml(vm_name,
snp_item,
to_file=tmp_file)
snp_file_list.append(tmp_file)
else:
if len(snp_list):
test.cancel("This domain has snapshot(s), "
"cannot be undefined!")
if option.count("remove-all-storage"):
pvtest = utlv.PoolVolumeTest(test, params)
pvtest.pre_pool(pool_name,
pool_type,
pool_target,
emulated_img,
emulated_size=emulated_size)
new_pool = libvirt_storage.PoolVolume(pool_name)
if not new_pool.create_volume(vol_name, volume_size):
test.fail("Creation of volume %s failed." % vol_name)
volumes = new_pool.list_volumes()
volume = volumes[vol_name]
ret = virsh.attach_disk(vm_name,
volume,
disk_target,
"--config",
debug=True)
if ret.exit_status != 0:
test.error("Attach disk failed: %s" % ret.stderr)
# Turn libvirtd into certain state.
if libvirtd_state == "off":
utils_libvirtd.libvirtd_stop()
# Test virsh undefine command.
output = ""
if vm_ref != "remote":
vm_ref = "%s %s" % (vm_ref, extra)
cmdresult = virsh.undefine(vm_ref,
option,
unprivileged_user=unprivileged_user,
uri=uri,
ignore_status=True,
debug=True)
status = cmdresult.exit_status
output = cmdresult.stdout.strip()
if status:
logging.debug("Error status, command output: %s",
cmdresult.stderr.strip())
if undefine_twice:
status2 = virsh.undefine(vm_ref, nvram_o,
ignore_status=True).exit_status
else:
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")
try:
local_user = params.get("username", "root")
uri = libvirt_vm.complete_uri(local_ip)
# setup ssh auto login from remote machine to test machine
# for the command to execute remotely
ssh_key.setup_remote_ssh_key(remote_ip,
remote_user,
remote_pwd,
hostname2=local_ip,
user2=local_user,
password2=local_pwd)
session = remote.remote_login("ssh", remote_ip, "22",
remote_user, remote_pwd,
remote_prompt)
cmd_undefine = "virsh -c %s undefine %s" % (uri, vm_name)
status, output = session.cmd_status_output(cmd_undefine)
logging.info("Undefine output: %s", output)
except (process.CmdError, remote.LoginError,
aexpect.ShellError) as de:
logging.error("Detail: %s", de)
status = 1
# Recover libvirtd state.
if libvirtd_state == "off":
utils_libvirtd.libvirtd_start()
# Shutdown VM.
if virsh.domain_exists(vm.name):
try:
if vm.is_alive():
vm.destroy(gracefully=False)
except process.CmdError as detail:
logging.error("Detail: %s", detail)
# After vm.destroy, virsh.domain_exists returns True due to
# timing issue and tests fails.
time.sleep(2)
# Check if VM exists.
vm_exist = virsh.domain_exists(vm_name)
# Check if xml file exists.
xml_exist = False
if vm.is_qemu() and os.path.exists(
"/etc/libvirt/qemu/%s.xml" % vm_name):
xml_exist = True
if vm.is_lxc() and os.path.exists("/etc/libvirt/lxc/%s.xml" % vm_name):
xml_exist = True
if vm.is_xen() and os.path.exists("/etc/xen/%s" % vm_name):
xml_exist = True
# Check if save file exists if use --managed-save
save_exist = os.path.exists(save_file)
# Check if save file exists if use --managed-save
volume_exist = volume and os.path.exists(volume)
# Test define with acl control and recover domain.
if params.get('setup_libvirt_polkit') == 'yes':
if virsh.domain_exists(vm.name):
virsh.undefine(vm_ref, nvram_o, ignore_status=True)
cmd = "chmod 666 %s" % backup_xml.xml
process.run(cmd, ignore_status=False, shell=True)
s_define = virsh.define(backup_xml.xml,
unprivileged_user=unprivileged_user,
uri=uri,
ignore_status=True,
debug=True)
status3 = s_define.exit_status
finally:
# Recover main VM.
try:
backup_xml.sync()
except LibvirtXMLError:
# sync() tries to undefines and define the xml to sync
# but virsh_undefine test would have undefined already
# may lead to error out
backup_xml.define()
# Recover existing guest images
if existing_images and option.count("remove-all-storage"):
for img in existing_images:
backup_img = img + '.bak'
logging.info('Recover image %s to %s', backup_img, img)
shutil.move(backup_img, img)
# Clean up pool
if pvtest:
pvtest.cleanup_pool(pool_name, pool_type, pool_target,
emulated_img)
# Recover VM snapshots.
if option.count("snapshot") and (not vm.is_lxc()):
logging.debug("Recover snapshots for domain!")
for file_item in snp_file_list:
virsh.snapshot_create(vm_name, file_item)
# Check results.
if status_error:
if not status:
if libvirtd_state == "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("virsh undefine return unexpected result.")
if params.get('setup_libvirt_polkit') == 'yes':
if status3 == 0:
test.fail("virsh define with false acl permission" +
" should failed.")
else:
if status:
test.fail("virsh undefine failed.")
if undefine_twice:
if not status2:
test.fail("Undefine the same VM twice succeeded.")
if vm_exist:
test.fail("VM still exists after undefine.")
if xml_exist:
test.fail("Xml file still exists after undefine.")
if option.count("managedsave") and save_exist:
test.fail("Save file still exists after undefine.")
if option.count("remove-all-storage") and volume_exist:
test.fail("Volume file '%s' still exists after"
" undefine." % volume)
if wipe_data and option.count("remove-all-storage"):
if not output.count("Wiping volume '%s'" % disk_target):
test.fail("Command didn't wipe volume storage!")
if params.get('setup_libvirt_polkit') == 'yes':
if status3:
test.fail("virsh define with right acl permission" +
" should succeeded")
def run(test, params, env):
"""
Test command: virsh destroy.
The command can destroy (stop) a domain.
1.Prepare test environment.
2.When the ibvirtd == "off", stop the libvirtd service.
3.Perform virsh destroy operation.
4.Recover test environment.
5.Confirm the test result.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
domid = vm.get_id()
domuuid = vm.get_uuid()
vm_ref = params.get("destroy_vm_ref")
status_error = params.get("status_error", "no")
libvirtd = params.get("libvirtd", "on")
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")
local_pwd = params.get("local_pwd", "LOCAL.EXAMPLE.COM")
if vm_ref == "remote" and (remote_ip.count("EXAMPLE.COM")
or local_ip.count("EXAMPLE.COM")):
raise error.TestNAError(
"Remote test parameters unchanged from default")
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.")
if vm_ref == "id":
vm_ref = domid
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 == "name":
vm_ref = "%s %s" % (vm_name, params.get("destroy_extra"))
elif vm_ref == "uuid":
vm_ref = domuuid
if libvirtd == "off":
utils_libvirtd.libvirtd_stop()
if vm_ref != "remote":
status = virsh.destroy(vm_ref,
ignore_status=True,
unprivileged_user=unprivileged_user,
uri=uri,
debug=True).exit_status
output = ""
else:
status = 0
try:
remote_uri = libvirt_vm.complete_uri(local_ip)
session = remote.remote_login("ssh", remote_ip, "22", "root",
remote_pwd, "#")
session.cmd_output('LANG=C')
# Setup up remote to remote login in local host
ssh_key.setup_remote_ssh_key(remote_ip, "root", remote_pwd,
local_ip, "root", local_pwd)
command = "virsh -c %s destroy %s" % (remote_uri, vm_name)
status, output = session.cmd_status_output(command,
internal_timeout=5)
session.close()
except process.CmdError:
status = 1
if libvirtd == "off":
utils_libvirtd.libvirtd_start()
# check status_error
if status_error == "yes":
if status == 0:
raise error.TestFail("Run successfully with wrong command! "
"Output:\n%s" % output)
elif status_error == "no":
if status != 0:
raise error.TestFail("Run failed with right command! Output:\n%s" %
output)
def run(test, params, env):
"""
Test virsh migrate command.
"""
def set_feature(vmxml, feature, value):
"""
Set guest features for PPC
:param state: the htm status
:param vmxml: guest xml
"""
features_xml = vm_xml.VMFeaturesXML()
if feature == 'hpt':
features_xml.hpt_resizing = value
elif feature == 'htm':
features_xml.htm = value
vmxml.features = features_xml
vmxml.sync()
def trigger_hpt_resize(session):
"""
Check the HPT order file and dmesg
:param session: the session to guest
:raise: test.fail if required message is not found
"""
hpt_order_path = "/sys/kernel/debug/powerpc/hpt_order"
hpt_order = session.cmd_output('cat %s' % hpt_order_path).strip()
hpt_order = int(hpt_order)
logging.info('Current hpt_order is %d', hpt_order)
hpt_order += 1
cmd = 'echo %d > %s' % (hpt_order, hpt_order_path)
cmd_result = session.cmd_status_output(cmd)
result = process.CmdResult(stderr=cmd_result[1],
stdout=cmd_result[1],
exit_status=cmd_result[0])
libvirt.check_exit_status(result)
dmesg = session.cmd('dmesg')
dmesg_content = params.get('dmesg_content').split('|')
for content in dmesg_content:
if content % hpt_order not in dmesg:
test.fail("'%s' is missing in dmesg" % (content % hpt_order))
else:
logging.info("'%s' is found in dmesg", content % hpt_order)
def check_vm_network_accessed(session=None):
"""
The operations to the VM need to be done before or after
migration happens
:param session: The session object to the host
:raise: test.error when ping fails
"""
# Confirm local/remote VM can be accessed through network.
logging.info("Check VM network connectivity")
s_ping, _ = utils_test.ping(vm.get_address(),
count=10,
timeout=20,
output_func=logging.debug,
session=session)
if s_ping != 0:
if session:
session.close()
test.fail("%s did not respond after %d sec." % (vm.name, 20))
def check_virsh_command_and_option(command, option=None):
"""
Check if virsh command exists
:param command: the command to be checked
:param option: the command option to be checked
"""
msg = "This version of libvirt does not support "
if not virsh.has_help_command(command):
test.cancel(msg + "virsh command '%s'" % command)
if option and not virsh.has_command_help_match(command, option):
test.cancel(msg + "virsh command '%s' with option '%s'" % (command,
option))
def add_ctrls(vm_xml, dev_type="pci", dev_index="0", dev_model="pci-root"):
"""
Add multiple devices
:param dev_type: the type of the device to be added
:param dev_index: the maximum index of the device to be added
:param dev_model: the model of the device to be added
"""
for inx in range(0, int(dev_index) + 1):
newcontroller = Controller("controller")
newcontroller.type = dev_type
newcontroller.index = inx
newcontroller.model = dev_model
logging.debug("New device is added:\n%s", newcontroller)
vm_xml.add_device(newcontroller)
vm_xml.sync()
def do_migration(vm, dest_uri, options, extra):
"""
Execute the migration with given parameters
:param vm: the guest to be migrated
:param dest_uri: the destination uri for migration
:param options: options next to 'migrate' command
:param extra: options in the end of the migrate command line
:return: CmdResult object
"""
logging.info("Sleeping 10 seconds before migration")
time.sleep(10)
# Migrate the guest.
virsh_args.update({"ignore_status": True})
migration_res = vm.migrate(dest_uri, options, extra, **virsh_args)
if int(migration_res.exit_status) != 0:
logging.error("Migration failed for %s.", vm_name)
return migration_res
if vm.is_alive(): # vm.connect_uri was updated
logging.info("VM is alive on destination %s.", dest_uri)
else:
test.fail("VM is not alive on destination %s" % dest_uri)
# Throws exception if console shows panic message
vm.verify_kernel_crash()
return migration_res
def cleanup_libvirtd_log(log_file):
"""
Remove existing libvirtd log file on source and target host.
:param log_file: log file with absolute path
"""
if os.path.exists(log_file):
logging.debug("Delete local libvirt log file '%s'", log_file)
os.remove(log_file)
cmd = "rm -f %s" % log_file
logging.debug("Delete remote libvirt log file '%s'", log_file)
cmd_parms = {'server_ip': server_ip, 'server_user': server_user, 'server_pwd': server_pwd}
remote.run_remote_cmd(cmd, cmd_parms, runner_on_target)
def cleanup_dest(vm):
"""
Clean up the destination host environment
when doing the uni-direction migration.
:param vm: the guest to be cleaned up
"""
logging.info("Cleaning up VMs on %s", vm.connect_uri)
try:
if virsh.domain_exists(vm.name, uri=vm.connect_uri):
vm_state = vm.state()
if vm_state == "paused":
vm.resume()
elif vm_state == "shut off":
vm.start()
vm.destroy(gracefully=False)
if vm.is_persistent():
vm.undefine()
except Exception as detail:
logging.error("Cleaning up destination failed.\n%s", detail)
def run_stress_in_vm():
"""
The function to load stress in VM
"""
stress_args = params.get("stress_args", "--cpu 8 --io 4 "
"--vm 2 --vm-bytes 128M "
"--timeout 20s")
try:
vm_session.cmd('stress %s' % stress_args)
except Exception as detail:
logging.debug(detail)
def control_migrate_speed(to_speed=1):
"""
Control migration duration
:param to_speed: the speed value in Mbps to be set for migration
:return int: the new migration speed after setting
"""
virsh_args.update({"ignore_status": False})
old_speed = virsh.migrate_getspeed(vm_name, **virsh_args)
logging.debug("Current migration speed is %s MiB/s\n", old_speed.stdout.strip())
logging.debug("Set migration speed to %d MiB/s\n", to_speed)
cmd_result = virsh.migrate_setspeed(vm_name, to_speed, "", **virsh_args)
actual_speed = virsh.migrate_getspeed(vm_name, **virsh_args)
logging.debug("New migration speed is %s MiB/s\n", actual_speed.stdout.strip())
return int(actual_speed.stdout.strip())
def check_setspeed(params):
"""
Set/get migration speed
:param params: the parameters used
:raise: test.fail if speed set does not take effect
"""
expected_value = int(params.get("migrate_speed", '41943040')) // (1024 * 1024)
actual_value = control_migrate_speed(to_speed=expected_value)
params.update({'compare_to_value': actual_value})
if actual_value != expected_value:
test.fail("Migration speed is expected to be '%d MiB/s', but '%d MiB/s' "
"found" % (expected_value, actual_value))
def check_domjobinfo(params, option=""):
"""
Check given item in domjobinfo of the guest is as expected
:param params: the parameters used
:param option: options for domjobinfo
:raise: test.fail if the value of given item is unexpected
"""
def search_jobinfo(jobinfo):
"""
Find value of given item in domjobinfo
:param jobinfo: cmdResult object
:raise: test.fail if not found
"""
for item in jobinfo.stdout.splitlines():
if item.count(jobinfo_item):
groups = re.findall(r'[0-9.]+', item.strip())
logging.debug("In '%s' search '%s'\n", item, groups[0])
if (math.fabs(float(groups[0]) - float(compare_to_value)) //
float(compare_to_value) > diff_rate):
test.fail("{} {} has too much difference from "
"{}".format(jobinfo_item,
groups[0],
compare_to_value))
break
jobinfo_item = params.get("jobinfo_item")
compare_to_value = params.get("compare_to_value")
logging.debug("compare_to_value:%s", compare_to_value)
diff_rate = float(params.get("diff_rate", "0"))
if not jobinfo_item or not compare_to_value:
return
vm_ref = '{}{}'.format(vm_name, option)
jobinfo = virsh.domjobinfo(vm_ref, **virsh_args)
search_jobinfo(jobinfo)
check_domjobinfo_remote = params.get("check_domjobinfo_remote")
if check_domjobinfo_remote:
remote_virsh_session = virsh.VirshPersistent(**remote_virsh_dargs)
jobinfo = remote_virsh_session.domjobinfo(vm_ref, **virsh_args)
search_jobinfo(jobinfo)
remote_virsh_session.close_session()
def check_maxdowntime(params):
"""
Set/get migration maxdowntime
:param params: the parameters used
:raise: test.fail if maxdowntime set does not take effect
"""
expected_value = int(float(params.get("migrate_maxdowntime", '0.3')) * 1000)
virsh_args.update({"ignore_status": False})
old_value = int(virsh.migrate_getmaxdowntime(vm_name).stdout.strip())
logging.debug("Current migration maxdowntime is %d ms", old_value)
logging.debug("Set migration maxdowntime to %d ms", expected_value)
virsh.migrate_setmaxdowntime(vm_name, expected_value, **virsh_args)
actual_value = int(virsh.migrate_getmaxdowntime(vm_name).stdout.strip())
logging.debug("New migration maxdowntime is %d ms", actual_value)
if actual_value != expected_value:
test.fail("Migration maxdowntime is expected to be '%d ms', but '%d ms' "
"found" % (expected_value, actual_value))
params.update({'compare_to_value': actual_value})
def do_actions_during_migrate(params):
"""
The entry point to execute action list during migration
:param params: the parameters used
"""
actions_during_migration = params.get("actions_during_migration")
if not actions_during_migration:
return
for action in actions_during_migration.split(","):
if action == 'setspeed':
check_setspeed(params)
elif action == 'domjobinfo':
check_domjobinfo(params)
elif action == 'setmaxdowntime':
check_maxdowntime(params)
time.sleep(3)
def attach_channel_xml():
"""
Create channel xml and attach it to guest configuration
"""
# Check if pty channel exists already
for elem in new_xml.devices.by_device_tag('channel'):
if elem.type_name == channel_type_name:
logging.debug("{0} channel already exists in guest. "
"No need to add new one".format(channel_type_name))
return
params = {'channel_type_name': channel_type_name,
'target_type': target_type,
'target_name': target_name}
channel_xml = libvirt.create_channel_xml(params)
virsh.attach_device(domain_opt=vm_name, file_opt=channel_xml.xml,
flagstr="--config", ignore_status=False)
logging.debug("New VMXML with channel:\n%s", virsh.dumpxml(vm_name))
def check_timeout_postcopy(params):
"""
Check the vm state on target host after timeout
when --postcopy and --timeout-postcopy are used.
The vm state is expected as running.
:param params: the parameters used
"""
timeout = int(params.get("timeout_postcopy", 10))
time.sleep(timeout + 1)
remote_virsh_session = virsh.VirshPersistent(**remote_virsh_dargs)
vm_state = results_stdout_52lts(remote_virsh_session.domstate(vm_name)).strip()
if vm_state != "running":
remote_virsh_session.close_session()
test.fail("After timeout '%s' seconds, "
"the vm state on target host should "
"be 'running', but '%s' found",
timeout, vm_state)
remote_virsh_session.close_session()
def get_usable_compress_cache(pagesize):
"""
Get a number which is bigger than pagesize and is power of two.
:param pagesize: the given integer
:return: an integer satisfying the criteria
"""
def calculate(num):
result = num & (num - 1)
return (result == 0)
item = pagesize
found = False
while (not found):
item += 1
found = calculate(item)
logging.debug("%d is smallest one that is bigger than '%s' and "
"is power of 2", item, pagesize)
return item
def check_migration_res(result):
"""
Check if the migration result is as expected
:param result: the output of migration
:raise: test.fail if test is failed
"""
logging.info("Migration out: %s", results_stdout_52lts(result).strip())
logging.info("Migration error: %s", results_stderr_52lts(result).strip())
if status_error: # Migration should fail
if err_msg: # Special error messages are expected
if not re.search(err_msg, results_stderr_52lts(result).strip()):
test.fail("Can not find the expected patterns '%s' in "
"output '%s'" % (err_msg,
results_stderr_52lts(result).strip()))
else:
logging.debug("It is the expected error message")
else:
if int(result.exit_status) != 0:
logging.debug("Migration failure is expected result")
else:
test.fail("Migration success is unexpected result")
else:
if int(result.exit_status) != 0:
test.fail(results_stderr_52lts(result).strip())
check_parameters(test, params)
# Params for NFS shared storage
shared_storage = params.get("migrate_shared_storage", "")
if shared_storage == "":
default_guest_asset = defaults.get_default_guest_os_info()['asset']
default_guest_asset = "%s.qcow2" % default_guest_asset
shared_storage = os.path.join(params.get("nfs_mount_dir"),
default_guest_asset)
logging.debug("shared_storage:%s", shared_storage)
# params for migration connection
params["virsh_migrate_desturi"] = libvirt_vm.complete_uri(
params.get("migrate_dest_host"))
# Params to update disk using shared storage
params["disk_type"] = "file"
params["disk_source_protocol"] = "netfs"
params["mnt_path_name"] = params.get("nfs_mount_dir")
# Local variables
virsh_args = {"debug": True}
virsh_opt = params.get("virsh_opt", "")
server_ip = params.get("server_ip")
server_user = params.get("server_user", "root")
server_pwd = params.get("server_pwd")
extra = params.get("virsh_migrate_extra")
options = params.get("virsh_migrate_options")
src_uri = params.get("virsh_migrate_connect_uri")
dest_uri = params.get("virsh_migrate_desturi")
log_file = params.get("libvirt_log", "/var/log/libvirt/libvirtd.log")
check_complete_job = "yes" == params.get("check_complete_job", "no")
config_libvirtd = "yes" == params.get("config_libvirtd", "no")
contrl_index = params.get("new_contrl_index", None)
asynch_migration = "yes" == params.get("asynch_migrate", "no")
grep_str_remote_log = params.get("grep_str_remote_log", "")
grep_str_local_log = params.get("grep_str_local_log", "")
disable_verify_peer = "yes" == params.get("disable_verify_peer", "no")
status_error = "yes" == params.get("status_error", "no")
stress_in_vm = "yes" == params.get("stress_in_vm", "no")
low_speed = params.get("low_speed", None)
remote_virsh_dargs = {'remote_ip': server_ip, 'remote_user': server_user,
'remote_pwd': server_pwd, 'unprivileged_user': None,
'ssh_remote_auth': True}
hpt_resize = params.get("hpt_resize", None)
htm_state = params.get("htm_state", None)
# For pty channel test
add_channel = "yes" == params.get("add_channel", "no")
channel_type_name = params.get("channel_type_name", None)
target_type = params.get("target_type", None)
target_name = params.get("target_name", None)
cmd_run_in_remote_guest = params.get("cmd_run_in_remote_guest", None)
cmd_run_in_remote_guest_1 = params.get("cmd_run_in_remote_guest_1", None)
cmd_run_in_remote_host = params.get("cmd_run_in_remote_host", None)
cmd_run_in_remote_host_1 = params.get("cmd_run_in_remote_host_1", None)
cmd_run_in_remote_host_2 = params.get("cmd_run_in_remote_host_2", None)
# For qemu command line checking
qemu_check = params.get("qemu_check", None)
xml_check_after_mig = params.get("guest_xml_check_after_mig", None)
# params for cache matrix test
cache = params.get("cache")
remove_cache = "yes" == params.get("remove_cache", "no")
err_msg = params.get("err_msg")
arch = platform.machine()
if any([hpt_resize, contrl_index, htm_state]) and 'ppc64' not in arch:
test.cancel("The case is PPC only.")
# For TLS
tls_recovery = params.get("tls_auto_recovery", "yes")
# qemu config
qemu_conf_dict = None
# libvirtd config
libvirtd_conf_dict = None
remote_virsh_session = None
vm = None
vm_session = None
libvirtd_conf = None
qemu_conf = None
mig_result = None
test_exception = None
is_TestError = False
is_TestFail = False
is_TestSkip = False
# Objects to be cleaned up in the end
objs_list = []
tls_obj = None
# Local variables
vm_name = params.get("migrate_main_vm")
vm = env.get_vm(vm_name)
vm.verify_alive()
# For safety reasons, we'd better back up xmlfile.
new_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
orig_config_xml = new_xml.copy()
if not orig_config_xml:
test.error("Backing up xmlfile failed.")
try:
# Create a remote runner for later use
runner_on_target = remote.RemoteRunner(host=server_ip,
username=server_user,
password=server_pwd)
# Change the configuration files if needed before starting guest
# For qemu.conf
if extra.count("--tls"):
# Setup TLS
tls_obj = TLSConnection(params)
if tls_recovery == "yes":
objs_list.append(tls_obj)
tls_obj.auto_recover = True
tls_obj.conn_setup()
if not disable_verify_peer:
qemu_conf_dict = {"migrate_tls_x509_verify": "1"}
# Setup qemu configure
logging.debug("Configure the qemu")
cleanup_libvirtd_log(log_file)
qemu_conf = libvirt.customize_libvirt_config(qemu_conf_dict,
config_type="qemu",
remote_host=True,
extra_params=params)
# Setup libvirtd
if config_libvirtd:
logging.debug("Configure the libvirtd")
cleanup_libvirtd_log(log_file)
libvirtd_conf_dict = setup_libvirtd_conf_dict(params)
libvirtd_conf = libvirt.customize_libvirt_config(libvirtd_conf_dict,
remote_host=True,
extra_params=params)
# Prepare required guest xml before starting guest
if contrl_index:
new_xml.remove_all_device_by_type('controller')
logging.debug("After removing controllers, current XML:\n%s\n", new_xml)
add_ctrls(new_xml, dev_index=contrl_index)
if add_channel:
attach_channel_xml()
if hpt_resize:
set_feature(new_xml, 'hpt', hpt_resize)
if htm_state:
set_feature(new_xml, 'htm', htm_state)
if cache:
params["driver_cache"] = cache
if remove_cache:
params["enable_cache"] = "no"
# Change the disk of the vm to shared disk and then start VM
libvirt.set_vm_disk(vm, params)
if not vm.is_alive():
vm.start()
logging.debug("Guest xml after starting:\n%s", vm_xml.VMXML.new_from_dumpxml(vm_name))
# Check qemu command line after guest is started
if qemu_check:
check_content = qemu_check
if hpt_resize:
check_content = "%s%s" % (qemu_check, hpt_resize)
if htm_state:
check_content = "%s%s" % (qemu_check, htm_state)
libvirt.check_qemu_cmd_line(check_content)
# Check local guest network connection before migration
vm_session = vm.wait_for_login()
check_vm_network_accessed()
# Preparation for the running guest before migration
if hpt_resize and hpt_resize != 'disabled':
trigger_hpt_resize(vm_session)
if low_speed:
control_migrate_speed(int(low_speed))
if stress_in_vm:
pkg_name = 'stress'
logging.debug("Check if stress tool is installed")
pkg_mgr = utils_package.package_manager(vm_session, pkg_name)
if not pkg_mgr.is_installed(pkg_name):
logging.debug("Stress tool will be installed")
if not pkg_mgr.install():
test.error("Package '%s' installation fails" % pkg_name)
stress_thread = threading.Thread(target=run_stress_in_vm,
args=())
stress_thread.start()
if extra.count("timeout-postcopy"):
func_name = check_timeout_postcopy
if params.get("actions_during_migration"):
func_name = do_actions_during_migrate
if extra.count("comp-xbzrle-cache"):
cache = get_usable_compress_cache(memory.get_page_size())
extra = "%s %s" % (extra, cache)
# For --postcopy enable
postcopy_options = params.get("postcopy_options")
if postcopy_options:
extra = "%s %s" % (extra, postcopy_options)
# Execute migration process
if not asynch_migration:
mig_result = do_migration(vm, dest_uri, options, extra)
else:
migration_test = libvirt.MigrationTest()
logging.debug("vm.connect_uri=%s", vm.connect_uri)
vms = [vm]
try:
migration_test.do_migration(vms, None, dest_uri, 'orderly',
options, thread_timeout=900,
ignore_status=True, virsh_opt=virsh_opt,
func=func_name, extra_opts=extra,
func_params=params)
mig_result = migration_test.ret
except exceptions.TestFail as fail_detail:
test.fail(fail_detail)
except exceptions.TestSkipError as skip_detail:
test.cancel(skip_detail)
except exceptions.TestError as error_detail:
test.error(error_detail)
except Exception as details:
mig_result = migration_test.ret
logging.error(details)
check_migration_res(mig_result)
if add_channel:
# Get the channel device source path of remote guest
if not remote_virsh_session:
remote_virsh_session = virsh.VirshPersistent(**remote_virsh_dargs)
file_path = tempfile.mktemp(dir=data_dir.get_tmp_dir())
remote_virsh_session.dumpxml(vm_name, to_file=file_path,
debug=True,
ignore_status=True)
local_vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
local_vmxml.xmltreefile = xml_utils.XMLTreeFile(file_path)
for elem in local_vmxml.devices.by_device_tag('channel'):
logging.debug("Found channel device {}".format(elem))
if elem.type_name == channel_type_name:
host_source = elem.source.get('path')
logging.debug("Remote guest uses {} for channel device".format(host_source))
break
remote_virsh_session.close_session()
if not host_source:
test.fail("Can not find source for %s channel on remote host" % channel_type_name)
# Prepare to wait for message on remote host from the channel
cmd_parms = {'server_ip': server_ip, 'server_user': server_user, 'server_pwd': server_pwd}
cmd_result = remote.run_remote_cmd(cmd_run_in_remote_host % host_source,
cmd_parms,
runner_on_target)
# Send message from remote guest to the channel file
remote_vm_obj = utils_test.RemoteVMManager(cmd_parms)
vm_ip = vm.get_address()
vm_pwd = params.get("password")
remote_vm_obj.setup_ssh_auth(vm_ip, vm_pwd)
cmd_result = remote_vm_obj.run_command(vm_ip, cmd_run_in_remote_guest_1)
remote_vm_obj.run_command(vm_ip, cmd_run_in_remote_guest % results_stdout_52lts(cmd_result).strip())
logging.debug("Sending message is done")
# Check message on remote host from the channel
remote.run_remote_cmd(cmd_run_in_remote_host_1, cmd_parms, runner_on_target)
logging.debug("Receiving message is done")
remote.run_remote_cmd(cmd_run_in_remote_host_2, cmd_parms, runner_on_target)
if check_complete_job:
opts = " --completed"
check_virsh_command_and_option("domjobinfo", opts)
if extra.count("comp-xbzrle-cache"):
params.update({'compare_to_value': cache // 1024})
check_domjobinfo(params, option=opts)
if grep_str_local_log:
cmd = "grep -E '%s' %s" % (grep_str_local_log, log_file)
cmdRes = process.run(cmd, shell=True, ignore_status=True)
if cmdRes.exit_status:
test.fail(results_stderr_52lts(cmdRes).strip())
if grep_str_remote_log:
cmd = "grep -E '%s' %s" % (grep_str_remote_log, log_file)
cmd_parms = {'server_ip': server_ip, 'server_user': server_user, 'server_pwd': server_pwd}
remote.run_remote_cmd(cmd, cmd_parms, runner_on_target)
if xml_check_after_mig:
if not remote_virsh_session:
remote_virsh_session = virsh.VirshPersistent(**remote_virsh_dargs)
target_guest_dumpxml = results_stdout_52lts(
remote_virsh_session.dumpxml(vm_name,
debug=True,
ignore_status=True)).strip()
if hpt_resize:
check_str = hpt_resize
elif htm_state:
check_str = htm_state
if hpt_resize or htm_state:
xml_check_after_mig = "%s'%s'" % (xml_check_after_mig, check_str)
if not re.search(xml_check_after_mig, target_guest_dumpxml):
remote_virsh_session.close_session()
test.fail("Fail to search '%s' in target guest XML:\n%s"
% (xml_check_after_mig, target_guest_dumpxml))
if contrl_index:
all_ctrls = re.findall(xml_check_after_mig, target_guest_dumpxml)
if len(all_ctrls) != int(contrl_index) + 1:
remote_virsh_session.close_session()
test.fail("%s pci-root controllers are expected in guest XML, "
"but found %s" % (int(contrl_index) + 1, len(all_ctrls)))
remote_virsh_session.close_session()
if int(mig_result.exit_status) == 0:
server_session = remote.wait_for_login('ssh', server_ip, '22',
server_user, server_pwd,
r"[\#\$]\s*$")
check_vm_network_accessed(server_session)
server_session.close()
except exceptions.TestFail as details:
is_TestFail = True
test_exception = details
except exceptions.TestSkipError as details:
is_TestSkip = True
test_exception = details
except exceptions.TestError as details:
is_TestError = True
test_exception = details
except Exception as details:
test_exception = details
finally:
logging.debug("Recover test environment")
try:
# Clean VM on destination
vm.connect_uri = dest_uri
cleanup_dest(vm)
vm.connect_uri = src_uri
logging.info("Recovery VM XML configration")
orig_config_xml.sync()
logging.debug("The current VM XML:\n%s", orig_config_xml.xmltreefile)
if remote_virsh_session:
remote_virsh_session.close_session()
if extra.count("--tls") and not disable_verify_peer:
logging.debug("Recover the qemu configuration")
libvirt.customize_libvirt_config(None,
config_type="qemu",
remote_host=True,
extra_params=params,
is_recover=True,
config_object=qemu_conf)
if config_libvirtd:
logging.debug("Recover the libvirtd configuration")
libvirt.customize_libvirt_config(None,
remote_host=True,
extra_params=params,
is_recover=True,
config_object=libvirtd_conf)
logging.info("Remove local NFS image")
source_file = params.get("source_file")
libvirt.delete_local_disk("file", path=source_file)
if objs_list:
for obj in objs_list:
logging.debug("Clean up local objs")
del obj
except Exception as exception_detail:
if (not test_exception and not is_TestError and
not is_TestFail and not is_TestSkip):
raise exception_detail
else:
# if any of above exceptions has been raised, only print
# error log here to avoid of hiding the original issue
logging.error(exception_detail)
# Check result
if is_TestFail:
test.fail(test_exception)
if is_TestSkip:
test.cancel(test_exception)
if is_TestError:
test.error(test_exception)
if not test_exception:
logging.info("Case execution is done.")
else:
test.error(test_exception)
