handle rpc client exceptions

Author: bisgaard-itis

services/api-server/src/simcore_service_api_server/exceptions/service_errors_utils.py

@@ -1,3 +1,4 @@
+import asyncio
 import logging
 from collections.abc import Callable, Coroutine, Mapping
 from contextlib import contextmanager
@@ -8,6 +9,7 @@
 import httpx
 from fastapi import HTTPException, status
 from pydantic import ValidationError
+from servicelib.rabbitmq._errors import RemoteMethodNotRegisteredError
 from simcore_service_api_server.exceptions.backend_errors import BaseBackEndError
 
 from ..models.schemas.errors import ErrorGet
@@ -50,8 +52,12 @@ class ToApiTuple(NamedTuple):
 
 
 # service to public-api status maps
-E = TypeVar("E", bound=BaseBackEndError)
-HttpStatusMap: TypeAlias = Mapping[ServiceHTTPStatus, E]
+BackEndErrorType = TypeVar("BackEndErrorType", bound=BaseBackEndError)
+RpcExceptionType = TypeVar(
+    "RpcExceptionType", bound=Exception
+)  # need more specific rpc exception base class
+HttpStatusMap: TypeAlias = Mapping[ServiceHTTPStatus, BackEndErrorType]
+RabbitMqRpcExceptionMap: TypeAlias = Mapping[RpcExceptionType, BackEndErrorType]
 
 
 def _get_http_exception_kwargs(
@@ -98,6 +104,7 @@ def _get_http_exception_kwargs(
 def service_exception_handler(
     service_name: str,
     http_status_map: HttpStatusMap,
+    rpc_exception_map: RabbitMqRpcExceptionMap,
     **context,
 ):
     status_code: int
@@ -126,35 +133,64 @@ def service_exception_handler(
             status_code=status_code, detail=detail, headers=headers
         ) from exc
 
+    except BaseException as exc:  # currently no baseclass for rpc errors
+        if (
+            type(exc) == asyncio.TimeoutError
+        ):  # https://github.com/ITISFoundation/osparc-simcore/blob/master/packages/service-library/src/servicelib/rabbitmq/_client_rpc.py#L76
+            raise HTTPException(
+                status_code=status.HTTP_504_GATEWAY_TIMEOUT,
+                detail="Request to backend timed out",
+            ) from exc
+        if type(exc) in {
+            asyncio.exceptions.CancelledError,
+            RuntimeError,
+            RemoteMethodNotRegisteredError,
+        }:  # https://github.com/ITISFoundation/osparc-simcore/blob/master/packages/service-library/src/servicelib/rabbitmq/_client_rpc.py#L76
+            raise HTTPException(
+                status_code=status.HTTP_502_BAD_GATEWAY, detail="Request to failed"
+            ) from exc
+        if backend_error_type := rpc_exception_map.get(type(exc)):
+            raise backend_error_type(**context) from exc
+        raise
+
 
 def service_exception_mapper(
     *,
     service_name: str,
-    http_status_map: HttpStatusMap,
+    http_status_map: HttpStatusMap = {},
+    rpc_exception_map: RabbitMqRpcExceptionMap = {},
 ) -> Callable[
     [Callable[Concatenate[Self, P], Coroutine[Any, Any, R]]],
     Callable[Concatenate[Self, P], Coroutine[Any, Any, R]],
 ]:
     def _decorator(member_func: Callable[Concatenate[Self, P], Coroutine[Any, Any, R]]):
-        _assert_correct_kwargs(func=member_func, status_map=http_status_map)
+        _assert_correct_kwargs(
+            func=member_func,
+            exception_types=set(http_status_map.values()).union(
+                set(rpc_exception_map.values())
+            ),
+        )
 
         @wraps(member_func)
         async def _wrapper(self: Self, *args: P.args, **kwargs: P.kwargs) -> R:
-            with service_exception_handler(service_name, http_status_map, **kwargs):
+            with service_exception_handler(
+                service_name, http_status_map, rpc_exception_map, **kwargs
+            ):
                 return await member_func(self, *args, **kwargs)
 
         return _wrapper
 
     return _decorator
 
 
-def _assert_correct_kwargs(func: Callable, status_map: HttpStatusMap):
+def _assert_correct_kwargs(func: Callable, exception_types: set[BackEndErrorType]):
     _required_kwargs = {
         name
         for name, param in signature(func).parameters.items()
         if param.kind == param.KEYWORD_ONLY
     }
-    for exc_type in status_map.values():
+    for exc_type in exception_types:
+        assert isinstance(exc_type, type)  # nosec
         _exception_inputs = exc_type.named_fields()
         assert _exception_inputs.issubset(
             _required_kwargs

services/api-server/src/simcore_service_api_server/services_rpc/wb_api_server.py

@@ -1,20 +1,27 @@
 from dataclasses import dataclass
+from functools import partial
 
 from fastapi import FastAPI
 from fastapi_pagination import Page, create_page
 from servicelib.rabbitmq._client_rpc import RabbitMQRPCClient
 from servicelib.rabbitmq.rpc_interfaces.webserver.licenses.licensed_items import (
     get_licensed_items as _get_licensed_items,
 )
+from simcore_service_api_server.exceptions.service_errors_utils import (
+    service_exception_mapper,
+)
 from simcore_service_api_server.models.pagination import PaginationParams
 
 from ..models.schemas.model_adapter import LicensedItemGet
 
+_exception_mapper = partial(service_exception_mapper, service_name="WebApiServer")
+
 
 @dataclass
 class WbApiRpcClient:
     _rabbitmq_rpc_client: RabbitMQRPCClient
 
+    @_exception_mapper(rpc_exception_map={})
     async def get_licensed_items(
         self, product_name: str, page_params: PaginationParams
     ) -> Page[LicensedItemGet]:

services/api-server/tests/unit/test_licensed_items.py

@@ -1,3 +1,5 @@
+import asyncio
+
 import pytest
 from fastapi import status
 from httpx import AsyncClient, BasicAuth
@@ -10,6 +12,7 @@
 from pydantic import TypeAdapter
 from pytest_mock import MockerFixture
 from servicelib.rabbitmq._client_rpc import RabbitMQRPCClient
+from servicelib.rabbitmq._errors import RemoteMethodNotRegisteredError
 from simcore_service_api_server._meta import API_VTAG
 from simcore_service_api_server.models.pagination import Page
 from simcore_service_api_server.models.schemas.model_adapter import LicensedItemGet
@@ -32,7 +35,7 @@ def _get_dummy_rpc_client():
 
 @pytest.fixture
 async def mock_wb_api_server_rcp(
-    mock_rabbitmq_rpc_client: MockerFixture,
+    mock_rabbitmq_rpc_client: MockerFixture, exception_to_raise: Exception | None
 ) -> MockerFixture:
     async def _get_backend_licensed_items(
         rabbitmq_rpc_client: RabbitMQRPCClient,
@@ -41,6 +44,8 @@ async def _get_backend_licensed_items(
         offset: int,
         limit: int,
     ) -> _LicensedItemGetPage:
+        if exception_to_raise is not None:
+            raise exception_to_raise
         extra = _LicensedItemGet.model_config.get("json_schema_extra")
         assert isinstance(extra, dict)
         examples = extra.get("examples")
@@ -58,9 +63,29 @@ async def _get_backend_licensed_items(
     return mock_rabbitmq_rpc_client
 
 
+@pytest.mark.parametrize("exception_to_raise", [None])
 async def test_get_licensed_items(
     mock_wb_api_server_rcp: MockerFixture, client: AsyncClient, auth: BasicAuth
 ):
     resp = await client.get(f"{API_VTAG}/licensed-items/page", auth=auth)
     assert resp.status_code == status.HTTP_200_OK
     TypeAdapter(Page[LicensedItemGet]).validate_json(resp.text)
+
+
+@pytest.mark.parametrize("exception_to_raise", [asyncio.TimeoutError()])
+async def test_get_licensed_items_timeout(
+    mock_wb_api_server_rcp: MockerFixture, client: AsyncClient, auth: BasicAuth
+):
+    resp = await client.get(f"{API_VTAG}/licensed-items/page", auth=auth)
+    assert resp.status_code == status.HTTP_504_GATEWAY_TIMEOUT
+
+
+@pytest.mark.parametrize(
+    "exception_to_raise",
+    [asyncio.CancelledError(), RuntimeError(), RemoteMethodNotRegisteredError()],
+)
+async def test_get_licensed_items_502(
+    mock_wb_api_server_rcp: MockerFixture, client: AsyncClient, auth: BasicAuth
+):
+    resp = await client.get(f"{API_VTAG}/licensed-items/page", auth=auth)
+    assert resp.status_code == status.HTTP_502_BAD_GATEWAY