@torrent-tv/proxy 2.9.74 → 2.9.76

package/services/torrent-worker/pool-adapter.js

@@ -1,179 +1,179 @@
-/**
- * @file `TorrentPool`'s interface, served from the worker thread.
- *
- * The routes, the planner, the health report and the session manager all reach
- * for a torrent pool and use it the same handful of ways. Rather than rewrite
- * every one of them to thread a `sourceKey` through and await what used to be
- * immediate, this presents the shape they already expect and does the thread
- * hop behind it. Swapping the implementation is then a one-line change at
- * construction, and the call sites are untouched — which is what keeps a change
- * of this size reviewable.
- *
- * Two accommodations are needed, and both are deliberate:
- *
- *  - **`acquireFile` and `prioritizeByteRange` stay synchronous.** They return
- *    nothing the caller inspects, so the command is dispatched and not awaited.
- *    `acquireFile` hands back a release function exactly as before, which sends
- *    its own command when called. Awaiting them would mean touching every call
- *    site for no observable gain.
- *  - **`getTorrent` needs a `sourceKey`.** Torrent objects cannot cross a
- *    thread, so the worker keys them. Callers that have one pass it; the rest
- *    get one derived from the source itself, so the identity stays stable
- *    across calls for the same torrent.
- */
-
-import crypto from "node:crypto";
-import { TorrentWorkerClient } from "./client.js";
-
-/**
- * Stable key for a source, matching how the worker keys its torrents.
- *
- * Derived from the source itself rather than handed out per request, so two
- * routes asking for the same torrent name the same thing on the worker side.
- *
- * @param {"magnet" | "torrent"} sourceType
- * @param {string} source
- * @returns {string}
- */
-function deriveSourceKey(sourceType, source) {
-  return `${sourceType}:${crypto.createHash("sha1").update(source).digest("hex")}`;
-}
-
-/**
- * A torrent pool whose work happens on another thread.
- *
- * See `protocol.js` for why: the torrent was taking ~85% of the main thread and
- * everything owed to a viewer queued behind it.
- */
-export class WorkerTorrentPool {
-  #client;
-  /** Stand-ins by source key, so repeat calls return the same object. */
-  #torrents = new Map();
-
-  /**
-   * @param {{ maxDiskBytes?: number }} [options]
-   */
-  constructor(options = {}) {
-    this.#client = new TorrentWorkerClient(options);
-  }
-
-  /**
-   * Load (or join) a torrent and return a stand-in for it.
-   *
-   * @param {"magnet" | "torrent"} sourceType
-   * @param {string} source
-   * @returns {Promise<object>}
-   */
-  async getTorrent(sourceType, source) {
-    const sourceKey = deriveSourceKey(sourceType, source);
-    const existing = this.#torrents.get(sourceKey);
-    if (existing) {
-      return existing;
-    }
-    const torrent = await this.#client.getTorrent({ sourceKey, sourceType, source });
-    this.#torrents.set(sourceKey, torrent);
-    return torrent;
-  }
-
-  /**
-   * Claim a file for reading; the returned function releases it.
-   *
-   * Synchronous by design — see the file header.
-   *
-   * @param {object} torrent - A stand-in from {@link getTorrent}.
-   * @param {number} fileIndex
-   * @returns {() => void}
-   */
-  acquireFile(torrent, fileIndex) {
-    const sourceKey = torrent?.sourceKey;
-    if (!sourceKey) {
-      return () => undefined;
-    }
-    // Dispatched, not awaited — callers use the result immediately and inspect
-    // nothing. But the release MUST NOT overtake it: both are ordinary messages
-    // to the worker, and if release arrives first the reader count drops to zero
-    // while a read is still running. The idle sweep then removes the torrent AND
-    // its downloaded data out from under the encoder — field 2026-08-02:
-    // "removed idle torrent ... and its store" mid-playback, after which every
-    // read hung and ffmpeg saw an empty input ("Stream ends prematurely at 0").
-    // Chaining the release onto the acquire keeps them in order.
-    const acquired = this.#client.acquireFile(sourceKey, fileIndex).catch(() => undefined);
-    let released = false;
-    return () => {
-      if (released) {
-        return;
-      }
-      released = true;
-      void acquired.then(() => this.#client.releaseFile(sourceKey, fileIndex)).catch(() => undefined);
-    };
-  }
-
-  /**
-   * Live download figures for the progress display.
-   *
-   * @param {object} torrent
-   * @param {number | null} [fileIndex]
-   * @param {{ resumeAnchorByteStart?: number | null }} [options]
-   * @returns {Promise<object | null>}
-   */
-  async getFileStats(torrent, fileIndex = null, options = {}) {
-    const sourceKey = torrent?.sourceKey;
-    if (!sourceKey) {
-      return null;
-    }
-    return this.#client.getFileStats({
-      sourceKey,
-      fileIndex,
-      resumeAnchorByteStart: options?.resumeAnchorByteStart ?? null
-    });
-  }
-
-  /**
-   * Reorder piece selection around a read position.
-   *
-   * Synchronous by design — see the file header.
-   *
-   * @param {object} torrent
-   * @param {number} fileIndex
-   * @param {number} byteStart
-   * @param {number} [windowBytes]
-   * @returns {void}
-   */
-  prioritizeByteRange(torrent, fileIndex, byteStart, windowBytes) {
-    const sourceKey = torrent?.sourceKey;
-    if (!sourceKey) {
-      return;
-    }
-    void this.#client
-      .prioritizeByteRange({ sourceKey, fileIndex, byteStart, windowBytes })
-      .catch(() => undefined);
-  }
-
-  /**
-   * Pre-fetch the head and tail the codec probe needs.
-   *
-   * @param {object} torrent
-   * @param {number} fileIndex
-   * @param {number} [headBytes]
-   * @param {number} [tailBytes]
-   * @param {number} [timeoutMs]
-   * @returns {Promise<unknown>}
-   */
-  async prefetchFileEdges(torrent, fileIndex, headBytes, tailBytes, timeoutMs) {
-    const sourceKey = torrent?.sourceKey;
-    if (!sourceKey) {
-      return null;
-    }
-    return this.#client.prefetchFileEdges({ sourceKey, fileIndex, headBytes, tailBytes, timeoutMs });
-  }
-
-  /**
-   * Shut the torrent client down and stop the thread.
-   *
-   * @returns {Promise<void>}
-   */
-  async destroyAll() {
-    this.#torrents.clear();
-    await this.#client.destroyAll();
-  }
-}
+/**
+ * @file `TorrentPool`'s interface, served from the worker thread.
+ *
+ * The routes, the planner, the health report and the session manager all reach
+ * for a torrent pool and use it the same handful of ways. Rather than rewrite
+ * every one of them to thread a `sourceKey` through and await what used to be
+ * immediate, this presents the shape they already expect and does the thread
+ * hop behind it. Swapping the implementation is then a one-line change at
+ * construction, and the call sites are untouched — which is what keeps a change
+ * of this size reviewable.
+ *
+ * Two accommodations are needed, and both are deliberate:
+ *
+ *  - **`acquireFile` and `prioritizeByteRange` stay synchronous.** They return
+ *    nothing the caller inspects, so the command is dispatched and not awaited.
+ *    `acquireFile` hands back a release function exactly as before, which sends
+ *    its own command when called. Awaiting them would mean touching every call
+ *    site for no observable gain.
+ *  - **`getTorrent` needs a `sourceKey`.** Torrent objects cannot cross a
+ *    thread, so the worker keys them. Callers that have one pass it; the rest
+ *    get one derived from the source itself, so the identity stays stable
+ *    across calls for the same torrent.
+ */
+
+import crypto from "node:crypto";
+import { TorrentWorkerClient } from "./client.js";
+
+/**
+ * Stable key for a source, matching how the worker keys its torrents.
+ *
+ * Derived from the source itself rather than handed out per request, so two
+ * routes asking for the same torrent name the same thing on the worker side.
+ *
+ * @param {"magnet" | "torrent"} sourceType
+ * @param {string} source
+ * @returns {string}
+ */
+function deriveSourceKey(sourceType, source) {
+  return `${sourceType}:${crypto.createHash("sha1").update(source).digest("hex")}`;
+}
+
+/**
+ * A torrent pool whose work happens on another thread.
+ *
+ * See `protocol.js` for why: the torrent was taking ~85% of the main thread and
+ * everything owed to a viewer queued behind it.
+ */
+export class WorkerTorrentPool {
+  #client;
+  /** Stand-ins by source key, so repeat calls return the same object. */
+  #torrents = new Map();
+
+  /**
+   * @param {{ maxDiskBytes?: number, memoryBytes?: number }} [options]
+   */
+  constructor(options = {}) {
+    this.#client = new TorrentWorkerClient(options);
+  }
+
+  /**
+   * Load (or join) a torrent and return a stand-in for it.
+   *
+   * @param {"magnet" | "torrent"} sourceType
+   * @param {string} source
+   * @returns {Promise<object>}
+   */
+  async getTorrent(sourceType, source) {
+    const sourceKey = deriveSourceKey(sourceType, source);
+    const existing = this.#torrents.get(sourceKey);
+    if (existing) {
+      return existing;
+    }
+    const torrent = await this.#client.getTorrent({ sourceKey, sourceType, source });
+    this.#torrents.set(sourceKey, torrent);
+    return torrent;
+  }
+
+  /**
+   * Claim a file for reading; the returned function releases it.
+   *
+   * Synchronous by design — see the file header.
+   *
+   * @param {object} torrent - A stand-in from {@link getTorrent}.
+   * @param {number} fileIndex
+   * @returns {() => void}
+   */
+  acquireFile(torrent, fileIndex) {
+    const sourceKey = torrent?.sourceKey;
+    if (!sourceKey) {
+      return () => undefined;
+    }
+    // Dispatched, not awaited — callers use the result immediately and inspect
+    // nothing. But the release MUST NOT overtake it: both are ordinary messages
+    // to the worker, and if release arrives first the reader count drops to zero
+    // while a read is still running. The idle sweep then removes the torrent AND
+    // its downloaded data out from under the encoder — field 2026-08-02:
+    // "removed idle torrent ... and its store" mid-playback, after which every
+    // read hung and ffmpeg saw an empty input ("Stream ends prematurely at 0").
+    // Chaining the release onto the acquire keeps them in order.
+    const acquired = this.#client.acquireFile(sourceKey, fileIndex).catch(() => undefined);
+    let released = false;
+    return () => {
+      if (released) {
+        return;
+      }
+      released = true;
+      void acquired.then(() => this.#client.releaseFile(sourceKey, fileIndex)).catch(() => undefined);
+    };
+  }
+
+  /**
+   * Live download figures for the progress display.
+   *
+   * @param {object} torrent
+   * @param {number | null} [fileIndex]
+   * @param {{ resumeAnchorByteStart?: number | null }} [options]
+   * @returns {Promise<object | null>}
+   */
+  async getFileStats(torrent, fileIndex = null, options = {}) {
+    const sourceKey = torrent?.sourceKey;
+    if (!sourceKey) {
+      return null;
+    }
+    return this.#client.getFileStats({
+      sourceKey,
+      fileIndex,
+      resumeAnchorByteStart: options?.resumeAnchorByteStart ?? null
+    });
+  }
+
+  /**
+   * Reorder piece selection around a read position.
+   *
+   * Synchronous by design — see the file header.
+   *
+   * @param {object} torrent
+   * @param {number} fileIndex
+   * @param {number} byteStart
+   * @param {number} [windowBytes]
+   * @returns {void}
+   */
+  prioritizeByteRange(torrent, fileIndex, byteStart, windowBytes) {
+    const sourceKey = torrent?.sourceKey;
+    if (!sourceKey) {
+      return;
+    }
+    void this.#client
+      .prioritizeByteRange({ sourceKey, fileIndex, byteStart, windowBytes })
+      .catch(() => undefined);
+  }
+
+  /**
+   * Pre-fetch the head and tail the codec probe needs.
+   *
+   * @param {object} torrent
+   * @param {number} fileIndex
+   * @param {number} [headBytes]
+   * @param {number} [tailBytes]
+   * @param {number} [timeoutMs]
+   * @returns {Promise<unknown>}
+   */
+  async prefetchFileEdges(torrent, fileIndex, headBytes, tailBytes, timeoutMs) {
+    const sourceKey = torrent?.sourceKey;
+    if (!sourceKey) {
+      return null;
+    }
+    return this.#client.prefetchFileEdges({ sourceKey, fileIndex, headBytes, tailBytes, timeoutMs });
+  }
+
+  /**
+   * Shut the torrent client down and stop the thread.
+   *
+   * @returns {Promise<void>}
+   */
+  async destroyAll() {
+    this.#torrents.clear();
+    await this.#client.destroyAll();
+  }
+}

package/services/torrent-worker/worker.js

@@ -32,8 +32,12 @@ import { Command, Event, STREAM_CHUNK_BYTES } from "./protocol.js";
 // the hook above had a chance to register. Verified the hard way: with a static
 // import the process still aborted, and the stack named the genuine polyfill.
 const { TorrentPool } = await import("../torrent-pool.js");
+const { collectStoreStats } = await import("../piece-store/shared-piece-store.js");
 
-const pool = new TorrentPool({ maxDiskBytes: workerData?.maxDiskBytes });
+const pool = new TorrentPool({
+  maxDiskBytes: workerData?.maxDiskBytes,
+  memoryBytes: workerData?.memoryBytes
+});
 
 /** Torrents by sourceKey — the main thread names them, this thread owns them. */
 const torrentsByKey = new Map();
@@ -122,6 +126,7 @@ async function streamRange({ id, sourceKey, fileIndex, start, end }) {
     await sender.send(merged);
   };
 
+  let failed = false;
   try {
     for await (const part of source) {
       if (sender.isCancelled()) {
@@ -136,10 +141,20 @@ async function streamRange({ id, sourceKey, fileIndex, start, end }) {
     if (!sender.isCancelled()) {
       await flush();
     }
+  } catch (error) {
+    // The end-of-read marker means "the body is complete". Sending it after a
+    // failure told the reader the file simply ended — a truncated segment that
+    // ffmpeg reported as `Stream ends prematurely`, with the real cause thrown
+    // away. Let the error propagate instead; the command handler reports it and
+    // the main thread fails the stream.
+    failed = true;
+    throw error;
   } finally {
     readsById.delete(id);
     releaseRead();
-    sender.end();
+    if (!failed) {
+      sender.end();
+    }
     // A cancelled read must stop the underlying torrent stream too, or the
     // pieces keep being fetched for a viewer who has gone.
     if (typeof source.destroy === "function") {
@@ -273,4 +288,36 @@ parentPort.on("message", async (message) => {
   }
 });
 
+/**
+ * How often the piece store reports what it has been doing.
+ *
+ * The store decides whether a read costs nothing or costs a disk trip, and
+ * until 2.9.75 nothing about it reached the log — a field oddity would have had
+ * no evidence to work from. Reported only when something changed, so an idle
+ * proxy stays quiet.
+ */
+const STORE_REPORT_INTERVAL_MS = 60_000;
+
+/** Last reported figures per store, so unchanged ones stay silent. */
+const lastReported = new Map();
+
+setInterval(() => {
+  for (const stats of collectStoreStats()) {
+    const signature = `${stats.fromMemory}/${stats.fromDisk}/${stats.spills}/${stats.revivals}/${stats.blockedByPins}`;
+    if (lastReported.get(stats.name) === signature) {
+      continue;
+    }
+    lastReported.set(stats.name, signature);
+
+    const reads = stats.fromMemory + stats.fromDisk;
+    const fromMemoryShare = reads > 0 ? ((stats.fromMemory / reads) * 100).toFixed(1) : "—";
+    log(
+      `piece-store "${stats.name.slice(0, 40)}": resident=${stats.resident}/${stats.capacity} ` +
+      `spilled=${stats.spilled} reads=${reads} (${fromMemoryShare}% from memory) ` +
+      `spills=${stats.spills} revivals=${stats.revivals}` +
+      (stats.blockedByPins > 0 ? ` blocked-by-pins=${stats.blockedByPins}` : "")
+    );
+  }
+}, STORE_REPORT_INTERVAL_MS).unref();
+
 log("torrent worker started");

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

@@ -209,6 +209,82 @@ test("a range within a piece is served correctly from memory and from disk", asy
   }
 });
 
+test("takes memory as it needs it, not the whole budget up front", async () => {
+  // The budget is per torrent, so a torrent that is merely open — or one being
+  // probed for its codecs — must not charge the host for the ceiling.
+  const { store, directory } = await makeStore({ pieces: 16, totalPieces: 64 });
+  try {
+    assert.equal(store.capacity, 16);
+    const initial = store.sharedBuffer.byteLength;
+    assert.ok(initial <= CHUNK * 2, `claimed ${initial} bytes before holding anything`);
+
+    for (let index = 0; index < 5; index += 1) {
+      await put(store, index, piece(index));
+    }
+
+    assert.equal(store.residentCount, 5);
+    assert.ok(
+      store.sharedBuffer.byteLength >= CHUNK * 5,
+      "the pool did not grow to hold what was put in it"
+    );
+    assert.ok(
+      store.sharedBuffer.byteLength <= CHUNK * 6,
+      "the pool grew past what was actually needed"
+    );
+
+    // Growing must not move bytes already written.
+    assert.deepEqual(await get(store, 0), piece(0), "an early piece was disturbed by growth");
+  } finally {
+    await new Promise((resolve) => store.destroy(resolve));
+    await fs.rm(directory, { recursive: true, force: true });
+  }
+});
+
+test("counts where reads were served from, so the budget can be judged", async () => {
+  const { store, directory } = await makeStore({ pieces: 2, totalPieces: 8 });
+  try {
+    await put(store, 0, piece(0));
+    await get(store, 0); // memory
+    await get(store, 0); // memory
+
+    await put(store, 1, piece(1));
+    await put(store, 2, piece(2)); // piece 0 spills
+    await get(store, 0); // disk
+
+    const stats = store.stats();
+    assert.equal(stats.fromMemory, 2, "memory reads miscounted");
+    assert.equal(stats.fromDisk, 1, "disk reads miscounted");
+    // Two: piece 0 goes out to make room for piece 2, then piece 1 goes out to
+    // make room for piece 0 coming back. Reviving costs a spill of its own, and
+    // that is worth seeing in the figures rather than hiding.
+    assert.equal(stats.spills, 2, "spills miscounted");
+    assert.equal(stats.revivals, 1, "revivals miscounted");
+    assert.equal(stats.blockedByPins, 0);
+    assert.equal(stats.capacity, 2);
+  } finally {
+    await new Promise((resolve) => store.destroy(resolve));
+    await fs.rm(directory, { recursive: true, force: true });
+  }
+});
+
+test("counts a refusal caused by pinned pieces", async () => {
+  const { store, directory } = await makeStore({ pieces: 2, totalPieces: 8 });
+  try {
+    await put(store, 0, piece(0));
+    await put(store, 1, piece(1));
+    store.pin(0);
+    store.pin(1);
+    await assert.rejects(() => put(store, 2, piece(2)));
+
+    assert.equal(store.stats().blockedByPins, 1, "a refusal went unrecorded");
+  } finally {
+    store.unpin(0);
+    store.unpin(1);
+    await new Promise((resolve) => store.destroy(resolve));
+    await fs.rm(directory, { recursive: true, force: true });
+  }
+});
+
 test("destroy removes the spill file", async () => {
   const { store, directory } = await makeStore({ pieces: 2, totalPieces: 8 });
   await put(store, 0, piece(0));

package/test/worker-channel.test.js

@@ -16,7 +16,8 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 import { MessageChannel } from "node:worker_threads";
-import { createSendStream, createReceiveStream } from "../services/torrent-worker/channel.js";
+import { createSendStream, createReceiveStream, createCaller } from "../services/torrent-worker/channel.js";
+import { TorrentWorkerClient } from "../services/torrent-worker/client.js";
 
 /**
  * A buffer standing in for one owned by WebTorrent's piece cache: allocated
@@ -96,6 +97,36 @@ test("chunks arrive with their contents intact", async () => {
   }
 });
 
+test("reads and commands never share a request id", () => {
+  const { port1, port2 } = new MessageChannel();
+  try {
+    const commandIds = [];
+    port2.on("message", (message) => commandIds.push(message.id));
+
+    const caller = createCaller(port1);
+    const readIds = [];
+
+    // Interleaved exactly as the real client does it: commands through `call`,
+    // reads taking an id directly, both over the same channel.
+    for (let round = 0; round < 50; round += 1) {
+      void caller.call("noop", {});
+      readIds.push(caller.nextId());
+    }
+
+    // A repeat between the two sequences is the collision that let a read's
+    // reply resolve a command — with its result, silently.
+    const everyId = [...commandIds, ...readIds];
+    assert.equal(
+      new Set(everyId).size,
+      everyId.length,
+      "an id was handed out to both a command and a read"
+    );
+  } finally {
+    port1.close();
+    port2.close();
+  }
+});
+
 test("a failed read surfaces on the reader instead of ending quietly", async () => {
   const { port1, port2 } = new MessageChannel();
   try {
@@ -118,3 +149,27 @@ test("a failed read surfaces on the reader instead of ending quietly", async ()
     port2.close();
   }
 });
+
+test("a read of an unknown source fails the stream rather than hanging", async () => {
+  // End to end through a real worker, because this is where the defect lived:
+  // the worker reported the failure, nothing on the main thread listened, and
+  // the reader waited forever. A unit test on either half alone passes happily.
+  const client = new TorrentWorkerClient({ memoryBytes: 8 * 1024 * 1024 });
+  try {
+    const stream = client.createReadStream({ sourceKey: "no-such-source", fileIndex: 0 });
+    const reader = stream.getReader();
+
+    const outcome = await Promise.race([
+      reader.read().then(() => "resolved", (error) => `rejected: ${error?.message}`),
+      new Promise((resolve) => setTimeout(() => resolve("hung"), 10_000))
+    ]);
+
+    assert.match(
+      outcome,
+      /^rejected: .*no-such-source/,
+      `expected the read to fail, got "${outcome}"`
+    );
+  } finally {
+    await client.destroyAll();
+  }
+});