main commit

venv/lib/python3.12/site-packages/redis/asyncio/sentinel.py

@@ -11,12 +11,8 @@ from redis.asyncio.connection import (
     SSLConnection,
 )
 from redis.commands import AsyncSentinelCommands
-from redis.exceptions import (
-    ConnectionError,
-    ReadOnlyError,
-    ResponseError,
-    TimeoutError,
-)
+from redis.exceptions import ConnectionError, ReadOnlyError, ResponseError, TimeoutError
+from redis.utils import str_if_bytes
 
 
 class MasterNotFoundError(ConnectionError):
@@ -33,18 +29,20 @@ class SentinelManagedConnection(Connection):
         super().__init__(**kwargs)
 
     def __repr__(self):
-        s = f"<{self.__class__.__module__}.{self.__class__.__name__}"
+        pool = self.connection_pool
+        s = f"{self.__class__.__name__}<service={pool.service_name}"
         if self.host:
             host_info = f",host={self.host},port={self.port}"
             s += host_info
-        return s + ")>"
+        return s + ">"
 
     async def connect_to(self, address):
         self.host, self.port = address
-        await self.connect_check_health(
-            check_health=self.connection_pool.check_connection,
-            retry_socket_connect=False,
-        )
+        await super().connect()
+        if self.connection_pool.check_connection:
+            await self.send_command("PING")
+            if str_if_bytes(await self.read_response()) != "PONG":
+                raise ConnectionError("PING failed")
 
     async def _connect_retry(self):
         if self._reader:
@@ -107,11 +105,9 @@ class SentinelConnectionPool(ConnectionPool):
     def __init__(self, service_name, sentinel_manager, **kwargs):
         kwargs["connection_class"] = kwargs.get(
             "connection_class",
-            (
-                SentinelManagedSSLConnection
-                if kwargs.pop("ssl", False)
-                else SentinelManagedConnection
-            ),
+            SentinelManagedSSLConnection
+            if kwargs.pop("ssl", False)
+            else SentinelManagedConnection,
         )
         self.is_master = kwargs.pop("is_master", True)
         self.check_connection = kwargs.pop("check_connection", False)
@@ -124,8 +120,8 @@ class SentinelConnectionPool(ConnectionPool):
 
     def __repr__(self):
         return (
-            f"<{self.__class__.__module__}.{self.__class__.__name__}"
-            f"(service={self.service_name}({self.is_master and 'master' or 'slave'}))>"
+            f"{self.__class__.__name__}"
+            f"<service={self.service_name}({self.is_master and 'master' or 'slave'})>"
         )
 
     def reset(self):
@@ -201,7 +197,6 @@ class Sentinel(AsyncSentinelCommands):
         sentinels,
         min_other_sentinels=0,
         sentinel_kwargs=None,
-        force_master_ip=None,
         **connection_kwargs,
     ):
         # if sentinel_kwargs isn't defined, use the socket_* options from
@@ -218,7 +213,6 @@ class Sentinel(AsyncSentinelCommands):
         ]
         self.min_other_sentinels = min_other_sentinels
         self.connection_kwargs = connection_kwargs
-        self._force_master_ip = force_master_ip
 
     async def execute_command(self, *args, **kwargs):
         """
@@ -226,31 +220,19 @@ class Sentinel(AsyncSentinelCommands):
         once - If set to True, then execute the resulting command on a single
                node at random, rather than across the entire sentinel cluster.
         """
-        once = bool(kwargs.pop("once", False))
-
-        # Check if command is supposed to return the original
-        # responses instead of boolean value.
-        return_responses = bool(kwargs.pop("return_responses", False))
+        once = bool(kwargs.get("once", False))
+        if "once" in kwargs.keys():
+            kwargs.pop("once")
 
         if once:
-            response = await random.choice(self.sentinels).execute_command(
-                *args, **kwargs
-            )
-            if return_responses:
-                return [response]
-            else:
-                return True if response else False
-
-        tasks = [
-            asyncio.Task(sentinel.execute_command(*args, **kwargs))
-            for sentinel in self.sentinels
-        ]
-        responses = await asyncio.gather(*tasks)
-
-        if return_responses:
-            return responses
-
-        return all(responses)
+            await random.choice(self.sentinels).execute_command(*args, **kwargs)
+        else:
+            tasks = [
+                asyncio.Task(sentinel.execute_command(*args, **kwargs))
+                for sentinel in self.sentinels
+            ]
+            await asyncio.gather(*tasks)
+        return True
 
     def __repr__(self):
         sentinel_addresses = []
@@ -259,10 +241,7 @@ class Sentinel(AsyncSentinelCommands):
                 f"{sentinel.connection_pool.connection_kwargs['host']}:"
                 f"{sentinel.connection_pool.connection_kwargs['port']}"
             )
-        return (
-            f"<{self.__class__}.{self.__class__.__name__}"
-            f"(sentinels=[{','.join(sentinel_addresses)}])>"
-        )
+        return f"{self.__class__.__name__}<sentinels=[{','.join(sentinel_addresses)}]>"
 
     def check_master_state(self, state: dict, service_name: str) -> bool:
         if not state["is_master"] or state["is_sdown"] or state["is_odown"]:
@@ -294,13 +273,7 @@ class Sentinel(AsyncSentinelCommands):
                     sentinel,
                     self.sentinels[0],
                 )
-
-                ip = (
-                    self._force_master_ip
-                    if self._force_master_ip is not None
-                    else state["ip"]
-                )
-                return ip, state["port"]
+                return state["ip"], state["port"]
 
         error_info = ""
         if len(collected_errors) > 0:
@@ -341,8 +314,6 @@ class Sentinel(AsyncSentinelCommands):
     ):
         """
         Returns a redis client instance for the ``service_name`` master.
-        Sentinel client will detect failover and reconnect Redis clients
-        automatically.
 
         A :py:class:`~redis.sentinel.SentinelConnectionPool` class is
         used to retrieve the master's address before establishing a new