Method get_connection

redis/connection.py:3128–3192

Get a connection from the pool

(self, command_name=None, *keys, **options)

        version="5.3.0",
    )
    def get_connection(self, command_name=None, *keys, **options) -> "Connection":
        "Get a connection from the pool"

        # Start timing for observability
        self._checkpid()
        is_created = False

        with self._lock:
            try:
                connection = self._available_connections.pop()
            except IndexError:
                # Start timing for observability
                start_time_created = time.monotonic()

                connection = self.make_connection()
                is_created = True
            self._in_use_connections.add(connection)

        # Record state transition: IDLE -> USED
        # (make_connection already recorded IDLE +1 for new connections)
        # This ensures counters stay balanced if connect() fails and release() is called
        pool_name = get_pool_name(self)
        record_connection_count(
            pool_name=pool_name,
            connection_state=ConnectionState.IDLE,
            counter=-1,
        )
        record_connection_count(
            pool_name=pool_name,
            connection_state=ConnectionState.USED,
            counter=1,
        )

        try:
            # ensure this connection is connected to Redis
            connection.connect()
            # connections that the pool provides should be ready to send
            # a command. if not, the connection was either returned to the
            # pool before all data has been read or the socket has been
            # closed. either way, reconnect and verify everything is good.
            try:
                if (
                    connection.can_read()
                    and self.cache is None
                    and not self.maint_notifications_enabled()
                ):
                    raise ConnectionError("Connection has data")
            except (ConnectionError, TimeoutError, OSError):
                connection.disconnect()
                connection.connect()
                if connection.can_read():
                    raise ConnectionError("Connection not ready")
        except BaseException:
            # release the connection back to the pool so that we don't
            # leak it
            self.release(connection)
            raise