@torrent-tv/proxy 2.85.1 → 2.87.0

package/test/one-budget.test.js

@@ -0,0 +1,149 @@
+/**
+ * @file One budget: one owner, one policy, a share per resource.
+ *
+ * What it replaced was two owners applying one rule to two readings — memory
+ * divided inside the torrent thread, disk divided on the main one, neither able
+ * to see the other. The claimants TRADE ACROSS RESOURCES: pieces that do not
+ * fit in memory are spilled to disk, so how much memory the piece store is
+ * given decides how much disk it needs. Field 2026-08-31: 14 400 MB spilled in
+ * fifty minutes while the memory store held 312-424 MB.
+ *
+ * And "disk" is not one resource. Measured on the addon host 2026-09-05,
+ * `/tmp` is the overlay filesystem and `/data` is ext4 on the nvme — two
+ * devices, so one figure divided between claimants on both gives each a share
+ * of a disk it does not write to.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { MachineBudget } from "../services/storage/MachineBudget.js";
+
+const MEGABYTE = 1024 * 1024;
+
+/**
+ * @param {{ name: string, resource: string, held?: number, wanted: number, minimum?: number }} shape
+ * @returns {{ claimant: object, allowed: () => number }}
+ */
+function claimantOf({ name, resource, held = 0, wanted, minimum }) {
+  let allowed = 0;
+  return {
+    claimant: {
+      name,
+      resource,
+      minimum,
+      held: () => held,
+      wanted: () => wanted,
+      allow: (bytes) => {
+        allowed = bytes;
+      }
+    },
+    allowed: () => allowed
+  };
+}
+
+test("each resource is divided on its own — a share of memory is not a share of disk", async () => {
+  const budget = new MachineBudget({ logger: { info: () => {}, warn: () => {} } });
+  budget.defineResource({ name: "memory", readFree: () => 100 * MEGABYTE });
+  budget.defineResource({ name: "disk:tmp", readFree: () => 10 * MEGABYTE });
+
+  const pieces = claimantOf({ name: "pieces in memory", resource: "memory", wanted: Number.MAX_SAFE_INTEGER });
+  const segments = claimantOf({ name: "segments", resource: "disk:tmp", wanted: Number.MAX_SAFE_INTEGER });
+  budget.register(pieces.claimant);
+  budget.register(segments.claimant);
+
+  await budget.revise();
+
+  assert.equal(pieces.allowed(), 100 * MEGABYTE, "memory is divided from what memory has");
+  assert.equal(segments.allowed(), 10 * MEGABYTE, "and disk from what that disk has");
+});
+
+test("two devices are two resources — one is not cut to pay for the other", async () => {
+  const budget = new MachineBudget({ logger: { info: () => {}, warn: () => {} } });
+  budget.defineResource({ name: "disk:66305", readFree: () => 8 * MEGABYTE });
+  budget.defineResource({ name: "disk:68", readFree: () => 80 * MEGABYTE });
+
+  // The shape on the addon host: segments and spill on the overlay, the
+  // evidence on the nvme.
+  const segments = claimantOf({ name: "segments", resource: "disk:68", wanted: Number.MAX_SAFE_INTEGER });
+  const spill = claimantOf({ name: "spilled pieces", resource: "disk:68", wanted: Number.MAX_SAFE_INTEGER });
+  const evidence = claimantOf({ name: "diagnostics", resource: "disk:66305", wanted: Number.MAX_SAFE_INTEGER });
+  for (const one of [segments, spill, evidence]) {
+    budget.register(one.claimant);
+  }
+
+  await budget.revise();
+
+  assert.equal(evidence.allowed(), 8 * MEGABYTE, "the evidence gets the disk it actually writes to, whole");
+  assert.equal(segments.allowed() + spill.allowed(), 80 * MEGABYTE, "and the other device is divided among its own");
+});
+
+test("a fixed ceiling is the operator's, and it binds", async () => {
+  const budget = new MachineBudget({
+    policy: { kind: "fixed", bytes: 5 * MEGABYTE },
+    logger: { info: () => {}, warn: () => {} }
+  });
+  budget.defineResource({ name: "disk", readFree: () => 1000 * MEGABYTE });
+  const segments = claimantOf({ name: "segments", resource: "disk", wanted: Number.MAX_SAFE_INTEGER });
+  budget.register(segments.claimant);
+
+  await budget.revise();
+
+  assert.equal(segments.allowed(), 5 * MEGABYTE, "a disk with a gigabyte free is still capped at what was asked for");
+});
+
+test("a share of free is the operator's too", async () => {
+  const budget = new MachineBudget({
+    policy: { kind: "share", share: 0.25 },
+    logger: { info: () => {}, warn: () => {} }
+  });
+  budget.defineResource({ name: "disk", readFree: () => 40 * MEGABYTE });
+  const segments = claimantOf({ name: "segments", resource: "disk", held: 0, wanted: Number.MAX_SAFE_INTEGER });
+  budget.register(segments.claimant);
+
+  await budget.revise();
+
+  assert.equal(segments.allowed(), 10 * MEGABYTE);
+});
+
+test("a floor lifts a policy that would allow less, and cannot invent room", async () => {
+  const budget = new MachineBudget({
+    policy: { kind: "fixed", bytes: MEGABYTE, floors: { disk: 6 * MEGABYTE } },
+    logger: { info: () => {}, warn: () => {} }
+  });
+  budget.defineResource({ name: "disk", readFree: () => 4 * MEGABYTE });
+  const segments = claimantOf({ name: "segments", resource: "disk", wanted: Number.MAX_SAFE_INTEGER });
+  budget.register(segments.claimant);
+
+  await budget.revise();
+
+  assert.equal(
+    segments.allowed(),
+    4 * MEGABYTE,
+    "the floor lifts the ceiling above the fixed one, but never past what the machine has"
+  );
+});
+
+test("a resource that cannot be read allows nothing to grow", async () => {
+  const budget = new MachineBudget({ logger: { info: () => {}, warn: () => {} } });
+  budget.defineResource({ name: "disk", readFree: () => null });
+  const segments = claimantOf({ name: "segments", resource: "disk", held: 0, wanted: Number.MAX_SAFE_INTEGER });
+  budget.register(segments.claimant);
+
+  await budget.revise();
+
+  assert.equal(segments.allowed(), 0, "unreadable is not the same as unbounded");
+});
+
+test("a claimant below its own minimum says so", async () => {
+  const said = [];
+  const budget = new MachineBudget({ logger: { info: () => {}, warn: (line) => said.push(line) } });
+  budget.defineResource({ name: "memory", readFree: () => MEGABYTE });
+  budget.register(claimantOf({
+    name: "pieces in memory", resource: "memory", wanted: Number.MAX_SAFE_INTEGER, minimum: 64 * MEGABYTE
+  }).claimant);
+
+  await budget.revise();
+
+  assert.equal(said.length, 1, "working below what it needs is a fault of the machine, and invisible otherwise");
+  assert.match(said[0], /below the 64MB it needs/);
+});

package/test/one-output-one-session.test.js

@@ -0,0 +1,204 @@
+/**
+ * @file Many viewers of one output are handed one session.
+ *
+ * This is the product behaviour the whole output key exists for: two people
+ * watching the same film, in the same form, at whatever moments, are served by
+ * one encode and one set of pieces. It had no check of any kind — every test
+ * that needed a session either built one by hand or replaced
+ * `createOrGetSession` with a stub — so the one line that decides it could have
+ * been broken by any edit without a word.
+ *
+ * What is checked here is the decision, not the creation: a session under the
+ * name this request produces already exists, and the request must be answered
+ * with it rather than with a new one. The name is the format produced, so the
+ * request is first taken as far as the format — the file's facts and its
+ * keyframe table are given as already known — and making the FIRST session,
+ * which reaches the disk, is a different subject.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { wireOutputs } from "../services/server/wire-outputs.js";
+import { AudioOutput, CutGrid, OutputSpec, VideoOutput } from "../services/encode/output/OutputSpec.js";
+import { Timeline } from "../services/encode/output/Timeline.js";
+import { SourceFile } from "../services/media/SourceFile.js";
+
+const TORRENT = "torrent:11f0929918e2b5aa2e5b71ecdbe5c0f1a4bbf7d1";
+
+/**
+ * What a browser asks for: this file, copied, sound inside the stream.
+ *
+ * @param {object} [over]
+ * @returns {object}
+ */
+function request(over = {}) {
+  return {
+    sourceKey: TORRENT,
+    fileIndex: 0,
+    fileName: "film.mkv",
+    transcodeVideo: false,
+    transcodeAudio: false,
+    audioTrackIndex: 0,
+    segmentFormatId: "fmp4",
+    ...over
+  };
+}
+
+/**
+ * The name the manager will look that request up under, built the way it builds
+ * it: a copied picture carrying its own sound, cut at the file's keyframes.
+ *
+ * @returns {string}
+ */
+function specOfThatOutput() {
+  return new OutputSpec({
+    sourceKey: TORRENT,
+    segmentFormatId: "fmp4",
+    grid: new CutGrid({ kind: "keyframe", fileIndex: 0 }),
+    video: new VideoOutput({ fileIndex: 0, encode: null }),
+    audio: new AudioOutput({ fileIndex: 0, trackIndex: 0, transcode: false })
+  });
+}
+
+/** @returns {string} */
+function nameOfThatOutput() {
+  return specOfThatOutput().toName();
+}
+
+/**
+ * @param {object} manager
+ * @returns {object} The session it is seeded with.
+ */
+function seedOneSession(manager) {
+  const session = {
+    id: nameOfThatOutput(),
+    spec: specOfThatOutput(),
+    outputKey: "seeded",
+    state: "ready",
+    file: new SourceFile({ sourceKey: TORRENT, fileIndex: 0, name: "film.mkv" }),
+    timeline: new Timeline({ boundaries: [0, 4, 8], cutGrid: "keyframe" }),
+    runs: new Set(),
+    progress: { processedSeconds: 0, startPositionSeconds: 0, updatedAt: Date.now() },
+    lastAccessedAt: Date.now(),
+    // READY, because a joining viewer waits for the session to be able to
+    // answer them, and this file is about which session answers rather than
+    // about that wait. A session publishing its own playlist from the probed
+    // duration has nothing to wait for; left out, every check here would sit
+    // out the warm-up deadline and would be measuring that timer.
+    useSyntheticPlaylist: true
+  };
+  manager.outputs.set(session.id, session);
+  return session;
+}
+
+/**
+ * What the proxy already knows about the file when a second viewer arrives:
+ * what a probe said, and where its keyframes are.
+ *
+ * @param {object} manager
+ */
+function knownFile(manager) {
+  manager.getCachedMediaInfo = () => ({ durationSeconds: 8, width: 1920, height: 1080, fps: 24 });
+  manager.keyframeTables.learn({ sourceKey: TORRENT, fileIndex: 0 }, { times: [0, 4], format: "test" });
+}
+
+test("a second viewer of one output is served by the session that exists", async (t) => {
+  const manager = wireOutputs({
+    enabled: true,
+    ffmpegBin: "ffmpeg",
+    localBindHost: "127.0.0.1",
+    localPort: 9090
+  });
+  t.after(() => manager.lifecycle.disposeAll());
+  // No plan runs here: this file is about which session answers a request, and
+  // placing encoders would spawn real processes.
+  manager.encodeRuns.planEncodersNow = () => {};
+  manager.encodeRuns.planEncodersSoon = () => {};
+  knownFile(manager);
+  const seeded = seedOneSession(manager);
+
+  const answered = await manager.viewerRequests.createOrGetSession(request({ consumerId: "viewer-two" }));
+
+  assert.equal(answered, seeded, "one output, one session");
+  assert.ok(manager.viewers.forOutput(seeded).has("viewer-two"), "and the second viewer is on it");
+});
+
+test("a request whose parameters differ is not that session", async (t) => {
+  // The other half, and it is what makes the first mean anything: the name is
+  // the output's, so a request producing something else must not find it. Here
+  // the sound is to be re-encoded, which is a different output and a different
+  // set of bytes.
+  const manager = wireOutputs({
+    enabled: true,
+    ffmpegBin: "ffmpeg",
+    localBindHost: "127.0.0.1",
+    localPort: 9090,
+    // A session made for real here waits for a playlist that nothing is going
+    // to write. Zero, so this check spends no time on a deadline it is not
+    // about — the deadline has its own subject elsewhere.
+    startupWaitMs: 0
+  });
+  t.after(() => manager.lifecycle.disposeAll());
+  manager.encodeRuns.planEncodersNow = () => {};
+  manager.encodeRuns.planEncodersSoon = () => {};
+  const seeded = seedOneSession(manager);
+
+  let answered = null;
+  try {
+    answered = await manager.viewerRequests.createOrGetSession(request({ consumerId: "viewer-two", transcodeAudio: true }));
+  } catch {
+    // Making a session for real needs a probe and a disk, which this file does
+    // not give it. Failing there is the proof: it did not take the seeded one.
+    answered = null;
+  }
+
+  assert.notEqual(answered, seeded);
+  assert.ok(!manager.viewers.forOutput(seeded).has("viewer-two"), "and nobody was added to somebody else's output");
+});
+
+test("two screens that come to the same format share one output, and a different format does not", async (t) => {
+  const manager = wireOutputs({
+    enabled: true,
+    ffmpegBin: "ffmpeg",
+    localBindHost: "127.0.0.1",
+    localPort: 9090,
+    startupWaitMs: 0,
+    // A host with no ladder to choose from: the box asked for, fitted to the
+    // source, is what is produced.
+    videoEncoder: { kind: "vaapi", name: "h264_vaapi", inputArgs: [] }
+  });
+  t.after(() => manager.lifecycle.disposeAll());
+  manager.encodeRuns.planEncodersNow = () => {};
+  manager.encodeRuns.planEncodersSoon = () => {};
+  knownFile(manager);
+  const spec = new OutputSpec({
+    sourceKey: TORRENT,
+    segmentFormatId: "fmp4",
+    grid: new CutGrid({ kind: "uniform", fileIndex: 0 }),
+    video: new VideoOutput({
+      fileIndex: 0,
+      encode: { encoder: "h264_vaapi", width: 1920, height: 1080, fps: 24, preset: null, tonemap: false }
+    }),
+    audio: new AudioOutput({ fileIndex: 0, trackIndex: 0, transcode: false })
+  });
+  const seeded = { ...seedOneSession(manager), id: spec.toName(), spec, timeline: new Timeline({ boundaries: [0, 4, 8], cutGrid: "uniform" }) };
+  manager.outputs.delete(nameOfThatOutput());
+  manager.outputs.set(seeded.id, seeded);
+
+  // A taller window than the film: fitted to the source it is the same 1920x1080.
+  const joined = await manager.viewerRequests.createOrGetSession(
+    request({ consumerId: "tall-window", transcodeVideo: true, targetWidth: 1920, targetHeight: 1200 })
+  );
+  assert.equal(joined, seeded, "the key names the format produced, not the window it was asked for");
+
+  let other = null;
+  try {
+    other = await manager.viewerRequests.createOrGetSession(
+      request({ consumerId: "small-window", transcodeVideo: true, targetWidth: 1280, targetHeight: 720 })
+    );
+  } catch {
+    other = null;
+  }
+  assert.notEqual(other, seeded, "a smaller picture is another output");
+  assert.ok(!manager.viewers.forOutput(seeded).has("small-window"));
+});

package/test/{disk-space.test.js → one-resource-divided.test.js}

@@ -7,7 +7,7 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { DiskSpace } from "../services/disk/DiskSpace.js";
+import { MachineBudget } from "../services/storage/MachineBudget.js";
 
 const MEGABYTE = 1024 * 1024;
 
@@ -31,9 +31,29 @@ function consumerOf(name, held, wanted) {
   };
 }
 
+/**
+ * A budget over ONE resource, which is what this file is about: the division
+ * itself, with the several-resources question asked in `one-budget.test.js`.
+ *
+ * @param {{ readFree: () => Promise<number | null>, logger?: object }} params
+ */
+function diskOf({ readFree, logger }) {
+  const budget = new MachineBudget({ logger });
+  budget.defineResource({ name: "disk", readFree });
+  return {
+    register: (consumer) => budget.register({ ...consumer, resource: "disk" }),
+    forget: (name) => budget.forget(name),
+    describe: () => budget.describe(),
+    revise: async () => {
+      const readings = await budget.revise();
+      return readings.get("disk") ?? { freeBytes: 0, allowanceBytes: 0, shares: [] };
+    }
+  };
+}
+
 test("what everyone may hold together never exceeds what the disk has", async () => {
   const free = 100 * MEGABYTE;
-  const space = new DiskSpace({ readFree: async () => free });
+  const space = diskOf({ readFree: async () => free });
   const segments = consumerOf("segments", 10 * MEGABYTE, 1000 * MEGABYTE);
   const pieces = consumerOf("pieces", 20 * MEGABYTE, 1000 * MEGABYTE);
   const diagnostics = consumerOf("diagnostics", 5 * MEGABYTE, 1000 * MEGABYTE);
@@ -55,7 +75,7 @@ test("what everyone may hold together never exceeds what the disk has", async ()
 });
 
 test("when everyone's ask fits, everyone gets it and the disk never binds", async () => {
-  const space = new DiskSpace({ readFree: async () => 1000 * MEGABYTE });
+  const space = diskOf({ readFree: async () => 1000 * MEGABYTE });
   const small = consumerOf("diagnostics", 0, 5 * MEGABYTE);
   const large = consumerOf("segments", 0, 500 * MEGABYTE);
   space.register(small.consumer);
@@ -70,7 +90,7 @@ test("when everyone's ask fits, everyone gets it and the disk never binds", asyn
 test("when they do not fit, each is cut in proportion to what it asked", async () => {
   // The same rule memory divides by, and the same reason: a share taken from
   // whoever asked most would hand the disk to whoever grew fastest.
-  const space = new DiskSpace({ readFree: async () => 200 * MEGABYTE });
+  const space = diskOf({ readFree: async () => 200 * MEGABYTE });
   const modest = consumerOf("diagnostics", 0, 100 * MEGABYTE);
   const greedy = consumerOf("segments", 0, 300 * MEGABYTE);
   space.register(modest.consumer);
@@ -85,7 +105,7 @@ test("when they do not fit, each is cut in proportion to what it asked", async (
 
 test("a disk that fills lowers every share, rather than keeping one taken when it was empty", async () => {
   let free = 1000 * MEGABYTE;
-  const space = new DiskSpace({ readFree: async () => free });
+  const space = diskOf({ readFree: async () => free });
   const segments = consumerOf("segments", 0, 10_000 * MEGABYTE);
   const pieces = consumerOf("pieces", 0, 10_000 * MEGABYTE);
   space.register(segments.consumer);
@@ -106,7 +126,7 @@ test("what another process took is left for it, not spent", async () => {
   // That is a measurement of somebody else's demand, and it is what the next
   // allowance leaves alone.
   let free = 1000 * MEGABYTE;
-  const space = new DiskSpace({ readFree: async () => free });
+  const space = diskOf({ readFree: async () => free });
   const only = consumerOf("segments", 0, 10_000 * MEGABYTE);
   space.register(only.consumer);
 
@@ -118,7 +138,7 @@ test("what another process took is left for it, not spent", async () => {
 });
 
 test("a disk that cannot be read allows nothing to grow", async () => {
-  const space = new DiskSpace({ readFree: async () => null });
+  const space = diskOf({ readFree: async () => null });
   const segments = consumerOf("segments", 0, 500 * MEGABYTE);
   space.register(segments.consumer);
 
@@ -130,7 +150,7 @@ test("a disk that cannot be read allows nothing to grow", async () => {
 });
 
 test("it says what the disk has and what each claimant may hold", async () => {
-  const space = new DiskSpace({ readFree: async () => 100 * MEGABYTE });
+  const space = diskOf({ readFree: async () => 100 * MEGABYTE });
   assert.match(space.describe(), /nothing has claimed/);
   space.register(consumerOf("segments", 4 * MEGABYTE, 8 * MEGABYTE).consumer);
   await space.revise();
@@ -139,7 +159,7 @@ test("it says what the disk has and what each claimant may hold", async () => {
 
 test("it says what it decided, every pass", async () => {
   const lines = [];
-  const space = new DiskSpace({
+  const space = diskOf({
     readFree: async () => 100 * MEGABYTE,
     logger: { info: (line) => lines.push(line) }
   });
@@ -154,7 +174,7 @@ test("the free space is read from the nearest directory that exists", async () =
   // when the proxy stops, so at every start `statfs` on it fails. Field
   // 2026-09-10: the first reading said `disk: 0MB free` on a host with 103 GB,
   // and zero means "no room" to everything that reads it.
-  const { freeBytesFor } = await import("../services/disk/free.js");
+  const { freeBytesFor } = await import("../services/storage/free.js");
   const os = await import("node:os");
   const path = await import("node:path");
   const missing = path.join(os.tmpdir(), "no-such-directory-here", "nor-here");