diff --git a/packages/@aws-cdk/custom-resources/README.md b/packages/@aws-cdk/custom-resources/README.md index e74c5cf97481b..ca0537308b10b 100644 --- a/packages/@aws-cdk/custom-resources/README.md +++ b/packages/@aws-cdk/custom-resources/README.md @@ -502,6 +502,10 @@ const awsCustom = new cr.AwsCustomResource(this, 'aws-custom', { }) ``` +You can omit `PhysicalResourceId` property in `onUpdate` to passthrough the value in `onCreate`. This behavior is useful when using Update APIs that response with an empty body. + +> AwsCustomResource.getResponseField() and .getResponseFieldReference() will not work if the Create and Update APIs don't consistently return the same fields. + ### Handling Custom Resource Errors Every error produced by the API call is treated as is and will cause a "FAILED" response to be submitted to CloudFormation. diff --git a/packages/@aws-cdk/custom-resources/lib/aws-custom-resource/aws-custom-resource.ts b/packages/@aws-cdk/custom-resources/lib/aws-custom-resource/aws-custom-resource.ts index 25b0ecb59fc82..4f323576ca461 100644 --- a/packages/@aws-cdk/custom-resources/lib/aws-custom-resource/aws-custom-resource.ts +++ b/packages/@aws-cdk/custom-resources/lib/aws-custom-resource/aws-custom-resource.ts @@ -86,7 +86,8 @@ export interface AwsSdkCall { /** * The physical resource id of the custom resource for this call. - * Mandatory for onCreate or onUpdate calls. + * Mandatory for onCreate call. + * In onUpdate, you can omit this to passthrough it from request. * * @default - no physical resource id */ @@ -384,10 +385,12 @@ export class AwsCustomResource extends Construct implements iam.IGrantable { throw new Error('At least one of `policy` or `role` (or both) must be specified.'); } - for (const call of [props.onCreate, props.onUpdate]) { - if (call && !call.physicalResourceId) { - throw new Error('`physicalResourceId` must be specified for onCreate and onUpdate calls.'); - } + if (props.onCreate && !props.onCreate.physicalResourceId) { + throw new Error("'physicalResourceId' must be specified for 'onCreate' call."); + } + + if (!props.onCreate && props.onUpdate && !props.onUpdate.physicalResourceId) { + throw new Error("'physicalResourceId' must be specified for 'onUpdate' call when 'onCreate' is omitted."); } for (const call of [props.onCreate, props.onUpdate, props.onDelete]) { diff --git a/packages/@aws-cdk/custom-resources/test/aws-custom-resource/aws-custom-resource.test.ts b/packages/@aws-cdk/custom-resources/test/aws-custom-resource/aws-custom-resource.test.ts index 700b707629abd..4abe91ce97038 100644 --- a/packages/@aws-cdk/custom-resources/test/aws-custom-resource/aws-custom-resource.test.ts +++ b/packages/@aws-cdk/custom-resources/test/aws-custom-resource/aws-custom-resource.test.ts @@ -171,20 +171,312 @@ test('fails when no calls are specified', () => { })).toThrow(/`onCreate`.+`onUpdate`.+`onDelete`/); }); -test('fails when no physical resource method is specified', () => { - const stack = new cdk.Stack(); +// test patterns for physicalResourceId +// | # | onCreate.physicalResourceId | onUpdate.physicalResourceId | Error thrown? | +// |---|-----------------------------------|----------------------------------|---------------| +// | 1 | ANY_VALUE | ANY_VALUE | no | +// | 2 | ANY_VALUE | undefined | no | +// | 3 | undefined | ANY_VALLUE | yes | +// | 4 | undefined | undefined | yes | +// | 5 | ANY_VALUE | undefined (*omit whole onUpdate) | no | +// | 6 | undefined | undefined (*omit whole onUpdate) | yes | +// | 7 | ANY_VALUE (*copied from onUpdate) | ANY_VALUE | no | +// | 8 | undefined (*copied from onUpdate) | undefined | yes | +describe('physicalResourceId patterns', () => { + // physicalResourceId pattern #1 + test('physicalResourceId is specified both in onCreate and onUpdate then success', () => { + // GIVEN + const stack = new cdk.Stack(); + + // WHEN + new AwsCustomResource(stack, 'AwsSdk', { + resourceType: 'Custom::AthenaNotebook', + onCreate: { + service: 'Athena', + action: 'createNotebook', + physicalResourceId: PhysicalResourceId.of('id'), + parameters: { + WorkGroup: 'WorkGroupA', + Name: 'Notebook1', + }, + }, + onUpdate: { + service: 'Athena', + action: 'updateNotebookMetadata', + physicalResourceId: PhysicalResourceId.of('id'), + parameters: { + Name: 'Notebook1', + NotebookId: new PhysicalResourceIdReference(), + }, + }, + policy: AwsCustomResourcePolicy.fromSdkCalls({ resources: AwsCustomResourcePolicy.ANY_RESOURCE }), + }); - expect(() => new AwsCustomResource(stack, 'AwsSdk', { - onUpdate: { - service: 'CloudWatchLogs', - action: 'putRetentionPolicy', - parameters: { - logGroupName: '/aws/lambda/loggroup', - retentionInDays: 90, + // THEN + Template.fromStack(stack).hasResourceProperties('Custom::AthenaNotebook', { + Create: JSON.stringify({ + service: 'Athena', + action: 'createNotebook', + physicalResourceId: { + id: 'id', + }, + parameters: { + WorkGroup: 'WorkGroupA', + Name: 'Notebook1', + }, + }), + Update: JSON.stringify({ + service: 'Athena', + action: 'updateNotebookMetadata', + physicalResourceId: { + id: 'id', + }, + parameters: { + Name: 'Notebook1', + NotebookId: 'PHYSICAL:RESOURCEID:', + }, + }), + }); + }); + + // physicalResourceId pattern #2 + test('physicalResourceId is specified in onCreate, is not in onUpdate then absent', () => { + // GIVEN + const stack = new cdk.Stack(); + + // WHEN + new AwsCustomResource(stack, 'AwsSdk', { + resourceType: 'Custom::AthenaNotebook', + onCreate: { + service: 'Athena', + action: 'createNotebook', + physicalResourceId: PhysicalResourceId.fromResponse('NotebookId'), + parameters: { + WorkGroup: 'WorkGroupA', + Name: 'Notebook1', + }, }, - }, - policy: AwsCustomResourcePolicy.fromSdkCalls({ resources: AwsCustomResourcePolicy.ANY_RESOURCE }), - })).toThrow(/`physicalResourceId`/); + onUpdate: { + service: 'Athena', + action: 'updateNotebookMetadata', + parameters: { + Name: 'Notebook1', + NotebookId: new PhysicalResourceIdReference(), + }, + }, + policy: AwsCustomResourcePolicy.fromSdkCalls({ resources: AwsCustomResourcePolicy.ANY_RESOURCE }), + }); + + // THEN + Template.fromStack(stack).hasResourceProperties('Custom::AthenaNotebook', { + Create: JSON.stringify({ + service: 'Athena', + action: 'createNotebook', + physicalResourceId: { + responsePath: 'NotebookId', + }, + parameters: { + WorkGroup: 'WorkGroupA', + Name: 'Notebook1', + }, + }), + Update: JSON.stringify({ + service: 'Athena', + action: 'updateNotebookMetadata', + parameters: { + Name: 'Notebook1', + NotebookId: 'PHYSICAL:RESOURCEID:', + }, + }), + }); + }); + + // physicalResourceId pattern #3 + test('physicalResourceId is not specified in onCreate but onUpdate then fail', () => { + // GIVEN + const stack = new cdk.Stack(); + + // WHEN + expect(() => { + new AwsCustomResource(stack, 'AwsSdk', { + resourceType: 'Custom::AthenaNotebook', + onCreate: { + service: 'Athena', + action: 'createNotebook', + parameters: { + WorkGroup: 'WorkGroupA', + Name: 'Notebook1', + }, + }, + onUpdate: { + service: 'Athena', + action: 'updateNotebookMetadata', + physicalResourceId: PhysicalResourceId.of('id'), + parameters: { + Name: 'Notebook1', + NotebookId: new PhysicalResourceIdReference(), + }, + }, + policy: AwsCustomResourcePolicy.fromSdkCalls({ resources: AwsCustomResourcePolicy.ANY_RESOURCE }), + }); + }).toThrow(/'physicalResourceId' must be specified for 'onCreate' call./); + }); + + // physicalResourceId pattern #4 + test('physicalResourceId is not specified both in onCreate and onUpdate then fail', () => { + // GIVEN + const stack = new cdk.Stack(); + + // WHEN + expect(() => { + new AwsCustomResource(stack, 'AwsSdk', { + resourceType: 'Custom::AthenaNotebook', + onCreate: { + service: 'Athena', + action: 'createNotebook', + parameters: { + WorkGroup: 'WorkGroupA', + Name: 'Notebook1', + }, + }, + onUpdate: { + service: 'Athena', + action: 'updateNotebookMetadata', + parameters: { + Name: 'Notebook1', + NotebookId: new PhysicalResourceIdReference(), + }, + }, + policy: AwsCustomResourcePolicy.fromSdkCalls({ resources: AwsCustomResourcePolicy.ANY_RESOURCE }), + }); + }).toThrow(/'physicalResourceId' must be specified for 'onCreate' call./); + }); + + // physicalResourceId pattern #5 + test('physicalResourceId is specified in onCreate with empty onUpdate then success', () => { + // GIVEN + const stack = new cdk.Stack(); + + // WHEN + new AwsCustomResource(stack, 'AwsSdk', { + resourceType: 'Custom::AthenaNotebook', + onCreate: { + service: 'Athena', + action: 'createNotebook', + physicalResourceId: PhysicalResourceId.of('id'), + parameters: { + WorkGroup: 'WorkGroupA', + Name: 'Notebook1', + }, + }, + policy: AwsCustomResourcePolicy.fromSdkCalls({ resources: AwsCustomResourcePolicy.ANY_RESOURCE }), + }); + + // THEN + Template.fromStack(stack).hasResourceProperties('Custom::AthenaNotebook', { + Create: JSON.stringify({ + service: 'Athena', + action: 'createNotebook', + physicalResourceId: { + id: 'id', + }, + parameters: { + WorkGroup: 'WorkGroupA', + Name: 'Notebook1', + }, + }), + }); + }); + + // physicalResourceId pattern #6 + test('physicalResourceId is not specified onCreate with empty onUpdate then fail', () => { + // GIVEN + const stack = new cdk.Stack(); + + // WHEN + expect(() => { + new AwsCustomResource(stack, 'AwsSdk', { + resourceType: 'Custom::AthenaNotebook', + onCreate: { + service: 'Athena', + action: 'createNotebook', + parameters: { + WorkGroup: 'WorkGroupA', + Name: 'Notebook1', + }, + }, + policy: AwsCustomResourcePolicy.fromSdkCalls({ resources: AwsCustomResourcePolicy.ANY_RESOURCE }), + }); + }).toThrow(/'physicalResourceId' must be specified for 'onCreate' call./); + }); + + // physicalResourceId pattern #7 + test('onCreate and onUpdate both have physicalResourceId when physicalResourceId is specified in onUpdate, even when onCreate is unspecified', () => { + // GIVEN + const stack = new cdk.Stack(); + + // WHEN + new AwsCustomResource(stack, 'AwsSdk', { + resourceType: 'Custom::AthenaNotebook', + onUpdate: { + service: 'Athena', + action: 'updateNotebookMetadata', + physicalResourceId: PhysicalResourceId.of('id'), + parameters: { + Name: 'Notebook1', + NotebookId: 'XXXX', + }, + }, + policy: AwsCustomResourcePolicy.fromSdkCalls({ resources: AwsCustomResourcePolicy.ANY_RESOURCE }), + }); + + Template.fromStack(stack).hasResourceProperties('Custom::AthenaNotebook', { + Create: JSON.stringify({ + service: 'Athena', + action: 'updateNotebookMetadata', + physicalResourceId: { + id: 'id', + }, + parameters: { + Name: 'Notebook1', + NotebookId: 'XXXX', + }, + }), + Update: JSON.stringify({ + service: 'Athena', + action: 'updateNotebookMetadata', + physicalResourceId: { + id: 'id', + }, + parameters: { + Name: 'Notebook1', + NotebookId: 'XXXX', + }, + }), + }); + }); + + // physicalResourceId pattern #8 + test('Omitting physicalResourceId in onCreate when onUpdate is undefined throws an error', () => { + // GIVEN + const stack = new cdk.Stack(); + + // WHEN + expect(() => { + new AwsCustomResource(stack, 'AwsSdk', { + resourceType: 'Custom::AthenaNotebook', + onUpdate: { + service: 'Athena', + action: 'updateNotebookMetadata', + parameters: { + Name: 'Notebook1', + NotebookId: 'XXXX', + }, + }, + policy: AwsCustomResourcePolicy.fromSdkCalls({ resources: AwsCustomResourcePolicy.ANY_RESOURCE }), + }); + }).toThrow(/'physicalResourceId' must be specified for 'onUpdate' call when 'onCreate' is omitted./); + }); }); test('booleans are encoded in the stringified parameters object', () => { diff --git a/packages/@aws-cdk/custom-resources/test/aws-custom-resource/integ.aws-custom-resource-athena.js.snapshot/CustomResourceAthenaDefaultTestDeployAssert7AE6A475.assets.json b/packages/@aws-cdk/custom-resources/test/aws-custom-resource/integ.aws-custom-resource-athena.js.snapshot/CustomResourceAthenaDefaultTestDeployAssert7AE6A475.assets.json new file mode 100644 index 0000000000000..ec45f4a6df8c2 --- /dev/null +++ b/packages/@aws-cdk/custom-resources/test/aws-custom-resource/integ.aws-custom-resource-athena.js.snapshot/CustomResourceAthenaDefaultTestDeployAssert7AE6A475.assets.json @@ -0,0 +1,19 @@ +{ + "version": "29.0.0", + "files": { + "21fbb51d7b23f6a6c262b46a9caee79d744a3ac019fd45422d988b96d44b2a22": { + "source": { + "path": "CustomResourceAthenaDefaultTestDeployAssert7AE6A475.template.json", + "packaging": "file" + }, + "destinations": { + "current_account-current_region": { + "bucketName": "cdk-hnb659fds-assets-${AWS::AccountId}-${AWS::Region}", + "objectKey": "21fbb51d7b23f6a6c262b46a9caee79d744a3ac019fd45422d988b96d44b2a22.json", + "assumeRoleArn": "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-hnb659fds-file-publishing-role-${AWS::AccountId}-${AWS::Region}" + } + } + } + }, + "dockerImages": {} +} \ No newline at end of file diff --git a/packages/@aws-cdk/custom-resources/test/aws-custom-resource/integ.aws-custom-resource-athena.js.snapshot/CustomResourceAthenaDefaultTestDeployAssert7AE6A475.template.json b/packages/@aws-cdk/custom-resources/test/aws-custom-resource/integ.aws-custom-resource-athena.js.snapshot/CustomResourceAthenaDefaultTestDeployAssert7AE6A475.template.json new file mode 100644 index 0000000000000..ad9d0fb73d1dd --- /dev/null +++ b/packages/@aws-cdk/custom-resources/test/aws-custom-resource/integ.aws-custom-resource-athena.js.snapshot/CustomResourceAthenaDefaultTestDeployAssert7AE6A475.template.json @@ -0,0 +1,36 @@ +{ + "Parameters": { + "BootstrapVersion": { + "Type": "AWS::SSM::Parameter::Value", + "Default": "/cdk-bootstrap/hnb659fds/version", + "Description": "Version of the CDK Bootstrap resources in this environment, automatically retrieved from SSM Parameter Store. [cdk:skip]" + } + }, + "Rules": { + "CheckBootstrapVersion": { + "Assertions": [ + { + "Assert": { + "Fn::Not": [ + { + "Fn::Contains": [ + [ + "1", + "2", + "3", + "4", + "5" + ], + { + "Ref": "BootstrapVersion" + } + ] + } + ] + }, + "AssertDescription": "CDK bootstrap stack version 6 required. Please run 'cdk bootstrap' with a recent version of the CDK CLI." + } + ] + } + } +} \ No newline at end of file diff --git a/packages/@aws-cdk/custom-resources/test/aws-custom-resource/integ.aws-custom-resource-athena.js.snapshot/asset.a268caa53756f51bda8ad5f499be4ed8484a81b314811806fbb66f874837c476/index.js b/packages/@aws-cdk/custom-resources/test/aws-custom-resource/integ.aws-custom-resource-athena.js.snapshot/asset.a268caa53756f51bda8ad5f499be4ed8484a81b314811806fbb66f874837c476/index.js new file mode 100644 index 0000000000000..d913ab9defaa1 --- /dev/null +++ b/packages/@aws-cdk/custom-resources/test/aws-custom-resource/integ.aws-custom-resource-athena.js.snapshot/asset.a268caa53756f51bda8ad5f499be4ed8484a81b314811806fbb66f874837c476/index.js @@ -0,0 +1,253 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.handler = exports.forceSdkInstallation = exports.flatten = exports.PHYSICAL_RESOURCE_ID_REFERENCE = void 0; +/* eslint-disable no-console */ +const child_process_1 = require("child_process"); +const fs = require("fs"); +const path_1 = require("path"); +/** + * Serialized form of the physical resource id for use in the operation parameters + */ +exports.PHYSICAL_RESOURCE_ID_REFERENCE = 'PHYSICAL:RESOURCEID:'; +/** + * Flattens a nested object + * + * @param object the object to be flattened + * @returns a flat object with path as keys + */ +function flatten(object) { + return Object.assign({}, ...function _flatten(child, path = []) { + return [].concat(...Object.keys(child) + .map(key => { + const childKey = Buffer.isBuffer(child[key]) ? child[key].toString('utf8') : child[key]; + return typeof childKey === 'object' && childKey !== null + ? _flatten(childKey, path.concat([key])) + : ({ [path.concat([key]).join('.')]: childKey }); + })); + }(object)); +} +exports.flatten = flatten; +/** + * Decodes encoded special values (physicalResourceId) + */ +function decodeSpecialValues(object, physicalResourceId) { + return JSON.parse(JSON.stringify(object), (_k, v) => { + switch (v) { + case exports.PHYSICAL_RESOURCE_ID_REFERENCE: + return physicalResourceId; + default: + return v; + } + }); +} +/** + * Filters the keys of an object. + */ +function filterKeys(object, pred) { + return Object.entries(object) + .reduce((acc, [k, v]) => pred(k) + ? { ...acc, [k]: v } + : acc, {}); +} +let latestSdkInstalled = false; +function forceSdkInstallation() { + latestSdkInstalled = false; +} +exports.forceSdkInstallation = forceSdkInstallation; +/** + * Installs latest AWS SDK v2 + */ +function installLatestSdk() { + console.log('Installing latest AWS SDK v2'); + // Both HOME and --prefix are needed here because /tmp is the only writable location + child_process_1.execSync('HOME=/tmp npm install aws-sdk@2 --production --no-package-lock --no-save --prefix /tmp'); + latestSdkInstalled = true; +} +// no currently patched services +const patchedServices = []; +/** + * Patches the AWS SDK by loading service models in the same manner as the actual SDK + */ +function patchSdk(awsSdk) { + const apiLoader = awsSdk.apiLoader; + patchedServices.forEach(({ serviceName, apiVersions }) => { + const lowerServiceName = serviceName.toLowerCase(); + if (!awsSdk.Service.hasService(lowerServiceName)) { + apiLoader.services[lowerServiceName] = {}; + awsSdk[serviceName] = awsSdk.Service.defineService(lowerServiceName, apiVersions); + } + else { + awsSdk.Service.addVersions(awsSdk[serviceName], apiVersions); + } + apiVersions.forEach(apiVersion => { + Object.defineProperty(apiLoader.services[lowerServiceName], apiVersion, { + get: function get() { + const modelFilePrefix = `aws-sdk-patch/${lowerServiceName}-${apiVersion}`; + const model = JSON.parse(fs.readFileSync(path_1.join(__dirname, `${modelFilePrefix}.service.json`), 'utf-8')); + model.paginators = JSON.parse(fs.readFileSync(path_1.join(__dirname, `${modelFilePrefix}.paginators.json`), 'utf-8')).pagination; + return model; + }, + enumerable: true, + configurable: true, + }); + }); + }); + return awsSdk; +} +/* eslint-disable @typescript-eslint/no-require-imports, import/no-extraneous-dependencies */ +async function handler(event, context) { + try { + let AWS; + if (!latestSdkInstalled && event.ResourceProperties.InstallLatestAwsSdk === 'true') { + try { + installLatestSdk(); + AWS = require('/tmp/node_modules/aws-sdk'); + } + catch (e) { + console.log(`Failed to install latest AWS SDK v2: ${e}`); + AWS = require('aws-sdk'); // Fallback to pre-installed version + } + } + else if (latestSdkInstalled) { + AWS = require('/tmp/node_modules/aws-sdk'); + } + else { + AWS = require('aws-sdk'); + } + try { + AWS = patchSdk(AWS); + } + catch (e) { + console.log(`Failed to patch AWS SDK: ${e}. Proceeding with the installed copy.`); + } + console.log(JSON.stringify({ ...event, ResponseURL: '...' })); + console.log('AWS SDK VERSION: ' + AWS.VERSION); + event.ResourceProperties.Create = decodeCall(event.ResourceProperties.Create); + event.ResourceProperties.Update = decodeCall(event.ResourceProperties.Update); + event.ResourceProperties.Delete = decodeCall(event.ResourceProperties.Delete); + // Default physical resource id + let physicalResourceId; + switch (event.RequestType) { + case 'Create': + physicalResourceId = event.ResourceProperties.Create?.physicalResourceId?.id ?? + event.ResourceProperties.Update?.physicalResourceId?.id ?? + event.ResourceProperties.Delete?.physicalResourceId?.id ?? + event.LogicalResourceId; + break; + case 'Update': + case 'Delete': + physicalResourceId = event.ResourceProperties[event.RequestType]?.physicalResourceId?.id ?? event.PhysicalResourceId; + break; + } + let flatData = {}; + let data = {}; + const call = event.ResourceProperties[event.RequestType]; + if (call) { + let credentials; + if (call.assumedRoleArn) { + const timestamp = (new Date()).getTime(); + const params = { + RoleArn: call.assumedRoleArn, + RoleSessionName: `${timestamp}-${physicalResourceId}`.substring(0, 64), + }; + credentials = new AWS.ChainableTemporaryCredentials({ + params: params, + stsConfig: { stsRegionalEndpoints: 'regional' }, + }); + } + if (!Object.prototype.hasOwnProperty.call(AWS, call.service)) { + throw Error(`Service ${call.service} does not exist in AWS SDK version ${AWS.VERSION}.`); + } + const awsService = new AWS[call.service]({ + apiVersion: call.apiVersion, + credentials: credentials, + region: call.region, + }); + try { + const response = await awsService[call.action](call.parameters && decodeSpecialValues(call.parameters, physicalResourceId)).promise(); + flatData = { + apiVersion: awsService.config.apiVersion, + region: awsService.config.region, + ...flatten(response), + }; + let outputPaths; + if (call.outputPath) { + outputPaths = [call.outputPath]; + } + else if (call.outputPaths) { + outputPaths = call.outputPaths; + } + if (outputPaths) { + data = filterKeys(flatData, startsWithOneOf(outputPaths)); + } + else { + data = flatData; + } + } + catch (e) { + if (!call.ignoreErrorCodesMatching || !new RegExp(call.ignoreErrorCodesMatching).test(e.code)) { + throw e; + } + } + if (call.physicalResourceId?.responsePath) { + physicalResourceId = flatData[call.physicalResourceId.responsePath]; + } + } + await respond('SUCCESS', 'OK', physicalResourceId, data); + } + catch (e) { + console.log(e); + await respond('FAILED', e.message || 'Internal Error', context.logStreamName, {}); + } + function respond(responseStatus, reason, physicalResourceId, data) { + const responseBody = JSON.stringify({ + Status: responseStatus, + Reason: reason, + PhysicalResourceId: physicalResourceId, + StackId: event.StackId, + RequestId: event.RequestId, + LogicalResourceId: event.LogicalResourceId, + NoEcho: false, + Data: data, + }); + console.log('Responding', responseBody); + // eslint-disable-next-line @typescript-eslint/no-require-imports + const parsedUrl = require('url').parse(event.ResponseURL); + const requestOptions = { + hostname: parsedUrl.hostname, + path: parsedUrl.path, + method: 'PUT', + headers: { 'content-type': '', 'content-length': responseBody.length }, + }; + return new Promise((resolve, reject) => { + try { + // eslint-disable-next-line @typescript-eslint/no-require-imports + const request = require('https').request(requestOptions, resolve); + request.on('error', reject); + request.write(responseBody); + request.end(); + } + catch (e) { + reject(e); + } + }); + } +} +exports.handler = handler; +function decodeCall(call) { + if (!call) { + return undefined; + } + return JSON.parse(call); +} +function startsWithOneOf(searchStrings) { + return function (string) { + for (const searchString of searchStrings) { + if (string.startsWith(searchString)) { + return true; + } + } + return false; + }; +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable no-console */\nimport { execSync } from 'child_process';\nimport * as fs from 'fs';\nimport { join } from 'path';\n// import the AWSLambda package explicitly,\n// which is globally available in the Lambda runtime,\n// as otherwise linking this repository with link-all.sh\n// fails in the CDK app executed with ts-node\n/* eslint-disable-next-line import/no-extraneous-dependencies,import/no-unresolved */\nimport * as AWSLambda from 'aws-lambda';\nimport { AwsSdkCall } from '../aws-custom-resource';\n\n/**\n * Serialized form of the physical resource id for use in the operation parameters\n */\nexport const PHYSICAL_RESOURCE_ID_REFERENCE = 'PHYSICAL:RESOURCEID:';\n\n/**\n * Flattens a nested object\n *\n * @param object the object to be flattened\n * @returns a flat object with path as keys\n */\nexport function flatten(object: object): { [key: string]: any } {\n  return Object.assign(\n    {},\n    ...function _flatten(child: any, path: string[] = []): any {\n      return [].concat(...Object.keys(child)\n        .map(key => {\n          const childKey = Buffer.isBuffer(child[key]) ? child[key].toString('utf8') : child[key];\n          return typeof childKey === 'object' && childKey !== null\n            ? _flatten(childKey, path.concat([key]))\n            : ({ [path.concat([key]).join('.')]: childKey });\n        }));\n    }(object),\n  );\n}\n\n/**\n * Decodes encoded special values (physicalResourceId)\n */\nfunction decodeSpecialValues(object: object, physicalResourceId: string) {\n  return JSON.parse(JSON.stringify(object), (_k, v) => {\n    switch (v) {\n      case PHYSICAL_RESOURCE_ID_REFERENCE:\n        return physicalResourceId;\n      default:\n        return v;\n    }\n  });\n}\n\n/**\n * Filters the keys of an object.\n */\nfunction filterKeys(object: object, pred: (key: string) => boolean) {\n  return Object.entries(object)\n    .reduce(\n      (acc, [k, v]) => pred(k)\n        ? { ...acc, [k]: v }\n        : acc,\n      {},\n    );\n}\n\nlet latestSdkInstalled = false;\n\nexport function forceSdkInstallation() {\n  latestSdkInstalled = false;\n}\n\n/**\n * Installs latest AWS SDK v2\n */\nfunction installLatestSdk(): void {\n  console.log('Installing latest AWS SDK v2');\n  // Both HOME and --prefix are needed here because /tmp is the only writable location\n  execSync('HOME=/tmp npm install aws-sdk@2 --production --no-package-lock --no-save --prefix /tmp');\n  latestSdkInstalled = true;\n}\n\n// no currently patched services\nconst patchedServices: { serviceName: string; apiVersions: string[] }[] = [];\n/**\n * Patches the AWS SDK by loading service models in the same manner as the actual SDK\n */\nfunction patchSdk(awsSdk: any): any {\n  const apiLoader = awsSdk.apiLoader;\n  patchedServices.forEach(({ serviceName, apiVersions }) => {\n    const lowerServiceName = serviceName.toLowerCase();\n    if (!awsSdk.Service.hasService(lowerServiceName)) {\n      apiLoader.services[lowerServiceName] = {};\n      awsSdk[serviceName] = awsSdk.Service.defineService(lowerServiceName, apiVersions);\n    } else {\n      awsSdk.Service.addVersions(awsSdk[serviceName], apiVersions);\n    }\n    apiVersions.forEach(apiVersion => {\n      Object.defineProperty(apiLoader.services[lowerServiceName], apiVersion, {\n        get: function get() {\n          const modelFilePrefix = `aws-sdk-patch/${lowerServiceName}-${apiVersion}`;\n          const model = JSON.parse(fs.readFileSync(join(__dirname, `${modelFilePrefix}.service.json`), 'utf-8'));\n          model.paginators = JSON.parse(fs.readFileSync(join(__dirname, `${modelFilePrefix}.paginators.json`), 'utf-8')).pagination;\n          return model;\n        },\n        enumerable: true,\n        configurable: true,\n      });\n    });\n  });\n  return awsSdk;\n}\n\n/* eslint-disable @typescript-eslint/no-require-imports, import/no-extraneous-dependencies */\nexport async function handler(event: AWSLambda.CloudFormationCustomResourceEvent, context: AWSLambda.Context) {\n  try {\n    let AWS: any;\n    if (!latestSdkInstalled && event.ResourceProperties.InstallLatestAwsSdk === 'true') {\n      try {\n        installLatestSdk();\n        AWS = require('/tmp/node_modules/aws-sdk');\n      } catch (e) {\n        console.log(`Failed to install latest AWS SDK v2: ${e}`);\n        AWS = require('aws-sdk'); // Fallback to pre-installed version\n      }\n    } else if (latestSdkInstalled) {\n      AWS = require('/tmp/node_modules/aws-sdk');\n    } else {\n      AWS = require('aws-sdk');\n    }\n    try {\n      AWS = patchSdk(AWS);\n    } catch (e) {\n      console.log(`Failed to patch AWS SDK: ${e}. Proceeding with the installed copy.`);\n    }\n\n    console.log(JSON.stringify({ ...event, ResponseURL: '...' }));\n    console.log('AWS SDK VERSION: ' + AWS.VERSION);\n\n    event.ResourceProperties.Create = decodeCall(event.ResourceProperties.Create);\n    event.ResourceProperties.Update = decodeCall(event.ResourceProperties.Update);\n    event.ResourceProperties.Delete = decodeCall(event.ResourceProperties.Delete);\n    // Default physical resource id\n    let physicalResourceId: string;\n    switch (event.RequestType) {\n      case 'Create':\n        physicalResourceId = event.ResourceProperties.Create?.physicalResourceId?.id ??\n                             event.ResourceProperties.Update?.physicalResourceId?.id ??\n                             event.ResourceProperties.Delete?.physicalResourceId?.id ??\n                             event.LogicalResourceId;\n        break;\n      case 'Update':\n      case 'Delete':\n        physicalResourceId = event.ResourceProperties[event.RequestType]?.physicalResourceId?.id ?? event.PhysicalResourceId;\n        break;\n    }\n\n    let flatData: { [key: string]: string } = {};\n    let data: { [key: string]: string } = {};\n    const call: AwsSdkCall | undefined = event.ResourceProperties[event.RequestType];\n\n    if (call) {\n\n      let credentials;\n      if (call.assumedRoleArn) {\n        const timestamp = (new Date()).getTime();\n\n        const params = {\n          RoleArn: call.assumedRoleArn,\n          RoleSessionName: `${timestamp}-${physicalResourceId}`.substring(0, 64),\n        };\n\n        credentials = new AWS.ChainableTemporaryCredentials({\n          params: params,\n          stsConfig: { stsRegionalEndpoints: 'regional' },\n        });\n      }\n\n      if (!Object.prototype.hasOwnProperty.call(AWS, call.service)) {\n        throw Error(`Service ${call.service} does not exist in AWS SDK version ${AWS.VERSION}.`);\n      }\n      const awsService = new (AWS as any)[call.service]({\n        apiVersion: call.apiVersion,\n        credentials: credentials,\n        region: call.region,\n      });\n\n      try {\n        const response = await awsService[call.action](\n          call.parameters && decodeSpecialValues(call.parameters, physicalResourceId)).promise();\n        flatData = {\n          apiVersion: awsService.config.apiVersion, // For test purposes: check if apiVersion was correctly passed.\n          region: awsService.config.region, // For test purposes: check if region was correctly passed.\n          ...flatten(response),\n        };\n\n        let outputPaths: string[] | undefined;\n        if (call.outputPath) {\n          outputPaths = [call.outputPath];\n        } else if (call.outputPaths) {\n          outputPaths = call.outputPaths;\n        }\n\n        if (outputPaths) {\n          data = filterKeys(flatData, startsWithOneOf(outputPaths));\n        } else {\n          data = flatData;\n        }\n      } catch (e) {\n        if (!call.ignoreErrorCodesMatching || !new RegExp(call.ignoreErrorCodesMatching).test(e.code)) {\n          throw e;\n        }\n      }\n\n      if (call.physicalResourceId?.responsePath) {\n        physicalResourceId = flatData[call.physicalResourceId.responsePath];\n      }\n    }\n\n    await respond('SUCCESS', 'OK', physicalResourceId, data);\n  } catch (e) {\n    console.log(e);\n    await respond('FAILED', e.message || 'Internal Error', context.logStreamName, {});\n  }\n\n  function respond(responseStatus: string, reason: string, physicalResourceId: string, data: any) {\n    const responseBody = JSON.stringify({\n      Status: responseStatus,\n      Reason: reason,\n      PhysicalResourceId: physicalResourceId,\n      StackId: event.StackId,\n      RequestId: event.RequestId,\n      LogicalResourceId: event.LogicalResourceId,\n      NoEcho: false,\n      Data: data,\n    });\n\n    console.log('Responding', responseBody);\n\n    // eslint-disable-next-line @typescript-eslint/no-require-imports\n    const parsedUrl = require('url').parse(event.ResponseURL);\n    const requestOptions = {\n      hostname: parsedUrl.hostname,\n      path: parsedUrl.path,\n      method: 'PUT',\n      headers: { 'content-type': '', 'content-length': responseBody.length },\n    };\n\n    return new Promise((resolve, reject) => {\n      try {\n        // eslint-disable-next-line @typescript-eslint/no-require-imports\n        const request = require('https').request(requestOptions, resolve);\n        request.on('error', reject);\n        request.write(responseBody);\n        request.end();\n      } catch (e) {\n        reject(e);\n      }\n    });\n  }\n}\n\nfunction decodeCall(call: string | undefined) {\n  if (!call) { return undefined; }\n  return JSON.parse(call);\n}\n\nfunction startsWithOneOf(searchStrings: string[]): (string: string) => boolean {\n  return function(string: string): boolean {\n    for (const searchString of searchStrings) {\n      if (string.startsWith(searchString)) {\n        return true;\n      }\n    }\n    return false;\n  };\n}\n"]} \ No newline at end of file diff --git a/packages/@aws-cdk/custom-resources/test/aws-custom-resource/integ.aws-custom-resource-athena.js.snapshot/aws-cdk-customresources-athena.assets.json b/packages/@aws-cdk/custom-resources/test/aws-custom-resource/integ.aws-custom-resource-athena.js.snapshot/aws-cdk-customresources-athena.assets.json new file mode 100644 index 0000000000000..a9f3774599edc --- /dev/null +++ b/packages/@aws-cdk/custom-resources/test/aws-custom-resource/integ.aws-custom-resource-athena.js.snapshot/aws-cdk-customresources-athena.assets.json @@ -0,0 +1,32 @@ +{ + "version": "29.0.0", + "files": { + "a268caa53756f51bda8ad5f499be4ed8484a81b314811806fbb66f874837c476": { + "source": { + "path": "asset.a268caa53756f51bda8ad5f499be4ed8484a81b314811806fbb66f874837c476", + "packaging": "zip" + }, + "destinations": { + "current_account-current_region": { + "bucketName": "cdk-hnb659fds-assets-${AWS::AccountId}-${AWS::Region}", + "objectKey": "a268caa53756f51bda8ad5f499be4ed8484a81b314811806fbb66f874837c476.zip", + "assumeRoleArn": "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-hnb659fds-file-publishing-role-${AWS::AccountId}-${AWS::Region}" + } + } + }, + "2c3b2903e60f617f0a14d38131e69d5d24c04a48700857dfc3c7322c1973749b": { + "source": { + "path": "aws-cdk-customresources-athena.template.json", + "packaging": "file" + }, + "destinations": { + "current_account-current_region": { + "bucketName": "cdk-hnb659fds-assets-${AWS::AccountId}-${AWS::Region}", + "objectKey": "2c3b2903e60f617f0a14d38131e69d5d24c04a48700857dfc3c7322c1973749b.json", + "assumeRoleArn": "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-hnb659fds-file-publishing-role-${AWS::AccountId}-${AWS::Region}" + } + } + } + }, + "dockerImages": {} +} \ No newline at end of file diff --git a/packages/@aws-cdk/custom-resources/test/aws-custom-resource/integ.aws-custom-resource-athena.js.snapshot/aws-cdk-customresources-athena.template.json b/packages/@aws-cdk/custom-resources/test/aws-custom-resource/integ.aws-custom-resource-athena.js.snapshot/aws-cdk-customresources-athena.template.json new file mode 100644 index 0000000000000..40897ec3e60ba --- /dev/null +++ b/packages/@aws-cdk/custom-resources/test/aws-custom-resource/integ.aws-custom-resource-athena.js.snapshot/aws-cdk-customresources-athena.template.json @@ -0,0 +1,235 @@ +{ + "Resources": { + "AthenaResultBucketDF85B968": { + "Type": "AWS::S3::Bucket", + "UpdateReplacePolicy": "Retain", + "DeletionPolicy": "Retain" + }, + "AthenaExecRole1895AF29": { + "Type": "AWS::IAM::Role", + "Properties": { + "AssumeRolePolicyDocument": { + "Statement": [ + { + "Action": "sts:AssumeRole", + "Effect": "Allow", + "Principal": { + "Service": "athena.amazonaws.com" + } + } + ], + "Version": "2012-10-17" + }, + "ManagedPolicyArns": [ + { + "Fn::Join": [ + "", + [ + "arn:", + { + "Ref": "AWS::Partition" + }, + ":iam::aws:policy/AmazonAthenaFullAccess" + ] + ] + } + ] + } + }, + "CustomResourceRoleAB1EF463": { + "Type": "AWS::IAM::Role", + "Properties": { + "AssumeRolePolicyDocument": { + "Statement": [ + { + "Action": "sts:AssumeRole", + "Effect": "Allow", + "Principal": { + "Service": "lambda.amazonaws.com" + } + } + ], + "Version": "2012-10-17" + }, + "ManagedPolicyArns": [ + { + "Fn::Join": [ + "", + [ + "arn:", + { + "Ref": "AWS::Partition" + }, + ":iam::aws:policy/service-role/AWSLambdaBasicExecutionRole" + ] + ] + } + ], + "Policies": [ + { + "PolicyDocument": { + "Statement": [ + { + "Action": "iam:PassRole", + "Effect": "Allow", + "Resource": { + "Fn::GetAtt": [ + "AthenaExecRole1895AF29", + "Arn" + ] + } + } + ], + "Version": "2012-10-17" + }, + "PolicyName": "PassRolePolicy" + }, + { + "PolicyDocument": { + "Statement": [ + { + "Action": [ + "athena:CreateWorkGroup", + "athena:DeleteWorkGroup" + ], + "Effect": "Allow", + "Resource": "*" + } + ], + "Version": "2012-10-17" + }, + "PolicyName": "AthenaWorkGroupPolicy" + }, + { + "PolicyDocument": { + "Statement": [ + { + "Action": [ + "athena:CreateNotebook", + "athena:DeleteNotebook", + "athena:UpdateNotebookMetadata" + ], + "Effect": "Allow", + "Resource": "*" + } + ], + "Version": "2012-10-17" + }, + "PolicyName": "AthenaNotebookPolicy" + } + ] + } + }, + "AthenaWorkGroupA2C2329E": { + "Type": "Custom::AthenaWorkGroup", + "Properties": { + "ServiceToken": { + "Fn::GetAtt": [ + "AWS679f53fac002430cb0da5b7982bd22872D164C4C", + "Arn" + ] + }, + "Create": { + "Fn::Join": [ + "", + [ + "{\"service\":\"Athena\",\"action\":\"createWorkGroup\",\"physicalResourceId\":{\"id\":\"TestWG\"},\"parameters\":{\"Name\":\"TestWG\",\"Configuration\":{\"ExecutionRole\":\"", + { + "Fn::GetAtt": [ + "AthenaExecRole1895AF29", + "Arn" + ] + }, + "\",\"ResultConfiguration\":{\"OutputLocation\":\"s3://", + { + "Ref": "AthenaResultBucketDF85B968" + }, + "\"},\"EngineVersion\":{\"SelectedEngineVersion\":\"PySpark engine version 3\"}}}}" + ] + ] + }, + "Delete": "{\"service\":\"Athena\",\"action\":\"deleteWorkGroup\",\"parameters\":{\"WorkGroup\":\"TestWG\"}}", + "InstallLatestAwsSdk": true + }, + "UpdateReplacePolicy": "Delete", + "DeletionPolicy": "Delete" + }, + "AWS679f53fac002430cb0da5b7982bd22872D164C4C": { + "Type": "AWS::Lambda::Function", + "Properties": { + "Code": { + "S3Bucket": { + "Fn::Sub": "cdk-hnb659fds-assets-${AWS::AccountId}-${AWS::Region}" + }, + "S3Key": "a268caa53756f51bda8ad5f499be4ed8484a81b314811806fbb66f874837c476.zip" + }, + "Role": { + "Fn::GetAtt": [ + "CustomResourceRoleAB1EF463", + "Arn" + ] + }, + "Handler": "index.handler", + "Runtime": "nodejs14.x", + "Timeout": 180 + }, + "DependsOn": [ + "CustomResourceRoleAB1EF463" + ] + }, + "AthenaNotebook878CD9ED": { + "Type": "Custom::AthenaNotebook", + "Properties": { + "ServiceToken": { + "Fn::GetAtt": [ + "AWS679f53fac002430cb0da5b7982bd22872D164C4C", + "Arn" + ] + }, + "Create": "{\"service\":\"Athena\",\"action\":\"createNotebook\",\"physicalResourceId\":{\"responsePath\":\"NotebookId\"},\"parameters\":{\"WorkGroup\":\"TestWG\",\"Name\":\"MyNotebook1\"}}", + "Update": "{\"service\":\"Athena\",\"action\":\"updateNotebookMetadata\",\"parameters\":{\"Name\":\"MyNotebook1\",\"NotebookId\":\"PHYSICAL:RESOURCEID:\"}}", + "Delete": "{\"service\":\"Athena\",\"action\":\"deleteNotebook\",\"parameters\":{\"NotebookId\":\"PHYSICAL:RESOURCEID:\"}}", + "InstallLatestAwsSdk": true + }, + "DependsOn": [ + "AthenaWorkGroupA2C2329E" + ], + "UpdateReplacePolicy": "Delete", + "DeletionPolicy": "Delete" + } + }, + "Parameters": { + "BootstrapVersion": { + "Type": "AWS::SSM::Parameter::Value", + "Default": "/cdk-bootstrap/hnb659fds/version", + "Description": "Version of the CDK Bootstrap resources in this environment, automatically retrieved from SSM Parameter Store. [cdk:skip]" + } + }, + "Rules": { + "CheckBootstrapVersion": { + "Assertions": [ + { + "Assert": { + "Fn::Not": [ + { + "Fn::Contains": [ + [ + "1", + "2", + "3", + "4", + "5" + ], + { + "Ref": "BootstrapVersion" + } + ] + } + ] + }, + "AssertDescription": "CDK bootstrap stack version 6 required. Please run 'cdk bootstrap' with a recent version of the CDK CLI." + } + ] + } + } +} \ No newline at end of file diff --git a/packages/@aws-cdk/custom-resources/test/aws-custom-resource/integ.aws-custom-resource-athena.js.snapshot/cdk.out b/packages/@aws-cdk/custom-resources/test/aws-custom-resource/integ.aws-custom-resource-athena.js.snapshot/cdk.out new file mode 100644 index 0000000000000..d8b441d447f8a --- /dev/null +++ b/packages/@aws-cdk/custom-resources/test/aws-custom-resource/integ.aws-custom-resource-athena.js.snapshot/cdk.out @@ -0,0 +1 @@ +{"version":"29.0.0"} \ No newline at end of file diff --git a/packages/@aws-cdk/custom-resources/test/aws-custom-resource/integ.aws-custom-resource-athena.js.snapshot/integ.json b/packages/@aws-cdk/custom-resources/test/aws-custom-resource/integ.aws-custom-resource-athena.js.snapshot/integ.json new file mode 100644 index 0000000000000..2b35c2c434938 --- /dev/null +++ b/packages/@aws-cdk/custom-resources/test/aws-custom-resource/integ.aws-custom-resource-athena.js.snapshot/integ.json @@ -0,0 +1,12 @@ +{ + "version": "29.0.0", + "testCases": { + "CustomResourceAthena/DefaultTest": { + "stacks": [ + "aws-cdk-customresources-athena" + ], + "assertionStack": "CustomResourceAthena/DefaultTest/DeployAssert", + "assertionStackName": "CustomResourceAthenaDefaultTestDeployAssert7AE6A475" + } + } +} \ No newline at end of file diff --git a/packages/@aws-cdk/custom-resources/test/aws-custom-resource/integ.aws-custom-resource-athena.js.snapshot/manifest.json b/packages/@aws-cdk/custom-resources/test/aws-custom-resource/integ.aws-custom-resource-athena.js.snapshot/manifest.json new file mode 100644 index 0000000000000..7ed76a438d351 --- /dev/null +++ b/packages/@aws-cdk/custom-resources/test/aws-custom-resource/integ.aws-custom-resource-athena.js.snapshot/manifest.json @@ -0,0 +1,141 @@ +{ + "version": "29.0.0", + "artifacts": { + "aws-cdk-customresources-athena.assets": { + "type": "cdk:asset-manifest", + "properties": { + "file": "aws-cdk-customresources-athena.assets.json", + "requiresBootstrapStackVersion": 6, + "bootstrapStackVersionSsmParameter": "/cdk-bootstrap/hnb659fds/version" + } + }, + "aws-cdk-customresources-athena": { + "type": "aws:cloudformation:stack", + "environment": "aws://unknown-account/unknown-region", + "properties": { + "templateFile": "aws-cdk-customresources-athena.template.json", + "validateOnSynth": false, + "assumeRoleArn": "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-hnb659fds-deploy-role-${AWS::AccountId}-${AWS::Region}", + "cloudFormationExecutionRoleArn": "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-hnb659fds-cfn-exec-role-${AWS::AccountId}-${AWS::Region}", + "stackTemplateAssetObjectUrl": "s3://cdk-hnb659fds-assets-${AWS::AccountId}-${AWS::Region}/2c3b2903e60f617f0a14d38131e69d5d24c04a48700857dfc3c7322c1973749b.json", + "requiresBootstrapStackVersion": 6, + "bootstrapStackVersionSsmParameter": "/cdk-bootstrap/hnb659fds/version", + "additionalDependencies": [ + "aws-cdk-customresources-athena.assets" + ], + "lookupRole": { + "arn": "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-hnb659fds-lookup-role-${AWS::AccountId}-${AWS::Region}", + "requiresBootstrapStackVersion": 8, + "bootstrapStackVersionSsmParameter": "/cdk-bootstrap/hnb659fds/version" + } + }, + "dependencies": [ + "aws-cdk-customresources-athena.assets" + ], + "metadata": { + "/aws-cdk-customresources-athena/AthenaResultBucket/Resource": [ + { + "type": "aws:cdk:logicalId", + "data": "AthenaResultBucketDF85B968" + } + ], + "/aws-cdk-customresources-athena/AthenaExecRole/Resource": [ + { + "type": "aws:cdk:logicalId", + "data": "AthenaExecRole1895AF29" + } + ], + "/aws-cdk-customresources-athena/CustomResourceRole/Resource": [ + { + "type": "aws:cdk:logicalId", + "data": "CustomResourceRoleAB1EF463" + } + ], + "/aws-cdk-customresources-athena/AthenaWorkGroup/Resource/Default": [ + { + "type": "aws:cdk:logicalId", + "data": "AthenaWorkGroupA2C2329E" + } + ], + "/aws-cdk-customresources-athena/AWS679f53fac002430cb0da5b7982bd2287/Resource": [ + { + "type": "aws:cdk:logicalId", + "data": "AWS679f53fac002430cb0da5b7982bd22872D164C4C" + } + ], + "/aws-cdk-customresources-athena/AthenaNotebook/Resource/Default": [ + { + "type": "aws:cdk:logicalId", + "data": "AthenaNotebook878CD9ED" + } + ], + "/aws-cdk-customresources-athena/BootstrapVersion": [ + { + "type": "aws:cdk:logicalId", + "data": "BootstrapVersion" + } + ], + "/aws-cdk-customresources-athena/CheckBootstrapVersion": [ + { + "type": "aws:cdk:logicalId", + "data": "CheckBootstrapVersion" + } + ] + }, + "displayName": "aws-cdk-customresources-athena" + }, + "CustomResourceAthenaDefaultTestDeployAssert7AE6A475.assets": { + "type": "cdk:asset-manifest", + "properties": { + "file": "CustomResourceAthenaDefaultTestDeployAssert7AE6A475.assets.json", + "requiresBootstrapStackVersion": 6, + "bootstrapStackVersionSsmParameter": "/cdk-bootstrap/hnb659fds/version" + } + }, + "CustomResourceAthenaDefaultTestDeployAssert7AE6A475": { + "type": "aws:cloudformation:stack", + "environment": "aws://unknown-account/unknown-region", + "properties": { + "templateFile": "CustomResourceAthenaDefaultTestDeployAssert7AE6A475.template.json", + "validateOnSynth": false, + "assumeRoleArn": "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-hnb659fds-deploy-role-${AWS::AccountId}-${AWS::Region}", + "cloudFormationExecutionRoleArn": "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-hnb659fds-cfn-exec-role-${AWS::AccountId}-${AWS::Region}", + "stackTemplateAssetObjectUrl": "s3://cdk-hnb659fds-assets-${AWS::AccountId}-${AWS::Region}/21fbb51d7b23f6a6c262b46a9caee79d744a3ac019fd45422d988b96d44b2a22.json", + "requiresBootstrapStackVersion": 6, + "bootstrapStackVersionSsmParameter": "/cdk-bootstrap/hnb659fds/version", + "additionalDependencies": [ + "CustomResourceAthenaDefaultTestDeployAssert7AE6A475.assets" + ], + "lookupRole": { + "arn": "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-hnb659fds-lookup-role-${AWS::AccountId}-${AWS::Region}", + "requiresBootstrapStackVersion": 8, + "bootstrapStackVersionSsmParameter": "/cdk-bootstrap/hnb659fds/version" + } + }, + "dependencies": [ + "CustomResourceAthenaDefaultTestDeployAssert7AE6A475.assets" + ], + "metadata": { + "/CustomResourceAthena/DefaultTest/DeployAssert/BootstrapVersion": [ + { + "type": "aws:cdk:logicalId", + "data": "BootstrapVersion" + } + ], + "/CustomResourceAthena/DefaultTest/DeployAssert/CheckBootstrapVersion": [ + { + "type": "aws:cdk:logicalId", + "data": "CheckBootstrapVersion" + } + ] + }, + "displayName": "CustomResourceAthena/DefaultTest/DeployAssert" + }, + "Tree": { + "type": "cdk:tree", + "properties": { + "file": "tree.json" + } + } + } +} \ No newline at end of file diff --git a/packages/@aws-cdk/custom-resources/test/aws-custom-resource/integ.aws-custom-resource-athena.js.snapshot/tree.json b/packages/@aws-cdk/custom-resources/test/aws-custom-resource/integ.aws-custom-resource-athena.js.snapshot/tree.json new file mode 100644 index 0000000000000..d37539f921ef8 --- /dev/null +++ b/packages/@aws-cdk/custom-resources/test/aws-custom-resource/integ.aws-custom-resource-athena.js.snapshot/tree.json @@ -0,0 +1,426 @@ +{ + "version": "tree-0.1", + "tree": { + "id": "App", + "path": "", + "children": { + "aws-cdk-customresources-athena": { + "id": "aws-cdk-customresources-athena", + "path": "aws-cdk-customresources-athena", + "children": { + "AthenaResultBucket": { + "id": "AthenaResultBucket", + "path": "aws-cdk-customresources-athena/AthenaResultBucket", + "children": { + "Resource": { + "id": "Resource", + "path": "aws-cdk-customresources-athena/AthenaResultBucket/Resource", + "attributes": { + "aws:cdk:cloudformation:type": "AWS::S3::Bucket", + "aws:cdk:cloudformation:props": {} + }, + "constructInfo": { + "fqn": "@aws-cdk/aws-s3.CfnBucket", + "version": "0.0.0" + } + } + }, + "constructInfo": { + "fqn": "@aws-cdk/aws-s3.Bucket", + "version": "0.0.0" + } + }, + "AthenaExecRole": { + "id": "AthenaExecRole", + "path": "aws-cdk-customresources-athena/AthenaExecRole", + "children": { + "ImportAthenaExecRole": { + "id": "ImportAthenaExecRole", + "path": "aws-cdk-customresources-athena/AthenaExecRole/ImportAthenaExecRole", + "constructInfo": { + "fqn": "@aws-cdk/core.Resource", + "version": "0.0.0" + } + }, + "Resource": { + "id": "Resource", + "path": "aws-cdk-customresources-athena/AthenaExecRole/Resource", + "attributes": { + "aws:cdk:cloudformation:type": "AWS::IAM::Role", + "aws:cdk:cloudformation:props": { + "assumeRolePolicyDocument": { + "Statement": [ + { + "Action": "sts:AssumeRole", + "Effect": "Allow", + "Principal": { + "Service": "athena.amazonaws.com" + } + } + ], + "Version": "2012-10-17" + }, + "managedPolicyArns": [ + { + "Fn::Join": [ + "", + [ + "arn:", + { + "Ref": "AWS::Partition" + }, + ":iam::aws:policy/AmazonAthenaFullAccess" + ] + ] + } + ] + } + }, + "constructInfo": { + "fqn": "@aws-cdk/aws-iam.CfnRole", + "version": "0.0.0" + } + } + }, + "constructInfo": { + "fqn": "@aws-cdk/aws-iam.Role", + "version": "0.0.0" + } + }, + "CustomResourceRole": { + "id": "CustomResourceRole", + "path": "aws-cdk-customresources-athena/CustomResourceRole", + "children": { + "ImportCustomResourceRole": { + "id": "ImportCustomResourceRole", + "path": "aws-cdk-customresources-athena/CustomResourceRole/ImportCustomResourceRole", + "constructInfo": { + "fqn": "@aws-cdk/core.Resource", + "version": "0.0.0" + } + }, + "Resource": { + "id": "Resource", + "path": "aws-cdk-customresources-athena/CustomResourceRole/Resource", + "attributes": { + "aws:cdk:cloudformation:type": "AWS::IAM::Role", + "aws:cdk:cloudformation:props": { + "assumeRolePolicyDocument": { + "Statement": [ + { + "Action": "sts:AssumeRole", + "Effect": "Allow", + "Principal": { + "Service": "lambda.amazonaws.com" + } + } + ], + "Version": "2012-10-17" + }, + "managedPolicyArns": [ + { + "Fn::Join": [ + "", + [ + "arn:", + { + "Ref": "AWS::Partition" + }, + ":iam::aws:policy/service-role/AWSLambdaBasicExecutionRole" + ] + ] + } + ], + "policies": [ + { + "policyName": "PassRolePolicy", + "policyDocument": { + "Statement": [ + { + "Action": "iam:PassRole", + "Effect": "Allow", + "Resource": { + "Fn::GetAtt": [ + "AthenaExecRole1895AF29", + "Arn" + ] + } + } + ], + "Version": "2012-10-17" + } + }, + { + "policyName": "AthenaWorkGroupPolicy", + "policyDocument": { + "Statement": [ + { + "Action": [ + "athena:CreateWorkGroup", + "athena:DeleteWorkGroup" + ], + "Effect": "Allow", + "Resource": "*" + } + ], + "Version": "2012-10-17" + } + }, + { + "policyName": "AthenaNotebookPolicy", + "policyDocument": { + "Statement": [ + { + "Action": [ + "athena:CreateNotebook", + "athena:DeleteNotebook", + "athena:UpdateNotebookMetadata" + ], + "Effect": "Allow", + "Resource": "*" + } + ], + "Version": "2012-10-17" + } + } + ] + } + }, + "constructInfo": { + "fqn": "@aws-cdk/aws-iam.CfnRole", + "version": "0.0.0" + } + } + }, + "constructInfo": { + "fqn": "@aws-cdk/aws-iam.Role", + "version": "0.0.0" + } + }, + "AthenaWorkGroup": { + "id": "AthenaWorkGroup", + "path": "aws-cdk-customresources-athena/AthenaWorkGroup", + "children": { + "Provider": { + "id": "Provider", + "path": "aws-cdk-customresources-athena/AthenaWorkGroup/Provider", + "constructInfo": { + "fqn": "@aws-cdk/aws-lambda.SingletonFunction", + "version": "0.0.0" + } + }, + "Resource": { + "id": "Resource", + "path": "aws-cdk-customresources-athena/AthenaWorkGroup/Resource", + "children": { + "Default": { + "id": "Default", + "path": "aws-cdk-customresources-athena/AthenaWorkGroup/Resource/Default", + "constructInfo": { + "fqn": "@aws-cdk/core.CfnResource", + "version": "0.0.0" + } + } + }, + "constructInfo": { + "fqn": "@aws-cdk/core.CustomResource", + "version": "0.0.0" + } + } + }, + "constructInfo": { + "fqn": "@aws-cdk/custom-resources.AwsCustomResource", + "version": "0.0.0" + } + }, + "AWS679f53fac002430cb0da5b7982bd2287": { + "id": "AWS679f53fac002430cb0da5b7982bd2287", + "path": "aws-cdk-customresources-athena/AWS679f53fac002430cb0da5b7982bd2287", + "children": { + "Code": { + "id": "Code", + "path": "aws-cdk-customresources-athena/AWS679f53fac002430cb0da5b7982bd2287/Code", + "children": { + "Stage": { + "id": "Stage", + "path": "aws-cdk-customresources-athena/AWS679f53fac002430cb0da5b7982bd2287/Code/Stage", + "constructInfo": { + "fqn": "@aws-cdk/core.AssetStaging", + "version": "0.0.0" + } + }, + "AssetBucket": { + "id": "AssetBucket", + "path": "aws-cdk-customresources-athena/AWS679f53fac002430cb0da5b7982bd2287/Code/AssetBucket", + "constructInfo": { + "fqn": "@aws-cdk/aws-s3.BucketBase", + "version": "0.0.0" + } + } + }, + "constructInfo": { + "fqn": "@aws-cdk/aws-s3-assets.Asset", + "version": "0.0.0" + } + }, + "Resource": { + "id": "Resource", + "path": "aws-cdk-customresources-athena/AWS679f53fac002430cb0da5b7982bd2287/Resource", + "attributes": { + "aws:cdk:cloudformation:type": "AWS::Lambda::Function", + "aws:cdk:cloudformation:props": { + "code": { + "s3Bucket": { + "Fn::Sub": "cdk-hnb659fds-assets-${AWS::AccountId}-${AWS::Region}" + }, + "s3Key": "a268caa53756f51bda8ad5f499be4ed8484a81b314811806fbb66f874837c476.zip" + }, + "role": { + "Fn::GetAtt": [ + "CustomResourceRoleAB1EF463", + "Arn" + ] + }, + "handler": "index.handler", + "runtime": "nodejs14.x", + "timeout": 180 + } + }, + "constructInfo": { + "fqn": "@aws-cdk/aws-lambda.CfnFunction", + "version": "0.0.0" + } + } + }, + "constructInfo": { + "fqn": "@aws-cdk/aws-lambda.Function", + "version": "0.0.0" + } + }, + "AthenaNotebook": { + "id": "AthenaNotebook", + "path": "aws-cdk-customresources-athena/AthenaNotebook", + "children": { + "Provider": { + "id": "Provider", + "path": "aws-cdk-customresources-athena/AthenaNotebook/Provider", + "constructInfo": { + "fqn": "@aws-cdk/aws-lambda.SingletonFunction", + "version": "0.0.0" + } + }, + "Resource": { + "id": "Resource", + "path": "aws-cdk-customresources-athena/AthenaNotebook/Resource", + "children": { + "Default": { + "id": "Default", + "path": "aws-cdk-customresources-athena/AthenaNotebook/Resource/Default", + "constructInfo": { + "fqn": "@aws-cdk/core.CfnResource", + "version": "0.0.0" + } + } + }, + "constructInfo": { + "fqn": "@aws-cdk/core.CustomResource", + "version": "0.0.0" + } + } + }, + "constructInfo": { + "fqn": "@aws-cdk/custom-resources.AwsCustomResource", + "version": "0.0.0" + } + }, + "BootstrapVersion": { + "id": "BootstrapVersion", + "path": "aws-cdk-customresources-athena/BootstrapVersion", + "constructInfo": { + "fqn": "@aws-cdk/core.CfnParameter", + "version": "0.0.0" + } + }, + "CheckBootstrapVersion": { + "id": "CheckBootstrapVersion", + "path": "aws-cdk-customresources-athena/CheckBootstrapVersion", + "constructInfo": { + "fqn": "@aws-cdk/core.CfnRule", + "version": "0.0.0" + } + } + }, + "constructInfo": { + "fqn": "@aws-cdk/core.Stack", + "version": "0.0.0" + } + }, + "CustomResourceAthena": { + "id": "CustomResourceAthena", + "path": "CustomResourceAthena", + "children": { + "DefaultTest": { + "id": "DefaultTest", + "path": "CustomResourceAthena/DefaultTest", + "children": { + "Default": { + "id": "Default", + "path": "CustomResourceAthena/DefaultTest/Default", + "constructInfo": { + "fqn": "constructs.Construct", + "version": "10.1.216" + } + }, + "DeployAssert": { + "id": "DeployAssert", + "path": "CustomResourceAthena/DefaultTest/DeployAssert", + "children": { + "BootstrapVersion": { + "id": "BootstrapVersion", + "path": "CustomResourceAthena/DefaultTest/DeployAssert/BootstrapVersion", + "constructInfo": { + "fqn": "@aws-cdk/core.CfnParameter", + "version": "0.0.0" + } + }, + "CheckBootstrapVersion": { + "id": "CheckBootstrapVersion", + "path": "CustomResourceAthena/DefaultTest/DeployAssert/CheckBootstrapVersion", + "constructInfo": { + "fqn": "@aws-cdk/core.CfnRule", + "version": "0.0.0" + } + } + }, + "constructInfo": { + "fqn": "@aws-cdk/core.Stack", + "version": "0.0.0" + } + } + }, + "constructInfo": { + "fqn": "@aws-cdk/integ-tests.IntegTestCase", + "version": "0.0.0" + } + } + }, + "constructInfo": { + "fqn": "@aws-cdk/integ-tests.IntegTest", + "version": "0.0.0" + } + }, + "Tree": { + "id": "Tree", + "path": "Tree", + "constructInfo": { + "fqn": "constructs.Construct", + "version": "10.1.216" + } + } + }, + "constructInfo": { + "fqn": "@aws-cdk/core.App", + "version": "0.0.0" + } + } +} \ No newline at end of file diff --git a/packages/@aws-cdk/custom-resources/test/aws-custom-resource/integ.aws-custom-resource-athena.ts b/packages/@aws-cdk/custom-resources/test/aws-custom-resource/integ.aws-custom-resource-athena.ts new file mode 100644 index 0000000000000..98dedeb8e2b72 --- /dev/null +++ b/packages/@aws-cdk/custom-resources/test/aws-custom-resource/integ.aws-custom-resource-athena.ts @@ -0,0 +1,141 @@ +import { ManagedPolicy, PolicyDocument, PolicyStatement, Role, ServicePrincipal } from '@aws-cdk/aws-iam'; +import { Bucket } from '@aws-cdk/aws-s3'; +import * as cdk from '@aws-cdk/core'; +import { IntegTest } from '@aws-cdk/integ-tests'; +import { AwsCustomResource, PhysicalResourceId, PhysicalResourceIdReference } from '../../lib'; + +/* + * + * Stack verification steps: + * + * 1) Deploy app. + * $ yarn build && yarn integ --update-on-failed --no-clean + * 2) Change `notebookName` to perform an update. + * $ yarn build && yarn integ --update-on-failed --no-clean + * 3) Check if PhysicalResourceId is consistent. + * $ aws cloudformation describe-stack-events \ + * --stack-name aws-cdk-customresources-athena \ + * --query 'StackEvents[?starts_with(LogicalResourceId,`AthenaNotebook`)]' + * + */ +const app = new cdk.App(); +const stack = new cdk.Stack(app, 'aws-cdk-customresources-athena'); + +const athenaResultBucket = new Bucket(stack, 'AthenaResultBucket'); +const athenaExecutionRole = new Role(stack, 'AthenaExecRole', { + assumedBy: new ServicePrincipal('athena.amazonaws.com'), + managedPolicies: [ + ManagedPolicy.fromAwsManagedPolicyName('AmazonAthenaFullAccess'), + ], +}); + +// To avoid the Lambda Function from failing due to delays +// in policy propagation, this role should be created explicitly. +const customResourceRole = new Role(stack, 'CustomResourceRole', { + assumedBy: new ServicePrincipal('lambda.amazonaws.com'), + managedPolicies: [ + ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSLambdaBasicExecutionRole'), + ], + inlinePolicies: { + PassRolePolicy: new PolicyDocument({ + statements: [new PolicyStatement({ + actions: ['iam:PassRole'], + resources: [athenaExecutionRole.roleArn], + })], + }), + AthenaWorkGroupPolicy: new PolicyDocument({ + statements: [new PolicyStatement({ + actions: [ + 'athena:CreateWorkGroup', + 'athena:DeleteWorkGroup', + ], + resources: ['*'], + })], + }), + AthenaNotebookPolicy: new PolicyDocument({ + statements: [new PolicyStatement({ + actions: [ + 'athena:CreateNotebook', + 'athena:UpdateNotebookMetadata', + 'athena:DeleteNotebook', + ], + resources: ['*'], + })], + }), + }, +}); + +const workgroupName = 'TestWG'; +const workgroup = new AwsCustomResource(stack, 'AthenaWorkGroup', { + role: customResourceRole, + resourceType: 'Custom::AthenaWorkGroup', + installLatestAwsSdk: true, + onCreate: { + service: 'Athena', + action: 'createWorkGroup', + physicalResourceId: PhysicalResourceId.of(workgroupName), + parameters: { + Name: workgroupName, + Configuration: { + ExecutionRole: athenaExecutionRole.roleArn, + ResultConfiguration: { + OutputLocation: athenaResultBucket.s3UrlForObject(), + }, + EngineVersion: { + SelectedEngineVersion: 'PySpark engine version 3', + }, + }, + }, + }, + onDelete: { + service: 'Athena', + action: 'deleteWorkGroup', + parameters: { + WorkGroup: workgroupName, + }, + }, + timeout: cdk.Duration.minutes(3), +}); + +// Athena.updateNotebook responses with empty body. +// This test case expects physicalResourceId to remain unchanged +// even if the user is unable to explicitly specify it because of empty response. +// https://docs.aws.amazon.com/athena/latest/APIReference/API_UpdateNotebook.html +const notebookName = 'MyNotebook1'; // Update name for test +const notebook = new AwsCustomResource(stack, 'AthenaNotebook', { + role: customResourceRole, + resourceType: 'Custom::AthenaNotebook', + installLatestAwsSdk: true, + onCreate: { + service: 'Athena', + action: 'createNotebook', + physicalResourceId: PhysicalResourceId.fromResponse('NotebookId'), + parameters: { + WorkGroup: workgroupName, + Name: notebookName, + }, + }, + onUpdate: { + service: 'Athena', + action: 'updateNotebookMetadata', + parameters: { + Name: notebookName, + NotebookId: new PhysicalResourceIdReference(), + }, + }, + onDelete: { + service: 'Athena', + action: 'deleteNotebook', + parameters: { + NotebookId: new PhysicalResourceIdReference(), + }, + }, + timeout: cdk.Duration.minutes(3), +}); +notebook.node.addDependency(workgroup); + +new IntegTest(app, 'CustomResourceAthena', { + testCases: [stack], +}); + +app.synth();