aws-cdk
Version:
CDK Toolkit, the command line tool for CDK apps
179 lines • 19.4 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.RWLock = void 0;
const fs_1 = require("fs");
const path = require("path");
const error_1 = require("../../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.
*/
/* istanbul ignore next: code paths are unpredictable */
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_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);
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_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)
*/
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;
/* istanbul ignore next: 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;
}
}
let tmpCounter = 0;
/* istanbul ignore next: 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);
}
/* istanbul ignore next: code paths are unpredictable */
async function deleteFile(filename) {
try {
await fs_1.promises.unlink(filename);
}
catch (e) {
if (e.code === 'ENOENT') {
return;
}
throw e;
}
}
/* istanbul ignore next: code paths are unpredictable */
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';\nimport { ToolkitError } from '../../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/* istanbul ignore next: 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<IWriterLock> {\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    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 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  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\n/* istanbul ignore next: 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') { return undefined; }\n    throw e;\n  }\n}\n\nlet tmpCounter = 0;\n/* istanbul ignore next: 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\n/* istanbul ignore next: 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\n/* istanbul ignore next: 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"]}