Lines Matching refs:self
47 def setUp(self): argument
48 iotests.create_image(backing_img, self.image_len)
51 self.vm = iotests.VM().add_drive(test_img, "node-name=top,backing.node-name=base")
53 self.vm.add_drive(None, 'media=cdrom', 'ide')
54 self.vm.launch()
56 def tearDown(self): argument
57 self.vm.shutdown()
65 def test_complete(self): argument
66 self.assert_no_active_block_jobs()
68 self.vm.cmd(self.qmp_cmd, device='drive0', sync='full',
69 target=self.qmp_target)
71 self.complete_and_wait()
72 result = self.vm.qmp('query-block')
73 self.assert_qmp(result, 'return[0]/inserted/file', target_img)
74 self.vm.shutdown()
75 self.assertTrue(iotests.compare_images(test_img, target_img),
78 def test_cancel(self): argument
79 self.assert_no_active_block_jobs()
81 self.vm.cmd(self.qmp_cmd, device='drive0', sync='full',
82 target=self.qmp_target)
84 self.cancel_and_wait(force=True)
85 result = self.vm.qmp('query-block')
86 self.assert_qmp(result, 'return[0]/inserted/file', test_img)
88 def test_cancel_after_ready(self): argument
89 self.assert_no_active_block_jobs()
91 self.vm.cmd(self.qmp_cmd, device='drive0', sync='full',
92 target=self.qmp_target)
94 self.wait_ready_and_cancel()
95 result = self.vm.qmp('query-block')
96 self.assert_qmp(result, 'return[0]/inserted/file', test_img)
97 self.vm.shutdown()
98 self.assertTrue(iotests.compare_images(test_img, target_img),
101 def test_pause(self): argument
102 self.assert_no_active_block_jobs()
104 self.vm.cmd(self.qmp_cmd, device='drive0', sync='full',
105 target=self.qmp_target)
107 self.pause_job('drive0')
109 result = self.vm.qmp('query-block-jobs')
110 offset = self.dictpath(result, 'return[0]/offset')
113 result = self.vm.qmp('query-block-jobs')
114 self.assert_qmp(result, 'return[0]/offset', offset)
116 self.vm.cmd('block-job-resume', device='drive0')
118 self.complete_and_wait()
119 self.vm.shutdown()
120 self.assertTrue(iotests.compare_images(test_img, target_img),
123 def test_small_buffer(self): argument
124 self.assert_no_active_block_jobs()
127 self.vm.cmd(self.qmp_cmd, device='drive0', sync='full',
128 buf_size=4096, target=self.qmp_target)
130 self.complete_and_wait()
131 result = self.vm.qmp('query-block')
132 self.assert_qmp(result, 'return[0]/inserted/file', target_img)
133 self.vm.shutdown()
134 self.assertTrue(iotests.compare_images(test_img, target_img),
137 def test_small_buffer2(self): argument
138 self.assert_no_active_block_jobs()
141 % (self.image_len, self.image_len), target_img)
142 self.vm.cmd(self.qmp_cmd, device='drive0', sync='full',
143 buf_size=65536, mode='existing', target=self.qmp_target)
145 self.complete_and_wait()
146 result = self.vm.qmp('query-block')
147 self.assert_qmp(result, 'return[0]/inserted/file', target_img)
148 self.vm.shutdown()
149 self.assertTrue(iotests.compare_images(test_img, target_img),
152 def test_large_cluster(self): argument
153 self.assert_no_active_block_jobs()
156 % (self.image_len, backing_img),
158 self.vm.cmd(self.qmp_cmd, device='drive0', sync='full',
159 mode='existing', target=self.qmp_target)
161 self.complete_and_wait()
162 result = self.vm.qmp('query-block')
163 self.assert_qmp(result, 'return[0]/inserted/file', target_img)
164 self.vm.shutdown()
165 self.assertTrue(iotests.compare_images(test_img, target_img),
170 def test_implicit_node(self): argument
171 self.assert_no_active_block_jobs()
173 self.vm.cmd(self.qmp_cmd, device='drive0', sync='full',
174 target=self.qmp_target)
176 result = self.vm.qmp('query-block')
177 self.assert_qmp(result, 'return[0]/inserted/file', test_img)
178 self.assert_qmp(result, 'return[0]/inserted/drv', iotests.imgfmt)
179 self.assert_qmp(result, 'return[0]/inserted/backing_file', backing_img)
180 self.assert_qmp(result, 'return[0]/inserted/backing_file_depth', 1)
181 self.assert_qmp(result, 'return[0]/inserted/image/filename', test_img)
182 self.assert_qmp(result, 'return[0]/inserted/image/backing-image/filename', backing_img)
184 result = self.vm.qmp('query-blockstats')
185 self.assert_qmp(result, 'return[0]/node-name', 'top')
186 self.assert_qmp(result, 'return[0]/backing/node-name', 'base')
188 self.cancel_and_wait(force=True)
189 result = self.vm.qmp('query-block')
190 self.assert_qmp(result, 'return[0]/inserted/file', test_img)
191 self.assert_qmp(result, 'return[0]/inserted/drv', iotests.imgfmt)
192 self.assert_qmp(result, 'return[0]/inserted/backing_file', backing_img)
193 self.assert_qmp(result, 'return[0]/inserted/backing_file_depth', 1)
194 self.assert_qmp(result, 'return[0]/inserted/image/filename', test_img)
195 self.assert_qmp(result, 'return[0]/inserted/image/backing-image/filename', backing_img)
197 result = self.vm.qmp('query-blockstats')
198 self.assert_qmp(result, 'return[0]/node-name', 'top')
199 self.assert_qmp(result, 'return[0]/backing/node-name', 'base')
201 def test_medium_not_found(self): argument
205 result = self.vm.qmp(self.qmp_cmd, device='ide1-cd0', sync='full',
206 target=self.qmp_target)
207 self.assert_qmp(result, 'error/class', 'GenericError')
209 def test_image_not_found(self): argument
210 result = self.vm.qmp(self.qmp_cmd, device='drive0', sync='full',
211 mode='existing', target=self.qmp_target)
212 self.assert_qmp(result, 'error/class', 'GenericError')
214 def test_device_not_found(self): argument
215 result = self.vm.qmp(self.qmp_cmd, device='nonexistent', sync='full',
216 target=self.qmp_target)
217 self.assert_qmp(result, 'error/class', 'GenericError')
223 def setUp(self): argument
224 TestSingleDrive.setUp(self)
228 'node-name': self.qmp_target,
230 self.vm.cmd("blockdev-add", args)
232 def test_mirror_to_self(self): argument
233 result = self.vm.qmp(self.qmp_cmd, job_id='job0',
234 device=self.qmp_target, sync='full',
235 target=self.qmp_target)
236 self.assert_qmp(result, 'error/class', 'GenericError')
238 def do_test_resize(self, device, node): argument
241 result = self.vm.qmp('block_resize', device=device, size=65536)
242 self.assert_qmp(result, 'error/class', 'GenericError')
244 result = self.vm.qmp('block_resize', node_name=node, size=65536)
245 self.assert_qmp(result, 'error/class', 'GenericError')
247 self.vm.cmd(self.qmp_cmd, job_id='job0', device='drive0',
248 sync='full', target=self.qmp_target,
251 result = self.vm.run_job('job0', auto_finalize=False,
253 self.assertEqual(result, None)
255 def test_source_resize(self): argument
256 self.do_test_resize('drive0', 'top')
258 def test_target_resize(self): argument
259 self.do_test_resize(None, self.qmp_target)
261 def do_test_target_size(self, size): argument
262 self.vm.cmd('block_resize', node_name=self.qmp_target,
265 self.vm.cmd(self.qmp_cmd, job_id='job0',
267 target=self.qmp_target)
269 result = self.vm.run_job('job0')
270 self.assertEqual(result, 'Source and target image have different sizes')
274 def test_small_target(self): argument
275 self.do_test_target_size(self.image_len // 2)
277 def test_large_target(self): argument
278 self.do_test_target_size(self.image_len * 2)
305 def setUp(self): argument
309 self.vm = iotests.VM().add_drive(test_img)
310 self.vm.launch()
312 def tearDown(self): argument
313 self.vm.shutdown()
322 def test_complete(self): argument
323 self.assert_no_active_block_jobs()
327 self.vm.cmd('drive-mirror', device='drive0', sync='full',
330 self.complete_and_wait()
331 result = self.vm.qmp('query-block')
332 self.assert_qmp(result, 'return[0]/inserted/file', target_img)
333 self.vm.shutdown()
334 self.assertTrue(iotests.compare_images(test_img, target_img),
337 def test_cancel(self): argument
338 self.assert_no_active_block_jobs()
342 self.vm.cmd('drive-mirror', device='drive0', sync='full',
345 self.wait_ready_and_cancel()
346 result = self.vm.qmp('query-block')
347 self.assert_qmp(result, 'return[0]/inserted/file', test_img)
348 self.vm.shutdown()
349 self.assertTrue(iotests.compare_images(test_img, target_img),
352 def test_large_cluster(self): argument
353 self.assert_no_active_block_jobs()
362 self.vm.cmd('drive-mirror', device='drive0', sync='full',
365 self.complete_and_wait()
366 result = self.vm.qmp('query-block')
367 self.assert_qmp(result, 'return[0]/inserted/file', target_img)
368 self.vm.shutdown()
369 self.assertTrue(iotests.compare_images(test_img, target_img),
376 def setUp(self): argument
381 self.vm = iotests.VM().add_drive(test_img)
382 self.vm.launch()
384 def tearDown(self): argument
385 self.vm.shutdown()
393 def test_complete_top(self): argument
394 self.assert_no_active_block_jobs()
396 self.vm.cmd('drive-mirror', device='drive0', sync='top',
399 self.complete_and_wait()
400 result = self.vm.qmp('query-block')
401 self.assert_qmp(result, 'return[0]/inserted/file', target_img)
402 self.vm.shutdown()
403 self.assertTrue(iotests.compare_images(test_img, target_img),
406 def test_complete_full(self): argument
407 self.assert_no_active_block_jobs()
409 self.vm.cmd('drive-mirror', device='drive0', sync='full',
412 self.complete_and_wait()
413 result = self.vm.qmp('query-block')
414 self.assert_qmp(result, 'return[0]/inserted/file', target_img)
415 self.vm.shutdown()
416 self.assertTrue(iotests.compare_images(test_img, target_img),
426 def create_blkdebug_file(self, name, event, errno): argument
446 ''' % (event, errno, self.MIRROR_GRANULARITY // 512, event, event))
449 def setUp(self): argument
450 self.blkdebug_file = backing_img + ".blkdebug"
452 self.create_blkdebug_file(self.blkdebug_file, "read_aio", 5)
455 % (self.blkdebug_file, backing_img),
458 qemu_io('-c', 'write %d 512' % (self.MIRROR_GRANULARITY + 65536),
460 self.vm = iotests.VM().add_drive(test_img)
461 self.vm.launch()
463 def tearDown(self): argument
464 self.vm.shutdown()
468 os.remove(self.blkdebug_file)
470 def test_report_read(self): argument
471 self.assert_no_active_block_jobs()
473 self.vm.cmd('drive-mirror', device='drive0', sync='full',
479 for event in self.vm.get_qmp_events(wait=True):
481 self.assert_qmp(event, 'data/device', 'drive0')
482 self.assert_qmp(event, 'data/operation', 'read')
485 self.assertTrue(False, 'job completed unexpectedly')
487 self.assertTrue(error, 'job completed unexpectedly')
488 self.assert_qmp(event, 'data/type', 'mirror')
489 self.assert_qmp(event, 'data/device', 'drive0')
490 self.assert_qmp(event, 'data/error', 'Input/output error')
493 self.assert_qmp(event, 'data/id', 'drive0')
495 self.assert_no_active_block_jobs()
497 def test_ignore_read(self): argument
498 self.assert_no_active_block_jobs()
500 self.vm.cmd('drive-mirror', device='drive0', sync='full',
503 event = self.vm.get_qmp_event(wait=True)
505 self.assert_qmp(event, 'data/id', 'drive0')
506 event = self.vm.get_qmp_event(wait=True)
508 self.assertEqual(event['event'], 'BLOCK_JOB_ERROR')
509 self.assert_qmp(event, 'data/device', 'drive0')
510 self.assert_qmp(event, 'data/operation', 'read')
511 result = self.vm.qmp('query-block-jobs')
512 self.assertIn(result['return'][0]['status'], ['running', 'ready'])
513 self.complete_and_wait()
515 def test_large_cluster(self): argument
516 self.assert_no_active_block_jobs()
524 self.vm.cmd('drive-mirror', device='drive0', sync='top',
528 event = self.vm.get_qmp_event(wait=True)
530 self.assert_qmp(event, 'data/id', 'drive0')
531 event = self.vm.get_qmp_event(wait=True)
533 self.assertEqual(event['event'], 'BLOCK_JOB_ERROR')
534 self.assert_qmp(event, 'data/device', 'drive0')
535 self.assert_qmp(event, 'data/operation', 'read')
536 result = self.vm.qmp('query-block-jobs')
537 self.assertIn(result['return'][0]['status'], ['running', 'ready'])
538 self.complete_and_wait()
539 self.vm.shutdown()
544 self.assertTrue(iotests.compare_images(test_img, target_img),
547 def test_stop_read(self): argument
548 self.assert_no_active_block_jobs()
550 self.vm.cmd('drive-mirror', device='drive0', sync='full',
556 for event in self.vm.get_qmp_events(wait=True):
558 self.assert_qmp(event, 'data/device', 'drive0')
559 self.assert_qmp(event, 'data/operation', 'read')
561 if self.vm.qmp('query-block-jobs')['return'][0]['status'] != 'paused':
562 self.vm.events_wait([(
567 result = self.vm.qmp('query-block-jobs')
568 self.assert_qmp(result, 'return[0]/status', 'paused')
569 self.assert_qmp(result, 'return[0]/io-status', 'failed')
571 self.vm.cmd('block-job-resume', device='drive0')
574 self.assertTrue(error, 'job completed unexpectedly')
575 self.assert_qmp(event, 'data/device', 'drive0')
578 result = self.vm.qmp('query-block-jobs')
579 self.assert_qmp(result, 'return[0]/status', 'ready')
580 self.assert_qmp(result, 'return[0]/io-status', 'ok')
582 self.complete_and_wait(wait_ready=False)
583 self.assert_no_active_block_jobs()
592 def create_blkdebug_file(self, name, event, errno): argument
612 ''' % (event, errno, self.MIRROR_GRANULARITY // 512, event, event))
615 def setUp(self): argument
616 self.blkdebug_file = target_img + ".blkdebug"
618 self.create_blkdebug_file(self.blkdebug_file, "write_aio", 5)
621 self.vm = iotests.VM().add_drive(test_img)
622 self.target_img = 'blkdebug:%s:%s' % (self.blkdebug_file, target_img)
624 self.vm.launch()
626 def tearDown(self): argument
627 self.vm.shutdown()
631 os.remove(self.blkdebug_file)
633 def test_report_write(self): argument
634 self.assert_no_active_block_jobs()
636 self.vm.cmd('drive-mirror', device='drive0', sync='full',
637 mode='existing', target=self.target_img)
642 for event in self.vm.get_qmp_events(wait=True):
644 self.assert_qmp(event, 'data/device', 'drive0')
645 self.assert_qmp(event, 'data/operation', 'write')
648 self.assertTrue(False, 'job completed unexpectedly')
650 self.assertTrue(error, 'job completed unexpectedly')
651 self.assert_qmp(event, 'data/type', 'mirror')
652 self.assert_qmp(event, 'data/device', 'drive0')
653 self.assert_qmp(event, 'data/error', 'Input/output error')
656 self.assert_no_active_block_jobs()
658 def test_ignore_write(self): argument
659 self.assert_no_active_block_jobs()
661 self.vm.cmd('drive-mirror', device='drive0', sync='full',
662 mode='existing', target=self.target_img,
665 event = self.vm.event_wait(name='BLOCK_JOB_ERROR')
666 self.assertEqual(event['event'], 'BLOCK_JOB_ERROR')
667 self.assert_qmp(event, 'data/device', 'drive0')
668 self.assert_qmp(event, 'data/operation', 'write')
669 result = self.vm.qmp('query-block-jobs')
670 self.assertIn(result['return'][0]['status'], ['running', 'ready'])
671 self.complete_and_wait()
673 def test_stop_write(self): argument
674 self.assert_no_active_block_jobs()
676 self.vm.cmd('drive-mirror', device='drive0', sync='full',
677 mode='existing', target=self.target_img,
683 for event in self.vm.get_qmp_events(wait=True):
685 self.assert_qmp(event, 'data/device', 'drive0')
686 self.assert_qmp(event, 'data/operation', 'write')
688 if self.vm.qmp('query-block-jobs')['return'][0]['status'] != 'paused':
689 self.vm.events_wait([(
694 result = self.vm.qmp('query-block-jobs')
695 self.assert_qmp(result, 'return[0]/status', 'paused')
696 self.assert_qmp(result, 'return[0]/io-status', 'failed')
698 self.vm.cmd('block-job-resume', device='drive0')
700 result = self.vm.qmp('query-block-jobs')
701 self.assertIn(result['return'][0]['status'], ['running', 'ready'])
702 self.assert_qmp(result, 'return[0]/io-status', 'ok')
705 self.assertTrue(error, 'job completed unexpectedly')
706 self.assert_qmp(event, 'data/device', 'drive0')
709 self.complete_and_wait(wait_ready=False)
710 self.assert_no_active_block_jobs()
715 def setUp(self): argument
719 self.vm = iotests.VM().add_drive(test_img)
720 self.vm.launch()
722 def tearDown(self): argument
723 self.vm.shutdown()
728 def test_set_speed(self): argument
729 self.assert_no_active_block_jobs()
731 self.vm.cmd('drive-mirror', device='drive0', sync='full',
735 result = self.vm.qmp('query-block-jobs')
736 self.assert_qmp(result, 'return[0]/device', 'drive0')
737 self.assert_qmp(result, 'return[0]/speed', 0)
739 self.vm.cmd('block-job-set-speed', device='drive0', speed=8 * 1024 * 1024)
742 result = self.vm.qmp('query-block-jobs')
743 self.assert_qmp(result, 'return[0]/device', 'drive0')
744 self.assert_qmp(result, 'return[0]/speed', 8 * 1024 * 1024)
746 self.wait_ready_and_cancel()
749 self.vm.cmd('drive-mirror', device='drive0', sync='full',
752 result = self.vm.qmp('query-block-jobs')
753 self.assert_qmp(result, 'return[0]/device', 'drive0')
754 self.assert_qmp(result, 'return[0]/speed', 4 * 1024 * 1024)
756 self.wait_ready_and_cancel()
758 def test_set_speed_invalid(self): argument
759 self.assert_no_active_block_jobs()
761 result = self.vm.qmp('drive-mirror', device='drive0', sync='full',
763 self.assert_qmp(result, 'error/class', 'GenericError')
765 self.assert_no_active_block_jobs()
767 self.vm.cmd('drive-mirror', device='drive0', sync='full',
770 result = self.vm.qmp('block-job-set-speed', device='drive0', speed=-1)
771 self.assert_qmp(result, 'error/class', 'GenericError')
773 self.wait_ready_and_cancel()
778 def setUp(self): argument
781 self.vm = iotests.VM()
782 self.vm.launch()
783 self.vm.cmd('blockdev-add', node_name='drive0',
790 def tearDown(self): argument
791 self.vm.shutdown()
795 def test_absolute_paths_full(self): argument
796 self.assert_no_active_block_jobs()
797 self.vm.cmd('drive-mirror', job_id='drive0', device='drive0',
800 self.complete_and_wait()
801 self.assert_no_active_block_jobs()
803 def test_absolute_paths_top(self): argument
804 self.assert_no_active_block_jobs()
805 self.vm.cmd('drive-mirror', job_id='drive0', device='drive0',
808 self.complete_and_wait()
809 self.assert_no_active_block_jobs()
811 def test_absolute_paths_none(self): argument
812 self.assert_no_active_block_jobs()
813 self.vm.cmd('drive-mirror', job_id='drive0', device='drive0',
816 self.complete_and_wait()
817 self.assert_no_active_block_jobs()
819 def test_existing_full(self): argument
821 str(self.image_len))
824 self.assert_no_active_block_jobs()
825 self.vm.cmd('drive-mirror', job_id='drive0', device='drive0',
827 self.complete_and_wait()
828 self.assert_no_active_block_jobs()
830 self.vm.cmd('blockdev-del', node_name='drive0')
832 self.assertTrue(iotests.compare_images(test_img, target_img),
835 def test_blockdev_full(self): argument
837 str(self.image_len))
840 self.vm.cmd('blockdev-add', node_name='target',
847 self.assert_no_active_block_jobs()
848 self.vm.cmd('blockdev-mirror', job_id='drive0', device='drive0',
850 self.complete_and_wait()
851 self.assert_no_active_block_jobs()
853 self.vm.cmd('blockdev-del', node_name='drive0')
855 self.vm.cmd('blockdev-del', node_name='target')
857 self.assertTrue(iotests.compare_images(test_img, target_img),
863 def setUp(self): argument
866 qemu_io('-c', 'write 0 %d' % (self.image_len),
868 self.vm = iotests.VM().add_drive(test_img)
869 self.vm.launch()
871 def tearDown(self): argument
872 self.vm.shutdown()
873 self.assertTrue(iotests.compare_images(test_img, target_img),
878 def test_granularity(self): argument
879 self.assert_no_active_block_jobs()
880 self.vm.cmd('drive-mirror', device='drive0',
884 event = self.vm.get_qmp_event(wait=60.0)
886 self.assert_qmp(event, 'data/id', 'drive0')
887 event = self.vm.get_qmp_event(wait=60.0)
890 self.assert_qmp(event, 'event', 'BLOCK_JOB_READY')
891 self.complete_and_wait(drive='drive0', wait_ready=False)
892 self.assert_no_active_block_jobs()
901 def setUp(self): argument
902 self.vm = iotests.VM()
905 self.vm.add_drive(None, 'media=cdrom', 'ide')
908 for i in self.IMAGES:
910 str(self.image_len))
913 opts = "node-name=img%i" % self.IMAGES.index(i)
917 self.vm = self.vm.add_blockdev(opts)
919 self.vm.launch()
924 self.vm.cmd("blockdev-add", args)
927 def tearDown(self): argument
928 self.vm.shutdown()
929 for i in self.IMAGES + [ quorum_repair_img, quorum_snapshot_file,
937 def test_complete(self): argument
938 self.vm.cmd('drive-mirror', job_id='job0', device='quorum0',
942 self.complete_and_wait(drive="job0")
943 self.assert_has_block_node("repair0", quorum_repair_img)
944 self.vm.assert_block_path('quorum0', '/children.1', 'repair0')
945 self.vm.shutdown()
946 self.assertTrue(iotests.compare_images(quorum_img2, quorum_repair_img),
949 def test_cancel(self): argument
950 self.vm.cmd('drive-mirror', job_id='job0', device='quorum0',
954 self.cancel_and_wait(drive="job0", force=True)
957 self.assert_has_block_node(None, quorum_img3)
959 def test_cancel_after_ready(self): argument
960 self.vm.cmd('drive-mirror', job_id='job0', device='quorum0',
964 self.wait_ready_and_cancel(drive="job0")
967 self.assert_has_block_node(None, quorum_img3)
968 self.vm.shutdown()
969 self.assertTrue(iotests.compare_images(quorum_img2, quorum_repair_img),
972 def test_pause(self): argument
973 self.vm.cmd('drive-mirror', job_id='job0', device='quorum0',
977 self.pause_job('job0')
979 result = self.vm.qmp('query-block-jobs')
980 offset = self.dictpath(result, 'return[0]/offset')
983 result = self.vm.qmp('query-block-jobs')
984 self.assert_qmp(result, 'return[0]/offset', offset)
986 self.vm.cmd('block-job-resume', device='job0')
988 self.complete_and_wait(drive="job0")
989 self.vm.shutdown()
990 self.assertTrue(iotests.compare_images(quorum_img2, quorum_repair_img),
993 def test_medium_not_found(self): argument
997 result = self.vm.qmp('drive-mirror', job_id='job0', device='drive0', # CD-ROM
1002 self.assert_qmp(result, 'error/class', 'GenericError')
1004 def test_image_not_found(self): argument
1005 result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
1009 self.assert_qmp(result, 'error/class', 'GenericError')
1011 def test_device_not_found(self): argument
1012 result = self.vm.qmp('drive-mirror', job_id='job0',
1017 self.assert_qmp(result, 'error/class', 'GenericError')
1019 def test_wrong_sync_mode(self): argument
1020 result = self.vm.qmp('drive-mirror', device='quorum0', job_id='job0',
1024 self.assert_qmp(result, 'error/class', 'GenericError')
1026 def test_no_node_name(self): argument
1027 result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
1030 self.assert_qmp(result, 'error/class', 'GenericError')
1032 def test_nonexistent_replaces(self): argument
1033 result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
1036 self.assert_qmp(result, 'error/class', 'GenericError')
1038 def test_after_a_quorum_snapshot(self): argument
1039 self.vm.cmd('blockdev-snapshot-sync', node_name='img1',
1043 result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
1046 self.assert_qmp(result, 'error/class', 'GenericError')
1048 self.vm.cmd('drive-mirror', job_id='job0', device='quorum0',
1052 self.complete_and_wait('job0')
1053 self.assert_has_block_node("repair0", quorum_repair_img)
1054 self.vm.assert_block_path('quorum0', '/children.1', 'repair0')
1056 def test_with_other_parent(self): argument
1061 self.vm.cmd('nbd-server-start',
1067 self.vm.cmd('nbd-server-add', device='img1')
1069 result = self.vm.qmp('drive-mirror', job_id='mirror', device='quorum0',
1072 self.assert_qmp(result, 'error/desc',
1077 def test_with_other_parents_after_mirror_start(self): argument
1082 self.vm.cmd('nbd-server-start',
1088 self.vm.cmd('drive-mirror', job_id='mirror', device='quorum0',
1092 self.vm.cmd('nbd-server-add', device='img1')
1095 self.complete_and_wait('mirror',
1099 self.vm.assert_block_path('quorum0', '/children.1', 'img1')
1102 self.vm.shutdown()
1103 log = self.vm.get_log()
1109 self.assertEqual(log,
1118 def setUp(self): argument
1129 self.vm = iotests.VM()
1130 self.vm.add_blockdev(self.vm.qmp_to_opts(blk0))
1131 self.vm.add_blockdev(self.vm.qmp_to_opts(blk1))
1132 self.vm.add_blockdev(self.vm.qmp_to_opts(blk2))
1133 self.vm.launch()
1135 def tearDown(self): argument
1136 self.vm.shutdown()
1138 def test_no_job_id(self): argument
1139 self.assert_no_active_block_jobs()
1141 result = self.vm.qmp('blockdev-mirror', device='src', sync='full',
1143 self.assert_qmp(result, 'error/class', 'GenericError')
1145 def test_success(self): argument
1146 self.assert_no_active_block_jobs()
1148 self.vm.cmd('blockdev-mirror', job_id='job', device='src',
1151 self.complete_and_wait('job')
1153 def test_failing_permissions(self): argument
1154 self.assert_no_active_block_jobs()
1156 result = self.vm.qmp('blockdev-mirror', device='src', sync='full',
1158 self.assert_qmp(result, 'error/class', 'GenericError')
1160 def test_failing_permission_in_complete(self): argument
1161 self.assert_no_active_block_jobs()
1165 self.vm.cmd('blockdev-add',
1171 self.vm.cmd('blockdev-mirror', job_id='job', device='src',
1178 self.vm.cmd('blockdev-add',
1188 self.complete_and_wait('job',
1193 nodes = self.vm.qmp('query-named-block-nodes')['return']
1197 self.assertTrue(expect in nodes, '%s disappeared' % expect)
1198 self.assertFalse('mirror-filter' in nodes,
1205 def setUp(self): argument
1206 self.vm = iotests.VM()
1207 self.vm.launch()
1209 def tearDown(self): argument
1210 self.vm.shutdown()
1218 def test_replace_filter(self): argument
1222 self.vm.cmd('blockdev-add', {
1234 self.vm.cmd('blockdev-add',
1237 self.vm.cmd('blockdev-mirror', job_id='mirror', device='filter0',
1240 self.complete_and_wait('mirror')
1242 self.vm.assert_block_path('filter0', '/file', 'target')
1247 def setUp(self): argument
1257 self.vm = iotests.VM().add_device('virtio-scsi,id=vio-scsi')
1258 self.vm.launch()
1260 self.vm.cmd('blockdev-add', {
1270 self.filterless_chain = {
1287 def tearDown(self): argument
1288 self.vm.shutdown()
1294 def test_cor(self): argument
1295 self.vm.cmd('blockdev-add', {
1298 'file': self.filterless_chain
1301 self.vm.cmd('blockdev-mirror',
1307 self.complete_and_wait('mirror')
1309 self.vm.qmp('blockdev-del', node_name='target')
1321 def test_implicit_mirror_filter(self): argument
1322 self.vm.cmd('blockdev-add', self.filterless_chain)
1325 self.vm.cmd('device_add',
1331 self.vm.cmd('blockdev-mirror',
1339 blockdevs = self.vm.qmp('query-block')['return']
1348 self.complete_and_wait('mirror')
1350 def test_explicit_mirror_filter(self): argument
1353 self.vm.cmd('blockdev-add', self.filterless_chain)
1356 self.vm.cmd('device_add',
1362 self.vm.cmd('blockdev-mirror',
1371 blockdevs = self.vm.qmp('query-block')['return']
1376 self.complete_and_wait('mirror')