jararaca 0.2.37a12__py3-none-any.whl → 0.3.0__py3-none-any.whl

jararaca/__init__.py

@@ -2,6 +2,7 @@ from importlib import import_module
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
+    from jararaca.broker_backend.redis_broker_backend import RedisMessageBrokerBackend
     from jararaca.messagebus.bus_message_controller import (
         ack,
         nack,
@@ -60,10 +61,12 @@ if TYPE_CHECKING:
     from .messagebus.interceptors.aiopika_publisher_interceptor import (
         AIOPikaConnectionFactory,
         GenericPoolConfig,
+    )
+    from .messagebus.interceptors.publisher_interceptor import (
         MessageBusPublisherInterceptor,
     )
+    from .messagebus.message import Message, MessageOf
     from .messagebus.publisher import use_publisher
-    from .messagebus.types import Message, MessageOf
     from .messagebus.worker import MessageBusWorker
     from .microservice import Microservice, use_app_context, use_current_container
     from .persistence.base import T_BASEMODEL, BaseEntity
@@ -115,6 +118,7 @@ if TYPE_CHECKING:
     from .tools.app_config.interceptor import AppConfigurationInterceptor
 
     __all__ = [
+        "RedisMessageBrokerBackend",
         "FilterRuleApplier",
         "SortRuleApplier",
         "use_bus_message_controller",
@@ -216,6 +220,11 @@ if TYPE_CHECKING:
 __SPEC_PARENT__: str = __spec__.parent  # type: ignore
 # A mapping of {<member name>: (package, <module name>)} defining dynamic imports
 _dynamic_imports: "dict[str, tuple[str, str, str | None]]" = {
+    "RedisMessageBrokerBackend": (
+        __SPEC_PARENT__,
+        "broker_backend.redis_broker_backend",
+        None,
+    ),
     "FilterRuleApplier": (__SPEC_PARENT__, "persistence.sort_filter", None),
     "SortRuleApplier": (__SPEC_PARENT__, "persistence.sort_filter", None),
     "use_bus_message_controller": (
@@ -286,8 +295,8 @@ _dynamic_imports: "dict[str, tuple[str, str, str | None]]" = {
     ),
     "Identifiable": (__SPEC_PARENT__, "persistence.utilities", None),
     "IdentifiableEntity": (__SPEC_PARENT__, "persistence.utilities", None),
-    "MessageOf": (__SPEC_PARENT__, "messagebus.types", None),
-    "Message": (__SPEC_PARENT__, "messagebus.types", None),
+    "MessageOf": (__SPEC_PARENT__, "messagebus.message", None),
+    "Message": (__SPEC_PARENT__, "messagebus.message", None),
     "StringCriteria": (__SPEC_PARENT__, "persistence.utilities", None),
     "DateCriteria": (__SPEC_PARENT__, "persistence.utilities", None),
     "DateOrderedFilter": (__SPEC_PARENT__, "persistence.utilities", None),
@@ -339,7 +348,7 @@ _dynamic_imports: "dict[str, tuple[str, str, str | None]]" = {
     ),
     "MessageBusPublisherInterceptor": (
         __SPEC_PARENT__,
-        "messagebus.interceptors.aiopika_publisher_interceptor",
+        "messagebus.interceptors.publisher_interceptor",
         None,
     ),
     "RedisWebSocketConnectionBackend": (

jararaca/broker_backend/__init__.py

@@ -0,0 +1,102 @@
+from abc import ABC
+from contextlib import asynccontextmanager
+from typing import AsyncContextManager, AsyncGenerator, Iterable
+
+from jararaca.scheduler.types import DelayedMessageData
+
+
+class MessageBrokerBackend(ABC):
+
+    def lock(self) -> AsyncContextManager[None]:
+        """
+        Acquire a lock for the message broker backend.
+        This is used to ensure that only one instance of the scheduler is running at a time.
+        """
+        raise NotImplementedError(f"lock() is not implemented by {self.__class__}.")
+
+    async def get_last_dispatch_time(self, action_name: str) -> int | None:
+        """
+        Get the last dispatch time of the scheduled action.
+        This is used to determine if the scheduled action should be executed again
+        or if it should be skipped.
+        """
+        raise NotImplementedError(
+            f"get_last_dispatch_time() is not implemented by {self.__class__}."
+        )
+
+    async def set_last_dispatch_time(self, action_name: str, timestamp: int) -> None:
+        """
+        Set the last dispatch time of the scheduled action.
+        This is used to determine if the scheduled action should be executed again
+        or if it should be skipped.
+        """
+        raise NotImplementedError(
+            f"set_last_dispatch_time() is not implemented by {self.__class__}."
+        )
+
+    async def get_in_execution_count(self, action_name: str) -> int:
+        """
+        Get the number of scheduled actions in execution.
+        This is used to determine if the scheduled action should be executed again
+        or if it should be skipped.
+        """
+        raise NotImplementedError(
+            f"get_in_execution_count() is not implemented by {self.__class__}."
+        )
+
+    def in_execution(self, action_name: str) -> AsyncContextManager[None]:
+        """
+        Acquire a lock for the scheduled action.
+        This is used to ensure that only one instance of the scheduled action is running at a time.
+        """
+        raise NotImplementedError(
+            f"in_execution() is not implemented by {self.__class__}."
+        )
+
+    async def dequeue_next_delayed_messages(
+        self, start_timestamp: int
+    ) -> Iterable[DelayedMessageData]:
+        """
+        Dequeue the next delayed messages from the message broker.
+        This is used to trigger the scheduled action.
+        """
+        raise NotImplementedError(
+            f"dequeue_next_delayed_messages() is not implemented by {self.__class__}."
+        )
+
+    async def enqueue_delayed_message(
+        self, delayed_message: DelayedMessageData
+    ) -> None:
+        """
+        Enqueue a delayed message to the message broker.
+        This is used to trigger the scheduled action.
+        """
+        raise NotImplementedError(
+            f"enqueue_delayed_message() is not implemented by {self.__class__}."
+        )
+
+    async def dispose(self) -> None:
+        """
+        Dispose of the message broker backend.
+        This is used to clean up resources used by the message broker backend.
+        """
+
+
+class NullBackend(MessageBrokerBackend):
+    """
+    A null backend that does nothing.
+    This is used for testing purposes.
+    """
+
+    @asynccontextmanager
+    async def lock(self) -> AsyncGenerator[None, None]:
+        yield
+
+    async def get_last_dispatch_time(self, action_name: str) -> int:
+        return 0
+
+    async def set_last_dispatch_time(self, action_name: str, timestamp: int) -> None:
+        pass
+
+    async def dispose(self) -> None:
+        pass

jararaca/broker_backend/mapper.py

@@ -0,0 +1,21 @@
+from jararaca.broker_backend import MessageBrokerBackend
+
+
+def get_message_broker_backend_from_url(url: str) -> MessageBrokerBackend:
+    """
+    Factory function to create a message broker backend instance from a URL.
+    Currently, only Redis is supported.
+    """
+    if (
+        url.startswith("redis://")
+        or url.startswith("rediss://")
+        or url.startswith("redis-socket://")
+        or url.startswith("rediss+socket://")
+    ):
+        from jararaca.broker_backend.redis_broker_backend import (
+            RedisMessageBrokerBackend,
+        )
+
+        return RedisMessageBrokerBackend(url)
+    else:
+        raise ValueError(f"Unsupported message broker backend URL: {url}")

jararaca/broker_backend/redis_broker_backend.py

@@ -0,0 +1,162 @@
+import logging
+import time
+from contextlib import asynccontextmanager
+from typing import AsyncGenerator, Iterable
+from uuid import uuid4
+
+import redis.asyncio
+
+from jararaca.broker_backend import MessageBrokerBackend
+from jararaca.scheduler.types import DelayedMessageData
+
+logger = logging.getLogger(__name__)
+
+
+class RedisMessageBrokerBackend(MessageBrokerBackend):
+    def __init__(self, url: str) -> None:
+        self.redis = redis.asyncio.Redis.from_url(url)
+        self.last_dispatch_time_key = "last_dispatch_time:{action_name}"
+        self.last_execution_time_key = "last_execution_time:{action_name}"
+        self.execution_indicator_key = "in_execution:{action_name}:{timestamp}"
+        self.execution_indicator_expiration = 60 * 5
+        self.delayed_messages_key = "delayed_messages"
+        self.delayed_messages_metadata_key = "delayed_messages_metadata:{task_id}"
+
+    @asynccontextmanager
+    async def lock(self) -> AsyncGenerator[None, None]:
+        yield
+
+    async def get_last_dispatch_time(self, action_name: str) -> int | None:
+
+        key = self.last_dispatch_time_key.format(action_name=action_name)
+        last_execution_time = await self.redis.get(key)
+        if last_execution_time is None:
+            return None
+        return int(last_execution_time)
+
+    async def set_last_dispatch_time(self, action_name: str, timestamp: int) -> None:
+        key = self.last_dispatch_time_key.format(action_name=action_name)
+        await self.redis.set(key, timestamp)
+
+    async def get_last_execution_time(self, action_name: str) -> int | None:
+        key = self.last_execution_time_key.format(action_name=action_name)
+        last_execution_time = await self.redis.get(key)
+        if last_execution_time is None:
+            return None
+        return int(last_execution_time)
+
+    async def set_last_execution_time(self, action_name: str, timestamp: int) -> None:
+        key = self.last_execution_time_key.format(action_name=action_name)
+        await self.redis.set(key, timestamp)
+
+    async def get_in_execution_count(self, action_name: str) -> int:
+        key = self.execution_indicator_key.format(
+            action_name=action_name, timestamp="*"
+        )
+        in_execution_count = await self.redis.keys(key)
+        if in_execution_count is None:
+            return 0
+
+        return len(in_execution_count)
+
+    @asynccontextmanager
+    async def in_execution(self, action_name: str) -> AsyncGenerator[None, None]:
+        """
+        Acquire a lock for the scheduled action.
+        This is used to ensure that only one instance of the scheduled action is running at a time.
+        """
+        key = self.execution_indicator_key.format(
+            action_name=action_name, timestamp=int(time.time())
+        )
+        await self.redis.set(key, 1, ex=self.execution_indicator_expiration)
+        try:
+            yield
+        finally:
+            await self.redis.delete(key)
+
+    async def enqueue_delayed_message(
+        self, delayed_message: DelayedMessageData
+    ) -> None:
+        """
+        Enqueue a delayed message to the message broker.
+        This is used to trigger the scheduled action.
+        """
+        task_id = str(uuid4())
+        async with self.redis.pipeline() as pipe:
+            pipe.set(
+                self.delayed_messages_metadata_key.format(task_id=task_id),
+                delayed_message.model_dump_json().encode(),
+            )
+            pipe.zadd(
+                self.delayed_messages_key,
+                {task_id: delayed_message.dispatch_time},
+                nx=True,
+            )
+            await pipe.execute()
+
+    async def dequeue_next_delayed_messages(
+        self, start_timestamp: int
+    ) -> Iterable[DelayedMessageData]:
+        """
+        Dequeue the next delayed messages from the message broker.
+        This is used to trigger the scheduled action.
+        """
+        tasks_ids = await self.redis.zrangebyscore(
+            name=self.delayed_messages_key,
+            max=start_timestamp,
+            min="-inf",
+            withscores=False,
+        )
+
+        if not tasks_ids:
+            return []
+
+        tasks_bytes_data: list[bytes] = []
+
+        for task_id_bytes in tasks_ids:
+            metadata = await self.redis.get(
+                self.delayed_messages_metadata_key.format(
+                    task_id=task_id_bytes.decode()
+                )
+            )
+            if metadata is None:
+                logger.warning(
+                    f"Delayed message metadata not found for task_id: {task_id_bytes.decode()}"
+                )
+
+                continue
+
+            tasks_bytes_data.append(metadata)
+
+        async with self.redis.pipeline() as pipe:
+            for task_id_bytes in tasks_ids:
+                pipe.zrem(self.delayed_messages_key, task_id_bytes.decode())
+                pipe.delete(
+                    self.delayed_messages_metadata_key.format(
+                        task_id=task_id_bytes.decode()
+                    )
+                )
+            await pipe.execute()
+
+        delayed_messages: list[DelayedMessageData] = []
+
+        for task_bytes_data in tasks_bytes_data:
+            try:
+                delayed_message = DelayedMessageData.model_validate_json(
+                    task_bytes_data.decode()
+                )
+                delayed_messages.append(delayed_message)
+            except Exception:
+                logger.error(
+                    f"Error parsing delayed message: {task_bytes_data.decode()}"
+                )
+                continue
+
+        return delayed_messages
+
+    async def dispose(self) -> None:
+        """
+        Dispose of the message broker backend.
+        This is used to close the connection to the message broker.
+        """
+        await self.redis.close()

jararaca/cli.py

@@ -11,11 +11,13 @@ import click
 import uvicorn
 from mako.template import Template  # type: ignore
 
-from jararaca.messagebus.worker import AioPikaWorkerConfig, MessageBusWorker
+from jararaca.messagebus import worker as worker_v1
+from jararaca.messagebus import worker_v2 as worker_v2_mod
 from jararaca.microservice import Microservice
 from jararaca.presentation.http_microservice import HttpMicroservice
 from jararaca.presentation.server import create_http_server
-from jararaca.scheduler.scheduler import Scheduler, SchedulerBackend, SchedulerConfig
+from jararaca.scheduler.scheduler import Scheduler
+from jararaca.scheduler.scheduler_v2 import SchedulerV2
 from jararaca.tools.typescript.interface_parser import (
     write_microservice_to_typescript_interface,
 )
@@ -35,7 +37,10 @@ def find_item_by_module_path(
     try:
         module = importlib.import_module(module_name)
     except ImportError as e:
-        raise ImportError("App module not found") from e
+        if e.name == module_name:
+            raise ImportError("Module not found") from e
+        else:
+            raise
 
     if not hasattr(module, app):
         raise ValueError("module %s has no attribute %s" % (module, app))
@@ -73,7 +78,7 @@ def cli() -> None:
 @click.option(
     "--url",
     type=str,
-    default="amqp://guest:guest@localhost/",
+    envvar="BROKER_URL",
 )
 @click.option(
     "--username",
@@ -90,11 +95,6 @@ def cli() -> None:
     type=str,
     default="jararaca_ex",
 )
-@click.option(
-    "--queue",
-    type=str,
-    default="jararaca_q",
-)
 @click.option(
     "--prefetch-count",
     type=int,
@@ -106,7 +106,6 @@ def worker(
     username: str | None,
     password: str | None,
     exchange: str,
-    queue: str,
     prefetch_count: int,
 ) -> None:
 
@@ -134,30 +133,59 @@ def worker(
 
     url = parsed_url.geturl()
 
-    config = AioPikaWorkerConfig(
+    config = worker_v1.AioPikaWorkerConfig(
         url=url,
         exchange=exchange,
-        queue=queue,
         prefetch_count=prefetch_count,
     )
 
-    MessageBusWorker(app, config=config).start_sync()
+    worker_v1.MessageBusWorker(app, config=config).start_sync()
 
 
 @cli.command()
 @click.argument(
     "app_path",
     type=str,
+    envvar="APP_PATH",
+)
+@click.option(
+    "--broker-url",
+    type=str,
+    envvar="BROKER_URL",
+)
+@click.option(
+    "--backend-url",
+    type=str,
+    envvar="BACKEND_URL",
+)
+def worker_v2(app_path: str, broker_url: str, backend_url: str) -> None:
+
+    app = find_microservice_by_module_path(app_path)
+
+    worker_v2_mod.MessageBusWorker(
+        app=app,
+        broker_url=broker_url,
+        backend_url=backend_url,
+    ).start_sync()
+
+
+@cli.command()
+@click.argument(
+    "app_path",
+    type=str,
+    envvar="APP_PATH",
 )
 @click.option(
     "--host",
     type=str,
     default="0.0.0.0",
+    envvar="HOST",
 )
 @click.option(
     "--port",
     type=int,
     default=8000,
+    envvar="PORT",
 )
 def server(app_path: str, host: str, port: int) -> None:
 
@@ -180,9 +208,6 @@ def server(app_path: str, host: str, port: int) -> None:
     uvicorn.run(asgi_app, host=host, port=port)
 
 
-class NullBackend(SchedulerBackend): ...
-
-
 @cli.command()
 @click.argument(
     "app_path",
@@ -199,7 +224,45 @@ def scheduler(
 ) -> None:
     app = find_microservice_by_module_path(app_path)
 
-    Scheduler(app, NullBackend(), SchedulerConfig(interval=interval)).run()
+    Scheduler(app, interval=interval).run()
+
+
+@cli.command()
+@click.argument(
+    "app_path",
+    type=str,
+)
+@click.option(
+    "--interval",
+    type=int,
+    default=1,
+    required=True,
+)
+@click.option(
+    "--broker-url",
+    type=str,
+    required=True,
+)
+@click.option(
+    "--backend-url",
+    type=str,
+    required=True,
+)
+def scheduler_v2(
+    interval: int,
+    broker_url: str,
+    backend_url: str,
+    app_path: str,
+) -> None:
+
+    app = find_microservice_by_module_path(app_path)
+    scheduler = SchedulerV2(
+        app=app,
+        interval=interval,
+        backend_url=backend_url,
+        broker_url=broker_url,
+    )
+    scheduler.run()
 
 
 @cli.command()
@@ -214,13 +277,11 @@ def scheduler(
 @click.option(
     "--watch",
     is_flag=True,
-    help="Watch for file changes and regenerate TypeScript interfaces",
 )
 @click.option(
     "--src-dir",
     type=click.Path(exists=True, file_okay=False, dir_okay=True),
     default="src",
-    help="Source directory to watch for changes (default: src)",
 )
 def gen_tsi(app_path: str, file_path: StreamWriter, watch: bool, src_dir: str) -> None:
     """Generate TypeScript interfaces from a Python microservice."""

jararaca/messagebus/__init__.py

@@ -1,3 +1,3 @@
-from .types import MessageOf
+from .message import MessageOf
 
 __all__ = ["MessageOf"]

jararaca/messagebus/decorators.py

@@ -2,7 +2,8 @@ import inspect
 from dataclasses import dataclass
 from typing import Any, Awaitable, Callable, Generic, TypeVar, cast
 
-from jararaca.messagebus.types import INHERITS_MESSAGE_CO, Message, MessageOf
+from jararaca.messagebus.message import INHERITS_MESSAGE_CO, Message, MessageOf
+from jararaca.scheduler.decorators import ScheduledAction
 
 DECORATED_FUNC = TypeVar("DECORATED_FUNC", bound=Callable[..., Any])
 DECORATED_CLASS = TypeVar("DECORATED_CLASS", bound=Any)
@@ -45,7 +46,7 @@ class MessageHandler(Generic[INHERITS_MESSAGE_CO]):
 
     @staticmethod
     def get_message_incoming(
-        func: Callable[[MessageOf[Any]], Awaitable[Any]]
+        func: Callable[[MessageOf[Any]], Awaitable[Any]],
     ) -> "MessageHandler[Message] | None":
         if not hasattr(func, MessageHandler.MESSAGE_INCOMING_ATTR):
             return None
@@ -62,7 +63,21 @@ class MessageHandlerData:
     callable: Callable[[MessageOf[Any]], Awaitable[None]]
 
 
+@dataclass(frozen=True)
+class ScheduleDispatchData:
+    timestamp: float
+
+
+@dataclass(frozen=True)
+class ScheduledActionData:
+    spec: ScheduledAction
+    callable: Callable[
+        ..., Awaitable[None]
+    ]  # Callable[[ScheduleDispatchData], Awaitable[None]]
+
+
 MESSAGE_HANDLER_DATA_SET = set[MessageHandlerData]
+SCHEDULED_ACTION_DATA_SET = set[ScheduledActionData]
 
 
 class MessageBusController:
@@ -70,11 +85,16 @@ class MessageBusController:
     MESSAGEBUS_ATTR = "__messagebus__"
 
     def __init__(self) -> None:
-        self.messagebus_factory: Callable[[Any], MESSAGE_HANDLER_DATA_SET] | None = None
+        self.messagebus_factory: (
+            Callable[[Any], tuple[MESSAGE_HANDLER_DATA_SET, SCHEDULED_ACTION_DATA_SET]]
+            | None
+        ) = None
 
     def get_messagebus_factory(
         self,
-    ) -> Callable[[DECORATED_CLASS], MESSAGE_HANDLER_DATA_SET]:
+    ) -> Callable[
+        [DECORATED_CLASS], 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
@@ -83,33 +103,49 @@ class MessageBusController:
 
         def messagebus_factory(
             instance: DECORATED_CLASS,
-        ) -> MESSAGE_HANDLER_DATA_SET:
+        ) -> tuple[MESSAGE_HANDLER_DATA_SET, SCHEDULED_ACTION_DATA_SET]:
             handlers: MESSAGE_HANDLER_DATA_SET = set()
-            inspect.signature(func)
+
+            schedulers: SCHEDULED_ACTION_DATA_SET = set()
 
             members = inspect.getmembers(func, predicate=inspect.isfunction)
 
             for name, member in members:
-                message_incoming = MessageHandler.get_message_incoming(member)
+                message_handler_decoration = MessageHandler.get_message_incoming(member)
+                scheduled_action_decoration = ScheduledAction.get_scheduled_action(
+                    member
+                )
 
-                if message_incoming is None:
-                    continue
+                if message_handler_decoration is not None:
 
-                if not inspect.iscoroutinefunction(member):
-                    raise Exception(
-                        "Message incoming handler '%s' from '%s.%s' must be a coroutine function"
-                        % (name, func.__module__, func.__qualname__)
-                    )
+                    if not inspect.iscoroutinefunction(member):
+                        raise Exception(
+                            "Message incoming handler '%s' from '%s.%s' must be a coroutine function"
+                            % (name, func.__module__, func.__qualname__)
+                        )
 
-                handlers.add(
-                    MessageHandlerData(
-                        message_type=message_incoming.message_type,
-                        spec=message_incoming,
-                        callable=getattr(instance, name),
+                    handlers.add(
+                        MessageHandlerData(
+                            message_type=message_handler_decoration.message_type,
+                            spec=message_handler_decoration,
+                            callable=getattr(instance, name),
+                        )
+                    )
+                elif scheduled_action_decoration is not None:
+                    if not inspect.iscoroutinefunction(member):
+                        raise Exception(
+                            "Scheduled action handler '%s' from '%s.%s' must be a coroutine function"
+                            % (name, func.__module__, func.__qualname__)
+                        )
+
+                    schedulers.add(
+                        ScheduledActionData(
+                            spec=scheduled_action_decoration,
+                            callable=getattr(instance, name),
+                        )
                     )
-                )
 
-            return handlers
+            return handlers, schedulers
 
         self.messagebus_factory = messagebus_factory