Coverage for faststream/mqtt/publisher/producer.py: 83%

78 statements  

« prev     ^ index     » next       coverage.py v7.17.3, created at 2026-11-17 21:20 +0000

1import asyncio 

2from typing import TYPE_CHECKING, Any, Optional 

3 

4import zmqtt 

5from typing_extensions import override 

6from zmqtt import PublishProperties 

7 

8from faststream._internal.endpoint.utils import ParserComposition 

9from faststream._internal.parser import DefaultCodec 

10from faststream._internal.producer import ProducerProto 

11from faststream._internal.types import IdGenerator 

12from faststream.exceptions import FeatureNotSupportedException, IncorrectState 

13from faststream.message import gen_cor_id 

14from faststream.mqtt.parser import MQTTParserV5, MQTTParserV311 

15from faststream.mqtt.response import MQTTPublishCommand 

16 

17if TYPE_CHECKING: 

18 from fast_depends.library.serializer import SerializerProto 

19 

20 from faststream._internal.parser import CodecProto 

21 from faststream._internal.types import AsyncCallable, CustomCallable 

22 

23 

24class ZmqttBaseProducer(ProducerProto[MQTTPublishCommand]): 

25 __slots__ = ( 

26 "_client", 

27 "_decoder", 

28 "_parser", 

29 "codec", 

30 "id_generator", 

31 "serializer", 

32 ) 

33 

34 _parser: "AsyncCallable" 

35 _decoder: "AsyncCallable" 

36 

37 def __init__( 

38 self, 

39 default_parser: Any, 

40 parser: Optional["CustomCallable"], 

41 decoder: Optional["CustomCallable"], 

42 id_generator: IdGenerator = gen_cor_id, 

43 ) -> None: 

44 self.serializer: SerializerProto | None = None 

45 self._client: zmqtt.MQTTClient | None = None 

46 self.codec: CodecProto = DefaultCodec() 

47 self.id_generator = id_generator 

48 

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

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

51 

52 def connect( 

53 self, 

54 client: "zmqtt.MQTTClient", 

55 serializer: Optional["SerializerProto"], 

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

57 ) -> None: 

58 self._client = client 

59 self.serializer = serializer 

60 self.codec = codec or DefaultCodec() 

61 

62 def disconnect(self) -> None: 

63 self._client = None 

64 self.serializer = None 

65 

66 @property 

67 def _connected_client(self) -> "zmqtt.MQTTClient": 

68 if self._client is None: 68 ↛ 69line 68 didn't jump to line 69 because the condition on line 68 was never true

69 msg = "Producer is not connected. Call connect() first." 

70 raise IncorrectState(msg) 

71 return self._client 

72 

73 @override 

74 async def publish(self, cmd: "MQTTPublishCommand") -> None: 

75 raise NotImplementedError 

76 

77 @override 

78 async def request(self, cmd: "MQTTPublishCommand") -> Any: 

79 raise NotImplementedError 

80 

81 @override 

82 async def publish_batch(self, cmd: "MQTTPublishCommand") -> None: 

83 msg = "MQTT does not support batch publishing." 

84 raise FeatureNotSupportedException(msg) 

85 

86 

87class ZmqttProducerV311(ZmqttBaseProducer): 

88 """Producer for MQTT 3.1.1 — publishes raw bytes only. 

89 

90 Headers, correlation_id, and other metadata are not supported. 

91 Use MQTT 5.0 for those features. Request/reply is supported via 

92 an explicit reply_to topic provided by the caller. 

93 """ 

94 

95 __slots__ = () 

96 

97 def __init__( 

98 self, 

99 parser: Optional["CustomCallable"], 

100 decoder: Optional["CustomCallable"], 

101 id_generator: IdGenerator = gen_cor_id, 

102 ) -> None: 

103 super().__init__(MQTTParserV311(), parser, decoder, id_generator) 

104 

105 @override 

106 async def publish(self, cmd: "MQTTPublishCommand") -> None: 

107 if cmd.headers: 

108 msg = "MQTT 3.1.1 does not support message headers. Use MQTT 5.0." 

109 raise FeatureNotSupportedException(msg) 

110 payload, _ = await self.codec.encode(cmd.body, self.serializer) 

111 await self._connected_client.publish( 

112 cmd.destination, 

113 payload, 

114 qos=zmqtt.QoS(cmd.qos), 

115 retain=cmd.retain, 

116 ) 

117 

118 @override 

119 async def request(self, cmd: "MQTTPublishCommand") -> "zmqtt.Message": 

120 """Request/reply for MQTT 3.1.1 via explicit reply topic. 

121 

122 The caller must supply ``cmd.reply_to``. FastStream subscribes to 

123 that topic, publishes the raw request payload, then waits for the 

124 first message on the reply topic. The handler side must publish 

125 its response to the same topic (e.g. via ``@broker.publisher``). 

126 """ 

127 if not cmd.reply_to: 127 ↛ 131line 127 didn't jump to line 131 because the condition on line 127 was always true

128 msg = "MQTT 3.1.1 request() requires an explicit reply_to topic." 

129 raise FeatureNotSupportedException(msg) 

130 

131 sub = self._connected_client.subscribe(cmd.reply_to) 

132 await sub.start() 

133 

134 try: 

135 payload, _ = await self.codec.encode(cmd.body, self.serializer) 

136 await self._connected_client.publish( 

137 cmd.destination, 

138 payload, 

139 qos=cmd.qos, 

140 retain=cmd.retain, 

141 ) 

142 return await asyncio.wait_for( 

143 sub.get_message(), 

144 timeout=cmd.timeout or 30.0, 

145 ) 

146 finally: 

147 await sub.stop() 

148 

149 

150class ZmqttProducerV5(ZmqttBaseProducer): 

151 """Producer for MQTT 5.0 — publishes with PublishProperties.""" 

152 

153 __slots__ = () 

154 

155 def __init__( 

156 self, 

157 parser: Optional["CustomCallable"], 

158 decoder: Optional["CustomCallable"], 

159 id_generator: IdGenerator = gen_cor_id, 

160 ) -> None: 

161 super().__init__(MQTTParserV5(), parser, decoder, id_generator) 

162 

163 @override 

164 async def publish(self, cmd: "MQTTPublishCommand") -> None: 

165 payload, content_type = await self.codec.encode(cmd.body, self.serializer) 

166 

167 user_props: list[tuple[str, str]] = [ 

168 (k, str(v)) for k, v in (cmd.headers or {}).items() 

169 ] 

170 

171 properties = PublishProperties( 

172 content_type=content_type or None, 

173 response_topic=cmd.reply_to or None, 

174 correlation_data=cmd.correlation_id.encode() if cmd.correlation_id else None, 

175 user_properties=tuple(user_props), 

176 message_expiry_interval=cmd.message_expiry_interval, 

177 ) 

178 

179 await self._connected_client.publish( 

180 cmd.destination, 

181 payload, 

182 qos=cmd.qos, 

183 retain=cmd.retain, 

184 properties=properties, 

185 ) 

186 

187 @override 

188 async def request(self, cmd: "MQTTPublishCommand") -> "zmqtt.Message": 

189 """Request/reply for MQTT 5.0 via zmqtt's native client.request(). 

190 

191 zmqtt auto-generates a unique reply topic. We pass our correlation 

192 ID explicitly so the responder echoes it back and the caller can 

193 verify it on the response StreamMessage. 

194 """ 

195 payload, content_type = await self.codec.encode(cmd.body, self.serializer) 

196 correlation_id = cmd.correlation_id or self.id_generator() 

197 

198 user_props: list[tuple[str, str]] = [ 

199 (k, str(v)) for k, v in (cmd.headers or {}).items() 

200 ] 

201 

202 # Pass correlation_data explicitly so the responder echoes it back. 

203 # Do NOT set response_topic — let zmqtt generate it. 

204 properties = PublishProperties( 

205 content_type=content_type or None, 

206 correlation_data=correlation_id.encode(), 

207 user_properties=tuple(user_props), 

208 message_expiry_interval=cmd.message_expiry_interval, 

209 ) 

210 

211 return await self._connected_client.request( 

212 cmd.destination, 

213 payload, 

214 qos=cmd.qos, 

215 timeout=cmd.timeout or 30.0, 

216 properties=properties, 

217 ) 

218 

219 

220class ZmqttFakeProducer(ZmqttBaseProducer): 

221 __slots__ = () 

222 

223 def __init__(self) -> None: ... 

224 def __bool__(self) -> bool: 

225 return False 

226 

227 def connect( 

228 self, 

229 client: "zmqtt.MQTTClient", 

230 serializer: Optional["SerializerProto"], 

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

232 ) -> None: 

233 raise NotImplementedError 

234 

235 def disconnect(self) -> None: 

236 raise NotImplementedError