def __init__(self, *args, **kwargs):
# NOTE we use HTTPPermanentRedirect (308) because
# clients sometimes turn POST requests into GET requests
# on 301, 302, or 303
# see https://tools.ietf.org/html/rfc7538
trailing_slash_redirect = normalize_path_middleware(
append_slash=True,
redirect_class=HTTPPermanentRedirect
)
self.subapp = web.Application(
middlewares=[
oauth_problem_middleware,
trailing_slash_redirect
]
)
AbstractAPI.__init__(self, *args, **kwargs)
aiohttp_jinja2.setup(
self.subapp,
loader=jinja2.FileSystemLoader(
str(self.options.openapi_console_ui_from_dir)
)
)
middlewares = self.options.as_dict().get('middlewares', [])
self.subapp.middlewares.extend(middlewares)
def __init__(self, *args, **kwargs):
# NOTE we use HTTPPermanentRedirect (308) because
# clients sometimes turn POST requests into GET requests
# on 301, 302, or 303
# see https://tools.ietf.org/html/rfc7538
trailing_slash_redirect = normalize_path_middleware(
append_slash=True,
redirect_class=HTTPPermanentRedirect
)
self.subapp = web.Application(
middlewares=[
problems_middleware,
trailing_slash_redirect
]
)
AbstractAPI.__init__(self, *args, **kwargs)
aiohttp_jinja2.setup(
self.subapp,
loader=jinja2.FileSystemLoader(
str(self.options.openapi_console_ui_from_dir)
)
)
middlewares = self.options.as_dict().get('middlewares', [])
self.subapp.middlewares.extend(middlewares)
def init_app(config: Optional[List[str]] = None) -> web.Application:
""" Initializing web application with middlewares, config, routs and etc.
:param config: Configuration
:return: Web application
"""
app = web.Application(
middlewares=[normalize_path_middleware(), validation_middleware])
init_config_app(app, config=config)
init_routes(app)
app.cleanup_ctx.extend([
redis,
])
app.on_startup.append(on_start)
app.on_cleanup.append(gracefully_on_stop)
setup_aiohttp_apispec(
app=app,
title="News project DD-flow",
version="v1",
url="/api/docs/swagger.json",
swagger_path="/api/docs",
)
return app
def main():
loop = asyncio.get_event_loop()
prefix = '/terial'
app = web.Application(middlewares=[
normalize_path_middleware(),
prefix_middleware(prefix),
common_exception_middleware(),
])
aiohttp_jinja2.setup(
app,
loader=jinja2.FileSystemLoader(str(script_dir / 'templates')),
context_processors=[aiohttp_jinja2.request_processor],
)
jinja_env = aiohttp_jinja2.get_env(app)
template_funcs.setup(jinja_env)
jinja_env.globals['config'] = config
jinja_env.globals['merge_dicts'] = merge_dicts
jinja_env.globals['is_dict'] = is_dict
routes.setup(app, prefix)
app['executor'] = ThreadPoolExecutor(max_workers=3)
web.run_app(app, port=9999, print=logger.info)
async def setup_middlewares(app):
app.middlewares.append(normalize_path_middleware(append_slash=True))
app.middlewares.append(is_ajax)
app.middlewares.append(csrf_token)
csrf_setup(app)
PRE_DISPATCHERS.append(csrf_pre_dispatch)
for middleware in settings.MIDDLEWARES:
try:
mod = importlib.import_module(middleware)
try:
mw = getattr(mod, 'middleware')
app.middlewares.append(mw)
except AttributeError:
pass
try:
setup = getattr(mod, 'setup')
await awaitable(setup(app))
except AttributeError:
pass
try:
PRE_DISPATCHERS.append(getattr(mod, 'pre_dispatch'))
except AttributeError:
pass
except ImportError as e:
web_logger.warn('Failed to register middleware %s' % middleware)
async def init(address, port, services, users):
context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
context.load_cert_chain(SSL_CERT_FILE, SSL_KEY_FILE)
mw = [
session_middleware(SimpleCookieStorage()),
normalize_path_middleware()
]
app = web.Application(middlewares=mw)
app.on_startup.append(background_tasks)
app.router.add_route('POST', '/file/render',
services.get('file_svc').render)
app.router.add_route('POST', '/file/download',
services.get('file_svc').download)
app.router.add_route('POST', '/file/upload',
services.get('file_svc').upload)
await services.get('data_svc').reload_database()
for user, pwd in users.items():
await services.get('auth_svc').register(username=user, password=pwd)
logging.debug('...Created user: %s:%s' % (user, pwd))
await attach_plugins(app, services)
runner = web.AppRunner(app)
await runner.setup()
await web.TCPSite(runner, address, port, ssl_context=context).start()
def create_app():
logging.basicConfig(level=logging.DEBUG)
app = web.Application(middlewares=[
web_middlewares.normalize_path_middleware(append_slash=True),
], client_max_size=4096**2)
app.update(name='consumer', settings=settings)
# setup Jinja2 template renderer
aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader(str(settings.PROJECT_ROOT / 'templates')))
# get credentials of the correct environment
for key, value in get_postgres_credentials(settings.ENVIRONMENT)._asdict().items():
setattr(app['settings'], key, value)
# create db connection on startup, shutdown on exit
app.on_startup.append(on_startup)
app.on_cleanup.append(close_pg)
# setup views and routes
setup_routes(app)
# setup middlewares
# setup_middlewares(app)
# setup aiojobs scheduler
setup_aiojobs(app)
return app
def get_app():
middlewares = [
normalize_path_middleware(),
metrics_middleware(),
]
if SENTRY_DSN:
middlewares.append(
SentryMiddleware(patch_logging=True,
sentry_log_level=logging.ERROR))
app = web.Application(client_max_size=MAX_UPLOAD, middlewares=middlewares)
# Register handler for default preview routes.
default_handler = make_handler(get_path)
app.add_routes([
web.post('/preview/', default_handler),
web.get('/preview/', default_handler)
])
# Some views not related to generating previews.
app.add_routes([web.get('/', info)])
app.add_routes([web.get('/test/', test)])
app.add_routes([web.get('/metrics/', metrics_handler)])
# Load and register any plugins.
for plugin in PLUGINS:
# We don't need to do much checking here as the config module validates
# the given plugins.
method = getattr(web, plugin.method.lower())
app.add_routes([method(plugin.pattern, make_handler(plugin))])
return app
def __init__(self, settings=None, logging=True, usernameField="username"):
baseSettings = defaultSettings()
baseSettings.update(settings or {})
middlewares = [
normalize_path_middleware(append_slash=True),
allowCors(origins=baseSettings["corsOrigins"]),
removeServerHeader,
]
if logging:
middlewares.append(logger(usernameField))
middlewares.append(
authenticationMiddleware(
db=baseSettings["db"],
secretKey=baseSettings["jwtKey"],
), )
super().__init__(middlewares=middlewares, )
self.documentation = []
self.tests = []
self["settings"] = baseSettings
self.router.add_route(
"GET",
"/",
self.documentationHandler,
)
self.addEndpoint(
"/healthy/",
healthRoutes.HealthCheckEndpoint,
name="Health Check",
)
async def run_web_server(listen_addr, port, config):
trailing_slash_redirect = normalize_path_middleware(append_slash=True)
app = web.Application(middlewares=[trailing_slash_redirect])
app.config = config
setup_metrics(app)
runner = web.AppRunner(app)
await runner.setup()
site = web.TCPSite(runner, listen_addr, port)
await site.start()
def __init__(self, db, config, cache_path, artifact_manager, task_memory_limit=None, task_timeout=None):
trailing_slash_redirect = normalize_path_middleware(append_slash=True)
super(DifferWebApp, self).__init__(middlewares=[trailing_slash_redirect])
self.router.add_routes(routes)
self.db = db
self.config = config
self.cache_path = cache_path
self.artifact_manager = artifact_manager
self.task_memory_limit = task_memory_limit
self.task_timeout = task_timeout
async def get_application(self):
logging.basicConfig(
level=logging.ERROR
) # subdue messages like 'DEBUG:asyncio:Using selector: KqueueSelector'
app = web.Application(middlewares=[
web_middlewares.normalize_path_middleware(append_slash=True)
])
settings = get_postgres_credentials(ENVIRONMENT='TEST')
app.update(name='test', settings=settings)
app.on_startup.append(init_pg)
return app
def init_server(loop=None):
normalize_mw = normalize_path_middleware(merge_slashes=False)
app = web.Application(middlewares=[
normalize_mw,
], loop=loop)
add_routes(app)
app.on_startup.append(init)
app.on_shutdown.append(cleanup)
return app
def main():
app = web.Application(middlewares=[
normalize_path_middleware(),
])
app.router.add_route('GET', '/', hello, name='hello')
app.router.add_route('POST', '/submit', data_handler, name='data_handler')
with session_scope() as sess:
materials = sess.query(models.Material).all()
app['material_by_id'] = {m.id: m for m in materials}
web.run_app(app, host=args.host, port=args.port, print=logger.info)
def start(argv):
loop = uvloop.new_event_loop()
asyncio.set_event_loop(loop)
app = web.Application(middlewares=[
normalize_path_middleware(append_slash=True, merge_slashes=True)
])
app.on_startup.append(initialize)
app.on_shutdown.append(close_websockets)
app.on_cleanup.append(close_db)
app.on_cleanup.append(close_redis)
return app
async def init(address, port, services, users):
context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
context.load_cert_chain(SSL_CERT_FILE, SSL_KEY_FILE)
mw = [session_middleware(SimpleCookieStorage()), normalize_path_middleware()]
app = web.Application(middlewares=mw)
app.on_startup.append(background_tasks)
await data_svc.reload_database()
for user, pwd in users.items():
await auth_svc.register(username=user, password=pwd)
await attach_plugins(app, services)
runner = web.AppRunner(app)
await runner.setup()
await web.TCPSite(runner, address, port, ssl_context=context).start()
def create_app():
logging.basicConfig(level=logging.DEBUG)
app = web.Application(middlewares=[
web_middlewares.normalize_path_middleware(append_slash=True),
],
client_max_size=4096**2)
app.update(name='producer', settings=settings)
# setup Jinja2 template renderer; jinja2 contains various loaders, can also try PackageLoader etc.
aiohttp_jinja2.setup(app,
loader=jinja2.FileSystemLoader(
str(settings.PROJECT_ROOT / 'static')))
# get credentials of the correct environment
for key, value in get_postgres_credentials(
settings.ENVIRONMENT)._asdict().items():
setattr(app['settings'], key, value)
# create db connection on startup, shutdown on exit
app.on_startup.append(on_startup)
app.on_cleanup.append(close_pg)
# setup views and routes
setup_routes(app)
# setup middlewares
# setup_middlewares(app)
# setup aiojobs scheduler
setup_aiojobs(app)
# 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 in list(app.router.routes()):
cors.add(route)
return app
async def run_web_server(listen_addr, port, dists_dir, config, generator_manager, tracer):
trailing_slash_redirect = normalize_path_middleware(append_slash=True)
app = web.Application(middlewares=[trailing_slash_redirect])
app.config = config
app.generator_manager = generator_manager
setup_metrics(app)
app.router.add_get("/", handle_index, name="index")
app.router.add_static("/dists", dists_dir, show_index=True)
app.router.add_post("/publish", handle_publish, name="publish")
app.router.add_get("/last-publish", handle_last_publish, name="last-publish")
app.router.add_get("/health", handle_health, name="health")
aiozipkin.setup(app, tracer)
runner = web.AppRunner(app)
await runner.setup()
site = web.TCPSite(runner, listen_addr, port)
await site.start()
def create_app() -> web.Application:
app = web.Application(
client_max_size=MAX_REQUEST_SIZE,
middlewares=[validation_middleware, normalize_path_middleware()]
)
# Registering routes
for route in urls.routes:
log.debug('Registering route %r', route)
app.router.add_route(**dataclasses.asdict(route))
# Swagger docs on /docs/ url
setup_aiohttp_apispec(
app=app,
title='TG File Uploader API',
version='v1',
swagger_path='/docs/'
)
return app
def create_app(
db,
publisher_url: str,
runner_url: str,
archiver_url: str,
vcs_store_url: str,
differ_url: str,
config: Config,
policy_config: PolicyConfig,
external_url: Optional[URL] = None,
trace_configs=None,
) -> web.Application:
trailing_slash_redirect = normalize_path_middleware(append_slash=True)
app = web.Application(middlewares=[trailing_slash_redirect])
app.router.add_routes(routes)
app['http_client_session'] = ClientSession(trace_configs=trace_configs)
app.config = config
app['logfile_manager'] = get_log_manager(config.logs_location)
app.jinja_env = env
app.db = db
app.external_url = external_url
app.policy_config = policy_config
app.publisher_url = publisher_url
app.vcs_store_url = vcs_store_url
app.runner_url = runner_url
app.differ_url = differ_url
app.archiver_url = archiver_url
app.router.add_get('/', lambda req: web.HTTPFound(location='docs'))
setup_aiohttp_apispec(
app=app,
title="Debian Janitor API Documentation",
version=None,
url="/swagger.json",
swagger_path="/docs",
)
# app.middlewares.append(apispec_validation_middleware)
return app
def run(self):
self.loop = self.__loop = asyncio.get_event_loop()
if self.loop_monitor:
self.__loop.set_debug(True)
# loop.slow_callback_duration(0.2)
# Needs to happen after setting debug or may cause race condition
# http://bugs.python.org/issue30805
self.__loop.run_until_complete(self.__plugins_load())
if self.loop_monitor:
# Start monitor thread after plugins have been loaded
# because of the time spent doing I/O
t = threading.Thread(target=self._loop_monitor_thread)
t.setDaemon(True)
t.start()
self.__loop.add_signal_handler(signal.SIGINT, self.terminate)
self.__loop.add_signal_handler(signal.SIGTERM, self.terminate)
self.__loop.add_signal_handler(signal.SIGUSR1, self.pdb)
app = web.Application(middlewares=[
normalize_path_middleware(redirect_class=HTTPPermanentRedirect)
], loop=self.__loop)
app.router.add_route('GET', '/websocket', self.ws_handler)
app.router.add_route("*", "/api/docs{path_info:.*}", WSGIHandler(apidocs_app))
self.fileapp = FileApplication(self, self.__loop)
app.router.add_route('*', '/_download{path_info:.*}', self.fileapp.download)
app.router.add_route('*', '/_upload{path_info:.*}', self.fileapp.upload)
shellapp = ShellApplication(self)
app.router.add_route('*', '/_shell{path_info:.*}', shellapp.ws_handler)
restful_api = RESTfulAPI(self, app)
self.__loop.run_until_complete(
asyncio.ensure_future(restful_api.register_resources())
)
asyncio.ensure_future(self.jobs.run())
self.__setup_periodic_tasks()
# Start up middleware worker process pool
self.__procpool._start_queue_management_thread()
runner = web.AppRunner(app, handle_signals=False, access_log=None)
self.__loop.run_until_complete(runner.setup())
self.__loop.run_until_complete(
web.TCPSite(runner, '0.0.0.0', 6000, reuse_address=True, reuse_port=True).start()
)
self.__loop.run_until_complete(web.UnixSite(runner, '/var/run/middlewared.sock').start())
self.logger.debug('Accepting connections')
try:
self.__loop.run_forever()
except RuntimeError as e:
if e.args[0] != "Event loop is closed":
raise
async def create_web_app(
listen_addr: str,
port: int,
vcs_manager: VcsManager,
db: state.Database,
config,
dulwich_server: bool = False,
client_max_size: Optional[int] = None,
):
trailing_slash_redirect = normalize_path_middleware(append_slash=True)
app = web.Application(middlewares=[trailing_slash_redirect],
client_max_size=client_max_size)
app.vcs_manager = vcs_manager
app.db = db
app.config = config
setup_metrics(app)
app.router.add_get("/diff/{run_id}/{role}", diff_request, name='diff')
if dulwich_server:
app.router.add_post(
"/git/{package}/{service:git-receive-pack|git-upload-pack}",
dulwich_service,
name='dulwich-service')
app.router.add_get("/git/{package}/info/refs",
dulwich_refs,
name='dulwich-refs')
else:
for (method, regex), fn in HTTPGitApplication.services.items():
app.router.add_route(
method, "/git/{package}{subpath:" + regex.pattern + "}",
git_backend)
app.router.add_get("/", handle_index, name="index")
app.router.add_get("/{vcs:git|bzr}/", handle_repo_list, name='repo-list')
app.router.add_get("/health", handle_health, name='health')
app.router.add_get("/git/{package}/{path_info:.*}",
handle_klaus,
name='klaus')
app.router.add_post("/bzr/{package}/.bzr/smart",
bzr_backend,
name='bzr-repo')
app.router.add_post("/bzr/{package}/{branch}/.bzr/smart",
bzr_backend,
name='bzr-branch')
app.router.add_get("/vcs-type/{package}", get_vcs_type, name='vcs-type')
app.router.add_post("/remotes/git/{package}/{remote}",
handle_set_git_remote,
name='git-remote')
app.router.add_post("/remotes/bzr/{package}/{remote}",
handle_set_bzr_remote,
name='bzr-remote')
logging.info("Listening on %s:%s", listen_addr, port)
endpoint = aiozipkin.create_endpoint("janitor.vcs_store",
ipv4=listen_addr,
port=port)
if config.zipkin_address:
tracer = await aiozipkin.create(config.zipkin_address,
endpoint,
sample_rate=1.0)
else:
tracer = await aiozipkin.create_custom(endpoint)
aiozipkin.setup(app, tracer)
return app
async def create_app(config,
policy_config,
minified=False,
external_url=None,
debugtoolbar=None,
runner_url=None,
publisher_url=None,
archiver_url=None,
vcs_store_url=None,
differ_url=None,
listen_address=None,
port=None):
if minified:
minified_prefix = ""
else:
minified_prefix = "min."
trailing_slash_redirect = normalize_path_middleware(append_slash=True)
app = web.Application(middlewares=[trailing_slash_redirect])
setup_metrics(app)
app.topic_notifications = Topic("notifications")
app.router.add_get(
"/ws/notifications",
functools.partial(pubsub_handler,
app.topic_notifications), # type: ignore
name="ws-notifications",
)
endpoint = aiozipkin.create_endpoint("janitor.site",
ipv4=listen_address,
port=port)
if config.zipkin_address:
tracer = await aiozipkin.create(config.zipkin_address,
endpoint,
sample_rate=1.0)
else:
tracer = await aiozipkin.create_custom(endpoint)
trace_configs = [aiozipkin.make_trace_config(tracer)]
aiozipkin.setup(app,
tracer,
skip_routes=[
app.router['metrics'],
app.router['ws-notifications'],
])
async def setup_client_session(app):
app.http_client_session = ClientSession(trace_configs=trace_configs)
async def close_client_session(app):
await app.http_client_session.close()
app.on_startup.append(setup_client_session)
app.on_cleanup.append(close_client_session)
async def start_gpg_context(app):
gpg_home = tempfile.TemporaryDirectory()
gpg_context = gpg.Context(home_dir=gpg_home.name)
app.gpg = gpg_context.__enter__()
async def cleanup_gpg(app):
gpg_context.__exit__(None, None, None)
shutil.rmtree(gpg_home)
app.on_cleanup.append(cleanup_gpg)
async def discover_openid_config(app):
url = URL(app.config.oauth2_provider.base_url).join(
URL("/.well-known/openid-configuration"))
async with app.http_client_session.get(url) as resp:
if resp.status != 200:
# TODO(jelmer): Fail? Set flag?
logging.warning(
"Unable to find openid configuration (%s): %s",
resp.status,
await resp.read(),
)
return
app.openid_config = await resp.json()
async def start_pubsub_forwarder(app):
async def listen_to_publisher_publish(app):
url = URL(app.publisher_url) / "ws/publish"
async for msg in pubsub_reader(app.http_client_session, url):
app.topic_notifications.publish(["publish", msg])
async def listen_to_publisher_mp(app):
url = URL(app.publisher_url) / "ws/merge-proposal"
async for msg in pubsub_reader(app.http_client_session, url):
app.topic_notifications.publish(["merge-proposal", msg])
app['runner_status'] = None
async def listen_to_queue(app):
url = URL(app.runner_url) / "ws/queue"
async for msg in pubsub_reader(app.http_client_session, url):
app['runner_status'] = msg
app.topic_notifications.publish(["queue", msg])
async def listen_to_result(app):
url = URL(app.runner_url) / "ws/result"
async for msg in pubsub_reader(app.http_client_session, url):
app.topic_notifications.publish(["result", msg])
for cb, title in [
(listen_to_publisher_publish, 'publisher publish listening'),
(listen_to_publisher_mp, 'merge proposal listiening'),
(listen_to_queue, 'queue listening'),
(listen_to_result, 'result listening'),
]:
listener = create_background_task(cb(app), title)
async def stop_listener(app):
listener.cancel()
await listener
app.on_cleanup.append(stop_listener)
for path, templatename in [
("/", "index"),
("/contact", "contact"),
("/about", "about"),
("/apt", "apt"),
("/cupboard/", "cupboard"),
]:
app.router.add_get(
path,
functools.partial(handle_simple, templatename + ".html"),
name=templatename,
)
app.router.add_get("/credentials", handle_credentials, name="credentials")
app.router.add_get("/ssh_keys", handle_ssh_keys, name="ssh-keys")
app.router.add_get(r"/pgp_keys{extension:(\.asc)?}",
handle_pgp_keys,
name="pgp-keys")
from .lintian_fixes import register_lintian_fixes_endpoints
register_lintian_fixes_endpoints(app.router)
from .multiarch_hints import register_multiarch_hints_endpoints
register_multiarch_hints_endpoints(app.router)
from .orphan import register_orphan_endpoints
register_orphan_endpoints(app.router)
from .debianize import register_debianize_endpoints
register_debianize_endpoints(app.router)
from .scrub_obsolete import register_scrub_obsolete_endpoints
register_scrub_obsolete_endpoints(app.router)
from .new_upstream import register_new_upstream_endpoints
register_new_upstream_endpoints(app.router)
SUITE_REGEX = "|".join([re.escape(suite.name) for suite in config.suite])
app.router.add_get(
"/{suite:%s}/merge-proposals" % SUITE_REGEX,
handle_merge_proposals,
name="suite-merge-proposals",
)
app.router.add_get("/{suite:%s}/ready" % SUITE_REGEX,
handle_ready_proposals,
name="suite-ready")
app.router.add_get(
"/{suite:%s}/maintainer" % SUITE_REGEX,
handle_maintainer_list,
name="suite-maintainer-list",
)
app.router.add_get("/{suite:%s}/pkg/" % SUITE_REGEX,
handle_pkg_list,
name="suite-package-list")
app.router.add_get("/{vcs:git|bzr}/", handle_repo_list, name="repo-list")
app.router.add_get("/{suite:unchanged}",
handle_apt_repo,
name="unchanged-start")
app.router.add_get("/cupboard/history", handle_history, name="history")
app.router.add_get("/cupboard/queue", handle_queue, name="queue")
app.router.add_get("/cupboard/result-codes/",
handle_result_codes,
name="result-code-list")
app.router.add_get("/cupboard/result-codes/{code}",
handle_result_codes,
name="result-code")
app.router.add_get("/cupboard/never-processed",
handle_never_processed,
name="never-processed")
app.router.add_get(
"/cupboard/maintainer-stats",
handle_cupboard_maintainer_stats,
name="cupboard-maintainer-stats",
)
app.router.add_get("/cupboard/maintainer",
handle_maintainer_list,
name="maintainer-list")
app.router.add_get(
"/cupboard/maintainer/{maintainer}",
handle_maintainer_overview,
name="cupboard-maintainer-overview",
)
app.router.add_get(
"/maintainer/{maintainer}",
handle_maintainer_overview,
name="maintainer-overview",
)
app.router.add_get("/m/",
handle_maintainer_index,
name="maintainer-index-short")
app.router.add_get("/m/{maintainer}",
handle_maintainer_overview,
name="maintainer-overview-short")
app.router.add_get("/cupboard/publish",
handle_publish_history,
name="publish-history")
app.router.add_get("/cupboard/ready",
handle_ready_proposals,
name="cupboard-ready")
app.router.add_get("/cupboard/pkg/", handle_pkg_list, name="package-list")
app.router.add_get("/cupboard/pkg/{pkg}/",
handle_pkg,
name="cupboard-package")
app.router.add_get("/cupboard/pkg/{pkg}/{run_id}/",
handle_run,
name="cupboard-run")
app.router.add_get("/cupboard/review",
handle_review,
name="cupboard-review")
app.router.add_get("/cupboard/rejected",
handle_rejected,
name="cupboard-rejected")
app.router.add_post("/cupboard/review",
handle_review_post,
name="cupboard-review-post")
app.router.add_get(
"/cupboard/failed-lintian-brush-fixers/",
handle_failed_lintian_brush_fixers_list,
name="failed-lintian-brush-fixer-list",
)
app.router.add_get(
"/cupboard/failed-lintian-brush-fixers/{fixer}",
handle_failed_lintian_brush_fixers,
name="failed-lintian-brush-fixer",
)
app.router.add_get(
"/cupboard/lintian-brush-regressions/",
handle_lintian_brush_regressions,
name="lintian-brush-regressions",
)
app.router.add_get(
"/cupboard/pkg/{pkg}/{run_id}/{filename:.+}",
handle_result_file,
name="cupboard-result-file",
)
app.router.add_get(
"/{suite:" + SUITE_REGEX + "}/pkg/{pkg}/{run_id}/{filename:.+}",
handle_result_file,
name="result-file",
)
app.router.add_get("/{suite:" + SUITE_REGEX + "}/",
handle_generic_start,
name="generic-start")
app.router.add_get(
"/{suite:" + SUITE_REGEX + "}/candidates",
handle_generic_candidates,
name="generic-candidates",
)
app.router.add_get(
"/{suite:" + SUITE_REGEX + "}/pkg/{pkg}/",
handle_generic_pkg,
name="generic-package",
)
app.router.add_get(
"/{suite:" + SUITE_REGEX + "}/pkg/{pkg}/{run_id}",
handle_generic_pkg,
name="generic-run",
)
app.router.add_get("/cupboard/vcs-regressions/",
handle_vcs_regressions,
name="vcs-regressions")
app.router.add_get("/cupboard/broken-merge-proposals",
handle_broken_mps,
name="broken-mps")
app.router.add_get("/login", handle_login, name="login")
for entry in os.scandir(os.path.join(os.path.dirname(__file__),
"_static")):
app.router.add_get(
"/_static/%s" % entry.name,
functools.partial(handle_static_file, entry.path),
)
app.router.add_static("/_static/images/datatables",
"/usr/share/javascript/jquery-datatables/images")
for (name, kind, basepath) in [
("chart", "js", "/usr/share/javascript/chart.js/Chart"),
("chart", "css", "/usr/share/javascript/chart.js/Chart"),
("jquery", "js", "/usr/share/javascript/jquery/jquery"),
(
"jquery.typeahead",
"js",
"/usr/share/javascript/jquery-typeahead/jquery.typeahead",
),
(
"jquery.datatables",
"js",
"/usr/share/javascript/jquery-datatables/jquery.dataTables",
),
("moment", "js", "/usr/share/javascript/moment/moment"),
]:
if not os.path.exists(basepath + "." + kind):
continue
app.router.add_get(
"/_static/%s.%s" % (name, kind),
functools.partial(handle_static_file,
"%s.%s%s" % (basepath, minified_prefix, kind)),
)
app.router.add_get("/oauth/callback",
handle_oauth_callback,
name="oauth2-callback")
from .api import create_app as create_api_app
from .webhook import process_webhook, is_webhook_request
async def handle_post_root(request):
if is_webhook_request(request):
return await process_webhook(request, request.app.database)
raise web.HTTPMethodNotAllowed(method='POST',
allowed_methods=['GET', 'HEAD'])
app.runner_url = runner_url
app.archiver_url = archiver_url
app.differ_url = differ_url
app.policy = policy_config
app.publisher_url = publisher_url
app.vcs_store_url = vcs_store_url
if config.oauth2_provider and config.oauth2_provider.base_url:
app.on_startup.append(discover_openid_config)
else:
app.openid_config = None
app.on_startup.append(start_pubsub_forwarder)
app.on_startup.append(start_gpg_context)
if external_url:
app.external_url = URL(external_url)
else:
app.external_url = None
database = state.Database(config.database_location)
app.database = database
from .stats import stats_app
app.add_subapp("/cupboard/stats",
stats_app(database, config, app.external_url))
app.config = config
from janitor.site import env
app.jinja_env = env
from janitor.artifacts import get_artifact_manager
async def startup_artifact_manager(app):
app['artifact_manager'] = get_artifact_manager(
config.artifact_location, trace_configs=trace_configs)
await app['artifact_manager'].__aenter__()
async def turndown_artifact_manager(app):
await app['artifact_manager'].__aexit__(None, None, None)
app.on_startup.append(startup_artifact_manager)
app.on_cleanup.append(turndown_artifact_manager)
setup_debsso(app)
app.router.add_post("/", handle_post_root, name="root-post")
app.router.add_get("/health", handle_health, name="health")
app.add_subapp(
"/api",
create_api_app(
app.database,
publisher_url,
runner_url, # type: ignore
archiver_url,
vcs_store_url,
differ_url,
config,
policy_config,
external_url=(app.external_url.join(URL("api"))
if app.external_url else None),
trace_configs=trace_configs,
),
)
import aiohttp_apispec
app.router.add_static(
'/static/swagger',
os.path.join(os.path.dirname(aiohttp_apispec.__file__), "static"))
if debugtoolbar:
import aiohttp_debugtoolbar
# install aiohttp_debugtoolbar
aiohttp_debugtoolbar.setup(app, hosts=debugtoolbar)
async def setup_logfile_manager(app):
app.logfile_manager = get_log_manager(config.logs_location,
trace_configs=trace_configs)
app.on_startup.append(setup_logfile_manager)
return app
def run(self):
self.loop = self.__loop = asyncio.get_event_loop()
if self.loop_monitor:
self.__loop.set_debug(True)
# loop.slow_callback_duration(0.2)
# Needs to happen after setting debug or may cause race condition
# http://bugs.python.org/issue30805
self.__loop.run_until_complete(self.__plugins_load())
if self.loop_monitor:
# Start monitor thread after plugins have been loaded
# because of the time spent doing I/O
t = threading.Thread(target=self._loop_monitor_thread)
t.setDaemon(True)
t.start()
self.__loop.add_signal_handler(signal.SIGINT, self.terminate)
self.__loop.add_signal_handler(signal.SIGTERM, self.terminate)
self.__loop.add_signal_handler(signal.SIGUSR1, self.pdb)
app = web.Application(middlewares=[
normalize_path_middleware(redirect_class=HTTPPermanentRedirect)
],
loop=self.__loop)
app.router.add_route('GET', '/websocket', self.ws_handler)
app.router.add_route("*", "/api/docs{path_info:.*}",
WSGIHandler(apidocs_app))
self.fileapp = FileApplication(self, self.__loop)
app.router.add_route('*', '/_download{path_info:.*}',
self.fileapp.download)
app.router.add_route('*', '/_upload{path_info:.*}',
self.fileapp.upload)
shellapp = ShellApplication(self)
app.router.add_route('*', '/_shell{path_info:.*}', shellapp.ws_handler)
restful_api = RESTfulAPI(self, app)
self.__loop.run_until_complete(
asyncio.ensure_future(restful_api.register_resources()))
asyncio.ensure_future(self.jobs.run())
self.__setup_periodic_tasks()
# Start up middleware worker process pool
self.__procpool._start_queue_management_thread()
runner = web.AppRunner(app, handle_signals=False, access_log=None)
self.__loop.run_until_complete(runner.setup())
self.__loop.run_until_complete(
web.TCPSite(runner,
'0.0.0.0',
6000,
reuse_address=True,
reuse_port=True).start())
self.__loop.run_until_complete(
web.UnixSite(runner, '/var/run/middlewared.sock').start())
self.logger.debug('Accepting connections')
try:
self.__loop.run_forever()
except RuntimeError as e:
if e.args[0] != "Event loop is closed":
raise
except Exception as e:
tb = traceback.format_exc()
log.exception("%s %s", request.method, request.path)
return json_error(500, e, tb)
return middleware_handler
async def init_client(app):
app["tibiapy"] = tibiapy.Client()
async def cleanup_client(app):
await app["tibiapy"].session.close()
if __name__ == "__main__":
normalize_paths = normalize_path_middleware(remove_slash=True,
append_slash=False)
app = web.Application(middlewares=[
error_middleware,
normalize_paths,
])
app.add_routes(routes)
app.on_startup.append(init_client)
app.on_cleanup.append(cleanup_client)
print("Registered routes:")
for route in routes: # type: RouteDef
print(f'- {route.method} {route.path}')
web.run_app(app, port=8000)
# -*- coding: utf-8 -*-
from aiohttp.web_middlewares import normalize_path_middleware
from aiohttp_baseapi.middleware.error_handler import error_handler
from aiohttp_baseapi.middleware.params_handler import params_handler
from conf import settings
__all__ = ('middlewares', )
middlewares = list()
middlewares.append(normalize_path_middleware())
middlewares.append(params_handler)
middlewares.append(error_handler(is_debug=settings.DEBUG))
try:
response = await handler(request)
if response.status == 404:
return json_error(response.status, Exception(response.message))
return response
except web.HTTPException as ex:
if ex.status == 404:
return json_error(ex.status, ex)
raise
except Exception as e:
tb = traceback.format_exc()
print(tb)
return json_error(500, e, tb)
return middleware_handler
async def init_client(app):
app["tibiapy"] = tibiapy.Client()
if __name__ == "__main__":
normalize_paths = normalize_path_middleware()
app = web.Application(middlewares=[error_middleware, normalize_paths])
app.add_routes(routes)
app.on_startup.append(init_client)
print("Registered routes:")
for route in routes: # type: RouteDef
print('\t[%s] %s' % (route.method, route.path))
web.run_app(app, port=8000)
