コード例 #1
0
ファイル: redis.py プロジェクト: Tolmachofof/aiotasks
    def __init__(self,
                 dsn: str = "redis://127.0.0.1:6379/0",
                 prefix: str = "aiotasks",
                 loop=None):
        super().__init__(loop=loop, prefix=prefix)

        _, password, host, port, db = parse_dsn(dsn,
                                                default_port=6379,
                                                default_db=0)
        db = int(db)

        # if not port:
        #     port = 6379
        #
        # port = int(port)
        # try:
        #     db = int(db)
        #
        #     if not db:
        #         db = 0
        # except ValueError:
        #     db = 0

        self._redis_pub = self._loop_subscribers.run_until_complete(
            aioredis.create_redis(address=(host, port),
                                  db=db,
                                  password=password,
                                  loop=self._loop_subscribers))

        self._redis_sub = self._loop_subscribers.run_until_complete(
            aioredis.create_redis(address=(host, port),
                                  db=db,
                                  password=password,
                                  loop=self._loop_subscribers))
コード例 #2
0
ファイル: redis.py プロジェクト: Tolmachofof/aiotasks
    def __init__(self,
                 dsn: str = "redis://127.0.0.1:6379/0",
                 prefix: str = "aiotasks",
                 concurrency: int = 5,
                 loop=None):
        super().__init__(loop=loop, prefix=prefix, concurrency=concurrency)

        _, password, host, port, db = parse_dsn(dsn,
                                                default_port=6379,
                                                default_db=0)

        db = int(db)

        # if not port:
        #     port = 6379
        #
        # port = int(port)
        # try:
        #     db = int(db)
        #     if not db:
        #         db = 0
        # except ValueError:
        #     db = 0

        self._redis_consumer = self._loop_delay. \
            run_until_complete(aioredis.create_redis(address=(host, port),
                                                     db=db,
                                                     password=password,
                                                     loop=self._loop_delay))

        self._redis_poller = self._loop_delay. \
            run_until_complete(aioredis.create_redis(address=(host, port),
                                                     db=db,
                                                     password=password,
                                                     loop=self._loop_delay))
コード例 #3
0
    def test_repr(self):
        redis = yield from create_redis(
            ('localhost', self.redis_port), db=1, loop=self.loop)
        self.assertEqual(repr(redis), '<Redis <RedisConnection [db:1]>>')

        redis = yield from create_redis(
            ('localhost', self.redis_port), db=0, loop=self.loop)
        self.assertEqual(repr(redis), '<Redis <RedisConnection [db:0]>>')
コード例 #4
0
    def test_migrate(self):
        yield from self.add('my-key', 123)

        conn2 = yield from create_redis(('localhost', 6380), db=2,
                                        loop=self.loop)
        yield from conn2.delete('my-key')
        self.assertTrue((yield from self.redis.exists('my-key')))
        self.assertFalse((yield from conn2.exists('my-key')))

        ok = yield from self.redis.migrate('localhost', 6380, 'my-key',
                                           2, 1000)
        self.assertTrue(ok)
        self.assertFalse((yield from self.redis.exists('my-key')))
        self.assertTrue((yield from conn2.exists('my-key')))

        with self.assertRaisesRegex(TypeError, "host .* str"):
            yield from self.redis.migrate(None, 1234, 'key', 1, 23)
        with self.assertRaisesRegex(TypeError, "args .* None"):
            yield from self.redis.migrate('host', '1234',  None, 1, 123)
        with self.assertRaisesRegex(TypeError, "dest_db .* int"):
            yield from self.redis.migrate('host', 123, 'key', 1.0, 123)
        with self.assertRaisesRegex(TypeError, "timeout .* int"):
            yield from self.redis.migrate('host', '1234', 'key', 2, None)
        with self.assertRaisesRegex(ValueError, "Got empty host"):
            yield from self.redis.migrate('', '123', 'key', 1, 123)
        with self.assertRaisesRegex(ValueError, "dest_db .* greater equal 0"):
            yield from self.redis.migrate('host', 6379, 'key', -1, 1000)
        with self.assertRaisesRegex(ValueError, "timeout .* greater equal 0"):
            yield from self.redis.migrate('host', 6379, 'key', 1, -1000)
コード例 #5
0
ファイル: start.py プロジェクト: Julien00859/Bomberman
async def connect_to_db():
    logger.info("Connect to Redis Server at %s:%d on database %d %s password",
                REDIS_HOST,
                REDIS_PORT,
                REDIS_DB,
                "without" if REDIS_PASSWORD is None else "with")
    redis_coro = create_redis((REDIS_HOST, REDIS_PORT),
                              db=REDIS_DB,
                              password=REDIS_PASSWORD,
                              loop=shared.app.loop)
    
    logger.info("Connect to PostgreSQL Server at %s:%d on database %s with user %s %s password",
                POSTGRES_HOST,
                POSTGRES_PORT,
                POSTGRES_DB,
                POSTGRES_USER,
                "without" if POSTGRES_PASSWORD is None else "and")
    pg_coro = pg_connect(host=POSTGRES_HOST,
                         port=POSTGRES_PORT,
                         user=POSTGRES_USER,
                         password=POSTGRES_PASSWORD,
                         database=POSTGRES_DB,
                         loop=shared.app.loop)
    
    global clients
    shared.redis, shared.postgres = await asyncio.gather(redis_coro, pg_coro, loop=shared.app.loop)
    logger.info("Connected")
コード例 #6
0
ファイル: producer.py プロジェクト: dpereira/experiments
def run(loop):
    client = yield aioredis.create_redis(('localhost', 6379), loop=loop)

    tasks = []
    fs = []

    s = Sync()

    for i in range(20):
        task_id = produce(i, client)
        tasks.append(task_id)
        print('Sent %s' % i)
        tasks
        fs.append(s.run(client, i, task_id))
        print('Synced %s' % i)
        if i % 1000:
            yield tornado.gen.sleep(0.01)

    print('All tasks sent')
    for i in fs:
        yield fs

    yield tornado.gen.sleep(60)

    client.close()
    yield client.wait_closed()
コード例 #7
0
ファイル: base.py プロジェクト: SleepyyNet/dogbot
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs, formatter=DogbotHelpFormatter())

        # configuration dict
        self.cfg = kwargs.get('cfg', {})

        # aiohttp session used for fetching data
        self.session = aiohttp.ClientSession(loop=self.loop)

        # boot time (for uptime)
        self.boot_time = datetime.datetime.utcnow()

        # aioredis connection
        redis_coroutine = aioredis.create_redis(
            (self.cfg['db']['redis'], 6379), loop=self.loop)
        self.redis = self.loop.run_until_complete(redis_coroutine)

        # asyncpg
        pg = self.cfg['db']['postgres']
        self.database = pg['database']
        self.pgpool = self.loop.run_until_complete(asyncpg.create_pool(**pg))

        # load core extensions
        self._exts_to_load = []
        self.load_extensions('dog/core/ext', 'Core recursive load')
コード例 #8
0
def get_value(digest):
    connection = yield from aioredis.create_redis(
        (config.get("redis")["host"], config.get("redis")["port"]),
        encoding='utf-8')
    value = yield from connection.get(digest)
    connection.close()
    return value
コード例 #9
0
ファイル: __init__.py プロジェクト: waartaa/ircb
 def setup_pubsub(self):
     redis = yield from aioredis.create_redis(
         (settings.REDIS_HOST, settings.REDIS_PORT)
     )
     if self.role == 'stores':
         bind_addr = settings.SUBSCRIBER_ENDPOINTS[self.role]
     else:
         bind_addr = 'tcp://{host}:*'.format(host=settings.INTERNAL_HOST)
     self.subscriber = yield from aiozmq.rpc.serve_pubsub(
         self.handler, subscribe='',
         bind=bind_addr,
         log_exceptions=True)
     subscriber_addr = list(self.subscriber.transport.bindings())[0]
     self.publisher = yield from aiozmq.rpc.connect_pubsub()
     if self.role == 'storeclient':
         self.publisher.transport.connect(
             settings.SUBSCRIBER_ENDPOINTS['stores'])
         _key = 'SUBSCRIBER_REGISTERED_{}'.format(subscriber_addr)
         ret = 0
         yield from redis.set(_key, ret)
         while ret != b'1':
             yield from self.publisher.publish(
                 'register_sub'
             ).register_sub(
                 subscriber_addr, _key
             )
             ret = yield from redis.get(_key)
             yield from asyncio.sleep(0.01)
     self.lock.release()
     redis.close()
コード例 #10
0
def go():
    redis = yield from aioredis.create_redis(
        ('localhost', 6379), loop=loop)

    bloom1 = BloomFilter(redis, 1000, 0.001, 'bloom:1')
    bloom2 = BloomFilter(redis, 1000, 0.001, 'bloom:2')

    yield from bloom1.add('tornado')
    yield from bloom1.add('python')

    yield from bloom2.add('asyncio')
    yield from bloom2.add('python')

    # intersection
    inter_bloom = yield from bloom1.intersection(bloom2)

    in_bloom1 = yield from inter_bloom.contains('python')
    print(in_bloom1)  # True
    in_bloom2 = yield from inter_bloom.contains('asyncio')
    print(in_bloom2)  # False

    # union
    union_bloom = yield from bloom1.intersection(bloom2)

    in_bloom1 = yield from union_bloom.contains('python')
    print(in_bloom1)  # True
    in_bloom2 = yield from union_bloom.contains('asyncio')
    print(in_bloom2)  # True

    redis.close()
コード例 #11
0
 def init_with_loop(self, loop):
     self.redis = loop.run_until_complete(
         aioredis.create_redis((options.redis_host, options.redis_port),
                               loop=loop))
     self.cache = RedisCacheBackend(self.redis)
     es_hosts = [x.strip() for x in options.es_hosts.split(',')]
     self.es = AsyncElasticsearch(hosts=es_hosts, loop=loop)
コード例 #12
0
ファイル: pubsub2.py プロジェクト: alefteris/aioredis
def pubsub():
    sub = yield from aioredis.create_redis(
         ('localhost', 6379))

    ch1, ch2 = yield from sub.subscribe('channel:1', 'channel:2')
    assert isinstance(ch1, aioredis.Channel)
    assert isinstance(ch2, aioredis.Channel)

    @asyncio.coroutine
    def async_reader(channel):
        while (yield from channel.wait_message()):
            msg = yield from channel.get(encoding='utf-8')
            # ... process message ...
            print("message in {}: {}".format(channel.name, msg))

    tsk1 = asyncio.async(async_reader(ch1))

    # Or alternatively:

    @asyncio.coroutine
    def async_reader2(channel):
        while True:
            msg = yield from channel.get(encoding='utf-8')
            if msg is None:
                break
            # ... process message ...
            print("message in {}: {}".format(channel.name, msg))

    tsk2 = asyncio.async(async_reader2(ch2))

    # Publish messages and terminate
    pub = yield from aioredis.create_redis(
        ('localhost', 6379))
    while True:
        channels = yield from pub.pubsub_channels()
        if len(channels) == 2:
            break

    for msg in ("Hello", ",", "world!"):
        for ch in ('channel:1', 'channel:2'):
            yield from pub.publish(ch, msg)
    pub.close()
    sub.close()
    yield from asyncio.sleep(0)
    yield from pub.wait_closed()
    yield from sub.wait_closed()
    yield from asyncio.gather(tsk1, tsk2)
コード例 #13
0
def pubsub():
    sub = yield from aioredis.create_redis(
         ('localhost', 6379))

    ch1, ch2 = yield from sub.subscribe('channel:1', 'channel:2')
    assert isinstance(ch1, aioredis.Channel)
    assert isinstance(ch2, aioredis.Channel)

    @asyncio.coroutine
    def async_reader(channel):
        while (yield from channel.wait_message()):
            msg = yield from channel.get(encoding='utf-8')
            # ... process message ...
            print("message in {}: {}".format(channel.name, msg))

    tsk1 = asyncio.async(async_reader(ch1))

    # Or alternatively:

    @asyncio.coroutine
    def async_reader2(channel):
        while True:
            msg = yield from channel.get(encoding='utf-8')
            if msg is None:
                break
            # ... process message ...
            print("message in {}: {}".format(channel.name, msg))

    tsk2 = asyncio.async(async_reader2(ch2))

    # Publish messages and terminate
    pub = yield from aioredis.create_redis(
        ('localhost', 6379))
    while True:
        channels = yield from pub.pubsub_channels('channel:*')
        if len(channels) == 2:
            break

    for msg in ("Hello", ",", "world!"):
        for ch in ('channel:1', 'channel:2'):
            yield from pub.publish(ch, msg)
    pub.close()
    sub.close()
    yield from asyncio.sleep(0)
    yield from pub.wait_closed()
    yield from sub.wait_closed()
    yield from asyncio.gather(tsk1, tsk2)
コード例 #14
0
ファイル: subMgr.py プロジェクト: evrimulgen/probet-1
    def connectRedis(self):

        self.objAioRedis = yield from aioredis.create_redis(address=self.setAddress, loop=self.objAioLoopObj,
                                                           db=self.iDb,
                                                           password=self.strPwd)

        res = yield from self.objAioRedis.subscribe(self.strSubName)
        self.objSubChanel = res[0]
コード例 #15
0
    def go():
        pub = yield from aioredis.create_redis(
            ('localhost', 6379))
        sub = yield from aioredis.create_redis(
            ('localhost', 6379))
        res = yield from sub.subscribe('chan:1')
        ch1 = res[0]

        tsk = asyncio.async(reader(ch1))

        res = yield from pub.publish_json('chan:1', ["Hello", "world"])
        assert res == 1

        yield from sub.unsubscribe('chan:1')
        yield from tsk
        sub.close()
        pub.close()
コード例 #16
0
    def go():
        redis = yield from aioredis.create_redis(('localhost', 6379))
        yield from redis.set('my-key', 'value')
        val = yield from redis.get('my-key')
        print(val)

        # optinally closing underlying connection
        redis.close()
コード例 #17
0
ファイル: consumer.py プロジェクト: dpereira/experiments
def run(loop):
    client = yield aioredis.create_redis(('localhost', 6379), loop=loop)
    while True:
        try:
            yield consume(client)
        except KeyboardInterrupt:
            client.close()
            yield client.await_closed()
コード例 #18
0
ファイル: core.py プロジェクト: MyOctopus/myoctopus-data
def publish(topic, name):
    import aioredis
    client = yield from aioredis.create_redis(('localhost', 6379))
    if __debug__:
        logger.debug('connected to redis server')
    while True:
        values = yield from topic.get()
        for v in values:
            client.publish_json(name, v._asdict())
コード例 #19
0
ファイル: simple.py プロジェクト: imlzg/aioredis_bloom
def go():
    redis = yield from aioredis.create_redis(('localhost', 6379), loop=loop)
    bloom = BloomFilter(redis, 100000, 0.0001)
    yield from bloom.add('python')
    yield from bloom.add('asyncio')
    result = yield from bloom.contains('tornado')
    print(result)

    redis.close()
コード例 #20
0
ファイル: Server.py プロジェクト: woniucao520/Tornado_web
    def subscribe(self, channel_name):
        """
        Create async redis client and subscribe to the given PUB/SUB channel.
        Listen to the message and launch publish handler
        :param channel_name: string respresenting Redis PUB/SUB channel name
        :return:
        """
        try:
            self._redis = yield aioredis.create_redis((ConfigParser.get('wx.redis.config','host'),ConfigParser.get('wx.redis.config','port')))
            self._redis_pub = yield aioredis.create_redis((ConfigParser.get('wx.redis.config','host'),ConfigParser.get('wx.redis.config','port')))
        except aioredis.MultiExecError:
            print('Failed to conect to Redis Server at {}:{}'.format(ConfigParser.get('wx.redis.config','host'),ConfigParser.get('wx.redis.config','port')))
        else:
            channels = yield self._redis.subscribe(channel_name)
            print('Subscribed to "{}" Redis channel'.format(channel_name))
            self._channel = channels[0]

            yield self.listen_redis()
コード例 #21
0
ファイル: conftest.py プロジェクト: akita8/helper_bot
def redis_async(request, event_loop):
    conn = event_loop.run_until_complete(
        aioredis.create_redis(('localhost', 6379), encoding="utf-8", db=10))

    def redis_async_cleanup():
        conn.close()

    request.addfinalizer(redis_async_cleanup)
    return conn
コード例 #22
0
def aioredis_connection():
    if sys.version_info <= (3, 5):
        pytest.skip()

    import aioredis

    connection_coroutine = aioredis.create_redis(('localhost', 6379))

    return connection_coroutine, ring.aioredis
コード例 #23
0
ファイル: commands.py プロジェクト: Natim/aioredis
    def go():
        redis = yield from aioredis.create_redis(
            ('localhost', 6379))
        yield from redis.set('my-key', 'value')
        val = yield from redis.get('my-key')
        print(val)

        # optinally closing underlying connection
        redis.close()
コード例 #24
0
ファイル: core.py プロジェクト: szm429006/goodmo
 def init_connections():
     redis_map = dict()
     for p in redis_set:
         r = cls.loads(p)
         redis_map[p] = yield from aioredis.create_redis(
             (r["host"], r["port"]),
             db=r["db"],
             password=r.get("password"))
     cls.attach(redis_map, objects)
     redis_completed.send(cls)
コード例 #25
0
def get_async_redis():
    """ initialize an asyncronous redis connection
    """
    global ASYNCREDIS
    if ASYNCREDIS is None or ASYNCREDIS.closed:  # pragma: no branch
        address = REDIS_PUBSUB["address"]
        db = REDIS_PUBSUB["db"]
        password = REDIS_PUBSUB["password"]
        ASYNCREDIS = yield from aioredis.create_redis(address, db=db, password=password)
    return ASYNCREDIS
コード例 #26
0
ファイル: redis_pubsub.py プロジェクト: mtian2018/charger
    def __int__(self, is_coap):
        sub = loop.run_until_complete(
            aioredis.create_redis('redis://redis:6379'))

        if is_coap:
            [ch] = loop.run_until_complete(sub.subscribe('ch:1'))
            loop.create_task(self.sub_command(ch))
        else:
            [ch] = loop.run_until_complete(sub.subscribe('ch:2'))
            loop.create_task(self.sub_status(ch))
コード例 #27
0
ファイル: simple.py プロジェクト: jettify/aioredis_bloom
def go():
    redis = yield from aioredis.create_redis(
        ('localhost', 6379), loop=loop)
    bloom = BloomFilter(redis, 100000, 0.0001)
    yield from bloom.add('python')
    yield from bloom.add('asyncio')
    result = yield from bloom.contains('tornado')
    print(result)

    redis.close()
コード例 #28
0
ファイル: run_example.py プロジェクト: dveselov/aiorq
def go():
    redis = yield from create_redis(('localhost', 6379))
    queue = Queue('my_async_queue', connection=redis)
    job = yield from queue.enqueue(
        http_client.fetch_page, 'https://www.python.org')
    yield from asyncio.sleep(5)
    result = yield from job.result
    assert '</html>' in result, 'Given content is not a html page'
    print('Well done, Turner!')
    redis.close()
コード例 #29
0
ファイル: application.py プロジェクト: olhoneles/politicos
 def init_with_loop(self, loop):
     self.redis = loop.run_until_complete(
         aioredis.create_redis(
             (options.redis_host, options.redis_port),
             loop=loop
         )
     )
     self.cache = RedisCacheBackend(self.redis)
     es_hosts = [x.strip() for x in options.es_hosts.split(',')]
     self.es = AsyncElasticsearch(hosts=es_hosts, loop=loop)
コード例 #30
0
ファイル: pool_test.py プロジェクト: TarasLevelUp/aioredis
 def test_release_bad_connection(self):
     pool = yield from create_pool(
         ('localhost', self.redis_port),
         loop=self.loop)
     yield from pool.acquire()
     other_conn = yield from create_redis(
         ('localhost', self.redis_port),
         loop=self.loop)
     with self.assertRaises(AssertionError):
         pool.release(other_conn)
コード例 #31
0
ファイル: app.py プロジェクト: singulared/aiohttp-example
def init(loop, app, handler):

    for route in route_map:
        app.router.add_route(*route)

    app.logger.info('Create redis connection')
    app.redis = yield from aioredis.create_redis(('localhost', 6379), loop=loop)

    srv = yield from loop.create_server(handler, '127.0.0.1', 8080)
    return srv
コード例 #32
0
def is_token_in_cache(token):
    """Check token is in cache.
    """
    conn = yield from aioredis.create_redis(('localhost', 6379),
                                            encoding='utf-8')
    try:
        print('Checking token: {}'.format(token))
        res = yield from conn.sismember('access_tokens', token)
        return res
    finally:
        conn.close()
コード例 #33
0
    def go():
        redis = yield from aioredis.create_redis(('localhost', 6379))

        yield from redis.mset('key:1', 'value1', 'key:2', 'value2')
        cur = b'0'  # set initial cursor to 0
        while cur:
            cur, keys = yield from redis.scan(cur, match='key:*')
            print("Iteration results:", keys)

        redis.close()
        yield from redis.wait_closed()
コード例 #34
0
def main(host, port):
    logging.info('Got params connection host {0}, port {1}'.format(host, port))
    loop = asyncio.get_event_loop()
    while True:
        title = loop.run_until_complete(get_current_song(host, port))
        if title:
            redis = loop.run_until_complete(create_redis(('localhost', 6379)))
            loop.run_until_complete(redis.publish('CHANNEL',
                                                  json.dumps(title)))
    loop.close()
    return False
コード例 #35
0
ファイル: transaction.py プロジェクト: TarasLevelUp/aioredis
 def go():
     redis = yield from aioredis.create_redis(
         ('localhost', 6379))
     yield from redis.delete('foo', 'bar')
     tr = redis.multi_exec()
     fut1 = tr.incr('foo')
     fut2 = tr.incr('bar')
     res = yield from tr.execute()
     res2 = yield from asyncio.gather(fut1, fut2)
     print(res)
     assert res == res2
コード例 #36
0
ファイル: test_server.py プロジェクト: snow-born/eng-exercise
def sanic_server(loop, app, test_server):
    app.redis = loop.run_until_complete(
        aioredis.create_redis("redis://{}:{}".format(app.config.DB_HOST,
                                                     app.config.DB_PORT),
                              db=TEST_DB,
                              encoding="utf-8"))
    logging.debug("Test server configured with Redis instance: {}".format(
        app.redis))
    loop.run_until_complete(app.redis.flushdb())
    controller.set_db(app.redis)
    return loop.run_until_complete(test_server(app))
コード例 #37
0
 def init_with_loop(self, loop, config):
     redis_db = 0
     try:
         redis_db = int(config.get('redis.db'))
     except ValueError:
         print("redis.db must be integer. Use default value(0)")
     self.redis = loop.run_until_complete(
         aioredis.create_redis(
             (config.get('redis.host')
              or 'localhost', config.get('redis.port') or 6379),
             db=int(config.get('redis.db')) or 0,
             loop=loop))
コード例 #38
0
    def subscribe(self, channel_name):
        """
        Create async redis client and subscribe to the given PUB/SUB channel.
        Listen to the messages and launch publish handler.

        :param channel_name: string representing Redis PUB/SUB channel name
        """
        self._redis = yield aioredis.create_redis(('localhost', 6379))
        channels = yield self._redis.subscribe(channel_name)
        print('Subscribed to "{}" Redis channel.'.format(channel_name))
        self._channel = channels[0]
        yield self.listen_redis()
コード例 #39
0
ファイル: caller.py プロジェクト: vargi/buzi
 def call(self, name, *args, **kwargs):
     loop = asyncio.get_event_loop()
     self.client = yield from aioredis.create_redis(("localhost", 6379), loop=loop)
     d = {"fn": name, "uuid": str(uuid.uuid4()), "args": args, "kwargs": kwargs}
     yield from self.client.rpush("fn_%s" % name, json.dumps(d))
     ret = yield from self.client.blpop("fn_result_%s" % d["uuid"], 0)
     ret_val = ret[1].decode("utf-8")
     result = json.loads(ret_val)
     if "error" in result:
         raise Exception(result["error"])
     print("result", result.get("result"))
     return result["result"]
コード例 #40
0
ファイル: transaction.py プロジェクト: underyx/aioredis
 def go():
     redis = yield from aioredis.create_redis(("localhost", 6379))
     yield from redis.delete("foo", "bar")
     tr = redis.multi_exec()
     fut1 = tr.incr("foo")
     fut2 = tr.incr("bar")
     res = yield from tr.execute()
     res2 = yield from asyncio.gather(fut1, fut2)
     print(res)
     assert res == res2
     redis.close()
     yield from redis.wait_closed()
コード例 #41
0
ファイル: connections.py プロジェクト: essobi/aiorq
def use_connection(redis=None, **kwargs):
    """Clears the stack and uses the given connection.  Protects against
    mixed use of use_connection() and stacked connection contexts.
    """

    assert len(_connection_stack) <= 1, \
        'You should not mix Connection contexts with use_connection()'
    release_local(_connection_stack)

    if redis is None:
        redis = yield from create_redis(**kwargs)
    push_connection(redis)
コード例 #42
0
def get_async_redis():
    """ initialize an asyncronous redis connection
    """
    global ASYNCREDIS
    if ASYNCREDIS is None or ASYNCREDIS.closed:  # pragma: no branch
        address = REDIS_PUBSUB["address"]
        db = REDIS_PUBSUB["db"]
        password = REDIS_PUBSUB["password"]
        ASYNCREDIS = yield from aioredis.create_redis(address,
                                                      db=db,
                                                      password=password)
    return ASYNCREDIS
コード例 #43
0
 def go():
     redis = yield from aioredis.create_redis(
         ('localhost', 6379))
     yield from redis.delete('foo', 'bar')
     tr = redis.multi_exec()
     fut1 = tr.incr('foo')
     fut2 = tr.incr('bar')
     res = yield from tr.execute()
     res2 = yield from asyncio.gather(fut1, fut2)
     print(res)
     assert res == res2
     redis.close()
     yield from redis.wait_closed()
コード例 #44
0
ファイル: __init__.py プロジェクト: timercrack/pydatacoll
 def __init__(self, io_loop: asyncio.AbstractEventLoop = None):
     super().__init__()
     self.io_loop = io_loop or asyncio.get_event_loop()
     self.sub_client = self.io_loop.run_until_complete(
             aioredis.create_redis((config.get('REDIS', 'host', fallback='localhost'),
                                    config.getint('REDIS', 'port', fallback=6379)),
                                   db=config.getint('REDIS', 'db', fallback=1)))
     self.redis_client = redis.StrictRedis(db=config.getint('REDIS', 'db', fallback=1), decode_responses=True)
     self.initialized = False
     self.sub_tasks = list()
     self.sub_channels = list()
     self.channel_router = dict()
     self._register_channel()
コード例 #45
0
ファイル: __init__.py プロジェクト: nochristrequired/ircb
 def register_sub(self, subscriber_addr, key):
     yield from self._lock.acquire()
     try:
         connections = self._dispatcher.publisher.transport.connections()
         if subscriber_addr in connections:
             self._lock.release()
             return
         self._dispatcher.publisher.transport.connect(subscriber_addr)
         redis = yield from aioredis.create_redis(
             (settings.REDIS_HOST, settings.REDIS_PORT))
         yield from redis.set(key, 1)
         redis.close()
     finally:
         self._lock.release()
コード例 #46
0
def main():
    redis = yield from aioredis.create_redis(('localhost', 6379))

    @asyncio.coroutine
    def transaction():
        tr = redis.multi_exec()
        future1 = tr.set('foo', '123')
        future2 = tr.set('bar', '321')
        result = yield from tr.execute()
        assert result == (yield from asyncio.gather(future1, future2))
        return result

    redis.close()
    yield from redis.wait_closed()
コード例 #47
0
 def _get_connection(self):
     """
     create new Redis connection
     for more details see create_redis function in aioredis module
     this function is coroutine
     """
     connection = yield from aioredis.create_redis(
         self.address,
         db=self.db,
         password=self.password,
         ssl=self.ssl,
         encoding=self.encoding,
         loop=self.loop
     )
     return connection
コード例 #48
0
ファイル: aiohttpapp.py プロジェクト: devel787/dj_aio_chat_01
    def __call__(self, request):
        yield from self.validation_part(request)

        ws = web.WebSocketResponse()
        ws.start(request)

        pub = yield from aioredis.create_redis(redis_address)
        sub = yield from aioredis.create_redis(redis_address)

        channel = "thread_{0}_messages".format(self.thread_id)

        sub_channel_list = yield from sub.subscribe(channel)
        zero_sub_channel = sub_channel_list[0]

        # ---------------------------------------------------------------------

        print("Connection opened")

        try:
            # Kick off both coroutines in parallel,
            # and then block until both are completed.
            yield from asyncio.gather(
                self.handle_ws_part(ws, pub, channel), self.handle_redis_part(ws, zero_sub_channel)
            )
        except Exception:
            print("")
            print("except Exception:")
            print("--------------------------------")
            traceback.print_exc()
            print("--------------------------------")
        finally:
            sub.close()
            pub.close()
            print("Connection closed")

        return ws
コード例 #49
0
def fake_aioredis(request: FixtureRequest, loop: asyncio.BaseEventLoop):
    r: aioredis.Redis = loop.run_until_complete(
        aioredis.create_redis('redis://localhost:6379', db=2,
                              encoding='utf-8'))
    loop.run_until_complete(r.flushdb())
    redis_objects = filter(
        lambda i: i != db.RedisObject and issubclass(i, db.RedisObject),
        filter(lambda i: type(i) == type, map(lambda i: getattr(db, i),
                                              dir(db))))
    for redis_object in redis_objects:
        redis_object.register_db(r)
    yield r
    loop.run_until_complete(r.flushdb())
    r._pool_or_conn.close()
    loop.run_until_complete(r._pool_or_conn.wait_closed())
コード例 #50
0
ファイル: __init__.py プロジェクト: waartaa/ircb
 def register_sub(self, subscriber_addr, key):
     yield from self._lock.acquire()
     try:
         connections = self._dispatcher.publisher.transport.connections()
         if subscriber_addr in connections:
             self._lock.release()
             return
         self._dispatcher.publisher.transport.connect(subscriber_addr)
         redis = yield from aioredis.create_redis(
             (settings.REDIS_HOST, settings.REDIS_PORT)
         )
         yield from redis.set(key, 1)
         redis.close()
     finally:
         self._lock.release()
コード例 #51
0
ファイル: transaction2.py プロジェクト: alefteris/aioredis
def main():
    redis = yield from aioredis.create_redis(
        ('localhost', 6379))

    @asyncio.coroutine
    def transaction():
        tr = redis.multi_exec()
        future1 = tr.set('foo', '123')
        future2 = tr.set('bar', '321')
        result = yield from tr.execute()
        assert result == (yield from asyncio.gather(future1, future2))
        return result

    redis.close()
    yield from redis.wait_closed()
コード例 #52
0
ファイル: pool_pubsub.py プロジェクト: vir-mir/aioredis
 def publish():
     pub = yield from aioredis.create_redis(('localhost', 6379))
     while not tsk.done():
         # wait for clients to subscribe
         while True:
             subs = yield from pub.pubsub_numsub('channel:1')
             if subs[b'channel:1'] == 1:
                 break
             yield from asyncio.sleep(0, loop=loop)
         # publish some messages
         for msg in ['one', 'two', 'three']:
             yield from pub.publish('channel:1', msg)
         # send stop word
         yield from pub.publish('channel:1', STOPWORD)
     pub.close()
     yield from pub.wait_closed()
コード例 #53
0
def run(loop):
    client = yield aioredis.create_redis(('localhost', 6379), loop=loop)
    tasks = []
    fs = []

    for i in range(50000):
        task_id = produce(i, client)
        fs.append(sync(client, i, task_id))
        if i % 1000:
            yield tornado.gen.sleep(0.01)

    print('All tasks sent')
    yield from fs

    client.close()
    yield client.wait_closed()
コード例 #54
0
ファイル: pool_pubsub.py プロジェクト: free-free/aioredis
 def publish():
     pub = yield from aioredis.create_redis(
         ('localhost', 6379))
     while not tsk.done():
         # wait for clients to subscribe
         while True:
             subs = yield from pub.pubsub_numsub('channel:1')
             if subs[b'channel:1'] == 1:
                 break
             yield from asyncio.sleep(0, loop=loop)
         # publish some messages
         for msg in ['one', 'two', 'three']:
             yield from pub.publish('channel:1', msg)
         # send stop word
         yield from pub.publish('channel:1', STOPWORD)
     pub.close()
     yield from pub.wait_closed()
コード例 #55
0
ファイル: __init__.py プロジェクト: wulon/pydatacoll
 def __init__(self, io_loop: asyncio.AbstractEventLoop = None):
     super().__init__()
     self.io_loop = io_loop or asyncio.get_event_loop()
     self.sub_client = self.io_loop.run_until_complete(
         aioredis.create_redis(
             (config.get('REDIS', 'host', fallback='localhost'),
              config.getint('REDIS', 'port', fallback=6379)),
             db=config.getint('REDIS', 'db', fallback=1)))
     self.redis_client = redis.StrictRedis(db=config.getint('REDIS',
                                                            'db',
                                                            fallback=1),
                                           decode_responses=True)
     self.initialized = False
     self.sub_tasks = list()
     self.sub_channels = list()
     self.channel_router = dict()
     self._register_channel()
コード例 #56
0
    def test_script_kill(self):
        script = "while (1) do redis.call('TIME') end"

        other_redis = yield from create_redis(
            ('localhost', self.redis_port), loop=self.loop)

        yield from self.add('key1', 'value')

        fut = other_redis.eval(script, keys=['non-existent-key'], args=[10])
        yield from asyncio.sleep(0, loop=self.loop)
        resp = yield from self.redis.script_kill()
        self.assertTrue(resp)

        with self.assertRaises(ReplyError):
            yield from fut

        with self.assertRaises(ReplyError):
            yield from self.redis.script_kill()
コード例 #57
0
ファイル: http_asyncio_redis.py プロジェクト: tailhook/stator
def main():
    loop = asyncio.get_event_loop()
    redis = loop.run_until_complete(
        aioredis.create_redis("/work/target/redis.sock", loop=loop))
    #redis = loop.run_until_complete(
    #    aioredis.create_redis(("127.0.0.1", 3001), loop=loop))

    @asyncio.coroutine
    def dispatch(loop, req):
        n = yield from redis.incr("hello-world-counter")
        req.reply(
            [200, u"OK"],
            {u"Content-Type": b"text/html"},
            "Hello page opened {} times".format(n).encode('utf-8'))

    sock = http.Http('0.0.0.0', 3000)
    aio.start(dispatch, loop=loop)

    loop.run_forever()