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