@torrent-tv/proxy 2.86.0 → 2.87.0

package/test/failed-start-breaker.test.js

@@ -29,11 +29,12 @@ import assert from "node:assert/strict";
 import { mkdtempSync, rmSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { HlsSessionManager } from "../services/hls-session-manager.js";
-import { SourceFile } from "../services/source/SourceFile.js";
+import { wireOutputs } from "../services/server/wire-outputs.js";
+import { SourceFile } from "../services/media/SourceFile.js";
 import { ENCODE_EXIT } from "../services/encode/encode-exit.js";
+import { outputSpec } from "./helpers/output-spec.js";
 
-const SESSION_ID = "cccccccc-0000-4000-8000-000000000001";
+const SESSION_ID = "cccccccc00004000";
 
 /**
  * A session with one run in it, shaped as the manager expects.
@@ -45,19 +46,13 @@ function sessionWithARun(dirPath) {
   const run = { from: 0, to: -1, argsDescribed: "ffmpeg …", state: "ENDED_FAILED" };
   const session = {
     id: SESSION_ID,
+    spec: outputSpec({ transcodeVideo: false }),
     dirPath,
     state: "live",
     file: new SourceFile({ sourceKey: "source-1", fileIndex: 0, name: "video.mkv" }),
     get inputFile() { return this.file; },
     get audioFile() { return this.file; },
     outputKey: "output-under-test",
-    consumers: new Set(["someone"]),
-    viewers: new Map(),
-    runs: new Set([run]),
-    transcodeVideo: false,
-    failedStartAt: -1,
-    failedStartCount: 0,
-    lastError: "",
     lastRequestedSegment: 0,
     progress: { updatedAt: 0, processedSeconds: 0, totalSeconds: 100, startPositionSeconds: 0 },
     lastAccessedAt: Date.now()
@@ -87,65 +82,121 @@ function failedFast(run, from) {
 test("a run that ended is still recognised as the session's own", (t) => {
   const dirPath = mkdtempSync(path.join(os.tmpdir(), "breaker-"));
   t.after(() => rmSync(dirPath, { recursive: true, force: true }));
-  const manager = new HlsSessionManager({
+  const manager = wireOutputs({
     enabled: true,
     ffmpegBin: "ffmpeg",
     localBindHost: "127.0.0.1",
     localPort: 9090
   });
   const { session, run } = sessionWithARun(dirPath);
-  manager.sessionsById.set(SESSION_ID, session);
+  manager.outputs.set(SESSION_ID, session);
+  manager.encodeOrchestrator.adopt(session.outputKey, run);
 
-  manager.noteRunEnded(session, run, failedFast(run, 0));
+  manager.encodeRuns.noteRunEnded(session, run, failedFast(run, 0));
 
   // If the identity were read after the removal, nothing here would have been
   // written: the handler would have returned at its second line.
-  assert.equal(session.failedStartCount, 1, "the failure was counted");
-  assert.equal(session.failedStartAt, 0, "at the position it happened");
-  assert.ok(session.lastError.length > 0, "and the session knows what went wrong");
+  assert.equal(manager.encodeOrchestrator.startFailureOf(session.outputKey).count, 1, "the failure was counted");
+  assert.equal(manager.encodeOrchestrator.startFailureOf(session.outputKey).at, 0, "at the position it happened");
+  assert.ok(manager.encodeOrchestrator.errorOf(session.outputKey).length > 0, "and the encoding owner knows what went wrong");
+  assert.equal(
+    manager.encodeOrchestrator.stateOf(session.outputKey),
+    "ENDED_FAILED",
+    "the ending remains observable after the ended run leaves the registry"
+  );
 });
 
 test("the count runs at segment 0, which is where a first start happens", (t) => {
   const dirPath = mkdtempSync(path.join(os.tmpdir(), "breaker-"));
   t.after(() => rmSync(dirPath, { recursive: true, force: true }));
-  const manager = new HlsSessionManager({
+  const manager = wireOutputs({
     enabled: true,
     ffmpegBin: "ffmpeg",
     localBindHost: "127.0.0.1",
     localPort: 9090
   });
   const { session } = sessionWithARun(dirPath);
-  manager.sessionsById.set(SESSION_ID, session);
+  manager.outputs.set(SESSION_ID, session);
 
   for (let attempt = 1; attempt <= 3; attempt += 1) {
     const run = { from: 0, to: -1, argsDescribed: "ffmpeg …" };
-    session.runs.add(run);
-    manager.noteRunEnded(session, run, failedFast(run, 0));
-    assert.equal(session.failedStartCount, attempt);
+    manager.encodeOrchestrator.adopt(session.outputKey, run);
+    manager.encodeRuns.noteRunEnded(session, run, failedFast(run, 0));
+    assert.equal(manager.encodeOrchestrator.startFailureOf(session.outputKey).count, attempt);
+    assert.equal(manager.encodeOrchestrator.mayStartAt(session.outputKey, 0), attempt < 3);
   }
+  assert.equal(manager.encodeOrchestrator.mayStartAt(session.outputKey, 1), true, "another position has its own budget");
 });
 
 test("real work resets the count, so a transient failure is not permanent", (t) => {
   const dirPath = mkdtempSync(path.join(os.tmpdir(), "breaker-"));
   t.after(() => rmSync(dirPath, { recursive: true, force: true }));
-  const manager = new HlsSessionManager({
+  const manager = wireOutputs({
     enabled: true,
     ffmpegBin: "ffmpeg",
     localBindHost: "127.0.0.1",
     localPort: 9090
   });
   const { session } = sessionWithARun(dirPath);
-  manager.sessionsById.set(SESSION_ID, session);
+  manager.outputs.set(SESSION_ID, session);
 
   const quick = { from: 0, to: -1 };
-  session.runs.add(quick);
-  manager.noteRunEnded(session, quick, failedFast(quick, 0));
-  assert.equal(session.failedStartCount, 1);
+  manager.encodeOrchestrator.adopt(session.outputKey, quick);
+  manager.encodeRuns.noteRunEnded(session, quick, failedFast(quick, 0));
+  assert.equal(manager.encodeOrchestrator.startFailureOf(session.outputKey).count, 1);
 
   const lived = { from: 0, to: -1 };
-  session.runs.add(lived);
-  manager.noteRunEnded(session, lived, { ...failedFast(lived, 0), livedMs: 30_000 });
+  manager.encodeOrchestrator.adopt(session.outputKey, lived);
+  manager.encodeRuns.noteRunEnded(session, lived, { ...failedFast(lived, 0), livedMs: 30_000 });
 
-  assert.equal(session.failedStartCount, 0, "a run that did real work is not a failing start");
-  assert.equal(session.failedStartAt, -1);
+  assert.equal(manager.encodeOrchestrator.startFailureOf(session.outputKey).count, 0, "a run that did real work is not a failing start");
+  assert.equal(manager.encodeOrchestrator.startFailureOf(session.outputKey).at, -1);
+});
+
+test("a failure belongs to the output it happened on, not to the next output of the same address", async (t) => {
+  const dirPath = mkdtempSync(path.join(os.tmpdir(), "breaker-"));
+  t.after(() => rmSync(dirPath, { recursive: true, force: true }));
+  const manager = wireOutputs({
+    enabled: true,
+    ffmpegBin: "ffmpeg",
+    localBindHost: "127.0.0.1",
+    localPort: 9090
+  });
+  t.after(() => manager.lifecycle.disposeAll());
+  const { session } = sessionWithARun(dirPath);
+  manager.outputs.set(SESSION_ID, session);
+  for (let attempt = 1; attempt <= 3; attempt += 1) {
+    const run = { from: 0, to: -1, argsDescribed: "ffmpeg …" };
+    manager.encodeOrchestrator.adopt(session.outputKey, run);
+    manager.encodeRuns.noteRunEnded(session, run, failedFast(run, 0));
+  }
+  assert.equal(manager.encodeOrchestrator.mayStartAt(session.outputKey, 0), false, "the first output is blocked");
+
+  await manager.lifecycle.disposeSession(SESSION_ID);
+
+  // The same parameters opened again: the name follows from the key, so the
+  // new output has the same address. What failed on the disposed one is not a
+  // fact about this one — a viewer arriving is new information.
+  assert.equal(manager.encodeOrchestrator.stateOf(session.outputKey), "IDLE", "no ending is inherited");
+  assert.equal(manager.encodeOrchestrator.errorOf(session.outputKey), "", "no error is inherited");
+  assert.equal(manager.encodeOrchestrator.mayStartAt(session.outputKey, 0), true, "no blocked position is inherited");
+});
+
+test("a run ending after its output was disposed leaves nothing behind for the next output", (t) => {
+  const dirPath = mkdtempSync(path.join(os.tmpdir(), "breaker-"));
+  t.after(() => rmSync(dirPath, { recursive: true, force: true }));
+  const manager = wireOutputs({
+    enabled: true,
+    ffmpegBin: "ffmpeg",
+    localBindHost: "127.0.0.1",
+    localPort: 9090
+  });
+  const { session, run } = sessionWithARun(dirPath);
+  manager.encodeOrchestrator.adopt(session.outputKey, run);
+  // Disposal removed the output from the registry; its process ends later.
+  manager.encodeRuns.noteRunEnded(session, run, failedFast(run, 0));
+
+  assert.equal(manager.encodeOrchestrator.stateOf(session.outputKey), "IDLE");
+  assert.equal(manager.encodeOrchestrator.errorOf(session.outputKey), "");
+  assert.equal(manager.encodeOrchestrator.startFailureOf(session.outputKey).count, 0);
 });

package/test/fastest-wires.test.js

@@ -10,7 +10,7 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 
-import { askFastestWiresFor, canPlaceRequests, wiresForPiece } from "../services/torrent-worker/fastest-wires.js";
+import { askFastestWiresFor, canPlaceRequests, wiresForPiece } from "../services/torrent/worker/fastest-wires.js";
 
 /**
  * @param {{ speed: number, has?: boolean, choking?: boolean, destroyed?: boolean }} options

package/test/ffmpeg-stream-counts.test.js

@@ -11,7 +11,7 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 
-import { parseFfmpegStreamCounts } from "../services/ffmpeg-banner.js";
+import { parseFfmpegStreamCounts } from "../services/media/ffmpeg-banner.js";
 
 const FIELD_BANNER = `
 Input #0, matroska,webm, from 'http://127.0.0.1:9090/stream?sourceKey=b3f08efc':

package/test/file-edges.test.js

@@ -15,9 +15,9 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { TorrentPool, stateFileEdges, withdrawFileEdges } from "../services/torrent-pool.js";
-import { demandFor, forgetTorrent } from "../services/download/registry.js";
-import { Urgency } from "../services/demand/index.js";
+import { TorrentPool, stateFileEdges, withdrawFileEdges } from "../services/torrent/torrent-pool.js";
+import { demandFor, forgetTorrent } from "../services/torrent/download/registry.js";
+import { Urgency } from "../services/torrent/demand/index.js";
 
 /** A torrent of two files, of which the second is the film. */
 function torrentOf({ length = 1_000_000 } = {}) {

package/test/fmp4-self-contained.test.js

@@ -11,7 +11,7 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { fmp4Format } from "../services/segment-formats/fmp4.js";
+import { fmp4Format } from "../services/encode/segment-formats/fmp4.js";
 
 /**
  * A piece shaped like the muxer's output. Sizes are what matters, not contents.

package/test/fmp4-timestamps.test.js

@@ -10,7 +10,7 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { stampSegmentStartTime } from "../services/segment-formats/mp4-boxes.js";
+import { stampSegmentStartTime } from "../services/encode/segment-formats/mp4-boxes.js";
 
 /**
  * @param {string} type

package/test/fmp4-track-completeness.test.js

@@ -12,7 +12,7 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { fmp4Format } from "../services/segment-formats/fmp4.js";
+import { fmp4Format } from "../services/encode/segment-formats/fmp4.js";
 // Build a minimal init declaring two tracks, and fragments declaring one/two.
 function box(type, body) {
   const b = Buffer.alloc(8 + body.length);

package/test/format-keyed-outputs.test.js

@@ -0,0 +1,78 @@
+/**
+ * @file An output is named by the format it produces, and nothing may put
+ * pieces of another format under that name.
+ *
+ * Two ways that could still happen once the name became the format: a
+ * directory left by an earlier version, whose key named the box a viewer asked
+ * for and so cannot say what format is inside; and a hardware encoder failing,
+ * after which the proxy encodes with software while outputs named by the failed
+ * encoder are still being watched.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { existsSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { managerWithOwnStore } from "./helpers/manager.js";
+import { outputSpec } from "./helpers/output-spec.js";
+import { ENCODE_EXIT } from "../services/encode/encode-exit.js";
+import { SourceFile } from "../services/media/SourceFile.js";
+
+test("a directory whose key names an asked-for box is not adopted, and one naming a format is", (t) => {
+  const { store, root, manager, cleanup } = managerWithOwnStore();
+  t.after(cleanup);
+  const oldKey = "torrent:abc:fmt=fmp4:grid=even@0:video-only:v=0/enc:1280x720:budget";
+  const newKey = outputSpec({ sourceKey: "torrent:abc", transcodeVideo: true, width: 1280, height: 720, audioSeparate: true }).toKey();
+  const oldDir = store.directoryFor(oldKey);
+  const newDir = store.directoryFor(newKey);
+  writeFileSync(path.join(oldDir, "segment-00000.mp4"), Buffer.alloc(10));
+  writeFileSync(path.join(newDir, "segment-00000.mp4"), Buffer.alloc(10));
+
+  const result = manager.lifecycle.adoptSegmentsLeftBehind();
+
+  assert.equal(result.adopted, 1);
+  assert.equal(result.dropped, 1);
+  assert.equal(existsSync(oldDir), false, "the old directory goes");
+  assert.equal(existsSync(newDir), true, "the named format stays");
+  assert.ok(root);
+});
+
+test("when a hardware encoder fails, the outputs it named are closed rather than continued by software", async (t) => {
+  const { manager, cleanup } = managerWithOwnStore({
+    videoEncoder: { kind: "vaapi", name: "h264_vaapi", inputArgs: [] }
+  });
+  t.after(async () => {
+    await manager.lifecycle.disposeAll();
+    cleanup();
+  });
+  manager.encodeRuns.planEncodersNow = () => {};
+  manager.encodeRuns.planEncodersSoon = () => {};
+  const file = new SourceFile({ sourceKey: "torrent:abc", fileIndex: 0, name: "film.mkv" });
+  const record = (id, encoder) => {
+    const spec = outputSpec({ sourceKey: "torrent:abc", transcodeVideo: true, width: 1280, height: 720, encoder });
+    const output = { id, spec, get outputKey() { return this.spec.toKey(); }, file };
+    manager.outputs.set(id, output);
+    return output;
+  };
+  const failing = record("aaaaaaaa00000001", "h264_vaapi");
+  const software = record("aaaaaaaa00000002", "libx264");
+  const run = { from: 0, to: -1, argsDescribed: "ffmpeg …" };
+  manager.encodeOrchestrator.adopt(failing.outputKey, run);
+
+  manager.encodeRuns.noteRunEnded(failing, run, {
+    address: failing.outputKey,
+    run,
+    ending: ENCODE_EXIT.FAILED,
+    from: 0,
+    to: -1,
+    livedMs: 30_000,
+    because: "vaapi failed",
+    lastError: "vaapi failed",
+    producedCount: 3
+  });
+  await new Promise((resolve) => setImmediate(resolve));
+
+  assert.equal(manager.videoEncoder.kind, "software");
+  assert.equal(manager.outputs.has(failing.id), false, "an output of the failed encoder is closed");
+  assert.equal(manager.outputs.has(software.id), true, "an output of another encoder is untouched");
+});

package/test/health-metrics.test.js

@@ -6,7 +6,8 @@ import test from "node:test";
 import assert from "node:assert/strict";
 import os from "node:os";
 
-import { availableMemoryBytes, collectHealthMetrics } from "../services/health-collector.js";
+import { collectHealthMetrics } from "../services/transport/health-collector.js";
+import { availableMemoryBytes } from "../services/storage/machine-memory.js";
 
 test("free memory is what could be given out, not what is idle this instant", () => {
   const available = availableMemoryBytes();
@@ -27,7 +28,7 @@ test("free memory is what could be given out, not what is idle this instant", ()
 });
 
 test("the health report is three bounded numbers", () => {
-  const metrics = collectHealthMetrics();
+  const metrics = collectHealthMetrics({ availableMemoryBytes });
   assert.ok(metrics.cpuLoad >= 0);
   assert.ok(metrics.memFree > 0 && metrics.memFree <= 1);
   assert.ok(Number.isInteger(metrics.uptime) && metrics.uptime >= 0);

package/test/held-request-width.test.js

@@ -11,23 +11,22 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { Timeline } from "../services/output/Timeline.js";
+import { Timeline } from "../services/encode/output/Timeline.js";
 import { mkdtemp, rm } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { HlsSessionManager } from "../services/hls-session-manager.js";
-import { fmp4Format } from "../services/segment-formats/fmp4.js";
-import { viewerOf } from "../services/viewer/Viewer.js";
+import { wireOutputs } from "../services/server/wire-outputs.js";
+import { fmp4Format } from "../services/encode/segment-formats/fmp4.js";
 
-const SESSION_ID = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee";
+const SESSION_ID = "aaaaaaaabbbbcccc";
 const SEGMENT_SECONDS = 4;
 
 /**
- * @returns {Promise<{ manager: HlsSessionManager, dirPath: string }>}
+ * @returns {Promise<{ manager: object, dirPath: string }>}
  */
 async function managerWithSession() {
   const dirPath = await mkdtemp(path.join(os.tmpdir(), "held-request-"));
-  const manager = new HlsSessionManager({
+  const manager = wireOutputs({
     enabled: true,
     ffmpegBin: "ffmpeg",
     localBindHost: "127.0.0.1",
@@ -47,10 +46,10 @@ async function managerWithSession() {
     segmentCount: 200,
     useSyntheticPlaylist: true
   };
-  manager.sessionsById.set(SESSION_ID, session);
+  manager.outputs.set(SESSION_ID, session);
   // The viewer is at segment #25, and says so themselves.
-  viewerOf(session, "").moveTo(25 * SEGMENT_SECONDS);
-  viewerOf(session, "").playing = false;
+  manager.viewers.of(session, "viewer").moveTo(25 * SEGMENT_SECONDS);
+  manager.viewers.of(session, "viewer").playing = false;
   return { manager, dirPath };
 }
 
@@ -70,9 +69,9 @@ test("the width is the encoder's own look-ahead, in segments", async (t) => {
 
   const width = Math.ceil(manager.lookaheadSeconds / manager.segmentDurationSec);
   assert.equal(width, 30, "120 s of look-ahead over 4 s segments");
-  assert.equal(manager.requestStillWanted(SESSION_ID, segment(25 + width)), true, "the far edge");
+  assert.equal(manager.serving.requestStillWanted(SESSION_ID, segment(25 + width)), true, "the far edge");
   assert.equal(
-    manager.requestStillWanted(SESSION_ID, segment(25 + width + 1)),
+    manager.serving.requestStillWanted(SESSION_ID, segment(25 + width + 1)),
     false,
     "past everything the encoder is allowed to have produced"
   );
@@ -87,7 +86,7 @@ test("a request the old eight-segment width would have refused is kept", async (
   // #34 is nine segments ahead of the viewer — inside a 120 s cushion and
   // outside the eight the width used to be. This is the request a browser
   // holding the whole cushion makes constantly.
-  assert.equal(manager.requestStillWanted(SESSION_ID, segment(34)), true);
+  assert.equal(manager.serving.requestStillWanted(SESSION_ID, segment(34)), true);
 });
 
 test("a segment behind the viewer is still released", async (t) => {
@@ -96,7 +95,7 @@ test("a segment behind the viewer is still released", async (t) => {
     await rm(dirPath, { recursive: true, force: true });
   });
 
-  assert.equal(manager.requestStillWanted(SESSION_ID, segment(24)), false);
+  assert.equal(manager.serving.requestStillWanted(SESSION_ID, segment(24)), false);
 });
 
 test("a seek by one viewer does not release the request held for another", async (t) => {
@@ -108,8 +107,8 @@ test("a seek by one viewer does not release the request held for another", async
   // One is at segment #25, the other far ahead at #150 — inside the fixture's
   // own 200-segment timeline, since a position past the end of the grid is
   // clamped to it and would prove nothing about the width.
-  manager.requestSeek(SESSION_ID, 100, "behind");
-  manager.requestSeek(SESSION_ID, 600, "ahead");
+  manager.viewerRequests.requestSeek(SESSION_ID, 100, "behind");
+  manager.viewerRequests.requestSeek(SESSION_ID, 600, "ahead");
 
   // A SEEK DOES ONE THING: it puts the viewer where they now are. It used to
   // write that position into five places, this session's shared field among
@@ -120,12 +119,12 @@ test("a seek by one viewer does not release the request held for another", async
   assert.equal(manager.viewers.get("ahead").positionSeconds(), 600);
 
   assert.equal(
-    manager.requestStillWanted(SESSION_ID, segment(26), "behind"),
+    manager.serving.requestStillWanted(SESSION_ID, segment(26), "behind"),
     true,
     "the segment the viewer behind is waiting for is still theirs to wait for"
   );
   assert.equal(
-    manager.requestStillWanted(SESSION_ID, segment(26), "ahead"),
+    manager.serving.requestStillWanted(SESSION_ID, segment(26), "ahead"),
     false,
     "and for the one in front it is a place they have left"
   );
@@ -140,9 +139,9 @@ test("a viewer's own head moves with their seek", async (t) => {
   // Their last request was at #25; they jump to 600 s, which is #150. The
   // segment at the target must be wanted — refusing it there is the freeze of
   // 2026-08-18.
-  manager.requestSeek(SESSION_ID, 600, "viewer");
-  assert.equal(manager.requestStillWanted(SESSION_ID, segment(150), "viewer"), true);
-  assert.equal(manager.requestStillWanted(SESSION_ID, segment(25), "viewer"), false);
+  manager.viewerRequests.requestSeek(SESSION_ID, 600, "viewer");
+  assert.equal(manager.serving.requestStillWanted(SESSION_ID, segment(150), "viewer"), true);
+  assert.equal(manager.serving.requestStillWanted(SESSION_ID, segment(25), "viewer"), false);
 });
 
 test("a viewer nobody can name is judged against the one shared position", async (t) => {
@@ -153,6 +152,6 @@ test("a viewer nobody can name is judged against the one shared position", async
 
   // A plain HTTP transport builds its own URLs and carries no id. The old
   // behaviour is what remains, which for a single viewer is the same thing.
-  assert.equal(manager.requestStillWanted(SESSION_ID, segment(26), ""), true);
-  assert.equal(manager.requestStillWanted(SESSION_ID, segment(24), ""), false);
+  assert.equal(manager.serving.requestStillWanted(SESSION_ID, segment(26), ""), true);
+  assert.equal(manager.serving.requestStillWanted(SESSION_ID, segment(24), ""), false);
 });