Do not allow attach if store already open in isolate.

Author: greenrobot-team

objectbox/lib/src/native/store.dart

@@ -100,12 +100,7 @@ class Store {
           malloc.free(cStr);
         }
       }
-      if (_openStoreDirectories.contains(_dbDir)) {
-        throw UnsupportedError(
-            'Cannot create multiple Store instances for the same directory. '
-            'Please use a single Store or close() the previous instance before '
-            'opening another one.');
-      }
+      _checkStoreDirectoryNotOpen();
       final model = Model(_defs.model);
 
       final opt = C.opt();
@@ -225,9 +220,13 @@ class Store {
       // _weak = false so store can be closed.
       : _weak = false,
         _queriesCaseSensitiveDefault = queriesCaseSensitiveDefault,
-        _dbDir = '' {
+        _dbDir = path.context.canonicalize(_safeDatabasePath(databasePath)) {
     try {
-      // Not checking if database directory is open as this allows it.
+      // Do not allow attaching to a store that is already open in the current
+      // isolate. While technically possible this is not the intended usage
+      // and e.g. transactions would have to be carefully managed to not
+      // overlap.
+      _checkStoreDirectoryNotOpen();
 
       final path = _safeDatabasePath(databasePath);
       final pathCStr = path.toNativeUtf8();
@@ -247,6 +246,15 @@ class Store {
     }
   }
 
+  void _checkStoreDirectoryNotOpen() {
+    if (_openStoreDirectories.contains(_dbDir)) {
+      throw UnsupportedError(
+          'Cannot create multiple Store instances for the same directory in the same isolate. '
+          'Please use a single Store, close() the previous instance before '
+          'opening another one or attach to it in another isolate.');
+    }
+  }
+
   void _checkStorePointer(Pointer cStore) {
     try {
       checkObxPtr(cStore, 'failed to create store');

objectbox/test/basics_test.dart

@@ -1,6 +1,8 @@
 import 'dart:ffi' as ffi;
 import 'dart:io';
+import 'dart:isolate';
 
+import 'package:async/async.dart';
 import 'package:objectbox/internal.dart';
 import 'package:objectbox/src/native/bindings/bindings.dart';
 import 'package:objectbox/src/native/bindings/helpers.dart';
@@ -60,25 +62,47 @@ void main() {
     env.closeAndDelete();
   });
 
-  test('store attach', () {
+  test('store attach fails if same isolate', () {
+    final env = TestEnv('basics');
+    expect(
+        () => Store.attach(getObjectBoxModel(), env.dir.path),
+        throwsA(predicate((UnsupportedError e) =>
+            e.message!.contains('Cannot create multiple Store instances'))));
+    env.closeAndDelete();
+  });
+
+  test('store attach remains open if main store closed', () async {
     final env = TestEnv('basics');
     final store1 = env.store;
-    final store2 = Store.attach(getObjectBoxModel(), env.dir.path);
-    expect(store1, isNot(store2));
-    expect(InternalStoreAccess.ptr(store1),
-        isNot(InternalStoreAccess.ptr(store2)));
+    final receivePort = ReceivePort();
+    final received = StreamQueue<dynamic>(receivePort);
+    await Isolate.spawn(storeAttachIsolate,
+        StoreAttachIsolateInit(receivePort.sendPort, env.dir.path));
+    final commandPort = await received.next as SendPort;
+
+    // Check native instance pointer is different.
+    final store2Address = await received.next as int;
+    expect(InternalStoreAccess.ptr(store1).address, isNot(store2Address));
 
     final id = store1.box<TestEntity>().put(TestEntity(tString: 'foo'));
     expect(id, 1);
     // Close original store to test store remains open until all refs closed.
     store1.close();
     expect(true, Store.isOpen('testdata-basics'));
-    final read = store2.box<TestEntity>().get(id);
-    expect(read, isNotNull);
-    expect(read!.tString, 'foo');
-    store2.close();
+
+    // Read data with attached store.
+    commandPort.send(id);
+    final readtString = await received.next as String?;
+    expect(readtString, isNotNull);
+    expect(readtString, 'foo');
+
+    // Close attached store, should close store completely.
+    commandPort.send(null);
+    await received.next;
     expect(false, Store.isOpen('testdata-basics'));
-    env.closeAndDelete();
+
+    // Dispose StreamQueue.
+    await received.cancel();
   });
 
   test('store is open', () {
@@ -166,3 +190,31 @@ void main() {
     Directory('basics').deleteSync(recursive: true);
   });
 }
+
+class StoreAttachIsolateInit {
+  SendPort sendPort;
+  String path;
+
+  StoreAttachIsolateInit(this.sendPort, this.path);
+}
+
+void storeAttachIsolate(StoreAttachIsolateInit init) async {
+  final store2 = Store.attach(getObjectBoxModel(), init.path);
+
+  final commandPort = ReceivePort();
+  init.sendPort.send(commandPort.sendPort);
+  init.sendPort.send(InternalStoreAccess.ptr(store2).address);
+
+  await for (final message in commandPort) {
+    if (message is int) {
+      final read = store2.box<TestEntity>().get(message);
+      init.sendPort.send(read?.tString);
+    } else if (message == null) {
+      store2.close();
+      init.sendPort.send(null);
+      break;
+    }
+  }
+
+  print('Store attach isolate finished');
+}

objectbox/test/isolates_test.dart

@@ -96,7 +96,6 @@ Future<void> testUsingStoreFromIsolate(Store Function(dynamic) storeCreator,
     return responseCompleter.future;
   };
 
-  // FIXME Send path instead of reference when using attach.
   // Pass the store to the isolate
   final env = TestEnv('isolates');
   expect(await call(storeRefGetter(env)), equals('store set'));