async def run(self):
app_runner = None
site = None
try:
app = web.Application(client_max_size=HTTP_CLIENT_MAX_SIZE)
app.add_routes([
web.post('/api/v1alpha/batches/jobs/create', self.create_job),
web.delete(
'/api/v1alpha/batches/{batch_id}/jobs/{job_id}/delete',
self.delete_job),
web.get('/api/v1alpha/batches/{batch_id}/jobs/{job_id}/log',
self.get_job_log),
web.get('/api/v1alpha/batches/{batch_id}/jobs/{job_id}/status',
self.get_job_status),
web.get('/healthcheck', self.healthcheck)
])
app_runner = web.AppRunner(app)
await app_runner.setup()
site = web.TCPSite(app_runner, '0.0.0.0', 5000)
await site.start()
try:
await asyncio.wait_for(self.activate(),
MAX_IDLE_TIME_MSECS / 1000)
except asyncio.TimeoutError:
log.exception(
f'could not activate after trying for {MAX_IDLE_TIME_MSECS} ms, exiting'
)
else:
idle_duration = time_msecs() - self.last_updated
while self.jobs or idle_duration < MAX_IDLE_TIME_MSECS:
log.info(
f'n_jobs {len(self.jobs)} free_cores {self.cpu_sem.value / 1000} idle {idle_duration}'
)
await asyncio.sleep(15)
idle_duration = time_msecs() - self.last_updated
log.info(f'idle {idle_duration} ms, exiting')
async with get_context_specific_ssl_client_session(
raise_for_status=True,
timeout=aiohttp.ClientTimeout(total=60)) as session:
# Don't retry. If it doesn't go through, the driver
# monitoring loops will recover. If the driver is
# gone (e.g. testing a PR), this would go into an
# infinite loop and the instance won't be deleted.
await session.post(deploy_config.url(
'batch-driver', '/api/v1alpha/instances/deactivate'),
headers=self.headers)
log.info('deactivated')
finally:
log.info('shutting down')
if site:
await site.stop()
log.info('stopped site')
if app_runner:
await app_runner.cleanup()
log.info('cleaned up app runner')
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 _register_store(self) -> None:
"""Register store endpoints."""
api_store = APIStore()
api_store.coresys = self.coresys
self.webapp.add_routes([
web.get("/store", api_store.store_info),
web.get("/store/addons", api_store.addons_list),
web.get("/store/addons/{addon}", api_store.addons_addon_info),
web.get("/store/addons/{addon}/{version}",
api_store.addons_addon_info),
web.get("/store/addons/{addon}/icon", api_store.addons_addon_icon),
web.get("/store/addons/{addon}/logo", api_store.addons_addon_logo),
web.get("/store/addons/{addon}/changelog",
api_store.addons_addon_changelog),
web.get(
"/store/addons/{addon}/documentation",
api_store.addons_addon_documentation,
),
web.post("/store/addons/{addon}/install",
api_store.addons_addon_install),
web.post(
"/store/addons/{addon}/install/{version}",
api_store.addons_addon_install,
),
web.post("/store/addons/{addon}/update",
api_store.addons_addon_update),
web.post(
"/store/addons/{addon}/update/{version}",
api_store.addons_addon_update,
),
web.post("/store/reload", api_store.reload),
web.get("/store/repositories", api_store.repositories_list),
web.get(
"/store/repositories/{repository}",
api_store.repositories_repository_info,
),
web.post("/store/repositories", api_store.add_repository),
web.delete("/store/repositories/{repository}",
api_store.remove_repository),
])
# Reroute from legacy
self.webapp.add_routes([
web.post("/addons/reload", api_store.reload),
web.post("/addons/{addon}/install",
api_store.addons_addon_install),
web.post("/addons/{addon}/update", api_store.addons_addon_update),
web.get("/addons/{addon}/icon", api_store.addons_addon_icon),
web.get("/addons/{addon}/logo", api_store.addons_addon_logo),
web.get("/addons/{addon}/changelog",
api_store.addons_addon_changelog),
web.get(
"/addons/{addon}/documentation",
api_store.addons_addon_documentation,
),
])
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),
])
def register_routes(app):
by_id_route = BASE_ROUTE + "/{id}"
app.router.add_routes([
web.get(BASE_ROUTE, MenuView),
web.post(BASE_ROUTE, MenuView),
web.get(by_id_route, MenuView),
web.put(by_id_route, MenuView),
web.delete(by_id_route, MenuView)
])
async def register(app: web.Application):
"""Register routes."""
app.add_routes(
[
web.get(
"/issue-credential-2.0/records",
credential_exchange_list,
allow_head=False,
),
web.post(
"/issue-credential-2.0/create-offer",
credential_exchange_create_free_offer,
),
web.get(
"/issue-credential-2.0/records/{cred_ex_id}",
credential_exchange_retrieve,
allow_head=False,
),
web.post("/issue-credential-2.0/create", credential_exchange_create),
web.post("/issue-credential-2.0/send", credential_exchange_send),
web.post(
"/issue-credential-2.0/send-proposal", credential_exchange_send_proposal
),
web.post(
"/issue-credential-2.0/send-offer", credential_exchange_send_free_offer
),
web.post(
"/issue-credential-2.0/send-request",
credential_exchange_send_free_request,
),
web.post(
"/issue-credential-2.0/records/{cred_ex_id}/send-offer",
credential_exchange_send_bound_offer,
),
web.post(
"/issue-credential-2.0/records/{cred_ex_id}/send-request",
credential_exchange_send_bound_request,
),
web.post(
"/issue-credential-2.0/records/{cred_ex_id}/issue",
credential_exchange_issue,
),
web.post(
"/issue-credential-2.0/records/{cred_ex_id}/store",
credential_exchange_store,
),
web.post(
"/issue-credential-2.0/records/{cred_ex_id}/problem-report",
credential_exchange_problem_report,
),
web.delete(
"/issue-credential-2.0/records/{cred_ex_id}",
credential_exchange_remove,
),
]
)
def attach(self, app: web.Application):
app.add_routes([
web.get('/sensors', self.handle_get),
web.post('/sensors', self.handle_post),
web.put('/sensors/{sensor_id}', self.handle_put),
web.delete('/sensors/{sensor_id}', self.handle_delete)
])
return app
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 setup_routes(app: Application, db: WebsiteStatusDB):
app.add_routes([
web.get('/api/websites/', handler=api_view(db)(list_websites)),
web.post('/api/websites/', handler=api_view(db)(add_website)),
web.delete('/api/websites/{url_id}/',
handler=api_view(db)(remove_website)),
web.get('/api/websites/status/', handler=api_view(db)(list_statuses)),
web.get('/', handler=api_view(db)(main_page)),
])
def setup_routes(app: web.Application) -> None:
app.add_routes([
# Subscriptions
web.get(
path='/newsfeed/{newsfeed_id}/subscriptions/',
handler=subscriptions.get_subscriptions_handler,
),
web.post(
path='/newsfeed/{newsfeed_id}/subscriptions/',
handler=subscriptions.post_subscription_handler,
),
web.delete(
path='/newsfeed/{newsfeed_id}/subscriptions/{subscription_id}/',
handler=subscriptions.delete_subscription_handler,
),
web.get(
path='/newsfeed/{newsfeed_id}/subscribers/subscriptions/',
handler=subscriptions.get_subscriber_subscriptions_handler,
),
# Events
web.get(
path='/newsfeed/{newsfeed_id}/events/',
handler=events.get_events_handler,
),
web.post(
path='/newsfeed/{newsfeed_id}/events/',
handler=events.post_event_handler,
),
web.delete(
path='/newsfeed/{newsfeed_id}/events/{event_id}/',
handler=events.delete_event_handler,
),
# Miscellaneous
web.get(
path='/status/',
handler=misc.get_status_handler,
),
web.get(
path='/docs/',
handler=misc.get_openapi_schema_handler,
),
])
def app():
"""Entry point of app.
Get and parse command line parameters and configure web app.
Command line options:
-p --port - port (default: 8080).
-f --folder - working directory (absolute or relative path, default: current app folder FileServer).
-i --init - initialize database.
-h --help - help.
"""
parser = commandline_parser()
namespace = parser.parse_args(sys.argv[1:])
db = DataBase()
if namespace.init:
db.init_system()
handler = Handler(namespace.folder)
app = web.Application()
app.add_routes([
web.get('/', handler.handle),
web.get('/files/list', handler.get_files),
web.get('/files', handler.get_file_info),
web.post('/files', handler.create_file),
web.delete('/files/{filename}', handler.delete_file),
web.get('/files/download', handler.download_file),
web.get('/files/download/queued', handler.download_file_queued),
web.post('/signup', handler.signup),
web.post('/signin', handler.signin),
web.get('/logout', handler.logout),
web.put('/method/{method_name}', handler.add_method),
web.delete('/method/{method_name}', handler.delete_method),
web.put('/role/{role_name}', handler.add_role),
web.delete('/role/{role_name}', handler.delete_role),
web.post('/add_method_to_role', handler.add_method_to_role),
web.post('/delete_method_from_role', handler.delete_method_from_role),
web.post('/change_shared_prop', handler.change_shared_prop),
web.post('/change_user_role', handler.change_user_role),
web.post('/change_file_dir', handler.change_file_dir),
])
logging.basicConfig(level=logging.INFO)
web.run_app(app, port=namespace.port)
def add_urls(app):
app.add_routes([
web.get('/', get_index),
web.get('/cursos', get_todos_cursos),
web.get('/curso/{id}', get_curso),
web.get('/cursos/nome/{nome}', get_cursos_nome),
web.post('/insere/curso', post_curso),
web.put('/atualiza/curso', put_curso),
web.delete('/deleta/curso/{id}', deleta_curso)
])
def _register_auth(self) -> None:
"""Register auth functions."""
api_auth = APIAuth()
api_auth.coresys = self.coresys
self.webapp.add_routes([
web.post("/auth", api_auth.auth),
web.post("/auth/reset", api_auth.reset),
web.delete("/auth/cache", api_auth.cache),
])
def _register_services(self):
api_services = APIServices()
api_services.coresys = self.coresys
self.webapp.add_routes([
web.get('/services', api_services.list),
web.get('/services/{service}', api_services.get_service),
web.post('/services/{service}', api_services.set_service),
web.delete('/services/{service}', api_services.del_service),
])
def bind(self, app: web.Application):
app.add_routes([
web.get("/about", self.about),
web.get("/users/", self.get_users),
web.get(r"/users/{id}", self.get_user),
web.post("/users/", self.add_user),
web.delete("/users/{id}", self.del_user),
web.get("/users/{id}/avatar", self.get_user_avatar),
web.put("/users/{id}/avatar", self.update_user_avatar),
])
def setup_route():
return [
web.post('/register', service.register),
web.post('/get-state', service.get_data_last_state),
web.delete('/gate', service.delete_gate_id),
web.post('/upload-encoded', service.forward_encoded_image),
web.post('/upload', service.forward_raw_image),
web.post('/upload-url', service.forward_url_image),
web.post('/lpr-result', service.get_data_image_result_by_ticket_number)
]
def create_subapp():
app = web.Application()
app.add_routes([
web.get('/', handle_articles_fetch),
web.post('/', handle_article_create),
web.get(r'/{id:\d+}', handle_article_fetch),
web.put(r'/{id:\d+}', handle_article_update),
web.delete(r'/{id:\d+}', handle_article_delete)
])
return app, []
def setup_routes(app: web.Application):
app.router.add_routes([
# REST API v1
# Friends:
web.get('/v1/users/{user_id}/friends', v1.friends.get_friends),
web.post('/v1/users/{user_id}/friends', v1.friends.add_friend),
web.get('/v1/users/{user_id}/friends/{friend_id}',
v1.friends.get_friend),
web.delete('/v1/users/{user_id}/friends/{friend_id}',
v1.friends.delete_friend),
# Users:
web.get('/v1/users', v1.users.get_users),
web.post('/v1/users', v1.users.add_user),
web.get('/v1/users/{user_id}', v1.users.get_user),
web.delete('/v1/users/{user_id}', v1.users.delete_user),
# REST API v2
# ...
])
def create_subapp():
app = web.Application()
app.add_routes([
web.get('/', handle_orders_fetch),
web.post('/', handle_order_create),
web.get(r'/{order_number:.+}', handle_order_fetch),
web.put(r'/{order_number:.+}', handle_order_update),
web.delete(r'/{order_number:.+}', handle_order_delete)
])
return app, []
def _register_resolution(self) -> None:
"""Register info functions."""
api_resolution = APIResoulution()
api_resolution.coresys = self.coresys
self.webapp.add_routes([
web.get("/resolution/info", api_resolution.info),
web.post(
"/resolution/suggestion/{suggestion}",
api_resolution.apply_suggestion,
),
web.delete(
"/resolution/suggestion/{suggestion}",
api_resolution.dismiss_suggestion,
),
web.delete(
"/resolution/issue/{issue}",
api_resolution.dismiss_issue,
),
])
def get_app(system_version_file: str = None,
config_file_override: str = None,
name_override: str = None,
loop: asyncio.AbstractEventLoop = None) -> web.Application:
""" Build and return the aiohttp.web.Application that runs the server
The params can be overloaded for testing.
"""
if not system_version_file:
system_version_file = BR_BUILTIN_VERSION_FILE
version = get_version(system_version_file)
name = name_override or name_management.get_name()
config_obj = config.load(config_file_override)
LOG.info("Setup: " + '\n\t'.join([
f'Device name: {name}', f'Buildroot version: '
f'{version.get("buildroot_version", "unknown")}',
f'\t(from git sha '
f'{version.get("buildroot_sha", "unknown")}',
f'API version: '
f'{version.get("opentrons_api_version", "unknown")}',
f'\t(from git sha '
f'{version.get("opentrons_api_sha", "unknown")}',
f'Update server version: '
f'{version.get("update_server_version", "unknown")}',
f'\t(from git sha '
f'{version.get("update_server_sha", "unknown")}',
f'Smoothie firmware version: TODO'
]))
if not loop:
loop = asyncio.get_event_loop()
app = web.Application(loop=loop, middlewares=[log_error_middleware])
app[config.CONFIG_VARNAME] = config_obj
app[constants.RESTART_LOCK_NAME] = asyncio.Lock()
app[constants.DEVICE_NAME_VARNAME] = name
app.router.add_routes([
web.get('/server/update/health',
control.build_health_endpoint(version)),
web.post('/server/update/begin', update.begin),
web.post('/server/update/cancel', update.cancel),
web.get('/server/update/{session}/status', update.status),
web.post('/server/update/{session}/file', update.file_upload),
web.post('/server/update/{session}/commit', update.commit),
web.post('/server/restart', control.restart),
web.get('/server/ssh_keys', ssh_key_management.list_keys),
web.post('/server/ssh_keys', ssh_key_management.add),
web.delete('/server/ssh_keys/{key_md5}', ssh_key_management.remove),
web.post('/server/name', name_management.set_name_endpoint),
web.get('/server/name', name_management.get_name_endpoint),
])
return app
def test_delete(router):
async def handler(request):
pass
router.add_routes([web.delete('/', handler)])
assert len(router.routes()) == 1
route = list(router.routes())[0]
assert route.handler is handler
assert route.method == 'DELETE'
assert str(route.url_for()) == '/'
def main():
app = web.Application()
s = SwaggerFile(app, "/docs", "petstore.yaml")
s.add_routes([
web.get("/pets", get_all_pets),
web.get("/pets/{pet_id}", get_one_pet),
web.delete("/pets/{pet_id}", delete_one_pet),
web.post("/pets", create_pet),
])
app["storage"] = {}
web.run_app(app)
def routes(self):
return [
web.post('/project', self.create),
web.put('/project', self.update),
web.delete('/project', self.delete),
web.get('/project', self.get),
web.get('/project/detail', self.detail),
web.get('/project/page', self.page),
web.post('/project/generate', self.generate),
web.post('/project/commit', self.commit_push)
]
def test_delete(router: Any) -> None:
async def handler(request):
pass
router.add_routes([web.delete("/", handler)])
assert len(router.routes()) == 1
route = list(router.routes())[0]
assert route.handler is handler
assert route.method == "DELETE"
assert str(route.url_for()) == "/"
def _register_services(self) -> None:
"""Register services functions."""
api_services = APIServices()
api_services.coresys = self.coresys
self.webapp.add_routes([
web.get('/services', api_services.list),
web.get('/services/{service}', api_services.get_service),
web.post('/services/{service}', api_services.set_service),
web.delete('/services/{service}', api_services.del_service),
])
def _register_discovery(self) -> None:
"""Register discovery functions."""
api_discovery = APIDiscovery()
api_discovery.coresys = self.coresys
self.webapp.add_routes([
web.get('/discovery', api_discovery.list),
web.get('/discovery/{uuid}', api_discovery.get_discovery),
web.delete('/discovery/{uuid}', api_discovery.del_discovery),
web.post('/discovery', api_discovery.set_discovery),
])
async def register(app: web.Application):
"""Register routes."""
app.add_routes(
[
web.get(
"/present-proof-2.0/records",
present_proof_list,
allow_head=False,
),
web.get(
"/present-proof-2.0/records/{pres_ex_id}",
present_proof_retrieve,
allow_head=False,
),
web.get(
"/present-proof-2.0/records/{pres_ex_id}/credentials",
present_proof_credentials_list,
allow_head=False,
),
web.post(
"/present-proof-2.0/send-proposal",
present_proof_send_proposal,
),
web.post(
"/present-proof-2.0/create-request",
present_proof_create_request,
),
web.post(
"/present-proof-2.0/send-request",
present_proof_send_free_request,
),
web.post(
"/present-proof-2.0/records/{pres_ex_id}/send-request",
present_proof_send_bound_request,
),
web.post(
"/present-proof-2.0/records/{pres_ex_id}/send-presentation",
present_proof_send_presentation,
),
web.post(
"/present-proof-2.0/records/{pres_ex_id}/verify-presentation",
present_proof_verify_presentation,
),
web.post(
"/present-proof-2.0/records/{pres_ex_id}/problem-report",
present_proof_problem_report,
),
web.delete(
"/present-proof-2.0/records/{pres_ex_id}",
present_proof_remove,
),
]
)
def _register_discovery(self):
api_discovery = APIDiscovery()
api_discovery.coresys = self.coresys
self.webapp.add_routes([
web.get('/services/discovery', api_discovery.list),
web.get('/services/discovery/{uuid}', api_discovery.get_discovery),
web.delete('/services/discovery/{uuid}',
api_discovery.del_discovery),
web.post('/services/discovery', api_discovery.set_discovery),
])
def __init__(self):
self.handlers = {}
app = self.app = web.Application()
app.add_routes([web.post('/{cls}', self.new),
web.post('/{cls}/{instance}/player', self.new_player),
web.get('/{cls}/{instance}/player/{pid}/e', self.player_events),
web.post('/{cls}/{instance}/player/{pid}/e/{event}', self.ack_player_event),
web.get('/{cls}/{instance}/player/{pid}/f', self.player_futures),
web.delete('/{cls}/{instance}/player/{pid}/f/{future}', self.ack_player_future),
web.post('/{cls}/{instance}/{method}', self.invoke),
])
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)
