image_len = 1 * 1024 * 1024 # MB
qmp_cmd = 'drive-mirror'
qmp_target = target_img
- not_found_error = 'DeviceNotFound'
def setUp(self):
iotests.create_image(backing_img, self.image_len)
result = self.vm.qmp(self.qmp_cmd, device='ide1-cd0', sync='full',
target=self.qmp_target)
- self.assert_qmp(result, 'error/class', self.not_found_error)
+ self.assert_qmp(result, 'error/class', 'GenericError')
def test_image_not_found(self):
result = self.vm.qmp(self.qmp_cmd, device='drive0', sync='full',
def test_device_not_found(self):
result = self.vm.qmp(self.qmp_cmd, device='nonexistent', sync='full',
target=self.qmp_target)
- self.assert_qmp(result, 'error/class', self.not_found_error)
+ self.assert_qmp(result, 'error/class', 'GenericError')
class TestSingleBlockdev(TestSingleDrive):
qmp_cmd = 'blockdev-mirror'
qmp_target = 'node1'
- not_found_error = 'GenericError'
def setUp(self):
TestSingleDrive.setUp(self)
qemu_img('create', '-f', iotests.imgfmt, '-o', 'backing_file=%s' % backing_img, target_img)
- args = {'options':
- {'driver': iotests.imgfmt,
- 'node-name': self.qmp_target,
- 'file': { 'filename': target_img, 'driver': 'file' } } }
+ args = {'driver': iotests.imgfmt,
+ 'node-name': self.qmp_target,
+ 'file': { 'filename': target_img, 'driver': 'file' } }
result = self.vm.qmp("blockdev-add", **args)
self.assert_qmp(result, 'return', {})
test_image_not_found = None
test_small_buffer2 = None
-class TestBlockdevAttached(iotests.QMPTestCase):
- image_len = 1 * 1024 * 1024 # MB
-
- def setUp(self):
- iotests.create_image(backing_img, self.image_len)
- qemu_img('create', '-f', iotests.imgfmt, '-o', 'backing_file=%s' % backing_img, test_img)
- qemu_img('create', '-f', iotests.imgfmt, '-o', 'backing_file=%s' % backing_img, target_img)
- self.vm = iotests.VM().add_drive(test_img)
- self.vm.launch()
-
- def tearDown(self):
- self.vm.shutdown()
- os.remove(test_img)
- os.remove(target_img)
-
- def test_blockdev_attached(self):
- self.assert_no_active_block_jobs()
- args = {'options':
- {'driver': iotests.imgfmt,
- 'id': 'drive1',
- 'file': { 'filename': target_img, 'driver': 'file' } } }
- result = self.vm.qmp("blockdev-add", **args)
- self.assert_qmp(result, 'return', {})
- result = self.vm.qmp('blockdev-mirror', device='drive0', sync='full',
- target='drive1')
- self.assert_qmp(result, 'error/class', 'GenericError')
-
class TestSingleDriveZeroLength(TestSingleDrive):
image_len = 0
test_small_buffer2 = None
self.complete_and_wait()
self.assert_no_active_block_jobs()
+class TestGranularity(iotests.QMPTestCase):
+ image_len = 10 * 1024 * 1024 # MB
+
+ def setUp(self):
+ qemu_img('create', '-f', iotests.imgfmt, test_img,
+ str(TestGranularity.image_len))
+ qemu_io('-c', 'write 0 %d' % (self.image_len),
+ test_img)
+ self.vm = iotests.VM().add_drive(test_img)
+ self.vm.launch()
+
+ def tearDown(self):
+ self.vm.shutdown()
+ self.assertTrue(iotests.compare_images(test_img, target_img),
+ 'target image does not match source after mirroring')
+ os.remove(test_img)
+ os.remove(target_img)
+
+ def test_granularity(self):
+ self.assert_no_active_block_jobs()
+ result = self.vm.qmp('drive-mirror', device='drive0',
+ sync='full', target=target_img,
+ mode='absolute-paths', granularity=8192)
+ self.assert_qmp(result, 'return', {})
+ event = self.vm.get_qmp_event(wait=60.0)
+ # Failures will manifest as COMPLETED/ERROR.
+ self.assert_qmp(event, 'event', 'BLOCK_JOB_READY')
+ self.complete_and_wait(drive='drive0', wait_ready=False)
+ self.assert_no_active_block_jobs()
+
class TestRepairQuorum(iotests.QMPTestCase):
""" This class test quorum file repair using drive-mirror.
It's mostly a fork of TestSingleDrive """
image_len = 1 * 1024 * 1024 # MB
IMAGES = [ quorum_img1, quorum_img2, quorum_img3 ]
- def has_quorum(self):
- return 'quorum' in iotests.qemu_img_pipe('--help')
-
def setUp(self):
self.vm = iotests.VM()
self.vm.launch()
#assemble the quorum block device from the individual files
- args = { "options" : { "driver": "quorum", "id": "quorum0",
- "vote-threshold": 2, "children": [ "img0", "img1", "img2" ] } }
- if self.has_quorum():
+ args = { "driver": "quorum", "node-name": "quorum0",
+ "vote-threshold": 2, "children": [ "img0", "img1", "img2" ] }
+ if iotests.supports_quorum():
result = self.vm.qmp("blockdev-add", **args)
self.assert_qmp(result, 'return', {})
pass
def test_complete(self):
- if not self.has_quorum():
+ if not iotests.supports_quorum():
return
self.assert_no_active_block_jobs()
- result = self.vm.qmp('drive-mirror', device='quorum0', sync='full',
- node_name="repair0",
- replaces="img1",
+ result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
+ sync='full', node_name="repair0", replaces="img1",
target=quorum_repair_img, format=iotests.imgfmt)
self.assert_qmp(result, 'return', {})
- self.complete_and_wait(drive="quorum0")
- result = self.vm.qmp('query-named-block-nodes')
- self.assert_qmp(result, 'return[0]/file', quorum_repair_img)
+ self.complete_and_wait(drive="job0")
+ self.assert_has_block_node("repair0", quorum_repair_img)
# TODO: a better test requiring some QEMU infrastructure will be added
# to check that this file is really driven by quorum
self.vm.shutdown()
'target image does not match source after mirroring')
def test_cancel(self):
- if not self.has_quorum():
+ if not iotests.supports_quorum():
return
self.assert_no_active_block_jobs()
- result = self.vm.qmp('drive-mirror', device='quorum0', sync='full',
- node_name="repair0",
- replaces="img1",
+ result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
+ sync='full', node_name="repair0", replaces="img1",
target=quorum_repair_img, format=iotests.imgfmt)
self.assert_qmp(result, 'return', {})
- self.cancel_and_wait(drive="quorum0", force=True)
+ self.cancel_and_wait(drive="job0", force=True)
# here we check that the last registered quorum file has not been
# swapped out and unref
- result = self.vm.qmp('query-named-block-nodes')
- self.assert_qmp(result, 'return[1]/file', quorum_img3)
+ self.assert_has_block_node(None, quorum_img3)
self.vm.shutdown()
def test_cancel_after_ready(self):
- if not self.has_quorum():
+ if not iotests.supports_quorum():
return
self.assert_no_active_block_jobs()
- result = self.vm.qmp('drive-mirror', device='quorum0', sync='full',
- node_name="repair0",
- replaces="img1",
+ result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
+ sync='full', node_name="repair0", replaces="img1",
target=quorum_repair_img, format=iotests.imgfmt)
self.assert_qmp(result, 'return', {})
- self.wait_ready_and_cancel(drive="quorum0")
- result = self.vm.qmp('query-named-block-nodes')
+ self.wait_ready_and_cancel(drive="job0")
# here we check that the last registered quorum file has not been
# swapped out and unref
- self.assert_qmp(result, 'return[1]/file', quorum_img3)
+ self.assert_has_block_node(None, quorum_img3)
self.vm.shutdown()
self.assertTrue(iotests.compare_images(quorum_img2, quorum_repair_img),
'target image does not match source after mirroring')
def test_pause(self):
- if not self.has_quorum():
+ if not iotests.supports_quorum():
return
self.assert_no_active_block_jobs()
- result = self.vm.qmp('drive-mirror', device='quorum0', sync='full',
- node_name="repair0",
- replaces="img1",
+ result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
+ sync='full', node_name="repair0", replaces="img1",
target=quorum_repair_img, format=iotests.imgfmt)
self.assert_qmp(result, 'return', {})
- result = self.vm.qmp('block-job-pause', device='quorum0')
+ result = self.vm.qmp('block-job-pause', device='job0')
self.assert_qmp(result, 'return', {})
time.sleep(1)
result = self.vm.qmp('query-block-jobs')
self.assert_qmp(result, 'return[0]/offset', offset)
- result = self.vm.qmp('block-job-resume', device='quorum0')
+ result = self.vm.qmp('block-job-resume', device='job0')
self.assert_qmp(result, 'return', {})
- self.complete_and_wait(drive="quorum0")
+ self.complete_and_wait(drive="job0")
self.vm.shutdown()
self.assertTrue(iotests.compare_images(quorum_img2, quorum_repair_img),
'target image does not match source after mirroring')
def test_medium_not_found(self):
- if not self.has_quorum():
+ if not iotests.supports_quorum():
return
if iotests.qemu_default_machine != 'pc':
return
- result = self.vm.qmp('drive-mirror', device='drive0', # CD-ROM
+ result = self.vm.qmp('drive-mirror', job_id='job0', device='drive0', # CD-ROM
sync='full',
node_name='repair0',
replaces='img1',
self.assert_qmp(result, 'error/class', 'GenericError')
def test_image_not_found(self):
- if not self.has_quorum():
+ if not iotests.supports_quorum():
return
- result = self.vm.qmp('drive-mirror', device='quorum0', sync='full',
- node_name='repair0',
- replaces='img1',
- mode='existing',
- target=quorum_repair_img, format=iotests.imgfmt)
+ result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
+ sync='full', node_name='repair0', replaces='img1',
+ mode='existing', target=quorum_repair_img,
+ format=iotests.imgfmt)
self.assert_qmp(result, 'error/class', 'GenericError')
def test_device_not_found(self):
- if not self.has_quorum():
+ if not iotests.supports_quorum():
return
- result = self.vm.qmp('drive-mirror', device='nonexistent', sync='full',
+ result = self.vm.qmp('drive-mirror', job_id='job0',
+ device='nonexistent', sync='full',
node_name='repair0',
replaces='img1',
target=quorum_repair_img, format=iotests.imgfmt)
- self.assert_qmp(result, 'error/class', 'DeviceNotFound')
+ self.assert_qmp(result, 'error/class', 'GenericError')
def test_wrong_sync_mode(self):
- if not self.has_quorum():
+ if not iotests.supports_quorum():
return
- result = self.vm.qmp('drive-mirror', device='quorum0',
+ result = self.vm.qmp('drive-mirror', device='quorum0', job_id='job0',
node_name='repair0',
replaces='img1',
target=quorum_repair_img, format=iotests.imgfmt)
self.assert_qmp(result, 'error/class', 'GenericError')
def test_no_node_name(self):
- if not self.has_quorum():
+ if not iotests.supports_quorum():
return
- result = self.vm.qmp('drive-mirror', device='quorum0', sync='full',
- replaces='img1',
+ result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
+ sync='full', replaces='img1',
target=quorum_repair_img, format=iotests.imgfmt)
self.assert_qmp(result, 'error/class', 'GenericError')
def test_nonexistent_replaces(self):
- if not self.has_quorum():
+ if not iotests.supports_quorum():
return
- result = self.vm.qmp('drive-mirror', device='quorum0', sync='full',
- node_name='repair0',
- replaces='img77',
+ result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
+ sync='full', node_name='repair0', replaces='img77',
target=quorum_repair_img, format=iotests.imgfmt)
self.assert_qmp(result, 'error/class', 'GenericError')
def test_after_a_quorum_snapshot(self):
- if not self.has_quorum():
+ if not iotests.supports_quorum():
return
result = self.vm.qmp('blockdev-snapshot-sync', node_name='img1',
snapshot_file=quorum_snapshot_file,
snapshot_node_name="snap1");
- result = self.vm.qmp('drive-mirror', device='quorum0', sync='full',
- node_name='repair0',
- replaces="img1",
+ result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
+ sync='full', node_name='repair0', replaces="img1",
target=quorum_repair_img, format=iotests.imgfmt)
self.assert_qmp(result, 'error/class', 'GenericError')
- result = self.vm.qmp('drive-mirror', device='quorum0', sync='full',
- node_name='repair0',
- replaces="snap1",
+ result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
+ sync='full', node_name='repair0', replaces="snap1",
target=quorum_repair_img, format=iotests.imgfmt)
self.assert_qmp(result, 'return', {})
- self.complete_and_wait(drive="quorum0")
- result = self.vm.qmp('query-named-block-nodes')
- self.assert_qmp(result, 'return[0]/file', quorum_repair_img)
+ self.complete_and_wait('job0')
+ self.assert_has_block_node("repair0", quorum_repair_img)
# TODO: a better test requiring some QEMU infrastructure will be added
# to check that this file is really driven by quorum
self.vm.shutdown()
+# Test mirroring with a source that does not have any parents (not even a
+# BlockBackend)
+class TestOrphanedSource(iotests.QMPTestCase):
+ def setUp(self):
+ blk0 = { 'node-name': 'src',
+ 'driver': 'null-co' }
+
+ blk1 = { 'node-name': 'dest',
+ 'driver': 'null-co' }
+
+ blk2 = { 'node-name': 'dest-ro',
+ 'driver': 'null-co',
+ 'read-only': 'on' }
+
+ self.vm = iotests.VM()
+ self.vm.add_blockdev(self.qmp_to_opts(blk0))
+ self.vm.add_blockdev(self.qmp_to_opts(blk1))
+ self.vm.add_blockdev(self.qmp_to_opts(blk2))
+ self.vm.launch()
+
+ def tearDown(self):
+ self.vm.shutdown()
+
+ def test_no_job_id(self):
+ self.assert_no_active_block_jobs()
+
+ result = self.vm.qmp('blockdev-mirror', device='src', sync='full',
+ target='dest')
+ self.assert_qmp(result, 'error/class', 'GenericError')
+
+ def test_success(self):
+ self.assert_no_active_block_jobs()
+
+ result = self.vm.qmp('blockdev-mirror', job_id='job', device='src',
+ sync='full', target='dest')
+ self.assert_qmp(result, 'return', {})
+
+ self.complete_and_wait('job')
+
+ def test_failing_permissions(self):
+ self.assert_no_active_block_jobs()
+
+ result = self.vm.qmp('blockdev-mirror', device='src', sync='full',
+ target='dest-ro')
+ self.assert_qmp(result, 'error/class', 'GenericError')
+
if __name__ == '__main__':
iotests.main(supported_fmts=['qcow2', 'qed'])
projects / qemu.git / blobdiff