def setup_routes(self): self.app.add_routes([web.get('', self.list_pseudonyms), web.get('/{pseudonym_name}/schemas', self.list_schemas), web.get('/{pseudonym_name}/public_key', self.get_pseudonym_public_key), web.get('/{pseudonym_name}/unload', self.unload_pseudonym), web.get('/{pseudonym_name}/remove', self.remove_pseudonym), web.get('/{pseudonym_name}/credentials', self.list_pseudonym_credentials), web.get('/{pseudonym_name}/credentials/{subject_key}', self.list_subject_credentials), web.get('/{pseudonym_name}/peers', self.list_pseudonym_peers), web.put('/{pseudonym_name}/allow/{verifier_key}', self.allow_pseudonym_verification), web.put('/{pseudonym_name}/disallow/{verifier_key}', self.disallow_pseudonym_verification), web.put('/{pseudonym_name}/request/{authority_key}', self.create_pseudonym_credential), web.put('/{pseudonym_name}/attest/{subject_key}', self.attest_pseudonym_credential), web.put('/{pseudonym_name}/verify/{subject_key}', self.verify_pseudonym_credential), web.get('/{pseudonym_name}/outstanding/attestations', self.list_pseudonym_outstanding_attestations), web.get('/{pseudonym_name}/outstanding/verifications', self.list_pseudonym_outstanding_verifications), web.get('/{pseudonym_name}/verifications', self.list_pseudonym_verification_output) ])
def setup_routes(self): self.app.add_routes([ web.get('', self.get_channels), web.get(r'/{channel_pk:\w*}/{channel_id:\w*}', self.get_channel_contents), web.get(r'/{channel_pk:\w*}/{channel_id:\w*}/description', self.get_channel_description), web.put(r'/{channel_pk:\w*}/{channel_id:\w*}/description', self.put_channel_description), web.get(r'/{channel_pk:\w*}/{channel_id:\w*}/thumbnail', self.get_channel_thumbnail), web.put(r'/{channel_pk:\w*}/{channel_id:\w*}/thumbnail', self.put_channel_thumbnail), web.post(r'/{channel_pk:\w*}/{channel_id:\w*}/copy', self.copy_channel), web.post(r'/{channel_pk:\w*}/{channel_id:\w*}/channels', self.create_channel), web.post(r'/{channel_pk:\w*}/{channel_id:\w*}/collections', self.create_collection), web.put(r'/{channel_pk:\w*}/{channel_id:\w*}/torrents', self.add_torrent_to_channel), web.post(r'/{channel_pk:\w*}/{channel_id:\w*}/commit', self.post_commit), web.get(r'/{channel_pk:\w*}/{channel_id:\w*}/commit', self.is_channel_dirty), web.get('/popular_torrents', self.get_popular_torrents_channel), ])
def setup_routes(self): self.app.add_routes([ web.get('/drift', self.retrieve_drift), web.put('/drift', self.enable_measurements), web.get('/tasks', self.get_asyncio_tasks), web.put('/debug', self.set_asyncio_debug), web.get('/debug', self.get_asyncio_debug) ])
def __init__(self): self.loop = None self.runner = None self.app = web.Application(middlewares=[self._authorize]) self.app.router.add_routes([ web.get('/', self.info), web.get('/version.json', self.stub_get), web.get('/dbinfo', self.dbinfo), web.get('/folders.json', self.stub_get), web.get('/stream.json', self.stream_info), web.post('/stream.json', self.create_stream), web.put('/stream.json', self.update_stream), web.put('/stream/move.json', self.move_stream), web.delete('/stream.json', self.delete_stream), web.post('/data', self.data_write), web.get('/data', self.data_read), web.get('/data/intervals.json', self.data_intervals), web.delete('/data', self.data_delete), web.get('/modules.json', self.stub_get), web.get('/module.json', self.stub_get), web.get('/module/logs.json', self.stub_get), web.put('/folder/move.json', self.move_folder), web.delete('/folder.json', self.delete_folder), web.get("/folder.json", self.folder_info), web.put("/folder.json", self.update_folder), web.get('/masters.json', self.stub_get), web.post('/master.json', self.create_master), web.delete('/master.json', self.delete_master), web.get('/annotations.json', self.get_annotations), web.put('/annotation.json', self.update_annotation), web.post('/annotation.json', self.create_annotation), web.delete('/annotation.json', self.delete_annotation), web.delete('/stream/annotations.json', self.delete_all_annotations) ]) self.stub_stream_info = False self.stub_stream_move = False self.stub_data_delete = False self.stub_stream_destroy = False self.stub_stream_create = False self.stub_data_read = False self.stub_data_write = False self.stub_folder_move = False self.stub_folder_destroy = False self.stub_folder_info = False self.stub_folder_update = False self.stub_data_intervals = False self.stub_master = False self.stub_stream_update = False self.stub_annotation = False self.first_lumen_user = True self.response = "" # need this because node info cmd makes two requests self.dbinfo_response = "--fill-in--" self.http_code = 200 self.streams: Dict[str, MockDbEntry] = {} self.msgs = None self.key = "invalid"
def _add_routes(self): self.app.add_routes([ web.get("/backup", self.backup_list), web.post("/backup", self.backup_create), web.put("/replication_state", self.replication_state_set), web.get("/status", self.status_show), web.put("/status", self.status_update), web.get("/status/restore", self.restore_status_show), ])
async def get_application(self): app = web.Application() app.add_routes([ web.get("/fail", self.fail_route), web.get("/succeed", self.succeed_route), web.put("/fail", self.fail_route), web.put("/succeed", self.succeed_route), ]) return app
def __init__(self): application = web.Application() application.add_routes([ web.get("/", self.handle_get), web.get("/{id}", self.handle_get_id), web.put("/edit/{id}", self.handle_edit), web.put("/delete/{id}", self.handle_remove_id), web.post("/add", self.handle_post), ]) web.run_app(application)
def make_routes(): routes = [ # websocket web.get('/ws', websocket_handler), # api web.post('/api/preview', preview), web.get('/api/project', project), web.get('/api/user_identity', user_identity), web.post('/api/issues', issue_add), web.put('/api/issues/{id}', issue_update), web.delete('/api/issues/{id}', issue_delete), web.post('/api/issues/{issue_id}/comments', issue_comment_add), web.put('/api/issues/{issue_id}/comments/{id}', issue_comment_update), web.delete( '/api/issues/{issue_id}/comments/{id}', issue_comment_delete ), web.get(r'/api/wiki/{path:\S*}', wiki_page), web.put(r'/api/wiki/{path:\S+}', wiki_page_update), web.delete(r'/api/wiki/{path:\S+}', wiki_page_delete), # serve uploaded file web.get(r'/files/{path:\S+}', file_get), # frontend web.get('/', static_handler('index.html')), # for SPA routing web.get('/issues{p:.*}', static_handler('index.html')), web.get('/wiki{p:.*}', static_handler('index.html')), web.get('/bundle.css', static_handler('bundle.css')), web.get('/bundle.css.map', static_handler('bundle.css.map')), web.get('/bundle.js', static_handler('bundle.js')), web.get('/bundle.js.map', static_handler('bundle.js.map')), web.get('/favicon.png', static_handler('favicon.png')), web.get('/global.css', static_handler('global.css')), web.get( '/vendor/docutils/math.css', static_handler('vendor/docutils/math.css') ), web.get( '/vendor/pygments/default.css', static_handler('vendor/pygments/default.css') ), web.get( '/vendor/mermaid/mermaid-8.8.0.min.js', static_handler('vendor/mermaid/mermaid-8.8.0.min.js') ), ] return routes
def routes(self): return [ web.post('/template', self.post), web.put('/template', self.put), web.delete('/template', self.delete), web.put('/template/repo', self.pull_repo), # Read ones web.get('/template', self.get), web.get('/templates', self.list_all), web.get('/template/detail', self.detail), web.get('/template/page', self.page) ]
def aiowebcam(argv=None): app = AioWebcam() run_app( host='localhost', port=8080, routes=[ web.get('/', app.index), web.get('/api/v1/video/out', app.video_out), web.put('/api/v1/video/header', app.video_header), web.put('/api/v1/video/chunks', app.video_chunks), ], )
def run_forever(self): app = web.Application() app.add_routes([ web.put('/add', self.add), web.put('/get_rows', self.get_rows), web.put('/get_agg', self.get_agg), ]) web.run_app( app, host=self.host, port=self.port, )
async def http_server(db_connection, shared_obj, config): app = web.Application() user = User(db_connection, shared_obj, config, sendWSMessage) app.add_routes([ web.get('/api/users', user.get), web.get('/api/users/{id}', user.get), web.post('/api/users', user.post), web.put('/api/users/{id}', user.put), web.delete('/api/users/{id}', user.delete), ]) production = Production(db_connection, shared_obj, config, sendWSMessage) app.add_routes([ web.post('/api/production', production.post), web.get('/api/production', production.get), web.get('/api/production/{id}', production.get), web.put('/api/production/{id}', production.put), web.delete('/api/production/{id}', production.delete), ]) printer = Printer(db_connection, shared_obj, config, sendWSMessage) app.add_routes([ web.get('/api/print/{action}', printer.get), web.post('/api/print/{action}', printer.post), web.get('/api/print/{action}/{subaction}', printer.get), web.post('/api/print/{action}/{subaction}', printer.post), web.put('/api/print/{action}/{subaction}', printer.put), web.delete('/api/print/{action}/{subaction}', printer.delete) ]) index = Index(db_connection, shared_obj, config) app.add_routes([ web.get('/', index.get), web.get('/users', index.get), web.get('/weighing', index.get), web.get('/templates', index.get), web.get('/production/list', index.get), web.get('/api/{action}', index.get) ]) app.add_routes([ web.static('/', './static'), ]) setup_middlewares(app) runner = web.AppRunner(app, logger=LOGGER) await runner.setup() site = web.TCPSite(runner, '0.0.0.0', 8080) await site.start()
async def init(loop): app = web.Application() tags_handler = TagsHandler(loop) ratings_handler = RatingsHandler(loop) logging.basicConfig(level=logging.INFO, format='%(asctime)s %(message)s', datefmt='%d/%m/%Y %I:%M:%S %p') app.add_routes([ web.put(url_prefix + "movie/{movieId}/tag/{tag}", tags_handler.add_tag_to_movie), web.put(url_prefix + "movie/{movieId}/rating/{rating}", ratings_handler.add_rating_to_movie) ]) return app
async def start_kapow_server(bind, scripts, capem=None, certfile=None, interactive=False, keyfile=None): user_app = DynamicApplication(client_max_size=1024**3) user_app["user_routes"] = list() # [KapowRoute] user_runner = web.AppRunner(user_app) await user_runner.setup() ssl_context = None if certfile and keyfile and capem: ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLSv1_2) ssl_context.verify_mode = ssl.CERT_REQUIRED ssl_context.load_verify_locations(cafile=capem) ssl_context.load_cert_chain(certfile, keyfile=keyfile) ssl_context.check_hostname = False ip, port = bind.split(':') user_site = web.TCPSite(user_runner, ip, int(port), ssl_context=ssl_context) await user_site.start() control_app = web.Application(client_max_size=1024**3) control_app.add_routes([ # Control API web.get('/routes', get_routes(user_app)), web.get('/routes/{id}', get_route(user_app)), web.post('/routes', append_route(user_app)), web.put('/routes', insert_route(user_app)), web.delete('/routes/{id}', delete_route(user_app)), # Data API web.get('/handlers/{id}/{field:.*}', get_field), web.put('/handlers/{id}/{field:.*}', set_field), ]) control_app["scripts"] = scripts control_app["interactive"] = interactive control_app.on_startup.append(start_background_tasks) control_runner = web.AppRunner(control_app) await control_runner.setup() control_site = web.TCPSite(control_runner, '127.0.0.1', 8081) await control_site.start()
def __init__(self): self.app = web.Application() self.app.router.add_routes([ web.get('/', self.info), web.get('/dbinfo', self.dbinfo), web.get('/stream/get_metadata', self.stream_get_metadata), web.post('/stream/set_metadata', self.stream_set_metadata), web.post('/stream/create', self.stream_create), web.put('/stream/insert', self.stream_insert), web.get('/stream/extract', self.stream_extract), web.get('/stream/intervals', self.stream_intervals), web.post('/stream/remove', self.stream_remove), web.get('/stream/list', self.stream_list), web.post('/stream/destroy', self.stream_destroy) ]) self.runner = None self.error_on_paths = {} # (msg, status) tuples to return for path self.stub_stream_create = False self.stub_stream_intervals = False self.http_code = 200 self.response = '' # record of transactions self.posts = [] self.gets = [] self.extract_calls = [] self.remove_calls = [] self.destroy_calls = [] self.stream_list_response = None # dict path=>layout from stream/create calls self.streams: Dict[str, FakeStream] = {} # optional queue of messages self.msgs: multiprocessing.Queue = None
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 __init__(self, config, orchestrator): self.config = config self.orchestrator = orchestrator self.app = web.Application( client_max_size=16 * 1024 * 1024, # 16MB max request size ) self.app.add_routes([ web.get('/', self.index), web.get('/ping', self.ping), web.get('/config', self.get_config), web.put('/config', self.put_config), web.get('/clients', self.get_clients), web.post('/clients', self.post_clients), web.get('/clients/{client_name}/debug', self.get_client_debug), web.post('/torrents/{realm_name}', self.post_torrents), web.delete('/torrents/{realm_name}/{info_hash}', self.delete_torrent), web.post('/pop_update_batch', self.post_pop_update_batch), web.get('/torrents/force_recheck/{realm_name}/{info_hash}', self.force_recheck), web.get('/torrents/pause_torrent/{realm_name}/{info_hash}', self.pause_torrent), web.get('/torrents/resume_torrent/{realm_name}/{info_hash}', self.resume_torrent), web.post('/torrents/rename_torrent/{realm_name}/{info_hash}', self.rename_torrent), web.get('/torrents/force_reannounce/{realm_name}/{info_hash}', self.force_reannounce), web.post('/torrents/move_data/{realm_name}/{info_hash}', self.move_data), ])
async def start_pool_server(): global server global runner private_key: PrivateKey = AugSchemeMPL.key_gen(std_hash(b"123")) config = load_config(DEFAULT_ROOT_PATH, "config.yaml") overrides = config["network_overrides"]["constants"][ config["selected_network"]] constants: ConsensusConstants = DEFAULT_CONSTANTS.replace_str_to_bytes( **overrides) server = PoolServer(private_key, config, constants) await server.start() # TODO(pool): support TLS app = web.Application() app.add_routes([ web.get("/", server.wrap_http_handler(server.index)), web.get("/pool_info", server.wrap_http_handler(server.get_pool_info)), web.get("/farmer", server.wrap_http_handler(server.get_farmer)), web.post("/farmer", server.wrap_http_handler(server.post_farmer)), web.put("/farmer", server.wrap_http_handler(server.put_farmer)), web.post("/partial", server.wrap_http_handler(server.post_partial)), web.get("/login", server.wrap_http_handler(server.get_login)), ]) runner = aiohttp.web.AppRunner(app, access_log=None) await runner.setup() site = aiohttp.web.TCPSite(runner, "0.0.0.0", int(80)) await site.start() await asyncio.sleep(10000000)
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 __init__(self): self.app = web.Application() #TODO register more handlers self.app.add_routes([web.post('/register', self.__register_handler)]) self.app.add_routes([web.put('/user-data', self.__put__data_handler)]) self.app.add_routes([web.get("/user-data", self.__get_data_handler)]) self.app.add_routes([web.get("/ping", self.__ping_handler)]) # Worker threads setup self.threads = [] self.threads.append(Thread(target=self.__duty_cycle_tick, args=[5])) self.threads.append(Thread(target=self.__group_match_tick, args=[10])) self.user_dict_lock = Lock() self.user_dict = {} self.non_member_id_set = set() self.group_dict_lock = Lock() self.group_dict = {} self.prev_initial_match = [] for thread in self.threads: thread.start() web.run_app(self.app)
def generate_routes() -> list: routes = [] for key, value in ROUTER.items(): if 'GET' in value: handler = value['GET'] routes.append( web.get(value['url'], object_at_end_of_path(handler), name=f'get-{key}')) if 'PUT' in value: handler = value['PUT'] routes.append( web.put(value['url'], object_at_end_of_path(handler), name=f'put-{key}')) if 'POST' in value: handler = value['POST'] routes.append( web.post(value['url'], object_at_end_of_path(handler), name=f'post-{key}')) return routes
def register(self,app): app.router.add_routes([ web.get('/limits/{client_id}', self.get_limits_handler, name="limit_get"), web.post('/limits', self.post_limits_handler, name="limit_post"), web.put('/limits/{client_id}', self.put_limits_handler, name = "limit_put"), web.delete('/limits/{client_id}', self.delete_limits_handler, name = "limit_delete") ])
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() -> _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 __init__(self, worker_agent, port): self._owner_worker_agent = worker_agent self._server = None self._runner = None self._port = port self._host_url = 'localhost' self._handler = Handler(self._owner_worker_agent) self._routers = [ web.get('/{uuid}/hello', self._handler.handle_test_hello), web.post('/{uuid}/controls/tick', self._handler.handle_start_worker), web.delete('/{uuid}/controls/tick', self._handler.handle_stop_worker), web.delete('/{uuid}/blackboard', self._handler.handle_reset_worker), web.put('/{uuid}/controls/tick', self._handler.handle_set_interval), web.get('/{uuid}', self._handler.handle_get_virtual_worker), web.get('/{uuid}/options', self._handler.handle_get_options), web.get('/{uuid}/blackboard', self._handler.handle_get_blackboard), web.get('/{uuid}/location', self._handler.handle_get_location), web.get('/{uuid}/controls/messages', self._handler.handle_get_messages), web.post('/{uuid}/controls/messages', self._handler.handle_add_messages), ]
def add_response( self, route: str, method: str, response: Union[Any, PathLike] = None, status: int = 200, ) -> None: """Push a mocked response onto a route.""" if isinstance(response, PathLike): with open(response) as json_file: response = json.load(json_file) else: response = response if (route, method) not in self.responses: if method.upper() == "GET": routes = [web.get(route, self._handler)] elif method.upper() == "POST": routes = [web.post(route, self._handler)] elif method.upper() == "PUT": routes = [web.put(route, self._handler)] else: raise TypeError(f"Unsupported method {method}") self.app.add_routes(routes) self.responses[(route, method)].append((status, response))
def setup_routes(self): self.app.add_routes([web.get('/statistics', self.get_statistics), web.get('/values', self.get_stored_values), web.get('/values/{key}', self.get_values), web.put('/values/{key}', self.put_value), web.get('/peers/{mid}', self.get_peer), web.get('/block', self.get_block)])
def setup_routes(app: web.Application) -> None: app.router.add_routes([ web.post("/tokens", handlers.handle_create_token), web.put("/tokens", handlers.handle_refresh_token), web.delete("/tokens", handlers.handle_delete_token), web.post("/users", handlers.handle_create_user) ])
def setup_routes(self, app): app.add_routes([ web.get("/api/v1/authors", self.author_ctl.get_authors), web.post("/api/v1/authors", self.author_ctl.save_author), web.put("/api/v1/authors", self.author_ctl.update_author), web.delete("/api/v1/authors", self.author_ctl.remove_author), ])
async def start_pool_server(pool_store: Optional[AbstractPoolStore] = None): global server global runner config = load_config(DEFAULT_ROOT_PATH, "config.yaml") overrides = config["network_overrides"]["constants"][ config["selected_network"]] constants: ConsensusConstants = DEFAULT_CONSTANTS.replace_str_to_bytes( **overrides) server = PoolServer(config, constants, pool_store) await server.start() app = web.Application() app.add_routes([ web.get("/", server.wrap_http_handler(server.index)), web.get("/pool_info", server.wrap_http_handler(server.get_pool_info)), web.get("/farmer", server.wrap_http_handler(server.get_farmer)), web.post("/farmer", server.wrap_http_handler(server.post_farmer)), web.put("/farmer", server.wrap_http_handler(server.put_farmer)), web.post("/partial", server.wrap_http_handler(server.post_partial)), web.get("/login", server.wrap_http_handler(server.get_login)), ]) runner = aiohttp.web.AppRunner(app, access_log=None) await runner.setup() ssl_context = get_ssl_context(server.pool_config) site = aiohttp.web.TCPSite( runner, host=server.host, port=server.port, ssl_context=ssl_context, ) await site.start() while True: await asyncio.sleep(3600)
async def register(app: web.Application): """Register routes.""" app.add_routes( [ web.get("/mediation/requests", list_mediation_requests, allow_head=False), web.get( "/mediation/requests/{mediation_id}", retrieve_mediation_request, allow_head=False, ), web.delete("/mediation/requests/{mediation_id}", delete_mediation_request), web.post( "/mediation/requests/{mediation_id}/grant", mediation_request_grant, ), web.post("/mediation/requests/{mediation_id}/deny", mediation_request_deny), web.post("/mediation/request/{conn_id}", request_mediation), web.get("/mediation/keylists", get_keylist, allow_head=False), web.post( "/mediation/keylists/{mediation_id}/send-keylist-update", send_keylist_update, ), web.post( "/mediation/keylists/{mediation_id}/send-keylist-query", send_keylist_query, ), web.get( "/mediation/default-mediator", get_default_mediator, allow_head=False ), web.put("/mediation/{mediation_id}/default-mediator", set_default_mediator), web.delete("/mediation/default-mediator", clear_default_mediator), ] )
def test_put(router): async def handler(request): pass router.add_routes([web.put('/', handler)]) assert len(router.routes()) == 1 route = list(router.routes())[0] assert route.handler is handler assert route.method == 'PUT' assert str(route.url_for()) == '/'
def main(argv: List[str]): opts = parse_args(argv) if opts.subparser_name == 'server': ssl_context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH) ssl_context.load_cert_chain(opts.cert, opts.key) ssl_context.check_hostname = False ssl_context.verify_mode = ssl.CERT_NONE auth = basic_auth_middleware(json.load(open(opts.password_db))) app = web.Application(middlewares=[auth], client_max_size=MAX_FILE_SIZE) app.add_routes([web.put('/archives', functools.partial(handle_put, opts.storage_folder, opts.min_free_space)), web.get('/list', functools.partial(handle_list, opts.storage_folder)), web.post('/get', functools.partial(handle_get, opts.storage_folder)), web.post('/del', functools.partial(handle_del, opts.storage_folder))]) host, port = opts.addr.split(":") web.run_app(app, host=host, port=int(port), ssl_context=ssl_context) elif opts.subparser_name == 'user_add': if os.path.exists(opts.db): db = json.load(open(opts.db)) else: db = {} if opts.password is None: if opts.user not in db: print("User not in db yet, provide password") exit(1) enc_password, salt, _ = db[opts.user] else: enc_password, salt = encrypt_password(opts.password) db[opts.user] = [enc_password, salt, opts.role] js = json.dumps(db, indent=4, sort_keys=True) open(opts.db, "w").write(js) else: assert opts.subparser_name == 'user_rm' db = json.load(open(opts.db)) if opts.user not in db: exit(0) del db[opts.user] js = json.dumps(db, indent=4, sort_keys=True) open(opts.db, "w").write(js)
if not e: return web.Response(text="Resource not found") e.prompt = d return web.Response(text="ok") def registTask(site, loop): global vrc cors = [] vrc = VRCollection.vrCollection(loop, host=HOST) cors.append(site.start()) # webサーバ return (cors) app = web.Application() # HTTPd用のルーティング設定 routes = [ web.get ("/", web_hello), web.get ("/vr", web_getportlist), web.get ("/vr/{port}", web_getdetail), web.put ("/vr/{port}", web_createvr), web.put ("/vr/{port}/scenario/{id}", web_putscenario), web.delete("/vr/{port}/scenario/{id}", web_delscenario), web.post ("/vr/{port}/restart", web_restart), web.get ("/vr/{port}/status", web_getstatus), web.get("/vr/{port}/create", web_createport), web.get("/port/{port}/set/{desc}", web_getsetportname), ] # その追加 app.add_routes(routes)