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)
