@torrent-tv/proxy 2.9.75 → 2.9.77

package/test/stream-route.test.js

@@ -0,0 +1,121 @@
+/**
+ * @file What `/stream` does with a HEAD request.
+ *
+ * Fastify answers HEAD from the GET handler, so without an explicit branch a
+ * HEAD started a read of the entire file. Node discards the body, but the read
+ * itself runs on and the response never completes, which blocks the next
+ * request on that keep-alive connection. The keyframe index asks for the file
+ * size with exactly such a HEAD before every transcode session.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { handleStreamGet } from "../routes/stream/get.js";
+
+/**
+ * Minimal stand-ins for the parts of Fastify and the pool this route touches.
+ *
+ * @param {{ method: string, range?: string }} request
+ * @returns {{ req: object, reply: object, sent: object, opened: string[], claims: number }}
+ */
+function harness({ method, range }) {
+  const opened = [];
+  const state = { claims: 0 };
+
+  const sent = { code: 200, headers: {}, body: undefined, called: false };
+  const reply = {
+    code(value) {
+      sent.code = value;
+      return reply;
+    },
+    header(name, value) {
+      sent.headers[name.toLowerCase()] = value;
+      return reply;
+    },
+    send(body) {
+      sent.called = true;
+      sent.body = body;
+      return reply;
+    },
+    hijack() {
+      sent.hijacked = true;
+    },
+    raw: {
+      // `bindRelease` listens here; HEAD writes its response here.
+      once() {},
+      writeHead(code, headers) {
+        sent.code = code;
+        for (const [name, value] of Object.entries(headers)) {
+          sent.headers[name.toLowerCase()] = value;
+        }
+      },
+      end() {
+        sent.called = true;
+      }
+    }
+  };
+
+  const file = {
+    name: "movie.mkv",
+    length: 5_869_669_065,
+    createReadStream(options = {}) {
+      opened.push(`${options.start ?? 0}-${options.end ?? "end"}`);
+      return { on() {} };
+    }
+  };
+
+  const torrentPool = {
+    async getTorrent() {
+      return { files: [file], sourceKey: "key" };
+    },
+    acquireFile() {
+      state.claims += 1;
+      return () => undefined;
+    },
+    prioritizeByteRange() {}
+  };
+
+  const req = {
+    method,
+    query: { sourceType: "magnet", source: "magnet:?xt=urn:btih:abc", fileIndex: "0" },
+    headers: range ? { range } : {},
+    raw: { once() {} }
+  };
+
+  return { req, reply, sent, opened, state, deps: { sourceRegistry: { get: () => null }, torrentPool } };
+}
+
+test("HEAD reports the size without opening a read", async () => {
+  const { req, reply, sent, opened, state, deps } = harness({ method: "HEAD" });
+
+  await handleStreamGet(req, reply, deps);
+
+  assert.deepEqual(opened, [], "HEAD started a read of the file");
+  assert.equal(state.claims, 0, "HEAD claimed the file it never read");
+  // The real size, not the zero Fastify substitutes for an empty payload — the
+  // keyframe index reads this header and treats 0 as "no index".
+  assert.equal(sent.headers["content-length"], "5869669065");
+  assert.equal(sent.headers["accept-ranges"], "bytes");
+  assert.equal(sent.called, true, "HEAD never completed its response");
+  assert.equal(sent.body, undefined, "HEAD answered with a body");
+});
+
+test("GET still streams the bytes", async () => {
+  const { req, reply, sent, opened, deps } = harness({ method: "GET" });
+
+  await handleStreamGet(req, reply, deps);
+
+  assert.equal(opened.length, 1, "GET did not open a read");
+  assert.equal(sent.headers["content-length"], "5869669065");
+});
+
+test("GET with a range streams only that range", async () => {
+  const { req, reply, sent, opened, deps } = harness({ method: "GET", range: "bytes=100-199" });
+
+  await handleStreamGet(req, reply, deps);
+
+  assert.deepEqual(opened, ["100-199"]);
+  assert.equal(sent.code, 206);
+  assert.equal(sent.headers["content-range"], "bytes 100-199/5869669065");
+  assert.equal(sent.headers["content-length"], "100");
+});

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

package/test/worker-source-race.test.js

@@ -0,0 +1,76 @@
+/**
+ * @file Naming a source that is still being added.
+ *
+ * Adding a magnet takes as long as its metadata does — seconds to tens of
+ * seconds — while the browser is already polling stats and the planner is
+ * already asking for a plan. Until 2.9.77 the worker registered the torrent
+ * only once the add had finished, so everything arriving in that window was
+ * told `Unknown source`, which is false: the source exists, it is not ready.
+ * Reproduced with a magnet nobody seeds — stats, the file listing and a read
+ * all failed instantly while the add was in flight.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import crypto from "node:crypto";
+import { TorrentWorkerClient } from "../services/torrent-worker/client.js";
+
+/** A well-formed infohash nobody is seeding, so the add stays in flight. */
+function pendingMagnet() {
+  return `magnet:?xt=urn:btih:${crypto.randomBytes(20).toString("hex")}&dn=nobody-has-this`;
+}
+
+/**
+ * What a promise did within `ms` — settled how, or still waiting.
+ *
+ * @param {Promise<unknown>} promise
+ * @param {number} ms
+ * @returns {Promise<string>}
+ */
+function outcomeWithin(promise, ms) {
+  return Promise.race([
+    promise.then(() => "resolved", (error) => `rejected: ${error?.message}`),
+    new Promise((resolve) => setTimeout(() => resolve("waiting"), ms))
+  ]);
+}
+
+test("commands wait for a source that is still being added", async () => {
+  const client = new TorrentWorkerClient({ memoryBytes: 16 * 1024 * 1024 });
+  try {
+    // Without this the worker's own startup would keep the commands waiting and
+    // the test would pass for the wrong reason.
+    await client.listFiles("warm-up").catch(() => undefined);
+
+    const sourceKey = "pending-source";
+    // Deliberately not awaited: this is the window under test.
+    const adding = client.addSource({ sourceKey, sourceType: "magnet", source: pendingMagnet() });
+    adding.catch(() => undefined);
+
+    await new Promise((resolve) => setTimeout(resolve, 500));
+
+    const stats = await outcomeWithin(client.getFileStats({ sourceKey, fileIndex: 0 }), 3000);
+    const files = await outcomeWithin(client.listFiles(sourceKey), 3000);
+
+    assert.equal(stats, "waiting", `stats did not wait for the add: ${stats}`);
+    assert.equal(files, "waiting", `the file listing did not wait for the add: ${files}`);
+  } finally {
+    await client.destroyAll();
+  }
+});
+
+test("a source that was never added is still reported as unknown", async () => {
+  const client = new TorrentWorkerClient({ memoryBytes: 16 * 1024 * 1024 });
+  try {
+    // Starting the worker takes several seconds — it builds a torrent client,
+    // a DHT and the rest — so the first command measures startup, not the
+    // behaviour under test. Wait for one to come back before timing anything.
+    await client.listFiles("warm-up").catch(() => undefined);
+
+    // Waiting forever for something nobody ever asked for would be worse than
+    // an error — this case must stay an error.
+    const outcome = await outcomeWithin(client.listFiles("never-added"), 5000);
+    assert.match(outcome, /^rejected: .*never-added/, `expected an error, got "${outcome}"`);
+  } finally {
+    await client.destroyAll();
+  }
+});