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)
