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"
