本文整理汇总了Python中redis.StrictRedis.llen方法的典型用法代码示例。如果您正苦于以下问题:Python StrictRedis.llen方法的具体用法?Python StrictRedis.llen怎么用?Python StrictRedis.llen使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类redis.StrictRedis
的用法示例。
在下文中一共展示了StrictRedis.llen方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: Worker
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import llen [as 别名]
class Worker(object):
def __init__(self, queue_name=None, from_queue=None, host='127.0.0.1', port=6379, db=0, prefix='easy_jobs:queue:'):
self.queue_name = queue_name
self.from_queue = from_queue
self.outputs = ['results']
if from_queue:
self.connection = self.from_queue.connection
self.key = self.from_queue.key
else:
self.key = '%s%s' % (prefix, queue_name)
self.connection = StrictRedis(host=host, port=port, db=db)
def start(self, once=False, threaded=False):
jobs = self.connection.llen(self.key)
while jobs > 0:
pickled = self.connection.rpop(self.key)
if pickled:
un_pickled = loads(pickled)
instance = un_pickled['foo']
args = un_pickled['args']
kwargs = un_pickled['kwargs']
p = Process(target=instance, args=args, kwargs=kwargs)
p.start()
if not threaded:
p.join()
jobs = self.connection.llen(self.key) if not once else -1
示例2: __init__
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import llen [as 别名]
class Repository:
def __init__(self, host, port):
self.r = StrictRedis(host=host, port=port)
# store dictionary
# redis.hmset(hkey, dict_to_store)
# retrieve dictionary
# redis.hmget(hkey)
# lists
# redis.lappend(hkey, string)
# redis.llen
def get_item(self, key_store, index):
length = self.r.llen(key_store)
if length == 0:
return None
if index >= length:
raise Exception('Index out of range.')
item_json = self.r.lindex(key_store, length - (index + 1))
item_dict = json.loads(item_json)
return item_dict
def append_item(self, key_store, item):
item_json = json.dumps(item)
if not self.r.lpush(key_store, item_json):
raise Exception('Unable to write key_store: [%s]' % item_json)
def fetch_all(self, key_store):
q = []
length = self.r.llen(key_store)
for i in range(length):
item_json = self.r.lindex(key_store, length - (i + 1))
item_dict = json.loads(item_json)
q.append(item_dict)
return q
def set(self, key_store, list):
self.r.delete(key_store)
for item_dict in list:
item_json = json.dumps(item_dict)
if not self.r.lpush(key_store, item_json):
raise Exception('Unable to write key_store: [%s]' % item_json)
def delete(self, key_store):
self.r.delete(key_store)
def info(self):
return self.r.info()
示例3: JSONRedisBackend
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import llen [as 别名]
class JSONRedisBackend(BaseBackend):
def __init__(self):
self.redis = StrictRedis()
def serialize(self, value):
return json.dumps(value)
def deserialize(self, value):
return value and json.loads(value) or None
def get(self, key):
value = self.redis.get(key)
result = self.deserialize(value)
return result
def set(self, key, value):
product = self.serialize(value)
return self.redis.set(key, product)
def rpush(self, key, value):
product = self.serialize(value)
return self.redis.rpush(key, product)
def lpush(self, key, value):
product = self.serialize(value)
return self.redis.lpush(key, product)
def lpop(self, key):
value = self.redis.lpop(key)
result = self.deserialize(value)
return result
def llen(self, key):
return self.redis.llen(key)
def rpop(self, key):
value = self.redis.rpop(key)
result = self.deserialize(value)
return result
def report_steps(self, name, consumers, producers):
pipeline = self.redis.pipeline()
producers_key = ':'.join([name, 'producers'])
consumers_key = ':'.join([name, 'consumers'])
for consumer in consumers:
pipeline.sadd(consumers_key, consumer)
for producer in producers:
pipeline.sadd(producers_key, producer)
pipeline.smembers(consumers_key)
pipeline.smembers(producers_key)
result = pipeline.execute()
all_consumers = result[-2]
all_producers = result[-1]
return all_consumers, all_producers
示例4: DbRedis
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import llen [as 别名]
class DbRedis(Db):
def __init__(self):
super().__init__()
self.redis = StrictRedis(**dbSettings)
def generateKey(self):
return self.redis.incr("id")
def store(self, key, objSerial):
self.redis.setex(key, TTL, objSerial)
def retrieve(self, key):
return self.redis.get(key)
def lenList(self, name):
return self.redis.llen(name)
def listAppend(self, name, val):
self.redis.lpush(name, val)
def listPopLeft(self, name):
return self.redis.lpop(name)
def retrieveList(self, name):
return self.redis.lrange(name, 0, -1)
def removeFromList(self, name, item):
self.redis.lrem(name, item, 0)
def keyExists(self, key):
return self.redis.exists(key)
示例5: RedisQueue
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import llen [as 别名]
class RedisQueue():
def __init__(self):
"""
初始化Redis
"""
self.db = StrictRedis(host=REDIS_HOST, port=REDIS_PORT, password=REDIS_PASSWORD)
def add(self, request):
"""
向队列添加序列化后的Request
:param request: 请求对象
:return: 添加结果
"""
if isinstance(request, WeixinRequset):
return self.db.rpush(REDIS_KEY, dumps(request))
return False
def pop(self):
"""
取出下一个Request并反序列化
:return: Request or None
"""
if self.db.llen(REDIS_KEY):
return loads(self.db.lpop(REDIS_KEY))
else:
return False
def clear(self):
self.db.delete(REDIS_KEY)
def empty(self):
"""
检查是否为空
:return:
"""
return self.db.llen(REDIS_KEY) == 0
示例6: __init__
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import llen [as 别名]
class VisualDebugger:
def __init__(self):
self.available_buckets = config["visual_debugger"]["available_buckets"]
self.bucket_generator = itertools.cycle(self.available_buckets)
self.redis_client = StrictRedis(**config["redis"])
self.clear_image_data()
def store_image_data(self, image_data, image_shape, bucket="debug"):
self.redis_client.lpush(f"{config['visual_debugger']['redis_key_prefix']}:{bucket}:SHAPE", pickle.dumps(image_shape))
self.redis_client.lpush(f"{config['visual_debugger']['redis_key_prefix']}:{bucket}", image_data.tobytes())
def retrieve_image_data(self):
bucket = next(self.bucket_generator)
bucket_key = f"{config['visual_debugger']['redis_key_prefix']}:{bucket}"
response = self.redis_client.rpop(bucket_key)
if response is not None:
bucket = bucket_key.split(":")[-1]
image_shape = self.redis_client.rpop(f"{config['visual_debugger']['redis_key_prefix']}:{bucket}:SHAPE")
image_shape = pickle.loads(image_shape)
image_data = np.fromstring(response, dtype="uint8").reshape(image_shape)
return bucket, image_data
return None
def save_image_data(self, bucket, image_data):
if bucket in self.available_buckets:
if image_data.dtype == "bool" or (image_data.dtype == "uint8" and 1 in np.unique(image_data)):
image_data = image_data.astype("uint8") * 255
skimage.io.imsave(f"{bucket}.png", image_data)
def clear_image_data(self):
visual_debugger_keys = self.redis_client.keys(f"{config['visual_debugger']['redis_key_prefix']}*")
for key in visual_debugger_keys:
self.redis_client.delete(key.decode("utf-8"))
def get_bucket_queue_length(self, bucket):
return self.redis_client.llen(f"{config['visual_debugger']['redis_key_prefix']}:{bucket}")
示例7: QueueClient
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import llen [as 别名]
class QueueClient(object):
"""Interface to a Redis queue/hashmap combo for managing account sync
allocation.
"""
# Lua scripts for atomic assignment and conflict-free unassignment.
ASSIGN = """
local k = redis.call('RPOP', KEYS[1])
if k then
local s = redis.call('HSETNX', KEYS[2], k, ARGV[1])
if s then
return k
end
end"""
UNASSIGN = """
if redis.call('HGET', KEYS[1], KEYS[2]) == ARGV[1] then
return redis.call('HDEL', KEYS[1], KEYS[2])
else
return 0
end
"""
def __init__(self, zone):
self.zone = zone
redis_host = config["ACCOUNT_QUEUE_REDIS_HOSTNAME"]
redis_db = config["ACCOUNT_QUEUE_REDIS_DB"]
self.redis = StrictRedis(
host=redis_host, db=redis_db, socket_connect_timeout=SOCKET_CONNECT_TIMEOUT, socket_timeout=SOCKET_TIMEOUT
)
def all(self):
"""
Returns all keys being tracked (either pending in the queue, or
already assigned).
"""
p = self.redis.pipeline(transaction=True)
p.hgetall(self._hash)
p.lrange(self._queue, 0, -1)
unassigned, assigned = p.execute()
return {int(k) for k in itertools.chain(unassigned, assigned)}
def assigned(self):
"""
Returns a dictionary of all currently assigned key/value pairs (keys
are coerced to integers).
"""
return {int(k): v for k, v in self.redis.hgetall(self._hash).items()}
def enqueue(self, key):
"""
Adds a new key onto the pending queue.
"""
self.redis.lpush(self._queue, key)
def claim_next(self, value):
"""
Pulls the next key off of the pending queue (if any exists), and sets
it to `value` in the hash. Returns None if the queue is empty or if the
key is already present in the hash; otherwise returns the key.
"""
s = self.redis.register_script(self.ASSIGN)
return s(keys=[self._queue, self._hash], args=[value])
def unassign(self, key, value):
"""
Removes `key` from the hash, if and only if it is present and set to
`value` (to prevent removing a key actually assigned to someone else).
"""
s = self.redis.register_script(self.UNASSIGN)
return s(keys=[self._hash, key], args=[value])
def qsize(self):
"""
Returns current length of the queue.
"""
return self.redis.llen(self._queue)
@property
def _queue(self):
return "unassigned_{}".format(self.zone)
@property
def _hash(self):
return "assigned_{}".format(self.zone)
示例8: RedisQueue
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import llen [as 别名]
class RedisQueue(object):
_cli = None
_connection_parameters = dict()
_queue = None
logger = getLogger()
def __init__(self, **kwargs):
self._queue = kwargs.pop('queue', None)
self._connection_parameters.update(kwargs)
def connect(self, **kwargs):
if self._cli and not kwargs:
return self
self._queue = kwargs.pop('queue') if kwargs.get('queue') else self._queue
self._connection_parameters.update(kwargs)
if not self._connection_parameters:
raise QueueConnectionError
self._cli = StrictRedis(**self._connection_parameters)
return self
def put(self, message, **kwargs):
self.connect() if not self._cli else None
queue = kwargs.pop('queue') if kwargs.get('queue') else self._queue
publisher = kwargs.pop('publisher') if kwargs.get('publisher') else 'default'
pipe = self._cli.pipeline()
return pipe.lpush(queue, dumps(message)).publish(publisher, queue).execute()
def get(self, **kwargs):
self.connect() if not self._cli else None
queue = kwargs.pop('queue') if kwargs.get('queue') else self._queue
timeout = kwargs.pop('timeout') if isinstance(kwargs.get('timeout'), int) else 1
try:
return loads(self._cli.brpop(queue, timeout)[1])
except TypeError:
return None
except ValueError:
return None
def length(self, queue=None):
self.connect() if not self._cli else None
queue = queue if queue else self._queue
return self._cli.llen('{0}'.format(queue))
@property
def queue(self):
return self._queue
@queue.setter
def queue(self, value):
self._queue = value
@queue.deleter
def queue(self):
self._queue = None
示例9: TaskTest
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import llen [as 别名]
class TaskTest(TestCase):
def setUp(self):
self.redis = StrictRedis(**settings.REDISES['default'])
self.job_changes_pool_key = 'queue_job_changes'
self.job_sync = JobSync(self.redis)
def tearDown(self):
Task.objects.all().delete()
#self.redis.delete('active_jobs_pool')
self.redis.delete(self.job_changes_pool_key)
self.redis.delete('job_stats.1')
def testAddJob(self):
task = self.generateTask()
task.run_time = '{"days":0, "hours":0, "minutes":10, "seconds":0}'
task.save()
self.assertTrue(task.id > 0)
job = task.getJob()
now = Task.objects.now()
self.assertTrue(job.compute_next_run_time(now) is not None)
self.assertEqual(600, job.trigger.interval_length)
self.assertEqual(task.run_entry, job.func)
self.assertEqual(1, self.redis.llen(self.job_changes_pool_key))
def testGetJob(self):
task = self.generateTask()
task.save()
job = task.getJob()
self.assertEqual(task.id, job.id)
self.assertEqual(task.name, job.name)
self.assertEqual(task.run_entry, job.func)
self.assertEqual(str(task.getTrigger()), str(job.trigger))
def testDelete(self):
task = self.generateTask()
task.active = 1
task.save()
now = Task.objects.now()
job_id, change_type, job = self.job_sync.pop(now)
self.assertEqual(task.id, job_id)
self.assertEqual('add', change_type)
task_id = task.id
task.delete()
job_id, change_type, job = self.job_sync.pop(now)
self.assertEqual(task_id, job_id)
self.assertEqual('remove', change_type)
def testUpdate(self):
task = self.generateTask()
task.save()
now = Task.objects.now()
job_id, change_type, job = self.job_sync.pop(now)
task.run_time = '2013-09-10 00:00:00'
task.type = 'date'
task.save()
job_id, change_type, job = self.job_sync.pop(now)
self.assertEqual(task.id, job_id)
self.assertEqual('update', change_type)
def testEnable(self):
task = self.generateTask()
task.active = 0
task.save()
self.assertEqual(0, self.job_sync.count())
task.disable()
self.assertEqual(0, self.job_sync.count())
task.enable()
now = Task.objects.now()
job_id, change_type, job = self.job_sync.pop(now)
self.assertEqual(task.id, job_id)
self.assertEqual('add', change_type)
def generateTask(self):
task = Task()
task.name = 'Task1'
task.run_time = '{"days":0, "hours":0, "minutes":10, "seconds":0}'
task.run_entry = 'http://baidu.com'
task.run_method = 'post'
task.active = 1
return task
def testDisable(self):
task = self.generateTask()
task.active = 1
task.save()
now = Task.objects.now()
job_id, change_type, job = self.job_sync.pop(now)
self.assertEqual(task.id, job_id)
self.assertEqual('add', change_type)
task.enable()
self.assertEqual(0, self.job_sync.count())
task.disable()
job_id, change_type, job = self.job_sync.pop(now)
#.........这里部分代码省略.........
示例10: __init__
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import llen [as 别名]
class RedisHelper:
prefix = "bc:chart:cache"
def __init__(self, host=None, port=None, prefix=None):
# 这里读取redis配置信息,用到了conf.py里面的函数
self._host = host
self._port = int(port)
self._redis = StrictRedis(host=self._host, port=self._port)
def gen_key(self, chart_id):
return "%s:%s" % (self.prefix, chart_id)
def put(self, chart_id, data, expire=2000):
key = self.gen_key(chart_id)
self._redis.set(key, dumps(data))
self._redis.expire(key, expire)
return True
def delete(self, chart_id):
key = self.gen_key(chart_id)
self._redis.delete(key)
def deleteN(self, chart_id):
key = self.gen_key(chart_id)
keys = self._redis.keys("%s*" % key)
for k in keys:
self._redis.delete(k)
def get(self, chart_id):
key = self.gen_key(chart_id)
data = self._redis.get(key)
return {} if not data else loads(data)
def hset(self, key, field, value):
self._redis.hset(key, field, value)
def hmget(self, key, fields):
return self._redis.hmget(key, fields)
def flush(self):
keys = self._redis.keys("%s*" % self.prefix)
pipe = self._redis.pipeline()
for key in keys:
pipe.delete(key)
pipe.execute()
# the type of value is list
def list_push(self, key, data):
return self._redis.rpush(key, dumps(data))
# pop the head element of the list
def list_pop(self, key):
return self._redis.lpop(key)
# pop all elements of the list
def list_all_pop(self, key):
while True:
if self.list_size(key) == 0:
self._redis.delete(key)
break
res = self._redis.lpop(key)
if res:
yield loads(res)
# the length of list
def list_size(self, key):
return self._redis.llen(key)
@property
def redis(self):
return self._redis
示例11: JSONRedisBackend
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import llen [as 别名]
class JSONRedisBackend(BaseBackend):
def initialize(self):
conf = env.get_uri("LINEUP_REDIS_URI")
self.redis = StrictRedis(
db=conf.username or 0,
host=conf.host,
port=conf.port,
# using `path` as password to support the URI like:
# redis://[email protected]:port/veryverylongpasswordhash
password=conf.path,
)
def serialize(self, value):
return json.dumps(value, default=bytes)
def deserialize(self, value):
return value and json.loads(value) or None
# read operations
@io_operation
def get(self, key):
value = self.redis.get(key)
result = self.deserialize(value)
return result
@io_operation
def lpop(self, key):
value = self.redis.lpop(key)
result = self.deserialize(value)
return result
@io_operation
def llen(self, key):
return self.redis.llen(key)
@io_operation
def lrange(self, key, start, stop):
return map(self.deserialize, self.redis.lrange(key, start, stop))
@io_operation
def rpop(self, key):
value = self.redis.rpop(key)
result = self.deserialize(value)
return result
# Write operations
@io_operation
def set(self, key, value):
product = self.serialize(value)
return self.redis.set(key, product)
@io_operation
def rpush(self, key, value):
product = self.serialize(value)
return self.redis.rpush(key, product)
@io_operation
def lpush(self, key, value):
product = self.serialize(value)
return self.redis.lpush(key, product)
# Pipeline operations
@io_operation
def report_steps(self, name, consumers, producers):
pipeline = self.redis.pipeline()
producers_key = ':'.join([name, 'producers'])
consumers_key = ':'.join([name, 'consumers'])
for consumer in consumers:
pipeline.sadd(consumers_key, consumer)
for producer in producers:
pipeline.sadd(producers_key, producer)
pipeline.smembers(consumers_key)
pipeline.smembers(producers_key)
result = pipeline.execute()
all_consumers = result[-2]
all_producers = result[-1]
return all_consumers, all_producers
示例12: float
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import llen [as 别名]
del post['uid']
# Look up the `username` for the `user_id` and attach this to the
# post. We now store this de-normalized to reduce reads
post['username'] = \
r.hget(USER.format(post.get('user_id')), 'username')
# `pid` becomes `_id`
post_id = post.get('pid')
post['_id'] = post_id
del post['pid']
# Get the count of comments for the post and add the new key
# This is now de-normalized
post['comment_count'] = \
r.llen(POST_COMMENTS.format(post_id))
post['created'] = float(post.get('created'))
post['score'] = int(post.get('score'))
if m.pjuu.posts.insert(post):
r.delete(POST.format(post_id))
r.delete(POST_COMMENTS.format(post_id))
# Convert all comments to become posts.
# DUPLICATES CAN HAPPEN HERE AND ARE EXPECTED. COMMENTS WHICH COLLIDE WILL
# BE GIVEN A NEW `_id`.
# There is a duplication of code here but as its a script I want
# readability to be a priority (this could brick some installations).
for key in r.keys('{comment:*}'):
if COMMENT_RE.match(key) is not None:
示例13: RedisTimeline
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import llen [as 别名]
class RedisTimeline(object):
_redis = None
def __init__(self, **kwargs):
"""
Creates Redis object with key ``timelines:<id>``.
"""
name = kwargs.pop('name')
prefix = kwargs.pop('prefix', "timelines")
sep = kwargs.pop('sep', ":")
self.name = "%s%s%s" % (prefix, sep, name)
# Default to uncapped length
self.max_length = kwargs.pop("max_length", 0)
if self._redis is None:
url = kwargs.get('url', None)
if url is not None:
self._redis = StrictRedis().from_url(url)
else:
self._redis = StrictRedis(**kwargs)
def push(self, value):
"""
Adds the value to the front of the list and trim if the
max length != 0. Returns the value.
"""
self._redis.lpush(self.name, value)
if self.max_length > 0:
self._redis.ltrim(self.name, 0, self.max_length-1)
return value
def range(self, count=0, **kwargs):
"""
Returns a range values from the front of the list to the limit.
"""
if count is 0:
# No count, check for offset/limit
offset = kwargs.get('offset', 0)
limit = kwargs.get('limit', -1)
else:
# If there's a count, default to offset 0
offset = 0
limit = count
if limit is 1:
# Get range of length 1 using LRANGE <timeline> <limit> <limit>
limit = offset
elif limit > 0:
limit = offset+limit - 1
return self._redis.lrange(self.name, offset, limit)
def count(self):
"""
Uses Redis LLEN to get the length of the timeline.
"""
return self._redis.llen(self.name)
@property
def length(self):
"""
Access the length (count) as a property.
"""
return self.count()
示例14: Game
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import llen [as 别名]
class Game(offshoot.Pluggable):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.config = config.get(f"{self.__class__.__name__}Plugin")
self.platform = kwargs.get("platform")
self.window_id = None
self.window_name = kwargs.get("window_name")
self.window_geometry = None
self.is_launched = False
self.frame_grabber_process = None
self.game_frame_limiter = GameFrameLimiter(fps=self.config.get("fps", 4))
self.sprites = self._discover_sprites()
self.redis_client = StrictRedis(**config["redis"])
self.kwargs = kwargs
@property
@offshoot.forbidden
def game_launcher(self):
return self.game_launchers.get(self.platform)
@property
@offshoot.forbidden
def game_launchers(self):
return {
"steam": SteamGameLauncher
}
@property
@offshoot.expected
def screen_regions(self):
raise NotImplementedError()
@property
@offshoot.forbidden
def is_focused(self):
focused_window_id = subprocess.check_output(shlex.split("xdotool getwindowfocus")).decode("utf-8").strip()
return focused_window_id == self.window_id
@offshoot.forbidden
def launch(self, dry_run=False):
self.before_launch()
if not dry_run:
self.game_launcher().launch(**self.kwargs)
self.after_launch()
def before_launch(self):
pass
def after_launch(self):
self.is_launched = True
time.sleep(5)
self.window_id = subprocess.check_output(shlex.split(f"xdotool search --name \"{self.window_name}\"")).decode("utf-8").strip()
subprocess.call(shlex.split(f"xdotool windowmove {self.window_id} 0 0"))
subprocess.call(shlex.split(f"xdotool windowactivate {self.window_id}"))
self.window_geometry = self.extract_window_geometry()
print(self.window_geometry)
def play(self, game_agent_class_name=None):
if not self.is_launched:
raise GameError(f"Game '{self.__class__.__name__}' is not running...")
game_agent_class = offshoot.discover("GameAgent").get(game_agent_class_name)
if game_agent_class is None:
raise GameError("The provided Game Agent class name does not map to an existing class...")
game_agent = game_agent_class(
game=self,
input_controller=InputController(game_window_id=self.window_id)
)
self.start_frame_grabber()
self.redis_client.delete(config["frame_grabber"]["redis_key"])
while self.redis_client.llen(config["frame_grabber"]["redis_key"]) == 0:
time.sleep(0.1)
subprocess.call(shlex.split(f"xdotool windowactivate {self.window_id}"))
while True:
self.game_frame_limiter.start()
game_frame = self.grab_latest_frame()
try:
if self.is_focused:
game_agent.on_game_frame(game_frame)
#.........这里部分代码省略.........
示例15: StrictRedis
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import llen [as 别名]
sys.exit(0)
if __name__ == "__main__":
signal.signal(signal.SIGTERM, sigterm_handler)
r = False
while not r:
try:
r = StrictRedis(host="inbox-redis", port=6379, db=0)
except:
print("Waiting for redis...")
time.sleep(2)
last_check = None
last_count = 0
try:
while True:
count = r.llen("incoming_urls")
if last_check is not None:
print("Queue size: %d" % count)
if count > last_count:
diff = count - last_count
if diff > QUEUE_GROWTH_THRESHOLD:
print("Queue growth of %d exceeds limit. Need to do something." % diff)
last_count = count
last_check = time.time()
time.sleep(INTERVAL_SECONDS)
finally:
print("Exiting")