Use of Isolates

[CharlotteJu]

Hello,

I apologize for bothering you but I must be missing something, I can't figure out how to properly use Isolates with Drift.

To make it short:

I need to access my DB directly and sometimes via Isolates from the WorkManager.

Before seeing your section on Isolates, sometimes it worked with my basic implementation, sometimes I had the error message Exception: No platform channel handler registered for background isolate.

Then I came across your doc.
I can't do all the processing of my isolate from a DriftIsolate.spawn(), or the computeWithDatabase, I need to have access to other classes and all the logic already built (then, I use 2 different DBs within my app).
Also, I use getIt dependency injection.

I tried to do this:

@singleton
@DriftDatabase(
  tables: [
    EntityErrors,
    ErrorDetails,
  ],
)
class SynchroErrorsDatabase extends _$SynchroErrorsDatabase {
  /// Fully functional before adding the code for isolates
  SynchroErrorsDatabase() : super(_openConnection());

  SynchroErrorsDatabase.forIsolate(QueryExecutor e) : super(e);
  /// Fully functional before adding the code for isolates
  SynchroErrorsDatabase.test(QueryExecutor e) : super(e);

  @override
  int get schemaVersion => 1;
}

/// Fully functional before adding the code for isolates
LazyDatabase _openConnection() {
  // the LazyDatabase util lets us find the right location for the file async.
  return LazyDatabase(() async {
    // put the database file, called db.sqlite here, into the documents folder
    // for your app.
    if (kDebugMode) {
      print("_openConnectionSynchroErrors");
    }
    final dbFolder = await getApplicationDocumentsDirectory();
    final file = File(p.join(dbFolder.path, "SynchroErrorDb"));
    return NativeDatabase.createInBackground(file);
  });
}
Future<DriftIsolate> _createDriftIsolate() async {
  final dbFolder = await getApplicationDocumentsDirectory();
  final file = File(p.join(dbFolder.path, "SynchroErrorDb"));
  return DriftIsolate.spawn(() => NativeDatabase.createInBackground(file));
}

Future<SynchroErrorsDatabase> openIsolateSynchroErrorDatabase() async {
  final isolate = await _createDriftIsolate();
  if (kDebugMode) {
    print("_openConnectionSynchroIsolate");
  }
  final connection = await isolate.connect();
  return SynchroErrorsDatabase.forIsolate(connection.executor);
}

Then, at the beginning of my isolate, I do:

Future<void> run(IsolateData data) async {
   try {
     BackgroundIsolateBinaryMessenger.ensureInitialized(data.token);
     final getIt = GetIt.instance;
     await getIt.init();
     await isolateGetIt.unregister<SynchroErrorsDatabase>();
     final synchroDbIsolate = await openIsolateSynchroErrorDatabase();
     isolateGetIt.registerSingleton<SynchroErrorsDatabase>(synchroDbIsolate);
     XXX logic XXX 
     data.sendPort.send(response);
   } catch (e) {
     data.sendPort.send(e.toString());
   }
 }

But already, I have a warning that is displayed when my isolate opens and I call getIt.init() to retrieve my DB.

WARNING (drift): It looks like you've created the database class SynchroErrorsDatabase multiple times. When these two databases use the same QueryExecutor, race conditions will occur and might corrupt the database.

I feel like I'm not doing things right but I don't know where, can you help me please?

Thanks in advance!

[simolus3]

But already, I have a warning that is displayed when my isolate opens and I call getIt.init() to retrieve my DB.

What is isolateGetIt (vs the normal getIt)? Static fields like getIt are not shared across isolates, so getIt.init() might attempt to open the database the same way the main isolate is opening it.
Also, is the run method you've shown running in a work manager context? How does it have access to the root messenger token?

You also don't have to combine DriftIsolate.spawn with NativeDatabase.creaetInBackground, as the latter already creates an isolate. Essentially, the best approach depends on whether the connection in your main isolate and the one for the workmanager can be independent (where independent means that they're accessing the same database file, but don't synchronize stream queries).
For independent connections, you don't need any isolate-specific overrides at all - just ensure that the background isolate messenger is properly initialized and then open the database in the regular way.
For connections that do have to synchronize, I would consider using the shareAcrossIsolate option from drift_flutter which simplifies these setups.

[CharlotteJu]

Yes sorry for the isolateGetIt, it's a bad replacement for copy-paste, I had tried to create a getIt specific to the isolate. 


Yes the run method is launched by the WorkManager but I don't understand what you mean by the « root messenger token » ?


Okay, so leaving only the NativeDatabase.createInBackground should be enough, that's what I was doing before.

But the problem is that when I run the task via the WorkManager, I get this error when I want to access the database ...

No platform channel handler registered for background isolate.

Ex methods call : 


TEST 1 : Exception


return await (database.entityErrors.select()
     ..where((t) => t.entityId.equals(entityId))
     ..where((t) => t.type.equals(type)))
   .getSingleOrNull();

TEST 2 : Exception

var table = database.entityErrors;
var query = """
SELECT * FROM ${table.aliasedName}
WHERE ${table.entityId.name} = $entityId
AND ${table.type.name} = $type
LIMIT 1
""";

var response = await database.customSelect(query).getSingleOrNull();
if (response == null) return null;
return EntityError(
  id: response.read<int>(table.id.name),
  entityId: response.read<int>(table.entityId.name),
  type: response.read<int>(table.type.name),
  parentId: response.read<int?>(table.parentId.name),
  parentType: response.read<int?>(table.parentType.name),
);



CREATE : Exception

int parentId = await database.into(database.entityErrors).insert(entity.entityError);

[simolus3]

Yes the run method is launched by the WorkManager but I don't understand what you mean by the « root messenger token » ?

Sorry, I meant the rootIsolateToken. Your original snippet includes BackgroundIsolateBinaryMessenger.ensureInitialized(data.token) - where does data.token come from? I'm not familiar with workmanager, from the readme it looks like only strings can be sent to tasks.

No platform channel handler registered for background isolate.

This error occurs because you need to use method channels to resolve the path of the database via getApplicationDocumentsDirectory. Method channels are only available in the main isolate if you don't send the rootIsolateToken to another isolate and install it there. Looking at run I thought you were doing that.

[CharlotteJu]

No worries, actually I hadn't put the code of the callbackDispatcher of my WorkManager:

Workmanager().executeTask((task, inputData) async {  
  ReceivePort port = ReceivePort();
  RootIsolateToken rootIsolateToken = RootIsolateToken.instance!;
  await Isolate.spawn<IsolateData>(
      IsolateSendData().run, // Method that calls my database written above
      IsolateData(
        port.sendPort,
        rootIsolateToken,
      ));
  XXX
}

The token is therefore created in the WorkManager and not passed to the task

[simolus3]

And the updated run method only calls the regular constructor using _openConnection()? Or is there another isolate involved?

[CharlotteJu]

It's the only Isolate in all my app

[simolus3]

Ok, so looking at e.g. this, it appears to be possible to use the platform manager in workmanager tasks. This means that you won't be able to regularly open your drift database from within the work manager task, as getApplicationDocumentsDirectory() is simply not available.

I think this approach should work:

1. Extract the logic used to find the path for the database into a standalone function.
2. Use that to open the database on the main isolate.
3. When registering a work manager task, tell it about the path to the database using inputData.

So in the end, it could look like this:

Future<File> _databaseFile() async {
  final dbFolder = await getApplicationDocumentsDirectory();
  return File(p.join(dbFolder.path, "SynchroErrorDb"));
}

LazyDatabase _openConnection() {
  // the LazyDatabase util lets us find the right location for the file async.
  return LazyDatabase(() async {
    return NativeDatabase.createInBackground(await _databaseFile());
  });
}

In your main isolate, you use a normal SynchroErrorsDatabase(). When creating the task, you use inputData: {'databasePath': (await _databaseFile()).absolute.path}. Then, inside the workmanager task, you use SynchroErrorsDatabase.forIsolate(NativeDatabase(File(inputData['databasePath']!))).