@volter/world-runtime 2.0.23 → 2.0.24

package/dist/src/runtime.js

@@ -114,11 +114,13 @@ async function untilReadyOrEnded(wait, ended, boot, what, log) {
  *  always runs in full: one port's answer says nothing of the others'. Programs that are not twins are never asked. */
 async function confirmOwnPort(port, boot, ended, twin, what, log, early = false) {
     // A twin is asked at once, raced with the settle: a server slow to answer costs no more than the settle did.
-    const answer = twin ? worldBootOf(port) : Promise.resolve(null);
+    boot.signal.throwIfAborted();
+    const answer = twin ? worldBootOf(port, boot.signal) : Promise.resolve(null);
     const own = early && twin ? answer.then((a) => (a && a.boot === boot.bootId ? 'own' : new Promise(() => undefined))) : new Promise(() => undefined);
     // `ended` absent: the process was already settled (a co-located host settles once for all its twins).
     if (ended) {
         const settled = await Promise.race([own, ended.then(() => 'ended'), new Promise((resolveAlive) => setTimeout(() => resolveAlive('alive'), 300))]);
+        boot.signal.throwIfAborted();
         if (settled === 'own')
             return;
         if (settled === 'ended')
@@ -127,28 +129,65 @@ async function confirmOwnPort(port, boot, ended, twin, what, log, early = false)
     if (!twin)
         return;
     const answered = await answer;
+    boot.signal.throwIfAborted();
     if (answered && typeof answered.boot === 'string' && answered.boot !== boot.bootId) {
         throw new Error(`${what}: its port is answered by a twin of another World boot (${answered.boot}), not this one; a leftover World holds the port. Stop it (\`volter-world list\`, then \`down\`) and retry.\nLog: ${log}`);
     }
 }
 /** What the server on a loopback port says its World boot is (WORLD_BOOT_PATH), or null. A direct loopback request:
  *  never through a proxy an activated shell's environment names. */
-function worldBootOf(port) {
+function worldBootOf(port, abort) {
     return new Promise((resolveBoot) => {
-        const request = httpGet({ host: '127.0.0.1', port, path: WORLD_BOOT_PATH, timeout: 1000, agent: false }, (response) => {
-            let body = '';
-            response.setEncoding('utf8');
-            response.on('data', (chunk) => { body += chunk; if (body.length > 4096)
-                request.destroy(); });
-            response.on('end', () => { try {
-                resolveBoot(response.statusCode === 200 ? JSON.parse(body) : null);
-            }
-            catch {
-                resolveBoot(null);
-            } });
-        });
-        request.on('timeout', () => request.destroy());
-        request.on('error', () => resolveBoot(null));
+        let request;
+        let deadline;
+        let settled = false;
+        let responseStarted = false;
+        const finish = (value) => {
+            if (settled)
+                return;
+            settled = true;
+            if (deadline !== undefined)
+                clearTimeout(deadline);
+            abort.removeEventListener('abort', cancel);
+            resolveBoot(value);
+        };
+        const cancel = () => { finish(null); request?.destroy(); };
+        if (abort.aborted) {
+            finish(null);
+            return;
+        }
+        abort.addEventListener('abort', cancel, { once: true });
+        // A socket timeout alone is insufficient: destroying a request after
+        // headers can close/abort its response without emitting request 'error'.
+        // Bound the whole probe, including a peer that dribbles bytes forever.
+        deadline = setTimeout(cancel, 1000);
+        try {
+            request = httpGet({ host: '127.0.0.1', port, path: WORLD_BOOT_PATH, timeout: 1000, agent: false }, (response) => {
+                responseStarted = true;
+                let body = '';
+                response.on('error', cancel);
+                response.on('aborted', cancel);
+                response.on('close', () => finish(null));
+                response.setEncoding('utf8');
+                response.on('data', (chunk) => { body += chunk; if (body.length > 4096)
+                    cancel(); });
+                response.on('end', () => {
+                    try {
+                        finish(response.statusCode === 200 ? JSON.parse(body) : null);
+                    }
+                    catch {
+                        finish(null);
+                    }
+                });
+            });
+            request.on('timeout', cancel);
+            request.on('error', () => finish(null));
+            request.on('close', () => { if (!responseStarted)
+                finish(null); });
+        }
+        catch {
+            cancel();
+        }
     });
 }
 /** A stopped service's own account from its log: how it ended and the last lines it wrote. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/world-runtime",
-  "version": "2.0.23",
+  "version": "2.0.24",
   "description": "World configs for twins: boot named local runtimes, allocate ports, generate world.env/instance.json, and run apps against fake-key twin worlds.",
   "keywords": [
     "twin",

package/src/runtime.ts

@@ -3,7 +3,7 @@ import { offSignal } from './signals.ts';
 import { assertWorldStateRemovable, removeWorldState } from './ancestry.ts';
 import { packCli, packEntry } from './catalog.ts';
 import { spawn, spawnSync } from 'node:child_process';
-import { get as httpGet } from 'node:http';
+import { get as httpGet, type ClientRequest } from 'node:http';
 import { siblingScript } from './sibling.ts';
 import { commandLifetime, commandProcessGroup, CommandRetirementError } from './command-lifetime.ts';
 import { superviseWorldRun } from './run-task.ts';
@@ -108,16 +108,19 @@ async function untilReadyOrEnded<T>(wait: (abort: AbortSignal) => Promise<T>, en
  *  always runs in full: one port's answer says nothing of the others'. Programs that are not twins are never asked. */
 async function confirmOwnPort(port: number, boot: BootContext, ended: Promise<void> | undefined, twin: boolean, what: string, log: string, early = false): Promise<void> {
   // A twin is asked at once, raced with the settle: a server slow to answer costs no more than the settle did.
-  const answer = twin ? worldBootOf(port) : Promise.resolve(null);
+  boot.signal.throwIfAborted();
+  const answer = twin ? worldBootOf(port, boot.signal) : Promise.resolve(null);
   const own = early && twin ? answer.then((a) => (a && a.boot === boot.bootId ? 'own' as const : new Promise<never>(() => undefined))) : new Promise<never>(() => undefined);
   // `ended` absent: the process was already settled (a co-located host settles once for all its twins).
   if (ended) {
     const settled = await Promise.race([own, ended.then(() => 'ended' as const), new Promise<'alive'>((resolveAlive) => setTimeout(() => resolveAlive('alive'), 300))]);
+    boot.signal.throwIfAborted();
     if (settled === 'own') return;
     if (settled === 'ended') throw new Error(`${what} ended right after its port first answered, so another process probably holds the port: the service ${endedAccount(log)}\nLog: ${log}`);
   }
   if (!twin) return;
   const answered = await answer;
+  boot.signal.throwIfAborted();
   if (answered && typeof answered.boot === 'string' && answered.boot !== boot.bootId) {
     throw new Error(`${what}: its port is answered by a twin of another World boot (${answered.boot}), not this one; a leftover World holds the port. Stop it (\`volter-world list\`, then \`down\`) and retry.\nLog: ${log}`);
   }
@@ -125,16 +128,44 @@ async function confirmOwnPort(port: number, boot: BootContext, ended: Promise<vo
 
 /** What the server on a loopback port says its World boot is (WORLD_BOOT_PATH), or null. A direct loopback request:
  *  never through a proxy an activated shell's environment names. */
-function worldBootOf(port: number): Promise<{ boot?: unknown } | null> {
+function worldBootOf(port: number, abort: AbortSignal): Promise<{ boot?: unknown } | null> {
   return new Promise((resolveBoot) => {
-    const request = httpGet({ host: '127.0.0.1', port, path: WORLD_BOOT_PATH, timeout: 1000, agent: false }, (response) => {
-      let body = '';
-      response.setEncoding('utf8');
-      response.on('data', (chunk: string) => { body += chunk; if (body.length > 4096) request.destroy(); });
-      response.on('end', () => { try { resolveBoot(response.statusCode === 200 ? JSON.parse(body) as { boot?: unknown } : null); } catch { resolveBoot(null); } });
-    });
-    request.on('timeout', () => request.destroy());
-    request.on('error', () => resolveBoot(null));
+    let request: ClientRequest | undefined;
+    let deadline: ReturnType<typeof setTimeout> | undefined;
+    let settled = false;
+    let responseStarted = false;
+    const finish = (value: { boot?: unknown } | null): void => {
+      if (settled) return;
+      settled = true;
+      if (deadline !== undefined) clearTimeout(deadline);
+      abort.removeEventListener('abort', cancel);
+      resolveBoot(value);
+    };
+    const cancel = (): void => { finish(null); request?.destroy(); };
+    if (abort.aborted) { finish(null); return; }
+    abort.addEventListener('abort', cancel, { once: true });
+    // A socket timeout alone is insufficient: destroying a request after
+    // headers can close/abort its response without emitting request 'error'.
+    // Bound the whole probe, including a peer that dribbles bytes forever.
+    deadline = setTimeout(cancel, 1000);
+    try {
+      request = httpGet({ host: '127.0.0.1', port, path: WORLD_BOOT_PATH, timeout: 1000, agent: false }, (response) => {
+        responseStarted = true;
+        let body = '';
+        response.on('error', cancel);
+        response.on('aborted', cancel);
+        response.on('close', () => finish(null));
+        response.setEncoding('utf8');
+        response.on('data', (chunk: string) => { body += chunk; if (body.length > 4096) cancel(); });
+        response.on('end', () => {
+          try { finish(response.statusCode === 200 ? JSON.parse(body) as { boot?: unknown } : null); }
+          catch { finish(null); }
+        });
+      });
+      request.on('timeout', cancel);
+      request.on('error', () => finish(null));
+      request.on('close', () => { if (!responseStarted) finish(null); });
+    } catch { cancel(); }
   });
 }