From f7a5922ad9c25ef1e478facf22bd161e32fe5f4c Mon Sep 17 00:00:00 2001 From: corymhall <43035978+corymhall@users.noreply.github.com> Date: Wed, 19 Apr 2023 14:16:00 +0000 Subject: [PATCH 1/2] fix(core): crossRegionReferences doesn't work when exporting to multiple regions The cross region export writer was only being given permissions to the first region it would export to. Fixing this by adding each consuming region to the IAM policy. fixes #24464 --- .../__entrypoint__.js | 147 ++ .../index.js | 152 ++ .../index.js | 1295 +++++++++++++++++ .../index.js | 768 ---------- .../__entrypoint__.js | 144 -- .../index.js | 148 -- .../cdk.out | 2 +- .../cross-region-consumer.assets.json | 12 +- .../cross-region-consumer.template.json | 2 +- .../cross-region-consumer2.assets.json | 48 + .../cross-region-consumer2.template.json | 198 +++ .../cross-region-producer.assets.json | 12 +- .../cross-region-producer.template.json | 200 ++- ...r2IntegNested80DBA5D8.nested.template.json | 32 + ...efaultTestDeployAssertAB7415FD.assets.json | 12 +- ...aultTestDeployAssertAB7415FD.template.json | 10 +- .../integ.json | 5 +- .../manifest.json | 122 +- .../integ.core-cross-region-references.ts | 16 +- .../lib/runner/private/cloud-assembly.ts | 7 +- .../export-writer-provider.ts | 45 +- .../export-writer-provider.test.ts | 128 +- 22 files changed, 2394 insertions(+), 1111 deletions(-) create mode 100644 packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/asset.27f8287125ebe89b1cb7f97768a61c84b3f3221450e0a22c152addc630ab2430/__entrypoint__.js create mode 100644 packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/asset.27f8287125ebe89b1cb7f97768a61c84b3f3221450e0a22c152addc630ab2430/index.js create mode 100644 packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/asset.ae370e1010629b78f494346f49ceef3ab2875718f20e6c808114e6aa770c7bf3.bundle/index.js delete mode 100644 packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/asset.b54b99043c35bd080b9d9d1afce31e3541cf15b679799ba980ed40c837dcb03b.bundle/index.js delete mode 100644 packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/asset.f86f86755c3b2013542fc4f9405bfe145a86c0bec508dd0b37baabe2055d33f3/__entrypoint__.js delete mode 100644 packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/asset.f86f86755c3b2013542fc4f9405bfe145a86c0bec508dd0b37baabe2055d33f3/index.js create mode 100644 packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/cross-region-consumer2.assets.json create mode 100644 packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/cross-region-consumer2.template.json create mode 100644 packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/crossregionconsumer2IntegNested80DBA5D8.nested.template.json diff --git a/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/asset.27f8287125ebe89b1cb7f97768a61c84b3f3221450e0a22c152addc630ab2430/__entrypoint__.js b/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/asset.27f8287125ebe89b1cb7f97768a61c84b3f3221450e0a22c152addc630ab2430/__entrypoint__.js new file mode 100644 index 0000000000000..c83ecebaaadac --- /dev/null +++ b/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/asset.27f8287125ebe89b1cb7f97768a61c84b3f3221450e0a22c152addc630ab2430/__entrypoint__.js @@ -0,0 +1,147 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.withRetries = exports.handler = exports.external = void 0; +const https = require("https"); +const url = require("url"); +// for unit tests +exports.external = { + sendHttpRequest: defaultSendHttpRequest, + log: defaultLog, + includeStackTraces: true, + userHandlerIndex: './index', +}; +const CREATE_FAILED_PHYSICAL_ID_MARKER = 'AWSCDK::CustomResourceProviderFramework::CREATE_FAILED'; +const MISSING_PHYSICAL_ID_MARKER = 'AWSCDK::CustomResourceProviderFramework::MISSING_PHYSICAL_ID'; +async function handler(event, context) { + const sanitizedEvent = { ...event, ResponseURL: '...' }; + exports.external.log(JSON.stringify(sanitizedEvent, undefined, 2)); + // ignore DELETE event when the physical resource ID is the marker that + // indicates that this DELETE is a subsequent DELETE to a failed CREATE + // operation. + if (event.RequestType === 'Delete' && event.PhysicalResourceId === CREATE_FAILED_PHYSICAL_ID_MARKER) { + exports.external.log('ignoring DELETE event caused by a failed CREATE event'); + await submitResponse('SUCCESS', event); + return; + } + try { + // invoke the user handler. this is intentionally inside the try-catch to + // ensure that if there is an error it's reported as a failure to + // cloudformation (otherwise cfn waits). + // eslint-disable-next-line @typescript-eslint/no-require-imports + const userHandler = require(exports.external.userHandlerIndex).handler; + const result = await userHandler(sanitizedEvent, context); + // validate user response and create the combined event + const responseEvent = renderResponse(event, result); + // submit to cfn as success + await submitResponse('SUCCESS', responseEvent); + } + catch (e) { + const resp = { + ...event, + Reason: exports.external.includeStackTraces ? e.stack : e.message, + }; + if (!resp.PhysicalResourceId) { + // special case: if CREATE fails, which usually implies, we usually don't + // have a physical resource id. in this case, the subsequent DELETE + // operation does not have any meaning, and will likely fail as well. to + // address this, we use a marker so the provider framework can simply + // ignore the subsequent DELETE. + if (event.RequestType === 'Create') { + exports.external.log('CREATE failed, responding with a marker physical resource id so that the subsequent DELETE will be ignored'); + resp.PhysicalResourceId = CREATE_FAILED_PHYSICAL_ID_MARKER; + } + else { + // otherwise, if PhysicalResourceId is not specified, something is + // terribly wrong because all other events should have an ID. + exports.external.log(`ERROR: Malformed event. "PhysicalResourceId" is required: ${JSON.stringify(event)}`); + } + } + // this is an actual error, fail the activity altogether and exist. + await submitResponse('FAILED', resp); + } +} +exports.handler = handler; +function renderResponse(cfnRequest, handlerResponse = {}) { + // if physical ID is not returned, we have some defaults for you based + // on the request type. + const physicalResourceId = handlerResponse.PhysicalResourceId ?? cfnRequest.PhysicalResourceId ?? cfnRequest.RequestId; + // if we are in DELETE and physical ID was changed, it's an error. + if (cfnRequest.RequestType === 'Delete' && physicalResourceId !== cfnRequest.PhysicalResourceId) { + throw new Error(`DELETE: cannot change the physical resource ID from "${cfnRequest.PhysicalResourceId}" to "${handlerResponse.PhysicalResourceId}" during deletion`); + } + // merge request event and result event (result prevails). + return { + ...cfnRequest, + ...handlerResponse, + PhysicalResourceId: physicalResourceId, + }; +} +async function submitResponse(status, event) { + const json = { + Status: status, + Reason: event.Reason ?? status, + StackId: event.StackId, + RequestId: event.RequestId, + PhysicalResourceId: event.PhysicalResourceId || MISSING_PHYSICAL_ID_MARKER, + LogicalResourceId: event.LogicalResourceId, + NoEcho: event.NoEcho, + Data: event.Data, + }; + exports.external.log('submit response to cloudformation', json); + const responseBody = JSON.stringify(json); + const parsedUrl = url.parse(event.ResponseURL); + const req = { + hostname: parsedUrl.hostname, + path: parsedUrl.path, + method: 'PUT', + headers: { + 'content-type': '', + 'content-length': Buffer.byteLength(responseBody, 'utf8'), + }, + }; + const retryOptions = { + attempts: 5, + sleep: 1000, + }; + await withRetries(retryOptions, exports.external.sendHttpRequest)(req, responseBody); +} +async function defaultSendHttpRequest(options, responseBody) { + return new Promise((resolve, reject) => { + try { + const request = https.request(options, _ => resolve()); + request.on('error', reject); + request.write(responseBody); + request.end(); + } + catch (e) { + reject(e); + } + }); +} +function defaultLog(fmt, ...params) { + // eslint-disable-next-line no-console + console.log(fmt, ...params); +} +function withRetries(options, fn) { + return async (...xs) => { + let attempts = options.attempts; + let ms = options.sleep; + while (true) { + try { + return await fn(...xs); + } + catch (e) { + if (attempts-- <= 0) { + throw e; + } + await sleep(Math.floor(Math.random() * ms)); + ms *= 2; + } + } + }; +} +exports.withRetries = withRetries; +async function sleep(ms) { + return new Promise((ok) => setTimeout(ok, ms)); +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nodejs-entrypoint.js","sourceRoot":"","sources":["nodejs-entrypoint.ts"],"names":[],"mappings":"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","sourcesContent":["import * as https from 'https';\nimport * as url from 'url';\n\n// for unit tests\nexport const external = {\n  sendHttpRequest: defaultSendHttpRequest,\n  log: defaultLog,\n  includeStackTraces: true,\n  userHandlerIndex: './index',\n};\n\nconst CREATE_FAILED_PHYSICAL_ID_MARKER = 'AWSCDK::CustomResourceProviderFramework::CREATE_FAILED';\nconst MISSING_PHYSICAL_ID_MARKER = 'AWSCDK::CustomResourceProviderFramework::MISSING_PHYSICAL_ID';\n\nexport type Response = AWSLambda.CloudFormationCustomResourceEvent & HandlerResponse;\nexport type Handler = (event: AWSLambda.CloudFormationCustomResourceEvent, context: AWSLambda.Context) => Promise<HandlerResponse | void>;\nexport type HandlerResponse = undefined | {\n  Data?: any;\n  PhysicalResourceId?: string;\n  Reason?: string;\n  NoEcho?: boolean;\n};\n\nexport async function handler(event: AWSLambda.CloudFormationCustomResourceEvent, context: AWSLambda.Context) {\n  const sanitizedEvent = { ...event, ResponseURL: '...' };\n  external.log(JSON.stringify(sanitizedEvent, undefined, 2));\n\n  // ignore DELETE event when the physical resource ID is the marker that\n  // indicates that this DELETE is a subsequent DELETE to a failed CREATE\n  // operation.\n  if (event.RequestType === 'Delete' && event.PhysicalResourceId === CREATE_FAILED_PHYSICAL_ID_MARKER) {\n    external.log('ignoring DELETE event caused by a failed CREATE event');\n    await submitResponse('SUCCESS', event);\n    return;\n  }\n\n  try {\n    // invoke the user handler. this is intentionally inside the try-catch to\n    // ensure that if there is an error it's reported as a failure to\n    // cloudformation (otherwise cfn waits).\n    // eslint-disable-next-line @typescript-eslint/no-require-imports\n    const userHandler: Handler = require(external.userHandlerIndex).handler;\n    const result = await userHandler(sanitizedEvent, context);\n\n    // validate user response and create the combined event\n    const responseEvent = renderResponse(event, result);\n\n    // submit to cfn as success\n    await submitResponse('SUCCESS', responseEvent);\n  } catch (e: any) {\n    const resp: Response = {\n      ...event,\n      Reason: external.includeStackTraces ? e.stack : e.message,\n    };\n\n    if (!resp.PhysicalResourceId) {\n      // special case: if CREATE fails, which usually implies, we usually don't\n      // have a physical resource id. in this case, the subsequent DELETE\n      // operation does not have any meaning, and will likely fail as well. to\n      // address this, we use a marker so the provider framework can simply\n      // ignore the subsequent DELETE.\n      if (event.RequestType === 'Create') {\n        external.log('CREATE failed, responding with a marker physical resource id so that the subsequent DELETE will be ignored');\n        resp.PhysicalResourceId = CREATE_FAILED_PHYSICAL_ID_MARKER;\n      } else {\n        // otherwise, if PhysicalResourceId is not specified, something is\n        // terribly wrong because all other events should have an ID.\n        external.log(`ERROR: Malformed event. \"PhysicalResourceId\" is required: ${JSON.stringify(event)}`);\n      }\n    }\n\n    // this is an actual error, fail the activity altogether and exist.\n    await submitResponse('FAILED', resp);\n  }\n}\n\nfunction renderResponse(\n  cfnRequest: AWSLambda.CloudFormationCustomResourceEvent & { PhysicalResourceId?: string },\n  handlerResponse: void | HandlerResponse = { }): Response {\n\n  // if physical ID is not returned, we have some defaults for you based\n  // on the request type.\n  const physicalResourceId = handlerResponse.PhysicalResourceId ?? cfnRequest.PhysicalResourceId ?? cfnRequest.RequestId;\n\n  // if we are in DELETE and physical ID was changed, it's an error.\n  if (cfnRequest.RequestType === 'Delete' && physicalResourceId !== cfnRequest.PhysicalResourceId) {\n    throw new Error(`DELETE: cannot change the physical resource ID from \"${cfnRequest.PhysicalResourceId}\" to \"${handlerResponse.PhysicalResourceId}\" during deletion`);\n  }\n\n  // merge request event and result event (result prevails).\n  return {\n    ...cfnRequest,\n    ...handlerResponse,\n    PhysicalResourceId: physicalResourceId,\n  };\n}\n\nasync function submitResponse(status: 'SUCCESS' | 'FAILED', event: Response) {\n  const json: AWSLambda.CloudFormationCustomResourceResponse = {\n    Status: status,\n    Reason: event.Reason ?? status,\n    StackId: event.StackId,\n    RequestId: event.RequestId,\n    PhysicalResourceId: event.PhysicalResourceId || MISSING_PHYSICAL_ID_MARKER,\n    LogicalResourceId: event.LogicalResourceId,\n    NoEcho: event.NoEcho,\n    Data: event.Data,\n  };\n\n  external.log('submit response to cloudformation', json);\n\n  const responseBody = JSON.stringify(json);\n  const parsedUrl = url.parse(event.ResponseURL);\n  const req = {\n    hostname: parsedUrl.hostname,\n    path: parsedUrl.path,\n    method: 'PUT',\n    headers: {\n      'content-type': '',\n      'content-length': Buffer.byteLength(responseBody, 'utf8'),\n    },\n  };\n\n  const retryOptions = {\n    attempts: 5,\n    sleep: 1000,\n  };\n  await withRetries(retryOptions, external.sendHttpRequest)(req, responseBody);\n}\n\nasync function defaultSendHttpRequest(options: https.RequestOptions, responseBody: string): Promise<void> {\n  return new Promise((resolve, reject) => {\n    try {\n      const request = https.request(options, _ => resolve());\n      request.on('error', reject);\n      request.write(responseBody);\n      request.end();\n    } catch (e) {\n      reject(e);\n    }\n  });\n}\n\nfunction defaultLog(fmt: string, ...params: any[]) {\n  // eslint-disable-next-line no-console\n  console.log(fmt, ...params);\n}\n\nexport interface RetryOptions {\n  /** How many retries (will at least try once) */\n  readonly attempts: number;\n  /** Sleep base, in ms */\n  readonly sleep: number;\n}\n\nexport function withRetries<A extends Array<any>, B>(options: RetryOptions, fn: (...xs: A) => Promise<B>): (...xs: A) => Promise<B> {\n  return async (...xs: A) => {\n    let attempts = options.attempts;\n    let ms = options.sleep;\n    while (true) {\n      try {\n        return await fn(...xs);\n      } catch (e) {\n        if (attempts-- <= 0) {\n          throw e;\n        }\n        await sleep(Math.floor(Math.random() * ms));\n        ms *= 2;\n      }\n    }\n  };\n}\n\nasync function sleep(ms: number): Promise<void> {\n  return new Promise((ok) => setTimeout(ok, ms));\n}\n"]} \ No newline at end of file diff --git a/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/asset.27f8287125ebe89b1cb7f97768a61c84b3f3221450e0a22c152addc630ab2430/index.js b/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/asset.27f8287125ebe89b1cb7f97768a61c84b3f3221450e0a22c152addc630ab2430/index.js new file mode 100644 index 0000000000000..6945e03987b7a --- /dev/null +++ b/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/asset.27f8287125ebe89b1cb7f97768a61c84b3f3221450e0a22c152addc630ab2430/index.js @@ -0,0 +1,152 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.handler = void 0; +/*eslint-disable no-console*/ +/* eslint-disable import/no-extraneous-dependencies */ +const aws_sdk_1 = require("aws-sdk"); +async function handler(event) { + const props = event.ResourceProperties.WriterProps; + const exports = props.exports; + const ssm = new aws_sdk_1.SSM({ region: props.region }); + try { + switch (event.RequestType) { + case 'Create': + console.info(`Creating new SSM Parameter exports in region ${props.region}`); + await throwIfAnyInUse(ssm, exports); + await putParameters(ssm, exports); + return; + case 'Update': + const oldProps = event.OldResourceProperties.WriterProps; + const oldExports = oldProps.exports; + const newExports = except(exports, oldExports); + // throw an error to fail the deployment if any export value is changing + const changedExports = changed(oldExports, exports); + if (changedExports.length > 0) { + throw new Error('Some exports have changed!\n' + changedExports.join('\n')); + } + // if we are removing any exports that are in use, then throw an + // error to fail the deployment + const removedExports = except(oldExports, exports); + await throwIfAnyInUse(ssm, removedExports); + // if the ones we are removing are not in use then delete them + // skip if no export names are to be deleted + const removedExportsNames = Object.keys(removedExports); + if (removedExportsNames.length > 0) { + await ssm.deleteParameters({ + Names: removedExportsNames, + }).promise(); + } + // also throw an error if we are creating a new export that already exists for some reason + await throwIfAnyInUse(ssm, newExports); + console.info(`Creating new SSM Parameter exports in region ${props.region}`); + await putParameters(ssm, newExports); + return; + case 'Delete': + // if any of the exports are currently in use then throw an error to fail + // the stack deletion. + await throwIfAnyInUse(ssm, exports); + // if none are in use then delete all of them + await ssm.deleteParameters({ + Names: Object.keys(exports), + }).promise(); + return; + default: + return; + } + } + catch (e) { + console.error('Error processing event: ', e); + throw e; + } +} +exports.handler = handler; +; +/** + * Create parameters for existing exports + */ +async function putParameters(ssm, parameters) { + await Promise.all(Array.from(Object.entries(parameters), ([name, value]) => { + return ssm.putParameter({ + Name: name, + Value: value, + Type: 'String', + }).promise(); + })); +} +/** + * Query for existing parameters that are in use + */ +async function throwIfAnyInUse(ssm, parameters) { + const tagResults = new Map(); + await Promise.all(Object.keys(parameters).map(async (name) => { + const result = await isInUse(ssm, name); + if (result.size > 0) { + tagResults.set(name, result); + } + })); + if (tagResults.size > 0) { + const message = Object.entries(tagResults) + .map((result) => `${result[0]} is in use by stack(s) ${result[1].join(' ')}`) + .join('\n'); + throw new Error(`Exports cannot be updated: \n${message}`); + } +} +/** + * Check if a parameter is in use + */ +async function isInUse(ssm, parameterName) { + const tagResults = new Set(); + try { + const result = await ssm.listTagsForResource({ + ResourceId: parameterName, + ResourceType: 'Parameter', + }).promise(); + result.TagList?.forEach(tag => { + const tagParts = tag.Key.split(':'); + if (tagParts[0] === 'aws-cdk' && tagParts[1] === 'strong-ref') { + tagResults.add(tagParts[2]); + } + }); + } + catch (e) { + // an InvalidResourceId means that the parameter doesn't exist + // which we should ignore since that means it's not in use + if (e.code === 'InvalidResourceId') { + return new Set(); + } + throw e; + } + return tagResults; +} +/** + * Return only the items from source that do not exist in the filter + * + * @param source the source object to perform the filter on + * @param filter filter out items that exist in this object + * @returns any exports that don't exist in the filter + */ +function except(source, filter) { + return Object.keys(source) + .filter(key => (!filter.hasOwnProperty(key))) + .reduce((acc, curr) => { + acc[curr] = source[curr]; + return acc; + }, {}); +} +/** + * Return items that exist in both the the old parameters and the new parameters, + * but have different values + * + * @param oldParams the exports that existed previous to this execution + * @param newParams the exports for the current execution + * @returns any parameters that have different values + */ +function changed(oldParams, newParams) { + return Object.keys(oldParams) + .filter(key => (newParams.hasOwnProperty(key) && oldParams[key] !== newParams[key])) + .reduce((acc, curr) => { + acc.push(curr); + return acc; + }, []); +} +//# 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*/\n/* eslint-disable import/no-extraneous-dependencies */\nimport { SSM } from 'aws-sdk';\nimport { CrossRegionExports, ExportWriterCRProps } from '../types';\n\nexport async function handler(event: AWSLambda.CloudFormationCustomResourceEvent) {\n  const props: ExportWriterCRProps = event.ResourceProperties.WriterProps;\n  const exports = props.exports as CrossRegionExports;\n\n  const ssm = new SSM({ region: props.region });\n  try {\n    switch (event.RequestType) {\n      case 'Create':\n        console.info(`Creating new SSM Parameter exports in region ${props.region}`);\n        await throwIfAnyInUse(ssm, exports);\n        await putParameters(ssm, exports);\n        return;\n      case 'Update':\n        const oldProps: ExportWriterCRProps = event.OldResourceProperties.WriterProps;\n        const oldExports = oldProps.exports as CrossRegionExports;\n        const newExports = except(exports, oldExports);\n\n        // throw an error to fail the deployment if any export value is changing\n        const changedExports = changed(oldExports, exports);\n        if (changedExports.length > 0) {\n          throw new Error('Some exports have changed!\\n'+ changedExports.join('\\n'));\n        }\n        // if we are removing any exports that are in use, then throw an\n        // error to fail the deployment\n        const removedExports = except(oldExports, exports);\n        await throwIfAnyInUse(ssm, removedExports);\n        // if the ones we are removing are not in use then delete them\n        // skip if no export names are to be deleted\n        const removedExportsNames = Object.keys(removedExports);\n        if (removedExportsNames.length > 0) {\n          await ssm.deleteParameters({\n            Names: removedExportsNames,\n          }).promise();\n        }\n\n        // also throw an error if we are creating a new export that already exists for some reason\n        await throwIfAnyInUse(ssm, newExports);\n        console.info(`Creating new SSM Parameter exports in region ${props.region}`);\n        await putParameters(ssm, newExports);\n        return;\n      case 'Delete':\n        // if any of the exports are currently in use then throw an error to fail\n        // the stack deletion.\n        await throwIfAnyInUse(ssm, exports);\n        // if none are in use then delete all of them\n        await ssm.deleteParameters({\n          Names: Object.keys(exports),\n        }).promise();\n        return;\n      default:\n        return;\n    }\n  } catch (e) {\n    console.error('Error processing event: ', e);\n    throw e;\n  }\n};\n\n/**\n * Create parameters for existing exports\n */\nasync function putParameters(ssm: SSM, parameters: CrossRegionExports): Promise<void> {\n  await Promise.all(Array.from(Object.entries(parameters), ([name, value]) => {\n    return ssm.putParameter({\n      Name: name,\n      Value: value,\n      Type: 'String',\n    }).promise();\n  }));\n}\n\n/**\n * Query for existing parameters that are in use\n */\nasync function throwIfAnyInUse(ssm: SSM, parameters: CrossRegionExports): Promise<void> {\n  const tagResults: Map<string, Set<string>> = new Map();\n  await Promise.all(Object.keys(parameters).map(async (name: string) => {\n    const result = await isInUse(ssm, name);\n    if (result.size > 0) {\n      tagResults.set(name, result);\n    }\n  }));\n\n  if (tagResults.size > 0) {\n    const message: string = Object.entries(tagResults)\n      .map((result: [string, string[]]) => `${result[0]} is in use by stack(s) ${result[1].join(' ')}`)\n      .join('\\n');\n    throw new Error(`Exports cannot be updated: \\n${message}`);\n  }\n}\n\n/**\n * Check if a parameter is in use\n */\nasync function isInUse(ssm: SSM, parameterName: string): Promise<Set<string>> {\n  const tagResults: Set<string> = new Set();\n  try {\n    const result = await ssm.listTagsForResource({\n      ResourceId: parameterName,\n      ResourceType: 'Parameter',\n    }).promise();\n    result.TagList?.forEach(tag => {\n      const tagParts = tag.Key.split(':');\n      if (tagParts[0] === 'aws-cdk' && tagParts[1] === 'strong-ref') {\n        tagResults.add(tagParts[2]);\n      }\n    });\n  } catch (e: any) {\n    // an InvalidResourceId means that the parameter doesn't exist\n    // which we should ignore since that means it's not in use\n    if (e.code === 'InvalidResourceId') {\n      return new Set();\n    }\n    throw e;\n  }\n  return tagResults;\n}\n\n/**\n * Return only the items from source that do not exist in the filter\n *\n * @param source the source object to perform the filter on\n * @param filter filter out items that exist in this object\n * @returns any exports that don't exist in the filter\n */\nfunction except(source: CrossRegionExports, filter: CrossRegionExports): CrossRegionExports {\n  return Object.keys(source)\n    .filter(key => (!filter.hasOwnProperty(key)))\n    .reduce((acc: CrossRegionExports, curr: string) => {\n      acc[curr] = source[curr];\n      return acc;\n    }, {});\n}\n\n/**\n * Return items that exist in both the the old parameters and the new parameters,\n * but have different values\n *\n * @param oldParams the exports that existed previous to this execution\n * @param newParams the exports for the current execution\n * @returns any parameters that have different values\n */\nfunction changed(oldParams: CrossRegionExports, newParams: CrossRegionExports): string[] {\n  return Object.keys(oldParams)\n    .filter(key => (newParams.hasOwnProperty(key) && oldParams[key] !== newParams[key]))\n    .reduce((acc: string[], curr: string) => {\n      acc.push(curr);\n      return acc;\n    }, []);\n}\n"]} \ No newline at end of file diff --git a/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/asset.ae370e1010629b78f494346f49ceef3ab2875718f20e6c808114e6aa770c7bf3.bundle/index.js b/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/asset.ae370e1010629b78f494346f49ceef3ab2875718f20e6c808114e6aa770c7bf3.bundle/index.js new file mode 100644 index 0000000000000..a54f75c9c3747 --- /dev/null +++ b/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/asset.ae370e1010629b78f494346f49ceef3ab2875718f20e6c808114e6aa770c7bf3.bundle/index.js @@ -0,0 +1,1295 @@ +var __create = Object.create; +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __getProtoOf = Object.getPrototypeOf; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __esm = (fn, res) => function __init() { + return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res; +}; +var __commonJS = (cb, mod) => function __require() { + return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; +}; +var __export = (target, all) => { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); +}; +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; +}; +var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( + // If the importer is in node compatibility mode or this is not an ESM + // file that has been converted to a CommonJS file using a Babel- + // compatible transform (i.e. "__esModule" has not been set), then set + // "default" to the CommonJS "module.exports" for node compatibility. + isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, + mod +)); +var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); + +// ../../aws-cdk-lib/assertions/lib/matcher.ts +var matcher_exports = {}; +__export(matcher_exports, { + MatchResult: () => MatchResult, + Matcher: () => Matcher +}); +function* range(n) { + for (let i = 0; i < n; i++) { + yield i; + } +} +function* enumFirst(xs) { + let first = true; + for (const x of xs) { + yield [first, x]; + first = false; + } +} +var Matcher, MatchResult; +var init_matcher = __esm({ + "../../aws-cdk-lib/assertions/lib/matcher.ts"() { + "use strict"; + Matcher = class { + /** + * Check whether the provided object is a subtype of the `IMatcher`. + */ + static isMatcher(x) { + return x && x instanceof Matcher; + } + }; + MatchResult = class { + constructor(target) { + this.failuresHere = /* @__PURE__ */ new Map(); + this.captures = /* @__PURE__ */ new Map(); + this.finalized = false; + this.innerMatchFailures = /* @__PURE__ */ new Map(); + this._hasFailed = false; + this._failCount = 0; + this._cost = 0; + this.target = target; + } + /** + * DEPRECATED + * @deprecated use recordFailure() + */ + push(matcher, path, message) { + return this.recordFailure({ matcher, path, message }); + } + /** + * Record a new failure into this result at a specific path. + */ + recordFailure(failure) { + const failKey = failure.path.join("."); + let list = this.failuresHere.get(failKey); + if (!list) { + list = []; + this.failuresHere.set(failKey, list); + } + this._failCount += 1; + this._cost += failure.cost ?? 1; + list.push(failure); + this._hasFailed = true; + return this; + } + /** Whether the match is a success */ + get isSuccess() { + return !this._hasFailed; + } + /** Does the result contain any failures. If not, the result is a success */ + hasFailed() { + return this._hasFailed; + } + /** The number of failures */ + get failCount() { + return this._failCount; + } + /** The cost of the failures so far */ + get failCost() { + return this._cost; + } + /** + * Compose the results of a previous match as a subtree. + * @param id the id of the parent tree. + */ + compose(id, inner) { + if (inner.hasFailed()) { + this._hasFailed = true; + this._failCount += inner.failCount; + this._cost += inner._cost; + this.innerMatchFailures.set(id, inner); + } + inner.captures.forEach((vals, capture) => { + vals.forEach((value) => this.recordCapture({ capture, value })); + }); + return this; + } + /** + * Prepare the result to be analyzed. + * This API *must* be called prior to analyzing these results. + */ + finished() { + if (this.finalized) { + return this; + } + if (this.failCount === 0) { + this.captures.forEach((vals, cap) => cap._captured.push(...vals)); + } + this.finalized = true; + return this; + } + /** + * Render the failed match in a presentable way + * + * Prefer using `renderMismatch` over this method. It is left for backwards + * compatibility for test suites that expect it, but `renderMismatch()` will + * produce better output. + */ + toHumanStrings() { + const failures = new Array(); + debugger; + recurse(this, []); + return failures.map((r) => { + const loc = r.path.length === 0 ? "" : ` at /${r.path.join("/")}`; + return "" + r.message + loc + ` (using ${r.matcher.name} matcher)`; + }); + function recurse(x, prefix) { + for (const fail of Array.from(x.failuresHere.values()).flat()) { + failures.push({ + matcher: fail.matcher, + message: fail.message, + path: [...prefix, ...fail.path] + }); + } + for (const [key, inner] of x.innerMatchFailures.entries()) { + recurse(inner, [...prefix, key]); + } + } + } + /** + * Do a deep render of the match result, showing the structure mismatches in context + */ + renderMismatch() { + if (!this.hasFailed()) { + return ""; + } + const parts = new Array(); + const indents = new Array(); + emitFailures(this, ""); + recurse(this); + return moveMarkersToFront(parts.join("").trimEnd()); + function emit(x) { + if (x === void 0) { + debugger; + } + parts.push(x.replace(/\n/g, ` +${indents.join("")}`)); + } + function emitFailures(r, path, scrapSet) { + for (const fail of r.failuresHere.get(path) ?? []) { + emit(`!! ${fail.message} +`); + } + scrapSet == null ? void 0 : scrapSet.delete(path); + } + function recurse(r) { + const remainingFailures = new Set(Array.from(r.failuresHere.keys()).filter((x) => x !== "")); + if (Array.isArray(r.target)) { + indents.push(" "); + emit("[\n"); + for (const [first, i] of enumFirst(range(r.target.length))) { + if (!first) { + emit(",\n"); + } + emitFailures(r, `${i}`, remainingFailures); + const innerMatcher = r.innerMatchFailures.get(`${i}`); + if (innerMatcher) { + emitFailures(innerMatcher, ""); + recurseComparingValues(innerMatcher, r.target[i]); + } else { + emit(renderAbridged(r.target[i])); + } + } + emitRemaining(); + indents.pop(); + emit("\n]"); + return; + } + if (r.target && typeof r.target === "object") { + indents.push(" "); + emit("{\n"); + const keys = Array.from(/* @__PURE__ */ new Set([ + ...Object.keys(r.target), + ...Array.from(remainingFailures) + ])).sort(); + for (const [first, key] of enumFirst(keys)) { + if (!first) { + emit(",\n"); + } + emitFailures(r, key, remainingFailures); + const innerMatcher = r.innerMatchFailures.get(key); + if (innerMatcher) { + emitFailures(innerMatcher, ""); + emit(`${jsonify(key)}: `); + recurseComparingValues(innerMatcher, r.target[key]); + } else { + emit(`${jsonify(key)}: `); + emit(renderAbridged(r.target[key])); + } + } + emitRemaining(); + indents.pop(); + emit("\n}"); + return; + } + emitRemaining(); + emit(jsonify(r.target)); + function emitRemaining() { + if (remainingFailures.size > 0) { + emit("\n"); + } + for (const key of remainingFailures) { + emitFailures(r, key); + } + } + } + function recurseComparingValues(inner, actualValue) { + if (inner.target === actualValue) { + return recurse(inner); + } + emit(renderAbridged(actualValue)); + emit(" <*> "); + recurse(inner); + } + function renderAbridged(x) { + if (Array.isArray(x)) { + switch (x.length) { + case 0: + return "[]"; + case 1: + return `[ ${renderAbridged(x[0])} ]`; + case 2: + if (x.every((e) => ["number", "boolean", "string"].includes(typeof e))) { + return `[ ${x.map(renderAbridged).join(", ")} ]`; + } + return "[ ... ]"; + default: + return "[ ... ]"; + } + } + if (x && typeof x === "object") { + const keys = Object.keys(x); + switch (keys.length) { + case 0: + return "{}"; + case 1: + return `{ ${JSON.stringify(keys[0])}: ${renderAbridged(x[keys[0]])} }`; + default: + return "{ ... }"; + } + } + return jsonify(x); + } + function jsonify(x) { + return JSON.stringify(x) ?? "undefined"; + } + function moveMarkersToFront(x) { + const re = /^(\s+)!!/gm; + return x.replace(re, (_, spaces) => `!!${spaces.substring(0, spaces.length - 2)}`); + } + } + /** + * Record a capture against in this match result. + */ + recordCapture(options) { + let values = this.captures.get(options.capture); + if (values === void 0) { + values = []; + } + values.push(options.value); + this.captures.set(options.capture, values); + } + }; + } +}); + +// ../../aws-cdk-lib/assertions/lib/private/matchers/absent.ts +var AbsentMatch; +var init_absent = __esm({ + "../../aws-cdk-lib/assertions/lib/private/matchers/absent.ts"() { + "use strict"; + init_matcher(); + AbsentMatch = class extends Matcher { + constructor(name) { + super(); + this.name = name; + } + test(actual) { + const result = new MatchResult(actual); + if (actual !== void 0) { + result.recordFailure({ + matcher: this, + path: [], + message: `Received ${actual}, but key should be absent` + }); + } + return result; + } + }; + } +}); + +// ../../aws-cdk-lib/assertions/lib/private/sorting.ts +function sortKeyComparator(keyFn) { + return (a, b) => { + const ak = keyFn(a); + const bk = keyFn(b); + for (let i = 0; i < ak.length && i < bk.length; i++) { + const av = ak[i]; + const bv = bk[i]; + let diff = 0; + if (typeof av === "number" && typeof bv === "number") { + diff = av - bv; + } else if (typeof av === "string" && typeof bv === "string") { + diff = av.localeCompare(bv); + } + if (diff !== 0) { + return diff; + } + } + return bk.length - ak.length; + }; +} +var init_sorting = __esm({ + "../../aws-cdk-lib/assertions/lib/private/sorting.ts"() { + "use strict"; + } +}); + +// ../../aws-cdk-lib/assertions/lib/private/sparse-matrix.ts +var SparseMatrix; +var init_sparse_matrix = __esm({ + "../../aws-cdk-lib/assertions/lib/private/sparse-matrix.ts"() { + "use strict"; + SparseMatrix = class { + constructor() { + this.matrix = /* @__PURE__ */ new Map(); + } + get(row, col) { + var _a; + return (_a = this.matrix.get(row)) == null ? void 0 : _a.get(col); + } + row(row) { + var _a; + return Array.from(((_a = this.matrix.get(row)) == null ? void 0 : _a.entries()) ?? []); + } + set(row, col, value) { + let r = this.matrix.get(row); + if (!r) { + r = /* @__PURE__ */ new Map(); + this.matrix.set(row, r); + } + r.set(col, value); + } + }; + } +}); + +// ../../aws-cdk-lib/assertions/lib/private/type.ts +function getType(obj) { + return Array.isArray(obj) ? "array" : typeof obj; +} +var init_type = __esm({ + "../../aws-cdk-lib/assertions/lib/private/type.ts"() { + "use strict"; + } +}); + +// ../../aws-cdk-lib/assertions/lib/match.ts +var match_exports = {}; +__export(match_exports, { + Match: () => Match +}); +var Match, LiteralMatch, ArrayMatch, ObjectMatch, SerializedJson, NotMatch, AnyMatch, StringLikeRegexpMatch; +var init_match = __esm({ + "../../aws-cdk-lib/assertions/lib/match.ts"() { + "use strict"; + init_matcher(); + init_absent(); + init_sorting(); + init_sparse_matrix(); + init_type(); + Match = class { + /** + * Use this matcher in the place of a field's value, if the field must not be present. + */ + static absent() { + return new AbsentMatch("absent"); + } + /** + * Matches the specified pattern with the array found in the same relative path of the target. + * The set of elements (or matchers) must be in the same order as would be found. + * @param pattern the pattern to match + */ + static arrayWith(pattern) { + return new ArrayMatch("arrayWith", pattern); + } + /** + * Matches the specified pattern with the array found in the same relative path of the target. + * The set of elements (or matchers) must match exactly and in order. + * @param pattern the pattern to match + */ + static arrayEquals(pattern) { + return new ArrayMatch("arrayEquals", pattern, { subsequence: false }); + } + /** + * Deep exact matching of the specified pattern to the target. + * @param pattern the pattern to match + */ + static exact(pattern) { + return new LiteralMatch("exact", pattern, { partialObjects: false }); + } + /** + * Matches the specified pattern to an object found in the same relative path of the target. + * The keys and their values (or matchers) must be present in the target but the target can be a superset. + * @param pattern the pattern to match + */ + static objectLike(pattern) { + return new ObjectMatch("objectLike", pattern); + } + /** + * Matches the specified pattern to an object found in the same relative path of the target. + * The keys and their values (or matchers) must match exactly with the target. + * @param pattern the pattern to match + */ + static objectEquals(pattern) { + return new ObjectMatch("objectEquals", pattern, { partial: false }); + } + /** + * Matches any target which does NOT follow the specified pattern. + * @param pattern the pattern to NOT match + */ + static not(pattern) { + return new NotMatch("not", pattern); + } + /** + * Matches any string-encoded JSON and applies the specified pattern after parsing it. + * @param pattern the pattern to match after parsing the encoded JSON. + */ + static serializedJson(pattern) { + return new SerializedJson("serializedJson", pattern); + } + /** + * Matches any non-null value at the target. + */ + static anyValue() { + return new AnyMatch("anyValue"); + } + /** + * Matches targets according to a regular expression + */ + static stringLikeRegexp(pattern) { + return new StringLikeRegexpMatch("stringLikeRegexp", pattern); + } + }; + LiteralMatch = class extends Matcher { + constructor(name, pattern, options = {}) { + super(); + this.name = name; + this.pattern = pattern; + this.partialObjects = options.partialObjects ?? false; + if (Matcher.isMatcher(this.pattern)) { + throw new Error("LiteralMatch cannot directly contain another matcher. Remove the top-level matcher or nest it more deeply."); + } + } + test(actual) { + if (Array.isArray(this.pattern)) { + return new ArrayMatch(this.name, this.pattern, { subsequence: false, partialObjects: this.partialObjects }).test(actual); + } + if (typeof this.pattern === "object") { + return new ObjectMatch(this.name, this.pattern, { partial: this.partialObjects }).test(actual); + } + const result = new MatchResult(actual); + if (typeof this.pattern !== typeof actual) { + result.recordFailure({ + matcher: this, + path: [], + message: `Expected type ${typeof this.pattern} but received ${getType(actual)}` + }); + return result; + } + if (actual !== this.pattern) { + result.recordFailure({ + matcher: this, + path: [], + message: `Expected ${this.pattern} but received ${actual}` + }); + } + return result; + } + }; + ArrayMatch = class extends Matcher { + constructor(name, pattern, options = {}) { + super(); + this.name = name; + this.pattern = pattern; + this.subsequence = options.subsequence ?? true; + this.partialObjects = options.partialObjects ?? false; + } + test(actual) { + if (!Array.isArray(actual)) { + return new MatchResult(actual).recordFailure({ + matcher: this, + path: [], + message: `Expected type array but received ${getType(actual)}` + }); + } + return this.subsequence ? this.testSubsequence(actual) : this.testFullArray(actual); + } + testFullArray(actual) { + const result = new MatchResult(actual); + let i = 0; + for (; i < this.pattern.length && i < actual.length; i++) { + const patternElement = this.pattern[i]; + const matcher = Matcher.isMatcher(patternElement) ? patternElement : new LiteralMatch(this.name, patternElement, { partialObjects: this.partialObjects }); + const innerResult = matcher.test(actual[i]); + result.compose(`${i}`, innerResult); + } + if (i < this.pattern.length) { + result.recordFailure({ + matcher: this, + message: `Not enough elements in array (expecting ${this.pattern.length}, got ${actual.length})`, + path: [`${i}`] + }); + } + if (i < actual.length) { + result.recordFailure({ + matcher: this, + message: `Too many elements in array (expecting ${this.pattern.length}, got ${actual.length})`, + path: [`${i}`] + }); + } + return result; + } + testSubsequence(actual) { + const result = new MatchResult(actual); + let patternIdx = 0; + let actualIdx = 0; + const matches = new SparseMatrix(); + while (patternIdx < this.pattern.length && actualIdx < actual.length) { + const patternElement = this.pattern[patternIdx]; + const matcher = Matcher.isMatcher(patternElement) ? patternElement : new LiteralMatch(this.name, patternElement, { partialObjects: this.partialObjects }); + const matcherName = matcher.name; + if (matcherName == "absent" || matcherName == "anyValue") { + throw new Error(`The Matcher ${matcherName}() cannot be nested within arrayWith()`); + } + const innerResult = matcher.test(actual[actualIdx]); + matches.set(patternIdx, actualIdx, innerResult); + actualIdx++; + if (innerResult.isSuccess) { + result.compose(`${actualIdx}`, innerResult); + patternIdx++; + } + } + if (patternIdx < this.pattern.length) { + for (let spi = 0; spi < patternIdx; spi++) { + const foundMatch = matches.row(spi).find(([, r]) => r.isSuccess); + if (!foundMatch) { + continue; + } + const [index] = foundMatch; + result.compose(`${index}`, new MatchResult(actual[index]).recordFailure({ + matcher: this, + message: `arrayWith pattern ${spi} matched here`, + path: [], + cost: 0 + // This is an informational message so it would be unfair to assign it cost + })); + } + const failedMatches = matches.row(patternIdx); + failedMatches.sort(sortKeyComparator(([i, r]) => [r.failCost, i])); + if (failedMatches.length > 0) { + const [index, innerResult] = failedMatches[0]; + result.recordFailure({ + matcher: this, + message: `Could not match arrayWith pattern ${patternIdx}. This is the closest match`, + path: [`${index}`], + cost: 0 + // Informational message + }); + result.compose(`${index}`, innerResult); + } else { + result.recordFailure({ + matcher: this, + message: `Could not match arrayWith pattern ${patternIdx}. No more elements to try`, + path: [`${actual.length}`] + }); + } + } + return result; + } + }; + ObjectMatch = class extends Matcher { + constructor(name, pattern, options = {}) { + super(); + this.name = name; + this.pattern = pattern; + this.partial = options.partial ?? true; + } + test(actual) { + if (typeof actual !== "object" || Array.isArray(actual)) { + return new MatchResult(actual).recordFailure({ + matcher: this, + path: [], + message: `Expected type object but received ${getType(actual)}` + }); + } + const result = new MatchResult(actual); + if (!this.partial) { + for (const a of Object.keys(actual)) { + if (!(a in this.pattern)) { + result.recordFailure({ + matcher: this, + path: [a], + message: `Unexpected key ${a}` + }); + } + } + } + for (const [patternKey, patternVal] of Object.entries(this.pattern)) { + if (!(patternKey in actual) && !(patternVal instanceof AbsentMatch)) { + result.recordFailure({ + matcher: this, + path: [patternKey], + message: `Missing key '${patternKey}'` + }); + continue; + } + const matcher = Matcher.isMatcher(patternVal) ? patternVal : new LiteralMatch(this.name, patternVal, { partialObjects: this.partial }); + const inner = matcher.test(actual[patternKey]); + result.compose(patternKey, inner); + } + return result; + } + }; + SerializedJson = class extends Matcher { + constructor(name, pattern) { + super(); + this.name = name; + this.pattern = pattern; + } + test(actual) { + if (getType(actual) !== "string") { + return new MatchResult(actual).recordFailure({ + matcher: this, + path: [], + message: `Expected JSON as a string but found ${getType(actual)}` + }); + } + let parsed; + try { + parsed = JSON.parse(actual); + } catch (err) { + if (err instanceof SyntaxError) { + return new MatchResult(actual).recordFailure({ + matcher: this, + path: [], + message: `Invalid JSON string: ${actual}` + }); + } else { + throw err; + } + } + const matcher = Matcher.isMatcher(this.pattern) ? this.pattern : new LiteralMatch(this.name, this.pattern); + const innerResult = matcher.test(parsed); + if (innerResult.hasFailed()) { + innerResult.recordFailure({ + matcher: this, + path: [], + message: "Encoded JSON value does not match" + }); + } + return innerResult; + } + }; + NotMatch = class extends Matcher { + constructor(name, pattern) { + super(); + this.name = name; + this.pattern = pattern; + } + test(actual) { + const matcher = Matcher.isMatcher(this.pattern) ? this.pattern : new LiteralMatch(this.name, this.pattern); + const innerResult = matcher.test(actual); + const result = new MatchResult(actual); + if (innerResult.failCount === 0) { + result.recordFailure({ + matcher: this, + path: [], + message: `Found unexpected match: ${JSON.stringify(actual, void 0, 2)}` + }); + } + return result; + } + }; + AnyMatch = class extends Matcher { + constructor(name) { + super(); + this.name = name; + } + test(actual) { + const result = new MatchResult(actual); + if (actual == null) { + result.recordFailure({ + matcher: this, + path: [], + message: "Expected a value but found none" + }); + } + return result; + } + }; + StringLikeRegexpMatch = class extends Matcher { + constructor(name, pattern) { + super(); + this.name = name; + this.pattern = pattern; + } + test(actual) { + const result = new MatchResult(actual); + const regex = new RegExp(this.pattern, "gm"); + if (typeof actual !== "string") { + result.recordFailure({ + matcher: this, + path: [], + message: `Expected a string, but got '${typeof actual}'` + }); + } + if (!regex.test(actual)) { + result.recordFailure({ + matcher: this, + path: [], + message: `String '${actual}' did not match pattern '${this.pattern}'` + }); + } + return result; + } + }; + } +}); + +// ../../aws-cdk-lib/assertions/lib/helpers-internal/index.js +var require_helpers_internal = __commonJS({ + "../../aws-cdk-lib/assertions/lib/helpers-internal/index.js"(exports) { + "use strict"; + var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + o[k2] = m[k]; + }); + var __exportStar = exports && exports.__exportStar || function(m, exports2) { + for (var p in m) + if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) + __createBinding(exports2, m, p); + }; + Object.defineProperty(exports, "__esModule", { value: true }); + __exportStar((init_match(), __toCommonJS(match_exports)), exports); + __exportStar((init_matcher(), __toCommonJS(matcher_exports)), exports); + } +}); + +// lib/assertions/providers/lambda-handler/index.ts +var lambda_handler_exports = {}; +__export(lambda_handler_exports, { + handler: () => handler, + isComplete: () => isComplete, + onTimeout: () => onTimeout +}); +module.exports = __toCommonJS(lambda_handler_exports); + +// lib/assertions/providers/lambda-handler/assertion.ts +var import_helpers_internal = __toESM(require_helpers_internal()); + +// lib/assertions/providers/lambda-handler/base.ts +var https = __toESM(require("https")); +var url = __toESM(require("url")); +var AWS = __toESM(require("aws-sdk")); +var CustomResourceHandler = class { + constructor(event, context) { + this.event = event; + this.context = context; + this.timedOut = false; + this.timeout = setTimeout(async () => { + await this.respond({ + status: "FAILED", + reason: "Lambda Function Timeout", + data: this.context.logStreamName + }); + this.timedOut = true; + }, context.getRemainingTimeInMillis() - 1200); + this.event = event; + this.physicalResourceId = extractPhysicalResourceId(event); + } + /** + * Handles executing the custom resource event. If `stateMachineArn` is present + * in the props then trigger the waiter statemachine + */ + async handle() { + try { + if ("stateMachineArn" in this.event.ResourceProperties) { + const req = { + stateMachineArn: this.event.ResourceProperties.stateMachineArn, + name: this.event.RequestId, + input: JSON.stringify(this.event) + }; + await this.startExecution(req); + return; + } else { + const response = await this.processEvent(this.event.ResourceProperties); + return response; + } + } catch (e) { + console.log(e); + throw e; + } finally { + clearTimeout(this.timeout); + } + } + /** + * Handle async requests from the waiter state machine + */ + async handleIsComplete() { + try { + const result = await this.processEvent(this.event.ResourceProperties); + return result; + } catch (e) { + console.log(e); + return; + } finally { + clearTimeout(this.timeout); + } + } + /** + * Start a step function state machine which will wait for the request + * to be successful. + */ + async startExecution(req) { + try { + const sfn = new AWS.StepFunctions(); + await sfn.startExecution(req).promise(); + } finally { + clearTimeout(this.timeout); + } + } + respond(response) { + if (this.timedOut) { + return; + } + const cfResponse = { + Status: response.status, + Reason: response.reason, + PhysicalResourceId: this.physicalResourceId, + StackId: this.event.StackId, + RequestId: this.event.RequestId, + LogicalResourceId: this.event.LogicalResourceId, + NoEcho: false, + Data: response.data + }; + const responseBody = JSON.stringify(cfResponse); + console.log("Responding to CloudFormation", responseBody); + const parsedUrl = url.parse(this.event.ResponseURL); + const requestOptions = { + hostname: parsedUrl.hostname, + path: parsedUrl.path, + method: "PUT", + headers: { + "content-type": "", + "content-length": Buffer.byteLength(responseBody, "utf8") + } + }; + return new Promise((resolve, reject) => { + try { + const request2 = https.request(requestOptions, resolve); + request2.on("error", reject); + request2.write(responseBody); + request2.end(); + } catch (e) { + reject(e); + } finally { + clearTimeout(this.timeout); + } + }); + } +}; +function extractPhysicalResourceId(event) { + switch (event.RequestType) { + case "Create": + return event.LogicalResourceId; + case "Update": + case "Delete": + return event.PhysicalResourceId; + } +} + +// lib/assertions/providers/lambda-handler/assertion.ts +var AssertionHandler = class extends CustomResourceHandler { + async processEvent(request2) { + let actual = decodeCall(request2.actual); + const expected = decodeCall(request2.expected); + let result; + const matcher = new MatchCreator(expected).getMatcher(); + console.log(`Testing equality between ${JSON.stringify(request2.actual)} and ${JSON.stringify(request2.expected)}`); + const matchResult = matcher.test(actual); + matchResult.finished(); + if (matchResult.hasFailed()) { + result = { + failed: true, + assertion: JSON.stringify({ + status: "fail", + message: matchResult.renderMismatch() + }) + }; + if (request2.failDeployment) { + throw new Error(result.assertion); + } + } else { + result = { + assertion: JSON.stringify({ + status: "success" + }) + }; + } + return result; + } +}; +var MatchCreator = class { + constructor(obj) { + this.parsedObj = { + matcher: obj + }; + } + /** + * Return a Matcher that can be tested against the actual results. + * This will convert the encoded matchers into their corresponding + * assertions matcher. + * + * For example: + * + * ExpectedResult.objectLike({ + * Messages: [{ + * Body: Match.objectLike({ + * Elements: Match.arrayWith([{ Asdf: 3 }]), + * Payload: Match.serializedJson({ key: 'value' }), + * }), + * }], + * }); + * + * Will be encoded as: + * { + * $ObjectLike: { + * Messages: [{ + * Body: { + * $ObjectLike: { + * Elements: { + * $ArrayWith: [{ Asdf: 3 }], + * }, + * Payload: { + * $SerializedJson: { key: 'value' } + * } + * }, + * }, + * }], + * }, + * } + * + * Which can then be parsed by this function. For each key (recursively) + * the parser will check if the value has one of the encoded matchers as a key + * and if so, it will set the value as the Matcher. So, + * + * { + * Body: { + * $ObjectLike: { + * Elements: { + * $ArrayWith: [{ Asdf: 3 }], + * }, + * Payload: { + * $SerializedJson: { key: 'value' } + * } + * }, + * }, + * } + * + * Will be converted to + * { + * Body: Match.objectLike({ + * Elements: Match.arrayWith([{ Asdf: 3 }]), + * Payload: Match.serializedJson({ key: 'value' }), + * }), + * } + */ + getMatcher() { + try { + const final = JSON.parse(JSON.stringify(this.parsedObj), function(_k, v) { + const nested = Object.keys(v)[0]; + switch (nested) { + case "$ArrayWith": + return import_helpers_internal.Match.arrayWith(v[nested]); + case "$ObjectLike": + return import_helpers_internal.Match.objectLike(v[nested]); + case "$StringLike": + return import_helpers_internal.Match.stringLikeRegexp(v[nested]); + case "$SerializedJson": + return import_helpers_internal.Match.serializedJson(v[nested]); + default: + return v; + } + }); + if (import_helpers_internal.Matcher.isMatcher(final.matcher)) { + return final.matcher; + } + return import_helpers_internal.Match.exact(final.matcher); + } catch { + return import_helpers_internal.Match.exact(this.parsedObj.matcher); + } + } +}; +function decodeCall(call) { + if (!call) { + return void 0; + } + try { + const parsed = JSON.parse(call); + return parsed; + } catch { + return call; + } +} + +// lib/assertions/providers/lambda-handler/utils.ts +function decode(object) { + return JSON.parse(JSON.stringify(object), (_k, v) => { + switch (v) { + case "TRUE:BOOLEAN": + return true; + case "FALSE:BOOLEAN": + return false; + default: + return v; + } + }); +} + +// lib/assertions/providers/lambda-handler/sdk.ts +function flatten(object) { + return Object.assign( + {}, + ...function _flatten(child, path = []) { + return [].concat(...Object.keys(child).map((key) => { + let childKey = Buffer.isBuffer(child[key]) ? child[key].toString("utf8") : child[key]; + if (typeof childKey === "string") { + childKey = isJsonString(childKey); + } + return typeof childKey === "object" && childKey !== null ? _flatten(childKey, path.concat([key])) : { [path.concat([key]).join(".")]: childKey }; + })); + }(object) + ); +} +var AwsApiCallHandler = class extends CustomResourceHandler { + async processEvent(request2) { + const AWS2 = require("aws-sdk"); + console.log(`AWS SDK VERSION: ${AWS2.VERSION}`); + if (!Object.prototype.hasOwnProperty.call(AWS2, request2.service)) { + throw Error(`Service ${request2.service} does not exist in AWS SDK version ${AWS2.VERSION}.`); + } + const service = new AWS2[request2.service](); + const response = await service[request2.api](request2.parameters && decode(request2.parameters)).promise(); + console.log(`SDK response received ${JSON.stringify(response)}`); + delete response.ResponseMetadata; + const respond = { + apiCallResponse: response + }; + const flatData = { + ...flatten(respond) + }; + let resp = respond; + if (request2.outputPaths) { + resp = filterKeys(flatData, request2.outputPaths); + } else if (request2.flattenResponse === "true") { + resp = flatData; + } + console.log(`Returning result ${JSON.stringify(resp)}`); + return resp; + } +}; +function filterKeys(object, searchStrings) { + return Object.entries(object).reduce((filteredObject, [key, value]) => { + for (const searchString of searchStrings) { + if (key.startsWith(`apiCallResponse.${searchString}`)) { + filteredObject[key] = value; + } + } + return filteredObject; + }, {}); +} +function isJsonString(value) { + try { + return JSON.parse(value); + } catch { + return value; + } +} + +// lib/assertions/providers/lambda-handler/types.ts +var ASSERT_RESOURCE_TYPE = "Custom::DeployAssert@AssertEquals"; +var SDK_RESOURCE_TYPE_PREFIX = "Custom::DeployAssert@SdkCall"; + +// lib/assertions/providers/lambda-handler/index.ts +async function handler(event, context) { + console.log(`Event: ${JSON.stringify({ ...event, ResponseURL: "..." })}`); + const provider = createResourceHandler(event, context); + try { + if (event.RequestType === "Delete") { + await provider.respond({ + status: "SUCCESS", + reason: "OK" + }); + return; + } + const result = await provider.handle(); + if ("stateMachineArn" in event.ResourceProperties) { + console.info('Found "stateMachineArn", waiter statemachine started'); + return; + } else if ("expected" in event.ResourceProperties) { + console.info('Found "expected", testing assertions'); + const actualPath = event.ResourceProperties.actualPath; + const actual = actualPath ? result[`apiCallResponse.${actualPath}`] : result.apiCallResponse; + const assertion = new AssertionHandler({ + ...event, + ResourceProperties: { + ServiceToken: event.ServiceToken, + actual, + expected: event.ResourceProperties.expected + } + }, context); + try { + const assertionResult = await assertion.handle(); + await provider.respond({ + status: "SUCCESS", + reason: "OK", + // return both the result of the API call _and_ the assertion results + data: { + ...assertionResult, + ...result + } + }); + return; + } catch (e) { + await provider.respond({ + status: "FAILED", + reason: e.message ?? "Internal Error" + }); + return; + } + } + await provider.respond({ + status: "SUCCESS", + reason: "OK", + data: result + }); + } catch (e) { + await provider.respond({ + status: "FAILED", + reason: e.message ?? "Internal Error" + }); + return; + } + return; +} +async function onTimeout(timeoutEvent) { + const isCompleteRequest = JSON.parse(JSON.parse(timeoutEvent.Cause).errorMessage); + const provider = createResourceHandler(isCompleteRequest, standardContext); + await provider.respond({ + status: "FAILED", + reason: "Operation timed out: " + JSON.stringify(isCompleteRequest) + }); +} +async function isComplete(event, context) { + console.log(`Event: ${JSON.stringify({ ...event, ResponseURL: "..." })}`); + const provider = createResourceHandler(event, context); + try { + const result = await provider.handleIsComplete(); + const actualPath = event.ResourceProperties.actualPath; + if (result) { + const actual = actualPath ? result[`apiCallResponse.${actualPath}`] : result.apiCallResponse; + if ("expected" in event.ResourceProperties) { + const assertion = new AssertionHandler({ + ...event, + ResourceProperties: { + ServiceToken: event.ServiceToken, + actual, + expected: event.ResourceProperties.expected + } + }, context); + const assertionResult = await assertion.handleIsComplete(); + if (!(assertionResult == null ? void 0 : assertionResult.failed)) { + await provider.respond({ + status: "SUCCESS", + reason: "OK", + data: { + ...assertionResult, + ...result + } + }); + return; + } else { + console.log(`Assertion Failed: ${JSON.stringify(assertionResult)}`); + throw new Error(JSON.stringify(event)); + } + } + await provider.respond({ + status: "SUCCESS", + reason: "OK", + data: result + }); + } else { + console.log("No result"); + throw new Error(JSON.stringify(event)); + } + return; + } catch (e) { + console.log(e); + throw new Error(JSON.stringify(event)); + } +} +function createResourceHandler(event, context) { + if (event.ResourceType.startsWith(SDK_RESOURCE_TYPE_PREFIX)) { + return new AwsApiCallHandler(event, context); + } else if (event.ResourceType.startsWith(ASSERT_RESOURCE_TYPE)) { + return new AssertionHandler(event, context); + } else { + throw new Error(`Unsupported resource type "${event.ResourceType}`); + } +} +var standardContext = { + getRemainingTimeInMillis: () => 9e4 +}; +// Annotate the CommonJS export names for ESM import in node: +0 && (module.exports = { + handler, + isComplete, + onTimeout +}); diff --git a/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/asset.b54b99043c35bd080b9d9d1afce31e3541cf15b679799ba980ed40c837dcb03b.bundle/index.js b/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/asset.b54b99043c35bd080b9d9d1afce31e3541cf15b679799ba980ed40c837dcb03b.bundle/index.js deleted file mode 100644 index 2d6c2f0e85497..0000000000000 --- a/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/asset.b54b99043c35bd080b9d9d1afce31e3541cf15b679799ba980ed40c837dcb03b.bundle/index.js +++ /dev/null @@ -1,768 +0,0 @@ -"use strict"; -var __create = Object.create; -var __defProp = Object.defineProperty; -var __getOwnPropDesc = Object.getOwnPropertyDescriptor; -var __getOwnPropNames = Object.getOwnPropertyNames; -var __getProtoOf = Object.getPrototypeOf; -var __hasOwnProp = Object.prototype.hasOwnProperty; -var __export = (target, all) => { - for (var name in all) - __defProp(target, name, { get: all[name], enumerable: true }); -}; -var __copyProps = (to, from, except, desc) => { - if (from && typeof from === "object" || typeof from === "function") { - for (let key of __getOwnPropNames(from)) - if (!__hasOwnProp.call(to, key) && key !== except) - __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); - } - return to; -}; -var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( - isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, - mod -)); -var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); - -// lib/assertions/providers/lambda-handler/index.ts -var lambda_handler_exports = {}; -__export(lambda_handler_exports, { - handler: () => handler, - isComplete: () => isComplete, - onTimeout: () => onTimeout -}); -module.exports = __toCommonJS(lambda_handler_exports); - -// ../assertions/lib/matcher.ts -var Matcher = class { - static isMatcher(x) { - return x && x instanceof Matcher; - } -}; -var MatchResult = class { - constructor(target) { - this.failures = []; - this.captures = /* @__PURE__ */ new Map(); - this.finalized = false; - this.target = target; - } - push(matcher, path, message) { - return this.recordFailure({ matcher, path, message }); - } - recordFailure(failure) { - this.failures.push(failure); - return this; - } - hasFailed() { - return this.failures.length !== 0; - } - get failCount() { - return this.failures.length; - } - compose(id, inner) { - const innerF = inner.failures; - this.failures.push(...innerF.map((f) => { - return { path: [id, ...f.path], message: f.message, matcher: f.matcher }; - })); - inner.captures.forEach((vals, capture) => { - vals.forEach((value) => this.recordCapture({ capture, value })); - }); - return this; - } - finished() { - if (this.finalized) { - return this; - } - if (this.failCount === 0) { - this.captures.forEach((vals, cap) => cap._captured.push(...vals)); - } - this.finalized = true; - return this; - } - toHumanStrings() { - return this.failures.map((r) => { - const loc = r.path.length === 0 ? "" : ` at ${r.path.join("")}`; - return "" + r.message + loc + ` (using ${r.matcher.name} matcher)`; - }); - } - recordCapture(options) { - let values = this.captures.get(options.capture); - if (values === void 0) { - values = []; - } - values.push(options.value); - this.captures.set(options.capture, values); - } -}; - -// ../assertions/lib/private/matchers/absent.ts -var AbsentMatch = class extends Matcher { - constructor(name) { - super(); - this.name = name; - } - test(actual) { - const result = new MatchResult(actual); - if (actual !== void 0) { - result.recordFailure({ - matcher: this, - path: [], - message: `Received ${actual}, but key should be absent` - }); - } - return result; - } -}; - -// ../assertions/lib/private/type.ts -function getType(obj) { - return Array.isArray(obj) ? "array" : typeof obj; -} - -// ../assertions/lib/match.ts -var Match = class { - static absent() { - return new AbsentMatch("absent"); - } - static arrayWith(pattern) { - return new ArrayMatch("arrayWith", pattern); - } - static arrayEquals(pattern) { - return new ArrayMatch("arrayEquals", pattern, { subsequence: false }); - } - static exact(pattern) { - return new LiteralMatch("exact", pattern, { partialObjects: false }); - } - static objectLike(pattern) { - return new ObjectMatch("objectLike", pattern); - } - static objectEquals(pattern) { - return new ObjectMatch("objectEquals", pattern, { partial: false }); - } - static not(pattern) { - return new NotMatch("not", pattern); - } - static serializedJson(pattern) { - return new SerializedJson("serializedJson", pattern); - } - static anyValue() { - return new AnyMatch("anyValue"); - } - static stringLikeRegexp(pattern) { - return new StringLikeRegexpMatch("stringLikeRegexp", pattern); - } -}; -var LiteralMatch = class extends Matcher { - constructor(name, pattern, options = {}) { - super(); - this.name = name; - this.pattern = pattern; - this.partialObjects = options.partialObjects ?? false; - if (Matcher.isMatcher(this.pattern)) { - throw new Error("LiteralMatch cannot directly contain another matcher. Remove the top-level matcher or nest it more deeply."); - } - } - test(actual) { - if (Array.isArray(this.pattern)) { - return new ArrayMatch(this.name, this.pattern, { subsequence: false, partialObjects: this.partialObjects }).test(actual); - } - if (typeof this.pattern === "object") { - return new ObjectMatch(this.name, this.pattern, { partial: this.partialObjects }).test(actual); - } - const result = new MatchResult(actual); - if (typeof this.pattern !== typeof actual) { - result.recordFailure({ - matcher: this, - path: [], - message: `Expected type ${typeof this.pattern} but received ${getType(actual)}` - }); - return result; - } - if (actual !== this.pattern) { - result.recordFailure({ - matcher: this, - path: [], - message: `Expected ${this.pattern} but received ${actual}` - }); - } - return result; - } -}; -var ArrayMatch = class extends Matcher { - constructor(name, pattern, options = {}) { - super(); - this.name = name; - this.pattern = pattern; - this.subsequence = options.subsequence ?? true; - this.partialObjects = options.partialObjects ?? false; - } - test(actual) { - if (!Array.isArray(actual)) { - return new MatchResult(actual).recordFailure({ - matcher: this, - path: [], - message: `Expected type array but received ${getType(actual)}` - }); - } - if (!this.subsequence && this.pattern.length !== actual.length) { - return new MatchResult(actual).recordFailure({ - matcher: this, - path: [], - message: `Expected array of length ${this.pattern.length} but received ${actual.length}` - }); - } - let patternIdx = 0; - let actualIdx = 0; - const result = new MatchResult(actual); - while (patternIdx < this.pattern.length && actualIdx < actual.length) { - const patternElement = this.pattern[patternIdx]; - const matcher = Matcher.isMatcher(patternElement) ? patternElement : new LiteralMatch(this.name, patternElement, { partialObjects: this.partialObjects }); - const matcherName = matcher.name; - if (this.subsequence && (matcherName == "absent" || matcherName == "anyValue")) { - throw new Error(`The Matcher ${matcherName}() cannot be nested within arrayWith()`); - } - const innerResult = matcher.test(actual[actualIdx]); - if (!this.subsequence || !innerResult.hasFailed()) { - result.compose(`[${actualIdx}]`, innerResult); - patternIdx++; - actualIdx++; - } else { - actualIdx++; - } - } - for (; patternIdx < this.pattern.length; patternIdx++) { - const pattern = this.pattern[patternIdx]; - const element = Matcher.isMatcher(pattern) || typeof pattern === "object" ? " " : ` [${pattern}] `; - result.recordFailure({ - matcher: this, - path: [], - message: `Missing element${element}at pattern index ${patternIdx}` - }); - } - return result; - } -}; -var ObjectMatch = class extends Matcher { - constructor(name, pattern, options = {}) { - super(); - this.name = name; - this.pattern = pattern; - this.partial = options.partial ?? true; - } - test(actual) { - if (typeof actual !== "object" || Array.isArray(actual)) { - return new MatchResult(actual).recordFailure({ - matcher: this, - path: [], - message: `Expected type object but received ${getType(actual)}` - }); - } - const result = new MatchResult(actual); - if (!this.partial) { - for (const a of Object.keys(actual)) { - if (!(a in this.pattern)) { - result.recordFailure({ - matcher: this, - path: [`/${a}`], - message: "Unexpected key" - }); - } - } - } - for (const [patternKey, patternVal] of Object.entries(this.pattern)) { - if (!(patternKey in actual) && !(patternVal instanceof AbsentMatch)) { - result.recordFailure({ - matcher: this, - path: [`/${patternKey}`], - message: `Missing key '${patternKey}' among {${Object.keys(actual).join(",")}}` - }); - continue; - } - const matcher = Matcher.isMatcher(patternVal) ? patternVal : new LiteralMatch(this.name, patternVal, { partialObjects: this.partial }); - const inner = matcher.test(actual[patternKey]); - result.compose(`/${patternKey}`, inner); - } - return result; - } -}; -var SerializedJson = class extends Matcher { - constructor(name, pattern) { - super(); - this.name = name; - this.pattern = pattern; - } - test(actual) { - const result = new MatchResult(actual); - if (getType(actual) !== "string") { - result.recordFailure({ - matcher: this, - path: [], - message: `Expected JSON as a string but found ${getType(actual)}` - }); - return result; - } - let parsed; - try { - parsed = JSON.parse(actual); - } catch (err) { - if (err instanceof SyntaxError) { - result.recordFailure({ - matcher: this, - path: [], - message: `Invalid JSON string: ${actual}` - }); - return result; - } else { - throw err; - } - } - const matcher = Matcher.isMatcher(this.pattern) ? this.pattern : new LiteralMatch(this.name, this.pattern); - const innerResult = matcher.test(parsed); - result.compose(`(${this.name})`, innerResult); - return result; - } -}; -var NotMatch = class extends Matcher { - constructor(name, pattern) { - super(); - this.name = name; - this.pattern = pattern; - } - test(actual) { - const matcher = Matcher.isMatcher(this.pattern) ? this.pattern : new LiteralMatch(this.name, this.pattern); - const innerResult = matcher.test(actual); - const result = new MatchResult(actual); - if (innerResult.failCount === 0) { - result.recordFailure({ - matcher: this, - path: [], - message: `Found unexpected match: ${JSON.stringify(actual, void 0, 2)}` - }); - } - return result; - } -}; -var AnyMatch = class extends Matcher { - constructor(name) { - super(); - this.name = name; - } - test(actual) { - const result = new MatchResult(actual); - if (actual == null) { - result.recordFailure({ - matcher: this, - path: [], - message: "Expected a value but found none" - }); - } - return result; - } -}; -var StringLikeRegexpMatch = class extends Matcher { - constructor(name, pattern) { - super(); - this.name = name; - this.pattern = pattern; - } - test(actual) { - const result = new MatchResult(actual); - const regex = new RegExp(this.pattern, "gm"); - if (typeof actual !== "string") { - result.recordFailure({ - matcher: this, - path: [], - message: `Expected a string, but got '${typeof actual}'` - }); - } - if (!regex.test(actual)) { - result.recordFailure({ - matcher: this, - path: [], - message: `String '${actual}' did not match pattern '${this.pattern}'` - }); - } - return result; - } -}; - -// lib/assertions/providers/lambda-handler/base.ts -var https = __toESM(require("https")); -var url = __toESM(require("url")); -var AWS = __toESM(require("aws-sdk")); -var CustomResourceHandler = class { - constructor(event, context) { - this.event = event; - this.context = context; - this.timedOut = false; - this.timeout = setTimeout(async () => { - await this.respond({ - status: "FAILED", - reason: "Lambda Function Timeout", - data: this.context.logStreamName - }); - this.timedOut = true; - }, context.getRemainingTimeInMillis() - 1200); - this.event = event; - this.physicalResourceId = extractPhysicalResourceId(event); - } - async handle() { - try { - if ("stateMachineArn" in this.event.ResourceProperties) { - const req = { - stateMachineArn: this.event.ResourceProperties.stateMachineArn, - name: this.event.RequestId, - input: JSON.stringify(this.event) - }; - await this.startExecution(req); - return; - } else { - const response = await this.processEvent(this.event.ResourceProperties); - return response; - } - } catch (e) { - console.log(e); - throw e; - } finally { - clearTimeout(this.timeout); - } - } - async handleIsComplete() { - try { - const result = await this.processEvent(this.event.ResourceProperties); - return result; - } catch (e) { - console.log(e); - return; - } finally { - clearTimeout(this.timeout); - } - } - async startExecution(req) { - try { - const sfn = new AWS.StepFunctions(); - await sfn.startExecution(req).promise(); - } finally { - clearTimeout(this.timeout); - } - } - respond(response) { - if (this.timedOut) { - return; - } - const cfResponse = { - Status: response.status, - Reason: response.reason, - PhysicalResourceId: this.physicalResourceId, - StackId: this.event.StackId, - RequestId: this.event.RequestId, - LogicalResourceId: this.event.LogicalResourceId, - NoEcho: false, - Data: response.data - }; - const responseBody = JSON.stringify(cfResponse); - console.log("Responding to CloudFormation", responseBody); - const parsedUrl = url.parse(this.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 { - const request2 = https.request(requestOptions, resolve); - request2.on("error", reject); - request2.write(responseBody); - request2.end(); - } catch (e) { - reject(e); - } finally { - clearTimeout(this.timeout); - } - }); - } -}; -function extractPhysicalResourceId(event) { - switch (event.RequestType) { - case "Create": - return event.LogicalResourceId; - case "Update": - case "Delete": - return event.PhysicalResourceId; - } -} - -// lib/assertions/providers/lambda-handler/assertion.ts -var AssertionHandler = class extends CustomResourceHandler { - async processEvent(request2) { - let actual = decodeCall(request2.actual); - const expected = decodeCall(request2.expected); - let result; - const matcher = new MatchCreator(expected).getMatcher(); - console.log(`Testing equality between ${JSON.stringify(request2.actual)} and ${JSON.stringify(request2.expected)}`); - const matchResult = matcher.test(actual); - matchResult.finished(); - if (matchResult.hasFailed()) { - result = { - failed: true, - assertion: JSON.stringify({ - status: "fail", - message: [ - ...matchResult.toHumanStrings(), - JSON.stringify(matchResult.target, void 0, 2) - ].join("\n") - }) - }; - if (request2.failDeployment) { - throw new Error(result.assertion); - } - } else { - result = { - assertion: JSON.stringify({ - status: "success" - }) - }; - } - return result; - } -}; -var MatchCreator = class { - constructor(obj) { - this.parsedObj = { - matcher: obj - }; - } - getMatcher() { - try { - const final = JSON.parse(JSON.stringify(this.parsedObj), function(_k, v) { - const nested = Object.keys(v)[0]; - switch (nested) { - case "$ArrayWith": - return Match.arrayWith(v[nested]); - case "$ObjectLike": - return Match.objectLike(v[nested]); - case "$StringLike": - return Match.stringLikeRegexp(v[nested]); - default: - return v; - } - }); - if (Matcher.isMatcher(final.matcher)) { - return final.matcher; - } - return Match.exact(final.matcher); - } catch { - return Match.exact(this.parsedObj.matcher); - } - } -}; -function decodeCall(call) { - if (!call) { - return void 0; - } - try { - const parsed = JSON.parse(call); - return parsed; - } catch (e) { - return call; - } -} - -// lib/assertions/providers/lambda-handler/utils.ts -function decode(object) { - return JSON.parse(JSON.stringify(object), (_k, v) => { - switch (v) { - case "TRUE:BOOLEAN": - return true; - case "FALSE:BOOLEAN": - return false; - default: - return v; - } - }); -} - -// lib/assertions/providers/lambda-handler/sdk.ts -function flatten(object) { - return Object.assign( - {}, - ...function _flatten(child, path = []) { - return [].concat(...Object.keys(child).map((key) => { - let childKey = Buffer.isBuffer(child[key]) ? child[key].toString("utf8") : child[key]; - if (typeof childKey === "string") { - childKey = isJsonString(childKey); - } - return typeof childKey === "object" && childKey !== null ? _flatten(childKey, path.concat([key])) : { [path.concat([key]).join(".")]: childKey }; - })); - }(object) - ); -} -var AwsApiCallHandler = class extends CustomResourceHandler { - async processEvent(request2) { - const AWS2 = require("aws-sdk"); - console.log(`AWS SDK VERSION: ${AWS2.VERSION}`); - if (!Object.prototype.hasOwnProperty.call(AWS2, request2.service)) { - throw Error(`Service ${request2.service} does not exist in AWS SDK version ${AWS2.VERSION}.`); - } - const service = new AWS2[request2.service](); - const response = await service[request2.api](request2.parameters && decode(request2.parameters)).promise(); - console.log(`SDK response received ${JSON.stringify(response)}`); - delete response.ResponseMetadata; - const respond = { - apiCallResponse: response - }; - const flatData = { - ...flatten(respond) - }; - const resp = request2.flattenResponse === "true" ? flatData : respond; - console.log(`Returning result ${JSON.stringify(resp)}`); - return resp; - } -}; -function isJsonString(value) { - try { - return JSON.parse(value); - } catch { - return value; - } -} - -// lib/assertions/providers/lambda-handler/types.ts -var ASSERT_RESOURCE_TYPE = "Custom::DeployAssert@AssertEquals"; -var SDK_RESOURCE_TYPE_PREFIX = "Custom::DeployAssert@SdkCall"; - -// lib/assertions/providers/lambda-handler/index.ts -async function handler(event, context) { - console.log(`Event: ${JSON.stringify({ ...event, ResponseURL: "..." })}`); - const provider = createResourceHandler(event, context); - try { - if (event.RequestType === "Delete") { - await provider.respond({ - status: "SUCCESS", - reason: "OK" - }); - return; - } - const result = await provider.handle(); - if ("stateMachineArn" in event.ResourceProperties) { - console.info('Found "stateMachineArn", waiter statemachine started'); - return; - } else if ("expected" in event.ResourceProperties) { - console.info('Found "expected", testing assertions'); - const actualPath = event.ResourceProperties.actualPath; - const actual = actualPath ? result[`apiCallResponse.${actualPath}`] : result.apiCallResponse; - const assertion = new AssertionHandler({ - ...event, - ResourceProperties: { - ServiceToken: event.ServiceToken, - actual, - expected: event.ResourceProperties.expected - } - }, context); - try { - const assertionResult = await assertion.handle(); - await provider.respond({ - status: "SUCCESS", - reason: "OK", - data: { - ...assertionResult, - ...result - } - }); - return; - } catch (e) { - await provider.respond({ - status: "FAILED", - reason: e.message ?? "Internal Error" - }); - return; - } - } - await provider.respond({ - status: "SUCCESS", - reason: "OK", - data: result - }); - } catch (e) { - await provider.respond({ - status: "FAILED", - reason: e.message ?? "Internal Error" - }); - return; - } - return; -} -async function onTimeout(timeoutEvent) { - const isCompleteRequest = JSON.parse(JSON.parse(timeoutEvent.Cause).errorMessage); - const provider = createResourceHandler(isCompleteRequest, standardContext); - await provider.respond({ - status: "FAILED", - reason: "Operation timed out: " + JSON.stringify(isCompleteRequest) - }); -} -async function isComplete(event, context) { - console.log(`Event: ${JSON.stringify({ ...event, ResponseURL: "..." })}`); - const provider = createResourceHandler(event, context); - try { - const result = await provider.handleIsComplete(); - const actualPath = event.ResourceProperties.actualPath; - if (result) { - const actual = actualPath ? result[`apiCallResponse.${actualPath}`] : result.apiCallResponse; - if ("expected" in event.ResourceProperties) { - const assertion = new AssertionHandler({ - ...event, - ResourceProperties: { - ServiceToken: event.ServiceToken, - actual, - expected: event.ResourceProperties.expected - } - }, context); - const assertionResult = await assertion.handleIsComplete(); - if (!(assertionResult == null ? void 0 : assertionResult.failed)) { - await provider.respond({ - status: "SUCCESS", - reason: "OK", - data: { - ...assertionResult, - ...result - } - }); - return; - } else { - console.log(`Assertion Failed: ${JSON.stringify(assertionResult)}`); - throw new Error(JSON.stringify(event)); - } - } - await provider.respond({ - status: "SUCCESS", - reason: "OK", - data: result - }); - } else { - console.log("No result"); - throw new Error(JSON.stringify(event)); - } - return; - } catch (e) { - console.log(e); - throw new Error(JSON.stringify(event)); - } -} -function createResourceHandler(event, context) { - if (event.ResourceType.startsWith(SDK_RESOURCE_TYPE_PREFIX)) { - return new AwsApiCallHandler(event, context); - } else if (event.ResourceType.startsWith(ASSERT_RESOURCE_TYPE)) { - return new AssertionHandler(event, context); - } else { - throw new Error(`Unsupported resource type "${event.ResourceType}`); - } -} -var standardContext = { - getRemainingTimeInMillis: () => 9e4 -}; -// Annotate the CommonJS export names for ESM import in node: -0 && (module.exports = { - handler, - isComplete, - onTimeout -}); diff --git a/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/asset.f86f86755c3b2013542fc4f9405bfe145a86c0bec508dd0b37baabe2055d33f3/__entrypoint__.js b/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/asset.f86f86755c3b2013542fc4f9405bfe145a86c0bec508dd0b37baabe2055d33f3/__entrypoint__.js deleted file mode 100644 index 1e3a3093c1706..0000000000000 --- a/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/asset.f86f86755c3b2013542fc4f9405bfe145a86c0bec508dd0b37baabe2055d33f3/__entrypoint__.js +++ /dev/null @@ -1,144 +0,0 @@ -"use strict"; -Object.defineProperty(exports, "__esModule", { value: true }); -exports.withRetries = exports.handler = exports.external = void 0; -const https = require("https"); -const url = require("url"); -// for unit tests -exports.external = { - sendHttpRequest: defaultSendHttpRequest, - log: defaultLog, - includeStackTraces: true, - userHandlerIndex: './index', -}; -const CREATE_FAILED_PHYSICAL_ID_MARKER = 'AWSCDK::CustomResourceProviderFramework::CREATE_FAILED'; -const MISSING_PHYSICAL_ID_MARKER = 'AWSCDK::CustomResourceProviderFramework::MISSING_PHYSICAL_ID'; -async function handler(event, context) { - const sanitizedEvent = { ...event, ResponseURL: '...' }; - exports.external.log(JSON.stringify(sanitizedEvent, undefined, 2)); - // ignore DELETE event when the physical resource ID is the marker that - // indicates that this DELETE is a subsequent DELETE to a failed CREATE - // operation. - if (event.RequestType === 'Delete' && event.PhysicalResourceId === CREATE_FAILED_PHYSICAL_ID_MARKER) { - exports.external.log('ignoring DELETE event caused by a failed CREATE event'); - await submitResponse('SUCCESS', event); - return; - } - try { - // invoke the user handler. this is intentionally inside the try-catch to - // ensure that if there is an error it's reported as a failure to - // cloudformation (otherwise cfn waits). - // eslint-disable-next-line @typescript-eslint/no-require-imports - const userHandler = require(exports.external.userHandlerIndex).handler; - const result = await userHandler(sanitizedEvent, context); - // validate user response and create the combined event - const responseEvent = renderResponse(event, result); - // submit to cfn as success - await submitResponse('SUCCESS', responseEvent); - } - catch (e) { - const resp = { - ...event, - Reason: exports.external.includeStackTraces ? e.stack : e.message, - }; - if (!resp.PhysicalResourceId) { - // special case: if CREATE fails, which usually implies, we usually don't - // have a physical resource id. in this case, the subsequent DELETE - // operation does not have any meaning, and will likely fail as well. to - // address this, we use a marker so the provider framework can simply - // ignore the subsequent DELETE. - if (event.RequestType === 'Create') { - exports.external.log('CREATE failed, responding with a marker physical resource id so that the subsequent DELETE will be ignored'); - resp.PhysicalResourceId = CREATE_FAILED_PHYSICAL_ID_MARKER; - } - else { - // otherwise, if PhysicalResourceId is not specified, something is - // terribly wrong because all other events should have an ID. - exports.external.log(`ERROR: Malformed event. "PhysicalResourceId" is required: ${JSON.stringify(event)}`); - } - } - // this is an actual error, fail the activity altogether and exist. - await submitResponse('FAILED', resp); - } -} -exports.handler = handler; -function renderResponse(cfnRequest, handlerResponse = {}) { - // if physical ID is not returned, we have some defaults for you based - // on the request type. - const physicalResourceId = handlerResponse.PhysicalResourceId ?? cfnRequest.PhysicalResourceId ?? cfnRequest.RequestId; - // if we are in DELETE and physical ID was changed, it's an error. - if (cfnRequest.RequestType === 'Delete' && physicalResourceId !== cfnRequest.PhysicalResourceId) { - throw new Error(`DELETE: cannot change the physical resource ID from "${cfnRequest.PhysicalResourceId}" to "${handlerResponse.PhysicalResourceId}" during deletion`); - } - // merge request event and result event (result prevails). - return { - ...cfnRequest, - ...handlerResponse, - PhysicalResourceId: physicalResourceId, - }; -} -async function submitResponse(status, event) { - const json = { - Status: status, - Reason: event.Reason ?? status, - StackId: event.StackId, - RequestId: event.RequestId, - PhysicalResourceId: event.PhysicalResourceId || MISSING_PHYSICAL_ID_MARKER, - LogicalResourceId: event.LogicalResourceId, - NoEcho: event.NoEcho, - Data: event.Data, - }; - exports.external.log('submit response to cloudformation', json); - const responseBody = JSON.stringify(json); - const parsedUrl = url.parse(event.ResponseURL); - const req = { - hostname: parsedUrl.hostname, - path: parsedUrl.path, - method: 'PUT', - headers: { 'content-type': '', 'content-length': responseBody.length }, - }; - const retryOptions = { - attempts: 5, - sleep: 1000, - }; - await withRetries(retryOptions, exports.external.sendHttpRequest)(req, responseBody); -} -async function defaultSendHttpRequest(options, responseBody) { - return new Promise((resolve, reject) => { - try { - const request = https.request(options, _ => resolve()); - request.on('error', reject); - request.write(responseBody); - request.end(); - } - catch (e) { - reject(e); - } - }); -} -function defaultLog(fmt, ...params) { - // eslint-disable-next-line no-console - console.log(fmt, ...params); -} -function withRetries(options, fn) { - return async (...xs) => { - let attempts = options.attempts; - let ms = options.sleep; - while (true) { - try { - return await fn(...xs); - } - catch (e) { - if (attempts-- <= 0) { - throw e; - } - await sleep(Math.floor(Math.random() * ms)); - ms *= 2; - } - } - }; -} -exports.withRetries = withRetries; -async function sleep(ms) { - return new Promise((ok) => setTimeout(ok, ms)); -} -//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nodejs-entrypoint.js","sourceRoot":"","sources":["nodejs-entrypoint.ts"],"names":[],"mappings":"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","sourcesContent":["import * as https from 'https';\nimport * as url from 'url';\n\n// for unit tests\nexport const external = {\n  sendHttpRequest: defaultSendHttpRequest,\n  log: defaultLog,\n  includeStackTraces: true,\n  userHandlerIndex: './index',\n};\n\nconst CREATE_FAILED_PHYSICAL_ID_MARKER = 'AWSCDK::CustomResourceProviderFramework::CREATE_FAILED';\nconst MISSING_PHYSICAL_ID_MARKER = 'AWSCDK::CustomResourceProviderFramework::MISSING_PHYSICAL_ID';\n\nexport type Response = AWSLambda.CloudFormationCustomResourceEvent & HandlerResponse;\nexport type Handler = (event: AWSLambda.CloudFormationCustomResourceEvent, context: AWSLambda.Context) => Promise<HandlerResponse | void>;\nexport type HandlerResponse = undefined | {\n  Data?: any;\n  PhysicalResourceId?: string;\n  Reason?: string;\n  NoEcho?: boolean;\n};\n\nexport async function handler(event: AWSLambda.CloudFormationCustomResourceEvent, context: AWSLambda.Context) {\n  const sanitizedEvent = { ...event, ResponseURL: '...' };\n  external.log(JSON.stringify(sanitizedEvent, undefined, 2));\n\n  // ignore DELETE event when the physical resource ID is the marker that\n  // indicates that this DELETE is a subsequent DELETE to a failed CREATE\n  // operation.\n  if (event.RequestType === 'Delete' && event.PhysicalResourceId === CREATE_FAILED_PHYSICAL_ID_MARKER) {\n    external.log('ignoring DELETE event caused by a failed CREATE event');\n    await submitResponse('SUCCESS', event);\n    return;\n  }\n\n  try {\n    // invoke the user handler. this is intentionally inside the try-catch to\n    // ensure that if there is an error it's reported as a failure to\n    // cloudformation (otherwise cfn waits).\n    // eslint-disable-next-line @typescript-eslint/no-require-imports\n    const userHandler: Handler = require(external.userHandlerIndex).handler;\n    const result = await userHandler(sanitizedEvent, context);\n\n    // validate user response and create the combined event\n    const responseEvent = renderResponse(event, result);\n\n    // submit to cfn as success\n    await submitResponse('SUCCESS', responseEvent);\n  } catch (e) {\n    const resp: Response = {\n      ...event,\n      Reason: external.includeStackTraces ? e.stack : e.message,\n    };\n\n    if (!resp.PhysicalResourceId) {\n      // special case: if CREATE fails, which usually implies, we usually don't\n      // have a physical resource id. in this case, the subsequent DELETE\n      // operation does not have any meaning, and will likely fail as well. to\n      // address this, we use a marker so the provider framework can simply\n      // ignore the subsequent DELETE.\n      if (event.RequestType === 'Create') {\n        external.log('CREATE failed, responding with a marker physical resource id so that the subsequent DELETE will be ignored');\n        resp.PhysicalResourceId = CREATE_FAILED_PHYSICAL_ID_MARKER;\n      } else {\n        // otherwise, if PhysicalResourceId is not specified, something is\n        // terribly wrong because all other events should have an ID.\n        external.log(`ERROR: Malformed event. \"PhysicalResourceId\" is required: ${JSON.stringify(event)}`);\n      }\n    }\n\n    // this is an actual error, fail the activity altogether and exist.\n    await submitResponse('FAILED', resp);\n  }\n}\n\nfunction renderResponse(\n  cfnRequest: AWSLambda.CloudFormationCustomResourceEvent & { PhysicalResourceId?: string },\n  handlerResponse: void | HandlerResponse = { }): Response {\n\n  // if physical ID is not returned, we have some defaults for you based\n  // on the request type.\n  const physicalResourceId = handlerResponse.PhysicalResourceId ?? cfnRequest.PhysicalResourceId ?? cfnRequest.RequestId;\n\n  // if we are in DELETE and physical ID was changed, it's an error.\n  if (cfnRequest.RequestType === 'Delete' && physicalResourceId !== cfnRequest.PhysicalResourceId) {\n    throw new Error(`DELETE: cannot change the physical resource ID from \"${cfnRequest.PhysicalResourceId}\" to \"${handlerResponse.PhysicalResourceId}\" during deletion`);\n  }\n\n  // merge request event and result event (result prevails).\n  return {\n    ...cfnRequest,\n    ...handlerResponse,\n    PhysicalResourceId: physicalResourceId,\n  };\n}\n\nasync function submitResponse(status: 'SUCCESS' | 'FAILED', event: Response) {\n  const json: AWSLambda.CloudFormationCustomResourceResponse = {\n    Status: status,\n    Reason: event.Reason ?? status,\n    StackId: event.StackId,\n    RequestId: event.RequestId,\n    PhysicalResourceId: event.PhysicalResourceId || MISSING_PHYSICAL_ID_MARKER,\n    LogicalResourceId: event.LogicalResourceId,\n    NoEcho: event.NoEcho,\n    Data: event.Data,\n  };\n\n  external.log('submit response to cloudformation', json);\n\n  const responseBody = JSON.stringify(json);\n  const parsedUrl = url.parse(event.ResponseURL);\n  const req = {\n    hostname: parsedUrl.hostname,\n    path: parsedUrl.path,\n    method: 'PUT',\n    headers: { 'content-type': '', 'content-length': responseBody.length },\n  };\n\n  const retryOptions = {\n    attempts: 5,\n    sleep: 1000,\n  };\n  await withRetries(retryOptions, external.sendHttpRequest)(req, responseBody);\n}\n\nasync function defaultSendHttpRequest(options: https.RequestOptions, responseBody: string): Promise<void> {\n  return new Promise((resolve, reject) => {\n    try {\n      const request = https.request(options, _ => resolve());\n      request.on('error', reject);\n      request.write(responseBody);\n      request.end();\n    } catch (e) {\n      reject(e);\n    }\n  });\n}\n\nfunction defaultLog(fmt: string, ...params: any[]) {\n  // eslint-disable-next-line no-console\n  console.log(fmt, ...params);\n}\n\nexport interface RetryOptions {\n  /** How many retries (will at least try once) */\n  readonly attempts: number;\n  /** Sleep base, in ms */\n  readonly sleep: number;\n}\n\nexport function withRetries<A extends Array<any>, B>(options: RetryOptions, fn: (...xs: A) => Promise<B>): (...xs: A) => Promise<B> {\n  return async (...xs: A) => {\n    let attempts = options.attempts;\n    let ms = options.sleep;\n    while (true) {\n      try {\n        return await fn(...xs);\n      } catch (e) {\n        if (attempts-- <= 0) {\n          throw e;\n        }\n        await sleep(Math.floor(Math.random() * ms));\n        ms *= 2;\n      }\n    }\n  };\n}\n\nasync function sleep(ms: number): Promise<void> {\n  return new Promise((ok) => setTimeout(ok, ms));\n}"]} \ No newline at end of file diff --git a/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/asset.f86f86755c3b2013542fc4f9405bfe145a86c0bec508dd0b37baabe2055d33f3/index.js b/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/asset.f86f86755c3b2013542fc4f9405bfe145a86c0bec508dd0b37baabe2055d33f3/index.js deleted file mode 100644 index 9f71f540e4994..0000000000000 --- a/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/asset.f86f86755c3b2013542fc4f9405bfe145a86c0bec508dd0b37baabe2055d33f3/index.js +++ /dev/null @@ -1,148 +0,0 @@ -"use strict"; -Object.defineProperty(exports, "__esModule", { value: true }); -exports.handler = void 0; -/*eslint-disable no-console*/ -/* eslint-disable import/no-extraneous-dependencies */ -const aws_sdk_1 = require("aws-sdk"); -async function handler(event) { - const props = event.ResourceProperties.WriterProps; - const exports = props.exports; - const ssm = new aws_sdk_1.SSM({ region: props.region }); - try { - switch (event.RequestType) { - case 'Create': - console.info(`Creating new SSM Parameter exports in region ${props.region}`); - await throwIfAnyInUse(ssm, exports); - await putParameters(ssm, exports); - return; - case 'Update': - const oldProps = event.OldResourceProperties.WriterProps; - const oldExports = oldProps.exports; - const newExports = except(exports, oldExports); - // throw an error to fail the deployment if any export value is changing - const changedExports = changed(oldExports, exports); - if (changedExports.length > 0) { - throw new Error('Some exports have changed!\n' + changedExports.join('\n')); - } - // if we are removing any exports that are in use, then throw an - // error to fail the deployment - const removedExports = except(oldExports, exports); - await throwIfAnyInUse(ssm, removedExports); - // if the ones we are removing are not in use then delete them - await ssm.deleteParameters({ - Names: Object.keys(removedExports), - }).promise(); - // also throw an error if we are creating a new export that already exists for some reason - await throwIfAnyInUse(ssm, newExports); - console.info(`Creating new SSM Parameter exports in region ${props.region}`); - await putParameters(ssm, newExports); - return; - case 'Delete': - // if any of the exports are currently in use then throw an error to fail - // the stack deletion. - await throwIfAnyInUse(ssm, exports); - // if none are in use then delete all of them - await ssm.deleteParameters({ - Names: Object.keys(exports), - }).promise(); - return; - default: - return; - } - } - catch (e) { - console.error('Error processing event: ', e); - throw e; - } -} -exports.handler = handler; -; -/** - * Create parameters for existing exports - */ -async function putParameters(ssm, parameters) { - await Promise.all(Array.from(Object.entries(parameters), ([name, value]) => { - return ssm.putParameter({ - Name: name, - Value: value, - Type: 'String', - }).promise(); - })); -} -/** - * Query for existing parameters that are in use - */ -async function throwIfAnyInUse(ssm, parameters) { - const tagResults = new Map(); - await Promise.all(Object.keys(parameters).map(async (name) => { - const result = await isInUse(ssm, name); - if (result.size > 0) { - tagResults.set(name, result); - } - })); - if (tagResults.size > 0) { - const message = Object.entries(tagResults) - .map((result) => `${result[0]} is in use by stack(s) ${result[1].join(' ')}`) - .join('\n'); - throw new Error(`Exports cannot be updated: \n${message}`); - } -} -/** - * Check if a parameter is in use - */ -async function isInUse(ssm, parameterName) { - const tagResults = new Set(); - try { - const result = await ssm.listTagsForResource({ - ResourceId: parameterName, - ResourceType: 'Parameter', - }).promise(); - result.TagList?.forEach(tag => { - const tagParts = tag.Key.split(':'); - if (tagParts[0] === 'aws-cdk' && tagParts[1] === 'strong-ref') { - tagResults.add(tagParts[2]); - } - }); - } - catch (e) { - // an InvalidResourceId means that the parameter doesn't exist - // which we should ignore since that means it's not in use - if (e.code === 'InvalidResourceId') { - return new Set(); - } - throw e; - } - return tagResults; -} -/** - * Return only the items from source that do not exist in the filter - * - * @param source the source object to perform the filter on - * @param filter filter out items that exist in this object - * @returns any exports that don't exist in the filter - */ -function except(source, filter) { - return Object.keys(source) - .filter(key => (!filter.hasOwnProperty(key))) - .reduce((acc, curr) => { - acc[curr] = source[curr]; - return acc; - }, {}); -} -/** - * Return items that exist in both the the old parameters and the new parameters, - * but have different values - * - * @param oldParams the exports that existed previous to this execution - * @param newParams the exports for the current execution - * @returns any parameters that have different values - */ -function changed(oldParams, newParams) { - return Object.keys(oldParams) - .filter(key => (newParams.hasOwnProperty(key) && oldParams[key] !== newParams[key])) - .reduce((acc, curr) => { - acc.push(curr); - return acc; - }, []); -} -//# 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*/\n/* eslint-disable import/no-extraneous-dependencies */\nimport { SSM } from 'aws-sdk';\nimport { CrossRegionExports, ExportWriterCRProps } from '../types';\n\nexport async function handler(event: AWSLambda.CloudFormationCustomResourceEvent) {\n  const props: ExportWriterCRProps = event.ResourceProperties.WriterProps;\n  const exports = props.exports as CrossRegionExports;\n\n  const ssm = new SSM({ region: props.region });\n  try {\n    switch (event.RequestType) {\n      case 'Create':\n        console.info(`Creating new SSM Parameter exports in region ${props.region}`);\n        await throwIfAnyInUse(ssm, exports);\n        await putParameters(ssm, exports);\n        return;\n      case 'Update':\n        const oldProps: ExportWriterCRProps = event.OldResourceProperties.WriterProps;\n        const oldExports = oldProps.exports as CrossRegionExports;\n        const newExports = except(exports, oldExports);\n\n        // throw an error to fail the deployment if any export value is changing\n        const changedExports = changed(oldExports, exports);\n        if (changedExports.length > 0) {\n          throw new Error('Some exports have changed!\\n'+ changedExports.join('\\n'));\n        }\n        // if we are removing any exports that are in use, then throw an\n        // error to fail the deployment\n        const removedExports = except(oldExports, exports);\n        await throwIfAnyInUse(ssm, removedExports);\n        // if the ones we are removing are not in use then delete them\n        await ssm.deleteParameters({\n          Names: Object.keys(removedExports),\n        }).promise();\n\n        // also throw an error if we are creating a new export that already exists for some reason\n        await throwIfAnyInUse(ssm, newExports);\n        console.info(`Creating new SSM Parameter exports in region ${props.region}`);\n        await putParameters(ssm, newExports);\n        return;\n      case 'Delete':\n        // if any of the exports are currently in use then throw an error to fail\n        // the stack deletion.\n        await throwIfAnyInUse(ssm, exports);\n        // if none are in use then delete all of them\n        await ssm.deleteParameters({\n          Names: Object.keys(exports),\n        }).promise();\n        return;\n      default:\n        return;\n    }\n  } catch (e) {\n    console.error('Error processing event: ', e);\n    throw e;\n  }\n};\n\n/**\n * Create parameters for existing exports\n */\nasync function putParameters(ssm: SSM, parameters: CrossRegionExports): Promise<void> {\n  await Promise.all(Array.from(Object.entries(parameters), ([name, value]) => {\n    return ssm.putParameter({\n      Name: name,\n      Value: value,\n      Type: 'String',\n    }).promise();\n  }));\n}\n\n/**\n * Query for existing parameters that are in use\n */\nasync function throwIfAnyInUse(ssm: SSM, parameters: CrossRegionExports): Promise<void> {\n  const tagResults: Map<string, Set<string>> = new Map();\n  await Promise.all(Object.keys(parameters).map(async (name: string) => {\n    const result = await isInUse(ssm, name);\n    if (result.size > 0) {\n      tagResults.set(name, result);\n    }\n  }));\n\n  if (tagResults.size > 0) {\n    const message: string = Object.entries(tagResults)\n      .map((result: [string, string[]]) => `${result[0]} is in use by stack(s) ${result[1].join(' ')}`)\n      .join('\\n');\n    throw new Error(`Exports cannot be updated: \\n${message}`);\n  }\n}\n\n/**\n * Check if a parameter is in use\n */\nasync function isInUse(ssm: SSM, parameterName: string): Promise<Set<string>> {\n  const tagResults: Set<string> = new Set();\n  try {\n    const result = await ssm.listTagsForResource({\n      ResourceId: parameterName,\n      ResourceType: 'Parameter',\n    }).promise();\n    result.TagList?.forEach(tag => {\n      const tagParts = tag.Key.split(':');\n      if (tagParts[0] === 'aws-cdk' && tagParts[1] === 'strong-ref') {\n        tagResults.add(tagParts[2]);\n      }\n    });\n  } catch (e) {\n    // an InvalidResourceId means that the parameter doesn't exist\n    // which we should ignore since that means it's not in use\n    if (e.code === 'InvalidResourceId') {\n      return new Set();\n    }\n    throw e;\n  }\n  return tagResults;\n}\n\n/**\n * Return only the items from source that do not exist in the filter\n *\n * @param source the source object to perform the filter on\n * @param filter filter out items that exist in this object\n * @returns any exports that don't exist in the filter\n */\nfunction except(source: CrossRegionExports, filter: CrossRegionExports): CrossRegionExports {\n  return Object.keys(source)\n    .filter(key => (!filter.hasOwnProperty(key)))\n    .reduce((acc: CrossRegionExports, curr: string) => {\n      acc[curr] = source[curr];\n      return acc;\n    }, {});\n}\n\n/**\n * Return items that exist in both the the old parameters and the new parameters,\n * but have different values\n *\n * @param oldParams the exports that existed previous to this execution\n * @param newParams the exports for the current execution\n * @returns any parameters that have different values\n */\nfunction changed(oldParams: CrossRegionExports, newParams: CrossRegionExports): string[] {\n  return Object.keys(oldParams)\n    .filter(key => (newParams.hasOwnProperty(key) && oldParams[key] !== newParams[key]))\n    .reduce((acc: string[], curr: string) => {\n      acc.push(curr);\n      return acc;\n    }, []);\n}\n"]} \ No newline at end of file diff --git a/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/cdk.out b/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/cdk.out index 8ecc185e9dbee..7925065efbcc4 100644 --- a/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/cdk.out +++ b/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/cdk.out @@ -1 +1 @@ -{"version":"21.0.0"} \ No newline at end of file +{"version":"31.0.0"} \ No newline at end of file diff --git a/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/cross-region-consumer.assets.json b/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/cross-region-consumer.assets.json index 2eb2f3a9bf7f4..6dffbbd6fd060 100644 --- a/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/cross-region-consumer.assets.json +++ b/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/cross-region-consumer.assets.json @@ -1,15 +1,15 @@ { - "version": "21.0.0", + "version": "31.0.0", "files": { - "4607a5d8b4a4167cb2ff3c986ec884e3eb44c22626b7bce07ac9807730147741": { + "4b6a500a9b63c31028b69751201d80225328cfb9df5c4a6abaac18e7d4c48a8c": { "source": { - "path": "asset.4607a5d8b4a4167cb2ff3c986ec884e3eb44c22626b7bce07ac9807730147741", + "path": "asset.4b6a500a9b63c31028b69751201d80225328cfb9df5c4a6abaac18e7d4c48a8c", "packaging": "zip" }, "destinations": { "current_account-us-east-2": { "bucketName": "cdk-hnb659fds-assets-${AWS::AccountId}-us-east-2", - "objectKey": "4607a5d8b4a4167cb2ff3c986ec884e3eb44c22626b7bce07ac9807730147741.zip", + "objectKey": "4b6a500a9b63c31028b69751201d80225328cfb9df5c4a6abaac18e7d4c48a8c.zip", "region": "us-east-2", "assumeRoleArn": "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-hnb659fds-file-publishing-role-${AWS::AccountId}-us-east-2" } @@ -29,7 +29,7 @@ } } }, - "33212ba7662e584fce97d4b64b2b7d157f5f1bac2b2ffe4e25e18545b514ec8b": { + "6ca479488b1cdd2429244a95639246ddc89aaa458989ff2526645df63a2953b2": { "source": { "path": "cross-region-consumer.template.json", "packaging": "file" @@ -37,7 +37,7 @@ "destinations": { "current_account-us-east-2": { "bucketName": "cdk-hnb659fds-assets-${AWS::AccountId}-us-east-2", - "objectKey": "33212ba7662e584fce97d4b64b2b7d157f5f1bac2b2ffe4e25e18545b514ec8b.json", + "objectKey": "6ca479488b1cdd2429244a95639246ddc89aaa458989ff2526645df63a2953b2.json", "region": "us-east-2", "assumeRoleArn": "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-hnb659fds-file-publishing-role-${AWS::AccountId}-us-east-2" } diff --git a/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/cross-region-consumer.template.json b/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/cross-region-consumer.template.json index b441ed812b9b7..3841159a91e9e 100644 --- a/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/cross-region-consumer.template.json +++ b/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/cross-region-consumer.template.json @@ -143,7 +143,7 @@ "S3Bucket": { "Fn::Sub": "cdk-hnb659fds-assets-${AWS::AccountId}-us-east-2" }, - "S3Key": "4607a5d8b4a4167cb2ff3c986ec884e3eb44c22626b7bce07ac9807730147741.zip" + "S3Key": "4b6a500a9b63c31028b69751201d80225328cfb9df5c4a6abaac18e7d4c48a8c.zip" }, "Timeout": 900, "MemorySize": 128, diff --git a/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/cross-region-consumer2.assets.json b/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/cross-region-consumer2.assets.json new file mode 100644 index 0000000000000..92e259a65bed9 --- /dev/null +++ b/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/cross-region-consumer2.assets.json @@ -0,0 +1,48 @@ +{ + "version": "31.0.0", + "files": { + "4b6a500a9b63c31028b69751201d80225328cfb9df5c4a6abaac18e7d4c48a8c": { + "source": { + "path": "asset.4b6a500a9b63c31028b69751201d80225328cfb9df5c4a6abaac18e7d4c48a8c", + "packaging": "zip" + }, + "destinations": { + "current_account-us-west-2": { + "bucketName": "cdk-hnb659fds-assets-${AWS::AccountId}-us-west-2", + "objectKey": "4b6a500a9b63c31028b69751201d80225328cfb9df5c4a6abaac18e7d4c48a8c.zip", + "region": "us-west-2", + "assumeRoleArn": "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-hnb659fds-file-publishing-role-${AWS::AccountId}-us-west-2" + } + } + }, + "84d9dca339aba67f809c2fc9e42e0446ec4e7ed0bce437a58a7e4edabf6bdd02": { + "source": { + "path": "crossregionconsumer2IntegNested80DBA5D8.nested.template.json", + "packaging": "file" + }, + "destinations": { + "current_account-us-west-2": { + "bucketName": "cdk-hnb659fds-assets-${AWS::AccountId}-us-west-2", + "objectKey": "84d9dca339aba67f809c2fc9e42e0446ec4e7ed0bce437a58a7e4edabf6bdd02.json", + "region": "us-west-2", + "assumeRoleArn": "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-hnb659fds-file-publishing-role-${AWS::AccountId}-us-west-2" + } + } + }, + "7314b777fac2e8baea2214fe1ce9c17ad4b1ef6ce74c41da04349ea1c754d8f3": { + "source": { + "path": "cross-region-consumer2.template.json", + "packaging": "file" + }, + "destinations": { + "current_account-us-west-2": { + "bucketName": "cdk-hnb659fds-assets-${AWS::AccountId}-us-west-2", + "objectKey": "7314b777fac2e8baea2214fe1ce9c17ad4b1ef6ce74c41da04349ea1c754d8f3.json", + "region": "us-west-2", + "assumeRoleArn": "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-hnb659fds-file-publishing-role-${AWS::AccountId}-us-west-2" + } + } + } + }, + "dockerImages": {} +} \ No newline at end of file diff --git a/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/cross-region-consumer2.template.json b/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/cross-region-consumer2.template.json new file mode 100644 index 0000000000000..499825c5d542d --- /dev/null +++ b/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/cross-region-consumer2.template.json @@ -0,0 +1,198 @@ +{ + "Resources": { + "IntegNestedNestedStackIntegNestedNestedStackResource168C5881": { + "Type": "AWS::CloudFormation::Stack", + "Properties": { + "TemplateURL": { + "Fn::Join": [ + "", + [ + "https://s3.us-west-2.", + { + "Ref": "AWS::URLSuffix" + }, + "/", + { + "Fn::Sub": "cdk-hnb659fds-assets-${AWS::AccountId}-us-west-2" + }, + "/84d9dca339aba67f809c2fc9e42e0446ec4e7ed0bce437a58a7e4edabf6bdd02.json" + ] + ] + }, + "Parameters": { + "referencetocrossregionconsumer2ExportsReader29C6F905cdkexportscrossregionconsumer2crossregionproduceruseast1FnGetAttIntegQueue3A18718AQueueName8D8D3C9B": { + "Fn::GetAtt": [ + "ExportsReader8B249524", + "/cdk/exports/cross-region-consumer2/crossregionproduceruseast1FnGetAttIntegQueue3A18718AQueueName8D8D3C9B" + ] + }, + "referencetocrossregionconsumer2ExportsReader29C6F905cdkexportscrossregionconsumer2crossregionproduceruseast1FnGetAttIntegNestedNestedStackIntegNestedNestedStackResource168C5881OutputscrossregionproducerIntegNestedNestedIntegQueueD686DB69QueueNameC1C9C99E": { + "Fn::GetAtt": [ + "ExportsReader8B249524", + "/cdk/exports/cross-region-consumer2/crossregionproduceruseast1FnGetAttIntegNestedNestedStackIntegNestedNestedStackResource168C5881OutputscrossregionproducerIntegNestedNestedIntegQueueD686DB69QueueNameC1C9C99E" + ] + } + } + }, + "UpdateReplacePolicy": "Delete", + "DeletionPolicy": "Delete" + }, + "IntegParameter02A1817A4": { + "Type": "AWS::SSM::Parameter", + "Properties": { + "Type": "String", + "Value": { + "Fn::GetAtt": [ + "ExportsReader8B249524", + "/cdk/exports/cross-region-consumer2/crossregionproduceruseast1FnGetAttIntegQueue3A18718AQueueName8D8D3C9B" + ] + }, + "Name": "integ-parameter0" + } + }, + "IntegParameter1EDBEF1C6": { + "Type": "AWS::SSM::Parameter", + "Properties": { + "Type": "String", + "Value": { + "Fn::GetAtt": [ + "ExportsReader8B249524", + "/cdk/exports/cross-region-consumer2/crossregionproduceruseast1FnGetAttIntegNestedNestedStackIntegNestedNestedStackResource168C5881OutputscrossregionproducerIntegNestedNestedIntegQueueD686DB69QueueNameC1C9C99E" + ] + }, + "Name": "integ-parameter1" + } + }, + "ExportsReader8B249524": { + "Type": "Custom::CrossRegionExportReader", + "Properties": { + "ServiceToken": { + "Fn::GetAtt": [ + "CustomCrossRegionExportReaderCustomResourceProviderHandler46647B68", + "Arn" + ] + }, + "ReaderProps": { + "region": "us-west-2", + "prefix": "cross-region-consumer2", + "imports": { + "/cdk/exports/cross-region-consumer2/crossregionproduceruseast1FnGetAttIntegQueue3A18718AQueueName8D8D3C9B": "{{resolve:ssm:/cdk/exports/cross-region-consumer2/crossregionproduceruseast1FnGetAttIntegQueue3A18718AQueueName8D8D3C9B}}", + "/cdk/exports/cross-region-consumer2/crossregionproduceruseast1FnGetAttIntegNestedNestedStackIntegNestedNestedStackResource168C5881OutputscrossregionproducerIntegNestedNestedIntegQueueD686DB69QueueNameC1C9C99E": "{{resolve:ssm:/cdk/exports/cross-region-consumer2/crossregionproduceruseast1FnGetAttIntegNestedNestedStackIntegNestedNestedStackResource168C5881OutputscrossregionproducerIntegNestedNestedIntegQueueD686DB69QueueNameC1C9C99E}}" + } + } + }, + "UpdateReplacePolicy": "Delete", + "DeletionPolicy": "Delete" + }, + "CustomCrossRegionExportReaderCustomResourceProviderRole10531BBD": { + "Type": "AWS::IAM::Role", + "Properties": { + "AssumeRolePolicyDocument": { + "Version": "2012-10-17", + "Statement": [ + { + "Action": "sts:AssumeRole", + "Effect": "Allow", + "Principal": { + "Service": "lambda.amazonaws.com" + } + } + ] + }, + "ManagedPolicyArns": [ + { + "Fn::Sub": "arn:${AWS::Partition}:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole" + } + ], + "Policies": [ + { + "PolicyName": "Inline", + "PolicyDocument": { + "Version": "2012-10-17", + "Statement": [ + { + "Effect": "Allow", + "Resource": { + "Fn::Join": [ + "", + [ + "arn:aws:ssm:us-west-2:", + { + "Ref": "AWS::AccountId" + }, + ":parameter/cdk/exports/cross-region-consumer2/*" + ] + ] + }, + "Action": [ + "ssm:AddTagsToResource", + "ssm:RemoveTagsFromResource", + "ssm:GetParameters" + ] + } + ] + } + } + ] + } + }, + "CustomCrossRegionExportReaderCustomResourceProviderHandler46647B68": { + "Type": "AWS::Lambda::Function", + "Properties": { + "Code": { + "S3Bucket": { + "Fn::Sub": "cdk-hnb659fds-assets-${AWS::AccountId}-us-west-2" + }, + "S3Key": "4b6a500a9b63c31028b69751201d80225328cfb9df5c4a6abaac18e7d4c48a8c.zip" + }, + "Timeout": 900, + "MemorySize": 128, + "Handler": "__entrypoint__.handler", + "Role": { + "Fn::GetAtt": [ + "CustomCrossRegionExportReaderCustomResourceProviderRole10531BBD", + "Arn" + ] + }, + "Runtime": "nodejs14.x" + }, + "DependsOn": [ + "CustomCrossRegionExportReaderCustomResourceProviderRole10531BBD" + ] + } + }, + "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-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/cross-region-producer.assets.json b/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/cross-region-producer.assets.json index a98a88fd5f9f8..7f6baff4ca902 100644 --- a/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/cross-region-producer.assets.json +++ b/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/cross-region-producer.assets.json @@ -1,15 +1,15 @@ { - "version": "21.0.0", + "version": "31.0.0", "files": { - "f86f86755c3b2013542fc4f9405bfe145a86c0bec508dd0b37baabe2055d33f3": { + "27f8287125ebe89b1cb7f97768a61c84b3f3221450e0a22c152addc630ab2430": { "source": { - "path": "asset.f86f86755c3b2013542fc4f9405bfe145a86c0bec508dd0b37baabe2055d33f3", + "path": "asset.27f8287125ebe89b1cb7f97768a61c84b3f3221450e0a22c152addc630ab2430", "packaging": "zip" }, "destinations": { "current_account-us-east-1": { "bucketName": "cdk-hnb659fds-assets-${AWS::AccountId}-us-east-1", - "objectKey": "f86f86755c3b2013542fc4f9405bfe145a86c0bec508dd0b37baabe2055d33f3.zip", + "objectKey": "27f8287125ebe89b1cb7f97768a61c84b3f3221450e0a22c152addc630ab2430.zip", "region": "us-east-1", "assumeRoleArn": "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-hnb659fds-file-publishing-role-${AWS::AccountId}-us-east-1" } @@ -29,7 +29,7 @@ } } }, - "70e0b1af0ea278adf024d80a32c2797554d527123f1dc1eb9f2a894a6d46bc7a": { + "f4f423c120bb2c3118761133362f056c498404cb31d1528f2ea55ebc825579df": { "source": { "path": "cross-region-producer.template.json", "packaging": "file" @@ -37,7 +37,7 @@ "destinations": { "current_account-us-east-1": { "bucketName": "cdk-hnb659fds-assets-${AWS::AccountId}-us-east-1", - "objectKey": "70e0b1af0ea278adf024d80a32c2797554d527123f1dc1eb9f2a894a6d46bc7a.json", + "objectKey": "f4f423c120bb2c3118761133362f056c498404cb31d1528f2ea55ebc825579df.json", "region": "us-east-1", "assumeRoleArn": "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-hnb659fds-file-publishing-role-${AWS::AccountId}-us-east-1" } diff --git a/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/cross-region-producer.template.json b/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/cross-region-producer.template.json index f0b15d4ab2e9e..782a116d8e548 100644 --- a/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/cross-region-producer.template.json +++ b/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/cross-region-producer.template.json @@ -104,6 +104,174 @@ "ssm:GetParameters", "ssm:PutParameter" ] + }, + { + "Effect": "Allow", + "Resource": { + "Fn::Join": [ + "", + [ + "arn:aws:ssm:us-east-2:", + { + "Ref": "AWS::AccountId" + }, + ":parameter/cdk/exports/*" + ] + ] + }, + "Action": [ + "ssm:DeleteParameters", + "ssm:ListTagsForResource", + "ssm:GetParameters", + "ssm:PutParameter" + ] + }, + { + "Effect": "Allow", + "Resource": { + "Fn::Join": [ + "", + [ + "arn:aws:ssm:us-east-2:", + { + "Ref": "AWS::AccountId" + }, + ":parameter/cdk/exports/*" + ] + ] + }, + "Action": [ + "ssm:DeleteParameters", + "ssm:ListTagsForResource", + "ssm:GetParameters", + "ssm:PutParameter" + ] + }, + { + "Effect": "Allow", + "Resource": { + "Fn::Join": [ + "", + [ + "arn:aws:ssm:us-east-2:", + { + "Ref": "AWS::AccountId" + }, + ":parameter/cdk/exports/*" + ] + ] + }, + "Action": [ + "ssm:DeleteParameters", + "ssm:ListTagsForResource", + "ssm:GetParameters", + "ssm:PutParameter" + ] + }, + { + "Effect": "Allow", + "Resource": { + "Fn::Join": [ + "", + [ + "arn:aws:ssm:us-east-2:", + { + "Ref": "AWS::AccountId" + }, + ":parameter/cdk/exports/*" + ] + ] + }, + "Action": [ + "ssm:DeleteParameters", + "ssm:ListTagsForResource", + "ssm:GetParameters", + "ssm:PutParameter" + ] + }, + { + "Effect": "Allow", + "Resource": { + "Fn::Join": [ + "", + [ + "arn:aws:ssm:us-west-2:", + { + "Ref": "AWS::AccountId" + }, + ":parameter/cdk/exports/*" + ] + ] + }, + "Action": [ + "ssm:DeleteParameters", + "ssm:ListTagsForResource", + "ssm:GetParameters", + "ssm:PutParameter" + ] + }, + { + "Effect": "Allow", + "Resource": { + "Fn::Join": [ + "", + [ + "arn:aws:ssm:us-west-2:", + { + "Ref": "AWS::AccountId" + }, + ":parameter/cdk/exports/*" + ] + ] + }, + "Action": [ + "ssm:DeleteParameters", + "ssm:ListTagsForResource", + "ssm:GetParameters", + "ssm:PutParameter" + ] + }, + { + "Effect": "Allow", + "Resource": { + "Fn::Join": [ + "", + [ + "arn:aws:ssm:us-west-2:", + { + "Ref": "AWS::AccountId" + }, + ":parameter/cdk/exports/*" + ] + ] + }, + "Action": [ + "ssm:DeleteParameters", + "ssm:ListTagsForResource", + "ssm:GetParameters", + "ssm:PutParameter" + ] + }, + { + "Effect": "Allow", + "Resource": { + "Fn::Join": [ + "", + [ + "arn:aws:ssm:us-west-2:", + { + "Ref": "AWS::AccountId" + }, + ":parameter/cdk/exports/*" + ] + ] + }, + "Action": [ + "ssm:DeleteParameters", + "ssm:ListTagsForResource", + "ssm:GetParameters", + "ssm:PutParameter" + ] } ] } @@ -118,7 +286,7 @@ "S3Bucket": { "Fn::Sub": "cdk-hnb659fds-assets-${AWS::AccountId}-us-east-1" }, - "S3Key": "f86f86755c3b2013542fc4f9405bfe145a86c0bec508dd0b37baabe2055d33f3.zip" + "S3Key": "27f8287125ebe89b1cb7f97768a61c84b3f3221450e0a22c152addc630ab2430.zip" }, "Timeout": 900, "MemorySize": 128, @@ -134,6 +302,36 @@ "DependsOn": [ "CustomCrossRegionExportWriterCustomResourceProviderRoleC951B1E1" ] + }, + "ExportsWriteruswest209BD44F0A7CF058B": { + "Type": "Custom::CrossRegionExportWriter", + "Properties": { + "ServiceToken": { + "Fn::GetAtt": [ + "CustomCrossRegionExportWriterCustomResourceProviderHandlerD8786E8A", + "Arn" + ] + }, + "WriterProps": { + "region": "us-west-2", + "exports": { + "/cdk/exports/cross-region-consumer2/crossregionproduceruseast1FnGetAttIntegQueue3A18718AQueueName8D8D3C9B": { + "Fn::GetAtt": [ + "IntegQueue3A18718A", + "QueueName" + ] + }, + "/cdk/exports/cross-region-consumer2/crossregionproduceruseast1FnGetAttIntegNestedNestedStackIntegNestedNestedStackResource168C5881OutputscrossregionproducerIntegNestedNestedIntegQueueD686DB69QueueNameC1C9C99E": { + "Fn::GetAtt": [ + "IntegNestedNestedStackIntegNestedNestedStackResource168C5881", + "Outputs.crossregionproducerIntegNestedNestedIntegQueueD686DB69QueueName" + ] + } + } + } + }, + "UpdateReplacePolicy": "Delete", + "DeletionPolicy": "Delete" } }, "Parameters": { diff --git a/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/crossregionconsumer2IntegNested80DBA5D8.nested.template.json b/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/crossregionconsumer2IntegNested80DBA5D8.nested.template.json new file mode 100644 index 0000000000000..46c7a9f12fccc --- /dev/null +++ b/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/crossregionconsumer2IntegNested80DBA5D8.nested.template.json @@ -0,0 +1,32 @@ +{ + "Resources": { + "IntegNestedParameter04B9B8A01": { + "Type": "AWS::SSM::Parameter", + "Properties": { + "Type": "String", + "Value": { + "Ref": "referencetocrossregionconsumer2ExportsReader29C6F905cdkexportscrossregionconsumer2crossregionproduceruseast1FnGetAttIntegQueue3A18718AQueueName8D8D3C9B" + }, + "Name": "integ-nested-parameter0" + } + }, + "IntegNestedParameter1DE6274D4": { + "Type": "AWS::SSM::Parameter", + "Properties": { + "Type": "String", + "Value": { + "Ref": "referencetocrossregionconsumer2ExportsReader29C6F905cdkexportscrossregionconsumer2crossregionproduceruseast1FnGetAttIntegNestedNestedStackIntegNestedNestedStackResource168C5881OutputscrossregionproducerIntegNestedNestedIntegQueueD686DB69QueueNameC1C9C99E" + }, + "Name": "integ-nested-parameter1" + } + } + }, + "Parameters": { + "referencetocrossregionconsumer2ExportsReader29C6F905cdkexportscrossregionconsumer2crossregionproduceruseast1FnGetAttIntegQueue3A18718AQueueName8D8D3C9B": { + "Type": "String" + }, + "referencetocrossregionconsumer2ExportsReader29C6F905cdkexportscrossregionconsumer2crossregionproduceruseast1FnGetAttIntegNestedNestedStackIntegNestedNestedStackResource168C5881OutputscrossregionproducerIntegNestedNestedIntegQueueD686DB69QueueNameC1C9C99E": { + "Type": "String" + } + } +} \ No newline at end of file diff --git a/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/crossregionreferencesDefaultTestDeployAssertAB7415FD.assets.json b/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/crossregionreferencesDefaultTestDeployAssertAB7415FD.assets.json index 3d31b494852c6..04c47104469f6 100644 --- a/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/crossregionreferencesDefaultTestDeployAssertAB7415FD.assets.json +++ b/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/crossregionreferencesDefaultTestDeployAssertAB7415FD.assets.json @@ -1,20 +1,20 @@ { - "version": "21.0.0", + "version": "31.0.0", "files": { - "b54b99043c35bd080b9d9d1afce31e3541cf15b679799ba980ed40c837dcb03b": { + "ae370e1010629b78f494346f49ceef3ab2875718f20e6c808114e6aa770c7bf3": { "source": { - "path": "asset.b54b99043c35bd080b9d9d1afce31e3541cf15b679799ba980ed40c837dcb03b.bundle", + "path": "asset.ae370e1010629b78f494346f49ceef3ab2875718f20e6c808114e6aa770c7bf3.bundle", "packaging": "zip" }, "destinations": { "current_account-current_region": { "bucketName": "cdk-hnb659fds-assets-${AWS::AccountId}-${AWS::Region}", - "objectKey": "b54b99043c35bd080b9d9d1afce31e3541cf15b679799ba980ed40c837dcb03b.zip", + "objectKey": "ae370e1010629b78f494346f49ceef3ab2875718f20e6c808114e6aa770c7bf3.zip", "assumeRoleArn": "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-hnb659fds-file-publishing-role-${AWS::AccountId}-${AWS::Region}" } } }, - "e62b4ad819f8f21c0c8707091f053b8b322398afc1a04fd089b1be1436fb011a": { + "d8798dd0bd8b18d69bd299a0773560da86b4fff407a6c7f4f481ac2cfa4ec54b": { "source": { "path": "crossregionreferencesDefaultTestDeployAssertAB7415FD.template.json", "packaging": "file" @@ -22,7 +22,7 @@ "destinations": { "current_account-current_region": { "bucketName": "cdk-hnb659fds-assets-${AWS::AccountId}-${AWS::Region}", - "objectKey": "e62b4ad819f8f21c0c8707091f053b8b322398afc1a04fd089b1be1436fb011a.json", + "objectKey": "d8798dd0bd8b18d69bd299a0773560da86b4fff407a6c7f4f481ac2cfa4ec54b.json", "assumeRoleArn": "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-hnb659fds-file-publishing-role-${AWS::AccountId}-${AWS::Region}" } } diff --git a/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/crossregionreferencesDefaultTestDeployAssertAB7415FD.template.json b/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/crossregionreferencesDefaultTestDeployAssertAB7415FD.template.json index cb2253ab681b4..56d3ca558e55e 100644 --- a/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/crossregionreferencesDefaultTestDeployAssertAB7415FD.template.json +++ b/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/crossregionreferencesDefaultTestDeployAssertAB7415FD.template.json @@ -15,7 +15,7 @@ "StackName": "cross-region-producer" }, "flattenResponse": "false", - "salt": "1666292907086" + "salt": "1681912047073" }, "UpdateReplacePolicy": "Delete", "DeletionPolicy": "Delete" @@ -87,7 +87,7 @@ "S3Bucket": { "Fn::Sub": "cdk-hnb659fds-assets-${AWS::AccountId}-${AWS::Region}" }, - "S3Key": "b54b99043c35bd080b9d9d1afce31e3541cf15b679799ba980ed40c837dcb03b.zip" + "S3Key": "ae370e1010629b78f494346f49ceef3ab2875718f20e6c808114e6aa770c7bf3.zip" }, "Timeout": 120, "Handler": "index.handler", @@ -118,7 +118,7 @@ "StackName": "cross-region-producer" }, "flattenResponse": "false", - "salt": "1666292907087" + "salt": "1681912047074" }, "DependsOn": [ "AwsApiCallCloudFormationdeleteStack" @@ -302,7 +302,7 @@ "S3Bucket": { "Fn::Sub": "cdk-hnb659fds-assets-${AWS::AccountId}-${AWS::Region}" }, - "S3Key": "b54b99043c35bd080b9d9d1afce31e3541cf15b679799ba980ed40c837dcb03b.zip" + "S3Key": "ae370e1010629b78f494346f49ceef3ab2875718f20e6c808114e6aa770c7bf3.zip" }, "Timeout": 120, "Handler": "index.isComplete", @@ -344,7 +344,7 @@ "S3Bucket": { "Fn::Sub": "cdk-hnb659fds-assets-${AWS::AccountId}-${AWS::Region}" }, - "S3Key": "b54b99043c35bd080b9d9d1afce31e3541cf15b679799ba980ed40c837dcb03b.zip" + "S3Key": "ae370e1010629b78f494346f49ceef3ab2875718f20e6c808114e6aa770c7bf3.zip" }, "Timeout": 120, "Handler": "index.onTimeout", diff --git a/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/integ.json b/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/integ.json index 42ba38db2813c..f6cc8e83e2d10 100644 --- a/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/integ.json +++ b/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/integ.json @@ -1,9 +1,10 @@ { - "version": "21.0.0", + "version": "31.0.0", "testCases": { "cross-region-references/DefaultTest": { "stacks": [ - "cross-region-consumer" + "cross-region-consumer", + "cross-region-consumer2" ], "stackUpdateWorkflow": false, "assertionStack": "cross-region-references/DefaultTest/DeployAssert", diff --git a/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/manifest.json b/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/manifest.json index 251eda57fc9af..f85602d094927 100644 --- a/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/manifest.json +++ b/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.js.snapshot/manifest.json @@ -1,5 +1,5 @@ { - "version": "21.0.0", + "version": "31.0.0", "artifacts": { "cross-region-producer.assets": { "type": "cdk:asset-manifest", @@ -17,7 +17,7 @@ "validateOnSynth": false, "assumeRoleArn": "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-hnb659fds-deploy-role-${AWS::AccountId}-us-east-1", "cloudFormationExecutionRoleArn": "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-hnb659fds-cfn-exec-role-${AWS::AccountId}-us-east-1", - "stackTemplateAssetObjectUrl": "s3://cdk-hnb659fds-assets-${AWS::AccountId}-us-east-1/70e0b1af0ea278adf024d80a32c2797554d527123f1dc1eb9f2a894a6d46bc7a.json", + "stackTemplateAssetObjectUrl": "s3://cdk-hnb659fds-assets-${AWS::AccountId}-us-east-1/f4f423c120bb2c3118761133362f056c498404cb31d1528f2ea55ebc825579df.json", "requiresBootstrapStackVersion": 6, "bootstrapStackVersionSsmParameter": "/cdk-bootstrap/hnb659fds/version", "additionalDependencies": [ @@ -75,6 +75,12 @@ "data": "CustomCrossRegionExportWriterCustomResourceProviderHandlerD8786E8A" } ], + "/cross-region-producer/ExportsWriteruswest209BD44F0/Resource/Default": [ + { + "type": "aws:cdk:logicalId", + "data": "ExportsWriteruswest209BD44F0A7CF058B" + } + ], "/cross-region-producer/BootstrapVersion": [ { "type": "aws:cdk:logicalId", @@ -106,7 +112,7 @@ "validateOnSynth": false, "assumeRoleArn": "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-hnb659fds-deploy-role-${AWS::AccountId}-us-east-2", "cloudFormationExecutionRoleArn": "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-hnb659fds-cfn-exec-role-${AWS::AccountId}-us-east-2", - "stackTemplateAssetObjectUrl": "s3://cdk-hnb659fds-assets-${AWS::AccountId}-us-east-2/33212ba7662e584fce97d4b64b2b7d157f5f1bac2b2ffe4e25e18545b514ec8b.json", + "stackTemplateAssetObjectUrl": "s3://cdk-hnb659fds-assets-${AWS::AccountId}-us-east-2/6ca479488b1cdd2429244a95639246ddc89aaa458989ff2526645df63a2953b2.json", "requiresBootstrapStackVersion": 6, "bootstrapStackVersionSsmParameter": "/cdk-bootstrap/hnb659fds/version", "additionalDependencies": [ @@ -198,6 +204,114 @@ }, "displayName": "cross-region-consumer" }, + "cross-region-consumer2.assets": { + "type": "cdk:asset-manifest", + "properties": { + "file": "cross-region-consumer2.assets.json", + "requiresBootstrapStackVersion": 6, + "bootstrapStackVersionSsmParameter": "/cdk-bootstrap/hnb659fds/version" + } + }, + "cross-region-consumer2": { + "type": "aws:cloudformation:stack", + "environment": "aws://unknown-account/us-west-2", + "properties": { + "templateFile": "cross-region-consumer2.template.json", + "validateOnSynth": false, + "assumeRoleArn": "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-hnb659fds-deploy-role-${AWS::AccountId}-us-west-2", + "cloudFormationExecutionRoleArn": "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-hnb659fds-cfn-exec-role-${AWS::AccountId}-us-west-2", + "stackTemplateAssetObjectUrl": "s3://cdk-hnb659fds-assets-${AWS::AccountId}-us-west-2/7314b777fac2e8baea2214fe1ce9c17ad4b1ef6ce74c41da04349ea1c754d8f3.json", + "requiresBootstrapStackVersion": 6, + "bootstrapStackVersionSsmParameter": "/cdk-bootstrap/hnb659fds/version", + "additionalDependencies": [ + "cross-region-consumer2.assets" + ], + "lookupRole": { + "arn": "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-hnb659fds-lookup-role-${AWS::AccountId}-us-west-2", + "requiresBootstrapStackVersion": 8, + "bootstrapStackVersionSsmParameter": "/cdk-bootstrap/hnb659fds/version" + } + }, + "dependencies": [ + "cross-region-producer", + "cross-region-consumer2.assets" + ], + "metadata": { + "/cross-region-consumer2/IntegNested/IntegNestedParameter0/Resource": [ + { + "type": "aws:cdk:logicalId", + "data": "IntegNestedParameter04B9B8A01" + } + ], + "/cross-region-consumer2/IntegNested/IntegNestedParameter1/Resource": [ + { + "type": "aws:cdk:logicalId", + "data": "IntegNestedParameter1DE6274D4" + } + ], + "/cross-region-consumer2/IntegNested/reference-to-crossregionconsumer2ExportsReader29C6F905--cdk--exports--cross-region-consumer2--crossregionproduceruseast1FnGetAttIntegQueue3A18718AQueueName8D8D3C9B": [ + { + "type": "aws:cdk:logicalId", + "data": "referencetocrossregionconsumer2ExportsReader29C6F905cdkexportscrossregionconsumer2crossregionproduceruseast1FnGetAttIntegQueue3A18718AQueueName8D8D3C9B" + } + ], + "/cross-region-consumer2/IntegNested/reference-to-crossregionconsumer2ExportsReader29C6F905--cdk--exports--cross-region-consumer2--crossregionproduceruseast1FnGetAttIntegNestedNestedStackIntegNestedNestedStackResource168C5881OutputscrossregionproducerIntegNestedNestedIntegQueueD686DB69QueueNameC1C9C99E": [ + { + "type": "aws:cdk:logicalId", + "data": "referencetocrossregionconsumer2ExportsReader29C6F905cdkexportscrossregionconsumer2crossregionproduceruseast1FnGetAttIntegNestedNestedStackIntegNestedNestedStackResource168C5881OutputscrossregionproducerIntegNestedNestedIntegQueueD686DB69QueueNameC1C9C99E" + } + ], + "/cross-region-consumer2/IntegNested.NestedStack/IntegNested.NestedStackResource": [ + { + "type": "aws:cdk:logicalId", + "data": "IntegNestedNestedStackIntegNestedNestedStackResource168C5881" + } + ], + "/cross-region-consumer2/IntegParameter0/Resource": [ + { + "type": "aws:cdk:logicalId", + "data": "IntegParameter02A1817A4" + } + ], + "/cross-region-consumer2/IntegParameter1/Resource": [ + { + "type": "aws:cdk:logicalId", + "data": "IntegParameter1EDBEF1C6" + } + ], + "/cross-region-consumer2/ExportsReader/Resource/Default": [ + { + "type": "aws:cdk:logicalId", + "data": "ExportsReader8B249524" + } + ], + "/cross-region-consumer2/Custom::CrossRegionExportReaderCustomResourceProvider/Role": [ + { + "type": "aws:cdk:logicalId", + "data": "CustomCrossRegionExportReaderCustomResourceProviderRole10531BBD" + } + ], + "/cross-region-consumer2/Custom::CrossRegionExportReaderCustomResourceProvider/Handler": [ + { + "type": "aws:cdk:logicalId", + "data": "CustomCrossRegionExportReaderCustomResourceProviderHandler46647B68" + } + ], + "/cross-region-consumer2/BootstrapVersion": [ + { + "type": "aws:cdk:logicalId", + "data": "BootstrapVersion" + } + ], + "/cross-region-consumer2/CheckBootstrapVersion": [ + { + "type": "aws:cdk:logicalId", + "data": "CheckBootstrapVersion" + } + ] + }, + "displayName": "cross-region-consumer2" + }, "crossregionreferencesDefaultTestDeployAssertAB7415FD.assets": { "type": "cdk:asset-manifest", "properties": { @@ -214,7 +328,7 @@ "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}/e62b4ad819f8f21c0c8707091f053b8b322398afc1a04fd089b1be1436fb011a.json", + "stackTemplateAssetObjectUrl": "s3://cdk-hnb659fds-assets-${AWS::AccountId}-${AWS::Region}/d8798dd0bd8b18d69bd299a0773560da86b4fff407a6c7f4f481ac2cfa4ec54b.json", "requiresBootstrapStackVersion": 6, "bootstrapStackVersionSsmParameter": "/cdk-bootstrap/hnb659fds/version", "additionalDependencies": [ diff --git a/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.ts b/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.ts index d77be7df4678e..b3cd6fc6f69b8 100644 --- a/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.ts +++ b/packages/@aws-cdk-testing/framework-integ/test/aws-cloudformation/test/integ.core-cross-region-references.ts @@ -27,13 +27,14 @@ class ProducerStack extends Stack { interface ConsumerStackProps extends StackProps { readonly queues: IQueue[]; + readonly region: string; } class ConsumerStack extends Stack { constructor(scope: Construct, id: string, props: ConsumerStackProps) { super(scope, id, { ...props, env: { - region: 'us-east-2', + region: props.region, }, crossRegionReferences: true, }); @@ -53,21 +54,26 @@ class ConsumerStack extends Stack { } class TestCase extends Construct { - public readonly testCase: Stack; + public readonly testCases: Stack[] = []; public readonly producer: ProducerStack; constructor(scope: Construct, id: string) { super(scope, id); this.producer = new ProducerStack(app, 'cross-region-producer'); - this.testCase = new ConsumerStack(app, 'cross-region-consumer', { + this.testCases.push(new ConsumerStack(app, 'cross-region-consumer', { queues: [this.producer.queue, this.producer.nestedQueue], - }); + region: 'us-east-2', + })); + this.testCases.push(new ConsumerStack(app, 'cross-region-consumer2', { + queues: [this.producer.queue, this.producer.nestedQueue], + region: 'us-west-2', + })); } } const testCase1 = new TestCase(app, 'TestCase1'); // THEN const integ = new IntegTest(app, 'cross-region-references', { - testCases: [testCase1.testCase], + testCases: testCase1.testCases, stackUpdateWorkflow: false, }); diff --git a/packages/@aws-cdk/integ-runner/lib/runner/private/cloud-assembly.ts b/packages/@aws-cdk/integ-runner/lib/runner/private/cloud-assembly.ts index 5ed77e9b0c388..f5003ba24cb2c 100644 --- a/packages/@aws-cdk/integ-runner/lib/runner/private/cloud-assembly.ts +++ b/packages/@aws-cdk/integ-runner/lib/runner/private/cloud-assembly.ts @@ -130,12 +130,13 @@ export class AssemblyManifestReader { const assets: string[] = []; for (const artifact of Object.values(this.manifest.artifacts ?? {})) { if (artifact.type === ArtifactType.ASSET_MANIFEST && (artifact.properties as AssetManifestProperties)?.file === `${stackId}.assets.json`) { - assets.push(...this.assetsFromAssetManifest(artifact).map(asset => { - if (asset.type === 'file') { + assets.push(...this.assetsFromAssetManifest(artifact).flatMap(asset => { + if (asset.type === 'file' && !asset.source.path?.endsWith('nested.template.json')) { return asset.source.path!; - } else { + } else if (asset.type !== 'file') { return asset.source.directory!; } + return []; })); } else if (artifact.type === ArtifactType.AWS_CLOUDFORMATION_STACK) { assets.push(...this.assetsFromAssemblyManifest(artifact).map(asset => asset.path)); diff --git a/packages/aws-cdk-lib/core/lib/custom-resource-provider/cross-region-export-providers/export-writer-provider.ts b/packages/aws-cdk-lib/core/lib/custom-resource-provider/cross-region-export-providers/export-writer-provider.ts index cefb0055e1b4b..a1390fe85f864 100644 --- a/packages/aws-cdk-lib/core/lib/custom-resource-provider/cross-region-export-providers/export-writer-provider.ts +++ b/packages/aws-cdk-lib/core/lib/custom-resource-provider/cross-region-export-providers/export-writer-provider.ts @@ -9,6 +9,7 @@ import { Intrinsic } from '../../private/intrinsic'; import { makeUniqueId } from '../../private/uniqueid'; import { Reference } from '../../reference'; import { Stack } from '../../stack'; +import { Token } from '../../token'; import { CustomResourceProvider, CustomResourceProviderRuntime } from '../custom-resource-provider'; /** @@ -54,22 +55,31 @@ export class ExportWriter extends Construct { }); } private readonly _references: CrossRegionExports = {}; + private readonly provider: CustomResourceProvider; + private readonly resourceArns = new Set; constructor(scope: Construct, id: string, props: ExportWriterProps) { super(scope, id); const stack = Stack.of(this); const region = props.region ?? stack.region; + this.resourceArns.add( + stack.formatArn({ + service: 'ssm', + resource: 'parameter', + region, + resourceName: `${SSM_EXPORT_PATH_PREFIX}*`, + }), + ); const resourceType = 'Custom::CrossRegionExportWriter'; - const serviceToken = CustomResourceProvider.getOrCreate(this, resourceType, { + this.provider = CustomResourceProvider.getOrCreateProvider(this, resourceType, { codeDirectory: path.join(__dirname, 'cross-region-ssm-writer-handler'), runtime: CustomResourceProviderRuntime.NODEJS_14_X, policyStatements: [{ Effect: 'Allow', - Resource: stack.formatArn({ - service: 'ssm', - resource: 'parameter', - region, - resourceName: `${SSM_EXPORT_PATH_PREFIX}*`, + Resource: Lazy.list({ + produce: () => [ + ...Array.from(this.resourceArns), + ], }), Action: [ 'ssm:DeleteParameters', @@ -86,7 +96,7 @@ export class ExportWriter extends Construct { }; new CustomResource(this, 'Resource', { resourceType: resourceType, - serviceToken, + serviceToken: this.provider.serviceToken, properties: { WriterProps: properties, }, @@ -114,12 +124,33 @@ export class ExportWriter extends Construct { return this.addToExportReader(parameterName, ref, importStack); } + /** + * Add a resource arn for the consuming stack region + * Each writer could be writing to multiple regions and needs + * permissions to each region. + * + * If the region is not resolved then do not add anything. + */ + private addRegionToPolicy(region: string): void { + if (!Token.isUnresolved(region)) { + this.resourceArns.add( + Stack.of(this).formatArn({ + service: 'ssm', + resource: 'parameter', + region, + resourceName: `${SSM_EXPORT_PATH_PREFIX}*`, + }), + ); + } + } + /** * Add the export to the export reader which is created in the importing stack */ private addToExportReader(exportName: string, exportValueRef: Intrinsic, importStack: Stack): Intrinsic { const readerConstructName = makeUniqueId(['ExportsReader']); const exportReader = ExportReader.getOrCreate(importStack.nestedStackParent ?? importStack, readerConstructName); + this.addRegionToPolicy(importStack.region); return exportReader.importValue(exportName, exportValueRef); } diff --git a/packages/aws-cdk-lib/core/test/custom-resource-provider/export-writer-provider.test.ts b/packages/aws-cdk-lib/core/test/custom-resource-provider/export-writer-provider.test.ts index 90f71197929a0..cb36c4348f972 100644 --- a/packages/aws-cdk-lib/core/test/custom-resource-provider/export-writer-provider.test.ts +++ b/packages/aws-cdk-lib/core/test/custom-resource-provider/export-writer-provider.test.ts @@ -63,7 +63,7 @@ describe('export writer provider', () => { 'ssm:PutParameter', ], Effect: 'Allow', - Resource: { + Resource: [{ 'Fn::Join': [ '', [ @@ -78,7 +78,7 @@ describe('export writer provider', () => { ':parameter/cdk/exports/*', ], ], - }, + }], }, ], Version: '2012-10-17', @@ -255,6 +255,126 @@ describe('export writer provider', () => { }); }); + test('multi region', () => { + // GIVEN + const app = new App(); + const stack = new Stack(app, 'Stack1', { env: { region: 'producer-region' } }); + const stack2 = new Stack(app, 'Stack2', { env: { region: 'consumer-region1' } }); + const stack3 = new Stack(app, 'Stack3', { env: { region: 'consumer-region2' } }); + const resource = new CfnResource(stack, 'MyResource', { + type: 'Custom::MyResource', + }); + + // WHEN + const exportWriter = new ExportWriter(stack, 'ExportWriter', { + region: 'us-east-1', + }); + exportWriter.exportValue('MyResourceName', resource.getAtt('arn'), stack2); + exportWriter.exportValue('MyResourceName', resource.getAtt('arn'), stack3); + + // THEN + const cfn = toCloudFormation(stack); + + expect(cfn).toMatchObject({ + Resources: { + MyResource: { + Type: 'Custom::MyResource', + }, + CustomCrossRegionExportWriterCustomResourceProviderRoleC951B1E1: { + Type: 'AWS::IAM::Role', + Properties: { + AssumeRolePolicyDocument: { + Version: '2012-10-17', + Statement: [ + { + Action: 'sts:AssumeRole', + Effect: 'Allow', + Principal: { + Service: 'lambda.amazonaws.com', + }, + }, + ], + }, + Policies: [ + { + PolicyDocument: { + Statement: [ + { + Action: [ + 'ssm:DeleteParameters', + 'ssm:ListTagsForResource', + 'ssm:GetParameters', + 'ssm:PutParameter', + ], + Effect: 'Allow', + Resource: [ + { + 'Fn::Join': [ + '', + [ + 'arn:', + { + Ref: 'AWS::Partition', + }, + ':ssm:us-east-1:', + { + Ref: 'AWS::AccountId', + }, + ':parameter/cdk/exports/*', + ], + ], + }, + { + 'Fn::Join': [ + '', + [ + 'arn:', + { + Ref: 'AWS::Partition', + }, + ':ssm:consumer-region1:', + { + Ref: 'AWS::AccountId', + }, + ':parameter/cdk/exports/*', + ], + ], + }, + { + 'Fn::Join': [ + '', + [ + 'arn:', + { + Ref: 'AWS::Partition', + }, + ':ssm:consumer-region2:', + { + Ref: 'AWS::AccountId', + }, + ':parameter/cdk/exports/*', + ], + ], + }, + ], + }, + ], + Version: '2012-10-17', + }, + PolicyName: 'Inline', + }, + ], + ManagedPolicyArns: [ + { + 'Fn::Sub': 'arn:${AWS::Partition}:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole', + }, + ], + }, + }, + }, + }); + }); + test('when consumer is a nested stack, ExportReader is created in the parent stack', () => { // GIVEN const app = new App(); @@ -312,7 +432,7 @@ describe('export writer provider', () => { 'ssm:PutParameter', ], Effect: 'Allow', - Resource: { + Resource: [{ 'Fn::Join': [ '', [ @@ -327,7 +447,7 @@ describe('export writer provider', () => { ':parameter/cdk/exports/*', ], ], - }, + }], }, ], Version: '2012-10-17', From 94c3bb2befd297c067e12ababe65a4c9a802b66f Mon Sep 17 00:00:00 2001 From: corymhall <43035978+corymhall@users.noreply.github.com> Date: Fri, 21 Apr 2023 13:14:20 +0000 Subject: [PATCH 2/2] update based on review --- .../export-writer-provider.ts | 9 +-------- 1 file changed, 1 insertion(+), 8 deletions(-) diff --git a/packages/aws-cdk-lib/core/lib/custom-resource-provider/cross-region-export-providers/export-writer-provider.ts b/packages/aws-cdk-lib/core/lib/custom-resource-provider/cross-region-export-providers/export-writer-provider.ts index a1390fe85f864..78054d053c403 100644 --- a/packages/aws-cdk-lib/core/lib/custom-resource-provider/cross-region-export-providers/export-writer-provider.ts +++ b/packages/aws-cdk-lib/core/lib/custom-resource-provider/cross-region-export-providers/export-writer-provider.ts @@ -61,14 +61,7 @@ export class ExportWriter extends Construct { super(scope, id); const stack = Stack.of(this); const region = props.region ?? stack.region; - this.resourceArns.add( - stack.formatArn({ - service: 'ssm', - resource: 'parameter', - region, - resourceName: `${SSM_EXPORT_PATH_PREFIX}*`, - }), - ); + this.addRegionToPolicy(region); const resourceType = 'Custom::CrossRegionExportWriter'; this.provider = CustomResourceProvider.getOrCreateProvider(this, resourceType, {