refactor(cli): resource-import uses IoHost

Author: mrgrain

packages/@aws-cdk/toolkit/lib/api/io/private/codes.ts

@@ -15,11 +15,15 @@ export const CODES = {
   // 2: List
   CDK_TOOLKIT_I2901: 'Provides details on the selected stacks and their dependencies',
 
+  // 3: Import & Migrate
+  CDK_TOOLKIT_E3900: 'Resource import failed',
+
   // 4: Diff
 
-  // 5: Deploy
+  // 5: Deploy & Watch
   CDK_TOOLKIT_I5000: 'Provides deployment times',
   CDK_TOOLKIT_I5001: 'Provides total time in deploy action, including synth and rollback',
+  CDK_TOOLKIT_I5002: 'Provides time for resource migration',
   CDK_TOOLKIT_I5031: 'Informs about any log groups that are traced as part of the deployment',
   CDK_TOOLKIT_I5050: 'Confirm rollback during deployment',
   CDK_TOOLKIT_I5060: 'Confirm deploy security sensitive changes',

packages/@aws-cdk/toolkit/lib/toolkit/toolkit.ts

@@ -19,7 +19,7 @@ import { CachedCloudAssemblySource, IdentityCloudAssemblySource, StackAssembly,
 import { ALL_STACKS, CloudAssemblySourceBuilder } from '../api/cloud-assembly/private';
 import { ToolkitError } from '../api/errors';
 import { IIoHost, IoMessageCode, IoMessageLevel } from '../api/io';
-import { asSdkLogger, withAction, Timer, confirm, error, highlight, info, success, warn, ActionAwareIoHost, debug, result, withoutEmojis, withoutColor, withTrimmedWhitespace } from '../api/io/private';
+import { asSdkLogger, withAction, Timer, confirm, error, info, success, warn, ActionAwareIoHost, debug, result, withoutEmojis, withoutColor, withTrimmedWhitespace } from '../api/io/private';
 
 /**
  * The current action being performed by the CLI. 'none' represents the absence of an action.
@@ -256,10 +256,8 @@ export class Toolkit extends CloudAssemblySourceBuilder implements AsyncDisposab
     }
 
     const deployments = await this.deploymentsForAction('deploy');
+    const migrator = new ResourceMigrator({ deployments });
 
-    const migrator = new ResourceMigrator({
-      deployments,
-    });
     await migrator.tryMigrateResources(stackCollection, options);
 
     const requireApproval = options.requireApproval ?? RequireApproval.NEVER;
@@ -275,7 +273,6 @@ export class Toolkit extends CloudAssemblySourceBuilder implements AsyncDisposab
     }
 
     const stacks = stackCollection.stackArtifacts;
-
     const stackOutputs: { [key: string]: any } = {};
     const outputsFile = options.outputsFile;
 
@@ -303,28 +300,31 @@ export class Toolkit extends CloudAssemblySourceBuilder implements AsyncDisposab
     const deployStack = async (stackNode: StackNode) => {
       const stack = stackNode.stack;
       if (stackCollection.stackCount !== 1) {
-        await ioHost.notify(highlight(stack.displayName));
+        await ioHost.notify(info(chalk.bold(stack.displayName)));
       }
 
       if (!stack.environment) {
-        // eslint-disable-next-line max-len
         throw new ToolkitError(
           `Stack ${stack.displayName} does not define an environment, and AWS credentials could not be obtained from standard locations or no region was configured.`,
         );
       }
 
+      // The generated stack has no resources
       if (Object.keys(stack.template.Resources || {}).length === 0) {
-        // The generated stack has no resources
-        if (!(await deployments.stackExists({ stack }))) {
-          await ioHost.notify(warn(`${chalk.bold(stack.displayName)}: stack has no resources, skipping deployment.`));
-        } else {
-          await ioHost.notify(warn(`${chalk.bold(stack.displayName)}: stack has no resources, deleting existing stack.`));
-          await this._destroy(assembly, 'deploy', {
-            stacks: { patterns: [stack.hierarchicalId], strategy: StackSelectionStrategy.PATTERN_MUST_MATCH_SINGLE },
-            roleArn: options.roleArn,
-            ci: options.ci,
-          });
+        // stack is empty and doesn't exist => do nothing
+        const stackExists = await deployments.stackExists({ stack });
+        if (!stackExists) {
+          return ioHost.notify(warn(`${chalk.bold(stack.displayName)}: stack has no resources, skipping deployment.`));
         }
+
+        // stack is empty, but exists => delete
+        await ioHost.notify(warn(`${chalk.bold(stack.displayName)}: stack has no resources, deleting existing stack.`));
+        await this._destroy(assembly, 'deploy', {
+          stacks: { patterns: [stack.hierarchicalId], strategy: StackSelectionStrategy.PATTERN_MUST_MATCH_SINGLE },
+          roleArn: options.roleArn,
+          ci: options.ci,
+        });
+
         return;
       }
 

packages/aws-cdk/lib/import.ts renamed to packages/aws-cdk/lib/api/resource-import/importer.ts

@@ -1,20 +1,71 @@
-import { DeployOptions } from '@aws-cdk/cloud-assembly-schema';
+import { format } from 'util';
 import * as cfnDiff from '@aws-cdk/cloudformation-diff';
 import { ResourceDifference } from '@aws-cdk/cloudformation-diff';
 import * as cxapi from '@aws-cdk/cx-api';
 import * as chalk from 'chalk';
 import * as fs from 'fs-extra';
 import * as promptly from 'promptly';
-import { assertIsSuccessfulDeployStackResult, Deployments, DeploymentMethod, ResourceIdentifierProperties, ResourcesToImport } from './api/deployments';
-import { Tag } from './api/tags';
-import { StackActivityProgress } from './api/util/cloudformation/stack-activity-monitor';
-import { error, info, success, warning } from './logging';
-import { ToolkitError } from './toolkit/error';
-
-export interface ImportDeploymentOptions extends DeployOptions {
-  deploymentMethod?: DeploymentMethod;
-  progress?: StackActivityProgress;
-  tags?: Tag[];
+import { error, info, warn } from '../../cli/messages';
+import { IIoHost, ToolkitAction } from '../../toolkit/cli-io-host';
+import { ToolkitError } from '../../toolkit/error';
+import { assertIsSuccessfulDeployStackResult, Deployments, DeploymentMethod, ResourceIdentifierProperties, ResourcesToImport } from '../deployments';
+import { Tag } from '../tags';
+import { StackActivityProgress } from '../util/cloudformation/stack-activity-monitor';
+
+export interface ResourceImporterProps {
+  deployments: Deployments;
+  ioHost: IIoHost;
+  action: ToolkitAction;
+}
+
+export interface ImportDeploymentOptions {
+  /**
+   * Name of the toolkit stack to use/deploy
+   *
+   * @default CDKToolkit
+   */
+  readonly toolkitStackName: string;
+
+  /**
+   * Role to pass to CloudFormation for deployment
+   *
+   * @default - Default stack role
+   */
+  readonly roleArn?: string;
+
+  /**
+   * Deployment method
+   */
+  readonly deploymentMethod?: DeploymentMethod;
+
+  /**
+   * Stack tags (pass through to CloudFormation)
+   */
+  readonly tags?: Tag[];
+
+  /**
+   * Use previous values for unspecified parameters
+   *
+   * If not set, all parameters must be specified for every deployment.
+   *
+   * @default true
+   */
+  readonly usePreviousParameters?: boolean;
+
+  /**
+   * Display mode for stack deployment progress.
+   *
+   * @default - StackActivityProgress.Bar - stack events will be displayed for
+   *   the resource currently being deployed.
+   */
+  readonly progress?: StackActivityProgress;
+
+  /**
+   * Rollback failed deployments
+   *
+   * @default true
+   */
+  readonly rollback?: boolean;
 }
 
 /**
@@ -61,9 +112,20 @@ export type ResourceMap = { [logicalResource: string]: ResourceIdentifierPropert
 export class ResourceImporter {
   private _currentTemplate: any;
 
+  private readonly stack: cxapi.CloudFormationStackArtifact;
+  private readonly cfn: Deployments;
+  private readonly ioHost: IIoHost;
+  private readonly action: ToolkitAction;
+
   constructor(
-    private readonly stack: cxapi.CloudFormationStackArtifact,
-    private readonly cfn: Deployments) { }
+    stack: cxapi.CloudFormationStackArtifact,
+    props: ResourceImporterProps,
+  ) {
+    this.stack = stack;
+    this.cfn = props.deployments;
+    this.ioHost = props.ioHost;
+    this.action = props.action;
+  }
 
   /**
    * Ask the user for resources to import
@@ -96,19 +158,19 @@ export class ResourceImporter {
       const descr = this.describeResource(resource.logicalId);
       const idProps = contents[resource.logicalId];
       if (idProps) {
-        info('%s: importing using %s', chalk.blue(descr), chalk.blue(fmtdict(idProps)));
+        await this.ioHost.notify(info(this.action, format('%s: importing using %s', chalk.blue(descr), chalk.blue(fmtdict(idProps)))));
 
         ret.importResources.push(resource);
         ret.resourceMap[resource.logicalId] = idProps;
         delete contents[resource.logicalId];
       } else {
-        info('%s: skipping', chalk.blue(descr));
+        await this.ioHost.notify(info(this.action, format('%s: skipping', chalk.blue(descr))));
       }
     }
 
     const unknown = Object.keys(contents);
     if (unknown.length > 0) {
-      warning(`Unrecognized resource identifiers in mapping file: ${unknown.join(', ')}`);
+      await this.ioHost.notify(warn(this.action, `Unrecognized resource identifiers in mapping file: ${unknown.join(', ')}`));
     }
 
     return ret;
@@ -158,9 +220,9 @@ export class ResourceImporter {
         ? ' ✅  %s (no changes)'
         : ' ✅  %s';
 
-      success('\n' + message, this.stack.displayName);
+      await this.ioHost.notify(info(this.action, '\n' + chalk.green(format(message, this.stack.displayName))));
     } catch (e) {
-      error('\n ❌  %s failed: %s', chalk.bold(this.stack.displayName), e);
+      await this.ioHost.notify(error(this.action, format('\n ❌  %s failed: %s', chalk.bold(this.stack.displayName), e), 'CDK_TOOLKIT_E3900'));
       throw e;
     }
   }
@@ -189,7 +251,7 @@ export class ResourceImporter {
       const offendingResources = nonAdditions.map(([logId, _]) => this.describeResource(logId));
 
       if (allowNonAdditions) {
-        warning(`Ignoring updated/deleted resources (--force): ${offendingResources.join(', ')}`);
+        await this.ioHost.notify(warn(this.action, `Ignoring updated/deleted resources (--force): ${offendingResources.join(', ')}`));
       } else {
         throw new ToolkitError('No resource updates or deletes are allowed on import operation. Make sure to resolve pending changes ' +
           `to existing resources, before attempting an import. Updated/deleted resources: ${offendingResources.join(', ')} (--force to override)`);
@@ -277,7 +339,7 @@ export class ResourceImporter {
     // Skip resources that do not support importing
     const resourceType = chg.resourceDiff.newResourceType;
     if (resourceType === undefined || !(resourceType in resourceIdentifiers)) {
-      warning(`${resourceName}: unsupported resource type ${resourceType}, skipping import.`);
+      await this.ioHost.notify(warn(this.action, `${resourceName}: unsupported resource type ${resourceType}, skipping import.`));
       return undefined;
     }
 
@@ -303,7 +365,7 @@ export class ResourceImporter {
 
     // If we got here and the user rejected any available identifiers, then apparently they don't want the resource at all
     if (satisfiedPropSets.length > 0) {
-      info(chalk.grey(`Skipping import of ${resourceName}`));
+      await this.ioHost.notify(info(this.action, chalk.grey(`Skipping import of ${resourceName}`)));
       return undefined;
     }
 
@@ -321,7 +383,7 @@ export class ResourceImporter {
 
     // Do the input loop here
     if (preamble) {
-      info(preamble);
+      await this.ioHost.notify(info(this.action, preamble));
     }
     for (const idProps of idPropSets) {
       const input: Record<string, string> = {};
@@ -356,7 +418,7 @@ export class ResourceImporter {
       }
     }
 
-    info(chalk.grey(`Skipping import of ${resourceName}`));
+    await this.ioHost.notify(info(this.action, chalk.grey(`Skipping import of ${resourceName}`)));
     return undefined;
   }
 

packages/aws-cdk/lib/api/resource-import/index.ts

@@ -0,0 +1,2 @@
+export * from './importer';
+export * from './migrator';

packages/aws-cdk/lib/migrator.ts renamed to packages/aws-cdk/lib/api/resource-import/migrator.ts

@@ -1,41 +1,53 @@
 import type * as cxapi from '@aws-cdk/cx-api';
 import * as chalk from 'chalk';
 import * as fs from 'fs-extra';
-import { StackCollection } from './api/cxapp/cloud-assembly';
-import { Deployments, ResourcesToImport } from './api/deployments';
-import { formatTime } from './api/util/string-manipulation';
-import { DeployOptions } from './cli/cdk-toolkit';
-import { ResourceImporter } from './import';
-import { info } from './logging';
+import { ImportDeploymentOptions, ResourceImporter } from './importer';
+import { info } from '../../cli/messages';
+import type { IIoHost, ToolkitAction } from '../../toolkit/cli-io-host';
+import { StackCollection } from '../cxapp/cloud-assembly';
+import { Deployments, ResourcesToImport } from '../deployments';
+import { formatTime } from '../util/string-manipulation';
 
 export interface ResourceMigratorProps {
   deployments: Deployments;
+  ioHost: IIoHost;
+  action: ToolkitAction;
 }
 
-type ResourceMigratorOptions = Pick<DeployOptions, 'roleArn' | 'toolkitStackName' | 'deploymentMethod' | 'progress' | 'rollback'>
-
 export class ResourceMigrator {
-  public constructor(private readonly props: ResourceMigratorProps) {}
+  private readonly props: ResourceMigratorProps;
+  private readonly ioHost: IIoHost;
+  private readonly action: ToolkitAction;
+
+  public constructor(props: ResourceMigratorProps) {
+    this.props = props;
+    this.ioHost = props.ioHost;
+    this.action = props.action;
+  }
 
   /**
    * Checks to see if a migrate.json file exists. If it does and the source is either `filepath` or
    * is in the same environment as the stack deployment, a new stack is created and the resources are
    * migrated to the stack using an IMPORT changeset. The normal deployment will resume after this is complete
    * to add back in any outputs and the CDKMetadata.
    */
-  public async tryMigrateResources(stacks: StackCollection, options: ResourceMigratorOptions): Promise<void> {
+  public async tryMigrateResources(stacks: StackCollection, options: ImportDeploymentOptions): Promise<void> {
     const stack = stacks.stackArtifacts[0];
-    const migrateDeployment = new ResourceImporter(stack, this.props.deployments);
+    const migrateDeployment = new ResourceImporter(stack, {
+      deployments: this.props.deployments,
+      ioHost: this.ioHost,
+      action: this.action,
+    });
     const resourcesToImport = await this.tryGetResources(await migrateDeployment.resolveEnvironment());
 
     if (resourcesToImport) {
-      info('%s: creating stack for resource migration...', chalk.bold(stack.displayName));
-      info('%s: importing resources into stack...', chalk.bold(stack.displayName));
+      await this.ioHost.notify(info(this.action, `${chalk.bold(stack.displayName)}: creating stack for resource migration...`));
+      await this.ioHost.notify(info(this.action, `${chalk.bold(stack.displayName)}: importing resources into stack...`));
 
       await this.performResourceMigration(migrateDeployment, resourcesToImport, options);
 
       fs.rmSync('migrate.json');
-      info('%s: applying CDKMetadata and Outputs to stack (if applicable)...', chalk.bold(stack.displayName));
+      await this.ioHost.notify(info(this.action, `${chalk.bold(stack.displayName)}: applying CDKMetadata and Outputs to stack (if applicable)...`));
     }
   }
 
@@ -45,7 +57,7 @@ export class ResourceMigrator {
   private async performResourceMigration(
     migrateDeployment: ResourceImporter,
     resourcesToImport: ResourcesToImport,
-    options: ResourceMigratorOptions,
+    options: ImportDeploymentOptions,
   ) {
     const startDeployTime = new Date().getTime();
     let elapsedDeployTime = 0;
@@ -61,7 +73,9 @@ export class ResourceMigrator {
     });
 
     elapsedDeployTime = new Date().getTime() - startDeployTime;
-    info('\n✨  Resource migration time: %ss\n', formatTime(elapsedDeployTime));
+    await this.ioHost.notify(info(this.action, `'\n✨  Resource migration time: ${formatTime(elapsedDeployTime)}s\n'`, 'CDK_TOOLKIT_I5002', {
+      duration: elapsedDeployTime,
+    }));
   }
 
   public async tryGetResources(environment: cxapi.Environment): Promise<ResourcesToImport | undefined> {