[6.0] Fix exception handling on transaction commit in DB::transaction()

src/Illuminate/Database/Concerns/ManagesTransactions.php

@@ -26,9 +26,7 @@ public function transaction(Closure $callback, $attempts = 1)
             // catch any exception we can rollback this transaction so that none of this
             // gets actually persisted to a database or stored in a permanent fashion.
             try {
-                return tap($callback($this), function () {
-                    $this->commit();
-                });
+                $callbackReturn = $callback($this);
             }
 
             // If we catch an exception we'll rollback this transaction and try again if we
@@ -38,11 +36,27 @@ public function transaction(Closure $callback, $attempts = 1)
                 $this->handleTransactionException(
                     $e, $currentAttempt, $attempts
                 );
+
+                continue;
             } catch (Throwable $e) {
                 $this->rollBack();
 
                 throw $e;
             }
+
+            // Exceptions on commit need to be handled separately as they automatically roll
+            // back the transaction, resulting in an error if we attempt to manually roll back.
+            try {
+                $this->commit();
+            } catch (Exception $e) {
+                $this->handleCommitTransactionException(
+                    $e, $currentAttempt, $attempts
+                );
+
+                continue;
+            }
+
+            return $callbackReturn;
         }
     }
 
@@ -81,6 +95,35 @@ protected function handleTransactionException($e, $currentAttempt, $maxAttempts)
         throw $e;
     }
 
+    /**
+     * Handle an exception encountered when committing a transaction.
+     *
+     * @param  \Exception  $e
+     * @param  int  $currentAttempt
+     * @param  int  $maxAttempts
+     * @return void
+     *
+     * @throws \Exception
+     */
+    protected function handleCommitTransactionException($e, $currentAttempt, $maxAttempts)
+    {
+        // If the COMMIT fails, the transaction is automatically rolled back.
+        $this->transactions--;
+
+        // If we encountered a serialization failure, try again if we are not out of attempts.
+        // SQLSTATE 40001 is designated as a serialization failure.
+        if ($e->getCode() === '40001' &&
+            $currentAttempt < $maxAttempts) {
+            return;
+        }
+
+        if ($this->causedByLostConnection($e)) {
+            $this->transactions = 0;
+        }
+
+        throw $e;
+    }
+
     /**
      * Start a new database transaction.
      *

tests/Database/DatabaseConnectionTest.php

@@ -240,6 +240,21 @@ public function testTransactionMethodRunsSuccessfully()
         $this->assertEquals($mock, $result);
     }
 
+    public function testTransactionRetriesOnSerializationFailure()
+    {
+        $this->expectException(PDOException::class);
+        $this->expectExceptionMessage('Serialization failure');
+
+        $pdo = $this->getMockBuilder(DatabaseConnectionTestMockPDO::class)->setMethods(['beginTransaction', 'commit', 'rollBack'])->getMock();
+        $mock = $this->getMockConnection([], $pdo);
+        $pdo->method('commit')->will($this->throwException(new DatabaseConnectionTestMockPDOException('Serialization failure', '40001')));
+        $pdo->expects($this->exactly(3))->method('beginTransaction');
+        $pdo->expects($this->never())->method('rollBack');
+        $pdo->expects($this->exactly(3))->method('commit');
+        $mock->transaction(function () {
+        }, 3);
+    }
+
     public function testTransactionMethodRetriesOnDeadlock()
     {
         $this->expectException(QueryException::class);
@@ -411,3 +426,20 @@ public function __construct()
         //
     }
 }
+
+class DatabaseConnectionTestMockPDOException extends PDOException
+{
+    /**
+     * Overrides Exception::__construct, which casts $code to integer, so that we can create
+     * an exception with a string $code consistent with the real PDOException behavior.
+     *
+     * @param  string|null  $message
+     * @param  string|null  $code
+     * @return void
+     */
+    public function __construct($message = null, $code = null)
+    {
+        $this->message = $message;
+        $this->code = $code;
+    }
+}