fix: initialize pool connections concurrently

initialize() used a serial for-loop, so create_pool(min_size=N) blocked
for N × per-connect RTT. Even a cold leader lookup stretched this into
seconds. Use asyncio.gather to create all min_size connections
concurrently instead.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: antoineleclair

src/dqliteclient/pool.py

@@ -92,9 +92,16 @@ async def initialize(self) -> None:
         async with self._lock:
             if self._initialized:
                 return
-            for _ in range(self._min_size):
-                conn = await self._create_connection()
-                await self._pool.put(conn)
+            # Create min_size connections concurrently so pool startup
+            # latency doesn't scale with min_size × per-connect RTT. If any
+            # one fails, cancel the rest and propagate; leave _initialized
+            # False so the caller can retry.
+            if self._min_size > 0:
+                conns = await asyncio.gather(
+                    *(self._create_connection() for _ in range(self._min_size))
+                )
+                for conn in conns:
+                    await self._pool.put(conn)
             self._initialized = True
 
     async def _create_connection(self) -> DqliteConnection:

tests/test_pool.py

@@ -843,6 +843,37 @@ async def try_acquire() -> BaseException | None:
             f"acquire() should wake within ~100ms of pool.close(); took {elapsed:.3f}s"
         )
 
+    async def test_initialize_creates_min_size_in_parallel(self) -> None:
+        """initialize() should connect min_size in parallel, not sequentially.
+        With min_size=5 and per-connect latency 0.1s, serial init takes ~0.5s;
+        parallel should finish in ~0.1s.
+        """
+        import asyncio
+        import time
+
+        pool = ConnectionPool(["localhost:9001"], min_size=5, max_size=10)
+
+        async def slow_connect(**kwargs):
+            await asyncio.sleep(0.1)
+            mock_conn = MagicMock()
+            mock_conn.is_connected = True
+            mock_conn.close = AsyncMock()
+            return mock_conn
+
+        with patch.object(pool._cluster, "connect", side_effect=slow_connect):
+            t0 = time.monotonic()
+            await pool.initialize()
+            elapsed = time.monotonic() - t0
+
+        assert pool._size == 5
+        assert elapsed < 0.3, (
+            f"expected parallel init (~0.1s), got {elapsed:.3f}s "
+            f"— looks like the connections were created sequentially"
+        )
+
+        await pool.close()
+
+
     async def test_reset_connection_returns_false_on_cancelled_error(self) -> None:
         """_reset_connection must return False (not raise) when ROLLBACK is cancelled."""
         import asyncio