aws-cdk
Version:
AWS CDK CLI, the command line tool for CDK apps
331 lines • 68.1 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Deployments = void 0;
const crypto_1 = require("crypto");
const cdk_assets = require("cdk-assets");
const chalk = require("chalk");
const asset_manifest_builder_1 = require("./asset-manifest-builder");
const asset_publishing_1 = require("./asset-publishing");
const cfn_api_1 = require("./cfn-api");
const checks_1 = require("./checks");
const deploy_stack_1 = require("./deploy-stack");
const api_1 = require("../../../../@aws-cdk/tmp-toolkit-helpers/src/api");
const private_1 = require("../../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private");
const util_1 = require("../../util");
const cloudformation_1 = require("../cloudformation");
const environment_1 = require("../environment");
const stack_events_1 = require("../stack-events");
const toolkit_info_1 = require("../toolkit-info");
const BOOTSTRAP_STACK_VERSION_FOR_ROLLBACK = 23;
/**
* Scope for a single set of deployments from a set of Cloud Assembly Artifacts
*
* Manages lookup of SDKs, Bootstrap stacks, etc.
*/
class Deployments {
constructor(props) {
this.props = props;
this.publisherCache = new Map();
this.assetSdkProvider = props.sdkProvider;
this.deployStackSdkProvider = props.sdkProvider;
this.ioHelper = props.ioHelper;
this.envs = new environment_1.EnvironmentAccess(props.sdkProvider, props.toolkitStackName ?? toolkit_info_1.DEFAULT_TOOLKIT_STACK_NAME, this.ioHelper);
}
/**
* Resolves the environment for a stack.
*/
async resolveEnvironment(stack) {
return this.envs.resolveStackEnvironment(stack);
}
async readCurrentTemplateWithNestedStacks(rootStackArtifact, retrieveProcessedTemplate = false) {
const env = await this.envs.accessStackForLookupBestEffort(rootStackArtifact);
return (0, cloudformation_1.loadCurrentTemplateWithNestedStacks)(rootStackArtifact, env.sdk, retrieveProcessedTemplate);
}
async readCurrentTemplate(stackArtifact) {
await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg(`Reading existing template for stack ${stackArtifact.displayName}.`));
const env = await this.envs.accessStackForLookupBestEffort(stackArtifact);
return (0, cloudformation_1.loadCurrentTemplate)(stackArtifact, env.sdk);
}
async resourceIdentifierSummaries(stackArtifact) {
await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg(`Retrieving template summary for stack ${stackArtifact.displayName}.`));
// Currently, needs to use `deploy-role` since it may need to read templates in the staging
// bucket which have been encrypted with a KMS key (and lookup-role may not read encrypted things)
const env = await this.envs.accessStackForReadOnlyStackOperations(stackArtifact);
const cfn = env.sdk.cloudFormation();
await (0, cfn_api_1.uploadStackTemplateAssets)(stackArtifact, this);
// Upload the template, if necessary, before passing it to CFN
const builder = new asset_manifest_builder_1.AssetManifestBuilder();
const cfnParam = await (0, cloudformation_1.makeBodyParameter)(this.ioHelper, stackArtifact, env.resolvedEnvironment, builder, env.resources);
// If the `makeBodyParameter` before this added assets, make sure to publish them before
// calling the API.
const addedAssets = builder.toManifest(stackArtifact.assembly.directory);
for (const entry of addedAssets.entries) {
await this.buildSingleAsset('no-version-validation', addedAssets, entry, {
stack: stackArtifact,
});
await this.publishSingleAsset(addedAssets, entry, {
stack: stackArtifact,
});
}
const response = await cfn.getTemplateSummary(cfnParam);
if (!response.ResourceIdentifierSummaries) {
await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg('GetTemplateSummary API call did not return "ResourceIdentifierSummaries"'));
}
return response.ResourceIdentifierSummaries ?? [];
}
async deployStack(options) {
let deploymentMethod = options.deploymentMethod;
if (options.changeSetName || options.execute !== undefined) {
if (deploymentMethod) {
throw new api_1.ToolkitError("You cannot supply both 'deploymentMethod' and 'changeSetName/execute'. Supply one or the other.");
}
deploymentMethod = {
method: 'change-set',
changeSetName: options.changeSetName,
execute: options.execute,
};
}
const env = await this.envs.accessStackForMutableStackOperations(options.stack);
// Do a verification of the bootstrap stack version
await this.validateBootstrapStackVersion(options.stack.stackName, options.stack.requiresBootstrapStackVersion, options.stack.bootstrapStackVersionSsmParameter, env.resources);
const executionRoleArn = await env.replacePlaceholders(options.roleArn ?? options.stack.cloudFormationExecutionRoleArn);
return (0, deploy_stack_1.deployStack)({
stack: options.stack,
resolvedEnvironment: env.resolvedEnvironment,
deployName: options.deployName,
notificationArns: options.notificationArns,
sdk: env.sdk,
sdkProvider: this.deployStackSdkProvider,
roleArn: executionRoleArn,
reuseAssets: options.reuseAssets,
envResources: env.resources,
tags: options.tags,
deploymentMethod,
force: options.force,
parameters: options.parameters,
usePreviousParameters: options.usePreviousParameters,
rollback: options.rollback,
hotswap: options.hotswap,
hotswapPropertyOverrides: options.hotswapPropertyOverrides,
extraUserAgent: options.extraUserAgent,
resourcesToImport: options.resourcesToImport,
overrideTemplate: options.overrideTemplate,
assetParallelism: options.assetParallelism,
}, this.ioHelper);
}
async rollbackStack(options) {
let resourcesToSkip = options.orphanLogicalIds ?? [];
if (options.force && resourcesToSkip.length > 0) {
throw new api_1.ToolkitError('Cannot combine --force with --orphan');
}
const env = await this.envs.accessStackForMutableStackOperations(options.stack);
if (options.validateBootstrapStackVersion ?? true) {
// Do a verification of the bootstrap stack version
await this.validateBootstrapStackVersion(options.stack.stackName, BOOTSTRAP_STACK_VERSION_FOR_ROLLBACK, options.stack.bootstrapStackVersionSsmParameter, env.resources);
}
const cfn = env.sdk.cloudFormation();
const deployName = options.stack.stackName;
// We loop in case of `--force` and the stack ends up in `CONTINUE_UPDATE_ROLLBACK`.
let maxLoops = 10;
while (maxLoops--) {
let cloudFormationStack = await cloudformation_1.CloudFormationStack.lookup(cfn, deployName);
const executionRoleArn = await env.replacePlaceholders(options.roleArn ?? options.stack.cloudFormationExecutionRoleArn);
switch (cloudFormationStack.stackStatus.rollbackChoice) {
case stack_events_1.RollbackChoice.NONE:
await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_WARN.msg(`Stack ${deployName} does not need a rollback: ${cloudFormationStack.stackStatus}`));
return { notInRollbackableState: true };
case stack_events_1.RollbackChoice.START_ROLLBACK:
await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg(`Initiating rollback of stack ${deployName}`));
await cfn.rollbackStack({
StackName: deployName,
RoleARN: executionRoleArn,
ClientRequestToken: (0, crypto_1.randomUUID)(),
// Enabling this is just the better overall default, the only reason it isn't the upstream default is backwards compatibility
RetainExceptOnCreate: true,
});
break;
case stack_events_1.RollbackChoice.CONTINUE_UPDATE_ROLLBACK:
if (options.force) {
// Find the failed resources from the deployment and automatically skip them
// (Using deployment log because we definitely have `DescribeStackEvents` permissions, and we might not have
// `DescribeStackResources` permissions).
const poller = new stack_events_1.StackEventPoller(cfn, {
stackName: deployName,
stackStatuses: ['ROLLBACK_IN_PROGRESS', 'UPDATE_ROLLBACK_IN_PROGRESS'],
});
await poller.poll();
resourcesToSkip = poller.resourceErrors
.filter((r) => !r.isStackEvent && r.parentStackLogicalIds.length === 0)
.map((r) => r.event.LogicalResourceId ?? '');
}
const skipDescription = resourcesToSkip.length > 0 ? ` (orphaning: ${resourcesToSkip.join(', ')})` : '';
await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_WARN.msg(`Continuing rollback of stack ${deployName}${skipDescription}`));
await cfn.continueUpdateRollback({
StackName: deployName,
ClientRequestToken: (0, crypto_1.randomUUID)(),
RoleARN: executionRoleArn,
ResourcesToSkip: resourcesToSkip,
});
break;
case stack_events_1.RollbackChoice.ROLLBACK_FAILED:
await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_WARN.msg(`Stack ${deployName} failed creation and rollback. This state cannot be rolled back. You can recreate this stack by running 'cdk deploy'.`));
return { notInRollbackableState: true };
default:
throw new api_1.ToolkitError(`Unexpected rollback choice: ${cloudFormationStack.stackStatus.rollbackChoice}`);
}
const monitor = new stack_events_1.StackActivityMonitor({
cfn,
stack: options.stack,
stackName: deployName,
ioHelper: this.ioHelper,
});
await monitor.start();
let stackErrorMessage = undefined;
let finalStackState = cloudFormationStack;
try {
const successStack = await (0, cfn_api_1.stabilizeStack)(cfn, this.ioHelper, deployName);
// This shouldn't really happen, but catch it anyway. You never know.
if (!successStack) {
throw new api_1.ToolkitError('Stack deploy failed (the stack disappeared while we were rolling it back)');
}
finalStackState = successStack;
const errors = monitor.errors.join(', ');
if (errors) {
stackErrorMessage = errors;
}
}
catch (e) {
stackErrorMessage = suffixWithErrors((0, util_1.formatErrorMessage)(e), monitor.errors);
}
finally {
await monitor.stop();
}
if (finalStackState.stackStatus.isRollbackSuccess || !stackErrorMessage) {
return { success: true };
}
// Either we need to ignore some resources to continue the rollback, or something went wrong
if (finalStackState.stackStatus.rollbackChoice === stack_events_1.RollbackChoice.CONTINUE_UPDATE_ROLLBACK && options.force) {
// Do another loop-de-loop
continue;
}
throw new api_1.ToolkitError(`${stackErrorMessage} (fix problem and retry, or orphan these resources using --orphan or --force)`);
}
throw new api_1.ToolkitError("Rollback did not finish after a large number of iterations; stopping because it looks like we're not making progress anymore. You can retry if rollback was progressing as expected.");
}
async destroyStack(options) {
const env = await this.envs.accessStackForMutableStackOperations(options.stack);
const executionRoleArn = await env.replacePlaceholders(options.roleArn ?? options.stack.cloudFormationExecutionRoleArn);
return (0, deploy_stack_1.destroyStack)({
sdk: env.sdk,
roleArn: executionRoleArn,
stack: options.stack,
deployName: options.deployName,
}, this.ioHelper);
}
async stackExists(options) {
let env;
if (options.tryLookupRole) {
env = await this.envs.accessStackForLookupBestEffort(options.stack);
}
else {
env = await this.envs.accessStackForReadOnlyStackOperations(options.stack);
}
const stack = await cloudformation_1.CloudFormationStack.lookup(env.sdk.cloudFormation(), options.deployName ?? options.stack.stackName);
return stack.exists;
}
/**
* Build a single asset from an asset manifest
*
* If an assert manifest artifact is given, the bootstrap stack version
* will be validated according to the constraints in that manifest artifact.
* If that is not necessary, `'no-version-validation'` can be passed.
*/
// eslint-disable-next-line max-len
async buildSingleAsset(assetArtifact, assetManifest, asset, options) {
if (assetArtifact !== 'no-version-validation') {
const env = await this.envs.accessStackForReadOnlyStackOperations(options.stack);
await this.validateBootstrapStackVersion(options.stack.stackName, assetArtifact.requiresBootstrapStackVersion, assetArtifact.bootstrapStackVersionSsmParameter, env.resources);
}
const resolvedEnvironment = await this.envs.resolveStackEnvironment(options.stack);
const publisher = this.cachedPublisher(assetManifest, resolvedEnvironment, options.stackName);
await publisher.buildEntry(asset);
if (publisher.hasFailures) {
throw new api_1.ToolkitError(`Failed to build asset ${asset.displayName(false)}`);
}
}
/**
* Publish a single asset from an asset manifest
*/
async publishSingleAsset(assetManifest, asset, options) {
const stackEnv = await this.envs.resolveStackEnvironment(options.stack);
// No need to validate anymore, we already did that during build
const publisher = this.cachedPublisher(assetManifest, stackEnv, options.stackName);
await publisher.publishEntry(asset, {
allowCrossAccount: await this.allowCrossAccountAssetPublishingForEnv(options.stack),
force: options.forcePublish,
});
if (publisher.hasFailures) {
throw new api_1.ToolkitError(`Failed to publish asset ${asset.displayName(true)}`);
}
}
async allowCrossAccountAssetPublishingForEnv(stack) {
if (this._allowCrossAccountAssetPublishing === undefined) {
const env = await this.envs.accessStackForReadOnlyStackOperations(stack);
this._allowCrossAccountAssetPublishing = await (0, checks_1.determineAllowCrossAccountAssetPublishing)(env.sdk, this.ioHelper, this.props.toolkitStackName);
}
return this._allowCrossAccountAssetPublishing;
}
/**
* Return whether a single asset has been published already
*/
async isSingleAssetPublished(assetManifest, asset, options) {
const stackEnv = await this.envs.resolveStackEnvironment(options.stack);
const publisher = this.cachedPublisher(assetManifest, stackEnv, options.stackName);
return publisher.isEntryPublished(asset);
}
/**
* Validate that the bootstrap stack has the right version for this stack
*
* Call into envResources.validateVersion, but prepend the stack name in case of failure.
*/
async validateBootstrapStackVersion(stackName, requiresBootstrapStackVersion, bootstrapStackVersionSsmParameter, envResources) {
try {
await envResources.validateVersion(requiresBootstrapStackVersion, bootstrapStackVersionSsmParameter);
}
catch (e) {
throw new api_1.ToolkitError(`${stackName}: ${(0, util_1.formatErrorMessage)(e)}`);
}
}
cachedPublisher(assetManifest, env, stackName) {
const existing = this.publisherCache.get(assetManifest);
if (existing) {
return existing;
}
const prefix = stackName ? `${chalk.bold(stackName)}: ` : '';
const publisher = new cdk_assets.AssetPublishing(assetManifest, {
// The AssetPublishing class takes care of role assuming etc, so it's okay to
// give it a direct `SdkProvider`.
aws: new asset_publishing_1.PublishingAws(this.assetSdkProvider, env),
progressListener: new ParallelSafeAssetProgress(prefix, this.ioHelper),
});
this.publisherCache.set(assetManifest, publisher);
return publisher;
}
}
exports.Deployments = Deployments;
/**
* Asset progress that doesn't do anything with percentages (currently)
*/
class ParallelSafeAssetProgress extends asset_publishing_1.BasePublishProgressListener {
constructor(prefix, ioHelper) {
super(ioHelper);
this.prefix = prefix;
}
getMessage(type, event) {
return `${this.prefix}${type}: ${event.message}`;
}
}
function suffixWithErrors(msg, errors) {
return errors && errors.length > 0 ? `${msg}: ${errors.join(', ')}` : msg;
}
//# sourceMappingURL=data:application/json;base64,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