@torrent-tv/proxy 2.81.2 → 2.83.0

package/services/torrent-pool.js

@@ -8,6 +8,7 @@
  * download.
  */
 
+import { IDLE_KEEP_MS } from "./disk/keep.js";
 import dns from "node:dns/promises";
 import os from "node:os";
 import path from "node:path";
@@ -61,13 +62,13 @@ const DHT_RESOLVE_TIMEOUT_MS = 2000;
 // torrent data lives under here.
 const WEBTORRENT_STORE_ROOT = path.join(os.tmpdir(), "webtorrent");
 
-// How long a torrent may sit with zero active file readers before it is
-// removed (with its on-disk store). Generous so brief gaps between ffmpeg
-// range reads — a pause, a backgrounded tab, or a phone turned off for a few
-// minutes — do not evict an in-use torrent's already-downloaded data, so a
-// resume plays from disk instead of re-downloading. A longer idle (viewer truly
-// gone) frees the disk; the global disk cap still evicts earlier under pressure.
-const TORRENT_IDLE_TTL_MS = 15 * 60 * 1000;
+// How long a torrent may sit with zero active file readers before it is removed
+// with its on-disk store. ONE NUMBER for everything nobody is using, shared with
+// the produced segments — see `services/disk/keep.js` for why it is one and what
+// it stands for. It was fifteen minutes here against thirty for the session it
+// feeds, so a viewer returning at the twentieth minute got a session whose source
+// had gone.
+const TORRENT_IDLE_TTL_MS = IDLE_KEEP_MS;
 
 // Bytes ahead of a read position to mark CRITICAL on each range request. In
 // WebTorrent, `critical` does NOT reorder the sequential piece scan — it enables

package/test/keeping-period.test.js

@@ -0,0 +1,83 @@
+/**
+ * @file How long material nobody is using is kept, and where that number comes
+ * from.
+ *
+ * It was three numbers and they contradicted each other: a torrent went at
+ * fifteen minutes while the session it feeds lived to thirty, so between them
+ * there was a session with no source. All three stand for one unmeasured thing
+ * — whether the viewer comes back — so they are one number now, and the thing
+ * they stand for is being measured.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { IDLE_KEEP_MS } from "../services/disk/keep.js";
+import { Returns } from "../services/disk/returns.js";
+
+const MINUTE = 60 * 1000;
+
+test("material outlives the session that reads it", () => {
+  // The contradiction this replaced, stated as the rule it must never break
+  // again: whatever holds a source must not go while something that reads it
+  // is still alive. The session's own period is thirty minutes.
+  const SESSION_TTL_MS = 30 * MINUTE;
+  assert.ok(
+    IDLE_KEEP_MS > SESSION_TTL_MS,
+    "a session would outlive its own source again: material is kept " +
+      `${IDLE_KEEP_MS / MINUTE}min against a session's ${SESSION_TTL_MS / MINUTE}min`
+  );
+});
+
+test("one number, and both kinds of material read it", async () => {
+  // Two guesses about one unknown is what produced the contradiction. Asserted
+  // on the source: a second literal period appearing anywhere is the fault
+  // coming back.
+  const { readFileSync } = await import("node:fs");
+  const path = await import("node:path");
+  const { fileURLToPath } = await import("node:url");
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  const read = (relative) => readFileSync(path.join(here, "..", relative), "utf8");
+
+  assert.match(read("services/torrent-pool.js"), /TORRENT_IDLE_TTL_MS = IDLE_KEEP_MS/);
+  assert.match(read("services/hls-session-manager.js"), /SEGMENT_STORE_IDLE_MS = IDLE_KEEP_MS/);
+});
+
+test("a session opened on material still held is a return, and its age is kept", () => {
+  const returns = new Returns();
+  const now = 10 * 60 * MINUTE;
+
+  returns.note({ lastReadAt: now - 5 * MINUTE, now });
+  returns.note({ lastReadAt: now - 45 * MINUTE, now });
+  returns.note({ lastReadAt: now - 20 * MINUTE, now });
+
+  const shape = returns.shape();
+  assert.equal(shape.warm, 3);
+  assert.equal(shape.cold, 0);
+  assert.equal(shape.medianMs, 20 * MINUTE, "the middle return is not the median");
+  assert.equal(shape.longestMs, 45 * MINUTE);
+});
+
+test("a session opened on material this proxy never had is not a return", () => {
+  const returns = new Returns();
+  const now = 10 * 60 * MINUTE;
+
+  returns.note({ lastReadAt: null, now });
+  returns.note({ lastReadAt: 0, now });
+
+  assert.equal(returns.shape(), null, "an opening with nothing behind it was counted as a return");
+});
+
+test("the reading says what viewers do beside what is being kept", () => {
+  const returns = new Returns();
+  const now = 10 * 60 * MINUTE;
+  assert.equal(returns.describe(IDLE_KEEP_MS), null, "it spoke before it had anything to say");
+
+  returns.note({ lastReadAt: now - 12 * MINUTE, now });
+  returns.note({ lastReadAt: null, now });
+
+  const line = returns.describe(IDLE_KEEP_MS);
+  assert.match(line, /1 session\(s\) opened on material still held/);
+  assert.match(line, /1 on material gone/);
+  assert.match(line, /median 12min after the last read/);
+  assert.match(line, /kept for 60min/);
+});

package/test/piece-disk-store.test.js

@@ -265,3 +265,91 @@ test("the spill ceiling is what the disk's owner said, divided between the store
     await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
   }
 });
+
+test("what lies behind every reader goes without waiting for the disk to be short", async () => {
+  // THE SECOND RULE. The ceiling is a share of free space, and on a roomy host
+  // that is tens of gigabytes against a measured growth of 14 400 MB in one
+  // viewing — so the ceiling alone never binds and nothing is removed until the
+  // torrent itself goes. A piece behind every read head has been read.
+  const { store, directory } = await makeStore(1000 * PIECE);
+  try {
+    for (const index of [0, 1, 2, 3, 4, 5]) {
+      await store.write(index, pieceOf(index));
+    }
+
+    const removed = store.forgetBehind([3, 4]);
+    await store.settled();
+
+    assert.equal(removed, 3, "the three behind the earliest reader should have gone");
+    assert.deepEqual([0, 1, 2].map((index) => store.has(index)), [false, false, false]);
+    assert.deepEqual([3, 4, 5].map((index) => store.has(index)), [true, true, true]);
+    assert.equal(store.stats().behind, 3);
+  } finally {
+    await store.destroy();
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
+  }
+});
+
+test("with no reader at all, nothing is thrown away", async () => {
+  // A store between reads is not a store nobody wants. What empties it whole is
+  // the torrent going idle, which removes the store and its directory.
+  const { store, directory } = await makeStore(1000 * PIECE);
+  try {
+    for (const index of [0, 1, 2]) {
+      await store.write(index, pieceOf(index));
+    }
+    assert.equal(store.forgetBehind([]), 0);
+    assert.equal(store.size, 3);
+  } finally {
+    await store.destroy();
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
+  }
+});
+
+test("a piece being read is not taken even when it is behind everybody", async () => {
+  const { store, directory } = await makeStore(1000 * PIECE);
+  try {
+    await store.write(0, pieceOf(0));
+    await store.write(5, pieceOf(5));
+    const reading = store.read(0, Buffer.alloc(PIECE));
+    const removed = store.forgetBehind([5]);
+    await reading;
+    await store.settled();
+
+    assert.equal(removed, 0, "a piece under a reader was thrown away");
+    assert.equal(store.has(0), true);
+  } finally {
+    await store.destroy();
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
+  }
+});
+
+test("when there is no room, what is behind the readers goes before what is ahead", async () => {
+  const directory = await fs.mkdtemp(path.join(os.tmpdir(), "piece-disk-heads-"));
+  const clock = { at: 1000 };
+  // The reader stands on #5. #4 is behind it and was touched LAST, so under the
+  // old rule — least recently used — it would have been the safest piece there.
+  const store = new PieceDiskStore({
+    directory,
+    name: "pieces",
+    chunkLength: PIECE,
+    allowanceBytes: 3 * PIECE,
+    now: () => clock.at,
+    readHeads: () => [5]
+  });
+  try {
+    for (const index of [8, 7, 4]) {
+      clock.at += 100;
+      await store.write(index, pieceOf(index));
+    }
+    clock.at += 100;
+    await store.write(9, pieceOf(9));
+    await store.settled();
+
+    assert.equal(store.has(4), false, "the piece behind the reader was kept because it was touched last");
+    assert.deepEqual([7, 8, 9].map((index) => store.has(index)), [true, true, true]);
+  } finally {
+    await store.destroy();
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
+  }
+});

package/test/startup-readings.test.js

@@ -0,0 +1,119 @@
+/**
+ * @file What this host must have measured before the first viewer arrives.
+ *
+ * The quality offer, the number of encoders and every decision about moving one
+ * are arithmetic over four figures: how fast this host encodes, how fast it
+ * decodes, what a second job costs it, and what starting and stopping an
+ * encoder cost. A figure nobody measured is reported as zero, and zero does not
+ * read as "unknown" — it reads as "free" or "instant", and the arithmetic then
+ * answers confidently and wrongly.
+ *
+ * Two gaps this pins, both found 2026-09-10:
+ *
+ * 1. three of the four ran only when the chosen encoder was SOFTWARE, and two
+ *    of those three are not about the encoder at all — a host with a GPU
+ *    decodes in software just the same, and what a second job costs is a
+ *    property of the machine. A GPU host measured none of them;
+ * 2. starting and stopping were learned only from runs that had already ENDED,
+ *    so at a cold open both were zero and moving an encoder was free. Field
+ *    2026-09-08: an encoder moved between two adjacent numbers every half
+ *    second and produced nothing.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { SoftwareEncoder } from "../services/encode/SoftwareEncoder.js";
+import { NvencEncoder } from "../services/encode/NvencEncoder.js";
+import { QsvEncoder } from "../services/encode/QsvEncoder.js";
+import { VaapiEncoder } from "../services/encode/VaapiEncoder.js";
+import { V4l2m2mEncoder } from "../services/encode/V4l2m2mEncoder.js";
+import { RunCosts } from "../services/encode/run-costs.js";
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+
+test("every encoder kind can say how to measure itself", () => {
+  const kinds = [
+    new SoftwareEncoder(),
+    new NvencEncoder(),
+    new QsvEncoder(),
+    new VaapiEncoder("/dev/dri/renderD128"),
+    new V4l2m2mEncoder()
+  ];
+  for (const encoder of kinds) {
+    const args = encoder.benchmarkArgs(null);
+    assert.ok(Array.isArray(args) && args.length >= 2, `${encoder.name} says nothing`);
+    assert.ok(args.includes("-c:v"), `${encoder.name} does not name a codec`);
+    assert.ok(
+      args.some((arg) => String(arg).includes(encoder.name)),
+      `${encoder.name} does not name itself`
+    );
+  }
+});
+
+test("a kind with a ladder is measured at every rung of it", () => {
+  for (const encoder of [new SoftwareEncoder(), new NvencEncoder(), new QsvEncoder()]) {
+    const ladder = encoder.speedLadder;
+    assert.ok(ladder.values.length > 1, `${encoder.name} declares no ladder to walk`);
+    const rungs = ladder.values.map((rung) => encoder.benchmarkArgs(rung).join(" "));
+    assert.equal(new Set(rungs).size, ladder.values.length, `${encoder.name} gives the same arguments for different rungs`);
+  }
+});
+
+test("nothing about the machine is asked only of a software encoder", () => {
+  // Decoding and contention are properties of the host. Asked only where the
+  // encoder was software, a host with a GPU had neither, and the quality offer
+  // could not price a re-encode nor a second process.
+  const server = readFileSync(path.join(HERE, "..", "server.js"), "utf8");
+  for (const call of ["benchmarkDecodeCost", "benchmarkContention"]) {
+    const at = server.indexOf(call);
+    assert.ok(at > 0, `${call} is not called at startup at all`);
+    const before = server.slice(Math.max(0, at - 200), at);
+    assert.equal(
+      before.includes('kind === "software"'),
+      false,
+      `${call} is still gated on the encoder being software`
+    );
+  }
+});
+
+test("the throughput benchmark is given the encoder that will actually run", () => {
+  const server = readFileSync(path.join(HERE, "..", "server.js"), "utf8");
+  assert.match(
+    server,
+    /benchmarkSoftwarePresets\(\{[^}]*encoder: videoEncoder/,
+    "the benchmark is not told which encoder to measure"
+  );
+});
+
+test("a start and a stop are measured before any viewer, and reach the plan", () => {
+  const server = readFileSync(path.join(HERE, "..", "server.js"), "utf8");
+  assert.match(server, /await measureStartAndStop\(/, "nothing measures a start at startup");
+  assert.match(server, /\n    startStopCost,/, "the reading never reaches the session manager");
+
+  const manager = readFileSync(path.join(HERE, "..", "services", "hls-session-manager.js"), "utf8");
+  assert.match(
+    manager,
+    /noteStartupCosts\(startStopCost\)/,
+    "the reading never reaches the encoding orchestrator"
+  );
+});
+
+test("with a startup reading, a cold plan is not told that starting is free", () => {
+  const costs = new RunCosts();
+  assert.equal(costs.seconds().firstByteWaitSec, 0, "nothing measured yet is nothing");
+
+  costs.noteStartup({ firstByteWaitSec: 0.68, killCostSec: 0.02 });
+  const cold = costs.seconds();
+  assert.equal(cold.firstByteWaitSec, 0.68, "the startup reading is not used");
+  assert.equal(cold.killCostSec, 0.02);
+
+  // A real run replaces it: the startup figure is where the plan starts from,
+  // not where it stays.
+  costs.note({ firstOutputMs: 4000, dyingMs: 300 });
+  const warm = costs.seconds();
+  assert.equal(warm.firstByteWaitSec, 4);
+  assert.equal(warm.killCostSec, 0.3);
+});