dcl-ops-lib 7.0.0 → 8.0.1

package/createFargateTask.d.ts

@@ -56,13 +56,25 @@ export type FargateTaskOptions = {
     runtimePlatform?: aws.types.input.ecs.TaskDefinitionRuntimePlatform;
     appAutoscaling?: {
         maxCapacity: number;
-        items: {
+        policy?: {
             metricName: string;
             targetValue: number;
             metricDimensionValue: pulumi.Output<string>;
-            statistic?: "Average" | "Minimum" | "Maximum";
-            scaleOutCooldown?: number;
-            scaleInCooldown?: number;
+            statistic: "Average" | "Minimum" | "Maximum";
+            scaleOutCooldown: number;
+            scaleInCooldown: number;
+        }[];
+        scheduleAction?: {
+            minCapacity: number;
+            maxCapacity: number;
+            /**
+             * Must be in one of the following formats:
+             * At expressions - "at(yyyy-mm-ddThh:mm:ss)"
+             * Rate expressions - "rate(value unit)"
+             * Cron expressions - "cron(fields)"
+             * @type {string}
+            */
+            schedule: string;
         }[];
     };
 };
@@ -117,13 +129,25 @@ export type InternalServiceOptions = {
     runtimePlatform?: aws.types.input.ecs.TaskDefinitionRuntimePlatform;
     appAutoscaling?: {
         maxCapacity: number;
-        items: {
+        policy?: {
             metricName: string;
             targetValue: number;
             metricDimensionValue: pulumi.Output<string>;
-            statistic?: "Average" | "Minimum" | "Maximum";
-            scaleOutCooldown?: number;
-            scaleInCooldown?: number;
+            statistic: "Average" | "Minimum" | "Maximum";
+            scaleOutCooldown: number;
+            scaleInCooldown: number;
+        }[];
+        scheduleAction?: {
+            maxCapacity: number;
+            minCapacity: number;
+            /**
+             * Must be in one of the following formats:
+             * At expressions - "at(yyyy-mm-ddThh:mm:ss)"
+             * Rate expressions - "rate(value unit)"
+             * Cron expressions - "cron(fields)"
+             * @type {string}
+             */
+            schedule: string;
         }[];
     };
 };

package/createFargateTask.js

@@ -372,15 +372,18 @@ function createInternalService(config) {
                 })),
             ],
         }, Object.assign(Object.assign({}, extraOpts), { dependsOn }));
-        if (!!appAutoscaling) {
-            setAutoscaling(service, serviceName, Object.assign(Object.assign({}, appAutoscaling), { desiredCount }));
+        if (appAutoscaling) {
+            setAutoscaling(service, serviceName, { appAutoscaling, desiredCount });
         }
         return service;
     });
 }
 function setAutoscaling(service, serviceName, config) {
+    if ((!config.appAutoscaling.policy && !config.appAutoscaling.scheduleAction) || (config.appAutoscaling.policy && config.appAutoscaling.scheduleAction)) {
+        throw new Error("Invalid autoscaling configuration. You must provide either a policy OR a scheduleAction.");
+    }
     const ecsTarget = new aws.appautoscaling.Target(`ecs-target-${(0, stack_1.getStackScopedName)(serviceName)}`, {
-        maxCapacity: config.maxCapacity,
+        maxCapacity: config.appAutoscaling.maxCapacity,
         minCapacity: config.desiredCount,
         resourceId: service.id.apply((id) => {
             return id.split(":").pop();
@@ -388,39 +391,55 @@ function setAutoscaling(service, serviceName, config) {
         scalableDimension: "ecs:service:DesiredCount",
         serviceNamespace: "ecs",
     });
-    config.items.forEach((item, index) => {
-        const CSM_ApproximateNumberOfMessagesVisible = {
-            metricName: item.metricName,
-            namespace: "AWS/SQS",
-            dimensions: [
-                {
-                    name: "QueueName",
-                    value: item.metricDimensionValue.apply((value) => {
-                        return value.split("/").pop();
-                    }),
+    if (config.appAutoscaling.policy) {
+        config.appAutoscaling.policy.forEach((item, index) => {
+            const CSM_ApproximateNumberOfMessagesVisible = {
+                metricName: item.metricName,
+                namespace: "AWS/SQS",
+                dimensions: [
+                    {
+                        name: "QueueName",
+                        value: item.metricDimensionValue.apply((value) => {
+                            return value.split("/").pop();
+                        }),
+                    },
+                ],
+                statistic: item.statistic,
+                unit: "Count",
+            };
+            let TTS_CustomizedMetricSpecification = undefined;
+            if (item.metricName === "ApproximateNumberOfMessagesVisible") {
+                TTS_CustomizedMetricSpecification =
+                    CSM_ApproximateNumberOfMessagesVisible;
+            }
+            return new aws.appautoscaling.Policy(`ecs-autoscaling-policy-${(0, stack_1.getStackScopedName)(serviceName)}-${index.toString()}`, // distinct policies by id
+            {
+                policyType: "TargetTrackingScaling",
+                resourceId: ecsTarget.resourceId,
+                scalableDimension: pulumi.interpolate `${ecsTarget.scalableDimension}`,
+                serviceNamespace: "ecs",
+                targetTrackingScalingPolicyConfiguration: {
+                    targetValue: item.targetValue,
+                    customizedMetricSpecification: TTS_CustomizedMetricSpecification,
+                    scaleOutCooldown: item.scaleOutCooldown,
+                    scaleInCooldown: item.scaleInCooldown,
                 },
-            ],
-            statistic: item.statistic,
-            unit: "Count",
-        };
-        let TTS_CustomizedMetricSpecification = undefined;
-        if (item.metricName === "ApproximateNumberOfMessagesVisible") {
-            TTS_CustomizedMetricSpecification =
-                CSM_ApproximateNumberOfMessagesVisible;
-        }
-        return new aws.appautoscaling.Policy(`ecs-autoscaling-policy-${(0, stack_1.getStackScopedName)(serviceName)}-${index.toString()}`, // distinct policies by id
-        {
-            policyType: "TargetTrackingScaling",
-            resourceId: ecsTarget.resourceId,
-            scalableDimension: pulumi.interpolate `${ecsTarget.scalableDimension}`,
-            serviceNamespace: "ecs",
-            targetTrackingScalingPolicyConfiguration: {
-                targetValue: item.targetValue,
-                customizedMetricSpecification: TTS_CustomizedMetricSpecification,
-                scaleOutCooldown: item.scaleOutCooldown,
-                scaleInCooldown: item.scaleInCooldown,
-            },
-        }, { dependsOn: [ecsTarget] });
-    });
+            }, { dependsOn: [ecsTarget] });
+        });
+    }
+    else if (config.appAutoscaling.scheduleAction) {
+        config.appAutoscaling.scheduleAction.forEach((item, index) => {
+            return new aws.appautoscaling.ScheduledAction(`ecs-scheduled-action-${(0, stack_1.getStackScopedName)(serviceName)}-${index.toString()}`, {
+                serviceNamespace: ecsTarget.serviceNamespace,
+                resourceId: ecsTarget.resourceId,
+                scalableDimension: ecsTarget.scalableDimension,
+                schedule: item.schedule,
+                scalableTargetAction: {
+                    minCapacity: item.minCapacity,
+                    maxCapacity: item.maxCapacity,
+                },
+            }, { dependsOn: [ecsTarget] });
+        });
+    }
 }
 //# sourceMappingURL=createFargateTask.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dcl-ops-lib",
-  "version": "7.0.0",
+  "version": "8.0.1",
   "scripts": {
     "build": "tsc && cp bin/* . && node test.js",
     "clean": "rm *.d.ts *.js *.js.map"