def init_app():
middleware = session_middleware(SimpleCookieStorage())
app = web.Application(middlewares=[middleware])
# create a global dict of identity -> (folder object, active ws connections)
cache = {}
app['folders'] = cache
app.on_startup.append(model.startup)
app.on_shutdown.append(shutdown)
policy = aiohttp_security.SessionIdentityPolicy()
aiohttp_security.setup(app, policy, SimpleAuthorizationPolicy(cache))
app.add_routes([
web.get('/ws', ws),
web.post('/signup', signup),
web.post('/login', login),
web.post('/logout', logout),
web.get('/auth', allow),
web.post('/files', upload),
web.get('/files', download),
# below are static files that should be served by NGINX
web.get(
'/', index,
name='index'), # static does not support redirect / to /index.html
web.get('/index.html', index), # serve a single static file with auth
web.static('/', os.path.join(dir_path, 'static'), name='static')
]) # handle static files such as html, js, css
return app
def init():
key = bytes(os.environ['SESSION_SECRET'], 'utf-8')
middleware = session_middleware(
EncryptedCookieStorage(secret_key=key, cookie_name="SSID"))
auth_middleware = site_auth_middleware_factory(login_handler)
app = web.Application(middlewares=[
middleware,
csrf_middleware,
ident_middleware,
auth_middleware,
])
policy = SessionIdentityPolicy()
setup(app, policy, MainAuthorizationPolicy())
app.add_routes(routes)
aiohttp_jinja2.setup(app,
context_processors=[
aiohttp_jinja2.request_processor,
],
loader=jinja2.PackageLoader('admin', 'template'))
app.router.add_static('/static/',
'%s/static/' % pathlib.Path(__file__).parent,
show_index=True,
append_version=True,
name='static')
app['static_root_url'] = '/static'
return app
async def init(loop):
# setup application and extensions
app = web.Application(loop=loop)
aiohttp_jinja2.setup(
app, loader=jinja2.FileSystemLoader(str(TEMPLATES_ROOT)))
# load config from yaml file
conf = load_config(str(PROJ_ROOT / 'config' / 'dev.yml'))
# create connection to the database
pg = await init_postgres(conf['postgres'], loop)
async def close_pg(app):
pg.close()
await pg.wait_closed()
# setup dummy auth and identity
ident_policy = DummyTokenIdentityPolicy()
auth_policy = DummyAuthPolicy(username="******", password="******")
aiohttp_security.setup(app, ident_policy, auth_policy)
# setup admin views
admin_config = str(PROJ_ROOT / 'static' / 'js')
setup_admin(app, pg, admin_config)
app.on_cleanup.append(close_pg)
# setup views and routes
handler = SiteHandler(pg)
setup_routes(app, handler, PROJ_ROOT)
host, port = conf['host'], conf['port']
return app, host, port
def setup_security(app, permissions=None):
# setup dummy auth and identity
ident_policy = DummyTokenIdentityPolicy()
auth_policy = DummyAuthPolicy(username="******",
password="******",
permissions=permissions)
aiohttp_security.setup(app, ident_policy, auth_policy)
async def init(loop):
# load config from yaml file
conf = load_config(str(PROJ_ROOT / 'config' / 'dev.yml'))
# setup application and extensions
app = web.Application(loop=loop)
pg = await setup_pg(app, conf, loop)
# init modules
aiohttp_jinja2.setup(
app, loader=jinja2.FileSystemLoader(str(TEMPLATES_ROOT)))
# 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, pg, admin_config)
# setup views and routes
handler = SiteHandler(pg)
add_route = app.router.add_route
add_route('GET', '/', handler.index)
app.router.add_static('/static', path=str(PROJ_ROOT / 'static'))
host, port = conf['host'], conf['port']
return app, host, port
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 setup(app):
log.debug("Setting up %s ...", __name__)
# Once user is identified, an identity string is created for that user
identity_policy = SessionIdentityPolicy()
# TODO: create basic/bearer authentication policy based on tokens instead of cookies!!
authorization_policy = DBAuthorizationPolicy(app)
aiohttp_security.setup(app, identity_policy, authorization_policy)
async def init(loop):
app = web.Application(loop=loop)
app.logger = config_logger()
if DEBUG:
# Configure default CORS settings.
cors = aiohttp_cors.setup(app,
defaults={
"*":
aiohttp_cors.ResourceOptions(
allow_credentials=True,
expose_headers="*",
allow_headers="*",
)
})
# Configure CORS on all routes.
for route, route_info in routes.routes.items():
resource = cors.add(
app.router.add_resource(route_info[1], name=route))
cors.add(resource.add_route(route_info[0], route_info[2]))
else:
# route part
for route, route_info in routes.routes.items():
app.router.add_route(route_info[0],
route,
route_info[1],
name=route_info[2])
# end route part
# Configure Jinja2
aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader(TEMPLATE_PATH))
# Add static
if DEBUG:
app.router.add_static(STATIC_URL, STATIC_PATH, name='static')
secret_key = base64.urlsafe_b64decode(COOKIE_SECRET.encode("utf8"))
aiohttp_session.setup(
app,
EncryptedCookieStorage(secret_key,
cookie_name=PROJECT_PREFIX.upper(),
httponly=False))
# Setup security
aiohttp_security.setup(app, SessionIdentityPolicy(),
DictionaryAuthorizationPolicy(USERS))
app.middlewares.append(login_required_middleware)
# end setup security
app.on_shutdown.append(on_shutdown)
return app, app.logger
def setup_admin(app, pg, admin_config_path):
admin_config_path = str(PROJ_ROOT / 'static' / 'js')
resources = (PGResource(pg, db.question, url='question'),
PGResource(pg, db.choice, url='choice'))
admin = aiohttp_admin.setup(app, admin_config_path, resources=resources)
# setup dummy auth and identity
ident_policy = DummyTokenIdentityPolicy()
auth_policy = DummyAuthPolicy(username="******", password="******")
aiohttp_security.setup(admin, ident_policy, auth_policy)
return admin
def create_server(self):
app = web.Application(loop=self.loop)
setup(app, CookiesIdentityPolicy(), Autz())
port = self.find_unused_port()
self.handler = app.make_handler(debug=False, keep_alive_on=False)
srv = yield from self.loop.create_server(self.handler, '127.0.0.1',
port)
url = "http://127.0.0.1:{}".format(port)
self.srv = srv
return app, srv, url
def setup_security(app: web.Application):
# Once user is identified, an identity string is created for that user
identity_policy = SessionIdentityPolicy()
# TODO: limitations is that it cannot contain checks need to be added here
access_model = RoleBasedAccessModel.from_rawdata(ROLES_PERMISSIONS)
# TODO: create basic/bearer authentication policy based on tokens instead of cookies!!
# when you do that, also update the openapi to reflect that
authorization_policy = AuthorizationPolicy(app, access_model)
aiohttp_security.setup(app, identity_policy, authorization_policy)
def create_server(self):
app = web.Application(loop=self.loop)
setup(app, CookiesIdentityPolicy(), Autz())
port = self.find_unused_port()
self.handler = app.make_handler(
debug=False, keep_alive_on=False)
srv = yield from self.loop.create_server(
self.handler, '127.0.0.1', port)
url = "http://127.0.0.1:{}".format(port)
self.srv = srv
return app, srv, url
def setup_admin(app, mongo):
admin_config_path = str(PROJ_ROOT / 'static' / 'js')
m = mongo
resources = (MotorResource(m.user, db.user, url="user"),
MotorResource(m.message, db.message, url="message"),
MotorResource(m.follower, db.follower, url="follower"))
admin = aiohttp_admin.setup(app, admin_config_path, resources=resources)
# setup dummy auth and identity
ident_policy = DummyTokenIdentityPolicy()
auth_policy = DummyAuthPolicy(username="******", password="******")
aiohttp_security.setup(admin, ident_policy, auth_policy)
return admin
def setup_admin(app, pg):
admin = aiohttp_admin._setup(
app,
title='Blog admin',
schema=schema,
db=pg,
)
# setup dummy auth and identity
ident_policy = DummyTokenIdentityPolicy()
auth_policy = DummyAuthPolicy(username="******", password="******")
aiohttp_security.setup(admin, ident_policy, auth_policy)
app.add_subapp('/admin/', admin)
def setup_admin(app, pg):
admin = aiohttp_admin._setup(
app,
title='Files admin',
schema=schema,
db=pg,
)
# setup dummy auth and identity
ident_policy = DummyTokenIdentityPolicy()
auth_policy = DummyAuthPolicy(username=app['config']['aiohttp-admin']['user'],
password=app['config']['aiohttp-admin']['password'])
aiohttp_security.setup(admin, ident_policy, auth_policy)
app.add_subapp('/admin', admin)
def run():
application = Application()
application.router.add_routes(routes)
aiohttp_jinja2.setup(application, loader=FileSystemLoader(f"{APPLICATION_DIR}/static"))
aiohttp_session.setup(application, SimpleCookieStorage())
aiohttp_security.setup(application, SessionIdentityPolicy(), DatabaseAuthorizationPolicy())
# do load file configuraion
configuration.load()
# do load database configuraion
dictionary.database.set_configuration(
host=configuration['database']['host'],
port=configuration['database']['port'],
name=configuration['database']['name'],
user=configuration['database']['user'],
password=configuration['database']['password']
)
return run_app(application, host='0.0.0.0', port=configuration['application']['business']['listen'])
def setup(app):
aiohttp_security.setup(app, SessionIdentityPolicy(), SimpleAuthPolicy())
def setup_security(app):
setup(app, CookiesIdentityPolicy(), AuthorizationPolicy(mongo))
import auth
import save
from planarally import PlanarAlly
FILE_DIR = os.path.dirname(os.path.realpath(__file__))
os.chdir(FILE_DIR)
SAVE_FILE = "planar.save"
save.check_save(SAVE_FILE)
PA = PlanarAlly(SAVE_FILE)
sio = socketio.AsyncServer(async_mode='aiohttp', engineio_logger=False)
app = web.Application()
app["AuthzPolicy"] = auth.ShelveDictAuthorizationPolicy(SAVE_FILE)
aiohttp_security.setup(app, SessionIdentityPolicy(), app['AuthzPolicy'])
aiohttp_session.setup(app,
EncryptedCookieStorage(app['AuthzPolicy'].secret_token))
aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader('templates'))
sio.attach(app)
def nested_dict_update(d, u):
for k, v in u.items():
if isinstance(v, collections.Mapping):
d[k] = nested_dict_update(d.get(k, {}), v)
else:
d[k] = v
return d
def setup_security(app):
# setup dummy auth and identity
ident_policy = DummyTokenIdentityPolicy()
auth_policy = DummyAuthPolicy(username="******", password="******")
aiohttp_security.setup(app, ident_policy, auth_policy)
def setup_app(middlewares: Iterable[Callable] = ()) -> web.Application:
app = web.Application(middlewares=middlewares)
app["AuthzPolicy"] = auth.AuthPolicy()
aiohttp_security.setup(app, SessionIdentityPolicy(), app["AuthzPolicy"])
aiohttp_session.setup(app, EncryptedCookieStorage(auth.get_secret_token()))
return app
def setup_security(app: web.Application) -> None:
aiohttp_security.setup(
app,
SessionIdentityPolicy(),
DbAuthorizationPolicy(app['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)
async def init(args):
LOG.info("Starting DEEP Dashboard...")
runtime_dir = pathlib.Path(CONF.runtime_dir)
runtime_dir.mkdir(parents=True, exist_ok=True)
app = web.Application(debug=True)
app.runtime_dir = runtime_dir
lockutils.set_defaults(runtime_dir)
tpl_path = pathlib.Path(__file__).parent / "templates"
aiohttp_jinja2.setup(
app,
context_processors=[aiohttp_session_flash.context_processor],
loader=jinja2.FileSystemLoader(tpl_path)
)
app.iam_client = auth.get_iam_client()
base.routes.static('/static', CONF.static_path, name="static")
app.add_routes(base.routes)
app.add_routes(deployments.routes)
app.add_routes(modules.routes)
if CONF.cache.memcached_ip:
loop = asyncio.get_event_loop()
mc = aiomcache.Client(CONF.cache.memcached_ip,
CONF.cache.memcached_port,
loop=loop)
sess_storage = aiohttp_session.memcached_storage.MemcachedStorage(
mc,
cookie_name='DEEPDASHBOARD_M'
)
aiocache.caches.add('default', {
'cache': "aiocache.MemcachedCache",
'endpoint': CONF.cache.memcached_ip,
'port': CONF.cache.memcached_port,
})
else:
LOG.warning("Not using memcached, unexpected behaviour when running "
"more than one worker!")
# secret_key must be 32 url-safe base64-encoded bytes
fernet_key = fernet.Fernet.generate_key()
secret_key = base64.urlsafe_b64decode(fernet_key)
sess_storage = aiohttp_session.cookie_storage.EncryptedCookieStorage(
secret_key,
cookie_name='DEEPDASHBOARD_E'
)
aiocache.caches.add('default', {
'cache': "aiocache.SimpleMemoryCache",
})
aiohttp_session.setup(app, sess_storage)
policy = aiohttp_security.SessionIdentityPolicy()
aiohttp_security.setup(app, policy, auth.IamAuthorizationPolicy())
app.middlewares.append(meta_middleware)
app.middlewares.append(aiohttp_session_flash.middleware)
app.middlewares.append(auth.auth_middleware)
app.middlewares.append(error_middleware)
app.modules = {}
cache = aiocache.caches.get("default")
app.cache = collections.namedtuple(
"Cache",
["modules", "tosca_templates"],
defaults=[CacheManager(cache, "modules"),
CacheManager(cache, "tosca")]
)()
app.scheduler = await aiojobs.create_scheduler()
app.pool = concurrent.futures.ThreadPoolExecutor()
app.on_startup.append(deep_oc.download_catalog)
app.on_startup.append(deep_oc.load_catalog)
return app
