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 start_webserver(self): app = web.Application() app.on_shutdown.append(self._on_shutdown) # настройка авторизации app.user_map = user_map fernet_key = fernet.Fernet.generate_key() secret_key = base64.urlsafe_b64decode(fernet_key) storage = EncryptedCookieStorage(secret_key, cookie_name='API_SESSION') setup_session(app, storage) policy = SessionIdentityPolicy() setup_security(app, policy, DictionaryAuthorizationPolicy(user_map)) # настройка маршрутов app.router.add_get("/", WebServer._index) app.router.add_get("/logo.svg", WebServer._logo) app.router.add_get("/client.js", WebServer._javascript) app.router.add_get("/login.html", WebServer._login_form) app.router.add_post("/login", WebServer._login) app.router.add_get("/logout", WebServer._logout) app.router.add_post("/offer", self._offer) app.router.add_get("/download/{name}", WebServer._download_file) aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader(os.path.dirname(__file__))) # запуск веб-сервера runner = web.AppRunner(app) await runner.setup() self._server = web.TCPSite(runner, host="0.0.0.0", port=8080, ssl_context=self._ssl_context) await self._server.start()
async def init_app() -> web.Application: """Initialize the async web application Returns ------- web.Application An instance of the aiohttp web app using the default loop. """ app = web.Application() aiohttp_jinja2.setup( app, loader=jinja2.PackageLoader("mach_prerelease", "views/templates"), ) fernet_key = fernet.Fernet.generate_key() secret_key = base64.urlsafe_b64decode(fernet_key) setup_session(app, EncryptedCookieStorage(secret_key)) app.router.add_get("/", IndexView.get) app.router.add_get("/static/styles", StaticFileHandler.get_styles) app.router.add_get("/static/scripts", StaticFileHandler.get_scripts) app.router.add_get("/static/assets", StaticFileHandler.get_assets) app.router.add_get("/static/favicon.ico", StaticFileHandler.get_favicon) app.router.add_post("/", IndexView.post) return app
async def init_app(argv=None): app = web.Application() app['config'] = get_config(argv) # secret_key must be 32 url-safe base64-encoded bytes fernet_key = fernet.Fernet.generate_key() secret_key = base64.urlsafe_b64decode(fernet_key) storage = EncryptedCookieStorage(secret_key, cookie_name='API_SESSION') setup_session(app, storage) policy = SessionIdentityPolicy() setup_security(app, policy, DbAuthorizationPolicy(app)) # setup Jinja2 template renderer aiohttp_jinja2.setup(app, loader=jinja2.PackageLoader('aiohttp_polls', 'templates')) # create db connection on startup, shutdown on exit app.on_startup.append(init_pg) app.on_cleanup.append(close_pg) # setup views and routes setup_routes(app) return app
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(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 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(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 init_app(argv=None): app = web.Application() app['config'] = get_config(argv) # create db connection on startup, close on exit # app.on_startup.append(init_pg) db_pool = await init_pg(app) app.on_cleanup.append(close_pg) fernet_key = fernet.Fernet.generate_key() secret_key = base64.urlsafe_b64decode(fernet_key) setup_session(app, EncryptedCookieStorage(secret_key)) aiohttp_jinja2.setup( app, loader=jinja2.PackageLoader(PACKAGE_NAME), context_processors=[current_user_ctx_processor], ) setup_security(app, SessionIdentityPolicy(), DBAuthorizationPolicy(db_pool)) # setup views and routes setup_routes(app) 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 setup_space(self): await super().setup(self) # Make the staging directory await mkdir(self.staging_dir) setup_session( self, EncryptedCookieStorage(secret_key=self.secret_key.encode(), cookie_name='PYVOSPACE_COOKIE', domain=self.domain)) self.authentication = DBUserAuthentication(self['space_name'], self['db_pool']) setup_security( self, SessionIdentityPolicy(), DBUserNodeAuthorizationPolicy(self['space_name'], self['db_pool'], self.ngas_hostname, self.ngas_port, self.ngas_session)) self.router.add_route('POST', '/login', self.authentication.login, name='login') self.router.add_route('POST', '/logout', self.authentication.logout, name='logout')
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__)())
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 _setup(app): # Setup session storage. fernet_key = fernet.Fernet.generate_key() secret_key = base64.urlsafe_b64decode(fernet_key) setup_session(app, EncryptedCookieStorage(secret_key)) setup_security(app, SessionIdentityPolicy(), DBAuthorizationPolicy(app['storage']))
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)
async def apply(self, app, users): for k, v in users.items(): self.user_map[k] = self.User(k, v, ('admin', 'user'),) app.user_map = self.user_map fernet_key = fernet.Fernet.generate_key() secret_key = base64.urlsafe_b64decode(fernet_key) storage = EncryptedCookieStorage(secret_key, cookie_name='API_SESSION') setup_session(app, storage) policy = SessionIdentityPolicy() setup_security(app, policy, DictionaryAuthorizationPolicy(self.user_map))
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 configure_session(self, app): """Cookie Session Configuration.""" print(self.secret_key, self.session_name) setup_session( app, EncryptedCookieStorage(self.secret_key, cookie_name=self.session_name, max_age=SESSION_TIMEOUT # domain=DOMAIN, ))
async def make_app(): app = web.Application() sio.attach(app) setup_session(app, EncryptedCookieStorage(secret_key)) aiohttp_jinja2.setup( app, loader=jinja2.FileSystemLoader('./templates')) app.router.add_static('/static', 'static') app.add_routes( [web.get('/', index), web.get('/another', another_page)]) 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()
async def init_db(app): setup_logger() app["db"] = db = motorio.AsyncIOMotorClient( app["config"]["mongo"].url, appname="sonata", io_loop=asyncio.get_event_loop())[app["config"]["mongo"].database] app["logger"].info("Mongo connected.") app.on_cleanup.append(close_mongo) session_collection = db.sessions setup_session(app, MongoStorage(session_collection, max_age=3600 * 24 * 30)) setup_security(app, SessionIdentityPolicy(), DBAuthorizationPolicy(db))
def setup_app(): app = web.Application(middlewares=setup_middlewares()) app.cleanup_ctx.append(db_engine) secret_key = base64.urlsafe_b64decode(SECRET) setup_session(app, EncryptedCookieStorage(secret_key)) setup_security( app, SessionIdentityPolicy(), AuthorizationPolicy(app), ) setup_routes(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']))
def configure(self, app: web.Application) -> web.Application: # configure session: setup_session(app, self._session_type) router = app.router router.add_route("GET", "/login", self.login_page, name="index_login") router.add_route("POST", "/login", self.login, name="login") router.add_route("GET", "/logout", self.logout, name="logout") router.add_route("GET", "/public", self.internal_page, name="public") router.add_route("GET", "/protected", self.protected_page, name="protected") return app
async def apply(self, app, users): if users: for group, user in users.items(): self.log.debug('Created authentication group: %s' % group) for username, password in user.items(): await self.create_user(username, password, group) app.user_map = self.user_map fernet_key = fernet.Fernet.generate_key() secret_key = base64.urlsafe_b64decode(fernet_key) storage = EncryptedCookieStorage(secret_key, cookie_name='API_SESSION') setup_session(app, storage) policy = SessionIdentityPolicy() setup_security(app, policy, DictionaryAuthorizationPolicy(self.user_map))
async def _make_mcache(): _encoder = partial(rapidjson.dumps, datetime_mode=rapidjson.DM_ISO8601) try: self._pool = await self.get_mcache() setup_session( app, MemcachedStorage(self._pool, cookie_name=self.session_name, encoder=_encoder, decoder=rapidjson.loads, max_age=int(SESSION_TIMEOUT))) except Exception as err: print(err) return False
async def get_application(self): async def index(request): csrf_token = await generate_csrf_token(request) if request.method in CSRF_METHODS: await validate_csrf_token(request) return web.Response() return web.Response(text=csrf_token) app = web.Application() setup_session(app, SimpleCookieStorage()) setup_csrf(app) app.router.add_get('/', index) for method in CSRF_METHODS: app.router.add_route(method, '/', index) return app
def main(): app = web.Application() app.router.add_route('GET', "/", example_basic_login) app.router.add_route('GET', "/admin/view", example_group_with_role) app.router.add_route('GET', "/admin", example_group) app.router.add_route('GET', "/login", login) setup_session(app, EncryptedCookieStorage(b'Thirty two length bytes key.', cookie_name="JSESSION_ID")) # setup auth setup_auth(app) web.run_app(app, host="127.0.0.1")
def setup_routes(app): """Setup routes and session handlers""" # we could use `secret` module here but that requires Python 3.6+ key = base64.urlsafe_b64decode(Fernet.generate_key()) setup_session(app, EncryptedCookieStorage(key)) setup_security(app, SessionIdentityPolicy(), PakreqAuth(app)) app.router.add_get('/', index) app.router.add_get('/detail/{ids:([0-9]*)}', detail) app.router.add_get('/requests', requests_all) app.router.add_get('/request/{ids:([0-9]*)}', request_detail) app.router.add_get('/login', login) app.router.add_post('/login', auth) app.router.add_get('/account', account) app.router.add_get('/logout', logout) setup_static_routes(app)
def make_app(): app = web.Application() app.user_map = user_map configure_handlers(app) # secret_key must be 32 url-safe base64-encoded bytes fernet_key = fernet.Fernet.generate_key() secret_key = base64.urlsafe_b64decode(fernet_key) storage = EncryptedCookieStorage(secret_key, cookie_name='API_SESSION') setup_session(app, storage) policy = SessionIdentityPolicy() setup_security(app, policy, DictionaryAuthorizationPolicy(user_map)) return app
async def setup(self): await super().setup() await mkdir(self.root_dir) await mkdir(self.staging_dir) setup_session( self, EncryptedCookieStorage(secret_key=self.secret_key.encode(), cookie_name='PYVOSPACE_COOKIE', domain=self.domain)) setup_security( self, SessionIdentityPolicy(), DBUserNodeAuthorizationPolicy(self.name, self.db_pool, self.root_dir))
def init(loop): redis_pool = yield from create_pool(('localhost', 6379)) dbengine = yield from create_engine(user='******', password='******', database='aiohttp_security', host='127.0.0.1') app = web.Application(loop=loop) setup_session(app, RedisStorage(redis_pool)) setup_security(app, SessionIdentityPolicy(), DBAuthorizationPolicy(dbengine)) web_handlers = Web() yield from web_handlers.configure(app) handler = app.make_handler() srv = yield from loop.create_server(handler, '127.0.0.1', 8080) print("Server started at http://127.0.0.1:8080") return srv, app, handler
async def init(loop): redis_pool = await create_pool(('localhost', 6379)) db_engine = await create_engine(user=settings.DB_USER, password=settings.DB_PASSWORD, database=settings.DATABASE, host=settings.DB_HOST) app = web.Application(loop=loop) app['engine'] = db_engine setup_debugtoolbar(app) setup_session(app, RedisStorage(redis_pool)) setup_security(app, SessionIdentityPolicy(), DBAuthorizationPolicy(db_engine)) setup_jinja2(app, loader=jinja2.FileSystemLoader('demo/templates')) auth_handlers = AuthHandlers() auth_handlers.configure(app) if settings.DEBUG: app.router.add_static('/static', path=str(PROJ_ROOT / 'static')) view_handlers = ViewsHandlers() view_handlers.configure(app) admin_config = str(PROJ_ROOT / 'static' / 'js') setup_admin(app, db_engine, admin_config) return app
def maker(*args, **kwargs): app, client = yield from create_app_and_client(*args, **kwargs) setup_session(app, SimpleCookieStorage()) setup_security(app, SessionIdentityPolicy(), Autz()) return app, client
analysisHandler = AnalysisHandler() sampleHandler = SampleHandler() phenoHandler = PhenotypeHandler() searchHandler = SearchHandler() panelHandler = PanelHandler() adminHandler = AdminHandler() # Create a auth ticket mechanism that expires after SESSION_MAX_DURATION seconds (default is 86400s = 24h), and has a randomly generated secret. # Also includes the optional inclusion of the users IP address in the hash key = base64.b64encode(PRIVATE_KEY32.encode()).decode() # Create server app app = web.Application() setup_session(app, EncryptedCookieStorage(key, max_age=SESSION_MAX_DURATION, cookie_name="regovar_session")) setup_security(app, SessionIdentityPolicy(session_key='regovar_session_token'), RegovarAuthorizationPolicy()) app['websockets'] = [] aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader(TEMPLATE_DIR)) # On shutdown, close all websockets app.on_shutdown.append(on_shutdown) # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # ROUTES # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
def make_app(loop): app = web.Application(loop=loop) setup_session(app, SimpleCookieStorage()) setup_security(app, SessionIdentityPolicy(), Autz()) return app