ec2-instance-running-scheduler 0.1.1

package/lib/constructs/ec2-instance-running-scheduler.d.ts

@@ -0,0 +1,62 @@
+import { TimeZone } from 'aws-cdk-lib';
+import { Construct } from 'constructs';
+/**
+ * Cron-style schedule configuration for start/stop actions.
+ */
+export interface Schedule {
+    /** Time zone for the schedule (e.g. ETC_UTC). */
+    readonly timezone: TimeZone;
+    /** Cron minute (0–59). */
+    readonly minute?: string;
+    /** Cron hour (0–23). */
+    readonly hour?: string;
+    /** Cron day of week (e.g. MON-FRI). */
+    readonly week?: string;
+}
+/**
+ * Defines which EC2 instances are targeted by tag key and values.
+ */
+export interface TargetResource {
+    /** Tag key used to select instances (e.g. Schedule). */
+    readonly tagKey: string;
+    /** Tag values that match instances to include. */
+    readonly tagValues: string[];
+}
+/**
+ * Secret identifiers required by the scheduler (e.g. Slack).
+ */
+export interface Secrets {
+    /** Name of the Secrets Manager secret containing Slack token and channel. */
+    readonly slackSecretName: string;
+}
+/**
+ * Properties for creating an EC2 instance running scheduler.
+ */
+export interface EC2InstanceRunningSchedulerProps {
+    /** Tag-based targeting for EC2 instances to start/stop. */
+    readonly targetResource: TargetResource;
+    /** Whether EventBridge Scheduler rules are enabled. Defaults to true if omitted. */
+    readonly enableScheduling?: boolean;
+    /** Secrets (e.g. Slack) used for notifications. */
+    readonly secrets: Secrets;
+    /** Cron schedule for stopping instances. */
+    readonly stopSchedule?: Schedule;
+    /** Cron schedule for starting instances. */
+    readonly startSchedule?: Schedule;
+}
+/**
+ * Provisions EventBridge Scheduler rules and a Durable Execution Lambda that start/stop tagged EC2 instances.
+ *
+ * Each schedule invokes the function with `Params` (`TagKey`, `TagValues`, `Mode`). The function uses
+ * the Resource Groups Tagging API and EC2 APIs; Slack notifications use the secret named in {@link Secrets.slackSecretName}.
+ */
+export declare class EC2InstanceRunningScheduler extends Construct {
+    /**
+     * Defines IAM, logging, two cron schedules (start/stop), and the bundled running-scheduler Lambda (Node.js, Durable Execution).
+     *
+     * @param scope - Parent construct.
+     * @param id - Construct id.
+     * @param props - Target tags, optional cron overrides, Slack secret name, and schedule enable flag.
+     */
+    constructor(scope: Construct, id: string, props: EC2InstanceRunningSchedulerProps);
+}

package/lib/constructs/ec2-instance-running-scheduler.js

@@ -0,0 +1,143 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EC2InstanceRunningScheduler = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const iam = require("aws-cdk-lib/aws-iam");
+const lambda = require("aws-cdk-lib/aws-lambda");
+const logs = require("aws-cdk-lib/aws-logs");
+const scheduler = require("aws-cdk-lib/aws-scheduler");
+const targets = require("aws-cdk-lib/aws-scheduler-targets");
+const aws_secretsmanager_1 = require("aws-cdk-lib/aws-secretsmanager");
+const constructs_1 = require("constructs");
+const running_scheduler_function_1 = require("../funcs/running-scheduler-function");
+/**
+ * Provisions EventBridge Scheduler rules and a Durable Execution Lambda that start/stop tagged EC2 instances.
+ *
+ * Each schedule invokes the function with `Params` (`TagKey`, `TagValues`, `Mode`). The function uses
+ * the Resource Groups Tagging API and EC2 APIs; Slack notifications use the secret named in {@link Secrets.slackSecretName}.
+ */
+class EC2InstanceRunningScheduler extends constructs_1.Construct {
+    /**
+     * Defines IAM, logging, two cron schedules (start/stop), and the bundled running-scheduler Lambda (Node.js, Durable Execution).
+     *
+     * @param scope - Parent construct.
+     * @param id - Construct id.
+     * @param props - Target tags, optional cron overrides, Slack secret name, and schedule enable flag.
+     */
+    constructor(scope, id, props) {
+        super(scope, id);
+        const slackSecret = aws_secretsmanager_1.Secret.fromSecretNameV2(this, 'SlackSecret', props.secrets.slackSecretName);
+        // Durable Functions-based Running Scheduler (previous Step Functions logic implemented in Lambda).
+        // Durable Execution requires Node.js 22+.
+        const runningScheduleFunction = new running_scheduler_function_1.RunningSchedulerFunction(this, 'RunningSchedulerFunction', {
+            description: 'Starts and stops tagged EC2 instances on EventBridge Scheduler schedules.',
+            architecture: lambda.Architecture.ARM_64,
+            timeout: aws_cdk_lib_1.Duration.minutes(15),
+            memorySize: 512,
+            retryAttempts: 2,
+            durableConfig: {
+                executionTimeout: aws_cdk_lib_1.Duration.hours(2),
+                retentionPeriod: aws_cdk_lib_1.Duration.days(1),
+            },
+            environment: {
+                SLACK_SECRET_NAME: props.secrets.slackSecretName,
+            },
+            paramsAndSecrets: lambda.ParamsAndSecretsLayerVersion.fromVersion(lambda.ParamsAndSecretsVersions.V1_0_103, {
+                cacheSize: 500,
+                logLevel: lambda.ParamsAndSecretsLogLevel.INFO,
+            }),
+            role: new iam.Role(this, 'RunningSchedulerFunctionRole', {
+                description: 'Allows the running scheduler to describe, start, and stop EC2 instances and read Slack secrets.',
+                assumedBy: new iam.ServicePrincipal('lambda.amazonaws.com'),
+                managedPolicies: [
+                    iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSLambdaBasicExecutionRole'),
+                    iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSLambdaBasicDurableExecutionRolePolicy'),
+                ],
+            }),
+            logGroup: new logs.LogGroup(this, 'RunningSchedulerFunctionLogGroup', {
+                retention: logs.RetentionDays.THREE_MONTHS,
+                removalPolicy: aws_cdk_lib_1.RemovalPolicy.DESTROY,
+            }),
+            loggingFormat: lambda.LoggingFormat.JSON,
+            systemLogLevelV2: lambda.SystemLogLevel.INFO,
+            applicationLogLevelV2: lambda.ApplicationLogLevel.INFO,
+        });
+        runningScheduleFunction.addToRolePolicy(new iam.PolicyStatement({
+            sid: 'GetResources',
+            effect: iam.Effect.ALLOW,
+            actions: [
+                'tag:GetResources',
+            ],
+            resources: ['*'],
+        }));
+        // EC2: describe instances and start/stop by instance id
+        runningScheduleFunction.addToRolePolicy(new iam.PolicyStatement({
+            sid: 'Ec2RunningControl',
+            effect: iam.Effect.ALLOW,
+            actions: [
+                'ec2:DescribeInstances',
+                'ec2:StartInstances',
+                'ec2:StopInstances',
+            ],
+            resources: ['*'],
+        }));
+        // Grant read access to the Slack secret
+        slackSecret.grantRead(runningScheduleFunction);
+        // See: https://docs.aws.amazon.com/lambda/latest/dg/durable-getting-started-iac.html
+        const runningScheduleFunctionAlias = runningScheduleFunction.addAlias('live');
+        // Whether schedules are enabled (default true unless explicitly disabled).
+        const scheduleEnabled = (() => {
+            if (props.enableScheduling === undefined || props.enableScheduling) {
+                return true;
+            }
+            else {
+                return false;
+            }
+        })();
+        // Durable Functions: Lambda performs tag lookup and instance start/stop in a single run.
+        new scheduler.Schedule(this, 'RunningStartSchedule', {
+            description: 'running start schedule',
+            enabled: scheduleEnabled,
+            schedule: scheduler.ScheduleExpression.cron({
+                minute: props.startSchedule?.minute ?? '50',
+                hour: props.startSchedule?.hour ?? '7',
+                weekDay: props.startSchedule?.week ?? 'MON-FRI',
+                timeZone: props.startSchedule?.timezone ?? aws_cdk_lib_1.TimeZone.ETC_UTC,
+            }),
+            target: new targets.LambdaInvoke(runningScheduleFunctionAlias, {
+                input: scheduler.ScheduleTargetInput.fromObject({
+                    Params: {
+                        TagKey: props.targetResource.tagKey,
+                        TagValues: props.targetResource.tagValues,
+                        Mode: 'Start',
+                    },
+                }),
+            }),
+        });
+        new scheduler.Schedule(this, 'RunningStopSchedule', {
+            description: 'running stop schedule',
+            enabled: scheduleEnabled,
+            schedule: scheduler.ScheduleExpression.cron({
+                minute: props.stopSchedule?.minute ?? '5',
+                hour: props.stopSchedule?.hour ?? '19',
+                weekDay: props.stopSchedule?.week ?? 'MON-FRI',
+                timeZone: props.stopSchedule?.timezone ?? aws_cdk_lib_1.TimeZone.ETC_UTC,
+            }),
+            target: new targets.LambdaInvoke(runningScheduleFunctionAlias, {
+                input: scheduler.ScheduleTargetInput.fromObject({
+                    Params: {
+                        TagKey: props.targetResource.tagKey,
+                        TagValues: props.targetResource.tagValues,
+                        Mode: 'Stop',
+                    },
+                }),
+            }),
+        });
+    }
+}
+exports.EC2InstanceRunningScheduler = EC2InstanceRunningScheduler;
+_a = JSII_RTTI_SYMBOL_1;
+EC2InstanceRunningScheduler[_a] = { fqn: "ec2-instance-running-scheduler.EC2InstanceRunningScheduler", version: "0.1.1" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ec2-instance-running-scheduler.js","sourceRoot":"","sources":["../../src/constructs/ec2-instance-running-scheduler.ts"],"names":[],"mappings":"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","sourcesContent":["import { Duration, RemovalPolicy, TimeZone } from 'aws-cdk-lib';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport * as lambda from 'aws-cdk-lib/aws-lambda';\nimport * as logs from 'aws-cdk-lib/aws-logs';\nimport * as scheduler from 'aws-cdk-lib/aws-scheduler';\nimport * as targets from 'aws-cdk-lib/aws-scheduler-targets';\nimport { Secret } from 'aws-cdk-lib/aws-secretsmanager';\nimport { Construct } from 'constructs';\nimport { RunningSchedulerFunction } from '../funcs/running-scheduler-function';\n\n/**\n * Cron-style schedule configuration for start/stop actions.\n */\nexport interface Schedule {\n  /** Time zone for the schedule (e.g. ETC_UTC). */\n  readonly timezone: TimeZone;\n  /** Cron minute (0–59). */\n  readonly minute?: string;\n  /** Cron hour (0–23). */\n  readonly hour?: string;\n  /** Cron day of week (e.g. MON-FRI). */\n  readonly week?: string;\n}\n\n/**\n * Defines which EC2 instances are targeted by tag key and values.\n */\nexport interface TargetResource {\n  /** Tag key used to select instances (e.g. Schedule). */\n  readonly tagKey: string;\n  /** Tag values that match instances to include. */\n  readonly tagValues: string[];\n}\n\n/**\n * Secret identifiers required by the scheduler (e.g. Slack).\n */\nexport interface Secrets {\n  /** Name of the Secrets Manager secret containing Slack token and channel. */\n  readonly slackSecretName: string;\n}\n\n/**\n * Properties for creating an EC2 instance running scheduler.\n */\nexport interface EC2InstanceRunningSchedulerProps {\n  /** Tag-based targeting for EC2 instances to start/stop. */\n  readonly targetResource: TargetResource;\n  /** Whether EventBridge Scheduler rules are enabled. Defaults to true if omitted. */\n  readonly enableScheduling?: boolean;\n  /** Secrets (e.g. Slack) used for notifications. */\n  readonly secrets: Secrets;\n  /** Cron schedule for stopping instances. */\n  readonly stopSchedule?: Schedule;\n  /** Cron schedule for starting instances. */\n  readonly startSchedule?: Schedule;\n}\n\n/**\n * Provisions EventBridge Scheduler rules and a Durable Execution Lambda that start/stop tagged EC2 instances.\n *\n * Each schedule invokes the function with `Params` (`TagKey`, `TagValues`, `Mode`). The function uses\n * the Resource Groups Tagging API and EC2 APIs; Slack notifications use the secret named in {@link Secrets.slackSecretName}.\n */\nexport class EC2InstanceRunningScheduler extends Construct {\n  /**\n   * Defines IAM, logging, two cron schedules (start/stop), and the bundled running-scheduler Lambda (Node.js, Durable Execution).\n   *\n   * @param scope - Parent construct.\n   * @param id - Construct id.\n   * @param props - Target tags, optional cron overrides, Slack secret name, and schedule enable flag.\n   */\n  constructor(scope: Construct, id: string, props: EC2InstanceRunningSchedulerProps) {\n    super(scope, id);\n\n    const slackSecret = Secret.fromSecretNameV2(this, 'SlackSecret', props.secrets.slackSecretName);\n\n    // Durable Functions-based Running Scheduler (previous Step Functions logic implemented in Lambda).\n    // Durable Execution requires Node.js 22+.\n    const runningScheduleFunction = new RunningSchedulerFunction(this, 'RunningSchedulerFunction', {\n      description: 'Starts and stops tagged EC2 instances on EventBridge Scheduler schedules.',\n      architecture: lambda.Architecture.ARM_64,\n      timeout: Duration.minutes(15),\n      memorySize: 512,\n      retryAttempts: 2,\n      durableConfig: {\n        executionTimeout: Duration.hours(2),\n        retentionPeriod: Duration.days(1),\n      },\n      environment: {\n        SLACK_SECRET_NAME: props.secrets.slackSecretName,\n      },\n      paramsAndSecrets: lambda.ParamsAndSecretsLayerVersion.fromVersion(lambda.ParamsAndSecretsVersions.V1_0_103, {\n        cacheSize: 500,\n        logLevel: lambda.ParamsAndSecretsLogLevel.INFO,\n      }),\n      role: new iam.Role(this, 'RunningSchedulerFunctionRole', {\n        description: 'Allows the running scheduler to describe, start, and stop EC2 instances and read Slack secrets.',\n        assumedBy: new iam.ServicePrincipal('lambda.amazonaws.com'),\n        managedPolicies: [\n          iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSLambdaBasicExecutionRole'),\n          iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSLambdaBasicDurableExecutionRolePolicy'),\n        ],\n      }),\n      logGroup: new logs.LogGroup(this, 'RunningSchedulerFunctionLogGroup', {\n        retention: logs.RetentionDays.THREE_MONTHS,\n        removalPolicy: RemovalPolicy.DESTROY,\n      }),\n      loggingFormat: lambda.LoggingFormat.JSON,\n      systemLogLevelV2: lambda.SystemLogLevel.INFO,\n      applicationLogLevelV2: lambda.ApplicationLogLevel.INFO,\n    });\n    runningScheduleFunction.addToRolePolicy(new iam.PolicyStatement({\n      sid: 'GetResources',\n      effect: iam.Effect.ALLOW,\n      actions: [\n        'tag:GetResources',\n      ],\n      resources: ['*'],\n    }));\n    // EC2: describe instances and start/stop by instance id\n    runningScheduleFunction.addToRolePolicy(new iam.PolicyStatement({\n      sid: 'Ec2RunningControl',\n      effect: iam.Effect.ALLOW,\n      actions: [\n        'ec2:DescribeInstances',\n        'ec2:StartInstances',\n        'ec2:StopInstances',\n      ],\n      resources: ['*'],\n    }));\n    // Grant read access to the Slack secret\n    slackSecret.grantRead(runningScheduleFunction);\n\n    // See: https://docs.aws.amazon.com/lambda/latest/dg/durable-getting-started-iac.html\n    const runningScheduleFunctionAlias = runningScheduleFunction.addAlias('live');\n\n    // Whether schedules are enabled (default true unless explicitly disabled).\n    const scheduleEnabled: boolean = (() => {\n      if (props.enableScheduling === undefined || props.enableScheduling) {\n        return true;\n      } else {\n        return false;\n      }\n    })();\n\n    // Durable Functions: Lambda performs tag lookup and instance start/stop in a single run.\n    new scheduler.Schedule(this, 'RunningStartSchedule', {\n      description: 'running start schedule',\n      enabled: scheduleEnabled,\n      schedule: scheduler.ScheduleExpression.cron({\n        minute: props.startSchedule?.minute ?? '50',\n        hour: props.startSchedule?.hour ?? '7',\n        weekDay: props.startSchedule?.week ?? 'MON-FRI',\n        timeZone: props.startSchedule?.timezone ?? TimeZone.ETC_UTC,\n      }),\n      target: new targets.LambdaInvoke(runningScheduleFunctionAlias, {\n        input: scheduler.ScheduleTargetInput.fromObject({\n          Params: {\n            TagKey: props.targetResource.tagKey,\n            TagValues: props.targetResource.tagValues,\n            Mode: 'Start',\n          },\n        }),\n      }),\n    });\n\n    new scheduler.Schedule(this, 'RunningStopSchedule', {\n      description: 'running stop schedule',\n      enabled: scheduleEnabled,\n      schedule: scheduler.ScheduleExpression.cron({\n        minute: props.stopSchedule?.minute ?? '5',\n        hour: props.stopSchedule?.hour ?? '19',\n        weekDay: props.stopSchedule?.week ?? 'MON-FRI',\n        timeZone: props.stopSchedule?.timezone ?? TimeZone.ETC_UTC,\n      }),\n      target: new targets.LambdaInvoke(runningScheduleFunctionAlias, {\n        input: scheduler.ScheduleTargetInput.fromObject({\n          Params: {\n            TagKey: props.targetResource.tagKey,\n            TagValues: props.targetResource.tagValues,\n            Mode: 'Stop',\n          },\n        }),\n      }),\n    });\n  }\n}\n"]}

package/lib/funcs/running-scheduler-function.d.ts

@@ -0,0 +1,13 @@
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+import { Construct } from 'constructs';
+/**
+ * Props for RunningSchedulerFunction
+ */
+export interface RunningSchedulerFunctionProps extends lambda.FunctionOptions {
+}
+/**
+ * An AWS Lambda function which executes src/funcs/running-scheduler.
+ */
+export declare class RunningSchedulerFunction extends lambda.Function {
+    constructor(scope: Construct, id: string, props?: RunningSchedulerFunctionProps);
+}

package/lib/funcs/running-scheduler-function.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunningSchedulerFunction = void 0;
+// ~~ Generated by projen. To modify, edit .projenrc.ts and run "npx projen".
+const path = require("path");
+const lambda = require("aws-cdk-lib/aws-lambda");
+/**
+ * An AWS Lambda function which executes src/funcs/running-scheduler.
+ */
+class RunningSchedulerFunction extends lambda.Function {
+    constructor(scope, id, props) {
+        super(scope, id, {
+            description: 'src/funcs/running-scheduler.lambda.ts',
+            ...props,
+            runtime: new lambda.Runtime('nodejs24.x', lambda.RuntimeFamily.NODEJS),
+            handler: 'index.handler',
+            code: lambda.Code.fromAsset(path.join(__dirname, '../../assets/funcs/running-scheduler.lambda')),
+        });
+        this.addEnvironment('AWS_NODEJS_CONNECTION_REUSE_ENABLED', '1', { removeInEdge: true });
+    }
+}
+exports.RunningSchedulerFunction = RunningSchedulerFunction;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/funcs/running-scheduler-predicates.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Pure predicates for the EC2 running scheduler Lambda (no AWS SDK).
+ */
+/** Value of `Params.Mode` from the EventBridge Scheduler payload. */
+export type RunningSchedulerMode = 'Start' | 'Stop';
+/**
+ * Whether the instance is already in the goal state for the scheduler mode (no start/stop needed).
+ *
+ * @param mode - `Start` expects `running`; `Stop` expects `stopped`.
+ * @param currentState - Instance state from `DescribeInstances` (e.g. `running`, `pending`).
+ * @returns `true` when the instance matches the target state for `mode`.
+ */
+export declare const isDesiredStableState: (mode: RunningSchedulerMode, currentState: string) => boolean;

package/lib/funcs/running-scheduler-predicates.js

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * Pure predicates for the EC2 running scheduler Lambda (no AWS SDK).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDesiredStableState = void 0;
+/**
+ * Whether the instance is already in the goal state for the scheduler mode (no start/stop needed).
+ *
+ * @param mode - `Start` expects `running`; `Stop` expects `stopped`.
+ * @param currentState - Instance state from `DescribeInstances` (e.g. `running`, `pending`).
+ * @returns `true` when the instance matches the target state for `mode`.
+ */
+const isDesiredStableState = (mode, currentState) => (mode === 'Start' && currentState === 'running') || (mode === 'Stop' && currentState === 'stopped');
+exports.isDesiredStableState = isDesiredStableState;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVubmluZy1zY2hlZHVsZXItcHJlZGljYXRlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9mdW5jcy9ydW5uaW5nLXNjaGVkdWxlci1wcmVkaWNhdGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTs7R0FFRzs7O0FBS0g7Ozs7OztHQU1HO0FBQ0ksTUFBTSxvQkFBb0IsR0FBRyxDQUFDLElBQTBCLEVBQUUsWUFBb0IsRUFBVyxFQUFFLENBQ2hHLENBQUMsSUFBSSxLQUFLLE9BQU8sSUFBSSxZQUFZLEtBQUssU0FBUyxDQUFDLElBQUksQ0FBQyxJQUFJLEtBQUssTUFBTSxJQUFJLFlBQVksS0FBSyxTQUFTLENBQUMsQ0FBQztBQUR6RixRQUFBLG9CQUFvQix3QkFDcUUiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFB1cmUgcHJlZGljYXRlcyBmb3IgdGhlIEVDMiBydW5uaW5nIHNjaGVkdWxlciBMYW1iZGEgKG5vIEFXUyBTREspLlxuICovXG5cbi8qKiBWYWx1ZSBvZiBgUGFyYW1zLk1vZGVgIGZyb20gdGhlIEV2ZW50QnJpZGdlIFNjaGVkdWxlciBwYXlsb2FkLiAqL1xuZXhwb3J0IHR5cGUgUnVubmluZ1NjaGVkdWxlck1vZGUgPSAnU3RhcnQnIHwgJ1N0b3AnO1xuXG4vKipcbiAqIFdoZXRoZXIgdGhlIGluc3RhbmNlIGlzIGFscmVhZHkgaW4gdGhlIGdvYWwgc3RhdGUgZm9yIHRoZSBzY2hlZHVsZXIgbW9kZSAobm8gc3RhcnQvc3RvcCBuZWVkZWQpLlxuICpcbiAqIEBwYXJhbSBtb2RlIC0gYFN0YXJ0YCBleHBlY3RzIGBydW5uaW5nYDsgYFN0b3BgIGV4cGVjdHMgYHN0b3BwZWRgLlxuICogQHBhcmFtIGN1cnJlbnRTdGF0ZSAtIEluc3RhbmNlIHN0YXRlIGZyb20gYERlc2NyaWJlSW5zdGFuY2VzYCAoZS5nLiBgcnVubmluZ2AsIGBwZW5kaW5nYCkuXG4gKiBAcmV0dXJucyBgdHJ1ZWAgd2hlbiB0aGUgaW5zdGFuY2UgbWF0Y2hlcyB0aGUgdGFyZ2V0IHN0YXRlIGZvciBgbW9kZWAuXG4gKi9cbmV4cG9ydCBjb25zdCBpc0Rlc2lyZWRTdGFibGVTdGF0ZSA9IChtb2RlOiBSdW5uaW5nU2NoZWR1bGVyTW9kZSwgY3VycmVudFN0YXRlOiBzdHJpbmcpOiBib29sZWFuID0+XG4gIChtb2RlID09PSAnU3RhcnQnICYmIGN1cnJlbnRTdGF0ZSA9PT0gJ3J1bm5pbmcnKSB8fCAobW9kZSA9PT0gJ1N0b3AnICYmIGN1cnJlbnRTdGF0ZSA9PT0gJ3N0b3BwZWQnKTtcbiJdfQ==

package/lib/funcs/running-scheduler.lambda.d.ts

@@ -0,0 +1,34 @@
+/**
+ * EC2 Running Scheduler – Durable Functions implementation.
+ *
+ * Implements the running-control flow using AWS Lambda Durable Execution.
+ * Step checkpoints, wait (no charge), and parallel map provide a flow equivalent to Step Functions.
+ *
+ * @see https://docs.aws.amazon.com/lambda/latest/dg/durable-execution-sdk.html
+ */
+/** Event payload from EventBridge Scheduler invoking this Lambda. */
+export interface SchedulerEvent {
+    Params: {
+        /** Tag key used to select EC2 instances. */
+        TagKey: string;
+        /** Tag values to match. */
+        TagValues: string[];
+        /** Whether to start or stop instances. */
+        Mode: 'Start' | 'Stop';
+    };
+}
+/**
+ * Durable Lambda entry point for the EC2 running scheduler.
+ *
+ * Resolves instances via Resource Groups Tagging API, runs {@link processOneResource} for each ARN
+ * in parallel (bounded concurrency), posts a parent Slack message and per-instance thread replies,
+ * and uses durable `step` / `wait` / `map` so the run can resume across suspensions.
+ *
+ * @param event - Payload from EventBridge Scheduler; must include `Params.TagKey`, `Params.TagValues`, `Params.Mode`.
+ * @param ctx - Root durable execution context.
+ * @returns
+ * - `{ status: 'TargetResourcesNotFound' }` when no instances match the tag filter.
+ * - `{ status: 'Completed', processed, results }` when instances were handled (`results` entries match {@link processOneResource}).
+ * @throws {Error} If `Params` is invalid, `SLACK_SECRET_NAME` is unset, the Slack secret is incomplete, or instance processing fails.
+ */
+export declare const handler: import("@aws/durable-execution-sdk-js").DurableLambdaHandler;