@peerbit/react 0.0.2

package/src/__tests__/lockstorage.test.ts

@@ -0,0 +1,264 @@
+/* 
+ISC License (ISC)
+Copyright (c) 2016, Wes Cruver <chieffancypants@gmail.com>
+
+Permission to use, copy, modify, and/or distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright notice
+and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+THIS SOFTWARE.
+*/
+
+import { FastMutex } from "../lockstorage.js";
+import sinon from "sinon";
+
+import nodelocalstorage from "node-localstorage";
+import { jest } from "@jest/globals";
+import { delay } from "@peerbit/time";
+var LocalStorage = nodelocalstorage.LocalStorage;
+var localStorage = new LocalStorage("./tmp/FastMutex");
+globalThis.localStorage = localStorage;
+describe("FastMutex", () => {
+    let sandbox;
+    beforeEach(() => {
+        sandbox = sinon.createSandbox();
+        localStorage.clear();
+    });
+    afterEach(() => {
+        sandbox.restore();
+        localStorage.clear();
+        expect(localStorage.length).toEqual(0);
+    });
+
+    it("should immediately establish a lock when there is no contention", async () => {
+        const fm1 = new FastMutex({ localStorage: localStorage });
+
+        expect(fm1.isLocked("clientId")).toBeFalse();
+        const stats = await fm1.lock("clientId");
+        expect(fm1.isLocked("clientId")).toBeTrue();
+    });
+
+    it("When another client has a lock (Y is not 0), it should restart to acquire a lock at a later time", function () {
+        const fm1 = new FastMutex({
+            xPrefix: "xPrefix_",
+            yPrefix: "yPrefix_",
+            localStorage: localStorage,
+        });
+
+        const key = "clientId";
+        fm1.setItem(`yPrefix_${key}`, "someOtherMutexId");
+
+        setTimeout(() => {
+            localStorage.removeItem(`yPrefix_${key}`);
+        }, 20);
+
+        return fm1.lock(key).then(() => {
+            expect(fm1.getLockedInfo(key)).toBeDefined();
+        });
+    });
+
+    it("when contending for a lock and ultimately losing, it should restart", () => {
+        const key = "somekey";
+        const fm = new FastMutex({
+            localStorage: localStorage,
+            clientId: "uniqueId",
+        });
+        const stub = sandbox.stub(fm, "getItem");
+
+        // Set up scenario for lock contention where we lost Y
+        stub.onCall(0).returns(null); // getItem Y
+        stub.onCall(1).returns("lockcontention"); // getItem X
+        stub.onCall(2).returns("youLostTheLock"); // getItem Y
+
+        // fastmutex should have restarted, so let's free up the lock:
+        stub.onCall(3).returns(null);
+        stub.onCall(4).returns("uniqueId");
+
+        return fm.lock(key).then((stats) => {
+            expect(stats.restartCount).toEqual(1);
+            expect(stats.locksLost).toEqual(1);
+            expect(stats.contentionCount).toEqual(1);
+        });
+    });
+
+    it("When contending for a lock and ultimately winning, it should not restart", () => {
+        const key = "somekey";
+        const fm = new FastMutex({
+            localStorage: localStorage,
+            clientId: "uniqueId",
+        });
+        const stub = sandbox.stub(fm, "getItem");
+
+        // Set up scenario for lock contention where we lost Y
+        stub.onCall(0).returns(null); // getItem Y
+        stub.onCall(1).returns("lockContention");
+        stub.onCall(2).returns("uniqueId");
+
+        const spy = sandbox.spy(fm, "lock");
+
+        return fm.lock(key).then((stats) => {
+            expect(stats.restartCount).toEqual(0);
+            expect(stats.locksLost).toEqual(0);
+            expect(stats.contentionCount).toEqual(1);
+            expect(spy.callCount).toEqual(1);
+        });
+    });
+
+    // This is just to ensure that the internals of FastMutex have prefixes on the
+    // X and Y locks such that two different FM clients can acquire locks on
+    // different keys concurrently without clashing.
+    it("should not clash with other fastMutex locks", async () => {
+        const yPrefix = "yLock";
+        const xPrefix = "xLock";
+        const opts = { localStorage, yPrefix, xPrefix };
+
+        const fm1 = new FastMutex(opts);
+        const fm2 = new FastMutex(opts);
+
+        let lock1Acquired = false;
+        let lock2Acquired = false;
+
+        /* eslint-disable jest/valid-expect-in-promise */
+        const lock1Promise = fm1.lock("lock1").then((stats) => {
+            lock1Acquired = true;
+            expect(localStorage.getItem(yPrefix + "lock1")).toBeDefined();
+            return stats;
+        });
+
+        /* eslint-disable jest/valid-expect-in-promise */
+        const lock2Promise = fm2.lock("lock2").then((stats) => {
+            lock2Acquired = true;
+            expect(localStorage.getItem(yPrefix + "lock2")).toBeDefined();
+            return stats;
+        });
+
+        await Promise.all([lock1Promise, lock2Promise]).then(() => {
+            expect(lock1Acquired).toBeTrue();
+            expect(lock2Acquired).toBeTrue();
+        });
+    });
+
+    it("release() should remove the y lock in localStorage", () => {
+        const key = "somekey";
+        const fm1 = new FastMutex({
+            localStorage: localStorage,
+            clientId: "releaseTestId",
+            yPrefix: "yLock",
+        });
+        return fm1
+            .lock(key)
+            .then(() => {
+                expect(fm1.getItem("yLock" + key)).toEqual("releaseTestId");
+                return fm1.release(key);
+            })
+            .then(() => {
+                expect(fm1.getItem("yLock" + key)).toBeUndefined();
+            });
+    });
+
+    // this is essentially just a better way to test that two locks cannot get
+    // an exclusive lock until the other releases.  It's a bit more accurate
+    // than the test above ("release should remove the y lock in localstorage")
+    it("two clients should never get locks at the same time", function () {
+        const fm1 = new FastMutex({ localStorage: localStorage });
+        const fm2 = new FastMutex({ localStorage: localStorage });
+        let fm1LockReleased = false;
+        const lockHoldTime = 10;
+
+        return fm1
+            .lock("clientId")
+            .then(() => {
+                // before the lock is released, try to establish another lock:
+                var lock2Promise = fm2.lock("clientId");
+                expect(fm1LockReleased).toBeFalse();
+
+                // in a few milliseconds, release the lock
+                setTimeout(() => {
+                    fm1.release("clientId");
+                    fm1LockReleased = true;
+                }, lockHoldTime);
+
+                return lock2Promise;
+            })
+            .then((lock2) => {
+                // this will only execute once the other lock was released
+                expect(fm1LockReleased).toBeTrue();
+            });
+    });
+
+    it("should throw if lock is never acquired after set time period", function () {
+        jest.setTimeout(1000);
+        // this.slow(500);
+
+        const fm1 = new FastMutex({ localStorage: localStorage, timeout: 50 });
+        const fm2 = new FastMutex({ localStorage: localStorage, timeout: 50 });
+
+        const p = fm1.lock("timeoutTest").then(() => {
+            // fm2 will never get a lock as we're not releasing fm1's lock:
+            return fm2.lock("timeoutTest");
+        });
+
+        return expect(p).rejects.toThrowError();
+    });
+
+    it("should ignore expired locks", () => {
+        const fm1 = new FastMutex({
+            localStorage: localStorage,
+            timeout: 5000,
+            yPrefix: "yLock",
+            clientId: "timeoutClient",
+        });
+        const expiredRecord = {
+            expiresAt: new Date().getTime() - 5000,
+            value: "oldclient",
+        };
+
+        localStorage.setItem("yLocktimeoutTest", JSON.stringify(expiredRecord));
+        expect(
+            JSON.parse(localStorage.getItem("yLocktimeoutTest")).value
+        ).toEqual("oldclient");
+        return expect(fm1.lock("timeoutTest")).toResolve();
+    });
+
+    it("should reset the client stats after lock is released", async () => {
+        // without resetting the stats, the acquireStart will always be set, and
+        // after `timeout` ms, will be unable to acquire a lock anymore
+        const fm1 = new FastMutex({ localStorage: localStorage, timeout: 50 });
+        let keepLock = true;
+        let keepLockFn = () => keepLock;
+        await fm1.lock("resetStats", keepLockFn);
+        expect(fm1.isLocked("resetStats")).toBeTrue();
+        keepLock = false;
+        await delay(100); // await timeout
+        expect(fm1.isLocked("resetStats")).toBeFalse();
+        const p = fm1.lock("resetStats").then(() => fm1.release("resetStats"));
+        await expect(p).toResolve();
+    });
+
+    it("can keep lock with callback function", async () => {
+        const fm1 = new FastMutex({ localStorage: localStorage, timeout: 50 });
+        await fm1.lock("x");
+        await fm1.release("x");
+        expect(fm1.isLocked("x")).toBeFalse();
+        await fm1.lock("x").then(() => fm1.release("x"));
+    });
+
+    it("should reset the client stats if the lock has expired", async () => {
+        // in the event a lock cannot be acquired within `timeout`, acquireStart
+        // will never be reset, and a subsequent call (after the `timeout`) would
+        // immediately fail
+        const fm1 = new FastMutex({ localStorage: localStorage, timeout: 50 });
+
+        await fm1.lock("resetStats");
+
+        // try to acquire a lock after `timeout`:
+        await delay(50);
+        await expect(fm1.lock("resetStats")).toResolve();
+    });
+});

package/src/__tests__/utils.test.ts

@@ -0,0 +1,83 @@
+import { getAllKeyPairs, getFreeKeypair, releaseKey } from "../utils";
+import nodelocalstorage from "node-localstorage";
+import { FastMutex } from "../lockstorage";
+import { delay } from "@peerbit/time";
+import { default as sodium } from "libsodium-wrappers";
+import { v4 as uuid } from "uuid";
+var LocalStorage = nodelocalstorage.LocalStorage;
+var localStorage = new LocalStorage("./tmp/getKeypair");
+globalThis.localStorage = localStorage;
+
+describe("getKeypair", () => {
+    beforeAll(async () => {
+        await sodium.ready;
+    });
+
+    it("can aquire multiple keypairs", async () => {
+        let timeout = 1000;
+        let mutex = new FastMutex({ localStorage, timeout });
+        let lock = true;
+        const lockCondition = () => lock;
+        let id = uuid();
+        const { key: keypair, path: path1 } = await getFreeKeypair(
+            id,
+            mutex,
+            lockCondition
+        );
+        const { key: keypair2, path: path2 } = await getFreeKeypair(id, mutex);
+        expect(keypair!.equals(keypair2!)).toBeFalse();
+        expect(path1).not.toEqual(path2);
+        lock = false;
+        await delay(timeout);
+        const { path: path3, key: keypair3 } = await getFreeKeypair(id, mutex);
+        expect(path3).toEqual(path1);
+        expect(keypair3.equals(keypair)).toBeTrue();
+
+        const allKeypair = await getAllKeyPairs(id);
+        expect(allKeypair.map((x) => x.publicKey.hashcode())).toEqual([
+            keypair3.publicKey.hashcode(),
+            keypair2.publicKey.hashcode(),
+        ]);
+    });
+
+    it("can release if same id", async () => {
+        let timeout = 1000;
+        let mutex = new FastMutex({ localStorage, timeout });
+        let lock = true;
+        const lockCondition = () => lock;
+        let id = uuid();
+        const { key: keypair, path: path1 } = await getFreeKeypair(
+            id,
+            mutex,
+            lockCondition,
+            true
+        );
+        const { key: keypair2, path: path2 } = await getFreeKeypair(
+            id,
+            mutex,
+            undefined,
+            true
+        );
+        expect(keypair!.equals(keypair2!)).toBeTrue();
+        expect(path1).toEqual(path2);
+        const allKeypair = await getAllKeyPairs(id);
+        expect(allKeypair).toHaveLength(1);
+    });
+
+    it("releases manually", async () => {
+        let timeout = 1000;
+        let mutex = new FastMutex({ localStorage, timeout });
+        const id = uuid();
+
+        const { key: keypair, path: path1 } = await getFreeKeypair(id, mutex);
+
+        const { key: keypair2, path: path2 } = await getFreeKeypair(id, mutex);
+
+        expect(path1).not.toEqual(path2);
+        releaseKey(path1, mutex);
+        expect(mutex.getLockedInfo(path1)).toBeUndefined();
+        const { key: keypair3, path: path3 } = await getFreeKeypair(id, mutex);
+
+        expect(path1).toEqual(path3); // we can now acquire key at path1 again, since we released it
+    });
+});

package/src/index.ts

@@ -0,0 +1,8 @@
+export {
+    PeerProvider,
+    PeerContext,
+    usePeer,
+    submitKeypairChange,
+} from "./usePeer.js";
+export * from "./utils.js";
+export { FastMutex } from "./lockstorage.js";

package/src/lockstorage.ts

@@ -0,0 +1,249 @@
+/* 
+ISC License (ISC)
+Copyright (c) 2016, Wes Cruver <chieffancypants@gmail.com>
+
+Permission to use, copy, modify, and/or distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright notice
+and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+THIS SOFTWARE.
+*/
+
+import debugFn from "debug";
+import { v4 as uuid } from "uuid";
+const debug = debugFn("FastMutex");
+
+export class FastMutex {
+    clientId: string;
+    xPrefix: string;
+    yPrefix: string;
+    timeout: number;
+    localStorage: any;
+    intervals: Map<string, any>;
+
+    constructor({
+        clientId = uuid(),
+        xPrefix = "_MUTEX_LOCK_X_",
+        yPrefix = "_MUTEX_LOCK_Y_",
+        timeout = 5000,
+        localStorage = undefined,
+    } = {}) {
+        this.clientId = clientId;
+        this.xPrefix = xPrefix;
+        this.yPrefix = yPrefix;
+        this.timeout = timeout;
+        this.intervals = new Map();
+
+        this.localStorage = localStorage || window.localStorage;
+    }
+
+    lock(
+        key: string,
+        keepLocked?: () => boolean
+    ): Promise<{ restartCount: number; contentionCount; locksLost: number }> {
+        debug(
+            'Attempting to acquire Lock on "%s" using FastMutex instance "%s"',
+            key,
+            this.clientId
+        );
+        const x = this.xPrefix + key;
+        const y = this.yPrefix + key;
+        let acquireStart = +new Date();
+        return new Promise((resolve, reject) => {
+            // we need to differentiate between API calls to lock() and our internal
+            // recursive calls so that we can timeout based on the original lock() and
+            // not each subsequent call.  Therefore, create a new function here within
+            // the promise closure that we use for subsequent calls:
+            let restartCount = 0;
+            let contentionCount = 0;
+            let locksLost = 0;
+            const acquireLock = (key) => {
+                if (
+                    restartCount > 1000 ||
+                    contentionCount > 1000 ||
+                    locksLost > 1000
+                ) {
+                    reject("Failed to resolve lock");
+                }
+
+                const elapsedTime = new Date().getTime() - acquireStart;
+                if (elapsedTime >= this.timeout) {
+                    debug(
+                        'Lock on "%s" could not be acquired within %sms by FastMutex client "%s"',
+                        key,
+                        this.timeout,
+                        this.clientId
+                    );
+                    return reject(
+                        new Error(
+                            `Lock could not be acquired within ${this.timeout}ms`
+                        )
+                    );
+                }
+
+                this.setItem(x, this.clientId, keepLocked);
+
+                // if y exists, another client is getting a lock, so retry in a bit
+                let lsY = this.getItem(y);
+                if (lsY) {
+                    debug("Lock exists on Y (%s), restarting...", lsY);
+                    restartCount++;
+                    setTimeout(() => acquireLock(key));
+                    return;
+                }
+
+                // ask for inner lock
+                this.setItem(y, this.clientId, keepLocked);
+
+                // if x was changed, another client is contending for an inner lock
+                let lsX = this.getItem(x);
+                if (lsX !== this.clientId) {
+                    contentionCount++;
+                    debug('Lock contention detected. X="%s"', lsX);
+
+                    // Give enough time for critical section:
+                    setTimeout(() => {
+                        lsY = this.getItem(y);
+                        if (lsY === this.clientId) {
+                            // we have a lock
+                            debug(
+                                'FastMutex client "%s" won the lock contention on "%s"',
+                                this.clientId,
+                                key
+                            );
+                            resolve({
+                                contentionCount,
+                                locksLost,
+                                restartCount,
+                            });
+                        } else {
+                            // we lost the lock, restart the process again
+                            restartCount++;
+                            locksLost++;
+                            debug(
+                                'FastMutex client "%s" lost the lock contention on "%s" to another process (%s). Restarting...',
+                                this.clientId,
+                                key,
+                                lsY
+                            );
+                            setTimeout(() => acquireLock(key));
+                        }
+                    }, 50);
+                    return;
+                }
+
+                // no contention:
+                debug(
+                    'FastMutex client "%s" acquired a lock on "%s" with no contention',
+                    this.clientId,
+                    key
+                );
+                resolve({ contentionCount, locksLost, restartCount });
+            };
+
+            acquireLock(key);
+        });
+    }
+
+    isLocked(key: string) {
+        const x = this.xPrefix + key;
+        const y = this.yPrefix + key;
+        return !!this.getItem(x) || !!this.getItem(y);
+    }
+
+    getLockedInfo(key: string): string | undefined {
+        const x = this.xPrefix + key;
+        const y = this.yPrefix + key;
+        return this.getItem(x) || this.getItem(y);
+    }
+
+    release(key: string) {
+        debug(
+            'FastMutex client "%s" is releasing lock on "%s"',
+            this.clientId,
+            key
+        );
+        let ps = [this.yPrefix + key, this.xPrefix + key];
+        for (const p of ps) {
+            clearInterval(this.intervals.get(p));
+            this.intervals.delete(p);
+            this.localStorage.removeItem(p);
+        }
+    }
+
+    /**
+     * Helper function to wrap all values in an object that includes the time (so
+     * that we can expire it in the future) and json.stringify's it
+     */
+    setItem(key: string, value: any, keepLocked?: () => boolean) {
+        if (!keepLocked) {
+            return this.localStorage.setItem(
+                key,
+                JSON.stringify({
+                    expiresAt: new Date().getTime() + this.timeout,
+                    value,
+                })
+            );
+        } else {
+            let getExpiry = () => +new Date() + this.timeout;
+            const ret = this.localStorage.setItem(
+                key,
+                JSON.stringify({
+                    expiresAt: getExpiry(),
+                    value,
+                })
+            );
+            const interval = setInterval(() => {
+                if (!keepLocked()) {
+                    this.localStorage.setItem(
+                        // TODO, release directly?
+                        key,
+                        JSON.stringify({
+                            expiresAt: 0,
+                            value,
+                        })
+                    );
+                } else {
+                    this.localStorage.setItem(
+                        key,
+                        JSON.stringify({
+                            expiresAt: getExpiry(), // bump expiry
+                            value,
+                        })
+                    );
+                }
+            }, this.timeout);
+            this.intervals.set(key, interval);
+            return ret;
+        }
+    }
+
+    /**
+     * Helper function to parse JSON encoded values set in localStorage
+     */
+    getItem(key: string): string | undefined {
+        const item = this.localStorage.getItem(key);
+        if (!item) return;
+
+        const parsed = JSON.parse(item);
+        if (new Date().getTime() - parsed.expiresAt >= this.timeout) {
+            debug(
+                'FastMutex client "%s" removed an expired record on "%s"',
+                this.clientId,
+                key
+            );
+            this.localStorage.removeItem(key);
+            clearInterval(this.intervals.get(key));
+            this.intervals.delete(key);
+            return;
+        }
+
+        return JSON.parse(item).value;
+    }
+}

package/src/useMount.tsx

@@ -0,0 +1,15 @@
+import { type EffectCallback, useEffect, useRef } from "react";
+
+export const useMount = (effect: EffectCallback) => {
+    const mounted = useRef(false);
+
+    useEffect(() => {
+        if (!mounted.current) {
+            effect();
+        }
+
+        mounted.current = true;
+
+        return () => {};
+    }, [mounted.current]);
+};