def __init__(self,
socket,
host,
port,
db,
max_idle_time=30,
idle_check_interval=0.1,
max_connections=50):
self.socket = socket
self.host = host
self.port = port
self.db = db
self.max_idle_time = max_idle_time
self.idle_check_interval = idle_check_interval
self.max_connections = max_connections
self.pool = None
if self.socket != "" and (self.socket).lower() != "none":
self.connection = 'socket'
self.pool = aredis.ConnectionPool(
connection_class=UnixDomainSocketConnection,
path=self.socket,
db=self.db)
else:
self.connection = 'tcp'
self.pool = aredis.ConnectionPool(
host=self.host,
port=self.port,
db=self.db,
max_connections=self.max_connections)
self.redis = aredis.StrictRedis(connection_pool=self.pool)
self.connected = False
def _get_cache(self):
pwd, host = self.CONFIG['broker_uri'].split('@')
if pwd:
cache_pool = aredis.ConnectionPool(host=host,
password=pwd,
decode_responses=True)
else:
cache_pool = aredis.ConnectionPool(host=host,
decode_responses=True)
cache = aredis.StrictRedis(connection_pool=cache_pool)
# cache = redis.Redis(connection_pool=cache_pool)
return cache
def get_pool(self, connection_kwargs=None, max_connections=None,
connection_class=DummyConnection):
connection_kwargs = connection_kwargs or {}
pool = aredis.ConnectionPool(
connection_class=connection_class,
max_connections=max_connections,
**connection_kwargs)
return pool
async def open_connection(app_, loop):
"""
Args:
Returns:
"""
# 返回值都做了解码，应用层不需要再decode
self.pool = aredis.ConnectionPool(host=host, port=port, db=dbname, password=passwd, decode_responses=True,
max_connections=pool_size)
self.redis_db = aredis.StrictRedis(connection_pool=self.pool, decode_responses=True)
def init_engine(self,
*,
host: str = None,
port: int = None,
dbname: int = None,
passwd: str = "",
pool_size: int = None):
"""
redis 非阻塞工具类
Args:
host:redis host
port:redis port
dbname: database name
passwd: redis password
pool_size: redis pool size
Returns:
"""
host = host or self.host
port = port or self.port
dbname = dbname or self.dbname
passwd = passwd or self.passwd
pool_size = pool_size or self.pool_size
passwd = passwd if passwd is None else str(passwd)
# 返回值都做了解码，应用层不需要再decode
self.pool = aredis.ConnectionPool(host=host,
port=port,
db=dbname,
password=passwd,
decode_responses=True,
max_connections=pool_size)
self.redis_db = aredis.StrictRedis(connection_pool=self.pool,
decode_responses=True)
@atexit.register
def close_connection():
"""
释放redis连接池所有连接
Args:
Returns:
"""
self.redis_db = None
if self.pool:
self.pool.disconnect()
def __init__(
self,
host: str = redis_host,
port: int = redis_port,
db: str = redis_db,
max_idle_time: int = 30,
idle_check_interval: float = 0.1,
):
self.db = db
self.max_idle_time: int = max_idle_time
self.idle_check_interval: float = idle_check_interval
self.host: str = host
self.port: int = port
self.verified: bool = False
self.pool = aredis.ConnectionPool(host=self.host,
port=self.port,
db=self.db,
max_connections=20)
self.redis = aredis.StrictRedis(connection_pool=self.pool)
import asyncio
import json
import time
import redis
import aredis
redis_pool = aredis.ConnectionPool(host='10.0.0.48', port=6379, db=1)
def aredis_cli():
return aredis.StrictRedis(
connection_pool=redis_pool,
decode_responses=True, # 自动解码
)
class TaskModel():
def __init__(self, *args, **kwargs):
self.redis_client = aredis_cli()
async def push(self, semaphore, site, type, value):
async with semaphore:
await self.redis_client.lpush('{}_{}'.format(site, type), value)
if __name__ == '__main__':
file = 'key_dajie.list'
site = 'dajie'
import asyncio
import time
import redis
import aredis
redis_pool = aredis.ConnectionPool(
host='192.168.170.132',
port=6379,
db=1
)
def aredis_cli():
return aredis.StrictRedis(
connection_pool=redis_pool,
decode_responses=True, # 自动解码
)
TYPE1_NUM = 3
class TaskModel():
def __init__(self, *args, **kwargs):
self.redis_client = aredis_cli()
self.maps = {
1: 'type1_%s',
2: 'type2',
# 3: 'type1_to_type1',
}
import random
import functools
import logging
import pickle
from inspect import iscoroutinefunction
import redis
import aredis
from binascii import crc32
from tornado.ioloop import IOLoop
from tornado.options import options
from .exception import PermissionDenied
redis_pool = aredis.ConnectionPool(host=options.REDIS_HOST,
port=options.REDIS_PORT,
db=options.REDIS_DB)
def redis_cli():
return redis.StrictRedis(
connection_pool=redis_pool,
decode_responses=True, # 自动解码
)
def aredis_cli():
return aredis.StrictRedis(
connection_pool=redis_pool,
decode_responses=True, # 自动解码
)
def start_redis_pool(host, port, db, max_idle_time=30, idle_check_interval=0.1, max_connections=10):
pool = aredis.ConnectionPool(host=host, port=port, db=db, max_connections=max_connections)
return aredis.StrictRedis(connection_pool=pool)
import asyncio
import uvloop
import aredis
from aredis.connection import UnixDomainSocketConnection
from prettyprinter import pprint
pool = aredis.ConnectionPool(connection_class=UnixDomainSocketConnection,
path='/tmp/redis-cache.sock',
db=0)
redis = aredis.StrictRedis(connection_pool=pool)
async def speak_async():
pprint(await redis.exists('news'))
b = redis.cache('news')
pprint(dir(b))
loop = asyncio.get_event_loop()
uvloop.install()
loop.run_until_complete(speak_async())
loop.close()
def init_redis(self, host, port, db):
self.redis_client = aredis.StrictRedis(
connection_pool=aredis.ConnectionPool(host=host, port=port, db=db),
decode_responses=True, # 自动解码
)
