Python StrictRedis.rpush方法代码示例

# 需要导入模块: 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')

# 需要导入模块: 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)

# 需要导入模块: 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()

# 需要导入模块: 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)

# 需要导入模块: 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))

# 需要导入模块: 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)

# 需要导入模块: 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

# 需要导入模块: 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)

# 需要导入模块: 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)

# 需要导入模块: 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)

# 需要导入模块: 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]

# 需要导入模块: 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)

# 需要导入模块: 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

# 需要导入模块: 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")

# 需要导入模块: 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))