def app(self): async def handle_root(request): # pylint: disable=W0613, unused-argument return web.Response(text="root") async def handle_clear(request): response = web.Response(text="clear") await schedule_close_all_session_ws(request, response) return response async def handle_websocket(request): async with session_ws(request) as wsr: # pylint: disable=W0613, unused-argument async for msg in wsr: await wsr.send_str(msg.data) return wsr app = web.Application(middlewares=[ aiohttp_session.session_middleware( aiohttp_session.SimpleCookieStorage(cookie_name=COOKIE_NAME)), session_ws_middleware, ]) app.router.add_get("/", handle_root) app.router.add_get("/clear", handle_clear) app.router.add_get("/ws", handle_websocket) setup_session_ws(app, SessionWSRegistry()) return app
def app(loop): """Default app fixture for tests.""" async def handler_remember(request): user_identity = request.match_info['user'] await auth.remember(request, user_identity) return web.Response(text='remember') @autz_required('admin') async def handler_admin(request): return web.Response(text='admin') @autz_required('guest') async def handler_guest(request): return web.Response(text='guest') application = web.Application(loop=loop) secret = b'01234567890abcdef' storage = aiohttp_session.SimpleCookieStorage() policy = auth.SessionTktAuthentication(secret, 15, cookie_name='auth') aiohttp_session.setup(application, storage) auth.setup(application, policy) autz_policy = CustomAutzPolicy(admin_user_identity='alex') autz.setup(application, autz_policy) application.router.add_get('/remember/{user}', handler_remember) application.router.add_get('/admin', handler_admin) application.router.add_get('/guest', handler_guest) yield application
def make_app(): app = web.Application(middlewares=[ aiohttp_session.session_middleware( aiohttp_session.SimpleCookieStorage()), session_ws_middleware, ]) app.router.add_get("/", handle_root) app.router.add_get("/reset", handle_reset) app.router.add_get("/ws", handle_websocket) setup_session_websockets(app, SessionWSRegistry()) return app
async def init_app() -> web.Application: app = web.Application() app.add_routes(router) app.cleanup_ctx.append(init_db) aiohttp_session.setup(app, aiohttp_session.SimpleCookieStorage()) aiohttp_jinja2.setup( app, loader=jinja2.FileSystemLoader(str(Path.cwd() / "templates")), context_processors=[username_ctx_processor], ) app.middlewares.append(error_middleware) app.middlewares.append(check_login) return app
async def test_middleware_installed_no_session(app, client): async def handler_test(request): user_id = await auth.get_auth(request) assert user_id is None return web.Response(text='test') app.router.add_get('/test', handler_test) aiohttp_session.setup(app, aiohttp_session.SimpleCookieStorage()) auth.setup(app, auth.SessionTktAuthentication(urandom(16), 15)) cli = await client(app) await assert_response(cli.get('/test'), 'test')
async def test_middleware_gets_auth_from_session(app, client): secret = b'01234567890abcdef' storage = aiohttp_session.SimpleCookieStorage() policy = auth.SessionTktAuthentication(secret, 15, cookie_name='auth') aiohttp_session.setup(app, storage) auth.setup(app, policy) cli = await client(app) response = await cli.get('/remember') assert await response.text() == 'remember' await assert_response(cli.get('/auth'), 'auth')
async def test_middleware_stores_auth_in_session(app, client): secret = b'01234567890abcdef' storage = aiohttp_session.SimpleCookieStorage() policy = auth.SessionTktAuthentication(secret, 15, cookie_name='auth') aiohttp_session.setup(app, storage) auth.setup(app, policy) cli = await client(app) response = await cli.get('/remember') text = await response.text() assert text == 'remember' value = response.cookies.get(storage.cookie_name).value assert policy.cookie_name in value
async def client(aiohttp_client): app = web.Application() aiohttp_session.setup(app, aiohttp_session.SimpleCookieStorage()) token_auth = TokenAuthenticator() Server( token_auth=token_auth, username_password_auth=UsernamePasswordAuthenticator( (EntityId(str(n)) for n in range(int(1e9))).__next__, token_auth, ), marketplace=Marketplace(), petname_registry=PetnameRegistry(), resources=Resources(app.router), ).add_handlers() yield await aiohttp_client(app)
async def init_app(db_path: Path) -> web.Application: app = web.Application(client_max_size=64 * 1024**2) app["DB_PATH"] = db_path app.add_routes(router) app.cleanup_ctx.append(init_db) aiohttp_session.setup(app, aiohttp_session.SimpleCookieStorage()) aiohttp_jinja2.setup( app, loader=jinja2.FileSystemLoader(str( Path(__file__).parent / "templates")), context_processors=[username_ctx_processor], ) app.middlewares.append(error_middleware) app.middlewares.append(check_login) return app
def app(self): async def handle_websocket(request): async with session_ws(request) as wsr: session_ws_id = await get_session_ws_id(request) async for msg in wsr: # pylint: disable=W0612, unused-variable await wsr.send_str(str(session_ws_id)) return wsr app = web.Application(middlewares=[ aiohttp_session.session_middleware( aiohttp_session.SimpleCookieStorage(cookie_name=COOKIE_NAME)) ]) app.router.add_get("/ws", handle_websocket) setup_session_ws(app, SessionWSRegistry()) return app
def get_app(): app = Application(middlewares=middlewares) app.on_shutdown.append(on_shutdown) app.client = AsyncIOMotorClient(MONGO_IP, MONGO_PORT) app.rooms = [] aiohttp_session.setup(app, aiohttp_session.SimpleCookieStorage()) aiohttp_jinja2.setup(app, loader=FileSystemLoader(TEMPLATES_DIR), context_processors=[static_processor]) for route in routes: app.router.add_route(*route[1:], name=route[0]) app.router.add_static('/static', 'static', name='static') return app
def create_app(): @login_required async def index(request): return web.Response(body=b'OK') async def login(request): return web.Response(body=b'OK') app = web.Application() app.router.add_route(method='GET', path='/', handler=index, name='index') app.router.add_route(method='GET', path='/login', handler=login, name='login') aiohttp_session.setup(app, aiohttp_session.SimpleCookieStorage()) return app
def app(loop): """Default app fixture for tests.""" async def handler_remember(request): await auth.remember(request, 'some_user') return web.Response(text='remember') application = web.Application(loop=loop) secret = b'01234567890abcdef' storage = aiohttp_session.SimpleCookieStorage() policy = auth.SessionTktAuthentication(secret, 15, cookie_name='auth') aiohttp_session.setup(application, storage) auth.setup(application, policy) application.router.add_get('/remember', handler_remember) yield application
async def start(self): """Start aiohttp web server.""" self.app = web.Application() aiohttp_jinja2.setup( self.app, loader=jinja2.PackageLoader('aiohttp_server', 'templates'), # enable_async=False, auto_reload=False) aiohttp_session.setup(self.app, aiohttp_session.SimpleCookieStorage()) self.add_routes() self.handler = self.app.make_handler() self.f = self.loop.create_server(self.handler, host='0.0.0.0', port=self.port) # Event loop is already running, so we await create server instead # of run_until_complete self.srv = await self.f
async def test_middleware_forget_with_session(app, client): secret = b'01234567890abcdef' storage = aiohttp_session.SimpleCookieStorage() policy = auth.SessionTktAuthentication(secret, 15, cookie_name='auth') aiohttp_session.setup(app, storage) auth.setup(app, policy) cli = await client(app) response = await assert_response(cli.get('/remember'), 'remember') value = response.cookies.get(storage.cookie_name).value assert policy.cookie_name in value response = await assert_response(cli.get('/forget'), 'forget') value = response.cookies.get(storage.cookie_name).value assert policy.cookie_name not in value with pytest.raises(AssertionError): await assert_response(cli.get('/auth'), 'auth')
def main(host_ip, port, upload_dir): print(aiohttp.__version__) # make uvloop the default loop in asyncio asyncio.set_event_loop_policy(uvloop.EventLoopPolicy()) app = web.Application() app.on_startup.append(start_background_tasks) app.on_cleanup.append(clean_background_tasks) # location of static files root_path = os.path.dirname(sys.modules['__main__'].__file__) # jinja2 template engine setup aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader( os.path.join(root_path, 'templates'))) # create if needed an upload dir if not os.path.exists(upload_dir): os.makedirs(upload_dir) app["upload_dir"] = upload_dir process_pool_executor = concurrent.futures.ProcessPoolExecutor( max_workers=3, ) app["process_pool_executor"] = process_pool_executor static_dir = os.path.join(root_path, 'static') setup_routes(app, upload_dir, static_dir) # secret_key must be 32 url-safe base64-encoded bytes # fernet_key = fernet.Fernet.generate_key() # secret_key = base64.urlsafe_b64decode(fernet_key) # aiohttp_session.setup(app, EncryptedCookieStorage(secret_key)) aiohttp_session.setup(app, aiohttp_session.SimpleCookieStorage()) web.run_app(app, host=host_ip, port=port)
async def test_aiohttp_auth_middleware_setup(loop): app = web.Application(loop=loop) secret = b'01234567890abcdef' storage = aiohttp_session.SimpleCookieStorage() aiohttp_session.setup(app, storage) auth_policy = auth.SessionTktAuthentication(secret, 15, cookie_name='auth') class ACLAutzPolicy(acl.AbstractACLAutzPolicy): async def acl_groups(self, user_identity): return None # pragma: no cover autz_policy = ACLAutzPolicy() aiohttp_auth.setup(app, auth_policy, autz_policy) middleware = auth.auth_middleware(auth_policy) assert app.middlewares[-2].__name__ == middleware.__name__ middleware = autz.autz_middleware(autz_policy) assert app.middlewares[-1].__name__ == middleware.__name__
def init_app(args=()): logging.basicConfig(level=logging.DEBUG) app = web.Application() app["client_id"] = os.getenv("CLIENT_ID") app["client_secret"] = os.getenv("CLIENT_SECRET") app["client_host"] = os.getenv("CLIENT_HOST") env = aiojinja.setup(app, loader=jinja2.FileSystemLoader( os.path.join(os.path.dirname(__file__), "templates"))) env.globals.update({ "currency": currency, "date_format": date_format, "url": url, }) aiosession.setup(app, storage=aiosession.SimpleCookieStorage()) # TODO app.router.add_get("/callback", callback, name="callback") app.router.add_get("/clear", clear) app.router.add_get("/logout", logout) app.router.add_get("/", base) app.router.add_static("/static", os.path.join(os.path.dirname(__file__), "static")) return app
from . import Server, Resources from ...words import random_words parser = argparse.ArgumentParser() parser.add_argument("-p", "--port", type=int, default=8080) parser.add_argument("-H", "--host", default="localhost") parser.add_argument("--random-seed", type=int, default=None) args = parser.parse_args() rng = random.Random() if args.random_seed is not None: rng.seed(args.random_seed) token_auth = TokenAuthenticator() app = web.Application() aiohttp_session.setup(app, aiohttp_session.SimpleCookieStorage()) html_server = Server( token_auth=token_auth, username_password_auth=UsernamePasswordAuthenticator( make_random_entity_id=(lambda: EntityId("-".join(random_words(4)))), token_authenticator=token_auth, ), marketplace=Marketplace(rng=rng), petname_registry=PetnameRegistry(), resources=Resources(app.router), ) html_server.add_handlers() web.run_app(app, host=args.host, port=args.port)
import aiohttp_session from pathlib import Path from aiohttp import web from ...api import auth from ...api.protobuf.predictionmarkets import auth_pb2 routes = web.RouteTableDef() @routes.get('/') async def index(req): return web.FileResponse(Path(__file__).parent/'LoginWidget.html') @routes.get('/static/LoginWidget.js') async def index(req): return web.FileResponse(Path(__file__).parent.parent/'elm'/'dist'/'LoginWidget.js') def raise_(e): raise e if __name__ == '__main__': authenticator = auth.Authenticator() app = web.Application(middlewares=[ aiohttp_session.session_middleware(aiohttp_session.SimpleCookieStorage()), authenticator.middleware, ]) app.add_routes(routes) app.add_routes(auth.make_routes(authenticator)) web.run_app(app, host='localhost', port=8080)