From 0620818abcf7b87122a5d6bdc8c777c748f532b4 Mon Sep 17 00:00:00 2001 From: Leonardo Gama Date: Thu, 1 May 2025 11:11:09 -0700 Subject: [PATCH 01/31] Add drift detection to cdk diff --- .../cloudformation-diff/lib/format.ts | 78 +++++++++- .../src/api/aws-auth/sdk.ts | 24 ++++ .../src/api/deployments/cfn-api.ts | 82 +++++++++++ .../src/api/diff/diff-formatter.ts | 68 ++++++++- .../test/api/diff/diff.test.ts | 136 ++++++++++++++++++ packages/aws-cdk/lib/cli/cdk-toolkit.ts | 36 ++++- packages/aws-cdk/lib/cli/cli-config.ts | 1 + packages/aws-cdk/lib/cli/cli.ts | 1 + .../aws-cdk/lib/cli/convert-to-user-input.ts | 2 + .../lib/cli/parse-command-line-arguments.ts | 5 + packages/aws-cdk/lib/cli/user-input.ts | 7 + 11 files changed, 435 insertions(+), 5 deletions(-) diff --git a/packages/@aws-cdk/cloudformation-diff/lib/format.ts b/packages/@aws-cdk/cloudformation-diff/lib/format.ts index bbfd621df..0390bdf93 100644 --- a/packages/@aws-cdk/cloudformation-diff/lib/format.ts +++ b/packages/@aws-cdk/cloudformation-diff/lib/format.ts @@ -1,9 +1,10 @@ import { format } from 'util'; +import type { DescribeStackResourceDriftsCommandOutput } from '@aws-sdk/client-cloudformation'; import * as chalk from 'chalk'; import type { DifferenceCollection, TemplateDiff } from './diff/types'; import { deepEqual } from './diff/util'; -import type { Difference, ResourceDifference } from './diff-template'; -import { isPropertyDifference, ResourceImpact } from './diff-template'; +import type { ResourceDifference } from './diff-template'; +import { isPropertyDifference, ResourceImpact, Difference } from './diff-template'; import { formatTable } from './format-table'; import type { IamChanges } from './iam/iam-changes'; import type { SecurityGroupChanges } from './network/security-group-changes'; @@ -19,6 +20,16 @@ export interface FormatStream extends NodeJS.WritableStream { columns?: number; } +/** + * Resource drift status types from CloudFormation + */ +export enum ResourceDriftStatus { + MODIFIED = 'MODIFIED', + DELETED = 'DELETED', + NOT_CHECKED = 'NOT_CHECKED', + IN_SYNC = 'IN_SYNC', +} + /** * Renders template differences to the process' console. * @@ -67,6 +78,69 @@ export function formatSecurityChanges( formatSecurityChangesWithBanner(formatter, templateDiff); } +/** + * Renders stack drift information to the given stream + * + * @param stream The stream to write the formatted drift to + * @param driftResults The stack resource drifts from CloudFormation + * @param logicalToPathMap A map from logical ID to construct path + */ +export function formatStackDriftChanges( + stream: FormatStream, + driftResults: DescribeStackResourceDriftsCommandOutput, + logicalToPathMap: { [logicalId: string]: string } = {}) { + const formatter = new Formatter(stream, logicalToPathMap); + + if (!driftResults.StackResourceDrifts || driftResults.StackResourceDrifts.length === 0) { + return; + } + + const drifts = driftResults.StackResourceDrifts; + + // Process modified resources + const modifiedResources = drifts.filter(d => d.StackResourceDriftStatus === ResourceDriftStatus.MODIFIED); + if (modifiedResources.length > 0) { + formatter.printSectionHeader('Modified Resources'); + + for (const drift of modifiedResources) { + if (!drift.LogicalResourceId || !drift.ResourceType) continue; + + // Print the resource header + formatter.print(`${UPDATE} ${formatter.formatValue(drift.ResourceType, chalk.cyan)} ${formatter.formatLogicalId(drift.LogicalResourceId)}`); + + // Format property differences using formatTreeDiff + if (drift.PropertyDifferences) { + const propDiffs = drift.PropertyDifferences; + for (let i = 0; i < propDiffs.length; i++) { + const diff = propDiffs[i]; + if (!diff.PropertyPath) continue; + + // Create a simple Difference object that formatTreeDiff can handle + const difference = new Difference(diff.ExpectedValue, diff.ActualValue); + + // Use formatTreeDiff to format the property difference + formatter.formatTreeDiff(diff.PropertyPath, difference, i === propDiffs.length - 1); + } + } + } + formatter.printSectionFooter(); + } + + // Process deleted resources + const deletedResources = drifts.filter(d => d.StackResourceDriftStatus === ResourceDriftStatus.DELETED); + if (deletedResources.length > 0) { + formatter.printSectionHeader('Deleted Resources'); + + for (const drift of deletedResources) { + if (!drift.LogicalResourceId || !drift.ResourceType) continue; + + // Use formatter's print method for consistent output + formatter.print(`${REMOVAL} ${formatter.formatValue(drift.ResourceType, chalk.cyan)} ${formatter.formatLogicalId(drift.LogicalResourceId)}`); + } + formatter.printSectionFooter(); + } +} + function formatSecurityChangesWithBanner(formatter: Formatter, templateDiff: TemplateDiff) { if (!templateDiff.iamChanges.hasChanges && !templateDiff.securityGroupChanges.hasChanges) { return; diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/src/api/aws-auth/sdk.ts b/packages/@aws-cdk/tmp-toolkit-helpers/src/api/aws-auth/sdk.ts index 0c6fd1fb0..11a845fd9 100644 --- a/packages/@aws-cdk/tmp-toolkit-helpers/src/api/aws-auth/sdk.ts +++ b/packages/@aws-cdk/tmp-toolkit-helpers/src/api/aws-auth/sdk.ts @@ -88,6 +88,14 @@ import type { UpdateTerminationProtectionCommandInput, UpdateTerminationProtectionCommandOutput, StackSummary, + DescribeStackDriftDetectionStatusCommandInput, + DescribeStackDriftDetectionStatusCommandOutput, + DescribeStackResourceDriftsCommandOutput, + DetectStackDriftCommandInput, + DetectStackDriftCommandOutput, + DetectStackResourceDriftCommandInput, + DetectStackResourceDriftCommandOutput, + DescribeStackResourceDriftsCommandInput, } from '@aws-sdk/client-cloudformation'; import { paginateListStacks, @@ -119,6 +127,10 @@ import { StartResourceScanCommand, UpdateStackCommand, UpdateTerminationProtectionCommand, + DescribeStackDriftDetectionStatusCommand, + DescribeStackResourceDriftsCommand, + DetectStackDriftCommand, + DetectStackResourceDriftCommand, } from '@aws-sdk/client-cloudformation'; import type { FilterLogEventsCommandInput, @@ -418,8 +430,12 @@ export interface ICloudFormationClient { input: DescribeGeneratedTemplateCommandInput, ): Promise; describeResourceScan(input: DescribeResourceScanCommandInput): Promise; + describeStackDriftDetectionStatus(input: DescribeStackDriftDetectionStatusCommandInput): Promise; describeStacks(input: DescribeStacksCommandInput): Promise; + describeStackResourceDrifts(input: DescribeStackResourceDriftsCommandInput): Promise; describeStackResources(input: DescribeStackResourcesCommandInput): Promise; + detectStackDrift(input: DetectStackDriftCommandInput): Promise; + detectStackResourceDrift(input: DetectStackResourceDriftCommandInput): Promise; executeChangeSet(input: ExecuteChangeSetCommandInput): Promise; getGeneratedTemplate(input: GetGeneratedTemplateCommandInput): Promise; getTemplate(input: GetTemplateCommandInput): Promise; @@ -680,6 +696,10 @@ export class SDK { ): Promise => client.send(new DeleteGeneratedTemplateCommand(input)), deleteStack: (input: DeleteStackCommandInput): Promise => client.send(new DeleteStackCommand(input)), + detectStackDrift: (input: DetectStackDriftCommandInput): Promise => + client.send(new DetectStackDriftCommand(input)), + detectStackResourceDrift: (input: DetectStackResourceDriftCommandInput): Promise => + client.send(new DetectStackResourceDriftCommand(input)), describeChangeSet: (input: DescribeChangeSetCommandInput): Promise => client.send(new DescribeChangeSetCommand(input)), describeGeneratedTemplate: ( @@ -687,6 +707,10 @@ export class SDK { ): Promise => client.send(new DescribeGeneratedTemplateCommand(input)), describeResourceScan: (input: DescribeResourceScanCommandInput): Promise => client.send(new DescribeResourceScanCommand(input)), + describeStackDriftDetectionStatus: (input: DescribeStackDriftDetectionStatusCommandInput): + Promise => client.send(new DescribeStackDriftDetectionStatusCommand(input)), + describeStackResourceDrifts: (input: DescribeStackResourceDriftsCommandInput): Promise => + client.send(new DescribeStackResourceDriftsCommand(input)), describeStacks: (input: DescribeStacksCommandInput): Promise => client.send(new DescribeStacksCommand(input)), describeStackResources: (input: DescribeStackResourcesCommandInput): Promise => diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/src/api/deployments/cfn-api.ts b/packages/@aws-cdk/tmp-toolkit-helpers/src/api/deployments/cfn-api.ts index 82453f361..92b5bca9f 100644 --- a/packages/@aws-cdk/tmp-toolkit-helpers/src/api/deployments/cfn-api.ts +++ b/packages/@aws-cdk/tmp-toolkit-helpers/src/api/deployments/cfn-api.ts @@ -3,6 +3,8 @@ import * as cxapi from '@aws-cdk/cx-api'; import { SSMPARAM_NO_INVALIDATE } from '@aws-cdk/cx-api'; import type { DescribeChangeSetCommandOutput, + DescribeStackDriftDetectionStatusCommandOutput, + DescribeStackResourceDriftsCommandOutput, Parameter, ResourceToImport, Tag, @@ -466,6 +468,86 @@ export async function stabilizeStack( }); } +/** + * Detect drift for a CloudFormation stack and wait for the detection to complete + * + * @param cfn a CloudFormation client + * @param ioHelper helper for IO operations + * @param stackName the name of the stack to check for drift + * + * @returns the CloudFormation description of the drift detection results + */ +export async function detectStackDrift( + cfn: ICloudFormationClient, + ioHelper: IoHelper, + stackName: string, +): Promise { + await ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(format('Starting drift detection for stack %s...', stackName))); + + // Start drift detection + const driftDetection = await cfn.detectStackDrift({ + StackName: stackName, + }); + + // Wait for drift detection to complete + const driftStatus = await waitForDriftDetection(cfn, ioHelper, driftDetection.StackDriftDetectionId!); + + if (!driftStatus) { + throw new ToolkitError('Drift detection took too long to complete. Aborting'); + } + + if (driftStatus?.DetectionStatus === 'DETECTION_FAILED') { + throw new ToolkitError( + `Failed to detect drift for stack ${stackName}: ${driftStatus.DetectionStatusReason || 'No reason provided'}`, + ); + } + + // Get the drift results + return cfn.describeStackResourceDrifts({ + StackName: stackName, + }); +} + +/** + * Wait for a drift detection operation to complete + */ +async function waitForDriftDetection( + cfn: ICloudFormationClient, + ioHelper: IoHelper, + driftDetectionId: string, +): Promise { + await ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(format('Waiting for drift detection %s to complete...', driftDetectionId))); + + const maxDelay = 30_000; // 30 seconds max delay + let baseDelay = 1_000; // Start with 1 second + let attempts = 0; + + while (true) { + const response = await cfn.describeStackDriftDetectionStatus({ + StackDriftDetectionId: driftDetectionId, + }); + + if (response.DetectionStatus === 'DETECTION_COMPLETE') { + return response; + } + + if (response.DetectionStatus === 'DETECTION_FAILED') { + throw new ToolkitError(`Drift detection failed: ${response.DetectionStatusReason}`); + } + + if (attempts++ > 30) { + throw new ToolkitError('Drift detection timed out after 30 attempts'); + } + + // Calculate backoff with jitter + const jitter = Math.random() * 1000; + const delay = Math.min(baseDelay + jitter, maxDelay); + await new Promise(resolve => setTimeout(resolve, delay)); + baseDelay *= 2; + attempts++; + } +} + /** * The set of (formal) parameters that have been declared in a template */ diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/src/api/diff/diff-formatter.ts b/packages/@aws-cdk/tmp-toolkit-helpers/src/api/diff/diff-formatter.ts index 3a90e521d..3731fac8c 100644 --- a/packages/@aws-cdk/tmp-toolkit-helpers/src/api/diff/diff-formatter.ts +++ b/packages/@aws-cdk/tmp-toolkit-helpers/src/api/diff/diff-formatter.ts @@ -6,8 +6,10 @@ import { fullDiff, mangleLikeCloudFormation, type TemplateDiff, + formatStackDriftChanges, } from '@aws-cdk/cloudformation-diff'; import type * as cxapi from '@aws-cdk/cx-api'; +import type { DescribeStackResourceDriftsCommandOutput } from '@aws-sdk/client-cloudformation'; import * as chalk from 'chalk'; import type { NestedStackTemplates } from '../cloudformation'; import type { IoHelper } from '../io/private'; @@ -41,6 +43,21 @@ interface FormatStackDiffOutput { readonly formattedDiff: string; } +/** + * Output of formatStackDrift + */ +interface FormatStackDriftOutput { + /** + * Number of stacks with drift + */ + readonly numResourcesWithDrift: number; + + /** + * Complete formatted drift + */ + readonly formattedDrift: string; +} + /** * Props for the Diff Formatter */ @@ -55,6 +72,11 @@ interface DiffFormatterProps { * Includes the old/current state of the stack as well as the new state. */ readonly templateInfo: TemplateInfo; + + /** + * The results of stack drift + */ + readonly driftResults?: DescribeStackResourceDriftsCommandOutput; } /** @@ -68,7 +90,7 @@ interface FormatSecurityDiffOptions { } /** - * PRoperties specific to formatting the stack diff + * Properties specific to formatting the stack diff */ interface FormatStackDiffOptions { /** @@ -93,6 +115,16 @@ interface FormatStackDiffOptions { readonly quiet?: boolean; } +/** + * Properties specific to formatting the stack drift diff + */ +interface FormatStackDriftOptions { + /** + * Silences 'There were no differences' messages + */ + readonly quiet?: boolean; +} + interface ReusableStackDiffOptions extends FormatStackDiffOptions { readonly ioDefaultHelper: IoDefaultMessages; } @@ -147,6 +179,7 @@ export class DiffFormatter { private readonly stackName: string; private readonly changeSet?: any; private readonly nestedStacks: { [nestedStackLogicalId: string]: NestedStackTemplates } | undefined; + private readonly driftResults?: DescribeStackResourceDriftsCommandOutput; private readonly isImport: boolean; /** @@ -162,6 +195,7 @@ export class DiffFormatter { this.stackName = props.templateInfo.newTemplate.stackName; this.changeSet = props.templateInfo.changeSet; this.nestedStacks = props.templateInfo.nestedStacks; + this.driftResults = props.driftResults; this.isImport = props.templateInfo.isImport ?? false; } @@ -308,6 +342,38 @@ export class DiffFormatter { } return {}; } + + public formatStackDrift(options: FormatStackDriftOptions): FormatStackDriftOutput { + const stream = new StringWriteStream(); + let driftCount = 0; + + if (!this.driftResults?.StackResourceDrifts) { + return { formattedDrift: '', numResourcesWithDrift: 0 }; + } + + const drifts = this.driftResults.StackResourceDrifts; + + if (drifts.length === 0 && !options.quiet) { + stream.write(chalk.green('No drift detected\n')); + stream.end(); + return { formattedDrift: stream.toString(), numResourcesWithDrift: 0 }; + } + + // Count resources with drift + driftCount = drifts.filter(d => + d.StackResourceDriftStatus === 'MODIFIED' || + d.StackResourceDriftStatus === 'DELETED', + ).length; + + formatStackDriftChanges(stream, this.driftResults, buildLogicalToPathMap(this.newTemplate)); + stream.write(chalk.yellow(`\n${driftCount} resource${driftCount === 1 ? '' : 's'} ${driftCount === 1 ? 'has' : 'have'} drifted from their expected configuration\n`)); + stream.end(); + + return { + formattedDrift: stream.toString(), + numResourcesWithDrift: driftCount, + }; + } } /** diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/test/api/diff/diff.test.ts b/packages/@aws-cdk/tmp-toolkit-helpers/test/api/diff/diff.test.ts index bfe0bcd66..fbcc90e87 100644 --- a/packages/@aws-cdk/tmp-toolkit-helpers/test/api/diff/diff.test.ts +++ b/packages/@aws-cdk/tmp-toolkit-helpers/test/api/diff/diff.test.ts @@ -1,4 +1,5 @@ import type * as cxapi from '@aws-cdk/cx-api'; +import type { DescribeStackResourceDriftsCommandOutput } from '@aws-sdk/client-cloudformation'; import * as chalk from 'chalk'; import { DiffFormatter } from '../../../src/api/diff/diff-formatter'; import { IoHelper, IoDefaultMessages } from '../../../src/api/io/private'; @@ -321,3 +322,138 @@ describe('formatSecurityDiff', () => { expect(mockIoDefaultMessages.warning).not.toHaveBeenCalled(); }); }); + +describe('formatStackDrift', () => { + let mockIoHelper: IoHelper; + let mockNewTemplate: cxapi.CloudFormationStackArtifact; + let mockIoDefaultMessages: any; + + beforeEach(() => { + const mockNotify = jest.fn().mockResolvedValue(undefined); + const mockRequestResponse = jest.fn().mockResolvedValue(undefined); + + mockIoHelper = IoHelper.fromIoHost( + { notify: mockNotify, requestResponse: mockRequestResponse }, + 'diff', + ); + + mockIoDefaultMessages = { + info: jest.fn(), + warning: jest.fn(), + error: jest.fn(), + }; + + jest.spyOn(mockIoHelper, 'notify').mockImplementation(() => Promise.resolve()); + jest.spyOn(mockIoHelper, 'requestResponse').mockImplementation(() => Promise.resolve()); + + (IoDefaultMessages as jest.Mock).mockImplementation(() => mockIoDefaultMessages); + + mockNewTemplate = { + template: { + Resources: { + Func: { + Type: 'AWS::Lambda::Function', + Properties: { + Code: { + S3Bucket: 'BuckChuckets', + S3Key: 'some-key', + }, + Handler: 'index.handler', + Runtime: 'nodejs20.x', + Description: 'Some description', + }, + }, + }, + }, + templateFile: 'template.json', + stackName: 'test-stack', + findMetadataByType: () => [], + } as any; + }); + + test('detects drift', () => { + // GIVEN + const mockDriftedResources: DescribeStackResourceDriftsCommandOutput = { + StackResourceDrifts: [{ + StackId: 'some:stack:arn', + StackResourceDriftStatus: 'MODIFIED', + LogicalResourceId: 'GiveUpTheFunc', + PhysicalResourceId: 'gotta-have-that-func', + ResourceType: 'AWS::Lambda::Function', + PropertyDifferences: [{ + PropertyPath: '/Description', + ExpectedValue: 'Some description', + ActualValue: 'Tear the Roof Off the Sucker', + DifferenceType: 'NOT_EQUAL', + }], + Timestamp: new Date(2024, 5, 3, 13, 0, 0), + }], + $metadata: {}, + }; + + // WHEN + const formatter = new DiffFormatter({ + ioHelper: mockIoHelper, + templateInfo: { + oldTemplate: mockNewTemplate.template, + newTemplate: mockNewTemplate, + }, + driftResults: mockDriftedResources, + }); + const result = formatter.formatStackDrift({}); + + // THEN + expect(result.numResourcesWithDrift).toBe(1); + const expectedStringsInOutput = [ + 'Modified Resources', + 'AWS::Lambda::Function', + 'GiveUpTheFunc', + 'Description', + 'Some description', + 'Tear the Roof Off the Sucker', + '1 resource has drifted', + ]; + for (const expectedStringInOutput of expectedStringsInOutput) { + expect(result.formattedDrift).toContain(expectedStringInOutput); + } + }); + + test('no drift detected', () => { + // GIVEN + const mockDriftResults: DescribeStackResourceDriftsCommandOutput = { + StackResourceDrifts: [], + $metadata: {}, + }; + + // WHEN + const formatter = new DiffFormatter({ + ioHelper: mockIoHelper, + templateInfo: { + oldTemplate: mockNewTemplate.template, + newTemplate: mockNewTemplate, + }, + driftResults: mockDriftResults, + }); + const result = formatter.formatStackDrift({}); + + // THEN + expect(result.numResourcesWithDrift).toBe(0); + expect(result.formattedDrift).toContain('No drift detected'); + }); + + test('if detect drift is false, no output', () => { + // WHEN + const formatter = new DiffFormatter({ + ioHelper: mockIoHelper, + templateInfo: { + oldTemplate: mockNewTemplate.template, + newTemplate: mockNewTemplate, + }, + }); + const result = formatter.formatStackDrift({}); + + // THEN + expect(result.numResourcesWithDrift).toBe(0); + expect(result.formattedDrift).toBeFalsy(); + }); +}); diff --git a/packages/aws-cdk/lib/cli/cdk-toolkit.ts b/packages/aws-cdk/lib/cli/cdk-toolkit.ts index 1a4e198dc..a1d3d8bdb 100644 --- a/packages/aws-cdk/lib/cli/cdk-toolkit.ts +++ b/packages/aws-cdk/lib/cli/cdk-toolkit.ts @@ -14,9 +14,11 @@ import type { ToolkitAction } from '../../../@aws-cdk/tmp-toolkit-helpers/src/ap import { ambiguousMovements, findResourceMovements, + Mode, resourceMappings, ToolkitError, } from '../../../@aws-cdk/tmp-toolkit-helpers/src/api'; +import { detectStackDrift } from '../../../@aws-cdk/tmp-toolkit-helpers/src/api/deployments/cfn-api'; import { asIoHelper } from '../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private'; import { AmbiguityError } from '../../../@aws-cdk/tmp-toolkit-helpers/src/api/refactoring'; import type { ToolkitOptions } from '../../../@aws-cdk/toolkit-lib/lib/toolkit'; @@ -213,6 +215,7 @@ export class CdkToolkit { const quiet = options.quiet || false; let diffs = 0; + let drifts = 0; const parameterMap = buildParameterMap(options.parameters); if (options.templatePath !== undefined) { @@ -263,6 +266,19 @@ export class CdkToolkit { const currentTemplate = templateWithNestedStacks.deployedRootTemplate; const nestedStacks = templateWithNestedStacks.nestedStacks; + let driftResults = undefined; + + if (options.detectDrift) { + const env = await this.props.deployments.resolveEnvironment(stack); + const cfn = (await this.props.sdkProvider.forEnvironment(env, Mode.ForReading)).sdk.cloudFormation(); + + driftResults = await detectStackDrift( + cfn, + asIoHelper(this.ioHost, 'diff'), + stack.stackName, + ); + } + const migrator = new ResourceMigrator({ deployments: this.props.deployments, ioHelper: asIoHelper(this.ioHost, 'diff'), @@ -318,6 +334,7 @@ export class CdkToolkit { isImport: !!resourcesToImport, nestedStacks, }, + driftResults, }); if (options.securityOnly) { @@ -334,13 +351,21 @@ export class CdkToolkit { context: contextLines, quiet, }); - info(diff.formattedDiff); + const drift = formatter.formatStackDrift({ + quiet, + }); + info(diff.formattedDiff + '\n' + drift.formattedDrift); diffs += diff.numStacksWithChanges; + drifts = drift.numResourcesWithDrift; } } } - info(format('\n✨ Number of stacks with differences: %s\n', diffs)); + if (options.detectDrift) { + info(format('\n✨ Number of stacks with differences: %s\n✨ Number of resources with drift: %s\n', diffs, drifts)); + } else { + info(format('\n✨ Number of stacks with differences: %s\n', diffs)); + } return diffs && options.fail ? 1 : 0; } @@ -1472,6 +1497,13 @@ export interface DiffOptions { */ readonly securityOnly?: boolean; + /** + * Run drift detection on the stack as well + * + * @default false + */ + readonly detectDrift?: boolean; + /** * Whether to run the diff against the template after the CloudFormation Transforms inside it have been executed * (as opposed to the original template, the default, which contains the unprocessed Transforms). diff --git a/packages/aws-cdk/lib/cli/cli-config.ts b/packages/aws-cdk/lib/cli/cli-config.ts index e8cea579c..a5af8a46b 100644 --- a/packages/aws-cdk/lib/cli/cli-config.ts +++ b/packages/aws-cdk/lib/cli/cli-config.ts @@ -308,6 +308,7 @@ export async function makeConfig(): Promise { 'template': { type: 'string', desc: 'The path to the CloudFormation template to compare with', requiresArg: true }, 'strict': { type: 'boolean', desc: 'Do not filter out AWS::CDK::Metadata resources, mangled non-ASCII characters, or the CheckBootstrapVersionRule', default: false }, 'security-only': { type: 'boolean', desc: 'Only diff for broadened security changes', default: false }, + 'detect-drift': { type: 'boolean', desc: 'Whether or not to also run CloudFormation drift detection', default: false }, 'fail': { type: 'boolean', desc: 'Fail with exit code 1 in case of diff' }, 'processed': { type: 'boolean', desc: 'Whether to compare against the template with Transforms already processed', default: false }, 'quiet': { type: 'boolean', alias: 'q', desc: 'Do not print stack name and default message when there is no diff to stdout', default: false }, diff --git a/packages/aws-cdk/lib/cli/cli.ts b/packages/aws-cdk/lib/cli/cli.ts index fd15044af..c3f00cf3d 100644 --- a/packages/aws-cdk/lib/cli/cli.ts +++ b/packages/aws-cdk/lib/cli/cli.ts @@ -256,6 +256,7 @@ export async function exec(args: string[], synthesizer?: Synthesizer): Promise): any { type: 'boolean', desc: 'Only diff for broadened security changes', }) + .option('detect-drift', { + default: false, + type: 'boolean', + desc: 'Whether or not to also run CloudFormation drift detection', + }) .option('fail', { default: undefined, type: 'boolean', diff --git a/packages/aws-cdk/lib/cli/user-input.ts b/packages/aws-cdk/lib/cli/user-input.ts index 3083eb626..dd03c3646 100644 --- a/packages/aws-cdk/lib/cli/user-input.ts +++ b/packages/aws-cdk/lib/cli/user-input.ts @@ -1073,6 +1073,13 @@ export interface DiffOptions { */ readonly securityOnly?: boolean; + /** + * Whether or not to also run CloudFormation drift detection + * + * @default - false + */ + readonly detectDrift?: boolean; + /** * Fail with exit code 1 in case of diff * From 7c4e1fcda3af7763ec913def983f9edbc554709c Mon Sep 17 00:00:00 2001 From: Leonardo Gama Date: Thu, 1 May 2025 11:23:12 -0700 Subject: [PATCH 02/31] Fix output for no drifts --- .../src/api/diff/diff-formatter.ts | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-) diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/src/api/diff/diff-formatter.ts b/packages/@aws-cdk/tmp-toolkit-helpers/src/api/diff/diff-formatter.ts index 3731fac8c..fce80b52e 100644 --- a/packages/@aws-cdk/tmp-toolkit-helpers/src/api/diff/diff-formatter.ts +++ b/packages/@aws-cdk/tmp-toolkit-helpers/src/api/diff/diff-formatter.ts @@ -351,7 +351,10 @@ export class DiffFormatter { return { formattedDrift: '', numResourcesWithDrift: 0 }; } - const drifts = this.driftResults.StackResourceDrifts; + const drifts = this.driftResults.StackResourceDrifts.filter(d => + d.StackResourceDriftStatus === 'MODIFIED' || + d.StackResourceDriftStatus === 'DELETED', + ); if (drifts.length === 0 && !options.quiet) { stream.write(chalk.green('No drift detected\n')); @@ -359,12 +362,7 @@ export class DiffFormatter { return { formattedDrift: stream.toString(), numResourcesWithDrift: 0 }; } - // Count resources with drift - driftCount = drifts.filter(d => - d.StackResourceDriftStatus === 'MODIFIED' || - d.StackResourceDriftStatus === 'DELETED', - ).length; - + driftCount = drifts.length; formatStackDriftChanges(stream, this.driftResults, buildLogicalToPathMap(this.newTemplate)); stream.write(chalk.yellow(`\n${driftCount} resource${driftCount === 1 ? '' : 's'} ${driftCount === 1 ? 'has' : 'have'} drifted from their expected configuration\n`)); stream.end(); From 3caf9c985e7062308522e9af3df3d939bc8085a2 Mon Sep 17 00:00:00 2001 From: Leonardo Gama Date: Thu, 1 May 2025 11:11:09 -0700 Subject: [PATCH 03/31] Add drift detection to cdk diff --- .../cloudformation-diff/lib/format.ts | 78 +++++++++- .../toolkit-lib/lib/api/aws-auth/sdk.ts | 24 ++++ .../lib/api/deployments/cfn-api.ts | 82 +++++++++++ .../lib/api/diff/diff-formatter.ts | 83 +++++++++++ .../toolkit-lib/test/api/diff/diff.test.ts | 136 ++++++++++++++++++ packages/aws-cdk/lib/cli/cdk-toolkit.ts | 51 +++++-- packages/aws-cdk/lib/cli/cli-config.ts | 1 + packages/aws-cdk/lib/cli/cli.ts | 1 + .../aws-cdk/lib/cli/convert-to-user-input.ts | 2 + .../lib/cli/parse-command-line-arguments.ts | 5 + packages/aws-cdk/lib/cli/user-input.ts | 7 + 11 files changed, 454 insertions(+), 16 deletions(-) diff --git a/packages/@aws-cdk/cloudformation-diff/lib/format.ts b/packages/@aws-cdk/cloudformation-diff/lib/format.ts index bbfd621df..0390bdf93 100644 --- a/packages/@aws-cdk/cloudformation-diff/lib/format.ts +++ b/packages/@aws-cdk/cloudformation-diff/lib/format.ts @@ -1,9 +1,10 @@ import { format } from 'util'; +import type { DescribeStackResourceDriftsCommandOutput } from '@aws-sdk/client-cloudformation'; import * as chalk from 'chalk'; import type { DifferenceCollection, TemplateDiff } from './diff/types'; import { deepEqual } from './diff/util'; -import type { Difference, ResourceDifference } from './diff-template'; -import { isPropertyDifference, ResourceImpact } from './diff-template'; +import type { ResourceDifference } from './diff-template'; +import { isPropertyDifference, ResourceImpact, Difference } from './diff-template'; import { formatTable } from './format-table'; import type { IamChanges } from './iam/iam-changes'; import type { SecurityGroupChanges } from './network/security-group-changes'; @@ -19,6 +20,16 @@ export interface FormatStream extends NodeJS.WritableStream { columns?: number; } +/** + * Resource drift status types from CloudFormation + */ +export enum ResourceDriftStatus { + MODIFIED = 'MODIFIED', + DELETED = 'DELETED', + NOT_CHECKED = 'NOT_CHECKED', + IN_SYNC = 'IN_SYNC', +} + /** * Renders template differences to the process' console. * @@ -67,6 +78,69 @@ export function formatSecurityChanges( formatSecurityChangesWithBanner(formatter, templateDiff); } +/** + * Renders stack drift information to the given stream + * + * @param stream The stream to write the formatted drift to + * @param driftResults The stack resource drifts from CloudFormation + * @param logicalToPathMap A map from logical ID to construct path + */ +export function formatStackDriftChanges( + stream: FormatStream, + driftResults: DescribeStackResourceDriftsCommandOutput, + logicalToPathMap: { [logicalId: string]: string } = {}) { + const formatter = new Formatter(stream, logicalToPathMap); + + if (!driftResults.StackResourceDrifts || driftResults.StackResourceDrifts.length === 0) { + return; + } + + const drifts = driftResults.StackResourceDrifts; + + // Process modified resources + const modifiedResources = drifts.filter(d => d.StackResourceDriftStatus === ResourceDriftStatus.MODIFIED); + if (modifiedResources.length > 0) { + formatter.printSectionHeader('Modified Resources'); + + for (const drift of modifiedResources) { + if (!drift.LogicalResourceId || !drift.ResourceType) continue; + + // Print the resource header + formatter.print(`${UPDATE} ${formatter.formatValue(drift.ResourceType, chalk.cyan)} ${formatter.formatLogicalId(drift.LogicalResourceId)}`); + + // Format property differences using formatTreeDiff + if (drift.PropertyDifferences) { + const propDiffs = drift.PropertyDifferences; + for (let i = 0; i < propDiffs.length; i++) { + const diff = propDiffs[i]; + if (!diff.PropertyPath) continue; + + // Create a simple Difference object that formatTreeDiff can handle + const difference = new Difference(diff.ExpectedValue, diff.ActualValue); + + // Use formatTreeDiff to format the property difference + formatter.formatTreeDiff(diff.PropertyPath, difference, i === propDiffs.length - 1); + } + } + } + formatter.printSectionFooter(); + } + + // Process deleted resources + const deletedResources = drifts.filter(d => d.StackResourceDriftStatus === ResourceDriftStatus.DELETED); + if (deletedResources.length > 0) { + formatter.printSectionHeader('Deleted Resources'); + + for (const drift of deletedResources) { + if (!drift.LogicalResourceId || !drift.ResourceType) continue; + + // Use formatter's print method for consistent output + formatter.print(`${REMOVAL} ${formatter.formatValue(drift.ResourceType, chalk.cyan)} ${formatter.formatLogicalId(drift.LogicalResourceId)}`); + } + formatter.printSectionFooter(); + } +} + function formatSecurityChangesWithBanner(formatter: Formatter, templateDiff: TemplateDiff) { if (!templateDiff.iamChanges.hasChanges && !templateDiff.securityGroupChanges.hasChanges) { return; diff --git a/packages/@aws-cdk/toolkit-lib/lib/api/aws-auth/sdk.ts b/packages/@aws-cdk/toolkit-lib/lib/api/aws-auth/sdk.ts index 0c6fd1fb0..11a845fd9 100644 --- a/packages/@aws-cdk/toolkit-lib/lib/api/aws-auth/sdk.ts +++ b/packages/@aws-cdk/toolkit-lib/lib/api/aws-auth/sdk.ts @@ -88,6 +88,14 @@ import type { UpdateTerminationProtectionCommandInput, UpdateTerminationProtectionCommandOutput, StackSummary, + DescribeStackDriftDetectionStatusCommandInput, + DescribeStackDriftDetectionStatusCommandOutput, + DescribeStackResourceDriftsCommandOutput, + DetectStackDriftCommandInput, + DetectStackDriftCommandOutput, + DetectStackResourceDriftCommandInput, + DetectStackResourceDriftCommandOutput, + DescribeStackResourceDriftsCommandInput, } from '@aws-sdk/client-cloudformation'; import { paginateListStacks, @@ -119,6 +127,10 @@ import { StartResourceScanCommand, UpdateStackCommand, UpdateTerminationProtectionCommand, + DescribeStackDriftDetectionStatusCommand, + DescribeStackResourceDriftsCommand, + DetectStackDriftCommand, + DetectStackResourceDriftCommand, } from '@aws-sdk/client-cloudformation'; import type { FilterLogEventsCommandInput, @@ -418,8 +430,12 @@ export interface ICloudFormationClient { input: DescribeGeneratedTemplateCommandInput, ): Promise; describeResourceScan(input: DescribeResourceScanCommandInput): Promise; + describeStackDriftDetectionStatus(input: DescribeStackDriftDetectionStatusCommandInput): Promise; describeStacks(input: DescribeStacksCommandInput): Promise; + describeStackResourceDrifts(input: DescribeStackResourceDriftsCommandInput): Promise; describeStackResources(input: DescribeStackResourcesCommandInput): Promise; + detectStackDrift(input: DetectStackDriftCommandInput): Promise; + detectStackResourceDrift(input: DetectStackResourceDriftCommandInput): Promise; executeChangeSet(input: ExecuteChangeSetCommandInput): Promise; getGeneratedTemplate(input: GetGeneratedTemplateCommandInput): Promise; getTemplate(input: GetTemplateCommandInput): Promise; @@ -680,6 +696,10 @@ export class SDK { ): Promise => client.send(new DeleteGeneratedTemplateCommand(input)), deleteStack: (input: DeleteStackCommandInput): Promise => client.send(new DeleteStackCommand(input)), + detectStackDrift: (input: DetectStackDriftCommandInput): Promise => + client.send(new DetectStackDriftCommand(input)), + detectStackResourceDrift: (input: DetectStackResourceDriftCommandInput): Promise => + client.send(new DetectStackResourceDriftCommand(input)), describeChangeSet: (input: DescribeChangeSetCommandInput): Promise => client.send(new DescribeChangeSetCommand(input)), describeGeneratedTemplate: ( @@ -687,6 +707,10 @@ export class SDK { ): Promise => client.send(new DescribeGeneratedTemplateCommand(input)), describeResourceScan: (input: DescribeResourceScanCommandInput): Promise => client.send(new DescribeResourceScanCommand(input)), + describeStackDriftDetectionStatus: (input: DescribeStackDriftDetectionStatusCommandInput): + Promise => client.send(new DescribeStackDriftDetectionStatusCommand(input)), + describeStackResourceDrifts: (input: DescribeStackResourceDriftsCommandInput): Promise => + client.send(new DescribeStackResourceDriftsCommand(input)), describeStacks: (input: DescribeStacksCommandInput): Promise => client.send(new DescribeStacksCommand(input)), describeStackResources: (input: DescribeStackResourcesCommandInput): Promise => diff --git a/packages/@aws-cdk/toolkit-lib/lib/api/deployments/cfn-api.ts b/packages/@aws-cdk/toolkit-lib/lib/api/deployments/cfn-api.ts index 972a7d11a..138c560e4 100644 --- a/packages/@aws-cdk/toolkit-lib/lib/api/deployments/cfn-api.ts +++ b/packages/@aws-cdk/toolkit-lib/lib/api/deployments/cfn-api.ts @@ -3,6 +3,8 @@ import * as cxapi from '@aws-cdk/cx-api'; import { SSMPARAM_NO_INVALIDATE } from '@aws-cdk/cx-api'; import type { DescribeChangeSetCommandOutput, + DescribeStackDriftDetectionStatusCommandOutput, + DescribeStackResourceDriftsCommandOutput, Parameter, ResourceToImport, Tag, @@ -466,6 +468,86 @@ export async function stabilizeStack( }); } +/** + * Detect drift for a CloudFormation stack and wait for the detection to complete + * + * @param cfn a CloudFormation client + * @param ioHelper helper for IO operations + * @param stackName the name of the stack to check for drift + * + * @returns the CloudFormation description of the drift detection results + */ +export async function detectStackDrift( + cfn: ICloudFormationClient, + ioHelper: IoHelper, + stackName: string, +): Promise { + await ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(format('Starting drift detection for stack %s...', stackName))); + + // Start drift detection + const driftDetection = await cfn.detectStackDrift({ + StackName: stackName, + }); + + // Wait for drift detection to complete + const driftStatus = await waitForDriftDetection(cfn, ioHelper, driftDetection.StackDriftDetectionId!); + + if (!driftStatus) { + throw new ToolkitError('Drift detection took too long to complete. Aborting'); + } + + if (driftStatus?.DetectionStatus === 'DETECTION_FAILED') { + throw new ToolkitError( + `Failed to detect drift for stack ${stackName}: ${driftStatus.DetectionStatusReason || 'No reason provided'}`, + ); + } + + // Get the drift results + return cfn.describeStackResourceDrifts({ + StackName: stackName, + }); +} + +/** + * Wait for a drift detection operation to complete + */ +async function waitForDriftDetection( + cfn: ICloudFormationClient, + ioHelper: IoHelper, + driftDetectionId: string, +): Promise { + await ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(format('Waiting for drift detection %s to complete...', driftDetectionId))); + + const maxDelay = 30_000; // 30 seconds max delay + let baseDelay = 1_000; // Start with 1 second + let attempts = 0; + + while (true) { + const response = await cfn.describeStackDriftDetectionStatus({ + StackDriftDetectionId: driftDetectionId, + }); + + if (response.DetectionStatus === 'DETECTION_COMPLETE') { + return response; + } + + if (response.DetectionStatus === 'DETECTION_FAILED') { + throw new ToolkitError(`Drift detection failed: ${response.DetectionStatusReason}`); + } + + if (attempts++ > 30) { + throw new ToolkitError('Drift detection timed out after 30 attempts'); + } + + // Calculate backoff with jitter + const jitter = Math.random() * 1000; + const delay = Math.min(baseDelay + jitter, maxDelay); + await new Promise(resolve => setTimeout(resolve, delay)); + baseDelay *= 2; + attempts++; + } +} + /** * The set of (formal) parameters that have been declared in a template */ diff --git a/packages/@aws-cdk/toolkit-lib/lib/api/diff/diff-formatter.ts b/packages/@aws-cdk/toolkit-lib/lib/api/diff/diff-formatter.ts index 9d6e8905a..f19fc0890 100644 --- a/packages/@aws-cdk/toolkit-lib/lib/api/diff/diff-formatter.ts +++ b/packages/@aws-cdk/toolkit-lib/lib/api/diff/diff-formatter.ts @@ -6,14 +6,18 @@ import { fullDiff, mangleLikeCloudFormation, type TemplateDiff, + formatStackDriftChanges, } from '@aws-cdk/cloudformation-diff'; import type * as cxapi from '@aws-cdk/cx-api'; +import type { DescribeStackResourceDriftsCommandOutput } from '@aws-sdk/client-cloudformation'; import * as chalk from 'chalk'; import { PermissionChangeType } from '../../payloads'; import type { NestedStackTemplates } from '../cloudformation'; import type { IoHelper } from '../io/private'; import { IoDefaultMessages } from '../io/private'; import { StringWriteStream } from '../streams'; +import { RequireApproval } from '../require-approval'; +import { ToolkitError } from '../toolkit-error'; /** * Output of formatSecurityDiff @@ -46,6 +50,21 @@ interface FormatStackDiffOutput { readonly formattedDiff: string; } +/** + * Output of formatStackDrift + */ +interface FormatStackDriftOutput { + /** + * Number of stacks with drift + */ + readonly numResourcesWithDrift: number; + + /** + * Complete formatted drift + */ + readonly formattedDrift: string; +} + /** * Props for the Diff Formatter */ @@ -60,6 +79,11 @@ interface DiffFormatterProps { * Includes the old/current state of the stack as well as the new state. */ readonly templateInfo: TemplateInfo; + + /** + * The results of stack drift + */ + readonly driftResults?: DescribeStackResourceDriftsCommandOutput; } /** @@ -88,6 +112,16 @@ interface FormatStackDiffOptions { readonly quiet?: boolean; } +/** + * Properties specific to formatting the stack drift diff + */ +interface FormatStackDriftOptions { + /** + * Silences 'There were no differences' messages + */ + readonly quiet?: boolean; +} + interface ReusableStackDiffOptions extends FormatStackDiffOptions { readonly ioDefaultHelper: IoDefaultMessages; } @@ -142,6 +176,7 @@ export class DiffFormatter { private readonly stackName: string; private readonly changeSet?: any; private readonly nestedStacks: { [nestedStackLogicalId: string]: NestedStackTemplates } | undefined; + private readonly driftResults?: DescribeStackResourceDriftsCommandOutput; private readonly isImport: boolean; /** @@ -157,6 +192,7 @@ export class DiffFormatter { this.stackName = props.templateInfo.newTemplate.stackName; this.changeSet = props.templateInfo.changeSet; this.nestedStacks = props.templateInfo.nestedStacks; + this.driftResults = props.driftResults; this.isImport = props.templateInfo.isImport ?? false; } @@ -329,6 +365,53 @@ export class DiffFormatter { const formattedDiff = stream.toString(); return { formattedDiff, permissionChangeType: this.permissionType() }; } + + public formatStackDrift(options: FormatStackDriftOptions): FormatStackDriftOutput { + const stream = new StringWriteStream(); + let driftCount = 0; + + if (!this.driftResults?.StackResourceDrifts) { + return { formattedDrift: '', numResourcesWithDrift: 0 }; + } + + const drifts = this.driftResults.StackResourceDrifts; + + if (drifts.length === 0 && !options.quiet) { + stream.write(chalk.green('No drift detected\n')); + stream.end(); + return { formattedDrift: stream.toString(), numResourcesWithDrift: 0 }; + } + + // Count resources with drift + driftCount = drifts.filter(d => + d.StackResourceDriftStatus === 'MODIFIED' || + d.StackResourceDriftStatus === 'DELETED', + ).length; + + formatStackDriftChanges(stream, this.driftResults, buildLogicalToPathMap(this.newTemplate)); + stream.write(chalk.yellow(`\n${driftCount} resource${driftCount === 1 ? '' : 's'} ${driftCount === 1 ? 'has' : 'have'} drifted from their expected configuration\n`)); + stream.end(); + + return { + formattedDrift: stream.toString(), + numResourcesWithDrift: driftCount, + }; + } +} + +/** + * Return whether the diff has security-impacting changes that need confirmation + * + * TODO: Filter the security impact determination based off of an enum that allows + * us to pick minimum "severities" to alert on. + */ +function diffRequiresApproval(diff: TemplateDiff, requireApproval: RequireApproval) { + switch (requireApproval) { + case RequireApproval.NEVER: return false; + case RequireApproval.ANY_CHANGE: return diff.permissionsAnyChanges; + case RequireApproval.BROADENING: return diff.permissionsBroadened; + default: throw new ToolkitError(`Unrecognized approval level: ${requireApproval}`); + } } function buildLogicalToPathMap(stack: cxapi.CloudFormationStackArtifact) { diff --git a/packages/@aws-cdk/toolkit-lib/test/api/diff/diff.test.ts b/packages/@aws-cdk/toolkit-lib/test/api/diff/diff.test.ts index 79de4e448..90536dd9f 100644 --- a/packages/@aws-cdk/toolkit-lib/test/api/diff/diff.test.ts +++ b/packages/@aws-cdk/toolkit-lib/test/api/diff/diff.test.ts @@ -1,4 +1,5 @@ import type * as cxapi from '@aws-cdk/cx-api'; +import type { DescribeStackResourceDriftsCommandOutput } from '@aws-sdk/client-cloudformation'; import * as chalk from 'chalk'; import { DiffFormatter } from '../../../lib/api/diff/diff-formatter'; import { IoHelper, IoDefaultMessages } from '../../../lib/api/io/private'; @@ -261,3 +262,138 @@ describe('formatSecurityDiff', () => { ); }); }); + +describe('formatStackDrift', () => { + let mockIoHelper: IoHelper; + let mockNewTemplate: cxapi.CloudFormationStackArtifact; + let mockIoDefaultMessages: any; + + beforeEach(() => { + const mockNotify = jest.fn().mockResolvedValue(undefined); + const mockRequestResponse = jest.fn().mockResolvedValue(undefined); + + mockIoHelper = IoHelper.fromIoHost( + { notify: mockNotify, requestResponse: mockRequestResponse }, + 'diff', + ); + + mockIoDefaultMessages = { + info: jest.fn(), + warning: jest.fn(), + error: jest.fn(), + }; + + jest.spyOn(mockIoHelper, 'notify').mockImplementation(() => Promise.resolve()); + jest.spyOn(mockIoHelper, 'requestResponse').mockImplementation(() => Promise.resolve()); + + (IoDefaultMessages as jest.Mock).mockImplementation(() => mockIoDefaultMessages); + + mockNewTemplate = { + template: { + Resources: { + Func: { + Type: 'AWS::Lambda::Function', + Properties: { + Code: { + S3Bucket: 'BuckChuckets', + S3Key: 'some-key', + }, + Handler: 'index.handler', + Runtime: 'nodejs20.x', + Description: 'Some description', + }, + }, + }, + }, + templateFile: 'template.json', + stackName: 'test-stack', + findMetadataByType: () => [], + } as any; + }); + + test('detects drift', () => { + // GIVEN + const mockDriftedResources: DescribeStackResourceDriftsCommandOutput = { + StackResourceDrifts: [{ + StackId: 'some:stack:arn', + StackResourceDriftStatus: 'MODIFIED', + LogicalResourceId: 'GiveUpTheFunc', + PhysicalResourceId: 'gotta-have-that-func', + ResourceType: 'AWS::Lambda::Function', + PropertyDifferences: [{ + PropertyPath: '/Description', + ExpectedValue: 'Some description', + ActualValue: 'Tear the Roof Off the Sucker', + DifferenceType: 'NOT_EQUAL', + }], + Timestamp: new Date(2024, 5, 3, 13, 0, 0), + }], + $metadata: {}, + }; + + // WHEN + const formatter = new DiffFormatter({ + ioHelper: mockIoHelper, + templateInfo: { + oldTemplate: mockNewTemplate.template, + newTemplate: mockNewTemplate, + }, + driftResults: mockDriftedResources, + }); + const result = formatter.formatStackDrift({}); + + // THEN + expect(result.numResourcesWithDrift).toBe(1); + const expectedStringsInOutput = [ + 'Modified Resources', + 'AWS::Lambda::Function', + 'GiveUpTheFunc', + 'Description', + 'Some description', + 'Tear the Roof Off the Sucker', + '1 resource has drifted', + ]; + for (const expectedStringInOutput of expectedStringsInOutput) { + expect(result.formattedDrift).toContain(expectedStringInOutput); + } + }); + + test('no drift detected', () => { + // GIVEN + const mockDriftResults: DescribeStackResourceDriftsCommandOutput = { + StackResourceDrifts: [], + $metadata: {}, + }; + + // WHEN + const formatter = new DiffFormatter({ + ioHelper: mockIoHelper, + templateInfo: { + oldTemplate: mockNewTemplate.template, + newTemplate: mockNewTemplate, + }, + driftResults: mockDriftResults, + }); + const result = formatter.formatStackDrift({}); + + // THEN + expect(result.numResourcesWithDrift).toBe(0); + expect(result.formattedDrift).toContain('No drift detected'); + }); + + test('if detect drift is false, no output', () => { + // WHEN + const formatter = new DiffFormatter({ + ioHelper: mockIoHelper, + templateInfo: { + oldTemplate: mockNewTemplate.template, + newTemplate: mockNewTemplate, + }, + }); + const result = formatter.formatStackDrift({}); + + // THEN + expect(result.numResourcesWithDrift).toBe(0); + expect(result.formattedDrift).toBeFalsy(); + }); +}); diff --git a/packages/aws-cdk/lib/cli/cdk-toolkit.ts b/packages/aws-cdk/lib/cli/cdk-toolkit.ts index 992045476..d2d0af93d 100644 --- a/packages/aws-cdk/lib/cli/cdk-toolkit.ts +++ b/packages/aws-cdk/lib/cli/cdk-toolkit.ts @@ -10,19 +10,10 @@ import * as uuid from 'uuid'; import { CliIoHost } from './io-host'; import type { Configuration } from './user-configuration'; import { PROJECT_CONFIG } from './user-configuration'; -import type { ToolkitAction } from '../../../@aws-cdk/toolkit-lib/lib/api'; -import { - ambiguousMovements, - findResourceMovements, - resourceMappings, - ToolkitError, -} from '../../../@aws-cdk/toolkit-lib/lib/api'; -import { asIoHelper } from '../../../@aws-cdk/toolkit-lib/lib/api/io/private'; -import { AmbiguityError } from '../../../@aws-cdk/toolkit-lib/lib/api/refactoring'; -import { PermissionChangeType } from '../../../@aws-cdk/toolkit-lib/lib/payloads'; +import { AmbiguityError, ambiguousMovements, findResourceMovements, resourceMappings, type ToolkitAction } from '../../../@aws-cdk/toolkit-lib/lib/api'; import type { ToolkitOptions } from '../../../@aws-cdk/toolkit-lib/lib/toolkit'; import { Toolkit } from '../../../@aws-cdk/toolkit-lib/lib/toolkit'; -import { DEFAULT_TOOLKIT_STACK_NAME } from '../api'; +import { DEFAULT_TOOLKIT_STACK_NAME, Mode, ToolkitError } from '../api'; import type { SdkProvider } from '../api/aws-auth'; import type { BootstrapEnvironmentOptions } from '../api/bootstrap'; import { Bootstrapper } from '../api/bootstrap'; @@ -35,7 +26,7 @@ import { removeNonImportResources, ResourceImporter, ResourceMigrator } from '.. import { type Tag, tagsForStack } from '../api/tags'; import type { AssetBuildNode, AssetPublishNode, Concurrency, StackNode, WorkGraph } from '../api/work-graph'; import { WorkGraphBuilder } from '../api/work-graph'; -import { cfnApi } from '../api-private'; +import { asIoHelper, cfnApi } from '../api-private'; import { StackActivityProgress } from '../commands/deploy'; import { DiffFormatter, RequireApproval } from '../commands/diff'; import { listStacks } from '../commands/list-stacks'; @@ -68,6 +59,8 @@ import { serializeStructure, validateSnsTopicArn, } from '../util'; +import { PermissionChangeType } from '../../../@aws-cdk/toolkit-lib/lib/payloads'; +import { detectStackDrift } from '../../../@aws-cdk/toolkit-lib/lib/api/deployments/cfn-api'; // Must use a require() otherwise esbuild complains about calling a namespace // eslint-disable-next-line @typescript-eslint/no-require-imports,@typescript-eslint/consistent-type-imports @@ -214,6 +207,7 @@ export class CdkToolkit { const quiet = options.quiet || false; let diffs = 0; + let drifts = 0; const parameterMap = buildParameterMap(options.parameters); if (options.templatePath !== undefined) { @@ -264,6 +258,19 @@ export class CdkToolkit { const currentTemplate = templateWithNestedStacks.deployedRootTemplate; const nestedStacks = templateWithNestedStacks.nestedStacks; + let driftResults = undefined; + + if (options.detectDrift) { + const env = await this.props.deployments.resolveEnvironment(stack); + const cfn = (await this.props.sdkProvider.forEnvironment(env, Mode.ForReading)).sdk.cloudFormation(); + + driftResults = await detectStackDrift( + cfn, + asIoHelper(this.ioHost, 'diff'), + stack.stackName, + ); + } + const migrator = new ResourceMigrator({ deployments: this.props.deployments, ioHelper: asIoHelper(this.ioHost, 'diff'), @@ -319,6 +326,7 @@ export class CdkToolkit { isImport: !!resourcesToImport, nestedStacks, }, + driftResults, }); if (options.securityOnly) { @@ -335,13 +343,21 @@ export class CdkToolkit { context: contextLines, quiet, }); - info(diff.formattedDiff); + const drift = formatter.formatStackDrift({ + quiet, + }); + info(diff.formattedDiff + '\n' + drift.formattedDrift); diffs += diff.numStacksWithChanges; + drifts = drift.numResourcesWithDrift; } } } - info(format('\n✨ Number of stacks with differences: %s\n', diffs)); + if (options.detectDrift) { + info(format('\n✨ Number of stacks with differences: %s\n✨ Number of resources with drift: %s\n', diffs, drifts)); + } else { + info(format('\n✨ Number of stacks with differences: %s\n', diffs)); + } return diffs && options.fail ? 1 : 0; } @@ -1476,6 +1492,13 @@ export interface DiffOptions { */ readonly securityOnly?: boolean; + /** + * Run drift detection on the stack as well + * + * @default false + */ + readonly detectDrift?: boolean; + /** * Whether to run the diff against the template after the CloudFormation Transforms inside it have been executed * (as opposed to the original template, the default, which contains the unprocessed Transforms). diff --git a/packages/aws-cdk/lib/cli/cli-config.ts b/packages/aws-cdk/lib/cli/cli-config.ts index 183b511be..ab00c5abb 100644 --- a/packages/aws-cdk/lib/cli/cli-config.ts +++ b/packages/aws-cdk/lib/cli/cli-config.ts @@ -308,6 +308,7 @@ export async function makeConfig(): Promise { 'template': { type: 'string', desc: 'The path to the CloudFormation template to compare with', requiresArg: true }, 'strict': { type: 'boolean', desc: 'Do not filter out AWS::CDK::Metadata resources, mangled non-ASCII characters, or the CheckBootstrapVersionRule', default: false }, 'security-only': { type: 'boolean', desc: 'Only diff for broadened security changes', default: false }, + 'detect-drift': { type: 'boolean', desc: 'Whether or not to also run CloudFormation drift detection', default: false }, 'fail': { type: 'boolean', desc: 'Fail with exit code 1 in case of diff' }, 'processed': { type: 'boolean', desc: 'Whether to compare against the template with Transforms already processed', default: false }, 'quiet': { type: 'boolean', alias: 'q', desc: 'Do not print stack name and default message when there is no diff to stdout', default: false }, diff --git a/packages/aws-cdk/lib/cli/cli.ts b/packages/aws-cdk/lib/cli/cli.ts index 08ee2f0bf..cbeafd699 100644 --- a/packages/aws-cdk/lib/cli/cli.ts +++ b/packages/aws-cdk/lib/cli/cli.ts @@ -256,6 +256,7 @@ export async function exec(args: string[], synthesizer?: Synthesizer): Promise): any { type: 'boolean', desc: 'Only diff for broadened security changes', }) + .option('detect-drift', { + default: false, + type: 'boolean', + desc: 'Whether or not to also run CloudFormation drift detection', + }) .option('fail', { default: undefined, type: 'boolean', diff --git a/packages/aws-cdk/lib/cli/user-input.ts b/packages/aws-cdk/lib/cli/user-input.ts index 4bfc9c3c7..3f4ac388e 100644 --- a/packages/aws-cdk/lib/cli/user-input.ts +++ b/packages/aws-cdk/lib/cli/user-input.ts @@ -1078,6 +1078,13 @@ export interface DiffOptions { */ readonly securityOnly?: boolean; + /** + * Whether or not to also run CloudFormation drift detection + * + * @default - false + */ + readonly detectDrift?: boolean; + /** * Fail with exit code 1 in case of diff * From 87cf1f399e57483dca4198a804323c7659518a96 Mon Sep 17 00:00:00 2001 From: Leonardo Gama Date: Thu, 1 May 2025 11:23:12 -0700 Subject: [PATCH 04/31] Fix output for no drifts --- .../toolkit-lib/lib/api/diff/diff-formatter.ts | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-) diff --git a/packages/@aws-cdk/toolkit-lib/lib/api/diff/diff-formatter.ts b/packages/@aws-cdk/toolkit-lib/lib/api/diff/diff-formatter.ts index f19fc0890..235dd0114 100644 --- a/packages/@aws-cdk/toolkit-lib/lib/api/diff/diff-formatter.ts +++ b/packages/@aws-cdk/toolkit-lib/lib/api/diff/diff-formatter.ts @@ -374,7 +374,10 @@ export class DiffFormatter { return { formattedDrift: '', numResourcesWithDrift: 0 }; } - const drifts = this.driftResults.StackResourceDrifts; + const drifts = this.driftResults.StackResourceDrifts.filter(d => + d.StackResourceDriftStatus === 'MODIFIED' || + d.StackResourceDriftStatus === 'DELETED', + ); if (drifts.length === 0 && !options.quiet) { stream.write(chalk.green('No drift detected\n')); @@ -382,12 +385,7 @@ export class DiffFormatter { return { formattedDrift: stream.toString(), numResourcesWithDrift: 0 }; } - // Count resources with drift - driftCount = drifts.filter(d => - d.StackResourceDriftStatus === 'MODIFIED' || - d.StackResourceDriftStatus === 'DELETED', - ).length; - + driftCount = drifts.length; formatStackDriftChanges(stream, this.driftResults, buildLogicalToPathMap(this.newTemplate)); stream.write(chalk.yellow(`\n${driftCount} resource${driftCount === 1 ? '' : 's'} ${driftCount === 1 ? 'has' : 'have'} drifted from their expected configuration\n`)); stream.end(); From 004fcab97432e848b68c41da5c0466c7167dd5c2 Mon Sep 17 00:00:00 2001 From: Leonardo Gama Date: Thu, 1 May 2025 11:32:34 -0700 Subject: [PATCH 05/31] Merge --- .../lib/api/aws-auth/account-cache.d.ts | 41 + .../lib/api/aws-auth/account-cache.js | 108 +++ .../lib/api/aws-auth/awscli-compatible.d.ts | 70 ++ .../lib/api/aws-auth/awscli-compatible.js | 250 +++++++ .../lib/api/aws-auth/cached.d.ts | 11 + .../lib/api/aws-auth/cached.js | 26 + .../lib/api/aws-auth/credential-plugins.d.ts | 38 + .../lib/api/aws-auth/credential-plugins.js | 154 ++++ .../lib/api/aws-auth/index.d.ts | 11 + .../lib/api/aws-auth/index.js | 37 + .../lib/api/aws-auth/provider-caching.d.ts | 13 + .../lib/api/aws-auth/provider-caching.js | 24 + .../lib/api/aws-auth/proxy-agent.d.ts | 13 + .../lib/api/aws-auth/proxy-agent.js | 54 ++ .../lib/api/aws-auth/sdk-logger.d.ts | 69 ++ .../lib/api/aws-auth/sdk-logger.js | 128 ++++ .../lib/api/aws-auth/sdk-provider.d.ts | 229 ++++++ .../lib/api/aws-auth/sdk-provider.js | 373 +++++++++ .../lib/api/aws-auth/sdk.d.ts | 239 ++++++ .../lib/api/aws-auth/sdk.js | 395 ++++++++++ .../lib/api/aws-auth/tracing.d.ts | 11 + .../lib/api/aws-auth/tracing.js | 60 ++ .../lib/api/aws-auth/user-agent.d.ts | 7 + .../lib/api/aws-auth/user-agent.js | 20 + .../lib/api/aws-auth/util.d.ts | 6 + .../lib/api/aws-auth/util.js | 21 + .../api/bootstrap/bootstrap-environment.d.ts | 35 + .../api/bootstrap/bootstrap-environment.js | 323 ++++++++ .../lib/api/bootstrap/bootstrap-props.d.ts | 130 ++++ .../lib/api/bootstrap/bootstrap-props.js | 14 + .../lib/api/bootstrap/bootstrap-template.yaml | 707 ++++++++++++++++++ .../lib/api/bootstrap/deploy-bootstrap.d.ts | 39 + .../lib/api/bootstrap/deploy-bootstrap.js | 147 ++++ .../lib/api/bootstrap/index.d.ts | 3 + .../lib/api/bootstrap/index.js | 23 + .../lib/api/bootstrap/legacy-template.d.ts | 2 + .../lib/api/bootstrap/legacy-template.js | 82 ++ .../lib/api/cloud-assembly/environment.d.ts | 43 ++ .../lib/api/cloud-assembly/environment.js | 127 ++++ .../lib/api/cloud-assembly/index.d.ts | 4 + .../lib/api/cloud-assembly/index.js | 21 + .../api/cloud-assembly/stack-assembly.d.ts | 55 ++ .../lib/api/cloud-assembly/stack-assembly.js | 139 ++++ .../api/cloud-assembly/stack-collection.d.ts | 27 + .../api/cloud-assembly/stack-collection.js | 112 +++ .../api/cloud-assembly/stack-selector.d.ts | 81 ++ .../lib/api/cloud-assembly/stack-selector.js | 64 ++ .../evaluate-cloudformation-template.d.ts | 85 +++ .../evaluate-cloudformation-template.js | 456 +++++++++++ .../lib/api/cloudformation/index.d.ts | 4 + .../lib/api/cloudformation/index.js | 21 + .../cloudformation/nested-stack-helpers.d.ts | 25 + .../cloudformation/nested-stack-helpers.js | 86 +++ .../lib/api/cloudformation/stack-helpers.d.ts | 96 +++ .../lib/api/cloudformation/stack-helpers.js | 163 ++++ .../template-body-parameter.d.ts | 22 + .../cloudformation/template-body-parameter.js | 104 +++ .../tmp-toolkit-helpers/lib/api/context.d.ts | 40 + .../tmp-toolkit-helpers/lib/api/context.js | 84 +++ .../deployments/asset-manifest-builder.d.ts | 8 + .../api/deployments/asset-manifest-builder.js | 33 + .../lib/api/deployments/asset-publishing.d.ts | 60 ++ .../lib/api/deployments/asset-publishing.js | 144 ++++ .../lib/api/deployments/assets.d.ts | 11 + .../lib/api/deployments/assets.js | 109 +++ .../lib/api/deployments/cfn-api.d.ts | 155 ++++ .../lib/api/deployments/cfn-api.js | 502 +++++++++++++ .../lib/api/deployments/checks.d.ts | 9 + .../lib/api/deployments/checks.js | 72 ++ .../lib/api/deployments/deploy-stack.d.ts | 164 ++++ .../lib/api/deployments/deploy-stack.js | 490 ++++++++++++ .../api/deployments/deployment-method.d.ts | 24 + .../lib/api/deployments/deployment-method.js | 3 + .../api/deployments/deployment-result.d.ts | 21 + .../lib/api/deployments/deployment-result.js | 10 + .../lib/api/deployments/deployments.d.ts | 289 +++++++ .../lib/api/deployments/deployments.js | 355 +++++++++ .../lib/api/deployments/index.d.ts | 6 + .../lib/api/deployments/index.js | 27 + .../lib/api/diff/diff-formatter.d.ts | 168 +++++ .../lib/api/diff/diff-formatter.js | 244 ++++++ .../lib/api/diff/index.d.ts | 1 + .../tmp-toolkit-helpers/lib/api/diff/index.js | 18 + .../api/environment/environment-access.d.ts | 139 ++++ .../lib/api/environment/environment-access.js | 205 +++++ .../environment/environment-resources.d.ts | 75 ++ .../api/environment/environment-resources.js | 213 ++++++ .../lib/api/environment/index.d.ts | 3 + .../lib/api/environment/index.js | 20 + .../lib/api/environment/placeholders.d.ts | 10 + .../lib/api/environment/placeholders.js | 23 + .../garbage-collection/garbage-collector.d.ts | 158 ++++ .../garbage-collection/garbage-collector.js | 614 +++++++++++++++ .../lib/api/garbage-collection/index.d.ts | 3 + .../lib/api/garbage-collection/index.js | 21 + .../garbage-collection/progress-printer.d.ts | 23 + .../garbage-collection/progress-printer.js | 80 ++ .../api/garbage-collection/stack-refresh.d.ts | 49 ++ .../api/garbage-collection/stack-refresh.js | 152 ++++ .../hotswap/appsync-mapping-templates.d.ts | 4 + .../api/hotswap/appsync-mapping-templates.js | 162 ++++ .../lib/api/hotswap/code-build-projects.d.ts | 4 + .../lib/api/hotswap/code-build-projects.js | 62 ++ .../lib/api/hotswap/common.d.ts | 89 +++ .../lib/api/hotswap/common.js | 137 ++++ .../lib/api/hotswap/ecs-services.d.ts | 4 + .../lib/api/hotswap/ecs-services.js | 159 ++++ .../lib/api/hotswap/hotswap-deployments.d.ts | 17 + .../lib/api/hotswap/hotswap-deployments.js | 441 +++++++++++ .../lib/api/hotswap/index.d.ts | 2 + .../lib/api/hotswap/index.js | 19 + .../lib/api/hotswap/lambda-functions.d.ts | 4 + .../lib/api/hotswap/lambda-functions.js | 297 ++++++++ .../api/hotswap/s3-bucket-deployments.d.ts | 5 + .../lib/api/hotswap/s3-bucket-deployments.js | 117 +++ .../hotswap/stepfunctions-state-machines.d.ts | 4 + .../hotswap/stepfunctions-state-machines.js | 48 ++ .../tmp-toolkit-helpers/lib/api/index.d.ts | 25 + .../tmp-toolkit-helpers/lib/api/index.js | 42 ++ .../tmp-toolkit-helpers/lib/api/io/index.d.ts | 3 + .../tmp-toolkit-helpers/lib/api/io/index.js | 20 + .../lib/api/io/io-host.d.ts | 15 + .../tmp-toolkit-helpers/lib/api/io/io-host.js | 3 + .../lib/api/io/io-message.d.ts | 76 ++ .../lib/api/io/io-message.js | 3 + .../lib/api/io/private/index.d.ts | 7 + .../lib/api/io/private/index.js | 24 + .../api/io/private/io-default-messages.d.ts | 21 + .../lib/api/io/private/io-default-messages.js | 59 ++ .../lib/api/io/private/io-helper.d.ts | 32 + .../lib/api/io/private/io-helper.js | 51 ++ .../lib/api/io/private/level-priority.d.ts | 11 + .../lib/api/io/private/level-priority.js | 33 + .../lib/api/io/private/message-maker.d.ts | 89 +++ .../lib/api/io/private/message-maker.js | 60 ++ .../lib/api/io/private/messages.d.ts | 178 +++++ .../lib/api/io/private/messages.js | 534 +++++++++++++ .../lib/api/io/private/span.d.ts | 93 +++ .../lib/api/io/private/span.js | 87 +++ .../api/io/private/testing/fake-io-host.d.ts | 28 + .../api/io/private/testing/fake-io-host.js | 41 + .../lib/api/io/private/testing/index.d.ts | 2 + .../lib/api/io/private/testing/index.js | 19 + .../api/io/private/testing/test-io-host.d.ts | 27 + .../api/io/private/testing/test-io-host.js | 61 ++ .../lib/api/io/private/types.d.ts | 4 + .../lib/api/io/private/types.js | 3 + .../lib/api/io/toolkit-action.d.ts | 4 + .../lib/api/io/toolkit-action.js | 3 + .../logs-monitor/find-cloudwatch-logs.d.ts | 25 + .../api/logs-monitor/find-cloudwatch-logs.js | 95 +++ .../lib/api/logs-monitor/index.d.ts | 2 + .../lib/api/logs-monitor/index.js | 19 + .../lib/api/logs-monitor/logs-monitor.d.ts | 76 ++ .../lib/api/logs-monitor/logs-monitor.js | 194 +++++ .../tmp-toolkit-helpers/lib/api/notices.d.ts | 210 ++++++ .../tmp-toolkit-helpers/lib/api/notices.js | 430 +++++++++++ .../api/plugin/context-provider-plugin.d.ts | 6 + .../lib/api/plugin/context-provider-plugin.js | 7 + .../lib/api/plugin/index.d.ts | 3 + .../lib/api/plugin/index.js | 20 + .../lib/api/plugin/mode.d.ts | 4 + .../lib/api/plugin/mode.js | 9 + .../lib/api/plugin/plugin.d.ts | 78 ++ .../lib/api/plugin/plugin.js | 132 ++++ .../tmp-toolkit-helpers/lib/api/private.d.ts | 1 + .../tmp-toolkit-helpers/lib/api/private.js | 18 + .../lib/api/refactoring/cloudformation.d.ts | 15 + .../lib/api/refactoring/cloudformation.js | 3 + .../lib/api/refactoring/digest.d.ts | 26 + .../lib/api/refactoring/digest.js | 175 +++++ .../lib/api/refactoring/index.d.ts | 51 ++ .../lib/api/refactoring/index.js | 214 ++++++ .../lib/api/require-approval.d.ts | 17 + .../lib/api/require-approval.js | 22 + .../lib/api/resource-import/importer.d.ts | 216 ++++++ .../lib/api/resource-import/importer.js | 331 ++++++++ .../lib/api/resource-import/index.d.ts | 2 + .../lib/api/resource-import/index.js | 19 + .../lib/api/resource-import/migrator.d.ts | 26 + .../lib/api/resource-import/migrator.js | 73 ++ .../lib/api/resource-metadata/index.d.ts | 1 + .../lib/api/resource-metadata/index.js | 18 + .../resource-metadata/resource-metadata.d.ts | 24 + .../resource-metadata/resource-metadata.js | 42 ++ .../tmp-toolkit-helpers/lib/api/rwlock.d.ts | 76 ++ .../tmp-toolkit-helpers/lib/api/rwlock.js | 204 +++++ .../tmp-toolkit-helpers/lib/api/settings.d.ts | 26 + .../tmp-toolkit-helpers/lib/api/settings.js | 107 +++ .../lib/api/stack-events/index.d.ts | 4 + .../lib/api/stack-events/index.js | 23 + .../stack-events/stack-activity-monitor.d.ts | 100 +++ .../stack-events/stack-activity-monitor.js | 164 ++++ .../api/stack-events/stack-event-poller.d.ts | 69 ++ .../api/stack-events/stack-event-poller.js | 130 ++++ .../stack-events/stack-progress-monitor.d.ts | 48 ++ .../stack-events/stack-progress-monitor.js | 98 +++ .../lib/api/stack-events/stack-status.d.ts | 42 ++ .../lib/api/stack-events/stack-status.js | 90 +++ .../tmp-toolkit-helpers/lib/api/streams.d.ts | 7 + .../tmp-toolkit-helpers/lib/api/streams.js | 24 + .../tmp-toolkit-helpers/lib/api/tags.d.ts | 9 + .../tmp-toolkit-helpers/lib/api/tags.js | 10 + .../lib/api/toolkit-error.d.ts | 86 +++ .../lib/api/toolkit-error.js | 132 ++++ .../lib/api/toolkit-info.d.ts | 52 ++ .../lib/api/toolkit-info.js | 157 ++++ .../tmp-toolkit-helpers/lib/api/tree.d.ts | 31 + .../tmp-toolkit-helpers/lib/api/tree.js | 37 + .../lib/api/work-graph/index.d.ts | 3 + .../lib/api/work-graph/index.js | 20 + .../api/work-graph/work-graph-builder.d.ts | 34 + .../lib/api/work-graph/work-graph-builder.js | 172 +++++ .../lib/api/work-graph/work-graph-types.d.ts | 50 ++ .../lib/api/work-graph/work-graph-types.js | 13 + .../lib/api/work-graph/work-graph.d.ts | 72 ++ .../lib/api/work-graph/work-graph.js | 349 +++++++++ .../lib/context-providers/ami.d.ts | 13 + .../lib/context-providers/ami.js | 52 ++ .../context-providers/availability-zones.d.ts | 13 + .../context-providers/availability-zones.js | 29 + .../context-providers/cc-api-provider.d.ts | 30 + .../lib/context-providers/cc-api-provider.js | 145 ++++ .../endpoint-service-availability-zones.d.ts | 13 + .../endpoint-service-availability-zones.js | 35 + .../lib/context-providers/hosted-zones.d.ts | 12 + .../lib/context-providers/hosted-zones.js | 69 ++ .../lib/context-providers/index.d.ts | 44 ++ .../lib/context-providers/index.js | 128 ++++ .../lib/context-providers/keys.d.ts | 13 + .../lib/context-providers/keys.js | 54 ++ .../lib/context-providers/load-balancers.d.ts | 20 + .../lib/context-providers/load-balancers.js | 161 ++++ .../context-providers/security-groups.d.ts | 14 + .../lib/context-providers/security-groups.js | 69 ++ .../lib/context-providers/ssm-parameters.d.ts | 25 + .../lib/context-providers/ssm-parameters.js | 61 ++ .../lib/context-providers/vpcs.d.ts | 13 + .../lib/context-providers/vpcs.js | 291 +++++++ .../tmp-toolkit-helpers/lib/index.d.ts | 3 + .../@aws-cdk/tmp-toolkit-helpers/lib/index.js | 20 + .../bootstrap-environment-progress.d.ts | 17 + .../bootstrap-environment-progress.js | 3 + .../lib/payloads/context.d.ts | 9 + .../lib/payloads/context.js | 3 + .../lib/payloads/deploy.d.ts | 69 ++ .../lib/payloads/deploy.js | 3 + .../lib/payloads/destroy.d.ts | 23 + .../lib/payloads/destroy.js | 3 + .../lib/payloads/diff.d.ts | 31 + .../tmp-toolkit-helpers/lib/payloads/diff.js | 22 + .../lib/payloads/hotswap.d.ts | 211 ++++++ .../lib/payloads/hotswap.js | 43 ++ .../lib/payloads/index.d.ts | 17 + .../tmp-toolkit-helpers/lib/payloads/index.js | 34 + .../lib/payloads/list.d.ts | 4 + .../tmp-toolkit-helpers/lib/payloads/list.js | 3 + .../lib/payloads/logs-monitor.d.ts | 33 + .../lib/payloads/logs-monitor.js | 3 + .../lib/payloads/progress.d.ts | 14 + .../lib/payloads/progress.js | 3 + .../lib/payloads/refactor.d.ts | 14 + .../lib/payloads/refactor.js | 3 + .../lib/payloads/rollback.d.ts | 17 + .../lib/payloads/rollback.js | 3 + .../lib/payloads/sdk-trace.d.ts | 20 + .../lib/payloads/sdk-trace.js | 3 + .../lib/payloads/stack-activity.d.ts | 53 ++ .../lib/payloads/stack-activity.js | 3 + .../lib/payloads/stack-details.d.ts | 17 + .../lib/payloads/stack-details.js | 3 + .../lib/payloads/synth.d.ts | 7 + .../tmp-toolkit-helpers/lib/payloads/synth.js | 3 + .../lib/payloads/types.d.ts | 95 +++ .../tmp-toolkit-helpers/lib/payloads/types.js | 3 + .../lib/payloads/watch.d.ts | 27 + .../tmp-toolkit-helpers/lib/payloads/watch.js | 3 + .../lib/private/activity-printer/base.d.ts | 50 ++ .../lib/private/activity-printer/base.js | 120 +++ .../lib/private/activity-printer/current.d.ts | 26 + .../lib/private/activity-printer/current.js | 122 +++ .../lib/private/activity-printer/display.d.ts | 13 + .../lib/private/activity-printer/display.js | 81 ++ .../lib/private/activity-printer/history.d.ts | 32 + .../lib/private/activity-printer/history.js | 109 +++ .../lib/private/activity-printer/index.d.ts | 3 + .../lib/private/activity-printer/index.js | 20 + .../lib/private/index.d.ts | 1 + .../tmp-toolkit-helpers/lib/private/index.js | 18 + .../tmp-toolkit-helpers/lib/util/archive.d.ts | 1 + .../tmp-toolkit-helpers/lib/util/archive.js | 86 +++ .../tmp-toolkit-helpers/lib/util/arrays.d.ts | 14 + .../tmp-toolkit-helpers/lib/util/arrays.js | 36 + .../tmp-toolkit-helpers/lib/util/bool.d.ts | 7 + .../tmp-toolkit-helpers/lib/util/bool.js | 13 + .../tmp-toolkit-helpers/lib/util/bytes.d.ts | 8 + .../tmp-toolkit-helpers/lib/util/bytes.js | 21 + .../lib/util/cloudformation.d.ts | 16 + .../lib/util/cloudformation.js | 36 + .../lib/util/content-hash.d.ts | 5 + .../lib/util/content-hash.js | 43 ++ .../lib/util/directories.d.ts | 22 + .../lib/util/directories.js | 59 ++ .../lib/util/format-error.d.ts | 9 + .../lib/util/format-error.js | 22 + .../tmp-toolkit-helpers/lib/util/index.d.ts | 18 + .../tmp-toolkit-helpers/lib/util/index.js | 35 + .../tmp-toolkit-helpers/lib/util/json.d.ts | 48 ++ .../tmp-toolkit-helpers/lib/util/json.js | 68 ++ .../tmp-toolkit-helpers/lib/util/objects.d.ts | 65 ++ .../tmp-toolkit-helpers/lib/util/objects.js | 230 ++++++ .../lib/util/package-info.d.ts | 3 + .../lib/util/package-info.js | 22 + .../lib/util/parallel.d.ts | 6 + .../tmp-toolkit-helpers/lib/util/parallel.js | 48 ++ .../lib/util/serialize.d.ts | 27 + .../tmp-toolkit-helpers/lib/util/serialize.js | 86 +++ .../lib/util/string-manipulation.d.ts | 18 + .../lib/util/string-manipulation.js | 46 ++ .../lib/util/type-brands.d.ts | 39 + .../lib/util/type-brands.js | 39 + .../tmp-toolkit-helpers/lib/util/types.d.ts | 27 + .../tmp-toolkit-helpers/lib/util/types.js | 25 + .../lib/util/version-range.d.ts | 2 + .../lib/util/version-range.js | 36 + .../lib/util/yaml-cfn.d.ts | 15 + .../tmp-toolkit-helpers/lib/util/yaml-cfn.js | 58 ++ 327 files changed, 22862 insertions(+) create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/account-cache.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/account-cache.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/awscli-compatible.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/awscli-compatible.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/cached.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/cached.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/credential-plugins.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/credential-plugins.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/index.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/index.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/provider-caching.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/provider-caching.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/proxy-agent.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/proxy-agent.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/sdk-logger.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/sdk-logger.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/sdk-provider.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/sdk-provider.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/sdk.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/sdk.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/tracing.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/tracing.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/user-agent.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/user-agent.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/util.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/util.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/bootstrap/bootstrap-environment.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/bootstrap/bootstrap-environment.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/bootstrap/bootstrap-props.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/bootstrap/bootstrap-props.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/bootstrap/bootstrap-template.yaml create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/bootstrap/deploy-bootstrap.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/bootstrap/deploy-bootstrap.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/bootstrap/index.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/bootstrap/index.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/bootstrap/legacy-template.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/bootstrap/legacy-template.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloud-assembly/environment.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloud-assembly/environment.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloud-assembly/index.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloud-assembly/index.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloud-assembly/stack-assembly.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloud-assembly/stack-assembly.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloud-assembly/stack-collection.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloud-assembly/stack-collection.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloud-assembly/stack-selector.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloud-assembly/stack-selector.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloudformation/evaluate-cloudformation-template.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloudformation/evaluate-cloudformation-template.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloudformation/index.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloudformation/index.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloudformation/nested-stack-helpers.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloudformation/nested-stack-helpers.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloudformation/stack-helpers.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloudformation/stack-helpers.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloudformation/template-body-parameter.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloudformation/template-body-parameter.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/context.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/context.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/deployments/asset-manifest-builder.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/deployments/asset-manifest-builder.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/deployments/asset-publishing.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/deployments/asset-publishing.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/deployments/assets.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/deployments/assets.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/deployments/cfn-api.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/deployments/cfn-api.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/deployments/checks.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/deployments/checks.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/deployments/deploy-stack.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/deployments/deploy-stack.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/deployments/deployment-method.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/deployments/deployment-method.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/deployments/deployment-result.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/deployments/deployment-result.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/deployments/deployments.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/deployments/deployments.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/deployments/index.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/deployments/index.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/diff/diff-formatter.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/diff/diff-formatter.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/diff/index.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/diff/index.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/environment/environment-access.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/environment/environment-access.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/environment/environment-resources.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/environment/environment-resources.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/environment/index.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/environment/index.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/environment/placeholders.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/environment/placeholders.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/garbage-collection/garbage-collector.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/garbage-collection/garbage-collector.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/garbage-collection/index.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/garbage-collection/index.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/garbage-collection/progress-printer.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/garbage-collection/progress-printer.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/garbage-collection/stack-refresh.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/garbage-collection/stack-refresh.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/hotswap/appsync-mapping-templates.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/hotswap/appsync-mapping-templates.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/hotswap/code-build-projects.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/hotswap/code-build-projects.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/hotswap/common.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/hotswap/common.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/hotswap/ecs-services.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/hotswap/ecs-services.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/hotswap/hotswap-deployments.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/hotswap/hotswap-deployments.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/hotswap/index.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/hotswap/index.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/hotswap/lambda-functions.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/hotswap/lambda-functions.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/hotswap/s3-bucket-deployments.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/hotswap/s3-bucket-deployments.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/hotswap/stepfunctions-state-machines.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/hotswap/stepfunctions-state-machines.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/index.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/index.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/io/index.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/io/index.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/io/io-host.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/io/io-host.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/io/io-message.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/io/io-message.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/io/private/index.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/io/private/index.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/io/private/io-default-messages.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/io/private/io-default-messages.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/io/private/io-helper.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/io/private/io-helper.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/io/private/level-priority.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/io/private/level-priority.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/io/private/message-maker.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/io/private/message-maker.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/io/private/messages.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/io/private/messages.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/io/private/span.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/io/private/span.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/io/private/testing/fake-io-host.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/io/private/testing/fake-io-host.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/io/private/testing/index.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/io/private/testing/index.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/io/private/testing/test-io-host.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/io/private/testing/test-io-host.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/io/private/types.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/io/private/types.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/io/toolkit-action.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/io/toolkit-action.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/logs-monitor/find-cloudwatch-logs.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/logs-monitor/find-cloudwatch-logs.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/logs-monitor/index.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/logs-monitor/index.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/logs-monitor/logs-monitor.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/logs-monitor/logs-monitor.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/notices.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/notices.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/plugin/context-provider-plugin.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/plugin/context-provider-plugin.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/plugin/index.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/plugin/index.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/plugin/mode.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/plugin/mode.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/plugin/plugin.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/plugin/plugin.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/private.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/private.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/refactoring/cloudformation.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/refactoring/cloudformation.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/refactoring/digest.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/refactoring/digest.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/refactoring/index.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/refactoring/index.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/require-approval.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/require-approval.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/resource-import/importer.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/resource-import/importer.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/resource-import/index.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/resource-import/index.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/resource-import/migrator.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/resource-import/migrator.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/resource-metadata/index.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/resource-metadata/index.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/resource-metadata/resource-metadata.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/resource-metadata/resource-metadata.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/rwlock.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/rwlock.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/settings.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/settings.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/stack-events/index.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/stack-events/index.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/stack-events/stack-activity-monitor.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/stack-events/stack-activity-monitor.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/stack-events/stack-event-poller.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/stack-events/stack-event-poller.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/stack-events/stack-progress-monitor.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/stack-events/stack-progress-monitor.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/stack-events/stack-status.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/stack-events/stack-status.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/streams.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/streams.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/tags.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/tags.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/toolkit-error.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/toolkit-error.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/toolkit-info.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/toolkit-info.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/tree.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/tree.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/work-graph/index.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/work-graph/index.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/work-graph/work-graph-builder.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/work-graph/work-graph-builder.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/work-graph/work-graph-types.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/work-graph/work-graph-types.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/work-graph/work-graph.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/api/work-graph/work-graph.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/context-providers/ami.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/context-providers/ami.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/context-providers/availability-zones.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/context-providers/availability-zones.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/context-providers/cc-api-provider.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/context-providers/cc-api-provider.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/context-providers/endpoint-service-availability-zones.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/context-providers/endpoint-service-availability-zones.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/context-providers/hosted-zones.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/context-providers/hosted-zones.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/context-providers/index.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/context-providers/index.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/context-providers/keys.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/context-providers/keys.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/context-providers/load-balancers.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/context-providers/load-balancers.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/context-providers/security-groups.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/context-providers/security-groups.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/context-providers/ssm-parameters.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/context-providers/ssm-parameters.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/context-providers/vpcs.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/context-providers/vpcs.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/index.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/index.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/payloads/bootstrap-environment-progress.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/payloads/bootstrap-environment-progress.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/payloads/context.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/payloads/context.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/payloads/deploy.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/payloads/deploy.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/payloads/destroy.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/payloads/destroy.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/payloads/diff.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/payloads/diff.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/payloads/hotswap.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/payloads/hotswap.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/payloads/index.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/payloads/index.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/payloads/list.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/payloads/list.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/payloads/logs-monitor.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/payloads/logs-monitor.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/payloads/progress.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/payloads/progress.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/payloads/refactor.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/payloads/refactor.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/payloads/rollback.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/payloads/rollback.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/payloads/sdk-trace.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/payloads/sdk-trace.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/payloads/stack-activity.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/payloads/stack-activity.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/payloads/stack-details.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/payloads/stack-details.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/payloads/synth.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/payloads/synth.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/payloads/types.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/payloads/types.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/payloads/watch.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/payloads/watch.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/private/activity-printer/base.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/private/activity-printer/base.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/private/activity-printer/current.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/private/activity-printer/current.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/private/activity-printer/display.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/private/activity-printer/display.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/private/activity-printer/history.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/private/activity-printer/history.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/private/activity-printer/index.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/private/activity-printer/index.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/private/index.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/private/index.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/util/archive.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/util/archive.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/util/arrays.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/util/arrays.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/util/bool.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/util/bool.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/util/bytes.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/util/bytes.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/util/cloudformation.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/util/cloudformation.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/util/content-hash.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/util/content-hash.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/util/directories.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/util/directories.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/util/format-error.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/util/format-error.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/util/index.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/util/index.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/util/json.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/util/json.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/util/objects.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/util/objects.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/util/package-info.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/util/package-info.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/util/parallel.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/util/parallel.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/util/serialize.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/util/serialize.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/util/string-manipulation.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/util/string-manipulation.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/util/type-brands.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/util/type-brands.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/util/types.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/util/types.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/util/version-range.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/util/version-range.js create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/util/yaml-cfn.d.ts create mode 100644 packages/@aws-cdk/tmp-toolkit-helpers/lib/util/yaml-cfn.js diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/account-cache.d.ts b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/account-cache.d.ts new file mode 100644 index 000000000..2a04f7d4e --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/account-cache.d.ts @@ -0,0 +1,41 @@ +import type { Account } from './sdk-provider'; +/** + * Disk cache which maps access key IDs to account IDs. + * Usage: + * cache.get(accessKey) => accountId | undefined + * cache.put(accessKey, accountId) + */ +export declare class AccountAccessKeyCache { + /** + * Max number of entries in the cache, after which the cache will be reset. + */ + static readonly MAX_ENTRIES = 1000; + /** + * The default path used for the accounts access key cache + */ + static get DEFAULT_PATH(): string; + private readonly cacheFile; + private readonly debug; + /** + * @param filePath Path to the cache file + */ + constructor(filePath: string | undefined, debugFn: (msg: string) => Promise); + /** + * Tries to fetch the account ID from cache. If it's not in the cache, invokes + * the resolver function which should retrieve the account ID and return it. + * Then, it will be stored into disk cache returned. + * + * Example: + * + * const accountId = cache.fetch(accessKey, async () => { + * return await fetchAccountIdFromSomewhere(accessKey); + * }); + */ + fetch(accessKeyId: string, resolver: () => Promise): Promise; + /** Get the account ID from an access key or undefined if not in cache */ + get(accessKeyId: string): Promise; + /** Put a mapping between access key and account ID */ + put(accessKeyId: string, account: Account): Promise; + private loadMap; + private saveMap; +} diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/account-cache.js b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/account-cache.js new file mode 100644 index 000000000..2780f2167 --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/account-cache.js @@ -0,0 +1,108 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.AccountAccessKeyCache = void 0; +const path = require("path"); +const fs = require("fs-extra"); +const util_1 = require("../../util"); +/** + * Disk cache which maps access key IDs to account IDs. + * Usage: + * cache.get(accessKey) => accountId | undefined + * cache.put(accessKey, accountId) + */ +class AccountAccessKeyCache { + /** + * Max number of entries in the cache, after which the cache will be reset. + */ + static MAX_ENTRIES = 1000; + /** + * The default path used for the accounts access key cache + */ + static get DEFAULT_PATH() { + // needs to be a getter because cdkCacheDir can be set via env variable and might change + return path.join((0, util_1.cdkCacheDir)(), 'accounts_partitions.json'); + } + cacheFile; + debug; + /** + * @param filePath Path to the cache file + */ + constructor(filePath = AccountAccessKeyCache.DEFAULT_PATH, debugFn) { + this.cacheFile = filePath; + this.debug = debugFn; + } + /** + * Tries to fetch the account ID from cache. If it's not in the cache, invokes + * the resolver function which should retrieve the account ID and return it. + * Then, it will be stored into disk cache returned. + * + * Example: + * + * const accountId = cache.fetch(accessKey, async () => { + * return await fetchAccountIdFromSomewhere(accessKey); + * }); + */ + async fetch(accessKeyId, resolver) { + // try to get account ID based on this access key ID from disk. + const cached = await this.get(accessKeyId); + if (cached) { + await this.debug(`Retrieved account ID ${cached.accountId} from disk cache`); + return cached; + } + // if it's not in the cache, resolve and put in cache. + const account = await resolver(); + if (account) { + await this.put(accessKeyId, account); + } + return account; + } + /** Get the account ID from an access key or undefined if not in cache */ + async get(accessKeyId) { + const map = await this.loadMap(); + return map[accessKeyId]; + } + /** Put a mapping between access key and account ID */ + async put(accessKeyId, account) { + let map = await this.loadMap(); + // nuke cache if it's too big. + if (Object.keys(map).length >= AccountAccessKeyCache.MAX_ENTRIES) { + map = {}; + } + map[accessKeyId] = account; + await this.saveMap(map); + } + async loadMap() { + try { + return await fs.readJson(this.cacheFile); + } + catch (e) { + // File doesn't exist or is not readable. This is a cache, + // pretend we successfully loaded an empty map. + if (e.code === 'ENOENT' || e.code === 'EACCES') { + return {}; + } + // File is not JSON, could be corrupted because of concurrent writes. + // Again, an empty cache is fine. + if (e instanceof SyntaxError) { + return {}; + } + throw e; + } + } + async saveMap(map) { + try { + await fs.ensureFile(this.cacheFile); + await fs.writeJson(this.cacheFile, map, { spaces: 2 }); + } + catch (e) { + // File doesn't exist or file/dir isn't writable. This is a cache, + // if we can't write it then too bad. + if (e.code === 'ENOENT' || e.code === 'EACCES' || e.code === 'EROFS') { + return; + } + throw e; + } + } +} +exports.AccountAccessKeyCache = AccountAccessKeyCache; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"account-cache.js","sourceRoot":"","sources":["../../../src/api/aws-auth/account-cache.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'path';\nimport * as fs from 'fs-extra';\nimport type { Account } from './sdk-provider';\nimport { cdkCacheDir } from '../../util';\n\n/**\n * Disk cache which maps access key IDs to account IDs.\n * Usage:\n *   cache.get(accessKey) => accountId | undefined\n *   cache.put(accessKey, accountId)\n */\nexport class AccountAccessKeyCache {\n  /**\n   * Max number of entries in the cache, after which the cache will be reset.\n   */\n  public static readonly MAX_ENTRIES = 1000;\n\n  /**\n   * The default path used for the accounts access key cache\n   */\n  public static get DEFAULT_PATH(): string {\n    // needs to be a getter because cdkCacheDir can be set via env variable and might change\n    return path.join(cdkCacheDir(), 'accounts_partitions.json');\n  }\n\n  private readonly cacheFile: string;\n\n  private readonly debug: (msg: string) => Promise<void>;\n\n  /**\n   * @param filePath Path to the cache file\n   */\n  constructor(filePath: string = AccountAccessKeyCache.DEFAULT_PATH, debugFn: (msg: string) => Promise<void>) {\n    this.cacheFile = filePath;\n    this.debug = debugFn;\n  }\n\n  /**\n   * Tries to fetch the account ID from cache. If it's not in the cache, invokes\n   * the resolver function which should retrieve the account ID and return it.\n   * Then, it will be stored into disk cache returned.\n   *\n   * Example:\n   *\n   *    const accountId = cache.fetch(accessKey, async () => {\n   *      return await fetchAccountIdFromSomewhere(accessKey);\n   *    });\n   */\n  public async fetch<A extends Account>(accessKeyId: string, resolver: () => Promise<A>) {\n    // try to get account ID based on this access key ID from disk.\n    const cached = await this.get(accessKeyId);\n    if (cached) {\n      await this.debug(`Retrieved account ID ${cached.accountId} from disk cache`);\n      return cached;\n    }\n\n    // if it's not in the cache, resolve and put in cache.\n    const account = await resolver();\n    if (account) {\n      await this.put(accessKeyId, account);\n    }\n\n    return account;\n  }\n\n  /** Get the account ID from an access key or undefined if not in cache */\n  public async get(accessKeyId: string): Promise<Account | undefined> {\n    const map = await this.loadMap();\n    return map[accessKeyId];\n  }\n\n  /** Put a mapping between access key and account ID */\n  public async put(accessKeyId: string, account: Account) {\n    let map = await this.loadMap();\n\n    // nuke cache if it's too big.\n    if (Object.keys(map).length >= AccountAccessKeyCache.MAX_ENTRIES) {\n      map = {};\n    }\n\n    map[accessKeyId] = account;\n    await this.saveMap(map);\n  }\n\n  private async loadMap(): Promise<{ [accessKeyId: string]: Account }> {\n    try {\n      return await fs.readJson(this.cacheFile);\n    } catch (e: any) {\n      // File doesn't exist or is not readable. This is a cache,\n      // pretend we successfully loaded an empty map.\n      if (e.code === 'ENOENT' || e.code === 'EACCES') {\n        return {};\n      }\n      // File is not JSON, could be corrupted because of concurrent writes.\n      // Again, an empty cache is fine.\n      if (e instanceof SyntaxError) {\n        return {};\n      }\n      throw e;\n    }\n  }\n\n  private async saveMap(map: { [accessKeyId: string]: Account }) {\n    try {\n      await fs.ensureFile(this.cacheFile);\n      await fs.writeJson(this.cacheFile, map, { spaces: 2 });\n    } catch (e: any) {\n      // File doesn't exist or file/dir isn't writable. This is a cache,\n      // if we can't write it then too bad.\n      if (e.code === 'ENOENT' || e.code === 'EACCES' || e.code === 'EROFS') {\n        return;\n      }\n      throw e;\n    }\n  }\n}\n"]} \ No newline at end of file diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/awscli-compatible.d.ts b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/awscli-compatible.d.ts new file mode 100644 index 000000000..dca462d34 --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/awscli-compatible.d.ts @@ -0,0 +1,70 @@ +import type { NodeHttpHandlerOptions } from '@smithy/node-http-handler'; +import type { AwsCredentialIdentityProvider, Logger } from '@smithy/types'; +import type { SdkHttpOptions } from './sdk-provider'; +import { type IoHelper } from '../io/private'; +/** + * Behaviors to match AWS CLI + * + * See these links: + * + * https://docs.aws.amazon.com/cli/latest/topic/config-vars.html + * https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-envvars.html + */ +export declare class AwsCliCompatible { + private readonly ioHelper; + private readonly requestHandler; + private readonly logger?; + constructor(ioHelper: IoHelper, requestHandler: NodeHttpHandlerOptions, logger?: Logger); + baseConfig(profile?: string): Promise<{ + credentialProvider: AwsCredentialIdentityProvider; + defaultRegion: string; + }>; + /** + * Build an AWS CLI-compatible credential chain provider + * + * The credential chain returned by this function is always caching. + */ + credentialChainBuilder(options?: CredentialChainOptions): Promise; + /** + * Attempts to get the region from a number of sources and falls back to us-east-1 if no region can be found, + * as is done in the AWS CLI. + * + * The order of priority is the following: + * + * 1. Environment variables specifying region, with both an AWS prefix and AMAZON prefix + * to maintain backwards compatibility, and without `DEFAULT` in the name because + * Lambda and CodeBuild set the $AWS_REGION variable. + * 2. Regions listed in the Shared Ini Files - First checking for the profile provided + * and then checking for the default profile. + * 3. IMDS instance identity region from the Metadata Service. + * 4. us-east-1 + */ + region(maybeProfile?: string): Promise; + /** + * The MetadataService class will attempt to fetch the instance identity document from + * IMDSv2 first, and then will attempt v1 as a fallback. + * + * If this fails, we will use us-east-1 as the region so no error should be thrown. + * @returns The region for the instance identity + */ + private regionFromMetadataService; + /** + * Looks up the region of the provided profile. If no region is present, + * it will attempt to lookup the default region. + * @param profile The profile to use to lookup the region + * @returns The region for the profile or default profile, if present. Otherwise returns undefined. + */ + private getRegionFromIni; + private getRegionFromIniFile; + /** + * Ask user for MFA token for given serial + * + * Result is send to callback function for SDK to authorize the request + */ + private tokenCodeFn; +} +export interface CredentialChainOptions { + readonly profile?: string; + readonly logger?: Logger; +} +export declare function makeRequestHandler(ioHelper: IoHelper, options?: SdkHttpOptions): Promise; diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/awscli-compatible.js b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/awscli-compatible.js new file mode 100644 index 000000000..0edd7e1b5 --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/awscli-compatible.js @@ -0,0 +1,250 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.AwsCliCompatible = void 0; +exports.makeRequestHandler = makeRequestHandler; +const node_util_1 = require("node:util"); +const credential_providers_1 = require("@aws-sdk/credential-providers"); +const ec2_metadata_service_1 = require("@aws-sdk/ec2-metadata-service"); +const shared_ini_file_loader_1 = require("@smithy/shared-ini-file-loader"); +const promptly = require("promptly"); +const provider_caching_1 = require("./provider-caching"); +const proxy_agent_1 = require("./proxy-agent"); +const private_1 = require("../io/private"); +const toolkit_error_1 = require("../toolkit-error"); +const DEFAULT_CONNECTION_TIMEOUT = 10000; +const DEFAULT_TIMEOUT = 300000; +/** + * Behaviors to match AWS CLI + * + * See these links: + * + * https://docs.aws.amazon.com/cli/latest/topic/config-vars.html + * https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-envvars.html + */ +class AwsCliCompatible { + ioHelper; + requestHandler; + logger; + constructor(ioHelper, requestHandler, logger) { + this.ioHelper = ioHelper; + this.requestHandler = requestHandler; + this.logger = logger; + } + async baseConfig(profile) { + const credentialProvider = await this.credentialChainBuilder({ + profile, + logger: this.logger, + }); + const defaultRegion = await this.region(profile); + return { credentialProvider, defaultRegion }; + } + /** + * Build an AWS CLI-compatible credential chain provider + * + * The credential chain returned by this function is always caching. + */ + async credentialChainBuilder(options = {}) { + const clientConfig = { + requestHandler: this.requestHandler, + customUserAgent: 'aws-cdk', + logger: options.logger, + }; + // Super hacky solution to https://github.com/aws/aws-cdk/issues/32510, proposed by the SDK team. + // + // Summary of the problem: we were reading the region from the config file and passing it to + // the credential providers. However, in the case of SSO, this makes the credential provider + // use that region to do the SSO flow, which is incorrect. The region that should be used for + // that is the one set in the sso_session section of the config file. + // + // The idea here: the "clientConfig" is for configuring the inner auth client directly, + // and has the highest priority, whereas "parentClientConfig" is the upper data client + // and has lower priority than the sso_region but still higher priority than STS global region. + const parentClientConfig = { + region: await this.region(options.profile), + }; + /** + * The previous implementation matched AWS CLI behavior: + * + * If a profile is explicitly set using `--profile`, + * we use that to the exclusion of everything else. + * + * Note: this does not apply to AWS_PROFILE, + * environment credentials still take precedence over AWS_PROFILE + */ + if (options.profile) { + return (0, provider_caching_1.makeCachingProvider)((0, credential_providers_1.fromIni)({ + profile: options.profile, + ignoreCache: true, + mfaCodeProvider: this.tokenCodeFn.bind(this), + clientConfig, + parentClientConfig, + logger: options.logger, + })); + } + const envProfile = process.env.AWS_PROFILE || process.env.AWS_DEFAULT_PROFILE; + /** + * Env AWS - EnvironmentCredentials with string AWS + * Env Amazon - EnvironmentCredentials with string AMAZON + * Profile Credentials - PatchedSharedIniFileCredentials with implicit profile, credentials file, http options, and token fn + * SSO with implicit profile only + * SharedIniFileCredentials with implicit profile and preferStaticCredentials true (profile with source_profile) + * Shared Credential file that points to Environment Credentials with AWS prefix + * Shared Credential file that points to EC2 Metadata + * Shared Credential file that points to ECS Credentials + * SSO Credentials - SsoCredentials with implicit profile and http options + * ProcessCredentials with implicit profile + * ECS Credentials - ECSCredentials with no input OR Web Identity - TokenFileWebIdentityCredentials with no input OR EC2 Metadata - EC2MetadataCredentials with no input + * + * These translate to: + * fromEnv() + * fromSSO()/fromIni() + * fromProcess() + * fromContainerMetadata() + * fromTokenFile() + * fromInstanceMetadata() + * + * The NodeProviderChain is already cached. + */ + const nodeProviderChain = (0, credential_providers_1.fromNodeProviderChain)({ + profile: envProfile, + clientConfig, + parentClientConfig, + logger: options.logger, + mfaCodeProvider: this.tokenCodeFn.bind(this), + ignoreCache: true, + }); + return shouldPrioritizeEnv() + ? (0, credential_providers_1.createCredentialChain)((0, credential_providers_1.fromEnv)(), nodeProviderChain).expireAfter(60 * 60_000) + : nodeProviderChain; + } + /** + * Attempts to get the region from a number of sources and falls back to us-east-1 if no region can be found, + * as is done in the AWS CLI. + * + * The order of priority is the following: + * + * 1. Environment variables specifying region, with both an AWS prefix and AMAZON prefix + * to maintain backwards compatibility, and without `DEFAULT` in the name because + * Lambda and CodeBuild set the $AWS_REGION variable. + * 2. Regions listed in the Shared Ini Files - First checking for the profile provided + * and then checking for the default profile. + * 3. IMDS instance identity region from the Metadata Service. + * 4. us-east-1 + */ + async region(maybeProfile) { + const defaultRegion = 'us-east-1'; + const profile = maybeProfile || process.env.AWS_PROFILE || process.env.AWS_DEFAULT_PROFILE || 'default'; + const region = process.env.AWS_REGION || + process.env.AMAZON_REGION || + process.env.AWS_DEFAULT_REGION || + process.env.AMAZON_DEFAULT_REGION || + (await this.getRegionFromIni(profile)) || + (await this.regionFromMetadataService()); + if (!region) { + const usedProfile = !profile ? '' : ` (profile: "${profile}")`; + await this.ioHelper.notify(private_1.IO.DEFAULT_SDK_DEBUG.msg(`Unable to determine AWS region from environment or AWS configuration${usedProfile}, defaulting to '${defaultRegion}'`)); + return defaultRegion; + } + return region; + } + /** + * The MetadataService class will attempt to fetch the instance identity document from + * IMDSv2 first, and then will attempt v1 as a fallback. + * + * If this fails, we will use us-east-1 as the region so no error should be thrown. + * @returns The region for the instance identity + */ + async regionFromMetadataService() { + await this.ioHelper.notify(private_1.IO.DEFAULT_SDK_DEBUG.msg('Looking up AWS region in the EC2 Instance Metadata Service (IMDS).')); + try { + const metadataService = new ec2_metadata_service_1.MetadataService({ + httpOptions: { + timeout: 1000, + }, + }); + await metadataService.fetchMetadataToken(); + const document = await metadataService.request('/latest/dynamic/instance-identity/document', {}); + return JSON.parse(document).region; + } + catch (e) { + await this.ioHelper.notify(private_1.IO.DEFAULT_SDK_DEBUG.msg(`Unable to retrieve AWS region from IMDS: ${e}`)); + } + } + /** + * Looks up the region of the provided profile. If no region is present, + * it will attempt to lookup the default region. + * @param profile The profile to use to lookup the region + * @returns The region for the profile or default profile, if present. Otherwise returns undefined. + */ + async getRegionFromIni(profile) { + const sharedFiles = await (0, shared_ini_file_loader_1.loadSharedConfigFiles)({ ignoreCache: true }); + // Priority: + // + // credentials come before config because aws-cli v1 behaves like that. + // + // 1. profile-region-in-credentials + // 2. profile-region-in-config + // 3. default-region-in-credentials + // 4. default-region-in-config + return this.getRegionFromIniFile(profile, sharedFiles.credentialsFile) + ?? this.getRegionFromIniFile(profile, sharedFiles.configFile) + ?? this.getRegionFromIniFile('default', sharedFiles.credentialsFile) + ?? this.getRegionFromIniFile('default', sharedFiles.configFile); + } + getRegionFromIniFile(profile, data) { + return data?.[profile]?.region; + } + /** + * Ask user for MFA token for given serial + * + * Result is send to callback function for SDK to authorize the request + */ + async tokenCodeFn(serialArn) { + const debugFn = (msg, ...args) => this.ioHelper.notify(private_1.IO.DEFAULT_SDK_DEBUG.msg((0, node_util_1.format)(msg, ...args))); + await debugFn('Require MFA token for serial ARN', serialArn); + try { + const token = await promptly.prompt(`MFA token for ${serialArn}: `, { + trim: true, + default: '', + }); + await debugFn('Successfully got MFA token from user'); + return token; + } + catch (err) { + await debugFn('Failed to get MFA token', err); + const e = new toolkit_error_1.AuthenticationError(`Error fetching MFA token: ${err.message ?? err}`); + e.name = 'SharedIniFileCredentialsProviderFailure'; + throw e; + } + } +} +exports.AwsCliCompatible = AwsCliCompatible; +/** + * We used to support both AWS and AMAZON prefixes for these environment variables. + * + * Adding this for backward compatibility. + */ +function shouldPrioritizeEnv() { + const id = process.env.AWS_ACCESS_KEY_ID || process.env.AMAZON_ACCESS_KEY_ID; + const key = process.env.AWS_SECRET_ACCESS_KEY || process.env.AMAZON_SECRET_ACCESS_KEY; + if (!!id && !!key) { + process.env.AWS_ACCESS_KEY_ID = id; + process.env.AWS_SECRET_ACCESS_KEY = key; + const sessionToken = process.env.AWS_SESSION_TOKEN ?? process.env.AMAZON_SESSION_TOKEN; + if (sessionToken) { + process.env.AWS_SESSION_TOKEN = sessionToken; + } + return true; + } + return false; +} +async function makeRequestHandler(ioHelper, options = {}) { + const agent = await new proxy_agent_1.ProxyAgentProvider(ioHelper).create(options); + return { + connectionTimeout: DEFAULT_CONNECTION_TIMEOUT, + requestTimeout: DEFAULT_TIMEOUT, + httpsAgent: agent, + httpAgent: agent, + }; +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"awscli-compatible.js","sourceRoot":"","sources":["../../../src/api/aws-auth/awscli-compatible.ts"],"names":[],"mappings":"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","sourcesContent":["import { format } from 'node:util';\nimport { createCredentialChain, fromEnv, fromIni, fromNodeProviderChain } from '@aws-sdk/credential-providers';\nimport { MetadataService } from '@aws-sdk/ec2-metadata-service';\nimport type { NodeHttpHandlerOptions } from '@smithy/node-http-handler';\nimport { loadSharedConfigFiles } from '@smithy/shared-ini-file-loader';\nimport type { AwsCredentialIdentityProvider, Logger } from '@smithy/types';\nimport * as promptly from 'promptly';\nimport { makeCachingProvider } from './provider-caching';\nimport { ProxyAgentProvider } from './proxy-agent';\nimport type { SdkHttpOptions } from './sdk-provider';\nimport { IO, type IoHelper } from '../io/private';\nimport { AuthenticationError } from '../toolkit-error';\n\nconst DEFAULT_CONNECTION_TIMEOUT = 10000;\nconst DEFAULT_TIMEOUT = 300000;\n\n/**\n * Behaviors to match AWS CLI\n *\n * See these links:\n *\n * https://docs.aws.amazon.com/cli/latest/topic/config-vars.html\n * https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-envvars.html\n */\nexport class AwsCliCompatible {\n  private readonly ioHelper: IoHelper;\n  private readonly requestHandler: NodeHttpHandlerOptions;\n  private readonly logger?: Logger;\n\n  public constructor(ioHelper: IoHelper, requestHandler: NodeHttpHandlerOptions, logger?: Logger) {\n    this.ioHelper = ioHelper;\n    this.requestHandler = requestHandler;\n    this.logger = logger;\n  }\n\n  public async baseConfig(profile?: string): Promise<{ credentialProvider: AwsCredentialIdentityProvider; defaultRegion: string }> {\n    const credentialProvider = await this.credentialChainBuilder({\n      profile,\n      logger: this.logger,\n    });\n    const defaultRegion = await this.region(profile);\n    return { credentialProvider, defaultRegion };\n  }\n\n  /**\n   * Build an AWS CLI-compatible credential chain provider\n   *\n   * The credential chain returned by this function is always caching.\n   */\n  public async credentialChainBuilder(\n    options: CredentialChainOptions = {},\n  ): Promise<AwsCredentialIdentityProvider> {\n    const clientConfig = {\n      requestHandler: this.requestHandler,\n      customUserAgent: 'aws-cdk',\n      logger: options.logger,\n    };\n\n    // Super hacky solution to https://github.com/aws/aws-cdk/issues/32510, proposed by the SDK team.\n    //\n    // Summary of the problem: we were reading the region from the config file and passing it to\n    // the credential providers. However, in the case of SSO, this makes the credential provider\n    // use that region to do the SSO flow, which is incorrect. The region that should be used for\n    // that is the one set in the sso_session section of the config file.\n    //\n    // The idea here: the \"clientConfig\" is for configuring the inner auth client directly,\n    // and has the highest priority, whereas \"parentClientConfig\" is the upper data client\n    // and has lower priority than the sso_region but still higher priority than STS global region.\n    const parentClientConfig = {\n      region: await this.region(options.profile),\n    };\n    /**\n     * The previous implementation matched AWS CLI behavior:\n     *\n     * If a profile is explicitly set using `--profile`,\n     * we use that to the exclusion of everything else.\n     *\n     * Note: this does not apply to AWS_PROFILE,\n     * environment credentials still take precedence over AWS_PROFILE\n     */\n    if (options.profile) {\n      return makeCachingProvider(fromIni({\n        profile: options.profile,\n        ignoreCache: true,\n        mfaCodeProvider: this.tokenCodeFn.bind(this),\n        clientConfig,\n        parentClientConfig,\n        logger: options.logger,\n      }));\n    }\n\n    const envProfile = process.env.AWS_PROFILE || process.env.AWS_DEFAULT_PROFILE;\n\n    /**\n     * Env AWS - EnvironmentCredentials with string AWS\n     * Env Amazon - EnvironmentCredentials with string AMAZON\n     * Profile Credentials - PatchedSharedIniFileCredentials with implicit profile, credentials file, http options, and token fn\n     *    SSO with implicit profile only\n     *    SharedIniFileCredentials with implicit profile and preferStaticCredentials true (profile with source_profile)\n     *    Shared Credential file that points to Environment Credentials with AWS prefix\n     *    Shared Credential file that points to EC2 Metadata\n     *    Shared Credential file that points to ECS Credentials\n     * SSO Credentials - SsoCredentials with implicit profile and http options\n     * ProcessCredentials with implicit profile\n     * ECS Credentials - ECSCredentials with no input OR Web Identity - TokenFileWebIdentityCredentials with no input OR EC2 Metadata - EC2MetadataCredentials with no input\n     *\n     * These translate to:\n     * fromEnv()\n     * fromSSO()/fromIni()\n     * fromProcess()\n     * fromContainerMetadata()\n     * fromTokenFile()\n     * fromInstanceMetadata()\n     *\n     * The NodeProviderChain is already cached.\n     */\n    const nodeProviderChain = fromNodeProviderChain({\n      profile: envProfile,\n      clientConfig,\n      parentClientConfig,\n      logger: options.logger,\n      mfaCodeProvider: this.tokenCodeFn.bind(this),\n      ignoreCache: true,\n    });\n\n    return shouldPrioritizeEnv()\n      ? createCredentialChain(fromEnv(), nodeProviderChain).expireAfter(60 * 60_000)\n      : nodeProviderChain;\n  }\n\n  /**\n   * Attempts to get the region from a number of sources and falls back to us-east-1 if no region can be found,\n   * as is done in the AWS CLI.\n   *\n   * The order of priority is the following:\n   *\n   * 1. Environment variables specifying region, with both an AWS prefix and AMAZON prefix\n   *    to maintain backwards compatibility, and without `DEFAULT` in the name because\n   *    Lambda and CodeBuild set the $AWS_REGION variable.\n   * 2. Regions listed in the Shared Ini Files - First checking for the profile provided\n   *    and then checking for the default profile.\n   * 3. IMDS instance identity region from the Metadata Service.\n   * 4. us-east-1\n   */\n  public async region(maybeProfile?: string): Promise<string> {\n    const defaultRegion = 'us-east-1';\n    const profile = maybeProfile || process.env.AWS_PROFILE || process.env.AWS_DEFAULT_PROFILE || 'default';\n\n    const region =\n      process.env.AWS_REGION ||\n      process.env.AMAZON_REGION ||\n      process.env.AWS_DEFAULT_REGION ||\n      process.env.AMAZON_DEFAULT_REGION ||\n      (await this.getRegionFromIni(profile)) ||\n      (await this.regionFromMetadataService());\n\n    if (!region) {\n      const usedProfile = !profile ? '' : ` (profile: \"${profile}\")`;\n      await this.ioHelper.notify(IO.DEFAULT_SDK_DEBUG.msg(\n        `Unable to determine AWS region from environment or AWS configuration${usedProfile}, defaulting to '${defaultRegion}'`,\n      ));\n      return defaultRegion;\n    }\n\n    return region;\n  }\n\n  /**\n   * The MetadataService class will attempt to fetch the instance identity document from\n   * IMDSv2 first, and then will attempt v1 as a fallback.\n   *\n   * If this fails, we will use us-east-1 as the region so no error should be thrown.\n   * @returns The region for the instance identity\n   */\n  private async regionFromMetadataService() {\n    await this.ioHelper.notify(IO.DEFAULT_SDK_DEBUG.msg('Looking up AWS region in the EC2 Instance Metadata Service (IMDS).'));\n    try {\n      const metadataService = new MetadataService({\n        httpOptions: {\n          timeout: 1000,\n        },\n      });\n\n      await metadataService.fetchMetadataToken();\n      const document = await metadataService.request('/latest/dynamic/instance-identity/document', {});\n      return JSON.parse(document).region;\n    } catch (e) {\n      await this.ioHelper.notify(IO.DEFAULT_SDK_DEBUG.msg(`Unable to retrieve AWS region from IMDS: ${e}`));\n    }\n  }\n\n  /**\n   * Looks up the region of the provided profile. If no region is present,\n   * it will attempt to lookup the default region.\n   * @param profile The profile to use to lookup the region\n   * @returns The region for the profile or default profile, if present. Otherwise returns undefined.\n   */\n  private async getRegionFromIni(profile: string): Promise<string | undefined> {\n    const sharedFiles = await loadSharedConfigFiles({ ignoreCache: true });\n\n    // Priority:\n    //\n    // credentials come before config because aws-cli v1 behaves like that.\n    //\n    // 1. profile-region-in-credentials\n    // 2. profile-region-in-config\n    // 3. default-region-in-credentials\n    // 4. default-region-in-config\n\n    return this.getRegionFromIniFile(profile, sharedFiles.credentialsFile)\n    ?? this.getRegionFromIniFile(profile, sharedFiles.configFile)\n    ?? this.getRegionFromIniFile('default', sharedFiles.credentialsFile)\n    ?? this.getRegionFromIniFile('default', sharedFiles.configFile);\n  }\n\n  private getRegionFromIniFile(profile: string, data?: any) {\n    return data?.[profile]?.region;\n  }\n\n  /**\n   * Ask user for MFA token for given serial\n   *\n   * Result is send to callback function for SDK to authorize the request\n   */\n  private async tokenCodeFn(serialArn: string): Promise<string> {\n    const debugFn = (msg: string, ...args: any[]) => this.ioHelper.notify(IO.DEFAULT_SDK_DEBUG.msg(format(msg, ...args)));\n    await debugFn('Require MFA token for serial ARN', serialArn);\n    try {\n      const token: string = await promptly.prompt(`MFA token for ${serialArn}: `, {\n        trim: true,\n        default: '',\n      });\n      await debugFn('Successfully got MFA token from user');\n      return token;\n    } catch (err: any) {\n      await debugFn('Failed to get MFA token', err);\n      const e = new AuthenticationError(`Error fetching MFA token: ${err.message ?? err}`);\n      e.name = 'SharedIniFileCredentialsProviderFailure';\n      throw e;\n    }\n  }\n}\n\n/**\n * We used to support both AWS and AMAZON prefixes for these environment variables.\n *\n * Adding this for backward compatibility.\n */\nfunction shouldPrioritizeEnv() {\n  const id = process.env.AWS_ACCESS_KEY_ID || process.env.AMAZON_ACCESS_KEY_ID;\n  const key = process.env.AWS_SECRET_ACCESS_KEY || process.env.AMAZON_SECRET_ACCESS_KEY;\n\n  if (!!id && !!key) {\n    process.env.AWS_ACCESS_KEY_ID = id;\n    process.env.AWS_SECRET_ACCESS_KEY = key;\n\n    const sessionToken = process.env.AWS_SESSION_TOKEN ?? process.env.AMAZON_SESSION_TOKEN;\n    if (sessionToken) {\n      process.env.AWS_SESSION_TOKEN = sessionToken;\n    }\n\n    return true;\n  }\n\n  return false;\n}\n\nexport interface CredentialChainOptions {\n  readonly profile?: string;\n  readonly logger?: Logger;\n}\n\nexport async function makeRequestHandler(ioHelper: IoHelper, options: SdkHttpOptions = {}): Promise<NodeHttpHandlerOptions> {\n  const agent = await new ProxyAgentProvider(ioHelper).create(options);\n\n  return {\n    connectionTimeout: DEFAULT_CONNECTION_TIMEOUT,\n    requestTimeout: DEFAULT_TIMEOUT,\n    httpsAgent: agent,\n    httpAgent: agent,\n  };\n}\n"]} \ No newline at end of file diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/cached.d.ts b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/cached.d.ts new file mode 100644 index 000000000..d2a9c2a27 --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/cached.d.ts @@ -0,0 +1,11 @@ +/** + * Cache the result of a function on an object + * + * We could have used @decorators to make this nicer but we don't use them anywhere yet, + * so let's keep it simple and readable. + */ +export declare function cached(obj: A, sym: symbol, fn: () => B): B; +/** + * Like 'cached', but async + */ +export declare function cachedAsync(obj: A, sym: symbol, fn: () => Promise): Promise; diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/cached.js b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/cached.js new file mode 100644 index 000000000..3a006ab94 --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/cached.js @@ -0,0 +1,26 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.cached = cached; +exports.cachedAsync = cachedAsync; +/** + * Cache the result of a function on an object + * + * We could have used @decorators to make this nicer but we don't use them anywhere yet, + * so let's keep it simple and readable. + */ +function cached(obj, sym, fn) { + if (!(sym in obj)) { + obj[sym] = fn(); + } + return obj[sym]; +} +/** + * Like 'cached', but async + */ +async function cachedAsync(obj, sym, fn) { + if (!(sym in obj)) { + obj[sym] = await fn(); + } + return obj[sym]; +} +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FjaGVkLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2FwaS9hd3MtYXV0aC9jYWNoZWQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFNQSx3QkFLQztBQUtELGtDQUtDO0FBckJEOzs7OztHQUtHO0FBQ0gsU0FBZ0IsTUFBTSxDQUFzQixHQUFNLEVBQUUsR0FBVyxFQUFFLEVBQVc7SUFDMUUsSUFBSSxDQUFDLENBQUMsR0FBRyxJQUFJLEdBQUcsQ0FBQyxFQUFFLENBQUM7UUFDakIsR0FBVyxDQUFDLEdBQUcsQ0FBQyxHQUFHLEVBQUUsRUFBRSxDQUFDO0lBQzNCLENBQUM7SUFDRCxPQUFRLEdBQVcsQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUMzQixDQUFDO0FBRUQ7O0dBRUc7QUFDSSxLQUFLLFVBQVUsV0FBVyxDQUFzQixHQUFNLEVBQUUsR0FBVyxFQUFFLEVBQW9CO0lBQzlGLElBQUksQ0FBQyxDQUFDLEdBQUcsSUFBSSxHQUFHLENBQUMsRUFBRSxDQUFDO1FBQ2pCLEdBQVcsQ0FBQyxHQUFHLENBQUMsR0FBRyxNQUFNLEVBQUUsRUFBRSxDQUFDO0lBQ2pDLENBQUM7SUFDRCxPQUFRLEdBQVcsQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUMzQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDYWNoZSB0aGUgcmVzdWx0IG9mIGEgZnVuY3Rpb24gb24gYW4gb2JqZWN0XG4gKlxuICogV2UgY291bGQgaGF2ZSB1c2VkIEBkZWNvcmF0b3JzIHRvIG1ha2UgdGhpcyBuaWNlciBidXQgd2UgZG9uJ3QgdXNlIHRoZW0gYW55d2hlcmUgeWV0LFxuICogc28gbGV0J3Mga2VlcCBpdCBzaW1wbGUgYW5kIHJlYWRhYmxlLlxuICovXG5leHBvcnQgZnVuY3Rpb24gY2FjaGVkPEEgZXh0ZW5kcyBvYmplY3QsIEI+KG9iajogQSwgc3ltOiBzeW1ib2wsIGZuOiAoKSA9PiBCKTogQiB7XG4gIGlmICghKHN5bSBpbiBvYmopKSB7XG4gICAgKG9iaiBhcyBhbnkpW3N5bV0gPSBmbigpO1xuICB9XG4gIHJldHVybiAob2JqIGFzIGFueSlbc3ltXTtcbn1cblxuLyoqXG4gKiBMaWtlICdjYWNoZWQnLCBidXQgYXN5bmNcbiAqL1xuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIGNhY2hlZEFzeW5jPEEgZXh0ZW5kcyBvYmplY3QsIEI+KG9iajogQSwgc3ltOiBzeW1ib2wsIGZuOiAoKSA9PiBQcm9taXNlPEI+KTogUHJvbWlzZTxCPiB7XG4gIGlmICghKHN5bSBpbiBvYmopKSB7XG4gICAgKG9iaiBhcyBhbnkpW3N5bV0gPSBhd2FpdCBmbigpO1xuICB9XG4gIHJldHVybiAob2JqIGFzIGFueSlbc3ltXTtcbn1cbiJdfQ== \ No newline at end of file diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/credential-plugins.d.ts b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/credential-plugins.d.ts new file mode 100644 index 000000000..3f10b78f9 --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/credential-plugins.d.ts @@ -0,0 +1,38 @@ +import type { AwsCredentialIdentityProvider } from '@smithy/types'; +import { type IoHelper } from '../io/private'; +import type { PluginHost } from '../plugin'; +import type { Mode } from '../plugin/mode'; +/** + * Cache for credential providers. + * + * Given an account and an operating mode (read or write) will return an + * appropriate credential provider for credentials for the given account. The + * credential provider will be cached so that multiple AWS clients for the same + * environment will not make multiple network calls to obtain credentials. + * + * Will use default credentials if they are for the right account; otherwise, + * all loaded credential provider plugins will be tried to obtain credentials + * for the given account. + */ +export declare class CredentialPlugins { + private readonly host; + private readonly ioHelper; + private readonly cache; + constructor(host: PluginHost, ioHelper: IoHelper); + fetchCredentialsFor(awsAccountId: string, mode: Mode): Promise; + get availablePluginNames(): string[]; + private lookupCredentials; +} +/** + * Result from trying to fetch credentials from the Plugin host + */ +export interface PluginCredentialsFetchResult { + /** + * SDK-v3 compatible credential provider + */ + readonly credentials: AwsCredentialIdentityProvider; + /** + * Name of plugin that successfully provided credentials + */ + readonly pluginName: string; +} diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/credential-plugins.js b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/credential-plugins.js new file mode 100644 index 000000000..756d2f7b2 --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/credential-plugins.js @@ -0,0 +1,154 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.CredentialPlugins = void 0; +const util_1 = require("util"); +const provider_caching_1 = require("./provider-caching"); +const util_2 = require("../../util"); +const private_1 = require("../io/private"); +const toolkit_error_1 = require("../toolkit-error"); +/** + * Cache for credential providers. + * + * Given an account and an operating mode (read or write) will return an + * appropriate credential provider for credentials for the given account. The + * credential provider will be cached so that multiple AWS clients for the same + * environment will not make multiple network calls to obtain credentials. + * + * Will use default credentials if they are for the right account; otherwise, + * all loaded credential provider plugins will be tried to obtain credentials + * for the given account. + */ +class CredentialPlugins { + host; + ioHelper; + cache = {}; + constructor(host, ioHelper) { + this.host = host; + this.ioHelper = ioHelper; + } + async fetchCredentialsFor(awsAccountId, mode) { + const key = `${awsAccountId}-${mode}`; + if (!(key in this.cache)) { + this.cache[key] = await this.lookupCredentials(awsAccountId, mode); + } + return this.cache[key]; + } + get availablePluginNames() { + return this.host.credentialProviderSources.map((s) => s.name); + } + async lookupCredentials(awsAccountId, mode) { + const triedSources = []; + // Otherwise, inspect the various credential sources we have + for (const source of this.host.credentialProviderSources) { + let available; + try { + available = await source.isAvailable(); + } + catch (e) { + // This shouldn't happen, but let's guard against it anyway + await this.ioHelper.notify(private_1.IO.CDK_TOOLKIT_W0100.msg(`Uncaught exception in ${source.name}: ${(0, util_2.formatErrorMessage)(e)}`)); + available = false; + } + if (!available) { + await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg(`Credentials source ${source.name} is not available, ignoring it.`)); + continue; + } + triedSources.push(source); + let canProvide; + try { + canProvide = await source.canProvideCredentials(awsAccountId); + } + catch (e) { + // This shouldn't happen, but let's guard against it anyway + await this.ioHelper.notify(private_1.IO.CDK_TOOLKIT_W0100.msg(`Uncaught exception in ${source.name}: ${(0, util_2.formatErrorMessage)(e)}`)); + canProvide = false; + } + if (!canProvide) { + continue; + } + await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg(`Using ${source.name} credentials for account ${awsAccountId}`)); + return { + credentials: await v3ProviderFromPlugin(() => source.getProvider(awsAccountId, mode, { + supportsV3Providers: true, + })), + pluginName: source.name, + }; + } + return undefined; + } +} +exports.CredentialPlugins = CredentialPlugins; +/** + * Take a function that calls the plugin, and turn it into an SDKv3-compatible credential provider. + * + * What we will do is the following: + * + * - Query the plugin and see what kind of result it gives us. + * - If the result is self-refreshing or doesn't need refreshing, we turn it into an SDKv3 provider + * and return it directly. + * * If the underlying return value is a provider, we will make it a caching provider + * (because we can't know if it will cache by itself or not). + * * If the underlying return value is a static credential, caching isn't relevant. + * * If the underlying return value is V2 credentials, those have caching built-in. + * - If the result is a static credential that expires, we will wrap it in an SDKv3 provider + * that will query the plugin again when the credential expires. + */ +async function v3ProviderFromPlugin(producer) { + const initial = await producer(); + if (isV3Provider(initial)) { + // Already a provider, make caching + return (0, provider_caching_1.makeCachingProvider)(initial); + } + else if (isV3Credentials(initial) && initial.expiration === undefined) { + // Static credentials that don't need refreshing nor caching + return () => Promise.resolve(initial); + } + else if (isV3Credentials(initial) && initial.expiration !== undefined) { + // Static credentials that do need refreshing and caching + return refreshFromPluginProvider(initial, producer); + } + else if (isV2Credentials(initial)) { + // V2 credentials that refresh and cache themselves + return v3ProviderFromV2Credentials(initial); + } + else { + throw new toolkit_error_1.AuthenticationError(`Plugin returned a value that doesn't resemble AWS credentials: ${(0, util_1.inspect)(initial)}`); + } +} +/** + * Converts a V2 credential into a V3-compatible provider + */ +function v3ProviderFromV2Credentials(x) { + return async () => { + // Get will fetch or refresh as necessary + await x.getPromise(); + return { + accessKeyId: x.accessKeyId, + secretAccessKey: x.secretAccessKey, + sessionToken: x.sessionToken, + expiration: x.expireTime ?? undefined, + }; + }; +} +function refreshFromPluginProvider(current, producer) { + return async () => { + if ((0, provider_caching_1.credentialsAboutToExpire)(current)) { + const newCreds = await producer(); + if (!isV3Credentials(newCreds)) { + throw new toolkit_error_1.AuthenticationError(`Plugin initially returned static V3 credentials but now returned something else: ${(0, util_1.inspect)(newCreds)}`); + } + current = newCreds; + } + return current; + }; +} +function isV3Provider(x) { + return typeof x === 'function'; +} +function isV2Credentials(x) { + return !!(x && typeof x === 'object' && x.getPromise); +} +function isV3Credentials(x) { + return !!(x && typeof x === 'object' && x.accessKeyId && !isV2Credentials(x)); +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"credential-plugins.js","sourceRoot":"","sources":["../../../src/api/aws-auth/credential-plugins.ts"],"names":[],"mappings":"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","sourcesContent":["import { inspect } from 'util';\nimport type { CredentialProviderSource, ForReading, ForWriting, PluginProviderResult, SDKv2CompatibleCredentials, SDKv3CompatibleCredentialProvider, SDKv3CompatibleCredentials } from '@aws-cdk/cli-plugin-contract';\nimport type { AwsCredentialIdentity, AwsCredentialIdentityProvider } from '@smithy/types';\nimport { credentialsAboutToExpire, makeCachingProvider } from './provider-caching';\nimport { formatErrorMessage } from '../../util';\nimport { IO, type IoHelper } from '../io/private';\nimport type { PluginHost } from '../plugin';\nimport type { Mode } from '../plugin/mode';\nimport { AuthenticationError } from '../toolkit-error';\n\n/**\n * Cache for credential providers.\n *\n * Given an account and an operating mode (read or write) will return an\n * appropriate credential provider for credentials for the given account. The\n * credential provider will be cached so that multiple AWS clients for the same\n * environment will not make multiple network calls to obtain credentials.\n *\n * Will use default credentials if they are for the right account; otherwise,\n * all loaded credential provider plugins will be tried to obtain credentials\n * for the given account.\n */\nexport class CredentialPlugins {\n  private readonly cache: { [key: string]: PluginCredentialsFetchResult | undefined } = {};\n\n  constructor(private readonly host: PluginHost, private readonly ioHelper: IoHelper) {\n  }\n\n  public async fetchCredentialsFor(awsAccountId: string, mode: Mode): Promise<PluginCredentialsFetchResult | undefined> {\n    const key = `${awsAccountId}-${mode}`;\n    if (!(key in this.cache)) {\n      this.cache[key] = await this.lookupCredentials(awsAccountId, mode);\n    }\n    return this.cache[key];\n  }\n\n  public get availablePluginNames(): string[] {\n    return this.host.credentialProviderSources.map((s) => s.name);\n  }\n\n  private async lookupCredentials(awsAccountId: string, mode: Mode): Promise<PluginCredentialsFetchResult | undefined> {\n    const triedSources: CredentialProviderSource[] = [];\n    // Otherwise, inspect the various credential sources we have\n    for (const source of this.host.credentialProviderSources) {\n      let available: boolean;\n      try {\n        available = await source.isAvailable();\n      } catch (e: any) {\n        // This shouldn't happen, but let's guard against it anyway\n        await this.ioHelper.notify(IO.CDK_TOOLKIT_W0100.msg(`Uncaught exception in ${source.name}: ${formatErrorMessage(e)}`));\n        available = false;\n      }\n\n      if (!available) {\n        await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`Credentials source ${source.name} is not available, ignoring it.`));\n        continue;\n      }\n      triedSources.push(source);\n      let canProvide: boolean;\n      try {\n        canProvide = await source.canProvideCredentials(awsAccountId);\n      } catch (e: any) {\n        // This shouldn't happen, but let's guard against it anyway\n        await this.ioHelper.notify(IO.CDK_TOOLKIT_W0100.msg(`Uncaught exception in ${source.name}: ${formatErrorMessage(e)}`));\n        canProvide = false;\n      }\n      if (!canProvide) {\n        continue;\n      }\n      await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`Using ${source.name} credentials for account ${awsAccountId}`));\n\n      return {\n        credentials: await v3ProviderFromPlugin(() => source.getProvider(awsAccountId, mode as ForReading | ForWriting, {\n          supportsV3Providers: true,\n        })),\n        pluginName: source.name,\n      };\n    }\n    return undefined;\n  }\n}\n\n/**\n * Result from trying to fetch credentials from the Plugin host\n */\nexport interface PluginCredentialsFetchResult {\n  /**\n   * SDK-v3 compatible credential provider\n   */\n  readonly credentials: AwsCredentialIdentityProvider;\n\n  /**\n   * Name of plugin that successfully provided credentials\n   */\n  readonly pluginName: string;\n}\n\n/**\n * Take a function that calls the plugin, and turn it into an SDKv3-compatible credential provider.\n *\n * What we will do is the following:\n *\n * - Query the plugin and see what kind of result it gives us.\n * - If the result is self-refreshing or doesn't need refreshing, we turn it into an SDKv3 provider\n *   and return it directly.\n *   * If the underlying return value is a provider, we will make it a caching provider\n *     (because we can't know if it will cache by itself or not).\n *   * If the underlying return value is a static credential, caching isn't relevant.\n *   * If the underlying return value is V2 credentials, those have caching built-in.\n * - If the result is a static credential that expires, we will wrap it in an SDKv3 provider\n *   that will query the plugin again when the credential expires.\n */\nasync function v3ProviderFromPlugin(producer: () => Promise<PluginProviderResult>): Promise<AwsCredentialIdentityProvider> {\n  const initial = await producer();\n\n  if (isV3Provider(initial)) {\n    // Already a provider, make caching\n    return makeCachingProvider(initial);\n  } else if (isV3Credentials(initial) && initial.expiration === undefined) {\n    // Static credentials that don't need refreshing nor caching\n    return () => Promise.resolve(initial);\n  } else if (isV3Credentials(initial) && initial.expiration !== undefined) {\n    // Static credentials that do need refreshing and caching\n    return refreshFromPluginProvider(initial, producer);\n  } else if (isV2Credentials(initial)) {\n    // V2 credentials that refresh and cache themselves\n    return v3ProviderFromV2Credentials(initial);\n  } else {\n    throw new AuthenticationError(`Plugin returned a value that doesn't resemble AWS credentials: ${inspect(initial)}`);\n  }\n}\n\n/**\n * Converts a V2 credential into a V3-compatible provider\n */\nfunction v3ProviderFromV2Credentials(x: SDKv2CompatibleCredentials): AwsCredentialIdentityProvider {\n  return async () => {\n    // Get will fetch or refresh as necessary\n    await x.getPromise();\n\n    return {\n      accessKeyId: x.accessKeyId,\n      secretAccessKey: x.secretAccessKey,\n      sessionToken: x.sessionToken,\n      expiration: x.expireTime ?? undefined,\n    };\n  };\n}\n\nfunction refreshFromPluginProvider(current: AwsCredentialIdentity, producer: () => Promise<PluginProviderResult>): AwsCredentialIdentityProvider {\n  return async () => {\n    if (credentialsAboutToExpire(current)) {\n      const newCreds = await producer();\n      if (!isV3Credentials(newCreds)) {\n        throw new AuthenticationError(`Plugin initially returned static V3 credentials but now returned something else: ${inspect(newCreds)}`);\n      }\n      current = newCreds;\n    }\n    return current;\n  };\n}\n\nfunction isV3Provider(x: PluginProviderResult): x is SDKv3CompatibleCredentialProvider {\n  return typeof x === 'function';\n}\n\nfunction isV2Credentials(x: PluginProviderResult): x is SDKv2CompatibleCredentials {\n  return !!(x && typeof x === 'object' && (x as SDKv2CompatibleCredentials).getPromise);\n}\n\nfunction isV3Credentials(x: PluginProviderResult): x is SDKv3CompatibleCredentials {\n  return !!(x && typeof x === 'object' && x.accessKeyId && !isV2Credentials(x));\n}\n"]} \ No newline at end of file diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/index.d.ts b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/index.d.ts new file mode 100644 index 000000000..73dc4914e --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/index.d.ts @@ -0,0 +1,11 @@ +export * from './proxy-agent'; +export * from './sdk'; +export * from './sdk-provider'; +export * from './sdk-logger'; +export { AccountAccessKeyCache } from './account-cache'; +export { cached } from './cached'; +export { AwsCliCompatible } from './awscli-compatible'; +export { setSdkTracing } from './tracing'; +export { CredentialPlugins } from './credential-plugins'; +export { credentialsAboutToExpire } from './provider-caching'; +export { defaultCliUserAgent } from './user-agent'; diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/index.js b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/index.js new file mode 100644 index 000000000..8570a0995 --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/index.js @@ -0,0 +1,37 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __exportStar = (this && this.__exportStar) || function(m, exports) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.defaultCliUserAgent = exports.credentialsAboutToExpire = exports.CredentialPlugins = exports.setSdkTracing = exports.AwsCliCompatible = exports.cached = exports.AccountAccessKeyCache = void 0; +__exportStar(require("./proxy-agent"), exports); +__exportStar(require("./sdk"), exports); +__exportStar(require("./sdk-provider"), exports); +__exportStar(require("./sdk-logger"), exports); +// temporary testing exports +var account_cache_1 = require("./account-cache"); +Object.defineProperty(exports, "AccountAccessKeyCache", { enumerable: true, get: function () { return account_cache_1.AccountAccessKeyCache; } }); +var cached_1 = require("./cached"); +Object.defineProperty(exports, "cached", { enumerable: true, get: function () { return cached_1.cached; } }); +var awscli_compatible_1 = require("./awscli-compatible"); +Object.defineProperty(exports, "AwsCliCompatible", { enumerable: true, get: function () { return awscli_compatible_1.AwsCliCompatible; } }); +var tracing_1 = require("./tracing"); +Object.defineProperty(exports, "setSdkTracing", { enumerable: true, get: function () { return tracing_1.setSdkTracing; } }); +var credential_plugins_1 = require("./credential-plugins"); +Object.defineProperty(exports, "CredentialPlugins", { enumerable: true, get: function () { return credential_plugins_1.CredentialPlugins; } }); +var provider_caching_1 = require("./provider-caching"); +Object.defineProperty(exports, "credentialsAboutToExpire", { enumerable: true, get: function () { return provider_caching_1.credentialsAboutToExpire; } }); +var user_agent_1 = require("./user-agent"); +Object.defineProperty(exports, "defaultCliUserAgent", { enumerable: true, get: function () { return user_agent_1.defaultCliUserAgent; } }); +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXBpL2F3cy1hdXRoL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsZ0RBQThCO0FBQzlCLHdDQUFzQjtBQUN0QixpREFBK0I7QUFDL0IsK0NBQTZCO0FBRTdCLDRCQUE0QjtBQUM1QixpREFBd0Q7QUFBL0Msc0hBQUEscUJBQXFCLE9BQUE7QUFDOUIsbUNBQWtDO0FBQXpCLGdHQUFBLE1BQU0sT0FBQTtBQUNmLHlEQUF1RDtBQUE5QyxxSEFBQSxnQkFBZ0IsT0FBQTtBQUN6QixxQ0FBMEM7QUFBakMsd0dBQUEsYUFBYSxPQUFBO0FBQ3RCLDJEQUF5RDtBQUFoRCx1SEFBQSxpQkFBaUIsT0FBQTtBQUMxQix1REFBOEQ7QUFBckQsNEhBQUEsd0JBQXdCLE9BQUE7QUFDakMsMkNBQW1EO0FBQTFDLGlIQUFBLG1CQUFtQixPQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9wcm94eS1hZ2VudCc7XG5leHBvcnQgKiBmcm9tICcuL3Nkayc7XG5leHBvcnQgKiBmcm9tICcuL3Nkay1wcm92aWRlcic7XG5leHBvcnQgKiBmcm9tICcuL3Nkay1sb2dnZXInO1xuXG4vLyB0ZW1wb3JhcnkgdGVzdGluZyBleHBvcnRzXG5leHBvcnQgeyBBY2NvdW50QWNjZXNzS2V5Q2FjaGUgfSBmcm9tICcuL2FjY291bnQtY2FjaGUnO1xuZXhwb3J0IHsgY2FjaGVkIH0gZnJvbSAnLi9jYWNoZWQnO1xuZXhwb3J0IHsgQXdzQ2xpQ29tcGF0aWJsZSB9IGZyb20gJy4vYXdzY2xpLWNvbXBhdGlibGUnO1xuZXhwb3J0IHsgc2V0U2RrVHJhY2luZyB9IGZyb20gJy4vdHJhY2luZyc7XG5leHBvcnQgeyBDcmVkZW50aWFsUGx1Z2lucyB9IGZyb20gJy4vY3JlZGVudGlhbC1wbHVnaW5zJztcbmV4cG9ydCB7IGNyZWRlbnRpYWxzQWJvdXRUb0V4cGlyZSB9IGZyb20gJy4vcHJvdmlkZXItY2FjaGluZyc7XG5leHBvcnQgeyBkZWZhdWx0Q2xpVXNlckFnZW50IH0gZnJvbSAnLi91c2VyLWFnZW50JztcbiJdfQ== \ No newline at end of file diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/provider-caching.d.ts b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/provider-caching.d.ts new file mode 100644 index 000000000..4ebe73b28 --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/provider-caching.d.ts @@ -0,0 +1,13 @@ +import type { AwsCredentialIdentity, AwsCredentialIdentityProvider } from '@smithy/types'; +/** + * Wrap a credential provider in a cache + * + * Some credential providers in the SDKv3 are cached (the default Node + * chain, specifically) but most others are not. + * + * Since we want to avoid duplicate calls to `AssumeRole`, or duplicate + * MFA prompts or what have you, we are going to liberally wrap providers + * in caches which will return the cached value until it expires. + */ +export declare function makeCachingProvider(provider: AwsCredentialIdentityProvider): AwsCredentialIdentityProvider; +export declare function credentialsAboutToExpire(token: AwsCredentialIdentity): boolean; diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/provider-caching.js b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/provider-caching.js new file mode 100644 index 000000000..5e3deb195 --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/provider-caching.js @@ -0,0 +1,24 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.makeCachingProvider = makeCachingProvider; +exports.credentialsAboutToExpire = credentialsAboutToExpire; +const property_provider_1 = require("@smithy/property-provider"); +/** + * Wrap a credential provider in a cache + * + * Some credential providers in the SDKv3 are cached (the default Node + * chain, specifically) but most others are not. + * + * Since we want to avoid duplicate calls to `AssumeRole`, or duplicate + * MFA prompts or what have you, we are going to liberally wrap providers + * in caches which will return the cached value until it expires. + */ +function makeCachingProvider(provider) { + return (0, property_provider_1.memoize)(provider, credentialsAboutToExpire, (token) => !!token.expiration); +} +function credentialsAboutToExpire(token) { + const expiryMarginSecs = 5; + // token.expiration is sometimes null + return !!token.expiration && token.expiration.getTime() - Date.now() < expiryMarginSecs * 1000; +} +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/proxy-agent.d.ts b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/proxy-agent.d.ts new file mode 100644 index 000000000..135969d05 --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/proxy-agent.d.ts @@ -0,0 +1,13 @@ +import { ProxyAgent } from 'proxy-agent'; +import type { SdkHttpOptions } from './sdk-provider'; +import { type IoHelper } from '../io/private'; +export declare class ProxyAgentProvider { + private readonly ioHelper; + constructor(ioHelper: IoHelper); + create(options: SdkHttpOptions): Promise; + private tryGetCACert; + /** + * Find and return a CA certificate bundle path to be passed into the SDK. + */ + private caBundlePathFromEnvironment; +} diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/proxy-agent.js b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/proxy-agent.js new file mode 100644 index 000000000..01beda351 --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/proxy-agent.js @@ -0,0 +1,54 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.ProxyAgentProvider = void 0; +const fs = require("fs-extra"); +const proxy_agent_1 = require("proxy-agent"); +const private_1 = require("../io/private"); +class ProxyAgentProvider { + ioHelper; + constructor(ioHelper) { + this.ioHelper = ioHelper; + } + async create(options) { + // Force it to use the proxy provided through the command line. + // Otherwise, let the ProxyAgent auto-detect the proxy using environment variables. + const getProxyForUrl = options.proxyAddress != null + ? () => Promise.resolve(options.proxyAddress) + : undefined; + return new proxy_agent_1.ProxyAgent({ + ca: await this.tryGetCACert(options.caBundlePath), + getProxyForUrl, + }); + } + async tryGetCACert(bundlePath) { + const path = bundlePath || this.caBundlePathFromEnvironment(); + if (path) { + await this.ioHelper.notify(private_1.IO.DEFAULT_SDK_DEBUG.msg(`Using CA bundle path: ${path}`)); + try { + if (!fs.pathExistsSync(path)) { + return undefined; + } + return fs.readFileSync(path, { encoding: 'utf-8' }); + } + catch (e) { + await this.ioHelper.notify(private_1.IO.DEFAULT_SDK_DEBUG.msg(String(e))); + return undefined; + } + } + return undefined; + } + /** + * Find and return a CA certificate bundle path to be passed into the SDK. + */ + caBundlePathFromEnvironment() { + if (process.env.aws_ca_bundle) { + return process.env.aws_ca_bundle; + } + if (process.env.AWS_CA_BUNDLE) { + return process.env.AWS_CA_BUNDLE; + } + return undefined; + } +} +exports.ProxyAgentProvider = ProxyAgentProvider; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/sdk-logger.d.ts b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/sdk-logger.d.ts new file mode 100644 index 000000000..6191f83c8 --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/sdk-logger.d.ts @@ -0,0 +1,69 @@ +import type { Logger } from '@smithy/types'; +import type { IoHelper } from '../io/private'; +export declare class SdkToCliLogger implements Logger { + private readonly ioHelper; + constructor(ioHelper: IoHelper); + private notify; + trace(..._content: any[]): void; + debug(..._content: any[]): void; + /** + * Info is called mostly (exclusively?) for successful API calls + * + * Payload: + * + * (Note the input contains entire CFN templates, for example) + * + * ``` + * { + * clientName: 'S3Client', + * commandName: 'GetBucketLocationCommand', + * input: { + * Bucket: '.....', + * ExpectedBucketOwner: undefined + * }, + * output: { LocationConstraint: 'eu-central-1' }, + * metadata: { + * httpStatusCode: 200, + * requestId: '....', + * extendedRequestId: '...', + * cfId: undefined, + * attempts: 1, + * totalRetryDelay: 0 + * } + * } + * ``` + */ + info(...content: any[]): void; + warn(...content: any[]): void; + /** + * Error is called mostly (exclusively?) for failing API calls + * + * Payload (input would be the entire API call arguments). + * + * ``` + * { + * clientName: 'STSClient', + * commandName: 'GetCallerIdentityCommand', + * input: {}, + * error: AggregateError [ECONNREFUSED]: + * at internalConnectMultiple (node:net:1121:18) + * at afterConnectMultiple (node:net:1688:7) { + * code: 'ECONNREFUSED', + * '$metadata': { attempts: 3, totalRetryDelay: 600 }, + * [errors]: [ [Error], [Error] ] + * }, + * metadata: { attempts: 3, totalRetryDelay: 600 } + * } + * ``` + */ + error(...content: any[]): void; +} +/** + * This can be anything. + * + * For debug, it seems to be mostly strings. + * For info, it seems to be objects. + * + * Stringify and join without separator. + */ +export declare function formatSdkLoggerContent(content: any[]): string; diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/sdk-logger.js b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/sdk-logger.js new file mode 100644 index 000000000..463117416 --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/sdk-logger.js @@ -0,0 +1,128 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.SdkToCliLogger = void 0; +exports.formatSdkLoggerContent = formatSdkLoggerContent; +const util_1 = require("util"); +const util_2 = require("../../util"); +const private_1 = require("../io/private"); +class SdkToCliLogger { + ioHelper; + constructor(ioHelper) { + this.ioHelper = ioHelper; + } + notify(level, ...content) { + void this.ioHelper.notify(private_1.IO.CDK_SDK_I0100.msg((0, util_1.format)('[SDK %s] %s', level, formatSdkLoggerContent(content)), { + sdkLevel: level, + content, + })); + } + trace(..._content) { + // This is too much detail for our logs + // this.notify('trace', ...content); + } + debug(..._content) { + // This is too much detail for our logs + // this.notify('debug', ...content); + } + /** + * Info is called mostly (exclusively?) for successful API calls + * + * Payload: + * + * (Note the input contains entire CFN templates, for example) + * + * ``` + * { + * clientName: 'S3Client', + * commandName: 'GetBucketLocationCommand', + * input: { + * Bucket: '.....', + * ExpectedBucketOwner: undefined + * }, + * output: { LocationConstraint: 'eu-central-1' }, + * metadata: { + * httpStatusCode: 200, + * requestId: '....', + * extendedRequestId: '...', + * cfId: undefined, + * attempts: 1, + * totalRetryDelay: 0 + * } + * } + * ``` + */ + info(...content) { + this.notify('info', ...content); + } + warn(...content) { + this.notify('warn', ...content); + } + /** + * Error is called mostly (exclusively?) for failing API calls + * + * Payload (input would be the entire API call arguments). + * + * ``` + * { + * clientName: 'STSClient', + * commandName: 'GetCallerIdentityCommand', + * input: {}, + * error: AggregateError [ECONNREFUSED]: + * at internalConnectMultiple (node:net:1121:18) + * at afterConnectMultiple (node:net:1688:7) { + * code: 'ECONNREFUSED', + * '$metadata': { attempts: 3, totalRetryDelay: 600 }, + * [errors]: [ [Error], [Error] ] + * }, + * metadata: { attempts: 3, totalRetryDelay: 600 } + * } + * ``` + */ + error(...content) { + this.notify('error', ...content); + } +} +exports.SdkToCliLogger = SdkToCliLogger; +/** + * This can be anything. + * + * For debug, it seems to be mostly strings. + * For info, it seems to be objects. + * + * Stringify and join without separator. + */ +function formatSdkLoggerContent(content) { + if (content.length === 1) { + const apiFmt = formatApiCall(content[0]); + if (apiFmt) { + return apiFmt; + } + } + return content.map((x) => typeof x === 'string' ? x : (0, util_1.inspect)(x)).join(''); +} +function formatApiCall(content) { + if (!isSdkApiCallSuccess(content) && !isSdkApiCallError(content)) { + return undefined; + } + const service = content.clientName.replace(/Client$/, ''); + const api = content.commandName.replace(/Command$/, ''); + const parts = []; + if ((content.metadata?.attempts ?? 0) > 1) { + parts.push(`[${content.metadata?.attempts} attempts, ${content.metadata?.totalRetryDelay}ms retry]`); + } + parts.push(`${service}.${api}(${JSON.stringify(content.input, util_2.replacerBufferWithInfo)})`); + if (isSdkApiCallSuccess(content)) { + parts.push('-> OK'); + } + else { + parts.push(`-> ${content.error}`); + } + return parts.join(' '); +} +function isSdkApiCallSuccess(x) { + return x && typeof x === 'object' && x.commandName && x.output; +} +function isSdkApiCallError(x) { + return x && typeof x === 'object' && x.commandName && x.error; +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sdk-logger.js","sourceRoot":"","sources":["../../../src/api/aws-auth/sdk-logger.ts"],"names":[],"mappings":"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","sourcesContent":["import { inspect, format } from 'util';\nimport type { Logger } from '@smithy/types';\nimport { replacerBufferWithInfo } from '../../util';\nimport type { IoHelper } from '../io/private';\nimport { IO } from '../io/private';\n\nexport class SdkToCliLogger implements Logger {\n  private readonly ioHelper: IoHelper;\n\n  public constructor(ioHelper: IoHelper) {\n    this.ioHelper = ioHelper;\n  }\n\n  private notify(level: 'info' | 'warn' | 'error', ...content: any[]) {\n    void this.ioHelper.notify(IO.CDK_SDK_I0100.msg(format('[SDK %s] %s', level, formatSdkLoggerContent(content)), {\n      sdkLevel: level,\n      content,\n    }));\n  }\n\n  public trace(..._content: any[]) {\n    // This is too much detail for our logs\n    // this.notify('trace', ...content);\n  }\n\n  public debug(..._content: any[]) {\n    // This is too much detail for our logs\n    // this.notify('debug', ...content);\n  }\n\n  /**\n   * Info is called mostly (exclusively?) for successful API calls\n   *\n   * Payload:\n   *\n   * (Note the input contains entire CFN templates, for example)\n   *\n   * ```\n   * {\n   *   clientName: 'S3Client',\n   *   commandName: 'GetBucketLocationCommand',\n   *   input: {\n   *     Bucket: '.....',\n   *     ExpectedBucketOwner: undefined\n   *   },\n   *   output: { LocationConstraint: 'eu-central-1' },\n   *   metadata: {\n   *     httpStatusCode: 200,\n   *     requestId: '....',\n   *     extendedRequestId: '...',\n   *     cfId: undefined,\n   *     attempts: 1,\n   *     totalRetryDelay: 0\n   *   }\n   * }\n   * ```\n   */\n  public info(...content: any[]) {\n    this.notify('info', ...content);\n  }\n\n  public warn(...content: any[]) {\n    this.notify('warn', ...content);\n  }\n\n  /**\n   * Error is called mostly (exclusively?) for failing API calls\n   *\n   * Payload (input would be the entire API call arguments).\n   *\n   * ```\n   * {\n   *   clientName: 'STSClient',\n   *   commandName: 'GetCallerIdentityCommand',\n   *   input: {},\n   *   error: AggregateError [ECONNREFUSED]:\n   *       at internalConnectMultiple (node:net:1121:18)\n   *       at afterConnectMultiple (node:net:1688:7) {\n   *     code: 'ECONNREFUSED',\n   *     '$metadata': { attempts: 3, totalRetryDelay: 600 },\n   *     [errors]: [ [Error], [Error] ]\n   *   },\n   *   metadata: { attempts: 3, totalRetryDelay: 600 }\n   * }\n   * ```\n   */\n  public error(...content: any[]) {\n    this.notify('error', ...content);\n  }\n}\n\n/**\n * This can be anything.\n *\n * For debug, it seems to be mostly strings.\n * For info, it seems to be objects.\n *\n * Stringify and join without separator.\n */\nexport function formatSdkLoggerContent(content: any[]) {\n  if (content.length === 1) {\n    const apiFmt = formatApiCall(content[0]);\n    if (apiFmt) {\n      return apiFmt;\n    }\n  }\n  return content.map((x) => typeof x === 'string' ? x : inspect(x)).join('');\n}\n\nfunction formatApiCall(content: any): string | undefined {\n  if (!isSdkApiCallSuccess(content) && !isSdkApiCallError(content)) {\n    return undefined;\n  }\n\n  const service = content.clientName.replace(/Client$/, '');\n  const api = content.commandName.replace(/Command$/, '');\n\n  const parts = [];\n  if ((content.metadata?.attempts ?? 0) > 1) {\n    parts.push(`[${content.metadata?.attempts} attempts, ${content.metadata?.totalRetryDelay}ms retry]`);\n  }\n\n  parts.push(`${service}.${api}(${JSON.stringify(content.input, replacerBufferWithInfo)})`);\n\n  if (isSdkApiCallSuccess(content)) {\n    parts.push('-> OK');\n  } else {\n    parts.push(`-> ${content.error}`);\n  }\n\n  return parts.join(' ');\n}\n\ninterface SdkApiCallBase {\n  clientName: string;\n  commandName: string;\n  input: Record<string, unknown>;\n  metadata?: {\n    httpStatusCode?: number;\n    requestId?: string;\n    extendedRequestId?: string;\n    cfId?: string;\n    attempts?: number;\n    totalRetryDelay?: number;\n  };\n}\n\ntype SdkApiCallSuccess = SdkApiCallBase & { output: Record<string, unknown> };\ntype SdkApiCallError = SdkApiCallBase & { error: Error };\n\nfunction isSdkApiCallSuccess(x: any): x is SdkApiCallSuccess {\n  return x && typeof x === 'object' && x.commandName && x.output;\n}\n\nfunction isSdkApiCallError(x: any): x is SdkApiCallError {\n  return x && typeof x === 'object' && x.commandName && x.error;\n}\n"]} \ No newline at end of file diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/sdk-provider.d.ts b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/sdk-provider.d.ts new file mode 100644 index 000000000..85030a43d --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/sdk-provider.d.ts @@ -0,0 +1,229 @@ +import type { ContextLookupRoleOptions } from '@aws-cdk/cloud-assembly-schema'; +import type { Environment } from '@aws-cdk/cx-api'; +import type { AssumeRoleCommandInput } from '@aws-sdk/client-sts'; +import type { NodeHttpHandlerOptions } from '@smithy/node-http-handler'; +import type { AwsCredentialIdentityProvider, Logger } from '@smithy/types'; +import { SDK } from './sdk'; +import { type IoHelper } from '../io/private'; +import { PluginHost, Mode } from '../plugin'; +export type AssumeRoleAdditionalOptions = Partial>; +/** + * Options for the default SDK provider + */ +export interface SdkProviderOptions extends SdkProviderServices { + /** + * Profile to read from ~/.aws + * + * @default - No profile + */ + readonly profile?: string; +} +/** + * Options for individual SDKs + */ +export interface SdkHttpOptions { + /** + * Proxy address to use + * + * @default No proxy + */ + readonly proxyAddress?: string; + /** + * A path to a certificate bundle that contains a cert to be trusted. + * + * @default No certificate bundle + */ + readonly caBundlePath?: string; +} +/** + * SDK configuration for a given environment + * 'forEnvironment' will attempt to assume a role and if it + * is not successful, then it will either: + * 1. Check to see if the default credentials (local credentials the CLI was executed with) + * are for the given environment. If they are then return those. + * 2. If the default credentials are not for the given environment then + * throw an error + * + * 'didAssumeRole' allows callers to whether they are receiving the assume role + * credentials or the default credentials. + */ +export interface SdkForEnvironment { + /** + * The SDK for the given environment + */ + readonly sdk: SDK; + /** + * Whether or not the assume role was successful. + * If the assume role was not successful (false) + * then that means that the 'sdk' returned contains + * the default credentials (not the assume role credentials) + */ + readonly didAssumeRole: boolean; +} +/** + * Creates instances of the AWS SDK appropriate for a given account/region. + * + * Behavior is as follows: + * + * - First, a set of "base" credentials are established + * - If a target environment is given and the default ("current") SDK credentials are for + * that account, return those; otherwise + * - If a target environment is given, scan all credential provider plugins + * for credentials, and return those if found; otherwise + * - Return default ("current") SDK credentials, noting that they might be wrong. + * + * - Second, a role may optionally need to be assumed. Use the base credentials + * established in the previous process to assume that role. + * - If assuming the role fails and the base credentials are for the correct + * account, return those. This is a fallback for people who are trying to interact + * with a Default Synthesized stack and already have right credentials setup. + * + * Typical cases we see in the wild: + * - Credential plugin setup that, although not recommended, works for them + * - Seeded terminal with `ReadOnly` credentials in order to do `cdk diff`--the `ReadOnly` + * role doesn't have `sts:AssumeRole` and will fail for no real good reason. + */ +export declare class SdkProvider { + /** + * Create a new SdkProvider which gets its defaults in a way that behaves like the AWS CLI does + * + * The AWS SDK for JS behaves slightly differently from the AWS CLI in a number of ways; see the + * class `AwsCliCompatible` for the details. + */ + static withAwsCliCompatibleDefaults(options: SdkProviderOptions): Promise; + readonly defaultRegion: string; + private readonly defaultCredentialProvider; + private readonly plugins; + private readonly requestHandler; + private readonly ioHelper; + private readonly logger?; + constructor(defaultCredentialProvider: AwsCredentialIdentityProvider, defaultRegion: string | undefined, services: SdkProviderServices); + /** + * Return an SDK which can do operations in the given environment + * + * The `environment` parameter is resolved first (see `resolveEnvironment()`). + */ + forEnvironment(environment: Environment, mode: Mode, options?: CredentialsOptions, quiet?: boolean): Promise; + /** + * Return the partition that base credentials are for + * + * Returns `undefined` if there are no base credentials. + */ + baseCredentialsPartition(environment: Environment, mode: Mode): Promise; + /** + * Resolve the environment for a stack + * + * Replaces the magic values `UNKNOWN_REGION` and `UNKNOWN_ACCOUNT` + * with the defaults for the current SDK configuration (`~/.aws/config` or + * otherwise). + * + * It is an error if `UNKNOWN_ACCOUNT` is used but the user hasn't configured + * any SDK credentials. + */ + resolveEnvironment(env: Environment): Promise; + /** + * The account we'd auth into if we used default credentials. + * + * Default credentials are the set of ambiently configured credentials using + * one of the environment variables, or ~/.aws/credentials, or the *one* + * profile that was passed into the CLI. + * + * Might return undefined if there are no default/ambient credentials + * available (in which case the user should better hope they have + * credential plugins configured). + * + * Uses a cache to avoid STS calls if we don't need 'em. + */ + defaultAccount(): Promise; + /** + * Get credentials for the given account ID in the given mode + * + * 1. Use the default credentials if the destination account matches the + * current credentials' account. + * 2. Otherwise try all credential plugins. + * 3. Fail if neither of these yield any credentials. + * 4. Return a failure if any of them returned credentials + */ + private obtainBaseCredentials; + /** + * Return an SDK which uses assumed role credentials + * + * The base credentials used to retrieve the assumed role credentials will be the + * same credentials returned by obtainCredentials if an environment and mode is passed, + * otherwise it will be the current credentials. + */ + private withAssumedRole; + /** + * Factory function that creates a new SDK instance + * + * This is a function here, instead of all the places where this is used creating a `new SDK` + * instance, so that it is trivial to mock from tests. + * + * Use like this: + * + * ```ts + * const mockSdk = jest.spyOn(SdkProvider.prototype, '_makeSdk').mockReturnValue(new MockSdk()); + * // ... + * mockSdk.mockRestore(); + * ``` + * + * @internal + */ + _makeSdk(credProvider: AwsCredentialIdentityProvider, region: string): SDK; +} +/** + * An AWS account + * + * An AWS account always exists in only one partition. Usually we don't care about + * the partition, but when we need to form ARNs we do. + */ +export interface Account { + /** + * The account number + */ + readonly accountId: string; + /** + * The partition ('aws' or 'aws-cn' or otherwise) + */ + readonly partition: string; +} +/** + * Options for obtaining credentials for an environment + */ +export interface CredentialsOptions { + /** + * The ARN of the role that needs to be assumed, if any + */ + readonly assumeRoleArn?: string; + /** + * External ID required to assume the given role. + */ + readonly assumeRoleExternalId?: string; + /** + * Session tags required to assume the given role. + */ + readonly assumeRoleAdditionalOptions?: AssumeRoleAdditionalOptions; +} +/** + * Instantiate an SDK for context providers. This function ensures that all + * lookup assume role options are used when context providers perform lookups. + */ +export declare function initContextProviderSdk(aws: SdkProvider, options: ContextLookupRoleOptions): Promise; +export interface SdkProviderServices { + /** + * An IO helper for emitting messages + */ + readonly ioHelper: IoHelper; + /** + * The request handler settings + */ + readonly requestHandler?: NodeHttpHandlerOptions; + /** + * A plugin host + */ + readonly pluginHost?: PluginHost; + /** + * An SDK logger + */ + readonly logger?: Logger; +} diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/sdk-provider.js b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/sdk-provider.js new file mode 100644 index 000000000..643ff189e --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/sdk-provider.js @@ -0,0 +1,373 @@ +"use strict"; +var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; +}; +var SdkProvider_1; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.SdkProvider = void 0; +exports.initContextProviderSdk = initContextProviderSdk; +const os = require("os"); +const cx_api_1 = require("@aws-cdk/cx-api"); +const credential_providers_1 = require("@aws-sdk/credential-providers"); +const awscli_compatible_1 = require("./awscli-compatible"); +const cached_1 = require("./cached"); +const credential_plugins_1 = require("./credential-plugins"); +const provider_caching_1 = require("./provider-caching"); +const sdk_1 = require("./sdk"); +const tracing_1 = require("./tracing"); +const util_1 = require("../../util"); +const private_1 = require("../io/private"); +const plugin_1 = require("../plugin"); +const toolkit_error_1 = require("../toolkit-error"); +const CACHED_ACCOUNT = Symbol('cached_account'); +/** + * Creates instances of the AWS SDK appropriate for a given account/region. + * + * Behavior is as follows: + * + * - First, a set of "base" credentials are established + * - If a target environment is given and the default ("current") SDK credentials are for + * that account, return those; otherwise + * - If a target environment is given, scan all credential provider plugins + * for credentials, and return those if found; otherwise + * - Return default ("current") SDK credentials, noting that they might be wrong. + * + * - Second, a role may optionally need to be assumed. Use the base credentials + * established in the previous process to assume that role. + * - If assuming the role fails and the base credentials are for the correct + * account, return those. This is a fallback for people who are trying to interact + * with a Default Synthesized stack and already have right credentials setup. + * + * Typical cases we see in the wild: + * - Credential plugin setup that, although not recommended, works for them + * - Seeded terminal with `ReadOnly` credentials in order to do `cdk diff`--the `ReadOnly` + * role doesn't have `sts:AssumeRole` and will fail for no real good reason. + */ +let SdkProvider = SdkProvider_1 = class SdkProvider { + /** + * Create a new SdkProvider which gets its defaults in a way that behaves like the AWS CLI does + * + * The AWS SDK for JS behaves slightly differently from the AWS CLI in a number of ways; see the + * class `AwsCliCompatible` for the details. + */ + static async withAwsCliCompatibleDefaults(options) { + (0, tracing_1.callTrace)(SdkProvider_1.withAwsCliCompatibleDefaults.name, SdkProvider_1.constructor.name, options.logger); + const config = await new awscli_compatible_1.AwsCliCompatible(options.ioHelper, options.requestHandler ?? {}, options.logger).baseConfig(options.profile); + return new SdkProvider_1(config.credentialProvider, config.defaultRegion, options); + } + defaultRegion; + defaultCredentialProvider; + plugins; + requestHandler; + ioHelper; + logger; + constructor(defaultCredentialProvider, defaultRegion, services) { + this.defaultCredentialProvider = defaultCredentialProvider; + this.defaultRegion = defaultRegion ?? 'us-east-1'; + this.requestHandler = services.requestHandler ?? {}; + this.ioHelper = services.ioHelper; + this.logger = services.logger; + this.plugins = new credential_plugins_1.CredentialPlugins(services.pluginHost ?? new plugin_1.PluginHost(), this.ioHelper); + } + /** + * Return an SDK which can do operations in the given environment + * + * The `environment` parameter is resolved first (see `resolveEnvironment()`). + */ + async forEnvironment(environment, mode, options, quiet = false) { + const env = await this.resolveEnvironment(environment); + const baseCreds = await this.obtainBaseCredentials(env.account, mode); + // At this point, we need at least SOME credentials + if (baseCreds.source === 'none') { + throw new toolkit_error_1.AuthenticationError(fmtObtainCredentialsError(env.account, baseCreds)); + } + // Simple case is if we don't need to "assumeRole" here. If so, we must now have credentials for the right + // account. + if (options?.assumeRoleArn === undefined) { + if (baseCreds.source === 'incorrectDefault') { + throw new toolkit_error_1.AuthenticationError(fmtObtainCredentialsError(env.account, baseCreds)); + } + // Our current credentials must be valid and not expired. Confirm that before we get into doing + // actual CloudFormation calls, which might take a long time to hang. + const sdk = this._makeSdk(baseCreds.credentials, env.region); + await sdk.validateCredentials(); + return { sdk, didAssumeRole: false }; + } + try { + // We will proceed to AssumeRole using whatever we've been given. + const sdk = await this.withAssumedRole(baseCreds, options.assumeRoleArn, options.assumeRoleExternalId, options.assumeRoleAdditionalOptions, env.region); + return { sdk, didAssumeRole: true }; + } + catch (err) { + if (err.name === 'ExpiredToken') { + throw err; + } + // AssumeRole failed. Proceed and warn *if and only if* the baseCredentials were already for the right account + // or returned from a plugin. This is to cover some current setups for people using plugins or preferring to + // feed the CLI credentials which are sufficient by themselves. Prefer to assume the correct role if we can, + // but if we can't then let's just try with available credentials anyway. + if (baseCreds.source === 'correctDefault' || baseCreds.source === 'plugin') { + await this.ioHelper.notify(private_1.IO.DEFAULT_SDK_DEBUG.msg(err.message)); + const maker = quiet ? private_1.IO.DEFAULT_SDK_DEBUG : private_1.IO.DEFAULT_SDK_WARN; + await this.ioHelper.notify(maker.msg(`${fmtObtainedCredentials(baseCreds)} could not be used to assume '${options.assumeRoleArn}', but are for the right account. Proceeding anyway.`)); + return { + sdk: this._makeSdk(baseCreds.credentials, env.region), + didAssumeRole: false, + }; + } + throw err; + } + } + /** + * Return the partition that base credentials are for + * + * Returns `undefined` if there are no base credentials. + */ + async baseCredentialsPartition(environment, mode) { + const env = await this.resolveEnvironment(environment); + const baseCreds = await this.obtainBaseCredentials(env.account, mode); + if (baseCreds.source === 'none') { + return undefined; + } + return (await this._makeSdk(baseCreds.credentials, env.region).currentAccount()).partition; + } + /** + * Resolve the environment for a stack + * + * Replaces the magic values `UNKNOWN_REGION` and `UNKNOWN_ACCOUNT` + * with the defaults for the current SDK configuration (`~/.aws/config` or + * otherwise). + * + * It is an error if `UNKNOWN_ACCOUNT` is used but the user hasn't configured + * any SDK credentials. + */ + async resolveEnvironment(env) { + const region = env.region !== cx_api_1.UNKNOWN_REGION ? env.region : this.defaultRegion; + const account = env.account !== cx_api_1.UNKNOWN_ACCOUNT ? env.account : (await this.defaultAccount())?.accountId; + if (!account) { + throw new toolkit_error_1.AuthenticationError('Unable to resolve AWS account to use. It must be either configured when you define your CDK Stack, or through the environment'); + } + return { + region, + account, + name: cx_api_1.EnvironmentUtils.format(account, region), + }; + } + /** + * The account we'd auth into if we used default credentials. + * + * Default credentials are the set of ambiently configured credentials using + * one of the environment variables, or ~/.aws/credentials, or the *one* + * profile that was passed into the CLI. + * + * Might return undefined if there are no default/ambient credentials + * available (in which case the user should better hope they have + * credential plugins configured). + * + * Uses a cache to avoid STS calls if we don't need 'em. + */ + async defaultAccount() { + return (0, cached_1.cached)(this, CACHED_ACCOUNT, async () => { + try { + return await this._makeSdk(this.defaultCredentialProvider, this.defaultRegion).currentAccount(); + } + catch (e) { + // Treat 'ExpiredToken' specially. This is a common situation that people may find themselves in, and + // they are complaining about if we fail 'cdk synth' on them. We loudly complain in order to show that + // the current situation is probably undesirable, but we don't fail. + if (e.name === 'ExpiredToken') { + await this.ioHelper.notify(private_1.IO.DEFAULT_SDK_WARN.msg('There are expired AWS credentials in your environment. The CDK app will synth without current account information.')); + return undefined; + } + await this.ioHelper.notify(private_1.IO.DEFAULT_SDK_DEBUG.msg(`Unable to determine the default AWS account (${e.name}): ${(0, util_1.formatErrorMessage)(e)}`)); + return undefined; + } + }); + } + /** + * Get credentials for the given account ID in the given mode + * + * 1. Use the default credentials if the destination account matches the + * current credentials' account. + * 2. Otherwise try all credential plugins. + * 3. Fail if neither of these yield any credentials. + * 4. Return a failure if any of them returned credentials + */ + async obtainBaseCredentials(accountId, mode) { + // First try 'current' credentials + const defaultAccountId = (await this.defaultAccount())?.accountId; + if (defaultAccountId === accountId) { + return { + source: 'correctDefault', + credentials: await this.defaultCredentialProvider, + }; + } + // Then try the plugins + const pluginCreds = await this.plugins.fetchCredentialsFor(accountId, mode); + if (pluginCreds) { + return { source: 'plugin', ...pluginCreds }; + } + // Fall back to default credentials with a note that they're not the right ones yet + if (defaultAccountId !== undefined) { + return { + source: 'incorrectDefault', + accountId: defaultAccountId, + credentials: await this.defaultCredentialProvider, + unusedPlugins: this.plugins.availablePluginNames, + }; + } + // Apparently we didn't find any at all + return { + source: 'none', + unusedPlugins: this.plugins.availablePluginNames, + }; + } + /** + * Return an SDK which uses assumed role credentials + * + * The base credentials used to retrieve the assumed role credentials will be the + * same credentials returned by obtainCredentials if an environment and mode is passed, + * otherwise it will be the current credentials. + */ + async withAssumedRole(mainCredentials, roleArn, externalId, additionalOptions, region) { + await this.ioHelper.notify(private_1.IO.DEFAULT_SDK_DEBUG.msg(`Assuming role '${roleArn}'.`)); + region = region ?? this.defaultRegion; + const sourceDescription = fmtObtainedCredentials(mainCredentials); + try { + const credentials = await (0, provider_caching_1.makeCachingProvider)((0, credential_providers_1.fromTemporaryCredentials)({ + masterCredentials: mainCredentials.credentials, + params: { + RoleArn: roleArn, + ExternalId: externalId, + RoleSessionName: `aws-cdk-${safeUsername()}`, + ...additionalOptions, + TransitiveTagKeys: additionalOptions?.Tags ? additionalOptions.Tags.map((t) => t.Key) : undefined, + }, + clientConfig: { + region, + requestHandler: this.requestHandler, + customUserAgent: 'aws-cdk', + logger: this.logger, + }, + logger: this.logger, + })); + // Call the provider at least once here, to catch an error if it occurs + await credentials(); + return this._makeSdk(credentials, region); + } + catch (err) { + if (err.name === 'ExpiredToken') { + throw err; + } + await this.ioHelper.notify(private_1.IO.DEFAULT_SDK_DEBUG.msg(`Assuming role failed: ${err.message}`)); + throw new toolkit_error_1.AuthenticationError([ + 'Could not assume role in target account', + ...(sourceDescription ? [`using ${sourceDescription}`] : []), + err.message, + ". Please make sure that this role exists in the account. If it doesn't exist, (re)-bootstrap the environment " + + "with the right '--trust', using the latest version of the CDK CLI.", + ].join(' ')); + } + } + /** + * Factory function that creates a new SDK instance + * + * This is a function here, instead of all the places where this is used creating a `new SDK` + * instance, so that it is trivial to mock from tests. + * + * Use like this: + * + * ```ts + * const mockSdk = jest.spyOn(SdkProvider.prototype, '_makeSdk').mockReturnValue(new MockSdk()); + * // ... + * mockSdk.mockRestore(); + * ``` + * + * @internal + */ + _makeSdk(credProvider, region) { + return new sdk_1.SDK(credProvider, region, this.requestHandler, this.ioHelper, this.logger); + } +}; +exports.SdkProvider = SdkProvider; +exports.SdkProvider = SdkProvider = SdkProvider_1 = __decorate([ + tracing_1.traceMemberMethods +], SdkProvider); +/** + * Return the username with characters invalid for a RoleSessionName removed + * + * @see https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html#API_AssumeRole_RequestParameters + */ +function safeUsername() { + try { + return os.userInfo().username.replace(/[^\w+=,.@-]/g, '@'); + } + catch { + return 'noname'; + } +} +/** + * Isolating the code that translates calculation errors into human error messages + * + * We cover the following cases: + * + * - No credentials are available at all + * - Default credentials are for the wrong account + */ +function fmtObtainCredentialsError(targetAccountId, obtainResult) { + const msg = [`Need to perform AWS calls for account ${targetAccountId}`]; + switch (obtainResult.source) { + case 'incorrectDefault': + msg.push(`but the current credentials are for ${obtainResult.accountId}`); + break; + case 'none': + msg.push('but no credentials have been configured'); + } + if (obtainResult.unusedPlugins.length > 0) { + msg.push(`and none of these plugins found any: ${obtainResult.unusedPlugins.join(', ')}`); + } + return msg.join(', '); +} +/** + * Format a message indicating where we got base credentials for the assume role + * + * We cover the following cases: + * + * - Default credentials for the right account + * - Default credentials for the wrong account + * - Credentials returned from a plugin + */ +function fmtObtainedCredentials(obtainResult) { + switch (obtainResult.source) { + case 'correctDefault': + return 'current credentials'; + case 'plugin': + return `credentials returned by plugin '${obtainResult.pluginName}'`; + case 'incorrectDefault': + const msg = []; + msg.push(`current credentials (which are for account ${obtainResult.accountId}`); + if (obtainResult.unusedPlugins.length > 0) { + msg.push(`, and none of the following plugins provided credentials: ${obtainResult.unusedPlugins.join(', ')}`); + } + msg.push(')'); + return msg.join(''); + } +} +/** + * Instantiate an SDK for context providers. This function ensures that all + * lookup assume role options are used when context providers perform lookups. + */ +async function initContextProviderSdk(aws, options) { + const account = options.account; + const region = options.region; + const creds = { + assumeRoleArn: options.lookupRoleArn, + assumeRoleExternalId: options.lookupRoleExternalId, + assumeRoleAdditionalOptions: options.assumeRoleAdditionalOptions, + }; + return (await aws.forEnvironment(cx_api_1.EnvironmentUtils.make(account, region), plugin_1.Mode.ForReading, creds)).sdk; +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sdk-provider.js","sourceRoot":"","sources":["../../../src/api/aws-auth/sdk-provider.ts"],"names":[],"mappings":"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","sourcesContent":["import * as os from 'os';\nimport type { ContextLookupRoleOptions } from '@aws-cdk/cloud-assembly-schema';\nimport type { Environment } from '@aws-cdk/cx-api';\nimport { EnvironmentUtils, UNKNOWN_ACCOUNT, UNKNOWN_REGION } from '@aws-cdk/cx-api';\nimport type { AssumeRoleCommandInput } from '@aws-sdk/client-sts';\nimport { fromTemporaryCredentials } from '@aws-sdk/credential-providers';\nimport type { NodeHttpHandlerOptions } from '@smithy/node-http-handler';\nimport type { AwsCredentialIdentityProvider, Logger } from '@smithy/types';\nimport { AwsCliCompatible } from './awscli-compatible';\nimport { cached } from './cached';\nimport { CredentialPlugins } from './credential-plugins';\nimport { makeCachingProvider } from './provider-caching';\nimport { SDK } from './sdk';\nimport { callTrace, traceMemberMethods } from './tracing';\nimport { formatErrorMessage } from '../../util';\nimport { IO, type IoHelper } from '../io/private';\nimport { PluginHost, Mode } from '../plugin';\nimport { AuthenticationError } from '../toolkit-error';\n\nexport type AssumeRoleAdditionalOptions = Partial<Omit<AssumeRoleCommandInput, 'ExternalId' | 'RoleArn'>>;\n\n/**\n * Options for the default SDK provider\n */\nexport interface SdkProviderOptions extends SdkProviderServices {\n  /**\n   * Profile to read from ~/.aws\n   *\n   * @default - No profile\n   */\n  readonly profile?: string;\n}\n\n/**\n * Options for individual SDKs\n */\nexport interface SdkHttpOptions {\n  /**\n   * Proxy address to use\n   *\n   * @default No proxy\n   */\n  readonly proxyAddress?: string;\n\n  /**\n   * A path to a certificate bundle that contains a cert to be trusted.\n   *\n   * @default No certificate bundle\n   */\n  readonly caBundlePath?: string;\n}\n\nconst CACHED_ACCOUNT = Symbol('cached_account');\n\n/**\n * SDK configuration for a given environment\n * 'forEnvironment' will attempt to assume a role and if it\n * is not successful, then it will either:\n *   1. Check to see if the default credentials (local credentials the CLI was executed with)\n *      are for the given environment. If they are then return those.\n *   2. If the default credentials are not for the given environment then\n *      throw an error\n *\n * 'didAssumeRole' allows callers to whether they are receiving the assume role\n * credentials or the default credentials.\n */\nexport interface SdkForEnvironment {\n  /**\n   * The SDK for the given environment\n   */\n  readonly sdk: SDK;\n\n  /**\n   * Whether or not the assume role was successful.\n   * If the assume role was not successful (false)\n   * then that means that the 'sdk' returned contains\n   * the default credentials (not the assume role credentials)\n   */\n  readonly didAssumeRole: boolean;\n}\n\n/**\n * Creates instances of the AWS SDK appropriate for a given account/region.\n *\n * Behavior is as follows:\n *\n * - First, a set of \"base\" credentials are established\n *   - If a target environment is given and the default (\"current\") SDK credentials are for\n *     that account, return those; otherwise\n *   - If a target environment is given, scan all credential provider plugins\n *     for credentials, and return those if found; otherwise\n *   - Return default (\"current\") SDK credentials, noting that they might be wrong.\n *\n * - Second, a role may optionally need to be assumed. Use the base credentials\n *   established in the previous process to assume that role.\n *   - If assuming the role fails and the base credentials are for the correct\n *     account, return those. This is a fallback for people who are trying to interact\n *     with a Default Synthesized stack and already have right credentials setup.\n *\n *     Typical cases we see in the wild:\n *     - Credential plugin setup that, although not recommended, works for them\n *     - Seeded terminal with `ReadOnly` credentials in order to do `cdk diff`--the `ReadOnly`\n *       role doesn't have `sts:AssumeRole` and will fail for no real good reason.\n */\n@traceMemberMethods\nexport class SdkProvider {\n  /**\n   * Create a new SdkProvider which gets its defaults in a way that behaves like the AWS CLI does\n   *\n   * The AWS SDK for JS behaves slightly differently from the AWS CLI in a number of ways; see the\n   * class `AwsCliCompatible` for the details.\n   */\n  public static async withAwsCliCompatibleDefaults(options: SdkProviderOptions) {\n    callTrace(SdkProvider.withAwsCliCompatibleDefaults.name, SdkProvider.constructor.name, options.logger);\n    const config = await new AwsCliCompatible(options.ioHelper, options.requestHandler ?? {}, options.logger).baseConfig(options.profile);\n    return new SdkProvider(config.credentialProvider, config.defaultRegion, options);\n  }\n\n  public readonly defaultRegion: string;\n  private readonly defaultCredentialProvider: AwsCredentialIdentityProvider;\n  private readonly plugins;\n  private readonly requestHandler: NodeHttpHandlerOptions;\n  private readonly ioHelper: IoHelper;\n  private readonly logger?: Logger;\n\n  public constructor(\n    defaultCredentialProvider: AwsCredentialIdentityProvider,\n    defaultRegion: string | undefined,\n    services: SdkProviderServices,\n  ) {\n    this.defaultCredentialProvider = defaultCredentialProvider;\n    this.defaultRegion = defaultRegion ?? 'us-east-1';\n    this.requestHandler = services.requestHandler ?? {};\n    this.ioHelper = services.ioHelper;\n    this.logger = services.logger;\n    this.plugins = new CredentialPlugins(services.pluginHost ?? new PluginHost(), this.ioHelper);\n  }\n\n  /**\n   * Return an SDK which can do operations in the given environment\n   *\n   * The `environment` parameter is resolved first (see `resolveEnvironment()`).\n   */\n  public async forEnvironment(\n    environment: Environment,\n    mode: Mode,\n    options?: CredentialsOptions,\n    quiet = false,\n  ): Promise<SdkForEnvironment> {\n    const env = await this.resolveEnvironment(environment);\n\n    const baseCreds = await this.obtainBaseCredentials(env.account, mode);\n\n    // At this point, we need at least SOME credentials\n    if (baseCreds.source === 'none') {\n      throw new AuthenticationError(fmtObtainCredentialsError(env.account, baseCreds));\n    }\n\n    // Simple case is if we don't need to \"assumeRole\" here. If so, we must now have credentials for the right\n    // account.\n    if (options?.assumeRoleArn === undefined) {\n      if (baseCreds.source === 'incorrectDefault') {\n        throw new AuthenticationError(fmtObtainCredentialsError(env.account, baseCreds));\n      }\n\n      // Our current credentials must be valid and not expired. Confirm that before we get into doing\n      // actual CloudFormation calls, which might take a long time to hang.\n      const sdk = this._makeSdk(baseCreds.credentials, env.region);\n      await sdk.validateCredentials();\n      return { sdk, didAssumeRole: false };\n    }\n\n    try {\n      // We will proceed to AssumeRole using whatever we've been given.\n      const sdk = await this.withAssumedRole(\n        baseCreds,\n        options.assumeRoleArn,\n        options.assumeRoleExternalId,\n        options.assumeRoleAdditionalOptions,\n        env.region,\n      );\n\n      return { sdk, didAssumeRole: true };\n    } catch (err: any) {\n      if (err.name === 'ExpiredToken') {\n        throw err;\n      }\n\n      // AssumeRole failed. Proceed and warn *if and only if* the baseCredentials were already for the right account\n      // or returned from a plugin. This is to cover some current setups for people using plugins or preferring to\n      // feed the CLI credentials which are sufficient by themselves. Prefer to assume the correct role if we can,\n      // but if we can't then let's just try with available credentials anyway.\n      if (baseCreds.source === 'correctDefault' || baseCreds.source === 'plugin') {\n        await this.ioHelper.notify(IO.DEFAULT_SDK_DEBUG.msg(err.message));\n\n        const maker = quiet ? IO.DEFAULT_SDK_DEBUG : IO.DEFAULT_SDK_WARN;\n        await this.ioHelper.notify(maker.msg(\n          `${fmtObtainedCredentials(baseCreds)} could not be used to assume '${options.assumeRoleArn}', but are for the right account. Proceeding anyway.`,\n        ));\n        return {\n          sdk: this._makeSdk(baseCreds.credentials, env.region),\n          didAssumeRole: false,\n        };\n      }\n\n      throw err;\n    }\n  }\n\n  /**\n   * Return the partition that base credentials are for\n   *\n   * Returns `undefined` if there are no base credentials.\n   */\n  public async baseCredentialsPartition(environment: Environment, mode: Mode): Promise<string | undefined> {\n    const env = await this.resolveEnvironment(environment);\n    const baseCreds = await this.obtainBaseCredentials(env.account, mode);\n    if (baseCreds.source === 'none') {\n      return undefined;\n    }\n    return (await this._makeSdk(baseCreds.credentials, env.region).currentAccount()).partition;\n  }\n\n  /**\n   * Resolve the environment for a stack\n   *\n   * Replaces the magic values `UNKNOWN_REGION` and `UNKNOWN_ACCOUNT`\n   * with the defaults for the current SDK configuration (`~/.aws/config` or\n   * otherwise).\n   *\n   * It is an error if `UNKNOWN_ACCOUNT` is used but the user hasn't configured\n   * any SDK credentials.\n   */\n  public async resolveEnvironment(env: Environment): Promise<Environment> {\n    const region = env.region !== UNKNOWN_REGION ? env.region : this.defaultRegion;\n    const account = env.account !== UNKNOWN_ACCOUNT ? env.account : (await this.defaultAccount())?.accountId;\n\n    if (!account) {\n      throw new AuthenticationError(\n        'Unable to resolve AWS account to use. It must be either configured when you define your CDK Stack, or through the environment',\n      );\n    }\n\n    return {\n      region,\n      account,\n      name: EnvironmentUtils.format(account, region),\n    };\n  }\n\n  /**\n   * The account we'd auth into if we used default credentials.\n   *\n   * Default credentials are the set of ambiently configured credentials using\n   * one of the environment variables, or ~/.aws/credentials, or the *one*\n   * profile that was passed into the CLI.\n   *\n   * Might return undefined if there are no default/ambient credentials\n   * available (in which case the user should better hope they have\n   * credential plugins configured).\n   *\n   * Uses a cache to avoid STS calls if we don't need 'em.\n   */\n  public async defaultAccount(): Promise<Account | undefined> {\n    return cached(this, CACHED_ACCOUNT, async () => {\n      try {\n        return await this._makeSdk(this.defaultCredentialProvider, this.defaultRegion).currentAccount();\n      } catch (e: any) {\n        // Treat 'ExpiredToken' specially. This is a common situation that people may find themselves in, and\n        // they are complaining about if we fail 'cdk synth' on them. We loudly complain in order to show that\n        // the current situation is probably undesirable, but we don't fail.\n        if (e.name === 'ExpiredToken') {\n          await this.ioHelper.notify(IO.DEFAULT_SDK_WARN.msg(\n            'There are expired AWS credentials in your environment. The CDK app will synth without current account information.',\n          ));\n          return undefined;\n        }\n\n        await this.ioHelper.notify(IO.DEFAULT_SDK_DEBUG.msg(`Unable to determine the default AWS account (${e.name}): ${formatErrorMessage(e)}`));\n        return undefined;\n      }\n    });\n  }\n\n  /**\n   * Get credentials for the given account ID in the given mode\n   *\n   * 1. Use the default credentials if the destination account matches the\n   *    current credentials' account.\n   * 2. Otherwise try all credential plugins.\n   * 3. Fail if neither of these yield any credentials.\n   * 4. Return a failure if any of them returned credentials\n   */\n  private async obtainBaseCredentials(accountId: string, mode: Mode): Promise<ObtainBaseCredentialsResult> {\n    // First try 'current' credentials\n    const defaultAccountId = (await this.defaultAccount())?.accountId;\n    if (defaultAccountId === accountId) {\n      return {\n        source: 'correctDefault',\n        credentials: await this.defaultCredentialProvider,\n      };\n    }\n\n    // Then try the plugins\n    const pluginCreds = await this.plugins.fetchCredentialsFor(accountId, mode);\n    if (pluginCreds) {\n      return { source: 'plugin', ...pluginCreds };\n    }\n\n    // Fall back to default credentials with a note that they're not the right ones yet\n    if (defaultAccountId !== undefined) {\n      return {\n        source: 'incorrectDefault',\n        accountId: defaultAccountId,\n        credentials: await this.defaultCredentialProvider,\n        unusedPlugins: this.plugins.availablePluginNames,\n      };\n    }\n\n    // Apparently we didn't find any at all\n    return {\n      source: 'none',\n      unusedPlugins: this.plugins.availablePluginNames,\n    };\n  }\n\n  /**\n   * Return an SDK which uses assumed role credentials\n   *\n   * The base credentials used to retrieve the assumed role credentials will be the\n   * same credentials returned by obtainCredentials if an environment and mode is passed,\n   * otherwise it will be the current credentials.\n   */\n  private async withAssumedRole(\n    mainCredentials: Exclude<ObtainBaseCredentialsResult, { source: 'none' }>,\n    roleArn: string,\n    externalId?: string,\n    additionalOptions?: AssumeRoleAdditionalOptions,\n    region?: string,\n  ): Promise<SDK> {\n    await this.ioHelper.notify(IO.DEFAULT_SDK_DEBUG.msg(`Assuming role '${roleArn}'.`));\n\n    region = region ?? this.defaultRegion;\n\n    const sourceDescription = fmtObtainedCredentials(mainCredentials);\n\n    try {\n      const credentials = await makeCachingProvider(fromTemporaryCredentials({\n        masterCredentials: mainCredentials.credentials,\n        params: {\n          RoleArn: roleArn,\n          ExternalId: externalId,\n          RoleSessionName: `aws-cdk-${safeUsername()}`,\n          ...additionalOptions,\n          TransitiveTagKeys: additionalOptions?.Tags ? additionalOptions.Tags.map((t) => t.Key!) : undefined,\n        },\n        clientConfig: {\n          region,\n          requestHandler: this.requestHandler,\n          customUserAgent: 'aws-cdk',\n          logger: this.logger,\n        },\n        logger: this.logger,\n      }));\n\n      // Call the provider at least once here, to catch an error if it occurs\n      await credentials();\n\n      return this._makeSdk(credentials, region);\n    } catch (err: any) {\n      if (err.name === 'ExpiredToken') {\n        throw err;\n      }\n\n      await this.ioHelper.notify(IO.DEFAULT_SDK_DEBUG.msg(`Assuming role failed: ${err.message}`));\n      throw new AuthenticationError(\n        [\n          'Could not assume role in target account',\n          ...(sourceDescription ? [`using ${sourceDescription}`] : []),\n          err.message,\n          \". Please make sure that this role exists in the account. If it doesn't exist, (re)-bootstrap the environment \" +\n            \"with the right '--trust', using the latest version of the CDK CLI.\",\n        ].join(' '),\n      );\n    }\n  }\n\n  /**\n   * Factory function that creates a new SDK instance\n   *\n   * This is a function here, instead of all the places where this is used creating a `new SDK`\n   * instance, so that it is trivial to mock from tests.\n   *\n   * Use like this:\n   *\n   * ```ts\n   * const mockSdk = jest.spyOn(SdkProvider.prototype, '_makeSdk').mockReturnValue(new MockSdk());\n   * // ...\n   * mockSdk.mockRestore();\n   * ```\n   *\n   * @internal\n   */\n  public _makeSdk(\n    credProvider: AwsCredentialIdentityProvider,\n    region: string,\n  ) {\n    return new SDK(credProvider, region, this.requestHandler, this.ioHelper, this.logger);\n  }\n}\n\n/**\n * An AWS account\n *\n * An AWS account always exists in only one partition. Usually we don't care about\n * the partition, but when we need to form ARNs we do.\n */\nexport interface Account {\n  /**\n   * The account number\n   */\n  readonly accountId: string;\n\n  /**\n   * The partition ('aws' or 'aws-cn' or otherwise)\n   */\n  readonly partition: string;\n}\n\n/**\n * Return the username with characters invalid for a RoleSessionName removed\n *\n * @see https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html#API_AssumeRole_RequestParameters\n */\nfunction safeUsername() {\n  try {\n    return os.userInfo().username.replace(/[^\\w+=,.@-]/g, '@');\n  } catch {\n    return 'noname';\n  }\n}\n\n/**\n * Options for obtaining credentials for an environment\n */\nexport interface CredentialsOptions {\n  /**\n   * The ARN of the role that needs to be assumed, if any\n   */\n  readonly assumeRoleArn?: string;\n\n  /**\n   * External ID required to assume the given role.\n   */\n  readonly assumeRoleExternalId?: string;\n\n  /**\n   * Session tags required to assume the given role.\n   */\n  readonly assumeRoleAdditionalOptions?: AssumeRoleAdditionalOptions;\n}\n\n/**\n * Result of obtaining base credentials\n */\ntype ObtainBaseCredentialsResult =\n  | { source: 'correctDefault'; credentials: AwsCredentialIdentityProvider }\n  | { source: 'plugin'; pluginName: string; credentials: AwsCredentialIdentityProvider }\n  | {\n    source: 'incorrectDefault';\n    credentials: AwsCredentialIdentityProvider;\n    accountId: string;\n    unusedPlugins: string[];\n  }\n  | { source: 'none'; unusedPlugins: string[] };\n\n/**\n * Isolating the code that translates calculation errors into human error messages\n *\n * We cover the following cases:\n *\n * - No credentials are available at all\n * - Default credentials are for the wrong account\n */\nfunction fmtObtainCredentialsError(\n  targetAccountId: string,\n  obtainResult: ObtainBaseCredentialsResult & {\n    source: 'none' | 'incorrectDefault';\n  },\n): string {\n  const msg = [`Need to perform AWS calls for account ${targetAccountId}`];\n  switch (obtainResult.source) {\n    case 'incorrectDefault':\n      msg.push(`but the current credentials are for ${obtainResult.accountId}`);\n      break;\n    case 'none':\n      msg.push('but no credentials have been configured');\n  }\n  if (obtainResult.unusedPlugins.length > 0) {\n    msg.push(`and none of these plugins found any: ${obtainResult.unusedPlugins.join(', ')}`);\n  }\n  return msg.join(', ');\n}\n\n/**\n * Format a message indicating where we got base credentials for the assume role\n *\n * We cover the following cases:\n *\n * - Default credentials for the right account\n * - Default credentials for the wrong account\n * - Credentials returned from a plugin\n */\nfunction fmtObtainedCredentials(obtainResult: Exclude<ObtainBaseCredentialsResult, { source: 'none' }>): string {\n  switch (obtainResult.source) {\n    case 'correctDefault':\n      return 'current credentials';\n    case 'plugin':\n      return `credentials returned by plugin '${obtainResult.pluginName}'`;\n    case 'incorrectDefault':\n      const msg = [];\n      msg.push(`current credentials (which are for account ${obtainResult.accountId}`);\n\n      if (obtainResult.unusedPlugins.length > 0) {\n        msg.push(`, and none of the following plugins provided credentials: ${obtainResult.unusedPlugins.join(', ')}`);\n      }\n      msg.push(')');\n\n      return msg.join('');\n  }\n}\n\n/**\n * Instantiate an SDK for context providers. This function ensures that all\n * lookup assume role options are used when context providers perform lookups.\n */\nexport async function initContextProviderSdk(aws: SdkProvider, options: ContextLookupRoleOptions): Promise<SDK> {\n  const account = options.account;\n  const region = options.region;\n\n  const creds: CredentialsOptions = {\n    assumeRoleArn: options.lookupRoleArn,\n    assumeRoleExternalId: options.lookupRoleExternalId,\n    assumeRoleAdditionalOptions: options.assumeRoleAdditionalOptions,\n  };\n\n  return (await aws.forEnvironment(EnvironmentUtils.make(account, region), Mode.ForReading, creds)).sdk;\n}\n\nexport interface SdkProviderServices {\n  /**\n   * An IO helper for emitting messages\n   */\n  readonly ioHelper: IoHelper;\n\n  /**\n   * The request handler settings\n   */\n  readonly requestHandler?: NodeHttpHandlerOptions;\n\n  /**\n   * A plugin host\n   */\n  readonly pluginHost?: PluginHost;\n\n  /**\n   * An SDK logger\n   */\n  readonly logger?: Logger;\n}\n"]} \ No newline at end of file diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/sdk.d.ts b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/sdk.d.ts new file mode 100644 index 000000000..fad1bd30c --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/sdk.d.ts @@ -0,0 +1,239 @@ +import type { FunctionConfiguration, GetSchemaCreationStatusCommandInput, GetSchemaCreationStatusCommandOutput, ListFunctionsCommandInput, StartSchemaCreationCommandInput, StartSchemaCreationCommandOutput, UpdateApiKeyCommandInput, UpdateApiKeyCommandOutput, UpdateFunctionCommandInput, UpdateFunctionCommandOutput, UpdateResolverCommandInput, UpdateResolverCommandOutput } from '@aws-sdk/client-appsync'; +import type { GetResourceCommandInput, GetResourceCommandOutput, ListResourcesCommandInput, ListResourcesCommandOutput } from '@aws-sdk/client-cloudcontrol'; +import type { ContinueUpdateRollbackCommandInput, ContinueUpdateRollbackCommandOutput, DescribeStackEventsCommandOutput, DescribeStackResourcesCommandInput, DescribeStackResourcesCommandOutput, ListStacksCommandInput, ListStacksCommandOutput, RollbackStackCommandInput, RollbackStackCommandOutput, StackResourceSummary, CreateChangeSetCommandInput, CreateChangeSetCommandOutput, CreateGeneratedTemplateCommandInput, CreateGeneratedTemplateCommandOutput, CreateStackCommandInput, CreateStackCommandOutput, DeleteChangeSetCommandInput, DeleteChangeSetCommandOutput, DeleteGeneratedTemplateCommandInput, DeleteGeneratedTemplateCommandOutput, DeleteStackCommandInput, DeleteStackCommandOutput, DescribeChangeSetCommandInput, DescribeChangeSetCommandOutput, DescribeGeneratedTemplateCommandInput, DescribeGeneratedTemplateCommandOutput, DescribeResourceScanCommandInput, DescribeResourceScanCommandOutput, DescribeStackEventsCommandInput, DescribeStacksCommandInput, DescribeStacksCommandOutput, ExecuteChangeSetCommandInput, ExecuteChangeSetCommandOutput, GetGeneratedTemplateCommandInput, GetGeneratedTemplateCommandOutput, GetTemplateCommandInput, GetTemplateCommandOutput, GetTemplateSummaryCommandInput, GetTemplateSummaryCommandOutput, ListExportsCommandInput, ListExportsCommandOutput, ListResourceScanRelatedResourcesCommandInput, ListResourceScanRelatedResourcesCommandOutput, ListResourceScanResourcesCommandInput, ListResourceScanResourcesCommandOutput, ListResourceScansCommandInput, ListResourceScansCommandOutput, ListStackResourcesCommandInput, StartResourceScanCommandInput, StartResourceScanCommandOutput, UpdateStackCommandInput, UpdateStackCommandOutput, UpdateTerminationProtectionCommandInput, UpdateTerminationProtectionCommandOutput, StackSummary, DescribeStackDriftDetectionStatusCommandInput, DescribeStackDriftDetectionStatusCommandOutput, DescribeStackResourceDriftsCommandOutput, DetectStackDriftCommandInput, DetectStackDriftCommandOutput, DetectStackResourceDriftCommandInput, DetectStackResourceDriftCommandOutput, DescribeStackResourceDriftsCommandInput } from '@aws-sdk/client-cloudformation'; +import type { FilterLogEventsCommandInput, FilterLogEventsCommandOutput, DescribeLogGroupsCommandInput, DescribeLogGroupsCommandOutput } from '@aws-sdk/client-cloudwatch-logs'; +import { type UpdateProjectCommandInput, type UpdateProjectCommandOutput } from '@aws-sdk/client-codebuild'; +import { type DescribeAvailabilityZonesCommandInput, type DescribeAvailabilityZonesCommandOutput, type DescribeImagesCommandInput, type DescribeImagesCommandOutput, type DescribeInstancesCommandInput, type DescribeInstancesCommandOutput, type DescribeRouteTablesCommandInput, type DescribeRouteTablesCommandOutput, type DescribeSecurityGroupsCommandInput, type DescribeSecurityGroupsCommandOutput, type DescribeSubnetsCommandInput, type DescribeSubnetsCommandOutput, type DescribeVpcEndpointServicesCommandInput, type DescribeVpcEndpointServicesCommandOutput, type DescribeVpcsCommandInput, type DescribeVpcsCommandOutput, type DescribeVpnGatewaysCommandInput, type DescribeVpnGatewaysCommandOutput } from '@aws-sdk/client-ec2'; +import type { BatchDeleteImageCommandInput, BatchDeleteImageCommandOutput, ListImagesCommandInput, ListImagesCommandOutput, PutImageCommandInput, PutImageCommandOutput, BatchGetImageCommandInput, BatchGetImageCommandOutput, CreateRepositoryCommandInput, CreateRepositoryCommandOutput, DescribeImagesCommandInput as ECRDescribeImagesCommandInput, DescribeImagesCommandOutput as ECRDescribeImagesCommandOutput, DescribeRepositoriesCommandInput, DescribeRepositoriesCommandOutput, GetAuthorizationTokenCommandInput, GetAuthorizationTokenCommandOutput, PutImageScanningConfigurationCommandInput, PutImageScanningConfigurationCommandOutput } from '@aws-sdk/client-ecr'; +import type { DescribeServicesCommandInput, RegisterTaskDefinitionCommandInput, ListClustersCommandInput, ListClustersCommandOutput, RegisterTaskDefinitionCommandOutput, UpdateServiceCommandInput, UpdateServiceCommandOutput } from '@aws-sdk/client-ecs'; +import type { Listener, LoadBalancer, DescribeListenersCommandInput, DescribeListenersCommandOutput, DescribeLoadBalancersCommandInput, DescribeLoadBalancersCommandOutput, DescribeTagsCommandInput, DescribeTagsCommandOutput } from '@aws-sdk/client-elastic-load-balancing-v2'; +import { type CreatePolicyCommandInput, type CreatePolicyCommandOutput, type GetPolicyCommandInput, type GetPolicyCommandOutput, type GetRoleCommandInput, type GetRoleCommandOutput } from '@aws-sdk/client-iam'; +import { type DescribeKeyCommandInput, type DescribeKeyCommandOutput, type ListAliasesCommandInput, type ListAliasesCommandOutput } from '@aws-sdk/client-kms'; +import { type InvokeCommandInput, type InvokeCommandOutput, type PublishVersionCommandInput, type PublishVersionCommandOutput, type UpdateAliasCommandInput, type UpdateAliasCommandOutput, type UpdateFunctionCodeCommandInput, type UpdateFunctionCodeCommandOutput, type UpdateFunctionConfigurationCommandInput, type UpdateFunctionConfigurationCommandOutput } from '@aws-sdk/client-lambda'; +import { type GetHostedZoneCommandInput, type GetHostedZoneCommandOutput, type ListHostedZonesByNameCommandInput, type ListHostedZonesByNameCommandOutput, type ListHostedZonesCommandInput, type ListHostedZonesCommandOutput } from '@aws-sdk/client-route-53'; +import type { DeleteObjectsCommandInput, DeleteObjectsCommandOutput, DeleteObjectTaggingCommandInput, DeleteObjectTaggingCommandOutput, GetObjectTaggingCommandInput, GetObjectTaggingCommandOutput, PutObjectTaggingCommandInput, PutObjectTaggingCommandOutput, CompleteMultipartUploadCommandOutput, GetBucketEncryptionCommandInput, GetBucketEncryptionCommandOutput, GetBucketLocationCommandInput, GetBucketLocationCommandOutput, GetObjectCommandInput, GetObjectCommandOutput, ListObjectsV2CommandInput, ListObjectsV2CommandOutput, PutObjectCommandInput } from '@aws-sdk/client-s3'; +import { type GetSecretValueCommandInput, type GetSecretValueCommandOutput } from '@aws-sdk/client-secrets-manager'; +import type { UpdateStateMachineCommandInput, UpdateStateMachineCommandOutput } from '@aws-sdk/client-sfn'; +import { type GetParameterCommandInput, type GetParameterCommandOutput } from '@aws-sdk/client-ssm'; +import type { NodeHttpHandlerOptions } from '@smithy/node-http-handler'; +import type { AwsCredentialIdentityProvider, Logger } from '@smithy/types'; +import { ConfiguredRetryStrategy } from '@smithy/util-retry'; +import type { WaiterResult } from '@smithy/util-waiter'; +import type { Account } from './sdk-provider'; +import { type IoHelper } from '../io/private'; +export interface S3ClientOptions { + /** + * If APIs are used that require MD5 checksums. + * + * Some S3 APIs in SDKv2 have a bug that always requires them to use a MD5 checksum. + * These APIs are not going to be supported in a FIPS environment. + */ + needsMd5Checksums?: boolean; +} +/** + * Additional SDK configuration options + */ +export interface SdkOptions { + /** + * Additional descriptive strings that indicate where the "AssumeRole" credentials are coming from + * + * Will be printed in an error message to help users diagnose auth problems. + */ + readonly assumeRoleCredentialsSourceDescription?: string; +} +export interface ConfigurationOptions { + region: string; + credentials: AwsCredentialIdentityProvider; + requestHandler: NodeHttpHandlerOptions; + retryStrategy: ConfiguredRetryStrategy; + customUserAgent: string; + logger?: Logger; + s3DisableBodySigning?: boolean; + computeChecksums?: boolean; +} +export interface IAppSyncClient { + getSchemaCreationStatus(input: GetSchemaCreationStatusCommandInput): Promise; + startSchemaCreation(input: StartSchemaCreationCommandInput): Promise; + updateApiKey(input: UpdateApiKeyCommandInput): Promise; + updateFunction(input: UpdateFunctionCommandInput): Promise; + updateResolver(input: UpdateResolverCommandInput): Promise; + listFunctions(input: ListFunctionsCommandInput): Promise; +} +export interface ICloudControlClient { + listResources(input: ListResourcesCommandInput): Promise; + getResource(input: GetResourceCommandInput): Promise; +} +export interface ICloudFormationClient { + continueUpdateRollback(input: ContinueUpdateRollbackCommandInput): Promise; + createChangeSet(input: CreateChangeSetCommandInput): Promise; + createGeneratedTemplate(input: CreateGeneratedTemplateCommandInput): Promise; + createStack(input: CreateStackCommandInput): Promise; + deleteChangeSet(input: DeleteChangeSetCommandInput): Promise; + deleteGeneratedTemplate(input: DeleteGeneratedTemplateCommandInput): Promise; + deleteStack(input: DeleteStackCommandInput): Promise; + describeChangeSet(input: DescribeChangeSetCommandInput): Promise; + describeGeneratedTemplate(input: DescribeGeneratedTemplateCommandInput): Promise; + describeResourceScan(input: DescribeResourceScanCommandInput): Promise; + describeStackDriftDetectionStatus(input: DescribeStackDriftDetectionStatusCommandInput): Promise; + describeStacks(input: DescribeStacksCommandInput): Promise; + describeStackResourceDrifts(input: DescribeStackResourceDriftsCommandInput): Promise; + describeStackResources(input: DescribeStackResourcesCommandInput): Promise; + detectStackDrift(input: DetectStackDriftCommandInput): Promise; + detectStackResourceDrift(input: DetectStackResourceDriftCommandInput): Promise; + executeChangeSet(input: ExecuteChangeSetCommandInput): Promise; + getGeneratedTemplate(input: GetGeneratedTemplateCommandInput): Promise; + getTemplate(input: GetTemplateCommandInput): Promise; + getTemplateSummary(input: GetTemplateSummaryCommandInput): Promise; + listExports(input: ListExportsCommandInput): Promise; + listResourceScanRelatedResources(input: ListResourceScanRelatedResourcesCommandInput): Promise; + listResourceScanResources(input: ListResourceScanResourcesCommandInput): Promise; + listResourceScans(input?: ListResourceScansCommandInput): Promise; + listStacks(input: ListStacksCommandInput): Promise; + rollbackStack(input: RollbackStackCommandInput): Promise; + startResourceScan(input: StartResourceScanCommandInput): Promise; + updateStack(input: UpdateStackCommandInput): Promise; + updateTerminationProtection(input: UpdateTerminationProtectionCommandInput): Promise; + describeStackEvents(input: DescribeStackEventsCommandInput): Promise; + listStackResources(input: ListStackResourcesCommandInput): Promise; + paginatedListStacks(input: ListStacksCommandInput): Promise; +} +export interface ICloudWatchLogsClient { + describeLogGroups(input: DescribeLogGroupsCommandInput): Promise; + filterLogEvents(input: FilterLogEventsCommandInput): Promise; +} +export interface ICodeBuildClient { + updateProject(input: UpdateProjectCommandInput): Promise; +} +export interface IEC2Client { + describeAvailabilityZones(input: DescribeAvailabilityZonesCommandInput): Promise; + describeImages(input: DescribeImagesCommandInput): Promise; + describeInstances(input: DescribeInstancesCommandInput): Promise; + describeRouteTables(input: DescribeRouteTablesCommandInput): Promise; + describeSecurityGroups(input: DescribeSecurityGroupsCommandInput): Promise; + describeSubnets(input: DescribeSubnetsCommandInput): Promise; + describeVpcEndpointServices(input: DescribeVpcEndpointServicesCommandInput): Promise; + describeVpcs(input: DescribeVpcsCommandInput): Promise; + describeVpnGateways(input: DescribeVpnGatewaysCommandInput): Promise; +} +export interface IECRClient { + batchDeleteImage(input: BatchDeleteImageCommandInput): Promise; + batchGetImage(input: BatchGetImageCommandInput): Promise; + createRepository(input: CreateRepositoryCommandInput): Promise; + describeImages(input: ECRDescribeImagesCommandInput): Promise; + describeRepositories(input: DescribeRepositoriesCommandInput): Promise; + getAuthorizationToken(input: GetAuthorizationTokenCommandInput): Promise; + listImages(input: ListImagesCommandInput): Promise; + putImage(input: PutImageCommandInput): Promise; + putImageScanningConfiguration(input: PutImageScanningConfigurationCommandInput): Promise; +} +export interface IECSClient { + listClusters(input: ListClustersCommandInput): Promise; + registerTaskDefinition(input: RegisterTaskDefinitionCommandInput): Promise; + updateService(input: UpdateServiceCommandInput): Promise; + waitUntilServicesStable(input: DescribeServicesCommandInput): Promise; +} +export interface IElasticLoadBalancingV2Client { + describeListeners(input: DescribeListenersCommandInput): Promise; + describeLoadBalancers(input: DescribeLoadBalancersCommandInput): Promise; + describeTags(input: DescribeTagsCommandInput): Promise; + paginateDescribeListeners(input: DescribeListenersCommandInput): Promise; + paginateDescribeLoadBalancers(input: DescribeLoadBalancersCommandInput): Promise; +} +export interface IIAMClient { + createPolicy(input: CreatePolicyCommandInput): Promise; + getPolicy(input: GetPolicyCommandInput): Promise; + getRole(input: GetRoleCommandInput): Promise; +} +export interface IKMSClient { + describeKey(input: DescribeKeyCommandInput): Promise; + listAliases(input: ListAliasesCommandInput): Promise; +} +export interface ILambdaClient { + invokeCommand(input: InvokeCommandInput): Promise; + publishVersion(input: PublishVersionCommandInput): Promise; + updateAlias(input: UpdateAliasCommandInput): Promise; + updateFunctionCode(input: UpdateFunctionCodeCommandInput): Promise; + updateFunctionConfiguration(input: UpdateFunctionConfigurationCommandInput): Promise; + waitUntilFunctionUpdated(delaySeconds: number, input: UpdateFunctionConfigurationCommandInput): Promise; +} +export interface IRoute53Client { + getHostedZone(input: GetHostedZoneCommandInput): Promise; + listHostedZones(input: ListHostedZonesCommandInput): Promise; + listHostedZonesByName(input: ListHostedZonesByNameCommandInput): Promise; +} +export interface IS3Client { + deleteObjects(input: DeleteObjectsCommandInput): Promise; + deleteObjectTagging(input: DeleteObjectTaggingCommandInput): Promise; + getBucketEncryption(input: GetBucketEncryptionCommandInput): Promise; + getBucketLocation(input: GetBucketLocationCommandInput): Promise; + getObject(input: GetObjectCommandInput): Promise; + getObjectTagging(input: GetObjectTaggingCommandInput): Promise; + listObjectsV2(input: ListObjectsV2CommandInput): Promise; + putObjectTagging(input: PutObjectTaggingCommandInput): Promise; + upload(input: PutObjectCommandInput): Promise; +} +export interface ISecretsManagerClient { + getSecretValue(input: GetSecretValueCommandInput): Promise; +} +export interface ISSMClient { + getParameter(input: GetParameterCommandInput): Promise; +} +export interface IStepFunctionsClient { + updateStateMachine(input: UpdateStateMachineCommandInput): Promise; +} +/** + * Base functionality of SDK without credential fetching + */ +export declare class SDK { + private readonly credProvider; + readonly currentRegion: string; + readonly config: ConfigurationOptions; + protected readonly logger?: Logger; + private readonly accountCache; + /** + * STS is used to check credential validity, don't do too many retries. + */ + private readonly stsRetryStrategy; + /** + * Whether we have proof that the credentials have not expired + * + * We need to do some manual plumbing around this because the JS SDKv2 treats `ExpiredToken` + * as retriable and we have hefty retries on CFN calls making the CLI hang for a good 15 minutes + * if the credentials have expired. + */ + private _credentialsValidated; + /** + * A function to create debug messages + */ + private readonly debug; + constructor(credProvider: AwsCredentialIdentityProvider, region: string, requestHandler: NodeHttpHandlerOptions, ioHelper: IoHelper, logger?: Logger); + appendCustomUserAgent(userAgentData?: string): void; + removeCustomUserAgent(userAgentData: string): void; + appsync(): IAppSyncClient; + cloudControl(): ICloudControlClient; + cloudFormation(): ICloudFormationClient; + cloudWatchLogs(): ICloudWatchLogsClient; + codeBuild(): ICodeBuildClient; + ec2(): IEC2Client; + ecr(): IECRClient; + ecs(): IECSClient; + elbv2(): IElasticLoadBalancingV2Client; + iam(): IIAMClient; + kms(): IKMSClient; + lambda(): ILambdaClient; + route53(): IRoute53Client; + s3(): IS3Client; + secretsManager(): ISecretsManagerClient; + ssm(): ISSMClient; + stepFunctions(): IStepFunctionsClient; + /** + * The AWS SDK v3 requires a client config and a command in order to get an endpoint for + * any given service. + */ + getUrlSuffix(region: string): Promise; + currentAccount(): Promise; + /** + * Make sure the the current credentials are not expired + */ + validateCredentials(): Promise; +} diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/sdk.js b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/sdk.js new file mode 100644 index 000000000..32320ce7e --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/sdk.js @@ -0,0 +1,395 @@ +"use strict"; +var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.SDK = void 0; +const client_appsync_1 = require("@aws-sdk/client-appsync"); +const client_cloudcontrol_1 = require("@aws-sdk/client-cloudcontrol"); +const client_cloudformation_1 = require("@aws-sdk/client-cloudformation"); +const client_cloudwatch_logs_1 = require("@aws-sdk/client-cloudwatch-logs"); +const client_codebuild_1 = require("@aws-sdk/client-codebuild"); +const client_ec2_1 = require("@aws-sdk/client-ec2"); +const client_ecr_1 = require("@aws-sdk/client-ecr"); +const client_ecs_1 = require("@aws-sdk/client-ecs"); +const client_elastic_load_balancing_v2_1 = require("@aws-sdk/client-elastic-load-balancing-v2"); +const client_iam_1 = require("@aws-sdk/client-iam"); +const client_kms_1 = require("@aws-sdk/client-kms"); +const client_lambda_1 = require("@aws-sdk/client-lambda"); +const client_route_53_1 = require("@aws-sdk/client-route-53"); +const client_s3_1 = require("@aws-sdk/client-s3"); +const client_secrets_manager_1 = require("@aws-sdk/client-secrets-manager"); +const client_sfn_1 = require("@aws-sdk/client-sfn"); +const client_ssm_1 = require("@aws-sdk/client-ssm"); +const client_sts_1 = require("@aws-sdk/client-sts"); +const lib_storage_1 = require("@aws-sdk/lib-storage"); +const middleware_endpoint_1 = require("@smithy/middleware-endpoint"); +const util_retry_1 = require("@smithy/util-retry"); +const account_cache_1 = require("./account-cache"); +const cached_1 = require("./cached"); +const tracing_1 = require("./tracing"); +const user_agent_1 = require("./user-agent"); +const util_1 = require("../../util"); +const private_1 = require("../io/private"); +const toolkit_error_1 = require("../toolkit-error"); +/** + * Base functionality of SDK without credential fetching + */ +let SDK = class SDK { + credProvider; + currentRegion; + config; + logger; + accountCache; + /** + * STS is used to check credential validity, don't do too many retries. + */ + stsRetryStrategy = new util_retry_1.ConfiguredRetryStrategy(3, (attempt) => 100 * (2 ** attempt)); + /** + * Whether we have proof that the credentials have not expired + * + * We need to do some manual plumbing around this because the JS SDKv2 treats `ExpiredToken` + * as retriable and we have hefty retries on CFN calls making the CLI hang for a good 15 minutes + * if the credentials have expired. + */ + _credentialsValidated = false; + /** + * A function to create debug messages + */ + debug; + constructor(credProvider, region, requestHandler, ioHelper, logger) { + this.credProvider = credProvider; + const debugFn = async (msg) => ioHelper.notify(private_1.IO.DEFAULT_SDK_DEBUG.msg(msg)); + this.accountCache = new account_cache_1.AccountAccessKeyCache(account_cache_1.AccountAccessKeyCache.DEFAULT_PATH, debugFn); + this.debug = debugFn; + this.config = { + region, + credentials: credProvider, + requestHandler, + retryStrategy: new util_retry_1.ConfiguredRetryStrategy(7, (attempt) => 300 * (2 ** attempt)), + customUserAgent: (0, user_agent_1.defaultCliUserAgent)(), + logger, + }; + this.logger = logger; + this.currentRegion = region; + } + appendCustomUserAgent(userAgentData) { + if (!userAgentData) { + return; + } + const currentCustomUserAgent = this.config.customUserAgent; + this.config.customUserAgent = currentCustomUserAgent ? `${currentCustomUserAgent} ${userAgentData}` : userAgentData; + } + removeCustomUserAgent(userAgentData) { + this.config.customUserAgent = this.config.customUserAgent?.replace(userAgentData, ''); + } + appsync() { + const client = new client_appsync_1.AppSyncClient(this.config); + return { + getSchemaCreationStatus: (input) => client.send(new client_appsync_1.GetSchemaCreationStatusCommand(input)), + startSchemaCreation: (input) => client.send(new client_appsync_1.StartSchemaCreationCommand(input)), + updateApiKey: (input) => client.send(new client_appsync_1.UpdateApiKeyCommand(input)), + updateFunction: (input) => client.send(new client_appsync_1.UpdateFunctionCommand(input)), + updateResolver: (input) => client.send(new client_appsync_1.UpdateResolverCommand(input)), + // Pagination Functions + listFunctions: async (input) => { + const functions = Array(); + const paginator = (0, client_appsync_1.paginateListFunctions)({ client }, input); + for await (const page of paginator) { + functions.push(...(page.functions || [])); + } + return functions; + }, + }; + } + cloudControl() { + const client = new client_cloudcontrol_1.CloudControlClient(this.config); + return { + listResources: (input) => client.send(new client_cloudcontrol_1.ListResourcesCommand(input)), + getResource: (input) => client.send(new client_cloudcontrol_1.GetResourceCommand(input)), + }; + } + cloudFormation() { + const client = new client_cloudformation_1.CloudFormationClient({ + ...this.config, + retryStrategy: new util_retry_1.ConfiguredRetryStrategy(11, (attempt) => 1000 * (2 ** attempt)), + }); + return { + continueUpdateRollback: async (input) => client.send(new client_cloudformation_1.ContinueUpdateRollbackCommand(input)), + createChangeSet: (input) => client.send(new client_cloudformation_1.CreateChangeSetCommand(input)), + createGeneratedTemplate: (input) => client.send(new client_cloudformation_1.CreateGeneratedTemplateCommand(input)), + createStack: (input) => client.send(new client_cloudformation_1.CreateStackCommand(input)), + deleteChangeSet: (input) => client.send(new client_cloudformation_1.DeleteChangeSetCommand(input)), + deleteGeneratedTemplate: (input) => client.send(new client_cloudformation_1.DeleteGeneratedTemplateCommand(input)), + deleteStack: (input) => client.send(new client_cloudformation_1.DeleteStackCommand(input)), + detectStackDrift: (input) => client.send(new client_cloudformation_1.DetectStackDriftCommand(input)), + detectStackResourceDrift: (input) => client.send(new client_cloudformation_1.DetectStackResourceDriftCommand(input)), + describeChangeSet: (input) => client.send(new client_cloudformation_1.DescribeChangeSetCommand(input)), + describeGeneratedTemplate: (input) => client.send(new client_cloudformation_1.DescribeGeneratedTemplateCommand(input)), + describeResourceScan: (input) => client.send(new client_cloudformation_1.DescribeResourceScanCommand(input)), + describeStackDriftDetectionStatus: (input) => client.send(new client_cloudformation_1.DescribeStackDriftDetectionStatusCommand(input)), + describeStackResourceDrifts: (input) => client.send(new client_cloudformation_1.DescribeStackResourceDriftsCommand(input)), + describeStacks: (input) => client.send(new client_cloudformation_1.DescribeStacksCommand(input)), + describeStackResources: (input) => client.send(new client_cloudformation_1.DescribeStackResourcesCommand(input)), + executeChangeSet: (input) => client.send(new client_cloudformation_1.ExecuteChangeSetCommand(input)), + getGeneratedTemplate: (input) => client.send(new client_cloudformation_1.GetGeneratedTemplateCommand(input)), + getTemplate: (input) => client.send(new client_cloudformation_1.GetTemplateCommand(input)), + getTemplateSummary: (input) => client.send(new client_cloudformation_1.GetTemplateSummaryCommand(input)), + listExports: (input) => client.send(new client_cloudformation_1.ListExportsCommand(input)), + listResourceScanRelatedResources: (input) => client.send(new client_cloudformation_1.ListResourceScanRelatedResourcesCommand(input)), + listResourceScanResources: (input) => client.send(new client_cloudformation_1.ListResourceScanResourcesCommand(input)), + listResourceScans: (input) => client.send(new client_cloudformation_1.ListResourceScansCommand(input)), + listStacks: (input) => client.send(new client_cloudformation_1.ListStacksCommand(input)), + rollbackStack: (input) => client.send(new client_cloudformation_1.RollbackStackCommand(input)), + startResourceScan: (input) => client.send(new client_cloudformation_1.StartResourceScanCommand(input)), + updateStack: (input) => client.send(new client_cloudformation_1.UpdateStackCommand(input)), + updateTerminationProtection: (input) => client.send(new client_cloudformation_1.UpdateTerminationProtectionCommand(input)), + describeStackEvents: (input) => { + return client.send(new client_cloudformation_1.DescribeStackEventsCommand(input)); + }, + listStackResources: async (input) => { + const stackResources = Array(); + const paginator = (0, client_cloudformation_1.paginateListStackResources)({ client }, input); + for await (const page of paginator) { + stackResources.push(...(page?.StackResourceSummaries || [])); + } + return stackResources; + }, + paginatedListStacks: async (input) => { + const stackResources = Array(); + const paginator = (0, client_cloudformation_1.paginateListStacks)({ client }, input); + for await (const page of paginator) { + stackResources.push(...(page?.StackSummaries || [])); + } + return stackResources; + }, + }; + } + cloudWatchLogs() { + const client = new client_cloudwatch_logs_1.CloudWatchLogsClient(this.config); + return { + describeLogGroups: (input) => client.send(new client_cloudwatch_logs_1.DescribeLogGroupsCommand(input)), + filterLogEvents: (input) => client.send(new client_cloudwatch_logs_1.FilterLogEventsCommand(input)), + }; + } + codeBuild() { + const client = new client_codebuild_1.CodeBuildClient(this.config); + return { + updateProject: (input) => client.send(new client_codebuild_1.UpdateProjectCommand(input)), + }; + } + ec2() { + const client = new client_ec2_1.EC2Client(this.config); + return { + describeAvailabilityZones: (input) => client.send(new client_ec2_1.DescribeAvailabilityZonesCommand(input)), + describeImages: (input) => client.send(new client_ec2_1.DescribeImagesCommand(input)), + describeInstances: (input) => client.send(new client_ec2_1.DescribeInstancesCommand(input)), + describeRouteTables: (input) => client.send(new client_ec2_1.DescribeRouteTablesCommand(input)), + describeSecurityGroups: (input) => client.send(new client_ec2_1.DescribeSecurityGroupsCommand(input)), + describeSubnets: (input) => client.send(new client_ec2_1.DescribeSubnetsCommand(input)), + describeVpcEndpointServices: (input) => client.send(new client_ec2_1.DescribeVpcEndpointServicesCommand(input)), + describeVpcs: (input) => client.send(new client_ec2_1.DescribeVpcsCommand(input)), + describeVpnGateways: (input) => client.send(new client_ec2_1.DescribeVpnGatewaysCommand(input)), + }; + } + ecr() { + const client = new client_ecr_1.ECRClient(this.config); + return { + batchDeleteImage: (input) => client.send(new client_ecr_1.BatchDeleteImageCommand(input)), + batchGetImage: (input) => client.send(new client_ecr_1.BatchGetImageCommand(input)), + createRepository: (input) => client.send(new client_ecr_1.CreateRepositoryCommand(input)), + describeImages: (input) => client.send(new client_ecr_1.DescribeImagesCommand(input)), + describeRepositories: (input) => client.send(new client_ecr_1.DescribeRepositoriesCommand(input)), + getAuthorizationToken: (input) => client.send(new client_ecr_1.GetAuthorizationTokenCommand(input)), + listImages: (input) => client.send(new client_ecr_1.ListImagesCommand(input)), + putImage: (input) => client.send(new client_ecr_1.PutImageCommand(input)), + putImageScanningConfiguration: (input) => client.send(new client_ecr_1.PutImageScanningConfigurationCommand(input)), + }; + } + ecs() { + const client = new client_ecs_1.ECSClient(this.config); + return { + listClusters: (input) => client.send(new client_ecs_1.ListClustersCommand(input)), + registerTaskDefinition: (input) => client.send(new client_ecs_1.RegisterTaskDefinitionCommand(input)), + updateService: (input) => client.send(new client_ecs_1.UpdateServiceCommand(input)), + // Waiters + waitUntilServicesStable: (input) => { + return (0, client_ecs_1.waitUntilServicesStable)({ + client, + maxWaitTime: 600, + minDelay: 6, + maxDelay: 6, + }, input); + }, + }; + } + elbv2() { + const client = new client_elastic_load_balancing_v2_1.ElasticLoadBalancingV2Client(this.config); + return { + describeListeners: (input) => client.send(new client_elastic_load_balancing_v2_1.DescribeListenersCommand(input)), + describeLoadBalancers: (input) => client.send(new client_elastic_load_balancing_v2_1.DescribeLoadBalancersCommand(input)), + describeTags: (input) => client.send(new client_elastic_load_balancing_v2_1.DescribeTagsCommand(input)), + // Pagination Functions + paginateDescribeListeners: async (input) => { + const listeners = Array(); + const paginator = (0, client_elastic_load_balancing_v2_1.paginateDescribeListeners)({ client }, input); + for await (const page of paginator) { + listeners.push(...(page?.Listeners || [])); + } + return listeners; + }, + paginateDescribeLoadBalancers: async (input) => { + const loadBalancers = Array(); + const paginator = (0, client_elastic_load_balancing_v2_1.paginateDescribeLoadBalancers)({ client }, input); + for await (const page of paginator) { + loadBalancers.push(...(page?.LoadBalancers || [])); + } + return loadBalancers; + }, + }; + } + iam() { + const client = new client_iam_1.IAMClient(this.config); + return { + createPolicy: (input) => client.send(new client_iam_1.CreatePolicyCommand(input)), + getPolicy: (input) => client.send(new client_iam_1.GetPolicyCommand(input)), + getRole: (input) => client.send(new client_iam_1.GetRoleCommand(input)), + }; + } + kms() { + const client = new client_kms_1.KMSClient(this.config); + return { + describeKey: (input) => client.send(new client_kms_1.DescribeKeyCommand(input)), + listAliases: (input) => client.send(new client_kms_1.ListAliasesCommand(input)), + }; + } + lambda() { + const client = new client_lambda_1.LambdaClient(this.config); + return { + invokeCommand: (input) => client.send(new client_lambda_1.InvokeCommand(input)), + publishVersion: (input) => client.send(new client_lambda_1.PublishVersionCommand(input)), + updateAlias: (input) => client.send(new client_lambda_1.UpdateAliasCommand(input)), + updateFunctionCode: (input) => client.send(new client_lambda_1.UpdateFunctionCodeCommand(input)), + updateFunctionConfiguration: (input) => client.send(new client_lambda_1.UpdateFunctionConfigurationCommand(input)), + // Waiters + waitUntilFunctionUpdated: (delaySeconds, input) => { + return (0, client_lambda_1.waitUntilFunctionUpdatedV2)({ + client, + maxDelay: delaySeconds, + minDelay: delaySeconds, + maxWaitTime: delaySeconds * 60, + }, input); + }, + }; + } + route53() { + const client = new client_route_53_1.Route53Client(this.config); + return { + getHostedZone: (input) => client.send(new client_route_53_1.GetHostedZoneCommand(input)), + listHostedZones: (input) => client.send(new client_route_53_1.ListHostedZonesCommand(input)), + listHostedZonesByName: (input) => client.send(new client_route_53_1.ListHostedZonesByNameCommand(input)), + }; + } + s3() { + const client = new client_s3_1.S3Client(this.config); + return { + deleteObjects: (input) => client.send(new client_s3_1.DeleteObjectsCommand({ + ...input, + ChecksumAlgorithm: 'SHA256', + })), + deleteObjectTagging: (input) => client.send(new client_s3_1.DeleteObjectTaggingCommand(input)), + getBucketEncryption: (input) => client.send(new client_s3_1.GetBucketEncryptionCommand(input)), + getBucketLocation: (input) => client.send(new client_s3_1.GetBucketLocationCommand(input)), + getObject: (input) => client.send(new client_s3_1.GetObjectCommand(input)), + getObjectTagging: (input) => client.send(new client_s3_1.GetObjectTaggingCommand(input)), + listObjectsV2: (input) => client.send(new client_s3_1.ListObjectsV2Command(input)), + putObjectTagging: (input) => client.send(new client_s3_1.PutObjectTaggingCommand({ + ...input, + ChecksumAlgorithm: 'SHA256', + })), + upload: (input) => { + try { + const upload = new lib_storage_1.Upload({ + client, + params: { ...input, ChecksumAlgorithm: 'SHA256' }, + }); + return upload.done(); + } + catch (e) { + throw new toolkit_error_1.AuthenticationError(`Upload failed: ${(0, util_1.formatErrorMessage)(e)}`); + } + }, + }; + } + secretsManager() { + const client = new client_secrets_manager_1.SecretsManagerClient(this.config); + return { + getSecretValue: (input) => client.send(new client_secrets_manager_1.GetSecretValueCommand(input)), + }; + } + ssm() { + const client = new client_ssm_1.SSMClient(this.config); + return { + getParameter: (input) => client.send(new client_ssm_1.GetParameterCommand(input)), + }; + } + stepFunctions() { + const client = new client_sfn_1.SFNClient(this.config); + return { + updateStateMachine: (input) => client.send(new client_sfn_1.UpdateStateMachineCommand(input)), + }; + } + /** + * The AWS SDK v3 requires a client config and a command in order to get an endpoint for + * any given service. + */ + async getUrlSuffix(region) { + const cfn = new client_cloudformation_1.CloudFormationClient({ region }); + const endpoint = await (0, middleware_endpoint_1.getEndpointFromInstructions)({}, client_cloudformation_1.DescribeStackResourcesCommand, { ...cfn.config }); + return endpoint.url.hostname.split(`${region}.`).pop(); + } + async currentAccount() { + return (0, cached_1.cachedAsync)(this, CURRENT_ACCOUNT_KEY, async () => { + const creds = await this.credProvider(); + return this.accountCache.fetch(creds.accessKeyId, async () => { + // if we don't have one, resolve from STS and store in cache. + await this.debug('Looking up default account ID from STS'); + const client = new client_sts_1.STSClient({ + ...this.config, + retryStrategy: this.stsRetryStrategy, + }); + const command = new client_sts_1.GetCallerIdentityCommand({}); + const result = await client.send(command); + const accountId = result.Account; + const partition = result.Arn.split(':')[1]; + if (!accountId) { + throw new toolkit_error_1.AuthenticationError("STS didn't return an account ID"); + } + await this.debug(`Default account ID: ${accountId}`); + // Save another STS call later if this one already succeeded + this._credentialsValidated = true; + return { accountId, partition }; + }); + }); + } + /** + * Make sure the the current credentials are not expired + */ + async validateCredentials() { + if (this._credentialsValidated) { + return; + } + const client = new client_sts_1.STSClient({ ...this.config, retryStrategy: this.stsRetryStrategy }); + await client.send(new client_sts_1.GetCallerIdentityCommand({})); + this._credentialsValidated = true; + } +}; +exports.SDK = SDK; +exports.SDK = SDK = __decorate([ + tracing_1.traceMemberMethods +], SDK); +const CURRENT_ACCOUNT_KEY = Symbol('current_account_key'); +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sdk.js","sourceRoot":"","sources":["../../../src/api/aws-auth/sdk.ts"],"names":[],"mappings":"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","sourcesContent":["import type {\n  FunctionConfiguration,\n  GetSchemaCreationStatusCommandInput,\n  GetSchemaCreationStatusCommandOutput,\n  ListFunctionsCommandInput,\n  StartSchemaCreationCommandInput,\n  StartSchemaCreationCommandOutput,\n  UpdateApiKeyCommandInput,\n  UpdateApiKeyCommandOutput,\n  UpdateFunctionCommandInput,\n  UpdateFunctionCommandOutput,\n  UpdateResolverCommandInput,\n  UpdateResolverCommandOutput,\n} from '@aws-sdk/client-appsync';\nimport {\n  AppSyncClient,\n  GetSchemaCreationStatusCommand,\n  paginateListFunctions,\n  StartSchemaCreationCommand,\n  UpdateApiKeyCommand,\n  UpdateFunctionCommand,\n  UpdateResolverCommand,\n} from '@aws-sdk/client-appsync';\nimport type {\n  GetResourceCommandInput,\n  GetResourceCommandOutput,\n  ListResourcesCommandInput,\n  ListResourcesCommandOutput,\n} from '@aws-sdk/client-cloudcontrol';\nimport {\n  CloudControlClient,\n  GetResourceCommand,\n  ListResourcesCommand,\n} from '@aws-sdk/client-cloudcontrol';\nimport type {\n  ContinueUpdateRollbackCommandInput,\n  ContinueUpdateRollbackCommandOutput,\n  DescribeStackEventsCommandOutput,\n  DescribeStackResourcesCommandInput,\n  DescribeStackResourcesCommandOutput,\n  ListStacksCommandInput,\n  ListStacksCommandOutput,\n  RollbackStackCommandInput,\n  RollbackStackCommandOutput,\n  StackResourceSummary,\n  CreateChangeSetCommandInput,\n  CreateChangeSetCommandOutput,\n  CreateGeneratedTemplateCommandInput,\n  CreateGeneratedTemplateCommandOutput,\n  CreateStackCommandInput,\n  CreateStackCommandOutput,\n  DeleteChangeSetCommandInput,\n  DeleteChangeSetCommandOutput,\n  DeleteGeneratedTemplateCommandInput,\n  DeleteGeneratedTemplateCommandOutput,\n  DeleteStackCommandInput,\n  DeleteStackCommandOutput,\n  DescribeChangeSetCommandInput,\n  DescribeChangeSetCommandOutput,\n  DescribeGeneratedTemplateCommandInput,\n  DescribeGeneratedTemplateCommandOutput,\n  DescribeResourceScanCommandInput,\n  DescribeResourceScanCommandOutput,\n  DescribeStackEventsCommandInput,\n  DescribeStacksCommandInput,\n  DescribeStacksCommandOutput,\n  ExecuteChangeSetCommandInput,\n  ExecuteChangeSetCommandOutput,\n  GetGeneratedTemplateCommandInput,\n  GetGeneratedTemplateCommandOutput,\n  GetTemplateCommandInput,\n  GetTemplateCommandOutput,\n  GetTemplateSummaryCommandInput,\n  GetTemplateSummaryCommandOutput,\n  ListExportsCommandInput,\n  ListExportsCommandOutput,\n  ListResourceScanRelatedResourcesCommandInput,\n  ListResourceScanRelatedResourcesCommandOutput,\n  ListResourceScanResourcesCommandInput,\n  ListResourceScanResourcesCommandOutput,\n  ListResourceScansCommandInput,\n  ListResourceScansCommandOutput,\n  ListStackResourcesCommandInput,\n  StartResourceScanCommandInput,\n  StartResourceScanCommandOutput,\n  UpdateStackCommandInput,\n  UpdateStackCommandOutput,\n  UpdateTerminationProtectionCommandInput,\n  UpdateTerminationProtectionCommandOutput,\n  StackSummary,\n  DescribeStackDriftDetectionStatusCommandInput,\n  DescribeStackDriftDetectionStatusCommandOutput,\n  DescribeStackResourceDriftsCommandOutput,\n  DetectStackDriftCommandInput,\n  DetectStackDriftCommandOutput,\n  DetectStackResourceDriftCommandInput,\n  DetectStackResourceDriftCommandOutput,\n  DescribeStackResourceDriftsCommandInput,\n} from '@aws-sdk/client-cloudformation';\nimport {\n  paginateListStacks,\n  CloudFormationClient,\n  ContinueUpdateRollbackCommand,\n  CreateChangeSetCommand,\n  CreateGeneratedTemplateCommand,\n  CreateStackCommand,\n  DeleteChangeSetCommand,\n  DeleteGeneratedTemplateCommand,\n  DeleteStackCommand,\n  DescribeChangeSetCommand,\n  DescribeGeneratedTemplateCommand,\n  DescribeResourceScanCommand,\n  DescribeStackEventsCommand,\n  DescribeStackResourcesCommand,\n  DescribeStacksCommand,\n  ExecuteChangeSetCommand,\n  GetGeneratedTemplateCommand,\n  GetTemplateCommand,\n  GetTemplateSummaryCommand,\n  ListExportsCommand,\n  ListResourceScanRelatedResourcesCommand,\n  ListResourceScanResourcesCommand,\n  ListResourceScansCommand,\n  ListStacksCommand,\n  paginateListStackResources,\n  RollbackStackCommand,\n  StartResourceScanCommand,\n  UpdateStackCommand,\n  UpdateTerminationProtectionCommand,\n  DescribeStackDriftDetectionStatusCommand,\n  DescribeStackResourceDriftsCommand,\n  DetectStackDriftCommand,\n  DetectStackResourceDriftCommand,\n} from '@aws-sdk/client-cloudformation';\nimport type {\n  FilterLogEventsCommandInput,\n  FilterLogEventsCommandOutput,\n  DescribeLogGroupsCommandInput,\n  DescribeLogGroupsCommandOutput,\n} from '@aws-sdk/client-cloudwatch-logs';\nimport {\n  CloudWatchLogsClient,\n  DescribeLogGroupsCommand,\n  FilterLogEventsCommand,\n} from '@aws-sdk/client-cloudwatch-logs';\nimport {\n  CodeBuildClient,\n  UpdateProjectCommand,\n  type UpdateProjectCommandInput,\n  type UpdateProjectCommandOutput,\n} from '@aws-sdk/client-codebuild';\nimport {\n  DescribeAvailabilityZonesCommand,\n  type DescribeAvailabilityZonesCommandInput,\n  type DescribeAvailabilityZonesCommandOutput,\n  DescribeImagesCommand,\n  type DescribeImagesCommandInput,\n  type DescribeImagesCommandOutput,\n  DescribeInstancesCommand,\n  type DescribeInstancesCommandInput,\n  type DescribeInstancesCommandOutput,\n  DescribeRouteTablesCommand,\n  type DescribeRouteTablesCommandInput,\n  type DescribeRouteTablesCommandOutput,\n  DescribeSecurityGroupsCommand,\n  type DescribeSecurityGroupsCommandInput,\n  type DescribeSecurityGroupsCommandOutput,\n  DescribeSubnetsCommand,\n  type DescribeSubnetsCommandInput,\n  type DescribeSubnetsCommandOutput,\n  DescribeVpcEndpointServicesCommand,\n  type DescribeVpcEndpointServicesCommandInput,\n  type DescribeVpcEndpointServicesCommandOutput,\n  DescribeVpcsCommand,\n  type DescribeVpcsCommandInput,\n  type DescribeVpcsCommandOutput,\n  DescribeVpnGatewaysCommand,\n  type DescribeVpnGatewaysCommandInput,\n  type DescribeVpnGatewaysCommandOutput,\n  EC2Client,\n} from '@aws-sdk/client-ec2';\nimport type {\n  BatchDeleteImageCommandInput,\n  BatchDeleteImageCommandOutput,\n  ListImagesCommandInput,\n  ListImagesCommandOutput,\n  PutImageCommandInput,\n  PutImageCommandOutput,\n  BatchGetImageCommandInput,\n  BatchGetImageCommandOutput,\n  CreateRepositoryCommandInput,\n  CreateRepositoryCommandOutput,\n  DescribeImagesCommandInput as ECRDescribeImagesCommandInput,\n  DescribeImagesCommandOutput as ECRDescribeImagesCommandOutput,\n  DescribeRepositoriesCommandInput,\n  DescribeRepositoriesCommandOutput,\n  GetAuthorizationTokenCommandInput,\n  GetAuthorizationTokenCommandOutput,\n  PutImageScanningConfigurationCommandInput,\n  PutImageScanningConfigurationCommandOutput,\n} from '@aws-sdk/client-ecr';\nimport {\n  BatchDeleteImageCommand,\n  CreateRepositoryCommand,\n  DescribeImagesCommand as ECRDescribeImagesCommand,\n  DescribeRepositoriesCommand,\n  ECRClient,\n  GetAuthorizationTokenCommand,\n  ListImagesCommand,\n  PutImageCommand,\n  PutImageScanningConfigurationCommand,\n  BatchGetImageCommand,\n} from '@aws-sdk/client-ecr';\nimport type {\n  DescribeServicesCommandInput,\n  RegisterTaskDefinitionCommandInput,\n  ListClustersCommandInput,\n  ListClustersCommandOutput,\n  RegisterTaskDefinitionCommandOutput,\n  UpdateServiceCommandInput,\n  UpdateServiceCommandOutput,\n} from '@aws-sdk/client-ecs';\nimport {\n  ECSClient,\n  ListClustersCommand,\n  RegisterTaskDefinitionCommand,\n  UpdateServiceCommand,\n  waitUntilServicesStable,\n} from '@aws-sdk/client-ecs';\nimport type {\n  Listener,\n  LoadBalancer,\n  DescribeListenersCommandInput,\n  DescribeListenersCommandOutput,\n  DescribeLoadBalancersCommandInput,\n  DescribeLoadBalancersCommandOutput,\n  DescribeTagsCommandInput,\n  DescribeTagsCommandOutput,\n} from '@aws-sdk/client-elastic-load-balancing-v2';\nimport {\n  DescribeListenersCommand,\n  DescribeLoadBalancersCommand,\n  DescribeTagsCommand,\n  ElasticLoadBalancingV2Client,\n  paginateDescribeListeners,\n  paginateDescribeLoadBalancers,\n} from '@aws-sdk/client-elastic-load-balancing-v2';\nimport {\n  CreatePolicyCommand,\n  type CreatePolicyCommandInput,\n  type CreatePolicyCommandOutput,\n  GetPolicyCommand,\n  type GetPolicyCommandInput,\n  type GetPolicyCommandOutput,\n  GetRoleCommand,\n  type GetRoleCommandInput,\n  type GetRoleCommandOutput,\n  IAMClient,\n} from '@aws-sdk/client-iam';\nimport {\n  DescribeKeyCommand,\n  type DescribeKeyCommandInput,\n  type DescribeKeyCommandOutput,\n  KMSClient,\n  ListAliasesCommand,\n  type ListAliasesCommandInput,\n  type ListAliasesCommandOutput,\n} from '@aws-sdk/client-kms';\nimport {\n  InvokeCommand,\n  type InvokeCommandInput,\n  type InvokeCommandOutput,\n  LambdaClient,\n  PublishVersionCommand,\n  type PublishVersionCommandInput,\n  type PublishVersionCommandOutput,\n  UpdateAliasCommand,\n  type UpdateAliasCommandInput,\n  type UpdateAliasCommandOutput,\n  UpdateFunctionCodeCommand,\n  type UpdateFunctionCodeCommandInput,\n  type UpdateFunctionCodeCommandOutput,\n  UpdateFunctionConfigurationCommand,\n  type UpdateFunctionConfigurationCommandInput,\n  type UpdateFunctionConfigurationCommandOutput,\n  waitUntilFunctionUpdatedV2,\n} from '@aws-sdk/client-lambda';\nimport {\n  GetHostedZoneCommand,\n  type GetHostedZoneCommandInput,\n  type GetHostedZoneCommandOutput,\n  ListHostedZonesByNameCommand,\n  type ListHostedZonesByNameCommandInput,\n  type ListHostedZonesByNameCommandOutput,\n  ListHostedZonesCommand,\n  type ListHostedZonesCommandInput,\n  type ListHostedZonesCommandOutput,\n  Route53Client,\n} from '@aws-sdk/client-route-53';\nimport type {\n  DeleteObjectsCommandInput,\n  DeleteObjectsCommandOutput,\n  DeleteObjectTaggingCommandInput,\n  DeleteObjectTaggingCommandOutput,\n  GetObjectTaggingCommandInput,\n  GetObjectTaggingCommandOutput,\n  PutObjectTaggingCommandInput,\n  PutObjectTaggingCommandOutput,\n  CompleteMultipartUploadCommandOutput,\n  GetBucketEncryptionCommandInput,\n  GetBucketEncryptionCommandOutput,\n  GetBucketLocationCommandInput,\n  GetBucketLocationCommandOutput,\n  GetObjectCommandInput,\n  GetObjectCommandOutput,\n  ListObjectsV2CommandInput,\n  ListObjectsV2CommandOutput,\n  PutObjectCommandInput,\n} from '@aws-sdk/client-s3';\nimport {\n  DeleteObjectsCommand,\n  DeleteObjectTaggingCommand,\n  GetBucketEncryptionCommand,\n  GetBucketLocationCommand,\n  GetObjectCommand,\n  GetObjectTaggingCommand,\n  ListObjectsV2Command,\n  PutObjectTaggingCommand,\n  S3Client,\n} from '@aws-sdk/client-s3';\nimport {\n  GetSecretValueCommand,\n  type GetSecretValueCommandInput,\n  type GetSecretValueCommandOutput,\n  SecretsManagerClient,\n} from '@aws-sdk/client-secrets-manager';\nimport type {\n  UpdateStateMachineCommandInput,\n  UpdateStateMachineCommandOutput,\n} from '@aws-sdk/client-sfn';\nimport {\n  SFNClient,\n  UpdateStateMachineCommand,\n} from '@aws-sdk/client-sfn';\nimport {\n  GetParameterCommand,\n  type GetParameterCommandInput,\n  type GetParameterCommandOutput,\n  SSMClient,\n} from '@aws-sdk/client-ssm';\nimport { GetCallerIdentityCommand, STSClient } from '@aws-sdk/client-sts';\nimport { Upload } from '@aws-sdk/lib-storage';\nimport { getEndpointFromInstructions } from '@smithy/middleware-endpoint';\nimport type { NodeHttpHandlerOptions } from '@smithy/node-http-handler';\nimport type { AwsCredentialIdentityProvider, Logger } from '@smithy/types';\nimport { ConfiguredRetryStrategy } from '@smithy/util-retry';\nimport type { WaiterResult } from '@smithy/util-waiter';\nimport { AccountAccessKeyCache } from './account-cache';\nimport { cachedAsync } from './cached';\nimport type { Account } from './sdk-provider';\nimport { traceMemberMethods } from './tracing';\nimport { defaultCliUserAgent } from './user-agent';\nimport { formatErrorMessage } from '../../util';\nimport { IO, type IoHelper } from '../io/private';\nimport { AuthenticationError } from '../toolkit-error';\n\nexport interface S3ClientOptions {\n  /**\n   * If APIs are used that require MD5 checksums.\n   *\n   * Some S3 APIs in SDKv2 have a bug that always requires them to use a MD5 checksum.\n   * These APIs are not going to be supported in a FIPS environment.\n   */\n  needsMd5Checksums?: boolean;\n}\n\n/**\n * Additional SDK configuration options\n */\nexport interface SdkOptions {\n  /**\n   * Additional descriptive strings that indicate where the \"AssumeRole\" credentials are coming from\n   *\n   * Will be printed in an error message to help users diagnose auth problems.\n   */\n  readonly assumeRoleCredentialsSourceDescription?: string;\n}\n\n// TODO: still some cleanup here. Make the pagination functions do all the work here instead of in individual packages.\n// Also add async/await. Does that actually matter in this context? Find out and update accordingly.\n\n// Also add notes to the PR about why you imported everything individually and used 'type' so reviewers don't have to ask.\n\nexport interface ConfigurationOptions {\n  region: string;\n  credentials: AwsCredentialIdentityProvider;\n  requestHandler: NodeHttpHandlerOptions;\n  retryStrategy: ConfiguredRetryStrategy;\n  customUserAgent: string;\n  logger?: Logger;\n  s3DisableBodySigning?: boolean;\n  computeChecksums?: boolean;\n}\n\nexport interface IAppSyncClient {\n  getSchemaCreationStatus(input: GetSchemaCreationStatusCommandInput): Promise<GetSchemaCreationStatusCommandOutput>;\n  startSchemaCreation(input: StartSchemaCreationCommandInput): Promise<StartSchemaCreationCommandOutput>;\n  updateApiKey(input: UpdateApiKeyCommandInput): Promise<UpdateApiKeyCommandOutput>;\n  updateFunction(input: UpdateFunctionCommandInput): Promise<UpdateFunctionCommandOutput>;\n  updateResolver(input: UpdateResolverCommandInput): Promise<UpdateResolverCommandOutput>;\n  // Pagination functions\n  listFunctions(input: ListFunctionsCommandInput): Promise<FunctionConfiguration[]>;\n}\n\nexport interface ICloudControlClient{\n  listResources(input: ListResourcesCommandInput): Promise<ListResourcesCommandOutput>;\n  getResource(input: GetResourceCommandInput): Promise<GetResourceCommandOutput>;\n}\n\nexport interface ICloudFormationClient {\n  continueUpdateRollback(input: ContinueUpdateRollbackCommandInput): Promise<ContinueUpdateRollbackCommandOutput>;\n  createChangeSet(input: CreateChangeSetCommandInput): Promise<CreateChangeSetCommandOutput>;\n  createGeneratedTemplate(input: CreateGeneratedTemplateCommandInput): Promise<CreateGeneratedTemplateCommandOutput>;\n  createStack(input: CreateStackCommandInput): Promise<CreateStackCommandOutput>;\n  deleteChangeSet(input: DeleteChangeSetCommandInput): Promise<DeleteChangeSetCommandOutput>;\n  deleteGeneratedTemplate(input: DeleteGeneratedTemplateCommandInput): Promise<DeleteGeneratedTemplateCommandOutput>;\n  deleteStack(input: DeleteStackCommandInput): Promise<DeleteStackCommandOutput>;\n  describeChangeSet(input: DescribeChangeSetCommandInput): Promise<DescribeChangeSetCommandOutput>;\n  describeGeneratedTemplate(\n    input: DescribeGeneratedTemplateCommandInput,\n  ): Promise<DescribeGeneratedTemplateCommandOutput>;\n  describeResourceScan(input: DescribeResourceScanCommandInput): Promise<DescribeResourceScanCommandOutput>;\n  describeStackDriftDetectionStatus(input: DescribeStackDriftDetectionStatusCommandInput): Promise<DescribeStackDriftDetectionStatusCommandOutput>;\n  describeStacks(input: DescribeStacksCommandInput): Promise<DescribeStacksCommandOutput>;\n  describeStackResourceDrifts(input: DescribeStackResourceDriftsCommandInput): Promise<DescribeStackResourceDriftsCommandOutput>;\n  describeStackResources(input: DescribeStackResourcesCommandInput): Promise<DescribeStackResourcesCommandOutput>;\n  detectStackDrift(input: DetectStackDriftCommandInput): Promise<DetectStackDriftCommandOutput>;\n  detectStackResourceDrift(input: DetectStackResourceDriftCommandInput): Promise<DetectStackResourceDriftCommandOutput>;\n  executeChangeSet(input: ExecuteChangeSetCommandInput): Promise<ExecuteChangeSetCommandOutput>;\n  getGeneratedTemplate(input: GetGeneratedTemplateCommandInput): Promise<GetGeneratedTemplateCommandOutput>;\n  getTemplate(input: GetTemplateCommandInput): Promise<GetTemplateCommandOutput>;\n  getTemplateSummary(input: GetTemplateSummaryCommandInput): Promise<GetTemplateSummaryCommandOutput>;\n  listExports(input: ListExportsCommandInput): Promise<ListExportsCommandOutput>;\n  listResourceScanRelatedResources(\n    input: ListResourceScanRelatedResourcesCommandInput,\n  ): Promise<ListResourceScanRelatedResourcesCommandOutput>;\n  listResourceScanResources(\n    input: ListResourceScanResourcesCommandInput,\n  ): Promise<ListResourceScanResourcesCommandOutput>;\n  listResourceScans(input?: ListResourceScansCommandInput): Promise<ListResourceScansCommandOutput>;\n  listStacks(input: ListStacksCommandInput): Promise<ListStacksCommandOutput>;\n  rollbackStack(input: RollbackStackCommandInput): Promise<RollbackStackCommandOutput>;\n  startResourceScan(input: StartResourceScanCommandInput): Promise<StartResourceScanCommandOutput>;\n  updateStack(input: UpdateStackCommandInput): Promise<UpdateStackCommandOutput>;\n  updateTerminationProtection(\n    input: UpdateTerminationProtectionCommandInput,\n  ): Promise<UpdateTerminationProtectionCommandOutput>;\n  // Pagination functions\n  describeStackEvents(input: DescribeStackEventsCommandInput): Promise<DescribeStackEventsCommandOutput>;\n  listStackResources(input: ListStackResourcesCommandInput): Promise<StackResourceSummary[]>;\n  paginatedListStacks(input: ListStacksCommandInput): Promise<StackSummary[]>;\n}\n\nexport interface ICloudWatchLogsClient {\n  describeLogGroups(input: DescribeLogGroupsCommandInput): Promise<DescribeLogGroupsCommandOutput>;\n  filterLogEvents(input: FilterLogEventsCommandInput): Promise<FilterLogEventsCommandOutput>;\n}\n\nexport interface ICodeBuildClient {\n  updateProject(input: UpdateProjectCommandInput): Promise<UpdateProjectCommandOutput>;\n}\nexport interface IEC2Client {\n  describeAvailabilityZones(\n    input: DescribeAvailabilityZonesCommandInput,\n  ): Promise<DescribeAvailabilityZonesCommandOutput>;\n  describeImages(input: DescribeImagesCommandInput): Promise<DescribeImagesCommandOutput>;\n  describeInstances(input: DescribeInstancesCommandInput): Promise<DescribeInstancesCommandOutput>;\n  describeRouteTables(input: DescribeRouteTablesCommandInput): Promise<DescribeRouteTablesCommandOutput>;\n  describeSecurityGroups(input: DescribeSecurityGroupsCommandInput): Promise<DescribeSecurityGroupsCommandOutput>;\n  describeSubnets(input: DescribeSubnetsCommandInput): Promise<DescribeSubnetsCommandOutput>;\n  describeVpcEndpointServices(\n    input: DescribeVpcEndpointServicesCommandInput,\n  ): Promise<DescribeVpcEndpointServicesCommandOutput>;\n  describeVpcs(input: DescribeVpcsCommandInput): Promise<DescribeVpcsCommandOutput>;\n  describeVpnGateways(input: DescribeVpnGatewaysCommandInput): Promise<DescribeVpnGatewaysCommandOutput>;\n}\n\nexport interface IECRClient {\n  batchDeleteImage(input: BatchDeleteImageCommandInput): Promise<BatchDeleteImageCommandOutput>;\n  batchGetImage(input: BatchGetImageCommandInput): Promise<BatchGetImageCommandOutput>;\n  createRepository(input: CreateRepositoryCommandInput): Promise<CreateRepositoryCommandOutput>;\n  describeImages(input: ECRDescribeImagesCommandInput): Promise<ECRDescribeImagesCommandOutput>;\n  describeRepositories(input: DescribeRepositoriesCommandInput): Promise<DescribeRepositoriesCommandOutput>;\n  getAuthorizationToken(input: GetAuthorizationTokenCommandInput): Promise<GetAuthorizationTokenCommandOutput>;\n  listImages(input: ListImagesCommandInput): Promise<ListImagesCommandOutput>;\n  putImage(input: PutImageCommandInput): Promise<PutImageCommandOutput>;\n  putImageScanningConfiguration(\n    input: PutImageScanningConfigurationCommandInput,\n  ): Promise<PutImageScanningConfigurationCommandOutput>;\n}\n\nexport interface IECSClient {\n  listClusters(input: ListClustersCommandInput): Promise<ListClustersCommandOutput>;\n  registerTaskDefinition(input: RegisterTaskDefinitionCommandInput): Promise<RegisterTaskDefinitionCommandOutput>;\n  updateService(input: UpdateServiceCommandInput): Promise<UpdateServiceCommandOutput>;\n  // Waiters\n  waitUntilServicesStable(input: DescribeServicesCommandInput): Promise<WaiterResult>;\n}\n\nexport interface IElasticLoadBalancingV2Client {\n  describeListeners(input: DescribeListenersCommandInput): Promise<DescribeListenersCommandOutput>;\n  describeLoadBalancers(input: DescribeLoadBalancersCommandInput): Promise<DescribeLoadBalancersCommandOutput>;\n  describeTags(input: DescribeTagsCommandInput): Promise<DescribeTagsCommandOutput>;\n  // Pagination\n  paginateDescribeListeners(input: DescribeListenersCommandInput): Promise<Listener[]>;\n  paginateDescribeLoadBalancers(input: DescribeLoadBalancersCommandInput): Promise<LoadBalancer[]>;\n}\n\nexport interface IIAMClient {\n  createPolicy(input: CreatePolicyCommandInput): Promise<CreatePolicyCommandOutput>;\n  getPolicy(input: GetPolicyCommandInput): Promise<GetPolicyCommandOutput>;\n  getRole(input: GetRoleCommandInput): Promise<GetRoleCommandOutput>;\n}\n\nexport interface IKMSClient {\n  describeKey(input: DescribeKeyCommandInput): Promise<DescribeKeyCommandOutput>;\n  listAliases(input: ListAliasesCommandInput): Promise<ListAliasesCommandOutput>;\n}\n\nexport interface ILambdaClient {\n  invokeCommand(input: InvokeCommandInput): Promise<InvokeCommandOutput>;\n  publishVersion(input: PublishVersionCommandInput): Promise<PublishVersionCommandOutput>;\n  updateAlias(input: UpdateAliasCommandInput): Promise<UpdateAliasCommandOutput>;\n  updateFunctionCode(input: UpdateFunctionCodeCommandInput): Promise<UpdateFunctionCodeCommandOutput>;\n  updateFunctionConfiguration(\n    input: UpdateFunctionConfigurationCommandInput,\n  ): Promise<UpdateFunctionConfigurationCommandOutput>;\n  // Waiters\n  waitUntilFunctionUpdated(delaySeconds: number, input: UpdateFunctionConfigurationCommandInput): Promise<WaiterResult>;\n}\n\nexport interface IRoute53Client {\n  getHostedZone(input: GetHostedZoneCommandInput): Promise<GetHostedZoneCommandOutput>;\n  listHostedZones(input: ListHostedZonesCommandInput): Promise<ListHostedZonesCommandOutput>;\n  listHostedZonesByName(input: ListHostedZonesByNameCommandInput): Promise<ListHostedZonesByNameCommandOutput>;\n}\n\nexport interface IS3Client {\n  deleteObjects(input: DeleteObjectsCommandInput): Promise<DeleteObjectsCommandOutput>;\n  deleteObjectTagging(input: DeleteObjectTaggingCommandInput): Promise<DeleteObjectTaggingCommandOutput>;\n  getBucketEncryption(input: GetBucketEncryptionCommandInput): Promise<GetBucketEncryptionCommandOutput>;\n  getBucketLocation(input: GetBucketLocationCommandInput): Promise<GetBucketLocationCommandOutput>;\n  getObject(input: GetObjectCommandInput): Promise<GetObjectCommandOutput>;\n  getObjectTagging(input: GetObjectTaggingCommandInput): Promise<GetObjectTaggingCommandOutput>;\n  listObjectsV2(input: ListObjectsV2CommandInput): Promise<ListObjectsV2CommandOutput>;\n  putObjectTagging(input: PutObjectTaggingCommandInput): Promise<PutObjectTaggingCommandOutput>;\n  upload(input: PutObjectCommandInput): Promise<CompleteMultipartUploadCommandOutput>;\n}\n\nexport interface ISecretsManagerClient {\n  getSecretValue(input: GetSecretValueCommandInput): Promise<GetSecretValueCommandOutput>;\n}\n\nexport interface ISSMClient {\n  getParameter(input: GetParameterCommandInput): Promise<GetParameterCommandOutput>;\n}\n\nexport interface IStepFunctionsClient {\n  updateStateMachine(input: UpdateStateMachineCommandInput): Promise<UpdateStateMachineCommandOutput>;\n}\n\n/**\n * Base functionality of SDK without credential fetching\n */\n@traceMemberMethods\nexport class SDK {\n  public readonly currentRegion: string;\n\n  public readonly config: ConfigurationOptions;\n\n  protected readonly logger?: Logger;\n\n  private readonly accountCache;\n\n  /**\n   * STS is used to check credential validity, don't do too many retries.\n   */\n  private readonly stsRetryStrategy = new ConfiguredRetryStrategy(3, (attempt) => 100 * (2 ** attempt));\n\n  /**\n   * Whether we have proof that the credentials have not expired\n   *\n   * We need to do some manual plumbing around this because the JS SDKv2 treats `ExpiredToken`\n   * as retriable and we have hefty retries on CFN calls making the CLI hang for a good 15 minutes\n   * if the credentials have expired.\n   */\n  private _credentialsValidated = false;\n\n  /**\n   * A function to create debug messages\n   */\n  private readonly debug: (msg: string) => Promise<void>;\n\n  constructor(\n    private readonly credProvider: AwsCredentialIdentityProvider,\n    region: string,\n    requestHandler: NodeHttpHandlerOptions,\n    ioHelper: IoHelper,\n    logger?: Logger,\n  ) {\n    const debugFn = async (msg: string) => ioHelper.notify(IO.DEFAULT_SDK_DEBUG.msg(msg));\n    this.accountCache = new AccountAccessKeyCache(AccountAccessKeyCache.DEFAULT_PATH, debugFn);\n    this.debug = debugFn;\n    this.config = {\n      region,\n      credentials: credProvider,\n      requestHandler,\n      retryStrategy: new ConfiguredRetryStrategy(7, (attempt) => 300 * (2 ** attempt)),\n      customUserAgent: defaultCliUserAgent(),\n      logger,\n    };\n    this.logger = logger;\n    this.currentRegion = region;\n  }\n\n  public appendCustomUserAgent(userAgentData?: string): void {\n    if (!userAgentData) {\n      return;\n    }\n\n    const currentCustomUserAgent = this.config.customUserAgent;\n    this.config.customUserAgent = currentCustomUserAgent ? `${currentCustomUserAgent} ${userAgentData}` : userAgentData;\n  }\n\n  public removeCustomUserAgent(userAgentData: string): void {\n    this.config.customUserAgent = this.config.customUserAgent?.replace(userAgentData, '');\n  }\n\n  public appsync(): IAppSyncClient {\n    const client = new AppSyncClient(this.config);\n    return {\n      getSchemaCreationStatus: (\n        input: GetSchemaCreationStatusCommandInput,\n      ): Promise<GetSchemaCreationStatusCommandOutput> => client.send(new GetSchemaCreationStatusCommand(input)),\n      startSchemaCreation: (input: StartSchemaCreationCommandInput): Promise<StartSchemaCreationCommandOutput> =>\n        client.send(new StartSchemaCreationCommand(input)),\n      updateApiKey: (input: UpdateApiKeyCommandInput): Promise<UpdateApiKeyCommandOutput> =>\n        client.send(new UpdateApiKeyCommand(input)),\n      updateFunction: (input: UpdateFunctionCommandInput): Promise<UpdateFunctionCommandOutput> =>\n        client.send(new UpdateFunctionCommand(input)),\n      updateResolver: (input: UpdateResolverCommandInput): Promise<UpdateResolverCommandOutput> =>\n        client.send(new UpdateResolverCommand(input)),\n\n      // Pagination Functions\n      listFunctions: async (input: ListFunctionsCommandInput): Promise<FunctionConfiguration[]> => {\n        const functions = Array<FunctionConfiguration>();\n        const paginator = paginateListFunctions({ client }, input);\n        for await (const page of paginator) {\n          functions.push(...(page.functions || []));\n        }\n        return functions;\n      },\n    };\n  }\n\n  public cloudControl(): ICloudControlClient {\n    const client = new CloudControlClient(this.config);\n    return {\n      listResources: (input: ListResourcesCommandInput): Promise<ListResourcesCommandOutput> =>\n        client.send(new ListResourcesCommand(input)),\n      getResource: (input: GetResourceCommandInput): Promise<GetResourceCommandOutput> =>\n        client.send(new GetResourceCommand(input)),\n    };\n  }\n\n  public cloudFormation(): ICloudFormationClient {\n    const client = new CloudFormationClient({\n      ...this.config,\n      retryStrategy: new ConfiguredRetryStrategy(11, (attempt: number) => 1000 * (2 ** attempt)),\n    });\n    return {\n      continueUpdateRollback: async (\n        input: ContinueUpdateRollbackCommandInput,\n      ): Promise<ContinueUpdateRollbackCommandOutput> => client.send(new ContinueUpdateRollbackCommand(input)),\n      createChangeSet: (input: CreateChangeSetCommandInput): Promise<CreateChangeSetCommandOutput> =>\n        client.send(new CreateChangeSetCommand(input)),\n      createGeneratedTemplate: (\n        input: CreateGeneratedTemplateCommandInput,\n      ): Promise<CreateGeneratedTemplateCommandOutput> => client.send(new CreateGeneratedTemplateCommand(input)),\n      createStack: (input: CreateStackCommandInput): Promise<CreateStackCommandOutput> =>\n        client.send(new CreateStackCommand(input)),\n      deleteChangeSet: (input: DeleteChangeSetCommandInput): Promise<DeleteChangeSetCommandOutput> =>\n        client.send(new DeleteChangeSetCommand(input)),\n      deleteGeneratedTemplate: (\n        input: DeleteGeneratedTemplateCommandInput,\n      ): Promise<DeleteGeneratedTemplateCommandOutput> => client.send(new DeleteGeneratedTemplateCommand(input)),\n      deleteStack: (input: DeleteStackCommandInput): Promise<DeleteStackCommandOutput> =>\n        client.send(new DeleteStackCommand(input)),\n      detectStackDrift: (input: DetectStackDriftCommandInput): Promise<DetectStackDriftCommandOutput> =>\n        client.send(new DetectStackDriftCommand(input)),\n      detectStackResourceDrift: (input: DetectStackResourceDriftCommandInput): Promise<DetectStackResourceDriftCommandOutput> =>\n        client.send(new DetectStackResourceDriftCommand(input)),\n      describeChangeSet: (input: DescribeChangeSetCommandInput): Promise<DescribeChangeSetCommandOutput> =>\n        client.send(new DescribeChangeSetCommand(input)),\n      describeGeneratedTemplate: (\n        input: DescribeGeneratedTemplateCommandInput,\n      ): Promise<DescribeGeneratedTemplateCommandOutput> => client.send(new DescribeGeneratedTemplateCommand(input)),\n      describeResourceScan: (input: DescribeResourceScanCommandInput): Promise<DescribeResourceScanCommandOutput> =>\n        client.send(new DescribeResourceScanCommand(input)),\n      describeStackDriftDetectionStatus: (input: DescribeStackDriftDetectionStatusCommandInput):\n      Promise<DescribeStackDriftDetectionStatusCommandOutput> => client.send(new DescribeStackDriftDetectionStatusCommand(input)),\n      describeStackResourceDrifts: (input: DescribeStackResourceDriftsCommandInput): Promise<DescribeStackResourceDriftsCommandOutput> =>\n        client.send(new DescribeStackResourceDriftsCommand(input)),\n      describeStacks: (input: DescribeStacksCommandInput): Promise<DescribeStacksCommandOutput> =>\n        client.send(new DescribeStacksCommand(input)),\n      describeStackResources: (input: DescribeStackResourcesCommandInput): Promise<DescribeStackResourcesCommandOutput> =>\n        client.send(new DescribeStackResourcesCommand(input)),\n      executeChangeSet: (input: ExecuteChangeSetCommandInput): Promise<ExecuteChangeSetCommandOutput> =>\n        client.send(new ExecuteChangeSetCommand(input)),\n      getGeneratedTemplate: (input: GetGeneratedTemplateCommandInput): Promise<GetGeneratedTemplateCommandOutput> =>\n        client.send(new GetGeneratedTemplateCommand(input)),\n      getTemplate: (input: GetTemplateCommandInput): Promise<GetTemplateCommandOutput> =>\n        client.send(new GetTemplateCommand(input)),\n      getTemplateSummary: (input: GetTemplateSummaryCommandInput): Promise<GetTemplateSummaryCommandOutput> =>\n        client.send(new GetTemplateSummaryCommand(input)),\n      listExports: (input: ListExportsCommandInput): Promise<ListExportsCommandOutput> =>\n        client.send(new ListExportsCommand(input)),\n      listResourceScanRelatedResources: (\n        input: ListResourceScanRelatedResourcesCommandInput,\n      ): Promise<ListResourceScanRelatedResourcesCommandOutput> =>\n        client.send(new ListResourceScanRelatedResourcesCommand(input)),\n      listResourceScanResources: (\n        input: ListResourceScanResourcesCommandInput,\n      ): Promise<ListResourceScanResourcesCommandOutput> => client.send(new ListResourceScanResourcesCommand(input)),\n      listResourceScans: (input: ListResourceScansCommandInput): Promise<ListResourceScansCommandOutput> =>\n        client.send(new ListResourceScansCommand(input)),\n      listStacks: (input: ListStacksCommandInput): Promise<ListStacksCommandOutput> =>\n        client.send(new ListStacksCommand(input)),\n      rollbackStack: (input: RollbackStackCommandInput): Promise<RollbackStackCommandOutput> =>\n        client.send(new RollbackStackCommand(input)),\n      startResourceScan: (input: StartResourceScanCommandInput): Promise<StartResourceScanCommandOutput> =>\n        client.send(new StartResourceScanCommand(input)),\n      updateStack: (input: UpdateStackCommandInput): Promise<UpdateStackCommandOutput> =>\n        client.send(new UpdateStackCommand(input)),\n      updateTerminationProtection: (\n        input: UpdateTerminationProtectionCommandInput,\n      ): Promise<UpdateTerminationProtectionCommandOutput> =>\n        client.send(new UpdateTerminationProtectionCommand(input)),\n      describeStackEvents: (input: DescribeStackEventsCommandInput): Promise<DescribeStackEventsCommandOutput> => {\n        return client.send(new DescribeStackEventsCommand(input));\n      },\n      listStackResources: async (input: ListStackResourcesCommandInput): Promise<StackResourceSummary[]> => {\n        const stackResources = Array<StackResourceSummary>();\n        const paginator = paginateListStackResources({ client }, input);\n        for await (const page of paginator) {\n          stackResources.push(...(page?.StackResourceSummaries || []));\n        }\n        return stackResources;\n      },\n      paginatedListStacks: async (input: ListStacksCommandInput): Promise<StackSummary[]> => {\n        const stackResources = Array<StackSummary>();\n        const paginator = paginateListStacks({ client }, input);\n        for await (const page of paginator) {\n          stackResources.push(...(page?.StackSummaries || []));\n        }\n        return stackResources;\n      },\n    };\n  }\n\n  public cloudWatchLogs(): ICloudWatchLogsClient {\n    const client = new CloudWatchLogsClient(this.config);\n    return {\n      describeLogGroups: (input: DescribeLogGroupsCommandInput): Promise<DescribeLogGroupsCommandOutput> =>\n        client.send(new DescribeLogGroupsCommand(input)),\n      filterLogEvents: (input: FilterLogEventsCommandInput): Promise<FilterLogEventsCommandOutput> =>\n        client.send(new FilterLogEventsCommand(input)),\n    };\n  }\n\n  public codeBuild(): ICodeBuildClient {\n    const client = new CodeBuildClient(this.config);\n    return {\n      updateProject: (input: UpdateProjectCommandInput): Promise<UpdateProjectCommandOutput> =>\n        client.send(new UpdateProjectCommand(input)),\n    };\n  }\n\n  public ec2(): IEC2Client {\n    const client = new EC2Client(this.config);\n    return {\n      describeAvailabilityZones: (\n        input: DescribeAvailabilityZonesCommandInput,\n      ): Promise<DescribeAvailabilityZonesCommandOutput> => client.send(new DescribeAvailabilityZonesCommand(input)),\n      describeImages: (input: DescribeImagesCommandInput): Promise<DescribeImagesCommandOutput> =>\n        client.send(new DescribeImagesCommand(input)),\n      describeInstances: (input: DescribeInstancesCommandInput): Promise<DescribeInstancesCommandOutput> =>\n        client.send(new DescribeInstancesCommand(input)),\n      describeRouteTables: (input: DescribeRouteTablesCommandInput): Promise<DescribeRouteTablesCommandOutput> =>\n        client.send(new DescribeRouteTablesCommand(input)),\n      describeSecurityGroups: (\n        input: DescribeSecurityGroupsCommandInput,\n      ): Promise<DescribeSecurityGroupsCommandOutput> => client.send(new DescribeSecurityGroupsCommand(input)),\n      describeSubnets: (input: DescribeSubnetsCommandInput): Promise<DescribeSubnetsCommandOutput> =>\n        client.send(new DescribeSubnetsCommand(input)),\n      describeVpcEndpointServices: (\n        input: DescribeVpcEndpointServicesCommandInput,\n      ): Promise<DescribeVpcEndpointServicesCommandOutput> =>\n        client.send(new DescribeVpcEndpointServicesCommand(input)),\n      describeVpcs: (input: DescribeVpcsCommandInput): Promise<DescribeVpcsCommandOutput> =>\n        client.send(new DescribeVpcsCommand(input)),\n      describeVpnGateways: (input: DescribeVpnGatewaysCommandInput): Promise<DescribeVpnGatewaysCommandOutput> =>\n        client.send(new DescribeVpnGatewaysCommand(input)),\n    };\n  }\n\n  public ecr(): IECRClient {\n    const client = new ECRClient(this.config);\n    return {\n      batchDeleteImage: (input: BatchDeleteImageCommandInput): Promise<BatchDeleteImageCommandOutput> =>\n        client.send(new BatchDeleteImageCommand(input)),\n      batchGetImage: (input: BatchGetImageCommandInput): Promise<BatchGetImageCommandOutput> =>\n        client.send(new BatchGetImageCommand(input)),\n      createRepository: (input: CreateRepositoryCommandInput): Promise<CreateRepositoryCommandOutput> =>\n        client.send(new CreateRepositoryCommand(input)),\n      describeImages: (input: ECRDescribeImagesCommandInput): Promise<ECRDescribeImagesCommandOutput> =>\n        client.send(new ECRDescribeImagesCommand(input)),\n      describeRepositories: (input: DescribeRepositoriesCommandInput): Promise<DescribeRepositoriesCommandOutput> =>\n        client.send(new DescribeRepositoriesCommand(input)),\n      getAuthorizationToken: (input: GetAuthorizationTokenCommandInput): Promise<GetAuthorizationTokenCommandOutput> =>\n        client.send(new GetAuthorizationTokenCommand(input)),\n      listImages: (input: ListImagesCommandInput): Promise<ListImagesCommandOutput> =>\n        client.send(new ListImagesCommand(input)),\n      putImage: (input: PutImageCommandInput): Promise<PutImageCommandOutput> =>\n        client.send(new PutImageCommand(input)),\n      putImageScanningConfiguration: (\n        input: PutImageScanningConfigurationCommandInput,\n      ): Promise<PutImageScanningConfigurationCommandOutput> =>\n        client.send(new PutImageScanningConfigurationCommand(input)),\n    };\n  }\n\n  public ecs(): IECSClient {\n    const client = new ECSClient(this.config);\n    return {\n      listClusters: (input: ListClustersCommandInput): Promise<ListClustersCommandOutput> =>\n        client.send(new ListClustersCommand(input)),\n      registerTaskDefinition: (\n        input: RegisterTaskDefinitionCommandInput,\n      ): Promise<RegisterTaskDefinitionCommandOutput> => client.send(new RegisterTaskDefinitionCommand(input)),\n      updateService: (input: UpdateServiceCommandInput): Promise<UpdateServiceCommandOutput> =>\n        client.send(new UpdateServiceCommand(input)),\n      // Waiters\n      waitUntilServicesStable: (input: DescribeServicesCommandInput): Promise<WaiterResult> => {\n        return waitUntilServicesStable(\n          {\n            client,\n            maxWaitTime: 600,\n            minDelay: 6,\n            maxDelay: 6,\n          },\n          input,\n        );\n      },\n    };\n  }\n\n  public elbv2(): IElasticLoadBalancingV2Client {\n    const client = new ElasticLoadBalancingV2Client(this.config);\n    return {\n      describeListeners: (input: DescribeListenersCommandInput): Promise<DescribeListenersCommandOutput> =>\n        client.send(new DescribeListenersCommand(input)),\n      describeLoadBalancers: (input: DescribeLoadBalancersCommandInput): Promise<DescribeLoadBalancersCommandOutput> =>\n        client.send(new DescribeLoadBalancersCommand(input)),\n      describeTags: (input: DescribeTagsCommandInput): Promise<DescribeTagsCommandOutput> =>\n        client.send(new DescribeTagsCommand(input)),\n      // Pagination Functions\n      paginateDescribeListeners: async (input: DescribeListenersCommandInput): Promise<Listener[]> => {\n        const listeners = Array<Listener>();\n        const paginator = paginateDescribeListeners({ client }, input);\n        for await (const page of paginator) {\n          listeners.push(...(page?.Listeners || []));\n        }\n        return listeners;\n      },\n      paginateDescribeLoadBalancers: async (input: DescribeLoadBalancersCommandInput): Promise<LoadBalancer[]> => {\n        const loadBalancers = Array<LoadBalancer>();\n        const paginator = paginateDescribeLoadBalancers({ client }, input);\n        for await (const page of paginator) {\n          loadBalancers.push(...(page?.LoadBalancers || []));\n        }\n        return loadBalancers;\n      },\n    };\n  }\n\n  public iam(): IIAMClient {\n    const client = new IAMClient(this.config);\n    return {\n      createPolicy: (input: CreatePolicyCommandInput): Promise<CreatePolicyCommandOutput> =>\n        client.send(new CreatePolicyCommand(input)),\n      getPolicy: (input: GetPolicyCommandInput): Promise<GetPolicyCommandOutput> =>\n        client.send(new GetPolicyCommand(input)),\n      getRole: (input: GetRoleCommandInput): Promise<GetRoleCommandOutput> => client.send(new GetRoleCommand(input)),\n    };\n  }\n\n  public kms(): IKMSClient {\n    const client = new KMSClient(this.config);\n    return {\n      describeKey: (input: DescribeKeyCommandInput): Promise<DescribeKeyCommandOutput> =>\n        client.send(new DescribeKeyCommand(input)),\n      listAliases: (input: ListAliasesCommandInput): Promise<ListAliasesCommandOutput> =>\n        client.send(new ListAliasesCommand(input)),\n    };\n  }\n\n  public lambda(): ILambdaClient {\n    const client = new LambdaClient(this.config);\n    return {\n      invokeCommand: (input: InvokeCommandInput): Promise<InvokeCommandOutput> => client.send(new InvokeCommand(input)),\n      publishVersion: (input: PublishVersionCommandInput): Promise<PublishVersionCommandOutput> =>\n        client.send(new PublishVersionCommand(input)),\n      updateAlias: (input: UpdateAliasCommandInput): Promise<UpdateAliasCommandOutput> =>\n        client.send(new UpdateAliasCommand(input)),\n      updateFunctionCode: (input: UpdateFunctionCodeCommandInput): Promise<UpdateFunctionCodeCommandOutput> =>\n        client.send(new UpdateFunctionCodeCommand(input)),\n      updateFunctionConfiguration: (\n        input: UpdateFunctionConfigurationCommandInput,\n      ): Promise<UpdateFunctionConfigurationCommandOutput> =>\n        client.send(new UpdateFunctionConfigurationCommand(input)),\n      // Waiters\n      waitUntilFunctionUpdated: (\n        delaySeconds: number,\n        input: UpdateFunctionConfigurationCommandInput,\n      ): Promise<WaiterResult> => {\n        return waitUntilFunctionUpdatedV2(\n          {\n            client,\n            maxDelay: delaySeconds,\n            minDelay: delaySeconds,\n            maxWaitTime: delaySeconds * 60,\n          },\n          input,\n        );\n      },\n    };\n  }\n\n  public route53(): IRoute53Client {\n    const client = new Route53Client(this.config);\n    return {\n      getHostedZone: (input: GetHostedZoneCommandInput): Promise<GetHostedZoneCommandOutput> =>\n        client.send(new GetHostedZoneCommand(input)),\n      listHostedZones: (input: ListHostedZonesCommandInput): Promise<ListHostedZonesCommandOutput> =>\n        client.send(new ListHostedZonesCommand(input)),\n      listHostedZonesByName: (input: ListHostedZonesByNameCommandInput): Promise<ListHostedZonesByNameCommandOutput> =>\n        client.send(new ListHostedZonesByNameCommand(input)),\n    };\n  }\n\n  public s3(): IS3Client {\n    const client = new S3Client(this.config);\n    return {\n      deleteObjects: (input: DeleteObjectsCommandInput): Promise<DeleteObjectsCommandOutput> =>\n        client.send(new DeleteObjectsCommand({\n          ...input,\n          ChecksumAlgorithm: 'SHA256',\n        })),\n      deleteObjectTagging: (input: DeleteObjectTaggingCommandInput): Promise<DeleteObjectTaggingCommandOutput> =>\n        client.send(new DeleteObjectTaggingCommand(input)),\n      getBucketEncryption: (input: GetBucketEncryptionCommandInput): Promise<GetBucketEncryptionCommandOutput> =>\n        client.send(new GetBucketEncryptionCommand(input)),\n      getBucketLocation: (input: GetBucketLocationCommandInput): Promise<GetBucketLocationCommandOutput> =>\n        client.send(new GetBucketLocationCommand(input)),\n      getObject: (input: GetObjectCommandInput): Promise<GetObjectCommandOutput> =>\n        client.send(new GetObjectCommand(input)),\n      getObjectTagging: (input: GetObjectTaggingCommandInput): Promise<GetObjectTaggingCommandOutput> =>\n        client.send(new GetObjectTaggingCommand(input)),\n      listObjectsV2: (input: ListObjectsV2CommandInput): Promise<ListObjectsV2CommandOutput> =>\n        client.send(new ListObjectsV2Command(input)),\n      putObjectTagging: (input: PutObjectTaggingCommandInput): Promise<PutObjectTaggingCommandOutput> =>\n        client.send(new PutObjectTaggingCommand({\n          ...input,\n          ChecksumAlgorithm: 'SHA256',\n        })),\n      upload: (input: PutObjectCommandInput): Promise<CompleteMultipartUploadCommandOutput> => {\n        try {\n          const upload = new Upload({\n            client,\n            params: { ...input, ChecksumAlgorithm: 'SHA256' },\n          });\n\n          return upload.done();\n        } catch (e: any) {\n          throw new AuthenticationError(`Upload failed: ${formatErrorMessage(e)}`);\n        }\n      },\n    };\n  }\n\n  public secretsManager(): ISecretsManagerClient {\n    const client = new SecretsManagerClient(this.config);\n    return {\n      getSecretValue: (input: GetSecretValueCommandInput): Promise<GetSecretValueCommandOutput> =>\n        client.send(new GetSecretValueCommand(input)),\n    };\n  }\n\n  public ssm(): ISSMClient {\n    const client = new SSMClient(this.config);\n    return {\n      getParameter: (input: GetParameterCommandInput): Promise<GetParameterCommandOutput> =>\n        client.send(new GetParameterCommand(input)),\n    };\n  }\n\n  public stepFunctions(): IStepFunctionsClient {\n    const client = new SFNClient(this.config);\n    return {\n      updateStateMachine: (input: UpdateStateMachineCommandInput): Promise<UpdateStateMachineCommandOutput> =>\n        client.send(new UpdateStateMachineCommand(input)),\n    };\n  }\n\n  /**\n   * The AWS SDK v3 requires a client config and a command in order to get an endpoint for\n   * any given service.\n   */\n  public async getUrlSuffix(region: string): Promise<string> {\n    const cfn = new CloudFormationClient({ region });\n    const endpoint = await getEndpointFromInstructions({}, DescribeStackResourcesCommand, { ...cfn.config });\n    return endpoint.url.hostname.split(`${region}.`).pop()!;\n  }\n\n  public async currentAccount(): Promise<Account> {\n    return cachedAsync(this, CURRENT_ACCOUNT_KEY, async () => {\n      const creds = await this.credProvider();\n      return this.accountCache.fetch(creds.accessKeyId, async () => {\n        // if we don't have one, resolve from STS and store in cache.\n        await this.debug('Looking up default account ID from STS');\n        const client = new STSClient({\n          ...this.config,\n          retryStrategy: this.stsRetryStrategy,\n        });\n        const command = new GetCallerIdentityCommand({});\n        const result = await client.send(command);\n        const accountId = result.Account;\n        const partition = result.Arn!.split(':')[1];\n        if (!accountId) {\n          throw new AuthenticationError(\"STS didn't return an account ID\");\n        }\n        await this.debug(`Default account ID: ${accountId}`);\n\n        // Save another STS call later if this one already succeeded\n        this._credentialsValidated = true;\n        return { accountId, partition };\n      });\n    });\n  }\n\n  /**\n   * Make sure the the current credentials are not expired\n   */\n  public async validateCredentials() {\n    if (this._credentialsValidated) {\n      return;\n    }\n\n    const client = new STSClient({ ...this.config, retryStrategy: this.stsRetryStrategy });\n    await client.send(new GetCallerIdentityCommand({}));\n    this._credentialsValidated = true;\n  }\n}\n\nconst CURRENT_ACCOUNT_KEY = Symbol('current_account_key');\n"]} \ No newline at end of file diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/tracing.d.ts b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/tracing.d.ts new file mode 100644 index 000000000..aa8a19170 --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/tracing.d.ts @@ -0,0 +1,11 @@ +import type { Logger } from '@smithy/types'; +export declare function setSdkTracing(enabled: boolean): void; +/** + * Method decorator to trace a single static or member method, any time it's called + */ +export declare function callTrace(fn: string, className?: string, logger?: Logger): void; +/** + * Class decorator, enable tracing for all member methods on this class + * @deprecated this doesn't work well with localized logging instances, don't use + */ +export declare function traceMemberMethods(constructor: Function): void; diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/tracing.js b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/tracing.js new file mode 100644 index 000000000..7b7cd36ca --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/tracing.js @@ -0,0 +1,60 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.setSdkTracing = setSdkTracing; +exports.callTrace = callTrace; +exports.traceMemberMethods = traceMemberMethods; +let ENABLED = false; +let INDENT = 0; +function setSdkTracing(enabled) { + ENABLED = enabled; +} +/** + * Method decorator to trace a single static or member method, any time it's called + */ +function callTrace(fn, className, logger) { + if (!ENABLED || !logger) { + return; + } + logger.info(`[trace] ${' '.repeat(INDENT)}${className || '(anonymous)'}#${fn}()`); +} +/** + * Method decorator to trace a single member method any time it's called + */ +function traceCall(receiver, _propertyKey, descriptor, parentClassName) { + const fn = descriptor.value; + const className = typeof receiver === 'function' ? receiver.name : parentClassName; + descriptor.value = function (...args) { + const logger = this.logger; + if (!ENABLED || typeof logger?.info !== 'function') { + return fn.apply(this, args); + } + logger.info.apply(logger, [`[trace] ${' '.repeat(INDENT)}${className || this.constructor.name || '(anonymous)'}#${fn.name}()`]); + INDENT += 2; + const ret = fn.apply(this, args); + if (ret instanceof Promise) { + return ret.finally(() => { + INDENT -= 2; + }); + } + else { + INDENT -= 2; + return ret; + } + }; + return descriptor; +} +/** + * Class decorator, enable tracing for all member methods on this class + * @deprecated this doesn't work well with localized logging instances, don't use + */ +function traceMemberMethods(constructor) { + // Instance members + for (const [name, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(constructor.prototype))) { + if (typeof descriptor.value !== 'function') { + continue; + } + const newDescriptor = traceCall(constructor.prototype, name, descriptor, constructor.name) ?? descriptor; + Object.defineProperty(constructor.prototype, name, newDescriptor); + } +} +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/user-agent.d.ts b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/user-agent.d.ts new file mode 100644 index 000000000..01ca9e12b --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/user-agent.d.ts @@ -0,0 +1,7 @@ +/** + * Find the package.json from the main toolkit. + * + * If we can't read it for some reason, try to do something reasonable anyway. + * Fall back to argv[1], or a standard string if that is undefined for some reason. + */ +export declare function defaultCliUserAgent(): string; diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/user-agent.js b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/user-agent.js new file mode 100644 index 000000000..2d83b73f5 --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/user-agent.js @@ -0,0 +1,20 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.defaultCliUserAgent = defaultCliUserAgent; +const path = require("path"); +const util_1 = require("./util"); +const util_2 = require("../../util"); +/** + * Find the package.json from the main toolkit. + * + * If we can't read it for some reason, try to do something reasonable anyway. + * Fall back to argv[1], or a standard string if that is undefined for some reason. + */ +function defaultCliUserAgent() { + const root = (0, util_2.bundledPackageRootDir)(__dirname, false); + const pkg = JSON.parse((root ? (0, util_1.readIfPossible)(path.join(root, 'package.json')) : undefined) ?? '{}'); + const name = pkg.name ?? path.basename(process.argv[1] ?? 'cdk-cli'); + const version = pkg.version ?? ''; + return `${name}/${version}`; +} +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXNlci1hZ2VudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9hcGkvYXdzLWF1dGgvdXNlci1hZ2VudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQVNBLGtEQU1DO0FBZkQsNkJBQTZCO0FBQzdCLGlDQUF3QztBQUN4QyxxQ0FBbUQ7QUFDbkQ7Ozs7O0dBS0c7QUFDSCxTQUFnQixtQkFBbUI7SUFDakMsTUFBTSxJQUFJLEdBQUcsSUFBQSw0QkFBcUIsRUFBQyxTQUFTLEVBQUUsS0FBSyxDQUFDLENBQUM7SUFDckQsTUFBTSxHQUFHLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsSUFBQSxxQkFBYyxFQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsSUFBSSxFQUFFLGNBQWMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLFNBQVMsQ0FBQyxJQUFJLElBQUksQ0FBQyxDQUFDO0lBQ3JHLE1BQU0sSUFBSSxHQUFHLEdBQUcsQ0FBQyxJQUFJLElBQUksSUFBSSxDQUFDLFFBQVEsQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxJQUFJLFNBQVMsQ0FBQyxDQUFDO0lBQ3JFLE1BQU0sT0FBTyxHQUFHLEdBQUcsQ0FBQyxPQUFPLElBQUksV0FBVyxDQUFDO0lBQzNDLE9BQU8sR0FBRyxJQUFJLElBQUksT0FBTyxFQUFFLENBQUM7QUFDOUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIHBhdGggZnJvbSAncGF0aCc7XG5pbXBvcnQgeyByZWFkSWZQb3NzaWJsZSB9IGZyb20gJy4vdXRpbCc7XG5pbXBvcnQgeyBidW5kbGVkUGFja2FnZVJvb3REaXIgfSBmcm9tICcuLi8uLi91dGlsJztcbi8qKlxuICogRmluZCB0aGUgcGFja2FnZS5qc29uIGZyb20gdGhlIG1haW4gdG9vbGtpdC5cbiAqXG4gKiBJZiB3ZSBjYW4ndCByZWFkIGl0IGZvciBzb21lIHJlYXNvbiwgdHJ5IHRvIGRvIHNvbWV0aGluZyByZWFzb25hYmxlIGFueXdheS5cbiAqIEZhbGwgYmFjayB0byBhcmd2WzFdLCBvciBhIHN0YW5kYXJkIHN0cmluZyBpZiB0aGF0IGlzIHVuZGVmaW5lZCBmb3Igc29tZSByZWFzb24uXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBkZWZhdWx0Q2xpVXNlckFnZW50KCkge1xuICBjb25zdCByb290ID0gYnVuZGxlZFBhY2thZ2VSb290RGlyKF9fZGlybmFtZSwgZmFsc2UpO1xuICBjb25zdCBwa2cgPSBKU09OLnBhcnNlKChyb290ID8gcmVhZElmUG9zc2libGUocGF0aC5qb2luKHJvb3QsICdwYWNrYWdlLmpzb24nKSkgOiB1bmRlZmluZWQpID8/ICd7fScpO1xuICBjb25zdCBuYW1lID0gcGtnLm5hbWUgPz8gcGF0aC5iYXNlbmFtZShwcm9jZXNzLmFyZ3ZbMV0gPz8gJ2Nkay1jbGknKTtcbiAgY29uc3QgdmVyc2lvbiA9IHBrZy52ZXJzaW9uID8/ICc8dW5rbm93bj4nO1xuICByZXR1cm4gYCR7bmFtZX0vJHt2ZXJzaW9ufWA7XG59XG4iXX0= \ No newline at end of file diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/util.d.ts b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/util.d.ts new file mode 100644 index 000000000..b84f5ca30 --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/util.d.ts @@ -0,0 +1,6 @@ +/** + * Read a file if it exists, or return undefined + * + * Not async because it is used in the constructor + */ +export declare function readIfPossible(filename: string): string | undefined; diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/util.js b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/util.js new file mode 100644 index 000000000..5fe1d4305 --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/aws-auth/util.js @@ -0,0 +1,21 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.readIfPossible = readIfPossible; +const fs = require("fs-extra"); +/** + * Read a file if it exists, or return undefined + * + * Not async because it is used in the constructor + */ +function readIfPossible(filename) { + try { + if (!fs.pathExistsSync(filename)) { + return undefined; + } + return fs.readFileSync(filename, { encoding: 'utf-8' }); + } + catch (e) { + return undefined; + } +} +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9hcGkvYXdzLWF1dGgvdXRpbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQU9BLHdDQVNDO0FBaEJELCtCQUErQjtBQUUvQjs7OztHQUlHO0FBQ0gsU0FBZ0IsY0FBYyxDQUFDLFFBQWdCO0lBQzdDLElBQUksQ0FBQztRQUNILElBQUksQ0FBQyxFQUFFLENBQUMsY0FBYyxDQUFDLFFBQVEsQ0FBQyxFQUFFLENBQUM7WUFDakMsT0FBTyxTQUFTLENBQUM7UUFDbkIsQ0FBQztRQUNELE9BQU8sRUFBRSxDQUFDLFlBQVksQ0FBQyxRQUFRLEVBQUUsRUFBRSxRQUFRLEVBQUUsT0FBTyxFQUFFLENBQUMsQ0FBQztJQUMxRCxDQUFDO0lBQUMsT0FBTyxDQUFNLEVBQUUsQ0FBQztRQUNoQixPQUFPLFNBQVMsQ0FBQztJQUNuQixDQUFDO0FBQ0gsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIGZzIGZyb20gJ2ZzLWV4dHJhJztcblxuLyoqXG4gKiBSZWFkIGEgZmlsZSBpZiBpdCBleGlzdHMsIG9yIHJldHVybiB1bmRlZmluZWRcbiAqXG4gKiBOb3QgYXN5bmMgYmVjYXVzZSBpdCBpcyB1c2VkIGluIHRoZSBjb25zdHJ1Y3RvclxuICovXG5leHBvcnQgZnVuY3Rpb24gcmVhZElmUG9zc2libGUoZmlsZW5hbWU6IHN0cmluZyk6IHN0cmluZyB8IHVuZGVmaW5lZCB7XG4gIHRyeSB7XG4gICAgaWYgKCFmcy5wYXRoRXhpc3RzU3luYyhmaWxlbmFtZSkpIHtcbiAgICAgIHJldHVybiB1bmRlZmluZWQ7XG4gICAgfVxuICAgIHJldHVybiBmcy5yZWFkRmlsZVN5bmMoZmlsZW5hbWUsIHsgZW5jb2Rpbmc6ICd1dGYtOCcgfSk7XG4gIH0gY2F0Y2ggKGU6IGFueSkge1xuICAgIHJldHVybiB1bmRlZmluZWQ7XG4gIH1cbn1cbiJdfQ== \ No newline at end of file diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/bootstrap/bootstrap-environment.d.ts b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/bootstrap/bootstrap-environment.d.ts new file mode 100644 index 000000000..6f74fc1f8 --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/bootstrap/bootstrap-environment.d.ts @@ -0,0 +1,35 @@ +import type * as cxapi from '@aws-cdk/cx-api'; +import type { BootstrapEnvironmentOptions } from './bootstrap-props'; +import type { SdkProvider } from '../aws-auth'; +import type { SuccessfulDeployStackResult } from '../deployments'; +import { type IoHelper } from '../io/private'; +export type BootstrapSource = { + source: 'legacy'; +} | { + source: 'default'; +} | { + source: 'custom'; + templateFile: string; +}; +export declare class Bootstrapper { + private readonly source; + private readonly ioHelper; + constructor(source: BootstrapSource | undefined, ioHelper: IoHelper); + bootstrapEnvironment(environment: cxapi.Environment, sdkProvider: SdkProvider, options?: BootstrapEnvironmentOptions): Promise; + showTemplate(json: boolean): Promise; + /** + * Deploy legacy bootstrap stack + * + */ + private legacyBootstrap; + /** + * Deploy CI/CD-ready bootstrap stack from template + * + */ + private modernBootstrap; + private getPolicyName; + private getExamplePermissionsBoundary; + private validatePolicyName; + private customBootstrap; + private loadTemplate; +} diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/bootstrap/bootstrap-environment.js b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/bootstrap/bootstrap-environment.js new file mode 100644 index 000000000..7adb664b8 --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/bootstrap/bootstrap-environment.js @@ -0,0 +1,323 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.Bootstrapper = void 0; +const path = require("path"); +const deploy_bootstrap_1 = require("./deploy-bootstrap"); +const legacy_template_1 = require("./legacy-template"); +const util_1 = require("../../util"); +const private_1 = require("../io/private"); +const plugin_1 = require("../plugin"); +const toolkit_error_1 = require("../toolkit-error"); +const toolkit_info_1 = require("../toolkit-info"); +class Bootstrapper { + source; + ioHelper; + constructor(source = { source: 'default' }, ioHelper) { + this.source = source; + this.ioHelper = ioHelper; + } + bootstrapEnvironment(environment, sdkProvider, options = {}) { + switch (this.source.source) { + case 'legacy': + return this.legacyBootstrap(environment, sdkProvider, options); + case 'default': + return this.modernBootstrap(environment, sdkProvider, options); + case 'custom': + return this.customBootstrap(environment, sdkProvider, options); + } + } + async showTemplate(json) { + const template = await this.loadTemplate(); + process.stdout.write(`${(0, util_1.serializeStructure)(template, json)}\n`); + } + /** + * Deploy legacy bootstrap stack + * + */ + async legacyBootstrap(environment, sdkProvider, options = {}) { + const params = options.parameters ?? {}; + if (params.trustedAccounts?.length) { + throw new toolkit_error_1.ToolkitError('--trust can only be passed for the modern bootstrap experience.'); + } + if (params.cloudFormationExecutionPolicies?.length) { + throw new toolkit_error_1.ToolkitError('--cloudformation-execution-policies can only be passed for the modern bootstrap experience.'); + } + if (params.createCustomerMasterKey !== undefined) { + throw new toolkit_error_1.ToolkitError('--bootstrap-customer-key can only be passed for the modern bootstrap experience.'); + } + if (params.qualifier) { + throw new toolkit_error_1.ToolkitError('--qualifier can only be passed for the modern bootstrap experience.'); + } + const toolkitStackName = options.toolkitStackName ?? toolkit_info_1.DEFAULT_TOOLKIT_STACK_NAME; + const current = await deploy_bootstrap_1.BootstrapStack.lookup(sdkProvider, environment, toolkitStackName, this.ioHelper); + return current.update(await this.loadTemplate(params), {}, { + ...options, + terminationProtection: options.terminationProtection ?? current.terminationProtection, + }); + } + /** + * Deploy CI/CD-ready bootstrap stack from template + * + */ + async modernBootstrap(environment, sdkProvider, options = {}) { + const params = options.parameters ?? {}; + const bootstrapTemplate = await this.loadTemplate(); + const toolkitStackName = options.toolkitStackName ?? toolkit_info_1.DEFAULT_TOOLKIT_STACK_NAME; + const current = await deploy_bootstrap_1.BootstrapStack.lookup(sdkProvider, environment, toolkitStackName, this.ioHelper); + const partition = await current.partition(); + if (params.createCustomerMasterKey !== undefined && params.kmsKeyId) { + throw new toolkit_error_1.ToolkitError("You cannot pass '--bootstrap-kms-key-id' and '--bootstrap-customer-key' together. Specify one or the other"); + } + // If people re-bootstrap, existing parameter values are reused so that people don't accidentally change the configuration + // on their bootstrap stack (this happens automatically in deployStack). However, to do proper validation on the + // combined arguments (such that if --trust has been given, --cloudformation-execution-policies is necessary as well) + // we need to take this parameter reuse into account. + // + // Ideally we'd do this inside the template, but the `Rules` section of CFN + // templates doesn't seem to be able to express the conditions that we need + // (can't use Fn::Join or reference Conditions) so we do it here instead. + const allTrusted = new Set([ + ...params.trustedAccounts ?? [], + ...params.trustedAccountsForLookup ?? [], + ]); + const invalid = intersection(allTrusted, new Set(params.untrustedAccounts)); + if (invalid.size > 0) { + throw new toolkit_error_1.ToolkitError(`Accounts cannot be both trusted and untrusted. Found: ${[...invalid].join(',')}`); + } + const removeUntrusted = (accounts) => accounts.filter(acc => !params.untrustedAccounts?.map(String).includes(String(acc))); + const trustedAccounts = removeUntrusted(params.trustedAccounts ?? splitCfnArray(current.parameters.TrustedAccounts)); + await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_INFO.msg(`Trusted accounts for deployment: ${trustedAccounts.length > 0 ? trustedAccounts.join(', ') : '(none)'}`)); + const trustedAccountsForLookup = removeUntrusted(params.trustedAccountsForLookup ?? splitCfnArray(current.parameters.TrustedAccountsForLookup)); + await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_INFO.msg(`Trusted accounts for lookup: ${trustedAccountsForLookup.length > 0 ? trustedAccountsForLookup.join(', ') : '(none)'}`)); + const cloudFormationExecutionPolicies = params.cloudFormationExecutionPolicies ?? splitCfnArray(current.parameters.CloudFormationExecutionPolicies); + if (trustedAccounts.length === 0 && cloudFormationExecutionPolicies.length === 0) { + // For self-trust it's okay to default to AdministratorAccess, and it improves the usability of bootstrapping a lot. + // + // We don't actually make the implicitly policy a physical parameter. The template will infer it instead, + // we simply do the UI advertising that behavior here. + // + // If we DID make it an explicit parameter, we wouldn't be able to tell the difference between whether + // we inferred it or whether the user told us, and the sequence: + // + // $ cdk bootstrap + // $ cdk bootstrap --trust 1234 + // + // Would leave AdministratorAccess policies with a trust relationship, without the user explicitly + // approving the trust policy. + const implicitPolicy = `arn:${partition}:iam::aws:policy/AdministratorAccess`; + await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_WARN.msg(`Using default execution policy of '${implicitPolicy}'. Pass '--cloudformation-execution-policies' to customize.`)); + } + else if (cloudFormationExecutionPolicies.length === 0) { + throw new toolkit_error_1.ToolkitError(`Please pass \'--cloudformation-execution-policies\' when using \'--trust\' to specify deployment permissions. Try a managed policy of the form \'arn:${partition}:iam::aws:policy/\'.`); + } + else { + // Remind people what the current settings are + await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_INFO.msg(`Execution policies: ${cloudFormationExecutionPolicies.join(', ')}`)); + } + // * If an ARN is given, that ARN. Otherwise: + // * '-' if customerKey = false + // * '' if customerKey = true + // * if customerKey is also not given + // * undefined if we already had a value in place (reusing what we had) + // * '-' if this is the first time we're deploying this stack (or upgrading from old to new bootstrap) + const currentKmsKeyId = current.parameters.FileAssetsBucketKmsKeyId; + const kmsKeyId = params.kmsKeyId ?? + (params.createCustomerMasterKey === true + ? CREATE_NEW_KEY + : params.createCustomerMasterKey === false || currentKmsKeyId === undefined + ? USE_AWS_MANAGED_KEY + : undefined); + /* A permissions boundary can be provided via: + * - the flag indicating the example one should be used + * - the name indicating the custom permissions boundary to be used + * Re-bootstrapping will NOT be blocked by either tightening or relaxing the permissions' boundary. + */ + // InputPermissionsBoundary is an `any` type and if it is not defined it + // appears as an empty string ''. We need to force it to evaluate an empty string + // as undefined + const currentPermissionsBoundary = current.parameters.InputPermissionsBoundary || undefined; + const inputPolicyName = params.examplePermissionsBoundary + ? CDK_BOOTSTRAP_PERMISSIONS_BOUNDARY + : params.customPermissionsBoundary; + let policyName; + if (inputPolicyName) { + // If the example policy is not already in place, it must be created. + const sdk = (await sdkProvider.forEnvironment(environment, plugin_1.Mode.ForWriting)).sdk; + policyName = await this.getPolicyName(environment, sdk, inputPolicyName, partition, params); + } + if (currentPermissionsBoundary !== policyName) { + if (!currentPermissionsBoundary) { + await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_WARN.msg(`Adding new permissions boundary ${policyName}`)); + } + else if (!policyName) { + await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_WARN.msg(`Removing existing permissions boundary ${currentPermissionsBoundary}`)); + } + else { + await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_WARN.msg(`Changing permissions boundary from ${currentPermissionsBoundary} to ${policyName}`)); + } + } + return current.update(bootstrapTemplate, { + FileAssetsBucketName: params.bucketName, + FileAssetsBucketKmsKeyId: kmsKeyId, + // Empty array becomes empty string + TrustedAccounts: trustedAccounts.join(','), + TrustedAccountsForLookup: trustedAccountsForLookup.join(','), + CloudFormationExecutionPolicies: cloudFormationExecutionPolicies.join(','), + Qualifier: params.qualifier, + PublicAccessBlockConfiguration: params.publicAccessBlockConfiguration || params.publicAccessBlockConfiguration === undefined + ? 'true' + : 'false', + InputPermissionsBoundary: policyName, + }, { + ...options, + terminationProtection: options.terminationProtection ?? current.terminationProtection, + }); + } + async getPolicyName(environment, sdk, permissionsBoundary, partition, params) { + if (permissionsBoundary !== CDK_BOOTSTRAP_PERMISSIONS_BOUNDARY) { + this.validatePolicyName(permissionsBoundary); + return Promise.resolve(permissionsBoundary); + } + // if no Qualifier is supplied, resort to the default one + const arn = await this.getExamplePermissionsBoundary(params.qualifier ?? 'hnb659fds', partition, environment.account, sdk); + const policyName = arn.split('/').pop(); + if (!policyName) { + throw new toolkit_error_1.ToolkitError('Could not retrieve the example permission boundary!'); + } + return Promise.resolve(policyName); + } + async getExamplePermissionsBoundary(qualifier, partition, account, sdk) { + const iam = sdk.iam(); + let policyName = `cdk-${qualifier}-permissions-boundary`; + const arn = `arn:${partition}:iam::${account}:policy/${policyName}`; + try { + let getPolicyResp = await iam.getPolicy({ PolicyArn: arn }); + if (getPolicyResp.Policy) { + return arn; + } + } + catch (e) { + // https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetPolicy.html#API_GetPolicy_Errors + if (e.name === 'NoSuchEntity') { + // noop, proceed with creating the policy + } + else { + throw e; + } + } + const policyDoc = { + Version: '2012-10-17', + Statement: [ + { + Action: ['*'], + Resource: '*', + Effect: 'Allow', + Sid: 'ExplicitAllowAll', + }, + { + Condition: { + StringEquals: { + 'iam:PermissionsBoundary': `arn:${partition}:iam::${account}:policy/cdk-${qualifier}-permissions-boundary`, + }, + }, + Action: [ + 'iam:CreateUser', + 'iam:CreateRole', + 'iam:PutRolePermissionsBoundary', + 'iam:PutUserPermissionsBoundary', + ], + Resource: '*', + Effect: 'Allow', + Sid: 'DenyAccessIfRequiredPermBoundaryIsNotBeingApplied', + }, + { + Action: [ + 'iam:CreatePolicyVersion', + 'iam:DeletePolicy', + 'iam:DeletePolicyVersion', + 'iam:SetDefaultPolicyVersion', + ], + Resource: `arn:${partition}:iam::${account}:policy/cdk-${qualifier}-permissions-boundary`, + Effect: 'Deny', + Sid: 'DenyPermBoundaryIAMPolicyAlteration', + }, + { + Action: ['iam:DeleteUserPermissionsBoundary', 'iam:DeleteRolePermissionsBoundary'], + Resource: '*', + Effect: 'Deny', + Sid: 'DenyRemovalOfPermBoundaryFromAnyUserOrRole', + }, + ], + }; + const request = { + PolicyName: policyName, + PolicyDocument: JSON.stringify(policyDoc), + }; + const createPolicyResponse = await iam.createPolicy(request); + if (createPolicyResponse.Policy?.Arn) { + return createPolicyResponse.Policy.Arn; + } + else { + throw new toolkit_error_1.ToolkitError(`Could not retrieve the example permission boundary ${arn}!`); + } + } + validatePolicyName(permissionsBoundary) { + // https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreatePolicy.html + // Added support for policy names with a path + // See https://github.com/aws/aws-cdk/issues/26320 + const regexp = /[\w+\/=,.@-]+/; + const matches = regexp.exec(permissionsBoundary); + if (!(matches && matches.length === 1 && matches[0] === permissionsBoundary)) { + throw new toolkit_error_1.ToolkitError(`The permissions boundary name ${permissionsBoundary} does not match the IAM conventions.`); + } + } + async customBootstrap(environment, sdkProvider, options = {}) { + // Look at the template, decide whether it's most likely a legacy or modern bootstrap + // template, and use the right bootstrapper for that. + const version = (0, deploy_bootstrap_1.bootstrapVersionFromTemplate)(await this.loadTemplate()); + if (version === 0) { + return this.legacyBootstrap(environment, sdkProvider, options); + } + else { + return this.modernBootstrap(environment, sdkProvider, options); + } + } + async loadTemplate(params = {}) { + switch (this.source.source) { + case 'custom': + return (0, util_1.loadStructuredFile)(this.source.templateFile); + case 'default': + return (0, util_1.loadStructuredFile)(path.join((0, util_1.bundledPackageRootDir)(__dirname), 'lib', 'api', 'bootstrap', 'bootstrap-template.yaml')); + case 'legacy': + return (0, legacy_template_1.legacyBootstrapTemplate)(params); + } + } +} +exports.Bootstrapper = Bootstrapper; +/** + * Magic parameter value that will cause the bootstrap-template.yml to NOT create a CMK but use the default key + */ +const USE_AWS_MANAGED_KEY = 'AWS_MANAGED_KEY'; +/** + * Magic parameter value that will cause the bootstrap-template.yml to create a CMK + */ +const CREATE_NEW_KEY = ''; +/** + * Parameter value indicating the use of the default, CDK provided permissions boundary for bootstrap-template.yml + */ +const CDK_BOOTSTRAP_PERMISSIONS_BOUNDARY = 'CDK_BOOTSTRAP_PERMISSIONS_BOUNDARY'; +/** + * Split an array-like CloudFormation parameter on , + * + * An empty string is the empty array (instead of `['']`). + */ +function splitCfnArray(xs) { + if (xs === '' || xs === undefined) { + return []; + } + return xs.split(','); +} +function intersection(xs, ys) { + return new Set(Array.from(xs).filter(x => ys.has(x))); +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bootstrap-environment.js","sourceRoot":"","sources":["../../../src/api/bootstrap/bootstrap-environment.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'path';\nimport type * as cxapi from '@aws-cdk/cx-api';\nimport type { BootstrapEnvironmentOptions, BootstrappingParameters } from './bootstrap-props';\nimport { BootstrapStack, bootstrapVersionFromTemplate } from './deploy-bootstrap';\nimport { legacyBootstrapTemplate } from './legacy-template';\nimport { bundledPackageRootDir, loadStructuredFile, serializeStructure } from '../../util';\nimport type { SDK, SdkProvider } from '../aws-auth';\nimport type { SuccessfulDeployStackResult } from '../deployments';\nimport { IO, type IoHelper } from '../io/private';\nimport { Mode } from '../plugin';\nimport { ToolkitError } from '../toolkit-error';\nimport { DEFAULT_TOOLKIT_STACK_NAME } from '../toolkit-info';\n\nexport type BootstrapSource = { source: 'legacy' } | { source: 'default' } | { source: 'custom'; templateFile: string };\n\nexport class Bootstrapper {\n  private readonly ioHelper: IoHelper;\n\n  constructor(\n    private readonly source: BootstrapSource = { source: 'default' },\n    ioHelper: IoHelper,\n  ) {\n    this.ioHelper = ioHelper;\n  }\n\n  public bootstrapEnvironment(\n    environment: cxapi.Environment,\n    sdkProvider: SdkProvider,\n    options: BootstrapEnvironmentOptions = {},\n  ): Promise<SuccessfulDeployStackResult> {\n    switch (this.source.source) {\n      case 'legacy':\n        return this.legacyBootstrap(environment, sdkProvider, options);\n      case 'default':\n        return this.modernBootstrap(environment, sdkProvider, options);\n      case 'custom':\n        return this.customBootstrap(environment, sdkProvider, options);\n    }\n  }\n\n  public async showTemplate(json: boolean) {\n    const template = await this.loadTemplate();\n    process.stdout.write(`${serializeStructure(template, json)}\\n`);\n  }\n\n  /**\n   * Deploy legacy bootstrap stack\n   *\n   */\n  private async legacyBootstrap(\n    environment: cxapi.Environment,\n    sdkProvider: SdkProvider,\n    options: BootstrapEnvironmentOptions = {},\n  ): Promise<SuccessfulDeployStackResult> {\n    const params = options.parameters ?? {};\n\n    if (params.trustedAccounts?.length) {\n      throw new ToolkitError('--trust can only be passed for the modern bootstrap experience.');\n    }\n    if (params.cloudFormationExecutionPolicies?.length) {\n      throw new ToolkitError('--cloudformation-execution-policies can only be passed for the modern bootstrap experience.');\n    }\n    if (params.createCustomerMasterKey !== undefined) {\n      throw new ToolkitError('--bootstrap-customer-key can only be passed for the modern bootstrap experience.');\n    }\n    if (params.qualifier) {\n      throw new ToolkitError('--qualifier can only be passed for the modern bootstrap experience.');\n    }\n\n    const toolkitStackName = options.toolkitStackName ?? DEFAULT_TOOLKIT_STACK_NAME;\n    const current = await BootstrapStack.lookup(sdkProvider, environment, toolkitStackName, this.ioHelper);\n    return current.update(\n      await this.loadTemplate(params),\n      {},\n      {\n        ...options,\n        terminationProtection: options.terminationProtection ?? current.terminationProtection,\n      },\n    );\n  }\n\n  /**\n   * Deploy CI/CD-ready bootstrap stack from template\n   *\n   */\n  private async modernBootstrap(\n    environment: cxapi.Environment,\n    sdkProvider: SdkProvider,\n    options: BootstrapEnvironmentOptions = {},\n  ): Promise<SuccessfulDeployStackResult> {\n    const params = options.parameters ?? {};\n\n    const bootstrapTemplate = await this.loadTemplate();\n\n    const toolkitStackName = options.toolkitStackName ?? DEFAULT_TOOLKIT_STACK_NAME;\n    const current = await BootstrapStack.lookup(sdkProvider, environment, toolkitStackName, this.ioHelper);\n    const partition = await current.partition();\n\n    if (params.createCustomerMasterKey !== undefined && params.kmsKeyId) {\n      throw new ToolkitError(\n        \"You cannot pass '--bootstrap-kms-key-id' and '--bootstrap-customer-key' together. Specify one or the other\",\n      );\n    }\n\n    // If people re-bootstrap, existing parameter values are reused so that people don't accidentally change the configuration\n    // on their bootstrap stack (this happens automatically in deployStack). However, to do proper validation on the\n    // combined arguments (such that if --trust has been given, --cloudformation-execution-policies is necessary as well)\n    // we need to take this parameter reuse into account.\n    //\n    // Ideally we'd do this inside the template, but the `Rules` section of CFN\n    // templates doesn't seem to be able to express the conditions that we need\n    // (can't use Fn::Join or reference Conditions) so we do it here instead.\n    const allTrusted = new Set([\n      ...params.trustedAccounts ?? [],\n      ...params.trustedAccountsForLookup ?? [],\n    ]);\n    const invalid = intersection(allTrusted, new Set(params.untrustedAccounts));\n    if (invalid.size > 0) {\n      throw new ToolkitError(`Accounts cannot be both trusted and untrusted. Found: ${[...invalid].join(',')}`);\n    }\n\n    const removeUntrusted = (accounts: string[]) =>\n      accounts.filter(acc => !params.untrustedAccounts?.map(String).includes(String(acc)));\n\n    const trustedAccounts = removeUntrusted(params.trustedAccounts ?? splitCfnArray(current.parameters.TrustedAccounts));\n    await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_INFO.msg(\n      `Trusted accounts for deployment: ${trustedAccounts.length > 0 ? trustedAccounts.join(', ') : '(none)'}`,\n    ));\n\n    const trustedAccountsForLookup = removeUntrusted(\n      params.trustedAccountsForLookup ?? splitCfnArray(current.parameters.TrustedAccountsForLookup),\n    );\n    await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_INFO.msg(\n      `Trusted accounts for lookup: ${trustedAccountsForLookup.length > 0 ? trustedAccountsForLookup.join(', ') : '(none)'}`,\n    ));\n\n    const cloudFormationExecutionPolicies =\n      params.cloudFormationExecutionPolicies ?? splitCfnArray(current.parameters.CloudFormationExecutionPolicies);\n    if (trustedAccounts.length === 0 && cloudFormationExecutionPolicies.length === 0) {\n      // For self-trust it's okay to default to AdministratorAccess, and it improves the usability of bootstrapping a lot.\n      //\n      // We don't actually make the implicitly policy a physical parameter. The template will infer it instead,\n      // we simply do the UI advertising that behavior here.\n      //\n      // If we DID make it an explicit parameter, we wouldn't be able to tell the difference between whether\n      // we inferred it or whether the user told us, and the sequence:\n      //\n      // $ cdk bootstrap\n      // $ cdk bootstrap --trust 1234\n      //\n      // Would leave AdministratorAccess policies with a trust relationship, without the user explicitly\n      // approving the trust policy.\n      const implicitPolicy = `arn:${partition}:iam::aws:policy/AdministratorAccess`;\n      await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_WARN.msg(\n        `Using default execution policy of '${implicitPolicy}'. Pass '--cloudformation-execution-policies' to customize.`,\n      ));\n    } else if (cloudFormationExecutionPolicies.length === 0) {\n      throw new ToolkitError(\n        `Please pass \\'--cloudformation-execution-policies\\' when using \\'--trust\\' to specify deployment permissions. Try a managed policy of the form \\'arn:${partition}:iam::aws:policy/<PolicyName>\\'.`,\n      );\n    } else {\n      // Remind people what the current settings are\n      await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_INFO.msg(`Execution policies: ${cloudFormationExecutionPolicies.join(', ')}`));\n    }\n\n    // * If an ARN is given, that ARN. Otherwise:\n    //   * '-' if customerKey = false\n    //   * '' if customerKey = true\n    //   * if customerKey is also not given\n    //     * undefined if we already had a value in place (reusing what we had)\n    //     * '-' if this is the first time we're deploying this stack (or upgrading from old to new bootstrap)\n    const currentKmsKeyId = current.parameters.FileAssetsBucketKmsKeyId;\n    const kmsKeyId =\n      params.kmsKeyId ??\n      (params.createCustomerMasterKey === true\n        ? CREATE_NEW_KEY\n        : params.createCustomerMasterKey === false || currentKmsKeyId === undefined\n          ? USE_AWS_MANAGED_KEY\n          : undefined);\n\n    /* A permissions boundary can be provided via:\n     *    - the flag indicating the example one should be used\n     *    - the name indicating the custom permissions boundary to be used\n     * Re-bootstrapping will NOT be blocked by either tightening or relaxing the permissions' boundary.\n     */\n\n    // InputPermissionsBoundary is an `any` type and if it is not defined it\n    // appears as an empty string ''. We need to force it to evaluate an empty string\n    // as undefined\n    const currentPermissionsBoundary: string | undefined = current.parameters.InputPermissionsBoundary || undefined;\n    const inputPolicyName = params.examplePermissionsBoundary\n      ? CDK_BOOTSTRAP_PERMISSIONS_BOUNDARY\n      : params.customPermissionsBoundary;\n    let policyName: string | undefined;\n    if (inputPolicyName) {\n      // If the example policy is not already in place, it must be created.\n      const sdk = (await sdkProvider.forEnvironment(environment, Mode.ForWriting)).sdk;\n      policyName = await this.getPolicyName(environment, sdk, inputPolicyName, partition, params);\n    }\n    if (currentPermissionsBoundary !== policyName) {\n      if (!currentPermissionsBoundary) {\n        await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_WARN.msg(\n          `Adding new permissions boundary ${policyName}`,\n        ));\n      } else if (!policyName) {\n        await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_WARN.msg(\n          `Removing existing permissions boundary ${currentPermissionsBoundary}`,\n        ));\n      } else {\n        await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_WARN.msg(\n          `Changing permissions boundary from ${currentPermissionsBoundary} to ${policyName}`,\n        ));\n      }\n    }\n\n    return current.update(\n      bootstrapTemplate,\n      {\n        FileAssetsBucketName: params.bucketName,\n        FileAssetsBucketKmsKeyId: kmsKeyId,\n        // Empty array becomes empty string\n        TrustedAccounts: trustedAccounts.join(','),\n        TrustedAccountsForLookup: trustedAccountsForLookup.join(','),\n        CloudFormationExecutionPolicies: cloudFormationExecutionPolicies.join(','),\n        Qualifier: params.qualifier,\n        PublicAccessBlockConfiguration:\n          params.publicAccessBlockConfiguration || params.publicAccessBlockConfiguration === undefined\n            ? 'true'\n            : 'false',\n        InputPermissionsBoundary: policyName,\n      },\n      {\n        ...options,\n        terminationProtection: options.terminationProtection ?? current.terminationProtection,\n      },\n    );\n  }\n\n  private async getPolicyName(\n    environment: cxapi.Environment,\n    sdk: SDK,\n    permissionsBoundary: string,\n    partition: string,\n    params: BootstrappingParameters,\n  ): Promise<string> {\n    if (permissionsBoundary !== CDK_BOOTSTRAP_PERMISSIONS_BOUNDARY) {\n      this.validatePolicyName(permissionsBoundary);\n      return Promise.resolve(permissionsBoundary);\n    }\n    // if no Qualifier is supplied, resort to the default one\n    const arn = await this.getExamplePermissionsBoundary(\n      params.qualifier ?? 'hnb659fds',\n      partition,\n      environment.account,\n      sdk,\n    );\n    const policyName = arn.split('/').pop();\n    if (!policyName) {\n      throw new ToolkitError('Could not retrieve the example permission boundary!');\n    }\n    return Promise.resolve(policyName);\n  }\n\n  private async getExamplePermissionsBoundary(\n    qualifier: string,\n    partition: string,\n    account: string,\n    sdk: SDK,\n  ): Promise<string> {\n    const iam = sdk.iam();\n\n    let policyName = `cdk-${qualifier}-permissions-boundary`;\n    const arn = `arn:${partition}:iam::${account}:policy/${policyName}`;\n\n    try {\n      let getPolicyResp = await iam.getPolicy({ PolicyArn: arn });\n      if (getPolicyResp.Policy) {\n        return arn;\n      }\n    } catch (e: any) {\n      // https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetPolicy.html#API_GetPolicy_Errors\n      if (e.name === 'NoSuchEntity') {\n        // noop, proceed with creating the policy\n      } else {\n        throw e;\n      }\n    }\n\n    const policyDoc = {\n      Version: '2012-10-17',\n      Statement: [\n        {\n          Action: ['*'],\n          Resource: '*',\n          Effect: 'Allow',\n          Sid: 'ExplicitAllowAll',\n        },\n        {\n          Condition: {\n            StringEquals: {\n              'iam:PermissionsBoundary': `arn:${partition}:iam::${account}:policy/cdk-${qualifier}-permissions-boundary`,\n            },\n          },\n          Action: [\n            'iam:CreateUser',\n            'iam:CreateRole',\n            'iam:PutRolePermissionsBoundary',\n            'iam:PutUserPermissionsBoundary',\n          ],\n          Resource: '*',\n          Effect: 'Allow',\n          Sid: 'DenyAccessIfRequiredPermBoundaryIsNotBeingApplied',\n        },\n        {\n          Action: [\n            'iam:CreatePolicyVersion',\n            'iam:DeletePolicy',\n            'iam:DeletePolicyVersion',\n            'iam:SetDefaultPolicyVersion',\n          ],\n          Resource: `arn:${partition}:iam::${account}:policy/cdk-${qualifier}-permissions-boundary`,\n          Effect: 'Deny',\n          Sid: 'DenyPermBoundaryIAMPolicyAlteration',\n        },\n        {\n          Action: ['iam:DeleteUserPermissionsBoundary', 'iam:DeleteRolePermissionsBoundary'],\n          Resource: '*',\n          Effect: 'Deny',\n          Sid: 'DenyRemovalOfPermBoundaryFromAnyUserOrRole',\n        },\n      ],\n    };\n    const request = {\n      PolicyName: policyName,\n      PolicyDocument: JSON.stringify(policyDoc),\n    };\n    const createPolicyResponse = await iam.createPolicy(request);\n    if (createPolicyResponse.Policy?.Arn) {\n      return createPolicyResponse.Policy.Arn;\n    } else {\n      throw new ToolkitError(`Could not retrieve the example permission boundary ${arn}!`);\n    }\n  }\n\n  private validatePolicyName(permissionsBoundary: string) {\n    // https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreatePolicy.html\n    // Added support for policy names with a path\n    // See https://github.com/aws/aws-cdk/issues/26320\n    const regexp: RegExp = /[\\w+\\/=,.@-]+/;\n    const matches = regexp.exec(permissionsBoundary);\n    if (!(matches && matches.length === 1 && matches[0] === permissionsBoundary)) {\n      throw new ToolkitError(`The permissions boundary name ${permissionsBoundary} does not match the IAM conventions.`);\n    }\n  }\n\n  private async customBootstrap(\n    environment: cxapi.Environment,\n    sdkProvider: SdkProvider,\n    options: BootstrapEnvironmentOptions = {},\n  ): Promise<SuccessfulDeployStackResult> {\n    // Look at the template, decide whether it's most likely a legacy or modern bootstrap\n    // template, and use the right bootstrapper for that.\n    const version = bootstrapVersionFromTemplate(await this.loadTemplate());\n    if (version === 0) {\n      return this.legacyBootstrap(environment, sdkProvider, options);\n    } else {\n      return this.modernBootstrap(environment, sdkProvider, options);\n    }\n  }\n\n  private async loadTemplate(params: BootstrappingParameters = {}): Promise<any> {\n    switch (this.source.source) {\n      case 'custom':\n        return loadStructuredFile(this.source.templateFile);\n      case 'default':\n        return loadStructuredFile(path.join(bundledPackageRootDir(__dirname), 'lib', 'api', 'bootstrap', 'bootstrap-template.yaml'));\n      case 'legacy':\n        return legacyBootstrapTemplate(params);\n    }\n  }\n}\n\n/**\n * Magic parameter value that will cause the bootstrap-template.yml to NOT create a CMK but use the default key\n */\nconst USE_AWS_MANAGED_KEY = 'AWS_MANAGED_KEY';\n\n/**\n * Magic parameter value that will cause the bootstrap-template.yml to create a CMK\n */\nconst CREATE_NEW_KEY = '';\n/**\n * Parameter value indicating the use of the default, CDK provided permissions boundary for bootstrap-template.yml\n */\nconst CDK_BOOTSTRAP_PERMISSIONS_BOUNDARY = 'CDK_BOOTSTRAP_PERMISSIONS_BOUNDARY';\n\n/**\n * Split an array-like CloudFormation parameter on ,\n *\n * An empty string is the empty array (instead of `['']`).\n */\nfunction splitCfnArray(xs: string | undefined): string[] {\n  if (xs === '' || xs === undefined) {\n    return [];\n  }\n  return xs.split(',');\n}\n\nfunction intersection<A>(xs: Set<A>, ys: Set<A>): Set<A> {\n  return new Set<A>(Array.from(xs).filter(x => ys.has(x)));\n}\n"]} \ No newline at end of file diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/bootstrap/bootstrap-props.d.ts b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/bootstrap/bootstrap-props.d.ts new file mode 100644 index 000000000..1240f55df --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/bootstrap/bootstrap-props.d.ts @@ -0,0 +1,130 @@ +import type { BootstrapSource } from './bootstrap-environment'; +import type { StringWithoutPlaceholders } from '../environment'; +import type { Tag } from '../tags'; +export declare const BUCKET_NAME_OUTPUT = "BucketName"; +export declare const REPOSITORY_NAME_OUTPUT = "ImageRepositoryName"; +export declare const BUCKET_DOMAIN_NAME_OUTPUT = "BucketDomainName"; +export declare const BOOTSTRAP_VERSION_OUTPUT = "BootstrapVersion"; +export declare const BOOTSTRAP_VERSION_RESOURCE = "CdkBootstrapVersion"; +export declare const BOOTSTRAP_VARIANT_PARAMETER = "BootstrapVariant"; +/** + * The assumed vendor of a template in case it is not set + */ +export declare const DEFAULT_BOOTSTRAP_VARIANT = "AWS CDK: Default Resources"; +/** + * Options for the bootstrapEnvironment operation(s) + */ +export interface BootstrapEnvironmentOptions { + readonly toolkitStackName?: string; + readonly roleArn?: StringWithoutPlaceholders; + readonly parameters?: BootstrappingParameters; + readonly forceDeployment?: boolean; + /** + * The source of the bootstrap stack + * + * @default - modern v2-style bootstrapping + */ + readonly source?: BootstrapSource; + /** + * Whether to execute the changeset or only create it and leave it in review. + * @default true + */ + readonly execute?: boolean; + /** + * Tags for cdktoolkit stack. + * + * @default - None. + */ + readonly tags?: Tag[]; + /** + * Whether the stacks created by the bootstrap process should be protected from termination. + * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-protect-stacks.html + * @default true + */ + readonly terminationProtection?: boolean; + /** + * Use previous values for unspecified parameters + * + * If not set, all parameters must be specified for every deployment. + * + * @default true + */ + usePreviousParameters?: boolean; +} +/** + * Parameters for the bootstrapping template + */ +export interface BootstrappingParameters { + /** + * The name to be given to the CDK Bootstrap bucket. + * + * @default - a name is generated by CloudFormation. + */ + readonly bucketName?: string; + /** + * The ID of an existing KMS key to be used for encrypting items in the bucket. + * + * @default - use the default KMS key or create a custom one + */ + readonly kmsKeyId?: string; + /** + * Whether or not to create a new customer master key (CMK) + * + * Only applies to modern bootstrapping. Legacy bootstrapping will never create + * a CMK, only use the default S3 key. + * + * @default false + */ + readonly createCustomerMasterKey?: boolean; + /** + * The list of AWS account IDs that are trusted to deploy into the environment being bootstrapped. + * + * @default - only the bootstrapped account can deploy into this environment + */ + readonly trustedAccounts?: string[]; + /** + * The list of AWS account IDs that are trusted to look up values in the environment being bootstrapped. + * + * @default - only the bootstrapped account can look up values in this environment + */ + readonly trustedAccountsForLookup?: string[]; + /** + * The list of AWS account IDs that should not be trusted by the bootstrapped environment. + * If these accounts are already trusted, they will be removed on bootstrapping. + * + * @default - no account will be untrusted. + */ + readonly untrustedAccounts?: string[]; + /** + * The ARNs of the IAM managed policies that should be attached to the role performing CloudFormation deployments. + * In most cases, this will be the AdministratorAccess policy. + * At least one policy is required if `trustedAccounts` were passed. + * + * @default - the role will have no policies attached + */ + readonly cloudFormationExecutionPolicies?: string[]; + /** + * Identifier to distinguish multiple bootstrapped environments + * + * @default - Default qualifier + */ + readonly qualifier?: string; + /** + * Whether or not to enable S3 Staging Bucket Public Access Block Configuration + * + * @default true + */ + readonly publicAccessBlockConfiguration?: boolean; + /** + * Flag for using the default permissions boundary for bootstrapping + * + * @default - No value, optional argument + */ + readonly examplePermissionsBoundary?: boolean; + /** + * Name for the customer's custom permissions boundary for bootstrapping + * + * @default - No value, optional argument + */ + readonly customPermissionsBoundary?: string; +} diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/bootstrap/bootstrap-props.js b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/bootstrap/bootstrap-props.js new file mode 100644 index 000000000..6dbcce56e --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/bootstrap/bootstrap-props.js @@ -0,0 +1,14 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.DEFAULT_BOOTSTRAP_VARIANT = exports.BOOTSTRAP_VARIANT_PARAMETER = exports.BOOTSTRAP_VERSION_RESOURCE = exports.BOOTSTRAP_VERSION_OUTPUT = exports.BUCKET_DOMAIN_NAME_OUTPUT = exports.REPOSITORY_NAME_OUTPUT = exports.BUCKET_NAME_OUTPUT = void 0; +exports.BUCKET_NAME_OUTPUT = 'BucketName'; +exports.REPOSITORY_NAME_OUTPUT = 'ImageRepositoryName'; +exports.BUCKET_DOMAIN_NAME_OUTPUT = 'BucketDomainName'; +exports.BOOTSTRAP_VERSION_OUTPUT = 'BootstrapVersion'; +exports.BOOTSTRAP_VERSION_RESOURCE = 'CdkBootstrapVersion'; +exports.BOOTSTRAP_VARIANT_PARAMETER = 'BootstrapVariant'; +/** + * The assumed vendor of a template in case it is not set + */ +exports.DEFAULT_BOOTSTRAP_VARIANT = 'AWS CDK: Default Resources'; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/bootstrap/bootstrap-template.yaml b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/bootstrap/bootstrap-template.yaml new file mode 100644 index 000000000..a1cf2b346 --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/bootstrap/bootstrap-template.yaml @@ -0,0 +1,707 @@ +Description: This stack includes resources needed to deploy AWS CDK apps into this + environment +Parameters: + TrustedAccounts: + Description: List of AWS accounts that are trusted to publish assets and deploy + stacks to this environment + Default: '' + Type: CommaDelimitedList + TrustedAccountsForLookup: + Description: List of AWS accounts that are trusted to look up values in this + environment + Default: '' + Type: CommaDelimitedList + CloudFormationExecutionPolicies: + Description: List of the ManagedPolicy ARN(s) to attach to the CloudFormation + deployment role + Default: '' + Type: CommaDelimitedList + FileAssetsBucketName: + Description: The name of the S3 bucket used for file assets + Default: '' + Type: String + FileAssetsBucketKmsKeyId: + Description: Empty to create a new key (default), 'AWS_MANAGED_KEY' to use a managed + S3 key, or the ID/ARN of an existing key. + Default: '' + Type: String + ContainerAssetsRepositoryName: + Description: A user-provided custom name to use for the container assets ECR repository + Default: '' + Type: String + Qualifier: + Description: An identifier to distinguish multiple bootstrap stacks in the same environment + Default: hnb659fds + Type: String + # "cdk-(qualifier)-image-publishing-role-(account)-(region)" needs to be <= 64 chars + # account = 12, region <= 14, 10 chars for qualifier and 28 for rest of role name + AllowedPattern: "[A-Za-z0-9_-]{1,10}" + ConstraintDescription: Qualifier must be an alphanumeric identifier of at most 10 characters + PublicAccessBlockConfiguration: + Description: Whether or not to enable S3 Staging Bucket Public Access Block Configuration + Default: 'true' + Type: 'String' + AllowedValues: ['true', 'false'] + InputPermissionsBoundary: + Description: Whether or not to use either the CDK supplied or custom permissions boundary + Default: '' + Type: 'String' + UseExamplePermissionsBoundary: + Default: 'false' + AllowedValues: [ 'true', 'false' ] + Type: String + BootstrapVariant: + Type: String + Default: 'AWS CDK: Default Resources' + Description: Describe the provenance of the resources in this bootstrap + stack. Change this when you customize the template. To prevent accidents, + the CDK CLI will not overwrite bootstrap stacks with a different variant. +Conditions: + HasTrustedAccounts: + Fn::Not: + - Fn::Equals: + - '' + - Fn::Join: + - '' + - Ref: TrustedAccounts + HasTrustedAccountsForLookup: + Fn::Not: + - Fn::Equals: + - '' + - Fn::Join: + - '' + - Ref: TrustedAccountsForLookup + HasCloudFormationExecutionPolicies: + Fn::Not: + - Fn::Equals: + - '' + - Fn::Join: + - '' + - Ref: CloudFormationExecutionPolicies + HasCustomFileAssetsBucketName: + Fn::Not: + - Fn::Equals: + - '' + - Ref: FileAssetsBucketName + CreateNewKey: + Fn::Equals: + - '' + - Ref: FileAssetsBucketKmsKeyId + UseAwsManagedKey: + Fn::Equals: + - 'AWS_MANAGED_KEY' + - Ref: FileAssetsBucketKmsKeyId + ShouldCreatePermissionsBoundary: + Fn::Equals: + - 'true' + - Ref: UseExamplePermissionsBoundary + PermissionsBoundarySet: + Fn::Not: + - Fn::Equals: + - '' + - Ref: InputPermissionsBoundary + HasCustomContainerAssetsRepositoryName: + Fn::Not: + - Fn::Equals: + - '' + - Ref: ContainerAssetsRepositoryName + UsePublicAccessBlockConfiguration: + Fn::Equals: + - 'true' + - Ref: PublicAccessBlockConfiguration +Resources: + FileAssetsBucketEncryptionKey: + Type: AWS::KMS::Key + Properties: + KeyPolicy: + Statement: + - Action: + - kms:Create* + - kms:Describe* + - kms:Enable* + - kms:List* + - kms:Put* + - kms:Update* + - kms:Revoke* + - kms:Disable* + - kms:Get* + - kms:Delete* + - kms:ScheduleKeyDeletion + - kms:CancelKeyDeletion + - kms:GenerateDataKey + - kms:TagResource + - kms:UntagResource + Effect: Allow + Principal: + AWS: + Ref: AWS::AccountId + Resource: "*" + - Action: + - kms:Decrypt + - kms:DescribeKey + - kms:Encrypt + - kms:ReEncrypt* + - kms:GenerateDataKey* + Effect: Allow + Principal: + # Not actually everyone -- see below for Conditions + AWS: "*" + Resource: "*" + Condition: + StringEquals: + # See https://docs.aws.amazon.com/kms/latest/developerguide/policy-conditions.html#conditions-kms-caller-account + kms:CallerAccount: + Ref: AWS::AccountId + kms:ViaService: + - Fn::Sub: s3.${AWS::Region}.amazonaws.com + - Action: + - kms:Decrypt + - kms:DescribeKey + - kms:Encrypt + - kms:ReEncrypt* + - kms:GenerateDataKey* + Effect: Allow + Principal: + AWS: + Fn::Sub: "${FilePublishingRole.Arn}" + Resource: "*" + Condition: CreateNewKey + UpdateReplacePolicy: Delete + DeletionPolicy: Delete + FileAssetsBucketEncryptionKeyAlias: + Condition: CreateNewKey + Type: AWS::KMS::Alias + Properties: + AliasName: + Fn::Sub: "alias/cdk-${Qualifier}-assets-key" + TargetKeyId: + Ref: FileAssetsBucketEncryptionKey + StagingBucket: + Type: AWS::S3::Bucket + Properties: + BucketName: + Fn::If: + - HasCustomFileAssetsBucketName + - Fn::Sub: "${FileAssetsBucketName}" + - Fn::Sub: cdk-${Qualifier}-assets-${AWS::AccountId}-${AWS::Region} + AccessControl: Private + BucketEncryption: + ServerSideEncryptionConfiguration: + - ServerSideEncryptionByDefault: + SSEAlgorithm: aws:kms + KMSMasterKeyID: + Fn::If: + - CreateNewKey + - Fn::Sub: "${FileAssetsBucketEncryptionKey.Arn}" + - Fn::If: + - UseAwsManagedKey + - Ref: AWS::NoValue + - Fn::Sub: "${FileAssetsBucketKmsKeyId}" + PublicAccessBlockConfiguration: + Fn::If: + - UsePublicAccessBlockConfiguration + - BlockPublicAcls: true + BlockPublicPolicy: true + IgnorePublicAcls: true + RestrictPublicBuckets: true + - Ref: AWS::NoValue + VersioningConfiguration: + Status: Enabled + LifecycleConfiguration: + Rules: + # Objects will only be noncurrent if they are deleted via garbage collection. + - Id: CleanupOldVersions + Status: Enabled + NoncurrentVersionExpiration: + NoncurrentDays: 30 + - Id: AbortIncompleteMultipartUploads + Status: Enabled + AbortIncompleteMultipartUpload: + DaysAfterInitiation: 1 + UpdateReplacePolicy: Retain + DeletionPolicy: Retain + StagingBucketPolicy: + Type: 'AWS::S3::BucketPolicy' + Properties: + Bucket: { Ref: 'StagingBucket' } + PolicyDocument: + Id: 'AccessControl' + Version: '2012-10-17' + Statement: + - Sid: 'AllowSSLRequestsOnly' + Action: 's3:*' + Effect: 'Deny' + Resource: + - { 'Fn::Sub': '${StagingBucket.Arn}' } + - { 'Fn::Sub': '${StagingBucket.Arn}/*' } + Condition: + Bool: { 'aws:SecureTransport': 'false' } + Principal: '*' + ContainerAssetsRepository: + Type: AWS::ECR::Repository + Properties: + ImageTagMutability: IMMUTABLE + # Untagged images should never exist but Security Hub wants this rule to exist + LifecyclePolicy: + LifecyclePolicyText: | + { + "rules": [ + { + "rulePriority": 1, + "description": "Untagged images should not exist, but expire any older than one year", + "selection": { + "tagStatus": "untagged", + "countType": "sinceImagePushed", + "countUnit": "days", + "countNumber": 365 + }, + "action": { "type": "expire" } + } + ] + } + RepositoryName: + Fn::If: + - HasCustomContainerAssetsRepositoryName + - Fn::Sub: "${ContainerAssetsRepositoryName}" + - Fn::Sub: cdk-${Qualifier}-container-assets-${AWS::AccountId}-${AWS::Region} + RepositoryPolicyText: + Version: "2012-10-17" + Statement: + # Necessary for Lambda container images + # https://docs.aws.amazon.com/lambda/latest/dg/configuration-images.html#configuration-images-permissions + - Sid: LambdaECRImageRetrievalPolicy + Effect: Allow + Principal: { Service: "lambda.amazonaws.com" } + Action: + - ecr:BatchGetImage + - ecr:GetDownloadUrlForLayer + Condition: + StringLike: + "aws:sourceArn": { "Fn::Sub": "arn:${AWS::Partition}:lambda:${AWS::Region}:${AWS::AccountId}:function:*" } + # Necessary for EMR Serverless container images + # https://docs.aws.amazon.com/emr/latest/EMR-Serverless-UserGuide/application-custom-image.html#access-repo + - Sid: EmrServerlessImageRetrievalPolicy + Effect: Allow + Principal: + Service: emr-serverless.amazonaws.com + Action: + - ecr:BatchGetImage + - ecr:GetDownloadUrlForLayer + - ecr:DescribeImages + Condition: + StringLike: + "aws:sourceArn": { "Fn::Sub": "arn:${AWS::Partition}:emr-serverless:${AWS::Region}:${AWS::AccountId}:/applications/*" } + FilePublishingRole: + Type: AWS::IAM::Role + Properties: + AssumeRolePolicyDocument: + Statement: + # allows this role to be assumed with session tags. + # see https://docs.aws.amazon.com/IAM/latest/UserGuide/id_session-tags.html#id_session-tags_permissions-required + - Action: sts:TagSession + Effect: Allow + Principal: + AWS: + Ref: AWS::AccountId + - Action: sts:AssumeRole + Effect: Allow + Principal: + AWS: + Ref: AWS::AccountId + - Fn::If: + - HasTrustedAccounts + - Action: sts:AssumeRole + Effect: Allow + Principal: + AWS: + Ref: TrustedAccounts + - Ref: AWS::NoValue + RoleName: + Fn::Sub: cdk-${Qualifier}-file-publishing-role-${AWS::AccountId}-${AWS::Region} + Tags: + - Key: aws-cdk:bootstrap-role + Value: file-publishing + ImagePublishingRole: + Type: AWS::IAM::Role + Properties: + AssumeRolePolicyDocument: + Statement: + # allows this role to be assumed with session tags. + # see https://docs.aws.amazon.com/IAM/latest/UserGuide/id_session-tags.html#id_session-tags_permissions-required + - Action: sts:TagSession + Effect: Allow + Principal: + AWS: + Ref: AWS::AccountId + - Action: sts:AssumeRole + Effect: Allow + Principal: + AWS: + Ref: AWS::AccountId + - Fn::If: + - HasTrustedAccounts + - Action: sts:AssumeRole + Effect: Allow + Principal: + AWS: + Ref: TrustedAccounts + - Ref: AWS::NoValue + RoleName: + Fn::Sub: cdk-${Qualifier}-image-publishing-role-${AWS::AccountId}-${AWS::Region} + Tags: + - Key: aws-cdk:bootstrap-role + Value: image-publishing + LookupRole: + Type: AWS::IAM::Role + Properties: + AssumeRolePolicyDocument: + Statement: + # allows this role to be assumed with session tags. + # see https://docs.aws.amazon.com/IAM/latest/UserGuide/id_session-tags.html#id_session-tags_permissions-required + - Action: sts:TagSession + Effect: Allow + Principal: + AWS: + Ref: AWS::AccountId + - Action: sts:AssumeRole + Effect: Allow + Principal: + AWS: + Ref: AWS::AccountId + - Fn::If: + - HasTrustedAccountsForLookup + - Action: sts:AssumeRole + Effect: Allow + Principal: + AWS: + Ref: TrustedAccountsForLookup + - Ref: AWS::NoValue + - Fn::If: + - HasTrustedAccounts + - Action: sts:AssumeRole + Effect: Allow + Principal: + AWS: + Ref: TrustedAccounts + - Ref: AWS::NoValue + RoleName: + Fn::Sub: cdk-${Qualifier}-lookup-role-${AWS::AccountId}-${AWS::Region} + ManagedPolicyArns: + - Fn::Sub: "arn:${AWS::Partition}:iam::aws:policy/ReadOnlyAccess" + Policies: + - PolicyDocument: + Statement: + - Sid: DontReadSecrets + Effect: Deny + Action: + - kms:Decrypt + Resource: "*" + Version: '2012-10-17' + PolicyName: LookupRolePolicy + Tags: + - Key: aws-cdk:bootstrap-role + Value: lookup + FilePublishingRoleDefaultPolicy: + Type: AWS::IAM::Policy + Properties: + PolicyDocument: + Statement: + - Action: + - s3:GetObject* + - s3:GetBucket* + - s3:GetEncryptionConfiguration + - s3:List* + - s3:DeleteObject* + - s3:PutObject* + - s3:Abort* + Resource: + - Fn::Sub: "${StagingBucket.Arn}" + - Fn::Sub: "${StagingBucket.Arn}/*" + Condition: + StringEquals: + aws:ResourceAccount: + - Fn::Sub: ${AWS::AccountId} + Effect: Allow + - Action: + - kms:Decrypt + - kms:DescribeKey + - kms:Encrypt + - kms:ReEncrypt* + - kms:GenerateDataKey* + Effect: Allow + Resource: + Fn::If: + - CreateNewKey + - Fn::Sub: "${FileAssetsBucketEncryptionKey.Arn}" + - Fn::Sub: arn:${AWS::Partition}:kms:${AWS::Region}:${AWS::AccountId}:key/${FileAssetsBucketKmsKeyId} + Version: '2012-10-17' + Roles: + - Ref: FilePublishingRole + PolicyName: + Fn::Sub: cdk-${Qualifier}-file-publishing-role-default-policy-${AWS::AccountId}-${AWS::Region} + ImagePublishingRoleDefaultPolicy: + Type: AWS::IAM::Policy + Properties: + PolicyDocument: + Statement: + - Action: + - ecr:PutImage + - ecr:InitiateLayerUpload + - ecr:UploadLayerPart + - ecr:CompleteLayerUpload + - ecr:BatchCheckLayerAvailability + - ecr:DescribeRepositories + - ecr:DescribeImages + - ecr:BatchGetImage + - ecr:GetDownloadUrlForLayer + Resource: + Fn::Sub: "${ContainerAssetsRepository.Arn}" + Effect: Allow + - Action: + - ecr:GetAuthorizationToken + Resource: "*" + Effect: Allow + Version: '2012-10-17' + Roles: + - Ref: ImagePublishingRole + PolicyName: + Fn::Sub: cdk-${Qualifier}-image-publishing-role-default-policy-${AWS::AccountId}-${AWS::Region} + DeploymentActionRole: + Type: AWS::IAM::Role + Properties: + AssumeRolePolicyDocument: + Statement: + # allows this role to be assumed with session tags. + # see https://docs.aws.amazon.com/IAM/latest/UserGuide/id_session-tags.html#id_session-tags_permissions-required + - Action: sts:TagSession + Effect: Allow + Principal: + AWS: + Ref: AWS::AccountId + - Action: sts:AssumeRole + Effect: Allow + Principal: + AWS: + Ref: AWS::AccountId + - Fn::If: + - HasTrustedAccounts + - Action: sts:AssumeRole + Effect: Allow + Principal: + AWS: + Ref: TrustedAccounts + - Ref: AWS::NoValue + Policies: + - PolicyDocument: + Statement: + - Sid: CloudFormationPermissions + Effect: Allow + Action: + - cloudformation:CreateChangeSet + - cloudformation:DeleteChangeSet + - cloudformation:DescribeChangeSet + - cloudformation:DescribeStacks + - cloudformation:ExecuteChangeSet + - cloudformation:CreateStack + - cloudformation:UpdateStack + - cloudformation:RollbackStack + - cloudformation:ContinueUpdateRollback + Resource: "*" + - Sid: PipelineCrossAccountArtifactsBucket + # Read/write buckets in different accounts. Permissions to buckets in + # same account are granted by bucket policies. + # + # Write permissions necessary to write outputs to the cross-region artifact replication bucket + # https://aws.amazon.com/premiumsupport/knowledge-center/codepipeline-deploy-cloudformation/. + Effect: Allow + Action: + - s3:GetObject* + - s3:GetBucket* + - s3:List* + - s3:Abort* + - s3:DeleteObject* + - s3:PutObject* + Resource: "*" + Condition: + StringNotEquals: + s3:ResourceAccount: + Ref: 'AWS::AccountId' + - Sid: PipelineCrossAccountArtifactsKey + # Use keys only for the purposes of reading encrypted files from S3. + Effect: Allow + Action: + - kms:Decrypt + - kms:DescribeKey + - kms:Encrypt + - kms:ReEncrypt* + - kms:GenerateDataKey* + Resource: "*" + Condition: + StringEquals: + kms:ViaService: + Fn::Sub: s3.${AWS::Region}.amazonaws.com + - Action: iam:PassRole + Resource: + Fn::Sub: "${CloudFormationExecutionRole.Arn}" + Effect: Allow + - Sid: CliPermissions + Action: + # Permissions needed by the CLI when doing `cdk deploy`. + # Our CI/CD does not need DeleteStack, + # but we also want to use this role from the CLI, + # and there you can call `cdk destroy` + - cloudformation:DescribeStackEvents + - cloudformation:GetTemplate + - cloudformation:DeleteStack + - cloudformation:UpdateTerminationProtection + - sts:GetCallerIdentity + # `cdk import` + - cloudformation:GetTemplateSummary + Resource: "*" + Effect: Allow + - Sid: CliStagingBucket + Effect: Allow + Action: + - s3:GetObject* + - s3:GetBucket* + - s3:List* + Resource: + - Fn::Sub: ${StagingBucket.Arn} + - Fn::Sub: ${StagingBucket.Arn}/* + - Sid: ReadVersion + Effect: Allow + Action: + - ssm:GetParameter + - ssm:GetParameters # CreateChangeSet uses this to evaluate any SSM parameters (like `CdkBootstrapVersion`) + Resource: + - Fn::Sub: "arn:${AWS::Partition}:ssm:${AWS::Region}:${AWS::AccountId}:parameter${CdkBootstrapVersion}" + Version: '2012-10-17' + PolicyName: default + RoleName: + Fn::Sub: cdk-${Qualifier}-deploy-role-${AWS::AccountId}-${AWS::Region} + Tags: + - Key: aws-cdk:bootstrap-role + Value: deploy + CloudFormationExecutionRole: + Type: AWS::IAM::Role + Properties: + AssumeRolePolicyDocument: + Statement: + - Action: sts:AssumeRole + Effect: Allow + Principal: + Service: cloudformation.amazonaws.com + Version: '2012-10-17' + ManagedPolicyArns: + Fn::If: + - HasCloudFormationExecutionPolicies + - Ref: CloudFormationExecutionPolicies + - Fn::If: + - HasTrustedAccounts + # The CLI will prevent this case from occurring + - Ref: AWS::NoValue + # The CLI will advertise that we picked this implicitly + - - Fn::Sub: "arn:${AWS::Partition}:iam::aws:policy/AdministratorAccess" + RoleName: + Fn::Sub: cdk-${Qualifier}-cfn-exec-role-${AWS::AccountId}-${AWS::Region} + PermissionsBoundary: + Fn::If: + - PermissionsBoundarySet + - Fn::Sub: 'arn:${AWS::Partition}:iam::${AWS::AccountId}:policy/${InputPermissionsBoundary}' + - Ref: AWS::NoValue + CdkBoostrapPermissionsBoundaryPolicy: + # Edit the template prior to boostrap in order to have this example policy created + Condition: ShouldCreatePermissionsBoundary + Type: AWS::IAM::ManagedPolicy + Properties: + PolicyDocument: + Statement: + # If permission boundaries do not have an explicit `allow`, then the effect is `deny` + - Sid: ExplicitAllowAll + Action: + - "*" + Effect: Allow + Resource: "*" + # Default permissions to prevent privilege escalation + - Sid: DenyAccessIfRequiredPermBoundaryIsNotBeingApplied + Action: + - iam:CreateUser + - iam:CreateRole + - iam:PutRolePermissionsBoundary + - iam:PutUserPermissionsBoundary + Condition: + StringNotEquals: + iam:PermissionsBoundary: + Fn::Sub: arn:${AWS::Partition}:iam::${AWS::AccountId}:policy/cdk-${Qualifier}-permissions-boundary-${AWS::AccountId}-${AWS::Region} + Effect: Deny + Resource: "*" + # Forbid the policy itself being edited + - Sid: DenyPermBoundaryIAMPolicyAlteration + Action: + - iam:CreatePolicyVersion + - iam:DeletePolicy + - iam:DeletePolicyVersion + - iam:SetDefaultPolicyVersion + Effect: Deny + Resource: + Fn::Sub: arn:${AWS::Partition}:iam::${AWS::AccountId}:policy/cdk-${Qualifier}-permissions-boundary-${AWS::AccountId}-${AWS::Region} + # Forbid removing the permissions boundary from any user or role that has it associated + - Sid: DenyRemovalOfPermBoundaryFromAnyUserOrRole + Action: + - iam:DeleteUserPermissionsBoundary + - iam:DeleteRolePermissionsBoundary + Effect: Deny + Resource: "*" + # Add your specific organizational security policy here + # Uncomment the example to deny access to AWS Config + #- Sid: OrganizationalSecurityPolicy + # Action: + # - "config:*" + # Effect: Deny + # Resource: "*" + Version: "2012-10-17" + Description: "Bootstrap Permission Boundary" + ManagedPolicyName: + Fn::Sub: cdk-${Qualifier}-permissions-boundary-${AWS::AccountId}-${AWS::Region} + Path: / + # The SSM parameter is used in pipeline-deployed templates to verify the version + # of the bootstrap resources. + CdkBootstrapVersion: + Type: AWS::SSM::Parameter + Properties: + Type: String + Name: + Fn::Sub: '/cdk-bootstrap/${Qualifier}/version' + Value: '27' +Outputs: + BucketName: + Description: The name of the S3 bucket owned by the CDK toolkit stack + Value: + Fn::Sub: "${StagingBucket}" + BucketDomainName: + Description: The domain name of the S3 bucket owned by the CDK toolkit stack + Value: + Fn::Sub: "${StagingBucket.RegionalDomainName}" + # @deprecated - This Export can be removed at some future point in time. + # We can't do it today because if there are stacks that use it, the bootstrap + # stack cannot be updated. Not used anymore by apps >= 1.60.0 + FileAssetKeyArn: + Description: The ARN of the KMS key used to encrypt the asset bucket (deprecated) + Value: + Fn::If: + - CreateNewKey + - Fn::Sub: "${FileAssetsBucketEncryptionKey.Arn}" + - Fn::Sub: "${FileAssetsBucketKmsKeyId}" + Export: + Name: + Fn::Sub: CdkBootstrap-${Qualifier}-FileAssetKeyArn + ImageRepositoryName: + Description: The name of the ECR repository which hosts docker image assets + Value: + Fn::Sub: "${ContainerAssetsRepository}" + # The Output is used by the CLI to verify the version of the bootstrap resources. + BootstrapVersion: + Description: The version of the bootstrap resources that are currently mastered + in this stack + Value: + Fn::GetAtt: [CdkBootstrapVersion, Value] diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/bootstrap/deploy-bootstrap.d.ts b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/bootstrap/deploy-bootstrap.d.ts new file mode 100644 index 000000000..a7bfd1b4c --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/bootstrap/deploy-bootstrap.d.ts @@ -0,0 +1,39 @@ +import type { Environment } from '@aws-cdk/cx-api'; +import type { BootstrapEnvironmentOptions } from './bootstrap-props'; +import type { SDK, SdkProvider } from '../aws-auth'; +import type { SuccessfulDeployStackResult } from '../deployments'; +import { type IoHelper } from '../io/private'; +import { ToolkitInfo } from '../toolkit-info'; +/** + * A class to hold state around stack bootstrapping + * + * This class exists so we can break bootstrapping into 2 phases: + * + * ```ts + * const current = BootstrapStack.lookup(...); + * // ... + * current.update(newTemplate, ...); + * ``` + * + * And do something in between the two phases (such as look at the + * current bootstrap stack and doing something intelligent). + */ +export declare class BootstrapStack { + private readonly sdkProvider; + private readonly sdk; + private readonly resolvedEnvironment; + private readonly toolkitStackName; + private readonly currentToolkitInfo; + private readonly ioHelper; + static lookup(sdkProvider: SdkProvider, environment: Environment, toolkitStackName: string, ioHelper: IoHelper): Promise; + protected constructor(sdkProvider: SdkProvider, sdk: SDK, resolvedEnvironment: Environment, toolkitStackName: string, currentToolkitInfo: ToolkitInfo, ioHelper: IoHelper); + get parameters(): Record; + get terminationProtection(): boolean | undefined; + partition(): Promise; + /** + * Perform the actual deployment of a bootstrap stack, given a template and some parameters + */ + update(template: any, parameters: Record, options: Omit): Promise; +} +export declare function bootstrapVersionFromTemplate(template: any): number; +export declare function bootstrapVariantFromTemplate(template: any): string; diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/bootstrap/deploy-bootstrap.js b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/bootstrap/deploy-bootstrap.js new file mode 100644 index 000000000..b0aa14c62 --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/bootstrap/deploy-bootstrap.js @@ -0,0 +1,147 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.BootstrapStack = void 0; +exports.bootstrapVersionFromTemplate = bootstrapVersionFromTemplate; +exports.bootstrapVariantFromTemplate = bootstrapVariantFromTemplate; +const os = require("os"); +const path = require("path"); +const cloud_assembly_schema_1 = require("@aws-cdk/cloud-assembly-schema"); +const cx_api_1 = require("@aws-cdk/cx-api"); +const fs = require("fs-extra"); +const bootstrap_props_1 = require("./bootstrap-props"); +const deployments_1 = require("../deployments"); +const deploy_stack_1 = require("../deployments/deploy-stack"); +const environment_1 = require("../environment"); +const private_1 = require("../io/private"); +const plugin_1 = require("../plugin"); +const toolkit_info_1 = require("../toolkit-info"); +/** + * A class to hold state around stack bootstrapping + * + * This class exists so we can break bootstrapping into 2 phases: + * + * ```ts + * const current = BootstrapStack.lookup(...); + * // ... + * current.update(newTemplate, ...); + * ``` + * + * And do something in between the two phases (such as look at the + * current bootstrap stack and doing something intelligent). + */ +class BootstrapStack { + sdkProvider; + sdk; + resolvedEnvironment; + toolkitStackName; + currentToolkitInfo; + ioHelper; + static async lookup(sdkProvider, environment, toolkitStackName, ioHelper) { + toolkitStackName = toolkitStackName ?? toolkit_info_1.DEFAULT_TOOLKIT_STACK_NAME; + const resolvedEnvironment = await sdkProvider.resolveEnvironment(environment); + const sdk = (await sdkProvider.forEnvironment(resolvedEnvironment, plugin_1.Mode.ForWriting)).sdk; + const currentToolkitInfo = await toolkit_info_1.ToolkitInfo.lookup(resolvedEnvironment, sdk, ioHelper, toolkitStackName); + return new BootstrapStack(sdkProvider, sdk, resolvedEnvironment, toolkitStackName, currentToolkitInfo, ioHelper); + } + constructor(sdkProvider, sdk, resolvedEnvironment, toolkitStackName, currentToolkitInfo, ioHelper) { + this.sdkProvider = sdkProvider; + this.sdk = sdk; + this.resolvedEnvironment = resolvedEnvironment; + this.toolkitStackName = toolkitStackName; + this.currentToolkitInfo = currentToolkitInfo; + this.ioHelper = ioHelper; + } + get parameters() { + return this.currentToolkitInfo.found ? this.currentToolkitInfo.bootstrapStack.parameters : {}; + } + get terminationProtection() { + return this.currentToolkitInfo.found ? this.currentToolkitInfo.bootstrapStack.terminationProtection : undefined; + } + async partition() { + return (await this.sdk.currentAccount()).partition; + } + /** + * Perform the actual deployment of a bootstrap stack, given a template and some parameters + */ + async update(template, parameters, options) { + if (this.currentToolkitInfo.found && !options.forceDeployment) { + // Safety checks + const abortResponse = { + type: 'did-deploy-stack', + noOp: true, + outputs: {}, + stackArn: this.currentToolkitInfo.bootstrapStack.stackId, + }; + // Validate that the bootstrap stack we're trying to replace is from the same variant as the one we're trying to deploy + const currentVariant = this.currentToolkitInfo.variant; + const newVariant = bootstrapVariantFromTemplate(template); + if (currentVariant !== newVariant) { + await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_WARN.msg(`Bootstrap stack already exists, containing '${currentVariant}'. Not overwriting it with a template containing '${newVariant}' (use --force if you intend to overwrite)`)); + return abortResponse; + } + // Validate that we're not downgrading the bootstrap stack + const newVersion = bootstrapVersionFromTemplate(template); + const currentVersion = this.currentToolkitInfo.version; + if (newVersion < currentVersion) { + await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_WARN.msg(`Bootstrap stack already at version ${currentVersion}. Not downgrading it to version ${newVersion} (use --force if you intend to downgrade)`)); + if (newVersion === 0) { + // A downgrade with 0 as target version means we probably have a new-style bootstrap in the account, + // and an old-style bootstrap as current target, which means the user probably forgot to put this flag in. + await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_WARN.msg("(Did you set the '@aws-cdk/core:newStyleStackSynthesis' feature flag in cdk.json?)")); + } + return abortResponse; + } + } + const outdir = await fs.mkdtemp(path.join(os.tmpdir(), 'cdk-bootstrap')); + const builder = new cx_api_1.CloudAssemblyBuilder(outdir); + const templateFile = `${this.toolkitStackName}.template.json`; + await fs.writeJson(path.join(builder.outdir, templateFile), template, { + spaces: 2, + }); + builder.addArtifact(this.toolkitStackName, { + type: cloud_assembly_schema_1.ArtifactType.AWS_CLOUDFORMATION_STACK, + environment: cx_api_1.EnvironmentUtils.format(this.resolvedEnvironment.account, this.resolvedEnvironment.region), + properties: { + templateFile, + terminationProtection: options.terminationProtection ?? false, + }, + }); + const assembly = builder.buildAssembly(); + const ret = await (0, deploy_stack_1.deployStack)({ + stack: assembly.getStackByName(this.toolkitStackName), + resolvedEnvironment: this.resolvedEnvironment, + sdk: this.sdk, + sdkProvider: this.sdkProvider, + forceDeployment: options.forceDeployment, + roleArn: options.roleArn, + tags: options.tags, + deploymentMethod: { method: 'change-set', execute: options.execute }, + parameters, + usePreviousParameters: options.usePreviousParameters ?? true, + // Obviously we can't need a bootstrap stack to deploy a bootstrap stack + envResources: new environment_1.NoBootstrapStackEnvironmentResources(this.resolvedEnvironment, this.sdk, this.ioHelper), + }, this.ioHelper); + (0, deployments_1.assertIsSuccessfulDeployStackResult)(ret); + return ret; + } +} +exports.BootstrapStack = BootstrapStack; +function bootstrapVersionFromTemplate(template) { + const versionSources = [ + template.Outputs?.[bootstrap_props_1.BOOTSTRAP_VERSION_OUTPUT]?.Value, + template.Resources?.[bootstrap_props_1.BOOTSTRAP_VERSION_RESOURCE]?.Properties?.Value, + ]; + for (const vs of versionSources) { + if (typeof vs === 'number') { + return vs; + } + if (typeof vs === 'string' && !isNaN(parseInt(vs, 10))) { + return parseInt(vs, 10); + } + } + return 0; +} +function bootstrapVariantFromTemplate(template) { + return template.Parameters?.[bootstrap_props_1.BOOTSTRAP_VARIANT_PARAMETER]?.Default ?? bootstrap_props_1.DEFAULT_BOOTSTRAP_VARIANT; +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"deploy-bootstrap.js","sourceRoot":"","sources":["../../../src/api/bootstrap/deploy-bootstrap.ts"],"names":[],"mappings":"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","sourcesContent":["import * as os from 'os';\nimport * as path from 'path';\nimport { ArtifactType } from '@aws-cdk/cloud-assembly-schema';\nimport type { Environment } from '@aws-cdk/cx-api';\nimport { CloudAssemblyBuilder, EnvironmentUtils } from '@aws-cdk/cx-api';\nimport * as fs from 'fs-extra';\nimport type { BootstrapEnvironmentOptions } from './bootstrap-props';\nimport {\n  BOOTSTRAP_VARIANT_PARAMETER,\n  BOOTSTRAP_VERSION_OUTPUT,\n  BOOTSTRAP_VERSION_RESOURCE,\n  DEFAULT_BOOTSTRAP_VARIANT,\n} from './bootstrap-props';\nimport type { SDK, SdkProvider } from '../aws-auth';\nimport type { SuccessfulDeployStackResult } from '../deployments';\nimport { assertIsSuccessfulDeployStackResult } from '../deployments';\nimport { deployStack } from '../deployments/deploy-stack';\nimport { NoBootstrapStackEnvironmentResources } from '../environment';\nimport { IO, type IoHelper } from '../io/private';\nimport { Mode } from '../plugin';\nimport { DEFAULT_TOOLKIT_STACK_NAME, ToolkitInfo } from '../toolkit-info';\n\n/**\n * A class to hold state around stack bootstrapping\n *\n * This class exists so we can break bootstrapping into 2 phases:\n *\n * ```ts\n * const current = BootstrapStack.lookup(...);\n * // ...\n * current.update(newTemplate, ...);\n * ```\n *\n * And do something in between the two phases (such as look at the\n * current bootstrap stack and doing something intelligent).\n */\nexport class BootstrapStack {\n  public static async lookup(sdkProvider: SdkProvider, environment: Environment, toolkitStackName: string, ioHelper: IoHelper) {\n    toolkitStackName = toolkitStackName ?? DEFAULT_TOOLKIT_STACK_NAME;\n\n    const resolvedEnvironment = await sdkProvider.resolveEnvironment(environment);\n    const sdk = (await sdkProvider.forEnvironment(resolvedEnvironment, Mode.ForWriting)).sdk;\n\n    const currentToolkitInfo = await ToolkitInfo.lookup(resolvedEnvironment, sdk, ioHelper, toolkitStackName);\n\n    return new BootstrapStack(sdkProvider, sdk, resolvedEnvironment, toolkitStackName, currentToolkitInfo, ioHelper);\n  }\n\n  protected constructor(\n    private readonly sdkProvider: SdkProvider,\n    private readonly sdk: SDK,\n    private readonly resolvedEnvironment: Environment,\n    private readonly toolkitStackName: string,\n    private readonly currentToolkitInfo: ToolkitInfo,\n    private readonly ioHelper: IoHelper,\n  ) {\n  }\n\n  public get parameters(): Record<string, string> {\n    return this.currentToolkitInfo.found ? this.currentToolkitInfo.bootstrapStack.parameters : {};\n  }\n\n  public get terminationProtection() {\n    return this.currentToolkitInfo.found ? this.currentToolkitInfo.bootstrapStack.terminationProtection : undefined;\n  }\n\n  public async partition(): Promise<string> {\n    return (await this.sdk.currentAccount()).partition;\n  }\n\n  /**\n   * Perform the actual deployment of a bootstrap stack, given a template and some parameters\n   */\n  public async update(\n    template: any,\n    parameters: Record<string, string | undefined>,\n    options: Omit<BootstrapEnvironmentOptions, 'parameters'>,\n  ): Promise<SuccessfulDeployStackResult> {\n    if (this.currentToolkitInfo.found && !options.forceDeployment) {\n      // Safety checks\n      const abortResponse = {\n        type: 'did-deploy-stack',\n        noOp: true,\n        outputs: {},\n        stackArn: this.currentToolkitInfo.bootstrapStack.stackId,\n      } satisfies SuccessfulDeployStackResult;\n\n      // Validate that the bootstrap stack we're trying to replace is from the same variant as the one we're trying to deploy\n      const currentVariant = this.currentToolkitInfo.variant;\n      const newVariant = bootstrapVariantFromTemplate(template);\n      if (currentVariant !== newVariant) {\n        await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_WARN.msg(\n          `Bootstrap stack already exists, containing '${currentVariant}'. Not overwriting it with a template containing '${newVariant}' (use --force if you intend to overwrite)`,\n        ));\n        return abortResponse;\n      }\n\n      // Validate that we're not downgrading the bootstrap stack\n      const newVersion = bootstrapVersionFromTemplate(template);\n      const currentVersion = this.currentToolkitInfo.version;\n      if (newVersion < currentVersion) {\n        await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_WARN.msg(\n          `Bootstrap stack already at version ${currentVersion}. Not downgrading it to version ${newVersion} (use --force if you intend to downgrade)`,\n        ));\n        if (newVersion === 0) {\n          // A downgrade with 0 as target version means we probably have a new-style bootstrap in the account,\n          // and an old-style bootstrap as current target, which means the user probably forgot to put this flag in.\n          await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_WARN.msg(\n            \"(Did you set the '@aws-cdk/core:newStyleStackSynthesis' feature flag in cdk.json?)\",\n          ));\n        }\n        return abortResponse;\n      }\n    }\n\n    const outdir = await fs.mkdtemp(path.join(os.tmpdir(), 'cdk-bootstrap'));\n    const builder = new CloudAssemblyBuilder(outdir);\n    const templateFile = `${this.toolkitStackName}.template.json`;\n    await fs.writeJson(path.join(builder.outdir, templateFile), template, {\n      spaces: 2,\n    });\n\n    builder.addArtifact(this.toolkitStackName, {\n      type: ArtifactType.AWS_CLOUDFORMATION_STACK,\n      environment: EnvironmentUtils.format(this.resolvedEnvironment.account, this.resolvedEnvironment.region),\n      properties: {\n        templateFile,\n        terminationProtection: options.terminationProtection ?? false,\n      },\n    });\n\n    const assembly = builder.buildAssembly();\n\n    const ret = await deployStack({\n      stack: assembly.getStackByName(this.toolkitStackName),\n      resolvedEnvironment: this.resolvedEnvironment,\n      sdk: this.sdk,\n      sdkProvider: this.sdkProvider,\n      forceDeployment: options.forceDeployment,\n      roleArn: options.roleArn,\n      tags: options.tags,\n      deploymentMethod: { method: 'change-set', execute: options.execute },\n      parameters,\n      usePreviousParameters: options.usePreviousParameters ?? true,\n      // Obviously we can't need a bootstrap stack to deploy a bootstrap stack\n      envResources: new NoBootstrapStackEnvironmentResources(this.resolvedEnvironment, this.sdk, this.ioHelper),\n    }, this.ioHelper);\n\n    assertIsSuccessfulDeployStackResult(ret);\n\n    return ret;\n  }\n}\n\nexport function bootstrapVersionFromTemplate(template: any): number {\n  const versionSources = [\n    template.Outputs?.[BOOTSTRAP_VERSION_OUTPUT]?.Value,\n    template.Resources?.[BOOTSTRAP_VERSION_RESOURCE]?.Properties?.Value,\n  ];\n\n  for (const vs of versionSources) {\n    if (typeof vs === 'number') {\n      return vs;\n    }\n    if (typeof vs === 'string' && !isNaN(parseInt(vs, 10))) {\n      return parseInt(vs, 10);\n    }\n  }\n  return 0;\n}\n\nexport function bootstrapVariantFromTemplate(template: any): string {\n  return template.Parameters?.[BOOTSTRAP_VARIANT_PARAMETER]?.Default ?? DEFAULT_BOOTSTRAP_VARIANT;\n}\n"]} \ No newline at end of file diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/bootstrap/index.d.ts b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/bootstrap/index.d.ts new file mode 100644 index 000000000..a4f40cbbb --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/bootstrap/index.d.ts @@ -0,0 +1,3 @@ +export * from './bootstrap-environment'; +export * from './bootstrap-props'; +export { legacyBootstrapTemplate } from './legacy-template'; diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/bootstrap/index.js b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/bootstrap/index.js new file mode 100644 index 000000000..daab97189 --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/bootstrap/index.js @@ -0,0 +1,23 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __exportStar = (this && this.__exportStar) || function(m, exports) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.legacyBootstrapTemplate = void 0; +__exportStar(require("./bootstrap-environment"), exports); +__exportStar(require("./bootstrap-props"), exports); +// testing exports +var legacy_template_1 = require("./legacy-template"); +Object.defineProperty(exports, "legacyBootstrapTemplate", { enumerable: true, get: function () { return legacy_template_1.legacyBootstrapTemplate; } }); +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXBpL2Jvb3RzdHJhcC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLDBEQUF3QztBQUN4QyxvREFBa0M7QUFFbEMsa0JBQWtCO0FBQ2xCLHFEQUE0RDtBQUFuRCwwSEFBQSx1QkFBdUIsT0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYm9vdHN0cmFwLWVudmlyb25tZW50JztcbmV4cG9ydCAqIGZyb20gJy4vYm9vdHN0cmFwLXByb3BzJztcblxuLy8gdGVzdGluZyBleHBvcnRzXG5leHBvcnQgeyBsZWdhY3lCb290c3RyYXBUZW1wbGF0ZSB9IGZyb20gJy4vbGVnYWN5LXRlbXBsYXRlJztcbiJdfQ== \ No newline at end of file diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/bootstrap/legacy-template.d.ts b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/bootstrap/legacy-template.d.ts new file mode 100644 index 000000000..2aeeb0038 --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/bootstrap/legacy-template.d.ts @@ -0,0 +1,2 @@ +import type { BootstrappingParameters } from './bootstrap-props'; +export declare function legacyBootstrapTemplate(params: BootstrappingParameters): any; diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/bootstrap/legacy-template.js b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/bootstrap/legacy-template.js new file mode 100644 index 000000000..239491537 --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/bootstrap/legacy-template.js @@ -0,0 +1,82 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.legacyBootstrapTemplate = legacyBootstrapTemplate; +const bootstrap_props_1 = require("./bootstrap-props"); +function legacyBootstrapTemplate(params) { + return { + Description: 'The CDK Toolkit Stack. It was created by `cdk bootstrap` and manages resources necessary for managing your Cloud Applications with AWS CDK.', + Conditions: { + UsePublicAccessBlockConfiguration: { + 'Fn::Equals': [ + params.publicAccessBlockConfiguration || params.publicAccessBlockConfiguration === undefined ? 'true' : 'false', + 'true', + ], + }, + }, + Resources: { + StagingBucket: { + Type: 'AWS::S3::Bucket', + Properties: { + BucketName: params.bucketName, + AccessControl: 'Private', + BucketEncryption: { + ServerSideEncryptionConfiguration: [{ + ServerSideEncryptionByDefault: { + SSEAlgorithm: 'aws:kms', + KMSMasterKeyID: params.kmsKeyId, + }, + }], + }, + PublicAccessBlockConfiguration: { + 'Fn::If': [ + 'UsePublicAccessBlockConfiguration', + { + BlockPublicAcls: true, + BlockPublicPolicy: true, + IgnorePublicAcls: true, + RestrictPublicBuckets: true, + }, + { Ref: 'AWS::NoValue' }, + ], + }, + }, + }, + StagingBucketPolicy: { + Type: 'AWS::S3::BucketPolicy', + Properties: { + Bucket: { Ref: 'StagingBucket' }, + PolicyDocument: { + Id: 'AccessControl', + Version: '2012-10-17', + Statement: [ + { + Sid: 'AllowSSLRequestsOnly', + Action: 's3:*', + Effect: 'Deny', + Resource: [ + { 'Fn::Sub': '${StagingBucket.Arn}' }, + { 'Fn::Sub': '${StagingBucket.Arn}/*' }, + ], + Condition: { + Bool: { 'aws:SecureTransport': 'false' }, + }, + Principal: '*', + }, + ], + }, + }, + }, + }, + Outputs: { + [bootstrap_props_1.BUCKET_NAME_OUTPUT]: { + Description: 'The name of the S3 bucket owned by the CDK toolkit stack', + Value: { Ref: 'StagingBucket' }, + }, + [bootstrap_props_1.BUCKET_DOMAIN_NAME_OUTPUT]: { + Description: 'The domain name of the S3 bucket owned by the CDK toolkit stack', + Value: { 'Fn::GetAtt': ['StagingBucket', 'RegionalDomainName'] }, + }, + }, + }; +} +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloud-assembly/environment.d.ts b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloud-assembly/environment.d.ts new file mode 100644 index 000000000..f23e1ffb4 --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloud-assembly/environment.d.ts @@ -0,0 +1,43 @@ +import type { SdkProvider } from '../aws-auth'; +import type { Settings } from '../settings'; +/** + * If we don't have region/account defined in context, we fall back to the default SDK behavior + * where region is retrieved from ~/.aws/config and account is based on default credentials provider + * chain and then STS is queried. + * + * This is done opportunistically: for example, if we can't access STS for some reason or the region + * is not configured, the context value will be 'null' and there could failures down the line. In + * some cases, synthesis does not require region/account information at all, so that might be perfectly + * fine in certain scenarios. + * + * @param context The context key/value bash. + */ +export declare function prepareDefaultEnvironment(aws: SdkProvider, debugFn: (msg: string) => Promise): Promise<{ + [key: string]: string; +}>; +/** + * Settings related to synthesis are read from context. + * The merging of various configuration sources like cli args or cdk.json has already happened. + * We now need to set the final values to the context. + */ +export declare function prepareContext(settings: Settings, context: { + [key: string]: any; +}, env: { + [key: string]: string | undefined; +}, debugFn: (msg: string) => Promise): Promise<{ + [key: string]: any; +}>; +export declare function spaceAvailableForContext(env: { + [key: string]: string; +}, limit: number): number; +/** + * Guess the executable from the command-line argument + * + * Only do this if the file is NOT marked as executable. If it is, + * we'll defer to the shebang inside the file itself. + * + * If we're on Windows, we ALWAYS take the handler, since it's hard to + * verify if registry associations have or have not been set up for this + * file type, so we'll assume the worst and take control. + */ +export declare function guessExecutable(app: string, debugFn: (msg: string) => Promise): Promise; diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloud-assembly/environment.js b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloud-assembly/environment.js new file mode 100644 index 000000000..cff245cff --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloud-assembly/environment.js @@ -0,0 +1,127 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.prepareDefaultEnvironment = prepareDefaultEnvironment; +exports.prepareContext = prepareContext; +exports.spaceAvailableForContext = spaceAvailableForContext; +exports.guessExecutable = guessExecutable; +const path = require("path"); +const util_1 = require("util"); +const cxapi = require("@aws-cdk/cx-api"); +const fs = require("fs-extra"); +/** + * If we don't have region/account defined in context, we fall back to the default SDK behavior + * where region is retrieved from ~/.aws/config and account is based on default credentials provider + * chain and then STS is queried. + * + * This is done opportunistically: for example, if we can't access STS for some reason or the region + * is not configured, the context value will be 'null' and there could failures down the line. In + * some cases, synthesis does not require region/account information at all, so that might be perfectly + * fine in certain scenarios. + * + * @param context The context key/value bash. + */ +async function prepareDefaultEnvironment(aws, debugFn) { + const env = {}; + env[cxapi.DEFAULT_REGION_ENV] = aws.defaultRegion; + await debugFn(`Setting "${cxapi.DEFAULT_REGION_ENV}" environment variable to ${env[cxapi.DEFAULT_REGION_ENV]}`); + const accountId = (await aws.defaultAccount())?.accountId; + if (accountId) { + env[cxapi.DEFAULT_ACCOUNT_ENV] = accountId; + await debugFn(`Setting "${cxapi.DEFAULT_ACCOUNT_ENV}" environment variable to ${env[cxapi.DEFAULT_ACCOUNT_ENV]}`); + } + return env; +} +/** + * Settings related to synthesis are read from context. + * The merging of various configuration sources like cli args or cdk.json has already happened. + * We now need to set the final values to the context. + */ +async function prepareContext(settings, context, env, debugFn) { + const debugMode = settings.get(['debug']) ?? true; + if (debugMode) { + env.CDK_DEBUG = 'true'; + } + const pathMetadata = settings.get(['pathMetadata']) ?? true; + if (pathMetadata) { + context[cxapi.PATH_METADATA_ENABLE_CONTEXT] = true; + } + const assetMetadata = settings.get(['assetMetadata']) ?? true; + if (assetMetadata) { + context[cxapi.ASSET_RESOURCE_METADATA_ENABLED_CONTEXT] = true; + } + const versionReporting = settings.get(['versionReporting']) ?? true; + if (versionReporting) { + context[cxapi.ANALYTICS_REPORTING_ENABLED_CONTEXT] = true; + } + // We need to keep on doing this for framework version from before this flag was deprecated. + if (!versionReporting) { + context['aws:cdk:disable-version-reporting'] = true; + } + const stagingEnabled = settings.get(['staging']) ?? true; + if (!stagingEnabled) { + context[cxapi.DISABLE_ASSET_STAGING_CONTEXT] = true; + } + const bundlingStacks = settings.get(['bundlingStacks']) ?? ['**']; + context[cxapi.BUNDLING_STACKS] = bundlingStacks; + await debugFn((0, util_1.format)('context:', context)); + return context; +} +function spaceAvailableForContext(env, limit) { + const size = (value) => value != null ? Buffer.byteLength(value) : 0; + const usedSpace = Object.entries(env) + .map(([k, v]) => k === cxapi.CONTEXT_ENV ? size(k) : size(k) + size(v)) + .reduce((a, b) => a + b, 0); + return Math.max(0, limit - usedSpace); +} +/** + * Guess the executable from the command-line argument + * + * Only do this if the file is NOT marked as executable. If it is, + * we'll defer to the shebang inside the file itself. + * + * If we're on Windows, we ALWAYS take the handler, since it's hard to + * verify if registry associations have or have not been set up for this + * file type, so we'll assume the worst and take control. + */ +async function guessExecutable(app, debugFn) { + const commandLine = appToArray(app); + if (commandLine.length === 1) { + let fstat; + try { + fstat = await fs.stat(commandLine[0]); + } + catch { + await debugFn(`Not a file: '${commandLine[0]}'. Using '${commandLine}' as command-line`); + return commandLine; + } + // eslint-disable-next-line no-bitwise + const isExecutable = (fstat.mode & fs.constants.X_OK) !== 0; + const isWindows = process.platform === 'win32'; + const handler = EXTENSION_MAP.get(path.extname(commandLine[0])); + if (handler && (!isExecutable || isWindows)) { + return handler(commandLine[0]); + } + } + return commandLine; +} +/** + * Mapping of extensions to command-line generators + */ +const EXTENSION_MAP = new Map([ + ['.js', executeNode], +]); +/** + * Execute the given file with the same 'node' process as is running the current process + */ +function executeNode(scriptFile) { + return [process.execPath, scriptFile]; +} +/** + * Make sure the 'app' is an array + * + * If it's a string, split on spaces as a trivial way of tokenizing the command line. + */ +function appToArray(app) { + return typeof app === 'string' ? app.split(' ') : app; +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"environment.js","sourceRoot":"","sources":["../../../src/api/cloud-assembly/environment.ts"],"names":[],"mappings":";;AAmBA,8DAgBC;AAOD,wCAyCC;AAED,4DAQC;AAYD,0CAsBC;AA/HD,6BAA6B;AAC7B,+BAA8B;AAC9B,yCAAyC;AACzC,+BAA+B;AAI/B;;;;;;;;;;;GAWG;AACI,KAAK,UAAU,yBAAyB,CAC7C,GAAgB,EAChB,OAAuC;IAEvC,MAAM,GAAG,GAA8B,EAAG,CAAC;IAE3C,GAAG,CAAC,KAAK,CAAC,kBAAkB,CAAC,GAAG,GAAG,CAAC,aAAa,CAAC;IAClD,MAAM,OAAO,CAAC,YAAY,KAAK,CAAC,kBAAkB,6BAA6B,GAAG,CAAC,KAAK,CAAC,kBAAkB,CAAC,EAAE,CAAC,CAAC;IAEhH,MAAM,SAAS,GAAG,CAAC,MAAM,GAAG,CAAC,cAAc,EAAE,CAAC,EAAE,SAAS,CAAC;IAC1D,IAAI,SAAS,EAAE,CAAC;QACd,GAAG,CAAC,KAAK,CAAC,mBAAmB,CAAC,GAAG,SAAS,CAAC;QAC3C,MAAM,OAAO,CAAC,YAAY,KAAK,CAAC,mBAAmB,6BAA6B,GAAG,CAAC,KAAK,CAAC,mBAAmB,CAAC,EAAE,CAAC,CAAC;IACpH,CAAC;IAED,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;GAIG;AACI,KAAK,UAAU,cAAc,CAClC,QAAkB,EAClB,OAA6B,EAC7B,GAAyC,EACzC,OAAuC;IAEvC,MAAM,SAAS,GAAY,QAAQ,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,CAAC,IAAI,IAAI,CAAC;IAC3D,IAAI,SAAS,EAAE,CAAC;QACd,GAAG,CAAC,SAAS,GAAG,MAAM,CAAC;IACzB,CAAC;IAED,MAAM,YAAY,GAAY,QAAQ,CAAC,GAAG,CAAC,CAAC,cAAc,CAAC,CAAC,IAAI,IAAI,CAAC;IACrE,IAAI,YAAY,EAAE,CAAC;QACjB,OAAO,CAAC,KAAK,CAAC,4BAA4B,CAAC,GAAG,IAAI,CAAC;IACrD,CAAC;IAED,MAAM,aAAa,GAAY,QAAQ,CAAC,GAAG,CAAC,CAAC,eAAe,CAAC,CAAC,IAAI,IAAI,CAAC;IACvE,IAAI,aAAa,EAAE,CAAC;QAClB,OAAO,CAAC,KAAK,CAAC,uCAAuC,CAAC,GAAG,IAAI,CAAC;IAChE,CAAC;IAED,MAAM,gBAAgB,GAAY,QAAQ,CAAC,GAAG,CAAC,CAAC,kBAAkB,CAAC,CAAC,IAAI,IAAI,CAAC;IAC7E,IAAI,gBAAgB,EAAE,CAAC;QACrB,OAAO,CAAC,KAAK,CAAC,mCAAmC,CAAC,GAAG,IAAI,CAAC;IAC5D,CAAC;IACD,4FAA4F;IAC5F,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACtB,OAAO,CAAC,mCAAmC,CAAC,GAAG,IAAI,CAAC;IACtD,CAAC;IAED,MAAM,cAAc,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC,IAAI,IAAI,CAAC;IACzD,IAAI,CAAC,cAAc,EAAE,CAAC;QACpB,OAAO,CAAC,KAAK,CAAC,6BAA6B,CAAC,GAAG,IAAI,CAAC;IACtD,CAAC;IAED,MAAM,cAAc,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,gBAAgB,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAClE,OAAO,CAAC,KAAK,CAAC,eAAe,CAAC,GAAG,cAAc,CAAC;IAEhD,MAAM,OAAO,CAAC,IAAA,aAAM,EAAC,UAAU,EAAE,OAAO,CAAC,CAAC,CAAC;IAE3C,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,SAAgB,wBAAwB,CAAC,GAA8B,EAAE,KAAa;IACpF,MAAM,IAAI,GAAG,CAAC,KAAa,EAAE,EAAE,CAAC,KAAK,IAAI,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAE7E,MAAM,SAAS,GAAG,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC;SAClC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;SACtE,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;IAE9B,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,GAAG,SAAS,CAAC,CAAC;AACxC,CAAC;AAED;;;;;;;;;GASG;AACI,KAAK,UAAU,eAAe,CAAC,GAAW,EAAE,OAAuC;IACxF,MAAM,WAAW,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC;IACpC,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC7B,IAAI,KAAK,CAAC;QAEV,IAAI,CAAC;YACH,KAAK,GAAG,MAAM,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;QACxC,CAAC;QAAC,MAAM,CAAC;YACP,MAAM,OAAO,CAAC,gBAAgB,WAAW,CAAC,CAAC,CAAC,aAAa,WAAW,mBAAmB,CAAC,CAAC;YACzF,OAAO,WAAW,CAAC;QACrB,CAAC;QAED,sCAAsC;QACtC,MAAM,YAAY,GAAG,CAAC,KAAK,CAAC,IAAI,GAAG,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC5D,MAAM,SAAS,GAAG,OAAO,CAAC,QAAQ,KAAK,OAAO,CAAC;QAE/C,MAAM,OAAO,GAAG,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAChE,IAAI,OAAO,IAAI,CAAC,CAAC,YAAY,IAAI,SAAS,CAAC,EAAE,CAAC;YAC5C,OAAO,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;QACjC,CAAC;IACH,CAAC;IACD,OAAO,WAAW,CAAC;AACrB,CAAC;AAED;;GAEG;AACH,MAAM,aAAa,GAAG,IAAI,GAAG,CAA2B;IACtD,CAAC,KAAK,EAAE,WAAW,CAAC;CACrB,CAAC,CAAC;AAIH;;GAEG;AACH,SAAS,WAAW,CAAC,UAAkB;IACrC,OAAO,CAAC,OAAO,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;AACxC,CAAC;AAED;;;;GAIG;AACH,SAAS,UAAU,CAAC,GAAQ;IAC1B,OAAO,OAAO,GAAG,KAAK,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;AACxD,CAAC","sourcesContent":["import * as path from 'path';\nimport { format } from 'util';\nimport * as cxapi from '@aws-cdk/cx-api';\nimport * as fs from 'fs-extra';\nimport type { SdkProvider } from '../aws-auth';\nimport type { Settings } from '../settings';\n\n/**\n * If we don't have region/account defined in context, we fall back to the default SDK behavior\n * where region is retrieved from ~/.aws/config and account is based on default credentials provider\n * chain and then STS is queried.\n *\n * This is done opportunistically: for example, if we can't access STS for some reason or the region\n * is not configured, the context value will be 'null' and there could failures down the line. In\n * some cases, synthesis does not require region/account information at all, so that might be perfectly\n * fine in certain scenarios.\n *\n * @param context The context key/value bash.\n */\nexport async function prepareDefaultEnvironment(\n  aws: SdkProvider,\n  debugFn: (msg: string) => Promise<void>,\n): Promise<{ [key: string]: string }> {\n  const env: { [key: string]: string } = { };\n\n  env[cxapi.DEFAULT_REGION_ENV] = aws.defaultRegion;\n  await debugFn(`Setting \"${cxapi.DEFAULT_REGION_ENV}\" environment variable to ${env[cxapi.DEFAULT_REGION_ENV]}`);\n\n  const accountId = (await aws.defaultAccount())?.accountId;\n  if (accountId) {\n    env[cxapi.DEFAULT_ACCOUNT_ENV] = accountId;\n    await debugFn(`Setting \"${cxapi.DEFAULT_ACCOUNT_ENV}\" environment variable to ${env[cxapi.DEFAULT_ACCOUNT_ENV]}`);\n  }\n\n  return env;\n}\n\n/**\n * Settings related to synthesis are read from context.\n * The merging of various configuration sources like cli args or cdk.json has already happened.\n * We now need to set the final values to the context.\n */\nexport async function prepareContext(\n  settings: Settings,\n  context: {[key: string]: any},\n  env: { [key: string]: string | undefined},\n  debugFn: (msg: string) => Promise<void>,\n) {\n  const debugMode: boolean = settings.get(['debug']) ?? true;\n  if (debugMode) {\n    env.CDK_DEBUG = 'true';\n  }\n\n  const pathMetadata: boolean = settings.get(['pathMetadata']) ?? true;\n  if (pathMetadata) {\n    context[cxapi.PATH_METADATA_ENABLE_CONTEXT] = true;\n  }\n\n  const assetMetadata: boolean = settings.get(['assetMetadata']) ?? true;\n  if (assetMetadata) {\n    context[cxapi.ASSET_RESOURCE_METADATA_ENABLED_CONTEXT] = true;\n  }\n\n  const versionReporting: boolean = settings.get(['versionReporting']) ?? true;\n  if (versionReporting) {\n    context[cxapi.ANALYTICS_REPORTING_ENABLED_CONTEXT] = true;\n  }\n  // We need to keep on doing this for framework version from before this flag was deprecated.\n  if (!versionReporting) {\n    context['aws:cdk:disable-version-reporting'] = true;\n  }\n\n  const stagingEnabled = settings.get(['staging']) ?? true;\n  if (!stagingEnabled) {\n    context[cxapi.DISABLE_ASSET_STAGING_CONTEXT] = true;\n  }\n\n  const bundlingStacks = settings.get(['bundlingStacks']) ?? ['**'];\n  context[cxapi.BUNDLING_STACKS] = bundlingStacks;\n\n  await debugFn(format('context:', context));\n\n  return context;\n}\n\nexport function spaceAvailableForContext(env: { [key: string]: string }, limit: number) {\n  const size = (value: string) => value != null ? Buffer.byteLength(value) : 0;\n\n  const usedSpace = Object.entries(env)\n    .map(([k, v]) => k === cxapi.CONTEXT_ENV ? size(k) : size(k) + size(v))\n    .reduce((a, b) => a + b, 0);\n\n  return Math.max(0, limit - usedSpace);\n}\n\n/**\n * Guess the executable from the command-line argument\n *\n * Only do this if the file is NOT marked as executable. If it is,\n * we'll defer to the shebang inside the file itself.\n *\n * If we're on Windows, we ALWAYS take the handler, since it's hard to\n * verify if registry associations have or have not been set up for this\n * file type, so we'll assume the worst and take control.\n */\nexport async function guessExecutable(app: string, debugFn: (msg: string) => Promise<void>) {\n  const commandLine = appToArray(app);\n  if (commandLine.length === 1) {\n    let fstat;\n\n    try {\n      fstat = await fs.stat(commandLine[0]);\n    } catch {\n      await debugFn(`Not a file: '${commandLine[0]}'. Using '${commandLine}' as command-line`);\n      return commandLine;\n    }\n\n    // eslint-disable-next-line no-bitwise\n    const isExecutable = (fstat.mode & fs.constants.X_OK) !== 0;\n    const isWindows = process.platform === 'win32';\n\n    const handler = EXTENSION_MAP.get(path.extname(commandLine[0]));\n    if (handler && (!isExecutable || isWindows)) {\n      return handler(commandLine[0]);\n    }\n  }\n  return commandLine;\n}\n\n/**\n * Mapping of extensions to command-line generators\n */\nconst EXTENSION_MAP = new Map<string, CommandGenerator>([\n  ['.js', executeNode],\n]);\n\ntype CommandGenerator = (file: string) => string[];\n\n/**\n * Execute the given file with the same 'node' process as is running the current process\n */\nfunction executeNode(scriptFile: string): string[] {\n  return [process.execPath, scriptFile];\n}\n\n/**\n * Make sure the 'app' is an array\n *\n * If it's a string, split on spaces as a trivial way of tokenizing the command line.\n */\nfunction appToArray(app: any) {\n  return typeof app === 'string' ? app.split(' ') : app;\n}\n"]} \ No newline at end of file diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloud-assembly/index.d.ts b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloud-assembly/index.d.ts new file mode 100644 index 000000000..7ed5f6288 --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloud-assembly/index.d.ts @@ -0,0 +1,4 @@ +export * from './environment'; +export * from './stack-assembly'; +export * from './stack-collection'; +export * from './stack-selector'; diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloud-assembly/index.js b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloud-assembly/index.js new file mode 100644 index 000000000..f002d6fc7 --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloud-assembly/index.js @@ -0,0 +1,21 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __exportStar = (this && this.__exportStar) || function(m, exports) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +__exportStar(require("./environment"), exports); +__exportStar(require("./stack-assembly"), exports); +__exportStar(require("./stack-collection"), exports); +__exportStar(require("./stack-selector"), exports); +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXBpL2Nsb3VkLWFzc2VtYmx5L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSxnREFBOEI7QUFDOUIsbURBQWlDO0FBQ2pDLHFEQUFtQztBQUNuQyxtREFBaUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2Vudmlyb25tZW50JztcbmV4cG9ydCAqIGZyb20gJy4vc3RhY2stYXNzZW1ibHknO1xuZXhwb3J0ICogZnJvbSAnLi9zdGFjay1jb2xsZWN0aW9uJztcbmV4cG9ydCAqIGZyb20gJy4vc3RhY2stc2VsZWN0b3InO1xuIl19 \ No newline at end of file diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloud-assembly/stack-assembly.d.ts b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloud-assembly/stack-assembly.d.ts new file mode 100644 index 000000000..8ac4814de --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloud-assembly/stack-assembly.d.ts @@ -0,0 +1,55 @@ +import type * as cxapi from '@aws-cdk/cx-api'; +import { StackCollection } from './stack-collection'; +import type { IoHelper } from '../io/private/io-helper'; +export interface IStackAssembly { + /** + * The directory this CloudAssembly was read from + */ + directory: string; + /** + * Select a single stack by its ID + */ + stackById(stackId: string): StackCollection; +} +/** + * When selecting stacks, what other stacks to include because of dependencies + */ +export declare enum ExtendedStackSelection { + /** + * Don't select any extra stacks + */ + None = 0, + /** + * Include stacks that this stack depends on + */ + Upstream = 1, + /** + * Include stacks that depend on this stack + */ + Downstream = 2 +} +/** + * A single Cloud Assembly and the operations we do on it to deploy the artifacts inside + */ +export declare abstract class BaseStackAssembly implements IStackAssembly { + readonly assembly: cxapi.CloudAssembly; + /** + * Sanitize a list of stack match patterns + */ + protected static sanitizePatterns(patterns: string[]): string[]; + /** + * The directory this CloudAssembly was read from + */ + readonly directory: string; + /** + * The IoHelper used for messaging + */ + protected readonly ioHelper: IoHelper; + constructor(assembly: cxapi.CloudAssembly, ioHelper: IoHelper); + /** + * Select a single stack by its ID + */ + stackById(stackId: string): StackCollection; + protected selectMatchingStacks(stacks: cxapi.CloudFormationStackArtifact[], patterns: string[], extend?: ExtendedStackSelection): Promise; + protected extendStacks(matched: cxapi.CloudFormationStackArtifact[], all: cxapi.CloudFormationStackArtifact[], extend?: ExtendedStackSelection): Promise; +} diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloud-assembly/stack-assembly.js b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloud-assembly/stack-assembly.js new file mode 100644 index 000000000..12c74c393 --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloud-assembly/stack-assembly.js @@ -0,0 +1,139 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.BaseStackAssembly = exports.ExtendedStackSelection = void 0; +const chalk = require("chalk"); +const minimatch_1 = require("minimatch"); +const stack_collection_1 = require("./stack-collection"); +const util_1 = require("../../util"); +const private_1 = require("../io/private"); +/** + * When selecting stacks, what other stacks to include because of dependencies + */ +var ExtendedStackSelection; +(function (ExtendedStackSelection) { + /** + * Don't select any extra stacks + */ + ExtendedStackSelection[ExtendedStackSelection["None"] = 0] = "None"; + /** + * Include stacks that this stack depends on + */ + ExtendedStackSelection[ExtendedStackSelection["Upstream"] = 1] = "Upstream"; + /** + * Include stacks that depend on this stack + */ + ExtendedStackSelection[ExtendedStackSelection["Downstream"] = 2] = "Downstream"; +})(ExtendedStackSelection || (exports.ExtendedStackSelection = ExtendedStackSelection = {})); +/** + * A single Cloud Assembly and the operations we do on it to deploy the artifacts inside + */ +class BaseStackAssembly { + assembly; + /** + * Sanitize a list of stack match patterns + */ + static sanitizePatterns(patterns) { + let sanitized = patterns.filter(s => s != null); // filter null/undefined + sanitized = [...new Set(sanitized)]; // make them unique + return sanitized; + } + /** + * The directory this CloudAssembly was read from + */ + directory; + /** + * The IoHelper used for messaging + */ + ioHelper; + constructor(assembly, ioHelper) { + this.assembly = assembly; + this.directory = assembly.directory; + this.ioHelper = ioHelper; + } + /** + * Select a single stack by its ID + */ + stackById(stackId) { + return new stack_collection_1.StackCollection(this, [this.assembly.getStackArtifact(stackId)]); + } + async selectMatchingStacks(stacks, patterns, extend = ExtendedStackSelection.None) { + const matchingPattern = (pattern) => (stack) => (0, minimatch_1.minimatch)(stack.hierarchicalId, pattern); + const matchedStacks = (0, util_1.flatten)(patterns.map(pattern => stacks.filter(matchingPattern(pattern)))); + return this.extendStacks(matchedStacks, stacks, extend); + } + async extendStacks(matched, all, extend = ExtendedStackSelection.None) { + const allStacks = new Map(); + for (const stack of all) { + allStacks.set(stack.hierarchicalId, stack); + } + const index = indexByHierarchicalId(matched); + switch (extend) { + case ExtendedStackSelection.Downstream: + await includeDownstreamStacks(this.ioHelper, index, allStacks); + break; + case ExtendedStackSelection.Upstream: + await includeUpstreamStacks(this.ioHelper, index, allStacks); + break; + } + // Filter original array because it is in the right order + const selectedList = all.filter(s => index.has(s.hierarchicalId)); + return new stack_collection_1.StackCollection(this, selectedList); + } +} +exports.BaseStackAssembly = BaseStackAssembly; +function indexByHierarchicalId(stacks) { + const result = new Map(); + for (const stack of stacks) { + result.set(stack.hierarchicalId, stack); + } + return result; +} +/** + * Calculate the transitive closure of stack dependents. + * + * Modifies `selectedStacks` in-place. + */ +async function includeDownstreamStacks(ioHelper, selectedStacks, allStacks) { + const added = new Array(); + let madeProgress; + do { + madeProgress = false; + for (const [id, stack] of allStacks) { + // Select this stack if it's not selected yet AND it depends on a stack that's in the selected set + if (!selectedStacks.has(id) && (stack.dependencies || []).some(dep => selectedStacks.has(dep.id))) { + selectedStacks.set(id, stack); + added.push(id); + madeProgress = true; + } + } + } while (madeProgress); + if (added.length > 0) { + await ioHelper.notify(private_1.IO.DEFAULT_ASSEMBLY_INFO.msg(`Including depending stacks: ${chalk.bold(added.join(', '))}`)); + } +} +/** + * Calculate the transitive closure of stack dependencies. + * + * Modifies `selectedStacks` in-place. + */ +async function includeUpstreamStacks(ioHelper, selectedStacks, allStacks) { + const added = new Array(); + let madeProgress = true; + while (madeProgress) { + madeProgress = false; + for (const stack of selectedStacks.values()) { + // Select an additional stack if it's not selected yet and a dependency of a selected stack (and exists, obviously) + for (const dependencyId of stack.dependencies.map(x => x.manifest.displayName ?? x.id)) { + if (!selectedStacks.has(dependencyId) && allStacks.has(dependencyId)) { + added.push(dependencyId); + selectedStacks.set(dependencyId, allStacks.get(dependencyId)); + madeProgress = true; + } + } + } + } + if (added.length > 0) { + await ioHelper.notify(private_1.IO.DEFAULT_ASSEMBLY_INFO.msg(`Including dependency stacks: ${chalk.bold(added.join(', '))}`)); + } +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stack-assembly.js","sourceRoot":"","sources":["../../../src/api/cloud-assembly/stack-assembly.ts"],"names":[],"mappings":"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","sourcesContent":["import type * as cxapi from '@aws-cdk/cx-api';\nimport * as chalk from 'chalk';\nimport { minimatch } from 'minimatch';\nimport { StackCollection } from './stack-collection';\nimport { flatten } from '../../util';\nimport { IO } from '../io/private';\nimport type { IoHelper } from '../io/private/io-helper';\n\nexport interface IStackAssembly {\n  /**\n   * The directory this CloudAssembly was read from\n   */\n  directory: string;\n\n  /**\n   * Select a single stack by its ID\n   */\n  stackById(stackId: string): StackCollection;\n}\n\n/**\n * When selecting stacks, what other stacks to include because of dependencies\n */\nexport enum ExtendedStackSelection {\n  /**\n   * Don't select any extra stacks\n   */\n  None,\n\n  /**\n   * Include stacks that this stack depends on\n   */\n  Upstream,\n\n  /**\n   * Include stacks that depend on this stack\n   */\n  Downstream,\n}\n\n/**\n * A single Cloud Assembly and the operations we do on it to deploy the artifacts inside\n */\nexport abstract class BaseStackAssembly implements IStackAssembly {\n  /**\n   * Sanitize a list of stack match patterns\n   */\n  protected static sanitizePatterns(patterns: string[]): string[] {\n    let sanitized = patterns.filter(s => s != null); // filter null/undefined\n    sanitized = [...new Set(sanitized)]; // make them unique\n    return sanitized;\n  }\n\n  /**\n   * The directory this CloudAssembly was read from\n   */\n  public readonly directory: string;\n\n  /**\n   * The IoHelper used for messaging\n   */\n  protected readonly ioHelper: IoHelper;\n\n  constructor(public readonly assembly: cxapi.CloudAssembly, ioHelper: IoHelper) {\n    this.directory = assembly.directory;\n    this.ioHelper = ioHelper;\n  }\n\n  /**\n   * Select a single stack by its ID\n   */\n  public stackById(stackId: string) {\n    return new StackCollection(this, [this.assembly.getStackArtifact(stackId)]);\n  }\n\n  protected async selectMatchingStacks(\n    stacks: cxapi.CloudFormationStackArtifact[],\n    patterns: string[],\n    extend: ExtendedStackSelection = ExtendedStackSelection.None,\n  ): Promise<StackCollection> {\n    const matchingPattern = (pattern: string) => (stack: cxapi.CloudFormationStackArtifact) => minimatch(stack.hierarchicalId, pattern);\n    const matchedStacks = flatten(patterns.map(pattern => stacks.filter(matchingPattern(pattern))));\n\n    return this.extendStacks(matchedStacks, stacks, extend);\n  }\n\n  protected async extendStacks(\n    matched: cxapi.CloudFormationStackArtifact[],\n    all: cxapi.CloudFormationStackArtifact[],\n    extend: ExtendedStackSelection = ExtendedStackSelection.None,\n  ) {\n    const allStacks = new Map<string, cxapi.CloudFormationStackArtifact>();\n    for (const stack of all) {\n      allStacks.set(stack.hierarchicalId, stack);\n    }\n\n    const index = indexByHierarchicalId(matched);\n\n    switch (extend) {\n      case ExtendedStackSelection.Downstream:\n        await includeDownstreamStacks(this.ioHelper, index, allStacks);\n        break;\n      case ExtendedStackSelection.Upstream:\n        await includeUpstreamStacks(this.ioHelper, index, allStacks);\n        break;\n    }\n\n    // Filter original array because it is in the right order\n    const selectedList = all.filter(s => index.has(s.hierarchicalId));\n\n    return new StackCollection(this, selectedList);\n  }\n}\n\nfunction indexByHierarchicalId(stacks: cxapi.CloudFormationStackArtifact[]): Map<string, cxapi.CloudFormationStackArtifact> {\n  const result = new Map<string, cxapi.CloudFormationStackArtifact>();\n\n  for (const stack of stacks) {\n    result.set(stack.hierarchicalId, stack);\n  }\n\n  return result;\n}\n\n/**\n * Calculate the transitive closure of stack dependents.\n *\n * Modifies `selectedStacks` in-place.\n */\nasync function includeDownstreamStacks(\n  ioHelper: IoHelper,\n  selectedStacks: Map<string, cxapi.CloudFormationStackArtifact>,\n  allStacks: Map<string, cxapi.CloudFormationStackArtifact>,\n) {\n  const added = new Array<string>();\n\n  let madeProgress;\n  do {\n    madeProgress = false;\n\n    for (const [id, stack] of allStacks) {\n      // Select this stack if it's not selected yet AND it depends on a stack that's in the selected set\n      if (!selectedStacks.has(id) && (stack.dependencies || []).some(dep => selectedStacks.has(dep.id))) {\n        selectedStacks.set(id, stack);\n        added.push(id);\n        madeProgress = true;\n      }\n    }\n  } while (madeProgress);\n\n  if (added.length > 0) {\n    await ioHelper.notify(IO.DEFAULT_ASSEMBLY_INFO.msg(`Including depending stacks: ${chalk.bold(added.join(', '))}`));\n  }\n}\n\n/**\n * Calculate the transitive closure of stack dependencies.\n *\n * Modifies `selectedStacks` in-place.\n */\nasync function includeUpstreamStacks(\n  ioHelper: IoHelper,\n  selectedStacks: Map<string, cxapi.CloudFormationStackArtifact>,\n  allStacks: Map<string, cxapi.CloudFormationStackArtifact>,\n) {\n  const added = new Array<string>();\n  let madeProgress = true;\n  while (madeProgress) {\n    madeProgress = false;\n\n    for (const stack of selectedStacks.values()) {\n      // Select an additional stack if it's not selected yet and a dependency of a selected stack (and exists, obviously)\n      for (const dependencyId of stack.dependencies.map(x => x.manifest.displayName ?? x.id)) {\n        if (!selectedStacks.has(dependencyId) && allStacks.has(dependencyId)) {\n          added.push(dependencyId);\n          selectedStacks.set(dependencyId, allStacks.get(dependencyId)!);\n          madeProgress = true;\n        }\n      }\n    }\n  }\n\n  if (added.length > 0) {\n    await ioHelper.notify(IO.DEFAULT_ASSEMBLY_INFO.msg(`Including dependency stacks: ${chalk.bold(added.join(', '))}`));\n  }\n}\n"]} \ No newline at end of file diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloud-assembly/stack-collection.d.ts b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloud-assembly/stack-collection.d.ts new file mode 100644 index 000000000..fd65fff87 --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloud-assembly/stack-collection.d.ts @@ -0,0 +1,27 @@ +import type * as cxapi from '@aws-cdk/cx-api'; +import type { IStackAssembly } from './stack-assembly'; +import { type StackDetails } from '../../payloads/stack-details'; +/** + * A collection of stacks and related artifacts + * + * In practice, not all artifacts in the CloudAssembly are created equal; + * stacks can be selected independently, but other artifacts such as asset + * bundles cannot. + */ +export declare class StackCollection { + readonly assembly: IStackAssembly; + readonly stackArtifacts: cxapi.CloudFormationStackArtifact[]; + constructor(assembly: IStackAssembly, stackArtifacts: cxapi.CloudFormationStackArtifact[]); + get stackCount(): number; + get firstStack(): cxapi.CloudFormationStackArtifact; + get stackIds(): string[]; + get hierarchicalIds(): string[]; + withDependencies(): StackDetails[]; + reversed(): StackCollection; + filter(predicate: (art: cxapi.CloudFormationStackArtifact) => boolean): StackCollection; + concat(...others: StackCollection[]): StackCollection; + /** + * Extracts 'aws:cdk:warning|info|error' metadata entries from the stack synthesis + */ + validateMetadata(failAt?: 'warn' | 'error' | 'none', logger?: (level: 'info' | 'error' | 'warn', msg: cxapi.SynthesisMessage) => Promise): Promise; +} diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloud-assembly/stack-collection.js b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloud-assembly/stack-collection.js new file mode 100644 index 000000000..915dfeecd --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloud-assembly/stack-collection.js @@ -0,0 +1,112 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.StackCollection = void 0; +const cx_api_1 = require("@aws-cdk/cx-api"); +const toolkit_error_1 = require("../toolkit-error"); +/** + * A collection of stacks and related artifacts + * + * In practice, not all artifacts in the CloudAssembly are created equal; + * stacks can be selected independently, but other artifacts such as asset + * bundles cannot. + */ +class StackCollection { + assembly; + stackArtifacts; + constructor(assembly, stackArtifacts) { + this.assembly = assembly; + this.stackArtifacts = stackArtifacts; + } + get stackCount() { + return this.stackArtifacts.length; + } + get firstStack() { + if (this.stackCount < 1) { + throw new toolkit_error_1.ToolkitError('StackCollection contains no stack artifacts (trying to access the first one)'); + } + return this.stackArtifacts[0]; + } + get stackIds() { + return this.stackArtifacts.map(s => s.id); + } + get hierarchicalIds() { + return this.stackArtifacts.map(s => s.hierarchicalId); + } + withDependencies() { + const allData = []; + for (const stack of this.stackArtifacts) { + const data = { + id: stack.displayName ?? stack.id, + name: stack.stackName, + environment: stack.environment, + dependencies: [], + }; + for (const dependencyId of stack.dependencies.map(x => x.id)) { + if (dependencyId.includes('.assets')) { + continue; + } + const depStack = this.assembly.stackById(dependencyId); + if (depStack.firstStack.dependencies.filter((dep) => !(dep.id).includes('.assets')).length > 0) { + for (const stackDetail of depStack.withDependencies()) { + data.dependencies.push({ + id: stackDetail.id, + dependencies: stackDetail.dependencies, + }); + } + } + else { + data.dependencies.push({ + id: depStack.firstStack.displayName ?? depStack.firstStack.id, + dependencies: [], + }); + } + } + allData.push(data); + } + return allData; + } + reversed() { + const arts = [...this.stackArtifacts]; + arts.reverse(); + return new StackCollection(this.assembly, arts); + } + filter(predicate) { + return new StackCollection(this.assembly, this.stackArtifacts.filter(predicate)); + } + concat(...others) { + return new StackCollection(this.assembly, this.stackArtifacts.concat(...others.map(o => o.stackArtifacts))); + } + /** + * Extracts 'aws:cdk:warning|info|error' metadata entries from the stack synthesis + */ + async validateMetadata(failAt = 'error', logger = async () => { + }) { + let warnings = false; + let errors = false; + for (const stack of this.stackArtifacts) { + for (const message of stack.messages) { + switch (message.level) { + case cx_api_1.SynthesisMessageLevel.WARNING: + warnings = true; + await logger('warn', message); + break; + case cx_api_1.SynthesisMessageLevel.ERROR: + errors = true; + await logger('error', message); + break; + case cx_api_1.SynthesisMessageLevel.INFO: + await logger('info', message); + break; + } + } + } + if (errors && failAt != 'none') { + throw toolkit_error_1.AssemblyError.withStacks('Found errors', this.stackArtifacts); + } + if (warnings && failAt === 'warn') { + throw toolkit_error_1.AssemblyError.withStacks('Found warnings (--strict mode)', this.stackArtifacts); + } + } +} +exports.StackCollection = StackCollection; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stack-collection.js","sourceRoot":"","sources":["../../../src/api/cloud-assembly/stack-collection.ts"],"names":[],"mappings":"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","sourcesContent":["import type * as cxapi from '@aws-cdk/cx-api';\nimport { SynthesisMessageLevel } from '@aws-cdk/cx-api';\nimport { AssemblyError, ToolkitError } from '../toolkit-error';\nimport type { IStackAssembly } from './stack-assembly';\nimport { type StackDetails } from '../../payloads/stack-details';\n\n/**\n * A collection of stacks and related artifacts\n *\n * In practice, not all artifacts in the CloudAssembly are created equal;\n * stacks can be selected independently, but other artifacts such as asset\n * bundles cannot.\n */\nexport class StackCollection {\n  constructor(public readonly assembly: IStackAssembly, public readonly stackArtifacts: cxapi.CloudFormationStackArtifact[]) {\n  }\n\n  public get stackCount() {\n    return this.stackArtifacts.length;\n  }\n\n  public get firstStack() {\n    if (this.stackCount < 1) {\n      throw new ToolkitError('StackCollection contains no stack artifacts (trying to access the first one)');\n    }\n    return this.stackArtifacts[0];\n  }\n\n  public get stackIds(): string[] {\n    return this.stackArtifacts.map(s => s.id);\n  }\n\n  public get hierarchicalIds(): string[] {\n    return this.stackArtifacts.map(s => s.hierarchicalId);\n  }\n\n  public withDependencies(): StackDetails[] {\n    const allData: StackDetails[] = [];\n\n    for (const stack of this.stackArtifacts) {\n      const data: StackDetails = {\n        id: stack.displayName ?? stack.id,\n        name: stack.stackName,\n        environment: stack.environment,\n        dependencies: [],\n      };\n\n      for (const dependencyId of stack.dependencies.map(x => x.id)) {\n        if (dependencyId.includes('.assets')) {\n          continue;\n        }\n\n        const depStack = this.assembly.stackById(dependencyId);\n\n        if (depStack.firstStack.dependencies.filter((dep) => !(dep.id).includes('.assets')).length > 0) {\n          for (const stackDetail of depStack.withDependencies()) {\n            data.dependencies.push({\n              id: stackDetail.id,\n              dependencies: stackDetail.dependencies,\n            });\n          }\n        } else {\n          data.dependencies.push({\n            id: depStack.firstStack.displayName ?? depStack.firstStack.id,\n            dependencies: [],\n          });\n        }\n      }\n\n      allData.push(data);\n    }\n\n    return allData;\n  }\n\n  public reversed() {\n    const arts = [...this.stackArtifacts];\n    arts.reverse();\n    return new StackCollection(this.assembly, arts);\n  }\n\n  public filter(predicate: (art: cxapi.CloudFormationStackArtifact) => boolean): StackCollection {\n    return new StackCollection(this.assembly, this.stackArtifacts.filter(predicate));\n  }\n\n  public concat(...others: StackCollection[]): StackCollection {\n    return new StackCollection(this.assembly, this.stackArtifacts.concat(...others.map(o => o.stackArtifacts)));\n  }\n\n  /**\n   * Extracts 'aws:cdk:warning|info|error' metadata entries from the stack synthesis\n   */\n  public async validateMetadata(\n    failAt: 'warn' | 'error' | 'none' = 'error',\n    logger: (level: 'info' | 'error' | 'warn', msg: cxapi.SynthesisMessage) => Promise<void> = async () => {\n    },\n  ) {\n    let warnings = false;\n    let errors = false;\n\n    for (const stack of this.stackArtifacts) {\n      for (const message of stack.messages) {\n        switch (message.level) {\n          case SynthesisMessageLevel.WARNING:\n            warnings = true;\n            await logger('warn', message);\n            break;\n          case SynthesisMessageLevel.ERROR:\n            errors = true;\n            await logger('error', message);\n            break;\n          case SynthesisMessageLevel.INFO:\n            await logger('info', message);\n            break;\n        }\n      }\n    }\n\n    if (errors && failAt != 'none') {\n      throw AssemblyError.withStacks('Found errors', this.stackArtifacts);\n    }\n\n    if (warnings && failAt === 'warn') {\n      throw AssemblyError.withStacks('Found warnings (--strict mode)', this.stackArtifacts);\n    }\n  }\n}\n"]} \ No newline at end of file diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloud-assembly/stack-selector.d.ts b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloud-assembly/stack-selector.d.ts new file mode 100644 index 000000000..d6be0fad6 --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloud-assembly/stack-selector.d.ts @@ -0,0 +1,81 @@ +/** + * Which stacks should be selected from a cloud assembly + */ +export declare enum StackSelectionStrategy { + /** + * Returns all stacks in the app regardless of patterns, + * including stacks inside nested assemblies. + */ + ALL_STACKS = "all-stacks", + /** + * Returns all stacks in the main (top level) assembly only. + */ + MAIN_ASSEMBLY = "main-assembly", + /** + * If the assembly includes a single stack, returns it. + * Otherwise throws an exception. + */ + ONLY_SINGLE = "only-single", + /** + * Return stacks matched by patterns. + * If no stacks are found, execution is halted successfully. + * Most likely you don't want to use this but `StackSelectionStrategy.MUST_MATCH_PATTERN` + */ + PATTERN_MATCH = "pattern-match", + /** + * Return stacks matched by patterns. + * Throws an exception if the patterns don't match at least one stack in the assembly. + */ + PATTERN_MUST_MATCH = "pattern-must-match", + /** + * Returns if exactly one stack is matched by the pattern(s). + * Throws an exception if no stack, or more than exactly one stack are matched. + */ + PATTERN_MUST_MATCH_SINGLE = "pattern-must-match-single" +} +/** + * When selecting stacks, what other stacks to include because of dependencies + */ +export declare enum ExpandStackSelection { + /** + * Don't select any extra stacks + */ + NONE = "none", + /** + * Include stacks that this stack depends on + */ + UPSTREAM = "upstream", + /** + * Include stacks that depend on this stack + */ + DOWNSTREAM = "downstream" +} +/** + * A specification of which stacks should be selected + */ +export interface StackSelector { + /** + * The behavior if if no selectors are provided. + */ + strategy: StackSelectionStrategy; + /** + * A list of patterns to match the stack hierarchical ids + * Only used with `PATTERN_*` selection strategies. + */ + patterns?: string[]; + /** + * Expand the selection to upstream/downstream stacks. + * @default ExpandStackSelection.None only select the specified/matched stacks + */ + expand?: ExpandStackSelection; + /** + * By default, we throw an exception if the assembly contains no stacks. + * Set to `false`, to halt execution for empty assemblies without error. + * + * Note that actions can still throw if a stack selection result is empty, + * but the assembly contains stacks in principle. + * + * @default true + */ + failOnEmpty?: boolean; +} diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloud-assembly/stack-selector.js b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloud-assembly/stack-selector.js new file mode 100644 index 000000000..b3083e976 --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloud-assembly/stack-selector.js @@ -0,0 +1,64 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.ExpandStackSelection = exports.StackSelectionStrategy = void 0; +/** + * Which stacks should be selected from a cloud assembly + */ +var StackSelectionStrategy; +(function (StackSelectionStrategy) { + /** + * Returns all stacks in the app regardless of patterns, + * including stacks inside nested assemblies. + */ + StackSelectionStrategy["ALL_STACKS"] = "all-stacks"; + /** + * Returns all stacks in the main (top level) assembly only. + */ + StackSelectionStrategy["MAIN_ASSEMBLY"] = "main-assembly"; + /** + * If the assembly includes a single stack, returns it. + * Otherwise throws an exception. + */ + StackSelectionStrategy["ONLY_SINGLE"] = "only-single"; + /** + * Return stacks matched by patterns. + * If no stacks are found, execution is halted successfully. + * Most likely you don't want to use this but `StackSelectionStrategy.MUST_MATCH_PATTERN` + */ + StackSelectionStrategy["PATTERN_MATCH"] = "pattern-match"; + /** + * Return stacks matched by patterns. + * Throws an exception if the patterns don't match at least one stack in the assembly. + */ + StackSelectionStrategy["PATTERN_MUST_MATCH"] = "pattern-must-match"; + /** + * Returns if exactly one stack is matched by the pattern(s). + * Throws an exception if no stack, or more than exactly one stack are matched. + */ + StackSelectionStrategy["PATTERN_MUST_MATCH_SINGLE"] = "pattern-must-match-single"; +})(StackSelectionStrategy || (exports.StackSelectionStrategy = StackSelectionStrategy = {})); +/** + * When selecting stacks, what other stacks to include because of dependencies + */ +var ExpandStackSelection; +(function (ExpandStackSelection) { + /** + * Don't select any extra stacks + */ + ExpandStackSelection["NONE"] = "none"; + /** + * Include stacks that this stack depends on + */ + ExpandStackSelection["UPSTREAM"] = "upstream"; + /** + * Include stacks that depend on this stack + */ + ExpandStackSelection["DOWNSTREAM"] = "downstream"; + /** + * @TODO + * Include both directions. + * I.e. stacks that this stack depends on, and stacks that depend on this stack. + */ + // FULL = 'full', +})(ExpandStackSelection || (exports.ExpandStackSelection = ExpandStackSelection = {})); +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RhY2stc2VsZWN0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXBpL2Nsb3VkLWFzc2VtYmx5L3N0YWNrLXNlbGVjdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBOztHQUVHO0FBQ0gsSUFBWSxzQkFvQ1g7QUFwQ0QsV0FBWSxzQkFBc0I7SUFDaEM7OztPQUdHO0lBQ0gsbURBQXlCLENBQUE7SUFFekI7O09BRUc7SUFDSCx5REFBK0IsQ0FBQTtJQUUvQjs7O09BR0c7SUFDSCxxREFBMkIsQ0FBQTtJQUUzQjs7OztPQUlHO0lBQ0gseURBQStCLENBQUE7SUFFL0I7OztPQUdHO0lBQ0gsbUVBQXlDLENBQUE7SUFFekM7OztPQUdHO0lBQ0gsaUZBQXVELENBQUE7QUFDekQsQ0FBQyxFQXBDVyxzQkFBc0Isc0NBQXRCLHNCQUFzQixRQW9DakM7QUFFRDs7R0FFRztBQUNILElBQVksb0JBc0JYO0FBdEJELFdBQVksb0JBQW9CO0lBQzlCOztPQUVHO0lBQ0gscUNBQWEsQ0FBQTtJQUViOztPQUVHO0lBQ0gsNkNBQXFCLENBQUE7SUFFckI7O09BRUc7SUFDSCxpREFBeUIsQ0FBQTtJQUV6Qjs7OztPQUlHO0lBQ0gsaUJBQWlCO0FBQ25CLENBQUMsRUF0Qlcsb0JBQW9CLG9DQUFwQixvQkFBb0IsUUFzQi9CIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBXaGljaCBzdGFja3Mgc2hvdWxkIGJlIHNlbGVjdGVkIGZyb20gYSBjbG91ZCBhc3NlbWJseVxuICovXG5leHBvcnQgZW51bSBTdGFja1NlbGVjdGlvblN0cmF0ZWd5IHtcbiAgLyoqXG4gICAqIFJldHVybnMgYWxsIHN0YWNrcyBpbiB0aGUgYXBwIHJlZ2FyZGxlc3Mgb2YgcGF0dGVybnMsXG4gICAqIGluY2x1ZGluZyBzdGFja3MgaW5zaWRlIG5lc3RlZCBhc3NlbWJsaWVzLlxuICAgKi9cbiAgQUxMX1NUQUNLUyA9ICdhbGwtc3RhY2tzJyxcblxuICAvKipcbiAgICogUmV0dXJucyBhbGwgc3RhY2tzIGluIHRoZSBtYWluICh0b3AgbGV2ZWwpIGFzc2VtYmx5IG9ubHkuXG4gICAqL1xuICBNQUlOX0FTU0VNQkxZID0gJ21haW4tYXNzZW1ibHknLFxuXG4gIC8qKlxuICAgKiBJZiB0aGUgYXNzZW1ibHkgaW5jbHVkZXMgYSBzaW5nbGUgc3RhY2ssIHJldHVybnMgaXQuXG4gICAqIE90aGVyd2lzZSB0aHJvd3MgYW4gZXhjZXB0aW9uLlxuICAgKi9cbiAgT05MWV9TSU5HTEUgPSAnb25seS1zaW5nbGUnLFxuXG4gIC8qKlxuICAgKiBSZXR1cm4gc3RhY2tzIG1hdGNoZWQgYnkgcGF0dGVybnMuXG4gICAqIElmIG5vIHN0YWNrcyBhcmUgZm91bmQsIGV4ZWN1dGlvbiBpcyBoYWx0ZWQgc3VjY2Vzc2Z1bGx5LlxuICAgKiBNb3N0IGxpa2VseSB5b3UgZG9uJ3Qgd2FudCB0byB1c2UgdGhpcyBidXQgYFN0YWNrU2VsZWN0aW9uU3RyYXRlZ3kuTVVTVF9NQVRDSF9QQVRURVJOYFxuICAgKi9cbiAgUEFUVEVSTl9NQVRDSCA9ICdwYXR0ZXJuLW1hdGNoJyxcblxuICAvKipcbiAgICogUmV0dXJuIHN0YWNrcyBtYXRjaGVkIGJ5IHBhdHRlcm5zLlxuICAgKiBUaHJvd3MgYW4gZXhjZXB0aW9uIGlmIHRoZSBwYXR0ZXJucyBkb24ndCBtYXRjaCBhdCBsZWFzdCBvbmUgc3RhY2sgaW4gdGhlIGFzc2VtYmx5LlxuICAgKi9cbiAgUEFUVEVSTl9NVVNUX01BVENIID0gJ3BhdHRlcm4tbXVzdC1tYXRjaCcsXG5cbiAgLyoqXG4gICAqIFJldHVybnMgaWYgZXhhY3RseSBvbmUgc3RhY2sgaXMgbWF0Y2hlZCBieSB0aGUgcGF0dGVybihzKS5cbiAgICogVGhyb3dzIGFuIGV4Y2VwdGlvbiBpZiBubyBzdGFjaywgb3IgbW9yZSB0aGFuIGV4YWN0bHkgb25lIHN0YWNrIGFyZSBtYXRjaGVkLlxuICAgKi9cbiAgUEFUVEVSTl9NVVNUX01BVENIX1NJTkdMRSA9ICdwYXR0ZXJuLW11c3QtbWF0Y2gtc2luZ2xlJyxcbn1cblxuLyoqXG4gKiBXaGVuIHNlbGVjdGluZyBzdGFja3MsIHdoYXQgb3RoZXIgc3RhY2tzIHRvIGluY2x1ZGUgYmVjYXVzZSBvZiBkZXBlbmRlbmNpZXNcbiAqL1xuZXhwb3J0IGVudW0gRXhwYW5kU3RhY2tTZWxlY3Rpb24ge1xuICAvKipcbiAgICogRG9uJ3Qgc2VsZWN0IGFueSBleHRyYSBzdGFja3NcbiAgICovXG4gIE5PTkUgPSAnbm9uZScsXG5cbiAgLyoqXG4gICAqIEluY2x1ZGUgc3RhY2tzIHRoYXQgdGhpcyBzdGFjayBkZXBlbmRzIG9uXG4gICAqL1xuICBVUFNUUkVBTSA9ICd1cHN0cmVhbScsXG5cbiAgLyoqXG4gICAqIEluY2x1ZGUgc3RhY2tzIHRoYXQgZGVwZW5kIG9uIHRoaXMgc3RhY2tcbiAgICovXG4gIERPV05TVFJFQU0gPSAnZG93bnN0cmVhbScsXG5cbiAgLyoqXG4gICAqIEBUT0RPXG4gICAqIEluY2x1ZGUgYm90aCBkaXJlY3Rpb25zLlxuICAgKiBJLmUuIHN0YWNrcyB0aGF0IHRoaXMgc3RhY2sgZGVwZW5kcyBvbiwgYW5kIHN0YWNrcyB0aGF0IGRlcGVuZCBvbiB0aGlzIHN0YWNrLlxuICAgKi9cbiAgLy8gRlVMTCA9ICdmdWxsJyxcbn1cblxuLyoqXG4gKiBBIHNwZWNpZmljYXRpb24gb2Ygd2hpY2ggc3RhY2tzIHNob3VsZCBiZSBzZWxlY3RlZFxuICovXG5leHBvcnQgaW50ZXJmYWNlIFN0YWNrU2VsZWN0b3Ige1xuICAvKipcbiAgICogVGhlIGJlaGF2aW9yIGlmIGlmIG5vIHNlbGVjdG9ycyBhcmUgcHJvdmlkZWQuXG4gICAqL1xuICBzdHJhdGVneTogU3RhY2tTZWxlY3Rpb25TdHJhdGVneTtcblxuICAvKipcbiAgICogQSBsaXN0IG9mIHBhdHRlcm5zIHRvIG1hdGNoIHRoZSBzdGFjayBoaWVyYXJjaGljYWwgaWRzXG4gICAqIE9ubHkgdXNlZCB3aXRoIGBQQVRURVJOXypgIHNlbGVjdGlvbiBzdHJhdGVnaWVzLlxuICAgKi9cbiAgcGF0dGVybnM/OiBzdHJpbmdbXTtcblxuICAvKipcbiAgICogRXhwYW5kIHRoZSBzZWxlY3Rpb24gdG8gdXBzdHJlYW0vZG93bnN0cmVhbSBzdGFja3MuXG4gICAqIEBkZWZhdWx0IEV4cGFuZFN0YWNrU2VsZWN0aW9uLk5vbmUgb25seSBzZWxlY3QgdGhlIHNwZWNpZmllZC9tYXRjaGVkIHN0YWNrc1xuICAgKi9cbiAgZXhwYW5kPzogRXhwYW5kU3RhY2tTZWxlY3Rpb247XG5cbiAgLyoqXG4gICAqIEJ5IGRlZmF1bHQsIHdlIHRocm93IGFuIGV4Y2VwdGlvbiBpZiB0aGUgYXNzZW1ibHkgY29udGFpbnMgbm8gc3RhY2tzLlxuICAgKiBTZXQgdG8gYGZhbHNlYCwgdG8gaGFsdCBleGVjdXRpb24gZm9yIGVtcHR5IGFzc2VtYmxpZXMgd2l0aG91dCBlcnJvci5cbiAgICpcbiAgICogTm90ZSB0aGF0IGFjdGlvbnMgY2FuIHN0aWxsIHRocm93IGlmIGEgc3RhY2sgc2VsZWN0aW9uIHJlc3VsdCBpcyBlbXB0eSxcbiAgICogYnV0IHRoZSBhc3NlbWJseSBjb250YWlucyBzdGFja3MgaW4gcHJpbmNpcGxlLlxuICAgKlxuICAgKiBAZGVmYXVsdCB0cnVlXG4gICAqL1xuICBmYWlsT25FbXB0eT86IGJvb2xlYW47XG59XG4iXX0= \ No newline at end of file diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloudformation/evaluate-cloudformation-template.d.ts b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloudformation/evaluate-cloudformation-template.d.ts new file mode 100644 index 000000000..461c34402 --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloudformation/evaluate-cloudformation-template.d.ts @@ -0,0 +1,85 @@ +import type { CloudFormationStackArtifact } from '@aws-cdk/cx-api'; +import type { Export, StackResourceSummary } from '@aws-sdk/client-cloudformation'; +import type { SDK } from '../aws-auth'; +import type { NestedStackTemplates } from './nested-stack-helpers'; +import type { Template } from './stack-helpers'; +import type { ResourceMetadata } from '../resource-metadata'; +export interface ListStackResources { + listStackResources(): Promise; +} +export declare class LazyListStackResources implements ListStackResources { + private readonly sdk; + private readonly stackName; + private stackResources; + constructor(sdk: SDK, stackName: string); + listStackResources(): Promise; +} +export interface LookupExport { + lookupExport(name: string): Promise; +} +export declare class LookupExportError extends Error { +} +export declare class LazyLookupExport implements LookupExport { + private readonly sdk; + private cachedExports; + constructor(sdk: SDK); + lookupExport(name: string): Promise; + private listExports; +} +export declare class CfnEvaluationException extends Error { +} +export interface ResourceDefinition { + readonly LogicalId: string; + readonly Type: string; + readonly Properties: { + [p: string]: any; + }; +} +export interface EvaluateCloudFormationTemplateProps { + readonly stackArtifact: CloudFormationStackArtifact; + readonly stackName?: string; + readonly template?: Template; + readonly parameters: { + [parameterName: string]: string; + }; + readonly account: string; + readonly region: string; + readonly partition: string; + readonly sdk: SDK; + readonly nestedStacks?: { + [nestedStackLogicalId: string]: NestedStackTemplates; + }; +} +export declare class EvaluateCloudFormationTemplate { + readonly stackArtifact: CloudFormationStackArtifact; + private readonly stackName; + private readonly template; + private readonly context; + private readonly account; + private readonly region; + private readonly partition; + private readonly sdk; + private readonly nestedStacks; + private readonly stackResources; + private readonly lookupExport; + private cachedUrlSuffix; + constructor(props: EvaluateCloudFormationTemplateProps); + createNestedEvaluateCloudFormationTemplate(stackName: string, nestedTemplate: Template, nestedStackParameters: { + [parameterName: string]: any; + }): Promise; + establishResourcePhysicalName(logicalId: string, physicalNameInCfnTemplate: any): Promise; + findPhysicalNameFor(logicalId: string): Promise; + findLogicalIdForPhysicalName(physicalName: string): Promise; + findReferencesTo(logicalId: string): Array; + evaluateCfnExpression(cfnExpression: any): Promise; + getResourceProperty(logicalId: string, propertyName: string): any; + metadataFor(logicalId: string): ResourceMetadata | undefined; + private references; + private parseIntrinsic; + private findRefTarget; + private findGetAttTarget; + private findNestedStack; + private formatResourceAttribute; + private getServiceOfResource; + private getResourceTypeArnPartOfResource; +} diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloudformation/evaluate-cloudformation-template.js b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloudformation/evaluate-cloudformation-template.js new file mode 100644 index 000000000..8c866cdb1 --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloudformation/evaluate-cloudformation-template.js @@ -0,0 +1,456 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.EvaluateCloudFormationTemplate = exports.CfnEvaluationException = exports.LazyLookupExport = exports.LookupExportError = exports.LazyListStackResources = void 0; +const toolkit_error_1 = require("../toolkit-error"); +const resource_metadata_1 = require("../resource-metadata"); +class LazyListStackResources { + sdk; + stackName; + stackResources; + constructor(sdk, stackName) { + this.sdk = sdk; + this.stackName = stackName; + } + async listStackResources() { + if (this.stackResources === undefined) { + this.stackResources = this.sdk.cloudFormation().listStackResources({ + StackName: this.stackName, + }); + } + return this.stackResources; + } +} +exports.LazyListStackResources = LazyListStackResources; +class LookupExportError extends Error { +} +exports.LookupExportError = LookupExportError; +class LazyLookupExport { + sdk; + cachedExports = {}; + constructor(sdk) { + this.sdk = sdk; + } + async lookupExport(name) { + if (this.cachedExports[name]) { + return this.cachedExports[name]; + } + for await (const cfnExport of this.listExports()) { + if (!cfnExport.Name) { + continue; // ignore any result that omits a name + } + this.cachedExports[cfnExport.Name] = cfnExport; + if (cfnExport.Name === name) { + return cfnExport; + } + } + return undefined; // export not found + } + // TODO: Paginate + async *listExports() { + let nextToken = undefined; + while (true) { + const response = await this.sdk.cloudFormation().listExports({ NextToken: nextToken }); + for (const cfnExport of response.Exports ?? []) { + yield cfnExport; + } + if (!response.NextToken) { + return; + } + nextToken = response.NextToken; + } + } +} +exports.LazyLookupExport = LazyLookupExport; +class CfnEvaluationException extends Error { +} +exports.CfnEvaluationException = CfnEvaluationException; +class EvaluateCloudFormationTemplate { + stackArtifact; + stackName; + template; + context; + account; + region; + partition; + sdk; + nestedStacks; + stackResources; + lookupExport; + cachedUrlSuffix; + constructor(props) { + this.stackArtifact = props.stackArtifact; + this.stackName = props.stackName ?? props.stackArtifact.stackName; + this.template = props.template ?? props.stackArtifact.template; + this.context = { + 'AWS::AccountId': props.account, + 'AWS::Region': props.region, + 'AWS::Partition': props.partition, + ...props.parameters, + }; + this.account = props.account; + this.region = props.region; + this.partition = props.partition; + this.sdk = props.sdk; + // We need names of nested stack so we can evaluate cross stack references + this.nestedStacks = props.nestedStacks ?? {}; + // The current resources of the Stack. + // We need them to figure out the physical name of a resource in case it wasn't specified by the user. + // We fetch it lazily, to save a service call, in case all hotswapped resources have their physical names set. + this.stackResources = new LazyListStackResources(this.sdk, this.stackName); + // CloudFormation Exports lookup to be able to resolve Fn::ImportValue intrinsics in template + this.lookupExport = new LazyLookupExport(this.sdk); + } + // clones current EvaluateCloudFormationTemplate object, but updates the stack name + async createNestedEvaluateCloudFormationTemplate(stackName, nestedTemplate, nestedStackParameters) { + const evaluatedParams = await this.evaluateCfnExpression(nestedStackParameters); + return new EvaluateCloudFormationTemplate({ + stackArtifact: this.stackArtifact, + stackName, + template: nestedTemplate, + parameters: evaluatedParams, + account: this.account, + region: this.region, + partition: this.partition, + sdk: this.sdk, + nestedStacks: this.nestedStacks, + }); + } + async establishResourcePhysicalName(logicalId, physicalNameInCfnTemplate) { + if (physicalNameInCfnTemplate != null) { + try { + return await this.evaluateCfnExpression(physicalNameInCfnTemplate); + } + catch (e) { + // If we can't evaluate the resource's name CloudFormation expression, + // just look it up in the currently deployed Stack + if (!(e instanceof CfnEvaluationException)) { + throw e; + } + } + } + return this.findPhysicalNameFor(logicalId); + } + async findPhysicalNameFor(logicalId) { + const stackResources = await this.stackResources.listStackResources(); + return stackResources.find((sr) => sr.LogicalResourceId === logicalId)?.PhysicalResourceId; + } + async findLogicalIdForPhysicalName(physicalName) { + const stackResources = await this.stackResources.listStackResources(); + return stackResources.find((sr) => sr.PhysicalResourceId === physicalName)?.LogicalResourceId; + } + findReferencesTo(logicalId) { + const ret = new Array(); + for (const [resourceLogicalId, resourceDef] of Object.entries(this.template?.Resources ?? {})) { + if (logicalId !== resourceLogicalId && this.references(logicalId, resourceDef)) { + ret.push({ + ...resourceDef, + LogicalId: resourceLogicalId, + }); + } + } + return ret; + } + async evaluateCfnExpression(cfnExpression) { + const self = this; + /** + * Evaluates CloudFormation intrinsic functions + * + * Note that supported intrinsic functions are documented in README.md -- please update + * list of supported functions when adding new evaluations + * + * See: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference.html + */ + class CfnIntrinsics { + evaluateIntrinsic(intrinsic) { + const intrinsicFunc = this[intrinsic.name]; + if (!intrinsicFunc) { + throw new CfnEvaluationException(`CloudFormation function ${intrinsic.name} is not supported`); + } + const argsAsArray = Array.isArray(intrinsic.args) ? intrinsic.args : [intrinsic.args]; + return intrinsicFunc.apply(this, argsAsArray); + } + async 'Fn::Join'(separator, args) { + const evaluatedArgs = await self.evaluateCfnExpression(args); + return evaluatedArgs.join(separator); + } + async 'Fn::Split'(separator, args) { + const evaluatedArgs = await self.evaluateCfnExpression(args); + return evaluatedArgs.split(separator); + } + async 'Fn::Select'(index, args) { + const evaluatedArgs = await self.evaluateCfnExpression(args); + return evaluatedArgs[index]; + } + async Ref(logicalId) { + const refTarget = await self.findRefTarget(logicalId); + if (refTarget) { + return refTarget; + } + else { + throw new CfnEvaluationException(`Parameter or resource '${logicalId}' could not be found for evaluation`); + } + } + async 'Fn::GetAtt'(logicalId, attributeName) { + // ToDo handle the 'logicalId.attributeName' form of Fn::GetAtt + const attrValue = await self.findGetAttTarget(logicalId, attributeName); + if (attrValue) { + return attrValue; + } + else { + throw new CfnEvaluationException(`Attribute '${attributeName}' of resource '${logicalId}' could not be found for evaluation`); + } + } + async 'Fn::Sub'(template, explicitPlaceholders) { + const placeholders = explicitPlaceholders ? await self.evaluateCfnExpression(explicitPlaceholders) : {}; + return asyncGlobalReplace(template, /\${([^}]*)}/g, (key) => { + if (key in placeholders) { + return placeholders[key]; + } + else { + const splitKey = key.split('.'); + return splitKey.length === 1 ? this.Ref(key) : this['Fn::GetAtt'](splitKey[0], splitKey.slice(1).join('.')); + } + }); + } + async 'Fn::ImportValue'(name) { + const exported = await self.lookupExport.lookupExport(name); + if (!exported) { + throw new CfnEvaluationException(`Export '${name}' could not be found for evaluation`); + } + if (!exported.Value) { + throw new CfnEvaluationException(`Export '${name}' exists without a value`); + } + return exported.Value; + } + } + if (cfnExpression == null) { + return cfnExpression; + } + if (Array.isArray(cfnExpression)) { + // Small arrays in practice + // eslint-disable-next-line @cdklabs/promiseall-no-unbounded-parallelism + return Promise.all(cfnExpression.map((expr) => this.evaluateCfnExpression(expr))); + } + if (typeof cfnExpression === 'object') { + const intrinsic = this.parseIntrinsic(cfnExpression); + if (intrinsic) { + return new CfnIntrinsics().evaluateIntrinsic(intrinsic); + } + else { + const ret = {}; + for (const [key, val] of Object.entries(cfnExpression)) { + ret[key] = await this.evaluateCfnExpression(val); + } + return ret; + } + } + return cfnExpression; + } + getResourceProperty(logicalId, propertyName) { + return this.template.Resources?.[logicalId]?.Properties?.[propertyName]; + } + metadataFor(logicalId) { + return (0, resource_metadata_1.resourceMetadata)(this.stackArtifact, logicalId); + } + references(logicalId, templateElement) { + if (typeof templateElement === 'string') { + return logicalId === templateElement; + } + if (templateElement == null) { + return false; + } + if (Array.isArray(templateElement)) { + return templateElement.some((el) => this.references(logicalId, el)); + } + if (typeof templateElement === 'object') { + return Object.values(templateElement).some((el) => this.references(logicalId, el)); + } + return false; + } + parseIntrinsic(x) { + const keys = Object.keys(x); + if (keys.length === 1 && (keys[0].startsWith('Fn::') || keys[0] === 'Ref')) { + return { + name: keys[0], + args: x[keys[0]], + }; + } + return undefined; + } + async findRefTarget(logicalId) { + // first, check to see if the Ref is a Parameter who's value we have + if (logicalId === 'AWS::URLSuffix') { + if (!this.cachedUrlSuffix) { + this.cachedUrlSuffix = await this.sdk.getUrlSuffix(this.region); + } + return this.cachedUrlSuffix; + } + // Try finding the ref in the passed in parameters + const parameterTarget = this.context[logicalId]; + if (parameterTarget) { + return parameterTarget; + } + // If not in the passed in parameters, see if there is a default value in the template parameter that was not passed in + const defaultParameterValue = this.template.Parameters?.[logicalId]?.Default; + if (defaultParameterValue) { + return defaultParameterValue; + } + // if it's not a Parameter, we need to search in the current Stack resources + return this.findGetAttTarget(logicalId); + } + async findGetAttTarget(logicalId, attribute) { + // Handle case where the attribute is referencing a stack output (used in nested stacks to share parameters) + // See https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/quickref-cloudformation.html#w2ab1c17c23c19b5 + if (logicalId === 'Outputs' && attribute) { + return this.evaluateCfnExpression(this.template.Outputs[attribute]?.Value); + } + const stackResources = await this.stackResources.listStackResources(); + const foundResource = stackResources.find((sr) => sr.LogicalResourceId === logicalId); + if (!foundResource) { + return undefined; + } + if (foundResource.ResourceType == 'AWS::CloudFormation::Stack' && attribute?.startsWith('Outputs.')) { + const dependantStack = this.findNestedStack(logicalId, this.nestedStacks); + if (!dependantStack || !dependantStack.physicalName) { + // this is a newly created nested stack and cannot be hotswapped + return undefined; + } + const evaluateCfnTemplate = await this.createNestedEvaluateCloudFormationTemplate(dependantStack.physicalName, dependantStack.generatedTemplate, dependantStack.generatedTemplate.Parameters); + // Split Outputs. into 'Outputs' and '' and recursively call evaluate + return evaluateCfnTemplate.evaluateCfnExpression({ + 'Fn::GetAtt': attribute.split(/\.(.*)/s), + }); + } + // now, we need to format the appropriate identifier depending on the resource type, + // and the requested attribute name + return this.formatResourceAttribute(foundResource, attribute); + } + findNestedStack(logicalId, nestedStacks) { + for (const nestedStackLogicalId of Object.keys(nestedStacks)) { + if (nestedStackLogicalId === logicalId) { + return nestedStacks[nestedStackLogicalId]; + } + const checkInNestedChildStacks = this.findNestedStack(logicalId, nestedStacks[nestedStackLogicalId].nestedStackTemplates); + if (checkInNestedChildStacks) + return checkInNestedChildStacks; + } + return undefined; + } + formatResourceAttribute(resource, attribute) { + const physicalId = resource.PhysicalResourceId; + // no attribute means Ref expression, for which we use the physical ID directly + if (!attribute) { + return physicalId; + } + const resourceTypeFormats = RESOURCE_TYPE_ATTRIBUTES_FORMATS[resource.ResourceType]; + if (!resourceTypeFormats) { + throw new CfnEvaluationException(`We don't support attributes of the '${resource.ResourceType}' resource. This is a CDK limitation. ` + + 'Please report it at https://github.com/aws/aws-cdk/issues/new/choose'); + } + const attributeFmtFunc = resourceTypeFormats[attribute]; + if (!attributeFmtFunc) { + throw new CfnEvaluationException(`We don't support the '${attribute}' attribute of the '${resource.ResourceType}' resource. This is a CDK limitation. ` + + 'Please report it at https://github.com/aws/aws-cdk/issues/new/choose'); + } + const service = this.getServiceOfResource(resource); + const resourceTypeArnPart = this.getResourceTypeArnPartOfResource(resource); + return attributeFmtFunc({ + partition: this.partition, + service, + region: this.region, + account: this.account, + resourceType: resourceTypeArnPart, + resourceName: physicalId, + }); + } + getServiceOfResource(resource) { + return resource.ResourceType.split('::')[1].toLowerCase(); + } + getResourceTypeArnPartOfResource(resource) { + const resourceType = resource.ResourceType; + const specialCaseResourceType = RESOURCE_TYPE_SPECIAL_NAMES[resourceType]?.resourceType; + return specialCaseResourceType + ? specialCaseResourceType + : // this is the default case + resourceType.split('::')[2].toLowerCase(); + } +} +exports.EvaluateCloudFormationTemplate = EvaluateCloudFormationTemplate; +/** + * Usually, we deduce the names of the service and the resource type used to format the ARN from the CloudFormation resource type. + * For a CFN type like AWS::Service::ResourceType, the second segment becomes the service name, and the third the resource type + * (after converting both of them to lowercase). + * However, some resource types break this simple convention, and we need to special-case them. + * This map is for storing those cases. + */ +const RESOURCE_TYPE_SPECIAL_NAMES = { + 'AWS::Events::EventBus': { + resourceType: 'event-bus', + }, +}; +const RESOURCE_TYPE_ATTRIBUTES_FORMATS = { + 'AWS::IAM::Role': { Arn: iamArnFmt }, + 'AWS::IAM::User': { Arn: iamArnFmt }, + 'AWS::IAM::Group': { Arn: iamArnFmt }, + 'AWS::S3::Bucket': { Arn: s3ArnFmt }, + 'AWS::Lambda::Function': { Arn: stdColonResourceArnFmt }, + 'AWS::Events::EventBus': { + Arn: stdSlashResourceArnFmt, + // the name attribute of the EventBus is the same as the Ref + Name: (parts) => parts.resourceName, + }, + 'AWS::DynamoDB::Table': { Arn: stdSlashResourceArnFmt }, + 'AWS::AppSync::GraphQLApi': { ApiId: appsyncGraphQlApiApiIdFmt }, + 'AWS::AppSync::FunctionConfiguration': { + FunctionId: appsyncGraphQlFunctionIDFmt, + }, + 'AWS::AppSync::DataSource': { Name: appsyncGraphQlDataSourceNameFmt }, + 'AWS::KMS::Key': { Arn: stdSlashResourceArnFmt }, +}; +function iamArnFmt(parts) { + // we skip region for IAM resources + return `arn:${parts.partition}:${parts.service}::${parts.account}:${parts.resourceType}/${parts.resourceName}`; +} +function s3ArnFmt(parts) { + // we skip account, region and resourceType for S3 resources + return `arn:${parts.partition}:${parts.service}:::${parts.resourceName}`; +} +function stdColonResourceArnFmt(parts) { + // this is a standard format for ARNs like: arn:aws:service:region:account:resourceType:resourceName + return `arn:${parts.partition}:${parts.service}:${parts.region}:${parts.account}:${parts.resourceType}:${parts.resourceName}`; +} +function stdSlashResourceArnFmt(parts) { + // this is a standard format for ARNs like: arn:aws:service:region:account:resourceType/resourceName + return `arn:${parts.partition}:${parts.service}:${parts.region}:${parts.account}:${parts.resourceType}/${parts.resourceName}`; +} +function appsyncGraphQlApiApiIdFmt(parts) { + // arn:aws:appsync:us-east-1:111111111111:apis/ + return parts.resourceName.split('/')[1]; +} +function appsyncGraphQlFunctionIDFmt(parts) { + // arn:aws:appsync:us-east-1:111111111111:apis//functions/ + return parts.resourceName.split('/')[3]; +} +function appsyncGraphQlDataSourceNameFmt(parts) { + // arn:aws:appsync:us-east-1:111111111111:apis//datasources/ + return parts.resourceName.split('/')[3]; +} +async function asyncGlobalReplace(str, regex, cb) { + if (!regex.global) { + throw new toolkit_error_1.ToolkitError('Regex must be created with /g flag'); + } + const ret = new Array(); + let start = 0; + while (true) { + const match = regex.exec(str); + if (!match) { + break; + } + ret.push(str.substring(start, match.index)); + ret.push(await cb(match[1])); + start = regex.lastIndex; + } + ret.push(str.slice(start)); + return ret.join(''); +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"evaluate-cloudformation-template.js","sourceRoot":"","sources":["../../../src/api/cloudformation/evaluate-cloudformation-template.ts"],"names":[],"mappings":"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","sourcesContent":["import type { CloudFormationStackArtifact } from '@aws-cdk/cx-api';\nimport type { Export, ListExportsCommandOutput, StackResourceSummary } from '@aws-sdk/client-cloudformation';\nimport type { SDK } from '../aws-auth';\nimport { ToolkitError } from '../toolkit-error';\nimport type { NestedStackTemplates } from './nested-stack-helpers';\nimport type { Template } from './stack-helpers';\nimport type { ResourceMetadata } from '../resource-metadata';\nimport { resourceMetadata } from '../resource-metadata';\n\nexport interface ListStackResources {\n  listStackResources(): Promise<StackResourceSummary[]>;\n}\n\nexport class LazyListStackResources implements ListStackResources {\n  private stackResources: Promise<StackResourceSummary[]> | undefined;\n\n  constructor(\n    private readonly sdk: SDK,\n    private readonly stackName: string,\n  ) {\n  }\n\n  public async listStackResources(): Promise<StackResourceSummary[]> {\n    if (this.stackResources === undefined) {\n      this.stackResources = this.sdk.cloudFormation().listStackResources({\n        StackName: this.stackName,\n      });\n    }\n    return this.stackResources;\n  }\n}\n\nexport interface LookupExport {\n  lookupExport(name: string): Promise<Export | undefined>;\n}\n\nexport class LookupExportError extends Error {\n}\n\nexport class LazyLookupExport implements LookupExport {\n  private cachedExports: { [name: string]: Export } = {};\n\n  constructor(private readonly sdk: SDK) {\n  }\n\n  async lookupExport(name: string): Promise<Export | undefined> {\n    if (this.cachedExports[name]) {\n      return this.cachedExports[name];\n    }\n\n    for await (const cfnExport of this.listExports()) {\n      if (!cfnExport.Name) {\n        continue; // ignore any result that omits a name\n      }\n      this.cachedExports[cfnExport.Name] = cfnExport;\n\n      if (cfnExport.Name === name) {\n        return cfnExport;\n      }\n    }\n\n    return undefined; // export not found\n  }\n\n  // TODO: Paginate\n  private async *listExports() {\n    let nextToken: string | undefined = undefined;\n    while (true) {\n      const response: ListExportsCommandOutput = await this.sdk.cloudFormation().listExports({ NextToken: nextToken });\n      for (const cfnExport of response.Exports ?? []) {\n        yield cfnExport;\n      }\n\n      if (!response.NextToken) {\n        return;\n      }\n      nextToken = response.NextToken;\n    }\n  }\n}\n\nexport class CfnEvaluationException extends Error {\n}\n\nexport interface ResourceDefinition {\n  readonly LogicalId: string;\n  readonly Type: string;\n  readonly Properties: { [p: string]: any };\n}\n\nexport interface EvaluateCloudFormationTemplateProps {\n  readonly stackArtifact: CloudFormationStackArtifact;\n  readonly stackName?: string;\n  readonly template?: Template;\n  readonly parameters: { [parameterName: string]: string };\n  readonly account: string;\n  readonly region: string;\n  readonly partition: string;\n  readonly sdk: SDK;\n  readonly nestedStacks?: {\n    [nestedStackLogicalId: string]: NestedStackTemplates;\n  };\n}\n\nexport class EvaluateCloudFormationTemplate {\n  public readonly stackArtifact: CloudFormationStackArtifact;\n  private readonly stackName: string;\n  private readonly template: Template;\n  private readonly context: { [k: string]: any };\n  private readonly account: string;\n  private readonly region: string;\n  private readonly partition: string;\n  private readonly sdk: SDK;\n  private readonly nestedStacks: {\n    [nestedStackLogicalId: string]: NestedStackTemplates;\n  };\n  private readonly stackResources: ListStackResources;\n  private readonly lookupExport: LookupExport;\n\n  private cachedUrlSuffix: string | undefined;\n\n  constructor(props: EvaluateCloudFormationTemplateProps) {\n    this.stackArtifact = props.stackArtifact;\n    this.stackName = props.stackName ?? props.stackArtifact.stackName;\n    this.template = props.template ?? props.stackArtifact.template;\n    this.context = {\n      'AWS::AccountId': props.account,\n      'AWS::Region': props.region,\n      'AWS::Partition': props.partition,\n      ...props.parameters,\n    };\n    this.account = props.account;\n    this.region = props.region;\n    this.partition = props.partition;\n    this.sdk = props.sdk;\n\n    // We need names of nested stack so we can evaluate cross stack references\n    this.nestedStacks = props.nestedStacks ?? {};\n\n    // The current resources of the Stack.\n    // We need them to figure out the physical name of a resource in case it wasn't specified by the user.\n    // We fetch it lazily, to save a service call, in case all hotswapped resources have their physical names set.\n    this.stackResources = new LazyListStackResources(this.sdk, this.stackName);\n\n    // CloudFormation Exports lookup to be able to resolve Fn::ImportValue intrinsics in template\n    this.lookupExport = new LazyLookupExport(this.sdk);\n  }\n\n  // clones current EvaluateCloudFormationTemplate object, but updates the stack name\n  public async createNestedEvaluateCloudFormationTemplate(\n    stackName: string,\n    nestedTemplate: Template,\n    nestedStackParameters: { [parameterName: string]: any },\n  ) {\n    const evaluatedParams = await this.evaluateCfnExpression(nestedStackParameters);\n    return new EvaluateCloudFormationTemplate({\n      stackArtifact: this.stackArtifact,\n      stackName,\n      template: nestedTemplate,\n      parameters: evaluatedParams,\n      account: this.account,\n      region: this.region,\n      partition: this.partition,\n      sdk: this.sdk,\n      nestedStacks: this.nestedStacks,\n    });\n  }\n\n  public async establishResourcePhysicalName(\n    logicalId: string,\n    physicalNameInCfnTemplate: any,\n  ): Promise<string | undefined> {\n    if (physicalNameInCfnTemplate != null) {\n      try {\n        return await this.evaluateCfnExpression(physicalNameInCfnTemplate);\n      } catch (e) {\n        // If we can't evaluate the resource's name CloudFormation expression,\n        // just look it up in the currently deployed Stack\n        if (!(e instanceof CfnEvaluationException)) {\n          throw e;\n        }\n      }\n    }\n    return this.findPhysicalNameFor(logicalId);\n  }\n\n  public async findPhysicalNameFor(logicalId: string): Promise<string | undefined> {\n    const stackResources = await this.stackResources.listStackResources();\n    return stackResources.find((sr) => sr.LogicalResourceId === logicalId)?.PhysicalResourceId;\n  }\n\n  public async findLogicalIdForPhysicalName(physicalName: string): Promise<string | undefined> {\n    const stackResources = await this.stackResources.listStackResources();\n    return stackResources.find((sr) => sr.PhysicalResourceId === physicalName)?.LogicalResourceId;\n  }\n\n  public findReferencesTo(logicalId: string): Array<ResourceDefinition> {\n    const ret = new Array<ResourceDefinition>();\n    for (const [resourceLogicalId, resourceDef] of Object.entries(this.template?.Resources ?? {})) {\n      if (logicalId !== resourceLogicalId && this.references(logicalId, resourceDef)) {\n        ret.push({\n          ...(resourceDef as any),\n          LogicalId: resourceLogicalId,\n        });\n      }\n    }\n    return ret;\n  }\n\n  public async evaluateCfnExpression(cfnExpression: any): Promise<any> {\n    const self = this;\n    /**\n     * Evaluates CloudFormation intrinsic functions\n     *\n     * Note that supported intrinsic functions are documented in README.md -- please update\n     * list of supported functions when adding new evaluations\n     *\n     * See: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference.html\n     */\n    class CfnIntrinsics {\n      public evaluateIntrinsic(intrinsic: Intrinsic): any {\n        const intrinsicFunc = (this as any)[intrinsic.name];\n        if (!intrinsicFunc) {\n          throw new CfnEvaluationException(`CloudFormation function ${intrinsic.name} is not supported`);\n        }\n\n        const argsAsArray = Array.isArray(intrinsic.args) ? intrinsic.args : [intrinsic.args];\n\n        return intrinsicFunc.apply(this, argsAsArray);\n      }\n\n      async 'Fn::Join'(separator: string, args: any[]): Promise<string> {\n        const evaluatedArgs = await self.evaluateCfnExpression(args);\n        return evaluatedArgs.join(separator);\n      }\n\n      async 'Fn::Split'(separator: string, args: any): Promise<string> {\n        const evaluatedArgs = await self.evaluateCfnExpression(args);\n        return evaluatedArgs.split(separator);\n      }\n\n      async 'Fn::Select'(index: number, args: any[]): Promise<string> {\n        const evaluatedArgs = await self.evaluateCfnExpression(args);\n        return evaluatedArgs[index];\n      }\n\n      async Ref(logicalId: string): Promise<string> {\n        const refTarget = await self.findRefTarget(logicalId);\n        if (refTarget) {\n          return refTarget;\n        } else {\n          throw new CfnEvaluationException(`Parameter or resource '${logicalId}' could not be found for evaluation`);\n        }\n      }\n\n      async 'Fn::GetAtt'(logicalId: string, attributeName: string): Promise<string> {\n        // ToDo handle the 'logicalId.attributeName' form of Fn::GetAtt\n        const attrValue = await self.findGetAttTarget(logicalId, attributeName);\n        if (attrValue) {\n          return attrValue;\n        } else {\n          throw new CfnEvaluationException(\n            `Attribute '${attributeName}' of resource '${logicalId}' could not be found for evaluation`,\n          );\n        }\n      }\n\n      async 'Fn::Sub'(template: string, explicitPlaceholders?: { [variable: string]: string }): Promise<string> {\n        const placeholders = explicitPlaceholders ? await self.evaluateCfnExpression(explicitPlaceholders) : {};\n\n        return asyncGlobalReplace(template, /\\${([^}]*)}/g, (key) => {\n          if (key in placeholders) {\n            return placeholders[key];\n          } else {\n            const splitKey = key.split('.');\n            return splitKey.length === 1 ? this.Ref(key) : this['Fn::GetAtt'](splitKey[0], splitKey.slice(1).join('.'));\n          }\n        });\n      }\n\n      async 'Fn::ImportValue'(name: string): Promise<string> {\n        const exported = await self.lookupExport.lookupExport(name);\n        if (!exported) {\n          throw new CfnEvaluationException(`Export '${name}' could not be found for evaluation`);\n        }\n        if (!exported.Value) {\n          throw new CfnEvaluationException(`Export '${name}' exists without a value`);\n        }\n        return exported.Value;\n      }\n    }\n\n    if (cfnExpression == null) {\n      return cfnExpression;\n    }\n\n    if (Array.isArray(cfnExpression)) {\n      // Small arrays in practice\n      // eslint-disable-next-line @cdklabs/promiseall-no-unbounded-parallelism\n      return Promise.all(cfnExpression.map((expr) => this.evaluateCfnExpression(expr)));\n    }\n\n    if (typeof cfnExpression === 'object') {\n      const intrinsic = this.parseIntrinsic(cfnExpression);\n      if (intrinsic) {\n        return new CfnIntrinsics().evaluateIntrinsic(intrinsic);\n      } else {\n        const ret: { [key: string]: any } = {};\n        for (const [key, val] of Object.entries(cfnExpression)) {\n          ret[key] = await this.evaluateCfnExpression(val);\n        }\n        return ret;\n      }\n    }\n\n    return cfnExpression;\n  }\n\n  public getResourceProperty(logicalId: string, propertyName: string): any {\n    return this.template.Resources?.[logicalId]?.Properties?.[propertyName];\n  }\n\n  public metadataFor(logicalId: string): ResourceMetadata | undefined {\n    return resourceMetadata(this.stackArtifact, logicalId);\n  }\n\n  private references(logicalId: string, templateElement: any): boolean {\n    if (typeof templateElement === 'string') {\n      return logicalId === templateElement;\n    }\n\n    if (templateElement == null) {\n      return false;\n    }\n\n    if (Array.isArray(templateElement)) {\n      return templateElement.some((el) => this.references(logicalId, el));\n    }\n\n    if (typeof templateElement === 'object') {\n      return Object.values(templateElement).some((el) => this.references(logicalId, el));\n    }\n\n    return false;\n  }\n\n  private parseIntrinsic(x: any): Intrinsic | undefined {\n    const keys = Object.keys(x);\n    if (keys.length === 1 && (keys[0].startsWith('Fn::') || keys[0] === 'Ref')) {\n      return {\n        name: keys[0],\n        args: x[keys[0]],\n      };\n    }\n    return undefined;\n  }\n\n  private async findRefTarget(logicalId: string): Promise<string | undefined> {\n    // first, check to see if the Ref is a Parameter who's value we have\n    if (logicalId === 'AWS::URLSuffix') {\n      if (!this.cachedUrlSuffix) {\n        this.cachedUrlSuffix = await this.sdk.getUrlSuffix(this.region);\n      }\n\n      return this.cachedUrlSuffix;\n    }\n\n    // Try finding the ref in the passed in parameters\n    const parameterTarget = this.context[logicalId];\n    if (parameterTarget) {\n      return parameterTarget;\n    }\n\n    // If not in the passed in parameters, see if there is a default value in the template parameter that was not passed in\n    const defaultParameterValue = this.template.Parameters?.[logicalId]?.Default;\n    if (defaultParameterValue) {\n      return defaultParameterValue;\n    }\n\n    // if it's not a Parameter, we need to search in the current Stack resources\n    return this.findGetAttTarget(logicalId);\n  }\n\n  private async findGetAttTarget(logicalId: string, attribute?: string): Promise<string | undefined> {\n    // Handle case where the attribute is referencing a stack output (used in nested stacks to share parameters)\n    // See https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/quickref-cloudformation.html#w2ab1c17c23c19b5\n    if (logicalId === 'Outputs' && attribute) {\n      return this.evaluateCfnExpression(this.template.Outputs[attribute]?.Value);\n    }\n\n    const stackResources = await this.stackResources.listStackResources();\n    const foundResource = stackResources.find((sr) => sr.LogicalResourceId === logicalId);\n    if (!foundResource) {\n      return undefined;\n    }\n\n    if (foundResource.ResourceType == 'AWS::CloudFormation::Stack' && attribute?.startsWith('Outputs.')) {\n      const dependantStack = this.findNestedStack(logicalId, this.nestedStacks);\n      if (!dependantStack || !dependantStack.physicalName) {\n        // this is a newly created nested stack and cannot be hotswapped\n        return undefined;\n      }\n      const evaluateCfnTemplate = await this.createNestedEvaluateCloudFormationTemplate(\n        dependantStack.physicalName,\n        dependantStack.generatedTemplate,\n        dependantStack.generatedTemplate.Parameters!,\n      );\n\n      // Split Outputs.<refName> into 'Outputs' and '<refName>' and recursively call evaluate\n      return evaluateCfnTemplate.evaluateCfnExpression({\n        'Fn::GetAtt': attribute.split(/\\.(.*)/s),\n      });\n    }\n    // now, we need to format the appropriate identifier depending on the resource type,\n    // and the requested attribute name\n    return this.formatResourceAttribute(foundResource, attribute);\n  }\n\n  private findNestedStack(\n    logicalId: string,\n    nestedStacks: {\n      [nestedStackLogicalId: string]: NestedStackTemplates;\n    },\n  ): NestedStackTemplates | undefined {\n    for (const nestedStackLogicalId of Object.keys(nestedStacks)) {\n      if (nestedStackLogicalId === logicalId) {\n        return nestedStacks[nestedStackLogicalId];\n      }\n      const checkInNestedChildStacks = this.findNestedStack(\n        logicalId,\n        nestedStacks[nestedStackLogicalId].nestedStackTemplates,\n      );\n      if (checkInNestedChildStacks) return checkInNestedChildStacks;\n    }\n    return undefined;\n  }\n\n  private formatResourceAttribute(resource: StackResourceSummary, attribute: string | undefined): string | undefined {\n    const physicalId = resource.PhysicalResourceId;\n\n    // no attribute means Ref expression, for which we use the physical ID directly\n    if (!attribute) {\n      return physicalId;\n    }\n\n    const resourceTypeFormats = RESOURCE_TYPE_ATTRIBUTES_FORMATS[resource.ResourceType!];\n    if (!resourceTypeFormats) {\n      throw new CfnEvaluationException(\n        `We don't support attributes of the '${resource.ResourceType}' resource. This is a CDK limitation. ` +\n          'Please report it at https://github.com/aws/aws-cdk/issues/new/choose',\n      );\n    }\n    const attributeFmtFunc = resourceTypeFormats[attribute];\n    if (!attributeFmtFunc) {\n      throw new CfnEvaluationException(\n        `We don't support the '${attribute}' attribute of the '${resource.ResourceType}' resource. This is a CDK limitation. ` +\n          'Please report it at https://github.com/aws/aws-cdk/issues/new/choose',\n      );\n    }\n    const service = this.getServiceOfResource(resource);\n    const resourceTypeArnPart = this.getResourceTypeArnPartOfResource(resource);\n    return attributeFmtFunc({\n      partition: this.partition,\n      service,\n      region: this.region,\n      account: this.account,\n      resourceType: resourceTypeArnPart,\n      resourceName: physicalId!,\n    });\n  }\n\n  private getServiceOfResource(resource: StackResourceSummary): string {\n    return resource.ResourceType!.split('::')[1].toLowerCase();\n  }\n\n  private getResourceTypeArnPartOfResource(resource: StackResourceSummary): string {\n    const resourceType = resource.ResourceType!;\n    const specialCaseResourceType = RESOURCE_TYPE_SPECIAL_NAMES[resourceType]?.resourceType;\n    return specialCaseResourceType\n      ? specialCaseResourceType\n      : // this is the default case\n      resourceType.split('::')[2].toLowerCase();\n  }\n}\n\ninterface ArnParts {\n  readonly partition: string;\n  readonly service: string;\n  readonly region: string;\n  readonly account: string;\n  readonly resourceType: string;\n  readonly resourceName: string;\n}\n\n/**\n * Usually, we deduce the names of the service and the resource type used to format the ARN from the CloudFormation resource type.\n * For a CFN type like AWS::Service::ResourceType, the second segment becomes the service name, and the third the resource type\n * (after converting both of them to lowercase).\n * However, some resource types break this simple convention, and we need to special-case them.\n * This map is for storing those cases.\n */\nconst RESOURCE_TYPE_SPECIAL_NAMES: {\n  [type: string]: { resourceType: string };\n} = {\n  'AWS::Events::EventBus': {\n    resourceType: 'event-bus',\n  },\n};\n\nconst RESOURCE_TYPE_ATTRIBUTES_FORMATS: {\n  [type: string]: { [attribute: string]: (parts: ArnParts) => string };\n} = {\n  'AWS::IAM::Role': { Arn: iamArnFmt },\n  'AWS::IAM::User': { Arn: iamArnFmt },\n  'AWS::IAM::Group': { Arn: iamArnFmt },\n  'AWS::S3::Bucket': { Arn: s3ArnFmt },\n  'AWS::Lambda::Function': { Arn: stdColonResourceArnFmt },\n  'AWS::Events::EventBus': {\n    Arn: stdSlashResourceArnFmt,\n    // the name attribute of the EventBus is the same as the Ref\n    Name: (parts) => parts.resourceName,\n  },\n  'AWS::DynamoDB::Table': { Arn: stdSlashResourceArnFmt },\n  'AWS::AppSync::GraphQLApi': { ApiId: appsyncGraphQlApiApiIdFmt },\n  'AWS::AppSync::FunctionConfiguration': {\n    FunctionId: appsyncGraphQlFunctionIDFmt,\n  },\n  'AWS::AppSync::DataSource': { Name: appsyncGraphQlDataSourceNameFmt },\n  'AWS::KMS::Key': { Arn: stdSlashResourceArnFmt },\n};\n\nfunction iamArnFmt(parts: ArnParts): string {\n  // we skip region for IAM resources\n  return `arn:${parts.partition}:${parts.service}::${parts.account}:${parts.resourceType}/${parts.resourceName}`;\n}\n\nfunction s3ArnFmt(parts: ArnParts): string {\n  // we skip account, region and resourceType for S3 resources\n  return `arn:${parts.partition}:${parts.service}:::${parts.resourceName}`;\n}\n\nfunction stdColonResourceArnFmt(parts: ArnParts): string {\n  // this is a standard format for ARNs like: arn:aws:service:region:account:resourceType:resourceName\n  return `arn:${parts.partition}:${parts.service}:${parts.region}:${parts.account}:${parts.resourceType}:${parts.resourceName}`;\n}\n\nfunction stdSlashResourceArnFmt(parts: ArnParts): string {\n  // this is a standard format for ARNs like: arn:aws:service:region:account:resourceType/resourceName\n  return `arn:${parts.partition}:${parts.service}:${parts.region}:${parts.account}:${parts.resourceType}/${parts.resourceName}`;\n}\n\nfunction appsyncGraphQlApiApiIdFmt(parts: ArnParts): string {\n  // arn:aws:appsync:us-east-1:111111111111:apis/<apiId>\n  return parts.resourceName.split('/')[1];\n}\n\nfunction appsyncGraphQlFunctionIDFmt(parts: ArnParts): string {\n  // arn:aws:appsync:us-east-1:111111111111:apis/<apiId>/functions/<functionId>\n  return parts.resourceName.split('/')[3];\n}\n\nfunction appsyncGraphQlDataSourceNameFmt(parts: ArnParts): string {\n  // arn:aws:appsync:us-east-1:111111111111:apis/<apiId>/datasources/<name>\n  return parts.resourceName.split('/')[3];\n}\n\ninterface Intrinsic {\n  readonly name: string;\n  readonly args: any;\n}\n\nasync function asyncGlobalReplace(str: string, regex: RegExp, cb: (x: string) => Promise<string>): Promise<string> {\n  if (!regex.global) {\n    throw new ToolkitError('Regex must be created with /g flag');\n  }\n\n  const ret = new Array<string>();\n  let start = 0;\n  while (true) {\n    const match = regex.exec(str);\n    if (!match) {\n      break;\n    }\n\n    ret.push(str.substring(start, match.index));\n    ret.push(await cb(match[1]));\n\n    start = regex.lastIndex;\n  }\n  ret.push(str.slice(start));\n\n  return ret.join('');\n}\n"]} \ No newline at end of file diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloudformation/index.d.ts b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloudformation/index.d.ts new file mode 100644 index 000000000..5a88aed86 --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloudformation/index.d.ts @@ -0,0 +1,4 @@ +export * from './evaluate-cloudformation-template'; +export * from './template-body-parameter'; +export * from './nested-stack-helpers'; +export * from './stack-helpers'; diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloudformation/index.js b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloudformation/index.js new file mode 100644 index 000000000..aeec18e19 --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloudformation/index.js @@ -0,0 +1,21 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __exportStar = (this && this.__exportStar) || function(m, exports) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +__exportStar(require("./evaluate-cloudformation-template"), exports); +__exportStar(require("./template-body-parameter"), exports); +__exportStar(require("./nested-stack-helpers"), exports); +__exportStar(require("./stack-helpers"), exports); +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXBpL2Nsb3VkZm9ybWF0aW9uL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSxxRUFBbUQ7QUFDbkQsNERBQTBDO0FBQzFDLHlEQUF1QztBQUN2QyxrREFBZ0MiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2V2YWx1YXRlLWNsb3VkZm9ybWF0aW9uLXRlbXBsYXRlJztcbmV4cG9ydCAqIGZyb20gJy4vdGVtcGxhdGUtYm9keS1wYXJhbWV0ZXInO1xuZXhwb3J0ICogZnJvbSAnLi9uZXN0ZWQtc3RhY2staGVscGVycyc7XG5leHBvcnQgKiBmcm9tICcuL3N0YWNrLWhlbHBlcnMnO1xuIl19 \ No newline at end of file diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloudformation/nested-stack-helpers.d.ts b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloudformation/nested-stack-helpers.d.ts new file mode 100644 index 000000000..495da00dc --- /dev/null +++ b/packages/@aws-cdk/tmp-toolkit-helpers/lib/api/cloudformation/nested-stack-helpers.d.ts @@ -0,0 +1,25 @@ +import type { CloudFormationStackArtifact } from '@aws-cdk/cx-api'; +import type { SDK } from '../aws-auth'; +import { type Template } from './stack-helpers'; +export interface RootTemplateWithNestedStacks { + readonly deployedRootTemplate: Template; + readonly nestedStacks: { + [nestedStackLogicalId: string]: NestedStackTemplates; + }; +} +/** + * Reads the currently deployed template and all of its nested stack templates from CloudFormation. + */ +export declare function loadCurrentTemplateWithNestedStacks(rootStackArtifact: CloudFormationStackArtifact, sdk: SDK, retrieveProcessedTemplate?: boolean): Promise; +/** + * Returns the currently deployed template from CloudFormation that corresponds to `stackArtifact`. + */ +export declare function loadCurrentTemplate(stackArtifact: CloudFormationStackArtifact, sdk: SDK, retrieveProcessedTemplate?: boolean): Promise