def add_bitmap(self):
self.bitmap_name = "bitmap_%s" % self.snapshot_tag
kargs = {
'bitmap_name': self.bitmap_name,
'target_device': self._top_device
}
block_bitmap.block_dirty_bitmap_add(self.main_vm, kargs)
def add_persistent_bitmap(self):
kargs = {
'bitmap_name': self._bitmaps[0],
'target_device': self._source_nodes[0],
'persistent': 'on'
}
block_dirty_bitmap_add(self.main_vm, kargs)
def run(test, params, env):
"""Bitmap test.
1. get target image and drive.
2. add bitmap.
3. check bitmap existence.
a) if existed, check after system_powerdown
:param test: vt test object
:param params: test parameters dictionary
:param env: test environment
"""
def check_bitmap_existence_as_expected(bitmaps, existence_param):
"""Check bitmaps' existence."""
bitmap_dict = block_dirty_bitmap.get_bitmaps(vm.monitor.info("block"))
logging.debug("bitmaps:\n%s", bitmap_dict)
msgs = []
for bitmap_params in bitmaps:
bitmap = bitmap_params.get("bitmap_name")
existence = bitmap_params.get(existence_param, "yes") == "yes"
if not block_dirty_bitmap.check_bitmap_existence(
bitmap_dict, bitmap_params, existence):
msg = "bitmap %s %s exists" % (bitmap,
"not" if existence else "")
msgs.append(msg)
if msgs:
test.fail("\n".join(msgs))
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
# wait till boot finishes
vm.wait_for_login(timeout=int(params.get("login_timeout", 360))).close()
bitmaps = block_dirty_bitmap.parse_params(vm, params)
error_context.context("add dirty bitmap")
for bitmap_params in bitmaps:
block_dirty_bitmap.block_dirty_bitmap_add(vm, bitmap_params)
error_context.context("check bitmap existence", logging.info)
check_bitmap_existence_as_expected(bitmaps, "existence")
error_context.context("system powerdown", logging.info)
vm.monitor.system_powerdown()
if not vm.wait_for_shutdown(int(params.get("shutdown_timeout", 360))):
test.fail("guest refuses to go down")
error_context.context("start vm", logging.info)
vm.create()
vm.verify_alive()
# wait till boot finishes
vm.wait_for_login(timeout=int(params.get("login_timeout", 360))).close()
error_context.context("check bitmap exsitence after shutdown",
logging.info)
check_bitmap_existence_as_expected(bitmaps, "existence_after_shutdown")
def merge_bitmap2_and_bitmap3_to_bitmap4(self):
"""merged bitmap2 and bitmap3 into bitmap4"""
source_bitmaps, target_bitmap = ["bitmap_2", "bitmap_3"], "bitmap_4"
args = {
"bitmap_name": target_bitmap,
"target_device": self.device,
"disabled": "on"}
block_dirty_bitmap.block_dirty_bitmap_add(self.vm, args)
block_dirty_bitmap.block_dirty_bitmap_merge(
self.vm, self.device, source_bitmaps, target_bitmap)
time.sleep(5)
def _handle_bitmaps(self, disabled_list, new_list, **extra):
for idx, bitmap in enumerate(disabled_list):
block_dirty_bitmap.block_dirty_bitmap_disable(
self.main_vm, self.source_images[idx], bitmap)
for idx, bitmap in enumerate(new_list):
bitmap_params = {}
bitmap_params['bitmap_name'] = bitmap
bitmap_params['target_device'] = self.source_images[idx]
bitmap_params['disabled'] = extra.pop('disabled', 'off')
block_dirty_bitmap.block_dirty_bitmap_add(self.main_vm,
bitmap_params)
merged_list = extra.pop('merged_list', [])
for idx, target in enumerate(merged_list):
src_list = [v[idx] for v in extra.values()]
block_dirty_bitmap.block_dirty_bitmap_merge(
self.main_vm, self.source_images[idx], src_list, target)
def add_bitmaps(self):
args = {'target_device': self._source_nodes[0], 'persistent': 'on'}
if self._granularities:
for granularity in self._granularities:
g = int(normalize_data_size(granularity, "B"))
args.update({
'bitmap_name': 'bitmap_%s' % g,
'bitmap_granularity': g
})
block_dirty_bitmap_add(self.main_vm, args)
else:
max_len = self.params.get_numeric('max_bitmap_name_len')
for i in range(self.params.get_numeric('bitmap_count')):
l = max_len - len(str(i))
args['bitmap_name'] = process.run(
self.params['create_bitmap_name_cmd'].format(length=l),
ignore_status=True,
shell=True).stdout.decode().strip() + str(i)
block_dirty_bitmap_add(self.main_vm, args)
def add_bitmap(self, node_name):
bitmap = "bitmap_%s" % node_name
kargs = {'bitmap_name': bitmap, 'target_device': node_name}
bitmap_handle.block_dirty_bitmap_add(self.main_vm, kargs)
self.bitmap_list.append(kargs)
def track_file3_with_bitmap5(self):
"""track file3 with bitmap5"""
args = {"bitmap_name": "bitmap_5", "target_device": self.device}
block_dirty_bitmap.block_dirty_bitmap_add(self.vm, args)
full_name = "%s/file3" % self.params.get("mount_point", "/mnt")
self.create_file(full_name)
def add_bitmap(self):
kargs = {
'bitmap_name': self._bitmaps[0],
'target_device': self._source_nodes[0]
}
block_dirty_bitmap_add(self.main_vm, kargs)
def add_one_bitmap(self):
args = {
'target_device': self._source_nodes[0],
'bitmap_name': self._merged_bitmaps[0]
}
block_dirty_bitmap_add(self.main_vm, args)
