def disable_bitmaps(self):
        for idx, bitmap in enumerate(self.bitmaps):
            # disable function has already checked if the bitmap was disabled
            block_dirty_bitmap.block_dirty_bitmap_disable(
                self.main_vm, self.source_images[idx], bitmap)

            # record the count of the bitmap
            info = block_dirty_bitmap.get_bitmap_by_name(
                self.main_vm, self.source_images[idx], bitmap)
            self.bitmap_counts[info['name']] = info['count']
예제 #2
0
def blockdev_backup(vm, source, target, **extra_options):
    cmd, arguments = blockdev_backup_qmp_cmd(source, target, **extra_options)
    timeout = int(extra_options.pop("timeout", 600))
    if "bitmap" in arguments:
        info = block_bitmap.get_bitmap_by_name(vm, source, arguments["bitmap"])
        assert info, "Bitmap '%s' not exists in device '%s'" % (
            arguments["bitmap"], source)
        auto_disable_bitmap = extra_options.pop("auto_disable_bitmap", True)
        if auto_disable_bitmap and info.get("status") != "disabled":
            block_bitmap.block_dirty_bitmap_disable(vm, source,
                                                    arguments["bitmap"])
    vm.monitor.cmd(cmd, arguments)
    job_id = arguments.get("job-id", source)
    job_utils.wait_until_block_job_completed(vm, job_id, timeout)
예제 #3
0
def incremental_backup(vm, node, target, bitmap=None, wait=True):
    """
    Do incremental backup with bitmap

    :param vm: VM object
    :param node: device ID or node-name
    :param target: target device node-name or ID
    :param wait: wait for backup job finished or not
    """
    options = {"device": node, "target": target, "sync": "incremental"}
    if bitmap:
        options["bitmap"] = bitmap
        info = block_bitmap.get_bitmap_by_name(vm, node, bitmap)
        assert info, "Bitmap '%s' not exists in device '%s'" % (bitmap, node)
        if info["status"] != "disabled":
            block_bitmap.block_dirty_bitmap_disable(vm, node, bitmap)
    return blockdev_backup(vm, options, wait)
예제 #4
0
    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)
예제 #5
0
 def disable_bitmap(self):
     block_dirty_bitmap_disable(self.main_vm, self._source_nodes[0],
                                self._bitmaps[0])
예제 #6
0
 def disable_bitmaps(self):
     list(
         map(lambda n, b: block_dirty_bitmap_disable(self.main_vm, n, b),
             self._source_nodes, self._bitmaps))