raises unavailble

Author: pcrespov

services/payments/src/simcore_service_payments/_constants.py

@@ -4,3 +4,6 @@
 PAG: Final[str] = "Payments Gateway service"
 PGDB: Final[str] = "Postgres service"
 RUT: Final[str] = "Resource Usage Tracker service"
+
+
+MSG_GATEWAY_UNAVAILABLE_ERROR = "Our payments provider is temporary unavailable"

services/payments/src/simcore_service_payments/core/errors.py

@@ -13,9 +13,9 @@ def get_full_class_name(cls) -> str:
 #
 
 
-class PaymentsGatewayError(_BaseAppError):
+class BasePaymentsGatewayError(_BaseAppError):
     ...
 
 
-class PaymentsGatewayNotReadyError(PaymentsGatewayError):
+class PaymentsGatewayNotReadyError(BasePaymentsGatewayError):
     msg_template = "Payments-Gateway is unresponsive: {checks}"

services/payments/src/simcore_service_payments/services/payments_gateway.py

@@ -16,9 +16,9 @@
 from fastapi import FastAPI
 from fastapi.encoders import jsonable_encoder
 from httpx import URL, HTTPStatusError
+from models_library.api_schemas_payments.errors import PaymentServiceUnavailableError
 from models_library.api_schemas_webserver.wallets import PaymentID, PaymentMethodID
 from pydantic import ValidationError, parse_raw_as
-from pydantic.errors import PydanticErrorMixin
 from servicelib.fastapi.app_state import SingletonInAppStateMixin
 from servicelib.fastapi.http_client import BaseHttpApi
 from servicelib.fastapi.httpx_utils import to_curl_command
@@ -29,7 +29,8 @@
 from tenacity.retry import retry_if_exception_type
 from tenacity.wait import wait_exponential
 
-from ..core.errors import PaymentsGatewayNotReadyError
+from .._constants import MSG_GATEWAY_UNAVAILABLE_ERROR, PAG
+from ..core.errors import BasePaymentsGatewayError, PaymentsGatewayNotReadyError
 from ..core.settings import ApplicationSettings
 from ..models.payments_gateway import (
     BatchGetPaymentMethods,
@@ -53,13 +54,13 @@ def _parse_raw_as_or_none(cls: type, text: str | None):
     return None
 
 
-class PaymentsGatewayError(PydanticErrorMixin, ValueError):
+class PaymentsGatewayApiError(BasePaymentsGatewayError):
     msg_template = "{operation_id} error {status_code}: {reason}"
 
     @classmethod
     def from_http_status_error(
         cls, err: HTTPStatusError, operation_id: str
-    ) -> "PaymentsGatewayError":
+    ) -> "PaymentsGatewayApiError":
         return cls(
             operation_id=f"PaymentsGatewayApi.{operation_id}",
             reason=f"{err}",
@@ -82,22 +83,37 @@ def get_detailed_message(self) -> str:
 
 
 @contextlib.contextmanager
-def _raise_as_payments_gateway_error(operation_id: str):
+def _reraise_as_service_errors_context(operation_id: str):
     try:
         yield
 
-    except HTTPStatusError as err:
-        error = PaymentsGatewayError.from_http_status_error(
+    except httpx.RequestError as err:
+        _logger.exception("%s: request error", PAG)
+        raise PaymentServiceUnavailableError(
+            human_reason=MSG_GATEWAY_UNAVAILABLE_ERROR
+        ) from err
+
+    except httpx.HTTPStatusError as err:
+        error = PaymentsGatewayApiError.from_http_status_error(
             err, operation_id=operation_id
         )
-        _logger.warning(error.get_detailed_message())
-        raise error from err
+
+        if err.response.is_client_error:
+            _logger.warning(error.get_detailed_message())
+            raise error from err
+
+        if err.response.is_server_error:
+            # 5XX in server -> turn into unavailable
+            _logger.exception(error.get_detailed_message())
+            raise PaymentServiceUnavailableError(
+                human_reason=MSG_GATEWAY_UNAVAILABLE_ERROR
+            ) from err
 
 
-def _handle_status_errors(coro: Callable):
+def _handle_httpx_errors(coro: Callable):
     @functools.wraps(coro)
     async def _wrapper(self, *args, **kwargs):
-        with _raise_as_payments_gateway_error(operation_id=coro.__name__):
+        with _reraise_as_service_errors_context(operation_id=coro.__name__):
             return await coro(self, *args, **kwargs)
 
     return _wrapper
@@ -119,7 +135,7 @@ class PaymentsGatewayApi(BaseHttpApi, SingletonInAppStateMixin):
     # api: one-time-payment workflow
     #
 
-    @_handle_status_errors
+    @_handle_httpx_errors
     async def init_payment(self, payment: InitPayment) -> PaymentInitiated:
         response = await self.client.post(
             "/init",
@@ -131,7 +147,7 @@ async def init_payment(self, payment: InitPayment) -> PaymentInitiated:
     def get_form_payment_url(self, id_: PaymentID) -> URL:
         return self.client.base_url.copy_with(path="/pay", params={"id": f"{id_}"})
 
-    @_handle_status_errors
+    @_handle_httpx_errors
     async def cancel_payment(
         self, payment_initiated: PaymentInitiated
     ) -> PaymentCancelled:
@@ -146,7 +162,7 @@ async def cancel_payment(
     # api: payment method workflows
     #
 
-    @_handle_status_errors
+    @_handle_httpx_errors
     async def init_payment_method(
         self,
         payment_method: InitPaymentMethod,
@@ -165,7 +181,7 @@ def get_form_payment_method_url(self, id_: PaymentMethodID) -> URL:
 
     # CRUD
 
-    @_handle_status_errors
+    @_handle_httpx_errors
     async def get_many_payment_methods(
         self, ids_: list[PaymentMethodID]
     ) -> list[GetPaymentMethod]:
@@ -178,18 +194,18 @@ async def get_many_payment_methods(
         response.raise_for_status()
         return PaymentMethodsBatch.parse_obj(response.json()).items
 
-    @_handle_status_errors
+    @_handle_httpx_errors
     async def get_payment_method(self, id_: PaymentMethodID) -> GetPaymentMethod:
         response = await self.client.get(f"/payment-methods/{id_}")
         response.raise_for_status()
         return GetPaymentMethod.parse_obj(response.json())
 
-    @_handle_status_errors
+    @_handle_httpx_errors
     async def delete_payment_method(self, id_: PaymentMethodID) -> None:
         response = await self.client.delete(f"/payment-methods/{id_}")
         response.raise_for_status()
 
-    @_handle_status_errors
+    @_handle_httpx_errors
     async def pay_with_payment_method(
         self, id_: PaymentMethodID, payment: InitPayment
     ) -> AckPaymentWithPaymentMethod:

services/payments/tests/unit/test_rpc_payments.py

@@ -9,15 +9,18 @@
 import pytest
 from faker import Faker
 from fastapi import FastAPI
-from models_library.api_schemas_payments.errors import PaymentNotFoundError
+from models_library.api_schemas_payments.errors import (
+    PaymentNotFoundError,
+    PaymentServiceUnavailableError,
+)
 from models_library.api_schemas_webserver.wallets import WalletPaymentInitiated
 from models_library.rabbitmq_basic_types import RPCMethodName
 from pydantic import parse_obj_as
 from pytest_mock import MockerFixture
 from pytest_simcore.helpers.typing_env import EnvVarsDict
 from pytest_simcore.helpers.utils_envs import setenvs_from_dict
 from respx import MockRouter
-from servicelib.rabbitmq import RabbitMQRPCClient, RPCServerError
+from servicelib.rabbitmq import RabbitMQRPCClient
 from servicelib.rabbitmq._constants import RPC_REQUEST_DEFAULT_TIMEOUT_S
 from simcore_service_payments.api.rpc.routes import PAYMENTS_RPC_NAMESPACE
 
@@ -87,19 +90,16 @@ async def test_rpc_init_payment_fail(
 ):
     assert app
 
-    with pytest.raises(RPCServerError) as exc_info:
+    with pytest.raises(PaymentServiceUnavailableError) as exc_info:
         await rpc_client.request(
             PAYMENTS_RPC_NAMESPACE,
             parse_obj_as(RPCMethodName, "init_payment"),
             **init_payment_kwargs,
             timeout_s=None if is_pdb_enabled else 5,
         )
 
-    error = exc_info.value
-    assert isinstance(error, RPCServerError)
-    assert error.exc_type == "httpx.ConnectError"
-    assert error.method_name == "init_payment"
-    assert error.msg
+    # FIXME: should raise
+    assert isinstance(exc_info.value, PaymentServiceUnavailableError)
 
 
 async def test_webserver_one_time_payment_workflow(

services/payments/tests/unit/test_services_payments_gateway.py

@@ -17,8 +17,8 @@
 )
 from simcore_service_payments.services.payments_gateway import (
     PaymentsGatewayApi,
-    PaymentsGatewayError,
-    _raise_as_payments_gateway_error,
+    PaymentsGatewayApiError,
+    _reraise_as_service_errors_context,
     setup_payments_gateway,
 )
 
@@ -187,7 +187,7 @@ async def test_payment_methods_workflow(
     # delete payment-method
     await payments_gateway_api.delete_payment_method(payment_method_id)
 
-    with pytest.raises(PaymentsGatewayError) as err_info:
+    with pytest.raises(PaymentsGatewayApiError) as err_info:
         await payments_gateway_api.get_payment_method(payment_method_id)
 
     assert str(err_info.value)
@@ -205,18 +205,18 @@ async def test_payment_methods_workflow(
 
 async def test_payments_gateway_error_exception():
     async def _go():
-        with _raise_as_payments_gateway_error(operation_id="foo"):
+        with _reraise_as_service_errors_context(operation_id="foo"):
             async with httpx.AsyncClient(
                 app=FastAPI(),
                 base_url="http://payments.testserver.io",
             ) as client:
                 response = await client.post("/foo", params={"x": "3"}, json={"y": 12})
                 response.raise_for_status()
 
-    with pytest.raises(PaymentsGatewayError) as err_info:
+    with pytest.raises(PaymentsGatewayApiError) as err_info:
         await _go()
     err = err_info.value
-    assert isinstance(err, PaymentsGatewayError)
+    assert isinstance(err, PaymentsGatewayApiError)
 
     assert "curl -X POST" in err.get_detailed_message()