def prepare_snapshot_file(self, snapshot_tags):
self.snapshot_images = list(map(self.get_image_by_tag, snapshot_tags))
params = self.params.copy()
params.setdefault("target_path", data_dir.get_data_dir())
for tag in snapshot_tags:
image = sp_admin.volume_define_by_params(tag, params)
image.hotplug(self.main_vm)
def prepare_snapshot_file(self):
self.trash = []
params = self.params.copy()
params.setdefault("target_path", data_dir.get_data_dir())
for snapshot_tag in self.snapshot_chain:
image = sp_admin.volume_define_by_params(snapshot_tag, params)
image.hotplug(self.main_vm)
self.trash.append(image)
def prepare_snapshot_file(self):
if self.is_blockdev_mode():
params = self.params.copy()
params.setdefault("target_path", data_dir.get_data_dir())
image = sp_admin.volume_define_by_params(self.snapshot_tag, params)
image.hotplug(self.main_vm)
else:
if self.params.get("mode") == "existing":
self.snapshot_image.create()
def create_image_with_data_file(vm, params, image_name):
"""
Create image with data_file
:param vm: vm object
:param params: params used to create data_file
:image_name: image that created on data_file_image
:return list: data_file image list
"""
image_list = []
image_params = params.object_params(image_name)
data_file_tag = image_params.get("image_data_file")
if data_file_tag:
data_file_image = sp_admin.volume_define_by_params(data_file_tag, params)
data_file_image.hotplug(vm)
image_list.append(data_file_image)
image = sp_admin.volume_define_by_params(image_name, params)
image.hotplug(vm)
image_list.append(image)
return image_list
def __target_disk_define_by_params(self, params, image_name):
if params.get("random_cluster_size") == "yes":
blacklist = list(map(int,
params.objects("cluster_size_blacklist")))
cluster_size = backup_utils.generate_random_cluster_size(blacklist)
params["image_cluster_size"] = cluster_size
logging.info("set target image cluster size to '%s'" %
cluster_size)
params.setdefault("target_path", data_dir.get_data_dir())
return sp_admin.volume_define_by_params(image_name, params)
def prepare_snapshot_file(self):
self.params["image_size_%s" % self.snapshot_tag] = self.base_image.size
self.params["image_name_%s" %
self.snapshot_tag] = 'images/' + self.snapshot_tag
snapshot_format = self.params.get("snapshot_format", "qcow2")
self.params["image_format_%s" % self.snapshot_tag] = snapshot_format
params = self.params.copy()
params.setdefault("target_path", data_dir.get_data_dir())
image = sp_admin.volume_define_by_params(self.snapshot_tag, params)
image.hotplug(self.main_vm)
return image
def prepare_snapshot_file(self):
for index in range(self.snapshot_num + 1):
snapshot_tag = "sn%s" % index
if snapshot_tag not in self.snapshot_chains:
self.snapshot_chains.append(snapshot_tag)
params = self.params.copy()
params.setdefault("target_path", data_dir.get_data_dir())
params["image_size_%s" % snapshot_tag] = self.base_image.size
params["image_name_%s" % snapshot_tag] = snapshot_tag
self.params["image_name_%s" % snapshot_tag] = snapshot_tag
snapshot_format = params.get("snapshot_format", "qcow2")
params["image_format_%s" % snapshot_tag] = snapshot_format
image = sp_admin.volume_define_by_params(snapshot_tag, params)
image.hotplug(self.main_vm)
def create_image_by_params(vm, params, image_name):
"""Create blockd device with vm by params"""
image = sp_admin.volume_define_by_params(image_name, params)
vm.verify_alive()
image.hotplug(vm)
return image
def _disk_define_by_params(self, tag):
params = self.params.copy()
params.setdefault("target_path", data_dir.get_data_dir())
return sp_admin.volume_define_by_params(tag, params)
def run(test, params, env):
"""
backup VM disk test:
1) start VM with data disk
2) create target disk with qmp command
3) full backup source disk to target disk with 65535 persistent bitmaps
4) shutdown VM
5) verify bitmap save to data disk
6) boot VM with data disk to check bitmaps with qmp cmd query-block
:param test: test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment.
"""
def full_backup(vm, source_node, target_node, bitmap_count):
"""start full backup job with 65535 bitmaps"""
logging.info("Begin full backup %s to %s" % (source_node, target_node))
actions, extra_options = [], {"sync": "full"}
cmd, args = backup_utils.blockdev_backup_qmp_cmd(
source_node, target_node, **extra_options)
backup_action = {"type": cmd, "data": args}
actions.append(backup_action)
bitmap_data = {"node": source_node, "persistent": True}
for idx in range(0, bitmap_count):
data = bitmap_data.copy()
data["name"] = "bitmap_%d" % idx
action = {"type": "block-dirty-bitmap-add", "data": data}
actions.append(action)
vm.monitor.cmd("transaction", {"actions": actions})
job_utils.wait_until_block_job_completed(vm, args["job-id"])
def verify_bitmap_counts(vm, source_node, bitmap_count):
"""Verify bitmap count after backup job is start"""
logging.info("Verify bitmap counts in device '%s'" % source_node)
out = vm.monitor.query("block")
bitmaps_dict = block_dirty_bitmap.get_bitmaps(out)
if source_node not in bitmaps_dict:
raise test.fail("device '%s' not found!" % source_node)
bitmap_len = len(bitmaps_dict[source_node])
msg = "bitmap count mismatch, %s != %s" % (bitmap_len, bitmap_count)
assert bitmap_len == bitmap_count, msg
def verify_persistent_bitmaps(params, image_name, bitmap_count):
"""Verify bitmap count by qemu-img command"""
logging.info("Verify bitmaps info save in image '%s'" % image_name)
image_dir = data_dir.get_data_dir()
image_params = params.object_params(image_name)
data_img = qemu_storage.QemuImg(image_params, image_dir, image_name)
output = data_img.info(output="json")
info = json.loads(output)
bitmap_len = len(info["format-specific"]["data"]["bitmaps"])
msg = "bitmap losts after destory VM, %s != %s" % (bitmap_len,
bitmap_count)
assert bitmap_len == bitmap_count, msg
source_image = params.get("source_image")
target_image = params.get("target_image")
source_node = "drive_%s" % source_image
target_node = "drive_%s" % target_image
bitmap_count = int(params.get("bitmap_count", 65535))
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
params.setdefault("target_path", data_dir.get_data_dir())
target_disk = sp_admin.volume_define_by_params(target_image, params)
target_disk.hotplug(vm)
full_backup(vm, source_node, target_node, bitmap_count)
verify_bitmap_counts(vm, source_node, bitmap_count)
vm.destroy()
verify_persistent_bitmaps(params, source_image, bitmap_count)
vm = env.get_vm(params["main_vm"])
vm.create()
vm.verify_alive()
verify_bitmap_counts(vm, source_node, bitmap_count)
def __target_disk_define_by_params(self, params, image_name):
params.setdefault("target_path", data_dir.get_data_dir())
return sp_admin.volume_define_by_params(image_name, params)
