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
def _middleware(self, acl_callback): """Returns the middlewares used in the test""" if acl_callback: return [ session_middleware(self.storage), auth_middleware(self.auth), acl_middleware(acl_callback)] return [ session_middleware(self.storage), auth_middleware(self.auth)]
def init_app(self): from nautilus.api.endpoints import template_dir as api_template_dir from nautilus.auth import template_dir as auth_template_dir # the secret key secret_key = 'NERbTdtQl7IrBM9kx1PDjJXiyZhWWBZ9E7q2B3U7KVE=' # create a web application instance self.app = aiohttp.web.Application( middlewares=[ session_middleware( EncryptedCookieStorage(secret_key, secure=True, domain='*') ) ] ) # add the template loader aiohttp_jinja2.setup(self.app, loader=jinja2.ChoiceLoader([ jinja2.FileSystemLoader(api_template_dir), jinja2.FileSystemLoader(auth_template_dir) ]) ) # TODO: # debug mode # attach the ioloop to the application self.loop = asyncio.get_event_loop() # attach the service to the loop self.loop.service = self
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) # setup dummy auth and identity ident_policy = DummyTokenIdentityPolicy() auth_policy = DummyAuthPolicy(username="******", password="******") aiohttp_security.setup(app, ident_policy, auth_policy) 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
def init(loop): app = web.Application(middlewares=[ session_middleware(EncryptedCookieStorage(conf.SECRET)), auth.auth_middleware, ]) aiohttp_jinja2.setup( app, context_processors=[context.static, aiohttp_jinja2.request_processor], loader=jinja2.FileSystemLoader(conf.relative('templates')) ) yield from get_storage().init_storage() if conf.DEBUG: app.router.add_static(conf.STATIC_URL, conf.STATIC_PATH) for _ in urls.urls: url, view, methods = (_ + (['GET', ], ))[:3] for method in methods: app.router.add_route(method, url, view) srv = yield from loop.create_server( app.make_handler(), '127.0.0.1', 8080 ) print("Server started at http://127.0.0.1:8080") return srv
async def init(loop): global app, dbpool redis = await aioredis.create_pool(('localhost', 6379)) storage = redis_storage.RedisStorage(redis) session_middleware1 = session_middleware(storage) #dbpool = await my_create_pool(dsn) dbpool = await aiopg.create_pool(dsn) app = web.Application(middlewares=[session_middleware1]) #app = web.Application(middlewares=[session_middleware( # EncryptedCookieStorage(b'Thirty two length bytes key.'))]) aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader(path('templates'))) # app.router.add_route('GET', '/test/ws/', ws_test) app.router.add_route('GET', '/admin/', admin) app.router.add_route('GET', '/admin/{host}/', admin) app.router.add_route('GET', '/admin/{host}/{nickname}/', chat_page_admin) app.router.add_route('POST', '/admin/{host}/{nickname}/', new_msg) app.router.add_route('GET', '/admin/{host}/{nickname}/ws/', websocket_handler) app.router.add_route('GET', '/', hello) app.router.add_route('POST', '/', hello) app.router.add_route('GET', '/{host}/', chat_page, name='chat_page') app.router.add_route('POST', '/{host}/', new_msg) app.router.add_route('GET', '/{host}/ws/', websocket_handler) srv = await loop.create_server( app.make_handler(), '0.0.0.0', 8080) return srv
async def init(loop, host: str, port: int, secret_key: str, persistence: BasePersistence): """Initialize the application.""" app = web.Application( loop=loop, middlewares=[session_middleware(EncryptedCookieStorage(secret_key))] ) for name, (method, path, handler) in routes.items(): def add_persistence_to_handler(handler): @wraps(handler) def handler_with_persistence(*args, **kwargs): return handler(*args, persistence=persistence, **kwargs) return handler_with_persistence app.router.add_route( method, path, add_persistence_to_handler(handler), name=name) static_dir = os.path.join(os.path.dirname(__file__), 'static/') app.router.add_static('/static', static_dir, name='Static') async def static_index(request): route = web.StaticRoute(None, '/', static_dir) request.match_info['filename'] = 'index.html' return await route.handle(request) app.router.add_route('GET', '/', static_index) srv = await loop.create_server(app.make_handler(), host, port) print('HTTP server started at %s:%s' % (host, port), file=sys.stderr) return srv
def main(): """OOI运行主函数。 :return: none """ # 解析命令行参数 args = parser.parse_args() host = args.host port = args.port # 初始化事件循环 loop = asyncio.get_event_loop() # 初始化请求处理器 api = APIHandler() frontend = FrontEndHandler() service = ServiceHandler() # 定义会话中间件 middlewares = [session_middleware(EncryptedCookieStorage(config.secret_key)), ] # 初始化应用 app = aiohttp.web.Application(middlewares=middlewares, loop=loop) # 定义Jinja2模板位置 aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader(config.template_dir)) # 给应用添加路由 app.router.add_route('GET', '/', frontend.form) app.router.add_route('POST', '/', frontend.login) app.router.add_route('GET', '/kancolle', frontend.normal) app.router.add_route('GET', '/kcv', frontend.kcv) app.router.add_route('GET', '/flash', frontend.flash) app.router.add_route('GET', '/poi', frontend.poi) app.router.add_route('GET', '/connector', frontend.connector) app.router.add_route('GET', '/logout', frontend.logout) app.router.add_route('GET', '/kcsapi/{action:.+}', api.api) app.router.add_route('POST', '/kcsapi/{action:.+}', api.api) app.router.add_route('GET', '/kcs/resources/image/world/{server:.+}_{size:[lst]}.png', api.world_image) app.router.add_route('POST', '/service/osapi', service.get_osapi) app.router.add_route('POST', '/service/flash', service.get_flash) app.router.add_static('/static', config.static_dir) app.router.add_static('/kcs', config.kcs_dir) app.router.add_static('/_kcs', config.kcs_dir) app_handlers = app.make_handler() # 启动OOI服务器 server = loop.run_until_complete(loop.create_server(app_handlers, host, port)) print('OOI serving on http://%s:%d' % server.sockets[0].getsockname()) try: loop.run_forever() except KeyboardInterrupt: pass finally: loop.run_until_complete(app_handlers.finish_connections(1.0)) server.close() loop.run_until_complete(server.wait_closed()) loop.run_until_complete(app.finish()) loop.close()
def init(loop, host='0.0.0.0', port=10000): from ircb.storeclient import initialize initialize() load_config() policy = auth.SessionTktAuthentication( settings.WEB_SALT, 60, include_ip=True) middlewares = [ session_middleware(EncryptedCookieStorage(settings.WEB_SALT)), auth.auth_middleware(policy) ] app = web.Application(middlewares=middlewares) app.router.add_route('GET', '/', index) app.router.add_route('*', '/api/v1/signup', SignupView, name='signup') app.router.add_route('*', '/api/v1/signin', SigninView, name='signin') app.router.add_route('*', '/api/v1/signout', SignoutView, name='signout') app.router.add_route('*', '/api/v1/networks', NetworkListView, name='networks') app.router.add_route('*', '/api/v1/network/{id}', NetworkView, name='network') app.router.add_route('PUT', '/api/v1/network/{id}/{action}', NetworkConnectionView, name='network_connection') srv = yield from loop.create_server( app.make_handler(logger=logger, access_log=logger), host, port) return srv
async def init(loop): middle = [ session_middleware(EncryptedCookieStorage(SECRET_KEY)), authorize, db_handler, ] if DEBUG: middle.append(aiohttp_debugtoolbar.middleware) app = web.Application(loop=loop, middlewares= middle ) app['websockets'] = [] handler = app.make_handler() if DEBUG: aiohttp_debugtoolbar.setup(app) aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader('templates')) # route part for route in routes: app.router.add_route(route[0], route[1], route[2], name=route[3]) app.router.add_static('/static', 'static', name='static') # end route part # db connect app.client = ma.AsyncIOMotorClient(MONGO_HOST) app.db = app.client[MONGO_DB_NAME] # end db connect app.on_shutdown.append(on_shutdown) serv_generator = loop.create_server(handler, SITE_HOST, SITE_PORT) return serv_generator, handler, app
def init(loop): adminMainController = AdminMainController() engine = yield from create_engine(**config['db']) with (yield from engine) as connection: adminUserController = AdminUserController( adminMainController, users, connection) redis = yield from aioredis.create_pool(('localhost', 6379)) storage = RedisStorage(redis) app = web.Application(middlewares=[session_middleware(storage)]) aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader('templates')) app.router.add_route('GET', '/', main_page_view) app.router.add_route('GET', '/admin', adminMainController.get) app.router.add_route( 'GET', '/admin/{table}', adminMainController.get_table) app.router.add_route( 'POST', '/admin/{table}', adminMainController.create_record) app.router.add_static('/dist', 'dist') server = yield from loop.create_server(app.make_handler(), '127.0.0.1', 8080) return server
async def init(loop): app = web.Application(loop=loop, middlewares=[ session_middleware(EncryptedCookieStorage(SECRET_KEY)), authorize, db_handler, aiohttp_debugtoolbar.middleware, ]) app['websockets'] = defaultdict(list) handler = app.make_handler() if DEBUG: aiohttp_debugtoolbar.setup(app, intercept_redirects=False) aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader('templates')) # route part for route in routes: app.router.add_route(route[0], route[1], route[2], name=route[3]) app.router.add_static('/static', 'static', name='static') # end route part # db connect app.db = await init_db( host=MYSQL_HOST, db=MYSQL_DB_NAME, user=MYSQL_USER, password=MYSQL_PASSWORD, loop=loop ) # end db connect app.on_shutdown.append(on_shutdown) serv_generator = loop.create_server(handler, SITE_HOST, SITE_PORT) return serv_generator, handler, app
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_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)
def init(loop): app = Application(middlewares=[session_middleware( EncryptedCookieStorage(SECRET_KEY))]) setup_jinja(app, loader=FileSystemLoader(TEMPLATE_DIR)) for route in routes: app.router.add_route(route['method'], route['url'], route['handler'], **route['kwargs_']) srv = yield from loop.create_server( app.make_handler(), '0.0.0.0', 8080) return srv
def init(loop): redis = yield from aioredis.create_pool(('localhost', 6379), loop=loop) storage = aiohttp_session.redis_storage.RedisStorage(redis) session_middleware = aiohttp_session.session_middleware(storage) app = aiohttp.web.Application(middlewares=[session_middleware]) app.router.add_route('GET', '/', handler) srv = yield from loop.create_server( app.make_handler(), '0.0.0.0', 8081) return srv
async def init(loop, port): app = InternetVotingApplication( loop=loop, middlewares=[ session_middleware(EncryptedCookieStorage(SECRET_KEY)), authorize, ] ) aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader('_static')) srv = await loop.create_server(app.make_handler(), '127.0.0.1', port) return srv
def app(loop): app = web.Application( loop=loop, middlewares=[ aiohttp_session.session_middleware(aiohttp_session.SimpleCookieStorage()), aiohttp_session_flash.middleware, ] ) yield app loop.run_until_complete(app.shutdown()) loop.run_until_complete(app.cleanup()) loop.close()
def create_server(self, method, path, handler=None): middleware = session_middleware(SimpleCookieStorage()) app = web.Application(middlewares=[middleware], loop=self.loop) if handler: app.router.add_route(method, path, handler) port = self.find_unused_port() srv = yield from self.loop.create_server( app.make_handler(), '127.0.0.1', port) url = "http://127.0.0.1:{}".format(port) + path self.addCleanup(srv.close) return app, srv, url
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
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)
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')
def create_server(self, method, path, handler=None): middleware = session_middleware( EncryptedCookieStorage(self.key)) app = web.Application(middlewares=[middleware], loop=self.loop) if handler: 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.srv = srv self.handler = handler return app, srv, url
def create_server(self, method, path, handler=None, max_age=None): self.redis = yield from aioredis.create_pool(("localhost", 6379), minsize=5, maxsize=10, loop=self.loop) self.addCleanup(self.redis.clear) middleware = session_middleware(RedisStorage(self.redis, max_age=max_age)) app = web.Application(middlewares=[middleware], loop=self.loop) if handler: 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.srv = srv self.handler = handler return app, srv, url
def init(loop): print("In init()") app = web.Application( # loop=loop, middlewares=[session_middleware(EncryptedCookieStorage(config.SECRET))], ) app.router.add_route('GET', '/login/{provider}', login) app.router.add_route('GET', '/secret', secret) srv = yield from loop.create_server( app.make_handler(), 'auth.tuhao.com', 8080, ) print("Server started", srv.sockets[0].getsockname()) return srv
def create_app(loop=None): app = web.Application( middlewares=[ session_middleware(EncryptedCookieStorage(settings.COOKIE_SECRET)), error_middleware], loop=loop if loop is not None else settings.loop) aiohttp_jinja2.setup( app, loader=jinja2.FileSystemLoader(settings.TEMPLATES_PATH)) for route in routes.routes: app.router.add_route(*route[0], **route[1]) if settings.DEBUG: app.router.add_static(settings.STATIC_URL, settings.STATIC_PATH) return app
def create(*, debug=False, ssl_ctx=None, proto='http'): nonlocal app, handler, srv app = Application( loop=loop, middlewares=[ session_middleware(EncryptedCookieStorage(b'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa')) ] ) port = unused_port() handler = app.make_handler(debug=debug, keep_alive_on=False) srv = yield from loop.create_server(handler, '127.0.0.1', port, ssl=ssl_ctx) if ssl_ctx: proto += 's' url = "{}://127.0.0.1:{}".format(proto, port) return app, url
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 test_app_setup_bad(loop): app = web.Application(loop=loop, middlewares=[ session_middleware(SimpleCookieStorage()) ]) aiologin.setup( app=app, auth_by_header=auth_by_header, auth_by_session=auth_by_session, login_signal=[bad_message, bad_message], logout_signal=[bad_message], secured_signal=[bad_message], auth_by_header_signal=[bad_message], auth_by_session_signal=[bad_message] ) app.router.add_route('GET', '/', handler) app.router.add_route('GET', '/login', login) app.router.add_route('GET', '/logout', logout) return app
def add_github_auth_middleware(app, cookie_key=None, cookie_name='aiogithubauth', **kwargs): if cookie_key is None: print('creating new cookie secret') cookie_key = os.urandom(16).hex() app._middlewares = app._middlewares + [ session_middleware( EncryptedCookieStorage(cookie_key.encode(), cookie_name=cookie_name, max_age=7200)), # two hours github_auth_middleware(**kwargs) ] app.router.add_route('GET', '/oauth_callback/github', handle_github_callback)
from routes import routes from middlewares import authorize from motor import motor_asyncio as ma from settings import * import hashlib async def on_shutdown(app): for ws in app['websockets']: await ws.close(code=1001, message='Server shutdown') middle = [ session_middleware( EncryptedCookieStorage( hashlib.sha256(bytes(SECRET_KEY, 'utf-8')).digest())), authorize, ] # if DEBUG: # middle.append(aiohttp_debugtoolbar.middleware) app = web.Application(middlewares=middle) # if DEBUG: # aiohttp_debugtoolbar.setup(app) aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader('templates')) # route part
from app.views import routes import app.auth as auth uvloop.install() async def startup(app: web.Application): app['pg'] = await asyncpg.create_pool(dsn=os.environ.get('DATABASE_URL')) async def cleanup(app: web.Application): await app['pg'].close() app = web.Application(middlewares=[ session_middleware(EncryptedCookieStorage(os.environ.get( 'SESSION_SECRET'))), auth.middleware(os.environ.get('AUTH_SALT').encode()), ]) app['name'] = 'AIOHTTP Server Practice' app['static_root_url'] = os.environ.get('STATIC_ROOT_URL') aiohttp_jinja2.setup(app, context_processors=[auth.jinja2_context_processor], loader=jinja2.FileSystemLoader('./app/templates')) app.add_routes(routes) app.on_startup.append(startup) app.on_cleanup.append(cleanup)
from db import database from utils.middlewares import request_user_middleware from settings import REDIS_CON, DATABASE from views import Test, WebSocket, LogInView, UserInfoView, RoomListView router = UrlDispatcher() loop = asyncio.get_event_loop() redis_pool = loop.run_until_complete(aioredis.create_pool(REDIS_CON, loop=loop)) middlewares = [ session_middleware( RedisStorage(redis_pool=redis_pool, cookie_name='aiochat_session_id', max_age=24 * 60 * 60, domain="192.168.0.101", httponly=False, secure=False)), request_user_middleware ] app = web.Application(router=router, middlewares=middlewares) cors = aiohttp_cors.setup(app, defaults={ "*": aiohttp_cors.ResourceOptions( allow_credentials=True, expose_headers="*", allow_headers="*") }) cors.add(router.add_post('/login', LogInView))
async def handler(request): return web.Response(text="OK") async def login(request): # remember is false you should add your own functionality await request.aiologin.authenticate(remember=False) return web.Response(text="logged in") async def logout(request): await request.aiologin.logout() return web.Response(text="logged out") app = web.Application(middlewares=[session_middleware(SimpleCookieStorage())]) aiologin.setup(app=app, auth_by_form=auth_by_form, auth_by_header=auth_by_header, auth_by_session=auth_by_session, signals=[(aiologin.ON_LOGIN, func0), (aiologin.ON_LOGIN, func1), (aiologin.ON_LOGOUT, func2), (aiologin.ON_AUTHENTICATED, func3), (aiologin.ON_FORBIDDEN, func4), (aiologin.ON_UNAUTHORIZED, func5)]) app.router.add_route('GET', '/', handler) app.router.add_route('GET', '/login', login) app.router.add_route('GET', '/logout', logout)
async def init(loop, config_args=None): # CONFIG config.configure(config_args) logger.info('Env: {env}'.format(env=config.get('env'))) # SESSION redis_db = config.get('redis_database', 0) redis_pool = await aioredis.create_pool(('localhost', 6379), db=redis_db) storage = redis_storage.RedisStorage( redis_pool, cookie_name="AIOHTTP_SESSION-{redis_db}".format(redis_db=redis_db)) app = web.Application( loop=loop, middlewares=[session_middleware(storage), db_handler]) app.redis_pool = redis_pool # QUEUE app.queue = Queue(connection=Redis()) # WEBSOCKET """ app['websockets'] = [] """ handler = app.make_handler() # ROUTES for route in routes: app.router.add_route(route[0], route[1], route[2], name=route[3]) if config.get('env', 'production') == 'development': static_path = os.path.join(ROOT, 'dist-dev') else: if config.get('release', 'latest') == 'latest': latest_version_path = os.path.join(ROOT, 'releases', 'latest.txt') if os.path.exists(latest_version_path): with open(latest_version_path, 'r') as fd: release_version = fd.read() else: raise Exception("The latest.txt file doesn't exists") else: release_version = config.get('release') static_path = os.path.join(ROOT, 'releases', release_version) app.router.add_static('/', static_path, name='static') logger.info( "Serving static: {static_path}".format(static_path=static_path)) aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader(static_path)) # PREPARE HOOK async def after_request(request, response): if hasattr(request, 'db_session'): request.db_session.end() request.db_session.db.client.close() app.on_response_prepare.append(after_request) # SHUTDOWN app.on_shutdown.append(on_shutdown) serv_generator = loop.create_server(handler, config.get('server_host'), config.get('server_port')) return serv_generator, handler, app
async def init(loop): global mc global app middlewares = [] # middlewares.append(aiohttp_debugtoolbar.middleware) # debugtoolbar.intercept_redirects = false middlewares.append(db_handler()) if settings.debug: middlewares.append(session_middleware(SimpleCookieStorage())) else: middlewares.append( session_middleware(EncryptedCookieStorage(settings.session_key))) app = web.Application(loop=loop, middlewares=middlewares) # aiohttp_debugtoolbar.setup(app) # debugtoolbar.intercept_redirects = False # aiohttp_debugtoolbar.intercept_redirects = False aiohttp_jinja2.setup(app, loader=jinja2.FunctionLoader(load_templ), bytecode_cache=None, cache_size=0) # Memcache init app.mc = aiomcache.Client(settings.memcache['addr'], settings.memcache['port'], loop=loop) # 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') # print('path->', path) app.router.add_static('/static/', os.path.join(settings.root_path, 'static')) sites = os.path.join(settings.tao_path, 'libs', 'sites', 'st') # print('sites->', sites) app.router.add_static( '/st/sites/', os.path.join(settings.tao_path, 'libs', 'sites', 'st')) app.router.add_static( '/st/table/', os.path.join(settings.tao_path, 'libs', 'table', 'st')) app.router.add_static( '/st/tree/', os.path.join(settings.tao_path, 'libs', 'tree', 'st')) app.router.add_static( '/st/admin/', os.path.join(settings.tao_path, 'libs', 'admin', 'st')) app.router.add_static( '/st/contents/', os.path.join(settings.tao_path, 'libs', 'contents', 'st')) app.router.add_static( '/st/chat/', os.path.join(settings.tao_path, 'libs', 'chat', 'st')) app.router.add_static( '/st/files/', os.path.join(settings.tao_path, 'libs', 'files', 'st')) app.router.add_static( '/st/game/', os.path.join(settings.tao_path, 'libs', 'game', 'st')) app.router.add_static( '/st/perm/', os.path.join(settings.tao_path, 'libs', 'perm', 'st')) # app.router.add_route('GET', '/static/{dir}/{fname}', st_file, name='static') handler = app.make_handler(debug=True) if debug and reload: aiohttp_autoreload.start() srv = await loop.create_server(handler, settings.addr[0], settings.addr[1]) print("Server started at " + settings.addr[0] + ' ' + str(settings.addr[1])) return srv, handler, app
async def init(loop, port=None, watch_change=False): logging.basicConfig(level=logging.INFO) logger = logging.getLogger("magrit_app.main") redis_cookie = await create_pool(('0.0.0.0', 6379), db=0, maxsize=50, loop=loop) redis_conn = await create_reconnecting_redis(('0.0.0.0', 6379), db=1, loop=loop) app = web.Application(loop=loop, client_max_size=16384**2, middlewares=[ error_middleware, session_middleware( redis_storage.RedisStorage(redis_cookie)) ]) aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader('templates')) add_route = app.router.add_route add_route('GET', '/', index_handler) add_route('GET', '/index', index_handler) add_route('GET', '/contact', serve_contact_form) add_route('POST', '/contact', store_contact_info) add_route('GET', '/modules', serve_main_page) add_route('GET', '/modules/', serve_main_page) add_route('GET', '/modules/{expr}', serve_main_page) # add_route('GET', '/layers', list_user_layers) add_route('POST', '/layers/add', receiv_layer) add_route('POST', '/layers/delete', remove_layer) add_route('GET', '/extrabasemaps', get_extrabasemaps) add_route('GET', '/get_layer/{expr}', handler_exists_layer) add_route('POST', '/get_layer2', handler_exists_layer2) add_route('POST', '/compute/{function}', geo_compute) add_route('POST', '/stats', get_stats_json) add_route('POST', '/sample', get_sample_layer) add_route('POST', '/convert_to_topojson', convert) add_route('POST', '/convert_topojson', convert_topo) add_route('POST', '/convert_csv_geo', convert_csv_geo) add_route('POST', '/convert_extrabasemap', convert_extrabasemap) add_route('POST', '/convert_tabular', convert_tabular) # add_route('POST', '/cache_topojson/{params}', cache_input_topojson) add_route('POST', '/helpers/calc', calc_helper) app.router.add_static('/static/', path='static', name='static') app['redis_conn'] = redis_conn app['app_users'] = set() app['logger'] = logger app['version'] = get_version() with open('static/json/sample_layers.json', 'r') as f: app['db_layers'] = json.loads(f.read().replace('/static', 'static'))[0] app['ThreadPool'] = ThreadPoolExecutor(4) app['ProcessPool'] = ProcessPoolExecutor(4) app['app_name'] = "Magrit" app['geo_function'] = { "stewart": call_stewart, "gridded": carto_gridded, "links": links_map, "carto_doug": carto_doug, "olson": compute_olson } if watch_change: app['FileWatcher'] = JsFileWatcher() # app.on_startup.append(on_startup) app.on_shutdown.append(on_shutdown) prepare_list_svg_symbols() if not port: return app else: handler = app.make_handler() srv = await loop.create_server(handler, '0.0.0.0', port) return srv, app, handler
def create_app(loop, handler, redis, max_age=None): middleware = session_middleware(RedisStorage(redis, max_age=max_age)) app = web.Application(middlewares=[middleware], loop=loop) app.router.add_route('GET', '/', handler) return app
def setup(secret_key): return session_middleware(EncryptedCookieStorage(secret_key))
from aiohttp_session import session_middleware from aiohttp_session.cookie_storage import EncryptedCookieStorage from aiohttp_session.redis_storage import RedisStorage from aiohttp import web from motor import motor_asyncio as ma from middlewares import authorize from routes import routes from utils import create_models, create_redis, close_redis, make_redis_pool from settings import SECRET_KEY, MONGO_DB_NAME, MONGO_HOST, PHOTO_DIR, AVATAR_DIR loop = asyncio.get_event_loop() redis_pool = loop.run_until_complete(make_redis_pool()) storage = RedisStorage(redis_pool) session_redis_middleware = aiohttp_session.session_middleware(storage) middle = [ session_middleware(EncryptedCookieStorage(hashlib.sha256(bytes(SECRET_KEY, 'utf-8')).digest())), authorize, session_redis_middleware ] app = web.Application(middlewares=middle) aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader('templates')) for route in routes: app.router.add_route(*route[:3], name=route[3]) app.router.add_static('/static', 'static', name='static')
def create_app(handler, key): middleware = session_middleware(NaClCookieStorage(key)) app = web.Application(middlewares=[middleware]) app.router.add_route('GET', '/', handler) return app
def __init__(self, configFolder): operationsystem= sys.platform if operationsystem.startswith('win'): set_event_loop_policy(WindowsSelectorEventLoopPolicy()) self.path = os.sep.join(os.path.abspath(__file__).split(os.sep)[:-1]) # The path to the package dir self.version = __version__ self.codename = __codename__ self.config_folder = configFolder self.static_config = load_config(configFolder.get_file_path("config.yaml")) logger.info("Init CraftBeerPI") policy = auth.SessionTktAuthentication(urandom(32), 60, include_ip=True) middlewares = [web.normalize_path_middleware(), session_middleware(EncryptedCookieStorage(urandom(32))), auth.auth_middleware(policy), error_middleware] # max upload size increased to 5 Mb. Default is 1 Mb -> config and svg upload self.app = web.Application(middlewares=middlewares, client_max_size=5*1024*1024) self.app["cbpi"] = self self._setup_shutdownhook() self.initializer = [] self.bus = CBPiEventBus(self.app.loop, self) self.job = JobController(self) self.config = ConfigController(self) self.ws = CBPiWebSocket(self) self.actor = ActorController(self) self.sensor = SensorController(self) self.plugin = PluginController(self) self.log = LogController(self) self.system = SystemController(self) self.kettle = KettleController(self) self.fermenter : FermentationController = FermentationController(self) self.step : StepController = StepController(self) self.recipe : RecipeController = RecipeController(self) self.fermenterrecipe : FermenterRecipeController = FermenterRecipeController(self) self.upload : UploadController = UploadController(self) self.notification : NotificationController = NotificationController(self) self.satellite = None if str(self.static_config.get("mqtt", False)).lower() == "true": self.satellite: SatelliteController = SatelliteController(self) self.dashboard = DashboardController(self) self.http_step = StepHttpEndpoints(self) self.http_recipe = RecipeHttpEndpoints(self) self.http_fermenterrecipe = FermenterRecipeHttpEndpoints(self) self.http_sensor = SensorHttpEndpoints(self) self.http_config = ConfigHttpEndpoints(self) self.http_actor = ActorHttpEndpoints(self) self.http_kettle = KettleHttpEndpoints(self) self.http_dashboard = DashBoardHttpEndpoints(self) self.http_plugin = PluginHttpEndpoints(self) self.http_system = SystemHttpEndpoints(self) self.http_log = LogHttpEndpoints(self) self.http_notification = NotificationHttpEndpoints(self) self.http_upload = UploadHttpEndpoints(self) self.http_fermenter = FermentationHttpEndpoints(self) self.login = Login(self)
import base64 from aiohttp import web from aiohttp_session import session_middleware, setup from aiohttp_swagger import setup_swagger from cryptography import fernet from aiohttp_security import setup as setup_security, SessionIdentityPolicy from db import init_mongo, close_mongo from middlewares import TokenStorage from policy import SimpleAuthorizationPolicy from settings import config from views import routes fernet_key = fernet.Fernet.generate_key() secret_key = base64.urlsafe_b64decode(fernet_key) middleware = session_middleware(TokenStorage(secret_key)) app = web.Application(middlewares=[middleware]) app.router.add_routes(routes) setup_swagger(app, swagger_from_file="docs/swagger.yaml") app['config'] = config app.on_startup.append(init_mongo) app.on_cleanup.append(close_mongo) setup_security(app, SessionIdentityPolicy(), SimpleAuthorizationPolicy(app)) web.run_app(app)
# setup # if os.path.exists('fernet_key'): with open('fernet_key', 'rb') as f: fernet_key = pickle.load(f) else: enc_fernet_key = cryptography.fernet.Fernet.generate_key() fernet = cryptography.fernet.Fernet(enc_fernet_key) fernet_key = base64.urlsafe_b64decode(enc_fernet_key) with open('fernet_key', 'wb') as f: pickle.dump(fernet_key, f) app = web.Application( middlewares=[session_middleware(EncryptedCookieStorage(fernet_key))]) aiohttp_jinja2.setup( app, loader=jinja2.FileSystemLoader(os.path.abspath('templates')), ) def route(method_type, method_route): def f(callback): def handler(request): return callback(request) app.router.add_route(method_type, method_route, handler) return f
def create_app(*handlers): middleware = session_middleware(SimpleCookieStorage()) app = web.Application(middlewares=[middleware]) for url, handler in handlers: app.router.add_route('GET', url, handler) return app
app['db'] = engine async_session = sessionmaker(engine, expire_on_commit=False, class_=AsyncSession) app['session'] = async_session() asyncio.create_task(background(app['session'])) async def delete_connection(app): await app['session'].close() if __name__ == "__main__": logging.basicConfig( level=logging.DEBUG, format='%(asctime)s %(name)-12s %(levelname)-8s %(message)s', datefmt='%m-%d %H:%M') loop = asyncio.get_event_loop() middleware = session_middleware( EncryptedCookieStorage(b'Thirty two length bytes key. ')) app = web.Application(middlewares=[middleware]) aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader( str(BASE_DIR / 'templates'))) setup_routes(app) setup_static_routes(app) setup_security(app, SessionIdentityPolicy(), MyAuthorizationPolicy(app)) app.on_startup.append(create_connection) app.on_cleanup.append(delete_connection) web.run_app(app)
if not session.empty: session['last_visited'] = datetime.datetime.now().isoformat() if session.get('user', None): request["user"] = session['user'] request['last_visited'] = session['last_visited'] return await handler(request) loop = asyncio.get_event_loop() pg_pool = loop.run_until_complete(create_pool()) db = Database(pg_pool) redis = loop.run_until_complete(get_redis_pool()) storage = RedisStorage(redis) session_middleware = aiohttp_session.session_middleware(storage) dir_path = os.path.dirname(os.path.realpath(__file__)) router = SwaggerRouter(search_dirs=[dir_path], swagger_ui='/api/', default_validate=True) app = web.Application(router=router, middlewares=[ session_middleware, error_middleware, user_middleware, jsonify ]) add_routes(app) aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader('templates')) app['database'] = db
from aiohttp import web import aiohttp_jinja2 import jinja2 import aiohttp_security from aiohttp_session import SimpleCookieStorage, session_middleware from routes import setup_routes from settings import config from db import close_pg, init_pg from secure import identity_policy, autz_policy middleware = session_middleware(SimpleCookieStorage()) app = web.Application(middlewares=[middleware]) app['config'] = config setup_routes(app) aiohttp_jinja2.setup( app, loader=jinja2.FileSystemLoader( r'D:\Programming\Aiohttp\Web-server\aiohttp_polls\templates')) app.on_startup.append(init_pg) app.on_cleanup.append(close_pg) aiohttp_security.setup(app, identity_policy, autz_policy) web.run_app(app)
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)
def get_session_middleware(): fernet_key = fernet.Fernet.generate_key() secret_key = base64.urlsafe_b64decode(base64.urlsafe_b64encode((" " * 32).encode())) return aiohttp_session.session_middleware(EncryptedCookieStorage(secret_key))
('GET', '/ws/friends', 'wsgetfriends', WSGetFriends), ('POST', '/login', 'httplogin', HTTPLogin), ('POST', '/logout', 'httplogout', HTTPLogout), ('POST', '/likes', 'httpposts', HTTPGetLikedPeoples), ('POST', '/comments', 'httpcomments', HTTPGetCommentedPeoples)] async def on_shutdown(app): for ws in app['websockets']: await ws.close(code=1001, message='Server shutdown') middle = [ session_middleware( EncryptedCookieStorage( hashlib.sha256( base64.urlsafe_b64decode( fernet.Fernet.generate_key())).digest())) ] app = web.Application() for route in ROUTES: app.router.add_route(method=route[0], path=route[1], name=route[2], handler=route[3]) static_path = config.get("static_path") if not os.path.exists(static_path): os.mkdir(static_path)
async def test_session_middleware_bad_storage() -> None: with pytest.raises(RuntimeError): # Ignoring typing since parameter type is wrong on purpose session_middleware(None) # type: ignore[arg-type]
def create_app(loop, handler, key): middleware = session_middleware(EncryptedCookieStorage(key)) app = web.Application(middlewares=[middleware], loop=loop) app.router.add_route('GET', '/', handler) return app
from aiohttp_session import session_middleware, SimpleCookieStorage from routes import routes from middlewares import authorize from database_handlers import init_mysql_db, close_mysql_db async def on_shutdown(app): await close_mysql_db(app) print("shutting down") # list of middlewares _middlewares = [ session_middleware(SimpleCookieStorage()), # no security authorize ] # initializing app, appending middlewares app = web.Application(middlewares=_middlewares) # appending templates aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader('templates')) # adding routes from routes.py to route table for route in routes: app.router.add_route(route[0], route[1], route[2], name=route[3]) app.add_routes([web.static('/static', 'static')]) # adding signals app.on_startup.append(init_mysql_db)
Setting up a session Setting up templates, adding routes ''' import aiohttp_jinja2 import jinja2 from aiohttp_session import session_middleware from aiohttp import web from middleware import auth_middleware, pg_engine_ctx from model import get_sekret_key from routes import setup_routes # initialize the application app = web.Application(middlewares=[ session_middleware(get_sekret_key()), # db_middleware, # migrate to app.cleanup_ctx auth_middleware, ]) # app.on_startup.append(create_pg_engine) # app.on_cleanup.append(dispose_pg_engine) app.cleanup_ctx.append(pg_engine_ctx) # specify a folder with html-templates for the template engine aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader('templates')) # set routes setup_routes(app) web.run_app(app)
def create_app(*, settings: Settings = None, logging_client=None): logging_client = logging_client or setup_logging() settings = settings or Settings() app = web.Application(logger=None, middlewares=(pg_middleware, user_middleware, csrf_middleware)) app.update( settings=settings, auth_fernet=fernet.Fernet(settings.auth_key), dummy_password_hash=mk_password(settings.dummy_password, settings), logging_client=logging_client, ) app.on_startup.append(startup) app.on_cleanup.append(cleanup) app.add_routes([ web.get(r'/', index, name='index'), web.get(r'/sitemap.xml', sitemap, name='sitemap'), web.post(r'/ses-webhook/', ses_webhook, name='ses-webhook'), web.get(r'/cat/{category}/', category_public, name='category'), # event admin web.get(r'/events/categories/', event_categories, name='event-categories'), *EventBread.routes(r'/events/'), web.get(r'/events/search/', event_search, name='event-search'), web.post(r'/events/{id:\d+}/set-status/', SetEventStatus.view(), name='event-set-status'), web.post(r'/events/{id:\d+}/set-image/new/', set_event_image_new, name='event-set-image-new'), web.post(r'/events/{id:\d+}/set-image/existing/', set_event_image_existing, name='event-set-image-existing'), web.post(r'/events/{id:\d+}/set-image/secondary/', set_event_secondary_image, name='event-set-image-secondary'), web.post( r'/events/{id:\d+}/remove-image/secondary/', remove_event_secondary_image, name='event-remove-image-secondary', ), web.post( r'/events/{id:\d+}/set-image/description/', set_event_description_image, name='event-set-image-description', ), web.post( r'/events/{id:\d+}/remove-image/description/', remove_event_description_image, name='event-remove-image-description', ), web.post(r'/events/{id:\d+}/clone/', EventClone.view(), name='event-clone'), web.get(r'/events/{id:\d+}/tickets/', event_tickets, name='event-tickets'), web.post(r'/events/{id:\d+}/tickets/{tid:\d+}/cancel/', CancelTickets.view(), name='event-tickets-cancel'), web.get(r'/events/{id:\d+}/tickets/export.csv', event_tickets_export, name='event-tickets-export'), web.get(r'/events/{id:\d+}/donations/export.csv', event_donations_export, name='event-donations-export'), web.get(r'/events/{id:\d+}/ticket-types/', event_ticket_types, name='event-ticket-types'), web.post(r'/events/{id:\d+}/ticket-types/update/', SetTicketTypes.view(), name='update-event-ticket-types'), web.post(r'/events/{id:\d+}/reserve/', ReserveTickets.view(), name='event-reserve-tickets'), web.post(r'/events/{id:\d+}/updates/send/', EventUpdate.view(), name='event-send-update'), web.get(r'/events/{id:\d+}/updates/list/', event_updates_sent, name='event-updates-sent'), web.post(r'/events/{id:\d+}/switch-highlight/', switch_highlight, name='event-switch-highlight'), web.post(r'/events/{id:\d+}/waiting-list/add/', waiting_list_add, name='event-waiting-list-add'), web.get( r'/events/{id:\d+}/waiting-list/remove/{user_id:\d+}/', waiting_list_remove, name='event-waiting-list-remove', ), # event public views web.post(r'/events/book-free/', BookFreeTickets.view(), name='event-book-tickets'), web.post(r'/events/cancel-reservation/', CancelReservedTickets.view(), name='event-cancel-reservation'), web.get(r'/events/{category}/{event}/', event_get, name='event-get-public'), web.get(r'/events/{category}/{event}/booking-info/', booking_info, name='event-booking-info-public'), web.get(r'/events/{category}/{event}/donating-info/', donating_info, name='event-donating-info-public'), web.get(r'/events/{category}/{event}/{sig}/', event_get, name='event-get-private'), web.get(r'/events/{category}/{event}/{sig}/booking-info/', booking_info, name='event-booking-info-private'), web.get(r'/events/{category}/{event}/{sig}/donating-info/', donating_info, name='event-donating-info-private'), # stripe views web.post(r'/stripe/webhook/', stripe_webhook, name='stripe-webhook'), web.get( r'/stripe/payment-method-details/{payment_method}/', get_payment_method_details, name='payment-method-details', ), web.post(r'/login/', login, name='login'), web.get(r'/login/captcha/', login_captcha_required, name='login-captcha-required'), web.post(r'/login/{site:(google|facebook)}/', login_with, name='login-google-facebook'), web.post(r'/auth-token/', authenticate_token, name='auth-token'), web.post(r'/reset-password/', reset_password_request, name='reset-password-request'), web.post(r'/set-password/', set_password, name='set-password'), web.post(r'/logout/', logout, name='logout'), web.post(r'/signup/guest/{site:(google|facebook|email)}/', guest_signup, name='signup-guest'), web.post(r'/signup/host/{site:(google|facebook|email)}/', host_signup, name='signup-host'), web.get(r'/unsubscribe/{id:\d+}/', unsubscribe, name='unsubscribe'), *CompanyBread.routes(r'/companies/'), web.post(r'/companies/upload/{field:(image|logo)}/', company_upload, name='company-upload'), web.post(r'/companies/footer-links/set/', company_set_footer_link, name='company-footer-links'), web.post(r'/categories/{cat_id:\d+}/add-image/', category_add_image, name='categories-add-image'), web.get(r'/categories/{cat_id:\d+}/images/', category_images, name='categories-images'), web.post(r'/categories/{cat_id:\d+}/images/set-default/', category_set_image, name='categories-set-image'), web.post(r'/categories/{cat_id:\d+}/images/delete/', category_delete_image, name='categories-delete-image'), *CategoryBread.routes(r'/categories/'), *UserBread.routes(r'/users/'), *UserSelfBread.routes(r'/account/', name='account'), web.get(r'/users/search/', user_search, name='user-search'), web.get(r'/users/{pk:\d+}/actions/', user_actions, name='user-actions'), web.get(r'/users/{pk:\d+}/tickets/', user_tickets, name='user-tickets'), web.post(r'/users/{pk:\d+}/switch-status/', switch_user_status, name='user-switch-status'), web.get( r'/export/{type:(events|categories|users|tickets|donations)}.csv', export, name='export'), web.get(r'/email-defs/', email_def_browse, name='email-defs-browse'), web.get(r'/email-defs/{trigger}/', email_def_retrieve, name='email-defs-retrieve'), web.post(r'/email-defs/{trigger}/edit/', email_def_edit, name='email-defs-edit'), web.post(r'/email-defs/{trigger}/clear/', clear_email_def, name='email-defs-clear'), # donations *DonationOptionBread.routes(r'/donation-options/', name='donation-options'), web.get(r'/categories/{cat_id:\d+}/donation-options/', donation_options, name='donation-options'), web.post(r'/donation-options/{pk:\d+}/upload-image/', donation_image_upload, name='donation-image-upload'), web.get(r'/donation-options/{pk:\d+}/donations/', opt_donations, name='donation-opt-donations'), web.post( r'/donation-options/{don_opt_id:\d+}/prepare/{event_id:\d+}/', donation_after_prepare, name='donation-after-prepare', ), web.post(r'/donation-prepare/{tt_id:\d+}/', PrepareDirectDonation.view(), name='donation-direct-prepare'), web.post(r'/donation/{action_id:\d+}/gift-aid/', DonationGiftAid.view(), name='donation-gift-aid'), ]) wrapper_app = web.Application( client_max_size=settings.max_request_size, middlewares=( session_middleware( EncryptedCookieStorage(settings.auth_key, cookie_name='nosht')), error_middleware, ), logger=None, ) wrapper_app.update( settings=settings, main_app=app, ) static_dir = settings.custom_static_dir or (Path(__file__).parent / '../../js/build').resolve() assert static_dir.exists( ), f'js static directory "{static_dir}" does not exists' logger.debug('serving static files "%s"', static_dir) wrapper_app.update( static_dir=static_dir, csp_headers=get_csp_headers(settings), ) wrapper_app.add_subapp(r'/api/', app) wrapper_app.add_routes( [web.get(r'/{path:.*}', static_handler, name='static')]) return wrapper_app
# await db.gino.create_all() # app['db'] = engine # app['config']['gino'] = {'user': '******', 'password':'******', 'host':'localhost', 'port':'5433', 'database':'chat_db'} async def close_pg(app): await app['mongo'].close() del app['mongo'] # db = Gino() fernet_key = fernet.Fernet.generate_key() secret_key = base64.urlsafe_b64decode(fernet_key) middle = [ # session_middleware(EncryptedCookieStorage(hashlib.sha256(bytes(SECRET_KEY, 'utf-8')).digest())), session_middleware(EncryptedCookieStorage(secret_key)), authorization, # permission, db ] # if DEBUG: # middle.append(aiohttp_debugtoolbar.middleware) app = web.Application(middlewares=middle) app['config'] = {} app['config']['gino'] = { 'user': '******', 'password': '******', 'host': '0.0.0.0', 'port': '5432',
def main(): """OOI运行主函数。 :return: none """ # 解析命令行参数 args = parser.parse_args() host = args.host port = args.port # 初始化事件循环 loop = asyncio.get_event_loop() # 初始化请求处理器 api = APIHandler() frontend = FrontEndHandler() service = ServiceHandler() # 定义会话中间件 middlewares = [ session_middleware(EncryptedCookieStorage(config.secret_key)), ] # 初始化应用 app = aiohttp.web.Application(middlewares=middlewares, loop=loop) # 定义Jinja2模板位置 aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader(config.template_dir)) # 给应用添加路由 app.router.add_route('GET', '/', frontend.form) app.router.add_route('POST', '/', frontend.login) app.router.add_route('GET', '/kancolle', frontend.normal) app.router.add_route('GET', '/kcv', frontend.kcv) app.router.add_route('GET', '/flash', frontend.flash) app.router.add_route('GET', '/poi', frontend.poi) app.router.add_route('GET', '/connector', frontend.connector) app.router.add_route('GET', '/logout', frontend.logout) app.router.add_route('GET', '/kcsapi/{action:.+}', api.api) app.router.add_route('POST', '/kcsapi/{action:.+}', api.api) app.router.add_route('GET', '/kcs2/resources/world/{server:.+}_{size:[lst]}.png', api.world_image) app.router.add_route('POST', '/service/osapi', service.get_osapi) app.router.add_route('POST', '/service/flash', service.get_flash) app.router.add_static('/static', config.static_dir) app.router.add_static('/kcs', config.kcs_dir) app.router.add_static('/_kcs', config.kcs_dir) app_handlers = app.make_handler() # 启动OOI服务器 server = loop.run_until_complete( loop.create_server(app_handlers, host, port)) print('OOI serving on http://%s:%d' % server.sockets[0].getsockname()) try: loop.run_forever() except KeyboardInterrupt: pass finally: loop.run_until_complete(app_handlers.finish_connections(1.0)) server.close() loop.run_until_complete(server.wait_closed()) loop.run_until_complete(app.cleanup()) loop.close()
async def run_application(): logger = get_root_logger('elasticsearch-proxy') with logged(logger, 'Examining environment', []): env = normalise_environment(os.environ) port = env['PORT'] ip_whitelist = env['INCOMING_IP_WHITELIST'] staff_sso_client_base = env['STAFF_SSO_BASE'] staff_sso_client_id = env['STAFF_SSO_CLIENT_ID'] staff_sso_client_secret = env['STAFF_SSO_CLIENT_SECRET'] kibana_url_no_password = URL('http://127.0.0.1:5601') vcap_services = json.loads(env['VCAP_SERVICES']) es_uri = vcap_services['elasticsearch'][0]['credentials']['uri'] redis_uri = vcap_services['redis'][0]['credentials']['uri'] es_parsed = URL(es_uri) es_user = es_parsed.user es_password = es_parsed.password kibana_url = kibana_url_no_password.with_user(es_user).with_password( es_password) client_session = aiohttp.ClientSession( skip_auto_headers=['Accept-Encoding']) async def handle(request): url = kibana_url.with_path(request.url.path) request_body = await request.read() headers = { header: request.headers[header] for header in ['Kbn-Xsrf', 'Kbn-Version', 'Content-Type'] if header in request.headers } with logged( request['logger'], 'Elasticsearch request by (%s) to (%s) (%s) (%s) (%s)', [ request['me_profile']['email'], request.method, str(url), request.url.query, request_body, ], ): async with client_session.request( request.method, str(url), params=request.url.query, data=request_body, headers=headers, ) as response: response_body = await response.read() response_headers = { key: value for key, value in response.headers.items() if key != 'Transfer-Encoding' } return web.Response(status=response.status, body=response_body, headers=response_headers) redis_pool = await aioredis.create_pool(redis_uri) redis_storage = RedisStorage(redis_pool, max_age=60 * 60 * 24) with logged(logger, 'Creating listening web application', []): app = web.Application(middlewares=[ server_logger(logger), authenticate_by_ip(INCORRECT, ip_whitelist), session_middleware(redis_storage), authenticate_by_staff_sso(client_session, staff_sso_client_base, staff_sso_client_id, staff_sso_client_secret), ]) app.add_routes([ web.delete(r'/{path:.*}', handle), web.get(r'/{path:.*}', handle), web.post(r'/{path:.*}', handle), web.put(r'/{path:.*}', handle), web.head(r'/{path:.*}', handle), ]) class NullAccessLogger(aiohttp.abc.AbstractAccessLogger): # pylint: disable=too-few-public-methods def log(self, request, response, time): pass runner = web.AppRunner(app, access_log_class=NullAccessLogger) await runner.setup() site = web.TCPSite(runner, '0.0.0.0', port) await site.start()
def session_storage(self, app_config): self.assertIn('REDIS_SERVER', app_config) self.assertIn('REDIS_PORT', app_config) self.assertIn('SESSION_AGE', app_config) return session_middleware( SimpleCookieStorage(cookie_name='RH_SESSION'))