From beb77513e18b0a2c39b785ccf4d30342c77c3a1f Mon Sep 17 00:00:00 2001 From: AWS CDK Team Date: Tue, 22 Sep 2020 03:05:25 +0000 Subject: [PATCH 01/29] chore(release): 1.64.0 --- CHANGELOG.md | 70 ++++++++++++++++++++++++++++++++++++++++++++++++++++ lerna.json | 2 +- 2 files changed, 71 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index ca071fd1212bf..69a3baea0bb4c 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,76 @@ All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines. +## [1.64.0](https://github.com/aws/aws-cdk/compare/v1.63.0...v1.64.0) (2020-09-22) + + +### ⚠ BREAKING CHANGES TO EXPERIMENTAL FEATURES + +* **codedeploy:** the default policy for `LambdaDeploymentGroup` no longer contains `sns:Publish` on `*` permissions +* **cfn-include:** the construction property 'nestedStacks' of class 'CfnInclude' has been renamed to 'loadNestedStacks' +* **rds:** removed protected member `subnetGroup` from DatabaseCluster classes +* **rds:** Cluster now has deletionProtection enabled if its removal policy is `RETAIN` +* **rds**: Instance now has deletionProtection enabled by default only if its removal policy is `RETAIN` +* **cfnspec:** Fixed ECS task definition within the L1 layer. Fixed the casing of the `efsVolumeConfiguration` property to match the spec published by cloudformation. Fixed the type of the `DockerVolumeConfiguration.labels` property to allow users to properly apply labels. + +* **ecs**: Task definitions configured with an `efsVolumeConfiguration` will incur a resource replacement due to wrong casing of the underlying resources introduced in this [PR](https://github.com/aws/aws-cdk/pull/8467/files). This replacement will in turn cause a rolling update to any running tasks that use that definition. +* **ecs**: `DockerVolumeConfiguration.labels` changed from an **array** to a **map**. This was a long standing latent bug and in fact configuring labels in the old format would have resulted in the wrong behavior. +* **eks:** Clusters previously running k8s version other than `1.15` and bottlerocket AMI(`aws-k8s-1.15` variant) will trigger AMI and node replacement. + +### Features + +* **cfn-include:** add 'loadNestedStack()' method ([#10292](https://github.com/aws/aws-cdk/issues/10292)) ([9d6817f](https://github.com/aws/aws-cdk/commit/9d6817f4bc3cc052f351bf464403165972ef0afb)) +* **cfn-include:** the package cloudformation-include is now 'Developer Preview' ([#10436](https://github.com/aws/aws-cdk/issues/10436)) ([d45a57c](https://github.com/aws/aws-cdk/commit/d45a57c22a006f682e584c5ef6c8ef3f416caf86)) +* **cfnspec:** cloudformation spec v18.3.0 ([#10385](https://github.com/aws/aws-cdk/issues/10385)) ([dbdc7ff](https://github.com/aws/aws-cdk/commit/dbdc7ff20812157be518229ee9be90a5bbcb8d65)) +* **cli:** skip bundling for operations where stack is not needed ([#9889](https://github.com/aws/aws-cdk/issues/9889)) ([28cee39](https://github.com/aws/aws-cdk/commit/28cee393be75c6785d8b5471a6ecc656fa29648c)), closes [#9540](https://github.com/aws/aws-cdk/issues/9540) +* **codedeploy:** change LambdaDeploymentGroup default managed policy to AWSCodeDeployRoleForLambdaLimited ([#10276](https://github.com/aws/aws-cdk/issues/10276)) ([13e7bde](https://github.com/aws/aws-cdk/commit/13e7bde5f8f53f49ccc57def38aba2ec00b85409)) +* **cognito:** user pool client logout urls ([#10301](https://github.com/aws/aws-cdk/issues/10301)) ([5111837](https://github.com/aws/aws-cdk/commit/511183771b844e22881e9a2b3640a4645437f34c)) +* **custom-resource:** allow referencing resource id in updates/deletes ([#10327](https://github.com/aws/aws-cdk/issues/10327)) ([a726dad](https://github.com/aws/aws-cdk/commit/a726dad3fb220e10bc12928fded3702b740e28a7)), closes [#10305](https://github.com/aws/aws-cdk/issues/10305) +* **ec2:** generic ssm backed machine image ([#10369](https://github.com/aws/aws-cdk/issues/10369)) ([1dbad6e](https://github.com/aws/aws-cdk/commit/1dbad6e1c9aa3821988735b320b397b1106cca46)) +* **ec2:** user-defined subnet selectors ([#10112](https://github.com/aws/aws-cdk/issues/10112)) ([491113d](https://github.com/aws/aws-cdk/commit/491113d7367ad087fa10d2c00bf220e7973ce320)) +* **eks:** bottlerocket versoin follows the cluster k8s versoin ([#10189](https://github.com/aws/aws-cdk/issues/10189)) ([19638a6](https://github.com/aws/aws-cdk/commit/19638a6dfeb33554a5c25a75914adbf2019688f3)), closes [#10188](https://github.com/aws/aws-cdk/issues/10188) +* **events-targets:** supports to specify fargate platform version ([#10223](https://github.com/aws/aws-cdk/issues/10223)) ([3dcd01e](https://github.com/aws/aws-cdk/commit/3dcd01eb1f6fa8504db444db59dacb03dd5d4578)), closes [#10186](https://github.com/aws/aws-cdk/issues/10186) +* **lambda-nodejs:** custom bundling image ([#10270](https://github.com/aws/aws-cdk/issues/10270)) ([a2174a4](https://github.com/aws/aws-cdk/commit/a2174a460a8e7b51e8bdd75304b2eb38ae1adc78)), closes [#10194](https://github.com/aws/aws-cdk/issues/10194) +* **pipelines:** support VPC property in ShellScriptAction ([#10240](https://github.com/aws/aws-cdk/issues/10240)) ([08a3c55](https://github.com/aws/aws-cdk/commit/08a3c55f973436393103fce26467800183d51e69)), closes [#9982](https://github.com/aws/aws-cdk/issues/9982) +* **rds:** add SQL Server version 15.00.4043.16.v1 ([#10289](https://github.com/aws/aws-cdk/issues/10289)) ([a578ef8](https://github.com/aws/aws-cdk/commit/a578ef88b1554947504e02d74b1cfd90709c2f44)), closes [#10273](https://github.com/aws/aws-cdk/issues/10273) +* **rds:** S3 import and export for DatabaseInstances ([#10370](https://github.com/aws/aws-cdk/issues/10370)) ([80a2ac9](https://github.com/aws/aws-cdk/commit/80a2ac94359f18b59f6f61bd068fd01e221be8b6)), closes [#4419](https://github.com/aws/aws-cdk/issues/4419) +* **rds:** support existing cluster subnet groups ([#10391](https://github.com/aws/aws-cdk/issues/10391)) ([a1df511](https://github.com/aws/aws-cdk/commit/a1df51187d77512d7618e205d21427557bd212b7)), closes [#9991](https://github.com/aws/aws-cdk/issues/9991) +* **redshift:** support existing cluster subnet groups ([#10340](https://github.com/aws/aws-cdk/issues/10340)) ([5ad8cdb](https://github.com/aws/aws-cdk/commit/5ad8cdb662a2b3a27a3590370d055eeb53b3645b)), closes [#9241](https://github.com/aws/aws-cdk/issues/9241) +* **secretsmanager:** import secrets by name ([#10309](https://github.com/aws/aws-cdk/issues/10309)) ([a8e8ed3](https://github.com/aws/aws-cdk/commit/a8e8ed37379c5bbaeeb13a773d5438ea5e5b2fec)), closes [#7444](https://github.com/aws/aws-cdk/issues/7444) [#7949](https://github.com/aws/aws-cdk/issues/7949) [#7994](https://github.com/aws/aws-cdk/issues/7994) +* add support for the 'Version' resource attribute ([#10376](https://github.com/aws/aws-cdk/issues/10376)) ([aac235a](https://github.com/aws/aws-cdk/commit/aac235aab349a103f92934b86dce9f0eee424c06)) +* **stepfunctions:** added new condition operators ([#9920](https://github.com/aws/aws-cdk/issues/9920)) ([b8490f2](https://github.com/aws/aws-cdk/commit/b8490f25a8eb6104163cf03c4e4ea9a61163877d)) +* **stepfunctions:** support X-Ray tracing ([#10371](https://github.com/aws/aws-cdk/issues/10371)) ([#10374](https://github.com/aws/aws-cdk/issues/10374)) ([ad011c0](https://github.com/aws/aws-cdk/commit/ad011c0afb487dcd27df968d7b48ea6d21ff04cb)) +* **stepfunctions-tasks:** handle Lambda service exceptions ([#10386](https://github.com/aws/aws-cdk/issues/10386)) ([edf75b6](https://github.com/aws/aws-cdk/commit/edf75b6707086d61b5379f832f6597427a08a84e)) + + +### Bug Fixes + +* **bootstrap:** no longer creates KMS master key by default ([#10365](https://github.com/aws/aws-cdk/issues/10365)) ([bedd4c0](https://github.com/aws/aws-cdk/commit/bedd4c00177f67809dd186488b254956039bd799)), closes [#10115](https://github.com/aws/aws-cdk/issues/10115) +* **bootstrapping:** `--cloudformation-execution-policies` not checked ([#10337](https://github.com/aws/aws-cdk/issues/10337)) ([ad9a705](https://github.com/aws/aws-cdk/commit/ad9a70543703e8d8ebaac82001ee9a62f784bea7)) +* **cfn-include:** allow referring to Conditions in Outputs and Rules ([#10373](https://github.com/aws/aws-cdk/issues/10373)) ([4751f42](https://github.com/aws/aws-cdk/commit/4751f4281287ab8fdfba5790b88148bbb1a8a0de)) +* **cfn-include:** correctly handle the 'AWS::CloudFormation::CustomResource' resource type ([#10415](https://github.com/aws/aws-cdk/issues/10415)) ([1a5a024](https://github.com/aws/aws-cdk/commit/1a5a024b601e28d158b6401b5d97ed408a73eb5d)) +* **cli:** `--profile` is ignored if AWS_ variables are set ([#10362](https://github.com/aws/aws-cdk/issues/10362)) ([957a12e](https://github.com/aws/aws-cdk/commit/957a12eeb464443687e3dfd5f224f2769814a41b)) +* **cli:** `cdk synth` fails if AWS_ credentials have expired ([#10343](https://github.com/aws/aws-cdk/issues/10343)) ([406f665](https://github.com/aws/aws-cdk/commit/406f6650a4d9ba0f2b6158aea27707710bb213f3)), closes [#7849](https://github.com/aws/aws-cdk/issues/7849) +* **cli:** stack outputs aren't sorted ([#10328](https://github.com/aws/aws-cdk/issues/10328)) ([9f430fc](https://github.com/aws/aws-cdk/commit/9f430fc86239e299b39aaaeea7982ff4a57fdcfd)) +* **cloudwatch:** LTE operator renders wrong symbol ([#10418](https://github.com/aws/aws-cdk/issues/10418)) ([2543584](https://github.com/aws/aws-cdk/commit/254358449ec3040c750a416c0b4923884a3d2612)), closes [#8913](https://github.com/aws/aws-cdk/issues/8913) +* **codebuild:** Project.addFileSystemLocation does not work without providing locations at construction ([#10460](https://github.com/aws/aws-cdk/issues/10460)) ([994d3c3](https://github.com/aws/aws-cdk/commit/994d3c3d6aca6b6aee84412333a073ebb6671f7f)), closes [#10442](https://github.com/aws/aws-cdk/issues/10442) +* **core:** CfnParameter of Number type cannot be used as a string ([#10422](https://github.com/aws/aws-cdk/issues/10422)) ([28adc88](https://github.com/aws/aws-cdk/commit/28adc8826a7498288e0cf4ee96f43471d24062cb)), closes [#10228](https://github.com/aws/aws-cdk/issues/10228) +* **diff:** `deepEqual` may miss difference other than `DependsOn` ([#10394](https://github.com/aws/aws-cdk/issues/10394)) ([9bcaf75](https://github.com/aws/aws-cdk/commit/9bcaf7564f72deea6942c3cd2e2fb98c14f3d152)), closes [#10322](https://github.com/aws/aws-cdk/issues/10322) +* **diff:** allow strings to be passed for boolean properties ([#10378](https://github.com/aws/aws-cdk/issues/10378)) ([673dd82](https://github.com/aws/aws-cdk/commit/673dd82268aa199099a7a589c956fead2a800d02)) +* **diff:** handle YAML short-forms like '!GetAtt' in diff ([#10381](https://github.com/aws/aws-cdk/issues/10381)) ([457e109](https://github.com/aws/aws-cdk/commit/457e109c649d97916ba1e21d08180a267e4c0711)), closes [#6537](https://github.com/aws/aws-cdk/issues/6537) +* **dynamodb:** cannot change serverSideEncryption from true to false ([#8450](https://github.com/aws/aws-cdk/issues/8450)) ([7a266b5](https://github.com/aws/aws-cdk/commit/7a266b53a3b07f70062639a4b68b1b89ecae726e)), closes [#8286](https://github.com/aws/aws-cdk/issues/8286) +* **ec2:** `InitFile` does not work on Windows ([#10450](https://github.com/aws/aws-cdk/issues/10450)) ([84b9d5e](https://github.com/aws/aws-cdk/commit/84b9d5ea8abd14dc2de228de3a0cb65dca0028ab)), closes [#10390](https://github.com/aws/aws-cdk/issues/10390) +* **eks:** cannot import a cluster with cdk managed `kubectlPrivateSubnets` ([#10459](https://github.com/aws/aws-cdk/issues/10459)) ([10d0a36](https://github.com/aws/aws-cdk/commit/10d0a368c0fe34513ba9c359c0fdaa24a569dc5a)) +* **eks:** circular dependencies when security groups from other stacks are used ([#10339](https://github.com/aws/aws-cdk/issues/10339)) ([857acbb](https://github.com/aws/aws-cdk/commit/857acbbb7f26feecca938dc881add57fe5cae7e4)) +* **lambda:** unable to add permissions to imported lambda functions ([#8828](https://github.com/aws/aws-cdk/issues/8828)) ([9bf8e13](https://github.com/aws/aws-cdk/commit/9bf8e13bd47608070b73221c11c55b09d03c0a4c)), closes [#7588](https://github.com/aws/aws-cdk/issues/7588) +* **lambda-nodejs:** local parcel not detected ([#10268](https://github.com/aws/aws-cdk/issues/10268)) ([457fab8](https://github.com/aws/aws-cdk/commit/457fab8768b89933beb8d659ac7ecab7fd8dfac4)) +* **pipelines:** make CdkPipeline build stage optional ([#10345](https://github.com/aws/aws-cdk/issues/10345)) ([e9ffa67](https://github.com/aws/aws-cdk/commit/e9ffa67c6bcfdfc96067bd70feda3450f3249867)), closes [#10148](https://github.com/aws/aws-cdk/issues/10148) +* **rds:** cannot use s3ImportBuckets or s3ExportBuckets with aurora postgres ([#10132](https://github.com/aws/aws-cdk/issues/10132)) ([cb6fef8](https://github.com/aws/aws-cdk/commit/cb6fef8ee4746ffea66df73e6ef64f613af5f983)), closes [#4419](https://github.com/aws/aws-cdk/issues/4419) [#8201](https://github.com/aws/aws-cdk/issues/8201) +* SSM Association 'parameters' property has incorrect type ([#10316](https://github.com/aws/aws-cdk/issues/10316)) ([7b5c9d2](https://github.com/aws/aws-cdk/commit/7b5c9d260a9f0600a35dd5f37454bea74e5f786f)), closes [#3092](https://github.com/aws/aws-cdk/issues/3092) +* **rds:** standardize removal policies and deletion protection ([#10412](https://github.com/aws/aws-cdk/issues/10412)) ([75811c1](https://github.com/aws/aws-cdk/commit/75811c1325c3d857cf9891048474201b2f28477a)) +* **redshift:** cluster defaultChild broken after adding subnet group ([#10389](https://github.com/aws/aws-cdk/issues/10389)) ([746dfe2](https://github.com/aws/aws-cdk/commit/746dfe2b8d0fced5d2a9e4b760f477b0abcb6df9)), closes [#10340](https://github.com/aws/aws-cdk/issues/10340) +* **s3-notifications:** lambda destination creates a circular dependency when bucket and lambda are in different stacks ([#10426](https://github.com/aws/aws-cdk/issues/10426)) ([7222b5d](https://github.com/aws/aws-cdk/commit/7222b5d62c70719f9a7b3af5a80840d750b109b1)) + ## [1.63.0](https://github.com/aws/aws-cdk/compare/v1.62.0...v1.63.0) (2020-09-12) diff --git a/lerna.json b/lerna.json index 41116c625ce66..7b4680783877f 100644 --- a/lerna.json +++ b/lerna.json @@ -10,5 +10,5 @@ "tools/*" ], "rejectCycles": "true", - "version": "1.63.0" + "version": "1.64.0" } From 635f0eda89ae0ae61fc2a562f7c097e61d647f29 Mon Sep 17 00:00:00 2001 From: Rico Huijbers Date: Tue, 22 Sep 2020 13:48:20 +0200 Subject: [PATCH 02/29] fix(cli): OS usernames cannot have Unicode characters (#10451) When assuming a role for uploading assets in the new-style synthesized stacks, the OS username was used to build the session name out of. OS usernames have a character set that is wider than the allowed characters in `RoleSessionName` though, so we needed to sanitize them. Fixes #10401. ---- *By submitting this pull request, I confirm that my contribution is made under the terms of the Apache-2.0 license* --- .../aws-cdk/lib/api/aws-auth/sdk-provider.ts | 11 +++++- packages/aws-cdk/lib/api/aws-auth/sdk.ts | 10 +++++ .../aws-cdk/test/api/sdk-provider.test.ts | 39 +++++++++++++++++++ packages/cdk-assets/bin/publish.ts | 11 +++++- 4 files changed, 69 insertions(+), 2 deletions(-) diff --git a/packages/aws-cdk/lib/api/aws-auth/sdk-provider.ts b/packages/aws-cdk/lib/api/aws-auth/sdk-provider.ts index 6b7522e4e09f2..d88d69406ca65 100644 --- a/packages/aws-cdk/lib/api/aws-auth/sdk-provider.ts +++ b/packages/aws-cdk/lib/api/aws-auth/sdk-provider.ts @@ -148,7 +148,7 @@ export class SdkProvider { params: { RoleArn: roleArn, ...externalId ? { ExternalId: externalId } : {}, - RoleSessionName: `aws-cdk-${os.userInfo().username}`, + RoleSessionName: `aws-cdk-${safeUsername()}`, }, stsConfig: { region, @@ -362,4 +362,13 @@ function readIfPossible(filename: string): string | undefined { debug(e); return undefined; } +} + +/** + * 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() { + return os.userInfo().username.replace(/[^\w+=,.@-]/g, '@'); } \ No newline at end of file diff --git a/packages/aws-cdk/lib/api/aws-auth/sdk.ts b/packages/aws-cdk/lib/api/aws-auth/sdk.ts index d735231836e27..28e24f19e988c 100644 --- a/packages/aws-cdk/lib/api/aws-auth/sdk.ts +++ b/packages/aws-cdk/lib/api/aws-auth/sdk.ts @@ -106,6 +106,16 @@ export class SDK implements ISDK { return { accountId, partition }; })); } + + /** + * Return the current credentials + * + * Don't use -- only used to write tests around assuming roles. + */ + public async currentCredentials(): Promise { + await this.credentials.getPromise(); + return this.credentials; + } } /** diff --git a/packages/aws-cdk/test/api/sdk-provider.test.ts b/packages/aws-cdk/test/api/sdk-provider.test.ts index 83eb525d54771..70319a113f829 100644 --- a/packages/aws-cdk/test/api/sdk-provider.test.ts +++ b/packages/aws-cdk/test/api/sdk-provider.test.ts @@ -1,3 +1,4 @@ +import * as os from 'os'; import * as cxapi from '@aws-cdk/cx-api'; import * as AWS from 'aws-sdk'; import * as SDKMock from 'aws-sdk-mock'; @@ -271,6 +272,44 @@ describe('with default config files', () => { await expect(sdk.s3().listBuckets().promise()).rejects.toThrow('did you bootstrap'); await expect(sdk.s3().listBuckets().promise()).rejects.toThrow('Nope!'); }); + + test('assuming a role sanitizes the username into the session name', async () => { + // GIVEN + SDKMock.restore(); + + await withMocked(os, 'userInfo', async (userInfo) => { + userInfo.mockReturnValue({ username: 'skål', uid: 1, gid: 1, homedir: '/here', shell: '/bin/sh' }); + + await withMocked((new AWS.STS()).constructor.prototype, 'assumeRole', async (assumeRole) => { + let assumeRoleRequest; + + assumeRole.mockImplementation(function ( + this: any, + request: AWS.STS.Types.AssumeRoleRequest, + cb?: (err: Error | null, x: AWS.STS.Types.AssumeRoleResponse) => void) { + + // Part of the request is stored on "this" + assumeRoleRequest = { ...this.config.params, ...request }; + + const response = { + Credentials: { AccessKeyId: `${uid}aid`, Expiration: new Date(), SecretAccessKey: 's', SessionToken: '' }, + }; + if (cb) { cb(null, response); } + return { promise: () => Promise.resolve(response) }; + }); + + // WHEN + const provider = new SdkProvider(new AWS.CredentialProviderChain([() => new AWS.Credentials({ accessKeyId: 'a', secretAccessKey: 's' })]), 'eu-somewhere'); + const sdk = await provider.withAssumedRole('bla.role.arn', undefined, undefined); + + await sdk.currentCredentials(); + + expect(assumeRoleRequest).toEqual(expect.objectContaining({ + RoleSessionName: 'aws-cdk-sk@l', + })); + }); + }); + }); }); describe('Plugins', () => { diff --git a/packages/cdk-assets/bin/publish.ts b/packages/cdk-assets/bin/publish.ts index 12a0e318d0f78..20b7a609bfdd0 100644 --- a/packages/cdk-assets/bin/publish.ts +++ b/packages/cdk-assets/bin/publish.ts @@ -140,7 +140,7 @@ class DefaultAwsClient implements IAws { params: { RoleArn: roleArn, ExternalId: externalId, - RoleSessionName: `cdk-assets-${os.userInfo().username}`, + RoleSessionName: `cdk-assets-${safeUsername()}`, }, stsConfig: { region, @@ -149,3 +149,12 @@ class DefaultAwsClient implements IAws { }); } } + +/** + * 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() { + return os.userInfo().username.replace(/[^\w+=,.@-]/g, '@'); +} \ No newline at end of file From 272363aed1a0056a490f105bc99677f7fdd8f2ca Mon Sep 17 00:00:00 2001 From: Jonathan Goldwasser Date: Tue, 22 Sep 2020 15:49:09 +0200 Subject: [PATCH 03/29] chore(core): AssetHashType.OUTPUT and improved JSDoc (#10473) Deprecate `AssetHashType.BUNDLE` in favor of `AssetHashType.OUTPUT`. Improve JSDoc for `AssetHashType`. Closes #9861 ---- *By submitting this pull request, I confirm that my contribution is made under the terms of the Apache-2.0 license* --- .../aws-lambda-nodejs/lib/bundling.ts | 2 +- .../aws-lambda-nodejs/test/bundling.test.ts | 12 +++--- packages/@aws-cdk/core/lib/asset-staging.ts | 5 ++- packages/@aws-cdk/core/lib/assets.ts | 17 ++++++++ packages/@aws-cdk/core/test/test.staging.ts | 40 ++++++++++++++++++- 5 files changed, 66 insertions(+), 10 deletions(-) diff --git a/packages/@aws-cdk/aws-lambda-nodejs/lib/bundling.ts b/packages/@aws-cdk/aws-lambda-nodejs/lib/bundling.ts index f68123c4d36be..5160904878e11 100644 --- a/packages/@aws-cdk/aws-lambda-nodejs/lib/bundling.ts +++ b/packages/@aws-cdk/aws-lambda-nodejs/lib/bundling.ts @@ -212,7 +212,7 @@ export class Bundling { }); return lambda.Code.fromAsset(projectRoot, { - assetHashType: cdk.AssetHashType.BUNDLE, + assetHashType: cdk.AssetHashType.OUTPUT, bundling: { local: localBundler, ...dockerBundler.bundlingOptions, diff --git a/packages/@aws-cdk/aws-lambda-nodejs/test/bundling.test.ts b/packages/@aws-cdk/aws-lambda-nodejs/test/bundling.test.ts index 40fdb21ac60a8..654e3b49f9029 100644 --- a/packages/@aws-cdk/aws-lambda-nodejs/test/bundling.test.ts +++ b/packages/@aws-cdk/aws-lambda-nodejs/test/bundling.test.ts @@ -40,7 +40,7 @@ test('Parcel bundling', () => { // Correctly bundles with parcel expect(Code.fromAsset).toHaveBeenCalledWith('/project', { - assetHashType: AssetHashType.BUNDLE, + assetHashType: AssetHashType.OUTPUT, bundling: expect.objectContaining({ local: { props: expect.objectContaining({ @@ -93,7 +93,7 @@ test('Parcel bundling with handler named index.ts', () => { // Correctly bundles with parcel expect(Code.fromAsset).toHaveBeenCalledWith('/project', { - assetHashType: AssetHashType.BUNDLE, + assetHashType: AssetHashType.OUTPUT, bundling: expect.objectContaining({ command: [ 'bash', '-c', @@ -112,7 +112,7 @@ test('Parcel bundling with tsx handler', () => { // Correctly bundles with parcel expect(Code.fromAsset).toHaveBeenCalledWith('/project', { - assetHashType: AssetHashType.BUNDLE, + assetHashType: AssetHashType.OUTPUT, bundling: expect.objectContaining({ command: [ 'bash', '-c', @@ -152,7 +152,7 @@ test('Parcel bundling with externals and dependencies', () => { // Correctly bundles with parcel expect(Code.fromAsset).toHaveBeenCalledWith('/project', { - assetHashType: AssetHashType.BUNDLE, + assetHashType: AssetHashType.OUTPUT, bundling: expect.objectContaining({ command: [ 'bash', '-c', @@ -199,7 +199,7 @@ test('Detects yarn.lock', () => { // Correctly bundles with parcel expect(Code.fromAsset).toHaveBeenCalledWith('/project', { - assetHashType: AssetHashType.BUNDLE, + assetHashType: AssetHashType.OUTPUT, bundling: expect.objectContaining({ command: expect.arrayContaining([ expect.stringMatching(/yarn\.lock.+yarn install/), @@ -316,7 +316,7 @@ test('Custom bundling docker image', () => { }); expect(Code.fromAsset).toHaveBeenCalledWith('/project', { - assetHashType: AssetHashType.BUNDLE, + assetHashType: AssetHashType.OUTPUT, bundling: expect.objectContaining({ image: { image: 'my-custom-image' }, }), diff --git a/packages/@aws-cdk/core/lib/asset-staging.ts b/packages/@aws-cdk/core/lib/asset-staging.ts index dc49750a46f2f..e5878c2a31365 100644 --- a/packages/@aws-cdk/core/lib/asset-staging.ts +++ b/packages/@aws-cdk/core/lib/asset-staging.ts @@ -113,7 +113,7 @@ export class AssetStaging extends Construct { this.relativePath = renderAssetFilename(this.assetHash); this.stagedPath = this.relativePath; } else { // Bundling is skipped - this.assetHash = props.assetHashType === AssetHashType.BUNDLE + this.assetHash = props.assetHashType === AssetHashType.BUNDLE || props.assetHashType === AssetHashType.OUTPUT ? this.calculateHash(AssetHashType.CUSTOM, this.node.path) // Use node path as dummy hash because we're not bundling : this.calculateHash(hashType, props.assetHash); this.stagedPath = this.sourcePath; @@ -295,8 +295,9 @@ export class AssetStaging extends Construct { case AssetHashType.SOURCE: return FileSystem.fingerprint(this.sourcePath, this.fingerprintOptions); case AssetHashType.BUNDLE: + case AssetHashType.OUTPUT: if (!this.bundleDir) { - throw new Error('Cannot use `AssetHashType.BUNDLE` when `bundling` is not specified.'); + throw new Error(`Cannot use \`${hashType}\` hash type when \`bundling\` is not specified.`); } return FileSystem.fingerprint(this.bundleDir, this.fingerprintOptions); default: diff --git a/packages/@aws-cdk/core/lib/assets.ts b/packages/@aws-cdk/core/lib/assets.ts index 012b7da4d489c..17d3b9d93e53f 100644 --- a/packages/@aws-cdk/core/lib/assets.ts +++ b/packages/@aws-cdk/core/lib/assets.ts @@ -60,18 +60,35 @@ export interface AssetOptions { /** * The type of asset hash + * + * NOTE: the hash is used in order to identify a specific revision of the asset, and + * used for optimizing and caching deployment activities related to this asset such as + * packaging, uploading to Amazon S3, etc. */ export enum AssetHashType { /** * Based on the content of the source path + * + * When bundling, use `SOURCE` when the content of the bundling output is not + * stable across repeated bundling operations. */ SOURCE = 'source', /** * Based on the content of the bundled path + * + * @deprecated use `OUTPUT` instead */ BUNDLE = 'bundle', + /** + * Based on the content of the bundling output + * + * Use `OUTPUT` when the source of the asset is a top level folder containing + * code and/or dependencies that are not directly linked to the asset. + */ + OUTPUT = 'output', + /** * Use a custom hash */ diff --git a/packages/@aws-cdk/core/test/test.staging.ts b/packages/@aws-cdk/core/test/test.staging.ts index ff7279172bb00..e652c884935f4 100644 --- a/packages/@aws-cdk/core/test/test.staging.ts +++ b/packages/@aws-cdk/core/test/test.staging.ts @@ -425,6 +425,28 @@ export = { test.done(); }, + 'bundling with OUTPUT asset hash type'(test: Test) { + // GIVEN + const app = new App(); + const stack = new Stack(app, 'stack'); + const directory = path.join(__dirname, 'fs', 'fixtures', 'test1'); + + // WHEN + const asset = new AssetStaging(stack, 'Asset', { + sourcePath: directory, + bundling: { + image: BundlingDockerImage.fromRegistry('alpine'), + command: [DockerStubCommand.SUCCESS], + }, + assetHashType: AssetHashType.OUTPUT, + }); + + // THEN + test.equal(asset.assetHash, '33cbf2cae5432438e0f046bc45ba8c3cef7b6afcf47b59d1c183775c1918fb1f'); + + test.done(); + }, + 'custom hash'(test: Test) { // GIVEN const app = new App(); @@ -474,7 +496,23 @@ export = { test.throws(() => new AssetStaging(stack, 'Asset', { sourcePath: directory, assetHashType: AssetHashType.BUNDLE, - }), /Cannot use `AssetHashType.BUNDLE` when `bundling` is not specified/); + }), /Cannot use `bundle` hash type when `bundling` is not specified/); + test.equal(fs.existsSync(STUB_INPUT_FILE), false); + + test.done(); + }, + + 'throws with OUTPUT hash type and no bundling'(test: Test) { + // GIVEN + const app = new App(); + const stack = new Stack(app, 'stack'); + const directory = path.join(__dirname, 'fs', 'fixtures', 'test1'); + + // THEN + test.throws(() => new AssetStaging(stack, 'Asset', { + sourcePath: directory, + assetHashType: AssetHashType.OUTPUT, + }), /Cannot use `output` hash type when `bundling` is not specified/); test.equal(fs.existsSync(STUB_INPUT_FILE), false); test.done(); From dac1e12196c84b84820052f74b14c86a7d4dddc3 Mon Sep 17 00:00:00 2001 From: Daniel <3842788+dscpinheiro@users.noreply.github.com> Date: Tue, 22 Sep 2020 14:14:52 +0000 Subject: [PATCH 04/29] feat(lambda): kafka topic as an event source (#10445) Lambda recently added support for MSK as an event source (https://aws.amazon.com/about-aws/whats-new/2020/08/aws-lambda-now-supports-amazon-managed-streaming-for-apache-kafka-as-an-event-source/), and there's now a "Topics" property on the CloudFormation resource definition (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-eventsourcemapping.html#cfn-lambda-eventsourcemapping-topics). Closes https://github.com/aws/aws-cdk/issues/10138 ---- *By submitting this pull request, I confirm that my contribution is made under the terms of the Apache-2.0 license* --- .../aws-lambda/lib/event-source-mapping.ts | 16 ++++++++--- .../test/test.event-source-mapping.ts | 28 +++++++++++++++++++ 2 files changed, 40 insertions(+), 4 deletions(-) diff --git a/packages/@aws-cdk/aws-lambda/lib/event-source-mapping.ts b/packages/@aws-cdk/aws-lambda/lib/event-source-mapping.ts index 760aca4f71e4d..a9fbc97bdea0e 100644 --- a/packages/@aws-cdk/aws-lambda/lib/event-source-mapping.ts +++ b/packages/@aws-cdk/aws-lambda/lib/event-source-mapping.ts @@ -17,7 +17,7 @@ export interface EventSourceMappingOptions { * * Valid Range: Minimum value of 1. Maximum value of 10000. * - * @default - Amazon Kinesis and Amazon DynamoDB is 100 records. + * @default - Amazon Kinesis, Amazon DynamoDB, and Amazon MSK is 100 records. * Both the default and maximum for Amazon SQS are 10 messages. */ readonly batchSize?: number; @@ -44,12 +44,12 @@ export interface EventSourceMappingOptions { readonly enabled?: boolean; /** - * The position in the DynamoDB or Kinesis stream where AWS Lambda should + * The position in the DynamoDB, Kinesis or MSK stream where AWS Lambda should * start reading. * * @see https://docs.aws.amazon.com/kinesis/latest/APIReference/API_GetShardIterator.html#Kinesis-GetShardIterator-request-ShardIteratorType * - * @default - Required for Amazon Kinesis and Amazon DynamoDB Streams sources. + * @default - Required for Amazon Kinesis, Amazon DynamoDB, and Amazon MSK Streams sources. */ readonly startingPosition?: StartingPosition; @@ -91,6 +91,13 @@ export interface EventSourceMappingOptions { * @default 1 */ readonly parallelizationFactor?: number; + + /** + * The name of the Kafka topic. + * + * @default - no topic + */ + readonly kafkaTopic?: string; } /** @@ -185,13 +192,14 @@ export class EventSourceMapping extends cdk.Resource implements IEventSourceMapp maximumRecordAgeInSeconds: props.maxRecordAge?.toSeconds(), maximumRetryAttempts: props.retryAttempts, parallelizationFactor: props.parallelizationFactor, + topics: props.kafkaTopic !== undefined ? [props.kafkaTopic] : undefined, }); this.eventSourceMappingId = cfnEventSourceMapping.ref; } } /** - * The position in the DynamoDB or Kinesis stream where AWS Lambda should start + * The position in the DynamoDB, Kinesis or MSK stream where AWS Lambda should start * reading. */ export enum StartingPosition { diff --git a/packages/@aws-cdk/aws-lambda/test/test.event-source-mapping.ts b/packages/@aws-cdk/aws-lambda/test/test.event-source-mapping.ts index 4de8108b609d2..bc9492f1d2f7e 100644 --- a/packages/@aws-cdk/aws-lambda/test/test.event-source-mapping.ts +++ b/packages/@aws-cdk/aws-lambda/test/test.event-source-mapping.ts @@ -1,3 +1,4 @@ +import { expect, haveResourceLike } from '@aws-cdk/assert'; import * as cdk from '@aws-cdk/core'; import { Test } from 'nodeunit'; import { Code, EventSourceMapping, Function, Runtime } from '../lib'; @@ -185,4 +186,31 @@ export = { test.equals(imported.stack.stackName, 'test-stack'); test.done(); }, + + 'accepts if kafkaTopic is a parameter'(test: Test) { + const stack = new cdk.Stack(); + const topicNameParam = new cdk.CfnParameter(stack, 'TopicNameParam', { + type: 'String', + }); + + const fn = new Function(stack, 'fn', { + handler: 'index.handler', + code: Code.fromInline('exports.handler = ${handler.toString()}'), + runtime: Runtime.NODEJS_10_X, + }); + + new EventSourceMapping(stack, 'test', { + target: fn, + eventSourceArn: '', + kafkaTopic: topicNameParam.valueAsString, + }); + + expect(stack).to(haveResourceLike('AWS::Lambda::EventSourceMapping', { + Topics: [{ + Ref: 'TopicNameParam', + }], + })); + + test.done(); + }, }; From bf3cc21c2d19cf344b706a4da2de939daded89a7 Mon Sep 17 00:00:00 2001 From: Ayush Goyal Date: Tue, 22 Sep 2020 21:02:55 +0530 Subject: [PATCH 05/29] feat: add configuration for GitHub CodeSpaces (#10470) Add `.devcontainer.json` referencing the existing `.gitpod.yml` for supporting GitHub codespaces closes #10447 ---- *By submitting this pull request, I confirm that my contribution is made under the terms of the Apache-2.0 license* --- .devcontainer.json | 8 ++++++++ 1 file changed, 8 insertions(+) create mode 100644 .devcontainer.json diff --git a/.devcontainer.json b/.devcontainer.json new file mode 100644 index 0000000000000..c40157671ce76 --- /dev/null +++ b/.devcontainer.json @@ -0,0 +1,8 @@ +{ + "name": "Dev Container Definition - AWS CDK", + "image": "jsii/superchain", + "postCreateCommand": "yarn build --skip-test --no-bail --skip-prereqs --skip-compat", + "extensions": [ + "dbaeumer.vscode-eslint@2.1.5" + ] +} \ No newline at end of file From 2e93863e03a668dd3afd1d1ce7612be1b96c5514 Mon Sep 17 00:00:00 2001 From: Pahud Hsieh Date: Wed, 23 Sep 2020 01:40:45 +0800 Subject: [PATCH 06/29] chore(rds): add additional aurora mysql engine versions (#10477) chore(rds): add additional aurora mysql engine versions Closes: #10476 ---- *By submitting this pull request, I confirm that my contribution is made under the terms of the Apache-2.0 license* --- packages/@aws-cdk/aws-rds/lib/cluster-engine.ts | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/packages/@aws-cdk/aws-rds/lib/cluster-engine.ts b/packages/@aws-cdk/aws-rds/lib/cluster-engine.ts index 76a542078958a..a25200ac22205 100644 --- a/packages/@aws-cdk/aws-rds/lib/cluster-engine.ts +++ b/packages/@aws-cdk/aws-rds/lib/cluster-engine.ts @@ -322,6 +322,10 @@ export class AuroraMysqlEngineVersion { public static readonly VER_2_08_0 = AuroraMysqlEngineVersion.builtIn_5_7('2.08.0'); /** Version "5.7.mysql_aurora.2.08.1". */ public static readonly VER_2_08_1 = AuroraMysqlEngineVersion.builtIn_5_7('2.08.1'); + /** Version "5.7.mysql_aurora.2.08.2". */ + public static readonly VER_2_08_2 = AuroraMysqlEngineVersion.builtIn_5_7('2.08.2'); + /** Version "5.7.mysql_aurora.2.09.0". */ + public static readonly VER_2_09_0 = AuroraMysqlEngineVersion.builtIn_5_7('2.09.0'); /** * Create a new AuroraMysqlEngineVersion with an arbitrary version. From 94bbabfff8b785656a40e85539f97ae8cb83c818 Mon Sep 17 00:00:00 2001 From: Alan Raison Date: Tue, 22 Sep 2020 20:28:43 +0100 Subject: [PATCH 07/29] fix(codepipeline-actions): use token as CodeCommitSourceAction branch (#10463) When using the EVENTS trigger, an event is created based on the branch name of the event, however this is not possible if the branch name is an unresolved value. Therefore generate a unique event name if this is the case. Fixes #10263 ---- *By submitting this pull request, I confirm that my contribution is made under the terms of the Apache-2.0 license* --- .../lib/codecommit/source-action.ts | 26 +++++++++-- .../test.codecommit-source-action.ts | 45 ++++++++++++++++++- 2 files changed, 67 insertions(+), 4 deletions(-) diff --git a/packages/@aws-cdk/aws-codepipeline-actions/lib/codecommit/source-action.ts b/packages/@aws-cdk/aws-codepipeline-actions/lib/codecommit/source-action.ts index 2fa7a67b29b93..8f33d16ac8c41 100644 --- a/packages/@aws-cdk/aws-codepipeline-actions/lib/codecommit/source-action.ts +++ b/packages/@aws-cdk/aws-codepipeline-actions/lib/codecommit/source-action.ts @@ -2,7 +2,7 @@ import * as codecommit from '@aws-cdk/aws-codecommit'; import * as codepipeline from '@aws-cdk/aws-codepipeline'; import * as targets from '@aws-cdk/aws-events-targets'; import * as iam from '@aws-cdk/aws-iam'; -import { Construct } from '@aws-cdk/core'; +import { Construct, Token } from '@aws-cdk/core'; import { Action } from '../action'; import { sourceArtifactBounds } from '../common'; @@ -122,8 +122,8 @@ export class CodeCommitSourceAction extends Action { const createEvent = this.props.trigger === undefined || this.props.trigger === CodeCommitTrigger.EVENTS; if (createEvent) { - const branchIdDisambiguator = this.branch === 'master' ? '' : `-${this.branch}-`; - this.props.repository.onCommit(`${stage.pipeline.node.uniqueId}${branchIdDisambiguator}EventRule`, { + const eventId = this.generateEventId(stage); + this.props.repository.onCommit(eventId, { target: new targets.CodePipeline(stage.pipeline), branches: [this.branch], }); @@ -153,4 +153,24 @@ export class CodeCommitSourceAction extends Action { }, }; } + + private generateEventId(stage: codepipeline.IStage): string { + const baseId = stage.pipeline.node.uniqueId; + if (Token.isUnresolved(this.branch)) { + let candidate = ''; + let counter = 0; + do { + candidate = this.eventIdFromPrefix(`${baseId}${counter}`); + counter += 1; + } while (this.props.repository.node.tryFindChild(candidate) !== undefined); + return candidate; + } else { + const branchIdDisambiguator = this.branch === 'master' ? '' : '-${this.branch}-'; + return this.eventIdFromPrefix(`${baseId}${branchIdDisambiguator}`); + } + } + + private eventIdFromPrefix(eventIdPrefix: string) { + return `${eventIdPrefix}EventRule`; + } } diff --git a/packages/@aws-cdk/aws-codepipeline-actions/test/codecommit/test.codecommit-source-action.ts b/packages/@aws-cdk/aws-codepipeline-actions/test/codecommit/test.codecommit-source-action.ts index e62e301168fa1..fda7c79dc1800 100644 --- a/packages/@aws-cdk/aws-codepipeline-actions/test/codecommit/test.codecommit-source-action.ts +++ b/packages/@aws-cdk/aws-codepipeline-actions/test/codecommit/test.codecommit-source-action.ts @@ -2,7 +2,7 @@ import { countResources, expect, haveResourceLike, not } from '@aws-cdk/assert'; import * as codebuild from '@aws-cdk/aws-codebuild'; import * as codecommit from '@aws-cdk/aws-codecommit'; import * as codepipeline from '@aws-cdk/aws-codepipeline'; -import { Stack } from '@aws-cdk/core'; +import { Stack, Lazy } from '@aws-cdk/core'; import { Test } from 'nodeunit'; import * as cpactions from '../../lib'; @@ -224,6 +224,49 @@ export = { test.done(); }, + + 'allows using a Token for the branch name'(test: Test) { + const stack = new Stack(); + + const sourceOutput = new codepipeline.Artifact(); + new codepipeline.Pipeline(stack, 'P', { + stages: [ + { + stageName: 'Source', + actions: [ + new cpactions.CodeCommitSourceAction({ + actionName: 'CodeCommit', + repository: new codecommit.Repository(stack, 'R', { + repositoryName: 'repository', + }), + branch: Lazy.stringValue({ produce: () => 'my-branch' }), + output: sourceOutput, + }), + ], + }, + { + stageName: 'Build', + actions: [ + new cpactions.CodeBuildAction({ + actionName: 'Build', + project: new codebuild.PipelineProject(stack, 'CodeBuild'), + input: sourceOutput, + }), + ], + }, + ], + }); + + expect(stack).to(haveResourceLike('AWS::Events::Rule', { + EventPattern: { + detail: { + referenceName: ['my-branch'], + }, + }, + })); + + test.done(); + }, }, }; From 2e7cb95e644cc61f36314c35ac91648d23c499ec Mon Sep 17 00:00:00 2001 From: Neta Nir Date: Tue, 22 Sep 2020 15:22:45 -0700 Subject: [PATCH 08/29] Update CHANGELOG.md --- CHANGELOG.md | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 69a3baea0bb4c..77867355f3560 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -12,10 +12,7 @@ All notable changes to this project will be documented in this file. See [standa * **rds:** removed protected member `subnetGroup` from DatabaseCluster classes * **rds:** Cluster now has deletionProtection enabled if its removal policy is `RETAIN` * **rds**: Instance now has deletionProtection enabled by default only if its removal policy is `RETAIN` -* **cfnspec:** Fixed ECS task definition within the L1 layer. Fixed the casing of the `efsVolumeConfiguration` property to match the spec published by cloudformation. Fixed the type of the `DockerVolumeConfiguration.labels` property to allow users to properly apply labels. -* **ecs**: Task definitions configured with an `efsVolumeConfiguration` will incur a resource replacement due to wrong casing of the underlying resources introduced in this [PR](https://github.com/aws/aws-cdk/pull/8467/files). This replacement will in turn cause a rolling update to any running tasks that use that definition. -* **ecs**: `DockerVolumeConfiguration.labels` changed from an **array** to a **map**. This was a long standing latent bug and in fact configuring labels in the old format would have resulted in the wrong behavior. * **eks:** Clusters previously running k8s version other than `1.15` and bottlerocket AMI(`aws-k8s-1.15` variant) will trigger AMI and node replacement. ### Features @@ -71,6 +68,7 @@ All notable changes to this project will be documented in this file. See [standa * **rds:** standardize removal policies and deletion protection ([#10412](https://github.com/aws/aws-cdk/issues/10412)) ([75811c1](https://github.com/aws/aws-cdk/commit/75811c1325c3d857cf9891048474201b2f28477a)) * **redshift:** cluster defaultChild broken after adding subnet group ([#10389](https://github.com/aws/aws-cdk/issues/10389)) ([746dfe2](https://github.com/aws/aws-cdk/commit/746dfe2b8d0fced5d2a9e4b760f477b0abcb6df9)), closes [#10340](https://github.com/aws/aws-cdk/issues/10340) * **s3-notifications:** lambda destination creates a circular dependency when bucket and lambda are in different stacks ([#10426](https://github.com/aws/aws-cdk/issues/10426)) ([7222b5d](https://github.com/aws/aws-cdk/commit/7222b5d62c70719f9a7b3af5a80840d750b109b1)) +* **ecs**: `DockerVolumeConfiguration.labels` changed from an **array** to a **map**. This was a long standing latent bug and in fact configuring labels in the old format would have resulted in the wrong behavior. ([#10385](https://github.com/aws/aws-cdk/pull/10385)) ## [1.63.0](https://github.com/aws/aws-cdk/compare/v1.62.0...v1.63.0) (2020-09-12) From dd308b6610a670f0dd91df2476253cffb4cb04a3 Mon Sep 17 00:00:00 2001 From: Eli Polonsky Date: Wed, 23 Sep 2020 01:49:18 +0300 Subject: [PATCH 09/29] chore: revert casing of EFSVolumeConfiguration to prevent breaking changes (#10483) ---- *By submitting this pull request, I confirm that my contribution is made under the terms of the Apache-2.0 license* --- .../aws-ecs/lib/base/task-definition.ts | 2 +- .../test/ec2/test.ec2-task-definition.ts | 4 +-- ...finition_EfsVolumeConfiguration_patch.json | 29 +++++++++++++++++++ 3 files changed, 32 insertions(+), 3 deletions(-) create mode 100644 packages/@aws-cdk/cfnspec/spec-source/620_Ecs_TaskDefinition_EfsVolumeConfiguration_patch.json diff --git a/packages/@aws-cdk/aws-ecs/lib/base/task-definition.ts b/packages/@aws-cdk/aws-ecs/lib/base/task-definition.ts index a27c65a6a34b2..0db212f2247a1 100644 --- a/packages/@aws-cdk/aws-ecs/lib/base/task-definition.ts +++ b/packages/@aws-cdk/aws-ecs/lib/base/task-definition.ts @@ -343,7 +343,7 @@ export class TaskDefinition extends TaskDefinitionBase { scope: spec.dockerVolumeConfiguration.scope, }, efsVolumeConfiguration: spec.efsVolumeConfiguration && { - filesystemId: spec.efsVolumeConfiguration.fileSystemId, + fileSystemId: spec.efsVolumeConfiguration.fileSystemId, authorizationConfig: spec.efsVolumeConfiguration.authorizationConfig, rootDirectory: spec.efsVolumeConfiguration.rootDirectory, transitEncryption: spec.efsVolumeConfiguration.transitEncryption, diff --git a/packages/@aws-cdk/aws-ecs/test/ec2/test.ec2-task-definition.ts b/packages/@aws-cdk/aws-ecs/test/ec2/test.ec2-task-definition.ts index 362c040ae97ba..9688e649b545c 100644 --- a/packages/@aws-cdk/aws-ecs/test/ec2/test.ec2-task-definition.ts +++ b/packages/@aws-cdk/aws-ecs/test/ec2/test.ec2-task-definition.ts @@ -1006,8 +1006,8 @@ export = { Family: 'Ec2TaskDef', Volumes: [{ Name: 'scratch', - EFSVolumeConfiguration: { - FilesystemId: 'local', + EfsVolumeConfiguration: { + FileSystemId: 'local', }, }], })); diff --git a/packages/@aws-cdk/cfnspec/spec-source/620_Ecs_TaskDefinition_EfsVolumeConfiguration_patch.json b/packages/@aws-cdk/cfnspec/spec-source/620_Ecs_TaskDefinition_EfsVolumeConfiguration_patch.json new file mode 100644 index 0000000000000..f19367bd89ea0 --- /dev/null +++ b/packages/@aws-cdk/cfnspec/spec-source/620_Ecs_TaskDefinition_EfsVolumeConfiguration_patch.json @@ -0,0 +1,29 @@ +{ + "PropertyTypes": { + "patch": { + "description": "Reverting EfsVolumeConfiguration casing", + "operations": [ + { + "path": "/AWS::ECS::TaskDefinition.Volume/Properties/EFSVolumeConfiguration/Type", + "op": "replace", + "value": "EfsVolumeConfiguration" + }, + { + "from": "/AWS::ECS::TaskDefinition.EFSVolumeConfiguration/Properties/FilesystemId", + "path": "/AWS::ECS::TaskDefinition.EFSVolumeConfiguration/Properties/FileSystemId", + "op": "move" + }, + { + "from": "/AWS::ECS::TaskDefinition.Volume/Properties/EFSVolumeConfiguration", + "path": "/AWS::ECS::TaskDefinition.Volume/Properties/EfsVolumeConfiguration", + "op": "move" + }, + { + "from": "/AWS::ECS::TaskDefinition.EFSVolumeConfiguration", + "path": "/AWS::ECS::TaskDefinition.EfsVolumeConfiguration", + "op": "move" + } + ] + } + } +} \ No newline at end of file From e8e350b737b73586506b2dd1d4b9fccbabb700f3 Mon Sep 17 00:00:00 2001 From: Eli Polonsky Date: Wed, 23 Sep 2020 14:44:25 +0300 Subject: [PATCH 10/29] chore(eks): readme touchups (#10496) A few readme touchups and clarifications. ---- *By submitting this pull request, I confirm that my contribution is made under the terms of the Apache-2.0 license* --- packages/@aws-cdk/aws-eks/README.md | 68 ++++++++++++++--------------- 1 file changed, 34 insertions(+), 34 deletions(-) diff --git a/packages/@aws-cdk/aws-eks/README.md b/packages/@aws-cdk/aws-eks/README.md index bf9200ce865ad..28f03e0d9644a 100644 --- a/packages/@aws-cdk/aws-eks/README.md +++ b/packages/@aws-cdk/aws-eks/README.md @@ -47,6 +47,8 @@ cluster.addManifest('mypod', { }); ``` +> **NOTE: You can only create 1 cluster per stack.** If you have a use-case for multiple clusters per stack, > or would like to understand more about this limitation, see https://github.com/aws/aws-cdk/issues/10073. + In order to interact with your cluster through `kubectl`, you can use the `aws eks update-kubeconfig` [AWS CLI command](https://docs.aws.amazon.com/cli/latest/reference/eks/update-kubeconfig.html) to configure your local kubeconfig. @@ -98,7 +100,8 @@ const cluster = new eks.Cluster(this, 'hello-eks', { }); ``` -The default value is `eks.EndpointAccess.PUBLIC_AND_PRIVATE`. Which means the cluster endpoint is accessible from outside of your VPC, and worker node traffic to the endpoint will stay within your VPC. +The default value is `eks.EndpointAccess.PUBLIC_AND_PRIVATE`. Which means the cluster endpoint is accessible from outside of your VPC, but worker node traffic as well as `kubectl` commands +to the endpoint will stay within your VPC. ### Capacity @@ -139,16 +142,12 @@ new eks.Cluster(this, 'cluster-with-no-capacity', { }); ``` -The `cluster.defaultCapacity` property will reference the `AutoScalingGroup` -resource for the default capacity. It will be `undefined` if `defaultCapacity` -is set to `0` or `defaultCapacityType` is either `NODEGROUP` or undefined. +When creating a cluster with default capacity (i.e `defaultCapacity !== 0` or is undefined), you can access the allocated capacity using: -And the `cluster.defaultNodegroup` property will reference the `Nodegroup` -resource for the default capacity. It will be `undefined` if `defaultCapacity` -is set to `0` or `defaultCapacityType` is `EC2`. +- `cluster.defaultCapacity` will reference the `AutoScalingGroup` resource in case `defaultCapacityType` is set to `EC2` or is undefined. +- `cluster.defaultNodegroup` will reference the `Nodegroup` resource in case `defaultCapacityType` is set to `NODEGROUP`. -You can add `AutoScalingGroup` resource as customized capacity through `cluster.addCapacity()` or -`cluster.addAutoScalingGroup()`: +You can add customized capacity in the form of an `AutoScalingGroup` resource through `cluster.addCapacity()` or `cluster.addAutoScalingGroup()`: ```ts cluster.addCapacity('frontend-nodes', { @@ -167,7 +166,7 @@ for Amazon EKS Kubernetes clusters. By default, `eks.Nodegroup` create a nodegro new eks.Nodegroup(stack, 'nodegroup', { cluster }); ``` -You can add customized node group through `cluster.addNodegroup()`: +You can add customized node groups through `cluster.addNodegroup()`: ```ts cluster.addNodegroup('nodegroup', { @@ -206,14 +205,13 @@ this.cluster.addNodegroup('extra-ng', { ### ARM64 Support -Instance types with `ARM64` architecture are supported in both managed nodegroup and self-managed capacity. Simply specify an ARM64 `instanceType` (such as `m6g.medium`), and the latest +Instance types with `ARM64` architecture are supported in both managed nodegroup and self-managed capacity. Simply specify an ARM64 `instanceType` (such as `m6g.medium`), and the latest Amazon Linux 2 AMI for ARM64 will be automatically selected. ```ts -// create a cluster with a default managed nodegroup +// create a cluster with a default managed nodegroup cluster = new eks.Cluster(this, 'Cluster', { vpc, - mastersRole, version: eks.KubernetesVersion.V1_17, }); @@ -298,12 +296,9 @@ can cause your EC2 instance to become unavailable, such as [EC2 maintenance even and [EC2 Spot interruptions](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-interruptions.html) and helps gracefully stop all pods running on spot nodes that are about to be terminated. -Current version: - -| name | version | -|------------|---------| -| Helm Chart | 0.9.5 | -| App | 1.7.0 | +> Handler Version: [1.7.0](https://github.com/aws/aws-node-termination-handler/releases/tag/v1.7.0) +> +> Chart Version: [0.9.5](https://github.com/aws/eks-charts/blob/v0.0.28/stable/aws-node-termination-handler/Chart.yaml) ### Bootstrapping @@ -327,7 +322,7 @@ cluster.addCapacity('spot', { To disable bootstrapping altogether (i.e. to fully customize user-data), set `bootstrapEnabled` to `false` when you add the capacity. -### Kubernetes Resources +### Kubernetes Manifests The `KubernetesManifest` construct or `cluster.addManifest` method can be used to apply Kubernetes resource manifests to this cluster. @@ -387,7 +382,7 @@ cluster.addManifest('hello-kub', service, deployment); #### Kubectl Layer and Environment -The resources are created in the cluster by running `kubectl apply` from a python lambda function. You can configure the environment of this function by specifying it at cluster instantiation. For example, this can useful in order to configure an http proxy: +The resources are created in the cluster by running `kubectl apply` from a python lambda function. You can configure the environment of this function by specifying it at cluster instantiation. For example, this can be useful in order to configure an http proxy: ```typescript const cluster = new eks.Cluster(this, 'hello-eks', { @@ -450,10 +445,14 @@ const manifest = yaml.safeLoadAll(request('GET', manifestUrl).getBody()); cluster.addManifest('my-resource', ...manifest); ``` -Since Kubernetes resources are implemented as CloudFormation resources in the -CDK. This means that if the resource is deleted from your code (or the stack is +Since Kubernetes manifests are implemented as CloudFormation resources in the +CDK. This means that if the manifest is deleted from your code (or the stack is deleted), the next `cdk deploy` will issue a `kubectl delete` command and the -Kubernetes resources will be deleted. +Kubernetes resources in that manifest will be deleted. + +#### Caveat + +If you have multiple resources in a single `KubernetesManifest`, and one of those **resources** is removed from the manifest, it will not be deleted and will remain orphan. See [Support Object pruning](https://github.com/aws/aws-cdk/issues/10495) for more details. #### Dependencies @@ -482,9 +481,9 @@ const service = cluster.addManifest('my-service', { service.node.addDependency(namespace); // will apply `my-namespace` before `my-service`. ``` -NOTE: when a `KubernetesManifest` includes multiple resources (either directly +**NOTE:** when a `KubernetesManifest` includes multiple resources (either directly or through `cluster.addManifest()`) (e.g. `cluster.addManifest('foo', r1, r2, -r3,...))`), these resources will be applied as a single manifest via `kubectl` +r3,...)`), these resources will be applied as a single manifest via `kubectl` and will be applied sequentially (the standard behavior in `kubectl`). ### Patching Kubernetes Resources @@ -582,7 +581,7 @@ If the cluster is configured with private-only or private and restricted public Kubernetes [endpoint access](#endpoint-access), you must also specify: - `kubectlSecurityGroupId` - the ID of an EC2 security group that is allowed - connections to the cluster's control security group. + connections to the cluster's control security group. For example, the EKS managed [cluster security group](#cluster-security-group). - `kubectlPrivateSubnetIds` - a list of private VPC subnets IDs that will be used to access the Kubernetes endpoint. @@ -598,7 +597,7 @@ users, roles and accounts. Furthermore, when auto-scaling capacity is added to the cluster (through `cluster.addCapacity` or `cluster.addAutoScalingGroup`), the IAM instance role of the auto-scaling group will be automatically mapped to RBAC so nodes can -connect to the cluster. No manual mapping is required any longer. +connect to the cluster. No manual mapping is required. For example, let's say you want to grant an IAM user administrative privileges on your cluster: @@ -657,11 +656,10 @@ const clusterEncryptionConfigKeyArn = cluster.clusterEncryptionConfigKeyArn; ### Node ssh Access If you want to be able to SSH into your worker nodes, you must already -have an SSH key in the region you're connecting to and pass it, and you must -be able to connect to the hosts (meaning they must have a public IP and you +have an SSH key in the region you're connecting to and pass it when you add capacity to the cluster. You must also be able to connect to the hosts (meaning they must have a public IP and you should be allowed to connect to them on port 22): -[ssh into nodes example](test/example.ssh-into-nodes.lit.ts) +See [SSH into nodes](test/example.ssh-into-nodes.lit.ts) for a code example. If you want to SSH into nodes in a private subnet, you should set up a bastion host in a public subnet. That setup is recommended, but is @@ -699,7 +697,7 @@ cluster.addChart('NginxIngress', { Helm charts will be installed and updated using `helm upgrade --install`, where a few parameters are being passed down (such as `repo`, `values`, `version`, `namespace`, `wait`, `timeout`, etc). This means that if the chart is added to CDK with the same release name, it will try to update -the chart in the cluster. The chart will exists as CloudFormation resource. +the chart in the cluster. Helm charts are implemented as CloudFormation resources in CDK. This means that if the chart is deleted from your code (or the stack is @@ -775,9 +773,11 @@ const mypod = cluster.addManifest('mypod', { } }); -// create the resource after the service account +// create the resource after the service account. +// note that using `sa.serviceAccountName` above **does not** translate into a dependency. +// this is why an explicit dependency is needed. See https://github.com/aws/aws-cdk/issues/9910 for more details. mypod.node.addDependency(sa); // print the IAM role arn for this service account new cdk.CfnOutput(this, 'ServiceAccountIamRole', { value: sa.role.roleArn }) -``` +``` \ No newline at end of file From c17969926a2644fc9607dd9b5f105450ed64309a Mon Sep 17 00:00:00 2001 From: Niranjan Jayakar Date: Wed, 23 Sep 2020 15:26:24 +0100 Subject: [PATCH 11/29] chore(awslint): rules permit constructs to extend from 'constructs' module (#10472) Introduce an environment variable - `AWSLINT_BASE_CONSTRUCT` recognized by `awslint`. This environment variable indicates that the module has [migrated][compat-rfc] away from construct classes and interfaces from `@aws-cdk/core` module to those in `constructs` module. Specific rules in the linter recognize this variable and modify their expectations. Motivation The primary motivation is to move the code base towards [removal of the construct compat layer][compat-rfc] as part of [CDKv2]. A large number of code changes to adopt "constructs" module can already be done as part of CDKv1 without incurring breaking changes to the API. This change enables these changes to be performed module-by-module. As modules are migrated, this flag will be enabled, to ensure no regression. [CDKv2]: https://github.com/aws/aws-cdk-rfcs/blob/master/text/0079-cdk-2.0.md [compat-rfc]: https://github.com/aws/aws-cdk-rfcs/blob/master/text/0192-remove-constructs-compat.md ---- *By submitting this pull request, I confirm that my contribution is made under the terms of the Apache-2.0 license* --- packages/@aws-cdk/aws-s3/lib/bucket-policy.ts | 3 +- packages/@aws-cdk/aws-s3/lib/bucket.ts | 3 +- packages/@aws-cdk/aws-s3/lib/util.ts | 5 ++-- packages/@aws-cdk/aws-s3/package.json | 5 +++- packages/@aws-cdk/aws-s3/test/test.aspect.ts | 3 +- .../@aws-cdk/core/lib/construct-compat.ts | 2 +- .../lib/private/physical-name-generator.ts | 7 +++-- packages/@aws-cdk/core/lib/resource.ts | 5 ++-- packages/@aws-cdk/core/lib/stack.ts | 16 ++++++----- packages/@aws-cdk/core/lib/stage.ts | 5 ++-- packages/@aws-cdk/core/package.json | 1 + packages/awslint/lib/rules/construct.ts | 20 +++++++++++-- packages/awslint/lib/rules/core-types.ts | 28 +++++++++++++++++-- packages/awslint/lib/rules/imports.ts | 19 ++++++++++--- tools/cdk-build-tools/bin/cdk-build.ts | 9 +++--- tools/cdk-build-tools/lib/compile.ts | 7 +++-- tools/cdk-build-tools/lib/lint.ts | 7 +++-- tools/cdk-build-tools/lib/package-info.ts | 5 ++++ 18 files changed, 110 insertions(+), 40 deletions(-) diff --git a/packages/@aws-cdk/aws-s3/lib/bucket-policy.ts b/packages/@aws-cdk/aws-s3/lib/bucket-policy.ts index 10f35b5c40e3d..395ff706b5fdc 100644 --- a/packages/@aws-cdk/aws-s3/lib/bucket-policy.ts +++ b/packages/@aws-cdk/aws-s3/lib/bucket-policy.ts @@ -1,5 +1,6 @@ import { PolicyDocument } from '@aws-cdk/aws-iam'; -import { Construct, RemovalPolicy, Resource } from '@aws-cdk/core'; +import { RemovalPolicy, Resource } from '@aws-cdk/core'; +import { Construct } from 'constructs'; import { IBucket } from './bucket'; import { CfnBucketPolicy } from './s3.generated'; diff --git a/packages/@aws-cdk/aws-s3/lib/bucket.ts b/packages/@aws-cdk/aws-s3/lib/bucket.ts index d44f989ba267b..99ecca8402211 100644 --- a/packages/@aws-cdk/aws-s3/lib/bucket.ts +++ b/packages/@aws-cdk/aws-s3/lib/bucket.ts @@ -2,7 +2,8 @@ import { EOL } from 'os'; import * as events from '@aws-cdk/aws-events'; import * as iam from '@aws-cdk/aws-iam'; import * as kms from '@aws-cdk/aws-kms'; -import { Construct, Fn, IResource, Lazy, RemovalPolicy, Resource, Stack, Token } from '@aws-cdk/core'; +import { Fn, IResource, Lazy, RemovalPolicy, Resource, Stack, Token } from '@aws-cdk/core'; +import { Construct } from 'constructs'; import { BucketPolicy } from './bucket-policy'; import { IBucketNotificationDestination } from './destination'; import { BucketNotifications } from './notifications-resource'; diff --git a/packages/@aws-cdk/aws-s3/lib/util.ts b/packages/@aws-cdk/aws-s3/lib/util.ts index 643fdc7472e1a..1c45ed899be4b 100644 --- a/packages/@aws-cdk/aws-s3/lib/util.ts +++ b/packages/@aws-cdk/aws-s3/lib/util.ts @@ -1,7 +1,8 @@ import * as cdk from '@aws-cdk/core'; +import { IConstruct } from 'constructs'; import { BucketAttributes } from './bucket'; -export function parseBucketArn(construct: cdk.IConstruct, props: BucketAttributes): string { +export function parseBucketArn(construct: IConstruct, props: BucketAttributes): string { // if we have an explicit bucket ARN, use it. if (props.bucketArn) { @@ -22,7 +23,7 @@ export function parseBucketArn(construct: cdk.IConstruct, props: BucketAttribute throw new Error('Cannot determine bucket ARN. At least `bucketArn` or `bucketName` is needed'); } -export function parseBucketName(construct: cdk.IConstruct, props: BucketAttributes): string | undefined { +export function parseBucketName(construct: IConstruct, props: BucketAttributes): string | undefined { // if we have an explicit bucket name, use it. if (props.bucketName) { diff --git a/packages/@aws-cdk/aws-s3/package.json b/packages/@aws-cdk/aws-s3/package.json index e9673a87c4893..83150e561020d 100644 --- a/packages/@aws-cdk/aws-s3/package.json +++ b/packages/@aws-cdk/aws-s3/package.json @@ -48,7 +48,10 @@ "compat": "cdk-compat" }, "cdk-build": { - "cloudformation": "AWS::S3" + "cloudformation": "AWS::S3", + "env": { + "AWSLINT_BASE_CONSTRUCT": "true" + } }, "keywords": [ "aws", diff --git a/packages/@aws-cdk/aws-s3/test/test.aspect.ts b/packages/@aws-cdk/aws-s3/test/test.aspect.ts index a1a94a44b0f1d..df020a5ca4698 100644 --- a/packages/@aws-cdk/aws-s3/test/test.aspect.ts +++ b/packages/@aws-cdk/aws-s3/test/test.aspect.ts @@ -1,6 +1,7 @@ // import { expect, haveResource, haveResourceLike, SynthUtils } from '@aws-cdk/assert'; import { SynthUtils } from '@aws-cdk/assert'; import * as cdk from '@aws-cdk/core'; +import { IConstruct } from 'constructs'; import { Test } from 'nodeunit'; import * as s3 from '../lib'; @@ -40,7 +41,7 @@ export = { }; class BucketVersioningChecker implements cdk.IAspect { - public visit(node: cdk.IConstruct): void { + public visit(node: IConstruct): void { if (node instanceof s3.CfnBucket) { if (!node.versioningConfiguration || (!cdk.Tokenization.isResolvable(node.versioningConfiguration) && node.versioningConfiguration.status !== 'Enabled')) { diff --git a/packages/@aws-cdk/core/lib/construct-compat.ts b/packages/@aws-cdk/core/lib/construct-compat.ts index 934b726d92199..d781e74bb0396 100644 --- a/packages/@aws-cdk/core/lib/construct-compat.ts +++ b/packages/@aws-cdk/core/lib/construct-compat.ts @@ -64,7 +64,7 @@ export class Construct extends constructs.Construct implements IConstruct { */ public readonly node: ConstructNode; - constructor(scope: Construct, id: string) { + constructor(scope: constructs.Construct, id: string) { super(scope, id, { nodeFactory: { createNode: (h: constructs.Construct, s: constructs.IConstruct, i: string) => diff --git a/packages/@aws-cdk/core/lib/private/physical-name-generator.ts b/packages/@aws-cdk/core/lib/private/physical-name-generator.ts index dbd0a2c8af772..7c9fae2ab15da 100644 --- a/packages/@aws-cdk/core/lib/private/physical-name-generator.ts +++ b/packages/@aws-cdk/core/lib/private/physical-name-generator.ts @@ -1,4 +1,5 @@ import * as crypto from 'crypto'; +import { Node } from 'constructs'; import { IResolvable, IResolveContext } from '../resolvable'; import { IResource } from '../resource'; import { Stack } from '../stack'; @@ -8,16 +9,16 @@ import { TokenMap } from './token-map'; export function generatePhysicalName(resource: IResource): string { const stack = Stack.of(resource); const stackPart = new PrefixNamePart(stack.stackName, 25); - const idPart = new SuffixNamePart(resource.node.uniqueId, 24); + const idPart = new SuffixNamePart(Node.of(resource).uniqueId, 24); const region: string = stack.region; if (Token.isUnresolved(region) || !region) { - throw new Error(`Cannot generate a physical name for ${resource.node.path}, because the region is un-resolved or missing`); + throw new Error(`Cannot generate a physical name for ${Node.of(resource).path}, because the region is un-resolved or missing`); } const account: string = stack.account; if (Token.isUnresolved(account) || !account) { - throw new Error(`Cannot generate a physical name for ${resource.node.path}, because the account is un-resolved or missing`); + throw new Error(`Cannot generate a physical name for ${Node.of(resource).path}, because the account is un-resolved or missing`); } const parts = [stackPart, idPart] diff --git a/packages/@aws-cdk/core/lib/resource.ts b/packages/@aws-cdk/core/lib/resource.ts index 1eb1da50f7335..c437ef98d5d42 100644 --- a/packages/@aws-cdk/core/lib/resource.ts +++ b/packages/@aws-cdk/core/lib/resource.ts @@ -1,5 +1,6 @@ +import { Construct } from 'constructs'; import { ArnComponents } from './arn'; -import { Construct, IConstruct } from './construct-compat'; +import { IConstruct, Construct as CoreConstruct } from './construct-compat'; import { Lazy } from './lazy'; import { generatePhysicalName, isGeneratedWhenNeededMarker } from './private/physical-name-generator'; import { IResolveContext } from './resolvable'; @@ -86,7 +87,7 @@ export interface ResourceProps { /** * A construct which represents an AWS resource. */ -export abstract class Resource extends Construct implements IResource { +export abstract class Resource extends CoreConstruct implements IResource { public readonly stack: Stack; public readonly env: ResourceEnvironment; diff --git a/packages/@aws-cdk/core/lib/stack.ts b/packages/@aws-cdk/core/lib/stack.ts index 2aad06f44c721..68b82dadfbb7d 100644 --- a/packages/@aws-cdk/core/lib/stack.ts +++ b/packages/@aws-cdk/core/lib/stack.ts @@ -2,6 +2,7 @@ import * as fs from 'fs'; import * as path from 'path'; import * as cxschema from '@aws-cdk/cloud-assembly-schema'; import * as cxapi from '@aws-cdk/cx-api'; +import { IConstruct, Node } from 'constructs'; import { Annotations } from './annotations'; import { App } from './app'; import { Arn, ArnComponents } from './arn'; @@ -10,7 +11,7 @@ import { CfnElement } from './cfn-element'; import { Fn } from './cfn-fn'; import { Aws, ScopedAws } from './cfn-pseudo'; import { CfnResource, TagType } from './cfn-resource'; -import { Construct, IConstruct, ISynthesisSession } from './construct-compat'; +import { Construct, ISynthesisSession } from './construct-compat'; import { ContextProvider } from './context-provider'; import { Environment } from './environment'; import { FeatureFlags } from './feature-flags'; @@ -169,11 +170,12 @@ export class Stack extends Construct implements ITaggable { return c; } - if (Stage.isStage(c) || !c.node.scope) { - throw new Error(`${construct.constructor?.name ?? 'Construct'} at '${construct.node.path}' should be created in the scope of a Stack, but no Stack found`); + const _scope = Node.of(c).scope; + if (Stage.isStage(c) || !_scope) { + throw new Error(`${construct.constructor?.name ?? 'Construct'} at '${Node.of(construct).path}' should be created in the scope of a Stack, but no Stack found`); } - return _lookup(c.node.scope); + return _lookup(_scope); } } @@ -934,7 +936,7 @@ export class Stack extends Construct implements ITaggable { */ private generateStackId(container: IConstruct | undefined) { const rootPath = rootPathTo(this, container); - const ids = rootPath.map(c => c.node.id); + const ids = rootPath.map(c => Node.of(c).id); // In unit tests our Stack (which is the only component) may not have an // id, so in that case just pretend it's "Stack". @@ -1051,7 +1053,7 @@ function cfnElements(node: IConstruct, into: CfnElement[] = []): CfnElement[] { into.push(node); } - for (const child of node.node.children) { + for (const child of Node.of(node).children) { // Don't recurse into a substack if (Stack.isStack(child)) { continue; } @@ -1067,7 +1069,7 @@ function cfnElements(node: IConstruct, into: CfnElement[] = []): CfnElement[] { * If no ancestor is given or the ancestor is not found, return the entire root path. */ export function rootPathTo(construct: IConstruct, ancestor?: IConstruct): IConstruct[] { - const scopes = construct.node.scopes; + const scopes = Node.of(construct).scopes; for (let i = scopes.length - 2; i >= 0; i--) { if (scopes[i] === ancestor) { return scopes.slice(i + 1); diff --git a/packages/@aws-cdk/core/lib/stage.ts b/packages/@aws-cdk/core/lib/stage.ts index b6f6a1f985d19..94296a6d167ee 100644 --- a/packages/@aws-cdk/core/lib/stage.ts +++ b/packages/@aws-cdk/core/lib/stage.ts @@ -1,5 +1,6 @@ import * as cxapi from '@aws-cdk/cx-api'; -import { Construct, IConstruct } from './construct-compat'; +import { IConstruct, Node } from 'constructs'; +import { Construct } from './construct-compat'; import { Environment } from './environment'; import { collectRuntimeInformation } from './private/runtime-info'; import { synthesize } from './private/synthesis'; @@ -73,7 +74,7 @@ export class Stage extends Construct { * @experimental */ public static of(construct: IConstruct): Stage | undefined { - return construct.node.scopes.reverse().slice(1).find(Stage.isStage); + return Node.of(construct).scopes.reverse().slice(1).find(Stage.isStage); } /** diff --git a/packages/@aws-cdk/core/package.json b/packages/@aws-cdk/core/package.json index 3d64a2d8f03fd..ac384aac42fb1 100644 --- a/packages/@aws-cdk/core/package.json +++ b/packages/@aws-cdk/core/package.json @@ -37,6 +37,7 @@ "exclude": [ "props-physical-name:@aws-cdk/aws-cloudformation.CustomResourceProps", "construct-ctor:@aws-cdk/core.App.", + "construct-ctor:@aws-cdk/core.Construct..params[0]", "props-no-cfn-types:@aws-cdk/core.CfnOutputProps.condition", "duration-prop-type:@aws-cdk/core.ResourceSignal.timeout", "props-no-any:@aws-cdk/core.CfnParameterProps.default", diff --git a/packages/awslint/lib/rules/construct.ts b/packages/awslint/lib/rules/construct.ts index ae922413828a4..0cdb50eebded6 100644 --- a/packages/awslint/lib/rules/construct.ts +++ b/packages/awslint/lib/rules/construct.ts @@ -24,6 +24,9 @@ export class ConstructReflection { return typeRef.fqn; } + /** + * @deprecated - use `CoreTypes.constructClass()` or `CoreTypes.baseConstructClass()` as appropriate + */ public readonly ROOT_CLASS: reflect.ClassType; // cdk.Construct public readonly fqn: string; @@ -79,7 +82,7 @@ export class ConstructReflection { constructLinter.add({ code: 'construct-ctor', - message: 'signature of all construct constructors should be "scope, id, props"', + message: 'signature of all construct constructors should be "scope, id, props". ' + baseConstructAddendum(), eval: e => { // only applies to non abstract classes if (e.ctx.classType.abstract) { @@ -93,9 +96,15 @@ constructLinter.add({ const expectedParams = new Array(); + let baseType; + if (process.env.AWSLINT_BASE_CONSTRUCT && !initializer.parentType.name.startsWith('Cfn')) { + baseType = e.ctx.core.baseConstructClass; + } else { + baseType = e.ctx.core.constructClass; + } expectedParams.push({ name: 'scope', - type: e.ctx.core.constructClass.fqn, + type: baseType.fqn, }); expectedParams.push({ @@ -276,3 +285,10 @@ constructLinter.add({ } }, }); + +function baseConstructAddendum(): string { + if (!process.env.AWSLINT_BASE_CONSTRUCT) { + return 'If the construct is using the "constructs" module, set the environment variable "AWSLINT_BASE_CONSTRUCT" and re-run'; + } + return ''; +} \ No newline at end of file diff --git a/packages/awslint/lib/rules/core-types.ts b/packages/awslint/lib/rules/core-types.ts index 09be91656d446..9e14eb5bb9d51 100644 --- a/packages/awslint/lib/rules/core-types.ts +++ b/packages/awslint/lib/rules/core-types.ts @@ -4,12 +4,18 @@ import { getDocTag } from './util'; const CORE_MODULE = '@aws-cdk/core'; enum CoreTypesFqn { CfnResource = '@aws-cdk/core.CfnResource', - Construct = '@aws-cdk/core.Construct', - ConstructInterface = '@aws-cdk/core.IConstruct', Resource = '@aws-cdk/core.Resource', ResourceInterface = '@aws-cdk/core.IResource', ResolvableInterface = '@aws-cdk/core.IResolvable', - PhysicalName = '@aws-cdk/core.PhysicalName' + PhysicalName = '@aws-cdk/core.PhysicalName', + + BaseConstruct = 'constructs.Construct', + BaseConstructInterface = 'constructs.Construct', + + /** @deprecated - use BaseConstruct */ + Construct = '@aws-cdk/core.Construct', + /** @deprecated - use BaseConstructInterface */ + ConstructInterface = '@aws-cdk/core.IConstruct', } export class CoreTypes { @@ -86,18 +92,34 @@ export class CoreTypes { /** * @returns `classType` for the core type Construct + * @deprecated - use `baseConstructClass()` */ public get constructClass() { return this.sys.findClass(CoreTypesFqn.Construct); } + /** + * @returns `classType` for the core type Construct + */ + public get baseConstructClass() { + return this.sys.findClass(CoreTypesFqn.BaseConstruct); + } + /** * @returns `interfacetype` for the core type Construct + * @deprecated - use `baseConstructInterface()` */ public get constructInterface() { return this.sys.findInterface(CoreTypesFqn.ConstructInterface); } + /** + * @returns `interfacetype` for the core type Construct + */ + public get baseConstructInterface() { + return this.sys.findInterface(CoreTypesFqn.BaseConstructInterface); + } + /** * @returns `classType` for the core type Construct */ diff --git a/packages/awslint/lib/rules/imports.ts b/packages/awslint/lib/rules/imports.ts index d69c5f2745d98..4940021e8fdce 100644 --- a/packages/awslint/lib/rules/imports.ts +++ b/packages/awslint/lib/rules/imports.ts @@ -63,16 +63,18 @@ importsLinter.add({ importsLinter.add({ code: 'from-signature', - message: 'invalid method signature for fromXxx method', + message: 'invalid method signature for fromXxx method. ' + baseConstructAddendum(), eval: e => { for (const method of e.ctx.fromMethods) { // "fromRoleArn" => "roleArn" const argName = e.ctx.resource.basename[0].toLocaleLowerCase() + method.name.slice('from'.length + 1); + const baseType = process.env.AWSLINT_BASE_CONSTRUCT ? e.ctx.resource.core.baseConstructClass : + e.ctx.resource.core.constructClass; e.assertSignature(method, { parameters: [ - { name: 'scope', type: e.ctx.resource.construct.ROOT_CLASS }, + { name: 'scope', type: baseType }, { name: 'id', type: 'string' }, { name: argName, type: 'string' }, ], @@ -84,15 +86,17 @@ importsLinter.add({ importsLinter.add({ code: 'from-attributes', - message: 'static fromXxxAttributes is a factory of IXxx from its primitive attributes', + message: 'static fromXxxAttributes is a factory of IXxx from its primitive attributes. ' + baseConstructAddendum(), eval: e => { if (!e.ctx.fromAttributesMethod) { return; } + const baseType = process.env.AWSLINT_BASE_CONSTRUCT ? e.ctx.resource.core.baseConstructClass + : e.ctx.resource.core.constructClass; e.assertSignature(e.ctx.fromAttributesMethod, { parameters: [ - { name: 'scope', type: e.ctx.resource.construct.ROOT_CLASS }, + { name: 'scope', type: baseType }, { name: 'id', type: 'string' }, { name: 'attrs', type: e.ctx.attributesStruct }, ], @@ -111,3 +115,10 @@ importsLinter.add({ e.assert(e.ctx.attributesStruct, e.ctx.attributesStructName); }, }); + +function baseConstructAddendum(): string { + if (!process.env.AWSLINT_BASE_CONSTRUCT) { + return 'If the construct is using the "constructs" module, set the environment variable "AWSLINT_BASE_CONSTRUCT" and re-run'; + } + return ''; +} diff --git a/tools/cdk-build-tools/bin/cdk-build.ts b/tools/cdk-build-tools/bin/cdk-build.ts index 87f269364adb8..185811c6b0658 100644 --- a/tools/cdk-build-tools/bin/cdk-build.ts +++ b/tools/cdk-build-tools/bin/cdk-build.ts @@ -27,9 +27,10 @@ async function main() { .argv; const options = cdkBuildOptions(); + const env = options.env; if (options.pre) { - await shell(options.pre, { timers }); + await shell(options.pre, { timers, env }); } // See if we need to call cfn2ts @@ -38,15 +39,15 @@ async function main() { // There can be multiple scopes, ensuring it's always an array. options.cloudformation = [options.cloudformation]; } - await shell(['cfn2ts', ...options.cloudformation.map(scope => `--scope=${scope}`)], { timers }); + await shell(['cfn2ts', ...options.cloudformation.map(scope => `--scope=${scope}`)], { timers, env }); } const overrides: CompilerOverrides = { eslint: args.eslint, jsii: args.jsii, tsc: args.tsc }; - await compileCurrentPackage(timers, overrides); + await compileCurrentPackage(options, timers, overrides); await lintCurrentPackage(options, overrides); if (options.post) { - await shell(options.post, { timers }); + await shell(options.post, { timers, env }); } } diff --git a/tools/cdk-build-tools/lib/compile.ts b/tools/cdk-build-tools/lib/compile.ts index 1101333113bf9..fe63d0c8f346e 100644 --- a/tools/cdk-build-tools/lib/compile.ts +++ b/tools/cdk-build-tools/lib/compile.ts @@ -1,12 +1,13 @@ import { makeExecutable, shell } from './os'; -import { CompilerOverrides, currentPackageJson, packageCompiler } from './package-info'; +import { CDKBuildOptions, CompilerOverrides, currentPackageJson, packageCompiler } from './package-info'; import { Timers } from './timer'; /** * Run the compiler on the current package */ -export async function compileCurrentPackage(timers: Timers, compilers: CompilerOverrides = {}): Promise { - await shell(packageCompiler(compilers), { timers }); +export async function compileCurrentPackage(options: CDKBuildOptions, timers: Timers, compilers: CompilerOverrides = {}): Promise { + const env = options.env; + await shell(packageCompiler(compilers), { timers, env }); // Find files in bin/ that look like they should be executable, and make them so. const scripts = currentPackageJson().bin || {}; diff --git a/tools/cdk-build-tools/lib/lint.ts b/tools/cdk-build-tools/lib/lint.ts index 77943bad48e8c..ca9128a4e5f82 100644 --- a/tools/cdk-build-tools/lib/lint.ts +++ b/tools/cdk-build-tools/lib/lint.ts @@ -3,6 +3,7 @@ import { shell } from './os'; import { CDKBuildOptions, CompilerOverrides } from './package-info'; export async function lintCurrentPackage(options: CDKBuildOptions, compilers: CompilerOverrides & { fix?: boolean } = {}): Promise { + const env = options.env; if (!options.eslint?.disable) { await shell([ compilers.eslint || require.resolve('eslint/bin/eslint'), @@ -10,12 +11,12 @@ export async function lintCurrentPackage(options: CDKBuildOptions, compilers: Co '--ext=.ts', `--resolve-plugins-relative-to=${__dirname}`, ...compilers.fix ? ['--fix'] : [], - ]); + ], { env }); } if (!options.pkglint?.disable) { - await shell(['pkglint']); + await shell(['pkglint'], { env }); } - await shell([path.join(__dirname, '..', 'bin', 'cdk-awslint')]); + await shell([path.join(__dirname, '..', 'bin', 'cdk-awslint')], { env }); } diff --git a/tools/cdk-build-tools/lib/package-info.ts b/tools/cdk-build-tools/lib/package-info.ts index afc4041776b9f..cf5b657d9a470 100644 --- a/tools/cdk-build-tools/lib/package-info.ts +++ b/tools/cdk-build-tools/lib/package-info.ts @@ -135,6 +135,11 @@ export interface CDKBuildOptions { * but we want to eventually move all of them to Jest. */ jest?: boolean; + + /** + * Environment variables to be passed to 'cdk-build' and all of its child processes. + */ + env?: NodeJS.ProcessEnv; } /** From c7c78516e712051884999a9d1801e97bafe49c5b Mon Sep 17 00:00:00 2001 From: Nick Lynch Date: Wed, 23 Sep 2020 18:07:46 +0100 Subject: [PATCH 12/29] feat(rds): support setting database master users from existing secrets (#10458) See https://github.com/aws/aws-cdk/issues/7927#issuecomment-694857345 for motivation and design. The current way of specifying master user logins for `DatabaseInstance` and `DatabaseCluster` is inconsistent between the two and introduces some awkward usage when creating a login from an existing `Secret`. This change converts the existing `Login` interface (used by the `DatabaseCluster`) into a class with factory methods for username/password or secret-based logins. This also then re-uses that same interface for `DatabaseInstance`. The one exception now will be `DatabaseInstanceFromSnapshot`, which has specific requirements that deserved its own interface (`SnapshotLogin`). As a side effect of this approach, existing `DatabaseCluster` users -- in Typescript at least -- will not be broken. For example, the following are equivalent: ```ts new rds.DatabaseCluster(this, 'Cluster1', { // Existing usage masterUser: { username: 'admin', }, // New usage masterUser: Login.fromUsername('admin'), }); ``` Lastly, this change makes the whole `masterUser` prop optional, as there's no good reason why we can't default a username. fixes #7927 BREAKING CHANGE: `DatabaseInstanceProps` and `DatabaseInstanceFromSnapshotProps` - `masterUsername`, `masterUserPassword` and `masterUserPasswordEncryptionKey` moved to `credentials` as a new `Credentials` class. * **rds:** `Login` renamed to `Credentials`. Use `Credentials.fromUsername` to replace existing usage. * **rds:** `DatabaseClusterProps` `masterUser` renamed to `credentials`. ---- *By submitting this pull request, I confirm that my contribution is made under the terms of the Apache-2.0 license* --- packages/@aws-cdk/aws-rds/README.md | 38 +++- packages/@aws-cdk/aws-rds/lib/cluster.ts | 29 ++- packages/@aws-cdk/aws-rds/lib/instance.ts | 89 +++------ packages/@aws-cdk/aws-rds/lib/props.ts | 148 +++++++++++++- .../test/integ.cluster-rotation.lit.ts | 3 - .../@aws-cdk/aws-rds/test/integ.cluster-s3.ts | 7 +- .../@aws-cdk/aws-rds/test/integ.cluster.ts | 7 +- .../aws-rds/test/integ.instance-s3.ts | 1 - .../aws-rds/test/integ.instance.lit.ts | 2 +- packages/@aws-cdk/aws-rds/test/integ.proxy.ts | 2 +- .../@aws-cdk/aws-rds/test/test.cluster.ts | 82 ++++---- .../@aws-cdk/aws-rds/test/test.instance.ts | 186 +++++++++--------- packages/@aws-cdk/aws-rds/test/test.proxy.ts | 8 - 13 files changed, 352 insertions(+), 250 deletions(-) diff --git a/packages/@aws-cdk/aws-rds/README.md b/packages/@aws-cdk/aws-rds/README.md index cc8be1361bca8..88a2d001107de 100644 --- a/packages/@aws-cdk/aws-rds/README.md +++ b/packages/@aws-cdk/aws-rds/README.md @@ -27,9 +27,7 @@ your instances will be launched privately or publicly: ```ts const cluster = new rds.DatabaseCluster(this, 'Database', { engine: rds.DatabaseClusterEngine.auroraMysql({ version: rds.AuroraMysqlEngineVersion.VER_2_08_1 }), - masterUser: { - username: 'clusteradmin' - }, + masterUser: rds.Login.fromUsername('clusteradmin'), // Optional - will default to admin instanceProps: { // optional, defaults to t3.medium instanceType: ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE2, ec2.InstanceSize.SMALL), @@ -76,7 +74,7 @@ const instance = new rds.DatabaseInstance(this, 'Instance', { engine: rds.DatabaseInstanceEngine.oracleSe2({ version: rds.OracleEngineVersion.VER_19_0_0_0_2020_04_R1 }), // optional, defaults to m5.large instanceType: ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE3, ec2.InstanceSize.SMALL), - masterUsername: 'syscdk', + masterUsername: rds.Login.fromUsername('syscdk'), // Optional - will default to admin vpc, vpcSubnets: { subnetType: ec2.SubnetType.PRIVATE @@ -103,7 +101,6 @@ const instance = new rds.DatabaseInstance(this, 'Instance', { engine: rds.DatabaseInstanceEngine.postgres({ version: rds.PostgresEngineVersion.VER_12_3 }), // optional, defaults to m5.large instanceType: ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE2, ec2.InstanceSize.SMALL), - masterUsername: 'syscdk', vpc, maxAllocatedStorage: 200, }); @@ -141,6 +138,35 @@ method: const rule = instance.onEvent('InstanceEvent', { target: new targets.LambdaFunction(fn) }); ``` +### Login credentials + +By default, database instances and clusters will have `admin` user with an auto-generated password. +An alternative username (and password) may be specified for the admin user instead of the default. + +The following examples use a `DatabaseInstance`, but the same usage is applicable to `DatabaseCluster`. + +```ts +const engine = rds.DatabaseInstanceEngine.postgres({ version: rds.PostgresEngineVersion.VER_12_3 }); +new rds.DatabaseInstance(this, 'InstanceWithUsername', { + engine, + vpc, + credentials: rds.Credentials.fromUsername('postgres'), // Creates an admin user of postgres with a generated password +}); + +new rds.DatabaseInstance(this, 'InstanceWithUsernameAndPassword', { + engine, + vpc, + credentials: rds.Credentials.fromUsername('postgres', { password: SecretValue.ssmSecure('/dbPassword', 1) }), // Use password from SSM +}); + +const mySecret = secretsmanager.Secret.fromSecretName(this, 'DBSecret', 'myDBLoginInfo'); +new rds.DatabaseInstance(this, 'InstanceWithSecretLogin', { + engine, + vpc, + credentials: rds.Credentials.fromSecret(mySecret), // Get both username and password from existing secret +}); +``` + ### Connecting To control who can access the cluster or instance, use the `.connections` attribute. RDS databases have @@ -211,7 +237,6 @@ The following example shows enabling IAM authentication for a database instance ```ts const instance = new rds.DatabaseInstance(stack, 'Instance', { engine: rds.DatabaseInstanceEngine.mysql({ version: rds.MysqlEngineVersion.VER_8_0_19 }), - masterUsername: 'admin', vpc, iamAuthentication: true, // Optional - will be automatically set if you call grantConnect(). }); @@ -240,7 +265,6 @@ const role = new iam.Role(stack, 'RDSDirectoryServicesRole', { }); const instance = new rds.DatabaseInstance(stack, 'Instance', { engine: rds.DatabaseInstanceEngine.mysql({ version: rds.MysqlEngineVersion.VER_8_0_19 }), - masterUsername: 'admin', vpc, domain: 'd-????????', // The ID of the domain for the instance to join. domainRole: role, // Optional - will be create automatically if not provided. diff --git a/packages/@aws-cdk/aws-rds/lib/cluster.ts b/packages/@aws-cdk/aws-rds/lib/cluster.ts index 9bd29be6e64e0..a4d01868ba5fb 100644 --- a/packages/@aws-cdk/aws-rds/lib/cluster.ts +++ b/packages/@aws-cdk/aws-rds/lib/cluster.ts @@ -11,7 +11,7 @@ import { DatabaseSecret } from './database-secret'; import { Endpoint } from './endpoint'; import { IParameterGroup } from './parameter-group'; import { applyRemovalPolicy, defaultDeletionProtection, setupS3ImportExport } from './private/util'; -import { BackupProps, InstanceProps, Login, PerformanceInsightRetention, RotationMultiUserOptions } from './props'; +import { BackupProps, Credentials, InstanceProps, PerformanceInsightRetention, RotationMultiUserOptions } from './props'; import { DatabaseProxy, DatabaseProxyOptions, ProxyTarget } from './proxy'; import { CfnDBCluster, CfnDBClusterProps, CfnDBInstance } from './rds.generated'; import { ISubnetGroup, SubnetGroup } from './subnet-group'; @@ -418,9 +418,11 @@ class ImportedDatabaseCluster extends DatabaseClusterBase implements IDatabaseCl */ export interface DatabaseClusterProps extends DatabaseClusterBaseProps { /** - * Username and password for the administrative user + * Credentials for the administrative user + * + * @default - A username of 'admin' and SecretsManager-generated password */ - readonly masterUser: Login; + readonly credentials?: Credentials; /** * Whether to enable storage encryption. @@ -476,23 +478,20 @@ export class DatabaseCluster extends DatabaseClusterNew { this.singleUserRotationApplication = props.engine.singleUserRotationApplication; this.multiUserRotationApplication = props.engine.multiUserRotationApplication; - let secret: DatabaseSecret | undefined; - if (!props.masterUser.password) { - secret = new DatabaseSecret(this, 'Secret', { - username: props.masterUser.username, - encryptionKey: props.masterUser.encryptionKey, - }); + let credentials = props.credentials ?? Credentials.fromUsername('admin'); + if (!credentials.secret && !credentials.password) { + credentials = Credentials.fromSecret(new DatabaseSecret(this, 'Secret', { + username: credentials.username, + encryptionKey: credentials.encryptionKey, + })); } + const secret = credentials.secret; const cluster = new CfnDBCluster(this, 'Resource', { ...this.newCfnProps, // Admin - masterUsername: secret ? secret.secretValueFromJson('username').toString() : props.masterUser.username, - masterUserPassword: secret - ? secret.secretValueFromJson('password').toString() - : (props.masterUser.password - ? props.masterUser.password.toString() - : undefined), + masterUsername: credentials.username, + masterUserPassword: credentials.password?.toString(), // Encryption kmsKeyId: props.storageEncryptionKey?.keyArn, storageEncrypted: props.storageEncryptionKey ? true : props.storageEncrypted, diff --git a/packages/@aws-cdk/aws-rds/lib/instance.ts b/packages/@aws-cdk/aws-rds/lib/instance.ts index 1339306e9553f..fa08049df2f97 100644 --- a/packages/@aws-cdk/aws-rds/lib/instance.ts +++ b/packages/@aws-cdk/aws-rds/lib/instance.ts @@ -5,14 +5,14 @@ import * as kms from '@aws-cdk/aws-kms'; import * as logs from '@aws-cdk/aws-logs'; import * as s3 from '@aws-cdk/aws-s3'; import * as secretsmanager from '@aws-cdk/aws-secretsmanager'; -import { Construct, Duration, IResource, Lazy, RemovalPolicy, Resource, SecretValue, Stack, Token } from '@aws-cdk/core'; +import { Construct, Duration, IResource, Lazy, RemovalPolicy, Resource, Stack, Token } from '@aws-cdk/core'; import { DatabaseSecret } from './database-secret'; import { Endpoint } from './endpoint'; import { IInstanceEngine } from './instance-engine'; import { IOptionGroup } from './option-group'; import { IParameterGroup } from './parameter-group'; import { applyRemovalPolicy, defaultDeletionProtection, engineDescription, setupS3ImportExport } from './private/util'; -import { PerformanceInsightRetention, RotationMultiUserOptions } from './props'; +import { Credentials, PerformanceInsightRetention, RotationMultiUserOptions, SnapshotCredentials } from './props'; import { DatabaseProxy, DatabaseProxyOptions, ProxyTarget } from './proxy'; import { CfnDBInstance, CfnDBInstanceProps } from './rds.generated'; import { ISubnetGroup, SubnetGroup } from './subnet-group'; @@ -750,20 +750,6 @@ export interface DatabaseInstanceSourceProps extends DatabaseInstanceNewProps { */ readonly allocatedStorage?: number; - /** - * The master user password. - * - * @default - a Secrets Manager generated password - */ - readonly masterUserPassword?: SecretValue; - - /** - * The KMS key used to encrypt the secret for the master user password. - * - * @default - default master key - */ - readonly masterUserPasswordEncryptionKey?: kms.IKey; - /** * The name of the database. * @@ -894,9 +880,11 @@ abstract class DatabaseInstanceSource extends DatabaseInstanceNew implements IDa */ export interface DatabaseInstanceProps extends DatabaseInstanceSourceProps { /** - * The master user name. + * Credentials for the administrative user + * + * @default - A username of 'admin' and SecretsManager-generated password */ - readonly masterUsername: string; + readonly credentials?: Credentials; /** * For supported engines, specifies the character set to associate with the @@ -936,22 +924,21 @@ export class DatabaseInstance extends DatabaseInstanceSource implements IDatabas constructor(scope: Construct, id: string, props: DatabaseInstanceProps) { super(scope, id, props); - let secret: DatabaseSecret | undefined; - if (!props.masterUserPassword) { - secret = new DatabaseSecret(this, 'Secret', { - username: props.masterUsername, - encryptionKey: props.masterUserPasswordEncryptionKey, - }); + let credentials = props.credentials ?? Credentials.fromUsername('admin'); + if (!credentials.secret && !credentials.password) { + credentials = Credentials.fromSecret(new DatabaseSecret(this, 'Secret', { + username: credentials.username, + encryptionKey: credentials.encryptionKey, + })); } + const secret = credentials.secret; const instance = new CfnDBInstance(this, 'Resource', { ...this.sourceCfnProps, characterSetName: props.characterSetName, kmsKeyId: props.storageEncryptionKey && props.storageEncryptionKey.keyArn, - masterUsername: secret ? secret.secretValueFromJson('username').toString() : props.masterUsername, - masterUserPassword: secret - ? secret.secretValueFromJson('password').toString() - : props.masterUserPassword && props.masterUserPassword.toString(), + masterUsername: credentials.username, + masterUserPassword: credentials.password?.toString(), storageEncrypted: props.storageEncryptionKey ? true : props.storageEncrypted, }); @@ -985,26 +972,14 @@ export interface DatabaseInstanceFromSnapshotProps extends DatabaseInstanceSourc readonly snapshotIdentifier: string; /** - * The master user name. - * - * Specify this prop with the **current** master user name of the snapshot - * only when generating a new master user password with `generateMasterUserPassword`. - * The value will be set in the generated secret attached to the instance. + * Master user credentials. * - * It is not possible to change the master user name of a RDS instance. - * - * @default - inherited from the snapshot - */ - readonly masterUsername?: string; - - /** - * Whether to generate a new master user password and store it in - * Secrets Manager. `masterUsername` must be specified with the **current** - * master user name of the snapshot when this property is set to true. + * Note - It is not possible to change the master username for a snapshot; + * however, it is possible to provide (or generate) a new password. * - * @default false + * @default - The existing username and password from the snapshot will be used. */ - readonly generateMasterUserPassword?: boolean; + readonly credentials?: SnapshotCredentials; } /** @@ -1022,25 +997,17 @@ export class DatabaseInstanceFromSnapshot extends DatabaseInstanceSource impleme constructor(scope: Construct, id: string, props: DatabaseInstanceFromSnapshotProps) { super(scope, id, props); - let secret: DatabaseSecret | undefined; - - if (props.generateMasterUserPassword) { - if (!props.masterUsername) { // We need the master username to include it in the generated secret - throw new Error('`masterUsername` must be specified when `generateMasterUserPassword` is set to true.'); - } - - if (props.masterUserPassword) { - throw new Error('Cannot specify `masterUserPassword` when `generateMasterUserPassword` is set to true.'); + let credentials = props.credentials; + let secret = credentials?.secret; + if (!secret && credentials?.generatePassword) { + if (!credentials.username) { + throw new Error('`credentials` `username` must be specified when `generatePassword` is set to true'); } secret = new DatabaseSecret(this, 'Secret', { - username: props.masterUsername, - encryptionKey: props.masterUserPasswordEncryptionKey, + username: credentials.username, + encryptionKey: credentials.encryptionKey, }); - } else { - if (props.masterUsername) { // It's not possible to change the master username of a RDS instance - throw new Error('Cannot specify `masterUsername` when `generateMasterUserPassword` is set to false.'); - } } const instance = new CfnDBInstance(this, 'Resource', { @@ -1048,7 +1015,7 @@ export class DatabaseInstanceFromSnapshot extends DatabaseInstanceSource impleme dbSnapshotIdentifier: props.snapshotIdentifier, masterUserPassword: secret ? secret.secretValueFromJson('password').toString() - : props.masterUserPassword && props.masterUserPassword.toString(), + : credentials?.password?.toString(), }); this.instanceIdentifier = instance.ref; diff --git a/packages/@aws-cdk/aws-rds/lib/props.ts b/packages/@aws-cdk/aws-rds/lib/props.ts index 8e037b77c7174..81a27a1e05d70 100644 --- a/packages/@aws-cdk/aws-rds/lib/props.ts +++ b/packages/@aws-cdk/aws-rds/lib/props.ts @@ -94,30 +94,166 @@ export interface BackupProps { readonly preferredWindow?: string; } +/** + * Options for creating a Login from a username. + */ +export interface CredentialsFromUsernameOptions { + /** + * Password + * + * Do not put passwords in your CDK code directly. + * + * @default - a Secrets Manager generated password + */ + readonly password?: SecretValue; + + /** + * KMS encryption key to encrypt the generated secret. + * + * @default - default master key + */ + readonly encryptionKey?: kms.IKey; +} + /** * Username and password combination */ -export interface Login { +export abstract class Credentials { + + /** + * Creates Credentials for the given username, and optional password and key. + * If no password is provided, one will be generated and stored in SecretsManager. + */ + public static fromUsername(username: string, options: CredentialsFromUsernameOptions = {}): Credentials { + return { username, password: options.password, encryptionKey: options.encryptionKey }; + } + + /** + * Creates Credentials from an existing SecretsManager ``Secret`` (or ``DatabaseSecret``) + * + * The Secret must be a JSON string with a ``username`` and ``password`` field: + * ``` + * { + * ... + * "username": , + * "password": , + * } + * ``` + */ + public static fromSecret(secret: secretsmanager.Secret): Credentials { + return { + username: secret.secretValueFromJson('username').toString(), + password: secret.secretValueFromJson('password'), + encryptionKey: secret.encryptionKey, + secret, + }; + } + /** * Username */ - readonly username: string; + public abstract readonly username: string; /** * Password * * Do not put passwords in your CDK code directly. * - * @default a Secrets Manager generated password + * @default - a Secrets Manager generated password */ - readonly password?: SecretValue; + public abstract readonly password?: SecretValue; /** * KMS encryption key to encrypt the generated secret. * - * @default default master key + * @default - default master key */ - readonly encryptionKey?: kms.IKey; + public abstract readonly encryptionKey?: kms.IKey; + + /** + * Secret used to instantiate this Login. + * + * @default - none + */ + public abstract readonly secret?: secretsmanager.Secret; +} + +/** + * Credentials to update the password for a ``DatabaseInstanceFromSnapshot``. + */ +export abstract class SnapshotCredentials { + /** + * Generate a new password for the snapshot, using the existing username and an optional encryption key. + * + * Note - The username must match the existing master username of the snapshot. + */ + public static fromGeneratedPassword(username: string, encryptionKey?: kms.IKey): SnapshotCredentials { + return { generatePassword: true, username, encryptionKey }; + } + + /** + * Update the snapshot login with an existing password. + */ + public static fromPassword(password: SecretValue): SnapshotCredentials { + return { generatePassword: false, password }; + } + + /** + * Update the snapshot login with an existing password from a Secret. + * + * The Secret must be a JSON string with a ``password`` field: + * ``` + * { + * ... + * "password": , + * } + * ``` + */ + public static fromSecret(secret: secretsmanager.Secret): SnapshotCredentials { + return { + generatePassword: false, + password: secret.secretValueFromJson('password'), + secret, + }; + } + + /** + * The master user name. + * + * Must be the **current** master user name of the snapshot. + * It is not possible to change the master user name of a RDS instance. + * + * @default - the existing username from the snapshot + */ + public abstract readonly username?: string; + + /** + * Whether a new password should be generated. + */ + public abstract readonly generatePassword: boolean; + + /** + * The master user password. + * + * Do not put passwords in your CDK code directly. + * + * @default - the existing password from the snapshot + */ + public abstract readonly password?: SecretValue; + + /** + * KMS encryption key to encrypt the generated secret. + * + * @default - default master key + */ + public abstract readonly encryptionKey?: kms.IKey; + + /** + * Secret used to instantiate this Login. + * + * @default - none + */ + public abstract readonly secret?: secretsmanager.Secret; } /** diff --git a/packages/@aws-cdk/aws-rds/test/integ.cluster-rotation.lit.ts b/packages/@aws-cdk/aws-rds/test/integ.cluster-rotation.lit.ts index 900364b2aa7b8..0a429ae3d5742 100644 --- a/packages/@aws-cdk/aws-rds/test/integ.cluster-rotation.lit.ts +++ b/packages/@aws-cdk/aws-rds/test/integ.cluster-rotation.lit.ts @@ -10,9 +10,6 @@ const vpc = new ec2.Vpc(stack, 'VPC'); /// !show const cluster = new rds.DatabaseCluster(stack, 'Database', { engine: rds.DatabaseClusterEngine.AURORA, - masterUser: { - username: 'admin', - }, instanceProps: { instanceType: ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE3, ec2.InstanceSize.SMALL), vpc, diff --git a/packages/@aws-cdk/aws-rds/test/integ.cluster-s3.ts b/packages/@aws-cdk/aws-rds/test/integ.cluster-s3.ts index 2153d8ea95410..5b4f2d3742f02 100644 --- a/packages/@aws-cdk/aws-rds/test/integ.cluster-s3.ts +++ b/packages/@aws-cdk/aws-rds/test/integ.cluster-s3.ts @@ -2,7 +2,7 @@ import * as ec2 from '@aws-cdk/aws-ec2'; import * as kms from '@aws-cdk/aws-kms'; import * as s3 from '@aws-cdk/aws-s3'; import * as cdk from '@aws-cdk/core'; -import { DatabaseCluster, DatabaseClusterEngine } from '../lib'; +import { Credentials, DatabaseCluster, DatabaseClusterEngine } from '../lib'; const app = new cdk.App(); const stack = new cdk.Stack(app, 'aws-cdk-rds-s3-integ'); @@ -16,10 +16,7 @@ const exportBucket = new s3.Bucket(stack, 'ExportBucket'); const cluster = new DatabaseCluster(stack, 'Database', { engine: DatabaseClusterEngine.AURORA, - masterUser: { - username: 'admin', - password: cdk.SecretValue.plainText('7959866cacc02c2d243ecfe177464fe6'), - }, + credentials: Credentials.fromUsername('admin', { password: cdk.SecretValue.plainText('7959866cacc02c2d243ecfe177464fe6') }), instanceProps: { instanceType: ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE3, ec2.InstanceSize.SMALL), vpcSubnets: { subnetType: ec2.SubnetType.PUBLIC }, diff --git a/packages/@aws-cdk/aws-rds/test/integ.cluster.ts b/packages/@aws-cdk/aws-rds/test/integ.cluster.ts index a5bdaba4883c9..245ab98ab8e78 100644 --- a/packages/@aws-cdk/aws-rds/test/integ.cluster.ts +++ b/packages/@aws-cdk/aws-rds/test/integ.cluster.ts @@ -1,7 +1,7 @@ import * as ec2 from '@aws-cdk/aws-ec2'; import * as kms from '@aws-cdk/aws-kms'; import * as cdk from '@aws-cdk/core'; -import { DatabaseCluster, DatabaseClusterEngine, ParameterGroup } from '../lib'; +import { Credentials, DatabaseCluster, DatabaseClusterEngine, ParameterGroup } from '../lib'; const app = new cdk.App(); const stack = new cdk.Stack(app, 'aws-cdk-rds-integ'); @@ -20,10 +20,7 @@ const kmsKey = new kms.Key(stack, 'DbSecurity'); const cluster = new DatabaseCluster(stack, 'Database', { engine: DatabaseClusterEngine.AURORA, - masterUser: { - username: 'admin', - password: cdk.SecretValue.plainText('7959866cacc02c2d243ecfe177464fe6'), - }, + credentials: Credentials.fromUsername('admin', { password: cdk.SecretValue.plainText('7959866cacc02c2d243ecfe177464fe6') }), instanceProps: { instanceType: ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE3, ec2.InstanceSize.SMALL), vpcSubnets: { subnetType: ec2.SubnetType.PUBLIC }, diff --git a/packages/@aws-cdk/aws-rds/test/integ.instance-s3.ts b/packages/@aws-cdk/aws-rds/test/integ.instance-s3.ts index d3503d5889404..876ac2251e8fc 100644 --- a/packages/@aws-cdk/aws-rds/test/integ.instance-s3.ts +++ b/packages/@aws-cdk/aws-rds/test/integ.instance-s3.ts @@ -13,7 +13,6 @@ const exportBucket = new s3.Bucket(stack, 'ExportBucket', { removalPolicy: cdk.R new DatabaseInstance(stack, 'Database', { engine: DatabaseInstanceEngine.sqlServerSe({ version: SqlServerEngineVersion.VER_14_00_3192_2_V1 }), - masterUsername: 'admin', vpc, licenseModel: LicenseModel.LICENSE_INCLUDED, s3ImportBuckets: [importBucket], diff --git a/packages/@aws-cdk/aws-rds/test/integ.instance.lit.ts b/packages/@aws-cdk/aws-rds/test/integ.instance.lit.ts index 7f36806c35230..eafe7a2953735 100644 --- a/packages/@aws-cdk/aws-rds/test/integ.instance.lit.ts +++ b/packages/@aws-cdk/aws-rds/test/integ.instance.lit.ts @@ -49,7 +49,7 @@ class DatabaseInstanceStack extends cdk.Stack { instanceType: ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE3, ec2.InstanceSize.MEDIUM), multiAz: true, storageType: rds.StorageType.IO1, - masterUsername: 'syscdk', + credentials: rds.Credentials.fromUsername('syscdk'), vpc, databaseName: 'ORCL', storageEncrypted: true, diff --git a/packages/@aws-cdk/aws-rds/test/integ.proxy.ts b/packages/@aws-cdk/aws-rds/test/integ.proxy.ts index 8c2ef1879787b..e45da0950ed2a 100644 --- a/packages/@aws-cdk/aws-rds/test/integ.proxy.ts +++ b/packages/@aws-cdk/aws-rds/test/integ.proxy.ts @@ -10,7 +10,7 @@ const vpc = new ec2.Vpc(stack, 'vpc', { maxAzs: 2 }); const dbInstance = new rds.DatabaseInstance(stack, 'dbInstance', { engine: rds.DatabaseInstanceEngine.POSTGRES, instanceType: ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE3, ec2.InstanceSize.MEDIUM), - masterUsername: 'master', + credentials: rds.Credentials.fromUsername('master'), vpc, }); diff --git a/packages/@aws-cdk/aws-rds/test/test.cluster.ts b/packages/@aws-cdk/aws-rds/test/test.cluster.ts index 8915973a5938d..82dce160e7128 100644 --- a/packages/@aws-cdk/aws-rds/test/test.cluster.ts +++ b/packages/@aws-cdk/aws-rds/test/test.cluster.ts @@ -20,7 +20,7 @@ export = { // WHEN new DatabaseCluster(stack, 'Database', { engine: DatabaseClusterEngine.AURORA, - masterUser: { + credentials: { username: 'admin', password: cdk.SecretValue.plainText('tooshort'), }, @@ -61,7 +61,7 @@ export = { new DatabaseCluster(stack, 'Database', { engine: DatabaseClusterEngine.AURORA, instances: 1, - masterUser: { + credentials: { username: 'admin', password: cdk.SecretValue.plainText('tooshort'), }, @@ -95,7 +95,7 @@ export = { new DatabaseCluster(stack, 'Database', { engine: DatabaseClusterEngine.AURORA, instances: 1, - masterUser: { + credentials: { username: 'admin', password: cdk.SecretValue.plainText('tooshort'), }, @@ -133,7 +133,7 @@ export = { }); new DatabaseCluster(stack, 'Database', { engine: DatabaseClusterEngine.AURORA, - masterUser: { + credentials: { username: 'admin', password: cdk.SecretValue.plainText('tooshort'), }, @@ -157,7 +157,7 @@ export = { const vpc = new ec2.Vpc(stack, 'Vpc'); new DatabaseCluster(stack, 'Cluster', { - masterUser: { username: 'admin' }, + credentials: { username: 'admin' }, engine: DatabaseClusterEngine.AURORA, instanceProps: { instanceType: ec2.InstanceType.of(ec2.InstanceClass.M5, ec2.InstanceSize.LARGE), @@ -182,7 +182,7 @@ export = { // WHEN new DatabaseCluster(stack, 'Database', { engine: DatabaseClusterEngine.AURORA_MYSQL, - masterUser: { + credentials: { username: 'admin', }, instanceProps: { @@ -239,7 +239,7 @@ export = { // WHEN new DatabaseCluster(stack, 'Database', { engine: DatabaseClusterEngine.AURORA_MYSQL, - masterUser: { + credentials: { username: 'admin', }, instanceProps: { @@ -276,7 +276,7 @@ export = { // WHEN new DatabaseCluster(stack, 'Database', { engine: DatabaseClusterEngine.AURORA, - masterUser: { + credentials: { username: 'admin', }, instanceProps: { @@ -305,7 +305,7 @@ export = { // WHEN new DatabaseCluster(stack, 'Database', { engine: DatabaseClusterEngine.AURORA, - masterUser: { + credentials: { username: 'admin', }, instanceProps: { @@ -333,7 +333,7 @@ export = { // WHEN new DatabaseCluster(stack, 'Database', { engine: DatabaseClusterEngine.AURORA, - masterUser: { + credentials: { username: 'admin', }, instanceProps: { @@ -358,7 +358,7 @@ export = { test.throws(() => { new DatabaseCluster(stack, 'Database', { engine: DatabaseClusterEngine.AURORA, - masterUser: { + credentials: { username: 'admin', }, instanceProps: { @@ -383,7 +383,7 @@ export = { engine: DatabaseClusterEngine.auroraMysql({ version: AuroraMysqlEngineVersion.VER_2_04_4, }), - masterUser: { + credentials: { username: 'admin', }, instanceProps: { @@ -411,7 +411,7 @@ export = { engine: DatabaseClusterEngine.auroraPostgres({ version: AuroraPostgresEngineVersion.VER_10_7, }), - masterUser: { + credentials: { username: 'admin', }, instanceProps: { @@ -437,7 +437,7 @@ export = { // WHEN const cluster = new DatabaseCluster(stack, 'Database', { engine: DatabaseClusterEngine.AURORA, - masterUser: { + credentials: { username: 'admin', }, instanceProps: { @@ -538,7 +538,7 @@ export = { const cluster = new DatabaseCluster(stack, 'Database', { engine: DatabaseClusterEngine.auroraMysql({ version: AuroraMysqlEngineVersion.VER_5_7_12 }), - masterUser: { + credentials: { username: 'admin', password: cdk.SecretValue.plainText('tooshort'), }, @@ -569,7 +569,7 @@ export = { new DatabaseCluster(stack, 'Database', { engine: DatabaseClusterEngine.AURORA, instances: 1, - masterUser: { + credentials: { username: 'admin', }, instanceProps: { @@ -635,7 +635,7 @@ export = { new DatabaseCluster(stack, 'Database', { engine: DatabaseClusterEngine.AURORA, instances: 1, - masterUser: { + credentials: { username: 'admin', }, instanceProps: { @@ -665,7 +665,7 @@ export = { // WHEN const cluster = new DatabaseCluster(stack, 'Database', { engine: DatabaseClusterEngine.AURORA_MYSQL, - masterUser: { + credentials: { username: 'admin', password: cdk.SecretValue.plainText('tooshort'), }, @@ -687,7 +687,7 @@ export = { const vpc = new ec2.Vpc(stack, 'VPC'); const cluster = new DatabaseCluster(stack, 'Database', { engine: DatabaseClusterEngine.AURORA_MYSQL, - masterUser: { username: 'admin' }, + credentials: { username: 'admin' }, instanceProps: { instanceType: ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE2, ec2.InstanceSize.SMALL), vpc, @@ -716,7 +716,7 @@ export = { new DatabaseCluster(stack, 'Database', { engine: DatabaseClusterEngine.AURORA, instances: 1, - masterUser: { + credentials: { username: 'admin', }, instanceProps: { @@ -764,7 +764,7 @@ export = { new DatabaseCluster(stack, 'Database', { engine: DatabaseClusterEngine.AURORA, instances: 1, - masterUser: { + credentials: { username: 'admin', }, instanceProps: { @@ -852,7 +852,7 @@ export = { version: AuroraPostgresEngineVersion.VER_10_12, }), instances: 1, - masterUser: { + credentials: { username: 'admin', }, instanceProps: { @@ -892,7 +892,7 @@ export = { version: AuroraPostgresEngineVersion.VER_10_4, }), instances: 1, - masterUser: { + credentials: { username: 'admin', }, instanceProps: { @@ -909,7 +909,7 @@ export = { version: AuroraPostgresEngineVersion.VER_10_4, }), instances: 1, - masterUser: { + credentials: { username: 'admin', }, instanceProps: { @@ -936,7 +936,7 @@ export = { version: AuroraPostgresEngineVersion.VER_10_12, }), instances: 1, - masterUser: { + credentials: { username: 'admin', }, instanceProps: { @@ -975,7 +975,7 @@ export = { new DatabaseCluster(stack, 'Database', { engine: DatabaseClusterEngine.AURORA, instances: 1, - masterUser: { + credentials: { username: 'admin', }, instanceProps: { @@ -1023,7 +1023,7 @@ export = { new DatabaseCluster(stack, 'Database', { engine: DatabaseClusterEngine.AURORA, instances: 1, - masterUser: { + credentials: { username: 'admin', }, instanceProps: { @@ -1113,7 +1113,7 @@ export = { new DatabaseCluster(stack, 'Database', { engine: DatabaseClusterEngine.AURORA, instances: 1, - masterUser: { + credentials: { username: 'admin', }, instanceProps: { @@ -1184,7 +1184,7 @@ export = { new DatabaseCluster(stack, 'Database', { engine: DatabaseClusterEngine.AURORA, instances: 1, - masterUser: { + credentials: { username: 'admin', }, instanceProps: { @@ -1251,7 +1251,7 @@ export = { version: AuroraPostgresEngineVersion.VER_11_6, }), instances: 1, - masterUser: { + credentials: { username: 'admin', }, instanceProps: { @@ -1291,7 +1291,7 @@ export = { new DatabaseCluster(stack, 'Database', { engine: DatabaseClusterEngine.AURORA_POSTGRESQL, instances: 1, - masterUser: { + credentials: { username: 'admin', }, instanceProps: { @@ -1339,7 +1339,7 @@ export = { new DatabaseCluster(stack, 'Database', { engine: DatabaseClusterEngine.AURORA_MYSQL, instances: 1, - masterUser: { + credentials: { username: 'admin', }, instanceProps: { @@ -1372,7 +1372,7 @@ export = { test.throws(() => new DatabaseCluster(stack, 'Database', { engine: DatabaseClusterEngine.AURORA, instances: 1, - masterUser: { + credentials: { username: 'admin', }, instanceProps: { @@ -1400,7 +1400,7 @@ export = { test.throws(() => new DatabaseCluster(stack, 'Database', { engine: DatabaseClusterEngine.AURORA, instances: 1, - masterUser: { + credentials: { username: 'admin', }, instanceProps: { @@ -1422,7 +1422,7 @@ export = { // WHEN new DatabaseCluster(stack, 'Database', { engine: DatabaseClusterEngine.AURORA, - masterUser: { + credentials: { username: 'admin', password: cdk.SecretValue.plainText('tooshort'), }, @@ -1449,7 +1449,7 @@ export = { // WHEN new DatabaseCluster(stack, 'Database', { engine: DatabaseClusterEngine.AURORA, - masterUser: { + credentials: { username: 'admin', password: cdk.SecretValue.plainText('tooshort'), }, @@ -1494,7 +1494,7 @@ export = { test.throws(() => { new DatabaseCluster(stack, 'Database', { engine: DatabaseClusterEngine.AURORA, - masterUser: { + credentials: { username: 'admin', password: cdk.SecretValue.plainText('tooshort'), }, @@ -1517,7 +1517,7 @@ export = { // WHEN new DatabaseCluster(stack, 'Database', { engine: DatabaseClusterEngine.AURORA, - masterUser: { + credentials: { username: 'admin', password: cdk.SecretValue.plainText('tooshort'), }, @@ -1545,7 +1545,7 @@ export = { new DatabaseCluster(stack, 'Database', { engine: DatabaseClusterEngine.AURORA, instances: 1, - masterUser: { + credentials: { username: 'admin', }, instanceProps: { @@ -1604,7 +1604,7 @@ export = { // WHEN new DatabaseCluster(stack, 'Database', { engine: DatabaseClusterEngine.aurora({ version: AuroraEngineVersion.VER_1_22_2 }), - masterUser: { + credentials: { username: 'admin', }, instanceProps: { @@ -1630,7 +1630,7 @@ export = { // WHEN const cluster = new DatabaseCluster(stack, 'Database', { engine: DatabaseClusterEngine.aurora({ version: AuroraEngineVersion.VER_1_22_2 }), - masterUser: { + credentials: { username: 'admin', }, instanceProps: { diff --git a/packages/@aws-cdk/aws-rds/test/test.instance.ts b/packages/@aws-cdk/aws-rds/test/test.instance.ts index 2cd024ead7aab..6dad43e8ec7f3 100644 --- a/packages/@aws-cdk/aws-rds/test/test.instance.ts +++ b/packages/@aws-cdk/aws-rds/test/test.instance.ts @@ -28,7 +28,7 @@ export = { instanceType: ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE2, ec2.InstanceSize.MEDIUM), multiAz: true, storageType: rds.StorageType.IO1, - masterUsername: 'syscdk', + credentials: rds.Credentials.fromUsername('syscdk'), vpc, databaseName: 'ORCL', storageEncrypted: true, @@ -220,8 +220,6 @@ export = { new rds.DatabaseInstance(stack, 'Database', { engine: rds.DatabaseInstanceEngine.SQL_SERVER_EE, instanceType: ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE2, ec2.InstanceSize.SMALL), - masterUsername: 'syscdk', - masterUserPassword: cdk.SecretValue.plainText('tooshort'), vpc, optionGroup, parameterGroup, @@ -244,7 +242,7 @@ export = { engine: rds.DatabaseInstanceEngine.mysql({ version: rds.MysqlEngineVersion.VER_8_0_19, }), - masterUsername: 'syscdk', + credentials: rds.Credentials.fromUsername('syscdk'), vpc, vpcPlacement: { subnetType: ec2.SubnetType.PRIVATE, @@ -272,67 +270,106 @@ export = { test.done(); }, - 'create an instance from snapshot'(test: Test) { - // WHEN - new rds.DatabaseInstanceFromSnapshot(stack, 'Instance', { - snapshotIdentifier: 'my-snapshot', - engine: rds.DatabaseInstanceEngine.POSTGRES, - instanceType: ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE2, ec2.InstanceSize.LARGE), - vpc, - }); + 'DatabaseInstanceFromSnapshot': { + 'create an instance from snapshot'(test: Test) { + new rds.DatabaseInstanceFromSnapshot(stack, 'Instance', { + snapshotIdentifier: 'my-snapshot', + engine: rds.DatabaseInstanceEngine.postgres({ version: rds.PostgresEngineVersion.VER_12_3 }), + instanceType: ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE2, ec2.InstanceSize.LARGE), + vpc, + }); - expect(stack).to(haveResource('AWS::RDS::DBInstance', { - DBSnapshotIdentifier: 'my-snapshot', - })); + expect(stack).to(haveResource('AWS::RDS::DBInstance', { + DBSnapshotIdentifier: 'my-snapshot', + })); - test.done(); - }, + test.done(); + }, - 'throws when trying to generate a new password from snapshot without username'(test: Test) { - // THEN - test.throws(() => new rds.DatabaseInstanceFromSnapshot(stack, 'Instance', { - snapshotIdentifier: 'my-snapshot', - engine: rds.DatabaseInstanceEngine.MYSQL, - instanceType: ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE2, ec2.InstanceSize.LARGE), - vpc, - generateMasterUserPassword: true, - }), '`masterUsername` must be specified when `generateMasterUserPassword` is set to true.'); + 'can generate a new snapshot password'(test: Test) { + new rds.DatabaseInstanceFromSnapshot(stack, 'Instance', { + snapshotIdentifier: 'my-snapshot', + engine: rds.DatabaseInstanceEngine.mysql({ version: rds.MysqlEngineVersion.VER_8_0_19 }), + vpc, + credentials: rds.SnapshotCredentials.fromGeneratedPassword('admin'), + }); - test.done(); - }, + expect(stack).to(haveResourceLike('AWS::RDS::DBInstance', { + MasterUsername: ABSENT, + MasterUserPassword: { + 'Fn::Join': ['', ['{{resolve:secretsmanager:', { Ref: 'InstanceSecret478E0A47' }, ':SecretString:password::}}']], + }, + })); + expect(stack).to(haveResource('AWS::SecretsManager::Secret', { + Description: { + 'Fn::Join': ['', ['Generated by the CDK for stack: ', { Ref: 'AWS::StackName' }]], + }, + GenerateSecretString: { + ExcludeCharacters: '\"@/\\', + GenerateStringKey: 'password', + PasswordLength: 30, + SecretStringTemplate: '{"username":"admin"}', + }, + })); - 'throws when specifying user name without asking to generate a new password'(test: Test) { - // THEN - test.throws(() => new rds.DatabaseInstanceFromSnapshot(stack, 'Instance', { - snapshotIdentifier: 'my-snapshot', - engine: rds.DatabaseInstanceEngine.MYSQL, - instanceType: ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE2, ec2.InstanceSize.LARGE), - vpc, - masterUsername: 'superadmin', - }), 'Cannot specify `masterUsername` when `generateMasterUserPassword` is set to false.'); + test.done(); + }, - test.done(); - }, + 'throws if generating a new password without a username'(test: Test) { + test.throws(() => new rds.DatabaseInstanceFromSnapshot(stack, 'Instance', { + snapshotIdentifier: 'my-snapshot', + engine: rds.DatabaseInstanceEngine.mysql({ version: rds.MysqlEngineVersion.VER_8_0_19 }), + vpc, + credentials: { generatePassword: true }, + }), /`credentials` `username` must be specified when `generatePassword` is set to true/); - 'throws when password and generate password ar both specified'(test: Test) { - // THEN - test.throws(() => new rds.DatabaseInstanceFromSnapshot(stack, 'Instance', { - snapshotIdentifier: 'my-snapshot', - engine: rds.DatabaseInstanceEngine.MYSQL, - instanceType: ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE2, ec2.InstanceSize.LARGE), - vpc, - masterUserPassword: cdk.SecretValue.plainText('supersecret'), - generateMasterUserPassword: true, - }), 'Cannot specify `masterUserPassword` when `generateMasterUserPassword` is set to true.'); + test.done(); + }, - test.done(); + 'can set a new snapshot password from an existing SecretValue'(test: Test) { + new rds.DatabaseInstanceFromSnapshot(stack, 'Instance', { + snapshotIdentifier: 'my-snapshot', + engine: rds.DatabaseInstanceEngine.mysql({ version: rds.MysqlEngineVersion.VER_8_0_19 }), + vpc, + credentials: rds.SnapshotCredentials.fromPassword(cdk.SecretValue.plainText('mysecretpassword')), + }); + + // TODO - Expect this to be broken + expect(stack).to(haveResourceLike('AWS::RDS::DBInstance', { + MasterUsername: ABSENT, + MasterUserPassword: 'mysecretpassword', + })); + + test.done(); + }, + + 'can set a new snapshot password from an existing Secret'(test: Test) { + const secret = new rds.DatabaseSecret(stack, 'DBSecret', { + username: 'admin', + encryptionKey: new kms.Key(stack, 'PasswordKey'), + }); + new rds.DatabaseInstanceFromSnapshot(stack, 'Instance', { + snapshotIdentifier: 'my-snapshot', + engine: rds.DatabaseInstanceEngine.mysql({ version: rds.MysqlEngineVersion.VER_8_0_19 }), + vpc, + credentials: rds.SnapshotCredentials.fromSecret(secret), + }); + + expect(stack).to(haveResourceLike('AWS::RDS::DBInstance', { + MasterUsername: ABSENT, + MasterUserPassword: { + 'Fn::Join': ['', ['{{resolve:secretsmanager:', { Ref: 'DBSecretD58955BC' }, ':SecretString:password::}}']], + }, + })); + + test.done(); + }, }, 'create a read replica in the same region - with the subnet group name'(test: Test) { const sourceInstance = new rds.DatabaseInstance(stack, 'Instance', { engine: rds.DatabaseInstanceEngine.MYSQL, instanceType: ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE2, ec2.InstanceSize.SMALL), - masterUsername: 'admin', vpc, }); @@ -368,8 +405,6 @@ export = { 'on event'(test: Test) { const instance = new rds.DatabaseInstance(stack, 'Instance', { engine: rds.DatabaseInstanceEngine.MYSQL, - instanceType: ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE2, ec2.InstanceSize.SMALL), - masterUsername: 'admin', vpc, }); const fn = new lambda.Function(stack, 'Function', { @@ -432,8 +467,6 @@ export = { 'on event without target'(test: Test) { const instance = new rds.DatabaseInstance(stack, 'Instance', { engine: rds.DatabaseInstanceEngine.MYSQL, - instanceType: ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE2, ec2.InstanceSize.SMALL), - masterUsername: 'admin', vpc, }); @@ -481,8 +514,6 @@ export = { // WHEN const instance = new rds.DatabaseInstance(stack, 'Instance', { engine: rds.DatabaseInstanceEngine.MYSQL, - instanceType: ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE2, ec2.InstanceSize.SMALL), - masterUsername: 'admin', vpc, }); @@ -502,8 +533,6 @@ export = { // WHEN const instance = new rds.DatabaseInstance(stack, 'Instance', { engine: rds.DatabaseInstanceEngine.MYSQL, - instanceType: ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE2, ec2.InstanceSize.SMALL), - masterUsername: 'admin', vpc, }); @@ -529,8 +558,6 @@ export = { // WHEN new rds.DatabaseInstance(stack, 'Instance', { engine: rds.DatabaseInstanceEngine.MYSQL, - instanceType: ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE2, ec2.InstanceSize.SMALL), - masterUsername: 'admin', vpc, backupRetention: cdk.Duration.seconds(0), }); @@ -575,8 +602,6 @@ export = { // WHEN new rds.DatabaseInstance(stack, 'Instance', { engine: rds.DatabaseInstanceEngine.MYSQL, - instanceType: ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE2, ec2.InstanceSize.SMALL), - masterUsername: 'admin', vpc, monitoringInterval: cdk.Duration.minutes(1), monitoringRole, @@ -601,8 +626,6 @@ export = { // WHEN const instance = new rds.DatabaseInstance(stack, 'Instance', { engine: rds.DatabaseInstanceEngine.MYSQL, - instanceType: ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE2, ec2.InstanceSize.SMALL), - masterUsername: 'admin', vpc, securityGroups: [securityGroup], }); @@ -635,9 +658,7 @@ export = { 'throws when trying to add rotation to an instance without secret'(test: Test) { const instance = new rds.DatabaseInstance(stack, 'Database', { engine: rds.DatabaseInstanceEngine.SQL_SERVER_EE, - instanceType: ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE2, ec2.InstanceSize.SMALL), - masterUsername: 'syscdk', - masterUserPassword: cdk.SecretValue.plainText('tooshort'), + credentials: rds.Credentials.fromUsername('syscdk', { password: cdk.SecretValue.plainText('tooshort') }), vpc, }); @@ -651,7 +672,7 @@ export = { const instance = new rds.DatabaseInstance(stack, 'Database', { engine: rds.DatabaseInstanceEngine.SQL_SERVER_EE, instanceType: ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE2, ec2.InstanceSize.SMALL), - masterUsername: 'syscdk', + credentials: rds.Credentials.fromUsername('syscdk'), vpc, }); @@ -674,8 +695,6 @@ export = { tzSupportedEngines.forEach((engine) => { test.ok(new rds.DatabaseInstance(stack, `${engine.engineType}-db`, { engine, - instanceType: ec2.InstanceType.of(ec2.InstanceClass.C5, ec2.InstanceSize.SMALL), - masterUsername: 'master', timezone: 'Europe/Zurich', vpc, })); @@ -684,8 +703,6 @@ export = { tzUnsupportedEngines.forEach((engine) => { test.throws(() => new rds.DatabaseInstance(stack, `${engine.engineType}-db`, { engine, - instanceType: ec2.InstanceType.of(ec2.InstanceClass.C5, ec2.InstanceSize.SMALL), - masterUsername: 'master', timezone: 'Europe/Zurich', vpc, }), /timezone property can not be configured for/); @@ -716,8 +733,6 @@ export = { // WHEN new rds.DatabaseInstance(stack, 'Instance', { engine: rds.DatabaseInstanceEngine.MYSQL, - instanceType: ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE2, ec2.InstanceSize.SMALL), - masterUsername: 'admin', vpc, backupRetention: cdk.Duration.seconds(0), maxAllocatedStorage: 250, @@ -735,7 +750,6 @@ export = { 'iam authentication - off by default'(test: Test) { new rds.DatabaseInstance(stack, 'Instance', { engine: rds.DatabaseInstanceEngine.mysql({ version: rds.MysqlEngineVersion.VER_8_0_19 }), - masterUsername: 'admin', vpc, }); @@ -749,7 +763,6 @@ export = { 'createGrant - creates IAM policy and enables IAM auth'(test: Test) { const instance = new rds.DatabaseInstance(stack, 'Instance', { engine: rds.DatabaseInstanceEngine.mysql({ version: rds.MysqlEngineVersion.VER_8_0_19 }), - masterUsername: 'admin', vpc, }); const role = new Role(stack, 'DBRole', { @@ -779,7 +792,6 @@ export = { 'createGrant - throws if IAM auth disabled'(test: Test) { const instance = new rds.DatabaseInstance(stack, 'Instance', { engine: rds.DatabaseInstanceEngine.mysql({ version: rds.MysqlEngineVersion.VER_8_0_19 }), - masterUsername: 'admin', vpc, iamAuthentication: false, }); @@ -799,7 +811,6 @@ export = { new rds.DatabaseInstance(stack, 'Instance', { engine: rds.DatabaseInstanceEngine.sqlServerWeb({ version: rds.SqlServerEngineVersion.VER_14_00_3192_2_V1 }), vpc, - masterUsername: 'admin', domain: domain, }); @@ -819,7 +830,6 @@ export = { new rds.DatabaseInstance(stack, 'Instance', { engine: rds.DatabaseInstanceEngine.sqlServerWeb({ version: rds.SqlServerEngineVersion.VER_14_00_3192_2_V1 }), vpc, - masterUsername: 'admin', domain: domain, domainRole: role, }); @@ -840,7 +850,6 @@ export = { new rds.DatabaseInstance(stack, 'Instance', { engine: rds.DatabaseInstanceEngine.sqlServerWeb({ version: rds.SqlServerEngineVersion.VER_14_00_3192_2_V1 }), vpc, - masterUsername: 'admin', domain: domain, }); @@ -892,8 +901,6 @@ export = { domainSupportedEngines.forEach((engine) => { test.ok(new rds.DatabaseInstance(stack, `${engine.engineType}-db`, { engine, - instanceType: ec2.InstanceType.of(ec2.InstanceClass.C5, ec2.InstanceSize.SMALL), - masterUsername: 'master', domain: 'd-90670a8d36', vpc, })); @@ -904,8 +911,6 @@ export = { test.throws(() => new rds.DatabaseInstance(stack, `${engine.engineType}-db`, { engine, - instanceType: ec2.InstanceType.of(ec2.InstanceClass.C5, ec2.InstanceSize.SMALL), - masterUsername: 'master', domain: 'd-90670a8d36', vpc, }), expectedError); @@ -918,7 +923,6 @@ export = { 'instance with all performance insights properties'(test: Test) { new rds.DatabaseInstance(stack, 'Instance', { engine: rds.DatabaseInstanceEngine.mysql({ version: rds.MysqlEngineVersion.VER_8_0_19 }), - masterUsername: 'admin', vpc, enablePerformanceInsights: true, performanceInsightRetention: rds.PerformanceInsightRetention.LONG_TERM, @@ -937,7 +941,6 @@ export = { 'setting performance insights fields enables performance insights'(test: Test) { new rds.DatabaseInstance(stack, 'Instance', { engine: rds.DatabaseInstanceEngine.mysql({ version: rds.MysqlEngineVersion.VER_8_0_19 }), - masterUsername: 'admin', vpc, performanceInsightRetention: rds.PerformanceInsightRetention.LONG_TERM, }); @@ -954,7 +957,6 @@ export = { test.throws(() => { new rds.DatabaseInstance(stack, 'Instance', { engine: rds.DatabaseInstanceEngine.mysql({ version: rds.MysqlEngineVersion.VER_8_0_19 }), - masterUsername: 'admin', vpc, enablePerformanceInsights: false, performanceInsightRetention: rds.PerformanceInsightRetention.DEFAULT, @@ -968,7 +970,6 @@ export = { 'reuse an existing subnet group'(test: Test) { new rds.DatabaseInstance(stack, 'Database', { engine: rds.DatabaseInstanceEngine.postgres({ version: rds.PostgresEngineVersion.VER_12_3 }), - masterUsername: 'admin', vpc, subnetGroup: rds.SubnetGroup.fromSubnetGroupName(stack, 'SubnetGroup', 'my-subnet-group'), }); @@ -984,7 +985,6 @@ export = { 'defaultChild returns the DB Instance'(test: Test) { const instance = new rds.DatabaseInstance(stack, 'Database', { engine: rds.DatabaseInstanceEngine.postgres({ version: rds.PostgresEngineVersion.VER_12_3 }), - masterUsername: 'admin', vpc, }); @@ -997,7 +997,6 @@ export = { 'instance with s3 import and export buckets'(test: Test) { new rds.DatabaseInstance(stack, 'DB', { engine: rds.DatabaseInstanceEngine.sqlServerSe({ version: rds.SqlServerEngineVersion.VER_14_00_3192_2_V1 }), - masterUsername: 'admin', vpc, s3ImportBuckets: [new s3.Bucket(stack, 'S3Import')], s3ExportBuckets: [new s3.Bucket(stack, 'S3Export')], @@ -1058,7 +1057,6 @@ export = { test.throws(() => { new rds.DatabaseInstance(stack, 'DBWithImportBucket', { engine: rds.DatabaseInstanceEngine.mysql({ version: rds.MysqlEngineVersion.VER_8_0_19 }), - masterUsername: 'admin', vpc, s3ImportBuckets: [new s3.Bucket(stack, 'S3Import')], }); @@ -1066,7 +1064,6 @@ export = { test.throws(() => { new rds.DatabaseInstance(stack, 'DBWithImportRole', { engine: rds.DatabaseInstanceEngine.mysql({ version: rds.MysqlEngineVersion.VER_8_0_19 }), - masterUsername: 'admin', vpc, s3ImportRole, }); @@ -1083,7 +1080,6 @@ export = { test.throws(() => { new rds.DatabaseInstance(stack, 'DBWithExportBucket', { engine: rds.DatabaseInstanceEngine.mysql({ version: rds.MysqlEngineVersion.VER_8_0_19 }), - masterUsername: 'admin', vpc, s3ExportBuckets: [new s3.Bucket(stack, 'S3Export')], }); @@ -1091,7 +1087,6 @@ export = { test.throws(() => { new rds.DatabaseInstance(stack, 'DBWithExportRole', { engine: rds.DatabaseInstanceEngine.mysql({ version: rds.MysqlEngineVersion.VER_8_0_19 }), - masterUsername: 'admin', vpc, s3ExportRole: s3ExportRole, }); @@ -1111,7 +1106,6 @@ export = { test.throws(() => { new rds.DatabaseInstance(stack, 'DBWithExportBucket', { engine: rds.DatabaseInstanceEngine.sqlServerEe({ version: rds.SqlServerEngineVersion.VER_14_00_3192_2_V1 }), - masterUsername: 'admin', vpc, s3ImportRole, s3ExportRole, diff --git a/packages/@aws-cdk/aws-rds/test/test.proxy.ts b/packages/@aws-cdk/aws-rds/test/test.proxy.ts index 6e4de63c7aeff..7fa03684fa53b 100644 --- a/packages/@aws-cdk/aws-rds/test/test.proxy.ts +++ b/packages/@aws-cdk/aws-rds/test/test.proxy.ts @@ -12,7 +12,6 @@ export = { const instance = new rds.DatabaseInstance(stack, 'Instance', { engine: rds.DatabaseInstanceEngine.MYSQL, instanceType: ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE2, ec2.InstanceSize.SMALL), - masterUsername: 'admin', vpc, }); @@ -82,9 +81,6 @@ export = { engine: rds.DatabaseClusterEngine.auroraPostgres({ version: rds.AuroraPostgresEngineVersion.VER_10_7, }), - masterUser: { - username: 'admin', - }, instanceProps: { instanceType: ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE2, ec2.InstanceSize.SMALL), vpc, @@ -157,9 +153,6 @@ export = { engine: rds.DatabaseClusterEngine.auroraPostgres({ version: rds.AuroraPostgresEngineVersion.VER_10_7, }), - masterUser: { - username: 'admin', - }, instanceProps: { instanceType: ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE2, ec2.InstanceSize.SMALL), vpc, @@ -188,7 +181,6 @@ export = { const vpc = new ec2.Vpc(stack, 'VPC'); const cluster = new rds.DatabaseCluster(stack, 'Database', { engine: rds.DatabaseClusterEngine.auroraPostgres({ version: rds.AuroraPostgresEngineVersion.VER_10_7 }), - masterUser: { username: 'admin' }, instanceProps: { instanceType: ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE2, ec2.InstanceSize.SMALL), vpc, From c5021147e5d6f2e2a91fe50daf3aacd149b0f895 Mon Sep 17 00:00:00 2001 From: Adam Ruka Date: Wed, 23 Sep 2020 12:57:53 -0700 Subject: [PATCH 13/29] fix(rds): allow creating Proxies for imported resources (#10488) The current ProxyTarget relied on the underlying L1s to get the engine type for a given Cluster/Instance. Change IDatabaseCluster and IInstanceEngine to add an (optional) `engine` property that is used instead. Allow the user to specify the engine when importing a Cluster or Instance. Also move the logic of determining the engine family into `IEngine`. Fixes #9195 ---- *By submitting this pull request, I confirm that my contribution is made under the terms of the Apache-2.0 license* --- .../@aws-cdk/aws-rds/lib/cluster-engine.ts | 2 + packages/@aws-cdk/aws-rds/lib/cluster-ref.ts | 14 + packages/@aws-cdk/aws-rds/lib/cluster.ts | 9 +- packages/@aws-cdk/aws-rds/lib/engine.ts | 11 + .../@aws-cdk/aws-rds/lib/instance-engine.ts | 5 + packages/@aws-cdk/aws-rds/lib/instance.ts | 17 ++ packages/@aws-cdk/aws-rds/lib/private/util.ts | 4 +- packages/@aws-cdk/aws-rds/lib/proxy.ts | 42 ++- packages/@aws-cdk/aws-rds/test/test.proxy.ts | 261 ++++++++++-------- 9 files changed, 221 insertions(+), 144 deletions(-) diff --git a/packages/@aws-cdk/aws-rds/lib/cluster-engine.ts b/packages/@aws-cdk/aws-rds/lib/cluster-engine.ts index a25200ac22205..9fb5bf08ccf3a 100644 --- a/packages/@aws-cdk/aws-rds/lib/cluster-engine.ts +++ b/packages/@aws-cdk/aws-rds/lib/cluster-engine.ts @@ -154,6 +154,7 @@ interface MysqlClusterEngineBaseProps { } abstract class MySqlClusterEngineBase extends ClusterEngineBase { + public readonly engineFamily = 'MYSQL'; public readonly supportedLogTypes: string[] = ['error', 'general', 'slowquery', 'audit']; constructor(props: MysqlClusterEngineBaseProps) { @@ -493,6 +494,7 @@ class AuroraPostgresClusterEngine extends ClusterEngineBase { */ private static readonly S3_EXPORT_FEATURE_NAME = 's3Export'; + public readonly engineFamily = 'POSTGRESQL'; public readonly supportedLogTypes: string[] = ['postgresql']; constructor(version?: AuroraPostgresEngineVersion) { diff --git a/packages/@aws-cdk/aws-rds/lib/cluster-ref.ts b/packages/@aws-cdk/aws-rds/lib/cluster-ref.ts index a464e2a0fd5c0..de1f89bd3dafa 100644 --- a/packages/@aws-cdk/aws-rds/lib/cluster-ref.ts +++ b/packages/@aws-cdk/aws-rds/lib/cluster-ref.ts @@ -1,6 +1,7 @@ import * as ec2 from '@aws-cdk/aws-ec2'; import * as secretsmanager from '@aws-cdk/aws-secretsmanager'; import { IResource } from '@aws-cdk/core'; +import { IClusterEngine } from './cluster-engine'; import { Endpoint } from './endpoint'; import { DatabaseProxy, DatabaseProxyOptions } from './proxy'; @@ -35,6 +36,12 @@ export interface IDatabaseCluster extends IResource, ec2.IConnectable, secretsma */ readonly instanceEndpoints: Endpoint[]; + /** + * The engine of this Cluster. + * May be not known for imported Clusters if it wasn't provided explicitly. + */ + readonly engine?: IClusterEngine; + /** * Add a new db proxy to this cluster. */ @@ -92,4 +99,11 @@ export interface DatabaseClusterAttributes { * @default - no instance endpoints */ readonly instanceEndpointAddresses?: string[]; + + /** + * The engine of the existing Cluster. + * + * @default - the imported Cluster's engine is unknown + */ + readonly engine?: IClusterEngine; } diff --git a/packages/@aws-cdk/aws-rds/lib/cluster.ts b/packages/@aws-cdk/aws-rds/lib/cluster.ts index a4d01868ba5fb..3ba13451e8731 100644 --- a/packages/@aws-cdk/aws-rds/lib/cluster.ts +++ b/packages/@aws-cdk/aws-rds/lib/cluster.ts @@ -281,7 +281,11 @@ export abstract class DatabaseClusterBase extends Resource implements IDatabaseC * Abstract base for ``DatabaseCluster`` and ``DatabaseClusterFromSnapshot`` */ abstract class DatabaseClusterNew extends DatabaseClusterBase { - + /** + * The engine for this Cluster. + * Never undefined. + */ + public readonly engine?: IClusterEngine; public readonly instanceIdentifiers: string[] = []; public readonly instanceEndpoints: Endpoint[] = []; @@ -331,6 +335,7 @@ abstract class DatabaseClusterNew extends DatabaseClusterBase { const clusterParameterGroup = props.parameterGroup ?? clusterEngineBindConfig.parameterGroup; const clusterParameterGroupConfig = clusterParameterGroup?.bindToCluster({}); + this.engine = props.engine; this.newCfnProps = { // Basic @@ -359,6 +364,7 @@ abstract class DatabaseClusterNew extends DatabaseClusterBase { class ImportedDatabaseCluster extends DatabaseClusterBase implements IDatabaseCluster { public readonly clusterIdentifier: string; public readonly connections: ec2.Connections; + public readonly engine?: IClusterEngine; private readonly _clusterEndpoint?: Endpoint; private readonly _clusterReadEndpoint?: Endpoint; @@ -375,6 +381,7 @@ class ImportedDatabaseCluster extends DatabaseClusterBase implements IDatabaseCl securityGroups: attrs.securityGroups, defaultPort, }); + this.engine = attrs.engine; this._clusterEndpoint = (attrs.clusterEndpointAddress && attrs.port) ? new Endpoint(attrs.clusterEndpointAddress, attrs.port) : undefined; this._clusterReadEndpoint = (attrs.readerEndpointAddress && attrs.port) ? new Endpoint(attrs.readerEndpointAddress, attrs.port) : undefined; diff --git a/packages/@aws-cdk/aws-rds/lib/engine.ts b/packages/@aws-cdk/aws-rds/lib/engine.ts index b1ccef4084c87..2feced9927ca2 100644 --- a/packages/@aws-cdk/aws-rds/lib/engine.ts +++ b/packages/@aws-cdk/aws-rds/lib/engine.ts @@ -28,4 +28,15 @@ export interface IEngine { * (which means the major version of the engine is also not known) */ readonly parameterGroupFamily?: string; + + /** + * The family this engine belongs to, + * like "MYSQL", or "POSTGRESQL". + * This property is used when creating a Database Proxy. + * Most engines don't belong to any family + * (and because of that, you can't create Database Proxies for their Clusters or Instances). + * + * @default - the engine doesn't belong to any family + */ + readonly engineFamily?: string; } diff --git a/packages/@aws-cdk/aws-rds/lib/instance-engine.ts b/packages/@aws-cdk/aws-rds/lib/instance-engine.ts index 3b2310212dbf8..25370706664c7 100644 --- a/packages/@aws-cdk/aws-rds/lib/instance-engine.ts +++ b/packages/@aws-cdk/aws-rds/lib/instance-engine.ts @@ -109,6 +109,7 @@ interface InstanceEngineBaseProps { readonly multiUserRotationApplication: secretsmanager.SecretRotationApplication; readonly version?: EngineVersion; readonly parameterGroupFamily?: string; + readonly engineFamily?: string; readonly features?: InstanceEngineFeatures; } @@ -118,6 +119,7 @@ abstract class InstanceEngineBase implements IInstanceEngine { public readonly parameterGroupFamily?: string; public readonly singleUserRotationApplication: secretsmanager.SecretRotationApplication; public readonly multiUserRotationApplication: secretsmanager.SecretRotationApplication; + public readonly engineFamily?: string; private readonly features?: InstanceEngineFeatures; @@ -129,6 +131,7 @@ abstract class InstanceEngineBase implements IInstanceEngine { this.engineVersion = props.version; this.parameterGroupFamily = props.parameterGroupFamily ?? (this.engineVersion ? `${this.engineType}${this.engineVersion.majorVersion}` : undefined); + this.engineFamily = props.engineFamily; } public bindToInstance(_scope: core.Construct, options: InstanceEngineBindOptions): InstanceEngineConfig { @@ -391,6 +394,7 @@ class MySqlInstanceEngine extends InstanceEngineBase { majorVersion: version.mysqlMajorVersion, } : undefined, + engineFamily: 'MYSQL', }); } } @@ -586,6 +590,7 @@ class PostgresInstanceEngine extends InstanceEngineBase { } : undefined, features: version ? version?._features : { s3Import: 's3Import' }, + engineFamily: 'POSTGRESQL', }); } } diff --git a/packages/@aws-cdk/aws-rds/lib/instance.ts b/packages/@aws-cdk/aws-rds/lib/instance.ts index fa08049df2f97..bfc5ac47f1b24 100644 --- a/packages/@aws-cdk/aws-rds/lib/instance.ts +++ b/packages/@aws-cdk/aws-rds/lib/instance.ts @@ -50,6 +50,13 @@ export interface IDatabaseInstance extends IResource, ec2.IConnectable, secretsm */ readonly instanceEndpoint: Endpoint; + /** + * The engine of this database Instance. + * May be not known for imported Instances if it wasn't provided explicitly, + * or for read replicas. + */ + readonly engine?: IInstanceEngine; + /** * Add a new db proxy to this instance. */ @@ -90,6 +97,13 @@ export interface DatabaseInstanceAttributes { * The security groups of the instance. */ readonly securityGroups: ec2.ISecurityGroup[]; + + /** + * The engine of the existing database Instance. + * + * @default - the imported Instance's engine is unknown + */ + readonly engine?: IInstanceEngine; } /** @@ -110,6 +124,7 @@ export abstract class DatabaseInstanceBase extends Resource implements IDatabase public readonly dbInstanceEndpointAddress = attrs.instanceEndpointAddress; public readonly dbInstanceEndpointPort = attrs.port.toString(); public readonly instanceEndpoint = new Endpoint(attrs.instanceEndpointAddress, attrs.port); + public readonly engine = attrs.engine; protected enableIamAuthentication = true; } @@ -769,6 +784,7 @@ export interface DatabaseInstanceSourceProps extends DatabaseInstanceNewProps { * A new source database instance (not a read replica) */ abstract class DatabaseInstanceSource extends DatabaseInstanceNew implements IDatabaseInstance { + public readonly engine?: IInstanceEngine; /** * The AWS Secrets Manager secret attached to the instance. */ @@ -785,6 +801,7 @@ abstract class DatabaseInstanceSource extends DatabaseInstanceNew implements IDa this.singleUserRotationApplication = props.engine.singleUserRotationApplication; this.multiUserRotationApplication = props.engine.multiUserRotationApplication; + this.engine = props.engine; let { s3ImportRole, s3ExportRole } = setupS3ImportExport(this, props, true); const engineConfig = props.engine.bindToInstance(this, { diff --git a/packages/@aws-cdk/aws-rds/lib/private/util.ts b/packages/@aws-cdk/aws-rds/lib/private/util.ts index 0caf78551b88d..a8439b652abc9 100644 --- a/packages/@aws-cdk/aws-rds/lib/private/util.ts +++ b/packages/@aws-cdk/aws-rds/lib/private/util.ts @@ -1,7 +1,7 @@ import * as iam from '@aws-cdk/aws-iam'; import * as s3 from '@aws-cdk/aws-s3'; import { Construct, CfnDeletionPolicy, CfnResource, RemovalPolicy } from '@aws-cdk/core'; -import { IInstanceEngine } from '../instance-engine'; +import { IEngine } from '../engine'; /** Common base of `DatabaseInstanceProps` and `DatabaseClusterBaseProps` that has only the S3 props */ export interface DatabaseS3ImportExportProps { @@ -56,7 +56,7 @@ export function setupS3ImportExport( return { s3ImportRole, s3ExportRole }; } -export function engineDescription(engine: IInstanceEngine) { +export function engineDescription(engine: IEngine) { return engine.engineType + (engine.engineVersion?.fullVersion ? `-${engine.engineVersion.fullVersion}` : ''); } diff --git a/packages/@aws-cdk/aws-rds/lib/proxy.ts b/packages/@aws-cdk/aws-rds/lib/proxy.ts index 7109202019c2f..dec7df1443723 100644 --- a/packages/@aws-cdk/aws-rds/lib/proxy.ts +++ b/packages/@aws-cdk/aws-rds/lib/proxy.ts @@ -3,8 +3,10 @@ import * as iam from '@aws-cdk/aws-iam'; import * as secretsmanager from '@aws-cdk/aws-secretsmanager'; import * as cdk from '@aws-cdk/core'; import { IDatabaseCluster } from './cluster-ref'; +import { IEngine } from './engine'; import { IDatabaseInstance } from './instance'; -import { CfnDBCluster, CfnDBInstance, CfnDBProxy, CfnDBProxyTargetGroup } from './rds.generated'; +import { engineDescription } from './private/util'; +import { CfnDBProxy, CfnDBProxyTargetGroup } from './rds.generated'; /** * SessionPinningFilter @@ -47,7 +49,7 @@ export class ProxyTarget { * @param instance RDS database instance */ public static fromInstance(instance: IDatabaseInstance): ProxyTarget { - return new ProxyTarget(instance); + return new ProxyTarget(instance, undefined); } /** @@ -59,34 +61,26 @@ export class ProxyTarget { return new ProxyTarget(undefined, cluster); } - private constructor(private readonly dbInstance?: IDatabaseInstance, private readonly dbCluster?: IDatabaseCluster) {} + private constructor( + private readonly dbInstance: IDatabaseInstance | undefined, + private readonly dbCluster: IDatabaseCluster | undefined) { + } /** * Bind this target to the specified database proxy. */ public bind(_: DatabaseProxy): ProxyTargetConfig { - let engine: string | undefined; - if (this.dbCluster && this.dbInstance) { - throw new Error('Proxy cannot target both database cluster and database instance.'); - } else if (this.dbCluster) { - engine = (this.dbCluster.node.defaultChild as CfnDBCluster).engine; - } else if (this.dbInstance) { - engine = (this.dbInstance.node.defaultChild as CfnDBInstance).engine; + const engine: IEngine | undefined = this.dbInstance?.engine ?? this.dbCluster?.engine; + + if (!engine) { + const errorResource = this.dbCluster ?? this.dbInstance; + throw new Error(`Could not determine engine for proxy target '${errorResource?.node.path}'. ` + + 'Please provide it explicitly when importing the resource'); } - let engineFamily; - switch (engine) { - case 'aurora': - case 'aurora-mysql': - case 'mysql': - engineFamily = 'MYSQL'; - break; - case 'aurora-postgresql': - case 'postgres': - engineFamily = 'POSTGRESQL'; - break; - default: - throw new Error(`Unsupported engine type - ${engine}`); + const engineFamily = engine.engineFamily; + if (!engineFamily) { + throw new Error(`Engine '${engineDescription(engine)}' does not support proxies`); } return { @@ -105,12 +99,14 @@ export interface ProxyTargetConfig { * The engine family of the database instance or cluster this proxy connects with. */ readonly engineFamily: string; + /** * The database instances to which this proxy connects. * Either this or `dbClusters` will be set and the other `undefined`. * @default - `undefined` if `dbClusters` is set. */ readonly dbInstances?: IDatabaseInstance[]; + /** * The database clusters to which this proxy connects. * Either this or `dbInstances` will be set and the other `undefined`. diff --git a/packages/@aws-cdk/aws-rds/test/test.proxy.ts b/packages/@aws-cdk/aws-rds/test/test.proxy.ts index 7fa03684fa53b..db57aaf4d8b93 100644 --- a/packages/@aws-cdk/aws-rds/test/test.proxy.ts +++ b/packages/@aws-cdk/aws-rds/test/test.proxy.ts @@ -1,17 +1,25 @@ -import { ABSENT, expect, haveResource, ResourcePart } from '@aws-cdk/assert'; +import { ABSENT, expect, haveResourceLike } from '@aws-cdk/assert'; import * as ec2 from '@aws-cdk/aws-ec2'; +import * as secretsmanager from '@aws-cdk/aws-secretsmanager'; import * as cdk from '@aws-cdk/core'; import { Test } from 'nodeunit'; import * as rds from '../lib'; +let stack: cdk.Stack; +let vpc: ec2.IVpc; + export = { + 'setUp'(cb: () => void) { + stack = new cdk.Stack(); + vpc = new ec2.Vpc(stack, 'VPC'); + + cb(); + }, + 'create a DB proxy from an instance'(test: Test) { // GIVEN - const stack = new cdk.Stack(); - const vpc = new ec2.Vpc(stack, 'VPC'); const instance = new rds.DatabaseInstance(stack, 'Instance', { engine: rds.DatabaseInstanceEngine.MYSQL, - instanceType: ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE2, ec2.InstanceSize.SMALL), vpc, }); @@ -23,68 +31,59 @@ export = { }); // THEN - expect(stack).to(haveResource('AWS::RDS::DBProxy', { - Properties: { - Auth: [ - { - AuthScheme: 'SECRETS', - IAMAuth: 'DISABLED', - SecretArn: { - Ref: 'InstanceSecretAttachment83BEE581', - }, + expect(stack).to(haveResourceLike('AWS::RDS::DBProxy', { + Auth: [ + { + AuthScheme: 'SECRETS', + IAMAuth: 'DISABLED', + SecretArn: { + Ref: 'InstanceSecretAttachment83BEE581', }, - ], - DBProxyName: 'Proxy', - EngineFamily: 'MYSQL', - RequireTLS: true, - RoleArn: { - 'Fn::GetAtt': [ - 'ProxyIAMRole2FE8AB0F', - 'Arn', - ], }, - VpcSubnetIds: [ - { - Ref: 'VPCPrivateSubnet1Subnet8BCA10E0', - }, - { - Ref: 'VPCPrivateSubnet2SubnetCFCDAA7A', - }, + ], + DBProxyName: 'Proxy', + EngineFamily: 'MYSQL', + RequireTLS: true, + RoleArn: { + 'Fn::GetAtt': [ + 'ProxyIAMRole2FE8AB0F', + 'Arn', ], }, - }, ResourcePart.CompleteDefinition)); + VpcSubnetIds: [ + { + Ref: 'VPCPrivateSubnet1Subnet8BCA10E0', + }, + { + Ref: 'VPCPrivateSubnet2SubnetCFCDAA7A', + }, + ], + })); // THEN - expect(stack).to(haveResource('AWS::RDS::DBProxyTargetGroup', { - Properties: { - DBProxyName: { - Ref: 'ProxyCB0DFB71', - }, - ConnectionPoolConfigurationInfo: {}, - DBInstanceIdentifiers: [ - { - Ref: 'InstanceC1063A87', - }, - ], - TargetGroupName: 'default', + expect(stack).to(haveResourceLike('AWS::RDS::DBProxyTargetGroup', { + DBProxyName: { + Ref: 'ProxyCB0DFB71', }, - }, ResourcePart.CompleteDefinition)); + ConnectionPoolConfigurationInfo: {}, + DBInstanceIdentifiers: [ + { + Ref: 'InstanceC1063A87', + }, + ], + TargetGroupName: 'default', + })); test.done(); }, 'create a DB proxy from a cluster'(test: Test) { // GIVEN - const stack = new cdk.Stack(); - const vpc = new ec2.Vpc(stack, 'VPC'); const cluster = new rds.DatabaseCluster(stack, 'Database', { engine: rds.DatabaseClusterEngine.auroraPostgres({ version: rds.AuroraPostgresEngineVersion.VER_10_7, }), - instanceProps: { - instanceType: ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE2, ec2.InstanceSize.SMALL), - vpc, - }, + instanceProps: { vpc }, }); // WHEN @@ -95,106 +94,132 @@ export = { }); // THEN - expect(stack).to(haveResource('AWS::RDS::DBProxy', { - Properties: { - Auth: [ - { - AuthScheme: 'SECRETS', - IAMAuth: 'DISABLED', - SecretArn: { - Ref: 'DatabaseSecretAttachmentE5D1B020', - }, + expect(stack).to(haveResourceLike('AWS::RDS::DBProxy', { + Auth: [ + { + AuthScheme: 'SECRETS', + IAMAuth: 'DISABLED', + SecretArn: { + Ref: 'DatabaseSecretAttachmentE5D1B020', }, - ], - DBProxyName: 'Proxy', - EngineFamily: 'POSTGRESQL', - RequireTLS: true, - RoleArn: { - 'Fn::GetAtt': [ - 'ProxyIAMRole2FE8AB0F', - 'Arn', - ], }, - VpcSubnetIds: [ - { - Ref: 'VPCPrivateSubnet1Subnet8BCA10E0', - }, - { - Ref: 'VPCPrivateSubnet2SubnetCFCDAA7A', - }, + ], + DBProxyName: 'Proxy', + EngineFamily: 'POSTGRESQL', + RequireTLS: true, + RoleArn: { + 'Fn::GetAtt': [ + 'ProxyIAMRole2FE8AB0F', + 'Arn', ], }, - }, ResourcePart.CompleteDefinition)); + VpcSubnetIds: [ + { + Ref: 'VPCPrivateSubnet1Subnet8BCA10E0', + }, + { + Ref: 'VPCPrivateSubnet2SubnetCFCDAA7A', + }, + ], + })); // THEN - expect(stack).to(haveResource('AWS::RDS::DBProxyTargetGroup', { - Properties: { - DBProxyName: { - Ref: 'ProxyCB0DFB71', - }, - ConnectionPoolConfigurationInfo: {}, - DBClusterIdentifiers: [ - { - Ref: 'DatabaseB269D8BB', - }, - ], - TargetGroupName: 'default', + expect(stack).to(haveResourceLike('AWS::RDS::DBProxyTargetGroup', { + DBProxyName: { + Ref: 'ProxyCB0DFB71', }, - }, ResourcePart.CompleteDefinition)); + ConnectionPoolConfigurationInfo: {}, + DBClusterIdentifiers: [ + { + Ref: 'DatabaseB269D8BB', + }, + ], + DBInstanceIdentifiers: ABSENT, + TargetGroupName: 'default', + })); test.done(); }, - 'Cannot specify both dbInstanceIdentifiers and dbClusterIdentifiers'(test: Test) { + 'One or more secrets are required.'(test: Test) { // GIVEN - const stack = new cdk.Stack(); - const vpc = new ec2.Vpc(stack, 'VPC'); const cluster = new rds.DatabaseCluster(stack, 'Database', { - engine: rds.DatabaseClusterEngine.auroraPostgres({ - version: rds.AuroraPostgresEngineVersion.VER_10_7, - }), - instanceProps: { - instanceType: ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE2, ec2.InstanceSize.SMALL), - vpc, - }, + engine: rds.DatabaseClusterEngine.auroraPostgres({ version: rds.AuroraPostgresEngineVersion.VER_10_7 }), + instanceProps: { vpc }, }); // WHEN - test.doesNotThrow(() => { + test.throws(() => { new rds.DatabaseProxy(stack, 'Proxy', { proxyTarget: rds.ProxyTarget.fromCluster(cluster), - secrets: [cluster.secret!], + secrets: [], // No secret vpc, }); - }, /Cannot specify both dbInstanceIdentifiers and dbClusterIdentifiers/); - - expect(stack).to(haveResource('AWS::RDS::DBProxyTargetGroup', { - DBInstanceIdentifiers: ABSENT, - }, ResourcePart.Properties)); + }, 'One or more secrets are required.'); test.done(); }, - 'One or more secrets are required.'(test: Test) { - // GIVEN - const stack = new cdk.Stack(); - const vpc = new ec2.Vpc(stack, 'VPC'); - const cluster = new rds.DatabaseCluster(stack, 'Database', { - engine: rds.DatabaseClusterEngine.auroraPostgres({ version: rds.AuroraPostgresEngineVersion.VER_10_7 }), - instanceProps: { - instanceType: ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE2, ec2.InstanceSize.SMALL), + 'fails when trying to create a proxy for a target without an engine'(test: Test) { + const importedCluster = rds.DatabaseCluster.fromDatabaseClusterAttributes(stack, 'Cluster', { + clusterIdentifier: 'my-cluster', + }); + + test.throws(() => { + new rds.DatabaseProxy(stack, 'Proxy', { + proxyTarget: rds.ProxyTarget.fromCluster(importedCluster), vpc, - }, + secrets: [new secretsmanager.Secret(stack, 'Secret')], + }); + }, /Could not determine engine for proxy target 'Default\/Cluster'\. Please provide it explicitly when importing the resource/); + + test.done(); + }, + + "fails when trying to create a proxy for a target with an engine that doesn't have engineFamily"(test: Test) { + const importedInstance = rds.DatabaseInstance.fromDatabaseInstanceAttributes(stack, 'Cluster', { + instanceIdentifier: 'my-instance', + instanceEndpointAddress: 'instance-address', + port: 5432, + securityGroups: [], + engine: rds.DatabaseInstanceEngine.mariaDb({ + version: rds.MariaDbEngineVersion.VER_10_0_24, + }), }); - // WHEN test.throws(() => { new rds.DatabaseProxy(stack, 'Proxy', { - proxyTarget: rds.ProxyTarget.fromCluster(cluster), - secrets: [], // No secret + proxyTarget: rds.ProxyTarget.fromInstance(importedInstance), vpc, + secrets: [new secretsmanager.Secret(stack, 'Secret')], }); - }, 'One or more secrets are required.'); + }, /Engine 'mariadb-10\.0\.24' does not support proxies/); + + test.done(); + }, + + 'correctly creates a proxy for an imported Cluster if its engine is known'(test: Test) { + const importedCluster = rds.DatabaseCluster.fromDatabaseClusterAttributes(stack, 'Cluster', { + clusterIdentifier: 'my-cluster', + engine: rds.DatabaseClusterEngine.auroraPostgres({ + version: rds.AuroraPostgresEngineVersion.VER_9_6_11, + }), + }); + + new rds.DatabaseProxy(stack, 'Proxy', { + proxyTarget: rds.ProxyTarget.fromCluster(importedCluster), + vpc, + secrets: [new secretsmanager.Secret(stack, 'Secret')], + }); + + expect(stack).to(haveResourceLike('AWS::RDS::DBProxy', { + EngineFamily: 'POSTGRESQL', + })); + expect(stack).to(haveResourceLike('AWS::RDS::DBProxyTargetGroup', { + DBClusterIdentifiers: [ + 'my-cluster', + ], + })); test.done(); }, From 451200e3dba6b8d80bc8396dc0b7d4d84f29cb56 Mon Sep 17 00:00:00 2001 From: Adam Ruka Date: Wed, 23 Sep 2020 18:24:32 -0700 Subject: [PATCH 14/29] chore(rds): add extra abstract properties to base classes to fix the build (#10502) Caused by JSII issue: https://github.com/aws/jsii/issues/2040 ---- *By submitting this pull request, I confirm that my contribution is made under the terms of the Apache-2.0 license* --- packages/@aws-cdk/aws-rds/lib/cluster.ts | 3 +++ packages/@aws-cdk/aws-rds/lib/instance.ts | 3 +++ 2 files changed, 6 insertions(+) diff --git a/packages/@aws-cdk/aws-rds/lib/cluster.ts b/packages/@aws-cdk/aws-rds/lib/cluster.ts index 3ba13451e8731..f3f9300788e1c 100644 --- a/packages/@aws-cdk/aws-rds/lib/cluster.ts +++ b/packages/@aws-cdk/aws-rds/lib/cluster.ts @@ -227,6 +227,9 @@ interface DatabaseClusterBaseProps { * A new or imported clustered database. */ export abstract class DatabaseClusterBase extends Resource implements IDatabaseCluster { + // only required because of JSII bug: https://github.com/aws/jsii/issues/2040 + public abstract readonly engine?: IClusterEngine; + /** * Identifier of the cluster */ diff --git a/packages/@aws-cdk/aws-rds/lib/instance.ts b/packages/@aws-cdk/aws-rds/lib/instance.ts index bfc5ac47f1b24..1479fa2fafe40 100644 --- a/packages/@aws-cdk/aws-rds/lib/instance.ts +++ b/packages/@aws-cdk/aws-rds/lib/instance.ts @@ -135,6 +135,8 @@ export abstract class DatabaseInstanceBase extends Resource implements IDatabase public abstract readonly dbInstanceEndpointAddress: string; public abstract readonly dbInstanceEndpointPort: string; public abstract readonly instanceEndpoint: Endpoint; + // only required because of JSII bug: https://github.com/aws/jsii/issues/2040 + public abstract readonly engine?: IInstanceEngine; protected abstract enableIamAuthentication?: boolean; /** @@ -1096,6 +1098,7 @@ export class DatabaseInstanceReadReplica extends DatabaseInstanceNew implements public readonly dbInstanceEndpointAddress: string; public readonly dbInstanceEndpointPort: string; public readonly instanceEndpoint: Endpoint; + public readonly engine?: IInstanceEngine = undefined; protected readonly instanceType: ec2.InstanceType; constructor(scope: Construct, id: string, props: DatabaseInstanceReadReplicaProps) { From c8e72e5567409c3340b243c2c240bb1ba1afa1dc Mon Sep 17 00:00:00 2001 From: Rico Huijbers Date: Thu, 24 Sep 2020 13:13:02 +0200 Subject: [PATCH 15/29] chore(integ): run all CDK integ tests with `-v` (#10503) Now that we suppress output of non-failing tests, it becomes all the more important to have detailed information for failing tests. ---- *By submitting this pull request, I confirm that my contribution is made under the terms of the Apache-2.0 license* --- .../cli-regression-patches/v1.64.0/NOTES.md | 3 + .../v1.64.0/cdk-helpers.js | 322 ++++++++++++++++++ .../aws-cdk/test/integ/cli/cdk-helpers.ts | 2 +- 3 files changed, 326 insertions(+), 1 deletion(-) create mode 100644 packages/aws-cdk/test/integ/cli-regression-patches/v1.64.0/NOTES.md create mode 100644 packages/aws-cdk/test/integ/cli-regression-patches/v1.64.0/cdk-helpers.js diff --git a/packages/aws-cdk/test/integ/cli-regression-patches/v1.64.0/NOTES.md b/packages/aws-cdk/test/integ/cli-regression-patches/v1.64.0/NOTES.md new file mode 100644 index 0000000000000..ade25e2ca159c --- /dev/null +++ b/packages/aws-cdk/test/integ/cli-regression-patches/v1.64.0/NOTES.md @@ -0,0 +1,3 @@ +Added a `-v` switch to the cdk executions that also needs to be +applied to the regression tesets so we have a better chance +of catching sporadically failing tests in the act. diff --git a/packages/aws-cdk/test/integ/cli-regression-patches/v1.64.0/cdk-helpers.js b/packages/aws-cdk/test/integ/cli-regression-patches/v1.64.0/cdk-helpers.js new file mode 100644 index 0000000000000..1b8bea33bf320 --- /dev/null +++ b/packages/aws-cdk/test/integ/cli-regression-patches/v1.64.0/cdk-helpers.js @@ -0,0 +1,322 @@ +"use strict"; +var _a, _b; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.randomString = exports.rimraf = exports.shell = exports.TestFixture = exports.cloneDirectory = exports.withDefaultFixture = exports.withCdkApp = exports.withAws = void 0; +const child_process = require("child_process"); +const fs = require("fs"); +const os = require("os"); +const path = require("path"); +const aws_helpers_1 = require("./aws-helpers"); +const resource_pool_1 = require("./resource-pool"); +const REGIONS = process.env.AWS_REGIONS + ? process.env.AWS_REGIONS.split(',') + : [(_b = (_a = process.env.AWS_REGION) !== null && _a !== void 0 ? _a : process.env.AWS_DEFAULT_REGION) !== null && _b !== void 0 ? _b : 'us-east-1']; +process.stdout.write(`Using regions: ${REGIONS}\n`); +const REGION_POOL = new resource_pool_1.ResourcePool(REGIONS); +/** + * Higher order function to execute a block with an AWS client setup + * + * Allocate the next region from the REGION pool and dispose it afterwards. + */ +function withAws(block) { + return (context) => REGION_POOL.using(async (region) => { + const aws = await aws_helpers_1.AwsClients.forRegion(region, context.output); + await sanityCheck(aws); + return block({ ...context, aws }); + }); +} +exports.withAws = withAws; +/** + * Higher order function to execute a block with a CDK app fixture + * + * Requires an AWS client to be passed in. + * + * For backwards compatibility with existing tests (so we don't have to change + * too much) the inner block is expecte to take a `TestFixture` object. + */ +function withCdkApp(block) { + return async (context) => { + const randy = randomString(); + const stackNamePrefix = `cdktest-${randy}`; + const integTestDir = path.join(os.tmpdir(), `cdk-integ-${randy}`); + context.output.write(` Stack prefix: ${stackNamePrefix}\n`); + context.output.write(` Test directory: ${integTestDir}\n`); + context.output.write(` Region: ${context.aws.region}\n`); + await cloneDirectory(path.join(__dirname, 'app'), integTestDir, context.output); + const fixture = new TestFixture(integTestDir, stackNamePrefix, context.output, context.aws); + let success = true; + try { + await fixture.shell(['npm', 'install', + '@aws-cdk/core', + '@aws-cdk/aws-sns', + '@aws-cdk/aws-iam', + '@aws-cdk/aws-lambda', + '@aws-cdk/aws-ssm', + '@aws-cdk/aws-ecr-assets', + '@aws-cdk/aws-cloudformation', + '@aws-cdk/aws-ec2']); + await ensureBootstrapped(fixture); + await block(fixture); + } + catch (e) { + success = false; + throw e; + } + finally { + await fixture.dispose(success); + } + }; +} +exports.withCdkApp = withCdkApp; +/** + * Default test fixture for most (all?) integ tests + * + * It's a composition of withAws/withCdkApp, expecting the test block to take a `TestFixture` + * object. + * + * We could have put `withAws(withCdkApp(fixture => { /... actual test here.../ }))` in every + * test declaration but centralizing it is going to make it convenient to modify in the future. + */ +function withDefaultFixture(block) { + return withAws(withCdkApp(block)); + // ^~~~~~ this is disappointing TypeScript! Feels like you should have been able to derive this. +} +exports.withDefaultFixture = withDefaultFixture; +/** + * Prepare a target dir byreplicating a source directory + */ +async function cloneDirectory(source, target, output) { + await shell(['rm', '-rf', target], { output }); + await shell(['mkdir', '-p', target], { output }); + await shell(['cp', '-R', source + '/*', target], { output }); +} +exports.cloneDirectory = cloneDirectory; +class TestFixture { + constructor(integTestDir, stackNamePrefix, output, aws) { + this.integTestDir = integTestDir; + this.stackNamePrefix = stackNamePrefix; + this.output = output; + this.aws = aws; + this.qualifier = randomString().substr(0, 10); + this.bucketsToDelete = new Array(); + } + log(s) { + this.output.write(`${s}\n`); + } + async shell(command, options = {}) { + return shell(command, { + output: this.output, + cwd: this.integTestDir, + ...options, + }); + } + async cdkDeploy(stackNames, options = {}) { + var _a, _b; + stackNames = typeof stackNames === 'string' ? [stackNames] : stackNames; + const neverRequireApproval = (_a = options.neverRequireApproval) !== null && _a !== void 0 ? _a : true; + return this.cdk(['deploy', + ...(neverRequireApproval ? ['--require-approval=never'] : []), // Default to no approval in an unattended test + ...((_b = options.options) !== null && _b !== void 0 ? _b : []), ...this.fullStackName(stackNames)], options); + } + async cdkDestroy(stackNames, options = {}) { + var _a; + stackNames = typeof stackNames === 'string' ? [stackNames] : stackNames; + return this.cdk(['destroy', + '-f', // We never want a prompt in an unattended test + ...((_a = options.options) !== null && _a !== void 0 ? _a : []), ...this.fullStackName(stackNames)], options); + } + async cdk(args, options = {}) { + return this.shell(['cdk', '-v', ...args], { + ...options, + modEnv: { + AWS_REGION: this.aws.region, + AWS_DEFAULT_REGION: this.aws.region, + STACK_NAME_PREFIX: this.stackNamePrefix, + ...options.modEnv, + }, + }); + } + fullStackName(stackNames) { + if (typeof stackNames === 'string') { + return `${this.stackNamePrefix}-${stackNames}`; + } + else { + return stackNames.map(s => `${this.stackNamePrefix}-${s}`); + } + } + /** + * Append this to the list of buckets to potentially delete + * + * At the end of a test, we clean up buckets that may not have gotten destroyed + * (for whatever reason). + */ + rememberToDeleteBucket(bucketName) { + this.bucketsToDelete.push(bucketName); + } + /** + * Cleanup leftover stacks and buckets + */ + async dispose(success) { + const stacksToDelete = await this.deleteableStacks(this.stackNamePrefix); + // Bootstrap stacks have buckets that need to be cleaned + const bucketNames = stacksToDelete.map(stack => aws_helpers_1.outputFromStack('BucketName', stack)).filter(defined); + await Promise.all(bucketNames.map(b => this.aws.emptyBucket(b))); + // Bootstrap stacks have ECR repositories with images which should be deleted + const imageRepositoryNames = stacksToDelete.map(stack => aws_helpers_1.outputFromStack('ImageRepositoryName', stack)).filter(defined); + await Promise.all(imageRepositoryNames.map(r => this.aws.deleteImageRepository(r))); + await this.aws.deleteStacks(...stacksToDelete.map(s => s.StackName)); + // We might have leaked some buckets by upgrading the bootstrap stack. Be + // sure to clean everything. + for (const bucket of this.bucketsToDelete) { + await this.aws.deleteBucket(bucket); + } + // If the tests completed successfully, happily delete the fixture + // (otherwise leave it for humans to inspect) + if (success) { + rimraf(this.integTestDir); + } + } + /** + * Return the stacks starting with our testing prefix that should be deleted + */ + async deleteableStacks(prefix) { + var _a; + const statusFilter = [ + 'CREATE_IN_PROGRESS', 'CREATE_FAILED', 'CREATE_COMPLETE', + 'ROLLBACK_IN_PROGRESS', 'ROLLBACK_FAILED', 'ROLLBACK_COMPLETE', + 'DELETE_FAILED', + 'UPDATE_IN_PROGRESS', 'UPDATE_COMPLETE_CLEANUP_IN_PROGRESS', + 'UPDATE_COMPLETE', 'UPDATE_ROLLBACK_IN_PROGRESS', + 'UPDATE_ROLLBACK_FAILED', + 'UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS', + 'UPDATE_ROLLBACK_COMPLETE', 'REVIEW_IN_PROGRESS', + 'IMPORT_IN_PROGRESS', 'IMPORT_COMPLETE', + 'IMPORT_ROLLBACK_IN_PROGRESS', 'IMPORT_ROLLBACK_FAILED', + 'IMPORT_ROLLBACK_COMPLETE', + ]; + const response = await this.aws.cloudFormation('describeStacks', {}); + return ((_a = response.Stacks) !== null && _a !== void 0 ? _a : []) + .filter(s => s.StackName.startsWith(prefix)) + .filter(s => statusFilter.includes(s.StackStatus)) + .filter(s => s.RootId === undefined); // Only delete parent stacks. Nested stacks are deleted in the process + } +} +exports.TestFixture = TestFixture; +/** + * Perform a one-time quick sanity check that the AWS clients has properly configured credentials + * + * If we don't do this, calls are going to fail and they'll be retried and everything will take + * forever before the user notices a simple misconfiguration. + * + * We can't check for the presence of environment variables since credentials could come from + * anywhere, so do simple account retrieval. + * + * Only do it once per process. + */ +async function sanityCheck(aws) { + if (sanityChecked === undefined) { + try { + await aws.account(); + sanityChecked = true; + } + catch (e) { + sanityChecked = false; + throw new Error(`AWS credentials probably not configured, got error: ${e.message}`); + } + } + if (!sanityChecked) { + throw new Error('AWS credentials probably not configured, see previous error'); + } +} +let sanityChecked; +/** + * Make sure that the given environment is bootstrapped + * + * Since we go striping across regions, it's going to suck doing this + * by hand so let's just mass-automate it. + */ +async function ensureBootstrapped(fixture) { + // Old-style bootstrap stack with default name + if (await fixture.aws.stackStatus('CDKToolkit') === undefined) { + await fixture.cdk(['bootstrap', `aws://${await fixture.aws.account()}/${fixture.aws.region}`]); + } +} +/** + * A shell command that does what you want + * + * Is platform-aware, handles errors nicely. + */ +async function shell(command, options = {}) { + var _a, _b; + if (options.modEnv && options.env) { + throw new Error('Use either env or modEnv but not both'); + } + (_a = options.output) === null || _a === void 0 ? void 0 : _a.write(`💻 ${command.join(' ')}\n`); + const env = (_b = options.env) !== null && _b !== void 0 ? _b : (options.modEnv ? { ...process.env, ...options.modEnv } : undefined); + const child = child_process.spawn(command[0], command.slice(1), { + ...options, + env, + // Need this for Windows where we want .cmd and .bat to be found as well. + shell: true, + stdio: ['ignore', 'pipe', 'pipe'], + }); + return new Promise((resolve, reject) => { + const stdout = new Array(); + const stderr = new Array(); + child.stdout.on('data', chunk => { + var _a; + (_a = options.output) === null || _a === void 0 ? void 0 : _a.write(chunk); + stdout.push(chunk); + }); + child.stderr.on('data', chunk => { + var _a, _b; + (_a = options.output) === null || _a === void 0 ? void 0 : _a.write(chunk); + if ((_b = options.captureStderr) !== null && _b !== void 0 ? _b : true) { + stderr.push(chunk); + } + }); + child.once('error', reject); + child.once('close', code => { + if (code === 0 || options.allowErrExit) { + resolve((Buffer.concat(stdout).toString('utf-8') + Buffer.concat(stderr).toString('utf-8')).trim()); + } + else { + reject(new Error(`'${command.join(' ')}' exited with error code ${code}`)); + } + }); + }); +} +exports.shell = shell; +function defined(x) { + return x !== undefined; +} +/** + * rm -rf reimplementation, don't want to depend on an NPM package for this + */ +function rimraf(fsPath) { + try { + const isDir = fs.lstatSync(fsPath).isDirectory(); + if (isDir) { + for (const file of fs.readdirSync(fsPath)) { + rimraf(path.join(fsPath, file)); + } + fs.rmdirSync(fsPath); + } + else { + fs.unlinkSync(fsPath); + } + } + catch (e) { + // We will survive ENOENT + if (e.code !== 'ENOENT') { + throw e; + } + } +} +exports.rimraf = rimraf; +function randomString() { + // Crazy + return Math.random().toString(36).replace(/[^a-z0-9]+/g, ''); +} +exports.randomString = randomString; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cdk-helpers.js","sourceRoot":"","sources":["cdk-helpers.ts"],"names":[],"mappings":"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","sourcesContent":["import * as child_process from 'child_process';\nimport * as fs from 'fs';\nimport * as os from 'os';\nimport * as path from 'path';\nimport { outputFromStack, AwsClients } from './aws-helpers';\nimport { ResourcePool } from './resource-pool';\nimport { TestContext } from './test-helpers';\n\nconst REGIONS = process.env.AWS_REGIONS\n  ? process.env.AWS_REGIONS.split(',')\n  : [process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION ?? 'us-east-1'];\n\nprocess.stdout.write(`Using regions: ${REGIONS}\\n`);\n\nconst REGION_POOL = new ResourcePool(REGIONS);\n\n\nexport type AwsContext = { readonly aws: AwsClients };\n\n/**\n * Higher order function to execute a block with an AWS client setup\n *\n * Allocate the next region from the REGION pool and dispose it afterwards.\n */\nexport function withAws<A extends TestContext>(block: (context: A & AwsContext) => Promise<void>) {\n  return (context: A) => REGION_POOL.using(async (region) => {\n    const aws = await AwsClients.forRegion(region, context.output);\n    await sanityCheck(aws);\n\n    return block({ ...context, aws });\n  });\n}\n\n/**\n * Higher order function to execute a block with a CDK app fixture\n *\n * Requires an AWS client to be passed in.\n *\n * For backwards compatibility with existing tests (so we don't have to change\n * too much) the inner block is expecte to take a `TestFixture` object.\n */\nexport function withCdkApp<A extends TestContext & AwsContext>(block: (context: TestFixture) => Promise<void>) {\n  return async (context: A) => {\n    const randy = randomString();\n    const stackNamePrefix = `cdktest-${randy}`;\n    const integTestDir = path.join(os.tmpdir(), `cdk-integ-${randy}`);\n\n    context.output.write(` Stack prefix:   ${stackNamePrefix}\\n`);\n    context.output.write(` Test directory: ${integTestDir}\\n`);\n    context.output.write(` Region:         ${context.aws.region}\\n`);\n\n    await cloneDirectory(path.join(__dirname, 'app'), integTestDir, context.output);\n    const fixture = new TestFixture(\n      integTestDir,\n      stackNamePrefix,\n      context.output,\n      context.aws);\n\n    let success = true;\n    try {\n      await fixture.shell(['npm', 'install',\n        '@aws-cdk/core',\n        '@aws-cdk/aws-sns',\n        '@aws-cdk/aws-iam',\n        '@aws-cdk/aws-lambda',\n        '@aws-cdk/aws-ssm',\n        '@aws-cdk/aws-ecr-assets',\n        '@aws-cdk/aws-cloudformation',\n        '@aws-cdk/aws-ec2']);\n\n      await ensureBootstrapped(fixture);\n\n      await block(fixture);\n    } catch (e) {\n      success = false;\n      throw e;\n    } finally {\n      await fixture.dispose(success);\n    }\n  };\n}\n\n/**\n * Default test fixture for most (all?) integ tests\n *\n * It's a composition of withAws/withCdkApp, expecting the test block to take a `TestFixture`\n * object.\n *\n * We could have put `withAws(withCdkApp(fixture => { /... actual test here.../ }))` in every\n * test declaration but centralizing it is going to make it convenient to modify in the future.\n */\nexport function withDefaultFixture(block: (context: TestFixture) => Promise<void>) {\n  return withAws<TestContext>(withCdkApp(block));\n  //              ^~~~~~ this is disappointing TypeScript! Feels like you should have been able to derive this.\n}\n\nexport interface ShellOptions extends child_process.SpawnOptions {\n  /**\n   * Properties to add to 'env'\n   */\n  modEnv?: Record<string, string>;\n\n  /**\n   * Don't fail when exiting with an error\n   *\n   * @default false\n   */\n  allowErrExit?: boolean;\n\n  /**\n   * Whether to capture stderr\n   *\n   * @default true\n   */\n  captureStderr?: boolean;\n\n  /**\n   * Pass output here\n   */\n  output?: NodeJS.WritableStream;\n}\n\nexport interface CdkCliOptions extends ShellOptions {\n  options?: string[];\n  neverRequireApproval?: boolean;\n}\n\n/**\n * Prepare a target dir byreplicating a source directory\n */\nexport async function cloneDirectory(source: string, target: string, output?: NodeJS.WritableStream) {\n  await shell(['rm', '-rf', target], { output });\n  await shell(['mkdir', '-p', target], { output });\n  await shell(['cp', '-R', source + '/*', target], { output });\n}\n\nexport class TestFixture {\n  public readonly qualifier = randomString().substr(0, 10);\n  private readonly bucketsToDelete = new Array<string>();\n\n  constructor(\n    public readonly integTestDir: string,\n    public readonly stackNamePrefix: string,\n    public readonly output: NodeJS.WritableStream,\n    public readonly aws: AwsClients) {\n  }\n\n  public log(s: string) {\n    this.output.write(`${s}\\n`);\n  }\n\n  public async shell(command: string[], options: Omit<ShellOptions, 'cwd'|'output'> = {}): Promise<string> {\n    return shell(command, {\n      output: this.output,\n      cwd: this.integTestDir,\n      ...options,\n    });\n  }\n\n  public async cdkDeploy(stackNames: string | string[], options: CdkCliOptions = {}) {\n    stackNames = typeof stackNames === 'string' ? [stackNames] : stackNames;\n\n    const neverRequireApproval = options.neverRequireApproval ?? true;\n\n    return this.cdk(['deploy',\n      ...(neverRequireApproval ? ['--require-approval=never'] : []), // Default to no approval in an unattended test\n      ...(options.options ?? []),\n      ...this.fullStackName(stackNames)], options);\n  }\n\n  public async cdkDestroy(stackNames: string | string[], options: CdkCliOptions = {}) {\n    stackNames = typeof stackNames === 'string' ? [stackNames] : stackNames;\n\n    return this.cdk(['destroy',\n      '-f', // We never want a prompt in an unattended test\n      ...(options.options ?? []),\n      ...this.fullStackName(stackNames)], options);\n  }\n\n  public async cdk(args: string[], options: CdkCliOptions = {}) {\n    return this.shell(['cdk', ...args], {\n      ...options,\n      modEnv: {\n        AWS_REGION: this.aws.region,\n        AWS_DEFAULT_REGION: this.aws.region,\n        STACK_NAME_PREFIX: this.stackNamePrefix,\n        ...options.modEnv,\n      },\n    });\n  }\n\n  public fullStackName(stackName: string): string;\n  public fullStackName(stackNames: string[]): string[];\n  public fullStackName(stackNames: string | string[]): string | string[] {\n    if (typeof stackNames === 'string') {\n      return `${this.stackNamePrefix}-${stackNames}`;\n    } else {\n      return stackNames.map(s => `${this.stackNamePrefix}-${s}`);\n    }\n  }\n\n  /**\n   * Append this to the list of buckets to potentially delete\n   *\n   * At the end of a test, we clean up buckets that may not have gotten destroyed\n   * (for whatever reason).\n   */\n  public rememberToDeleteBucket(bucketName: string) {\n    this.bucketsToDelete.push(bucketName);\n  }\n\n  /**\n   * Cleanup leftover stacks and buckets\n   */\n  public async dispose(success: boolean) {\n    const stacksToDelete = await this.deleteableStacks(this.stackNamePrefix);\n\n    // Bootstrap stacks have buckets that need to be cleaned\n    const bucketNames = stacksToDelete.map(stack => outputFromStack('BucketName', stack)).filter(defined);\n    await Promise.all(bucketNames.map(b => this.aws.emptyBucket(b)));\n\n    // Bootstrap stacks have ECR repositories with images which should be deleted\n    const imageRepositoryNames = stacksToDelete.map(stack => outputFromStack('ImageRepositoryName', stack)).filter(defined);\n    await Promise.all(imageRepositoryNames.map(r => this.aws.deleteImageRepository(r)));\n\n    await this.aws.deleteStacks(...stacksToDelete.map(s => s.StackName));\n\n    // We might have leaked some buckets by upgrading the bootstrap stack. Be\n    // sure to clean everything.\n    for (const bucket of this.bucketsToDelete) {\n      await this.aws.deleteBucket(bucket);\n    }\n\n    // If the tests completed successfully, happily delete the fixture\n    // (otherwise leave it for humans to inspect)\n    if (success) {\n      rimraf(this.integTestDir);\n    }\n  }\n\n  /**\n   * Return the stacks starting with our testing prefix that should be deleted\n   */\n  private async deleteableStacks(prefix: string): Promise<AWS.CloudFormation.Stack[]> {\n    const statusFilter = [\n      'CREATE_IN_PROGRESS', 'CREATE_FAILED', 'CREATE_COMPLETE',\n      'ROLLBACK_IN_PROGRESS', 'ROLLBACK_FAILED', 'ROLLBACK_COMPLETE',\n      'DELETE_FAILED',\n      'UPDATE_IN_PROGRESS', 'UPDATE_COMPLETE_CLEANUP_IN_PROGRESS',\n      'UPDATE_COMPLETE', 'UPDATE_ROLLBACK_IN_PROGRESS',\n      'UPDATE_ROLLBACK_FAILED',\n      'UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS',\n      'UPDATE_ROLLBACK_COMPLETE', 'REVIEW_IN_PROGRESS',\n      'IMPORT_IN_PROGRESS', 'IMPORT_COMPLETE',\n      'IMPORT_ROLLBACK_IN_PROGRESS', 'IMPORT_ROLLBACK_FAILED',\n      'IMPORT_ROLLBACK_COMPLETE',\n    ];\n\n    const response = await this.aws.cloudFormation('describeStacks', {});\n\n    return (response.Stacks ?? [])\n      .filter(s => s.StackName.startsWith(prefix))\n      .filter(s => statusFilter.includes(s.StackStatus))\n      .filter(s => s.RootId === undefined); // Only delete parent stacks. Nested stacks are deleted in the process\n  }\n}\n\n/**\n * Perform a one-time quick sanity check that the AWS clients has properly configured credentials\n *\n * If we don't do this, calls are going to fail and they'll be retried and everything will take\n * forever before the user notices a simple misconfiguration.\n *\n * We can't check for the presence of environment variables since credentials could come from\n * anywhere, so do simple account retrieval.\n *\n * Only do it once per process.\n */\nasync function sanityCheck(aws: AwsClients) {\n  if (sanityChecked === undefined) {\n    try {\n      await aws.account();\n      sanityChecked = true;\n    } catch (e) {\n      sanityChecked = false;\n      throw new Error(`AWS credentials probably not configured, got error: ${e.message}`);\n    }\n  }\n  if (!sanityChecked) {\n    throw new Error('AWS credentials probably not configured, see previous error');\n  }\n}\nlet sanityChecked: boolean | undefined;\n\n/**\n * Make sure that the given environment is bootstrapped\n *\n * Since we go striping across regions, it's going to suck doing this\n * by hand so let's just mass-automate it.\n */\nasync function ensureBootstrapped(fixture: TestFixture) {\n  // Old-style bootstrap stack with default name\n  if (await fixture.aws.stackStatus('CDKToolkit') === undefined) {\n    await fixture.cdk(['bootstrap', `aws://${await fixture.aws.account()}/${fixture.aws.region}`]);\n  }\n}\n\n/**\n * A shell command that does what you want\n *\n * Is platform-aware, handles errors nicely.\n */\nexport async function shell(command: string[], options: ShellOptions = {}): Promise<string> {\n  if (options.modEnv && options.env) {\n    throw new Error('Use either env or modEnv but not both');\n  }\n\n  options.output?.write(`💻 ${command.join(' ')}\\n`);\n\n  const env = options.env ?? (options.modEnv ? { ...process.env, ...options.modEnv } : undefined);\n\n  const child = child_process.spawn(command[0], command.slice(1), {\n    ...options,\n    env,\n    // Need this for Windows where we want .cmd and .bat to be found as well.\n    shell: true,\n    stdio: ['ignore', 'pipe', 'pipe'],\n  });\n\n  return new Promise<string>((resolve, reject) => {\n    const stdout = new Array<Buffer>();\n    const stderr = new Array<Buffer>();\n\n    child.stdout!.on('data', chunk => {\n      options.output?.write(chunk);\n      stdout.push(chunk);\n    });\n\n    child.stderr!.on('data', chunk => {\n      options.output?.write(chunk);\n      if (options.captureStderr ?? true) {\n        stderr.push(chunk);\n      }\n    });\n\n    child.once('error', reject);\n\n    child.once('close', code => {\n      if (code === 0 || options.allowErrExit) {\n        resolve((Buffer.concat(stdout).toString('utf-8') + Buffer.concat(stderr).toString('utf-8')).trim());\n      } else {\n        reject(new Error(`'${command.join(' ')}' exited with error code ${code}`));\n      }\n    });\n  });\n}\n\nfunction defined<A>(x: A): x is NonNullable<A> {\n  return x !== undefined;\n}\n\n/**\n * rm -rf reimplementation, don't want to depend on an NPM package for this\n */\nexport function rimraf(fsPath: string) {\n  try {\n    const isDir = fs.lstatSync(fsPath).isDirectory();\n\n    if (isDir) {\n      for (const file of fs.readdirSync(fsPath)) {\n        rimraf(path.join(fsPath, file));\n      }\n      fs.rmdirSync(fsPath);\n    } else {\n      fs.unlinkSync(fsPath);\n    }\n  } catch (e) {\n    // We will survive ENOENT\n    if (e.code !== 'ENOENT') { throw e; }\n  }\n}\n\nexport function randomString() {\n  // Crazy\n  return Math.random().toString(36).replace(/[^a-z0-9]+/g, '');\n}"]} diff --git a/packages/aws-cdk/test/integ/cli/cdk-helpers.ts b/packages/aws-cdk/test/integ/cli/cdk-helpers.ts index 66c6799164fd8..30828ce0f7522 100644 --- a/packages/aws-cdk/test/integ/cli/cdk-helpers.ts +++ b/packages/aws-cdk/test/integ/cli/cdk-helpers.ts @@ -178,7 +178,7 @@ export class TestFixture { } public async cdk(args: string[], options: CdkCliOptions = {}) { - return this.shell(['cdk', ...args], { + return this.shell(['cdk', '-v', ...args], { ...options, modEnv: { AWS_REGION: this.aws.region, From e9b5b8c16c11b6dab37d8d9c7fdba2265621eae7 Mon Sep 17 00:00:00 2001 From: Jonathan Goldwasser Date: Thu, 24 Sep 2020 15:14:20 +0200 Subject: [PATCH 16/29] fix(core): bundling with staging disabled returns a relative path (#10507) The change introduced in #9576 did not handle the "staging disabled" case. As a consequence, when bundling the staged path was always relative. Revert to the behavior that was present before this change: when staging is disabled the staged path is absolute (whether bundling or not). Closes #10367 ---- *By submitting this pull request, I confirm that my contribution is made under the terms of the Apache-2.0 license* --- packages/@aws-cdk/core/lib/asset-staging.ts | 14 +++++++------- packages/@aws-cdk/core/test/test.staging.ts | 10 +++++++++- 2 files changed, 16 insertions(+), 8 deletions(-) diff --git a/packages/@aws-cdk/core/lib/asset-staging.ts b/packages/@aws-cdk/core/lib/asset-staging.ts index e5878c2a31365..53f607f9588a0 100644 --- a/packages/@aws-cdk/core/lib/asset-staging.ts +++ b/packages/@aws-cdk/core/lib/asset-staging.ts @@ -120,14 +120,14 @@ export class AssetStaging extends Construct { } } else { this.assetHash = this.calculateHash(hashType, props.assetHash); + this.relativePath = renderAssetFilename(this.assetHash, path.extname(this.sourcePath)); + this.stagedPath = this.relativePath; + } - const stagingDisabled = this.node.tryGetContext(cxapi.DISABLE_ASSET_STAGING_CONTEXT); - if (stagingDisabled) { - this.stagedPath = this.sourcePath; - } else { - this.relativePath = renderAssetFilename(this.assetHash, path.extname(this.sourcePath)); - this.stagedPath = this.relativePath; - } + const stagingDisabled = this.node.tryGetContext(cxapi.DISABLE_ASSET_STAGING_CONTEXT); + if (stagingDisabled) { + this.relativePath = undefined; + this.stagedPath = this.bundleDir ?? this.sourcePath; } this.sourceHash = this.assetHash; diff --git a/packages/@aws-cdk/core/test/test.staging.ts b/packages/@aws-cdk/core/test/test.staging.ts index e652c884935f4..6d649325db94e 100644 --- a/packages/@aws-cdk/core/test/test.staging.ts +++ b/packages/@aws-cdk/core/test/test.staging.ts @@ -148,7 +148,7 @@ export = { const directory = path.join(__dirname, 'fs', 'fixtures', 'test1'); // WHEN - new AssetStaging(stack, 'Asset', { + const asset = new AssetStaging(stack, 'Asset', { sourcePath: directory, bundling: { image: BundlingDockerImage.fromRegistry('alpine'), @@ -167,6 +167,14 @@ export = { 'tree.json', ]); + test.equal(asset.sourceHash, 'b1e32e86b3523f2fa512eb99180ee2975a50a4439e63e8badd153f2a68d61aa4'); + test.equal(asset.sourcePath, directory); + + const resolvedStagePath = stack.resolve(asset.stagedPath); + // absolute path ending with bundling dir + test.ok(path.isAbsolute(resolvedStagePath)); + test.ok(new RegExp('asset.b1e32e86b3523f2fa512eb99180ee2975a50a4439e63e8badd153f2a68d61aa4$').test(resolvedStagePath)); + test.done(); }, From 8ec1cfe67cc03f34f9ba436d5092209649bb73e3 Mon Sep 17 00:00:00 2001 From: Rico Huijbers Date: Thu, 24 Sep 2020 15:43:32 +0200 Subject: [PATCH 17/29] chore(integ): revert run all CDK integ tests with `-v` (#10511) Reverts aws/aws-cdk#10503 We can't actually do this. There are tests that check that the output of the `cdk` command is *exactly* "some value", and adding the logging in breaks the expectation. Revert the `-v` to allow the tests to go back to passing 90% of the time. --- .../cli-regression-patches/v1.64.0/NOTES.md | 3 - .../v1.64.0/cdk-helpers.js | 322 ------------------ .../aws-cdk/test/integ/cli/cdk-helpers.ts | 2 +- 3 files changed, 1 insertion(+), 326 deletions(-) delete mode 100644 packages/aws-cdk/test/integ/cli-regression-patches/v1.64.0/NOTES.md delete mode 100644 packages/aws-cdk/test/integ/cli-regression-patches/v1.64.0/cdk-helpers.js diff --git a/packages/aws-cdk/test/integ/cli-regression-patches/v1.64.0/NOTES.md b/packages/aws-cdk/test/integ/cli-regression-patches/v1.64.0/NOTES.md deleted file mode 100644 index ade25e2ca159c..0000000000000 --- a/packages/aws-cdk/test/integ/cli-regression-patches/v1.64.0/NOTES.md +++ /dev/null @@ -1,3 +0,0 @@ -Added a `-v` switch to the cdk executions that also needs to be -applied to the regression tesets so we have a better chance -of catching sporadically failing tests in the act. diff --git a/packages/aws-cdk/test/integ/cli-regression-patches/v1.64.0/cdk-helpers.js b/packages/aws-cdk/test/integ/cli-regression-patches/v1.64.0/cdk-helpers.js deleted file mode 100644 index 1b8bea33bf320..0000000000000 --- a/packages/aws-cdk/test/integ/cli-regression-patches/v1.64.0/cdk-helpers.js +++ /dev/null @@ -1,322 +0,0 @@ -"use strict"; -var _a, _b; -Object.defineProperty(exports, "__esModule", { value: true }); -exports.randomString = exports.rimraf = exports.shell = exports.TestFixture = exports.cloneDirectory = exports.withDefaultFixture = exports.withCdkApp = exports.withAws = void 0; -const child_process = require("child_process"); -const fs = require("fs"); -const os = require("os"); -const path = require("path"); -const aws_helpers_1 = require("./aws-helpers"); -const resource_pool_1 = require("./resource-pool"); -const REGIONS = process.env.AWS_REGIONS - ? process.env.AWS_REGIONS.split(',') - : [(_b = (_a = process.env.AWS_REGION) !== null && _a !== void 0 ? _a : process.env.AWS_DEFAULT_REGION) !== null && _b !== void 0 ? _b : 'us-east-1']; -process.stdout.write(`Using regions: ${REGIONS}\n`); -const REGION_POOL = new resource_pool_1.ResourcePool(REGIONS); -/** - * Higher order function to execute a block with an AWS client setup - * - * Allocate the next region from the REGION pool and dispose it afterwards. - */ -function withAws(block) { - return (context) => REGION_POOL.using(async (region) => { - const aws = await aws_helpers_1.AwsClients.forRegion(region, context.output); - await sanityCheck(aws); - return block({ ...context, aws }); - }); -} -exports.withAws = withAws; -/** - * Higher order function to execute a block with a CDK app fixture - * - * Requires an AWS client to be passed in. - * - * For backwards compatibility with existing tests (so we don't have to change - * too much) the inner block is expecte to take a `TestFixture` object. - */ -function withCdkApp(block) { - return async (context) => { - const randy = randomString(); - const stackNamePrefix = `cdktest-${randy}`; - const integTestDir = path.join(os.tmpdir(), `cdk-integ-${randy}`); - context.output.write(` Stack prefix: ${stackNamePrefix}\n`); - context.output.write(` Test directory: ${integTestDir}\n`); - context.output.write(` Region: ${context.aws.region}\n`); - await cloneDirectory(path.join(__dirname, 'app'), integTestDir, context.output); - const fixture = new TestFixture(integTestDir, stackNamePrefix, context.output, context.aws); - let success = true; - try { - await fixture.shell(['npm', 'install', - '@aws-cdk/core', - '@aws-cdk/aws-sns', - '@aws-cdk/aws-iam', - '@aws-cdk/aws-lambda', - '@aws-cdk/aws-ssm', - '@aws-cdk/aws-ecr-assets', - '@aws-cdk/aws-cloudformation', - '@aws-cdk/aws-ec2']); - await ensureBootstrapped(fixture); - await block(fixture); - } - catch (e) { - success = false; - throw e; - } - finally { - await fixture.dispose(success); - } - }; -} -exports.withCdkApp = withCdkApp; -/** - * Default test fixture for most (all?) integ tests - * - * It's a composition of withAws/withCdkApp, expecting the test block to take a `TestFixture` - * object. - * - * We could have put `withAws(withCdkApp(fixture => { /... actual test here.../ }))` in every - * test declaration but centralizing it is going to make it convenient to modify in the future. - */ -function withDefaultFixture(block) { - return withAws(withCdkApp(block)); - // ^~~~~~ this is disappointing TypeScript! Feels like you should have been able to derive this. -} -exports.withDefaultFixture = withDefaultFixture; -/** - * Prepare a target dir byreplicating a source directory - */ -async function cloneDirectory(source, target, output) { - await shell(['rm', '-rf', target], { output }); - await shell(['mkdir', '-p', target], { output }); - await shell(['cp', '-R', source + '/*', target], { output }); -} -exports.cloneDirectory = cloneDirectory; -class TestFixture { - constructor(integTestDir, stackNamePrefix, output, aws) { - this.integTestDir = integTestDir; - this.stackNamePrefix = stackNamePrefix; - this.output = output; - this.aws = aws; - this.qualifier = randomString().substr(0, 10); - this.bucketsToDelete = new Array(); - } - log(s) { - this.output.write(`${s}\n`); - } - async shell(command, options = {}) { - return shell(command, { - output: this.output, - cwd: this.integTestDir, - ...options, - }); - } - async cdkDeploy(stackNames, options = {}) { - var _a, _b; - stackNames = typeof stackNames === 'string' ? [stackNames] : stackNames; - const neverRequireApproval = (_a = options.neverRequireApproval) !== null && _a !== void 0 ? _a : true; - return this.cdk(['deploy', - ...(neverRequireApproval ? ['--require-approval=never'] : []), // Default to no approval in an unattended test - ...((_b = options.options) !== null && _b !== void 0 ? _b : []), ...this.fullStackName(stackNames)], options); - } - async cdkDestroy(stackNames, options = {}) { - var _a; - stackNames = typeof stackNames === 'string' ? [stackNames] : stackNames; - return this.cdk(['destroy', - '-f', // We never want a prompt in an unattended test - ...((_a = options.options) !== null && _a !== void 0 ? _a : []), ...this.fullStackName(stackNames)], options); - } - async cdk(args, options = {}) { - return this.shell(['cdk', '-v', ...args], { - ...options, - modEnv: { - AWS_REGION: this.aws.region, - AWS_DEFAULT_REGION: this.aws.region, - STACK_NAME_PREFIX: this.stackNamePrefix, - ...options.modEnv, - }, - }); - } - fullStackName(stackNames) { - if (typeof stackNames === 'string') { - return `${this.stackNamePrefix}-${stackNames}`; - } - else { - return stackNames.map(s => `${this.stackNamePrefix}-${s}`); - } - } - /** - * Append this to the list of buckets to potentially delete - * - * At the end of a test, we clean up buckets that may not have gotten destroyed - * (for whatever reason). - */ - rememberToDeleteBucket(bucketName) { - this.bucketsToDelete.push(bucketName); - } - /** - * Cleanup leftover stacks and buckets - */ - async dispose(success) { - const stacksToDelete = await this.deleteableStacks(this.stackNamePrefix); - // Bootstrap stacks have buckets that need to be cleaned - const bucketNames = stacksToDelete.map(stack => aws_helpers_1.outputFromStack('BucketName', stack)).filter(defined); - await Promise.all(bucketNames.map(b => this.aws.emptyBucket(b))); - // Bootstrap stacks have ECR repositories with images which should be deleted - const imageRepositoryNames = stacksToDelete.map(stack => aws_helpers_1.outputFromStack('ImageRepositoryName', stack)).filter(defined); - await Promise.all(imageRepositoryNames.map(r => this.aws.deleteImageRepository(r))); - await this.aws.deleteStacks(...stacksToDelete.map(s => s.StackName)); - // We might have leaked some buckets by upgrading the bootstrap stack. Be - // sure to clean everything. - for (const bucket of this.bucketsToDelete) { - await this.aws.deleteBucket(bucket); - } - // If the tests completed successfully, happily delete the fixture - // (otherwise leave it for humans to inspect) - if (success) { - rimraf(this.integTestDir); - } - } - /** - * Return the stacks starting with our testing prefix that should be deleted - */ - async deleteableStacks(prefix) { - var _a; - const statusFilter = [ - 'CREATE_IN_PROGRESS', 'CREATE_FAILED', 'CREATE_COMPLETE', - 'ROLLBACK_IN_PROGRESS', 'ROLLBACK_FAILED', 'ROLLBACK_COMPLETE', - 'DELETE_FAILED', - 'UPDATE_IN_PROGRESS', 'UPDATE_COMPLETE_CLEANUP_IN_PROGRESS', - 'UPDATE_COMPLETE', 'UPDATE_ROLLBACK_IN_PROGRESS', - 'UPDATE_ROLLBACK_FAILED', - 'UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS', - 'UPDATE_ROLLBACK_COMPLETE', 'REVIEW_IN_PROGRESS', - 'IMPORT_IN_PROGRESS', 'IMPORT_COMPLETE', - 'IMPORT_ROLLBACK_IN_PROGRESS', 'IMPORT_ROLLBACK_FAILED', - 'IMPORT_ROLLBACK_COMPLETE', - ]; - const response = await this.aws.cloudFormation('describeStacks', {}); - return ((_a = response.Stacks) !== null && _a !== void 0 ? _a : []) - .filter(s => s.StackName.startsWith(prefix)) - .filter(s => statusFilter.includes(s.StackStatus)) - .filter(s => s.RootId === undefined); // Only delete parent stacks. Nested stacks are deleted in the process - } -} -exports.TestFixture = TestFixture; -/** - * Perform a one-time quick sanity check that the AWS clients has properly configured credentials - * - * If we don't do this, calls are going to fail and they'll be retried and everything will take - * forever before the user notices a simple misconfiguration. - * - * We can't check for the presence of environment variables since credentials could come from - * anywhere, so do simple account retrieval. - * - * Only do it once per process. - */ -async function sanityCheck(aws) { - if (sanityChecked === undefined) { - try { - await aws.account(); - sanityChecked = true; - } - catch (e) { - sanityChecked = false; - throw new Error(`AWS credentials probably not configured, got error: ${e.message}`); - } - } - if (!sanityChecked) { - throw new Error('AWS credentials probably not configured, see previous error'); - } -} -let sanityChecked; -/** - * Make sure that the given environment is bootstrapped - * - * Since we go striping across regions, it's going to suck doing this - * by hand so let's just mass-automate it. - */ -async function ensureBootstrapped(fixture) { - // Old-style bootstrap stack with default name - if (await fixture.aws.stackStatus('CDKToolkit') === undefined) { - await fixture.cdk(['bootstrap', `aws://${await fixture.aws.account()}/${fixture.aws.region}`]); - } -} -/** - * A shell command that does what you want - * - * Is platform-aware, handles errors nicely. - */ -async function shell(command, options = {}) { - var _a, _b; - if (options.modEnv && options.env) { - throw new Error('Use either env or modEnv but not both'); - } - (_a = options.output) === null || _a === void 0 ? void 0 : _a.write(`💻 ${command.join(' ')}\n`); - const env = (_b = options.env) !== null && _b !== void 0 ? _b : (options.modEnv ? { ...process.env, ...options.modEnv } : undefined); - const child = child_process.spawn(command[0], command.slice(1), { - ...options, - env, - // Need this for Windows where we want .cmd and .bat to be found as well. - shell: true, - stdio: ['ignore', 'pipe', 'pipe'], - }); - return new Promise((resolve, reject) => { - const stdout = new Array(); - const stderr = new Array(); - child.stdout.on('data', chunk => { - var _a; - (_a = options.output) === null || _a === void 0 ? void 0 : _a.write(chunk); - stdout.push(chunk); - }); - child.stderr.on('data', chunk => { - var _a, _b; - (_a = options.output) === null || _a === void 0 ? void 0 : _a.write(chunk); - if ((_b = options.captureStderr) !== null && _b !== void 0 ? _b : true) { - stderr.push(chunk); - } - }); - child.once('error', reject); - child.once('close', code => { - if (code === 0 || options.allowErrExit) { - resolve((Buffer.concat(stdout).toString('utf-8') + Buffer.concat(stderr).toString('utf-8')).trim()); - } - else { - reject(new Error(`'${command.join(' ')}' exited with error code ${code}`)); - } - }); - }); -} -exports.shell = shell; -function defined(x) { - return x !== undefined; -} -/** - * rm -rf reimplementation, don't want to depend on an NPM package for this - */ -function rimraf(fsPath) { - try { - const isDir = fs.lstatSync(fsPath).isDirectory(); - if (isDir) { - for (const file of fs.readdirSync(fsPath)) { - rimraf(path.join(fsPath, file)); - } - fs.rmdirSync(fsPath); - } - else { - fs.unlinkSync(fsPath); - } - } - catch (e) { - // We will survive ENOENT - if (e.code !== 'ENOENT') { - throw e; - } - } -} -exports.rimraf = rimraf; -function randomString() { - // Crazy - return Math.random().toString(36).replace(/[^a-z0-9]+/g, ''); -} -exports.randomString = randomString; -//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cdk-helpers.js","sourceRoot":"","sources":["cdk-helpers.ts"],"names":[],"mappings":"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","sourcesContent":["import * as child_process from 'child_process';\nimport * as fs from 'fs';\nimport * as os from 'os';\nimport * as path from 'path';\nimport { outputFromStack, AwsClients } from './aws-helpers';\nimport { ResourcePool } from './resource-pool';\nimport { TestContext } from './test-helpers';\n\nconst REGIONS = process.env.AWS_REGIONS\n  ? process.env.AWS_REGIONS.split(',')\n  : [process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION ?? 'us-east-1'];\n\nprocess.stdout.write(`Using regions: ${REGIONS}\\n`);\n\nconst REGION_POOL = new ResourcePool(REGIONS);\n\n\nexport type AwsContext = { readonly aws: AwsClients };\n\n/**\n * Higher order function to execute a block with an AWS client setup\n *\n * Allocate the next region from the REGION pool and dispose it afterwards.\n */\nexport function withAws<A extends TestContext>(block: (context: A & AwsContext) => Promise<void>) {\n  return (context: A) => REGION_POOL.using(async (region) => {\n    const aws = await AwsClients.forRegion(region, context.output);\n    await sanityCheck(aws);\n\n    return block({ ...context, aws });\n  });\n}\n\n/**\n * Higher order function to execute a block with a CDK app fixture\n *\n * Requires an AWS client to be passed in.\n *\n * For backwards compatibility with existing tests (so we don't have to change\n * too much) the inner block is expecte to take a `TestFixture` object.\n */\nexport function withCdkApp<A extends TestContext & AwsContext>(block: (context: TestFixture) => Promise<void>) {\n  return async (context: A) => {\n    const randy = randomString();\n    const stackNamePrefix = `cdktest-${randy}`;\n    const integTestDir = path.join(os.tmpdir(), `cdk-integ-${randy}`);\n\n    context.output.write(` Stack prefix:   ${stackNamePrefix}\\n`);\n    context.output.write(` Test directory: ${integTestDir}\\n`);\n    context.output.write(` Region:         ${context.aws.region}\\n`);\n\n    await cloneDirectory(path.join(__dirname, 'app'), integTestDir, context.output);\n    const fixture = new TestFixture(\n      integTestDir,\n      stackNamePrefix,\n      context.output,\n      context.aws);\n\n    let success = true;\n    try {\n      await fixture.shell(['npm', 'install',\n        '@aws-cdk/core',\n        '@aws-cdk/aws-sns',\n        '@aws-cdk/aws-iam',\n        '@aws-cdk/aws-lambda',\n        '@aws-cdk/aws-ssm',\n        '@aws-cdk/aws-ecr-assets',\n        '@aws-cdk/aws-cloudformation',\n        '@aws-cdk/aws-ec2']);\n\n      await ensureBootstrapped(fixture);\n\n      await block(fixture);\n    } catch (e) {\n      success = false;\n      throw e;\n    } finally {\n      await fixture.dispose(success);\n    }\n  };\n}\n\n/**\n * Default test fixture for most (all?) integ tests\n *\n * It's a composition of withAws/withCdkApp, expecting the test block to take a `TestFixture`\n * object.\n *\n * We could have put `withAws(withCdkApp(fixture => { /... actual test here.../ }))` in every\n * test declaration but centralizing it is going to make it convenient to modify in the future.\n */\nexport function withDefaultFixture(block: (context: TestFixture) => Promise<void>) {\n  return withAws<TestContext>(withCdkApp(block));\n  //              ^~~~~~ this is disappointing TypeScript! Feels like you should have been able to derive this.\n}\n\nexport interface ShellOptions extends child_process.SpawnOptions {\n  /**\n   * Properties to add to 'env'\n   */\n  modEnv?: Record<string, string>;\n\n  /**\n   * Don't fail when exiting with an error\n   *\n   * @default false\n   */\n  allowErrExit?: boolean;\n\n  /**\n   * Whether to capture stderr\n   *\n   * @default true\n   */\n  captureStderr?: boolean;\n\n  /**\n   * Pass output here\n   */\n  output?: NodeJS.WritableStream;\n}\n\nexport interface CdkCliOptions extends ShellOptions {\n  options?: string[];\n  neverRequireApproval?: boolean;\n}\n\n/**\n * Prepare a target dir byreplicating a source directory\n */\nexport async function cloneDirectory(source: string, target: string, output?: NodeJS.WritableStream) {\n  await shell(['rm', '-rf', target], { output });\n  await shell(['mkdir', '-p', target], { output });\n  await shell(['cp', '-R', source + '/*', target], { output });\n}\n\nexport class TestFixture {\n  public readonly qualifier = randomString().substr(0, 10);\n  private readonly bucketsToDelete = new Array<string>();\n\n  constructor(\n    public readonly integTestDir: string,\n    public readonly stackNamePrefix: string,\n    public readonly output: NodeJS.WritableStream,\n    public readonly aws: AwsClients) {\n  }\n\n  public log(s: string) {\n    this.output.write(`${s}\\n`);\n  }\n\n  public async shell(command: string[], options: Omit<ShellOptions, 'cwd'|'output'> = {}): Promise<string> {\n    return shell(command, {\n      output: this.output,\n      cwd: this.integTestDir,\n      ...options,\n    });\n  }\n\n  public async cdkDeploy(stackNames: string | string[], options: CdkCliOptions = {}) {\n    stackNames = typeof stackNames === 'string' ? [stackNames] : stackNames;\n\n    const neverRequireApproval = options.neverRequireApproval ?? true;\n\n    return this.cdk(['deploy',\n      ...(neverRequireApproval ? ['--require-approval=never'] : []), // Default to no approval in an unattended test\n      ...(options.options ?? []),\n      ...this.fullStackName(stackNames)], options);\n  }\n\n  public async cdkDestroy(stackNames: string | string[], options: CdkCliOptions = {}) {\n    stackNames = typeof stackNames === 'string' ? [stackNames] : stackNames;\n\n    return this.cdk(['destroy',\n      '-f', // We never want a prompt in an unattended test\n      ...(options.options ?? []),\n      ...this.fullStackName(stackNames)], options);\n  }\n\n  public async cdk(args: string[], options: CdkCliOptions = {}) {\n    return this.shell(['cdk', ...args], {\n      ...options,\n      modEnv: {\n        AWS_REGION: this.aws.region,\n        AWS_DEFAULT_REGION: this.aws.region,\n        STACK_NAME_PREFIX: this.stackNamePrefix,\n        ...options.modEnv,\n      },\n    });\n  }\n\n  public fullStackName(stackName: string): string;\n  public fullStackName(stackNames: string[]): string[];\n  public fullStackName(stackNames: string | string[]): string | string[] {\n    if (typeof stackNames === 'string') {\n      return `${this.stackNamePrefix}-${stackNames}`;\n    } else {\n      return stackNames.map(s => `${this.stackNamePrefix}-${s}`);\n    }\n  }\n\n  /**\n   * Append this to the list of buckets to potentially delete\n   *\n   * At the end of a test, we clean up buckets that may not have gotten destroyed\n   * (for whatever reason).\n   */\n  public rememberToDeleteBucket(bucketName: string) {\n    this.bucketsToDelete.push(bucketName);\n  }\n\n  /**\n   * Cleanup leftover stacks and buckets\n   */\n  public async dispose(success: boolean) {\n    const stacksToDelete = await this.deleteableStacks(this.stackNamePrefix);\n\n    // Bootstrap stacks have buckets that need to be cleaned\n    const bucketNames = stacksToDelete.map(stack => outputFromStack('BucketName', stack)).filter(defined);\n    await Promise.all(bucketNames.map(b => this.aws.emptyBucket(b)));\n\n    // Bootstrap stacks have ECR repositories with images which should be deleted\n    const imageRepositoryNames = stacksToDelete.map(stack => outputFromStack('ImageRepositoryName', stack)).filter(defined);\n    await Promise.all(imageRepositoryNames.map(r => this.aws.deleteImageRepository(r)));\n\n    await this.aws.deleteStacks(...stacksToDelete.map(s => s.StackName));\n\n    // We might have leaked some buckets by upgrading the bootstrap stack. Be\n    // sure to clean everything.\n    for (const bucket of this.bucketsToDelete) {\n      await this.aws.deleteBucket(bucket);\n    }\n\n    // If the tests completed successfully, happily delete the fixture\n    // (otherwise leave it for humans to inspect)\n    if (success) {\n      rimraf(this.integTestDir);\n    }\n  }\n\n  /**\n   * Return the stacks starting with our testing prefix that should be deleted\n   */\n  private async deleteableStacks(prefix: string): Promise<AWS.CloudFormation.Stack[]> {\n    const statusFilter = [\n      'CREATE_IN_PROGRESS', 'CREATE_FAILED', 'CREATE_COMPLETE',\n      'ROLLBACK_IN_PROGRESS', 'ROLLBACK_FAILED', 'ROLLBACK_COMPLETE',\n      'DELETE_FAILED',\n      'UPDATE_IN_PROGRESS', 'UPDATE_COMPLETE_CLEANUP_IN_PROGRESS',\n      'UPDATE_COMPLETE', 'UPDATE_ROLLBACK_IN_PROGRESS',\n      'UPDATE_ROLLBACK_FAILED',\n      'UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS',\n      'UPDATE_ROLLBACK_COMPLETE', 'REVIEW_IN_PROGRESS',\n      'IMPORT_IN_PROGRESS', 'IMPORT_COMPLETE',\n      'IMPORT_ROLLBACK_IN_PROGRESS', 'IMPORT_ROLLBACK_FAILED',\n      'IMPORT_ROLLBACK_COMPLETE',\n    ];\n\n    const response = await this.aws.cloudFormation('describeStacks', {});\n\n    return (response.Stacks ?? [])\n      .filter(s => s.StackName.startsWith(prefix))\n      .filter(s => statusFilter.includes(s.StackStatus))\n      .filter(s => s.RootId === undefined); // Only delete parent stacks. Nested stacks are deleted in the process\n  }\n}\n\n/**\n * Perform a one-time quick sanity check that the AWS clients has properly configured credentials\n *\n * If we don't do this, calls are going to fail and they'll be retried and everything will take\n * forever before the user notices a simple misconfiguration.\n *\n * We can't check for the presence of environment variables since credentials could come from\n * anywhere, so do simple account retrieval.\n *\n * Only do it once per process.\n */\nasync function sanityCheck(aws: AwsClients) {\n  if (sanityChecked === undefined) {\n    try {\n      await aws.account();\n      sanityChecked = true;\n    } catch (e) {\n      sanityChecked = false;\n      throw new Error(`AWS credentials probably not configured, got error: ${e.message}`);\n    }\n  }\n  if (!sanityChecked) {\n    throw new Error('AWS credentials probably not configured, see previous error');\n  }\n}\nlet sanityChecked: boolean | undefined;\n\n/**\n * Make sure that the given environment is bootstrapped\n *\n * Since we go striping across regions, it's going to suck doing this\n * by hand so let's just mass-automate it.\n */\nasync function ensureBootstrapped(fixture: TestFixture) {\n  // Old-style bootstrap stack with default name\n  if (await fixture.aws.stackStatus('CDKToolkit') === undefined) {\n    await fixture.cdk(['bootstrap', `aws://${await fixture.aws.account()}/${fixture.aws.region}`]);\n  }\n}\n\n/**\n * A shell command that does what you want\n *\n * Is platform-aware, handles errors nicely.\n */\nexport async function shell(command: string[], options: ShellOptions = {}): Promise<string> {\n  if (options.modEnv && options.env) {\n    throw new Error('Use either env or modEnv but not both');\n  }\n\n  options.output?.write(`💻 ${command.join(' ')}\\n`);\n\n  const env = options.env ?? (options.modEnv ? { ...process.env, ...options.modEnv } : undefined);\n\n  const child = child_process.spawn(command[0], command.slice(1), {\n    ...options,\n    env,\n    // Need this for Windows where we want .cmd and .bat to be found as well.\n    shell: true,\n    stdio: ['ignore', 'pipe', 'pipe'],\n  });\n\n  return new Promise<string>((resolve, reject) => {\n    const stdout = new Array<Buffer>();\n    const stderr = new Array<Buffer>();\n\n    child.stdout!.on('data', chunk => {\n      options.output?.write(chunk);\n      stdout.push(chunk);\n    });\n\n    child.stderr!.on('data', chunk => {\n      options.output?.write(chunk);\n      if (options.captureStderr ?? true) {\n        stderr.push(chunk);\n      }\n    });\n\n    child.once('error', reject);\n\n    child.once('close', code => {\n      if (code === 0 || options.allowErrExit) {\n        resolve((Buffer.concat(stdout).toString('utf-8') + Buffer.concat(stderr).toString('utf-8')).trim());\n      } else {\n        reject(new Error(`'${command.join(' ')}' exited with error code ${code}`));\n      }\n    });\n  });\n}\n\nfunction defined<A>(x: A): x is NonNullable<A> {\n  return x !== undefined;\n}\n\n/**\n * rm -rf reimplementation, don't want to depend on an NPM package for this\n */\nexport function rimraf(fsPath: string) {\n  try {\n    const isDir = fs.lstatSync(fsPath).isDirectory();\n\n    if (isDir) {\n      for (const file of fs.readdirSync(fsPath)) {\n        rimraf(path.join(fsPath, file));\n      }\n      fs.rmdirSync(fsPath);\n    } else {\n      fs.unlinkSync(fsPath);\n    }\n  } catch (e) {\n    // We will survive ENOENT\n    if (e.code !== 'ENOENT') { throw e; }\n  }\n}\n\nexport function randomString() {\n  // Crazy\n  return Math.random().toString(36).replace(/[^a-z0-9]+/g, '');\n}"]} diff --git a/packages/aws-cdk/test/integ/cli/cdk-helpers.ts b/packages/aws-cdk/test/integ/cli/cdk-helpers.ts index 30828ce0f7522..66c6799164fd8 100644 --- a/packages/aws-cdk/test/integ/cli/cdk-helpers.ts +++ b/packages/aws-cdk/test/integ/cli/cdk-helpers.ts @@ -178,7 +178,7 @@ export class TestFixture { } public async cdk(args: string[], options: CdkCliOptions = {}) { - return this.shell(['cdk', '-v', ...args], { + return this.shell(['cdk', ...args], { ...options, modEnv: { AWS_REGION: this.aws.region, From 4a4c154aa433a5c99994398c5b6798aaea75b7b6 Mon Sep 17 00:00:00 2001 From: Hiroyoshi HOUCHI Date: Fri, 25 Sep 2020 03:27:15 +0900 Subject: [PATCH 18/29] feat(rds): add support for update and backup properties to Cluster instances (#10324) fixes #9926 Added the following parameters to DatabaseCluster. * AutoMinorVersionUpgrade * AllowMajorVersionUpgrade * DeleteAutomatedBackups #10092 as a reference, only defined simple parameters. ---- *By submitting this pull request, I confirm that my contribution is made under the terms of the Apache-2.0 license* --- packages/@aws-cdk/aws-rds/lib/cluster.ts | 3 + packages/@aws-cdk/aws-rds/lib/props.ts | 21 +++++++ .../@aws-cdk/aws-rds/test/test.cluster.ts | 63 +++++++++++++++++++ 3 files changed, 87 insertions(+) diff --git a/packages/@aws-cdk/aws-rds/lib/cluster.ts b/packages/@aws-cdk/aws-rds/lib/cluster.ts index f3f9300788e1c..6ed9b4da06b68 100644 --- a/packages/@aws-cdk/aws-rds/lib/cluster.ts +++ b/packages/@aws-cdk/aws-rds/lib/cluster.ts @@ -716,6 +716,9 @@ function createInstances(cluster: DatabaseClusterNew, props: DatabaseClusterBase dbParameterGroupName: instanceParameterGroupConfig?.parameterGroupName, monitoringInterval: props.monitoringInterval && props.monitoringInterval.toSeconds(), monitoringRoleArn: monitoringRole && monitoringRole.roleArn, + autoMinorVersionUpgrade: props.instanceProps.autoMinorVersionUpgrade, + allowMajorVersionUpgrade: props.instanceProps.allowMajorVersionUpgrade, + deleteAutomatedBackups: props.instanceProps.deleteAutomatedBackups, }); // If removalPolicy isn't explicitly set, diff --git a/packages/@aws-cdk/aws-rds/lib/props.ts b/packages/@aws-cdk/aws-rds/lib/props.ts index 81a27a1e05d70..e9be6be583af9 100644 --- a/packages/@aws-cdk/aws-rds/lib/props.ts +++ b/packages/@aws-cdk/aws-rds/lib/props.ts @@ -63,6 +63,27 @@ export interface InstanceProps { * @default - default master key */ readonly performanceInsightEncryptionKey?: kms.IKey; + + /** + * Whether to enable automatic upgrade of minor version for the DB instance. + * + * @default - true + */ + readonly autoMinorVersionUpgrade?: boolean; + + /** + * Whether to allow upgrade of major version for the DB instance. + * + * @default - false + */ + readonly allowMajorVersionUpgrade?: boolean; + + /** + * Whether to remove automated backups immediately after the DB instance is deleted for the DB instance. + * + * @default - true + */ + readonly deleteAutomatedBackups?: boolean; } /** diff --git a/packages/@aws-cdk/aws-rds/test/test.cluster.ts b/packages/@aws-cdk/aws-rds/test/test.cluster.ts index 82dce160e7128..47b9ce619fe17 100644 --- a/packages/@aws-cdk/aws-rds/test/test.cluster.ts +++ b/packages/@aws-cdk/aws-rds/test/test.cluster.ts @@ -373,6 +373,69 @@ export = { }, }, + 'cluster with disable automatic upgrade of minor version'(test: Test) { + // GIVEN + const stack = testStack(); + const vpc = new ec2.Vpc(stack, 'VPC'); + + // WHEN + new DatabaseCluster(stack, 'Database', { + engine: DatabaseClusterEngine.AURORA, + instanceProps: { + autoMinorVersionUpgrade: false, + vpc, + }, + }); + + expect(stack).to(haveResource('AWS::RDS::DBInstance', { + AutoMinorVersionUpgrade: false, + })); + + test.done(); + }, + + 'cluster with allow upgrade of major version'(test: Test) { + // GIVEN + const stack = testStack(); + const vpc = new ec2.Vpc(stack, 'VPC'); + + // WHEN + new DatabaseCluster(stack, 'Database', { + engine: DatabaseClusterEngine.AURORA, + instanceProps: { + allowMajorVersionUpgrade: true, + vpc, + }, + }); + + expect(stack).to(haveResourceLike('AWS::RDS::DBInstance', { + AllowMajorVersionUpgrade: true, + })); + + test.done(); + }, + + 'cluster with disallow remove backups'(test: Test) { + // GIVEN + const stack = testStack(); + const vpc = new ec2.Vpc(stack, 'VPC'); + + // WHEN + new DatabaseCluster(stack, 'Database', { + engine: DatabaseClusterEngine.AURORA, + instanceProps: { + deleteAutomatedBackups: false, + vpc, + }, + }); + + expect(stack).to(haveResourceLike('AWS::RDS::DBInstance', { + DeleteAutomatedBackups: false, + })); + + test.done(); + }, + 'create a cluster using a specific version of MySQL'(test: Test) { // GIVEN const stack = testStack(); From e349004a522e2123c1e93bd3402dd7c3f9c5c17c Mon Sep 17 00:00:00 2001 From: Clement Allen Date: Thu, 24 Sep 2020 21:52:33 +0100 Subject: [PATCH 19/29] feat(ecs-patterns): allow passthrough of security groups to service (#10501) Closes #8953 ---- *By submitting this pull request, I confirm that my contribution is made under the terms of the Apache-2.0 license* --- packages/@aws-cdk/aws-ecs-patterns/README.md | 2 + ...plication-load-balanced-fargate-service.ts | 9 ++++ .../test.load-balanced-fargate-service.ts | 44 +++++++++++++++++++ 3 files changed, 55 insertions(+) diff --git a/packages/@aws-cdk/aws-ecs-patterns/README.md b/packages/@aws-cdk/aws-ecs-patterns/README.md index ffee66fe6cc96..cd88ea5133292 100644 --- a/packages/@aws-cdk/aws-ecs-patterns/README.md +++ b/packages/@aws-cdk/aws-ecs-patterns/README.md @@ -62,6 +62,8 @@ You can customize the health check for your target group; otherwise it defaults Fargate services will use the `LATEST` platform version by default, but you can override by providing a value for the `platformVersion` property in the constructor. +Fargate services use the default VPC Security Group unless one or more are provided using the `securityGroups` property in the constructor. + By setting `redirectHTTP` to true, CDK will automatically create a listener on port 80 that redirects HTTP traffic to the HTTPS port. Additionally, if more than one application target group are needed, instantiate one of the following: diff --git a/packages/@aws-cdk/aws-ecs-patterns/lib/fargate/application-load-balanced-fargate-service.ts b/packages/@aws-cdk/aws-ecs-patterns/lib/fargate/application-load-balanced-fargate-service.ts index baa8a191410dc..d2b6ed7219fb0 100644 --- a/packages/@aws-cdk/aws-ecs-patterns/lib/fargate/application-load-balanced-fargate-service.ts +++ b/packages/@aws-cdk/aws-ecs-patterns/lib/fargate/application-load-balanced-fargate-service.ts @@ -1,3 +1,4 @@ +import { ISecurityGroup } from '@aws-cdk/aws-ec2'; import { FargatePlatformVersion, FargateService, FargateTaskDefinition } from '@aws-cdk/aws-ecs'; import { Construct } from '@aws-cdk/core'; import { ApplicationLoadBalancedServiceBase, ApplicationLoadBalancedServiceBaseProps } from '../base/application-load-balanced-service-base'; @@ -75,6 +76,13 @@ export interface ApplicationLoadBalancedFargateServiceProps extends ApplicationL * @default Latest */ readonly platformVersion?: FargatePlatformVersion; + + /** + * The security groups to associate with the service. If you do not specify a security group, the default security group for the VPC is used. + * + * @default - A new security group is created. + */ + readonly securityGroups?: ISecurityGroup[]; } /** @@ -151,6 +159,7 @@ export class ApplicationLoadBalancedFargateService extends ApplicationLoadBalanc enableECSManagedTags: props.enableECSManagedTags, cloudMapOptions: props.cloudMapOptions, platformVersion: props.platformVersion, + securityGroups: props.securityGroups, }); this.addServiceAsTarget(this.service); } diff --git a/packages/@aws-cdk/aws-ecs-patterns/test/fargate/test.load-balanced-fargate-service.ts b/packages/@aws-cdk/aws-ecs-patterns/test/fargate/test.load-balanced-fargate-service.ts index 60559f4be1120..12b3adea9dcc1 100644 --- a/packages/@aws-cdk/aws-ecs-patterns/test/fargate/test.load-balanced-fargate-service.ts +++ b/packages/@aws-cdk/aws-ecs-patterns/test/fargate/test.load-balanced-fargate-service.ts @@ -637,4 +637,48 @@ export = { test.done(); }, + 'passing in previously created security groups to ALB Fargate Service'(test: Test) { + // GIVEN + const stack = new cdk.Stack(); + const vpc = new ec2.Vpc(stack, 'Vpc'); + const cluster = new ecs.Cluster(stack, 'Cluster', { vpc, clusterName: 'MyCluster' }); + const securityGroup = new ec2.SecurityGroup(stack, 'SecurityGroup', { + allowAllOutbound: false, + description: 'Example', + securityGroupName: 'Rolly', + vpc, + }); + + // WHEN + new ecsPatterns.ApplicationLoadBalancedFargateService(stack, 'Service', { + cluster, + taskImageOptions: { + image: ecs.ContainerImage.fromRegistry('amazon/amazon-ecs-sample'), + }, + securityGroups: [securityGroup], + }); + + // THEN + expect(stack).to(haveResourceLike('AWS::ECS::Service', { + LaunchType: 'FARGATE', + })); + expect(stack).to(haveResource('AWS::EC2::SecurityGroup', { + GroupDescription: 'Example', + GroupName: 'Rolly', + SecurityGroupEgress: [ + { + CidrIp: '255.255.255.255/32', + Description: 'Disallow all traffic', + FromPort: 252, + IpProtocol: 'icmp', + ToPort: 86, + }, + ], + VpcId: { + Ref: 'Vpc8378EB38', + }, + })); + test.done(); + }, + }; From b23ce03121466b686dfdd25731ea107e4e27d17b Mon Sep 17 00:00:00 2001 From: Eli Polonsky Date: Fri, 25 Sep 2020 17:19:43 +0300 Subject: [PATCH 20/29] fix(eks): `KubernetesPatch` and `FargateCluster` creates a circular dependency and breaks deployment (#10536) In version [`1.62.0`](https://github.com/aws/aws-cdk/releases/tag/v1.62.0) we introduced the ability to run `kubectl` commands on imported clusters. (See https://github.com/aws/aws-cdk/pull/9802). Part of this change included some refactoring with regards to how we use and create the `KubectlProvider`. Looks like we didn't consistently apply the same logic across all constructs that use it. Case in point: https://github.com/aws/aws-cdk/blob/e349004a522e2123c1e93bd3402dd7c3f9c5c17c/packages/%40aws-cdk/aws-eks/lib/k8s-manifest.ts#L58 Notice that here we use `this` as the scope to the `getOrCreate` call. Same goes for: https://github.com/aws/aws-cdk/blob/e349004a522e2123c1e93bd3402dd7c3f9c5c17c/packages/%40aws-cdk/aws-eks/lib/k8s-object-value.ts#L64 However, `KubernetesPatch` use `scope` instead. https://github.com/aws/aws-cdk/blob/e349004a522e2123c1e93bd3402dd7c3f9c5c17c/packages/%40aws-cdk/aws-eks/lib/k8s-patch.ts#L74 This means that the entire `scope` of the `KubernetesPatch` now depends, among others, on the `kubectlBarrier`. The scope will usually be either the cluster itself (when using `FargateCluster`), or the entire stack (when using `new KubernetesPatch`). In any case, the scope will most likely contain the cluster VPC. This creates the following dependency cycle: `Cluster => ClusterVpc => KubectlBarrier => Cluster`. The fix aligns the `KubernetesPatch` behavior to all other `kubectl` constructs and uses `this` as the scope, which will only add dependency on the barrier to the custom resource representing the patch. Fixes https://github.com/aws/aws-cdk/issues/10528 Fixes https://github.com/aws/aws-cdk/issues/10537 ---- *By submitting this pull request, I confirm that my contribution is made under the terms of the Apache-2.0 license* --- packages/@aws-cdk/aws-eks/lib/k8s-patch.ts | 2 +- .../test/integ.fargate-cluster.expected.json | 1388 +++++++++++++++++ .../aws-eks/test/integ.fargate-cluster.ts | 21 + .../@aws-cdk/aws-eks/test/test.k8s-patch.ts | 6 +- 4 files changed, 1415 insertions(+), 2 deletions(-) create mode 100644 packages/@aws-cdk/aws-eks/test/integ.fargate-cluster.expected.json create mode 100644 packages/@aws-cdk/aws-eks/test/integ.fargate-cluster.ts diff --git a/packages/@aws-cdk/aws-eks/lib/k8s-patch.ts b/packages/@aws-cdk/aws-eks/lib/k8s-patch.ts index d35de30a18fe5..88db0f4352f11 100644 --- a/packages/@aws-cdk/aws-eks/lib/k8s-patch.ts +++ b/packages/@aws-cdk/aws-eks/lib/k8s-patch.ts @@ -71,7 +71,7 @@ export class KubernetesPatch extends Construct { super(scope, id); const stack = Stack.of(this); - const provider = KubectlProvider.getOrCreate(scope, props.cluster); + const provider = KubectlProvider.getOrCreate(this, props.cluster); new CustomResource(this, 'Resource', { serviceToken: provider.serviceToken, diff --git a/packages/@aws-cdk/aws-eks/test/integ.fargate-cluster.expected.json b/packages/@aws-cdk/aws-eks/test/integ.fargate-cluster.expected.json new file mode 100644 index 0000000000000..de489ef72836e --- /dev/null +++ b/packages/@aws-cdk/aws-eks/test/integ.fargate-cluster.expected.json @@ -0,0 +1,1388 @@ +{ + "Resources": { + "FargateClusterDefaultVpcE69D3A13": { + "Type": "AWS::EC2::VPC", + "Properties": { + "CidrBlock": "10.0.0.0/16", + "EnableDnsHostnames": true, + "EnableDnsSupport": true, + "InstanceTenancy": "default", + "Tags": [ + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc" + } + ] + } + }, + "FargateClusterDefaultVpcPublicSubnet1Subnet96AFDABC": { + "Type": "AWS::EC2::Subnet", + "Properties": { + "CidrBlock": "10.0.0.0/19", + "VpcId": { + "Ref": "FargateClusterDefaultVpcE69D3A13" + }, + "AvailabilityZone": "test-region-1a", + "MapPublicIpOnLaunch": true, + "Tags": [ + { + "Key": "aws-cdk:subnet-name", + "Value": "Public" + }, + { + "Key": "aws-cdk:subnet-type", + "Value": "Public" + }, + { + "Key": "kubernetes.io/role/elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PublicSubnet1" + } + ] + } + }, + "FargateClusterDefaultVpcPublicSubnet1RouteTableC2D2B434": { + "Type": "AWS::EC2::RouteTable", + "Properties": { + "VpcId": { + "Ref": "FargateClusterDefaultVpcE69D3A13" + }, + "Tags": [ + { + "Key": "kubernetes.io/role/elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PublicSubnet1" + } + ] + } + }, + "FargateClusterDefaultVpcPublicSubnet1RouteTableAssociation43821F5B": { + "Type": "AWS::EC2::SubnetRouteTableAssociation", + "Properties": { + "RouteTableId": { + "Ref": "FargateClusterDefaultVpcPublicSubnet1RouteTableC2D2B434" + }, + "SubnetId": { + "Ref": "FargateClusterDefaultVpcPublicSubnet1Subnet96AFDABC" + } + } + }, + "FargateClusterDefaultVpcPublicSubnet1DefaultRouteA0A93C70": { + "Type": "AWS::EC2::Route", + "Properties": { + "RouteTableId": { + "Ref": "FargateClusterDefaultVpcPublicSubnet1RouteTableC2D2B434" + }, + "DestinationCidrBlock": "0.0.0.0/0", + "GatewayId": { + "Ref": "FargateClusterDefaultVpcIGWFD9278DA" + } + }, + "DependsOn": [ + "FargateClusterDefaultVpcVPCGWA7F012E1" + ] + }, + "FargateClusterDefaultVpcPublicSubnet1EIP0093A4E0": { + "Type": "AWS::EC2::EIP", + "Properties": { + "Domain": "vpc", + "Tags": [ + { + "Key": "kubernetes.io/role/elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PublicSubnet1" + } + ] + } + }, + "FargateClusterDefaultVpcPublicSubnet1NATGatewayEC4DEB51": { + "Type": "AWS::EC2::NatGateway", + "Properties": { + "AllocationId": { + "Fn::GetAtt": [ + "FargateClusterDefaultVpcPublicSubnet1EIP0093A4E0", + "AllocationId" + ] + }, + "SubnetId": { + "Ref": "FargateClusterDefaultVpcPublicSubnet1Subnet96AFDABC" + }, + "Tags": [ + { + "Key": "kubernetes.io/role/elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PublicSubnet1" + } + ] + } + }, + "FargateClusterDefaultVpcPublicSubnet2Subnet92A9CC93": { + "Type": "AWS::EC2::Subnet", + "Properties": { + "CidrBlock": "10.0.32.0/19", + "VpcId": { + "Ref": "FargateClusterDefaultVpcE69D3A13" + }, + "AvailabilityZone": "test-region-1b", + "MapPublicIpOnLaunch": true, + "Tags": [ + { + "Key": "aws-cdk:subnet-name", + "Value": "Public" + }, + { + "Key": "aws-cdk:subnet-type", + "Value": "Public" + }, + { + "Key": "kubernetes.io/role/elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PublicSubnet2" + } + ] + } + }, + "FargateClusterDefaultVpcPublicSubnet2RouteTableEDDB89D9": { + "Type": "AWS::EC2::RouteTable", + "Properties": { + "VpcId": { + "Ref": "FargateClusterDefaultVpcE69D3A13" + }, + "Tags": [ + { + "Key": "kubernetes.io/role/elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PublicSubnet2" + } + ] + } + }, + "FargateClusterDefaultVpcPublicSubnet2RouteTableAssociationCF18C87A": { + "Type": "AWS::EC2::SubnetRouteTableAssociation", + "Properties": { + "RouteTableId": { + "Ref": "FargateClusterDefaultVpcPublicSubnet2RouteTableEDDB89D9" + }, + "SubnetId": { + "Ref": "FargateClusterDefaultVpcPublicSubnet2Subnet92A9CC93" + } + } + }, + "FargateClusterDefaultVpcPublicSubnet2DefaultRouteABE51CF2": { + "Type": "AWS::EC2::Route", + "Properties": { + "RouteTableId": { + "Ref": "FargateClusterDefaultVpcPublicSubnet2RouteTableEDDB89D9" + }, + "DestinationCidrBlock": "0.0.0.0/0", + "GatewayId": { + "Ref": "FargateClusterDefaultVpcIGWFD9278DA" + } + }, + "DependsOn": [ + "FargateClusterDefaultVpcVPCGWA7F012E1" + ] + }, + "FargateClusterDefaultVpcPublicSubnet2EIPA4C07B68": { + "Type": "AWS::EC2::EIP", + "Properties": { + "Domain": "vpc", + "Tags": [ + { + "Key": "kubernetes.io/role/elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PublicSubnet2" + } + ] + } + }, + "FargateClusterDefaultVpcPublicSubnet2NATGateway77D6A579": { + "Type": "AWS::EC2::NatGateway", + "Properties": { + "AllocationId": { + "Fn::GetAtt": [ + "FargateClusterDefaultVpcPublicSubnet2EIPA4C07B68", + "AllocationId" + ] + }, + "SubnetId": { + "Ref": "FargateClusterDefaultVpcPublicSubnet2Subnet92A9CC93" + }, + "Tags": [ + { + "Key": "kubernetes.io/role/elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PublicSubnet2" + } + ] + } + }, + "FargateClusterDefaultVpcPublicSubnet3SubnetB408ADA9": { + "Type": "AWS::EC2::Subnet", + "Properties": { + "CidrBlock": "10.0.64.0/19", + "VpcId": { + "Ref": "FargateClusterDefaultVpcE69D3A13" + }, + "AvailabilityZone": "test-region-1c", + "MapPublicIpOnLaunch": true, + "Tags": [ + { + "Key": "aws-cdk:subnet-name", + "Value": "Public" + }, + { + "Key": "aws-cdk:subnet-type", + "Value": "Public" + }, + { + "Key": "kubernetes.io/role/elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PublicSubnet3" + } + ] + } + }, + "FargateClusterDefaultVpcPublicSubnet3RouteTable4E802182": { + "Type": "AWS::EC2::RouteTable", + "Properties": { + "VpcId": { + "Ref": "FargateClusterDefaultVpcE69D3A13" + }, + "Tags": [ + { + "Key": "kubernetes.io/role/elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PublicSubnet3" + } + ] + } + }, + "FargateClusterDefaultVpcPublicSubnet3RouteTableAssociation93B95514": { + "Type": "AWS::EC2::SubnetRouteTableAssociation", + "Properties": { + "RouteTableId": { + "Ref": "FargateClusterDefaultVpcPublicSubnet3RouteTable4E802182" + }, + "SubnetId": { + "Ref": "FargateClusterDefaultVpcPublicSubnet3SubnetB408ADA9" + } + } + }, + "FargateClusterDefaultVpcPublicSubnet3DefaultRoute8341F833": { + "Type": "AWS::EC2::Route", + "Properties": { + "RouteTableId": { + "Ref": "FargateClusterDefaultVpcPublicSubnet3RouteTable4E802182" + }, + "DestinationCidrBlock": "0.0.0.0/0", + "GatewayId": { + "Ref": "FargateClusterDefaultVpcIGWFD9278DA" + } + }, + "DependsOn": [ + "FargateClusterDefaultVpcVPCGWA7F012E1" + ] + }, + "FargateClusterDefaultVpcPublicSubnet3EIP46E028EF": { + "Type": "AWS::EC2::EIP", + "Properties": { + "Domain": "vpc", + "Tags": [ + { + "Key": "kubernetes.io/role/elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PublicSubnet3" + } + ] + } + }, + "FargateClusterDefaultVpcPublicSubnet3NATGateway0AAE540F": { + "Type": "AWS::EC2::NatGateway", + "Properties": { + "AllocationId": { + "Fn::GetAtt": [ + "FargateClusterDefaultVpcPublicSubnet3EIP46E028EF", + "AllocationId" + ] + }, + "SubnetId": { + "Ref": "FargateClusterDefaultVpcPublicSubnet3SubnetB408ADA9" + }, + "Tags": [ + { + "Key": "kubernetes.io/role/elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PublicSubnet3" + } + ] + } + }, + "FargateClusterDefaultVpcPrivateSubnet1Subnet50EA43AA": { + "Type": "AWS::EC2::Subnet", + "Properties": { + "CidrBlock": "10.0.96.0/19", + "VpcId": { + "Ref": "FargateClusterDefaultVpcE69D3A13" + }, + "AvailabilityZone": "test-region-1a", + "MapPublicIpOnLaunch": false, + "Tags": [ + { + "Key": "aws-cdk:subnet-name", + "Value": "Private" + }, + { + "Key": "aws-cdk:subnet-type", + "Value": "Private" + }, + { + "Key": "kubernetes.io/role/internal-elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PrivateSubnet1" + } + ] + } + }, + "FargateClusterDefaultVpcPrivateSubnet1RouteTableA42013EB": { + "Type": "AWS::EC2::RouteTable", + "Properties": { + "VpcId": { + "Ref": "FargateClusterDefaultVpcE69D3A13" + }, + "Tags": [ + { + "Key": "kubernetes.io/role/internal-elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PrivateSubnet1" + } + ] + } + }, + "FargateClusterDefaultVpcPrivateSubnet1RouteTableAssociationDC34627F": { + "Type": "AWS::EC2::SubnetRouteTableAssociation", + "Properties": { + "RouteTableId": { + "Ref": "FargateClusterDefaultVpcPrivateSubnet1RouteTableA42013EB" + }, + "SubnetId": { + "Ref": "FargateClusterDefaultVpcPrivateSubnet1Subnet50EA43AA" + } + } + }, + "FargateClusterDefaultVpcPrivateSubnet1DefaultRouteE93D7B93": { + "Type": "AWS::EC2::Route", + "Properties": { + "RouteTableId": { + "Ref": "FargateClusterDefaultVpcPrivateSubnet1RouteTableA42013EB" + }, + "DestinationCidrBlock": "0.0.0.0/0", + "NatGatewayId": { + "Ref": "FargateClusterDefaultVpcPublicSubnet1NATGatewayEC4DEB51" + } + } + }, + "FargateClusterDefaultVpcPrivateSubnet2Subnet0C9D6154": { + "Type": "AWS::EC2::Subnet", + "Properties": { + "CidrBlock": "10.0.128.0/19", + "VpcId": { + "Ref": "FargateClusterDefaultVpcE69D3A13" + }, + "AvailabilityZone": "test-region-1b", + "MapPublicIpOnLaunch": false, + "Tags": [ + { + "Key": "aws-cdk:subnet-name", + "Value": "Private" + }, + { + "Key": "aws-cdk:subnet-type", + "Value": "Private" + }, + { + "Key": "kubernetes.io/role/internal-elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PrivateSubnet2" + } + ] + } + }, + "FargateClusterDefaultVpcPrivateSubnet2RouteTable1691B33C": { + "Type": "AWS::EC2::RouteTable", + "Properties": { + "VpcId": { + "Ref": "FargateClusterDefaultVpcE69D3A13" + }, + "Tags": [ + { + "Key": "kubernetes.io/role/internal-elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PrivateSubnet2" + } + ] + } + }, + "FargateClusterDefaultVpcPrivateSubnet2RouteTableAssociation6C0234FE": { + "Type": "AWS::EC2::SubnetRouteTableAssociation", + "Properties": { + "RouteTableId": { + "Ref": "FargateClusterDefaultVpcPrivateSubnet2RouteTable1691B33C" + }, + "SubnetId": { + "Ref": "FargateClusterDefaultVpcPrivateSubnet2Subnet0C9D6154" + } + } + }, + "FargateClusterDefaultVpcPrivateSubnet2DefaultRouteABCE20FF": { + "Type": "AWS::EC2::Route", + "Properties": { + "RouteTableId": { + "Ref": "FargateClusterDefaultVpcPrivateSubnet2RouteTable1691B33C" + }, + "DestinationCidrBlock": "0.0.0.0/0", + "NatGatewayId": { + "Ref": "FargateClusterDefaultVpcPublicSubnet2NATGateway77D6A579" + } + } + }, + "FargateClusterDefaultVpcPrivateSubnet3Subnet1F8A52F1": { + "Type": "AWS::EC2::Subnet", + "Properties": { + "CidrBlock": "10.0.160.0/19", + "VpcId": { + "Ref": "FargateClusterDefaultVpcE69D3A13" + }, + "AvailabilityZone": "test-region-1c", + "MapPublicIpOnLaunch": false, + "Tags": [ + { + "Key": "aws-cdk:subnet-name", + "Value": "Private" + }, + { + "Key": "aws-cdk:subnet-type", + "Value": "Private" + }, + { + "Key": "kubernetes.io/role/internal-elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PrivateSubnet3" + } + ] + } + }, + "FargateClusterDefaultVpcPrivateSubnet3RouteTable7D0EEC96": { + "Type": "AWS::EC2::RouteTable", + "Properties": { + "VpcId": { + "Ref": "FargateClusterDefaultVpcE69D3A13" + }, + "Tags": [ + { + "Key": "kubernetes.io/role/internal-elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PrivateSubnet3" + } + ] + } + }, + "FargateClusterDefaultVpcPrivateSubnet3RouteTableAssociationCC0949D8": { + "Type": "AWS::EC2::SubnetRouteTableAssociation", + "Properties": { + "RouteTableId": { + "Ref": "FargateClusterDefaultVpcPrivateSubnet3RouteTable7D0EEC96" + }, + "SubnetId": { + "Ref": "FargateClusterDefaultVpcPrivateSubnet3Subnet1F8A52F1" + } + } + }, + "FargateClusterDefaultVpcPrivateSubnet3DefaultRouteEFE144B5": { + "Type": "AWS::EC2::Route", + "Properties": { + "RouteTableId": { + "Ref": "FargateClusterDefaultVpcPrivateSubnet3RouteTable7D0EEC96" + }, + "DestinationCidrBlock": "0.0.0.0/0", + "NatGatewayId": { + "Ref": "FargateClusterDefaultVpcPublicSubnet3NATGateway0AAE540F" + } + } + }, + "FargateClusterDefaultVpcIGWFD9278DA": { + "Type": "AWS::EC2::InternetGateway", + "Properties": { + "Tags": [ + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc" + } + ] + } + }, + "FargateClusterDefaultVpcVPCGWA7F012E1": { + "Type": "AWS::EC2::VPCGatewayAttachment", + "Properties": { + "VpcId": { + "Ref": "FargateClusterDefaultVpcE69D3A13" + }, + "InternetGatewayId": { + "Ref": "FargateClusterDefaultVpcIGWFD9278DA" + } + } + }, + "FargateClusterRole8E36B33A": { + "Type": "AWS::IAM::Role", + "Properties": { + "AssumeRolePolicyDocument": { + "Statement": [ + { + "Action": "sts:AssumeRole", + "Effect": "Allow", + "Principal": { + "Service": "eks.amazonaws.com" + } + } + ], + "Version": "2012-10-17" + }, + "ManagedPolicyArns": [ + { + "Fn::Join": [ + "", + [ + "arn:", + { + "Ref": "AWS::Partition" + }, + ":iam::aws:policy/AmazonEKSClusterPolicy" + ] + ] + } + ] + } + }, + "FargateClusterControlPlaneSecurityGroup1021A150": { + "Type": "AWS::EC2::SecurityGroup", + "Properties": { + "GroupDescription": "EKS Control Plane Security Group", + "SecurityGroupEgress": [ + { + "CidrIp": "0.0.0.0/0", + "Description": "Allow all outbound traffic by default", + "IpProtocol": "-1" + } + ], + "VpcId": { + "Ref": "FargateClusterDefaultVpcE69D3A13" + } + } + }, + "FargateClusterCreationRole8C524AD8": { + "Type": "AWS::IAM::Role", + "Properties": { + "AssumeRolePolicyDocument": { + "Statement": [ + { + "Action": "sts:AssumeRole", + "Effect": "Allow", + "Principal": { + "AWS": { + "Fn::Join": [ + "", + [ + "arn:", + { + "Ref": "AWS::Partition" + }, + ":iam::12345678:root" + ] + ] + } + } + } + ], + "Version": "2012-10-17" + } + }, + "DependsOn": [ + "FargateClusterDefaultVpcIGWFD9278DA", + "FargateClusterDefaultVpcPrivateSubnet1DefaultRouteE93D7B93", + "FargateClusterDefaultVpcPrivateSubnet1RouteTableA42013EB", + "FargateClusterDefaultVpcPrivateSubnet1RouteTableAssociationDC34627F", + "FargateClusterDefaultVpcPrivateSubnet1Subnet50EA43AA", + "FargateClusterDefaultVpcPrivateSubnet2DefaultRouteABCE20FF", + "FargateClusterDefaultVpcPrivateSubnet2RouteTable1691B33C", + "FargateClusterDefaultVpcPrivateSubnet2RouteTableAssociation6C0234FE", + "FargateClusterDefaultVpcPrivateSubnet2Subnet0C9D6154", + "FargateClusterDefaultVpcPrivateSubnet3DefaultRouteEFE144B5", + "FargateClusterDefaultVpcPrivateSubnet3RouteTable7D0EEC96", + "FargateClusterDefaultVpcPrivateSubnet3RouteTableAssociationCC0949D8", + "FargateClusterDefaultVpcPrivateSubnet3Subnet1F8A52F1", + "FargateClusterDefaultVpcPublicSubnet1DefaultRouteA0A93C70", + "FargateClusterDefaultVpcPublicSubnet1EIP0093A4E0", + "FargateClusterDefaultVpcPublicSubnet1NATGatewayEC4DEB51", + "FargateClusterDefaultVpcPublicSubnet1RouteTableC2D2B434", + "FargateClusterDefaultVpcPublicSubnet1RouteTableAssociation43821F5B", + "FargateClusterDefaultVpcPublicSubnet1Subnet96AFDABC", + "FargateClusterDefaultVpcPublicSubnet2DefaultRouteABE51CF2", + "FargateClusterDefaultVpcPublicSubnet2EIPA4C07B68", + "FargateClusterDefaultVpcPublicSubnet2NATGateway77D6A579", + "FargateClusterDefaultVpcPublicSubnet2RouteTableEDDB89D9", + "FargateClusterDefaultVpcPublicSubnet2RouteTableAssociationCF18C87A", + "FargateClusterDefaultVpcPublicSubnet2Subnet92A9CC93", + "FargateClusterDefaultVpcPublicSubnet3DefaultRoute8341F833", + "FargateClusterDefaultVpcPublicSubnet3EIP46E028EF", + "FargateClusterDefaultVpcPublicSubnet3NATGateway0AAE540F", + "FargateClusterDefaultVpcPublicSubnet3RouteTable4E802182", + "FargateClusterDefaultVpcPublicSubnet3RouteTableAssociation93B95514", + "FargateClusterDefaultVpcPublicSubnet3SubnetB408ADA9", + "FargateClusterDefaultVpcE69D3A13", + "FargateClusterDefaultVpcVPCGWA7F012E1" + ] + }, + "FargateClusterCreationRoleDefaultPolicy629049D0": { + "Type": "AWS::IAM::Policy", + "Properties": { + "PolicyDocument": { + "Statement": [ + { + "Action": "iam:PassRole", + "Effect": "Allow", + "Resource": { + "Fn::GetAtt": [ + "FargateClusterRole8E36B33A", + "Arn" + ] + } + }, + { + "Action": [ + "ec2:DescribeSubnets", + "ec2:DescribeRouteTables" + ], + "Effect": "Allow", + "Resource": "*" + }, + { + "Action": [ + "eks:CreateCluster", + "eks:DescribeCluster", + "eks:DescribeUpdate", + "eks:DeleteCluster", + "eks:UpdateClusterVersion", + "eks:UpdateClusterConfig", + "eks:CreateFargateProfile", + "eks:TagResource", + "eks:UntagResource" + ], + "Effect": "Allow", + "Resource": [ + "*" + ] + }, + { + "Action": [ + "eks:DescribeFargateProfile", + "eks:DeleteFargateProfile" + ], + "Effect": "Allow", + "Resource": "*" + }, + { + "Action": [ + "iam:GetRole", + "iam:listAttachedRolePolicies" + ], + "Effect": "Allow", + "Resource": "*" + }, + { + "Action": "iam:CreateServiceLinkedRole", + "Effect": "Allow", + "Resource": "*" + }, + { + "Action": "ec2:DescribeVpcs", + "Effect": "Allow", + "Resource": { + "Fn::Join": [ + "", + [ + "arn:", + { + "Ref": "AWS::Partition" + }, + ":ec2:test-region:12345678:vpc/", + { + "Ref": "FargateClusterDefaultVpcE69D3A13" + } + ] + ] + } + }, + { + "Action": "iam:PassRole", + "Effect": "Allow", + "Resource": { + "Fn::GetAtt": [ + "FargateClusterfargateprofiledefaultPodExecutionRole66F2610E", + "Arn" + ] + } + } + ], + "Version": "2012-10-17" + }, + "PolicyName": "FargateClusterCreationRoleDefaultPolicy629049D0", + "Roles": [ + { + "Ref": "FargateClusterCreationRole8C524AD8" + } + ] + }, + "DependsOn": [ + "FargateClusterDefaultVpcIGWFD9278DA", + "FargateClusterDefaultVpcPrivateSubnet1DefaultRouteE93D7B93", + "FargateClusterDefaultVpcPrivateSubnet1RouteTableA42013EB", + "FargateClusterDefaultVpcPrivateSubnet1RouteTableAssociationDC34627F", + "FargateClusterDefaultVpcPrivateSubnet1Subnet50EA43AA", + "FargateClusterDefaultVpcPrivateSubnet2DefaultRouteABCE20FF", + "FargateClusterDefaultVpcPrivateSubnet2RouteTable1691B33C", + "FargateClusterDefaultVpcPrivateSubnet2RouteTableAssociation6C0234FE", + "FargateClusterDefaultVpcPrivateSubnet2Subnet0C9D6154", + "FargateClusterDefaultVpcPrivateSubnet3DefaultRouteEFE144B5", + "FargateClusterDefaultVpcPrivateSubnet3RouteTable7D0EEC96", + "FargateClusterDefaultVpcPrivateSubnet3RouteTableAssociationCC0949D8", + "FargateClusterDefaultVpcPrivateSubnet3Subnet1F8A52F1", + "FargateClusterDefaultVpcPublicSubnet1DefaultRouteA0A93C70", + "FargateClusterDefaultVpcPublicSubnet1EIP0093A4E0", + "FargateClusterDefaultVpcPublicSubnet1NATGatewayEC4DEB51", + "FargateClusterDefaultVpcPublicSubnet1RouteTableC2D2B434", + "FargateClusterDefaultVpcPublicSubnet1RouteTableAssociation43821F5B", + "FargateClusterDefaultVpcPublicSubnet1Subnet96AFDABC", + "FargateClusterDefaultVpcPublicSubnet2DefaultRouteABE51CF2", + "FargateClusterDefaultVpcPublicSubnet2EIPA4C07B68", + "FargateClusterDefaultVpcPublicSubnet2NATGateway77D6A579", + "FargateClusterDefaultVpcPublicSubnet2RouteTableEDDB89D9", + "FargateClusterDefaultVpcPublicSubnet2RouteTableAssociationCF18C87A", + "FargateClusterDefaultVpcPublicSubnet2Subnet92A9CC93", + "FargateClusterDefaultVpcPublicSubnet3DefaultRoute8341F833", + "FargateClusterDefaultVpcPublicSubnet3EIP46E028EF", + "FargateClusterDefaultVpcPublicSubnet3NATGateway0AAE540F", + "FargateClusterDefaultVpcPublicSubnet3RouteTable4E802182", + "FargateClusterDefaultVpcPublicSubnet3RouteTableAssociation93B95514", + "FargateClusterDefaultVpcPublicSubnet3SubnetB408ADA9", + "FargateClusterDefaultVpcE69D3A13", + "FargateClusterDefaultVpcVPCGWA7F012E1" + ] + }, + "FargateCluster019F03E8": { + "Type": "Custom::AWSCDK-EKS-Cluster", + "Properties": { + "ServiceToken": { + "Fn::GetAtt": [ + "awscdkawseksClusterResourceProviderNestedStackawscdkawseksClusterResourceProviderNestedStackResource9827C454", + "Outputs.awscdkeksfargateclustertestawscdkawseksClusterResourceProviderframeworkonEventC85EBDF3Arn" + ] + }, + "Config": { + "version": "1.17", + "roleArn": { + "Fn::GetAtt": [ + "FargateClusterRole8E36B33A", + "Arn" + ] + }, + "resourcesVpcConfig": { + "subnetIds": [ + { + "Ref": "FargateClusterDefaultVpcPublicSubnet1Subnet96AFDABC" + }, + { + "Ref": "FargateClusterDefaultVpcPublicSubnet2Subnet92A9CC93" + }, + { + "Ref": "FargateClusterDefaultVpcPublicSubnet3SubnetB408ADA9" + }, + { + "Ref": "FargateClusterDefaultVpcPrivateSubnet1Subnet50EA43AA" + }, + { + "Ref": "FargateClusterDefaultVpcPrivateSubnet2Subnet0C9D6154" + }, + { + "Ref": "FargateClusterDefaultVpcPrivateSubnet3Subnet1F8A52F1" + } + ], + "securityGroupIds": [ + { + "Fn::GetAtt": [ + "FargateClusterControlPlaneSecurityGroup1021A150", + "GroupId" + ] + } + ], + "endpointPublicAccess": true, + "endpointPrivateAccess": true + } + }, + "AssumeRoleArn": { + "Fn::GetAtt": [ + "FargateClusterCreationRole8C524AD8", + "Arn" + ] + }, + "AttributesRevision": 2 + }, + "DependsOn": [ + "FargateClusterDefaultVpcIGWFD9278DA", + "FargateClusterDefaultVpcPrivateSubnet1DefaultRouteE93D7B93", + "FargateClusterDefaultVpcPrivateSubnet1RouteTableA42013EB", + "FargateClusterDefaultVpcPrivateSubnet1RouteTableAssociationDC34627F", + "FargateClusterDefaultVpcPrivateSubnet1Subnet50EA43AA", + "FargateClusterDefaultVpcPrivateSubnet2DefaultRouteABCE20FF", + "FargateClusterDefaultVpcPrivateSubnet2RouteTable1691B33C", + "FargateClusterDefaultVpcPrivateSubnet2RouteTableAssociation6C0234FE", + "FargateClusterDefaultVpcPrivateSubnet2Subnet0C9D6154", + "FargateClusterDefaultVpcPrivateSubnet3DefaultRouteEFE144B5", + "FargateClusterDefaultVpcPrivateSubnet3RouteTable7D0EEC96", + "FargateClusterDefaultVpcPrivateSubnet3RouteTableAssociationCC0949D8", + "FargateClusterDefaultVpcPrivateSubnet3Subnet1F8A52F1", + "FargateClusterDefaultVpcPublicSubnet1DefaultRouteA0A93C70", + "FargateClusterDefaultVpcPublicSubnet1EIP0093A4E0", + "FargateClusterDefaultVpcPublicSubnet1NATGatewayEC4DEB51", + "FargateClusterDefaultVpcPublicSubnet1RouteTableC2D2B434", + "FargateClusterDefaultVpcPublicSubnet1RouteTableAssociation43821F5B", + "FargateClusterDefaultVpcPublicSubnet1Subnet96AFDABC", + "FargateClusterDefaultVpcPublicSubnet2DefaultRouteABE51CF2", + "FargateClusterDefaultVpcPublicSubnet2EIPA4C07B68", + "FargateClusterDefaultVpcPublicSubnet2NATGateway77D6A579", + "FargateClusterDefaultVpcPublicSubnet2RouteTableEDDB89D9", + "FargateClusterDefaultVpcPublicSubnet2RouteTableAssociationCF18C87A", + "FargateClusterDefaultVpcPublicSubnet2Subnet92A9CC93", + "FargateClusterDefaultVpcPublicSubnet3DefaultRoute8341F833", + "FargateClusterDefaultVpcPublicSubnet3EIP46E028EF", + "FargateClusterDefaultVpcPublicSubnet3NATGateway0AAE540F", + "FargateClusterDefaultVpcPublicSubnet3RouteTable4E802182", + "FargateClusterDefaultVpcPublicSubnet3RouteTableAssociation93B95514", + "FargateClusterDefaultVpcPublicSubnet3SubnetB408ADA9", + "FargateClusterDefaultVpcE69D3A13", + "FargateClusterDefaultVpcVPCGWA7F012E1", + "FargateClusterCreationRoleDefaultPolicy629049D0", + "FargateClusterCreationRole8C524AD8" + ], + "UpdateReplacePolicy": "Delete", + "DeletionPolicy": "Delete" + }, + "FargateClusterKubectlReadyBarrier93746934": { + "Type": "AWS::SSM::Parameter", + "Properties": { + "Type": "String", + "Value": "aws:cdk:eks:kubectl-ready" + }, + "DependsOn": [ + "FargateClusterfargateprofiledefaultPodExecutionRole66F2610E", + "FargateClusterfargateprofiledefault10E54561", + "FargateClusterCreationRoleDefaultPolicy629049D0", + "FargateClusterCreationRole8C524AD8", + "FargateCluster019F03E8" + ] + }, + "FargateClusterMastersRole50BAF9FD": { + "Type": "AWS::IAM::Role", + "Properties": { + "AssumeRolePolicyDocument": { + "Statement": [ + { + "Action": "sts:AssumeRole", + "Effect": "Allow", + "Principal": { + "AWS": { + "Fn::Join": [ + "", + [ + "arn:", + { + "Ref": "AWS::Partition" + }, + ":iam::12345678:root" + ] + ] + } + } + } + ], + "Version": "2012-10-17" + } + } + }, + "FargateClusterAwsAuthmanifest1F7A5553": { + "Type": "Custom::AWSCDK-EKS-KubernetesResource", + "Properties": { + "ServiceToken": { + "Fn::GetAtt": [ + "awscdkawseksKubectlProviderNestedStackawscdkawseksKubectlProviderNestedStackResourceA7AEBA6B", + "Outputs.awscdkeksfargateclustertestawscdkawseksKubectlProviderframeworkonEvent33B2ACA4Arn" + ] + }, + "Manifest": { + "Fn::Join": [ + "", + [ + "[{\"apiVersion\":\"v1\",\"kind\":\"ConfigMap\",\"metadata\":{\"name\":\"aws-auth\",\"namespace\":\"kube-system\"},\"data\":{\"mapRoles\":\"[{\\\"rolearn\\\":\\\"", + { + "Fn::GetAtt": [ + "FargateClusterMastersRole50BAF9FD", + "Arn" + ] + }, + "\\\",\\\"username\\\":\\\"", + { + "Fn::GetAtt": [ + "FargateClusterMastersRole50BAF9FD", + "Arn" + ] + }, + "\\\",\\\"groups\\\":[\\\"system:masters\\\"]},{\\\"rolearn\\\":\\\"", + { + "Fn::GetAtt": [ + "FargateClusterfargateprofiledefaultPodExecutionRole66F2610E", + "Arn" + ] + }, + "\\\",\\\"username\\\":\\\"system:node:{{SessionName}}\\\",\\\"groups\\\":[\\\"system:bootstrappers\\\",\\\"system:nodes\\\",\\\"system:node-proxier\\\"]}]\",\"mapUsers\":\"[]\",\"mapAccounts\":\"[]\"}}]" + ] + ] + }, + "ClusterName": { + "Ref": "FargateCluster019F03E8" + }, + "RoleArn": { + "Fn::GetAtt": [ + "FargateClusterCreationRole8C524AD8", + "Arn" + ] + } + }, + "DependsOn": [ + "FargateClusterKubectlReadyBarrier93746934" + ], + "UpdateReplacePolicy": "Delete", + "DeletionPolicy": "Delete" + }, + "FargateClusterCoreDnsComputeTypePatch711BF1B2": { + "Type": "Custom::AWSCDK-EKS-KubernetesPatch", + "Properties": { + "ServiceToken": { + "Fn::GetAtt": [ + "awscdkawseksKubectlProviderNestedStackawscdkawseksKubectlProviderNestedStackResourceA7AEBA6B", + "Outputs.awscdkeksfargateclustertestawscdkawseksKubectlProviderframeworkonEvent33B2ACA4Arn" + ] + }, + "ResourceName": "deployment/coredns", + "ResourceNamespace": "kube-system", + "ApplyPatchJson": "{\"spec\":{\"template\":{\"metadata\":{\"annotations\":{\"eks.amazonaws.com/compute-type\":\"fargate\"}}}}}", + "RestorePatchJson": "{\"spec\":{\"template\":{\"metadata\":{\"annotations\":{\"eks.amazonaws.com/compute-type\":\"ec2\"}}}}}", + "ClusterName": { + "Ref": "FargateCluster019F03E8" + }, + "RoleArn": { + "Fn::GetAtt": [ + "FargateClusterCreationRole8C524AD8", + "Arn" + ] + }, + "PatchType": "strategic" + }, + "DependsOn": [ + "FargateClusterKubectlReadyBarrier93746934" + ], + "UpdateReplacePolicy": "Delete", + "DeletionPolicy": "Delete" + }, + "FargateClusterfargateprofiledefaultPodExecutionRole66F2610E": { + "Type": "AWS::IAM::Role", + "Properties": { + "AssumeRolePolicyDocument": { + "Statement": [ + { + "Action": "sts:AssumeRole", + "Effect": "Allow", + "Principal": { + "Service": "eks-fargate-pods.amazonaws.com" + } + } + ], + "Version": "2012-10-17" + }, + "ManagedPolicyArns": [ + { + "Fn::Join": [ + "", + [ + "arn:", + { + "Ref": "AWS::Partition" + }, + ":iam::aws:policy/AmazonEKSFargatePodExecutionRolePolicy" + ] + ] + } + ] + } + }, + "FargateClusterfargateprofiledefault10E54561": { + "Type": "Custom::AWSCDK-EKS-FargateProfile", + "Properties": { + "ServiceToken": { + "Fn::GetAtt": [ + "awscdkawseksClusterResourceProviderNestedStackawscdkawseksClusterResourceProviderNestedStackResource9827C454", + "Outputs.awscdkeksfargateclustertestawscdkawseksClusterResourceProviderframeworkonEventC85EBDF3Arn" + ] + }, + "AssumeRoleArn": { + "Fn::GetAtt": [ + "FargateClusterCreationRole8C524AD8", + "Arn" + ] + }, + "Config": { + "clusterName": { + "Ref": "FargateCluster019F03E8" + }, + "podExecutionRoleArn": { + "Fn::GetAtt": [ + "FargateClusterfargateprofiledefaultPodExecutionRole66F2610E", + "Arn" + ] + }, + "selectors": [ + { + "namespace": "default" + }, + { + "namespace": "kube-system" + } + ] + } + }, + "UpdateReplacePolicy": "Delete", + "DeletionPolicy": "Delete" + }, + "awscdkawseksClusterResourceProviderNestedStackawscdkawseksClusterResourceProviderNestedStackResource9827C454": { + "Type": "AWS::CloudFormation::Stack", + "Properties": { + "TemplateURL": { + "Fn::Join": [ + "", + [ + "https://s3.test-region.", + { + "Ref": "AWS::URLSuffix" + }, + "/", + { + "Ref": "AssetParametersbedcab6ba6cdb530ab9574b630651abdee4c67fb22c69ad17ab3b4369d3b7c89S3Bucket60C2BF28" + }, + "/", + { + "Fn::Select": [ + 0, + { + "Fn::Split": [ + "||", + { + "Ref": "AssetParametersbedcab6ba6cdb530ab9574b630651abdee4c67fb22c69ad17ab3b4369d3b7c89S3VersionKey81C20166" + } + ] + } + ] + }, + { + "Fn::Select": [ + 1, + { + "Fn::Split": [ + "||", + { + "Ref": "AssetParametersbedcab6ba6cdb530ab9574b630651abdee4c67fb22c69ad17ab3b4369d3b7c89S3VersionKey81C20166" + } + ] + } + ] + } + ] + ] + }, + "Parameters": { + "referencetoawscdkeksfargateclustertestFargateClusterCreationRoleFB2229CFArn": { + "Fn::GetAtt": [ + "FargateClusterCreationRole8C524AD8", + "Arn" + ] + }, + "referencetoawscdkeksfargateclustertestAssetParameters87b1e2c41f84590d14f7ab8cb0f338c51d6fa3efe78943867af07fa959593dbaS3Bucket122A6EA8Ref": { + "Ref": "AssetParameters87b1e2c41f84590d14f7ab8cb0f338c51d6fa3efe78943867af07fa959593dbaS3Bucket14D204F9" + }, + "referencetoawscdkeksfargateclustertestAssetParameters87b1e2c41f84590d14f7ab8cb0f338c51d6fa3efe78943867af07fa959593dbaS3VersionKey56570425Ref": { + "Ref": "AssetParameters87b1e2c41f84590d14f7ab8cb0f338c51d6fa3efe78943867af07fa959593dbaS3VersionKeyDE8A2F1F" + }, + "referencetoawscdkeksfargateclustertestAssetParameters5db52e19f1f79cac27e817fa59d0b1f73d524301b679e2e7354122e474fcba0cS3Bucket7ABEDF68Ref": { + "Ref": "AssetParameters5db52e19f1f79cac27e817fa59d0b1f73d524301b679e2e7354122e474fcba0cS3Bucket8132A6E0" + }, + "referencetoawscdkeksfargateclustertestAssetParameters5db52e19f1f79cac27e817fa59d0b1f73d524301b679e2e7354122e474fcba0cS3VersionKey810DC943Ref": { + "Ref": "AssetParameters5db52e19f1f79cac27e817fa59d0b1f73d524301b679e2e7354122e474fcba0cS3VersionKey722E831A" + } + } + } + }, + "awscdkawseksKubectlProviderNestedStackawscdkawseksKubectlProviderNestedStackResourceA7AEBA6B": { + "Type": "AWS::CloudFormation::Stack", + "Properties": { + "TemplateURL": { + "Fn::Join": [ + "", + [ + "https://s3.test-region.", + { + "Ref": "AWS::URLSuffix" + }, + "/", + { + "Ref": "AssetParametersc3e7ad226d0efc3c9ecf3b4c84ea434556c67008349c6cc43c1cdb58323ddf7cS3Bucket1E579A0A" + }, + "/", + { + "Fn::Select": [ + 0, + { + "Fn::Split": [ + "||", + { + "Ref": "AssetParametersc3e7ad226d0efc3c9ecf3b4c84ea434556c67008349c6cc43c1cdb58323ddf7cS3VersionKey91701E13" + } + ] + } + ] + }, + { + "Fn::Select": [ + 1, + { + "Fn::Split": [ + "||", + { + "Ref": "AssetParametersc3e7ad226d0efc3c9ecf3b4c84ea434556c67008349c6cc43c1cdb58323ddf7cS3VersionKey91701E13" + } + ] + } + ] + } + ] + ] + }, + "Parameters": { + "referencetoawscdkeksfargateclustertestFargateCluster8588769EArn": { + "Fn::GetAtt": [ + "FargateCluster019F03E8", + "Arn" + ] + }, + "referencetoawscdkeksfargateclustertestFargateClusterCreationRoleFB2229CFArn": { + "Fn::GetAtt": [ + "FargateClusterCreationRole8C524AD8", + "Arn" + ] + }, + "referencetoawscdkeksfargateclustertestAssetParametersb7d8a9750f8bfded8ac76be100e3bee1c3d4824df006766110d023f42952f5c2S3BucketF3D15942Ref": { + "Ref": "AssetParametersb7d8a9750f8bfded8ac76be100e3bee1c3d4824df006766110d023f42952f5c2S3Bucket9ABBD5A2" + }, + "referencetoawscdkeksfargateclustertestAssetParametersb7d8a9750f8bfded8ac76be100e3bee1c3d4824df006766110d023f42952f5c2S3VersionKey362BF04DRef": { + "Ref": "AssetParametersb7d8a9750f8bfded8ac76be100e3bee1c3d4824df006766110d023f42952f5c2S3VersionKey40FF2C4A" + }, + "referencetoawscdkeksfargateclustertestFargateClusterDefaultVpcPrivateSubnet1Subnet0278E6BCRef": { + "Ref": "FargateClusterDefaultVpcPrivateSubnet1Subnet50EA43AA" + }, + "referencetoawscdkeksfargateclustertestFargateClusterDefaultVpcPrivateSubnet2Subnet1F1EC575Ref": { + "Ref": "FargateClusterDefaultVpcPrivateSubnet2Subnet0C9D6154" + }, + "referencetoawscdkeksfargateclustertestFargateClusterDefaultVpcPrivateSubnet3Subnet3A4CBF94Ref": { + "Ref": "FargateClusterDefaultVpcPrivateSubnet3Subnet1F8A52F1" + }, + "referencetoawscdkeksfargateclustertestFargateCluster8588769EClusterSecurityGroupId": { + "Fn::GetAtt": [ + "FargateCluster019F03E8", + "ClusterSecurityGroupId" + ] + }, + "referencetoawscdkeksfargateclustertestAssetParameters5db52e19f1f79cac27e817fa59d0b1f73d524301b679e2e7354122e474fcba0cS3Bucket7ABEDF68Ref": { + "Ref": "AssetParameters5db52e19f1f79cac27e817fa59d0b1f73d524301b679e2e7354122e474fcba0cS3Bucket8132A6E0" + }, + "referencetoawscdkeksfargateclustertestAssetParameters5db52e19f1f79cac27e817fa59d0b1f73d524301b679e2e7354122e474fcba0cS3VersionKey810DC943Ref": { + "Ref": "AssetParameters5db52e19f1f79cac27e817fa59d0b1f73d524301b679e2e7354122e474fcba0cS3VersionKey722E831A" + } + } + } + } + }, + "Outputs": { + "FargateClusterConfigCommand46D4A6C7": { + "Value": { + "Fn::Join": [ + "", + [ + "aws eks update-kubeconfig --name ", + { + "Ref": "FargateCluster019F03E8" + }, + " --region test-region --role-arn ", + { + "Fn::GetAtt": [ + "FargateClusterMastersRole50BAF9FD", + "Arn" + ] + } + ] + ] + } + }, + "FargateClusterGetTokenCommand4ADED7BB": { + "Value": { + "Fn::Join": [ + "", + [ + "aws eks get-token --cluster-name ", + { + "Ref": "FargateCluster019F03E8" + }, + " --region test-region --role-arn ", + { + "Fn::GetAtt": [ + "FargateClusterMastersRole50BAF9FD", + "Arn" + ] + } + ] + ] + } + } + }, + "Parameters": { + "AssetParameters87b1e2c41f84590d14f7ab8cb0f338c51d6fa3efe78943867af07fa959593dbaS3Bucket14D204F9": { + "Type": "String", + "Description": "S3 bucket for asset \"87b1e2c41f84590d14f7ab8cb0f338c51d6fa3efe78943867af07fa959593dba\"" + }, + "AssetParameters87b1e2c41f84590d14f7ab8cb0f338c51d6fa3efe78943867af07fa959593dbaS3VersionKeyDE8A2F1F": { + "Type": "String", + "Description": "S3 key for asset version \"87b1e2c41f84590d14f7ab8cb0f338c51d6fa3efe78943867af07fa959593dba\"" + }, + "AssetParameters87b1e2c41f84590d14f7ab8cb0f338c51d6fa3efe78943867af07fa959593dbaArtifactHash54822A43": { + "Type": "String", + "Description": "Artifact hash for asset \"87b1e2c41f84590d14f7ab8cb0f338c51d6fa3efe78943867af07fa959593dba\"" + }, + "AssetParameters5db52e19f1f79cac27e817fa59d0b1f73d524301b679e2e7354122e474fcba0cS3Bucket8132A6E0": { + "Type": "String", + "Description": "S3 bucket for asset \"5db52e19f1f79cac27e817fa59d0b1f73d524301b679e2e7354122e474fcba0c\"" + }, + "AssetParameters5db52e19f1f79cac27e817fa59d0b1f73d524301b679e2e7354122e474fcba0cS3VersionKey722E831A": { + "Type": "String", + "Description": "S3 key for asset version \"5db52e19f1f79cac27e817fa59d0b1f73d524301b679e2e7354122e474fcba0c\"" + }, + "AssetParameters5db52e19f1f79cac27e817fa59d0b1f73d524301b679e2e7354122e474fcba0cArtifactHash67988836": { + "Type": "String", + "Description": "Artifact hash for asset \"5db52e19f1f79cac27e817fa59d0b1f73d524301b679e2e7354122e474fcba0c\"" + }, + "AssetParametersb7d8a9750f8bfded8ac76be100e3bee1c3d4824df006766110d023f42952f5c2S3Bucket9ABBD5A2": { + "Type": "String", + "Description": "S3 bucket for asset \"b7d8a9750f8bfded8ac76be100e3bee1c3d4824df006766110d023f42952f5c2\"" + }, + "AssetParametersb7d8a9750f8bfded8ac76be100e3bee1c3d4824df006766110d023f42952f5c2S3VersionKey40FF2C4A": { + "Type": "String", + "Description": "S3 key for asset version \"b7d8a9750f8bfded8ac76be100e3bee1c3d4824df006766110d023f42952f5c2\"" + }, + "AssetParametersb7d8a9750f8bfded8ac76be100e3bee1c3d4824df006766110d023f42952f5c2ArtifactHashE86B38C7": { + "Type": "String", + "Description": "Artifact hash for asset \"b7d8a9750f8bfded8ac76be100e3bee1c3d4824df006766110d023f42952f5c2\"" + }, + "AssetParametersbedcab6ba6cdb530ab9574b630651abdee4c67fb22c69ad17ab3b4369d3b7c89S3Bucket60C2BF28": { + "Type": "String", + "Description": "S3 bucket for asset \"bedcab6ba6cdb530ab9574b630651abdee4c67fb22c69ad17ab3b4369d3b7c89\"" + }, + "AssetParametersbedcab6ba6cdb530ab9574b630651abdee4c67fb22c69ad17ab3b4369d3b7c89S3VersionKey81C20166": { + "Type": "String", + "Description": "S3 key for asset version \"bedcab6ba6cdb530ab9574b630651abdee4c67fb22c69ad17ab3b4369d3b7c89\"" + }, + "AssetParametersbedcab6ba6cdb530ab9574b630651abdee4c67fb22c69ad17ab3b4369d3b7c89ArtifactHashC2E43922": { + "Type": "String", + "Description": "Artifact hash for asset \"bedcab6ba6cdb530ab9574b630651abdee4c67fb22c69ad17ab3b4369d3b7c89\"" + }, + "AssetParametersc3e7ad226d0efc3c9ecf3b4c84ea434556c67008349c6cc43c1cdb58323ddf7cS3Bucket1E579A0A": { + "Type": "String", + "Description": "S3 bucket for asset \"c3e7ad226d0efc3c9ecf3b4c84ea434556c67008349c6cc43c1cdb58323ddf7c\"" + }, + "AssetParametersc3e7ad226d0efc3c9ecf3b4c84ea434556c67008349c6cc43c1cdb58323ddf7cS3VersionKey91701E13": { + "Type": "String", + "Description": "S3 key for asset version \"c3e7ad226d0efc3c9ecf3b4c84ea434556c67008349c6cc43c1cdb58323ddf7c\"" + }, + "AssetParametersc3e7ad226d0efc3c9ecf3b4c84ea434556c67008349c6cc43c1cdb58323ddf7cArtifactHash4D9F989B": { + "Type": "String", + "Description": "Artifact hash for asset \"c3e7ad226d0efc3c9ecf3b4c84ea434556c67008349c6cc43c1cdb58323ddf7c\"" + } + } +} \ No newline at end of file diff --git a/packages/@aws-cdk/aws-eks/test/integ.fargate-cluster.ts b/packages/@aws-cdk/aws-eks/test/integ.fargate-cluster.ts new file mode 100644 index 0000000000000..870b3059b1a2b --- /dev/null +++ b/packages/@aws-cdk/aws-eks/test/integ.fargate-cluster.ts @@ -0,0 +1,21 @@ +/// !cdk-integ pragma:ignore-assets +import { App } from '@aws-cdk/core'; +import * as eks from '../lib'; +import { TestStack } from './util'; + +class EksFargateClusterStack extends TestStack { + + constructor(scope: App, id: string) { + super(scope, id); + + new eks.FargateCluster(this, 'FargateCluster', { + version: eks.KubernetesVersion.V1_17, + }); + } +} + +const app = new App(); + +new EksFargateClusterStack(app, 'aws-cdk-eks-fargate-cluster-test'); + +app.synth(); \ No newline at end of file diff --git a/packages/@aws-cdk/aws-eks/test/test.k8s-patch.ts b/packages/@aws-cdk/aws-eks/test/test.k8s-patch.ts index e77035688b19e..c4defdf107606 100644 --- a/packages/@aws-cdk/aws-eks/test/test.k8s-patch.ts +++ b/packages/@aws-cdk/aws-eks/test/test.k8s-patch.ts @@ -13,7 +13,7 @@ export = { const cluster = new eks.Cluster(stack, 'MyCluster', { version: CLUSTER_VERSION }); // WHEN - new KubernetesPatch(stack, 'MyPatch', { + const patch = new KubernetesPatch(stack, 'MyPatch', { cluster, applyPatch: { patch: { to: 'apply' } }, restorePatch: { restore: { patch: 123 } }, @@ -42,6 +42,10 @@ export = { ], }, })); + + // also make sure a dependency on the barrier is added to the patch construct. + test.deepEqual(patch.node.dependencies.map(d => d.target.node.uniqueId), ['MyClusterKubectlReadyBarrier7547948A']); + test.done(); }, 'defaults to "strategic" patch type if no patchType is specified'(test: Test) { From ddcf3e5e5582f86fcaf45d4cde3541deceb33518 Mon Sep 17 00:00:00 2001 From: Neta Nir Date: Fri, 25 Sep 2020 07:56:15 -0700 Subject: [PATCH 21/29] chore: run integ test with 'v' (#10525) Following up on https://github.com/aws/aws-cdk/pull/10503, enabling verbose logging for integ tests. opt out for tests that relies on exact match of the output: * 'cdk synth' - match the output of `synth`. * 'Two ways of shoing the version' - This one is tricker. Since `--version` is implemnted using `.version()` of `yargs` it ignores the `-v` argument, but `version` (no dash) which is our implementation respect it. ``` $cdk version -v CDK toolkit version: 1.63.0 (build 7a68125) .... blah blah ``` vs: ``` $cdk --version -v 1.63.0 (build 7a68125) ``` ---- *By submitting this pull request, I confirm that my contribution is made under the terms of the Apache-2.0 license* --- .../cli-regression-patches/v1.64.0/NOTES.md | 3 + .../v1.64.0/cdk-helpers.js | 325 ++++++++++++++++++ .../aws-cdk/test/integ/cli/cdk-helpers.ts | 7 +- .../aws-cdk/test/integ/cli/cli.integtest.ts | 8 +- 4 files changed, 337 insertions(+), 6 deletions(-) create mode 100644 packages/aws-cdk/test/integ/cli-regression-patches/v1.64.0/NOTES.md create mode 100644 packages/aws-cdk/test/integ/cli-regression-patches/v1.64.0/cdk-helpers.js diff --git a/packages/aws-cdk/test/integ/cli-regression-patches/v1.64.0/NOTES.md b/packages/aws-cdk/test/integ/cli-regression-patches/v1.64.0/NOTES.md new file mode 100644 index 0000000000000..1cb31072ab5de --- /dev/null +++ b/packages/aws-cdk/test/integ/cli-regression-patches/v1.64.0/NOTES.md @@ -0,0 +1,3 @@ +Added a `-v` switch to the cdk executions that also needs to be +applied to the regression tests so we have a better chance +of catching sporadically failing tests in the act. \ No newline at end of file diff --git a/packages/aws-cdk/test/integ/cli-regression-patches/v1.64.0/cdk-helpers.js b/packages/aws-cdk/test/integ/cli-regression-patches/v1.64.0/cdk-helpers.js new file mode 100644 index 0000000000000..da45aebb27469 --- /dev/null +++ b/packages/aws-cdk/test/integ/cli-regression-patches/v1.64.0/cdk-helpers.js @@ -0,0 +1,325 @@ +"use strict"; +var _a, _b; +Object.defineProperty(exports, "__esModule", { value: true }); +const child_process = require("child_process"); +const fs = require("fs"); +const os = require("os"); +const path = require("path"); +const aws_helpers_1 = require("./aws-helpers"); +const resource_pool_1 = require("./resource-pool"); +const REGIONS = process.env.AWS_REGIONS +? process.env.AWS_REGIONS.split(',') +: [(_b = (_a = process.env.AWS_REGION) !== null && _a !== void 0 ? _a : process.env.AWS_DEFAULT_REGION) !== null && _b !== void 0 ? _b : 'us-east-1']; +process.stdout.write(`Using regions: ${REGIONS}\n`); +const REGION_POOL = new resource_pool_1.ResourcePool(REGIONS); +/** + * Higher order function to execute a block with an AWS client setup + * + * Allocate the next region from the REGION pool and dispose it afterwards. + */ +function withAws(block) { +return (context) => REGION_POOL.using(async (region) => { + const aws = await aws_helpers_1.AwsClients.forRegion(region, context.output); + await sanityCheck(aws); + return block({ ...context, aws }); +}); +} +exports.withAws = withAws; +/** + * Higher order function to execute a block with a CDK app fixture + * + * Requires an AWS client to be passed in. + * + * For backwards compatibility with existing tests (so we don't have to change + * too much) the inner block is expected to take a `TestFixture` object. + */ +function withCdkApp(block) { +return async (context) => { + const randy = randomString(); + const stackNamePrefix = `cdktest-${randy}`; + const integTestDir = path.join(os.tmpdir(), `cdk-integ-${randy}`); + context.output.write(` Stack prefix: ${stackNamePrefix}\n`); + context.output.write(` Test directory: ${integTestDir}\n`); + context.output.write(` Region: ${context.aws.region}\n`); + await cloneDirectory(path.join(__dirname, 'app'), integTestDir, context.output); + const fixture = new TestFixture(integTestDir, stackNamePrefix, context.output, context.aws); + let success = true; + try { + await fixture.shell(['npm', 'install', + '@aws-cdk/core', + '@aws-cdk/aws-sns', + '@aws-cdk/aws-iam', + '@aws-cdk/aws-lambda', + '@aws-cdk/aws-ssm', + '@aws-cdk/aws-ecr-assets', + '@aws-cdk/aws-cloudformation', + '@aws-cdk/aws-ec2']); + await ensureBootstrapped(fixture); + await block(fixture); + } + catch (e) { + success = false; + throw e; + } + finally { + await fixture.dispose(success); + } +}; +} +exports.withCdkApp = withCdkApp; +/** + * Default test fixture for most (all?) integ tests + * + * It's a composition of withAws/withCdkApp, expecting the test block to take a `TestFixture` + * object. + * + * We could have put `withAws(withCdkApp(fixture => { /... actual test here.../ }))` in every + * test declaration but centralizing it is going to make it convenient to modify in the future. + */ +function withDefaultFixture(block) { +return withAws(withCdkApp(block)); +// ^~~~~~ this is disappointing TypeScript! Feels like you should have been able to derive this. +} +exports.withDefaultFixture = withDefaultFixture; +/** + * Prepare a target dir byreplicating a source directory + */ +async function cloneDirectory(source, target, output) { +await shell(['rm', '-rf', target], { output }); +await shell(['mkdir', '-p', target], { output }); +await shell(['cp', '-R', source + '/*', target], { output }); +} +exports.cloneDirectory = cloneDirectory; +class TestFixture { +constructor(integTestDir, stackNamePrefix, output, aws) { + this.integTestDir = integTestDir; + this.stackNamePrefix = stackNamePrefix; + this.output = output; + this.aws = aws; + this.qualifier = randomString().substr(0, 10); + this.bucketsToDelete = new Array(); +} +log(s) { + this.output.write(`${s}\n`); +} +async shell(command, options = {}) { + return shell(command, { + output: this.output, + cwd: this.integTestDir, + ...options, + }); +} +async cdkDeploy(stackNames, options = {}) { + var _a, _b; + stackNames = typeof stackNames === 'string' ? [stackNames] : stackNames; + const neverRequireApproval = (_a = options.neverRequireApproval) !== null && _a !== void 0 ? _a : true; + return this.cdk(['deploy', + ...(neverRequireApproval ? ['--require-approval=never'] : []), + ...((_b = options.options) !== null && _b !== void 0 ? _b : []), + ...this.fullStackName(stackNames)], options); +} +async cdkDestroy(stackNames, options = {}) { + var _a; + stackNames = typeof stackNames === 'string' ? [stackNames] : stackNames; + return this.cdk(['destroy', + '-f', + ...((_a = options.options) !== null && _a !== void 0 ? _a : []), + ...this.fullStackName(stackNames)], options); +} +async cdk(args, options = {}) { + var _a; + const verbose = (_a = options.verbose) !== null && _a !== void 0 ? _a : true; + return this.shell(['cdk', ...(verbose ? ['-v'] : []), ...args], { + ...options, + modEnv: { + AWS_REGION: this.aws.region, + AWS_DEFAULT_REGION: this.aws.region, + STACK_NAME_PREFIX: this.stackNamePrefix, + ...options.modEnv, + }, + }); +} +fullStackName(stackNames) { + if (typeof stackNames === 'string') { + return `${this.stackNamePrefix}-${stackNames}`; + } + else { + return stackNames.map(s => `${this.stackNamePrefix}-${s}`); + } +} +/** + * Append this to the list of buckets to potentially delete + * + * At the end of a test, we clean up buckets that may not have gotten destroyed + * (for whatever reason). + */ +rememberToDeleteBucket(bucketName) { + this.bucketsToDelete.push(bucketName); +} +/** + * Cleanup leftover stacks and buckets + */ +async dispose(success) { + const stacksToDelete = await this.deleteableStacks(this.stackNamePrefix); + // Bootstrap stacks have buckets that need to be cleaned + const bucketNames = stacksToDelete.map(stack => aws_helpers_1.outputFromStack('BucketName', stack)).filter(defined); + await Promise.all(bucketNames.map(b => this.aws.emptyBucket(b))); + // Bootstrap stacks have ECR repositories with images which should be deleted + const imageRepositoryNames = stacksToDelete.map(stack => aws_helpers_1.outputFromStack('ImageRepositoryName', stack)).filter(defined); + await Promise.all(imageRepositoryNames.map(r => this.aws.deleteImageRepository(r))); + await this.aws.deleteStacks(...stacksToDelete.map(s => s.StackName)); + // We might have leaked some buckets by upgrading the bootstrap stack. Be + // sure to clean everything. + for (const bucket of this.bucketsToDelete) { + await this.aws.deleteBucket(bucket); + } + // If the tests completed successfully, happily delete the fixture + // (otherwise leave it for humans to inspect) + if (success) { + rimraf(this.integTestDir); + } +} +/** + * Return the stacks starting with our testing prefix that should be deleted + */ +async deleteableStacks(prefix) { + var _a; + const statusFilter = [ + 'CREATE_IN_PROGRESS', 'CREATE_FAILED', 'CREATE_COMPLETE', + 'ROLLBACK_IN_PROGRESS', 'ROLLBACK_FAILED', 'ROLLBACK_COMPLETE', + 'DELETE_FAILED', + 'UPDATE_IN_PROGRESS', 'UPDATE_COMPLETE_CLEANUP_IN_PROGRESS', + 'UPDATE_COMPLETE', 'UPDATE_ROLLBACK_IN_PROGRESS', + 'UPDATE_ROLLBACK_FAILED', + 'UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS', + 'UPDATE_ROLLBACK_COMPLETE', 'REVIEW_IN_PROGRESS', + 'IMPORT_IN_PROGRESS', 'IMPORT_COMPLETE', + 'IMPORT_ROLLBACK_IN_PROGRESS', 'IMPORT_ROLLBACK_FAILED', + 'IMPORT_ROLLBACK_COMPLETE', + ]; + const response = await this.aws.cloudFormation('describeStacks', {}); + return ((_a = response.Stacks) !== null && _a !== void 0 ? _a : []) + .filter(s => s.StackName.startsWith(prefix)) + .filter(s => statusFilter.includes(s.StackStatus)) + .filter(s => s.RootId === undefined); // Only delete parent stacks. Nested stacks are deleted in the process +} +} +exports.TestFixture = TestFixture; +/** + * Perform a one-time quick sanity check that the AWS clients has properly configured credentials + * + * If we don't do this, calls are going to fail and they'll be retried and everything will take + * forever before the user notices a simple misconfiguration. + * + * We can't check for the presence of environment variables since credentials could come from + * anywhere, so do simple account retrieval. + * + * Only do it once per process. + */ +async function sanityCheck(aws) { +if (sanityChecked === undefined) { + try { + await aws.account(); + sanityChecked = true; + } + catch (e) { + sanityChecked = false; + throw new Error(`AWS credentials probably not configured, got error: ${e.message}`); + } +} +if (!sanityChecked) { + throw new Error('AWS credentials probably not configured, see previous error'); +} +} +let sanityChecked; +/** + * Make sure that the given environment is bootstrapped + * + * Since we go striping across regions, it's going to suck doing this + * by hand so let's just mass-automate it. + */ +async function ensureBootstrapped(fixture) { +// Old-style bootstrap stack with default name +if (await fixture.aws.stackStatus('CDKToolkit') === undefined) { + await fixture.cdk(['bootstrap', `aws://${await fixture.aws.account()}/${fixture.aws.region}`]); +} +} +/** + * A shell command that does what you want + * + * Is platform-aware, handles errors nicely. + */ +async function shell(command, options = {}) { +var _a, _b; +if (options.modEnv && options.env) { + throw new Error('Use either env or modEnv but not both'); +} +(_a = options.output) === null || _a === void 0 ? void 0 : _a.write(`💻 ${command.join(' ')}\n`); +const env = (_b = options.env) !== null && _b !== void 0 ? _b : (options.modEnv ? { ...process.env, ...options.modEnv } : undefined); +const child = child_process.spawn(command[0], command.slice(1), { + ...options, + env, + // Need this for Windows where we want .cmd and .bat to be found as well. + shell: true, + stdio: ['ignore', 'pipe', 'pipe'], +}); +return new Promise((resolve, reject) => { + const stdout = new Array(); + const stderr = new Array(); + child.stdout.on('data', chunk => { + var _a; + (_a = options.output) === null || _a === void 0 ? void 0 : _a.write(chunk); + stdout.push(chunk); + }); + child.stderr.on('data', chunk => { + var _a, _b; + (_a = options.output) === null || _a === void 0 ? void 0 : _a.write(chunk); + if ((_b = options.captureStderr) !== null && _b !== void 0 ? _b : true) { + stderr.push(chunk); + } + }); + child.once('error', reject); + child.once('close', code => { + if (code === 0 || options.allowErrExit) { + resolve((Buffer.concat(stdout).toString('utf-8') + Buffer.concat(stderr).toString('utf-8')).trim()); + } + else { + reject(new Error(`'${command.join(' ')}' exited with error code ${code}`)); + } + }); +}); +} +exports.shell = shell; +function defined(x) { +return x !== undefined; +} +/** + * rm -rf reimplementation, don't want to depend on an NPM package for this + */ +function rimraf(fsPath) { +try { + const isDir = fs.lstatSync(fsPath).isDirectory(); + if (isDir) { + for (const file of fs.readdirSync(fsPath)) { + rimraf(path.join(fsPath, file)); + } + fs.rmdirSync(fsPath); + } + else { + fs.unlinkSync(fsPath); + } +} +catch (e) { + // We will survive ENOENT + if (e.code !== 'ENOENT') { + throw e; + } +} +} +exports.rimraf = rimraf; +function randomString() { +// Crazy +return Math.random().toString(36).replace(/[^a-z0-9]+/g, ''); +} +exports.randomString = randomString; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cdk-helpers.js","sourceRoot":"","sources":["cdk-helpers.ts"],"names":[],"mappings":"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","sourcesContent":["import * as child_process from 'child_process';\nimport * as fs from 'fs';\nimport * as os from 'os';\nimport * as path from 'path';\nimport { outputFromStack, AwsClients } from './aws-helpers';\nimport { ResourcePool } from './resource-pool';\nimport { TestContext } from './test-helpers';\n\nconst REGIONS = process.env.AWS_REGIONS\n  ? process.env.AWS_REGIONS.split(',')\n  : [process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION ?? 'us-east-1'];\n\nprocess.stdout.write(`Using regions: ${REGIONS}\\n`);\n\nconst REGION_POOL = new ResourcePool(REGIONS);\n\n\nexport type AwsContext = { readonly aws: AwsClients };\n\n/**\n * Higher order function to execute a block with an AWS client setup\n *\n * Allocate the next region from the REGION pool and dispose it afterwards.\n */\nexport function withAws<A extends TestContext>(block: (context: A & AwsContext) => Promise<void>) {\n  return (context: A) => REGION_POOL.using(async (region) => {\n    const aws = await AwsClients.forRegion(region, context.output);\n    await sanityCheck(aws);\n\n    return block({ ...context, aws });\n  });\n}\n\n/**\n * Higher order function to execute a block with a CDK app fixture\n *\n * Requires an AWS client to be passed in.\n *\n * For backwards compatibility with existing tests (so we don't have to change\n * too much) the inner block is expected to take a `TestFixture` object.\n */\nexport function withCdkApp<A extends TestContext & AwsContext>(block: (context: TestFixture) => Promise<void>) {\n  return async (context: A) => {\n    const randy = randomString();\n    const stackNamePrefix = `cdktest-${randy}`;\n    const integTestDir = path.join(os.tmpdir(), `cdk-integ-${randy}`);\n\n    context.output.write(` Stack prefix:   ${stackNamePrefix}\\n`);\n    context.output.write(` Test directory: ${integTestDir}\\n`);\n    context.output.write(` Region:         ${context.aws.region}\\n`);\n\n    await cloneDirectory(path.join(__dirname, 'app'), integTestDir, context.output);\n    const fixture = new TestFixture(\n      integTestDir,\n      stackNamePrefix,\n      context.output,\n      context.aws);\n\n    let success = true;\n    try {\n      await fixture.shell(['npm', 'install',\n        '@aws-cdk/core',\n        '@aws-cdk/aws-sns',\n        '@aws-cdk/aws-iam',\n        '@aws-cdk/aws-lambda',\n        '@aws-cdk/aws-ssm',\n        '@aws-cdk/aws-ecr-assets',\n        '@aws-cdk/aws-cloudformation',\n        '@aws-cdk/aws-ec2']);\n\n      await ensureBootstrapped(fixture);\n\n      await block(fixture);\n    } catch (e) {\n      success = false;\n      throw e;\n    } finally {\n      await fixture.dispose(success);\n    }\n  };\n}\n\n/**\n * Default test fixture for most (all?) integ tests\n *\n * It's a composition of withAws/withCdkApp, expecting the test block to take a `TestFixture`\n * object.\n *\n * We could have put `withAws(withCdkApp(fixture => { /... actual test here.../ }))` in every\n * test declaration but centralizing it is going to make it convenient to modify in the future.\n */\nexport function withDefaultFixture(block: (context: TestFixture) => Promise<void>) {\n  return withAws<TestContext>(withCdkApp(block));\n  //              ^~~~~~ this is disappointing TypeScript! Feels like you should have been able to derive this.\n}\n\nexport interface ShellOptions extends child_process.SpawnOptions {\n  /**\n   * Properties to add to 'env'\n   */\n  modEnv?: Record<string, string>;\n\n  /**\n   * Don't fail when exiting with an error\n   *\n   * @default false\n   */\n  allowErrExit?: boolean;\n\n  /**\n   * Whether to capture stderr\n   *\n   * @default true\n   */\n  captureStderr?: boolean;\n\n  /**\n   * Pass output here\n   */\n  output?: NodeJS.WritableStream;\n}\n\nexport interface CdkCliOptions extends ShellOptions {\n  options?: string[];\n  neverRequireApproval?: boolean;\n  verbose?: boolean;\n}\n\n/**\n * Prepare a target dir byreplicating a source directory\n */\nexport async function cloneDirectory(source: string, target: string, output?: NodeJS.WritableStream) {\n  await shell(['rm', '-rf', target], { output });\n  await shell(['mkdir', '-p', target], { output });\n  await shell(['cp', '-R', source + '/*', target], { output });\n}\n\nexport class TestFixture {\n  public readonly qualifier = randomString().substr(0, 10);\n  private readonly bucketsToDelete = new Array<string>();\n\n  constructor(\n    public readonly integTestDir: string,\n    public readonly stackNamePrefix: string,\n    public readonly output: NodeJS.WritableStream,\n    public readonly aws: AwsClients) {\n  }\n\n  public log(s: string) {\n    this.output.write(`${s}\\n`);\n  }\n\n  public async shell(command: string[], options: Omit<ShellOptions, 'cwd'|'output'> = {}): Promise<string> {\n    return shell(command, {\n      output: this.output,\n      cwd: this.integTestDir,\n      ...options,\n    });\n  }\n\n  public async cdkDeploy(stackNames: string | string[], options: CdkCliOptions = {}) {\n    stackNames = typeof stackNames === 'string' ? [stackNames] : stackNames;\n\n    const neverRequireApproval = options.neverRequireApproval ?? true;\n\n    return this.cdk(['deploy',\n      ...(neverRequireApproval ? ['--require-approval=never'] : []), // Default to no approval in an unattended test\n      ...(options.options ?? []),\n      ...this.fullStackName(stackNames)], options);\n  }\n\n  public async cdkDestroy(stackNames: string | string[], options: CdkCliOptions = {}) {\n    stackNames = typeof stackNames === 'string' ? [stackNames] : stackNames;\n\n    return this.cdk(['destroy',\n      '-f', // We never want a prompt in an unattended test\n      ...(options.options ?? []),\n      ...this.fullStackName(stackNames)], options);\n  }\n\n  public async cdk(args: string[], options: CdkCliOptions = {}) {\n    const verbose = options.verbose ?? true;\n\n    return this.shell(['cdk', ...(verbose ? ['-v'] : []), ...args], {\n      ...options,\n      modEnv: {\n        AWS_REGION: this.aws.region,\n        AWS_DEFAULT_REGION: this.aws.region,\n        STACK_NAME_PREFIX: this.stackNamePrefix,\n        ...options.modEnv,\n      },\n    });\n  }\n\n  public fullStackName(stackName: string): string;\n  public fullStackName(stackNames: string[]): string[];\n  public fullStackName(stackNames: string | string[]): string | string[] {\n    if (typeof stackNames === 'string') {\n      return `${this.stackNamePrefix}-${stackNames}`;\n    } else {\n      return stackNames.map(s => `${this.stackNamePrefix}-${s}`);\n    }\n  }\n\n  /**\n   * Append this to the list of buckets to potentially delete\n   *\n   * At the end of a test, we clean up buckets that may not have gotten destroyed\n   * (for whatever reason).\n   */\n  public rememberToDeleteBucket(bucketName: string) {\n    this.bucketsToDelete.push(bucketName);\n  }\n\n  /**\n   * Cleanup leftover stacks and buckets\n   */\n  public async dispose(success: boolean) {\n    const stacksToDelete = await this.deleteableStacks(this.stackNamePrefix);\n\n    // Bootstrap stacks have buckets that need to be cleaned\n    const bucketNames = stacksToDelete.map(stack => outputFromStack('BucketName', stack)).filter(defined);\n    await Promise.all(bucketNames.map(b => this.aws.emptyBucket(b)));\n\n    // Bootstrap stacks have ECR repositories with images which should be deleted\n    const imageRepositoryNames = stacksToDelete.map(stack => outputFromStack('ImageRepositoryName', stack)).filter(defined);\n    await Promise.all(imageRepositoryNames.map(r => this.aws.deleteImageRepository(r)));\n\n    await this.aws.deleteStacks(...stacksToDelete.map(s => s.StackName));\n\n    // We might have leaked some buckets by upgrading the bootstrap stack. Be\n    // sure to clean everything.\n    for (const bucket of this.bucketsToDelete) {\n      await this.aws.deleteBucket(bucket);\n    }\n\n    // If the tests completed successfully, happily delete the fixture\n    // (otherwise leave it for humans to inspect)\n    if (success) {\n      rimraf(this.integTestDir);\n    }\n  }\n\n  /**\n   * Return the stacks starting with our testing prefix that should be deleted\n   */\n  private async deleteableStacks(prefix: string): Promise<AWS.CloudFormation.Stack[]> {\n    const statusFilter = [\n      'CREATE_IN_PROGRESS', 'CREATE_FAILED', 'CREATE_COMPLETE',\n      'ROLLBACK_IN_PROGRESS', 'ROLLBACK_FAILED', 'ROLLBACK_COMPLETE',\n      'DELETE_FAILED',\n      'UPDATE_IN_PROGRESS', 'UPDATE_COMPLETE_CLEANUP_IN_PROGRESS',\n      'UPDATE_COMPLETE', 'UPDATE_ROLLBACK_IN_PROGRESS',\n      'UPDATE_ROLLBACK_FAILED',\n      'UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS',\n      'UPDATE_ROLLBACK_COMPLETE', 'REVIEW_IN_PROGRESS',\n      'IMPORT_IN_PROGRESS', 'IMPORT_COMPLETE',\n      'IMPORT_ROLLBACK_IN_PROGRESS', 'IMPORT_ROLLBACK_FAILED',\n      'IMPORT_ROLLBACK_COMPLETE',\n    ];\n\n    const response = await this.aws.cloudFormation('describeStacks', {});\n\n    return (response.Stacks ?? [])\n      .filter(s => s.StackName.startsWith(prefix))\n      .filter(s => statusFilter.includes(s.StackStatus))\n      .filter(s => s.RootId === undefined); // Only delete parent stacks. Nested stacks are deleted in the process\n  }\n}\n\n/**\n * Perform a one-time quick sanity check that the AWS clients has properly configured credentials\n *\n * If we don't do this, calls are going to fail and they'll be retried and everything will take\n * forever before the user notices a simple misconfiguration.\n *\n * We can't check for the presence of environment variables since credentials could come from\n * anywhere, so do simple account retrieval.\n *\n * Only do it once per process.\n */\nasync function sanityCheck(aws: AwsClients) {\n  if (sanityChecked === undefined) {\n    try {\n      await aws.account();\n      sanityChecked = true;\n    } catch (e) {\n      sanityChecked = false;\n      throw new Error(`AWS credentials probably not configured, got error: ${e.message}`);\n    }\n  }\n  if (!sanityChecked) {\n    throw new Error('AWS credentials probably not configured, see previous error');\n  }\n}\nlet sanityChecked: boolean | undefined;\n\n/**\n * Make sure that the given environment is bootstrapped\n *\n * Since we go striping across regions, it's going to suck doing this\n * by hand so let's just mass-automate it.\n */\nasync function ensureBootstrapped(fixture: TestFixture) {\n  // Old-style bootstrap stack with default name\n  if (await fixture.aws.stackStatus('CDKToolkit') === undefined) {\n    await fixture.cdk(['bootstrap', `aws://${await fixture.aws.account()}/${fixture.aws.region}`]);\n  }\n}\n\n/**\n * A shell command that does what you want\n *\n * Is platform-aware, handles errors nicely.\n */\nexport async function shell(command: string[], options: ShellOptions = {}): Promise<string> {\n  if (options.modEnv && options.env) {\n    throw new Error('Use either env or modEnv but not both');\n  }\n\n  options.output?.write(`💻 ${command.join(' ')}\\n`);\n\n  const env = options.env ?? (options.modEnv ? { ...process.env, ...options.modEnv } : undefined);\n\n  const child = child_process.spawn(command[0], command.slice(1), {\n    ...options,\n    env,\n    // Need this for Windows where we want .cmd and .bat to be found as well.\n    shell: true,\n    stdio: ['ignore', 'pipe', 'pipe'],\n  });\n\n  return new Promise<string>((resolve, reject) => {\n    const stdout = new Array<Buffer>();\n    const stderr = new Array<Buffer>();\n\n    child.stdout!.on('data', chunk => {\n      options.output?.write(chunk);\n      stdout.push(chunk);\n    });\n\n    child.stderr!.on('data', chunk => {\n      options.output?.write(chunk);\n      if (options.captureStderr ?? true) {\n        stderr.push(chunk);\n      }\n    });\n\n    child.once('error', reject);\n\n    child.once('close', code => {\n      if (code === 0 || options.allowErrExit) {\n        resolve((Buffer.concat(stdout).toString('utf-8') + Buffer.concat(stderr).toString('utf-8')).trim());\n      } else {\n        reject(new Error(`'${command.join(' ')}' exited with error code ${code}`));\n      }\n    });\n  });\n}\n\nfunction defined<A>(x: A): x is NonNullable<A> {\n  return x !== undefined;\n}\n\n/**\n * rm -rf reimplementation, don't want to depend on an NPM package for this\n */\nexport function rimraf(fsPath: string) {\n  try {\n    const isDir = fs.lstatSync(fsPath).isDirectory();\n\n    if (isDir) {\n      for (const file of fs.readdirSync(fsPath)) {\n        rimraf(path.join(fsPath, file));\n      }\n      fs.rmdirSync(fsPath);\n    } else {\n      fs.unlinkSync(fsPath);\n    }\n  } catch (e) {\n    // We will survive ENOENT\n    if (e.code !== 'ENOENT') { throw e; }\n  }\n}\n\nexport function randomString() {\n  // Crazy\n  return Math.random().toString(36).replace(/[^a-z0-9]+/g, '');\n}"]} \ No newline at end of file diff --git a/packages/aws-cdk/test/integ/cli/cdk-helpers.ts b/packages/aws-cdk/test/integ/cli/cdk-helpers.ts index 66c6799164fd8..01829ebff413f 100644 --- a/packages/aws-cdk/test/integ/cli/cdk-helpers.ts +++ b/packages/aws-cdk/test/integ/cli/cdk-helpers.ts @@ -37,7 +37,7 @@ export function withAws(block: (context: A & AwsContext) * Requires an AWS client to be passed in. * * For backwards compatibility with existing tests (so we don't have to change - * too much) the inner block is expecte to take a `TestFixture` object. + * too much) the inner block is expected to take a `TestFixture` object. */ export function withCdkApp(block: (context: TestFixture) => Promise) { return async (context: A) => { @@ -123,6 +123,7 @@ export interface ShellOptions extends child_process.SpawnOptions { export interface CdkCliOptions extends ShellOptions { options?: string[]; neverRequireApproval?: boolean; + verbose?: boolean; } /** @@ -178,7 +179,9 @@ export class TestFixture { } public async cdk(args: string[], options: CdkCliOptions = {}) { - return this.shell(['cdk', ...args], { + const verbose = options.verbose ?? true; + + return this.shell(['cdk', ...(verbose ? ['-v'] : []), ...args], { ...options, modEnv: { AWS_REGION: this.aws.region, diff --git a/packages/aws-cdk/test/integ/cli/cli.integtest.ts b/packages/aws-cdk/test/integ/cli/cli.integtest.ts index d203c0f66e605..079a560175a8d 100644 --- a/packages/aws-cdk/test/integ/cli/cli.integtest.ts +++ b/packages/aws-cdk/test/integ/cli/cli.integtest.ts @@ -20,8 +20,8 @@ integTest('VPC Lookup', withDefaultFixture(async (fixture) => { })); integTest('Two ways of shoing the version', withDefaultFixture(async (fixture) => { - const version1 = await fixture.cdk(['version']); - const version2 = await fixture.cdk(['--version']); + const version1 = await fixture.cdk(['version'], { verbose: false }); + const version2 = await fixture.cdk(['--version'], { verbose: false }); expect(version1).toEqual(version2); })); @@ -39,14 +39,14 @@ integTest('Termination protection', withDefaultFixture(async (fixture) => { })); integTest('cdk synth', withDefaultFixture(async (fixture) => { - await expect(fixture.cdk(['synth', fixture.fullStackName('test-1')])).resolves.toEqual( + await expect(fixture.cdk(['synth', fixture.fullStackName('test-1')], { verbose: false })).resolves.toEqual( `Resources: topic69831491: Type: AWS::SNS::Topic Metadata: aws:cdk:path: ${fixture.stackNamePrefix}-test-1/topic/Resource`); - await expect(fixture.cdk(['synth', fixture.fullStackName('test-2')])).resolves.toEqual( + await expect(fixture.cdk(['synth', fixture.fullStackName('test-2')], { verbose: false })).resolves.toEqual( `Resources: topic152D84A37: Type: AWS::SNS::Topic From f0f8a63c98e8a7ff5bedcf271a78fcb417988378 Mon Sep 17 00:00:00 2001 From: Eli Polonsky Date: Fri, 25 Sep 2020 17:19:43 +0300 Subject: [PATCH 22/29] fix(eks): `KubernetesPatch` and `FargateCluster` creates a circular dependency and breaks deployment (#10536) In version [`1.62.0`](https://github.com/aws/aws-cdk/releases/tag/v1.62.0) we introduced the ability to run `kubectl` commands on imported clusters. (See https://github.com/aws/aws-cdk/pull/9802). Part of this change included some refactoring with regards to how we use and create the `KubectlProvider`. Looks like we didn't consistently apply the same logic across all constructs that use it. Case in point: https://github.com/aws/aws-cdk/blob/e349004a522e2123c1e93bd3402dd7c3f9c5c17c/packages/%40aws-cdk/aws-eks/lib/k8s-manifest.ts#L58 Notice that here we use `this` as the scope to the `getOrCreate` call. Same goes for: https://github.com/aws/aws-cdk/blob/e349004a522e2123c1e93bd3402dd7c3f9c5c17c/packages/%40aws-cdk/aws-eks/lib/k8s-object-value.ts#L64 However, `KubernetesPatch` use `scope` instead. https://github.com/aws/aws-cdk/blob/e349004a522e2123c1e93bd3402dd7c3f9c5c17c/packages/%40aws-cdk/aws-eks/lib/k8s-patch.ts#L74 This means that the entire `scope` of the `KubernetesPatch` now depends, among others, on the `kubectlBarrier`. The scope will usually be either the cluster itself (when using `FargateCluster`), or the entire stack (when using `new KubernetesPatch`). In any case, the scope will most likely contain the cluster VPC. This creates the following dependency cycle: `Cluster => ClusterVpc => KubectlBarrier => Cluster`. The fix aligns the `KubernetesPatch` behavior to all other `kubectl` constructs and uses `this` as the scope, which will only add dependency on the barrier to the custom resource representing the patch. Fixes https://github.com/aws/aws-cdk/issues/10528 Fixes https://github.com/aws/aws-cdk/issues/10537 ---- *By submitting this pull request, I confirm that my contribution is made under the terms of the Apache-2.0 license* --- packages/@aws-cdk/aws-eks/lib/k8s-patch.ts | 2 +- .../test/integ.fargate-cluster.expected.json | 1388 +++++++++++++++++ .../aws-eks/test/integ.fargate-cluster.ts | 21 + .../@aws-cdk/aws-eks/test/test.k8s-patch.ts | 6 +- 4 files changed, 1415 insertions(+), 2 deletions(-) create mode 100644 packages/@aws-cdk/aws-eks/test/integ.fargate-cluster.expected.json create mode 100644 packages/@aws-cdk/aws-eks/test/integ.fargate-cluster.ts diff --git a/packages/@aws-cdk/aws-eks/lib/k8s-patch.ts b/packages/@aws-cdk/aws-eks/lib/k8s-patch.ts index d35de30a18fe5..88db0f4352f11 100644 --- a/packages/@aws-cdk/aws-eks/lib/k8s-patch.ts +++ b/packages/@aws-cdk/aws-eks/lib/k8s-patch.ts @@ -71,7 +71,7 @@ export class KubernetesPatch extends Construct { super(scope, id); const stack = Stack.of(this); - const provider = KubectlProvider.getOrCreate(scope, props.cluster); + const provider = KubectlProvider.getOrCreate(this, props.cluster); new CustomResource(this, 'Resource', { serviceToken: provider.serviceToken, diff --git a/packages/@aws-cdk/aws-eks/test/integ.fargate-cluster.expected.json b/packages/@aws-cdk/aws-eks/test/integ.fargate-cluster.expected.json new file mode 100644 index 0000000000000..de489ef72836e --- /dev/null +++ b/packages/@aws-cdk/aws-eks/test/integ.fargate-cluster.expected.json @@ -0,0 +1,1388 @@ +{ + "Resources": { + "FargateClusterDefaultVpcE69D3A13": { + "Type": "AWS::EC2::VPC", + "Properties": { + "CidrBlock": "10.0.0.0/16", + "EnableDnsHostnames": true, + "EnableDnsSupport": true, + "InstanceTenancy": "default", + "Tags": [ + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc" + } + ] + } + }, + "FargateClusterDefaultVpcPublicSubnet1Subnet96AFDABC": { + "Type": "AWS::EC2::Subnet", + "Properties": { + "CidrBlock": "10.0.0.0/19", + "VpcId": { + "Ref": "FargateClusterDefaultVpcE69D3A13" + }, + "AvailabilityZone": "test-region-1a", + "MapPublicIpOnLaunch": true, + "Tags": [ + { + "Key": "aws-cdk:subnet-name", + "Value": "Public" + }, + { + "Key": "aws-cdk:subnet-type", + "Value": "Public" + }, + { + "Key": "kubernetes.io/role/elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PublicSubnet1" + } + ] + } + }, + "FargateClusterDefaultVpcPublicSubnet1RouteTableC2D2B434": { + "Type": "AWS::EC2::RouteTable", + "Properties": { + "VpcId": { + "Ref": "FargateClusterDefaultVpcE69D3A13" + }, + "Tags": [ + { + "Key": "kubernetes.io/role/elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PublicSubnet1" + } + ] + } + }, + "FargateClusterDefaultVpcPublicSubnet1RouteTableAssociation43821F5B": { + "Type": "AWS::EC2::SubnetRouteTableAssociation", + "Properties": { + "RouteTableId": { + "Ref": "FargateClusterDefaultVpcPublicSubnet1RouteTableC2D2B434" + }, + "SubnetId": { + "Ref": "FargateClusterDefaultVpcPublicSubnet1Subnet96AFDABC" + } + } + }, + "FargateClusterDefaultVpcPublicSubnet1DefaultRouteA0A93C70": { + "Type": "AWS::EC2::Route", + "Properties": { + "RouteTableId": { + "Ref": "FargateClusterDefaultVpcPublicSubnet1RouteTableC2D2B434" + }, + "DestinationCidrBlock": "0.0.0.0/0", + "GatewayId": { + "Ref": "FargateClusterDefaultVpcIGWFD9278DA" + } + }, + "DependsOn": [ + "FargateClusterDefaultVpcVPCGWA7F012E1" + ] + }, + "FargateClusterDefaultVpcPublicSubnet1EIP0093A4E0": { + "Type": "AWS::EC2::EIP", + "Properties": { + "Domain": "vpc", + "Tags": [ + { + "Key": "kubernetes.io/role/elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PublicSubnet1" + } + ] + } + }, + "FargateClusterDefaultVpcPublicSubnet1NATGatewayEC4DEB51": { + "Type": "AWS::EC2::NatGateway", + "Properties": { + "AllocationId": { + "Fn::GetAtt": [ + "FargateClusterDefaultVpcPublicSubnet1EIP0093A4E0", + "AllocationId" + ] + }, + "SubnetId": { + "Ref": "FargateClusterDefaultVpcPublicSubnet1Subnet96AFDABC" + }, + "Tags": [ + { + "Key": "kubernetes.io/role/elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PublicSubnet1" + } + ] + } + }, + "FargateClusterDefaultVpcPublicSubnet2Subnet92A9CC93": { + "Type": "AWS::EC2::Subnet", + "Properties": { + "CidrBlock": "10.0.32.0/19", + "VpcId": { + "Ref": "FargateClusterDefaultVpcE69D3A13" + }, + "AvailabilityZone": "test-region-1b", + "MapPublicIpOnLaunch": true, + "Tags": [ + { + "Key": "aws-cdk:subnet-name", + "Value": "Public" + }, + { + "Key": "aws-cdk:subnet-type", + "Value": "Public" + }, + { + "Key": "kubernetes.io/role/elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PublicSubnet2" + } + ] + } + }, + "FargateClusterDefaultVpcPublicSubnet2RouteTableEDDB89D9": { + "Type": "AWS::EC2::RouteTable", + "Properties": { + "VpcId": { + "Ref": "FargateClusterDefaultVpcE69D3A13" + }, + "Tags": [ + { + "Key": "kubernetes.io/role/elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PublicSubnet2" + } + ] + } + }, + "FargateClusterDefaultVpcPublicSubnet2RouteTableAssociationCF18C87A": { + "Type": "AWS::EC2::SubnetRouteTableAssociation", + "Properties": { + "RouteTableId": { + "Ref": "FargateClusterDefaultVpcPublicSubnet2RouteTableEDDB89D9" + }, + "SubnetId": { + "Ref": "FargateClusterDefaultVpcPublicSubnet2Subnet92A9CC93" + } + } + }, + "FargateClusterDefaultVpcPublicSubnet2DefaultRouteABE51CF2": { + "Type": "AWS::EC2::Route", + "Properties": { + "RouteTableId": { + "Ref": "FargateClusterDefaultVpcPublicSubnet2RouteTableEDDB89D9" + }, + "DestinationCidrBlock": "0.0.0.0/0", + "GatewayId": { + "Ref": "FargateClusterDefaultVpcIGWFD9278DA" + } + }, + "DependsOn": [ + "FargateClusterDefaultVpcVPCGWA7F012E1" + ] + }, + "FargateClusterDefaultVpcPublicSubnet2EIPA4C07B68": { + "Type": "AWS::EC2::EIP", + "Properties": { + "Domain": "vpc", + "Tags": [ + { + "Key": "kubernetes.io/role/elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PublicSubnet2" + } + ] + } + }, + "FargateClusterDefaultVpcPublicSubnet2NATGateway77D6A579": { + "Type": "AWS::EC2::NatGateway", + "Properties": { + "AllocationId": { + "Fn::GetAtt": [ + "FargateClusterDefaultVpcPublicSubnet2EIPA4C07B68", + "AllocationId" + ] + }, + "SubnetId": { + "Ref": "FargateClusterDefaultVpcPublicSubnet2Subnet92A9CC93" + }, + "Tags": [ + { + "Key": "kubernetes.io/role/elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PublicSubnet2" + } + ] + } + }, + "FargateClusterDefaultVpcPublicSubnet3SubnetB408ADA9": { + "Type": "AWS::EC2::Subnet", + "Properties": { + "CidrBlock": "10.0.64.0/19", + "VpcId": { + "Ref": "FargateClusterDefaultVpcE69D3A13" + }, + "AvailabilityZone": "test-region-1c", + "MapPublicIpOnLaunch": true, + "Tags": [ + { + "Key": "aws-cdk:subnet-name", + "Value": "Public" + }, + { + "Key": "aws-cdk:subnet-type", + "Value": "Public" + }, + { + "Key": "kubernetes.io/role/elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PublicSubnet3" + } + ] + } + }, + "FargateClusterDefaultVpcPublicSubnet3RouteTable4E802182": { + "Type": "AWS::EC2::RouteTable", + "Properties": { + "VpcId": { + "Ref": "FargateClusterDefaultVpcE69D3A13" + }, + "Tags": [ + { + "Key": "kubernetes.io/role/elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PublicSubnet3" + } + ] + } + }, + "FargateClusterDefaultVpcPublicSubnet3RouteTableAssociation93B95514": { + "Type": "AWS::EC2::SubnetRouteTableAssociation", + "Properties": { + "RouteTableId": { + "Ref": "FargateClusterDefaultVpcPublicSubnet3RouteTable4E802182" + }, + "SubnetId": { + "Ref": "FargateClusterDefaultVpcPublicSubnet3SubnetB408ADA9" + } + } + }, + "FargateClusterDefaultVpcPublicSubnet3DefaultRoute8341F833": { + "Type": "AWS::EC2::Route", + "Properties": { + "RouteTableId": { + "Ref": "FargateClusterDefaultVpcPublicSubnet3RouteTable4E802182" + }, + "DestinationCidrBlock": "0.0.0.0/0", + "GatewayId": { + "Ref": "FargateClusterDefaultVpcIGWFD9278DA" + } + }, + "DependsOn": [ + "FargateClusterDefaultVpcVPCGWA7F012E1" + ] + }, + "FargateClusterDefaultVpcPublicSubnet3EIP46E028EF": { + "Type": "AWS::EC2::EIP", + "Properties": { + "Domain": "vpc", + "Tags": [ + { + "Key": "kubernetes.io/role/elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PublicSubnet3" + } + ] + } + }, + "FargateClusterDefaultVpcPublicSubnet3NATGateway0AAE540F": { + "Type": "AWS::EC2::NatGateway", + "Properties": { + "AllocationId": { + "Fn::GetAtt": [ + "FargateClusterDefaultVpcPublicSubnet3EIP46E028EF", + "AllocationId" + ] + }, + "SubnetId": { + "Ref": "FargateClusterDefaultVpcPublicSubnet3SubnetB408ADA9" + }, + "Tags": [ + { + "Key": "kubernetes.io/role/elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PublicSubnet3" + } + ] + } + }, + "FargateClusterDefaultVpcPrivateSubnet1Subnet50EA43AA": { + "Type": "AWS::EC2::Subnet", + "Properties": { + "CidrBlock": "10.0.96.0/19", + "VpcId": { + "Ref": "FargateClusterDefaultVpcE69D3A13" + }, + "AvailabilityZone": "test-region-1a", + "MapPublicIpOnLaunch": false, + "Tags": [ + { + "Key": "aws-cdk:subnet-name", + "Value": "Private" + }, + { + "Key": "aws-cdk:subnet-type", + "Value": "Private" + }, + { + "Key": "kubernetes.io/role/internal-elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PrivateSubnet1" + } + ] + } + }, + "FargateClusterDefaultVpcPrivateSubnet1RouteTableA42013EB": { + "Type": "AWS::EC2::RouteTable", + "Properties": { + "VpcId": { + "Ref": "FargateClusterDefaultVpcE69D3A13" + }, + "Tags": [ + { + "Key": "kubernetes.io/role/internal-elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PrivateSubnet1" + } + ] + } + }, + "FargateClusterDefaultVpcPrivateSubnet1RouteTableAssociationDC34627F": { + "Type": "AWS::EC2::SubnetRouteTableAssociation", + "Properties": { + "RouteTableId": { + "Ref": "FargateClusterDefaultVpcPrivateSubnet1RouteTableA42013EB" + }, + "SubnetId": { + "Ref": "FargateClusterDefaultVpcPrivateSubnet1Subnet50EA43AA" + } + } + }, + "FargateClusterDefaultVpcPrivateSubnet1DefaultRouteE93D7B93": { + "Type": "AWS::EC2::Route", + "Properties": { + "RouteTableId": { + "Ref": "FargateClusterDefaultVpcPrivateSubnet1RouteTableA42013EB" + }, + "DestinationCidrBlock": "0.0.0.0/0", + "NatGatewayId": { + "Ref": "FargateClusterDefaultVpcPublicSubnet1NATGatewayEC4DEB51" + } + } + }, + "FargateClusterDefaultVpcPrivateSubnet2Subnet0C9D6154": { + "Type": "AWS::EC2::Subnet", + "Properties": { + "CidrBlock": "10.0.128.0/19", + "VpcId": { + "Ref": "FargateClusterDefaultVpcE69D3A13" + }, + "AvailabilityZone": "test-region-1b", + "MapPublicIpOnLaunch": false, + "Tags": [ + { + "Key": "aws-cdk:subnet-name", + "Value": "Private" + }, + { + "Key": "aws-cdk:subnet-type", + "Value": "Private" + }, + { + "Key": "kubernetes.io/role/internal-elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PrivateSubnet2" + } + ] + } + }, + "FargateClusterDefaultVpcPrivateSubnet2RouteTable1691B33C": { + "Type": "AWS::EC2::RouteTable", + "Properties": { + "VpcId": { + "Ref": "FargateClusterDefaultVpcE69D3A13" + }, + "Tags": [ + { + "Key": "kubernetes.io/role/internal-elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PrivateSubnet2" + } + ] + } + }, + "FargateClusterDefaultVpcPrivateSubnet2RouteTableAssociation6C0234FE": { + "Type": "AWS::EC2::SubnetRouteTableAssociation", + "Properties": { + "RouteTableId": { + "Ref": "FargateClusterDefaultVpcPrivateSubnet2RouteTable1691B33C" + }, + "SubnetId": { + "Ref": "FargateClusterDefaultVpcPrivateSubnet2Subnet0C9D6154" + } + } + }, + "FargateClusterDefaultVpcPrivateSubnet2DefaultRouteABCE20FF": { + "Type": "AWS::EC2::Route", + "Properties": { + "RouteTableId": { + "Ref": "FargateClusterDefaultVpcPrivateSubnet2RouteTable1691B33C" + }, + "DestinationCidrBlock": "0.0.0.0/0", + "NatGatewayId": { + "Ref": "FargateClusterDefaultVpcPublicSubnet2NATGateway77D6A579" + } + } + }, + "FargateClusterDefaultVpcPrivateSubnet3Subnet1F8A52F1": { + "Type": "AWS::EC2::Subnet", + "Properties": { + "CidrBlock": "10.0.160.0/19", + "VpcId": { + "Ref": "FargateClusterDefaultVpcE69D3A13" + }, + "AvailabilityZone": "test-region-1c", + "MapPublicIpOnLaunch": false, + "Tags": [ + { + "Key": "aws-cdk:subnet-name", + "Value": "Private" + }, + { + "Key": "aws-cdk:subnet-type", + "Value": "Private" + }, + { + "Key": "kubernetes.io/role/internal-elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PrivateSubnet3" + } + ] + } + }, + "FargateClusterDefaultVpcPrivateSubnet3RouteTable7D0EEC96": { + "Type": "AWS::EC2::RouteTable", + "Properties": { + "VpcId": { + "Ref": "FargateClusterDefaultVpcE69D3A13" + }, + "Tags": [ + { + "Key": "kubernetes.io/role/internal-elb", + "Value": "1" + }, + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc/PrivateSubnet3" + } + ] + } + }, + "FargateClusterDefaultVpcPrivateSubnet3RouteTableAssociationCC0949D8": { + "Type": "AWS::EC2::SubnetRouteTableAssociation", + "Properties": { + "RouteTableId": { + "Ref": "FargateClusterDefaultVpcPrivateSubnet3RouteTable7D0EEC96" + }, + "SubnetId": { + "Ref": "FargateClusterDefaultVpcPrivateSubnet3Subnet1F8A52F1" + } + } + }, + "FargateClusterDefaultVpcPrivateSubnet3DefaultRouteEFE144B5": { + "Type": "AWS::EC2::Route", + "Properties": { + "RouteTableId": { + "Ref": "FargateClusterDefaultVpcPrivateSubnet3RouteTable7D0EEC96" + }, + "DestinationCidrBlock": "0.0.0.0/0", + "NatGatewayId": { + "Ref": "FargateClusterDefaultVpcPublicSubnet3NATGateway0AAE540F" + } + } + }, + "FargateClusterDefaultVpcIGWFD9278DA": { + "Type": "AWS::EC2::InternetGateway", + "Properties": { + "Tags": [ + { + "Key": "Name", + "Value": "aws-cdk-eks-fargate-cluster-test/FargateCluster/DefaultVpc" + } + ] + } + }, + "FargateClusterDefaultVpcVPCGWA7F012E1": { + "Type": "AWS::EC2::VPCGatewayAttachment", + "Properties": { + "VpcId": { + "Ref": "FargateClusterDefaultVpcE69D3A13" + }, + "InternetGatewayId": { + "Ref": "FargateClusterDefaultVpcIGWFD9278DA" + } + } + }, + "FargateClusterRole8E36B33A": { + "Type": "AWS::IAM::Role", + "Properties": { + "AssumeRolePolicyDocument": { + "Statement": [ + { + "Action": "sts:AssumeRole", + "Effect": "Allow", + "Principal": { + "Service": "eks.amazonaws.com" + } + } + ], + "Version": "2012-10-17" + }, + "ManagedPolicyArns": [ + { + "Fn::Join": [ + "", + [ + "arn:", + { + "Ref": "AWS::Partition" + }, + ":iam::aws:policy/AmazonEKSClusterPolicy" + ] + ] + } + ] + } + }, + "FargateClusterControlPlaneSecurityGroup1021A150": { + "Type": "AWS::EC2::SecurityGroup", + "Properties": { + "GroupDescription": "EKS Control Plane Security Group", + "SecurityGroupEgress": [ + { + "CidrIp": "0.0.0.0/0", + "Description": "Allow all outbound traffic by default", + "IpProtocol": "-1" + } + ], + "VpcId": { + "Ref": "FargateClusterDefaultVpcE69D3A13" + } + } + }, + "FargateClusterCreationRole8C524AD8": { + "Type": "AWS::IAM::Role", + "Properties": { + "AssumeRolePolicyDocument": { + "Statement": [ + { + "Action": "sts:AssumeRole", + "Effect": "Allow", + "Principal": { + "AWS": { + "Fn::Join": [ + "", + [ + "arn:", + { + "Ref": "AWS::Partition" + }, + ":iam::12345678:root" + ] + ] + } + } + } + ], + "Version": "2012-10-17" + } + }, + "DependsOn": [ + "FargateClusterDefaultVpcIGWFD9278DA", + "FargateClusterDefaultVpcPrivateSubnet1DefaultRouteE93D7B93", + "FargateClusterDefaultVpcPrivateSubnet1RouteTableA42013EB", + "FargateClusterDefaultVpcPrivateSubnet1RouteTableAssociationDC34627F", + "FargateClusterDefaultVpcPrivateSubnet1Subnet50EA43AA", + "FargateClusterDefaultVpcPrivateSubnet2DefaultRouteABCE20FF", + "FargateClusterDefaultVpcPrivateSubnet2RouteTable1691B33C", + "FargateClusterDefaultVpcPrivateSubnet2RouteTableAssociation6C0234FE", + "FargateClusterDefaultVpcPrivateSubnet2Subnet0C9D6154", + "FargateClusterDefaultVpcPrivateSubnet3DefaultRouteEFE144B5", + "FargateClusterDefaultVpcPrivateSubnet3RouteTable7D0EEC96", + "FargateClusterDefaultVpcPrivateSubnet3RouteTableAssociationCC0949D8", + "FargateClusterDefaultVpcPrivateSubnet3Subnet1F8A52F1", + "FargateClusterDefaultVpcPublicSubnet1DefaultRouteA0A93C70", + "FargateClusterDefaultVpcPublicSubnet1EIP0093A4E0", + "FargateClusterDefaultVpcPublicSubnet1NATGatewayEC4DEB51", + "FargateClusterDefaultVpcPublicSubnet1RouteTableC2D2B434", + "FargateClusterDefaultVpcPublicSubnet1RouteTableAssociation43821F5B", + "FargateClusterDefaultVpcPublicSubnet1Subnet96AFDABC", + "FargateClusterDefaultVpcPublicSubnet2DefaultRouteABE51CF2", + "FargateClusterDefaultVpcPublicSubnet2EIPA4C07B68", + "FargateClusterDefaultVpcPublicSubnet2NATGateway77D6A579", + "FargateClusterDefaultVpcPublicSubnet2RouteTableEDDB89D9", + "FargateClusterDefaultVpcPublicSubnet2RouteTableAssociationCF18C87A", + "FargateClusterDefaultVpcPublicSubnet2Subnet92A9CC93", + "FargateClusterDefaultVpcPublicSubnet3DefaultRoute8341F833", + "FargateClusterDefaultVpcPublicSubnet3EIP46E028EF", + "FargateClusterDefaultVpcPublicSubnet3NATGateway0AAE540F", + "FargateClusterDefaultVpcPublicSubnet3RouteTable4E802182", + "FargateClusterDefaultVpcPublicSubnet3RouteTableAssociation93B95514", + "FargateClusterDefaultVpcPublicSubnet3SubnetB408ADA9", + "FargateClusterDefaultVpcE69D3A13", + "FargateClusterDefaultVpcVPCGWA7F012E1" + ] + }, + "FargateClusterCreationRoleDefaultPolicy629049D0": { + "Type": "AWS::IAM::Policy", + "Properties": { + "PolicyDocument": { + "Statement": [ + { + "Action": "iam:PassRole", + "Effect": "Allow", + "Resource": { + "Fn::GetAtt": [ + "FargateClusterRole8E36B33A", + "Arn" + ] + } + }, + { + "Action": [ + "ec2:DescribeSubnets", + "ec2:DescribeRouteTables" + ], + "Effect": "Allow", + "Resource": "*" + }, + { + "Action": [ + "eks:CreateCluster", + "eks:DescribeCluster", + "eks:DescribeUpdate", + "eks:DeleteCluster", + "eks:UpdateClusterVersion", + "eks:UpdateClusterConfig", + "eks:CreateFargateProfile", + "eks:TagResource", + "eks:UntagResource" + ], + "Effect": "Allow", + "Resource": [ + "*" + ] + }, + { + "Action": [ + "eks:DescribeFargateProfile", + "eks:DeleteFargateProfile" + ], + "Effect": "Allow", + "Resource": "*" + }, + { + "Action": [ + "iam:GetRole", + "iam:listAttachedRolePolicies" + ], + "Effect": "Allow", + "Resource": "*" + }, + { + "Action": "iam:CreateServiceLinkedRole", + "Effect": "Allow", + "Resource": "*" + }, + { + "Action": "ec2:DescribeVpcs", + "Effect": "Allow", + "Resource": { + "Fn::Join": [ + "", + [ + "arn:", + { + "Ref": "AWS::Partition" + }, + ":ec2:test-region:12345678:vpc/", + { + "Ref": "FargateClusterDefaultVpcE69D3A13" + } + ] + ] + } + }, + { + "Action": "iam:PassRole", + "Effect": "Allow", + "Resource": { + "Fn::GetAtt": [ + "FargateClusterfargateprofiledefaultPodExecutionRole66F2610E", + "Arn" + ] + } + } + ], + "Version": "2012-10-17" + }, + "PolicyName": "FargateClusterCreationRoleDefaultPolicy629049D0", + "Roles": [ + { + "Ref": "FargateClusterCreationRole8C524AD8" + } + ] + }, + "DependsOn": [ + "FargateClusterDefaultVpcIGWFD9278DA", + "FargateClusterDefaultVpcPrivateSubnet1DefaultRouteE93D7B93", + "FargateClusterDefaultVpcPrivateSubnet1RouteTableA42013EB", + "FargateClusterDefaultVpcPrivateSubnet1RouteTableAssociationDC34627F", + "FargateClusterDefaultVpcPrivateSubnet1Subnet50EA43AA", + "FargateClusterDefaultVpcPrivateSubnet2DefaultRouteABCE20FF", + "FargateClusterDefaultVpcPrivateSubnet2RouteTable1691B33C", + "FargateClusterDefaultVpcPrivateSubnet2RouteTableAssociation6C0234FE", + "FargateClusterDefaultVpcPrivateSubnet2Subnet0C9D6154", + "FargateClusterDefaultVpcPrivateSubnet3DefaultRouteEFE144B5", + "FargateClusterDefaultVpcPrivateSubnet3RouteTable7D0EEC96", + "FargateClusterDefaultVpcPrivateSubnet3RouteTableAssociationCC0949D8", + "FargateClusterDefaultVpcPrivateSubnet3Subnet1F8A52F1", + "FargateClusterDefaultVpcPublicSubnet1DefaultRouteA0A93C70", + "FargateClusterDefaultVpcPublicSubnet1EIP0093A4E0", + "FargateClusterDefaultVpcPublicSubnet1NATGatewayEC4DEB51", + "FargateClusterDefaultVpcPublicSubnet1RouteTableC2D2B434", + "FargateClusterDefaultVpcPublicSubnet1RouteTableAssociation43821F5B", + "FargateClusterDefaultVpcPublicSubnet1Subnet96AFDABC", + "FargateClusterDefaultVpcPublicSubnet2DefaultRouteABE51CF2", + "FargateClusterDefaultVpcPublicSubnet2EIPA4C07B68", + "FargateClusterDefaultVpcPublicSubnet2NATGateway77D6A579", + "FargateClusterDefaultVpcPublicSubnet2RouteTableEDDB89D9", + "FargateClusterDefaultVpcPublicSubnet2RouteTableAssociationCF18C87A", + "FargateClusterDefaultVpcPublicSubnet2Subnet92A9CC93", + "FargateClusterDefaultVpcPublicSubnet3DefaultRoute8341F833", + "FargateClusterDefaultVpcPublicSubnet3EIP46E028EF", + "FargateClusterDefaultVpcPublicSubnet3NATGateway0AAE540F", + "FargateClusterDefaultVpcPublicSubnet3RouteTable4E802182", + "FargateClusterDefaultVpcPublicSubnet3RouteTableAssociation93B95514", + "FargateClusterDefaultVpcPublicSubnet3SubnetB408ADA9", + "FargateClusterDefaultVpcE69D3A13", + "FargateClusterDefaultVpcVPCGWA7F012E1" + ] + }, + "FargateCluster019F03E8": { + "Type": "Custom::AWSCDK-EKS-Cluster", + "Properties": { + "ServiceToken": { + "Fn::GetAtt": [ + "awscdkawseksClusterResourceProviderNestedStackawscdkawseksClusterResourceProviderNestedStackResource9827C454", + "Outputs.awscdkeksfargateclustertestawscdkawseksClusterResourceProviderframeworkonEventC85EBDF3Arn" + ] + }, + "Config": { + "version": "1.17", + "roleArn": { + "Fn::GetAtt": [ + "FargateClusterRole8E36B33A", + "Arn" + ] + }, + "resourcesVpcConfig": { + "subnetIds": [ + { + "Ref": "FargateClusterDefaultVpcPublicSubnet1Subnet96AFDABC" + }, + { + "Ref": "FargateClusterDefaultVpcPublicSubnet2Subnet92A9CC93" + }, + { + "Ref": "FargateClusterDefaultVpcPublicSubnet3SubnetB408ADA9" + }, + { + "Ref": "FargateClusterDefaultVpcPrivateSubnet1Subnet50EA43AA" + }, + { + "Ref": "FargateClusterDefaultVpcPrivateSubnet2Subnet0C9D6154" + }, + { + "Ref": "FargateClusterDefaultVpcPrivateSubnet3Subnet1F8A52F1" + } + ], + "securityGroupIds": [ + { + "Fn::GetAtt": [ + "FargateClusterControlPlaneSecurityGroup1021A150", + "GroupId" + ] + } + ], + "endpointPublicAccess": true, + "endpointPrivateAccess": true + } + }, + "AssumeRoleArn": { + "Fn::GetAtt": [ + "FargateClusterCreationRole8C524AD8", + "Arn" + ] + }, + "AttributesRevision": 2 + }, + "DependsOn": [ + "FargateClusterDefaultVpcIGWFD9278DA", + "FargateClusterDefaultVpcPrivateSubnet1DefaultRouteE93D7B93", + "FargateClusterDefaultVpcPrivateSubnet1RouteTableA42013EB", + "FargateClusterDefaultVpcPrivateSubnet1RouteTableAssociationDC34627F", + "FargateClusterDefaultVpcPrivateSubnet1Subnet50EA43AA", + "FargateClusterDefaultVpcPrivateSubnet2DefaultRouteABCE20FF", + "FargateClusterDefaultVpcPrivateSubnet2RouteTable1691B33C", + "FargateClusterDefaultVpcPrivateSubnet2RouteTableAssociation6C0234FE", + "FargateClusterDefaultVpcPrivateSubnet2Subnet0C9D6154", + "FargateClusterDefaultVpcPrivateSubnet3DefaultRouteEFE144B5", + "FargateClusterDefaultVpcPrivateSubnet3RouteTable7D0EEC96", + "FargateClusterDefaultVpcPrivateSubnet3RouteTableAssociationCC0949D8", + "FargateClusterDefaultVpcPrivateSubnet3Subnet1F8A52F1", + "FargateClusterDefaultVpcPublicSubnet1DefaultRouteA0A93C70", + "FargateClusterDefaultVpcPublicSubnet1EIP0093A4E0", + "FargateClusterDefaultVpcPublicSubnet1NATGatewayEC4DEB51", + "FargateClusterDefaultVpcPublicSubnet1RouteTableC2D2B434", + "FargateClusterDefaultVpcPublicSubnet1RouteTableAssociation43821F5B", + "FargateClusterDefaultVpcPublicSubnet1Subnet96AFDABC", + "FargateClusterDefaultVpcPublicSubnet2DefaultRouteABE51CF2", + "FargateClusterDefaultVpcPublicSubnet2EIPA4C07B68", + "FargateClusterDefaultVpcPublicSubnet2NATGateway77D6A579", + "FargateClusterDefaultVpcPublicSubnet2RouteTableEDDB89D9", + "FargateClusterDefaultVpcPublicSubnet2RouteTableAssociationCF18C87A", + "FargateClusterDefaultVpcPublicSubnet2Subnet92A9CC93", + "FargateClusterDefaultVpcPublicSubnet3DefaultRoute8341F833", + "FargateClusterDefaultVpcPublicSubnet3EIP46E028EF", + "FargateClusterDefaultVpcPublicSubnet3NATGateway0AAE540F", + "FargateClusterDefaultVpcPublicSubnet3RouteTable4E802182", + "FargateClusterDefaultVpcPublicSubnet3RouteTableAssociation93B95514", + "FargateClusterDefaultVpcPublicSubnet3SubnetB408ADA9", + "FargateClusterDefaultVpcE69D3A13", + "FargateClusterDefaultVpcVPCGWA7F012E1", + "FargateClusterCreationRoleDefaultPolicy629049D0", + "FargateClusterCreationRole8C524AD8" + ], + "UpdateReplacePolicy": "Delete", + "DeletionPolicy": "Delete" + }, + "FargateClusterKubectlReadyBarrier93746934": { + "Type": "AWS::SSM::Parameter", + "Properties": { + "Type": "String", + "Value": "aws:cdk:eks:kubectl-ready" + }, + "DependsOn": [ + "FargateClusterfargateprofiledefaultPodExecutionRole66F2610E", + "FargateClusterfargateprofiledefault10E54561", + "FargateClusterCreationRoleDefaultPolicy629049D0", + "FargateClusterCreationRole8C524AD8", + "FargateCluster019F03E8" + ] + }, + "FargateClusterMastersRole50BAF9FD": { + "Type": "AWS::IAM::Role", + "Properties": { + "AssumeRolePolicyDocument": { + "Statement": [ + { + "Action": "sts:AssumeRole", + "Effect": "Allow", + "Principal": { + "AWS": { + "Fn::Join": [ + "", + [ + "arn:", + { + "Ref": "AWS::Partition" + }, + ":iam::12345678:root" + ] + ] + } + } + } + ], + "Version": "2012-10-17" + } + } + }, + "FargateClusterAwsAuthmanifest1F7A5553": { + "Type": "Custom::AWSCDK-EKS-KubernetesResource", + "Properties": { + "ServiceToken": { + "Fn::GetAtt": [ + "awscdkawseksKubectlProviderNestedStackawscdkawseksKubectlProviderNestedStackResourceA7AEBA6B", + "Outputs.awscdkeksfargateclustertestawscdkawseksKubectlProviderframeworkonEvent33B2ACA4Arn" + ] + }, + "Manifest": { + "Fn::Join": [ + "", + [ + "[{\"apiVersion\":\"v1\",\"kind\":\"ConfigMap\",\"metadata\":{\"name\":\"aws-auth\",\"namespace\":\"kube-system\"},\"data\":{\"mapRoles\":\"[{\\\"rolearn\\\":\\\"", + { + "Fn::GetAtt": [ + "FargateClusterMastersRole50BAF9FD", + "Arn" + ] + }, + "\\\",\\\"username\\\":\\\"", + { + "Fn::GetAtt": [ + "FargateClusterMastersRole50BAF9FD", + "Arn" + ] + }, + "\\\",\\\"groups\\\":[\\\"system:masters\\\"]},{\\\"rolearn\\\":\\\"", + { + "Fn::GetAtt": [ + "FargateClusterfargateprofiledefaultPodExecutionRole66F2610E", + "Arn" + ] + }, + "\\\",\\\"username\\\":\\\"system:node:{{SessionName}}\\\",\\\"groups\\\":[\\\"system:bootstrappers\\\",\\\"system:nodes\\\",\\\"system:node-proxier\\\"]}]\",\"mapUsers\":\"[]\",\"mapAccounts\":\"[]\"}}]" + ] + ] + }, + "ClusterName": { + "Ref": "FargateCluster019F03E8" + }, + "RoleArn": { + "Fn::GetAtt": [ + "FargateClusterCreationRole8C524AD8", + "Arn" + ] + } + }, + "DependsOn": [ + "FargateClusterKubectlReadyBarrier93746934" + ], + "UpdateReplacePolicy": "Delete", + "DeletionPolicy": "Delete" + }, + "FargateClusterCoreDnsComputeTypePatch711BF1B2": { + "Type": "Custom::AWSCDK-EKS-KubernetesPatch", + "Properties": { + "ServiceToken": { + "Fn::GetAtt": [ + "awscdkawseksKubectlProviderNestedStackawscdkawseksKubectlProviderNestedStackResourceA7AEBA6B", + "Outputs.awscdkeksfargateclustertestawscdkawseksKubectlProviderframeworkonEvent33B2ACA4Arn" + ] + }, + "ResourceName": "deployment/coredns", + "ResourceNamespace": "kube-system", + "ApplyPatchJson": "{\"spec\":{\"template\":{\"metadata\":{\"annotations\":{\"eks.amazonaws.com/compute-type\":\"fargate\"}}}}}", + "RestorePatchJson": "{\"spec\":{\"template\":{\"metadata\":{\"annotations\":{\"eks.amazonaws.com/compute-type\":\"ec2\"}}}}}", + "ClusterName": { + "Ref": "FargateCluster019F03E8" + }, + "RoleArn": { + "Fn::GetAtt": [ + "FargateClusterCreationRole8C524AD8", + "Arn" + ] + }, + "PatchType": "strategic" + }, + "DependsOn": [ + "FargateClusterKubectlReadyBarrier93746934" + ], + "UpdateReplacePolicy": "Delete", + "DeletionPolicy": "Delete" + }, + "FargateClusterfargateprofiledefaultPodExecutionRole66F2610E": { + "Type": "AWS::IAM::Role", + "Properties": { + "AssumeRolePolicyDocument": { + "Statement": [ + { + "Action": "sts:AssumeRole", + "Effect": "Allow", + "Principal": { + "Service": "eks-fargate-pods.amazonaws.com" + } + } + ], + "Version": "2012-10-17" + }, + "ManagedPolicyArns": [ + { + "Fn::Join": [ + "", + [ + "arn:", + { + "Ref": "AWS::Partition" + }, + ":iam::aws:policy/AmazonEKSFargatePodExecutionRolePolicy" + ] + ] + } + ] + } + }, + "FargateClusterfargateprofiledefault10E54561": { + "Type": "Custom::AWSCDK-EKS-FargateProfile", + "Properties": { + "ServiceToken": { + "Fn::GetAtt": [ + "awscdkawseksClusterResourceProviderNestedStackawscdkawseksClusterResourceProviderNestedStackResource9827C454", + "Outputs.awscdkeksfargateclustertestawscdkawseksClusterResourceProviderframeworkonEventC85EBDF3Arn" + ] + }, + "AssumeRoleArn": { + "Fn::GetAtt": [ + "FargateClusterCreationRole8C524AD8", + "Arn" + ] + }, + "Config": { + "clusterName": { + "Ref": "FargateCluster019F03E8" + }, + "podExecutionRoleArn": { + "Fn::GetAtt": [ + "FargateClusterfargateprofiledefaultPodExecutionRole66F2610E", + "Arn" + ] + }, + "selectors": [ + { + "namespace": "default" + }, + { + "namespace": "kube-system" + } + ] + } + }, + "UpdateReplacePolicy": "Delete", + "DeletionPolicy": "Delete" + }, + "awscdkawseksClusterResourceProviderNestedStackawscdkawseksClusterResourceProviderNestedStackResource9827C454": { + "Type": "AWS::CloudFormation::Stack", + "Properties": { + "TemplateURL": { + "Fn::Join": [ + "", + [ + "https://s3.test-region.", + { + "Ref": "AWS::URLSuffix" + }, + "/", + { + "Ref": "AssetParametersbedcab6ba6cdb530ab9574b630651abdee4c67fb22c69ad17ab3b4369d3b7c89S3Bucket60C2BF28" + }, + "/", + { + "Fn::Select": [ + 0, + { + "Fn::Split": [ + "||", + { + "Ref": "AssetParametersbedcab6ba6cdb530ab9574b630651abdee4c67fb22c69ad17ab3b4369d3b7c89S3VersionKey81C20166" + } + ] + } + ] + }, + { + "Fn::Select": [ + 1, + { + "Fn::Split": [ + "||", + { + "Ref": "AssetParametersbedcab6ba6cdb530ab9574b630651abdee4c67fb22c69ad17ab3b4369d3b7c89S3VersionKey81C20166" + } + ] + } + ] + } + ] + ] + }, + "Parameters": { + "referencetoawscdkeksfargateclustertestFargateClusterCreationRoleFB2229CFArn": { + "Fn::GetAtt": [ + "FargateClusterCreationRole8C524AD8", + "Arn" + ] + }, + "referencetoawscdkeksfargateclustertestAssetParameters87b1e2c41f84590d14f7ab8cb0f338c51d6fa3efe78943867af07fa959593dbaS3Bucket122A6EA8Ref": { + "Ref": "AssetParameters87b1e2c41f84590d14f7ab8cb0f338c51d6fa3efe78943867af07fa959593dbaS3Bucket14D204F9" + }, + "referencetoawscdkeksfargateclustertestAssetParameters87b1e2c41f84590d14f7ab8cb0f338c51d6fa3efe78943867af07fa959593dbaS3VersionKey56570425Ref": { + "Ref": "AssetParameters87b1e2c41f84590d14f7ab8cb0f338c51d6fa3efe78943867af07fa959593dbaS3VersionKeyDE8A2F1F" + }, + "referencetoawscdkeksfargateclustertestAssetParameters5db52e19f1f79cac27e817fa59d0b1f73d524301b679e2e7354122e474fcba0cS3Bucket7ABEDF68Ref": { + "Ref": "AssetParameters5db52e19f1f79cac27e817fa59d0b1f73d524301b679e2e7354122e474fcba0cS3Bucket8132A6E0" + }, + "referencetoawscdkeksfargateclustertestAssetParameters5db52e19f1f79cac27e817fa59d0b1f73d524301b679e2e7354122e474fcba0cS3VersionKey810DC943Ref": { + "Ref": "AssetParameters5db52e19f1f79cac27e817fa59d0b1f73d524301b679e2e7354122e474fcba0cS3VersionKey722E831A" + } + } + } + }, + "awscdkawseksKubectlProviderNestedStackawscdkawseksKubectlProviderNestedStackResourceA7AEBA6B": { + "Type": "AWS::CloudFormation::Stack", + "Properties": { + "TemplateURL": { + "Fn::Join": [ + "", + [ + "https://s3.test-region.", + { + "Ref": "AWS::URLSuffix" + }, + "/", + { + "Ref": "AssetParametersc3e7ad226d0efc3c9ecf3b4c84ea434556c67008349c6cc43c1cdb58323ddf7cS3Bucket1E579A0A" + }, + "/", + { + "Fn::Select": [ + 0, + { + "Fn::Split": [ + "||", + { + "Ref": "AssetParametersc3e7ad226d0efc3c9ecf3b4c84ea434556c67008349c6cc43c1cdb58323ddf7cS3VersionKey91701E13" + } + ] + } + ] + }, + { + "Fn::Select": [ + 1, + { + "Fn::Split": [ + "||", + { + "Ref": "AssetParametersc3e7ad226d0efc3c9ecf3b4c84ea434556c67008349c6cc43c1cdb58323ddf7cS3VersionKey91701E13" + } + ] + } + ] + } + ] + ] + }, + "Parameters": { + "referencetoawscdkeksfargateclustertestFargateCluster8588769EArn": { + "Fn::GetAtt": [ + "FargateCluster019F03E8", + "Arn" + ] + }, + "referencetoawscdkeksfargateclustertestFargateClusterCreationRoleFB2229CFArn": { + "Fn::GetAtt": [ + "FargateClusterCreationRole8C524AD8", + "Arn" + ] + }, + "referencetoawscdkeksfargateclustertestAssetParametersb7d8a9750f8bfded8ac76be100e3bee1c3d4824df006766110d023f42952f5c2S3BucketF3D15942Ref": { + "Ref": "AssetParametersb7d8a9750f8bfded8ac76be100e3bee1c3d4824df006766110d023f42952f5c2S3Bucket9ABBD5A2" + }, + "referencetoawscdkeksfargateclustertestAssetParametersb7d8a9750f8bfded8ac76be100e3bee1c3d4824df006766110d023f42952f5c2S3VersionKey362BF04DRef": { + "Ref": "AssetParametersb7d8a9750f8bfded8ac76be100e3bee1c3d4824df006766110d023f42952f5c2S3VersionKey40FF2C4A" + }, + "referencetoawscdkeksfargateclustertestFargateClusterDefaultVpcPrivateSubnet1Subnet0278E6BCRef": { + "Ref": "FargateClusterDefaultVpcPrivateSubnet1Subnet50EA43AA" + }, + "referencetoawscdkeksfargateclustertestFargateClusterDefaultVpcPrivateSubnet2Subnet1F1EC575Ref": { + "Ref": "FargateClusterDefaultVpcPrivateSubnet2Subnet0C9D6154" + }, + "referencetoawscdkeksfargateclustertestFargateClusterDefaultVpcPrivateSubnet3Subnet3A4CBF94Ref": { + "Ref": "FargateClusterDefaultVpcPrivateSubnet3Subnet1F8A52F1" + }, + "referencetoawscdkeksfargateclustertestFargateCluster8588769EClusterSecurityGroupId": { + "Fn::GetAtt": [ + "FargateCluster019F03E8", + "ClusterSecurityGroupId" + ] + }, + "referencetoawscdkeksfargateclustertestAssetParameters5db52e19f1f79cac27e817fa59d0b1f73d524301b679e2e7354122e474fcba0cS3Bucket7ABEDF68Ref": { + "Ref": "AssetParameters5db52e19f1f79cac27e817fa59d0b1f73d524301b679e2e7354122e474fcba0cS3Bucket8132A6E0" + }, + "referencetoawscdkeksfargateclustertestAssetParameters5db52e19f1f79cac27e817fa59d0b1f73d524301b679e2e7354122e474fcba0cS3VersionKey810DC943Ref": { + "Ref": "AssetParameters5db52e19f1f79cac27e817fa59d0b1f73d524301b679e2e7354122e474fcba0cS3VersionKey722E831A" + } + } + } + } + }, + "Outputs": { + "FargateClusterConfigCommand46D4A6C7": { + "Value": { + "Fn::Join": [ + "", + [ + "aws eks update-kubeconfig --name ", + { + "Ref": "FargateCluster019F03E8" + }, + " --region test-region --role-arn ", + { + "Fn::GetAtt": [ + "FargateClusterMastersRole50BAF9FD", + "Arn" + ] + } + ] + ] + } + }, + "FargateClusterGetTokenCommand4ADED7BB": { + "Value": { + "Fn::Join": [ + "", + [ + "aws eks get-token --cluster-name ", + { + "Ref": "FargateCluster019F03E8" + }, + " --region test-region --role-arn ", + { + "Fn::GetAtt": [ + "FargateClusterMastersRole50BAF9FD", + "Arn" + ] + } + ] + ] + } + } + }, + "Parameters": { + "AssetParameters87b1e2c41f84590d14f7ab8cb0f338c51d6fa3efe78943867af07fa959593dbaS3Bucket14D204F9": { + "Type": "String", + "Description": "S3 bucket for asset \"87b1e2c41f84590d14f7ab8cb0f338c51d6fa3efe78943867af07fa959593dba\"" + }, + "AssetParameters87b1e2c41f84590d14f7ab8cb0f338c51d6fa3efe78943867af07fa959593dbaS3VersionKeyDE8A2F1F": { + "Type": "String", + "Description": "S3 key for asset version \"87b1e2c41f84590d14f7ab8cb0f338c51d6fa3efe78943867af07fa959593dba\"" + }, + "AssetParameters87b1e2c41f84590d14f7ab8cb0f338c51d6fa3efe78943867af07fa959593dbaArtifactHash54822A43": { + "Type": "String", + "Description": "Artifact hash for asset \"87b1e2c41f84590d14f7ab8cb0f338c51d6fa3efe78943867af07fa959593dba\"" + }, + "AssetParameters5db52e19f1f79cac27e817fa59d0b1f73d524301b679e2e7354122e474fcba0cS3Bucket8132A6E0": { + "Type": "String", + "Description": "S3 bucket for asset \"5db52e19f1f79cac27e817fa59d0b1f73d524301b679e2e7354122e474fcba0c\"" + }, + "AssetParameters5db52e19f1f79cac27e817fa59d0b1f73d524301b679e2e7354122e474fcba0cS3VersionKey722E831A": { + "Type": "String", + "Description": "S3 key for asset version \"5db52e19f1f79cac27e817fa59d0b1f73d524301b679e2e7354122e474fcba0c\"" + }, + "AssetParameters5db52e19f1f79cac27e817fa59d0b1f73d524301b679e2e7354122e474fcba0cArtifactHash67988836": { + "Type": "String", + "Description": "Artifact hash for asset \"5db52e19f1f79cac27e817fa59d0b1f73d524301b679e2e7354122e474fcba0c\"" + }, + "AssetParametersb7d8a9750f8bfded8ac76be100e3bee1c3d4824df006766110d023f42952f5c2S3Bucket9ABBD5A2": { + "Type": "String", + "Description": "S3 bucket for asset \"b7d8a9750f8bfded8ac76be100e3bee1c3d4824df006766110d023f42952f5c2\"" + }, + "AssetParametersb7d8a9750f8bfded8ac76be100e3bee1c3d4824df006766110d023f42952f5c2S3VersionKey40FF2C4A": { + "Type": "String", + "Description": "S3 key for asset version \"b7d8a9750f8bfded8ac76be100e3bee1c3d4824df006766110d023f42952f5c2\"" + }, + "AssetParametersb7d8a9750f8bfded8ac76be100e3bee1c3d4824df006766110d023f42952f5c2ArtifactHashE86B38C7": { + "Type": "String", + "Description": "Artifact hash for asset \"b7d8a9750f8bfded8ac76be100e3bee1c3d4824df006766110d023f42952f5c2\"" + }, + "AssetParametersbedcab6ba6cdb530ab9574b630651abdee4c67fb22c69ad17ab3b4369d3b7c89S3Bucket60C2BF28": { + "Type": "String", + "Description": "S3 bucket for asset \"bedcab6ba6cdb530ab9574b630651abdee4c67fb22c69ad17ab3b4369d3b7c89\"" + }, + "AssetParametersbedcab6ba6cdb530ab9574b630651abdee4c67fb22c69ad17ab3b4369d3b7c89S3VersionKey81C20166": { + "Type": "String", + "Description": "S3 key for asset version \"bedcab6ba6cdb530ab9574b630651abdee4c67fb22c69ad17ab3b4369d3b7c89\"" + }, + "AssetParametersbedcab6ba6cdb530ab9574b630651abdee4c67fb22c69ad17ab3b4369d3b7c89ArtifactHashC2E43922": { + "Type": "String", + "Description": "Artifact hash for asset \"bedcab6ba6cdb530ab9574b630651abdee4c67fb22c69ad17ab3b4369d3b7c89\"" + }, + "AssetParametersc3e7ad226d0efc3c9ecf3b4c84ea434556c67008349c6cc43c1cdb58323ddf7cS3Bucket1E579A0A": { + "Type": "String", + "Description": "S3 bucket for asset \"c3e7ad226d0efc3c9ecf3b4c84ea434556c67008349c6cc43c1cdb58323ddf7c\"" + }, + "AssetParametersc3e7ad226d0efc3c9ecf3b4c84ea434556c67008349c6cc43c1cdb58323ddf7cS3VersionKey91701E13": { + "Type": "String", + "Description": "S3 key for asset version \"c3e7ad226d0efc3c9ecf3b4c84ea434556c67008349c6cc43c1cdb58323ddf7c\"" + }, + "AssetParametersc3e7ad226d0efc3c9ecf3b4c84ea434556c67008349c6cc43c1cdb58323ddf7cArtifactHash4D9F989B": { + "Type": "String", + "Description": "Artifact hash for asset \"c3e7ad226d0efc3c9ecf3b4c84ea434556c67008349c6cc43c1cdb58323ddf7c\"" + } + } +} \ No newline at end of file diff --git a/packages/@aws-cdk/aws-eks/test/integ.fargate-cluster.ts b/packages/@aws-cdk/aws-eks/test/integ.fargate-cluster.ts new file mode 100644 index 0000000000000..870b3059b1a2b --- /dev/null +++ b/packages/@aws-cdk/aws-eks/test/integ.fargate-cluster.ts @@ -0,0 +1,21 @@ +/// !cdk-integ pragma:ignore-assets +import { App } from '@aws-cdk/core'; +import * as eks from '../lib'; +import { TestStack } from './util'; + +class EksFargateClusterStack extends TestStack { + + constructor(scope: App, id: string) { + super(scope, id); + + new eks.FargateCluster(this, 'FargateCluster', { + version: eks.KubernetesVersion.V1_17, + }); + } +} + +const app = new App(); + +new EksFargateClusterStack(app, 'aws-cdk-eks-fargate-cluster-test'); + +app.synth(); \ No newline at end of file diff --git a/packages/@aws-cdk/aws-eks/test/test.k8s-patch.ts b/packages/@aws-cdk/aws-eks/test/test.k8s-patch.ts index e77035688b19e..c4defdf107606 100644 --- a/packages/@aws-cdk/aws-eks/test/test.k8s-patch.ts +++ b/packages/@aws-cdk/aws-eks/test/test.k8s-patch.ts @@ -13,7 +13,7 @@ export = { const cluster = new eks.Cluster(stack, 'MyCluster', { version: CLUSTER_VERSION }); // WHEN - new KubernetesPatch(stack, 'MyPatch', { + const patch = new KubernetesPatch(stack, 'MyPatch', { cluster, applyPatch: { patch: { to: 'apply' } }, restorePatch: { restore: { patch: 123 } }, @@ -42,6 +42,10 @@ export = { ], }, })); + + // also make sure a dependency on the barrier is added to the patch construct. + test.deepEqual(patch.node.dependencies.map(d => d.target.node.uniqueId), ['MyClusterKubectlReadyBarrier7547948A']); + test.done(); }, 'defaults to "strategic" patch type if no patchType is specified'(test: Test) { From c0602d71bf0f13c9be4044905bf765fe29e72525 Mon Sep 17 00:00:00 2001 From: epolon Date: Fri, 25 Sep 2020 19:33:31 +0300 Subject: [PATCH 23/29] chore(release): 1.64.1 --- CHANGELOG.md | 7 +++++++ lerna.json | 2 +- 2 files changed, 8 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 77867355f3560..3e73ff4585a48 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,13 @@ All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines. +### [1.64.1](https://github.com/aws/aws-cdk/compare/v1.64.0...v1.64.1) (2020-09-25) + + +### Bug Fixes + +* **eks:** `KubernetesPatch` and `FargateCluster` creates a circular dependency and breaks deployment ([#10536](https://github.com/aws/aws-cdk/issues/10536)) ([f0f8a63](https://github.com/aws/aws-cdk/commit/f0f8a63c98e8a7ff5bedcf271a78fcb417988378)), closes [40aws-cdk/aws-eks/lib/k8s-manifest.ts#L58](https://github.com/40aws-cdk/aws-eks/lib/k8s-manifest.ts/issues/L58) [40aws-cdk/aws-eks/lib/k8s-object-value.ts#L64](https://github.com/40aws-cdk/aws-eks/lib/k8s-object-value.ts/issues/L64) [40aws-cdk/aws-eks/lib/k8s-patch.ts#L74](https://github.com/40aws-cdk/aws-eks/lib/k8s-patch.ts/issues/L74) + ## [1.64.0](https://github.com/aws/aws-cdk/compare/v1.63.0...v1.64.0) (2020-09-22) diff --git a/lerna.json b/lerna.json index 7b4680783877f..dab86c14f2229 100644 --- a/lerna.json +++ b/lerna.json @@ -10,5 +10,5 @@ "tools/*" ], "rejectCycles": "true", - "version": "1.64.0" + "version": "1.64.1" } From 423d704f1ecfedf3756ce6b995fed4f5d3e87da6 Mon Sep 17 00:00:00 2001 From: epolon Date: Fri, 25 Sep 2020 19:35:48 +0300 Subject: [PATCH 24/29] Fix CHANGELOG header --- CHANGELOG.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 3e73ff4585a48..bfbe72373287c 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,7 +2,7 @@ All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines. -### [1.64.1](https://github.com/aws/aws-cdk/compare/v1.64.0...v1.64.1) (2020-09-25) +## [1.64.1](https://github.com/aws/aws-cdk/compare/v1.64.0...v1.64.1) (2020-09-25) ### Bug Fixes From 10c7b497525ffb2acf79215140d699a56117aa15 Mon Sep 17 00:00:00 2001 From: epolon Date: Fri, 25 Sep 2020 19:42:45 +0300 Subject: [PATCH 25/29] Fix CHANGELOG entry corruption --- CHANGELOG.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index bfbe72373287c..408ea09b12e14 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -7,7 +7,7 @@ All notable changes to this project will be documented in this file. See [standa ### Bug Fixes -* **eks:** `KubernetesPatch` and `FargateCluster` creates a circular dependency and breaks deployment ([#10536](https://github.com/aws/aws-cdk/issues/10536)) ([f0f8a63](https://github.com/aws/aws-cdk/commit/f0f8a63c98e8a7ff5bedcf271a78fcb417988378)), closes [40aws-cdk/aws-eks/lib/k8s-manifest.ts#L58](https://github.com/40aws-cdk/aws-eks/lib/k8s-manifest.ts/issues/L58) [40aws-cdk/aws-eks/lib/k8s-object-value.ts#L64](https://github.com/40aws-cdk/aws-eks/lib/k8s-object-value.ts/issues/L64) [40aws-cdk/aws-eks/lib/k8s-patch.ts#L74](https://github.com/40aws-cdk/aws-eks/lib/k8s-patch.ts/issues/L74) +* **eks:** `KubernetesPatch` and `FargateCluster` creates a circular dependency and breaks deployment ([#10536](https://github.com/aws/aws-cdk/issues/10536)) ([f0f8a63](https://github.com/aws/aws-cdk/commit/f0f8a63c98e8a7ff5bedcf271a78fcb417988378)), closes [#10528](https://github.com/aws/aws-cdk/issues/10528) ## [1.64.0](https://github.com/aws/aws-cdk/compare/v1.63.0...v1.64.0) (2020-09-22) From bd8e07de8b4cb002a0af8ef5be21fde77fce86d7 Mon Sep 17 00:00:00 2001 From: Neta Nir Date: Fri, 25 Sep 2020 10:23:46 -0700 Subject: [PATCH 26/29] chore: add patch for regression integ tests v1.64 (#10542) ---- *By submitting this pull request, I confirm that my contribution is made under the terms of the Apache-2.0 license* --- .../v1.64.0/cli.integtest.js | 599 ++++++++++++++++++ 1 file changed, 599 insertions(+) create mode 100644 packages/aws-cdk/test/integ/cli-regression-patches/v1.64.0/cli.integtest.js diff --git a/packages/aws-cdk/test/integ/cli-regression-patches/v1.64.0/cli.integtest.js b/packages/aws-cdk/test/integ/cli-regression-patches/v1.64.0/cli.integtest.js new file mode 100644 index 0000000000000..a63578ecfaee1 --- /dev/null +++ b/packages/aws-cdk/test/integ/cli-regression-patches/v1.64.0/cli.integtest.js @@ -0,0 +1,599 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const fs_1 = require("fs"); +const os = require("os"); +const path = require("path"); +const aws_helpers_1 = require("./aws-helpers"); +const cdk_helpers_1 = require("./cdk-helpers"); +const test_helpers_1 = require("./test-helpers"); +jest.setTimeout(600 * 1000); +test_helpers_1.integTest('VPC Lookup', cdk_helpers_1.withDefaultFixture(async (fixture) => { + fixture.log('Making sure we are clean before starting.'); + await fixture.cdkDestroy('define-vpc', { modEnv: { ENABLE_VPC_TESTING: 'DEFINE' } }); + fixture.log('Setting up: creating a VPC with known tags'); + await fixture.cdkDeploy('define-vpc', { modEnv: { ENABLE_VPC_TESTING: 'DEFINE' } }); + fixture.log('Setup complete!'); + fixture.log('Verifying we can now import that VPC'); + await fixture.cdkDeploy('import-vpc', { modEnv: { ENABLE_VPC_TESTING: 'IMPORT' } }); +})); +test_helpers_1.integTest('Two ways of shoing the version', cdk_helpers_1.withDefaultFixture(async (fixture) => { + const version1 = await fixture.cdk(['version'], { verbose: false }); + const version2 = await fixture.cdk(['--version'], { verbose: false }); + expect(version1).toEqual(version2); +})); +test_helpers_1.integTest('Termination protection', cdk_helpers_1.withDefaultFixture(async (fixture) => { + const stackName = 'termination-protection'; + await fixture.cdkDeploy(stackName); + // Try a destroy that should fail + await expect(fixture.cdkDestroy(stackName)).rejects.toThrow('exited with error'); + // Can update termination protection even though the change set doesn't contain changes + await fixture.cdkDeploy(stackName, { modEnv: { TERMINATION_PROTECTION: 'FALSE' } }); + await fixture.cdkDestroy(stackName); +})); +test_helpers_1.integTest('cdk synth', cdk_helpers_1.withDefaultFixture(async (fixture) => { + await expect(fixture.cdk(['synth', fixture.fullStackName('test-1')], { verbose: false })).resolves.toEqual(`Resources: + topic69831491: + Type: AWS::SNS::Topic + Metadata: + aws:cdk:path: ${fixture.stackNamePrefix}-test-1/topic/Resource`); + await expect(fixture.cdk(['synth', fixture.fullStackName('test-2')], { verbose: false })).resolves.toEqual(`Resources: + topic152D84A37: + Type: AWS::SNS::Topic + Metadata: + aws:cdk:path: ${fixture.stackNamePrefix}-test-2/topic1/Resource + topic2A4FB547F: + Type: AWS::SNS::Topic + Metadata: + aws:cdk:path: ${fixture.stackNamePrefix}-test-2/topic2/Resource`); +})); +test_helpers_1.integTest('ssm parameter provider error', cdk_helpers_1.withDefaultFixture(async (fixture) => { + await expect(fixture.cdk(['synth', + fixture.fullStackName('missing-ssm-parameter'), + '-c', 'test:ssm-parameter-name=/does/not/exist'], { + allowErrExit: true, + })).resolves.toContain('SSM parameter not available in account'); +})); +test_helpers_1.integTest('automatic ordering', cdk_helpers_1.withDefaultFixture(async (fixture) => { + // Deploy the consuming stack which will include the producing stack + await fixture.cdkDeploy('order-consuming'); + // Destroy the providing stack which will include the consuming stack + await fixture.cdkDestroy('order-providing'); +})); +test_helpers_1.integTest('context setting', cdk_helpers_1.withDefaultFixture(async (fixture) => { + await fs_1.promises.writeFile(path.join(fixture.integTestDir, 'cdk.context.json'), JSON.stringify({ + contextkey: 'this is the context value', + })); + try { + await expect(fixture.cdk(['context'])).resolves.toContain('this is the context value'); + // Test that deleting the contextkey works + await fixture.cdk(['context', '--reset', 'contextkey']); + await expect(fixture.cdk(['context'])).resolves.not.toContain('this is the context value'); + // Test that forced delete of the context key does not throw + await fixture.cdk(['context', '-f', '--reset', 'contextkey']); + } + finally { + await fs_1.promises.unlink(path.join(fixture.integTestDir, 'cdk.context.json')); + } +})); +test_helpers_1.integTest('deploy', cdk_helpers_1.withDefaultFixture(async (fixture) => { + var _a; + const stackArn = await fixture.cdkDeploy('test-2', { captureStderr: false }); + // verify the number of resources in the stack + const response = await fixture.aws.cloudFormation('describeStackResources', { + StackName: stackArn, + }); + expect((_a = response.StackResources) === null || _a === void 0 ? void 0 : _a.length).toEqual(2); +})); +test_helpers_1.integTest('deploy all', cdk_helpers_1.withDefaultFixture(async (fixture) => { + const arns = await fixture.cdkDeploy('test-*', { captureStderr: false }); + // verify that we only deployed a single stack (there's a single ARN in the output) + expect(arns.split('\n').length).toEqual(2); +})); +test_helpers_1.integTest('nested stack with parameters', cdk_helpers_1.withDefaultFixture(async (fixture) => { + var _a; + // STACK_NAME_PREFIX is used in MyTopicParam to allow multiple instances + // of this test to run in parallel, othewise they will attempt to create the same SNS topic. + const stackArn = await fixture.cdkDeploy('with-nested-stack-using-parameters', { + options: ['--parameters', `MyTopicParam=${fixture.stackNamePrefix}ThereIsNoSpoon`], + captureStderr: false, + }); + // verify that we only deployed a single stack (there's a single ARN in the output) + expect(stackArn.split('\n').length).toEqual(1); + // verify the number of resources in the stack + const response = await fixture.aws.cloudFormation('describeStackResources', { + StackName: stackArn, + }); + expect((_a = response.StackResources) === null || _a === void 0 ? void 0 : _a.length).toEqual(1); +})); +test_helpers_1.integTest('deploy without execute', cdk_helpers_1.withDefaultFixture(async (fixture) => { + var _a; + const stackArn = await fixture.cdkDeploy('test-2', { + options: ['--no-execute'], + captureStderr: false, + }); + // verify that we only deployed a single stack (there's a single ARN in the output) + expect(stackArn.split('\n').length).toEqual(1); + const response = await fixture.aws.cloudFormation('describeStacks', { + StackName: stackArn, + }); + expect((_a = response.Stacks) === null || _a === void 0 ? void 0 : _a[0].StackStatus).toEqual('REVIEW_IN_PROGRESS'); +})); +test_helpers_1.integTest('security related changes without a CLI are expected to fail', cdk_helpers_1.withDefaultFixture(async (fixture) => { + // redirect /dev/null to stdin, which means there will not be tty attached + // since this stack includes security-related changes, the deployment should + // immediately fail because we can't confirm the changes + const stackName = 'iam-test'; + await expect(fixture.cdkDeploy(stackName, { + options: ['<', '/dev/null'], + neverRequireApproval: false, + })).rejects.toThrow('exited with error'); + // Ensure stack was not deployed + await expect(fixture.aws.cloudFormation('describeStacks', { + StackName: fixture.fullStackName(stackName), + })).rejects.toThrow('does not exist'); +})); +test_helpers_1.integTest('deploy wildcard with outputs', cdk_helpers_1.withDefaultFixture(async (fixture) => { + const outputsFile = path.join(fixture.integTestDir, 'outputs', 'outputs.json'); + await fs_1.promises.mkdir(path.dirname(outputsFile), { recursive: true }); + await fixture.cdkDeploy(['outputs-test-*'], { + options: ['--outputs-file', outputsFile], + }); + const outputs = JSON.parse((await fs_1.promises.readFile(outputsFile, { encoding: 'utf-8' })).toString()); + expect(outputs).toEqual({ + [`${fixture.stackNamePrefix}-outputs-test-1`]: { + TopicName: `${fixture.stackNamePrefix}-outputs-test-1MyTopic`, + }, + [`${fixture.stackNamePrefix}-outputs-test-2`]: { + TopicName: `${fixture.stackNamePrefix}-outputs-test-2MyOtherTopic`, + }, + }); +})); +test_helpers_1.integTest('deploy with parameters', cdk_helpers_1.withDefaultFixture(async (fixture) => { + var _a; + const stackArn = await fixture.cdkDeploy('param-test-1', { + options: [ + '--parameters', `TopicNameParam=${fixture.stackNamePrefix}bazinga`, + ], + captureStderr: false, + }); + const response = await fixture.aws.cloudFormation('describeStacks', { + StackName: stackArn, + }); + expect((_a = response.Stacks) === null || _a === void 0 ? void 0 : _a[0].Parameters).toEqual([ + { + ParameterKey: 'TopicNameParam', + ParameterValue: `${fixture.stackNamePrefix}bazinga`, + }, + ]); +})); +test_helpers_1.integTest('update to stack in ROLLBACK_COMPLETE state will delete stack and create a new one', cdk_helpers_1.withDefaultFixture(async (fixture) => { + var _a, _b, _c, _d; + // GIVEN + await expect(fixture.cdkDeploy('param-test-1', { + options: [ + '--parameters', `TopicNameParam=${fixture.stackNamePrefix}@aww`, + ], + captureStderr: false, + })).rejects.toThrow('exited with error'); + const response = await fixture.aws.cloudFormation('describeStacks', { + StackName: fixture.fullStackName('param-test-1'), + }); + const stackArn = (_a = response.Stacks) === null || _a === void 0 ? void 0 : _a[0].StackId; + expect((_b = response.Stacks) === null || _b === void 0 ? void 0 : _b[0].StackStatus).toEqual('ROLLBACK_COMPLETE'); + // WHEN + const newStackArn = await fixture.cdkDeploy('param-test-1', { + options: [ + '--parameters', `TopicNameParam=${fixture.stackNamePrefix}allgood`, + ], + captureStderr: false, + }); + const newStackResponse = await fixture.aws.cloudFormation('describeStacks', { + StackName: newStackArn, + }); + // THEN + expect(stackArn).not.toEqual(newStackArn); // new stack was created + expect((_c = newStackResponse.Stacks) === null || _c === void 0 ? void 0 : _c[0].StackStatus).toEqual('CREATE_COMPLETE'); + expect((_d = newStackResponse.Stacks) === null || _d === void 0 ? void 0 : _d[0].Parameters).toEqual([ + { + ParameterKey: 'TopicNameParam', + ParameterValue: `${fixture.stackNamePrefix}allgood`, + }, + ]); +})); +test_helpers_1.integTest('stack in UPDATE_ROLLBACK_COMPLETE state can be updated', cdk_helpers_1.withDefaultFixture(async (fixture) => { + var _a, _b, _c, _d; + // GIVEN + const stackArn = await fixture.cdkDeploy('param-test-1', { + options: [ + '--parameters', `TopicNameParam=${fixture.stackNamePrefix}nice`, + ], + captureStderr: false, + }); + let response = await fixture.aws.cloudFormation('describeStacks', { + StackName: stackArn, + }); + expect((_a = response.Stacks) === null || _a === void 0 ? void 0 : _a[0].StackStatus).toEqual('CREATE_COMPLETE'); + // bad parameter name with @ will put stack into UPDATE_ROLLBACK_COMPLETE + await expect(fixture.cdkDeploy('param-test-1', { + options: [ + '--parameters', `TopicNameParam=${fixture.stackNamePrefix}@aww`, + ], + captureStderr: false, + })).rejects.toThrow('exited with error'); + ; + response = await fixture.aws.cloudFormation('describeStacks', { + StackName: stackArn, + }); + expect((_b = response.Stacks) === null || _b === void 0 ? void 0 : _b[0].StackStatus).toEqual('UPDATE_ROLLBACK_COMPLETE'); + // WHEN + await fixture.cdkDeploy('param-test-1', { + options: [ + '--parameters', `TopicNameParam=${fixture.stackNamePrefix}allgood`, + ], + captureStderr: false, + }); + response = await fixture.aws.cloudFormation('describeStacks', { + StackName: stackArn, + }); + // THEN + expect((_c = response.Stacks) === null || _c === void 0 ? void 0 : _c[0].StackStatus).toEqual('UPDATE_COMPLETE'); + expect((_d = response.Stacks) === null || _d === void 0 ? void 0 : _d[0].Parameters).toEqual([ + { + ParameterKey: 'TopicNameParam', + ParameterValue: `${fixture.stackNamePrefix}allgood`, + }, + ]); +})); +test_helpers_1.integTest('deploy with wildcard and parameters', cdk_helpers_1.withDefaultFixture(async (fixture) => { + await fixture.cdkDeploy('param-test-*', { + options: [ + '--parameters', `${fixture.stackNamePrefix}-param-test-1:TopicNameParam=${fixture.stackNamePrefix}bazinga`, + '--parameters', `${fixture.stackNamePrefix}-param-test-2:OtherTopicNameParam=${fixture.stackNamePrefix}ThatsMySpot`, + '--parameters', `${fixture.stackNamePrefix}-param-test-3:DisplayNameParam=${fixture.stackNamePrefix}HeyThere`, + '--parameters', `${fixture.stackNamePrefix}-param-test-3:OtherDisplayNameParam=${fixture.stackNamePrefix}AnotherOne`, + ], + }); +})); +test_helpers_1.integTest('deploy with parameters multi', cdk_helpers_1.withDefaultFixture(async (fixture) => { + var _a; + const paramVal1 = `${fixture.stackNamePrefix}bazinga`; + const paramVal2 = `${fixture.stackNamePrefix}=jagshemash`; + const stackArn = await fixture.cdkDeploy('param-test-3', { + options: [ + '--parameters', `DisplayNameParam=${paramVal1}`, + '--parameters', `OtherDisplayNameParam=${paramVal2}`, + ], + captureStderr: false, + }); + const response = await fixture.aws.cloudFormation('describeStacks', { + StackName: stackArn, + }); + expect((_a = response.Stacks) === null || _a === void 0 ? void 0 : _a[0].Parameters).toEqual([ + { + ParameterKey: 'DisplayNameParam', + ParameterValue: paramVal1, + }, + { + ParameterKey: 'OtherDisplayNameParam', + ParameterValue: paramVal2, + }, + ]); +})); +test_helpers_1.integTest('deploy with notification ARN', cdk_helpers_1.withDefaultFixture(async (fixture) => { + var _a; + const topicName = `${fixture.stackNamePrefix}-test-topic`; + const response = await fixture.aws.sns('createTopic', { Name: topicName }); + const topicArn = response.TopicArn; + try { + await fixture.cdkDeploy('test-2', { + options: ['--notification-arns', topicArn], + }); + // verify that the stack we deployed has our notification ARN + const describeResponse = await fixture.aws.cloudFormation('describeStacks', { + StackName: fixture.fullStackName('test-2'), + }); + expect((_a = describeResponse.Stacks) === null || _a === void 0 ? void 0 : _a[0].NotificationARNs).toEqual([topicArn]); + } + finally { + await fixture.aws.sns('deleteTopic', { + TopicArn: topicArn, + }); + } +})); +test_helpers_1.integTest('deploy with role', cdk_helpers_1.withDefaultFixture(async (fixture) => { + const roleName = `${fixture.stackNamePrefix}-test-role`; + await deleteRole(); + const createResponse = await fixture.aws.iam('createRole', { + RoleName: roleName, + AssumeRolePolicyDocument: JSON.stringify({ + Version: '2012-10-17', + Statement: [{ + Action: 'sts:AssumeRole', + Principal: { Service: 'cloudformation.amazonaws.com' }, + Effect: 'Allow', + }, { + Action: 'sts:AssumeRole', + Principal: { AWS: (await fixture.aws.sts('getCallerIdentity', {})).Arn }, + Effect: 'Allow', + }], + }), + }); + const roleArn = createResponse.Role.Arn; + try { + await fixture.aws.iam('putRolePolicy', { + RoleName: roleName, + PolicyName: 'DefaultPolicy', + PolicyDocument: JSON.stringify({ + Version: '2012-10-17', + Statement: [{ + Action: '*', + Resource: '*', + Effect: 'Allow', + }], + }), + }); + await aws_helpers_1.retry(fixture.output, 'Trying to assume fresh role', aws_helpers_1.retry.forSeconds(300), async () => { + await fixture.aws.sts('assumeRole', { + RoleArn: roleArn, + RoleSessionName: 'testing', + }); + }); + // In principle, the role has replicated from 'us-east-1' to wherever we're testing. + // Give it a little more sleep to make sure CloudFormation is not hitting a box + // that doesn't have it yet. + await aws_helpers_1.sleep(5000); + await fixture.cdkDeploy('test-2', { + options: ['--role-arn', roleArn], + }); + // Immediately delete the stack again before we delete the role. + // + // Since roles are sticky, if we delete the role before the stack, subsequent DeleteStack + // operations will fail when CloudFormation tries to assume the role that's already gone. + await fixture.cdkDestroy('test-2'); + } + finally { + await deleteRole(); + } + async function deleteRole() { + try { + for (const policyName of (await fixture.aws.iam('listRolePolicies', { RoleName: roleName })).PolicyNames) { + await fixture.aws.iam('deleteRolePolicy', { + RoleName: roleName, + PolicyName: policyName, + }); + } + await fixture.aws.iam('deleteRole', { RoleName: roleName }); + } + catch (e) { + if (e.message.indexOf('cannot be found') > -1) { + return; + } + throw e; + } + } +})); +test_helpers_1.integTest('cdk diff', cdk_helpers_1.withDefaultFixture(async (fixture) => { + const diff1 = await fixture.cdk(['diff', fixture.fullStackName('test-1')]); + expect(diff1).toContain('AWS::SNS::Topic'); + const diff2 = await fixture.cdk(['diff', fixture.fullStackName('test-2')]); + expect(diff2).toContain('AWS::SNS::Topic'); + // We can make it fail by passing --fail + await expect(fixture.cdk(['diff', '--fail', fixture.fullStackName('test-1')])) + .rejects.toThrow('exited with error'); +})); +test_helpers_1.integTest('cdk diff --fail on multiple stacks exits with error if any of the stacks contains a diff', cdk_helpers_1.withDefaultFixture(async (fixture) => { + // GIVEN + const diff1 = await fixture.cdk(['diff', fixture.fullStackName('test-1')]); + expect(diff1).toContain('AWS::SNS::Topic'); + await fixture.cdkDeploy('test-2'); + const diff2 = await fixture.cdk(['diff', fixture.fullStackName('test-2')]); + expect(diff2).toContain('There were no differences'); + // WHEN / THEN + await expect(fixture.cdk(['diff', '--fail', fixture.fullStackName('test-1'), fixture.fullStackName('test-2')])).rejects.toThrow('exited with error'); +})); +test_helpers_1.integTest('cdk diff --fail with multiple stack exits with if any of the stacks contains a diff', cdk_helpers_1.withDefaultFixture(async (fixture) => { + // GIVEN + await fixture.cdkDeploy('test-1'); + const diff1 = await fixture.cdk(['diff', fixture.fullStackName('test-1')]); + expect(diff1).toContain('There were no differences'); + const diff2 = await fixture.cdk(['diff', fixture.fullStackName('test-2')]); + expect(diff2).toContain('AWS::SNS::Topic'); + // WHEN / THEN + await expect(fixture.cdk(['diff', '--fail', fixture.fullStackName('test-1'), fixture.fullStackName('test-2')])).rejects.toThrow('exited with error'); +})); +test_helpers_1.integTest('deploy stack with docker asset', cdk_helpers_1.withDefaultFixture(async (fixture) => { + await fixture.cdkDeploy('docker'); +})); +test_helpers_1.integTest('deploy and test stack with lambda asset', cdk_helpers_1.withDefaultFixture(async (fixture) => { + var _a, _b; + const stackArn = await fixture.cdkDeploy('lambda', { captureStderr: false }); + const response = await fixture.aws.cloudFormation('describeStacks', { + StackName: stackArn, + }); + const lambdaArn = (_b = (_a = response.Stacks) === null || _a === void 0 ? void 0 : _a[0].Outputs) === null || _b === void 0 ? void 0 : _b[0].OutputValue; + if (lambdaArn === undefined) { + throw new Error('Stack did not have expected Lambda ARN output'); + } + const output = await fixture.aws.lambda('invoke', { + FunctionName: lambdaArn, + }); + expect(JSON.stringify(output.Payload)).toContain('dear asset'); +})); +test_helpers_1.integTest('cdk ls', cdk_helpers_1.withDefaultFixture(async (fixture) => { + const listing = await fixture.cdk(['ls'], { captureStderr: false }); + const expectedStacks = [ + 'conditional-resource', + 'docker', + 'docker-with-custom-file', + 'failed', + 'iam-test', + 'lambda', + 'missing-ssm-parameter', + 'order-providing', + 'outputs-test-1', + 'outputs-test-2', + 'param-test-1', + 'param-test-2', + 'param-test-3', + 'termination-protection', + 'test-1', + 'test-2', + 'with-nested-stack', + 'with-nested-stack-using-parameters', + 'order-consuming', + ]; + for (const stack of expectedStacks) { + expect(listing).toContain(fixture.fullStackName(stack)); + } +})); +test_helpers_1.integTest('deploy stack without resource', cdk_helpers_1.withDefaultFixture(async (fixture) => { + // Deploy the stack without resources + await fixture.cdkDeploy('conditional-resource', { modEnv: { NO_RESOURCE: 'TRUE' } }); + // This should have succeeded but not deployed the stack. + await expect(fixture.aws.cloudFormation('describeStacks', { StackName: fixture.fullStackName('conditional-resource') })) + .rejects.toThrow('conditional-resource does not exist'); + // Deploy the stack with resources + await fixture.cdkDeploy('conditional-resource'); + // Then again WITHOUT resources (this should destroy the stack) + await fixture.cdkDeploy('conditional-resource', { modEnv: { NO_RESOURCE: 'TRUE' } }); + await expect(fixture.aws.cloudFormation('describeStacks', { StackName: fixture.fullStackName('conditional-resource') })) + .rejects.toThrow('conditional-resource does not exist'); +})); +test_helpers_1.integTest('IAM diff', cdk_helpers_1.withDefaultFixture(async (fixture) => { + const output = await fixture.cdk(['diff', fixture.fullStackName('iam-test')]); + // Roughly check for a table like this: + // + // ┌───┬─────────────────┬────────┬────────────────┬────────────────────────────-──┬───────────┐ + // │ │ Resource │ Effect │ Action │ Principal │ Condition │ + // ├───┼─────────────────┼────────┼────────────────┼───────────────────────────────┼───────────┤ + // │ + │ ${SomeRole.Arn} │ Allow │ sts:AssumeRole │ Service:ec2.amazonaws.com │ │ + // └───┴─────────────────┴────────┴────────────────┴───────────────────────────────┴───────────┘ + expect(output).toContain('${SomeRole.Arn}'); + expect(output).toContain('sts:AssumeRole'); + expect(output).toContain('ec2.amazonaws.com'); +})); +test_helpers_1.integTest('fast deploy', cdk_helpers_1.withDefaultFixture(async (fixture) => { + // we are using a stack with a nested stack because CFN will always attempt to + // update a nested stack, which will allow us to verify that updates are actually + // skipped unless --force is specified. + const stackArn = await fixture.cdkDeploy('with-nested-stack', { captureStderr: false }); + const changeSet1 = await getLatestChangeSet(); + // Deploy the same stack again, there should be no new change set created + await fixture.cdkDeploy('with-nested-stack'); + const changeSet2 = await getLatestChangeSet(); + expect(changeSet2.ChangeSetId).toEqual(changeSet1.ChangeSetId); + // Deploy the stack again with --force, now we should create a changeset + await fixture.cdkDeploy('with-nested-stack', { options: ['--force'] }); + const changeSet3 = await getLatestChangeSet(); + expect(changeSet3.ChangeSetId).not.toEqual(changeSet2.ChangeSetId); + // Deploy the stack again with tags, expected to create a new changeset + // even though the resources didn't change. + await fixture.cdkDeploy('with-nested-stack', { options: ['--tags', 'key=value'] }); + const changeSet4 = await getLatestChangeSet(); + expect(changeSet4.ChangeSetId).not.toEqual(changeSet3.ChangeSetId); + async function getLatestChangeSet() { + var _a, _b, _c; + const response = await fixture.aws.cloudFormation('describeStacks', { StackName: stackArn }); + if (!((_a = response.Stacks) === null || _a === void 0 ? void 0 : _a[0])) { + throw new Error('Did not get a ChangeSet at all'); + } + fixture.log(`Found Change Set ${(_b = response.Stacks) === null || _b === void 0 ? void 0 : _b[0].ChangeSetId}`); + return (_c = response.Stacks) === null || _c === void 0 ? void 0 : _c[0]; + } +})); +test_helpers_1.integTest('failed deploy does not hang', cdk_helpers_1.withDefaultFixture(async (fixture) => { + // this will hang if we introduce https://github.com/aws/aws-cdk/issues/6403 again. + await expect(fixture.cdkDeploy('failed')).rejects.toThrow('exited with error'); +})); +test_helpers_1.integTest('can still load old assemblies', cdk_helpers_1.withDefaultFixture(async (fixture) => { + const cxAsmDir = path.join(os.tmpdir(), 'cdk-integ-cx'); + const testAssembliesDirectory = path.join(__dirname, 'cloud-assemblies'); + for (const asmdir of await listChildDirs(testAssembliesDirectory)) { + fixture.log(`ASSEMBLY ${asmdir}`); + await cdk_helpers_1.cloneDirectory(asmdir, cxAsmDir); + // Some files in the asm directory that have a .js extension are + // actually treated as templates. Evaluate them using NodeJS. + const templates = await listChildren(cxAsmDir, fullPath => Promise.resolve(fullPath.endsWith('.js'))); + for (const template of templates) { + const targetName = template.replace(/.js$/, ''); + await cdk_helpers_1.shell([process.execPath, template, '>', targetName], { + cwd: cxAsmDir, + output: fixture.output, + modEnv: { + TEST_ACCOUNT: await fixture.aws.account(), + TEST_REGION: fixture.aws.region, + }, + }); + } + // Use this directory as a Cloud Assembly + const output = await fixture.cdk([ + '--app', cxAsmDir, + '-v', + 'synth', + ]); + // Assert that there was no providerError in CDK's stderr + // Because we rely on the app/framework to actually error in case the + // provider fails, we inspect the logs here. + expect(output).not.toContain('$providerError'); + } +})); +test_helpers_1.integTest('generating and loading assembly', cdk_helpers_1.withDefaultFixture(async (fixture) => { + const asmOutputDir = `${fixture.integTestDir}-cdk-integ-asm`; + await fixture.shell(['rm', '-rf', asmOutputDir]); + // Synthesize a Cloud Assembly tothe default directory (cdk.out) and a specific directory. + await fixture.cdk(['synth']); + await fixture.cdk(['synth', '--output', asmOutputDir]); + // cdk.out in the current directory and the indicated --output should be the same + await fixture.shell(['diff', 'cdk.out', asmOutputDir]); + // Check that we can 'ls' the synthesized asm. + // Change to some random directory to make sure we're not accidentally loading cdk.json + const list = await fixture.cdk(['--app', asmOutputDir, 'ls'], { cwd: os.tmpdir() }); + // Same stacks we know are in the app + expect(list).toContain(`${fixture.stackNamePrefix}-lambda`); + expect(list).toContain(`${fixture.stackNamePrefix}-test-1`); + expect(list).toContain(`${fixture.stackNamePrefix}-test-2`); + // Check that we can use '.' and just synth ,the generated asm + const stackTemplate = await fixture.cdk(['--app', '.', 'synth', fixture.fullStackName('test-2')], { + cwd: asmOutputDir, + }); + expect(stackTemplate).toContain('topic152D84A37'); + // Deploy a Lambda from the copied asm + await fixture.cdkDeploy('lambda', { options: ['-a', '.'], cwd: asmOutputDir }); + // Remove (rename) the original custom docker file that was used during synth. + // this verifies that the assemly has a copy of it and that the manifest uses + // relative paths to reference to it. + const customDockerFile = path.join(fixture.integTestDir, 'docker', 'Dockerfile.Custom'); + await fs_1.promises.rename(customDockerFile, `${customDockerFile}~`); + try { + // deploy a docker image with custom file without synth (uses assets) + await fixture.cdkDeploy('docker-with-custom-file', { options: ['-a', '.'], cwd: asmOutputDir }); + } + finally { + // Rename back to restore fixture to original state + await fs_1.promises.rename(`${customDockerFile}~`, customDockerFile); + } +})); +test_helpers_1.integTest('templates on disk contain metadata resource, also in nested assemblies', cdk_helpers_1.withDefaultFixture(async (fixture) => { + // Synth first, and switch on version reporting because cdk.json is disabling it + await fixture.cdk(['synth', '--version-reporting=true']); + // Load template from disk from root assembly + const templateContents = await fixture.shell(['cat', 'cdk.out/*-lambda.template.json']); + expect(JSON.parse(templateContents).Resources.CDKMetadata).toBeTruthy(); + // Load template from nested assembly + const nestedTemplateContents = await fixture.shell(['cat', 'cdk.out/assembly-*-stage/*-stage-StackInStage.template.json']); + expect(JSON.parse(nestedTemplateContents).Resources.CDKMetadata).toBeTruthy(); +})); +async function listChildren(parent, pred) { + const ret = new Array(); + for (const child of await fs_1.promises.readdir(parent, { encoding: 'utf-8' })) { + const fullPath = path.join(parent, child.toString()); + if (await pred(fullPath)) { + ret.push(fullPath); + } + } + return ret; +} +async function listChildDirs(parent) { + return listChildren(parent, async (fullPath) => (await fs_1.promises.stat(fullPath)).isDirectory()); +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cli.integtest.js","sourceRoot":"","sources":["cli.integtest.ts"],"names":[],"mappings":"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","sourcesContent":["import { promises as fs } from 'fs';\nimport * as os from 'os';\nimport * as path from 'path';\nimport { retry, sleep } from './aws-helpers';\nimport { cloneDirectory, shell, withDefaultFixture } from './cdk-helpers';\nimport { integTest } from './test-helpers';\n\njest.setTimeout(600 * 1000);\n\nintegTest('VPC Lookup', withDefaultFixture(async (fixture) => {\n  fixture.log('Making sure we are clean before starting.');\n  await fixture.cdkDestroy('define-vpc', { modEnv: { ENABLE_VPC_TESTING: 'DEFINE' } });\n\n  fixture.log('Setting up: creating a VPC with known tags');\n  await fixture.cdkDeploy('define-vpc', { modEnv: { ENABLE_VPC_TESTING: 'DEFINE' } });\n  fixture.log('Setup complete!');\n\n  fixture.log('Verifying we can now import that VPC');\n  await fixture.cdkDeploy('import-vpc', { modEnv: { ENABLE_VPC_TESTING: 'IMPORT' } });\n}));\n\nintegTest('Two ways of shoing the version', withDefaultFixture(async (fixture) => {\n  const version1 = await fixture.cdk(['version'], { verbose: false });\n  const version2 = await fixture.cdk(['--version'], { verbose: false });\n\n  expect(version1).toEqual(version2);\n}));\n\nintegTest('Termination protection', withDefaultFixture(async (fixture) => {\n  const stackName = 'termination-protection';\n  await fixture.cdkDeploy(stackName);\n\n  // Try a destroy that should fail\n  await expect(fixture.cdkDestroy(stackName)).rejects.toThrow('exited with error');\n\n  // Can update termination protection even though the change set doesn't contain changes\n  await fixture.cdkDeploy(stackName, { modEnv: { TERMINATION_PROTECTION: 'FALSE' } });\n  await fixture.cdkDestroy(stackName);\n}));\n\nintegTest('cdk synth', withDefaultFixture(async (fixture) => {\n  await expect(fixture.cdk(['synth', fixture.fullStackName('test-1')], { verbose: false })).resolves.toEqual(\n    `Resources:\n  topic69831491:\n    Type: AWS::SNS::Topic\n    Metadata:\n      aws:cdk:path: ${fixture.stackNamePrefix}-test-1/topic/Resource`);\n\n  await expect(fixture.cdk(['synth', fixture.fullStackName('test-2')], { verbose: false })).resolves.toEqual(\n    `Resources:\n  topic152D84A37:\n    Type: AWS::SNS::Topic\n    Metadata:\n      aws:cdk:path: ${fixture.stackNamePrefix}-test-2/topic1/Resource\n  topic2A4FB547F:\n    Type: AWS::SNS::Topic\n    Metadata:\n      aws:cdk:path: ${fixture.stackNamePrefix}-test-2/topic2/Resource`);\n}));\n\nintegTest('ssm parameter provider error', withDefaultFixture(async (fixture) => {\n  await expect(fixture.cdk(['synth',\n    fixture.fullStackName('missing-ssm-parameter'),\n    '-c', 'test:ssm-parameter-name=/does/not/exist'], {\n    allowErrExit: true,\n  })).resolves.toContain('SSM parameter not available in account');\n}));\n\nintegTest('automatic ordering', withDefaultFixture(async (fixture) => {\n  // Deploy the consuming stack which will include the producing stack\n  await fixture.cdkDeploy('order-consuming');\n\n  // Destroy the providing stack which will include the consuming stack\n  await fixture.cdkDestroy('order-providing');\n}));\n\nintegTest('context setting', withDefaultFixture(async (fixture) => {\n  await fs.writeFile(path.join(fixture.integTestDir, 'cdk.context.json'), JSON.stringify({\n    contextkey: 'this is the context value',\n  }));\n  try {\n    await expect(fixture.cdk(['context'])).resolves.toContain('this is the context value');\n\n    // Test that deleting the contextkey works\n    await fixture.cdk(['context', '--reset', 'contextkey']);\n    await expect(fixture.cdk(['context'])).resolves.not.toContain('this is the context value');\n\n    // Test that forced delete of the context key does not throw\n    await fixture.cdk(['context', '-f', '--reset', 'contextkey']);\n\n  } finally {\n    await fs.unlink(path.join(fixture.integTestDir, 'cdk.context.json'));\n  }\n}));\n\nintegTest('deploy', withDefaultFixture(async (fixture) => {\n  const stackArn = await fixture.cdkDeploy('test-2', { captureStderr: false });\n\n  // verify the number of resources in the stack\n  const response = await fixture.aws.cloudFormation('describeStackResources', {\n    StackName: stackArn,\n  });\n  expect(response.StackResources?.length).toEqual(2);\n}));\n\nintegTest('deploy all', withDefaultFixture(async (fixture) => {\n  const arns = await fixture.cdkDeploy('test-*', { captureStderr: false });\n\n  // verify that we only deployed a single stack (there's a single ARN in the output)\n  expect(arns.split('\\n').length).toEqual(2);\n}));\n\nintegTest('nested stack with parameters', withDefaultFixture(async (fixture) => {\n  // STACK_NAME_PREFIX is used in MyTopicParam to allow multiple instances\n  // of this test to run in parallel, othewise they will attempt to create the same SNS topic.\n  const stackArn = await fixture.cdkDeploy('with-nested-stack-using-parameters', {\n    options: ['--parameters', `MyTopicParam=${fixture.stackNamePrefix}ThereIsNoSpoon`],\n    captureStderr: false,\n  });\n\n  // verify that we only deployed a single stack (there's a single ARN in the output)\n  expect(stackArn.split('\\n').length).toEqual(1);\n\n  // verify the number of resources in the stack\n  const response = await fixture.aws.cloudFormation('describeStackResources', {\n    StackName: stackArn,\n  });\n  expect(response.StackResources?.length).toEqual(1);\n}));\n\nintegTest('deploy without execute', withDefaultFixture(async (fixture) => {\n  const stackArn = await fixture.cdkDeploy('test-2', {\n    options: ['--no-execute'],\n    captureStderr: false,\n  });\n  // verify that we only deployed a single stack (there's a single ARN in the output)\n  expect(stackArn.split('\\n').length).toEqual(1);\n\n  const response = await fixture.aws.cloudFormation('describeStacks', {\n    StackName: stackArn,\n  });\n\n  expect(response.Stacks?.[0].StackStatus).toEqual('REVIEW_IN_PROGRESS');\n}));\n\nintegTest('security related changes without a CLI are expected to fail', withDefaultFixture(async (fixture) => {\n  // redirect /dev/null to stdin, which means there will not be tty attached\n  // since this stack includes security-related changes, the deployment should\n  // immediately fail because we can't confirm the changes\n  const stackName = 'iam-test';\n  await expect(fixture.cdkDeploy(stackName, {\n    options: ['<', '/dev/null'], // H4x, this only works because I happen to know we pass shell: true.\n    neverRequireApproval: false,\n  })).rejects.toThrow('exited with error');\n\n  // Ensure stack was not deployed\n  await expect(fixture.aws.cloudFormation('describeStacks', {\n    StackName: fixture.fullStackName(stackName),\n  })).rejects.toThrow('does not exist');\n}));\n\nintegTest('deploy wildcard with outputs', withDefaultFixture(async (fixture) => {\n  const outputsFile = path.join(fixture.integTestDir, 'outputs', 'outputs.json');\n  await fs.mkdir(path.dirname(outputsFile), { recursive: true });\n\n  await fixture.cdkDeploy(['outputs-test-*'], {\n    options: ['--outputs-file', outputsFile],\n  });\n\n  const outputs = JSON.parse((await fs.readFile(outputsFile, { encoding: 'utf-8' })).toString());\n  expect(outputs).toEqual({\n    [`${fixture.stackNamePrefix}-outputs-test-1`]: {\n      TopicName: `${fixture.stackNamePrefix}-outputs-test-1MyTopic`,\n    },\n    [`${fixture.stackNamePrefix}-outputs-test-2`]: {\n      TopicName: `${fixture.stackNamePrefix}-outputs-test-2MyOtherTopic`,\n    },\n  });\n}));\n\nintegTest('deploy with parameters', withDefaultFixture(async (fixture) => {\n  const stackArn = await fixture.cdkDeploy('param-test-1', {\n    options: [\n      '--parameters', `TopicNameParam=${fixture.stackNamePrefix}bazinga`,\n    ],\n    captureStderr: false,\n  });\n\n  const response = await fixture.aws.cloudFormation('describeStacks', {\n    StackName: stackArn,\n  });\n\n  expect(response.Stacks?.[0].Parameters).toEqual([\n    {\n      ParameterKey: 'TopicNameParam',\n      ParameterValue: `${fixture.stackNamePrefix}bazinga`,\n    },\n  ]);\n}));\n\nintegTest('update to stack in ROLLBACK_COMPLETE state will delete stack and create a new one', withDefaultFixture(async (fixture) => {\n  // GIVEN\n  await expect(fixture.cdkDeploy('param-test-1', {\n    options: [\n      '--parameters', `TopicNameParam=${fixture.stackNamePrefix}@aww`,\n    ],\n    captureStderr: false,\n  })).rejects.toThrow('exited with error');\n\n  const response = await fixture.aws.cloudFormation('describeStacks', {\n    StackName: fixture.fullStackName('param-test-1'),\n  });\n\n  const stackArn = response.Stacks?.[0].StackId;\n  expect(response.Stacks?.[0].StackStatus).toEqual('ROLLBACK_COMPLETE');\n\n  // WHEN\n  const newStackArn = await fixture.cdkDeploy('param-test-1', {\n    options: [\n      '--parameters', `TopicNameParam=${fixture.stackNamePrefix}allgood`,\n    ],\n    captureStderr: false,\n  });\n\n  const newStackResponse = await fixture.aws.cloudFormation('describeStacks', {\n    StackName: newStackArn,\n  });\n\n  // THEN\n  expect (stackArn).not.toEqual(newStackArn); // new stack was created\n  expect(newStackResponse.Stacks?.[0].StackStatus).toEqual('CREATE_COMPLETE');\n  expect(newStackResponse.Stacks?.[0].Parameters).toEqual([\n    {\n      ParameterKey: 'TopicNameParam',\n      ParameterValue: `${fixture.stackNamePrefix}allgood`,\n    },\n  ]);\n}));\n\nintegTest('stack in UPDATE_ROLLBACK_COMPLETE state can be updated', withDefaultFixture(async (fixture) => {\n  // GIVEN\n  const stackArn = await fixture.cdkDeploy('param-test-1', {\n    options: [\n      '--parameters', `TopicNameParam=${fixture.stackNamePrefix}nice`,\n    ],\n    captureStderr: false,\n  });\n\n  let response = await fixture.aws.cloudFormation('describeStacks', {\n    StackName: stackArn,\n  });\n\n  expect(response.Stacks?.[0].StackStatus).toEqual('CREATE_COMPLETE');\n\n  // bad parameter name with @ will put stack into UPDATE_ROLLBACK_COMPLETE\n  await expect(fixture.cdkDeploy('param-test-1', {\n    options: [\n      '--parameters', `TopicNameParam=${fixture.stackNamePrefix}@aww`,\n    ],\n    captureStderr: false,\n  })).rejects.toThrow('exited with error');;\n\n  response = await fixture.aws.cloudFormation('describeStacks', {\n    StackName: stackArn,\n  });\n\n  expect(response.Stacks?.[0].StackStatus).toEqual('UPDATE_ROLLBACK_COMPLETE');\n\n  // WHEN\n  await fixture.cdkDeploy('param-test-1', {\n    options: [\n      '--parameters', `TopicNameParam=${fixture.stackNamePrefix}allgood`,\n    ],\n    captureStderr: false,\n  });\n\n  response = await fixture.aws.cloudFormation('describeStacks', {\n    StackName: stackArn,\n  });\n\n  // THEN\n  expect(response.Stacks?.[0].StackStatus).toEqual('UPDATE_COMPLETE');\n  expect(response.Stacks?.[0].Parameters).toEqual([\n    {\n      ParameterKey: 'TopicNameParam',\n      ParameterValue: `${fixture.stackNamePrefix}allgood`,\n    },\n  ]);\n}));\n\nintegTest('deploy with wildcard and parameters', withDefaultFixture(async (fixture) => {\n  await fixture.cdkDeploy('param-test-*', {\n    options: [\n      '--parameters', `${fixture.stackNamePrefix}-param-test-1:TopicNameParam=${fixture.stackNamePrefix}bazinga`,\n      '--parameters', `${fixture.stackNamePrefix}-param-test-2:OtherTopicNameParam=${fixture.stackNamePrefix}ThatsMySpot`,\n      '--parameters', `${fixture.stackNamePrefix}-param-test-3:DisplayNameParam=${fixture.stackNamePrefix}HeyThere`,\n      '--parameters', `${fixture.stackNamePrefix}-param-test-3:OtherDisplayNameParam=${fixture.stackNamePrefix}AnotherOne`,\n    ],\n  });\n}));\n\nintegTest('deploy with parameters multi', withDefaultFixture(async (fixture) => {\n  const paramVal1 = `${fixture.stackNamePrefix}bazinga`;\n  const paramVal2 = `${fixture.stackNamePrefix}=jagshemash`;\n\n  const stackArn = await fixture.cdkDeploy('param-test-3', {\n    options: [\n      '--parameters', `DisplayNameParam=${paramVal1}`,\n      '--parameters', `OtherDisplayNameParam=${paramVal2}`,\n    ],\n    captureStderr: false,\n  });\n\n  const response = await fixture.aws.cloudFormation('describeStacks', {\n    StackName: stackArn,\n  });\n\n  expect(response.Stacks?.[0].Parameters).toEqual([\n    {\n      ParameterKey: 'DisplayNameParam',\n      ParameterValue: paramVal1,\n    },\n    {\n      ParameterKey: 'OtherDisplayNameParam',\n      ParameterValue: paramVal2,\n    },\n  ]);\n}));\n\nintegTest('deploy with notification ARN', withDefaultFixture(async (fixture) => {\n  const topicName = `${fixture.stackNamePrefix}-test-topic`;\n\n  const response = await fixture.aws.sns('createTopic', { Name: topicName });\n  const topicArn = response.TopicArn!;\n  try {\n    await fixture.cdkDeploy('test-2', {\n      options: ['--notification-arns', topicArn],\n    });\n\n    // verify that the stack we deployed has our notification ARN\n    const describeResponse = await fixture.aws.cloudFormation('describeStacks', {\n      StackName: fixture.fullStackName('test-2'),\n    });\n    expect(describeResponse.Stacks?.[0].NotificationARNs).toEqual([topicArn]);\n  } finally {\n    await fixture.aws.sns('deleteTopic', {\n      TopicArn: topicArn,\n    });\n  }\n}));\n\nintegTest('deploy with role', withDefaultFixture(async (fixture) => {\n  const roleName = `${fixture.stackNamePrefix}-test-role`;\n\n  await deleteRole();\n\n  const createResponse = await fixture.aws.iam('createRole', {\n    RoleName: roleName,\n    AssumeRolePolicyDocument: JSON.stringify({\n      Version: '2012-10-17',\n      Statement: [{\n        Action: 'sts:AssumeRole',\n        Principal: { Service: 'cloudformation.amazonaws.com' },\n        Effect: 'Allow',\n      }, {\n        Action: 'sts:AssumeRole',\n        Principal: { AWS: (await fixture.aws.sts('getCallerIdentity', {})).Arn },\n        Effect: 'Allow',\n      }],\n    }),\n  });\n  const roleArn = createResponse.Role.Arn;\n  try {\n    await fixture.aws.iam('putRolePolicy', {\n      RoleName: roleName,\n      PolicyName: 'DefaultPolicy',\n      PolicyDocument: JSON.stringify({\n        Version: '2012-10-17',\n        Statement: [{\n          Action: '*',\n          Resource: '*',\n          Effect: 'Allow',\n        }],\n      }),\n    });\n\n    await retry(fixture.output, 'Trying to assume fresh role', retry.forSeconds(300), async () => {\n      await fixture.aws.sts('assumeRole', {\n        RoleArn: roleArn,\n        RoleSessionName: 'testing',\n      });\n    });\n\n    // In principle, the role has replicated from 'us-east-1' to wherever we're testing.\n    // Give it a little more sleep to make sure CloudFormation is not hitting a box\n    // that doesn't have it yet.\n    await sleep(5000);\n\n    await fixture.cdkDeploy('test-2', {\n      options: ['--role-arn', roleArn],\n    });\n\n    // Immediately delete the stack again before we delete the role.\n    //\n    // Since roles are sticky, if we delete the role before the stack, subsequent DeleteStack\n    // operations will fail when CloudFormation tries to assume the role that's already gone.\n    await fixture.cdkDestroy('test-2');\n\n  } finally {\n    await deleteRole();\n  }\n\n  async function deleteRole() {\n    try {\n      for (const policyName of (await fixture.aws.iam('listRolePolicies', { RoleName: roleName })).PolicyNames) {\n        await fixture.aws.iam('deleteRolePolicy', {\n          RoleName: roleName,\n          PolicyName: policyName,\n        });\n      }\n      await fixture.aws.iam('deleteRole', { RoleName: roleName });\n    } catch (e) {\n      if (e.message.indexOf('cannot be found') > -1) { return; }\n      throw e;\n    }\n  }\n}));\n\nintegTest('cdk diff', withDefaultFixture(async (fixture) => {\n  const diff1 = await fixture.cdk(['diff', fixture.fullStackName('test-1')]);\n  expect(diff1).toContain('AWS::SNS::Topic');\n\n  const diff2 = await fixture.cdk(['diff', fixture.fullStackName('test-2')]);\n  expect(diff2).toContain('AWS::SNS::Topic');\n\n  // We can make it fail by passing --fail\n  await expect(fixture.cdk(['diff', '--fail', fixture.fullStackName('test-1')]))\n    .rejects.toThrow('exited with error');\n}));\n\nintegTest('cdk diff --fail on multiple stacks exits with error if any of the stacks contains a diff', withDefaultFixture(async (fixture) => {\n  // GIVEN\n  const diff1 = await fixture.cdk(['diff', fixture.fullStackName('test-1')]);\n  expect(diff1).toContain('AWS::SNS::Topic');\n\n  await fixture.cdkDeploy('test-2');\n  const diff2 = await fixture.cdk(['diff', fixture.fullStackName('test-2')]);\n  expect(diff2).toContain('There were no differences');\n\n  // WHEN / THEN\n  await expect(fixture.cdk(['diff', '--fail', fixture.fullStackName('test-1'), fixture.fullStackName('test-2')])).rejects.toThrow('exited with error');\n}));\n\nintegTest('cdk diff --fail with multiple stack exits with if any of the stacks contains a diff', withDefaultFixture(async (fixture) => {\n  // GIVEN\n  await fixture.cdkDeploy('test-1');\n  const diff1 = await fixture.cdk(['diff', fixture.fullStackName('test-1')]);\n  expect(diff1).toContain('There were no differences');\n\n  const diff2 = await fixture.cdk(['diff', fixture.fullStackName('test-2')]);\n  expect(diff2).toContain('AWS::SNS::Topic');\n\n  // WHEN / THEN\n  await expect(fixture.cdk(['diff', '--fail', fixture.fullStackName('test-1'), fixture.fullStackName('test-2')])).rejects.toThrow('exited with error');\n}));\n\nintegTest('deploy stack with docker asset', withDefaultFixture(async (fixture) => {\n  await fixture.cdkDeploy('docker');\n}));\n\nintegTest('deploy and test stack with lambda asset', withDefaultFixture(async (fixture) => {\n  const stackArn = await fixture.cdkDeploy('lambda', { captureStderr: false });\n\n  const response = await fixture.aws.cloudFormation('describeStacks', {\n    StackName: stackArn,\n  });\n  const lambdaArn = response.Stacks?.[0].Outputs?.[0].OutputValue;\n  if (lambdaArn === undefined) {\n    throw new Error('Stack did not have expected Lambda ARN output');\n  }\n\n  const output = await fixture.aws.lambda('invoke', {\n    FunctionName: lambdaArn,\n  });\n\n  expect(JSON.stringify(output.Payload)).toContain('dear asset');\n}));\n\nintegTest('cdk ls', withDefaultFixture(async (fixture) => {\n  const listing = await fixture.cdk(['ls'], { captureStderr: false });\n\n  const expectedStacks = [\n    'conditional-resource',\n    'docker',\n    'docker-with-custom-file',\n    'failed',\n    'iam-test',\n    'lambda',\n    'missing-ssm-parameter',\n    'order-providing',\n    'outputs-test-1',\n    'outputs-test-2',\n    'param-test-1',\n    'param-test-2',\n    'param-test-3',\n    'termination-protection',\n    'test-1',\n    'test-2',\n    'with-nested-stack',\n    'with-nested-stack-using-parameters',\n    'order-consuming',\n  ];\n\n  for (const stack of expectedStacks) {\n    expect(listing).toContain(fixture.fullStackName(stack));\n  }\n}));\n\nintegTest('deploy stack without resource', withDefaultFixture(async (fixture) => {\n  // Deploy the stack without resources\n  await fixture.cdkDeploy('conditional-resource', { modEnv: { NO_RESOURCE: 'TRUE' } });\n\n  // This should have succeeded but not deployed the stack.\n  await expect(fixture.aws.cloudFormation('describeStacks', { StackName: fixture.fullStackName('conditional-resource') }))\n    .rejects.toThrow('conditional-resource does not exist');\n\n  // Deploy the stack with resources\n  await fixture.cdkDeploy('conditional-resource');\n\n  // Then again WITHOUT resources (this should destroy the stack)\n  await fixture.cdkDeploy('conditional-resource', { modEnv: { NO_RESOURCE: 'TRUE' } });\n\n  await expect(fixture.aws.cloudFormation('describeStacks', { StackName: fixture.fullStackName('conditional-resource') }))\n    .rejects.toThrow('conditional-resource does not exist');\n}));\n\nintegTest('IAM diff', withDefaultFixture(async (fixture) => {\n  const output = await fixture.cdk(['diff', fixture.fullStackName('iam-test')]);\n\n  // Roughly check for a table like this:\n  //\n  // ┌───┬─────────────────┬────────┬────────────────┬────────────────────────────-──┬───────────┐\n  // │   │ Resource        │ Effect │ Action         │ Principal                     │ Condition │\n  // ├───┼─────────────────┼────────┼────────────────┼───────────────────────────────┼───────────┤\n  // │ + │ ${SomeRole.Arn} │ Allow  │ sts:AssumeRole │ Service:ec2.amazonaws.com     │           │\n  // └───┴─────────────────┴────────┴────────────────┴───────────────────────────────┴───────────┘\n\n  expect(output).toContain('${SomeRole.Arn}');\n  expect(output).toContain('sts:AssumeRole');\n  expect(output).toContain('ec2.amazonaws.com');\n}));\n\nintegTest('fast deploy', withDefaultFixture(async (fixture) => {\n  // we are using a stack with a nested stack because CFN will always attempt to\n  // update a nested stack, which will allow us to verify that updates are actually\n  // skipped unless --force is specified.\n  const stackArn = await fixture.cdkDeploy('with-nested-stack', { captureStderr: false });\n  const changeSet1 = await getLatestChangeSet();\n\n  // Deploy the same stack again, there should be no new change set created\n  await fixture.cdkDeploy('with-nested-stack');\n  const changeSet2 = await getLatestChangeSet();\n  expect(changeSet2.ChangeSetId).toEqual(changeSet1.ChangeSetId);\n\n  // Deploy the stack again with --force, now we should create a changeset\n  await fixture.cdkDeploy('with-nested-stack', { options: ['--force'] });\n  const changeSet3 = await getLatestChangeSet();\n  expect(changeSet3.ChangeSetId).not.toEqual(changeSet2.ChangeSetId);\n\n  // Deploy the stack again with tags, expected to create a new changeset\n  // even though the resources didn't change.\n  await fixture.cdkDeploy('with-nested-stack', { options: ['--tags', 'key=value'] });\n  const changeSet4 = await getLatestChangeSet();\n  expect(changeSet4.ChangeSetId).not.toEqual(changeSet3.ChangeSetId);\n\n  async function getLatestChangeSet() {\n    const response = await fixture.aws.cloudFormation('describeStacks', { StackName: stackArn });\n    if (!response.Stacks?.[0]) { throw new Error('Did not get a ChangeSet at all'); }\n    fixture.log(`Found Change Set ${response.Stacks?.[0].ChangeSetId}`);\n    return response.Stacks?.[0];\n  }\n}));\n\nintegTest('failed deploy does not hang', withDefaultFixture(async (fixture) => {\n  // this will hang if we introduce https://github.com/aws/aws-cdk/issues/6403 again.\n  await expect(fixture.cdkDeploy('failed')).rejects.toThrow('exited with error');\n}));\n\nintegTest('can still load old assemblies', withDefaultFixture(async (fixture) => {\n  const cxAsmDir = path.join(os.tmpdir(), 'cdk-integ-cx');\n\n  const testAssembliesDirectory = path.join(__dirname, 'cloud-assemblies');\n  for (const asmdir of await listChildDirs(testAssembliesDirectory)) {\n    fixture.log(`ASSEMBLY ${asmdir}`);\n    await cloneDirectory(asmdir, cxAsmDir);\n\n    // Some files in the asm directory that have a .js extension are\n    // actually treated as templates. Evaluate them using NodeJS.\n    const templates = await listChildren(cxAsmDir, fullPath => Promise.resolve(fullPath.endsWith('.js')));\n    for (const template of templates) {\n      const targetName = template.replace(/.js$/, '');\n      await shell([process.execPath, template, '>', targetName], {\n        cwd: cxAsmDir,\n        output: fixture.output,\n        modEnv: {\n          TEST_ACCOUNT: await fixture.aws.account(),\n          TEST_REGION: fixture.aws.region,\n        },\n      });\n    }\n\n    // Use this directory as a Cloud Assembly\n    const output = await fixture.cdk([\n      '--app', cxAsmDir,\n      '-v',\n      'synth',\n    ]);\n\n    // Assert that there was no providerError in CDK's stderr\n    // Because we rely on the app/framework to actually error in case the\n    // provider fails, we inspect the logs here.\n    expect(output).not.toContain('$providerError');\n  }\n}));\n\nintegTest('generating and loading assembly', withDefaultFixture(async (fixture) => {\n  const asmOutputDir = `${fixture.integTestDir}-cdk-integ-asm`;\n  await fixture.shell(['rm', '-rf', asmOutputDir]);\n\n  // Synthesize a Cloud Assembly tothe default directory (cdk.out) and a specific directory.\n  await fixture.cdk(['synth']);\n  await fixture.cdk(['synth', '--output', asmOutputDir]);\n\n  // cdk.out in the current directory and the indicated --output should be the same\n  await fixture.shell(['diff', 'cdk.out', asmOutputDir]);\n\n  // Check that we can 'ls' the synthesized asm.\n  // Change to some random directory to make sure we're not accidentally loading cdk.json\n  const list = await fixture.cdk(['--app', asmOutputDir, 'ls'], { cwd: os.tmpdir() });\n  // Same stacks we know are in the app\n  expect(list).toContain(`${fixture.stackNamePrefix}-lambda`);\n  expect(list).toContain(`${fixture.stackNamePrefix}-test-1`);\n  expect(list).toContain(`${fixture.stackNamePrefix}-test-2`);\n\n  // Check that we can use '.' and just synth ,the generated asm\n  const stackTemplate = await fixture.cdk(['--app', '.', 'synth', fixture.fullStackName('test-2')], {\n    cwd: asmOutputDir,\n  });\n  expect(stackTemplate).toContain('topic152D84A37');\n\n  // Deploy a Lambda from the copied asm\n  await fixture.cdkDeploy('lambda', { options: ['-a', '.'], cwd: asmOutputDir });\n\n  // Remove (rename) the original custom docker file that was used during synth.\n  // this verifies that the assemly has a copy of it and that the manifest uses\n  // relative paths to reference to it.\n  const customDockerFile = path.join(fixture.integTestDir, 'docker', 'Dockerfile.Custom');\n  await fs.rename(customDockerFile, `${customDockerFile}~`);\n  try {\n\n    // deploy a docker image with custom file without synth (uses assets)\n    await fixture.cdkDeploy('docker-with-custom-file', { options: ['-a', '.'], cwd: asmOutputDir });\n\n  } finally {\n    // Rename back to restore fixture to original state\n    await fs.rename(`${customDockerFile}~`, customDockerFile);\n  }\n}));\n\nintegTest('templates on disk contain metadata resource, also in nested assemblies', withDefaultFixture(async (fixture) => {\n  // Synth first, and switch on version reporting because cdk.json is disabling it\n  await fixture.cdk(['synth', '--version-reporting=true']);\n\n  // Load template from disk from root assembly\n  const templateContents = await fixture.shell(['cat', 'cdk.out/*-lambda.template.json']);\n\n  expect(JSON.parse(templateContents).Resources.CDKMetadata).toBeTruthy();\n\n  // Load template from nested assembly\n  const nestedTemplateContents = await fixture.shell(['cat', 'cdk.out/assembly-*-stage/*-stage-StackInStage.template.json']);\n\n  expect(JSON.parse(nestedTemplateContents).Resources.CDKMetadata).toBeTruthy();\n}));\n\nasync function listChildren(parent: string, pred: (x: string) => Promise<boolean>) {\n  const ret = new Array<string>();\n  for (const child of await fs.readdir(parent, { encoding: 'utf-8' })) {\n    const fullPath = path.join(parent, child.toString());\n    if (await pred(fullPath)) {\n      ret.push(fullPath);\n    }\n  }\n  return ret;\n}\n\nasync function listChildDirs(parent: string) {\n  return listChildren(parent, async (fullPath: string) => (await fs.stat(fullPath)).isDirectory());\n}\n"]} \ No newline at end of file From ff5838fc9d6421bac4e0b54d73f0fc60f8e33fb2 Mon Sep 17 00:00:00 2001 From: Neta Nir Date: Fri, 25 Sep 2020 16:02:11 -0700 Subject: [PATCH 27/29] chore: patch regression tests v1.64.1 (#10548) ---- *By submitting this pull request, I confirm that my contribution is made under the terms of the Apache-2.0 license* --- .../cli-regression-patches/v1.64.1/NOTES.md | 3 + .../v1.64.1/cdk-helpers.js | 324 ++++++++++ .../v1.64.1/cli.integtest.js | 599 ++++++++++++++++++ 3 files changed, 926 insertions(+) create mode 100644 packages/aws-cdk/test/integ/cli-regression-patches/v1.64.1/NOTES.md create mode 100644 packages/aws-cdk/test/integ/cli-regression-patches/v1.64.1/cdk-helpers.js create mode 100644 packages/aws-cdk/test/integ/cli-regression-patches/v1.64.1/cli.integtest.js diff --git a/packages/aws-cdk/test/integ/cli-regression-patches/v1.64.1/NOTES.md b/packages/aws-cdk/test/integ/cli-regression-patches/v1.64.1/NOTES.md new file mode 100644 index 0000000000000..1cb31072ab5de --- /dev/null +++ b/packages/aws-cdk/test/integ/cli-regression-patches/v1.64.1/NOTES.md @@ -0,0 +1,3 @@ +Added a `-v` switch to the cdk executions that also needs to be +applied to the regression tests so we have a better chance +of catching sporadically failing tests in the act. \ No newline at end of file diff --git a/packages/aws-cdk/test/integ/cli-regression-patches/v1.64.1/cdk-helpers.js b/packages/aws-cdk/test/integ/cli-regression-patches/v1.64.1/cdk-helpers.js new file mode 100644 index 0000000000000..ef82e3d3edace --- /dev/null +++ b/packages/aws-cdk/test/integ/cli-regression-patches/v1.64.1/cdk-helpers.js @@ -0,0 +1,324 @@ +"use strict"; +var _a, _b; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.randomString = exports.rimraf = exports.shell = exports.TestFixture = exports.cloneDirectory = exports.withDefaultFixture = exports.withCdkApp = exports.withAws = void 0; +const child_process = require("child_process"); +const fs = require("fs"); +const os = require("os"); +const path = require("path"); +const aws_helpers_1 = require("./aws-helpers"); +const resource_pool_1 = require("./resource-pool"); +const REGIONS = process.env.AWS_REGIONS + ? process.env.AWS_REGIONS.split(',') + : [(_b = (_a = process.env.AWS_REGION) !== null && _a !== void 0 ? _a : process.env.AWS_DEFAULT_REGION) !== null && _b !== void 0 ? _b : 'us-east-1']; +process.stdout.write(`Using regions: ${REGIONS}\n`); +const REGION_POOL = new resource_pool_1.ResourcePool(REGIONS); +/** + * Higher order function to execute a block with an AWS client setup + * + * Allocate the next region from the REGION pool and dispose it afterwards. + */ +function withAws(block) { + return (context) => REGION_POOL.using(async (region) => { + const aws = await aws_helpers_1.AwsClients.forRegion(region, context.output); + await sanityCheck(aws); + return block({ ...context, aws }); + }); +} +exports.withAws = withAws; +/** + * Higher order function to execute a block with a CDK app fixture + * + * Requires an AWS client to be passed in. + * + * For backwards compatibility with existing tests (so we don't have to change + * too much) the inner block is expected to take a `TestFixture` object. + */ +function withCdkApp(block) { + return async (context) => { + const randy = randomString(); + const stackNamePrefix = `cdktest-${randy}`; + const integTestDir = path.join(os.tmpdir(), `cdk-integ-${randy}`); + context.output.write(` Stack prefix: ${stackNamePrefix}\n`); + context.output.write(` Test directory: ${integTestDir}\n`); + context.output.write(` Region: ${context.aws.region}\n`); + await cloneDirectory(path.join(__dirname, 'app'), integTestDir, context.output); + const fixture = new TestFixture(integTestDir, stackNamePrefix, context.output, context.aws); + let success = true; + try { + await fixture.shell(['npm', 'install', + '@aws-cdk/core', + '@aws-cdk/aws-sns', + '@aws-cdk/aws-iam', + '@aws-cdk/aws-lambda', + '@aws-cdk/aws-ssm', + '@aws-cdk/aws-ecr-assets', + '@aws-cdk/aws-cloudformation', + '@aws-cdk/aws-ec2']); + await ensureBootstrapped(fixture); + await block(fixture); + } + catch (e) { + success = false; + throw e; + } + finally { + await fixture.dispose(success); + } + }; +} +exports.withCdkApp = withCdkApp; +/** + * Default test fixture for most (all?) integ tests + * + * It's a composition of withAws/withCdkApp, expecting the test block to take a `TestFixture` + * object. + * + * We could have put `withAws(withCdkApp(fixture => { /... actual test here.../ }))` in every + * test declaration but centralizing it is going to make it convenient to modify in the future. + */ +function withDefaultFixture(block) { + return withAws(withCdkApp(block)); + // ^~~~~~ this is disappointing TypeScript! Feels like you should have been able to derive this. +} +exports.withDefaultFixture = withDefaultFixture; +/** + * Prepare a target dir byreplicating a source directory + */ +async function cloneDirectory(source, target, output) { + await shell(['rm', '-rf', target], { output }); + await shell(['mkdir', '-p', target], { output }); + await shell(['cp', '-R', source + '/*', target], { output }); +} +exports.cloneDirectory = cloneDirectory; +class TestFixture { + constructor(integTestDir, stackNamePrefix, output, aws) { + this.integTestDir = integTestDir; + this.stackNamePrefix = stackNamePrefix; + this.output = output; + this.aws = aws; + this.qualifier = randomString().substr(0, 10); + this.bucketsToDelete = new Array(); + } + log(s) { + this.output.write(`${s}\n`); + } + async shell(command, options = {}) { + return shell(command, { + output: this.output, + cwd: this.integTestDir, + ...options, + }); + } + async cdkDeploy(stackNames, options = {}) { + var _a, _b; + stackNames = typeof stackNames === 'string' ? [stackNames] : stackNames; + const neverRequireApproval = (_a = options.neverRequireApproval) !== null && _a !== void 0 ? _a : true; + return this.cdk(['deploy', + ...(neverRequireApproval ? ['--require-approval=never'] : []), // Default to no approval in an unattended test + ...((_b = options.options) !== null && _b !== void 0 ? _b : []), ...this.fullStackName(stackNames)], options); + } + async cdkDestroy(stackNames, options = {}) { + var _a; + stackNames = typeof stackNames === 'string' ? [stackNames] : stackNames; + return this.cdk(['destroy', + '-f', // We never want a prompt in an unattended test + ...((_a = options.options) !== null && _a !== void 0 ? _a : []), ...this.fullStackName(stackNames)], options); + } + async cdk(args, options = {}) { + var _a; + const verbose = (_a = options.verbose) !== null && _a !== void 0 ? _a : true; + return this.shell(['cdk', ...(verbose ? ['-v'] : []), ...args], { + ...options, + modEnv: { + AWS_REGION: this.aws.region, + AWS_DEFAULT_REGION: this.aws.region, + STACK_NAME_PREFIX: this.stackNamePrefix, + ...options.modEnv, + }, + }); + } + fullStackName(stackNames) { + if (typeof stackNames === 'string') { + return `${this.stackNamePrefix}-${stackNames}`; + } + else { + return stackNames.map(s => `${this.stackNamePrefix}-${s}`); + } + } + /** + * Append this to the list of buckets to potentially delete + * + * At the end of a test, we clean up buckets that may not have gotten destroyed + * (for whatever reason). + */ + rememberToDeleteBucket(bucketName) { + this.bucketsToDelete.push(bucketName); + } + /** + * Cleanup leftover stacks and buckets + */ + async dispose(success) { + const stacksToDelete = await this.deleteableStacks(this.stackNamePrefix); + // Bootstrap stacks have buckets that need to be cleaned + const bucketNames = stacksToDelete.map(stack => aws_helpers_1.outputFromStack('BucketName', stack)).filter(defined); + await Promise.all(bucketNames.map(b => this.aws.emptyBucket(b))); + // Bootstrap stacks have ECR repositories with images which should be deleted + const imageRepositoryNames = stacksToDelete.map(stack => aws_helpers_1.outputFromStack('ImageRepositoryName', stack)).filter(defined); + await Promise.all(imageRepositoryNames.map(r => this.aws.deleteImageRepository(r))); + await this.aws.deleteStacks(...stacksToDelete.map(s => s.StackName)); + // We might have leaked some buckets by upgrading the bootstrap stack. Be + // sure to clean everything. + for (const bucket of this.bucketsToDelete) { + await this.aws.deleteBucket(bucket); + } + // If the tests completed successfully, happily delete the fixture + // (otherwise leave it for humans to inspect) + if (success) { + rimraf(this.integTestDir); + } + } + /** + * Return the stacks starting with our testing prefix that should be deleted + */ + async deleteableStacks(prefix) { + var _a; + const statusFilter = [ + 'CREATE_IN_PROGRESS', 'CREATE_FAILED', 'CREATE_COMPLETE', + 'ROLLBACK_IN_PROGRESS', 'ROLLBACK_FAILED', 'ROLLBACK_COMPLETE', + 'DELETE_FAILED', + 'UPDATE_IN_PROGRESS', 'UPDATE_COMPLETE_CLEANUP_IN_PROGRESS', + 'UPDATE_COMPLETE', 'UPDATE_ROLLBACK_IN_PROGRESS', + 'UPDATE_ROLLBACK_FAILED', + 'UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS', + 'UPDATE_ROLLBACK_COMPLETE', 'REVIEW_IN_PROGRESS', + 'IMPORT_IN_PROGRESS', 'IMPORT_COMPLETE', + 'IMPORT_ROLLBACK_IN_PROGRESS', 'IMPORT_ROLLBACK_FAILED', + 'IMPORT_ROLLBACK_COMPLETE', + ]; + const response = await this.aws.cloudFormation('describeStacks', {}); + return ((_a = response.Stacks) !== null && _a !== void 0 ? _a : []) + .filter(s => s.StackName.startsWith(prefix)) + .filter(s => statusFilter.includes(s.StackStatus)) + .filter(s => s.RootId === undefined); // Only delete parent stacks. Nested stacks are deleted in the process + } +} +exports.TestFixture = TestFixture; +/** + * Perform a one-time quick sanity check that the AWS clients has properly configured credentials + * + * If we don't do this, calls are going to fail and they'll be retried and everything will take + * forever before the user notices a simple misconfiguration. + * + * We can't check for the presence of environment variables since credentials could come from + * anywhere, so do simple account retrieval. + * + * Only do it once per process. + */ +async function sanityCheck(aws) { + if (sanityChecked === undefined) { + try { + await aws.account(); + sanityChecked = true; + } + catch (e) { + sanityChecked = false; + throw new Error(`AWS credentials probably not configured, got error: ${e.message}`); + } + } + if (!sanityChecked) { + throw new Error('AWS credentials probably not configured, see previous error'); + } +} +let sanityChecked; +/** + * Make sure that the given environment is bootstrapped + * + * Since we go striping across regions, it's going to suck doing this + * by hand so let's just mass-automate it. + */ +async function ensureBootstrapped(fixture) { + // Old-style bootstrap stack with default name + if (await fixture.aws.stackStatus('CDKToolkit') === undefined) { + await fixture.cdk(['bootstrap', `aws://${await fixture.aws.account()}/${fixture.aws.region}`]); + } +} +/** + * A shell command that does what you want + * + * Is platform-aware, handles errors nicely. + */ +async function shell(command, options = {}) { + var _a, _b; + if (options.modEnv && options.env) { + throw new Error('Use either env or modEnv but not both'); + } + (_a = options.output) === null || _a === void 0 ? void 0 : _a.write(`💻 ${command.join(' ')}\n`); + const env = (_b = options.env) !== null && _b !== void 0 ? _b : (options.modEnv ? { ...process.env, ...options.modEnv } : undefined); + const child = child_process.spawn(command[0], command.slice(1), { + ...options, + env, + // Need this for Windows where we want .cmd and .bat to be found as well. + shell: true, + stdio: ['ignore', 'pipe', 'pipe'], + }); + return new Promise((resolve, reject) => { + const stdout = new Array(); + const stderr = new Array(); + child.stdout.on('data', chunk => { + var _a; + (_a = options.output) === null || _a === void 0 ? void 0 : _a.write(chunk); + stdout.push(chunk); + }); + child.stderr.on('data', chunk => { + var _a, _b; + (_a = options.output) === null || _a === void 0 ? void 0 : _a.write(chunk); + if ((_b = options.captureStderr) !== null && _b !== void 0 ? _b : true) { + stderr.push(chunk); + } + }); + child.once('error', reject); + child.once('close', code => { + if (code === 0 || options.allowErrExit) { + resolve((Buffer.concat(stdout).toString('utf-8') + Buffer.concat(stderr).toString('utf-8')).trim()); + } + else { + reject(new Error(`'${command.join(' ')}' exited with error code ${code}`)); + } + }); + }); +} +exports.shell = shell; +function defined(x) { + return x !== undefined; +} +/** + * rm -rf reimplementation, don't want to depend on an NPM package for this + */ +function rimraf(fsPath) { + try { + const isDir = fs.lstatSync(fsPath).isDirectory(); + if (isDir) { + for (const file of fs.readdirSync(fsPath)) { + rimraf(path.join(fsPath, file)); + } + fs.rmdirSync(fsPath); + } + else { + fs.unlinkSync(fsPath); + } + } + catch (e) { + // We will survive ENOENT + if (e.code !== 'ENOENT') { + throw e; + } + } +} +exports.rimraf = rimraf; +function randomString() { + // Crazy + return Math.random().toString(36).replace(/[^a-z0-9]+/g, ''); +} +exports.randomString = randomString; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cdk-helpers.js","sourceRoot":"","sources":["cdk-helpers.ts"],"names":[],"mappings":"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","sourcesContent":["import * as child_process from 'child_process';\nimport * as fs from 'fs';\nimport * as os from 'os';\nimport * as path from 'path';\nimport { outputFromStack, AwsClients } from './aws-helpers';\nimport { ResourcePool } from './resource-pool';\nimport { TestContext } from './test-helpers';\n\nconst REGIONS = process.env.AWS_REGIONS\n  ? process.env.AWS_REGIONS.split(',')\n  : [process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION ?? 'us-east-1'];\n\nprocess.stdout.write(`Using regions: ${REGIONS}\\n`);\n\nconst REGION_POOL = new ResourcePool(REGIONS);\n\n\nexport type AwsContext = { readonly aws: AwsClients };\n\n/**\n * Higher order function to execute a block with an AWS client setup\n *\n * Allocate the next region from the REGION pool and dispose it afterwards.\n */\nexport function withAws<A extends TestContext>(block: (context: A & AwsContext) => Promise<void>) {\n  return (context: A) => REGION_POOL.using(async (region) => {\n    const aws = await AwsClients.forRegion(region, context.output);\n    await sanityCheck(aws);\n\n    return block({ ...context, aws });\n  });\n}\n\n/**\n * Higher order function to execute a block with a CDK app fixture\n *\n * Requires an AWS client to be passed in.\n *\n * For backwards compatibility with existing tests (so we don't have to change\n * too much) the inner block is expected to take a `TestFixture` object.\n */\nexport function withCdkApp<A extends TestContext & AwsContext>(block: (context: TestFixture) => Promise<void>) {\n  return async (context: A) => {\n    const randy = randomString();\n    const stackNamePrefix = `cdktest-${randy}`;\n    const integTestDir = path.join(os.tmpdir(), `cdk-integ-${randy}`);\n\n    context.output.write(` Stack prefix:   ${stackNamePrefix}\\n`);\n    context.output.write(` Test directory: ${integTestDir}\\n`);\n    context.output.write(` Region:         ${context.aws.region}\\n`);\n\n    await cloneDirectory(path.join(__dirname, 'app'), integTestDir, context.output);\n    const fixture = new TestFixture(\n      integTestDir,\n      stackNamePrefix,\n      context.output,\n      context.aws);\n\n    let success = true;\n    try {\n      await fixture.shell(['npm', 'install',\n        '@aws-cdk/core',\n        '@aws-cdk/aws-sns',\n        '@aws-cdk/aws-iam',\n        '@aws-cdk/aws-lambda',\n        '@aws-cdk/aws-ssm',\n        '@aws-cdk/aws-ecr-assets',\n        '@aws-cdk/aws-cloudformation',\n        '@aws-cdk/aws-ec2']);\n\n      await ensureBootstrapped(fixture);\n\n      await block(fixture);\n    } catch (e) {\n      success = false;\n      throw e;\n    } finally {\n      await fixture.dispose(success);\n    }\n  };\n}\n\n/**\n * Default test fixture for most (all?) integ tests\n *\n * It's a composition of withAws/withCdkApp, expecting the test block to take a `TestFixture`\n * object.\n *\n * We could have put `withAws(withCdkApp(fixture => { /... actual test here.../ }))` in every\n * test declaration but centralizing it is going to make it convenient to modify in the future.\n */\nexport function withDefaultFixture(block: (context: TestFixture) => Promise<void>) {\n  return withAws<TestContext>(withCdkApp(block));\n  //              ^~~~~~ this is disappointing TypeScript! Feels like you should have been able to derive this.\n}\n\nexport interface ShellOptions extends child_process.SpawnOptions {\n  /**\n   * Properties to add to 'env'\n   */\n  modEnv?: Record<string, string>;\n\n  /**\n   * Don't fail when exiting with an error\n   *\n   * @default false\n   */\n  allowErrExit?: boolean;\n\n  /**\n   * Whether to capture stderr\n   *\n   * @default true\n   */\n  captureStderr?: boolean;\n\n  /**\n   * Pass output here\n   */\n  output?: NodeJS.WritableStream;\n}\n\nexport interface CdkCliOptions extends ShellOptions {\n  options?: string[];\n  neverRequireApproval?: boolean;\n  verbose?: boolean;\n}\n\n/**\n * Prepare a target dir byreplicating a source directory\n */\nexport async function cloneDirectory(source: string, target: string, output?: NodeJS.WritableStream) {\n  await shell(['rm', '-rf', target], { output });\n  await shell(['mkdir', '-p', target], { output });\n  await shell(['cp', '-R', source + '/*', target], { output });\n}\n\nexport class TestFixture {\n  public readonly qualifier = randomString().substr(0, 10);\n  private readonly bucketsToDelete = new Array<string>();\n\n  constructor(\n    public readonly integTestDir: string,\n    public readonly stackNamePrefix: string,\n    public readonly output: NodeJS.WritableStream,\n    public readonly aws: AwsClients) {\n  }\n\n  public log(s: string) {\n    this.output.write(`${s}\\n`);\n  }\n\n  public async shell(command: string[], options: Omit<ShellOptions, 'cwd'|'output'> = {}): Promise<string> {\n    return shell(command, {\n      output: this.output,\n      cwd: this.integTestDir,\n      ...options,\n    });\n  }\n\n  public async cdkDeploy(stackNames: string | string[], options: CdkCliOptions = {}) {\n    stackNames = typeof stackNames === 'string' ? [stackNames] : stackNames;\n\n    const neverRequireApproval = options.neverRequireApproval ?? true;\n\n    return this.cdk(['deploy',\n      ...(neverRequireApproval ? ['--require-approval=never'] : []), // Default to no approval in an unattended test\n      ...(options.options ?? []),\n      ...this.fullStackName(stackNames)], options);\n  }\n\n  public async cdkDestroy(stackNames: string | string[], options: CdkCliOptions = {}) {\n    stackNames = typeof stackNames === 'string' ? [stackNames] : stackNames;\n\n    return this.cdk(['destroy',\n      '-f', // We never want a prompt in an unattended test\n      ...(options.options ?? []),\n      ...this.fullStackName(stackNames)], options);\n  }\n\n  public async cdk(args: string[], options: CdkCliOptions = {}) {\n    const verbose = options.verbose ?? true;\n\n    return this.shell(['cdk', ...(verbose ? ['-v'] : []), ...args], {\n      ...options,\n      modEnv: {\n        AWS_REGION: this.aws.region,\n        AWS_DEFAULT_REGION: this.aws.region,\n        STACK_NAME_PREFIX: this.stackNamePrefix,\n        ...options.modEnv,\n      },\n    });\n  }\n\n  public fullStackName(stackName: string): string;\n  public fullStackName(stackNames: string[]): string[];\n  public fullStackName(stackNames: string | string[]): string | string[] {\n    if (typeof stackNames === 'string') {\n      return `${this.stackNamePrefix}-${stackNames}`;\n    } else {\n      return stackNames.map(s => `${this.stackNamePrefix}-${s}`);\n    }\n  }\n\n  /**\n   * Append this to the list of buckets to potentially delete\n   *\n   * At the end of a test, we clean up buckets that may not have gotten destroyed\n   * (for whatever reason).\n   */\n  public rememberToDeleteBucket(bucketName: string) {\n    this.bucketsToDelete.push(bucketName);\n  }\n\n  /**\n   * Cleanup leftover stacks and buckets\n   */\n  public async dispose(success: boolean) {\n    const stacksToDelete = await this.deleteableStacks(this.stackNamePrefix);\n\n    // Bootstrap stacks have buckets that need to be cleaned\n    const bucketNames = stacksToDelete.map(stack => outputFromStack('BucketName', stack)).filter(defined);\n    await Promise.all(bucketNames.map(b => this.aws.emptyBucket(b)));\n\n    // Bootstrap stacks have ECR repositories with images which should be deleted\n    const imageRepositoryNames = stacksToDelete.map(stack => outputFromStack('ImageRepositoryName', stack)).filter(defined);\n    await Promise.all(imageRepositoryNames.map(r => this.aws.deleteImageRepository(r)));\n\n    await this.aws.deleteStacks(...stacksToDelete.map(s => s.StackName));\n\n    // We might have leaked some buckets by upgrading the bootstrap stack. Be\n    // sure to clean everything.\n    for (const bucket of this.bucketsToDelete) {\n      await this.aws.deleteBucket(bucket);\n    }\n\n    // If the tests completed successfully, happily delete the fixture\n    // (otherwise leave it for humans to inspect)\n    if (success) {\n      rimraf(this.integTestDir);\n    }\n  }\n\n  /**\n   * Return the stacks starting with our testing prefix that should be deleted\n   */\n  private async deleteableStacks(prefix: string): Promise<AWS.CloudFormation.Stack[]> {\n    const statusFilter = [\n      'CREATE_IN_PROGRESS', 'CREATE_FAILED', 'CREATE_COMPLETE',\n      'ROLLBACK_IN_PROGRESS', 'ROLLBACK_FAILED', 'ROLLBACK_COMPLETE',\n      'DELETE_FAILED',\n      'UPDATE_IN_PROGRESS', 'UPDATE_COMPLETE_CLEANUP_IN_PROGRESS',\n      'UPDATE_COMPLETE', 'UPDATE_ROLLBACK_IN_PROGRESS',\n      'UPDATE_ROLLBACK_FAILED',\n      'UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS',\n      'UPDATE_ROLLBACK_COMPLETE', 'REVIEW_IN_PROGRESS',\n      'IMPORT_IN_PROGRESS', 'IMPORT_COMPLETE',\n      'IMPORT_ROLLBACK_IN_PROGRESS', 'IMPORT_ROLLBACK_FAILED',\n      'IMPORT_ROLLBACK_COMPLETE',\n    ];\n\n    const response = await this.aws.cloudFormation('describeStacks', {});\n\n    return (response.Stacks ?? [])\n      .filter(s => s.StackName.startsWith(prefix))\n      .filter(s => statusFilter.includes(s.StackStatus))\n      .filter(s => s.RootId === undefined); // Only delete parent stacks. Nested stacks are deleted in the process\n  }\n}\n\n/**\n * Perform a one-time quick sanity check that the AWS clients has properly configured credentials\n *\n * If we don't do this, calls are going to fail and they'll be retried and everything will take\n * forever before the user notices a simple misconfiguration.\n *\n * We can't check for the presence of environment variables since credentials could come from\n * anywhere, so do simple account retrieval.\n *\n * Only do it once per process.\n */\nasync function sanityCheck(aws: AwsClients) {\n  if (sanityChecked === undefined) {\n    try {\n      await aws.account();\n      sanityChecked = true;\n    } catch (e) {\n      sanityChecked = false;\n      throw new Error(`AWS credentials probably not configured, got error: ${e.message}`);\n    }\n  }\n  if (!sanityChecked) {\n    throw new Error('AWS credentials probably not configured, see previous error');\n  }\n}\nlet sanityChecked: boolean | undefined;\n\n/**\n * Make sure that the given environment is bootstrapped\n *\n * Since we go striping across regions, it's going to suck doing this\n * by hand so let's just mass-automate it.\n */\nasync function ensureBootstrapped(fixture: TestFixture) {\n  // Old-style bootstrap stack with default name\n  if (await fixture.aws.stackStatus('CDKToolkit') === undefined) {\n    await fixture.cdk(['bootstrap', `aws://${await fixture.aws.account()}/${fixture.aws.region}`]);\n  }\n}\n\n/**\n * A shell command that does what you want\n *\n * Is platform-aware, handles errors nicely.\n */\nexport async function shell(command: string[], options: ShellOptions = {}): Promise<string> {\n  if (options.modEnv && options.env) {\n    throw new Error('Use either env or modEnv but not both');\n  }\n\n  options.output?.write(`💻 ${command.join(' ')}\\n`);\n\n  const env = options.env ?? (options.modEnv ? { ...process.env, ...options.modEnv } : undefined);\n\n  const child = child_process.spawn(command[0], command.slice(1), {\n    ...options,\n    env,\n    // Need this for Windows where we want .cmd and .bat to be found as well.\n    shell: true,\n    stdio: ['ignore', 'pipe', 'pipe'],\n  });\n\n  return new Promise<string>((resolve, reject) => {\n    const stdout = new Array<Buffer>();\n    const stderr = new Array<Buffer>();\n\n    child.stdout!.on('data', chunk => {\n      options.output?.write(chunk);\n      stdout.push(chunk);\n    });\n\n    child.stderr!.on('data', chunk => {\n      options.output?.write(chunk);\n      if (options.captureStderr ?? true) {\n        stderr.push(chunk);\n      }\n    });\n\n    child.once('error', reject);\n\n    child.once('close', code => {\n      if (code === 0 || options.allowErrExit) {\n        resolve((Buffer.concat(stdout).toString('utf-8') + Buffer.concat(stderr).toString('utf-8')).trim());\n      } else {\n        reject(new Error(`'${command.join(' ')}' exited with error code ${code}`));\n      }\n    });\n  });\n}\n\nfunction defined<A>(x: A): x is NonNullable<A> {\n  return x !== undefined;\n}\n\n/**\n * rm -rf reimplementation, don't want to depend on an NPM package for this\n */\nexport function rimraf(fsPath: string) {\n  try {\n    const isDir = fs.lstatSync(fsPath).isDirectory();\n\n    if (isDir) {\n      for (const file of fs.readdirSync(fsPath)) {\n        rimraf(path.join(fsPath, file));\n      }\n      fs.rmdirSync(fsPath);\n    } else {\n      fs.unlinkSync(fsPath);\n    }\n  } catch (e) {\n    // We will survive ENOENT\n    if (e.code !== 'ENOENT') { throw e; }\n  }\n}\n\nexport function randomString() {\n  // Crazy\n  return Math.random().toString(36).replace(/[^a-z0-9]+/g, '');\n}"]} \ No newline at end of file diff --git a/packages/aws-cdk/test/integ/cli-regression-patches/v1.64.1/cli.integtest.js b/packages/aws-cdk/test/integ/cli-regression-patches/v1.64.1/cli.integtest.js new file mode 100644 index 0000000000000..a63578ecfaee1 --- /dev/null +++ b/packages/aws-cdk/test/integ/cli-regression-patches/v1.64.1/cli.integtest.js @@ -0,0 +1,599 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const fs_1 = require("fs"); +const os = require("os"); +const path = require("path"); +const aws_helpers_1 = require("./aws-helpers"); +const cdk_helpers_1 = require("./cdk-helpers"); +const test_helpers_1 = require("./test-helpers"); +jest.setTimeout(600 * 1000); +test_helpers_1.integTest('VPC Lookup', cdk_helpers_1.withDefaultFixture(async (fixture) => { + fixture.log('Making sure we are clean before starting.'); + await fixture.cdkDestroy('define-vpc', { modEnv: { ENABLE_VPC_TESTING: 'DEFINE' } }); + fixture.log('Setting up: creating a VPC with known tags'); + await fixture.cdkDeploy('define-vpc', { modEnv: { ENABLE_VPC_TESTING: 'DEFINE' } }); + fixture.log('Setup complete!'); + fixture.log('Verifying we can now import that VPC'); + await fixture.cdkDeploy('import-vpc', { modEnv: { ENABLE_VPC_TESTING: 'IMPORT' } }); +})); +test_helpers_1.integTest('Two ways of shoing the version', cdk_helpers_1.withDefaultFixture(async (fixture) => { + const version1 = await fixture.cdk(['version'], { verbose: false }); + const version2 = await fixture.cdk(['--version'], { verbose: false }); + expect(version1).toEqual(version2); +})); +test_helpers_1.integTest('Termination protection', cdk_helpers_1.withDefaultFixture(async (fixture) => { + const stackName = 'termination-protection'; + await fixture.cdkDeploy(stackName); + // Try a destroy that should fail + await expect(fixture.cdkDestroy(stackName)).rejects.toThrow('exited with error'); + // Can update termination protection even though the change set doesn't contain changes + await fixture.cdkDeploy(stackName, { modEnv: { TERMINATION_PROTECTION: 'FALSE' } }); + await fixture.cdkDestroy(stackName); +})); +test_helpers_1.integTest('cdk synth', cdk_helpers_1.withDefaultFixture(async (fixture) => { + await expect(fixture.cdk(['synth', fixture.fullStackName('test-1')], { verbose: false })).resolves.toEqual(`Resources: + topic69831491: + Type: AWS::SNS::Topic + Metadata: + aws:cdk:path: ${fixture.stackNamePrefix}-test-1/topic/Resource`); + await expect(fixture.cdk(['synth', fixture.fullStackName('test-2')], { verbose: false })).resolves.toEqual(`Resources: + topic152D84A37: + Type: AWS::SNS::Topic + Metadata: + aws:cdk:path: ${fixture.stackNamePrefix}-test-2/topic1/Resource + topic2A4FB547F: + Type: AWS::SNS::Topic + Metadata: + aws:cdk:path: ${fixture.stackNamePrefix}-test-2/topic2/Resource`); +})); +test_helpers_1.integTest('ssm parameter provider error', cdk_helpers_1.withDefaultFixture(async (fixture) => { + await expect(fixture.cdk(['synth', + fixture.fullStackName('missing-ssm-parameter'), + '-c', 'test:ssm-parameter-name=/does/not/exist'], { + allowErrExit: true, + })).resolves.toContain('SSM parameter not available in account'); +})); +test_helpers_1.integTest('automatic ordering', cdk_helpers_1.withDefaultFixture(async (fixture) => { + // Deploy the consuming stack which will include the producing stack + await fixture.cdkDeploy('order-consuming'); + // Destroy the providing stack which will include the consuming stack + await fixture.cdkDestroy('order-providing'); +})); +test_helpers_1.integTest('context setting', cdk_helpers_1.withDefaultFixture(async (fixture) => { + await fs_1.promises.writeFile(path.join(fixture.integTestDir, 'cdk.context.json'), JSON.stringify({ + contextkey: 'this is the context value', + })); + try { + await expect(fixture.cdk(['context'])).resolves.toContain('this is the context value'); + // Test that deleting the contextkey works + await fixture.cdk(['context', '--reset', 'contextkey']); + await expect(fixture.cdk(['context'])).resolves.not.toContain('this is the context value'); + // Test that forced delete of the context key does not throw + await fixture.cdk(['context', '-f', '--reset', 'contextkey']); + } + finally { + await fs_1.promises.unlink(path.join(fixture.integTestDir, 'cdk.context.json')); + } +})); +test_helpers_1.integTest('deploy', cdk_helpers_1.withDefaultFixture(async (fixture) => { + var _a; + const stackArn = await fixture.cdkDeploy('test-2', { captureStderr: false }); + // verify the number of resources in the stack + const response = await fixture.aws.cloudFormation('describeStackResources', { + StackName: stackArn, + }); + expect((_a = response.StackResources) === null || _a === void 0 ? void 0 : _a.length).toEqual(2); +})); +test_helpers_1.integTest('deploy all', cdk_helpers_1.withDefaultFixture(async (fixture) => { + const arns = await fixture.cdkDeploy('test-*', { captureStderr: false }); + // verify that we only deployed a single stack (there's a single ARN in the output) + expect(arns.split('\n').length).toEqual(2); +})); +test_helpers_1.integTest('nested stack with parameters', cdk_helpers_1.withDefaultFixture(async (fixture) => { + var _a; + // STACK_NAME_PREFIX is used in MyTopicParam to allow multiple instances + // of this test to run in parallel, othewise they will attempt to create the same SNS topic. + const stackArn = await fixture.cdkDeploy('with-nested-stack-using-parameters', { + options: ['--parameters', `MyTopicParam=${fixture.stackNamePrefix}ThereIsNoSpoon`], + captureStderr: false, + }); + // verify that we only deployed a single stack (there's a single ARN in the output) + expect(stackArn.split('\n').length).toEqual(1); + // verify the number of resources in the stack + const response = await fixture.aws.cloudFormation('describeStackResources', { + StackName: stackArn, + }); + expect((_a = response.StackResources) === null || _a === void 0 ? void 0 : _a.length).toEqual(1); +})); +test_helpers_1.integTest('deploy without execute', cdk_helpers_1.withDefaultFixture(async (fixture) => { + var _a; + const stackArn = await fixture.cdkDeploy('test-2', { + options: ['--no-execute'], + captureStderr: false, + }); + // verify that we only deployed a single stack (there's a single ARN in the output) + expect(stackArn.split('\n').length).toEqual(1); + const response = await fixture.aws.cloudFormation('describeStacks', { + StackName: stackArn, + }); + expect((_a = response.Stacks) === null || _a === void 0 ? void 0 : _a[0].StackStatus).toEqual('REVIEW_IN_PROGRESS'); +})); +test_helpers_1.integTest('security related changes without a CLI are expected to fail', cdk_helpers_1.withDefaultFixture(async (fixture) => { + // redirect /dev/null to stdin, which means there will not be tty attached + // since this stack includes security-related changes, the deployment should + // immediately fail because we can't confirm the changes + const stackName = 'iam-test'; + await expect(fixture.cdkDeploy(stackName, { + options: ['<', '/dev/null'], + neverRequireApproval: false, + })).rejects.toThrow('exited with error'); + // Ensure stack was not deployed + await expect(fixture.aws.cloudFormation('describeStacks', { + StackName: fixture.fullStackName(stackName), + })).rejects.toThrow('does not exist'); +})); +test_helpers_1.integTest('deploy wildcard with outputs', cdk_helpers_1.withDefaultFixture(async (fixture) => { + const outputsFile = path.join(fixture.integTestDir, 'outputs', 'outputs.json'); + await fs_1.promises.mkdir(path.dirname(outputsFile), { recursive: true }); + await fixture.cdkDeploy(['outputs-test-*'], { + options: ['--outputs-file', outputsFile], + }); + const outputs = JSON.parse((await fs_1.promises.readFile(outputsFile, { encoding: 'utf-8' })).toString()); + expect(outputs).toEqual({ + [`${fixture.stackNamePrefix}-outputs-test-1`]: { + TopicName: `${fixture.stackNamePrefix}-outputs-test-1MyTopic`, + }, + [`${fixture.stackNamePrefix}-outputs-test-2`]: { + TopicName: `${fixture.stackNamePrefix}-outputs-test-2MyOtherTopic`, + }, + }); +})); +test_helpers_1.integTest('deploy with parameters', cdk_helpers_1.withDefaultFixture(async (fixture) => { + var _a; + const stackArn = await fixture.cdkDeploy('param-test-1', { + options: [ + '--parameters', `TopicNameParam=${fixture.stackNamePrefix}bazinga`, + ], + captureStderr: false, + }); + const response = await fixture.aws.cloudFormation('describeStacks', { + StackName: stackArn, + }); + expect((_a = response.Stacks) === null || _a === void 0 ? void 0 : _a[0].Parameters).toEqual([ + { + ParameterKey: 'TopicNameParam', + ParameterValue: `${fixture.stackNamePrefix}bazinga`, + }, + ]); +})); +test_helpers_1.integTest('update to stack in ROLLBACK_COMPLETE state will delete stack and create a new one', cdk_helpers_1.withDefaultFixture(async (fixture) => { + var _a, _b, _c, _d; + // GIVEN + await expect(fixture.cdkDeploy('param-test-1', { + options: [ + '--parameters', `TopicNameParam=${fixture.stackNamePrefix}@aww`, + ], + captureStderr: false, + })).rejects.toThrow('exited with error'); + const response = await fixture.aws.cloudFormation('describeStacks', { + StackName: fixture.fullStackName('param-test-1'), + }); + const stackArn = (_a = response.Stacks) === null || _a === void 0 ? void 0 : _a[0].StackId; + expect((_b = response.Stacks) === null || _b === void 0 ? void 0 : _b[0].StackStatus).toEqual('ROLLBACK_COMPLETE'); + // WHEN + const newStackArn = await fixture.cdkDeploy('param-test-1', { + options: [ + '--parameters', `TopicNameParam=${fixture.stackNamePrefix}allgood`, + ], + captureStderr: false, + }); + const newStackResponse = await fixture.aws.cloudFormation('describeStacks', { + StackName: newStackArn, + }); + // THEN + expect(stackArn).not.toEqual(newStackArn); // new stack was created + expect((_c = newStackResponse.Stacks) === null || _c === void 0 ? void 0 : _c[0].StackStatus).toEqual('CREATE_COMPLETE'); + expect((_d = newStackResponse.Stacks) === null || _d === void 0 ? void 0 : _d[0].Parameters).toEqual([ + { + ParameterKey: 'TopicNameParam', + ParameterValue: `${fixture.stackNamePrefix}allgood`, + }, + ]); +})); +test_helpers_1.integTest('stack in UPDATE_ROLLBACK_COMPLETE state can be updated', cdk_helpers_1.withDefaultFixture(async (fixture) => { + var _a, _b, _c, _d; + // GIVEN + const stackArn = await fixture.cdkDeploy('param-test-1', { + options: [ + '--parameters', `TopicNameParam=${fixture.stackNamePrefix}nice`, + ], + captureStderr: false, + }); + let response = await fixture.aws.cloudFormation('describeStacks', { + StackName: stackArn, + }); + expect((_a = response.Stacks) === null || _a === void 0 ? void 0 : _a[0].StackStatus).toEqual('CREATE_COMPLETE'); + // bad parameter name with @ will put stack into UPDATE_ROLLBACK_COMPLETE + await expect(fixture.cdkDeploy('param-test-1', { + options: [ + '--parameters', `TopicNameParam=${fixture.stackNamePrefix}@aww`, + ], + captureStderr: false, + })).rejects.toThrow('exited with error'); + ; + response = await fixture.aws.cloudFormation('describeStacks', { + StackName: stackArn, + }); + expect((_b = response.Stacks) === null || _b === void 0 ? void 0 : _b[0].StackStatus).toEqual('UPDATE_ROLLBACK_COMPLETE'); + // WHEN + await fixture.cdkDeploy('param-test-1', { + options: [ + '--parameters', `TopicNameParam=${fixture.stackNamePrefix}allgood`, + ], + captureStderr: false, + }); + response = await fixture.aws.cloudFormation('describeStacks', { + StackName: stackArn, + }); + // THEN + expect((_c = response.Stacks) === null || _c === void 0 ? void 0 : _c[0].StackStatus).toEqual('UPDATE_COMPLETE'); + expect((_d = response.Stacks) === null || _d === void 0 ? void 0 : _d[0].Parameters).toEqual([ + { + ParameterKey: 'TopicNameParam', + ParameterValue: `${fixture.stackNamePrefix}allgood`, + }, + ]); +})); +test_helpers_1.integTest('deploy with wildcard and parameters', cdk_helpers_1.withDefaultFixture(async (fixture) => { + await fixture.cdkDeploy('param-test-*', { + options: [ + '--parameters', `${fixture.stackNamePrefix}-param-test-1:TopicNameParam=${fixture.stackNamePrefix}bazinga`, + '--parameters', `${fixture.stackNamePrefix}-param-test-2:OtherTopicNameParam=${fixture.stackNamePrefix}ThatsMySpot`, + '--parameters', `${fixture.stackNamePrefix}-param-test-3:DisplayNameParam=${fixture.stackNamePrefix}HeyThere`, + '--parameters', `${fixture.stackNamePrefix}-param-test-3:OtherDisplayNameParam=${fixture.stackNamePrefix}AnotherOne`, + ], + }); +})); +test_helpers_1.integTest('deploy with parameters multi', cdk_helpers_1.withDefaultFixture(async (fixture) => { + var _a; + const paramVal1 = `${fixture.stackNamePrefix}bazinga`; + const paramVal2 = `${fixture.stackNamePrefix}=jagshemash`; + const stackArn = await fixture.cdkDeploy('param-test-3', { + options: [ + '--parameters', `DisplayNameParam=${paramVal1}`, + '--parameters', `OtherDisplayNameParam=${paramVal2}`, + ], + captureStderr: false, + }); + const response = await fixture.aws.cloudFormation('describeStacks', { + StackName: stackArn, + }); + expect((_a = response.Stacks) === null || _a === void 0 ? void 0 : _a[0].Parameters).toEqual([ + { + ParameterKey: 'DisplayNameParam', + ParameterValue: paramVal1, + }, + { + ParameterKey: 'OtherDisplayNameParam', + ParameterValue: paramVal2, + }, + ]); +})); +test_helpers_1.integTest('deploy with notification ARN', cdk_helpers_1.withDefaultFixture(async (fixture) => { + var _a; + const topicName = `${fixture.stackNamePrefix}-test-topic`; + const response = await fixture.aws.sns('createTopic', { Name: topicName }); + const topicArn = response.TopicArn; + try { + await fixture.cdkDeploy('test-2', { + options: ['--notification-arns', topicArn], + }); + // verify that the stack we deployed has our notification ARN + const describeResponse = await fixture.aws.cloudFormation('describeStacks', { + StackName: fixture.fullStackName('test-2'), + }); + expect((_a = describeResponse.Stacks) === null || _a === void 0 ? void 0 : _a[0].NotificationARNs).toEqual([topicArn]); + } + finally { + await fixture.aws.sns('deleteTopic', { + TopicArn: topicArn, + }); + } +})); +test_helpers_1.integTest('deploy with role', cdk_helpers_1.withDefaultFixture(async (fixture) => { + const roleName = `${fixture.stackNamePrefix}-test-role`; + await deleteRole(); + const createResponse = await fixture.aws.iam('createRole', { + RoleName: roleName, + AssumeRolePolicyDocument: JSON.stringify({ + Version: '2012-10-17', + Statement: [{ + Action: 'sts:AssumeRole', + Principal: { Service: 'cloudformation.amazonaws.com' }, + Effect: 'Allow', + }, { + Action: 'sts:AssumeRole', + Principal: { AWS: (await fixture.aws.sts('getCallerIdentity', {})).Arn }, + Effect: 'Allow', + }], + }), + }); + const roleArn = createResponse.Role.Arn; + try { + await fixture.aws.iam('putRolePolicy', { + RoleName: roleName, + PolicyName: 'DefaultPolicy', + PolicyDocument: JSON.stringify({ + Version: '2012-10-17', + Statement: [{ + Action: '*', + Resource: '*', + Effect: 'Allow', + }], + }), + }); + await aws_helpers_1.retry(fixture.output, 'Trying to assume fresh role', aws_helpers_1.retry.forSeconds(300), async () => { + await fixture.aws.sts('assumeRole', { + RoleArn: roleArn, + RoleSessionName: 'testing', + }); + }); + // In principle, the role has replicated from 'us-east-1' to wherever we're testing. + // Give it a little more sleep to make sure CloudFormation is not hitting a box + // that doesn't have it yet. + await aws_helpers_1.sleep(5000); + await fixture.cdkDeploy('test-2', { + options: ['--role-arn', roleArn], + }); + // Immediately delete the stack again before we delete the role. + // + // Since roles are sticky, if we delete the role before the stack, subsequent DeleteStack + // operations will fail when CloudFormation tries to assume the role that's already gone. + await fixture.cdkDestroy('test-2'); + } + finally { + await deleteRole(); + } + async function deleteRole() { + try { + for (const policyName of (await fixture.aws.iam('listRolePolicies', { RoleName: roleName })).PolicyNames) { + await fixture.aws.iam('deleteRolePolicy', { + RoleName: roleName, + PolicyName: policyName, + }); + } + await fixture.aws.iam('deleteRole', { RoleName: roleName }); + } + catch (e) { + if (e.message.indexOf('cannot be found') > -1) { + return; + } + throw e; + } + } +})); +test_helpers_1.integTest('cdk diff', cdk_helpers_1.withDefaultFixture(async (fixture) => { + const diff1 = await fixture.cdk(['diff', fixture.fullStackName('test-1')]); + expect(diff1).toContain('AWS::SNS::Topic'); + const diff2 = await fixture.cdk(['diff', fixture.fullStackName('test-2')]); + expect(diff2).toContain('AWS::SNS::Topic'); + // We can make it fail by passing --fail + await expect(fixture.cdk(['diff', '--fail', fixture.fullStackName('test-1')])) + .rejects.toThrow('exited with error'); +})); +test_helpers_1.integTest('cdk diff --fail on multiple stacks exits with error if any of the stacks contains a diff', cdk_helpers_1.withDefaultFixture(async (fixture) => { + // GIVEN + const diff1 = await fixture.cdk(['diff', fixture.fullStackName('test-1')]); + expect(diff1).toContain('AWS::SNS::Topic'); + await fixture.cdkDeploy('test-2'); + const diff2 = await fixture.cdk(['diff', fixture.fullStackName('test-2')]); + expect(diff2).toContain('There were no differences'); + // WHEN / THEN + await expect(fixture.cdk(['diff', '--fail', fixture.fullStackName('test-1'), fixture.fullStackName('test-2')])).rejects.toThrow('exited with error'); +})); +test_helpers_1.integTest('cdk diff --fail with multiple stack exits with if any of the stacks contains a diff', cdk_helpers_1.withDefaultFixture(async (fixture) => { + // GIVEN + await fixture.cdkDeploy('test-1'); + const diff1 = await fixture.cdk(['diff', fixture.fullStackName('test-1')]); + expect(diff1).toContain('There were no differences'); + const diff2 = await fixture.cdk(['diff', fixture.fullStackName('test-2')]); + expect(diff2).toContain('AWS::SNS::Topic'); + // WHEN / THEN + await expect(fixture.cdk(['diff', '--fail', fixture.fullStackName('test-1'), fixture.fullStackName('test-2')])).rejects.toThrow('exited with error'); +})); +test_helpers_1.integTest('deploy stack with docker asset', cdk_helpers_1.withDefaultFixture(async (fixture) => { + await fixture.cdkDeploy('docker'); +})); +test_helpers_1.integTest('deploy and test stack with lambda asset', cdk_helpers_1.withDefaultFixture(async (fixture) => { + var _a, _b; + const stackArn = await fixture.cdkDeploy('lambda', { captureStderr: false }); + const response = await fixture.aws.cloudFormation('describeStacks', { + StackName: stackArn, + }); + const lambdaArn = (_b = (_a = response.Stacks) === null || _a === void 0 ? void 0 : _a[0].Outputs) === null || _b === void 0 ? void 0 : _b[0].OutputValue; + if (lambdaArn === undefined) { + throw new Error('Stack did not have expected Lambda ARN output'); + } + const output = await fixture.aws.lambda('invoke', { + FunctionName: lambdaArn, + }); + expect(JSON.stringify(output.Payload)).toContain('dear asset'); +})); +test_helpers_1.integTest('cdk ls', cdk_helpers_1.withDefaultFixture(async (fixture) => { + const listing = await fixture.cdk(['ls'], { captureStderr: false }); + const expectedStacks = [ + 'conditional-resource', + 'docker', + 'docker-with-custom-file', + 'failed', + 'iam-test', + 'lambda', + 'missing-ssm-parameter', + 'order-providing', + 'outputs-test-1', + 'outputs-test-2', + 'param-test-1', + 'param-test-2', + 'param-test-3', + 'termination-protection', + 'test-1', + 'test-2', + 'with-nested-stack', + 'with-nested-stack-using-parameters', + 'order-consuming', + ]; + for (const stack of expectedStacks) { + expect(listing).toContain(fixture.fullStackName(stack)); + } +})); +test_helpers_1.integTest('deploy stack without resource', cdk_helpers_1.withDefaultFixture(async (fixture) => { + // Deploy the stack without resources + await fixture.cdkDeploy('conditional-resource', { modEnv: { NO_RESOURCE: 'TRUE' } }); + // This should have succeeded but not deployed the stack. + await expect(fixture.aws.cloudFormation('describeStacks', { StackName: fixture.fullStackName('conditional-resource') })) + .rejects.toThrow('conditional-resource does not exist'); + // Deploy the stack with resources + await fixture.cdkDeploy('conditional-resource'); + // Then again WITHOUT resources (this should destroy the stack) + await fixture.cdkDeploy('conditional-resource', { modEnv: { NO_RESOURCE: 'TRUE' } }); + await expect(fixture.aws.cloudFormation('describeStacks', { StackName: fixture.fullStackName('conditional-resource') })) + .rejects.toThrow('conditional-resource does not exist'); +})); +test_helpers_1.integTest('IAM diff', cdk_helpers_1.withDefaultFixture(async (fixture) => { + const output = await fixture.cdk(['diff', fixture.fullStackName('iam-test')]); + // Roughly check for a table like this: + // + // ┌───┬─────────────────┬────────┬────────────────┬────────────────────────────-──┬───────────┐ + // │ │ Resource │ Effect │ Action │ Principal │ Condition │ + // ├───┼─────────────────┼────────┼────────────────┼───────────────────────────────┼───────────┤ + // │ + │ ${SomeRole.Arn} │ Allow │ sts:AssumeRole │ Service:ec2.amazonaws.com │ │ + // └───┴─────────────────┴────────┴────────────────┴───────────────────────────────┴───────────┘ + expect(output).toContain('${SomeRole.Arn}'); + expect(output).toContain('sts:AssumeRole'); + expect(output).toContain('ec2.amazonaws.com'); +})); +test_helpers_1.integTest('fast deploy', cdk_helpers_1.withDefaultFixture(async (fixture) => { + // we are using a stack with a nested stack because CFN will always attempt to + // update a nested stack, which will allow us to verify that updates are actually + // skipped unless --force is specified. + const stackArn = await fixture.cdkDeploy('with-nested-stack', { captureStderr: false }); + const changeSet1 = await getLatestChangeSet(); + // Deploy the same stack again, there should be no new change set created + await fixture.cdkDeploy('with-nested-stack'); + const changeSet2 = await getLatestChangeSet(); + expect(changeSet2.ChangeSetId).toEqual(changeSet1.ChangeSetId); + // Deploy the stack again with --force, now we should create a changeset + await fixture.cdkDeploy('with-nested-stack', { options: ['--force'] }); + const changeSet3 = await getLatestChangeSet(); + expect(changeSet3.ChangeSetId).not.toEqual(changeSet2.ChangeSetId); + // Deploy the stack again with tags, expected to create a new changeset + // even though the resources didn't change. + await fixture.cdkDeploy('with-nested-stack', { options: ['--tags', 'key=value'] }); + const changeSet4 = await getLatestChangeSet(); + expect(changeSet4.ChangeSetId).not.toEqual(changeSet3.ChangeSetId); + async function getLatestChangeSet() { + var _a, _b, _c; + const response = await fixture.aws.cloudFormation('describeStacks', { StackName: stackArn }); + if (!((_a = response.Stacks) === null || _a === void 0 ? void 0 : _a[0])) { + throw new Error('Did not get a ChangeSet at all'); + } + fixture.log(`Found Change Set ${(_b = response.Stacks) === null || _b === void 0 ? void 0 : _b[0].ChangeSetId}`); + return (_c = response.Stacks) === null || _c === void 0 ? void 0 : _c[0]; + } +})); +test_helpers_1.integTest('failed deploy does not hang', cdk_helpers_1.withDefaultFixture(async (fixture) => { + // this will hang if we introduce https://github.com/aws/aws-cdk/issues/6403 again. + await expect(fixture.cdkDeploy('failed')).rejects.toThrow('exited with error'); +})); +test_helpers_1.integTest('can still load old assemblies', cdk_helpers_1.withDefaultFixture(async (fixture) => { + const cxAsmDir = path.join(os.tmpdir(), 'cdk-integ-cx'); + const testAssembliesDirectory = path.join(__dirname, 'cloud-assemblies'); + for (const asmdir of await listChildDirs(testAssembliesDirectory)) { + fixture.log(`ASSEMBLY ${asmdir}`); + await cdk_helpers_1.cloneDirectory(asmdir, cxAsmDir); + // Some files in the asm directory that have a .js extension are + // actually treated as templates. Evaluate them using NodeJS. + const templates = await listChildren(cxAsmDir, fullPath => Promise.resolve(fullPath.endsWith('.js'))); + for (const template of templates) { + const targetName = template.replace(/.js$/, ''); + await cdk_helpers_1.shell([process.execPath, template, '>', targetName], { + cwd: cxAsmDir, + output: fixture.output, + modEnv: { + TEST_ACCOUNT: await fixture.aws.account(), + TEST_REGION: fixture.aws.region, + }, + }); + } + // Use this directory as a Cloud Assembly + const output = await fixture.cdk([ + '--app', cxAsmDir, + '-v', + 'synth', + ]); + // Assert that there was no providerError in CDK's stderr + // Because we rely on the app/framework to actually error in case the + // provider fails, we inspect the logs here. + expect(output).not.toContain('$providerError'); + } +})); +test_helpers_1.integTest('generating and loading assembly', cdk_helpers_1.withDefaultFixture(async (fixture) => { + const asmOutputDir = `${fixture.integTestDir}-cdk-integ-asm`; + await fixture.shell(['rm', '-rf', asmOutputDir]); + // Synthesize a Cloud Assembly tothe default directory (cdk.out) and a specific directory. + await fixture.cdk(['synth']); + await fixture.cdk(['synth', '--output', asmOutputDir]); + // cdk.out in the current directory and the indicated --output should be the same + await fixture.shell(['diff', 'cdk.out', asmOutputDir]); + // Check that we can 'ls' the synthesized asm. + // Change to some random directory to make sure we're not accidentally loading cdk.json + const list = await fixture.cdk(['--app', asmOutputDir, 'ls'], { cwd: os.tmpdir() }); + // Same stacks we know are in the app + expect(list).toContain(`${fixture.stackNamePrefix}-lambda`); + expect(list).toContain(`${fixture.stackNamePrefix}-test-1`); + expect(list).toContain(`${fixture.stackNamePrefix}-test-2`); + // Check that we can use '.' and just synth ,the generated asm + const stackTemplate = await fixture.cdk(['--app', '.', 'synth', fixture.fullStackName('test-2')], { + cwd: asmOutputDir, + }); + expect(stackTemplate).toContain('topic152D84A37'); + // Deploy a Lambda from the copied asm + await fixture.cdkDeploy('lambda', { options: ['-a', '.'], cwd: asmOutputDir }); + // Remove (rename) the original custom docker file that was used during synth. + // this verifies that the assemly has a copy of it and that the manifest uses + // relative paths to reference to it. + const customDockerFile = path.join(fixture.integTestDir, 'docker', 'Dockerfile.Custom'); + await fs_1.promises.rename(customDockerFile, `${customDockerFile}~`); + try { + // deploy a docker image with custom file without synth (uses assets) + await fixture.cdkDeploy('docker-with-custom-file', { options: ['-a', '.'], cwd: asmOutputDir }); + } + finally { + // Rename back to restore fixture to original state + await fs_1.promises.rename(`${customDockerFile}~`, customDockerFile); + } +})); +test_helpers_1.integTest('templates on disk contain metadata resource, also in nested assemblies', cdk_helpers_1.withDefaultFixture(async (fixture) => { + // Synth first, and switch on version reporting because cdk.json is disabling it + await fixture.cdk(['synth', '--version-reporting=true']); + // Load template from disk from root assembly + const templateContents = await fixture.shell(['cat', 'cdk.out/*-lambda.template.json']); + expect(JSON.parse(templateContents).Resources.CDKMetadata).toBeTruthy(); + // Load template from nested assembly + const nestedTemplateContents = await fixture.shell(['cat', 'cdk.out/assembly-*-stage/*-stage-StackInStage.template.json']); + expect(JSON.parse(nestedTemplateContents).Resources.CDKMetadata).toBeTruthy(); +})); +async function listChildren(parent, pred) { + const ret = new Array(); + for (const child of await fs_1.promises.readdir(parent, { encoding: 'utf-8' })) { + const fullPath = path.join(parent, child.toString()); + if (await pred(fullPath)) { + ret.push(fullPath); + } + } + return ret; +} +async function listChildDirs(parent) { + return listChildren(parent, async (fullPath) => (await fs_1.promises.stat(fullPath)).isDirectory()); +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cli.integtest.js","sourceRoot":"","sources":["cli.integtest.ts"],"names":[],"mappings":";;AAAA,2BAAoC;AACpC,yBAAyB;AACzB,6BAA6B;AAC7B,+CAA6C;AAC7C,+CAA0E;AAC1E,iDAA2C;AAE3C,IAAI,CAAC,UAAU,CAAC,GAAG,GAAG,IAAI,CAAC,CAAC;AAE5B,wBAAS,CAAC,YAAY,EAAE,gCAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;IAC3D,OAAO,CAAC,GAAG,CAAC,2CAA2C,CAAC,CAAC;IACzD,MAAM,OAAO,CAAC,UAAU,CAAC,YAAY,EAAE,EAAE,MAAM,EAAE,EAAE,kBAAkB,EAAE,QAAQ,EAAE,EAAE,CAAC,CAAC;IAErF,OAAO,CAAC,GAAG,CAAC,4CAA4C,CAAC,CAAC;IAC1D,MAAM,OAAO,CAAC,SAAS,CAAC,YAAY,EAAE,EAAE,MAAM,EAAE,EAAE,kBAAkB,EAAE,QAAQ,EAAE,EAAE,CAAC,CAAC;IACpF,OAAO,CAAC,GAAG,CAAC,iBAAiB,CAAC,CAAC;IAE/B,OAAO,CAAC,GAAG,CAAC,sCAAsC,CAAC,CAAC;IACpD,MAAM,OAAO,CAAC,SAAS,CAAC,YAAY,EAAE,EAAE,MAAM,EAAE,EAAE,kBAAkB,EAAE,QAAQ,EAAE,EAAE,CAAC,CAAC;AACtF,CAAC,CAAC,CAAC,CAAC;AAEJ,wBAAS,CAAC,gCAAgC,EAAE,gCAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;IAC/E,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC;IACpE,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC,WAAW,CAAC,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC;IAEtE,MAAM,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;AACrC,CAAC,CAAC,CAAC,CAAC;AAEJ,wBAAS,CAAC,wBAAwB,EAAE,gCAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;IACvE,MAAM,SAAS,GAAG,wBAAwB,CAAC;IAC3C,MAAM,OAAO,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;IAEnC,iCAAiC;IACjC,MAAM,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,mBAAmB,CAAC,CAAC;IAEjF,uFAAuF;IACvF,MAAM,OAAO,CAAC,SAAS,CAAC,SAAS,EAAE,EAAE,MAAM,EAAE,EAAE,sBAAsB,EAAE,OAAO,EAAE,EAAE,CAAC,CAAC;IACpF,MAAM,OAAO,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;AACtC,CAAC,CAAC,CAAC,CAAC;AAEJ,wBAAS,CAAC,WAAW,EAAE,gCAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;IAC1D,MAAM,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,OAAO,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,OAAO,CACxG;;;;sBAIkB,OAAO,CAAC,eAAe,wBAAwB,CAAC,CAAC;IAErE,MAAM,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,OAAO,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,OAAO,CACxG;;;;sBAIkB,OAAO,CAAC,eAAe;;;;sBAIvB,OAAO,CAAC,eAAe,yBAAyB,CAAC,CAAC;AACxE,CAAC,CAAC,CAAC,CAAC;AAEJ,wBAAS,CAAC,8BAA8B,EAAE,gCAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;IAC7E,MAAM,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,OAAO;QAC/B,OAAO,CAAC,aAAa,CAAC,uBAAuB,CAAC;QAC9C,IAAI,EAAE,yCAAyC,CAAC,EAAE;QAClD,YAAY,EAAE,IAAI;KACnB,CAAC,CAAC,CAAC,QAAQ,CAAC,SAAS,CAAC,wCAAwC,CAAC,CAAC;AACnE,CAAC,CAAC,CAAC,CAAC;AAEJ,wBAAS,CAAC,oBAAoB,EAAE,gCAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;IACnE,oEAAoE;IACpE,MAAM,OAAO,CAAC,SAAS,CAAC,iBAAiB,CAAC,CAAC;IAE3C,qEAAqE;IACrE,MAAM,OAAO,CAAC,UAAU,CAAC,iBAAiB,CAAC,CAAC;AAC9C,CAAC,CAAC,CAAC,CAAC;AAEJ,wBAAS,CAAC,iBAAiB,EAAE,gCAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;IAChE,MAAM,aAAE,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE,kBAAkB,CAAC,EAAE,IAAI,CAAC,SAAS,CAAC;QACrF,UAAU,EAAE,2BAA2B;KACxC,CAAC,CAAC,CAAC;IACJ,IAAI;QACF,MAAM,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,SAAS,CAAC,2BAA2B,CAAC,CAAC;QAEvF,0CAA0C;QAC1C,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,SAAS,EAAE,YAAY,CAAC,CAAC,CAAC;QACxD,MAAM,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,2BAA2B,CAAC,CAAC;QAE3F,4DAA4D;QAC5D,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,IAAI,EAAE,SAAS,EAAE,YAAY,CAAC,CAAC,CAAC;KAE/D;YAAS;QACR,MAAM,aAAE,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE,kBAAkB,CAAC,CAAC,CAAC;KACtE;AACH,CAAC,CAAC,CAAC,CAAC;AAEJ,wBAAS,CAAC,QAAQ,EAAE,gCAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;;IACvD,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,SAAS,CAAC,QAAQ,EAAE,EAAE,aAAa,EAAE,KAAK,EAAE,CAAC,CAAC;IAE7E,8CAA8C;IAC9C,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,wBAAwB,EAAE;QAC1E,SAAS,EAAE,QAAQ;KACpB,CAAC,CAAC;IACH,MAAM,OAAC,QAAQ,CAAC,cAAc,0CAAE,MAAM,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;AACrD,CAAC,CAAC,CAAC,CAAC;AAEJ,wBAAS,CAAC,YAAY,EAAE,gCAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;IAC3D,MAAM,IAAI,GAAG,MAAM,OAAO,CAAC,SAAS,CAAC,QAAQ,EAAE,EAAE,aAAa,EAAE,KAAK,EAAE,CAAC,CAAC;IAEzE,mFAAmF;IACnF,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;AAC7C,CAAC,CAAC,CAAC,CAAC;AAEJ,wBAAS,CAAC,8BAA8B,EAAE,gCAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;;IAC7E,wEAAwE;IACxE,4FAA4F;IAC5F,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,SAAS,CAAC,oCAAoC,EAAE;QAC7E,OAAO,EAAE,CAAC,cAAc,EAAE,gBAAgB,OAAO,CAAC,eAAe,gBAAgB,CAAC;QAClF,aAAa,EAAE,KAAK;KACrB,CAAC,CAAC;IAEH,mFAAmF;IACnF,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IAE/C,8CAA8C;IAC9C,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,wBAAwB,EAAE;QAC1E,SAAS,EAAE,QAAQ;KACpB,CAAC,CAAC;IACH,MAAM,OAAC,QAAQ,CAAC,cAAc,0CAAE,MAAM,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;AACrD,CAAC,CAAC,CAAC,CAAC;AAEJ,wBAAS,CAAC,wBAAwB,EAAE,gCAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;;IACvE,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,SAAS,CAAC,QAAQ,EAAE;QACjD,OAAO,EAAE,CAAC,cAAc,CAAC;QACzB,aAAa,EAAE,KAAK;KACrB,CAAC,CAAC;IACH,mFAAmF;IACnF,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IAE/C,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,gBAAgB,EAAE;QAClE,SAAS,EAAE,QAAQ;KACpB,CAAC,CAAC;IAEH,MAAM,OAAC,QAAQ,CAAC,MAAM,0CAAG,CAAC,EAAE,WAAW,CAAC,CAAC,OAAO,CAAC,oBAAoB,CAAC,CAAC;AACzE,CAAC,CAAC,CAAC,CAAC;AAEJ,wBAAS,CAAC,6DAA6D,EAAE,gCAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;IAC5G,0EAA0E;IAC1E,4EAA4E;IAC5E,wDAAwD;IACxD,MAAM,SAAS,GAAG,UAAU,CAAC;IAC7B,MAAM,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,SAAS,EAAE;QACxC,OAAO,EAAE,CAAC,GAAG,EAAE,WAAW,CAAC;QAC3B,oBAAoB,EAAE,KAAK;KAC5B,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,mBAAmB,CAAC,CAAC;IAEzC,gCAAgC;IAChC,MAAM,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,gBAAgB,EAAE;QACxD,SAAS,EAAE,OAAO,CAAC,aAAa,CAAC,SAAS,CAAC;KAC5C,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,gBAAgB,CAAC,CAAC;AACxC,CAAC,CAAC,CAAC,CAAC;AAEJ,wBAAS,CAAC,8BAA8B,EAAE,gCAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;IAC7E,MAAM,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE,SAAS,EAAE,cAAc,CAAC,CAAC;IAC/E,MAAM,aAAE,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAE/D,MAAM,OAAO,CAAC,SAAS,CAAC,CAAC,gBAAgB,CAAC,EAAE;QAC1C,OAAO,EAAE,CAAC,gBAAgB,EAAE,WAAW,CAAC;KACzC,CAAC,CAAC;IAEH,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,MAAM,aAAE,CAAC,QAAQ,CAAC,WAAW,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC;IAC/F,MAAM,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC;QACtB,CAAC,GAAG,OAAO,CAAC,eAAe,iBAAiB,CAAC,EAAE;YAC7C,SAAS,EAAE,GAAG,OAAO,CAAC,eAAe,wBAAwB;SAC9D;QACD,CAAC,GAAG,OAAO,CAAC,eAAe,iBAAiB,CAAC,EAAE;YAC7C,SAAS,EAAE,GAAG,OAAO,CAAC,eAAe,6BAA6B;SACnE;KACF,CAAC,CAAC;AACL,CAAC,CAAC,CAAC,CAAC;AAEJ,wBAAS,CAAC,wBAAwB,EAAE,gCAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;;IACvE,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,SAAS,CAAC,cAAc,EAAE;QACvD,OAAO,EAAE;YACP,cAAc,EAAE,kBAAkB,OAAO,CAAC,eAAe,SAAS;SACnE;QACD,aAAa,EAAE,KAAK;KACrB,CAAC,CAAC;IAEH,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,gBAAgB,EAAE;QAClE,SAAS,EAAE,QAAQ;KACpB,CAAC,CAAC;IAEH,MAAM,OAAC,QAAQ,CAAC,MAAM,0CAAG,CAAC,EAAE,UAAU,CAAC,CAAC,OAAO,CAAC;QAC9C;YACE,YAAY,EAAE,gBAAgB;YAC9B,cAAc,EAAE,GAAG,OAAO,CAAC,eAAe,SAAS;SACpD;KACF,CAAC,CAAC;AACL,CAAC,CAAC,CAAC,CAAC;AAEJ,wBAAS,CAAC,mFAAmF,EAAE,gCAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;;IAClI,QAAQ;IACR,MAAM,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,cAAc,EAAE;QAC7C,OAAO,EAAE;YACP,cAAc,EAAE,kBAAkB,OAAO,CAAC,eAAe,MAAM;SAChE;QACD,aAAa,EAAE,KAAK;KACrB,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,mBAAmB,CAAC,CAAC;IAEzC,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,gBAAgB,EAAE;QAClE,SAAS,EAAE,OAAO,CAAC,aAAa,CAAC,cAAc,CAAC;KACjD,CAAC,CAAC;IAEH,MAAM,QAAQ,SAAG,QAAQ,CAAC,MAAM,0CAAG,CAAC,EAAE,OAAO,CAAC;IAC9C,MAAM,OAAC,QAAQ,CAAC,MAAM,0CAAG,CAAC,EAAE,WAAW,CAAC,CAAC,OAAO,CAAC,mBAAmB,CAAC,CAAC;IAEtE,OAAO;IACP,MAAM,WAAW,GAAG,MAAM,OAAO,CAAC,SAAS,CAAC,cAAc,EAAE;QAC1D,OAAO,EAAE;YACP,cAAc,EAAE,kBAAkB,OAAO,CAAC,eAAe,SAAS;SACnE;QACD,aAAa,EAAE,KAAK;KACrB,CAAC,CAAC;IAEH,MAAM,gBAAgB,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,gBAAgB,EAAE;QAC1E,SAAS,EAAE,WAAW;KACvB,CAAC,CAAC;IAEH,OAAO;IACP,MAAM,CAAE,QAAQ,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,wBAAwB;IACpE,MAAM,OAAC,gBAAgB,CAAC,MAAM,0CAAG,CAAC,EAAE,WAAW,CAAC,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC;IAC5E,MAAM,OAAC,gBAAgB,CAAC,MAAM,0CAAG,CAAC,EAAE,UAAU,CAAC,CAAC,OAAO,CAAC;QACtD;YACE,YAAY,EAAE,gBAAgB;YAC9B,cAAc,EAAE,GAAG,OAAO,CAAC,eAAe,SAAS;SACpD;KACF,CAAC,CAAC;AACL,CAAC,CAAC,CAAC,CAAC;AAEJ,wBAAS,CAAC,wDAAwD,EAAE,gCAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;;IACvG,QAAQ;IACR,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,SAAS,CAAC,cAAc,EAAE;QACvD,OAAO,EAAE;YACP,cAAc,EAAE,kBAAkB,OAAO,CAAC,eAAe,MAAM;SAChE;QACD,aAAa,EAAE,KAAK;KACrB,CAAC,CAAC;IAEH,IAAI,QAAQ,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,gBAAgB,EAAE;QAChE,SAAS,EAAE,QAAQ;KACpB,CAAC,CAAC;IAEH,MAAM,OAAC,QAAQ,CAAC,MAAM,0CAAG,CAAC,EAAE,WAAW,CAAC,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC;IAEpE,yEAAyE;IACzE,MAAM,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,cAAc,EAAE;QAC7C,OAAO,EAAE;YACP,cAAc,EAAE,kBAAkB,OAAO,CAAC,eAAe,MAAM;SAChE;QACD,aAAa,EAAE,KAAK;KACrB,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,mBAAmB,CAAC,CAAC;IAAA,CAAC;IAE1C,QAAQ,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,gBAAgB,EAAE;QAC5D,SAAS,EAAE,QAAQ;KACpB,CAAC,CAAC;IAEH,MAAM,OAAC,QAAQ,CAAC,MAAM,0CAAG,CAAC,EAAE,WAAW,CAAC,CAAC,OAAO,CAAC,0BAA0B,CAAC,CAAC;IAE7E,OAAO;IACP,MAAM,OAAO,CAAC,SAAS,CAAC,cAAc,EAAE;QACtC,OAAO,EAAE;YACP,cAAc,EAAE,kBAAkB,OAAO,CAAC,eAAe,SAAS;SACnE;QACD,aAAa,EAAE,KAAK;KACrB,CAAC,CAAC;IAEH,QAAQ,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,gBAAgB,EAAE;QAC5D,SAAS,EAAE,QAAQ;KACpB,CAAC,CAAC;IAEH,OAAO;IACP,MAAM,OAAC,QAAQ,CAAC,MAAM,0CAAG,CAAC,EAAE,WAAW,CAAC,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC;IACpE,MAAM,OAAC,QAAQ,CAAC,MAAM,0CAAG,CAAC,EAAE,UAAU,CAAC,CAAC,OAAO,CAAC;QAC9C;YACE,YAAY,EAAE,gBAAgB;YAC9B,cAAc,EAAE,GAAG,OAAO,CAAC,eAAe,SAAS;SACpD;KACF,CAAC,CAAC;AACL,CAAC,CAAC,CAAC,CAAC;AAEJ,wBAAS,CAAC,qCAAqC,EAAE,gCAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;IACpF,MAAM,OAAO,CAAC,SAAS,CAAC,cAAc,EAAE;QACtC,OAAO,EAAE;YACP,cAAc,EAAE,GAAG,OAAO,CAAC,eAAe,gCAAgC,OAAO,CAAC,eAAe,SAAS;YAC1G,cAAc,EAAE,GAAG,OAAO,CAAC,eAAe,qCAAqC,OAAO,CAAC,eAAe,aAAa;YACnH,cAAc,EAAE,GAAG,OAAO,CAAC,eAAe,kCAAkC,OAAO,CAAC,eAAe,UAAU;YAC7G,cAAc,EAAE,GAAG,OAAO,CAAC,eAAe,uCAAuC,OAAO,CAAC,eAAe,YAAY;SACrH;KACF,CAAC,CAAC;AACL,CAAC,CAAC,CAAC,CAAC;AAEJ,wBAAS,CAAC,8BAA8B,EAAE,gCAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;;IAC7E,MAAM,SAAS,GAAG,GAAG,OAAO,CAAC,eAAe,SAAS,CAAC;IACtD,MAAM,SAAS,GAAG,GAAG,OAAO,CAAC,eAAe,aAAa,CAAC;IAE1D,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,SAAS,CAAC,cAAc,EAAE;QACvD,OAAO,EAAE;YACP,cAAc,EAAE,oBAAoB,SAAS,EAAE;YAC/C,cAAc,EAAE,yBAAyB,SAAS,EAAE;SACrD;QACD,aAAa,EAAE,KAAK;KACrB,CAAC,CAAC;IAEH,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,gBAAgB,EAAE;QAClE,SAAS,EAAE,QAAQ;KACpB,CAAC,CAAC;IAEH,MAAM,OAAC,QAAQ,CAAC,MAAM,0CAAG,CAAC,EAAE,UAAU,CAAC,CAAC,OAAO,CAAC;QAC9C;YACE,YAAY,EAAE,kBAAkB;YAChC,cAAc,EAAE,SAAS;SAC1B;QACD;YACE,YAAY,EAAE,uBAAuB;YACrC,cAAc,EAAE,SAAS;SAC1B;KACF,CAAC,CAAC;AACL,CAAC,CAAC,CAAC,CAAC;AAEJ,wBAAS,CAAC,8BAA8B,EAAE,gCAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;;IAC7E,MAAM,SAAS,GAAG,GAAG,OAAO,CAAC,eAAe,aAAa,CAAC;IAE1D,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,aAAa,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC,CAAC;IAC3E,MAAM,QAAQ,GAAG,QAAQ,CAAC,QAAS,CAAC;IACpC,IAAI;QACF,MAAM,OAAO,CAAC,SAAS,CAAC,QAAQ,EAAE;YAChC,OAAO,EAAE,CAAC,qBAAqB,EAAE,QAAQ,CAAC;SAC3C,CAAC,CAAC;QAEH,6DAA6D;QAC7D,MAAM,gBAAgB,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,gBAAgB,EAAE;YAC1E,SAAS,EAAE,OAAO,CAAC,aAAa,CAAC,QAAQ,CAAC;SAC3C,CAAC,CAAC;QACH,MAAM,OAAC,gBAAgB,CAAC,MAAM,0CAAG,CAAC,EAAE,gBAAgB,CAAC,CAAC,OAAO,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;KAC3E;YAAS;QACR,MAAM,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,aAAa,EAAE;YACnC,QAAQ,EAAE,QAAQ;SACnB,CAAC,CAAC;KACJ;AACH,CAAC,CAAC,CAAC,CAAC;AAEJ,wBAAS,CAAC,kBAAkB,EAAE,gCAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;IACjE,MAAM,QAAQ,GAAG,GAAG,OAAO,CAAC,eAAe,YAAY,CAAC;IAExD,MAAM,UAAU,EAAE,CAAC;IAEnB,MAAM,cAAc,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,YAAY,EAAE;QACzD,QAAQ,EAAE,QAAQ;QAClB,wBAAwB,EAAE,IAAI,CAAC,SAAS,CAAC;YACvC,OAAO,EAAE,YAAY;YACrB,SAAS,EAAE,CAAC;oBACV,MAAM,EAAE,gBAAgB;oBACxB,SAAS,EAAE,EAAE,OAAO,EAAE,8BAA8B,EAAE;oBACtD,MAAM,EAAE,OAAO;iBAChB,EAAE;oBACD,MAAM,EAAE,gBAAgB;oBACxB,SAAS,EAAE,EAAE,GAAG,EAAE,CAAC,MAAM,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,mBAAmB,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,EAAE;oBACxE,MAAM,EAAE,OAAO;iBAChB,CAAC;SACH,CAAC;KACH,CAAC,CAAC;IACH,MAAM,OAAO,GAAG,cAAc,CAAC,IAAI,CAAC,GAAG,CAAC;IACxC,IAAI;QACF,MAAM,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,eAAe,EAAE;YACrC,QAAQ,EAAE,QAAQ;YAClB,UAAU,EAAE,eAAe;YAC3B,cAAc,EAAE,IAAI,CAAC,SAAS,CAAC;gBAC7B,OAAO,EAAE,YAAY;gBACrB,SAAS,EAAE,CAAC;wBACV,MAAM,EAAE,GAAG;wBACX,QAAQ,EAAE,GAAG;wBACb,MAAM,EAAE,OAAO;qBAChB,CAAC;aACH,CAAC;SACH,CAAC,CAAC;QAEH,MAAM,mBAAK,CAAC,OAAO,CAAC,MAAM,EAAE,6BAA6B,EAAE,mBAAK,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,KAAK,IAAI,EAAE;YAC3F,MAAM,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,YAAY,EAAE;gBAClC,OAAO,EAAE,OAAO;gBAChB,eAAe,EAAE,SAAS;aAC3B,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QAEH,oFAAoF;QACpF,+EAA+E;QAC/E,4BAA4B;QAC5B,MAAM,mBAAK,CAAC,IAAI,CAAC,CAAC;QAElB,MAAM,OAAO,CAAC,SAAS,CAAC,QAAQ,EAAE;YAChC,OAAO,EAAE,CAAC,YAAY,EAAE,OAAO,CAAC;SACjC,CAAC,CAAC;QAEH,gEAAgE;QAChE,EAAE;QACF,yFAAyF;QACzF,yFAAyF;QACzF,MAAM,OAAO,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;KAEpC;YAAS;QACR,MAAM,UAAU,EAAE,CAAC;KACpB;IAED,KAAK,UAAU,UAAU;QACvB,IAAI;YACF,KAAK,MAAM,UAAU,IAAI,CAAC,MAAM,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,kBAAkB,EAAE,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC,WAAW,EAAE;gBACxG,MAAM,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,kBAAkB,EAAE;oBACxC,QAAQ,EAAE,QAAQ;oBAClB,UAAU,EAAE,UAAU;iBACvB,CAAC,CAAC;aACJ;YACD,MAAM,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,YAAY,EAAE,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC,CAAC;SAC7D;QAAC,OAAO,CAAC,EAAE;YACV,IAAI,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC,EAAE;gBAAE,OAAO;aAAE;YAC1D,MAAM,CAAC,CAAC;SACT;IACH,CAAC;AACH,CAAC,CAAC,CAAC,CAAC;AAEJ,wBAAS,CAAC,UAAU,EAAE,gCAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;IACzD,MAAM,KAAK,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,OAAO,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;IAC3E,MAAM,CAAC,KAAK,CAAC,CAAC,SAAS,CAAC,iBAAiB,CAAC,CAAC;IAE3C,MAAM,KAAK,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,OAAO,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;IAC3E,MAAM,CAAC,KAAK,CAAC,CAAC,SAAS,CAAC,iBAAiB,CAAC,CAAC;IAE3C,wCAAwC;IACxC,MAAM,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,QAAQ,EAAE,OAAO,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;SAC3E,OAAO,CAAC,OAAO,CAAC,mBAAmB,CAAC,CAAC;AAC1C,CAAC,CAAC,CAAC,CAAC;AAEJ,wBAAS,CAAC,0FAA0F,EAAE,gCAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;IACzI,QAAQ;IACR,MAAM,KAAK,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,OAAO,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;IAC3E,MAAM,CAAC,KAAK,CAAC,CAAC,SAAS,CAAC,iBAAiB,CAAC,CAAC;IAE3C,MAAM,OAAO,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;IAClC,MAAM,KAAK,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,OAAO,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;IAC3E,MAAM,CAAC,KAAK,CAAC,CAAC,SAAS,CAAC,2BAA2B,CAAC,CAAC;IAErD,cAAc;IACd,MAAM,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,QAAQ,EAAE,OAAO,CAAC,aAAa,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,mBAAmB,CAAC,CAAC;AACvJ,CAAC,CAAC,CAAC,CAAC;AAEJ,wBAAS,CAAC,qFAAqF,EAAE,gCAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;IACpI,QAAQ;IACR,MAAM,OAAO,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;IAClC,MAAM,KAAK,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,OAAO,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;IAC3E,MAAM,CAAC,KAAK,CAAC,CAAC,SAAS,CAAC,2BAA2B,CAAC,CAAC;IAErD,MAAM,KAAK,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,OAAO,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;IAC3E,MAAM,CAAC,KAAK,CAAC,CAAC,SAAS,CAAC,iBAAiB,CAAC,CAAC;IAE3C,cAAc;IACd,MAAM,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,QAAQ,EAAE,OAAO,CAAC,aAAa,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,mBAAmB,CAAC,CAAC;AACvJ,CAAC,CAAC,CAAC,CAAC;AAEJ,wBAAS,CAAC,gCAAgC,EAAE,gCAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;IAC/E,MAAM,OAAO,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;AACpC,CAAC,CAAC,CAAC,CAAC;AAEJ,wBAAS,CAAC,yCAAyC,EAAE,gCAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;;IACxF,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,SAAS,CAAC,QAAQ,EAAE,EAAE,aAAa,EAAE,KAAK,EAAE,CAAC,CAAC;IAE7E,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,gBAAgB,EAAE;QAClE,SAAS,EAAE,QAAQ;KACpB,CAAC,CAAC;IACH,MAAM,SAAS,eAAG,QAAQ,CAAC,MAAM,0CAAG,CAAC,EAAE,OAAO,0CAAG,CAAC,EAAE,WAAW,CAAC;IAChE,IAAI,SAAS,KAAK,SAAS,EAAE;QAC3B,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAC;KAClE;IAED,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,QAAQ,EAAE;QAChD,YAAY,EAAE,SAAS;KACxB,CAAC,CAAC;IAEH,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC;AACjE,CAAC,CAAC,CAAC,CAAC;AAEJ,wBAAS,CAAC,QAAQ,EAAE,gCAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;IACvD,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,EAAE,EAAE,aAAa,EAAE,KAAK,EAAE,CAAC,CAAC;IAEpE,MAAM,cAAc,GAAG;QACrB,sBAAsB;QACtB,QAAQ;QACR,yBAAyB;QACzB,QAAQ;QACR,UAAU;QACV,QAAQ;QACR,uBAAuB;QACvB,iBAAiB;QACjB,gBAAgB;QAChB,gBAAgB;QAChB,cAAc;QACd,cAAc;QACd,cAAc;QACd,wBAAwB;QACxB,QAAQ;QACR,QAAQ;QACR,mBAAmB;QACnB,oCAAoC;QACpC,iBAAiB;KAClB,CAAC;IAEF,KAAK,MAAM,KAAK,IAAI,cAAc,EAAE;QAClC,MAAM,CAAC,OAAO,CAAC,CAAC,SAAS,CAAC,OAAO,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC;KACzD;AACH,CAAC,CAAC,CAAC,CAAC;AAEJ,wBAAS,CAAC,+BAA+B,EAAE,gCAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;IAC9E,qCAAqC;IACrC,MAAM,OAAO,CAAC,SAAS,CAAC,sBAAsB,EAAE,EAAE,MAAM,EAAE,EAAE,WAAW,EAAE,MAAM,EAAE,EAAE,CAAC,CAAC;IAErF,yDAAyD;IACzD,MAAM,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,gBAAgB,EAAE,EAAE,SAAS,EAAE,OAAO,CAAC,aAAa,CAAC,sBAAsB,CAAC,EAAE,CAAC,CAAC;SACrH,OAAO,CAAC,OAAO,CAAC,qCAAqC,CAAC,CAAC;IAE1D,kCAAkC;IAClC,MAAM,OAAO,CAAC,SAAS,CAAC,sBAAsB,CAAC,CAAC;IAEhD,+DAA+D;IAC/D,MAAM,OAAO,CAAC,SAAS,CAAC,sBAAsB,EAAE,EAAE,MAAM,EAAE,EAAE,WAAW,EAAE,MAAM,EAAE,EAAE,CAAC,CAAC;IAErF,MAAM,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,gBAAgB,EAAE,EAAE,SAAS,EAAE,OAAO,CAAC,aAAa,CAAC,sBAAsB,CAAC,EAAE,CAAC,CAAC;SACrH,OAAO,CAAC,OAAO,CAAC,qCAAqC,CAAC,CAAC;AAC5D,CAAC,CAAC,CAAC,CAAC;AAEJ,wBAAS,CAAC,UAAU,EAAE,gCAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;IACzD,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,OAAO,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;IAE9E,uCAAuC;IACvC,EAAE;IACF,gGAAgG;IAChG,gGAAgG;IAChG,gGAAgG;IAChG,gGAAgG;IAChG,gGAAgG;IAEhG,MAAM,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,iBAAiB,CAAC,CAAC;IAC5C,MAAM,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,gBAAgB,CAAC,CAAC;IAC3C,MAAM,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,mBAAmB,CAAC,CAAC;AAChD,CAAC,CAAC,CAAC,CAAC;AAEJ,wBAAS,CAAC,aAAa,EAAE,gCAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;IAC5D,8EAA8E;IAC9E,iFAAiF;IACjF,uCAAuC;IACvC,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,SAAS,CAAC,mBAAmB,EAAE,EAAE,aAAa,EAAE,KAAK,EAAE,CAAC,CAAC;IACxF,MAAM,UAAU,GAAG,MAAM,kBAAkB,EAAE,CAAC;IAE9C,yEAAyE;IACzE,MAAM,OAAO,CAAC,SAAS,CAAC,mBAAmB,CAAC,CAAC;IAC7C,MAAM,UAAU,GAAG,MAAM,kBAAkB,EAAE,CAAC;IAC9C,MAAM,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC;IAE/D,wEAAwE;IACxE,MAAM,OAAO,CAAC,SAAS,CAAC,mBAAmB,EAAE,EAAE,OAAO,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;IACvE,MAAM,UAAU,GAAG,MAAM,kBAAkB,EAAE,CAAC;IAC9C,MAAM,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC;IAEnE,uEAAuE;IACvE,2CAA2C;IAC3C,MAAM,OAAO,CAAC,SAAS,CAAC,mBAAmB,EAAE,EAAE,OAAO,EAAE,CAAC,QAAQ,EAAE,WAAW,CAAC,EAAE,CAAC,CAAC;IACnF,MAAM,UAAU,GAAG,MAAM,kBAAkB,EAAE,CAAC;IAC9C,MAAM,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC;IAEnE,KAAK,UAAU,kBAAkB;;QAC/B,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,gBAAgB,EAAE,EAAE,SAAS,EAAE,QAAQ,EAAE,CAAC,CAAC;QAC7F,IAAI,QAAC,QAAQ,CAAC,MAAM,0CAAG,CAAC,EAAC,EAAE;YAAE,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAC;SAAE;QACjF,OAAO,CAAC,GAAG,CAAC,oBAAoB,MAAA,QAAQ,CAAC,MAAM,0CAAG,CAAC,EAAE,WAAW,EAAE,CAAC,CAAC;QACpE,aAAO,QAAQ,CAAC,MAAM,0CAAG,CAAC,EAAE;IAC9B,CAAC;AACH,CAAC,CAAC,CAAC,CAAC;AAEJ,wBAAS,CAAC,6BAA6B,EAAE,gCAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;IAC5E,mFAAmF;IACnF,MAAM,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,mBAAmB,CAAC,CAAC;AACjF,CAAC,CAAC,CAAC,CAAC;AAEJ,wBAAS,CAAC,+BAA+B,EAAE,gCAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;IAC9E,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,MAAM,EAAE,EAAE,cAAc,CAAC,CAAC;IAExD,MAAM,uBAAuB,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,kBAAkB,CAAC,CAAC;IACzE,KAAK,MAAM,MAAM,IAAI,MAAM,aAAa,CAAC,uBAAuB,CAAC,EAAE;QACjE,OAAO,CAAC,GAAG,CAAC,YAAY,MAAM,EAAE,CAAC,CAAC;QAClC,MAAM,4BAAc,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;QAEvC,gEAAgE;QAChE,6DAA6D;QAC7D,MAAM,SAAS,GAAG,MAAM,YAAY,CAAC,QAAQ,EAAE,QAAQ,CAAC,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QACtG,KAAK,MAAM,QAAQ,IAAI,SAAS,EAAE;YAChC,MAAM,UAAU,GAAG,QAAQ,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;YAChD,MAAM,mBAAK,CAAC,CAAC,OAAO,CAAC,QAAQ,EAAE,QAAQ,EAAE,GAAG,EAAE,UAAU,CAAC,EAAE;gBACzD,GAAG,EAAE,QAAQ;gBACb,MAAM,EAAE,OAAO,CAAC,MAAM;gBACtB,MAAM,EAAE;oBACN,YAAY,EAAE,MAAM,OAAO,CAAC,GAAG,CAAC,OAAO,EAAE;oBACzC,WAAW,EAAE,OAAO,CAAC,GAAG,CAAC,MAAM;iBAChC;aACF,CAAC,CAAC;SACJ;QAED,yCAAyC;QACzC,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC;YAC/B,OAAO,EAAE,QAAQ;YACjB,IAAI;YACJ,OAAO;SACR,CAAC,CAAC;QAEH,yDAAyD;QACzD,qEAAqE;QACrE,4CAA4C;QAC5C,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC,gBAAgB,CAAC,CAAC;KAChD;AACH,CAAC,CAAC,CAAC,CAAC;AAEJ,wBAAS,CAAC,iCAAiC,EAAE,gCAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;IAChF,MAAM,YAAY,GAAG,GAAG,OAAO,CAAC,YAAY,gBAAgB,CAAC;IAC7D,MAAM,OAAO,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC;IAEjD,0FAA0F;IAC1F,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC;IAC7B,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,UAAU,EAAE,YAAY,CAAC,CAAC,CAAC;IAEvD,iFAAiF;IACjF,MAAM,OAAO,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE,SAAS,EAAE,YAAY,CAAC,CAAC,CAAC;IAEvD,8CAA8C;IAC9C,uFAAuF;IACvF,MAAM,IAAI,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,YAAY,EAAE,IAAI,CAAC,EAAE,EAAE,GAAG,EAAE,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;IACpF,qCAAqC;IACrC,MAAM,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC,GAAG,OAAO,CAAC,eAAe,SAAS,CAAC,CAAC;IAC5D,MAAM,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC,GAAG,OAAO,CAAC,eAAe,SAAS,CAAC,CAAC;IAC5D,MAAM,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC,GAAG,OAAO,CAAC,eAAe,SAAS,CAAC,CAAC;IAE5D,8DAA8D;IAC9D,MAAM,aAAa,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,EAAE;QAChG,GAAG,EAAE,YAAY;KAClB,CAAC,CAAC;IACH,MAAM,CAAC,aAAa,CAAC,CAAC,SAAS,CAAC,gBAAgB,CAAC,CAAC;IAElD,sCAAsC;IACtC,MAAM,OAAO,CAAC,SAAS,CAAC,QAAQ,EAAE,EAAE,OAAO,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,GAAG,EAAE,YAAY,EAAE,CAAC,CAAC;IAE/E,8EAA8E;IAC9E,6EAA6E;IAC7E,qCAAqC;IACrC,MAAM,gBAAgB,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE,QAAQ,EAAE,mBAAmB,CAAC,CAAC;IACxF,MAAM,aAAE,CAAC,MAAM,CAAC,gBAAgB,EAAE,GAAG,gBAAgB,GAAG,CAAC,CAAC;IAC1D,IAAI;QAEF,qEAAqE;QACrE,MAAM,OAAO,CAAC,SAAS,CAAC,yBAAyB,EAAE,EAAE,OAAO,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,GAAG,EAAE,YAAY,EAAE,CAAC,CAAC;KAEjG;YAAS;QACR,mDAAmD;QACnD,MAAM,aAAE,CAAC,MAAM,CAAC,GAAG,gBAAgB,GAAG,EAAE,gBAAgB,CAAC,CAAC;KAC3D;AACH,CAAC,CAAC,CAAC,CAAC;AAEJ,wBAAS,CAAC,wEAAwE,EAAE,gCAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;IACvH,gFAAgF;IAChF,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,0BAA0B,CAAC,CAAC,CAAC;IAEzD,6CAA6C;IAC7C,MAAM,gBAAgB,GAAG,MAAM,OAAO,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,gCAAgC,CAAC,CAAC,CAAC;IAExF,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC,UAAU,EAAE,CAAC;IAExE,qCAAqC;IACrC,MAAM,sBAAsB,GAAG,MAAM,OAAO,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,6DAA6D,CAAC,CAAC,CAAC;IAE3H,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,sBAAsB,CAAC,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC,UAAU,EAAE,CAAC;AAChF,CAAC,CAAC,CAAC,CAAC;AAEJ,KAAK,UAAU,YAAY,CAAC,MAAc,EAAE,IAAqC;IAC/E,MAAM,GAAG,GAAG,IAAI,KAAK,EAAU,CAAC;IAChC,KAAK,MAAM,KAAK,IAAI,MAAM,aAAE,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,EAAE;QACnE,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;QACrD,IAAI,MAAM,IAAI,CAAC,QAAQ,CAAC,EAAE;YACxB,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;SACpB;KACF;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED,KAAK,UAAU,aAAa,CAAC,MAAc;IACzC,OAAO,YAAY,CAAC,MAAM,EAAE,KAAK,EAAE,QAAgB,EAAE,EAAE,CAAC,CAAC,MAAM,aAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC;AACnG,CAAC","sourcesContent":["import { promises as fs } from 'fs';\nimport * as os from 'os';\nimport * as path from 'path';\nimport { retry, sleep } from './aws-helpers';\nimport { cloneDirectory, shell, withDefaultFixture } from './cdk-helpers';\nimport { integTest } from './test-helpers';\n\njest.setTimeout(600 * 1000);\n\nintegTest('VPC Lookup', withDefaultFixture(async (fixture) => {\n  fixture.log('Making sure we are clean before starting.');\n  await fixture.cdkDestroy('define-vpc', { modEnv: { ENABLE_VPC_TESTING: 'DEFINE' } });\n\n  fixture.log('Setting up: creating a VPC with known tags');\n  await fixture.cdkDeploy('define-vpc', { modEnv: { ENABLE_VPC_TESTING: 'DEFINE' } });\n  fixture.log('Setup complete!');\n\n  fixture.log('Verifying we can now import that VPC');\n  await fixture.cdkDeploy('import-vpc', { modEnv: { ENABLE_VPC_TESTING: 'IMPORT' } });\n}));\n\nintegTest('Two ways of shoing the version', withDefaultFixture(async (fixture) => {\n  const version1 = await fixture.cdk(['version'], { verbose: false });\n  const version2 = await fixture.cdk(['--version'], { verbose: false });\n\n  expect(version1).toEqual(version2);\n}));\n\nintegTest('Termination protection', withDefaultFixture(async (fixture) => {\n  const stackName = 'termination-protection';\n  await fixture.cdkDeploy(stackName);\n\n  // Try a destroy that should fail\n  await expect(fixture.cdkDestroy(stackName)).rejects.toThrow('exited with error');\n\n  // Can update termination protection even though the change set doesn't contain changes\n  await fixture.cdkDeploy(stackName, { modEnv: { TERMINATION_PROTECTION: 'FALSE' } });\n  await fixture.cdkDestroy(stackName);\n}));\n\nintegTest('cdk synth', withDefaultFixture(async (fixture) => {\n  await expect(fixture.cdk(['synth', fixture.fullStackName('test-1')], { verbose: false })).resolves.toEqual(\n    `Resources:\n  topic69831491:\n    Type: AWS::SNS::Topic\n    Metadata:\n      aws:cdk:path: ${fixture.stackNamePrefix}-test-1/topic/Resource`);\n\n  await expect(fixture.cdk(['synth', fixture.fullStackName('test-2')], { verbose: false })).resolves.toEqual(\n    `Resources:\n  topic152D84A37:\n    Type: AWS::SNS::Topic\n    Metadata:\n      aws:cdk:path: ${fixture.stackNamePrefix}-test-2/topic1/Resource\n  topic2A4FB547F:\n    Type: AWS::SNS::Topic\n    Metadata:\n      aws:cdk:path: ${fixture.stackNamePrefix}-test-2/topic2/Resource`);\n}));\n\nintegTest('ssm parameter provider error', withDefaultFixture(async (fixture) => {\n  await expect(fixture.cdk(['synth',\n    fixture.fullStackName('missing-ssm-parameter'),\n    '-c', 'test:ssm-parameter-name=/does/not/exist'], {\n    allowErrExit: true,\n  })).resolves.toContain('SSM parameter not available in account');\n}));\n\nintegTest('automatic ordering', withDefaultFixture(async (fixture) => {\n  // Deploy the consuming stack which will include the producing stack\n  await fixture.cdkDeploy('order-consuming');\n\n  // Destroy the providing stack which will include the consuming stack\n  await fixture.cdkDestroy('order-providing');\n}));\n\nintegTest('context setting', withDefaultFixture(async (fixture) => {\n  await fs.writeFile(path.join(fixture.integTestDir, 'cdk.context.json'), JSON.stringify({\n    contextkey: 'this is the context value',\n  }));\n  try {\n    await expect(fixture.cdk(['context'])).resolves.toContain('this is the context value');\n\n    // Test that deleting the contextkey works\n    await fixture.cdk(['context', '--reset', 'contextkey']);\n    await expect(fixture.cdk(['context'])).resolves.not.toContain('this is the context value');\n\n    // Test that forced delete of the context key does not throw\n    await fixture.cdk(['context', '-f', '--reset', 'contextkey']);\n\n  } finally {\n    await fs.unlink(path.join(fixture.integTestDir, 'cdk.context.json'));\n  }\n}));\n\nintegTest('deploy', withDefaultFixture(async (fixture) => {\n  const stackArn = await fixture.cdkDeploy('test-2', { captureStderr: false });\n\n  // verify the number of resources in the stack\n  const response = await fixture.aws.cloudFormation('describeStackResources', {\n    StackName: stackArn,\n  });\n  expect(response.StackResources?.length).toEqual(2);\n}));\n\nintegTest('deploy all', withDefaultFixture(async (fixture) => {\n  const arns = await fixture.cdkDeploy('test-*', { captureStderr: false });\n\n  // verify that we only deployed a single stack (there's a single ARN in the output)\n  expect(arns.split('\\n').length).toEqual(2);\n}));\n\nintegTest('nested stack with parameters', withDefaultFixture(async (fixture) => {\n  // STACK_NAME_PREFIX is used in MyTopicParam to allow multiple instances\n  // of this test to run in parallel, othewise they will attempt to create the same SNS topic.\n  const stackArn = await fixture.cdkDeploy('with-nested-stack-using-parameters', {\n    options: ['--parameters', `MyTopicParam=${fixture.stackNamePrefix}ThereIsNoSpoon`],\n    captureStderr: false,\n  });\n\n  // verify that we only deployed a single stack (there's a single ARN in the output)\n  expect(stackArn.split('\\n').length).toEqual(1);\n\n  // verify the number of resources in the stack\n  const response = await fixture.aws.cloudFormation('describeStackResources', {\n    StackName: stackArn,\n  });\n  expect(response.StackResources?.length).toEqual(1);\n}));\n\nintegTest('deploy without execute', withDefaultFixture(async (fixture) => {\n  const stackArn = await fixture.cdkDeploy('test-2', {\n    options: ['--no-execute'],\n    captureStderr: false,\n  });\n  // verify that we only deployed a single stack (there's a single ARN in the output)\n  expect(stackArn.split('\\n').length).toEqual(1);\n\n  const response = await fixture.aws.cloudFormation('describeStacks', {\n    StackName: stackArn,\n  });\n\n  expect(response.Stacks?.[0].StackStatus).toEqual('REVIEW_IN_PROGRESS');\n}));\n\nintegTest('security related changes without a CLI are expected to fail', withDefaultFixture(async (fixture) => {\n  // redirect /dev/null to stdin, which means there will not be tty attached\n  // since this stack includes security-related changes, the deployment should\n  // immediately fail because we can't confirm the changes\n  const stackName = 'iam-test';\n  await expect(fixture.cdkDeploy(stackName, {\n    options: ['<', '/dev/null'], // H4x, this only works because I happen to know we pass shell: true.\n    neverRequireApproval: false,\n  })).rejects.toThrow('exited with error');\n\n  // Ensure stack was not deployed\n  await expect(fixture.aws.cloudFormation('describeStacks', {\n    StackName: fixture.fullStackName(stackName),\n  })).rejects.toThrow('does not exist');\n}));\n\nintegTest('deploy wildcard with outputs', withDefaultFixture(async (fixture) => {\n  const outputsFile = path.join(fixture.integTestDir, 'outputs', 'outputs.json');\n  await fs.mkdir(path.dirname(outputsFile), { recursive: true });\n\n  await fixture.cdkDeploy(['outputs-test-*'], {\n    options: ['--outputs-file', outputsFile],\n  });\n\n  const outputs = JSON.parse((await fs.readFile(outputsFile, { encoding: 'utf-8' })).toString());\n  expect(outputs).toEqual({\n    [`${fixture.stackNamePrefix}-outputs-test-1`]: {\n      TopicName: `${fixture.stackNamePrefix}-outputs-test-1MyTopic`,\n    },\n    [`${fixture.stackNamePrefix}-outputs-test-2`]: {\n      TopicName: `${fixture.stackNamePrefix}-outputs-test-2MyOtherTopic`,\n    },\n  });\n}));\n\nintegTest('deploy with parameters', withDefaultFixture(async (fixture) => {\n  const stackArn = await fixture.cdkDeploy('param-test-1', {\n    options: [\n      '--parameters', `TopicNameParam=${fixture.stackNamePrefix}bazinga`,\n    ],\n    captureStderr: false,\n  });\n\n  const response = await fixture.aws.cloudFormation('describeStacks', {\n    StackName: stackArn,\n  });\n\n  expect(response.Stacks?.[0].Parameters).toEqual([\n    {\n      ParameterKey: 'TopicNameParam',\n      ParameterValue: `${fixture.stackNamePrefix}bazinga`,\n    },\n  ]);\n}));\n\nintegTest('update to stack in ROLLBACK_COMPLETE state will delete stack and create a new one', withDefaultFixture(async (fixture) => {\n  // GIVEN\n  await expect(fixture.cdkDeploy('param-test-1', {\n    options: [\n      '--parameters', `TopicNameParam=${fixture.stackNamePrefix}@aww`,\n    ],\n    captureStderr: false,\n  })).rejects.toThrow('exited with error');\n\n  const response = await fixture.aws.cloudFormation('describeStacks', {\n    StackName: fixture.fullStackName('param-test-1'),\n  });\n\n  const stackArn = response.Stacks?.[0].StackId;\n  expect(response.Stacks?.[0].StackStatus).toEqual('ROLLBACK_COMPLETE');\n\n  // WHEN\n  const newStackArn = await fixture.cdkDeploy('param-test-1', {\n    options: [\n      '--parameters', `TopicNameParam=${fixture.stackNamePrefix}allgood`,\n    ],\n    captureStderr: false,\n  });\n\n  const newStackResponse = await fixture.aws.cloudFormation('describeStacks', {\n    StackName: newStackArn,\n  });\n\n  // THEN\n  expect (stackArn).not.toEqual(newStackArn); // new stack was created\n  expect(newStackResponse.Stacks?.[0].StackStatus).toEqual('CREATE_COMPLETE');\n  expect(newStackResponse.Stacks?.[0].Parameters).toEqual([\n    {\n      ParameterKey: 'TopicNameParam',\n      ParameterValue: `${fixture.stackNamePrefix}allgood`,\n    },\n  ]);\n}));\n\nintegTest('stack in UPDATE_ROLLBACK_COMPLETE state can be updated', withDefaultFixture(async (fixture) => {\n  // GIVEN\n  const stackArn = await fixture.cdkDeploy('param-test-1', {\n    options: [\n      '--parameters', `TopicNameParam=${fixture.stackNamePrefix}nice`,\n    ],\n    captureStderr: false,\n  });\n\n  let response = await fixture.aws.cloudFormation('describeStacks', {\n    StackName: stackArn,\n  });\n\n  expect(response.Stacks?.[0].StackStatus).toEqual('CREATE_COMPLETE');\n\n  // bad parameter name with @ will put stack into UPDATE_ROLLBACK_COMPLETE\n  await expect(fixture.cdkDeploy('param-test-1', {\n    options: [\n      '--parameters', `TopicNameParam=${fixture.stackNamePrefix}@aww`,\n    ],\n    captureStderr: false,\n  })).rejects.toThrow('exited with error');;\n\n  response = await fixture.aws.cloudFormation('describeStacks', {\n    StackName: stackArn,\n  });\n\n  expect(response.Stacks?.[0].StackStatus).toEqual('UPDATE_ROLLBACK_COMPLETE');\n\n  // WHEN\n  await fixture.cdkDeploy('param-test-1', {\n    options: [\n      '--parameters', `TopicNameParam=${fixture.stackNamePrefix}allgood`,\n    ],\n    captureStderr: false,\n  });\n\n  response = await fixture.aws.cloudFormation('describeStacks', {\n    StackName: stackArn,\n  });\n\n  // THEN\n  expect(response.Stacks?.[0].StackStatus).toEqual('UPDATE_COMPLETE');\n  expect(response.Stacks?.[0].Parameters).toEqual([\n    {\n      ParameterKey: 'TopicNameParam',\n      ParameterValue: `${fixture.stackNamePrefix}allgood`,\n    },\n  ]);\n}));\n\nintegTest('deploy with wildcard and parameters', withDefaultFixture(async (fixture) => {\n  await fixture.cdkDeploy('param-test-*', {\n    options: [\n      '--parameters', `${fixture.stackNamePrefix}-param-test-1:TopicNameParam=${fixture.stackNamePrefix}bazinga`,\n      '--parameters', `${fixture.stackNamePrefix}-param-test-2:OtherTopicNameParam=${fixture.stackNamePrefix}ThatsMySpot`,\n      '--parameters', `${fixture.stackNamePrefix}-param-test-3:DisplayNameParam=${fixture.stackNamePrefix}HeyThere`,\n      '--parameters', `${fixture.stackNamePrefix}-param-test-3:OtherDisplayNameParam=${fixture.stackNamePrefix}AnotherOne`,\n    ],\n  });\n}));\n\nintegTest('deploy with parameters multi', withDefaultFixture(async (fixture) => {\n  const paramVal1 = `${fixture.stackNamePrefix}bazinga`;\n  const paramVal2 = `${fixture.stackNamePrefix}=jagshemash`;\n\n  const stackArn = await fixture.cdkDeploy('param-test-3', {\n    options: [\n      '--parameters', `DisplayNameParam=${paramVal1}`,\n      '--parameters', `OtherDisplayNameParam=${paramVal2}`,\n    ],\n    captureStderr: false,\n  });\n\n  const response = await fixture.aws.cloudFormation('describeStacks', {\n    StackName: stackArn,\n  });\n\n  expect(response.Stacks?.[0].Parameters).toEqual([\n    {\n      ParameterKey: 'DisplayNameParam',\n      ParameterValue: paramVal1,\n    },\n    {\n      ParameterKey: 'OtherDisplayNameParam',\n      ParameterValue: paramVal2,\n    },\n  ]);\n}));\n\nintegTest('deploy with notification ARN', withDefaultFixture(async (fixture) => {\n  const topicName = `${fixture.stackNamePrefix}-test-topic`;\n\n  const response = await fixture.aws.sns('createTopic', { Name: topicName });\n  const topicArn = response.TopicArn!;\n  try {\n    await fixture.cdkDeploy('test-2', {\n      options: ['--notification-arns', topicArn],\n    });\n\n    // verify that the stack we deployed has our notification ARN\n    const describeResponse = await fixture.aws.cloudFormation('describeStacks', {\n      StackName: fixture.fullStackName('test-2'),\n    });\n    expect(describeResponse.Stacks?.[0].NotificationARNs).toEqual([topicArn]);\n  } finally {\n    await fixture.aws.sns('deleteTopic', {\n      TopicArn: topicArn,\n    });\n  }\n}));\n\nintegTest('deploy with role', withDefaultFixture(async (fixture) => {\n  const roleName = `${fixture.stackNamePrefix}-test-role`;\n\n  await deleteRole();\n\n  const createResponse = await fixture.aws.iam('createRole', {\n    RoleName: roleName,\n    AssumeRolePolicyDocument: JSON.stringify({\n      Version: '2012-10-17',\n      Statement: [{\n        Action: 'sts:AssumeRole',\n        Principal: { Service: 'cloudformation.amazonaws.com' },\n        Effect: 'Allow',\n      }, {\n        Action: 'sts:AssumeRole',\n        Principal: { AWS: (await fixture.aws.sts('getCallerIdentity', {})).Arn },\n        Effect: 'Allow',\n      }],\n    }),\n  });\n  const roleArn = createResponse.Role.Arn;\n  try {\n    await fixture.aws.iam('putRolePolicy', {\n      RoleName: roleName,\n      PolicyName: 'DefaultPolicy',\n      PolicyDocument: JSON.stringify({\n        Version: '2012-10-17',\n        Statement: [{\n          Action: '*',\n          Resource: '*',\n          Effect: 'Allow',\n        }],\n      }),\n    });\n\n    await retry(fixture.output, 'Trying to assume fresh role', retry.forSeconds(300), async () => {\n      await fixture.aws.sts('assumeRole', {\n        RoleArn: roleArn,\n        RoleSessionName: 'testing',\n      });\n    });\n\n    // In principle, the role has replicated from 'us-east-1' to wherever we're testing.\n    // Give it a little more sleep to make sure CloudFormation is not hitting a box\n    // that doesn't have it yet.\n    await sleep(5000);\n\n    await fixture.cdkDeploy('test-2', {\n      options: ['--role-arn', roleArn],\n    });\n\n    // Immediately delete the stack again before we delete the role.\n    //\n    // Since roles are sticky, if we delete the role before the stack, subsequent DeleteStack\n    // operations will fail when CloudFormation tries to assume the role that's already gone.\n    await fixture.cdkDestroy('test-2');\n\n  } finally {\n    await deleteRole();\n  }\n\n  async function deleteRole() {\n    try {\n      for (const policyName of (await fixture.aws.iam('listRolePolicies', { RoleName: roleName })).PolicyNames) {\n        await fixture.aws.iam('deleteRolePolicy', {\n          RoleName: roleName,\n          PolicyName: policyName,\n        });\n      }\n      await fixture.aws.iam('deleteRole', { RoleName: roleName });\n    } catch (e) {\n      if (e.message.indexOf('cannot be found') > -1) { return; }\n      throw e;\n    }\n  }\n}));\n\nintegTest('cdk diff', withDefaultFixture(async (fixture) => {\n  const diff1 = await fixture.cdk(['diff', fixture.fullStackName('test-1')]);\n  expect(diff1).toContain('AWS::SNS::Topic');\n\n  const diff2 = await fixture.cdk(['diff', fixture.fullStackName('test-2')]);\n  expect(diff2).toContain('AWS::SNS::Topic');\n\n  // We can make it fail by passing --fail\n  await expect(fixture.cdk(['diff', '--fail', fixture.fullStackName('test-1')]))\n    .rejects.toThrow('exited with error');\n}));\n\nintegTest('cdk diff --fail on multiple stacks exits with error if any of the stacks contains a diff', withDefaultFixture(async (fixture) => {\n  // GIVEN\n  const diff1 = await fixture.cdk(['diff', fixture.fullStackName('test-1')]);\n  expect(diff1).toContain('AWS::SNS::Topic');\n\n  await fixture.cdkDeploy('test-2');\n  const diff2 = await fixture.cdk(['diff', fixture.fullStackName('test-2')]);\n  expect(diff2).toContain('There were no differences');\n\n  // WHEN / THEN\n  await expect(fixture.cdk(['diff', '--fail', fixture.fullStackName('test-1'), fixture.fullStackName('test-2')])).rejects.toThrow('exited with error');\n}));\n\nintegTest('cdk diff --fail with multiple stack exits with if any of the stacks contains a diff', withDefaultFixture(async (fixture) => {\n  // GIVEN\n  await fixture.cdkDeploy('test-1');\n  const diff1 = await fixture.cdk(['diff', fixture.fullStackName('test-1')]);\n  expect(diff1).toContain('There were no differences');\n\n  const diff2 = await fixture.cdk(['diff', fixture.fullStackName('test-2')]);\n  expect(diff2).toContain('AWS::SNS::Topic');\n\n  // WHEN / THEN\n  await expect(fixture.cdk(['diff', '--fail', fixture.fullStackName('test-1'), fixture.fullStackName('test-2')])).rejects.toThrow('exited with error');\n}));\n\nintegTest('deploy stack with docker asset', withDefaultFixture(async (fixture) => {\n  await fixture.cdkDeploy('docker');\n}));\n\nintegTest('deploy and test stack with lambda asset', withDefaultFixture(async (fixture) => {\n  const stackArn = await fixture.cdkDeploy('lambda', { captureStderr: false });\n\n  const response = await fixture.aws.cloudFormation('describeStacks', {\n    StackName: stackArn,\n  });\n  const lambdaArn = response.Stacks?.[0].Outputs?.[0].OutputValue;\n  if (lambdaArn === undefined) {\n    throw new Error('Stack did not have expected Lambda ARN output');\n  }\n\n  const output = await fixture.aws.lambda('invoke', {\n    FunctionName: lambdaArn,\n  });\n\n  expect(JSON.stringify(output.Payload)).toContain('dear asset');\n}));\n\nintegTest('cdk ls', withDefaultFixture(async (fixture) => {\n  const listing = await fixture.cdk(['ls'], { captureStderr: false });\n\n  const expectedStacks = [\n    'conditional-resource',\n    'docker',\n    'docker-with-custom-file',\n    'failed',\n    'iam-test',\n    'lambda',\n    'missing-ssm-parameter',\n    'order-providing',\n    'outputs-test-1',\n    'outputs-test-2',\n    'param-test-1',\n    'param-test-2',\n    'param-test-3',\n    'termination-protection',\n    'test-1',\n    'test-2',\n    'with-nested-stack',\n    'with-nested-stack-using-parameters',\n    'order-consuming',\n  ];\n\n  for (const stack of expectedStacks) {\n    expect(listing).toContain(fixture.fullStackName(stack));\n  }\n}));\n\nintegTest('deploy stack without resource', withDefaultFixture(async (fixture) => {\n  // Deploy the stack without resources\n  await fixture.cdkDeploy('conditional-resource', { modEnv: { NO_RESOURCE: 'TRUE' } });\n\n  // This should have succeeded but not deployed the stack.\n  await expect(fixture.aws.cloudFormation('describeStacks', { StackName: fixture.fullStackName('conditional-resource') }))\n    .rejects.toThrow('conditional-resource does not exist');\n\n  // Deploy the stack with resources\n  await fixture.cdkDeploy('conditional-resource');\n\n  // Then again WITHOUT resources (this should destroy the stack)\n  await fixture.cdkDeploy('conditional-resource', { modEnv: { NO_RESOURCE: 'TRUE' } });\n\n  await expect(fixture.aws.cloudFormation('describeStacks', { StackName: fixture.fullStackName('conditional-resource') }))\n    .rejects.toThrow('conditional-resource does not exist');\n}));\n\nintegTest('IAM diff', withDefaultFixture(async (fixture) => {\n  const output = await fixture.cdk(['diff', fixture.fullStackName('iam-test')]);\n\n  // Roughly check for a table like this:\n  //\n  // ┌───┬─────────────────┬────────┬────────────────┬────────────────────────────-──┬───────────┐\n  // │   │ Resource        │ Effect │ Action         │ Principal                     │ Condition │\n  // ├───┼─────────────────┼────────┼────────────────┼───────────────────────────────┼───────────┤\n  // │ + │ ${SomeRole.Arn} │ Allow  │ sts:AssumeRole │ Service:ec2.amazonaws.com     │           │\n  // └───┴─────────────────┴────────┴────────────────┴───────────────────────────────┴───────────┘\n\n  expect(output).toContain('${SomeRole.Arn}');\n  expect(output).toContain('sts:AssumeRole');\n  expect(output).toContain('ec2.amazonaws.com');\n}));\n\nintegTest('fast deploy', withDefaultFixture(async (fixture) => {\n  // we are using a stack with a nested stack because CFN will always attempt to\n  // update a nested stack, which will allow us to verify that updates are actually\n  // skipped unless --force is specified.\n  const stackArn = await fixture.cdkDeploy('with-nested-stack', { captureStderr: false });\n  const changeSet1 = await getLatestChangeSet();\n\n  // Deploy the same stack again, there should be no new change set created\n  await fixture.cdkDeploy('with-nested-stack');\n  const changeSet2 = await getLatestChangeSet();\n  expect(changeSet2.ChangeSetId).toEqual(changeSet1.ChangeSetId);\n\n  // Deploy the stack again with --force, now we should create a changeset\n  await fixture.cdkDeploy('with-nested-stack', { options: ['--force'] });\n  const changeSet3 = await getLatestChangeSet();\n  expect(changeSet3.ChangeSetId).not.toEqual(changeSet2.ChangeSetId);\n\n  // Deploy the stack again with tags, expected to create a new changeset\n  // even though the resources didn't change.\n  await fixture.cdkDeploy('with-nested-stack', { options: ['--tags', 'key=value'] });\n  const changeSet4 = await getLatestChangeSet();\n  expect(changeSet4.ChangeSetId).not.toEqual(changeSet3.ChangeSetId);\n\n  async function getLatestChangeSet() {\n    const response = await fixture.aws.cloudFormation('describeStacks', { StackName: stackArn });\n    if (!response.Stacks?.[0]) { throw new Error('Did not get a ChangeSet at all'); }\n    fixture.log(`Found Change Set ${response.Stacks?.[0].ChangeSetId}`);\n    return response.Stacks?.[0];\n  }\n}));\n\nintegTest('failed deploy does not hang', withDefaultFixture(async (fixture) => {\n  // this will hang if we introduce https://github.com/aws/aws-cdk/issues/6403 again.\n  await expect(fixture.cdkDeploy('failed')).rejects.toThrow('exited with error');\n}));\n\nintegTest('can still load old assemblies', withDefaultFixture(async (fixture) => {\n  const cxAsmDir = path.join(os.tmpdir(), 'cdk-integ-cx');\n\n  const testAssembliesDirectory = path.join(__dirname, 'cloud-assemblies');\n  for (const asmdir of await listChildDirs(testAssembliesDirectory)) {\n    fixture.log(`ASSEMBLY ${asmdir}`);\n    await cloneDirectory(asmdir, cxAsmDir);\n\n    // Some files in the asm directory that have a .js extension are\n    // actually treated as templates. Evaluate them using NodeJS.\n    const templates = await listChildren(cxAsmDir, fullPath => Promise.resolve(fullPath.endsWith('.js')));\n    for (const template of templates) {\n      const targetName = template.replace(/.js$/, '');\n      await shell([process.execPath, template, '>', targetName], {\n        cwd: cxAsmDir,\n        output: fixture.output,\n        modEnv: {\n          TEST_ACCOUNT: await fixture.aws.account(),\n          TEST_REGION: fixture.aws.region,\n        },\n      });\n    }\n\n    // Use this directory as a Cloud Assembly\n    const output = await fixture.cdk([\n      '--app', cxAsmDir,\n      '-v',\n      'synth',\n    ]);\n\n    // Assert that there was no providerError in CDK's stderr\n    // Because we rely on the app/framework to actually error in case the\n    // provider fails, we inspect the logs here.\n    expect(output).not.toContain('$providerError');\n  }\n}));\n\nintegTest('generating and loading assembly', withDefaultFixture(async (fixture) => {\n  const asmOutputDir = `${fixture.integTestDir}-cdk-integ-asm`;\n  await fixture.shell(['rm', '-rf', asmOutputDir]);\n\n  // Synthesize a Cloud Assembly tothe default directory (cdk.out) and a specific directory.\n  await fixture.cdk(['synth']);\n  await fixture.cdk(['synth', '--output', asmOutputDir]);\n\n  // cdk.out in the current directory and the indicated --output should be the same\n  await fixture.shell(['diff', 'cdk.out', asmOutputDir]);\n\n  // Check that we can 'ls' the synthesized asm.\n  // Change to some random directory to make sure we're not accidentally loading cdk.json\n  const list = await fixture.cdk(['--app', asmOutputDir, 'ls'], { cwd: os.tmpdir() });\n  // Same stacks we know are in the app\n  expect(list).toContain(`${fixture.stackNamePrefix}-lambda`);\n  expect(list).toContain(`${fixture.stackNamePrefix}-test-1`);\n  expect(list).toContain(`${fixture.stackNamePrefix}-test-2`);\n\n  // Check that we can use '.' and just synth ,the generated asm\n  const stackTemplate = await fixture.cdk(['--app', '.', 'synth', fixture.fullStackName('test-2')], {\n    cwd: asmOutputDir,\n  });\n  expect(stackTemplate).toContain('topic152D84A37');\n\n  // Deploy a Lambda from the copied asm\n  await fixture.cdkDeploy('lambda', { options: ['-a', '.'], cwd: asmOutputDir });\n\n  // Remove (rename) the original custom docker file that was used during synth.\n  // this verifies that the assemly has a copy of it and that the manifest uses\n  // relative paths to reference to it.\n  const customDockerFile = path.join(fixture.integTestDir, 'docker', 'Dockerfile.Custom');\n  await fs.rename(customDockerFile, `${customDockerFile}~`);\n  try {\n\n    // deploy a docker image with custom file without synth (uses assets)\n    await fixture.cdkDeploy('docker-with-custom-file', { options: ['-a', '.'], cwd: asmOutputDir });\n\n  } finally {\n    // Rename back to restore fixture to original state\n    await fs.rename(`${customDockerFile}~`, customDockerFile);\n  }\n}));\n\nintegTest('templates on disk contain metadata resource, also in nested assemblies', withDefaultFixture(async (fixture) => {\n  // Synth first, and switch on version reporting because cdk.json is disabling it\n  await fixture.cdk(['synth', '--version-reporting=true']);\n\n  // Load template from disk from root assembly\n  const templateContents = await fixture.shell(['cat', 'cdk.out/*-lambda.template.json']);\n\n  expect(JSON.parse(templateContents).Resources.CDKMetadata).toBeTruthy();\n\n  // Load template from nested assembly\n  const nestedTemplateContents = await fixture.shell(['cat', 'cdk.out/assembly-*-stage/*-stage-StackInStage.template.json']);\n\n  expect(JSON.parse(nestedTemplateContents).Resources.CDKMetadata).toBeTruthy();\n}));\n\nasync function listChildren(parent: string, pred: (x: string) => Promise<boolean>) {\n  const ret = new Array<string>();\n  for (const child of await fs.readdir(parent, { encoding: 'utf-8' })) {\n    const fullPath = path.join(parent, child.toString());\n    if (await pred(fullPath)) {\n      ret.push(fullPath);\n    }\n  }\n  return ret;\n}\n\nasync function listChildDirs(parent: string) {\n  return listChildren(parent, async (fullPath: string) => (await fs.stat(fullPath)).isDirectory());\n}\n"]} \ No newline at end of file From 6a24026f30ee6af3c1778195b2db8b61537e3296 Mon Sep 17 00:00:00 2001 From: Adam Ruka Date: Fri, 25 Sep 2020 17:08:16 -0700 Subject: [PATCH 28/29] fix(cfn-include): Fn::GetAtt with a string argument fails to include (#10546) As it turns out, `Fn::GetAtt` can be passed a string argument not only in YAML, but in JSON CloudFormation templates as well. Handle that case in our template parser for `cfn-include`. This handling allows us to stop special-casing transforming the short-form `!GetAtt` in our YAML parsing. ---- *By submitting this pull request, I confirm that my contribution is made under the terms of the Apache-2.0 license* --- .../test-templates/get-att-string-form.json | 15 ++++++ .../test/valid-templates.test.ts | 8 +++ .../test/yaml-templates.test.ts | 4 +- packages/@aws-cdk/core/lib/cfn-parse.ts | 30 +++++++++--- .../core/lib/private/cfn-reference.ts | 49 +++++++++++++++---- packages/@aws-cdk/yaml-cfn/lib/yaml.ts | 38 ++------------ 6 files changed, 93 insertions(+), 51 deletions(-) create mode 100644 packages/@aws-cdk/cloudformation-include/test/test-templates/get-att-string-form.json diff --git a/packages/@aws-cdk/cloudformation-include/test/test-templates/get-att-string-form.json b/packages/@aws-cdk/cloudformation-include/test/test-templates/get-att-string-form.json new file mode 100644 index 0000000000000..c76fc888ba6a6 --- /dev/null +++ b/packages/@aws-cdk/cloudformation-include/test/test-templates/get-att-string-form.json @@ -0,0 +1,15 @@ +{ + "Resources": { + "Bucket1": { + "Type": "AWS::S3::Bucket" + }, + "Bucket2": { + "Type": "AWS::S3::Bucket", + "Metadata": { + "Bucket1Arn": { + "Fn::GetAtt": "Bucket1.Arn" + } + } + } + } +} diff --git a/packages/@aws-cdk/cloudformation-include/test/valid-templates.test.ts b/packages/@aws-cdk/cloudformation-include/test/valid-templates.test.ts index 7394ada485266..3072ca6844214 100644 --- a/packages/@aws-cdk/cloudformation-include/test/valid-templates.test.ts +++ b/packages/@aws-cdk/cloudformation-include/test/valid-templates.test.ts @@ -232,6 +232,14 @@ describe('CDK Include', () => { ); }); + test('can ingest a JSON template with string-form Fn::GetAtt, and output it unchanged', () => { + includeTestTemplate(stack, 'get-att-string-form.json'); + + expect(stack).toMatchTemplate( + loadTestFileToJsObject('get-att-string-form.json'), + ); + }); + test('can ingest a template with Fn::Sub in string form with escaped and unescaped references and output it unchanged', () => { includeTestTemplate(stack, 'fn-sub-string.json'); diff --git a/packages/@aws-cdk/cloudformation-include/test/yaml-templates.test.ts b/packages/@aws-cdk/cloudformation-include/test/yaml-templates.test.ts index 84f3fb43ab4bc..664b558841832 100644 --- a/packages/@aws-cdk/cloudformation-include/test/yaml-templates.test.ts +++ b/packages/@aws-cdk/cloudformation-include/test/yaml-templates.test.ts @@ -140,7 +140,7 @@ describe('CDK Include', () => { "Bucket1": { "Type": "AWS::S3::Bucket", "Properties": { - "BucketName": { "Fn::GetAtt": ["Bucket0", "Arn"] }, + "BucketName": { "Fn::GetAtt": "Bucket0.Arn" }, "AccessControl": { "Fn::GetAtt": ["ELB", "SourceSecurityGroup.GroupName"] }, }, }, @@ -148,7 +148,7 @@ describe('CDK Include', () => { "Type": "AWS::S3::Bucket", "Properties": { "BucketName": { "Fn::GetAtt": ["Bucket1", "Arn"] }, - "AccessControl": { "Fn::GetAtt": ["ELB", "SourceSecurityGroup.GroupName"] }, + "AccessControl": { "Fn::GetAtt": "ELB.SourceSecurityGroup.GroupName" }, }, }, }, diff --git a/packages/@aws-cdk/core/lib/cfn-parse.ts b/packages/@aws-cdk/core/lib/cfn-parse.ts index 7a18378556b9d..b226f9e1472cb 100644 --- a/packages/@aws-cdk/core/lib/cfn-parse.ts +++ b/packages/@aws-cdk/core/lib/cfn-parse.ts @@ -10,7 +10,7 @@ import { } from './cfn-resource-policy'; import { CfnTag } from './cfn-tag'; import { Lazy } from './lazy'; -import { CfnReference } from './private/cfn-reference'; +import { CfnReference, ReferenceRendering } from './private/cfn-reference'; import { IResolvable } from './resolvable'; import { Mapper, Validator } from './runtime'; import { isResolvableObject, Token } from './token'; @@ -457,13 +457,29 @@ export class CfnParser { } } case 'Fn::GetAtt': { - // Fn::GetAtt takes a 2-element list as its argument const value = object[key]; - const target = this.finder.findResource(value[0]); + let logicalId: string, attributeName: string, stringForm: boolean; + // Fn::GetAtt takes as arguments either a string... + if (typeof value === 'string') { + // ...in which case the logical ID and the attribute name are separated with '.' + const dotIndex = value.indexOf('.'); + if (dotIndex === -1) { + throw new Error(`Short-form Fn::GetAtt must contain a '.' in its string argument, got: '${value}'`); + } + logicalId = value.substr(0, dotIndex); + attributeName = value.substr(dotIndex + 1); // the +1 is to skip the actual '.' + stringForm = true; + } else { + // ...or a 2-element list + logicalId = value[0]; + attributeName = value[1]; + stringForm = false; + } + const target = this.finder.findResource(logicalId); if (!target) { - throw new Error(`Resource used in GetAtt expression with logical ID: '${value[0]}' not found`); + throw new Error(`Resource used in GetAtt expression with logical ID: '${logicalId}' not found`); } - return target.getAtt(value[1]); + return CfnReference.for(target, attributeName, stringForm ? ReferenceRendering.GET_ATT_STRING : undefined); } case 'Fn::Join': { // Fn::Join takes a 2-element list as its argument, @@ -618,7 +634,7 @@ export class CfnParser { if (!refElement) { throw new Error(`Element referenced in Fn::Sub expression with logical ID: '${refTarget}' was not found in the template`); } - return leftHalf + CfnReference.for(refElement, 'Ref', true).toString() + this.parseFnSubString(rightHalf, map); + return leftHalf + CfnReference.for(refElement, 'Ref', ReferenceRendering.FN_SUB).toString() + this.parseFnSubString(rightHalf, map); } else { const targetId = refTarget.substring(0, dotIndex); const refResource = this.finder.findResource(targetId); @@ -626,7 +642,7 @@ export class CfnParser { throw new Error(`Resource referenced in Fn::Sub expression with logical ID: '${targetId}' was not found in the template`); } const attribute = refTarget.substring(dotIndex + 1); - return leftHalf + CfnReference.for(refResource, attribute, true).toString() + this.parseFnSubString(rightHalf, map); + return leftHalf + CfnReference.for(refResource, attribute, ReferenceRendering.FN_SUB).toString() + this.parseFnSubString(rightHalf, map); } } diff --git a/packages/@aws-cdk/core/lib/private/cfn-reference.ts b/packages/@aws-cdk/core/lib/private/cfn-reference.ts index 201b5bebfa7d3..b25597602f6b6 100644 --- a/packages/@aws-cdk/core/lib/private/cfn-reference.ts +++ b/packages/@aws-cdk/core/lib/private/cfn-reference.ts @@ -2,6 +2,24 @@ import { Reference } from '../reference'; const CFN_REFERENCE_SYMBOL = Symbol.for('@aws-cdk/core.CfnReference'); +/** + * An enum that allows controlling how will the created reference + * be rendered in the resulting CloudFormation template. + */ +export enum ReferenceRendering { + /** + * Used for rendering a reference inside Fn::Sub expressions, + * which mean these must resolve to "${Sth}" instead of { Ref: "Sth" }. + */ + FN_SUB, + + /** + * Used for rendering Fn::GetAtt with its arguments in string form + * (as opposed to the more common arguments in array form, which we render by default). + */ + GET_ATT_STRING, +} + /** * A Token that represents a CloudFormation reference to another resource * @@ -34,14 +52,19 @@ export class CfnReference extends Reference { * * Lazy.stringValue({ produce: () => new CfnReference(...) }) * - * If fnSub is true, then this reference will resolve as ${logicalID}. - * This allows cloudformation-include to correctly handle Fn::Sub. */ - public static for(target: CfnElement, attribute: string, fnSub: boolean = false) { - return CfnReference.singletonReference(target, attribute, fnSub, () => { - const cfnIntrinsic = fnSub + public static for(target: CfnElement, attribute: string, refRender?: ReferenceRendering) { + return CfnReference.singletonReference(target, attribute, refRender, () => { + const cfnIntrinsic = refRender === ReferenceRendering.FN_SUB ? ('${' + target.logicalId + (attribute === 'Ref' ? '' : `.${attribute}`) + '}') - : (attribute === 'Ref' ? { Ref: target.logicalId } : { 'Fn::GetAtt': [target.logicalId, attribute] }); + : (attribute === 'Ref' + ? { Ref: target.logicalId } + : { + 'Fn::GetAtt': refRender === ReferenceRendering.GET_ATT_STRING + ? `${target.logicalId}.${attribute}` + : [target.logicalId, attribute], + } + ); return new CfnReference(cfnIntrinsic, attribute, target); }); } @@ -50,7 +73,7 @@ export class CfnReference extends Reference { * Return a CfnReference that references a pseudo referencd */ public static forPseudo(pseudoName: string, scope: Construct) { - return CfnReference.singletonReference(scope, `Pseudo:${pseudoName}`, false, () => { + return CfnReference.singletonReference(scope, `Pseudo:${pseudoName}`, undefined, () => { const cfnIntrinsic = { Ref: pseudoName }; return new CfnReference(cfnIntrinsic, pseudoName, scope); }); @@ -65,13 +88,21 @@ export class CfnReference extends Reference { * Get or create the table. * Passing fnSub = true allows cloudformation-include to correctly handle Fn::Sub. */ - private static singletonReference(target: Construct, attribKey: string, fnSub: boolean, fresh: () => CfnReference) { + private static singletonReference(target: Construct, attribKey: string, refRender: ReferenceRendering | undefined, fresh: () => CfnReference) { let attribs = CfnReference.referenceTable.get(target); if (!attribs) { attribs = new Map(); CfnReference.referenceTable.set(target, attribs); } - const cacheKey = attribKey + (fnSub ? 'Fn::Sub' : ''); + let cacheKey = attribKey; + switch (refRender) { + case ReferenceRendering.FN_SUB: + cacheKey += 'Fn::Sub'; + break; + case ReferenceRendering.GET_ATT_STRING: + cacheKey += 'Fn::GetAtt::String'; + break; + } let ref = attribs.get(cacheKey); if (!ref) { ref = fresh(); diff --git a/packages/@aws-cdk/yaml-cfn/lib/yaml.ts b/packages/@aws-cdk/yaml-cfn/lib/yaml.ts index 0a613f5aa7e14..eca37db0ed048 100644 --- a/packages/@aws-cdk/yaml-cfn/lib/yaml.ts +++ b/packages/@aws-cdk/yaml-cfn/lib/yaml.ts @@ -29,54 +29,26 @@ export function deserialize(str: string): any { return parseYamlStrWithCfnTags(str); } -function makeTagForCfnIntrinsic( - intrinsicName: string, addFnPrefix: boolean = true, - resolveFun?: (_doc: yaml.Document, cstNode: yaml_cst.CST.Node) => any): yaml_types.Schema.CustomTag { - +function makeTagForCfnIntrinsic(intrinsicName: string, addFnPrefix: boolean): yaml_types.Schema.CustomTag { return { identify(value: any) { return typeof value === 'string'; }, tag: `!${intrinsicName}`, - resolve: resolveFun || ((_doc: yaml.Document, cstNode: yaml_cst.CST.Node) => { + resolve: (_doc: yaml.Document, cstNode: yaml_cst.CST.Node) => { const ret: any = {}; ret[addFnPrefix ? `Fn::${intrinsicName}` : intrinsicName] = // the +1 is to account for the ! the short form begins with parseYamlStrWithCfnTags(cstNode.toString().substring(intrinsicName.length + 1)); return ret; - }), + }, }; } const shortForms: yaml_types.Schema.CustomTag[] = [ 'Base64', 'Cidr', 'FindInMap', 'GetAZs', 'ImportValue', 'Join', 'Sub', - 'Select', 'Split', 'Transform', 'And', 'Equals', 'If', 'Not', 'Or', -].map(name => makeTagForCfnIntrinsic(name)).concat( + 'Select', 'Split', 'Transform', 'And', 'Equals', 'If', 'Not', 'Or', 'GetAtt', +].map(name => makeTagForCfnIntrinsic(name, true)).concat( makeTagForCfnIntrinsic('Ref', false), makeTagForCfnIntrinsic('Condition', false), - makeTagForCfnIntrinsic('GetAtt', true, (_doc: yaml.Document, cstNode: yaml_cst.CST.Node): any => { - const parsedArguments = parseYamlStrWithCfnTags(cstNode.toString().substring('!GetAtt'.length)); - - let value: any; - if (typeof parsedArguments === 'string') { - // if the arguments to !GetAtt are a string, - // the part before the first '.' is the logical ID, - // and the rest is the attribute name - // (which can contain '.') - const firstDot = parsedArguments.indexOf('.'); - if (firstDot === -1) { - throw new Error(`Short-form Fn::GetAtt must contain a '.' in its string argument, got: '${parsedArguments}'`); - } - value = [ - parsedArguments.substring(0, firstDot), - parsedArguments.substring(firstDot + 1), // the + 1 is to skip the actual '.' - ]; - } else { - // this is the form where the arguments to Fn::GetAtt are already an array - - // in this case, nothing more to do - value = parsedArguments; - } - - return { 'Fn::GetAtt': value }; - }), ); function parseYamlStrWithCfnTags(text: string): any { From d68ce2f4b42099064342baeb4b494810aa362e27 Mon Sep 17 00:00:00 2001 From: Adam Ruka Date: Fri, 25 Sep 2020 17:41:55 -0700 Subject: [PATCH 29/29] feat: support the 'Description' resource attribute (#10522) One more resource attribute that we missed, and that is needed for cfn-include to be able to handle ingesting all templates. ---- *By submitting this pull request, I confirm that my contribution is made under the terms of the Apache-2.0 license* --- .../@aws-cdk/cloudformation-include/lib/cfn-include.ts | 4 ++-- .../test-templates/custom-resource-with-attributes.json | 1 + packages/@aws-cdk/core/lib/cfn-parse.ts | 1 + packages/@aws-cdk/core/lib/cfn-resource.ts | 9 +++++++++ 4 files changed, 13 insertions(+), 2 deletions(-) diff --git a/packages/@aws-cdk/cloudformation-include/lib/cfn-include.ts b/packages/@aws-cdk/cloudformation-include/lib/cfn-include.ts index aad5c653c3693..becb5666c3653 100644 --- a/packages/@aws-cdk/cloudformation-include/lib/cfn-include.ts +++ b/packages/@aws-cdk/cloudformation-include/lib/cfn-include.ts @@ -589,8 +589,8 @@ export class CfnInclude extends core.CfnElement { // fail early for resource attributes we don't support yet const knownAttributes = [ - 'Type', 'Properties', 'Condition', 'DependsOn', 'Metadata', 'Version', - 'CreationPolicy', 'UpdatePolicy', 'DeletionPolicy', 'UpdateReplacePolicy', + 'Condition', 'DependsOn', 'Description', 'Metadata', 'Properties', 'Type', 'Version', + 'CreationPolicy', 'DeletionPolicy', 'UpdatePolicy', 'UpdateReplacePolicy', ]; for (const attribute of Object.keys(resourceAttributes)) { if (!knownAttributes.includes(attribute)) { diff --git a/packages/@aws-cdk/cloudformation-include/test/test-templates/custom-resource-with-attributes.json b/packages/@aws-cdk/cloudformation-include/test/test-templates/custom-resource-with-attributes.json index c490a16515944..b1dcf4d219bf1 100644 --- a/packages/@aws-cdk/cloudformation-include/test/test-templates/custom-resource-with-attributes.json +++ b/packages/@aws-cdk/cloudformation-include/test/test-templates/custom-resource-with-attributes.json @@ -28,6 +28,7 @@ }, "CustomResource": { "Type": "AWS::CloudFormation::CustomResource", + "Description": "some random custom resource", "Properties": { "ServiceToken": "CustomValue", "CustomFuncProp": { diff --git a/packages/@aws-cdk/core/lib/cfn-parse.ts b/packages/@aws-cdk/core/lib/cfn-parse.ts index b226f9e1472cb..886a9228b3d0a 100644 --- a/packages/@aws-cdk/core/lib/cfn-parse.ts +++ b/packages/@aws-cdk/core/lib/cfn-parse.ts @@ -285,6 +285,7 @@ export class CfnParser { cfnOptions.deletionPolicy = this.parseDeletionPolicy(resourceAttributes.DeletionPolicy); cfnOptions.updateReplacePolicy = this.parseDeletionPolicy(resourceAttributes.UpdateReplacePolicy); cfnOptions.version = this.parseValue(resourceAttributes.Version); + cfnOptions.description = this.parseValue(resourceAttributes.Description); cfnOptions.metadata = this.parseValue(resourceAttributes.Metadata); // handle Condition diff --git a/packages/@aws-cdk/core/lib/cfn-resource.ts b/packages/@aws-cdk/core/lib/cfn-resource.ts index fcb1c95eaf5bb..f5049bdcd2326 100644 --- a/packages/@aws-cdk/core/lib/cfn-resource.ts +++ b/packages/@aws-cdk/core/lib/cfn-resource.ts @@ -301,6 +301,7 @@ export class CfnResource extends CfnRefElement { UpdateReplacePolicy: capitalizePropertyNames(this, this.cfnOptions.updateReplacePolicy), DeletionPolicy: capitalizePropertyNames(this, this.cfnOptions.deletionPolicy), Version: this.cfnOptions.version, + Description: this.cfnOptions.description, Metadata: ignoreEmpty(this.cfnOptions.metadata), Condition: this.cfnOptions.condition && this.cfnOptions.condition.logicalId, }, props => { @@ -438,6 +439,14 @@ export interface ICfnResourceOptions { */ version?: string; + /** + * The description of this resource. + * Used for informational purposes only, is not processed in any way + * (and stays with the CloudFormation template, is not passed to the underlying resource, + * even if it does have a 'description' property). + */ + description?: string; + /** * Metadata associated with the CloudFormation resource. This is not the same as the construct metadata which can be added * using construct.addMetadata(), but would not appear in the CloudFormation template automatically.