@aws-cdk/toolkit-lib 1.24.0 → 1.25.1

package/lib/api/diagnosing/diagnosis-formatting.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hostMessageFromDiagnosis = hostMessageFromDiagnosis;
+exports.throwDeploymentErrorFromDiagnosis = throwDeploymentErrorFromDiagnosis;
+const tree_builder_1 = require("./tree-builder");
+const toolkit_error_1 = require("../../toolkit/toolkit-error");
+const util_1 = require("../../util");
+const private_1 = require("../io/private");
+/**
+ * Turn the given stack diagnosis result into an IO message, with default message formatting
+ *
+ * The default message formatting is what the CLI will print.
+ */
+function hostMessageFromDiagnosis(stack) {
+    const diagnosis = stack.result;
+    switch (diagnosis.type) {
+        case 'no-problem':
+            return private_1.IO.CDK_TOOLKIT_I9500.msg(formatNoProblemStack(stack, diagnosis), stack);
+        case 'problem':
+            return private_1.IO.CDK_TOOLKIT_E9500.msg(formatProblemStack(stack, diagnosis), stack);
+        case 'error-diagnosing':
+            return private_1.IO.CDK_TOOLKIT_W9501.msg(formatDiagnosisErrorStack(stack, diagnosis), stack);
+    }
+}
+/**
+ * Turn the given diagnosis into a DeploymentError
+ */
+function throwDeploymentErrorFromDiagnosis(diag) {
+    switch (diag.type) {
+        case 'no-problem':
+            throw new toolkit_error_1.ToolkitError('DeploymentErrorNotError', 'Diagnosis should represent an error, but does not');
+        case 'error-diagnosing':
+            throw new toolkit_error_1.DeploymentError(diag.message, 'ErrorDiagnosisFailed');
+    }
+    // Guaranteed 'type=problem' here
+    const errorCode = diag.problems[0]?.errorCode;
+    let defaultErrorCode;
+    switch (diag.detectedBy.type) {
+        case 'change-set':
+            defaultErrorCode = 'ChangeSetCreationFailed';
+            break;
+        case 'early-validation':
+            defaultErrorCode = 'EarlyValidationFailure';
+            break;
+        case 'deployment':
+            defaultErrorCode = 'StackDeployFailed';
+            break;
+    }
+    throw new toolkit_error_1.DeploymentError(formatProblemDiagnosis(diag), errorCode ?? defaultErrorCode);
+}
+function formatProblemDiagnosis(diag) {
+    switch (diag.detectedBy.type) {
+        case 'change-set':
+            return formatChangeSetProblems(diag.problems, diag.detectedBy);
+        case 'early-validation':
+            return formatEarlyValidationProblems(diag.problems, diag.detectedBy);
+        case 'deployment':
+            return formatDeploymentProblems(diag.problems, diag.detectedBy);
+    }
+}
+function formatChangeSetProblems(problems, detectedBy) {
+    const caption = `Failed to create change set ${detectedBy.changeSetName}`;
+    if (problems.length > 0) {
+        return `${caption}:\n${formatResourceErrors(problems)}`;
+    }
+    else {
+        return `${caption}: ${detectedBy.statusReason}`;
+    }
+}
+function formatEarlyValidationProblems(problems, detectedBy) {
+    const caption = `Early validation failed for change set ${detectedBy.changeSetName}`;
+    if (problems.length > 0) {
+        return `${caption}:\n${formatResourceErrors(problems)}`;
+    }
+    else {
+        return caption;
+    }
+}
+function formatDeploymentProblems(problems, detectedBy) {
+    const caption = 'Resource updates failed';
+    if (problems.length > 0) {
+        return `${caption}:\n${formatResourceErrors(problems)}`;
+    }
+    else {
+        return `${caption} (${detectedBy.stackStatus}): ${detectedBy.statusReason}`;
+    }
+}
+function formatNoProblemStack(stack, _m) {
+    // TODO: print stack by construct path, not name
+    return `✅ Stack ${stack.stackName}: no issues found.`;
+}
+function formatProblemStack(stack, m) {
+    // TODO: print stack by construct path, not name
+    return `❌ Stack ${stack.stackName}:\n${formatProblemDiagnosis(m)}`;
+}
+function formatDiagnosisErrorStack(stack, m) {
+    // TODO: print stack by construct path, not name
+    return `⚠️ Could not diagnose stack ${stack.stackName}: ${m.message}`;
+}
+function formatResourceErrors(es) {
+    (0, util_1.sortByKey)(es, (e) => [locateResourceError(e)]);
+    const b = new tree_builder_1.TreeBuilder('');
+    for (const e of es) {
+        const p = locateResourceError(e);
+        const lastPart = p.split('/').slice(-1)[0];
+        const nodeText = b.nodeText(p);
+        nodeText.header = [`${lastPart}  ${addendum(' ', e.resourceType, e.logicalId)}`.trim()];
+        nodeText.body.push(...(0, tree_builder_1.sideBySide)(['🛑'], ' ', (0, tree_builder_1.wrapText)(120, e.message)));
+        nodeText.footer = e.sourceTrace?.creationStackTrace
+            ? (0, tree_builder_1.sideBySide)(['Source Location:'], ' ', e.sourceTrace?.creationStackTrace)
+            : [];
+    }
+    return b.render();
+}
+/**
+ * Return a /-separated construct path for the given error, or try to build as close a represention as possible if we don't have a construct path
+ *
+ * The root will be the "app"
+ */
+function locateResourceError(e) {
+    if (e.sourceTrace?.constructPath) {
+        return e.sourceTrace?.constructPath;
+    }
+    const nestedStackParts = e.parentStackLogicalIds.map((l) => `Nested stack ${l}`);
+    if (e.logicalId) {
+        return [e.topLevelStackHierarchicalId, ...nestedStackParts, e.logicalId].join('/');
+    }
+    // No logical ID means we are targeting the stack itself
+    return [e.topLevelStackHierarchicalId, nestedStackParts].join('/');
+}
+function addendum(sep, ...xs) {
+    xs = xs.filter(x => x && typeof x === 'string');
+    if (xs.length > 0) {
+        return `(${xs.join(sep)})`;
+    }
+    else {
+        return '';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"diagnosis-formatting.js","sourceRoot":"","sources":["diagnosis-formatting.ts"],"names":[],"mappings":"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","sourcesContent":["import { sideBySide, TreeBuilder, wrapText } from './tree-builder';\nimport type { DiagnosedStack, StackDiagnosis, StackProblemSource, TracedResourceError } from '../../actions/diagnose';\nimport { DeploymentError, ToolkitError } from '../../toolkit/toolkit-error';\nimport { sortByKey } from '../../util';\nimport type { ActionLessMessage } from '../io/private';\nimport { IO } from '../io/private';\n\n/**\n * Turn the given stack diagnosis result into an IO message, with default message formatting\n *\n * The default message formatting is what the CLI will print.\n */\nexport function hostMessageFromDiagnosis(stack: DiagnosedStack): ActionLessMessage<any> {\n  const diagnosis = stack.result;\n\n  switch (diagnosis.type) {\n    case 'no-problem':\n      return IO.CDK_TOOLKIT_I9500.msg(formatNoProblemStack(stack, diagnosis), stack);\n\n    case 'problem':\n      return IO.CDK_TOOLKIT_E9500.msg(formatProblemStack(stack, diagnosis), stack);\n\n    case 'error-diagnosing':\n      return IO.CDK_TOOLKIT_W9501.msg(formatDiagnosisErrorStack(stack, diagnosis), stack);\n  }\n}\n\n/**\n * Turn the given diagnosis into a DeploymentError\n */\nexport function throwDeploymentErrorFromDiagnosis(diag: StackDiagnosis): never {\n  switch (diag.type) {\n    case 'no-problem':\n      throw new ToolkitError('DeploymentErrorNotError', 'Diagnosis should represent an error, but does not');\n\n    case 'error-diagnosing':\n      throw new DeploymentError(diag.message, 'ErrorDiagnosisFailed');\n  }\n  // Guaranteed 'type=problem' here\n\n  const errorCode = diag.problems[0]?.errorCode;\n  let defaultErrorCode;\n  switch (diag.detectedBy.type) {\n    case 'change-set':\n      defaultErrorCode = 'ChangeSetCreationFailed';\n      break;\n\n    case 'early-validation':\n      defaultErrorCode = 'EarlyValidationFailure';\n      break;\n\n    case 'deployment':\n      defaultErrorCode = 'StackDeployFailed';\n      break;\n  }\n\n  throw new DeploymentError(formatProblemDiagnosis(diag), errorCode ?? defaultErrorCode);\n}\n\nfunction formatProblemDiagnosis(diag: Extract<StackDiagnosis, { type: 'problem' }>): string {\n  switch (diag.detectedBy.type) {\n    case 'change-set':\n      return formatChangeSetProblems(diag.problems, diag.detectedBy);\n\n    case 'early-validation':\n      return formatEarlyValidationProblems(diag.problems, diag.detectedBy);\n\n    case 'deployment':\n      return formatDeploymentProblems(diag.problems, diag.detectedBy);\n  }\n}\n\nfunction formatChangeSetProblems(problems: TracedResourceError[], detectedBy: Extract<StackProblemSource, { type: 'change-set' }>): string {\n  const caption = `Failed to create change set ${detectedBy.changeSetName}`;\n\n  if (problems.length > 0) {\n    return `${caption}:\\n${formatResourceErrors(problems)}`;\n  } else {\n    return `${caption}: ${detectedBy.statusReason}`;\n  }\n}\n\nfunction formatEarlyValidationProblems(problems: TracedResourceError[], detectedBy: Extract<StackProblemSource, { type: 'early-validation' }>): string {\n  const caption = `Early validation failed for change set ${detectedBy.changeSetName}`;\n  if (problems.length > 0) {\n    return `${caption}:\\n${formatResourceErrors(problems)}`;\n  } else {\n    return caption;\n  }\n}\n\nfunction formatDeploymentProblems(problems: TracedResourceError[], detectedBy: Extract<StackProblemSource, { type: 'deployment' }>): string {\n  const caption = 'Resource updates failed';\n\n  if (problems.length > 0) {\n    return `${caption}:\\n${formatResourceErrors(problems)}`;\n  } else {\n    return `${caption} (${detectedBy.stackStatus}): ${detectedBy.statusReason}`;\n  }\n}\n\nfunction formatNoProblemStack(stack: DiagnosedStack, _m: Extract<StackDiagnosis, { type: 'no-problem' }>) {\n  // TODO: print stack by construct path, not name\n  return `✅ Stack ${stack.stackName}: no issues found.`;\n}\n\nfunction formatProblemStack(stack: DiagnosedStack, m: Extract<StackDiagnosis, { type: 'problem' }>) {\n  // TODO: print stack by construct path, not name\n  return `❌ Stack ${stack.stackName}:\\n${formatProblemDiagnosis(m)}`;\n}\n\nfunction formatDiagnosisErrorStack(stack: DiagnosedStack, m: Extract<StackDiagnosis, { type: 'error-diagnosing' }>) {\n  // TODO: print stack by construct path, not name\n  return `⚠️ Could not diagnose stack ${stack.stackName}: ${m.message}`;\n}\n\nfunction formatResourceErrors(es: TracedResourceError[]) {\n  sortByKey(es, (e) => [locateResourceError(e)]);\n\n  const b = new TreeBuilder('');\n  for (const e of es) {\n    const p = locateResourceError(e);\n    const lastPart = p.split('/').slice(-1)[0];\n\n    const nodeText = b.nodeText(p);\n    nodeText.header = [`${lastPart}  ${addendum(' ', e.resourceType, e.logicalId)}`.trim()];\n    nodeText.body.push(...sideBySide(['🛑'], ' ', wrapText(120, e.message)));\n    nodeText.footer = e.sourceTrace?.creationStackTrace\n      ? sideBySide(['Source Location:'], ' ', e.sourceTrace?.creationStackTrace)\n      : [];\n  }\n  return b.render();\n}\n\n/**\n * Return a /-separated construct path for the given error, or try to build as close a represention as possible if we don't have a construct path\n *\n * The root will be the \"app\"\n */\nfunction locateResourceError(e: TracedResourceError): string {\n  if (e.sourceTrace?.constructPath) {\n    return e.sourceTrace?.constructPath;\n  }\n\n  const nestedStackParts = e.parentStackLogicalIds.map((l) => `Nested stack ${l}`);\n  if (e.logicalId) {\n    return [e.topLevelStackHierarchicalId, ...nestedStackParts, e.logicalId].join('/');\n  }\n  // No logical ID means we are targeting the stack itself\n  return [e.topLevelStackHierarchicalId, nestedStackParts].join('/');\n}\n\nfunction addendum(sep: string, ...xs: Array<string | undefined>): string {\n  xs = xs.filter(x => x && typeof x === 'string');\n  if (xs.length > 0) {\n    return `(${xs.join(sep)})`;\n  } else {\n    return '';\n  }\n}\n"]}

package/lib/api/diagnosing/stack-diagnoser.d.ts

@@ -0,0 +1,106 @@
+import type { ChangeSetSummary, Stack } from '@aws-sdk/client-cloudformation';
+import type { StackDiagnosis } from '../../actions/diagnose';
+import type { SDK } from '../aws-auth/sdk';
+import type { EnvironmentResources } from '../environment';
+import type { IoHelper } from '../io/private/io-helper';
+import type { ISourceTracer } from '../source-tracing/private/source-tracing';
+import type { ResourceErrors } from '../stack-events/resource-errors';
+export interface CloudFormationStackDiagnoserProps {
+    readonly sdk: SDK;
+    readonly envResources?: EnvironmentResources;
+    readonly sourceTracer: ISourceTracer;
+    readonly ioHelper: IoHelper;
+    readonly topLevelStackHierarchicalId: string;
+}
+/**
+ * Diagnose a stack's failed state
+ *
+ * - First, determine the stack's state.
+ * - If it is in a failed state, we started a deployment that failed. Describe the stack
+ *   events, and try to determine the root cause from that.
+ * - If it is in a normal state, see if there are any failed change sets. Either
+ *   get the failure message from the change set, or get the failure events from
+ *   the change set (early validation).
+ *
+ * This class works at the CloudFormation level, and does not deal with tracing
+ * CloudFormation errors to construct code sources yet.
+ */
+export declare class CloudFormationStackDiagnoser {
+    private readonly props;
+    private readonly cfn;
+    private parentStackLogicalIds;
+    constructor(props: CloudFormationStackDiagnoserProps);
+    /**
+     * Diagnose a stack's root cause given no pre-existing state
+     */
+    diagnoseFromFresh(stackName: string): Promise<StackDiagnosis>;
+    /**
+     * Diagnose potential problems with the change set
+     */
+    diagnoseChangeSet(changeSet: ChangeSetSummary): Promise<StackDiagnosis>;
+    /**
+     * Diagnose potential problems with the change set
+     */
+    diagnoseFromErrorCollection(errors: ResourceErrors, stack: Stack): Promise<StackDiagnosis>;
+    /**
+     * Diagnose a deployment failure via stack events
+     *
+     * This is the same logic that the deployment monitor uses.
+     */
+    private _diagnoseViaStackEvents;
+    private _diagnoseChangeSetFailureFromStackName;
+    /**
+     * Try to diagnose the reason that caused a changeset to fail to create
+     *
+     * There are a couple of different reasons this can happen, and we go through each of them in order.
+     *
+     * Usually this starts from trying to detect an error message pattern in the change set status reason,
+     * and then potentially going to fetch additional information using additional API calls.
+     */
+    private _diagnoseChangeSetFailure;
+    /**
+     * Try to read the resource-specific reasons for a changeset failure from `DescribeEvents`.
+     *
+     * If we couldn't read the events or there are 0 errors returned by that API, return a generic
+     * error.
+     */
+    private _reportChangeSetFailureFromEvents;
+    private addErrorTraces;
+    private addErrorTrace;
+    /**
+     * Build a generic stack error from the given change set information
+     *
+     * We can't point to a specific resource.
+     */
+    private _nonSpecificChangeSetError;
+    /**
+     * Look for nested change sets that have failed, and diagnose those.
+     */
+    private _diagnoseNestedChangeSetFailure;
+    private _findFailedNestedStack;
+    /**
+     * Try to parse failed auto-imports out from a change set status
+     *
+     * The pattern looks like this:
+     *
+     * ```
+     * CloudFormation is attempting to import some resources because they already exist in your account. The resources must have the DeletionPolicy attribute set to 'Retain' or 'RetainExceptOnCreate' in the template for successful import. The affected resources are SomeBucketD5B70704 ({BucketName=zomaareenbucket})
+     * ```
+     *
+     * Followed by
+     *
+     * ```
+     * LogicalID ({Prop=Value,Prop=Value}), LogicalID ({Prop=Value}), ...
+     * ```
+     */
+    private _tryDetectFailedAutoImport;
+}
+/**
+ * Return true if the given change set has no changes
+ *
+ * This must be determined from the status, not the 'Changes' array on the
+ * object; the latter can be empty because no resources were changed, but if
+ * there are changes to Outputs, the change set can still be executed.
+ */
+export declare function changeSetHasNoChanges(description: ChangeSetSummary): boolean;
+//# sourceMappingURL=stack-diagnoser.d.ts.map