jararaca 0.3.11a7__py3-none-any.whl → 0.3.11a9__py3-none-any.whl

jararaca/messagebus/worker.py

@@ -95,39 +95,44 @@ class AioPikaMicroserviceConsumer:
         self.lock = asyncio.Lock()
         self.tasks: set[asyncio.Task[Any]] = set()
 
-    async def consume(self, passive_declare: bool) -> None:
-
+    async def consume(self) -> None:
         connection = await aio_pika.connect(self.config.url)
-
         channel = await connection.channel()
-
         await channel.set_qos(prefetch_count=self.config.prefetch_count)
 
-        main_ex = await RabbitmqUtils.declare_main_exchange(
-            channel=channel,
-            exchange_name=self.config.exchange,
-            passive=passive_declare,
-        )
-
-        dlx, dlq = await RabbitmqUtils.declare_dl_kit(channel=channel)
+        # Get existing exchange and DL kit
+        try:
+            main_ex = await RabbitmqUtils.get_main_exchange(
+                channel=channel,
+                exchange_name=self.config.exchange,
+            )
+            dlx, dlq = await RabbitmqUtils.get_dl_kit(channel=channel)
+        except Exception as e:
+            logger.error(
+                f"Required exchange or queue infrastructure not found. "
+                f"Please use the declare command first to create the required infrastructure. Error: {e}"
+            )
+            self.shutdown_event.set()
+            return
 
         for handler in self.message_handler_set:
-
             queue_name = f"{handler.message_type.MESSAGE_TOPIC}.{handler.instance_callable.__module__}.{handler.instance_callable.__qualname__}"
             routing_key = f"{handler.message_type.MESSAGE_TOPIC}.#"
 
             self.incoming_map[queue_name] = handler
 
-            queue: aio_pika.abc.AbstractQueue = await channel.declare_queue(
-                passive=passive_declare,
-                name=queue_name,
-                arguments={
-                    "x-dead-letter-exchange": dlx.name,
-                    "x-dead-letter-routing-key": dlq.name,
-                },
-            )
-
-            await queue.bind(exchange=main_ex, routing_key=routing_key)
+            # Get existing queue
+            try:
+                queue = await RabbitmqUtils.get_worker_v1_queue(
+                    channel=channel,
+                    queue_name=queue_name,
+                )
+            except Exception as e:
+                logger.error(
+                    f"Worker queue '{queue_name}' not found. "
+                    f"Please use the declare command first to create the queue. Error: {e}"
+                )
+                continue
 
             await queue.consume(
                 callback=MessageHandlerCallback(
@@ -337,7 +342,7 @@ class MessageBusWorker:
             raise RuntimeError("Consumer not started")
         return self._consumer
 
-    async def start_async(self, passive_declare: bool) -> None:
+    async def start_async(self, handler_names: set[str] | None = None) -> None:
         all_message_handlers_set: MESSAGE_HANDLER_DATA_SET = set()
         async with self.lifecycle():
             for instance_type in self.app.controllers:
@@ -356,6 +361,15 @@ class MessageBusWorker:
                 for handler_data in handlers:
                     message_type = handler_data.spec.message_type
                     topic = message_type.MESSAGE_TOPIC
+
+                    # Filter handlers by name if specified
+                    if handler_names is not None and handler_data.spec.name is not None:
+                        if handler_data.spec.name not in handler_names:
+                            continue
+                    elif handler_names is not None and handler_data.spec.name is None:
+                        # Skip handlers without names when filtering is requested
+                        continue
+
                     if (
                         topic in message_handler_data_map
                         and message_type.MESSAGE_TYPE == "task"
@@ -374,9 +388,9 @@ class MessageBusWorker:
                 uow_context_provider=self.uow_context_provider,
             )
 
-            await consumer.consume(passive_declare=passive_declare)
+            await consumer.consume()
 
-    def start_sync(self, passive_declare: bool) -> None:
+    def start_sync(self, handler_names: set[str] | None = None) -> None:
 
         def on_shutdown(loop: asyncio.AbstractEventLoop) -> None:
             logger.info("Shutting down")
@@ -386,7 +400,7 @@ class MessageBusWorker:
             runner.get_loop().add_signal_handler(
                 signal.SIGINT, on_shutdown, runner.get_loop()
             )
-            runner.run(self.start_async(passive_declare=passive_declare))
+            runner.run(self.start_async(handler_names=handler_names))
 
 
 class AioPikaMessageBusController(BusMessageController):

jararaca/messagebus/worker_v2.py

@@ -12,6 +12,7 @@ from urllib.parse import parse_qs, urlparse
 import aio_pika
 import aio_pika.abc
 import uvloop
+from aio_pika.exceptions import AMQPError, ChannelClosed, ChannelNotFoundEntity
 from pydantic import BaseModel
 
 from jararaca.broker_backend import MessageBrokerBackend
@@ -105,7 +106,6 @@ class AioPikaMicroserviceConsumer(MessageBusConsumer):
         message_handler_set: MESSAGE_HANDLER_DATA_SET,
         scheduled_actions: SCHEDULED_ACTION_DATA_SET,
         uow_context_provider: UnitOfWorkContextProvider,
-        passive_declare: bool = False,
     ):
 
         self.broker_backend = broker_backend
@@ -117,7 +117,6 @@ class AioPikaMicroserviceConsumer(MessageBusConsumer):
         self.shutdown_event = asyncio.Event()
         self.lock = asyncio.Lock()
         self.tasks: set[asyncio.Task[Any]] = set()
-        self.passive_declare = passive_declare
 
     async def consume(self) -> None:
 
@@ -127,21 +126,22 @@ class AioPikaMicroserviceConsumer(MessageBusConsumer):
 
         await channel.set_qos(prefetch_count=self.config.prefetch_count)
 
-        await RabbitmqUtils.declare_main_exchange(
-            channel=channel,
-            exchange_name=self.config.exchange,
-            passive=self.passive_declare,
-        )
-
-        dlx = await RabbitmqUtils.declare_dl_exchange(
-            channel=channel, passive=self.passive_declare
-        )
-
-        dlq = await RabbitmqUtils.declare_dl_queue(
-            channel=channel, passive=self.passive_declare
-        )
+        # Get existing exchange and queues
+        try:
+            exchange = await RabbitmqUtils.get_main_exchange(
+                channel=channel,
+                exchange_name=self.config.exchange,
+            )
 
-        await dlq.bind(dlx, routing_key=RabbitmqUtils.DEAD_LETTER_EXCHANGE)
+            dlx = await RabbitmqUtils.get_dl_exchange(channel=channel)
+            dlq = await RabbitmqUtils.get_dl_queue(channel=channel)
+        except (ChannelNotFoundEntity, ChannelClosed, AMQPError) as e:
+            logger.critical(
+                f"Required exchange or queue infrastructure not found and passive mode is enabled. "
+                f"Please use the declare command first to create the required infrastructure. Error: {e}"
+            )
+            self.shutdown_event.set()
+            return
 
         for handler in self.message_handler_set:
 
@@ -150,11 +150,16 @@ class AioPikaMicroserviceConsumer(MessageBusConsumer):
 
             self.incoming_map[queue_name] = handler
 
-            queue = await RabbitmqUtils.declare_queue(
-                channel=channel, queue_name=queue_name, passive=self.passive_declare
-            )
-
-            await queue.bind(exchange=self.config.exchange, routing_key=routing_key)
+            try:
+                queue = await RabbitmqUtils.get_queue(
+                    channel=channel, queue_name=queue_name
+                )
+            except (ChannelNotFoundEntity, ChannelClosed, AMQPError) as e:
+                logger.error(
+                    f"Queue '{queue_name}' not found and passive mode is enabled. "
+                    f"Please use the declare command first to create the queue. Error: {e}"
+                )
+                continue
 
             await queue.consume(
                 callback=MessageHandlerCallback(
@@ -174,11 +179,16 @@ class AioPikaMicroserviceConsumer(MessageBusConsumer):
 
             routing_key = queue_name
 
-            queue = await RabbitmqUtils.declare_queue(
-                channel=channel, queue_name=queue_name, passive=self.passive_declare
-            )
-
-            await queue.bind(exchange=self.config.exchange, routing_key=routing_key)
+            try:
+                queue = await RabbitmqUtils.get_queue(
+                    channel=channel, queue_name=queue_name
+                )
+            except (ChannelNotFoundEntity, ChannelClosed, AMQPError) as e:
+                logger.error(
+                    f"Scheduler queue '{queue_name}' not found and passive mode is enabled. "
+                    f"Please use the declare command first to create the queue. Error: {e}"
+                )
+                continue
 
             await queue.consume(
                 callback=ScheduledMessageHandlerCallback(
@@ -515,10 +525,17 @@ async def none_context() -> AsyncGenerator[None, None]:
 
 
 class MessageBusWorker:
-    def __init__(self, app: Microservice, broker_url: str, backend_url: str) -> None:
+    def __init__(
+        self,
+        app: Microservice,
+        broker_url: str,
+        backend_url: str,
+        handler_names: set[str] | None = None,
+    ) -> None:
         self.app = app
         self.backend_url = backend_url
         self.broker_url = broker_url
+        self.handler_names = handler_names
 
         self.container = Container(app)
         self.lifecycle = AppLifecycle(app, self.container)
@@ -555,6 +572,21 @@ class MessageBusWorker:
                 for handler_data in handlers:
                     message_type = handler_data.spec.message_type
                     topic = message_type.MESSAGE_TOPIC
+
+                    # Filter handlers by name if specified
+                    if (
+                        self.handler_names is not None
+                        and handler_data.spec.name is not None
+                    ):
+                        if handler_data.spec.name not in self.handler_names:
+                            continue
+                    elif (
+                        self.handler_names is not None
+                        and handler_data.spec.name is None
+                    ):
+                        # Skip handlers without names when filtering is requested
+                        continue
+
                     if (
                         topic in message_handler_data_map
                         and message_type.MESSAGE_TYPE == "task"

jararaca/microservice.py

@@ -1,4 +1,5 @@
 import inspect
+import logging
 from contextlib import contextmanager, suppress
 from contextvars import ContextVar
 from dataclasses import dataclass, field
@@ -25,6 +26,8 @@ from jararaca.messagebus import MessageOf
 from jararaca.messagebus.message import Message
 from jararaca.reflect.controller_inspect import ControllerMemberReflect
 
+logger = logging.getLogger(__name__)
+
 if TYPE_CHECKING:
     from typing_extensions import TypeIs
 
@@ -145,6 +148,49 @@ class Microservice:
     )
 
 
+@dataclass
+class InstantiationNode:
+    property_name: str
+    parent: "InstantiationNode | None" = None
+    source_type: Any | None = None
+    target_type: Any | None = None
+
+
+instantiation_vector_ctxvar = ContextVar[list[InstantiationNode]](
+    "instantiation_vector", default=[]
+)
+
+
+def print_instantiation_vector(
+    instantiation_vector: list[InstantiationNode],
+) -> None:
+    """
+    Prints the instantiation vector for debugging purposes.
+    """
+    for node in instantiation_vector:
+        print(
+            f"Property: {node.property_name}, Source: {node.source_type}, Target: {node.target_type}"
+        )
+
+
+@contextmanager
+def span_instantiation_vector(
+    instantiation_node: InstantiationNode,
+) -> Generator[None, None, None]:
+    """
+    Context manager to track instantiation nodes in a vector.
+    This is useful for debugging and tracing instantiation paths.
+    """
+    current_vector = list(instantiation_vector_ctxvar.get())
+    current_vector.append(instantiation_node)
+    token = instantiation_vector_ctxvar.set(current_vector)
+    try:
+        yield
+    finally:
+        with suppress(ValueError):
+            instantiation_vector_ctxvar.reset(token)
+
+
 class Container:
 
     def __init__(self, app: Microservice) -> None:
@@ -161,40 +207,54 @@ class Container:
                 if provider.use_value:
                     self.instances_map[provider.provide] = provider.use_value
                 elif provider.use_class:
-                    self.get_and_register(provider.use_class, provider.provide)
+                    self._get_and_register(provider.use_class, provider.provide)
                 elif provider.use_factory:
-                    self.get_and_register(provider.use_factory, provider.provide)
+                    self._get_and_register(provider.use_factory, provider.provide)
             else:
-                self.get_and_register(provider, provider)
+                self._get_and_register(provider, provider)
 
-    def instantiate(self, type_: type[Any] | Callable[..., Any]) -> Any:
+    def _instantiate(self, type_: type[Any] | Callable[..., Any]) -> Any:
 
-        dependencies = self.parse_dependencies(type_)
+        dependencies = self._parse_dependencies(type_)
 
-        evaluated_dependencies = {
-            name: self.get_or_register_token_or_type(dependency)
-            for name, dependency in dependencies.items()
-        }
+        evaluated_dependencies: dict[str, Any] = {}
+        for name, dependency in dependencies.items():
+            with span_instantiation_vector(
+                InstantiationNode(
+                    property_name=name,
+                    source_type=type_,
+                    target_type=dependency,
+                )
+            ):
+                evaluated_dependencies[name] = self.get_or_register_token_or_type(
+                    dependency
+                )
 
         instance = type_(**evaluated_dependencies)
 
         return instance
 
-    def parse_dependencies(
+    def _parse_dependencies(
         self, provider: type[Any] | Callable[..., Any]
     ) -> dict[str, type[Any]]:
 
-        signature = inspect.signature(provider)
+        vector = instantiation_vector_ctxvar.get()
+        try:
+            signature = inspect.signature(provider)
+        except ValueError:
+            print("VECTOR:", vector)
+            print_instantiation_vector(vector)
+            raise
 
         parameters = signature.parameters
 
         return {
-            name: self.lookup_parameter_type(parameter)
+            name: self._lookup_parameter_type(parameter)
             for name, parameter in parameters.items()
             if parameter.annotation != inspect.Parameter.empty
         }
 
-    def lookup_parameter_type(self, parameter: inspect.Parameter) -> Any:
+    def _lookup_parameter_type(self, parameter: inspect.Parameter) -> Any:
         if parameter.annotation == inspect.Parameter.empty:
             raise Exception(f"Parameter {parameter.name} has no type annotation")
 
@@ -227,14 +287,14 @@ class Container:
             item_type = bind_to = token_or_type
 
         if token_or_type not in self.instances_map:
-            return self.get_and_register(item_type, bind_to)
+            return self._get_and_register(item_type, bind_to)
 
         return cast(T, self.instances_map[bind_to])
 
-    def get_and_register(
+    def _get_and_register(
         self, item_type: Type[T] | Callable[..., T], bind_to: Any
     ) -> T:
-        instance = self.instantiate(item_type)
+        instance = self._instantiate(item_type)
         self.register(instance, bind_to)
         return cast(T, instance)
 

jararaca/scheduler/decorators.py

@@ -20,6 +20,7 @@ class ScheduledAction:
         exclusive: bool = True,
         timeout: int | None = None,
         exception_handler: Callable[[BaseException], None] | None = None,
+        name: str | None = None,
     ) -> None:
         """
         :param cron: A string representing the cron expression for the scheduled action.
@@ -27,6 +28,7 @@ class ScheduledAction:
         :param exclusive: A boolean indicating if the scheduled action should be executed in one instance of the application. (Requires a distributed lock provided by a backend)
         :param exception_handler: A callable that will be called when an exception is raised during the execution of the scheduled action.
         :param timeout: An integer representing the timeout for the scheduled action in seconds. If the scheduled action takes longer than this time, it will be terminated.
+        :param name: An optional name for the scheduled action, used for filtering which actions to run.
         """
         self.cron = cron
         """
@@ -55,6 +57,11 @@ class ScheduledAction:
         If the scheduled action takes longer than this time, it will be terminated.
         """
 
+        self.name = name
+        """
+        An optional name for the scheduled action, used for filtering which actions to run.
+        """
+
     def __call__(self, func: DECORATED_FUNC) -> DECORATED_FUNC:
         ScheduledAction.register(func, self)
         return func

jararaca/scheduler/scheduler.py

@@ -34,7 +34,7 @@ class SchedulerConfig:
 
 
 def extract_scheduled_actions(
-    app: Microservice, container: Container
+    app: Microservice, container: Container, scheduler_names: set[str] | None = None
 ) -> list[ScheduledActionData]:
     scheduled_actions: list[ScheduledActionData] = []
     for controllers in app.controllers:
@@ -42,6 +42,17 @@ def extract_scheduled_actions(
         controller_instance: Any = container.get_by_type(controllers)
 
         controller_scheduled_actions = get_type_scheduled_actions(controller_instance)
+
+        # Filter scheduled actions by name if scheduler_names is provided
+        if scheduler_names is not None:
+            filtered_actions = []
+            for action in controller_scheduled_actions:
+                # Include actions that have a name and it's in the provided set
+                if action.spec.name and action.spec.name in scheduler_names:
+                    filtered_actions.append(action)
+                # Skip actions without names when filtering is active
+            controller_scheduled_actions = filtered_actions
+
         scheduled_actions.extend(controller_scheduled_actions)
 
     return scheduled_actions
@@ -59,10 +70,12 @@ class Scheduler:
         self,
         app: Microservice,
         interval: int,
+        scheduler_names: set[str] | None = None,
     ) -> None:
         self.app = app
 
         self.interval = interval
+        self.scheduler_names = scheduler_names
         self.container = Container(self.app)
         self.uow_provider = UnitOfWorkContextProvider(app, self.container)
 
@@ -146,7 +159,9 @@ class Scheduler:
         async def run_scheduled_actions() -> None:
 
             async with self.lifceycle():
-                scheduled_actions = extract_scheduled_actions(self.app, self.container)
+                scheduled_actions = extract_scheduled_actions(
+                    self.app, self.container, self.scheduler_names
+                )
 
                 while True:
                     for action in scheduled_actions:

jararaca/scheduler/scheduler_v2.py

@@ -31,12 +31,13 @@ from jararaca.scheduler.decorators import (
     get_type_scheduled_actions,
 )
 from jararaca.scheduler.types import DelayedMessageData
+from jararaca.utils.rabbitmq_utils import RabbitmqUtils
 
 logger = logging.getLogger(__name__)
 
 
 def extract_scheduled_actions(
-    app: Microservice, container: Container
+    app: Microservice, container: Container, scheduler_names: set[str] | None = None
 ) -> list[ScheduledActionData]:
     scheduled_actions: list[ScheduledActionData] = []
     for controllers in app.controllers:
@@ -44,6 +45,17 @@ def extract_scheduled_actions(
         controller_instance: Any = container.get_by_type(controllers)
 
         controller_scheduled_actions = get_type_scheduled_actions(controller_instance)
+
+        # Filter scheduled actions by name if scheduler_names is provided
+        if scheduler_names is not None:
+            filtered_actions = []
+            for action in controller_scheduled_actions:
+                # Include actions that have a name and it's in the provided set
+                if action.spec.name and action.spec.name in scheduler_names:
+                    filtered_actions.append(action)
+                # Skip actions without names when filtering is active
+            controller_scheduled_actions = filtered_actions
+
         scheduled_actions.extend(controller_scheduled_actions)
 
     return scheduled_actions
@@ -145,7 +157,7 @@ class RabbitMQBrokerDispatcher(MessageBrokerDispatcher):
 
         logger.info(f"Dispatching message to {action_id} at {timestamp}")
         async with self.channel_pool.acquire() as channel:
-            exchange = await channel.get_exchange(self.exchange)
+            exchange = await RabbitmqUtils.get_main_exchange(channel, self.exchange)
 
             await exchange.publish(
                 aio_pika.Message(body=str(timestamp).encode()),
@@ -163,7 +175,7 @@ class RabbitMQBrokerDispatcher(MessageBrokerDispatcher):
         """
         async with self.channel_pool.acquire() as channel:
 
-            exchange = await channel.get_exchange(self.exchange)
+            exchange = await RabbitmqUtils.get_main_exchange(channel, self.exchange)
             await exchange.publish(
                 aio_pika.Message(
                     body=delayed_message.payload,
@@ -178,25 +190,15 @@ class RabbitMQBrokerDispatcher(MessageBrokerDispatcher):
         """
 
         async with self.channel_pool.acquire() as channel:
-
-            await channel.declare_exchange(
-                name=self.exchange,
-                type="topic",
-                durable=True,
-                auto_delete=False,
-            )
+            await RabbitmqUtils.get_main_exchange(channel, self.exchange)
 
             for sched_act_data in scheduled_actions:
-                queue = await channel.declare_queue(
-                    name=ScheduledAction.get_function_id(sched_act_data.callable),
-                    durable=True,
-                )
+                queue_name = ScheduledAction.get_function_id(sched_act_data.callable)
 
-                await queue.bind(
-                    exchange=self.exchange,
-                    routing_key=ScheduledAction.get_function_id(
-                        sched_act_data.callable
-                    ),
+                # Try to get existing queue
+                await RabbitmqUtils.get_scheduler_queue(
+                    channel=channel,
+                    queue_name=queue_name,
                 )
 
     async def dispose(self) -> None:
@@ -226,6 +228,7 @@ class SchedulerV2:
         interval: int,
         broker_url: str,
         backend_url: str,
+        scheduler_names: set[str] | None = None,
     ) -> None:
         self.app = app
 
@@ -237,6 +240,7 @@ class SchedulerV2:
         )
 
         self.interval = interval
+        self.scheduler_names = scheduler_names
         self.container = Container(self.app)
         self.uow_provider = UnitOfWorkContextProvider(app, self.container)
 
@@ -262,7 +266,9 @@ class SchedulerV2:
         """
         async with self.lifecycle():
 
-            scheduled_actions = extract_scheduled_actions(self.app, self.container)
+            scheduled_actions = extract_scheduled_actions(
+                self.app, self.container, self.scheduler_names
+            )
 
             await self.broker.initialize(scheduled_actions)