async def start(self): app = web.Application() app.add_routes( [web.static("/static/", os.path.dirname(__file__) + "/static/")]) app.add_routes( [web.get("/stream/{message_id}/{token}", self._stream_handler)]) app.add_routes([ web.options("/stream/{message_id}/{token}", self._upnp_discovery_handler) ]) app.add_routes([ web.put("/stream/{message_id}/{token}", self._upnp_discovery_handler) ]) app.add_routes([web.get("/healthcheck", self._health_check_handler)]) for finder in self._finders: routers = await finder.get_routers(self._config) for handler in routers: app.add_routes([web.get(handler.get_path(), handler.handle)]) # noinspection PyProtectedMember await web._run_app(app, host=self._config.listen_host, port=self._config.listen_port)
def setup() -> _T: state: Dict[str, str] = {} async def reg(request: Request) -> None: nonlocal state state["method"] = request.method state["body"] = await request.read() async def handler(request: Request) -> Response: await reg(request) return Response(text="Some text") async def json_handler(request: Request) -> Response: await reg(request) return json_response({"key": "value"}) app = Application() app.add_routes([ web.get("/url/", handler), web.post("/url/", handler), web.options("/url/", handler), web.put("/url/", handler), web.patch("/url/", handler), web.delete("/url/", handler), web.get("/json_url/", json_handler), ]) return app, state
async def init(data_dir, server_conf, send_queue, recv_queue): """Initialize the proxy and the http server.""" proxy = ProxyDaemon( server_conf.name, server_conf.homeserver, server_conf, data_dir, send_queue=send_queue.async_q if send_queue else None, recv_queue=recv_queue.async_q if recv_queue else None, proxy=server_conf.proxy.geturl() if server_conf.proxy else None, ssl=None if server_conf.ssl is True else False, ) # 100 MB max POST size app = web.Application(client_max_size=1024**2 * 100) app.add_routes([ web.post("/_matrix/client/r0/login", proxy.login), web.get("/_matrix/client/r0/sync", proxy.sync), web.get("/_matrix/client/r0/rooms/{room_id}/messages", proxy.messages), web.put( r"/_matrix/client/r0/rooms/{room_id}/send/{event_type}/{txnid}", proxy.send_message, ), web.post( r"/_matrix/client/r0/rooms/{room_id}/send/{event_type}", proxy.send_message, ), web.post("/_matrix/client/r0/user/{user_id}/filter", proxy.filter), web.post("/.well-known/matrix/client", proxy.well_known), web.get("/.well-known/matrix/client", proxy.well_known), web.post("/_matrix/client/r0/search", proxy.search), web.options("/_matrix/client/r0/search", proxy.search_opts), web.get("/_matrix/media/v1/download/{server_name}/{media_id}", proxy.download), web.get( "/_matrix/media/v1/download/{server_name}/{media_id}/{file_name}", proxy.download, ), web.get("/_matrix/media/r0/download/{server_name}/{media_id}", proxy.download), web.get( "/_matrix/media/r0/download/{server_name}/{media_id}/{file_name}", proxy.download, ), ]) app.router.add_route("*", "/" + "{proxyPath:.*}", proxy.router) app.on_shutdown.append(proxy.shutdown) runner = web.AppRunner(app) await runner.setup() site = web.TCPSite(runner, str(server_conf.listen_address), server_conf.listen_port) return proxy, runner, site
def test_options(router): async def handler(request): pass router.add_routes([web.options('/', handler)]) assert len(router.routes()) == 1 route = list(router.routes())[0] assert route.handler is handler assert route.method == 'OPTIONS' assert str(route.url_for()) == '/'
def test_options(router: Any) -> None: async def handler(request): pass router.add_routes([web.options("/", handler)]) assert len(router.routes()) == 1 route = list(router.routes())[0] assert route.handler is handler assert route.method == "OPTIONS" assert str(route.url_for()) == "/"
def _routes(cls, root, name) -> List[web.RouteDef]: yield from super()._routes(root, name) if cls.add_enabled: yield web.post(root + r'/add/', cls.view(Action.add), name=f'{name}-add') yield web.options(root + r'/add/', cls.view(Action.add_options), name=f'{name}-add-options') if cls.edit_enabled: yield web.post(root + r'/{pk:\d+}/', cls.view(Action.edit), name=f'{name}-edit') yield web.options(root + r'/{pk:\d+}/', cls.view(Action.edit_options), name=f'{name}-edit-options') if cls.delete_enabled: yield web.post(root + r'/{pk:\d+}/delete/', cls.view(Action.delete), name=f'{name}-delete')
async def start(self): app = web.Application() app.add_routes([web.get("/stream/{message_id}", self._stream_handler)]) app.add_routes([ web.options("/stream/{message_id}", self._upnp_discovery_handler) ]) app.add_routes( [web.put("/stream/{message_id}", self._upnp_discovery_handler)]) app.add_routes([web.get("/healthcheck", self._health_check_handler)]) # noinspection PyProtectedMember await aiohttp.web._run_app(app, host=self._config.listen_host, port=self._config.listen_port)
def setUp(self): self.DATA_PATH = './tests/data' self.HOST = '127.0.0.1' self.PORT = 8000 self.SERVER_ADDRESS = (self.HOST, self.PORT) self.app = web.Application() self.app.add_routes([ web.get('/{tail:.*}', handle_factory(self.DATA_PATH)), web.post('/{tail:.*}', handle_factory(self.DATA_PATH)), web.put('/{tail:.*}', handle_factory(self.DATA_PATH)), web.patch('/{tail:.*}', handle_factory(self.DATA_PATH)), web.head('/{tail:.*}', handle_factory(self.DATA_PATH)), web.delete('/{tail:.*}', handle_factory(self.DATA_PATH)), web.options('/{tail:.*}', handle_factory(self.DATA_PATH)), ]) self.test_server = TestServer(self.app, host=self.HOST, port=self.PORT)
def main(): parser = argparse.ArgumentParser(description='HTTP data mocker') parser.add_argument('data_path', help='The data folder') parser.add_argument('-p', '--port', help='The TCP port', default=TCP_PORT, type=int) parser.add_argument('--host', help='The host', default=HOST) parser.add_argument('-l', '--log-file', help='save log messages in a given file') parser.add_argument('-v', '--verbose', action='store_true', default=False, help='print more detailed log messages') parser.add_argument( '--version', action='version', version=f'Mocker version {pkg_resources.require("mocker")[0].version}') args = parser.parse_args() logging_level = logging.DEBUG if args.verbose else logging.INFO logging.basicConfig(filename=args.log_file, level=logging_level) if os.path.exists(args.data_path): app = web.Application() app.add_routes([ web.get('/{tail:.*}', handle_factory(args.data_path)), web.post('/{tail:.*}', handle_factory(args.data_path)), web.put('/{tail:.*}', handle_factory(args.data_path)), web.patch('/{tail:.*}', handle_factory(args.data_path)), web.head('/{tail:.*}', handle_factory(args.data_path)), web.delete('/{tail:.*}', handle_factory(args.data_path)), web.options('/{tail:.*}', handle_factory(args.data_path)), ]) try: web.run_app(app, host=args.host, port=args.port) except KeyboardInterrupt: print('Exiting Mocker...') else: print('Folder {} not found'.format(args.data_path))
async def pan_proxy_server(tempdir, aiohttp_server): loop = asyncio.get_event_loop() app = web.Application() server_name = faker.hostname() config = ServerConfig(server_name, urlparse("https://example.org"), keyring=False) pan_queue = janus.Queue() ui_queue = janus.Queue() proxy = ProxyDaemon(config.name, config.homeserver, config, tempdir, send_queue=pan_queue.async_q, recv_queue=ui_queue.async_q, proxy=None, ssl=False, client_store_class=SqliteStore) app.add_routes([ web.post("/_matrix/client/r0/login", proxy.login), web.get("/_matrix/client/r0/sync", proxy.sync), web.get("/_matrix/client/r0/rooms/{room_id}/messages", proxy.messages), web.put( r"/_matrix/client/r0/rooms/{room_id}/send/{event_type}/{txnid}", proxy.send_message), web.post("/_matrix/client/r0/user/{user_id}/filter", proxy.filter), web.post("/_matrix/client/r0/search", proxy.search), web.options("/_matrix/client/r0/search", proxy.search_opts), ]) server = await aiohttp_server(app) yield server, proxy, (pan_queue, ui_queue) await proxy.shutdown(app)
await g.reset() # disconnect all, reset state if g.id != default_id: # do not delete default game del app.games[g.id] app = web.Application() app.websockets = weakref.WeakSet() app.games = {} # default game, temporary, hackish app.games[default_id] = HatGame(name='Secret Tea') app.games[default_id].id = default_id app.add_routes(( web.get('/', Login, name='login'), web.get('/games/{id}', GetGame, name='get_game'), web.get('/games', ListGames, name='list_games'), web.post('/games', NewGame, name='new_game'), web.get('/ws/{id}', WebSocket, name='game'), web.get('/ws', WebSocket), # default game )) if settings.NEED_CORS: app.add_routes([web.options('/games', NewGame, name='cors')]) cron = Scheduler(60, expire_games, app) if __name__ == '__main__': web.run_app(app, host=settings.SITE_HOST, port=settings.SITE_PORT)
from aiohttp import web from .router import handle_graphql, handle_hello from serverside.server_side_events import ServerSideEvents server_side_events = ServerSideEvents( cors_headers={ "Access-Control-Allow-Origin": "*", "Access-Control-Allow-Credentials": "true", "Access-Control-Allow-Methods": "GET, POST, OPTIONS", "Access-Control-Max-Age": "3600", "Access-Control-Allow-Headers": "Content-Type, Accept, X-Requested-With, Authorization, device" }) routes = [ web.get("/sse", server_side_events.get_system_info), web.get("/hello", handle_hello), web.options("/graphql", handle_graphql), web.post("/graphql", handle_graphql) ]
def __init__(self, app: web.Application, pyctuator_impl: PyctuatorImpl) -> None: super().__init__(app, pyctuator_impl) custom_dumps = partial(json.dumps, default=self._custom_json_serializer) async def empty_handler(request: web.Request) -> web.Response: return web.Response(text='') async def get_endpoints(request: web.Request) -> web.Response: return web.json_response(self.get_endpoints_data(), dumps=custom_dumps) async def get_environment(request: web.Request) -> web.Response: return web.json_response(pyctuator_impl.get_environment(), dumps=custom_dumps) async def get_info(request: web.Request) -> web.Response: return web.json_response(pyctuator_impl.app_info, dumps=custom_dumps) async def get_health(request: web.Request) -> web.Response: return web.json_response(pyctuator_impl.get_health(), dumps=custom_dumps) async def get_metric_names(request: web.Request) -> web.Response: return web.json_response(pyctuator_impl.get_metric_names(), dumps=custom_dumps) async def get_loggers(request: web.Request) -> web.Response: return web.json_response(pyctuator_impl.logging.get_loggers(), dumps=custom_dumps) async def set_logger_level(request: web.Request) -> web.Response: request_dict = await request.json() pyctuator_impl.logging.set_logger_level( request.match_info["logger_name"], request_dict.get("configuredLevel", None), ) return web.json_response({}) async def get_logger(request: web.Request) -> web.Response: logger_name = request.match_info["logger_name"] return web.json_response( pyctuator_impl.logging.get_logger(logger_name), dumps=custom_dumps) async def get_thread_dump(request: web.Request) -> web.Response: return web.json_response(pyctuator_impl.get_thread_dump(), dumps=custom_dumps) async def get_httptrace(request: web.Request) -> web.Response: raw_data = pyctuator_impl.http_tracer.get_httptrace() return web.json_response(raw_data, dumps=custom_dumps) async def get_metric_measurement(request: web.Request) -> web.Response: return web.json_response(pyctuator_impl.get_metric_measurement( request.match_info["metric_name"]), dumps=custom_dumps) async def get_logfile(request: web.Request) -> web.Response: range_header = request.headers.get("range") if not range_header: return web.Response( body=f"{pyctuator_impl.logfile.log_messages.get_range()}") str_res, start, end = pyctuator_impl.logfile.get_logfile( range_header) response = web.Response( status=HTTPStatus.PARTIAL_CONTENT.value, body=str_res, headers={ "Content-Type": "text/html; charset=UTF-8", "Accept-Ranges": "bytes", "Content-Range": f"bytes {start}-{end}/{end}", }, ) return response @web.middleware async def intercept_requests_and_responses(request: web.Request, handler: Callable) -> Any: request_time = datetime.now() response = await handler(request) response_time = datetime.now() # Set the SBA-V2 content type for responses from Pyctuator if request.url.path.startswith( self.pyctuator_impl.pyctuator_endpoint_path_prefix): response.headers["Content-Type"] = SBA_V2_CONTENT_TYPE # Record the request and response new_record = self._create_record(request, response, request_time, response_time) self.pyctuator_impl.http_tracer.add_record(record=new_record) return response app.add_routes([ web.get("/pyctuator", get_endpoints), web.options("/pyctuator/env", empty_handler), web.options("/pyctuator/info", empty_handler), web.options("/pyctuator/health", empty_handler), web.options("/pyctuator/metrics", empty_handler), web.options("/pyctuator/loggers", empty_handler), web.options("/pyctuator/dump", empty_handler), web.options("/pyctuator/threaddump", empty_handler), web.options("/pyctuator/logfile", empty_handler), web.options("/pyctuator/trace", empty_handler), web.options("/pyctuator/httptrace", empty_handler), web.get("/pyctuator/env", get_environment), web.get("/pyctuator/info", get_info), web.get("/pyctuator/health", get_health), web.get("/pyctuator/metrics", get_metric_names), web.get("/pyctuator/metrics/{metric_name}", get_metric_measurement), web.get("/pyctuator/loggers", get_loggers), web.get("/pyctuator/loggers/{logger_name}", get_logger), web.post("/pyctuator/loggers/{logger_name}", set_logger_level), web.get("/pyctuator/dump", get_thread_dump), web.get("/pyctuator/threaddump", get_thread_dump), web.get("/pyctuator/logfile", get_logfile), web.get("/pyctuator/trace", get_httptrace), web.get("/pyctuator/httptrace", get_httptrace), ]) app.middlewares.append(intercept_requests_and_responses)
print("Parsing config file") config = configparser.ConfigParser() config.read_file(open('config.ini')) listen_port = int(config.get('steadyobserver', 'listen_port')) listen_host = config.get('steadyobserver', 'listen_host') mongo_port = int(config.get('mongo', 'listen_port')) mongo_host = config.get('mongo', 'listen_host') #mongo_pass = config.get('mongo', 'password') #mongo_user = config.get('mongo', 'username') print("Building API") app = web.Application() app.add_routes([ web.options('/{tail:.*}', handle_options), web.get('/', get_time), web.get('/time', get_time), web.get('/tasks', get_tasks), web.get('/tasks/{id}', get_task), web.get('/tasks/{id}/results', get_results), web.get('/results/{id}', get_result), web.get('/tasks/uuid/{uuid}', get_task_with_uuid), web.post('/tasks', create_task), web.post('/tasks/{id}/suspend', suspend_task), web.post('/tasks/{id}/resume', resume_task), web.post('/tasks/{id}/result', post_result), web.delete('/tasks/{id}', delete_task), web.delete('/results/{id}', delete_result) ])