Python rbd.Image类代码示例

 def test_copy(self):
     global ioctx
     data = rand_data(256)
     self.image.write(data, 256)
     bytes_copied = self.image.copy(ioctx, IMG_NAME + '2')
     copy = Image(ioctx, IMG_NAME + '2')
     copy_data = copy.read(256, 256)
     copy.close()
     self.rbd.remove(ioctx, IMG_NAME + '2')
     eq(bytes_copied, IMG_SIZE)
     eq(data, copy_data)

 def test_copy(self):
     global ioctx
     data = rand_data(256)
     self.image.write(data, 256)
     self.image.copy(ioctx, IMG_NAME + "2")
     assert_raises(ImageExists, self.image.copy, ioctx, IMG_NAME + "2")
     copy = Image(ioctx, IMG_NAME + "2")
     copy_data = copy.read(256, 256)
     copy.close()
     self.rbd.remove(ioctx, IMG_NAME + "2")
     eq(data, copy_data)

 def test_copy(self):
     global ioctx
     data = rand_data(256)
     self.image.write(data, 256)
     image_name = get_temp_image_name()
     self.image.copy(ioctx, image_name)
     assert_raises(ImageExists, self.image.copy, ioctx, image_name)
     copy = Image(ioctx, image_name)
     copy_data = copy.read(256, 256)
     copy.close()
     self.rbd.remove(ioctx, image_name)
     eq(data, copy_data)

 def test_create_snap(self):
     global ioctx
     self.image.create_snap('snap1')
     read = self.image.read(0, 256)
     eq(read, '\0' * 256)
     data = rand_data(256)
     self.image.write(data, 0)
     read = self.image.read(0, 256)
     eq(read, data)
     at_snapshot = Image(ioctx, IMG_NAME, 'snap1')
     snap_data = at_snapshot.read(0, 256)
     at_snapshot.close()
     eq(snap_data, '\0' * 256)

 def setUp(self):
     global ioctx
     global features
     self.rbd = RBD()
     create_image()
     self.image = Image(ioctx, IMG_NAME)
     data = rand_data(256)
     self.image.write(data, IMG_SIZE / 2)
     self.image.create_snap("snap1")
     global features
     self.image.protect_snap("snap1")
     self.rbd.clone(ioctx, IMG_NAME, "snap1", ioctx, "clone", features)
     self.clone = Image(ioctx, "clone")

 def test_create_snap(self):
     global ioctx
     self.image.create_snap("snap1")
     read = self.image.read(0, 256)
     eq(read, "\0" * 256)
     data = rand_data(256)
     self.image.write(data, 0)
     read = self.image.read(0, 256)
     eq(read, data)
     at_snapshot = Image(ioctx, IMG_NAME, "snap1")
     snap_data = at_snapshot.read(0, 256)
     at_snapshot.close()
     eq(snap_data, "\0" * 256)
     self.image.remove_snap("snap1")

 def setUp(self):
     global ioctx
     global features
     self.rbd = RBD()
     create_image()
     self.image = Image(ioctx, image_name)
     data = rand_data(256)
     self.image.write(data, IMG_SIZE // 2)
     self.image.create_snap("snap1")
     global features
     self.image.protect_snap("snap1")
     self.clone_name = get_temp_image_name()
     self.rbd.clone(ioctx, image_name, "snap1", ioctx, self.clone_name, features)
     self.clone = Image(ioctx, self.clone_name)

def delete_image(ioctx, img_name):
    image = Image(ioctx, img_name)
    for snap in image.list_snaps():
        snap_name = snap['name']
        print("removing snapshot: %[email protected]%s" % (img_name, snap_name))
        if image.is_protected_snap(snap_name):
            image.unprotect_snap(snap_name)
        image.remove_snap(snap_name)
    image.close()
    print("removing image: %s" % img_name)
    RBD().remove(ioctx, img_name)

    def test_list_children(self):
        global ioctx
        global features
        self.image.set_snap('snap1')
        self.check_children([(pool_name, self.clone_name)])
        self.clone.close()
        self.rbd.remove(ioctx, self.clone_name)
        eq(self.image.list_children(), [])

        clone_name = get_temp_image_name() + '_'
        expected_children = []
        for i in xrange(10):
            self.rbd.clone(ioctx, image_name, 'snap1', ioctx,
                           clone_name + str(i), features)
            expected_children.append((pool_name, clone_name + str(i)))
            self.check_children(expected_children)

        for i in xrange(10):
            self.rbd.remove(ioctx, clone_name + str(i))
            expected_children.pop(0)
            self.check_children(expected_children)

        eq(self.image.list_children(), [])
        self.rbd.clone(ioctx, image_name, 'snap1', ioctx, self.clone_name,
                       features)
        self.check_children([(pool_name, self.clone_name)])
        self.clone = Image(ioctx, self.clone_name)

 def _test_copy(self, features=None, order=None, stripe_unit=None, stripe_count=None):
     global ioctx
     data = rand_data(256)
     self.image.write(data, 256)
     image_name = get_temp_image_name()
     if features is None:
         self.image.copy(ioctx, image_name)
     elif order is None:
         self.image.copy(ioctx, image_name, features)
     elif stripe_unit is None:
         self.image.copy(ioctx, image_name, features, order)
     elif stripe_count is None:
         self.image.copy(ioctx, image_name, features, order, stripe_unit)
     else:
         self.image.copy(ioctx, image_name, features, order, stripe_unit, stripe_count)
     assert_raises(ImageExists, self.image.copy, ioctx, image_name)
     copy = Image(ioctx, image_name)
     copy_data = copy.read(256, 256)
     copy.close()
     self.rbd.remove(ioctx, image_name)
     eq(data, copy_data)

    def check_flatten_with_order(self, new_order):
        global ioctx
        global features
        self.rbd.clone(ioctx, IMG_NAME, "snap1", ioctx, "clone2", features, new_order)
        # with Image(ioctx, 'clone2') as clone:
        clone2 = Image(ioctx, "clone2")
        clone2.flatten()
        eq(clone2.overlap(), 0)
        clone2.close()
        self.rbd.remove(ioctx, "clone2")

        # flatten after resizing to non-block size
        self.rbd.clone(ioctx, IMG_NAME, "snap1", ioctx, "clone2", features, new_order)
        with Image(ioctx, "clone2") as clone:
            clone.resize(IMG_SIZE / 2 - 1)
            clone.flatten()
            eq(0, clone.overlap())
        self.rbd.remove(ioctx, "clone2")

        # flatten after resizing to non-block size
        self.rbd.clone(ioctx, IMG_NAME, "snap1", ioctx, "clone2", features, new_order)
        with Image(ioctx, "clone2") as clone:
            clone.resize(IMG_SIZE / 2 + 1)
            clone.flatten()
            eq(clone.overlap(), 0)
        self.rbd.remove(ioctx, "clone2")

    def check_flatten_with_order(self, new_order):
        global ioctx
        global features
        clone_name2 = get_temp_image_name()
        self.rbd.clone(ioctx, image_name, 'snap1', ioctx, clone_name2,
                       features, new_order)
        #with Image(ioctx, 'clone2') as clone:
        clone2 = Image(ioctx, clone_name2)
        clone2.flatten()
        eq(clone2.overlap(), 0)
        clone2.close()
        self.rbd.remove(ioctx, clone_name2)

        # flatten after resizing to non-block size
        self.rbd.clone(ioctx, image_name, 'snap1', ioctx, clone_name2,
                       features, new_order)
        with Image(ioctx, clone_name2) as clone:
            clone.resize(IMG_SIZE / 2 - 1)
            clone.flatten()
            eq(0, clone.overlap())
        self.rbd.remove(ioctx, clone_name2)

        # flatten after resizing to non-block size
        self.rbd.clone(ioctx, image_name, 'snap1', ioctx, clone_name2,
                       features, new_order)
        with Image(ioctx, clone_name2) as clone:
            clone.resize(IMG_SIZE / 2 + 1)
            clone.flatten()
            eq(clone.overlap(), 0)
        self.rbd.remove(ioctx, clone_name2)

 def test_create_with_params(self):
     global features
     image_name = get_temp_image_name()
     order = 20
     stripe_unit = 1 << 20
     stripe_count = 10
     self.rbd.create(ioctx, image_name, IMG_SIZE, order, False, features, stripe_unit, stripe_count)
     image = Image(ioctx, image_name)
     info = image.stat()
     check_stat(info, IMG_SIZE, order)
     eq(image.features(), features)
     eq(image.stripe_unit(), stripe_unit)
     eq(image.stripe_count(), stripe_count)
     image.close()
     RBD().remove(ioctx, image_name)

    def test_unprotect_with_children(self):
        global features
        # can't remove a snapshot that has dependent clones
        assert_raises(ImageBusy, self.image.remove_snap, 'snap1')

        # validate parent info of clone created by TestClone.setUp
        (pool, image, snap) = self.clone.parent_info()
        eq(pool, pool_name)
        eq(image, image_name)
        eq(snap, 'snap1')

        # create a new pool...
        pool_name2 = get_temp_pool_name()
        rados.create_pool(pool_name2)
        other_ioctx = rados.open_ioctx(pool_name2)

        # ...with a clone of the same parent
        other_clone_name = get_temp_image_name()
        self.rbd.clone(ioctx, image_name, 'snap1', other_ioctx,
                       other_clone_name, features)
        self.other_clone = Image(other_ioctx, other_clone_name)
        # validate its parent info
        (pool, image, snap) = self.other_clone.parent_info()
        eq(pool, pool_name)
        eq(image, image_name)
        eq(snap, 'snap1')

        # can't unprotect snap with children
        assert_raises(ImageBusy, self.image.unprotect_snap, 'snap1')

        # 2 children, check that cannot remove the parent snap
        assert_raises(ImageBusy, self.image.remove_snap, 'snap1')

        # close and remove other pool's clone
        self.other_clone.close()
        self.rbd.remove(other_ioctx, other_clone_name)

        # check that we cannot yet remove the parent snap
        assert_raises(ImageBusy, self.image.remove_snap, 'snap1')

        other_ioctx.close()
        rados.delete_pool(pool_name2)

    def test_unprotect_with_children(self):
        global features
        # can't remove a snapshot that has dependent clones
        assert_raises(ImageBusy, self.image.remove_snap, "snap1")

        # validate parent info of clone created by TestClone.setUp
        (pool, image, snap) = self.clone.parent_info()
        eq(pool, "rbd")
        eq(image, IMG_NAME)
        eq(snap, "snap1")

        # create a new pool...
        rados.create_pool("rbd2")
        other_ioctx = rados.open_ioctx("rbd2")

        # ...with a clone of the same parent
        self.rbd.clone(ioctx, IMG_NAME, "snap1", other_ioctx, "other_clone", features)
        self.other_clone = Image(other_ioctx, "other_clone")
        # validate its parent info
        (pool, image, snap) = self.other_clone.parent_info()
        eq(pool, "rbd")
        eq(image, IMG_NAME)
        eq(snap, "snap1")

        # can't unprotect snap with children
        assert_raises(ImageBusy, self.image.unprotect_snap, "snap1")

        # 2 children, check that cannot remove the parent snap
        assert_raises(ImageBusy, self.image.remove_snap, "snap1")

        # close and remove other pool's clone
        self.other_clone.close()
        self.rbd.remove(other_ioctx, "other_clone")

        # check that we cannot yet remove the parent snap
        assert_raises(ImageBusy, self.image.remove_snap, "snap1")

        other_ioctx.close()
        rados.delete_pool("rbd2")