WIP

Author: CMCDragonkai

src/DB.ts

@@ -37,8 +37,8 @@ class DB {
   public static async createDB({
     dbPath,
     crypto,
-    fs = require('fs'),
     deadlock = false,
+    fs = require('fs'),
     logger = new Logger(this.name),
     fresh = false,
     ...dbOptions
@@ -48,16 +48,16 @@ class DB {
       key: Buffer;
       ops: Crypto;
     };
+    deadlock?: boolean;
     fs?: FileSystem;
     logger?: Logger;
-    deadlock?: boolean;
     fresh?: boolean;
   } & DBOptions): Promise<DB> {
     logger.info(`Creating ${this.name}`);
     const db = new this({
       dbPath,
-      fs,
       deadlock,
+      fs,
       logger,
     });
     await db.start({
@@ -78,7 +78,7 @@ class DB {
   protected logger: Logger;
   protected workerManager?: DBWorkerManagerInterface;
   protected _lockBox: LockBox<RWLockWriter> = new LockBox();
-  protected _locksPending?: Map<string, { count: number}>;
+  protected _locksPending?: Map<string, { count: number }>;
   protected _db: RocksDBDatabase;
   /**
    * References to iterators
@@ -113,21 +113,21 @@ class DB {
 
   constructor({
     dbPath,
-    fs,
     deadlock,
+    fs,
     logger,
   }: {
     dbPath: string;
-    fs: FileSystem;
     deadlock: boolean;
+    fs: FileSystem;
     logger: Logger;
   }) {
     this.logger = logger;
     this.dbPath = dbPath;
-    this.fs = fs;
     if (deadlock) {
       this._locksPending = new Map();
     }
+    this.fs = fs;
   }
 
   public async start({

src/DBTransaction.ts

@@ -1,4 +1,3 @@
-import type { ResourceRelease } from '@matrixai/resources';
 import type { LockBox } from '@matrixai/async-locks';
 import type DB from './DB';
 import type {
@@ -19,7 +18,7 @@ import {
   Monitor,
   Lock,
   RWLockWriter,
-  errors as asyncLocksErrors
+  errors as asyncLocksErrors,
 } from '@matrixai/async-locks';
 import DBIterator from './DBIterator';
 import { rocksdbP } from './native';
@@ -63,12 +62,7 @@ class DBTransaction {
     logger.debug(`Constructing ${this.constructor.name}`);
     this.logger = logger;
     this._db = db;
-    // This creates the monitor that I care about
-    this.monitor = new Monitor(
-      lockBox,
-      RWLockWriter,
-      locksPending
-    );
+    this.monitor = new Monitor(lockBox, RWLockWriter, locksPending);
     const options_ = {
       ...options,
       // Transactions should be synchronous

src/errors.ts

@@ -88,8 +88,7 @@ class ErrorDBTransactionLockType<T> extends ErrorDBTransaction<T> {
 }
 
 class ErrorDBTransactionDeadlock<T> extends ErrorDBTransaction<T> {
-  static description =
-    'DBTransaction encountered a pessimistic deadlock';
+  static description = 'DBTransaction encountered a pessimistic deadlock';
 }
 
 export {

src/types.ts

@@ -1,5 +1,4 @@
 import type fs from 'fs';
-import type { RWLockWriter } from '@matrixai/async-locks';
 import type { WorkerManagerInterface } from '@matrixai/workers';
 import type {
   RocksDBDatabaseOptions,
@@ -17,13 +16,6 @@ import type {
  */
 type POJO = { [key: string]: any };
 
-/**
- * Any type that can be turned into a string
- */
-// interface ToString {
-//   toString(): string;
-// }
-
 /**
  * Opaque types are wrappers of existing types
  * that require smart constructors
@@ -159,14 +151,8 @@ type DBOp =
 
 type DBOps = Array<DBOp>;
 
-// type MultiLockRequest = [
-//   key: ToString,
-//   ...lockingParams: Parameters<RWLockWriter['lock']>,
-// ];
-
 export type {
   POJO,
-  // ToString,
   Opaque,
   Callback,
   Merge,
@@ -182,5 +168,4 @@ export type {
   DBBatch,
   DBOp,
   DBOps,
-  // MultiLockRequest,
 };

tests/DBTransaction.test.ts

@@ -1139,4 +1139,30 @@ describe(DBTransaction.name, () => {
       });
     });
   });
+  test('deadlock detection', async () => {
+    const dbPath = `${dataDir}/db2`;
+    const db = await DB.createDB({ dbPath, crypto, deadlock: true, logger });
+    const barrier = await Barrier.createBarrier(2);
+    const results = await Promise.allSettled([
+      db.withTransactionF(async (tran1) => {
+        await tran1.lock('foo');
+        await barrier.wait();
+        await tran1.lock('bar');
+      }),
+      db.withTransactionF(async (tran2) => {
+        await tran2.lock('bar');
+        await barrier.wait();
+        await tran2.lock('foo');
+      }),
+    ]);
+    expect(
+      results.some(
+        (r) =>
+          r.status === 'rejected' &&
+          r.reason instanceof errors.ErrorDBTransactionDeadlock,
+      ),
+    ).toBe(true);
+    expect(results.some((r) => r.status === 'fulfilled')).toBe(true);
+    await db.stop();
+  });
 });