def wait_till_job_ready(self):
event = get_event_by_condition(self.main_vm,
'BLOCK_JOB_READY',
self.params.get_numeric(
'job_ready_timeout', 120),
device=self._jobs[0])
if event is None:
self.test.fail('Job failed to reach ready state')
def cancel_job(self):
self.main_vm.monitor.cmd("job-cancel", {'id': self._jobs[0]})
event = get_event_by_condition(self.main_vm,
'BLOCK_JOB_CANCELLED',
self.params.get_numeric(
'job_cancelled_timeout', 60),
device=self._jobs[0])
if event is None:
self.test.fail('Job failed to cancel')
def check_io_error_event(self):
event = get_event_by_condition(
self.main_vm, 'BLOCK_IO_ERROR',
self.params.get_numeric('event_timeout', 30))
if event:
if event['data'].get('reason') != self.params['error_msg']:
self.test.fail('Unexpected error')
else:
self.test.fail('Failed to get BLOCK_IO_ERROR event')
def check_no_space_error(self):
# check 'error' message in BLOCK_JOB_COMPLETED event
tmo = self.params.get_numeric('job_complete_timeout', 900)
event = get_event_by_condition(self.main_vm, BLOCK_JOB_COMPLETED_EVENT,
tmo)
if event:
if event['data'].get('error') != self.params['error_msg']:
self.test.fail('Unexpected error: %s' %
event['data'].get('error'))
else:
self.test.fail('Failed to get BLOCK_JOB_COMPLETED event')
def check_no_space_error(self):
tmo = self.params.get_numeric('job_completed_timeout', 360)
cond = {'device': self.inc_job_id}
event = get_event_by_condition(self.main_vm, BLOCK_JOB_COMPLETED_EVENT,
tmo, **cond)
if event:
if event['data'].get('error') != self.params['error_msg']:
self.test.fail('Unexpected error: %s' %
event['data'].get('error'))
else:
self.test.fail('Failed to get BLOCK_JOB_COMPLETED event')
def verify_job_status(self):
tmo = self.params.get_numeric('job_completed_timeout', 30)
# check offset/len in BLOCK_JOB_COMPLETED event
cond = {'device': self._job}
event = job_utils.get_event_by_condition(
self.main_vm, job_utils.BLOCK_JOB_COMPLETED_EVENT, tmo, **cond)
if event:
if event['data'].get('offset') != 0 or event['data'].get('len') != 0:
self.test.fail('offset and len should always be 0')
else:
self.test.fail('Failed to get BLOCK_JOB_COMPLETED event for %s'
% self._job)
def check_second_job_no_space_error(self):
"""
We always get the 'no enough space' error for the 2nd job
"""
tmo = self.params.get_numeric('job_completed_timeout', 360)
cond = {'device': self._job_ids[1]}
event = get_event_by_condition(self.main_vm, 'BLOCK_JOB_COMPLETED',
tmo, **cond)
if event:
if event['data'].get('error') != self.params['error_msg']:
self.test.fail('Unexpected error: %s' % event['data']['error'])
else:
self.test.fail('Failed to get BLOCK_JOB_COMPLETED event')
def check_no_space_error(self):
tmo = self.params.get_numeric('block_io_error_timeout', 60)
# check 'error' message in BLOCK_JOB_COMPLETED event
cond = {'device': self._job}
event = job_utils.get_event_by_condition(
self.main_vm, job_utils.BLOCK_JOB_COMPLETED_EVENT, tmo, **cond)
if event:
if event['data'].get('error') != self.params['error_msg']:
self.test.fail('Unexpected error: %s' %
event['data'].get('error'))
else:
self.test.fail('Failed to get BLOCK_JOB_COMPLETED event for %s' %
self._job)
def check_job_error_event(self):
"""
Check if BLOCK_JOB_ERROR can be received, then clear all
"""
tmo = self.params.get_numeric('job_error_timeout', 120)
event = job_utils.get_event_by_condition(
self.main_vm,
job_utils.BLOCK_JOB_ERROR_EVENT,
tmo,
device=self._job,
action='ignore')
if not event:
self.test.fail('Failed to get BLOCK_JOB_ERROR event for %s in %s' %
(self._job, tmo))
self.main_vm.monitor.clear_event(job_utils.BLOCK_JOB_ERROR_EVENT)
def wait_till_export_removed(self):
"""
When we remove an export with block-export-del, the export may still
stay around after this command returns, BLOCK_EXPORT_DELETED will be
emitted when a block export is removed and its id can be reused.
"""
if self._export_uid is not None:
cond = {'id': self._export_uid}
tmo = self._image_params.get_numeric('block_export_del_timeout',
60)
event = get_event_by_condition(self._vm, 'BLOCK_EXPORT_DELETED',
tmo, **cond)
if event is None:
raise exceptions.TestFail(
'Failed to receive BLOCK_EXPORT_DELETED')
self._export_uid = None
def check_first_job_status(self):
"""
when completion-mode is
grouped: the 1st job should be cancelled
default: the 1st job should complete without any error
"""
job_event = 'BLOCK_JOB_CANCELLED' if self.params.get(
"completion_mode") == "grouped" else 'BLOCK_JOB_COMPLETED'
tmo = self.params.get_numeric('job_completed_timeout', 360)
cond = {'device': self._job_ids[0]}
event = get_event_by_condition(self.main_vm, job_event, tmo, **cond)
if event:
if event['data'].get('error'):
self.test.fail('Unexpected error: %s' % event['data']['error'])
else:
self.test.fail('Failed to get %s for the first job' % job_event)
def commit_snapshots(self):
device = self.params.get("device_tag")
device_params = self.params.object_params(device)
snapshot_tags = device_params["snapshot_tags"].split()
self.device_node = self.get_node_name(device)
options = ["speed", "auto-finalize", "auto-dismiss"]
arguments = self.params.copy_from_keys(options)
arguments["speed"] = self.params["commit_speed"]
arguments["auto-finalize"] = self.params.get_boolean("finalize")
arguments["auto-dismiss"] = self.params.get_boolean("dismiss")
device = self.get_node_name(snapshot_tags[-1])
commit_cmd = backup_utils.block_commit_qmp_cmd
cmd, args = commit_cmd(device, **arguments)
self.main_vm.monitor.cmd(cmd, args)
job_id = args.get("job-id", device)
self.main_vm.monitor.cmd("block-job-set-speed", {
'device': job_id,
'speed': 10240
})
self.commit_op("stop")
self.commit_op("cont")
self.commit_op("job-pause", {'id': job_id})
self.commit_op("job-resume", {'id': job_id})
self.commit_op("job-cancel", {'id': job_id})
event = job_utils.get_event_by_condition(self.main_vm,
'BLOCK_JOB_CANCELLED',
self.params.get_numeric(
'job_cancelled_timeout',
60),
device=job_id)
if event is None:
self.test.fail('Job failed to cancel')
if not self.params.get_boolean("dismiss"):
self.commit_op("job-dismiss", {'id': job_id})
self.main_vm.monitor.cmd(cmd, args)
self.main_vm.monitor.cmd("block-job-set-speed", {
'device': job_id,
'speed': 0
})
job_utils.wait_until_block_job_completed(self.main_vm, job_id)
def commit_snapshots(self):
device = self.params.get("device_tag")
device_params = self.params.object_params(device)
snapshot_tags = device_params["snapshot_tags"].split()
self.device_node = self.get_node_name(device)
device = self.get_node_name(snapshot_tags[-1])
commit_cmd = backup_utils.block_commit_qmp_cmd
cmd, args = commit_cmd(device)
self.main_vm.monitor.cmd(cmd, args)
job_id = args.get("job-id", device)
job_utils.wait_until_job_status_match(self.main_vm,
"ready",
job_id,
timeout=120)
self.main_vm.monitor.cmd("job-pause", {"id": job_id})
if not job_utils.is_block_job_paused(self.main_vm, job_id):
self.test.fail("Block job is not paused")
self.main_vm.monitor.cmd("job-complete", {"id": job_id})
self.main_vm.monitor.cmd("job-resume", {"id": job_id})
if not job_utils.get_event_by_condition(self.main_vm,
"BLOCK_JOB_COMPLETED"):
self.test.fail("Block backup job not finished")
def do_test(self):
self.snapshot_test()
self.blockdev_stream()
job_utils.check_block_jobs_started(
self.main_vm, [self._job],
self.params.get_numeric('job_started_timeout', 30))
self.main_vm.monitor.cmd("job-pause", {'id': self._job})
job_utils.check_block_jobs_paused(
self.main_vm, [self._job],
self.params.get_numeric('job_paused_interval', 30))
self.main_vm.monitor.cmd(
"block-job-set-speed", {
'device': self._job,
'speed': self.params.get_numeric('resume_speed')
})
self.main_vm.monitor.cmd("job-resume", {'id': self._job})
job_utils.check_block_jobs_running(
self.main_vm, [self._job],
self.params.get_numeric('job_running_timeout', 300))
self.main_vm.monitor.cmd("job-cancel", {'id': self._job})
event = job_utils.get_event_by_condition(self.main_vm,
'BLOCK_JOB_CANCELLED',
self.params.get_numeric(
'job_cancelled_timeout',
30),
device=self._job)
if not event:
self.test.fail('Failed to get BLOCK_JOB_CANCELLED event for %s' %
self._job)
job_utils.block_job_dismiss(self.main_vm, self._job)
self._stream_options['speed'] = 0
self.blockdev_stream()
self.wait_stream_job_completed()
self.check_backing_file()
self.clone_vm.create()
self.mount_data_disks()
self.verify_data_file()
def wait_block_io_error(self):
event = get_event_by_condition(
self.main_vm, 'BLOCK_IO_ERROR',
self.params.get_numeric('event_timeout', 30))
if event is None:
self.test.fail('Failed to get BLOCK_IO_ERROR event')
def check_vm_reset_event(self):
tmo = self.params.get_numeric('vm_reset_timeout', 60)
if get_event_by_condition(self.main_vm, 'RESET', tmo) is None:
self.test.fail('Failed to reset VM after triggering crash')