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)
])
