Improve handling of uncaught errors in Isolates.

Author: rkistner

lib/src/connection_pool.dart

@@ -158,7 +158,8 @@ class SqliteConnectionPool with SqliteQueries implements SqliteConnection {
     if (closed || _readConnections.length >= maxReaders) {
       return;
     }
-    bool hasCapacity = _readConnections.any((connection) => !connection.locked);
+    bool hasCapacity = _readConnections
+        .any((connection) => !connection.locked && !connection.closed);
     if (!hasCapacity) {
       var name = debugName == null
           ? null

lib/src/port_channel.dart

@@ -21,6 +21,8 @@ class ParentPortClient implements PortClient {
   final ReceivePort _receivePort = ReceivePort();
   final ReceivePort _errorPort = ReceivePort();
   bool closed = false;
+  Object? _closeError;
+  String? _isolateDebugName;
   int _nextId = 1;
 
   Map<int, Completer<Object?>> handlers = HashMap();
@@ -59,33 +61,34 @@ class ParentPortClient implements PortClient {
       close();
     });
     _errorPort.listen((message) {
-      var [error, stackTrace] = message;
+      final [error, stackTraceString] = message;
+      final stackTrace = stackTraceString == null
+          ? null
+          : StackTrace.fromString(stackTraceString);
       if (!initCompleter.isCompleted) {
-        if (stackTrace == null) {
-          initCompleter.completeError(error);
-        } else {
-          initCompleter.completeError(error, StackTrace.fromString(stackTrace));
-        }
+        initCompleter.completeError(error, stackTrace);
       }
+      _close(IsolateError(cause: error, isolateDebugName: _isolateDebugName),
+          stackTrace);
     });
   }
 
   Future<void> get ready async {
     await sendPortFuture;
   }
 
-  void _cancelAll(Object error) {
+  void _cancelAll(Object error, [StackTrace? stackTrace]) {
     var handlers = this.handlers;
     this.handlers = {};
     for (var message in handlers.values) {
-      message.completeError(error);
+      message.completeError(error, stackTrace);
     }
   }
 
   @override
   Future<T> post<T>(Object message) async {
     if (closed) {
-      throw ClosedException();
+      throw _closeError ?? const ClosedException();
     }
     var completer = Completer<T>.sync();
     var id = _nextId++;
@@ -98,7 +101,7 @@ class ParentPortClient implements PortClient {
   @override
   void fire(Object message) async {
     if (closed) {
-      throw ClosedException();
+      throw _closeError ?? ClosedException();
     }
     final port = sendPort ?? await sendPortFuture;
     port.send(_FireMessage(message));
@@ -108,17 +111,27 @@ class ParentPortClient implements PortClient {
     return RequestPortServer(_receivePort.sendPort);
   }
 
-  void close() async {
+  void _close([Object? error, StackTrace? stackTrace]) {
     if (!closed) {
       closed = true;
 
       _receivePort.close();
       _errorPort.close();
-      _cancelAll(const ClosedException());
+      if (error == null) {
+        _cancelAll(const ClosedException());
+      } else {
+        _closeError = error;
+        _cancelAll(error, stackTrace);
+      }
     }
   }
 
+  void close() {
+    _close();
+  }
+
   tieToIsolate(Isolate isolate) {
+    _isolateDebugName = isolate.debugName;
     isolate.addErrorListener(_errorPort.sendPort);
     isolate.addOnExitListener(_receivePort.sendPort, response: _closeMessage);
   }
@@ -274,6 +287,27 @@ class _RequestMessage {
 
 class ClosedException implements Exception {
   const ClosedException();
+
+  @override
+  String toString() {
+    return 'ClosedException';
+  }
+}
+
+class IsolateError extends Error {
+  final Object cause;
+  final String? isolateDebugName;
+
+  IsolateError({required this.cause, this.isolateDebugName});
+
+  @override
+  String toString() {
+    if (isolateDebugName != null) {
+      return 'IsolateError in $isolateDebugName: $cause';
+    } else {
+      return 'IsolateError: $cause';
+    }
+  }
 }
 
 class _PortChannelResult<T> {

test/basic_test.dart

@@ -4,6 +4,7 @@ import 'dart:math';
 import 'package:sqlite3/sqlite3.dart' as sqlite;
 import 'package:sqlite_async/mutex.dart';
 import 'package:sqlite_async/sqlite_async.dart';
+import 'package:test/expect.dart';
 import 'package:test/test.dart';
 
 import 'util.dart';
@@ -301,8 +302,11 @@ void main() {
       }).catchError((error) {
         caughtError = error;
       });
-      // This may change into a better error in the future
-      expect(caughtError.toString(), equals("Instance of 'ClosedException'"));
+      // The specific error message may change
+      expect(
+          caughtError.toString(),
+          equals(
+              "IsolateError in sqlite-writer: Invalid argument(s): uncaught async error"));
 
       // Check that we can still continue afterwards
       final computed = await db.computeWithDatabase((db) async {
@@ -328,8 +332,11 @@ void main() {
         }).catchError((error) {
           caughtError = error;
         });
-        // This may change into a better error in the future
-        expect(caughtError.toString(), equals("Instance of 'ClosedException'"));
+        // The specific message may change
+        expect(
+            caughtError.toString(),
+            matches(RegExp(
+                r'IsolateError in sqlite-\d+: Invalid argument\(s\): uncaught async error')));
       }
 
       // Check that we can still continue afterwards