ceph/qa/tasks/mgr/dashboard/test_rbd.py

   1 # -*- coding: utf-8 -*-
   2 # pylint: disable=too-many-public-methods
   3
   4 from __future__ import absolute_import
   5
   6 import time
   7
   8 from .helper import DashboardTestCase, JObj, JLeaf, JList
   9
  10
  11 class RbdTest(DashboardTestCase):
  12     AUTH_ROLES = ['pool-manager', 'block-manager']
  13
  14     @classmethod
  15     def create_pool(cls, name, pg_num, pool_type, application='rbd'):
  16         data = {
  17             'pool': name,
  18             'pg_num': pg_num,
  19             'pool_type': pool_type,
  20             'application_metadata': [application]
  21         }
  22         if pool_type == 'erasure':
  23             data['flags'] = ['ec_overwrites']
  24         cls._task_post("/api/pool", data)
  25
  26     @DashboardTestCase.RunAs('test', 'test', [{'rbd-image': ['create', 'update', 'delete']}])
  27     def test_read_access_permissions(self):
  28         self._get('/api/block/image')
  29         self.assertStatus(403)
  30         self._get('/api/block/image/pool/image')
  31         self.assertStatus(403)
  32
  33     @DashboardTestCase.RunAs('test', 'test', [{'rbd-image': ['read', 'update', 'delete']}])
  34     def test_create_access_permissions(self):
  35         self.create_image('pool', 'name', 0)
  36         self.assertStatus(403)
  37         self.create_snapshot('pool', 'image', 'snapshot')
  38         self.assertStatus(403)
  39         self.copy_image('src_pool', 'src_image', 'dest_pool', 'dest_image')
  40         self.assertStatus(403)
  41         self.clone_image('parent_pool', 'parent_image', 'parent_snap', 'pool', 'name')
  42         self.assertStatus(403)
  43
  44     @DashboardTestCase.RunAs('test', 'test', [{'rbd-image': ['read', 'create', 'delete']}])
  45     def test_update_access_permissions(self):
  46         self.edit_image('pool', 'image')
  47         self.assertStatus(403)
  48         self.update_snapshot('pool', 'image', 'snapshot', None, None)
  49         self.assertStatus(403)
  50         self._task_post('/api/block/image/rbd/rollback_img/snap/snap1/rollback')
  51         self.assertStatus(403)
  52         self.flatten_image('pool', 'image')
  53         self.assertStatus(403)
  54
  55     @DashboardTestCase.RunAs('test', 'test', [{'rbd-image': ['read', 'create', 'update']}])
  56     def test_delete_access_permissions(self):
  57         self.remove_image('pool', 'image')
  58         self.assertStatus(403)
  59         self.remove_snapshot('pool', 'image', 'snapshot')
  60         self.assertStatus(403)
  61
  62     @classmethod
  63     def create_image(cls, pool, name, size, **kwargs):
  64         data = {'name': name, 'pool_name': pool, 'size': size}
  65         data.update(kwargs)
  66         return cls._task_post('/api/block/image', data)
  67
  68     @classmethod
  69     def clone_image(cls, parent_pool, parent_image, parent_snap, pool, name,
  70                     **kwargs):
  71         # pylint: disable=too-many-arguments
  72         data = {'child_image_name': name, 'child_pool_name': pool}
  73         data.update(kwargs)
  74         return cls._task_post('/api/block/image/{}/{}/snap/{}/clone'
  75                               .format(parent_pool, parent_image, parent_snap),
  76                               data)
  77
  78     @classmethod
  79     def copy_image(cls, src_pool, src_image, dest_pool, dest_image, **kwargs):
  80         # pylint: disable=too-many-arguments
  81         data = {'dest_image_name': dest_image, 'dest_pool_name': dest_pool}
  82         data.update(kwargs)
  83         return cls._task_post('/api/block/image/{}/{}/copy'
  84                               .format(src_pool, src_image), data)
  85
  86     @classmethod
  87     def remove_image(cls, pool, image):
  88         return cls._task_delete('/api/block/image/{}/{}'.format(pool, image))
  89
  90     # pylint: disable=too-many-arguments
  91     @classmethod
  92     def edit_image(cls, pool, image, name=None, size=None, features=None, **kwargs):
  93         kwargs.update({'name': name, 'size': size, 'features': features})
  94         return cls._task_put('/api/block/image/{}/{}'.format(pool, image), kwargs)
  95
  96     @classmethod
  97     def flatten_image(cls, pool, image):
  98         return cls._task_post('/api/block/image/{}/{}/flatten'.format(pool, image))
  99
 100     @classmethod
 101     def create_snapshot(cls, pool, image, snapshot):
 102         return cls._task_post('/api/block/image/{}/{}/snap'.format(pool, image),
 103                               {'snapshot_name': snapshot})
 104
 105     @classmethod
 106     def remove_snapshot(cls, pool, image, snapshot):
 107         return cls._task_delete('/api/block/image/{}/{}/snap/{}'.format(pool, image, snapshot))
 108
 109     @classmethod
 110     def update_snapshot(cls, pool, image, snapshot, new_name, is_protected):
 111         return cls._task_put('/api/block/image/{}/{}/snap/{}'.format(pool, image, snapshot),
 112                              {'new_snap_name': new_name, 'is_protected': is_protected})
 113
 114     @classmethod
 115     def setUpClass(cls):
 116         super(RbdTest, cls).setUpClass()
 117         cls.create_pool('rbd', 10, 'replicated')
 118         cls.create_pool('rbd_iscsi', 10, 'replicated')
 119
 120         cls.create_image('rbd', 'img1', 2**30)
 121         cls.create_image('rbd', 'img2', 2*2**30)
 122         cls.create_image('rbd_iscsi', 'img1', 2**30)
 123         cls.create_image('rbd_iscsi', 'img2', 2*2**30)
 124
 125         osd_metadata = cls.ceph_cluster.mon_manager.get_osd_metadata()
 126         cls.bluestore_support = True
 127         for osd in osd_metadata:
 128             if osd['osd_objectstore'] != 'bluestore':
 129                 cls.bluestore_support = False
 130                 break
 131
 132     @classmethod
 133     def tearDownClass(cls):
 134         super(RbdTest, cls).tearDownClass()
 135         cls._ceph_cmd(['osd', 'pool', 'delete', 'rbd', 'rbd', '--yes-i-really-really-mean-it'])
 136         cls._ceph_cmd(['osd', 'pool', 'delete', 'rbd_iscsi', 'rbd_iscsi',
 137                        '--yes-i-really-really-mean-it'])
 138         cls._ceph_cmd(['osd', 'pool', 'delete', 'rbd_data', 'rbd_data',
 139                        '--yes-i-really-really-mean-it'])
 140
 141     @classmethod
 142     def create_image_in_trash(cls, pool, name, delay=0):
 143         cls.create_image(pool, name, 10240)
 144         img = cls._get('/api/block/image/{}/{}'.format(pool, name))
 145
 146         cls._task_post("/api/block/image/{}/{}/move_trash".format(pool, name),
 147                         {'delay': delay})
 148
 149         return img['id']
 150
 151     @classmethod
 152     def remove_trash(cls, pool, image_id, image_name, force=False):
 153         return cls._task_delete('/api/block/image/trash/{}/{}/?image_name={}&force={}'.format('rbd', image_id, image_name, force))
 154
 155     @classmethod
 156     def get_trash(cls, pool, image_id):
 157         trash = cls._get('/api/block/image/trash/?pool_name={}'.format(pool))
 158         if isinstance(trash, list):
 159             for pool in trash:
 160                 for image in pool['value']:
 161                     if image['id'] == image_id:
 162                         return image
 163
 164         return None
 165
 166     def _validate_image(self, img, **kwargs):
 167         """
 168         Example of an RBD image json:
 169
 170         {
 171             "size": 1073741824,
 172             "obj_size": 4194304,
 173             "num_objs": 256,
 174             "order": 22,
 175             "block_name_prefix": "rbd_data.10ae2ae8944a",
 176             "name": "img1",
 177             "pool_name": "rbd",
 178             "features": 61,
 179             "features_name": ["deep-flatten", "exclusive-lock", "fast-diff", "layering",
 180                               "object-map"]
 181         }
 182         """
 183         schema = JObj(sub_elems={
 184             'size': JLeaf(int),
 185             'obj_size': JLeaf(int),
 186             'num_objs': JLeaf(int),
 187             'order': JLeaf(int),
 188             'block_name_prefix': JLeaf(str),
 189             'name': JLeaf(str),
 190             'id': JLeaf(str),
 191             'pool_name': JLeaf(str),
 192             'features': JLeaf(int),
 193             'features_name': JList(JLeaf(str)),
 194             'stripe_count': JLeaf(int, none=True),
 195             'stripe_unit': JLeaf(int, none=True),
 196             'parent': JObj(sub_elems={'pool_name': JLeaf(str),
 197                                       'image_name': JLeaf(str),
 198                                       'snap_name': JLeaf(str)}, none=True),
 199             'data_pool': JLeaf(str, none=True),
 200             'snapshots': JList(JLeaf(dict)),
 201             'timestamp': JLeaf(str, none=True),
 202             'disk_usage': JLeaf(int, none=True),
 203             'total_disk_usage': JLeaf(int, none=True),
 204             'configuration': JList(JObj(sub_elems={
 205                 'name': JLeaf(str),
 206                 'source': JLeaf(int),
 207                 'value': JLeaf(str),
 208             })),
 209         })
 210         self.assertSchema(img, schema)
 211
 212         for k, v in kwargs.items():
 213             if isinstance(v, list):
 214                 self.assertSetEqual(set(img[k]), set(v))
 215             else:
 216                 self.assertEqual(img[k], v)
 217
 218     def _validate_snapshot(self, snap, **kwargs):
 219         self.assertIn('id', snap)
 220         self.assertIn('name', snap)
 221         self.assertIn('is_protected', snap)
 222         self.assertIn('timestamp', snap)
 223         self.assertIn('size', snap)
 224         self.assertIn('children', snap)
 225
 226         for k, v in kwargs.items():
 227             if isinstance(v, list):
 228                 self.assertSetEqual(set(snap[k]), set(v))
 229             else:
 230                 self.assertEqual(snap[k], v)
 231
 232     def _validate_snapshot_list(self, snap_list, snap_name=None, **kwargs):
 233         found = False
 234         for snap in snap_list:
 235             self.assertIn('name', snap)
 236             if snap_name and snap['name'] == snap_name:
 237                 found = True
 238                 self._validate_snapshot(snap, **kwargs)
 239                 break
 240         if snap_name and not found:
 241             self.fail("Snapshot {} not found".format(snap_name))
 242
 243     def test_list(self):
 244         data = self._view_cache_get('/api/block/image')
 245         self.assertStatus(200)
 246         self.assertEqual(len(data), 2)
 247
 248         for pool_view in data:
 249             self.assertEqual(pool_view['status'], 0)
 250             self.assertIsNotNone(pool_view['value'])
 251             self.assertIn('pool_name', pool_view)
 252             self.assertIn(pool_view['pool_name'], ['rbd', 'rbd_iscsi'])
 253             image_list = pool_view['value']
 254             self.assertEqual(len(image_list), 2)
 255
 256             for img in image_list:
 257                 self.assertIn('name', img)
 258                 self.assertIn('pool_name', img)
 259                 self.assertIn(img['pool_name'], ['rbd', 'rbd_iscsi'])
 260                 if img['name'] == 'img1':
 261                     self._validate_image(img, size=1073741824,
 262                                          num_objs=256, obj_size=4194304,
 263                                          features_name=['deep-flatten',
 264                                                         'exclusive-lock',
 265                                                         'fast-diff',
 266                                                         'layering',
 267                                                         'object-map'])
 268                 elif img['name'] == 'img2':
 269                     self._validate_image(img, size=2147483648,
 270                                          num_objs=512, obj_size=4194304,
 271                                          features_name=['deep-flatten',
 272                                                         'exclusive-lock',
 273                                                         'fast-diff',
 274                                                         'layering',
 275                                                         'object-map'])
 276                 else:
 277                     assert False, "Unexcepted image '{}' in result list".format(img['name'])
 278
 279     def test_create(self):
 280         rbd_name = 'test_rbd'
 281         self.create_image('rbd', rbd_name, 10240)
 282         self.assertStatus(201)
 283
 284         img = self._get('/api/block/image/rbd/test_rbd')
 285         self.assertStatus(200)
 286
 287         self._validate_image(img, name=rbd_name, size=10240,
 288                              num_objs=1, obj_size=4194304,
 289                              features_name=['deep-flatten',
 290                                             'exclusive-lock',
 291                                             'fast-diff', 'layering',
 292                                             'object-map'])
 293
 294         self.remove_image('rbd', rbd_name)
 295
 296     def test_create_with_configuration(self):
 297         pool = 'rbd'
 298         image_name = 'image_with_config'
 299         size = 10240
 300         configuration = {
 301             'rbd_qos_bps_limit': 10240,
 302             'rbd_qos_bps_burst': 10240 * 2,
 303         }
 304         expected = [{
 305             'name': 'rbd_qos_bps_limit',
 306             'source': 2,
 307             'value': str(10240),
 308         }, {
 309             'name': 'rbd_qos_bps_burst',
 310             'source': 2,
 311             'value': str(10240 * 2),
 312         }]
 313
 314         self.create_image(pool, image_name, size, configuration=configuration)
 315         self.assertStatus(201)
 316         img = self._get('/api/block/image/rbd/{}'.format(image_name))
 317         self.assertStatus(200)
 318         for conf in expected:
 319             self.assertIn(conf, img['configuration'])
 320
 321         self.remove_image(pool, image_name)
 322
 323     def test_create_rbd_in_data_pool(self):
 324         if not self.bluestore_support:
 325             self.skipTest('requires bluestore cluster')
 326
 327         self.create_pool('data_pool', 12, 'erasure')
 328
 329         rbd_name = 'test_rbd_in_data_pool'
 330         self.create_image('rbd', rbd_name, 10240, data_pool='data_pool')
 331         self.assertStatus(201)
 332
 333         img = self._get('/api/block/image/rbd/test_rbd_in_data_pool')
 334         self.assertStatus(200)
 335
 336         self._validate_image(img, name=rbd_name, size=10240,
 337                              num_objs=1, obj_size=4194304,
 338                              data_pool='data_pool',
 339                              features_name=['data-pool', 'deep-flatten',
 340                                             'exclusive-lock',
 341                                             'fast-diff', 'layering',
 342                                             'object-map'])
 343
 344         self.remove_image('rbd', rbd_name)
 345         self.assertStatus(204)
 346         self._ceph_cmd(['osd', 'pool', 'delete', 'data_pool', 'data_pool',
 347                         '--yes-i-really-really-mean-it'])
 348
 349     def test_create_rbd_twice(self):
 350         res = self.create_image('rbd', 'test_rbd_twice', 10240)
 351
 352         res = self.create_image('rbd', 'test_rbd_twice', 10240)
 353         self.assertStatus(400)
 354         self.assertEqual(res, {"code": '17', 'status': 400, "component": "rbd",
 355                                "detail": "[errno 17] error creating image",
 356                                'task': {'name': 'rbd/create',
 357                                         'metadata': {'pool_name': 'rbd',
 358                                                      'image_name': 'test_rbd_twice'}}})
 359         self.remove_image('rbd', 'test_rbd_twice')
 360         self.assertStatus(204)
 361
 362     def test_snapshots_and_clone_info(self):
 363         self.create_snapshot('rbd', 'img1', 'snap1')
 364         self.create_snapshot('rbd', 'img1', 'snap2')
 365         self._rbd_cmd(['snap', 'protect', 'rbd/img1@snap1'])
 366         self._rbd_cmd(['clone', 'rbd/img1@snap1', 'rbd_iscsi/img1_clone'])
 367
 368         img = self._get('/api/block/image/rbd/img1')
 369         self.assertStatus(200)
 370         self._validate_image(img, name='img1', size=1073741824,
 371                              num_objs=256, obj_size=4194304, parent=None,
 372                              features_name=['deep-flatten', 'exclusive-lock',
 373                                             'fast-diff', 'layering',
 374                                             'object-map'])
 375         for snap in img['snapshots']:
 376             if snap['name'] == 'snap1':
 377                 self._validate_snapshot(snap, is_protected=True)
 378                 self.assertEqual(len(snap['children']), 1)
 379                 self.assertDictEqual(snap['children'][0],
 380                                      {'pool_name': 'rbd_iscsi',
 381                                       'image_name': 'img1_clone'})
 382             elif snap['name'] == 'snap2':
 383                 self._validate_snapshot(snap, is_protected=False)
 384
 385         img = self._get('/api/block/image/rbd_iscsi/img1_clone')
 386         self.assertStatus(200)
 387         self._validate_image(img, name='img1_clone', size=1073741824,
 388                              num_objs=256, obj_size=4194304,
 389                              parent={'pool_name': 'rbd', 'image_name': 'img1',
 390                                      'snap_name': 'snap1'},
 391                              features_name=['deep-flatten', 'exclusive-lock',
 392                                             'fast-diff', 'layering',
 393                                             'object-map'])
 394         self.remove_image('rbd_iscsi', 'img1_clone')
 395         self.assertStatus(204)
 396
 397     def test_disk_usage(self):
 398         self._rbd_cmd(['bench', '--io-type', 'write', '--io-total', '50M', 'rbd/img2'])
 399         self.create_snapshot('rbd', 'img2', 'snap1')
 400         self._rbd_cmd(['bench', '--io-type', 'write', '--io-total', '20M', 'rbd/img2'])
 401         self.create_snapshot('rbd', 'img2', 'snap2')
 402         self._rbd_cmd(['bench', '--io-type', 'write', '--io-total', '10M', 'rbd/img2'])
 403         self.create_snapshot('rbd', 'img2', 'snap3')
 404         self._rbd_cmd(['bench', '--io-type', 'write', '--io-total', '5M', 'rbd/img2'])
 405         img = self._get('/api/block/image/rbd/img2')
 406         self.assertStatus(200)
 407         self._validate_image(img, name='img2', size=2147483648,
 408                              total_disk_usage=268435456, disk_usage=67108864)
 409
 410     def test_delete_non_existent_image(self):
 411         res = self.remove_image('rbd', 'i_dont_exist')
 412         self.assertStatus(400)
 413         self.assertEqual(res, {u'code': u'2', "status": 400, "component": "rbd",
 414                                "detail": "[errno 2] error removing image",
 415                                'task': {'name': 'rbd/delete',
 416                                         'metadata': {'pool_name': 'rbd',
 417                                                      'image_name': 'i_dont_exist'}}})
 418
 419     def test_image_delete(self):
 420         self.create_image('rbd', 'delete_me', 2**30)
 421         self.assertStatus(201)
 422         self.create_snapshot('rbd', 'delete_me', 'snap1')
 423         self.assertStatus(201)
 424         self.create_snapshot('rbd', 'delete_me', 'snap2')
 425         self.assertStatus(201)
 426
 427         img = self._get('/api/block/image/rbd/delete_me')
 428         self.assertStatus(200)
 429         self._validate_image(img, name='delete_me', size=2**30)
 430         self.assertEqual(len(img['snapshots']), 2)
 431
 432         self.remove_snapshot('rbd', 'delete_me', 'snap1')
 433         self.assertStatus(204)
 434         self.remove_snapshot('rbd', 'delete_me', 'snap2')
 435         self.assertStatus(204)
 436
 437         img = self._get('/api/block/image/rbd/delete_me')
 438         self.assertStatus(200)
 439         self._validate_image(img, name='delete_me', size=2**30)
 440         self.assertEqual(len(img['snapshots']), 0)
 441
 442         self.remove_image('rbd', 'delete_me')
 443         self.assertStatus(204)
 444
 445     def test_image_rename(self):
 446         self.create_image('rbd', 'edit_img', 2**30)
 447         self.assertStatus(201)
 448         self._get('/api/block/image/rbd/edit_img')
 449         self.assertStatus(200)
 450         self.edit_image('rbd', 'edit_img', 'new_edit_img')
 451         self.assertStatus(200)
 452         self._get('/api/block/image/rbd/edit_img')
 453         self.assertStatus(404)
 454         self._get('/api/block/image/rbd/new_edit_img')
 455         self.assertStatus(200)
 456         self.remove_image('rbd', 'new_edit_img')
 457         self.assertStatus(204)
 458
 459     def test_image_resize(self):
 460         self.create_image('rbd', 'edit_img', 2**30)
 461         self.assertStatus(201)
 462         img = self._get('/api/block/image/rbd/edit_img')
 463         self.assertStatus(200)
 464         self._validate_image(img, size=2**30)
 465         self.edit_image('rbd', 'edit_img', size=2*2**30)
 466         self.assertStatus(200)
 467         img = self._get('/api/block/image/rbd/edit_img')
 468         self.assertStatus(200)
 469         self._validate_image(img, size=2*2**30)
 470         self.remove_image('rbd', 'edit_img')
 471         self.assertStatus(204)
 472
 473     def test_image_change_features(self):
 474         self.create_image('rbd', 'edit_img', 2**30, features=["layering"])
 475         self.assertStatus(201)
 476         img = self._get('/api/block/image/rbd/edit_img')
 477         self.assertStatus(200)
 478         self._validate_image(img, features_name=["layering"])
 479         self.edit_image('rbd', 'edit_img',
 480                         features=["fast-diff", "object-map", "exclusive-lock"])
 481         img = self._get('/api/block/image/rbd/edit_img')
 482         self.assertStatus(200)
 483         self._validate_image(img, features_name=['exclusive-lock',
 484                                                  'fast-diff', 'layering',
 485                                                  'object-map'])
 486         self.edit_image('rbd', 'edit_img',
 487                         features=["journaling", "exclusive-lock"])
 488         img = self._get('/api/block/image/rbd/edit_img')
 489         self.assertStatus(200)
 490         self._validate_image(img, features_name=['exclusive-lock',
 491                                                  'journaling', 'layering'])
 492         self.remove_image('rbd', 'edit_img')
 493         self.assertStatus(204)
 494
 495     def test_image_change_config(self):
 496         pool = 'rbd'
 497         image = 'image_with_config'
 498         initial_conf = {
 499             'rbd_qos_bps_limit': 10240,
 500             'rbd_qos_write_iops_limit': None
 501         }
 502         initial_expect = [{
 503             'name': 'rbd_qos_bps_limit',
 504             'source': 2,
 505             'value': '10240',
 506         }, {
 507             'name': 'rbd_qos_write_iops_limit',
 508             'source': 0,
 509             'value': '0',
 510         }]
 511         new_conf = {
 512             'rbd_qos_bps_limit': 0,
 513             'rbd_qos_bps_burst': 20480,
 514             'rbd_qos_write_iops_limit': None
 515         }
 516         new_expect = [{
 517             'name': 'rbd_qos_bps_limit',
 518             'source': 2,
 519             'value': '0',
 520         }, {
 521             'name': 'rbd_qos_bps_burst',
 522             'source': 2,
 523             'value': '20480',
 524         }, {
 525             'name': 'rbd_qos_write_iops_limit',
 526             'source': 0,
 527             'value': '0',
 528         }]
 529
 530         self.create_image(pool, image, 2**30, configuration=initial_conf)
 531         self.assertStatus(201)
 532         img = self._get('/api/block/image/{}/{}'.format(pool, image))
 533         self.assertStatus(200)
 534         for conf in initial_expect:
 535             self.assertIn(conf, img['configuration'])
 536
 537         self.edit_image(pool, image, configuration=new_conf)
 538         img = self._get('/api/block/image/{}/{}'.format(pool, image))
 539         self.assertStatus(200)
 540         for conf in new_expect:
 541             self.assertIn(conf, img['configuration'])
 542
 543         self.remove_image(pool, image)
 544         self.assertStatus(204)
 545
 546     def test_update_snapshot(self):
 547         self.create_snapshot('rbd', 'img1', 'snap5')
 548         self.assertStatus(201)
 549         img = self._get('/api/block/image/rbd/img1')
 550         self._validate_snapshot_list(img['snapshots'], 'snap5', is_protected=False)
 551
 552         self.update_snapshot('rbd', 'img1', 'snap5', 'snap6', None)
 553         self.assertStatus(200)
 554         img = self._get('/api/block/image/rbd/img1')
 555         self._validate_snapshot_list(img['snapshots'], 'snap6', is_protected=False)
 556
 557         self.update_snapshot('rbd', 'img1', 'snap6', None, True)
 558         self.assertStatus(200)
 559         img = self._get('/api/block/image/rbd/img1')
 560         self._validate_snapshot_list(img['snapshots'], 'snap6', is_protected=True)
 561
 562         self.update_snapshot('rbd', 'img1', 'snap6', 'snap5', False)
 563         self.assertStatus(200)
 564         img = self._get('/api/block/image/rbd/img1')
 565         self._validate_snapshot_list(img['snapshots'], 'snap5', is_protected=False)
 566
 567         self.remove_snapshot('rbd', 'img1', 'snap5')
 568         self.assertStatus(204)
 569
 570     def test_snapshot_rollback(self):
 571         self.create_image('rbd', 'rollback_img', 2**30,
 572                           features=["layering", "exclusive-lock", "fast-diff",
 573                                     "object-map"])
 574         self.assertStatus(201)
 575         self.create_snapshot('rbd', 'rollback_img', 'snap1')
 576         self.assertStatus(201)
 577
 578         img = self._get('/api/block/image/rbd/rollback_img')
 579         self.assertStatus(200)
 580         self.assertEqual(img['disk_usage'], 0)
 581
 582         self._rbd_cmd(['bench', '--io-type', 'write', '--io-total', '5M',
 583                        'rbd/rollback_img'])
 584
 585         img = self._get('/api/block/image/rbd/rollback_img')
 586         self.assertStatus(200)
 587         self.assertGreater(img['disk_usage'], 0)
 588
 589         self._task_post('/api/block/image/rbd/rollback_img/snap/snap1/rollback')
 590         self.assertStatus([201, 200])
 591
 592         img = self._get('/api/block/image/rbd/rollback_img')
 593         self.assertStatus(200)
 594         self.assertEqual(img['disk_usage'], 0)
 595
 596         self.remove_snapshot('rbd', 'rollback_img', 'snap1')
 597         self.assertStatus(204)
 598         self.remove_image('rbd', 'rollback_img')
 599         self.assertStatus(204)
 600
 601     def test_clone(self):
 602         self.create_image('rbd', 'cimg', 2**30, features=["layering"])
 603         self.assertStatus(201)
 604         self.create_snapshot('rbd', 'cimg', 'snap1')
 605         self.assertStatus(201)
 606         self.update_snapshot('rbd', 'cimg', 'snap1', None, True)
 607         self.assertStatus(200)
 608         self.clone_image('rbd', 'cimg', 'snap1', 'rbd', 'cimg-clone',
 609                          features=["layering", "exclusive-lock", "fast-diff",
 610                                    "object-map"])
 611         self.assertStatus([200, 201])
 612
 613         img = self._get('/api/block/image/rbd/cimg-clone')
 614         self.assertStatus(200)
 615         self._validate_image(img, features_name=['exclusive-lock',
 616                                                  'fast-diff', 'layering',
 617                                                  'object-map'],
 618                              parent={'pool_name': 'rbd', 'image_name': 'cimg',
 619                                      'snap_name': 'snap1'})
 620
 621         res = self.remove_image('rbd', 'cimg')
 622         self.assertStatus(400)
 623         self.assertIn('code', res)
 624         self.assertEqual(res['code'], '39')
 625
 626         self.remove_image('rbd', 'cimg-clone')
 627         self.assertStatus(204)
 628         self.update_snapshot('rbd', 'cimg', 'snap1', None, False)
 629         self.assertStatus(200)
 630         self.remove_snapshot('rbd', 'cimg', 'snap1')
 631         self.assertStatus(204)
 632         self.remove_image('rbd', 'cimg')
 633         self.assertStatus(204)
 634
 635     def test_copy(self):
 636         self.create_image('rbd', 'coimg', 2**30,
 637                           features=["layering", "exclusive-lock", "fast-diff",
 638                                     "object-map"])
 639         self.assertStatus(201)
 640
 641         self._rbd_cmd(['bench', '--io-type', 'write', '--io-total', '5M',
 642                        'rbd/coimg'])
 643
 644         self.copy_image('rbd', 'coimg', 'rbd_iscsi', 'coimg-copy',
 645                         features=["layering", "fast-diff", "exclusive-lock",
 646                                   "object-map"])
 647         self.assertStatus([200, 201])
 648
 649         img = self._get('/api/block/image/rbd/coimg')
 650         self.assertStatus(200)
 651         self._validate_image(img, features_name=['layering', 'exclusive-lock',
 652                                                  'fast-diff', 'object-map'])
 653
 654         img_copy = self._get('/api/block/image/rbd_iscsi/coimg-copy')
 655         self._validate_image(img_copy, features_name=['exclusive-lock',
 656                                                       'fast-diff', 'layering',
 657                                                       'object-map'],
 658                              disk_usage=img['disk_usage'])
 659
 660         self.remove_image('rbd', 'coimg')
 661         self.assertStatus(204)
 662         self.remove_image('rbd_iscsi', 'coimg-copy')
 663         self.assertStatus(204)
 664
 665     def test_flatten(self):
 666         self.create_snapshot('rbd', 'img1', 'snapf')
 667         self.update_snapshot('rbd', 'img1', 'snapf', None, True)
 668         self.clone_image('rbd', 'img1', 'snapf', 'rbd_iscsi', 'img1_snapf_clone')
 669
 670         img = self._get('/api/block/image/rbd_iscsi/img1_snapf_clone')
 671         self.assertStatus(200)
 672         self.assertIsNotNone(img['parent'])
 673
 674         self.flatten_image('rbd_iscsi', 'img1_snapf_clone')
 675         self.assertStatus([200, 201])
 676
 677         img = self._get('/api/block/image/rbd_iscsi/img1_snapf_clone')
 678         self.assertStatus(200)
 679         self.assertIsNone(img['parent'])
 680
 681         self.update_snapshot('rbd', 'img1', 'snapf', None, False)
 682         self.remove_snapshot('rbd', 'img1', 'snapf')
 683         self.assertStatus(204)
 684
 685         self.remove_image('rbd_iscsi', 'img1_snapf_clone')
 686         self.assertStatus(204)
 687
 688     def test_default_features(self):
 689         default_features = self._get('/api/block/image/default_features')
 690         self.assertEqual(default_features, ['deep-flatten', 'exclusive-lock',
 691                                              'fast-diff', 'layering',
 692                                              'object-map'])
 693
 694     def test_image_with_special_name(self):
 695         rbd_name = 'test/rbd'
 696         rbd_name_encoded = 'test%2Frbd'
 697
 698         self.create_image('rbd', rbd_name, 10240)
 699         self.assertStatus(201)
 700
 701         img = self._get("/api/block/image/rbd/" + rbd_name_encoded)
 702         self.assertStatus(200)
 703
 704         self._validate_image(img, name=rbd_name, size=10240,
 705                              num_objs=1, obj_size=4194304,
 706                              features_name=['deep-flatten',
 707                                             'exclusive-lock',
 708                                             'fast-diff', 'layering',
 709                                             'object-map'])
 710
 711         self.remove_image('rbd', rbd_name_encoded)
 712
 713     def test_move_image_to_trash(self):
 714         id = self.create_image_in_trash('rbd', 'test_rbd')
 715         self.assertStatus(200)
 716
 717         self._get('/api/block/image/rbd/test_rbd')
 718         self.assertStatus(404)
 719
 720         time.sleep(1)
 721
 722         image = self.get_trash('rbd', id)
 723         self.assertIsNotNone(image)
 724
 725         self.remove_trash('rbd', id, 'test_rbd')
 726
 727     def test_list_trash(self):
 728         id = self.create_image_in_trash('rbd', 'test_rbd', 0)
 729         data = self._get('/api/block/image/trash/?pool_name={}'.format('rbd'))
 730         self.assertStatus(200)
 731         self.assertIsInstance(data, list)
 732         self.assertIsNotNone(data)
 733
 734         self.remove_trash('rbd', id, 'test_rbd')
 735         self.assertStatus(204)
 736
 737     def test_restore_trash(self):
 738         id = self.create_image_in_trash('rbd', 'test_rbd')
 739
 740         self._task_post('/api/block/image/trash/{}/{}/restore'.format('rbd', id), {'new_image_name': 'test_rbd'})
 741
 742         self._get('/api/block/image/rbd/test_rbd')
 743         self.assertStatus(200)
 744
 745         image = self.get_trash('rbd', id)
 746         self.assertIsNone(image)
 747
 748         self.remove_image('rbd', 'test_rbd')
 749
 750     def test_remove_expired_trash(self):
 751         id = self.create_image_in_trash('rbd', 'test_rbd', 0)
 752         self.remove_trash('rbd', id, 'test_rbd', False)
 753         self.assertStatus(204)
 754
 755         image = self.get_trash('rbd', id)
 756         self.assertIsNone(image)
 757
 758     def test_remove_not_expired_trash(self):
 759         id = self.create_image_in_trash('rbd', 'test_rbd', 9999)
 760         self.remove_trash('rbd', id, 'test_rbd', False)
 761         self.assertStatus(400)
 762
 763         time.sleep(1)
 764
 765         image = self.get_trash('rbd', id)
 766         self.assertIsNotNone(image)
 767
 768         self.remove_trash('rbd', id, 'test_rbd', True)
 769
 770     def test_remove_not_expired_trash_with_force(self):
 771         id = self.create_image_in_trash('rbd', 'test_rbd', 9999)
 772         self.remove_trash('rbd', id, 'test_rbd', True)
 773         self.assertStatus(204)
 774
 775         image = self.get_trash('rbd', id)
 776         self.assertIsNone(image)
 777
 778     def test_purge_trash(self):
 779         id_expired = self.create_image_in_trash('rbd', 'test_rbd_expired', 0)
 780         id_not_expired = self.create_image_in_trash('rbd', 'test_rbd', 9999)
 781
 782         time.sleep(1)
 783
 784         self._task_post('/api/block/image/trash/purge?pool_name={}'.format('rbd'))
 785         self.assertStatus(200)
 786
 787         time.sleep(1)
 788
 789         trash_not_expired = self.get_trash('rbd', id_not_expired)
 790         self.assertIsNotNone(trash_not_expired)
 791
 792         trash_expired = self.get_trash('rbd', id_expired)
 793         self.assertIsNone(trash_expired)