jararaca 0.4.0a5__py3-none-any.whl → 0.4.0a19__py3-none-any.whl

jararaca/helpers/global_scheduler/controller.py

@@ -0,0 +1,42 @@
+# SPDX-FileCopyrightText: 2025 Lucas S
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+import asyncio
+
+from jararaca.helpers.global_scheduler.config import GlobalSchedulerConfigAnnotated
+from jararaca.helpers.global_scheduler.registry import (
+    GlobalScheduleFnType,
+    GlobalSchedulerRegistry,
+)
+from jararaca.messagebus.decorators import MessageBusController
+from jararaca.scheduler.decorators import ScheduledAction
+from jararaca.utils.env_parse_utils import get_env_str
+
+SCHEDULER_CRON = get_env_str("SCHEDULER_CRON", "*/5 * * * *")
+
+
+@MessageBusController()
+class GlobalSchedulerController:
+
+    def __init__(self, config: GlobalSchedulerConfigAnnotated):
+        self._config = config
+
+    @ScheduledAction(cron=SCHEDULER_CRON)
+    async def trigger_scheduled_actions(self) -> None:
+        """Trigger all registered scheduled actions."""
+
+        taks = []
+
+        semaphore = asyncio.Semaphore(self._config.MAX_CONCURRENT_JOBS)
+
+        for action in GlobalSchedulerRegistry.get_registered_actions():
+            task = asyncio.create_task(self._run_with_semaphore(semaphore, action))
+
+            taks.append(task)
+
+    async def _run_with_semaphore(
+        self, semaphore: asyncio.Semaphore, action: GlobalScheduleFnType
+    ) -> None:
+        async with semaphore:
+            await action()

jararaca/helpers/global_scheduler/registry.py

@@ -0,0 +1,32 @@
+# SPDX-FileCopyrightText: 2025 Lucas S
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+
+from typing import Any, Awaitable, Callable
+
+GlobalScheduleFnType = Callable[[], Awaitable[Any]]
+
+
+class GlobalSchedulerRegistry:
+    """Registry for the Global Scheduler helper."""
+
+    _REGISTRY: list[GlobalScheduleFnType] = []
+
+    @classmethod
+    def register(cls, fn: GlobalScheduleFnType) -> None:
+        """Register a scheduled action function.
+
+        Args:
+            fn: The scheduled action function to register.
+        """
+        cls._REGISTRY.append(fn)
+
+    @classmethod
+    def get_registered_actions(cls) -> list[GlobalScheduleFnType]:
+        """Get the list of registered scheduled action functions.
+
+        Returns:
+            A list of registered scheduled action functions.
+        """
+        return cls._REGISTRY

jararaca/messagebus/decorators.py

@@ -5,35 +5,129 @@
 
 import inspect
 from dataclasses import dataclass
-from typing import Any, Awaitable, Callable
+from typing import Any, Awaitable, Callable, Literal, TypeVar, cast, get_args
 
-from jararaca.messagebus.message import INHERITS_MESSAGE_CO
+from jararaca.messagebus.message import INHERITS_MESSAGE_CO, Message, MessageOf
 from jararaca.reflect.controller_inspect import (
     ControllerMemberReflect,
     inspect_controller,
 )
-from jararaca.reflect.decorators import DECORATED_T, StackableDecorator
+from jararaca.reflect.decorators import (
+    FUNC_OR_TYPE_T,
+    GenericStackableDecorator,
+    StackableDecorator,
+)
+from jararaca.reflect.helpers import is_generic_alias
 from jararaca.scheduler.decorators import ScheduledAction, ScheduledActionData
+from jararaca.utils.env_parse_utils import get_env_float, get_env_int, is_env_truffy
+from jararaca.utils.retry import RetryPolicy
+
+AcceptableHandler = (
+    Callable[[Any, MessageOf[Any]], Awaitable[None]]
+    | Callable[[Any, Any], Awaitable[None]]
+)
+MessageHandlerT = TypeVar("MessageHandlerT", bound=AcceptableHandler)
 
+DEFAULT_TIMEOUT = get_env_int("JARARACA_MESSAGEBUS_HANDLER_TIMEOUT")
+DEFAULT_NACK_ON_EXCEPTION = is_env_truffy("JARARACA_MESSAGEBUS_NACK_ON_EXCEPTION")
+DEFAULT_AUTO_ACK = is_env_truffy("JARARACA_MESSAGEBUS_AUTO_ACK")
+DEFAULT_NACK_DELAY_ON_EXCEPTION = get_env_float(
+    "JARARACA_MESSAGEBUS_NACK_DELAY_ON_EXCEPTION"
+)
 
-class MessageHandler(StackableDecorator):
+
+class MessageHandler(GenericStackableDecorator[AcceptableHandler]):
 
     def __init__(
         self,
         message: type[INHERITS_MESSAGE_CO],
-        timeout: int | None = None,
+        *,
+        timeout: int | None = DEFAULT_TIMEOUT if DEFAULT_TIMEOUT is not False else None,
         exception_handler: Callable[[BaseException], None] | None = None,
-        nack_on_exception: bool = False,
-        auto_ack: bool = False,
+        nack_on_exception: bool = DEFAULT_NACK_ON_EXCEPTION,
+        nack_delay_on_exception: float = DEFAULT_NACK_DELAY_ON_EXCEPTION or 5.0,
+        auto_ack: bool = DEFAULT_AUTO_ACK,
         name: str | None = None,
+        retry_config: RetryPolicy | None = None,
     ) -> None:
         self.message_type = message
 
         self.timeout = timeout
         self.exception_handler = exception_handler
         self.nack_on_exception = nack_on_exception
+        self.nack_delay_on_exception = nack_delay_on_exception
+
         self.auto_ack = auto_ack
         self.name = name
+        self.retry_config = retry_config
+
+    def __call__(self, subject: MessageHandlerT) -> MessageHandlerT:
+        return cast(MessageHandlerT, super().__call__(subject))
+
+    def pre_decorated(self, subject: FUNC_OR_TYPE_T) -> None:
+        MessageHandler.validate_decorated_fn(subject)
+
+    @staticmethod
+    def validate_decorated_fn(
+        subject: FUNC_OR_TYPE_T,
+    ) -> tuple[Literal["WRAPPED", "DIRECT"], type[Message]]:
+        """Validates that the decorated function has the correct signature
+        the decorated must follow one of the patterns:
+
+        async def handler(self, message: MessageOf[YourMessageType]) -> None:
+            ...
+
+        async def handler(self, message: YourMessageType) -> None:
+            ...
+
+        """
+
+        if not inspect.iscoroutinefunction(subject):
+            raise RuntimeError(
+                "Message handler '%s' must be a coroutine function"
+                % (subject.__qualname__)
+            )
+
+        signature = inspect.signature(subject)
+
+        parameters = list(signature.parameters.values())
+
+        if len(parameters) != 2:
+            raise RuntimeError(
+                "Message handler '%s' must have exactly two parameters (self, message)"
+                % (subject.__qualname__)
+            )
+
+        message_param = parameters[1]
+
+        if message_param.annotation is inspect.Parameter.empty:
+            raise RuntimeError(
+                "Message handler '%s' must have type annotation for the message parameter"
+                % (subject.__qualname__)
+            )
+
+        annotation_type = message_param.annotation
+        mode: Literal["WRAPPED", "DIRECT"]
+        if is_generic_alias(annotation_type):
+
+            message_model_type = get_args(annotation_type)[0]
+
+            mode = "WRAPPED"
+
+        else:
+            message_model_type = annotation_type
+
+            mode = "DIRECT"
+
+        if not inspect.isclass(message_model_type) or not issubclass(
+            message_model_type, Message
+        ):
+            raise RuntimeError(
+                "Message handler '%s' message parameter must be of type 'MessageOf[YourMessageType]' or 'YourMessageType' where 'YourMessageType' is a subclass of 'Message'"
+                % (subject.__qualname__)
+            )
+
+        return mode, message_model_type
 
 
 @dataclass(frozen=True)
@@ -73,16 +167,16 @@ class MessageBusController(StackableDecorator):
     def get_messagebus_factory(
         self,
     ) -> Callable[
-        [DECORATED_T], tuple[MESSAGE_HANDLER_DATA_SET, SCHEDULED_ACTION_DATA_SET]
+        [FUNC_OR_TYPE_T], tuple[MESSAGE_HANDLER_DATA_SET, SCHEDULED_ACTION_DATA_SET]
     ]:
         if self.messagebus_factory is None:
             raise Exception("MessageBus factory is not set")
         return self.messagebus_factory
 
-    def post_decorated(self, subject: DECORATED_T) -> None:
+    def post_decorated(self, subject: FUNC_OR_TYPE_T) -> None:
 
         def messagebus_factory(
-            instance: DECORATED_T,
+            instance: FUNC_OR_TYPE_T,
         ) -> tuple[MESSAGE_HANDLER_DATA_SET, SCHEDULED_ACTION_DATA_SET]:
             handlers: MESSAGE_HANDLER_DATA_SET = set()
 

jararaca/messagebus/interceptors/aiopika_publisher_interceptor.py

@@ -9,6 +9,7 @@ from datetime import tzinfo as _TzInfo
 from typing import Any, AsyncGenerator
 
 import aio_pika
+import tenacity
 from aio_pika.abc import AbstractConnection
 from pydantic import BaseModel
 
@@ -71,7 +72,9 @@ class AIOPikaMessagePublisher(MessagePublisher):
             )
         )
 
-    async def schedule(self, message: IMessage, when: datetime, tz: _TzInfo) -> None:
+    async def schedule(
+        self, message: IMessage, when: datetime, timezone: _TzInfo
+    ) -> None:
         if not self.message_broker_backend:
             raise NotImplementedError(
                 "Schedule is not implemented for AIOPikaMessagePublisher"
@@ -110,6 +113,18 @@ class GenericPoolConfig(BaseModel):
     max_size: int
 
 
+default_retry = tenacity.retry(
+    wait=tenacity.wait_exponential_jitter(initial=1, max=60),
+    before_sleep=tenacity.before_sleep_log(logger, logging.WARNING),
+)
+
+default_retry_channel = tenacity.retry(
+    wait=tenacity.wait_exponential_jitter(initial=1, max=60),
+    before_sleep=tenacity.before_sleep_log(logger, logging.WARNING),
+    stop=tenacity.stop_after_attempt(5),
+)
+
+
 class AIOPikaConnectionFactory(MessageBusConnectionFactory):
 
     def __init__(
@@ -130,6 +145,7 @@ class AIOPikaConnectionFactory(MessageBusConnectionFactory):
 
         if connection_pool_config:
 
+            @default_retry
             async def get_connection() -> AbstractConnection:
                 return await aio_pika.connect(self.url)
 
@@ -140,6 +156,7 @@ class AIOPikaConnectionFactory(MessageBusConnectionFactory):
 
         if channel_pool_config:
 
+            @default_retry_channel
             async def get_channel() -> aio_pika.abc.AbstractChannel:
                 async with self.acquire_connection() as connection:
                     return await connection.channel(publisher_confirms=False)
@@ -148,10 +165,14 @@ class AIOPikaConnectionFactory(MessageBusConnectionFactory):
                 get_channel, max_size=channel_pool_config.max_size
             )
 
+    @default_retry
+    async def _connect(self) -> AbstractConnection:
+        return await aio_pika.connect(self.url)
+
     @asynccontextmanager
     async def acquire_connection(self) -> AsyncGenerator[AbstractConnection, Any]:
         if not self.connection_pool:
-            async with await aio_pika.connect(self.url) as connection:
+            async with await self._connect() as connection:
                 yield connection
         else:
 
@@ -162,12 +183,33 @@ class AIOPikaConnectionFactory(MessageBusConnectionFactory):
     async def acquire_channel(
         self,
     ) -> AsyncGenerator[aio_pika.abc.AbstractChannel, Any]:
-        if not self.channel_pool:
-            async with self.acquire_connection() as connection:
-                yield await connection.channel(publisher_confirms=False)
-        else:
-            async with self.channel_pool.acquire() as channel:
-                yield channel
+
+        async for attempt in tenacity.AsyncRetrying(
+            wait=tenacity.wait_exponential_jitter(initial=1, max=10),
+            before_sleep=tenacity.before_sleep_log(logger, logging.WARNING),
+            # stop=tenacity.stop_after_attempt(9000),
+        ):
+            with attempt:
+
+                if not self.connection_pool or not self.channel_pool:
+                    async with self.acquire_connection() as connection:
+                        yield await connection.channel(publisher_confirms=False)
+                else:
+
+                    async with self.connection_pool.acquire() as connection:
+                        if not connection.connected.is_set():
+                            await connection.connect()
+
+                        async with connection.channel(
+                            publisher_confirms=False
+                        ) as channel:
+                            yield channel
+                        # await connection.close()
+                if attempt.retry_state.attempt_number > 1:
+                    logger.warning(
+                        "Later successful connection attempt #%d",
+                        attempt.retry_state.attempt_number,
+                    )
 
     @asynccontextmanager
     async def provide_connection(self) -> AsyncGenerator[AIOPikaMessagePublisher, Any]:

jararaca/messagebus/interceptors/message_publisher_collector.py

@@ -0,0 +1,62 @@
+# SPDX-FileCopyrightText: 2025 Lucas S
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from dataclasses import dataclass
+from datetime import UTC, datetime, timedelta, tzinfo
+
+from jararaca.messagebus.publisher import IMessage, MessagePublisher
+
+
+@dataclass
+class CollectorDelayedMessageData:
+    message: IMessage
+    when: datetime
+    timezone: tzinfo
+
+
+class MessagePublisherCollector(MessagePublisher):
+
+    def __init__(self) -> None:
+        self.staged_delayed_messages: list[CollectorDelayedMessageData] = []
+        self.staged_messages: list[IMessage] = []
+
+    async def publish(self, message: IMessage, topic: str) -> None:
+        self.staged_messages.append(message)
+
+    async def delay(self, message: IMessage, seconds: int) -> None:
+        self.staged_delayed_messages.append(
+            CollectorDelayedMessageData(
+                message=message,
+                when=datetime.now(UTC) + timedelta(seconds=seconds),
+                timezone=UTC,
+            )
+        )
+
+    async def schedule(
+        self, message: IMessage, when: datetime, timezone: tzinfo
+    ) -> None:
+        self.staged_delayed_messages.append(
+            CollectorDelayedMessageData(
+                message=message,
+                when=when,
+                timezone=timezone,
+            )
+        )
+
+    async def fill(self, publisher: MessagePublisher) -> None:
+        for message in self.staged_messages:
+            await publisher.publish(message, message.MESSAGE_TOPIC)
+
+        for delayed_message in self.staged_delayed_messages:
+            await publisher.schedule(
+                delayed_message.message,
+                delayed_message.when,
+                delayed_message.timezone,
+            )
+
+    def has_messages(self) -> bool:
+        return bool(self.staged_messages or self.staged_delayed_messages)
+
+    async def flush(self) -> None:
+        raise NotImplementedError("I'm just a poor little collector! :(")

jararaca/messagebus/interceptors/publisher_interceptor.py

@@ -6,6 +6,9 @@ from contextlib import asynccontextmanager
 from typing import AsyncContextManager, AsyncGenerator, Protocol
 
 from jararaca.broker_backend import MessageBrokerBackend
+from jararaca.messagebus.interceptors.message_publisher_collector import (
+    MessagePublisherCollector,
+)
 from jararaca.messagebus.publisher import MessagePublisher, provide_message_publisher
 from jararaca.microservice import AppInterceptor, AppTransactionContext
 
@@ -22,10 +25,15 @@ class MessageBusPublisherInterceptor(AppInterceptor):
         connection_factory: MessageBusConnectionFactory,
         connection_name: str = "default",
         message_scheduler: MessageBrokerBackend | None = None,
+        *,
+        open_connection_at_end_of_transaction: bool = False,
     ):
         self.connection_factory = connection_factory
         self.connection_name = connection_name
         self.message_scheduler = message_scheduler
+        self.open_connection_at_end_of_transaction = (
+            open_connection_at_end_of_transaction
+        )
 
     @asynccontextmanager
     async def intercept(
@@ -35,8 +43,22 @@ class MessageBusPublisherInterceptor(AppInterceptor):
             yield
             return
 
-        async with self.connection_factory.provide_connection() as connection:
-            with provide_message_publisher(self.connection_name, connection):
+        if self.open_connection_at_end_of_transaction:
+
+            collector = MessagePublisherCollector()
+            with provide_message_publisher(self.connection_name, collector):
                 yield
 
-                await connection.flush()
+            if collector.has_messages():
+                async with self.connection_factory.provide_connection() as connection:
+                    await collector.fill(connection)
+                    await connection.flush()
+                    return
+        else:
+
+            yield
+
+            async with self.connection_factory.provide_connection() as connection:
+                with provide_message_publisher(self.connection_name, connection):
+
+                    await connection.flush()