jararaca 0.3.12a4__tar.gz → 0.3.12a5__tar.gz

{jararaca-0.3.12a4 → jararaca-0.3.12a5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: jararaca
-Version: 0.3.12a4
+Version: 0.3.12a5
 Summary: A simple and fast API framework for Python
 Home-page: https://github.com/LuscasLeo/jararaca
 Author: Lucas S

{jararaca-0.3.12a4 → jararaca-0.3.12a5}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "jararaca"
-version = "0.3.12a4"
+version = "0.3.12a5"
 description = "A simple and fast API framework for Python"
 authors = ["Lucas S <me@luscasleo.dev>"]
 readme = "README.md"

{jararaca-0.3.12a4 → jararaca-0.3.12a5}/src/jararaca/__init__.py

@@ -102,6 +102,8 @@ if TYPE_CHECKING:
     from .messagebus.publisher import use_publisher
     from .microservice import (
         Microservice,
+        is_shutting_down,
+        request_shutdown,
         use_app_context,
         use_app_transaction_context,
         use_app_tx_ctx_data,
@@ -207,6 +209,12 @@ if TYPE_CHECKING:
         "QueryInjector",
         "HttpMicroservice",
         "use_current_container",
+        "use_app_context",
+        "use_app_transaction_context",
+        "use_app_tx_ctx_data",
+        "is_shutting_down",
+        "request_shutdown",
+        "Microservice",
         "T_BASEMODEL",
         "DatedEntity",
         "BaseEntity",
@@ -229,7 +237,6 @@ if TYPE_CHECKING:
         "MessageBusController",
         "MessageHandler",
         "ScheduledAction",
-        "Microservice",
         "ProviderSpec",
         "Token",
         "AIOSqlAlchemySessionInterceptor",
@@ -284,9 +291,6 @@ if TYPE_CHECKING:
         "RetryConfig",
         # Exception classes
         "TimeoutException",
-        "use_app_context",
-        "use_app_transaction_context",
-        "use_app_tx_ctx_data",
         "AppTransactionContext",
         "AppContext",
         "ControllerMemberReflect",
@@ -501,6 +505,8 @@ _dynamic_imports: "dict[str, tuple[str, str, str | None]]" = {
     "use_app_context": (__SPEC_PARENT__, "microservice", None),
     "use_app_transaction_context": (__SPEC_PARENT__, "microservice", None),
     "use_app_tx_ctx_data": (__SPEC_PARENT__, "microservice", None),
+    "is_shutting_down": (__SPEC_PARENT__, "microservice", None),
+    "request_shutdown": (__SPEC_PARENT__, "microservice", None),
     "AppContext": (__SPEC_PARENT__, "microservice", None),
     "AppInterceptor": (__SPEC_PARENT__, "microservice", None),
     "AppTransactionContext": (__SPEC_PARENT__, "microservice", None),

{jararaca-0.3.12a4 → jararaca-0.3.12a5}/src/jararaca/messagebus/worker.py

@@ -49,6 +49,8 @@ from jararaca.microservice import (
     MessageBusTransactionData,
     Microservice,
     SchedulerTransactionData,
+    ShutdownState,
+    provide_shutdown_state,
 )
 from jararaca.scheduler.decorators import ScheduledActionData
 from jararaca.utils.rabbitmq_utils import RabbitmqUtils
@@ -129,6 +131,17 @@ class MessageBusConsumer(ABC):
         """Close all resources related to the consumer"""
 
 
+class _WorkerShutdownState(ShutdownState):
+    def __init__(self, shutdown_event: asyncio.Event):
+        self.shutdown_event = shutdown_event
+
+    def request_shutdown(self) -> None:
+        self.shutdown_event.set()
+
+    def is_shutdown_requested(self) -> bool:
+        return self.shutdown_event.is_set()
+
+
 class AioPikaMicroserviceConsumer(MessageBusConsumer):
     def __init__(
         self,
@@ -146,6 +159,7 @@ class AioPikaMicroserviceConsumer(MessageBusConsumer):
         self.incoming_map: dict[str, MessageHandlerData] = {}
         self.uow_context_provider = uow_context_provider
         self.shutdown_event = asyncio.Event()
+        self.shutdown_state = _WorkerShutdownState(self.shutdown_event)
         self.lock = asyncio.Lock()
         self.tasks: set[asyncio.Task[Any]] = set()
         self.connection: aio_pika.abc.AbstractConnection | None = None
@@ -832,18 +846,19 @@ class ScheduledMessageHandlerCallback:
         args: tuple[Any, ...],
         kwargs: dict[str, Any],
     ) -> None:
-        async with self.consumer.uow_context_provider(
-            AppTransactionContext(
-                controller_member_reflect=scheduled_action.controller_member,
-                transaction_data=SchedulerTransactionData(
-                    scheduled_to=datetime.now(UTC),
-                    cron_expression=scheduled_action.spec.cron,
-                    triggered_at=datetime.now(UTC),
-                ),
-            )
-        ):
+        with provide_shutdown_state(self.consumer.shutdown_state):
+            async with self.consumer.uow_context_provider(
+                AppTransactionContext(
+                    controller_member_reflect=scheduled_action.controller_member,
+                    transaction_data=SchedulerTransactionData(
+                        scheduled_to=datetime.now(UTC),
+                        cron_expression=scheduled_action.spec.cron,
+                        triggered_at=datetime.now(UTC),
+                    ),
+                )
+            ):
 
-            await scheduled_action.callable(*args, **kwargs)
+                await scheduled_action.callable(*args, **kwargs)
 
 
 class MessageHandlerCallback:
@@ -1133,83 +1148,86 @@ class MessageHandlerCallback:
         incoming_message_spec = MessageHandler.get_message_incoming(handler)
         assert incoming_message_spec is not None
 
-        async with self.consumer.uow_context_provider(
-            AppTransactionContext(
-                controller_member_reflect=handler_data.controller_member,
-                transaction_data=MessageBusTransactionData(
-                    message=builded_message,
-                    topic=routing_key,
-                ),
-            )
-        ):
-            ctx: AsyncContextManager[Any]
-            if incoming_message_spec.timeout is not None:
-                ctx = asyncio.timeout(incoming_message_spec.timeout)
-            else:
-                ctx = none_context()
-            async with ctx:
-                try:
-                    with provide_bus_message_controller(
-                        AioPikaMessageBusController(aio_pika_message)
-                    ):
-                        await handler(builded_message)
-                    if not incoming_message_spec.auto_ack:
-                        with suppress(aio_pika.MessageProcessError):
-                            # Use channel context for acknowledgement
-                            async with self.consumer.get_channel_ctx(self.queue_name):
-                                await aio_pika_message.ack()
-                except BaseException as base_exc:
-                    # Get message id for logging
-                    message_id = aio_pika_message.message_id or str(uuid.uuid4())
-
-                    # Extract retry count from headers if available
-                    headers = aio_pika_message.headers or {}
-                    retry_count = int(str(headers.get("x-retry-count", 0)))
-
-                    # Process exception handler if configured
-                    if incoming_message_spec.exception_handler is not None:
-                        try:
-                            incoming_message_spec.exception_handler(base_exc)
-                        except Exception as nested_exc:
+        with provide_shutdown_state(self.consumer.shutdown_state):
+            async with self.consumer.uow_context_provider(
+                AppTransactionContext(
+                    controller_member_reflect=handler_data.controller_member,
+                    transaction_data=MessageBusTransactionData(
+                        message=builded_message,
+                        topic=routing_key,
+                    ),
+                )
+            ):
+                ctx: AsyncContextManager[Any]
+                if incoming_message_spec.timeout is not None:
+                    ctx = asyncio.timeout(incoming_message_spec.timeout)
+                else:
+                    ctx = none_context()
+                async with ctx:
+                    try:
+                        with provide_bus_message_controller(
+                            AioPikaMessageBusController(aio_pika_message)
+                        ):
+                            await handler(builded_message)
+                        if not incoming_message_spec.auto_ack:
+                            with suppress(aio_pika.MessageProcessError):
+                                # Use channel context for acknowledgement
+                                async with self.consumer.get_channel_ctx(
+                                    self.queue_name
+                                ):
+                                    await aio_pika_message.ack()
+                    except BaseException as base_exc:
+                        # Get message id for logging
+                        message_id = aio_pika_message.message_id or str(uuid.uuid4())
+
+                        # Extract retry count from headers if available
+                        headers = aio_pika_message.headers or {}
+                        retry_count = int(str(headers.get("x-retry-count", 0)))
+
+                        # Process exception handler if configured
+                        if incoming_message_spec.exception_handler is not None:
+                            try:
+                                incoming_message_spec.exception_handler(base_exc)
+                            except Exception as nested_exc:
+                                logger.exception(
+                                    f"Error processing exception handler for message {message_id}: {base_exc} | {nested_exc}"
+                                )
+                        else:
                             logger.exception(
-                                f"Error processing exception handler for message {message_id}: {base_exc} | {nested_exc}"
+                                f"Error processing message {message_id} on topic {routing_key}: {str(base_exc)}"
                             )
-                    else:
-                        logger.exception(
-                            f"Error processing message {message_id} on topic {routing_key}: {str(base_exc)}"
-                        )
 
-                    # Handle rejection with retry logic
-                    if incoming_message_spec.requeue_on_exception:
-                        # Use our retry with backoff mechanism
-                        await self.handle_reject_message(
-                            aio_pika_message,
-                            requeue=False,  # Don't requeue directly, use our backoff mechanism
-                            retry_count=retry_count,
-                            exception=base_exc,
-                        )
-                    else:
-                        # Message shouldn't be retried, reject it
-                        await self.handle_reject_message(
-                            aio_pika_message, requeue=False, exception=base_exc
-                        )
-                else:
-                    # Message processed successfully, log and clean up any retry state
-                    message_id = aio_pika_message.message_id or str(uuid.uuid4())
-                    if message_id in self.retry_state:
-                        del self.retry_state[message_id]
-
-                    # Log success with retry information if applicable
-                    headers = aio_pika_message.headers or {}
-                    if "x-retry-count" in headers:
-                        retry_count = int(str(headers.get("x-retry-count", 0)))
-                        logger.info(
-                            f"Message {message_id}#{self.queue_name} processed successfully after {retry_count} retries"
-                        )
+                        # Handle rejection with retry logic
+                        if incoming_message_spec.requeue_on_exception:
+                            # Use our retry with backoff mechanism
+                            await self.handle_reject_message(
+                                aio_pika_message,
+                                requeue=False,  # Don't requeue directly, use our backoff mechanism
+                                retry_count=retry_count,
+                                exception=base_exc,
+                            )
+                        else:
+                            # Message shouldn't be retried, reject it
+                            await self.handle_reject_message(
+                                aio_pika_message, requeue=False, exception=base_exc
+                            )
                     else:
-                        logger.info(
-                            f"Message {message_id}#{self.queue_name} processed successfully"
-                        )
+                        # Message processed successfully, log and clean up any retry state
+                        message_id = aio_pika_message.message_id or str(uuid.uuid4())
+                        if message_id in self.retry_state:
+                            del self.retry_state[message_id]
+
+                        # Log success with retry information if applicable
+                        headers = aio_pika_message.headers or {}
+                        if "x-retry-count" in headers:
+                            retry_count = int(str(headers.get("x-retry-count", 0)))
+                            logger.info(
+                                f"Message {message_id}#{self.queue_name} processed successfully after {retry_count} retries"
+                            )
+                        else:
+                            logger.info(
+                                f"Message {message_id}#{self.queue_name} processed successfully"
+                            )
 
 
 @asynccontextmanager

{jararaca-0.3.12a4 → jararaca-0.3.12a5}/src/jararaca/microservice.py

@@ -325,6 +325,48 @@ def provide_container(container: Container) -> Generator[None, None, None]:
             current_container_ctx.reset(token)
 
 
+class ShutdownState(Protocol):
+
+    def request_shutdown(self) -> None: ...
+
+    def is_shutdown_requested(self) -> bool: ...
+
+
+shutdown_state_ctx = ContextVar[ShutdownState]("shutdown_state")
+
+
+def is_shutting_down() -> bool:
+    """
+    Check if the application is in the process of shutting down.
+    """
+    return shutdown_state_ctx.get().is_shutdown_requested()
+
+
+def request_shutdown() -> None:
+    """
+    Request the application to shut down.
+    This will set the shutdown event, allowing the application to gracefully shut down.
+    """
+    shutdown_state_ctx.get().request_shutdown()
+
+
+@contextmanager
+def provide_shutdown_state(
+    state: ShutdownState,
+) -> Generator[None, None, None]:
+    """
+    Context manager to provide the shutdown state.
+    This is used to manage the shutdown event for the application.
+    """
+
+    token = shutdown_state_ctx.set(state)
+    try:
+        yield
+    finally:
+        with suppress(ValueError):
+            shutdown_state_ctx.reset(token)
+
+
 __all__ = [
     "AppTransactionContext",
     "AppInterceptor",

{jararaca-0.3.12a4 → jararaca-0.3.12a5}/src/jararaca/presentation/server.py

@@ -1,4 +1,8 @@
+import os
+import signal
+import threading
 from contextlib import asynccontextmanager
+from signal import SIGINT, SIGTERM
 from typing import Any, AsyncGenerator
 
 from fastapi import Depends, FastAPI, Request, WebSocket
@@ -10,7 +14,9 @@ from jararaca.lifecycle import AppLifecycle
 from jararaca.microservice import (
     AppTransactionContext,
     HttpTransactionData,
+    ShutdownState,
     WebSocketTransactionData,
+    provide_shutdown_state,
 )
 from jararaca.presentation.decorators import RestController
 from jararaca.presentation.http_microservice import HttpMicroservice
@@ -76,10 +82,49 @@ class HttpAppLifecycle:
             yield
 
 
+class HttpShutdownState(ShutdownState):
+    def __init__(self) -> None:
+        self._requested = False
+        self.old_signal_handlers = {
+            SIGINT: signal.getsignal(SIGINT),
+            SIGTERM: signal.getsignal(SIGTERM),
+        }
+        self.thread_lock = threading.Lock()
+
+    def request_shutdown(self) -> None:
+        if not self._requested:
+            self._requested = True
+            os.kill(os.getpid(), SIGINT)
+
+    def is_shutdown_requested(self) -> bool:
+        return self._requested
+
+    def handle_signal(self, signum: int, frame: Any) -> None:
+        print(f"Received signal {signum}, initiating shutdown...")
+        if self._requested:
+            print("Shutdown already requested, ignoring signal.")
+            return
+        print("Requesting shutdown...")
+        self._requested = True
+
+        # remove the signal handler to prevent recursion
+        for sig in (SIGINT, SIGTERM):
+            if self.old_signal_handlers[sig] is not None:
+                signal.signal(sig, self.old_signal_handlers[sig])
+
+        signal.raise_signal(signum)
+
+    def setup_signal_handlers(self) -> None:
+        signal.signal(SIGINT, self.handle_signal)
+        signal.signal(SIGTERM, self.handle_signal)
+
+
 class HttpUowContextProviderDependency:
 
     def __init__(self, uow_provider: UnitOfWorkContextProvider) -> None:
         self.uow_provider = uow_provider
+        self.shutdown_state = HttpShutdownState()
+        self.shutdown_state.setup_signal_handlers()
 
     async def __call__(
         self, websocket: WebSocket = None, request: Request = None  # type: ignore
@@ -101,17 +146,18 @@ class HttpUowContextProviderDependency:
             "ControllerMemberReflect, but got: {}".format(type(member))
         )
 
-        async with self.uow_provider(
-            AppTransactionContext(
-                controller_member_reflect=member,
-                transaction_data=(
-                    HttpTransactionData(request=request)
-                    if request
-                    else WebSocketTransactionData(websocket=websocket)
-                ),
-            )
-        ):
-            yield
+        with provide_shutdown_state(self.shutdown_state):
+            async with self.uow_provider(
+                AppTransactionContext(
+                    controller_member_reflect=member,
+                    transaction_data=(
+                        HttpTransactionData(request=request)
+                        if request
+                        else WebSocketTransactionData(websocket=websocket)
+                    ),
+                )
+            ):
+                yield
 
 
 def create_http_server(