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