"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"]}