def create_webapp(config, messages_service):
webapp = web.Application(
middlewares=[timer_middleware, error_middleware],
debug=config['debug_mode'],
logger=logger
)
x_forwarded = XForwardedRelaxed(num=0) # num=0 is a hack to get the first
ensure_future(x_forwarded.setup(webapp))
prefix = config['prefix']
webapp.router.add_get(prefix + '/{channel}', get_messages)
webapp.router.add_post(prefix + '/{channel}', webhook_handler)
webapp['messages'] = messages_service
return webapp
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 test_x_forwarded_relaxed_multiple_host(aiohttp_client):
async def handler(request):
return web.Response()
app = web.Application()
app.router.add_get('/', handler)
await _setup(app, XForwardedRelaxed())
cl = await aiohttp_client(app)
resp = await cl.get('/', headers=[('X-Forwarded-For', '10.10.10.10'),
('X-Forwarded-Proto', 'http'),
('X-Forwarded-Host', 'example.org'),
('X-Forwarded-Host', 'example.com')])
assert resp.status == 400
def make_app():
handler = Handler()
handler.load_data(path=settings.PROJECT_ROOT / 'data')
app = web.Application(middlewares=[
XForwardedRelaxed().middleware,
blacklist_middleware,
])
setup_routes(app, handler)
app.cleanup_ctx.append(heartbeat_ctx)
return app
def __init__(self, port, logs=None):
# Build Web App
self.port = port
self.logs = logs
self.webapp = web.Application(middlewares=[
# Just in case someone wants to use it behind a reverse proxy
# Not sure why someone will want to do that though
XForwardedRelaxed().middleware,
# Handle unexpected and HTTP exceptions
self._middleware_exceptions,
# Handle media type validation
self._middleware_media_type,
# Handle schema validation
self._middleware_schema,
])
self.webapp.router.add_get('/api/logs', self.api_logs)
self.webapp.router.add_post('/api/config', self.api_config)
self.webapp.router.add_post('/api/push', self.api_push)
self.webapp.router.add_post('/api/message', self.api_message)
# Enable CORS in case someone wants to build a web agent
self.cors = CorsConfig(
self.webapp, defaults={
'*': ResourceOptions(
allow_credentials=True,
expose_headers='*',
allow_headers='*',
)
}
)
for route in self.webapp.router.routes():
self.cors.add(route)
# Create task for the push hearbeat
event_loop = get_event_loop()
self.timestamp = None
self.heartbeat = event_loop.create_task(self._check_last_timestamp())
# Build Terminal UI App
self.ui = UIManager()
self.tuiapp = MainLoop(
self.ui.topmost,
pop_ups=True,
palette=self.ui.palette,
event_loop=AsyncioEventLoop(loop=event_loop),
)
async def test_x_forwarded_relaxed_no_forwards(test_client):
async def handler(request):
url = cl.make_url('/')
host = url.host + ':' + str(url.port)
assert request.host == host
assert request.scheme == 'http'
assert not request.secure
assert request.remote == '127.0.0.1'
return web.Response()
app = web.Application()
app.router.add_get('/', handler)
await _setup(app, XForwardedRelaxed())
cl = await test_client(app)
resp = await cl.get('/')
assert resp.status == 200
async def test_x_forwarded_relaxed_ok(aiohttp_client):
async def handler(request):
assert request.host == 'example.com'
assert request.scheme == 'https'
assert request.secure
assert request.remote == '10.10.10.10'
return web.Response()
app = web.Application()
app.router.add_get('/', handler)
await _setup(app, XForwardedRelaxed())
cl = await aiohttp_client(app)
resp = await cl.get('/', headers={'X-Forwarded-For': '10.10.10.10',
'X-Forwarded-Proto': 'https',
'X-Forwarded-Host': 'example.com'})
assert resp.status == 200
async def serve(self, endpoint):
app = aiohttp.web.Application()
app.add_routes([
aiohttp.web.get("/", self.serve_index),
aiohttp.web.get("/vgm", self.serve_vgm),
])
try:
from aiohttp_remotes import XForwardedRelaxed, setup as setup_remotes
await setup_remotes(app, XForwardedRelaxed())
except ImportError:
self._logger.warning("aiohttp_remotes not installed; X-Forwarded-For will not be used")
runner = aiohttp.web.AppRunner(app,
access_log_format='%a(%{X-Forwarded-For}i) "%r" %s "%{Referer}i" "%{User-Agent}i"')
await runner.setup()
site = aiohttp.web.TCPSite(runner, *endpoint.split(":", 2))
await site.start()
await asyncio.Future()
async def app_factory(*args) -> web.Application: # pylint: disable=unused-argument
app = web.Application(middlewares=[
ForwardedRelaxed().middleware,
XForwardedRelaxed().middleware,
request_context_middleware,
])
app.update( # pylint: disable=no-member
subapps={},
client_session=None, # populated via signal
scheduler=None, # populated via signal
redis=None, # populated via signal
db=None, # populated via signal
REDIS_URL=settings.REDIS_URL,
DATABASE_URL=settings.DATABASE_URL,
SLACK_INVITE_TOKEN=settings.SLACK_INVITE_TOKEN,
SLACK_TOKEN=settings.SLACK_TOKEN,
)
app.cleanup_ctx.extend([
apscheduler_ctx,
client_session,
redis_pool,
postgresql_pool,
slack_client,
background_jobs,
])
app.router.add_get("/", index)
app["subapps"]["website"] = await website.app_factory()
app.add_subapp("/web", app["subapps"]["website"])
app["subapps"]["sirbot"] = await sirbot.app_factory()
app.add_subapp("/bot", app["subapps"]["sirbot"])
return app
async def app_factory() -> web.Application:
app = web.Application(middlewares=[
ForwardedRelaxed().middleware,
XForwardedRelaxed().middleware,
request_context_middleware,
])
app.update( # pylint: disable=no-member
client_session=None, # populated via signal
scheduler=None, # populated via signal
redis=None, # populated via signal
db=None, # populated via signal
REDIS_URL=settings.REDIS_URL,
POSTGRESQL_DSN=settings.POSTGRESQL_DSN,
)
app.cleanup_ctx.extend(
[apscheduler, client_session, redis_pool, postgresql_pool])
app.router.add_get("/", index)
app["website_app"] = await website.app_factory()
app.add_subapp("/web", app["website_app"])
return app
return response
app = web.Application()
aiohttp_jinja2.setup(app,
loader=jinja2.FileSystemLoader(
str(Path(__file__).parent / "templates")))
env = aiohttp_jinja2.get_env(app)
env.filters.update(yaml=filter_yaml, highlight=filter_highlight)
env.globals["version"] = __version__
app.add_routes(routes)
app.router.add_static("/assets",
Path(__file__).parent / "templates" / "assets")
# behind proxy
app.middlewares.append(XForwardedRelaxed().middleware)
secret_key = os.getenv("SESSION_SECRET_KEY") or Fernet.generate_key()
secret_key = base64.urlsafe_b64decode(secret_key)
session_setup(app,
EncryptedCookieStorage(secret_key, cookie_name="KUBE_WEB_VIEW"))
authorize_url = os.getenv("OAUTH2_AUTHORIZE_URL")
access_token_url = os.getenv("OAUTH2_ACCESS_TOKEN_URL")
if authorize_url and access_token_url:
app.middlewares.append(auth)
web.run_app(app)
def get_app(cluster_manager, config):
templates_paths = [str(Path(__file__).parent / "templates")]
if config.templates_path:
# prepend the custom template path so custom templates will overwrite any default ones
templates_paths.insert(0, config.templates_path)
static_assets_path = Path(__file__).parent / "templates" / "assets"
if config.static_assets_path:
# overwrite assets path
static_assets_path = Path(config.static_assets_path)
object_links = collections.defaultdict(list)
if config.object_links:
for link_def in config.object_links.split(","):
resource_type, sep, url_template = link_def.partition("=")
object_links[resource_type].append({
"href": url_template,
"title": "External link for object {name}",
"icon": "external-link-alt",
})
label_links = collections.defaultdict(list)
if config.label_links:
for link_def in config.label_links.split(","):
label, sep, url_template = link_def.partition("=")
label_links[label].append({
"href": url_template,
"title":
"External link for {label} label with value '{label_value}'",
"icon": "external-link-alt",
})
app = web.Application()
aiohttp_jinja2.setup(
app,
loader=jinja2.FileSystemLoader(templates_paths),
trim_blocks=True,
lstrip_blocks=True,
)
env = aiohttp_jinja2.get_env(app)
env.filters.update(
pluralize=jinja2_filters.pluralize,
yaml=jinja2_filters.yaml,
highlight=jinja2_filters.highlight,
age_color=jinja2_filters.age_color,
cpu=jinja2_filters.cpu,
memory=jinja2_filters.memory,
)
env.globals["version"] = __version__
env.globals["object_links"] = object_links
env.globals["label_links"] = label_links
app.add_routes(routes)
app.router.add_static("/assets", static_assets_path)
# behind proxy
app.middlewares.append(XForwardedRelaxed().middleware)
secret_key = os.getenv("SESSION_SECRET_KEY") or Fernet.generate_key()
secret_key = base64.urlsafe_b64decode(secret_key)
session_setup(
app, EncryptedCookieStorage(secret_key, cookie_name="KUBE_WEB_VIEW"))
authorize_url = os.getenv("OAUTH2_AUTHORIZE_URL")
access_token_url = os.getenv("OAUTH2_ACCESS_TOKEN_URL")
if authorize_url and access_token_url:
logger.info(
f"Using OAuth2 middleware with authorization endpoint {authorize_url}"
)
app.middlewares.append(auth)
app.middlewares.append(error_handler)
app[CLUSTER_MANAGER] = cluster_manager
app[CONFIG] = config
return app
def create_app(**kwargs):
''' Completely initialize the flask application
'''
from aiohttp import web
from aiohttp_wsgi import WSGIHandler
from aiohttp_remotes import setup, XForwardedRelaxed
#
from flask import Flask, Blueprint, current_app, redirect
from flask_cors import CORS
#
from appyter.render.flask_app.socketio import socketio
from appyter.render.flask_app.core import core
import appyter.render.flask_app.static
import appyter.render.flask_app.download
import appyter.render.flask_app.execution
if kwargs['debug']:
import appyter.render.flask_app.livereload
#
from appyter.context import get_env, find_blueprints
from appyter.util import join_routes
config = get_env(**kwargs)
#
if config['DEBUG']:
logging.basicConfig(
level=logging.DEBUG,
format='%(name)s %(message).80s',
)
else:
logging.basicConfig(
level=logging.WARNING,
format='%(name)s %(message).80s',
)
logging.getLogger(__package__).setLevel(logging.INFO)
#
logger.info('Initializing aiohttp...')
app = web.Application()
app['config'] = config
#
logger.info('Initializing socketio...')
socketio.attach(app, join_routes(config['PREFIX'], 'socket.io'))
#
logger.info('Initializing flask...')
flask_app = Flask(__name__, static_url_path=None, static_folder=None)
CORS(flask_app)
flask_app.config.update(config)
flask_app.debug = config['DEBUG']
#
logger.info('Registering blueprints...')
flask_app.register_blueprint(core)
for blueprint_name, blueprint in find_blueprints(
config=flask_app.config).items():
if isinstance(blueprint, Blueprint):
flask_app.register_blueprint(blueprint,
url_prefix='/' +
blueprint_name.strip('/'))
elif callable(blueprint):
blueprint(flask_app, url_prefix='/' + blueprint_name.strip('/'))
else:
raise Exception('Unrecognized blueprint type: ' + blueprint_name)
#
if app['config']['PREFIX'].strip('/'):
logger.info('Registering prefix redirect')
async def redirect_to_prefix(request):
path = request.match_info['path']
if path == app['config']['PREFIX'].strip('/'): path = ''
raise web.HTTPFound(
join_routes(app['config']['PREFIX'], path) + '/')
app.router.add_get('/{path:[^/]*}', redirect_to_prefix)
#
logger.info('Registering flask with aiohttp...')
wsgi_handler = WSGIHandler(flask_app)
app.router.add_route(
'*', join_routes(app['config']['PREFIX'], '{path_info:.*}'),
wsgi_handler)
if flask_app.config['PROXY']:
logger.info('Applying proxy fix middleware...')
import asyncio
asyncio.get_event_loop().run_until_complete(
setup(app, XForwardedRelaxed()))
return app
