Add the from_pool argument to asyncio.Redis

Author: kristjanvalur

docs/examples/asyncio_examples.ipynb

@@ -44,6 +44,26 @@
     "await connection.close()"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "If you create custom `ConnectionPool` for the `Redis` instance to use, use the `from_pool` argument.  This will cause the pool to be disconnected along with the Redis instance. Disconnecting the connection pool simply disconnects all connections hosted in the pool."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import redis.asyncio as redis\n",
+    "\n",
+    "pool = redis.ConnectionPool.from_url(\"redis://localhost\")\n",
+    "connection = redis.Redis(from_pool=pool)\n",
+    "await connection.close()"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {
@@ -53,7 +73,8 @@
     }
    },
    "source": [
-    "If you supply a custom `ConnectionPool` that is supplied to several `Redis` instances, you may want to disconnect the connection pool explicitly. Disconnecting the connection pool simply disconnects all connections hosted in the pool."
+    "\n",
+    "However, If you supply a `ConnectionPool` that is shared several `Redis` instances, you may want to disconnect the connection pool explicitly. use the `connection_pool` argument in that case."
    ]
   },
   {
@@ -69,10 +90,12 @@
    "source": [
     "import redis.asyncio as redis\n",
     "\n",
-    "connection = redis.Redis(auto_close_connection_pool=False)\n",
-    "await connection.close()\n",
-    "# Or: await connection.close(close_connection_pool=False)\n",
-    "await connection.connection_pool.disconnect()"
+    "pool = redis.ConnectionPool.from_url(\"redis://localhost\")\n",
+    "connection1 = redis.Redis(connection_pool=pool)\n",
+    "connection2 = redis.Redis(connection_pool=pool)\n",
+    "await connection1.close()\n",
+    "await connection2.close()\n",
+    "await pool.disconnect()"
    ]
   },
   {

redis/asyncio/client.py

@@ -114,7 +114,6 @@ def from_url(
         cls,
         url: str,
         single_connection_client: bool = False,
-        auto_close_connection_pool: bool = True,
         **kwargs,
     ):
         """
@@ -160,12 +159,10 @@ class initializer. In the case of conflicting arguments, querystring
 
         """
         connection_pool = ConnectionPool.from_url(url, **kwargs)
-        redis = cls(
-            connection_pool=connection_pool,
+        return cls(
+            from_pool=connection_pool,
             single_connection_client=single_connection_client,
         )
-        redis.auto_close_connection_pool = auto_close_connection_pool
-        return redis
 
     def __init__(
         self,
@@ -179,6 +176,7 @@ def __init__(
         socket_keepalive: Optional[bool] = None,
         socket_keepalive_options: Optional[Mapping[int, Union[int, bytes]]] = None,
         connection_pool: Optional[ConnectionPool] = None,
+        from_pool: Optional[ConnectionPool] = None,
         unix_socket_path: Optional[str] = None,
         encoding: str = "utf-8",
         encoding_errors: str = "strict",
@@ -200,6 +198,7 @@ def __init__(
         lib_version: Optional[str] = get_lib_version(),
         username: Optional[str] = None,
         retry: Optional[Retry] = None,
+        # deprecated. create a pool and use connection_pool instead
         auto_close_connection_pool: bool = True,
         redis_connect_func=None,
         credential_provider: Optional[CredentialProvider] = None,
@@ -213,14 +212,9 @@ def __init__(
         To retry on TimeoutError, `retry_on_timeout` can also be set to `True`.
         """
         kwargs: Dict[str, Any]
-        # auto_close_connection_pool only has an effect if connection_pool is
-        # None. This is a similar feature to the missing __del__ to resolve #1103,
-        # but it accounts for whether a user wants to manually close the connection
-        # pool, as a similar feature to ConnectionPool's __del__.
-        self.auto_close_connection_pool = (
-            auto_close_connection_pool if connection_pool is None else False
-        )
-        if not connection_pool:
+
+        if not connection_pool and not from_pool:
+            # Create internal connection pool, expected to be closed by Redis instance
             if not retry_on_error:
                 retry_on_error = []
             if retry_on_timeout is True:
@@ -277,8 +271,28 @@ def __init__(
                             "ssl_check_hostname": ssl_check_hostname,
                         }
                     )
-            connection_pool = ConnectionPool(**kwargs)
-        self.connection_pool = connection_pool
+            # backwards compatibility.  This arg only used if no pool
+            # is provided
+            if auto_close_connection_pool:
+                from_pool = ConnectionPool(**kwargs)
+            else:
+                connection_pool = ConnectionPool(**kwargs)
+
+        if from_pool is not None:
+            # internal connection pool, expected to be closed by Redis instance
+            if connection_pool is not None:
+                raise ValueError(
+                    "Cannot use both from_pool and connection_pool arguments"
+                )
+            self.connection_pool = from_pool
+            self.auto_close_connection_pool = True  # the Redis instance closes the pool
+        else:
+            # external connection pool, expected to be closed by caller
+            self.connection_pool = connection_pool
+            self.auto_close_connection_pool = (
+                False  # the user is expected to close the pool
+            )
+
         self.single_connection_client = single_connection_client
         self.connection: Optional[Connection] = None
 

redis/asyncio/connection.py

@@ -1199,7 +1199,7 @@ class BlockingConnectionPool(ConnectionPool):
     Thread-safe blocking connection pool::
 
         >>> from redis.client import Redis
-        >>> client = Redis(connection_pool=BlockingConnectionPool())
+        >>> client = Redis(from_pool=BlockingConnectionPool())
 
     It performs the same function as the default
     :py:class:`~redis.ConnectionPool` implementation, in that,

redis/asyncio/sentinel.py

@@ -338,12 +338,9 @@ def master_for(
 
         connection_pool = connection_pool_class(service_name, self, **connection_kwargs)
         # The Redis object "owns" the pool
-        auto_close_connection_pool = True
-        client = redis_class(
-            connection_pool=connection_pool,
+        return redis_class(
+            from_pool=connection_pool,
         )
-        client.auto_close_connection_pool = auto_close_connection_pool
-        return client
 
     def slave_for(
         self,
@@ -375,9 +372,6 @@ def slave_for(
 
         connection_pool = connection_pool_class(service_name, self, **connection_kwargs)
         # The Redis object "owns" the pool
-        auto_close_connection_pool = True
-        client = redis_class(
-            connection_pool=connection_pool,
+        return redis_class(
+            from_pool=connection_pool,
         )
-        client.auto_close_connection_pool = auto_close_connection_pool
-        return client