@torrent-tv/proxy 2.62.0 → 2.64.0

package/test/memory-budget.test.js

@@ -4,8 +4,12 @@ import assert from "node:assert/strict";
 import { describeMemory } from "../services/memory-report.js";
 import {
   budgetForNewStore,
+  SharedPieceStore,
   totalStoreBudgetBytes
 } from "../services/piece-store/shared-piece-store.js";
+import { mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
 
 const MEGABYTE = 1024 * 1024;
 const GIGABYTE = 1024 * MEGABYTE;
@@ -50,12 +54,18 @@ test("the memory line says bytes, and names what it could not measure", () => {
     availableBytes: 1900 * MEGABYTE,
     availableMeasured: true,
     stores: [
-      { name: "a film", residentBytes: 504 * MEGABYTE, budgetBytes: 512 * MEGABYTE }
+      {
+        name: "a film",
+        residentBytes: 504 * MEGABYTE,
+        committedBytes: 504 * MEGABYTE,
+        spilledBytes: 0,
+        budgetBytes: 512 * MEGABYTE
+      }
     ]
   });
   // The figures the kernel's own kill line quoted, so the two can be compared.
   assert.match(measured, /rss=2366MB/);
-  assert.match(measured, /1 torrent store\(s\) holding 504MB of 512MB allowed/);
+  assert.match(measured, /1 torrent store\(s\) holding 504MB, committed 504MB of 512MB allowed/);
   assert.match(measured, /machine has 1900MB available$/);
 
   const estimated = describeMemory({
@@ -67,3 +77,80 @@ test("the memory line says bytes, and names what it could not measure", () => {
   assert.match(estimated, /no torrent stores/);
   assert.match(estimated, /estimated — \/proc\/meminfo could not be read/);
 });
+
+test("holding and having taken are separate figures, and the line says both", () => {
+  // The shape that hid 650 MB on 2026-08-28: eighteen pieces held, sixty-four
+  // slots taken and never given back, and a line that only mentioned the first.
+  const line = describeMemory({
+    process: { rss: 893 * MEGABYTE, heapUsed: 29 * MEGABYTE, heapTotal: 34 * MEGABYTE, external: 11 * MEGABYTE, arrayBuffers: 7 * MEGABYTE },
+    availableBytes: 2287 * MEGABYTE,
+    availableMeasured: true,
+    anonymousBytes: 870 * MEGABYTE,
+    diskFreeBytes: 12000 * MEGABYTE,
+    stores: [
+      {
+        name: "a film",
+        residentBytes: 144 * MEGABYTE,
+        committedBytes: 512 * MEGABYTE,
+        spilledBytes: 2904 * MEGABYTE,
+        budgetBytes: 512 * MEGABYTE
+      }
+    ]
+  });
+  assert.match(line, /holding 144MB, committed 512MB of 512MB allowed, 2904MB spilled to disk/);
+  assert.match(line, /anon=870MB/);
+  assert.match(line, /12000MB free on disk$/);
+});
+
+test("a thread's reading leaves out what belongs to the process", () => {
+  // `rss` and the kernel's rollup are process-wide and are read once, on the
+  // main thread. What the torrent worker can say — and the only place it can be
+  // said — is its own isolate, where the piece pool actually lives.
+  const line = describeMemory({
+    scope: "thread",
+    label: "torrent worker",
+    process: { rss: 893 * MEGABYTE, heapUsed: 12 * MEGABYTE, heapTotal: 20 * MEGABYTE, external: 530 * MEGABYTE, arrayBuffers: 512 * MEGABYTE },
+    stores: [
+      {
+        name: "a film",
+        residentBytes: 144 * MEGABYTE,
+        committedBytes: 512 * MEGABYTE,
+        spilledBytes: 0,
+        budgetBytes: 512 * MEGABYTE
+      }
+    ]
+  });
+  assert.match(line, /^memory \(torrent worker\): heap=12MB\/20MB/);
+  assert.match(line, /arrayBuffers=512MB/);
+  assert.doesNotMatch(line, /rss=/);
+  assert.doesNotMatch(line, /machine has/);
+});
+
+test("a store's allowance follows the machine, and never passes its reservation", async () => {
+  // The defect: a store created on an idle machine kept an idle machine's
+  // allowance for life and went on growing into memory the host no longer had.
+  const directory = await mkdtemp(path.join(os.tmpdir(), "budget-revision-"));
+  const store = new SharedPieceStore(1024, {
+    path: directory,
+    name: "revision",
+    memoryBytes: 64 * 1024
+  });
+  try {
+    const born = store.stats().budgetBytes;
+    assert.ok(born > 0);
+
+    // The machine fills up: the ceiling comes down and growth stops there.
+    const lowered = store.reviseGrowthCeiling(8 * 1024);
+    assert.ok(lowered.ceilingBytes < born, "a busier machine buys fewer slots");
+    assert.equal(store.stats().budgetBytes, lowered.ceilingBytes, "the line says what is allowed now");
+
+    // The machine empties again: the ceiling may rise, but never above the
+    // reservation, because `maxByteLength` was fixed from it and `grow()`
+    // cannot pass it.
+    const raised = store.reviseGrowthCeiling(1024 * 1024 * 1024);
+    assert.equal(raised.ceilingBytes, born, "the reservation is the hard limit");
+  } finally {
+    await new Promise((resolve) => store.destroy(resolve));
+    await rm(directory, { recursive: true, force: true });
+  }
+});

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

@@ -1,76 +0,0 @@
-/**
- * @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();
-  }
-});