def migration_scenario(self):
sync = SyncData(self.master_id(), self.hostid, self.hosts,
self.id, self.sync_server)
self.vm = params.get("vms").split()[0]
address_cache = env.get("address_cache")
if (self.hostid == self.master_id()):
utils.run("dd if=/dev/urandom of=%s bs=1M"
" count=%s" % (host_path, file_size))
self.vm_addr = self._prepare_vm(self.vm).get_address()
end_event = threading.Event()
bg = utils.InterruptedThread(self._copy_until_end,
(end_event,))
self._hosts_barrier(self.hosts, self.id, "befor_mig", 120)
sync.sync(address_cache, timeout=120)
error.context("ping-pong between host and guest while"
" migrating", logging.info)
self._run_and_migrate(bg, end_event, sync, migrate_count)
# Check if guest lives.
remote.wait_for_login(shell_client, self.vm_addr,
shell_port, guest_root,
guest_pass, shell_prompt)
self._hosts_barrier(self.hosts, self.id, "After_check", 120)
error.context("comparing hashes", logging.info)
orig_hash = client_utils.hash_file(host_path)
returned_hash = client_utils.hash_file(host_path_returned)
#Check all check sum
wrong_check_sum = False
for i in range(len(self.file_check_sums)):
check_sum = self.file_check_sums[i]
if check_sum != orig_hash:
wrong_check_sum = True
logging.error("Checksum in transfer number"
" %d if wrong." % (i))
if wrong_check_sum:
raise error.TestFail("Returned file hash (%s) differs from"
" original one (%s)" % (returned_hash,
orig_hash))
else:
#clean temp
utils.run("rm -rf %s" % (host_path))
utils.run("rm -rf %s" % (returned_hash))
error.context()
else:
self._hosts_barrier(self.hosts, self.id, "befor_mig", 260)
address_cache.update(sync.sync(timeout=120)[self.master_id()])
logging.debug("Address cache updated to %s" % address_cache)
self._slave_migrate(sync)
#Wait for check if guest lives.
self._hosts_barrier(self.hosts, self.id, "After_check", 120)
def service_libvirtd_control(action,
remote_ip=None,
remote_pwd=None,
remote_user='******',
libvirtd=LIBVIRTD):
"""
Libvirtd control by action, if cmd executes successfully,
return True, otherwise raise LibvirtActionError.
If the action is status, return True when it's running,
otherwise return False.
@ param action: start|stop|status|restart|condrestart|
reload|force-reload|try-restart
@ raise LibvirtdActionUnknownError: Action is not supported.
@ raise LibvirtdActionError: Take the action on libvirtd Failed.
"""
if LIBVIRTD is None:
logging.warning("Libvirtd service is not available in host, "
"utils_libvirtd module will not function normally")
service_cmd = ('service %s %s' % (libvirtd, action))
actions = [
'start', 'stop', 'restart', 'condrestart', 'reload', 'force-reload',
'try-restart'
]
session = None
if remote_ip:
try:
session = remote.wait_for_login('ssh', remote_ip, '22',
remote_user, remote_pwd,
r"[\#\$]\s*$")
except remote.LoginError, detail:
raise LibvirtdActionError(action, detail)
def _new_session(self):
"""
Build a new server session.
"""
port = self.port
prompt = self.prompt
host = self.server_ip
client = self.client
username = self.server_user
password = self.server_pwd
try:
session = remote.wait_for_login(client, host, port, username,
password, prompt)
except remote.LoginTimeoutError:
raise exceptions.TestError(
"Got a timeout error when login to server.")
except remote.LoginAuthenticationError:
raise exceptions.TestError(
"Authentication failed to login to server.")
except remote.LoginProcessTerminatedError:
raise exceptions.TestError(
"Host terminates during login to server.")
except remote.LoginError:
raise exceptions.TestError(
"Some error occurs login to client server.")
return session
def hugepage_assign(hp_num, target_ip='', node='', hp_size='', user='',
password=''):
"""
Allocates hugepages for src and dst machines
:param hp_num: number of hugepages
:param target_ip: ip address of destination machine
:param node: numa node to which HP have to be allocated
:param hp_size: hugepage size
:param user: remote machine's username
:param password: remote machine's password
"""
command = ""
if node == '':
if target_ip == '':
utils_memory.set_num_huge_pages(int(hp_num))
else:
command = "echo %s > /proc/sys/vm/nr_hugepages" % (hp_num)
else:
command = "echo %s > /sys/devices/system/node/node" % (hp_num)
command += "%s/hugepages/hugepages-%skB/" % (str(node), hp_size)
command += "nr_hugepages"
if command != "":
if target_ip != "":
server_session = remote.wait_for_login('ssh', target_ip, '22',
user, password,
r"[\#\$]\s*$")
cmd_output = server_session.cmd_status_output(command)
server_session.close()
if (cmd_output[0] != 0):
raise error.TestNAError("HP not supported/configured")
else:
process.system_output(command, verbose=True, shell=True)
def __init__(self, test, params, env):
"""
Initialize the object and set a few attributes.
"""
self.test = test
self.server_hostname = None
self.server_ip = params.get("remote_ip")
if self.server_ip.count("REMOTE"):
self.test.cancel("Please set server ip!")
self.server_user = params.get("remote_user")
self.server_password = params.get("remote_pwd")
self.local_clock = params.get("local_clock")
self.net_range = params.get("net_range")
self.mask = params.get("mask", "255.255.255.0")
self.restrict_option = params.get("restrict_option")
self.vm_name = params.get("main_vm")
self.ntpdate_sleep = int(params.get("ntpdate_sleep", "0"))
self.ntpd_sleep = int(params.get("ntpd_sleep", "0"))
self.long_sleep = int(params.get("long_sleep", "0"))
self.vm = env.get_vm(self.vm_name)
try:
self.server_session = remote.wait_for_login(
'ssh', self.server_ip, "22", self.server_user,
self.server_password, r"[\$#]\s*$")
self.session = self.vm.wait_for_login()
except remote.LoginTimeoutError as detail:
self.test.cancel(str(detail))
def conn_recover(self):
"""
Do the clean up work.
(1).initialize variables.
(2).Delete remote file.
(3).Restart libvirtd on server.
"""
# initialize variables
server_ip = self.server_ip
server_user = self.server_user
server_pwd = self.server_pwd
del self.client_hosts
del self.server_syslibvirtd
del self.server_libvirtdconf
# restart libvirtd service on server
try:
session = remote.wait_for_login('ssh', server_ip, '22',
server_user, server_pwd,
r"[\#\$]\s*$")
libvirtd_service = utils_libvirtd.Libvirtd(session=session)
libvirtd_service.restart()
except (remote.LoginError, aexpect.ShellError), detail:
raise ConnServerRestartError(detail)
def __init__(self, test, params, env):
"""
Initialize the object and set a few attributes.
"""
self.test = test
self.server_hostname = None
self.server_ip = params.get("remote_ip")
if self.server_ip.count("REMOTE"):
self.test.cancel("Please set server ip!")
self.server_user = params.get("remote_user")
self.server_password = params.get("remote_pwd")
self.local_clock = params.get("local_clock")
self.net_range = params.get("net_range")
self.mask = params.get("mask", "255.255.255.0")
self.restrict_option = params.get("restrict_option")
self.vm_name = params.get("main_vm")
self.ntpdate_sleep = int(params.get("ntpdate_sleep", "0"))
self.ntpd_sleep = int(params.get("ntpd_sleep", "0"))
self.long_sleep = int(params.get("long_sleep", "0"))
self.vm = env.get_vm(self.vm_name)
try:
self.server_session = remote.wait_for_login('ssh',
self.server_ip, "22",
self.server_user,
self.server_password,
r"[\$#]\s*$")
self.session = self.vm.wait_for_login()
except remote.LoginTimeoutError as detail:
self.test.cancel(str(detail))
def conn_recover(self):
"""
Do the clean up work.
(1).initialize variables.
(2).Delete remote file.
(3).Restart libvirtd on server.
"""
# initialize variables
server_ip = self.server_ip
server_user = self.server_user
server_pwd = self.server_pwd
del self.client_hosts
del self.server_syslibvirtd
del self.server_libvirtdconf
# restart libvirtd service on server
try:
session = remote.wait_for_login('ssh', server_ip, '22',
server_user, server_pwd,
r"[\#\$]\s*$")
libvirtd_service = utils_libvirtd.Libvirtd(session=session)
libvirtd_service.restart()
except (remote.LoginError, aexpect.ShellError), detail:
raise ConnServerRestartError(detail)
def _new_session(self):
"""
Build a new server session.
"""
port = self.port
prompt = self.prompt
host = self.server_ip
client = self.client
username = self.server_user
password = self.server_pwd
try:
session = remote.wait_for_login(client, host, port,
username, password, prompt)
except remote.LoginTimeoutError:
raise exceptions.TestError(
"Got a timeout error when login to server.")
except remote.LoginAuthenticationError:
raise exceptions.TestError(
"Authentication failed to login to server.")
except remote.LoginProcessTerminatedError:
raise exceptions.TestError(
"Host terminates during login to server.")
except remote.LoginError:
raise exceptions.TestError(
"Some error occurs login to client server.")
return session
def service_libvirtd_control(action, remote_ip=None,
remote_pwd=None, remote_user='******',
libvirtd=LIBVIRTD):
"""
Libvirtd control by action, if cmd executes successfully,
return True, otherwise raise LibvirtActionError.
If the action is status, return True when it's running,
otherwise return False.
@ param action: start|stop|status|restart|condrestart|
reload|force-reload|try-restart
@ raise LibvirtdActionUnknownError: Action is not supported.
@ raise LibvirtdActionError: Take the action on libvirtd Failed.
"""
service_cmd = ('service %s %s' % (libvirtd, action))
actions = ['start', 'stop', 'restart', 'condrestart', 'reload',
'force-reload', 'try-restart']
session = None
if remote_ip:
try:
session = remote.wait_for_login('ssh', remote_ip, '22',
remote_user, remote_pwd,
r"[\#\$]\s*$")
except remote.LoginError, detail:
raise LibvirtdActionError(action, detail)
def create_destroy_pool_on_remote(test, action, params):
"""
This is to create or destroy a specified pool on remote.
:param action: "create" or "destroy"
:type str
:param params: a dict for parameters
:type dict
:return: True if successful, otherwise False
:rtype: Boolean
"""
remote_ip = params.get("migrate_dest_host")
remote_user = params.get("migrate_dest_user", "root")
remote_pwd = params.get("migrate_dest_pwd")
virsh_dargs = {
'remote_ip': remote_ip,
'remote_user': remote_user,
'remote_pwd': remote_pwd,
'unprivileged_user': None,
'ssh_remote_auth': True
}
new_session = virsh.VirshPersistent(**virsh_dargs)
pool_name = params.get("precreation_pool_name", "tmp_pool_1")
timeout = params.get("timeout", 60)
prompt = params.get("prompt", r"[\#\$]\s*$")
if action == 'create':
# Firstly check if the pool already exists
all_pools = new_session.pool_list(option="--all")
logging.debug("Pools on remote host:\n%s", all_pools)
if all_pools.stdout.find(pool_name) >= 0:
logging.debug(
"The pool %s already exists and skip "
"to create it.", pool_name)
new_session.close_session()
return True
pool_type = params.get("precreation_pool_type", "dir")
pool_target = params.get("precreation_pool_target")
cmd = "mkdir -p %s" % pool_target
session = remote.wait_for_login("ssh", remote_ip, 22, remote_user,
remote_pwd, prompt)
status, output = session.cmd_status_output(cmd, timeout)
session.close()
if status:
new_session.close_session()
test.fail("Run '%s' on remote host '%s' failed: %s." %
(cmd, remote_ip, output))
ret = new_session.pool_create_as(pool_name, pool_type, pool_target)
else: # suppose it is to destroy
ret = new_session.pool_destroy(pool_name)
new_session.close_session()
return ret
def network_restart(params):
"""
Restart remote network
"""
time_out = int(params.get('time_out'))
remote_ip = params.get('remote_ip')
remote_user = params.get('remote_user')
remote_pwd = params.get('remote_pwd')
session = remote.remote_login("ssh", remote_ip, "22", remote_user,
remote_pwd, "#")
runner = remote.RemoteRunner(session=session)
net_service = service.Factory.create_service("network", runner.run)
net_service.restart()
session.close()
try:
remote.wait_for_login("ssh", remote_ip, "22", remote_user,
remote_pwd, "#", timeout=time_out)
except remote.LoginTimeoutError, detail:
raise error.TestError(str(detail))
def network_restart(test, params):
"""
Restart remote network
"""
time_out = int(params.get('time_out'))
remote_ip = params.get('remote_ip')
remote_user = params.get('remote_user')
remote_pwd = params.get('remote_pwd')
session = remote.remote_login("ssh", remote_ip, "22", remote_user,
remote_pwd, "#")
runner = remote.RemoteRunner(session=session)
net_service = service.Factory.create_service("network", runner.run)
net_service.restart()
session.close()
try:
remote.wait_for_login("ssh", remote_ip, "22", remote_user,
remote_pwd, "#", timeout=time_out)
except remote.LoginTimeoutError as detail:
test.error(str(detail))
def remove_key_for_modular_daemon(params, remote_dargs=None):
"""
Remove some configuration keys if the modular daemon is enabled.
If you set "do_search" or/and "do_not_search" in params, it first
checks the values and then removes the keys from the config file.
:param param: The param to use
:param remote_dargs: The params for remote access
:return: remote.RemoteFile object for remote file or
utils_config.LibvirtConfigCommon object for local configuration file
"""
conf_obj = None
session = None
if remote_dargs:
server_ip = remote_dargs.get("server_ip",
remote_dargs.get("remote_ip"))
server_pwd = remote_dargs.get("server_pwd",
remote_dargs.get("remote_pwd"))
server_user = remote_dargs.get("server_user",
remote_dargs.get("remote_user"))
if not all([server_ip, server_pwd, server_user]):
raise exceptions.TestError("server_[ip|user|pwd] are necessary!")
session = remote.wait_for_login('ssh', server_ip, '22', server_user,
server_pwd, r"[\#\$]\s*$")
if utils_split_daemons.is_modular_daemon(session):
remove_key = eval(params.get("remove_key", "['remote_mode']"))
conf_type = params.get("conf_type", "libvirt")
search_cond = eval(params.get("do_search", '{}'))
no_search_cond = eval(params.get("no_search", '{}'))
for k, v in search_cond.items():
if not re.search(v, k, re.IGNORECASE):
LOG.debug(
"The key '%s' does not contain '%s', "
"no need to remove %s in %s conf file.", k, v, remove_key,
conf_type)
return
for k, v in no_search_cond.items():
if re.search(v, k, re.IGNORECASE):
LOG.debug(
"The key '%s' contains '%s', "
"no need to remove %s in %s conf file.", k, v, remove_key,
conf_type)
return
conf_obj = remove_key_in_conf(remove_key,
conf_type=conf_type,
remote_params=remote_dargs)
if session:
session.close()
return conf_obj
def create_session_on_remote(connect_params):
"""
Connect to hypervisor via virsh.
:param connect_params. Dictionary with connection parameters like server_ip.
:return: session to server.
"""
server_session = remote.wait_for_login('ssh', connect_params['server_ip'],
connect_params['port'],
connect_params['server_user'],
connect_params['server_pwd'],
r"[\#\$]\s*$")
return server_session
def service_libvirtd_control(action, remote_ip=None, remote_pwd=None,
remote_user='******'):
deprecation_warning()
session = None
if remote_ip:
session = remote.wait_for_login('ssh', remote_ip, '22',
remote_user, remote_pwd,
r"[\#\$]\s*$")
libvirtd_instance = Libvirtd(session)
else:
libvirtd_instance = Libvirtd()
getattr(libvirtd_instance, action)()
def create_destroy_pool_on_remote(test, action, params):
"""
This is to create or destroy a specified pool on remote.
:param action: "create" or "destory"
:type str
:param params: a dict for parameters
:type dict
:return: True if successful, otherwise False
:rtype: Boolean
"""
remote_ip = params.get("migrate_dest_host")
remote_user = params.get("migrate_dest_user", "root")
remote_pwd = params.get("migrate_dest_pwd")
virsh_dargs = {'remote_ip': remote_ip, 'remote_user': remote_user,
'remote_pwd': remote_pwd, 'unprivileged_user': None,
'ssh_remote_auth': True}
new_session = virsh.VirshPersistent(**virsh_dargs)
pool_name = params.get("precreation_pool_name", "tmp_pool_1")
timeout = params.get("timeout", 60)
prompt = params.get("prompt", r"[\#\$]\s*$")
if action == 'create':
# Firstly check if the pool already exists
all_pools = new_session.pool_list(option="--all")
logging.debug("Pools on remote host:\n%s", all_pools)
if all_pools.stdout.find(pool_name) >= 0:
logging.debug("The pool %s already exists and skip "
"to create it.", pool_name)
new_session.close_session()
return True
pool_type = params.get("precreation_pool_type", "dir")
pool_target = params.get("precreation_pool_target")
cmd = "mkdir -p %s" % pool_target
session = remote.wait_for_login("ssh", remote_ip, 22,
remote_user, remote_pwd, prompt)
status, output = session.cmd_status_output(cmd, timeout)
session.close()
if status:
new_session.close_session()
test.fail("Run '%s' on remote host '%s' failed: %s."
% (cmd, remote_ip, output))
ret = new_session.pool_create_as(pool_name, pool_type, pool_target)
else: # suppose it is to destroy
ret = new_session.pool_destroy(pool_name)
new_session.close_session()
return ret
def remove_remote_firewall_port(port, params):
"""
Remove the port on remote host
:param port: port to remove
:param params: Dictionary with the test parameters
"""
server_ip = params.get("server_ip")
server_user = params.get("server_user")
server_pwd = params.get("server_pwd")
remote_session = remote.wait_for_login('ssh', server_ip, '22',
server_user, server_pwd,
r"[\#\$]\s*$")
firewall_cmd = utils_iptables.Firewall_cmd(remote_session)
firewall_cmd.remove_port(port, 'tcp', permanent=True)
remote_session.close()
def create_destroy_pool_on_remote(action, params):
"""
This is to create or destroy a specified pool on remote.
:param action: "create" or "destory"
:type str
:param params: a dict for parameters
:type dict
:return: True if successful, otherwise False
:rtype: Boolean
"""
remote_ip = params.get("migrate_dest_host")
remote_user = params.get("migrate_dest_user", "root")
remote_pwd = params.get("migrate_dest_pwd")
virsh_dargs = {
'remote_ip': remote_ip,
'remote_user': remote_user,
'remote_pwd': remote_pwd,
'unprivileged_user': None,
'ssh_remote_auth': True
}
new_session = virsh.VirshPersistent(**virsh_dargs)
pool_name = params.get("precreation_pool_name", "tmp_pool_1")
timeout = params.get("timeout", 60)
prompt = params.get("prompt", r"[\#\$]\s*$")
if action == 'create':
pool_type = params.get("precreation_pool_type", "dir")
pool_target = params.get("precreation_pool_target")
cmd = "mkdir -p %s" % pool_target
session = remote.wait_for_login("ssh", remote_ip, 22, remote_user,
remote_pwd, prompt)
status, output = session.cmd_status_output(cmd, timeout)
session.close()
if status:
new_session.close_session()
raise error.TestFail("Run '%s' on remote host '%s' failed: %s." %
(cmd, remote_ip, output))
ret = new_session.pool_create_as(pool_name, pool_type, pool_target)
else: # suppose it is to destroy
ret = new_session.pool_destroy(pool_name)
new_session.close_session()
return ret
def create_destroy_pool_on_remote(action, params):
"""
This is to create or destroy a specified pool on remote.
:param action: "create" or "destory"
:type str
:param params: a dict for parameters
:type dict
:return: True if successful, otherwise False
:rtype: Boolean
"""
remote_ip = params.get("migrate_dest_host")
remote_user = params.get("migrate_dest_user", "root")
remote_pwd = params.get("migrate_dest_pwd")
virsh_dargs = {'remote_ip': remote_ip, 'remote_user': remote_user,
'remote_pwd': remote_pwd, 'unprivileged_user': None,
'ssh_remote_auth': True}
new_session = virsh.VirshPersistent(**virsh_dargs)
pool_name = params.get("precreation_pool_name", "tmp_pool_1")
timeout = params.get("timeout", 60)
prompt = params.get("prompt", r"[\#\$]\s*$")
if action == 'create':
pool_type = params.get("precreation_pool_type", "dir")
pool_target = params.get("precreation_pool_target")
cmd = "mkdir -p %s" % pool_target
session = remote.wait_for_login("ssh", remote_ip, 22,
remote_user, remote_pwd, prompt)
status, output = session.cmd_status_output(cmd, timeout)
session.close()
if status:
new_session.close_session()
raise error.TestFail("Run '%s' on remote host '%s' failed: %s."
% (cmd, remote_ip, output))
ret = new_session.pool_create_as(pool_name, pool_type, pool_target)
else: # suppose it is to destroy
ret = new_session.pool_destroy(pool_name)
new_session.close_session()
return ret
def conn_setup(self):
"""
Enable tcp connect of libvirtd on server.
(1).initialization for variables.
(2).edit /etc/sysconfig/libvirtd on server.
(3).edit /etc/libvirt/libvirtd.conf on server.
(4).restart libvirtd service on server.
"""
# initialize variables
server_ip = self.server_ip
server_user = self.server_user
server_pwd = self.server_pwd
tcp_port = self.tcp_port
# edit the /etc/sysconfig/libvirtd to add --listen args in libvirtd
pattern2repl = {
r".*LIBVIRTD_ARGS\s*=\s*\"\s*--listen\s*\".*":
"LIBVIRTD_ARGS=\"--listen\""
}
self.remote_syslibvirtd.sub_else_add(pattern2repl)
# edit the /etc/libvirt/libvirtd.conf
# listen_tcp=1, tcp_port=$tcp_port, auth_tcp="none"
pattern2repl = {
r".*listen_tls\s*=.*": 'listen_tls=0',
r".*listen_tcp\s*=.*": 'listen_tcp=1',
r".*tcp_port\s*=.*": 'tcp_port="%s"' % (tcp_port),
r'.*auth_tcp\s*=.*': 'auth_tcp="none"'
}
self.remote_libvirtdconf.sub_else_add(pattern2repl)
# restart libvirtd service on server
try:
session = remote.wait_for_login('ssh', server_ip, '22',
server_user, server_pwd,
r"[\#\$]\s*$")
libvirtd_service = utils_libvirtd.Libvirtd(session=session)
libvirtd_service.restart()
except (remote.LoginError, aexpect.ShellError), detail:
raise ConnServerRestartError(detail)
def remotely_control_libvirtd(server_ip, server_user, server_pwd,
action='restart', status_error='no'):
"""
Remotely restart libvirt service
"""
session = None
try:
session = remote.wait_for_login('ssh', server_ip, '22',
server_user, server_pwd,
r"[\#\$]\s*$")
logging.info("%s libvirt daemon\n", action)
service_libvirtd_control(action, session)
session.close()
except (remote.LoginError, aexpect.ShellError, error.CmdError), detail:
if session:
session.close()
if status_error == "no":
raise error.TestFail("Failed to %s libvirtd service on "
"server: %s\n", action, detail)
else:
logging.info("It is an expect %s", detail)
def compare_virt_version(server_ip, server_user, server_pwd):
"""
Make sure libvirt version is different
"""
client = "ssh"
port = "22"
prompt = r"[\#\$]\s*$"
query_cmd = "rpm -q libvirt"
# query libvirt version on local host
status, output_local = commands.getstatusoutput(query_cmd)
if status:
raise error.TestError(output_local)
# query libvirt version on remote host
session = remote.wait_for_login(client, server_ip, port,
server_user, server_pwd, prompt)
status, output_remote = session.cmd_status_output(query_cmd)
if status:
raise error.TestError(output_remote)
# compare libvirt version between local and remote host
if output_local == output_remote.strip():
raise error.TestNAError("To expect different libvirt version "
"<%s>:<%s>", output_local, output_remote)
def compare_virt_version(server_ip, server_user, server_pwd):
"""
Make sure libvirt version is different
"""
client = "ssh"
port = "22"
prompt = r"[\#\$]\s*$"
query_cmd = "rpm -q libvirt"
# query libvirt version on local host
status, output_local = commands.getstatusoutput(query_cmd)
if status:
raise error.TestError(output_local)
# query libvirt version on remote host
session = remote.wait_for_login(client, server_ip, port,
server_user, server_pwd, prompt)
status, output_remote = session.cmd_status_output(query_cmd)
if status:
raise error.TestError(output_remote)
# compare libvirt version between local and remote host
if output_local == output_remote.strip():
raise error.TestNAError("To expect different libvirt version "
"<%s>:<%s>", output_local, output_remote)
def compare_virt_version(server_ip, server_user, server_pwd, test):
"""
Make sure libvirt version is different
"""
client = "ssh"
port = "22"
prompt = r"[\#\$]\s*$"
query_cmd = "rpm -q libvirt"
# query libvirt version on local host
ret = process.run(query_cmd, allow_output_check='combined', shell=True)
status, output_local = ret.exit_status, ret.stdout.strip()
if status:
test.error(output_local)
# query libvirt version on remote host
session = remote.wait_for_login(client, server_ip, port, server_user,
server_pwd, prompt)
status, output_remote = session.cmd_status_output(query_cmd)
if status:
test.error(output_remote)
# compare libvirt version between local and remote host
if output_local == output_remote.strip():
test.cancel("To expect different libvirt version "
"<%s>:<%s>", output_local, output_remote)
def compare_virt_version(server_ip, server_user, server_pwd, test):
"""
Make sure libvirt version is different
"""
client = "ssh"
port = "22"
prompt = r"[\#\$]\s*$"
query_cmd = "rpm -q libvirt"
# query libvirt version on local host
ret = process.run(query_cmd, allow_output_check='combined', shell=True)
status, output_local = ret.exit_status, ret.stdout_text.strip()
if status:
test.error(output_local)
# query libvirt version on remote host
session = remote.wait_for_login(client, server_ip, port,
server_user, server_pwd, prompt)
status, output_remote = session.cmd_status_output(query_cmd)
if status:
test.error(output_remote)
# compare libvirt version between local and remote host
if output_local == output_remote.strip():
test.cancel("To expect different libvirt version "
"<%s>:<%s>", output_local, output_remote)
def _new_server_session(self):
"""
Build a new server session.
"""
transport = 'ssh'
host = self.server_ip
port = 22
username = self.server_user
password = self.server_pwd
prompt = r"[\#\$]\s*$"
try:
server_session = remote.wait_for_login(transport, host, port,
username, password, prompt)
except remote.LoginTimeoutError:
raise ConnLoginError("Got a timeout error when login to server.")
except remote.LoginAuthenticationError:
raise ConnLoginError("Authentication failed to login to server.")
except remote.LoginProcessTerminatedError:
raise ConnLoginError("Host terminates during login to server.")
except remote.LoginError:
raise ConnLoginError("Some error occurs login to client server.")
return server_session
def _new_server_session(self):
"""
Build a new server session.
"""
transport = 'ssh'
host = self.server_ip
port = 22
username = self.server_user
password = self.server_pwd
prompt = r"[\#\$]\s*$"
try:
server_session = remote.wait_for_login(transport, host, port,
username, password, prompt)
except remote.LoginTimeoutError:
raise ConnLoginError("Got a timeout error when login to server.")
except remote.LoginAuthenticationError:
raise ConnLoginError("Authentication failed to login to server.")
except remote.LoginProcessTerminatedError:
raise ConnLoginError("Host terminates during login to server.")
except remote.LoginError:
raise ConnLoginError("Some error occurs login to client server.")
return server_session
def conn_setup(self):
"""
Enable tcp connect of libvirtd on server.
(1).initialization for variables.
(2).edit /etc/sysconfig/libvirtd on server.
(3).edit /etc/libvirt/libvirtd.conf on server.
(4).restart libvirtd service on server.
"""
# initialize variables
server_ip = self.server_ip
server_user = self.server_user
server_pwd = self.server_pwd
tcp_port = self.tcp_port
# edit the /etc/sysconfig/libvirtd to add --listen args in libvirtd
pattern2repl = {r".*LIBVIRTD_ARGS\s*=\s*\"\s*--listen\s*\".*":
"LIBVIRTD_ARGS=\"--listen\""}
self.remote_syslibvirtd.sub_else_add(pattern2repl)
# edit the /etc/libvirt/libvirtd.conf
# listen_tcp=1, tcp_port=$tcp_port, auth_tcp="none"
pattern2repl = {r".*listen_tls\s*=.*": 'listen_tls=0',
r".*listen_tcp\s*=.*": 'listen_tcp=1',
r".*tcp_port\s*=.*": 'tcp_port="%s"' % (tcp_port),
r'.*auth_tcp\s*=.*': 'auth_tcp="none"'}
self.remote_libvirtdconf.sub_else_add(pattern2repl)
# restart libvirtd service on server
try:
session = remote.wait_for_login('ssh', server_ip, '22',
server_user, server_pwd,
r"[\#\$]\s*$")
libvirtd_service = utils_libvirtd.Libvirtd(session=session)
libvirtd_service.restart()
except (remote.LoginError, aexpect.ShellError), detail:
raise ConnServerRestartError(detail)
def conn_recover(self):
"""
Clean up for TCP connection.
(1).initialize variables.
(2).Delete the RemoteFile.
(3).restart libvirtd on server.
"""
# initialize variables
server_ip = self.server_ip
server_user = self.server_user
server_pwd = self.server_pwd
# delete the RemoteFile object to recover remote file.
del self.remote_syslibvirtd
del self.remote_libvirtdconf
# restart libvirtd service on server
try:
session = remote.wait_for_login('ssh', server_ip, '22',
server_user, server_pwd,
r"[\#\$]\s*$")
libvirtd_service = utils_libvirtd.Libvirtd(session=session)
libvirtd_service.restart()
except (remote.LoginError, aexpect.ShellError), detail:
raise ConnServerRestartError(detail)
def conn_recover(self):
"""
Clean up for TCP connection.
(1).initialize variables.
(2).Delete the RemoteFile.
(3).restart libvirtd on server.
"""
# initialize variables
server_ip = self.server_ip
server_user = self.server_user
server_pwd = self.server_pwd
# delete the RemoteFile object to recover remote file.
del self.remote_syslibvirtd
del self.remote_libvirtdconf
# restart libvirtd service on server
try:
session = remote.wait_for_login('ssh', server_ip, '22',
server_user, server_pwd,
r"[\#\$]\s*$")
libvirtd_service = utils_libvirtd.Libvirtd(session=session)
libvirtd_service.restart()
except (remote.LoginError, aexpect.ShellError), detail:
raise ConnServerRestartError(detail)
def run(test, params, env):
"""
Run Pktgen test between host/guest
1) Boot the main vm, or just grab it if it's already booted.
2) Configure pktgen server(only linux)
3) Run pktgen test, finish when timeout or env["pktgen_run"] != True
:param test: QEMU test object.
:param params: Dictionary with the test parameters.
:param env: Dictionary with test environment.
"""
login_timeout = float(params.get("login_timeout", 360))
error.context("Init the VM, and try to login", logging.info)
external_host = params.get("external_host")
if not external_host:
get_host_cmd = "ip route | awk '/default/ {print $3}'"
external_host = utils.system_output(get_host_cmd)
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
session = vm.wait_for_login(timeout=login_timeout)
error.context("Pktgen server environment prepare", logging.info)
# pktgen server only support linux, since pktgen is a linux kernel module
pktgen_server = params.get("pktgen_server", "localhost")
params_server = params.object_params("pktgen_server")
s_shell_client = params_server.get("shell_client", "ssh")
s_shell_port = params_server.get("shell_port", "22")
s_username = params_server.get("username", "root")
s_passwd = params_server.get("password", "123456")
s_shell_prompt = params_server.get("shell_prompt")
server_session = ""
# pktgen server is autotest virtual guest(only linux)
if pktgen_server in params.get("vms", "vm1 vm2"):
vm_pktgen = env.get_vm(pktgen_server)
vm_pktgen.verify_alive()
server_session = vm_pktgen.wait_for_login(timeout=login_timeout)
runner = server_session.cmd_output_safe
pktgen_ip = vm_pktgen.get_address()
pktgen_mac = vm_pktgen.get_mac_address()
server_interface = utils_net.get_linux_ifname(server_session,
pktgen_mac)
# pktgen server is a external host assigned
elif re.match(r"((\d){1,3}\.){3}(\d){1,3}", pktgen_server):
pktgen_ip = pktgen_server
server_session = remote.wait_for_login(s_shell_client, pktgen_ip,
s_shell_port, s_username,
s_passwd, s_shell_prompt)
runner = server_session.cmd_output_safe
server_interface = params.get("server_interface")
if not server_interface:
raise error.TestNAError("Must config server interface before test")
else:
# using host as a pktgen server
server_interface = params.get("netdst", "switch")
host_nic = utils_net.Interface(server_interface)
pktgen_ip = host_nic.get_ip()
pktgen_mac = host_nic.get_mac()
runner = utils.system
# copy pktgen_test scipt to the test server.
local_path = os.path.join(data_dir.get_root_dir(),
"shared/scripts/pktgen.sh")
remote_path = "/tmp/pktgen.sh"
remote.scp_to_remote(pktgen_ip, s_shell_port, s_username, s_passwd,
local_path, remote_path)
error.context("Run pktgen test")
run_threads = params.get("pktgen_threads", 1)
pktgen_stress_timeout = float(params.get("pktgen_test_timeout", 600))
exec_cmd = "%s %s %s %s %s" % (remote_path, vm.get_address(),
vm.get_mac_address(), server_interface,
run_threads)
try:
env["pktgen_run"] = True
try:
# Set a run flag in env, when other case call this case as a sub
# backgroud process, can set run flag to False to stop this case.
start_time = time.time()
stop_time = start_time + pktgen_stress_timeout
while (env["pktgen_run"] and time.time < stop_time):
runner(exec_cmd, timeout=pktgen_stress_timeout)
# using ping to kill the pktgen stress
except aexpect.ShellTimeoutError:
session.cmd("ping %s" % pktgen_ip, ignore_all_errors=True)
finally:
env["pktgen_run"] = False
error.context("Verify Host and guest kernel no error and call trace",
logging.info)
vm.verify_kernel_crash()
utils_misc.verify_host_dmesg()
error.context("Ping external host after pktgen test", logging.info)
status, output = utils_test.ping(dest=external_host,
session=session,
timeout=240,
count=20)
loss_ratio = utils_test.get_loss_ratio(output)
if (loss_ratio > int(params.get("packet_lost_ratio", 5))
or loss_ratio == -1):
logging.debug("Ping %s output: %s" % (external_host, output))
raise error.TestFail("Guest network connction unusable," +
"packet lost ratio is '%%%d'" % loss_ratio)
if server_session:
server_session.close()
if session:
session.close()
def run(test, params, env):
"""
Network stress test with netperf.
1) Boot up VM(s), setup SSH authorization between host
and guest(s)/external host
2) Prepare the test environment in server/client/host
3) Execute netperf tests, collect and analyze the results
:param test: QEMU test object.
:param params: Dictionary with the test parameters.
:param env: Dictionary with test environment.
"""
def mtu_set(mtu):
"""
Set server/client/host's mtu
:param mtu: mtu value to be set
"""
server_mtu_cmd = params.get("server_mtu_cmd")
client_mtu_cmd = params.get("client_mtu_cmd")
host_mtu_cmd = params.get("host_mtu_cmd")
error_context.context("Changing the MTU of guest", logging.info)
if params.get("os_type") == "linux":
ethname = utils_net.get_linux_ifname(server_ctl, mac)
netperf_base.ssh_cmd(server_ctl, server_mtu_cmd % (ethname, mtu))
elif params.get("os_type") == "windows":
connection_id = utils_net.get_windows_nic_attribute(
server_ctl, "macaddress", mac, "netconnectionid")
netperf_base.ssh_cmd(server_ctl,
server_mtu_cmd % (connection_id, mtu))
error_context.context("Changing the MTU of client", logging.info)
netperf_base.ssh_cmd(
client, client_mtu_cmd % (params.get("client_physical_nic"), mtu))
netdst = params.get("netdst", "switch")
host_bridges = utils_net.Bridge()
br_in_use = host_bridges.list_br()
if netdst in br_in_use:
ifaces_in_use = host_bridges.list_iface()
target_ifaces = list(ifaces_in_use + br_in_use)
if params.get("netdst_nic1") in process.system_output(
"ovs-vsctl list-br", ignore_status=True, shell=True).decode():
ovs_list = "ovs-vsctl list-ports %s" % params["netdst_nic1"]
ovs_port = process.system_output(ovs_list,
shell=True).decode().splitlines()
target_ifaces = target_ifaces + \
params.objects("netdst_nic1") + ovs_port
if vm.virtnet[0].nettype == "macvtap":
target_ifaces.extend([vm.virtnet[0].netdst, vm.get_ifname(0)])
error_context.context("Change all Bridge NICs MTU to %s" % mtu,
logging.info)
for iface in target_ifaces:
try:
process.run(host_mtu_cmd % (iface, mtu),
ignore_status=False,
shell=True)
except process.CmdError as err:
if "SIOCSIFMTU" in err.result.stderr.decode():
test.cancel("The ethenet device does not support jumbo,"
"cancel test")
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
login_timeout = int(params.get("login_timeout", 360))
try:
vm.wait_for_serial_login(timeout=login_timeout,
restart_network=True).close()
except virt_vm.VMIPAddressMissingError:
pass
if len(params.get("nics", "").split()) > 1:
session = vm.wait_for_login(nic_index=1, timeout=login_timeout)
else:
session = vm.wait_for_login(timeout=login_timeout)
config_cmds = params.get("config_cmds")
if config_cmds:
for config_cmd in config_cmds.split(","):
cmd = params.get(config_cmd.strip())
if cmd:
s, o = session.cmd_status_output(cmd)
if s:
msg = "Config command %s failed. Output: %s" % (cmd, o)
test.error(msg)
if params.get("reboot_after_config", "yes") == "yes":
session = vm.reboot(session=session, timeout=login_timeout)
vm.wait_for_serial_login(timeout=login_timeout,
restart_network=True).close()
mac = vm.get_mac_address(0)
if params.get("os_type") == "linux":
ethname = utils_net.get_linux_ifname(session, mac)
queues = int(params.get("queues", 1))
if queues > 1:
if params.get("os_type") == "linux":
session.cmd_status_output("ethtool -L %s combined %s" %
(ethname, queues))
else:
logging.info("FIXME: support to enable MQ for Windows guest!")
if params.get("server_private_ip") and params.get("os_type") == "linux":
server_ip = params.get("server_private_ip")
cmd = "systemctl stop NetworkManager.service"
cmd += " && ifconfig %s %s up" % (ethname, server_ip)
session.cmd_output(cmd)
else:
server_ip = vm.wait_for_get_address(0, timeout=90)
if len(params.get("nics", "").split()) > 1:
server_ctl = vm.wait_for_login(nic_index=1, timeout=login_timeout)
server_ctl_ip = vm.wait_for_get_address(1, timeout=90)
else:
server_ctl = vm.wait_for_login(timeout=login_timeout)
server_ctl_ip = server_ip
if params.get("rh_perf_envsetup_script"):
utils_test.service_setup(vm, session, test.virtdir)
session.close()
if (params.get("os_type") == "windows"
and params.get("use_cygwin") == "yes"):
cygwin_prompt = params.get("cygwin_prompt", r"\$\s+$")
cygwin_start = params.get("cygwin_start")
server_cyg = vm.wait_for_login(timeout=login_timeout)
server_cyg.set_prompt(cygwin_prompt)
server_cyg.cmd_output(cygwin_start)
else:
server_cyg = None
logging.debug(
process.system_output("numactl --hardware",
verbose=False,
ignore_status=True,
shell=True).decode())
logging.debug(
process.system_output("numactl --show",
verbose=False,
ignore_status=True,
shell=True).decode())
# pin guest vcpus/memory/vhost threads to last numa node of host by default
numa_node = netperf_base.pin_vm_threads(vm, params.get("numa_node"))
host = params.get("host", "localhost")
host_ip = host
if host != "localhost":
params_host = params.object_params("host")
host = remote.wait_for_login(params_host.get("shell_client"), host_ip,
params_host.get("shell_port"),
params_host.get("username"),
params_host.get("password"),
params_host.get("shell_prompt"))
client = params.get("client", "localhost")
client_ip = client
clients = []
# client session 1 for control, session 2 for data communication
for i in range(2):
if client in params.get("vms"):
vm_client = env.get_vm(client)
tmp = vm_client.wait_for_login(timeout=login_timeout)
client_ip = vm_client.wait_for_get_address(0, timeout=5)
elif client != "localhost" and params.get("os_type_client") == "linux":
client_pub_ip = params.get("client_public_ip")
tmp = remote.wait_for_login(params.get("shell_client_client"),
client_pub_ip,
params.get("shell_port_client"),
params.get("username_client"),
params.get("password_client"),
params.get("shell_prompt_client"))
cmd = "ifconfig %s %s up" % (params.get("client_physical_nic"),
client_ip)
netperf_base.ssh_cmd(tmp, cmd)
else:
tmp = "localhost"
clients.append(tmp)
client = clients[0]
vms_list = params["vms"].split()
if len(vms_list) > 1:
vm2 = env.get_vm(vms_list[-1])
vm2.verify_alive()
session2 = vm2.wait_for_login(timeout=login_timeout)
if params.get("rh_perf_envsetup_script"):
utils_test.service_setup(vm2, session2, test.virtdir)
client = vm2.wait_for_login(timeout=login_timeout)
client_ip = vm2.get_address()
session2.close()
netperf_base.pin_vm_threads(vm2, numa_node)
error_context.context("Prepare env of server/client/host", logging.info)
prepare_list = set([server_ctl, client, host])
tag_dict = {server_ctl: "server", client: "client", host: "host"}
if client_pub_ip:
ip_dict = {
server_ctl: server_ctl_ip,
client: client_pub_ip,
host: host_ip
}
else:
ip_dict = {server_ctl: server_ctl_ip, client: client_ip, host: host_ip}
for i in prepare_list:
params_tmp = params.object_params(tag_dict[i])
if params_tmp.get("os_type") == "linux":
shell_port = int(params_tmp["shell_port"])
password = params_tmp["password"]
username = params_tmp["username"]
netperf_base.env_setup(test, params, i, ip_dict[i], username,
shell_port, password)
elif params_tmp.get("os_type") == "windows":
windows_disable_firewall = params.get("windows_disable_firewall")
netperf_base.ssh_cmd(i, windows_disable_firewall)
netperf_base.tweak_tuned_profile(params, server_ctl, client, host)
mtu = int(params.get("mtu", "1500"))
mtu_set(mtu)
env.stop_ip_sniffing()
try:
error_context.context("Start netperf testing", logging.info)
start_test(server_ip,
server_ctl,
host,
clients,
test.resultsdir,
test_duration=int(params.get('l')),
sessions_rr=params.get('sessions_rr'),
sessions=params.get('sessions'),
sizes_rr=params.get('sizes_rr'),
sizes=params.get('sizes'),
protocols=params.get('protocols'),
netserver_port=params.get('netserver_port', "12865"),
params=params,
server_cyg=server_cyg,
test=test)
if params.get("log_hostinfo_script"):
src = os.path.join(test.virtdir, params.get("log_hostinfo_script"))
path = os.path.join(test.resultsdir, "systeminfo")
process.system_output("bash %s %s &> %s" %
(src, test.resultsdir, path),
shell=True)
if params.get("log_guestinfo_script") and params.get(
"log_guestinfo_exec"):
src = os.path.join(test.virtdir,
params.get("log_guestinfo_script"))
path = os.path.join(test.resultsdir, "systeminfo")
destpath = params.get("log_guestinfo_path",
"/tmp/log_guestinfo.sh")
vm.copy_files_to(src, destpath, nic_index=1)
logexec = params.get("log_guestinfo_exec", "bash")
output = server_ctl.cmd_output("%s %s" % (logexec, destpath))
logfile = open(path, "a+")
logfile.write(output)
logfile.close()
finally:
if mtu != 1500:
mtu_default = 1500
error_context.context(
"Change back server, client and host's mtu to %s" %
mtu_default)
mtu_set(mtu_default)
if params.get("client_physical_nic") and params.get(
"os_type_client") == "linux":
cmd = 'ifconfig %s 0.0.0.0 down' % params.get(
"client_physical_nic")
netperf_base.ssh_cmd(client, cmd)
def run(test, params, env):
"""
Test the command virsh hostname
(1) Call virsh hostname
(2) Call virsh hostname with an unexpected option
(3) Call virsh hostname with libvirtd service stop
"""
remote_ip = params.get("remote_ip")
remote_pwd = params.get("remote_pwd", None)
remote_user = params.get("remote_user", "root")
remote_uri = params.get("remote_uri", None)
if remote_uri and remote_ip.count("EXAMPLE"):
test.cancel("Pls configure rempte_ip first")
session = None
if remote_uri:
session = remote.wait_for_login('ssh', remote_ip, '22',
remote_user, remote_pwd,
r"[\#\$]\s*$")
hostname = session.cmd_output("hostname -f").strip()
else:
hostname_result = process.run("hostname -f", shell=True, ignore_status=True)
hostname = hostname_result.stdout_text.strip()
# Prepare libvirtd service on local
check_libvirtd = "libvirtd" in params
if check_libvirtd:
libvirtd = params.get("libvirtd")
if libvirtd == "off":
utils_libvirtd.libvirtd_stop()
# Start libvirtd on remote server
if remote_uri:
if not utils_package.package_install("libvirt", session):
test.cancel("Failed to install libvirt on remote server")
libvirtd = utils_libvirtd.Libvirtd(session=session)
libvirtd.restart()
# Run test case
if remote_uri:
ssh_key.setup_ssh_key(remote_ip, remote_user, remote_pwd)
option = params.get("virsh_hostname_options")
hostname_test = virsh.hostname(option, uri=remote_uri,
ignore_status=True,
debug=True)
status = 0
if hostname_test == '':
status = 1
hostname_test = None
# Recover libvirtd service start
if libvirtd == "off":
utils_libvirtd.libvirtd_start()
# Close session
if session:
session.close()
# Check status_error
status_error = params.get("status_error")
if status_error == "yes":
if status == 0:
test.fail("Command 'virsh hostname %s' succeeded "
"(incorrect command)" % option)
elif status_error == "no":
if hostname != hostname_test:
test.fail(
"Virsh cmd gives hostname %s != %s." % (hostname_test, hostname))
if status != 0:
test.fail("Command 'virsh hostname %s' failed "
"(correct command)" % option)
def run(test, params, env):
"""
Network stress test with netperf.
1) Boot up VM(s), setup SSH authorization between host
and guest(s)/external host
2) Prepare the test environment in server/client/host
3) Execute netperf tests, collect and analyze the results
:param test: QEMU test object.
:param params: Dictionary with the test parameters.
:param env: Dictionary with test environment.
"""
def env_setup(session, ip, user, port, password):
error_context.context("Setup env for %s" % ip)
if params.get("env_setup_cmd"):
ssh_cmd(session, params.get("env_setup_cmd"), ignore_status=True)
pkg = params["netperf_pkg"]
pkg = os.path.join(data_dir.get_deps_dir(), pkg)
remote.scp_to_remote(ip, shell_port, username, password, pkg, "/tmp")
ssh_cmd(session, params.get("setup_cmd"))
agent_path = os.path.join(test.virtdir, "scripts/netperf_agent.py")
remote.scp_to_remote(ip, shell_port, username, password,
agent_path, "/tmp")
def mtu_set(mtu):
"""
Set server/client/host's mtu
:param mtu: mtu value to be set
"""
server_mtu_cmd = params.get("server_mtu_cmd")
client_mtu_cmd = params.get("client_mtu_cmd")
host_mtu_cmd = params.get("host_mtu_cmd")
error_context.context("Changing the MTU of guest", logging.info)
if params.get("os_type") == "linux":
ethname = utils_net.get_linux_ifname(server_ctl, mac)
ssh_cmd(server_ctl, server_mtu_cmd % (ethname, mtu))
elif params.get("os_type") == "windows":
connection_id = utils_net.get_windows_nic_attribute(
server_ctl, "macaddress", mac, "netconnectionid")
ssh_cmd(server_ctl, server_mtu_cmd % (connection_id, mtu))
error_context.context("Changing the MTU of client", logging.info)
ssh_cmd(client, client_mtu_cmd
% (params.get("client_physical_nic"), mtu))
netdst = params.get("netdst", "switch")
host_bridges = utils_net.Bridge()
br_in_use = host_bridges.list_br()
if netdst in br_in_use:
ifaces_in_use = host_bridges.list_iface()
target_ifaces = list(ifaces_in_use + br_in_use)
if params.get("netdst_nic1") in process.system_output(
"ovs-vsctl list-br", ignore_status=True, shell=True).decode():
ovs_list = "ovs-vsctl list-ports %s" % params["netdst_nic1"]
ovs_port = process.system_output(ovs_list,
shell=True).decode().splitlines()
target_ifaces = target_ifaces + \
params.objects("netdst_nic1") + ovs_port
if vm.virtnet[0].nettype == "macvtap":
target_ifaces.extend([vm.virtnet[0].netdst, vm.get_ifname(0)])
error_context.context("Change all Bridge NICs MTU to %s"
% mtu, logging.info)
for iface in target_ifaces:
try:
process.run(host_mtu_cmd % (iface, mtu), ignore_status=False,
shell=True)
except process.CmdError as err:
if "SIOCSIFMTU" in err.result.stderr.decode():
test.cancel("The ethenet device does not support jumbo,"
"cancel test")
def tweak_tuned_profile():
"""
Tweak configuration with truned profile
"""
client_tuned_profile = params.get("client_tuned_profile")
server_tuned_profile = params.get("server_tuned_profile")
host_tuned_profile = params.get("host_tuned_profile")
error_context.context("Changing tune profile of guest", logging.info)
if params.get("os_type") == "linux" and server_tuned_profile:
ssh_cmd(server_ctl, server_tuned_profile)
error_context.context("Changing tune profile of client/host",
logging.info)
if client_tuned_profile:
ssh_cmd(client, client_tuned_profile)
if host_tuned_profile:
ssh_cmd(host, host_tuned_profile)
def _pin_vm_threads(vm, node):
if node:
if not isinstance(node, utils_misc.NumaNode):
node = utils_misc.NumaNode(int(node))
utils_test.qemu.pin_vm_threads(vm, node)
return node
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
login_timeout = int(params.get("login_timeout", 360))
vm.wait_for_serial_login(timeout=login_timeout, restart_network=True).close()
if len(params.get("nics", "").split()) > 1:
session = vm.wait_for_login(nic_index=1, timeout=login_timeout)
else:
session = vm.wait_for_login(timeout=login_timeout)
config_cmds = params.get("config_cmds")
if config_cmds:
for config_cmd in config_cmds.split(","):
cmd = params.get(config_cmd.strip())
if cmd:
s, o = session.cmd_status_output(cmd)
if s:
msg = "Config command %s failed. Output: %s" % (cmd, o)
test.error(msg)
if params.get("reboot_after_config", "yes") == "yes":
session = vm.reboot(session=session, timeout=login_timeout)
vm.wait_for_serial_login(timeout=login_timeout, restart_network=True).close()
server_ip = vm.wait_for_get_address(0, timeout=90)
if len(params.get("nics", "").split()) > 1:
server_ctl = vm.wait_for_login(nic_index=1, timeout=login_timeout)
server_ctl_ip = vm.wait_for_get_address(1, timeout=90)
else:
server_ctl = vm.wait_for_login(timeout=login_timeout)
server_ctl_ip = server_ip
mac = vm.get_mac_address(0)
queues = int(params.get("queues", 1))
if queues > 1:
if params.get("os_type") == "linux":
ethname = utils_net.get_linux_ifname(session, mac)
session.cmd_status_output("ethtool -L %s combined %s" %
(ethname, queues))
else:
logging.info("FIXME: support to enable MQ for Windows guest!")
if params.get("rh_perf_envsetup_script"):
utils_test.service_setup(vm, session, test.virtdir)
session.close()
if (params.get("os_type") == "windows" and
params.get("use_cygwin") == "yes"):
cygwin_prompt = params.get("cygwin_prompt", r"\$\s+$")
cygwin_start = params.get("cygwin_start")
server_cyg = vm.wait_for_login(timeout=login_timeout)
server_cyg.set_prompt(cygwin_prompt)
server_cyg.cmd_output(cygwin_start)
else:
server_cyg = None
logging.debug(process.system_output("numactl --hardware",
verbose=False, ignore_status=True,
shell=True).decode())
logging.debug(process.system_output("numactl --show",
verbose=False, ignore_status=True,
shell=True).decode())
# pin guest vcpus/memory/vhost threads to last numa node of host by default
numa_node = _pin_vm_threads(vm, params.get("numa_node"))
host = params.get("host", "localhost")
host_ip = host
if host != "localhost":
params_host = params.object_params("host")
host = remote.wait_for_login(params_host.get("shell_client"),
host_ip,
params_host.get("shell_port"),
params_host.get("username"),
params_host.get("password"),
params_host.get("shell_prompt"))
client = params.get("client", "localhost")
client_ip = client
clients = []
# client session 1 for control, session 2 for data communication
for i in range(2):
if client in params.get("vms"):
vm_client = env.get_vm(client)
tmp = vm_client.wait_for_login(timeout=login_timeout)
client_ip = vm_client.wait_for_get_address(0, timeout=5)
elif client != "localhost":
tmp = remote.wait_for_login(params.get("shell_client_client"),
client_ip,
params.get("shell_port_client"),
params.get("username_client"),
params.get("password_client"),
params.get("shell_prompt_client"))
else:
tmp = "localhost"
clients.append(tmp)
client = clients[0]
vms_list = params["vms"].split()
if len(vms_list) > 1:
vm2 = env.get_vm(vms_list[-1])
vm2.verify_alive()
session2 = vm2.wait_for_login(timeout=login_timeout)
if params.get("rh_perf_envsetup_script"):
utils_test.service_setup(vm2, session2, test.virtdir)
client = vm2.wait_for_login(timeout=login_timeout)
client_ip = vm2.get_address()
session2.close()
_pin_vm_threads(vm2, numa_node)
error_context.context("Prepare env of server/client/host", logging.info)
prepare_list = set([server_ctl, client, host])
tag_dict = {server_ctl: "server", client: "client", host: "host"}
ip_dict = {server_ctl: server_ctl_ip, client: client_ip, host: host_ip}
for i in prepare_list:
params_tmp = params.object_params(tag_dict[i])
if params_tmp.get("os_type") == "linux":
shell_port = int(params_tmp["shell_port"])
password = params_tmp["password"]
username = params_tmp["username"]
env_setup(i, ip_dict[i], username, shell_port, password)
elif params_tmp.get("os_type") == "windows":
windows_disable_firewall = params.get("windows_disable_firewall")
ssh_cmd(i, windows_disable_firewall)
tweak_tuned_profile()
mtu = int(params.get("mtu", "1500"))
mtu_set(mtu)
env.stop_ip_sniffing()
try:
error_context.context("Start netperf testing", logging.info)
start_test(server_ip, server_ctl, host, clients, test.resultsdir,
test_duration=int(params.get('l')),
sessions_rr=params.get('sessions_rr'),
sessions=params.get('sessions'),
sizes_rr=params.get('sizes_rr'),
sizes=params.get('sizes'),
protocols=params.get('protocols'),
ver_cmd=params.get('ver_cmd', "rpm -q qemu-kvm"),
netserver_port=params.get('netserver_port', "12865"),
params=params, server_cyg=server_cyg, test=test)
if params.get("log_hostinfo_script"):
src = os.path.join(test.virtdir, params.get("log_hostinfo_script"))
path = os.path.join(test.resultsdir, "systeminfo")
process.system_output("bash %s %s &> %s" % (
src, test.resultsdir, path), shell=True)
if params.get("log_guestinfo_script") and params.get("log_guestinfo_exec"):
src = os.path.join(test.virtdir, params.get("log_guestinfo_script"))
path = os.path.join(test.resultsdir, "systeminfo")
destpath = params.get("log_guestinfo_path", "/tmp/log_guestinfo.sh")
vm.copy_files_to(src, destpath, nic_index=1)
logexec = params.get("log_guestinfo_exec", "bash")
output = server_ctl.cmd_output("%s %s" % (logexec, destpath))
logfile = open(path, "a+")
logfile.write(output)
logfile.close()
finally:
if mtu != 1500:
mtu_default = 1500
error_context.context("Change back server, client and host's mtu to %s"
% mtu_default)
mtu_set(mtu_default)
def enable_hugepage(vmname, no_of_HPs, hp_unit='', hp_node='', pin=False,
node_list=[], host_hp_size=0, numa_pin=False):
"""
creates list of dictionaries of page tag for HP
:param vmname: name of the guest
:param no_of_HPs: Number of hugepages
:param hp_unit: unit of HP size
:param hp_node: number of numa nodes to be HP pinned
:param pin: flag to pin HP with guest numa or not
:param node_list: Numa node list
:param host_hp_size: size of the HP to pin with guest numa
:param numa_pin: flag to numa pin
:return: list of page tag dictionary for HP pin
"""
dest_machine = params.get("migrate_dest_host")
server_user = params.get("server_user", "root")
server_pwd = params.get("server_pwd")
command = "cat /proc/meminfo | grep HugePages_Free"
server_session = remote.wait_for_login('ssh', dest_machine, '22',
server_user, server_pwd,
r"[\#\$]\s*$")
cmd_output = server_session.cmd_status_output(command)
server_session.close()
if (cmd_output[0] == 0):
dest_HP_free = cmd_output[1].strip('HugePages_Free:').strip()
else:
raise error.TestNAError("HP not supported/configured")
hp_list = []
# setting hugepages in destination machine here as remote ssh
# configuration is done
hugepage_assign(str(no_of_HPs), target_ip=dest_machine,
user=server_user, password=server_pwd)
logging.debug("Remote host hugepage config done")
if numa_pin:
for each_node in node_list:
if (each_node['mode'] == 'strict'):
# reset source host hugepages
if int(utils_memory.get_num_huge_pages() > 0):
logging.debug("reset source host hugepages")
hugepage_assign("0")
# reset dest host hugepages
if (int(dest_HP_free) > 0):
logging.debug("reset dest host hugepages")
hugepage_assign("0", target_ip=dest_machine,
user=server_user, password=server_pwd)
# set source host hugepages for the specific node
logging.debug("set src host hugepages for specific node")
hugepage_assign(str(no_of_HPs), node=each_node['nodeset'],
hp_size=str(host_hp_size))
# set dest host hugepages for specific node
logging.debug("set dest host hugepages for specific node")
hugepage_assign(str(no_of_HPs), target_ip=dest_machine,
node=each_node['nodeset'], hp_size=str(
host_hp_size), user=server_user,
password=server_pwd)
if not pin:
vm_xml.VMXML.set_memoryBacking_tag(vmname)
logging.debug("Hugepage without pin")
else:
hp_dict = {}
hp_dict['size'] = str(host_hp_size)
hp_dict['unit'] = str(hp_unit)
if int(hp_node) == 1:
hp_dict['nodeset'] = "0"
logging.debug("Hugepage with pin to 1 node")
else:
hp_dict['nodeset'] = "0-1"
logging.debug("Hugepage with pin to both nodes")
hp_list.append(hp_dict)
logging.debug(hp_list)
return hp_list
def run_multi_nic_stress(test, params, env):
"""
Network stress with multi nics test with netperf.
1) Boot up VM(s), setup SSH authorization between host
and guest(s)/external host
2) Prepare the test environment in server/client
3) Execute netperf stress on multi nics
4) After the stress do ping, check the nics works
:param test: QEMU test object.
:param params: Dictionary with the test parameters.
:param env: Dictionary with test environment.
"""
def env_setup(session, ip_addr, username, shell_port, password):
"""
Test env setup
"""
error.context("Setup env for %s" % ip_addr)
ssh_cmd(session, "service iptables stop; true")
netperf_links = params["netperf_links"].split()
remote_dir = params.get("remote_dir", "/var/tmp")
for netperf_link in netperf_links:
if utils.is_url(netperf_link):
download_dir = data_dir.get_download_dir()
md5sum = params.get("pkg_md5sum")
netperf_dir = utils.unmap_url_cache(download_dir,
netperf_link, md5sum)
elif netperf_link:
netperf_dir = os.path.join(data_dir.get_root_dir(),
"shared/%s" % netperf_link)
remote.scp_to_remote(ip_addr, shell_port, username, password,
netperf_dir, remote_dir)
ssh_cmd(session, params.get("setup_cmd"))
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
login_timeout = int(params.get("login_timeout", 360))
server_ips = []
server_ctl = vm.wait_for_login(timeout=login_timeout)
server_ip = vm.get_address()
server_ips.append(server_ip)
server_ctl_ip = server_ip
server_ctl_mac = vm.get_mac_address()
# the first nic used for server control.
params_server_nic = params.object_params(vm.name)
nics_count = len(params_server_nic.get("nics", "").split())
if nics_count > 1:
server_ips = []
for i in range(nics_count)[1:]:
vm.wait_for_login(nic_index=i, timeout=login_timeout)
server_ips.append(vm.get_address(index=i))
clients = params.get("client", "localhost")
clients_ips = []
clients_sessions = []
# client session 1 for control, session 2 for data communication
for client in clients.split():
for i in range(2):
if client in params.get("vms"):
vm = env.get_vm(client)
vm.verify_alive()
tmp = vm.wait_for_login()
client_ip = vm.get_address()
elif client == "localhost":
client_ip = client
tmp = "localhost"
else:
client_ip == client
tmp = remote.wait_for_login(params.get("shell_client_client"),
client_ip,
params.get("shell_port_client"),
params.get("username_client"),
params.get("password_client"),
params.get("shell_prompt_client"),
params.get("shell_linesep_client"))
clients_sessions.append(tmp)
clients_ips.append(client_ip)
client_ctl_session = clients_sessions[::2]
clients = clients_sessions[1::2]
if params.get("os_type") == "linux":
nics_list = utils_net.get_linux_ifname(server_ctl)
if len(nics_list) > 1:
ctl_nic = utils_net.get_linux_ifname(server_ctl, server_ctl_mac)
nics_list.remove(ctl_nic)
for ip in clients_ips:
index = clients_ips.index(ip) % len(nics_list)
server_ctl.cmd("route add -host %s %s" % (ip, nics_list[index]))
error.context("Prepare env of server/client", logging.info)
client_ctl_session.append(server_ctl)
clients_ips.append(server_ctl_ip)
for session in client_ctl_session:
if session == server_ctl:
para_tag = "server"
else:
para_tag = "client"
params_tmp = params.object_params(para_tag)
if params_tmp.get("os_type") == "linux":
shell_port = int(params_tmp["shell_port"])
password = params_tmp["password"]
username = params_tmp["username"]
env_setup(session, clients_ips[client_ctl_session.index(session)],
username, shell_port, password)
error.context("Start netperf testing", logging.info)
try:
start_test(server_ips, server_ctl, clients,
l=int(params.get('l', 60)),
sessions_rr=params.get('sessions_rr'),
sessions=params.get('sessions'),
sizes_rr=params.get('sizes_rr'),
sizes=params.get('sizes'),
protocols=params.get('protocols'),
netserver_port=params.get('netserver_port', "12865"),
params=params)
finally:
for session in clients_sessions:
if session:
session.close()
if server_ctl:
server_ctl.close()
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 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 remote access with TCP, TLS connection
"""
test_dict = dict(params)
vm_name = test_dict.get("main_vm")
status_error = test_dict.get("status_error", "no")
allowed_dn_str = params.get("tls_allowed_dn_list")
if allowed_dn_str:
allowed_dn_list = []
if not libvirt_version.version_compare(1, 0, 0):
# Reverse the order in the dn list to workaround the
# feature changes between RHEL 6 and RHEL 7
dn_list = allowed_dn_str.split(",")
dn_list.reverse()
allowed_dn_str = ','.join(dn_list)
allowed_dn_list.append(allowed_dn_str)
test_dict['tls_allowed_dn_list'] = allowed_dn_list
transport = test_dict.get("transport")
plus = test_dict.get("conn_plus", "+")
config_ipv6 = test_dict.get("config_ipv6", "no")
tls_port = test_dict.get("tls_port", "")
listen_addr = test_dict.get("listen_addr", "0.0.0.0")
ssh_port = test_dict.get("ssh_port", "")
tcp_port = test_dict.get("tcp_port", "")
server_ip = test_dict.get("server_ip")
server_user = test_dict.get("server_user")
server_pwd = test_dict.get("server_pwd")
no_any_config = params.get("no_any_config", "no")
sasl_type = test_dict.get("sasl_type", "gssapi")
sasl_user_pwd = test_dict.get("sasl_user_pwd")
sasl_allowed_users = test_dict.get("sasl_allowed_users")
server_cn = test_dict.get("server_cn")
custom_pki_path = test_dict.get("custom_pki_path")
rm_client_key_cmd = test_dict.get("remove_client_key_cmd")
rm_client_cert_cmd = test_dict.get("remove_client_cert_cmd")
ca_cn_new = test_dict.get("ca_cn_new")
no_verify = test_dict.get("no_verify", "no")
ipv6_addr_des = test_dict.get("ipv6_addr_des")
tls_sanity_cert = test_dict.get("tls_sanity_cert")
restart_libvirtd = test_dict.get("restart_libvirtd", "yes")
diff_virt_ver = test_dict.get("diff_virt_ver", "no")
driver = test_dict.get("test_driver", "qemu")
uri_path = test_dict.get("uri_path", "/system")
virsh_cmd = params.get("virsh_cmd", "list")
action = test_dict.get("libvirtd_action", "restart")
uri_user = test_dict.get("uri_user", "")
unix_sock_dir = test_dict.get("unix_sock_dir")
mkdir_cmd = test_dict.get("mkdir_cmd")
rmdir_cmd = test_dict.get("rmdir_cmd")
adduser_cmd = test_dict.get("adduser_cmd")
deluser_cmd = test_dict.get("deluser_cmd")
auth_conf = test_dict.get("auth_conf")
auth_conf_cxt = test_dict.get("auth_conf_cxt")
polkit_pkla = test_dict.get("polkit_pkla")
polkit_pkla_cxt = test_dict.get("polkit_pkla_cxt")
ssh_setup = test_dict.get("ssh_setup", "no")
tcp_setup = test_dict.get("tcp_setup", "no")
tls_setup = test_dict.get("tls_setup", "no")
unix_setup = test_dict.get("unix_setup", "no")
ssh_recovery = test_dict.get("ssh_auto_recovery", "yes")
tcp_recovery = test_dict.get("tcp_auto_recovery", "yes")
tls_recovery = test_dict.get("tls_auto_recovery", "yes")
unix_recovery = test_dict.get("unix_auto_recovery", "yes")
port = ""
# extra URI arguments
extra_params = ""
# it's used to clean up SSH, TLS, TCP, UNIX and SASL objs later
objs_list = []
# redirect LIBVIRT_DEBUG log into test log later
test_dict["logfile"] = test.logfile
# Make sure all of parameters are assigned a valid value
check_parameters(test_dict, test)
# only simply connect libvirt daemon then return
if no_any_config == "yes":
test_dict["uri"] = "%s%s%s://%s" % (driver, plus, transport, uri_path)
remote_access(test_dict, test)
return
# append extra 'pkipath' argument to URI if exists
if custom_pki_path:
extra_params = "?pkipath=%s" % custom_pki_path
# append extra 'no_verify' argument to URI if exists
if no_verify == "yes":
extra_params = "?no_verify=1"
# append extra 'socket' argument to URI if exists
if unix_sock_dir:
extra_params = "?socket=%s/libvirt-sock" % unix_sock_dir
# generate auth.conf and default under the '/etc/libvirt'
if auth_conf_cxt and auth_conf:
cmd = "echo -e '%s' > %s" % (auth_conf_cxt, auth_conf)
process.system(cmd, ignore_status=True, shell=True)
# generate polkit_pkla and default under the
# '/etc/polkit-1/localauthority/50-local.d/'
if polkit_pkla_cxt and polkit_pkla:
cmd = "echo -e '%s' > %s" % (polkit_pkla_cxt, polkit_pkla)
process.system(cmd, ignore_status=True, shell=True)
# generate remote IP
if config_ipv6 == "yes" and ipv6_addr_des:
remote_ip = "[%s]" % ipv6_addr_des
elif config_ipv6 != "yes" and server_cn:
remote_ip = server_cn
elif config_ipv6 != "yes" and ipv6_addr_des:
remote_ip = "[%s]" % ipv6_addr_des
elif server_ip and transport != "unix":
remote_ip = server_ip
else:
remote_ip = ""
# get URI port
if tcp_port != "":
port = ":" + tcp_port
if tls_port != "":
port = ":" + tls_port
if ssh_port != "" and not ipv6_addr_des:
port = ":" + ssh_port
# generate URI
uri = "%s%s%s://%s%s%s%s%s" % (driver, plus, transport, uri_user,
remote_ip, port, uri_path, extra_params)
test_dict["uri"] = uri
logging.debug("The final test dict:\n<%s>", test_dict)
if virsh_cmd == "start" and transport != "unix":
session = remote.wait_for_login("ssh", server_ip, "22", "root",
server_pwd, "#")
cmd = "virsh domstate %s" % vm_name
status, output = session.cmd_status_output(cmd)
if status:
session.close()
test.cancel(output)
session.close()
try:
# setup IPv6
if config_ipv6 == "yes":
ipv6_obj = IPv6Manager(test_dict)
objs_list.append(ipv6_obj)
ipv6_obj.setup()
# compare libvirt version if needs
if diff_virt_ver == "yes":
compare_virt_version(server_ip, server_user, server_pwd, test)
# setup SSH
if transport == "ssh" or ssh_setup == "yes":
if not test_dict.get("auth_pwd"):
ssh_obj = SSHConnection(test_dict)
if ssh_recovery == "yes":
objs_list.append(ssh_obj)
# setup test environment
ssh_obj.conn_setup()
# setup TLS
if transport == "tls" or tls_setup == "yes":
tls_obj = TLSConnection(test_dict)
if tls_recovery == "yes":
objs_list.append(tls_obj)
# reserve cert path
tmp_dir = tls_obj.tmp_dir
# setup test environment
if tls_sanity_cert == "no":
# only setup CA and client
tls_obj.conn_setup(False, True)
else:
# setup CA, server and client
tls_obj.conn_setup()
# setup TCP
if transport == "tcp" or tcp_setup == "yes":
tcp_obj = TCPConnection(test_dict)
if tcp_recovery == "yes":
objs_list.append(tcp_obj)
# setup test environment
tcp_obj.conn_setup()
# create a directory if needs
if mkdir_cmd:
process.system(mkdir_cmd, ignore_status=True, shell=True)
# setup UNIX
if transport == "unix" or unix_setup == "yes":
unix_obj = UNIXConnection(test_dict)
if unix_recovery == "yes":
objs_list.append(unix_obj)
# setup test environment
unix_obj.conn_setup()
# need to restart libvirt service for negative testing
if restart_libvirtd == "no":
remotely_control_libvirtd(server_ip, server_user,
server_pwd, action, status_error)
# check TCP/IP listening by service
if restart_libvirtd != "no" and transport != "unix":
service = 'libvirtd'
if transport == "ssh":
service = 'ssh'
check_listening_port_remote_by_service(server_ip, server_user,
server_pwd, service,
port, listen_addr)
# remove client certifications if exist, only for TLS negative testing
if rm_client_key_cmd:
process.system(rm_client_key_cmd, ignore_status=True, shell=True)
if rm_client_cert_cmd:
process.system(rm_client_cert_cmd, ignore_status=True, shell=True)
# add user to specific group
if adduser_cmd:
process.system(adduser_cmd, ignore_status=True, shell=True)
# change /etc/pki/libvirt/servercert.pem then
# restart libvirt service on the remote host
if tls_sanity_cert == "no" and ca_cn_new:
test_dict['ca_cn'] = ca_cn_new
test_dict['ca_cakey_path'] = tmp_dir
test_dict['scp_new_cacert'] = 'no'
tls_obj_new = TLSConnection(test_dict)
test_dict['tls_obj_new'] = tls_obj_new
# only setup new CA and server
tls_obj_new.conn_setup(True, False)
# setup SASL certification
# From libvirt-3.2.0, the default sasl change from
# DIGEST-MD5 to GSSAPI. "sasl_user" is discarded.
# More details: https://libvirt.org/auth.html#ACL_server_kerberos
if sasl_user_pwd and sasl_type == 'digest-md5':
# covert string tuple and list to python data type
sasl_user_pwd = eval(sasl_user_pwd)
if sasl_allowed_users:
sasl_allowed_users = eval(sasl_allowed_users)
# create a sasl user
sasl_obj = SASL(test_dict)
objs_list.append(sasl_obj)
sasl_obj.setup()
for sasl_user, sasl_pwd in sasl_user_pwd:
# need't authentication if the auth.conf is configured by user
if not auth_conf:
test_dict["auth_user"] = sasl_user
test_dict["auth_pwd"] = sasl_pwd
logging.debug("sasl_user, sasl_pwd = "
"(%s, %s)", sasl_user, sasl_pwd)
if sasl_allowed_users and sasl_user not in sasl_allowed_users:
test_dict["status_error"] = "yes"
patterns_extra_dict = {"authentication name": sasl_user}
test_dict["patterns_extra_dict"] = patterns_extra_dict
remote_access(test_dict, test)
else:
remote_access(test_dict, test)
finally:
# recovery test environment
# Destroy the VM after all test are done
cleanup(objs_list)
if vm_name:
vm = env.get_vm(vm_name)
if vm and vm.is_alive():
vm.destroy(gracefully=False)
if rmdir_cmd:
process.system(rmdir_cmd, ignore_status=True, shell=True)
if deluser_cmd:
process.system(deluser_cmd, ignore_status=True, shell=True)
if auth_conf and os.path.isfile(auth_conf):
os.unlink(auth_conf)
if polkit_pkla and os.path.isfile(polkit_pkla):
os.unlink(polkit_pkla)
def run(test, params, env):
"""
Test command: virsh set-user-password
The command set the user password inside the domain
1. Prepare test environment, start vm with guest agent
2. Perform virsh set-user-password operation(encrypted/ non-encrypted)
3. Login the vm with new/old password
4. Recover test environment
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
encrypted = params.get("encrypted", "no") == "yes"
option = params.get("option", "no") == "yes"
add_user = params.get("add_user", "no") == "yes"
set_user_name = params.get("set_user_name", "root")
status_error = params.get("status_error", "no")
err_domain = params.get("err_domain", "")
err_msg = params.get("err_msg", "")
start_ga = params.get("start_ga", "yes") == "yes"
ori_passwd = vm.params.get("password")
new_passwd = "a" + ori_passwd
passwd = new_passwd
# Back up domain XML
vmxml_bak = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
try:
vmxml = vmxml_bak.copy()
if start_ga:
# Start guest agent in vm
vm.prepare_guest_agent(prepare_xml=False, channel=False, start=True)
# Error test
if status_error == "yes":
if err_domain:
vm_name = err_domain
ret = virsh.set_user_password(vm_name, set_user_name, new_passwd,
encrypted=encrypted, option=option, debug=True)
libvirt.check_result(ret, err_msg)
# Normal test
else:
# Get guest ip address
session = vm.wait_for_login(timeout=30, username="******", password=ori_passwd)
vm_mac = vm.get_virsh_mac_address()
vm_ip = utils_net.get_guest_ip_addr(session, vm_mac)
# Add user
if add_user:
cmd = " rm -f /etc/gshadow.lock & useradd %s" % set_user_name
status, output = session.cmd_status_output(cmd)
if status:
test.error("Adding user '%s' got failed: '%s'" %
(set_user_name, output))
session.close()
# Set the user password in vm
if encrypted:
cmd = "openssl passwd -crypt %s" % new_passwd
ret = process.run(cmd, shell=True)
libvirt.check_exit_status(ret)
en_passwd = str(ret.stdout_text.strip())
passwd = en_passwd
ret = virsh.set_user_password(vm_name, set_user_name, passwd,
encrypted=encrypted, option=option, debug=True)
libvirt.check_exit_status(ret)
# Login with new password
try:
session = remote.wait_for_login("ssh", vm_ip, "22", set_user_name, new_passwd,
r"[\#\$]\s*$", timeout=30)
session.close()
except remote.LoginAuthenticationError, e:
logging.debug(e)
# Login with old password
try:
session = remote.wait_for_login("ssh", vm_ip, "22", set_user_name, ori_passwd,
r"[\#\$]\s*$", timeout=10)
session.close()
except remote.LoginAuthenticationError:
logging.debug("Login with old password failed as expected.")
# Change the password back in VM
ret = virsh.set_user_password(vm_name, set_user_name, ori_passwd, False,
option=option, debug=True)
libvirt.check_exit_status(ret)
# Login with the original password
try:
session = remote.wait_for_login("ssh", vm_ip, "22", set_user_name, ori_passwd,
r"[\#\$]\s*$", timeout=30)
session.close()
except remote.LoginAuthenticationError, e:
logging.debug(e)
if start_ga:
# Stop guest agent in vm
vm.prepare_guest_agent(prepare_xml=False, channel=False, start=False)
# Del user
if add_user:
session = vm.wait_for_login(timeout=30, username="******", password=ori_passwd)
cmd = "userdel -r %s" % set_user_name
status, output = session.cmd_status_output(cmd)
if status:
test.error("Deleting user '%s' got failed: '%s'" %
(set_user_name, output))
session.close()
except Exception, info:
raise exceptions.TestFail(info)
if obj_migration.RET_MIGRATION:
utils_test.check_dest_vm_network(vm, vm.get_address(),
server_ip, server_user,
server_pwd)
ret_migrate = True
else:
ret_migrate = False
if not asynch_migration:
ret_migrate = do_migration(delay, vm, dest_uri, options, extra)
dest_state = params.get("virsh_migrate_dest_state", "running")
if ret_migrate and dest_state == "running":
server_session = remote.wait_for_login('ssh', server_ip, '22',
server_user, server_pwd,
r"[\#\$]\s*$")
logging.info("Check VM network connectivity after migrating")
s_ping, o_ping = utils_test.ping(vm_ip, count=ping_count,
timeout=ping_timeout,
output_func=logging.debug,
session=server_session)
logging.info(o_ping)
if s_ping != 0:
server_session.close()
raise error.TestError("%s did not respond after %d sec."
% (vm.name, ping_timeout))
server_session.close()
if graphics_server:
logging.info("To check the process running '%s'.",
def run(test, params, env):
"""
Test remote access with TCP, TLS connection
"""
test_dict = dict(params)
vm_name = test_dict.get("main_vm")
status_error = test_dict.get("status_error", "no")
allowed_dn_str = params.get("tls_allowed_dn_list")
if allowed_dn_str:
allowed_dn_list = []
if not libvirt_version.version_compare(1, 0, 0):
# Reverse the order in the dn list to workaround the
# feature changes between RHEL 6 and RHEL 7
dn_list = allowed_dn_str.split(",")
dn_list.reverse()
allowed_dn_str = ','.join(dn_list)
allowed_dn_list.append(allowed_dn_str)
test_dict['tls_allowed_dn_list'] = allowed_dn_list
transport = test_dict.get("transport")
plus = test_dict.get("conn_plus", "+")
config_ipv6 = test_dict.get("config_ipv6", "no")
tls_port = test_dict.get("tls_port", "")
listen_addr = test_dict.get("listen_addr", "0.0.0.0")
ssh_port = test_dict.get("ssh_port", "")
tcp_port = test_dict.get("tcp_port", "")
server_ip = test_dict.get("server_ip")
server_user = test_dict.get("server_user")
server_pwd = test_dict.get("server_pwd")
no_any_config = params.get("no_any_config", "no")
sasl_user_pwd = test_dict.get("sasl_user_pwd")
sasl_allowed_users = test_dict.get("sasl_allowed_users")
server_cn = test_dict.get("server_cn")
custom_pki_path = test_dict.get("custom_pki_path")
rm_client_key_cmd = test_dict.get("remove_client_key_cmd")
rm_client_cert_cmd = test_dict.get("remove_client_cert_cmd")
ca_cn_new = test_dict.get("ca_cn_new")
no_verify = test_dict.get("no_verify", "no")
ipv6_addr_des = test_dict.get("ipv6_addr_des")
tls_sanity_cert = test_dict.get("tls_sanity_cert")
restart_libvirtd = test_dict.get("restart_libvirtd", "yes")
diff_virt_ver = test_dict.get("diff_virt_ver", "no")
driver = test_dict.get("test_driver", "qemu")
uri_path = test_dict.get("uri_path", "/system")
virsh_cmd = params.get("virsh_cmd", "list")
action = test_dict.get("libvirtd_action", "restart")
uri_user = test_dict.get("uri_user", "")
unix_sock_dir = test_dict.get("unix_sock_dir")
mkdir_cmd = test_dict.get("mkdir_cmd")
rmdir_cmd = test_dict.get("rmdir_cmd")
adduser_cmd = test_dict.get("adduser_cmd")
deluser_cmd = test_dict.get("deluser_cmd")
auth_conf = test_dict.get("auth_conf")
auth_conf_cxt = test_dict.get("auth_conf_cxt")
polkit_pkla = test_dict.get("polkit_pkla")
polkit_pkla_cxt = test_dict.get("polkit_pkla_cxt")
ssh_setup = test_dict.get("ssh_setup", "no")
tcp_setup = test_dict.get("tcp_setup", "no")
tls_setup = test_dict.get("tls_setup", "no")
unix_setup = test_dict.get("unix_setup", "no")
ssh_recovery = test_dict.get("ssh_auto_recovery", "yes")
tcp_recovery = test_dict.get("tcp_auto_recovery", "yes")
tls_recovery = test_dict.get("tls_auto_recovery", "yes")
unix_recovery = test_dict.get("unix_auto_recovery", "yes")
port = ""
# extra URI arguments
extra_params = ""
# it's used to clean up SSH, TLS, TCP, UNIX and SASL objs later
objs_list = []
# redirect LIBVIRT_DEBUG log into test log later
test_dict["logfile"] = test.logfile
# Make sure all of parameters are assigned a valid value
check_parameters(test_dict, test)
# only simply connect libvirt daemon then return
if no_any_config == "yes":
test_dict["uri"] = "%s%s%s://%s" % (driver, plus, transport, uri_path)
remote_access(test_dict, test)
return
# append extra 'pkipath' argument to URI if exists
if custom_pki_path:
extra_params = "?pkipath=%s" % custom_pki_path
# append extra 'no_verify' argument to URI if exists
if no_verify == "yes":
extra_params = "?no_verify=1"
# append extra 'socket' argument to URI if exists
if unix_sock_dir:
extra_params = "?socket=%s/libvirt-sock" % unix_sock_dir
# generate auth.conf and default under the '/etc/libvirt'
if auth_conf_cxt and auth_conf:
cmd = "echo -e '%s' > %s" % (auth_conf_cxt, auth_conf)
process.system(cmd, ignore_status=True, shell=True)
# generate polkit_pkla and default under the
# '/etc/polkit-1/localauthority/50-local.d/'
if polkit_pkla_cxt and polkit_pkla:
cmd = "echo -e '%s' > %s" % (polkit_pkla_cxt, polkit_pkla)
process.system(cmd, ignore_status=True, shell=True)
# generate remote IP
if config_ipv6 == "yes" and ipv6_addr_des:
remote_ip = "[%s]" % ipv6_addr_des
elif config_ipv6 != "yes" and server_cn:
remote_ip = server_cn
elif config_ipv6 != "yes" and ipv6_addr_des:
remote_ip = "[%s]" % ipv6_addr_des
elif server_ip and transport != "unix":
remote_ip = server_ip
else:
remote_ip = ""
# get URI port
if tcp_port != "":
port = ":" + tcp_port
if tls_port != "":
port = ":" + tls_port
if ssh_port != "" and not ipv6_addr_des:
port = ":" + ssh_port
# generate URI
uri = "%s%s%s://%s%s%s%s%s" % (driver, plus, transport, uri_user,
remote_ip, port, uri_path, extra_params)
test_dict["uri"] = uri
logging.debug("The final test dict:\n<%s>", test_dict)
if virsh_cmd == "start" and transport != "unix":
session = remote.wait_for_login("ssh", server_ip, "22", "root",
server_pwd, "#")
cmd = "virsh domstate %s" % vm_name
status, output = session.cmd_status_output(cmd)
if status:
session.close()
test.cancel(output)
session.close()
try:
# setup IPv6
if config_ipv6 == "yes":
ipv6_obj = IPv6Manager(test_dict)
objs_list.append(ipv6_obj)
ipv6_obj.setup()
# compare libvirt version if needs
if diff_virt_ver == "yes":
compare_virt_version(server_ip, server_user, server_pwd, test)
# setup SSH
if transport == "ssh" or ssh_setup == "yes":
if not test_dict.get("auth_pwd"):
ssh_obj = SSHConnection(test_dict)
if ssh_recovery == "yes":
objs_list.append(ssh_obj)
# setup test environment
ssh_obj.conn_setup()
# setup TLS
if transport == "tls" or tls_setup == "yes":
tls_obj = TLSConnection(test_dict)
if tls_recovery == "yes":
objs_list.append(tls_obj)
# reserve cert path
tmp_dir = tls_obj.tmp_dir
# setup test environment
if tls_sanity_cert == "no":
# only setup CA and client
tls_obj.conn_setup(False, True)
else:
# setup CA, server and client
tls_obj.conn_setup()
# setup TCP
if transport == "tcp" or tcp_setup == "yes":
tcp_obj = TCPConnection(test_dict)
if tcp_recovery == "yes":
objs_list.append(tcp_obj)
# setup test environment
tcp_obj.conn_setup()
# create a directory if needs
if mkdir_cmd:
process.system(mkdir_cmd, ignore_status=True, shell=True)
# setup UNIX
if transport == "unix" or unix_setup == "yes":
unix_obj = UNIXConnection(test_dict)
if unix_recovery == "yes":
objs_list.append(unix_obj)
# setup test environment
unix_obj.conn_setup()
# need to restart libvirt service for negative testing
if restart_libvirtd == "no":
remotely_control_libvirtd(server_ip, server_user, server_pwd,
action, status_error)
# check TCP/IP listening by service
if restart_libvirtd != "no" and transport != "unix":
service = 'libvirtd'
if transport == "ssh":
service = 'ssh'
check_listening_port_remote_by_service(server_ip, server_user,
server_pwd, service, port,
listen_addr)
# remove client certifications if exist, only for TLS negative testing
if rm_client_key_cmd:
process.system(rm_client_key_cmd, ignore_status=True, shell=True)
if rm_client_cert_cmd:
process.system(rm_client_cert_cmd, ignore_status=True, shell=True)
# add user to specific group
if adduser_cmd:
process.system(adduser_cmd, ignore_status=True, shell=True)
# change /etc/pki/libvirt/servercert.pem then
# restart libvirt service on the remote host
if tls_sanity_cert == "no" and ca_cn_new:
test_dict['ca_cn'] = ca_cn_new
test_dict['ca_cakey_path'] = tmp_dir
test_dict['scp_new_cacert'] = 'no'
tls_obj_new = TLSConnection(test_dict)
test_dict['tls_obj_new'] = tls_obj_new
# only setup new CA and server
tls_obj_new.conn_setup(True, False)
# setup SASL certification
# From libvirt-3.2.0, the default sasl change from
# DIGEST-MD5 to GSSAPI. "sasl_user" is discarded.
# More details: https://libvirt.org/auth.html#ACL_server_kerberos
if sasl_user_pwd and not libvirt_version.version_compare(3, 2, 0):
# covert string tuple and list to python data type
sasl_user_pwd = eval(sasl_user_pwd)
if sasl_allowed_users:
sasl_allowed_users = eval(sasl_allowed_users)
# create a sasl user
sasl_obj = SASL(test_dict)
objs_list.append(sasl_obj)
sasl_obj.setup()
for sasl_user, sasl_pwd in sasl_user_pwd:
# need't authentication if the auth.conf is configured by user
if not auth_conf:
test_dict["auth_user"] = sasl_user
test_dict["auth_pwd"] = sasl_pwd
logging.debug("sasl_user, sasl_pwd = "
"(%s, %s)", sasl_user, sasl_pwd)
if sasl_allowed_users and sasl_user not in sasl_allowed_users:
test_dict["status_error"] = "yes"
patterns_extra_dict = {"authentication name": sasl_user}
test_dict["patterns_extra_dict"] = patterns_extra_dict
remote_access(test_dict, test)
else:
remote_access(test_dict, test)
finally:
# recovery test environment
# Destroy the VM after all test are done
if vm_name:
vm = env.get_vm(vm_name)
if vm and vm.is_alive():
vm.destroy(gracefully=False)
if rmdir_cmd:
process.system(rmdir_cmd, ignore_status=True, shell=True)
if deluser_cmd:
process.system(deluser_cmd, ignore_status=True, shell=True)
if auth_conf and os.path.isfile(auth_conf):
os.unlink(auth_conf)
if polkit_pkla and os.path.isfile(polkit_pkla):
os.unlink(polkit_pkla)
cleanup(objs_list)
def run(test, params, env):
"""
Run Pktgen test between host/guest
1) Boot the main vm, or just grab it if it's already booted.
2) Configure pktgen server(only linux)
3) Run pktgen test, finish when timeout or env["pktgen_run"] != True
:param test: QEMU test object.
:param params: Dictionary with the test parameters.
:param env: Dictionary with test environment.
"""
login_timeout = float(params.get("login_timeout", 360))
error.context("Init the VM, and try to login", logging.info)
external_host = params.get("external_host")
if not external_host:
get_host_cmd = "ip route | awk '/default/ {print $3}'"
external_host = utils.system_output(get_host_cmd)
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
session = vm.wait_for_login(timeout=login_timeout)
error.context("Pktgen server environment prepare", logging.info)
# pktgen server only support linux, since pktgen is a linux kernel module
pktgen_server = params.get("pktgen_server", "localhost")
params_server = params.object_params("pktgen_server")
s_shell_client = params_server.get("shell_client", "ssh")
s_shell_port = params_server.get("shell_port", "22")
s_username = params_server.get("username", "root")
s_passwd = params_server.get("password", "123456")
s_shell_prompt = params_server.get("shell_prompt")
server_session = ""
# pktgen server is autotest virtual guest(only linux)
if pktgen_server in params.get("vms", "vm1 vm2"):
vm_pktgen = env.get_vm(pktgen_server)
vm_pktgen.verify_alive()
server_session = vm_pktgen.wait_for_login(timeout=login_timeout)
runner = server_session.cmd_output_safe
pktgen_ip = vm_pktgen.get_address()
pktgen_mac = vm_pktgen.get_mac_address()
server_interface = utils_net.get_linux_ifname(server_session, pktgen_mac)
# pktgen server is a external host assigned
elif re.match(r"((\d){1,3}\.){3}(\d){1,3}", pktgen_server):
pktgen_ip = pktgen_server
server_session = remote.wait_for_login(
s_shell_client, pktgen_ip, s_shell_port, s_username, s_passwd, s_shell_prompt
)
runner = server_session.cmd_output_safe
server_interface = params.get("server_interface")
if not server_interface:
raise error.TestNAError("Must config server interface before test")
else:
# using host as a pktgen server
server_interface = params.get("netdst", "switch")
host_nic = utils_net.Interface(server_interface)
pktgen_ip = host_nic.get_ip()
pktgen_mac = host_nic.get_mac()
runner = utils.system
# copy pktgen_test scipt to the test server.
local_path = os.path.join(data_dir.get_root_dir(), "shared/scripts/pktgen.sh")
remote_path = "/tmp/pktgen.sh"
remote.scp_to_remote(pktgen_ip, s_shell_port, s_username, s_passwd, local_path, remote_path)
error.context("Run pktgen test", logging.info)
run_threads = params.get("pktgen_threads", 1)
pktgen_stress_timeout = float(params.get("pktgen_test_timeout", 600))
exec_cmd = "%s %s %s %s %s" % (remote_path, vm.get_address(), vm.get_mac_address(), server_interface, run_threads)
try:
env["pktgen_run"] = True
try:
# Set a run flag in env, when other case call this case as a sub
# backgroud process, can set run flag to False to stop this case.
start_time = time.time()
stop_time = start_time + pktgen_stress_timeout
while env["pktgen_run"] and time.time() < stop_time:
runner(exec_cmd, timeout=pktgen_stress_timeout)
# using ping to kill the pktgen stress
except aexpect.ShellTimeoutError:
session.cmd("ping %s" % pktgen_ip, ignore_all_errors=True)
finally:
env["pktgen_run"] = False
error.context("Verify Host and guest kernel no error and call trace", logging.info)
vm.verify_kernel_crash()
utils_misc.verify_host_dmesg()
error.context("Ping external host after pktgen test", logging.info)
status, output = utils_test.ping(dest=external_host, session=session, timeout=240, count=20)
loss_ratio = utils_test.get_loss_ratio(output)
if loss_ratio > int(params.get("packet_lost_ratio", 5)) or loss_ratio == -1:
logging.debug("Ping %s output: %s" % (external_host, output))
raise error.TestFail("Guest network connction unusable," + "packet lost ratio is '%d%%'" % loss_ratio)
if server_session:
server_session.close()
if session:
session.close()
def setup_or_cleanup_iptables_rules(cls, rules, params=None,
cleanup=False):
"""
Setup or cleanup for iptable rules, it can be locally or remotely
:param rules: list of rules
:param params: dict with server details
:param cleanup: Boolean value, true to cleanup, false to setup
"""
commands = []
# check the existing iptables rules in remote or local machine
iptable_check_cmd = "iptables -S"
if params:
server_ip = params.get("server_ip")
server_user = params.get("server_user", "root")
server_pwd = params.get("server_pwd")
server_session = remote.wait_for_login('ssh', server_ip, '22',
server_user, server_pwd,
r"[\#\$]\s*$")
cmd_output = server_session.cmd_status_output(iptable_check_cmd)
if (cmd_output[0] == 0):
exist_rules = cmd_output[1].strip().split('\n')
else:
server_session.close()
raise exceptions.TestError("iptables fails for command "
"remotely %s" % iptable_check_cmd)
else:
try:
cmd_output = decode_to_text(process.system_output(iptable_check_cmd,
shell=True))
exist_rules = cmd_output.strip().split('\n')
except process.CmdError as info:
raise exceptions.TestError("iptables fails for command "
"locally %s" % iptable_check_cmd)
# check rules whether it is really needed to be added or cleaned
for rule in rules:
flag = False
for exist_rule in exist_rules:
if rule in exist_rule:
logging.debug("Rule: %s exist in iptables", rule)
flag = True
if cleanup:
logging.debug("cleaning rule: %s", rule)
commands.append("iptables -D %s" % rule)
if not flag and not cleanup:
logging.debug("Adding rule: %s", rule)
commands.append("iptables -I %s" % rule)
# Once rules are filtered, then it is executed in remote or local
# machine
for command in commands:
if params:
cmd_output = server_session.cmd_status_output(command)
if (cmd_output[0] != 0):
server_session.close()
raise exceptions.TestError("iptables command failed "
"remotely %s" % command)
else:
logging.debug("iptable command success %s", command)
else:
try:
cmd_output = decode_to_text(process.system_output(command, shell=True))
logging.debug("iptable command success %s", command)
except process.CmdError as info:
raise exceptions.TestError("iptables fails for command "
"locally %s" % command)
# cleanup server session
if params:
server_session.close()
def run(test, params, env):
"""
Test Boot OVMF Guest and Seabios Guest with options
Steps:
1) Edit VM xml with specified options
2) For secure boot mode, boot OVMF Guest from
cdrom first, enroll the key, then switch
boot from hd
3) For normal boot mode, directly boot Guest from given device
4) Verify if Guest can boot as expected
"""
vm_name = params.get("main_vm", "")
vm = env.get_vm(vm_name)
username = params.get("username", "root")
password = params.get("password", "redhat")
test_cmd = params.get("test_cmd", "")
check_point = params.get("checkpoint", "")
status_error = "yes" == params.get("status_error", "no")
boot_iso_file = os.path.join(data_dir.get_tmp_dir(), "boot.iso")
secure_boot_mode = (params.get("secure_boot_mode", "no") == "yes")
non_release_os_url = params.get("non_release_os_url", "")
download_file_path = os.path.join(data_dir.get_tmp_dir(), "non_released_os.qcow2")
uefi_iso = params.get("uefi_iso", "")
custom_codes = params.get("uefi_custom_codes", "")
uefi_target_dev = params.get("uefi_target_dev", "")
uefi_device_bus = params.get("uefi_device_bus", "")
with_boot = (params.get("with_boot", "no") == "yes")
boot_ref = params.get("boot_ref", "dev")
boot_order = params.get("boot_order", "1")
boot_dev = params.get("boot_dev", "hd")
target_dev = params.get("target_dev", "vdb")
vol_name = params.get("vol_name")
brick_path = os.path.join(test.virtdir, "gluster-pool")
# Prepare result checkpoint list
check_points = []
if check_point:
check_points.append(check_point)
# Back VM XML
vmxml_backup = vm_xml.VMXML.new_from_dumpxml(vm_name)
vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
try:
# Create /etc/ceph/ceph.conf file to suppress false warning error message.
process.run("mkdir -p /etc/ceph", ignore_status=True, shell=True)
cmd = ("echo 'mon_host = {0}' >/etc/ceph/ceph.conf"
.format(params.get("mon_host")))
process.run(cmd, ignore_status=True, shell=True)
setup_test_env(params, test)
apply_boot_options(vmxml, params)
blk_source = vm.get_first_disk_devices()['source']
set_domain_disk(vmxml, blk_source, params, test)
vmxml.remove_all_boots()
if with_boot and not secure_boot_mode:
boot_kwargs = {"boot_ref": boot_ref,
"boot_dev": boot_dev,
"boot_order": boot_order,
"target_dev": target_dev}
if "yes" == params.get("two_same_boot_dev", "no"):
boot_kwargs.update({"two_same_boot_dev": True})
set_boot_dev_or_boot_order(vmxml, **boot_kwargs)
if secure_boot_mode:
secure_boot_kwargs = {"uefi_iso": uefi_iso,
"uefi_target_dev": uefi_target_dev,
"uefi_device_bus": uefi_device_bus,
"uefi_custom_codes": custom_codes}
enable_secure_boot(vm, vmxml, test, **secure_boot_kwargs)
if not secure_boot_mode:
define_error = ("yes" == params.get("define_error", "no"))
enable_normal_boot(vmxml, check_points, define_error, test)
# Some negative cases failed at virsh.define
if define_error:
return
# Start VM and check result
# For boot from cdrom or non_released_os, just verify key words from serial console output
# For boot from disk image, run 'test cmd' to verify if OS boot well
if boot_dev == "cdrom" or non_release_os_url:
if not vm.is_alive():
vm.start()
check_prompt = params.get("check_prompt", "")
while True:
match, text = read_until_any_line_matches(
vm.serial_console,
[check_prompt],
timeout=30.0, internal_timeout=0.5,
custom_codes=custom_codes)
logging.debug("matches %s", check_prompt)
if match == -1:
logging.debug("Got check point as expected")
break
elif boot_dev == "hd":
ret = virsh.start(vm_name, timeout=60)
utlv.check_result(ret, expected_fails=check_points)
# For no boot options, further check if boot dev can be automatically added
if not with_boot:
if re.search(r"<boot dev='hd'/>", virsh.dumpxml(vm_name).stdout.strip()):
logging.debug("OS boot dev added automatically")
else:
test.fail("OS boot dev not added as expected")
if not status_error:
vm_ip = vm.wait_for_get_address(0, timeout=240)
remote_session = remote.wait_for_login("ssh", vm_ip, "22", username, password,
"[\#\$]\s*$")
if test_cmd:
status, output = remote_session.cmd_status_output(test_cmd)
logging.debug("CMD '%s' running result is:\n%s", test_cmd, output)
if status:
test.fail("Failed to boot %s from %s" % (vm_name, vmxml.xml))
remote_session.close()
logging.debug("Succeed to boot %s" % vm_name)
finally:
# Remove /etc/ceph/ceph.conf file if exists.
if os.path.exists('/etc/ceph/ceph.conf'):
os.remove('/etc/ceph/ceph.conf')
logging.debug("Start to cleanup")
if vm.is_alive:
vm.destroy()
logging.debug("Restore the VM XML")
vmxml_backup.sync(options="--nvram")
if cleanup_gluster:
process.run("umount /mnt", ignore_status=True, shell=True)
utlv.setup_or_cleanup_gluster(False, vol_name, brick_path)
if cleanup_iscsi:
utlv.setup_or_cleanup_iscsi(False)
if cleanup_iso_file:
process.run("rm -rf %s" % boot_iso_file, shell=True, ignore_status=True)
if cleanup_image_file:
process.run("rm -rf %s" % download_file_path, shell=True, ignore_status=True)
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_netperf(test, params, env):
"""
Network stress test with netperf.
1) Boot up VM(s), setup SSH authorization between host
and guest(s)/external host
2) Prepare the test environment in server/client/host
3) Execute netperf tests, collect and analyze the results
:param test: QEMU test object.
:param params: Dictionary with the test parameters.
:param env: Dictionary with test environment.
"""
def env_setup(session, ip, user, port, password):
error.context("Setup env for %s" % ip)
ssh_cmd(session, "iptables -F; true")
ssh_cmd(session, "service iptables stop; true")
ssh_cmd(session, "echo 1 > /proc/sys/net/ipv4/conf/all/arp_ignore")
download_link = params.get("netperf_download_link")
download_dir = data_dir.get_download_dir()
md5sum = params.get("pkg_md5sum")
pkg = utils.unmap_url_cache(download_dir, download_link, md5sum)
remote.scp_to_remote(ip, shell_port, username, password, pkg, "/tmp")
ssh_cmd(session, params.get("setup_cmd"))
agent_path = os.path.join(test.virtdir, "scripts/netperf_agent.py")
remote.scp_to_remote(ip, shell_port, username, password,
agent_path, "/tmp")
def _pin_vm_threads(vm, node):
if node:
if not isinstance(node, utils_misc.NumaNode):
node = utils_misc.NumaNode(int(node))
utils_test.qemu.pin_vm_threads(vm, node)
return node
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
login_timeout = int(params.get("login_timeout", 360))
session = vm.wait_for_login(timeout=login_timeout)
config_cmds = params.get("config_cmds")
if config_cmds:
for config_cmd in config_cmds.split(","):
cmd = params.get(config_cmd.strip())
if cmd:
s, o = session.cmd_status_output(cmd)
if s:
msg = "Config command %s failed. Output: %s" % (cmd, o)
raise error.TestError(msg)
if params.get("reboot_after_config", "yes") == "yes":
session = vm.reboot(session=session, timeout=login_timeout)
if params.get("rh_perf_envsetup_script"):
utils_test.service_setup(vm, session, test.virtdir)
session.close()
server_ip = vm.get_address()
server_ctl = vm.wait_for_login(timeout=login_timeout)
server_ctl_ip = server_ip
if (params.get("os_type") == "windows"
and params.get("use_cygwin") == "yes"):
cygwin_prompt = params.get("cygwin_prompt", r"\$\s+$")
cygwin_start = params.get("cygwin_start")
server_cyg = vm.wait_for_login(timeout=login_timeout)
server_cyg.set_prompt(cygwin_prompt)
server_cyg.cmd_output(cygwin_start)
else:
server_cyg = None
if len(params.get("nics", "").split()) > 1:
vm.wait_for_login(nic_index=1, timeout=login_timeout)
server_ip = vm.get_address(1)
logging.debug(commands.getoutput("numactl --hardware"))
logging.debug(commands.getoutput("numactl --show"))
# pin guest vcpus/memory/vhost threads to last numa node of host by default
numa_node = _pin_vm_threads(vm, params.get("numa_node"))
host = params.get("host", "localhost")
host_ip = host
if host != "localhost":
params_host = params.object_params("host")
host = remote.wait_for_login(params_host.get("shell_client"),
host_ip,
params_host.get("shell_port"),
params_host.get("username"),
params_host.get("password"),
params_host.get("shell_prompt"))
client = params.get("client", "localhost")
client_ip = client
clients = []
# client session 1 for control, session 2 for data communication
for i in range(2):
if client in params.get("vms"):
vm_client = env.get_vm(client)
tmp = vm_client.wait_for_login(timeout=login_timeout)
client_ip = vm_client.get_address()
elif client != "localhost":
tmp = remote.wait_for_login(params.get("shell_client_client"),
client_ip,
params.get("shell_port_client"),
params.get("username_client"),
params.get("password_client"),
params.get("shell_prompt_client"))
else:
tmp = "localhost"
clients.append(tmp)
client = clients[0]
vms_list = params["vms"].split()
if len(vms_list) > 1:
vm2 = env.get_vm(vms_list[-1])
vm2.verify_alive()
session2 = vm2.wait_for_login(timeout=login_timeout)
if params.get("rh_perf_envsetup_script"):
utils_test.service_setup(vm2, session2, test.virtdir)
client = vm2.wait_for_login(timeout=login_timeout)
client_ip = vm2.get_address()
session2.close()
_pin_vm_threads(vm2, numa_node)
error.context("Prepare env of server/client/host", logging.info)
prepare_list = set([server_ctl, client, host])
tag_dict = {server_ctl: "server", client: "client", host: "host"}
ip_dict = {server_ctl: server_ctl_ip, client: client_ip, host: host_ip}
for i in prepare_list:
params_tmp = params.object_params(tag_dict[i])
if params_tmp.get("os_type") == "linux":
shell_port = int(params_tmp["shell_port"])
password = params_tmp["password"]
username = params_tmp["username"]
env_setup(i, ip_dict[i], username, shell_port, password)
env.stop_tcpdump()
error.context("Start netperf testing", logging.info)
start_test(server_ip, server_ctl, host, clients, test.resultsdir,
l=int(params.get('l')),
sessions_rr=params.get('sessions_rr'),
sessions=params.get('sessions'),
sizes_rr=params.get('sizes_rr'),
sizes=params.get('sizes'),
protocols=params.get('protocols'),
ver_cmd=params.get('ver_cmd', "rpm -q qemu-kvm"),
netserver_port=params.get('netserver_port', "12865"),
params=params, server_cyg=server_cyg, test=test)
def run(test, params, env):
"""
Test command: virsh set-user-password
The command set the user password inside the domain
1. Prepare test environment, start vm with guest agent
2. Perform virsh set-user-password operation(encrypted/ non-encrypted)
3. Login the vm with new/old password
4. Recover test environment
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
encrypted = params.get("encrypted", "no") == "yes"
option = params.get("option", "no") == "yes"
add_user = params.get("add_user", "no") == "yes"
set_user_name = params.get("set_user_name", "root")
status_error = params.get("status_error", "no")
err_domain = params.get("err_domain", "")
err_msg = params.get("err_msg", "")
start_ga = params.get("start_ga", "yes") == "yes"
ori_passwd = vm.params.get("password")
new_passwd = "a" + ori_passwd
passwd = new_passwd
# Back up domain XML
vmxml_bak = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
try:
vmxml = vmxml_bak.copy()
if start_ga:
# Start guest agent in vm
vm.prepare_guest_agent(prepare_xml=False,
channel=False,
start=True)
# Error test
if status_error == "yes":
if err_domain:
vm_name = err_domain
ret = virsh.set_user_password(vm_name,
set_user_name,
new_passwd,
encrypted=encrypted,
option=option,
debug=True)
libvirt.check_result(ret, err_msg)
# Normal test
else:
# Get guest ip address
session = vm.wait_for_login(timeout=30,
username="******",
password=ori_passwd)
vm_mac = vm.get_virsh_mac_address()
vm_ip = utils_net.get_guest_ip_addr(session, vm_mac)
# Add user
if add_user:
cmd = " rm -f /etc/gshadow.lock & useradd %s" % set_user_name
status, output = session.cmd_status_output(cmd)
if status:
test.error("Adding user '%s' got failed: '%s'" %
(set_user_name, output))
session.close()
# Set the user password in vm
if encrypted:
cmd = "openssl passwd -crypt %s" % new_passwd
ret = process.run(cmd, shell=True)
libvirt.check_exit_status(ret)
en_passwd = str(ret.stdout_text.strip())
passwd = en_passwd
ret = virsh.set_user_password(vm_name,
set_user_name,
passwd,
encrypted=encrypted,
option=option,
debug=True)
libvirt.check_exit_status(ret)
# Login with new password
try:
session = remote.wait_for_login("ssh",
vm_ip,
"22",
set_user_name,
new_passwd,
r"[\#\$]\s*$",
timeout=30)
session.close()
except remote.LoginAuthenticationError, e:
logging.debug(e)
# Login with old password
try:
session = remote.wait_for_login("ssh",
vm_ip,
"22",
set_user_name,
ori_passwd,
r"[\#\$]\s*$",
timeout=10)
session.close()
except remote.LoginAuthenticationError:
logging.debug("Login with old password failed as expected.")
# Change the password back in VM
ret = virsh.set_user_password(vm_name,
set_user_name,
ori_passwd,
False,
option=option,
debug=True)
libvirt.check_exit_status(ret)
# Login with the original password
try:
session = remote.wait_for_login("ssh",
vm_ip,
"22",
set_user_name,
ori_passwd,
r"[\#\$]\s*$",
timeout=30)
session.close()
except remote.LoginAuthenticationError, e:
logging.debug(e)
if start_ga:
# Stop guest agent in vm
vm.prepare_guest_agent(prepare_xml=False,
channel=False,
start=False)
# Del user
if add_user:
session = vm.wait_for_login(timeout=30,
username="******",
password=ori_passwd)
cmd = "userdel -r %s" % set_user_name
status, output = session.cmd_status_output(cmd)
if status:
test.error("Deleting user '%s' got failed: '%s'" %
(set_user_name, output))
session.close()
def setup_or_cleanup_iptables_rules(cls, rules, params=None,
cleanup=False):
"""
Setup or cleanup for iptable rules, it can be locally or remotely
:param rules: list of rules
:param params: dict with server details
:param cleanup: Boolean value, true to cleanup, false to setup
"""
commands = []
# check the existing iptables rules in remote or local machine
iptable_check_cmd = "iptables -S"
if params:
server_ip = params.get("server_ip")
server_user = params.get("server_user", "root")
server_pwd = params.get("server_pwd")
server_session = remote.wait_for_login('ssh', server_ip, '22',
server_user, server_pwd,
r"[\#\$]\s*$")
cmd_output = server_session.cmd_status_output(iptable_check_cmd)
if (cmd_output[0] == 0):
exist_rules = cmd_output[1].strip().split('\n')
else:
server_session.close()
raise exceptions.TestError("iptables fails for command "
"remotely %s" % iptable_check_cmd)
else:
try:
cmd_output = process.run(iptable_check_cmd,
shell=True).stdout_text
exist_rules = cmd_output.strip().split('\n')
except process.CmdError as info:
raise exceptions.TestError("iptables fails for command "
"locally %s" % iptable_check_cmd)
# check rules whether it is really needed to be added or cleaned
for rule in rules:
flag = False
for exist_rule in exist_rules:
if rule in exist_rule:
logging.debug("Rule: %s exist in iptables", rule)
flag = True
if cleanup:
logging.debug("cleaning rule: %s", rule)
commands.append("iptables -D %s" % rule)
if not flag and not cleanup:
logging.debug("Adding rule: %s", rule)
commands.append("iptables -I %s" % rule)
# Once rules are filtered, then it is executed in remote or local
# machine
for command in commands:
if params:
cmd_output = server_session.cmd_status_output(command)
if (cmd_output[0] != 0):
server_session.close()
raise exceptions.TestError("iptables command failed "
"remotely %s" % command)
else:
logging.debug("iptable command success %s", command)
else:
try:
cmd_output = process.run(command, shell=True).stdout_text
logging.debug("iptable command success %s", command)
except process.CmdError as info:
raise exceptions.TestError("iptables fails for command "
"locally %s" % command)
# cleanup server session
if params:
server_session.close()
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 Boot OVMF Guest and Seabios Guest with options
Steps:
1) Edit VM xml with specified options
2) For secure boot mode, boot OVMF Guest from
cdrom first, enroll the key, then switch
boot from hd
3) For normal boot mode, directly boot Guest from given device
4) Verify if Guest can boot as expected
"""
vm_name = params.get("main_vm", "")
vm = env.get_vm(vm_name)
username = params.get("username", "root")
password = params.get("password", "redhat")
test_cmd = params.get("test_cmd", "")
expected_output = params.get("expected_output", "")
check_point = params.get("checkpoint", "")
status_error = "yes" == params.get("status_error", "no")
boot_iso_file = os.path.join(data_dir.get_tmp_dir(), "boot.iso")
non_release_os_url = params.get("non_release_os_url", "")
download_file_path = os.path.join(data_dir.get_tmp_dir(),
"non_released_os.qcow2")
release_os_url = params.get("release_os_url", "")
download_released_file_path = os.path.join(data_dir.get_tmp_dir(),
"released_os.qcow2")
uefi_iso = params.get("uefi_iso", "")
custom_codes = params.get("uefi_custom_codes", "")
uefi_target_dev = params.get("uefi_target_dev", "")
uefi_device_bus = params.get("uefi_device_bus", "")
with_boot = (params.get("with_boot", "no") == "yes")
boot_ref = params.get("boot_ref", "dev")
boot_order = params.get("boot_order", "1")
boot_dev = params.get("boot_dev", "hd")
target_dev = params.get("target_dev", "vdb")
vol_name = params.get("vol_name")
brick_path = os.path.join(test.virtdir, "gluster-pool")
boot_type = params.get("boot_type", "seabios")
boot_loadparm = params.get("boot_loadparm", None)
libvirt_version.is_libvirt_feature_supported(params)
# Prepare result checkpoint list
check_points = []
if check_point:
check_points.append(check_point)
# Back VM XML
vmxml_backup = vm_xml.VMXML.new_from_dumpxml(vm_name)
vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
# Prepare a blank params to confirm if delete the configure at the end of the test
ceph_cfg = ''
try:
# Create config file if it doesn't exist
ceph_cfg = ceph.create_config_file(params.get("mon_host"))
setup_test_env(params, test)
apply_boot_options(vmxml, params, test)
blk_source = vm.get_first_disk_devices()['source']
set_domain_disk(vmxml, blk_source, params, test)
vmxml.remove_all_boots()
if with_boot:
boot_kwargs = {
"boot_ref": boot_ref,
"boot_dev": boot_dev,
"boot_order": boot_order,
"target_dev": target_dev,
"loadparm": boot_loadparm
}
if "yes" == params.get("two_same_boot_dev", "no"):
boot_kwargs.update({"two_same_boot_dev": True})
set_boot_dev_or_boot_order(vmxml, **boot_kwargs)
define_error = ("yes" == params.get("define_error", "no"))
enable_normal_boot(vmxml, check_points, define_error, test)
# Some negative cases failed at virsh.define
if define_error:
return
# Start VM and check result
# For boot from cdrom or non_released_os, just verify key words from serial console output
# For boot from disk image, run 'test cmd' to verify if OS boot well
if boot_dev == "cdrom" or non_release_os_url:
if not vm.is_alive():
vm.start()
check_prompt = params.get("check_prompt", "")
while True:
if boot_type == "ovmf":
match, text = vm.serial_console.read_until_any_line_matches(
[check_prompt], timeout=30.0, internal_timeout=0.5)
else:
match, text = read_until_any_line_matches(
vm.serial_console, [check_prompt],
timeout=30.0,
internal_timeout=0.5)
logging.debug("matches %s", check_prompt)
if match == -1:
logging.debug("Got check point as expected")
break
elif boot_dev == "hd":
ret = virsh.start(vm_name, timeout=60)
utlv.check_result(ret, expected_fails=check_points)
# For no boot options, further check if boot dev can be automatically added
if not with_boot:
if re.search(r"<boot dev='hd'/>",
virsh.dumpxml(vm_name).stdout.strip()):
logging.debug("OS boot dev added automatically")
else:
test.fail("OS boot dev not added as expected")
if not status_error:
vm_ip = vm.wait_for_get_address(0, timeout=240)
remote_session = remote.wait_for_login("ssh", vm_ip, "22",
username, password,
r"[\#\$]\s*$")
if test_cmd:
status, output = remote_session.cmd_status_output(test_cmd)
logging.debug("CMD '%s' running result is:\n%s", test_cmd,
output)
if expected_output:
if not re.search(expected_output, output):
test.fail("Expected '%s' to match '%s'"
" but failed." %
(output, expected_output))
if status:
test.fail("Failed to boot %s from %s" %
(vm_name, vmxml.xml))
remote_session.close()
logging.debug("Succeed to boot %s" % vm_name)
finally:
# Remove ceph configure file if created.
if ceph_cfg:
os.remove(ceph_cfg)
logging.debug("Start to cleanup")
if vm.is_alive:
vm.destroy()
logging.debug("Restore the VM XML")
vmxml_backup.sync(options="--nvram")
if cleanup_gluster:
process.run("umount /mnt", ignore_status=True, shell=True)
gluster.setup_or_cleanup_gluster(False,
brick_path=brick_path,
**params)
if cleanup_iscsi:
utlv.setup_or_cleanup_iscsi(False)
if cleanup_iso_file:
process.run("rm -rf %s" % boot_iso_file,
shell=True,
ignore_status=True)
if cleanup_image_file:
process.run("rm -rf %s" % download_file_path,
shell=True,
ignore_status=True)
if cleanup_released_image_file:
process.run("rm -rf %s" % download_released_file_path,
shell=True,
ignore_status=True)
def run(test, params, env):
"""
Test Steps:
1. boot up guest with sndbuf=1048576 or other value.
2. Transfer file between host and guest.
3. Run netperf between host and guest.
4. During netperf testing, from an external host ping the host whitch
booting the guest.
Params:
:param test: QEMU test object.
:param params: Dictionary with the test parameters.
:param env: Dictionary with test environment.
"""
dst_ses = None
try:
error.context("Transfer file between host and guest", logging.info)
utils_test.run_file_transfer(test, params, env)
dsthost = params.get("dsthost")
login_timeout = int(params.get("login_timeout", 360))
if dsthost:
params_host = params.object_params("dsthost")
dst_ses = remote.wait_for_login(params_host.get("shell_client"),
dsthost,
params_host.get("shell_port"),
params_host.get("username"),
params_host.get("password"),
params_host.get("shell_prompt"),
timeout=login_timeout)
else:
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
dst_ses = vm.wait_for_login(timeout=login_timeout)
dsthost = vm.get_address()
bg_stress_test = params.get("background_stress_test", 'netperf_stress')
error.context("Run subtest %s between host and guest." % bg_stress_test,
logging.info)
s_thread = ""
wait_time = float(params.get("wait_bg_time", 60))
bg_stress_run_flag = params.get("bg_stress_run_flag")
env[bg_stress_run_flag] = False
stress_thread = utils.InterruptedThread(
utils_test.run_virt_sub_test, (test, params, env),
{"sub_type": bg_stress_test})
stress_thread.start()
if not utils_misc.wait_for(lambda: env.get(bg_stress_run_flag),
wait_time, 0, 1,
"Wait %s test start" % bg_stress_test):
err = "Fail to start netperf test between guest and host"
raise error.TestError(err)
ping_timeout = int(params.get("ping_timeout", 60))
host_ip = utils_net.get_host_ip_address(params)
txt = "Ping %s from %s during netperf testing" % (host_ip, dsthost)
error.context(txt, logging.info)
status, output = utils_test.ping(host_ip, session=dst_ses,
timeout=ping_timeout)
if status != 0:
raise error.TestFail("Ping returns non-zero value %s" % output)
package_lost = utils_test.get_loss_ratio(output)
package_lost_ratio = float(params.get("package_lost_ratio", 5))
txt = "%s%% packeage lost when ping %s from %s." % (package_lost,
host_ip,
dsthost)
if package_lost > package_lost_ratio:
raise error.TestFail(txt)
logging.info(txt)
finally:
try:
stress_thread.join(60)
except Exception:
pass
if dst_ses:
dst_ses.close()
def migrate_pre_setup(self,
desturi,
params,
cleanup=False,
ports='49152:49216'):
"""
# Setup before migration,
# 1. To enable migration ports using iptables
# 2. Turn off SMT for power8 machine in remote machine to migrate
:param desturi: uri of destination machine to which VM gets migrated
:param params: Test params dict
:param cleanup: if True revert back to default setting, used to cleanup
:param ports: ports used for allowing migration
"""
use_firewall_cmd = distro.detect().name != "Ubuntu"
iptables_func = utils_iptables.Iptables.setup_or_cleanup_iptables_rules
try:
utils_path.find_command("firewall-cmd")
except utils_path.CmdNotFoundError:
logging.debug("Using iptables for replacement")
use_firewall_cmd = False
if use_firewall_cmd:
port_to_add = ports
if ":" in ports:
port_to_add = "%s-%s" % (ports.split(":")[0],
ports.split(":")[1])
else:
rule = ["INPUT -p tcp -m tcp --dport %s -j ACCEPT" % ports]
try:
dest_ip = re.search(r'//.*/', desturi,
re.I).group(0).strip('/').strip()
source_ip = params.get("migrate_source_host", "").strip()
# check whether migrate back to source machine or not
if ((desturi == "qemu:///system") or (dest_ip == source_ip)):
if use_firewall_cmd:
firewall_cmd = utils_iptables.Firewall_cmd()
if cleanup:
firewall_cmd.remove_port(port_to_add,
'tcp',
permanent=True)
else:
firewall_cmd.add_port(port_to_add,
'tcp',
permanent=True)
# open migration ports in local machine using firewall_cmd
else:
# open migration ports in local machine using iptables
iptables_func(rule, cleanup=cleanup)
# SMT for Power8 machine is turned off for local machine during
# test setup
else:
server_ip = params.get("server_ip", params.get("remote_ip"))
server_user = params.get("server_user",
params.get("remote_user"))
server_pwd = params.get("server_pwd", params.get("remote_pwd"))
server_session = remote.wait_for_login('ssh', server_ip, '22',
server_user, server_pwd,
r"[\#\$]\s*$")
if use_firewall_cmd:
firewall_cmd = utils_iptables.Firewall_cmd(server_session)
# open migration ports in remote machine using firewall_cmd
if cleanup:
firewall_cmd.remove_port(port_to_add,
'tcp',
permanent=True)
else:
firewall_cmd.add_port(port_to_add,
'tcp',
permanent=True)
else:
# open migration ports in remote machine using iptables
iptables_func(rule, params=params, cleanup=cleanup)
cmd = "grep cpu /proc/cpuinfo | awk '{print $3}' | head -n 1"
# Check if remote machine is Power8, if so check for smt state
# and turn off if it is on.
cmd_output = server_session.cmd_status_output(cmd)
server_session.close()
if (cmd_output[0] == 0):
cmd_output = cmd_output[1].strip().upper()
if "POWER8" in cmd_output:
test_setup.switch_smt(state="off", params=params)
else:
raise exceptions.TestError(
"Failed to get cpuinfo of remote "
"server", cmd_output[1])
except AttributeError:
# Negative scenarios will have invalid desturi for which test should
# continue
pass
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)
