matrix-react-sdk
Version:
SDK for matrix.org using React
262 lines (240 loc) • 36.2 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.SESSION_LOCK_CONSTANTS = void 0;
exports.checkSessionLockFree = checkSessionLockFree;
exports.getSessionLock = getSessionLock;
var _logger = require("matrix-js-sdk/src/logger");
var _uuid = require("uuid");
/*
Copyright 2024 New Vector Ltd.
Copyright 2023 The Matrix.org Foundation C.I.C.
SPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only
Please see LICENSE files in the repository root for full details.
*/
/*
* Functionality for checking that only one instance is running at once
*
* The algorithm here is twofold.
*
* First, we "claim" a lock by periodically writing to `STORAGE_ITEM_PING`. On shutdown, we clear that item. So,
* a new instance starting up can check if the lock is free by inspecting `STORAGE_ITEM_PING`. If it is unset,
* or is stale, the new instance can assume the lock is free and claim it for itself. Otherwise, the new instance
* has to wait for the ping to be stale, or the item to be cleared.
*
* Secondly, we need a mechanism for proactively telling existing instances to shut down. We do this by writing a
* unique value to `STORAGE_ITEM_CLAIMANT`. Other instances of the app are supposed to monitor for writes to
* `STORAGE_ITEM_CLAIMANT` and initiate shutdown when it happens.
*
* There is slight complexity in `STORAGE_ITEM_CLAIMANT` in that we need to watch out for yet another instance
* starting up and staking a claim before we even get a chance to take the lock. When that happens we just bail out
* and let the newer instance get the lock.
*
* `STORAGE_ITEM_OWNER` has no functional role in the lock mechanism; it exists solely as a diagnostic indicator
* of which instance is writing to `STORAGE_ITEM_PING`.
*/
const SESSION_LOCK_CONSTANTS = exports.SESSION_LOCK_CONSTANTS = {
/**
* LocalStorage key for an item which indicates we have the lock.
*
* The instance which holds the lock writes the current time to this key every few seconds, to indicate it is still
* alive and holds the lock.
*/
STORAGE_ITEM_PING: "react_sdk_session_lock_ping",
/**
* LocalStorage key for an item which holds the unique "session ID" of the instance which currently holds the lock.
*
* This property doesn't actually form a functional part of the locking algorithm; it is purely diagnostic.
*/
STORAGE_ITEM_OWNER: "react_sdk_session_lock_owner",
/**
* LocalStorage key for the session ID of the most recent claimant to the lock.
*
* Each instance writes to this key on startup, so existing instances can detect new ones starting up.
*/
STORAGE_ITEM_CLAIMANT: "react_sdk_session_lock_claimant",
/**
* The number of milliseconds after which we consider a lock claim stale
*/
LOCK_EXPIRY_TIME_MS: 30000
};
/**
* See if any instances are currently running
*
* @returns true if any instance is currently active
*/
function checkSessionLockFree() {
const prefixedLogger = _logger.logger.getChild(`checkSessionLockFree`);
const lastPingTime = window.localStorage.getItem(SESSION_LOCK_CONSTANTS.STORAGE_ITEM_PING);
if (lastPingTime === null) {
// no other holder
prefixedLogger.info("No other session has the lock");
return true;
}
const lockHolder = window.localStorage.getItem(SESSION_LOCK_CONSTANTS.STORAGE_ITEM_OWNER);
// see if it has expired
const timeAgo = Date.now() - parseInt(lastPingTime);
const remaining = SESSION_LOCK_CONSTANTS.LOCK_EXPIRY_TIME_MS - timeAgo;
if (remaining <= 0) {
// another session claimed the lock, but it is stale.
prefixedLogger.info(`Last ping (from ${lockHolder}) was ${timeAgo}ms ago: lock is free`);
return true;
}
prefixedLogger.info(`Last ping (from ${lockHolder}) was ${timeAgo}ms ago: lock is taken`);
return false;
}
/**
* Ensure that only one instance of the application is running at once.
*
* If there are any other running instances, tells them to stop, and waits for them to do so.
*
* Once we are the sole instance, sets a background job going to service a lock. Then, if another instance starts up,
* `onNewInstance` is called: it should shut the app down to make sure we aren't doing any more work.
*
* @param onNewInstance - callback to handle another instance starting up. NOTE: this may be called before
* `getSessionLock` returns if the lock is stolen before we get a chance to start.
*
* @returns true if we successfully claimed the lock; false if another instance stole it from under our nose
* (in which `onNewInstance` will have been called)
*/
async function getSessionLock(onNewInstance) {
/** unique ID for this session */
const sessionIdentifier = (0, _uuid.v4)();
const prefixedLogger = _logger.logger.getChild(`getSessionLock[${sessionIdentifier}]`);
/** The ID of our regular task to service the lock.
*
* Non-null while we hold the lock; null if we have not yet claimed it, or have released it. */
let lockServicer = null;
/**
* See if the lock is free.
*
* @returns
* - `>0`: the number of milliseconds before the current claim on the lock can be considered stale.
* - `0`: the lock is free for the taking
* - `<0`: someone else has staked a claim for the lock, so we are no longer in line for it.
*/
function checkLock() {
// first of all, check that we are still the active claimant (ie, another instance hasn't come along while we were waiting.
const claimant = window.localStorage.getItem(SESSION_LOCK_CONSTANTS.STORAGE_ITEM_CLAIMANT);
if (claimant !== sessionIdentifier) {
prefixedLogger.warn(`Lock was claimed by ${claimant} while we were waiting for it: aborting startup`);
return -1;
}
const lastPingTime = window.localStorage.getItem(SESSION_LOCK_CONSTANTS.STORAGE_ITEM_PING);
const lockHolder = window.localStorage.getItem(SESSION_LOCK_CONSTANTS.STORAGE_ITEM_OWNER);
if (lastPingTime === null) {
prefixedLogger.info("No other session has the lock: proceeding with startup");
return 0;
}
const timeAgo = Date.now() - parseInt(lastPingTime);
const remaining = SESSION_LOCK_CONSTANTS.LOCK_EXPIRY_TIME_MS - timeAgo;
if (remaining <= 0) {
// another session claimed the lock, but it is stale.
prefixedLogger.info(`Last ping (from ${lockHolder}) was ${timeAgo}ms ago: proceeding with startup`);
return 0;
}
prefixedLogger.info(`Last ping (from ${lockHolder}) was ${timeAgo}ms ago, waiting ${remaining}ms`);
return remaining;
}
function serviceLock() {
window.localStorage.setItem(SESSION_LOCK_CONSTANTS.STORAGE_ITEM_OWNER, sessionIdentifier);
window.localStorage.setItem(SESSION_LOCK_CONSTANTS.STORAGE_ITEM_PING, Date.now().toString());
}
// handler for storage events, used later
function onStorageEvent(event) {
if (event.key === SESSION_LOCK_CONSTANTS.STORAGE_ITEM_CLAIMANT) {
// It's possible that the event was delayed, and this update actually predates our claim on the lock.
// (In particular: suppose tab A and tab B start concurrently and both attempt to set STORAGE_ITEM_CLAIMANT.
// Each write queues up a `storage` event for all other tabs. So both tabs see the `storage` event from the
// other, even though by the time it arrives we may have overwritten it.)
//
// To resolve any doubt, we check the *actual* state of the storage.
const claimingSession = window.localStorage.getItem(SESSION_LOCK_CONSTANTS.STORAGE_ITEM_CLAIMANT);
if (claimingSession === sessionIdentifier) {
return;
}
prefixedLogger.info(`Session ${claimingSession} is waiting for the lock`);
window.removeEventListener("storage", onStorageEvent);
releaseLock().catch(err => {
prefixedLogger.error("Error releasing session lock", err);
});
}
}
// handler for pagehide and unload events, used later
function onPagehideEvent() {
// only remove the ping if we still think we're the owner. Otherwise we could be removing someone else's claim!
if (lockServicer !== null) {
prefixedLogger.debug("page hide: clearing our claim");
window.clearInterval(lockServicer);
window.localStorage.removeItem(SESSION_LOCK_CONSTANTS.STORAGE_ITEM_PING);
window.localStorage.removeItem(SESSION_LOCK_CONSTANTS.STORAGE_ITEM_OWNER);
lockServicer = null;
}
// It's worth noting that, according to the spec, the page might come back to life again after a pagehide.
//
// In practice that's unlikely because Element is unlikely to qualify for the bfcache, but if it does,
// this is probably the best we can do: we certainly don't want to stop the user loading any new tabs because
// Element happens to be in a bfcache somewhere.
//
// So, we just hope that we aren't in the middle of any crypto operations, and rely on `onStorageEvent` kicking
// in soon enough after we resume to tell us if another tab woke up while we were asleep.
}
async function releaseLock() {
// tell the app to shut down
await onNewInstance();
// and, once it has done so, stop pinging the lock.
if (lockServicer !== null) {
window.clearInterval(lockServicer);
}
window.localStorage.removeItem(SESSION_LOCK_CONSTANTS.STORAGE_ITEM_PING);
window.localStorage.removeItem(SESSION_LOCK_CONSTANTS.STORAGE_ITEM_OWNER);
lockServicer = null;
}
// first of all, stake a claim for the lock. This tells anyone else holding the lock that we want it.
window.localStorage.setItem(SESSION_LOCK_CONSTANTS.STORAGE_ITEM_CLAIMANT, sessionIdentifier);
// now, wait for the lock to be free.
// eslint-disable-next-line no-constant-condition
while (true) {
const remaining = checkLock();
if (remaining == 0) {
// ok, the lock is free, and nobody else has staked a more recent claim.
break;
} else if (remaining < 0) {
// someone else staked a claim for the lock; we bail out.
await onNewInstance();
return false;
}
// someone else has the lock.
// wait for either the ping to expire, or a storage event.
let onStorageUpdate;
const storageUpdatePromise = new Promise(resolve => {
onStorageUpdate = event => {
if (event.key === SESSION_LOCK_CONSTANTS.STORAGE_ITEM_PING || event.key === SESSION_LOCK_CONSTANTS.STORAGE_ITEM_CLAIMANT) resolve(event);
};
});
const sleepPromise = new Promise(resolve => {
setTimeout(resolve, remaining, undefined);
});
window.addEventListener("storage", onStorageUpdate);
await Promise.race([sleepPromise, storageUpdatePromise]);
window.removeEventListener("storage", onStorageUpdate);
}
// If we get here, we know the lock is ours for the taking.
// CRITICAL SECTION
//
// The following code, up to the end of the function, must all be synchronous (ie, no `await` calls), to ensure that
// we get our listeners in place and all the writes to localStorage done before other tabs run again.
// claim the lock, and kick off a background process to service it every 5 seconds
serviceLock();
lockServicer = window.setInterval(serviceLock, 5000);
// Now add a listener for other claimants to the lock.
window.addEventListener("storage", onStorageEvent);
// also add a listener to clear our claims when our tab closes or navigates away
window.addEventListener("pagehide", onPagehideEvent);
// The pagehide event is called unreliably on Firefox, so additionally add an unload handler.
// https://bugzilla.mozilla.org/show_bug.cgi?id=1854492
window.addEventListener("unload", onPagehideEvent);
return true;
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_logger","require","_uuid","SESSION_LOCK_CONSTANTS","exports","STORAGE_ITEM_PING","STORAGE_ITEM_OWNER","STORAGE_ITEM_CLAIMANT","LOCK_EXPIRY_TIME_MS","checkSessionLockFree","prefixedLogger","logger","getChild","lastPingTime","window","localStorage","getItem","info","lockHolder","timeAgo","Date","now","parseInt","remaining","getSessionLock","onNewInstance","sessionIdentifier","uuidv4","lockServicer","checkLock","claimant","warn","serviceLock","setItem","toString","onStorageEvent","event","key","claimingSession","removeEventListener","releaseLock","catch","err","error","onPagehideEvent","debug","clearInterval","removeItem","onStorageUpdate","storageUpdatePromise","Promise","resolve","sleepPromise","setTimeout","undefined","addEventListener","race","setInterval"],"sources":["../../src/utils/SessionLock.ts"],"sourcesContent":["/*\nCopyright 2024 New Vector Ltd.\nCopyright 2023 The Matrix.org Foundation C.I.C.\n\nSPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only\nPlease see LICENSE files in the repository root for full details.\n*/\n\nimport { logger } from \"matrix-js-sdk/src/logger\";\nimport { v4 as uuidv4 } from \"uuid\";\n\n/*\n * Functionality for checking that only one instance is running at once\n *\n * The algorithm here is twofold.\n *\n * First, we \"claim\" a lock by periodically writing to `STORAGE_ITEM_PING`. On shutdown, we clear that item. So,\n * a new instance starting up can check if the lock is free by inspecting `STORAGE_ITEM_PING`. If it is unset,\n * or is stale, the new instance can assume the lock is free and claim it for itself. Otherwise, the new instance\n * has to wait for the ping to be stale, or the item to be cleared.\n *\n * Secondly, we need a mechanism for proactively telling existing instances to shut down. We do this by writing a\n * unique value to `STORAGE_ITEM_CLAIMANT`. Other instances of the app are supposed to monitor for writes to\n * `STORAGE_ITEM_CLAIMANT` and initiate shutdown when it happens.\n *\n * There is slight complexity in `STORAGE_ITEM_CLAIMANT` in that we need to watch out for yet another instance\n * starting up and staking a claim before we even get a chance to take the lock. When that happens we just bail out\n * and let the newer instance get the lock.\n *\n * `STORAGE_ITEM_OWNER` has no functional role in the lock mechanism; it exists solely as a diagnostic indicator\n * of which instance is writing to `STORAGE_ITEM_PING`.\n */\n\nexport const SESSION_LOCK_CONSTANTS = {\n    /**\n     * LocalStorage key for an item which indicates we have the lock.\n     *\n     * The instance which holds the lock writes the current time to this key every few seconds, to indicate it is still\n     * alive and holds the lock.\n     */\n    STORAGE_ITEM_PING: \"react_sdk_session_lock_ping\",\n\n    /**\n     * LocalStorage key for an item which holds the unique \"session ID\" of the instance which currently holds the lock.\n     *\n     * This property doesn't actually form a functional part of the locking algorithm; it is purely diagnostic.\n     */\n    STORAGE_ITEM_OWNER: \"react_sdk_session_lock_owner\",\n\n    /**\n     * LocalStorage key for the session ID of the most recent claimant to the lock.\n     *\n     * Each instance writes to this key on startup, so existing instances can detect new ones starting up.\n     */\n    STORAGE_ITEM_CLAIMANT: \"react_sdk_session_lock_claimant\",\n\n    /**\n     * The number of milliseconds after which we consider a lock claim stale\n     */\n    LOCK_EXPIRY_TIME_MS: 30000,\n};\n\n/**\n * See if any instances are currently running\n *\n * @returns true if any instance is currently active\n */\nexport function checkSessionLockFree(): boolean {\n    const prefixedLogger = logger.getChild(`checkSessionLockFree`);\n\n    const lastPingTime = window.localStorage.getItem(SESSION_LOCK_CONSTANTS.STORAGE_ITEM_PING);\n    if (lastPingTime === null) {\n        // no other holder\n        prefixedLogger.info(\"No other session has the lock\");\n        return true;\n    }\n\n    const lockHolder = window.localStorage.getItem(SESSION_LOCK_CONSTANTS.STORAGE_ITEM_OWNER);\n\n    // see if it has expired\n    const timeAgo = Date.now() - parseInt(lastPingTime);\n\n    const remaining = SESSION_LOCK_CONSTANTS.LOCK_EXPIRY_TIME_MS - timeAgo;\n    if (remaining <= 0) {\n        // another session claimed the lock, but it is stale.\n        prefixedLogger.info(`Last ping (from ${lockHolder}) was ${timeAgo}ms ago: lock is free`);\n        return true;\n    }\n\n    prefixedLogger.info(`Last ping (from ${lockHolder}) was ${timeAgo}ms ago: lock is taken`);\n    return false;\n}\n\n/**\n * Ensure that only one instance of the application is running at once.\n *\n * If there are any other running instances, tells them to stop, and waits for them to do so.\n *\n * Once we are the sole instance, sets a background job going to service a lock. Then, if another instance starts up,\n * `onNewInstance` is called: it should shut the app down to make sure we aren't doing any more work.\n *\n * @param onNewInstance - callback to handle another instance starting up. NOTE: this may be called before\n *     `getSessionLock` returns if the lock is stolen before we get a chance to start.\n *\n * @returns true if we successfully claimed the lock; false if another instance stole it from under our nose\n *     (in which `onNewInstance` will have been called)\n */\nexport async function getSessionLock(onNewInstance: () => Promise<void>): Promise<boolean> {\n    /** unique ID for this session */\n    const sessionIdentifier = uuidv4();\n\n    const prefixedLogger = logger.getChild(`getSessionLock[${sessionIdentifier}]`);\n\n    /** The ID of our regular task to service the lock.\n     *\n     * Non-null while we hold the lock; null if we have not yet claimed it, or have released it. */\n    let lockServicer: number | null = null;\n\n    /**\n     * See if the lock is free.\n     *\n     * @returns\n     *  - `>0`: the number of milliseconds before the current claim on the lock can be considered stale.\n     *  - `0`: the lock is free for the taking\n     *  - `<0`: someone else has staked a claim for the lock, so we are no longer in line for it.\n     */\n    function checkLock(): number {\n        // first of all, check that we are still the active claimant (ie, another instance hasn't come along while we were waiting.\n        const claimant = window.localStorage.getItem(SESSION_LOCK_CONSTANTS.STORAGE_ITEM_CLAIMANT);\n        if (claimant !== sessionIdentifier) {\n            prefixedLogger.warn(`Lock was claimed by ${claimant} while we were waiting for it: aborting startup`);\n            return -1;\n        }\n\n        const lastPingTime = window.localStorage.getItem(SESSION_LOCK_CONSTANTS.STORAGE_ITEM_PING);\n        const lockHolder = window.localStorage.getItem(SESSION_LOCK_CONSTANTS.STORAGE_ITEM_OWNER);\n        if (lastPingTime === null) {\n            prefixedLogger.info(\"No other session has the lock: proceeding with startup\");\n            return 0;\n        }\n\n        const timeAgo = Date.now() - parseInt(lastPingTime);\n        const remaining = SESSION_LOCK_CONSTANTS.LOCK_EXPIRY_TIME_MS - timeAgo;\n        if (remaining <= 0) {\n            // another session claimed the lock, but it is stale.\n            prefixedLogger.info(`Last ping (from ${lockHolder}) was ${timeAgo}ms ago: proceeding with startup`);\n            return 0;\n        }\n\n        prefixedLogger.info(`Last ping (from ${lockHolder}) was ${timeAgo}ms ago, waiting ${remaining}ms`);\n        return remaining;\n    }\n\n    function serviceLock(): void {\n        window.localStorage.setItem(SESSION_LOCK_CONSTANTS.STORAGE_ITEM_OWNER, sessionIdentifier);\n        window.localStorage.setItem(SESSION_LOCK_CONSTANTS.STORAGE_ITEM_PING, Date.now().toString());\n    }\n\n    // handler for storage events, used later\n    function onStorageEvent(event: StorageEvent): void {\n        if (event.key === SESSION_LOCK_CONSTANTS.STORAGE_ITEM_CLAIMANT) {\n            // It's possible that the event was delayed, and this update actually predates our claim on the lock.\n            // (In particular: suppose tab A and tab B start concurrently and both attempt to set STORAGE_ITEM_CLAIMANT.\n            // Each write queues up a `storage` event for all other tabs. So both tabs see the `storage` event from the\n            // other, even though by the time it arrives we may have overwritten it.)\n            //\n            // To resolve any doubt, we check the *actual* state of the storage.\n            const claimingSession = window.localStorage.getItem(SESSION_LOCK_CONSTANTS.STORAGE_ITEM_CLAIMANT);\n            if (claimingSession === sessionIdentifier) {\n                return;\n            }\n            prefixedLogger.info(`Session ${claimingSession} is waiting for the lock`);\n            window.removeEventListener(\"storage\", onStorageEvent);\n            releaseLock().catch((err) => {\n                prefixedLogger.error(\"Error releasing session lock\", err);\n            });\n        }\n    }\n\n    // handler for pagehide and unload events, used later\n    function onPagehideEvent(): void {\n        // only remove the ping if we still think we're the owner. Otherwise we could be removing someone else's claim!\n        if (lockServicer !== null) {\n            prefixedLogger.debug(\"page hide: clearing our claim\");\n            window.clearInterval(lockServicer);\n            window.localStorage.removeItem(SESSION_LOCK_CONSTANTS.STORAGE_ITEM_PING);\n            window.localStorage.removeItem(SESSION_LOCK_CONSTANTS.STORAGE_ITEM_OWNER);\n            lockServicer = null;\n        }\n\n        // It's worth noting that, according to the spec, the page might come back to life again after a pagehide.\n        //\n        // In practice that's unlikely because Element is unlikely to qualify for the bfcache, but if it does,\n        // this is probably the best we can do: we certainly don't want to stop the user loading any new tabs because\n        // Element happens to be in a bfcache somewhere.\n        //\n        // So, we just hope that we aren't in the middle of any crypto operations, and rely on `onStorageEvent` kicking\n        // in soon enough after we resume to tell us if another tab woke up while we were asleep.\n    }\n\n    async function releaseLock(): Promise<void> {\n        // tell the app to shut down\n        await onNewInstance();\n\n        // and, once it has done so, stop pinging the lock.\n        if (lockServicer !== null) {\n            window.clearInterval(lockServicer);\n        }\n        window.localStorage.removeItem(SESSION_LOCK_CONSTANTS.STORAGE_ITEM_PING);\n        window.localStorage.removeItem(SESSION_LOCK_CONSTANTS.STORAGE_ITEM_OWNER);\n        lockServicer = null;\n    }\n\n    // first of all, stake a claim for the lock. This tells anyone else holding the lock that we want it.\n    window.localStorage.setItem(SESSION_LOCK_CONSTANTS.STORAGE_ITEM_CLAIMANT, sessionIdentifier);\n\n    // now, wait for the lock to be free.\n    // eslint-disable-next-line no-constant-condition\n    while (true) {\n        const remaining = checkLock();\n\n        if (remaining == 0) {\n            // ok, the lock is free, and nobody else has staked a more recent claim.\n            break;\n        } else if (remaining < 0) {\n            // someone else staked a claim for the lock; we bail out.\n            await onNewInstance();\n            return false;\n        }\n\n        // someone else has the lock.\n        // wait for either the ping to expire, or a storage event.\n        let onStorageUpdate: (event: StorageEvent) => void;\n\n        const storageUpdatePromise = new Promise((resolve) => {\n            onStorageUpdate = (event: StorageEvent) => {\n                if (\n                    event.key === SESSION_LOCK_CONSTANTS.STORAGE_ITEM_PING ||\n                    event.key === SESSION_LOCK_CONSTANTS.STORAGE_ITEM_CLAIMANT\n                )\n                    resolve(event);\n            };\n        });\n\n        const sleepPromise = new Promise((resolve) => {\n            setTimeout(resolve, remaining, undefined);\n        });\n\n        window.addEventListener(\"storage\", onStorageUpdate!);\n        await Promise.race([sleepPromise, storageUpdatePromise]);\n        window.removeEventListener(\"storage\", onStorageUpdate!);\n    }\n\n    // If we get here, we know the lock is ours for the taking.\n\n    // CRITICAL SECTION\n    //\n    // The following code, up to the end of the function, must all be synchronous (ie, no `await` calls), to ensure that\n    // we get our listeners in place and all the writes to localStorage done before other tabs run again.\n\n    // claim the lock, and kick off a background process to service it every 5 seconds\n    serviceLock();\n    lockServicer = window.setInterval(serviceLock, 5000);\n\n    // Now add a listener for other claimants to the lock.\n    window.addEventListener(\"storage\", onStorageEvent);\n\n    // also add a listener to clear our claims when our tab closes or navigates away\n    window.addEventListener(\"pagehide\", onPagehideEvent);\n\n    // The pagehide event is called unreliably on Firefox, so additionally add an unload handler.\n    // https://bugzilla.mozilla.org/show_bug.cgi?id=1854492\n    window.addEventListener(\"unload\", onPagehideEvent);\n\n    return true;\n}\n"],"mappings":"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","ignoreList":[]}