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)