@aws-cdk-testing/cli-integ 0.0.0

package/lib/with-temporary-directory.ts

@@ -0,0 +1,35 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { TestContext } from './integ-test';
+import { rimraf } from './shell';
+
+export interface TemporaryDirectoryContext {
+  readonly integTestDir: string;
+}
+
+export function withTemporaryDirectory<A extends TestContext>(block: (context: A & TemporaryDirectoryContext) => Promise<void>) {
+  return async (context: A) => {
+    const integTestDir = path.join(os.tmpdir(), `cdk-integ-${context.randomString}`);
+
+    fs.mkdirSync(integTestDir, { recursive: true });
+
+    try {
+      await block({
+        ...context,
+        integTestDir,
+      });
+
+      // Clean up in case of success
+      if (process.env.SKIP_CLEANUP) {
+        context.log(`Left test directory in '${integTestDir}' ($SKIP_CLEANUP)\n`);
+      } else {
+        rimraf(integTestDir);
+      }
+    } catch (e) {
+      context.log(`Left test directory in '${integTestDir}'\n`);
+      throw e;
+    }
+  };
+}
+

package/lib/with-timeout.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Run a block with a timeout
+ *
+ * We can't use the jest timeout feature:
+ *
+ * - `jest.concurrent()` does not do any concurrency management. It starts all
+ *   tests at the same time.
+ * - Our tests use locking to make sure only one test is running at a time per
+ *   region.
+ *
+ * The wait time for the locks is included in the jest test timeout. We therefore
+ * need to set it unreasonably high (as long as the last test may need to wait
+ * if all tests are executed using only 1 region, and they effectively execute
+ * sequentially), which makes it not useful to detect stuck tests.
+ *
+ * The `withTimeout()` modifier makes it possible to measure only a specific
+ * block of code. In our case: the effective test code, excluding the wait time.
+ */
+export declare function withTimeout<A>(seconds: number, block: (x: A) => Promise<void>): (x: A) => Promise<void>;

package/lib/with-timeout.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withTimeout = withTimeout;
+/**
+ * Run a block with a timeout
+ *
+ * We can't use the jest timeout feature:
+ *
+ * - `jest.concurrent()` does not do any concurrency management. It starts all
+ *   tests at the same time.
+ * - Our tests use locking to make sure only one test is running at a time per
+ *   region.
+ *
+ * The wait time for the locks is included in the jest test timeout. We therefore
+ * need to set it unreasonably high (as long as the last test may need to wait
+ * if all tests are executed using only 1 region, and they effectively execute
+ * sequentially), which makes it not useful to detect stuck tests.
+ *
+ * The `withTimeout()` modifier makes it possible to measure only a specific
+ * block of code. In our case: the effective test code, excluding the wait time.
+ */
+function withTimeout(seconds, block) {
+    return (x) => {
+        const timeOut = new Promise((_ok, ko) => {
+            const timerHandle = setTimeout(() => ko(new Error(`Timeout: test took more than ${seconds}s to complete`)), seconds * 1000);
+            timerHandle.unref();
+        });
+        return Promise.race([
+            block(x),
+            timeOut,
+        ]);
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/with-timeout.ts

@@ -0,0 +1,33 @@
+/**
+ * Run a block with a timeout
+ *
+ * We can't use the jest timeout feature:
+ *
+ * - `jest.concurrent()` does not do any concurrency management. It starts all
+ *   tests at the same time.
+ * - Our tests use locking to make sure only one test is running at a time per
+ *   region.
+ *
+ * The wait time for the locks is included in the jest test timeout. We therefore
+ * need to set it unreasonably high (as long as the last test may need to wait
+ * if all tests are executed using only 1 region, and they effectively execute
+ * sequentially), which makes it not useful to detect stuck tests.
+ *
+ * The `withTimeout()` modifier makes it possible to measure only a specific
+ * block of code. In our case: the effective test code, excluding the wait time.
+ */
+export function withTimeout<A>(seconds: number, block: (x: A) => Promise<void>) {
+  return (x: A) => {
+    const timeOut = new Promise<void>((_ok, ko) => {
+      const timerHandle = setTimeout(
+        () => ko(new Error(`Timeout: test took more than ${seconds}s to complete`)),
+        seconds * 1000);
+      timerHandle.unref();
+    });
+
+    return Promise.race([
+      block(x),
+      timeOut,
+    ]);
+  };
+}

package/lib/xpmutex.d.ts

@@ -0,0 +1,43 @@
+export declare class XpMutexPool {
+    readonly directory: string;
+    static fromDirectory(directory: string): XpMutexPool;
+    static fromName(name: string): XpMutexPool;
+    private readonly waitingResolvers;
+    private watcher;
+    private constructor();
+    mutex(name: string): XpMutex;
+    /**
+     * Await an unlock event
+     *
+     * (An unlock event is when a file in the directory gets deleted, with a tiny
+     * random sleep attached to it).
+     */
+    awaitUnlock(maxWaitMs?: number): Promise<void>;
+    private startWatch;
+    private notifyWaiters;
+}
+/**
+ * Cross-process mutex
+ *
+ * Uses the presence of a file on disk and `fs.watch` to represent the mutex
+ * and discover unlocks.
+ */
+export declare class XpMutex {
+    private readonly pool;
+    readonly mutexName: string;
+    private readonly fileName;
+    constructor(pool: XpMutexPool, mutexName: string);
+    /**
+     * Try to acquire the lock (may fail)
+     */
+    tryAcquire(): Promise<ILock | undefined>;
+    /**
+     * Acquire the lock, waiting until we can
+     */
+    acquire(): Promise<ILock>;
+    private readPidFile;
+    private writePidFile;
+}
+export interface ILock {
+    release(): Promise<void>;
+}

package/lib/xpmutex.js

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XpMutex = exports.XpMutexPool = void 0;
+const fs_1 = require("fs");
+const os = require("os");
+const path = require("path");
+class XpMutexPool {
+    static fromDirectory(directory) {
+        (0, fs_1.mkdirSync)(directory, { recursive: true });
+        return new XpMutexPool(directory);
+    }
+    static fromName(name) {
+        return XpMutexPool.fromDirectory(path.join(os.tmpdir(), name));
+    }
+    constructor(directory) {
+        this.directory = directory;
+        this.waitingResolvers = new Set();
+        this.startWatch();
+    }
+    mutex(name) {
+        return new XpMutex(this, name);
+    }
+    /**
+     * Await an unlock event
+     *
+     * (An unlock event is when a file in the directory gets deleted, with a tiny
+     * random sleep attached to it).
+     */
+    awaitUnlock(maxWaitMs) {
+        const wait = new Promise(ok => {
+            this.waitingResolvers.add(async () => {
+                await randomSleep(10);
+                ok();
+            });
+        });
+        if (maxWaitMs) {
+            return Promise.race([wait, sleep(maxWaitMs)]);
+        }
+        else {
+            return wait;
+        }
+    }
+    startWatch() {
+        this.watcher = (0, fs_1.watch)(this.directory);
+        this.watcher.unref(); // @types doesn't know about this but it exists
+        this.watcher.on('change', async (eventType, fname) => {
+            // Only trigger on 'deletes'.
+            // After receiving the event, we check if the file exists.
+            // - If no: the file was deleted! Huzzah, this counts as a wakeup.
+            // - If yes: either the file was just created (in which case we don't need to wakeup)
+            //   or the event was due to a delete but someone raced us to it and claimed the
+            //   file already (in which case we also don't need to wake up).
+            if (eventType === 'rename' && !await fileExists(path.join(this.directory, fname.toString()))) {
+                this.notifyWaiters();
+            }
+        });
+        this.watcher.on('error', async (e) => {
+            // eslint-disable-next-line no-console
+            console.error(e);
+            await randomSleep(100);
+            this.startWatch();
+        });
+    }
+    notifyWaiters() {
+        for (const promise of this.waitingResolvers) {
+            promise();
+        }
+        this.waitingResolvers.clear();
+    }
+}
+exports.XpMutexPool = XpMutexPool;
+/**
+ * Cross-process mutex
+ *
+ * Uses the presence of a file on disk and `fs.watch` to represent the mutex
+ * and discover unlocks.
+ */
+class XpMutex {
+    constructor(pool, mutexName) {
+        this.pool = pool;
+        this.mutexName = mutexName;
+        this.fileName = path.join(pool.directory, `${mutexName}.mutex`);
+    }
+    /**
+     * Try to acquire the lock (may fail)
+     */
+    async tryAcquire() {
+        while (true) {
+            // Acquire lock by being the one to create the file
+            try {
+                return await this.writePidFile('wx'); // Fails if the file already exists
+            }
+            catch (e) {
+                if (e.code !== 'EEXIST') {
+                    throw e;
+                }
+            }
+            // File already exists. Read the contents, see if it's an existent PID (if so, the lock is taken)
+            const ownerPid = await this.readPidFile();
+            if (ownerPid === undefined) {
+                // File got deleted just now, maybe we can acquire it again
+                continue;
+            }
+            if (processExists(ownerPid)) {
+                return undefined;
+            }
+            // If not, the lock is stale and will never be released anymore. We may
+            // delete it and acquire it anyway, but we may be racing someone else trying
+            // to do the same. Solve this as follows:
+            // - Try to acquire a lock that gives us permissions to declare the existing lock stale.
+            // - Sleep a small random period to reduce contention on this operation
+            await randomSleep(10);
+            const innerMux = new XpMutex(this.pool, `${this.mutexName}.${ownerPid}`);
+            const innerLock = await innerMux.tryAcquire();
+            if (!innerLock) {
+                return undefined;
+            }
+            // We may not release the 'inner lock' we used to acquire the rights to declare the other
+            // lock stale until we release the actual lock itself. If we did, other contenders might
+            // see it released while they're still in this fallback block and accidentally steal
+            // from a new legitimate owner.
+            return this.writePidFile('w', innerLock); // Force write lock file, attach inner lock as well
+        }
+    }
+    /**
+     * Acquire the lock, waiting until we can
+     */
+    async acquire() {
+        while (true) {
+            // Start the wait here, so we don't miss the signal if it comes after
+            // we try but before we sleep.
+            //
+            // We also periodically retry anyway since we may have missed the delete
+            // signal due to unfortunate timing.
+            const wait = this.pool.awaitUnlock(5000);
+            const lock = await this.tryAcquire();
+            if (lock) {
+                // Ignore the wait (count as handled)
+                wait.then(() => { }, () => { });
+                return lock;
+            }
+            await wait;
+            await randomSleep(100);
+        }
+    }
+    async readPidFile() {
+        const deadLine = Date.now() + 1000;
+        while (Date.now() < deadLine) {
+            let contents;
+            try {
+                contents = await fs_1.promises.readFile(this.fileName, { encoding: 'utf-8' });
+            }
+            catch (e) {
+                if (e.code === 'ENOENT') {
+                    return undefined;
+                }
+                throw e;
+            }
+            // Retry until we've seen the full contents
+            if (contents.endsWith('.')) {
+                return parseInt(contents.substring(0, contents.length - 1), 10);
+            }
+            await sleep(10);
+        }
+        throw new Error(`${this.fileName} was never completely written`);
+    }
+    async writePidFile(mode, additionalLock) {
+        const fd = await fs_1.promises.open(this.fileName, mode); // May fail if the file already exists
+        await fd.write(`${process.pid}.`); // Period guards against partial reads
+        await fd.close();
+        return {
+            release: async () => {
+                await fs_1.promises.unlink(this.fileName);
+                await (additionalLock === null || additionalLock === void 0 ? void 0 : additionalLock.release());
+            },
+        };
+    }
+}
+exports.XpMutex = XpMutex;
+async function fileExists(fileName) {
+    try {
+        await fs_1.promises.stat(fileName);
+        return true;
+    }
+    catch (e) {
+        if (e.code === 'ENOENT') {
+            return false;
+        }
+        throw e;
+    }
+}
+function processExists(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function sleep(ms) {
+    return new Promise(ok => setTimeout(ok, ms).unref());
+}
+function randomSleep(ms) {
+    return sleep(Math.floor(Math.random() * ms));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"xpmutex.js","sourceRoot":"","sources":["xpmutex.ts"],"names":[],"mappings":"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","sourcesContent":["import { watch, promises as fs, mkdirSync } from 'fs';\nimport * as os from 'os';\nimport * as path from 'path';\n\nexport class XpMutexPool {\n  public static fromDirectory(directory: string) {\n    mkdirSync(directory, { recursive: true });\n    return new XpMutexPool(directory);\n  }\n\n  public static fromName(name: string) {\n    return XpMutexPool.fromDirectory(path.join(os.tmpdir(), name));\n  }\n\n  private readonly waitingResolvers = new Set<() => void>();\n  private watcher: ReturnType<typeof watch> | undefined;\n\n  private constructor(public readonly directory: string) {\n    this.startWatch();\n  }\n\n  public mutex(name: string) {\n    return new XpMutex(this, name);\n  }\n\n  /**\n   * Await an unlock event\n   *\n   * (An unlock event is when a file in the directory gets deleted, with a tiny\n   * random sleep attached to it).\n   */\n  public awaitUnlock(maxWaitMs?: number): Promise<void> {\n    const wait = new Promise<void>(ok => {\n      this.waitingResolvers.add(async () => {\n        await randomSleep(10);\n        ok();\n      });\n    });\n\n    if (maxWaitMs) {\n      return Promise.race([wait, sleep(maxWaitMs)]);\n    } else {\n      return wait;\n    }\n  }\n\n  private startWatch() {\n    this.watcher = watch(this.directory);\n    (this.watcher as any).unref(); // @types doesn't know about this but it exists\n    this.watcher.on('change', async (eventType, fname) => {\n      // Only trigger on 'deletes'.\n      // After receiving the event, we check if the file exists.\n      // - If no: the file was deleted! Huzzah, this counts as a wakeup.\n      // - If yes: either the file was just created (in which case we don't need to wakeup)\n      //   or the event was due to a delete but someone raced us to it and claimed the\n      //   file already (in which case we also don't need to wake up).\n      if (eventType === 'rename' && !await fileExists(path.join(this.directory, fname.toString()))) {\n        this.notifyWaiters();\n      }\n    });\n    this.watcher.on('error', async (e) => {\n      // eslint-disable-next-line no-console\n      console.error(e);\n      await randomSleep(100);\n      this.startWatch();\n    });\n  }\n\n  private notifyWaiters() {\n    for (const promise of this.waitingResolvers) {\n      promise();\n    }\n    this.waitingResolvers.clear();\n  }\n}\n\n/**\n * Cross-process mutex\n *\n * Uses the presence of a file on disk and `fs.watch` to represent the mutex\n * and discover unlocks.\n */\nexport class XpMutex {\n  private readonly fileName: string;\n\n  constructor(private readonly pool: XpMutexPool, public readonly mutexName: string) {\n    this.fileName = path.join(pool.directory, `${mutexName}.mutex`);\n  }\n\n  /**\n   * Try to acquire the lock (may fail)\n   */\n  public async tryAcquire(): Promise<ILock | undefined> {\n    while (true) {\n      // Acquire lock by being the one to create the file\n      try {\n        return await this.writePidFile('wx'); // Fails if the file already exists\n      } catch (e: any) {\n        if (e.code !== 'EEXIST') { throw e; }\n      }\n\n      // File already exists. Read the contents, see if it's an existent PID (if so, the lock is taken)\n      const ownerPid = await this.readPidFile();\n      if (ownerPid === undefined) {\n        // File got deleted just now, maybe we can acquire it again\n        continue;\n      }\n      if (processExists(ownerPid)) {\n        return undefined;\n      }\n\n      // If not, the lock is stale and will never be released anymore. We may\n      // delete it and acquire it anyway, but we may be racing someone else trying\n      // to do the same. Solve this as follows:\n      // - Try to acquire a lock that gives us permissions to declare the existing lock stale.\n      // - Sleep a small random period to reduce contention on this operation\n      await randomSleep(10);\n      const innerMux = new XpMutex(this.pool, `${this.mutexName}.${ownerPid}`);\n      const innerLock = await innerMux.tryAcquire();\n      if (!innerLock) {\n        return undefined;\n      }\n\n      // We may not release the 'inner lock' we used to acquire the rights to declare the other\n      // lock stale until we release the actual lock itself. If we did, other contenders might\n      // see it released while they're still in this fallback block and accidentally steal\n      // from a new legitimate owner.\n      return this.writePidFile('w', innerLock); // Force write lock file, attach inner lock as well\n    }\n  }\n\n  /**\n   * Acquire the lock, waiting until we can\n   */\n  public async acquire(): Promise<ILock> {\n    while (true) {\n      // Start the wait here, so we don't miss the signal if it comes after\n      // we try but before we sleep.\n      //\n      // We also periodically retry anyway since we may have missed the delete\n      // signal due to unfortunate timing.\n      const wait = this.pool.awaitUnlock(5000);\n\n      const lock = await this.tryAcquire();\n      if (lock) {\n        // Ignore the wait (count as handled)\n        wait.then(() => {}, () => {});\n        return lock;\n      }\n\n      await wait;\n      await randomSleep(100);\n    }\n  }\n\n  private async readPidFile(): Promise<number | undefined> {\n    const deadLine = Date.now() + 1000;\n    while (Date.now() < deadLine) {\n      let contents;\n      try {\n        contents = await fs.readFile(this.fileName, { encoding: 'utf-8' });\n      } catch (e: any) {\n        if (e.code === 'ENOENT') { return undefined; }\n        throw e;\n      }\n\n      // Retry until we've seen the full contents\n      if (contents.endsWith('.')) { return parseInt(contents.substring(0, contents.length - 1), 10); }\n      await sleep(10);\n    }\n\n    throw new Error(`${this.fileName} was never completely written`);\n  }\n\n  private async writePidFile(mode: string, additionalLock?: ILock): Promise<ILock> {\n    const fd = await fs.open(this.fileName, mode); // May fail if the file already exists\n    await fd.write(`${process.pid}.`); // Period guards against partial reads\n    await fd.close();\n\n    return {\n      release: async () => {\n        await fs.unlink(this.fileName);\n        await additionalLock?.release();\n      },\n    };\n  }\n}\n\nexport interface ILock {\n  release(): Promise<void>;\n}\n\nasync function fileExists(fileName: string) {\n  try {\n    await fs.stat(fileName);\n    return true;\n  } catch (e: any) {\n    if (e.code === 'ENOENT') { return false; }\n    throw e;\n  }\n}\n\nfunction processExists(pid: number) {\n  try {\n    process.kill(pid, 0);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\nfunction sleep(ms: number): Promise<void> {\n  return new Promise(ok => (setTimeout(ok, ms) as any).unref());\n}\n\nfunction randomSleep(ms: number) {\n  return sleep(Math.floor(Math.random() * ms));\n}\n"]}

package/lib/xpmutex.ts

@@ -0,0 +1,218 @@
+import { watch, promises as fs, mkdirSync } from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+
+export class XpMutexPool {
+  public static fromDirectory(directory: string) {
+    mkdirSync(directory, { recursive: true });
+    return new XpMutexPool(directory);
+  }
+
+  public static fromName(name: string) {
+    return XpMutexPool.fromDirectory(path.join(os.tmpdir(), name));
+  }
+
+  private readonly waitingResolvers = new Set<() => void>();
+  private watcher: ReturnType<typeof watch> | undefined;
+
+  private constructor(public readonly directory: string) {
+    this.startWatch();
+  }
+
+  public mutex(name: string) {
+    return new XpMutex(this, name);
+  }
+
+  /**
+   * Await an unlock event
+   *
+   * (An unlock event is when a file in the directory gets deleted, with a tiny
+   * random sleep attached to it).
+   */
+  public awaitUnlock(maxWaitMs?: number): Promise<void> {
+    const wait = new Promise<void>(ok => {
+      this.waitingResolvers.add(async () => {
+        await randomSleep(10);
+        ok();
+      });
+    });
+
+    if (maxWaitMs) {
+      return Promise.race([wait, sleep(maxWaitMs)]);
+    } else {
+      return wait;
+    }
+  }
+
+  private startWatch() {
+    this.watcher = watch(this.directory);
+    (this.watcher as any).unref(); // @types doesn't know about this but it exists
+    this.watcher.on('change', async (eventType, fname) => {
+      // Only trigger on 'deletes'.
+      // After receiving the event, we check if the file exists.
+      // - If no: the file was deleted! Huzzah, this counts as a wakeup.
+      // - If yes: either the file was just created (in which case we don't need to wakeup)
+      //   or the event was due to a delete but someone raced us to it and claimed the
+      //   file already (in which case we also don't need to wake up).
+      if (eventType === 'rename' && !await fileExists(path.join(this.directory, fname.toString()))) {
+        this.notifyWaiters();
+      }
+    });
+    this.watcher.on('error', async (e) => {
+      // eslint-disable-next-line no-console
+      console.error(e);
+      await randomSleep(100);
+      this.startWatch();
+    });
+  }
+
+  private notifyWaiters() {
+    for (const promise of this.waitingResolvers) {
+      promise();
+    }
+    this.waitingResolvers.clear();
+  }
+}
+
+/**
+ * Cross-process mutex
+ *
+ * Uses the presence of a file on disk and `fs.watch` to represent the mutex
+ * and discover unlocks.
+ */
+export class XpMutex {
+  private readonly fileName: string;
+
+  constructor(private readonly pool: XpMutexPool, public readonly mutexName: string) {
+    this.fileName = path.join(pool.directory, `${mutexName}.mutex`);
+  }
+
+  /**
+   * Try to acquire the lock (may fail)
+   */
+  public async tryAcquire(): Promise<ILock | undefined> {
+    while (true) {
+      // Acquire lock by being the one to create the file
+      try {
+        return await this.writePidFile('wx'); // Fails if the file already exists
+      } catch (e: any) {
+        if (e.code !== 'EEXIST') { throw e; }
+      }
+
+      // File already exists. Read the contents, see if it's an existent PID (if so, the lock is taken)
+      const ownerPid = await this.readPidFile();
+      if (ownerPid === undefined) {
+        // File got deleted just now, maybe we can acquire it again
+        continue;
+      }
+      if (processExists(ownerPid)) {
+        return undefined;
+      }
+
+      // If not, the lock is stale and will never be released anymore. We may
+      // delete it and acquire it anyway, but we may be racing someone else trying
+      // to do the same. Solve this as follows:
+      // - Try to acquire a lock that gives us permissions to declare the existing lock stale.
+      // - Sleep a small random period to reduce contention on this operation
+      await randomSleep(10);
+      const innerMux = new XpMutex(this.pool, `${this.mutexName}.${ownerPid}`);
+      const innerLock = await innerMux.tryAcquire();
+      if (!innerLock) {
+        return undefined;
+      }
+
+      // We may not release the 'inner lock' we used to acquire the rights to declare the other
+      // lock stale until we release the actual lock itself. If we did, other contenders might
+      // see it released while they're still in this fallback block and accidentally steal
+      // from a new legitimate owner.
+      return this.writePidFile('w', innerLock); // Force write lock file, attach inner lock as well
+    }
+  }
+
+  /**
+   * Acquire the lock, waiting until we can
+   */
+  public async acquire(): Promise<ILock> {
+    while (true) {
+      // Start the wait here, so we don't miss the signal if it comes after
+      // we try but before we sleep.
+      //
+      // We also periodically retry anyway since we may have missed the delete
+      // signal due to unfortunate timing.
+      const wait = this.pool.awaitUnlock(5000);
+
+      const lock = await this.tryAcquire();
+      if (lock) {
+        // Ignore the wait (count as handled)
+        wait.then(() => {}, () => {});
+        return lock;
+      }
+
+      await wait;
+      await randomSleep(100);
+    }
+  }
+
+  private async readPidFile(): Promise<number | undefined> {
+    const deadLine = Date.now() + 1000;
+    while (Date.now() < deadLine) {
+      let contents;
+      try {
+        contents = await fs.readFile(this.fileName, { encoding: 'utf-8' });
+      } catch (e: any) {
+        if (e.code === 'ENOENT') { return undefined; }
+        throw e;
+      }
+
+      // Retry until we've seen the full contents
+      if (contents.endsWith('.')) { return parseInt(contents.substring(0, contents.length - 1), 10); }
+      await sleep(10);
+    }
+
+    throw new Error(`${this.fileName} was never completely written`);
+  }
+
+  private async writePidFile(mode: string, additionalLock?: ILock): Promise<ILock> {
+    const fd = await fs.open(this.fileName, mode); // May fail if the file already exists
+    await fd.write(`${process.pid}.`); // Period guards against partial reads
+    await fd.close();
+
+    return {
+      release: async () => {
+        await fs.unlink(this.fileName);
+        await additionalLock?.release();
+      },
+    };
+  }
+}
+
+export interface ILock {
+  release(): Promise<void>;
+}
+
+async function fileExists(fileName: string) {
+  try {
+    await fs.stat(fileName);
+    return true;
+  } catch (e: any) {
+    if (e.code === 'ENOENT') { return false; }
+    throw e;
+  }
+}
+
+function processExists(pid: number) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise(ok => (setTimeout(ok, ms) as any).unref());
+}
+
+function randomSleep(ms: number) {
+  return sleep(Math.floor(Math.random() * ms));
+}