sst 2.20.0 → 2.21.0

package/runtime/handlers/container.js

@@ -1,11 +1,13 @@
+import http from "http";
+import { spawn } from "child_process";
 import { useRuntimeHandlers } from "../handlers.js";
 import { useRuntimeWorkers } from "../workers.js";
+import { useRuntimeServerConfig } from "../server.js";
 import { Context } from "../../context/context.js";
 import { VisibleError } from "../../error.js";
-import { spawn } from "child_process";
-import { useRuntimeServerConfig } from "../server.js";
 import { isChild } from "../../util/fs.js";
 import { execAsync } from "../../util/process.js";
+import { useFunctions } from "../../constructs/Function.js";
 export const useContainerHandler = Context.memo(async () => {
     const workers = await useRuntimeWorkers();
     const server = await useRuntimeServerConfig();
@@ -21,36 +23,9 @@ export const useContainerHandler = Context.memo(async () => {
         },
         canHandle: (input) => input.startsWith("container"),
         startWorker: async (input) => {
-            const name = `sst-workerID-${input.workerID}-${Date.now()}`;
-            const proc = spawn("docker", [
-                "run",
-                "--rm",
-                "--network=host",
-                `--name=${name}`,
-                ...Object.entries({
-                    ...input.environment,
-                    IS_LOCAL: "true",
-                    AWS_LAMBDA_RUNTIME_API: `host.docker.internal:${server.port}/${input.workerID}`,
-                })
-                    .map(([key, value]) => ["-e", `${key}=${value}`])
-                    .flat(),
-                `sst-dev:${input.functionID}`,
-            ], {
-                env: {
-                    ...process.env,
-                },
-                cwd: input.out,
-            });
-            proc.on("exit", () => {
-                workers.exited(input.workerID);
-            });
-            proc.stdout.on("data", (data) => {
-                workers.stdout(input.workerID, data.toString());
-            });
-            proc.stderr.on("data", (data) => {
-                workers.stdout(input.workerID, data.toString());
-            });
-            containers.set(input.workerID, name);
+            input.environment.SST_DEBUG_JOB
+                ? startJobWorker(input)
+                : startLambdaWorker(input);
         },
         stopWorker: async (workerID) => {
             const name = containers.get(workerID);
@@ -121,4 +96,155 @@ export const useContainerHandler = Context.memo(async () => {
             };
         },
     });
+    function dockerRun(input, opts, onExit) {
+        const name = `sst-workerID-${input.workerID}-${Date.now()}`;
+        const proc = spawn("docker", [
+            "run",
+            "--rm",
+            "--network=host",
+            `--name=${name}`,
+            ...Object.entries({
+                ...input.environment,
+                ...opts.envs,
+                IS_LOCAL: "true",
+            })
+                .map(([key, value]) => ["-e", `${key}=${value}`])
+                .flat(),
+            ...(opts.entrypoint !== undefined
+                ? ["--entrypoint", opts.entrypoint]
+                : []),
+            `sst-dev:${input.functionID}`,
+            ...(opts.cmd ?? []),
+        ], {
+            env: {
+                ...process.env,
+            },
+            cwd: input.out,
+        });
+        proc.on("exit", (code) => {
+            onExit(code);
+        });
+        proc.stdout.on("data", (data) => {
+            workers.stdout(input.workerID, data.toString());
+        });
+        proc.stderr.on("data", (data) => {
+            workers.stdout(input.workerID, data.toString());
+        });
+        containers.set(input.workerID, name);
+    }
+    function startLambdaWorker(input) {
+        dockerRun(input, {
+            envs: {
+                AWS_LAMBDA_RUNTIME_API: `host.docker.internal:${server.port}/${input.workerID}`,
+            },
+        }, () => {
+            workers.exited(input.workerID);
+        });
+    }
+    async function startJobWorker(input) {
+        // Job container is special:
+        // 1. Not capable of receiving the `event` payload
+        //    - on `sst deploy`, the CodeBuild job is started with `SST_PAYLOAD` env var
+        //    - on `sst dev`, set `SST_DEBUG_JOB` env var here
+        // 2. Worker exits at the end of the run.
+        const fn = useFunctions().fromID(input.functionID);
+        // Fetch request
+        const result = await init();
+        const awsRequestId = result.headers["lambda-runtime-aws-request-id"];
+        try {
+            dockerRun(input, {
+                entrypoint: "",
+                cmd: fn?.container?.docker.cmd,
+                envs: {
+                    SST_PAYLOAD: result.body,
+                },
+            }, async (code) => {
+                code === 0 ? await success() : await error();
+                workers.exited(input.workerID);
+            });
+        }
+        catch (ex) {
+            await initError(ex);
+            workers.exited(input.workerID);
+        }
+        async function init() {
+            return await fetch({
+                path: `/runtime/invocation/next`,
+                method: "GET",
+                headers: {},
+            });
+        }
+        async function initError(ex) {
+            return await fetch({
+                path: `/runtime/init/error`,
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    errorType: "Error",
+                    errorMessage: ex.message,
+                    trace: ex.stack?.split("\n"),
+                }),
+            });
+        }
+        async function success() {
+            while (true) {
+                try {
+                    await fetch({
+                        path: `/runtime/invocation/${awsRequestId}/response`,
+                        method: "POST",
+                        headers: {
+                            "Content-Type": "application/json",
+                        },
+                        body: JSON.stringify("Job completed successfully"),
+                    });
+                    break;
+                }
+                catch (ex) {
+                    console.error(ex);
+                    await new Promise((resolve) => setTimeout(resolve, 500));
+                }
+            }
+        }
+        async function error() {
+            return await fetch({
+                path: `/runtime/invocation/${awsRequestId}/error`,
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    errorType: "Error",
+                    errorMessage: "Failed to run job",
+                    trace: [],
+                }),
+            });
+        }
+        function fetch(req) {
+            return new Promise((resolve, reject) => {
+                const request = http.request(input.url + req.path, {
+                    headers: req.headers,
+                    method: req.method,
+                }, (res) => {
+                    let body = "";
+                    res.setEncoding("utf8");
+                    res.on("data", (chunk) => {
+                        body += chunk.toString();
+                    });
+                    res.on("end", () => {
+                        resolve({
+                            statusCode: res.statusCode,
+                            headers: res.headers,
+                            body,
+                        });
+                    });
+                });
+                request.on("error", reject);
+                if (req.body)
+                    request.write(req.body);
+                request.end();
+            });
+        }
+    }
 });

package/runtime/handlers.d.ts

@@ -19,7 +19,7 @@ interface BuildInput {
     out: string;
     props: FunctionProps;
 }
-interface StartWorkerInput {
+export interface StartWorkerInput {
     url: string;
     workerID: string;
     functionID: string;

package/sst.mjs

@@ -5718,16 +5718,18 @@ var container_exports = {};
 __export(container_exports, {
   useContainerHandler: () => useContainerHandler
 });
+import http from "http";
 import { spawn as spawn3 } from "child_process";
+import { useFunctions as useFunctions3 } from "../src/constructs/Function.js";
 var useContainerHandler;
 var init_container = __esm({
   "src/runtime/handlers/container.ts"() {
     "use strict";
     init_handlers2();
     init_workers();
+    init_server();
     init_context();
     init_error();
-    init_server();
     init_fs();
     init_process();
     useContainerHandler = Context.memo(async () => {
@@ -5745,38 +5747,7 @@ var init_container = __esm({
         },
         canHandle: (input) => input.startsWith("container"),
         startWorker: async (input) => {
-          const name = `sst-workerID-${input.workerID}-${Date.now()}`;
-          const proc = spawn3(
-            "docker",
-            [
-              "run",
-              "--rm",
-              "--network=host",
-              `--name=${name}`,
-              ...Object.entries({
-                ...input.environment,
-                IS_LOCAL: "true",
-                AWS_LAMBDA_RUNTIME_API: `host.docker.internal:${server.port}/${input.workerID}`
-              }).map(([key, value]) => ["-e", `${key}=${value}`]).flat(),
-              `sst-dev:${input.functionID}`
-            ],
-            {
-              env: {
-                ...process.env
-              },
-              cwd: input.out
-            }
-          );
-          proc.on("exit", () => {
-            workers.exited(input.workerID);
-          });
-          proc.stdout.on("data", (data2) => {
-            workers.stdout(input.workerID, data2.toString());
-          });
-          proc.stderr.on("data", (data2) => {
-            workers.stdout(input.workerID, data2.toString());
-          });
-          containers.set(input.workerID, name);
+          input.environment.SST_DEBUG_JOB ? startJobWorker(input) : startLambdaWorker(input);
         },
         stopWorker: async (workerID) => {
           const name = containers.get(workerID);
@@ -5845,6 +5816,161 @@ var init_container = __esm({
           };
         }
       });
+      function dockerRun(input, opts, onExit) {
+        const name = `sst-workerID-${input.workerID}-${Date.now()}`;
+        const proc = spawn3(
+          "docker",
+          [
+            "run",
+            "--rm",
+            "--network=host",
+            `--name=${name}`,
+            ...Object.entries({
+              ...input.environment,
+              ...opts.envs,
+              IS_LOCAL: "true"
+            }).map(([key, value]) => ["-e", `${key}=${value}`]).flat(),
+            ...opts.entrypoint !== void 0 ? ["--entrypoint", opts.entrypoint] : [],
+            `sst-dev:${input.functionID}`,
+            ...opts.cmd ?? []
+          ],
+          {
+            env: {
+              ...process.env
+            },
+            cwd: input.out
+          }
+        );
+        proc.on("exit", (code) => {
+          onExit(code);
+        });
+        proc.stdout.on("data", (data2) => {
+          workers.stdout(input.workerID, data2.toString());
+        });
+        proc.stderr.on("data", (data2) => {
+          workers.stdout(input.workerID, data2.toString());
+        });
+        containers.set(input.workerID, name);
+      }
+      function startLambdaWorker(input) {
+        dockerRun(
+          input,
+          {
+            envs: {
+              AWS_LAMBDA_RUNTIME_API: `host.docker.internal:${server.port}/${input.workerID}`
+            }
+          },
+          () => {
+            workers.exited(input.workerID);
+          }
+        );
+      }
+      async function startJobWorker(input) {
+        const fn = useFunctions3().fromID(input.functionID);
+        const result = await init();
+        const awsRequestId = result.headers["lambda-runtime-aws-request-id"];
+        try {
+          dockerRun(
+            input,
+            {
+              entrypoint: "",
+              cmd: fn?.container?.docker.cmd,
+              envs: {
+                SST_PAYLOAD: result.body
+              }
+            },
+            async (code) => {
+              code === 0 ? await success() : await error3();
+              workers.exited(input.workerID);
+            }
+          );
+        } catch (ex) {
+          await initError(ex);
+          workers.exited(input.workerID);
+        }
+        async function init() {
+          return await fetch({
+            path: `/runtime/invocation/next`,
+            method: "GET",
+            headers: {}
+          });
+        }
+        async function initError(ex) {
+          return await fetch({
+            path: `/runtime/init/error`,
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+              errorType: "Error",
+              errorMessage: ex.message,
+              trace: ex.stack?.split("\n")
+            })
+          });
+        }
+        async function success() {
+          while (true) {
+            try {
+              await fetch({
+                path: `/runtime/invocation/${awsRequestId}/response`,
+                method: "POST",
+                headers: {
+                  "Content-Type": "application/json"
+                },
+                body: JSON.stringify("Job completed successfully")
+              });
+              break;
+            } catch (ex) {
+              console.error(ex);
+              await new Promise((resolve2) => setTimeout(resolve2, 500));
+            }
+          }
+        }
+        async function error3() {
+          return await fetch({
+            path: `/runtime/invocation/${awsRequestId}/error`,
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+              errorType: "Error",
+              errorMessage: "Failed to run job",
+              trace: []
+            })
+          });
+        }
+        function fetch(req) {
+          return new Promise((resolve2, reject) => {
+            const request = http.request(
+              input.url + req.path,
+              {
+                headers: req.headers,
+                method: req.method
+              },
+              (res) => {
+                let body = "";
+                res.setEncoding("utf8");
+                res.on("data", (chunk) => {
+                  body += chunk.toString();
+                });
+                res.on("end", () => {
+                  resolve2({
+                    statusCode: res.statusCode,
+                    headers: res.headers,
+                    body
+                  });
+                });
+              }
+            );
+            request.on("error", reject);
+            if (req.body)
+              request.write(req.body);
+            request.end();
+          });
+        }
+      }
     });
   }
 });
@@ -6855,7 +6981,7 @@ import express2 from "express";
 import fs14 from "fs/promises";
 import { WebSocketServer } from "ws";
 import https3 from "https";
-import http from "http";
+import http2 from "http";
 import { applyWSSHandler } from "@trpc/server/adapters/ws/dist/trpc-server-adapters-ws.cjs.js";
 import { optimise } from "dendriform-immer-patch-optimiser";
 import { sync } from "cross-spawn";
@@ -6951,7 +7077,7 @@ async function useLocalServer(opts) {
         rest
       );
     }
-    return http.createServer({}, rest);
+    return http2.createServer({}, rest);
   })();
   const wss = new WebSocketServer({ server });
   wss.on("connection", (socket, req) => {
@@ -8210,7 +8336,7 @@ var dev = (program2) => program2.command(
     const { useLocalServer: useLocalServer2 } = await Promise.resolve().then(() => (init_server2(), server_exports2));
     const fs19 = await import("fs/promises");
     const crypto2 = await import("crypto");
-    const { useFunctions: useFunctions3 } = await import("../src/constructs/Function.js");
+    const { useFunctions: useFunctions4 } = await import("../src/constructs/Function.js");
     const { useSites } = await import("../src/constructs/SsrSite.js");
     const { usePothosBuilder: usePothosBuilder2 } = await Promise.resolve().then(() => (init_pothos2(), pothos_exports2));
     const { useKyselyTypeGenerator: useKyselyTypeGenerator2 } = await Promise.resolve().then(() => (init_kysely(), kysely_exports));
@@ -8255,12 +8381,12 @@ var dev = (program2) => program2.command(
           prefix(evt.properties.requestID),
           Colors2.dim.bold("Invoked"),
           Colors2.dim(
-            useFunctions3().fromID(evt.properties.functionID)?.handler
+            useFunctions4().fromID(evt.properties.functionID)?.handler
           )
         );
       });
       bus.subscribe("worker.stdout", async (evt) => {
-        const info = useFunctions3().fromID(evt.properties.functionID);
+        const info = useFunctions4().fromID(evt.properties.functionID);
         prefix(evt.properties.requestID);
         const { started } = pending.get(evt.properties.requestID);
         for (let line of evt.properties.message.split("\n")) {
@@ -8278,7 +8404,7 @@ var dev = (program2) => program2.command(
         }
       });
       bus.subscribe("function.build.started", async (evt) => {
-        const info = useFunctions3().fromID(evt.properties.functionID);
+        const info = useFunctions4().fromID(evt.properties.functionID);
         if (!info)
           return;
         if (info.enableLiveDev === false)
@@ -8290,7 +8416,7 @@ var dev = (program2) => program2.command(
         );
       });
       bus.subscribe("function.build.success", async (evt) => {
-        const info = useFunctions3().fromID(evt.properties.functionID);
+        const info = useFunctions4().fromID(evt.properties.functionID);
         if (!info)
           return;
         if (info.enableLiveDev === false)
@@ -8300,7 +8426,7 @@ var dev = (program2) => program2.command(
         );
       });
       bus.subscribe("function.build.failed", async (evt) => {
-        const info = useFunctions3().fromID(evt.properties.functionID);
+        const info = useFunctions4().fromID(evt.properties.functionID);
         if (!info)
           return;
         if (info.enableLiveDev === false)