@torrent-tv/proxy 2.9.75 → 2.9.76

package/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 2.9.76
+
+- **Fix**: A read that failed inside the torrent thread left the reader waiting forever, and a read that failed part-way looked like a file that had simply ended. Two halves of one hole, both present since the thread split: the worker sent the end-of-read marker from its `finally` even when the read had thrown, and the main thread had no handler for a read error at all — so the report was dropped as unknown. That is why the 2.9.71 defect took three releases to find: every symptom said "empty file", never "this read failed, here is why". Now the marker is sent only on success and the failure fails the caller's stream. Covered end to end by a test that hung before the fix.
+- **Fix**: Reads and commands drew request ids from two independent counters into one namespace, so a read and a command could both be in flight as the same number. The worker's reply to the read then resolved the **command** — with the read's result, silently — and the command's real answer arrived later and was discarded as unknown. Depending on which command lost the race this produced empty stats, a prefetch that returned early, or a file claim released before its read had finished. Every id now comes from one sequence, which makes the collision impossible rather than unlikely; a test hands out ids down both paths and asserts they never repeat.
+
 ## 2.9.75
 
 - **New**: The piece store reports what it is doing — resident pieces against the budget, how many spilled to disk, what share of reads came from memory rather than disk, and how often eviction was refused because every piece was being read. Logged once a minute and only when something changed. Without this the component that decides whether a read is free or costs a disk trip was invisible in the field, and the first oddity would have had no evidence behind it.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@torrent-tv/proxy",
-  "version": "2.9.75",
+  "version": "2.9.76",
   "description": "Torrent proxy client that exposes webseed-like HTTP stream endpoint.",
   "license": "GPL-3.0-or-later",
   "publishConfig": {

package/services/torrent-worker/channel.js

@@ -42,6 +42,18 @@ export function createCaller(port) {
   const pending = new Map();
 
   return {
+    /**
+     * The one source of request ids on this side of the channel.
+     *
+     * Reads used to number themselves from a second counter, which put two
+     * unrelated sequences in one namespace: a read and a command could both be
+     * in flight as id 5, and the worker's reply to the read then resolved the
+     * command — with the read's result, silently, while the command's real
+     * answer arrived later and was dropped as unknown. Handing out every id
+     * from here makes that collision impossible rather than unlikely.
+     */
+    nextId,
+
     call(command, params = {}) {
       return new Promise((resolve, reject) => {
         const id = nextId();

package/services/torrent-worker/client.js

@@ -37,8 +37,6 @@ export class TorrentWorkerClient {
   #caller;
   /** Receive-side handles for in-flight reads, keyed by request id. */
   #reads = new Map();
-  /** Monotonic ids for reads, independent of the caller's own numbering. */
-  #nextReadId = 0;
 
   /**
    * @param {{ maxDiskBytes?: number, memoryBytes?: number }} [options]
@@ -50,6 +48,18 @@ export class TorrentWorkerClient {
     this.#caller = createCaller(this.#worker);
 
     this.#worker.on("message", (message) => {
+      // A failed read must fail its stream. This is checked BEFORE the caller
+      // sees the message: until 2.9.76 nothing here handled a read error at
+      // all, so the worker's report was dropped as unknown, and because the
+      // worker sent the end-of-read marker from its `finally` even when the
+      // read had thrown, the reader saw a clean end of file instead. A read
+      // that failed before it produced anything simply hung forever.
+      if (message?.type === Event.ERROR && this.#reads.has(message.id)) {
+        const read = this.#reads.get(message.id);
+        this.#reads.delete(message.id);
+        read.fail(new Error(message.error ?? "Torrent worker read failed."));
+        return;
+      }
       if (this.#caller.handleReply(message)) {
         return;
       }
@@ -176,7 +186,8 @@ export class TorrentWorkerClient {
    * @returns {ReadableStream<Uint8Array>}
    */
   createReadStream({ sourceKey, fileIndex, start = null, end = null }) {
-    const readId = (this.#nextReadId += 1);
+    // Same id sequence as commands — see `nextId` in `channel.js`.
+    const readId = this.#caller.nextId();
     const receive = createReceiveStream({
       port: this.#worker,
       requestId: readId,

package/services/torrent-worker/worker.js

@@ -126,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()) {
@@ -140,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") {

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();
+  }
+});