@aws-cdk/integ-runner
Version:
CDK Integration Testing Tool
368 lines • 40.1 kB
JavaScript
"use strict";
var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
if (value !== null && value !== void 0) {
if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
var dispose, inner;
if (async) {
if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
dispose = value[Symbol.asyncDispose];
}
if (dispose === void 0) {
if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
dispose = value[Symbol.dispose];
if (async) inner = dispose;
}
if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
env.stack.push({ value: value, dispose: dispose, async: async });
}
else if (async) {
env.stack.push({ async: true });
}
return value;
};
var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
return function (env) {
function fail(e) {
env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
env.hasError = true;
}
var r, s = 0;
function next() {
while (r = env.stack.pop()) {
try {
if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
if (r.dispose) {
var result = r.dispose.call(r.value);
if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
}
else s |= 1;
}
catch (e) {
fail(e);
}
}
if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
if (env.hasError) throw env.error;
}
return next();
};
})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
var e = new Error(message);
return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
});
Object.defineProperty(exports, "__esModule", { value: true });
exports.ToolkitLibRunnerEngine = void 0;
const path = require("node:path");
const cloud_assembly_api_1 = require("@aws-cdk/cloud-assembly-api");
const toolkit_lib_1 = require("@aws-cdk/toolkit-lib");
const chalk = require("chalk");
const fs = require("fs-extra");
const proxy_agent_1 = require("./proxy-agent");
/**
* A runner engine powered directly by the toolkit-lib
*/
class ToolkitLibRunnerEngine {
toolkit;
options;
showOutput;
ioHost;
toolkitCache = new Map();
constructor(options) {
this.options = options;
this.showOutput = options.showOutput ?? false;
// We always create this for ourselves to emit warnings, but potentially
// don't pass it to the toolkit.
this.ioHost = new IntegRunnerIoHost();
this.toolkit = this.getOrCreateToolkit();
// @TODO - these options are currently available on the action calls
// but toolkit-lib needs them at the constructor level.
// Need to decide what to do with them.
//
// Validations
// - assemblyFailureAt: options.strict ?? options.ignoreErrors
// Logging
// - options.color
// @TODO - similar to the above, but in toolkit-lib these options would go on the IoHost
// - options.trace
// - options.verbose
// - options.json
}
/**
* Get or create a Toolkit instance for the given action options.
* Caches instances by their resolved configuration to avoid creating
* duplicate Toolkit instances for identical settings.
*/
getOrCreateToolkit(actionOptions) {
const profile = actionOptions?.profile ?? this.options.profile;
const proxy = actionOptions?.proxy ?? this.options.proxy;
const caBundlePath = actionOptions?.caBundlePath ?? this.options.caBundlePath;
const key = JSON.stringify([profile, proxy, caBundlePath]);
const cached = this.toolkitCache.get(key);
if (cached) {
return cached;
}
const toolkit = new toolkit_lib_1.Toolkit({
ioHost: this.showOutput ? this.ioHost : new NoopIoHost(),
sdkConfig: {
baseCredentials: toolkit_lib_1.BaseCredentials.awsCliCompatible({
profile,
defaultRegion: this.options.region,
}),
httpOptions: {
agent: proxy_agent_1.ProxyAgentProvider.getOrCreate({ proxyAddress: proxy, caBundlePath }),
},
},
});
this.toolkitCache.set(key, toolkit);
return toolkit;
}
/**
* Synthesizes the CDK app
*/
async synth(options) {
const cx = await this.cx({
app: options.app,
output: options.output,
context: options.context,
lookups: false,
resolveDefaultEnvironment: false,
env: options.env,
versionReporting: false,
pathMetadata: false,
assetMetadata: false,
});
try {
const env_1 = { stack: [], error: void 0, hasError: false };
try {
const lock = __addDisposableResource(env_1, await this.toolkit.synth(cx, {
validateStacks: false,
stacks: {
strategy: toolkit_lib_1.StackSelectionStrategy.ALL_STACKS,
failOnEmpty: false,
},
}), true);
await this.validateRegion(lock);
}
catch (e_1) {
env_1.error = e_1;
env_1.hasError = true;
}
finally {
const result_1 = __disposeResources(env_1);
if (result_1)
await result_1;
}
}
catch (e) {
if (e.message.includes('Missing context keys')) {
// @TODO - silently ignore missing context
// This is actually an undefined case in the old implementation, which doesn't use the toolkit code
// and won't fail for missing context. To preserve existing behavior, we do the same here.
// However in future we need to find a way for integ tests to provide context through snapshots.
return;
}
throw e;
}
}
/**
* Lists the stacks in the CDK app
*/
async list(options) {
const toolkit = this.getOrCreateToolkit(options);
const cx = await this.cx(options);
const stacks = await toolkit.list(cx, {
stacks: this.stackSelector(options),
});
return stacks.map(s => s.name);
}
/**
* Deploys the CDK app
*/
async deploy(options) {
const toolkit = this.getOrCreateToolkit(options);
const cx = await this.cx(options);
await toolkit.deploy(cx, {
roleArn: options.roleArn,
traceLogs: options.traceLogs,
stacks: this.stackSelector(options),
deploymentMethod: {
method: 'change-set',
},
outputsFile: options.outputsFile ? path.join(this.options.workingDirectory, options.outputsFile) : undefined,
});
}
/**
* Watches the CDK app for changes and deploys them automatically
*/
async watch(options, events) {
const toolkit = this.getOrCreateToolkit(options);
const cx = await this.cx(options);
try {
const watcher = await toolkit.watch(cx, {
roleArn: options.roleArn,
traceLogs: options.traceLogs,
stacks: this.stackSelector(options),
deploymentMethod: options.deploymentMethod,
});
await watcher.waitForEnd();
}
catch (e) {
if (events?.onStderr) {
events.onStderr(String(e));
}
if (events?.onClose) {
events.onClose(1);
}
return;
}
if (events?.onClose) {
events.onClose(0);
}
}
/**
* Destroys the CDK app
*/
async destroy(options) {
const toolkit = this.getOrCreateToolkit(options);
const cx = await this.cx(options);
await toolkit.destroy(cx, {
roleArn: options.roleArn,
stacks: this.stackSelector(options),
});
}
/**
* Creates a Cloud Assembly Source from the provided options.
*/
async cx(options) {
if (!options.app) {
throw new Error('No app provided');
}
// check if the app is a path to existing snapshot and then use it as an assembly directory
const potentialCxPath = path.join(this.options.workingDirectory, options.app);
if (fs.pathExistsSync(potentialCxPath) && fs.statSync(potentialCxPath).isDirectory()) {
return this.toolkit.fromAssemblyDirectory(potentialCxPath);
}
let outdir;
if (options.output) {
outdir = path.join(this.options.workingDirectory, options.output);
}
return this.toolkit.fromCdkApp(options.app, {
workingDirectory: this.options.workingDirectory,
outdir,
lookups: options.lookups,
contextStore: new toolkit_lib_1.MemoryContext(options.context),
resolveDefaultEnvironment: options.resolveDefaultEnvironment,
env: {
...this.options.env,
...options.env,
},
synthOptions: {
debug: options.debug,
versionReporting: options.versionReporting ?? false,
pathMetadata: options.pathMetadata ?? false,
assetMetadata: options.assetMetadata ?? false,
assetStaging: options.staging,
},
});
}
/**
* Creates a StackSelector from the provided options.
*/
stackSelector(options) {
return {
strategy: options.all ? toolkit_lib_1.StackSelectionStrategy.ALL_STACKS : toolkit_lib_1.StackSelectionStrategy.PATTERN_MUST_MATCH,
patterns: options.stacks ?? ['**'],
expand: options.exclusively ? toolkit_lib_1.ExpandStackSelection.NONE : toolkit_lib_1.ExpandStackSelection.UPSTREAM,
};
}
/**
* Check that the regions for the stacks in the CloudAssembly match the regions requested on the engine
*
* This prevents misconfiguration of the integ test app. People tend to put:
*
* ```ts
* new Stack(app, 'Stack', {
* env: {
* region: 'some-region-that-suits-me',
* }
* });
* ```
*
* Into their integ tests, instead of:
*
* ```ts
* {
* region: process.env.CDK_DEFAULT_REGION,
* }
* ```
*
* This catches that misconfiguration.
*/
async validateRegion(asm) {
// this happens for existing snapshots, in that case nothing to check
if (this.options.region === cloud_assembly_api_1.UNKNOWN_REGION) {
return;
}
for (const stack of asm.cloudAssembly.stacksRecursively) {
if (stack.environment.region !== this.options.region && stack.environment.region !== cloud_assembly_api_1.UNKNOWN_REGION) {
this.ioHost.notify({
action: 'deploy',
code: 'CDK_RUNNER_W0000',
time: new Date(),
level: 'warn',
message: `Stack ${stack.displayName} synthesizes for region ${stack.environment.region}, even though ${this.options.region} was requested. Please configure \`{ env: { region: process.env.CDK_DEFAULT_REGION, account: process.env.CDK_DEFAULT_ACCOUNT } }\`, or use no env at all. Do not hardcode a region or account.`,
data: {
stackName: stack.displayName,
stackRegion: stack.environment.region,
requestedRegion: this.options.region,
},
}).catch((e) => {
if (e) {
// eslint-disable-next-line no-console
console.error(e);
}
});
}
}
}
}
exports.ToolkitLibRunnerEngine = ToolkitLibRunnerEngine;
/**
* An IoHost used in the integ-runner to provide non-interactive output
*/
class IntegRunnerIoHost extends toolkit_lib_1.NonInteractiveIoHost {
constructor(props = {}) {
super({
...props,
isTTY: false,
});
}
async notify(msg) {
let color;
switch (msg.level) {
case 'error':
color = chalk.red;
break;
case 'warn':
color = chalk.yellow;
break;
default: color = chalk.gray;
}
return super.notify({
...msg,
message: color(msg.message),
});
}
}
/**
* An IoHost that doesn't do anything
*/
class NoopIoHost {
async notify() {
}
async requestResponse(msg) {
return msg.defaultResponse;
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"toolkit-lib.js","sourceRoot":"","sources":["toolkit-lib.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'node:path';\nimport { UNKNOWN_REGION } from '@aws-cdk/cloud-assembly-api';\nimport type { DefaultCdkOptions } from '@aws-cdk/cloud-assembly-schema/lib/integ-tests';\nimport type { ICloudAssemblySource, IIoHost, IoMessage, IoRequest, IReadableCloudAssembly, NonInteractiveIoHostProps, StackSelector } from '@aws-cdk/toolkit-lib';\nimport { BaseCredentials, ExpandStackSelection, MemoryContext, NonInteractiveIoHost, StackSelectionStrategy, Toolkit } from '@aws-cdk/toolkit-lib';\nimport * as chalk from 'chalk';\nimport * as fs from 'fs-extra';\nimport type { CxOptions, DeployOptions, DestroyOptions, ICdk, ListOptions, SynthOptions, WatchEvents, WatchOptions } from './cdk-interface';\nimport { ProxyAgentProvider } from './proxy-agent';\n\nexport interface ToolkitLibEngineOptions {\n  /**\n   * The directory to run the cdk commands from\n   */\n  readonly workingDirectory: string;\n\n  /**\n   * Additional environment variables to set\n   * in the execution environment that will be running\n   * the cdk app\n   *\n   * @default - no additional env vars\n   */\n  readonly env?: { [name: string]: string };\n\n  /**\n   * Show the output from running the CDK CLI\n   *\n   * @default false\n   */\n  readonly showOutput?: boolean;\n\n  /**\n   * The region the CDK app should synthesize itself for\n   */\n  readonly region: string;\n\n  /**\n   * The AWS profile to use when authenticating\n   *\n   * @default - no profile is passed, the default profile is used\n   */\n  readonly profile?: string;\n\n  /**\n   * Use the indicated proxy\n   *\n   * @default - no proxy, ProxyAgent auto-detects from environment variables\n   */\n  readonly proxy?: string;\n\n  /**\n   * Path to CA certificate to use when validating HTTPS requests\n   *\n   * @default - no additional CA bundle\n   */\n  readonly caBundlePath?: string;\n}\n\n/**\n * Per-action options that can override the engine defaults.\n */\nexport interface ActionOptions {\n  /**\n   * The AWS profile to use\n   */\n  readonly profile?: string;\n\n  /**\n   * Use the indicated proxy\n   */\n  readonly proxy?: string;\n\n  /**\n   * Path to CA certificate to use when validating HTTPS requests\n   */\n  readonly caBundlePath?: string;\n}\n\n/**\n * A runner engine powered directly by the toolkit-lib\n */\nexport class ToolkitLibRunnerEngine implements ICdk {\n  private readonly toolkit: Toolkit;\n  private readonly options: ToolkitLibEngineOptions;\n  private readonly showOutput: boolean;\n  private readonly ioHost: IntegRunnerIoHost;\n  private readonly toolkitCache = new Map<string, Toolkit>();\n\n  public constructor(options: ToolkitLibEngineOptions) {\n    this.options = options;\n    this.showOutput = options.showOutput ?? false;\n\n    // We always create this for ourselves to emit warnings, but potentially\n    // don't pass it to the toolkit.\n    this.ioHost = new IntegRunnerIoHost();\n\n    this.toolkit = this.getOrCreateToolkit();\n\n    // @TODO - these options are currently available on the action calls\n    // but toolkit-lib needs them at the constructor level.\n    // Need to decide what to do with them.\n    //\n    // Validations\n    //  - assemblyFailureAt: options.strict ?? options.ignoreErrors\n    // Logging\n    //  - options.color\n\n    // @TODO - similar to the above, but in toolkit-lib these options would go on the IoHost\n    //  - options.trace\n    //  - options.verbose\n    //  - options.json\n  }\n\n  /**\n   * Get or create a Toolkit instance for the given action options.\n   * Caches instances by their resolved configuration to avoid creating\n   * duplicate Toolkit instances for identical settings.\n   */\n  private getOrCreateToolkit(actionOptions?: ActionOptions): Toolkit {\n    const profile = actionOptions?.profile ?? this.options.profile;\n    const proxy = actionOptions?.proxy ?? this.options.proxy;\n    const caBundlePath = actionOptions?.caBundlePath ?? this.options.caBundlePath;\n    const key = JSON.stringify([profile, proxy, caBundlePath]);\n\n    const cached = this.toolkitCache.get(key);\n    if (cached) {\n      return cached;\n    }\n\n    const toolkit = new Toolkit({\n      ioHost: this.showOutput ? this.ioHost : new NoopIoHost(),\n      sdkConfig: {\n        baseCredentials: BaseCredentials.awsCliCompatible({\n          profile,\n          defaultRegion: this.options.region,\n        }),\n        httpOptions: {\n          agent: ProxyAgentProvider.getOrCreate({ proxyAddress: proxy, caBundlePath }),\n        },\n      },\n    });\n\n    this.toolkitCache.set(key, toolkit);\n    return toolkit;\n  }\n\n  /**\n   * Synthesizes the CDK app\n   */\n  public async synth(options: SynthOptions) {\n    const cx = await this.cx({\n      app: options.app,\n      output: options.output,\n      context: options.context,\n      lookups: false,\n      resolveDefaultEnvironment: false,\n      env: options.env,\n      versionReporting: false,\n      pathMetadata: false,\n      assetMetadata: false,\n    });\n\n    try {\n      await using lock = await this.toolkit.synth(cx, {\n        validateStacks: false,\n        stacks: {\n          strategy: StackSelectionStrategy.ALL_STACKS,\n          failOnEmpty: false,\n        },\n      });\n      await this.validateRegion(lock);\n    } catch (e: any) {\n      if (e.message.includes('Missing context keys')) {\n        // @TODO - silently ignore missing context\n        // This is actually an undefined case in the old implementation, which doesn't use the toolkit code\n        // and won't fail for missing context. To preserve existing behavior, we do the same here.\n        // However in future we need to find a way for integ tests to provide context through snapshots.\n        return;\n      }\n      throw e;\n    }\n  }\n\n  /**\n   * Lists the stacks in the CDK app\n   */\n  public async list(options: ListOptions): Promise<string[]> {\n    const toolkit = this.getOrCreateToolkit(options);\n    const cx = await this.cx(options);\n    const stacks = await toolkit.list(cx, {\n      stacks: this.stackSelector(options),\n    });\n\n    return stacks.map(s => s.name);\n  }\n\n  /**\n   * Deploys the CDK app\n   */\n  public async deploy(options: DeployOptions) {\n    const toolkit = this.getOrCreateToolkit(options);\n    const cx = await this.cx(options);\n    await toolkit.deploy(cx, {\n      roleArn: options.roleArn,\n      traceLogs: options.traceLogs,\n      stacks: this.stackSelector(options),\n      deploymentMethod: {\n        method: 'change-set',\n      },\n      outputsFile: options.outputsFile ? path.join(this.options.workingDirectory, options.outputsFile) : undefined,\n    });\n  }\n\n  /**\n   * Watches the CDK app for changes and deploys them automatically\n   */\n  public async watch(options: WatchOptions, events?: WatchEvents) {\n    const toolkit = this.getOrCreateToolkit(options);\n    const cx = await this.cx(options);\n    try {\n      const watcher = await toolkit.watch(cx, {\n        roleArn: options.roleArn,\n        traceLogs: options.traceLogs,\n        stacks: this.stackSelector(options),\n        deploymentMethod: options.deploymentMethod,\n      });\n      await watcher.waitForEnd();\n    } catch (e: unknown) {\n      if (events?.onStderr) {\n        events.onStderr(String(e));\n      }\n      if (events?.onClose) {\n        events.onClose(1);\n      }\n      return;\n    }\n\n    if (events?.onClose) {\n      events.onClose(0);\n    }\n  }\n\n  /**\n   * Destroys the CDK app\n   */\n  public async destroy(options: DestroyOptions) {\n    const toolkit = this.getOrCreateToolkit(options);\n    const cx = await this.cx(options);\n\n    await toolkit.destroy(cx, {\n      roleArn: options.roleArn,\n      stacks: this.stackSelector(options),\n    });\n  }\n\n  /**\n   * Creates a Cloud Assembly Source from the provided options.\n   */\n  private async cx(options: CxOptions): Promise<ICloudAssemblySource> {\n    if (!options.app) {\n      throw new Error('No app provided');\n    }\n\n    // check if the app is a path to existing snapshot and then use it as an assembly directory\n    const potentialCxPath = path.join(this.options.workingDirectory, options.app);\n    if (fs.pathExistsSync(potentialCxPath) && fs.statSync(potentialCxPath).isDirectory()) {\n      return this.toolkit.fromAssemblyDirectory(potentialCxPath);\n    }\n\n    let outdir;\n    if (options.output) {\n      outdir = path.join(this.options.workingDirectory, options.output);\n    }\n\n    return this.toolkit.fromCdkApp(options.app, {\n      workingDirectory: this.options.workingDirectory,\n      outdir,\n      lookups: options.lookups,\n      contextStore: new MemoryContext(options.context),\n      resolveDefaultEnvironment: options.resolveDefaultEnvironment,\n      env: {\n        ...this.options.env,\n        ...options.env,\n      },\n      synthOptions: {\n        debug: options.debug,\n        versionReporting: options.versionReporting ?? false,\n        pathMetadata: options.pathMetadata ?? false,\n        assetMetadata: options.assetMetadata ?? false,\n        assetStaging: options.staging,\n      },\n    });\n  }\n\n  /**\n   * Creates a StackSelector from the provided options.\n   */\n  private stackSelector(options: DefaultCdkOptions & { readonly exclusively?: boolean }): StackSelector {\n    return {\n      strategy: options.all ? StackSelectionStrategy.ALL_STACKS : StackSelectionStrategy.PATTERN_MUST_MATCH,\n      patterns: options.stacks ?? ['**'],\n      expand: options.exclusively ? ExpandStackSelection.NONE : ExpandStackSelection.UPSTREAM,\n    };\n  }\n\n  /**\n   * Check that the regions for the stacks in the CloudAssembly match the regions requested on the engine\n   *\n   * This prevents misconfiguration of the integ test app. People tend to put:\n   *\n   * ```ts\n   * new Stack(app, 'Stack', {\n   *   env: {\n   *     region: 'some-region-that-suits-me',\n   *   }\n   * });\n   * ```\n   *\n   * Into their integ tests, instead of:\n   *\n   * ```ts\n   * {\n   *   region: process.env.CDK_DEFAULT_REGION,\n   * }\n   * ```\n   *\n   * This catches that misconfiguration.\n   */\n  private async validateRegion(asm: IReadableCloudAssembly): Promise<void> {\n    // this happens for existing snapshots, in that case nothing to check\n    if (this.options.region === UNKNOWN_REGION) {\n      return;\n    }\n\n    for (const stack of asm.cloudAssembly.stacksRecursively) {\n      if (stack.environment.region !== this.options.region && stack.environment.region !== UNKNOWN_REGION) {\n        this.ioHost.notify({\n          action: 'deploy',\n          code: 'CDK_RUNNER_W0000',\n          time: new Date(),\n          level: 'warn',\n          message: `Stack ${stack.displayName} synthesizes for region ${stack.environment.region}, even though ${this.options.region} was requested. Please configure \\`{ env: { region: process.env.CDK_DEFAULT_REGION, account: process.env.CDK_DEFAULT_ACCOUNT } }\\`, or use no env at all. Do not hardcode a region or account.`,\n          data: {\n            stackName: stack.displayName,\n            stackRegion: stack.environment.region,\n            requestedRegion: this.options.region,\n          },\n        }).catch((e) => {\n          if (e) {\n            // eslint-disable-next-line no-console\n            console.error(e);\n          }\n        });\n      }\n    }\n  }\n}\n\n/**\n * An IoHost used in the integ-runner to provide non-interactive output\n */\nclass IntegRunnerIoHost extends NonInteractiveIoHost {\n  public constructor(props: NonInteractiveIoHostProps = {}) {\n    super({\n      ...props,\n      isTTY: false,\n    });\n  }\n  public async notify(msg: IoMessage<unknown>): Promise<void> {\n    let color;\n    switch (msg.level) {\n      case 'error': color = chalk.red; break;\n      case 'warn': color = chalk.yellow; break;\n      default: color = chalk.gray;\n    }\n\n    return super.notify({\n      ...msg,\n      message: color(msg.message),\n    });\n  }\n}\n\n/**\n * An IoHost that doesn't do anything\n */\nclass NoopIoHost implements IIoHost {\n  public async notify(): Promise<void> {\n  }\n  public async requestResponse<T>(msg: IoRequest<unknown, T>): Promise<T> {\n    return msg.defaultResponse;\n  }\n}\n"]}