TransactionObserver can access the database, even if the transaction was completed in a cancelled task.

Fix groue#1746

Author: groue

GRDB/Core/Database+Statements.swift

@@ -494,11 +494,9 @@ extension Database {
 
         switch ResultCode(rawValue: resultCode) {
         case .SQLITE_INTERRUPT, .SQLITE_ABORT:
-            if suspensionMutex.load().isCancelled {
-                // The only error that a user sees when a Task is cancelled
-                // is CancellationError.
-                throw CancellationError()
-            }
+            // The only error that a user sees when a Task is cancelled
+            // is CancellationError.
+            try suspensionMutex.load().checkCancellation()
         default:
             break
         }

GRDB/Core/Database.swift

@@ -341,10 +341,22 @@ public final class Database: CustomStringConvertible, CustomDebugStringConvertib
 
         /// If true, the database access has been cancelled.
         var isCancelled: Bool
+        
+        /// If true, the database throws an error when it is cancelled.
+        var interruptsWhenCancelled: Bool
+        
+        func checkCancellation() throws {
+            if isCancelled, interruptsWhenCancelled {
+                throw CancellationError()
+            }
+        }
     }
 
     /// Support for `checkForSuspensionViolation(from:)`
-    let suspensionMutex = Mutex(Suspension(isSuspended: false, isCancelled: false))
+    let suspensionMutex = Mutex(Suspension(
+        isSuspended: false,
+        isCancelled: false,
+        interruptsWhenCancelled: true))
 
     // MARK: - Transaction Date
 
@@ -1222,7 +1234,7 @@ public final class Database: CustomStringConvertible, CustomDebugStringConvertib
             }
 
             suspension.isCancelled = true
-            return true
+            return suspension.interruptsWhenCancelled
         }
 
         if needsInterrupt {
@@ -1237,6 +1249,24 @@ public final class Database: CustomStringConvertible, CustomDebugStringConvertib
         }
     }
 
+    /// Within the given closure, Task cancellation does not interrupt
+    /// database accesses.
+    func ignoringCancellation<T>(_ value: () throws -> T) rethrows -> T {
+        let previous = suspensionMutex.withLock {
+            let previous = $0.interruptsWhenCancelled
+            $0.interruptsWhenCancelled = false
+            return previous
+        }
+        
+        defer {
+            suspensionMutex.withLock {
+                $0.interruptsWhenCancelled = previous
+            }
+        }
+        
+        return try value()
+    }
+    
     /// Support for `checkForSuspensionViolation(from:)`
     private func journalMode() throws -> String {
         if let journalMode = journalModeCache {
@@ -1303,7 +1333,7 @@ public final class Database: CustomStringConvertible, CustomDebugStringConvertib
         let interrupt: Interrupt? = try suspensionMutex.withLock { suspension in
             // Check for cancellation first, so that the only error that
             // a user sees when a Task is cancelled is CancellationError.
-            if suspension.isCancelled {
+            if suspension.isCancelled, suspension.interruptsWhenCancelled {
                 return .cancel
             }
 

GRDB/Core/TransactionObserver.swift

@@ -549,8 +549,12 @@ class DatabaseObservationBroker {
         savepointStack.clear()
 
         if !database.isReadOnly {
-            for observation in transactionObservations {
-                observation.databaseDidCommit(database)
+            // Observers must be able to access the database, even if the
+            // task that has performed the commit is cancelled.
+            database.ignoringCancellation {
+                for observation in transactionObservations {
+                    observation.databaseDidCommit(database)
+                }
             }
         }
 
@@ -609,12 +613,18 @@ class DatabaseObservationBroker {
 
     // Called from statementDidExecute or statementDidFail
     private func databaseDidRollback(notifyTransactionObservers: Bool) {
+        #warning("TODO")
         savepointStack.clear()
 
         if notifyTransactionObservers {
             assert(!database.isReadOnly, "Read-only transactions are not notified")
-            for observation in transactionObservations {
-                observation.databaseDidRollback(database)
+            
+            // Observers must be able to access the database, even if the
+            // task that has performed the commit is cancelled.
+            database.ignoringCancellation {
+                for observation in transactionObservations {
+                    observation.databaseDidRollback(database)
+                }
             }
         }
         databaseDidEndTransaction()