1#!/usr/bin/env python 2# 3# Tests for image mirroring. 4# 5# Copyright (C) 2012 Red Hat, Inc. 6# 7# This program is free software; you can redistribute it and/or modify 8# it under the terms of the GNU General Public License as published by 9# the Free Software Foundation; either version 2 of the License, or 10# (at your option) any later version. 11# 12# This program is distributed in the hope that it will be useful, 13# but WITHOUT ANY WARRANTY; without even the implied warranty of 14# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15# GNU General Public License for more details. 16# 17# You should have received a copy of the GNU General Public License 18# along with this program. If not, see <http://www.gnu.org/licenses/>. 19# 20 21import time 22import os 23import iotests 24from iotests import qemu_img, qemu_io 25 26backing_img = os.path.join(iotests.test_dir, 'backing.img') 27target_backing_img = os.path.join(iotests.test_dir, 'target-backing.img') 28test_img = os.path.join(iotests.test_dir, 'test.img') 29target_img = os.path.join(iotests.test_dir, 'target.img') 30 31quorum_img1 = os.path.join(iotests.test_dir, 'quorum1.img') 32quorum_img2 = os.path.join(iotests.test_dir, 'quorum2.img') 33quorum_img3 = os.path.join(iotests.test_dir, 'quorum3.img') 34quorum_repair_img = os.path.join(iotests.test_dir, 'quorum_repair.img') 35quorum_snapshot_file = os.path.join(iotests.test_dir, 'quorum_snapshot.img') 36 37class TestSingleDrive(iotests.QMPTestCase): 38 image_len = 1 * 1024 * 1024 # MB 39 qmp_cmd = 'drive-mirror' 40 qmp_target = target_img 41 not_found_error = 'DeviceNotFound' 42 43 def setUp(self): 44 iotests.create_image(backing_img, self.image_len) 45 qemu_img('create', '-f', iotests.imgfmt, '-o', 'backing_file=%s' % backing_img, test_img) 46 self.vm = iotests.VM().add_drive(test_img) 47 if iotests.qemu_default_machine == 'pc': 48 self.vm.add_drive(None, 'media=cdrom', 'ide') 49 self.vm.launch() 50 51 def tearDown(self): 52 self.vm.shutdown() 53 os.remove(test_img) 54 os.remove(backing_img) 55 try: 56 os.remove(target_img) 57 except OSError: 58 pass 59 60 def test_complete(self): 61 self.assert_no_active_block_jobs() 62 63 result = self.vm.qmp(self.qmp_cmd, device='drive0', sync='full', 64 target=self.qmp_target) 65 self.assert_qmp(result, 'return', {}) 66 67 self.complete_and_wait() 68 result = self.vm.qmp('query-block') 69 self.assert_qmp(result, 'return[0]/inserted/file', target_img) 70 self.vm.shutdown() 71 self.assertTrue(iotests.compare_images(test_img, target_img), 72 'target image does not match source after mirroring') 73 74 def test_cancel(self): 75 self.assert_no_active_block_jobs() 76 77 result = self.vm.qmp(self.qmp_cmd, device='drive0', sync='full', 78 target=self.qmp_target) 79 self.assert_qmp(result, 'return', {}) 80 81 self.cancel_and_wait(force=True) 82 result = self.vm.qmp('query-block') 83 self.assert_qmp(result, 'return[0]/inserted/file', test_img) 84 self.vm.shutdown() 85 86 def test_cancel_after_ready(self): 87 self.assert_no_active_block_jobs() 88 89 result = self.vm.qmp(self.qmp_cmd, device='drive0', sync='full', 90 target=self.qmp_target) 91 self.assert_qmp(result, 'return', {}) 92 93 self.wait_ready_and_cancel() 94 result = self.vm.qmp('query-block') 95 self.assert_qmp(result, 'return[0]/inserted/file', test_img) 96 self.vm.shutdown() 97 self.assertTrue(iotests.compare_images(test_img, target_img), 98 'target image does not match source after mirroring') 99 100 def test_pause(self): 101 self.assert_no_active_block_jobs() 102 103 result = self.vm.qmp(self.qmp_cmd, device='drive0', sync='full', 104 target=self.qmp_target) 105 self.assert_qmp(result, 'return', {}) 106 107 result = self.vm.qmp('block-job-pause', device='drive0') 108 self.assert_qmp(result, 'return', {}) 109 110 time.sleep(1) 111 result = self.vm.qmp('query-block-jobs') 112 offset = self.dictpath(result, 'return[0]/offset') 113 114 time.sleep(1) 115 result = self.vm.qmp('query-block-jobs') 116 self.assert_qmp(result, 'return[0]/offset', offset) 117 118 result = self.vm.qmp('block-job-resume', device='drive0') 119 self.assert_qmp(result, 'return', {}) 120 121 self.complete_and_wait() 122 self.vm.shutdown() 123 self.assertTrue(iotests.compare_images(test_img, target_img), 124 'target image does not match source after mirroring') 125 126 def test_small_buffer(self): 127 self.assert_no_active_block_jobs() 128 129 # A small buffer is rounded up automatically 130 result = self.vm.qmp(self.qmp_cmd, device='drive0', sync='full', 131 buf_size=4096, target=self.qmp_target) 132 self.assert_qmp(result, 'return', {}) 133 134 self.complete_and_wait() 135 result = self.vm.qmp('query-block') 136 self.assert_qmp(result, 'return[0]/inserted/file', target_img) 137 self.vm.shutdown() 138 self.assertTrue(iotests.compare_images(test_img, target_img), 139 'target image does not match source after mirroring') 140 141 def test_small_buffer2(self): 142 self.assert_no_active_block_jobs() 143 144 qemu_img('create', '-f', iotests.imgfmt, '-o', 'cluster_size=%d,size=%d' 145 % (self.image_len, self.image_len), target_img) 146 result = self.vm.qmp(self.qmp_cmd, device='drive0', sync='full', 147 buf_size=65536, mode='existing', target=self.qmp_target) 148 self.assert_qmp(result, 'return', {}) 149 150 self.complete_and_wait() 151 result = self.vm.qmp('query-block') 152 self.assert_qmp(result, 'return[0]/inserted/file', target_img) 153 self.vm.shutdown() 154 self.assertTrue(iotests.compare_images(test_img, target_img), 155 'target image does not match source after mirroring') 156 157 def test_large_cluster(self): 158 self.assert_no_active_block_jobs() 159 160 qemu_img('create', '-f', iotests.imgfmt, '-o', 'cluster_size=%d,backing_file=%s' 161 % (self.image_len, backing_img), target_img) 162 result = self.vm.qmp(self.qmp_cmd, device='drive0', sync='full', 163 mode='existing', target=self.qmp_target) 164 self.assert_qmp(result, 'return', {}) 165 166 self.complete_and_wait() 167 result = self.vm.qmp('query-block') 168 self.assert_qmp(result, 'return[0]/inserted/file', target_img) 169 self.vm.shutdown() 170 self.assertTrue(iotests.compare_images(test_img, target_img), 171 'target image does not match source after mirroring') 172 173 def test_medium_not_found(self): 174 if iotests.qemu_default_machine != 'pc': 175 return 176 177 result = self.vm.qmp(self.qmp_cmd, device='ide1-cd0', sync='full', 178 target=self.qmp_target) 179 self.assert_qmp(result, 'error/class', self.not_found_error) 180 181 def test_image_not_found(self): 182 result = self.vm.qmp(self.qmp_cmd, device='drive0', sync='full', 183 mode='existing', target=self.qmp_target) 184 self.assert_qmp(result, 'error/class', 'GenericError') 185 186 def test_device_not_found(self): 187 result = self.vm.qmp(self.qmp_cmd, device='nonexistent', sync='full', 188 target=self.qmp_target) 189 self.assert_qmp(result, 'error/class', self.not_found_error) 190 191class TestSingleBlockdev(TestSingleDrive): 192 qmp_cmd = 'blockdev-mirror' 193 qmp_target = 'node1' 194 not_found_error = 'GenericError' 195 196 def setUp(self): 197 TestSingleDrive.setUp(self) 198 qemu_img('create', '-f', iotests.imgfmt, '-o', 'backing_file=%s' % backing_img, target_img) 199 args = {'options': 200 {'driver': iotests.imgfmt, 201 'node-name': self.qmp_target, 202 'file': { 'filename': target_img, 'driver': 'file' } } } 203 result = self.vm.qmp("blockdev-add", **args) 204 self.assert_qmp(result, 'return', {}) 205 206 test_large_cluster = None 207 test_image_not_found = None 208 test_small_buffer2 = None 209 210class TestBlockdevAttached(iotests.QMPTestCase): 211 image_len = 1 * 1024 * 1024 # MB 212 213 def setUp(self): 214 iotests.create_image(backing_img, self.image_len) 215 qemu_img('create', '-f', iotests.imgfmt, '-o', 'backing_file=%s' % backing_img, test_img) 216 qemu_img('create', '-f', iotests.imgfmt, '-o', 'backing_file=%s' % backing_img, target_img) 217 self.vm = iotests.VM().add_drive(test_img) 218 self.vm.launch() 219 220 def tearDown(self): 221 self.vm.shutdown() 222 os.remove(test_img) 223 os.remove(target_img) 224 225 def test_blockdev_attached(self): 226 self.assert_no_active_block_jobs() 227 args = {'options': 228 {'driver': iotests.imgfmt, 229 'id': 'drive1', 230 'file': { 'filename': target_img, 'driver': 'file' } } } 231 result = self.vm.qmp("blockdev-add", **args) 232 self.assert_qmp(result, 'return', {}) 233 result = self.vm.qmp('blockdev-mirror', device='drive0', sync='full', 234 target='drive1') 235 self.assert_qmp(result, 'error/class', 'GenericError') 236 237class TestSingleDriveZeroLength(TestSingleDrive): 238 image_len = 0 239 test_small_buffer2 = None 240 test_large_cluster = None 241 242class TestSingleBlockdevZeroLength(TestSingleBlockdev): 243 image_len = 0 244 245class TestSingleDriveUnalignedLength(TestSingleDrive): 246 image_len = 1025 * 1024 247 test_small_buffer2 = None 248 test_large_cluster = None 249 250class TestSingleBlockdevUnalignedLength(TestSingleBlockdev): 251 image_len = 1025 * 1024 252 253class TestMirrorNoBacking(iotests.QMPTestCase): 254 image_len = 2 * 1024 * 1024 # MB 255 256 def setUp(self): 257 iotests.create_image(backing_img, TestMirrorNoBacking.image_len) 258 qemu_img('create', '-f', iotests.imgfmt, '-o', 'backing_file=%s' % backing_img, test_img) 259 self.vm = iotests.VM().add_drive(test_img) 260 self.vm.launch() 261 262 def tearDown(self): 263 self.vm.shutdown() 264 os.remove(test_img) 265 os.remove(backing_img) 266 try: 267 os.remove(target_backing_img) 268 except: 269 pass 270 os.remove(target_img) 271 272 def test_complete(self): 273 self.assert_no_active_block_jobs() 274 275 qemu_img('create', '-f', iotests.imgfmt, '-o', 'backing_file=%s' % backing_img, target_img) 276 result = self.vm.qmp('drive-mirror', device='drive0', sync='full', 277 mode='existing', target=target_img) 278 self.assert_qmp(result, 'return', {}) 279 280 self.complete_and_wait() 281 result = self.vm.qmp('query-block') 282 self.assert_qmp(result, 'return[0]/inserted/file', target_img) 283 self.vm.shutdown() 284 self.assertTrue(iotests.compare_images(test_img, target_img), 285 'target image does not match source after mirroring') 286 287 def test_cancel(self): 288 self.assert_no_active_block_jobs() 289 290 qemu_img('create', '-f', iotests.imgfmt, '-o', 'backing_file=%s' % backing_img, target_img) 291 result = self.vm.qmp('drive-mirror', device='drive0', sync='full', 292 mode='existing', target=target_img) 293 self.assert_qmp(result, 'return', {}) 294 295 self.wait_ready_and_cancel() 296 result = self.vm.qmp('query-block') 297 self.assert_qmp(result, 'return[0]/inserted/file', test_img) 298 self.vm.shutdown() 299 self.assertTrue(iotests.compare_images(test_img, target_img), 300 'target image does not match source after mirroring') 301 302 def test_large_cluster(self): 303 self.assert_no_active_block_jobs() 304 305 # qemu-img create fails if the image is not there 306 qemu_img('create', '-f', iotests.imgfmt, '-o', 'size=%d' 307 %(TestMirrorNoBacking.image_len), target_backing_img) 308 qemu_img('create', '-f', iotests.imgfmt, '-o', 'cluster_size=%d,backing_file=%s' 309 % (TestMirrorNoBacking.image_len, target_backing_img), target_img) 310 311 result = self.vm.qmp('drive-mirror', device='drive0', sync='full', 312 mode='existing', target=target_img) 313 self.assert_qmp(result, 'return', {}) 314 315 self.complete_and_wait() 316 result = self.vm.qmp('query-block') 317 self.assert_qmp(result, 'return[0]/inserted/file', target_img) 318 self.vm.shutdown() 319 self.assertTrue(iotests.compare_images(test_img, target_img), 320 'target image does not match source after mirroring') 321 322class TestMirrorResized(iotests.QMPTestCase): 323 backing_len = 1 * 1024 * 1024 # MB 324 image_len = 2 * 1024 * 1024 # MB 325 326 def setUp(self): 327 iotests.create_image(backing_img, TestMirrorResized.backing_len) 328 qemu_img('create', '-f', iotests.imgfmt, '-o', 'backing_file=%s' % backing_img, test_img) 329 qemu_img('resize', test_img, '2M') 330 self.vm = iotests.VM().add_drive(test_img) 331 self.vm.launch() 332 333 def tearDown(self): 334 self.vm.shutdown() 335 os.remove(test_img) 336 os.remove(backing_img) 337 try: 338 os.remove(target_img) 339 except OSError: 340 pass 341 342 def test_complete_top(self): 343 self.assert_no_active_block_jobs() 344 345 result = self.vm.qmp('drive-mirror', device='drive0', sync='top', 346 target=target_img) 347 self.assert_qmp(result, 'return', {}) 348 349 self.complete_and_wait() 350 result = self.vm.qmp('query-block') 351 self.assert_qmp(result, 'return[0]/inserted/file', target_img) 352 self.vm.shutdown() 353 self.assertTrue(iotests.compare_images(test_img, target_img), 354 'target image does not match source after mirroring') 355 356 def test_complete_full(self): 357 self.assert_no_active_block_jobs() 358 359 result = self.vm.qmp('drive-mirror', device='drive0', sync='full', 360 target=target_img) 361 self.assert_qmp(result, 'return', {}) 362 363 self.complete_and_wait() 364 result = self.vm.qmp('query-block') 365 self.assert_qmp(result, 'return[0]/inserted/file', target_img) 366 self.vm.shutdown() 367 self.assertTrue(iotests.compare_images(test_img, target_img), 368 'target image does not match source after mirroring') 369 370class TestReadErrors(iotests.QMPTestCase): 371 image_len = 2 * 1024 * 1024 # MB 372 373 # this should be a multiple of twice the default granularity 374 # so that we hit this offset first in state 1 375 MIRROR_GRANULARITY = 1024 * 1024 376 377 def create_blkdebug_file(self, name, event, errno): 378 file = open(name, 'w') 379 file.write(''' 380[inject-error] 381state = "1" 382event = "%s" 383errno = "%d" 384immediately = "off" 385once = "on" 386sector = "%d" 387 388[set-state] 389state = "1" 390event = "%s" 391new_state = "2" 392 393[set-state] 394state = "2" 395event = "%s" 396new_state = "1" 397''' % (event, errno, self.MIRROR_GRANULARITY / 512, event, event)) 398 file.close() 399 400 def setUp(self): 401 self.blkdebug_file = backing_img + ".blkdebug" 402 iotests.create_image(backing_img, TestReadErrors.image_len) 403 self.create_blkdebug_file(self.blkdebug_file, "read_aio", 5) 404 qemu_img('create', '-f', iotests.imgfmt, 405 '-o', 'backing_file=blkdebug:%s:%s,backing_fmt=raw' 406 % (self.blkdebug_file, backing_img), 407 test_img) 408 # Write something for tests that use sync='top' 409 qemu_io('-c', 'write %d 512' % (self.MIRROR_GRANULARITY + 65536), 410 test_img) 411 self.vm = iotests.VM().add_drive(test_img) 412 self.vm.launch() 413 414 def tearDown(self): 415 self.vm.shutdown() 416 os.remove(test_img) 417 os.remove(backing_img) 418 os.remove(self.blkdebug_file) 419 420 def test_report_read(self): 421 self.assert_no_active_block_jobs() 422 423 result = self.vm.qmp('drive-mirror', device='drive0', sync='full', 424 target=target_img) 425 self.assert_qmp(result, 'return', {}) 426 427 completed = False 428 error = False 429 while not completed: 430 for event in self.vm.get_qmp_events(wait=True): 431 if event['event'] == 'BLOCK_JOB_ERROR': 432 self.assert_qmp(event, 'data/device', 'drive0') 433 self.assert_qmp(event, 'data/operation', 'read') 434 error = True 435 elif event['event'] == 'BLOCK_JOB_READY': 436 self.assertTrue(False, 'job completed unexpectedly') 437 elif event['event'] == 'BLOCK_JOB_COMPLETED': 438 self.assertTrue(error, 'job completed unexpectedly') 439 self.assert_qmp(event, 'data/type', 'mirror') 440 self.assert_qmp(event, 'data/device', 'drive0') 441 self.assert_qmp(event, 'data/error', 'Input/output error') 442 completed = True 443 444 self.assert_no_active_block_jobs() 445 self.vm.shutdown() 446 447 def test_ignore_read(self): 448 self.assert_no_active_block_jobs() 449 450 result = self.vm.qmp('drive-mirror', device='drive0', sync='full', 451 target=target_img, on_source_error='ignore') 452 self.assert_qmp(result, 'return', {}) 453 454 event = self.vm.get_qmp_event(wait=True) 455 self.assertEquals(event['event'], 'BLOCK_JOB_ERROR') 456 self.assert_qmp(event, 'data/device', 'drive0') 457 self.assert_qmp(event, 'data/operation', 'read') 458 result = self.vm.qmp('query-block-jobs') 459 self.assert_qmp(result, 'return[0]/paused', False) 460 self.complete_and_wait() 461 self.vm.shutdown() 462 463 def test_large_cluster(self): 464 self.assert_no_active_block_jobs() 465 466 # Test COW into the target image. The first half of the 467 # cluster at MIRROR_GRANULARITY has to be copied from 468 # backing_img, even though sync='top'. 469 qemu_img('create', '-f', iotests.imgfmt, '-ocluster_size=131072,backing_file=%s' %(backing_img), target_img) 470 result = self.vm.qmp('drive-mirror', device='drive0', sync='top', 471 on_source_error='ignore', 472 mode='existing', target=target_img) 473 self.assert_qmp(result, 'return', {}) 474 475 event = self.vm.get_qmp_event(wait=True) 476 self.assertEquals(event['event'], 'BLOCK_JOB_ERROR') 477 self.assert_qmp(event, 'data/device', 'drive0') 478 self.assert_qmp(event, 'data/operation', 'read') 479 result = self.vm.qmp('query-block-jobs') 480 self.assert_qmp(result, 'return[0]/paused', False) 481 self.complete_and_wait() 482 self.vm.shutdown() 483 484 # Detach blkdebug to compare images successfully 485 qemu_img('rebase', '-f', iotests.imgfmt, '-u', '-b', backing_img, test_img) 486 self.assertTrue(iotests.compare_images(test_img, target_img), 487 'target image does not match source after mirroring') 488 489 def test_stop_read(self): 490 self.assert_no_active_block_jobs() 491 492 result = self.vm.qmp('drive-mirror', device='drive0', sync='full', 493 target=target_img, on_source_error='stop') 494 self.assert_qmp(result, 'return', {}) 495 496 error = False 497 ready = False 498 while not ready: 499 for event in self.vm.get_qmp_events(wait=True): 500 if event['event'] == 'BLOCK_JOB_ERROR': 501 self.assert_qmp(event, 'data/device', 'drive0') 502 self.assert_qmp(event, 'data/operation', 'read') 503 504 result = self.vm.qmp('query-block-jobs') 505 self.assert_qmp(result, 'return[0]/paused', True) 506 self.assert_qmp(result, 'return[0]/io-status', 'failed') 507 508 result = self.vm.qmp('block-job-resume', device='drive0') 509 self.assert_qmp(result, 'return', {}) 510 error = True 511 elif event['event'] == 'BLOCK_JOB_READY': 512 self.assertTrue(error, 'job completed unexpectedly') 513 self.assert_qmp(event, 'data/device', 'drive0') 514 ready = True 515 516 result = self.vm.qmp('query-block-jobs') 517 self.assert_qmp(result, 'return[0]/paused', False) 518 self.assert_qmp(result, 'return[0]/io-status', 'ok') 519 520 self.complete_and_wait(wait_ready=False) 521 self.assert_no_active_block_jobs() 522 self.vm.shutdown() 523 524class TestWriteErrors(iotests.QMPTestCase): 525 image_len = 2 * 1024 * 1024 # MB 526 527 # this should be a multiple of twice the default granularity 528 # so that we hit this offset first in state 1 529 MIRROR_GRANULARITY = 1024 * 1024 530 531 def create_blkdebug_file(self, name, event, errno): 532 file = open(name, 'w') 533 file.write(''' 534[inject-error] 535state = "1" 536event = "%s" 537errno = "%d" 538immediately = "off" 539once = "on" 540sector = "%d" 541 542[set-state] 543state = "1" 544event = "%s" 545new_state = "2" 546 547[set-state] 548state = "2" 549event = "%s" 550new_state = "1" 551''' % (event, errno, self.MIRROR_GRANULARITY / 512, event, event)) 552 file.close() 553 554 def setUp(self): 555 self.blkdebug_file = target_img + ".blkdebug" 556 iotests.create_image(backing_img, TestWriteErrors.image_len) 557 self.create_blkdebug_file(self.blkdebug_file, "write_aio", 5) 558 qemu_img('create', '-f', iotests.imgfmt, '-obacking_file=%s' %(backing_img), test_img) 559 self.vm = iotests.VM().add_drive(test_img) 560 self.target_img = 'blkdebug:%s:%s' % (self.blkdebug_file, target_img) 561 qemu_img('create', '-f', iotests.imgfmt, '-osize=%d' %(TestWriteErrors.image_len), target_img) 562 self.vm.launch() 563 564 def tearDown(self): 565 self.vm.shutdown() 566 os.remove(test_img) 567 os.remove(backing_img) 568 os.remove(self.blkdebug_file) 569 570 def test_report_write(self): 571 self.assert_no_active_block_jobs() 572 573 result = self.vm.qmp('drive-mirror', device='drive0', sync='full', 574 mode='existing', target=self.target_img) 575 self.assert_qmp(result, 'return', {}) 576 577 completed = False 578 error = False 579 while not completed: 580 for event in self.vm.get_qmp_events(wait=True): 581 if event['event'] == 'BLOCK_JOB_ERROR': 582 self.assert_qmp(event, 'data/device', 'drive0') 583 self.assert_qmp(event, 'data/operation', 'write') 584 error = True 585 elif event['event'] == 'BLOCK_JOB_READY': 586 self.assertTrue(False, 'job completed unexpectedly') 587 elif event['event'] == 'BLOCK_JOB_COMPLETED': 588 self.assertTrue(error, 'job completed unexpectedly') 589 self.assert_qmp(event, 'data/type', 'mirror') 590 self.assert_qmp(event, 'data/device', 'drive0') 591 self.assert_qmp(event, 'data/error', 'Input/output error') 592 completed = True 593 594 self.assert_no_active_block_jobs() 595 self.vm.shutdown() 596 597 def test_ignore_write(self): 598 self.assert_no_active_block_jobs() 599 600 result = self.vm.qmp('drive-mirror', device='drive0', sync='full', 601 mode='existing', target=self.target_img, 602 on_target_error='ignore') 603 self.assert_qmp(result, 'return', {}) 604 605 event = self.vm.get_qmp_event(wait=True) 606 self.assertEquals(event['event'], 'BLOCK_JOB_ERROR') 607 self.assert_qmp(event, 'data/device', 'drive0') 608 self.assert_qmp(event, 'data/operation', 'write') 609 result = self.vm.qmp('query-block-jobs') 610 self.assert_qmp(result, 'return[0]/paused', False) 611 self.complete_and_wait() 612 self.vm.shutdown() 613 614 def test_stop_write(self): 615 self.assert_no_active_block_jobs() 616 617 result = self.vm.qmp('drive-mirror', device='drive0', sync='full', 618 mode='existing', target=self.target_img, 619 on_target_error='stop') 620 self.assert_qmp(result, 'return', {}) 621 622 error = False 623 ready = False 624 while not ready: 625 for event in self.vm.get_qmp_events(wait=True): 626 if event['event'] == 'BLOCK_JOB_ERROR': 627 self.assert_qmp(event, 'data/device', 'drive0') 628 self.assert_qmp(event, 'data/operation', 'write') 629 630 result = self.vm.qmp('query-block-jobs') 631 self.assert_qmp(result, 'return[0]/paused', True) 632 self.assert_qmp(result, 'return[0]/io-status', 'failed') 633 634 result = self.vm.qmp('block-job-resume', device='drive0') 635 self.assert_qmp(result, 'return', {}) 636 637 result = self.vm.qmp('query-block-jobs') 638 self.assert_qmp(result, 'return[0]/paused', False) 639 self.assert_qmp(result, 'return[0]/io-status', 'ok') 640 error = True 641 elif event['event'] == 'BLOCK_JOB_READY': 642 self.assertTrue(error, 'job completed unexpectedly') 643 self.assert_qmp(event, 'data/device', 'drive0') 644 ready = True 645 646 self.complete_and_wait(wait_ready=False) 647 self.assert_no_active_block_jobs() 648 self.vm.shutdown() 649 650class TestSetSpeed(iotests.QMPTestCase): 651 image_len = 80 * 1024 * 1024 # MB 652 653 def setUp(self): 654 qemu_img('create', backing_img, str(TestSetSpeed.image_len)) 655 qemu_img('create', '-f', iotests.imgfmt, '-o', 'backing_file=%s' % backing_img, test_img) 656 self.vm = iotests.VM().add_drive(test_img) 657 self.vm.launch() 658 659 def tearDown(self): 660 self.vm.shutdown() 661 os.remove(test_img) 662 os.remove(backing_img) 663 os.remove(target_img) 664 665 def test_set_speed(self): 666 self.assert_no_active_block_jobs() 667 668 result = self.vm.qmp('drive-mirror', device='drive0', sync='full', 669 target=target_img) 670 self.assert_qmp(result, 'return', {}) 671 672 # Default speed is 0 673 result = self.vm.qmp('query-block-jobs') 674 self.assert_qmp(result, 'return[0]/device', 'drive0') 675 self.assert_qmp(result, 'return[0]/speed', 0) 676 677 result = self.vm.qmp('block-job-set-speed', device='drive0', speed=8 * 1024 * 1024) 678 self.assert_qmp(result, 'return', {}) 679 680 # Ensure the speed we set was accepted 681 result = self.vm.qmp('query-block-jobs') 682 self.assert_qmp(result, 'return[0]/device', 'drive0') 683 self.assert_qmp(result, 'return[0]/speed', 8 * 1024 * 1024) 684 685 self.wait_ready_and_cancel() 686 687 # Check setting speed in drive-mirror works 688 result = self.vm.qmp('drive-mirror', device='drive0', sync='full', 689 target=target_img, speed=4*1024*1024) 690 self.assert_qmp(result, 'return', {}) 691 692 result = self.vm.qmp('query-block-jobs') 693 self.assert_qmp(result, 'return[0]/device', 'drive0') 694 self.assert_qmp(result, 'return[0]/speed', 4 * 1024 * 1024) 695 696 self.wait_ready_and_cancel() 697 698 def test_set_speed_invalid(self): 699 self.assert_no_active_block_jobs() 700 701 result = self.vm.qmp('drive-mirror', device='drive0', sync='full', 702 target=target_img, speed=-1) 703 self.assert_qmp(result, 'error/class', 'GenericError') 704 705 self.assert_no_active_block_jobs() 706 707 result = self.vm.qmp('drive-mirror', device='drive0', sync='full', 708 target=target_img) 709 self.assert_qmp(result, 'return', {}) 710 711 result = self.vm.qmp('block-job-set-speed', device='drive0', speed=-1) 712 self.assert_qmp(result, 'error/class', 'GenericError') 713 714 self.wait_ready_and_cancel() 715 716class TestUnbackedSource(iotests.QMPTestCase): 717 image_len = 2 * 1024 * 1024 # MB 718 719 def setUp(self): 720 qemu_img('create', '-f', iotests.imgfmt, test_img, 721 str(TestUnbackedSource.image_len)) 722 self.vm = iotests.VM().add_drive(test_img) 723 self.vm.launch() 724 725 def tearDown(self): 726 self.vm.shutdown() 727 os.remove(test_img) 728 os.remove(target_img) 729 730 def test_absolute_paths_full(self): 731 self.assert_no_active_block_jobs() 732 result = self.vm.qmp('drive-mirror', device='drive0', 733 sync='full', target=target_img, 734 mode='absolute-paths') 735 self.assert_qmp(result, 'return', {}) 736 self.complete_and_wait() 737 self.assert_no_active_block_jobs() 738 739 def test_absolute_paths_top(self): 740 self.assert_no_active_block_jobs() 741 result = self.vm.qmp('drive-mirror', device='drive0', 742 sync='top', target=target_img, 743 mode='absolute-paths') 744 self.assert_qmp(result, 'return', {}) 745 self.complete_and_wait() 746 self.assert_no_active_block_jobs() 747 748 def test_absolute_paths_none(self): 749 self.assert_no_active_block_jobs() 750 result = self.vm.qmp('drive-mirror', device='drive0', 751 sync='none', target=target_img, 752 mode='absolute-paths') 753 self.assert_qmp(result, 'return', {}) 754 self.complete_and_wait() 755 self.assert_no_active_block_jobs() 756 757class TestRepairQuorum(iotests.QMPTestCase): 758 """ This class test quorum file repair using drive-mirror. 759 It's mostly a fork of TestSingleDrive """ 760 image_len = 1 * 1024 * 1024 # MB 761 IMAGES = [ quorum_img1, quorum_img2, quorum_img3 ] 762 763 def has_quorum(self): 764 return 'quorum' in iotests.qemu_img_pipe('--help') 765 766 def setUp(self): 767 self.vm = iotests.VM() 768 769 if iotests.qemu_default_machine == 'pc': 770 self.vm.add_drive(None, 'media=cdrom', 'ide') 771 772 # Add each individual quorum images 773 for i in self.IMAGES: 774 qemu_img('create', '-f', iotests.imgfmt, i, 775 str(TestSingleDrive.image_len)) 776 # Assign a node name to each quorum image in order to manipulate 777 # them 778 opts = "node-name=img%i" % self.IMAGES.index(i) 779 self.vm = self.vm.add_drive(i, opts) 780 781 self.vm.launch() 782 783 #assemble the quorum block device from the individual files 784 args = { "options" : { "driver": "quorum", "id": "quorum0", 785 "vote-threshold": 2, "children": [ "img0", "img1", "img2" ] } } 786 if self.has_quorum(): 787 result = self.vm.qmp("blockdev-add", **args) 788 self.assert_qmp(result, 'return', {}) 789 790 791 def tearDown(self): 792 self.vm.shutdown() 793 for i in self.IMAGES + [ quorum_repair_img ]: 794 # Do a try/except because the test may have deleted some images 795 try: 796 os.remove(i) 797 except OSError: 798 pass 799 800 def test_complete(self): 801 if not self.has_quorum(): 802 return 803 804 self.assert_no_active_block_jobs() 805 806 result = self.vm.qmp('drive-mirror', device='quorum0', sync='full', 807 node_name="repair0", 808 replaces="img1", 809 target=quorum_repair_img, format=iotests.imgfmt) 810 self.assert_qmp(result, 'return', {}) 811 812 self.complete_and_wait(drive="quorum0") 813 self.assert_has_block_node("repair0", quorum_repair_img) 814 # TODO: a better test requiring some QEMU infrastructure will be added 815 # to check that this file is really driven by quorum 816 self.vm.shutdown() 817 self.assertTrue(iotests.compare_images(quorum_img2, quorum_repair_img), 818 'target image does not match source after mirroring') 819 820 def test_cancel(self): 821 if not self.has_quorum(): 822 return 823 824 self.assert_no_active_block_jobs() 825 826 result = self.vm.qmp('drive-mirror', device='quorum0', sync='full', 827 node_name="repair0", 828 replaces="img1", 829 target=quorum_repair_img, format=iotests.imgfmt) 830 self.assert_qmp(result, 'return', {}) 831 832 self.cancel_and_wait(drive="quorum0", force=True) 833 # here we check that the last registered quorum file has not been 834 # swapped out and unref 835 self.assert_has_block_node(None, quorum_img3) 836 self.vm.shutdown() 837 838 def test_cancel_after_ready(self): 839 if not self.has_quorum(): 840 return 841 842 self.assert_no_active_block_jobs() 843 844 result = self.vm.qmp('drive-mirror', device='quorum0', sync='full', 845 node_name="repair0", 846 replaces="img1", 847 target=quorum_repair_img, format=iotests.imgfmt) 848 self.assert_qmp(result, 'return', {}) 849 850 self.wait_ready_and_cancel(drive="quorum0") 851 # here we check that the last registered quorum file has not been 852 # swapped out and unref 853 self.assert_has_block_node(None, quorum_img3) 854 self.vm.shutdown() 855 self.assertTrue(iotests.compare_images(quorum_img2, quorum_repair_img), 856 'target image does not match source after mirroring') 857 858 def test_pause(self): 859 if not self.has_quorum(): 860 return 861 862 self.assert_no_active_block_jobs() 863 864 result = self.vm.qmp('drive-mirror', device='quorum0', sync='full', 865 node_name="repair0", 866 replaces="img1", 867 target=quorum_repair_img, format=iotests.imgfmt) 868 self.assert_qmp(result, 'return', {}) 869 870 result = self.vm.qmp('block-job-pause', device='quorum0') 871 self.assert_qmp(result, 'return', {}) 872 873 time.sleep(1) 874 result = self.vm.qmp('query-block-jobs') 875 offset = self.dictpath(result, 'return[0]/offset') 876 877 time.sleep(1) 878 result = self.vm.qmp('query-block-jobs') 879 self.assert_qmp(result, 'return[0]/offset', offset) 880 881 result = self.vm.qmp('block-job-resume', device='quorum0') 882 self.assert_qmp(result, 'return', {}) 883 884 self.complete_and_wait(drive="quorum0") 885 self.vm.shutdown() 886 self.assertTrue(iotests.compare_images(quorum_img2, quorum_repair_img), 887 'target image does not match source after mirroring') 888 889 def test_medium_not_found(self): 890 if not self.has_quorum(): 891 return 892 893 if iotests.qemu_default_machine != 'pc': 894 return 895 896 result = self.vm.qmp('drive-mirror', device='drive0', # CD-ROM 897 sync='full', 898 node_name='repair0', 899 replaces='img1', 900 target=quorum_repair_img, format=iotests.imgfmt) 901 self.assert_qmp(result, 'error/class', 'GenericError') 902 903 def test_image_not_found(self): 904 if not self.has_quorum(): 905 return 906 907 result = self.vm.qmp('drive-mirror', device='quorum0', sync='full', 908 node_name='repair0', 909 replaces='img1', 910 mode='existing', 911 target=quorum_repair_img, format=iotests.imgfmt) 912 self.assert_qmp(result, 'error/class', 'GenericError') 913 914 def test_device_not_found(self): 915 if not self.has_quorum(): 916 return 917 918 result = self.vm.qmp('drive-mirror', device='nonexistent', sync='full', 919 node_name='repair0', 920 replaces='img1', 921 target=quorum_repair_img, format=iotests.imgfmt) 922 self.assert_qmp(result, 'error/class', 'DeviceNotFound') 923 924 def test_wrong_sync_mode(self): 925 if not self.has_quorum(): 926 return 927 928 result = self.vm.qmp('drive-mirror', device='quorum0', 929 node_name='repair0', 930 replaces='img1', 931 target=quorum_repair_img, format=iotests.imgfmt) 932 self.assert_qmp(result, 'error/class', 'GenericError') 933 934 def test_no_node_name(self): 935 if not self.has_quorum(): 936 return 937 938 result = self.vm.qmp('drive-mirror', device='quorum0', sync='full', 939 replaces='img1', 940 target=quorum_repair_img, format=iotests.imgfmt) 941 self.assert_qmp(result, 'error/class', 'GenericError') 942 943 def test_nonexistent_replaces(self): 944 if not self.has_quorum(): 945 return 946 947 result = self.vm.qmp('drive-mirror', device='quorum0', sync='full', 948 node_name='repair0', 949 replaces='img77', 950 target=quorum_repair_img, format=iotests.imgfmt) 951 self.assert_qmp(result, 'error/class', 'GenericError') 952 953 def test_after_a_quorum_snapshot(self): 954 if not self.has_quorum(): 955 return 956 957 result = self.vm.qmp('blockdev-snapshot-sync', node_name='img1', 958 snapshot_file=quorum_snapshot_file, 959 snapshot_node_name="snap1"); 960 961 result = self.vm.qmp('drive-mirror', device='quorum0', sync='full', 962 node_name='repair0', 963 replaces="img1", 964 target=quorum_repair_img, format=iotests.imgfmt) 965 self.assert_qmp(result, 'error/class', 'GenericError') 966 967 result = self.vm.qmp('drive-mirror', device='quorum0', sync='full', 968 node_name='repair0', 969 replaces="snap1", 970 target=quorum_repair_img, format=iotests.imgfmt) 971 self.assert_qmp(result, 'return', {}) 972 973 self.complete_and_wait(drive="quorum0") 974 self.assert_has_block_node("repair0", quorum_repair_img) 975 # TODO: a better test requiring some QEMU infrastructure will be added 976 # to check that this file is really driven by quorum 977 self.vm.shutdown() 978 979if __name__ == '__main__': 980 iotests.main(supported_fmts=['qcow2', 'qed']) 981