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 TestSingleDriveZeroLength(TestSingleDrive): 211 image_len = 0 212 test_small_buffer2 = None 213 test_large_cluster = None 214 215class TestSingleBlockdevZeroLength(TestSingleBlockdev): 216 image_len = 0 217 218class TestSingleDriveUnalignedLength(TestSingleDrive): 219 image_len = 1025 * 1024 220 test_small_buffer2 = None 221 test_large_cluster = None 222 223class TestSingleBlockdevUnalignedLength(TestSingleBlockdev): 224 image_len = 1025 * 1024 225 226class TestMirrorNoBacking(iotests.QMPTestCase): 227 image_len = 2 * 1024 * 1024 # MB 228 229 def setUp(self): 230 iotests.create_image(backing_img, TestMirrorNoBacking.image_len) 231 qemu_img('create', '-f', iotests.imgfmt, '-o', 'backing_file=%s' % backing_img, test_img) 232 self.vm = iotests.VM().add_drive(test_img) 233 self.vm.launch() 234 235 def tearDown(self): 236 self.vm.shutdown() 237 os.remove(test_img) 238 os.remove(backing_img) 239 try: 240 os.remove(target_backing_img) 241 except: 242 pass 243 os.remove(target_img) 244 245 def test_complete(self): 246 self.assert_no_active_block_jobs() 247 248 qemu_img('create', '-f', iotests.imgfmt, '-o', 'backing_file=%s' % backing_img, target_img) 249 result = self.vm.qmp('drive-mirror', device='drive0', sync='full', 250 mode='existing', target=target_img) 251 self.assert_qmp(result, 'return', {}) 252 253 self.complete_and_wait() 254 result = self.vm.qmp('query-block') 255 self.assert_qmp(result, 'return[0]/inserted/file', target_img) 256 self.vm.shutdown() 257 self.assertTrue(iotests.compare_images(test_img, target_img), 258 'target image does not match source after mirroring') 259 260 def test_cancel(self): 261 self.assert_no_active_block_jobs() 262 263 qemu_img('create', '-f', iotests.imgfmt, '-o', 'backing_file=%s' % backing_img, target_img) 264 result = self.vm.qmp('drive-mirror', device='drive0', sync='full', 265 mode='existing', target=target_img) 266 self.assert_qmp(result, 'return', {}) 267 268 self.wait_ready_and_cancel() 269 result = self.vm.qmp('query-block') 270 self.assert_qmp(result, 'return[0]/inserted/file', test_img) 271 self.vm.shutdown() 272 self.assertTrue(iotests.compare_images(test_img, target_img), 273 'target image does not match source after mirroring') 274 275 def test_large_cluster(self): 276 self.assert_no_active_block_jobs() 277 278 # qemu-img create fails if the image is not there 279 qemu_img('create', '-f', iotests.imgfmt, '-o', 'size=%d' 280 %(TestMirrorNoBacking.image_len), target_backing_img) 281 qemu_img('create', '-f', iotests.imgfmt, '-o', 'cluster_size=%d,backing_file=%s' 282 % (TestMirrorNoBacking.image_len, target_backing_img), target_img) 283 284 result = self.vm.qmp('drive-mirror', device='drive0', sync='full', 285 mode='existing', target=target_img) 286 self.assert_qmp(result, 'return', {}) 287 288 self.complete_and_wait() 289 result = self.vm.qmp('query-block') 290 self.assert_qmp(result, 'return[0]/inserted/file', target_img) 291 self.vm.shutdown() 292 self.assertTrue(iotests.compare_images(test_img, target_img), 293 'target image does not match source after mirroring') 294 295class TestMirrorResized(iotests.QMPTestCase): 296 backing_len = 1 * 1024 * 1024 # MB 297 image_len = 2 * 1024 * 1024 # MB 298 299 def setUp(self): 300 iotests.create_image(backing_img, TestMirrorResized.backing_len) 301 qemu_img('create', '-f', iotests.imgfmt, '-o', 'backing_file=%s' % backing_img, test_img) 302 qemu_img('resize', test_img, '2M') 303 self.vm = iotests.VM().add_drive(test_img) 304 self.vm.launch() 305 306 def tearDown(self): 307 self.vm.shutdown() 308 os.remove(test_img) 309 os.remove(backing_img) 310 try: 311 os.remove(target_img) 312 except OSError: 313 pass 314 315 def test_complete_top(self): 316 self.assert_no_active_block_jobs() 317 318 result = self.vm.qmp('drive-mirror', device='drive0', sync='top', 319 target=target_img) 320 self.assert_qmp(result, 'return', {}) 321 322 self.complete_and_wait() 323 result = self.vm.qmp('query-block') 324 self.assert_qmp(result, 'return[0]/inserted/file', target_img) 325 self.vm.shutdown() 326 self.assertTrue(iotests.compare_images(test_img, target_img), 327 'target image does not match source after mirroring') 328 329 def test_complete_full(self): 330 self.assert_no_active_block_jobs() 331 332 result = self.vm.qmp('drive-mirror', device='drive0', sync='full', 333 target=target_img) 334 self.assert_qmp(result, 'return', {}) 335 336 self.complete_and_wait() 337 result = self.vm.qmp('query-block') 338 self.assert_qmp(result, 'return[0]/inserted/file', target_img) 339 self.vm.shutdown() 340 self.assertTrue(iotests.compare_images(test_img, target_img), 341 'target image does not match source after mirroring') 342 343class TestReadErrors(iotests.QMPTestCase): 344 image_len = 2 * 1024 * 1024 # MB 345 346 # this should be a multiple of twice the default granularity 347 # so that we hit this offset first in state 1 348 MIRROR_GRANULARITY = 1024 * 1024 349 350 def create_blkdebug_file(self, name, event, errno): 351 file = open(name, 'w') 352 file.write(''' 353[inject-error] 354state = "1" 355event = "%s" 356errno = "%d" 357immediately = "off" 358once = "on" 359sector = "%d" 360 361[set-state] 362state = "1" 363event = "%s" 364new_state = "2" 365 366[set-state] 367state = "2" 368event = "%s" 369new_state = "1" 370''' % (event, errno, self.MIRROR_GRANULARITY / 512, event, event)) 371 file.close() 372 373 def setUp(self): 374 self.blkdebug_file = backing_img + ".blkdebug" 375 iotests.create_image(backing_img, TestReadErrors.image_len) 376 self.create_blkdebug_file(self.blkdebug_file, "read_aio", 5) 377 qemu_img('create', '-f', iotests.imgfmt, 378 '-o', 'backing_file=blkdebug:%s:%s,backing_fmt=raw' 379 % (self.blkdebug_file, backing_img), 380 test_img) 381 # Write something for tests that use sync='top' 382 qemu_io('-c', 'write %d 512' % (self.MIRROR_GRANULARITY + 65536), 383 test_img) 384 self.vm = iotests.VM().add_drive(test_img) 385 self.vm.launch() 386 387 def tearDown(self): 388 self.vm.shutdown() 389 os.remove(test_img) 390 os.remove(backing_img) 391 os.remove(self.blkdebug_file) 392 393 def test_report_read(self): 394 self.assert_no_active_block_jobs() 395 396 result = self.vm.qmp('drive-mirror', device='drive0', sync='full', 397 target=target_img) 398 self.assert_qmp(result, 'return', {}) 399 400 completed = False 401 error = False 402 while not completed: 403 for event in self.vm.get_qmp_events(wait=True): 404 if event['event'] == 'BLOCK_JOB_ERROR': 405 self.assert_qmp(event, 'data/device', 'drive0') 406 self.assert_qmp(event, 'data/operation', 'read') 407 error = True 408 elif event['event'] == 'BLOCK_JOB_READY': 409 self.assertTrue(False, 'job completed unexpectedly') 410 elif event['event'] == 'BLOCK_JOB_COMPLETED': 411 self.assertTrue(error, 'job completed unexpectedly') 412 self.assert_qmp(event, 'data/type', 'mirror') 413 self.assert_qmp(event, 'data/device', 'drive0') 414 self.assert_qmp(event, 'data/error', 'Input/output error') 415 completed = True 416 417 self.assert_no_active_block_jobs() 418 self.vm.shutdown() 419 420 def test_ignore_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, on_source_error='ignore') 425 self.assert_qmp(result, 'return', {}) 426 427 event = self.vm.get_qmp_event(wait=True) 428 self.assertEquals(event['event'], 'BLOCK_JOB_ERROR') 429 self.assert_qmp(event, 'data/device', 'drive0') 430 self.assert_qmp(event, 'data/operation', 'read') 431 result = self.vm.qmp('query-block-jobs') 432 self.assert_qmp(result, 'return[0]/paused', False) 433 self.complete_and_wait() 434 self.vm.shutdown() 435 436 def test_large_cluster(self): 437 self.assert_no_active_block_jobs() 438 439 # Test COW into the target image. The first half of the 440 # cluster at MIRROR_GRANULARITY has to be copied from 441 # backing_img, even though sync='top'. 442 qemu_img('create', '-f', iotests.imgfmt, '-ocluster_size=131072,backing_file=%s' %(backing_img), target_img) 443 result = self.vm.qmp('drive-mirror', device='drive0', sync='top', 444 on_source_error='ignore', 445 mode='existing', target=target_img) 446 self.assert_qmp(result, 'return', {}) 447 448 event = self.vm.get_qmp_event(wait=True) 449 self.assertEquals(event['event'], 'BLOCK_JOB_ERROR') 450 self.assert_qmp(event, 'data/device', 'drive0') 451 self.assert_qmp(event, 'data/operation', 'read') 452 result = self.vm.qmp('query-block-jobs') 453 self.assert_qmp(result, 'return[0]/paused', False) 454 self.complete_and_wait() 455 self.vm.shutdown() 456 457 # Detach blkdebug to compare images successfully 458 qemu_img('rebase', '-f', iotests.imgfmt, '-u', '-b', backing_img, test_img) 459 self.assertTrue(iotests.compare_images(test_img, target_img), 460 'target image does not match source after mirroring') 461 462 def test_stop_read(self): 463 self.assert_no_active_block_jobs() 464 465 result = self.vm.qmp('drive-mirror', device='drive0', sync='full', 466 target=target_img, on_source_error='stop') 467 self.assert_qmp(result, 'return', {}) 468 469 error = False 470 ready = False 471 while not ready: 472 for event in self.vm.get_qmp_events(wait=True): 473 if event['event'] == 'BLOCK_JOB_ERROR': 474 self.assert_qmp(event, 'data/device', 'drive0') 475 self.assert_qmp(event, 'data/operation', 'read') 476 477 result = self.vm.qmp('query-block-jobs') 478 self.assert_qmp(result, 'return[0]/paused', True) 479 self.assert_qmp(result, 'return[0]/io-status', 'failed') 480 481 result = self.vm.qmp('block-job-resume', device='drive0') 482 self.assert_qmp(result, 'return', {}) 483 error = True 484 elif event['event'] == 'BLOCK_JOB_READY': 485 self.assertTrue(error, 'job completed unexpectedly') 486 self.assert_qmp(event, 'data/device', 'drive0') 487 ready = True 488 489 result = self.vm.qmp('query-block-jobs') 490 self.assert_qmp(result, 'return[0]/paused', False) 491 self.assert_qmp(result, 'return[0]/io-status', 'ok') 492 493 self.complete_and_wait(wait_ready=False) 494 self.assert_no_active_block_jobs() 495 self.vm.shutdown() 496 497class TestWriteErrors(iotests.QMPTestCase): 498 image_len = 2 * 1024 * 1024 # MB 499 500 # this should be a multiple of twice the default granularity 501 # so that we hit this offset first in state 1 502 MIRROR_GRANULARITY = 1024 * 1024 503 504 def create_blkdebug_file(self, name, event, errno): 505 file = open(name, 'w') 506 file.write(''' 507[inject-error] 508state = "1" 509event = "%s" 510errno = "%d" 511immediately = "off" 512once = "on" 513sector = "%d" 514 515[set-state] 516state = "1" 517event = "%s" 518new_state = "2" 519 520[set-state] 521state = "2" 522event = "%s" 523new_state = "1" 524''' % (event, errno, self.MIRROR_GRANULARITY / 512, event, event)) 525 file.close() 526 527 def setUp(self): 528 self.blkdebug_file = target_img + ".blkdebug" 529 iotests.create_image(backing_img, TestWriteErrors.image_len) 530 self.create_blkdebug_file(self.blkdebug_file, "write_aio", 5) 531 qemu_img('create', '-f', iotests.imgfmt, '-obacking_file=%s' %(backing_img), test_img) 532 self.vm = iotests.VM().add_drive(test_img) 533 self.target_img = 'blkdebug:%s:%s' % (self.blkdebug_file, target_img) 534 qemu_img('create', '-f', iotests.imgfmt, '-osize=%d' %(TestWriteErrors.image_len), target_img) 535 self.vm.launch() 536 537 def tearDown(self): 538 self.vm.shutdown() 539 os.remove(test_img) 540 os.remove(backing_img) 541 os.remove(self.blkdebug_file) 542 543 def test_report_write(self): 544 self.assert_no_active_block_jobs() 545 546 result = self.vm.qmp('drive-mirror', device='drive0', sync='full', 547 mode='existing', target=self.target_img) 548 self.assert_qmp(result, 'return', {}) 549 550 completed = False 551 error = False 552 while not completed: 553 for event in self.vm.get_qmp_events(wait=True): 554 if event['event'] == 'BLOCK_JOB_ERROR': 555 self.assert_qmp(event, 'data/device', 'drive0') 556 self.assert_qmp(event, 'data/operation', 'write') 557 error = True 558 elif event['event'] == 'BLOCK_JOB_READY': 559 self.assertTrue(False, 'job completed unexpectedly') 560 elif event['event'] == 'BLOCK_JOB_COMPLETED': 561 self.assertTrue(error, 'job completed unexpectedly') 562 self.assert_qmp(event, 'data/type', 'mirror') 563 self.assert_qmp(event, 'data/device', 'drive0') 564 self.assert_qmp(event, 'data/error', 'Input/output error') 565 completed = True 566 567 self.assert_no_active_block_jobs() 568 self.vm.shutdown() 569 570 def test_ignore_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 on_target_error='ignore') 576 self.assert_qmp(result, 'return', {}) 577 578 event = self.vm.get_qmp_event(wait=True) 579 self.assertEquals(event['event'], 'BLOCK_JOB_ERROR') 580 self.assert_qmp(event, 'data/device', 'drive0') 581 self.assert_qmp(event, 'data/operation', 'write') 582 result = self.vm.qmp('query-block-jobs') 583 self.assert_qmp(result, 'return[0]/paused', False) 584 self.complete_and_wait() 585 self.vm.shutdown() 586 587 def test_stop_write(self): 588 self.assert_no_active_block_jobs() 589 590 result = self.vm.qmp('drive-mirror', device='drive0', sync='full', 591 mode='existing', target=self.target_img, 592 on_target_error='stop') 593 self.assert_qmp(result, 'return', {}) 594 595 error = False 596 ready = False 597 while not ready: 598 for event in self.vm.get_qmp_events(wait=True): 599 if event['event'] == 'BLOCK_JOB_ERROR': 600 self.assert_qmp(event, 'data/device', 'drive0') 601 self.assert_qmp(event, 'data/operation', 'write') 602 603 result = self.vm.qmp('query-block-jobs') 604 self.assert_qmp(result, 'return[0]/paused', True) 605 self.assert_qmp(result, 'return[0]/io-status', 'failed') 606 607 result = self.vm.qmp('block-job-resume', device='drive0') 608 self.assert_qmp(result, 'return', {}) 609 610 result = self.vm.qmp('query-block-jobs') 611 self.assert_qmp(result, 'return[0]/paused', False) 612 self.assert_qmp(result, 'return[0]/io-status', 'ok') 613 error = True 614 elif event['event'] == 'BLOCK_JOB_READY': 615 self.assertTrue(error, 'job completed unexpectedly') 616 self.assert_qmp(event, 'data/device', 'drive0') 617 ready = True 618 619 self.complete_and_wait(wait_ready=False) 620 self.assert_no_active_block_jobs() 621 self.vm.shutdown() 622 623class TestSetSpeed(iotests.QMPTestCase): 624 image_len = 80 * 1024 * 1024 # MB 625 626 def setUp(self): 627 qemu_img('create', backing_img, str(TestSetSpeed.image_len)) 628 qemu_img('create', '-f', iotests.imgfmt, '-o', 'backing_file=%s' % backing_img, test_img) 629 self.vm = iotests.VM().add_drive(test_img) 630 self.vm.launch() 631 632 def tearDown(self): 633 self.vm.shutdown() 634 os.remove(test_img) 635 os.remove(backing_img) 636 os.remove(target_img) 637 638 def test_set_speed(self): 639 self.assert_no_active_block_jobs() 640 641 result = self.vm.qmp('drive-mirror', device='drive0', sync='full', 642 target=target_img) 643 self.assert_qmp(result, 'return', {}) 644 645 # Default speed is 0 646 result = self.vm.qmp('query-block-jobs') 647 self.assert_qmp(result, 'return[0]/device', 'drive0') 648 self.assert_qmp(result, 'return[0]/speed', 0) 649 650 result = self.vm.qmp('block-job-set-speed', device='drive0', speed=8 * 1024 * 1024) 651 self.assert_qmp(result, 'return', {}) 652 653 # Ensure the speed we set was accepted 654 result = self.vm.qmp('query-block-jobs') 655 self.assert_qmp(result, 'return[0]/device', 'drive0') 656 self.assert_qmp(result, 'return[0]/speed', 8 * 1024 * 1024) 657 658 self.wait_ready_and_cancel() 659 660 # Check setting speed in drive-mirror works 661 result = self.vm.qmp('drive-mirror', device='drive0', sync='full', 662 target=target_img, speed=4*1024*1024) 663 self.assert_qmp(result, 'return', {}) 664 665 result = self.vm.qmp('query-block-jobs') 666 self.assert_qmp(result, 'return[0]/device', 'drive0') 667 self.assert_qmp(result, 'return[0]/speed', 4 * 1024 * 1024) 668 669 self.wait_ready_and_cancel() 670 671 def test_set_speed_invalid(self): 672 self.assert_no_active_block_jobs() 673 674 result = self.vm.qmp('drive-mirror', device='drive0', sync='full', 675 target=target_img, speed=-1) 676 self.assert_qmp(result, 'error/class', 'GenericError') 677 678 self.assert_no_active_block_jobs() 679 680 result = self.vm.qmp('drive-mirror', device='drive0', sync='full', 681 target=target_img) 682 self.assert_qmp(result, 'return', {}) 683 684 result = self.vm.qmp('block-job-set-speed', device='drive0', speed=-1) 685 self.assert_qmp(result, 'error/class', 'GenericError') 686 687 self.wait_ready_and_cancel() 688 689class TestUnbackedSource(iotests.QMPTestCase): 690 image_len = 2 * 1024 * 1024 # MB 691 692 def setUp(self): 693 qemu_img('create', '-f', iotests.imgfmt, test_img, 694 str(TestUnbackedSource.image_len)) 695 self.vm = iotests.VM().add_drive(test_img) 696 self.vm.launch() 697 698 def tearDown(self): 699 self.vm.shutdown() 700 os.remove(test_img) 701 os.remove(target_img) 702 703 def test_absolute_paths_full(self): 704 self.assert_no_active_block_jobs() 705 result = self.vm.qmp('drive-mirror', device='drive0', 706 sync='full', target=target_img, 707 mode='absolute-paths') 708 self.assert_qmp(result, 'return', {}) 709 self.complete_and_wait() 710 self.assert_no_active_block_jobs() 711 712 def test_absolute_paths_top(self): 713 self.assert_no_active_block_jobs() 714 result = self.vm.qmp('drive-mirror', device='drive0', 715 sync='top', target=target_img, 716 mode='absolute-paths') 717 self.assert_qmp(result, 'return', {}) 718 self.complete_and_wait() 719 self.assert_no_active_block_jobs() 720 721 def test_absolute_paths_none(self): 722 self.assert_no_active_block_jobs() 723 result = self.vm.qmp('drive-mirror', device='drive0', 724 sync='none', target=target_img, 725 mode='absolute-paths') 726 self.assert_qmp(result, 'return', {}) 727 self.complete_and_wait() 728 self.assert_no_active_block_jobs() 729 730class TestGranularity(iotests.QMPTestCase): 731 image_len = 10 * 1024 * 1024 # MB 732 733 def setUp(self): 734 qemu_img('create', '-f', iotests.imgfmt, test_img, 735 str(TestGranularity.image_len)) 736 qemu_io('-c', 'write 0 %d' % (self.image_len), 737 test_img) 738 self.vm = iotests.VM().add_drive(test_img) 739 self.vm.launch() 740 741 def tearDown(self): 742 self.vm.shutdown() 743 self.assertTrue(iotests.compare_images(test_img, target_img), 744 'target image does not match source after mirroring') 745 os.remove(test_img) 746 os.remove(target_img) 747 748 def test_granularity(self): 749 self.assert_no_active_block_jobs() 750 result = self.vm.qmp('drive-mirror', device='drive0', 751 sync='full', target=target_img, 752 mode='absolute-paths', granularity=8192) 753 self.assert_qmp(result, 'return', {}) 754 event = self.vm.get_qmp_event(wait=60.0) 755 # Failures will manifest as COMPLETED/ERROR. 756 self.assert_qmp(event, 'event', 'BLOCK_JOB_READY') 757 self.complete_and_wait(drive='drive0', wait_ready=False) 758 self.assert_no_active_block_jobs() 759 760class TestRepairQuorum(iotests.QMPTestCase): 761 """ This class test quorum file repair using drive-mirror. 762 It's mostly a fork of TestSingleDrive """ 763 image_len = 1 * 1024 * 1024 # MB 764 IMAGES = [ quorum_img1, quorum_img2, quorum_img3 ] 765 766 def has_quorum(self): 767 return 'quorum' in iotests.qemu_img_pipe('--help') 768 769 def setUp(self): 770 self.vm = iotests.VM() 771 772 if iotests.qemu_default_machine == 'pc': 773 self.vm.add_drive(None, 'media=cdrom', 'ide') 774 775 # Add each individual quorum images 776 for i in self.IMAGES: 777 qemu_img('create', '-f', iotests.imgfmt, i, 778 str(TestSingleDrive.image_len)) 779 # Assign a node name to each quorum image in order to manipulate 780 # them 781 opts = "node-name=img%i" % self.IMAGES.index(i) 782 self.vm = self.vm.add_drive(i, opts) 783 784 self.vm.launch() 785 786 #assemble the quorum block device from the individual files 787 args = { "options" : { "driver": "quorum", "id": "quorum0", 788 "vote-threshold": 2, "children": [ "img0", "img1", "img2" ] } } 789 if self.has_quorum(): 790 result = self.vm.qmp("blockdev-add", **args) 791 self.assert_qmp(result, 'return', {}) 792 793 794 def tearDown(self): 795 self.vm.shutdown() 796 for i in self.IMAGES + [ quorum_repair_img ]: 797 # Do a try/except because the test may have deleted some images 798 try: 799 os.remove(i) 800 except OSError: 801 pass 802 803 def test_complete(self): 804 if not self.has_quorum(): 805 return 806 807 self.assert_no_active_block_jobs() 808 809 result = self.vm.qmp('drive-mirror', device='quorum0', sync='full', 810 node_name="repair0", 811 replaces="img1", 812 target=quorum_repair_img, format=iotests.imgfmt) 813 self.assert_qmp(result, 'return', {}) 814 815 self.complete_and_wait(drive="quorum0") 816 self.assert_has_block_node("repair0", quorum_repair_img) 817 # TODO: a better test requiring some QEMU infrastructure will be added 818 # to check that this file is really driven by quorum 819 self.vm.shutdown() 820 self.assertTrue(iotests.compare_images(quorum_img2, quorum_repair_img), 821 'target image does not match source after mirroring') 822 823 def test_cancel(self): 824 if not self.has_quorum(): 825 return 826 827 self.assert_no_active_block_jobs() 828 829 result = self.vm.qmp('drive-mirror', device='quorum0', sync='full', 830 node_name="repair0", 831 replaces="img1", 832 target=quorum_repair_img, format=iotests.imgfmt) 833 self.assert_qmp(result, 'return', {}) 834 835 self.cancel_and_wait(drive="quorum0", force=True) 836 # here we check that the last registered quorum file has not been 837 # swapped out and unref 838 self.assert_has_block_node(None, quorum_img3) 839 self.vm.shutdown() 840 841 def test_cancel_after_ready(self): 842 if not self.has_quorum(): 843 return 844 845 self.assert_no_active_block_jobs() 846 847 result = self.vm.qmp('drive-mirror', device='quorum0', sync='full', 848 node_name="repair0", 849 replaces="img1", 850 target=quorum_repair_img, format=iotests.imgfmt) 851 self.assert_qmp(result, 'return', {}) 852 853 self.wait_ready_and_cancel(drive="quorum0") 854 # here we check that the last registered quorum file has not been 855 # swapped out and unref 856 self.assert_has_block_node(None, quorum_img3) 857 self.vm.shutdown() 858 self.assertTrue(iotests.compare_images(quorum_img2, quorum_repair_img), 859 'target image does not match source after mirroring') 860 861 def test_pause(self): 862 if not self.has_quorum(): 863 return 864 865 self.assert_no_active_block_jobs() 866 867 result = self.vm.qmp('drive-mirror', device='quorum0', sync='full', 868 node_name="repair0", 869 replaces="img1", 870 target=quorum_repair_img, format=iotests.imgfmt) 871 self.assert_qmp(result, 'return', {}) 872 873 result = self.vm.qmp('block-job-pause', device='quorum0') 874 self.assert_qmp(result, 'return', {}) 875 876 time.sleep(1) 877 result = self.vm.qmp('query-block-jobs') 878 offset = self.dictpath(result, 'return[0]/offset') 879 880 time.sleep(1) 881 result = self.vm.qmp('query-block-jobs') 882 self.assert_qmp(result, 'return[0]/offset', offset) 883 884 result = self.vm.qmp('block-job-resume', device='quorum0') 885 self.assert_qmp(result, 'return', {}) 886 887 self.complete_and_wait(drive="quorum0") 888 self.vm.shutdown() 889 self.assertTrue(iotests.compare_images(quorum_img2, quorum_repair_img), 890 'target image does not match source after mirroring') 891 892 def test_medium_not_found(self): 893 if not self.has_quorum(): 894 return 895 896 if iotests.qemu_default_machine != 'pc': 897 return 898 899 result = self.vm.qmp('drive-mirror', device='drive0', # CD-ROM 900 sync='full', 901 node_name='repair0', 902 replaces='img1', 903 target=quorum_repair_img, format=iotests.imgfmt) 904 self.assert_qmp(result, 'error/class', 'GenericError') 905 906 def test_image_not_found(self): 907 if not self.has_quorum(): 908 return 909 910 result = self.vm.qmp('drive-mirror', device='quorum0', sync='full', 911 node_name='repair0', 912 replaces='img1', 913 mode='existing', 914 target=quorum_repair_img, format=iotests.imgfmt) 915 self.assert_qmp(result, 'error/class', 'GenericError') 916 917 def test_device_not_found(self): 918 if not self.has_quorum(): 919 return 920 921 result = self.vm.qmp('drive-mirror', device='nonexistent', sync='full', 922 node_name='repair0', 923 replaces='img1', 924 target=quorum_repair_img, format=iotests.imgfmt) 925 self.assert_qmp(result, 'error/class', 'DeviceNotFound') 926 927 def test_wrong_sync_mode(self): 928 if not self.has_quorum(): 929 return 930 931 result = self.vm.qmp('drive-mirror', device='quorum0', 932 node_name='repair0', 933 replaces='img1', 934 target=quorum_repair_img, format=iotests.imgfmt) 935 self.assert_qmp(result, 'error/class', 'GenericError') 936 937 def test_no_node_name(self): 938 if not self.has_quorum(): 939 return 940 941 result = self.vm.qmp('drive-mirror', device='quorum0', sync='full', 942 replaces='img1', 943 target=quorum_repair_img, format=iotests.imgfmt) 944 self.assert_qmp(result, 'error/class', 'GenericError') 945 946 def test_nonexistent_replaces(self): 947 if not self.has_quorum(): 948 return 949 950 result = self.vm.qmp('drive-mirror', device='quorum0', sync='full', 951 node_name='repair0', 952 replaces='img77', 953 target=quorum_repair_img, format=iotests.imgfmt) 954 self.assert_qmp(result, 'error/class', 'GenericError') 955 956 def test_after_a_quorum_snapshot(self): 957 if not self.has_quorum(): 958 return 959 960 result = self.vm.qmp('blockdev-snapshot-sync', node_name='img1', 961 snapshot_file=quorum_snapshot_file, 962 snapshot_node_name="snap1"); 963 964 result = self.vm.qmp('drive-mirror', device='quorum0', sync='full', 965 node_name='repair0', 966 replaces="img1", 967 target=quorum_repair_img, format=iotests.imgfmt) 968 self.assert_qmp(result, 'error/class', 'GenericError') 969 970 result = self.vm.qmp('drive-mirror', device='quorum0', sync='full', 971 node_name='repair0', 972 replaces="snap1", 973 target=quorum_repair_img, format=iotests.imgfmt) 974 self.assert_qmp(result, 'return', {}) 975 976 self.complete_and_wait(drive="quorum0") 977 self.assert_has_block_node("repair0", quorum_repair_img) 978 # TODO: a better test requiring some QEMU infrastructure will be added 979 # to check that this file is really driven by quorum 980 self.vm.shutdown() 981 982if __name__ == '__main__': 983 iotests.main(supported_fmts=['qcow2', 'qed']) 984