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

1from abc import abstractmethod 

2from typing import ( 

3 TYPE_CHECKING, 

4 Optional, 

5 Protocol, 

6 cast, 

7) 

8 

9import anyio 

10from typing_extensions import Unpack, override 

11 

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 

21 

22if TYPE_CHECKING: 

23 from types import TracebackType 

24 

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 

30 

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 

38 

39 from .options import MessageOptions 

40 

41 

42class LockState(Protocol): 

43 __slots__ = () 

44 

45 @property 

46 def lock(self) -> "anyio.Lock": ... 

47 

48 

49class LockUnset: 

50 __slots__ = () 

51 

52 @property 

53 def lock(self) -> "anyio.Lock": 

54 msg = "You should call `producer.connect()` method at first." 

55 raise IncorrectState(msg) 

56 

57 

58class RealLock: 

59 __slots__ = ("lock",) 

60 

61 def __init__(self) -> None: 

62 self.lock = anyio.Lock() 

63 

64 

65class AioPikaFastProducer(ProducerProto[RabbitPublishCommand]): 

66 __slots__ = () 

67 

68 def connect( 

69 self, 

70 serializer: Optional["SerializerProto"] = None, 

71 codec: Optional["CodecProto"] = None, 

72 ) -> None: ... 

73 

74 def disconnect(self) -> None: ... 

75 

76 @abstractmethod 

77 async def publish( 

78 self, 

79 cmd: "RabbitPublishCommand", 

80 ) -> Optional["aiormq.abc.ConfirmationFrameType"]: ... 

81 

82 @abstractmethod 

83 async def request(self, cmd: "RabbitPublishCommand") -> "IncomingMessage": ... 

84 

85 @override 

86 async def publish_batch(self, cmd: "RabbitPublishCommand") -> None: 

87 msg = "RabbitMQ doesn't support publishing in batches." 

88 raise FeatureNotSupportedException(msg) 

89 

90 

91class FakeAioPikaFastProducer(AioPikaFastProducer): 

92 __slots__ = () 

93 

94 def __bool__(self) -> bool: 

95 return False 

96 

97 def connect( 

98 self, 

99 serializer: Optional["SerializerProto"] = None, 

100 codec: Optional["CodecProto"] = None, 

101 ) -> None: 

102 raise NotImplementedError 

103 

104 def disconnect(self) -> None: 

105 raise NotImplementedError 

106 

107 @override 

108 async def publish( 

109 self, 

110 cmd: "RabbitPublishCommand", 

111 ) -> Optional["aiormq.abc.ConfirmationFrameType"]: 

112 raise NotImplementedError 

113 

114 @override 

115 async def request(self, cmd: "RabbitPublishCommand") -> "IncomingMessage": 

116 raise NotImplementedError 

117 

118 

119class AioPikaFastProducerImpl(AioPikaFastProducer): 

120 """A class for fast producing messages using aio-pika.""" 

121 

122 __slots__ = ( 

123 "__lock", 

124 "_decoder", 

125 "_parser", 

126 "codec", 

127 "declarer", 

128 "id_generator", 

129 "serializer", 

130 ) 

131 

132 _decoder: "AsyncCallable" 

133 _parser: "AsyncCallable" 

134 

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 

145 

146 self.__lock: LockState = LockUnset() 

147 self.serializer: SerializerProto | None = None 

148 self.codec: CodecProto = DefaultCodec() 

149 

150 default_parser = AioPikaParser() 

151 self._parser = ParserComposition(parser, default_parser.parse_message) 

152 self._decoder = ParserComposition(decoder, default_parser.decode_message) 

153 

154 def connect( 

155 self, 

156 serializer: Optional["SerializerProto"] = None, 

157 codec: Optional["CodecProto"] = None, 

158 ) -> None: 

159 """Lock initialization. 

160 

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() 

166 

167 def disconnect(self) -> None: 

168 self.__lock = LockUnset() 

169 

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 ) 

185 

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() 

204 

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 ) 

223 

224 exchange_obj = await self.declarer.declare_exchange( 

225 exchange=exchange, 

226 declare=False, 

227 ) 

228 

229 return await exchange_obj.publish( 

230 message=message, 

231 routing_key=routing_key, 

232 mandatory=mandatory, 

233 immediate=immediate, 

234 timeout=timeout, 

235 ) 

236 

237 

238class _RPCCallback: 

239 """A class provides an RPC lock.""" 

240 

241 __slots__ = ( 

242 "consumer_tag", 

243 "lock", 

244 "queue", 

245 "receive_response_stream", 

246 "send_response_stream", 

247 ) 

248 

249 def __init__(self, lock: "anyio.Lock", callback_queue: "RobustQueue") -> None: 

250 self.lock = lock 

251 self.queue = callback_queue 

252 

253 async def __aenter__(self) -> "MemoryObjectReceiveStream[IncomingMessage]": 

254 self.send_response_stream: MemoryObjectSendStream[AbstractIncomingMessage] 

255 self.receive_response_stream: MemoryObjectReceiveStream[AbstractIncomingMessage] 

256 

257 await self.lock.acquire() 

258 

259 ( 

260 self.send_response_stream, 

261 self.receive_response_stream, 

262 ) = anyio.create_memory_object_stream(max_buffer_size=1) 

263 

264 try: 

265 self.consumer_tag = await self.queue.consume( 

266 callback=self.send_response_stream.send, 

267 no_ack=True, 

268 ) 

269 

270 except BaseException: 

271 # `__aexit__` does not run when entering fails 

272 self._close_streams() 

273 self.lock.release() 

274 raise 

275 

276 return cast( 

277 "MemoryObjectReceiveStream[IncomingMessage]", 

278 self.receive_response_stream, 

279 ) 

280 

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() 

288 

289 try: 

290 await self.queue.cancel(self.consumer_tag) 

291 finally: 

292 self._close_streams() 

293 

294 def _close_streams(self) -> None: 

295 self.send_response_stream.close() 

296 self.receive_response_stream.close()