Merge pull request #670 from suqinhuang/verifier_context

Remove verifier log.info from test

generic/tests/cfg/iozone_windows.cfg

@@ -6,7 +6,6 @@
     disk_letter = "C"
     iozone_cmd = "WIN_UTILS:\Iozone\iozone.exe -azR -r 64k -n 1G -g 4G -M -b iozone.xls -f ${disk_letter}:\testfile"
     iozone_timeout = 7200
-    need_enable_verifier = yes
     post_result = yes
     mem = 2048
     variants:

generic/tests/iozone_windows.py

@@ -8,7 +8,6 @@ from virttest import postprocess_iozone
 from virttest import utils_misc
 from virttest import utils_test
 from virttest import error_context
-from virttest import funcatexit
 from avocado.core import exceptions
 
 
@@ -65,22 +64,12 @@ def run(test, params, env):
 
     vm = env.get_vm(params["main_vm"])
     vm.verify_alive()
-    session = vm.wait_for_login(timeout=timeout)
 
     driver_name = get_driver()
     if driver_name:
-        if params.get("need_enable_verifier", "no") == "yes":
-            error_context.context("Enable %s driver verifier" % driver_name,
-                                  logging.info)
-            try:
-                session = utils_test.qemu.setup_win_driver_verifier(
-                          session, driver_name, vm, timeout)
-                funcatexit.register(env, params.get("type"),
-                                    utils_test.qemu.clear_win_driver_verifier,
-                                    session, vm, timeout)
-            except Exception, e:
-                raise exceptions.TestFail(e)
+        utils_test.qemu.setup_win_driver_verifier(driver_name, vm, timeout)
 
+    session = vm.wait_for_login(timeout=timeout)
     if params.get("format_disk", "no") == "yes":
         error_context.context("Format disk", logging.info)
         utils_misc.format_windows_disk(session, disk_index,

qemu/tests/balloon_service.py

@@ -32,7 +32,6 @@ def run(test, params, env):
 
         :param session: VM session.
         """
-        volume_name = params["cdrom_virtio"]
         key = "VolumeName like 'virtio-win%'"
         try:
             return utils_misc.get_win_disk_vol(session,
@@ -47,23 +46,23 @@ def run(test, params, env):
         :param session: VM session.
         :param drive_letter: virtio-win disk volume letter.
         """
-        status_balloon_service = params["status_balloon_service"] % drive_letter
+        status_cmd = params["status_balloon_service"] % drive_letter
         logging.debug("Check balloon service status.")
-        output = session.cmd_output(status_balloon_service)
+        output = session.cmd_output(status_cmd)
         if re.search(r"running", output.lower(), re.M):
             logging.debug("Balloon service is already running !")
         elif re.search(r"stop", output.lower(), re.M):
             logging.debug("Run Balloon Service in guest.")
             try:
-                run_balloon_service = params["run_balloon_service"] % drive_letter
-                session.cmd(run_balloon_service)
+                start_cmd = params["run_balloon_service"] % drive_letter
+                session.cmd(start_cmd)
             except ShellCmdError:
-                raise exceptions.TestError("Run balloon service failed !")
+                raise exceptions.TestError("Start balloon service failed!")
         else:
             logging.debug("Install Balloon Service in guest.")
             try:
-                install_balloon_service = params["install_balloon_service"] % drive_letter
-                session.cmd(install_balloon_service)
+                install_cmd = params["install_balloon_service"] % drive_letter
+                session.cmd(install_cmd)
             except ShellCmdError:
                 raise exceptions.TestError("Install balloon service failed !")
 
@@ -75,25 +74,28 @@ def run(test, params, env):
         :param get_polling_output: output of get polling in qmp.
         :param keyname: key name of the output of the 'qom-get' property.
         """
-        error_context.context("Check whether memory status as expected",
-                              logging.info)
         check_mem_ratio = float(params.get("check_mem_ratio", 0.1))
+
+        error_context.context("Get memory from guest", logging.info)
         mem_base = MemoryBaseTest(test, params, env)
         if keyname == "stat-free-memory":
             guest_mem = mem_base.get_guest_free_mem(vm)
         elif keyname == "stat-total-memory":
             guest_mem = mem_base.get_vm_mem(vm)
 
+        error_context.context("Get memory from qmp", logging.info)
         stat_memory_qmp = get_polling_output['stats'][keyname]
         stat_memory_qmp = "%sB" % stat_memory_qmp
         stat_memory_qmp = int(float(utils_misc.normalize_data_size(
                                    (stat_memory_qmp), order_magnitude="M")))
+
+        error_context.context("Compare memory from guest with qmp",
+                              logging.info)
         if (abs(guest_mem - stat_memory_qmp)) > (guest_mem * check_mem_ratio):
             raise exceptions.TestFail("%s of guest %s is not equal to %s in"
-                                      " qmp, the ratio is %s" % (keyname,
-                                                                 guest_mem,
-                                                                 stat_memory_qmp,
-                                                                 check_mem_ratio))
+                                      " qmp, the acceptable ratio is %s" %
+                                      (keyname, guest_mem, stat_memory_qmp,
+                                       check_mem_ratio))
 
     def balloon_memory(session, device_path):
         """
@@ -114,8 +116,10 @@ def run(test, params, env):
                 min_sz, max_sz = balloon_test.get_memory_boundary(balloon_type)
                 expect_mem = int(random.uniform(min_sz, max_sz))
 
-                quit_after_test = balloon_test.run_ballooning_test(expect_mem, tag)
-                get_polling_output = vm.monitor.qom_get(device_path, get_balloon_property)
+                quit_after_test = balloon_test.run_ballooning_test(expect_mem,
+                                                                   tag)
+                get_polling_output = vm.monitor.qom_get(device_path,
+                                                        get_balloon_property)
                 memory_check(vm, get_polling_output, 'stat-free-memory')
                 if quit_after_test:
                     return
@@ -129,9 +133,8 @@ def run(test, params, env):
     error_context.context("Boot guest with balloon device", logging.info)
     vm = env.get_vm(params["main_vm"])
     vm.verify_alive()
-    session = vm.wait_for_login(timeout=timeout)
 
-    polling_sleep_time = int(params.get("polling_sleep_time", 20))
+    sleep_time = int(params.get("polling_sleep_time", 20))
     base_path = params.get("base_path", "/machine/peripheral/")
     device = params.get("balloon", "balloon0")
     device_path = os.path.join(base_path, device)
@@ -139,37 +142,27 @@ def run(test, params, env):
                                       "guest-stats-polling-interval")
     get_balloon_property = params.get("get_balloon_property", "guest-stats")
     polling_interval = int(params.get("polling_interval", 2))
-    drive_letter = get_disk_vol(session)
 
     try:
-        error_context.context("Enable %s driver verifier in guest" % driver_name,
-                              logging.info)
-        if params.get("need_enable_verifier", "yes") == "yes":
-            session = utils_test.qemu.setup_win_driver_verifier(session, driver_name,
-                                                                vm, timeout)
+        utils_test.qemu.setup_win_driver_verifier(driver_name, vm, timeout)
 
         error_context.context("Config balloon service in guest", logging.info)
+        session = vm.wait_for_login(timeout=timeout)
+        drive_letter = get_disk_vol(session)
         config_balloon_service(session, drive_letter)
 
         error_context.context("Enable polling in qemu", logging.info)
         vm.monitor.qom_set(device_path, set_balloon_property, polling_interval)
-        logging.debug("Sleep %ss to wait for the polling work" % polling_sleep_time)
-        time.sleep(polling_sleep_time)
-        get_polling_output = vm.monitor.qom_get(device_path, get_balloon_property)
+        time.sleep(sleep_time)
+        get_polling_output = vm.monitor.qom_get(device_path,
+                                                get_balloon_property)
         memory_check(vm, get_polling_output, 'stat-total-memory')
 
-        error_context.context("balloon vm memory in loop", logging.info)
+        error_context.context("Balloon vm memory in loop", logging.info)
         balloon_memory(session, device_path)
 
     finally:
         error_context.context("Clear balloon service in guest", logging.info)
-        uninstall_balloon_service = params["uninstall_balloon_service"] % drive_letter
-        session.cmd(uninstall_balloon_service, ignore_all_errors=True)
-
-        error_context.context("Clear balloon driver verifier in guest",
-                              logging.info)
-        if params.get("need_clear_verifier", "yes") == "yes":
-            session = utils_test.qemu.clear_win_driver_verifier(session, vm,
-                                                                timeout)
-        if session:
-            session.close()
+        uninstall_cmd = params["uninstall_balloon_service"] % drive_letter
+        session.cmd(uninstall_cmd, ignore_all_errors=True)
+        session.close()

qemu/tests/balloon_stress.py

@@ -36,12 +36,9 @@ def run(test, params, env):
         session.cmd(params.get("pre_cmd"))
 
     driver_name = params["driver_name"]
-    if params.get("need_enable_verifier", "yes") == "yes":
-        error.context("Enable %s driver verifier in guest" % driver_name,
-                      logging.info)
-        session = utils_test.qemu.setup_win_driver_verifier(session,
-                                                            driver_name,
-                                                            vm, timeout)
+    if params["os_type"] == "windows":
+        utils_test.qemu.setup_win_driver_verifier(driver_name, vm, timeout)
+    session = vm.wait_for_login(timeout=timeout)
 
     error.context("Play video in guest", logging.info)
     play_video_cmd = params["play_video_cmd"]
@@ -78,10 +75,3 @@ def run(test, params, env):
     error.context("verify guest still alive", logging.info)
     session.cmd(params["stop_player_cmd"])
     vm.verify_alive()
-
-    if params.get("need_clear_verifier", "yes") == "yes":
-        error.context("Clear %s driver verifier in guest" % driver_name,
-                      logging.info)
-        session = utils_test.qemu.clear_win_driver_verifier(session, vm, timeout)
-    if session:
-        session.close()

qemu/tests/block_resize.py

@@ -5,7 +5,6 @@ from autotest.client.shared import error
 
 from virttest import utils_misc
 from virttest import utils_test
-from virttest import funcatexit
 from virttest import storage
 from virttest import data_dir
 
@@ -57,20 +56,12 @@ def run(test, params, env):
     vm = env.get_vm(params["main_vm"])
     vm.verify_alive()
     timeout = float(params.get("login_timeout", 240))
-    session = vm.wait_for_login(timeout=timeout)
+    driver_name = params.get("driver_name")
 
-    if params.get("need_enable_verifier", "no") == "yes":
-        error.context("Enable %s driver verifier"
-                      % params["driver_name"], logging.info)
-        try:
-            session = utils_test.qemu.setup_win_driver_verifier(
-                      session, params["driver_name"], vm, timeout)
-            funcatexit.register(env, params.get("type"),
-                                utils_test.qemu.clear_win_driver_verifier,
-                                session, vm, timeout)
-        except Exception, e:
-            raise error.TestFail(e)
+    if params.get("os_type") == "windows":
+        utils_test.qemu.setup_win_driver_verifier(driver_name, vm, timeout)
 
+    session = vm.wait_for_login(timeout=timeout)
     data_image = params.get("images").split()[-1]
     data_image_params = params.object_params(data_image)
     data_image_size = data_image_params.get("image_size")

qemu/tests/cfg/balloon_service.cfg

@@ -9,8 +9,6 @@
     balloon_dev_devid = balloon0
     balloon_dev_add_bus = yes
     driver_name = "balloon"
-    need_enable_verifier = yes
-    need_clear_verifier = yes
     cdroms = "cd1 winutils virtio"
     drive_index_virtio = 3
     cdrom_virtio = isos/windows/virtio-win-1.8.0-4.iso

qemu/tests/cfg/balloon_stress.cfg

@@ -19,8 +19,6 @@
         play_video_cmd  = taskkill /IM wmplayer.exe /F & "${program_files}\Windows Media Player\wmplayer.exe"  "${video_url}"  /play /fullscreen
         check_playing_cmd = "tasklist|findstr /I wmplayer"
         driver_name = "balloon.sys"
-        need_enable_verifier = yes
-        need_clear_verifier = yes
         stop_player_cmd = "taskkill /IM wmplayer.exe /F"
         # reset media player play mode
         post_cmd += "reg add HKCU\Software\Microsoft\MediaPlayer\Preferences /v ModeLoop /t REG_DWORD /d 0 /f"

qemu/tests/cfg/block_resize.cfg

@@ -24,7 +24,6 @@
         format_disk = yes
         block_size_pattern = "1\s+(\d+)"
         accept_ratio = 0.005
-        need_enable_verifier = yes
         disk_update_cmd = "echo rescan > cmd"
         disk_update_cmd += " && echo select disk 1 >> cmd"
         disk_update_cmd += " && echo select partition 1 >> cmd"

qemu/tests/driver_in_use.py

@@ -22,18 +22,19 @@ def run(test, params, env):
     :param env: Dictionary with test environment.
     """
 
-    def check_bg_running(session, target_process):
+    def check_bg_running(target_process):
         """
         Check the backgroud test status in guest.
 
-        :param session: VM session.
         :param target_process: Background process running in guest.
         :return: return True if find the driver name;
                  else return False
         """
+        session = vm.wait_for_login()
         list_cmd = "wmic process where name='%s' list" % target_process
         output = session.cmd_output_safe(list_cmd, timeout=60)
         check_reg = re.compile(r"%s" % target_process, re.I | re.M)
+        session.close()
         return bool(check_reg.findall(output))
 
     def run_bg_stress_test(bg_stress_test):
@@ -57,8 +58,8 @@ def run(test, params, env):
             utils_test.run_virt_sub_test, (test, params, env),
             {"sub_type": bg_stress_test})
         stress_thread.start()
-        if not utils_misc.wait_for(lambda: check_bg_running(session,
-                                   target_process), 120, 0, 5):
+        if not utils_misc.wait_for(lambda: check_bg_running(target_process),
+                                   120, 0, 5):
             raise exceptions.TestFail("Backgroud test %s is not "
                                       "alive!" % bg_stress_test)
         if params.get("set_bg_stress_flag", "no") == "yes":
@@ -84,12 +85,8 @@ def run(test, params, env):
     vm = env.get_vm(params["main_vm"])
     vm.verify_alive()
     error_context.context("Boot guest with %s device" % driver, logging.info)
-    session = vm.wait_for_login(timeout=timeout)
 
-    error_context.context("Enable %s driver verifier in guest" % driver,
-                          logging.info)
-    session = utils_test.qemu.setup_win_driver_verifier(session,
-                                                        driver, vm, timeout)
+    utils_test.qemu.setup_win_driver_verifier(driver, vm, timeout)
 
     env["bg_status"] = 0
     run_bg_flag = params.get("run_bg_flag")
@@ -123,11 +120,5 @@ def run(test, params, env):
             run_subtest(sub_type)
 
     finally:
-        if vm.is_dead():
-            vm.create(params=params)
-        error_context.context("Clear %s driver verifier in guest" % driver,
-                              logging.info)
-        session = utils_test.qemu.clear_win_driver_verifier(session,
-                                                            vm, timeout)
-        if session:
-            session.close()
+        session.close()
+        utils_test.qemu.clear_win_driver_verifier(driver, vm, timeout)