@torrent-tv/proxy 2.55.14 → 2.57.0

package/test/packet-witness-ring.test.js

@@ -0,0 +1,236 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { EventEmitter } from "node:events";
+import { mkdtemp, readdir, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+import {
+  adoptOrphanRingFiles,
+  createPacketWitness,
+  WITNESS_RING_BASENAME
+} from "../services/packet-witness.js";
+
+/**
+ * A stand-in for a spawned tcpdump: it records how it was called and stays
+ * "running" until something kills it.
+ */
+class FakeChild extends EventEmitter {
+  constructor(command, args) {
+    super();
+    this.command = command;
+    this.args = args;
+    this.killed = false;
+    this.signals = [];
+  }
+
+  kill(signal) {
+    this.signals.push(signal);
+    if (!this.killed) {
+      this.killed = true;
+      // A real child exits asynchronously, which is what the code must wait for.
+      setImmediate(() => this.emit("close", 0, signal));
+    }
+    return true;
+  }
+}
+
+/**
+ * @returns {{ spawnProcess: Function, children: FakeChild[], rings: FakeChild[] }}
+ */
+function makeSpawn() {
+  const children = [];
+  const spawnProcess = (command, args) => {
+    const child = new FakeChild(command, args);
+    children.push(child);
+    if (args.includes("--version")) {
+      // The availability probe: answer at once, like a present tcpdump.
+      setImmediate(() => child.emit("spawn"));
+    }
+    return child;
+  };
+  return {
+    spawnProcess,
+    children,
+    get rings() {
+      return children.filter((child) => !child.args.includes("--version"));
+    }
+  };
+}
+
+/**
+ * Wait until `check` holds, rather than for a chosen interval.
+ *
+ * A fixed sleep passes alone and fails in a full run — the defect roadmap item
+ * 51 names — and the work here is several awaits deep (probe, stop, readdir,
+ * copy, restart), so its duration is whatever the machine is busy with.
+ *
+ * @param {() => boolean | Promise<boolean>} check
+ * @param {string} what
+ * @returns {Promise<void>}
+ */
+async function waitFor(check, what) {
+  const deadline = Date.now() + 10_000;
+  for (;;) {
+    if (await check()) {
+      return;
+    }
+    if (Date.now() > deadline) {
+      throw new Error(`timed out waiting for ${what}`);
+    }
+    await new Promise((resolve) => setTimeout(resolve, 5));
+  }
+}
+
+/** Let every already-queued microtask and immediate run. */
+const settle = () => new Promise((resolve) => setTimeout(resolve, 20));
+
+async function withDir(run) {
+  const dir = await mkdtemp(path.join(os.tmpdir(), "witness-ring-"));
+  try {
+    await run(dir);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+}
+
+test("the ring runs while a channel is open and stops with the last one", async () => {
+  await withDir(async (dir) => {
+    const spawn = makeSpawn();
+    const witness = createPacketWitness({
+      log: () => {},
+      dir,
+      port: 9090,
+      spawnProcess: spawn.spawnProcess
+    });
+
+    witness.holdRing();
+    witness.holdRing();
+    await waitFor(() => spawn.rings.length === 1, "the ring to start");
+    assert.equal(spawn.rings.length, 1, "a second channel must not start a second ring");
+    assert.equal(spawn.rings[0].killed, false);
+
+    witness.releaseRing();
+    await settle();
+    assert.equal(spawn.rings[0].killed, false, "one channel left still wants the ring");
+
+    witness.releaseRing();
+    await waitFor(() => spawn.rings[0].killed, "the ring to stop");
+  });
+});
+
+test("a channel that opens and closes while the ring is starting leaves nothing running", async () => {
+  await withDir(async (dir) => {
+    const spawn = makeSpawn();
+    const witness = createPacketWitness({
+      log: () => {},
+      dir,
+      port: 9090,
+      spawnProcess: spawn.spawnProcess
+    });
+    // Release before the availability probe has resolved — the start is still
+    // in flight. Without the second look after the await this leaves a tcpdump
+    // nobody holds and nobody will ever stop.
+    witness.holdRing();
+    witness.releaseRing();
+    await waitFor(
+      () => spawn.rings.every((child) => child.killed),
+      "any ring started mid-flight to be stopped"
+    );
+    const alive = spawn.rings.filter((child) => !child.killed);
+    assert.deepEqual(alive, [], "no ring may outlive the channels that wanted it");
+  });
+});
+
+test("the ring's files are removed once nobody is being served", async () => {
+  await withDir(async (dir) => {
+    const spawn = makeSpawn();
+    const witness = createPacketWitness({
+      log: () => {},
+      dir,
+      port: 9090,
+      spawnProcess: spawn.spawnProcess
+    });
+    witness.holdRing();
+    await waitFor(() => spawn.rings.length === 1, "the ring to start");
+    await writeFile(path.join(dir, `${WITNESS_RING_BASENAME}0`), "pcap");
+    witness.releaseRing();
+    await waitFor(async () => (await readdir(dir)).length === 0, "the ring files to be removed");
+  });
+});
+
+test("a wedge keeps the ring's history, and the ring keeps recording afterwards", async () => {
+  await withDir(async (dir) => {
+    const spawn = makeSpawn();
+    const lines = [];
+    const witness = createPacketWitness({
+      log: (message) => lines.push(message),
+      dir,
+      port: 9090,
+      spawnProcess: spawn.spawnProcess
+    });
+    witness.holdRing();
+    await waitFor(() => spawn.rings.length === 1, "the ring to start");
+    await writeFile(path.join(dir, `${WITNESS_RING_BASENAME}0`), "before-the-freeze");
+    await writeFile(path.join(dir, `${WITNESS_RING_BASENAME}1`), "also-before");
+
+    const started = witness.maybeCapture({
+      sessionId: "68296f7d-0000-0000-0000-000000000000",
+      tag: "68296f7d",
+      label: "proxy",
+      remote: { address: "2001:db8::1", port: 61649 },
+      queuedBytes: 67_372_267,
+      stuckForMs: 4000
+    });
+    assert.equal(started, true);
+    await waitFor(
+      async () => (await readdir(dir)).filter((name) => name.includes(".before")).length === 2,
+      "both ring files to be copied aside"
+    );
+
+    const kept = (await readdir(dir)).filter((name) => name.includes(".before"));
+    assert.equal(kept.length, 2, "both ring files must be kept, not just the finished one");
+    assert.ok(kept.every((name) => name.startsWith("packet-witness.68296f7d.")));
+    // Stopped to flush, then started again: two ring processes over the episode.
+    await waitFor(() => spawn.rings.length >= 2, "the ring to resume after the copy");
+    assert.equal(spawn.rings.at(-1).killed, false);
+    assert.ok(lines.some((line) => line.includes("kept 2 ring file(s)")));
+
+    // End the tail capture: it would otherwise sit out its whole window, and
+    // its timer would hold this process open.
+    for (const child of spawn.children) {
+      child.kill("SIGTERM");
+    }
+    await settle();
+  });
+});
+
+test("dispose stops the ring and clears its files", async () => {
+  await withDir(async (dir) => {
+    const spawn = makeSpawn();
+    const witness = createPacketWitness({
+      log: () => {},
+      dir,
+      port: 9090,
+      spawnProcess: spawn.spawnProcess
+    });
+    witness.holdRing();
+    await waitFor(() => spawn.rings.length === 1, "the ring to start");
+    await writeFile(path.join(dir, `${WITNESS_RING_BASENAME}0`), "pcap");
+    await witness.dispose();
+    assert.equal(spawn.rings.at(-1).killed, true);
+    assert.deepEqual(await readdir(dir), []);
+  });
+});
+
+test("ring files left by a killed process are kept, not deleted by the next one", async () => {
+  await withDir(async (dir) => {
+    await writeFile(path.join(dir, `${WITNESS_RING_BASENAME}0`), "the seconds before the crash");
+    await writeFile(path.join(dir, `${WITNESS_RING_BASENAME}2`), "and these");
+    const adopted = await adoptOrphanRingFiles(dir);
+    assert.equal(adopted.length, 2);
+    const left = await readdir(dir);
+    assert.equal(left.filter((name) => name.startsWith(WITNESS_RING_BASENAME)).length, 0);
+    assert.ok(left.every((name) => name.startsWith("packet-witness.orphan.")));
+  });
+});

package/test/packet-witness.test.js

@@ -1,120 +1,148 @@
-/**
- * @file The packet witness's gating rules and command construction.
- *
- * Roadmap item 10: a send queue wedged longer than ~30 s must start a bounded
- * tcpdump on its own, because the 2026-08-24 episode proved no counter above
- * the wire can name the cause. Everything here is the part that decides WHEN
- * and WITH WHAT ARGUMENTS — the spawning itself is thin glue around these.
- */
-
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import {
-  buildTcpdumpArgs,
-  createPacketWitness,
-  isWitnessCapture,
-  normalizeRemoteAddress,
-  shouldStartCapture,
-  WITNESS_CAPTURE_SECONDS,
-  WITNESS_RING_FILES,
-  WITNESS_ROTATE_SECONDS
-} from "../services/packet-witness.js";
-
-test("an IPv4 literal survives unchanged", () => {
-  assert.equal(normalizeRemoteAddress("192.168.178.57"), "192.168.178.57");
-});
-
-test("an IPv6 literal survives unchanged", () => {
-  assert.equal(
-    normalizeRemoteAddress("2001:1c00:a603:2100:a129:a1a1:7f07:3f0b"),
-    "2001:1c00:a603:2100:a129:a1a1:7f07:3f0b"
-  );
-});
-
-test("a zone suffix is stripped", () => {
-  assert.equal(normalizeRemoteAddress("fe80::2aca:8001:3ba6:f16f%18"), "fe80::2aca:8001:3ba6:f16f");
-});
-
-test("hostnames, garbage and shell text are rejected", () => {
-  assert.equal(normalizeRemoteAddress("homeassistant.local"), null);
-  assert.equal(normalizeRemoteAddress("8.8.8.8; rm -rf /"), null);
-  assert.equal(normalizeRemoteAddress("999.1.1.1"), null);
-  assert.equal(normalizeRemoteAddress(""), null);
-  assert.equal(normalizeRemoteAddress(undefined), null);
-  assert.equal(normalizeRemoteAddress(42), null);
-});
-
-test("the tcpdump command line is bounded and filtered to one peer", () => {
-  const args = buildTcpdumpArgs({
-    host: "2001:db8::1",
-    port: 9090,
-    filePrefix: "/data/packet-witness.e2b5ef39.1787600000.pcap"
-  });
-  assert.deepEqual(args, [
-    "-n",
-    "-S",
-    "-s",
-    "128",
-    "-i",
-    "any",
-    "-w",
-    "/data/packet-witness.e2b5ef39.1787600000.pcap",
-    "-G",
-    String(WITNESS_ROTATE_SECONDS),
-    "-W",
-    String(WITNESS_RING_FILES),
-    "udp",
-    "and",
-    "host",
-    "2001:db8::1",
-    "and",
-    "port",
-    "9090"
-  ]);
-});
-
-test("the capture window is what the rotation ring adds up to", () => {
-  assert.equal(WITNESS_ROTATE_SECONDS * WITNESS_RING_FILES, WITNESS_CAPTURE_SECONDS);
-});
-
-test("one capture runs at a time", () => {
-  assert.equal(shouldStartCapture({ running: true, lastStartedAt: Date.now() }), false);
-});
-
-test("the first capture of a process is always allowed", () => {
-  assert.equal(shouldStartCapture({ running: false, lastStartedAt: 0, now: 1000 }), true);
-});
-
-test("a capture within the cooldown is refused, one after it is allowed", () => {
-  const state = { running: false, lastStartedAt: 10_000 };
-  assert.equal(shouldStartCapture({ ...state, now: 10_000 + 599_999 }), false);
-  assert.equal(shouldStartCapture({ ...state, now: 10_000 + 600_000 }), true);
-});
-
-test("capture files are recognised by name, rotations included", () => {
-  assert.equal(isWitnessCapture("packet-witness.e2b5ef39.1787600000.pcap"), true);
-  assert.equal(isWitnessCapture("packet-witness.e2b5ef39.1787600000.pcap20260825T120000"), true);
-  assert.equal(isWitnessCapture("core.WorkerThread.81.1787600000"), false);
-  assert.equal(isWitnessCapture("proxy.log"), false);
-  assert.equal(isWitnessCapture("../packet-witness.x.pcap"), false);
-});
-
-test("a trigger without a usable remote endpoint is refused without touching anything", () => {
-  const lines = [];
-  const witness = createPacketWitness({
-    log: (message) => lines.push(message),
-    dir: "",
-    port: 9090
-  });
-  const started = witness.maybeCapture({
-    sessionId: "e2b5ef39-0000",
-    tag: "e2b5ef39",
-    label: "proxy",
-    remote: null,
-    queuedBytes: 160_000_000,
-    stuckForMs: 31_000
-  });
-  assert.equal(started, false);
-  assert.deepEqual(lines, []);
-});
+/**
+ * @file The packet witness's gating rules and command construction.
+ *
+ * Roadmap item 10: a send queue wedged longer than ~30 s must start a bounded
+ * tcpdump on its own, because the 2026-08-24 episode proved no counter above
+ * the wire can name the cause. Everything here is the part that decides WHEN
+ * and WITH WHAT ARGUMENTS — the spawning itself is thin glue around these.
+ */
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  buildTcpdumpArgs,
+  createPacketWitness,
+  isWitnessCapture,
+  isWitnessRingFile,
+  normalizeRemoteAddress,
+  shouldStartCapture,
+  WITNESS_RING_FILE_MB,
+  WITNESS_RING_FILES,
+  WITNESS_RTO_CEILING_SECONDS,
+  WITNESS_TAIL_SECONDS
+} from "../services/packet-witness.js";
+
+test("an IPv4 literal survives unchanged", () => {
+  assert.equal(normalizeRemoteAddress("192.168.178.57"), "192.168.178.57");
+});
+
+test("an IPv6 literal survives unchanged", () => {
+  assert.equal(
+    normalizeRemoteAddress("2001:1c00:a603:2100:a129:a1a1:7f07:3f0b"),
+    "2001:1c00:a603:2100:a129:a1a1:7f07:3f0b"
+  );
+});
+
+test("a zone suffix is stripped", () => {
+  assert.equal(normalizeRemoteAddress("fe80::2aca:8001:3ba6:f16f%18"), "fe80::2aca:8001:3ba6:f16f");
+});
+
+test("hostnames, garbage and shell text are rejected", () => {
+  assert.equal(normalizeRemoteAddress("homeassistant.local"), null);
+  assert.equal(normalizeRemoteAddress("8.8.8.8; rm -rf /"), null);
+  assert.equal(normalizeRemoteAddress("999.1.1.1"), null);
+  assert.equal(normalizeRemoteAddress(""), null);
+  assert.equal(normalizeRemoteAddress(undefined), null);
+  assert.equal(normalizeRemoteAddress(42), null);
+});
+
+test("the tcpdump command line is bounded and filtered to one peer", () => {
+  const args = buildTcpdumpArgs({
+    host: "2001:db8::1",
+    port: 9090,
+    filePrefix: "/data/packet-witness.e2b5ef39.1787600000.pcap"
+  });
+  assert.deepEqual(args, [
+    "-n",
+    "-S",
+    "-s",
+    "128",
+    "-i",
+    "any",
+    "-w",
+    "/data/packet-witness.e2b5ef39.1787600000.pcap",
+    "-C",
+    String(WITNESS_RING_FILE_MB),
+    "-W",
+    String(WITNESS_RING_FILES),
+    "udp",
+    "and",
+    "port",
+    "9090",
+    "and",
+    "host",
+    "2001:db8::1"
+  ]);
+});
+
+test("rotation is by size, so the ring files cannot collapse onto one name", () => {
+  // `-G` with a name carrying no strftime field overwrote a single file, which
+  // is why both field captures held 28 s instead of the intended 120.
+  const args = buildTcpdumpArgs({ port: 9090, filePrefix: "/data/ring.pcap" });
+  assert.equal(args.includes("-G"), false);
+  assert.equal(args[args.indexOf("-C") + 1], String(WITNESS_RING_FILE_MB));
+});
+
+test("with no peer named the ring records every peer on the port", () => {
+  const args = buildTcpdumpArgs({ port: 9090, filePrefix: "/data/ring.pcap" });
+  assert.equal(args.includes("host"), false);
+  assert.deepEqual(args.slice(-4), ["udp", "and", "port", "9090"]);
+});
+
+test("the tail outlasts three retransmission timeouts", () => {
+  assert.equal(WITNESS_TAIL_SECONDS, WITNESS_RTO_CEILING_SECONDS * 3);
+  // A zero-window probe is due once per timeout, so a window shorter than the
+  // ceiling could not tell silence from a probe that had not come round yet.
+  assert.ok(WITNESS_TAIL_SECONDS > WITNESS_RTO_CEILING_SECONDS);
+});
+
+test("ring files are told apart from the copies kept as evidence", () => {
+  assert.equal(isWitnessRingFile("packet-witness-ring.pcap"), true);
+  assert.equal(isWitnessRingFile("packet-witness-ring.pcap3"), true);
+  assert.equal(isWitnessRingFile("packet-witness.e2b5ef39.1787600000.before1.pcap"), false);
+  assert.equal(isWitnessCapture("packet-witness-ring.pcap3"), false);
+  assert.equal(isWitnessCapture("packet-witness.e2b5ef39.1787600000.before1.pcap"), true);
+  assert.equal(isWitnessCapture("packet-witness.e2b5ef39.1787600000.tail.pcap1"), true);
+});
+
+test("one capture runs at a time", () => {
+  assert.equal(shouldStartCapture({ running: true, lastStartedAt: Date.now() }), false);
+});
+
+test("the first capture of a process is always allowed", () => {
+  assert.equal(shouldStartCapture({ running: false, lastStartedAt: 0, now: 1000 }), true);
+});
+
+test("a capture within the cooldown is refused, one after it is allowed", () => {
+  const state = { running: false, lastStartedAt: 10_000 };
+  assert.equal(shouldStartCapture({ ...state, now: 10_000 + 599_999 }), false);
+  assert.equal(shouldStartCapture({ ...state, now: 10_000 + 600_000 }), true);
+});
+
+test("capture files are recognised by name, rotations included", () => {
+  assert.equal(isWitnessCapture("packet-witness.e2b5ef39.1787600000.pcap"), true);
+  assert.equal(isWitnessCapture("packet-witness.e2b5ef39.1787600000.pcap20260825T120000"), true);
+  assert.equal(isWitnessCapture("core.WorkerThread.81.1787600000"), false);
+  assert.equal(isWitnessCapture("proxy.log"), false);
+  assert.equal(isWitnessCapture("../packet-witness.x.pcap"), false);
+});
+
+test("a trigger without a usable remote endpoint is refused without touching anything", () => {
+  const lines = [];
+  const witness = createPacketWitness({
+    log: (message) => lines.push(message),
+    dir: "",
+    port: 9090
+  });
+  const started = witness.maybeCapture({
+    sessionId: "e2b5ef39-0000",
+    tag: "e2b5ef39",
+    label: "proxy",
+    remote: null,
+    queuedBytes: 160_000_000,
+    stuckForMs: 31_000
+  });
+  assert.equal(started, false);
+  assert.deepEqual(lines, []);
+});