Python Rados.connect方法代码示例

# 需要导入模块: from rados import Rados [as 别名]
# 或者: from rados.Rados import connect [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 connect [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 connect [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 connect [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 connect [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 connect [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 connect [as 别名]
class CephClusterCommand(dict):
    """
    Issue a ceph command on the given cluster and provide the returned json
    """
    def configure(self):
        self.config = CephApiConfig()
        self.clusterprop = CephClusterProperties(self.config)
        self.cluster = Rados(**self.clusterprop)

    def __init__(self, **kwargs):
        self.configure()
        self.cmd = json.dumps(kwargs)
        dict.__init__(self)

    def run(self):
        self.configure()
        self.cluster.connect()
        self.cluster.require_state("connected")
        ret, buf, err = self.cluster.mon_command(self.cmd, '', timeout=5)
        if ret != 0:
            self['err'] = err
        else:
            self.update(json.loads(buf, parse_int=str))
        self.cluster.shutdown()
        return self

# 需要导入模块: from rados import Rados [as 别名]
# 或者: from rados.Rados import connect [as 别名]
class TestCommand(object):
    def setUp(self):
        self.rados = Rados(conffile="")
        self.rados.connect()

    def tearDown(self):
        self.rados.shutdown()

    def test_monmap_dump(self):

        # check for success and some plain output with epoch in it
        cmd = {"prefix": "mon dump"}
        ret, buf, errs = self.rados.mon_command(json.dumps(cmd), "", timeout=30)
        eq(ret, 0)
        assert len(buf) > 0
        assert "epoch" in buf

        # JSON, and grab current epoch
        cmd["format"] = "json"
        ret, buf, errs = self.rados.mon_command(json.dumps(cmd), "", timeout=30)
        eq(ret, 0)
        assert len(buf) > 0
        d = json.loads(buf)
        assert "epoch" in d
        epoch = d["epoch"]

        # assume epoch + 1000 does not exist; test for ENOENT
        cmd["epoch"] = epoch + 1000
        ret, buf, errs = self.rados.mon_command(json.dumps(cmd), "", timeout=30)
        eq(ret, -errno.ENOENT)
        eq(len(buf), 0)
        del cmd["epoch"]

        # send to specific target by name
        target = d["mons"][0]["name"]
        print target
        ret, buf, errs = self.rados.mon_command(json.dumps(cmd), "", timeout=30, target=target)
        eq(ret, 0)
        assert len(buf) > 0
        d = json.loads(buf)
        assert "epoch" in d

        # and by rank
        target = d["mons"][0]["rank"]
        print target
        ret, buf, errs = self.rados.mon_command(json.dumps(cmd), "", timeout=30, target=target)
        eq(ret, 0)
        assert len(buf) > 0
        d = json.loads(buf)
        assert "epoch" in d

    def test_osd_bench(self):
        cmd = dict(prefix="bench", size=4096, count=8192)
        ret, buf, err = self.rados.osd_command(0, json.dumps(cmd), "", timeout=30)
        eq(ret, 0)
        assert len(err) > 0
        out = json.loads(err)
        eq(out["blocksize"], cmd["size"])
        eq(out["bytes_written"], cmd["count"])

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

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

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

    def setUp(self):
        self.rados = Rados(conffile='')
        self.rados.conf_parse_env('FOO_DOES_NOT_EXIST_BLAHBLAH')
        self.rados.conf_parse_env()
        self.rados.connect()

        # Assume any pre-existing pools are the cluster's defaults
        self.default_pools = self.rados.list_pools()

    def tearDown(self):
        self.rados.shutdown()

    def test_create(self):
        self.rados.create_pool('foo')
        self.rados.delete_pool('foo')

    def test_create_auid(self):
        self.rados.create_pool('foo', 100)
        assert self.rados.pool_exists('foo')
        self.rados.delete_pool('foo')

    def test_eexist(self):
        self.rados.create_pool('foo')
        assert_raises(ObjectExists, self.rados.create_pool, 'foo')
        self.rados.delete_pool('foo')

    def list_non_default_pools(self):
        pools = self.rados.list_pools()
        for p in self.default_pools:
            pools.remove(p)
        return set(pools)

    def test_list_pools(self):
        eq(set(), self.list_non_default_pools())
        self.rados.create_pool('foo')
        eq(set(['foo']), self.list_non_default_pools())
        self.rados.create_pool('bar')
        eq(set(['foo', 'bar']), self.list_non_default_pools())
        self.rados.create_pool('baz')
        eq(set(['foo', 'bar', 'baz']), self.list_non_default_pools())
        self.rados.delete_pool('foo')
        eq(set(['bar', 'baz']), self.list_non_default_pools())
        self.rados.delete_pool('baz')
        eq(set(['bar']), self.list_non_default_pools())
        self.rados.delete_pool('bar')
        eq(set(), self.list_non_default_pools())
        self.rados.create_pool('a' * 500)
        eq(set(['a' * 500]), self.list_non_default_pools())
        self.rados.delete_pool('a' * 500)

    def test_get_fsid(self):
        fsid = self.rados.get_fsid()
        eq(len(fsid), 36)

# 需要导入模块: from rados import Rados [as 别名]
# 或者: from rados.Rados import connect [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 connect [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
    ioctx = rados.open_ioctx(pool_name)

# 需要导入模块: from rados import Rados [as 别名]
# 或者: from rados.Rados import connect [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 connect [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 connect [as 别名]
class TestMonCommand(object):

    def setUp(self):
        self.rados = Rados(conffile='')
        self.rados.connect()

    def tearDown(self):
        self.rados.shutdown()

    def test_monmap_dump(self):

        # check for success and some plain output with epoch in it
        cmd = {"prefix":"mon dump"}
        ret, buf, errs = self.rados.mon_command(json.dumps(cmd), '', timeout=30)
        eq(ret, 0)
        assert len(buf) > 0
        assert('epoch' in buf)

        # JSON, and grab current epoch
        cmd['format'] = 'json'
        ret, buf, errs = self.rados.mon_command(json.dumps(cmd), '', timeout=30)
        eq(ret, 0)
        assert len(buf) > 0
        d = json.loads(buf)
        assert('epoch' in d)
        epoch = d['epoch']

        # assume epoch + 1000 does not exist; test for ENOENT
        cmd['epoch'] = epoch + 1000
        ret, buf, errs = self.rados.mon_command(json.dumps(cmd), '', timeout=30)
        eq(ret, -errno.ENOENT)
        eq(len(buf), 0)
        del cmd['epoch']

        # send to specific target by name
        target = d['mons'][0]['name']
        print target
        ret, buf, errs = self.rados.mon_command(json.dumps(cmd), '', timeout=30,
                                                target=target)
        eq(ret, 0)
        assert len(buf) > 0
        d = json.loads(buf)
        assert('epoch' in d)

        # and by rank
        target = d['mons'][0]['rank']
        print target
        ret, buf, errs = self.rados.mon_command(json.dumps(cmd), '', timeout=30,
                                                target=target)
        eq(ret, 0)
        assert len(buf) > 0
        d = json.loads(buf)
        assert('epoch' in d)