@aws-cdk/toolkit-lib 0.3.1 → 0.3.3

package/lib/api/hotswap/code-build-projects.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isHotswappableCodeBuildProjectChange = isHotswappableCodeBuildProjectChange;
+const common_1 = require("./common");
+const util_1 = require("../../util");
+async function isHotswappableCodeBuildProjectChange(logicalId, change, evaluateCfnTemplate) {
+    if (change.newValue.Type !== 'AWS::CodeBuild::Project') {
+        return [];
+    }
+    const ret = [];
+    const classifiedChanges = (0, common_1.classifyChanges)(change, ['Source', 'Environment', 'SourceVersion']);
+    classifiedChanges.reportNonHotswappablePropertyChanges(ret);
+    if (classifiedChanges.namesOfHotswappableProps.length > 0) {
+        const updateProjectInput = {
+            name: '',
+        };
+        const projectName = await evaluateCfnTemplate.establishResourcePhysicalName(logicalId, change.newValue.Properties?.Name);
+        // nothing to do jere
+        if (!projectName) {
+            return ret;
+        }
+        ret.push({
+            change: {
+                cause: change,
+                resources: [{
+                        logicalId: logicalId,
+                        resourceType: change.newValue.Type,
+                        physicalName: projectName,
+                        metadata: evaluateCfnTemplate.metadataFor(logicalId),
+                    }],
+            },
+            hotswappable: true,
+            service: 'codebuild',
+            apply: async (sdk) => {
+                updateProjectInput.name = projectName;
+                for (const updatedPropName in change.propertyUpdates) {
+                    const updatedProp = change.propertyUpdates[updatedPropName];
+                    switch (updatedPropName) {
+                        case 'Source':
+                            updateProjectInput.source = (0, util_1.transformObjectKeys)(await evaluateCfnTemplate.evaluateCfnExpression(updatedProp.newValue), convertSourceCloudformationKeyToSdkKey);
+                            break;
+                        case 'Environment':
+                            updateProjectInput.environment = await (0, util_1.transformObjectKeys)(await evaluateCfnTemplate.evaluateCfnExpression(updatedProp.newValue), util_1.lowerCaseFirstCharacter);
+                            break;
+                        case 'SourceVersion':
+                            updateProjectInput.sourceVersion = await evaluateCfnTemplate.evaluateCfnExpression(updatedProp.newValue);
+                            break;
+                    }
+                }
+                await sdk.codeBuild().updateProject(updateProjectInput);
+            },
+        });
+    }
+    return ret;
+}
+function convertSourceCloudformationKeyToSdkKey(key) {
+    if (key.toLowerCase() === 'buildspec') {
+        return key.toLowerCase();
+    }
+    return (0, util_1.lowerCaseFirstCharacter)(key);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/hotswap/common.d.ts

@@ -0,0 +1,89 @@
+import type { PropertyDifference } from '@aws-cdk/cloudformation-diff';
+import type { HotswappableChange, NonHotswappableChange, ResourceChange } from '../../payloads/hotswap';
+import { NonHotswappableReason } from '../../payloads/hotswap';
+import type { SDK } from '../aws-auth/private';
+export declare const ICON = "\u2728";
+export interface HotswapOperation {
+    /**
+     * Marks the operation as hotswappable
+     */
+    readonly hotswappable: true;
+    /**
+     * The name of the service being hotswapped.
+     * Used to set a custom User-Agent for SDK calls.
+     */
+    readonly service: string;
+    /**
+     * Description of the change that is applied as part of the operation
+     */
+    readonly change: HotswappableChange;
+    /**
+     * Applies the hotswap operation
+     */
+    readonly apply: (sdk: SDK) => Promise<void>;
+}
+export interface RejectedChange {
+    /**
+     * Marks the change as not hotswappable
+     */
+    readonly hotswappable: false;
+    /**
+     * The change that got rejected
+     */
+    readonly change: NonHotswappableChange;
+    /**
+     * Whether or not to show this change when listing non-hotswappable changes in HOTSWAP_ONLY mode. Does not affect
+     * listing in FALL_BACK mode.
+     *
+     * @default true
+     */
+    readonly hotswapOnlyVisible?: boolean;
+}
+export type HotswapChange = HotswapOperation | RejectedChange;
+export declare enum HotswapMode {
+    /**
+     * Will fall back to CloudFormation when a non-hotswappable change is detected
+     */
+    FALL_BACK = "fall-back",
+    /**
+     * Will not fall back to CloudFormation when a non-hotswappable change is detected
+     */
+    HOTSWAP_ONLY = "hotswap-only",
+    /**
+     * Will not attempt to hotswap anything and instead go straight to CloudFormation
+     */
+    FULL_DEPLOYMENT = "full-deployment"
+}
+/**
+ * Represents configuration property overrides for hotswap deployments
+ */
+export declare class HotswapPropertyOverrides {
+    ecsHotswapProperties?: EcsHotswapProperties;
+    constructor(ecsHotswapProperties?: EcsHotswapProperties);
+}
+/**
+ * Represents configuration properties for ECS hotswap deployments
+ */
+export declare class EcsHotswapProperties {
+    readonly minimumHealthyPercent?: number;
+    readonly maximumHealthyPercent?: number;
+    constructor(minimumHealthyPercent?: number, maximumHealthyPercent?: number);
+    /**
+     * Check if any hotswap properties are defined
+     * @returns true if all properties are undefined, false otherwise
+     */
+    isEmpty(): boolean;
+}
+type PropDiffs = Record<string, PropertyDifference<any>>;
+declare class ClassifiedChanges {
+    readonly change: ResourceChange;
+    readonly hotswappableProps: PropDiffs;
+    readonly nonHotswappableProps: PropDiffs;
+    constructor(change: ResourceChange, hotswappableProps: PropDiffs, nonHotswappableProps: PropDiffs);
+    reportNonHotswappablePropertyChanges(ret: HotswapChange[]): void;
+    get namesOfHotswappableProps(): string[];
+}
+export declare function classifyChanges(xs: ResourceChange, hotswappablePropNames: string[]): ClassifiedChanges;
+export declare function nonHotswappableChange(change: ResourceChange, reason: NonHotswappableReason, description: string, nonHotswappableProps?: PropDiffs, hotswapOnlyVisible?: boolean): RejectedChange;
+export declare function nonHotswappableResource(change: ResourceChange): RejectedChange;
+export {};

package/lib/api/hotswap/common.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EcsHotswapProperties = exports.HotswapPropertyOverrides = exports.HotswapMode = exports.ICON = void 0;
+exports.classifyChanges = classifyChanges;
+exports.nonHotswappableChange = nonHotswappableChange;
+exports.nonHotswappableResource = nonHotswappableResource;
+const hotswap_1 = require("../../payloads/hotswap");
+const toolkit_error_1 = require("../toolkit-error");
+exports.ICON = '✨';
+var HotswapMode;
+(function (HotswapMode) {
+    /**
+     * Will fall back to CloudFormation when a non-hotswappable change is detected
+     */
+    HotswapMode["FALL_BACK"] = "fall-back";
+    /**
+     * Will not fall back to CloudFormation when a non-hotswappable change is detected
+     */
+    HotswapMode["HOTSWAP_ONLY"] = "hotswap-only";
+    /**
+     * Will not attempt to hotswap anything and instead go straight to CloudFormation
+     */
+    HotswapMode["FULL_DEPLOYMENT"] = "full-deployment";
+})(HotswapMode || (exports.HotswapMode = HotswapMode = {}));
+/**
+ * Represents configuration property overrides for hotswap deployments
+ */
+class HotswapPropertyOverrides {
+    // Each supported resource type will have its own properties. Currently this is ECS
+    ecsHotswapProperties;
+    constructor(ecsHotswapProperties) {
+        this.ecsHotswapProperties = ecsHotswapProperties;
+    }
+}
+exports.HotswapPropertyOverrides = HotswapPropertyOverrides;
+/**
+ * Represents configuration properties for ECS hotswap deployments
+ */
+class EcsHotswapProperties {
+    // The lower limit on the number of your service's tasks that must remain in the RUNNING state during a deployment, as a percentage of the desiredCount
+    minimumHealthyPercent;
+    // The upper limit on the number of your service's tasks that are allowed in the RUNNING or PENDING state during a deployment, as a percentage of the desiredCount
+    maximumHealthyPercent;
+    constructor(minimumHealthyPercent, maximumHealthyPercent) {
+        if (minimumHealthyPercent !== undefined && minimumHealthyPercent < 0) {
+            throw new toolkit_error_1.ToolkitError('hotswap-ecs-minimum-healthy-percent can\'t be a negative number');
+        }
+        if (maximumHealthyPercent !== undefined && maximumHealthyPercent < 0) {
+            throw new toolkit_error_1.ToolkitError('hotswap-ecs-maximum-healthy-percent can\'t be a negative number');
+        }
+        // In order to preserve the current behaviour, when minimumHealthyPercent is not defined, it will be set to the currently default value of 0
+        if (minimumHealthyPercent == undefined) {
+            this.minimumHealthyPercent = 0;
+        }
+        else {
+            this.minimumHealthyPercent = minimumHealthyPercent;
+        }
+        this.maximumHealthyPercent = maximumHealthyPercent;
+    }
+    /**
+     * Check if any hotswap properties are defined
+     * @returns true if all properties are undefined, false otherwise
+     */
+    isEmpty() {
+        return this.minimumHealthyPercent === 0 && this.maximumHealthyPercent === undefined;
+    }
+}
+exports.EcsHotswapProperties = EcsHotswapProperties;
+class ClassifiedChanges {
+    change;
+    hotswappableProps;
+    nonHotswappableProps;
+    constructor(change, hotswappableProps, nonHotswappableProps) {
+        this.change = change;
+        this.hotswappableProps = hotswappableProps;
+        this.nonHotswappableProps = nonHotswappableProps;
+    }
+    reportNonHotswappablePropertyChanges(ret) {
+        const nonHotswappablePropNames = Object.keys(this.nonHotswappableProps);
+        if (nonHotswappablePropNames.length > 0) {
+            const tagOnlyChange = nonHotswappablePropNames.length === 1 && nonHotswappablePropNames[0] === 'Tags';
+            const reason = tagOnlyChange ? hotswap_1.NonHotswappableReason.TAGS : hotswap_1.NonHotswappableReason.PROPERTIES;
+            const description = tagOnlyChange ? 'Tags are not hotswappable' : `resource properties '${nonHotswappablePropNames}' are not hotswappable on this resource type`;
+            ret.push(nonHotswappableChange(this.change, reason, description, this.nonHotswappableProps));
+        }
+    }
+    get namesOfHotswappableProps() {
+        return Object.keys(this.hotswappableProps);
+    }
+}
+function classifyChanges(xs, hotswappablePropNames) {
+    const hotswappableProps = {};
+    const nonHotswappableProps = {};
+    for (const [name, propDiff] of Object.entries(xs.propertyUpdates)) {
+        if (hotswappablePropNames.includes(name)) {
+            hotswappableProps[name] = propDiff;
+        }
+        else {
+            nonHotswappableProps[name] = propDiff;
+        }
+    }
+    return new ClassifiedChanges(xs, hotswappableProps, nonHotswappableProps);
+}
+function nonHotswappableChange(change, reason, description, nonHotswappableProps, hotswapOnlyVisible = true) {
+    return {
+        hotswappable: false,
+        hotswapOnlyVisible,
+        change: {
+            reason,
+            description,
+            subject: {
+                type: 'Resource',
+                logicalId: change.logicalId,
+                resourceType: change.newValue.Type,
+                rejectedProperties: Object.keys(nonHotswappableProps ?? change.propertyUpdates),
+                metadata: change.metadata,
+            },
+        },
+    };
+}
+function nonHotswappableResource(change) {
+    return {
+        hotswappable: false,
+        change: {
+            reason: hotswap_1.NonHotswappableReason.RESOURCE_UNSUPPORTED,
+            description: 'This resource type is not supported for hotswap deployments',
+            subject: {
+                type: 'Resource',
+                logicalId: change.logicalId,
+                resourceType: change.newValue.Type,
+                rejectedProperties: Object.keys(change.propertyUpdates),
+                metadata: change.metadata,
+            },
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"common.js","sourceRoot":"","sources":["common.ts"],"names":[],"mappings":"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","sourcesContent":["import type { PropertyDifference } from '@aws-cdk/cloudformation-diff';\nimport type { HotswappableChange, NonHotswappableChange, ResourceChange } from '../../payloads/hotswap';\nimport { NonHotswappableReason } from '../../payloads/hotswap';\nimport type { SDK } from '../aws-auth/private';\nimport { ToolkitError } from '../toolkit-error';\n\nexport const ICON = '✨';\n\nexport interface HotswapOperation {\n  /**\n   * Marks the operation as hotswappable\n   */\n  readonly hotswappable: true;\n\n  /**\n   * The name of the service being hotswapped.\n   * Used to set a custom User-Agent for SDK calls.\n   */\n  readonly service: string;\n\n  /**\n   * Description of the change that is applied as part of the operation\n   */\n  readonly change: HotswappableChange;\n\n  /**\n   * Applies the hotswap operation\n   */\n  readonly apply: (sdk: SDK) => Promise<void>;\n}\n\nexport interface RejectedChange {\n  /**\n   * Marks the change as not hotswappable\n   */\n  readonly hotswappable: false;\n  /**\n   * The change that got rejected\n   */\n  readonly change: NonHotswappableChange;\n  /**\n   * Whether or not to show this change when listing non-hotswappable changes in HOTSWAP_ONLY mode. Does not affect\n   * listing in FALL_BACK mode.\n   *\n   * @default true\n   */\n  readonly hotswapOnlyVisible?: boolean;\n}\n\nexport type HotswapChange = HotswapOperation | RejectedChange;\n\nexport enum HotswapMode {\n  /**\n   * Will fall back to CloudFormation when a non-hotswappable change is detected\n   */\n  FALL_BACK = 'fall-back',\n\n  /**\n   * Will not fall back to CloudFormation when a non-hotswappable change is detected\n   */\n  HOTSWAP_ONLY = 'hotswap-only',\n\n  /**\n   * Will not attempt to hotswap anything and instead go straight to CloudFormation\n   */\n  FULL_DEPLOYMENT = 'full-deployment',\n}\n\n/**\n * Represents configuration property overrides for hotswap deployments\n */\nexport class HotswapPropertyOverrides {\n  // Each supported resource type will have its own properties. Currently this is ECS\n  ecsHotswapProperties?: EcsHotswapProperties;\n\n  public constructor (ecsHotswapProperties?: EcsHotswapProperties) {\n    this.ecsHotswapProperties = ecsHotswapProperties;\n  }\n}\n\n/**\n * Represents configuration properties for ECS hotswap deployments\n */\nexport class EcsHotswapProperties {\n  // The lower limit on the number of your service's tasks that must remain in the RUNNING state during a deployment, as a percentage of the desiredCount\n  readonly minimumHealthyPercent?: number;\n  // The upper limit on the number of your service's tasks that are allowed in the RUNNING or PENDING state during a deployment, as a percentage of the desiredCount\n  readonly maximumHealthyPercent?: number;\n\n  public constructor (minimumHealthyPercent?: number, maximumHealthyPercent?: number) {\n    if (minimumHealthyPercent !== undefined && minimumHealthyPercent < 0 ) {\n      throw new ToolkitError('hotswap-ecs-minimum-healthy-percent can\\'t be a negative number');\n    }\n    if (maximumHealthyPercent !== undefined && maximumHealthyPercent < 0 ) {\n      throw new ToolkitError('hotswap-ecs-maximum-healthy-percent can\\'t be a negative number');\n    }\n    // In order to preserve the current behaviour, when minimumHealthyPercent is not defined, it will be set to the currently default value of 0\n    if (minimumHealthyPercent == undefined) {\n      this.minimumHealthyPercent = 0;\n    } else {\n      this.minimumHealthyPercent = minimumHealthyPercent;\n    }\n    this.maximumHealthyPercent = maximumHealthyPercent;\n  }\n\n  /**\n   * Check if any hotswap properties are defined\n   * @returns true if all properties are undefined, false otherwise\n   */\n  public isEmpty(): boolean {\n    return this.minimumHealthyPercent === 0 && this.maximumHealthyPercent === undefined;\n  }\n}\n\ntype PropDiffs = Record<string, PropertyDifference<any>>;\n\nclass ClassifiedChanges {\n  public constructor(\n    public readonly change: ResourceChange,\n    public readonly hotswappableProps: PropDiffs,\n    public readonly nonHotswappableProps: PropDiffs,\n  ) {\n  }\n\n  public reportNonHotswappablePropertyChanges(ret: HotswapChange[]): void {\n    const nonHotswappablePropNames = Object.keys(this.nonHotswappableProps);\n    if (nonHotswappablePropNames.length > 0) {\n      const tagOnlyChange = nonHotswappablePropNames.length === 1 && nonHotswappablePropNames[0] === 'Tags';\n      const reason = tagOnlyChange ? NonHotswappableReason.TAGS : NonHotswappableReason.PROPERTIES;\n      const description = tagOnlyChange ? 'Tags are not hotswappable' : `resource properties '${nonHotswappablePropNames}' are not hotswappable on this resource type`;\n\n      ret.push(nonHotswappableChange(\n        this.change,\n        reason,\n        description,\n        this.nonHotswappableProps,\n      ));\n    }\n  }\n\n  public get namesOfHotswappableProps(): string[] {\n    return Object.keys(this.hotswappableProps);\n  }\n}\n\nexport function classifyChanges(xs: ResourceChange, hotswappablePropNames: string[]): ClassifiedChanges {\n  const hotswappableProps: PropDiffs = {};\n  const nonHotswappableProps: PropDiffs = {};\n\n  for (const [name, propDiff] of Object.entries(xs.propertyUpdates)) {\n    if (hotswappablePropNames.includes(name)) {\n      hotswappableProps[name] = propDiff;\n    } else {\n      nonHotswappableProps[name] = propDiff;\n    }\n  }\n\n  return new ClassifiedChanges(xs, hotswappableProps, nonHotswappableProps);\n}\n\nexport function nonHotswappableChange(\n  change: ResourceChange,\n  reason: NonHotswappableReason,\n  description: string,\n  nonHotswappableProps?: PropDiffs,\n  hotswapOnlyVisible: boolean = true,\n): RejectedChange {\n  return {\n    hotswappable: false,\n    hotswapOnlyVisible,\n    change: {\n      reason,\n      description,\n      subject: {\n        type: 'Resource',\n        logicalId: change.logicalId,\n        resourceType: change.newValue.Type,\n        rejectedProperties: Object.keys(nonHotswappableProps ?? change.propertyUpdates),\n        metadata: change.metadata,\n      },\n    },\n  };\n}\n\nexport function nonHotswappableResource(change: ResourceChange): RejectedChange {\n  return {\n    hotswappable: false,\n    change: {\n      reason: NonHotswappableReason.RESOURCE_UNSUPPORTED,\n      description: 'This resource type is not supported for hotswap deployments',\n      subject: {\n        type: 'Resource',\n        logicalId: change.logicalId,\n        resourceType: change.newValue.Type,\n        rejectedProperties: Object.keys(change.propertyUpdates),\n        metadata: change.metadata,\n      },\n    },\n  };\n}\n"]}

package/lib/api/hotswap/ecs-services.d.ts

@@ -0,0 +1,4 @@
+import type { HotswapPropertyOverrides, HotswapChange } from './common';
+import { type ResourceChange } from '../../payloads/hotswap';
+import type { EvaluateCloudFormationTemplate } from '../cloudformation';
+export declare function isHotswappableEcsServiceChange(logicalId: string, change: ResourceChange, evaluateCfnTemplate: EvaluateCloudFormationTemplate, hotswapPropertyOverrides: HotswapPropertyOverrides): Promise<HotswapChange[]>;

package/lib/api/hotswap/ecs-services.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isHotswappableEcsServiceChange = isHotswappableEcsServiceChange;
+const common_1 = require("./common");
+const hotswap_1 = require("../../payloads/hotswap");
+const util_1 = require("../../util");
+const ECS_SERVICE_RESOURCE_TYPE = 'AWS::ECS::Service';
+async function isHotswappableEcsServiceChange(logicalId, change, evaluateCfnTemplate, hotswapPropertyOverrides) {
+    // the only resource change we can evaluate here is an ECS TaskDefinition
+    if (change.newValue.Type !== 'AWS::ECS::TaskDefinition') {
+        return [];
+    }
+    const ret = [];
+    // We only allow a change in the ContainerDefinitions of the TaskDefinition for now -
+    // it contains the image and environment variables, so seems like a safe bet for now.
+    // We might revisit this decision in the future though!
+    const classifiedChanges = (0, common_1.classifyChanges)(change, ['ContainerDefinitions']);
+    classifiedChanges.reportNonHotswappablePropertyChanges(ret);
+    // find all ECS Services that reference the TaskDefinition that changed
+    const resourcesReferencingTaskDef = evaluateCfnTemplate.findReferencesTo(logicalId);
+    const ecsServiceResourcesReferencingTaskDef = resourcesReferencingTaskDef.filter((r) => r.Type === ECS_SERVICE_RESOURCE_TYPE);
+    const ecsServicesReferencingTaskDef = new Array();
+    for (const ecsServiceResource of ecsServiceResourcesReferencingTaskDef) {
+        const serviceArn = await evaluateCfnTemplate.findPhysicalNameFor(ecsServiceResource.LogicalId);
+        if (serviceArn) {
+            ecsServicesReferencingTaskDef.push({
+                logicalId: ecsServiceResource.LogicalId,
+                serviceArn,
+            });
+        }
+    }
+    if (ecsServicesReferencingTaskDef.length === 0) {
+        /**
+         * ECS Services can have a task definition that doesn't refer to the task definition being updated.
+         * We have to log this as a non-hotswappable change to the task definition, but when we do,
+         * we wind up hotswapping the task definition and logging it as a non-hotswappable change.
+         *
+         * This logic prevents us from logging that change as non-hotswappable when we hotswap it.
+         */
+        ret.push((0, common_1.nonHotswappableChange)(change, hotswap_1.NonHotswappableReason.DEPENDENCY_UNSUPPORTED, 'No ECS services reference the changed task definition', undefined, false));
+    }
+    if (resourcesReferencingTaskDef.length > ecsServicesReferencingTaskDef.length) {
+        // if something besides an ECS Service is referencing the TaskDefinition,
+        // hotswap is not possible in FALL_BACK mode
+        const nonEcsServiceTaskDefRefs = resourcesReferencingTaskDef.filter((r) => r.Type !== ECS_SERVICE_RESOURCE_TYPE);
+        for (const taskRef of nonEcsServiceTaskDefRefs) {
+            ret.push((0, common_1.nonHotswappableChange)(change, hotswap_1.NonHotswappableReason.DEPENDENCY_UNSUPPORTED, `A resource '${taskRef.LogicalId}' with Type '${taskRef.Type}' that is not an ECS Service was found referencing the changed TaskDefinition '${logicalId}'`));
+        }
+    }
+    const namesOfHotswappableChanges = Object.keys(classifiedChanges.hotswappableProps);
+    if (namesOfHotswappableChanges.length > 0) {
+        const taskDefinitionResource = await prepareTaskDefinitionChange(evaluateCfnTemplate, logicalId, change);
+        ret.push({
+            change: {
+                cause: change,
+                resources: [
+                    {
+                        logicalId,
+                        resourceType: change.newValue.Type,
+                        physicalName: await taskDefinitionResource.Family,
+                        metadata: evaluateCfnTemplate.metadataFor(logicalId),
+                    },
+                    ...ecsServicesReferencingTaskDef.map((ecsService) => ({
+                        resourceType: ECS_SERVICE_RESOURCE_TYPE,
+                        physicalName: ecsService.serviceArn.split('/')[2],
+                        logicalId: ecsService.logicalId,
+                        metadata: evaluateCfnTemplate.metadataFor(ecsService.logicalId),
+                    })),
+                ],
+            },
+            hotswappable: true,
+            service: 'ecs-service',
+            apply: async (sdk) => {
+                // Step 1 - update the changed TaskDefinition, creating a new TaskDefinition Revision
+                // we need to lowercase the evaluated TaskDef from CloudFormation,
+                // as the AWS SDK uses lowercase property names for these
+                // The SDK requires more properties here than its worth doing explicit typing for
+                // instead, just use all the old values in the diff to fill them in implicitly
+                const lowercasedTaskDef = (0, util_1.transformObjectKeys)(taskDefinitionResource, util_1.lowerCaseFirstCharacter, {
+                    // All the properties that take arbitrary string as keys i.e. { "string" : "string" }
+                    // https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_RegisterTaskDefinition.html#API_RegisterTaskDefinition_RequestSyntax
+                    ContainerDefinitions: {
+                        DockerLabels: true,
+                        FirelensConfiguration: {
+                            Options: true,
+                        },
+                        LogConfiguration: {
+                            Options: true,
+                        },
+                    },
+                    Volumes: {
+                        DockerVolumeConfiguration: {
+                            DriverOpts: true,
+                            Labels: true,
+                        },
+                    },
+                });
+                const registerTaskDefResponse = await sdk.ecs().registerTaskDefinition(lowercasedTaskDef);
+                const taskDefRevArn = registerTaskDefResponse.taskDefinition?.taskDefinitionArn;
+                let ecsHotswapProperties = hotswapPropertyOverrides.ecsHotswapProperties;
+                let minimumHealthyPercent = ecsHotswapProperties?.minimumHealthyPercent;
+                let maximumHealthyPercent = ecsHotswapProperties?.maximumHealthyPercent;
+                // Step 2 - update the services using that TaskDefinition to point to the new TaskDefinition Revision
+                // Forcing New Deployment and setting Minimum Healthy Percent to 0.
+                // As CDK HotSwap is development only, this seems the most efficient way to ensure all tasks are replaced immediately, regardless of original amount
+                // eslint-disable-next-line @cdklabs/promiseall-no-unbounded-parallelism
+                await Promise.all(ecsServicesReferencingTaskDef.map(async (service) => {
+                    const cluster = service.serviceArn.split('/')[1];
+                    const update = await sdk.ecs().updateService({
+                        service: service.serviceArn,
+                        taskDefinition: taskDefRevArn,
+                        cluster,
+                        forceNewDeployment: true,
+                        deploymentConfiguration: {
+                            minimumHealthyPercent: minimumHealthyPercent !== undefined ? minimumHealthyPercent : 0,
+                            maximumPercent: maximumHealthyPercent !== undefined ? maximumHealthyPercent : undefined,
+                        },
+                    });
+                    await sdk.ecs().waitUntilServicesStable({
+                        cluster: update.service?.clusterArn,
+                        services: [service.serviceArn],
+                    });
+                }));
+            },
+        });
+    }
+    return ret;
+}
+async function prepareTaskDefinitionChange(evaluateCfnTemplate, logicalId, change) {
+    const taskDefinitionResource = {
+        ...change.oldValue.Properties,
+        ContainerDefinitions: change.newValue.Properties?.ContainerDefinitions,
+    };
+    // first, let's get the name of the family
+    const familyNameOrArn = await evaluateCfnTemplate.establishResourcePhysicalName(logicalId, taskDefinitionResource?.Family);
+    if (!familyNameOrArn) {
+        // if the Family property has not been provided, and we can't find it in the current Stack,
+        // this means hotswapping is not possible
+        return;
+    }
+    // the physical name of the Task Definition in CloudFormation includes its current revision number at the end,
+    // remove it if needed
+    const familyNameOrArnParts = familyNameOrArn.split(':');
+    const family = familyNameOrArnParts.length > 1
+        ? // familyNameOrArn is actually an ARN, of the format 'arn:aws:ecs:region:account:task-definition/<family-name>:<revision-nr>'
+            // so, take the 6th element, at index 5, and split it on '/'
+            familyNameOrArnParts[5].split('/')[1]
+        : // otherwise, familyNameOrArn is just the simple name evaluated from the CloudFormation template
+            familyNameOrArn;
+    // then, let's evaluate the body of the remainder of the TaskDef (without the Family property)
+    return {
+        ...(await evaluateCfnTemplate.evaluateCfnExpression({
+            ...(taskDefinitionResource ?? {}),
+            Family: undefined,
+        })),
+        Family: family,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ecs-services.js","sourceRoot":"","sources":["ecs-services.ts"],"names":[],"mappings":"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","sourcesContent":["import type {\n  HotswapPropertyOverrides,\n  HotswapChange,\n} from './common';\nimport {\n  classifyChanges,\n  nonHotswappableChange,\n} from './common';\nimport { NonHotswappableReason, type ResourceChange } from '../../payloads/hotswap';\nimport { lowerCaseFirstCharacter, transformObjectKeys } from '../../util';\nimport type { SDK } from '../aws-auth/private';\nimport type { EvaluateCloudFormationTemplate } from '../cloudformation';\n\nconst ECS_SERVICE_RESOURCE_TYPE = 'AWS::ECS::Service';\n\nexport async function isHotswappableEcsServiceChange(\n  logicalId: string,\n  change: ResourceChange,\n  evaluateCfnTemplate: EvaluateCloudFormationTemplate,\n  hotswapPropertyOverrides: HotswapPropertyOverrides,\n): Promise<HotswapChange[]> {\n  // the only resource change we can evaluate here is an ECS TaskDefinition\n  if (change.newValue.Type !== 'AWS::ECS::TaskDefinition') {\n    return [];\n  }\n\n  const ret: HotswapChange[] = [];\n\n  // We only allow a change in the ContainerDefinitions of the TaskDefinition for now -\n  // it contains the image and environment variables, so seems like a safe bet for now.\n  // We might revisit this decision in the future though!\n  const classifiedChanges = classifyChanges(change, ['ContainerDefinitions']);\n  classifiedChanges.reportNonHotswappablePropertyChanges(ret);\n\n  // find all ECS Services that reference the TaskDefinition that changed\n  const resourcesReferencingTaskDef = evaluateCfnTemplate.findReferencesTo(logicalId);\n  const ecsServiceResourcesReferencingTaskDef = resourcesReferencingTaskDef.filter(\n    (r) => r.Type === ECS_SERVICE_RESOURCE_TYPE,\n  );\n  const ecsServicesReferencingTaskDef = new Array<EcsService>();\n  for (const ecsServiceResource of ecsServiceResourcesReferencingTaskDef) {\n    const serviceArn = await evaluateCfnTemplate.findPhysicalNameFor(ecsServiceResource.LogicalId);\n    if (serviceArn) {\n      ecsServicesReferencingTaskDef.push({\n        logicalId: ecsServiceResource.LogicalId,\n        serviceArn,\n      });\n    }\n  }\n  if (ecsServicesReferencingTaskDef.length === 0) {\n    /**\n     * ECS Services can have a task definition that doesn't refer to the task definition being updated.\n     * We have to log this as a non-hotswappable change to the task definition, but when we do,\n     * we wind up hotswapping the task definition and logging it as a non-hotswappable change.\n     *\n     * This logic prevents us from logging that change as non-hotswappable when we hotswap it.\n     */\n    ret.push(nonHotswappableChange(\n      change,\n      NonHotswappableReason.DEPENDENCY_UNSUPPORTED,\n      'No ECS services reference the changed task definition',\n      undefined,\n      false,\n    ));\n  }\n  if (resourcesReferencingTaskDef.length > ecsServicesReferencingTaskDef.length) {\n    // if something besides an ECS Service is referencing the TaskDefinition,\n    // hotswap is not possible in FALL_BACK mode\n    const nonEcsServiceTaskDefRefs = resourcesReferencingTaskDef.filter((r) => r.Type !== ECS_SERVICE_RESOURCE_TYPE);\n    for (const taskRef of nonEcsServiceTaskDefRefs) {\n      ret.push(nonHotswappableChange(\n        change,\n        NonHotswappableReason.DEPENDENCY_UNSUPPORTED,\n        `A resource '${taskRef.LogicalId}' with Type '${taskRef.Type}' that is not an ECS Service was found referencing the changed TaskDefinition '${logicalId}'`,\n      ));\n    }\n  }\n\n  const namesOfHotswappableChanges = Object.keys(classifiedChanges.hotswappableProps);\n  if (namesOfHotswappableChanges.length > 0) {\n    const taskDefinitionResource = await prepareTaskDefinitionChange(evaluateCfnTemplate, logicalId, change);\n    ret.push({\n      change: {\n        cause: change,\n        resources: [\n          {\n            logicalId,\n            resourceType: change.newValue.Type,\n            physicalName: await taskDefinitionResource.Family,\n            metadata: evaluateCfnTemplate.metadataFor(logicalId),\n          },\n          ...ecsServicesReferencingTaskDef.map((ecsService) => ({\n            resourceType: ECS_SERVICE_RESOURCE_TYPE,\n            physicalName: ecsService.serviceArn.split('/')[2],\n            logicalId: ecsService.logicalId,\n            metadata: evaluateCfnTemplate.metadataFor(ecsService.logicalId),\n          })),\n        ],\n      },\n      hotswappable: true,\n      service: 'ecs-service',\n      apply: async (sdk: SDK) => {\n        // Step 1 - update the changed TaskDefinition, creating a new TaskDefinition Revision\n        // we need to lowercase the evaluated TaskDef from CloudFormation,\n        // as the AWS SDK uses lowercase property names for these\n\n        // The SDK requires more properties here than its worth doing explicit typing for\n        // instead, just use all the old values in the diff to fill them in implicitly\n        const lowercasedTaskDef = transformObjectKeys(taskDefinitionResource, lowerCaseFirstCharacter, {\n          // All the properties that take arbitrary string as keys i.e. { \"string\" : \"string\" }\n          // https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_RegisterTaskDefinition.html#API_RegisterTaskDefinition_RequestSyntax\n          ContainerDefinitions: {\n            DockerLabels: true,\n            FirelensConfiguration: {\n              Options: true,\n            },\n            LogConfiguration: {\n              Options: true,\n            },\n          },\n          Volumes: {\n            DockerVolumeConfiguration: {\n              DriverOpts: true,\n              Labels: true,\n            },\n          },\n        });\n        const registerTaskDefResponse = await sdk.ecs().registerTaskDefinition(lowercasedTaskDef);\n        const taskDefRevArn = registerTaskDefResponse.taskDefinition?.taskDefinitionArn;\n\n        let ecsHotswapProperties = hotswapPropertyOverrides.ecsHotswapProperties;\n        let minimumHealthyPercent = ecsHotswapProperties?.minimumHealthyPercent;\n        let maximumHealthyPercent = ecsHotswapProperties?.maximumHealthyPercent;\n\n        // Step 2 - update the services using that TaskDefinition to point to the new TaskDefinition Revision\n        // Forcing New Deployment and setting Minimum Healthy Percent to 0.\n        // As CDK HotSwap is development only, this seems the most efficient way to ensure all tasks are replaced immediately, regardless of original amount\n        // eslint-disable-next-line @cdklabs/promiseall-no-unbounded-parallelism\n        await Promise.all(\n          ecsServicesReferencingTaskDef.map(async (service) => {\n            const cluster = service.serviceArn.split('/')[1];\n            const update = await sdk.ecs().updateService({\n              service: service.serviceArn,\n              taskDefinition: taskDefRevArn,\n              cluster,\n              forceNewDeployment: true,\n              deploymentConfiguration: {\n                minimumHealthyPercent: minimumHealthyPercent !== undefined ? minimumHealthyPercent : 0,\n                maximumPercent: maximumHealthyPercent !== undefined ? maximumHealthyPercent : undefined,\n              },\n            });\n\n            await sdk.ecs().waitUntilServicesStable({\n              cluster: update.service?.clusterArn,\n              services: [service.serviceArn],\n            });\n          }),\n        );\n      },\n    });\n  }\n\n  return ret;\n}\n\ninterface EcsService {\n  readonly logicalId: string;\n  readonly serviceArn: string;\n}\n\nasync function prepareTaskDefinitionChange(\n  evaluateCfnTemplate: EvaluateCloudFormationTemplate,\n  logicalId: string,\n  change: ResourceChange,\n) {\n  const taskDefinitionResource: { [name: string]: any } = {\n    ...change.oldValue.Properties,\n    ContainerDefinitions: change.newValue.Properties?.ContainerDefinitions,\n  };\n  // first, let's get the name of the family\n  const familyNameOrArn = await evaluateCfnTemplate.establishResourcePhysicalName(\n    logicalId,\n    taskDefinitionResource?.Family,\n  );\n  if (!familyNameOrArn) {\n    // if the Family property has not been provided, and we can't find it in the current Stack,\n    // this means hotswapping is not possible\n    return;\n  }\n  // the physical name of the Task Definition in CloudFormation includes its current revision number at the end,\n  // remove it if needed\n  const familyNameOrArnParts = familyNameOrArn.split(':');\n  const family =\n    familyNameOrArnParts.length > 1\n      ? // familyNameOrArn is actually an ARN, of the format 'arn:aws:ecs:region:account:task-definition/<family-name>:<revision-nr>'\n    // so, take the 6th element, at index 5, and split it on '/'\n      familyNameOrArnParts[5].split('/')[1]\n      : // otherwise, familyNameOrArn is just the simple name evaluated from the CloudFormation template\n      familyNameOrArn;\n  // then, let's evaluate the body of the remainder of the TaskDef (without the Family property)\n  return {\n    ...(await evaluateCfnTemplate.evaluateCfnExpression({\n      ...(taskDefinitionResource ?? {}),\n      Family: undefined,\n    })),\n    Family: family,\n  };\n}\n"]}

package/lib/api/hotswap/hotswap-deployments.d.ts

@@ -0,0 +1,17 @@
+import type * as cxapi from '@aws-cdk/cx-api';
+import type { SdkProvider } from '../aws-auth/private';
+import type { CloudFormationStack } from '../cloudformation';
+import type { HotswapPropertyOverrides } from './common';
+import type { SuccessfulDeployStackResult } from '../deployments';
+import type { IoHelper } from '../io/private';
+type HotswapMode = 'hotswap-only' | 'fall-back';
+/**
+ * Perform a hotswap deployment, short-circuiting CloudFormation if possible.
+ * If it's not possible to short-circuit the deployment
+ * (because the CDK Stack contains changes that cannot be deployed without CloudFormation),
+ * returns `undefined`.
+ */
+export declare function tryHotswapDeployment(sdkProvider: SdkProvider, ioHelper: IoHelper, assetParams: {
+    [key: string]: string;
+}, cloudFormationStack: CloudFormationStack, stackArtifact: cxapi.CloudFormationStackArtifact, hotswapMode: HotswapMode, hotswapPropertyOverrides: HotswapPropertyOverrides): Promise<SuccessfulDeployStackResult | undefined>;
+export {};