@genroc/eval-node 0.0.0-edge.e00b1c02 → 0.0.0-edge.e1372854

package/README.md

@@ -78,9 +78,9 @@ export default function (input: Input): Output {
 ## Running the worker
 
 ```sh
-docker run -e GENROC_SERVER=http://host:8448 -e TASK=eval_node ghcr.io/genroc/eval-node:preview
+docker run -e GENROC_SERVER=http://host:8448 ghcr.io/genroc/eval-node:latest
 # or
-GENROC_SERVER=http://localhost:8448 TASK=eval_node npx genroc-eval-node
+GENROC_SERVER=http://localhost:8448 npx genroc-eval-node
 ```
 
 The worker connects to genroc, not the other way round, so it only needs outbound access.
@@ -88,8 +88,8 @@ The worker connects to genroc, not the other way round, so it only needs outboun
 | env | default | |
 |---|---|---|
 | `GENROC_SERVER` | `http://localhost:8448` | the genroc server |
-| `GENROC_TOKEN` / `GENROC_TOKEN_FILE` | *(none)* | token, or a file holding it, when the server uses `--auth token` |
-| `TASK` / `PROCESS` | *(none)* | claim only this task id / process. **Without one, the worker claims every external task.** |
+| `GENROC_TOKEN` / `GENROC_TOKEN_FILE` | *(none)* | token, or a file holding it, when the server uses `--auth` |
+| `PROCESS` / `TASK` | `script-node` / `eval_node` | the process and task id this worker claims; the defaults are script-node's. Set `PROCESS` for a renamed copy. Neither may be empty. |
 | `CONCURRENCY` | `4` | scripts run at once |
 | `LEASE_MS` | `30000` | claim lease, renewed every third of it |
 | `POLL_MS` | `250` | idle poll interval |
@@ -109,19 +109,20 @@ match. Retrying does not help with any of them, because the same code fails the
 | code | when |
 |---|---|
 | `threw` | the script threw or rejected |
-| `timeout` | it ran past `timeout_ms` (default 5000) |
+| `timeout` | it ran past the task's `timeout` (5000 ms when the task has none) |
 | `compile_error` | the module does not parse, or has no default-export function |
 | `nonserializable` | the return value cannot be serialized to JSON (a cycle, a `BigInt`) |
 | `exited` | the script called `process.exit()` |
 
-`error.data` is `{name, stack?}`. Set `e.name = "LimitExceeded"` in the script to tell your
-own failures apart. The stack is mapped back to your source lines.
+`error.data` is `{name, stack?}`. `name` is the error's class name, so throwing your own
+`class LimitExceeded extends Error {}` tells your failures apart; setting `e.name` overrides it,
+and a thrown non-`Error` is `Thrown`. The stack is mapped back to your source lines.
 
 If the worker itself faults, it releases the task for another worker and reports no error.
 
-Keep the task's `timeout` above `timeout_ms`. Otherwise a slow script ends with
-`external.timeout`, and you cannot tell it from having no worker at all. The `script-node`
-template already does this.
+The task's `timeout` is the script's budget, waiting in the queue included. The worker stops
+the script just before it and answers `timeout`, so `external.timeout` means no worker answered
+at all. With `script-node`, set it through the `timeout_ms` input.
 
 ## Limits
 

package/dist/realm.js

@@ -36,7 +36,10 @@ function scriptStack(err) {
 }
 function describe(err, kind) {
     if (err instanceof Error) {
-        return { kind, name: err.name, message: err.message, stack: scriptStack(err) };
+        // A subclass inherits `name` from Error.prototype, so `class LimitExceeded extends Error {}`
+        // would report "Error"; a name the script set still wins.
+        const name = err.name === "Error" && err.constructor.name ? err.constructor.name : err.name;
+        return { kind, name, message: err.message, stack: scriptStack(err) };
     }
     // A script may throw a non-Error (`throw {code: "x"}`), so name/message must not assume one.
     return { kind, name: "Thrown", message: safeText(err) };

package/dist/worker.js

@@ -19,8 +19,17 @@ const POLL_MS = Number(process.env.POLL_MS ?? 250);
 // should return its task quickly rather than holding it for the whole budget.
 const LEASE_MS = Number(process.env.LEASE_MS ?? 30_000);
 const RENEW_MS = Math.max(1_000, Math.floor(LEASE_MS / 3));
-const PROCESS_FILTER = process.env.PROCESS ?? "";
-const TASK_FILTER = process.env.TASK ?? "";
+// The answer has to land before the task's deadline fires, or a script that overran surfaces as
+// external.timeout ("nobody answered") rather than as its own `timeout`.
+const ANSWER_MARGIN_MS = 250;
+// script-node's names; a renamed copy sets PROCESS. The claim requires both: this worker answers
+// one task's contract, so it must never be handed another's.
+const PROCESS_FILTER = process.env.PROCESS ?? "script-node";
+const TASK_FILTER = process.env.TASK ?? "eval_node";
+if (!PROCESS_FILTER || !TASK_FILTER) {
+    console.error("PROCESS and TASK must both name the queue this worker serves; neither may be empty.");
+    process.exit(1);
+}
 // Large values arrive as refs; a bundle is one object per definition version, fetched once.
 // Refs are content hashes, so the cache never invalidates.
 const objectCache = new Map();
@@ -94,17 +103,13 @@ async function call(path, body) {
 }
 /** A task input that is not an EvalRequest is the definition's fault, reported as compile_error:
  *  the nearest permanent kind, since no retry fixes the definition. */
-function asEvalRequest(input) {
+function asEvalRequest(input, timeoutMs) {
     if (typeof input !== "object" || input === null)
         return "the task input is not an object";
     const r = input;
     if (typeof r.code !== "string")
         return "the task input has no `code` string";
-    return {
-        code: r.code,
-        input: r.input,
-        timeout_ms: typeof r.timeout_ms === "number" ? r.timeout_ms : undefined,
-    };
+    return { code: r.code, input: r.input, timeout_ms: timeoutMs };
 }
 const inFlight = new Map();
 let running = true;
@@ -116,8 +121,8 @@ async function claim(n) {
         worker_id: WORKER_ID,
         limit: n,
         lease_ms: LEASE_MS,
-        ...(PROCESS_FILTER ? { process: PROCESS_FILTER } : {}),
-        ...(TASK_FILTER ? { task: TASK_FILTER } : {}),
+        process: PROCESS_FILTER,
+        task: TASK_FILTER,
     });
     if (!ok) {
         // A credential problem is not transient, and polling through it looks like a healthy idle
@@ -161,6 +166,9 @@ async function answer(token, outcome) {
     await release(token);
 }
 async function run(job, signal) {
+    // The task's own timeout is the script's budget, moved onto the monotonic clock so a wall-clock
+    // step mid-run cannot stretch it. Fetching the objects below spends the same deadline.
+    const due = job.deadline === undefined ? undefined : performance.now() + (Date.parse(job.deadline) - Date.now());
     let resolved;
     try {
         resolved = await resolveObjects(job);
@@ -172,7 +180,16 @@ async function run(job, signal) {
         await release(job.token);
         return;
     }
-    const req = asEvalRequest(resolved);
+    let timeoutMs;
+    if (due !== undefined) {
+        timeoutMs = Math.floor(due - performance.now() - ANSWER_MARGIN_MS);
+        if (timeoutMs <= 0) {
+            // Too late to run anything: the deadline fires as external.timeout, which is the truth.
+            await release(job.token);
+            return;
+        }
+    }
+    const req = asEvalRequest(resolved, timeoutMs);
     if (typeof req === "string") {
         await answer(job.token, {
             error: { code: "compile_error", message: req, data: { name: "BadTaskInput" } },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@genroc/eval-node",
-  "version": "0.0.0-edge.e00b1c02",
+  "version": "0.0.0-edge.e1372854",
   "type": "module",
   "engines": {
     "node": ">=24"

package/realm.ts

@@ -35,7 +35,10 @@ function scriptStack(err: unknown): string | undefined {
 
 function describe(err: unknown, kind: FailureKind): EvalFailure {
   if (err instanceof Error) {
-    return { kind, name: err.name, message: err.message, stack: scriptStack(err) };
+    // A subclass inherits `name` from Error.prototype, so `class LimitExceeded extends Error {}`
+    // would report "Error"; a name the script set still wins.
+    const name = err.name === "Error" && err.constructor.name ? err.constructor.name : err.name;
+    return { kind, name, message: err.message, stack: scriptStack(err) };
   }
   // A script may throw a non-Error (`throw {code: "x"}`), so name/message must not assume one.
   return { kind, name: "Thrown", message: safeText(err) };

package/worker.ts

@@ -22,8 +22,17 @@ const POLL_MS = Number(process.env.POLL_MS ?? 250);
 // should return its task quickly rather than holding it for the whole budget.
 const LEASE_MS = Number(process.env.LEASE_MS ?? 30_000);
 const RENEW_MS = Math.max(1_000, Math.floor(LEASE_MS / 3));
-const PROCESS_FILTER = process.env.PROCESS ?? "";
-const TASK_FILTER = process.env.TASK ?? "";
+// The answer has to land before the task's deadline fires, or a script that overran surfaces as
+// external.timeout ("nobody answered") rather than as its own `timeout`.
+const ANSWER_MARGIN_MS = 250;
+// script-node's names; a renamed copy sets PROCESS. The claim requires both: this worker answers
+// one task's contract, so it must never be handed another's.
+const PROCESS_FILTER = process.env.PROCESS ?? "script-node";
+const TASK_FILTER = process.env.TASK ?? "eval_node";
+if (!PROCESS_FILTER || !TASK_FILTER) {
+  console.error("PROCESS and TASK must both name the queue this worker serves; neither may be empty.");
+  process.exit(1);
+}
 
 type ObjectEntry = { path: (string | number)[]; ref: string; size: number };
 
@@ -33,7 +42,7 @@ type QueueTask = {
   task: string;
   external_input: unknown;
   objects?: ObjectEntry[];
-  raises?: Record<string, unknown>;
+  deadline?: string;
 };
 
 // Large values arrive as refs; a bundle is one object per definition version, fetched once.
@@ -106,15 +115,11 @@ async function call(path: string, body: unknown): Promise<{ ok: boolean; status:
 
 /** A task input that is not an EvalRequest is the definition's fault, reported as compile_error:
  *  the nearest permanent kind, since no retry fixes the definition. */
-function asEvalRequest(input: unknown): EvalRequest | string {
+function asEvalRequest(input: unknown, timeoutMs: number | undefined): EvalRequest | string {
   if (typeof input !== "object" || input === null) return "the task input is not an object";
   const r = input as Record<string, unknown>;
   if (typeof r.code !== "string") return "the task input has no `code` string";
-  return {
-    code: r.code,
-    input: r.input,
-    timeout_ms: typeof r.timeout_ms === "number" ? r.timeout_ms : undefined,
-  };
+  return { code: r.code, input: r.input, timeout_ms: timeoutMs };
 }
 
 /** genroc cannot call us, so a cancellation arrives on our own heartbeat and reaches the
@@ -133,8 +138,8 @@ async function claim(n: number): Promise<QueueTask[]> {
     worker_id: WORKER_ID,
     limit: n,
     lease_ms: LEASE_MS,
-    ...(PROCESS_FILTER ? { process: PROCESS_FILTER } : {}),
-    ...(TASK_FILTER ? { task: TASK_FILTER } : {}),
+    process: PROCESS_FILTER,
+    task: TASK_FILTER,
   });
   if (!ok) {
     // A credential problem is not transient, and polling through it looks like a healthy idle
@@ -183,6 +188,9 @@ async function answer(token: string, outcome: Record<string, unknown>): Promise<
 }
 
 async function run(job: QueueTask, signal: AbortSignal): Promise<void> {
+  // The task's own timeout is the script's budget, moved onto the monotonic clock so a wall-clock
+  // step mid-run cannot stretch it. Fetching the objects below spends the same deadline.
+  const due = job.deadline === undefined ? undefined : performance.now() + (Date.parse(job.deadline) - Date.now());
   let resolved: unknown;
   try {
     resolved = await resolveObjects(job);
@@ -193,7 +201,16 @@ async function run(job: QueueTask, signal: AbortSignal): Promise<void> {
     await release(job.token);
     return;
   }
-  const req = asEvalRequest(resolved);
+  let timeoutMs: number | undefined;
+  if (due !== undefined) {
+    timeoutMs = Math.floor(due - performance.now() - ANSWER_MARGIN_MS);
+    if (timeoutMs <= 0) {
+      // Too late to run anything: the deadline fires as external.timeout, which is the truth.
+      await release(job.token);
+      return;
+    }
+  }
+  const req = asEvalRequest(resolved, timeoutMs);
   if (typeof req === "string") {
     await answer(job.token, {
       error: { code: "compile_error", message: req, data: { name: "BadTaskInput" } },