def run(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) qemu_img.compare_images(source_image, target_image) mirror_test.vm.resume() session = mirror_test.get_session() session.cmd("cd %s" % tmp_dir) session.cmd(clean_cmd) mirror_test.vm.destroy() finally: mirror_test.clean()
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()
def run_drive_mirror_cancel(test, params, env): """ Test block mirroring functionality 1). boot vm then mirror $source_image to nfs/iscsi target 2). block nfs/iscsi serivce port via iptables rules 3). cancel block job and check it not cancel immedicatly 4). flush iptables chain then check job canceled in 10s """ tag = params.get("source_images", "image1") mirror_test = drive_mirror.DriveMirror(test, params, env, tag) try: mirror_test.start() error.context("Block network connection with iptables", logging.info) utils.run(params["start_firewall_cmd"]) bg = utils.InterruptedThread(mirror_test.cancel, ) bg.start() job = mirror_test.get_status() if job["type"] != "mirror": raise error.TestFail("Job cancel immediacatly") error.context("Cleanup rules in iptables", logging.info) utils.run(params["stop_firewall_cmd"]) bg.join(timeout=int(params["cancel_timeout"])) finally: mirror_test.vm.destroy() mirror_test.clean()
def run(test, params, env): """ drive_mirror_stress test: 1). guest installation 2). start mirror during guest installation 3). after installation complete, reboot guest verfiy guest reboot correctly. :param test: QEMU test object :param params: Dictionary with the test parameters :param env: Dictionary with test environment. """ args = (test, params, env) bg = utils_misc.InterruptedThread(utils_test.run_virt_sub_test, args, {"sub_type": "unattended_install"}) bg.start() utils_misc.wait_for(bg.is_alive, timeout=10) time.sleep(random.uniform(60, 200)) tag = params["source_image"] mirror_test = drive_mirror.DriveMirror(test, params, env, tag) mirror_test.trash_files.append(mirror_test.image_file) try: mirror_test.start() mirror_test.wait_for_steady() mirror_test.reopen() bg.join() finally: mirror_test.clean()
def run(test, params, env): """ Test block mirroring functionality 1). boot vm, then mirror $source_image to $target_image 2). wait for mirroring job go into ready status 3). pause vm after vm in ready status 4). reopen $target_image file 5). compare $source image and $target_image file 6). resume vm 7). boot vm from $target_image and check vm is alive if necessary "qemu-img compare" is used to verify disk is mirrored successfully. """ tag = params.get("source_image", "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.action_when_steady() mirror_test.vm.pause() mirror_test.reopen() mirror_test.action_after_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") error.context("Compare fully mirrored images", logging.info) qemu_img.compare_images(source_image, target_image, force_share=True) mirror_test.vm.resume() if params.get("boot_target_image", "no") == "yes": mirror_test.vm.destroy() params = params.object_params(tag) if params.get("image_type") == "iscsi": params["image_raw_device"] = "yes" env_process.preprocess_vm(test, params, env, params["main_vm"]) mirror_test = drive_mirror.DriveMirror(test, params, env, tag) mirror_test.verify_alive() finally: mirror_test.clean()
def run_drive_mirror_complete(test, params, env): """ Test block mirroring functionality 1). boot vm, then mirror $source_image to $target_image 2). wait for mirroring job go into ready status 3). compare $source image and $target_image file 4). reopen $target_image file if $open_target_image is 'yes' 5). boot vm from $target_image , and check guest alive "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() time.sleep(5) if params.get("open_target_image", "no") == "yes": 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") error.context("Compare fully mirrored images", logging.info) qemu_img.compare_images(source_image, target_image) mirror_test.vm.resume() mirror_test.vm.destroy() if params.get("boot_target_image", "no") == "yes": params = params.object_params(tag) if params.get("target_image_type") == "iscsi": params["image_name"] = mirror_test.target_image params["image_raw_device"] = "yes" else: params["image_name"] = params["target_image"] params["image_format"] = params["target_format"] env_process.preprocess_vm(test, params, env, params["main_vm"]) vm = env.get_vm(params["main_vm"]) timeout = int(params.get("login_timeout", 600)) session = vm.wait_for_login(timeout=timeout) session.cmd(params.get("alive_check_cmd", "dir"), timeout=120) session.close() vm.destroy() finally: mirror_test.clean()
def run_drive_mirror_reboot(test, params, env): """ drive_mirror_reboot test: 1). boot guest, do system_reset 2). start mirroring, wait go into steady status 3). reopen new image then reboot guest 4). check guest alive @param test: QEMU test object @param params: Dictionary with the test parameters @param env: Dictionary with test environment. """ tag = params.get("source_images", "image1") reboot_test = drive_mirror.DriveMirror(test, params, env, tag) try: reboot_test.reboot("system_reset", False) reboot_test.start() reboot_test.action_when_steady() reboot_test.action_after_reopen() finally: reboot_test.clean()