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):
"""
Run the test to check events when migration
:param test: test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment.
"""
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", "")
action_during_mig = params.get("action_during_mig")
migrate_speed = params.get("migrate_speed")
virsh_session = None
remote_session = None
if action_during_mig:
action_during_mig = migration_base.parse_funcs(action_during_mig, test,
params)
# 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:
# Change the disk of the 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))
vm.wait_for_login().close()
if migrate_speed:
mode = 'both' if '--postcopy' in postcopy_options else 'precopy'
migration_test.control_migrate_speed(vm_name, int(migrate_speed),
mode)
# Monitor event on source/target host
virsh_session, remote_virsh_session = migration_base.monitor_event(
params)
# 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)
# Check event output
migration_base.check_event_output(params, test, virsh_session,
remote_virsh_session)
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
# Clean VM on destination and source
migration_test.cleanup_vm(vm, dest_uri)
orig_config_xml.sync()
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", "")
action_during_mig = params.get("action_during_mig")
migrate_speed = params.get("migrate_speed")
migrate_again = "yes" == params.get("migrate_again", "no")
vm_state_after_abort = params.get("vm_state_after_abort")
kill_service = "yes" == params.get("kill_service", "no")
expected_image_ownership = params.get("expected_image_ownership")
service_name = params.get("service_name", "libvirtd")
service_on_dst = "yes" == params.get("service_on_dst", "no")
server_ip = params.get("remote_ip")
server_user = params.get("remote_user", "root")
server_pwd = params.get("remote_pwd")
# 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:
# Update guest disk xml
libvirt.set_vm_disk(vm, params)
logging.debug("Guest xml after starting:\n%s",
vm_xml.VMXML.new_from_dumpxml(vm_name))
vm.wait_for_login().close()
if kill_service:
check_image_ownership(vm_name, expected_image_ownership, test)
if service_name == "libvirtd":
if service_on_dst:
remote_session = remote.wait_for_login(
'ssh', server_ip, '22', server_user, server_pwd,
r"[\#\$]\s*$")
service_name = utils_libvirtd.Libvirtd(
session=remote_session).service_name
remote_session.close()
else:
service_name = utils_libvirtd.Libvirtd().service_name
params.update({'service_name': service_name})
if migrate_speed:
mode = 'both' if '--postcopy' in postcopy_options else 'precopy'
migration_test.control_migrate_speed(vm_name, int(migrate_speed),
mode)
if action_during_mig:
action_during_mig = migration_base.parse_funcs(
action_during_mig, test, params)
# 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 vm_state_after_abort:
check_vm_state_after_abort(vm_name, vm_state_after_abort, bk_uri,
dest_uri, test)
if kill_service:
check_image_ownership(vm_name, expected_image_ownership, test)
if migrate_again:
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")
migration_base.do_migration(vm, migration_test, None, dest_uri,
options, virsh_options, extra,
action_during_mig, extra_args)
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
# Clean VM on destination and source
migration_test.cleanup_vm(vm, dest_uri)
orig_config_xml.sync()
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", "")
migrate_again = "yes" == params.get("migrate_again", "no")
src_state = params.get("virsh_migrate_src_state", "shut off")
set_src_and_dst_hostname = "yes" == params.get("set_src_and_dst_hostname",
"no")
src_hostname = params.get("src_hostname")
dst_hostname = params.get("dst_hostname")
server_ip = params.get("remote_ip")
server_user = params.get("remote_user", "root")
server_pwd = params.get("remote_pwd")
server_params = {
'server_ip': server_ip,
'server_user': server_user,
'server_pwd': server_pwd
}
dst_session = None
dst_libvirtd = None
src_libvirtd = None
src_NM_service = None
dest_NM_service = None
old_dst_hostname = None
old_source_hostname = 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()
try:
# Update guest disk xml
libvirt.set_vm_disk(vm, params)
if set_src_and_dst_hostname:
old_dst_hostname = get_hostname(test, remote_params=server_params)
old_source_hostname = get_hostname(test)
dst_session = remote_old.wait_for_login('ssh', server_ip, '22',
server_user, server_pwd,
r"[\#\$]\s*$")
dst_libvirtd = utils_libvirtd.Libvirtd(session=dst_session)
src_libvirtd = utils_libvirtd.Libvirtd()
try:
# Check local NetworkManager service
NM = utils_path.find_command("NetworkManager")
except utils_path.CmdNotFoundError:
logging.debug("No NetworkManager command found on source.")
NM = None
if NM is not None:
# Stop local NetworkManager service
src_NM_service = service.Factory.create_service(
"NetworkManager")
if src_NM_service is not None:
stop_NM(src_NM_service)
set_hostname(src_hostname, test)
src_libvirtd.restart()
# Check remote NetworkManager service
check_cmd = "rpm -q NetworkManager"
check_result = remote_old.run_remote_cmd(check_cmd,
server_params,
ignore_status=False)
if check_result.exit_status:
logging.debug("No NetworkManager command found on target.")
else:
# Stop remote NetworkManager service
remote_runner = remote.RemoteRunner(host=server_ip,
username=server_user,
password=server_pwd)
runner = remote_runner.run
dest_NM_service = service.Factory.create_service(
"NetworkManager", run=runner)
if dest_NM_service is not None:
stop_NM(dest_NM_service)
set_hostname(dst_hostname, test, remote_params=server_params)
dst_libvirtd.restart()
if not vm.is_alive():
vm.start()
logging.debug("Guest xml after starting:\n%s",
vm_xml.VMXML.new_from_dumpxml(vm_name))
vm.wait_for_login()
# Execute migration process
migration_base.do_migration(vm, migration_test, None, dest_uri,
options, virsh_options, extra, None,
extra_args)
func_returns = dict(migration_test.func_ret)
migration_test.func_ret.clear()
logging.debug("Migration returns function results:%s", func_returns)
if migrate_again:
if not vm.is_alive():
vm.start()
vm.wait_for_login()
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")
migration_base.do_migration(vm, migration_test, None, dest_uri,
options, virsh_options, extra, None,
extra_args)
if int(migration_test.ret.exit_status) == 0:
migration_test.post_migration_check([vm], params, uri=dest_uri)
if not libvirt.check_vm_state(vm_name, state=src_state, uri=bk_uri):
test.fail("Can't get the expected vm state '%s'" % src_state)
finally:
logging.info("Recover test environment")
vm.connect_uri = bk_uri
# Clean VM on destination and source
migration_test.cleanup_vm(vm, dest_uri)
if set_src_and_dst_hostname:
if src_NM_service is not None:
start_NM(src_NM_service)
if dest_NM_service is not None:
start_NM(dest_NM_service)
set_hostname(old_dst_hostname, test, remote_params=server_params)
if dst_libvirtd:
dst_libvirtd.restart()
if dst_session:
dst_session.close()
set_hostname(old_source_hostname, test)
if src_libvirtd:
src_libvirtd.restart()
orig_config_xml.sync()
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.
"""
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")
#action_params_map = params.get('action_params_map')
migrate_speed = params.get("migrate_speed")
migrate_again = "yes" == params.get("migrate_again", "no")
vm_state_after_abort = params.get("vm_state_after_abort")
return_port = params.get("return_port")
if action_during_mig:
action_during_mig = migration_base.parse_funcs(action_during_mig,
test, params)
setup_tls = params.get("setup_tls", "no")
if setup_tls == "yes":
if not libvirt_version.version_compare(6, 9, 0):
test.cancel("Cannot support migrate_tls_force in this libvirt version.")
qemu_conf_src = eval(params.get("qemu_conf_src", "{}"))
qemu_conf_dest = params.get("qemu_conf_dest", "{}")
status_error = "yes" == params.get("status_error", "no")
migrate_tls_force_default = "yes" == params.get("migrate_tls_force_default", "no")
server_ip = params.get("server_ip")
server_user = params.get("server_user")
server_pwd = params.get("server_pwd")
server_params = {'server_ip': server_ip,
'server_user': server_user,
'server_pwd': server_pwd}
tls_obj = None
qemu_conf_local = None
qemu_conf_remote = 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()
try:
libvirt.set_vm_disk(vm, params)
# Setup libvirtd remote connection TLS connection env
if setup_tls == "yes":
tls_obj = TLSConnection(params)
tls_obj.auto_recover = True
tls_obj.conn_setup()
# 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"
libvirt_config.remove_key_in_conf(value_list, "qemu", remote_params=server_params)
# Setup migrate_tls_force default value on local
libvirt_config.remove_key_in_conf(value_list, "qemu")
# Update 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 qemu conf
if qemu_conf_src:
qemu_conf_local = libvirt.customize_libvirt_config(qemu_conf_src, "qemu")
if not vm.is_alive():
vm.start()
logging.debug("Guest xml after starting:\n%s",
vm_xml.VMXML.new_from_dumpxml(vm_name))
vm.wait_for_login().close()
if stress_package:
migration_test.run_stress_in_vm(vm, params)
if migrate_speed:
mode = 'both' if '--postcopy' in postcopy_options else 'precopy'
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 vm_state_after_abort:
check_vm_state_after_abort(vm_name, vm_state_after_abort,
bk_uri, dest_uri, test)
if migrate_again:
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")
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)
migration_test.post_migration_check([vm], params, uri=dest_uri)
finally:
logging.info("Recover test environment")
vm.connect_uri = bk_uri
# Clean VM on destination and source
migration_test.cleanup_vm(vm, dest_uri)
# Restore local qemu conf and restart libvirtd
if qemu_conf_local:
logging.debug("Recover local qemu configurations")
libvirt.customize_libvirt_config(None, config_type="qemu", is_recover=True,
config_object=qemu_conf_local)
# Restore remote qemu conf and restart libvirtd
if qemu_conf_remote:
logging.debug("Recover remote qemu configurations")
del qemu_conf_remote
# Clean up TLS test env:
if setup_tls and tls_obj:
logging.debug("Clean up TLS object")
del tls_obj
orig_config_xml.sync()