ec2-instance-running-scheduler 0.1.1

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

@@ -0,0 +1,261 @@
+"use strict";
+/**
+ * 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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handler = void 0;
+const durable_execution_sdk_js_1 = require("@aws/durable-execution-sdk-js");
+const client_ec2_1 = require("@aws-sdk/client-ec2");
+const client_resource_groups_tagging_api_1 = require("@aws-sdk/client-resource-groups-tagging-api");
+const web_api_1 = require("@slack/web-api");
+const aws_lambda_secret_fetcher_1 = require("aws-lambda-secret-fetcher");
+const safe_env_getter_1 = require("safe-env-getter");
+const running_scheduler_predicates_1 = require("./running-scheduler-predicates");
+/** Mapping of EC2 instance state to display name and emoji for Slack. */
+const STATE_LIST = [
+    { name: 'RUNNING', emoji: '😆', state: 'running' },
+    { name: 'STOPPED', emoji: '😴', state: 'stopped' },
+];
+/** Seconds to wait between polling instance state after start/stop. */
+const STATUS_CHANGE_WAIT_SECONDS = 20;
+/**
+ * Returns display name and emoji for an EC2 instance state.
+ *
+ * @param current - Current instance state (e.g. 'running', 'stopped').
+ * @returns Display info or undefined if state is not in STATE_LIST.
+ */
+const getStateDisplay = (current) => {
+    const found = STATE_LIST.find((s) => s.state === current);
+    return found ? { emoji: found.emoji, name: found.name } : undefined;
+};
+/**
+ * Processes one EC2 instance: describes state, issues start/stop when needed, then polls until
+ * {@link isDesiredStableState} is satisfied (durable `step` / `wait` between attempts).
+ *
+ * @param ctx - Durable execution context (child context per instance recommended).
+ * @param targetResource - EC2 instance ARN.
+ * @param params - Scheduler params (`TagKey`, `TagValues`, `Mode`).
+ * @param resourceIndex - Index used in durable step names for this resource.
+ * @returns Final resource ARN, EC2 state name, parsed account, region, and instance id.
+ * @throws {Error} If the state is neither actionable, transitioning, nor the desired stable state.
+ */
+const processOneResource = async (ctx, targetResource, params, resourceIndex) => {
+    const parts = targetResource.split('/');
+    const identifier = parts[parts.length - 1] ?? 'unknown';
+    const arnParts = targetResource.split(':');
+    const account = arnParts[4] ?? '';
+    const region = arnParts[3] ?? '';
+    const stepPrefix = `resource-${resourceIndex}-${identifier}`;
+    ctx.logger.info('processOneResource: start', {
+        resourceIndex,
+        identifier,
+        region,
+        account,
+        mode: params.Mode,
+    });
+    let loopCount = 0;
+    let currentState = '';
+    do {
+        currentState = await ctx.step(`${stepPrefix}-describe-${loopCount}`, async () => {
+            const ec2 = new client_ec2_1.EC2Client({});
+            const out = await ec2.send(new client_ec2_1.DescribeInstancesCommand({ InstanceIds: [identifier] }));
+            return out.Reservations?.[0]?.Instances?.[0]?.State?.Name ?? 'unknown';
+        });
+        ctx.logger.info('processOneResource: described', {
+            identifier,
+            loopCount,
+            currentState,
+            mode: params.Mode,
+        });
+        const mode = params.Mode;
+        if (mode === 'Start' && currentState === 'stopped') {
+            ctx.logger.info('processOneResource: starting instance', { identifier, loopCount });
+            await ctx.step(`${stepPrefix}-start-${loopCount}`, async () => {
+                const ec2 = new client_ec2_1.EC2Client({});
+                await ec2.send(new client_ec2_1.StartInstancesCommand({ InstanceIds: [identifier] }));
+            });
+            ctx.logger.info('processOneResource: wait after start', {
+                identifier,
+                seconds: STATUS_CHANGE_WAIT_SECONDS,
+            });
+            await ctx.wait({ seconds: STATUS_CHANGE_WAIT_SECONDS });
+            loopCount += 1;
+            continue;
+        }
+        if (mode === 'Stop' && currentState === 'running') {
+            ctx.logger.info('processOneResource: stopping instance', { identifier, loopCount });
+            await ctx.step(`${stepPrefix}-stop-${loopCount}`, async () => {
+                const ec2 = new client_ec2_1.EC2Client({});
+                await ec2.send(new client_ec2_1.StopInstancesCommand({ InstanceIds: [identifier] }));
+            });
+            ctx.logger.info('processOneResource: wait after stop', {
+                identifier,
+                seconds: STATUS_CHANGE_WAIT_SECONDS,
+            });
+            await ctx.wait({ seconds: STATUS_CHANGE_WAIT_SECONDS });
+            loopCount += 1;
+            continue;
+        }
+        if (!(0, running_scheduler_predicates_1.isDesiredStableState)(mode, currentState)) {
+            const transitioning = (mode === 'Start' && currentState === 'pending') ||
+                (mode === 'Stop' && (currentState === 'stopping' || currentState === 'shutting-down'));
+            if (transitioning) {
+                ctx.logger.info('processOneResource: wait while transitioning', {
+                    identifier,
+                    loopCount,
+                    currentState,
+                    mode,
+                    seconds: STATUS_CHANGE_WAIT_SECONDS,
+                });
+                await ctx.wait({ seconds: STATUS_CHANGE_WAIT_SECONDS });
+                loopCount += 1;
+                continue;
+            }
+            ctx.logger.error('processOneResource: unexpected state', {
+                identifier,
+                mode,
+                currentState,
+                loopCount,
+            });
+            throw new Error(`instance status fail: mode=${mode} currentState=${currentState}`);
+        }
+    } while (!(0, running_scheduler_predicates_1.isDesiredStableState)(params.Mode, currentState));
+    ctx.logger.info('processOneResource: reached desired stable state', {
+        identifier,
+        finalState: currentState,
+        mode: params.Mode,
+        loopCount,
+    });
+    return {
+        identifier,
+        account,
+        region,
+        resource: targetResource,
+        status: currentState,
+    };
+};
+/**
+ * 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.
+ */
+exports.handler = (0, durable_execution_sdk_js_1.withDurableExecution)(async (event, ctx) => {
+    const params = event.Params;
+    ctx.logger.info('running-scheduler: invocation', {
+        mode: params?.Mode,
+        tagKey: params?.TagKey,
+        tagValueCount: params?.TagValues?.length ?? 0,
+    });
+    if (!params?.TagKey || !params?.TagValues || !params?.Mode) {
+        throw new Error('Invalid event: Params.TagKey, Params.TagValues, Params.Mode are required.');
+    }
+    // safe get Secrets name from environment variable
+    const slackSecretName = safe_env_getter_1.SafeEnvGetter.getEnv('SLACK_SECRET_NAME');
+    const slackSecretValue = await ctx.step('fetch-slack-secret', async () => {
+        ctx.logger.info('running-scheduler: fetching Slack secret', { secretName: slackSecretName });
+        return aws_lambda_secret_fetcher_1.secretFetcher.getSecretValue(slackSecretName);
+    });
+    ctx.logger.info('running-scheduler: Slack secret loaded');
+    if (!slackSecretValue?.token || !slackSecretValue?.channel) {
+        throw new Error('Slack secret must contain token and channel.');
+    }
+    const targetResources = await ctx.step('get-target-resources', async () => {
+        const client = new client_resource_groups_tagging_api_1.ResourceGroupsTaggingAPIClient({});
+        const result = await client.send(new client_resource_groups_tagging_api_1.GetResourcesCommand({
+            ResourceTypeFilters: ['ec2:instance'],
+            TagFilters: [{ Key: params.TagKey, Values: params.TagValues }],
+        }));
+        const arns = (result.ResourceTagMappingList ?? [])
+            .map((m) => m.ResourceARN)
+            .filter((arn) => arn != null);
+        ctx.logger.info('running-scheduler: get-target-resources done', { count: arns.length });
+        return arns;
+    });
+    if (targetResources.length === 0) {
+        ctx.logger.info('running-scheduler: no matching instances', { tagKey: params.TagKey });
+        return { status: 'TargetResourcesNotFound' };
+    }
+    const client = new web_api_1.WebClient(slackSecretValue.token);
+    const channel = slackSecretValue.channel;
+    ctx.logger.info('running-scheduler: posting parent Slack message', {
+        instanceCount: targetResources.length,
+    });
+    // send slack message
+    const slackParentMessageResult = await ctx.step('post-slack-messages', async () => {
+        return client.chat.postMessage({
+            channel,
+            text: `${params.Mode === 'Start' ? '😆 Starts' : '🥱 Stops'} the scheduled EC2 Instance.`,
+        });
+    });
+    ctx.logger.info('running-scheduler: parent Slack message posted', {
+        threadTs: slackParentMessageResult?.ts ?? null,
+    });
+    ctx.logger.info('running-scheduler: starting parallel instance processing', {
+        count: targetResources.length,
+        maxConcurrency: 10,
+    });
+    const results = await ctx.map(targetResources, 
+    // async (ctx: DurableContext, targetResource: string, index: number) =>
+    //   ctx.step(`process-resource-${index}`, async () =>
+    //     processOneResource(ctx, targetResource, params, index),
+    //   ),
+    async (mapCtx, targetResource, index) => {
+        return mapCtx.runInChildContext(`resource-${index}`, async (childCtx) => {
+            const result = await processOneResource(childCtx, targetResource, params, index);
+            // if (result.status === 'skipped') {
+            //   return result;
+            // }
+            childCtx.logger.info('running-scheduler: posting thread Slack message', {
+                index,
+                identifier: result.identifier,
+                status: result.status,
+            });
+            // send slack thread message
+            await childCtx.step('post-slack-child-messages', async () => {
+                const display = getStateDisplay(result.status);
+                return client.chat.postMessage({
+                    channel,
+                    thread_ts: slackParentMessageResult?.ts,
+                    attachments: [
+                        {
+                            color: '#36a64f',
+                            pretext: `${display?.emoji} The status of the EC2 Instance ${result.identifier} changed to ${display?.name} due to the schedule.`,
+                            fields: [
+                                { title: 'Account', value: result.account, short: true },
+                                { title: 'Region', value: result.region, short: true },
+                                { title: 'Identifier', value: result.identifier, short: true },
+                                { title: 'Status', value: (display?.name ?? 'Unknown'), short: true },
+                            ],
+                        },
+                    ],
+                });
+            });
+            return result;
+        });
+    }, { maxConcurrency: 10 });
+    const resultList = Array.isArray(results) ? results : [];
+    ctx.logger.info('running-scheduler: completed', {
+        processed: targetResources.length,
+        resultCount: resultList.length,
+    });
+    return {
+        status: 'Completed',
+        processed: targetResources.length,
+        results: resultList,
+    };
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"running-scheduler.lambda.js","sourceRoot":"","sources":["../../src/funcs/running-scheduler.lambda.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * EC2 Running Scheduler – Durable Functions implementation.\n *\n * Implements the running-control flow using AWS Lambda Durable Execution.\n * Step checkpoints, wait (no charge), and parallel map provide a flow equivalent to Step Functions.\n *\n * @see https://docs.aws.amazon.com/lambda/latest/dg/durable-execution-sdk.html\n */\n\nimport { withDurableExecution, type DurableContext } from '@aws/durable-execution-sdk-js';\nimport {\n  EC2Client,\n  DescribeInstancesCommand,\n  StartInstancesCommand,\n  StopInstancesCommand,\n} from '@aws-sdk/client-ec2';\nimport { GetResourcesCommand, ResourceGroupsTaggingAPIClient } from '@aws-sdk/client-resource-groups-tagging-api';\nimport { WebClient } from '@slack/web-api';\nimport { secretFetcher } from 'aws-lambda-secret-fetcher';\nimport { SafeEnvGetter } from 'safe-env-getter';\nimport { isDesiredStableState } from './running-scheduler-predicates';\n\n/** Mapping of EC2 instance state to display name and emoji for Slack. */\nconst STATE_LIST = [\n  { name: 'RUNNING', emoji: '😆', state: 'running' },\n  { name: 'STOPPED', emoji: '😴', state: 'stopped' },\n] as const;\n\n/** Seconds to wait between polling instance state after start/stop. */\nconst STATUS_CHANGE_WAIT_SECONDS = 20;\n\n/** Event payload from EventBridge Scheduler invoking this Lambda. */\nexport interface SchedulerEvent {\n  Params: {\n    /** Tag key used to select EC2 instances. */\n    TagKey: string;\n    /** Tag values to match. */\n    TagValues: string[];\n    /** Whether to start or stop instances. */\n    Mode: 'Start' | 'Stop';\n  };\n}\n\n/** Slack credentials and default channel loaded from Secrets Manager (`SLACK_SECRET_NAME`). */\ninterface SlackSecret {\n  /** Slack bot token for the Slack `WebClient`. */\n  token: string;\n  /** Channel ID or name passed to `chat.postMessage`. */\n  channel: string;\n}\n\n/**\n * Returns display name and emoji for an EC2 instance state.\n *\n * @param current - Current instance state (e.g. 'running', 'stopped').\n * @returns Display info or undefined if state is not in STATE_LIST.\n */\nconst getStateDisplay = (current: string): { emoji: string; name: string } | undefined => {\n  const found = STATE_LIST.find((s) => s.state === current);\n  return found ? { emoji: found.emoji, name: found.name } : undefined;\n};\n\n/**\n * Processes one EC2 instance: describes state, issues start/stop when needed, then polls until\n * {@link isDesiredStableState} is satisfied (durable `step` / `wait` between attempts).\n *\n * @param ctx - Durable execution context (child context per instance recommended).\n * @param targetResource - EC2 instance ARN.\n * @param params - Scheduler params (`TagKey`, `TagValues`, `Mode`).\n * @param resourceIndex - Index used in durable step names for this resource.\n * @returns Final resource ARN, EC2 state name, parsed account, region, and instance id.\n * @throws {Error} If the state is neither actionable, transitioning, nor the desired stable state.\n */\nconst processOneResource = async (\n  ctx: DurableContext,\n  targetResource: string,\n  params: SchedulerEvent['Params'],\n  resourceIndex: number,\n): Promise<{ resource: string; status: string; account: string; region: string; identifier: string }> => {\n  const parts = targetResource.split('/');\n  const identifier = parts[parts.length - 1] ?? 'unknown';\n  const arnParts = targetResource.split(':');\n  const account = arnParts[4] ?? '';\n  const region = arnParts[3] ?? '';\n  const stepPrefix = `resource-${resourceIndex}-${identifier}`;\n\n  ctx.logger.info('processOneResource: start', {\n    resourceIndex,\n    identifier,\n    region,\n    account,\n    mode: params.Mode,\n  });\n\n  let loopCount = 0;\n  let currentState = '';\n  do {\n    currentState = await ctx.step(`${stepPrefix}-describe-${loopCount}`, async () => {\n      const ec2 = new EC2Client({});\n      const out = await ec2.send(new DescribeInstancesCommand({ InstanceIds: [identifier] }));\n      return out.Reservations?.[0]?.Instances?.[0]?.State?.Name ?? 'unknown';\n    });\n\n    ctx.logger.info('processOneResource: described', {\n      identifier,\n      loopCount,\n      currentState,\n      mode: params.Mode,\n    });\n\n    const mode = params.Mode;\n\n    if (mode === 'Start' && currentState === 'stopped') {\n      ctx.logger.info('processOneResource: starting instance', { identifier, loopCount });\n      await ctx.step(`${stepPrefix}-start-${loopCount}`, async () => {\n        const ec2 = new EC2Client({});\n        await ec2.send(new StartInstancesCommand({ InstanceIds: [identifier] }));\n      });\n      ctx.logger.info('processOneResource: wait after start', {\n        identifier,\n        seconds: STATUS_CHANGE_WAIT_SECONDS,\n      });\n      await ctx.wait({ seconds: STATUS_CHANGE_WAIT_SECONDS });\n      loopCount += 1;\n      continue;\n    }\n\n    if (mode === 'Stop' && currentState === 'running') {\n      ctx.logger.info('processOneResource: stopping instance', { identifier, loopCount });\n      await ctx.step(`${stepPrefix}-stop-${loopCount}`, async () => {\n        const ec2 = new EC2Client({});\n        await ec2.send(new StopInstancesCommand({ InstanceIds: [identifier] }));\n      });\n      ctx.logger.info('processOneResource: wait after stop', {\n        identifier,\n        seconds: STATUS_CHANGE_WAIT_SECONDS,\n      });\n      await ctx.wait({ seconds: STATUS_CHANGE_WAIT_SECONDS });\n      loopCount += 1;\n      continue;\n    }\n\n    if (!isDesiredStableState(mode, currentState)) {\n      const transitioning =\n        (mode === 'Start' && currentState === 'pending') ||\n        (mode === 'Stop' && (currentState === 'stopping' || currentState === 'shutting-down'));\n\n      if (transitioning) {\n        ctx.logger.info('processOneResource: wait while transitioning', {\n          identifier,\n          loopCount,\n          currentState,\n          mode,\n          seconds: STATUS_CHANGE_WAIT_SECONDS,\n        });\n        await ctx.wait({ seconds: STATUS_CHANGE_WAIT_SECONDS });\n        loopCount += 1;\n        continue;\n      }\n\n      ctx.logger.error('processOneResource: unexpected state', {\n        identifier,\n        mode,\n        currentState,\n        loopCount,\n      });\n      throw new Error(`instance status fail: mode=${mode} currentState=${currentState}`);\n    }\n  } while (!isDesiredStableState(params.Mode, currentState));\n\n  ctx.logger.info('processOneResource: reached desired stable state', {\n    identifier,\n    finalState: currentState,\n    mode: params.Mode,\n    loopCount,\n  });\n\n  return {\n    identifier,\n    account,\n    region,\n    resource: targetResource,\n    status: currentState,\n  };\n};\n\n/**\n * Durable Lambda entry point for the EC2 running scheduler.\n *\n * Resolves instances via Resource Groups Tagging API, runs {@link processOneResource} for each ARN\n * in parallel (bounded concurrency), posts a parent Slack message and per-instance thread replies,\n * and uses durable `step` / `wait` / `map` so the run can resume across suspensions.\n *\n * @param event - Payload from EventBridge Scheduler; must include `Params.TagKey`, `Params.TagValues`, `Params.Mode`.\n * @param ctx - Root durable execution context.\n * @returns\n * - `{ status: 'TargetResourcesNotFound' }` when no instances match the tag filter.\n * - `{ status: 'Completed', processed, results }` when instances were handled (`results` entries match {@link processOneResource}).\n * @throws {Error} If `Params` is invalid, `SLACK_SECRET_NAME` is unset, the Slack secret is incomplete, or instance processing fails.\n */\nexport const handler = withDurableExecution(async (event: SchedulerEvent, ctx: DurableContext) => {\n\n  const params = event.Params;\n\n  ctx.logger.info('running-scheduler: invocation', {\n    mode: params?.Mode,\n    tagKey: params?.TagKey,\n    tagValueCount: params?.TagValues?.length ?? 0,\n  });\n\n  if (!params?.TagKey || !params?.TagValues || !params?.Mode) {\n    throw new Error('Invalid event: Params.TagKey, Params.TagValues, Params.Mode are required.');\n  }\n\n  // safe get Secrets name from environment variable\n  const slackSecretName = SafeEnvGetter.getEnv('SLACK_SECRET_NAME');\n\n  const slackSecretValue = await ctx.step('fetch-slack-secret', async () => {\n    ctx.logger.info('running-scheduler: fetching Slack secret', { secretName: slackSecretName });\n    return secretFetcher.getSecretValue<SlackSecret>(slackSecretName);\n  });\n\n  ctx.logger.info('running-scheduler: Slack secret loaded');\n\n  if (!slackSecretValue?.token || !slackSecretValue?.channel) {\n    throw new Error('Slack secret must contain token and channel.');\n  }\n\n  const targetResources = await ctx.step('get-target-resources', async () => {\n    const client = new ResourceGroupsTaggingAPIClient({});\n    const result = await client.send(\n      new GetResourcesCommand({\n        ResourceTypeFilters: ['ec2:instance'],\n        TagFilters: [{ Key: params.TagKey, Values: params.TagValues }],\n      }),\n    );\n    const arns = (result.ResourceTagMappingList ?? [])\n      .map((m: { ResourceARN?: string }) => m.ResourceARN)\n      .filter((arn: string | undefined): arn is string => arn != null);\n    ctx.logger.info('running-scheduler: get-target-resources done', { count: arns.length });\n    return arns;\n  });\n\n  if (targetResources.length === 0) {\n    ctx.logger.info('running-scheduler: no matching instances', { tagKey: params.TagKey });\n    return { status: 'TargetResourcesNotFound' as const };\n  }\n\n  const client = new WebClient(slackSecretValue.token);\n  const channel = slackSecretValue.channel;\n\n  ctx.logger.info('running-scheduler: posting parent Slack message', {\n    instanceCount: targetResources.length,\n  });\n\n  // send slack message\n  const slackParentMessageResult = await ctx.step('post-slack-messages', async () => {\n    return client.chat.postMessage({\n      channel,\n      text: `${params.Mode === 'Start' ? '😆 Starts' : '🥱 Stops'} the scheduled EC2 Instance.`,\n    });\n  });\n\n  ctx.logger.info('running-scheduler: parent Slack message posted', {\n    threadTs: slackParentMessageResult?.ts ?? null,\n  });\n\n  ctx.logger.info('running-scheduler: starting parallel instance processing', {\n    count: targetResources.length,\n    maxConcurrency: 10,\n  });\n\n  const results = await ctx.map(\n    targetResources,\n    // async (ctx: DurableContext, targetResource: string, index: number) =>\n    //   ctx.step(`process-resource-${index}`, async () =>\n    //     processOneResource(ctx, targetResource, params, index),\n    //   ),\n    async (mapCtx: DurableContext, targetResource: string, index: number) => {\n      return mapCtx.runInChildContext(`resource-${index}`, async (childCtx: DurableContext) => {\n        const result = await processOneResource(childCtx, targetResource, params, index);\n        // if (result.status === 'skipped') {\n        //   return result;\n        // }\n        childCtx.logger.info('running-scheduler: posting thread Slack message', {\n          index,\n          identifier: result.identifier,\n          status: result.status,\n        });\n        // send slack thread message\n        await childCtx.step('post-slack-child-messages', async () => {\n          const display = getStateDisplay(result.status);\n\n          return client.chat.postMessage({\n            channel,\n            thread_ts: slackParentMessageResult?.ts,\n            attachments: [\n              {\n                color: '#36a64f',\n                pretext: `${display?.emoji} The status of the EC2 Instance ${result.identifier} changed to ${display?.name} due to the schedule.`,\n                fields: [\n                  { title: 'Account', value: result.account, short: true },\n                  { title: 'Region', value: result.region, short: true },\n                  { title: 'Identifier', value: result.identifier, short: true },\n                  { title: 'Status', value: (display?.name ?? 'Unknown'), short: true },\n                ],\n              },\n            ],\n          });\n        });\n        return result;\n      });\n    },\n    { maxConcurrency: 10 },\n  );\n\n  const resultList = Array.isArray(results) ? results : [];\n  ctx.logger.info('running-scheduler: completed', {\n    processed: targetResources.length,\n    resultCount: resultList.length,\n  });\n  return {\n    status: 'Completed' as const,\n    processed: targetResources.length,\n    results: resultList,\n  };\n});\n"]}

package/lib/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Public API: EC2 instance running scheduler construct and stack.
+ */
+export * from './constructs/ec2-instance-running-scheduler';
+export * from './stacks/ec2-instance-running-schedule-stack';

package/lib/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Public API: EC2 instance running scheduler construct and stack.
+ */
+__exportStar(require("./constructs/ec2-instance-running-scheduler"), exports);
+__exportStar(require("./stacks/ec2-instance-running-schedule-stack"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBOztHQUVHO0FBQ0gsOEVBQTREO0FBQzVELCtFQUE2RCIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogUHVibGljIEFQSTogRUMyIGluc3RhbmNlIHJ1bm5pbmcgc2NoZWR1bGVyIGNvbnN0cnVjdCBhbmQgc3RhY2suXG4gKi9cbmV4cG9ydCAqIGZyb20gJy4vY29uc3RydWN0cy9lYzItaW5zdGFuY2UtcnVubmluZy1zY2hlZHVsZXInO1xuZXhwb3J0ICogZnJvbSAnLi9zdGFja3MvZWMyLWluc3RhbmNlLXJ1bm5pbmctc2NoZWR1bGUtc3RhY2snOyJdfQ==

package/lib/stacks/ec2-instance-running-schedule-stack.d.ts

@@ -0,0 +1,31 @@
+import { Stack, StackProps } from 'aws-cdk-lib';
+import { Construct } from 'constructs';
+import { TargetResource, Secrets, Schedule } from '../constructs/ec2-instance-running-scheduler';
+/**
+ * Props for the EC2 instance running schedule CDK stack.
+ */
+export interface EC2InstanceRunningScheduleStackProps extends StackProps {
+    /** Tag-based target resource for EC2 instances to start/stop. */
+    readonly targetResource: TargetResource;
+    /** Whether scheduling is enabled. Defaults to true if omitted. */
+    readonly enableScheduling?: boolean;
+    /** Secrets (e.g. Slack) for the scheduler. */
+    readonly secrets: Secrets;
+    /** Cron schedule for stopping instances. */
+    readonly stopSchedule?: Schedule;
+    /** Cron schedule for starting instances. */
+    readonly startSchedule?: Schedule;
+}
+/**
+ * CDK Stack that deploys the EC2 instance running scheduler (EventBridge Scheduler + Durable Lambda).
+ */
+export declare class EC2InstanceRunningScheduleStack extends Stack {
+    /**
+     * Creates the stack and the EC2InstanceRunningScheduler construct.
+     *
+     * @param scope - Parent construct.
+     * @param id - Stack id.
+     * @param props - Stack props (target resource, schedules, secrets).
+     */
+    constructor(scope: Construct, id: string, props: EC2InstanceRunningScheduleStackProps);
+}

package/lib/stacks/ec2-instance-running-schedule-stack.js

@@ -0,0 +1,33 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EC2InstanceRunningScheduleStack = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const ec2_instance_running_scheduler_1 = require("../constructs/ec2-instance-running-scheduler");
+/**
+ * CDK Stack that deploys the EC2 instance running scheduler (EventBridge Scheduler + Durable Lambda).
+ */
+class EC2InstanceRunningScheduleStack extends aws_cdk_lib_1.Stack {
+    /**
+     * Creates the stack and the EC2InstanceRunningScheduler construct.
+     *
+     * @param scope - Parent construct.
+     * @param id - Stack id.
+     * @param props - Stack props (target resource, schedules, secrets).
+     */
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        new ec2_instance_running_scheduler_1.EC2InstanceRunningScheduler(this, 'EC2InstanceRunningScheduler', {
+            targetResource: props.targetResource,
+            enableScheduling: props.enableScheduling,
+            secrets: props.secrets,
+            stopSchedule: props.stopSchedule,
+            startSchedule: props.startSchedule,
+        });
+    }
+}
+exports.EC2InstanceRunningScheduleStack = EC2InstanceRunningScheduleStack;
+_a = JSII_RTTI_SYMBOL_1;
+EC2InstanceRunningScheduleStack[_a] = { fqn: "ec2-instance-running-scheduler.EC2InstanceRunningScheduleStack", version: "0.1.1" };
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -0,0 +1,152 @@
+{
+  "name": "ec2-instance-running-scheduler",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/gammarers-aws-cdk-constructs/ec2-instance-running-scheduler.git"
+  },
+  "scripts": {
+    "build": "projen build",
+    "bump": "projen bump",
+    "bundle": "projen bundle",
+    "bundle:funcs/running-scheduler.lambda": "projen bundle:funcs/running-scheduler.lambda",
+    "bundle:funcs/running-scheduler.lambda:watch": "projen bundle:funcs/running-scheduler.lambda:watch",
+    "clobber": "projen clobber",
+    "compat": "projen compat",
+    "compile": "projen compile",
+    "default": "projen default",
+    "docgen": "projen docgen",
+    "eject": "projen eject",
+    "eslint": "projen eslint",
+    "package": "projen package",
+    "package-all": "projen package-all",
+    "package:js": "projen package:js",
+    "post-compile": "projen post-compile",
+    "post-upgrade": "projen post-upgrade",
+    "pre-compile": "projen pre-compile",
+    "release": "projen release",
+    "test": "projen test",
+    "test:watch": "projen test:watch",
+    "unbump": "projen unbump",
+    "upgrade": "projen upgrade",
+    "watch": "projen watch",
+    "projen": "projen"
+  },
+  "author": {
+    "name": "yicr",
+    "email": "yicr@users.noreply.github.com",
+    "organization": false
+  },
+  "devDependencies": {
+    "@aws-sdk/client-ec2": "^3",
+    "@aws-sdk/client-resource-groups-tagging-api": "^3",
+    "@aws/durable-execution-sdk-js": "^1",
+    "@slack/web-api": "^6",
+    "@stylistic/eslint-plugin": "^2",
+    "@types/aws-lambda": "^8",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^20",
+    "@typescript-eslint/eslint-plugin": "^8",
+    "@typescript-eslint/parser": "^8",
+    "aws-cdk-lib": "2.232.0",
+    "aws-lambda-secret-fetcher": "^0.3",
+    "aws-sdk-client-mock": "^2",
+    "aws-sdk-client-mock-jest": "^2",
+    "commit-and-tag-version": "^12",
+    "constructs": "10.5.1",
+    "esbuild": "^0.28.0",
+    "eslint": "^9",
+    "eslint-import-resolver-typescript": "^3.10.1",
+    "eslint-plugin-import": "^2.32.0",
+    "jest": "^29.7.0",
+    "jest-junit": "^16",
+    "jsii": "5.9.x",
+    "jsii-diff": "^1.128.0",
+    "jsii-docgen": "^10.5.0",
+    "jsii-pacmak": "^1.128.0",
+    "jsii-rosetta": "5.9.x",
+    "projen": "^0.99.48",
+    "safe-env-getter": "^0.2",
+    "ts-jest": "^29.4.9",
+    "ts-node": "^10.9.2",
+    "typescript": "5.9.x"
+  },
+  "peerDependencies": {
+    "aws-cdk-lib": "^2.232.0",
+    "constructs": "^10.5.1"
+  },
+  "keywords": [
+    "cdk"
+  ],
+  "engines": {
+    "node": ">= 20.0.0"
+  },
+  "devEngines": {
+    "packageManager": {
+      "name": "yarn",
+      "version": "1.22.22",
+      "onFail": "ignore"
+    }
+  },
+  "main": "lib/index.js",
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "0.1.1",
+  "jest": {
+    "coverageProvider": "v8",
+    "testMatch": [
+      "<rootDir>/@(src|test)/**/*(*.)@(spec|test).ts?(x)",
+      "<rootDir>/@(src|test)/**/__tests__/**/*.ts?(x)",
+      "<rootDir>/@(projenrc)/**/*(*.)@(spec|test).ts?(x)",
+      "<rootDir>/@(projenrc)/**/__tests__/**/*.ts?(x)"
+    ],
+    "clearMocks": true,
+    "collectCoverage": true,
+    "coverageReporters": [
+      "json",
+      "lcov",
+      "clover",
+      "cobertura",
+      "text"
+    ],
+    "coverageDirectory": "coverage",
+    "coveragePathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "testPathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "watchPathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "reporters": [
+      "default",
+      [
+        "jest-junit",
+        {
+          "outputDirectory": "test-reports"
+        }
+      ]
+    ],
+    "transform": {
+      "^.+\\.[t]sx?$": [
+        "ts-jest",
+        {
+          "tsconfig": "tsconfig.dev.json"
+        }
+      ]
+    }
+  },
+  "types": "lib/index.d.ts",
+  "stability": "stable",
+  "jsii": {
+    "outdir": "dist",
+    "targets": {},
+    "tsc": {
+      "outDir": "lib",
+      "rootDir": "src"
+    }
+  },
+  "//": "~~ Generated by projen. To modify, edit .projenrc.ts and run \"npx projen\"."
+}