aws-cdk 2.5.0 → 2.9.0

package/lib/api/logs/find-cloudwatch-logs.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findCloudWatchLogGroups = void 0;
+const aws_auth_1 = require("../aws-auth");
+const cloudformation_deployments_1 = require("../cloudformation-deployments");
+const evaluate_cloudformation_template_1 = require("../evaluate-cloudformation-template");
+// resource types that have associated CloudWatch Log Groups that should _not_ be monitored
+const IGNORE_LOGS_RESOURCE_TYPES = ['AWS::EC2::FlowLog', 'AWS::CloudTrail::Trail', 'AWS::CodeBuild::Project'];
+// Resource types that will create a CloudWatch log group with a specific name if one is not provided.
+// The keys are CFN resource types, and the values are the name of the physical name property of that resource
+// and the service name that is used in the automatically created CloudWatch log group.
+const RESOURCE_TYPES_WITH_IMPLICIT_LOGS = {
+    'AWS::Lambda::Function': {
+        PhysicalNamePropertyName: 'FunctionName',
+        LogGroupServiceName: 'lambda',
+    },
+};
+async function findCloudWatchLogGroups(sdkProvider, stackArtifact) {
+    let sdk;
+    const resolvedEnv = await sdkProvider.resolveEnvironment(stackArtifact.environment);
+    // try to assume the lookup role and fallback to the default credentials
+    try {
+        sdk = (await cloudformation_deployments_1.prepareSdkWithLookupRoleFor(sdkProvider, stackArtifact)).sdk;
+    }
+    catch (e) {
+        sdk = (await sdkProvider.forEnvironment(resolvedEnv, aws_auth_1.Mode.ForReading)).sdk;
+    }
+    const listStackResources = new evaluate_cloudformation_template_1.LazyListStackResources(sdk, stackArtifact.stackName);
+    const evaluateCfnTemplate = new evaluate_cloudformation_template_1.EvaluateCloudFormationTemplate({
+        stackArtifact,
+        parameters: {},
+        account: resolvedEnv.account,
+        region: resolvedEnv.region,
+        partition: (await sdk.currentAccount()).partition,
+        urlSuffix: (region) => sdk.getEndpointSuffix(region),
+        listStackResources,
+    });
+    const stackResources = await listStackResources.listStackResources();
+    const logGroupNames = findAllLogGroupNames(stackResources, evaluateCfnTemplate);
+    return {
+        env: resolvedEnv,
+        sdk,
+        logGroupNames,
+    };
+}
+exports.findCloudWatchLogGroups = findCloudWatchLogGroups;
+/**
+ * Determine if a CloudWatch Log Group is associated
+ * with an ignored resource
+ */
+function isReferencedFromIgnoredResource(logGroupResource, evaluateCfnTemplate) {
+    let foundReference = false;
+    const resourcesReferencingLogGroup = evaluateCfnTemplate.findReferencesTo(logGroupResource.LogicalResourceId);
+    for (const reference of resourcesReferencingLogGroup) {
+        if (IGNORE_LOGS_RESOURCE_TYPES.includes(reference.Type)) {
+            foundReference = true;
+        }
+    }
+    return foundReference;
+}
+/**
+ * Find all CloudWatch Log Groups in the deployed template.
+ * This will find both explicitely created Log Groups (excluding those associated with ignored resources)
+ * as well as Log Groups created implicitely (i.e. Lambda Functions)
+ */
+function findAllLogGroupNames(stackResources, evaluateCfnTemplate) {
+    return stackResources.reduce((logGroupNames, resource) => {
+        let logGroupName;
+        if (resource.ResourceType === 'AWS::Logs::LogGroup') {
+            if (!isReferencedFromIgnoredResource(resource, evaluateCfnTemplate)) {
+                logGroupName = resource.PhysicalResourceId;
+            }
+        }
+        else if (RESOURCE_TYPES_WITH_IMPLICIT_LOGS[resource.ResourceType]) {
+            const servicePart = RESOURCE_TYPES_WITH_IMPLICIT_LOGS[resource.ResourceType].LogGroupServiceName;
+            logGroupName = `/aws/${servicePart}/${resource.PhysicalResourceId}`;
+        }
+        if (logGroupName) {
+            logGroupNames.push(logGroupName);
+        }
+        return logGroupNames;
+    }, []);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"find-cloudwatch-logs.js","sourceRoot":"","sources":["find-cloudwatch-logs.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cxapi from '@aws-cdk/cx-api';\nimport { CloudFormation } from 'aws-sdk';\nimport { Mode, SdkProvider, ISDK } from '../aws-auth';\nimport { prepareSdkWithLookupRoleFor } from '../cloudformation-deployments';\nimport { EvaluateCloudFormationTemplate, LazyListStackResources } from '../evaluate-cloudformation-template';\n\n// resource types that have associated CloudWatch Log Groups that should _not_ be monitored\nconst IGNORE_LOGS_RESOURCE_TYPES = ['AWS::EC2::FlowLog', 'AWS::CloudTrail::Trail', 'AWS::CodeBuild::Project'];\n\n// Resource types that will create a CloudWatch log group with a specific name if one is not provided.\n// The keys are CFN resource types, and the values are the name of the physical name property of that resource\n// and the service name that is used in the automatically created CloudWatch log group.\nconst RESOURCE_TYPES_WITH_IMPLICIT_LOGS: { [cfnResourceType: string]: { [key: string]: string } } = {\n  'AWS::Lambda::Function': {\n    PhysicalNamePropertyName: 'FunctionName',\n    LogGroupServiceName: 'lambda',\n  },\n};\n\n/**\n * Configuration needed to monitor CloudWatch Log Groups\n * found in a given CloudFormation Stack\n */\nexport interface FoundLogGroupsResult {\n  /**\n   * The resolved environment (account/region) that the log\n   * groups are deployed in\n   */\n  readonly env: cxapi.Environment;\n\n  /**\n   * The SDK that can be used to read events from the CloudWatch\n   * Log Groups in the given environment\n   */\n  readonly sdk: ISDK;\n\n  /**\n   * The names of the relevant CloudWatch Log Groups\n   * in the given CloudFormation template\n   */\n  readonly logGroupNames: string[]\n}\n\nexport async function findCloudWatchLogGroups(\n  sdkProvider: SdkProvider,\n  stackArtifact: cxapi.CloudFormationStackArtifact,\n): Promise<FoundLogGroupsResult> {\n  let sdk: ISDK;\n  const resolvedEnv = await sdkProvider.resolveEnvironment(stackArtifact.environment);\n  // try to assume the lookup role and fallback to the default credentials\n  try {\n    sdk = (await prepareSdkWithLookupRoleFor(sdkProvider, stackArtifact)).sdk;\n  } catch (e) {\n    sdk = (await sdkProvider.forEnvironment(resolvedEnv, Mode.ForReading)).sdk;\n  }\n\n  const listStackResources = new LazyListStackResources(sdk, stackArtifact.stackName);\n  const evaluateCfnTemplate = new EvaluateCloudFormationTemplate({\n    stackArtifact,\n    parameters: {},\n    account: resolvedEnv.account,\n    region: resolvedEnv.region,\n    partition: (await sdk.currentAccount()).partition,\n    urlSuffix: (region) => sdk.getEndpointSuffix(region),\n    listStackResources,\n  });\n\n  const stackResources = await listStackResources.listStackResources();\n  const logGroupNames = findAllLogGroupNames(stackResources, evaluateCfnTemplate);\n\n  return {\n    env: resolvedEnv,\n    sdk,\n    logGroupNames,\n  };\n}\n\n/**\n * Determine if a CloudWatch Log Group is associated\n * with an ignored resource\n */\nfunction isReferencedFromIgnoredResource(\n  logGroupResource: CloudFormation.StackResourceSummary,\n  evaluateCfnTemplate: EvaluateCloudFormationTemplate,\n): boolean {\n  let foundReference = false;\n  const resourcesReferencingLogGroup = evaluateCfnTemplate.findReferencesTo(logGroupResource.LogicalResourceId);\n  for (const reference of resourcesReferencingLogGroup) {\n    if (IGNORE_LOGS_RESOURCE_TYPES.includes(reference.Type)) {\n      foundReference = true;\n    }\n  }\n  return foundReference;\n}\n\n/**\n * Find all CloudWatch Log Groups in the deployed template.\n * This will find both explicitely created Log Groups (excluding those associated with ignored resources)\n * as well as Log Groups created implicitely (i.e. Lambda Functions)\n */\nfunction findAllLogGroupNames(\n  stackResources: CloudFormation.StackResourceSummary[],\n  evaluateCfnTemplate: EvaluateCloudFormationTemplate,\n): string[] {\n  return stackResources.reduce((logGroupNames: string[], resource) => {\n    let logGroupName;\n    if (resource.ResourceType === 'AWS::Logs::LogGroup') {\n      if (!isReferencedFromIgnoredResource(resource, evaluateCfnTemplate)) {\n        logGroupName = resource.PhysicalResourceId;\n      }\n    } else if (RESOURCE_TYPES_WITH_IMPLICIT_LOGS[resource.ResourceType]) {\n      const servicePart = RESOURCE_TYPES_WITH_IMPLICIT_LOGS[resource.ResourceType].LogGroupServiceName;\n      logGroupName = `/aws/${servicePart}/${resource.PhysicalResourceId}`;\n    }\n    if (logGroupName) {\n      logGroupNames.push(logGroupName);\n    }\n    return logGroupNames;\n  }, []);\n}\n"]}

package/lib/api/logs/logs-monitor.d.ts

@@ -0,0 +1,53 @@
+import * as cxapi from '@aws-cdk/cx-api';
+import { ISDK } from '../aws-auth';
+export declare class CloudWatchLogEventMonitor {
+    /**
+     * Determines which events not to display
+     */
+    private startTime;
+    /**
+     * Map of environment (account:region) to LogGroupsAccessSettings
+     */
+    private readonly envsLogGroupsAccessSettings;
+    private active;
+    constructor(startTime?: Date);
+    /**
+     * resume reading/printing events
+     */
+    activate(): void;
+    /**
+     * deactivates the monitor so no new events are read
+     * use case for this is when we are in the middle of performing a deployment
+     * and don't want to interweave all the logs together with the CFN
+     * deployment logs
+     *
+     * Also resets the start time to be when the new deployment was triggered
+     * and clears the list of tracked log groups
+     */
+    deactivate(): void;
+    /**
+     * Adds CloudWatch log groups to read log events from.
+     * Since we could be watching multiple stacks that deploy to
+     * multiple environments (account+region), we need to store a list of log groups
+     * per env along with the SDK object that has access to read from
+     * that environment.
+     */
+    addLogGroups(env: cxapi.Environment, sdk: ISDK, logGroupNames: string[]): void;
+    private scheduleNextTick;
+    private tick;
+    /**
+     * Reads all new log events from a set of CloudWatch Log Groups
+     * in parallel
+     */
+    private readNewEvents;
+    /**
+     * Print out a cloudwatch event
+     */
+    private print;
+    /**
+     * Reads all new log events from a CloudWatch Log Group
+     * starting at either the time the hotswap was triggered or
+     * when the last event was read on the previous tick
+     */
+    private readEventsFromLogGroup;
+}

package/lib/api/logs/logs-monitor.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloudWatchLogEventMonitor = void 0;
+const util = require("util");
+const chalk = require("chalk");
+const logging_1 = require("../../logging");
+const arrays_1 = require("../../util/arrays");
+/**
+ * After reading events from all CloudWatch log groups
+ * how long should we wait to read more events.
+ *
+ * If there is some error with reading events (i.e. Throttle)
+ * then this is also how long we wait until we try again
+ */
+const SLEEP = 2000;
+class CloudWatchLogEventMonitor {
+    constructor(startTime) {
+        var _a;
+        /**
+         * Map of environment (account:region) to LogGroupsAccessSettings
+         */
+        this.envsLogGroupsAccessSettings = new Map();
+        this.active = false;
+        this.startTime = (_a = startTime === null || startTime === void 0 ? void 0 : startTime.getTime()) !== null && _a !== void 0 ? _a : Date.now();
+    }
+    /**
+     * resume reading/printing events
+     */
+    activate() {
+        this.active = true;
+        this.scheduleNextTick(0);
+    }
+    /**
+     * deactivates the monitor so no new events are read
+     * use case for this is when we are in the middle of performing a deployment
+     * and don't want to interweave all the logs together with the CFN
+     * deployment logs
+     *
+     * Also resets the start time to be when the new deployment was triggered
+     * and clears the list of tracked log groups
+     */
+    deactivate() {
+        this.active = false;
+        this.startTime = Date.now();
+        this.envsLogGroupsAccessSettings.clear();
+    }
+    /**
+     * Adds CloudWatch log groups to read log events from.
+     * Since we could be watching multiple stacks that deploy to
+     * multiple environments (account+region), we need to store a list of log groups
+     * per env along with the SDK object that has access to read from
+     * that environment.
+     */
+    addLogGroups(env, sdk, logGroupNames) {
+        var _a;
+        const awsEnv = `${env.account}:${env.region}`;
+        const logGroupsStartTimes = logGroupNames.reduce((acc, groupName) => {
+            acc[groupName] = this.startTime;
+            return acc;
+        }, {});
+        this.envsLogGroupsAccessSettings.set(awsEnv, {
+            sdk,
+            logGroupsStartTimes: {
+                ...(_a = this.envsLogGroupsAccessSettings.get(awsEnv)) === null || _a === void 0 ? void 0 : _a.logGroupsStartTimes,
+                ...logGroupsStartTimes,
+            },
+        });
+    }
+    scheduleNextTick(sleep) {
+        setTimeout(() => void (this.tick()), sleep);
+    }
+    async tick() {
+        if (!this.active) {
+            return;
+        }
+        try {
+            const events = arrays_1.flatten(await this.readNewEvents());
+            events.forEach(event => {
+                this.print(event);
+            });
+        }
+        catch (e) {
+            logging_1.error('Error occurred while monitoring logs: %s', e);
+        }
+        this.scheduleNextTick(SLEEP);
+    }
+    /**
+     * Reads all new log events from a set of CloudWatch Log Groups
+     * in parallel
+     */
+    async readNewEvents() {
+        const promises = [];
+        for (const settings of this.envsLogGroupsAccessSettings.values()) {
+            for (const group of Object.keys(settings.logGroupsStartTimes)) {
+                promises.push(this.readEventsFromLogGroup(settings, group));
+            }
+        }
+        return Promise.all(promises);
+    }
+    /**
+     * Print out a cloudwatch event
+     */
+    print(event) {
+        logging_1.print(util.format('[%s] %s %s', chalk.blue(event.logGroupName), chalk.yellow(event.timestamp.toLocaleTimeString()), event.message.trim()));
+    }
+    /**
+     * Reads all new log events from a CloudWatch Log Group
+     * starting at either the time the hotswap was triggered or
+     * when the last event was read on the previous tick
+     */
+    async readEventsFromLogGroup(logGroupsAccessSettings, logGroupName) {
+        var _a, _b;
+        const events = [];
+        // log events from some service are ingested faster than others
+        // so we need to track the start/end time for each log group individually
+        // to make sure that we process all events from each log group
+        const startTime = (_a = logGroupsAccessSettings.logGroupsStartTimes[logGroupName]) !== null && _a !== void 0 ? _a : this.startTime;
+        let endTime = startTime;
+        try {
+            const response = await logGroupsAccessSettings.sdk.cloudWatchLogs().filterLogEvents({
+                logGroupName: logGroupName,
+                limit: 100,
+                startTime: startTime,
+            }).promise();
+            const filteredEvents = (_b = response.events) !== null && _b !== void 0 ? _b : [];
+            for (const event of filteredEvents) {
+                if (event.message) {
+                    events.push({
+                        message: event.message,
+                        logGroupName,
+                        timestamp: event.timestamp ? new Date(event.timestamp) : new Date(),
+                    });
+                    if (event.timestamp && endTime < event.timestamp) {
+                        endTime = event.timestamp;
+                    }
+                }
+            }
+            // if we have > 100 events let the user know some
+            // messages have been supressed. We are essentially
+            // showing them a sampling (10000 events printed out is not very useful)
+            if (filteredEvents.length > 0 && response.nextToken) {
+                events.push({
+                    message: '>>> `watch` shows only the first 100 log messages - the rest have been truncated...',
+                    logGroupName,
+                    timestamp: new Date(endTime),
+                });
+            }
+        }
+        catch (e) {
+            // with Lambda functions the CloudWatch is not created
+            // until something is logged, so just keep polling until
+            // there is somthing to find
+            if (e.code === 'ResourceNotFoundException') {
+                return [];
+            }
+            throw e;
+        }
+        logGroupsAccessSettings.logGroupsStartTimes[logGroupName] = endTime + 1;
+        return events;
+    }
+}
+exports.CloudWatchLogEventMonitor = CloudWatchLogEventMonitor;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"logs-monitor.js","sourceRoot":"","sources":["logs-monitor.ts"],"names":[],"mappings":"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","sourcesContent":["import * as util from 'util';\nimport * as cxapi from '@aws-cdk/cx-api';\nimport * as chalk from 'chalk';\nimport { print, error } from '../../logging';\nimport { flatten } from '../../util/arrays';\nimport { ISDK } from '../aws-auth';\n\n/**\n * After reading events from all CloudWatch log groups\n * how long should we wait to read more events.\n *\n * If there is some error with reading events (i.e. Throttle)\n * then this is also how long we wait until we try again\n */\nconst SLEEP = 2_000;\n\n/**\n * Represents a CloudWatch Log Event that will be\n * printed to the terminal\n */\ninterface CloudWatchLogEvent {\n  /**\n   * The log event message\n   */\n  readonly message: string;\n\n  /**\n   * The name of the log group\n   */\n  readonly logGroupName: string;\n\n  /**\n   * The time at which the event occurred\n   */\n  readonly timestamp: Date;\n}\n\n/**\n * Configuration tracking information on the log groups that are\n * being monitored\n */\ninterface LogGroupsAccessSettings {\n  /**\n   * The SDK for a given environment (account/region)\n   */\n  readonly sdk: ISDK;\n\n  /**\n   * A map of log groups and associated startTime in a given account.\n   *\n   * The monitor will read events from the log group starting at the\n   * associated startTime\n   */\n  readonly logGroupsStartTimes: { [logGroupName: string]: number };\n}\n\nexport class CloudWatchLogEventMonitor {\n  /**\n   * Determines which events not to display\n   */\n  private startTime: number;\n\n  /**\n   * Map of environment (account:region) to LogGroupsAccessSettings\n   */\n  private readonly envsLogGroupsAccessSettings = new Map<string, LogGroupsAccessSettings>();\n\n  private active = false;\n\n  constructor(startTime?: Date) {\n    this.startTime = startTime?.getTime() ?? Date.now();\n  }\n\n  /**\n   * resume reading/printing events\n   */\n  public activate(): void {\n    this.active = true;\n    this.scheduleNextTick(0);\n  }\n\n  /**\n   * deactivates the monitor so no new events are read\n   * use case for this is when we are in the middle of performing a deployment\n   * and don't want to interweave all the logs together with the CFN\n   * deployment logs\n   *\n   * Also resets the start time to be when the new deployment was triggered\n   * and clears the list of tracked log groups\n   */\n  public deactivate(): void {\n    this.active = false;\n    this.startTime = Date.now();\n    this.envsLogGroupsAccessSettings.clear();\n  }\n\n  /**\n   * Adds CloudWatch log groups to read log events from.\n   * Since we could be watching multiple stacks that deploy to\n   * multiple environments (account+region), we need to store a list of log groups\n   * per env along with the SDK object that has access to read from\n   * that environment.\n   */\n  public addLogGroups(env: cxapi.Environment, sdk: ISDK, logGroupNames: string[]): void {\n    const awsEnv = `${env.account}:${env.region}`;\n    const logGroupsStartTimes = logGroupNames.reduce((acc, groupName) => {\n      acc[groupName] = this.startTime;\n      return acc;\n    }, {} as { [logGroupName: string]: number });\n    this.envsLogGroupsAccessSettings.set(awsEnv, {\n      sdk,\n      logGroupsStartTimes: {\n        ...this.envsLogGroupsAccessSettings.get(awsEnv)?.logGroupsStartTimes,\n        ...logGroupsStartTimes,\n      },\n    });\n  }\n\n  private scheduleNextTick(sleep: number): void {\n    setTimeout(() => void(this.tick()), sleep);\n  }\n\n  private async tick(): Promise<void> {\n    if (!this.active) {\n      return;\n    }\n    try {\n      const events = flatten(await this.readNewEvents());\n      events.forEach(event => {\n        this.print(event);\n      });\n    } catch (e) {\n      error('Error occurred while monitoring logs: %s', e);\n    }\n\n    this.scheduleNextTick(SLEEP);\n  }\n\n  /**\n   * Reads all new log events from a set of CloudWatch Log Groups\n   * in parallel\n   */\n  private async readNewEvents(): Promise<Array<Array<CloudWatchLogEvent>>> {\n    const promises: Array<Promise<Array<CloudWatchLogEvent>>> = [];\n    for (const settings of this.envsLogGroupsAccessSettings.values()) {\n      for (const group of Object.keys(settings.logGroupsStartTimes)) {\n        promises.push(this.readEventsFromLogGroup(settings, group));\n      }\n    }\n    return Promise.all(promises);\n  }\n\n  /**\n   * Print out a cloudwatch event\n   */\n  private print(event: CloudWatchLogEvent): void {\n    print(util.format('[%s] %s %s',\n      chalk.blue(event.logGroupName),\n      chalk.yellow(event.timestamp.toLocaleTimeString()),\n      event.message.trim()));\n  }\n\n  /**\n   * Reads all new log events from a CloudWatch Log Group\n   * starting at either the time the hotswap was triggered or\n   * when the last event was read on the previous tick\n   */\n  private async readEventsFromLogGroup(\n    logGroupsAccessSettings: LogGroupsAccessSettings,\n    logGroupName: string,\n  ): Promise<Array<CloudWatchLogEvent>> {\n    const events: CloudWatchLogEvent[] = [];\n\n    // log events from some service are ingested faster than others\n    // so we need to track the start/end time for each log group individually\n    // to make sure that we process all events from each log group\n    const startTime = logGroupsAccessSettings.logGroupsStartTimes[logGroupName] ?? this.startTime;\n    let endTime = startTime;\n    try {\n      const response = await logGroupsAccessSettings.sdk.cloudWatchLogs().filterLogEvents({\n        logGroupName: logGroupName,\n        limit: 100,\n        startTime: startTime,\n      }).promise();\n      const filteredEvents = response.events ?? [];\n\n      for (const event of filteredEvents) {\n        if (event.message) {\n          events.push({\n            message: event.message,\n            logGroupName,\n            timestamp: event.timestamp ? new Date(event.timestamp) : new Date(),\n          });\n\n          if (event.timestamp && endTime < event.timestamp) {\n            endTime = event.timestamp;\n          }\n\n        }\n      }\n      // if we have > 100 events let the user know some\n      // messages have been supressed. We are essentially\n      // showing them a sampling (10000 events printed out is not very useful)\n      if (filteredEvents.length > 0 && response.nextToken) {\n        events.push({\n          message: '>>> `watch` shows only the first 100 log messages - the rest have been truncated...',\n          logGroupName,\n          timestamp: new Date(endTime),\n        });\n      }\n    } catch (e) {\n      // with Lambda functions the CloudWatch is not created\n      // until something is logged, so just keep polling until\n      // there is somthing to find\n      if (e.code === 'ResourceNotFoundException') {\n        return [];\n      }\n      throw e;\n    }\n    logGroupsAccessSettings.logGroupsStartTimes[logGroupName] = endTime + 1;\n    return events;\n  }\n}\n"]}

package/lib/api/toolkit-info.d.ts

@@ -32,19 +32,19 @@ export declare abstract class ToolkitInfo {
     static fromStack(stack: CloudFormationStack, sdk: ISDK): ToolkitInfo;
     static bootstraplessDeploymentsOnly(sdk: ISDK): ToolkitInfo;
     static bootstrapStackNotFoundInfo(sdk: ISDK): ToolkitInfo;
+    /**
+     * Read a version from an SSM parameter, cached
+     */
+    static versionFromSsmParameter(sdk: ISDK, parameterName: string, ssmCache?: Map<string, number>): Promise<number>;
+    protected readonly ssmCache: Map<string, number>;
     abstract readonly found: boolean;
     abstract readonly bucketUrl: string;
     abstract readonly bucketName: string;
     abstract readonly version: number;
     abstract readonly bootstrapStack: CloudFormationStack;
-    private readonly ssmCache;
     constructor(sdk: ISDK);
     abstract validateVersion(expectedVersion: number, ssmParameterName: string | undefined): Promise<void>;
     abstract prepareEcrRepository(repositoryName: string): Promise<EcrRepositoryInfo>;
-    /**
-     * Read a version from an SSM parameter, cached
-     */
-    protected versionFromSsmParameter(parameterName: string): Promise<number>;
 }
 export interface EcrRepositoryInfo {
     repositoryUri: string;

package/lib/api/toolkit-info.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ToolkitInfo = exports.DEFAULT_TOOLKIT_STACK_NAME = void 0;
-const colors = require("colors/safe");
+const chalk = require("chalk");
 const logging_1 = require("../logging");
 const bootstrap_1 = require("./bootstrap");
 const cloudformation_1 = require("./util/cloudformation");
@@ -45,12 +45,12 @@ class ToolkitInfo {
         const cfn = sdk.cloudFormation();
         const stack = await cloudformation_1.stabilizeStack(cfn, stackName !== null && stackName !== void 0 ? stackName : exports.DEFAULT_TOOLKIT_STACK_NAME);
         if (!stack) {
-            logging_1.debug('The environment %s doesn\'t have the CDK toolkit stack (%s) installed. Use %s to setup your environment for use with the toolkit.', environment.name, stackName, colors.blue(`cdk bootstrap "${environment.name}"`));
+            logging_1.debug('The environment %s doesn\'t have the CDK toolkit stack (%s) installed. Use %s to setup your environment for use with the toolkit.', environment.name, stackName, chalk.blue(`cdk bootstrap "${environment.name}"`));
             return ToolkitInfo.bootstrapStackNotFoundInfo(sdk);
         }
         if (stack.stackStatus.isCreationFailure) {
             // Treat a "failed to create" bootstrap stack as an absent one.
-            logging_1.debug('The environment %s has a CDK toolkit stack (%s) that failed to create. Use %s to try provisioning it again.', environment.name, stackName, colors.blue(`cdk bootstrap "${environment.name}"`));
+            logging_1.debug('The environment %s has a CDK toolkit stack (%s) that failed to create. Use %s to try provisioning it again.', environment.name, stackName, chalk.blue(`cdk bootstrap "${environment.name}"`));
             return ToolkitInfo.bootstrapStackNotFoundInfo(sdk);
         }
         return new ExistingToolkitInfo(stack, sdk);
@@ -67,20 +67,20 @@ class ToolkitInfo {
     /**
      * Read a version from an SSM parameter, cached
      */
-    async versionFromSsmParameter(parameterName) {
+    static async versionFromSsmParameter(sdk, parameterName, ssmCache) {
         var _a, _b;
-        const existing = this.ssmCache.get(parameterName);
+        const existing = ssmCache === null || ssmCache === void 0 ? void 0 : ssmCache.get(parameterName);
         if (existing !== undefined) {
             return existing;
         }
-        const ssm = this.sdk.ssm();
+        const ssm = sdk.ssm();
         try {
             const result = await ssm.getParameter({ Name: parameterName }).promise();
             const asNumber = parseInt(`${(_a = result.Parameter) === null || _a === void 0 ? void 0 : _a.Value}`, 10);
             if (isNaN(asNumber)) {
                 throw new Error(`SSM parameter ${parameterName} not a number: ${(_b = result.Parameter) === null || _b === void 0 ? void 0 : _b.Value}`);
             }
-            this.ssmCache.set(parameterName, asNumber);
+            ssmCache === null || ssmCache === void 0 ? void 0 : ssmCache.set(parameterName, asNumber);
             return asNumber;
         }
         catch (e) {
@@ -132,7 +132,7 @@ class ExistingToolkitInfo extends ToolkitInfo {
         let version = this.version; // Default to the current version, but will be overwritten by a lookup if required.
         if (ssmParameterName !== undefined) {
             try {
-                version = await this.versionFromSsmParameter(ssmParameterName);
+                version = await ToolkitInfo.versionFromSsmParameter(this.sdk, ssmParameterName, this.ssmCache);
             }
             catch (e) {
                 if (e.code !== 'AccessDeniedException') {
@@ -234,7 +234,7 @@ class BootstrapStackNotFoundInfo extends ToolkitInfo {
         }
         let version;
         try {
-            version = await this.versionFromSsmParameter(ssmParameterName);
+            version = await ToolkitInfo.versionFromSsmParameter(this.sdk, ssmParameterName, this.ssmCache);
         }
         catch (e) {
             if (e.code !== 'AccessDeniedException') {
@@ -256,4 +256,4 @@ class BootstrapStackNotFoundInfo extends ToolkitInfo {
         throw new Error(this.errorMessage);
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"toolkit-info.js","sourceRoot":"","sources":["toolkit-info.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cxapi from '@aws-cdk/cx-api';\nimport * as colors from 'colors/safe';\nimport { debug, warning } from '../logging';\nimport { ISDK } from './aws-auth';\nimport { BOOTSTRAP_VERSION_OUTPUT, BUCKET_DOMAIN_NAME_OUTPUT, BUCKET_NAME_OUTPUT } from './bootstrap';\nimport { stabilizeStack, CloudFormationStack } from './util/cloudformation';\n\nexport const DEFAULT_TOOLKIT_STACK_NAME = 'CDKToolkit';\n\n/**\n * The bootstrap template version that introduced ssm:GetParameter\n */\nconst BOOTSTRAP_TEMPLATE_VERSION_INTRODUCING_GETPARAMETER = 5;\n\n/**\n * Information on the Bootstrap stack of the environment we're deploying to.\n *\n * This class serves to:\n *\n * - Inspect the bootstrap stack, and return various properties of it for successful\n *   asset deployment (in case of legacy-synthesized stacks).\n * - Validate the version of the target environment, and nothing else (in case of\n *   default-synthesized stacks).\n *\n * An object of this type might represent a bootstrap stack that could not be found.\n * This is not an issue unless any members are used that require the bootstrap stack\n * to have been found, in which case an error is thrown (default-synthesized stacks\n * should never run into this as they don't need information from the bootstrap\n * stack, all information is already encoded into the Cloud Assembly Manifest).\n *\n * Nevertheless, an instance of this class exists to serve as a cache for SSM\n * parameter lookups (otherwise, the \"bootstrap stack version\" parameter would\n * need to be read repeatedly).\n *\n * Called \"ToolkitInfo\" for historical reasons.\n *\n */\nexport abstract class ToolkitInfo {\n  public static determineName(overrideName?: string) {\n    return overrideName ?? DEFAULT_TOOLKIT_STACK_NAME;\n  }\n\n  public static async lookup(environment: cxapi.Environment, sdk: ISDK, stackName: string | undefined): Promise<ToolkitInfo> {\n    const cfn = sdk.cloudFormation();\n    const stack = await stabilizeStack(cfn, stackName ?? DEFAULT_TOOLKIT_STACK_NAME);\n    if (!stack) {\n      debug('The environment %s doesn\\'t have the CDK toolkit stack (%s) installed. Use %s to setup your environment for use with the toolkit.',\n        environment.name, stackName, colors.blue(`cdk bootstrap \"${environment.name}\"`));\n      return ToolkitInfo.bootstrapStackNotFoundInfo(sdk);\n    }\n    if (stack.stackStatus.isCreationFailure) {\n      // Treat a \"failed to create\" bootstrap stack as an absent one.\n      debug('The environment %s has a CDK toolkit stack (%s) that failed to create. Use %s to try provisioning it again.',\n        environment.name, stackName, colors.blue(`cdk bootstrap \"${environment.name}\"`));\n      return ToolkitInfo.bootstrapStackNotFoundInfo(sdk);\n    }\n\n    return new ExistingToolkitInfo(stack, sdk);\n  }\n\n  public static fromStack(stack: CloudFormationStack, sdk: ISDK): ToolkitInfo {\n    return new ExistingToolkitInfo(stack, sdk);\n  }\n\n  public static bootstraplessDeploymentsOnly(sdk: ISDK): ToolkitInfo {\n    return new BootstrapStackNotFoundInfo(sdk, '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  public static bootstrapStackNotFoundInfo(sdk: ISDK): ToolkitInfo {\n    return new BootstrapStackNotFoundInfo(sdk, 'This deployment requires a bootstrap stack with a known name; pass \\'--toolkit-stack-name\\' or switch to using the \\'DefaultStackSynthesizer\\' (see https://docs.aws.amazon.com/cdk/latest/guide/bootstrapping.html)');\n  }\n\n  public abstract readonly found: boolean;\n  public abstract readonly bucketUrl: string;\n  public abstract readonly bucketName: string;\n  public abstract readonly version: number;\n  public abstract readonly bootstrapStack: CloudFormationStack;\n\n  private readonly ssmCache = new Map<string, number>();\n\n  constructor(protected readonly sdk: ISDK) {\n  }\n  public abstract validateVersion(expectedVersion: number, ssmParameterName: string | undefined): Promise<void>;\n  public abstract prepareEcrRepository(repositoryName: string): Promise<EcrRepositoryInfo>;\n\n  /**\n   * Read a version from an SSM parameter, cached\n   */\n  protected async versionFromSsmParameter(parameterName: string): Promise<number> {\n    const existing = this.ssmCache.get(parameterName);\n    if (existing !== undefined) { return existing; }\n\n    const ssm = this.sdk.ssm();\n\n    try {\n      const result = await ssm.getParameter({ Name: parameterName }).promise();\n\n      const asNumber = parseInt(`${result.Parameter?.Value}`, 10);\n      if (isNaN(asNumber)) {\n        throw new Error(`SSM parameter ${parameterName} not a number: ${result.Parameter?.Value}`);\n      }\n\n      this.ssmCache.set(parameterName, asNumber);\n      return asNumber;\n    } catch (e) {\n      if (e.code === 'ParameterNotFound') {\n        throw new Error(`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      throw e;\n    }\n  }\n}\n\n/**\n * Returned when a bootstrap stack is found\n */\nclass ExistingToolkitInfo extends ToolkitInfo {\n  public readonly found = true;\n\n  constructor(public readonly bootstrapStack: CloudFormationStack, sdk: ISDK) {\n    super(sdk);\n  }\n\n  public get bucketUrl() {\n    return `https://${this.requireOutput(BUCKET_DOMAIN_NAME_OUTPUT)}`;\n  }\n\n  public get bucketName() {\n    return this.requireOutput(BUCKET_NAME_OUTPUT);\n  }\n\n  public get version() {\n    return parseInt(this.bootstrapStack.outputs[BOOTSTRAP_VERSION_OUTPUT] ?? '0', 10);\n  }\n\n  public get parameters(): Record<string, string> {\n    return this.bootstrapStack.parameters ?? {};\n  }\n\n  public get terminationProtection(): boolean {\n    return this.bootstrapStack.terminationProtection ?? false;\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, ssmParameterName: string | undefined) {\n    let version = this.version; // Default to the current version, but will be overwritten by a lookup if required.\n\n    if (ssmParameterName !== undefined) {\n      try {\n        version = await this.versionFromSsmParameter(ssmParameterName);\n      } catch (e) {\n        if (e.code !== 'AccessDeniedException') { throw e; }\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        if (this.version >= BOOTSTRAP_TEMPLATE_VERSION_INTRODUCING_GETPARAMETER) {\n          throw e;\n        }\n\n        warning(`Could not read SSM parameter ${ssmParameterName}: ${e.message}`);\n        // Fall through on purpose\n      }\n    }\n\n    if (expectedVersion > version) {\n      throw new Error(`This CDK deployment requires bootstrap stack version '${expectedVersion}', found '${version}'. Please run 'cdk bootstrap'.`);\n    }\n  }\n\n  /**\n   * Prepare an ECR repository for uploading to using Docker\n   *\n   */\n  public async prepareEcrRepository(repositoryName: string): Promise<EcrRepositoryInfo> {\n    if (!this.sdk) {\n      throw new Error('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      debug(`${repositoryName}: checking if ECR repository already exists`);\n      const describeResponse = await ecr.describeRepositories({ repositoryNames: [repositoryName] }).promise();\n      const existingRepositoryUri = describeResponse.repositories![0]?.repositoryUri;\n      if (existingRepositoryUri) {\n        return { repositoryUri: existingRepositoryUri };\n      }\n    } catch (e) {\n      if (e.code !== 'RepositoryNotFoundException') { throw e; }\n    }\n\n    // create the repo (tag it so it will be easier to garbage collect in the future)\n    debug(`${repositoryName}: creating ECR repository`);\n    const assetTag = { Key: 'awscdk:asset', Value: 'true' };\n    const response = await ecr.createRepository({ repositoryName, tags: [assetTag] }).promise();\n    const repositoryUri = response.repository?.repositoryUri;\n    if (!repositoryUri) {\n      throw new Error(`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    debug(`${repositoryName}: enable image scanning`);\n    await ecr.putImageScanningConfiguration({ repositoryName, imageScanningConfiguration: { scanOnPush: true } }).promise();\n\n    return { repositoryUri };\n  }\n\n  private requireOutput(output: string): string {\n    if (!(output in this.bootstrapStack.outputs)) {\n      throw new Error(`The CDK toolkit stack (${this.bootstrapStack.stackName}) does not have an output named ${output}. Use 'cdk bootstrap' to correct this.`);\n    }\n    return this.bootstrapStack.outputs[output];\n  }\n}\n\n/**\n * Returned when a bootstrap stack could not be found\n *\n * This is not an error in principle, UNTIL one of the members is called that requires\n * the bootstrap stack to have been found, in which case the lookup error is still thrown\n * belatedly.\n *\n * The errors below serve as a last stop-gap message--normally calling code should have\n * checked `toolkit.found` and produced an appropriate error message.\n */\nclass BootstrapStackNotFoundInfo extends ToolkitInfo {\n  public readonly found = false;\n\n  constructor(sdk: ISDK, private readonly errorMessage: string) {\n    super(sdk);\n  }\n\n  public get bootstrapStack(): CloudFormationStack {\n    throw new Error(this.errorMessage);\n  }\n\n  public get bucketUrl(): string {\n    throw new Error(this.errorMessage);\n  }\n\n  public get bucketName(): string {\n    throw new Error(this.errorMessage);\n  }\n\n  public get version(): number {\n    throw new Error(this.errorMessage);\n  }\n\n  public async validateVersion(expectedVersion: number, ssmParameterName: string | undefined): Promise<void> {\n    if (ssmParameterName === undefined) {\n      throw new Error(this.errorMessage);\n    }\n\n    let version: number;\n    try {\n      version = await this.versionFromSsmParameter(ssmParameterName);\n    } catch (e) {\n      if (e.code !== 'AccessDeniedException') { throw e; }\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 a 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.\n      warning(`Could not read SSM parameter ${ssmParameterName}: ${e.message}`);\n      throw new Error(`This CDK deployment requires bootstrap stack version '${expectedVersion}', found an older version. Please run 'cdk bootstrap'.`);\n    }\n\n    if (expectedVersion > version) {\n      throw new Error(`This CDK deployment requires bootstrap stack version '${expectedVersion}', found '${version}'. Please run 'cdk bootstrap'.`);\n    }\n  }\n\n  public prepareEcrRepository(): Promise<EcrRepositoryInfo> {\n    throw new Error(this.errorMessage);\n  }\n}\n\nexport interface EcrRepositoryInfo {\n  repositoryUri: string;\n}\n\nexport interface EcrCredentials {\n  username: string;\n  password: string;\n  endpoint: string;\n}"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"toolkit-info.js","sourceRoot":"","sources":["toolkit-info.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cxapi from '@aws-cdk/cx-api';\nimport * as chalk from 'chalk';\nimport { debug, warning } from '../logging';\nimport { ISDK } from './aws-auth';\nimport { BOOTSTRAP_VERSION_OUTPUT, BUCKET_DOMAIN_NAME_OUTPUT, BUCKET_NAME_OUTPUT } from './bootstrap';\nimport { stabilizeStack, CloudFormationStack } from './util/cloudformation';\n\nexport const DEFAULT_TOOLKIT_STACK_NAME = 'CDKToolkit';\n\n/**\n * The bootstrap template version that introduced ssm:GetParameter\n */\nconst BOOTSTRAP_TEMPLATE_VERSION_INTRODUCING_GETPARAMETER = 5;\n\n/**\n * Information on the Bootstrap stack of the environment we're deploying to.\n *\n * This class serves to:\n *\n * - Inspect the bootstrap stack, and return various properties of it for successful\n *   asset deployment (in case of legacy-synthesized stacks).\n * - Validate the version of the target environment, and nothing else (in case of\n *   default-synthesized stacks).\n *\n * An object of this type might represent a bootstrap stack that could not be found.\n * This is not an issue unless any members are used that require the bootstrap stack\n * to have been found, in which case an error is thrown (default-synthesized stacks\n * should never run into this as they don't need information from the bootstrap\n * stack, all information is already encoded into the Cloud Assembly Manifest).\n *\n * Nevertheless, an instance of this class exists to serve as a cache for SSM\n * parameter lookups (otherwise, the \"bootstrap stack version\" parameter would\n * need to be read repeatedly).\n *\n * Called \"ToolkitInfo\" for historical reasons.\n *\n */\nexport abstract class ToolkitInfo {\n  public static determineName(overrideName?: string) {\n    return overrideName ?? DEFAULT_TOOLKIT_STACK_NAME;\n  }\n\n  public static async lookup(environment: cxapi.Environment, sdk: ISDK, stackName: string | undefined): Promise<ToolkitInfo> {\n    const cfn = sdk.cloudFormation();\n    const stack = await stabilizeStack(cfn, stackName ?? DEFAULT_TOOLKIT_STACK_NAME);\n    if (!stack) {\n      debug('The environment %s doesn\\'t have the CDK toolkit stack (%s) installed. Use %s to setup your environment for use with the toolkit.',\n        environment.name, stackName, chalk.blue(`cdk bootstrap \"${environment.name}\"`));\n      return ToolkitInfo.bootstrapStackNotFoundInfo(sdk);\n    }\n    if (stack.stackStatus.isCreationFailure) {\n      // Treat a \"failed to create\" bootstrap stack as an absent one.\n      debug('The environment %s has a CDK toolkit stack (%s) that failed to create. Use %s to try provisioning it again.',\n        environment.name, stackName, chalk.blue(`cdk bootstrap \"${environment.name}\"`));\n      return ToolkitInfo.bootstrapStackNotFoundInfo(sdk);\n    }\n\n    return new ExistingToolkitInfo(stack, sdk);\n  }\n\n  public static fromStack(stack: CloudFormationStack, sdk: ISDK): ToolkitInfo {\n    return new ExistingToolkitInfo(stack, sdk);\n  }\n\n  public static bootstraplessDeploymentsOnly(sdk: ISDK): ToolkitInfo {\n    return new BootstrapStackNotFoundInfo(sdk, '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  public static bootstrapStackNotFoundInfo(sdk: ISDK): ToolkitInfo {\n    return new BootstrapStackNotFoundInfo(sdk, 'This deployment requires a bootstrap stack with a known name; pass \\'--toolkit-stack-name\\' or switch to using the \\'DefaultStackSynthesizer\\' (see https://docs.aws.amazon.com/cdk/latest/guide/bootstrapping.html)');\n  }\n\n  /**\n   * Read a version from an SSM parameter, cached\n   */\n  public static async versionFromSsmParameter(sdk: ISDK, parameterName: string, ssmCache?: Map<string, number>): Promise<number> {\n    const existing = ssmCache?.get(parameterName);\n    if (existing !== undefined) { return existing; }\n\n    const ssm = sdk.ssm();\n\n    try {\n      const result = await ssm.getParameter({ Name: parameterName }).promise();\n\n      const asNumber = parseInt(`${result.Parameter?.Value}`, 10);\n      if (isNaN(asNumber)) {\n        throw new Error(`SSM parameter ${parameterName} not a number: ${result.Parameter?.Value}`);\n      }\n\n      ssmCache?.set(parameterName, asNumber);\n      return asNumber;\n    } catch (e) {\n      if (e.code === 'ParameterNotFound') {\n        throw new Error(`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      throw e;\n    }\n  }\n\n  protected readonly ssmCache = new Map<string, number>();\n  public abstract readonly found: boolean;\n  public abstract readonly bucketUrl: string;\n  public abstract readonly bucketName: string;\n  public abstract readonly version: number;\n  public abstract readonly bootstrapStack: CloudFormationStack;\n\n  constructor(protected readonly sdk: ISDK) {\n  }\n  public abstract validateVersion(expectedVersion: number, ssmParameterName: string | undefined): Promise<void>;\n  public abstract prepareEcrRepository(repositoryName: string): Promise<EcrRepositoryInfo>;\n}\n\n/**\n * Returned when a bootstrap stack is found\n */\nclass ExistingToolkitInfo extends ToolkitInfo {\n  public readonly found = true;\n\n  constructor(public readonly bootstrapStack: CloudFormationStack, sdk: ISDK) {\n    super(sdk);\n  }\n\n  public get bucketUrl() {\n    return `https://${this.requireOutput(BUCKET_DOMAIN_NAME_OUTPUT)}`;\n  }\n\n  public get bucketName() {\n    return this.requireOutput(BUCKET_NAME_OUTPUT);\n  }\n\n  public get version() {\n    return parseInt(this.bootstrapStack.outputs[BOOTSTRAP_VERSION_OUTPUT] ?? '0', 10);\n  }\n\n  public get parameters(): Record<string, string> {\n    return this.bootstrapStack.parameters ?? {};\n  }\n\n  public get terminationProtection(): boolean {\n    return this.bootstrapStack.terminationProtection ?? false;\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, ssmParameterName: string | undefined) {\n    let version = this.version; // Default to the current version, but will be overwritten by a lookup if required.\n\n    if (ssmParameterName !== undefined) {\n      try {\n        version = await ToolkitInfo.versionFromSsmParameter(this.sdk, ssmParameterName, this.ssmCache);\n      } catch (e) {\n        if (e.code !== 'AccessDeniedException') { throw e; }\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        if (this.version >= BOOTSTRAP_TEMPLATE_VERSION_INTRODUCING_GETPARAMETER) {\n          throw e;\n        }\n\n        warning(`Could not read SSM parameter ${ssmParameterName}: ${e.message}`);\n        // Fall through on purpose\n      }\n    }\n\n    if (expectedVersion > version) {\n      throw new Error(`This CDK deployment requires bootstrap stack version '${expectedVersion}', found '${version}'. Please run 'cdk bootstrap'.`);\n    }\n  }\n\n  /**\n   * Prepare an ECR repository for uploading to using Docker\n   *\n   */\n  public async prepareEcrRepository(repositoryName: string): Promise<EcrRepositoryInfo> {\n    if (!this.sdk) {\n      throw new Error('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      debug(`${repositoryName}: checking if ECR repository already exists`);\n      const describeResponse = await ecr.describeRepositories({ repositoryNames: [repositoryName] }).promise();\n      const existingRepositoryUri = describeResponse.repositories![0]?.repositoryUri;\n      if (existingRepositoryUri) {\n        return { repositoryUri: existingRepositoryUri };\n      }\n    } catch (e) {\n      if (e.code !== 'RepositoryNotFoundException') { throw e; }\n    }\n\n    // create the repo (tag it so it will be easier to garbage collect in the future)\n    debug(`${repositoryName}: creating ECR repository`);\n    const assetTag = { Key: 'awscdk:asset', Value: 'true' };\n    const response = await ecr.createRepository({ repositoryName, tags: [assetTag] }).promise();\n    const repositoryUri = response.repository?.repositoryUri;\n    if (!repositoryUri) {\n      throw new Error(`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    debug(`${repositoryName}: enable image scanning`);\n    await ecr.putImageScanningConfiguration({ repositoryName, imageScanningConfiguration: { scanOnPush: true } }).promise();\n\n    return { repositoryUri };\n  }\n\n  private requireOutput(output: string): string {\n    if (!(output in this.bootstrapStack.outputs)) {\n      throw new Error(`The CDK toolkit stack (${this.bootstrapStack.stackName}) does not have an output named ${output}. Use 'cdk bootstrap' to correct this.`);\n    }\n    return this.bootstrapStack.outputs[output];\n  }\n}\n\n/**\n * Returned when a bootstrap stack could not be found\n *\n * This is not an error in principle, UNTIL one of the members is called that requires\n * the bootstrap stack to have been found, in which case the lookup error is still thrown\n * belatedly.\n *\n * The errors below serve as a last stop-gap message--normally calling code should have\n * checked `toolkit.found` and produced an appropriate error message.\n */\nclass BootstrapStackNotFoundInfo extends ToolkitInfo {\n  public readonly found = false;\n\n  constructor(sdk: ISDK, private readonly errorMessage: string) {\n    super(sdk);\n  }\n\n  public get bootstrapStack(): CloudFormationStack {\n    throw new Error(this.errorMessage);\n  }\n\n  public get bucketUrl(): string {\n    throw new Error(this.errorMessage);\n  }\n\n  public get bucketName(): string {\n    throw new Error(this.errorMessage);\n  }\n\n  public get version(): number {\n    throw new Error(this.errorMessage);\n  }\n\n  public async validateVersion(expectedVersion: number, ssmParameterName: string | undefined): Promise<void> {\n    if (ssmParameterName === undefined) {\n      throw new Error(this.errorMessage);\n    }\n\n    let version: number;\n    try {\n      version = await ToolkitInfo.versionFromSsmParameter(this.sdk, ssmParameterName, this.ssmCache);\n    } catch (e) {\n      if (e.code !== 'AccessDeniedException') { throw e; }\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 a 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.\n      warning(`Could not read SSM parameter ${ssmParameterName}: ${e.message}`);\n      throw new Error(`This CDK deployment requires bootstrap stack version '${expectedVersion}', found an older version. Please run 'cdk bootstrap'.`);\n    }\n\n    if (expectedVersion > version) {\n      throw new Error(`This CDK deployment requires bootstrap stack version '${expectedVersion}', found '${version}'. Please run 'cdk bootstrap'.`);\n    }\n  }\n\n  public prepareEcrRepository(): Promise<EcrRepositoryInfo> {\n    throw new Error(this.errorMessage);\n  }\n}\n\nexport interface EcrRepositoryInfo {\n  repositoryUri: string;\n}\n\nexport interface EcrCredentials {\n  username: string;\n  password: string;\n  endpoint: string;\n}\n"]}