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()