def test_route(router): async def handler(request): pass router.add_routes([web.route('OTHER', '/', handler)]) assert len(router.routes()) == 1 route = list(router.routes())[0] assert route.handler is handler assert route.method == 'OTHER' assert str(route.url_for()) == '/'
def setup_routes(app: web.Application) -> None: app.add_routes([web.view('/connect/authorize', AuthorizeView), web.view('/connect/token', TokenView), web.view('/client', ClientListView), web.view('/client/register', RegisterClientView), web.view('/account', AccountListView), web.view('/account/create', CreateAccountView), web.view('/account/{username}', GetAccountView), web.route('*', '/{tail:.*}', catch_all)]) project_root = pathlib.Path(__file__).parent.parent app.add_routes([web.static('/static/', path=project_root / 'static', name='static')])
def __init__(self, wllp, Allow_Origin, ssl_key_path, port=None, host=None): self._headers = { 'Access-Control-Allow-Origin': Allow_Origin, 'Access-Control-Allow-Methods': 'GET, PUT, POST, DELETE, OPTIONS', 'Access-Control-Allow-Headers': 'Content-Type' } self.wllp = wllp self.web_app = web.Application() self.web_app.add_routes([web.get('/ws', self.websocket_handler), web.route('*', '/{tail:.*}', self.router)]) ssl_context = ssl.create_default_context(purpose=ssl.Purpose.CLIENT_AUTH) ssl_context.load_cert_chain(ssl_key_path) self.app_task = asyncio.create_task(web._run_app(self.web_app, host=host or get_local_ip(), port=port or 8989, ssl_context=ssl_context))
async def _start(self): try: HummingWebApp._port = get_open_port() self._impl: Optional[web.Application] = web.Application() self._impl.add_routes( [web.route("*", '/{tail:.*}', self._handler)]) self._runner = web.AppRunner(self._impl) await self._runner.setup() site = web.TCPSite(self._runner, host=HummingWebApp.host, port=HummingWebApp._port) await site.start() self._started = True except Exception: logging.error("oops!", exc_info=True)
def mock_api_app(client_id: str, client_secret: str, redirect_uri: str) -> web.Application: app = web.Application() app["client_id"] = client_id app["client_secret"] = client_secret app["redirect_uri"] = redirect_uri app.router.add_routes([ web.get("/authorize", authorize, name="authorize"), web.post("/token", token, name="token"), web.route("*", "/api/{endpoint}", api, name="api"), ]) return app
def __init__(self, vasp): self.vasp = vasp # For the moment hold one session per VASP. self.session = None self.app = web.Application() # Register routes. route = f"/v1/{{other_addr}}/{self.vasp.get_vasp_address().as_str()}/command" self.app.add_routes([web.route("*", route, self.handle_request)]) logger.debug(f'Register route {route}') # The watchdog process variables. self.watchdog_period = 10.0 # seconds self.watchdog_task_obj = None # Store the task here to cancel.
def init_app(self, app, url_prefix=None, name_prefix=None, app_root=None): self.acl = self.force_acl if self.force_acl else set( app['route_acl'][self.acl_key]) name = '.'.join(filter(None, [name_prefix, self.name])) for url_rule, options in self.url_rules: url_rule = ''.join(filter(None, [url_prefix, url_rule])) if options['methods'] is None: options['methods'] = ['GET'] assert len(options['methods']) == 1 app['api_endpoints'][name] = self app.add_routes([ web.route(options['methods'][0], f'{app_root}{url_rule}', self.__call__, name=name) ])
async def set_server(self) -> web.Application: """ set server """ server = WebServer(database_config=self.database_config, client_config=self.client_config) if self.database_config.need_update: await server.generate_schemas() web_app = web.Application() web_app.add_routes([ web.get("/api/command/", server.api_start_user_client), web.route("*", "/api/", server.api_doc), ]) aiohttp_jinja2.setup( web_app, loader=jinja2.FileSystemLoader('server_settings/html/')) return web_app
async def start(self): app = web.Application() app.add_routes([web.route('*', '/{tail:.*}', self.handle_request)]) aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader(self.dir)) middleware = SnareMiddleware(self.meta['/status_404']['hash']) middleware.setup_middlewares(app) self.runner = web.AppRunner(app) await self.runner.setup() site = web.TCPSite(self.runner, self.run_args.host_ip, self.run_args.port) await site.start() names = sorted(str(s.name) for s in self.runner.sites) print("======== Running on {} ========\n" "(Press CTRL+C to quit)".format(', '.join(names)))
def __init__(self): self.name = "v1_private_common" self.plugin_type = "sub_api" self.sub_api = "api_v1" self.routes = [ web.route("*", "/private/{country}/{language}/{devid}/{apptype}/{appversion}/{devtype}/{aid}/common/checkAPPVersion", self.handle_checkAPPVersion, name="v1_common_checkAppVersion"), web.route("*", "/private/{country}/{language}/{devid}/{apptype}/{appversion}/{devtype}/{aid}/common/checkVersion", self.handle_checkVersion, name="v1_common_checkVersion"), web.route("*", "/private/{country}/{language}/{devid}/{apptype}/{appversion}/{devtype}/{aid}/common/uploadDeviceInfo", self.handle_uploadDeviceInfo, name="v1_common_uploadDeviceInfo"), web.route("*", "/private/{country}/{language}/{devid}/{apptype}/{appversion}/{devtype}/{aid}/common/getSystemReminder", self.handle_getSystemReminder, name="v1_common_getSystemReminder"), web.route("*", "/private/{country}/{language}/{devid}/{apptype}/{appversion}/{devtype}/{aid}/common/getConfig",self.handle_getConfig, name="v1_common_getConfig"), web.route("*", "/private/{country}/{language}/{devid}/{apptype}/{appversion}/{devtype}/{aid}/common/getAreas",self.handle_getAreas, name="v1_common_getAreas"), web.route("*", "/private/{country}/{language}/{devid}/{apptype}/{appversion}/{devtype}/{aid}/common/getAgreementURLBatch", self.handle_getAgreementURLBatch, name="v1_common_getAgreementURLBatch"), web.route("*", "/private/{country}/{language}/{devid}/{apptype}/{appversion}/{devtype}/{aid}/common/getTimestamp", self.handle_getTimestamp, name="v1_common_getTimestamp"), ] self.get_milli_time = bumper.ConfServer.ConfServer_GeneralFunctions().get_milli_time
async def main(): from config.log4 import web_access_logger @web.middleware async def log_access(request, handler): ua = request.headers.get("User-Agent", "NON_UA") resp = await handler(request) web_access_logger.info( f"{request.method}-{resp.status} {request.remote} {request.url}\n\t{ua}" ) return resp @web.middleware async def set_server_name(request, handler): try: resp = await handler(request) except Exception as e: status = getattr(e, "status", 500) resp = web.Response(status=status, text=f"{e}") resp.headers['Server'] = 'madliar/2.1.1a11(Darwin)' return resp app = web.Application(middlewares=[log_access, set_server_name]) async def home_page(request): return web.Response(text=f"OK.\n\n{datetime.datetime.now()}") app.add_routes([ web.get('/', home_page), web.get('/lt_{token}', lt.lt), web.post('/lt/login', lt.login), web.get('/lt/qr_code_result', lt.qr_code_result), web.get('/lt/settings', lt.settings), web.post('/lt/post_settings', lt.post_settings), web.get('/lt/trends_qq_notice', lt.trends_qq_notice), web.route('*', "/lt/cq_handler", cq_zy.handler), ]) runner = web.AppRunner(app) await runner.setup() site = web.TCPSite(runner, '0.0.0.0', 2020) await site.start() print("Site started.") while True: await asyncio.sleep(100)
def __init__(self): self.name = "v2_private_user" self.plugin_type = "sub_api" self.sub_api = "api_v2" authhandler = bumper.ConfServer.ConfServer_AuthHandler() self.routes = [ web.route( "*", "/private/{country}/{language}/{devid}/{apptype}/{appversion}/{devtype}/{aid}/user/checkLogin", authhandler.login, name="v2_user_checkLogin"), ] self.get_milli_time = bumper.ConfServer.ConfServer_GeneralFunctions( ).get_milli_time
def create_app(endpoints: Tuple[str, ...] = ("success", "failure")) -> web.Application: """Factory for aioHTTP app. Each endpoint except the one for schema saves requests in the list shared in the app instance and could be used to verify generated requests. >>> def test_something(app, server): >>> # make some request to the app here >>> assert app["incoming_requests"][0].method == "GET" """ incoming_requests = [] schema_requests = [] async def schema(request: web.Request) -> web.Response: schema_data = request.app["config"]["schema_data"] content = yaml.dump(schema_data) schema_requests.append(request) return web.Response(body=content) def wrapper(handler_name: str) -> Callable: handler = getattr(handlers, handler_name) @wraps(handler) async def inner(request: web.Request) -> web.Response: if "Content-Type" in request.headers and not request.headers[ "Content-Type"].startswith("multipart/"): await request.read() incoming_requests.append(request) return await handler(request) return inner app = web.Application() app.add_routes([web.get("/swagger.yaml", schema)] + [ web.route(item.value[0], item.value[1], wrapper(item.name)) for item in Endpoint ]) app["incoming_requests"] = incoming_requests app["schema_requests"] = schema_requests app["config"] = { "should_fail": True, "schema_data": make_schema(endpoints) } return app
def __init__(self, redis_server, session_class=None, websocket_path="/porkpepper", **kwargs): if redis_server is None: raise ValueError self._session_class = session_class self._app_options = kwargs or dict() self._http_app: WebsocketApp = WebsocketApp(session_class=session_class, **self._app_options) self._http_app.add_routes([web.route('GET', path, self._http_app.handler) for path in [websocket_path, ]]) self._redis_server_class = redis_server self._redis_server = self._redis_server_class(app=self._http_app) self._redis_server_task = None self._redis_server_object = None self._runner = None self.start_event = asyncio.Event() self.stop_event = asyncio.Event()
async def start(self): app = web.Application() app.add_routes([web.route("*", "/{tail:.*}", self.handle_request)]) aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader(self.dir)) middleware = SnareMiddleware( error_404=self.meta["/status_404"].get("hash"), headers=self.meta["/status_404"].get("headers", []), server_header=self.run_args.server_header, ) middleware.setup_middlewares(app) self.runner = web.AppRunner(app) await self.runner.setup() site = web.TCPSite(self.runner, self.run_args.host_ip, self.run_args.port) await site.start() names = sorted(str(s.name) for s in self.runner.sites) print("======== Running on {} ========\n" "(Press CTRL+C to quit)".format(", ".join(names)))
async def main(): from aiohttp import web async def login(request): request_params = await request.text() r = main_handler({"body": request_params}, None) return web.Response(status=r["statusCode"], text=r["body"], content_type=r["headers"]["Content-Type"]) app = web.Application() app.add_routes([web.route('*', '/login', login)]) runner = web.AppRunner(app) await runner.setup() site = web.TCPSite(runner, '127.0.0.1', 4096) await site.start() print(f"Started. http://127.0.0.1:4096/login") while True: await asyncio.sleep(100)
def create_web_app(*, base_path: str, routes: Sequence[web.RouteDef]) -> web.Application: """Create web application.""" app = web.Application() if base_path.endswith('/'): base_path = base_path[:-1] prefixed_routes = [] for base_route in routes: prefixed_routes.append( web.route( method=base_route.method, path=f'{base_path}{base_route.path}', handler=base_route.handler, **base_route.kwargs, )) app.add_routes(prefixed_routes) return app
async def start(self): app = web.Application() app.add_routes([web.route('*', '/{tail:.*}', self.handle_request)]) aiohttp_jinja2.setup( app, loader=jinja2.FileSystemLoader(self.dir) ) middleware = SnareMiddleware( self.meta['/status_404']['hash'], self.run_args.server_header ) middleware.setup_middlewares(app) self.runner = web.AppRunner(app) await self.runner.setup() site = web.TCPSite(self.runner, self.run_args.host_ip, self.run_args.port) await site.start() names = sorted(str(s.name) for s in self.runner.sites) print("======== Running on {} ========\n" "(Press CTRL+C to quit)".format(', '.join(names)))
def server(self): logger.debug('Запуск сервера') app = web.Application() routes = [ web.route('GET', '/usd/get', self.get_usd), web.route('GET', '/rub/get', self.get_rub), web.route('GET', '/eur/get', self.get_eur), web.route('GET', '/amount/get', self.get_amount), web.route('POST', '/amount/set', self.post_amount_set), web.route('POST', '/modify', self.post_modify) ] app.router.add_routes(routes) app.on_startup.append(self.start_background_tasks) web.run_app(app=app, host='localhost', port=8080)
def function(): routes = [ p__web.route('get', '/', handle), p__web.route('get', '/mongo/', handle_mongo), p__web.route('get', '/postgres/', handle_postgres), p__web.route('get', '/redis/', handle_redis), p__web.route('get', '/time/', handle_time), p__web.route('get', '/url/{name}/', handle_url), ] application = p__web.Application(debug=True, ) application.add_routes(routes) p__web.run_app( application, port=80, )
def add_handler(app, handler, path=None): """ Add a new handler to an application. Can be passed a type instead of an instance, and the handler will be automatically constructed. :param app: aiohttp Application to add handler to :param handler: Handler to add to the application :param path: Path for the handler to control, defaults to the root path """ if isinstance(handler, type): handler = handler(app=app, path=path) if "handlers" not in app: app["handlers"] = [] routes = [] for method in hdrs.METH_ALL: meth = getattr(handler, method.lower(), None) if meth is not None: npath = f"/{path}/{{tail:.*}}" if path else "/{tail:.*}" routes.append(web.route(method, npath, meth)) app.add_routes(routes) app["handlers"].append(handler)
def start_server(middleware, port): asyncio.set_event_loop_policy(uvloop.EventLoopPolicy()) async def handle(request): response_content = HTTPResponse() for plugin in middleware: if plugin.threaded: threading.Thread(target=plugin.handle, args=(request, response_content)).start() else: plugin_output = plugin.handle(request, response_content) if plugin_output: response_content = plugin_output return web.Response(body=response_content.body, content_type=response_content.content_type, status=response_content.status_code) app = web.Application() app.add_routes([web.route("*", "/{tail:.*}", handle)]) web.run_app(app, port=port)
async def start(self): app = web.Application() app.add_routes([web.route('*', '/{tail:.*}', self.handle_request)]) aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader(self.dir)) middleware = SnareMiddleware( error_404=self.meta['/status_404'].get('hash'), headers=self.meta['/status_404'].get('headers', []), server_header=self.run_args.server_header) middleware.setup_middlewares(app) middleware.auth_middlewares(app, self.setting_info['auth_list'], self.setting_info['user_dict']) self.runner = web.AppRunner(app, access_log_class=RuleAccessLogger) await self.runner.setup() site = web.TCPSite(self.runner, self.run_args.host_ip, self.run_args.port) await site.start() names = sorted(str(s.name) for s in self.runner.sites) print("======== Running on {} ========\n" "(Press CTRL+C to quit)".format(', '.join(names)))
def __init__(self): self.name = "v1_private_user" self.plugin_type = "sub_api" self.sub_api = "api_v1" authhandler = bumper.ConfServer.ConfServer_AuthHandler() self.routes = [ web.route("*", "/private/{country}/{language}/{devid}/{apptype}/{appversion}/{devtype}/{aid}/user/login", authhandler.login, name="v1_user_login"), web.route("*", "/private/{country}/{language}/{devid}/{apptype}/{appversion}/{devtype}/{aid}/user/checkLogin", authhandler.login, name="v1_user_checkLogin"), web.route("*", "/private/{country}/{language}/{devid}/{apptype}/{appversion}/{devtype}/{aid}/user/getAuthCode", authhandler.get_AuthCode, name="v1_user_getAuthCode"), web.route("*", "/private/{country}/{language}/{devid}/{apptype}/{appversion}/{devtype}/{aid}/user/logout", authhandler.logout, name="v1_user_logout"), web.route("*", "/private/{country}/{language}/{devid}/{apptype}/{appversion}/{devtype}/{aid}/user/checkAgreement", self.handle_checkAgreement,name="v1_user_checkAgreement"), web.route("*", "/private/{country}/{language}/{devid}/{apptype}/{appversion}/{devtype}/{aid}/user/checkAgreementBatch", self.handle_checkAgreement,name="v1_user_checkAgreementBatch"), web.route("*", "/private/{country}/{language}/{devid}/{apptype}/{appversion}/{devtype}/{aid}/user/getUserAccountInfo", authhandler.getUserAccountInfo,name="v1_user_getUserAccountInfo"), web.route("*", "/private/{country}/{language}/{devid}/{apptype}/{appversion}/{devtype}/{aid}/user/getUserMenuInfo", self.handle_getUserMenuInfo,name="v1_user_getUserMenuInfo"), # Direct register from app: # /{apiversion}/private/{country}/{language}/{devid}/{apptype}/{appversion}/{devtype}/{aid}/user/directRegister #Register by email # /registerByEmail ] self.get_milli_time = bumper.ConfServer.ConfServer_GeneralFunctions().get_milli_time
async def start(self): app = web.Application() app.add_routes([web.route('*', '/{tail:.*}', self.handle_request)]) if self.is_directory: aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader( self.run_args.full_page_path)) middleware = SnareMiddleware( error_404=self.meta['/status_404'].get('hash'), headers=self.meta['/status_404'].get('headers', []), server_header=self.run_args.server_header) middleware.setup_middlewares(app) self.runner = web.AppRunner(app) await self.runner.setup() site = web.TCPSite(self.runner, self.run_args.host_ip, self.run_args.port) await site.start() names = sorted(str(s.name) for s in self.runner.sites) print("======== Running on {} ========\n" "(Press CTRL+C to quit)".format(', '.join(names)))
def setup_catalog(app: web.Application, *, disable_auth=False): # resolve url cfg = get_config(app).copy() app[f"{__name__}.catalog_origin"] = URL.build(scheme="http", host=cfg["host"], port=cfg["port"]) app[f"{__name__}.catalog_version_prefix"] = cfg["version"] specs = app[APP_OPENAPI_SPECS_KEY] # validated openapi specs # bind routes with handlers handler = (_reverse_proxy_handler.__wrapped__ if disable_auth else _reverse_proxy_handler) routes = [ web.route(method.upper(), path, handler, name=operation_id) for method, path, operation_id, tags in iter_path_operations(specs) if "catalog" in tags ] assert routes, "Got no paths tagged as catalog" # nosec # reverse proxy to catalog's API app.router.add_routes(routes)
def create_app(endpoints: Tuple[str, ...] = ("success", "failure")) -> web.Application: """Factory for aioHTTP app. Each endpoint except the one for schema saves requests in the list shared in the app instance and could be used to verify generated requests. >>> def test_something(app, server): >>> # make some request to the app here >>> assert app["incoming_requests"][0].method == "GET" """ incoming_requests = [] schema_requests = [] schema_data = make_schema(endpoints) async def schema(request: web.Request) -> web.Response: content = yaml.dump(schema_data) schema_requests.append(request) return web.Response(body=content) def wrapper(handler: Callable) -> Callable: @wraps(handler) async def inner(request: web.Request) -> web.Response: incoming_requests.append(request) return await handler(request) return inner app = web.Application() app.add_routes([web.get("/swagger.yaml", schema)] + [ web.route(item.value[0], item.value[1], wrapper(item.value[2])) for item in Endpoint if item.name in endpoints ]) app["incoming_requests"] = incoming_requests app["schema_requests"] = schema_requests return app
def setup_catalog(app: web.Application, *, disable_auth=False): # ---------------------------------------------- # TODO: temporary, just to check compatibility between # trafaret and pydantic schemas cfg, _ = assert_valid_config(app) # --------------------------------------------- # resolve url app[KCATALOG_ORIGIN] = URL.build(scheme="http", host=cfg["host"], port=cfg["port"]) app[KCATALOG_VERSION_PREFIX] = cfg["version"] specs = app[APP_OPENAPI_SPECS_KEY] # validated openapi specs exclude: List[str] = [] route_def: RouteDef for route_def in catalog_api_handlers.routes: route_def.kwargs["name"] = operation_id = route_def.handler.__name__ exclude.append(operation_id) app.add_routes(catalog_api_handlers.routes) # bind the rest routes with the reverse-proxy-handler # FIXME: this would reroute **anything** to the catalog service! handler = (_reverse_proxy_handler.__wrapped__ if disable_auth else _reverse_proxy_handler) routes = [ web.route(method.upper(), path, handler, name=operation_id) for method, path, operation_id, tags in iter_path_operations(specs) if "catalog" in tags and operation_id not in exclude ] assert routes, "Got no paths tagged as catalog" # nosec # reverse proxy to catalog's API app.router.add_routes(routes)
def load_handlers(self): data_handlers = { "basic": BasicDataHandler, "anonymous": AnonymousDataHandler, } handlers = [] for mapping in self.__config.get("mapping"): try: security_type = "anonymous" if mapping.get( "security") is None else mapping["security"]["type"].lower( ) if security_type != "anonymous": Users.add_user(mapping['endpoint'], mapping['security']['username'], mapping['security']['password']) for http_method in mapping['HTTPMethods']: handler = data_handlers[security_type]( self.collect_statistic_and_send, self.get_name(), self.endpoints[mapping["endpoint"]]) handlers.append( web.route(http_method, mapping['endpoint'], handler)) except Exception as e: log.error("Error on creating handlers - %s", str(e)) self._app.add_routes(handlers)
data = await request.text() headers = request.headers return web.json_response({ 'message': 'ok', 'data': data, 'headers': dict(headers) }) class ClassView(web.View): async def get(self): return render( 'index.html', self.request, context={'name': self.request.query.get('name') or 'world'}) async def post(self): return web.json_response({'method': 'POST'}, status=201) async def delete(self): return web.json_response({}, status=204) application.add_routes([ web.route('GET', '/hello/{name}', index, name='index'), web.post('/post', post_example, name='post'), web.route('*', '/class-example', ClassView, name='cbv_example') ]) web.run_app(application)
"""Routes of various API versions.""" import aiohttp.web as web from . import resources v1 = [ web.route('*', '/v1/snippets', resources.Snippets), web.route('*', '/v1/snippets/{id}', resources.Snippet), web.route('*', '/v1/syntaxes', resources.Syntaxes), # These routes are what we had before during era of API versioning through # HTTP header. Nowadays we prefer versioning through HTTP URI, but we want # to be good guys and provide these routes for a while and avoid breaking # the world. web.route('*', '/snippets', resources.Snippets), web.route('*', '/snippets/{id}', resources.Snippet), web.route('*', '/syntaxes', resources.Syntaxes), ]
def setup_routes(app: web.Application) -> None: app.add_routes([web.route('*', '/.well-known/webfinger', negotiate.route)])
print('Specified port is out of range.') parser.print_help(sys.stderr) raise SystemExit(0) else: print('You must specify a port to use.') parser.print_help(sys.stderr) raise SystemExit(0) logging.debug('Destination port: {}'.format(str(redirectPort))) if args.destination: redirectHost = args.destination logging.debug('Destination host: {}'.format(redirectHost)) if useHTTPS == False: logging.debug('Starting HTTP redirector.') app.add_routes([web.route('*', '/{path:.*}', handle_http)]) web.run_app(app, host=bindTo, port=listenPort) elif useHTTPS == True: if os.path.exists(args.certificate) and os.path.exists(args.key): logging.debug('Starting HTTPS redirector.') app.add_routes([web.route('*', '/{path:.*}', handle_https)]) ssl_context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH) ssl_context.load_cert_chain(args.certificate, args.key) web.run_app(app, host=bindTo, port=listenPort, ssl_context=ssl_context) else: print('Please make sure the path to the certificate and key are valid') parser.print_help(sys.stderr) raise SystemExit(0) else: print('Secure must be an integer with value 0 or 1') parser.print_help(sys.stderr)
from aiohttp.web import route from game_controller import GameController game_controller = GameController() ROUTES = [route('GET', r'/ws', game_controller.ws_handler)]
## Using coroutines if True: # `app.add_routes` with list async def foo(request): # $ requestHandler return web.Response(text="foo") # $ HttpResponse async def foo2(request): # $ requestHandler return web.Response(text="foo2") # $ HttpResponse async def foo3(request): # $ requestHandler return web.Response(text="foo3") # $ HttpResponse app.add_routes([ web.get("/foo", foo), # $ routeSetup="/foo" web.route("*", "/foo2", foo2), # $ routeSetup="/foo2" web.get(path="/foo3", handler=foo3), # $ routeSetup="/foo3" ]) # using decorator routes = web.RouteTableDef() @routes.get("/bar") # $ routeSetup="/bar" async def bar(request): # $ requestHandler return web.Response(text="bar") # $ HttpResponse @routes.route("*", "/bar2") # $ routeSetup="/bar2" async def bar2(request): # $ requestHandler return web.Response(text="bar2") # $ HttpResponse @routes.get(path="/bar3") # $ routeSetup="/bar3"