@evident-ai/runner-cdk 0.1.1-dev.d96ef8a → 0.1.1-dev.da88f8e

package/dist/microvm-image-context/hook-server.js

@@ -0,0 +1,290 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../lambda-microvm-runtime/dist/runtime.js
+var require_runtime = __commonJS({
+  "../lambda-microvm-runtime/dist/runtime.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.HOOK_SIGTERM_SECONDS = exports2.HOOK_PATHS = exports2.HOOK_NAMES = exports2.HOOK_PATH_PREFIX = void 0;
+    exports2.parseRunEnvelope = parseRunEnvelope;
+    exports2.createMicrovmRuntime = createMicrovmRuntime;
+    var node_http_1 = require("node:http");
+    exports2.HOOK_PATH_PREFIX = "/aws/lambda-microvms/runtime/v1";
+    exports2.HOOK_NAMES = ["ready", "validate", "run", "resume", "suspend", "terminate"];
+    exports2.HOOK_PATHS = Object.fromEntries(exports2.HOOK_NAMES.map((name) => [name, `${exports2.HOOK_PATH_PREFIX}/${name}`]));
+    var RUN_HOOK_PAYLOAD_MAX_BYTES = 16384;
+    var MAX_BODY_BYTES = RUN_HOOK_PAYLOAD_MAX_BYTES * 8;
+    exports2.HOOK_SIGTERM_SECONDS = 55;
+    var DEFAULT_TIMEOUT_SECONDS = exports2.HOOK_SIGTERM_SECONDS;
+    var DEFAULT_KILL_GRACE_SECONDS = 10;
+    function readBody(request) {
+      return new Promise((resolve, reject) => {
+        const chunks = [];
+        let size = 0;
+        let oversize = false;
+        request.on("data", (chunk) => {
+          if (oversize) {
+            return;
+          }
+          size += chunk.length;
+          if (size > MAX_BODY_BYTES) {
+            oversize = true;
+            resolve(null);
+            return;
+          }
+          chunks.push(chunk);
+        });
+        request.on("end", () => {
+          if (!oversize) {
+            resolve(Buffer.concat(chunks).toString("utf8"));
+          }
+        });
+        request.on("error", reject);
+      });
+    }
+    function parseRunEnvelope(rawBody) {
+      let parsed;
+      try {
+        parsed = JSON.parse(rawBody);
+      } catch {
+        throw new Error("run hook body is not valid JSON");
+      }
+      if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new Error("run hook body is not a JSON object");
+      }
+      const envelope = parsed;
+      const microvmId = envelope.microvmId;
+      const runHookPayload = envelope.runHookPayload;
+      if (typeof microvmId !== "string" || microvmId === "") {
+        throw new Error("run hook body is missing microvmId");
+      }
+      if (typeof runHookPayload !== "string") {
+        throw new Error("run hook body is missing runHookPayload");
+      }
+      return { microvmId, runHookPayload };
+    }
+    function createMicrovmRuntime({ hooksDir, spawn, hasScript, timeoutSeconds = DEFAULT_TIMEOUT_SECONDS, killGraceSeconds = DEFAULT_KILL_GRACE_SECONDS }) {
+      function runScript(hook, script, env, payload) {
+        return new Promise((resolve) => {
+          const child = spawn(script, { env });
+          let settled = false;
+          let escalation;
+          const settle = (outcome) => {
+            if (settled) {
+              return;
+            }
+            settled = true;
+            clearTimeout(timer);
+            resolve(outcome);
+          };
+          const timer = setTimeout(() => {
+            console.error(`[hook] hook=${hook} status=timeout limit_seconds=${timeoutSeconds}`);
+            child.kill("SIGTERM");
+            escalation = setTimeout(() => {
+              console.error(`[hook] hook=${hook} status=kill_escalated grace_seconds=${killGraceSeconds}`);
+              child.kill("SIGKILL");
+            }, killGraceSeconds * 1e3);
+            escalation.unref();
+            settle({ statusCode: 500, message: "hook timed out" });
+          }, timeoutSeconds * 1e3);
+          timer.unref();
+          child.once("error", (error) => {
+            console.error(`[hook] hook=${hook} status=spawn_failed error=${error.message}`);
+            settle({ statusCode: 500, message: "hook could not be started" });
+          });
+          child.once("exit", (code) => {
+            clearTimeout(escalation);
+            if (code === 0) {
+              settle({ statusCode: 200, message: hook });
+              return;
+            }
+            console.error(`[hook] hook=${hook} status=failed exit_code=${code}`);
+            settle({ statusCode: 500, message: "hook failed" });
+          });
+          if (payload !== void 0 && child.stdin) {
+            child.stdin.write(payload);
+            child.stdin.end();
+          } else {
+            child.stdin?.end();
+          }
+        });
+      }
+      async function dispatch(hook, rawBody) {
+        const env = { ...process.env };
+        let payload;
+        if (hook === "run") {
+          const envelope = parseRunEnvelope(rawBody);
+          env.MICROVM_ID = envelope.microvmId;
+          payload = envelope.runHookPayload;
+        }
+        const script = `${hooksDir}/${hook}`;
+        if (!hasScript(script)) {
+          return { statusCode: 200, message: `${hook} (no script)` };
+        }
+        const outcome = await runScript(hook, script, env, payload);
+        if (hook === "terminate" && outcome.statusCode !== 200) {
+          console.error("[hook] hook=terminate status=reported_ok_despite_failure");
+          return { statusCode: 200, message: "terminate (best effort)" };
+        }
+        return outcome;
+      }
+      return (0, node_http_1.createServer)((request, response) => {
+        const send = (statusCode, message) => {
+          response.writeHead(statusCode, { "content-type": "application/json" });
+          response.end(JSON.stringify({ message }));
+        };
+        const path = (request.url ?? "").split("?")[0];
+        const hook = exports2.HOOK_NAMES.find((name) => exports2.HOOK_PATHS[name] === path);
+        if (!hook) {
+          request.resume();
+          send(404, "unknown hook path");
+          return;
+        }
+        if (request.method !== "POST") {
+          request.resume();
+          send(405, "hook requires POST");
+          return;
+        }
+        void readBody(request).then(async (body) => {
+          if (body === null) {
+            send(413, "hook body too large");
+            return;
+          }
+          try {
+            const outcome = await dispatch(hook, body);
+            send(outcome.statusCode, outcome.message);
+          } catch (error) {
+            send(400, error instanceof Error ? error.message : "bad request");
+          }
+        }).catch((error) => {
+          console.error(`[hook] hook=${hook} status=unhandled_error error=${error instanceof Error ? error.message : String(error)}`);
+          send(500, "hook failed");
+        });
+      });
+    }
+  }
+});
+
+// ../lambda-microvm-runtime/dist/node-runtime.js
+var require_node_runtime = __commonJS({
+  "../lambda-microvm-runtime/dist/node-runtime.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.createNodeRuntime = createNodeRuntime2;
+    var node_child_process_1 = require("node:child_process");
+    var node_fs_1 = require("node:fs");
+    var runtime_1 = require_runtime();
+    function createNodeRuntime2({ hooksDir, timeoutSeconds, killGraceSeconds }) {
+      return (0, runtime_1.createMicrovmRuntime)({
+        hooksDir,
+        timeoutSeconds,
+        killGraceSeconds,
+        hasScript: (script) => {
+          try {
+            (0, node_fs_1.accessSync)(script, node_fs_1.constants.X_OK);
+            return true;
+          } catch {
+            return false;
+          }
+        },
+        spawn: (script, options) => {
+          const child = (0, node_child_process_1.spawn)(script, {
+            env: options.env,
+            // stdin is a pipe so the run payload never has to travel in argv.
+            stdio: ["pipe", "inherit", "inherit"],
+            // Its own process group, so a signal can reach the tree the script
+            // built — a hook shells out, and stopping only the shell orphans the
+            // synchroniser or probe it was waiting on.
+            detached: true
+          });
+          child.kill = (signal) => {
+            try {
+              process.kill(-child.pid, signal);
+              return true;
+            } catch (error) {
+              if (error.code !== "ESRCH") {
+                console.error(`[hook] script=${script} status=signal_failed signal=${String(signal)} error=${error instanceof Error ? error.message : String(error)}`);
+              }
+              return false;
+            }
+          };
+          child.stdin?.on("error", (error) => {
+            console.error(`[hook] script=${script} status=stdin_write_failed error=${error.message}`);
+          });
+          return child;
+        }
+      });
+    }
+  }
+});
+
+// ../lambda-microvm-runtime/dist/index.js
+var require_dist = __commonJS({
+  "../lambda-microvm-runtime/dist/index.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.createNodeRuntime = exports2.HOOK_SIGTERM_SECONDS = exports2.HOOK_PATH_PREFIX = exports2.HOOK_PATHS = exports2.HOOK_NAMES = exports2.parseRunEnvelope = exports2.createMicrovmRuntime = void 0;
+    var runtime_1 = require_runtime();
+    Object.defineProperty(exports2, "createMicrovmRuntime", { enumerable: true, get: function() {
+      return runtime_1.createMicrovmRuntime;
+    } });
+    Object.defineProperty(exports2, "parseRunEnvelope", { enumerable: true, get: function() {
+      return runtime_1.parseRunEnvelope;
+    } });
+    Object.defineProperty(exports2, "HOOK_NAMES", { enumerable: true, get: function() {
+      return runtime_1.HOOK_NAMES;
+    } });
+    Object.defineProperty(exports2, "HOOK_PATHS", { enumerable: true, get: function() {
+      return runtime_1.HOOK_PATHS;
+    } });
+    Object.defineProperty(exports2, "HOOK_PATH_PREFIX", { enumerable: true, get: function() {
+      return runtime_1.HOOK_PATH_PREFIX;
+    } });
+    Object.defineProperty(exports2, "HOOK_SIGTERM_SECONDS", { enumerable: true, get: function() {
+      return runtime_1.HOOK_SIGTERM_SECONDS;
+    } });
+    var node_runtime_1 = require_node_runtime();
+    Object.defineProperty(exports2, "createNodeRuntime", { enumerable: true, get: function() {
+      return node_runtime_1.createNodeRuntime;
+    } });
+  }
+});
+
+// src/microvm/image/hook-server.ts
+var import_lambda_microvm_runtime = __toESM(require_dist());
+
+// src/microvm/constants.ts
+var HOOKS_PORT = 8080;
+var HOOKS_DIR = "/etc/evident/hooks";
+
+// src/microvm/image/hook-server.ts
+var server = (0, import_lambda_microvm_runtime.createNodeRuntime)({ hooksDir: HOOKS_DIR });
+var port = Number(process.env.HOOKS_PORT ?? HOOKS_PORT);
+server.listen(port, "0.0.0.0", () => {
+  console.log(`[hook] server listening on 0.0.0.0:${port}`);
+});