Prevent nested transactions

src/Spanner/Database.php

@@ -143,6 +143,11 @@ class Database
      */
     private $sessionPool;
 
+    /**
+     * @var bool
+     */
+    private $isRunningTransaction = false;
+
     /**
      * Create an object representing a Database.
      *
@@ -507,10 +512,16 @@ public function iam()
      *           **Defaults to** `false`.
      * }
      * @return Snapshot
+     * @throws \BadMethodCallException If attempting to call this method within
+     *         an existing transaction.
      * @codingStandardsIgnoreEnd
      */
     public function snapshot(array $options = [])
     {
+        if ($this->isRunningTransaction) {
+            throw new \BadMethodCallException('Nested transactions are not supported by this client.');
+        }
+
         $options += [
             'singleUse' => false
         ];
@@ -560,9 +571,15 @@ public function snapshot(array $options = [])
      *           **Defaults to** `false`.
      * }
      * @return Transaction
+     * @throws \BadMethodCallException If attempting to call this method within
+     *         an existing transaction.
      */
     public function transaction(array $options = [])
     {
+        if ($this->isRunningTransaction) {
+            throw new \BadMethodCallException('Nested transactions are not supported by this client.');
+        }
+
         // There isn't anything configurable here.
         $options['transactionOptions'] = $this->configureTransactionOptions();
 
@@ -593,6 +610,10 @@ public function transaction(array $options = [])
      * it is important that every transaction commits or rolls back as early as
      * possible. Do not hold transactions open longer than necessary.
      *
+     * Please also note that nested transactions are NOT supported by this client.
+     * Attempting to call `runTransaction` inside a transaction callable will
+     * raise a `BadMethodCallException`.
+     *
      * If a callable finishes executing without invoking
      * {@see Google\Cloud\Spanner\Transaction::commit()} or
      * {@see Google\Cloud\Spanner\Transaction::rollback()}, the transaction will
@@ -643,10 +664,16 @@ public function transaction(array $options = [])
      *           `false`.
      * }
      * @return mixed The return value of `$operation`.
-     * @throws \RuntimeException
+     * @throws \RuntimeException If a transaction is not committed or rolled back.
+     * @throws \BadMethodCallException If attempting to call this method within
+     *         an existing transaction.
      */
     public function runTransaction(callable $operation, array $options = [])
     {
+        if ($this->isRunningTransaction) {
+            throw new \BadMethodCallException('Nested transactions are not supported by this client.');
+        }
+
         $options += [
             'maxRetries' => self::MAX_RETRIES,
         ];
@@ -683,7 +710,13 @@ public function runTransaction(callable $operation, array $options = [])
                 $options
             ]);
 
-            $res = call_user_func($operation, $transaction);
+            // Prevent nested transactions.
+            $this->isRunningTransaction = true;
+            try {
+                $res = call_user_func($operation, $transaction);
+            } finally {
+                $this->isRunningTransaction = false;
+            }
 
             $active = $transaction->state() === Transaction::STATE_ACTIVE;
             $singleUse = $transaction->type() === Transaction::TYPE_SINGLE_USE;

tests/unit/Spanner/DatabaseTest.php

@@ -300,6 +300,25 @@ public function testSnapshotMaxStaleness()
         $this->database->snapshot(['maxStaleness' => 'foo']);
     }
 
+    /**
+     * @expectedException BadMethodCallException
+     */
+    public function testSnapshotNestedTransaction()
+    {
+        $this->connection->beginTransaction(Argument::any())
+            ->shouldBeCalled()
+            ->willReturn(['id' => self::TRANSACTION]);
+
+        $this->connection->rollback(Argument::any())
+            ->shouldNotBeCalled();
+
+        $this->refreshOperation();
+
+        $this->database->runTransaction(function ($t) {
+            $this->database->snapshot();
+        });
+    }
+
     public function testRunTransaction()
     {
         $this->connection->beginTransaction(Argument::any())
@@ -340,6 +359,25 @@ public function testRunTransactionNoCommit()
         $this->database->runTransaction(function (Transaction $t) {});
     }
 
+    /**
+     * @expectedException BadMethodCallException
+     */
+    public function testRunTransactionNestedTransaction()
+    {
+        $this->connection->beginTransaction(Argument::any())
+            ->shouldBeCalled()
+            ->willReturn(['id' => self::TRANSACTION]);
+
+        $this->connection->rollback(Argument::any())
+            ->shouldNotBeCalled();
+
+        $this->refreshOperation();
+
+        $this->database->runTransaction(function ($t) {
+            $this->database->runTransaction(function ($t) {});
+        });
+    }
+
     public function testRunTransactionRetry()
     {
         $abort = new AbortedException('foo', 409, null, [
@@ -427,6 +465,25 @@ public function testTransaction()
         $this->assertInstanceOf(Transaction::class, $t);
     }
 
+    /**
+     * @expectedException BadMethodCallException
+     */
+    public function testTransactionNestedTransaction()
+    {
+        $this->connection->beginTransaction(Argument::any())
+            ->shouldBeCalled()
+            ->willReturn(['id' => self::TRANSACTION]);
+
+        $this->connection->rollback(Argument::any())
+            ->shouldNotBeCalled();
+
+        $this->refreshOperation();
+
+        $this->database->runTransaction(function ($t) {
+            $this->database->transaction();
+        });
+    }
+
     public function testInsert()
     {
         $table = 'foo';