Add retry mechanism to use method for connection handling with tests

Author: ArnabChatterjee20k

src/Pools/Pool.php

@@ -219,21 +219,37 @@ public function setTelemetry(Telemetry $telemetry): static
      *
      * @template T
      * @param callable(TResource): T $callback Function that receives the connection resource
+     * @param int $retries Number of retry attempts if the callback fails (default: 0)
      * @return T Return value from the callback
+     * @throws \Throwable If all retry attempts fail, throws the last exception
      */
-    public function use(callable $callback): mixed
+    public function use(callable $callback, int $retries = 0): mixed
     {
-        $start = microtime(true);
-        $connection = null;
-        try {
-            $connection = $this->pop();
-            return $callback($connection->getResource());
-        } finally {
-            if ($connection !== null) {
-                $this->telemetryUseDuration->record(microtime(true) - $start, $this->telemetryAttributes);
+        $lastException = null;
+        
+        for ($attempt = 0; $attempt <= $retries; $attempt++) {
+            $start = microtime(true);
+            $connection = null;
+            
+            try {
+                $connection = $this->pop();
+                $result = $callback($connection->getResource());
                 $this->reclaim($connection);
+                $this->telemetryUseDuration->record(microtime(true) - $start, $this->telemetryAttributes);
+                return $result;
+            } catch (\Throwable $e) {
+                if ($connection !== null) {
+                    $this->destroy($connection);
+                }
+                $this->telemetryUseDuration->record(microtime(true) - $start, $this->telemetryAttributes);
+                $lastException = $e;
+                if ($attempt === $retries) {
+                    throw $lastException;
+                }
             }
         }
+
+        throw $lastException;
     }
 
     /**

tests/Pools/Scopes/PoolTestScope.php

@@ -367,4 +367,129 @@ public function testPoolTelemetry(): void
             });
         });
     }
+
+    public function testPoolUseWithRetrySuccess(): void
+    {
+        $this->execute(function (): void {
+            $i = 0;
+            $pool = new Pool($this->getAdapter(), 'testRetry', 2, function () use (&$i) {
+                $i++;
+                return "connection-{$i}";
+            });
+
+            $attempts = 0;
+            $result = $pool->use(function ($resource) use (&$attempts) {
+                $attempts++;
+                
+                // Fail on first two attempts, succeed on third
+                if ($attempts < 3) {
+                    throw new Exception("Simulated connection failure");
+                }
+                
+                return "success: {$resource}";
+            }, 3); // Allow up to 3 retries (4 total attempts)
+
+            $this->assertEquals(3, $attempts);
+            $this->assertEquals("success: connection-3", $result);
+            
+            // Pool should have connections available (destroyed failed ones, created new)
+            $this->assertGreaterThan(0, $pool->count());
+        });
+
+        $this->execute(function (): void {
+            $pool = new Pool($this->getAdapter(), 'testIntermittent', 5, fn () => 'resource');
+
+            $callCount = 0;
+            
+            $result = $pool->use(function ($resource) use (&$callCount) {
+                $callCount++;
+                
+                // Fail on odd attempts, succeed on even
+                if ($callCount % 2 === 1) {
+                    throw new Exception("Odd attempt failure");
+                }
+                
+                return "success on attempt {$callCount}";
+            }, 5); // Allow 5 retries
+
+            $this->assertEquals("success on attempt 2", $result);
+            $this->assertEquals(2, $callCount); // Should succeed on second attempt
+        });
+    }
+
+    public function testPoolUseWithRetryFailure(): void
+    {
+        $this->execute(function (): void {
+            $pool = new Pool($this->getAdapter(), 'testRetryFail', 3, fn () => 'x');
+
+            $attempts = 0;
+            
+            try {
+                $pool->use(function ($resource) use (&$attempts) {
+                    $attempts++;
+                    throw new Exception("Persistent failure");
+                }, 2); // Allow up to 2 retries (3 total attempts)
+                
+                $this->fail('Expected exception was not thrown');
+            } catch (Exception $e) {
+                $this->assertEquals("Persistent failure", $e->getMessage());
+                $this->assertEquals(3, $attempts); // Should have tried 3 times (initial + 2 retries)
+            }
+        });
+    }
+
+    public function testPoolUseWithoutRetry(): void
+    {
+        $this->execute(function (): void {
+            $pool = new Pool($this->getAdapter(), 'testNoRetry', 2, fn () => 'x');
+
+            $attempts = 0;
+            
+            try {
+                $pool->use(function ($resource) use (&$attempts) {
+                    $attempts++;
+                    throw new Exception("First attempt failure");
+                }); // No retries (default)
+                
+                $this->fail('Expected exception was not thrown');
+            } catch (Exception $e) {
+                $this->assertEquals("First attempt failure", $e->getMessage());
+                $this->assertEquals(1, $attempts); // Should only try once
+            }
+        });
+    }
+
+    public function testPoolUseRetryDestroysFailedConnections(): void
+    {
+        $this->execute(function (): void {
+            $i = 0;
+            $pool = new Pool($this->getAdapter(), 'testDestroyOnRetry', 3, function () use (&$i) {
+                $i++;
+                return "connection-{$i}";
+            });
+
+            $attempts = 0;
+            $seenResources = [];
+            
+            $pool->use(function ($resource) use (&$attempts, &$seenResources) {
+                $attempts++;
+                $seenResources[] = $resource;
+                
+                // Fail twice, succeed on third
+                if ($attempts < 3) {
+                    throw new Exception("Connection failed");
+                }
+                
+                return "success";
+            }, 3);
+
+            // Should have created 3 connections (one for each attempt)
+            $this->assertEquals(3, $i);
+            $this->assertEquals(3, $attempts);
+            
+            // Each attempt should have gotten a different connection (failed ones were destroyed)
+            $this->assertCount(3, array_unique($seenResources));
+            $this->assertEquals(['connection-1', 'connection-2', 'connection-3'], $seenResources);
+        });
+    }
 }