801 lines
113 KiB
JavaScript
801 lines
113 KiB
JavaScript
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.FromScan = exports.CfnTemplateGeneratorProvider = exports.FilterType = exports.ScanStatus = exports.TemplateSourceOptions = void 0;
|
|
exports.generateCdkApp = generateCdkApp;
|
|
exports.generateStack = generateStack;
|
|
exports.readFromPath = readFromPath;
|
|
exports.readFromStack = readFromStack;
|
|
exports.generateTemplate = generateTemplate;
|
|
exports.chunks = chunks;
|
|
exports.setEnvironment = setEnvironment;
|
|
exports.parseSourceOptions = parseSourceOptions;
|
|
exports.printBar = printBar;
|
|
exports.printDots = printDots;
|
|
exports.rewriteLine = rewriteLine;
|
|
exports.writeMigrateJsonFile = writeMigrateJsonFile;
|
|
exports.getMigrateScanType = getMigrateScanType;
|
|
exports.isThereAWarning = isThereAWarning;
|
|
exports.buildGeneratedTemplateOutput = buildGeneratedTemplateOutput;
|
|
exports.buildCfnClient = buildCfnClient;
|
|
exports.appendWarningsToReadme = appendWarningsToReadme;
|
|
/* eslint-disable @typescript-eslint/no-require-imports */
|
|
/* eslint-disable @typescript-eslint/no-var-requires */
|
|
const fs = require("fs");
|
|
const path = require("path");
|
|
const cloud_assembly_api_1 = require("@aws-cdk/cloud-assembly-api");
|
|
const toolkit_lib_1 = require("@aws-cdk/toolkit-lib");
|
|
const cdk_from_cfn = require("cdk-from-cfn");
|
|
const chalk = require("chalk");
|
|
const init_1 = require("./init");
|
|
const cloudformation_1 = require("../api/cloudformation");
|
|
const plugin_1 = require("../api/plugin");
|
|
const util_1 = require("../util");
|
|
const camelCase = require('camelcase');
|
|
const decamelize = require('decamelize');
|
|
/** The list of languages supported by the built-in noctilucent binary. */
|
|
const MIGRATE_SUPPORTED_LANGUAGES = cdk_from_cfn.supported_languages();
|
|
/**
|
|
* Generates a CDK app from a yaml or json template.
|
|
*
|
|
* @param stackName - The name to assign to the stack in the generated app
|
|
* @param stack - The yaml or json template for the stack
|
|
* @param language - The language to generate the CDK app in
|
|
* @param outputPath - The path at which to generate the CDK app
|
|
*/
|
|
async function generateCdkApp(ioHelper, stackName, stack, language, outputPath, compress) {
|
|
const resolvedOutputPath = path.join(outputPath ?? process.cwd(), stackName);
|
|
const formattedStackName = decamelize(stackName);
|
|
try {
|
|
fs.rmSync(resolvedOutputPath, { recursive: true, force: true });
|
|
fs.mkdirSync(resolvedOutputPath, { recursive: true });
|
|
const generateOnly = compress;
|
|
await (0, init_1.cliInit)({
|
|
ioHelper,
|
|
type: 'app',
|
|
language,
|
|
canUseNetwork: true,
|
|
generateOnly,
|
|
workDir: resolvedOutputPath,
|
|
stackName,
|
|
migrate: true,
|
|
});
|
|
let stackFileName;
|
|
switch (language) {
|
|
case 'typescript':
|
|
stackFileName = `${resolvedOutputPath}/lib/${formattedStackName}-stack.ts`;
|
|
break;
|
|
case 'java':
|
|
stackFileName = `${resolvedOutputPath}/src/main/java/com/myorg/${camelCase(formattedStackName, { pascalCase: true })}Stack.java`;
|
|
break;
|
|
case 'python':
|
|
stackFileName = `${resolvedOutputPath}/${formattedStackName.replace(/-/g, '_')}/${formattedStackName.replace(/-/g, '_')}_stack.py`;
|
|
break;
|
|
case 'csharp':
|
|
stackFileName = `${resolvedOutputPath}/src/${camelCase(formattedStackName, { pascalCase: true })}/${camelCase(formattedStackName, { pascalCase: true })}Stack.cs`;
|
|
break;
|
|
case 'go':
|
|
stackFileName = `${resolvedOutputPath}/${formattedStackName}.go`;
|
|
break;
|
|
default:
|
|
throw new toolkit_lib_1.ToolkitError('UnsupportedMigrateLanguage', `${language} is not supported by CDK Migrate. Please choose from: ${MIGRATE_SUPPORTED_LANGUAGES.join(', ')}`);
|
|
}
|
|
fs.writeFileSync(stackFileName, stack);
|
|
if (compress) {
|
|
await (0, util_1.zipDirectory)(resolvedOutputPath, `${resolvedOutputPath}.zip`);
|
|
fs.rmSync(resolvedOutputPath, { recursive: true, force: true });
|
|
}
|
|
}
|
|
catch (error) {
|
|
fs.rmSync(resolvedOutputPath, { recursive: true, force: true });
|
|
throw error;
|
|
}
|
|
}
|
|
/**
|
|
* Generates a CDK stack file.
|
|
* @param template - The template to translate into a CDK stack
|
|
* @param stackName - The name to assign to the stack
|
|
* @param language - The language to generate the stack in
|
|
* @returns A string representation of a CDK stack file
|
|
*/
|
|
function generateStack(template, stackName, language) {
|
|
const formattedStackName = `${camelCase(decamelize(stackName), { pascalCase: true })}Stack`;
|
|
try {
|
|
return cdk_from_cfn.transmute(template, language, formattedStackName);
|
|
}
|
|
catch (e) {
|
|
throw new toolkit_lib_1.ToolkitError('StackGenerationFailed', `${formattedStackName} could not be generated because ${e.message}`);
|
|
}
|
|
}
|
|
/**
|
|
* Reads and returns a stack template from a local path.
|
|
*
|
|
* @param inputPath - The location of the template
|
|
* @returns A string representation of the template if present, otherwise undefined
|
|
*/
|
|
function readFromPath(inputPath) {
|
|
let readFile;
|
|
try {
|
|
readFile = fs.readFileSync(inputPath, 'utf8');
|
|
}
|
|
catch (e) {
|
|
throw new toolkit_lib_1.ToolkitError('InvalidPath', `'${inputPath}' is not a valid path.`);
|
|
}
|
|
if (readFile == '') {
|
|
throw new toolkit_lib_1.ToolkitError('EmptyTemplateFile', `Cloudformation template filepath: '${inputPath}' is an empty file.`);
|
|
}
|
|
return readFile;
|
|
}
|
|
/**
|
|
* Reads and returns a stack template from a deployed CloudFormation stack.
|
|
*
|
|
* @param stackName - The name of the stack
|
|
* @param sdkProvider - The sdk provider for making CloudFormation calls
|
|
* @param environment - The account and region where the stack is deployed
|
|
* @returns A string representation of the template if present, otherwise undefined
|
|
*/
|
|
async function readFromStack(stackName, sdkProvider, environment) {
|
|
const cloudFormation = (await sdkProvider.forEnvironment(environment, plugin_1.Mode.ForReading)).sdk.cloudFormation();
|
|
const stack = await cloudformation_1.CloudFormationStack.lookup(cloudFormation, stackName, true);
|
|
if (stack.stackStatus.isDeploySuccess || stack.stackStatus.isRollbackSuccess) {
|
|
return JSON.stringify(await stack.template());
|
|
}
|
|
else {
|
|
throw new toolkit_lib_1.ToolkitError('UnhealthyStackStatus', `Stack '${stackName}' in account ${environment.account} and region ${environment.region} has a status of '${stack.stackStatus.name}' due to '${stack.stackStatus.reason}'. The stack cannot be migrated until it is in a healthy state.`);
|
|
}
|
|
}
|
|
/**
|
|
* Takes in a stack name and account and region and returns a generated cloudformation template using the cloudformation
|
|
* template generator.
|
|
*
|
|
* @param GenerateTemplateOptions - An object containing the stack name, filters, sdkProvider, environment, and newScan flag
|
|
* @returns a generated cloudformation template
|
|
*/
|
|
async function generateTemplate(options) {
|
|
const cfn = new CfnTemplateGeneratorProvider(await buildCfnClient(options.sdkProvider, options.environment), options.ioHelper);
|
|
const ioHelper = options.ioHelper;
|
|
const scanId = await findLastSuccessfulScan(cfn, options);
|
|
// if a customer accidentally ctrl-c's out of the command and runs it again, this will continue the progress bar where it left off
|
|
const curScan = await cfn.describeResourceScan(scanId);
|
|
if (curScan.Status == ScanStatus.IN_PROGRESS) {
|
|
await ioHelper.defaults.info('Resource scan in progress. Please wait, this can take 10 minutes or longer.');
|
|
await scanProgressBar(ioHelper, scanId, cfn);
|
|
}
|
|
await displayTimeDiff(ioHelper, new Date(), new Date(curScan.StartTime));
|
|
let resources = await cfn.listResourceScanResources(scanId, options.filters);
|
|
await ioHelper.defaults.info('finding related resources.');
|
|
let relatedResources = await cfn.getResourceScanRelatedResources(scanId, resources);
|
|
await ioHelper.defaults.info(`Found ${relatedResources.length} resources.`);
|
|
await ioHelper.defaults.info('Generating CFN template from scanned resources.');
|
|
const templateArn = (await cfn.createGeneratedTemplate(options.stackName, relatedResources)).GeneratedTemplateId;
|
|
let generatedTemplate = await cfn.describeGeneratedTemplate(templateArn);
|
|
await ioHelper.defaults.info('Please wait, template creation in progress. This may take a couple minutes.');
|
|
while (generatedTemplate.Status !== ScanStatus.COMPLETE && generatedTemplate.Status !== ScanStatus.FAILED) {
|
|
await printDots(`[${generatedTemplate.Status}] Template Creation in Progress`, 400);
|
|
generatedTemplate = await cfn.describeGeneratedTemplate(templateArn);
|
|
}
|
|
await ioHelper.defaults.info('\nTemplate successfully generated!');
|
|
return buildGeneratedTemplateOutput(generatedTemplate, (await cfn.getGeneratedTemplate(templateArn)).TemplateBody, templateArn);
|
|
}
|
|
async function findLastSuccessfulScan(cfn, options) {
|
|
const ioHelper = options.ioHelper;
|
|
let resourceScanSummaries = [];
|
|
const clientRequestToken = `cdk-migrate-${options.environment.account}-${options.environment.region}`;
|
|
if (options.fromScan === FromScan.NEW) {
|
|
await ioHelper.defaults.info(`Starting new scan for account ${options.environment.account} in region ${options.environment.region}`);
|
|
try {
|
|
await cfn.startResourceScan(clientRequestToken);
|
|
resourceScanSummaries = (await cfn.listResourceScans()).ResourceScanSummaries;
|
|
}
|
|
catch (e) {
|
|
// continuing here because if the scan fails on a new-scan it is very likely because there is either already a scan in progress
|
|
// or the customer hit a rate limit. In either case we want to continue with the most recent scan.
|
|
// If this happens to fail for a credential error then that will be caught immediately after anyway.
|
|
await ioHelper.defaults.info(`Scan failed to start due to error '${e.message}', defaulting to latest scan.`);
|
|
}
|
|
}
|
|
else {
|
|
resourceScanSummaries = (await cfn.listResourceScans()).ResourceScanSummaries;
|
|
await cfn.checkForResourceScan(resourceScanSummaries, options, clientRequestToken);
|
|
}
|
|
// get the latest scan, which we know will exist
|
|
resourceScanSummaries = (await cfn.listResourceScans()).ResourceScanSummaries;
|
|
let scanId = resourceScanSummaries[0].ResourceScanId;
|
|
// find the most recent scan that isn't in a failed state in case we didn't start a new one
|
|
for (const summary of resourceScanSummaries) {
|
|
if (summary.Status !== ScanStatus.FAILED) {
|
|
scanId = summary.ResourceScanId;
|
|
break;
|
|
}
|
|
}
|
|
return scanId;
|
|
}
|
|
/**
|
|
* Takes a string of filters in the format of key1=value1,key2=value2 and returns a map of the filters.
|
|
*
|
|
* @param filters - a string of filters in the format of key1=value1,key2=value2
|
|
* @returns a map of the filters
|
|
*/
|
|
function parseFilters(filters) {
|
|
if (!filters) {
|
|
return {
|
|
'resource-identifier': undefined,
|
|
'resource-type-prefix': undefined,
|
|
'tag-key': undefined,
|
|
'tag-value': undefined,
|
|
};
|
|
}
|
|
const filterShorthands = {
|
|
'identifier': FilterType.RESOURCE_IDENTIFIER,
|
|
'id': FilterType.RESOURCE_IDENTIFIER,
|
|
'type': FilterType.RESOURCE_TYPE_PREFIX,
|
|
'type-prefix': FilterType.RESOURCE_TYPE_PREFIX,
|
|
};
|
|
const filterList = filters.split(',');
|
|
let filterMap = {
|
|
[FilterType.RESOURCE_IDENTIFIER]: undefined,
|
|
[FilterType.RESOURCE_TYPE_PREFIX]: undefined,
|
|
[FilterType.TAG_KEY]: undefined,
|
|
[FilterType.TAG_VALUE]: undefined,
|
|
};
|
|
for (const fil of filterList) {
|
|
const filter = fil.split('=');
|
|
let filterKey = filter[0];
|
|
const filterValue = filter[1];
|
|
// if the key is a shorthand, replace it with the full name
|
|
if (filterKey in filterShorthands) {
|
|
filterKey = filterShorthands[filterKey];
|
|
}
|
|
if (Object.values(FilterType).includes(filterKey)) {
|
|
filterMap[filterKey] = filterValue;
|
|
}
|
|
else {
|
|
throw new toolkit_lib_1.ToolkitError('InvalidFilter', `Invalid filter: ${filterKey}`);
|
|
}
|
|
}
|
|
return filterMap;
|
|
}
|
|
/**
|
|
* Takes a list of any type and breaks it up into chunks of a specified size.
|
|
*
|
|
* @param list - The list to break up
|
|
* @param chunkSize - The size of each chunk
|
|
* @returns A list of lists of the specified size
|
|
*/
|
|
function chunks(list, chunkSize) {
|
|
const chunkedList = [];
|
|
for (let i = 0; i < list.length; i += chunkSize) {
|
|
chunkedList.push(list.slice(i, i + chunkSize));
|
|
}
|
|
return chunkedList;
|
|
}
|
|
/**
|
|
* Sets the account and region for making CloudFormation calls.
|
|
* @param account - The account to use
|
|
* @param region - The region to use
|
|
* @returns The environment object
|
|
*/
|
|
function setEnvironment(account, region) {
|
|
return {
|
|
account: account ?? cloud_assembly_api_1.UNKNOWN_ACCOUNT,
|
|
region: region ?? cloud_assembly_api_1.UNKNOWN_REGION,
|
|
name: 'cdk-migrate-env',
|
|
};
|
|
}
|
|
/**
|
|
* Enum for the source options for the template
|
|
*/
|
|
var TemplateSourceOptions;
|
|
(function (TemplateSourceOptions) {
|
|
TemplateSourceOptions["PATH"] = "path";
|
|
TemplateSourceOptions["STACK"] = "stack";
|
|
TemplateSourceOptions["SCAN"] = "scan";
|
|
})(TemplateSourceOptions || (exports.TemplateSourceOptions = TemplateSourceOptions = {}));
|
|
/**
|
|
* Enum for the status of a resource scan
|
|
*/
|
|
var ScanStatus;
|
|
(function (ScanStatus) {
|
|
ScanStatus["IN_PROGRESS"] = "IN_PROGRESS";
|
|
ScanStatus["COMPLETE"] = "COMPLETE";
|
|
ScanStatus["FAILED"] = "FAILED";
|
|
})(ScanStatus || (exports.ScanStatus = ScanStatus = {}));
|
|
var FilterType;
|
|
(function (FilterType) {
|
|
FilterType["RESOURCE_IDENTIFIER"] = "resource-identifier";
|
|
FilterType["RESOURCE_TYPE_PREFIX"] = "resource-type-prefix";
|
|
FilterType["TAG_KEY"] = "tag-key";
|
|
FilterType["TAG_VALUE"] = "tag-value";
|
|
})(FilterType || (exports.FilterType = FilterType = {}));
|
|
/**
|
|
* Validates that exactly one source option has been provided.
|
|
* @param fromPath - The content of the flag `--from-path`
|
|
* @param fromStack - the content of the flag `--from-stack`
|
|
*/
|
|
function parseSourceOptions(fromPath, fromStack, stackName) {
|
|
if (fromPath && fromStack) {
|
|
throw new toolkit_lib_1.ToolkitError('ConflictingSourceOptions', 'Only one of `--from-path` or `--from-stack` may be provided.');
|
|
}
|
|
if (!stackName) {
|
|
throw new toolkit_lib_1.ToolkitError('MissingStackName', '`--stack-name` is a required field.');
|
|
}
|
|
if (!fromPath && !fromStack) {
|
|
return { source: TemplateSourceOptions.SCAN };
|
|
}
|
|
if (fromPath) {
|
|
return { source: TemplateSourceOptions.PATH, templatePath: fromPath };
|
|
}
|
|
return { source: TemplateSourceOptions.STACK, stackName: stackName };
|
|
}
|
|
/**
|
|
* Takes a set of resources and removes any with the managedbystack flag set to true.
|
|
*
|
|
* @param resourceList - the list of resources provided by the list scanned resources calls
|
|
* @returns a list of resources not managed by cfn stacks
|
|
*/
|
|
function excludeManaged(resourceList) {
|
|
return resourceList
|
|
.filter((r) => !r.ManagedByStack)
|
|
.map((r) => ({
|
|
ResourceType: r.ResourceType,
|
|
ResourceIdentifier: r.ResourceIdentifier,
|
|
}));
|
|
}
|
|
/**
|
|
* Transforms a list of resources into a list of resource identifiers by removing the ManagedByStack flag.
|
|
* Setting the value of the field to undefined effectively removes it from the object.
|
|
*
|
|
* @param resourceList - the list of resources provided by the list scanned resources calls
|
|
* @returns a list of ScannedResourceIdentifier[]
|
|
*/
|
|
function resourceIdentifiers(resourceList) {
|
|
const identifiers = [];
|
|
resourceList.forEach((r) => {
|
|
const identifier = {
|
|
ResourceType: r.ResourceType,
|
|
ResourceIdentifier: r.ResourceIdentifier,
|
|
};
|
|
identifiers.push(identifier);
|
|
});
|
|
return identifiers;
|
|
}
|
|
/**
|
|
* Takes a scan id and maintains a progress bar to display the progress of a scan to the user.
|
|
*
|
|
* @param scanId - A string representing the scan id
|
|
* @param cloudFormation - The CloudFormation sdk client to use
|
|
*/
|
|
async function scanProgressBar(ioHelper, scanId, cfn) {
|
|
let curProgress = 0.5;
|
|
// we know it's in progress initially since we wouldn't have gotten here if it wasn't
|
|
let curScan = {
|
|
Status: ScanStatus.IN_PROGRESS,
|
|
$metadata: {},
|
|
};
|
|
while (curScan.Status == ScanStatus.IN_PROGRESS) {
|
|
curScan = await cfn.describeResourceScan(scanId);
|
|
curProgress = curScan.PercentageCompleted ?? curProgress;
|
|
printBar(30, curProgress);
|
|
await new Promise((resolve) => setTimeout(resolve, 2000));
|
|
}
|
|
await ioHelper.defaults.info('\n✅ Scan Complete!');
|
|
}
|
|
/**
|
|
* Prints a progress bar to the console. To be used in a while loop to show progress of a long running task.
|
|
* The progress bar deletes the current line on the console and rewrites it with the progress amount.
|
|
*
|
|
* @param width - The width of the progress bar
|
|
* @param progress - The current progress to display as a percentage of 100
|
|
*/
|
|
function printBar(width, progress) {
|
|
if (!process.env.MIGRATE_INTEG_TEST) {
|
|
const FULL_BLOCK = '█';
|
|
const PARTIAL_BLOCK = ['', '▏', '▎', '▍', '▌', '▋', '▊', '▉'];
|
|
const fraction = Math.min(progress / 100, 1);
|
|
const innerWidth = Math.max(1, width - 2);
|
|
const chars = innerWidth * fraction;
|
|
const remainder = chars - Math.floor(chars);
|
|
const fullChars = FULL_BLOCK.repeat(Math.floor(chars));
|
|
const partialChar = PARTIAL_BLOCK[Math.floor(remainder * PARTIAL_BLOCK.length)];
|
|
const filler = '·'.repeat(innerWidth - Math.floor(chars) - (partialChar ? 1 : 0));
|
|
const color = chalk.green;
|
|
rewriteLine('[' + color(fullChars + partialChar) + filler + `] (${progress}%)`);
|
|
}
|
|
}
|
|
/**
|
|
* Prints a message to the console with a series periods appended to it. To be used in a while loop to show progress of a long running task.
|
|
* The message deletes the current line and rewrites it several times to display 1-3 periods to show the user that the task is still running.
|
|
*
|
|
* @param message - The message to display
|
|
* @param timeoutx4 - The amount of time to wait before printing the next period
|
|
*/
|
|
async function printDots(message, timeoutx4) {
|
|
if (!process.env.MIGRATE_INTEG_TEST) {
|
|
rewriteLine(message + ' .');
|
|
await new Promise((resolve) => setTimeout(resolve, timeoutx4));
|
|
rewriteLine(message + ' ..');
|
|
await new Promise((resolve) => setTimeout(resolve, timeoutx4));
|
|
rewriteLine(message + ' ...');
|
|
await new Promise((resolve) => setTimeout(resolve, timeoutx4));
|
|
rewriteLine(message);
|
|
await new Promise((resolve) => setTimeout(resolve, timeoutx4));
|
|
}
|
|
}
|
|
/**
|
|
* Rewrites the current line on the console and writes a new message to it.
|
|
* This is a helper funciton for printDots and printBar.
|
|
*
|
|
* @param message - The message to display
|
|
*/
|
|
function rewriteLine(message) {
|
|
process.stdout.clearLine(0);
|
|
process.stdout.cursorTo(0);
|
|
process.stdout.write(message);
|
|
}
|
|
/**
|
|
* Prints the time difference between two dates in days, hours, and minutes.
|
|
*
|
|
* @param time1 - The first date to compare
|
|
* @param time2 - The second date to compare
|
|
*/
|
|
async function displayTimeDiff(ioHelper, time1, time2) {
|
|
const diff = Math.abs(time1.getTime() - time2.getTime());
|
|
const days = Math.floor(diff / (1000 * 60 * 60 * 24));
|
|
const hours = Math.floor((diff % (1000 * 60 * 60 * 24)) / (1000 * 60 * 60));
|
|
const minutes = Math.floor((diff % (1000 * 60 * 60)) / (1000 * 60));
|
|
await ioHelper.defaults.info(`Using the latest successful scan which is ${days} days, ${hours} hours, and ${minutes} minutes old.`);
|
|
}
|
|
/**
|
|
* Writes a migrate.json file to the output directory.
|
|
*
|
|
* @param outputPath - The path to write the migrate.json file to
|
|
* @param stackName - The name of the stack
|
|
* @param generatedOutput - The output of the template generator
|
|
*/
|
|
function writeMigrateJsonFile(outputPath, stackName, migrateJson) {
|
|
const outputToJson = {
|
|
'//': 'This file is generated by cdk migrate. It will be automatically deleted after the first successful deployment of this app to the environment of the original resources.',
|
|
'Source': migrateJson.source,
|
|
'Resources': migrateJson.resources,
|
|
};
|
|
fs.writeFileSync(`${path.join(outputPath ?? process.cwd(), stackName)}/migrate.json`, JSON.stringify(outputToJson, null, 2));
|
|
}
|
|
/**
|
|
* Takes a string representing the from-scan flag and returns a FromScan enum value.
|
|
*
|
|
* @param scanType - A string representing the from-scan flag
|
|
* @returns A FromScan enum value
|
|
*/
|
|
function getMigrateScanType(scanType) {
|
|
switch (scanType) {
|
|
case 'new':
|
|
return FromScan.NEW;
|
|
case 'most-recent':
|
|
return FromScan.MOST_RECENT;
|
|
case '':
|
|
return FromScan.DEFAULT;
|
|
case undefined:
|
|
return FromScan.DEFAULT;
|
|
default:
|
|
throw new toolkit_lib_1.ToolkitError('UnknownScanType', `Unknown scan type: ${scanType}`);
|
|
}
|
|
}
|
|
/**
|
|
* Takes a generatedTemplateOutput objct and returns a boolean representing whether there are any warnings on any rescources.
|
|
*
|
|
* @param generatedTemplateOutput - A GenerateTemplateOutput object
|
|
* @returns A boolean representing whether there are any warnings on any rescources
|
|
*/
|
|
function isThereAWarning(generatedTemplateOutput) {
|
|
if (generatedTemplateOutput.resources) {
|
|
for (const resource of generatedTemplateOutput.resources) {
|
|
if (resource.Warnings && resource.Warnings.length > 0) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
/**
|
|
* Builds the GenerateTemplateOutput object from the DescribeGeneratedTemplateOutput and the template body.
|
|
*
|
|
* @param generatedTemplateSummary - The output of the describe generated template call
|
|
* @param templateBody - The body of the generated template
|
|
* @returns A GenerateTemplateOutput object
|
|
*/
|
|
function buildGeneratedTemplateOutput(generatedTemplateSummary, templateBody, source) {
|
|
const resources = generatedTemplateSummary.Resources;
|
|
const migrateJson = {
|
|
templateBody: templateBody,
|
|
source: source,
|
|
resources: generatedTemplateSummary.Resources.map((r) => ({
|
|
ResourceType: r.ResourceType,
|
|
LogicalResourceId: r.LogicalResourceId,
|
|
ResourceIdentifier: r.ResourceIdentifier,
|
|
})),
|
|
};
|
|
const templateId = generatedTemplateSummary.GeneratedTemplateId;
|
|
return {
|
|
migrateJson: migrateJson,
|
|
resources: resources,
|
|
templateId: templateId,
|
|
};
|
|
}
|
|
/**
|
|
* Builds a CloudFormation sdk client for making requests with the CFN template generator.
|
|
*
|
|
* @param sdkProvider - The sdk provider for making CloudFormation calls
|
|
* @param environment - The account and region where the stack is deployed
|
|
* @returns A CloudFormation sdk client
|
|
*/
|
|
async function buildCfnClient(sdkProvider, environment) {
|
|
const sdk = (await sdkProvider.forEnvironment(environment, plugin_1.Mode.ForReading)).sdk;
|
|
sdk.appendCustomUserAgent('cdk-migrate');
|
|
return sdk.cloudFormation();
|
|
}
|
|
/**
|
|
* Appends a list of warnings to a readme file.
|
|
*
|
|
* @param filepath - The path to the readme file
|
|
* @param resources - A list of resources to append warnings for
|
|
*/
|
|
function appendWarningsToReadme(filepath, resources) {
|
|
const readme = fs.readFileSync(filepath, 'utf8');
|
|
const lines = readme.split('\n');
|
|
const index = lines.findIndex((line) => line.trim() === 'Enjoy!');
|
|
let linesToAdd = ['\n## Warnings'];
|
|
linesToAdd.push('### Write-only properties');
|
|
linesToAdd.push("Write-only properties are resource property values that can be written to but can't be read by AWS CloudFormation or CDK Migrate. For more information, see [IaC generator and write-only properties](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/generate-IaC-write-only-properties.html).");
|
|
linesToAdd.push('\n');
|
|
linesToAdd.push('Write-only properties discovered during migration are organized here by resource ID and categorized by write-only property type. Resolve write-only properties by providing property values in your CDK app. For guidance, see [Resolve write-only properties](https://docs.aws.amazon.com/cdk/v2/guide/migrate.html#migrate-resources-writeonly).');
|
|
for (const resource of resources) {
|
|
if (resource.Warnings && resource.Warnings.length > 0) {
|
|
linesToAdd.push(`### ${resource.LogicalResourceId}`);
|
|
for (const warning of resource.Warnings) {
|
|
linesToAdd.push(`- **${warning.Type}**: `);
|
|
for (const property of warning.Properties) {
|
|
linesToAdd.push(` - ${property.PropertyPath}: ${property.Description}`);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
lines.splice(index, 0, ...linesToAdd);
|
|
fs.writeFileSync(filepath, lines.join('\n'));
|
|
}
|
|
/**
|
|
* takes a list of resources and returns a list of unique resources based on the resource type and logical resource id.
|
|
*
|
|
* @param resources - A list of resources to deduplicate
|
|
* @returns A list of unique resources
|
|
*/
|
|
function deduplicateResources(resources) {
|
|
let uniqueResources = {};
|
|
for (const resource of resources) {
|
|
const key = Object.keys(resource.ResourceIdentifier)[0];
|
|
// Creating our unique identifier using the resource type, the key, and the value of the resource identifier
|
|
// The resource identifier is a combination of a key value pair defined by a resource's schema, and the resource type of the resource.
|
|
const uniqueIdentifer = `${resource.ResourceType}:${key}:${resource.ResourceIdentifier[key]}`;
|
|
uniqueResources[uniqueIdentifer] = resource;
|
|
}
|
|
return Object.values(uniqueResources);
|
|
}
|
|
/**
|
|
* Class for making CloudFormation template generator calls
|
|
*/
|
|
class CfnTemplateGeneratorProvider {
|
|
constructor(cfn, ioHelper) {
|
|
this.cfn = cfn;
|
|
this.ioHelper = ioHelper;
|
|
}
|
|
async checkForResourceScan(resourceScanSummaries, options, clientRequestToken) {
|
|
if (!resourceScanSummaries || resourceScanSummaries.length === 0) {
|
|
if (options.fromScan === FromScan.MOST_RECENT) {
|
|
throw new toolkit_lib_1.ToolkitError('NoScansFound', 'No scans found. Please either start a new scan with the `--from-scan` new or do not specify a `--from-scan` option.');
|
|
}
|
|
else {
|
|
await this.ioHelper.defaults.info('No scans found. Initiating a new resource scan.');
|
|
await this.startResourceScan(clientRequestToken);
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Retrieves a tokenized list of resources and their associated scan. If a token is present the function
|
|
* will loop through all pages and combine them into a single list of ScannedRelatedResources
|
|
*
|
|
* @param scanId - scan id for the to list resources for
|
|
* @param resources - A list of resources to find related resources for
|
|
*/
|
|
async getResourceScanRelatedResources(scanId, resources) {
|
|
let relatedResourceList = resources;
|
|
// break the list of resources into chunks of 100 to avoid hitting the 100 resource limit
|
|
for (const chunk of chunks(resources, 100)) {
|
|
// get the first page of related resources
|
|
const res = await this.cfn.listResourceScanRelatedResources({
|
|
ResourceScanId: scanId,
|
|
Resources: chunk,
|
|
});
|
|
// add the first page to the list
|
|
relatedResourceList.push(...(res.RelatedResources ?? []));
|
|
let nextToken = res.NextToken;
|
|
// if there are more pages, cycle through them and add them to the list before moving on to the next chunk
|
|
while (nextToken) {
|
|
const nextRelatedResources = await this.cfn.listResourceScanRelatedResources({
|
|
ResourceScanId: scanId,
|
|
Resources: resourceIdentifiers(resources),
|
|
NextToken: nextToken,
|
|
});
|
|
nextToken = nextRelatedResources.NextToken;
|
|
relatedResourceList.push(...(nextRelatedResources.RelatedResources ?? []));
|
|
}
|
|
}
|
|
relatedResourceList = deduplicateResources(relatedResourceList);
|
|
// prune the managedbystack flag off of them again.
|
|
return process.env.MIGRATE_INTEG_TEST
|
|
? resourceIdentifiers(relatedResourceList)
|
|
: resourceIdentifiers(excludeManaged(relatedResourceList));
|
|
}
|
|
/**
|
|
* Kicks off a scan of a customers account, returning the scan id. A scan can take
|
|
* 10 minutes or longer to complete. However this will return a scan id as soon as
|
|
* the scan has begun.
|
|
*
|
|
* @returns A string representing the scan id
|
|
*/
|
|
async startResourceScan(requestToken) {
|
|
return (await this.cfn.startResourceScan({
|
|
ClientRequestToken: requestToken,
|
|
})).ResourceScanId;
|
|
}
|
|
/**
|
|
* Gets the most recent scans a customer has completed
|
|
*
|
|
* @returns a list of resource scan summaries
|
|
*/
|
|
async listResourceScans() {
|
|
return this.cfn.listResourceScans();
|
|
}
|
|
/**
|
|
* Retrieves a tokenized list of resources from a resource scan. If a token is present, this function
|
|
* will loop through all pages and combine them into a single list of ScannedResource[].
|
|
* Additionally will apply any filters provided by the customer.
|
|
*
|
|
* @param scanId - scan id for the to list resources for
|
|
* @param filters - a string of filters in the format of key1=value1,key2=value2
|
|
* @returns a combined list of all resources from the scan
|
|
*/
|
|
async listResourceScanResources(scanId, filters = []) {
|
|
let resourceList = [];
|
|
let resourceScanInputs;
|
|
if (filters.length > 0) {
|
|
await this.ioHelper.defaults.info('Applying filters to resource scan.');
|
|
for (const filter of filters) {
|
|
const filterList = parseFilters(filter);
|
|
resourceScanInputs = {
|
|
ResourceScanId: scanId,
|
|
ResourceIdentifier: filterList[FilterType.RESOURCE_IDENTIFIER],
|
|
ResourceTypePrefix: filterList[FilterType.RESOURCE_TYPE_PREFIX],
|
|
TagKey: filterList[FilterType.TAG_KEY],
|
|
TagValue: filterList[FilterType.TAG_VALUE],
|
|
};
|
|
const resources = await this.cfn.listResourceScanResources(resourceScanInputs);
|
|
resourceList = resourceList.concat(resources.Resources ?? []);
|
|
let nextToken = resources.NextToken;
|
|
// cycle through the pages adding all resources to the list until we run out of pages
|
|
while (nextToken) {
|
|
resourceScanInputs.NextToken = nextToken;
|
|
const nextResources = await this.cfn.listResourceScanResources(resourceScanInputs);
|
|
nextToken = nextResources.NextToken;
|
|
resourceList = resourceList.concat(nextResources.Resources ?? []);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
await this.ioHelper.defaults.info('No filters provided. Retrieving all resources from scan.');
|
|
resourceScanInputs = {
|
|
ResourceScanId: scanId,
|
|
};
|
|
const resources = await this.cfn.listResourceScanResources(resourceScanInputs);
|
|
resourceList = resourceList.concat(resources.Resources ?? []);
|
|
let nextToken = resources.NextToken;
|
|
// cycle through the pages adding all resources to the list until we run out of pages
|
|
while (nextToken) {
|
|
resourceScanInputs.NextToken = nextToken;
|
|
const nextResources = await this.cfn.listResourceScanResources(resourceScanInputs);
|
|
nextToken = nextResources.NextToken;
|
|
resourceList = resourceList.concat(nextResources.Resources ?? []);
|
|
}
|
|
}
|
|
if (resourceList.length === 0) {
|
|
throw new toolkit_lib_1.ToolkitError('NoResourcesFound', `No resources found with filters ${filters.join(' ')}. Please try again with different filters.`);
|
|
}
|
|
resourceList = deduplicateResources(resourceList);
|
|
return process.env.MIGRATE_INTEG_TEST
|
|
? resourceIdentifiers(resourceList)
|
|
: resourceIdentifiers(excludeManaged(resourceList));
|
|
}
|
|
/**
|
|
* Retrieves information about a resource scan.
|
|
*
|
|
* @param scanId - scan id for the to list resources for
|
|
* @returns information about the scan
|
|
*/
|
|
async describeResourceScan(scanId) {
|
|
return this.cfn.describeResourceScan({
|
|
ResourceScanId: scanId,
|
|
});
|
|
}
|
|
/**
|
|
* Describes the current status of the template being generated.
|
|
*
|
|
* @param templateId - A string representing the template id
|
|
* @returns DescribeGeneratedTemplateOutput an object containing the template status and results
|
|
*/
|
|
async describeGeneratedTemplate(templateId) {
|
|
const generatedTemplate = await this.cfn.describeGeneratedTemplate({
|
|
GeneratedTemplateName: templateId,
|
|
});
|
|
if (generatedTemplate.Status == ScanStatus.FAILED) {
|
|
throw new toolkit_lib_1.ToolkitError('TemplateGenerationFailed', generatedTemplate.StatusReason);
|
|
}
|
|
return generatedTemplate;
|
|
}
|
|
/**
|
|
* Retrieves a completed generated cloudformation template from the template generator.
|
|
*
|
|
* @param templateId - A string representing the template id
|
|
* @param cloudFormation - The CloudFormation sdk client to use
|
|
* @returns DescribeGeneratedTemplateOutput an object containing the template status and body
|
|
*/
|
|
async getGeneratedTemplate(templateId) {
|
|
return this.cfn.getGeneratedTemplate({
|
|
GeneratedTemplateName: templateId,
|
|
});
|
|
}
|
|
/**
|
|
* Kicks off a template generation for a set of resources.
|
|
*
|
|
* @param stackName - The name of the stack
|
|
* @param resources - A list of resources to generate the template from
|
|
* @returns CreateGeneratedTemplateOutput an object containing the template arn to query on later
|
|
*/
|
|
async createGeneratedTemplate(stackName, resources) {
|
|
const createTemplateOutput = await this.cfn.createGeneratedTemplate({
|
|
Resources: resources,
|
|
GeneratedTemplateName: stackName,
|
|
});
|
|
if (createTemplateOutput.GeneratedTemplateId === undefined) {
|
|
throw new toolkit_lib_1.ToolkitError('MissingTemplateArn', 'CreateGeneratedTemplate failed to return an Arn.');
|
|
}
|
|
return createTemplateOutput;
|
|
}
|
|
/**
|
|
* Deletes a generated template from the template generator.
|
|
*
|
|
* @param templateArn - The arn of the template to delete
|
|
* @returns A promise that resolves when the template has been deleted
|
|
*/
|
|
async deleteGeneratedTemplate(templateArn) {
|
|
await this.cfn.deleteGeneratedTemplate({
|
|
GeneratedTemplateName: templateArn,
|
|
});
|
|
}
|
|
}
|
|
exports.CfnTemplateGeneratorProvider = CfnTemplateGeneratorProvider;
|
|
/**
|
|
* The possible ways to choose a scan to generate a CDK application from
|
|
*/
|
|
var FromScan;
|
|
(function (FromScan) {
|
|
/**
|
|
* Initiate a new resource scan to build the CDK application from.
|
|
*/
|
|
FromScan[FromScan["NEW"] = 0] = "NEW";
|
|
/**
|
|
* Use the last successful scan to build the CDK application from. Will fail if no scan is found.
|
|
*/
|
|
FromScan[FromScan["MOST_RECENT"] = 1] = "MOST_RECENT";
|
|
/**
|
|
* Starts a scan if none exists, otherwise uses the most recent successful scan to build the CDK application from.
|
|
*/
|
|
FromScan[FromScan["DEFAULT"] = 2] = "DEFAULT";
|
|
})(FromScan || (exports.FromScan = FromScan = {}));
|
|
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"migrate.js","sourceRoot":"","sources":["migrate.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-require-imports */\n/* eslint-disable @typescript-eslint/no-var-requires */\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport type { Environment } from '@aws-cdk/cloud-assembly-api';\nimport { UNKNOWN_ACCOUNT, UNKNOWN_REGION } from '@aws-cdk/cloud-assembly-api';\nimport { ToolkitError } from '@aws-cdk/toolkit-lib';\nimport type {\n  DescribeGeneratedTemplateCommandOutput,\n  DescribeResourceScanCommandOutput,\n  GetGeneratedTemplateCommandOutput,\n  ListResourceScanResourcesCommandInput,\n  ResourceDefinition,\n  ResourceDetail,\n  ResourceIdentifierSummary,\n  ResourceScanSummary,\n  ScannedResource,\n  ScannedResourceIdentifier,\n} from '@aws-sdk/client-cloudformation';\nimport * as cdk_from_cfn from 'cdk-from-cfn';\nimport * as chalk from 'chalk';\nimport { cliInit } from './init';\nimport type { ICloudFormationClient, SdkProvider } from '../api/aws-auth';\nimport { CloudFormationStack } from '../api/cloudformation';\nimport { Mode } from '../api/plugin';\nimport type { IoHelper } from '../api-private';\nimport { zipDirectory } from '../util';\nconst camelCase = require('camelcase');\nconst decamelize = require('decamelize');\n/** The list of languages supported by the built-in noctilucent binary. */\nconst MIGRATE_SUPPORTED_LANGUAGES: readonly string[] = cdk_from_cfn.supported_languages();\n\n/**\n * Generates a CDK app from a yaml or json template.\n *\n * @param stackName - The name to assign to the stack in the generated app\n * @param stack - The yaml or json template for the stack\n * @param language - The language to generate the CDK app in\n * @param outputPath - The path at which to generate the CDK app\n */\nexport async function generateCdkApp(\n  ioHelper: IoHelper,\n  stackName: string,\n  stack: string,\n  language: string,\n  outputPath?: string,\n  compress?: boolean,\n): Promise<void> {\n  const resolvedOutputPath = path.join(outputPath ?? process.cwd(), stackName);\n  const formattedStackName = decamelize(stackName);\n\n  try {\n    fs.rmSync(resolvedOutputPath, { recursive: true, force: true });\n    fs.mkdirSync(resolvedOutputPath, { recursive: true });\n    const generateOnly = compress;\n    await cliInit({\n      ioHelper,\n      type: 'app',\n      language,\n      canUseNetwork: true,\n      generateOnly,\n      workDir: resolvedOutputPath,\n      stackName,\n      migrate: true,\n    });\n\n    let stackFileName: string;\n    switch (language) {\n      case 'typescript':\n        stackFileName = `${resolvedOutputPath}/lib/${formattedStackName}-stack.ts`;\n        break;\n      case 'java':\n        stackFileName = `${resolvedOutputPath}/src/main/java/com/myorg/${camelCase(formattedStackName, { pascalCase: true })}Stack.java`;\n        break;\n      case 'python':\n        stackFileName = `${resolvedOutputPath}/${formattedStackName.replace(/-/g, '_')}/${formattedStackName.replace(/-/g, '_')}_stack.py`;\n        break;\n      case 'csharp':\n        stackFileName = `${resolvedOutputPath}/src/${camelCase(formattedStackName, { pascalCase: true })}/${camelCase(formattedStackName, { pascalCase: true })}Stack.cs`;\n        break;\n      case 'go':\n        stackFileName = `${resolvedOutputPath}/${formattedStackName}.go`;\n        break;\n      default:\n        throw new ToolkitError(\n          'UnsupportedMigrateLanguage',\n          `${language} is not supported by CDK Migrate. Please choose from: ${MIGRATE_SUPPORTED_LANGUAGES.join(', ')}`,\n        );\n    }\n    fs.writeFileSync(stackFileName, stack);\n    if (compress) {\n      await zipDirectory(resolvedOutputPath, `${resolvedOutputPath}.zip`);\n      fs.rmSync(resolvedOutputPath, { recursive: true, force: true });\n    }\n  } catch (error) {\n    fs.rmSync(resolvedOutputPath, { recursive: true, force: true });\n    throw error;\n  }\n}\n\n/**\n * Generates a CDK stack file.\n * @param template - The template to translate into a CDK stack\n * @param stackName - The name to assign to the stack\n * @param language - The language to generate the stack in\n * @returns A string representation of a CDK stack file\n */\nexport function generateStack(template: string, stackName: string, language: string) {\n  const formattedStackName = `${camelCase(decamelize(stackName), { pascalCase: true })}Stack`;\n  try {\n    return cdk_from_cfn.transmute(template, language, formattedStackName);\n  } catch (e) {\n    throw new ToolkitError('StackGenerationFailed', `${formattedStackName} could not be generated because ${(e as Error).message}`);\n  }\n}\n\n/**\n * Reads and returns a stack template from a local path.\n *\n * @param inputPath - The location of the template\n * @returns A string representation of the template if present, otherwise undefined\n */\nexport function readFromPath(inputPath: string): string {\n  let readFile: string;\n  try {\n    readFile = fs.readFileSync(inputPath, 'utf8');\n  } catch (e) {\n    throw new ToolkitError('InvalidPath', `'${inputPath}' is not a valid path.`);\n  }\n  if (readFile == '') {\n    throw new ToolkitError('EmptyTemplateFile', `Cloudformation template filepath: '${inputPath}' is an empty file.`);\n  }\n  return readFile;\n}\n\n/**\n * Reads and returns a stack template from a deployed CloudFormation stack.\n *\n * @param stackName - The name of the stack\n * @param sdkProvider - The sdk provider for making CloudFormation calls\n * @param environment - The account and region where the stack is deployed\n * @returns A string representation of the template if present, otherwise undefined\n */\nexport async function readFromStack(\n  stackName: string,\n  sdkProvider: SdkProvider,\n  environment: Environment,\n): Promise<string | undefined> {\n  const cloudFormation = (await sdkProvider.forEnvironment(environment, Mode.ForReading)).sdk.cloudFormation();\n\n  const stack = await CloudFormationStack.lookup(cloudFormation, stackName, true);\n  if (stack.stackStatus.isDeploySuccess || stack.stackStatus.isRollbackSuccess) {\n    return JSON.stringify(await stack.template());\n  } else {\n    throw new ToolkitError(\n      'UnhealthyStackStatus',\n      `Stack '${stackName}' in account ${environment.account} and region ${environment.region} has a status of '${stack.stackStatus.name}' due to '${stack.stackStatus.reason}'. The stack cannot be migrated until it is in a healthy state.`,\n    );\n  }\n}\n\n/**\n * Takes in a stack name and account and region and returns a generated cloudformation template using the cloudformation\n * template generator.\n *\n * @param GenerateTemplateOptions - An object containing the stack name, filters, sdkProvider, environment, and newScan flag\n * @returns a generated cloudformation template\n */\nexport async function generateTemplate(options: GenerateTemplateOptions): Promise<GenerateTemplateOutput> {\n  const cfn = new CfnTemplateGeneratorProvider(await buildCfnClient(options.sdkProvider, options.environment), options.ioHelper);\n  const ioHelper = options.ioHelper;\n\n  const scanId = await findLastSuccessfulScan(cfn, options);\n\n  // if a customer accidentally ctrl-c's out of the command and runs it again, this will continue the progress bar where it left off\n  const curScan = await cfn.describeResourceScan(scanId);\n  if (curScan.Status == ScanStatus.IN_PROGRESS) {\n    await ioHelper.defaults.info('Resource scan in progress. Please wait, this can take 10 minutes or longer.');\n    await scanProgressBar(ioHelper, scanId, cfn);\n  }\n\n  await displayTimeDiff(ioHelper, new Date(), new Date(curScan.StartTime!));\n\n  let resources: ScannedResource[] = await cfn.listResourceScanResources(scanId!, options.filters);\n\n  await ioHelper.defaults.info('finding related resources.');\n  let relatedResources = await cfn.getResourceScanRelatedResources(scanId!, resources);\n\n  await ioHelper.defaults.info(`Found ${relatedResources.length} resources.`);\n\n  await ioHelper.defaults.info('Generating CFN template from scanned resources.');\n  const templateArn = (await cfn.createGeneratedTemplate(options.stackName, relatedResources)).GeneratedTemplateId!;\n\n  let generatedTemplate = await cfn.describeGeneratedTemplate(templateArn);\n\n  await ioHelper.defaults.info('Please wait, template creation in progress. This may take a couple minutes.');\n  while (generatedTemplate.Status !== ScanStatus.COMPLETE && generatedTemplate.Status !== ScanStatus.FAILED) {\n    await printDots(`[${generatedTemplate.Status}] Template Creation in Progress`, 400);\n    generatedTemplate = await cfn.describeGeneratedTemplate(templateArn);\n  }\n  await ioHelper.defaults.info('\\nTemplate successfully generated!');\n  return buildGeneratedTemplateOutput(\n    generatedTemplate,\n    (await cfn.getGeneratedTemplate(templateArn)).TemplateBody!,\n    templateArn,\n  );\n}\n\nasync function findLastSuccessfulScan(\n  cfn: CfnTemplateGeneratorProvider,\n  options: GenerateTemplateOptions,\n): Promise<string> {\n  const ioHelper = options.ioHelper;\n  let resourceScanSummaries: ResourceScanSummary[] | undefined = [];\n  const clientRequestToken = `cdk-migrate-${options.environment.account}-${options.environment.region}`;\n  if (options.fromScan === FromScan.NEW) {\n    await ioHelper.defaults.info(`Starting new scan for account ${options.environment.account} in region ${options.environment.region}`);\n    try {\n      await cfn.startResourceScan(clientRequestToken);\n      resourceScanSummaries = (await cfn.listResourceScans()).ResourceScanSummaries;\n    } catch (e) {\n      // continuing here because if the scan fails on a new-scan it is very likely because there is either already a scan in progress\n      // or the customer hit a rate limit. In either case we want to continue with the most recent scan.\n      // If this happens to fail for a credential error then that will be caught immediately after anyway.\n      await ioHelper.defaults.info(`Scan failed to start due to error '${(e as Error).message}', defaulting to latest scan.`);\n    }\n  } else {\n    resourceScanSummaries = (await cfn.listResourceScans()).ResourceScanSummaries;\n    await cfn.checkForResourceScan(resourceScanSummaries, options, clientRequestToken);\n  }\n  // get the latest scan, which we know will exist\n  resourceScanSummaries = (await cfn.listResourceScans()).ResourceScanSummaries;\n  let scanId: string | undefined = resourceScanSummaries![0].ResourceScanId;\n\n  // find the most recent scan that isn't in a failed state in case we didn't start a new one\n  for (const summary of resourceScanSummaries!) {\n    if (summary.Status !== ScanStatus.FAILED) {\n      scanId = summary.ResourceScanId!;\n      break;\n    }\n  }\n\n  return scanId!;\n}\n\n/**\n * Takes a string of filters in the format of key1=value1,key2=value2 and returns a map of the filters.\n *\n * @param filters - a string of filters in the format of key1=value1,key2=value2\n * @returns a map of the filters\n */\nfunction parseFilters(filters: string): {\n  [key in FilterType]: string | undefined;\n} {\n  if (!filters) {\n    return {\n      'resource-identifier': undefined,\n      'resource-type-prefix': undefined,\n      'tag-key': undefined,\n      'tag-value': undefined,\n    };\n  }\n\n  const filterShorthands: { [key: string]: FilterType } = {\n    'identifier': FilterType.RESOURCE_IDENTIFIER,\n    'id': FilterType.RESOURCE_IDENTIFIER,\n    'type': FilterType.RESOURCE_TYPE_PREFIX,\n    'type-prefix': FilterType.RESOURCE_TYPE_PREFIX,\n  };\n\n  const filterList = filters.split(',');\n\n  let filterMap: { [key in FilterType]: string | undefined } = {\n    [FilterType.RESOURCE_IDENTIFIER]: undefined,\n    [FilterType.RESOURCE_TYPE_PREFIX]: undefined,\n    [FilterType.TAG_KEY]: undefined,\n    [FilterType.TAG_VALUE]: undefined,\n  };\n\n  for (const fil of filterList) {\n    const filter = fil.split('=');\n    let filterKey = filter[0];\n    const filterValue = filter[1];\n    // if the key is a shorthand, replace it with the full name\n    if (filterKey in filterShorthands) {\n      filterKey = filterShorthands[filterKey];\n    }\n    if (Object.values(FilterType).includes(filterKey as any)) {\n      filterMap[filterKey as keyof typeof filterMap] = filterValue;\n    } else {\n      throw new ToolkitError('InvalidFilter', `Invalid filter: ${filterKey}`);\n    }\n  }\n  return filterMap;\n}\n\n/**\n * Takes a list of any type and breaks it up into chunks of a specified size.\n *\n * @param list - The list to break up\n * @param chunkSize - The size of each chunk\n * @returns A list of lists of the specified size\n */\nexport function chunks(list: any[], chunkSize: number): any[][] {\n  const chunkedList: any[][] = [];\n  for (let i = 0; i < list.length; i += chunkSize) {\n    chunkedList.push(list.slice(i, i + chunkSize));\n  }\n  return chunkedList;\n}\n\n/**\n * Sets the account and region for making CloudFormation calls.\n * @param account - The account to use\n * @param region - The region to use\n * @returns The environment object\n */\nexport function setEnvironment(account?: string, region?: string): Environment {\n  return {\n    account: account ?? UNKNOWN_ACCOUNT,\n    region: region ?? UNKNOWN_REGION,\n    name: 'cdk-migrate-env',\n  };\n}\n\n/**\n * Enum for the source options for the template\n */\nexport enum TemplateSourceOptions {\n  PATH = 'path',\n  STACK = 'stack',\n  SCAN = 'scan',\n}\n\n/**\n * An object representing the source of a template.\n */\ntype TemplateSource =\n  | { source: TemplateSourceOptions.SCAN }\n  | { source: TemplateSourceOptions.PATH; templatePath: string }\n  | { source: TemplateSourceOptions.STACK; stackName: string };\n\n/**\n * Enum for the status of a resource scan\n */\nexport enum ScanStatus {\n  IN_PROGRESS = 'IN_PROGRESS',\n  COMPLETE = 'COMPLETE',\n  FAILED = 'FAILED',\n}\n\nexport enum FilterType {\n  RESOURCE_IDENTIFIER = 'resource-identifier',\n  RESOURCE_TYPE_PREFIX = 'resource-type-prefix',\n  TAG_KEY = 'tag-key',\n  TAG_VALUE = 'tag-value',\n}\n\n/**\n * Validates that exactly one source option has been provided.\n * @param fromPath - The content of the flag `--from-path`\n * @param fromStack - the content of the flag `--from-stack`\n */\nexport function parseSourceOptions(fromPath?: string, fromStack?: boolean, stackName?: string): TemplateSource {\n  if (fromPath && fromStack) {\n    throw new ToolkitError('ConflictingSourceOptions', 'Only one of `--from-path` or `--from-stack` may be provided.');\n  }\n  if (!stackName) {\n    throw new ToolkitError('MissingStackName', '`--stack-name` is a required field.');\n  }\n  if (!fromPath && !fromStack) {\n    return { source: TemplateSourceOptions.SCAN };\n  }\n  if (fromPath) {\n    return { source: TemplateSourceOptions.PATH, templatePath: fromPath };\n  }\n  return { source: TemplateSourceOptions.STACK, stackName: stackName! };\n}\n\n/**\n * Takes a set of resources and removes any with the managedbystack flag set to true.\n *\n * @param resourceList - the list of resources provided by the list scanned resources calls\n * @returns a list of resources not managed by cfn stacks\n */\nfunction excludeManaged(resourceList: ScannedResource[]): ScannedResourceIdentifier[] {\n  return resourceList\n    .filter((r) => !r.ManagedByStack)\n    .map((r) => ({\n      ResourceType: r.ResourceType!,\n      ResourceIdentifier: r.ResourceIdentifier!,\n    }));\n}\n\n/**\n * Transforms a list of resources into a list of resource identifiers by removing the ManagedByStack flag.\n * Setting the value of the field to undefined effectively removes it from the object.\n *\n * @param resourceList - the list of resources provided by the list scanned resources calls\n * @returns a list of ScannedResourceIdentifier[]\n */\nfunction resourceIdentifiers(resourceList: ScannedResource[]): ScannedResourceIdentifier[] {\n  const identifiers: ScannedResourceIdentifier[] = [];\n  resourceList.forEach((r) => {\n    const identifier: ScannedResourceIdentifier = {\n      ResourceType: r.ResourceType!,\n      ResourceIdentifier: r.ResourceIdentifier!,\n    };\n    identifiers.push(identifier);\n  });\n  return identifiers;\n}\n\n/**\n * Takes a scan id and maintains a progress bar to display the progress of a scan to the user.\n *\n * @param scanId - A string representing the scan id\n * @param cloudFormation - The CloudFormation sdk client to use\n */\nasync function scanProgressBar(ioHelper: IoHelper, scanId: string, cfn: CfnTemplateGeneratorProvider) {\n  let curProgress = 0.5;\n  // we know it's in progress initially since we wouldn't have gotten here if it wasn't\n  let curScan: DescribeResourceScanCommandOutput = {\n    Status: ScanStatus.IN_PROGRESS,\n    $metadata: {},\n  };\n  while (curScan.Status == ScanStatus.IN_PROGRESS) {\n    curScan = await cfn.describeResourceScan(scanId);\n    curProgress = curScan.PercentageCompleted ?? curProgress;\n    printBar(30, curProgress);\n    await new Promise((resolve) => setTimeout(resolve, 2000));\n  }\n  await ioHelper.defaults.info('\\n✅ Scan Complete!');\n}\n\n/**\n * Prints a progress bar to the console. To be used in a while loop to show progress of a long running task.\n * The progress bar deletes the current line on the console and rewrites it with the progress amount.\n *\n * @param width - The width of the progress bar\n * @param progress - The current progress to display as a percentage of 100\n */\nexport function printBar(width: number, progress: number) {\n  if (!process.env.MIGRATE_INTEG_TEST) {\n    const FULL_BLOCK = '█';\n    const PARTIAL_BLOCK = ['', '▏', '▎', '▍', '▌', '▋', '▊', '▉'];\n    const fraction = Math.min(progress / 100, 1);\n    const innerWidth = Math.max(1, width - 2);\n    const chars = innerWidth * fraction;\n    const remainder = chars - Math.floor(chars);\n\n    const fullChars = FULL_BLOCK.repeat(Math.floor(chars));\n    const partialChar = PARTIAL_BLOCK[Math.floor(remainder * PARTIAL_BLOCK.length)];\n    const filler = '·'.repeat(innerWidth - Math.floor(chars) - (partialChar ? 1 : 0));\n\n    const color = chalk.green;\n\n    rewriteLine('[' + color(fullChars + partialChar) + filler + `] (${progress}%)`);\n  }\n}\n\n/**\n * Prints a message to the console with a series periods appended to it. To be used in a while loop to show progress of a long running task.\n * The message deletes the current line and rewrites it several times to display 1-3 periods to show the user that the task is still running.\n *\n * @param message - The message to display\n * @param timeoutx4 - The amount of time to wait before printing the next period\n */\nexport async function printDots(message: string, timeoutx4: number) {\n  if (!process.env.MIGRATE_INTEG_TEST) {\n    rewriteLine(message + ' .');\n    await new Promise((resolve) => setTimeout(resolve, timeoutx4));\n\n    rewriteLine(message + ' ..');\n    await new Promise((resolve) => setTimeout(resolve, timeoutx4));\n\n    rewriteLine(message + ' ...');\n    await new Promise((resolve) => setTimeout(resolve, timeoutx4));\n\n    rewriteLine(message);\n    await new Promise((resolve) => setTimeout(resolve, timeoutx4));\n  }\n}\n\n/**\n * Rewrites the current line on the console and writes a new message to it.\n * This is a helper funciton for printDots and printBar.\n *\n * @param message - The message to display\n */\nexport function rewriteLine(message: string) {\n  process.stdout.clearLine(0);\n  process.stdout.cursorTo(0);\n  process.stdout.write(message);\n}\n\n/**\n * Prints the time difference between two dates in days, hours, and minutes.\n *\n * @param time1 - The first date to compare\n * @param time2 - The second date to compare\n */\nasync function displayTimeDiff(ioHelper: IoHelper, time1: Date, time2: Date): Promise<void> {\n  const diff = Math.abs(time1.getTime() - time2.getTime());\n\n  const days = Math.floor(diff / (1000 * 60 * 60 * 24));\n  const hours = Math.floor((diff % (1000 * 60 * 60 * 24)) / (1000 * 60 * 60));\n  const minutes = Math.floor((diff % (1000 * 60 * 60)) / (1000 * 60));\n\n  await ioHelper.defaults.info(`Using the latest successful scan which is ${days} days, ${hours} hours, and ${minutes} minutes old.`);\n}\n\n/**\n * Writes a migrate.json file to the output directory.\n *\n * @param outputPath - The path to write the migrate.json file to\n * @param stackName - The name of the stack\n * @param generatedOutput - The output of the template generator\n */\nexport function writeMigrateJsonFile(\n  outputPath: string | undefined,\n  stackName: string,\n  migrateJson: MigrateJsonFormat,\n) {\n  const outputToJson = {\n    '//': 'This file is generated by cdk migrate. It will be automatically deleted after the first successful deployment of this app to the environment of the original resources.',\n    'Source': migrateJson.source,\n    'Resources': migrateJson.resources,\n  };\n  fs.writeFileSync(\n    `${path.join(outputPath ?? process.cwd(), stackName)}/migrate.json`,\n    JSON.stringify(outputToJson, null, 2),\n  );\n}\n\n/**\n * Takes a string representing the from-scan flag and returns a FromScan enum value.\n *\n * @param scanType - A string representing the from-scan flag\n * @returns A FromScan enum value\n */\nexport function getMigrateScanType(scanType: string) {\n  switch (scanType) {\n    case 'new':\n      return FromScan.NEW;\n    case 'most-recent':\n      return FromScan.MOST_RECENT;\n    case '':\n      return FromScan.DEFAULT;\n    case undefined:\n      return FromScan.DEFAULT;\n    default:\n      throw new ToolkitError('UnknownScanType', `Unknown scan type: ${scanType}`);\n  }\n}\n\n/**\n * Takes a generatedTemplateOutput objct and returns a boolean representing whether there are any warnings on any rescources.\n *\n * @param generatedTemplateOutput - A GenerateTemplateOutput object\n * @returns A boolean representing whether there are any warnings on any rescources\n */\nexport function isThereAWarning(generatedTemplateOutput: GenerateTemplateOutput) {\n  if (generatedTemplateOutput.resources) {\n    for (const resource of generatedTemplateOutput.resources) {\n      if (resource.Warnings && resource.Warnings.length > 0) {\n        return true;\n      }\n    }\n  }\n  return false;\n}\n\n/**\n * Builds the GenerateTemplateOutput object from the DescribeGeneratedTemplateOutput and the template body.\n *\n * @param generatedTemplateSummary - The output of the describe generated template call\n * @param templateBody - The body of the generated template\n * @returns A GenerateTemplateOutput object\n */\nexport function buildGeneratedTemplateOutput(\n  generatedTemplateSummary: DescribeGeneratedTemplateCommandOutput,\n  templateBody: string,\n  source: string,\n): GenerateTemplateOutput {\n  const resources: ResourceDetail[] | undefined = generatedTemplateSummary.Resources;\n  const migrateJson: MigrateJsonFormat = {\n    templateBody: templateBody,\n    source: source,\n    resources: generatedTemplateSummary.Resources!.map((r) => ({\n      ResourceType: r.ResourceType!,\n      LogicalResourceId: r.LogicalResourceId!,\n      ResourceIdentifier: r.ResourceIdentifier!,\n    })),\n  };\n  const templateId = generatedTemplateSummary.GeneratedTemplateId!;\n  return {\n    migrateJson: migrateJson,\n    resources: resources,\n    templateId: templateId,\n  };\n}\n\n/**\n * Builds a CloudFormation sdk client for making requests with the CFN template generator.\n *\n * @param sdkProvider - The sdk provider for making CloudFormation calls\n * @param environment - The account and region where the stack is deployed\n * @returns A CloudFormation sdk client\n */\nexport async function buildCfnClient(sdkProvider: SdkProvider, environment: Environment) {\n  const sdk = (await sdkProvider.forEnvironment(environment, Mode.ForReading)).sdk;\n  sdk.appendCustomUserAgent('cdk-migrate');\n  return sdk.cloudFormation();\n}\n\n/**\n * Appends a list of warnings to a readme file.\n *\n * @param filepath - The path to the readme file\n * @param resources - A list of resources to append warnings for\n */\nexport function appendWarningsToReadme(filepath: string, resources: ResourceDetail[]) {\n  const readme = fs.readFileSync(filepath, 'utf8');\n  const lines = readme.split('\\n');\n  const index = lines.findIndex((line) => line.trim() === 'Enjoy!');\n  let linesToAdd = ['\\n## Warnings'];\n  linesToAdd.push('### Write-only properties');\n  linesToAdd.push(\n    \"Write-only properties are resource property values that can be written to but can't be read by AWS CloudFormation or CDK Migrate. For more information, see [IaC generator and write-only properties](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/generate-IaC-write-only-properties.html).\",\n  );\n  linesToAdd.push('\\n');\n  linesToAdd.push(\n    'Write-only properties discovered during migration are organized here by resource ID and categorized by write-only property type. Resolve write-only properties by providing property values in your CDK app. For guidance, see [Resolve write-only properties](https://docs.aws.amazon.com/cdk/v2/guide/migrate.html#migrate-resources-writeonly).',\n  );\n  for (const resource of resources) {\n    if (resource.Warnings && resource.Warnings.length > 0) {\n      linesToAdd.push(`### ${resource.LogicalResourceId}`);\n      for (const warning of resource.Warnings) {\n        linesToAdd.push(`- **${warning.Type}**: `);\n        for (const property of warning.Properties!) {\n          linesToAdd.push(`  - ${property.PropertyPath}: ${property.Description}`);\n        }\n      }\n    }\n  }\n  lines.splice(index, 0, ...linesToAdd);\n  fs.writeFileSync(filepath, lines.join('\\n'));\n}\n\n/**\n * takes a list of resources and returns a list of unique resources based on the resource type and logical resource id.\n *\n * @param resources - A list of resources to deduplicate\n * @returns A list of unique resources\n */\nfunction deduplicateResources(resources: ResourceDetail[]) {\n  let uniqueResources: { [key: string]: ResourceDetail } = {};\n\n  for (const resource of resources) {\n    const key = Object.keys(resource.ResourceIdentifier!)[0];\n\n    // Creating our unique identifier using the resource type, the key, and the value of the resource identifier\n    // The resource identifier is a combination of a key value pair defined by a resource's schema, and the resource type of the resource.\n    const uniqueIdentifer = `${resource.ResourceType}:${key}:${resource.ResourceIdentifier![key]}`;\n    uniqueResources[uniqueIdentifer] = resource;\n  }\n\n  return Object.values(uniqueResources);\n}\n\n/**\n * Class for making CloudFormation template generator calls\n */\nexport class CfnTemplateGeneratorProvider {\n  private cfn: ICloudFormationClient;\n  private ioHelper: IoHelper;\n  constructor(cfn: ICloudFormationClient, ioHelper: IoHelper) {\n    this.cfn = cfn;\n    this.ioHelper = ioHelper;\n  }\n\n  async checkForResourceScan(\n    resourceScanSummaries: ResourceScanSummary[] | undefined,\n    options: GenerateTemplateOptions,\n    clientRequestToken: string,\n  ) {\n    if (!resourceScanSummaries || resourceScanSummaries.length === 0) {\n      if (options.fromScan === FromScan.MOST_RECENT) {\n        throw new ToolkitError(\n          'NoScansFound',\n          'No scans found. Please either start a new scan with the `--from-scan` new or do not specify a `--from-scan` option.',\n        );\n      } else {\n        await this.ioHelper.defaults.info('No scans found. Initiating a new resource scan.');\n        await this.startResourceScan(clientRequestToken);\n      }\n    }\n  }\n\n  /**\n   * Retrieves a tokenized list of resources and their associated scan. If a token is present the function\n   * will loop through all pages and combine them into a single list of ScannedRelatedResources\n   *\n   * @param scanId - scan id for the to list resources for\n   * @param resources - A list of resources to find related resources for\n   */\n  async getResourceScanRelatedResources(\n    scanId: string,\n    resources: ScannedResource[],\n  ): Promise<ScannedResourceIdentifier[]> {\n    let relatedResourceList = resources;\n\n    // break the list of resources into chunks of 100 to avoid hitting the 100 resource limit\n    for (const chunk of chunks(resources, 100)) {\n      // get the first page of related resources\n      const res = await this.cfn.listResourceScanRelatedResources({\n        ResourceScanId: scanId,\n        Resources: chunk,\n      });\n\n      // add the first page to the list\n      relatedResourceList.push(...(res.RelatedResources ?? []));\n      let nextToken = res.NextToken;\n\n      // if there are more pages, cycle through them and add them to the list before moving on to the next chunk\n      while (nextToken) {\n        const nextRelatedResources = await this.cfn.listResourceScanRelatedResources({\n          ResourceScanId: scanId,\n          Resources: resourceIdentifiers(resources),\n          NextToken: nextToken,\n        });\n        nextToken = nextRelatedResources.NextToken;\n        relatedResourceList.push(...(nextRelatedResources.RelatedResources ?? []));\n      }\n    }\n\n    relatedResourceList = deduplicateResources(relatedResourceList);\n\n    // prune the managedbystack flag off of them again.\n    return process.env.MIGRATE_INTEG_TEST\n      ? resourceIdentifiers(relatedResourceList)\n      : resourceIdentifiers(excludeManaged(relatedResourceList));\n  }\n\n  /**\n   * Kicks off a scan of a customers account, returning the scan id. A scan can take\n   * 10 minutes or longer to complete. However this will return a scan id as soon as\n   * the scan has begun.\n   *\n   * @returns A string representing the scan id\n   */\n  async startResourceScan(requestToken: string) {\n    return (\n      await this.cfn.startResourceScan({\n        ClientRequestToken: requestToken,\n      })\n    ).ResourceScanId;\n  }\n\n  /**\n   * Gets the most recent scans a customer has completed\n   *\n   * @returns a list of resource scan summaries\n   */\n  async listResourceScans() {\n    return this.cfn.listResourceScans();\n  }\n\n  /**\n   * Retrieves a tokenized list of resources from a resource scan. If a token is present, this function\n   * will loop through all pages and combine them into a single list of ScannedResource[].\n   * Additionally will apply any filters provided by the customer.\n   *\n   * @param scanId - scan id for the to list resources for\n   * @param filters - a string of filters in the format of key1=value1,key2=value2\n   * @returns a combined list of all resources from the scan\n   */\n  async listResourceScanResources(scanId: string, filters: string[] = []): Promise<ScannedResourceIdentifier[]> {\n    let resourceList: ScannedResource[] = [];\n    let resourceScanInputs: ListResourceScanResourcesCommandInput;\n\n    if (filters.length > 0) {\n      await this.ioHelper.defaults.info('Applying filters to resource scan.');\n      for (const filter of filters) {\n        const filterList = parseFilters(filter);\n        resourceScanInputs = {\n          ResourceScanId: scanId,\n          ResourceIdentifier: filterList[FilterType.RESOURCE_IDENTIFIER],\n          ResourceTypePrefix: filterList[FilterType.RESOURCE_TYPE_PREFIX],\n          TagKey: filterList[FilterType.TAG_KEY],\n          TagValue: filterList[FilterType.TAG_VALUE],\n        };\n        const resources = await this.cfn.listResourceScanResources(resourceScanInputs);\n        resourceList = resourceList.concat(resources.Resources ?? []);\n        let nextToken = resources.NextToken;\n\n        // cycle through the pages adding all resources to the list until we run out of pages\n        while (nextToken) {\n          resourceScanInputs.NextToken = nextToken;\n          const nextResources = await this.cfn.listResourceScanResources(resourceScanInputs);\n          nextToken = nextResources.NextToken;\n          resourceList = resourceList!.concat(nextResources.Resources ?? []);\n        }\n      }\n    } else {\n      await this.ioHelper.defaults.info('No filters provided. Retrieving all resources from scan.');\n      resourceScanInputs = {\n        ResourceScanId: scanId,\n      };\n      const resources = await this.cfn.listResourceScanResources(resourceScanInputs);\n      resourceList = resourceList!.concat(resources.Resources ?? []);\n      let nextToken = resources.NextToken;\n\n      // cycle through the pages adding all resources to the list until we run out of pages\n      while (nextToken) {\n        resourceScanInputs.NextToken = nextToken;\n        const nextResources = await this.cfn.listResourceScanResources(resourceScanInputs);\n        nextToken = nextResources.NextToken;\n        resourceList = resourceList!.concat(nextResources.Resources ?? []);\n      }\n    }\n    if (resourceList.length === 0) {\n      throw new ToolkitError('NoResourcesFound', `No resources found with filters ${filters.join(' ')}. Please try again with different filters.`);\n    }\n    resourceList = deduplicateResources(resourceList);\n\n    return process.env.MIGRATE_INTEG_TEST\n      ? resourceIdentifiers(resourceList)\n      : resourceIdentifiers(excludeManaged(resourceList));\n  }\n\n  /**\n   * Retrieves information about a resource scan.\n   *\n   * @param scanId - scan id for the to list resources for\n   * @returns information about the scan\n   */\n  async describeResourceScan(scanId: string): Promise<DescribeResourceScanCommandOutput> {\n    return this.cfn.describeResourceScan({\n      ResourceScanId: scanId,\n    });\n  }\n\n  /**\n   * Describes the current status of the template being generated.\n   *\n   * @param templateId - A string representing the template id\n   * @returns DescribeGeneratedTemplateOutput an object containing the template status and results\n   */\n  async describeGeneratedTemplate(templateId: string): Promise<DescribeGeneratedTemplateCommandOutput> {\n    const generatedTemplate = await this.cfn.describeGeneratedTemplate({\n      GeneratedTemplateName: templateId,\n    });\n\n    if (generatedTemplate.Status == ScanStatus.FAILED) {\n      throw new ToolkitError('TemplateGenerationFailed', generatedTemplate.StatusReason!);\n    }\n\n    return generatedTemplate;\n  }\n\n  /**\n   * Retrieves a completed generated cloudformation template from the template generator.\n   *\n   * @param templateId - A string representing the template id\n   * @param cloudFormation - The CloudFormation sdk client to use\n   * @returns DescribeGeneratedTemplateOutput an object containing the template status and body\n   */\n  async getGeneratedTemplate(templateId: string): Promise<GetGeneratedTemplateCommandOutput> {\n    return this.cfn.getGeneratedTemplate({\n      GeneratedTemplateName: templateId,\n    });\n  }\n\n  /**\n   * Kicks off a template generation for a set of resources.\n   *\n   * @param stackName - The name of the stack\n   * @param resources - A list of resources to generate the template from\n   * @returns CreateGeneratedTemplateOutput an object containing the template arn to query on later\n   */\n  async createGeneratedTemplate(stackName: string, resources: ResourceDefinition[]) {\n    const createTemplateOutput = await this.cfn.createGeneratedTemplate({\n      Resources: resources,\n      GeneratedTemplateName: stackName,\n    });\n\n    if (createTemplateOutput.GeneratedTemplateId === undefined) {\n      throw new ToolkitError('MissingTemplateArn', 'CreateGeneratedTemplate failed to return an Arn.');\n    }\n    return createTemplateOutput;\n  }\n\n  /**\n   * Deletes a generated template from the template generator.\n   *\n   * @param templateArn - The arn of the template to delete\n   * @returns A promise that resolves when the template has been deleted\n   */\n  async deleteGeneratedTemplate(templateArn: string): Promise<void> {\n    await this.cfn.deleteGeneratedTemplate({\n      GeneratedTemplateName: templateArn,\n    });\n  }\n}\n\n/**\n * The possible ways to choose a scan to generate a CDK application from\n */\nexport enum FromScan {\n  /**\n   * Initiate a new resource scan to build the CDK application from.\n   */\n  NEW,\n\n  /**\n   * Use the last successful scan to build the CDK application from. Will fail if no scan is found.\n   */\n  MOST_RECENT,\n\n  /**\n   * Starts a scan if none exists, otherwise uses the most recent successful scan to build the CDK application from.\n   */\n  DEFAULT,\n}\n\n/**\n * Interface for the options object passed to the generateTemplate function\n *\n * @param stackName - The name of the stack\n * @param filters - A list of filters to apply to the scan\n * @param fromScan - An enum value specifying whether a new scan should be started or the most recent successful scan should be used\n * @param sdkProvider - The sdk provider for making CloudFormation calls\n * @param environment - The account and region where the stack is deployed\n */\nexport interface GenerateTemplateOptions {\n  stackName: string;\n  filters?: string[];\n  fromScan?: FromScan;\n  sdkProvider: SdkProvider;\n  environment: Environment;\n  ioHelper: IoHelper;\n}\n\n/**\n * Interface for the output of the generateTemplate function\n *\n * @param migrateJson - The generated Migrate.json file\n * @param resources - The generated template\n */\nexport interface GenerateTemplateOutput {\n  migrateJson: MigrateJsonFormat;\n  resources?: ResourceDetail[];\n  templateId?: string;\n}\n\n/**\n * Interface defining the format of the generated Migrate.json file\n *\n * @param TemplateBody - The generated template\n * @param Source - The source of the template\n * @param Resources - A list of resources that were used to generate the template\n */\nexport interface MigrateJsonFormat {\n  templateBody: string;\n  source: string;\n  resources?: GeneratedResourceImportIdentifier[];\n}\n\n/**\n * Interface representing the format of a resource identifier required for resource import\n *\n * @param ResourceType - The type of resource\n * @param LogicalResourceId - The logical id of the resource\n * @param ResourceIdentifier - The resource identifier of the resource\n */\nexport interface GeneratedResourceImportIdentifier {\n  // cdk deploy expects the migrate.json resource identifiers to be PascalCase, not camelCase.\n  ResourceType: string;\n  LogicalResourceId: string;\n  ResourceIdentifier: ResourceIdentifierSummary;\n}\n"]}
|