def test_decoding(self): conn = yield from create_connection( ('localhost', self.redis_port), encoding='utf-8', loop=self.loop) self.assertEqual(conn.encoding, 'utf-8',) res = yield from conn.execute('set', 'key1', 'value') self.assertEqual(res, 'OK') res = yield from conn.execute('get', 'key1') self.assertEqual(res, 'value') res = yield from conn.execute('set', 'key1', b'bin-value') self.assertEqual(res, 'OK') res = yield from conn.execute('get', 'key1') self.assertEqual(res, 'bin-value') res = yield from conn.execute('get', 'key1', encoding='ascii') self.assertEqual(res, 'bin-value') res = yield from conn.execute('get', 'key1', encoding=None) self.assertEqual(res, b'bin-value') with self.assertRaises(UnicodeDecodeError): yield from conn.execute('set', 'key1', 'значение') yield from conn.execute('get', 'key1', encoding='ascii') conn2 = yield from create_connection( ('localhost', self.redis_port), loop=self.loop) res = yield from conn2.execute('get', 'key1', encoding='utf-8') self.assertEqual(res, 'значение')
def test_auth(self): conn = yield from create_connection( ('localhost', self.redis_port), loop=self.loop) res = yield from conn.execute('CONFIG', 'SET', 'requirepass', 'pass') self.assertEqual(res, b'OK') conn2 = yield from create_connection( ('localhost', self.redis_port), loop=self.loop) with self.assertRaises(ReplyError): yield from conn2.select(1) res = yield from conn2.auth('pass') self.assertEqual(res, True) res = yield from conn2.select(1) self.assertTrue(res) conn3 = yield from create_connection( ('localhost', self.redis_port), password='******', loop=self.loop) res = yield from conn3.select(1) self.assertTrue(res) res = yield from conn2.execute('CONFIG', 'SET', 'requirepass', '') self.assertEqual(res, b'OK')
def test_connect_tcp(self): conn = yield from create_connection( ('localhost', self.redis_port), loop=self.loop) self.assertEqual(conn.db, 0) self.assertEqual(str(conn), '<RedisConnection [db:0]>') conn = yield from create_connection( ['localhost', self.redis_port], loop=self.loop) self.assertEqual(conn.db, 0) self.assertEqual(str(conn), '<RedisConnection [db:0]>')
def test_close_connection__tcp(self): loop = self.loop conn = loop.run_until_complete(create_connection( ('localhost', self.redis_port), loop=loop)) conn.close() with self.assertRaises(AssertionError): loop.run_until_complete(conn.select(1)) conn = loop.run_until_complete(create_connection( ('localhost', self.redis_port), loop=loop)) with self.assertRaises(AssertionError): conn.close() fut = conn.select(1) loop.run_until_complete(fut)
def test_execute_exceptions(self): conn = yield from create_connection( ('localhost', self.redis_port), loop=self.loop) with self.assertRaises(TypeError): yield from conn.execute(None) with self.assertRaises(TypeError): yield from conn.execute("ECHO", None)
def test_global_loop(self): asyncio.set_event_loop(self.loop) conn = self.loop.run_until_complete(create_connection( ('localhost', self.redis_port), db=0)) self.assertEqual(conn.db, 0) self.assertIs(conn._loop, self.loop)
def redis_server(docker, session_id, loop, request): if not request.config.option.no_pull: docker.pull('redis:{}'.format('latest')) container = docker.create_container( image='redis:{}'.format('latest'), name='redis-test-server-{}-{}'.format('latest', session_id), ports=[6379], detach=True, ) docker.start(container=container['Id']) inspection = docker.inspect_container(container['Id']) host = inspection['NetworkSettings']['IPAddress'] delay = 0.001 for i in range(100): try: conn = loop.run_until_complete( aioredis.create_connection((host, 6379), loop=loop)) loop.run_until_complete(conn.execute('SET', 'foo', 'bar')) break except ConnectionRefusedError as e: time.sleep(delay) delay *= 2 else: pytest.fail("Cannot start redis server") container['redis_params'] = dict(address=(host, 6379)) yield container docker.kill(container=container['Id']) docker.remove_container(container['Id'])
def drain_queues(transport, loop): conn = yield from aioredis.create_connection( (config.get('redis', 'host'), 6379), loop=loop) while True: # check redis for list of my clients clients = yield from conn.execute('zrange', '%s:clients' % myid(), 0, -1) # for each client, check redis if there is a message in their queue for client in clients: next_message_in_queue = yield from conn.execute('lpop', '%s:queue' % client) if next_message_in_queue is not None: # not needed but makes nice debug msg = message.MQTTSNMessage() msg.parse(next_message_in_queue) logger.debug("Sending %s to %s" % (msg, client,)) # get the socket from redis socket = pickle.loads(client) # if I want more info about this, it's here # client_info = r.hget('%s:socket' % client, 'socket')) # get transport somehow transport.sendto(next_message_in_queue, socket) conn.close()
def go(params): conn = yield from aioredis.create_connection( ('localhost', 6379), encoding='utf-8') ok = yield from conn.execute(*params) print("%s = %s" % (params, ok,)) conn.close()
def go(params): conn = yield from aioredis.create_connection(('localhost', 6379), encoding='utf-8') ok = yield from conn.execute(*params) print("%s = %s" % ( params, ok, )) conn.close()
def test_protocol_error(self): loop = self.loop conn = yield from create_connection( ('localhost', self.redis_port), loop=loop) reader = conn._reader with self.assertRaises(ProtocolError): reader.feed_data(b'not good redis protocol response') yield from conn.select(1) self.assertEqual(len(conn._waiters), 0)
def test_select_db(self): address = ('localhost', self.redis_port) conn = yield from create_connection(address, loop=self.loop) self.assertEqual(conn.db, 0) with self.assertRaises(ValueError): yield from create_connection(address, db=-1, loop=self.loop) with self.assertRaises(TypeError): yield from create_connection(address, db=1.0, loop=self.loop) with self.assertRaises(TypeError): yield from create_connection( address, db='bad value', loop=self.loop) with self.assertRaises(TypeError): conn = yield from create_connection( address, db=None, loop=self.loop) yield from conn.select(None) with self.assertRaises(ReplyError): yield from create_connection( address, db=100000, loop=self.loop) yield from conn.select(1) self.assertEqual(conn.db, 1) yield from conn.select(2) self.assertEqual(conn.db, 2) yield from conn.execute('select', 0) self.assertEqual(conn.db, 0) yield from conn.execute(b'select', 1) self.assertEqual(conn.db, 1)
def redis_server( docker: DockerClient, session_id: str, loop: asyncio.AbstractEventLoop, ) -> Generator[_TContainerInfo, None, None]: image = 'redis:{}'.format('latest') if sys.platform.startswith('darwin'): port = unused_port() else: port = None container = docker.containers.run( image=image, detach=True, name='redis-test-server-{}-{}'.format('latest', session_id), ports={ '6379/tcp': port, }, environment={ 'http.host': '0.0.0.0', 'transport.host': '127.0.0.1', }, ) if sys.platform.startswith('darwin'): host = '0.0.0.0' else: inspection = docker.api.inspect_container(container.id) host = inspection['NetworkSettings']['IPAddress'] port = 6379 delay = 0.1 for i in range(20): try: conn = loop.run_until_complete( aioredis.create_connection((host, port), loop=loop)) loop.run_until_complete(conn.execute('SET', 'foo', 'bar')) break except ConnectionRefusedError: time.sleep(delay) delay *= 2 else: pytest.fail("Cannot start redis server") yield {'host': host, 'port': port, 'container': container} container.kill(signal=9) container.remove(force=True)
def go(): conn = yield from aioredis.create_connection(('localhost', 6379), encoding='utf-8') ok = yield from conn.execute('set', 'my-key', 'some value') assert ok == 'OK', ok str_value = yield from conn.execute('get', 'my-key') raw_value = yield from conn.execute('get', 'my-key', encoding=None) assert str_value == 'some value' assert raw_value == b'some value' print('str value:', str_value) print('raw value:', raw_value) # optionally close connection conn.close()
def go(): conn = yield from aioredis.create_connection( ('localhost', 6379), encoding='utf-8') ok = yield from conn.execute('set', 'my-key', 'some value') assert ok == 'OK', ok str_value = yield from conn.execute('get', 'my-key') raw_value = yield from conn.execute('get', 'my-key', encoding=None) assert str_value == 'some value' assert raw_value == b'some value' print('str value:', str_value) print('raw value:', raw_value) # optionally close connection conn.close()
def main(): loop = asyncio.get_event_loop() redis = loop.run_until_complete( aioredis.create_connection(('localhost', 6379))) bots = [ EchoBot(echo_bot_token, loop, redis), JournalBot(journal_bot_token, loop, redis, client[journal_bot_token]), ] try: aiohttp.web.run_app(init_app(bots)) except BaseException as exc: print(exc) finally: for bot in bots: bot.shutdown()
def get_digest(value): """Get digest takes either an URI/URL or a Literal value and calls the SHA1 for the add_get_hash.lua script. Args: value -- URI/URL or Literal value """ if not value: return None connection = yield from aioredis.create_connection( (config.get("redis")["host"], config.get("redis")["port"]), encoding='utf-8') sha1_digest = yield from connection.execute(b'EVALSHA', LUA_SCRIPTS['add_get_hash'], 1, value, config.get("redis").get('ttl')) connection.close() return sha1_digest
async def go(): foo = aioredis.create_connection( (redis_url.hostname, redis_url.port), password=redis_url.password, loop=loop) print(foo) import types print(isinstance(foo, types.GeneratorType)) conn = await foo print(conn) print('foo') import json foo = {'foo': 'bar'} #await conn.execute('set', 'my-key', json.dumps(foo)) val = await conn.execute('get', 'my-key') print(json.loads(val)) conn.close() await conn.wait_closed()
def go(): # def create_connection(address, *, db=None, password=None, # encoding=None, loop=None): conn = yield from aioredis.create_connection(('localhost', 6379), encoding='utf-8') print("redis connection:",conn) ok = yield from conn.execute('set', 'my-key', 'selo') assert ok == 'OK', ok str_value = yield from conn.execute('get', 'my-key') raw_value = yield from conn.execute('get', 'my-key', encoding=None) print('str_value:', str_value) print('raw_value:', raw_value) assert str_value == 'selo' assert raw_value == b'selo' conn.close()
def connect_to_redis_servers(self): print("[ {} ] Connecting to Redis servers...".format( datetime.datetime.utcnow())) self.redis_clients = [] self.redis_nodes = dict() counter = 1 for IP, port in self.redis_endpoints: print( "[ {} ] Attempting to connect to Redis server {}/{} at {}:{}". format(datetime.datetime.utcnow(), counter, len(self.redis_endpoints), IP, port)) connection = yield aioredis.create_connection( address=(IP, port), loop=IOLoop.current().asyncio_loop, encoding=options.encoding ) #redis.StrictRedis(host=IP, port = port, db = 0) redis_client = aioredis.Redis(connection) print("[ {} ] Successfully connected to Redis server {}.".format( datetime.datetime.utcnow(), counter)) self.redis_clients.append(redis_client) key_string = "node-" + str(IP) + ":" + str(port) self.redis_nodes[key_string] = { "hostname": key_string + ".FQDN", "nodename": key_string, "instance": redis_client, "port": port, "vnodes": 40 } counter += 1 self.hash_ring = HashRing(self.redis_nodes) #for port in self.redis_ports: # print("[ {} ] Attempting to connect to Redis server {}/{} at {}:{}".format(datetime.datetime.utcnow(), counter, len(self.redis_ports), self.redis_endpoint, port)) # #connection = IOLoop.current().run_sync(lambda: aioredis.create_connection(address = (self.redis_endpoint, port), loop = IOLoop.current().asyncio_loop, encoding = options.encoding)) # connection = yield aioredis.create_connection(address = (self.redis_endpoint, port), loop = IOLoop.current().asyncio_loop, encoding = options.encoding) # redis_client = aioredis.Redis(connection) # self.redis_clients.append(redis_client) # counter = counter + 1 self.num_redis_clients = len(self.redis_clients)
def create_connection(self, *args, **kw): conn = yield from create_connection(*args, **kw) self._conns.append(conn) return conn
def f(*args, **kw): conn = yield from aioredis.create_connection(*args, **kw) _closable(conn) return conn
lambda d: 'soundcloud' in d.data) dp.register_callback_query_handler( callback_handlers.artist_callback_handler, lambda d: 'artist' in d.data) dp.register_callback_query_handler(callback_handlers.callback_handler) dp.register_chosen_inline_handler(inline_handlers.finish_download_handler) dp.middleware.setup(Middleware()) try: global session bot = Bot(token=config.bot_token, loop=loop) storage = MemoryStorage() dp = Dispatcher(bot, storage=storage) var.downloading = {} var.session = aiohttp.ClientSession(raise_for_status=True) print('created session') var.CSRFToken = None var.loop = loop from spotify import Spotify_API var.spot = Spotify_API( config.spotify_client, config.spotify_secret) var.db = database('db.sqlite') var.conn = loop.run_until_complete(aioredis.create_connection( ('localhost', 6379), encoding='utf-8', db=4, loop=loop)) print('datebase connected') except Exception as e: print(e)
response.send_headers() yield from response.write_eof() def snare_setup(): if os.getuid() != 0: print('Snare has to be started as root!') sys.exit(1) if not os.path.exists('/opt/snare'): os.mkdir('/opt/snare') if not os.path.exists('/opt/snare/pages'): os.mkdir('/opt/snare/pages') if __name__ == '__main__': snare_setup() parser = argparse.ArgumentParser() parser.add_argument("--page-dir", help="name of the folder to be served") args = parser.parse_args() loop = asyncio.get_event_loop() redis_conn = aioredis.create_connection(('localhost', 6379), loop=loop) f = loop.create_server( lambda: HttpRequestHandler(args, debug=True, keep_alive=75), '0.0.0.0', '8080') srv = loop.run_until_complete(f) print('serving on', srv.sockets[0].getsockname()) try: loop.run_forever() except KeyboardInterrupt: pass
def test_close_connection__socket(self): conn = yield from create_connection( self.redis_socket, loop=self.loop) conn.close() with self.assertRaises(AssertionError): yield from conn.select(1)
def init_connection(self): self.connection =\ yield from aioredis.create_connection((self.url, self.port), loop=self.loop, encoding='utf-8')
def test_connect_unixsocket(self): conn = yield from create_connection( self.redis_socket, db=0, loop=self.loop) self.assertEqual(conn.db, 0) self.assertEqual(str(conn), '<RedisConnection [db:0]>')
'Connection': 'keep-alive', } var.session = aiohttp.ClientSession(cookies=cookies, headers=headers, raise_for_status=False) var.session.get = utils.retry(aiohttp.ClientResponseError, retries=5, cooldown=0.1)(var.session.get) var.session.post = utils.retry(aiohttp.ClientResponseError, retries=5, cooldown=0.1)(var.session.post) print('created session') var.CSRFToken = None var.loop = loop dp = Dispatcher(bot, storage=storage) from spotify import Spotify_API var.spot = Spotify_API(config.spotify_client, config.spotify_secret) var.db = database('db.sqlite') var.conn = loop.run_until_complete( aioredis.create_connection(('localhost', 6379), encoding='utf-8', db=4, loop=loop)) print('datebase connected') except Exception as e: print(e)
def f(*args, **kw): kw.setdefault('loop', loop) conn = yield from aioredis.create_connection(*args, **kw) _closable(conn) return conn