async def init_app(): cfg = Config() pg_pool = await asyncpg.create_pool(cfg.DB_ADDRESS) db_handler = DbHandler(pg_pool=pg_pool, cfg=cfg) app = web.Application() app.add_routes(make_routes_table()) app['cfg'] = cfg app[cfg.DB_HANDLER] = db_handler redis_pool = await aioredis.create_redis_pool(('localhost', 6379)) setup_session(app, RedisStorage(redis_pool, cookie_name='CURRENT_SESSION')) async def dispose_pools(app): redis_pool.close() await redis_pool.wait_closed() await pg_pool.close() app.on_cleanup.append(dispose_pools) app.middlewares.extend(middlewares) mongo_client = AsyncIOMotorClient('localhost', 27017) app[cfg.MONGO_DB] = mongo_client[cfg.MONGO_DB_NAME] http_session = ClientSession() app['http_session'] = http_session async def close_http_session(app): await http_session.close() app.on_cleanup.append(close_http_session) return app
async def init(): #App init app = web.Application() #Add full configs app['config'] = setupConfig() #Add routes setupRoutes(app) app['wslist'] = [] #Add static config setupStatic(app) #Jinja config setupJinja(app) #PostgreSQL init app.db = await init_pg(app) #Setup redis REDIS_CONFIG = tuple(app['config']['redis'].values()) redis_pool = await aioredis.create_pool(REDIS_CONFIG, loop=loop) setup(app, RedisStorage(redis_pool)) app['redis'] = await aioredis.create_redis(REDIS_CONFIG) #ShutDown setups app.on_shutdown.append(close_pg) app.on_shutdown.append(close_redis) return app
async def init_app(config): app = web.Application() app['config'] = config setup_routes(app) setup_middlewares(app) app.on_startup.append(init_pg) app.on_cleanup.append(close_pg) #db_pool = await init_db(app) redis_pool = await setup_redis(app) setup_session(app, RedisStorage(redis_pool)) # needs to be after session setup because of `current_user_ctx_processor` aiohttp_jinja2.setup( app, loader=jinja2.FileSystemLoader(str(BASE_DIR / 'ba' / 'templates')), context_processors=[current_user_ctx_processor], ) setup_security(app, SessionIdentityPolicy(), DBAuthorizationPolicy(app)) log.debug(app['config']) return app
async def init(loop): redis_pool = await create_pool(('localhost', 6379)) dbengine = await create_engine(user=config['postgres']['user'], password=config['postgres']['password'], database=config['postgres']['database'], host=config['postgres']['host']) app = web.Application() app.telegram_token = config['telegram_token'] app.API_URL = API_URL app.dbengine = dbengine #app.logger=AccessLogger() setup_session(app, RedisStorage(redis_pool)) setup_security(app, SessionIdentityPolicy(), DBAuthorizationPolicy(dbengine)) web_handlers = Web() web_handlers.configure(app) #aiohttp_jinja2.setup(app, # loader=jinja2.FileSystemLoader(str(base_dir / 'robo_app' / 'templates'))) aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader(str(TEMPLATES_ROOT))) handler = app.make_handler() srv = await loop.create_server(handler, '127.0.0.1', 8082) print('Server started at http://127.0.0.1:8082') return srv, app, handler
async def create_app(loop): """ Prepare application """ redis_pool = await aioredis.create_pool(settings.REDIS_CON, loop=loop) middlewares = [ session_middleware(RedisStorage(redis_pool)), json_response, status_initial, request_checker, request_user_middleware ] # init application app = web.Application(loop=loop, middlewares=middlewares) app.redis_pool = redis_pool app.wslist = {} jinja_env = aiohttp_jinja2.setup( app, loader=jinja2.FileSystemLoader(settings.TEMPLATE_DIR), context_processors=[aiohttp_jinja2.request_processor], ) jinja_env.globals.update(tags) # db conn database.init(**settings.DATABASE) app.database = database app.database.set_allow_sync(False) app.objects = peewee_async.Manager(app.database) app.database.connect() # make routes setup_routes(app) app.router.add_static('/static', settings.STATIC_DIR, name='static') app.logger = logger handler = app.make_handler(access_log=logger) serv_generator = loop.create_server(handler, settings.HOST, settings.PORT) return serv_generator, handler, app
async def make_app(): parser = argparse.ArgumentParser( description='Python CAS Gateway', formatter_class=argparse.ArgumentDefaultsHelpFormatter ) parser.add_argument('--redis-url', help='Redis URL', default='redis://127.0.0.1:6379/0') parser.add_argument('--timeout', type=int, help='Request timeout', default=10) parser.add_argument('--bind-host', help='Address to bind to', default='0.0.0.0') parser.add_argument('--bind-port', type=int, help='Port to bind to', default='8000') parser.add_argument('--cas-version', type=int, help='CAS version in use', default=3) parser.add_argument('--chunk-size', type=int, help='Chunk size for streaming responses back to the client', default=1024*4) parser.add_argument('--require-attribute', help='Require the given CAS attribute to be present and ' 'not set to an empty string. Requires CAS version 3.') required_named = parser.add_argument_group('required named arguments') required_named.add_argument('--backend-url', help='URL to the backend to be proxied (e.g. http://myhost.com:8888)', required=True) required_named.add_argument('--cas-url', help='URL to the CAS server', required=True) args = parser.parse_args() app = web.Application() print("Configuring...") app.settings = type('Settings', (object,), dict( backend_url=URL(args.backend_url), cas_url=URL(args.cas_url), redis_url=URL(args.redis_url), timeout=args.timeout, bind_host=args.bind_host, bind_port=args.bind_port, # aiohttp_cas was this as a string cas_version=str(args.cas_version), require_attribute=args.require_attribute, ))() print("Connecting to redis...") pool = await create_pool( (app.settings.redis_url.host or '127.0.0.1', app.settings.redis_url.port or 6379), db=int(app.settings.redis_url.path.strip('/') or 0), create_connection_timeout=10, password=app.settings.redis_url.password, ) await remotes_setup(app, XForwardedRelaxed()) session_setup(app, RedisStorage(pool)) u = app.settings.cas_url cas_setup( app=app, host='{}:{}'.format(u.host, u.port) if u.port != 80 else u.host, host_prefix=app.settings.cas_url.path, version=app.settings.cas_version, host_scheme=app.settings.cas_url.scheme ) app.router.add_route('GET', '/cas-gateway-ready', ready_check) app.router.add_route('*', '/{tail:.*}', handle) return app
async def make_app(): app = web.Application() app['config'] = config app['session_name'] = 'VODOMAT_SESSION' app.on_startup.extend([init_db, init_db_redis]) app.on_cleanup.extend([close_db, close_db_redis]) app.add_routes(routes) db_pool = await init_db(app) redis_pool = await init_db_redis(app) setup_session( app, RedisStorage(redis_pool, cookie_name=app['session_name'], max_age=3600)) setup_security(app, SessionIdentityPolicy(), DBAuthorizationPolicy(db_pool)) aiohttp_jinja2.setup( app, loader=jinja2.FileSystemLoader('{}/templates'.format( os.path.dirname(__file__))), filters={'datetime_from_timestamp': datetime_from_timestamp_filter}, context_processors=[current_user_context_processor], ) setup_middlewares(app) aiojobs.aiohttp.setup(app) return app
async def init_app(): """ Initialize app """ redis_pool = await aioredis.create_pool(settings.REDIS, loop=loop) # setup middlewares middlewares = [ session_middleware(RedisStorage(redis_pool)), request_user_middleware ] app = web.Application(middlewares=middlewares) app.redis_pool = redis_pool await db.set_bind(settings.DATABASE_URL) # Create tables await db.gino.create_all() app.router.add_static(settings.STATIC_URL, settings.STATIC_DIR, name='static') app.db = db # Jinja(template system) setup jinja_env = aiohttp_jinja2.setup( app, loader=jinja2.FileSystemLoader(settings.TEMPLATE_DIR), context_processors=[aiohttp_jinja2.request_processor], ) app.add_routes(routes) app.wslist = {} return app
async def init_app(config, loop): app = web.Application() app['config'] = config app['websockets'] = {} app.on_shutdown.append(shutdown) db_pool = await init_db(app) mysql_pool = await setup_mysql(app, loop) mongo_pool = await setup_mongo(app, loop) redis_pool = await setup_redis(app) ws_handler = WsHandler(redis_pool, mongo_pool, mysql_pool) setup_routes(app, ws_handler) setup_session(app, RedisStorage(redis_pool)) # needs to be after session setup because of `current_user_ctx_processor` aiohttp_jinja2.setup( app, loader=jinja2.PackageLoader(PACKAGE_NAME), context_processors=[current_user_ctx_processor], ) setup_security(app, SessionIdentityPolicy(), DBAuthorizationPolicy(db_pool)) return app
async def init(loop): app = web.Application() redis = await create_pool(('localhost', 6379)) setup(app, RedisStorage(redis, cookie_name="testmyid", max_age=3)) app.router.add_route('GET', '/', handler) srv = await loop.create_server(app.make_handler(), '0.0.0.0', 8084) return srv
def __init__(self, type: str = "redis", name: str = "AIOHTTP_SESSION", backends: list = [], **kwargs): async def make_redis_pool(url, **kwargs: dict): kwargs['timeout'] = 1 return await aioredis.create_pool(url, **kwargs) if type == "redis": try: url = kwargs["url"] del kwargs["url"] except KeyError: raise Exception( "Error: For Redis Storage, you need session URL") self._pool = asyncio.get_event_loop().run_until_complete( make_redis_pool(url, **kwargs)) self._session_type = RedisStorage(self._pool, cookie_name=name) elif type == "cookie": try: secret_key = kwargs["secret_key"] except KeyError: fernet_key = fernet.Fernet.generate_key() secret_key = base64.urlsafe_b64decode(fernet_key) self._session_type = EncryptedCookieStorage(secret_key, cookie_name=name) # TODO: type memcached # configure backends for backend in backends: if backend == "hosts": obj = auth_hosts() elif backend == "session": obj = auth_users() self._backends.append(obj)
async def init_app(config): app = web.Application() app['config'] = config setup_routes(app) db_pool = await init_db(app) redis_pool = await setup_redis(app) setup_session(app, RedisStorage(redis_pool)) # needs to be after session setup because of `current_user_ctx_processor` aiohttp_jinja2.setup( app, loader=jinja2.PackageLoader(PACKAGE_NAME), context_processors=[current_user_ctx_processor], ) setup_security(app, SessionIdentityPolicy(), DBAuthorizationPolicy(db_pool)) log.debug(app['config']) return app
async def create_app(): """ Prepare application """ redis_pool = await aioredis.create_pool(settings.REDIS_CON) middlewares = [ session_middleware(RedisStorage(redis_pool)), request_user_middleware ] if settings.DEBUG: middlewares.append(aiohttp_debugtoolbar.middleware) # init application app = web.Application(middlewares=middlewares) app.redis_pool = redis_pool app.ws_list = {} jinja_env = aiohttp_jinja2.setup( app, loader=jinja2.FileSystemLoader(settings.TEMPLATE_DIR), context_processors=[aiohttp_jinja2.request_processor], ) jinja_env.globals.update(tags) if settings.DEBUG: aiohttp_debugtoolbar.setup(app, intercept_redirects=False) # db conn database.init(**settings.DATABASE) app.database = database app.database.set_allow_sync(False) app.objects = peewee_async.Manager(app.database) # make routes from urls import routes for route in routes: app.router.add_route(**route) app.router.add_static('/static', settings.STATIC_DIR, name='static') app.logger = logger return app
def __init__(self, *args, config=None, routes=[], **kwargs): self.logger = logging.getLogger('ampythomine') self.jinja = aiohttp_jinja2 super().__init__(*args, **kwargs) self.jinja.setup(self, loader=jinja2.FileSystemLoader( os.path.abspath(config['TEMPLATE_PATH']))) for route in routes: self.router.add_route(route[0], route[1], route[2]) # Database init db_backend = importlib.import_module(config['DATABASE']['BACKEND']) getattr(db_backend, db_backend.__backend__)().init(config['DATABASE']) # Auth init # TODO: подтягивать бэкэнд для хранения сессий из конфига self.redis_pool = RedisPool(('localhost', 6379), db=0, password=None, ssl=None, encoding=None, minsize=1, maxsize=10, commands_factory=Redis, loop=None) setup_session(self, RedisStorage(self.redis_pool)) auth_backend = importlib.import_module(config['AUTH']['BACKEND']) setup_security(self, IdentityPolicy(), getattr(auth_backend, auth_backend.__auth_policy__)())
def create_app(handler, redis, max_age=None, key_factory=lambda: uuid.uuid4().hex): middleware = session_middleware( RedisStorage(redis, max_age=max_age, key_factory=key_factory)) app = web.Application(middlewares=[middleware]) app.router.add_route('GET', '/', handler) return app
async def init(loop): # Redis redis_opts = (config['redis']['host'], config['redis']['port']) redis_pool = await create_pool(redis_opts) # SQLAlchemy sa_cfg = config['postgres'] dbengine = await create_engine(database=sa_cfg.get('database', 'aiohttp_security'), user=sa_cfg.get('user', 'admin')) app = web.Application() app.db_engine = dbengine # Auth setup_session(app, RedisStorage(redis_pool)) setup_security(app, SessionIdentityPolicy(), DBAuthorizationPolicy(dbengine)) aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader('./templates')) setup_routes(app) setup_middlewares(app) handler = app._make_handler() app_conf = config['app'] srv = await loop.create_server(handler, app_conf['host'], app_conf['port']) print('Server started at http://{}:{}'.format(str(app_conf['host']), str(app_conf['port']))) return srv, app, handler
async def setup_session(app): conf = app["config"]["redis"] redis_address = "redis://" + conf["host"] + ":" + str(conf["port"]) redis_pool = await aioredis.create_redis_pool(redis_address) app["session_pool"] = redis_pool storage = RedisStorage(redis_pool) sessionsetup(app, storage)
def setup(app_config): loop = asyncio.get_event_loop() redis_pool = loop.run_until_complete( make_redis_pool(app_config['REDIS_SERVER'], app_config['REDIS_PORT'])) return session_middleware( RedisStorage(redis_pool, cookie_name='RH_SESSION', max_age=int(app_config['SESSION_AGE'])))
async def _init_app(loop=None): loop = loop or asyncio.get_event_loop() app = web.Application(loop=loop, middlewares=[middleware_404]) aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader('httplib/template')) setup_router(app) redis = await create_pool(('localhost', 6379)) setup(app, RedisStorage(redis, cookie_name="aiosession", max_age=3600)) return app
def redis_connect(app): async def make_redis_pool(): redis_address = (os.getenv('REDIS_HOST', 'redis'), os.getenv('REDIS_PORT', '6379')) return await aioredis.create_redis_pool(redis_address, timeout=1) loop = asyncio.get_event_loop() redis_pool = loop.run_until_complete(make_redis_pool()) storage = RedisStorage(redis_pool) return storage, redis_pool
async def session_middleware(request, handler): """Wrapper to Session Middleware factory. """ # Do the trick, by passing app & handler back to original session # middleware factory. Do not forget to await on results here as original # session middleware factory is also awaitable. app = request.app storage = RedisStorage(app['redis'], httponly=False) middleware = session_middleware_(storage) return await middleware(request, handler)
async def init_app(app): await init_db(app) await init_redis(app) setup_security(app, SessionIdentityPolicy(), DBAuthorizationPolicy(app['db'])) setup_session(app, RedisStorage(app['redis'])) await set_redis_init_values(app)
def run_server(host, port): loop = asyncio.get_event_loop() redis_pool = loop.run_until_complete(create_pool(('localhost', 6379))) client = motor_asyncio.AsyncIOMotorClient('localhost', 27017) # Initiate main application app = web.Application(loop=loop, logger=server_logger) setup_routes(app, 'main') setup_static(app) aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader('templates/')) # Initiate sub-applications admin = web.Application(loop=loop, logger=server_logger) setup_routes(admin, 'admin') aiohttp_jinja2.setup(admin, loader=jinja2.FileSystemLoader('templates/')) setup_session( admin, RedisStorage(redis_pool, max_age=COOKIE_AGE, cookie_name=COOKIE_AUTH_NAME)) setup_security(admin, SessionIdentityPolicy(), DBAuthorizationPolicy()) app.add_subapp('/admin/', admin) api = web.Application(loop=loop, logger=server_logger) setup_routes(api, 'api') app.add_subapp('/api/', api) # Session and security setup_session( app, RedisStorage(redis_pool, max_age=COOKIE_AGE, cookie_name=COOKIE_AUTH_NAME)) setup_security(app, SessionIdentityPolicy(), DBAuthorizationPolicy()) # Run server web.run_app(app=app, host=host, port=port, access_log=access_logger, access_log_format= '%a %l %u %t "%r" %s %b "%{Referrer}i" "%{User-Agent}i"')
async def init_pre(self, app): ''' 启动前的初始化工作 ''' await mysql.initpool(loop=self.loop) await redis.init_pool(loop=self.loop) redis_pool = redis.get_pool() storage = RedisStorage(redis_pool) setup(app, storage) app.middlewares.append(response_factory) #一定要放在session的后面 先执行这个
async def app_init(app): app['client_queues'] = {} app['redis_addr'] = ('localhost', 6379) app['redis'] = await aioredis.create_redis_pool(app['redis_addr'], db=0) sess_storage = RedisStorage( await aioredis.create_redis_pool(app['redis_addr'], db=1), max_age=3600, ) setup_session(app, sess_storage) app['distributer'] = asyncio.create_task(chat_distribute(app))
def setup(app_config): # Monkey patch aiohttp_session.py Session.__init__ method to remove PR 331 as above Session.__init__ = aiohttp_session_pr_331_rollback loop = get_event_loop() redis_pool = loop.run_until_complete( make_redis_pool(app_config['REDIS_SERVER'], app_config['REDIS_PORT'])) return session_middleware( RedisStorage(redis_pool, cookie_name='FSDRUI_SESSION', max_age=int(app_config['SESSION_AGE'])))
def create_app( handler: _Handler, redis: aioredis.commands.Redis, max_age: Optional[int] = None, key_factory: Callable[[], str] = lambda: uuid.uuid4().hex) -> web.Application: middleware = session_middleware( RedisStorage(redis, max_age=max_age, key_factory=key_factory)) app = web.Application(middlewares=[middleware]) app.router.add_route('GET', '/', handler) return app
async def redis(app: web.Application) -> None: config = app["config"]["redis"] app["redis"] = await create_pool((config["host"], config["port"])) setup_session(app, RedisStorage(app["redis"])) # TODO move to init_app yield app["redis"].close() await app["redis"].wait_closed()
def init_app( loop: asyncio.AbstractEventLoop, redis_pool: Optional[aioredis.ConnectionsPool] = None, ) -> web.Application: app = web.Application(loop=loop) app['config'] = settings if not redis_pool: redis_pool = loop.run_until_complete(make_redis_pool()) storage = RedisStorage(redis_pool, cookie_name='sesssionid') setup(app, storage) async def dispose_redis_pool(app: web.Application) -> None: if redis_pool is not None: redis_pool.close() await redis_pool.wait_closed() aiohttp_jinja2.setup( app, loader=jinja2.FileSystemLoader(str(BASE_DIR / 'its_on' / 'templates'), ), ) app['static_root_url'] = '/static' app.on_startup.append(init_pg) app.on_cleanup.append(close_pg) app.on_cleanup.append(dispose_redis_pool) setup_security(app, SessionIdentityPolicy(session_key='sessionkey'), DBAuthorizationPolicy(app)) cors_config = { origin: aiohttp_cors.ResourceOptions(allow_methods=['GET', 'OPTIONS'], allow_headers=settings.CORS_ALLOW_HEADERS) for origin in settings.CORS_ALLOW_ORIGIN } cors = aiohttp_cors.setup(app, defaults=cors_config) setup_routes(app, BASE_DIR, cors) setup_aiohttp_apispec(app=app, title='Flags Bestdoctor', version='v1', url='/api/docs/swagger.json', swagger_path='/api/docs', static_path='/assets/swagger', request_data_name='validated_data') setup_middlewares(app) setup_cache(app) return app
async def init_security(app): redis_pool = await create_pool( (app['config']['redis']['host'], app['config']['redis']['port'])) async def close_redis(app): redis_pool.close() await redis_pool.wait_closed() app.on_cleanup.append(close_redis) setup_session(app, RedisStorage(redis_pool)) setup_security(app, SessionIdentityPolicy(), DBAuthorizationPolicy(app['db']))