def run(test, params, env):
"""
Test migration under stress.
"""
vm_names = params.get("vms").split()
if len(vm_names) < 2:
test.cancel("Provide enough vms for migration")
src_uri = "qemu:///system"
dest_uri = libvirt_vm.complete_uri(params.get("migrate_dest_host",
"EXAMPLE"))
if dest_uri.count('///') or dest_uri.count('EXAMPLE'):
test.cancel("The dest_uri '%s' is invalid" % dest_uri)
# Migrated vms' instance
vms = env.get_all_vms()
params["load_vms"] = list(vms)
cpu = int(params.get("smp", 1))
memory = int(params.get("mem")) * 1024
stress_tool = params.get("stress_tool", "")
remote_stress = params.get("migration_stress_remote", "no") == "yes"
host_stress = params.get("migration_stress_host", "no") == "yes"
vms_stress = params.get("migration_stress_vms", "no") == "yes"
vm_bytes = params.get("stress_vm_bytes", "128M")
stress_args = params.get("%s_args" % stress_tool)
migration_type = params.get("migration_type")
start_migration_vms = params.get("start_migration_vms", "yes") == "yes"
thread_timeout = int(params.get("thread_timeout", 120))
ubuntu_dep = ['build-essential', 'git']
hstress = rstress = None
vstress = {}
# Set vm_bytes for start_cmd
mem_total = utils_memory.memtotal()
vm_reserved = len(vms) * memory
if vm_bytes == "half":
vm_bytes = (mem_total - vm_reserved) / 2
elif vm_bytes == "shortage":
vm_bytes = mem_total - vm_reserved + 524288
if "vm-bytes" in stress_args:
params["%s_args" % stress_tool] = stress_args % vm_bytes
# Ensure stress tool is available in host
if host_stress:
# remove package manager installed tool to avoid conflict
if not utils_package.package_remove(stress_tool):
logging.error("Existing %s is not removed")
if "stress-ng" in stress_tool and 'Ubuntu' in utils_misc.get_distro():
params['stress-ng_dependency_packages_list'] = ubuntu_dep
try:
hstress = utils_test.HostStress(stress_tool, params)
hstress.load_stress_tool()
except utils_test.StressError, info:
test.error(info)
def run(test, params, env):
"""
Test vm time according timer management of XML configuration.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
vmxml_backup = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
# Backup host timezone in the same dir
process.run("ln --backup /etc/localtime /etc/localtime.bk", shell=True)
timer_test_type = params.get("timer_test_type")
testcase = globals()[timer_test_type]
try:
# run the test
testcase(test, vm, params)
finally:
vm.destroy()
vmxml_backup.sync()
os.rename("/etc/localtime.bk", '/etc/localtime')
if params.get("operation") == "stress_on_host":
utils_test.HostStress(params, "stress").unload_stress()
def _prepare_test_environment():
"""
Prepare the test tools, such as hv_tlbflush & stress
return: a running HostStress object
"""
copy_tlbflush_cmd = params["copy_tlbflush_cmd"]
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
session = vm.wait_for_login(timeout=timeout)
logging.info("Copy tlbflush tool related files")
for f in tlbflush_filenames:
copy_file_cmd = utils_misc.set_winutils_letter(
session, copy_tlbflush_cmd % f)
session.cmd(copy_file_cmd)
logging.info("Create a large file for test")
create_test_file_cmd = params["create_test_file_cmd"]
test_file_size = params["test_file_size"]
test_file_size = utils_numeric.normalize_data_size(test_file_size,
order_magnitude="B")
session.cmd(create_test_file_cmd % test_file_size)
vm.graceful_shutdown(timeout=timeout)
stress_type = params.get("stress_type", "stress")
stress_pkg_name = params.get("stress_pkg_name", "stress-1.0.4.tar.gz")
stress_root_dir = data_dir.get_deps_dir("stress")
downloaded_file_path = os.path.join(stress_root_dir, stress_pkg_name)
host_cpu_count = cpu.total_cpus_count()
host_stress = utils_test.HostStress(
stress_type,
params,
download_type="tarball",
downloaded_file_path=downloaded_file_path,
stress_args="--cpu %s > /dev/null 2>&1& " % host_cpu_count)
return host_stress
def run(test, params, env):
"""
Timer device boot guest:
1) Check host clock's sync status with chronyd
2) Add some load on host (Optional)
3) Boot the guest with specific clock source
4) Check the clock source currently used on guest
5) Do some file operation on guest (Optional)
6) Check the system time on guest and host (Optional)
7) Check the hardware time on guest (linux only)
8) Sleep period of time before reboot (Optional)
9) Reboot guest (Optional)
10) Check the system time on guest and host (Optional)
11) Check the hardware time on guest (Optional)
12) Restore guest's clock source
:param test: QEMU test object.
:param params: Dictionary with test parameters.
:param env: Dictionary with the test environment.
"""
def get_hwtime(session):
"""
Get guest's hardware clock.
:param session: VM session.
"""
hwclock_time_command = params.get("hwclock_time_command", "hwclock -u")
hwclock_time_filter_re = params.get("hwclock_time_filter_re",
r"(\d+-\d+-\d+ \d+:\d+:\d+)")
hwclock_time_format = params.get("hwclock_time_format",
"%Y-%m-%d %H:%M:%S")
output = session.cmd_output_safe(hwclock_time_command)
try:
str_time = re.findall(hwclock_time_filter_re, output)[0]
guest_time = time.mktime(
time.strptime(str_time, hwclock_time_format))
except Exception as err:
test.log.debug("(time_format, time_string): (%s, %s)",
hwclock_time_format, str_time)
raise err
return guest_time
def verify_timedrift(session, is_hardware=False):
"""
Verify timedrift between host and guest.
:param session: VM session.
:param is_hardware: if need to verify guest's hardware time.
"""
# Command to run to get the current time
time_command = params["time_command"]
# Filter which should match a string to be passed to time.strptime()
time_filter_re = params["time_filter_re"]
# Time format for time.strptime()
time_format = params["time_format"]
timerdevice_drift_threshold = float(
params.get("timerdevice_drift_threshold", 3))
time_type = "system" if not is_hardware else "harware"
error_context.context("Check the %s time on guest" % time_type,
test.log.info)
host_time, guest_time = utils_test.get_time(session, time_command,
time_filter_re,
time_format)
if is_hardware:
guest_time = get_hwtime(session)
drift = abs(float(host_time) - float(guest_time))
if drift > timerdevice_drift_threshold:
test.fail("The guest's %s time is different with"
" host's system time. Host time: '%s', guest time:"
" '%s'" % (time_type, host_time, guest_time))
def get_current_clksrc(session):
cmd = "cat /sys/devices/system/clocksource/"
cmd += "clocksource0/current_clocksource"
current_clksrc = session.cmd_output_safe(cmd)
if "kvm-clock" in current_clksrc:
return "kvm-clock"
elif "tsc" in current_clksrc:
return "tsc"
elif "timebase" in current_clksrc:
return "timebase"
elif "acpi_pm" in current_clksrc:
return "acpi_pm"
return current_clksrc
def update_clksrc(session, clksrc):
"""
Update guest's clocksource, this func can work when not login
into guest with ssh.
:param session: VM session.
:param clksrc: expected guest's clocksource.
"""
avail_cmd = "cat /sys/devices/system/clocksource/clocksource0/"
avail_cmd += "available_clocksource"
avail_clksrc = session.cmd_output_safe(avail_cmd)
if clksrc in avail_clksrc:
clksrc_cmd = "echo %s > /sys/devices/system/clocksource/" % clksrc
clksrc_cmd += "clocksource0/current_clocksource"
status, output = session.cmd_status_output(clksrc_cmd)
if status:
test.fail(
"fail to update guest's clocksource to %s,"
"details: %s" % clksrc, output)
else:
test.error("please check the clocksource you want to set, "
"it's not supported by current guest, current "
"available clocksources: %s" % avail_clksrc)
error_context.context("sync host time with NTP server", test.log.info)
clock_sync_command = params["clock_sync_command"]
process.system(clock_sync_command, shell=True)
timerdevice_host_load_cmd = params.get("timerdevice_host_load_cmd")
if timerdevice_host_load_cmd:
error_context.context("Add some load on host", test.log.info)
host_cpu_cnt_cmd = params["host_cpu_cnt_cmd"]
host_cpu_cnt = int(
process.system_output(host_cpu_cnt_cmd, shell=True).strip())
if params["os_type"] == "linux":
timerdevice_host_load_cmd = timerdevice_host_load_cmd % host_cpu_cnt
process.system(timerdevice_host_load_cmd,
shell=True,
ignore_bg_processes=True)
else:
timerdevice_host_load_cmd = timerdevice_host_load_cmd % int(
host_cpu_cnt / 2)
stress_bg = utils_test.HostStress(
"stress", params, stress_args=timerdevice_host_load_cmd)
stress_bg.load_stress_tool()
host_load_stop_cmd = params.get("timerdevice_host_load_stop_cmd",
"pkill -f 'do X=1'")
funcatexit.register(env, params["type"], _system, host_load_stop_cmd)
params["start_vm"] = "yes"
env_process.preprocess_vm(test, params, env, params.get("main_vm"))
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
error_context.context("Sync guest timezone before test", test.log.info)
timeout = int(params.get("login_timeout", 360))
if params["os_type"] == 'linux':
utils_time.sync_timezone_linux(vm, timeout)
else:
utils_time.sync_timezone_win(vm, timeout)
session = vm.wait_for_serial_login(timeout=timeout)
timerdevice_clksource = params.get("timerdevice_clksource")
need_restore_clksrc = False
if timerdevice_clksource:
origin_clksrc = get_current_clksrc(session)
test.log.info("guest is booted with %s", origin_clksrc)
if timerdevice_clksource != origin_clksrc:
update_clksrc(session, timerdevice_clksource)
need_restore_clksrc = True
error_context.context("check timedrift between guest and host.",
test.log.info)
verify_timedrift(session)
if params["os_type"] == "linux":
verify_timedrift(session, is_hardware=True)
repeat_nums = params.get_numeric("repeat_nums")
if repeat_nums:
sleep_time = params["sleep_time"]
for index in range(repeat_nums):
time.sleep(int(sleep_time))
verify_timedrift(session)
if params["os_type"] == "linux":
verify_timedrift(session, is_hardware=True)
if params.get("timerdevice_reboot_test") == "yes":
sleep_time = params.get("timerdevice_sleep_time")
if sleep_time:
error_context.context("Sleep '%s' secs before reboot" % sleep_time,
test.log.info)
sleep_time = int(sleep_time)
time.sleep(sleep_time)
error_context.context(
"Check timedrift between guest and host "
"after reboot.", test.log.info)
vm.reboot(timeout=timeout, serial=True)
verify_timedrift(session)
if params["os_type"] == "linux":
verify_timedrift(session, is_hardware=True)
if need_restore_clksrc:
update_clksrc(session, origin_clksrc)
session.close()
def run(test, params, env):
"""
Test migration under stress.
"""
vm_names = params.get("vms").split()
if len(vm_names) < 2:
test.cancel("Provide enough vms for migration")
src_uri = "qemu:///system"
dest_uri = libvirt_vm.complete_uri(
params.get("migrate_dest_host", "EXAMPLE"))
if dest_uri.count('///') or dest_uri.count('EXAMPLE'):
test.cancel("The dest_uri '%s' is invalid" % dest_uri)
# Migrated vms' instance
vms = env.get_all_vms()
params["load_vms"] = list(vms)
cpu = int(params.get("smp", 1))
memory = int(params.get("mem")) * 1024
stress_tool = params.get("stress_tool", "")
remote_stress = params.get("migration_stress_remote", "no") == "yes"
host_stress = params.get("migration_stress_host", "no") == "yes"
vms_stress = params.get("migration_stress_vms", "no") == "yes"
vm_bytes = params.get("stress_vm_bytes", "128M")
stress_args = params.get("%s_args" % stress_tool)
migration_type = params.get("migration_type")
start_migration_vms = params.get("start_migration_vms", "yes") == "yes"
thread_timeout = int(params.get("thread_timeout", 120))
ubuntu_dep = ['build-essential', 'git']
hstress = rstress = None
vstress = {}
# Set vm_bytes for start_cmd
mem_total = utils_memory.memtotal()
vm_reserved = len(vms) * memory
if vm_bytes == "half":
vm_bytes = (mem_total - vm_reserved) / 2
elif vm_bytes == "shortage":
vm_bytes = mem_total - vm_reserved + 524288
if "vm-bytes" in stress_args:
params["%s_args" % stress_tool] = stress_args % vm_bytes
# Ensure stress tool is available in host
if host_stress:
# remove package manager installed tool to avoid conflict
if not utils_package.package_remove(stress_tool):
logging.error("Existing %s is not removed")
if "stress-ng" in stress_tool and 'Ubuntu' in utils_misc.get_distro():
params['stress-ng_dependency_packages_list'] = ubuntu_dep
try:
hstress = utils_test.HostStress(stress_tool, params)
hstress.load_stress_tool()
except utils_test.StressError as info:
test.error(info)
if remote_stress:
try:
server_ip = params['remote_ip']
server_pwd = params['remote_pwd']
server_user = params.get('remote_user', 'root')
remote_session = remote.wait_for_login('ssh', server_ip, '22',
server_user, server_pwd,
r"[\#\$]\s*$")
# remove package manager installed tool to avoid conflict
if not utils_package.package_remove(stress_tool,
session=remote_session):
logging.error("Existing %s is not removed")
if ("stess-ng" in stress_tool and 'Ubuntu'
in utils_misc.get_distro(session=remote_session)):
params['stress-ng_dependency_packages_list'] = ubuntu_dep
rstress = utils_test.HostStress(stress_tool,
params,
remote_server=True)
rstress.load_stress_tool()
remote_session.close()
except utils_test.StressError as info:
remote_session.close()
test.error(info)
for vm in vms:
# Keep vm dead for edit
if vm.is_alive():
vm.destroy()
set_cpu_memory(vm.name, cpu, memory)
try:
if start_migration_vms:
for vm in vms:
vm.start()
session = vm.wait_for_login()
# remove package manager installed tool to avoid conflict
if not utils_package.package_remove(stress_tool,
session=session):
logging.error("Existing %s is not removed")
# configure stress in VM
if vms_stress:
if ("stress-ng" in stress_tool and 'Ubuntu'
in utils_misc.get_distro(session=session)):
params[
'stress-ng_dependency_packages_list'] = ubuntu_dep
try:
vstress[vm.name] = utils_test.VMStress(
vm, stress_tool, params)
vstress[vm.name].load_stress_tool()
except utils_test.StressError as info:
session.close()
test.error(info)
session.close()
do_stress_migration(vms, src_uri, dest_uri, migration_type, test,
params, thread_timeout)
finally:
logging.debug("Cleanup vms...")
for vm in vms:
utils_test.libvirt.MigrationTest().cleanup_dest_vm(
vm, None, dest_uri)
# Try to start vms in source once vms in destination are
# cleaned up
if not vm.is_alive():
vm.start()
vm.wait_for_login()
try:
if vstress[vm.name]:
vstress[vm.name].unload_stress()
except KeyError:
continue
if rstress:
rstress.unload_stress()
if hstress:
hstress.unload_stress()
if remote_stress:
try:
server_ip = params['remote_ip']
server_pwd = params['remote_pwd']
server_user = params.get('remote_user', 'root')
remote_session = remote.wait_for_login('ssh', server_ip, '22', server_user,
server_pwd, r"[\#\$]\s*$")
# remove package manager installed tool to avoid conflict
if not utils_package.package_remove(stress_tool, session=remote_session):
logging.error("Existing %s is not removed")
if("stess-ng" in stress_tool and
'Ubuntu' in utils_misc.get_distro(session=remote_session)):
params['stress-ng_dependency_packages_list'] = ubuntu_dep
rstress = utils_test.HostStress(stress_tool, params, remote_server=True)
rstress.load_stress_tool()
remote_session.close()
except utils_test.StressError, info:
remote_session.close()
test.error(info)
for vm in vms:
# Keep vm dead for edit
if vm.is_alive():
vm.destroy()
set_cpu_memory(vm.name, cpu, memory)
try:
if start_migration_vms:
for vm in vms:
def unload_stress(stress_type, params):
"""Cleanup stress on host"""
if stress_type == "stress_on_host":
utils_test.HostStress(params, "stress").unload_stress()
