204 lines
21 KiB
JavaScript
204 lines
21 KiB
JavaScript
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.RWLock = void 0;
|
|
const fs_1 = require("fs");
|
|
const path = require("path");
|
|
const toolkit_error_1 = require("../toolkit/toolkit-error");
|
|
/**
|
|
* A single-writer/multi-reader lock on a directory
|
|
*
|
|
* It uses marker files with PIDs in them as a locking marker; the PIDs will be
|
|
* checked for liveness, so that if the process exits without cleaning up the
|
|
* files the lock is implicitly released.
|
|
*
|
|
* This class is not 100% race safe, but in practice it should be a lot
|
|
* better than the 0 protection we have today.
|
|
*/
|
|
/* c8 ignore start */ // code paths are unpredictable
|
|
class RWLock {
|
|
directory;
|
|
pidString;
|
|
writerFile;
|
|
readCounter = 0;
|
|
constructor(directory) {
|
|
this.directory = directory;
|
|
this.pidString = `${process.pid}`;
|
|
this.writerFile = path.join(this.directory, 'synth.lock');
|
|
}
|
|
/**
|
|
* Acquire a writer lock.
|
|
*
|
|
* No other readers or writers must exist for the given directory.
|
|
*/
|
|
async acquireWrite() {
|
|
await this.assertNoOtherWriters();
|
|
const readers = await this._currentReaders();
|
|
if (readers.length > 0) {
|
|
throw new toolkit_error_1.ToolkitError(`Other CLIs (PID=${readers}) are currently reading from ${this.directory}. Invoke the CLI in sequence, or use '--output' to synth into different directories.`);
|
|
}
|
|
await writeFileAtomic(this.writerFile, this.pidString);
|
|
let released = false;
|
|
return {
|
|
release: async () => {
|
|
// Releasing needs a flag, otherwise we might delete a file that some other lock has created in the mean time.
|
|
if (!released) {
|
|
await deleteFile(this.writerFile);
|
|
released = true;
|
|
}
|
|
},
|
|
convertToReaderLock: async () => {
|
|
// Acquire the read lock before releasing the write lock. Slightly less
|
|
// chance of racing!
|
|
const ret = await this.doAcquireRead();
|
|
await deleteFile(this.writerFile);
|
|
return ret;
|
|
},
|
|
};
|
|
}
|
|
/**
|
|
* Acquire a read lock
|
|
*
|
|
* Will fail if there are any writers.
|
|
*/
|
|
async acquireRead() {
|
|
await this.assertNoOtherWriters();
|
|
return this.doAcquireRead();
|
|
}
|
|
/**
|
|
* Obtains the name fo a (new) `readerFile` to use. This includes a counter so
|
|
* that if multiple threads of the same PID attempt to concurrently acquire
|
|
* the same lock, they're guaranteed to use a different reader file name (only
|
|
* one thread will ever execute JS code at once, guaranteeing the readCounter
|
|
* is incremented "atomically" from the point of view of this PID.).
|
|
*/
|
|
readerFile() {
|
|
return path.join(this.directory, `read.${this.pidString}.${++this.readCounter}.lock`);
|
|
}
|
|
/**
|
|
* Do the actual acquiring of a read lock.
|
|
*/
|
|
async doAcquireRead() {
|
|
const readerFile = this.readerFile();
|
|
await writeFileAtomic(readerFile, this.pidString);
|
|
let released = false;
|
|
return {
|
|
release: async () => {
|
|
// Releasing needs a flag, otherwise we might delete a file that some other lock has created in the mean time.
|
|
if (!released) {
|
|
await deleteFile(readerFile);
|
|
released = true;
|
|
}
|
|
},
|
|
};
|
|
}
|
|
async assertNoOtherWriters() {
|
|
const writer = await this._currentWriter();
|
|
if (writer) {
|
|
throw new toolkit_error_1.ToolkitError(`Another CLI (PID=${writer}) is currently synthing to ${this.directory}. Invoke the CLI in sequence, or use '--output' to synth into different directories.`);
|
|
}
|
|
}
|
|
/**
|
|
* Check the current writer (if any)
|
|
*
|
|
* Publicly accessible for testing purposes. Do not use.
|
|
*
|
|
* @internal
|
|
*/
|
|
async _currentWriter() {
|
|
const contents = await readFileIfExists(this.writerFile);
|
|
if (!contents) {
|
|
return undefined;
|
|
}
|
|
const pid = parseInt(contents, 10);
|
|
if (!processExists(pid)) {
|
|
// Do cleanup of a stray file now
|
|
await deleteFile(this.writerFile);
|
|
return undefined;
|
|
}
|
|
return pid;
|
|
}
|
|
/**
|
|
* Check the current readers (if any)
|
|
*
|
|
* Publicly accessible for testing purposes. Do not use.
|
|
*
|
|
* @internal
|
|
*/
|
|
async _currentReaders() {
|
|
const re = /^read\.([^.]+)\.[^.]+\.lock$/;
|
|
const ret = new Array();
|
|
let children;
|
|
try {
|
|
children = await fs_1.promises.readdir(this.directory, { encoding: 'utf-8' });
|
|
}
|
|
catch (e) {
|
|
// Can't be locked if the directory doesn't exist
|
|
if (e.code === 'ENOENT') {
|
|
return [];
|
|
}
|
|
throw e;
|
|
}
|
|
for (const fname of children) {
|
|
const m = fname.match(re);
|
|
if (m) {
|
|
const pid = parseInt(m[1], 10);
|
|
if (processExists(pid)) {
|
|
ret.push(pid);
|
|
}
|
|
else {
|
|
// Do cleanup of a stray file now
|
|
await deleteFile(path.join(this.directory, fname));
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
exports.RWLock = RWLock;
|
|
/* c8 ignore start */ // code paths are unpredictable
|
|
async function readFileIfExists(filename) {
|
|
try {
|
|
return await fs_1.promises.readFile(filename, { encoding: 'utf-8' });
|
|
}
|
|
catch (e) {
|
|
if (e.code === 'ENOENT') {
|
|
return undefined;
|
|
}
|
|
throw e;
|
|
}
|
|
}
|
|
/* c8 ignore stop */
|
|
let tmpCounter = 0;
|
|
/* c8 ignore start */ // code paths are unpredictable
|
|
async function writeFileAtomic(filename, contents) {
|
|
await fs_1.promises.mkdir(path.dirname(filename), { recursive: true });
|
|
const tmpFile = `${filename}.${process.pid}_${++tmpCounter}`;
|
|
await fs_1.promises.writeFile(tmpFile, contents, { encoding: 'utf-8' });
|
|
await fs_1.promises.rename(tmpFile, filename);
|
|
}
|
|
/* c8 ignore stop */
|
|
/* c8 ignore start */ // code paths are unpredictable
|
|
async function deleteFile(filename) {
|
|
try {
|
|
await fs_1.promises.unlink(filename);
|
|
}
|
|
catch (e) {
|
|
if (e.code === 'ENOENT') {
|
|
return;
|
|
}
|
|
throw e;
|
|
}
|
|
}
|
|
/* c8 ignore stop */
|
|
/* c8 ignore start */ // code paths are unpredictable
|
|
function processExists(pid) {
|
|
try {
|
|
process.kill(pid, 0);
|
|
return true;
|
|
}
|
|
catch (e) {
|
|
return false;
|
|
}
|
|
}
|
|
/* c8 ignore stop */
|
|
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rwlock.js","sourceRoot":"","sources":["rwlock.ts"],"names":[],"mappings":"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","sourcesContent":["import { promises as fs } from 'fs';\nimport * as path from 'path';\nimport { ToolkitError } from '../toolkit/toolkit-error';\n\n/**\n * A single-writer/multi-reader lock on a directory\n *\n * It uses marker files with PIDs in them as a locking marker; the PIDs will be\n * checked for liveness, so that if the process exits without cleaning up the\n * files the lock is implicitly released.\n *\n * This class is not 100% race safe, but in practice it should be a lot\n * better than the 0 protection we have today.\n */\n/* c8 ignore start */ // code paths are unpredictable\nexport class RWLock {\n  private readonly pidString: string;\n  private readonly writerFile: string;\n  private readCounter = 0;\n\n  constructor(public readonly directory: string) {\n    this.pidString = `${process.pid}`;\n\n    this.writerFile = path.join(this.directory, 'synth.lock');\n  }\n\n  /**\n   * Acquire a writer lock.\n   *\n   * No other readers or writers must exist for the given directory.\n   */\n  public async acquireWrite(): Promise<IWriteLock> {\n    await this.assertNoOtherWriters();\n\n    const readers = await this._currentReaders();\n    if (readers.length > 0) {\n      throw new ToolkitError(`Other CLIs (PID=${readers}) are currently reading from ${this.directory}. Invoke the CLI in sequence, or use '--output' to synth into different directories.`);\n    }\n\n    await writeFileAtomic(this.writerFile, this.pidString);\n\n    let released = false;\n    return {\n      release: async () => {\n        // Releasing needs a flag, otherwise we might delete a file that some other lock has created in the mean time.\n        if (!released) {\n          await deleteFile(this.writerFile);\n          released = true;\n        }\n      },\n      convertToReaderLock: async () => {\n        // Acquire the read lock before releasing the write lock. Slightly less\n        // chance of racing!\n        const ret = await this.doAcquireRead();\n        await deleteFile(this.writerFile);\n        return ret;\n      },\n    };\n  }\n\n  /**\n   * Acquire a read lock\n   *\n   * Will fail if there are any writers.\n   */\n  public async acquireRead(): Promise<IReadLock> {\n    await this.assertNoOtherWriters();\n    return this.doAcquireRead();\n  }\n\n  /**\n   * Obtains the name fo a (new) `readerFile` to use. This includes a counter so\n   * that if multiple threads of the same PID attempt to concurrently acquire\n   * the same lock, they're guaranteed to use a different reader file name (only\n   * one thread will ever execute JS code at once, guaranteeing the readCounter\n   * is incremented \"atomically\" from the point of view of this PID.).\n   */\n  private readerFile(): string {\n    return path.join(this.directory, `read.${this.pidString}.${++this.readCounter}.lock`);\n  }\n\n  /**\n   * Do the actual acquiring of a read lock.\n   */\n  private async doAcquireRead(): Promise<IReadLock> {\n    const readerFile = this.readerFile();\n    await writeFileAtomic(readerFile, this.pidString);\n\n    let released = false;\n    return {\n      release: async () => {\n        // Releasing needs a flag, otherwise we might delete a file that some other lock has created in the mean time.\n        if (!released) {\n          await deleteFile(readerFile);\n          released = true;\n        }\n      },\n    };\n  }\n\n  private async assertNoOtherWriters() {\n    const writer = await this._currentWriter();\n    if (writer) {\n      throw new ToolkitError(`Another CLI (PID=${writer}) is currently synthing to ${this.directory}. Invoke the CLI in sequence, or use '--output' to synth into different directories.`);\n    }\n  }\n\n  /**\n   * Check the current writer (if any)\n   *\n   * Publicly accessible for testing purposes. Do not use.\n   *\n   * @internal\n   */\n  public async _currentWriter(): Promise<number | undefined> {\n    const contents = await readFileIfExists(this.writerFile);\n    if (!contents) {\n      return undefined;\n    }\n\n    const pid = parseInt(contents, 10);\n    if (!processExists(pid)) {\n      // Do cleanup of a stray file now\n      await deleteFile(this.writerFile);\n      return undefined;\n    }\n\n    return pid;\n  }\n\n  /**\n   * Check the current readers (if any)\n   *\n   * Publicly accessible for testing purposes. Do not use.\n   *\n   * @internal\n   */\n  public async _currentReaders(): Promise<number[]> {\n    const re = /^read\\.([^.]+)\\.[^.]+\\.lock$/;\n    const ret = new Array<number>();\n\n    let children;\n    try {\n      children = await fs.readdir(this.directory, { encoding: 'utf-8' });\n    } catch (e: any) {\n      // Can't be locked if the directory doesn't exist\n      if (e.code === 'ENOENT') {\n        return [];\n      }\n      throw e;\n    }\n\n    for (const fname of children) {\n      const m = fname.match(re);\n      if (m) {\n        const pid = parseInt(m[1], 10);\n        if (processExists(pid)) {\n          ret.push(pid);\n        } else {\n          // Do cleanup of a stray file now\n          await deleteFile(path.join(this.directory, fname));\n        }\n      }\n    }\n    return ret;\n  }\n}\n/* c8 ignore stop */\n\n/**\n * An acquired lock\n */\nexport interface IReadLock {\n  /**\n   * Release the lock. Can be called more than once.\n   */\n  release(): Promise<void>;\n}\n\n/**\n * An acquired writer lock\n */\nexport interface IWriteLock extends IReadLock {\n  /**\n   * Convert the writer lock to a reader lock\n   */\n  convertToReaderLock(): Promise<IReadLock>;\n}\n\n/* c8 ignore start */ // code paths are unpredictable\nasync function readFileIfExists(filename: string): Promise<string | undefined> {\n  try {\n    return await fs.readFile(filename, { encoding: 'utf-8' });\n  } catch (e: any) {\n    if (e.code === 'ENOENT') {\n      return undefined;\n    }\n    throw e;\n  }\n}\n/* c8 ignore stop */\n\nlet tmpCounter = 0;\n/* c8 ignore start */ // code paths are unpredictable\nasync function writeFileAtomic(filename: string, contents: string): Promise<void> {\n  await fs.mkdir(path.dirname(filename), { recursive: true });\n  const tmpFile = `${filename}.${process.pid}_${++tmpCounter}`;\n  await fs.writeFile(tmpFile, contents, { encoding: 'utf-8' });\n  await fs.rename(tmpFile, filename);\n}\n/* c8 ignore stop */\n\n/* c8 ignore start */ // code paths are unpredictable\nasync function deleteFile(filename: string) {\n  try {\n    await fs.unlink(filename);\n  } catch (e: any) {\n    if (e.code === 'ENOENT') {\n      return;\n    }\n    throw e;\n  }\n}\n/* c8 ignore stop */\n\n/* c8 ignore start */ // code paths are unpredictable\nfunction processExists(pid: number) {\n  try {\n    process.kill(pid, 0);\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n/* c8 ignore stop */\n"]}
|