コード例 #1
0
 def get_client(self):
     redis_cluster = RedisCluster(self.hosts, router_cls=self.router_cls,
                                  router_options=self.router_options,
                                  pool_cls=self.pool_cls,
                                  pool_options=self.pool_options)
     return redis_cluster.get_client(self.max_concurrency,
                                     self.poller_timeout)
コード例 #2
0
ファイル: cache.py プロジェクト: fengsp/rc
 def get_client(self):
     redis_cluster = RedisCluster(self.hosts, router_cls=self.router_cls,
                                  router_options=self.router_options,
                                  pool_cls=self.pool_cls,
                                  pool_options=self.pool_options)
     return redis_cluster.get_client(self.max_concurrency,
                                     self.poller_timeout)
コード例 #3
0
ファイル: test_redis_clients.py プロジェクト: neocortex/rc
def test_redis_cluster_client_basic_operations(redis_hosts):
    cluster = RedisCluster(redis_hosts)
    client = cluster.get_client()

    keys = []
    for i in xrange(10):
        key = 'test key: %s' % i
        keys.append(key)
        client.set(key, i)
    for i, key in enumerate(keys):
        assert client.get(key) == str(i)
    assert client.mget(keys) == map(str, range(10))

    keys = []
    for i in xrange(10, 20):
        key = 'test key: %s' % i
        keys.append(key)
        client.setex(key, 100, i)
    for i, key in enumerate(keys, 10):
        assert client.get(key) == str(i)
    assert client.mget(keys) == map(str, range(10, 20))

    keys = []
    deleted_keys = []
    for i in xrange(20, 30):
        key = 'test key: %s' % i
        keys.append(key)
        client.setex(key, 100, i)
    for i in xrange(20, 25):
        key = 'test key: %s' % i
        deleted_keys.append(key)
        client.delete(key)
    for i, key in enumerate(keys[5:], 25):
        assert client.get(key) == str(i)
    for key in deleted_keys:
        assert client.get(key) is None
    assert client.mget(keys) == [None] * 5 + map(str, range(25, 30))

    keys = []
    mapping = {}
    deleted_keys = []
    for i in xrange(30, 40):
        key = 'test key: %s' % i
        mapping[key] = i
        keys.append(key)
    assert client.msetex(mapping, 100)
    for i, key in enumerate(keys, 30):
        assert client.get(key) == str(i)
    assert client.mget(keys) == map(str, range(30, 40))
    for i in xrange(30, 35):
        key = 'test key: %s' % i
        deleted_keys.append(key)
    assert client.mdelete(*deleted_keys)
    for i, key in enumerate(keys[5:], 35):
        assert client.get(key) == str(i)
    for key in deleted_keys:
        assert client.get(key) is None
    assert client.mget(keys) == [None] * 5 + map(str, range(35, 40))
コード例 #4
0
ファイル: test_redis_cluster.py プロジェクト: neocortex/rc
def test_cluster_pools():
    cluster = RedisCluster({
        0: {'password': '******', 'ssl': True},
        1: {'unix_socket_path': '/tmp/redis_socket'},
    })
    pool_for_0 = cluster.get_pool_of_host(0)
    pool_for_1 = cluster.get_pool_of_host(1)
    pool_for_0_again = cluster.get_pool_of_host(0)
    assert pool_for_0 is pool_for_0_again
    assert pool_for_0 is not pool_for_1
コード例 #5
0
def test_all_pollers(redis_hosts, poller, monkeypatch):
    monkeypatch.setattr(redis_clients, 'poller', poller)

    # assert len(supported_pollers) == 4
    redis_cluster = RedisCluster(redis_hosts)
    cluster_client = redis_cluster.get_client()
    keys = []
    for i in range(10):
        key = 'key-%s' % i
        keys.append(key)
        cluster_client.set(key, i)
    assert cluster_client.mget(keys) == map(str, range(10))
コード例 #6
0
ファイル: test_redis_cluster.py プロジェクト: neocortex/rc
def test_cluster_constructor():
    cluster = RedisCluster({
        0: {'password': '******', 'ssl': True},
        1: {'host': '127.0.0.1', 'port': 10000, 'db': 1},
        2: {'unix_socket_path': '/tmp/redis_socket'},
    })

    assert cluster.hosts[0].host_name == 0
    assert cluster.hosts[0].host == 'localhost'
    assert cluster.hosts[0].port == 6379
    assert cluster.hosts[0].unix_socket_path is None
    assert cluster.hosts[0].db == 0
    assert cluster.hosts[0].password == 'pass'
    assert cluster.hosts[0].ssl is True
    assert cluster.hosts[0].ssl_options is None

    assert cluster.hosts[1].host_name == 1
    assert cluster.hosts[1].host == '127.0.0.1'
    assert cluster.hosts[1].port == 10000
    assert cluster.hosts[1].unix_socket_path is None
    assert cluster.hosts[1].db == 1
    assert cluster.hosts[1].password is None
    assert cluster.hosts[1].ssl is False
    assert cluster.hosts[1].ssl_options is None

    assert cluster.hosts[2].host_name == 2
    assert cluster.hosts[2].host == 'localhost'
    assert cluster.hosts[2].port == 6379
    assert cluster.hosts[2].unix_socket_path == '/tmp/redis_socket'
    assert cluster.hosts[2].db == 0
    assert cluster.hosts[2].password is None
    assert cluster.hosts[2].ssl is False
    assert cluster.hosts[2].ssl_options is None
コード例 #7
0
ファイル: test_redis_router.py プロジェクト: neocortex/rc
def test_redis_router_basics():
    cluster = RedisCluster({
        0: {},
        1: {},
        2: {},
    })
    router = cluster.router

    assert router.get_key_for_command('GET', 'c') == 'c'
    assert router.get_key_for_command('SET', 'g') == 'g'
    with pytest.raises(RuntimeError):
        router.get_key_for_command('MGET', ['a', 'b', 'c'])

    assert router.get_host_for_key('c') == 0
    assert router.get_host_for_key('g') == 1
    assert router.get_host_for_key('a') == 2

    assert router.get_host_for_command('GET', 'c') == 0
    assert router.get_host_for_command('GET', 'g') == 1
    assert router.get_host_for_command('SET', 'a') == 2
コード例 #8
0
ファイル: bench.py プロジェクト: fatelei/rc
import time
from itertools import izip

from redis import StrictRedis
from rc.redis_cluster import RedisCluster


cluster = RedisCluster({
    0: {'host': 'redis01.aws.dev', 'port': 4001, 'db': 0},
    1: {'host': 'redis01.aws.dev', 'port': 4001, 'db': 1},
    2: {'host': 'redis01.aws.dev', 'port': 4001, 'db': 2},
    3: {'host': 'redis01.aws.dev', 'port': 4001, 'db': 3},
    4: {'host': 'redis01.aws.dev', 'port': 4001, 'db': 4},
    5: {'host': 'redis01.aws.dev', 'port': 4001, 'db': 5},
    6: {'host': 'redis01.aws.dev', 'port': 4001, 'db': 6},
})
cluster_router = cluster.router
cluster_client = cluster.get_client()
clients = [
    StrictRedis(host='redis01.aws.dev', port=4001, db=0),
    StrictRedis(host='redis01.aws.dev', port=4001, db=1),
    StrictRedis(host='redis01.aws.dev', port=4001, db=2),
    StrictRedis(host='redis01.aws.dev', port=4001, db=3),
    StrictRedis(host='redis01.aws.dev', port=4001, db=4),
    StrictRedis(host='redis01.aws.dev', port=4001, db=5),
    StrictRedis(host='redis01.aws.dev', port=4001, db=6),
]


def bench_cluster(keys):
    print 'Benching cluster...'
コード例 #9
0
ファイル: bench.py プロジェクト: neocortex/rc
cluster = RedisCluster({
    0: {
        'host': 'redis01.aws.dev',
        'port': 4001,
        'db': 0
    },
    1: {
        'host': 'redis01.aws.dev',
        'port': 4001,
        'db': 1
    },
    2: {
        'host': 'redis01.aws.dev',
        'port': 4001,
        'db': 2
    },
    3: {
        'host': 'redis01.aws.dev',
        'port': 4001,
        'db': 3
    },
    4: {
        'host': 'redis01.aws.dev',
        'port': 4001,
        'db': 4
    },
    5: {
        'host': 'redis01.aws.dev',
        'port': 4001,
        'db': 5
    },
    6: {
        'host': 'redis01.aws.dev',
        'port': 4001,
        'db': 6
    },
})