From 67972580ab7258aa0829c00120083850b8ce6ffd Mon Sep 17 00:00:00 2001
From: Sami Turcotte <sturcotte@onica.com>
Date: Fri, 12 Feb 2021 18:36:42 -0500
Subject: [PATCH 1/2] Reintroduce --change-set-name CLI flag

---
 packages/aws-cdk/README.md                    |   7 +-
 packages/aws-cdk/bin/cdk.ts                   |   2 +
 .../lib/api/cloudformation-deployments.ts     | 155 +++++++++++++-----
 packages/aws-cdk/lib/api/deploy-stack.ts      |  28 ++--
 packages/aws-cdk/lib/cdk-toolkit.ts           |   7 +
 .../aws-cdk/test/integ/cli/cli.integtest.ts   |  15 +-
 6 files changed, 156 insertions(+), 58 deletions(-)

diff --git a/packages/aws-cdk/README.md b/packages/aws-cdk/README.md
index 78e2177b186cd..71b05cc420eac 100644
--- a/packages/aws-cdk/README.md
+++ b/packages/aws-cdk/README.md
@@ -288,13 +288,14 @@ The `progress` key can also be specified as a user setting (`~/.cdk.json`)
 #### Externally Executable CloudFormation Change Sets
 
 For more control over when stack changes are deployed, the CDK can generate a
-CloudFormation change set but not execute it. The name of the generated
+CloudFormation change set but not execute it. The default name of the generated
 change set is *cdk-deploy-change-set*, and a previous change set with that
 name will be overwritten. The change set will always be created, even if it
-is empty.
+is empty. A name can also be given to the change set to make it easier to later 
+execute.
 
 ```console
-$ cdk deploy --no-execute
+$ cdk deploy --no-execute --change-set-name MyChangeSetName
 ```
 
 ### `cdk destroy`
diff --git a/packages/aws-cdk/bin/cdk.ts b/packages/aws-cdk/bin/cdk.ts
index 707c4ab770758..9dc3a71799457 100644
--- a/packages/aws-cdk/bin/cdk.ts
+++ b/packages/aws-cdk/bin/cdk.ts
@@ -94,6 +94,7 @@ async function parseCommandLineArguments() {
       // @deprecated(v2) -- tags are part of the Cloud Assembly and tags specified here will be overwritten on the next deployment
       .option('tags', { type: 'array', alias: 't', desc: 'Tags to add to the stack (KEY=VALUE), overrides tags from Cloud Assembly (deprecated)', nargs: 1, requiresArg: true })
       .option('execute', { type: 'boolean', desc: 'Whether to execute ChangeSet (--no-execute will NOT execute the ChangeSet)', default: true })
+      .option('change-set-name', { type: 'string', desc: 'Name of the CloudFormation change set to create' })
       .option('force', { alias: 'f', type: 'boolean', desc: 'Always deploy stack even if templates are identical', default: false })
       .option('parameters', { type: 'array', desc: 'Additional parameters passed to CloudFormation at deploy time (STACK:KEY=VALUE)', nargs: 1, requiresArg: true, default: {} })
       .option('outputs-file', { type: 'string', alias: 'O', desc: 'Path to file where stack outputs will be written as JSON', requiresArg: true })
@@ -316,6 +317,7 @@ async function initCommandLine() {
           reuseAssets: args['build-exclude'],
           tags: configuration.settings.get(['tags']),
           execute: args.execute,
+          changeSetName: args.changeSetName,
           force: args.force,
           parameters: parameterMap,
           usePreviousParameters: args['previous-parameters'],
diff --git a/packages/aws-cdk/lib/api/cloudformation-deployments.ts b/packages/aws-cdk/lib/api/cloudformation-deployments.ts
index 3fe5fed118a76..2d98dd358338c 100644
--- a/packages/aws-cdk/lib/api/cloudformation-deployments.ts
+++ b/packages/aws-cdk/lib/api/cloudformation-deployments.ts
@@ -1,13 +1,13 @@
-import * as cxapi from '@aws-cdk/cx-api';
-import { AssetManifest } from 'cdk-assets';
-import { Tag } from '../cdk-toolkit';
-import { debug } from '../logging';
-import { publishAssets } from '../util/asset-publishing';
-import { Mode, SdkProvider } from './aws-auth';
-import { deployStack, DeployStackResult, destroyStack } from './deploy-stack';
-import { ToolkitInfo } from './toolkit-info';
-import { CloudFormationStack, Template } from './util/cloudformation';
-import { StackActivityProgress } from './util/cloudformation/stack-activity-monitor';
+import * as cxapi from "@aws-cdk/cx-api";
+import { AssetManifest } from "cdk-assets";
+import { Tag } from "../cdk-toolkit";
+import { debug } from "../logging";
+import { publishAssets } from "../util/asset-publishing";
+import { Mode, SdkProvider } from "./aws-auth";
+import { deployStack, DeployStackResult, destroyStack } from "./deploy-stack";
+import { ToolkitInfo } from "./toolkit-info";
+import { CloudFormationStack, Template } from "./util/cloudformation";
+import { StackActivityProgress } from "./util/cloudformation/stack-activity-monitor";
 
 export interface DeployStackOptions {
   /**
@@ -69,6 +69,12 @@ export interface DeployStackOptions {
    */
   execute?: boolean;
 
+  /**
+   * Optional name to use for the CloudFormation change set.
+   * If not provided, a name will be generated automatically.
+   */
+  changeSetName?: string;
+
   /**
    * Force deployment, even if the deployed template is identical to the one we are about to deploy.
    * @default false deployment will be skipped if the template is identical
@@ -136,19 +142,38 @@ export class CloudFormationDeployments {
     this.sdkProvider = props.sdkProvider;
   }
 
-  public async readCurrentTemplate(stackArtifact: cxapi.CloudFormationStackArtifact): Promise<Template> {
+  public async readCurrentTemplate(
+    stackArtifact: cxapi.CloudFormationStackArtifact
+  ): Promise<Template> {
     debug(`Reading existing template for stack ${stackArtifact.displayName}.`);
-    const { stackSdk } = await this.prepareSdkFor(stackArtifact, undefined, Mode.ForReading);
+    const { stackSdk } = await this.prepareSdkFor(
+      stackArtifact,
+      undefined,
+      Mode.ForReading
+    );
     const cfn = stackSdk.cloudFormation();
 
-    const stack = await CloudFormationStack.lookup(cfn, stackArtifact.stackName);
+    const stack = await CloudFormationStack.lookup(
+      cfn,
+      stackArtifact.stackName
+    );
     return stack.template();
   }
 
-  public async deployStack(options: DeployStackOptions): Promise<DeployStackResult> {
-    const { stackSdk, resolvedEnvironment, cloudFormationRoleArn } = await this.prepareSdkFor(options.stack, options.roleArn);
+  public async deployStack(
+    options: DeployStackOptions
+  ): Promise<DeployStackResult> {
+    const {
+      stackSdk,
+      resolvedEnvironment,
+      cloudFormationRoleArn,
+    } = await this.prepareSdkFor(options.stack, options.roleArn);
 
-    const toolkitInfo = await ToolkitInfo.lookup(resolvedEnvironment, stackSdk, options.toolkitStackName);
+    const toolkitInfo = await ToolkitInfo.lookup(
+      resolvedEnvironment,
+      stackSdk,
+      options.toolkitStackName
+    );
 
     // Publish any assets before doing the actual deploy
     await this.publishStackAssets(options.stack, toolkitInfo);
@@ -158,7 +183,8 @@ export class CloudFormationDeployments {
       options.stack.stackName,
       options.stack.requiresBootstrapStackVersion,
       options.stack.bootstrapStackVersionSsmParameter,
-      toolkitInfo);
+      toolkitInfo
+    );
 
     return deployStack({
       stack: options.stack,
@@ -173,6 +199,7 @@ export class CloudFormationDeployments {
       toolkitInfo,
       tags: options.tags,
       execute: options.execute,
+      changeSetName: options.changeSetName,
       force: options.force,
       parameters: options.parameters,
       usePreviousParameters: options.usePreviousParameters,
@@ -182,7 +209,10 @@ export class CloudFormationDeployments {
   }
 
   public async destroyStack(options: DestroyStackOptions): Promise<void> {
-    const { stackSdk, cloudFormationRoleArn: roleArn } = await this.prepareSdkFor(options.stack, options.roleArn);
+    const {
+      stackSdk,
+      cloudFormationRoleArn: roleArn,
+    } = await this.prepareSdkFor(options.stack, options.roleArn);
 
     return destroyStack({
       sdk: stackSdk,
@@ -194,8 +224,15 @@ export class CloudFormationDeployments {
   }
 
   public async stackExists(options: StackExistsOptions): Promise<boolean> {
-    const { stackSdk } = await this.prepareSdkFor(options.stack, undefined, Mode.ForReading);
-    const stack = await CloudFormationStack.lookup(stackSdk.cloudFormation(), options.deployName ?? options.stack.stackName);
+    const { stackSdk } = await this.prepareSdkFor(
+      options.stack,
+      undefined,
+      Mode.ForReading
+    );
+    const stack = await CloudFormationStack.lookup(
+      stackSdk.cloudFormation(),
+      options.deployName ?? options.stack.stackName
+    );
     return stack.exists;
   }
 
@@ -208,24 +245,39 @@ export class CloudFormationDeployments {
    * - SDK loaded with the right credentials for calling `CreateChangeSet`.
    * - The Execution Role that should be passed to CloudFormation.
    */
-  private async prepareSdkFor(stack: cxapi.CloudFormationStackArtifact, roleArn?: string, mode = Mode.ForWriting) {
+  private async prepareSdkFor(
+    stack: cxapi.CloudFormationStackArtifact,
+    roleArn?: string,
+    mode = Mode.ForWriting
+  ) {
     if (!stack.environment) {
-      throw new Error(`The stack ${stack.displayName} does not have an environment`);
+      throw new Error(
+        `The stack ${stack.displayName} does not have an environment`
+      );
     }
 
-    const resolvedEnvironment = await this.sdkProvider.resolveEnvironment(stack.environment);
+    const resolvedEnvironment = await this.sdkProvider.resolveEnvironment(
+      stack.environment
+    );
 
     // Substitute any placeholders with information about the current environment
-    const arns = await this.replaceEnvPlaceholders({
-      assumeRoleArn: stack.assumeRoleArn,
+    const arns = await this.replaceEnvPlaceholders(
+      {
+        assumeRoleArn: stack.assumeRoleArn,
 
-      // Use the override if given, otherwise use the field from the stack
-      cloudFormationRoleArn: roleArn ?? stack.cloudFormationExecutionRoleArn,
-    }, resolvedEnvironment);
+        // Use the override if given, otherwise use the field from the stack
+        cloudFormationRoleArn: roleArn ?? stack.cloudFormationExecutionRoleArn,
+      },
+      resolvedEnvironment
+    );
 
-    const stackSdk = await this.sdkProvider.forEnvironment(resolvedEnvironment, mode, {
-      assumeRoleArn: arns.assumeRoleArn,
-    });
+    const stackSdk = await this.sdkProvider.forEnvironment(
+      resolvedEnvironment,
+      mode,
+      {
+        assumeRoleArn: arns.assumeRoleArn,
+      }
+    );
 
     return {
       stackSdk,
@@ -237,7 +289,10 @@ export class CloudFormationDeployments {
   /**
    * Replace the {ACCOUNT} and {REGION} placeholders in all strings found in a complex object.
    */
-  private async replaceEnvPlaceholders<A extends { }>(object: A, env: cxapi.Environment): Promise<A> {
+  private async replaceEnvPlaceholders<A extends {}>(
+    object: A,
+    env: cxapi.Environment
+  ): Promise<A> {
     return cxapi.EnvironmentPlaceholders.replaceAsync(object, {
       accountId: () => Promise.resolve(env.account),
       region: () => Promise.resolve(env.region),
@@ -247,7 +302,12 @@ export class CloudFormationDeployments {
         //
         // 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 this.sdkProvider.baseCredentialsPartition(env, Mode.ForReading)) ?? 'aws';
+        return (
+          (await this.sdkProvider.baseCredentialsPartition(
+            env,
+            Mode.ForReading
+          )) ?? "aws"
+        );
       },
     });
   }
@@ -255,8 +315,13 @@ export class CloudFormationDeployments {
   /**
    * Publish all asset manifests that are referenced by the given stack
    */
-  private async publishStackAssets(stack: cxapi.CloudFormationStackArtifact, toolkitInfo: ToolkitInfo) {
-    const stackEnv = await this.sdkProvider.resolveEnvironment(stack.environment);
+  private async publishStackAssets(
+    stack: cxapi.CloudFormationStackArtifact,
+    toolkitInfo: ToolkitInfo
+  ) {
+    const stackEnv = await this.sdkProvider.resolveEnvironment(
+      stack.environment
+    );
     const assetArtifacts = stack.dependencies.filter(isAssetManifestArtifact);
 
     for (const assetArtifact of assetArtifacts) {
@@ -264,7 +329,8 @@ export class CloudFormationDeployments {
         stack.stackName,
         assetArtifact.requiresBootstrapStackVersion,
         assetArtifact.bootstrapStackVersionSsmParameter,
-        toolkitInfo);
+        toolkitInfo
+      );
 
       const manifest = AssetManifest.fromFile(assetArtifact.file);
       await publishAssets(manifest, this.sdkProvider, stackEnv);
@@ -278,18 +344,25 @@ export class CloudFormationDeployments {
     stackName: string,
     requiresBootstrapStackVersion: number | undefined,
     bootstrapStackVersionSsmParameter: string | undefined,
-    toolkitInfo: ToolkitInfo) {
-
-    if (requiresBootstrapStackVersion === undefined) { return; }
+    toolkitInfo: ToolkitInfo
+  ) {
+    if (requiresBootstrapStackVersion === undefined) {
+      return;
+    }
 
     try {
-      await toolkitInfo.validateVersion(requiresBootstrapStackVersion, bootstrapStackVersionSsmParameter);
+      await toolkitInfo.validateVersion(
+        requiresBootstrapStackVersion,
+        bootstrapStackVersionSsmParameter
+      );
     } catch (e) {
       throw new Error(`${stackName}: ${e.message}`);
     }
   }
 }
 
-function isAssetManifestArtifact(art: cxapi.CloudArtifact): art is cxapi.AssetManifestArtifact {
+function isAssetManifestArtifact(
+  art: cxapi.CloudArtifact
+): art is cxapi.AssetManifestArtifact {
   return art instanceof cxapi.AssetManifestArtifact;
 }
diff --git a/packages/aws-cdk/lib/api/deploy-stack.ts b/packages/aws-cdk/lib/api/deploy-stack.ts
index 2dfb2f5119c71..177df82d4fcbf 100644
--- a/packages/aws-cdk/lib/api/deploy-stack.ts
+++ b/packages/aws-cdk/lib/api/deploy-stack.ts
@@ -131,6 +131,12 @@ export interface DeployStackOptions {
    */
   execute?: boolean;
 
+  /**
+   * Optional name to use for the CloudFormation change set.
+   * If not provided, a name will be generated automatically.
+   */
+  changeSetName?: string;
+
   /**
    * The collection of extra parameters
    * (in addition to those used for assets)
@@ -174,7 +180,6 @@ export interface DeployStackOptions {
 }
 
 const LARGE_TEMPLATE_SIZE_KB = 50;
-const CDK_CHANGE_SET_NAME = 'cdk-deploy-change-set';
 
 /** @experimental */
 export async function deployStack(options: DeployStackOptions): Promise<DeployStackResult> {
@@ -229,20 +234,21 @@ export async function deployStack(options: DeployStackOptions): Promise<DeploySt
 
   await publishAssets(legacyAssets.toManifest(stackArtifact.assembly.directory), options.sdkProvider, stackEnv);
 
+  const changeSetName = options.changeSetName || 'cdk-deploy-change-set';
   if (cloudFormationStack.exists) {
     //Delete any existing change sets generated by CDK since change set names must be unique.
     //The delete request is successful as long as the stack exists (even if the change set does not exist).
-    debug(`Removing existing change set with name ${CDK_CHANGE_SET_NAME} if it exists`);
-    await cfn.deleteChangeSet({ StackName: deployName, ChangeSetName: CDK_CHANGE_SET_NAME }).promise();
+    debug(`Removing existing change set with name ${changeSetName} if it exists`);
+    await cfn.deleteChangeSet({ StackName: deployName, ChangeSetName: changeSetName }).promise();
   }
 
   const update = cloudFormationStack.exists && cloudFormationStack.stackStatus.name !== 'REVIEW_IN_PROGRESS';
 
-  debug(`Attempting to create ChangeSet ${CDK_CHANGE_SET_NAME} to ${update ? 'update' : 'create'} stack ${deployName}`);
+  debug(`Attempting to create ChangeSet with name ${changeSetName} to ${update ? 'update' : 'create'} stack ${deployName}`);
   print('%s: creating CloudFormation changeset...', colors.bold(deployName));
   const changeSet = await cfn.createChangeSet({
     StackName: deployName,
-    ChangeSetName: CDK_CHANGE_SET_NAME,
+    ChangeSetName: changeSetName,
     ChangeSetType: update ? 'UPDATE' : 'CREATE',
     Description: `CDK Changeset for execution ${executionId}`,
     TemplateBody: bodyParameter.TemplateBody,
@@ -254,7 +260,7 @@ export async function deployStack(options: DeployStackOptions): Promise<DeploySt
     Tags: options.tags,
   }).promise();
   debug('Initiated creation of changeset: %s; waiting for it to finish creating...', changeSet.Id);
-  const changeSetDescription = await waitForChangeSet(cfn, deployName, CDK_CHANGE_SET_NAME);
+  const changeSetDescription = await waitForChangeSet(cfn, deployName, changeSetName);
 
   // Update termination protection only if it has changed.
   const terminationProtection = stackArtifact.terminationProtection ?? false;
@@ -271,22 +277,22 @@ export async function deployStack(options: DeployStackOptions): Promise<DeploySt
     debug('No changes are to be performed on %s.', deployName);
     if (options.execute) {
       debug('Deleting empty change set %s', changeSet.Id);
-      await cfn.deleteChangeSet({ StackName: deployName, ChangeSetName: CDK_CHANGE_SET_NAME }).promise();
+      await cfn.deleteChangeSet({ StackName: deployName, ChangeSetName: changeSetName }).promise();
     }
     return { noOp: true, outputs: cloudFormationStack.outputs, stackArn: changeSet.StackId!, stackArtifact };
   }
 
   const execute = options.execute === undefined ? true : options.execute;
   if (execute) {
-    debug('Initiating execution of changeset %s on stack %s', CDK_CHANGE_SET_NAME, deployName);
-    await cfn.executeChangeSet({ StackName: deployName, ChangeSetName: CDK_CHANGE_SET_NAME }).promise();
+    debug('Initiating execution of changeset %s on stack %s', changeSet.Id, deployName);
+    await cfn.executeChangeSet({ StackName: deployName, ChangeSetName: changeSetName }).promise();
     // eslint-disable-next-line max-len
     const monitor = options.quiet ? undefined : StackActivityMonitor.withDefaultPrinter(cfn, deployName, stackArtifact, {
       resourcesTotal: (changeSetDescription.Changes ?? []).length,
       progress: options.progress,
       changeSetCreationTime: changeSetDescription.CreationTime,
     }).start();
-    debug('Execution of changeset %s on stack %s has started; waiting for the update to complete...', CDK_CHANGE_SET_NAME, deployName);
+    debug('Execution of changeset %s on stack %s has started; waiting for the update to complete...', changeSet.Id, deployName);
     try {
       const finalStack = await waitForStackDeploy(cfn, deployName);
 
@@ -298,7 +304,7 @@ export async function deployStack(options: DeployStackOptions): Promise<DeploySt
     }
     debug('Stack %s has completed updating', deployName);
   } else {
-    print('Changeset %s created and waiting in review for manual execution (--no-execute)', CDK_CHANGE_SET_NAME);
+    print('Changeset %s created and waiting in review for manual execution (--no-execute)', changeSet.Id);
   }
 
   return { noOp: false, outputs: cloudFormationStack.outputs, stackArn: changeSet.StackId!, stackArtifact };
diff --git a/packages/aws-cdk/lib/cdk-toolkit.ts b/packages/aws-cdk/lib/cdk-toolkit.ts
index 84542eb8f4c7f..5491a3d221e24 100644
--- a/packages/aws-cdk/lib/cdk-toolkit.ts
+++ b/packages/aws-cdk/lib/cdk-toolkit.ts
@@ -186,6 +186,7 @@ export class CdkToolkit {
           notificationArns: options.notificationArns,
           tags,
           execute: options.execute,
+          changeSetName: options.changeSetName,
           force: options.force,
           parameters: Object.assign({}, parameterMap['*'], parameterMap[stack.stackName]),
           usePreviousParameters: options.usePreviousParameters,
@@ -554,6 +555,12 @@ export interface DeployOptions {
    */
   execute?: boolean;
 
+  /**
+   * Optional name to use for the CloudFormation change set.
+   * If not provided, a name will be generated automatically.
+   */
+  changeSetName?: string;
+
   /**
    * Always deploy, even if templates are identical.
    * @default false
diff --git a/packages/aws-cdk/test/integ/cli/cli.integtest.ts b/packages/aws-cdk/test/integ/cli/cli.integtest.ts
index 087efd00eb524..eddce24e7a778 100644
--- a/packages/aws-cdk/test/integ/cli/cli.integtest.ts
+++ b/packages/aws-cdk/test/integ/cli/cli.integtest.ts
@@ -139,9 +139,10 @@ integTest('nested stack with parameters', withDefaultFixture(async (fixture) =>
   expect(response.StackResources?.length).toEqual(1);
 }));
 
-integTest('deploy without execute', withDefaultFixture(async (fixture) => {
+integTest('deploy without execute a named change set', withDefaultFixture(async (fixture) => {
+  const changeSetName = 'custom-change-set-name';
   const stackArn = await fixture.cdkDeploy('test-2', {
-    options: ['--no-execute'],
+    options: ['--no-execute', '--change-set-name', changeSetName],
     captureStderr: false,
   });
   // verify that we only deployed a single stack (there's a single ARN in the output)
@@ -150,8 +151,16 @@ integTest('deploy without execute', withDefaultFixture(async (fixture) => {
   const response = await fixture.aws.cloudFormation('describeStacks', {
     StackName: stackArn,
   });
-
   expect(response.Stacks?.[0].StackStatus).toEqual('REVIEW_IN_PROGRESS');
+
+  //verify a change set was created with the provided name
+  const changeSetResponse = await fixture.aws.cloudFormation('listChangeSets', {
+    StackName: stackArn,
+  });
+  const changeSets = changeSetResponse.Summaries || [];
+  expect(changeSets.length).toEqual(1);
+  expect(changeSets[0].ChangeSetName).toEqual(changeSetName);
+  expect(changeSets[0].Status).toEqual('CREATE_COMPLETE');
 }));
 
 integTest('security related changes without a CLI are expected to fail', withDefaultFixture(async (fixture) => {

From 90c8bc3ef99ebe1cdeb702b6b312528538176fc2 Mon Sep 17 00:00:00 2001
From: Sami Turcotte <sturcotte@onica.com>
Date: Fri, 12 Feb 2021 19:44:31 -0500
Subject: [PATCH 2/2] Revert formatting

---
 .../lib/api/cloudformation-deployments.ts     | 148 +++++-------------
 1 file changed, 41 insertions(+), 107 deletions(-)

diff --git a/packages/aws-cdk/lib/api/cloudformation-deployments.ts b/packages/aws-cdk/lib/api/cloudformation-deployments.ts
index 2d98dd358338c..3dde581f0b514 100644
--- a/packages/aws-cdk/lib/api/cloudformation-deployments.ts
+++ b/packages/aws-cdk/lib/api/cloudformation-deployments.ts
@@ -1,13 +1,13 @@
-import * as cxapi from "@aws-cdk/cx-api";
-import { AssetManifest } from "cdk-assets";
-import { Tag } from "../cdk-toolkit";
-import { debug } from "../logging";
-import { publishAssets } from "../util/asset-publishing";
-import { Mode, SdkProvider } from "./aws-auth";
-import { deployStack, DeployStackResult, destroyStack } from "./deploy-stack";
-import { ToolkitInfo } from "./toolkit-info";
-import { CloudFormationStack, Template } from "./util/cloudformation";
-import { StackActivityProgress } from "./util/cloudformation/stack-activity-monitor";
+import * as cxapi from '@aws-cdk/cx-api';
+import { AssetManifest } from 'cdk-assets';
+import { Tag } from '../cdk-toolkit';
+import { debug } from '../logging';
+import { publishAssets } from '../util/asset-publishing';
+import { Mode, SdkProvider } from './aws-auth';
+import { deployStack, DeployStackResult, destroyStack } from './deploy-stack';
+import { ToolkitInfo } from './toolkit-info';
+import { CloudFormationStack, Template } from './util/cloudformation';
+import { StackActivityProgress } from './util/cloudformation/stack-activity-monitor';
 
 export interface DeployStackOptions {
   /**
@@ -142,38 +142,19 @@ export class CloudFormationDeployments {
     this.sdkProvider = props.sdkProvider;
   }
 
-  public async readCurrentTemplate(
-    stackArtifact: cxapi.CloudFormationStackArtifact
-  ): Promise<Template> {
+  public async readCurrentTemplate(stackArtifact: cxapi.CloudFormationStackArtifact): Promise<Template> {
     debug(`Reading existing template for stack ${stackArtifact.displayName}.`);
-    const { stackSdk } = await this.prepareSdkFor(
-      stackArtifact,
-      undefined,
-      Mode.ForReading
-    );
+    const { stackSdk } = await this.prepareSdkFor(stackArtifact, undefined, Mode.ForReading);
     const cfn = stackSdk.cloudFormation();
 
-    const stack = await CloudFormationStack.lookup(
-      cfn,
-      stackArtifact.stackName
-    );
+    const stack = await CloudFormationStack.lookup(cfn, stackArtifact.stackName);
     return stack.template();
   }
 
-  public async deployStack(
-    options: DeployStackOptions
-  ): Promise<DeployStackResult> {
-    const {
-      stackSdk,
-      resolvedEnvironment,
-      cloudFormationRoleArn,
-    } = await this.prepareSdkFor(options.stack, options.roleArn);
+  public async deployStack(options: DeployStackOptions): Promise<DeployStackResult> {
+    const { stackSdk, resolvedEnvironment, cloudFormationRoleArn } = await this.prepareSdkFor(options.stack, options.roleArn);
 
-    const toolkitInfo = await ToolkitInfo.lookup(
-      resolvedEnvironment,
-      stackSdk,
-      options.toolkitStackName
-    );
+    const toolkitInfo = await ToolkitInfo.lookup(resolvedEnvironment, stackSdk, options.toolkitStackName);
 
     // Publish any assets before doing the actual deploy
     await this.publishStackAssets(options.stack, toolkitInfo);
@@ -183,8 +164,7 @@ export class CloudFormationDeployments {
       options.stack.stackName,
       options.stack.requiresBootstrapStackVersion,
       options.stack.bootstrapStackVersionSsmParameter,
-      toolkitInfo
-    );
+      toolkitInfo);
 
     return deployStack({
       stack: options.stack,
@@ -209,10 +189,7 @@ export class CloudFormationDeployments {
   }
 
   public async destroyStack(options: DestroyStackOptions): Promise<void> {
-    const {
-      stackSdk,
-      cloudFormationRoleArn: roleArn,
-    } = await this.prepareSdkFor(options.stack, options.roleArn);
+    const { stackSdk, cloudFormationRoleArn: roleArn } = await this.prepareSdkFor(options.stack, options.roleArn);
 
     return destroyStack({
       sdk: stackSdk,
@@ -224,15 +201,8 @@ export class CloudFormationDeployments {
   }
 
   public async stackExists(options: StackExistsOptions): Promise<boolean> {
-    const { stackSdk } = await this.prepareSdkFor(
-      options.stack,
-      undefined,
-      Mode.ForReading
-    );
-    const stack = await CloudFormationStack.lookup(
-      stackSdk.cloudFormation(),
-      options.deployName ?? options.stack.stackName
-    );
+    const { stackSdk } = await this.prepareSdkFor(options.stack, undefined, Mode.ForReading);
+    const stack = await CloudFormationStack.lookup(stackSdk.cloudFormation(), options.deployName ?? options.stack.stackName);
     return stack.exists;
   }
 
@@ -245,39 +215,24 @@ export class CloudFormationDeployments {
    * - SDK loaded with the right credentials for calling `CreateChangeSet`.
    * - The Execution Role that should be passed to CloudFormation.
    */
-  private async prepareSdkFor(
-    stack: cxapi.CloudFormationStackArtifact,
-    roleArn?: string,
-    mode = Mode.ForWriting
-  ) {
+  private async prepareSdkFor(stack: cxapi.CloudFormationStackArtifact, roleArn?: string, mode = Mode.ForWriting) {
     if (!stack.environment) {
-      throw new Error(
-        `The stack ${stack.displayName} does not have an environment`
-      );
+      throw new Error(`The stack ${stack.displayName} does not have an environment`);
     }
 
-    const resolvedEnvironment = await this.sdkProvider.resolveEnvironment(
-      stack.environment
-    );
+    const resolvedEnvironment = await this.sdkProvider.resolveEnvironment(stack.environment);
 
     // Substitute any placeholders with information about the current environment
-    const arns = await this.replaceEnvPlaceholders(
-      {
-        assumeRoleArn: stack.assumeRoleArn,
+    const arns = await this.replaceEnvPlaceholders({
+      assumeRoleArn: stack.assumeRoleArn,
 
-        // Use the override if given, otherwise use the field from the stack
-        cloudFormationRoleArn: roleArn ?? stack.cloudFormationExecutionRoleArn,
-      },
-      resolvedEnvironment
-    );
+      // Use the override if given, otherwise use the field from the stack
+      cloudFormationRoleArn: roleArn ?? stack.cloudFormationExecutionRoleArn,
+    }, resolvedEnvironment);
 
-    const stackSdk = await this.sdkProvider.forEnvironment(
-      resolvedEnvironment,
-      mode,
-      {
-        assumeRoleArn: arns.assumeRoleArn,
-      }
-    );
+    const stackSdk = await this.sdkProvider.forEnvironment(resolvedEnvironment, mode, {
+      assumeRoleArn: arns.assumeRoleArn,
+    });
 
     return {
       stackSdk,
@@ -289,10 +244,7 @@ export class CloudFormationDeployments {
   /**
    * Replace the {ACCOUNT} and {REGION} placeholders in all strings found in a complex object.
    */
-  private async replaceEnvPlaceholders<A extends {}>(
-    object: A,
-    env: cxapi.Environment
-  ): Promise<A> {
+  private async replaceEnvPlaceholders<A extends { }>(object: A, env: cxapi.Environment): Promise<A> {
     return cxapi.EnvironmentPlaceholders.replaceAsync(object, {
       accountId: () => Promise.resolve(env.account),
       region: () => Promise.resolve(env.region),
@@ -302,12 +254,7 @@ export class CloudFormationDeployments {
         //
         // 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 this.sdkProvider.baseCredentialsPartition(
-            env,
-            Mode.ForReading
-          )) ?? "aws"
-        );
+        return (await this.sdkProvider.baseCredentialsPartition(env, Mode.ForReading)) ?? 'aws';
       },
     });
   }
@@ -315,13 +262,8 @@ export class CloudFormationDeployments {
   /**
    * Publish all asset manifests that are referenced by the given stack
    */
-  private async publishStackAssets(
-    stack: cxapi.CloudFormationStackArtifact,
-    toolkitInfo: ToolkitInfo
-  ) {
-    const stackEnv = await this.sdkProvider.resolveEnvironment(
-      stack.environment
-    );
+  private async publishStackAssets(stack: cxapi.CloudFormationStackArtifact, toolkitInfo: ToolkitInfo) {
+    const stackEnv = await this.sdkProvider.resolveEnvironment(stack.environment);
     const assetArtifacts = stack.dependencies.filter(isAssetManifestArtifact);
 
     for (const assetArtifact of assetArtifacts) {
@@ -329,8 +271,7 @@ export class CloudFormationDeployments {
         stack.stackName,
         assetArtifact.requiresBootstrapStackVersion,
         assetArtifact.bootstrapStackVersionSsmParameter,
-        toolkitInfo
-      );
+        toolkitInfo);
 
       const manifest = AssetManifest.fromFile(assetArtifact.file);
       await publishAssets(manifest, this.sdkProvider, stackEnv);
@@ -344,25 +285,18 @@ export class CloudFormationDeployments {
     stackName: string,
     requiresBootstrapStackVersion: number | undefined,
     bootstrapStackVersionSsmParameter: string | undefined,
-    toolkitInfo: ToolkitInfo
-  ) {
-    if (requiresBootstrapStackVersion === undefined) {
-      return;
-    }
+    toolkitInfo: ToolkitInfo) {
+
+    if (requiresBootstrapStackVersion === undefined) { return; }
 
     try {
-      await toolkitInfo.validateVersion(
-        requiresBootstrapStackVersion,
-        bootstrapStackVersionSsmParameter
-      );
+      await toolkitInfo.validateVersion(requiresBootstrapStackVersion, bootstrapStackVersionSsmParameter);
     } catch (e) {
       throw new Error(`${stackName}: ${e.message}`);
     }
   }
 }
 
-function isAssetManifestArtifact(
-  art: cxapi.CloudArtifact
-): art is cxapi.AssetManifestArtifact {
+function isAssetManifestArtifact(art: cxapi.CloudArtifact): art is cxapi.AssetManifestArtifact {
   return art instanceof cxapi.AssetManifestArtifact;
 }