@aws-cdk/toolkit-lib 0.3.2 → 0.3.3

package/lib/api/environment/environment-access.js

@@ -0,0 +1,205 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnvironmentAccess = void 0;
+const toolkit_error_1 = require("../toolkit-error");
+const environment_resources_1 = require("./environment-resources");
+const placeholders_1 = require("./placeholders");
+const util_1 = require("../../util");
+const private_1 = require("../io/private");
+const plugin_1 = require("../plugin");
+/**
+ * Access particular AWS resources, based on information from the CX manifest
+ *
+ * It is not possible to grab direct access to AWS credentials; 9 times out of 10
+ * we have to allow for role assumption, and role assumption can only work if
+ * there is a CX Manifest that contains a role ARN.
+ *
+ * This class exists so new code isn't tempted to go and get SDK credentials directly.
+ */
+class EnvironmentAccess {
+    sdkProvider;
+    sdkCache = new Map();
+    environmentResources;
+    ioHelper;
+    constructor(sdkProvider, toolkitStackName, ioHelper) {
+        this.sdkProvider = sdkProvider;
+        this.environmentResources = new environment_resources_1.EnvironmentResourcesRegistry(toolkitStackName);
+        this.ioHelper = ioHelper;
+    }
+    /**
+     * Resolves the environment for a stack.
+     */
+    async resolveStackEnvironment(stack) {
+        return this.sdkProvider.resolveEnvironment(stack.environment);
+    }
+    /**
+     * Get an SDK to access the given stack's environment for stack operations
+     *
+     * Will ask plugins for readonly credentials if available, use the default
+     * AWS credentials if not.
+     *
+     * Will assume the deploy role if configured on the stack. Check the default `deploy-role`
+     * policies to see what you can do with this role.
+     */
+    async accessStackForReadOnlyStackOperations(stack) {
+        return this.accessStackForStackOperations(stack, plugin_1.Mode.ForReading);
+    }
+    /**
+     * Get an SDK to access the given stack's environment for stack operations
+     *
+     * Will ask plugins for mutating credentials if available, use the default AWS
+     * credentials if not.  The `mode` parameter is only used for querying
+     * plugins.
+     *
+     * Will assume the deploy role if configured on the stack. Check the default `deploy-role`
+     * policies to see what you can do with this role.
+     */
+    async accessStackForMutableStackOperations(stack) {
+        return this.accessStackForStackOperations(stack, plugin_1.Mode.ForWriting);
+    }
+    /**
+     * Get an SDK to access the given stack's environment for environmental lookups
+     *
+     * Will use a plugin if available, use the default AWS credentials if not.
+     * The `mode` parameter is only used for querying plugins.
+     *
+     * Will assume the lookup role if configured on the stack. Check the default `lookup-role`
+     * policies to see what you can do with this role. It can generally read everything
+     * in the account that does not require KMS access.
+     *
+     * ---
+     *
+     * For backwards compatibility reasons, there are some scenarios that are handled here:
+     *
+     *  1. The lookup role may not exist (it was added in bootstrap stack version 7). If so:
+     *     a. Return the default credentials if the default credentials are for the stack account
+     *        (you will notice this as `isFallbackCredentials=true`).
+     *     b. Throw an error if the default credentials are not for the stack account.
+     *
+     *  2. The lookup role may not have the correct permissions (for example, ReadOnlyAccess was added in
+     *     bootstrap stack version 8); the stack will have a minimum version number on it.
+     *     a. If it does not we throw an error which should be handled in the calling
+     *        function (and fallback to use a different role, etc)
+     *
+     * Upon success, caller will have an SDK for the right account, which may or may not have
+     * the right permissions.
+     */
+    async accessStackForLookup(stack) {
+        if (!stack.environment) {
+            throw new toolkit_error_1.ToolkitError(`The stack ${stack.displayName} does not have an environment`);
+        }
+        const lookupEnv = await this.prepareSdk({
+            environment: stack.environment,
+            mode: plugin_1.Mode.ForReading,
+            assumeRoleArn: stack.lookupRole?.arn,
+            assumeRoleExternalId: stack.lookupRole?.assumeRoleExternalId,
+            assumeRoleAdditionalOptions: stack.lookupRole?.assumeRoleAdditionalOptions,
+        });
+        // if we succeed in assuming the lookup role, make sure we have the correct bootstrap stack version
+        if (lookupEnv.didAssumeRole && stack.lookupRole?.bootstrapStackVersionSsmParameter && stack.lookupRole.requiresBootstrapStackVersion) {
+            const version = await lookupEnv.resources.versionFromSsmParameter(stack.lookupRole.bootstrapStackVersionSsmParameter);
+            if (version < stack.lookupRole.requiresBootstrapStackVersion) {
+                throw new toolkit_error_1.ToolkitError(`Bootstrap stack version '${stack.lookupRole.requiresBootstrapStackVersion}' is required, found version '${version}'. To get rid of this error, please upgrade to bootstrap version >= ${stack.lookupRole.requiresBootstrapStackVersion}`);
+            }
+        }
+        if (lookupEnv.isFallbackCredentials) {
+            const arn = await lookupEnv.replacePlaceholders(stack.lookupRole?.arn);
+            await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_WARN.msg(`Lookup role ${arn} was not assumed. Proceeding with default credentials.`));
+        }
+        return lookupEnv;
+    }
+    /**
+     * Get an SDK to access the given stack's environment for reading stack attributes
+     *
+     * Will use a plugin if available, use the default AWS credentials if not.
+     * The `mode` parameter is only used for querying plugins.
+     *
+     * Will try to assume the lookup role if given, will use the regular stack operations
+     * access (deploy-role) otherwise. When calling this, you should assume that you will get
+     * the least privileged role, so don't try to use it for anything the `deploy-role`
+     * wouldn't be able to do. Also you cannot rely on being able to read encrypted anything.
+     */
+    async accessStackForLookupBestEffort(stack) {
+        if (!stack.environment) {
+            throw new toolkit_error_1.ToolkitError(`The stack ${stack.displayName} does not have an environment`);
+        }
+        try {
+            return await this.accessStackForLookup(stack);
+        }
+        catch (e) {
+            await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_WARN.msg(`${(0, util_1.formatErrorMessage)(e)}`));
+        }
+        return this.accessStackForStackOperations(stack, plugin_1.Mode.ForReading);
+    }
+    /**
+     * Get an SDK to access the given stack's environment for stack operations
+     *
+     * Will use a plugin if available, use the default AWS credentials if not.
+     * The `mode` parameter is only used for querying plugins.
+     *
+     * Will assume the deploy role if configured on the stack. Check the default `deploy-role`
+     * policies to see what you can do with this role.
+     */
+    async accessStackForStackOperations(stack, mode) {
+        if (!stack.environment) {
+            throw new toolkit_error_1.ToolkitError(`The stack ${stack.displayName} does not have an environment`);
+        }
+        return this.prepareSdk({
+            environment: stack.environment,
+            mode,
+            assumeRoleArn: stack.assumeRoleArn,
+            assumeRoleExternalId: stack.assumeRoleExternalId,
+            assumeRoleAdditionalOptions: stack.assumeRoleAdditionalOptions,
+        });
+    }
+    /**
+     * Prepare an SDK for use in the given environment and optionally with a role assumed.
+     */
+    async prepareSdk(options) {
+        const resolvedEnvironment = await this.sdkProvider.resolveEnvironment(options.environment);
+        // Substitute any placeholders with information about the current environment
+        const { assumeRoleArn } = await (0, placeholders_1.replaceEnvPlaceholders)({
+            assumeRoleArn: options.assumeRoleArn,
+        }, resolvedEnvironment, this.sdkProvider);
+        const stackSdk = await this.cachedSdkForEnvironment(resolvedEnvironment, options.mode, {
+            assumeRoleArn,
+            assumeRoleExternalId: options.assumeRoleExternalId,
+            assumeRoleAdditionalOptions: options.assumeRoleAdditionalOptions,
+        });
+        return {
+            sdk: stackSdk.sdk,
+            resolvedEnvironment,
+            resources: this.environmentResources.for(resolvedEnvironment, stackSdk.sdk, this.ioHelper),
+            // If we asked for a role, did not successfully assume it, and yet got here without an exception: that
+            // means we must have fallback credentials.
+            isFallbackCredentials: !stackSdk.didAssumeRole && !!assumeRoleArn,
+            didAssumeRole: stackSdk.didAssumeRole,
+            replacePlaceholders: async (str) => {
+                const ret = await (0, placeholders_1.replaceEnvPlaceholders)({ str }, resolvedEnvironment, this.sdkProvider);
+                return ret.str;
+            },
+        };
+    }
+    async cachedSdkForEnvironment(environment, mode, options) {
+        const cacheKeyElements = [
+            environment.account,
+            environment.region,
+            `${mode}`,
+            options?.assumeRoleArn ?? '',
+            options?.assumeRoleExternalId ?? '',
+        ];
+        if (options?.assumeRoleAdditionalOptions) {
+            cacheKeyElements.push(JSON.stringify(options.assumeRoleAdditionalOptions));
+        }
+        const cacheKey = cacheKeyElements.join(':');
+        const existing = this.sdkCache.get(cacheKey);
+        if (existing) {
+            return existing;
+        }
+        const ret = await this.sdkProvider.forEnvironment(environment, mode, options);
+        this.sdkCache.set(cacheKey, ret);
+        return ret;
+    }
+}
+exports.EnvironmentAccess = EnvironmentAccess;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"environment-access.js","sourceRoot":"","sources":["environment-access.ts"],"names":[],"mappings":"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","sourcesContent":["import type * as cxapi from '@aws-cdk/cx-api';\nimport { ToolkitError } from '../toolkit-error';\nimport type { EnvironmentResources } from './environment-resources';\nimport { EnvironmentResourcesRegistry } from './environment-resources';\nimport type { StringWithoutPlaceholders } from './placeholders';\nimport { replaceEnvPlaceholders } from './placeholders';\nimport { formatErrorMessage } from '../../util';\nimport type { SDK, CredentialsOptions, SdkForEnvironment, SdkProvider } from '../aws-auth/private';\nimport { IO, type IoHelper } from '../io/private';\nimport { Mode } from '../plugin';\n\n/**\n * Access particular AWS resources, based on information from the CX manifest\n *\n * It is not possible to grab direct access to AWS credentials; 9 times out of 10\n * we have to allow for role assumption, and role assumption can only work if\n * there is a CX Manifest that contains a role ARN.\n *\n * This class exists so new code isn't tempted to go and get SDK credentials directly.\n */\nexport class EnvironmentAccess {\n  private readonly sdkCache = new Map<string, SdkForEnvironment>();\n  private readonly environmentResources: EnvironmentResourcesRegistry;\n  private readonly ioHelper: IoHelper;\n\n  constructor(private readonly sdkProvider: SdkProvider, toolkitStackName: string, ioHelper: IoHelper) {\n    this.environmentResources = new EnvironmentResourcesRegistry(toolkitStackName);\n    this.ioHelper = ioHelper;\n  }\n\n  /**\n   * Resolves the environment for a stack.\n   */\n  public async resolveStackEnvironment(stack: cxapi.CloudFormationStackArtifact): Promise<cxapi.Environment> {\n    return this.sdkProvider.resolveEnvironment(stack.environment);\n  }\n\n  /**\n   * Get an SDK to access the given stack's environment for stack operations\n   *\n   * Will ask plugins for readonly credentials if available, use the default\n   * AWS credentials if not.\n   *\n   * Will assume the deploy role if configured on the stack. Check the default `deploy-role`\n   * policies to see what you can do with this role.\n   */\n  public async accessStackForReadOnlyStackOperations(stack: cxapi.CloudFormationStackArtifact): Promise<TargetEnvironment> {\n    return this.accessStackForStackOperations(stack, Mode.ForReading);\n  }\n\n  /**\n   * Get an SDK to access the given stack's environment for stack operations\n   *\n   * Will ask plugins for mutating credentials if available, use the default AWS\n   * credentials if not.  The `mode` parameter is only used for querying\n   * plugins.\n   *\n   * Will assume the deploy role if configured on the stack. Check the default `deploy-role`\n   * policies to see what you can do with this role.\n   */\n  public async accessStackForMutableStackOperations(stack: cxapi.CloudFormationStackArtifact): Promise<TargetEnvironment> {\n    return this.accessStackForStackOperations(stack, Mode.ForWriting);\n  }\n\n  /**\n   * Get an SDK to access the given stack's environment for environmental lookups\n   *\n   * Will use a plugin if available, use the default AWS credentials if not.\n   * The `mode` parameter is only used for querying plugins.\n   *\n   * Will assume the lookup role if configured on the stack. Check the default `lookup-role`\n   * policies to see what you can do with this role. It can generally read everything\n   * in the account that does not require KMS access.\n   *\n   * ---\n   *\n   * For backwards compatibility reasons, there are some scenarios that are handled here:\n   *\n   *  1. The lookup role may not exist (it was added in bootstrap stack version 7). If so:\n   *     a. Return the default credentials if the default credentials are for the stack account\n   *        (you will notice this as `isFallbackCredentials=true`).\n   *     b. Throw an error if the default credentials are not for the stack account.\n   *\n   *  2. The lookup role may not have the correct permissions (for example, ReadOnlyAccess was added in\n   *     bootstrap stack version 8); the stack will have a minimum version number on it.\n   *     a. If it does not we throw an error which should be handled in the calling\n   *        function (and fallback to use a different role, etc)\n   *\n   * Upon success, caller will have an SDK for the right account, which may or may not have\n   * the right permissions.\n   */\n  public async accessStackForLookup(stack: cxapi.CloudFormationStackArtifact): Promise<TargetEnvironment> {\n    if (!stack.environment) {\n      throw new ToolkitError(`The stack ${stack.displayName} does not have an environment`);\n    }\n\n    const lookupEnv = await this.prepareSdk({\n      environment: stack.environment,\n      mode: Mode.ForReading,\n      assumeRoleArn: stack.lookupRole?.arn,\n      assumeRoleExternalId: stack.lookupRole?.assumeRoleExternalId,\n      assumeRoleAdditionalOptions: stack.lookupRole?.assumeRoleAdditionalOptions,\n    });\n\n    // if we succeed in assuming the lookup role, make sure we have the correct bootstrap stack version\n    if (lookupEnv.didAssumeRole && stack.lookupRole?.bootstrapStackVersionSsmParameter && stack.lookupRole.requiresBootstrapStackVersion) {\n      const version = await lookupEnv.resources.versionFromSsmParameter(stack.lookupRole.bootstrapStackVersionSsmParameter);\n      if (version < stack.lookupRole.requiresBootstrapStackVersion) {\n        throw new ToolkitError(`Bootstrap stack version '${stack.lookupRole.requiresBootstrapStackVersion}' is required, found version '${version}'. To get rid of this error, please upgrade to bootstrap version >= ${stack.lookupRole.requiresBootstrapStackVersion}`);\n      }\n    }\n    if (lookupEnv.isFallbackCredentials) {\n      const arn = await lookupEnv.replacePlaceholders(stack.lookupRole?.arn);\n      await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_WARN.msg(`Lookup role ${arn} was not assumed. Proceeding with default credentials.`));\n    }\n    return lookupEnv;\n  }\n\n  /**\n   * Get an SDK to access the given stack's environment for reading stack attributes\n   *\n   * Will use a plugin if available, use the default AWS credentials if not.\n   * The `mode` parameter is only used for querying plugins.\n   *\n   * Will try to assume the lookup role if given, will use the regular stack operations\n   * access (deploy-role) otherwise. When calling this, you should assume that you will get\n   * the least privileged role, so don't try to use it for anything the `deploy-role`\n   * wouldn't be able to do. Also you cannot rely on being able to read encrypted anything.\n   */\n  public async accessStackForLookupBestEffort(stack: cxapi.CloudFormationStackArtifact): Promise<TargetEnvironment> {\n    if (!stack.environment) {\n      throw new ToolkitError(`The stack ${stack.displayName} does not have an environment`);\n    }\n\n    try {\n      return await this.accessStackForLookup(stack);\n    } catch (e: any) {\n      await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_WARN.msg(`${formatErrorMessage(e)}`));\n    }\n    return this.accessStackForStackOperations(stack, Mode.ForReading);\n  }\n\n  /**\n   * Get an SDK to access the given stack's environment for stack operations\n   *\n   * Will use a plugin if available, use the default AWS credentials if not.\n   * The `mode` parameter is only used for querying plugins.\n   *\n   * Will assume the deploy role if configured on the stack. Check the default `deploy-role`\n   * policies to see what you can do with this role.\n   */\n  private async accessStackForStackOperations(stack: cxapi.CloudFormationStackArtifact, mode: Mode): Promise<TargetEnvironment> {\n    if (!stack.environment) {\n      throw new ToolkitError(`The stack ${stack.displayName} does not have an environment`);\n    }\n\n    return this.prepareSdk({\n      environment: stack.environment,\n      mode,\n      assumeRoleArn: stack.assumeRoleArn,\n      assumeRoleExternalId: stack.assumeRoleExternalId,\n      assumeRoleAdditionalOptions: stack.assumeRoleAdditionalOptions,\n    });\n  }\n\n  /**\n   * Prepare an SDK for use in the given environment and optionally with a role assumed.\n   */\n  private async prepareSdk(\n    options: PrepareSdkRoleOptions,\n  ): Promise<TargetEnvironment> {\n    const resolvedEnvironment = await this.sdkProvider.resolveEnvironment(options.environment);\n\n    // Substitute any placeholders with information about the current environment\n    const { assumeRoleArn } = await replaceEnvPlaceholders({\n      assumeRoleArn: options.assumeRoleArn,\n    }, resolvedEnvironment, this.sdkProvider);\n\n    const stackSdk = await this.cachedSdkForEnvironment(resolvedEnvironment, options.mode, {\n      assumeRoleArn,\n      assumeRoleExternalId: options.assumeRoleExternalId,\n      assumeRoleAdditionalOptions: options.assumeRoleAdditionalOptions,\n    });\n\n    return {\n      sdk: stackSdk.sdk,\n      resolvedEnvironment,\n      resources: this.environmentResources.for(resolvedEnvironment, stackSdk.sdk, this.ioHelper),\n      // If we asked for a role, did not successfully assume it, and yet got here without an exception: that\n      // means we must have fallback credentials.\n      isFallbackCredentials: !stackSdk.didAssumeRole && !!assumeRoleArn,\n      didAssumeRole: stackSdk.didAssumeRole,\n      replacePlaceholders: async <A extends string | undefined>(str: A) => {\n        const ret = await replaceEnvPlaceholders({ str }, resolvedEnvironment, this.sdkProvider);\n        return ret.str;\n      },\n    };\n  }\n\n  private async cachedSdkForEnvironment(\n    environment: cxapi.Environment,\n    mode: Mode,\n    options?: CredentialsOptions,\n  ) {\n    const cacheKeyElements = [\n      environment.account,\n      environment.region,\n      `${mode}`,\n      options?.assumeRoleArn ?? '',\n      options?.assumeRoleExternalId ?? '',\n    ];\n\n    if (options?.assumeRoleAdditionalOptions) {\n      cacheKeyElements.push(JSON.stringify(options.assumeRoleAdditionalOptions));\n    }\n\n    const cacheKey = cacheKeyElements.join(':');\n    const existing = this.sdkCache.get(cacheKey);\n    if (existing) {\n      return existing;\n    }\n    const ret = await this.sdkProvider.forEnvironment(environment, mode, options);\n    this.sdkCache.set(cacheKey, ret);\n    return ret;\n  }\n}\n\n/**\n * SDK obtained by assuming the deploy role\n * for a given environment\n */\nexport interface TargetEnvironment {\n  /**\n   * The SDK for the given environment\n   */\n  readonly sdk: SDK;\n\n  /**\n   * The resolved environment for the stack\n   * (no more 'unknown-account/unknown-region')\n   */\n  readonly resolvedEnvironment: cxapi.Environment;\n\n  /**\n   * Access class for environmental resources to help the deployment\n   */\n  readonly resources: EnvironmentResources;\n\n  /**\n   * Whether or not we assumed a role in the process of getting these credentials\n   */\n  readonly didAssumeRole: boolean;\n\n  /**\n   * Whether or not these are fallback credentials\n   *\n   * Fallback credentials means that assuming the intended role failed, but the\n   * base credentials happen to be for the right account so we just picked those\n   * and hope the future SDK calls succeed.\n   *\n   * This is a backwards compatibility mechanism from around the time we introduced\n   * deployment roles.\n   */\n  readonly isFallbackCredentials: boolean;\n\n  /**\n   * Replace environment placeholders according to the current environment\n   */\n  replacePlaceholders(x: string | undefined): Promise<StringWithoutPlaceholders | undefined>;\n}\n\ninterface PrepareSdkRoleOptions {\n  readonly environment: cxapi.Environment;\n  readonly mode: Mode;\n  readonly assumeRoleArn?: string;\n  readonly assumeRoleExternalId?: string;\n  readonly assumeRoleAdditionalOptions?: { [key: string]: any };\n}\n"]}

package/lib/api/environment/environment-resources.d.ts

@@ -0,0 +1,75 @@
+import type { Environment } from '@aws-cdk/cx-api';
+import type { SDK } from '../aws-auth/private';
+import { type IoHelper } from '../io/private';
+import { type EcrRepositoryInfo, ToolkitInfo } from '../toolkit-info';
+/**
+ * Registry class for `EnvironmentResources`.
+ *
+ * The state management of this class is a bit non-standard. We want to cache
+ * data related to toolkit stacks and SSM parameters, but we are not in charge
+ * of ensuring caching of SDKs. Since `EnvironmentResources` needs an SDK to
+ * function, we treat it as an ephemeral class, and store the actual cached data
+ * in `EnvironmentResourcesRegistry`.
+ */
+export declare class EnvironmentResourcesRegistry {
+    private readonly toolkitStackName?;
+    private readonly cache;
+    constructor(toolkitStackName?: string | undefined);
+    for(resolvedEnvironment: Environment, sdk: SDK, ioHelper: IoHelper): EnvironmentResources;
+}
+/**
+ * Interface with the account and region we're deploying into
+ *
+ * Manages lookups for bootstrapped resources, falling back to the legacy "CDK Toolkit"
+ * original bootstrap stack if necessary.
+ *
+ * The state management of this class is a bit non-standard. We want to cache
+ * data related to toolkit stacks and SSM parameters, but we are not in charge
+ * of ensuring caching of SDKs. Since `EnvironmentResources` needs an SDK to
+ * function, we treat it as an ephemeral class, and store the actual cached data
+ * in `EnvironmentResourcesRegistry`.
+ */
+export declare class EnvironmentResources {
+    readonly environment: Environment;
+    private readonly sdk;
+    private readonly ioHelper;
+    private readonly cache;
+    private readonly toolkitStackName?;
+    constructor(environment: Environment, sdk: SDK, ioHelper: IoHelper, cache: EnvironmentCache, toolkitStackName?: string | undefined);
+    /**
+     * Look up the toolkit for a given environment, using a given SDK
+     */
+    lookupToolkit(): Promise<ToolkitInfo>;
+    /**
+     * Validate that the bootstrap stack version matches or exceeds the expected version
+     *
+     * Use the SSM parameter name to read the version number if given, otherwise use the version
+     * discovered on the bootstrap stack.
+     *
+     * Pass in the SSM parameter name so we can cache the lookups an don't need to do the same
+     * lookup again and again for every artifact.
+     */
+    validateVersion(expectedVersion: number | undefined, ssmParameterName: string | undefined): Promise<void>;
+    /**
+     * Read a version from an SSM parameter, cached
+     */
+    versionFromSsmParameter(parameterName: string): Promise<number>;
+    prepareEcrRepository(repositoryName: string): Promise<EcrRepositoryInfo>;
+}
+export declare class NoBootstrapStackEnvironmentResources extends EnvironmentResources {
+    constructor(environment: Environment, sdk: SDK, ioHelper: IoHelper);
+    /**
+     * Look up the toolkit for a given environment, using a given SDK
+     */
+    lookupToolkit(): Promise<ToolkitInfo>;
+}
+/**
+ * Data that is cached on a per-environment level
+ *
+ * This cache may be shared between different instances of the `EnvironmentResources` class.
+ */
+interface EnvironmentCache {
+    readonly ssmParameters: Map<string, number>;
+    toolkitInfo?: ToolkitInfo;
+}
+export {};

package/lib/api/environment/environment-resources.js

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoBootstrapStackEnvironmentResources = exports.EnvironmentResources = exports.EnvironmentResourcesRegistry = void 0;
+const util_1 = require("../../util");
+const private_1 = require("../io/private");
+const notices_1 = require("../notices");
+const toolkit_error_1 = require("../toolkit-error");
+const toolkit_info_1 = require("../toolkit-info");
+/**
+ * Registry class for `EnvironmentResources`.
+ *
+ * The state management of this class is a bit non-standard. We want to cache
+ * data related to toolkit stacks and SSM parameters, but we are not in charge
+ * of ensuring caching of SDKs. Since `EnvironmentResources` needs an SDK to
+ * function, we treat it as an ephemeral class, and store the actual cached data
+ * in `EnvironmentResourcesRegistry`.
+ */
+class EnvironmentResourcesRegistry {
+    toolkitStackName;
+    cache = new Map();
+    constructor(toolkitStackName) {
+        this.toolkitStackName = toolkitStackName;
+    }
+    for(resolvedEnvironment, sdk, ioHelper) {
+        const key = `${resolvedEnvironment.account}:${resolvedEnvironment.region}`;
+        let envCache = this.cache.get(key);
+        if (!envCache) {
+            envCache = emptyCache();
+            this.cache.set(key, envCache);
+        }
+        return new EnvironmentResources(resolvedEnvironment, sdk, ioHelper, envCache, this.toolkitStackName);
+    }
+}
+exports.EnvironmentResourcesRegistry = EnvironmentResourcesRegistry;
+/**
+ * Interface with the account and region we're deploying into
+ *
+ * Manages lookups for bootstrapped resources, falling back to the legacy "CDK Toolkit"
+ * original bootstrap stack if necessary.
+ *
+ * The state management of this class is a bit non-standard. We want to cache
+ * data related to toolkit stacks and SSM parameters, but we are not in charge
+ * of ensuring caching of SDKs. Since `EnvironmentResources` needs an SDK to
+ * function, we treat it as an ephemeral class, and store the actual cached data
+ * in `EnvironmentResourcesRegistry`.
+ */
+class EnvironmentResources {
+    environment;
+    sdk;
+    ioHelper;
+    cache;
+    toolkitStackName;
+    constructor(environment, sdk, ioHelper, cache, toolkitStackName) {
+        this.environment = environment;
+        this.sdk = sdk;
+        this.ioHelper = ioHelper;
+        this.cache = cache;
+        this.toolkitStackName = toolkitStackName;
+    }
+    /**
+     * Look up the toolkit for a given environment, using a given SDK
+     */
+    async lookupToolkit() {
+        if (!this.cache.toolkitInfo) {
+            this.cache.toolkitInfo = await toolkit_info_1.ToolkitInfo.lookup(this.environment, this.sdk, this.ioHelper, this.toolkitStackName);
+        }
+        return this.cache.toolkitInfo;
+    }
+    /**
+     * Validate that the bootstrap stack version matches or exceeds the expected version
+     *
+     * Use the SSM parameter name to read the version number if given, otherwise use the version
+     * discovered on the bootstrap stack.
+     *
+     * Pass in the SSM parameter name so we can cache the lookups an don't need to do the same
+     * lookup again and again for every artifact.
+     */
+    async validateVersion(expectedVersion, ssmParameterName) {
+        if (expectedVersion === undefined) {
+            // No requirement
+            return;
+        }
+        const defExpectedVersion = expectedVersion;
+        if (ssmParameterName !== undefined) {
+            try {
+                doValidate(await this.versionFromSsmParameter(ssmParameterName), this.environment);
+                return;
+            }
+            catch (e) {
+                if (e.name !== 'AccessDeniedException') {
+                    throw e;
+                }
+                // This is a fallback! The bootstrap template that goes along with this change introduces
+                // a new 'ssm:GetParameter' permission, but when run using the previous bootstrap template we
+                // won't have the permissions yet to read the version, so we won't be able to show the
+                // message telling the user they need to update! When we see an AccessDeniedException, fall
+                // back to the version we read from Stack Outputs; but ONLY if the version we discovered via
+                // outputs is legitimately an old version. If it's newer than that, something else must be broken,
+                // so let it fail as it would if we didn't have this fallback.
+                const bootstrapStack = await this.lookupToolkit();
+                if (bootstrapStack.found && bootstrapStack.version < BOOTSTRAP_TEMPLATE_VERSION_INTRODUCING_GETPARAMETER) {
+                    await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_WARN.msg(`Could not read SSM parameter ${ssmParameterName}: ${(0, util_1.formatErrorMessage)(e)}, falling back to version from ${bootstrapStack}`));
+                    doValidate(bootstrapStack.version, this.environment);
+                    return;
+                }
+                throw new toolkit_error_1.ToolkitError(`This CDK deployment requires bootstrap stack version '${expectedVersion}', but during the confirmation via SSM parameter ${ssmParameterName} the following error occurred: ${e}`);
+            }
+        }
+        // No SSM parameter
+        const bootstrapStack = await this.lookupToolkit();
+        doValidate(bootstrapStack.version, this.environment);
+        function doValidate(version, environment) {
+            const notices = notices_1.Notices.get();
+            if (notices) {
+                // if `Notices` hasn't been initialized there is probably a good
+                // reason for it. handle gracefully.
+                notices.addBootstrappedEnvironment({ bootstrapStackVersion: version, environment });
+            }
+            if (defExpectedVersion > version) {
+                throw new toolkit_error_1.ToolkitError(`This CDK deployment requires bootstrap stack version '${expectedVersion}', found '${version}'. Please run 'cdk bootstrap'.`);
+            }
+        }
+    }
+    /**
+     * Read a version from an SSM parameter, cached
+     */
+    async versionFromSsmParameter(parameterName) {
+        const existing = this.cache.ssmParameters.get(parameterName);
+        if (existing !== undefined) {
+            return existing;
+        }
+        const ssm = this.sdk.ssm();
+        try {
+            const result = await ssm.getParameter({ Name: parameterName });
+            const asNumber = parseInt(`${result.Parameter?.Value}`, 10);
+            if (isNaN(asNumber)) {
+                throw new toolkit_error_1.ToolkitError(`SSM parameter ${parameterName} not a number: ${result.Parameter?.Value}`);
+            }
+            this.cache.ssmParameters.set(parameterName, asNumber);
+            return asNumber;
+        }
+        catch (e) {
+            if (e.name === 'ParameterNotFound') {
+                throw new toolkit_error_1.ToolkitError(`SSM parameter ${parameterName} not found. Has the environment been bootstrapped? Please run \'cdk bootstrap\' (see https://docs.aws.amazon.com/cdk/latest/guide/bootstrapping.html)`);
+            }
+            throw e;
+        }
+    }
+    async prepareEcrRepository(repositoryName) {
+        if (!this.sdk) {
+            throw new toolkit_error_1.ToolkitError('ToolkitInfo needs to have been initialized with an sdk to call prepareEcrRepository');
+        }
+        const ecr = this.sdk.ecr();
+        // check if repo already exists
+        try {
+            await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg(`${repositoryName}: checking if ECR repository already exists`));
+            const describeResponse = await ecr.describeRepositories({
+                repositoryNames: [repositoryName],
+            });
+            const existingRepositoryUri = describeResponse.repositories[0]?.repositoryUri;
+            if (existingRepositoryUri) {
+                return { repositoryUri: existingRepositoryUri };
+            }
+        }
+        catch (e) {
+            if (e.name !== 'RepositoryNotFoundException') {
+                throw e;
+            }
+        }
+        // create the repo (tag it so it will be easier to garbage collect in the future)
+        await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg(`${repositoryName}: creating ECR repository`));
+        const assetTag = { Key: 'awscdk:asset', Value: 'true' };
+        const response = await ecr.createRepository({
+            repositoryName,
+            tags: [assetTag],
+        });
+        const repositoryUri = response.repository?.repositoryUri;
+        if (!repositoryUri) {
+            throw new toolkit_error_1.ToolkitError(`CreateRepository did not return a repository URI for ${repositoryUri}`);
+        }
+        // configure image scanning on push (helps in identifying software vulnerabilities, no additional charge)
+        await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg(`${repositoryName}: enable image scanning`));
+        await ecr.putImageScanningConfiguration({
+            repositoryName,
+            imageScanningConfiguration: { scanOnPush: true },
+        });
+        return { repositoryUri };
+    }
+}
+exports.EnvironmentResources = EnvironmentResources;
+class NoBootstrapStackEnvironmentResources extends EnvironmentResources {
+    constructor(environment, sdk, ioHelper) {
+        super(environment, sdk, ioHelper, emptyCache());
+    }
+    /**
+     * Look up the toolkit for a given environment, using a given SDK
+     */
+    async lookupToolkit() {
+        throw new toolkit_error_1.ToolkitError('Trying to perform an operation that requires a bootstrap stack; you should not see this error, this is a bug in the CDK CLI.');
+    }
+}
+exports.NoBootstrapStackEnvironmentResources = NoBootstrapStackEnvironmentResources;
+function emptyCache() {
+    return {
+        ssmParameters: new Map(),
+        toolkitInfo: undefined,
+    };
+}
+/**
+ * The bootstrap template version that introduced ssm:GetParameter
+ */
+const BOOTSTRAP_TEMPLATE_VERSION_INTRODUCING_GETPARAMETER = 5;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"environment-resources.js","sourceRoot":"","sources":["environment-resources.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Environment } from '@aws-cdk/cx-api';\nimport { formatErrorMessage } from '../../util';\nimport type { SDK } from '../aws-auth/private';\nimport { IO, type IoHelper } from '../io/private';\nimport { Notices } from '../notices';\nimport { ToolkitError } from '../toolkit-error';\nimport { type EcrRepositoryInfo, ToolkitInfo } from '../toolkit-info';\n\n/**\n * Registry class for `EnvironmentResources`.\n *\n * The state management of this class is a bit non-standard. We want to cache\n * data related to toolkit stacks and SSM parameters, but we are not in charge\n * of ensuring caching of SDKs. Since `EnvironmentResources` needs an SDK to\n * function, we treat it as an ephemeral class, and store the actual cached data\n * in `EnvironmentResourcesRegistry`.\n */\nexport class EnvironmentResourcesRegistry {\n  private readonly cache = new Map<string, EnvironmentCache>();\n\n  constructor(private readonly toolkitStackName?: string) {\n  }\n\n  public for(resolvedEnvironment: Environment, sdk: SDK, ioHelper: IoHelper) {\n    const key = `${resolvedEnvironment.account}:${resolvedEnvironment.region}`;\n    let envCache = this.cache.get(key);\n    if (!envCache) {\n      envCache = emptyCache();\n      this.cache.set(key, envCache);\n    }\n    return new EnvironmentResources(resolvedEnvironment, sdk, ioHelper, envCache, this.toolkitStackName);\n  }\n}\n\n/**\n * Interface with the account and region we're deploying into\n *\n * Manages lookups for bootstrapped resources, falling back to the legacy \"CDK Toolkit\"\n * original bootstrap stack if necessary.\n *\n * The state management of this class is a bit non-standard. We want to cache\n * data related to toolkit stacks and SSM parameters, but we are not in charge\n * of ensuring caching of SDKs. Since `EnvironmentResources` needs an SDK to\n * function, we treat it as an ephemeral class, and store the actual cached data\n * in `EnvironmentResourcesRegistry`.\n */\nexport class EnvironmentResources {\n  constructor(\n    public readonly environment: Environment,\n    private readonly sdk: SDK,\n    private readonly ioHelper: IoHelper,\n    private readonly cache: EnvironmentCache,\n    private readonly toolkitStackName?: string,\n  ) {\n  }\n\n  /**\n   * Look up the toolkit for a given environment, using a given SDK\n   */\n  public async lookupToolkit() {\n    if (!this.cache.toolkitInfo) {\n      this.cache.toolkitInfo = await ToolkitInfo.lookup(this.environment, this.sdk, this.ioHelper, this.toolkitStackName);\n    }\n    return this.cache.toolkitInfo;\n  }\n\n  /**\n   * Validate that the bootstrap stack version matches or exceeds the expected version\n   *\n   * Use the SSM parameter name to read the version number if given, otherwise use the version\n   * discovered on the bootstrap stack.\n   *\n   * Pass in the SSM parameter name so we can cache the lookups an don't need to do the same\n   * lookup again and again for every artifact.\n   */\n  public async validateVersion(expectedVersion: number | undefined, ssmParameterName: string | undefined) {\n    if (expectedVersion === undefined) {\n      // No requirement\n      return;\n    }\n    const defExpectedVersion = expectedVersion;\n\n    if (ssmParameterName !== undefined) {\n      try {\n        doValidate(await this.versionFromSsmParameter(ssmParameterName), this.environment);\n        return;\n      } catch (e: any) {\n        if (e.name !== 'AccessDeniedException') {\n          throw e;\n        }\n\n        // This is a fallback! The bootstrap template that goes along with this change introduces\n        // a new 'ssm:GetParameter' permission, but when run using the previous bootstrap template we\n        // won't have the permissions yet to read the version, so we won't be able to show the\n        // message telling the user they need to update! When we see an AccessDeniedException, fall\n        // back to the version we read from Stack Outputs; but ONLY if the version we discovered via\n        // outputs is legitimately an old version. If it's newer than that, something else must be broken,\n        // so let it fail as it would if we didn't have this fallback.\n        const bootstrapStack = await this.lookupToolkit();\n        if (bootstrapStack.found && bootstrapStack.version < BOOTSTRAP_TEMPLATE_VERSION_INTRODUCING_GETPARAMETER) {\n          await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_WARN.msg(\n            `Could not read SSM parameter ${ssmParameterName}: ${formatErrorMessage(e)}, falling back to version from ${bootstrapStack}`,\n          ));\n          doValidate(bootstrapStack.version, this.environment);\n          return;\n        }\n\n        throw new ToolkitError(\n          `This CDK deployment requires bootstrap stack version '${expectedVersion}', but during the confirmation via SSM parameter ${ssmParameterName} the following error occurred: ${e}`,\n        );\n      }\n    }\n\n    // No SSM parameter\n    const bootstrapStack = await this.lookupToolkit();\n    doValidate(bootstrapStack.version, this.environment);\n\n    function doValidate(version: number, environment: Environment) {\n      const notices = Notices.get();\n      if (notices) {\n        // if `Notices` hasn't been initialized there is probably a good\n        // reason for it. handle gracefully.\n        notices.addBootstrappedEnvironment({ bootstrapStackVersion: version, environment });\n      }\n      if (defExpectedVersion > version) {\n        throw new ToolkitError(\n          `This CDK deployment requires bootstrap stack version '${expectedVersion}', found '${version}'. Please run 'cdk bootstrap'.`,\n        );\n      }\n    }\n  }\n\n  /**\n   * Read a version from an SSM parameter, cached\n   */\n  public async versionFromSsmParameter(parameterName: string): Promise<number> {\n    const existing = this.cache.ssmParameters.get(parameterName);\n    if (existing !== undefined) {\n      return existing;\n    }\n\n    const ssm = this.sdk.ssm();\n\n    try {\n      const result = await ssm.getParameter({ Name: parameterName });\n\n      const asNumber = parseInt(`${result.Parameter?.Value}`, 10);\n      if (isNaN(asNumber)) {\n        throw new ToolkitError(`SSM parameter ${parameterName} not a number: ${result.Parameter?.Value}`);\n      }\n\n      this.cache.ssmParameters.set(parameterName, asNumber);\n      return asNumber;\n    } catch (e: any) {\n      if (e.name === 'ParameterNotFound') {\n        throw new ToolkitError(\n          `SSM parameter ${parameterName} not found. Has the environment been bootstrapped? Please run \\'cdk bootstrap\\' (see https://docs.aws.amazon.com/cdk/latest/guide/bootstrapping.html)`,\n        );\n      }\n      throw e;\n    }\n  }\n\n  public async prepareEcrRepository(repositoryName: string): Promise<EcrRepositoryInfo> {\n    if (!this.sdk) {\n      throw new ToolkitError('ToolkitInfo needs to have been initialized with an sdk to call prepareEcrRepository');\n    }\n    const ecr = this.sdk.ecr();\n\n    // check if repo already exists\n    try {\n      await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`${repositoryName}: checking if ECR repository already exists`));\n      const describeResponse = await ecr.describeRepositories({\n        repositoryNames: [repositoryName],\n      });\n      const existingRepositoryUri = describeResponse.repositories![0]?.repositoryUri;\n      if (existingRepositoryUri) {\n        return { repositoryUri: existingRepositoryUri };\n      }\n    } catch (e: any) {\n      if (e.name !== 'RepositoryNotFoundException') {\n        throw e;\n      }\n    }\n\n    // create the repo (tag it so it will be easier to garbage collect in the future)\n    await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`${repositoryName}: creating ECR repository`));\n    const assetTag = { Key: 'awscdk:asset', Value: 'true' };\n    const response = await ecr.createRepository({\n      repositoryName,\n      tags: [assetTag],\n    });\n    const repositoryUri = response.repository?.repositoryUri;\n    if (!repositoryUri) {\n      throw new ToolkitError(`CreateRepository did not return a repository URI for ${repositoryUri}`);\n    }\n\n    // configure image scanning on push (helps in identifying software vulnerabilities, no additional charge)\n    await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`${repositoryName}: enable image scanning`));\n    await ecr.putImageScanningConfiguration({\n      repositoryName,\n      imageScanningConfiguration: { scanOnPush: true },\n    });\n\n    return { repositoryUri };\n  }\n}\n\nexport class NoBootstrapStackEnvironmentResources extends EnvironmentResources {\n  constructor(environment: Environment, sdk: SDK, ioHelper: IoHelper) {\n    super(environment, sdk, ioHelper, emptyCache());\n  }\n\n  /**\n   * Look up the toolkit for a given environment, using a given SDK\n   */\n  public async lookupToolkit(): Promise<ToolkitInfo> {\n    throw new ToolkitError(\n      'Trying to perform an operation that requires a bootstrap stack; you should not see this error, this is a bug in the CDK CLI.',\n    );\n  }\n}\n\n/**\n * Data that is cached on a per-environment level\n *\n * This cache may be shared between different instances of the `EnvironmentResources` class.\n */\ninterface EnvironmentCache {\n  readonly ssmParameters: Map<string, number>;\n  toolkitInfo?: ToolkitInfo;\n}\n\nfunction emptyCache(): EnvironmentCache {\n  return {\n    ssmParameters: new Map(),\n    toolkitInfo: undefined,\n  };\n}\n\n/**\n * The bootstrap template version that introduced ssm:GetParameter\n */\nconst BOOTSTRAP_TEMPLATE_VERSION_INTRODUCING_GETPARAMETER = 5;\n"]}

package/lib/api/environment/index.d.ts

@@ -0,0 +1,3 @@
+export * from './environment-access';
+export * from './environment-resources';
+export * from './placeholders';

package/lib/api/environment/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./environment-access"), exports);
+__exportStar(require("./environment-resources"), exports);
+__exportStar(require("./placeholders"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsdURBQXFDO0FBQ3JDLDBEQUF3QztBQUN4QyxpREFBK0IiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2Vudmlyb25tZW50LWFjY2Vzcyc7XG5leHBvcnQgKiBmcm9tICcuL2Vudmlyb25tZW50LXJlc291cmNlcyc7XG5leHBvcnQgKiBmcm9tICcuL3BsYWNlaG9sZGVycyc7XG4iXX0=

package/lib/api/environment/placeholders.d.ts

@@ -0,0 +1,10 @@
+import { type Environment } from '@aws-cdk/cx-api';
+import type { Branded } from '../../util';
+import type { SdkProvider } from '../aws-auth/private';
+/**
+ * Replace the {ACCOUNT} and {REGION} placeholders in all strings found in a complex object.
+ */
+export declare function replaceEnvPlaceholders<A extends Record<string, string | undefined>>(object: A, env: Environment, sdkProvider: SdkProvider): Promise<{
+    [k in keyof A]: StringWithoutPlaceholders | undefined;
+}>;
+export type StringWithoutPlaceholders = Branded<string, 'NoPlaceholders'>;

package/lib/api/environment/placeholders.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replaceEnvPlaceholders = replaceEnvPlaceholders;
+const cx_api_1 = require("@aws-cdk/cx-api");
+const plugin_1 = require("../plugin");
+/**
+ * Replace the {ACCOUNT} and {REGION} placeholders in all strings found in a complex object.
+ */
+async function replaceEnvPlaceholders(object, env, sdkProvider) {
+    return cx_api_1.EnvironmentPlaceholders.replaceAsync(object, {
+        accountId: () => Promise.resolve(env.account),
+        region: () => Promise.resolve(env.region),
+        partition: async () => {
+            // There's no good way to get the partition!
+            // We should have had it already, except we don't.
+            //
+            // Best we can do is ask the "base credentials" for this environment for their partition. Cross-partition
+            // AssumeRole'ing will never work anyway, so this answer won't be wrong (it will just be slow!)
+            return (await sdkProvider.baseCredentialsPartition(env, plugin_1.Mode.ForReading)) ?? 'aws';
+        },
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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