qemu.tests: refactor block mirror test with exist framework

The test add by commit 4436fb03c30317597848a7ea7e87577b90582aa9 and it
only support human monitors commands; This commit split sub-test in
this commit into two case and refactor it with exist test framework to
make it support both QMP monitor and  windows guest;
Signed-off-by: NXu Tian <xutian@redhat.com>

qemu/tests/block_mirror.py

-import os, logging, time
-from autotest.client.shared import utils, error
-from virttest import qemu_monitor, qemu_storage, storage, env_process, data_dir
-from virttest import utils_misc
-
-
-@error.context_aware
-def run_block_mirror(test, params, env):
-    """
-    Test block mirroring functionality
-
-    Test consists of two subtests:
-
-    1) Mirror the guest and switch to the mirrored one
-    2) Synchronize disk and then do continuous backup
-
-    "qemu-img compare" is used to verify disk is mirrored successfully.
-    """
-    image_name = params.get("image_name", "image")
-    image_format = params.get("image_format", "qcow2")
-    image_mirror = utils_misc.get_path(data_dir.get_data_dir(),
-                                       "%s-mirror.%s" % (image_name,
-                                           image_format))
-    block_mirror_cmd = params.get("block_mirror_cmd", "drive-mirror")
-    qemu_img = qemu_storage.QemuImg(params, data_dir.get_data_dir(),
-                                    "block-mirror")
-    source_images = params.get("source_images", "image1").split()
-    source_image = source_images[0]
-    _params = params.object_params(source_image)
-    speed = int(_params.get("default_speed", 0))
-    sync = _params.get("full_copy").lower()
-    if block_mirror_cmd.startswith("__"):
-        sync = (sync == "full")
-    mode = _params.get("create_mode", "absolute-paths")
-    format = _params.get("target_format", "qcow2")
-    check_event = _params.get("check_event")
-
-
-    def check_block_jobs_info(device_id):
-        """
-        Verify block-jobs status reported by monitor command info block-jobs.
-
-        @return: parsed output of info block-jobs
-        """
-        fail = 0
-        status = dict()
-        try:
-            status = vm.get_job_status(device_id)
-        except qemu_monitor.MonitorError, e:
-            logging.error(e)
-            fail += 1
-            return status
-        return status
-
-
-    def run_mirroring(vm, device, dest, sync, speed=0, foramt="qcow2",
-            mode="absolute-paths", complete = True):
-        """
-        Run block mirroring.
-
-        @param vm: Virtual machine object
-        @param device: Guest device that has to be mirrored
-        @param dest: Location image has to be mirrored into
-        @param speed: limited speed
-        @param format: target image format
-        @param mode: image create mode
-        @param complete: If True, mirroring will complete (switch to mirror),
-                         If False, finish image synchronization and keep
-                         mirroring running (any changes will be mirrored)
-        """
-        vm.block_mirror(device, dest, speed, sync, format, mode)
-        while True:
-            status = check_block_jobs_info(device)
-            if 'mirror' in status.get("type", ""):
-                logging.info("[(Completed bytes): %s (Total bytes): %s "
-                             "(Speed limit in bytes/s): %s]", status["offset"],
-                             status["len"], status["speed"])
-                if status["offset"] != int(status["len"]):
-                    time.sleep(10)
-                    continue
-                elif vm.monitor.protocol == "qmp" and check_event == "yes":
-                    if vm.monitor.get_event("BLOCK_JOB_READY") is None:
-                        continue
-                else:
-                    logging.info("Target synchronized with source")
-                    if complete:
-                        logging.info("Start mirroring completing")
-                        vm.pause()
-                        vm.block_reopen(device, dest, format)
-                        time.sleep(5)
-                    else:
-                        break
-            elif not status:
-                logging.info("Block job completed")
-                break
-
-    try:
-        # Setup phase
-        vm_name = params['main_vm']
-        env_process.preprocess_vm(test, params, env, vm_name)
-        vm = env.get_vm(vm_name)
-        vm.create()
-
-        timeout = int(params.get("login_timeout", 360))
-        session = vm.wait_for_login(timeout=timeout)
-        img_path = storage.get_image_filename(params, data_dir.get_data_dir())
-        device_id = vm.get_block({"file": img_path})
-
-
-        # Subtest 1 - Complete mirroring
-        error.context("Testing complete mirroring")
-        run_mirroring(vm, device_id, image_mirror, sync, speed, format, mode)
-        _device_id = vm.get_block({"file": image_mirror})
-        if device_id != _device_id:
-            raise error.TestError("Mirrored image not being used by guest")
-        error.context("Compare fully mirrored images")
-        qemu_img.compare_images(img_path, image_mirror)
-        vm.destroy()
-
-        # Subtest 2 - Continuous backup
-        error.context("Testing continuous backup")
-        vm.create()
-        session = vm.wait_for_login(timeout=timeout)
-        run_mirroring(vm, device_id, image_mirror, sync,
-                      speed, format, mode, False)
-        for fn in range(0,128):
-            session.cmd("dd bs=1024 count=1024 if=/dev/urandom of=tmp%d.file"
-                        % fn)
-        time.sleep(10)
-        vm.pause()
-        time.sleep(5)
-        error.context("Compare original and backup images")
-        qemu_img.compare_images(img_path, image_mirror)
-        vm.destroy()
-
-    finally:
-        if os.path.isfile(image_mirror):
-            os.remove(image_mirror)

qemu/tests/cfg/drive_mirror.cfg

@@ -30,7 +30,7 @@
     target_image_image1 = "/tmp/target1"
     check_event = no
     variants:
-        - simple:
+        - simple_test:
             type = drive_mirror_simple
             repeat_times = 3
             cancel_timeout = 3
@@ -50,7 +50,13 @@
                     default_speed_image1 = 3M
                     max_speed_image1 = 10M
                 - mirroring:
-                    type = block_mirror
+                    variants:
+                        - block_job_complete:
+                           type = drive_mirror_complete
+                        - continuous_backup:
+                           type = drive_mirror_continuous_backup
+                           clean_cmd = "rm -f tmp*.file"
+                           dd_cmd = "dd if=/dev/zero bs=1024 count=1024 of=tmp%s.file"
         - with_stress:
             type = drive_mirror_stress
             reopen_timeout = 360

qemu/tests/drive_mirror_complete.py

+import logging, time
+from autotest.client.shared import error
+from virttest import qemu_storage, data_dir
+from qemu.tests import drive_mirror
+
+@error.context_aware
+def run_drive_mirror_complete(test, params, env):
+    """
+    Test block mirroring functionality
+
+    1) Mirror the guest and switch to the mirrored one
+
+    "qemu-img compare" is used to verify disk is mirrored successfully.
+    """
+    tag = params.get("source_images", "image1")
+    qemu_img = qemu_storage.QemuImg(params, data_dir.get_data_dir(), tag)
+    mirror_test = drive_mirror.DriveMirror(test, params, env, tag)
+    try:
+        source_image = mirror_test.get_image_file()
+        target_image = mirror_test.get_target_image()
+        mirror_test.start()
+        mirror_test.wait_for_steady()
+        mirror_test.vm.pause()
+        mirror_test.reopen()
+        device_id = mirror_test.vm.get_block({"file": target_image})
+        if device_id != mirror_test.device:
+            raise error.TestError("Mirrored image not being used by guest")
+        time.sleep(5)
+        error.context("Compare fully mirrored images", logging.info)
+        qemu_img.compare_images(source_image, target_image)
+        mirror_test.vm.destroy()
+    finally:
+        mirror_test.clean()

qemu/tests/drive_mirror_continuous_backup.py

+import logging, time
+from autotest.client.shared import error
+from virttest import qemu_storage, data_dir
+from qemu.tests import drive_mirror
+
+@error.context_aware
+def run_drive_mirror_continuous_backup(test, params, env):
+    """
+    1) Synchronize disk and then do continuous backup
+
+    "qemu-img compare" is used to verify disk is mirrored successfully.
+    """
+    tag = params.get("source_images", "image1")
+    qemu_img = qemu_storage.QemuImg(params, data_dir.get_data_dir(), tag)
+    mirror_test = drive_mirror.DriveMirror(test, params, env, tag)
+    tmp_dir = params.get("tmp_dir", "c:\\")
+    clean_cmd = params.get("clean_cmd", "del /f /s /q tmp*.file")
+    dd_cmd = "dd if=/dev/zero bs=1024 count=1024 of=tmp%s.file"
+    dd_cmd = params.get("dd_cmd", dd_cmd)
+    try:
+        source_image = mirror_test.get_image_file()
+        target_image = mirror_test.get_target_image()
+        mirror_test.start()
+        mirror_test.wait_for_steady()
+        error.context("Testing continuous backup")
+        session = mirror_test.get_session()
+        session.cmd("cd %s" % tmp_dir)
+        for fn in range(0, 128):
+            session.cmd(dd_cmd % fn)
+        time.sleep(10)
+        mirror_test.vm.pause()
+        time.sleep(5)
+        error.context("Compare original and backup images", logging.info)
+        mirror_test.vm.resume()
+        session = mirror_test.get_session()
+        session.cmd(clean_cmd)
+        session.cmd("cd %s" % tmp_dir)
+        qemu_img.compare_images(source_image, target_image)
+        mirror_test.vm.destroy()
+    finally:
+        mirror_test.clean()