@aws-cdk/toolkit-lib 1.23.0 → 1.25.0

package/lib/api/diagnosing/early-validation.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EarlyValidationReporter = void 0;
+/**
+ * A ValidationReporter that checks for early validation errors right after
+ * creating the change set.
+ */
+class EarlyValidationReporter {
+    sdk;
+    envResources;
+    constructor(sdk, envResources) {
+        this.sdk = sdk;
+        this.envResources = envResources;
+    }
+    /**
+     * Fetch the details and return them as a string.
+     *
+     * If the details could not be fetched, log that as a warning using the IoHelper.
+     */
+    async fetchDetailsString(changeSetName, stackName, ioHelper) {
+        const summary = `Early validation failed for stack '${stackName}' (ChangeSet '${changeSetName}')`;
+        const result = await this.fetchDetailsStructured(changeSetName, stackName);
+        switch (result.type) {
+            case 'could-not-check':
+                await ioHelper.defaults.warn(result.message);
+                return summary;
+            case 'resource-errors':
+                if (result.errors.length === 0) {
+                    return summary;
+                }
+                return [
+                    `${summary}:`,
+                    ...result.errors.map(e => `  - ${e.message} (at ${e.documentPath})`),
+                ].join('\n');
+        }
+    }
+    /**
+     * Fetch the details and return them in structured form.
+     */
+    async fetchDetailsStructured(changeSetName, stackName) {
+        let operationEvents = [];
+        try {
+            operationEvents = await this.getFailedEvents(stackName, changeSetName);
+        }
+        catch (error) {
+            let currentVersion = undefined;
+            try {
+                currentVersion = (await this.envResources?.lookupToolkit())?.version;
+            }
+            catch (e) {
+            }
+            return {
+                type: 'could-not-check',
+                message: `Could not retrieve additional details about early validation errors (${error}). Make sure you have permissions to call the DescribeEvents API, or re-bootstrap your environment by running 'cdk bootstrap' to update the Bootstrap CDK Toolkit stack. Bootstrap toolkit stack version 30 or later is needed; current version: ${currentVersion ?? 'unknown'}.`,
+            };
+        }
+        return {
+            type: 'resource-errors',
+            errors: operationEvents.map((ev) => ({
+                eventType: ev.EventType ?? '',
+                logicalId: ev.LogicalResourceId ?? '',
+                message: ev.ValidationStatusReason ?? '',
+                physicalId: ev.PhysicalResourceId ? ev.PhysicalResourceId : undefined,
+                validationName: ev.ValidationName ?? '',
+                documentPath: ev.ValidationPath ?? '',
+                resourceType: ev.ResourceType,
+            })),
+        };
+    }
+    async getFailedEvents(stackName, changeSetName) {
+        return this.sdk.cloudFormation().paginatedDescribeEvents({
+            StackName: stackName,
+            ChangeSetName: changeSetName,
+            Filters: {
+                FailedEvents: true,
+            },
+        });
+    }
+}
+exports.EarlyValidationReporter = EarlyValidationReporter;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,99 @@
+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;
+    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

package/lib/api/diagnosing/stack-diagnoser.js

@@ -0,0 +1,338 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloudFormationStackDiagnoser = void 0;
+exports.changeSetHasNoChanges = changeSetHasNoChanges;
+const client_cloudformation_1 = require("@aws-sdk/client-cloudformation");
+const early_validation_1 = require("./early-validation");
+const stack_events_1 = require("../stack-events");
+const stack_status_1 = require("../stack-events/stack-status");
+/**
+ * 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.
+ */
+class CloudFormationStackDiagnoser {
+    props;
+    cfn;
+    parentStackLogicalIds;
+    constructor(props) {
+        this.props = props;
+        this.cfn = this.props.sdk.cloudFormation();
+        this.parentStackLogicalIds = [];
+    }
+    /**
+     * Diagnose a stack's root cause given no pre-existing state
+     */
+    async diagnoseFromFresh(stackName) {
+        try {
+            const response = await this.cfn.describeStacks({ StackName: stackName });
+            const stack = response.Stacks?.[0];
+            if (!stack) {
+                return {
+                    type: 'error-diagnosing',
+                    message: `Stack with name ${stackName} not found`,
+                };
+            }
+            const status = stack_status_1.StackStatus.fromStackDescription(stack);
+            if (status.isInProgress) {
+                return {
+                    type: 'error-diagnosing',
+                    message: `Stack with name ${stackName} is currently being updated (${status.name}). Try again when it's finished.`,
+                };
+            }
+            if (status.isFailure) {
+                return await this._diagnoseViaStackEvents(stackName, stack);
+            }
+            return await this._diagnoseChangeSetFailureFromStackName(stackName);
+        }
+        catch (e) {
+            return { type: 'error-diagnosing', message: e.message };
+        }
+    }
+    /**
+     * Diagnose potential problems with the change set
+     */
+    async diagnoseChangeSet(changeSet) {
+        try {
+            return await this._diagnoseChangeSetFailure(changeSet);
+        }
+        catch (e) {
+            return { type: 'error-diagnosing', message: e.message };
+        }
+    }
+    /**
+     * Diagnose potential problems with the change set
+     */
+    async diagnoseFromErrorCollection(errors, stack) {
+        if (errors.isEmpty()) {
+            return { type: 'no-problem' };
+        }
+        return {
+            type: 'problem',
+            detectedBy: {
+                type: 'deployment',
+                stackStatus: stack.StackStatus ?? '',
+                statusReason: stack.StackStatusReason ?? '',
+            },
+            problems: await this.addErrorTraces(errors.all),
+        };
+    }
+    /**
+     * Diagnose a deployment failure via stack events
+     *
+     * This is the same logic that the deployment monitor uses.
+     */
+    async _diagnoseViaStackEvents(stackName, stack) {
+        const poller = new stack_events_1.StackEventPoller(this.cfn, {
+            stackName,
+            initialPollRange: stack_events_1.PollRange.mostRecentOperation(),
+        });
+        // We don't need the resulting events of polling. Polling will automatically update the error collection,
+        // which is the thing we care about.
+        await poller.poll();
+        return this.diagnoseFromErrorCollection(poller.errors, stack);
+    }
+    async _diagnoseChangeSetFailureFromStackName(stackName) {
+        const cs = (await this.cfn.listChangeSets({
+            StackName: stackName,
+        })).Summaries ?? [];
+        const pending = cs.filter(x => x.Status === client_cloudformation_1.ChangeSetStatus.CREATE_IN_PROGRESS || x.Status === client_cloudformation_1.ChangeSetStatus.CREATE_PENDING);
+        if (pending.length > 0) {
+            return {
+                type: 'error-diagnosing',
+                message: `Stack with name ${stackName} has change sets currently being created (${pending[0].ChangeSetName}). Try again when it's finished.`,
+            };
+        }
+        const failed = cs.filter(x => x.Status === client_cloudformation_1.ChangeSetStatus.FAILED);
+        if (failed.length === 0) {
+            return { type: 'no-problem' };
+        }
+        return this._diagnoseChangeSetFailure(failed[0]);
+    }
+    /**
+     * 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.
+     */
+    async _diagnoseChangeSetFailure(changeSet) {
+        if (changeSet.Status !== client_cloudformation_1.ChangeSetStatus.FAILED) {
+            return { type: 'no-problem' };
+        }
+        if (changeSetHasNoChanges(changeSet)) {
+            // This will lead to a change set that is FAILED but it's not actually a problem
+            return { type: 'no-problem' };
+        }
+        const isEarlyValidationError = changeSet.StatusReason?.includes('AWS::EarlyValidation');
+        if (isEarlyValidationError) {
+            const ev = await new early_validation_1.EarlyValidationReporter(this.props.sdk, this.props.envResources)
+                .fetchDetailsStructured(changeSet.ChangeSetName, changeSet.StackName);
+            switch (ev.type) {
+                case 'could-not-check':
+                    // Emit the warning here and otherwise just return an empty error block
+                    await this.props.ioHelper.defaults.warn(ev.message);
+                    return {
+                        type: 'problem',
+                        detectedBy: {
+                            type: 'early-validation',
+                            changeSetName: changeSet.ChangeSetName ?? '',
+                        },
+                        problems: [],
+                    };
+                case 'resource-errors':
+                    return {
+                        type: 'problem',
+                        detectedBy: {
+                            type: 'early-validation',
+                            changeSetName: changeSet.ChangeSetName ?? '',
+                        },
+                        problems: await this.addErrorTraces(ev.errors.map((e) => resourceErrorFromEarlyValidationError(changeSet.StackId ?? '', this.parentStackLogicalIds, e))),
+                    };
+            }
+        }
+        if (changeSet.StatusReason?.includes('Nested change set')) {
+            return this._diagnoseNestedChangeSetFailure(changeSet);
+        }
+        const failedAutoErrors = this._tryDetectFailedAutoImport(changeSet);
+        if (failedAutoErrors) {
+            return {
+                type: 'problem',
+                detectedBy: {
+                    type: 'change-set',
+                    changeSetStatus: changeSet.Status ?? '',
+                    changeSetName: changeSet.ChangeSetName ?? '',
+                    statusReason: changeSet.StatusReason ?? '',
+                },
+                problems: await this.addErrorTraces(failedAutoErrors),
+            };
+        }
+        return this._nonSpecificChangeSetError(changeSet);
+    }
+    async addErrorTraces(errs) {
+        // eslint-disable-next-line @cdklabs/promiseall-no-unbounded-parallelism
+        return Promise.all(errs.map((e) => this.addErrorTrace(e)));
+    }
+    async addErrorTrace(err) {
+        let sourceTrace;
+        if (err.logicalId) {
+            sourceTrace = await this.props.sourceTracer.traceResource(err.stackArn, err.parentStackLogicalIds, err.logicalId);
+        }
+        else {
+            sourceTrace = await this.props.sourceTracer.traceStack(err.stackArn, err.parentStackLogicalIds);
+        }
+        return { ...err, sourceTrace, topLevelStackHierarchicalId: this.props.topLevelStackHierarchicalId };
+    }
+    /**
+     * Build a generic stack error from the given change set information
+     *
+     * We can't point to a specific resource.
+     */
+    async _nonSpecificChangeSetError(changeSet) {
+        return {
+            type: 'problem',
+            detectedBy: {
+                type: 'change-set',
+                changeSetName: changeSet.ChangeSetName ?? '',
+                changeSetStatus: changeSet.Status ?? '',
+                statusReason: changeSet.StatusReason ?? '',
+            },
+            problems: [
+                await this.addErrorTrace({
+                    // It's about a stack
+                    logicalId: undefined,
+                    message: changeSet.StatusReason ?? '',
+                    parentStackLogicalIds: this.parentStackLogicalIds,
+                    stackArn: changeSet.StackId ?? '',
+                    physicalId: changeSet.StackId,
+                    resourceType: 'AWS::CloudFormation::Stack',
+                }),
+            ],
+        };
+    }
+    /**
+     * Look for nested change sets that have failed, and diagnose those.
+     */
+    async _diagnoseNestedChangeSetFailure(changeSet) {
+        const nested = await this._findFailedNestedStack(changeSet);
+        if (!nested) {
+            // That's weird. Let's return the change set's status reason as a non-specific error
+            return this._nonSpecificChangeSetError(changeSet);
+        }
+        const nestedCs = await this.cfn.describeChangeSet({
+            ChangeSetName: nested.changeSetName,
+            StackName: nested.stackName,
+        });
+        const nestedDiag = new CloudFormationStackDiagnoser(this.props);
+        nestedDiag.parentStackLogicalIds = [...this.parentStackLogicalIds, nested.logicalId];
+        return nestedDiag._diagnoseChangeSetFailure(nestedCs);
+    }
+    async _findFailedNestedStack(changeSet) {
+        // The status reason only includes the change set ID, but we also need the stack name. The way to get this is
+        // describe the current change set, then from the Changes find the stack whose ChangeSetId is mentioned in the
+        // status reason, then look up that change set and recurse into a regular change set diagnosis.
+        let nextToken = undefined;
+        do {
+            // Changes in this response might be paginated
+            const resp = await this.cfn.describeChangeSet({
+                StackName: changeSet.StackName,
+                ChangeSetName: changeSet.ChangeSetName,
+                ...nextToken ? { NextToken: nextToken } : {},
+            });
+            for (const change of resp.Changes ?? []) {
+                if (change.Type === client_cloudformation_1.ChangeType.Resource && change.ResourceChange?.ResourceType === 'AWS::CloudFormation::Stack' && change.ResourceChange?.ChangeSetId && changeSet.StatusReason?.includes(change.ResourceChange?.ChangeSetId)) {
+                    return {
+                        changeSetName: change.ResourceChange.ChangeSetId,
+                        stackName: change.ResourceChange.PhysicalResourceId ?? '',
+                        logicalId: change.ResourceChange.LogicalResourceId ?? '',
+                    };
+                }
+            }
+            nextToken = resp.NextToken;
+        } while (nextToken);
+        return undefined;
+    }
+    /**
+     * 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}), ...
+     * ```
+     */
+    _tryDetectFailedAutoImport(changeSet) {
+        const message = changeSet.StatusReason;
+        // Only enhance the specific CFN error about importing existing resources
+        if (!message?.includes('CloudFormation is attempting to import some resources because they already exist in your account')) {
+            return undefined;
+        }
+        const marker = 'The affected resources are ';
+        const markerIndex = message.indexOf(marker);
+        if (markerIndex === -1) {
+            return undefined;
+        }
+        const ret = [];
+        let remaining = message.slice(markerIndex + marker.length);
+        while (remaining) {
+            const endIx = remaining.indexOf('), ');
+            const thisResource = endIx > -1 ? remaining.slice(0, endIx + 1) : remaining;
+            remaining = remaining.slice(thisResource.length + 2);
+            // thisResource = "LogicalId ({Prop=Value, Prop=Value})"
+            const openParen = thisResource.indexOf('(');
+            const logicalId = openParen > -1 ? thisResource.slice(0, openParen).trim() : undefined;
+            ret.push({
+                message: `Automatic import of existing resource ${thisResource} needs a DeletionPolicy of \'Retain\' or \'RetainExceptOnCreate\'. Set the removal policy to \'RemovalPolicy.RETAIN\' or \'RemovalPolicy.RETAIN_ON_UPDATE_OR_DELETE\' (See https://docs.aws.amazon.com/cdk/v2/guide/resources.html#resources-removal)`,
+                parentStackLogicalIds: this.parentStackLogicalIds,
+                stackArn: changeSet.StackId ?? '',
+                errorCode: 'AutomaticImportNeedsRetain',
+                logicalId,
+            });
+        }
+        return ret;
+    }
+}
+exports.CloudFormationStackDiagnoser = CloudFormationStackDiagnoser;
+/**
+ * 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.
+ */
+function changeSetHasNoChanges(description) {
+    const noChangeErrorPrefixes = [
+        // Error message for a regular template
+        "The submitted information didn't contain changes.",
+        // Error message when a Transform is involved (see #10650)
+        'No updates are to be performed.',
+    ];
+    return (description.Status === 'FAILED' && noChangeErrorPrefixes.some((p) => (description.StatusReason ?? '').startsWith(p)));
+}
+function resourceErrorFromEarlyValidationError(stackId, parentStackLogicalIds, ev) {
+    return {
+        logicalId: ev.logicalId,
+        physicalId: ev.physicalId,
+        resourceType: ev.resourceType,
+        message: `${ev.message} (at ${ev.documentPath})`,
+        errorCode: `${ev.validationName}_${ev.eventType}`,
+        parentStackLogicalIds,
+        stackArn: stackId,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stack-diagnoser.js","sourceRoot":"","sources":["stack-diagnoser.ts"],"names":[],"mappings":"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","sourcesContent":["import type { ChangeSetSummary, Stack } from '@aws-sdk/client-cloudformation';\nimport { ChangeSetStatus, ChangeType } from '@aws-sdk/client-cloudformation';\nimport type { EarlyValidationError } from './early-validation';\nimport { EarlyValidationReporter } from './early-validation';\nimport type { StackDiagnosis, TracedResourceError } from '../../actions/diagnose';\nimport type { ICloudFormationClient, SDK } from '../aws-auth/sdk';\nimport type { EnvironmentResources } from '../environment';\nimport type { IoHelper } from '../io/private/io-helper';\nimport type { ISourceTracer } from '../source-tracing/private/source-tracing';\nimport { PollRange, StackEventPoller } from '../stack-events';\nimport type { ResourceError, ResourceErrors } from '../stack-events/resource-errors';\nimport { StackStatus } from '../stack-events/stack-status';\n\nexport interface CloudFormationStackDiagnoserProps {\n  readonly sdk: SDK;\n  readonly envResources?: EnvironmentResources;\n  readonly sourceTracer: ISourceTracer;\n  readonly ioHelper: IoHelper;\n  readonly topLevelStackHierarchicalId: string;\n}\n\n/**\n * Diagnose a stack's failed state\n *\n * - First, determine the stack's state.\n * - If it is in a failed state, we started a deployment that failed. Describe the stack\n *   events, and try to determine the root cause from that.\n * - If it is in a normal state, see if there are any failed change sets. Either\n *   get the failure message from the change set, or get the failure events from\n *   the change set (early validation).\n *\n * This class works at the CloudFormation level, and does not deal with tracing\n * CloudFormation errors to construct code sources yet.\n */\nexport class CloudFormationStackDiagnoser {\n  private readonly cfn: ICloudFormationClient;\n  private parentStackLogicalIds: string[];\n\n  constructor(private readonly props: CloudFormationStackDiagnoserProps) {\n    this.cfn = this.props.sdk.cloudFormation();\n    this.parentStackLogicalIds = [];\n  }\n\n  /**\n   * Diagnose a stack's root cause given no pre-existing state\n   */\n  public async diagnoseFromFresh(stackName: string): Promise<StackDiagnosis> {\n    try {\n      const response = await this.cfn.describeStacks({ StackName: stackName });\n      const stack = response.Stacks?.[0];\n      if (!stack) {\n        return {\n          type: 'error-diagnosing',\n          message: `Stack with name ${stackName} not found`,\n        };\n      }\n\n      const status = StackStatus.fromStackDescription(stack);\n      if (status.isInProgress) {\n        return {\n          type: 'error-diagnosing',\n          message: `Stack with name ${stackName} is currently being updated (${status.name}). Try again when it's finished.`,\n        };\n      }\n\n      if (status.isFailure) {\n        return await this._diagnoseViaStackEvents(stackName, stack);\n      }\n\n      return await this._diagnoseChangeSetFailureFromStackName(stackName);\n    } catch (e: any) {\n      return { type: 'error-diagnosing', message: e.message };\n    }\n  }\n\n  /**\n   * Diagnose potential problems with the change set\n   */\n  public async diagnoseChangeSet(changeSet: ChangeSetSummary): Promise<StackDiagnosis> {\n    try {\n      return await this._diagnoseChangeSetFailure(changeSet);\n    } catch (e: any) {\n      return { type: 'error-diagnosing', message: e.message };\n    }\n  }\n\n  /**\n   * Diagnose potential problems with the change set\n   */\n  public async diagnoseFromErrorCollection(errors: ResourceErrors, stack: Stack): Promise<StackDiagnosis> {\n    if (errors.isEmpty()) {\n      return { type: 'no-problem' };\n    }\n\n    return {\n      type: 'problem',\n      detectedBy: {\n        type: 'deployment',\n        stackStatus: stack.StackStatus ?? '',\n        statusReason: stack.StackStatusReason ?? '',\n      },\n      problems: await this.addErrorTraces(errors.all),\n    };\n  }\n\n  /**\n   * Diagnose a deployment failure via stack events\n   *\n   * This is the same logic that the deployment monitor uses.\n   */\n  private async _diagnoseViaStackEvents(stackName: string, stack: Stack): Promise<StackDiagnosis> {\n    const poller = new StackEventPoller(this.cfn, {\n      stackName,\n      initialPollRange: PollRange.mostRecentOperation(),\n    });\n\n    // We don't need the resulting events of polling. Polling will automatically update the error collection,\n    // which is the thing we care about.\n    await poller.poll();\n\n    return this.diagnoseFromErrorCollection(poller.errors, stack);\n  }\n\n  private async _diagnoseChangeSetFailureFromStackName(stackName: string): Promise<StackDiagnosis> {\n    const cs = (await this.cfn.listChangeSets({\n      StackName: stackName,\n    })).Summaries ?? [];\n\n    const pending = cs.filter(x => x.Status === ChangeSetStatus.CREATE_IN_PROGRESS || x.Status === ChangeSetStatus.CREATE_PENDING);\n    if (pending.length > 0) {\n      return {\n        type: 'error-diagnosing',\n        message: `Stack with name ${stackName} has change sets currently being created (${pending[0].ChangeSetName}). Try again when it's finished.`,\n      };\n    }\n\n    const failed = cs.filter(x => x.Status === ChangeSetStatus.FAILED);\n    if (failed.length === 0) {\n      return { type: 'no-problem' };\n    }\n\n    return this._diagnoseChangeSetFailure(failed[0]);\n  }\n\n  /**\n   * Try to diagnose the reason that caused a changeset to fail to create\n   *\n   * There are a couple of different reasons this can happen, and we go through each of them in order.\n   *\n   * Usually this starts from trying to detect an error message pattern in the change set status reason,\n   * and then potentially going to fetch additional information using additional API calls.\n   */\n  private async _diagnoseChangeSetFailure(changeSet: ChangeSetSummary): Promise<StackDiagnosis> {\n    if (changeSet.Status !== ChangeSetStatus.FAILED) {\n      return { type: 'no-problem' };\n    }\n\n    if (changeSetHasNoChanges(changeSet)) {\n      // This will lead to a change set that is FAILED but it's not actually a problem\n      return { type: 'no-problem' };\n    }\n\n    const isEarlyValidationError = changeSet.StatusReason?.includes('AWS::EarlyValidation');\n    if (isEarlyValidationError) {\n      const ev = await new EarlyValidationReporter(this.props.sdk, this.props.envResources)\n        .fetchDetailsStructured(changeSet.ChangeSetName!, changeSet.StackName!);\n      switch (ev.type) {\n        case 'could-not-check':\n          // Emit the warning here and otherwise just return an empty error block\n          await this.props.ioHelper.defaults.warn(ev.message);\n          return {\n            type: 'problem',\n            detectedBy: {\n              type: 'early-validation',\n              changeSetName: changeSet.ChangeSetName ?? '',\n            },\n            problems: [],\n          };\n        case 'resource-errors':\n          return {\n            type: 'problem',\n            detectedBy: {\n              type: 'early-validation',\n              changeSetName: changeSet.ChangeSetName ?? '',\n            },\n            problems: await this.addErrorTraces(ev.errors.map((e) => resourceErrorFromEarlyValidationError(changeSet.StackId ?? '', this.parentStackLogicalIds, e))),\n          };\n      }\n    }\n\n    if (changeSet.StatusReason?.includes('Nested change set')) {\n      return this._diagnoseNestedChangeSetFailure(changeSet);\n    }\n\n    const failedAutoErrors = this._tryDetectFailedAutoImport(changeSet);\n    if (failedAutoErrors) {\n      return {\n        type: 'problem',\n        detectedBy: {\n          type: 'change-set',\n          changeSetStatus: changeSet.Status ?? '',\n          changeSetName: changeSet.ChangeSetName ?? '',\n          statusReason: changeSet.StatusReason ?? '',\n        },\n        problems: await this.addErrorTraces(failedAutoErrors),\n      };\n    }\n\n    return this._nonSpecificChangeSetError(changeSet);\n  }\n\n  private async addErrorTraces(errs: readonly ResourceError[]): Promise<TracedResourceError[]> {\n    // eslint-disable-next-line @cdklabs/promiseall-no-unbounded-parallelism\n    return Promise.all(errs.map((e) => this.addErrorTrace(e)));\n  }\n\n  private async addErrorTrace(err: ResourceError): Promise<TracedResourceError> {\n    let sourceTrace;\n    if (err.logicalId) {\n      sourceTrace = await this.props.sourceTracer.traceResource(err.stackArn, err.parentStackLogicalIds, err.logicalId);\n    } else {\n      sourceTrace = await this.props.sourceTracer.traceStack(err.stackArn, err.parentStackLogicalIds);\n    }\n\n    return { ...err, sourceTrace, topLevelStackHierarchicalId: this.props.topLevelStackHierarchicalId };\n  }\n\n  /**\n   * Build a generic stack error from the given change set information\n   *\n   * We can't point to a specific resource.\n   */\n  private async _nonSpecificChangeSetError(changeSet: ChangeSetSummary): Promise<StackDiagnosis> {\n    return {\n      type: 'problem',\n      detectedBy: {\n        type: 'change-set',\n        changeSetName: changeSet.ChangeSetName ?? '',\n        changeSetStatus: changeSet.Status ?? '',\n        statusReason: changeSet.StatusReason ?? '',\n      },\n      problems: [\n        await this.addErrorTrace({\n          // It's about a stack\n          logicalId: undefined,\n          message: changeSet.StatusReason ?? '',\n          parentStackLogicalIds: this.parentStackLogicalIds,\n          stackArn: changeSet.StackId ?? '',\n          physicalId: changeSet.StackId,\n          resourceType: 'AWS::CloudFormation::Stack',\n        }),\n      ],\n    };\n  }\n\n  /**\n   * Look for nested change sets that have failed, and diagnose those.\n   */\n  private async _diagnoseNestedChangeSetFailure(changeSet: ChangeSetSummary): Promise<StackDiagnosis> {\n    const nested = await this._findFailedNestedStack(changeSet);\n    if (!nested) {\n      // That's weird. Let's return the change set's status reason as a non-specific error\n      return this._nonSpecificChangeSetError(changeSet);\n    }\n\n    const nestedCs = await this.cfn.describeChangeSet({\n      ChangeSetName: nested.changeSetName,\n      StackName: nested.stackName,\n    });\n\n    const nestedDiag = new CloudFormationStackDiagnoser(this.props);\n    nestedDiag.parentStackLogicalIds = [...this.parentStackLogicalIds, nested.logicalId];\n    return nestedDiag._diagnoseChangeSetFailure(nestedCs);\n  }\n\n  private async _findFailedNestedStack(changeSet: ChangeSetSummary): Promise<{\n    stackName: string;\n    changeSetName: string;\n    logicalId: string;\n  } | undefined> {\n    // The status reason only includes the change set ID, but we also need the stack name. The way to get this is\n    // describe the current change set, then from the Changes find the stack whose ChangeSetId is mentioned in the\n    // status reason, then look up that change set and recurse into a regular change set diagnosis.\n    let nextToken = undefined;\n    do {\n      // Changes in this response might be paginated\n      const resp = await this.cfn.describeChangeSet({\n        StackName: changeSet.StackName,\n        ChangeSetName: changeSet.ChangeSetName,\n        ...nextToken ? { NextToken: nextToken } : {},\n      });\n\n      for (const change of resp.Changes ?? []) {\n        if (change.Type === ChangeType.Resource && change.ResourceChange?.ResourceType === 'AWS::CloudFormation::Stack' && change.ResourceChange?.ChangeSetId && changeSet.StatusReason?.includes(change.ResourceChange?.ChangeSetId)) {\n          return {\n            changeSetName: change.ResourceChange.ChangeSetId,\n            stackName: change.ResourceChange.PhysicalResourceId ?? '',\n            logicalId: change.ResourceChange.LogicalResourceId ?? '',\n          };\n        }\n      }\n\n      nextToken = resp.NextToken;\n    } while (nextToken);\n\n    return undefined;\n  }\n\n  /**\n   * Try to parse failed auto-imports out from a change set status\n   *\n   * The pattern looks like this:\n   *\n   * ```\n   * 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})\n   * ```\n   *\n   * Followed by\n   *\n   * ```\n   * LogicalID ({Prop=Value,Prop=Value}), LogicalID ({Prop=Value}), ...\n   * ```\n   */\n  private _tryDetectFailedAutoImport(changeSet: ChangeSetSummary): ResourceError[] | undefined {\n    const message = changeSet.StatusReason;\n    // Only enhance the specific CFN error about importing existing resources\n    if (!message?.includes('CloudFormation is attempting to import some resources because they already exist in your account')) {\n      return undefined;\n    }\n\n    const marker = 'The affected resources are ';\n    const markerIndex = message.indexOf(marker);\n    if (markerIndex === -1) {\n      return undefined;\n    }\n\n    const ret: ResourceError[] = [];\n    let remaining = message.slice(markerIndex + marker.length);\n    while (remaining) {\n      const endIx = remaining.indexOf('), ');\n      const thisResource = endIx > -1 ? remaining.slice(0, endIx + 1) : remaining;\n      remaining = remaining.slice(thisResource.length + 2);\n\n      // thisResource = \"LogicalId ({Prop=Value, Prop=Value})\"\n      const openParen = thisResource.indexOf('(');\n      const logicalId = openParen > -1 ? thisResource.slice(0, openParen).trim() : undefined;\n\n      ret.push({\n        message: `Automatic import of existing resource ${thisResource} needs a DeletionPolicy of \\'Retain\\' or \\'RetainExceptOnCreate\\'. Set the removal policy to \\'RemovalPolicy.RETAIN\\' or \\'RemovalPolicy.RETAIN_ON_UPDATE_OR_DELETE\\' (See https://docs.aws.amazon.com/cdk/v2/guide/resources.html#resources-removal)`,\n        parentStackLogicalIds: this.parentStackLogicalIds,\n        stackArn: changeSet.StackId ?? '',\n        errorCode: 'AutomaticImportNeedsRetain',\n        logicalId,\n      });\n    }\n    return ret;\n  }\n}\n\n/**\n * Return true if the given change set has no changes\n *\n * This must be determined from the status, not the 'Changes' array on the\n * object; the latter can be empty because no resources were changed, but if\n * there are changes to Outputs, the change set can still be executed.\n */\nexport function changeSetHasNoChanges(description: ChangeSetSummary) {\n  const noChangeErrorPrefixes = [\n    // Error message for a regular template\n    \"The submitted information didn't contain changes.\",\n    // Error message when a Transform is involved (see #10650)\n    'No updates are to be performed.',\n  ];\n\n  return (\n    description.Status === 'FAILED' && noChangeErrorPrefixes.some((p) => (description.StatusReason ?? '').startsWith(p))\n  );\n}\n\nfunction resourceErrorFromEarlyValidationError(stackId: string, parentStackLogicalIds: string[], ev: EarlyValidationError): ResourceError {\n  return {\n    logicalId: ev.logicalId,\n    physicalId: ev.physicalId,\n    resourceType: ev.resourceType,\n    message: `${ev.message} (at ${ev.documentPath})`,\n    errorCode: `${ev.validationName}_${ev.eventType}`,\n    parentStackLogicalIds,\n    stackArn: stackId,\n  };\n}\n"]}

package/lib/api/diagnosing/tree-builder.d.ts

@@ -0,0 +1,12 @@
+export declare class TreeBuilder {
+    private readonly rootText;
+    private readonly root;
+    constructor(rootText: string);
+    setNodeText(constructPath: string, nodeText: string): void;
+    render(): string;
+    toString(): string;
+    private obtainNode;
+}
+export declare function sideBySide(left: string[], sep: string, right: string[]): string[];
+export declare function wrapText(n: number, text: string): string[];
+//# sourceMappingURL=tree-builder.d.ts.map