@mavogel/cdk-vscode-server 0.0.62 → 0.0.64

package/integ-tests/integ.stop-on-idle.ts.snapshot/asset.22c8a6c357b704e370bef317ae1b52c59f684aa7640422a3d1dfe813d1f77853.lambda/index.js

@@ -0,0 +1,67 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/idle-monitor-enabler/idle-monitor-enabler.lambda.ts
+var idle_monitor_enabler_lambda_exports = {};
+__export(idle_monitor_enabler_lambda_exports, {
+  handler: () => handler
+});
+module.exports = __toCommonJS(idle_monitor_enabler_lambda_exports);
+var import_client_eventbridge = require("@aws-sdk/client-eventbridge");
+var eventBridge = new import_client_eventbridge.EventBridge();
+var handler = async (event) => {
+  console.log("Event: %j", { ...event, ResponseURL: "..." });
+  const ruleName = event.ResourceProperties.RuleName;
+  if (!ruleName) {
+    throw new Error("RuleName is required in ResourceProperties");
+  }
+  switch (event.RequestType) {
+    case "Create":
+    case "Update":
+      console.log(`Enabling EventBridge rule: ${ruleName}`);
+      await eventBridge.send(
+        new import_client_eventbridge.EnableRuleCommand({
+          Name: ruleName
+        })
+      );
+      console.log(`Successfully enabled rule: ${ruleName}`);
+      return {
+        PhysicalResourceId: `idle-monitor-enabler-${ruleName}`
+      };
+    case "Delete":
+      console.log(`Disabling EventBridge rule on deletion: ${ruleName}`);
+      try {
+        await eventBridge.send(
+          new import_client_eventbridge.DisableRuleCommand({
+            Name: ruleName
+          })
+        );
+        console.log(`Successfully disabled rule: ${ruleName}`);
+      } catch (error) {
+        console.log(`Error disabling rule (ignoring): ${error.message}`);
+      }
+      return {};
+    default:
+      throw new Error(`Unsupported RequestType: ${event.RequestType}`);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  handler
+});

package/integ-tests/{integ.custom-domain.ts.snapshot/asset.33da23274e25bd9f43638c5d83dad26e3931cbe78d462ffd9a9f565e948b4f5f.lambda → integ.stop-on-idle.ts.snapshot/asset.2f99f38311da357eaaea1284d67c759759324dec4a1cd11621d9c59eea9e81df.lambda}/index.js

@@ -59,47 +59,89 @@ var handler = async (event, context) => {
     parameters[key] = [value];
   }
   console.log("mapped parameters: %j", parameters);
-  let attemptNo = 0;
-  let timeRemaining = context.getRemainingTimeInMillis();
   console.log(
     `Running SSM Document '${documentName}' on EC2 instance '${instanceId}'. Logging to '${cloudWatchLogGroupName}' with parameters: '${JSON.stringify(parameters)}'`
   );
+  let commandId;
+  let attemptNo = 0;
   while (true) {
     attemptNo += 1;
+    const timeRemaining = context.getRemainingTimeInMillis();
     console.log(
-      `Attempt: ${attemptNo}. Time Remaining: ${timeRemaining / 1e3}s`
+      `Send attempt: ${attemptNo}. Time Remaining: ${timeRemaining / 1e3}s`
     );
     try {
-      const response = await ssm.sendCommand({
-        DocumentName: documentName,
-        InstanceIds: [instanceId],
-        CloudWatchOutputConfig: {
-          CloudWatchLogGroupName: cloudWatchLogGroupName,
-          CloudWatchOutputEnabled: true
-        },
-        Parameters: parameters
-      });
-      console.log(`response: ${JSON.stringify(response)}`);
+      const response = await ssm.send(
+        new import_client_ssm.SendCommandCommand({
+          DocumentName: documentName,
+          InstanceIds: [instanceId],
+          CloudWatchOutputConfig: {
+            CloudWatchLogGroupName: cloudWatchLogGroupName,
+            CloudWatchOutputEnabled: true
+          },
+          Parameters: parameters
+        })
+      );
+      console.log(`sendCommand response: ${JSON.stringify(response)}`);
       const command = response.Command;
-      const commandId = command.CommandId;
-      const responseData = { CommandId: commandId };
-      switch (command.Status) {
+      commandId = command.CommandId;
+      console.log(`Command sent successfully. CommandId: ${commandId}`);
+      break;
+    } catch (error) {
+      console.log("Error sending command:", error);
+      const isUnauthorized = error.name === "UnauthorizedException" || error.name === "AccessDeniedException" || error.message && error.message.includes("not authorized");
+      const isThrottled = error.name === "ThrottlingException" || error.name === "TooManyRequestsException";
+      const isRetryable = isUnauthorized || isThrottled;
+      const remainingTime = context.getRemainingTimeInMillis();
+      if (isRetryable && remainingTime > SLEEP_MS) {
+        console.log(
+          `Retryable error encountered (${error.name}). Attempt ${attemptNo}. Sleeping: ${SLEEP_MS / 1e3}s before retry`
+        );
+        await new Promise((resolve) => setTimeout(resolve, SLEEP_MS));
+      } else {
+        console.log("Non-retryable error or timeout. Failing...");
+        throw error;
+      }
+    }
+  }
+  let pollAttemptNo = 0;
+  const responseData = { CommandId: commandId };
+  while (true) {
+    pollAttemptNo += 1;
+    const timeRemaining = context.getRemainingTimeInMillis();
+    console.log(
+      `Poll attempt: ${pollAttemptNo}. Time Remaining: ${timeRemaining / 1e3}s`
+    );
+    try {
+      const invocationResponse = await ssm.send(
+        new import_client_ssm.GetCommandInvocationCommand({
+          CommandId: commandId,
+          InstanceId: instanceId
+        })
+      );
+      console.log(
+        `getCommandInvocation response: ${JSON.stringify(invocationResponse)}`
+      );
+      const status = invocationResponse.Status;
+      switch (status) {
         case "Pending":
         case "InProgress":
-          timeRemaining = context.getRemainingTimeInMillis();
+        case "Delayed":
           if (timeRemaining > SLEEP_MS) {
             console.log(
-              `Instance ${instanceId} not ready: 'InProgress'. Sleeping: ${SLEEP_MS / 1e3}s`
+              `Command ${commandId} status: '${status}'. Sleeping: ${SLEEP_MS / 1e3}s`
             );
             await new Promise((resolve) => setTimeout(resolve, SLEEP_MS));
             break;
           } else {
             throw new Error(
-              `SSM Document ${documentName} on EC2 instance ${instanceId} timed out while lambda in progress`
+              `SSM Document ${documentName} on EC2 instance ${instanceId} timed out while lambda waiting (status: ${status})`
             );
           }
         case "Success":
-          console.log(`Instance ${instanceId} successfully bootstrapped`);
+          console.log(
+            `Instance ${instanceId} successfully bootstrapped. Command ${commandId} completed.`
+          );
           return { Data: responseData };
         case "TimedOut":
           throw new Error(
@@ -115,23 +157,18 @@ var handler = async (event, context) => {
           );
         default:
           throw new Error(
-            `SSM Document ${documentName} on EC2 instance ${instanceId} status ${command.Status}`
+            `SSM Document ${documentName} on EC2 instance ${instanceId} unknown status: ${status}`
           );
       }
-      return { Data: responseData };
     } catch (error) {
-      console.log("Error occurred:", error);
-      const isUnauthorized = error.name === "UnauthorizedException" || error.name === "AccessDeniedException" || error.message && error.message.includes("not authorized");
-      const isThrottled = error.name === "ThrottlingException" || error.name === "TooManyRequestsException";
-      const isRetryable = isUnauthorized || isThrottled;
-      timeRemaining = context.getRemainingTimeInMillis();
-      if (isRetryable && timeRemaining > SLEEP_MS) {
+      const remainingTime = context.getRemainingTimeInMillis();
+      if (error.name === "InvocationDoesNotExist" && remainingTime > SLEEP_MS) {
         console.log(
-          `Retryable error encountered (${error.name}). Attempt ${attemptNo}. Sleeping: ${SLEEP_MS / 1e3}s before retry`
+          `Invocation not yet available. Sleeping: ${SLEEP_MS / 1e3}s`
         );
         await new Promise((resolve) => setTimeout(resolve, SLEEP_MS));
       } else {
-        console.log("Non-retryable error or timeout. Failing...");
+        console.log("Error checking command status:", error);
         throw error;
       }
     }