Coverage for faststream/rabbit/publisher/producer.py: 94%
84 statements
« prev ^ index » next coverage.py v7.17.3, created at 2026-11-17 21:20 +0000
« prev ^ index » next coverage.py v7.17.3, created at 2026-11-17 21:20 +0000
1from abc import abstractmethod
2from typing import (
3 TYPE_CHECKING,
4 Optional,
5 Protocol,
6 cast,
7)
9import anyio
10from typing_extensions import Unpack, override
12from faststream._internal.endpoint.utils import ParserComposition
13from faststream._internal.parser import DefaultCodec
14from faststream._internal.producer import ProducerProto
15from faststream._internal.types import IdGenerator
16from faststream.exceptions import FeatureNotSupportedException, IncorrectState
17from faststream.message import gen_cor_id
18from faststream.rabbit.parser import AioPikaParser
19from faststream.rabbit.response import RabbitPublishCommand
20from faststream.rabbit.schemas import RABBIT_REPLY, RabbitExchange
22if TYPE_CHECKING:
23 from types import TracebackType
25 import aiormq
26 from aio_pika import IncomingMessage, RobustQueue
27 from aio_pika.abc import AbstractIncomingMessage, TimeoutType
28 from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
29 from fast_depends.library.serializer import SerializerProto
31 from faststream._internal.parser import CodecProto
32 from faststream._internal.types import (
33 AsyncCallable,
34 CustomCallable,
35 )
36 from faststream.rabbit.helpers import RabbitDeclarer
37 from faststream.rabbit.types import AioPikaSendableMessage
39 from .options import MessageOptions
42class LockState(Protocol):
43 __slots__ = ()
45 @property
46 def lock(self) -> "anyio.Lock": ...
49class LockUnset:
50 __slots__ = ()
52 @property
53 def lock(self) -> "anyio.Lock":
54 msg = "You should call `producer.connect()` method at first."
55 raise IncorrectState(msg)
58class RealLock:
59 __slots__ = ("lock",)
61 def __init__(self) -> None:
62 self.lock = anyio.Lock()
65class AioPikaFastProducer(ProducerProto[RabbitPublishCommand]):
66 __slots__ = ()
68 def connect(
69 self,
70 serializer: Optional["SerializerProto"] = None,
71 codec: Optional["CodecProto"] = None,
72 ) -> None: ...
74 def disconnect(self) -> None: ...
76 @abstractmethod
77 async def publish(
78 self,
79 cmd: "RabbitPublishCommand",
80 ) -> Optional["aiormq.abc.ConfirmationFrameType"]: ...
82 @abstractmethod
83 async def request(self, cmd: "RabbitPublishCommand") -> "IncomingMessage": ...
85 @override
86 async def publish_batch(self, cmd: "RabbitPublishCommand") -> None:
87 msg = "RabbitMQ doesn't support publishing in batches."
88 raise FeatureNotSupportedException(msg)
91class FakeAioPikaFastProducer(AioPikaFastProducer):
92 __slots__ = ()
94 def __bool__(self) -> bool:
95 return False
97 def connect(
98 self,
99 serializer: Optional["SerializerProto"] = None,
100 codec: Optional["CodecProto"] = None,
101 ) -> None:
102 raise NotImplementedError
104 def disconnect(self) -> None:
105 raise NotImplementedError
107 @override
108 async def publish(
109 self,
110 cmd: "RabbitPublishCommand",
111 ) -> Optional["aiormq.abc.ConfirmationFrameType"]:
112 raise NotImplementedError
114 @override
115 async def request(self, cmd: "RabbitPublishCommand") -> "IncomingMessage":
116 raise NotImplementedError
119class AioPikaFastProducerImpl(AioPikaFastProducer):
120 """A class for fast producing messages using aio-pika."""
122 __slots__ = (
123 "__lock",
124 "_decoder",
125 "_parser",
126 "codec",
127 "declarer",
128 "id_generator",
129 "serializer",
130 )
132 _decoder: "AsyncCallable"
133 _parser: "AsyncCallable"
135 def __init__(
136 self,
137 *,
138 declarer: "RabbitDeclarer",
139 parser: Optional["CustomCallable"],
140 decoder: Optional["CustomCallable"],
141 id_generator: IdGenerator = gen_cor_id,
142 ) -> None:
143 self.declarer = declarer
144 self.id_generator = id_generator
146 self.__lock: LockState = LockUnset()
147 self.serializer: SerializerProto | None = None
148 self.codec: CodecProto = DefaultCodec()
150 default_parser = AioPikaParser()
151 self._parser = ParserComposition(parser, default_parser.parse_message)
152 self._decoder = ParserComposition(decoder, default_parser.decode_message)
154 def connect(
155 self,
156 serializer: Optional["SerializerProto"] = None,
157 codec: Optional["CodecProto"] = None,
158 ) -> None:
159 """Lock initialization.
161 Should be called in async context due `anyio.Lock` object can't be created outside event loop.
162 """
163 self.serializer = serializer
164 self.codec = codec or DefaultCodec()
165 self.__lock = RealLock()
167 def disconnect(self) -> None:
168 self.__lock = LockUnset()
170 @override
171 async def publish(
172 self,
173 cmd: "RabbitPublishCommand",
174 ) -> Optional["aiormq.abc.ConfirmationFrameType"]:
175 return await self._publish(
176 message=cmd.body,
177 exchange=cmd.exchange,
178 routing_key=cmd.destination,
179 reply_to=cmd.reply_to,
180 headers=cmd.headers,
181 correlation_id=cmd.correlation_id,
182 **cmd.publish_options,
183 **cmd.message_options,
184 )
186 @override
187 async def request(self, cmd: "RabbitPublishCommand") -> "IncomingMessage":
188 async with _RPCCallback(
189 self.__lock.lock,
190 await self.declarer.declare_queue(RABBIT_REPLY),
191 ) as response_queue:
192 with anyio.fail_after(cmd.timeout):
193 await self._publish(
194 message=cmd.body,
195 exchange=cmd.exchange,
196 routing_key=cmd.destination,
197 reply_to=RABBIT_REPLY.name,
198 headers=cmd.headers,
199 correlation_id=cmd.correlation_id,
200 **cmd.publish_options,
201 **cmd.message_options,
202 )
203 return await response_queue.receive()
205 async def _publish(
206 self,
207 message: "AioPikaSendableMessage",
208 *,
209 exchange: "RabbitExchange",
210 routing_key: str,
211 mandatory: bool = True,
212 immediate: bool = False,
213 timeout: "TimeoutType" = None,
214 **message_options: Unpack["MessageOptions"],
215 ) -> Optional["aiormq.abc.ConfirmationFrameType"]:
216 message = await AioPikaParser.encode_message(
217 message=message,
218 serializer=self.serializer,
219 codec=self.codec,
220 id_generator=self.id_generator,
221 **message_options,
222 )
224 exchange_obj = await self.declarer.declare_exchange(
225 exchange=exchange,
226 declare=False,
227 )
229 return await exchange_obj.publish(
230 message=message,
231 routing_key=routing_key,
232 mandatory=mandatory,
233 immediate=immediate,
234 timeout=timeout,
235 )
238class _RPCCallback:
239 """A class provides an RPC lock."""
241 __slots__ = (
242 "consumer_tag",
243 "lock",
244 "queue",
245 "receive_response_stream",
246 "send_response_stream",
247 )
249 def __init__(self, lock: "anyio.Lock", callback_queue: "RobustQueue") -> None:
250 self.lock = lock
251 self.queue = callback_queue
253 async def __aenter__(self) -> "MemoryObjectReceiveStream[IncomingMessage]":
254 self.send_response_stream: MemoryObjectSendStream[AbstractIncomingMessage]
255 self.receive_response_stream: MemoryObjectReceiveStream[AbstractIncomingMessage]
257 await self.lock.acquire()
259 (
260 self.send_response_stream,
261 self.receive_response_stream,
262 ) = anyio.create_memory_object_stream(max_buffer_size=1)
264 try:
265 self.consumer_tag = await self.queue.consume(
266 callback=self.send_response_stream.send,
267 no_ack=True,
268 )
270 except BaseException:
271 # `__aexit__` does not run when entering fails
272 self._close_streams()
273 self.lock.release()
274 raise
276 return cast(
277 "MemoryObjectReceiveStream[IncomingMessage]",
278 self.receive_response_stream,
279 )
281 async def __aexit__(
282 self,
283 exc_type: type[BaseException] | None = None,
284 exc_val: BaseException | None = None,
285 exc_tb: Optional["TracebackType"] = None,
286 ) -> None:
287 self.lock.release()
289 try:
290 await self.queue.cancel(self.consumer_tag)
291 finally:
292 self._close_streams()
294 def _close_streams(self) -> None:
295 self.send_response_stream.close()
296 self.receive_response_stream.close()