@torrent-tv/proxy 2.87.19 → 2.87.20

package/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 2.87.20
+
+- **Fix**: Expose completed files through the worker pool adapter so source HTTP reads use the assembled file; open it before sending headers and return to torrent reads if it has already been removed.
+
 ## 2.87.19
 
 - **Fix**: Return shared source bytes after whole-file assembly and retain the buffer held by concurrent readers instead of replacing it; fail malformed fragments explicitly rather than skipping source bytes.

package/package.json

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

package/routes/stream/get.js

@@ -6,7 +6,7 @@
  * and HTTP 200 for full-file requests.
  */
 
-import { createReadStream } from "node:fs";
+import { open } from "node:fs/promises";
 import { parseRange } from "../../utils/parse-range.js";
 import { logger } from "../../utils/logger.js";
 
@@ -107,9 +107,10 @@ function wholeFileFor(torrentPool, sourceKey, fileIndex) {
  * @param {import("fastify").FastifyRequest} req
  * @param {import("fastify").FastifyReply} reply
  * @param {{ path: string, length: number, name: string }} file
+ * @param {import("node:fs/promises").FileHandle} handle - Already open; closed for HEAD.
  * @returns {Promise<void> | void}
  */
-function serveWholeFile(req, reply, file) {
+function serveWholeFile(req, reply, file, handle) {
   const disposition = `inline; filename*=UTF-8''${encodeURIComponent(file.name)}`;
   if (req.method === "HEAD") {
     reply.hijack();
@@ -128,13 +129,13 @@ function serveWholeFile(req, reply, file) {
   const range = parseRange(req.headers.range, file.length);
   if (!range) {
     reply.header("Content-Length", String(file.length));
-    return reply.send(createReadStream(file.path));
+    return reply.send(handle.createReadStream());
   }
   const { start, end } = range;
   reply.code(206);
   reply.header("Content-Length", String(end - start + 1));
   reply.header("Content-Range", `bytes ${start}-${end}/${file.length}`);
-  return reply.send(createReadStream(file.path, { start, end }));
+  return reply.send(handle.createReadStream({ start, end }));
 }
 
 export async function handleStreamGet(req, reply, { sourceRegistry, torrentPool, noteInputBytes = null }) {
@@ -157,7 +158,25 @@ export async function handleStreamGet(req, reply, { sourceRegistry, torrentPool,
   // nothing the torrent would have told us.
   const whole = wholeFileFor(torrentPool, sourceKey, fileIndex);
   if (whole) {
-    return serveWholeFile(req, reply, whole);
+    let handle;
+    try {
+      // Open before committing headers: the disk owner may have removed an
+      // announced file. An open descriptor also preserves a live POSIX read.
+      handle = await open(whole.path, "r");
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+      const key = `${sourceKey.slice("torrent:".length).toLowerCase()}/${fileIndex}`;
+      if (torrentPool.wholeFiles.get(key) === whole) torrentPool.wholeFiles.delete(key);
+    }
+    if (handle) {
+      if (req.method === "HEAD") await handle.close();
+      try {
+        return serveWholeFile(req, reply, whole, handle);
+      } catch (error) {
+        await handle.close().catch(() => undefined);
+        throw error;
+      }
+    }
   }
 
   let torrent;

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

@@ -36,9 +36,10 @@ export class WorkerTorrentPool {
 
   /**
    * @param {{ memoryBytes?: number, stateDir?: string }} [options]
+   * @param {object | null} [client] - The worker interface; tests supply a fake.
    */
-  constructor(options = {}) {
-    this.#client = new TorrentWorkerClient(options);
+  constructor(options = {}, client = null) {
+    this.#client = client ?? new TorrentWorkerClient(options);
   }
 
   /**
@@ -95,6 +96,11 @@ export class WorkerTorrentPool {
     return this.#client.wholeFileBytes ?? 0;
   }
 
+  /** Completed files announced by the worker, shared with the HTTP reader. */
+  get wholeFiles() {
+    return this.#client.wholeFiles;
+  }
+
   allowWholeFileBytes(bytes) {
     return this.#client.allowWholeFileBytes(bytes);
   }

package/test/stream-route.test.js

@@ -14,6 +14,7 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { handleStreamGet } from "../routes/stream/get.js";
+import { WorkerTorrentPool } from "../services/torrent/worker/pool-adapter.js";
 
 /**
  * Minimal stand-ins for the parts of Fastify and the pool this route touches.
@@ -151,13 +152,18 @@ test("a file downloaded whole is served from disk without touching the torrent",
   try {
     const { req, reply, sent, deps } = harness({ method: "GET", range: "bytes=2-6" });
     let asked = false;
-    deps.torrentPool.getTorrent = async () => {
-      asked = true;
-      throw new Error("the torrent was asked for, which is what this avoids");
-    };
-    deps.torrentPool.wholeFiles = new Map([
+    const wholeFiles = new Map([
       ["abc/0", { path: where, length: bytes.length, name: "film.mkv" }]
     ]);
+    // Supply the worker boundary explicitly: no Worker or torrent is started.
+    deps.torrentPool = new WorkerTorrentPool({}, {
+      wholeFiles,
+      async getTorrent() {
+        asked = true;
+        throw new Error("the worker must not be asked for completed bytes");
+      }
+    });
+    assert.equal(deps.torrentPool.wholeFiles, wholeFiles);
     // The source key IS the identity — `torrent:<infohash>` — and it is all the
     // route needs to find the file.
     deps.sourceRegistry = { get: () => ({ sourceType: "torrent", source: "magnet:?xt=urn:btih:abc" }) };
@@ -169,11 +175,32 @@ test("a file downloaded whole is served from disk without touching the torrent",
     assert.equal(sent.code, 206);
     assert.equal(sent.headers["content-range"], `bytes 2-6/${bytes.length}`);
     assert.equal(sent.headers["content-length"], "5");
+    const chunks = [];
+    for await (const chunk of sent.body) chunks.push(chunk);
+    assert.deepEqual(Buffer.concat(chunks), bytes.subarray(2, 7));
   } finally {
     await fs.rm(root, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
   }
 });
 
+test("an announced file removed before opening falls back to the torrent before headers", async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), "stream-removed-"));
+  try {
+    const { req, reply, sent, opened, deps } = harness({ method: "GET", range: "bytes=2-6" });
+    deps.torrentPool.wholeFiles = new Map([
+      ["abc/0", { path: path.join(root, "missing"), length: 10, name: "gone.mkv" }]
+    ]);
+    deps.sourceRegistry = { get: () => ({ sourceType: "magnet", source: "magnet:?xt=urn:btih:abc" }) };
+    req.query = { sourceKey: "torrent:abc", fileIndex: "0" };
+    await handleStreamGet(req, reply, deps);
+    assert.deepEqual(opened, ["2-6"]);
+    assert.equal(deps.torrentPool.wholeFiles.size, 0);
+    assert.equal(sent.headers["content-range"], "bytes 2-6/5869669065");
+  } finally {
+    await fs.rm(root, { recursive: true, force: true });
+  }
+});
+
 test("a file this proxy does not have whole still goes to the torrent", async () => {
   const { req, reply, state, deps } = harness({ method: "GET", range: "bytes=0-99" });
   deps.torrentPool.wholeFiles = new Map([["other/7", { path: "/nowhere", length: 1, name: "x" }]]);