superlock 1.3.5 → 1.4.1

package/README.md

@@ -1,6 +1,6 @@
-![Last version](https://img.shields.io/github/tag/Kikobeats/superlock.svg?style=flat-square)
-[![Coverage Status](https://img.shields.io/coveralls/github/Kikobeats/superlock?style=flat-square)](https://coveralls.io/github/Kikobeats/superlock)
-[![NPM Status](https://img.shields.io/npm/dm/superlock.svg?style=flat-square)](https://www.npmjs.org/package/superlock)
+[![Last version](https://img.shields.io/github/v/tag/Kikobeats/superlock?style=flat-square)](https://github.com/Kikobeats/superlock/releases)
+[![Coverage Status](https://img.shields.io/coverallsCoverage/github/Kikobeats/superlock?style=flat-square)](https://coveralls.io/github/Kikobeats/superlock)
+[![NPM Status](https://img.shields.io/npm/dm/superlock?style=flat-square)](https://www.npmjs.com/package/superlock)
 
 > A mutex/semaphore implementation made easy to use.
 

package/package.json

@@ -2,12 +2,13 @@
   "name": "superlock",
   "description": "Minimal async mutex and semaphore for serializing critical sections in Node.js.",
   "homepage": "https://github.com/Kikobeats/superlock",
-  "version": "1.3.5",
+  "version": "1.4.1",
   "types": "src/index.d.ts",
   "main": "src/index.js",
   "exports": {
     ".": "./src/index.js",
-    "./create": "./src/create.js"
+    "./create": "./src/create.js",
+    "./fair": "./src/fair.js"
   },
   "author": {
     "email": "josefrancisco.verdu@gmail.com",

package/src/create.js

@@ -1,45 +1,6 @@
 'use strict'
 
-class Node {
-  constructor (data) {
-    this.data = data
-  }
-}
-
-class LinkedList {
-  constructor () {
-    this.length = 0
-  }
-
-  enqueue (data) {
-    const node = new Node(data)
-    node.prev = this.tail
-    if (this.tail) this.tail.next = node
-    else this.head = node
-    this.tail = node
-    this.length++
-    return node
-  }
-
-  dequeue () {
-    if (!this.head) return
-    const { data } = this.head
-    this.remove(this.head)
-    return data
-  }
-
-  remove (node) {
-    if (node.prev) node.prev.next = node.next
-    else this.head = node.next
-    if (node.next) node.next.prev = node.prev
-    else this.tail = node.prev
-    this.length--
-  }
-
-  size () {
-    return this.length
-  }
-}
+const LinkedList = require('./linked-list')
 
 module.exports = (slots = 1) => {
   const queue = new LinkedList()

package/src/fair.js

@@ -0,0 +1,86 @@
+'use strict'
+
+const LinkedList = require('./linked-list')
+
+const SHARED = Symbol('shared')
+const NONE = Symbol('none')
+
+module.exports = (slots = 1) => {
+  const queues = new Map()
+  const ring = new LinkedList()
+  let waiting = 0
+  let last = NONE
+
+  const drop = entry => {
+    ring.remove(entry.ringNode)
+    queues.delete(entry.key)
+  }
+
+  const enqueue = (key, waiter) => {
+    let entry = queues.get(key)
+    if (!entry) {
+      entry = { key, queue: new LinkedList(), ringNode: ring.enqueue(key) }
+      queues.set(key, entry)
+    }
+    waiting++
+    waiter.entry = entry
+    waiter.node = entry.queue.enqueue(waiter)
+  }
+
+  const grant = () => {
+    if (ring.size() === 0) return
+    const current = queues.get(last)
+    const node =
+      current && current.ringNode.next ? current.ringNode.next : ring.head
+    const entry = queues.get(node.data)
+    const waiter = entry.queue.dequeue()
+    waiting--
+    if (entry.queue.size() === 0) drop(entry)
+    last = entry.key
+    waiter.acquire()
+  }
+
+  const release = () => {
+    ++slots
+    grant()
+  }
+
+  const acquire = (resolve, key) => {
+    --slots
+    last = key
+    resolve(release)
+  }
+
+  const lock = (signal, key) =>
+    new Promise(resolve => {
+      if (signal != null && typeof signal.addEventListener !== 'function') {
+        throw new TypeError('`signal` needs to be an AbortSignal.')
+      }
+      const id = key === undefined ? SHARED : key
+      if (signal?.aborted) return resolve(null)
+      if (!lock.isLocked()) return acquire(resolve, id)
+
+      const waiter = { acquire: () => acquire(resolve, id) }
+      enqueue(id, waiter)
+
+      if (signal != null) {
+        const onAbort = () => {
+          waiter.entry.queue.remove(waiter.node)
+          waiting--
+          if (waiter.entry.queue.size() === 0) drop(waiter.entry)
+          resolve(null)
+        }
+        waiter.acquire = () => {
+          signal.removeEventListener('abort', onAbort)
+          acquire(resolve, id)
+        }
+        signal.addEventListener('abort', onAbort, { once: true })
+      }
+    })
+
+  lock.isLocked = () => slots === 0
+
+  lock.awaiting = () => waiting
+
+  return lock
+}

package/src/index.d.ts

@@ -9,6 +9,15 @@ interface LockInterface extends Lock {
 
 declare function createLock(slots?: number): LockInterface;
 
+declare type FairLock = (signal: AbortSignal | undefined | null, key?: unknown) => Promise<Release | null>;
+
+interface FairLockInterface extends FairLock {
+  isLocked: () => boolean;
+  awaiting: () => number;
+}
+
+declare function createFairLock(slots?: number): FairLockInterface;
+
 declare type WithLock = <T>(fn: () => Promise<T>, signal?: AbortSignal) => Promise<T | undefined>;
 
 interface WithLockInterface extends WithLock {
@@ -18,4 +27,4 @@ interface WithLockInterface extends WithLock {
 
 declare function withLock(opts?: number): WithLockInterface;
 
-export { withLock, createLock, WithLockInterface };
+export { withLock, createLock, createFairLock, WithLockInterface, FairLockInterface };

package/src/index.js

@@ -1,5 +1,6 @@
 'use strict'
 
+const createFairLock = require('./fair')
 const createLock = require('./create')
 
 const withLock = opts => {
@@ -21,4 +22,4 @@ const withLock = opts => {
   return withLock
 }
 
-module.exports = { withLock, createLock }
+module.exports = { withLock, createLock, createFairLock }

package/src/linked-list.js

@@ -0,0 +1,42 @@
+'use strict'
+
+class Node {
+  constructor (data) {
+    this.data = data
+  }
+}
+
+module.exports = class LinkedList {
+  constructor () {
+    this.length = 0
+  }
+
+  enqueue (data) {
+    const node = new Node(data)
+    node.prev = this.tail
+    if (this.tail) this.tail.next = node
+    else this.head = node
+    this.tail = node
+    this.length++
+    return node
+  }
+
+  dequeue () {
+    if (!this.head) return
+    const { data } = this.head
+    this.remove(this.head)
+    return data
+  }
+
+  remove (node) {
+    if (node.prev) node.prev.next = node.next
+    else this.head = node.next
+    if (node.next) node.next.prev = node.prev
+    else this.tail = node.prev
+    this.length--
+  }
+
+  size () {
+    return this.length
+  }
+}