rabbitkit 0.19.0__tar.gz → 0.19.1__tar.gz

{rabbitkit-0.19.0/src/rabbitkit.egg-info → rabbitkit-0.19.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rabbitkit
-Version: 0.19.0
+Version: 0.19.1
 Summary: Production-grade RabbitMQ toolkit — sync/async, decorator routing, retry, compression, full configurability
 Author-email: Talaat Magdy <talaatmagdy75@gmail.com>
 License-Expression: MIT

{rabbitkit-0.19.0 → rabbitkit-0.19.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "rabbitkit"
-version = "0.19.0"
+version = "0.19.1"
 description = "Production-grade RabbitMQ toolkit — sync/async, decorator routing, retry, compression, full configurability"
 readme = "README.md"
 license = "MIT"

{rabbitkit-0.19.0 → rabbitkit-0.19.1}/src/rabbitkit/_version.py

@@ -1,3 +1,3 @@
 """rabbitkit version — single source of truth."""
 
-__version__ = "0.19.0"
+__version__ = "0.19.1"

{rabbitkit-0.19.0 → rabbitkit-0.19.1}/src/rabbitkit/async_/pool.py

@@ -13,6 +13,7 @@ import asyncio
 import contextlib
 import logging
 import random
+import time
 from collections.abc import Callable
 from contextlib import asynccontextmanager
 from typing import Any
@@ -22,6 +23,9 @@ from rabbitkit.core.config import ConnectionConfig, PoolConfig, SecurityConfig
 
 logger = logging.getLogger(__name__)
 
+#: Seconds between "Channel pool exhausted" warnings from one pool.
+_EXHAUSTED_WARNING_INTERVAL = 60.0
+
 
 class AsyncChannelPool:
     """Async channel pool.
@@ -42,11 +46,14 @@ class AsyncChannelPool:
         publisher_confirms: bool = True,
         on_channel_opened: Callable[[], None] | None = None,
         on_channel_rebuilt: Callable[[], None] | None = None,
+        on_return_raises: bool = False,
     ) -> None:
         self._connection = connection
         self._pool_size = pool_size
         self._acquire_timeout = acquire_timeout
         self._publisher_confirms = publisher_confirms
+        self._on_return_raises = on_return_raises
+        self._exhausted_warned_at = -_EXHAUSTED_WARNING_INTERVAL
         self._pool: asyncio.Queue[Any] = asyncio.Queue(maxsize=pool_size)
         self._lock = asyncio.Lock()
         self._created = 0
@@ -111,7 +118,7 @@ class AsyncChannelPool:
                 # turns the hang into a raise so ``acquire_publisher_channel``
                 # can rebuild the connection.
                 async with asyncio.timeout(self._acquire_timeout):
-                    channel = await self._connection.channel(publisher_confirms=self._publisher_confirms)
+                    channel = await self._connection.channel(**self._channel_kwargs())
             except BaseException:
                 # creation failed (or timed out) — give the reserved slot back.
                 async with self._lock:
@@ -128,7 +135,15 @@ class AsyncChannelPool:
         # Pool exhausted — wait with timeout to avoid deadlocks. R-timeout:
         # ``asyncio.timeout`` (3.11+) replaces ``asyncio.wait_for`` to avoid
         # the wrapper-task overhead.
-        logger.warning(
+        # Once a minute at WARNING, then DEBUG: under a burst every waiting
+        # publish lands here (2000 concurrent mandatory publishes logged 11874
+        # warnings), and a wait that runs out still raises TimeoutError below.
+        now = time.monotonic()
+        log = logger.debug
+        if now - self._exhausted_warned_at >= _EXHAUSTED_WARNING_INTERVAL:
+            self._exhausted_warned_at = now
+            log = logger.warning
+        log(
             "Channel pool exhausted (pool_size=%d, created=%d). "
             "Waiting up to %.1fs for a channel to be released. "
             "Consider increasing PoolConfig.channel_pool_size.",
@@ -152,6 +167,12 @@ class AsyncChannelPool:
             self._in_use.add(channel)
         return channel
 
+    def _channel_kwargs(self) -> dict[str, bool]:
+        kwargs = {"publisher_confirms": self._publisher_confirms}
+        if self._on_return_raises:
+            kwargs["on_return_raises"] = True
+        return kwargs
+
     async def release(self, channel: Any) -> None:
         """Release a channel back to the pool."""
         async with self._lock:
@@ -265,6 +286,9 @@ class AsyncConnectionPool:
         self._publisher_connection: Any | None = None
         self._consumer_connection: Any | None = None
         self._publisher_channel_pool: AsyncChannelPool | None = None
+        # mandatory=True publishes: confirmed channels that raise on Basic.Return,
+        # one publish per channel at a time — see acquire_mandatory_channel()
+        self._mandatory_channel_pool: AsyncChannelPool | None = None
         self._lock = asyncio.Lock()
         self._prewarmed = False
 
@@ -378,10 +402,12 @@ class AsyncConnectionPool:
             if self._publisher_connection is not stale:
                 return  # another worker already rebuilt it
             old_pool, self._publisher_channel_pool = self._publisher_channel_pool, None
+            old_mandatory, self._mandatory_channel_pool = self._mandatory_channel_pool, None
             old_conn, self._publisher_connection = self._publisher_connection, None
-            if old_pool is not None:
-                with contextlib.suppress(Exception):
-                    await asyncio.wait_for(old_pool.close_all(), timeout=timeout)
+            for stale_pool in (old_pool, old_mandatory):
+                if stale_pool is not None:
+                    with contextlib.suppress(Exception):
+                        await asyncio.wait_for(stale_pool.close_all(), timeout=timeout)
             if old_conn is not None and not old_conn.is_closed:
                 with contextlib.suppress(Exception):
                     await asyncio.wait_for(old_conn.close(), timeout=timeout)
@@ -398,12 +424,57 @@ class AsyncConnectionPool:
         if self._publisher_channel_pool is not None:
             await self._publisher_channel_pool.release(channel)
 
+    def _mandatory_pool(self) -> AsyncChannelPool:
+        if self._mandatory_channel_pool is None:
+            assert self._publisher_connection is not None
+            self._mandatory_channel_pool = AsyncChannelPool(
+                self._publisher_connection,
+                pool_size=self._pool_config.channel_pool_size,
+                acquire_timeout=self._pool_config.channel_acquire_timeout,
+                publisher_confirms=True,
+                on_return_raises=True,
+                on_channel_opened=self._on_channel_opened,
+                on_channel_rebuilt=self._on_channel_rebuilt,
+            )
+        return self._mandatory_channel_pool
+
+    async def acquire_mandatory_channel(self) -> Any:
+        """A channel for one ``mandatory=True`` publish: confirms on, and
+        ``on_return_raises=True`` so an unroutable return raises.
+
+        One publish per channel at a time, like the confirmed pool. A publish
+        the broker refuses (403, 404, 406: an unknown exchange, a forged
+        ``user_id``) closes its channel, and every operation still in flight
+        on that channel fails with it. One shared mandatory channel therefore
+        let one refused publish fail every concurrent innocent one. Closed
+        channels are discarded on release. Self-heals a wedged connection the
+        same way :meth:`acquire_publisher_channel` does.
+        """
+        if self._publisher_connection is None:
+            await self.get_publisher_connection()
+        try:
+            return await self._mandatory_pool().acquire()
+        except asyncio.CancelledError:
+            raise
+        except Exception as exc:
+            logger.warning("Mandatory channel acquire failed (%s); rebuilding connection", exc)
+            await self._rebuild_publisher_connection(stale=self._publisher_connection)
+            return await self._mandatory_pool().acquire()
+
+    async def release_mandatory_channel(self, channel: Any) -> None:
+        """Return a mandatory-publish channel to its pool (a closed one is discarded)."""
+        if self._mandatory_channel_pool is not None:
+            await self._mandatory_channel_pool.release(channel)
+
     async def close_all(self) -> None:
         """Close all channel pools and connections."""
         async with self._lock:
             if self._publisher_channel_pool is not None:
                 await self._publisher_channel_pool.close_all()
                 self._publisher_channel_pool = None
+            if self._mandatory_channel_pool is not None:
+                await self._mandatory_channel_pool.close_all()
+                self._mandatory_channel_pool = None
 
             for conn in [self._publisher_connection, self._consumer_connection]:
                 if conn is not None:

{rabbitkit-0.19.0 → rabbitkit-0.19.1}/src/rabbitkit/async_/transport.py

@@ -176,21 +176,14 @@ class AsyncTransportImpl:
         self._fast_publish_channel: Any | None = None
         self._fast_channel_lock: asyncio.Lock = asyncio.Lock()
 
-        # H1: dedicated, always-confirmed channel for mandatory=True publishes,
-        # independent of confirm_delivery. Detecting an unroutable Basic.Return
-        # reliably requires BOTH publisher confirms AND on_return_raises=True —
-        # neither the fast channel (no confirms at all) nor the regular pool
-        # (confirms follow confirm_delivery, which may be False) guarantee that.
-        self._mandatory_publish_channel: Any | None = None
-        # M3: in-flight mandatory publishes on the shared channel + a
-        # deferred-recycle flag set by a confirm timeout (closed at zero).
-        self._mandatory_in_flight = 0
-        self._mandatory_channel_recycle = False
+        # H1: mandatory=True publishes use the connection pool's mandatory
+        # channels (acquire_mandatory_channel): always confirmed and
+        # on_return_raises=True, independent of confirm_delivery, one publish
+        # per channel so a refused publish fails only itself.
         # m3: bindings recorded for re-apply after robust reconnect (they are
         # not in RobustChannel's restoration registry — see bind_queue).
         self._recorded_bindings: list[tuple[str, str, str, str, dict[str, Any] | None]] = []
         self._binding_restore_tasks: set[Any] = set()
-        self._mandatory_channel_lock: asyncio.Lock = asyncio.Lock()
 
         # Backpressure callbacks (FlowController registers here). Each is a
         # zero-arg callable; aio-pika's blocked/unblocked frames are adapted.
@@ -510,15 +503,7 @@ class AsyncTransportImpl:
                     pass
             self._fast_publish_channel = None
 
-            # Close the dedicated mandatory-publish channel (H1)
-            if self._mandatory_publish_channel is not None and not self._mandatory_publish_channel.is_closed:
-                try:
-                    await self._mandatory_publish_channel.close()
-                except Exception:  # pragma: no cover — best effort close, network errors only
-                    pass
-            self._mandatory_publish_channel = None
-
-            await self._conn_pool.close_all()
+            await self._conn_pool.close_all()  # includes the mandatory-publish channels
         except Exception as e:
             logger.warning("Error during disconnect: %s", e)
         finally:
@@ -632,36 +617,6 @@ class AsyncTransportImpl:
                 self._fire_channel_rebuilt()
             return self._fast_publish_channel
 
-    async def _get_mandatory_channel(self) -> Any:
-        """Return the dedicated always-confirmed channel for mandatory=True
-        publishes, (re)opening if needed.
-
-        H1: ``on_return_raises=True`` makes an unroutable ``Basic.Return``
-        raise ``aio_pika.exceptions.PublishError`` (caught by
-        :meth:`_publish_on_channel` and mapped to ``PublishStatus.RETURNED``)
-        instead of silently resolving the confirmation with the returned
-        message — indistinguishable from success otherwise. This channel is
-        used for every ``mandatory=True`` publish regardless of the broker's
-        ``confirm_delivery`` setting, since reliable return detection needs
-        confirms + on_return_raises unconditionally.
-        """
-        ch = self._mandatory_publish_channel
-        if ch is not None and not ch.is_closed:
-            return ch
-        async with self._mandatory_channel_lock:
-            ch = self._mandatory_publish_channel
-            if ch is not None and not ch.is_closed:  # pragma: no cover — concurrent path
-                return ch
-            conn = self._conn_pool._publisher_connection
-            if conn is None:
-                raise RuntimeError("Publisher connection is not available")
-            is_rebuild = ch is not None  # replacing a closed/recycled channel
-            self._mandatory_publish_channel = await conn.channel(publisher_confirms=True, on_return_raises=True)
-            self._fire_channel_opened()
-            if is_rebuild:
-                self._fire_channel_rebuilt()
-            return self._mandatory_publish_channel
-
     def _build_aio_message(self, envelope: MessageEnvelope) -> Any:
         """Build an aio_pika.Message from a MessageEnvelope.
 
@@ -697,8 +652,8 @@ class AsyncTransportImpl:
 
         H1: a ``mandatory=True`` publish that the broker cannot route raises
         ``aio_pika.exceptions.PublishError`` when the channel has
-        ``on_return_raises=True`` (only true for channels obtained via
-        :meth:`_get_mandatory_channel` — regular pool/fast channels default to
+        ``on_return_raises=True`` (only true for the connection pool's
+        mandatory channels — regular pool/fast channels default to
         ``on_return_raises=False`` and would otherwise resolve the confirmation
         with the returned message instead of raising, indistinguishable from
         success). Mapped to ``PublishStatus.RETURNED`` so callers keying off
@@ -817,10 +772,13 @@ class AsyncTransportImpl:
         "PRECONDITION_FAILED - fast reply consumer does not exist".
 
         H1: a ``mandatory=True`` envelope (that isn't a direct reply-to
-        request) always publishes via the dedicated always-confirmed channel
-        from :meth:`_get_mandatory_channel`, regardless of ``confirm_delivery``
-        — see that method's docstring for why neither the fast nor the regular
-        pool channel can reliably report an unroutable ``Basic.Return``.
+        request) always publishes on a mandatory channel of its own
+        (``AsyncConnectionPool.acquire_mandatory_channel``): confirmed and
+        ``on_return_raises=True`` regardless of ``confirm_delivery``, since
+        neither the fast nor the regular pool channel reliably reports an
+        unroutable ``Basic.Return``. One publish per channel: a publish the
+        broker refuses closes its channel and fails everything in flight on
+        it, so a shared channel let one refused publish fail its siblings.
 
         The confirmed (pooled-channel) path is handled by
         :meth:`_publish_confirmed`, OUTSIDE this method's own try/except
@@ -835,36 +793,7 @@ class AsyncTransportImpl:
                 if not channel.is_closed:
                     return await self._publish_on_channel(channel, envelope)
 
-            if envelope.mandatory:
-                channel = await self._get_mandatory_channel()
-                # M3 (architect review): this single persistent channel is
-                # shared by ALL concurrent mandatory publishes. Closing it the
-                # instant OUR publish times out cascades channel-closed errors
-                # into every sibling still awaiting its own confirm (spurious
-                # NACKED/ERROR → caller retries → duplicates). Ref-count
-                # in-flight publishes and recycle the channel only when the
-                # last one resolves; _get_mandatory_channel() lazily reopens.
-                self._mandatory_in_flight += 1
-                try:
-                    outcome = await self._publish_on_channel(channel, envelope)
-                finally:
-                    self._mandatory_in_flight -= 1
-                if outcome.status == PublishStatus.TIMEOUT:
-                    self._mandatory_channel_recycle = True
-                current = self._mandatory_publish_channel
-                if (
-                    self._mandatory_channel_recycle
-                    and self._mandatory_in_flight == 0
-                    and current is not None
-                    and channel is current
-                    and not current.is_closed
-                ):
-                    self._mandatory_channel_recycle = False
-                    with contextlib.suppress(Exception):
-                        await current.close()
-                return outcome
-
-            if not self._confirm_delivery:
+            if not envelope.mandatory and not self._confirm_delivery:
                 # Fast path: persistent channel, no confirm wait, no pool overhead
                 message = self._build_aio_message(envelope)
                 channel = await self._get_fast_channel()
@@ -917,17 +846,23 @@ class AsyncTransportImpl:
            which discards it since it's closed). No wait/recovery, or a
            second failure, returns ERROR — never raises.
         """
+        pool = self._conn_pool
+        acquire, release = (
+            (pool.acquire_mandatory_channel, pool.release_mandatory_channel)
+            if envelope.mandatory
+            else (pool.acquire_publisher_channel, pool.release_publisher_channel)
+        )
         last_exc: Exception | None = None
         for attempt in range(2):
             channel = None
             try:
-                channel = await self._conn_pool.acquire_publisher_channel()
+                channel = await acquire()
                 outcome = await self._publish_on_channel(channel, envelope)
             except Exception as e:
                 last_exc = e
                 if channel is not None:
                     with contextlib.suppress(Exception):
-                        await self._conn_pool.release_publisher_channel(channel)
+                        await release(channel)
                 if attempt == 0 and _is_connection_error(e) and await self._wait_for_recovery():
                     logger.warning(
                         "Publish hit a connection error, retrying once after recovery: exchange=%s routing_key=%s",
@@ -952,7 +887,7 @@ class AsyncTransportImpl:
                     with contextlib.suppress(Exception):
                         await channel.close()
                 with contextlib.suppress(Exception):
-                    await self._conn_pool.release_publisher_channel(channel)
+                    await release(channel)
                 return outcome
 
         return PublishOutcome(  # pragma: no cover — defensive; the loop always returns above

{rabbitkit-0.19.0 → rabbitkit-0.19.1/src/rabbitkit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rabbitkit
-Version: 0.19.0
+Version: 0.19.1
 Summary: Production-grade RabbitMQ toolkit — sync/async, decorator routing, retry, compression, full configurability
 Author-email: Talaat Magdy <talaatmagdy75@gmail.com>
 License-Expression: MIT