async def get_connection(alias): _conn = getattr(_connections, alias) if isawaitable(_conn) and not isinstance(_conn, aioredis.ConnectionsPool): _conn = await _conn return aioredis.Redis(_conn)
def __init__(self) -> None: self.instances: list[Instance] = [] pool = aioredis.ConnectionPool.from_url( f"redis://{config.database.redis_host}:{config.database.redis_port}/{config.database.redis_database}", max_connections=2, ) self.redis = aioredis.Redis(connection_pool=pool)
async def connection(self, **kwargs): """ __init async redis initialization """ self._logger.info("AsyncRedis: Connecting to {}".format(self._dsn)) try: connection = await aioredis.create_connection( self._dsn, loop=self._loop, encoding=self._encoding, timeout=self._timeout, **kwargs, ) self._connection = aioredis.Redis(connection) except (aioredis.ProtocolError, aioredis.AuthError) as err: raise ProviderError( "Unable to connect to Redis, connection Refused: {}".format( str(err))) except (aioredis.RedisError, asyncio.TimeoutError) as err: raise ConnectionTimeout("Unable to connect to Redis: {}".format( str(err))) except Exception as err: raise ProviderError("Unknown Redis Error: {}".format(str(err))) return False # is connected if self._connection: self._connected = True self._initialized_on = time.time()
async def connect(self, **kwargs): """ __init async db initialization """ self.logger.debug("Redis Pool: Connecting to {}".format(self._dsn)) try: self._pool = aioredis.ConnectionPool.from_url( self._dsn, encoding=self._encoding, decode_responses=True, max_connections=self._max_queries, **kwargs, ) self._connection = aioredis.Redis(connection_pool=self._pool) except (aioredis.exceptions.ConnectionError) as err: raise ConnectionTimeout("Unable to connect to Redis: {}".format( str(err))) except (aioredis.exceptions.RedisError) as err: raise ProviderError( "Unable to connect to Redis, connection Refused: {}".format( str(err))) except Exception as err: raise ProviderError("Unknown Error: {}".format(str(err))) return False # is connected if self._pool: self._connected = True self._initialized_on = time.time()
async def _connect(self): settings = app_settings["redis"] self._pool = await aioredis.create_pool( (settings["host"], settings["port"]), **settings["pool"], loop=self._loop ) self._conn = await self._pool.acquire() self._pubsub_subscriptor = aioredis.Redis(self._conn)
def redis_pool() -> Redis: connection_pool = aioredis.ConnectionPool(max_connections=100) REDIS_POOL = aioredis.Redis(host="127.0.0.1", port=6379, db=0, connection_pool=connection_pool) return REDIS_POOL
async def f(url: str = request.config.getoption("--redis-url"), **kwargs): single = kwargs.pop("single_connection_client", False) or single_connection parser_class = kwargs.pop("parser_class", None) or parser_cls url_options = parse_url(url) url_options.update(kwargs) pool = aioredis.ConnectionPool(parser_class=parser_class, **url_options) client: aioredis.Redis = aioredis.Redis(connection_pool=pool) if single: client = client.client() await client.initialize() def teardown(): async def ateardown(): if "username" in kwargs: return try: await client.flushdb() except aioredis.ConnectionError: # handle cases where a test disconnected a client # just manually retry the flushdb await client.flushdb() await client.close() await client.connection_pool.disconnect() if event_loop.is_running(): event_loop.create_task(ateardown()) else: event_loop.run_until_complete(ateardown()) request.addfinalizer(teardown) return client
def _connect_redis(self) -> None: pool = aioredis.ConnectionPool.from_url( self.config['redis']['host'], password=self.config['redis']['password'], db=self.config['redis']['db-index']) self.redis = aioredis.Redis(connection_pool=pool)
async def _get_channel(self) -> aioredis.Channel: conn = aioredis.Redis(await self.connection.acquire()) client_id = await conn.execute(b"CLIENT", b"ID") await conn.execute(*BCAST_ON.format( client_id=client_id, prefix=self._prefix).encode().split()) channel, *_ = await conn.subscribe(_REDIS_INVALIDATE_CHAN) return channel
async def connect_all(self): """Connects all databases and initializes sessions""" proxy_url = self.config.external.proxy_url if proxy_url is None: self.session = aiohttp.ClientSession() else: self.session = ProxiedClientSession(proxy_url=proxy_url) self.trusted_session = aiohttp.ClientSession() pool = aioredis.ConnectionPool.from_url( f"redis://{self.config.database.redis_host}:{self.config.database.redis_port}/{self.config.database.redis_database}", max_connections=20, ) self.redis = aioredis.Redis(connection_pool=pool) database_creds = { "database": self.config.database.postgres_name, "user": self.config.database.postgres_user, "password": self.config.database.postgres_password, "host": self.config.database.postgres_host, "port": self.config.database.postgres_port, } self.pool = await asyncpg.create_pool(**database_creds, min_size=10, max_size=20, command_timeout=60.0) for extension in self.config.bot.initial_extensions: try: self.load_extension(extension) except Exception: print(f"Failed to load extension {extension}.", file=sys.stderr) traceback.print_exc() self.redis_version = await self.get_redis_version() await self.load_bans() await self.start(self.config.bot.token)
async def open(self) -> None: try: self._connection = await self._pool.acquire() self._redis = aioredis.Redis(self._connection) except OSError: bot.globals.running = False raise
async def f(*args, **kwargs): async with RedisConnector.instance(name).connection() as redis: if "redis" in kwargs: raise RedisConnectorError( "duplicated database argument for redis %s" % name) kwargs.update({"redis": aioredis.Redis(redis)}) retval = await function(*args, **kwargs) return retval
async def start(self, *args, **kwargs): t = threading.Thread(target=block_check, args=(self.loop,)) t.setDaemon(True) t.start() self.redis = aioredis.Redis(await aioredis.create_pool("redis://" + self.config.redis_host)) # self.loop.create_task(self._shards_reader()) return await super().start(*args, **kwargs)
async def f(*args, **kwargs): async with RedisConnector.instance(name).connection() as redis: if 'redis' in kwargs: raise RedisConnectorError( f'duplicated database argument for redis {name}') kwargs.update({'redis': aioredis.Redis(redis)}) retval = await function(*args, **kwargs) return retval
async def on_start(self, _app: http.app.Application, _loop: ioloop.IOLoop) -> None: """Invoked on startup of the application""" self.startup_complete = asyncio.Event() if sentry_sdk and self.settings['sentry_backend_dsn']: sentry_sdk.init(debug=self.settings['debug'], dsn=self.settings['sentry_backend_dsn'], environment=os.environ.get('environment', 'production'), integrations=[ sentry_logging.LoggingIntegration( event_level=logging.CRITICAL), sentry_tornado.TornadoIntegration() ], release=version) self.loop = ioloop.IOLoop.current() try: self.session_redis = aioredis.Redis(await aioredis.create_pool( self.settings['session_redis_url'], maxsize=self.settings['session_pool_size'])) except (OSError, ConnectionRefusedError) as error: LOGGER.info('Error connecting to Session redis: %r', error) self.stop(self.loop) return try: pool = aioredis.Redis(await aioredis.create_pool( self.settings['session_redis_url'], maxsize=self.settings['session_pool_size'])) except (OSError, ConnectionRefusedError) as error: LOGGER.info('Error connecting to Stats redis: %r', error) self.stop(self.loop) return else: self.stats = stats.Stats(pool) await self._postgres_connected.wait() self.startup_complete.set() self._ready_to_serve = True LOGGER.info('Application startup complete, ready to serve requests')
def __init__(self, conn_address=str, key_prefix='', loop=None): # conn = loop.run_until_complete(aioredis.create_pool(settings.REDIS_ADDRESS)) conn = aioredis.ConnectionsPool(address=conn_address, minsize=1, maxsize=10, loop=loop or asyncio.get_event_loop()) self._redis = aioredis.Redis(conn) self._rk = key_prefix+RK_STORAGE_DATA if (not key_prefix) or key_prefix.endswith(':') \ else key_prefix+':'+RK_STORAGE_DATA
async def start_services(sanic, loop): await db.set_bind(f'postgresql://' f'{app.config.POSTGRES_USER}:' f'{app.config.POSTGRES_PASSWORD}@' f'{app.config.POSTGRES_HOST}/' f'{app.config.POSTGRES_NAME}') pool = aioredis.ConnectionPool.from_url( f'redis://{app.config.REDIS_ADDRESS}:{app.config.REDIS_PORT}') app.ctx.redis = aioredis.Redis(connection_pool=pool)
def __init__(self, config: MinosConfig, pool_size: int = 50): """Perform initial configuration and connection to Redis""" address = config.discovery.database.host port = config.discovery.database.port password = config.discovery.database.password pool = aioredis.ConnectionPool.from_url(f"redis://{address}:{port}", password=password, max_connections=pool_size) self.redis = aioredis.Redis(connection_pool=pool)
def __init__(self, host='localhost', port=6379, db=0, password=None, prefix='telebot_'): if not redis_installed: raise ImportError('AioRedis is not installed. Install it via "pip install aioredis"') aioredis_version = tuple(map(int, aioredis.__version__.split(".")[0])) if aioredis_version < (2,): raise ImportError('Invalid aioredis version. Aioredis version should be >= 2.0.0') self.redis = aioredis.Redis(host=host, port=port, db=db, password=password) self.prefix = prefix
async def wrapper(self, *args, _conn=None, **kwargs): if _conn is None: pool = await self._get_pool() conn_context = await pool with conn_context as _conn: if not AIOREDIS_BEFORE_ONE: _conn = aioredis.Redis(_conn) return await func(self, *args, _conn=_conn, **kwargs) return await func(self, *args, _conn=_conn, **kwargs)
async def total_api_calls(request): if request.method == 'GET': pool = aioredis.ConnectionPool.from_url("redis://redis:6379/0", decode_responses=True) r = aioredis.Redis(connection_pool=pool) content = await r.get("api_requests") data = json.loads(content) pool.disconnect() return JsonResponse(data, safe=False, json_dumps_params={'indent': 4}) else: return HttpResponse(status=400)
async def median_prices(request): await LogEndpoint("Network Median Pricing") if request.method == 'GET': pool = aioredis.ConnectionPool.from_url("redis://redis:6379/0", decode_responses=True) r = aioredis.Redis(connection_pool=pool) content = await r.get("network_median_pricing") data = json.loads(content) pool.disconnect() return JsonResponse(data, safe=False, json_dumps_params={'indent': 4}) else: return HttpResponse(status=400)
async def stats(context, request): memory_cache = cache.get_memory_cache() redis = aioredis.Redis(await cache.get_redis_pool()) redis_data = await redis.info() return { 'in-memory': { 'size': len(memory_cache), 'stats': memory_cache.get_stats() }, 'redis': redis_data }
async def __aenter__(self): pool = await aioredis.create_connection(self.addr.redis_server, **self.transport._redis_opts) self.transport._redis = aioredis.Redis(pool) key = f'{self.addr.stream_key}.conn' await self.transport._redis.xadd(key, {b'meta': b'create-stream'}) groups = await self.transport._redis.xinfo_groups(key) if not any( map(lambda g: g[b'name'] == self.addr.group.encode(), groups)): await self.transport._redis.xgroup_create( key, self.addr.group) # TODO: mkstream=True in future aioredis return RPCRedisConnection(self.transport, self.addr, ('conn', 'bind'))
async def __call__(self) -> aioredis.Redis: if self._pool is not None: return self._pool async with self._lock: if self._pool is not None: return self._pool logger.debug("Creating Redis Pool") host = settings.REDIS_HOST port = settings.REDIS_PORT pool = await aioredis.create_pool((host, port), encoding="utf-8") self._pool = aioredis.Redis(pool) return self._pool
async def test_connect_pool_aioredis_instance(self): def awaiter(self): yield from [] pool = FakePool() redis_connection = aioredis.Redis(pool) instance = Instance(redis_connection) assert instance._pool is None await instance.connect() assert pool.execute.call_count == 2 assert instance.set_lock_script_sha1 is not None assert instance.unset_lock_script_sha1 is not None
def __init__(self, settings: Settings) -> None: """Set initial state.""" try: config = settings["plugin_config"][self.config_key] self.connection = config["connection"] except KeyError as error: raise OutboundQueueConfigurationError( "Configuration missing for redis queue") from error self.prefix = config.get("prefix", "acapy") self.pool = aioredis.ConnectionPool.from_url(self.connection, max_connections=10) self.redis = aioredis.Redis(connection_pool=self.pool)
async def init(): """Create a connection to the Redis server.""" global redis_conn # pylint: disable=global-statement,invalid-name conn = await aioredis.create_connection( # pylint: disable=invalid-name 'redis://{}:{}'.format( SETTINGS.get('FLOW_EXECUTOR', {}).get('REDIS_CONNECTION', {}).get('host', 'localhost'), SETTINGS.get('FLOW_EXECUTOR', {}).get('REDIS_CONNECTION', {}).get('port', 56379)), db=int( SETTINGS.get('FLOW_EXECUTOR', {}).get('REDIS_CONNECTION', {}).get('db', 1))) redis_conn = aioredis.Redis(conn)
async def f(*args, **kwargs): if 'redis' in kwargs: raise RedisConnectorError( f'duplicated database argument for redis {name}') connector = RedisConnector.instance(name) connection = await connector.acquire() redis = aioredis.Redis(connection) kwargs.update({'redis': redis}) try: retval = await function(*args, **kwargs) return retval finally: connector.release()
async def __aenter__(self): pool = await aioredis.create_connection(self.addr.redis_server, **self.transport._redis_opts) self.transport._redis = aioredis.Redis(pool) key = self.addr.stream_key # If there were no stream with the specified key before, # it is created as a side effect of adding the message. await self.transport._redis.xadd( key, {b'meta': b'create-or-join-to-stream'}) groups = await self.transport._redis.xinfo_groups(key) if not any( map(lambda g: g[b'name'] == self.addr.group.encode(), groups)): await self.transport._redis.xgroup_create(key, self.addr.group) return DispatchRedisConnection(self.transport, self.addr)