aws-cdk
Version:
CDK Toolkit, the command line tool for CDK apps
189 lines • 26.5 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.NoBootstrapStackEnvironmentResources = exports.EnvironmentResources = exports.EnvironmentResourcesRegistry = void 0;
const toolkit_info_1 = require("./toolkit-info");
const logging_1 = require("../logging");
/**
* 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 {
constructor(toolkitStackName) {
this.toolkitStackName = toolkitStackName;
this.cache = new Map();
}
for(resolvedEnvironment, sdk) {
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, 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 {
constructor(environment, sdk, cache, toolkitStackName) {
this.environment = environment;
this.sdk = sdk;
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.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));
return;
}
catch (e) {
if (e.code !== '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) {
(0, logging_1.warning)(`Could not read SSM parameter ${ssmParameterName}: ${e.message}, falling back to version from ${bootstrapStack}`);
doValidate(bootstrapStack.version);
return;
}
throw new Error(`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);
function doValidate(version) {
if (defExpectedVersion > version) {
throw new Error(`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 }).promise();
const asNumber = parseInt(`${result.Parameter?.Value}`, 10);
if (isNaN(asNumber)) {
throw new Error(`SSM parameter ${parameterName} not a number: ${result.Parameter?.Value}`);
}
this.cache.ssmParameters.set(parameterName, asNumber);
return asNumber;
}
catch (e) {
if (e.code === 'ParameterNotFound') {
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)`);
}
throw e;
}
}
async prepareEcrRepository(repositoryName) {
if (!this.sdk) {
throw new Error('ToolkitInfo needs to have been initialized with an sdk to call prepareEcrRepository');
}
const ecr = this.sdk.ecr();
// check if repo already exists
try {
(0, logging_1.debug)(`${repositoryName}: checking if ECR repository already exists`);
const describeResponse = await ecr.describeRepositories({ repositoryNames: [repositoryName] }).promise();
const existingRepositoryUri = describeResponse.repositories[0]?.repositoryUri;
if (existingRepositoryUri) {
return { repositoryUri: existingRepositoryUri };
}
}
catch (e) {
if (e.code !== 'RepositoryNotFoundException') {
throw e;
}
}
// create the repo (tag it so it will be easier to garbage collect in the future)
(0, logging_1.debug)(`${repositoryName}: creating ECR repository`);
const assetTag = { Key: 'awscdk:asset', Value: 'true' };
const response = await ecr.createRepository({ repositoryName, tags: [assetTag] }).promise();
const repositoryUri = response.repository?.repositoryUri;
if (!repositoryUri) {
throw new Error(`CreateRepository did not return a repository URI for ${repositoryUri}`);
}
// configure image scanning on push (helps in identifying software vulnerabilities, no additional charge)
(0, logging_1.debug)(`${repositoryName}: enable image scanning`);
await ecr.putImageScanningConfiguration({ repositoryName, imageScanningConfiguration: { scanOnPush: true } }).promise();
return { repositoryUri };
}
}
exports.EnvironmentResources = EnvironmentResources;
class NoBootstrapStackEnvironmentResources extends EnvironmentResources {
constructor(environment, sdk) {
super(environment, sdk, emptyCache());
}
/**
* Look up the toolkit for a given environment, using a given SDK
*/
async lookupToolkit() {
throw new Error('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 * as cxapi from '@aws-cdk/cx-api';\nimport { ISDK } from './aws-auth';\nimport { EcrRepositoryInfo, ToolkitInfo } from './toolkit-info';\nimport { debug, warning } from '../logging';\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: cxapi.Environment, sdk: ISDK) {\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, 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: cxapi.Environment,\n    private readonly sdk: ISDK,\n    private readonly cache: EnvironmentCache,\n    private readonly toolkitStackName?: string,\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.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));\n        return;\n      } catch (e: any) {\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        const bootstrapStack = await this.lookupToolkit();\n        if (bootstrapStack.found && bootstrapStack.version < BOOTSTRAP_TEMPLATE_VERSION_INTRODUCING_GETPARAMETER) {\n          warning(`Could not read SSM parameter ${ssmParameterName}: ${e.message}, falling back to version from ${bootstrapStack}`);\n          doValidate(bootstrapStack.version);\n          return;\n        }\n\n        throw new Error(`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    // No SSM parameter\n    const bootstrapStack = await this.lookupToolkit();\n    doValidate(bootstrapStack.version);\n\n    function doValidate(version: number) {\n      if (defExpectedVersion > version) {\n        throw new Error(`This CDK deployment requires bootstrap stack version '${expectedVersion}', found '${version}'. Please run 'cdk bootstrap'.`);\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) { 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.cache.ssmParameters.set(parameterName, asNumber);\n      return asNumber;\n    } catch (e: any) {\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  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: any) {\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\nexport class NoBootstrapStackEnvironmentResources extends EnvironmentResources {\n  constructor(environment: cxapi.Environment, sdk: ISDK) {\n    super(environment, sdk, 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 Error('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 * 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"]}