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
« 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
7import anyio
8from typing_extensions import override
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
20if TYPE_CHECKING:
21 from redis.asyncio.client import Redis
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
32TopicName: TypeAlias = bytes
33Offset: TypeAlias = bytes
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
41class LogicSubscriber(TasksMixin, SubscriberUsecase[UnifyRedisDict]):
42 """A class to represent a Redis handler."""
44 __slots__ = ("config",)
46 _outer_config: "RedisBrokerConfig"
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
57 @property
58 def _client(self) -> "Redis[bytes]":
59 return cast("Redis[bytes]", self._outer_config.connection.client)
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 )
73 @override
74 async def start(
75 self,
76 *args: Any,
77 ) -> None:
78 await super().start()
80 self._post_start()
82 start_signal = anyio.Event()
84 if self.calls:
85 self.add_task(self._consume, args, {"start_signal": start_signal})
87 with anyio.fail_after(3.0):
88 await start_signal.wait()
90 else:
91 start_signal.set()
93 async def _consume(self, *args: Any, start_signal: anyio.Event) -> None:
94 connected = True
96 while self.running:
97 try:
98 await self._get_msgs(*args)
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 )
107 if connected:
108 connected = False
110 await anyio.sleep(CONSUME_ERROR_BACKOFF_SECONDS)
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
116 finally:
117 if not start_signal.is_set():
118 with suppress(Exception):
119 start_signal.set()
121 @abstractmethod
122 async def _get_msgs(self, *args: Any) -> None:
123 raise NotImplementedError
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 }
135 async def consume_one(self, msg: Any) -> None:
136 await self.consume(msg)
139class ConcurrentSubscriber(
140 ConcurrentMixin["BrokerStreamMessage[Any]"],
141 LogicSubscriber,
142):
143 __slots__ = ()
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)
154 async def start(self) -> None:
155 await super().start()
156 self.start_consume_task()
158 async def consume_one(self, msg: "BrokerStreamMessage[Any]") -> None:
159 await self._put_msg(msg)