def setUp(self):
pool = ConnectionPool(
host='localhost', port=6379, db=9,
encoding='utf-8', decode_responses=True,
parser_class=HiredisParser)
self.client = redis.Redis(connection_pool=pool)
self.client.flushdb()
def _construct_connection_pool(pool):
""" Construct a blocking socket connection pool based on asynchronous pool
"""
_pool = ConnectionPool(Connection, pool.max_connections,
**pool.connection_kwargs)
return _pool
def __init__(self,
host='localhost',
port=6379,
db=0,
password=None,
socket_timeout=None,
connection_pool=None,
charset='utf-8',
errors='strict',
unix_socket_path=None):
if not connection_pool:
kwargs = {
'db': db,
'password': password,
'socket_timeout': socket_timeout,
'encoding': charset,
'encoding_errors': errors
}
# based on input, setup appropriate connection args
if unix_socket_path:
kwargs.update({
'path': unix_socket_path,
'connection_class': UnixDomainSocketConnection
})
else:
kwargs.update({'host': host, 'port': port})
connection_pool = ConnectionPool(**kwargs)
self.connection_pool = connection_pool
self.response_callbacks = self.__class__.RESPONSE_CALLBACKS.copy()
def __init__(self,
client_ns_versions,
host='localhost',
port=6379,
db=0,
password=None,
socket_timeout=None,
socket_connect_timeout=None,
socket_keepalive=None,
socket_keepalive_options=None,
connection_pool=None,
unix_socket_path=None,
encoding='utf-8',
encoding_errors='strict',
charset=None,
errors=None,
decode_responses=False,
retry_on_timeout=False,
ssl=False,
ssl_keyfile=None,
ssl_certfile=None,
ssl_cert_reqs=None,
ssl_ca_certs=None):
kwargs = {
'db': db,
'password': password,
'socket_timeout': socket_timeout,
'encoding': encoding,
'encoding_errors': encoding_errors,
'decode_responses': decode_responses,
'retry_on_timeout': retry_on_timeout,
'fun_ptr': self.verify_ns_info
}
# TCP specific options
kwargs.update({
'host': host,
'port': port,
'socket_connect_timeout': socket_connect_timeout,
'socket_keepalive': socket_keepalive,
'socket_keepalive_options': socket_keepalive_options,
})
self.connection_pool = ConnectionPool(connection_class=NoReConnection,
**kwargs)
self._use_lua_lock = None
self.response_callbacks = self.__class__.RESPONSE_CALLBACKS.copy()
self.client_ns_versions = dict()
#dict of lists of namespace versions
self.ns_versions_dict = dict()
# check to see if we are the initial version and must init
for (ns, v) in client_ns_versions:
self.append_new_version(v, ns, startup=True)
#logging.debug(self.client_ns_versions)
# check to see if existing updates need to be loaded into this client
self.upd_dict = dict()
self.load_upd_tuples()
self.client_setname(self.ns_dict_as_string())
class RedisClient(Redis):
"""Redis client, 使用一个全局的连接池"""
_pool = ConnectionPool(**config['redis'])
def __init__(self, **kwargs):
kwargs.setdefault('connection_pool', self._pool)
super().__init__(**kwargs)
def __init__(self,
host='localhost',
port=7711,
password=None,
socket_timeout=None,
socket_connect_timeout=None,
socket_keepalive=None,
socket_keepalive_options=None,
connection_pool=None,
unix_socket_path=None,
encoding='utf-8',
encoding_errors='strict',
decode_responses=False,
retry_on_timeout=False,
job_origin_ttl_secs=5,
record_job_origin=False):
"""
job_origin_ttl_secs is the number of seconds to store counts of
incoming jobs. The higher the throughput you're expecting, the lower
this number should be.
"""
self.record_job_origin = record_job_origin
kwargs = {
'password': password,
'socket_timeout': socket_timeout,
'encoding': encoding,
'encoding_errors': encoding_errors,
'decode_responses': decode_responses,
'retry_on_timeout': retry_on_timeout,
'db': 0,
}
# based on input, setup appropriate connection args
if unix_socket_path is not None:
kwargs.update({
'path': unix_socket_path,
'connection_class': UnixDomainSocketConnection
})
else:
# TCP specific options
kwargs.update({
'host': host,
'port': port,
'socket_connect_timeout': socket_connect_timeout,
'socket_keepalive': socket_keepalive,
'socket_keepalive_options': socket_keepalive_options,
})
if not connection_pool:
connection_pool = ConnectionPool(**kwargs)
self.response_callbacks = self.__class__.RESPONSE_CALLBACKS.copy()
self.connection_pool = {'default': connection_pool}
self.default_node = 'default'
self._job_score = RollingCounter(ttl_secs=job_origin_ttl_secs)
self.__connect_cluster(kwargs)
def __connect_cluster(self, connection_kwargs):
hi = self.hello()
self.default_node = bin_to_str(hi['id'][:8])
self.connection_pool.pop('default')
for node, ip, port, version in hi['nodes']:
connection_kwargs.update(dict(host=ip, port=port))
self.connection_pool[bin_to_str(
node[:8])] = ConnectionPool(**connection_kwargs)
def __init__(self, hosts, **kwargs):
self.pools = []
for host in hosts:
pool = ConnectionPool(host=host['host'],
port=host['port'],
**kwargs)
self.pools.append(pool)
self._len = len(pool)
self.idx = 0
def test_conflicting_init_args(self):
options = {'host': 'localhost', 'url': 'redis://localhost',
'connection_pool': ConnectionPool()}
combinations = itertools.combinations(options.items(), 2)
for kwargs in (dict(item) for item in combinations):
self.assertRaises(ConfigurationError, lambda: RedisHuey(**kwargs))
# None values are fine, however.
RedisHuey(host=None, port=None, db=None, url='redis://localhost')
def __init__(self, hosts, **kwargs):
host = hosts[0]
if isinstance(host, str):
self.pool = ConnectionPool.from_url(host, **kwargs)
else:
db = host.get('db', 0)
self.pool = ConnectionPool(host=host['host'],
port=host['port'],
db=db,
**kwargs)
def normal_poll():
pool = ConnectionPool(host='127.0.0.1', port=6379, db=0)
cli = Redis(connection_pool=pool)
poller = poll()
conns = [(key, cli.connection_pool.get_connection('_')) for key in keys]
register(conns, poller)
try:
start_poll(conns, poller, cli)
except KeyboardInterrupt:
unregister(conns, poller)
def test_conflicting_init_args(self):
options = {
'host': 'localhost',
'url': 'redis://localhost',
'connection_pool': ConnectionPool()
}
combinations = itertools.combinations(options.items(), 2)
for kwargs in (dict(item) for item in combinations):
self.assertRaises(ValueError, lambda: RedisStorage(**kwargs))
def test_pool(self):
pool = ConnectionPool(host=self.ip,
port=self.port,
db=1,
max_connections=20)
r = Redis(connection_pool=pool)
r.set("huawei", "huawei")
print r.get("huawei")
r.delete("huawei")
print r.ping()
print r.get("huawei")
print 2**2
def __init__(self,
ip="",
port=6379,
defalutDb=1,
max_connections=30,
password=""):
self.pool = ConnectionPool(host=ip,
port=port,
db=defalutDb,
max_connections=max_connections,
password=password)
self.redis = Redis(connection_pool=self.pool)
def init_pools(self, hosts, **kwargs):
# Ensure consistency of db value
kwargs.update({'db': 0})
for host in hosts:
if isinstance(host, str):
addr = self.parse_addr(host)
pool = ConnectionPool.from_url(host, **kwargs)
else:
addr = '{}:{}'.format(host['host'], host['port'])
pool = ConnectionPool(host=host['host'],
port=host['port'],
**kwargs)
self.cluster_pools[addr] = pool
self.reset_slots(**kwargs)
def get_pool(self, key=None):
if not key:
pool = self.get_random_pool()
return pool
addr = self._key_to_addr(key)
if addr:
pool = self.cluster_pools.get(addr)
if not pool:
host, port = addr.split(':')
pool = ConnectionPool(host=host,
port=int(port),
**self.pool_kwargs)
self.cluster_pools[addr] = pool
return pool
raise ClusterError("No slot found for key...", key)
def _shared_pool(**opts):
if "host" in opts:
key = "{}:{}/{}".format(opts["host"], opts["port"], opts["db"])
else:
key = "{}/{}".format(opts["path"], opts["db"])
pool = _pool_cache.get(key)
if pool is not None:
return pool
with _pool_lock:
pool = _pool_cache.get(key)
if pool is not None:
return pool
pool = ConnectionPool(**opts)
_pool_cache[key] = pool
return pool
def _shared_pool(**opts):
if 'host' in opts:
key = '%s:%s/%s' % (opts['host'], opts['port'], opts['db'], )
else:
key = '%s/%s' % (opts['path'], opts['db'])
pool = _pool_cache.get(key)
if pool is not None:
return pool
with _pool_lock:
pool = _pool_cache.get(key)
if pool is not None:
return pool
pool = ConnectionPool(**opts)
_pool_cache[key] = pool
return pool
def __init__(self,
host='localhost',
port=6379,
db=0,
password=None,
connection_pool=None,
max_connections=None):
if not connection_pool:
kwargs = {
'host': host,
'port': port,
'db': db,
'password': password,
'max_connections': max_connections
}
connection_pool = ConnectionPool(**kwargs)
self.connection_pool = connection_pool
def reset_slots(self, **kwargs):
pool = self.get_random_pool()
resp = pool.execute_command('CLUSTER', 'SLOTS')
if not isinstance(resp, (list, tuple)):
raise RedisError('Unable to locate redis slots.')
_pools = {}
for elem in resp:
_start, _end, master = elem[0], elem[1], elem[2]
ip, port = self._stringconv(master[0]), self._stringconv(master[1])
addr = '{}:{}'.format(ip, port)
for i in range(int(_start), int(_end) + 1):
self.mapping[i] = addr
if addr not in _pools:
p = (self.cluster_pools.pop(addr, None)
or ConnectionPool(host=ip, port=port, **kwargs))
p.addr = addr
_pools[addr] = p
self.cluster_pools.clear()
self.cluster_pools = _pools
# -*- coding: utf-8 -*-
import redis
import threading
import logging
from redis.connection import ConnectionPool
redis_settings = {"servers": "localhost", "port": 6379, "db": 11}
_pool0 = ConnectionPool(**redis_settings)
class RedisClient(object):
instance = None
locker = threading.Lock()
def __init__(self):
""" intialize the client of redis include port db and servers """
try:
self.servers = redis_settings["servers"]
self.port = redis_settings["port"]
self.db = redis_settings["db"]
self.redis = redis.Redis(connection_pool=_pool0)
except Exception, e:
logging.error(e)
@classmethod
def get_instance(cls):
"""
get the instance of RedisClient
def getPool():
return ConnectionPool(host='223.4.155.152')
# encoding: utf-8
import tornado.ioloop
import redis
from tornado import gen
from tornado.web import RequestHandler, Application
from redis.connection import ConnectionPool
from async_redis.connection import AsyncConnection
from async_redis.client import AsyncRedis
connection_pool = ConnectionPool(AsyncConnection, host='localhost', port=6379, db=0, socket_connect_timeout=0.00000001)
async_redis = AsyncRedis(connection_pool=connection_pool)
sync_redis = redis.StrictRedis()
class MainHandler(RequestHandler):
@gen.coroutine
def get(self):
key1, value1 = 'my_key1', 'value1'
key2, value2 = 'my_key2', 'value2'
key3, value3 = 'my_key3', 'value3'
with async_redis.pipeline() as p:
p.set(key1, value1)
p.set(key2, value2)
p.set(key3, value3)
p.get(key1)
p.get(key2)
p.get(key3)
result = yield p.execute()
import redis
from redis.connection import ConnectionPool, PythonParser
from config import CONFIG as cfg
# Because of a bug (https://github.com/andymccurdy/redis-py/issues/318) with
# script reloading in `redis-py, we need to force the `PythonParser` to prevent
# sixpack from crashing if redis restarts (or scripts are flushed).
pool = ConnectionPool(host=cfg.get('redis_host'),
port=cfg.get('redis_port'),
db=cfg.get('redis_db'),
parser_class=PythonParser)
REDIS = redis.StrictRedis(connection_pool=pool)
DEFAULT_PREFIX = cfg.get('redis_prefix')
def _key(k):
return "{0}:{1}".format(DEFAULT_PREFIX, k)
monotonic_zadd = REDIS.register_script("""
local sequential_id = redis.call('zscore', KEYS[1], ARGV[1])
if not sequential_id then
sequential_id = redis.call('zcard', KEYS[1])
redis.call('zadd', KEYS[1], sequential_id, ARGV[1])
end
return sequential_id
""")
def sequential_id(k, identifier):
# sixpack from crashing if redis restarts (or scripts are flushed).
if cfg.get('redis_sentinels'):
from redis.sentinel import Sentinel, SentinelConnectionPool
service_name = cfg.get('redis_sentinel_service_name')
sentinel = Sentinel(sentinels=cfg.get('redis_sentinels'),
password=cfg.get('redis_password', None),
socket_timeout=cfg.get('redis_socket_timeout'))
pool = SentinelConnectionPool(service_name, sentinel,
db=cfg.get('redis_db'),
max_connections=cfg.get('redis_max_connections'),
parser_class=PythonParser)
else:
from redis.connection import ConnectionPool
pool = ConnectionPool(host=cfg.get('redis_host'),
port=cfg.get('redis_port'),
password=cfg.get('redis_password', None),
db=cfg.get('redis_db'),
max_connections=cfg.get('redis_max_connections'),
parser_class=PythonParser)
REDIS = redis.StrictRedis(connection_pool=pool)
DEFAULT_PREFIX = cfg.get('redis_prefix')
def _key(k):
return "{0}:{1}".format(DEFAULT_PREFIX, k)
monotonic_zadd = REDIS.register_script("""
local sequential_id = redis.call('zscore', KEYS[1], ARGV[1])
if not sequential_id then
sequential_id = redis.call('zcard', KEYS[1])
def __init__(self):
pool = ConnectionPool(host=cfg.REDIS_HOST, port=cfg.REDIS_PORT)
self.client = Redis(connection_pool=pool)
