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
