Change lock granularity; use locking for all relevant tasks.

Author: adewes

src/actor.ts

@@ -19,26 +19,26 @@ export interface Cache<T, G> {
     get(...args: any[]): Promise<T>
 }
 
-type Task = [string, Date, number]
-
-function timeout(ms: number) {
-    return new Promise((resolve) => setTimeout(resolve, ms))
+interface Task {
+    name: string
 }
 
 export function locked<T, G extends Actor>(
     f: (this: G, ...args: any[]) => Promise<T | Error>
 ): (this: G, ...args: any[]) => Promise<T | Error> {
     return async function (this: G, ...args: any[]): Promise<T | Error> {
         // we lock the task
-        if ((await this.lock(f.name)) === false)
-            return { status: Status.Failed } // we can't obtain a lock
-
-        const result = await f.apply(this, args)
-
-        // we unlock the task
-        this.unlock(f.name)
-
-        return result
+        const [task, existing] = this.lock(f.name)
+        if (existing) return { status: Status.Failed } // we can't obtain a lock
+        try {
+            return await f.apply(this, args)
+        } catch (e) {
+            console.log(e)
+            return { status: Status.Failed }
+        } finally {
+            // we unlock the task
+            this.unlock(f.name)
+        }
     }
 }
 
@@ -94,19 +94,15 @@ export class Actor extends Observer {
     public actor: string
     public id: string
 
-    private _taskId: number
-    private _tasks: Task[]
-    private _locked: boolean
+    private _tasks: { [Key: string]: Task }
 
     constructor(actor: string, id: string, backend: Backend) {
         // the ID will be used to address local storage so that e.g. we can
         // manage multiple providers, users etc. if necessary...
 
         super()
 
-        this._taskId = 0
-        this._tasks = []
-        this._locked = false
+        this._tasks = {}
 
         this.actor = actor
         this.id = id
@@ -132,36 +128,21 @@ export class Actor extends Observer {
     }
 
     unlock(task: string) {
-        if (this._tasks.length === 0) return false // should never happen
-        if (this._tasks[0][0] !== task) return false // wrong task order (should not happen)
-        this._tasks = this._tasks.slice(1)
-        return true
+        delete this._tasks[task]
     }
 
-    async lock(task: string) {
-        if (this._tasks.find((t: Task) => t[0] === task) !== undefined) {
-            console.warn(
-                `Task ${this.actor}::${this.id}::${task} is already in queue, aborting...`
-            )
-            return false
+    lock(task: string): [Task, boolean] {
+        if (this._tasks[task] === undefined) {
+            this._tasks[task] = {
+                name: task,
+            }
+            return [this._tasks[task], false]
         }
 
-        const taskId = this._taskId++
-        this._tasks.push([task, new Date(), taskId])
-
-        while (true) {
-            if (this._tasks.length === 0) return false // should not happen
-            const [t, dt, id] = this._tasks[0]
-            if (id === taskId) break // it's our turn
-            if (new Date().getTime() - dt.getTime() > 1000 * 10)
-                // tasks time out after 10 seconds
-                this._tasks = this._tasks.slice(1)
-            await timeout(10)
-        }
-        return true
+        return [this._tasks[task], true]
     }
 
     clearLocks() {
-        this._tasks = []
+        this._tasks = {}
     }
 }

src/provider/backup-data.ts

@@ -30,7 +30,7 @@ export interface CloudBackupData extends BackupData {
     data: ProviderData | null
 }
 
-interface BackupDataResult extends Result {
+export interface BackupDataResult extends Result {
     data: AESData
 }
 

src/provider/index.ts

@@ -13,7 +13,7 @@ import { getAppointments } from "./get-appointments"
 
 import { buf2base32, b642buf } from "../helpers/conversion"
 import { randomBytes } from "../crypto"
-import { Actor, cached } from "../actor"
+import { Actor, cached, locked } from "../actor"
 import { Backend } from "../backend"
 
 import {
@@ -28,14 +28,16 @@ import {
 export * from "./helpers"
 
 export class Provider extends Actor {
-    public backupData = backupData
-    public checkData = checkData
-    public storeData = storeData
+    public backupData = locked(backupData)
+    public checkData = locked(checkData)
+    public storeData = locked(storeData)
+    public restoreFromBackup = locked(restoreFromBackup)
+    public publishAppointments = locked(publishAppointments)
+    public generateKeyPairs = locked(generateKeyPairs)
+    public appointments = cached(locked(getAppointments), "appointments")
+
+    // helper/convenience functions
     public createAppointment = createAppointment
-    public restoreFromBackup = restoreFromBackup
-    public publishAppointments = publishAppointments
-    public generateKeyPairs = generateKeyPairs
-    public appointments = cached(getAppointments, "appointments")
 
     constructor(id: string, backend: Backend) {
         super("provider", id, backend)

src/provider/restore-from-backup.ts

@@ -8,7 +8,7 @@ import { Provider } from "./"
 import { LocalBackupData, CloudBackupData } from "./backup-data"
 import { AESData, Result, Error, Status, ErrorType } from "../interfaces"
 
-interface RestoreFromBackupResult extends Result {
+export interface RestoreFromBackupResult extends Result {
     data: { [Key: string]: any } | null
 }
 

src/user/backup-data.ts

@@ -30,7 +30,7 @@ export interface CloudBackupData extends BackupData {
     acceptedAppointment: AcceptedAppointment | null
 }
 
-interface BackupDataResult extends Result {
+export interface BackupDataResult extends Result {
     data: AESData
 }
 

src/user/book-appointment.ts

@@ -15,7 +15,7 @@ import {
 } from "../interfaces"
 import { User } from "./"
 
-interface BookAppointmentResult extends Result {
+export interface BookAppointmentResult extends Result {
     acceptedAppointment: AcceptedAppointment
 }
 

src/user/get-token.ts

@@ -13,7 +13,7 @@ import {
 import { User } from "./"
 import { Result, Error, ContactData, Status } from "../interfaces"
 
-interface GetTokenResult extends Result {}
+export interface GetTokenResult extends Result {}
 
 async function hashContactData(data: ContactData) {
     const hashData = {

src/user/index.ts

@@ -23,17 +23,17 @@ import {
     ProviderAppointments,
 } from "../interfaces"
 
-import { Actor, cached } from "../actor"
+import { Actor, cached, locked } from "../actor"
 
 export class User extends Actor {
-    public restoreFromBackup = restoreFromBackup
-    public cancelAppointment = cancelAppointment
-    public generateKeyPairs = generateKeyPairs
-    public bookAppointment = bookAppointment
-    public appointments = cached(getAppointments, "appointments")
-    public appointment = cached(getAppointment, "appointment")
-    public backupData = backupData
-    public getToken = getToken
+    public restoreFromBackup = locked(restoreFromBackup)
+    public cancelAppointment = locked(cancelAppointment)
+    public generateKeyPairs = locked(generateKeyPairs)
+    public bookAppointment = locked(bookAppointment)
+    public appointments = cached(locked(getAppointments), "appointments")
+    public appointment = cached(locked(getAppointment), "appointment")
+    public backupData = locked(backupData)
+    public getToken = locked(getToken)
 
     private generateSecret() {
         this.secret = buf2base32(b642buf(randomBytes(10)))