redis 7.0.0b3__py3-none-any.whl → 7.0.1__py3-none-any.whl

redis/connection.py

@@ -5,7 +5,7 @@ import sys
 import threading
 import time
 import weakref
-from abc import abstractmethod
+from abc import ABC, abstractmethod
 from itertools import chain
 from queue import Empty, Full, LifoQueue
 from typing import (
@@ -178,10 +178,6 @@ class ConnectionInterface:
     def set_parser(self, parser_class):
         pass
 
-    @abstractmethod
-    def set_maint_notifications_pool_handler(self, maint_notifications_pool_handler):
-        pass
-
     @abstractmethod
     def get_protocol(self):
         pass
@@ -245,29 +241,6 @@ class ConnectionInterface:
     def re_auth(self):
         pass
 
-    @property
-    @abstractmethod
-    def maintenance_state(self) -> MaintenanceState:
-        """
-        Returns the current maintenance state of the connection.
-        """
-        pass
-
-    @maintenance_state.setter
-    @abstractmethod
-    def maintenance_state(self, state: "MaintenanceState"):
-        """
-        Sets the current maintenance state of the connection.
-        """
-        pass
-
-    @abstractmethod
-    def getpeername(self):
-        """
-        Returns the peer name of the connection.
-        """
-        pass
-
     @abstractmethod
     def mark_for_reconnect(self):
         """
@@ -284,250 +257,189 @@ class ConnectionInterface:
         pass
 
     @abstractmethod
-    def get_resolved_ip(self):
-        """
-        Get resolved ip address for the connection.
-        """
-        pass
-
-    @abstractmethod
-    def update_current_socket_timeout(self, relaxed_timeout: Optional[float] = None):
+    def reset_should_reconnect(self):
         """
-        Update the timeout for the current socket.
+        Reset the internal flag to False.
         """
         pass
 
-    @abstractmethod
-    def set_tmp_settings(
-        self,
-        tmp_host_address: Optional[str] = None,
-        tmp_relaxed_timeout: Optional[float] = None,
-    ):
-        """
-        Updates temporary host address and timeout settings for the connection.
-        """
-        pass
 
-    @abstractmethod
-    def reset_tmp_settings(
-        self,
-        reset_host_address: bool = False,
-        reset_relaxed_timeout: bool = False,
-    ):
-        """
-        Resets temporary host address and timeout settings for the connection.
-        """
-        pass
+class MaintNotificationsAbstractConnection:
+    """
+    Abstract class for handling maintenance notifications logic.
+    This class is expected to be used as base class together with ConnectionInterface.
 
+    This class is intended to be used with multiple inheritance!
 
-class AbstractConnection(ConnectionInterface):
-    "Manages communication to and from a Redis server"
+    All logic related to maintenance notifications is encapsulated in this class.
+    """
 
     def __init__(
         self,
-        db: int = 0,
-        password: Optional[str] = None,
-        socket_timeout: Optional[float] = None,
-        socket_connect_timeout: Optional[float] = None,
-        retry_on_timeout: bool = False,
-        retry_on_error: Union[Iterable[Type[Exception]], object] = SENTINEL,
-        encoding: str = "utf-8",
-        encoding_errors: str = "strict",
-        decode_responses: bool = False,
-        parser_class=DefaultParser,
-        socket_read_size: int = 65536,
-        health_check_interval: int = 0,
-        client_name: Optional[str] = None,
-        lib_name: Optional[str] = "redis-py",
-        lib_version: Optional[str] = get_lib_version(),
-        username: Optional[str] = None,
-        retry: Union[Any, None] = None,
-        redis_connect_func: Optional[Callable[[], None]] = None,
-        credential_provider: Optional[CredentialProvider] = None,
-        protocol: Optional[int] = 2,
-        command_packer: Optional[Callable[[], None]] = None,
-        event_dispatcher: Optional[EventDispatcher] = None,
+        maint_notifications_config: Optional[MaintNotificationsConfig],
         maint_notifications_pool_handler: Optional[
             MaintNotificationsPoolHandler
         ] = None,
-        maint_notifications_config: Optional[MaintNotificationsConfig] = None,
         maintenance_state: "MaintenanceState" = MaintenanceState.NONE,
         maintenance_notification_hash: Optional[int] = None,
         orig_host_address: Optional[str] = None,
         orig_socket_timeout: Optional[float] = None,
         orig_socket_connect_timeout: Optional[float] = None,
+        parser: Optional[Union[_HiredisParser, _RESP3Parser]] = None,
     ):
         """
-        Initialize a new Connection.
-        To specify a retry policy for specific errors, first set
-        `retry_on_error` to a list of the error/s to retry on, then set
-        `retry` to a valid `Retry` object.
-        To retry on TimeoutError, `retry_on_timeout` can also be set to `True`.
-        """
-        if (username or password) and credential_provider is not None:
-            raise DataError(
-                "'username' and 'password' cannot be passed along with 'credential_"
-                "provider'. Please provide only one of the following arguments: \n"
-                "1. 'password' and (optional) 'username'\n"
-                "2. 'credential_provider'"
-            )
-        if event_dispatcher is None:
-            self._event_dispatcher = EventDispatcher()
-        else:
-            self._event_dispatcher = event_dispatcher
-        self.pid = os.getpid()
-        self.db = db
-        self.client_name = client_name
-        self.lib_name = lib_name
-        self.lib_version = lib_version
-        self.credential_provider = credential_provider
-        self.password = password
-        self.username = username
-        self.socket_timeout = socket_timeout
-        if socket_connect_timeout is None:
-            socket_connect_timeout = socket_timeout
-        self.socket_connect_timeout = socket_connect_timeout
-        self.retry_on_timeout = retry_on_timeout
-        if retry_on_error is SENTINEL:
-            retry_on_errors_list = []
-        else:
-            retry_on_errors_list = list(retry_on_error)
-        if retry_on_timeout:
-            # Add TimeoutError to the errors list to retry on
-            retry_on_errors_list.append(TimeoutError)
-        self.retry_on_error = retry_on_errors_list
-        if retry or self.retry_on_error:
-            if retry is None:
-                self.retry = Retry(NoBackoff(), 1)
-            else:
-                # deep-copy the Retry object as it is mutable
-                self.retry = copy.deepcopy(retry)
-            if self.retry_on_error:
-                # Update the retry's supported errors with the specified errors
-                self.retry.update_supported_errors(self.retry_on_error)
-        else:
-            self.retry = Retry(NoBackoff(), 0)
-        self.health_check_interval = health_check_interval
-        self.next_health_check = 0
-        self.redis_connect_func = redis_connect_func
-        self.encoder = Encoder(encoding, encoding_errors, decode_responses)
-        self.handshake_metadata = None
-        self._sock = None
-        self._socket_read_size = socket_read_size
-        self._connect_callbacks = []
-        self._buffer_cutoff = 6000
-        self._re_auth_token: Optional[TokenInterface] = None
-        try:
-            p = int(protocol)
-        except TypeError:
-            p = DEFAULT_RESP_VERSION
-        except ValueError:
-            raise ConnectionError("protocol must be an integer")
-        finally:
-            if p < 2 or p > 3:
-                raise ConnectionError("protocol must be either 2 or 3")
-                # p = DEFAULT_RESP_VERSION
-            self.protocol = p
-        if self.protocol == 3 and parser_class == DefaultParser:
-            parser_class = _RESP3Parser
-        self.set_parser(parser_class)
+        Initialize the maintenance notifications for the connection.
 
+        Args:
+            maint_notifications_config (MaintNotificationsConfig): The configuration for maintenance notifications.
+            maint_notifications_pool_handler (Optional[MaintNotificationsPoolHandler]): The pool handler for maintenance notifications.
+            maintenance_state (MaintenanceState): The current maintenance state of the connection.
+            maintenance_notification_hash (Optional[int]): The current maintenance notification hash of the connection.
+            orig_host_address (Optional[str]): The original host address of the connection.
+            orig_socket_timeout (Optional[float]): The original socket timeout of the connection.
+            orig_socket_connect_timeout (Optional[float]): The original socket connect timeout of the connection.
+            parser (Optional[Union[_HiredisParser, _RESP3Parser]]): The parser to use for maintenance notifications.
+                    If not provided, the parser from the connection is used.
+                    This is useful when the parser is created after this object.
+        """
         self.maint_notifications_config = maint_notifications_config
-
-        # Set up maintenance notifications if enabled
+        self.maintenance_state = maintenance_state
+        self.maintenance_notification_hash = maintenance_notification_hash
         self._configure_maintenance_notifications(
             maint_notifications_pool_handler,
             orig_host_address,
             orig_socket_timeout,
             orig_socket_connect_timeout,
+            parser,
         )
 
-        self._should_reconnect = False
-        self.maintenance_state = maintenance_state
-        self.maintenance_notification_hash = maintenance_notification_hash
+    @abstractmethod
+    def _get_parser(self) -> Union[_HiredisParser, _RESP3Parser]:
+        pass
 
-        self._command_packer = self._construct_command_packer(command_packer)
+    @abstractmethod
+    def _get_socket(self) -> Optional[socket.socket]:
+        pass
 
-    def __repr__(self):
-        repr_args = ",".join([f"{k}={v}" for k, v in self.repr_pieces()])
-        return f"<{self.__class__.__module__}.{self.__class__.__name__}({repr_args})>"
+    @abstractmethod
+    def get_protocol(self) -> Union[int, str]:
+        """
+        Returns:
+            The RESP protocol version, or ``None`` if the protocol is not specified,
+            in which case the server default will be used.
+        """
+        pass
 
+    @property
     @abstractmethod
-    def repr_pieces(self):
+    def host(self) -> str:
         pass
 
-    def __del__(self):
-        try:
-            self.disconnect()
-        except Exception:
-            pass
+    @host.setter
+    @abstractmethod
+    def host(self, value: str):
+        pass
 
-    def _construct_command_packer(self, packer):
-        if packer is not None:
-            return packer
-        elif HIREDIS_AVAILABLE:
-            return HiredisRespSerializer()
-        else:
-            return PythonRespSerializer(self._buffer_cutoff, self.encoder.encode)
+    @property
+    @abstractmethod
+    def socket_timeout(self) -> Optional[Union[float, int]]:
+        pass
 
-    def register_connect_callback(self, callback):
-        """
-        Register a callback to be called when the connection is established either
-        initially or reconnected.  This allows listeners to issue commands that
-        are ephemeral to the connection, for example pub/sub subscription or
-        key tracking.  The callback must be a _method_ and will be kept as
-        a weak reference.
-        """
-        wm = weakref.WeakMethod(callback)
-        if wm not in self._connect_callbacks:
-            self._connect_callbacks.append(wm)
+    @socket_timeout.setter
+    @abstractmethod
+    def socket_timeout(self, value: Optional[Union[float, int]]):
+        pass
 
-    def deregister_connect_callback(self, callback):
-        """
-        De-register a previously registered callback.  It will no-longer receive
-        notifications on connection events.  Calling this is not required when the
-        listener goes away, since the callbacks are kept as weak methods.
-        """
-        try:
-            self._connect_callbacks.remove(weakref.WeakMethod(callback))
-        except ValueError:
-            pass
+    @property
+    @abstractmethod
+    def socket_connect_timeout(self) -> Optional[Union[float, int]]:
+        pass
 
-    def set_parser(self, parser_class):
-        """
-        Creates a new instance of parser_class with socket size:
-        _socket_read_size and assigns it to the parser for the connection
-        :param parser_class: The required parser class
-        """
-        self._parser = parser_class(socket_read_size=self._socket_read_size)
+    @socket_connect_timeout.setter
+    @abstractmethod
+    def socket_connect_timeout(self, value: Optional[Union[float, int]]):
+        pass
+
+    @abstractmethod
+    def send_command(self, *args, **kwargs):
+        pass
+
+    @abstractmethod
+    def read_response(
+        self,
+        disable_decoding=False,
+        *,
+        disconnect_on_error=True,
+        push_request=False,
+    ):
+        pass
+
+    @abstractmethod
+    def disconnect(self, *args):
+        pass
 
     def _configure_maintenance_notifications(
         self,
-        maint_notifications_pool_handler=None,
+        maint_notifications_pool_handler: Optional[
+            MaintNotificationsPoolHandler
+        ] = None,
         orig_host_address=None,
         orig_socket_timeout=None,
         orig_socket_connect_timeout=None,
+        parser: Optional[Union[_HiredisParser, _RESP3Parser]] = None,
     ):
-        """Enable maintenance notifications by setting up handlers and storing original connection parameters."""
+        """
+        Enable maintenance notifications by setting up
+        handlers and storing original connection parameters.
+
+        Should be used ONLY with parsers that support push notifications.
+        """
         if (
             not self.maint_notifications_config
             or not self.maint_notifications_config.enabled
         ):
+            self._maint_notifications_pool_handler = None
             self._maint_notifications_connection_handler = None
             return
 
-        # Set up pool handler if available
-        if maint_notifications_pool_handler:
-            self._parser.set_node_moving_push_handler(
-                maint_notifications_pool_handler.handle_notification
+        if not parser:
+            raise RedisError(
+                "To configure maintenance notifications, a parser must be provided!"
             )
 
-        # Set up connection handler
-        self._maint_notifications_connection_handler = (
-            MaintNotificationsConnectionHandler(self, self.maint_notifications_config)
-        )
-        self._parser.set_maintenance_push_handler(
-            self._maint_notifications_connection_handler.handle_notification
+        if not isinstance(parser, _HiredisParser) and not isinstance(
+            parser, _RESP3Parser
+        ):
+            raise RedisError(
+                "Maintenance notifications are only supported with hiredis and RESP3 parsers!"
+            )
+
+        if maint_notifications_pool_handler:
+            # Extract a reference to a new pool handler that copies all properties
+            # of the original one and has a different connection reference
+            # This is needed because when we attach the handler to the parser
+            # we need to make sure that the handler has a reference to the
+            # connection that the parser is attached to.
+            self._maint_notifications_pool_handler = (
+                maint_notifications_pool_handler.get_handler_for_connection()
+            )
+            self._maint_notifications_pool_handler.set_connection(self)
+        else:
+            self._maint_notifications_pool_handler = None
+
+        self._maint_notifications_connection_handler = (
+            MaintNotificationsConnectionHandler(self, self.maint_notifications_config)
+        )
+
+        # Set up pool handler if available
+        if self._maint_notifications_pool_handler:
+            parser.set_node_moving_push_handler(
+                self._maint_notifications_pool_handler.handle_notification
+            )
+
+        # Set up connection handler
+        parser.set_maintenance_push_handler(
+            self._maint_notifications_connection_handler.handle_notification
         )
 
         # Store original connection parameters
@@ -541,14 +453,24 @@ class AbstractConnection(ConnectionInterface):
             else self.socket_connect_timeout
         )
 
-    def set_maint_notifications_pool_handler(
+    def set_maint_notifications_pool_handler_for_connection(
         self, maint_notifications_pool_handler: MaintNotificationsPoolHandler
     ):
-        maint_notifications_pool_handler.set_connection(self)
-        self._parser.set_node_moving_push_handler(
-            maint_notifications_pool_handler.handle_notification
+        # Deep copy the pool handler to avoid sharing the same pool handler
+        # between multiple connections, because otherwise each connection will override
+        # the connection reference and the pool handler will only hold a reference
+        # to the last connection that was set.
+        maint_notifications_pool_handler_copy = (
+            maint_notifications_pool_handler.get_handler_for_connection()
+        )
+
+        maint_notifications_pool_handler_copy.set_connection(self)
+        self._get_parser().set_node_moving_push_handler(
+            maint_notifications_pool_handler_copy.handle_notification
         )
 
+        self._maint_notifications_pool_handler = maint_notifications_pool_handler_copy
+
         # Update maintenance notification connection handler if it doesn't exist
         if not self._maint_notifications_connection_handler:
             self._maint_notifications_connection_handler = (
@@ -556,7 +478,7 @@ class AbstractConnection(ConnectionInterface):
                     self, maint_notifications_pool_handler.config
                 )
             )
-            self._parser.set_maintenance_push_handler(
+            self._get_parser().set_maintenance_push_handler(
                 self._maint_notifications_connection_handler.handle_notification
             )
         else:
@@ -564,130 +486,7 @@ class AbstractConnection(ConnectionInterface):
                 maint_notifications_pool_handler.config
             )
 
-    def connect(self):
-        "Connects to the Redis server if not already connected"
-        self.connect_check_health(check_health=True)
-
-    def connect_check_health(
-        self, check_health: bool = True, retry_socket_connect: bool = True
-    ):
-        if self._sock:
-            return
-        try:
-            if retry_socket_connect:
-                sock = self.retry.call_with_retry(
-                    lambda: self._connect(), lambda error: self.disconnect(error)
-                )
-            else:
-                sock = self._connect()
-        except socket.timeout:
-            raise TimeoutError("Timeout connecting to server")
-        except OSError as e:
-            raise ConnectionError(self._error_message(e))
-
-        self._sock = sock
-        try:
-            if self.redis_connect_func is None:
-                # Use the default on_connect function
-                self.on_connect_check_health(check_health=check_health)
-            else:
-                # Use the passed function redis_connect_func
-                self.redis_connect_func(self)
-        except RedisError:
-            # clean up after any error in on_connect
-            self.disconnect()
-            raise
-
-        # run any user callbacks. right now the only internal callback
-        # is for pubsub channel/pattern resubscription
-        # first, remove any dead weakrefs
-        self._connect_callbacks = [ref for ref in self._connect_callbacks if ref()]
-        for ref in self._connect_callbacks:
-            callback = ref()
-            if callback:
-                callback(self)
-
-    @abstractmethod
-    def _connect(self):
-        pass
-
-    @abstractmethod
-    def _host_error(self):
-        pass
-
-    def _error_message(self, exception):
-        return format_error_message(self._host_error(), exception)
-
-    def on_connect(self):
-        self.on_connect_check_health(check_health=True)
-
-    def on_connect_check_health(self, check_health: bool = True):
-        "Initialize the connection, authenticate and select a database"
-        self._parser.on_connect(self)
-        parser = self._parser
-
-        auth_args = None
-        # if credential provider or username and/or password are set, authenticate
-        if self.credential_provider or (self.username or self.password):
-            cred_provider = (
-                self.credential_provider
-                or UsernamePasswordCredentialProvider(self.username, self.password)
-            )
-            auth_args = cred_provider.get_credentials()
-
-        # if resp version is specified and we have auth args,
-        # we need to send them via HELLO
-        if auth_args and self.protocol not in [2, "2"]:
-            if isinstance(self._parser, _RESP2Parser):
-                self.set_parser(_RESP3Parser)
-                # update cluster exception classes
-                self._parser.EXCEPTION_CLASSES = parser.EXCEPTION_CLASSES
-                self._parser.on_connect(self)
-            if len(auth_args) == 1:
-                auth_args = ["default", auth_args[0]]
-            # avoid checking health here -- PING will fail if we try
-            # to check the health prior to the AUTH
-            self.send_command(
-                "HELLO", self.protocol, "AUTH", *auth_args, check_health=False
-            )
-            self.handshake_metadata = self.read_response()
-            # if response.get(b"proto") != self.protocol and response.get(
-            #     "proto"
-            # ) != self.protocol:
-            #     raise ConnectionError("Invalid RESP version")
-        elif auth_args:
-            # avoid checking health here -- PING will fail if we try
-            # to check the health prior to the AUTH
-            self.send_command("AUTH", *auth_args, check_health=False)
-
-            try:
-                auth_response = self.read_response()
-            except AuthenticationWrongNumberOfArgsError:
-                # a username and password were specified but the Redis
-                # server seems to be < 6.0.0 which expects a single password
-                # arg. retry auth with just the password.
-                # https://github.com/andymccurdy/redis-py/issues/1274
-                self.send_command("AUTH", auth_args[-1], check_health=False)
-                auth_response = self.read_response()
-
-            if str_if_bytes(auth_response) != "OK":
-                raise AuthenticationError("Invalid Username or Password")
-
-        # if resp version is specified, switch to it
-        elif self.protocol not in [2, "2"]:
-            if isinstance(self._parser, _RESP2Parser):
-                self.set_parser(_RESP3Parser)
-                # update cluster exception classes
-                self._parser.EXCEPTION_CLASSES = parser.EXCEPTION_CLASSES
-                self._parser.on_connect(self)
-            self.send_command("HELLO", self.protocol, check_health=check_health)
-            self.handshake_metadata = self.read_response()
-            if (
-                self.handshake_metadata.get(b"proto") != self.protocol
-                and self.handshake_metadata.get("proto") != self.protocol
-            ):
-                raise ConnectionError("Invalid RESP version")
-
+    def activate_maint_notifications_handling_if_enabled(self, check_health=True):
         # Send maintenance notifications handshake if RESP3 is active
         # and maintenance notifications are enabled
         # and we have a host to determine the endpoint type from
@@ -695,16 +494,29 @@ class AbstractConnection(ConnectionInterface):
         # we just log a warning if the handshake fails
         # When the mode is enabled=True, we raise an exception in case of failure
         if (
-            self.protocol not in [2, "2"]
+            self.get_protocol() not in [2, "2"]
             and self.maint_notifications_config
             and self.maint_notifications_config.enabled
             and self._maint_notifications_connection_handler
             and hasattr(self, "host")
         ):
-            try:
-                endpoint_type = self.maint_notifications_config.get_endpoint_type(
-                    self.host, self
+            self._enable_maintenance_notifications(
+                maint_notifications_config=self.maint_notifications_config,
+                check_health=check_health,
+            )
+
+    def _enable_maintenance_notifications(
+        self, maint_notifications_config: MaintNotificationsConfig, check_health=True
+    ):
+        try:
+            host = getattr(self, "host", None)
+            if host is None:
+                raise ValueError(
+                    "Cannot enable maintenance notifications for connection"
+                    " object that doesn't have a host attribute."
                 )
+            else:
+                endpoint_type = maint_notifications_config.get_endpoint_type(host, self)
                 self.send_command(
                     "CLIENT",
                     "MAINT_NOTIFICATIONS",
@@ -714,337 +526,105 @@ class AbstractConnection(ConnectionInterface):
                     check_health=check_health,
                 )
                 response = self.read_response()
-                if str_if_bytes(response) != "OK":
+                if not response or str_if_bytes(response) != "OK":
                     raise ResponseError(
                         "The server doesn't support maintenance notifications"
                     )
-            except Exception as e:
-                if (
-                    isinstance(e, ResponseError)
-                    and self.maint_notifications_config.enabled == "auto"
-                ):
-                    # Log warning but don't fail the connection
-                    import logging
+        except Exception as e:
+            if (
+                isinstance(e, ResponseError)
+                and maint_notifications_config.enabled == "auto"
+            ):
+                # Log warning but don't fail the connection
+                import logging
 
-                    logger = logging.getLogger(__name__)
-                    logger.warning(f"Failed to enable maintenance notifications: {e}")
-                else:
-                    raise
+                logger = logging.getLogger(__name__)
+                logger.warning(f"Failed to enable maintenance notifications: {e}")
+            else:
+                raise
 
-        # if a client_name is given, set it
-        if self.client_name:
-            self.send_command(
-                "CLIENT",
-                "SETNAME",
-                self.client_name,
-                check_health=check_health,
-            )
-            if str_if_bytes(self.read_response()) != "OK":
-                raise ConnectionError("Error setting client name")
+    def get_resolved_ip(self) -> Optional[str]:
+        """
+        Extract the resolved IP address from an
+        established connection or resolve it from the host.
+
+        First tries to get the actual IP from the socket (most accurate),
+        then falls back to DNS resolution if needed.
+
+        Args:
+            connection: The connection object to extract the IP from
+
+        Returns:
+            str: The resolved IP address, or None if it cannot be determined
+        """
 
+        # Method 1: Try to get the actual IP from the established socket connection
+        # This is most accurate as it shows the exact IP being used
         try:
-            # set the library name and version
-            if self.lib_name:
-                self.send_command(
-                    "CLIENT",
-                    "SETINFO",
-                    "LIB-NAME",
-                    self.lib_name,
-                    check_health=check_health,
-                )
-                self.read_response()
-        except ResponseError:
+            conn_socket = self._get_socket()
+            if conn_socket is not None:
+                peer_addr = conn_socket.getpeername()
+                if peer_addr and len(peer_addr) >= 1:
+                    # For TCP sockets, peer_addr is typically (host, port) tuple
+                    # Return just the host part
+                    return peer_addr[0]
+        except (AttributeError, OSError):
+            # Socket might not be connected or getpeername() might fail
             pass
 
+        # Method 2: Fallback to DNS resolution of the host
+        # This is less accurate but works when socket is not available
         try:
-            if self.lib_version:
-                self.send_command(
-                    "CLIENT",
-                    "SETINFO",
-                    "LIB-VER",
-                    self.lib_version,
-                    check_health=check_health,
+            host = getattr(self, "host", "localhost")
+            port = getattr(self, "port", 6379)
+            if host:
+                # Use getaddrinfo to resolve the hostname to IP
+                # This mimics what the connection would do during _connect()
+                addr_info = socket.getaddrinfo(
+                    host, port, socket.AF_UNSPEC, socket.SOCK_STREAM
                 )
-                self.read_response()
-        except ResponseError:
+                if addr_info:
+                    # Return the IP from the first result
+                    # addr_info[0] is (family, socktype, proto, canonname, sockaddr)
+                    # sockaddr[0] is the IP address
+                    return str(addr_info[0][4][0])
+        except (AttributeError, OSError, socket.gaierror):
+            # DNS resolution might fail
             pass
 
-        # if a database is specified, switch to it
-        if self.db:
-            self.send_command("SELECT", self.db, check_health=check_health)
-            if str_if_bytes(self.read_response()) != "OK":
-                raise ConnectionError("Invalid Database")
+        return None
 
-    def disconnect(self, *args):
-        "Disconnects from the Redis server"
-        self._parser.on_disconnect()
+    @property
+    def maintenance_state(self) -> MaintenanceState:
+        return self._maintenance_state
 
-        conn_sock = self._sock
-        self._sock = None
-        # reset the reconnect flag
-        self._should_reconnect = False
-        if conn_sock is None:
-            return
+    @maintenance_state.setter
+    def maintenance_state(self, state: "MaintenanceState"):
+        self._maintenance_state = state
 
-        if os.getpid() == self.pid:
-            try:
-                conn_sock.shutdown(socket.SHUT_RDWR)
-            except (OSError, TypeError):
-                pass
-
-        try:
-            conn_sock.close()
-        except OSError:
-            pass
-
-    def _send_ping(self):
-        """Send PING, expect PONG in return"""
-        self.send_command("PING", check_health=False)
-        if str_if_bytes(self.read_response()) != "PONG":
-            raise ConnectionError("Bad response from PING health check")
-
-    def _ping_failed(self, error):
-        """Function to call when PING fails"""
-        self.disconnect()
-
-    def check_health(self):
-        """Check the health of the connection with a PING/PONG"""
-        if self.health_check_interval and time.monotonic() > self.next_health_check:
-            self.retry.call_with_retry(self._send_ping, self._ping_failed)
-
-    def send_packed_command(self, command, check_health=True):
-        """Send an already packed command to the Redis server"""
-        if not self._sock:
-            self.connect_check_health(check_health=False)
-        # guard against health check recursion
-        if check_health:
-            self.check_health()
-        try:
-            if isinstance(command, str):
-                command = [command]
-            for item in command:
-                self._sock.sendall(item)
-        except socket.timeout:
-            self.disconnect()
-            raise TimeoutError("Timeout writing to socket")
-        except OSError as e:
-            self.disconnect()
-            if len(e.args) == 1:
-                errno, errmsg = "UNKNOWN", e.args[0]
-            else:
-                errno = e.args[0]
-                errmsg = e.args[1]
-            raise ConnectionError(f"Error {errno} while writing to socket. {errmsg}.")
-        except BaseException:
-            # BaseExceptions can be raised when a socket send operation is not
-            # finished, e.g. due to a timeout.  Ideally, a caller could then re-try
-            # to send un-sent data. However, the send_packed_command() API
-            # does not support it so there is no point in keeping the connection open.
-            self.disconnect()
-            raise
-
-    def send_command(self, *args, **kwargs):
-        """Pack and send a command to the Redis server"""
-        self.send_packed_command(
-            self._command_packer.pack(*args),
-            check_health=kwargs.get("check_health", True),
-        )
-
-    def can_read(self, timeout=0):
-        """Poll the socket to see if there's data that can be read."""
-        sock = self._sock
-        if not sock:
-            self.connect()
-
-        host_error = self._host_error()
-
-        try:
-            return self._parser.can_read(timeout)
-
-        except OSError as e:
-            self.disconnect()
-            raise ConnectionError(f"Error while reading from {host_error}: {e.args}")
-
-    def read_response(
-        self,
-        disable_decoding=False,
-        *,
-        disconnect_on_error=True,
-        push_request=False,
-    ):
-        """Read the response from a previously sent command"""
-
-        host_error = self._host_error()
-
-        try:
-            if self.protocol in ["3", 3]:
-                response = self._parser.read_response(
-                    disable_decoding=disable_decoding, push_request=push_request
-                )
-            else:
-                response = self._parser.read_response(disable_decoding=disable_decoding)
-        except socket.timeout:
-            if disconnect_on_error:
-                self.disconnect()
-            raise TimeoutError(f"Timeout reading from {host_error}")
-        except OSError as e:
-            if disconnect_on_error:
-                self.disconnect()
-            raise ConnectionError(f"Error while reading from {host_error} : {e.args}")
-        except BaseException:
-            # Also by default close in case of BaseException.  A lot of code
-            # relies on this behaviour when doing Command/Response pairs.
-            # See #1128.
-            if disconnect_on_error:
-                self.disconnect()
-            raise
-
-        if self.health_check_interval:
-            self.next_health_check = time.monotonic() + self.health_check_interval
-
-        if isinstance(response, ResponseError):
-            try:
-                raise response
-            finally:
-                del response  # avoid creating ref cycles
-        return response
-
-    def pack_command(self, *args):
-        """Pack a series of arguments into the Redis protocol"""
-        return self._command_packer.pack(*args)
-
-    def pack_commands(self, commands):
-        """Pack multiple commands into the Redis protocol"""
-        output = []
-        pieces = []
-        buffer_length = 0
-        buffer_cutoff = self._buffer_cutoff
-
-        for cmd in commands:
-            for chunk in self._command_packer.pack(*cmd):
-                chunklen = len(chunk)
-                if (
-                    buffer_length > buffer_cutoff
-                    or chunklen > buffer_cutoff
-                    or isinstance(chunk, memoryview)
-                ):
-                    if pieces:
-                        output.append(SYM_EMPTY.join(pieces))
-                    buffer_length = 0
-                    pieces = []
-
-                if chunklen > buffer_cutoff or isinstance(chunk, memoryview):
-                    output.append(chunk)
-                else:
-                    pieces.append(chunk)
-                    buffer_length += chunklen
-
-        if pieces:
-            output.append(SYM_EMPTY.join(pieces))
-        return output
-
-    def get_protocol(self) -> Union[int, str]:
-        return self.protocol
-
-    @property
-    def handshake_metadata(self) -> Union[Dict[bytes, bytes], Dict[str, str]]:
-        return self._handshake_metadata
-
-    @handshake_metadata.setter
-    def handshake_metadata(self, value: Union[Dict[bytes, bytes], Dict[str, str]]):
-        self._handshake_metadata = value
-
-    def set_re_auth_token(self, token: TokenInterface):
-        self._re_auth_token = token
-
-    def re_auth(self):
-        if self._re_auth_token is not None:
-            self.send_command(
-                "AUTH",
-                self._re_auth_token.try_get("oid"),
-                self._re_auth_token.get_value(),
-            )
-            self.read_response()
-            self._re_auth_token = None
-
-    def get_resolved_ip(self) -> Optional[str]:
-        """
-        Extract the resolved IP address from an
-        established connection or resolve it from the host.
-
-        First tries to get the actual IP from the socket (most accurate),
-        then falls back to DNS resolution if needed.
-
-        Args:
-            connection: The connection object to extract the IP from
-
-        Returns:
-            str: The resolved IP address, or None if it cannot be determined
-        """
-
-        # Method 1: Try to get the actual IP from the established socket connection
-        # This is most accurate as it shows the exact IP being used
-        try:
-            if self._sock is not None:
-                peer_addr = self._sock.getpeername()
-                if peer_addr and len(peer_addr) >= 1:
-                    # For TCP sockets, peer_addr is typically (host, port) tuple
-                    # Return just the host part
-                    return peer_addr[0]
-        except (AttributeError, OSError):
-            # Socket might not be connected or getpeername() might fail
-            pass
-
-        # Method 2: Fallback to DNS resolution of the host
-        # This is less accurate but works when socket is not available
-        try:
-            host = getattr(self, "host", "localhost")
-            port = getattr(self, "port", 6379)
-            if host:
-                # Use getaddrinfo to resolve the hostname to IP
-                # This mimics what the connection would do during _connect()
-                addr_info = socket.getaddrinfo(
-                    host, port, socket.AF_UNSPEC, socket.SOCK_STREAM
-                )
-                if addr_info:
-                    # Return the IP from the first result
-                    # addr_info[0] is (family, socktype, proto, canonname, sockaddr)
-                    # sockaddr[0] is the IP address
-                    return addr_info[0][4][0]
-        except (AttributeError, OSError, socket.gaierror):
-            # DNS resolution might fail
-            pass
-
-        return None
-
-    @property
-    def maintenance_state(self) -> MaintenanceState:
-        return self._maintenance_state
-
-    @maintenance_state.setter
-    def maintenance_state(self, state: "MaintenanceState"):
-        self._maintenance_state = state
-
-    def getpeername(self):
-        if not self._sock:
-            return None
-        return self._sock.getpeername()[0]
-
-    def mark_for_reconnect(self):
-        self._should_reconnect = True
-
-    def should_reconnect(self):
-        return self._should_reconnect
+    def getpeername(self):
+        """
+        Returns the peer name of the connection.
+        """
+        conn_socket = self._get_socket()
+        if conn_socket:
+            return conn_socket.getpeername()[0]
+        return None
 
     def update_current_socket_timeout(self, relaxed_timeout: Optional[float] = None):
-        if self._sock:
+        conn_socket = self._get_socket()
+        if conn_socket:
             timeout = relaxed_timeout if relaxed_timeout != -1 else self.socket_timeout
-            self._sock.settimeout(timeout)
-            self.update_parser_buffer_timeout(timeout)
+            conn_socket.settimeout(timeout)
+            self.update_parser_timeout(timeout)
 
-    def update_parser_buffer_timeout(self, timeout: Optional[float] = None):
-        if self._parser and self._parser._buffer:
-            self._parser._buffer.socket_timeout = timeout
+    def update_parser_timeout(self, timeout: Optional[float] = None):
+        parser = self._get_parser()
+        if parser and parser._buffer:
+            if isinstance(parser, _RESP3Parser) and timeout:
+                parser._buffer.socket_timeout = timeout
+            elif isinstance(parser, _HiredisParser):
+                parser._socket_timeout = timeout
 
     def set_tmp_settings(
         self,
@@ -1054,8 +634,8 @@ class AbstractConnection(ConnectionInterface):
         """
         The value of SENTINEL is used to indicate that the property should not be updated.
         """
-        if tmp_host_address is not SENTINEL:
-            self.host = tmp_host_address
+        if tmp_host_address and tmp_host_address != SENTINEL:
+            self.host = str(tmp_host_address)
         if tmp_relaxed_timeout != -1:
             self.socket_timeout = tmp_relaxed_timeout
             self.socket_connect_timeout = tmp_relaxed_timeout
@@ -1072,26 +652,609 @@ class AbstractConnection(ConnectionInterface):
             self.socket_connect_timeout = self.orig_socket_connect_timeout
 
 
-class Connection(AbstractConnection):
-    "Manages TCP communication to and from a Redis server"
+class AbstractConnection(MaintNotificationsAbstractConnection, ConnectionInterface):
+    "Manages communication to and from a Redis server"
 
     def __init__(
         self,
-        host="localhost",
-        port=6379,
-        socket_keepalive=False,
-        socket_keepalive_options=None,
-        socket_type=0,
-        **kwargs,
-    ):
-        self.host = host
-        self.port = int(port)
-        self.socket_keepalive = socket_keepalive
-        self.socket_keepalive_options = socket_keepalive_options or {}
-        self.socket_type = socket_type
-        super().__init__(**kwargs)
-
-    def repr_pieces(self):
+        db: int = 0,
+        password: Optional[str] = None,
+        socket_timeout: Optional[float] = None,
+        socket_connect_timeout: Optional[float] = None,
+        retry_on_timeout: bool = False,
+        retry_on_error: Union[Iterable[Type[Exception]], object] = SENTINEL,
+        encoding: str = "utf-8",
+        encoding_errors: str = "strict",
+        decode_responses: bool = False,
+        parser_class=DefaultParser,
+        socket_read_size: int = 65536,
+        health_check_interval: int = 0,
+        client_name: Optional[str] = None,
+        lib_name: Optional[str] = "redis-py",
+        lib_version: Optional[str] = get_lib_version(),
+        username: Optional[str] = None,
+        retry: Union[Any, None] = None,
+        redis_connect_func: Optional[Callable[[], None]] = None,
+        credential_provider: Optional[CredentialProvider] = None,
+        protocol: Optional[int] = 2,
+        command_packer: Optional[Callable[[], None]] = None,
+        event_dispatcher: Optional[EventDispatcher] = None,
+        maint_notifications_config: Optional[MaintNotificationsConfig] = None,
+        maint_notifications_pool_handler: Optional[
+            MaintNotificationsPoolHandler
+        ] = None,
+        maintenance_state: "MaintenanceState" = MaintenanceState.NONE,
+        maintenance_notification_hash: Optional[int] = None,
+        orig_host_address: Optional[str] = None,
+        orig_socket_timeout: Optional[float] = None,
+        orig_socket_connect_timeout: Optional[float] = None,
+    ):
+        """
+        Initialize a new Connection.
+        To specify a retry policy for specific errors, first set
+        `retry_on_error` to a list of the error/s to retry on, then set
+        `retry` to a valid `Retry` object.
+        To retry on TimeoutError, `retry_on_timeout` can also be set to `True`.
+        """
+        if (username or password) and credential_provider is not None:
+            raise DataError(
+                "'username' and 'password' cannot be passed along with 'credential_"
+                "provider'. Please provide only one of the following arguments: \n"
+                "1. 'password' and (optional) 'username'\n"
+                "2. 'credential_provider'"
+            )
+        if event_dispatcher is None:
+            self._event_dispatcher = EventDispatcher()
+        else:
+            self._event_dispatcher = event_dispatcher
+        self.pid = os.getpid()
+        self.db = db
+        self.client_name = client_name
+        self.lib_name = lib_name
+        self.lib_version = lib_version
+        self.credential_provider = credential_provider
+        self.password = password
+        self.username = username
+        self._socket_timeout = socket_timeout
+        if socket_connect_timeout is None:
+            socket_connect_timeout = socket_timeout
+        self._socket_connect_timeout = socket_connect_timeout
+        self.retry_on_timeout = retry_on_timeout
+        if retry_on_error is SENTINEL:
+            retry_on_errors_list = []
+        else:
+            retry_on_errors_list = list(retry_on_error)
+        if retry_on_timeout:
+            # Add TimeoutError to the errors list to retry on
+            retry_on_errors_list.append(TimeoutError)
+        self.retry_on_error = retry_on_errors_list
+        if retry or self.retry_on_error:
+            if retry is None:
+                self.retry = Retry(NoBackoff(), 1)
+            else:
+                # deep-copy the Retry object as it is mutable
+                self.retry = copy.deepcopy(retry)
+            if self.retry_on_error:
+                # Update the retry's supported errors with the specified errors
+                self.retry.update_supported_errors(self.retry_on_error)
+        else:
+            self.retry = Retry(NoBackoff(), 0)
+        self.health_check_interval = health_check_interval
+        self.next_health_check = 0
+        self.redis_connect_func = redis_connect_func
+        self.encoder = Encoder(encoding, encoding_errors, decode_responses)
+        self.handshake_metadata = None
+        self._sock = None
+        self._socket_read_size = socket_read_size
+        self._connect_callbacks = []
+        self._buffer_cutoff = 6000
+        self._re_auth_token: Optional[TokenInterface] = None
+        try:
+            p = int(protocol)
+        except TypeError:
+            p = DEFAULT_RESP_VERSION
+        except ValueError:
+            raise ConnectionError("protocol must be an integer")
+        finally:
+            if p < 2 or p > 3:
+                raise ConnectionError("protocol must be either 2 or 3")
+                # p = DEFAULT_RESP_VERSION
+            self.protocol = p
+        if self.protocol == 3 and parser_class == _RESP2Parser:
+            # If the protocol is 3 but the parser is RESP2, change it to RESP3
+            # This is needed because the parser might be set before the protocol
+            # or might be provided as a kwarg to the constructor
+            # We need to react on discrepancy only for RESP2 and RESP3
+            # as hiredis supports both
+            parser_class = _RESP3Parser
+        self.set_parser(parser_class)
+
+        self._command_packer = self._construct_command_packer(command_packer)
+        self._should_reconnect = False
+
+        # Set up maintenance notifications
+        MaintNotificationsAbstractConnection.__init__(
+            self,
+            maint_notifications_config,
+            maint_notifications_pool_handler,
+            maintenance_state,
+            maintenance_notification_hash,
+            orig_host_address,
+            orig_socket_timeout,
+            orig_socket_connect_timeout,
+            self._parser,
+        )
+
+    def __repr__(self):
+        repr_args = ",".join([f"{k}={v}" for k, v in self.repr_pieces()])
+        return f"<{self.__class__.__module__}.{self.__class__.__name__}({repr_args})>"
+
+    @abstractmethod
+    def repr_pieces(self):
+        pass
+
+    def __del__(self):
+        try:
+            self.disconnect()
+        except Exception:
+            pass
+
+    def _construct_command_packer(self, packer):
+        if packer is not None:
+            return packer
+        elif HIREDIS_AVAILABLE:
+            return HiredisRespSerializer()
+        else:
+            return PythonRespSerializer(self._buffer_cutoff, self.encoder.encode)
+
+    def register_connect_callback(self, callback):
+        """
+        Register a callback to be called when the connection is established either
+        initially or reconnected.  This allows listeners to issue commands that
+        are ephemeral to the connection, for example pub/sub subscription or
+        key tracking.  The callback must be a _method_ and will be kept as
+        a weak reference.
+        """
+        wm = weakref.WeakMethod(callback)
+        if wm not in self._connect_callbacks:
+            self._connect_callbacks.append(wm)
+
+    def deregister_connect_callback(self, callback):
+        """
+        De-register a previously registered callback.  It will no-longer receive
+        notifications on connection events.  Calling this is not required when the
+        listener goes away, since the callbacks are kept as weak methods.
+        """
+        try:
+            self._connect_callbacks.remove(weakref.WeakMethod(callback))
+        except ValueError:
+            pass
+
+    def set_parser(self, parser_class):
+        """
+        Creates a new instance of parser_class with socket size:
+        _socket_read_size and assigns it to the parser for the connection
+        :param parser_class: The required parser class
+        """
+        self._parser = parser_class(socket_read_size=self._socket_read_size)
+
+    def _get_parser(self) -> Union[_HiredisParser, _RESP3Parser, _RESP2Parser]:
+        return self._parser
+
+    def connect(self):
+        "Connects to the Redis server if not already connected"
+        self.connect_check_health(check_health=True)
+
+    def connect_check_health(
+        self, check_health: bool = True, retry_socket_connect: bool = True
+    ):
+        if self._sock:
+            return
+        try:
+            if retry_socket_connect:
+                sock = self.retry.call_with_retry(
+                    lambda: self._connect(), lambda error: self.disconnect(error)
+                )
+            else:
+                sock = self._connect()
+        except socket.timeout:
+            raise TimeoutError("Timeout connecting to server")
+        except OSError as e:
+            raise ConnectionError(self._error_message(e))
+
+        self._sock = sock
+        try:
+            if self.redis_connect_func is None:
+                # Use the default on_connect function
+                self.on_connect_check_health(check_health=check_health)
+            else:
+                # Use the passed function redis_connect_func
+                self.redis_connect_func(self)
+        except RedisError:
+            # clean up after any error in on_connect
+            self.disconnect()
+            raise
+
+        # run any user callbacks. right now the only internal callback
+        # is for pubsub channel/pattern resubscription
+        # first, remove any dead weakrefs
+        self._connect_callbacks = [ref for ref in self._connect_callbacks if ref()]
+        for ref in self._connect_callbacks:
+            callback = ref()
+            if callback:
+                callback(self)
+
+    @abstractmethod
+    def _connect(self):
+        pass
+
+    @abstractmethod
+    def _host_error(self):
+        pass
+
+    def _error_message(self, exception):
+        return format_error_message(self._host_error(), exception)
+
+    def on_connect(self):
+        self.on_connect_check_health(check_health=True)
+
+    def on_connect_check_health(self, check_health: bool = True):
+        "Initialize the connection, authenticate and select a database"
+        self._parser.on_connect(self)
+        parser = self._parser
+
+        auth_args = None
+        # if credential provider or username and/or password are set, authenticate
+        if self.credential_provider or (self.username or self.password):
+            cred_provider = (
+                self.credential_provider
+                or UsernamePasswordCredentialProvider(self.username, self.password)
+            )
+            auth_args = cred_provider.get_credentials()
+
+        # if resp version is specified and we have auth args,
+        # we need to send them via HELLO
+        if auth_args and self.protocol not in [2, "2"]:
+            if isinstance(self._parser, _RESP2Parser):
+                self.set_parser(_RESP3Parser)
+                # update cluster exception classes
+                self._parser.EXCEPTION_CLASSES = parser.EXCEPTION_CLASSES
+                self._parser.on_connect(self)
+            if len(auth_args) == 1:
+                auth_args = ["default", auth_args[0]]
+            # avoid checking health here -- PING will fail if we try
+            # to check the health prior to the AUTH
+            self.send_command(
+                "HELLO", self.protocol, "AUTH", *auth_args, check_health=False
+            )
+            self.handshake_metadata = self.read_response()
+            # if response.get(b"proto") != self.protocol and response.get(
+            #     "proto"
+            # ) != self.protocol:
+            #     raise ConnectionError("Invalid RESP version")
+        elif auth_args:
+            # avoid checking health here -- PING will fail if we try
+            # to check the health prior to the AUTH
+            self.send_command("AUTH", *auth_args, check_health=False)
+
+            try:
+                auth_response = self.read_response()
+            except AuthenticationWrongNumberOfArgsError:
+                # a username and password were specified but the Redis
+                # server seems to be < 6.0.0 which expects a single password
+                # arg. retry auth with just the password.
+                # https://github.com/andymccurdy/redis-py/issues/1274
+                self.send_command("AUTH", auth_args[-1], check_health=False)
+                auth_response = self.read_response()
+
+            if str_if_bytes(auth_response) != "OK":
+                raise AuthenticationError("Invalid Username or Password")
+
+        # if resp version is specified, switch to it
+        elif self.protocol not in [2, "2"]:
+            if isinstance(self._parser, _RESP2Parser):
+                self.set_parser(_RESP3Parser)
+                # update cluster exception classes
+                self._parser.EXCEPTION_CLASSES = parser.EXCEPTION_CLASSES
+                self._parser.on_connect(self)
+            self.send_command("HELLO", self.protocol, check_health=check_health)
+            self.handshake_metadata = self.read_response()
+            if (
+                self.handshake_metadata.get(b"proto") != self.protocol
+                and self.handshake_metadata.get("proto") != self.protocol
+            ):
+                raise ConnectionError("Invalid RESP version")
+
+        # Activate maintenance notifications for this connection
+        # if enabled in the configuration
+        # This is a no-op if maintenance notifications are not enabled
+        self.activate_maint_notifications_handling_if_enabled(check_health=check_health)
+
+        # if a client_name is given, set it
+        if self.client_name:
+            self.send_command(
+                "CLIENT",
+                "SETNAME",
+                self.client_name,
+                check_health=check_health,
+            )
+            if str_if_bytes(self.read_response()) != "OK":
+                raise ConnectionError("Error setting client name")
+
+        try:
+            # set the library name and version
+            if self.lib_name:
+                self.send_command(
+                    "CLIENT",
+                    "SETINFO",
+                    "LIB-NAME",
+                    self.lib_name,
+                    check_health=check_health,
+                )
+                self.read_response()
+        except ResponseError:
+            pass
+
+        try:
+            if self.lib_version:
+                self.send_command(
+                    "CLIENT",
+                    "SETINFO",
+                    "LIB-VER",
+                    self.lib_version,
+                    check_health=check_health,
+                )
+                self.read_response()
+        except ResponseError:
+            pass
+
+        # if a database is specified, switch to it
+        if self.db:
+            self.send_command("SELECT", self.db, check_health=check_health)
+            if str_if_bytes(self.read_response()) != "OK":
+                raise ConnectionError("Invalid Database")
+
+    def disconnect(self, *args):
+        "Disconnects from the Redis server"
+        self._parser.on_disconnect()
+
+        conn_sock = self._sock
+        self._sock = None
+        # reset the reconnect flag
+        self.reset_should_reconnect()
+        if conn_sock is None:
+            return
+
+        if os.getpid() == self.pid:
+            try:
+                conn_sock.shutdown(socket.SHUT_RDWR)
+            except (OSError, TypeError):
+                pass
+
+        try:
+            conn_sock.close()
+        except OSError:
+            pass
+
+    def mark_for_reconnect(self):
+        self._should_reconnect = True
+
+    def should_reconnect(self):
+        return self._should_reconnect
+
+    def reset_should_reconnect(self):
+        self._should_reconnect = False
+
+    def _send_ping(self):
+        """Send PING, expect PONG in return"""
+        self.send_command("PING", check_health=False)
+        if str_if_bytes(self.read_response()) != "PONG":
+            raise ConnectionError("Bad response from PING health check")
+
+    def _ping_failed(self, error):
+        """Function to call when PING fails"""
+        self.disconnect()
+
+    def check_health(self):
+        """Check the health of the connection with a PING/PONG"""
+        if self.health_check_interval and time.monotonic() > self.next_health_check:
+            self.retry.call_with_retry(self._send_ping, self._ping_failed)
+
+    def send_packed_command(self, command, check_health=True):
+        """Send an already packed command to the Redis server"""
+        if not self._sock:
+            self.connect_check_health(check_health=False)
+        # guard against health check recursion
+        if check_health:
+            self.check_health()
+        try:
+            if isinstance(command, str):
+                command = [command]
+            for item in command:
+                self._sock.sendall(item)
+        except socket.timeout:
+            self.disconnect()
+            raise TimeoutError("Timeout writing to socket")
+        except OSError as e:
+            self.disconnect()
+            if len(e.args) == 1:
+                errno, errmsg = "UNKNOWN", e.args[0]
+            else:
+                errno = e.args[0]
+                errmsg = e.args[1]
+            raise ConnectionError(f"Error {errno} while writing to socket. {errmsg}.")
+        except BaseException:
+            # BaseExceptions can be raised when a socket send operation is not
+            # finished, e.g. due to a timeout.  Ideally, a caller could then re-try
+            # to send un-sent data. However, the send_packed_command() API
+            # does not support it so there is no point in keeping the connection open.
+            self.disconnect()
+            raise
+
+    def send_command(self, *args, **kwargs):
+        """Pack and send a command to the Redis server"""
+        self.send_packed_command(
+            self._command_packer.pack(*args),
+            check_health=kwargs.get("check_health", True),
+        )
+
+    def can_read(self, timeout=0):
+        """Poll the socket to see if there's data that can be read."""
+        sock = self._sock
+        if not sock:
+            self.connect()
+
+        host_error = self._host_error()
+
+        try:
+            return self._parser.can_read(timeout)
+
+        except OSError as e:
+            self.disconnect()
+            raise ConnectionError(f"Error while reading from {host_error}: {e.args}")
+
+    def read_response(
+        self,
+        disable_decoding=False,
+        *,
+        disconnect_on_error=True,
+        push_request=False,
+    ):
+        """Read the response from a previously sent command"""
+
+        host_error = self._host_error()
+
+        try:
+            if self.protocol in ["3", 3]:
+                response = self._parser.read_response(
+                    disable_decoding=disable_decoding, push_request=push_request
+                )
+            else:
+                response = self._parser.read_response(disable_decoding=disable_decoding)
+        except socket.timeout:
+            if disconnect_on_error:
+                self.disconnect()
+            raise TimeoutError(f"Timeout reading from {host_error}")
+        except OSError as e:
+            if disconnect_on_error:
+                self.disconnect()
+            raise ConnectionError(f"Error while reading from {host_error} : {e.args}")
+        except BaseException:
+            # Also by default close in case of BaseException.  A lot of code
+            # relies on this behaviour when doing Command/Response pairs.
+            # See #1128.
+            if disconnect_on_error:
+                self.disconnect()
+            raise
+
+        if self.health_check_interval:
+            self.next_health_check = time.monotonic() + self.health_check_interval
+
+        if isinstance(response, ResponseError):
+            try:
+                raise response
+            finally:
+                del response  # avoid creating ref cycles
+        return response
+
+    def pack_command(self, *args):
+        """Pack a series of arguments into the Redis protocol"""
+        return self._command_packer.pack(*args)
+
+    def pack_commands(self, commands):
+        """Pack multiple commands into the Redis protocol"""
+        output = []
+        pieces = []
+        buffer_length = 0
+        buffer_cutoff = self._buffer_cutoff
+
+        for cmd in commands:
+            for chunk in self._command_packer.pack(*cmd):
+                chunklen = len(chunk)
+                if (
+                    buffer_length > buffer_cutoff
+                    or chunklen > buffer_cutoff
+                    or isinstance(chunk, memoryview)
+                ):
+                    if pieces:
+                        output.append(SYM_EMPTY.join(pieces))
+                    buffer_length = 0
+                    pieces = []
+
+                if chunklen > buffer_cutoff or isinstance(chunk, memoryview):
+                    output.append(chunk)
+                else:
+                    pieces.append(chunk)
+                    buffer_length += chunklen
+
+        if pieces:
+            output.append(SYM_EMPTY.join(pieces))
+        return output
+
+    def get_protocol(self) -> Union[int, str]:
+        return self.protocol
+
+    @property
+    def handshake_metadata(self) -> Union[Dict[bytes, bytes], Dict[str, str]]:
+        return self._handshake_metadata
+
+    @handshake_metadata.setter
+    def handshake_metadata(self, value: Union[Dict[bytes, bytes], Dict[str, str]]):
+        self._handshake_metadata = value
+
+    def set_re_auth_token(self, token: TokenInterface):
+        self._re_auth_token = token
+
+    def re_auth(self):
+        if self._re_auth_token is not None:
+            self.send_command(
+                "AUTH",
+                self._re_auth_token.try_get("oid"),
+                self._re_auth_token.get_value(),
+            )
+            self.read_response()
+            self._re_auth_token = None
+
+    def _get_socket(self) -> Optional[socket.socket]:
+        return self._sock
+
+    @property
+    def socket_timeout(self) -> Optional[Union[float, int]]:
+        return self._socket_timeout
+
+    @socket_timeout.setter
+    def socket_timeout(self, value: Optional[Union[float, int]]):
+        self._socket_timeout = value
+
+    @property
+    def socket_connect_timeout(self) -> Optional[Union[float, int]]:
+        return self._socket_connect_timeout
+
+    @socket_connect_timeout.setter
+    def socket_connect_timeout(self, value: Optional[Union[float, int]]):
+        self._socket_connect_timeout = value
+
+
+class Connection(AbstractConnection):
+    "Manages TCP communication to and from a Redis server"
+
+    def __init__(
+        self,
+        host="localhost",
+        port=6379,
+        socket_keepalive=False,
+        socket_keepalive_options=None,
+        socket_type=0,
+        **kwargs,
+    ):
+        self._host = host
+        self.port = int(port)
+        self.socket_keepalive = socket_keepalive
+        self.socket_keepalive_options = socket_keepalive_options or {}
+        self.socket_type = socket_type
+        super().__init__(**kwargs)
+
+    def repr_pieces(self):
         pieces = [("host", self.host), ("port", self.port), ("db", self.db)]
         if self.client_name:
             pieces.append(("client_name", self.client_name))
@@ -1146,8 +1309,16 @@ class Connection(AbstractConnection):
     def _host_error(self):
         return f"{self.host}:{self.port}"
 
+    @property
+    def host(self) -> str:
+        return self._host
+
+    @host.setter
+    def host(self, value: str):
+        self._host = value
+
 
-class CacheProxyConnection(ConnectionInterface):
+class CacheProxyConnection(MaintNotificationsAbstractConnection, ConnectionInterface):
     DUMMY_CACHE_VALUE = b"foo"
     MIN_ALLOWED_VERSION = "7.4.0"
     DEFAULT_SERVER_NAME = "redis"
@@ -1171,6 +1342,19 @@ class CacheProxyConnection(ConnectionInterface):
         self._current_options = None
         self.register_connect_callback(self._enable_tracking_callback)
 
+        if isinstance(self._conn, MaintNotificationsAbstractConnection):
+            MaintNotificationsAbstractConnection.__init__(
+                self,
+                self._conn.maint_notifications_config,
+                self._conn._maint_notifications_pool_handler,
+                self._conn.maintenance_state,
+                self._conn.maintenance_notification_hash,
+                self._conn.host,
+                self._conn.socket_timeout,
+                self._conn.socket_connect_timeout,
+                self._conn._get_parser(),
+            )
+
     def repr_pieces(self):
         return self._conn.repr_pieces()
 
@@ -1183,6 +1367,17 @@ class CacheProxyConnection(ConnectionInterface):
     def set_parser(self, parser_class):
         self._conn.set_parser(parser_class)
 
+    def set_maint_notifications_pool_handler_for_connection(
+        self, maint_notifications_pool_handler
+    ):
+        if isinstance(self._conn, MaintNotificationsAbstractConnection):
+            self._conn.set_maint_notifications_pool_handler_for_connection(
+                maint_notifications_pool_handler
+            )
+
+    def get_protocol(self):
+        return self._conn.get_protocol()
+
     def connect(self):
         self._conn.connect()
 
@@ -1328,6 +1523,109 @@ class CacheProxyConnection(ConnectionInterface):
     def handshake_metadata(self) -> Union[Dict[bytes, bytes], Dict[str, str]]:
         return self._conn.handshake_metadata
 
+    def set_re_auth_token(self, token: TokenInterface):
+        self._conn.set_re_auth_token(token)
+
+    def re_auth(self):
+        self._conn.re_auth()
+
+    def mark_for_reconnect(self):
+        self._conn.mark_for_reconnect()
+
+    def should_reconnect(self):
+        return self._conn.should_reconnect()
+
+    def reset_should_reconnect(self):
+        self._conn.reset_should_reconnect()
+
+    @property
+    def host(self) -> str:
+        return self._conn.host
+
+    @host.setter
+    def host(self, value: str):
+        self._conn.host = value
+
+    @property
+    def socket_timeout(self) -> Optional[Union[float, int]]:
+        return self._conn.socket_timeout
+
+    @socket_timeout.setter
+    def socket_timeout(self, value: Optional[Union[float, int]]):
+        self._conn.socket_timeout = value
+
+    @property
+    def socket_connect_timeout(self) -> Optional[Union[float, int]]:
+        return self._conn.socket_connect_timeout
+
+    @socket_connect_timeout.setter
+    def socket_connect_timeout(self, value: Optional[Union[float, int]]):
+        self._conn.socket_connect_timeout = value
+
+    def _get_socket(self) -> Optional[socket.socket]:
+        if isinstance(self._conn, MaintNotificationsAbstractConnection):
+            return self._conn._get_socket()
+        else:
+            raise NotImplementedError(
+                "Maintenance notifications are not supported by this connection type"
+            )
+
+    def _get_maint_notifications_connection_instance(
+        self, connection
+    ) -> MaintNotificationsAbstractConnection:
+        """
+        Validate that connection instance supports maintenance notifications.
+        With this helper method we ensure that we are working
+        with the correct connection type.
+        After twe validate that connection instance supports maintenance notifications
+        we can safely return the connection instance
+        as MaintNotificationsAbstractConnection.
+        """
+        if not isinstance(connection, MaintNotificationsAbstractConnection):
+            raise NotImplementedError(
+                "Maintenance notifications are not supported by this connection type"
+            )
+        else:
+            return connection
+
+    @property
+    def maintenance_state(self) -> MaintenanceState:
+        con = self._get_maint_notifications_connection_instance(self._conn)
+        return con.maintenance_state
+
+    @maintenance_state.setter
+    def maintenance_state(self, state: MaintenanceState):
+        con = self._get_maint_notifications_connection_instance(self._conn)
+        con.maintenance_state = state
+
+    def getpeername(self):
+        con = self._get_maint_notifications_connection_instance(self._conn)
+        return con.getpeername()
+
+    def get_resolved_ip(self):
+        con = self._get_maint_notifications_connection_instance(self._conn)
+        return con.get_resolved_ip()
+
+    def update_current_socket_timeout(self, relaxed_timeout: Optional[float] = None):
+        con = self._get_maint_notifications_connection_instance(self._conn)
+        con.update_current_socket_timeout(relaxed_timeout)
+
+    def set_tmp_settings(
+        self,
+        tmp_host_address: Optional[str] = None,
+        tmp_relaxed_timeout: Optional[float] = None,
+    ):
+        con = self._get_maint_notifications_connection_instance(self._conn)
+        con.set_tmp_settings(tmp_host_address, tmp_relaxed_timeout)
+
+    def reset_tmp_settings(
+        self,
+        reset_host_address: bool = False,
+        reset_relaxed_timeout: bool = False,
+    ):
+        con = self._get_maint_notifications_connection_instance(self._conn)
+        con.reset_tmp_settings(reset_host_address, reset_relaxed_timeout)
+
     def _connect(self):
         self._conn._connect()
 
@@ -1351,15 +1649,6 @@ class CacheProxyConnection(ConnectionInterface):
             else:
                 self._cache.delete_by_redis_keys(data[1])
 
-    def get_protocol(self):
-        return self._conn.get_protocol()
-
-    def set_re_auth_token(self, token: TokenInterface):
-        self._conn.set_re_auth_token(token)
-
-    def re_auth(self):
-        self._conn.re_auth()
-
 
 class SSLConnection(Connection):
     """Manages SSL connections to and from the Redis server(s).
@@ -1448,240 +1737,629 @@ class SSLConnection(Connection):
         self.ssl_ciphers = ssl_ciphers
         super().__init__(**kwargs)
 
-    def _connect(self):
-        """
-        Wrap the socket with SSL support, handling potential errors.
-        """
-        sock = super()._connect()
-        try:
-            return self._wrap_socket_with_ssl(sock)
-        except (OSError, RedisError):
-            sock.close()
-            raise
+    def _connect(self):
+        """
+        Wrap the socket with SSL support, handling potential errors.
+        """
+        sock = super()._connect()
+        try:
+            return self._wrap_socket_with_ssl(sock)
+        except (OSError, RedisError):
+            sock.close()
+            raise
+
+    def _wrap_socket_with_ssl(self, sock):
+        """
+        Wraps the socket with SSL support.
+
+        Args:
+            sock: The plain socket to wrap with SSL.
+
+        Returns:
+            An SSL wrapped socket.
+        """
+        context = ssl.create_default_context()
+        context.check_hostname = self.check_hostname
+        context.verify_mode = self.cert_reqs
+        if self.ssl_include_verify_flags:
+            for flag in self.ssl_include_verify_flags:
+                context.verify_flags |= flag
+        if self.ssl_exclude_verify_flags:
+            for flag in self.ssl_exclude_verify_flags:
+                context.verify_flags &= ~flag
+        if self.certfile or self.keyfile:
+            context.load_cert_chain(
+                certfile=self.certfile,
+                keyfile=self.keyfile,
+                password=self.certificate_password,
+            )
+        if (
+            self.ca_certs is not None
+            or self.ca_path is not None
+            or self.ca_data is not None
+        ):
+            context.load_verify_locations(
+                cafile=self.ca_certs, capath=self.ca_path, cadata=self.ca_data
+            )
+        if self.ssl_min_version is not None:
+            context.minimum_version = self.ssl_min_version
+        if self.ssl_ciphers:
+            context.set_ciphers(self.ssl_ciphers)
+        if self.ssl_validate_ocsp is True and CRYPTOGRAPHY_AVAILABLE is False:
+            raise RedisError("cryptography is not installed.")
+
+        if self.ssl_validate_ocsp_stapled and self.ssl_validate_ocsp:
+            raise RedisError(
+                "Either an OCSP staple or pure OCSP connection must be validated "
+                "- not both."
+            )
+
+        sslsock = context.wrap_socket(sock, server_hostname=self.host)
+
+        # validation for the stapled case
+        if self.ssl_validate_ocsp_stapled:
+            import OpenSSL
+
+            from .ocsp import ocsp_staple_verifier
+
+            # if a context is provided use it - otherwise, a basic context
+            if self.ssl_ocsp_context is None:
+                staple_ctx = OpenSSL.SSL.Context(OpenSSL.SSL.SSLv23_METHOD)
+                staple_ctx.use_certificate_file(self.certfile)
+                staple_ctx.use_privatekey_file(self.keyfile)
+            else:
+                staple_ctx = self.ssl_ocsp_context
+
+            staple_ctx.set_ocsp_client_callback(
+                ocsp_staple_verifier, self.ssl_ocsp_expected_cert
+            )
+
+            #  need another socket
+            con = OpenSSL.SSL.Connection(staple_ctx, socket.socket())
+            con.request_ocsp()
+            con.connect((self.host, self.port))
+            con.do_handshake()
+            con.shutdown()
+            return sslsock
+
+        # pure ocsp validation
+        if self.ssl_validate_ocsp is True and CRYPTOGRAPHY_AVAILABLE:
+            from .ocsp import OCSPVerifier
+
+            o = OCSPVerifier(sslsock, self.host, self.port, self.ca_certs)
+            if o.is_valid():
+                return sslsock
+            else:
+                raise ConnectionError("ocsp validation error")
+        return sslsock
+
+
+class UnixDomainSocketConnection(AbstractConnection):
+    "Manages UDS communication to and from a Redis server"
+
+    def __init__(self, path="", socket_timeout=None, **kwargs):
+        super().__init__(**kwargs)
+        self.path = path
+        self.socket_timeout = socket_timeout
+
+    def repr_pieces(self):
+        pieces = [("path", self.path), ("db", self.db)]
+        if self.client_name:
+            pieces.append(("client_name", self.client_name))
+        return pieces
+
+    def _connect(self):
+        "Create a Unix domain socket connection"
+        sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        sock.settimeout(self.socket_connect_timeout)
+        try:
+            sock.connect(self.path)
+        except OSError:
+            # Prevent ResourceWarnings for unclosed sockets.
+            try:
+                sock.shutdown(socket.SHUT_RDWR)  # ensure a clean close
+            except OSError:
+                pass
+            sock.close()
+            raise
+        sock.settimeout(self.socket_timeout)
+        return sock
+
+    def _host_error(self):
+        return self.path
+
+
+FALSE_STRINGS = ("0", "F", "FALSE", "N", "NO")
+
+
+def to_bool(value):
+    if value is None or value == "":
+        return None
+    if isinstance(value, str) and value.upper() in FALSE_STRINGS:
+        return False
+    return bool(value)
+
+
+def parse_ssl_verify_flags(value):
+    # flags are passed in as a string representation of a list,
+    # e.g. VERIFY_X509_STRICT, VERIFY_X509_PARTIAL_CHAIN
+    verify_flags_str = value.replace("[", "").replace("]", "")
+
+    verify_flags = []
+    for flag in verify_flags_str.split(","):
+        flag = flag.strip()
+        if not hasattr(VerifyFlags, flag):
+            raise ValueError(f"Invalid ssl verify flag: {flag}")
+        verify_flags.append(getattr(VerifyFlags, flag))
+    return verify_flags
+
+
+URL_QUERY_ARGUMENT_PARSERS = {
+    "db": int,
+    "socket_timeout": float,
+    "socket_connect_timeout": float,
+    "socket_keepalive": to_bool,
+    "retry_on_timeout": to_bool,
+    "retry_on_error": list,
+    "max_connections": int,
+    "health_check_interval": int,
+    "ssl_check_hostname": to_bool,
+    "ssl_include_verify_flags": parse_ssl_verify_flags,
+    "ssl_exclude_verify_flags": parse_ssl_verify_flags,
+    "timeout": float,
+}
+
+
+def parse_url(url):
+    if not (
+        url.startswith("redis://")
+        or url.startswith("rediss://")
+        or url.startswith("unix://")
+    ):
+        raise ValueError(
+            "Redis URL must specify one of the following "
+            "schemes (redis://, rediss://, unix://)"
+        )
+
+    url = urlparse(url)
+    kwargs = {}
+
+    for name, value in parse_qs(url.query).items():
+        if value and len(value) > 0:
+            value = unquote(value[0])
+            parser = URL_QUERY_ARGUMENT_PARSERS.get(name)
+            if parser:
+                try:
+                    kwargs[name] = parser(value)
+                except (TypeError, ValueError):
+                    raise ValueError(f"Invalid value for '{name}' in connection URL.")
+            else:
+                kwargs[name] = value
+
+    if url.username:
+        kwargs["username"] = unquote(url.username)
+    if url.password:
+        kwargs["password"] = unquote(url.password)
+
+    # We only support redis://, rediss:// and unix:// schemes.
+    if url.scheme == "unix":
+        if url.path:
+            kwargs["path"] = unquote(url.path)
+        kwargs["connection_class"] = UnixDomainSocketConnection
+
+    else:  # implied:  url.scheme in ("redis", "rediss"):
+        if url.hostname:
+            kwargs["host"] = unquote(url.hostname)
+        if url.port:
+            kwargs["port"] = int(url.port)
+
+        # If there's a path argument, use it as the db argument if a
+        # querystring value wasn't specified
+        if url.path and "db" not in kwargs:
+            try:
+                kwargs["db"] = int(unquote(url.path).replace("/", ""))
+            except (AttributeError, ValueError):
+                pass
+
+        if url.scheme == "rediss":
+            kwargs["connection_class"] = SSLConnection
+
+    return kwargs
+
+
+_CP = TypeVar("_CP", bound="ConnectionPool")
+
+
+class ConnectionPoolInterface(ABC):
+    @abstractmethod
+    def get_protocol(self):
+        pass
+
+    @abstractmethod
+    def reset(self):
+        pass
+
+    @abstractmethod
+    @deprecated_args(
+        args_to_warn=["*"],
+        reason="Use get_connection() without args instead",
+        version="5.3.0",
+    )
+    def get_connection(
+        self, command_name: Optional[str], *keys, **options
+    ) -> ConnectionInterface:
+        pass
+
+    @abstractmethod
+    def get_encoder(self):
+        pass
 
-    def _wrap_socket_with_ssl(self, sock):
-        """
-        Wraps the socket with SSL support.
+    @abstractmethod
+    def release(self, connection: ConnectionInterface):
+        pass
 
-        Args:
-            sock: The plain socket to wrap with SSL.
+    @abstractmethod
+    def disconnect(self, inuse_connections: bool = True):
+        pass
 
-        Returns:
-            An SSL wrapped socket.
-        """
-        context = ssl.create_default_context()
-        context.check_hostname = self.check_hostname
-        context.verify_mode = self.cert_reqs
-        if self.ssl_include_verify_flags:
-            for flag in self.ssl_include_verify_flags:
-                context.verify_flags |= flag
-        if self.ssl_exclude_verify_flags:
-            for flag in self.ssl_exclude_verify_flags:
-                context.verify_flags &= ~flag
-        if self.certfile or self.keyfile:
-            context.load_cert_chain(
-                certfile=self.certfile,
-                keyfile=self.keyfile,
-                password=self.certificate_password,
-            )
-        if (
-            self.ca_certs is not None
-            or self.ca_path is not None
-            or self.ca_data is not None
-        ):
-            context.load_verify_locations(
-                cafile=self.ca_certs, capath=self.ca_path, cadata=self.ca_data
-            )
-        if self.ssl_min_version is not None:
-            context.minimum_version = self.ssl_min_version
-        if self.ssl_ciphers:
-            context.set_ciphers(self.ssl_ciphers)
-        if self.ssl_validate_ocsp is True and CRYPTOGRAPHY_AVAILABLE is False:
-            raise RedisError("cryptography is not installed.")
+    @abstractmethod
+    def close(self):
+        pass
 
-        if self.ssl_validate_ocsp_stapled and self.ssl_validate_ocsp:
-            raise RedisError(
-                "Either an OCSP staple or pure OCSP connection must be validated "
-                "- not both."
-            )
+    @abstractmethod
+    def set_retry(self, retry: Retry):
+        pass
 
-        sslsock = context.wrap_socket(sock, server_hostname=self.host)
+    @abstractmethod
+    def re_auth_callback(self, token: TokenInterface):
+        pass
 
-        # validation for the stapled case
-        if self.ssl_validate_ocsp_stapled:
-            import OpenSSL
 
-            from .ocsp import ocsp_staple_verifier
+class MaintNotificationsAbstractConnectionPool:
+    """
+    Abstract class for handling maintenance notifications logic.
+    This class is mixed into the ConnectionPool classes.
 
-            # if a context is provided use it - otherwise, a basic context
-            if self.ssl_ocsp_context is None:
-                staple_ctx = OpenSSL.SSL.Context(OpenSSL.SSL.SSLv23_METHOD)
-                staple_ctx.use_certificate_file(self.certfile)
-                staple_ctx.use_privatekey_file(self.keyfile)
-            else:
-                staple_ctx = self.ssl_ocsp_context
+    This class is not intended to be used directly!
 
-            staple_ctx.set_ocsp_client_callback(
-                ocsp_staple_verifier, self.ssl_ocsp_expected_cert
+    All logic related to maintenance notifications and
+    connection pool handling is encapsulated in this class.
+    """
+
+    def __init__(
+        self,
+        maint_notifications_config: Optional[MaintNotificationsConfig] = None,
+        **kwargs,
+    ):
+        # Initialize maintenance notifications
+        is_protocol_supported = kwargs.get("protocol") in [3, "3"]
+        if maint_notifications_config is None and is_protocol_supported:
+            maint_notifications_config = MaintNotificationsConfig()
+
+        if maint_notifications_config and maint_notifications_config.enabled:
+            if not is_protocol_supported:
+                raise RedisError(
+                    "Maintenance notifications handlers on connection are only supported with RESP version 3"
+                )
+
+            self._maint_notifications_pool_handler = MaintNotificationsPoolHandler(
+                self, maint_notifications_config
             )
 
-            #  need another socket
-            con = OpenSSL.SSL.Connection(staple_ctx, socket.socket())
-            con.request_ocsp()
-            con.connect((self.host, self.port))
-            con.do_handshake()
-            con.shutdown()
-            return sslsock
+            self._update_connection_kwargs_for_maint_notifications(
+                self._maint_notifications_pool_handler
+            )
+        else:
+            self._maint_notifications_pool_handler = None
 
-        # pure ocsp validation
-        if self.ssl_validate_ocsp is True and CRYPTOGRAPHY_AVAILABLE:
-            from .ocsp import OCSPVerifier
+    @property
+    @abstractmethod
+    def connection_kwargs(self) -> Dict[str, Any]:
+        pass
 
-            o = OCSPVerifier(sslsock, self.host, self.port, self.ca_certs)
-            if o.is_valid():
-                return sslsock
-            else:
-                raise ConnectionError("ocsp validation error")
-        return sslsock
+    @connection_kwargs.setter
+    @abstractmethod
+    def connection_kwargs(self, value: Dict[str, Any]):
+        pass
 
+    @abstractmethod
+    def _get_pool_lock(self) -> threading.RLock:
+        pass
 
-class UnixDomainSocketConnection(AbstractConnection):
-    "Manages UDS communication to and from a Redis server"
+    @abstractmethod
+    def _get_free_connections(self) -> Iterable["MaintNotificationsAbstractConnection"]:
+        pass
 
-    def __init__(self, path="", socket_timeout=None, **kwargs):
-        super().__init__(**kwargs)
-        self.path = path
-        self.socket_timeout = socket_timeout
+    @abstractmethod
+    def _get_in_use_connections(
+        self,
+    ) -> Iterable["MaintNotificationsAbstractConnection"]:
+        pass
 
-    def repr_pieces(self):
-        pieces = [("path", self.path), ("db", self.db)]
-        if self.client_name:
-            pieces.append(("client_name", self.client_name))
-        return pieces
+    def maint_notifications_enabled(self):
+        """
+        Returns:
+            True if the maintenance notifications are enabled, False otherwise.
+            The maintenance notifications config is stored in the pool handler.
+            If the pool handler is not set, the maintenance notifications are not enabled.
+        """
+        maint_notifications_config = (
+            self._maint_notifications_pool_handler.config
+            if self._maint_notifications_pool_handler
+            else None
+        )
 
-    def _connect(self):
-        "Create a Unix domain socket connection"
-        sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
-        sock.settimeout(self.socket_connect_timeout)
-        try:
-            sock.connect(self.path)
-        except OSError:
-            # Prevent ResourceWarnings for unclosed sockets.
-            try:
-                sock.shutdown(socket.SHUT_RDWR)  # ensure a clean close
-            except OSError:
-                pass
-            sock.close()
-            raise
-        sock.settimeout(self.socket_timeout)
-        return sock
+        return maint_notifications_config and maint_notifications_config.enabled
 
-    def _host_error(self):
-        return self.path
+    def update_maint_notifications_config(
+        self, maint_notifications_config: MaintNotificationsConfig
+    ):
+        """
+        Updates the maintenance notifications configuration.
+        This method should be called only if the pool was created
+        without enabling the maintenance notifications and
+        in a later point in time maintenance notifications
+        are requested to be enabled.
+        """
+        if (
+            self.maint_notifications_enabled()
+            and not maint_notifications_config.enabled
+        ):
+            raise ValueError(
+                "Cannot disable maintenance notifications after enabling them"
+            )
+        # first update pool settings
+        if not self._maint_notifications_pool_handler:
+            self._maint_notifications_pool_handler = MaintNotificationsPoolHandler(
+                self, maint_notifications_config
+            )
+        else:
+            self._maint_notifications_pool_handler.config = maint_notifications_config
 
+        # then update connection kwargs and existing connections
+        self._update_connection_kwargs_for_maint_notifications(
+            self._maint_notifications_pool_handler
+        )
+        self._update_maint_notifications_configs_for_connections(
+            self._maint_notifications_pool_handler
+        )
 
-FALSE_STRINGS = ("0", "F", "FALSE", "N", "NO")
+    def _update_connection_kwargs_for_maint_notifications(
+        self, maint_notifications_pool_handler: MaintNotificationsPoolHandler
+    ):
+        """
+        Update the connection kwargs for all future connections.
+        """
+        if not self.maint_notifications_enabled():
+            return
 
+        self.connection_kwargs.update(
+            {
+                "maint_notifications_pool_handler": maint_notifications_pool_handler,
+                "maint_notifications_config": maint_notifications_pool_handler.config,
+            }
+        )
 
-def to_bool(value):
-    if value is None or value == "":
-        return None
-    if isinstance(value, str) and value.upper() in FALSE_STRINGS:
-        return False
-    return bool(value)
+        # Store original connection parameters for maintenance notifications.
+        if self.connection_kwargs.get("orig_host_address", None) is None:
+            # If orig_host_address is None it means we haven't
+            # configured the original values yet
+            self.connection_kwargs.update(
+                {
+                    "orig_host_address": self.connection_kwargs.get("host"),
+                    "orig_socket_timeout": self.connection_kwargs.get(
+                        "socket_timeout", None
+                    ),
+                    "orig_socket_connect_timeout": self.connection_kwargs.get(
+                        "socket_connect_timeout", None
+                    ),
+                }
+            )
+
+    def _update_maint_notifications_configs_for_connections(
+        self, maint_notifications_pool_handler: MaintNotificationsPoolHandler
+    ):
+        """Update the maintenance notifications config for all connections in the pool."""
+        with self._get_pool_lock():
+            for conn in self._get_free_connections():
+                conn.set_maint_notifications_pool_handler_for_connection(
+                    maint_notifications_pool_handler
+                )
+                conn.maint_notifications_config = (
+                    maint_notifications_pool_handler.config
+                )
+                conn.disconnect()
+            for conn in self._get_in_use_connections():
+                conn.set_maint_notifications_pool_handler_for_connection(
+                    maint_notifications_pool_handler
+                )
+                conn.maint_notifications_config = (
+                    maint_notifications_pool_handler.config
+                )
+                conn.mark_for_reconnect()
+
+    def _should_update_connection(
+        self,
+        conn: "MaintNotificationsAbstractConnection",
+        matching_pattern: Literal[
+            "connected_address", "configured_address", "notification_hash"
+        ] = "connected_address",
+        matching_address: Optional[str] = None,
+        matching_notification_hash: Optional[int] = None,
+    ) -> bool:
+        """
+        Check if the connection should be updated based on the matching criteria.
+        """
+        if matching_pattern == "connected_address":
+            if matching_address and conn.getpeername() != matching_address:
+                return False
+        elif matching_pattern == "configured_address":
+            if matching_address and conn.host != matching_address:
+                return False
+        elif matching_pattern == "notification_hash":
+            if (
+                matching_notification_hash
+                and conn.maintenance_notification_hash != matching_notification_hash
+            ):
+                return False
+        return True
 
+    def update_connection_settings(
+        self,
+        conn: "MaintNotificationsAbstractConnection",
+        state: Optional["MaintenanceState"] = None,
+        maintenance_notification_hash: Optional[int] = None,
+        host_address: Optional[str] = None,
+        relaxed_timeout: Optional[float] = None,
+        update_notification_hash: bool = False,
+        reset_host_address: bool = False,
+        reset_relaxed_timeout: bool = False,
+    ):
+        """
+        Update the settings for a single connection.
+        """
+        if state:
+            conn.maintenance_state = state
 
-def parse_ssl_verify_flags(value):
-    # flags are passed in as a string representation of a list,
-    # e.g. VERIFY_X509_STRICT, VERIFY_X509_PARTIAL_CHAIN
-    verify_flags_str = value.replace("[", "").replace("]", "")
+        if update_notification_hash:
+            # update the notification hash only if requested
+            conn.maintenance_notification_hash = maintenance_notification_hash
 
-    verify_flags = []
-    for flag in verify_flags_str.split(","):
-        flag = flag.strip()
-        if not hasattr(VerifyFlags, flag):
-            raise ValueError(f"Invalid ssl verify flag: {flag}")
-        verify_flags.append(getattr(VerifyFlags, flag))
-    return verify_flags
+        if host_address is not None:
+            conn.set_tmp_settings(tmp_host_address=host_address)
 
+        if relaxed_timeout is not None:
+            conn.set_tmp_settings(tmp_relaxed_timeout=relaxed_timeout)
 
-URL_QUERY_ARGUMENT_PARSERS = {
-    "db": int,
-    "socket_timeout": float,
-    "socket_connect_timeout": float,
-    "socket_keepalive": to_bool,
-    "retry_on_timeout": to_bool,
-    "retry_on_error": list,
-    "max_connections": int,
-    "health_check_interval": int,
-    "ssl_check_hostname": to_bool,
-    "ssl_include_verify_flags": parse_ssl_verify_flags,
-    "ssl_exclude_verify_flags": parse_ssl_verify_flags,
-    "timeout": float,
-}
+        if reset_relaxed_timeout or reset_host_address:
+            conn.reset_tmp_settings(
+                reset_host_address=reset_host_address,
+                reset_relaxed_timeout=reset_relaxed_timeout,
+            )
 
+        conn.update_current_socket_timeout(relaxed_timeout)
 
-def parse_url(url):
-    if not (
-        url.startswith("redis://")
-        or url.startswith("rediss://")
-        or url.startswith("unix://")
+    def update_connections_settings(
+        self,
+        state: Optional["MaintenanceState"] = None,
+        maintenance_notification_hash: Optional[int] = None,
+        host_address: Optional[str] = None,
+        relaxed_timeout: Optional[float] = None,
+        matching_address: Optional[str] = None,
+        matching_notification_hash: Optional[int] = None,
+        matching_pattern: Literal[
+            "connected_address", "configured_address", "notification_hash"
+        ] = "connected_address",
+        update_notification_hash: bool = False,
+        reset_host_address: bool = False,
+        reset_relaxed_timeout: bool = False,
+        include_free_connections: bool = True,
     ):
-        raise ValueError(
-            "Redis URL must specify one of the following "
-            "schemes (redis://, rediss://, unix://)"
-        )
-
-    url = urlparse(url)
-    kwargs = {}
+        """
+        Update the settings for all matching connections in the pool.
 
-    for name, value in parse_qs(url.query).items():
-        if value and len(value) > 0:
-            value = unquote(value[0])
-            parser = URL_QUERY_ARGUMENT_PARSERS.get(name)
-            if parser:
-                try:
-                    kwargs[name] = parser(value)
-                except (TypeError, ValueError):
-                    raise ValueError(f"Invalid value for '{name}' in connection URL.")
-            else:
-                kwargs[name] = value
+        This method does not create new connections.
+        This method does not affect the connection kwargs.
 
-    if url.username:
-        kwargs["username"] = unquote(url.username)
-    if url.password:
-        kwargs["password"] = unquote(url.password)
+        :param state: The maintenance state to set for the connection.
+        :param maintenance_notification_hash: The hash of the maintenance notification
+                                               to set for the connection.
+        :param host_address: The host address to set for the connection.
+        :param relaxed_timeout: The relaxed timeout to set for the connection.
+        :param matching_address: The address to match for the connection.
+        :param matching_notification_hash: The notification hash to match for the connection.
+        :param matching_pattern: The pattern to match for the connection.
+        :param update_notification_hash: Whether to update the notification hash for the connection.
+        :param reset_host_address: Whether to reset the host address to the original address.
+        :param reset_relaxed_timeout: Whether to reset the relaxed timeout to the original timeout.
+        :param include_free_connections: Whether to include free/available connections.
+        """
+        with self._get_pool_lock():
+            for conn in self._get_in_use_connections():
+                if self._should_update_connection(
+                    conn,
+                    matching_pattern,
+                    matching_address,
+                    matching_notification_hash,
+                ):
+                    self.update_connection_settings(
+                        conn,
+                        state=state,
+                        maintenance_notification_hash=maintenance_notification_hash,
+                        host_address=host_address,
+                        relaxed_timeout=relaxed_timeout,
+                        update_notification_hash=update_notification_hash,
+                        reset_host_address=reset_host_address,
+                        reset_relaxed_timeout=reset_relaxed_timeout,
+                    )
 
-    # We only support redis://, rediss:// and unix:// schemes.
-    if url.scheme == "unix":
-        if url.path:
-            kwargs["path"] = unquote(url.path)
-        kwargs["connection_class"] = UnixDomainSocketConnection
+            if include_free_connections:
+                for conn in self._get_free_connections():
+                    if self._should_update_connection(
+                        conn,
+                        matching_pattern,
+                        matching_address,
+                        matching_notification_hash,
+                    ):
+                        self.update_connection_settings(
+                            conn,
+                            state=state,
+                            maintenance_notification_hash=maintenance_notification_hash,
+                            host_address=host_address,
+                            relaxed_timeout=relaxed_timeout,
+                            update_notification_hash=update_notification_hash,
+                            reset_host_address=reset_host_address,
+                            reset_relaxed_timeout=reset_relaxed_timeout,
+                        )
 
-    else:  # implied:  url.scheme in ("redis", "rediss"):
-        if url.hostname:
-            kwargs["host"] = unquote(url.hostname)
-        if url.port:
-            kwargs["port"] = int(url.port)
+    def update_connection_kwargs(
+        self,
+        **kwargs,
+    ):
+        """
+        Update the connection kwargs for all future connections.
 
-        # If there's a path argument, use it as the db argument if a
-        # querystring value wasn't specified
-        if url.path and "db" not in kwargs:
-            try:
-                kwargs["db"] = int(unquote(url.path).replace("/", ""))
-            except (AttributeError, ValueError):
-                pass
+        This method updates the connection kwargs for all future connections created by the pool.
+        Existing connections are not affected.
+        """
+        self.connection_kwargs.update(kwargs)
 
-        if url.scheme == "rediss":
-            kwargs["connection_class"] = SSLConnection
+    def update_active_connections_for_reconnect(
+        self,
+        moving_address_src: Optional[str] = None,
+    ):
+        """
+        Mark all active connections for reconnect.
+        This is used when a cluster node is migrated to a different address.
 
-    return kwargs
+        :param moving_address_src: The address of the node that is being moved.
+        """
+        with self._get_pool_lock():
+            for conn in self._get_in_use_connections():
+                if self._should_update_connection(
+                    conn, "connected_address", moving_address_src
+                ):
+                    conn.mark_for_reconnect()
 
+    def disconnect_free_connections(
+        self,
+        moving_address_src: Optional[str] = None,
+    ):
+        """
+        Disconnect all free/available connections.
+        This is used when a cluster node is migrated to a different address.
 
-_CP = TypeVar("_CP", bound="ConnectionPool")
+        :param moving_address_src: The address of the node that is being moved.
+        """
+        with self._get_pool_lock():
+            for conn in self._get_free_connections():
+                if self._should_update_connection(
+                    conn, "connected_address", moving_address_src
+                ):
+                    conn.disconnect()
 
 
-class ConnectionPool:
+class ConnectionPool(MaintNotificationsAbstractConnectionPool, ConnectionPoolInterface):
     """
     Create a connection pool. ``If max_connections`` is set, then this
     object raises :py:class:`~redis.exceptions.ConnectionError` when the pool's
@@ -1692,6 +2370,12 @@ class ConnectionPool:
     unix sockets.
     :py:class:`~redis.SSLConnection` can be used for SSL enabled connections.
 
+    If ``maint_notifications_config`` is provided, the connection pool will support
+    maintenance notifications.
+    Maintenance notifications are supported only with RESP3.
+    If the ``maint_notifications_config`` is not provided but the ``protocol`` is 3,
+    the maintenance notifications will be enabled by default.
+
     Any additional keyword arguments are passed to the constructor of
     ``connection_class``.
     """
@@ -1750,6 +2434,7 @@ class ConnectionPool:
         connection_class=Connection,
         max_connections: Optional[int] = None,
         cache_factory: Optional[CacheFactoryInterface] = None,
+        maint_notifications_config: Optional[MaintNotificationsConfig] = None,
         **connection_kwargs,
     ):
         max_connections = max_connections or 2**31
@@ -1757,16 +2442,16 @@ class ConnectionPool:
             raise ValueError('"max_connections" must be a positive integer')
 
         self.connection_class = connection_class
-        self.connection_kwargs = connection_kwargs
+        self._connection_kwargs = connection_kwargs
         self.max_connections = max_connections
         self.cache = None
         self._cache_factory = cache_factory
 
         if connection_kwargs.get("cache_config") or connection_kwargs.get("cache"):
-            if self.connection_kwargs.get("protocol") not in [3, "3"]:
+            if self._connection_kwargs.get("protocol") not in [3, "3"]:
                 raise RedisError("Client caching is only supported with RESP version 3")
 
-            cache = self.connection_kwargs.get("cache")
+            cache = self._connection_kwargs.get("cache")
 
             if cache is not None:
                 if not isinstance(cache, CacheInterface):
@@ -1778,29 +2463,13 @@ class ConnectionPool:
                     self.cache = self._cache_factory.get_cache()
                 else:
                     self.cache = CacheFactory(
-                        self.connection_kwargs.get("cache_config")
+                        self._connection_kwargs.get("cache_config")
                     ).get_cache()
 
         connection_kwargs.pop("cache", None)
         connection_kwargs.pop("cache_config", None)
 
-        if self.connection_kwargs.get(
-            "maint_notifications_pool_handler"
-        ) or self.connection_kwargs.get("maint_notifications_config"):
-            if self.connection_kwargs.get("protocol") not in [3, "3"]:
-                raise RedisError(
-                    "Push handlers on connection are only supported with RESP version 3"
-                )
-            config = self.connection_kwargs.get("maint_notifications_config", None) or (
-                self.connection_kwargs.get("maint_notifications_pool_handler").config
-                if self.connection_kwargs.get("maint_notifications_pool_handler")
-                else None
-            )
-
-            if config and config.enabled:
-                self._update_connection_kwargs_for_maint_notifications()
-
-        self._event_dispatcher = self.connection_kwargs.get("event_dispatcher", None)
+        self._event_dispatcher = self._connection_kwargs.get("event_dispatcher", None)
         if self._event_dispatcher is None:
             self._event_dispatcher = EventDispatcher()
 
@@ -1816,6 +2485,12 @@ class ConnectionPool:
         self._fork_lock = threading.RLock()
         self._lock = threading.RLock()
 
+        MaintNotificationsAbstractConnectionPool.__init__(
+            self,
+            maint_notifications_config=maint_notifications_config,
+            **connection_kwargs,
+        )
+
         self.reset()
 
     def __repr__(self) -> str:
@@ -1826,76 +2501,21 @@ class ConnectionPool:
             f"({conn_kwargs})>)>"
         )
 
+    @property
+    def connection_kwargs(self) -> Dict[str, Any]:
+        return self._connection_kwargs
+
+    @connection_kwargs.setter
+    def connection_kwargs(self, value: Dict[str, Any]):
+        self._connection_kwargs = value
+
     def get_protocol(self):
         """
         Returns:
             The RESP protocol version, or ``None`` if the protocol is not specified,
             in which case the server default will be used.
-        """
-        return self.connection_kwargs.get("protocol", None)
-
-    def maint_notifications_pool_handler_enabled(self):
-        """
-        Returns:
-            True if the maintenance notifications pool handler is enabled, False otherwise.
-        """
-        maint_notifications_config = self.connection_kwargs.get(
-            "maint_notifications_config", None
-        )
-
-        return maint_notifications_config and maint_notifications_config.enabled
-
-    def set_maint_notifications_pool_handler(
-        self, maint_notifications_pool_handler: MaintNotificationsPoolHandler
-    ):
-        self.connection_kwargs.update(
-            {
-                "maint_notifications_pool_handler": maint_notifications_pool_handler,
-                "maint_notifications_config": maint_notifications_pool_handler.config,
-            }
-        )
-        self._update_connection_kwargs_for_maint_notifications()
-
-        self._update_maint_notifications_configs_for_connections(
-            maint_notifications_pool_handler
-        )
-
-    def _update_maint_notifications_configs_for_connections(
-        self, maint_notifications_pool_handler
-    ):
-        """Update the maintenance notifications config for all connections in the pool."""
-        with self._lock:
-            for conn in self._available_connections:
-                conn.set_maint_notifications_pool_handler(
-                    maint_notifications_pool_handler
-                )
-                conn.maint_notifications_config = (
-                    maint_notifications_pool_handler.config
-                )
-            for conn in self._in_use_connections:
-                conn.set_maint_notifications_pool_handler(
-                    maint_notifications_pool_handler
-                )
-                conn.maint_notifications_config = (
-                    maint_notifications_pool_handler.config
-                )
-
-    def _update_connection_kwargs_for_maint_notifications(self):
-        """Store original connection parameters for maintenance notifications."""
-        if self.connection_kwargs.get("orig_host_address", None) is None:
-            # If orig_host_address is None it means we haven't
-            # configured the original values yet
-            self.connection_kwargs.update(
-                {
-                    "orig_host_address": self.connection_kwargs.get("host"),
-                    "orig_socket_timeout": self.connection_kwargs.get(
-                        "socket_timeout", None
-                    ),
-                    "orig_socket_connect_timeout": self.connection_kwargs.get(
-                        "socket_connect_timeout", None
-                    ),
-                }
-            )
+        """
+        return self.connection_kwargs.get("protocol", None)
 
     def reset(self) -> None:
         self._created_connections = 0
@@ -1987,7 +2607,7 @@ class ConnectionPool:
                 if (
                     connection.can_read()
                     and self.cache is None
-                    and not self.maint_notifications_pool_handler_enabled()
+                    and not self.maint_notifications_enabled()
                 ):
                     raise ConnectionError("Connection has data")
             except (ConnectionError, TimeoutError, OSError):
@@ -2059,7 +2679,7 @@ class ConnectionPool:
         Disconnects connections in the pool
 
         If ``inuse_connections`` is True, disconnect connections that are
-        current in use, potentially by other threads. Otherwise only disconnect
+        currently in use, potentially by other threads. Otherwise only disconnect
         connections that are idle in the pool.
         """
         self._checkpid()
@@ -2100,185 +2720,16 @@ class ConnectionPool:
             for conn in self._in_use_connections:
                 conn.set_re_auth_token(token)
 
-    def _should_update_connection(
-        self,
-        conn: "Connection",
-        matching_pattern: Literal[
-            "connected_address", "configured_address", "notification_hash"
-        ] = "connected_address",
-        matching_address: Optional[str] = None,
-        matching_notification_hash: Optional[int] = None,
-    ) -> bool:
-        """
-        Check if the connection should be updated based on the matching criteria.
-        """
-        if matching_pattern == "connected_address":
-            if matching_address and conn.getpeername() != matching_address:
-                return False
-        elif matching_pattern == "configured_address":
-            if matching_address and conn.host != matching_address:
-                return False
-        elif matching_pattern == "notification_hash":
-            if (
-                matching_notification_hash
-                and conn.maintenance_notification_hash != matching_notification_hash
-            ):
-                return False
-        return True
-
-    def update_connection_settings(
-        self,
-        conn: "Connection",
-        state: Optional["MaintenanceState"] = None,
-        maintenance_notification_hash: Optional[int] = None,
-        host_address: Optional[str] = None,
-        relaxed_timeout: Optional[float] = None,
-        update_notification_hash: bool = False,
-        reset_host_address: bool = False,
-        reset_relaxed_timeout: bool = False,
-    ):
-        """
-        Update the settings for a single connection.
-        """
-        if state:
-            conn.maintenance_state = state
-
-        if update_notification_hash:
-            # update the notification hash only if requested
-            conn.maintenance_notification_hash = maintenance_notification_hash
-
-        if host_address is not None:
-            conn.set_tmp_settings(tmp_host_address=host_address)
-
-        if relaxed_timeout is not None:
-            conn.set_tmp_settings(tmp_relaxed_timeout=relaxed_timeout)
-
-        if reset_relaxed_timeout or reset_host_address:
-            conn.reset_tmp_settings(
-                reset_host_address=reset_host_address,
-                reset_relaxed_timeout=reset_relaxed_timeout,
-            )
-
-        conn.update_current_socket_timeout(relaxed_timeout)
-
-    def update_connections_settings(
-        self,
-        state: Optional["MaintenanceState"] = None,
-        maintenance_notification_hash: Optional[int] = None,
-        host_address: Optional[str] = None,
-        relaxed_timeout: Optional[float] = None,
-        matching_address: Optional[str] = None,
-        matching_notification_hash: Optional[int] = None,
-        matching_pattern: Literal[
-            "connected_address", "configured_address", "notification_hash"
-        ] = "connected_address",
-        update_notification_hash: bool = False,
-        reset_host_address: bool = False,
-        reset_relaxed_timeout: bool = False,
-        include_free_connections: bool = True,
-    ):
-        """
-        Update the settings for all matching connections in the pool.
-
-        This method does not create new connections.
-        This method does not affect the connection kwargs.
-
-        :param state: The maintenance state to set for the connection.
-        :param maintenance_notification_hash: The hash of the maintenance notification
-                                               to set for the connection.
-        :param host_address: The host address to set for the connection.
-        :param relaxed_timeout: The relaxed timeout to set for the connection.
-        :param matching_address: The address to match for the connection.
-        :param matching_notification_hash: The notification hash to match for the connection.
-        :param matching_pattern: The pattern to match for the connection.
-        :param update_notification_hash: Whether to update the notification hash for the connection.
-        :param reset_host_address: Whether to reset the host address to the original address.
-        :param reset_relaxed_timeout: Whether to reset the relaxed timeout to the original timeout.
-        :param include_free_connections: Whether to include free/available connections.
-        """
-        with self._lock:
-            for conn in self._in_use_connections:
-                if self._should_update_connection(
-                    conn,
-                    matching_pattern,
-                    matching_address,
-                    matching_notification_hash,
-                ):
-                    self.update_connection_settings(
-                        conn,
-                        state=state,
-                        maintenance_notification_hash=maintenance_notification_hash,
-                        host_address=host_address,
-                        relaxed_timeout=relaxed_timeout,
-                        update_notification_hash=update_notification_hash,
-                        reset_host_address=reset_host_address,
-                        reset_relaxed_timeout=reset_relaxed_timeout,
-                    )
-
-            if include_free_connections:
-                for conn in self._available_connections:
-                    if self._should_update_connection(
-                        conn,
-                        matching_pattern,
-                        matching_address,
-                        matching_notification_hash,
-                    ):
-                        self.update_connection_settings(
-                            conn,
-                            state=state,
-                            maintenance_notification_hash=maintenance_notification_hash,
-                            host_address=host_address,
-                            relaxed_timeout=relaxed_timeout,
-                            update_notification_hash=update_notification_hash,
-                            reset_host_address=reset_host_address,
-                            reset_relaxed_timeout=reset_relaxed_timeout,
-                        )
-
-    def update_connection_kwargs(
-        self,
-        **kwargs,
-    ):
-        """
-        Update the connection kwargs for all future connections.
-
-        This method updates the connection kwargs for all future connections created by the pool.
-        Existing connections are not affected.
-        """
-        self.connection_kwargs.update(kwargs)
-
-    def update_active_connections_for_reconnect(
-        self,
-        moving_address_src: Optional[str] = None,
-    ):
-        """
-        Mark all active connections for reconnect.
-        This is used when a cluster node is migrated to a different address.
+    def _get_pool_lock(self):
+        return self._lock
 
-        :param moving_address_src: The address of the node that is being moved.
-        """
+    def _get_free_connections(self):
         with self._lock:
-            for conn in self._in_use_connections:
-                if self._should_update_connection(
-                    conn, "connected_address", moving_address_src
-                ):
-                    conn.mark_for_reconnect()
-
-    def disconnect_free_connections(
-        self,
-        moving_address_src: Optional[str] = None,
-    ):
-        """
-        Disconnect all free/available connections.
-        This is used when a cluster node is migrated to a different address.
+            return self._available_connections
 
-        :param moving_address_src: The address of the node that is being moved.
-        """
+    def _get_in_use_connections(self):
         with self._lock:
-            for conn in self._available_connections:
-                if self._should_update_connection(
-                    conn, "connected_address", moving_address_src
-                ):
-                    conn.disconnect()
+            return self._in_use_connections
 
     async def _mock(self, error: RedisError):
         """
@@ -2391,7 +2842,7 @@ class BlockingConnectionPool(ConnectionPool):
                 )
             else:
                 connection = self.connection_class(**self.connection_kwargs)
-                self._connections.append(connection)
+            self._connections.append(connection)
             return connection
         finally:
             if self._locked:
@@ -2503,14 +2954,18 @@ class BlockingConnectionPool(ConnectionPool):
                     pass
                 self._locked = False
 
-    def disconnect(self):
-        "Disconnects all connections in the pool."
+    def disconnect(self, inuse_connections: bool = True):
+        "Disconnects either all connections in the pool or just the free connections."
         self._checkpid()
         try:
             if self._in_maintenance:
                 self._lock.acquire()
                 self._locked = True
-            for connection in self._connections:
+            if inuse_connections:
+                connections = self._connections
+            else:
+                connections = self._get_free_connections()
+            for connection in connections:
                 connection.disconnect()
         finally:
             if self._locked:
@@ -2520,124 +2975,19 @@ class BlockingConnectionPool(ConnectionPool):
                     pass
                 self._locked = False
 
-    def update_connections_settings(
-        self,
-        state: Optional["MaintenanceState"] = None,
-        maintenance_notification_hash: Optional[int] = None,
-        relaxed_timeout: Optional[float] = None,
-        host_address: Optional[str] = None,
-        matching_address: Optional[str] = None,
-        matching_notification_hash: Optional[int] = None,
-        matching_pattern: Literal[
-            "connected_address", "configured_address", "notification_hash"
-        ] = "connected_address",
-        update_notification_hash: bool = False,
-        reset_host_address: bool = False,
-        reset_relaxed_timeout: bool = False,
-        include_free_connections: bool = True,
-    ):
-        """
-        Override base class method to work with BlockingConnectionPool's structure.
-        """
+    def _get_free_connections(self):
         with self._lock:
-            if include_free_connections:
-                for conn in tuple(self._connections):
-                    if self._should_update_connection(
-                        conn,
-                        matching_pattern,
-                        matching_address,
-                        matching_notification_hash,
-                    ):
-                        self.update_connection_settings(
-                            conn,
-                            state=state,
-                            maintenance_notification_hash=maintenance_notification_hash,
-                            host_address=host_address,
-                            relaxed_timeout=relaxed_timeout,
-                            update_notification_hash=update_notification_hash,
-                            reset_host_address=reset_host_address,
-                            reset_relaxed_timeout=reset_relaxed_timeout,
-                        )
-            else:
-                connections_in_queue = {conn for conn in self.pool.queue if conn}
-                for conn in self._connections:
-                    if conn not in connections_in_queue:
-                        if self._should_update_connection(
-                            conn,
-                            matching_pattern,
-                            matching_address,
-                            matching_notification_hash,
-                        ):
-                            self.update_connection_settings(
-                                conn,
-                                state=state,
-                                maintenance_notification_hash=maintenance_notification_hash,
-                                host_address=host_address,
-                                relaxed_timeout=relaxed_timeout,
-                                update_notification_hash=update_notification_hash,
-                                reset_host_address=reset_host_address,
-                                reset_relaxed_timeout=reset_relaxed_timeout,
-                            )
-
-    def update_active_connections_for_reconnect(
-        self,
-        moving_address_src: Optional[str] = None,
-    ):
-        """
-        Mark all active connections for reconnect.
-        This is used when a cluster node is migrated to a different address.
+            return {conn for conn in self.pool.queue if conn}
 
-        :param moving_address_src: The address of the node that is being moved.
-        """
+    def _get_in_use_connections(self):
         with self._lock:
+            # free connections
             connections_in_queue = {conn for conn in self.pool.queue if conn}
-            for conn in self._connections:
-                if conn not in connections_in_queue:
-                    if self._should_update_connection(
-                        conn,
-                        matching_pattern="connected_address",
-                        matching_address=moving_address_src,
-                    ):
-                        conn.mark_for_reconnect()
-
-    def disconnect_free_connections(
-        self,
-        moving_address_src: Optional[str] = None,
-    ):
-        """
-        Disconnect all free/available connections.
-        This is used when a cluster node is migrated to a different address.
-
-        :param moving_address_src: The address of the node that is being moved.
-        """
-        with self._lock:
-            existing_connections = self.pool.queue
-
-            for conn in existing_connections:
-                if conn:
-                    if self._should_update_connection(
-                        conn, "connected_address", moving_address_src
-                    ):
-                        conn.disconnect()
-
-    def _update_maint_notifications_config_for_connections(
-        self, maint_notifications_config
-    ):
-        for conn in tuple(self._connections):
-            conn.maint_notifications_config = maint_notifications_config
-
-    def _update_maint_notifications_configs_for_connections(
-        self, maint_notifications_pool_handler
-    ):
-        """Update the maintenance notifications config for all connections in the pool."""
-        with self._lock:
-            for conn in tuple(self._connections):
-                conn.set_maint_notifications_pool_handler(
-                    maint_notifications_pool_handler
-                )
-                conn.maint_notifications_config = (
-                    maint_notifications_pool_handler.config
-                )
+            # in self._connections we keep all created connections
+            # so the ones that are not in the queue are the in use ones
+            return {
+                conn for conn in self._connections if conn not in connections_in_queue
+            }
 
     def set_in_maintenance(self, in_maintenance: bool):
         """