async def init_app():
cfg = Config()
pg_pool = await asyncpg.create_pool(cfg.DB_ADDRESS)
db_handler = DbHandler(pg_pool=pg_pool, cfg=cfg)
app = web.Application()
app.add_routes(make_routes_table())
app['cfg'] = cfg
app[cfg.DB_HANDLER] = db_handler
redis_pool = await aioredis.create_redis_pool(('localhost', 6379))
setup_session(app, RedisStorage(redis_pool, cookie_name='CURRENT_SESSION'))
async def dispose_pools(app):
redis_pool.close()
await redis_pool.wait_closed()
await pg_pool.close()
app.on_cleanup.append(dispose_pools)
app.middlewares.extend(middlewares)
mongo_client = AsyncIOMotorClient('localhost', 27017)
app[cfg.MONGO_DB] = mongo_client[cfg.MONGO_DB_NAME]
http_session = ClientSession()
app['http_session'] = http_session
async def close_http_session(app):
await http_session.close()
app.on_cleanup.append(close_http_session)
return app
async def init():
#App init
app = web.Application()
#Add full configs
app['config'] = setupConfig()
#Add routes
setupRoutes(app)
app['wslist'] = []
#Add static config
setupStatic(app)
#Jinja config
setupJinja(app)
#PostgreSQL init
app.db = await init_pg(app)
#Setup redis
REDIS_CONFIG = tuple(app['config']['redis'].values())
redis_pool = await aioredis.create_pool(REDIS_CONFIG, loop=loop)
setup(app, RedisStorage(redis_pool))
app['redis'] = await aioredis.create_redis(REDIS_CONFIG)
#ShutDown setups
app.on_shutdown.append(close_pg)
app.on_shutdown.append(close_redis)
return app
async def init_app(config):
app = web.Application()
app['config'] = config
setup_routes(app)
setup_middlewares(app)
app.on_startup.append(init_pg)
app.on_cleanup.append(close_pg)
#db_pool = await init_db(app)
redis_pool = await setup_redis(app)
setup_session(app, RedisStorage(redis_pool))
# needs to be after session setup because of `current_user_ctx_processor`
aiohttp_jinja2.setup(
app,
loader=jinja2.FileSystemLoader(str(BASE_DIR / 'ba' / 'templates')),
context_processors=[current_user_ctx_processor],
)
setup_security(app, SessionIdentityPolicy(), DBAuthorizationPolicy(app))
log.debug(app['config'])
return app
async def init(loop):
redis_pool = await create_pool(('localhost', 6379))
dbengine = await create_engine(user=config['postgres']['user'],
password=config['postgres']['password'],
database=config['postgres']['database'],
host=config['postgres']['host'])
app = web.Application()
app.telegram_token = config['telegram_token']
app.API_URL = API_URL
app.dbengine = dbengine
#app.logger=AccessLogger()
setup_session(app, RedisStorage(redis_pool))
setup_security(app, SessionIdentityPolicy(),
DBAuthorizationPolicy(dbengine))
web_handlers = Web()
web_handlers.configure(app)
#aiohttp_jinja2.setup(app,
# loader=jinja2.FileSystemLoader(str(base_dir / 'robo_app' / 'templates')))
aiohttp_jinja2.setup(app,
loader=jinja2.FileSystemLoader(str(TEMPLATES_ROOT)))
handler = app.make_handler()
srv = await loop.create_server(handler, '127.0.0.1', 8082)
print('Server started at http://127.0.0.1:8082')
return srv, app, handler
async def create_app(loop):
""" Prepare application """
redis_pool = await aioredis.create_pool(settings.REDIS_CON, loop=loop)
middlewares = [
session_middleware(RedisStorage(redis_pool)), json_response,
status_initial, request_checker, request_user_middleware
]
# init application
app = web.Application(loop=loop, middlewares=middlewares)
app.redis_pool = redis_pool
app.wslist = {}
jinja_env = aiohttp_jinja2.setup(
app,
loader=jinja2.FileSystemLoader(settings.TEMPLATE_DIR),
context_processors=[aiohttp_jinja2.request_processor],
)
jinja_env.globals.update(tags)
# db conn
database.init(**settings.DATABASE)
app.database = database
app.database.set_allow_sync(False)
app.objects = peewee_async.Manager(app.database)
app.database.connect()
# make routes
setup_routes(app)
app.router.add_static('/static', settings.STATIC_DIR, name='static')
app.logger = logger
handler = app.make_handler(access_log=logger)
serv_generator = loop.create_server(handler, settings.HOST, settings.PORT)
return serv_generator, handler, app
async def make_app():
parser = argparse.ArgumentParser(
description='Python CAS Gateway',
formatter_class=argparse.ArgumentDefaultsHelpFormatter
)
parser.add_argument('--redis-url', help='Redis URL', default='redis://127.0.0.1:6379/0')
parser.add_argument('--timeout', type=int, help='Request timeout', default=10)
parser.add_argument('--bind-host', help='Address to bind to', default='0.0.0.0')
parser.add_argument('--bind-port', type=int, help='Port to bind to', default='8000')
parser.add_argument('--cas-version', type=int, help='CAS version in use', default=3)
parser.add_argument('--chunk-size', type=int, help='Chunk size for streaming responses back to the client',
default=1024*4)
parser.add_argument('--require-attribute', help='Require the given CAS attribute to be present and '
'not set to an empty string. Requires CAS version 3.')
required_named = parser.add_argument_group('required named arguments')
required_named.add_argument('--backend-url', help='URL to the backend to be proxied (e.g. http://myhost.com:8888)',
required=True)
required_named.add_argument('--cas-url', help='URL to the CAS server', required=True)
args = parser.parse_args()
app = web.Application()
print("Configuring...")
app.settings = type('Settings', (object,), dict(
backend_url=URL(args.backend_url),
cas_url=URL(args.cas_url),
redis_url=URL(args.redis_url),
timeout=args.timeout,
bind_host=args.bind_host,
bind_port=args.bind_port,
# aiohttp_cas was this as a string
cas_version=str(args.cas_version),
require_attribute=args.require_attribute,
))()
print("Connecting to redis...")
pool = await create_pool(
(app.settings.redis_url.host or '127.0.0.1', app.settings.redis_url.port or 6379),
db=int(app.settings.redis_url.path.strip('/') or 0),
create_connection_timeout=10,
password=app.settings.redis_url.password,
)
await remotes_setup(app, XForwardedRelaxed())
session_setup(app, RedisStorage(pool))
u = app.settings.cas_url
cas_setup(
app=app,
host='{}:{}'.format(u.host, u.port) if u.port != 80 else u.host,
host_prefix=app.settings.cas_url.path,
version=app.settings.cas_version,
host_scheme=app.settings.cas_url.scheme
)
app.router.add_route('GET', '/cas-gateway-ready', ready_check)
app.router.add_route('*', '/{tail:.*}', handle)
return app
async def make_app():
app = web.Application()
app['config'] = config
app['session_name'] = 'VODOMAT_SESSION'
app.on_startup.extend([init_db, init_db_redis])
app.on_cleanup.extend([close_db, close_db_redis])
app.add_routes(routes)
db_pool = await init_db(app)
redis_pool = await init_db_redis(app)
setup_session(
app,
RedisStorage(redis_pool, cookie_name=app['session_name'],
max_age=3600))
setup_security(app, SessionIdentityPolicy(),
DBAuthorizationPolicy(db_pool))
aiohttp_jinja2.setup(
app,
loader=jinja2.FileSystemLoader('{}/templates'.format(
os.path.dirname(__file__))),
filters={'datetime_from_timestamp': datetime_from_timestamp_filter},
context_processors=[current_user_context_processor],
)
setup_middlewares(app)
aiojobs.aiohttp.setup(app)
return app
async def init_app():
"""
Initialize app
"""
redis_pool = await aioredis.create_pool(settings.REDIS, loop=loop)
# setup middlewares
middlewares = [
session_middleware(RedisStorage(redis_pool)),
request_user_middleware
]
app = web.Application(middlewares=middlewares)
app.redis_pool = redis_pool
await db.set_bind(settings.DATABASE_URL)
# Create tables
await db.gino.create_all()
app.router.add_static(settings.STATIC_URL, settings.STATIC_DIR, name='static')
app.db = db
# Jinja(template system) setup
jinja_env = aiohttp_jinja2.setup(
app, loader=jinja2.FileSystemLoader(settings.TEMPLATE_DIR),
context_processors=[aiohttp_jinja2.request_processor], )
app.add_routes(routes)
app.wslist = {}
return app
async def init_app(config, loop):
app = web.Application()
app['config'] = config
app['websockets'] = {}
app.on_shutdown.append(shutdown)
db_pool = await init_db(app)
mysql_pool = await setup_mysql(app, loop)
mongo_pool = await setup_mongo(app, loop)
redis_pool = await setup_redis(app)
ws_handler = WsHandler(redis_pool, mongo_pool, mysql_pool)
setup_routes(app, ws_handler)
setup_session(app, RedisStorage(redis_pool))
# needs to be after session setup because of `current_user_ctx_processor`
aiohttp_jinja2.setup(
app,
loader=jinja2.PackageLoader(PACKAGE_NAME),
context_processors=[current_user_ctx_processor],
)
setup_security(app, SessionIdentityPolicy(),
DBAuthorizationPolicy(db_pool))
return app
async def init(loop):
app = web.Application()
redis = await create_pool(('localhost', 6379))
setup(app, RedisStorage(redis, cookie_name="testmyid", max_age=3))
app.router.add_route('GET', '/', handler)
srv = await loop.create_server(app.make_handler(), '0.0.0.0', 8084)
return srv
def __init__(self,
type: str = "redis",
name: str = "AIOHTTP_SESSION",
backends: list = [],
**kwargs):
async def make_redis_pool(url, **kwargs: dict):
kwargs['timeout'] = 1
return await aioredis.create_pool(url, **kwargs)
if type == "redis":
try:
url = kwargs["url"]
del kwargs["url"]
except KeyError:
raise Exception(
"Error: For Redis Storage, you need session URL")
self._pool = asyncio.get_event_loop().run_until_complete(
make_redis_pool(url, **kwargs))
self._session_type = RedisStorage(self._pool, cookie_name=name)
elif type == "cookie":
try:
secret_key = kwargs["secret_key"]
except KeyError:
fernet_key = fernet.Fernet.generate_key()
secret_key = base64.urlsafe_b64decode(fernet_key)
self._session_type = EncryptedCookieStorage(secret_key,
cookie_name=name)
# TODO: type memcached
# configure backends
for backend in backends:
if backend == "hosts":
obj = auth_hosts()
elif backend == "session":
obj = auth_users()
self._backends.append(obj)
async def init_app(config):
app = web.Application()
app['config'] = config
setup_routes(app)
db_pool = await init_db(app)
redis_pool = await setup_redis(app)
setup_session(app, RedisStorage(redis_pool))
# needs to be after session setup because of `current_user_ctx_processor`
aiohttp_jinja2.setup(
app,
loader=jinja2.PackageLoader(PACKAGE_NAME),
context_processors=[current_user_ctx_processor],
)
setup_security(app, SessionIdentityPolicy(),
DBAuthorizationPolicy(db_pool))
log.debug(app['config'])
return app
async def create_app():
""" Prepare application """
redis_pool = await aioredis.create_pool(settings.REDIS_CON)
middlewares = [
session_middleware(RedisStorage(redis_pool)), request_user_middleware
]
if settings.DEBUG:
middlewares.append(aiohttp_debugtoolbar.middleware)
# init application
app = web.Application(middlewares=middlewares)
app.redis_pool = redis_pool
app.ws_list = {}
jinja_env = aiohttp_jinja2.setup(
app,
loader=jinja2.FileSystemLoader(settings.TEMPLATE_DIR),
context_processors=[aiohttp_jinja2.request_processor],
)
jinja_env.globals.update(tags)
if settings.DEBUG:
aiohttp_debugtoolbar.setup(app, intercept_redirects=False)
# db conn
database.init(**settings.DATABASE)
app.database = database
app.database.set_allow_sync(False)
app.objects = peewee_async.Manager(app.database)
# make routes
from urls import routes
for route in routes:
app.router.add_route(**route)
app.router.add_static('/static', settings.STATIC_DIR, name='static')
app.logger = logger
return app
def __init__(self, *args, config=None, routes=[], **kwargs):
self.logger = logging.getLogger('ampythomine')
self.jinja = aiohttp_jinja2
super().__init__(*args, **kwargs)
self.jinja.setup(self,
loader=jinja2.FileSystemLoader(
os.path.abspath(config['TEMPLATE_PATH'])))
for route in routes:
self.router.add_route(route[0], route[1], route[2])
# Database init
db_backend = importlib.import_module(config['DATABASE']['BACKEND'])
getattr(db_backend, db_backend.__backend__)().init(config['DATABASE'])
# Auth init
# TODO: подтягивать бэкэнд для хранения сессий из конфига
self.redis_pool = RedisPool(('localhost', 6379),
db=0,
password=None,
ssl=None,
encoding=None,
minsize=1,
maxsize=10,
commands_factory=Redis,
loop=None)
setup_session(self, RedisStorage(self.redis_pool))
auth_backend = importlib.import_module(config['AUTH']['BACKEND'])
setup_security(self, IdentityPolicy(),
getattr(auth_backend, auth_backend.__auth_policy__)())
def create_app(handler, redis, max_age=None,
key_factory=lambda: uuid.uuid4().hex):
middleware = session_middleware(
RedisStorage(redis, max_age=max_age, key_factory=key_factory))
app = web.Application(middlewares=[middleware])
app.router.add_route('GET', '/', handler)
return app
async def init(loop):
# Redis
redis_opts = (config['redis']['host'], config['redis']['port'])
redis_pool = await create_pool(redis_opts)
# SQLAlchemy
sa_cfg = config['postgres']
dbengine = await create_engine(database=sa_cfg.get('database', 'aiohttp_security'),
user=sa_cfg.get('user', 'admin'))
app = web.Application()
app.db_engine = dbengine
# Auth
setup_session(app, RedisStorage(redis_pool))
setup_security(app,
SessionIdentityPolicy(),
DBAuthorizationPolicy(dbengine))
aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader('./templates'))
setup_routes(app)
setup_middlewares(app)
handler = app._make_handler()
app_conf = config['app']
srv = await loop.create_server(handler,
app_conf['host'],
app_conf['port'])
print('Server started at http://{}:{}'.format(str(app_conf['host']), str(app_conf['port'])))
return srv, app, handler
async def setup_session(app):
conf = app["config"]["redis"]
redis_address = "redis://" + conf["host"] + ":" + str(conf["port"])
redis_pool = await aioredis.create_redis_pool(redis_address)
app["session_pool"] = redis_pool
storage = RedisStorage(redis_pool)
sessionsetup(app, storage)
def setup(app_config):
loop = asyncio.get_event_loop()
redis_pool = loop.run_until_complete(
make_redis_pool(app_config['REDIS_SERVER'], app_config['REDIS_PORT']))
return session_middleware(
RedisStorage(redis_pool,
cookie_name='RH_SESSION',
max_age=int(app_config['SESSION_AGE'])))
async def _init_app(loop=None):
loop = loop or asyncio.get_event_loop()
app = web.Application(loop=loop, middlewares=[middleware_404])
aiohttp_jinja2.setup(app,
loader=jinja2.FileSystemLoader('httplib/template'))
setup_router(app)
redis = await create_pool(('localhost', 6379))
setup(app, RedisStorage(redis, cookie_name="aiosession", max_age=3600))
return app
def redis_connect(app):
async def make_redis_pool():
redis_address = (os.getenv('REDIS_HOST',
'redis'), os.getenv('REDIS_PORT', '6379'))
return await aioredis.create_redis_pool(redis_address, timeout=1)
loop = asyncio.get_event_loop()
redis_pool = loop.run_until_complete(make_redis_pool())
storage = RedisStorage(redis_pool)
return storage, redis_pool
async def session_middleware(request, handler):
"""Wrapper to Session Middleware factory.
"""
# Do the trick, by passing app & handler back to original session
# middleware factory. Do not forget to await on results here as original
# session middleware factory is also awaitable.
app = request.app
storage = RedisStorage(app['redis'], httponly=False)
middleware = session_middleware_(storage)
return await middleware(request, handler)
async def init_app(app):
await init_db(app)
await init_redis(app)
setup_security(app, SessionIdentityPolicy(),
DBAuthorizationPolicy(app['db']))
setup_session(app, RedisStorage(app['redis']))
await set_redis_init_values(app)
def run_server(host, port):
loop = asyncio.get_event_loop()
redis_pool = loop.run_until_complete(create_pool(('localhost', 6379)))
client = motor_asyncio.AsyncIOMotorClient('localhost', 27017)
# Initiate main application
app = web.Application(loop=loop, logger=server_logger)
setup_routes(app, 'main')
setup_static(app)
aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader('templates/'))
# Initiate sub-applications
admin = web.Application(loop=loop, logger=server_logger)
setup_routes(admin, 'admin')
aiohttp_jinja2.setup(admin, loader=jinja2.FileSystemLoader('templates/'))
setup_session(
admin,
RedisStorage(redis_pool,
max_age=COOKIE_AGE,
cookie_name=COOKIE_AUTH_NAME))
setup_security(admin, SessionIdentityPolicy(), DBAuthorizationPolicy())
app.add_subapp('/admin/', admin)
api = web.Application(loop=loop, logger=server_logger)
setup_routes(api, 'api')
app.add_subapp('/api/', api)
# Session and security
setup_session(
app,
RedisStorage(redis_pool,
max_age=COOKIE_AGE,
cookie_name=COOKIE_AUTH_NAME))
setup_security(app, SessionIdentityPolicy(), DBAuthorizationPolicy())
# Run server
web.run_app(app=app,
host=host,
port=port,
access_log=access_logger,
access_log_format=
'%a %l %u %t "%r" %s %b "%{Referrer}i" "%{User-Agent}i"')
async def init_pre(self, app):
'''
启动前的初始化工作
'''
await mysql.initpool(loop=self.loop)
await redis.init_pool(loop=self.loop)
redis_pool = redis.get_pool()
storage = RedisStorage(redis_pool)
setup(app, storage)
app.middlewares.append(response_factory) #一定要放在session的后面 先执行这个
async def app_init(app):
app['client_queues'] = {}
app['redis_addr'] = ('localhost', 6379)
app['redis'] = await aioredis.create_redis_pool(app['redis_addr'], db=0)
sess_storage = RedisStorage(
await aioredis.create_redis_pool(app['redis_addr'], db=1),
max_age=3600,
)
setup_session(app, sess_storage)
app['distributer'] = asyncio.create_task(chat_distribute(app))
def setup(app_config):
# Monkey patch aiohttp_session.py Session.__init__ method to remove PR 331 as above
Session.__init__ = aiohttp_session_pr_331_rollback
loop = get_event_loop()
redis_pool = loop.run_until_complete(
make_redis_pool(app_config['REDIS_SERVER'], app_config['REDIS_PORT']))
return session_middleware(
RedisStorage(redis_pool,
cookie_name='FSDRUI_SESSION',
max_age=int(app_config['SESSION_AGE'])))
def create_app(
handler: _Handler,
redis: aioredis.commands.Redis,
max_age: Optional[int] = None,
key_factory: Callable[[],
str] = lambda: uuid.uuid4().hex) -> web.Application:
middleware = session_middleware(
RedisStorage(redis, max_age=max_age, key_factory=key_factory))
app = web.Application(middlewares=[middleware])
app.router.add_route('GET', '/', handler)
return app
async def redis(app: web.Application) -> None:
config = app["config"]["redis"]
app["redis"] = await create_pool((config["host"], config["port"]))
setup_session(app, RedisStorage(app["redis"])) # TODO move to init_app
yield
app["redis"].close()
await app["redis"].wait_closed()
def init_app(
loop: asyncio.AbstractEventLoop,
redis_pool: Optional[aioredis.ConnectionsPool] = None,
) -> web.Application:
app = web.Application(loop=loop)
app['config'] = settings
if not redis_pool:
redis_pool = loop.run_until_complete(make_redis_pool())
storage = RedisStorage(redis_pool, cookie_name='sesssionid')
setup(app, storage)
async def dispose_redis_pool(app: web.Application) -> None:
if redis_pool is not None:
redis_pool.close()
await redis_pool.wait_closed()
aiohttp_jinja2.setup(
app,
loader=jinja2.FileSystemLoader(str(BASE_DIR / 'its_on' /
'templates'), ),
)
app['static_root_url'] = '/static'
app.on_startup.append(init_pg)
app.on_cleanup.append(close_pg)
app.on_cleanup.append(dispose_redis_pool)
setup_security(app, SessionIdentityPolicy(session_key='sessionkey'),
DBAuthorizationPolicy(app))
cors_config = {
origin:
aiohttp_cors.ResourceOptions(allow_methods=['GET', 'OPTIONS'],
allow_headers=settings.CORS_ALLOW_HEADERS)
for origin in settings.CORS_ALLOW_ORIGIN
}
cors = aiohttp_cors.setup(app, defaults=cors_config)
setup_routes(app, BASE_DIR, cors)
setup_aiohttp_apispec(app=app,
title='Flags Bestdoctor',
version='v1',
url='/api/docs/swagger.json',
swagger_path='/api/docs',
static_path='/assets/swagger',
request_data_name='validated_data')
setup_middlewares(app)
setup_cache(app)
return app
async def init_security(app):
redis_pool = await create_pool(
(app['config']['redis']['host'], app['config']['redis']['port']))
async def close_redis(app):
redis_pool.close()
await redis_pool.wait_closed()
app.on_cleanup.append(close_redis)
setup_session(app, RedisStorage(redis_pool))
setup_security(app, SessionIdentityPolicy(),
DBAuthorizationPolicy(app['db']))
