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'])