async def run(): app = web.Application(middlewares=[ cors_middleware, db_middleware, auth_middleware, error_middleware ]) def cors_fallback(req): return web.Response(headers={ "Access-Control-Allow-Origin": "*", "Access-Control-Allow-Headers": "Authorization", "Access-Control-Allow-Methods": "GET, POST, PATCH" }, status=404 if req.method != "OPTIONS" else 200) app.add_routes([ web.get("/s", Handlers.get_system), web.post("/s/switches", Handlers.post_switch), web.get("/s/{system}", Handlers.get_other_system), web.get("/s/{system}/members", Handlers.get_system_members), web.get("/s/{system}/switches", Handlers.get_system_switches), web.get("/s/{system}/fronters", Handlers.get_system_fronters), web.patch("/s", Handlers.patch_system), web.get("/m/{member}", Handlers.get_member), web.post("/m", Handlers.post_member), web.patch("/m/{member}", Handlers.patch_member), web.delete("/m/{member}", Handlers.delete_member), web.post("/discord_oauth", Handlers.discord_oauth), web.route("*", "/{tail:.*}", cors_fallback) ]) app["pool"] = await db.connect(os.environ["DATABASE_URI"]) return app
async def register(app: web.Application): """Register routes.""" app.add_routes([ web.post("/revocation/create-registry", revocation_create_registry), web.get( "/revocation/registries/created", revocation_registries_created, allow_head=False, ), web.get("/revocation/registry/{rev_reg_id}", get_registry, allow_head=False), web.get( "/revocation/active-registry/{cred_def_id}", get_active_registry, allow_head=False, ), web.get( "/revocation/registry/{rev_reg_id}/tails-file", get_tails_file, allow_head=False, ), web.patch("/revocation/registry/{rev_reg_id}", update_registry), web.post("/revocation/registry/{rev_reg_id}/publish", publish_registry), web.patch( "/revocation/registry/{rev_reg_id}/set-state", set_registry_state, ), ])
async def register(app: web.Application): """Register routes.""" app.add_routes([ web.post("/revocation/create-registry", create_rev_reg), web.get( "/revocation/registries/created", rev_regs_created, allow_head=False, ), web.get("/revocation/registry/{rev_reg_id}", get_rev_reg, allow_head=False), web.get( "/revocation/active-registry/{cred_def_id}", get_active_rev_reg, allow_head=False, ), web.get( "/revocation/registry/{rev_reg_id}/tails-file", get_tails_file, allow_head=False, ), web.put("/revocation/registry/{rev_reg_id}/tails-file", upload_tails_file), web.patch("/revocation/registry/{rev_reg_id}", update_rev_reg), web.post("/revocation/registry/{rev_reg_id}/definition", send_rev_reg_def), web.post("/revocation/registry/{rev_reg_id}/entry", send_rev_reg_entry), web.patch( "/revocation/registry/{rev_reg_id}/set-state", set_rev_reg_state, ), ])
def setup_routes(self): self.app.add_routes([ web.patch('', self.update_channel_entries), web.delete('', self.delete_channel_entries), web.get('/torrents/{infohash}/health', self.get_torrent_health), web.patch(r'/{public_key:\w*}/{id:\w*}', self.update_channel_entry), web.get(r'/{public_key:\w*}/{id:\w*}', self.get_channel_entries), ])
def _create_api(self, spec) -> None: resource = Resource(spec, self.injector) self.add_routes([ web.get('/', RootResource(spec).get), web.get('/{resource}/{id}', resource.get, allow_head=False), web.get('/{resource}', resource.get, allow_head=False), web.head('/{resource}/{id}', resource.head), web.head('/{resource}', resource.head), web.patch('/{resource}/{id}', resource.patch), web.patch('/{resource}', resource.patch), ])
async def serve_rest(self): global web from aiohttp import web import aiohttp_cors app = web.Application() app.add_routes([ web.get('/{tail:.*}', self._handle_get), web.put('/{tail:.*}', self._handle_put), web.patch('/{tail:.*}', self._handle_equilibrate), ]) # Configure default CORS settings. cors = aiohttp_cors.setup(app, defaults={ "*": aiohttp_cors.ResourceOptions( allow_credentials=True, expose_headers="*", allow_headers="*", allow_methods=["GET", "PATCH", "PUT"] ) }) # Configure CORS on all routes. for route in list(app.router.routes()): cors.add(route) runner = web.AppRunner(app) await runner.setup() site = web.TCPSite(runner, self.address, self.rest_port) #TODO: try more ports await site.start() print("Opened the seamless REST server at port {0}".format(self.rest_port))
def setup_routes(self): self.app.add_routes( [ web.patch('/{infohash}', self.update_tags_entries), web.get('/{infohash}/suggestions', self.get_suggestions), ] )
async def serve_rest(self): global web from aiohttp import web import aiohttp_cors app = web.Application() app.add_routes([ web.get('/{tail:.*}', self._handle_get), web.put('/{tail:.*}', self._handle_put), web.patch('/{tail:.*}', self._handle_equilibrate), ]) # Configure default CORS settings. cors = aiohttp_cors.setup( app, defaults={ "*": aiohttp_cors.ResourceOptions( allow_credentials=True, expose_headers="*", allow_headers="*", allow_methods=["GET", "PATCH", "PUT"]) }) # Configure CORS on all routes. for route in list(app.router.routes()): cors.add(route) runner = web.AppRunner(app) await runner.setup() site = web.TCPSite(runner, self.address, self.rest_port) #TODO: try more ports await site.start() print("Opened the seamless REST server at port {0}".format( self.rest_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
def routes(self): return [ web.get("/api/dashboard", self.dashboards), web.post("/api/dashboard", self.add_dashboard), web.get("/api/dashboard/{dashboard_id}", self.dashboard), web.delete("/api/dashboard/{dashboard_id}", self.remove_dashboard), web.patch("/api/dashboard/{dashboard_id}", self.patch_dashboard), ]
def setup_routes(self): self.app.add_routes([ web.get('', self.get_downloads), web.put('', self.add_download), web.delete('/{infohash}', self.return_404), web.patch('/{infohash}', self.update_download), web.get('/{infohash}/torrent', self.return_404), web.get('/{infohash}/files', self.get_files), ])
async def register(app: web.Application): """Register routes.""" app.add_routes([ web.post("/revocation/create-registry", revocation_create_registry), web.get("/revocation/registry/{id}", get_current_registry), web.get("/revocation/registry/{id}/tails-file", get_tails_file), web.patch("/revocation/registry/{id}", update_registry), web.post("/revocation/registry/{id}/publish", publish_registry), ])
def get_routes(api): return [ web.post('/api/card_payment', api.card_payment_post), web.post('/api/requested_payment', api.requested_payment_post), web.get('/api/card_payment', api.card_payment_get), web.get('/api/requested_payment', api.requested_payment_get), web.patch('/api/card_payment', api.card_payment_patch), web.post('/api/internet_bank_payment', api.internet_bank_payment), web.get('/payment/{customer}', api.payment_customer), ]
async def run(): app = web.Application( middlewares=[db_middleware, auth_middleware, error_middleware]) app.add_routes([ web.get("/s", Handlers.get_system), web.post("/s/switches", Handlers.post_switch), web.get("/s/{system}", Handlers.get_other_system), web.get("/s/{system}/members", Handlers.get_system_members), web.get("/s/{system}/switches", Handlers.get_system_switches), web.get("/s/{system}/fronters", Handlers.get_system_fronters), web.patch("/s", Handlers.patch_system), web.get("/m/{member}", Handlers.get_member), web.post("/m", Handlers.post_member), web.patch("/m/{member}", Handlers.patch_member), web.delete("/m/{member}", Handlers.delete_member), web.post("/discord_oauth", Handlers.discord_oauth) ]) app["pool"] = await db.connect(os.environ["DATABASE_URI"]) return app
def test_patch(router: Any) -> None: async def handler(request): pass router.add_routes([web.patch("/", handler)]) assert len(router.routes()) == 1 route = list(router.routes())[0] assert route.handler is handler assert route.method == "PATCH" assert str(route.url_for()) == "/"
def add_handlers(app): """ Adding handlers for web application """ app.add_routes([web.get('', handlers.get_help_handle), web.post('/imports', handlers.import_handle), web.patch('/imports/{import_id}/citizens/{citizen_id}', handlers.patch_handle), web.get('/imports/{import_id}/citizens', handlers.get_citizens_handle), web.get('/imports/{import_id}/citizens/birthdays', handlers.get_presents_handle), web.get('/imports/{import_id}/towns/stat/percentile/age', handlers.percentile_handle) ])
def create_app(settings: Optional[Settings] = None) -> web.Application: """Identification provider entry point: builds and run a webserver.""" settings = settings or load_conf() app = web.Application(middlewares=[enforce_json, vary_origin]) setup(app) app["settings"] = settings app["identity_backend"] = import_idp( settings["identity_backend"]["class"])( options=settings["identity_backend"].get("options", {})) async def on_startup_wrapper(app): """Wrapper to call __aenter__.""" await app["identity_backend"].__aenter__() async def on_cleanup_wrapper(app): """Wrapper to call __exit__.""" await app["identity_backend"].__aexit__(None, None, None) app.on_startup.append(on_startup_wrapper) app.on_cleanup.append(on_cleanup_wrapper) app.add_routes([ web.get("/", views.get_root), web.get("/users/", views.get_users), web.post("/users/", views.post_users), web.get("/jwt/", views.get_jwts), web.post("/jwt/", views.post_jwt), web.get("/jwt/{jid}", views.get_jwt), web.get("/users/", views.get_users), web.patch("/users/{user_id}/", views.patch_user), web.get("/password_recoveries/", views.get_password_recoveries), web.post("/password_recoveries/", views.post_password_recoveries), web.get("/health", views.get_health), ]) cors = aiohttp_cors.setup( app, defaults={ "*": aiohttp_cors.ResourceOptions( allow_credentials=True, expose_headers="*", allow_headers="*", allow_methods=[ "GET", "OPTIONS", "PUT", "POST", "DELETE", "PATCH" ], ) }, ) for route in list(app.router.routes()): cors.add(route) return app
def start_server(): app = web.Application() app.add_routes([ web.get('/', handle), web.patch('/', handle), web.post('/', handle), web.put('/', handle), ]) runner = web.AppRunner(app) return runner
def test_patch(router): async def handler(request): pass router.add_routes([web.patch('/', handler)]) assert len(router.routes()) == 1 route = list(router.routes())[0] assert route.handler is handler assert route.method == 'PATCH' assert str(route.url_for()) == '/'
def setup_routes(self): self.app.add_routes([ web.get('', self.get_downloads), web.put('', self.add_download), web.delete('/{infohash}', self.delete_download), web.patch('/{infohash}', self.update_download), web.get('/{infohash}/torrent', self.get_torrent), web.get('/{infohash}/files', self.get_files), web.get('/{infohash}/stream/{fileindex}', self.stream, allow_head=False) ])
async def register(app: web.Application): """Register routes.""" app.add_routes([ web.post("/ledger/register-nym", register_ledger_nym), web.patch("/ledger/rotate-public-did-keypair", rotate_public_did_keypair), web.get("/ledger/did-verkey", get_did_verkey, allow_head=False), web.get("/ledger/did-endpoint", get_did_endpoint, allow_head=False), web.get("/ledger/taa", ledger_get_taa, allow_head=False), web.post("/ledger/taa/accept", ledger_accept_taa), ])
def setup_routes(self): self.app.add_routes([ web.get('', self.get_channel), web.put('', self.update_channel), web.post('', self.create_channel), web.get('/torrents', self.get_torrents), web.post('/torrents', self.update_torrents), web.delete('/torrents', self.delete_torrent), web.get('/torrents/count', self.get_torrent_count), web.patch('/torrents/{infohash}', self.update_torrent), web.post('/commit', self.commit), ])
def routes(self): return [ put('/upload/drive/v3/files/progress/{id}', self._uploadProgress), post('/upload/drive/v3/files/', self._upload), post('/drive/v3/files/', self._create), get('/drive/v3/files/', self._query), delete('/drive/v3/files/{id}/', self._delete), patch('/drive/v3/files/{id}/', self._update), get('/drive/v3/files/{id}/', self._get), post('/oauth2/v4/token', self._oauth2Token), get('/o/oauth2/v2/auth', self._oAuth2Authorize), get('/drive/customcreds', self._getCustomCred), post('/token', self._driveToken), ]
async def register(app: web.Application): """Register routes.""" app.add_routes([ web.get("/wallet/did", wallet_did_list, allow_head=False), web.post("/wallet/did/create", wallet_create_did), web.get("/wallet/did/public", wallet_get_public_did, allow_head=False), web.post("/wallet/did/public", wallet_set_public_did), web.post("/wallet/set-did-endpoint", wallet_set_did_endpoint), web.get("/wallet/get-did-endpoint", wallet_get_did_endpoint, allow_head=False), web.patch("/wallet/did/local/rotate-keypair", wallet_rotate_did_keypair), ])
def _register_routes(self): self._app.add_routes([ web.get("/", lambda _: web.HTTPFound("/index.html")), # search web.get("/api/v1/search", self._search_handler.search), web.get("/api/v1/details", self._search_handler.details), # session web.get("/api/v1/session", self._session_handler.show), web.post("/api/v1/session", self._session_handler.update), # torrents web.get("/api/v1/session/torrents", self._torrents_handler.index), web.get("/api/v1/session/torrents/{info_hash}", self._torrents_handler.show), web.post("/api/v1/session/torrents", self._torrents_handler.create), web.patch("/api/v1/session/torrents/{info_hash}", self._torrents_handler.update), web.delete("/api/v1/session/torrents/{info_hash}", self._torrents_handler.destroy), # files web.get("/api/v1/session/torrents/{info_hash}/files", self._files_handler.index), web.get("/api/v1/session/torrents/{info_hash}/files/{file_idx}", self._files_handler.show), web.patch("/api/v1/session/torrents/{info_hash}/files/{file_idx}", self._files_handler.update), # watch web.get("/watch", self._watch_handler.show), web.get("/watch/{info_hash}", self._watch_handler.show), web.get("/watch/{info_hash}/{file_name}", self._watch_handler.show), web.get("/play/{info_hash}/{file_name}", self._play), # static # always keep static route last web.static("/", self.resource_path("web/")) ])
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 create_application(path): app = web.Application() try: db = sqlite3.connect(path) app['db'] = db except sqlite3.Error as e: print(e) app.add_routes([ web.post('/couriers', couriers), web.patch('/couriers/{id}', update_couriers), web.post('/orders', orders), web.post('/orders/assign', assign_orders), web.post('/orders/complete', complete_orders), web.get('/couriers/{id}', courier_info) ]) return app
async def async_main(): stdout_handler = logging.StreamHandler(sys.stdout) for logger_name in ["aiohttp.server", "aiohttp.web", "aiohttp.access"]: logger = logging.getLogger(logger_name) logger.setLevel(logging.DEBUG) logger.addHandler(stdout_handler) async def handle_http(request): data = { "method": request.method, "content": (await request.read()).decode(), "headers": dict(request.headers), } return web.json_response( data, status=405, headers={"from-upstream": "upstream-header-value"} ) async def handle_websockets(request): wsock = web.WebSocketResponse() await wsock.prepare(request) await wsock.send_str(json.dumps(dict(request.headers))) async for msg in wsock: if msg.type == aiohttp.WSMsgType.CLOSE: await wsock.close() if msg.type == aiohttp.WSMsgType.TEXT: await wsock.send_str(msg.data) if msg.type == aiohttp.WSMsgType.BINARY: await wsock.send_bytes(msg.data) return wsock upstream = web.Application() upstream.add_routes( [ web.get("/http", handle_http), web.patch("/http", handle_http), web.get("/websockets", handle_websockets), ] ) upstream_runner = web.AppRunner(upstream) await upstream_runner.setup() upstream_site = web.TCPSite(upstream_runner, "0.0.0.0", 8888) await upstream_site.start() await asyncio.Future()
def __init__(self, **kwargs): self.app = web.Application(**kwargs) self.app.router.add_routes([ web.post("/user", self._post_user), web.patch("/user", self._patch_user), web.get("/user", self._get_user), web.delete("/user", self._delete_user), web.delete(r"/user/error/{id:[a-f0-9]+}", self._delete_user_error), web.get("/user/courses", self._get_user_courses), web.post("/user/courses/update", self._post_user_courses_update), web.post("/form_geometry", self._post_form_geometry), web.post("/update_all_courses", self._post_update_all_courses), web.get("/debug/tasks", self._get_debug_tasks), web.post("/debug/tasks/update", self._post_debug_tasks_update), web.post("/test_form", self._post_test_form) ]) self.db = LockboxDB("db", 27017)
def routes(self): return [ post('/addons/self/options', self.hassioUpdateOptions), post("/homeassistant/api/services/persistent_notification/dismiss", self.dismissNotification), post("/homeassistant/api/services/persistent_notification/create", self.createNotification), post("/homeassistant/api/events/{name}", self.haEventUpdate), post("/homeassistant/api/states/{entity}", self.haStateUpdate), post('/auth', self.hassioAuthenticate), get('/auth', self.hassioAuthenticate), get('/info', self.hassioInfo), get('/addons/self/info', self.hassioSelfInfo), get('/snapshots/{slug}/download', self.hassioSnapshotDownload), get('/snapshots/{slug}/info', self.hassioSnapshotInfo), post('/snapshots/{slug}/remove', self.hassioDelete), post('/snapshots/new/upload', self.uploadNewSnapshot), get('/snapshots/new/upload', self.uploadNewSnapshot), get('/debug/toggleblock', self.toggleBlockSnapshot), post('/snapshots/new/partial', self.hassioNewPartialSnapshot), post('/snapshots/new/full', self.hassioNewFullSnapshot), get('/snapshots/new/full', self.hassioNewFullSnapshot), get('/homeassistant/info', self.haInfo), get('/supervisor/info', self.hassioSupervisorInfo), get('/supervisor/logs', self.supervisorLogs), get('/core/logs', self.coreLogs), get('/snapshots', self.hassioSnapshots), put('/upload/drive/v3/files/progress/{id}', self.driveContinueUpload), post('/upload/drive/v3/files/', self.driveStartUpload), post('/drive/v3/files/', self.driveCreate), get('/drive/v3/files/', self.driveQuery), delete('/drive/v3/files/{id}/', self.driveDelete), patch('/drive/v3/files/{id}/', self.driveUpdate), get('/drive/v3/files/{id}/', self.driveGetItem), post('/updatesettings', self.updateSettings), get('/readfile', self.readFile), post('/uploadfile', self.uploadfile), post('/doareset', self.reset), post('/oauth2/v4/token', self.driveRefreshToken), get('/o/oauth2/v2/auth', self.driveAuthorize), post('/token', self.driveToken), get('/hassio/ingress/self_slug', self.slugRedirect) ]
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))