jararaca 0.2.37a12__py3-none-any.whl → 0.3.1__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

@@ -1,9 +1,11 @@
 import importlib
 import importlib.resources
+import multiprocessing
 import os
 import sys
 import time
 from codecs import StreamWriter
+from pathlib import Path
 from typing import Any
 from urllib.parse import urlparse, urlunsplit
 
@@ -11,11 +13,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 +39,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 +80,7 @@ def cli() -> None:
 @click.option(
     "--url",
     type=str,
-    default="amqp://guest:guest@localhost/",
+    envvar="BROKER_URL",
 )
 @click.option(
     "--username",
@@ -90,11 +97,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 +108,6 @@ def worker(
     username: str | None,
     password: str | None,
     exchange: str,
-    queue: str,
     prefetch_count: int,
 ) -> None:
 
@@ -134,30 +135,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 +210,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 +226,7 @@ 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()
@@ -207,47 +234,86 @@ def scheduler(
     "app_path",
     type=str,
 )
-@click.argument(
-    "file_path",
-    type=click.File("w"),
+@click.option(
+    "--interval",
+    type=int,
+    default=1,
+    required=True,
 )
 @click.option(
-    "--watch",
-    is_flag=True,
-    help="Watch for file changes and regenerate TypeScript interfaces",
+    "--broker-url",
+    type=str,
+    required=True,
 )
 @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)",
+    "--backend-url",
+    type=str,
+    required=True,
 )
-def gen_tsi(app_path: str, file_path: StreamWriter, watch: bool, src_dir: str) -> None:
-    """Generate TypeScript interfaces from a Python microservice."""
+def scheduler_v2(
+    interval: int,
+    broker_url: str,
+    backend_url: str,
+    app_path: str,
+) -> None:
 
-    # Generate typescript interfaces
-    def generate_interfaces() -> None:
-        try:
-            app = find_microservice_by_module_path(app_path)
-            content = write_microservice_to_typescript_interface(app)
+    app = find_microservice_by_module_path(app_path)
+    scheduler = SchedulerV2(
+        app=app,
+        interval=interval,
+        backend_url=backend_url,
+        broker_url=broker_url,
+    )
+    scheduler.run()
 
+
+def generate_interfaces(app_path: str, file_path: str) -> None:
+    try:
+        app = find_microservice_by_module_path(app_path)
+        content = write_microservice_to_typescript_interface(app)
+
+        with open(file_path, "w", encoding="utf-8") as file:
             # Save current position
-            file_path.tell()
+            file.tell()
 
             # Reset file to beginning
-            file_path.seek(0)
-            file_path.truncate()
+            file.seek(0)
+            file.truncate()
 
             # Write new content
-            file_path.write(content)
-            file_path.flush()
+            file.write(content)
+            file.flush()
+
+        print(
+            f"Generated TypeScript interfaces at {time.strftime('%H:%M:%S')} at {str(Path(file_path).absolute())}"
+        )
+    except Exception as e:
+        print(f"Error generating TypeScript interfaces: {e}", file=sys.stderr)
 
-            print(f"Generated TypeScript interfaces at {time.strftime('%H:%M:%S')}")
-        except Exception as e:
-            print(f"Error generating TypeScript interfaces: {e}", file=sys.stderr)
+
+@cli.command()
+@click.argument(
+    "app_path",
+    type=str,
+)
+@click.argument(
+    "file_path",
+    type=click.Path(file_okay=True, dir_okay=False),
+)
+@click.option(
+    "--watch",
+    is_flag=True,
+)
+@click.option(
+    "--src-dir",
+    type=click.Path(exists=True, file_okay=False, dir_okay=True),
+    default="src",
+)
+def gen_tsi(app_path: str, file_path: str, watch: bool, src_dir: str) -> None:
+    """Generate TypeScript interfaces from a Python microservice."""
 
     # Initial generation
-    generate_interfaces()
+    generate_interfaces(app_path, file_path)
 
     # If watch mode is not enabled, exit
     if not watch:
@@ -273,7 +339,33 @@ def gen_tsi(app_path: str, file_path: StreamWriter, watch: bool, src_dir: str) -
             )
             if not event.is_directory and src_path.endswith(".py"):
                 print(f"File changed: {src_path}")
-                generate_interfaces()
+                # Create a completely detached process to ensure classes are reloaded
+                process = multiprocessing.get_context("spawn").Process(
+                    target=generate_interfaces,
+                    args=(app_path, file_path),
+                    daemon=False,  # Non-daemon to ensure it completes
+                )
+                process.start()
+                # Don't join to keep it detached from main process
+
+        def _run_generator_in_separate_process(
+            self, app_path: str, file_path: str
+        ) -> None:
+            # Using Python executable to start a completely new process
+            # This ensures all modules are freshly imported
+            generate_interfaces(app_path, file_path)
+            # cmd = [
+            #     sys.executable,
+            #     "-c",
+            #     (
+            #         f"import sys; sys.path.extend({sys.path}); "
+            #         f"from jararaca.cli import generate_interfaces; "
+            #         f"generate_interfaces('{app_path}', '{file_path}')"
+            #     ),
+            # ]
+            # import subprocess
+
+            # subprocess.run(cmd, check=False)
 
     # Set up observer
     observer = Observer()

jararaca/messagebus/__init__.py

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