jararaca 0.3.11a8__py3-none-any.whl → 0.3.11a10__py3-none-any.whl

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(

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/scheduler_v2.py

@@ -157,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()),
@@ -175,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,
@@ -190,26 +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 RabbitmqUtils.declare_scheduler_queue(
-                    channel=channel,
-                    queue_name=ScheduledAction.get_function_id(sched_act_data.callable),
-                    passive=False,
-                )
+                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:

jararaca/utils/rabbitmq_utils.py

@@ -1,4 +1,9 @@
+import logging
+
 from aio_pika.abc import AbstractChannel, AbstractExchange, AbstractQueue
+from aio_pika.exceptions import AMQPError, ChannelClosed, ChannelNotFoundEntity
+
+logger = logging.getLogger(__name__)
 
 
 class RabbitmqUtils:
@@ -6,6 +11,39 @@ class RabbitmqUtils:
     DEAD_LETTER_EXCHANGE = "dlx"
     DEAD_LETTER_QUEUE = "dlq"
 
+    # Note: get_worker_v1_queue method is already defined above
+
+    DEAD_LETTER_EXCHANGE = "dlx"
+    DEAD_LETTER_QUEUE = "dlq"
+
+    @classmethod
+    async def get_dl_exchange(cls, channel: AbstractChannel) -> AbstractExchange:
+        """
+        Get the Dead Letter Exchange (DLX) for the given channel.
+        """
+        try:
+            return await channel.get_exchange(
+                cls.DEAD_LETTER_EXCHANGE,
+            )
+        except ChannelNotFoundEntity as e:
+            logger.error(
+                f"Dead Letter Exchange '{cls.DEAD_LETTER_EXCHANGE}' does not exist. "
+                f"Please use the declare command to create it first. Error: {e}"
+            )
+            raise
+        except ChannelClosed as e:
+            logger.error(
+                f"Channel closed while getting Dead Letter Exchange '{cls.DEAD_LETTER_EXCHANGE}'. "
+                f"Error: {e}"
+            )
+            raise
+        except AMQPError as e:
+            logger.error(
+                f"AMQP error while getting Dead Letter Exchange '{cls.DEAD_LETTER_EXCHANGE}'. "
+                f"Error: {e}"
+            )
+            raise
+
     @classmethod
     async def declare_dl_exchange(
         cls, channel: AbstractChannel, passive: bool
@@ -22,6 +60,34 @@ class RabbitmqUtils:
             auto_delete=False,
         )
 
+    @classmethod
+    async def get_dl_queue(cls, channel: AbstractChannel) -> AbstractQueue:
+        """
+        Get the Dead Letter Queue (DLQ) for the given channel.
+        """
+        try:
+            return await channel.get_queue(
+                cls.DEAD_LETTER_QUEUE,
+            )
+        except ChannelNotFoundEntity as e:
+            logger.error(
+                f"Dead Letter Queue '{cls.DEAD_LETTER_QUEUE}' does not exist. "
+                f"Please use the declare command to create it first. Error: {e}"
+            )
+            raise
+        except ChannelClosed as e:
+            logger.error(
+                f"Channel closed while getting Dead Letter Queue '{cls.DEAD_LETTER_QUEUE}'. "
+                f"Error: {e}"
+            )
+            raise
+        except AMQPError as e:
+            logger.error(
+                f"AMQP error while getting Dead Letter Queue '{cls.DEAD_LETTER_QUEUE}'. "
+                f"Error: {e}"
+            )
+            raise
+
     @classmethod
     async def declare_dl_queue(
         cls, channel: AbstractChannel, passive: bool
@@ -40,6 +106,36 @@ class RabbitmqUtils:
             },
         )
 
+    @classmethod
+    async def get_dl_kit(
+        cls,
+        channel: AbstractChannel,
+    ) -> tuple[AbstractExchange, AbstractQueue]:
+        """
+        Get the Dead Letter Exchange and Queue (DLX and DLQ) for the given channel.
+        """
+        try:
+            dlx = await cls.get_dl_exchange(channel)
+            dlq = await cls.get_dl_queue(channel)
+            return dlx, dlq
+        except ChannelNotFoundEntity as e:
+            logger.error(
+                f"Dead Letter infrastructure does not exist completely. "
+                f"Please use the declare command to create it first. Error: {e}"
+            )
+            raise
+        except ChannelClosed as e:
+            logger.error(
+                f"Channel closed while getting Dead Letter infrastructure. "
+                f"Error: {e}"
+            )
+            raise
+        except AMQPError as e:
+            logger.error(
+                f"AMQP error while getting Dead Letter infrastructure. " f"Error: {e}"
+            )
+            raise
+
     @classmethod
     async def declare_dl_kit(
         cls,
@@ -54,6 +150,33 @@ class RabbitmqUtils:
         await dlq.bind(dlx, routing_key=cls.DEAD_LETTER_EXCHANGE)
         return dlx, dlq
 
+    @classmethod
+    async def get_main_exchange(
+        cls, channel: AbstractChannel, exchange_name: str
+    ) -> AbstractExchange:
+        """
+        Get the main exchange for the given channel.
+        """
+        try:
+            return await channel.get_exchange(exchange_name)
+        except ChannelNotFoundEntity as e:
+            logger.error(
+                f"Exchange '{exchange_name}' does not exist. "
+                f"Please use the declare command to create it first. Error: {e}"
+            )
+            raise
+        except ChannelClosed as e:
+            logger.error(
+                f"Channel closed while getting exchange '{exchange_name}'. "
+                f"Error: {e}"
+            )
+            raise
+        except AMQPError as e:
+            logger.error(
+                f"AMQP error while getting exchange '{exchange_name}'. " f"Error: {e}"
+            )
+            raise
+
     @classmethod
     async def declare_main_exchange(
         cls, channel: AbstractChannel, exchange_name: str, passive: bool
@@ -70,6 +193,34 @@ class RabbitmqUtils:
             auto_delete=False,
         )
 
+    @classmethod
+    async def get_queue(
+        cls,
+        channel: AbstractChannel,
+        queue_name: str,
+    ) -> AbstractQueue:
+        """
+        Get a queue with the given name.
+        """
+        try:
+            return await channel.get_queue(queue_name)
+        except ChannelNotFoundEntity as e:
+            logger.error(
+                f"Queue '{queue_name}' does not exist. "
+                f"Please use the declare command to create it first. Error: {e}"
+            )
+            raise
+        except ChannelClosed as e:
+            logger.error(
+                f"Channel closed while getting queue '{queue_name}'. " f"Error: {e}"
+            )
+            raise
+        except AMQPError as e:
+            logger.error(
+                f"AMQP error while getting queue '{queue_name}'. " f"Error: {e}"
+            )
+            raise
+
     @classmethod
     async def declare_queue(
         cls,
@@ -91,6 +242,35 @@ class RabbitmqUtils:
             },
         )
 
+    @classmethod
+    async def get_worker_v1_queue(
+        cls,
+        channel: AbstractChannel,
+        queue_name: str,
+    ) -> AbstractQueue:
+        """
+        Get a worker v1 queue.
+        """
+        try:
+            return await channel.get_queue(queue_name)
+        except ChannelNotFoundEntity as e:
+            logger.error(
+                f"Worker queue '{queue_name}' does not exist. "
+                f"Please use the declare command to create it first. Error: {e}"
+            )
+            raise
+        except ChannelClosed as e:
+            logger.error(
+                f"Channel closed while getting worker queue '{queue_name}'. "
+                f"Error: {e}"
+            )
+            raise
+        except AMQPError as e:
+            logger.error(
+                f"AMQP error while getting worker queue '{queue_name}'. " f"Error: {e}"
+            )
+            raise
+
     @classmethod
     async def declare_worker_v1_queue(
         cls,
@@ -113,6 +293,36 @@ class RabbitmqUtils:
             durable=True,
         )
 
+    @classmethod
+    async def get_scheduler_queue(
+        cls,
+        channel: AbstractChannel,
+        queue_name: str,
+    ) -> AbstractQueue:
+        """
+        Get a scheduler queue.
+        """
+        try:
+            return await channel.get_queue(queue_name)
+        except ChannelNotFoundEntity as e:
+            logger.error(
+                f"Scheduler queue '{queue_name}' does not exist. "
+                f"Please use the declare command to create it first. Error: {e}"
+            )
+            raise
+        except ChannelClosed as e:
+            logger.error(
+                f"Channel closed while getting scheduler queue '{queue_name}'. "
+                f"Error: {e}"
+            )
+            raise
+        except AMQPError as e:
+            logger.error(
+                f"AMQP error while getting scheduler queue '{queue_name}'. "
+                f"Error: {e}"
+            )
+            raise
+
     @classmethod
     async def declare_scheduler_queue(
         cls,
@@ -130,41 +340,53 @@ class RabbitmqUtils:
         )
 
     @classmethod
-    async def delete_queue(
+    async def delete_exchange(
         cls,
         channel: AbstractChannel,
-        queue_name: str,
+        exchange_name: str,
         if_unused: bool = False,
-        if_empty: bool = False,
     ) -> None:
         """
-        Delete a queue.
+        Delete an exchange.
         """
         try:
-            await channel.queue_delete(
-                queue_name=queue_name,
+            await channel.exchange_delete(
+                exchange_name=exchange_name,
                 if_unused=if_unused,
-                if_empty=if_empty,
             )
-        except Exception:
-            # Queue might not exist, which is fine
-            pass
+        except ChannelNotFoundEntity:
+            # Exchange might not exist, which is fine
+            logger.info(
+                f"Exchange '{exchange_name}' does not exist, nothing to delete."
+            )
+        except ChannelClosed as e:
+            logger.warning(
+                f"Channel closed while deleting exchange '{exchange_name}': {e}"
+            )
+        except AMQPError as e:
+            logger.warning(f"AMQP error while deleting exchange '{exchange_name}': {e}")
 
     @classmethod
-    async def delete_exchange(
+    async def delete_queue(
         cls,
         channel: AbstractChannel,
-        exchange_name: str,
+        queue_name: str,
         if_unused: bool = False,
+        if_empty: bool = False,
     ) -> None:
         """
-        Delete an exchange.
+        Delete a queue.
         """
         try:
-            await channel.exchange_delete(
-                exchange_name=exchange_name,
+            await channel.queue_delete(
+                queue_name=queue_name,
                 if_unused=if_unused,
+                if_empty=if_empty,
             )
-        except Exception:
-            # Exchange might not exist, which is fine
-            pass
+        except ChannelNotFoundEntity:
+            # Queue might not exist, which is fine
+            logger.info(f"Queue '{queue_name}' does not exist, nothing to delete.")
+        except ChannelClosed as e:
+            logger.warning(f"Channel closed while deleting queue '{queue_name}': {e}")
+        except AMQPError as e:
+            logger.warning(f"AMQP error while deleting queue '{queue_name}': {e}")

{jararaca-0.3.11a8.dist-info → jararaca-0.3.11a10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: jararaca
-Version: 0.3.11a8
+Version: 0.3.11a10
 Summary: A simple and fast API framework for Python
 Author: Lucas S
 Author-email: me@luscasleo.dev