@aws-cdk/toolkit-lib 0.3.2 → 0.3.3

package/lib/api/resource-metadata/resource-metadata.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resourceMetadata = resourceMetadata;
+const cloud_assembly_schema_1 = require("@aws-cdk/cloud-assembly-schema");
+/**
+ * Attempts to read metadata for resources from a CloudFormation stack artifact
+ *
+ * @param stack The CloudFormation stack to read from
+ * @param logicalId The logical ID of the resource to read
+ *
+ * @returns The resource metadata, or undefined if the resource was not found
+ */
+function resourceMetadata(stack, logicalId) {
+    const metadata = stack.manifest?.metadata;
+    if (!metadata) {
+        return undefined;
+    }
+    for (const path of Object.keys(metadata)) {
+        const entry = metadata[path]
+            .filter((e) => e.type === cloud_assembly_schema_1.ArtifactMetadataEntryType.LOGICAL_ID)
+            .find((e) => e.data === logicalId);
+        if (entry) {
+            return {
+                entry,
+                constructPath: simplifyConstructPath(path, stack.stackName),
+            };
+        }
+    }
+    return undefined;
+}
+function simplifyConstructPath(path, stackName) {
+    path = path.replace(/\/Resource$/, '');
+    path = path.replace(/^\//, ''); // remove "/" prefix
+    // remove "<stack-name>/" prefix
+    if (stackName) {
+        if (path.startsWith(stackName + '/')) {
+            path = path.slice(stackName.length + 1);
+        }
+    }
+    return path;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/rwlock.d.ts

@@ -0,0 +1,60 @@
+/**
+ * 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.
+ */
+export declare class RWLock {
+    readonly directory: string;
+    private readonly pidString;
+    private readonly writerFile;
+    private readCounter;
+    constructor(directory: string);
+    /**
+     * Acquire a writer lock.
+     *
+     * No other readers or writers must exist for the given directory.
+     */
+    acquireWrite(): Promise<IWriteLock>;
+    /**
+     * Acquire a read lock
+     *
+     * Will fail if there are any writers.
+     */
+    acquireRead(): Promise<IReadLock>;
+    /**
+     * 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.).
+     */
+    private readerFile;
+    /**
+     * Do the actual acquiring of a read lock.
+     */
+    private doAcquireRead;
+    private assertNoOtherWriters;
+}
+/**
+ * An acquired lock
+ */
+export interface IReadLock {
+    /**
+     * Release the lock. Can be called more than once.
+     */
+    release(): Promise<void>;
+}
+/**
+ * An acquired writer lock
+ */
+export interface IWriteLock extends IReadLock {
+    /**
+     * Convert the writer lock to a reader lock
+     */
+    convertToReaderLock(): Promise<IReadLock>;
+}

package/lib/api/rwlock.js

@@ -0,0 +1,204 @@
+"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-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-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"]}

package/lib/api/settings.d.ts

@@ -0,0 +1,26 @@
+export type SettingsMap = {
+    [key: string]: any;
+};
+/**
+ * If a context value is an object with this key set to a truthy value, it won't be saved to cdk.context.json
+ */
+export declare const TRANSIENT_CONTEXT_KEY = "$dontSaveContext";
+/**
+ * A single bag of settings
+ */
+export declare class Settings {
+    private settings;
+    readonly readOnly: boolean;
+    static mergeAll(...settings: Settings[]): Settings;
+    constructor(settings?: SettingsMap, readOnly?: boolean);
+    save(fileName: string): Promise<this>;
+    get all(): any;
+    merge(other: Settings): Settings;
+    subSettings(keyPrefix: string[]): Settings;
+    makeReadOnly(): Settings;
+    clear(): void;
+    get empty(): boolean;
+    get(path: string[]): any;
+    set(path: string[], value: any): Settings;
+    unset(path: string[]): void;
+}

package/lib/api/settings.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Settings = exports.TRANSIENT_CONTEXT_KEY = void 0;
+const os = require("os");
+const fs_path = require("path");
+const fs = require("fs-extra");
+const toolkit_error_1 = require("./toolkit-error");
+const util = require("../util");
+/**
+ * If a context value is an object with this key set to a truthy value, it won't be saved to cdk.context.json
+ */
+exports.TRANSIENT_CONTEXT_KEY = '$dontSaveContext';
+/**
+ * A single bag of settings
+ */
+class Settings {
+    settings;
+    readOnly;
+    static mergeAll(...settings) {
+        let ret = new Settings();
+        for (const setting of settings) {
+            ret = ret.merge(setting);
+        }
+        return ret;
+    }
+    constructor(settings = {}, readOnly = false) {
+        this.settings = settings;
+        this.readOnly = readOnly;
+    }
+    async save(fileName) {
+        const expanded = expandHomeDir(fileName);
+        await fs.writeJson(expanded, stripTransientValues(this.settings), {
+            spaces: 2,
+        });
+        return this;
+    }
+    get all() {
+        return this.get([]);
+    }
+    merge(other) {
+        return new Settings(util.deepMerge(this.settings, other.settings));
+    }
+    subSettings(keyPrefix) {
+        return new Settings(this.get(keyPrefix) || {}, false);
+    }
+    makeReadOnly() {
+        return new Settings(this.settings, true);
+    }
+    clear() {
+        if (this.readOnly) {
+            throw new toolkit_error_1.ToolkitError('Cannot clear(): settings are readonly');
+        }
+        this.settings = {};
+    }
+    get empty() {
+        return Object.keys(this.settings).length === 0;
+    }
+    get(path) {
+        return util.deepClone(util.deepGet(this.settings, path));
+    }
+    set(path, value) {
+        if (this.readOnly) {
+            throw new toolkit_error_1.ToolkitError(`Can't set ${path}: settings object is readonly`);
+        }
+        if (path.length === 0) {
+            // deepSet can't handle this case
+            this.settings = value;
+        }
+        else {
+            util.deepSet(this.settings, path, value);
+        }
+        return this;
+    }
+    unset(path) {
+        this.set(path, undefined);
+    }
+}
+exports.Settings = Settings;
+function expandHomeDir(x) {
+    if (x.startsWith('~')) {
+        return fs_path.join(os.homedir(), x.slice(1));
+    }
+    return x;
+}
+/**
+ * Return all context value that are not transient context values
+ */
+function stripTransientValues(obj) {
+    const ret = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (!isTransientValue(value)) {
+            ret[key] = value;
+        }
+    }
+    return ret;
+}
+/**
+ * Return whether the given value is a transient context value
+ *
+ * Values that are objects with a magic key set to a truthy value are considered transient.
+ */
+function isTransientValue(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        value[exports.TRANSIENT_CONTEXT_KEY]);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/shared-private.d.ts

@@ -1,6 +1,8 @@
-export * from '../../../tmp-toolkit-helpers/src/api/io/private';
-export * from '../../../tmp-toolkit-helpers/src/private';
-export * from '../../../tmp-toolkit-helpers/src/api';
-export * as cfnApi from '../../../tmp-toolkit-helpers/src/api/deployments/cfn-api';
-export { makeRequestHandler } from '../../../tmp-toolkit-helpers/src/api/aws-auth/awscli-compatible';
-export * as contextproviders from '../../../tmp-toolkit-helpers/src/context-providers';
+import '../private/dispose-polyfill';
+export * from '../private';
+export * from './io/private';
+export * from './aws-auth/private';
+export * from './cloud-assembly/private';
+export * as cfnApi from './deployments/cfn-api';
+export { makeRequestHandler } from './aws-auth/awscli-compatible';
+export * as contextproviders from '../context-providers';