async def test_aiohttp_error(self):
exc = web_exceptions.HTTPNotFound()
response = await view_test(exc)
assert response.status == 404
assert json.loads(response.text) == {
"message": "HTTPNotFound", "debug_message": "404: Not Found", "code": None,
}
async def running_interactive_services_get(request, service_uuid): # pylint:disable=unused-argument
log.debug(
"Client does running_interactive_services_get request %s with service_uuid %s",
request, service_uuid)
try:
service = await producer.get_service_details(service_uuid)
return web.json_response(data=dict(data=service), status=200)
except exceptions.ServiceUUIDNotFoundError as err:
raise web_exceptions.HTTPNotFound(reason=str(err))
except Exception as err:
raise web_exceptions.HTTPInternalServerError(reason=str(err))
async def receive_redirect_to(request):
""" Receives the OAuth redirect_to response and forwards it to a registerd
client if a match can be found.
"""
token = await extract_token(request)
if token:
return await forward_request(token, request)
raise ex.HTTPNotFound(reason="Invalid token")
async def get_file_bytes(request: web.Request):
"""
Gets the file identified by the sha256sum.
The client can decide the number of file to get using the
"bytes" query param.
"""
id = request.match_info['id']
try:
# all the following should probably go to another function
with get_file(id) as (io, file_size, filename):
# do we limit to N-nth byte or to the whole file?
max_byte = request.query.get('max_byte', None)
if max_byte:
try:
max_byte = int(max_byte)
except ValueError:
raise web_exceptions.HTTPBadRequest(
text=f'max_byte must be an integer "{max_byte}" found')
if max_byte <= 0:
raise web_exceptions.HTTPBadRequest(
text=f'max_byte must be positive "{max_byte}" found')
else:
max_byte = file_size
# We use a streaming response here
response = web.StreamResponse(
headers={
'Content-Length': str(max_byte),
'Content-Disposition': f'attachment;filename="{filename}"'
})
await response.prepare(request)
# stream with 16 Kib chunks
chunk_size = (2**3)**4
# Iterate through the file until we hit 0.
while max_byte > 0:
chunk_size = min(max_byte, chunk_size)
text = io.read(chunk_size)
await response.write(text)
max_byte -= chunk_size
# ok we write the eof at the end of the cycle
await response.write_eof(b'')
except FileNotFoundError:
raise web_exceptions.HTTPNotFound(text=f"Resource {id} not found.")
return response
async def running_interactive_services_delete(request, service_uuid): # pylint:disable=unused-argument
log.debug(
"Client does running_interactive_services_delete request %s with service_uuid %s",
request, service_uuid)
try:
await producer.stop_service(service_uuid)
except exceptions.ServiceUUIDNotFoundError as err:
raise web_exceptions.HTTPNotFound(reason=str(err))
except Exception as err:
raise web_exceptions.HTTPInternalServerError(reason=str(err))
return web.json_response(status=204)
async def add_card(self, request):
"""
---
description: Запрос для добавления новой карты клиента
tags:
- Cards
produces:
- application/json
- application/xml
parameters:
- name: card
in: body
description: данные новой карты
required: true
schema:
type: object
properties:
owner_id:
type: integer
description: идентификатор владельца карты
required: true
payment_system:
type: string
description: платежная система
required: true
currency:
type: string
description: валюта карты
required: true
balance:
type: numeric
description: баланс карты
required: true
responses:
"200":
description: успех. Возвращает данные новой карты клиента
"404":
description: ошибка. Клиент не найден
"406":
description: ошибка клиента. Указан неверный Accept
"""
encoder = self.__choose_encoder(request)
data = await self.__decode_post(request)
try:
card = await self.__client_model.add_card(data)
return web.HTTPCreated(content_type=encoder.content_type, body=encoder.encode(card))
except MultipleInvalid as e:
raise web_exceptions.HTTPBadRequest(text=str(e))
except ItemNotFoundException as e:
raise web_exceptions.HTTPNotFound(text=str(e))
async def running_interactive_services_delete(
request: web.Request, service_uuid: str) -> web.Response:
log.debug(
"Client does running_interactive_services_delete request %s with service_uuid %s",
request,
service_uuid,
)
try:
await producer.stop_service(request.app, service_uuid)
except exceptions.ServiceUUIDNotFoundError as err:
raise web_exceptions.HTTPNotFound(reason=str(err))
except Exception as err:
raise web_exceptions.HTTPInternalServerError(reason=str(err))
return web.json_response(status=204)
async def services_by_key_version_get(request, service_key, service_version): # pylint:disable=unused-argument
log.debug(
"Client does services_get request %s with service_key %s, service_version %s",
request, service_key, service_version)
try:
services = [
await registry_proxy.get_service_details(service_key,
service_version)
]
return web.json_response(data=dict(data=services))
except exceptions.ServiceNotAvailableError as err:
raise web_exceptions.HTTPNotFound(reason=str(err))
except exceptions.RegistryConnectionError as err:
raise web_exceptions.HTTPUnauthorized(reason=str(err))
except Exception as err:
raise web_exceptions.HTTPInternalServerError(reason=str(err))
async def _get_node_details(node_key: str, node_version: str,
app: web.Application) -> Dict:
if "file-picker" in node_key:
# create a fake file-picker schema here!!
fake_node_details = {
"inputs": {},
"outputs": {
"outFile": {
"label": "the output",
"displayOrder": 0,
"description": "a file",
"type": "data:*/*",
}
},
"type": "dynamic",
}
return fake_node_details
if "frontend/nodes-group" in node_key:
return None
if "StimulationSelectivity" in node_key:
# create a fake file-picker schema here!!
fake_node_details = {
"inputs": {},
"outputs": {
"stimulationFactor": {
"label": "the output",
"displayOrder": 0,
"description": "a file",
"type": "data:*/*",
"defaultValue": 0.6,
}
},
"type": "dynamic",
}
return fake_node_details
node_details = await director_api.get_service_by_key_version(
app, node_key, node_version)
if not node_details:
log.error(
"Error (while getting node details) could not find service %s:%s",
node_key,
node_version,
)
raise web_exceptions.HTTPNotFound(
reason=
f"details of service {node_key}:{node_version} could not be found")
return node_details
async def get_service_labels(request: web.Request, service_key: str,
service_version: str) -> web.Response:
log.debug(
"Retrieving service labels %s with service_key %s, service_version %s",
request,
service_key,
service_version,
)
try:
service_labels = await registry_proxy.get_image_labels(
request.app, service_key, service_version)
return web.json_response(data=dict(data=service_labels))
except exceptions.ServiceNotAvailableError as err:
raise web_exceptions.HTTPNotFound(reason=str(err))
except exceptions.RegistryConnectionError as err:
raise web_exceptions.HTTPUnauthorized(reason=str(err))
except Exception as err:
raise web_exceptions.HTTPInternalServerError(reason=str(err))
async def _get_node_extras(node_key: str, node_version: str,
app: web.Application) -> Dict:
"""Returns the service_extras if possible otherwise None"""
if to_node_class(node_key) == NodeClass.FRONTEND:
return None
node_extras = await director_api.get_services_extras(
app, node_key, node_version)
if not node_extras:
log.error(
"Error (while getting node extras) could not find service %s:%s",
node_key,
node_version,
)
raise web_exceptions.HTTPNotFound(
reason=
f"extras of service {node_key}:{node_version} could not be found")
return node_extras
async def archivate(request: web.Request):
folder_to_download = request.app['archives_folder_path'].joinpath(
request.match_info["archive_hash"])
logging.debug(f"Searching for files in {folder_to_download.as_posix()}")
# check for unexisting folders and path injections
if not folder_to_download.exists(
) or '.' in request.match_info["archive_hash"]:
logging.debug(f"'{folder_to_download.as_posix()}' doesn't exists ")
return web_exceptions.HTTPNotFound(text=await get_404_content(),
content_type='text/html')
logging.debug(f"{folder_to_download.as_posix()} has been found")
response = web.StreamResponse()
response.headers[
'Content-Disposition'] = 'attachment; filename="archive.zip"'
await response.prepare(request)
cmd_to_zip = shlex.split(
ZIP_GENERATE_CMD_TMP.format(folder_path=folder_to_download.absolute()))
archive_stream_proc = await asyncio.create_subprocess_exec(
*cmd_to_zip, stdout=asyncio.subprocess.PIPE)
logging.debug(
f"Starting download pid: {archive_stream_proc.pid} with delay {request.app['interval_secs']} secs."
)
try:
while True:
chunk = await archive_stream_proc.stdout.read(CHUNK_SIZE)
if not chunk:
break
logging.debug('Sending archive chunk ...')
await response.write(chunk)
await asyncio.sleep(request.app['interval_secs'])
except asyncio.CancelledError:
logging.debug("Download was interrupted")
logging.debug(f"Killing process {archive_stream_proc.pid}")
archive_stream_proc.kill()
raise
finally:
await archive_stream_proc.wait()
response.force_close()
return response
async def _get_node_details(node_key: str, node_version: str,
app: web.Application) -> dict:
if "file-picker" in node_key:
# create a fake file-picker schema here!!
fake_node_details = {
"inputs": {},
"outputs": {
"outFile": {
"label": "the output",
"displayOrder": 0,
"description": "a file",
"type": "data:*/*"
}
},
"type": "dynamic"
}
return fake_node_details
if "StimulationSelectivity" in node_key:
# create a fake file-picker schema here!!
fake_node_details = {
"inputs": {},
"outputs": {
"stimulationFactor": {
"label": "the output",
"displayOrder": 0,
"description": "a file",
"type": "data:*/*",
"defaultValue": 0.6
}
},
"type": "dynamic"
}
return fake_node_details
try:
services_enveloped = await director_sdk.create_director_api_client(
app).services_by_key_version_get(node_key, node_version)
node_details = services_enveloped.data[0].to_dict()
return node_details
except ApiException as err:
log.exception("Error could not find service %s:%s", node_key,
node_version)
raise web_exceptions.HTTPNotFound(reason=str(err))
async def services_by_key_version_get(request: web.Request, service_key: str,
service_version: str) -> web.Response:
log.debug(
"Client does services_get request %s with service_key %s, service_version %s",
request,
service_key,
service_version,
)
try:
services = [
await registry_proxy.get_image_details(request.app, service_key,
service_version)
]
return web.json_response(data=dict(data=services))
except exceptions.ServiceNotAvailableError as err:
raise web_exceptions.HTTPNotFound(reason=str(err))
except exceptions.RegistryConnectionError as err:
raise web_exceptions.HTTPUnauthorized(reason=str(err))
except Exception as err:
raise web_exceptions.HTTPInternalServerError(reason=str(err))
async def running_interactive_services_post(
request: web.Request,
user_id: str,
project_id: str,
service_key: str,
service_uuid: str,
service_tag: str,
service_basepath: str,
) -> web.Response:
log.debug(
"Client does running_interactive_services_post request %s with user_id %s, project_id %s, service %s:%s, service_uuid %s, service_basepath %s",
request,
user_id,
project_id,
service_key,
service_tag,
service_uuid,
service_basepath,
)
try:
service = await producer.start_service(
request.app,
user_id,
project_id,
service_key,
service_tag,
service_uuid,
service_basepath,
)
return web.json_response(data=dict(data=service), status=201)
except exceptions.ServiceStartTimeoutError as err:
raise web_exceptions.HTTPInternalServerError(reason=str(err))
except exceptions.ServiceNotAvailableError as err:
raise web_exceptions.HTTPNotFound(reason=str(err))
except exceptions.ServiceUUIDInUseError as err:
raise web_exceptions.HTTPConflict(reason=str(err))
except exceptions.RegistryConnectionError as err:
raise web_exceptions.HTTPUnauthorized(reason=str(err))
except Exception as err:
raise web_exceptions.HTTPInternalServerError(reason=str(err))
async def running_interactive_services_delete(
request: web.Request,
service_uuid: str,
save_state: Optional[bool] = True) -> web.Response:
log.debug(
"Client does running_interactive_services_delete request %s with service_uuid %s",
request,
service_uuid,
)
try:
await producer.stop_service(request.app, service_uuid, save_state)
except exceptions.ServiceUUIDNotFoundError as err:
raise web_exceptions.HTTPNotFound(reason=str(err))
except Exception as err:
# server errors are logged (>=500)
log.exception(
"Failed to delete dynamic service %s (save_state=%s)",
service_uuid,
save_state,
)
raise web_exceptions.HTTPInternalServerError(reason=str(err))
return web.json_response(status=204)
