amqp-client-python 0.2.0.post1__tar.gz → 0.2.1.dev1__tar.gz

{amqp_client_python-0.2.0.post1 → amqp_client_python-0.2.1.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: amqp-client-python
-Version: 0.2.0.post1
+Version: 0.2.1.dev1
 Summary: Python AMQP Client Library
 Project-URL: Homepage, https://github.com/nutes-uepb/amqp-client-python
 Project-URL: Repository, https://github.com/nutes-uepb/amqp-client-python
@@ -17,7 +17,6 @@ Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Natural Language :: English
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11

{amqp_client_python-0.2.0.post1 → amqp_client_python-0.2.1.dev1}/amqp_client_python/__init__.py

@@ -2,3 +2,14 @@ from .rabbitmq import EventbusRabbitMQ, AsyncEventbusRabbitMQ, EventbusWrapperRa
 from .domain.models import Config, Options, SSLOptions
 from .domain.utils import ConnectionType
 from pika import DeliveryMode
+
+__all__ = [
+    "EventbusRabbitMQ",
+    "AsyncEventbusRabbitMQ",
+    "EventbusWrapperRabbitMQ",
+    "Config",
+    "Options",
+    "SSLOptions",
+    "ConnectionType",
+    "DeliveryMode",
+]

{amqp_client_python-0.2.0.post1 → amqp_client_python-0.2.1.dev1}/amqp_client_python/domain/models/__init__.py

@@ -1,3 +1,9 @@
 from .config import Config
 from .options import Options
 from .ssl_options import SSLOptions
+
+__all__ = [
+    "Config",
+    "Options",
+    "SSLOptions",
+]

{amqp_client_python-0.2.0.post1 → amqp_client_python-0.2.1.dev1}/amqp_client_python/domain/utils/__init__.py

@@ -1,2 +1,7 @@
 from .connection_type import ConnectionType
 from .types import HandlerType
+
+__all__ = [
+    "ConnectionType",
+    "HandlerType",
+]

{amqp_client_python-0.2.0.post1 → amqp_client_python-0.2.1.dev1}/amqp_client_python/event/__init__.py

@@ -4,3 +4,12 @@ from .async_provider_handler import AsyncProviderHandler
 from .async_subscriber_handler import AsyncSubscriberHandler
 from .provider_handler import ProviderHandler
 from .subscriber_handler import SubscriberHandler
+
+__all__ = [
+    "IntegrationEvent",
+    "IntegrationEventHandler",
+    "AsyncProviderHandler",
+    "AsyncSubscriberHandler",
+    "ProviderHandler",
+    "SubscriberHandler",
+]

{amqp_client_python-0.2.0.post1 → amqp_client_python-0.2.1.dev1}/amqp_client_python/exceptions/__init__.py

@@ -7,3 +7,15 @@ from .publish_timeout_exception import PublishTimeoutException
 from .auto_reconnect_exception import AutoReconnectException
 from .blocking_exception import BlockingException
 from .thread_unsafe_exception import ThreadUnsafeException
+
+__all__ = [
+    "EventBusException",
+    "NackException",
+    "RpcProviderException",
+    "TimeoutException",
+    "ResponseTimeoutException",
+    "PublishTimeoutException",
+    "AutoReconnectException",
+    "BlockingException",
+    "ThreadUnsafeException",
+]

{amqp_client_python-0.2.0.post1 → amqp_client_python-0.2.1.dev1}/amqp_client_python/rabbitmq/__init__.py

@@ -1,6 +1,6 @@
 from .async_eventbus_rabbitmq import AsyncEventbusRabbitMQ
 from .async_connection_factory import AsyncConnectionFactoryRabbitMQ
-from .async_connection import AsyncConnection, ConnectionType
+from .async_connection import AsyncConnection
 from .async_channel_factory import AsyncChannelFactoryRabbitMQ
 from .async_channel import AsyncChannel
 from .eventbus_rabbitmq import EventbusRabbitMQ
@@ -9,3 +9,17 @@ from .connection_rabbitmq import ConnectionRabbitMQ
 from .channel_factory_rabbitmq import ChannelFactoryRabbitMQ
 from .channel_rabbitmq import ChannelRabbitMQ
 from .eventbus_wrapper_rabbitmq import EventbusWrapperRabbitMQ
+
+__all__ = [
+    "AsyncEventbusRabbitMQ",
+    "AsyncConnectionFactoryRabbitMQ",
+    "AsyncConnection",
+    "AsyncChannelFactoryRabbitMQ",
+    "AsyncChannel",
+    "EventbusRabbitMQ",
+    "ConnectionFactoryRabbitMQ",
+    "ConnectionRabbitMQ",
+    "ChannelFactoryRabbitMQ",
+    "ChannelRabbitMQ",
+    "EventbusWrapperRabbitMQ",
+]

{amqp_client_python-0.2.0.post1 → amqp_client_python-0.2.1.dev1}/amqp_client_python/rabbitmq/async_channel.py

@@ -1,3 +1,4 @@
+from collections import deque
 from typing import MutableMapping, Mapping, Optional, Union, Dict, List
 from .async_channel_factory import AsyncChannelFactoryRabbitMQ
 from amqp_client_python.exceptions import (
@@ -63,9 +64,9 @@ class AsyncChannel:
     def is_open(self) -> Optional[bool]:
         return self._channel and self._channel.is_open
 
-    def open(self, connection: AsyncioConnection, callbacks=[]):
+    def open(self, connection: AsyncioConnection, callbacks=None):
         if not self.is_open:
-            self.callbacks = callbacks
+            self.callbacks = callbacks if callbacks is not None else deque()
             self._connection = connection
             self.ioloop = connection.ioloop
             self._channel = self.channel_factory.create_channel(
@@ -87,10 +88,15 @@ class AsyncChannel:
         self.ioloop.create_task(self.process_callbacks())  # type: ignore
 
     async def process_callbacks(self):
-        for callback, future in self.callbacks:
-            result = await callback()
-            if not future.done():
-                future.set_result(result)
+        while self.callbacks:
+            callback, future = self.callbacks.popleft()
+            try:
+                result = await callback()
+                if not future.done():
+                    future.set_result(result)
+            except Exception as exc:
+                if not future.done():
+                    future.set_exception(exc)
 
     def add_on_channel_close_callback(self):
         """This method tells pika to call the on_channel_closed method if
@@ -302,7 +308,7 @@ class AsyncChannel:
         if self.rpc_publisher_started:
             return True
         if self.rpc_publisher_starting:
-            return await self.rpc_consumer_future
+            return await self.rpc_publisher_future
         self.rpc_publisher_starting = True
         self.rpc_publisher_future = self.ioloop.create_future()
 

{amqp_client_python-0.2.0.post1 → amqp_client_python-0.2.1.dev1}/amqp_client_python/rabbitmq/async_connection.py

@@ -1,4 +1,6 @@
-from typing import Optional, Callable, Awaitable, Tuple, Dict, List, Any
+from collections import deque
+from typing import Optional, Callable, Awaitable, Tuple, Dict, Any
+
 from .async_connection_factory import AsyncConnectionFactoryRabbitMQ, AsyncioConnection
 from .async_channel import AsyncChannel
 from ..exceptions import AutoReconnectException
@@ -60,7 +62,7 @@ class AsyncConnection:
         self.openning = False
         self.reconnecting = False
         self.reconnect_delay = 1
-        self.callbacks: List[Tuple[Callable, Future]] = []
+        self.callbacks: deque[Tuple[Callable, Future]] = deque()
         self.type = connection_type
         self.backup: Dict[str, Dict[str, Any]] = {
             "exchange": {},
@@ -87,6 +89,7 @@ class AsyncConnection:
             if not self.ioloop:
                 self.ioloop = get_event_loop()
             self.openning = True
+            self._closing = False
             self._connection = self.connection_factory.create_connection(
                 uri=uri,
                 on_connection_open=self.on_connection_open,
@@ -129,6 +132,33 @@ class AsyncConnection:
             signal=self.signal,
         )
         self._channel.publisher_confirms = self.publisher_confirms
+
+        if self.reconnecting or self.backup["subscribe"] or self.backup["rpc_subscribe"]:
+            async def recorvery():
+                for routing_key in list(self.backup["subscribe"].keys()):
+                    params = self.backup["subscribe"][routing_key]
+                    await self.subscribe(
+                        params["queue_name"],
+                        params["exchange_name"],
+                        routing_key,
+                        params["callback"],
+                        params["timeout"],
+                    )
+                for routing_key in list(self.backup["rpc_subscribe"].keys()):
+                    params = self.backup["rpc_subscribe"][routing_key]
+                    await self.rpc_subscribe(
+                        params["queue_name"],
+                        params["exchange_name"],
+                        routing_key,
+                        params["callback"],
+                        params["timeout"],
+                    )
+
+            future: Future = Future(loop=self.ioloop)
+            self.callbacks.append((recorvery, future))
+            self.reconnect_delay = 1
+            self.reconnecting = False
+
         self._channel.open(self._connection, self.callbacks)
 
     def on_connection_open_error(self, _unused_connection, err):
@@ -193,30 +223,30 @@ class AsyncConnection:
             )
             self.reconnect_delay += 1
         else:
-
-            async def recorvery():
-                for routing_key in self.backup["subscribe"]:
-                    params = self.backup["subscribe"][routing_key]
-                    await self.subscribe(
-                        params["queue_name"],
-                        params["exchange_name"],
-                        routing_key,
-                        params["callback"],
-                        params["timeout"],
-                    )
-                for routing_key in self.backup["rpc_subscribe"]:
-                    params = self.backup["rpc_subscribe"][routing_key]
-                    await self.rpc_subscribe(
-                        params["queue_name"],
-                        params["exchange_name"],
-                        routing_key,
-                        params["callback"],
-                        params["timeout"],
-                    )
-
-            self.ioloop.create_task(self.add_callback(recorvery))  # type: ignore
-            self.reconnect_delay = 1
-            self.reconnecting = False
+            if self.reconnecting:
+                async def recorvery():
+                    for routing_key in list(self.backup["subscribe"].keys()):
+                        params = self.backup["subscribe"][routing_key]
+                        await self.subscribe(
+                            params["queue_name"],
+                            params["exchange_name"],
+                            routing_key,
+                            params["callback"],
+                            params["timeout"],
+                        )
+                    for routing_key in list(self.backup["rpc_subscribe"].keys()):
+                        params = self.backup["rpc_subscribe"][routing_key]
+                        await self.rpc_subscribe(
+                            params["queue_name"],
+                            params["exchange_name"],
+                            routing_key,
+                            params["callback"],
+                            params["timeout"],
+                        )
+
+                self.reconnect_delay = 1
+                self.reconnecting = False
+                self.ioloop.create_task(self.add_callback(recorvery))  # type: ignore
 
     @property
     def is_open(self) -> Optional[bool]:
@@ -464,7 +494,7 @@ class AsyncConnection:
             >>> result = await connection.add_callback(my_operation, 10.0)
         """
         try:
-            if self.is_open and self._channel.is_open:
+            if self.is_open and self._channel and self._channel.is_open:
                 return await callback()
             else:
                 future: Future = Future(loop=self.ioloop)

{amqp_client_python-0.2.0.post1 → amqp_client_python-0.2.1.dev1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "amqp-client-python"
-version = "0.2.0.post1"
+version = "0.2.1.dev.1"
 description = "Python AMQP Client Library"
 readme = "README.md"
 requires-python = ">=3.9,<4.0"
@@ -19,7 +19,6 @@ classifiers = [
     "Operating System :: OS Independent",
     "License :: OSI Approved :: Apache Software License",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.8",
     "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",

amqp_client_python-0.2.1.dev1/tests/integration/async_eventbus/auto_recovery_test.py

@@ -0,0 +1,167 @@
+import pytest
+from amqp_client_python import AsyncEventbusRabbitMQ
+from asyncio import Future, BaseEventLoop, sleep
+from uuid import uuid4
+
+
+@pytest.mark.asyncio_cooperative
+async def test_rpc_provider_auto_recovery_on_connection_drop(async_eventbus: AsyncEventbusRabbitMQ, loop: BaseEventLoop):
+    """
+    Test that an RPC provider automatically recovers its consumers when the RabbitMQ connection is forcibly closed,
+    allowing subsequent RPC calls to succeed without manual restarts.
+    """
+    expected_result = "response_after_recovery"
+    future_count = 0
+
+    async def handle(body):
+        nonlocal future_count
+        future_count += 1
+        return expected_result
+
+    routing_key = f"rk_recovery_{str(uuid4())[:8]}"
+    
+    # 1. Register RPC provider
+    await async_eventbus.provide_resource(routing_key, handle, timeout=10)
+    await sleep(1)
+
+    # 2. First RPC request before disconnect
+    res1 = await async_eventbus.rpc_client(
+        async_eventbus.config.options.rpc_exchange_name,
+        routing_key,
+        ["request_1"],
+        timeout=10,
+    )
+    assert res1 == expected_result.encode()
+    assert future_count == 1
+
+    # 3. Simulate sudden RabbitMQ connection drop by closing the underlying connection
+    rpc_conn = async_eventbus._rpc_server_connection
+    if rpc_conn._connection:
+        rpc_conn._connection.close()
+
+    # 4. Wait for auto-reconnection and consumer re-registration
+    await sleep(3)
+
+    # 5. Second RPC request after auto-recovery
+    res2 = await async_eventbus.rpc_client(
+        async_eventbus.config.options.rpc_exchange_name,
+        routing_key,
+        ["request_2"],
+        timeout=10,
+    )
+    assert res2 == expected_result.encode()
+    assert future_count == 2
+
+
+@pytest.mark.asyncio_cooperative
+async def test_subscribe_auto_recovery_on_connection_drop(async_eventbus: AsyncEventbusRabbitMQ, loop: BaseEventLoop):
+    """
+    Test that a pub/sub subscriber automatically recovers its consumers when the RabbitMQ connection is forcibly closed.
+    """
+    received_messages = []
+
+    async def handle(body):
+        received_messages.append(body)
+
+    exchange_name = "ex_subscribe_recovery"
+    routing_key = f"rk_sub_{str(uuid4())[:8]}"
+
+    # 1. Register subscriber
+    await async_eventbus.subscribe(exchange_name, routing_key, handle, timeout=10)
+    await sleep(1)
+
+    # 2. Publish message 1
+    await async_eventbus.publish(exchange_name, routing_key, ["msg_1"])
+    await sleep(1)
+    assert len(received_messages) == 1
+
+    # 3. Force connection drop on sub_connection
+    sub_conn = async_eventbus._sub_connection
+    if sub_conn._connection:
+        sub_conn._connection.close()
+
+    # 4. Wait for auto-reconnection
+    await sleep(3)
+
+    # 5. Publish message 2 after auto-recovery
+    await async_eventbus.publish(exchange_name, routing_key, ["msg_2"])
+    await sleep(1)
+    assert len(received_messages) == 2
+    assert received_messages == [["msg_1"], ["msg_2"]]
+
+
+@pytest.mark.asyncio_cooperative
+async def test_multiple_consecutive_drops_auto_recovery(async_eventbus: AsyncEventbusRabbitMQ, loop: BaseEventLoop):
+    """
+    Edge Case Test: Verify auto-recovery works reliably over multiple consecutive connection drops (network flapping).
+    """
+    call_count = 0
+
+    async def handle(body):
+        nonlocal call_count
+        call_count += 1
+        return f"resp_{call_count}"
+
+    routing_key = f"rk_flapping_{str(uuid4())[:8]}"
+    await async_eventbus.provide_resource(routing_key, handle, timeout=10)
+    await sleep(1)
+
+    # Perform 3 consecutive drops and verify recovery after each
+    for i in range(1, 4):
+        # Force close connection
+        rpc_conn = async_eventbus._rpc_server_connection
+        if rpc_conn._connection:
+            rpc_conn._connection.close()
+
+        # Wait for auto-recovery
+        await sleep(3)
+
+        # Make RPC call after recovery
+        res = await async_eventbus.rpc_client(
+            async_eventbus.config.options.rpc_exchange_name,
+            routing_key,
+            [f"req_{i}"],
+            timeout=10,
+        )
+        assert res == f"resp_{i}".encode()
+
+    assert call_count == 3
+
+
+@pytest.mark.asyncio_cooperative
+async def test_multiple_handlers_simultaneous_recovery(async_eventbus: AsyncEventbusRabbitMQ, loop: BaseEventLoop):
+    """
+    Edge Case Test: Verify that multiple RPC handlers registered on the same connection all recover concurrently without channel collision.
+    """
+    keys = [f"rk_multi_{i}_{str(uuid4())[:6]}" for i in range(3)]
+    counts = {k: 0 for k in keys}
+
+    def make_handler(k):
+        async def handler(body):
+            counts[k] += 1
+            return f"ok_{k}"
+        return handler
+
+    # Register 3 handlers concurrently
+    for k in keys:
+        await async_eventbus.provide_resource(k, make_handler(k), timeout=10)
+    await sleep(1)
+
+    # Force connection drop
+    rpc_conn = async_eventbus._rpc_server_connection
+    if rpc_conn._connection:
+        rpc_conn._connection.close()
+
+    # Wait for auto-recovery
+    await sleep(3)
+
+    # Verify all 3 handlers recovered and respond correctly
+    for k in keys:
+        res = await async_eventbus.rpc_client(
+            async_eventbus.config.options.rpc_exchange_name,
+            k,
+            ["payload"],
+            timeout=10,
+        )
+        assert res == f"ok_{k}".encode()
+        assert counts[k] == 1

amqp_client_python-0.2.1.dev1/tests/unit/eventbus/test_auto_recovery.py

@@ -0,0 +1,64 @@
+import pytest
+from collections import deque
+from unittest.mock import MagicMock, AsyncMock, patch
+from asyncio import get_event_loop
+from amqp_client_python.rabbitmq.async_channel import AsyncChannel
+from amqp_client_python.rabbitmq.async_connection import AsyncConnection
+
+
+@pytest.mark.asyncio_cooperative
+async def test_start_rpc_publisher_concurrency_fix():
+    """Verify start_rpc_publisher awaits rpc_publisher_future when starting, avoiding rpc_consumer_future bug."""
+    channel = AsyncChannel()
+    channel.ioloop = get_event_loop()
+    channel.rpc_publisher_starting = True
+    channel.rpc_publisher_future = channel.ioloop.create_future()
+    channel.rpc_publisher_future.set_result(True)
+
+    result = await channel.start_rpc_publisher()
+    assert result is True
+
+
+@pytest.mark.asyncio_cooperative
+async def test_process_callbacks_clears_list():
+    """Verify process_callbacks clears the callbacks list so tasks are not executed twice."""
+    channel = AsyncChannel()
+    called = False
+
+    async def dummy_callback():
+        nonlocal called
+        called = True
+        return True
+
+    loop = get_event_loop()
+    future = loop.create_future()
+    channel.callbacks = deque([(dummy_callback, future)])
+
+    await channel.process_callbacks()
+    assert called is True
+    assert len(channel.callbacks) == 0
+    assert future.done()
+    assert future.result() is True
+
+
+@pytest.mark.asyncio_cooperative
+async def test_auto_recovery_on_connection_open():
+    """Verify on_connection_open enqueues recovery callback when reconnecting is True."""
+    loop = get_event_loop()
+    conn = AsyncConnection(ioloop=loop)
+    conn.reconnecting = True
+    conn.backup["rpc_subscribe"]["test_key"] = {
+        "queue_name": "q_test",
+        "exchange_name": "ex_test",
+        "callback": AsyncMock(),
+        "timeout": 10,
+    }
+
+    mock_connection = MagicMock()
+    conn.connection_factory.create_connection = MagicMock(return_value=mock_connection)
+    
+    with patch.object(AsyncChannel, "open") as mock_channel_open:
+        conn.on_connection_open(mock_connection)
+        assert conn.reconnecting is False
+        assert len(conn.callbacks) == 1
+        mock_channel_open.assert_called_once()