def init_gunicorn():
global mc
middlewares = []
middlewares.append(db_handler())
if settings.debug:
middlewares.append(session_middleware(SimpleCookieStorage()))
else:
middlewares.append(
session_middleware(EncryptedCookieStorage(settings.session_key)))
app = web.Application(middlewares=middlewares)
aiohttp_jinja2.setup(app, loader=jinja2.FunctionLoader(load_templ))
# Memcache init
app.mc = aiomcache.Client(settings.memcache['addr'],
settings.memcache['port'])
# Mongo init
db_connect(app)
union_routes(os.path.join(settings.tao_path, 'libs'))
union_routes(os.path.join(settings.root_path, 'apps'))
union_routes(os.path.join(settings.root_path), p=True)
for res in routes:
name = res[3]
if name is None: name = '{}:{}'.format(res[0], res[2])
app.router.add_route(res[0], res[1], res[2], name=name)
path = os.path.join(settings.root_path, 'static')
app.router.add_static('/static/', path, name='static')
return app
async def init(address, port, services, users):
context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
context.load_cert_chain(SSL_CERT_FILE, SSL_KEY_FILE)
mw = [
session_middleware(SimpleCookieStorage()),
normalize_path_middleware()
]
app = web.Application(middlewares=mw)
app.on_startup.append(background_tasks)
app.router.add_route('POST', '/file/render',
services.get('file_svc').render)
app.router.add_route('POST', '/file/download',
services.get('file_svc').download)
app.router.add_route('POST', '/file/upload',
services.get('file_svc').upload)
await services.get('data_svc').reload_database()
for user, pwd in users.items():
await services.get('auth_svc').register(username=user, password=pwd)
logging.debug('...Created user: %s:%s' % (user, pwd))
await attach_plugins(app, services)
runner = web.AppRunner(app)
await runner.setup()
await web.TCPSite(runner, address, port, ssl_context=context).start()
def init_app():
middleware = session_middleware(SimpleCookieStorage())
app = web.Application(middlewares=[middleware])
# create a global dict of identity -> (folder object, active ws connections)
cache = {}
app['folders'] = cache
app.on_startup.append(model.startup)
app.on_shutdown.append(shutdown)
policy = aiohttp_security.SessionIdentityPolicy()
aiohttp_security.setup(app, policy, SimpleAuthorizationPolicy(cache))
app.add_routes([
web.get('/ws', ws),
web.post('/signup', signup),
web.post('/login', login),
web.post('/logout', logout),
web.get('/auth', allow),
web.post('/files', upload),
web.get('/files', download),
# below are static files that should be served by NGINX
web.get(
'/', index,
name='index'), # static does not support redirect / to /index.html
web.get('/index.html', index), # serve a single static file with auth
web.static('/', os.path.join(dir_path, 'static'), name='static')
]) # handle static files such as html, js, css
return app
async def make_app():
#
# WARNING!!!
# Never use SimpleCookieStorage on production!!!
# It’s highly insecure!!!
#
# make app
middleware = session_middleware(SimpleCookieStorage())
app = web.Application(middlewares=[middleware])
# add the routes
app.add_routes([
web.get('/', handler_root),
web.get('/login', handler_login_jack),
web.get('/logout', handler_logout),
web.get('/listen', handler_listen),
web.get('/speak', handler_speak)
])
# set up policies
policy = SessionIdentityPolicy()
setup_security(app, policy, SimpleJack_AuthorizationPolicy())
for resource in app.router.resources():
print(resource)
return app
def app_factory() -> web.Application:
app = web.Application()
jinja2_setup(app,
loader=jinja2.FileSystemLoader(
[Path(__file__).parent / "templates"]))
session_setup(app, SimpleCookieStorage())
app.add_subapp(
"/auth/dataporten/",
dataporten(
FEIDE_CLIENT_ID,
FEIDE_CLIENT_SECRET,
on_login=on_dataporten_login,
scopes=[
'profile', 'userid', 'openid', 'groups', 'peoplesearch',
'email', 'userid-feide'
],
json_data=False,
),
)
app.add_routes([web.get("/", index), web.get("/auth/logout", logout)])
return app
async def test_bad_response_type(test_client):
async def bad_response(request):
return ''
middleware = session_middleware(SimpleCookieStorage())
req = make_mocked_request('GET', '/')
with pytest.raises(RuntimeError):
await middleware(req, bad_response)
def create_app():
app = web.Application()
app.router.add_get('/', index)
app.router.add_post('/start-job/', start_job)
app['downloader'] = Downloader(redis_settings=redis_settings)
app.on_shutdown.append(shutdown)
session_setup(app, SimpleCookieStorage())
return app
async def test_middleware_installed_no_session(self):
middlewares = [
session_middleware(SimpleCookieStorage()),
auth_middleware(auth.SessionTktAuthentication(urandom(16), 15))
]
request = await make_request('GET', '/', middlewares)
user_id = await auth.get_auth(request)
self.assertIsNone(user_id)
async def test_no_middleware_installed(self):
middlewares = [
session_middleware(SimpleCookieStorage()),
]
request = await make_request('GET', '/', middlewares)
with self.assertRaises(RuntimeError):
await auth.get_auth(request)
async def test_prepared_response_type(aiohttp_client: _TAiohttpClient) -> None:
async def prepared_response(request: web.Request) -> web.StreamResponse:
resp = web.Response()
await resp.prepare(request)
return resp
middleware = session_middleware(SimpleCookieStorage())
req = make_mocked_request('GET', '/')
with pytest.raises(RuntimeError):
await middleware(req, prepared_response)
async def test_prepared_response_type(test_client):
async def prepared_response(request):
resp = web.Response()
await resp.prepare(request)
return resp
middleware = session_middleware(SimpleCookieStorage())
req = make_mocked_request('GET', '/')
with pytest.raises(RuntimeError):
await middleware(req, prepared_response)
async def test_bad_response_type(aiohttp_client: _TAiohttpClient) -> None:
# Ignoring typing since return type is on purpose wrong
@no_type_check
async def bad_response(request: web.Request) -> str:
return ''
middleware = session_middleware(SimpleCookieStorage())
req = make_mocked_request('GET', '/')
with pytest.raises(RuntimeError):
await middleware(req, bad_response)
def test_prepared_response_type(test_client):
@asyncio.coroutine
def prepared_response(request):
resp = web.Response()
yield from resp.prepare(request)
return resp
middleware = session_middleware(SimpleCookieStorage())
req = make_mocked_request('GET', '/')
with pytest.raises(RuntimeError):
yield from middleware(req, prepared_response)
def create_app(loop, handler, path=None, domain=None):
middleware = session_middleware(
SimpleCookieStorage(
max_age=10,
path="/anotherpath",
domain="127.0.0.1",
))
app = web.Application(middlewares=[middleware], loop=loop)
app.router.add_route('GET', '/', handler)
app.router.add_route('GET', '/anotherpath', handler)
return app
async def test_middleware_stores_auth_in_session(self):
secret = b'01234567890abcdef'
storage = SimpleCookieStorage()
auth_ = auth.SessionTktAuthentication(secret, 15, cookie_name='auth')
middlewares = [session_middleware(storage), auth_middleware(auth_)]
request = await make_request('GET', '/', middlewares)
await auth.remember(request, 'some_user')
response = await make_response(request, middlewares)
self.assertTrue(auth_.cookie_name in \
response.cookies.get(storage.cookie_name).value)
def create_server(self, method, path, handler):
middleware = session_middleware(SimpleCookieStorage())
app = web.Application(middlewares=[middleware], loop=self.loop)
app.router.add_route(method, path, handler)
port = self.find_unused_port()
handler = app.make_handler()
srv = yield from self.loop.create_server(handler, '127.0.0.1', port)
url = "http://127.0.0.1:{}".format(port) + path
self.handler = handler
self.srv = srv
return app, srv, url
def setup_sessions(self):
"""Add handlers for handling sessions and flash messages."""
if self.conf['debug']:
cookie_storage = SimpleCookieStorage()
else: # pragma: no cover
secret_key = base64.urlsafe_b64decode(
self.conf['session_key'].encode('utf-8'))
cookie_storage = EncryptedCookieStorage(secret_key)
self.middlewares.append(
aiohttp_session.session_middleware(cookie_storage))
self.middlewares.append(aiohttp_session_flash.middleware)
def __init__(self, loop: asyncio.AbstractEventLoop, adapter,
bluetooth_devices: BluetoothDeviceRegistry,
hid_devices: HIDDeviceRegistry):
self.loop = loop
self.adapter = adapter
self.adapter.set_on_agent_action_handler(self.on_agent_action)
self.adapter.set_on_interface_changed_handler(
self.on_adapter_interface_changed)
self.hid_devices = hid_devices
self.hid_devices.set_on_devices_changed_handler(
self.on_hid_devices_change)
self.bluetooth_devices = bluetooth_devices
self.bluetooth_devices.set_on_devices_changed_handler(
self.on_bluetooth_devices_change)
middleware = session_middleware(SimpleCookieStorage())
self.app = web.Application(middlewares=[middleware])
self.app.router.add_route('*', '/', self.root_handler)
self.app.router.add_route('POST', '/changepassword',
self.change_password_handler)
self.app.router.add_route('POST', '/login', self.handler_login)
self.app.router.add_route('GET', '/authorised',
self.handler_is_authorised)
self.app.router.add_route('POST', '/setdevicecapture',
self.set_device_capture)
self.app.router.add_route('POST', '/setdevicefilter',
self.set_device_filter)
self.app.router.add_route('POST', '/setcompatibilitydevice',
self.set_compatibility_device)
self.app.router.add_route('POST', '/startscanning',
self.start_scanning)
self.app.router.add_route('POST', '/stopscanning', self.stop_scanning)
self.app.router.add_route('POST', '/startdiscoverable',
self.start_discoverable)
self.app.router.add_route('POST', '/stopdiscoverable',
self.stop_discoverable)
self.app.router.add_route('GET', '/hiddevices',
self.get_hid_devices_handler)
self.app.router.add_route('GET', '/bluetoothdevices',
self.get_bluetooth_devices)
self.app.router.add_routes([web.get('/ws', self.websocket_handler)])
self.app.router.add_static(
'/', "web/") # add_routes([web.get('/', self.hello)])
policy = SessionIdentityPolicy()
setup_security(self.app, policy, PiAuthorizationPolicy())
self.runner = None
self.site = None
self.ws = []
self.executor = concurrent.futures.ThreadPoolExecutor(max_workers=3)
#web.run_app(self.app)
asyncio.run_coroutine_threadsafe(self.start_server(), loop=self.loop)
def create_app(handler: _Handler,
path: Optional[str] = None,
domain: Optional[str] = None) -> web.Application:
middleware = session_middleware(
SimpleCookieStorage(
max_age=10,
path="/anotherpath",
domain="127.0.0.1",
))
app = web.Application(middlewares=[middleware])
app.router.add_route('GET', '/', handler)
app.router.add_route('GET', '/anotherpath', handler)
return app
async def test_middleware_gets_auth_from_session(self):
secret = b'01234567890abcdef'
storage = SimpleCookieStorage()
auth_ = auth.SessionTktAuthentication(secret, 15, cookie_name='auth')
middlewares = [session_middleware(storage), auth_middleware(auth_)]
session_data = make_auth_session(secret, 'some_user',
auth_.cookie_name)
request = await make_request('GET', '/', middlewares, \
[(storage.cookie_name, json.dumps(session_data))])
user_id = await auth.get_auth(request)
self.assertEqual(user_id, 'some_user')
async def init(address, port, services, users):
context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
context.load_cert_chain(SSL_CERT_FILE, SSL_KEY_FILE)
mw = [session_middleware(SimpleCookieStorage()), normalize_path_middleware()]
app = web.Application(middlewares=mw)
app.on_startup.append(background_tasks)
await data_svc.reload_database()
for user, pwd in users.items():
await auth_svc.register(username=user, password=pwd)
await attach_plugins(app, services)
runner = web.AppRunner(app)
await runner.setup()
await web.TCPSite(runner, address, port, ssl_context=context).start()
async def entrance():
await db.create_tables()
app.add_routes([
web.get('/task3', index),
web.get('/task3/', index),
web.post('/task3/', form),
web.get('/task3/login', login),
web.post('/task3/login', auth),
web.get('/task3/logout', logout),
web.get('/task3/set_form/{id}', set_form),
web.get('/task3/admin', admin_page),
web.get('/task3/del_form/{id}', delete_form)
])
setup(app, SimpleCookieStorage())
return app
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
async def make_app(db_url: str):
"""
Фабрика для создания приложения
"""
engine = sqlalchemy.create_engine(db_url,
echo=False,
pool_size=10,
max_overflow=0)
logger.info(
"Создается новый экземпляр приложения. Настройки подключения к бд: %s",
str(engine))
storage.database.ScopedAppSession.configure(bind=engine)
app = Application(dialogs_queues=queues.DictRepository())
setup(app, SimpleCookieStorage())
app.add_routes(routes)
return app
def application(loop=None):
middlewares = [
minify_middleware,
error_middleware,
flash_middleware,
]
if getattr(config, 'test', None):
storage = SimpleCookieStorage()
else:
storage = EncryptedCookieStorage(config.session_key)
middlewares.append(session_middleware(storage))
app = web.Application(loop=loop,
middlewares=middlewares,
debug=config.debug)
app.mcache = aiomcache.Client(*config.memcache['server'], loop=loop)
if config.debug:
import aiohttp_debugtoolbar
aiohttp_debugtoolbar.setup(app, intercept_redirects=False)
app.config = config
engine.setup(
app,
context_processors=[context_processor, engine.request_processor],
loader=jinja2.FileSystemLoader('./template'))
app.router \
.add_resource('/', name='home') \
.add_route('GET', home)
app.router \
.add_resource('/contact', name='contact') \
.add_route('POST', contact)
app.router \
.add_resource('/callback', name='callback') \
.add_route('POST', callback)
app.router \
.add_resource('/ws', name='chat') \
.add_route('GET', ws)
app.router.add_route('GET', '/wsh', ws_handler)
return app
def app_factory() -> web.Application:
app = web.Application()
jinja2_setup(
app, loader=jinja2.FileSystemLoader([Path(__file__).parent / "templates"])
)
session_setup(app, SimpleCookieStorage())
app.add_subapp(
"/auth/github/",
github(
"a1b8c7904865ac38baba",
"147d82d8ded7a74899fcc4da2b61f8d305bf81c5",
on_login=on_github_login,
),
)
app.add_routes([web.get("/", index), web.get("/auth/logout", logout)])
return app
def go(loop, policy, storage):
async def handler_get(request):
token = await aiohttp_csrf.generate_token(request)
body = '''
<html>
<head></head>
<body>
<form>
<input type="hidden" name="{field_name}" value="{token}" />
</form>
</body>
</html>
''' # noqa
body = body.format(field_name=FORM_FIELD_NAME, token=token)
return web.Response(body=body.encode('utf-8'))
async def handler_post(request):
return web.Response(body=b'OK')
handlers = [
('GET', '/', handler_get),
('POST', '/', handler_post)
]
app = init_app(
policy=policy,
storage=storage,
handlers=handlers,
loop=loop,
)
if isinstance(storage, aiohttp_csrf.storage.SessionStorage):
session_storage = SimpleCookieStorage()
setup_session(app, session_storage)
app.middlewares.append(aiohttp_csrf.csrf_middleware)
return app
async def init(loop):
conf = load_config(str(PROJ_ROOT / 'config' / 'config.yml'))
app = web.Application(loop=loop)
cookie_storage = SimpleCookieStorage()
app = web.Application(middlewares=[session_middleware(cookie_storage)])
mongo = await setup_mongo(app, conf, loop)
setup_jinja(app)
admin_config = str(PROJ_ROOT / 'static' / 'js')
setup_admin(app, mongo, admin_config)
app.router.add_static('/static', path=str(PROJ_ROOT / 'static'))
# setup views and routes
handler = SiteHandler(mongo)
setup_routes(app, handler, PROJ_ROOT)
host, port = conf['host'], conf['port']
return app, host, port
async def main(loop):
app = web.Application(middlewares=[server_redirect])
app['loop'] = loop
await init(app)
app['emailcode'] = {}
app.on_startup.append(start_background_tasks)
# fernet_key = fernet.Fernet.generate_key()
# secret_key = base64.urlsafe_b64decode(fernet_key)
# setup(app, EncryptedCookieStorage(secret_key))
setup(app, SimpleCookieStorage())
# app.on_cleanup.append(cleanup_background_tasks)
aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader('./views'))
routes.static('/s', './public', append_version=True)
app.add_routes(routes)
runner = web.AppRunner(app)
await runner.setup()
site = web.TCPSite(runner, 'localhost', app['port'])
await site.start()
await asyncio.sleep(99999999999)
def run():
application = Application()
application.router.add_routes(routes)
aiohttp_jinja2.setup(application, loader=FileSystemLoader(f"{APPLICATION_DIR}/static"))
aiohttp_session.setup(application, SimpleCookieStorage())
aiohttp_security.setup(application, SessionIdentityPolicy(), DatabaseAuthorizationPolicy())
# do load file configuraion
configuration.load()
# do load database configuraion
dictionary.database.set_configuration(
host=configuration['database']['host'],
port=configuration['database']['port'],
name=configuration['database']['name'],
user=configuration['database']['user'],
password=configuration['database']['password']
)
return run_app(application, host='0.0.0.0', port=configuration['application']['business']['listen'])
