def __init__(self,
pickle_protocol=pickle.DEFAULT_PROTOCOL,
namespace=None,
**kwargs):
"""Initialize Redis DB
Args:
pickle_protocol (int, optional): https://docs.python.org/3.7/library/pickle.html#data-stream-format
namespace (str, optional): If set, key names in the Redis DB will
be preceeded by "<namespace>:".
**kwargs (optional): All these will be sent to redis.Redis(). See
https://github.com/andymccurdy/redis-py for more info.
"""
from redis import Redis
super().__init__()
self._pickle_protocol = pickle_protocol
self._namespace = namespace
# Quick check so the number of databases is sufficient
if "db" in kwargs and kwargs["db"] > 0:
redis_kwargs = kwargs.copy()
redis_kwargs["db"] = 0
redis = Redis(**redis_kwargs)
dbs = redis.config_get("databases")
if int(dbs["databases"]) <= kwargs["db"]:
redis.close()
raise ValueError(
f"Tried to open Redis DB #{kwargs['db']}, but there are only {dbs['databases']} databases"
)
redis.close()
self._redis = Redis(**kwargs)
def bzpoptimed(
r: Redis,
key: str,
*,
timeout: Union[float, int] = 0) -> Optional[Tuple[bytes, float]]:
# pylint: disable=function-redefined,missing-docstring,unused-argument; overload
"""Pop the earliest member (with score) in the sorted set at *key* as soon as it is available.
Blocking variant of :meth:`zpoptimed`. *timeout* is the maximum number of seconds to block
before returning ``None``, with ``0`` blocking indefinitely.
"""
if r not in _BZPOPTIMED_CACHE:
flags = set(r.config_get()['notify-keyspace-events']) | set('Kz')
r.config_set('notify-keyspace-events', ''.join(flags))
_BZPOPTIMED_CACHE.add(r)
deadline = time() + timeout if timeout else float('inf')
p = r.pubsub()
p.subscribe('__keyspace@{}__:{}'.format(
r.connection_pool.connection_kwargs['db'], key))
while True:
result = zpoptimed(r, key)
if isinstance(result, tuple):
p.close()
return result
now = time()
if now >= deadline:
return None
sleep = max(min(result, deadline) - now, 0)
# get_message() doesn't provide a way to block indefinitely, so just sleep very long
p.get_message(timeout=60 * 60 if isinf(sleep) else sleep)
class BaseTest(unittest.TestCase):
CAPACITY = 10000
ERROR_RATE = 0.1
KEY = b'pyreBloomTesting'
def setUp(self):
self.bloom = PyreBloom(self.KEY, self.CAPACITY, self.ERROR_RATE)
self.redis = Redis()
def tearDown(self):
"""Remove the bloom filter at the provided test key in all databases"""
databases = int(self.redis.config_get('databases').get('databases', 0))
for db in range(databases):
PyreBloom(self.KEY, 1, 0.1, db=db).delete()
class BaseTest(unittest.TestCase):
CAPACITY = 10000
ERROR_RATE = 0.1
KEY = b'pyreBloomTesting'
def setUp(self):
self.bloom = PyreBloom(self.KEY, self.CAPACITY, self.ERROR_RATE)
self.redis = Redis()
def tearDown(self):
"""Remove the bloom filter at the provided test key in all databases"""
databases = int(self.redis.config_get('databases').get('databases', 0))
for db in range(databases):
PyreBloom(self.KEY, 1, 0.1, db=db).delete()
class BaseTest(unittest.TestCase):
CAPACITY = 10000
ERROR_RATE = 0.1
KEY = 'ibloomTesting'
def setUp(self):
self.bloom = IBloom(self.KEY, self.CAPACITY, self.ERROR_RATE, HOST,
PORT)
self.redis = Redis(host='127.0.0.1', port=6383)
def tearDown(self):
"""Remove the bloom filter at the provided test key in all databases"""
databases = int(self.redis.config_get('databases').get('databases', 0))
for db in range(databases):
self.bloom.delete()
def get_databases_of_server(server_id):
q = RedisServer.query.get(server_id)
if q.password:
redis = Redis(host=q.host, port=q.port, password=q.password)
else:
redis = Redis(host=q.host, port=q.port)
db_count = int(redis.config_get('databases')['databases'])
data = []
for i in range(db_count):
if q.password:
redis = Redis(host=q.host, port=q.port, password=q.password, db=i)
else:
redis = Redis(host=q.host, port=q.port, db=i)
if redis.dbsize() > 0 or i == 0:
data.append(
{
'leaf': True,
'label': i,
'value': i
}
)
return success_json(data=data)
import sqlite3
from redis import Redis
from conn import SQLITE_DB_URI
client = Redis()
cf = 'stop-writes-on-bgsave-error'
if client.config_get(cf).get(cf) == 'yes': client.config_set(cf, 'no')
class RedisClient():
def table(self, table):
"""
# 切换表
:param table:
:return:
"""
self.__table = table
return self
def pop(self, left=False):
"""
从指定方向弹出一条
:param left:
:return:
"""
if left: row = client.lpop(self.__table)
else: row = client.rpop(self.__table)
if row: return row.decode('utf-8')
return None
from random import randint
from redis import Redis
redis = Redis()
cf = 'stop-writes-on-bgsave-error'
if redis.config_get(cf).get(cf) == 'yes': redis.config_set(cf, 'no')
table = 'proxies'
class RedisClient():
def pop(self, left=False):
"""
从指定方向弹出一条
:param left:
:return:
"""
if left: row = redis.lpop(table)
else: row = redis.rpop(table)
if row: return row.decode('utf-8')
return None
def put(self, row, left=True):
"""
从指定方向添加一条数据
:param proxy:
:param left:
:return:
"""
if left: return redis.lpush(table, row)
