grepmax 0.24.0 → 0.25.0

package/dist/lib/store/store-lease.js

@@ -0,0 +1,473 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StoreLease = exports.StoreLeaseTimeoutError = void 0;
+exports.storeLeasePaths = storeLeasePaths;
+exports.hasStoreExclusiveIntent = hasStoreExclusiveIntent;
+const node_child_process_1 = require("node:child_process");
+const node_crypto_1 = require("node:crypto");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const proper_lockfile_1 = __importDefault(require("proper-lockfile"));
+function storeLeasePaths(storeDir) {
+    const root = `${path.resolve(storeDir)}.lease`;
+    const intentDir = path.join(root, "exclusive-intent");
+    return {
+        root,
+        readersDir: path.join(root, "readers"),
+        intentDir,
+        intentOwnerFile: path.join(intentDir, "owner.json"),
+    };
+}
+class StoreLeaseTimeoutError extends Error {
+    constructor(message, blockers) {
+        super(message);
+        this.blockers = blockers;
+        this.name = "StoreLeaseTimeoutError";
+    }
+}
+exports.StoreLeaseTimeoutError = StoreLeaseTimeoutError;
+function abortError() {
+    const error = new Error("Aborted");
+    error.name = "AbortError";
+    return error;
+}
+let cachedCurrentProcessStart = null;
+function currentProcessStart(pid) {
+    if (pid === process.pid && cachedCurrentProcessStart) {
+        return cachedCurrentProcessStart;
+    }
+    try {
+        const start = (0, node_child_process_1.execFileSync)("ps", ["-p", String(pid), "-o", "lstart="], {
+            encoding: "utf8",
+            timeout: 1000,
+        }).trim();
+        if (pid === process.pid)
+            cachedCurrentProcessStart = start;
+        return start;
+    }
+    catch (_a) {
+        const fallback = `pid:${pid}:started:${Math.trunc(Date.now() - process.uptime() * 1000)}`;
+        if (pid === process.pid)
+            cachedCurrentProcessStart = fallback;
+        return fallback;
+    }
+}
+function defaultProbeOwner(owner) {
+    try {
+        process.kill(owner.pid, 0);
+    }
+    catch (error) {
+        return error.code === "ESRCH"
+            ? "dead"
+            : "unknown";
+    }
+    if (owner.processStart.startsWith(`pid:${owner.pid}:started:`))
+        return "same";
+    try {
+        const start = (0, node_child_process_1.execFileSync)("ps", ["-p", String(owner.pid), "-o", "lstart="], { encoding: "utf8", timeout: 1000 }).trim();
+        if (!start)
+            return "unknown";
+        return start === owner.processStart ? "same" : "reused";
+    }
+    catch (_a) {
+        return "unknown";
+    }
+}
+function readOwner(filePath) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
+        if (!parsed || typeof parsed !== "object")
+            return null;
+        const owner = parsed;
+        return typeof owner.pid === "number" &&
+            typeof owner.processStart === "string" &&
+            typeof owner.nonce === "string" &&
+            typeof owner.role === "string" &&
+            typeof owner.acquiredAt === "number"
+            ? owner
+            : null;
+    }
+    catch (_a) {
+        return null;
+    }
+}
+function writeOwnerAtomic(filePath, owner) {
+    const temp = `${filePath}.${owner.nonce}.tmp`;
+    fs.writeFileSync(temp, `${JSON.stringify(owner)}\n`, { flag: "wx" });
+    fs.renameSync(temp, filePath);
+}
+function delay(ms, signal) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (signal === null || signal === void 0 ? void 0 : signal.aborted)
+            throw abortError();
+        yield new Promise((resolve, reject) => {
+            const finish = () => {
+                signal === null || signal === void 0 ? void 0 : signal.removeEventListener("abort", onAbort);
+                resolve();
+            };
+            const timer = setTimeout(finish, ms);
+            const onAbort = () => {
+                clearTimeout(timer);
+                signal === null || signal === void 0 ? void 0 : signal.removeEventListener("abort", onAbort);
+                reject(abortError());
+            };
+            signal === null || signal === void 0 ? void 0 : signal.addEventListener("abort", onAbort, { once: true });
+            timer.unref();
+        });
+    });
+}
+class StoreLease {
+    constructor(mode, owner, markerPath, paths, storeDir) {
+        this.mode = mode;
+        this.owner = owner;
+        this.markerPath = markerPath;
+        this.paths = paths;
+        this.storeDir = storeDir;
+        this.released = false;
+        this.claimedBy = null;
+    }
+    static acquireShared(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const context = StoreLease.context(options);
+            fs.mkdirSync(context.paths.readersDir, { recursive: true });
+            const markerPath = path.join(context.paths.readersDir, `${context.owner.nonce}.json`);
+            while (Date.now() <= context.deadline) {
+                if ((_a = options.signal) === null || _a === void 0 ? void 0 : _a.aborted)
+                    throw abortError();
+                StoreLease.withIntentLock(context, () => StoreLease.removeStaleIntent(context));
+                if (!fs.existsSync(context.paths.intentDir)) {
+                    writeOwnerAtomic(markerPath, context.owner);
+                    if (!fs.existsSync(context.paths.intentDir)) {
+                        return new StoreLease("shared", context.owner, markerPath, context.paths, options.storeDir);
+                    }
+                    fs.rmSync(markerPath, { force: true });
+                }
+                yield delay(context.pollMs, options.signal);
+            }
+            throw new StoreLeaseTimeoutError("Timed out waiting for exclusive store intent to clear", StoreLease.intentBlockers(context.paths));
+        });
+    }
+    static acquireExclusive(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const context = StoreLease.context(options);
+            fs.mkdirSync(context.paths.readersDir, { recursive: true });
+            let ownsIntent = false;
+            try {
+                while (Date.now() <= context.deadline) {
+                    if ((_a = options.signal) === null || _a === void 0 ? void 0 : _a.aborted)
+                        throw abortError();
+                    StoreLease.withIntentLock(context, () => {
+                        StoreLease.removeStaleIntent(context);
+                        if (fs.existsSync(context.paths.intentDir))
+                            return;
+                        const tempIntent = `${context.paths.intentDir}.${context.owner.nonce}.tmp`;
+                        try {
+                            fs.mkdirSync(tempIntent);
+                            writeOwnerAtomic(path.join(tempIntent, "owner.json"), context.owner);
+                            fs.renameSync(tempIntent, context.paths.intentDir);
+                            ownsIntent = true;
+                        }
+                        finally {
+                            fs.rmSync(tempIntent, { recursive: true, force: true });
+                        }
+                    });
+                    if (ownsIntent)
+                        break;
+                    yield delay(context.pollMs, options.signal);
+                }
+                if (!ownsIntent) {
+                    throw new StoreLeaseTimeoutError("Timed out waiting to acquire exclusive store intent", StoreLease.intentBlockers(context.paths));
+                }
+                while (Date.now() <= context.deadline) {
+                    if ((_b = options.signal) === null || _b === void 0 ? void 0 : _b.aborted)
+                        throw abortError();
+                    const blockers = StoreLease.liveReaders(context);
+                    if (blockers.length === 0) {
+                        const current = readOwner(context.paths.intentOwnerFile);
+                        if ((current === null || current === void 0 ? void 0 : current.nonce) !== context.owner.nonce) {
+                            throw new Error("Exclusive store lease ownership was lost");
+                        }
+                        return new StoreLease("exclusive", context.owner, context.paths.intentDir, context.paths, options.storeDir);
+                    }
+                    yield delay(context.pollMs, options.signal);
+                }
+                throw new StoreLeaseTimeoutError("Timed out waiting for shared store owners to close", StoreLease.liveReaders(context));
+            }
+            catch (error) {
+                if (ownsIntent) {
+                    yield StoreLease.releaseIntentWithRetry(context.paths, context.owner, 1000, context.pollMs);
+                }
+                throw error;
+            }
+        });
+    }
+    release() {
+        return __awaiter(this, arguments, void 0, function* (options = {}) {
+            if (this.released)
+                return;
+            if (this.mode === "shared") {
+                const current = readOwner(this.markerPath);
+                if ((current === null || current === void 0 ? void 0 : current.nonce) === this.owner.nonce) {
+                    fs.rmSync(this.markerPath, { force: true });
+                }
+                this.released = true;
+                this.claimedBy = null;
+                return;
+            }
+            yield StoreLease.releaseIntentWithRetry(this.paths, this.owner, options.timeoutMs, options.pollMs);
+            this.released = true;
+            this.claimedBy = null;
+        });
+    }
+    claim(holder, storeDir) {
+        if (path.resolve(storeDir) !== path.resolve(this.storeDir)) {
+            throw new Error("Store lease belongs to a different store");
+        }
+        if (this.released)
+            throw new Error("Store lease has already been released");
+        if (this.claimedBy && this.claimedBy !== holder) {
+            throw new Error("Store lease is already attached to another owner");
+        }
+        const current = this.mode === "shared"
+            ? readOwner(this.markerPath)
+            : readOwner(this.paths.intentOwnerFile);
+        if ((current === null || current === void 0 ? void 0 : current.nonce) !== this.owner.nonce) {
+            throw new Error("Store lease ownership could not be verified");
+        }
+        this.claimedBy = holder;
+    }
+    relinquish(holder) {
+        if (this.claimedBy === holder)
+            this.claimedBy = null;
+    }
+    /** Atomically replace this shared lease with an exclusive lease. */
+    upgrade() {
+        return __awaiter(this, arguments, void 0, function* (options = {}) {
+            if (this.mode !== "shared") {
+                throw new Error("Only a shared store lease can be upgraded");
+            }
+            if (this.released)
+                throw new Error("Store lease has already been released");
+            const exclusive = yield StoreLease.acquireExclusive(Object.assign(Object.assign({}, options), { storeDir: this.storeDir, pid: this.owner.pid, processStart: this.owner.processStart, ignoreNonces: new Set([this.owner.nonce]) }));
+            try {
+                yield this.release();
+                return exclusive;
+            }
+            catch (error) {
+                yield exclusive.release();
+                throw error;
+            }
+        });
+    }
+    /** Replace this exclusive lease with a shared lease without an ownership gap. */
+    downgrade() {
+        return __awaiter(this, arguments, void 0, function* (options = {}) {
+            if (this.mode !== "exclusive") {
+                throw new Error("Only an exclusive store lease can be downgraded");
+            }
+            if (this.released)
+                throw new Error("Store lease has already been released");
+            const current = readOwner(this.paths.intentOwnerFile);
+            if ((current === null || current === void 0 ? void 0 : current.nonce) !== this.owner.nonce) {
+                throw new Error("Exclusive store lease ownership could not be verified");
+            }
+            const context = StoreLease.context(Object.assign(Object.assign({}, options), { storeDir: this.storeDir, pid: this.owner.pid, processStart: this.owner.processStart }));
+            fs.mkdirSync(context.paths.readersDir, { recursive: true });
+            const markerPath = path.join(context.paths.readersDir, `${context.owner.nonce}.json`);
+            writeOwnerAtomic(markerPath, context.owner);
+            try {
+                const stillCurrent = readOwner(this.paths.intentOwnerFile);
+                if ((stillCurrent === null || stillCurrent === void 0 ? void 0 : stillCurrent.nonce) !== this.owner.nonce) {
+                    throw new Error("Exclusive store lease ownership changed during downgrade");
+                }
+                while (!StoreLease.withIntentLock(context, () => StoreLease.releaseIntent(this.paths, this.owner, true))) {
+                    if (Date.now() > context.deadline) {
+                        throw new Error("Timed out waiting to release exclusive store intent during downgrade");
+                    }
+                    yield delay(context.pollMs, options.signal);
+                }
+                this.released = true;
+                this.claimedBy = null;
+                return new StoreLease("shared", context.owner, markerPath, context.paths, this.storeDir);
+            }
+            catch (error) {
+                fs.rmSync(markerPath, { force: true });
+                throw error;
+            }
+        });
+    }
+    static context(options) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        const pid = (_a = options.pid) !== null && _a !== void 0 ? _a : process.pid;
+        const nonce = (_b = options.nonce) !== null && _b !== void 0 ? _b : (0, node_crypto_1.randomUUID)();
+        if (!/^[A-Za-z0-9._-]+$/.test(nonce)) {
+            throw new Error("Store lease nonce contains invalid characters");
+        }
+        const owner = {
+            pid,
+            processStart: (_c = options.processStart) !== null && _c !== void 0 ? _c : currentProcessStart(pid),
+            nonce,
+            role: (_e = (_d = options.role) !== null && _d !== void 0 ? _d : process.title) !== null && _e !== void 0 ? _e : "gmax",
+            acquiredAt: Date.now(),
+        };
+        return {
+            owner,
+            paths: storeLeasePaths(options.storeDir),
+            deadline: Date.now() + ((_f = options.timeoutMs) !== null && _f !== void 0 ? _f : 10000),
+            pollMs: (_g = options.pollMs) !== null && _g !== void 0 ? _g : 50,
+            ignoreNonces: (_h = options.ignoreNonces) !== null && _h !== void 0 ? _h : new Set(),
+            probeOwner: (_j = options.probeOwner) !== null && _j !== void 0 ? _j : defaultProbeOwner,
+        };
+    }
+    static removeStaleIntent(context) {
+        if (!fs.existsSync(context.paths.intentDir))
+            return;
+        const owner = readOwner(context.paths.intentOwnerFile);
+        if (!owner)
+            return;
+        const status = context.probeOwner(owner);
+        if (status === "dead" || status === "reused") {
+            StoreLease.releaseIntent(context.paths, owner, true);
+        }
+    }
+    static withIntentLock(context, fn) {
+        return StoreLease.withIntentPathsLock(context.paths, fn);
+    }
+    static withIntentPathsLock(paths, fn) {
+        fs.mkdirSync(paths.root, { recursive: true });
+        let release;
+        try {
+            release = proper_lockfile_1.default.lockSync(paths.root, {
+                realpath: false,
+                retries: 0,
+                stale: 10000,
+            });
+            fn();
+            return true;
+        }
+        catch (error) {
+            if (error.code !== "ELOCKED")
+                throw error;
+            return false;
+        }
+        finally {
+            release === null || release === void 0 ? void 0 : release();
+        }
+    }
+    static releaseIntentWithRetry(paths_1, owner_1) {
+        return __awaiter(this, arguments, void 0, function* (paths, owner, timeoutMs = 1000, pollMs = 10) {
+            const deadline = Date.now() + timeoutMs;
+            while (!StoreLease.releaseIntent(paths, owner)) {
+                if (Date.now() > deadline) {
+                    throw new Error("Timed out waiting to release exclusive store intent");
+                }
+                yield delay(pollMs);
+            }
+        });
+    }
+    static releaseIntent(paths, owner, lockHeld = false) {
+        const remove = () => {
+            const current = readOwner(paths.intentOwnerFile);
+            if ((current === null || current === void 0 ? void 0 : current.nonce) === owner.nonce) {
+                fs.rmSync(paths.intentDir, { recursive: true, force: true });
+            }
+        };
+        if (lockHeld) {
+            remove();
+            return true;
+        }
+        return StoreLease.withIntentPathsLock(paths, remove);
+    }
+    static intentBlockers(paths) {
+        const owner = readOwner(paths.intentOwnerFile);
+        return owner ? [owner] : [];
+    }
+    static liveReaders(context) {
+        let names;
+        try {
+            names = fs.readdirSync(context.paths.readersDir);
+        }
+        catch (_a) {
+            return [];
+        }
+        const blockers = [];
+        for (const name of names) {
+            const markerPath = path.join(context.paths.readersDir, name);
+            const owner = readOwner(markerPath);
+            if (!owner) {
+                blockers.push({
+                    pid: -1,
+                    processStart: "unknown",
+                    nonce: name,
+                    role: "invalid-marker",
+                    acquiredAt: 0,
+                });
+                continue;
+            }
+            if (context.ignoreNonces.has(owner.nonce) &&
+                owner.pid === context.owner.pid &&
+                owner.processStart === context.owner.processStart) {
+                continue;
+            }
+            const status = context.probeOwner(owner);
+            if (status === "dead" || status === "reused") {
+                fs.rmSync(markerPath, { force: true });
+            }
+            else {
+                blockers.push(owner);
+            }
+        }
+        return blockers;
+    }
+}
+exports.StoreLease = StoreLease;
+function hasStoreExclusiveIntent(storeDir) {
+    return fs.existsSync(storeLeasePaths(storeDir).intentDir);
+}