Python Rados.open_ioctx方法代码示例

# 需要导入模块: from rados import Rados [as 别名]
# 或者: from rados.Rados import open_ioctx [as 别名]
def setup_rados(args):
    global RADOS
    RADOS = Rados(conffile='')
    RADOS.connect()

    try:
        RADOS.create_pool(args.pool)
    except ObjectExists:
        pass

    global IOCTX_CAS
    global IOCTX_INDEX
    IOCTX_CAS = RADOS.open_ioctx(args.pool)
    IOCTX_INDEX = RADOS.open_ioctx(args.pool)

    global CAS
    global CHUNKER

    if "compression" in args:
        CAS = cas.CAS(IOCTX_CAS, compression=args.compression)
    else:
        CAS = cas.CAS(IOCTX_CAS)

    if "chunk_size" in args:
        CHUNKER = Chunker(CAS, IOCTX_INDEX, chunk_size=args.chunk_size)
    else:
        CHUNKER = Chunker(CAS, IOCTX_INDEX)

# 需要导入模块: from rados import Rados [as 别名]
# 或者: from rados.Rados import open_ioctx [as 别名]
def setup_module():
    global rados
    rados = Rados(conffile='')
    rados.connect()

    global pool_name
    pool_name = random_id()
    rados.create_pool(pool_name)

    global ioctx_cas
    global ioctx_index
    ioctx_cas = rados.open_ioctx(pool_name)
    ioctx_index = rados.open_ioctx(pool_name)

# 需要导入模块: from rados import Rados [as 别名]
# 或者: from rados.Rados import open_ioctx [as 别名]
def setUp():
    global rados
    rados = Rados(conffile='')
    rados.connect()
    assert rados.pool_exists('rbd')
    global ioctx
    ioctx = rados.open_ioctx('rbd')

# 需要导入模块: from rados import Rados [as 别名]
# 或者: from rados.Rados import open_ioctx [as 别名]
 def setUp(self):
     global rados2
     rados2 = Rados(conffile='')
     rados2.connect()
     global ioctx2
     ioctx2 = rados2.open_ioctx(pool_name)
     create_image()

# 需要导入模块: from rados import Rados [as 别名]
# 或者: from rados.Rados import open_ioctx [as 别名]
class TestObject(object):
    def setUp(self):
        self.rados = Rados(conffile="")
        self.rados.connect()
        self.rados.create_pool("test_pool")
        assert self.rados.pool_exists("test_pool")
        self.ioctx = self.rados.open_ioctx("test_pool")
        self.ioctx.write("foo", b"bar")
        self.object = Object(self.ioctx, "foo")

    def tearDown(self):
        self.ioctx.close()
        self.ioctx = None
        self.rados.delete_pool("test_pool")
        self.rados.shutdown()
        self.rados = None

    def test_read(self):
        eq(self.object.read(3), b"bar")
        eq(self.object.read(100), b"")

    def test_seek(self):
        self.object.write(b"blah")
        self.object.seek(0)
        eq(self.object.read(4), b"blah")
        self.object.seek(1)
        eq(self.object.read(3), b"lah")

    def test_write(self):
        self.object.write(b"barbaz")
        self.object.seek(0)
        eq(self.object.read(3), b"bar")
        eq(self.object.read(3), b"baz")

# 需要导入模块: from rados import Rados [as 别名]
# 或者: from rados.Rados import open_ioctx [as 别名]
class TestObject(object):

    def setUp(self):
        self.rados = Rados(conffile='')
        self.rados.connect()
        self.rados.create_pool('test_pool')
        assert self.rados.pool_exists('test_pool')
        self.ioctx = self.rados.open_ioctx('test_pool')
        self.ioctx.write('foo', b'bar')
        self.object = Object(self.ioctx, 'foo')

    def tearDown(self):
        self.ioctx.close()
        self.ioctx = None
        self.rados.delete_pool('test_pool')
        self.rados.shutdown()
        self.rados = None

    def test_read(self):
        eq(self.object.read(3), b'bar')
        eq(self.object.read(100), b'')

    def test_seek(self):
        self.object.write(b'blah')
        self.object.seek(0)
        eq(self.object.read(4), b'blah')
        self.object.seek(1)
        eq(self.object.read(3), b'lah')

    def test_write(self):
        self.object.write(b'barbaz')
        self.object.seek(0)
        eq(self.object.read(3), b'bar')
        eq(self.object.read(3), b'baz')

# 需要导入模块: from rados import Rados [as 别名]
# 或者: from rados.Rados import open_ioctx [as 别名]
class TestIoctxEc(object):

    def setUp(self):
        self.rados = Rados(conffile='')
        self.rados.connect()
        self.pool = 'test-ec'
        self.profile = 'testprofile-%s' % self.pool
        cmd = {"prefix": "osd erasure-code-profile set", 
               "name": self.profile, "profile": ["k=2", "m=1", "crush-failure-domain=osd"]}
        ret, buf, out = self.rados.mon_command(json.dumps(cmd), b'', timeout=30)
        eq(ret, 0, msg=out)
        # create ec pool with profile created above
        cmd = {'prefix': 'osd pool create', 'pg_num': 8, 'pgp_num': 8,
               'pool': self.pool, 'pool_type': 'erasure', 
               'erasure_code_profile': self.profile}
        ret, buf, out = self.rados.mon_command(json.dumps(cmd), b'', timeout=30)
        eq(ret, 0, msg=out)
        assert self.rados.pool_exists(self.pool)
        self.ioctx = self.rados.open_ioctx(self.pool)

    def tearDown(self):
        cmd = {"prefix": "osd unset", "key": "noup"}
        self.rados.mon_command(json.dumps(cmd), b'')
        self.ioctx.close()
        self.rados.delete_pool(self.pool)
        self.rados.shutdown()

    def test_alignment(self):
        eq(self.ioctx.alignment(), 8192)

# 需要导入模块: from rados import Rados [as 别名]
# 或者: from rados.Rados import open_ioctx [as 别名]
def setup_module():
    global rados
    rados = Rados(conffile="")
    rados.connect()
    assert rados.pool_exists("rbd")
    global ioctx
    ioctx = rados.open_ioctx("rbd")
    global features
    features = os.getenv("RBD_FEATURES")
    if features is not None:
        features = int(features)

# 需要导入模块: from rados import Rados [as 别名]
# 或者: from rados.Rados import open_ioctx [as 别名]
def setUp():
    global rados
    rados = Rados(conffile='')
    rados.connect()
    assert rados.pool_exists('rbd')
    global ioctx
    ioctx = rados.open_ioctx('rbd')
    global features
    features = os.getenv("RBD_FEATURES")
    if features is not None:
        features = int(features)

# 需要导入模块: from rados import Rados [as 别名]
# 或者: from rados.Rados import open_ioctx [as 别名]
def setup_module():
    global rados
    rados = Rados(conffile='')
    rados.connect()
    global pool_name
    pool_name = get_temp_pool_name()
    rados.create_pool(pool_name)
    global ioctx
    ioctx = rados.open_ioctx(pool_name)
    global features
    features = os.getenv("RBD_FEATURES")
    features = int(features) if features is not None else 61

# 需要导入模块: from rados import Rados [as 别名]
# 或者: from rados.Rados import open_ioctx [as 别名]
def main():
    if len(sys.argv) != 2 or sys.argv[1] not in ['master', 'slave']:
        print("usage: %s: [master/slave]" % sys.argv[0])
        sys.exit(2)

    rados = Rados(conffile='')
    rados.connect()
    ioctx = rados.open_ioctx(POOL_NAME)
    if sys.argv[1] == 'master':
        master(ioctx)
    else:
        slave(ioctx)
    rados.shutdown()

# 需要导入模块: from rados import Rados [as 别名]
# 或者: from rados.Rados import open_ioctx [as 别名]
class TestIoCtxSelfManagedSnaps(object):
    def setUp(self):
        self.rados = Rados(conffile='')
        self.rados.connect()
        self.rados.create_pool('test_pool')
        assert self.rados.pool_exists('test_pool')
        self.ioctx = self.rados.open_ioctx('test_pool')

    def tearDown(self):
        cmd = {"prefix":"osd unset", "key":"noup"}
        self.rados.mon_command(json.dumps(cmd), b'')
        self.ioctx.close()
        self.rados.delete_pool('test_pool')
        self.rados.shutdown()

    def test(self):
        # cannot mix-and-match pool and self-managed snapshot mode
        self.ioctx.set_self_managed_snap_write([])
        self.ioctx.write('abc', b'abc')
        snap_id_1 = self.ioctx.create_self_managed_snap()
        self.ioctx.set_self_managed_snap_write([snap_id_1])

        self.ioctx.write('abc', b'def')
        snap_id_2 = self.ioctx.create_self_managed_snap()
        self.ioctx.set_self_managed_snap_write([snap_id_1, snap_id_2])

        self.ioctx.write('abc', b'ghi')

        self.ioctx.rollback_self_managed_snap('abc', snap_id_1)
        eq(self.ioctx.read('abc'), b'abc')

        self.ioctx.rollback_self_managed_snap('abc', snap_id_2)
        eq(self.ioctx.read('abc'), b'def')

        self.ioctx.remove_self_managed_snap(snap_id_1)
        self.ioctx.remove_self_managed_snap(snap_id_2)

# 需要导入模块: from rados import Rados [as 别名]
# 或者: from rados.Rados import open_ioctx [as 别名]
class TestIoctx(object):

    def setUp(self):
        self.rados = Rados(conffile='')
        self.rados.connect()
        self.rados.create_pool('test_pool')
        assert self.rados.pool_exists('test_pool')
        self.ioctx = self.rados.open_ioctx('test_pool')

    def tearDown(self):
        cmd = {"prefix":"osd unset", "key":"noup"}
        self.rados.mon_command(json.dumps(cmd), '')
        self.ioctx.close()
        self.rados.delete_pool('test_pool')
        self.rados.shutdown()

    def test_change_auid(self):
        self.ioctx.change_auid(ANONYMOUS_AUID)
        self.ioctx.change_auid(ADMIN_AUID)

    def test_write(self):
        self.ioctx.write('abc', 'abc')
        eq(self.ioctx.read('abc'), 'abc')

    def test_write_full(self):
        self.ioctx.write('abc', 'abc')
        eq(self.ioctx.read('abc'), 'abc')
        self.ioctx.write_full('abc', 'd')
        eq(self.ioctx.read('abc'), 'd')

    def test_append(self):
        self.ioctx.write('abc', 'a')
        self.ioctx.append('abc', 'b')
        self.ioctx.append('abc', 'c')
        eq(self.ioctx.read('abc'), 'abc')

    def test_write_zeros(self):
        self.ioctx.write('abc', 'a\0b\0c')
        eq(self.ioctx.read('abc'), 'a\0b\0c')

    def test_trunc(self):
        self.ioctx.write('abc', 'abc')
        self.ioctx.trunc('abc', 2)
        eq(self.ioctx.read('abc'), 'ab')
        size = self.ioctx.stat('abc')[0]
        eq(size, 2)

    def test_list_objects_empty(self):
        eq(list(self.ioctx.list_objects()), [])

    def test_list_objects(self):
        self.ioctx.write('a', '')
        self.ioctx.write('b', 'foo')
        self.ioctx.write_full('c', 'bar')
        self.ioctx.append('d', 'jazz')
        object_names = [obj.key for obj in self.ioctx.list_objects()]
        eq(sorted(object_names), ['a', 'b', 'c', 'd'])

    def test_list_ns_objects(self):
        self.ioctx.write('a', '')
        self.ioctx.write('b', 'foo')
        self.ioctx.write_full('c', 'bar')
        self.ioctx.append('d', 'jazz')
        self.ioctx.set_namespace("ns1")
        self.ioctx.write('ns1-a', '')
        self.ioctx.write('ns1-b', 'foo')
        self.ioctx.write_full('ns1-c', 'bar')
        self.ioctx.append('ns1-d', 'jazz')
        self.ioctx.append('d', 'jazz')
        self.ioctx.set_namespace(LIBRADOS_ALL_NSPACES)
        object_names = [(obj.nspace, obj.key) for obj in self.ioctx.list_objects()]
        eq(sorted(object_names), [('', 'a'), ('','b'), ('','c'), ('','d'),\
                ('ns1', 'd'), ('ns1', 'ns1-a'), ('ns1', 'ns1-b'),\
                ('ns1', 'ns1-c'), ('ns1', 'ns1-d')])

    def test_xattrs(self):
        xattrs = dict(a='1', b='2', c='3', d='a\0b', e='\0')
        self.ioctx.write('abc', '')
        for key, value in xattrs.iteritems():
            self.ioctx.set_xattr('abc', key, value)
            eq(self.ioctx.get_xattr('abc', key), value)
        stored_xattrs = {}
        for key, value in self.ioctx.get_xattrs('abc'):
            stored_xattrs[key] = value
        eq(stored_xattrs, xattrs)

    def test_obj_xattrs(self):
        xattrs = dict(a='1', b='2', c='3', d='a\0b', e='\0')
        self.ioctx.write('abc', '')
        obj = list(self.ioctx.list_objects())[0]
        for key, value in xattrs.iteritems():
            obj.set_xattr(key, value)
            eq(obj.get_xattr(key), value)
        stored_xattrs = {}
        for key, value in obj.get_xattrs():
            stored_xattrs[key] = value
        eq(stored_xattrs, xattrs)

    def test_create_snap(self):
        assert_raises(ObjectNotFound, self.ioctx.remove_snap, 'foo')
#.........这里部分代码省略.........

# 需要导入模块: from rados import Rados [as 别名]
# 或者: from rados.Rados import open_ioctx [as 别名]
class TestIoctx(object):

    def setUp(self):
        self.rados = Rados(conffile='')
        self.rados.connect()
        self.rados.create_pool('test_pool')
        assert self.rados.pool_exists('test_pool')
        self.ioctx = self.rados.open_ioctx('test_pool')

    def tearDown(self):
        cmd = {"prefix":"osd unset", "key":"noup"}
        self.rados.mon_command(json.dumps(cmd), b'')
        self.ioctx.close()
        self.rados.delete_pool('test_pool')
        self.rados.shutdown()

    def test_get_last_version(self):
        version = self.ioctx.get_last_version()
        assert version >= 0

    def test_get_stats(self):
        stats = self.ioctx.get_stats()
        eq(stats, {'num_objects_unfound': 0,
                   'num_objects_missing_on_primary': 0,
                   'num_object_clones': 0,
                   'num_objects': 0,
                   'num_object_copies': 0,
                   'num_bytes': 0,
                   'num_rd_kb': 0,
                   'num_wr_kb': 0,
                   'num_kb': 0,
                   'num_wr': 0,
                   'num_objects_degraded': 0,
                   'num_rd': 0})

    def test_change_auid(self):
        self.ioctx.change_auid(ANONYMOUS_AUID)
        self.ioctx.change_auid(ADMIN_AUID)

    def test_write(self):
        self.ioctx.write('abc', b'abc')
        eq(self.ioctx.read('abc'), b'abc')

    def test_write_full(self):
        self.ioctx.write('abc', b'abc')
        eq(self.ioctx.read('abc'), b'abc')
        self.ioctx.write_full('abc', b'd')
        eq(self.ioctx.read('abc'), b'd')

    def test_append(self):
        self.ioctx.write('abc', b'a')
        self.ioctx.append('abc', b'b')
        self.ioctx.append('abc', b'c')
        eq(self.ioctx.read('abc'), b'abc')

    def test_write_zeros(self):
        self.ioctx.write('abc', b'a\0b\0c')
        eq(self.ioctx.read('abc'), b'a\0b\0c')

    def test_trunc(self):
        self.ioctx.write('abc', b'abc')
        self.ioctx.trunc('abc', 2)
        eq(self.ioctx.read('abc'), b'ab')
        size = self.ioctx.stat('abc')[0]
        eq(size, 2)

    def test_list_objects_empty(self):
        eq(list(self.ioctx.list_objects()), [])

    def test_list_objects(self):
        self.ioctx.write('a', b'')
        self.ioctx.write('b', b'foo')
        self.ioctx.write_full('c', b'bar')
        self.ioctx.append('d', b'jazz')
        object_names = [obj.key for obj in self.ioctx.list_objects()]
        eq(sorted(object_names), ['a', 'b', 'c', 'd'])

    def test_list_ns_objects(self):
        self.ioctx.write('a', b'')
        self.ioctx.write('b', b'foo')
        self.ioctx.write_full('c', b'bar')
        self.ioctx.append('d', b'jazz')
        self.ioctx.set_namespace("ns1")
        self.ioctx.write('ns1-a', b'')
        self.ioctx.write('ns1-b', b'foo')
        self.ioctx.write_full('ns1-c', b'bar')
        self.ioctx.append('ns1-d', b'jazz')
        self.ioctx.append('d', b'jazz')
        self.ioctx.set_namespace(LIBRADOS_ALL_NSPACES)
        object_names = [(obj.nspace, obj.key) for obj in self.ioctx.list_objects()]
        eq(sorted(object_names), [('', 'a'), ('','b'), ('','c'), ('','d'),\
                ('ns1', 'd'), ('ns1', 'ns1-a'), ('ns1', 'ns1-b'),\
                ('ns1', 'ns1-c'), ('ns1', 'ns1-d')])

    def test_xattrs(self):
        xattrs = dict(a=b'1', b=b'2', c=b'3', d=b'a\0b', e=b'\0')
        self.ioctx.write('abc', b'')
        for key, value in xattrs.items():
            self.ioctx.set_xattr('abc', key, value)
            eq(self.ioctx.get_xattr('abc', key), value)
#.........这里部分代码省略.........

# 需要导入模块: from rados import Rados [as 别名]
# 或者: from rados.Rados import open_ioctx [as 别名]
class TestIoctx(object):
    def setUp(self):
        self.rados = Rados(conffile="")
        self.rados.connect()
        self.rados.create_pool("test_pool")
        assert self.rados.pool_exists("test_pool")
        self.ioctx = self.rados.open_ioctx("test_pool")

    def tearDown(self):
        self.ioctx.close()
        self.rados.delete_pool("test_pool")
        self.rados.shutdown()

    def test_change_auid(self):
        self.ioctx.change_auid(ANONYMOUS_AUID)
        self.ioctx.change_auid(ADMIN_AUID)

    def test_write(self):
        self.ioctx.write("abc", "abc")
        eq(self.ioctx.read("abc"), "abc")

    def test_write_full(self):
        self.ioctx.write("abc", "abc")
        eq(self.ioctx.read("abc"), "abc")
        self.ioctx.write_full("abc", "d")
        eq(self.ioctx.read("abc"), "d")

    def test_write_zeros(self):
        self.ioctx.write("abc", "a\0b\0c")
        eq(self.ioctx.read("abc"), "a\0b\0c")

    def test_list_objects_empty(self):
        eq(list(self.ioctx.list_objects()), [])

    def test_list_objects(self):
        self.ioctx.write("a", "")
        self.ioctx.write("b", "foo")
        self.ioctx.write_full("c", "bar")
        object_names = [obj.key for obj in self.ioctx.list_objects()]
        eq(sorted(object_names), ["a", "b", "c"])

    def test_xattrs(self):
        xattrs = dict(a="1", b="2", c="3", d="a\0b", e="\0")
        self.ioctx.write("abc", "")
        for key, value in xattrs.iteritems():
            self.ioctx.set_xattr("abc", key, value)
            eq(self.ioctx.get_xattr("abc", key), value)
        stored_xattrs = {}
        for key, value in self.ioctx.get_xattrs("abc"):
            stored_xattrs[key] = value
        eq(stored_xattrs, xattrs)

    def test_create_snap(self):
        assert_raises(ObjectNotFound, self.ioctx.remove_snap, "foo")
        self.ioctx.create_snap("foo")
        self.ioctx.remove_snap("foo")

    def test_list_snaps_empty(self):
        eq(list(self.ioctx.list_snaps()), [])

    def test_list_snaps(self):
        snaps = ["snap1", "snap2", "snap3"]
        for snap in snaps:
            self.ioctx.create_snap(snap)
        listed_snaps = [snap.name for snap in self.ioctx.list_snaps()]
        eq(snaps, listed_snaps)

    def test_lookup_snap(self):
        self.ioctx.create_snap("foo")
        snap = self.ioctx.lookup_snap("foo")
        eq(snap.name, "foo")

    def test_snap_timestamp(self):
        self.ioctx.create_snap("foo")
        snap = self.ioctx.lookup_snap("foo")
        snap.get_timestamp()

    def test_remove_snap(self):
        self.ioctx.create_snap("foo")
        (snap,) = self.ioctx.list_snaps()
        eq(snap.name, "foo")
        self.ioctx.remove_snap("foo")
        eq(list(self.ioctx.list_snaps()), [])