aws-cdk
Version:
CDK Toolkit, the command line tool for CDK apps
173 lines • 18.2 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.RWLock = void 0;
const fs_1 = require("fs");
const path = require("path");
/**
* 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.
*/
class RWLock {
constructor(directory) {
this.directory = directory;
this.readCounter = 0;
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 Error(`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);
return {
release: async () => {
await deleteFile(this.writerFile);
},
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);
return {
release: async () => {
await deleteFile(readerFile);
},
};
}
async assertNoOtherWriters() {
const writer = await this.currentWriter();
if (writer) {
throw new Error(`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)
*/
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)
*/
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;
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;
}
}
let tmpCounter = 0;
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);
}
async function deleteFile(filename) {
try {
await fs_1.promises.unlink(filename);
}
catch (e) {
if (e.code === 'ENOENT') {
return;
}
throw e;
}
}
function processExists(pid) {
try {
process.kill(pid, 0);
return true;
}
catch (e) {
return false;
}
}
//# 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';\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 */\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<IWriterLock> {\n    await this.assertNoOtherWriters();\n\n    const readers = await this.currentReaders();\n    if (readers.length > 0) {\n      throw new Error(`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    return {\n      release: async () => {\n        await deleteFile(this.writerFile);\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<ILock> {\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<ILock> {\n    const readerFile = this.readerFile();\n    await writeFileAtomic(readerFile, this.pidString);\n    return {\n      release: async () => {\n        await deleteFile(readerFile);\n      },\n    };\n  }\n\n  private async assertNoOtherWriters() {\n    const writer = await this.currentWriter();\n    if (writer) {\n      throw new Error(`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  private async currentWriter(): Promise<number | undefined> {\n    const contents = await readFileIfExists(this.writerFile);\n    if (!contents) { return undefined; }\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  private 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') { return []; }\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\n/**\n * An acquired lock\n */\nexport interface ILock {\n  release(): Promise<void>;\n}\n\n/**\n * An acquired writer lock\n */\nexport interface IWriterLock extends ILock {\n  /**\n   * Convert the writer lock to a reader lock\n   */\n  convertToReaderLock(): Promise<ILock>;\n}\n\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') { return undefined; }\n    throw e;\n  }\n}\n\nlet tmpCounter = 0;\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\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\nfunction processExists(pid: number) {\n  try {\n    process.kill(pid, 0);\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n"]}