本文整理汇总了Python中redis.StrictRedis.rpush方法的典型用法代码示例。如果您正苦于以下问题:Python StrictRedis.rpush方法的具体用法?Python StrictRedis.rpush怎么用?Python StrictRedis.rpush使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类redis.StrictRedis
的用法示例。
在下文中一共展示了StrictRedis.rpush方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: second_order_replace2
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import rpush [as 别名]
def second_order_replace2(self, state=False):
from redis import StrictRedis
redis_connection = StrictRedis()
if not state:
redis_connection.rpush('redis-echo', 'In B')
new_task = chain(redis_echo.s("In/Out C"),
second_order_replace2.si(state=True))
raise self.replace(new_task)
else:
redis_connection.rpush('redis-echo', 'Out B')
示例2: test_start_command_via_queue
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import rpush [as 别名]
def test_start_command_via_queue(self):
"""
Call the stop via queue command
"""
ctrl_man = ControlManager.factory(list())
rqc = RedisQueueConfiguration(self.__config)
redis = StrictRedis(connection_pool=rqc.create_redis_connection_pool())
redis.rpush(rqc.queue, 'START')
redis.publish('{:s}_PUBSUB_CH'.format(rqc.queue), '1')
sleep(5)
self.assertTrue(ctrl_man.server.running)
示例3: test_stop_command_via_queue
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import rpush [as 别名]
def test_stop_command_via_queue(self):
"""
Call the stop via queue command
"""
ControlManager.factory(list())
self.assertTrue(ControlManager().command_handler.should_run)
rqc = RedisQueueConfiguration(self.__config)
redis = StrictRedis(connection_pool=rqc.create_redis_connection_pool())
redis.rpush(rqc.queue, 'STOP')
redis.publish('{:s}_PUBSUB_CH'.format(rqc.queue), '1')
sleep(5)
self.util_check_stopped()
示例4: RedisStorage
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import rpush [as 别名]
class RedisStorage(object):
def __init__(self, host, port):
self.connection = StrictRedis(host=host, port=port)
def get(self, item_id):
return self.connection.get(item_id)
def set(self, item_id, item_value):
self.connection.rpush(item_id, item_value)
def rm(self, item_id):
self.connection.delete(item_id)
示例5: __init__
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import rpush [as 别名]
class ShortProxy:
def __init__(self):
self.r = StrictRedis(__REDIS_HOST__, __REDIS_PORT__)
def redirect_to(self, inputurl, data):
self.r.rpush('l_{}'.format(inputurl), data)
return self.r.get(inputurl)
def generate_url(self, origin, target):
return self.r.set('{}{}'.format(origin, self._randomString()), target)
def _randomString(self, size=6, chars=string.ascii_lowercase + string.ascii_uppercase + string.digits):
return ''.join(random.choice(chars) for x in xrange(size))
示例6: test_Redis
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import rpush [as 别名]
def test_Redis(self):
host = "localhost"
r = StrictRedis(host, socket_timeout=60)
msg = "Hello world"
r.delete("channel")
r.rpush("channel", msg)
m = r.lpop("channel")
print m
assert(m == msg)
r.rpush("channel", [1, 2, 3])
m = ast.literal_eval(r.lpop("channel"))
print m, type(m)
示例7: JSONRedisBackend
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import rpush [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
示例8: main
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import rpush [as 别名]
def main(args=None):
if args is None:
args = sys.argv[1:]
parser = argparse.ArgumentParser(description="Kinto Deployment Worker")
parser.add_argument('--ini',
help='Application configuration file',
dest='ini_file')
parsed_args = vars(parser.parse_args(args))
logging.basicConfig(level=DEFAULT_LOG_LEVEL, format=DEFAULT_LOG_FORMAT)
config_file = parsed_args['ini_file']
env = bootstrap(config_file)
registry = env['registry']
r = StrictRedis(**registry.redis)
while True:
try:
queue, b64_credentials = r.blpop(DEPLOY_QUEUE, 0)
except KeyboardInterrupt:
print("\rBye bye buddy")
sys.exit(0)
user_id = hmac_digest(registry.hmac_secret, b64_credentials)
credentials = base64.b64decode(b64_credentials).split(':', 1)
id_alwaysdata = r.get(ID_ALWAYSDATA_KEY.format(user_id))
settings = {
'id_alwaysdata': id_alwaysdata,
'credentials': tuple(credentials),
'postgresql_host': "postgresql-%s.alwaysdata.net" % id_alwaysdata,
'ssh_host': "ssh-%s.alwaysdata.net" % id_alwaysdata,
'ftp_host': "ftp-%s.alwaysdata.net" % id_alwaysdata,
'prefixed_username': "%s_kinto" % id_alwaysdata
}
status_handler = RedisStatusHandler(r, user_id)
try:
deploy_kinto_to_alwaysdata(status_handler, file_root=FILE_ROOT, **settings)
except Exception as e:
logger.error(e)
# Retry later
r.rpush(DEPLOY_QUEUE, b64_credentials)
示例9: handle
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import rpush [as 别名]
def handle(self, *args, **options):
daemon = BeatmapDaemon()
daemon.crawler.start_session()
page = 0
flag = True
redis = StrictRedis()
while flag:
flag = False
page += 1
url = "https://osu.ppy.sh/p/beatmaplist&s=4&r=0&page=%d" % page
beatmap_ids = set(daemon.crawler.parse_listing_page(daemon.crawler.session.get(url).text))
for beatmap in Beatmap.objects.filter(id__in=beatmap_ids).all():
beatmap_ids.remove(beatmap.id)
for beatmap_id in beatmap_ids:
if redis.lrem(FETCH_QUEUE_KEY, 0, beatmap_id) == 0L:
flag = True
redis.rpush(FETCH_QUEUE_KEY, beatmap_id)
self.stderr.write('Enqueued #%d.' % beatmap_id)
示例10: list_example
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import rpush [as 别名]
def list_example():
""" Example list pagination.
"""
from uuid import uuid4
from redis import StrictRedis
from zato.redis_paginator import ListPaginator
conn = StrictRedis()
key = 'paginator:{}'.format(uuid4().hex)
for x in range(1, 18):
conn.rpush(key, x)
p = ListPaginator(conn, key, 6)
print(p.count) # 17
print(p.num_pages) # 3
print(p.page_range) # [1, 2, 3]
page = p.page(3)
print(page) # <Page 3 of 3>
print(page.object_list) # ['13', '14', '15', '16', '17']
conn.delete(key)
示例11: RedisEngine
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import rpush [as 别名]
class RedisEngine(QueueEngine):
"""docstring for RedisEngine"""
def __init__(self):
super(RedisEngine, self).__init__()
self.r = None
self.host = 'localhost'
self.port = 6379
def connect(self):
self.r = StrictRedis(self.host, self.port, db=0)
return self.is_available()
def is_available(self):
print('is redis available')
if self.r is None:
return False
return self.r.ping() is not None
def enqueue(self, queue, msg, timeout=0):
self.r.rpush(queue, msg)
def dequeue(self, queue, timeout):
rsp = self.r.blpop(queue, timeout=0)
return rsp[1]
示例12: Hipache
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import rpush [as 别名]
class Hipache(object):
def __init__(self, url):
host, port, password, database = parse_redis_url(url)
self.r = StrictRedis(host=host, port=port, db=database, password=password)
def __iter__(self):
for i, k in enumerate(self.r.keys()):
vhost = k.split(":")[1]
xs = self.r.lrange(k, 0, -1)
if len(xs) == 2:
id, url = xs
yield {"id": id, "host": vhost, "url": url}
def add(self, id, host, ip, port):
url = format_url(ip, port)
vhost = "frontend:{0:s}".format(host)
if vhost in self.r.keys():
members = self.r.lrange(vhost, 0, -1)
if id in members:
if url not in members:
self.r.linsert(vhost, "after", id, url)
else:
self.r.rpush(vhost, id)
self.r.rpush(vhost, url)
else:
self.r.rpush(vhost, id)
self.r.rpush(vhost, url)
def delete(self, id, host, ip, port):
vhost = "frontend:{0:s}".format(host)
if not ip:
self.r.delete(vhost, id)
else:
url = format_url(ip, port)
self.r.lrem(vhost, 0, url)
示例13: RedisQueue
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import rpush [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
示例14: PyRPS
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import rpush [as 别名]
#.........这里部分代码省略.........
RPUSH shop.orders.fullfillment 1
Reading message from queue
--------------------------------------------------------------------------
sub.consume()
--> BLPOP shop.orders.fullfillment
-> 1
GET shop.orders.messages.1
-> "order data"
<-- "order data"
Destroying the message queue
--------------------------------------------------------------------------
sub.unsubscribe()
--> SREM shop.orders.consumers fullfillment
DEL shop.orders.fullfillment.messages
"""
def __init__(self, namespace, redis_url=("localhost", 6379)):
"""
Create instance of PyRPS.
@param redis_url Redis instance address (tuple containing (hostname, port)).
@param namespace Namespace to separate Pub/Sub instance from another running on the same redis host.
"""
self.namespace = namespace
if isinstance(redis_url, tuple):
self.redis = StrictRedis(host=redis_url[0], port=redis_url[1])
elif isinstance(redis_url, str):
self.redis = StrictRedis(host=redis_url)
def subscribe(self, queue, consumer_id):
"""
Subscribe to message queue. Yields messages as they appear in
the queue.
@param queue Queue name
@param consumer_id Consumer name
"""
# Add myself to the list of consumers, if not already present.
self.redis.sadd(self._ns_subscriptions(queue), consumer_id)
return Subscription(self, queue, consumer_id)
def publish(self, queue, message, ttl=3600):
"""
Publish new message into queue.
@param queue Queue name.
@param message Message data.
@param ttl How long the message should stay alive.
"""
# Get next message ID
message_id = self.redis.incr(self._ns_nextid())
# Push message to queue
self.redis.setex(self._ns_message(queue, message_id), ttl, message)
# List all consumers of given queue
consumers = self.redis.smembers(self._ns_subscriptions(queue))
# Publish the message to all the consumers.
for consumer in consumers:
self.redis.rpush(self._ns_queue(queue, consumer), message_id)
def _ns(self, *args):
""" Convinience method to retrieve names of redis keys including
configured namespace. """
return "%s.%s" % (self.namespace, ".".join([str(arg) for arg in args]))
def _ns_subscriptions(self, queue):
""" Return key for subscribers list for given queue. """
return self._ns(queue, "consumers")
def _ns_nextid(self):
""" Return key for nextid counter. """
return self._ns("nextid")
def _ns_message(self, queue, message_id):
""" Return key for retrieving message. """
return self._ns(queue, "messages", message_id)
def _ns_queue(self, queue, consumer_id):
""" Return key for queue for one consumer. """
return self._ns(queue, consumer_id, "messages")
示例15: Zone
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import rpush [as 别名]
#.........这里部分代码省略.........
len(self.components), len(self.modes)
))
def start(self):
try:
self.redis.ping()
except ConnectionError as e:
fatal("Redis error: %s" % e.message)
self.running = True
log.info('Listening.')
# Clear any existing tick events
self.redis.ltrim(self.tick_key, 0, 0)
try:
while self.running:
self.process_one_event()
except Exception as e:
log.critical(traceback.format_exc())
except BaseException as e:
pass
finally:
self.save_snapshot()
def stop(self):
self.running = False
def start_ticker(self):
log.info('Ticking every %ss.' % self.tick_interval)
tock = False
while True:
log.debug('Tock.' if tock else 'Tick.')
# TODO: timestamp here instead of True, for debugging?
self.redis.rpush(self.tick_key, True)
sleep(self.tick_interval)
tock = not tock
def send_message(self, entity_id, message):
self.redis.publish(self.messages_key(entity_id), message)
def listen(self, entity_id):
subscription = self.subscribe(entity_id)
for message in subscription.listen():
yield message['data']
# TODO: Leaky abstraction :\
def subscribe(self, entity_id):
subscription = self.redis.pubsub(ignore_subscribe_messages=True)
subscription.subscribe(self.messages_key(entity_id))
return subscription
def process_one_event(self):
key, value = self.redis.blpop([self.tick_key, self.incoming_key])
if key == self.tick_key:
self.perform_tick()
else:
entity_id, _, command = value.partition(' ')
self.perform_command(int(entity_id), command)
def enqueue_command(self, entity_id, command):
self.redis.rpush(self.incoming_key, ' '.join([str(entity_id), command]))
def perform_command(self, entity_id, command):
entity = self.get(entity_id)
log.debug('Processing: [%s] %s' % (entity.id, command))