Enabled timeout for waitForUnlock

Author: CMCDragonkai

src/Lock.ts

@@ -2,7 +2,7 @@ import type { MutexInterface } from 'async-mutex';
 import type { ResourceAcquire } from '@matrixai/resources';
 import { Mutex, withTimeout } from 'async-mutex';
 import { withF, withG } from '@matrixai/resources';
-import { yieldMicro } from './utils';
+import { sleep, yieldMicro } from './utils';
 import { ErrorAsyncLocksTimeout } from './errors';
 
 class Lock {
@@ -43,8 +43,21 @@ class Lock {
     return this._lock.isLocked();
   }
 
-  public async waitForUnlock(): Promise<void> {
-    return this._lock.waitForUnlock();
+  public async waitForUnlock(timeout?: number): Promise<void> {
+    if (timeout != null) {
+      let timedOut = false;
+      await Promise.race([
+        this._lock.waitForUnlock(),
+        sleep(timeout).then(() => {
+          timedOut = true;
+        }),
+      ]);
+      if (timedOut) {
+        throw new ErrorAsyncLocksTimeout();
+      }
+    } else {
+      await this._lock.waitForUnlock();
+    }
   }
 
   public async withF<T>(

src/RWLockReader.ts

@@ -2,7 +2,7 @@ import type { MutexInterface } from 'async-mutex';
 import type { ResourceAcquire } from '@matrixai/resources';
 import { Mutex, withTimeout } from 'async-mutex';
 import { withF, withG } from '@matrixai/resources';
-import { yieldMicro } from './utils';
+import { sleep, yieldMicro } from './utils';
 import { ErrorAsyncLocksTimeout } from './errors';
 
 /**
@@ -83,8 +83,21 @@ class RWLockReader {
     return this.lock.isLocked();
   }
 
-  public async waitForUnlock(): Promise<void> {
-    return this.lock.waitForUnlock();
+  public async waitForUnlock(timeout?: number): Promise<void> {
+    if (timeout != null) {
+      let timedOut = false;
+      await Promise.race([
+        this.lock.waitForUnlock(),
+        sleep(timeout).then(() => {
+          timedOut = true;
+        }),
+      ]);
+      if (timedOut) {
+        throw new ErrorAsyncLocksTimeout();
+      }
+    } else {
+      await this.lock.waitForUnlock();
+    }
   }
 
   public async withReadF<T>(

src/RWLockWriter.ts

@@ -135,12 +135,27 @@ class RWLockWriter {
     return this.readersLock.isLocked() || this.writersLock.isLocked();
   }
 
-  public async waitForUnlock(): Promise<void> {
-    await Promise.all([
-      this.readersLock.waitForUnlock(),
-      this.writersLock.waitForUnlock(),
-    ]);
-    return;
+  public async waitForUnlock(timeout?: number): Promise<void> {
+    if (timeout != null) {
+      let timedOut = false;
+      await Promise.race([
+        Promise.all([
+          this.readersLock.waitForUnlock(),
+          this.writersLock.waitForUnlock(),
+        ]),
+        sleep(timeout).then(() => {
+          timedOut = true;
+        }),
+      ]);
+      if (timedOut) {
+        throw new ErrorAsyncLocksTimeout();
+      }
+    } else {
+      await Promise.all([
+        this.readersLock.waitForUnlock(),
+        this.writersLock.waitForUnlock(),
+      ]);
+    }
   }
 
   public async withReadF<T>(

tests/Lock.test.ts

@@ -195,4 +195,21 @@ describe(Lock.name, () => {
     expect(lock.isLocked()).toBe(false);
     expect(lock.count).toBe(0);
   });
+  test('timeout waiting for unlock', async () => {
+    const lock = new Lock();
+    await lock.waitForUnlock(100);
+    await withF([lock.lock()], async ([lock]) => {
+      await expect(lock.waitForUnlock(100)).rejects.toThrow(
+        errors.ErrorAsyncLocksTimeout,
+      );
+    });
+    await lock.waitForUnlock(100);
+    const g = withG([lock.lock()], async function* ([lock]) {
+      await expect(lock.waitForUnlock(100)).rejects.toThrow(
+        errors.ErrorAsyncLocksTimeout,
+      );
+    });
+    await g.next();
+    await lock.waitForUnlock(100);
+  });
 });

tests/RWLockReader.test.ts

@@ -445,4 +445,21 @@ describe(RWLockReader.name, () => {
     expect(lock.readerCount).toBe(0);
     expect(lock.writerCount).toBe(0);
   });
+  test('timeout waiting for unlock', async () => {
+    const lock = new RWLockReader();
+    await lock.waitForUnlock(100);
+    await withF([lock.read()], async ([lock]) => {
+      await expect(lock.waitForUnlock(100)).rejects.toThrow(
+        errors.ErrorAsyncLocksTimeout,
+      );
+    });
+    await lock.waitForUnlock(100);
+    const g = withG([lock.write()], async function* ([lock]) {
+      await expect(lock.waitForUnlock(100)).rejects.toThrow(
+        errors.ErrorAsyncLocksTimeout,
+      );
+    });
+    await g.next();
+    await lock.waitForUnlock(100);
+  });
 });

tests/RWLockWriter.test.ts

@@ -442,4 +442,21 @@ describe(RWLockWriter.name, () => {
     expect(lock.readerCount).toBe(0);
     expect(lock.writerCount).toBe(0);
   });
+  test('timeout waiting for unlock', async () => {
+    const lock = new RWLockWriter();
+    await lock.waitForUnlock(100);
+    await withF([lock.read()], async ([lock]) => {
+      await expect(lock.waitForUnlock(100)).rejects.toThrow(
+        errors.ErrorAsyncLocksTimeout,
+      );
+    });
+    await lock.waitForUnlock(100);
+    const g = withG([lock.write()], async function* ([lock]) {
+      await expect(lock.waitForUnlock(100)).rejects.toThrow(
+        errors.ErrorAsyncLocksTimeout,
+      );
+    });
+    await g.next();
+    await lock.waitForUnlock(100);
+  });
 });