tests/qemu-iotests/118

   1 #!/usr/bin/env python
   2 #
   3 # Test case for the QMP 'change' command and all other associated
   4 # commands
   5 #
   6 # Copyright (C) 2015 Red Hat, Inc.
   7 #
   8 # This program is free software; you can redistribute it and/or modify
   9 # it under the terms of the GNU General Public License as published by
  10 # the Free Software Foundation; either version 2 of the License, or
  11 # (at your option) any later version.
  12 #
  13 # This program is distributed in the hope that it will be useful,
  14 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 # GNU General Public License for more details.
  17 #
  18 # You should have received a copy of the GNU General Public License
  19 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20 #
  21
  22 import os
  23 import stat
  24 import time
  25 import iotests
  26 from iotests import qemu_img
  27
  28 old_img = os.path.join(iotests.test_dir, 'test0.img')
  29 new_img = os.path.join(iotests.test_dir, 'test1.img')
  30
  31 class ChangeBaseClass(iotests.QMPTestCase):
  32     has_opened = False
  33     has_closed = False
  34
  35     def process_events(self):
  36         for event in self.vm.get_qmp_events(wait=False):
  37             if (event['event'] == 'DEVICE_TRAY_MOVED' and
  38                 event['data']['device'] == 'drive0'):
  39                 if event['data']['tray-open'] == False:
  40                     self.has_closed = True
  41                 else:
  42                     self.has_opened = True
  43
  44     def wait_for_open(self):
  45         timeout = time.clock() + 3
  46         while not self.has_opened and time.clock() < timeout:
  47             self.process_events()
  48         if not self.has_opened:
  49             self.fail('Timeout while waiting for the tray to open')
  50
  51     def wait_for_close(self):
  52         timeout = time.clock() + 3
  53         while not self.has_closed and time.clock() < timeout:
  54             self.process_events()
  55         if not self.has_opened:
  56             self.fail('Timeout while waiting for the tray to close')
  57
  58 class GeneralChangeTestsBaseClass(ChangeBaseClass):
  59     def test_change(self):
  60         result = self.vm.qmp('change', device='drive0', target=new_img,
  61                                        arg=iotests.imgfmt)
  62         self.assert_qmp(result, 'return', {})
  63
  64         self.wait_for_open()
  65         self.wait_for_close()
  66
  67         result = self.vm.qmp('query-block')
  68         self.assert_qmp(result, 'return[0]/tray_open', False)
  69         self.assert_qmp(result, 'return[0]/inserted/image/filename', new_img)
  70
  71     def test_blockdev_change_medium(self):
  72         result = self.vm.qmp('blockdev-change-medium', device='drive0',
  73                                                        filename=new_img,
  74                                                        format=iotests.imgfmt)
  75         self.assert_qmp(result, 'return', {})
  76
  77         self.wait_for_open()
  78         self.wait_for_close()
  79
  80         result = self.vm.qmp('query-block')
  81         self.assert_qmp(result, 'return[0]/tray_open', False)
  82         self.assert_qmp(result, 'return[0]/inserted/image/filename', new_img)
  83
  84     def test_eject(self):
  85         result = self.vm.qmp('eject', device='drive0', force=True)
  86         self.assert_qmp(result, 'return', {})
  87
  88         self.wait_for_open()
  89
  90         result = self.vm.qmp('query-block')
  91         self.assert_qmp(result, 'return[0]/tray_open', True)
  92         self.assert_qmp_absent(result, 'return[0]/inserted')
  93
  94     def test_tray_eject_change(self):
  95         result = self.vm.qmp('eject', device='drive0', force=True)
  96         self.assert_qmp(result, 'return', {})
  97
  98         self.wait_for_open()
  99
 100         result = self.vm.qmp('query-block')
 101         self.assert_qmp(result, 'return[0]/tray_open', True)
 102         self.assert_qmp_absent(result, 'return[0]/inserted')
 103
 104         result = self.vm.qmp('blockdev-change-medium', device='drive0',
 105                                                        filename=new_img,
 106                                                        format=iotests.imgfmt)
 107         self.assert_qmp(result, 'return', {})
 108
 109         self.wait_for_close()
 110
 111         result = self.vm.qmp('query-block')
 112         self.assert_qmp(result, 'return[0]/tray_open', False)
 113         self.assert_qmp(result, 'return[0]/inserted/image/filename', new_img)
 114
 115     def test_tray_open_close(self):
 116         result = self.vm.qmp('blockdev-open-tray', device='drive0', force=True)
 117         self.assert_qmp(result, 'return', {})
 118
 119         self.wait_for_open()
 120
 121         result = self.vm.qmp('query-block')
 122         self.assert_qmp(result, 'return[0]/tray_open', True)
 123         if self.was_empty == True:
 124             self.assert_qmp_absent(result, 'return[0]/inserted')
 125         else:
 126             self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)
 127
 128         result = self.vm.qmp('blockdev-close-tray', device='drive0')
 129         self.assert_qmp(result, 'return', {})
 130
 131         if self.has_real_tray or not self.was_empty:
 132             self.wait_for_close()
 133
 134         result = self.vm.qmp('query-block')
 135         if self.has_real_tray or not self.was_empty:
 136             self.assert_qmp(result, 'return[0]/tray_open', False)
 137         else:
 138             self.assert_qmp(result, 'return[0]/tray_open', True)
 139         if self.was_empty == True:
 140             self.assert_qmp_absent(result, 'return[0]/inserted')
 141         else:
 142             self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)
 143
 144     def test_tray_eject_close(self):
 145         result = self.vm.qmp('eject', device='drive0', force=True)
 146         self.assert_qmp(result, 'return', {})
 147
 148         self.wait_for_open()
 149
 150         result = self.vm.qmp('query-block')
 151         self.assert_qmp(result, 'return[0]/tray_open', True)
 152         self.assert_qmp_absent(result, 'return[0]/inserted')
 153
 154         result = self.vm.qmp('blockdev-close-tray', device='drive0')
 155         self.assert_qmp(result, 'return', {})
 156
 157         if self.has_real_tray:
 158             self.wait_for_close()
 159
 160         result = self.vm.qmp('query-block')
 161         if self.has_real_tray:
 162             self.assert_qmp(result, 'return[0]/tray_open', False)
 163         else:
 164             self.assert_qmp(result, 'return[0]/tray_open', True)
 165         self.assert_qmp_absent(result, 'return[0]/inserted')
 166
 167     def test_tray_open_change(self):
 168         result = self.vm.qmp('blockdev-open-tray', device='drive0', force=True)
 169         self.assert_qmp(result, 'return', {})
 170
 171         self.wait_for_open()
 172
 173         result = self.vm.qmp('query-block')
 174         self.assert_qmp(result, 'return[0]/tray_open', True)
 175         if self.was_empty == True:
 176             self.assert_qmp_absent(result, 'return[0]/inserted')
 177         else:
 178             self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)
 179
 180         result = self.vm.qmp('blockdev-change-medium', device='drive0',
 181                                                        filename=new_img,
 182                                                        format=iotests.imgfmt)
 183         self.assert_qmp(result, 'return', {})
 184
 185         self.wait_for_close()
 186
 187         result = self.vm.qmp('query-block')
 188         self.assert_qmp(result, 'return[0]/tray_open', False)
 189         self.assert_qmp(result, 'return[0]/inserted/image/filename', new_img)
 190
 191     def test_cycle(self):
 192         result = self.vm.qmp('blockdev-add',
 193                              options={'node-name': 'new',
 194                                       'driver': iotests.imgfmt,
 195                                       'file': {'filename': new_img,
 196                                                'driver': 'file'}})
 197         self.assert_qmp(result, 'return', {})
 198
 199         result = self.vm.qmp('blockdev-open-tray', device='drive0', force=True)
 200         self.assert_qmp(result, 'return', {})
 201
 202         self.wait_for_open()
 203
 204         result = self.vm.qmp('query-block')
 205         self.assert_qmp(result, 'return[0]/tray_open', True)
 206         if self.was_empty == True:
 207             self.assert_qmp_absent(result, 'return[0]/inserted')
 208         else:
 209             self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)
 210
 211         result = self.vm.qmp('x-blockdev-remove-medium', device='drive0')
 212         self.assert_qmp(result, 'return', {})
 213
 214         result = self.vm.qmp('query-block')
 215         self.assert_qmp(result, 'return[0]/tray_open', True)
 216         self.assert_qmp_absent(result, 'return[0]/inserted')
 217
 218         result = self.vm.qmp('x-blockdev-insert-medium', device='drive0',
 219                                                        node_name='new')
 220         self.assert_qmp(result, 'return', {})
 221
 222         result = self.vm.qmp('query-block')
 223         self.assert_qmp(result, 'return[0]/tray_open', True)
 224         self.assert_qmp(result, 'return[0]/inserted/image/filename', new_img)
 225
 226         result = self.vm.qmp('blockdev-close-tray', device='drive0')
 227         self.assert_qmp(result, 'return', {})
 228
 229         self.wait_for_close()
 230
 231         result = self.vm.qmp('query-block')
 232         self.assert_qmp(result, 'return[0]/tray_open', False)
 233         self.assert_qmp(result, 'return[0]/inserted/image/filename', new_img)
 234
 235     def test_close_on_closed(self):
 236         result = self.vm.qmp('blockdev-close-tray', device='drive0')
 237         # Should be a no-op
 238         self.assert_qmp(result, 'return', {})
 239         self.assertEquals(self.vm.get_qmp_events(wait=False), [])
 240
 241     def test_remove_on_closed(self):
 242         if self.has_opened:
 243             # Empty floppy drive
 244             return
 245
 246         result = self.vm.qmp('x-blockdev-remove-medium', device='drive0')
 247         self.assert_qmp(result, 'error/class', 'GenericError')
 248
 249     def test_insert_on_closed(self):
 250         if self.has_opened:
 251             # Empty floppy drive
 252             return
 253
 254         result = self.vm.qmp('blockdev-add',
 255                              options={'node-name': 'new',
 256                                       'driver': iotests.imgfmt,
 257                                       'file': {'filename': new_img,
 258                                                'driver': 'file'}})
 259         self.assert_qmp(result, 'return', {})
 260
 261         result = self.vm.qmp('x-blockdev-insert-medium', device='drive0',
 262                                                        node_name='new')
 263         self.assert_qmp(result, 'error/class', 'GenericError')
 264
 265 class TestInitiallyFilled(GeneralChangeTestsBaseClass):
 266     was_empty = False
 267
 268     def setUp(self, media, interface):
 269         qemu_img('create', '-f', iotests.imgfmt, old_img, '1440k')
 270         qemu_img('create', '-f', iotests.imgfmt, new_img, '1440k')
 271         self.vm = iotests.VM().add_drive(old_img, 'media=%s' % media, interface)
 272         self.vm.launch()
 273
 274     def tearDown(self):
 275         self.vm.shutdown()
 276         os.remove(old_img)
 277         os.remove(new_img)
 278
 279     def test_insert_on_filled(self):
 280         result = self.vm.qmp('blockdev-add',
 281                              options={'node-name': 'new',
 282                                       'driver': iotests.imgfmt,
 283                                       'file': {'filename': new_img,
 284                                                'driver': 'file'}})
 285         self.assert_qmp(result, 'return', {})
 286
 287         result = self.vm.qmp('blockdev-open-tray', device='drive0')
 288         self.assert_qmp(result, 'return', {})
 289
 290         self.wait_for_open()
 291
 292         result = self.vm.qmp('x-blockdev-insert-medium', device='drive0',
 293                                                        node_name='new')
 294         self.assert_qmp(result, 'error/class', 'GenericError')
 295
 296 class TestInitiallyEmpty(GeneralChangeTestsBaseClass):
 297     was_empty = True
 298
 299     def setUp(self, media, interface):
 300         qemu_img('create', '-f', iotests.imgfmt, new_img, '1440k')
 301         self.vm = iotests.VM().add_drive(None, 'media=%s' % media, interface)
 302         self.vm.launch()
 303
 304     def tearDown(self):
 305         self.vm.shutdown()
 306         os.remove(new_img)
 307
 308     def test_remove_on_empty(self):
 309         result = self.vm.qmp('blockdev-open-tray', device='drive0')
 310         self.assert_qmp(result, 'return', {})
 311
 312         self.wait_for_open()
 313
 314         result = self.vm.qmp('x-blockdev-remove-medium', device='drive0')
 315         # Should be a no-op
 316         self.assert_qmp(result, 'return', {})
 317
 318 class TestCDInitiallyFilled(TestInitiallyFilled):
 319     TestInitiallyFilled = TestInitiallyFilled
 320     has_real_tray = True
 321
 322     def setUp(self):
 323         self.TestInitiallyFilled.setUp(self, 'cdrom', 'ide')
 324
 325 class TestCDInitiallyEmpty(TestInitiallyEmpty):
 326     TestInitiallyEmpty = TestInitiallyEmpty
 327     has_real_tray = True
 328
 329     def setUp(self):
 330         self.TestInitiallyEmpty.setUp(self, 'cdrom', 'ide')
 331
 332 class TestFloppyInitiallyFilled(TestInitiallyFilled):
 333     TestInitiallyFilled = TestInitiallyFilled
 334     has_real_tray = False
 335
 336     def setUp(self):
 337         self.TestInitiallyFilled.setUp(self, 'disk', 'floppy')
 338
 339 class TestFloppyInitiallyEmpty(TestInitiallyEmpty):
 340     TestInitiallyEmpty = TestInitiallyEmpty
 341     has_real_tray = False
 342
 343     def setUp(self):
 344         self.TestInitiallyEmpty.setUp(self, 'disk', 'floppy')
 345         # FDDs not having a real tray and there not being a medium inside the
 346         # tray at startup means the tray will be considered open
 347         self.has_opened = True
 348
 349 class TestChangeReadOnly(ChangeBaseClass):
 350     def setUp(self):
 351         qemu_img('create', '-f', iotests.imgfmt, old_img, '1440k')
 352         qemu_img('create', '-f', iotests.imgfmt, new_img, '1440k')
 353         self.vm = iotests.VM()
 354
 355     def tearDown(self):
 356         self.vm.shutdown()
 357         os.chmod(old_img, 0666)
 358         os.chmod(new_img, 0666)
 359         os.remove(old_img)
 360         os.remove(new_img)
 361
 362     def test_ro_ro_retain(self):
 363         os.chmod(old_img, 0444)
 364         os.chmod(new_img, 0444)
 365         self.vm.add_drive(old_img, 'media=disk,read-only=on', 'floppy')
 366         self.vm.launch()
 367
 368         result = self.vm.qmp('query-block')
 369         self.assert_qmp(result, 'return[0]/tray_open', False)
 370         self.assert_qmp(result, 'return[0]/inserted/ro', True)
 371         self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)
 372
 373         result = self.vm.qmp('blockdev-change-medium', device='drive0',
 374                                                        filename=new_img,
 375                                                        format=iotests.imgfmt,
 376                                                        read_only_mode='retain')
 377         self.assert_qmp(result, 'return', {})
 378
 379         self.wait_for_open()
 380         self.wait_for_close()
 381
 382         result = self.vm.qmp('query-block')
 383         self.assert_qmp(result, 'return[0]/tray_open', False)
 384         self.assert_qmp(result, 'return[0]/inserted/ro', True)
 385         self.assert_qmp(result, 'return[0]/inserted/image/filename', new_img)
 386
 387     def test_ro_rw_retain(self):
 388         os.chmod(old_img, 0444)
 389         self.vm.add_drive(old_img, 'media=disk,read-only=on', 'floppy')
 390         self.vm.launch()
 391
 392         result = self.vm.qmp('query-block')
 393         self.assert_qmp(result, 'return[0]/tray_open', False)
 394         self.assert_qmp(result, 'return[0]/inserted/ro', True)
 395         self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)
 396
 397         result = self.vm.qmp('blockdev-change-medium', device='drive0',
 398                                                        filename=new_img,
 399                                                        format=iotests.imgfmt,
 400                                                        read_only_mode='retain')
 401         self.assert_qmp(result, 'return', {})
 402
 403         self.wait_for_open()
 404         self.wait_for_close()
 405
 406         result = self.vm.qmp('query-block')
 407         self.assert_qmp(result, 'return[0]/tray_open', False)
 408         self.assert_qmp(result, 'return[0]/inserted/ro', True)
 409         self.assert_qmp(result, 'return[0]/inserted/image/filename', new_img)
 410
 411     def test_rw_ro_retain(self):
 412         os.chmod(new_img, 0444)
 413         self.vm.add_drive(old_img, 'media=disk', 'floppy')
 414         self.vm.launch()
 415
 416         result = self.vm.qmp('query-block')
 417         self.assert_qmp(result, 'return[0]/tray_open', False)
 418         self.assert_qmp(result, 'return[0]/inserted/ro', False)
 419         self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)
 420
 421         result = self.vm.qmp('blockdev-change-medium', device='drive0',
 422                                                        filename=new_img,
 423                                                        format=iotests.imgfmt,
 424                                                        read_only_mode='retain')
 425         self.assert_qmp(result, 'error/class', 'GenericError')
 426
 427         self.assertEquals(self.vm.get_qmp_events(wait=False), [])
 428
 429         result = self.vm.qmp('query-block')
 430         self.assert_qmp(result, 'return[0]/tray_open', False)
 431         self.assert_qmp(result, 'return[0]/inserted/ro', False)
 432         self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)
 433
 434     def test_ro_rw(self):
 435         os.chmod(old_img, 0444)
 436         self.vm.add_drive(old_img, 'media=disk,read-only=on', 'floppy')
 437         self.vm.launch()
 438
 439         result = self.vm.qmp('query-block')
 440         self.assert_qmp(result, 'return[0]/tray_open', False)
 441         self.assert_qmp(result, 'return[0]/inserted/ro', True)
 442         self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)
 443
 444         result = self.vm.qmp('blockdev-change-medium',
 445                              device='drive0',
 446                              filename=new_img,
 447                              format=iotests.imgfmt,
 448                              read_only_mode='read-write')
 449         self.assert_qmp(result, 'return', {})
 450
 451         self.wait_for_open()
 452         self.wait_for_close()
 453
 454         result = self.vm.qmp('query-block')
 455         self.assert_qmp(result, 'return[0]/tray_open', False)
 456         self.assert_qmp(result, 'return[0]/inserted/ro', False)
 457         self.assert_qmp(result, 'return[0]/inserted/image/filename', new_img)
 458
 459     def test_rw_ro(self):
 460         os.chmod(new_img, 0444)
 461         self.vm.add_drive(old_img, 'media=disk', 'floppy')
 462         self.vm.launch()
 463
 464         result = self.vm.qmp('query-block')
 465         self.assert_qmp(result, 'return[0]/tray_open', False)
 466         self.assert_qmp(result, 'return[0]/inserted/ro', False)
 467         self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)
 468
 469         result = self.vm.qmp('blockdev-change-medium',
 470                              device='drive0',
 471                              filename=new_img,
 472                              format=iotests.imgfmt,
 473                              read_only_mode='read-only')
 474         self.assert_qmp(result, 'return', {})
 475
 476         self.wait_for_open()
 477         self.wait_for_close()
 478
 479         result = self.vm.qmp('query-block')
 480         self.assert_qmp(result, 'return[0]/tray_open', False)
 481         self.assert_qmp(result, 'return[0]/inserted/ro', True)
 482         self.assert_qmp(result, 'return[0]/inserted/image/filename', new_img)
 483
 484     def test_make_rw_ro(self):
 485         self.vm.add_drive(old_img, 'media=disk', 'floppy')
 486         self.vm.launch()
 487
 488         result = self.vm.qmp('query-block')
 489         self.assert_qmp(result, 'return[0]/tray_open', False)
 490         self.assert_qmp(result, 'return[0]/inserted/ro', False)
 491         self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)
 492
 493         result = self.vm.qmp('blockdev-change-medium',
 494                              device='drive0',
 495                              filename=new_img,
 496                              format=iotests.imgfmt,
 497                              read_only_mode='read-only')
 498         self.assert_qmp(result, 'return', {})
 499
 500         self.wait_for_open()
 501         self.wait_for_close()
 502
 503         result = self.vm.qmp('query-block')
 504         self.assert_qmp(result, 'return[0]/tray_open', False)
 505         self.assert_qmp(result, 'return[0]/inserted/ro', True)
 506         self.assert_qmp(result, 'return[0]/inserted/image/filename', new_img)
 507
 508     def test_make_ro_rw(self):
 509         os.chmod(new_img, 0444)
 510         self.vm.add_drive(old_img, 'media=disk', 'floppy')
 511         self.vm.launch()
 512
 513         result = self.vm.qmp('query-block')
 514         self.assert_qmp(result, 'return[0]/tray_open', False)
 515         self.assert_qmp(result, 'return[0]/inserted/ro', False)
 516         self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)
 517
 518         result = self.vm.qmp('blockdev-change-medium',
 519                              device='drive0',
 520                              filename=new_img,
 521                              format=iotests.imgfmt,
 522                              read_only_mode='read-write')
 523         self.assert_qmp(result, 'error/class', 'GenericError')
 524
 525         self.assertEquals(self.vm.get_qmp_events(wait=False), [])
 526
 527         result = self.vm.qmp('query-block')
 528         self.assert_qmp(result, 'return[0]/tray_open', False)
 529         self.assert_qmp(result, 'return[0]/inserted/ro', False)
 530         self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)
 531
 532     def test_make_rw_ro_by_retain(self):
 533         os.chmod(old_img, 0444)
 534         self.vm.add_drive(old_img, 'media=disk,read-only=on', 'floppy')
 535         self.vm.launch()
 536
 537         result = self.vm.qmp('query-block')
 538         self.assert_qmp(result, 'return[0]/tray_open', False)
 539         self.assert_qmp(result, 'return[0]/inserted/ro', True)
 540         self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)
 541
 542         result = self.vm.qmp('blockdev-change-medium', device='drive0',
 543                                                        filename=new_img,
 544                                                        format=iotests.imgfmt,
 545                                                        read_only_mode='retain')
 546         self.assert_qmp(result, 'return', {})
 547
 548         self.wait_for_open()
 549         self.wait_for_close()
 550
 551         result = self.vm.qmp('query-block')
 552         self.assert_qmp(result, 'return[0]/tray_open', False)
 553         self.assert_qmp(result, 'return[0]/inserted/ro', True)
 554         self.assert_qmp(result, 'return[0]/inserted/image/filename', new_img)
 555
 556     def test_make_ro_rw_by_retain(self):
 557         os.chmod(new_img, 0444)
 558         self.vm.add_drive(old_img, 'media=disk', 'floppy')
 559         self.vm.launch()
 560
 561         result = self.vm.qmp('query-block')
 562         self.assert_qmp(result, 'return[0]/tray_open', False)
 563         self.assert_qmp(result, 'return[0]/inserted/ro', False)
 564         self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)
 565
 566         result = self.vm.qmp('blockdev-change-medium', device='drive0',
 567                                                        filename=new_img,
 568                                                        format=iotests.imgfmt,
 569                                                        read_only_mode='retain')
 570         self.assert_qmp(result, 'error/class', 'GenericError')
 571
 572         self.assertEquals(self.vm.get_qmp_events(wait=False), [])
 573
 574         result = self.vm.qmp('query-block')
 575         self.assert_qmp(result, 'return[0]/tray_open', False)
 576         self.assert_qmp(result, 'return[0]/inserted/ro', False)
 577         self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)
 578
 579     def test_rw_ro_cycle(self):
 580         os.chmod(new_img, 0444)
 581         self.vm.add_drive(old_img, 'media=disk', 'floppy')
 582         self.vm.launch()
 583
 584         result = self.vm.qmp('query-block')
 585         self.assert_qmp(result, 'return[0]/tray_open', False)
 586         self.assert_qmp(result, 'return[0]/inserted/ro', False)
 587         self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)
 588
 589         result = self.vm.qmp('blockdev-add',
 590                              options={'node-name': 'new',
 591                                       'driver': iotests.imgfmt,
 592                                       'read-only': True,
 593                                       'file': {'filename': new_img,
 594                                                'driver': 'file'}})
 595         self.assert_qmp(result, 'return', {})
 596
 597         result = self.vm.qmp('blockdev-open-tray', device='drive0', force=True)
 598         self.assert_qmp(result, 'return', {})
 599
 600         self.wait_for_open()
 601
 602         result = self.vm.qmp('query-block')
 603         self.assert_qmp(result, 'return[0]/tray_open', True)
 604         self.assert_qmp(result, 'return[0]/inserted/ro', False)
 605         self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)
 606
 607         result = self.vm.qmp('x-blockdev-remove-medium', device='drive0')
 608         self.assert_qmp(result, 'return', {})
 609
 610         result = self.vm.qmp('query-block')
 611         self.assert_qmp(result, 'return[0]/tray_open', True)
 612         self.assert_qmp_absent(result, 'return[0]/inserted')
 613
 614         result = self.vm.qmp('x-blockdev-insert-medium', device='drive0',
 615                                                        node_name='new')
 616         self.assert_qmp(result, 'return', {})
 617
 618         result = self.vm.qmp('query-block')
 619         self.assert_qmp(result, 'return[0]/tray_open', True)
 620         self.assert_qmp(result, 'return[0]/inserted/ro', True)
 621         self.assert_qmp(result, 'return[0]/inserted/image/filename', new_img)
 622
 623         result = self.vm.qmp('blockdev-close-tray', device='drive0')
 624         self.assert_qmp(result, 'return', {})
 625
 626         self.wait_for_close()
 627
 628         result = self.vm.qmp('query-block')
 629         self.assert_qmp(result, 'return[0]/tray_open', False)
 630         self.assert_qmp(result, 'return[0]/inserted/ro', True)
 631         self.assert_qmp(result, 'return[0]/inserted/image/filename', new_img)
 632
 633 GeneralChangeTestsBaseClass = None
 634 TestInitiallyFilled = None
 635 TestInitiallyEmpty = None
 636
 637
 638 class TestBlockJobsAfterCycle(ChangeBaseClass):
 639     def setUp(self):
 640         qemu_img('create', '-f', iotests.imgfmt, old_img, '1M')
 641
 642         self.vm = iotests.VM()
 643         self.vm.launch()
 644
 645         result = self.vm.qmp('blockdev-add',
 646                              options={'id': 'drive0',
 647                                       'driver': 'null-co'})
 648         self.assert_qmp(result, 'return', {})
 649
 650         result = self.vm.qmp('query-block')
 651         self.assert_qmp(result, 'return[0]/tray_open', False)
 652         self.assert_qmp(result, 'return[0]/inserted/image/format', 'null-co')
 653
 654         # For device-less BBs, calling blockdev-open-tray or blockdev-close-tray
 655         # is not necessary
 656         result = self.vm.qmp('x-blockdev-remove-medium', device='drive0')
 657         self.assert_qmp(result, 'return', {})
 658
 659         result = self.vm.qmp('query-block')
 660         self.assert_qmp_absent(result, 'return[0]/inserted')
 661
 662         result = self.vm.qmp('blockdev-add',
 663                              options={'node-name': 'node0',
 664                                       'driver': iotests.imgfmt,
 665                                       'file': {'filename': old_img,
 666                                                'driver': 'file'}})
 667         self.assert_qmp(result, 'return', {})
 668
 669         result = self.vm.qmp('x-blockdev-insert-medium', device='drive0',
 670                                                        node_name='node0')
 671         self.assert_qmp(result, 'return', {})
 672
 673         result = self.vm.qmp('query-block')
 674         self.assert_qmp(result, 'return[0]/tray_open', False)
 675         self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)
 676
 677     def tearDown(self):
 678         self.vm.shutdown()
 679         os.remove(old_img)
 680         try:
 681             os.remove(new_img)
 682         except OSError:
 683             pass
 684
 685     def test_snapshot_and_commit(self):
 686         # We need backing file support
 687         if iotests.imgfmt != 'qcow2' and iotests.imgfmt != 'qed':
 688             return
 689
 690         result = self.vm.qmp('blockdev-snapshot-sync', device='drive0',
 691                                                        snapshot_file=new_img,
 692                                                        format=iotests.imgfmt)
 693         self.assert_qmp(result, 'return', {})
 694
 695         result = self.vm.qmp('query-block')
 696         self.assert_qmp(result, 'return[0]/inserted/image/filename', new_img)
 697         self.assert_qmp(result,
 698                         'return[0]/inserted/image/backing-image/filename',
 699                         old_img)
 700
 701         result = self.vm.qmp('block-commit', device='drive0')
 702         self.assert_qmp(result, 'return', {})
 703
 704         self.vm.event_wait(name='BLOCK_JOB_READY')
 705
 706         result = self.vm.qmp('query-block-jobs')
 707         self.assert_qmp(result, 'return[0]/device', 'drive0')
 708
 709         result = self.vm.qmp('block-job-complete', device='drive0')
 710         self.assert_qmp(result, 'return', {})
 711
 712         self.vm.event_wait(name='BLOCK_JOB_COMPLETED')
 713
 714
 715 if __name__ == '__main__':
 716     if iotests.qemu_default_machine != 'pc':
 717         # We need floppy and IDE CD-ROM
 718         iotests.notrun('not suitable for this machine type: %s' %
 719                        iotests.qemu_default_machine)
 720     iotests.main()