rpc errors

Author: pcrespov

packages/service-library/src/servicelib/rabbitmq/__init__.py

@@ -5,6 +5,7 @@
 from ._constants import BIND_TO_ALL_TOPICS, RPC_REQUEST_DEFAULT_TIMEOUT_S
 from ._errors import (
     RemoteMethodNotRegisteredError,
+    RPCInterfaceError,
     RPCNotInitializedError,
     RPCServerError,
 )
@@ -14,18 +15,19 @@
 
 __all__: tuple[str, ...] = (
     "BIND_TO_ALL_TOPICS",
+    "RPC_REQUEST_DEFAULT_TIMEOUT_S",
     "ConsumerTag",
     "ExchangeName",
-    "is_rabbitmq_responsive",
     "QueueName",
-    "RabbitMQClient",
-    "RabbitMQRPCClient",
-    "RemoteMethodNotRegisteredError",
-    "RPC_REQUEST_DEFAULT_TIMEOUT_S",
+    "RPCInterfaceError",
     "RPCNamespace",
     "RPCNotInitializedError",
     "RPCRouter",
     "RPCServerError",
+    "RabbitMQClient",
+    "RabbitMQRPCClient",
+    "RemoteMethodNotRegisteredError",
+    "is_rabbitmq_responsive",
     "wait_till_rabbitmq_responsive",
 )
 

packages/service-library/src/servicelib/rabbitmq/_errors.py

@@ -5,17 +5,16 @@
 _ERROR_PREFIX: Final[str] = "rabbitmq_error"
 
 
-class BaseRPCError(OsparcErrorMixin, RuntimeError):
-    ...
+class BaseRPCError(OsparcErrorMixin, RuntimeError): ...
 
 
 class RPCNotInitializedError(BaseRPCError):
-    code = f"{_ERROR_PREFIX}.not_started"   # type: ignore[assignment]
+    code = f"{_ERROR_PREFIX}.not_started"  # type: ignore[assignment]
     msg_template = "Please check that the RabbitMQ RPC backend was initialized!"
 
 
 class RemoteMethodNotRegisteredError(BaseRPCError):
-    code = f"{_ERROR_PREFIX}.remote_not_registered" # type: ignore[assignment]
+    code = f"{_ERROR_PREFIX}.remote_not_registered"  # type: ignore[assignment]
     msg_template = (
         "Could not find a remote method named: '{method_name}'. "
         "Message from remote server was returned: {incoming_message}. "
@@ -27,3 +26,23 @@ class RPCServerError(BaseRPCError):
         "While running method '{method_name}' raised "
         "'{exc_type}': '{exc_message}'\n{traceback}"
     )
+
+
+class RPCInterfaceError(RPCServerError):
+    """
+    Base class for RPC interface exceptions.
+
+    Avoid using domain exceptions directly; if a one-to-one mapping is required,
+    prefer using the `from_domain_error` transformation function.
+    """
+
+    msg_template = "{domain_error_message} [{domain_error_code}]"
+
+    @classmethod
+    def from_domain_error(cls, err: OsparcErrorMixin):
+        domain_err_ctx = err.error_context()
+        return cls(
+            domain_error_message=domain_err_ctx.pop("message"),
+            domain_error_code=domain_err_ctx.pop("code"),
+            **domain_err_ctx,  # same context as domain
+        )

packages/service-library/src/servicelib/rabbitmq/rpc_interfaces/webserver/errors.py

@@ -1,23 +1,7 @@
-from common_library.errors_classes import OsparcErrorMixin
+from ..._errors import RPCInterfaceError
 
-from ..._errors import RPCServerError
 
+class ProjectNotFoundRpcError(RPCInterfaceError): ...
 
-class WebServerRpcError(RPCServerError):
-    msg_template = "{domain_error_nessage} [{domain_error_type_name}]"
 
-    @classmethod
-    def from_domain_error(cls, err: OsparcErrorMixin):
-        return cls(
-            # composes a  message
-            domain_error_nessage=err.message,
-            domain_error_type_name=f"{err.__class__.__name__}",
-            # copies context
-            **err.error_context(),
-        )
-
-
-class ProjectNotFoundRpcError(WebServerRpcError): ...
-
-
-class ProjectForbiddenRpcError(WebServerRpcError): ...
+class ProjectForbiddenRpcError(RPCInterfaceError): ...

packages/service-library/tests/rabbitmq/test_rabbitmq_rpc_router.py

@@ -2,12 +2,15 @@
 # pylint:disable=unused-argument
 
 from collections.abc import Awaitable, Callable
+from typing import cast
 
 import pytest
+from common_library.errors_classes import OsparcErrorMixin
 from faker import Faker
 from models_library.rabbitmq_basic_types import RPCMethodName
 from servicelib.rabbitmq import (
     RabbitMQRPCClient,
+    RPCInterfaceError,
     RPCNamespace,
     RPCRouter,
     RPCServerError,
@@ -18,15 +21,21 @@
 ]
 
 
-router = RPCRouter()
+class MyServiceError(OsparcErrorMixin, Exception): ...
 
 
-class MyBaseError(Exception):
-    ...
+class MyDomainError(MyServiceError):
+    msg_template = "This could happen"
 
 
-class MyExpectedError(MyBaseError):
-    ...
+def raise_my_expected_error():
+    raise MyDomainError(user_id=33, project_id=3)
+
+
+router = RPCRouter()  # Server-side
+
+
+class MyExpectedRpcError(RPCInterfaceError): ...
 
 
 @router.expose()
@@ -41,10 +50,13 @@ async def an_int_method(a_global_arg: str, *, a_global_kwarg: str) -> int:
     return 34
 
 
-@router.expose(reraise_if_error_type=(MyBaseError,))
-async def raising_expected_error(a_global_arg: str, *, a_global_kwarg: str) -> int:
-    msg = "This could happen"
-    raise MyExpectedError(msg)
+@router.expose(reraise_if_error_type=(MyExpectedRpcError,))
+async def raising_expected_error(a_global_arg: str, *, a_global_kwarg: str):
+    try:
+        raise_my_expected_error()
+    except MyDomainError as exc:
+        # NOTE how it is adapted from a domain exception to an interface exception
+        raise MyExpectedRpcError.from_domain_error(exc) from exc
 
 
 @router.expose()
@@ -55,7 +67,7 @@ async def raising_unexpected_error(a_global_arg: str, *, a_global_kwarg: str) ->
 
 @pytest.fixture
 def router_namespace(faker: Faker) -> RPCNamespace:
-    return faker.pystr()
+    return cast(RPCNamespace, faker.pystr())
 
 
 async def test_exposed_methods(
@@ -100,10 +112,18 @@ async def test_exposed_methods(
     assert "builtins.ValueError" in f"{exc_info.value}"
 
     # This error was classified int he interface
-    with pytest.raises(MyBaseError) as exc_info:
+    with pytest.raises(RPCInterfaceError) as exc_info:
         await rpc_client.request(
             router_namespace,
             RPCMethodName(raising_expected_error.__name__),
         )
 
-    assert isinstance(exc_info.value, MyExpectedError)
+    assert isinstance(exc_info.value, MyExpectedRpcError)
+    assert exc_info.value.error_context() == {
+        "message": "This could happen [MyServiceError.MyDomainError]",
+        "code": "RuntimeError.BaseRPCError.RPCServerError",
+        "domain_error_message": "This could happen",
+        "domain_error_code": "MyServiceError.MyDomainError",
+        "user_id": 33,
+        "project_id": 3,
+    }