Coverage for faststream/redis/subscriber/usecases/basic.py: 81%

53 statements  

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

1import logging 

2from abc import abstractmethod 

3from collections.abc import Sequence 

4from contextlib import suppress 

5from typing import TYPE_CHECKING, Any, Optional, TypeAlias, cast 

6 

7import anyio 

8from typing_extensions import override 

9 

10from faststream._internal.endpoint.subscriber import ( 

11 SubscriberSpecification, 

12 SubscriberUsecase, 

13) 

14from faststream._internal.endpoint.subscriber.mixins import ConcurrentMixin, TasksMixin 

15from faststream.redis.message import ( 

16 UnifyRedisDict, 

17) 

18from faststream.redis.publisher.fake import RedisFakePublisher 

19 

20if TYPE_CHECKING: 

21 from redis.asyncio.client import Redis 

22 

23 from faststream._internal.endpoint.publisher import PublisherProto 

24 from faststream._internal.endpoint.subscriber.call_item import ( 

25 CallsCollection, 

26 ) 

27 from faststream.message import StreamMessage as BrokerStreamMessage 

28 from faststream.redis.configs import RedisBrokerConfig 

29 from faststream.redis.subscriber.config import RedisSubscriberConfig 

30 

31 

32TopicName: TypeAlias = bytes 

33Offset: TypeAlias = bytes 

34 

35# Delay (seconds) before a subscriber retries after a message-fetch error. 

36# Shared by all Redis subscriber loops to avoid busy-looping on persistent 

37# connection errors (e.g. while a Sentinel pool fails over to a new master). 

38CONSUME_ERROR_BACKOFF_SECONDS = 5 

39 

40 

41class LogicSubscriber(TasksMixin, SubscriberUsecase[UnifyRedisDict]): 

42 """A class to represent a Redis handler.""" 

43 

44 __slots__ = ("config",) 

45 

46 _outer_config: "RedisBrokerConfig" 

47 

48 def __init__( 

49 self, 

50 config: "RedisSubscriberConfig", 

51 specification: "SubscriberSpecification[Any, Any]", 

52 calls: "CallsCollection[Any]", 

53 ) -> None: 

54 super().__init__(config, specification, calls) 

55 self.config = config 

56 

57 @property 

58 def _client(self) -> "Redis[bytes]": 

59 return cast("Redis[bytes]", self._outer_config.connection.client) 

60 

61 def _make_response_publisher( 

62 self, 

63 message: "BrokerStreamMessage[UnifyRedisDict]", 

64 ) -> Sequence["PublisherProto"]: 

65 return ( 

66 RedisFakePublisher( 

67 self._outer_config.producer, 

68 channel=message.reply_to, 

69 message_format=self.config.message_format, 

70 ), 

71 ) 

72 

73 @override 

74 async def start( 

75 self, 

76 *args: Any, 

77 ) -> None: 

78 await super().start() 

79 

80 self._post_start() 

81 

82 start_signal = anyio.Event() 

83 

84 if self.calls: 

85 self.add_task(self._consume, args, {"start_signal": start_signal}) 

86 

87 with anyio.fail_after(3.0): 

88 await start_signal.wait() 

89 

90 else: 

91 start_signal.set() 

92 

93 async def _consume(self, *args: Any, start_signal: anyio.Event) -> None: 

94 connected = True 

95 

96 while self.running: 

97 try: 

98 await self._get_msgs(*args) 

99 

100 except Exception as e: # ruff: ignore[try-except-in-loop] 

101 self._log( 

102 log_level=logging.ERROR, 

103 message="Message fetch error", 

104 exc_info=e, 

105 ) 

106 

107 if connected: 

108 connected = False 

109 

110 await anyio.sleep(CONSUME_ERROR_BACKOFF_SECONDS) 

111 

112 else: 

113 if not connected: 113 ↛ 114line 113 didn't jump to line 114 because the condition on line 113 was never true

114 connected = True 

115 

116 finally: 

117 if not start_signal.is_set(): 

118 with suppress(Exception): 

119 start_signal.set() 

120 

121 @abstractmethod 

122 async def _get_msgs(self, *args: Any) -> None: 

123 raise NotImplementedError 

124 

125 @staticmethod 

126 def build_log_context( 

127 message: Optional["BrokerStreamMessage[Any]"], 

128 channel: str = "", 

129 ) -> dict[str, str]: 

130 return { 

131 "channel": channel, 

132 "message_id": getattr(message, "message_id", ""), 

133 } 

134 

135 async def consume_one(self, msg: Any) -> None: 

136 await self.consume(msg) 

137 

138 

139class ConcurrentSubscriber( 

140 ConcurrentMixin["BrokerStreamMessage[Any]"], 

141 LogicSubscriber, 

142): 

143 __slots__ = () 

144 

145 def __init__( 

146 self, 

147 config: "RedisSubscriberConfig", 

148 specification: "SubscriberSpecification[Any, Any]", 

149 calls: "CallsCollection[Any]", 

150 max_workers: int, 

151 ) -> None: 

152 super().__init__(config, specification, calls, max_workers=max_workers) 

153 

154 async def start(self) -> None: 

155 await super().start() 

156 self.start_consume_task() 

157 

158 async def consume_one(self, msg: "BrokerStreamMessage[Any]") -> None: 

159 await self._put_msg(msg)