@torrent-tv/proxy 2.80.17 → 2.80.19

package/services/encode/open-piece.js

@@ -1,135 +0,0 @@
-/**
- * @file The piece a run had open when it ended.
- *
- * A fact of a run's output directory, and therefore of the encoding layer. It
- * lived in the eleven-thousand-line file that is being taken apart, where it was
- * called by the one place that killed a run; stopping is decided in one place
- * now and carried out in another, so the cleanup belongs to the layer that owns
- * the directories rather than to whoever happened to do the killing.
- */
-
-import { readdir, readFile, stat, unlink } from "node:fs/promises";
-import path from "node:path";
-
-/**
- * Remove the piece a run had open when it ended, if that piece is unusable.
- *
- * The `segment` muxer creates its output file when it OPENS it and writes into
- * it until the next cut, so at any instant exactly one file in a run's
- * directory is unfinished: the highest-numbered one. A run that reaches the end
- * of its work closes that file and it is a good piece; a run killed for a seek
- * does not — measured 2026-09-03, ffmpeg exited 19 ms after SIGTERM and left
- * `segment-00025.mp4` at zero bytes, which then closed the only hole in the
- * numbering and convinced the look-ahead to keep the encoder stopped for having
- * "produced" it.
- *
- * **A piece is whole only if the run PROVED it, and reading it proves nothing.**
- *
- * The highest-numbered file in a run's stretch is the one it had open. How a
- * run ends decides what became of that file, and all three outcomes leave it
- * readable-looking: stopped with SIGTERM, ffmpeg writes it out and names it on
- * the ready channel exactly as it names a finished one; killed harder, or dying
- * on its own, it leaves the bytes it had written with no name at all. In every
- * case the file decodes and holds film only up to the instant the run ended,
- * under a number whose playlist entry promises a whole span. Field 2026-09-06:
- * `segment-00010.mp4` held 3.92 s of its declared 5.589 s — 96 frames — and the
- * picture jumped 1.5 s at 1:02; the soundtrack did the same at 17.5 s, 2.8 s
- * wide, in the same session. Both decoded, which is how both reached the viewer.
- *
- * So the question asked here is not what the file contains but whether the run
- * named it while it was still running normally. That is a fact the run holds,
- * so there is no span to measure and no tolerance to choose.
- *
- * A piece finished in the moment between the last such name and the end is
- * then made a second time. That is the cheaper error: the other is a hole the
- * viewer sees.
- *
- * @param {string | null | undefined} runDirPath
- * @param {{ isSegmentFileName: (name: string) => boolean, segmentIndexFromName: (name: string) => number }} segmentFormat
- * @param {((raw: Buffer) => boolean) | null} judgeUsable - Whether a non-empty
- *   piece carries what it should. Null where nothing can say, and then only an
- *   empty file is removed.
- * @param {string | null} [provenName] - The last piece the run named while it
- *   was running normally. A file beyond it was open when the run ended and goes
- *   whether or not it reads. Null where the run proved nothing, and then every
- *   piece it left is unproven.
- * @returns {Promise<number | null>} The segment number removed, or null.
- */
-export async function discardOpenPiece(runDirPath, segmentFormat, within, judgeUsable, provenName = null) {
-  if (!runDirPath || typeof segmentFormat?.isSegmentFileName !== "function") {
-    return null;
-  }
-  // Only inside the stretch the ended run was given. Every run of an output
-  // writes into one directory now — they are kept apart by their intervals
-  // rather than by a directory each — so the highest-numbered file in there may
-  // belong to a run that is still going, and removing it would take away a
-  // piece somebody is producing.
-  const from = Number.isInteger(within?.from) ? within.from : 0;
-  // THE RUN'S OWN REACH, which is a fact it holds and needs nothing measured.
-  //
-  // A run cannot have opened a file above the one just past the last it named:
-  // ffmpeg names a piece when it closes it and opens the next, so the open piece
-  // is at most `proven + 1`, and where it named nothing at all the open one is
-  // the first it was given.
-  //
-  // Used only where no end was declared — `to` below `from`, which is how "to
-  // the end of the track" is written everywhere here. Such a run had no bound at
-  // all: the search covered the whole directory and took the highest-numbered
-  // file in it. Every run of an output writes into that one
-  // directory, so what it took was a piece a LIVE run had just finished. Field
-  // 2026-09-06: the piece holding 2:47-2:57 went that way, its number is spent
-  // for good because names only grow, and the picture stood still for 647 s.
-  const provenIndex = typeof provenName === "string" && segmentFormat.isSegmentFileName(provenName)
-    ? segmentFormat.segmentIndexFromName(provenName)
-    : null;
-  const reach = Number.isInteger(provenIndex) && provenIndex >= from ? provenIndex + 1 : from;
-  // The declared end is the bound wherever there is one. The run's own reach is
-  // the bound of LAST RESORT, for a run given none: before it, such a run had no
-  // bound at all and the search covered the whole directory.
-  const to = Number.isInteger(within?.to) && within.to >= from ? within.to : reach;
-  let highest = null;
-  try {
-    for (const name of await readdir(runDirPath)) {
-      if (!segmentFormat.isSegmentFileName(name)) {
-        continue;
-      }
-      const index = segmentFormat.segmentIndexFromName(name);
-      if (index < from || index > to) {
-        continue;
-      }
-      if (index >= 0 && (highest === null || index > highest.index)) {
-        highest = { index, name };
-      }
-    }
-  } catch {
-    return null; // The run wrote nothing, or its directory is already gone.
-  }
-  if (highest === null) {
-    return null;
-  }
-  const filePath = path.join(runDirPath, highest.name);
-  // Proven finished only if the run said so while it was running. Anything
-  // beyond that name was open when the run ended, and its contents cannot say
-  // so — it decodes.
-  const proven = typeof provenName === "string" && provenName === highest.name;
-  let unusable = !proven;
-  try {
-    const info = await stat(filePath);
-    if (info.size === 0) {
-      unusable = true;
-    } else if (!unusable && typeof judgeUsable === "function") {
-      unusable = !judgeUsable(await readFile(filePath));
-    }
-  } catch {
-    return null; // Gone between the listing and the question.
-  }
-  if (!unusable) {
-    return null;
-  }
-  try {
-    await unlink(filePath);
-    return highest.index;
-  } catch {
-    return null; // Already removed.
-  }
-}

package/test/open-piece.test.js

@@ -1,152 +0,0 @@
-/**
- * @file The piece a run had open when it ended, and what proves one whole.
- *
- * `-segment_list pipe:3` was taken as proof: ffmpeg names a file when it closes
- * it, so a named file is closed. True of the FILE and false of the SPAN. The
- * highest-numbered file in a run's stretch is the one it had open, and how the
- * run ended decides what became of it — stopped with SIGTERM, ffmpeg writes it
- * out and names it exactly as it names a finished one; killed harder, or dying
- * on its own, it leaves the bytes it had written. All three outcomes decode,
- * and all three hold film only up to the instant the run ended.
- *
- * Field 2026-09-06, one session, both tracks: `segment-00010.mp4` held 3.92 s
- * of its declared 5.589 s (96 frames), and the picture jumped 1.5 s at 1:02;
- * the soundtrack's own stopped run left the same shape at 17.5 s, 2.8 s wide.
- * Judging such a file by whether it decodes answers yes, which is how both
- * reached the viewer.
- *
- * So what is kept is what the run PROVED it finished: the last piece it named
- * while it was still running normally.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { existsSync } from "node:fs";
-import { mkdtemp, rm, writeFile, readdir } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { discardOpenPiece } from "../services/encode/open-piece.js";
-
-const format = {
-  isSegmentFileName: (name) => /^segment-\d{5}\.mp4$/.test(name),
-  segmentIndexFromName: (name) => Number(name.slice(8, 13))
-};
-
-/** A run directory holding pieces 0..last, every one of them readable. */
-async function runDirectory(last) {
-  const dir = await mkdtemp(path.join(os.tmpdir(), "open-piece-"));
-  for (let index = 0; index <= last; index += 1) {
-    await writeFile(path.join(dir, `segment-${String(index).padStart(5, "0")}.mp4`), Buffer.alloc(64, 7));
-  }
-  return dir;
-}
-
-test("the piece written out on the way to being stopped goes, though it reads", async () => {
-  // The field case: ffmpeg named #10 while shutting down, so #9 is the last it
-  // proved. Everything decodes, and nothing about #10's contents betrays it.
-  const dir = await runDirectory(10);
-  try {
-    const removed = await discardOpenPiece(
-      dir, format, { from: 0, to: 535 }, () => true, "segment-00009.mp4"
-    );
-    assert.equal(removed, 10, "the open piece was kept because it decodes");
-    const left = await readdir(dir);
-    assert.ok(!left.includes("segment-00010.mp4"));
-    assert.ok(left.includes("segment-00009.mp4"), "a piece the run proved was taken too");
-  } finally {
-    await rm(dir, { recursive: true, force: true });
-  }
-});
-
-test("a piece the run never named goes too, however it was killed", async () => {
-  // Killed harder than SIGTERM, or dead on its own: the open piece is left
-  // half-written and unnamed. It still decodes, and it is still short.
-  const dir = await runDirectory(10);
-  try {
-    const removed = await discardOpenPiece(
-      dir, format, { from: 0, to: 535 }, () => true, "segment-00009.mp4"
-    );
-    assert.equal(removed, 10);
-  } finally {
-    await rm(dir, { recursive: true, force: true });
-  }
-});
-
-test("the piece the run proved finished stays", async () => {
-  // A run stopped in the moment after closing #10 and before opening #11
-  // proved #10. Removing it would mean encoding it a second time for nothing.
-  const dir = await runDirectory(10);
-  try {
-    const removed = await discardOpenPiece(
-      dir, format, { from: 0, to: 535 }, () => true, "segment-00010.mp4"
-    );
-    assert.equal(removed, null);
-    assert.ok((await readdir(dir)).includes("segment-00010.mp4"));
-  } finally {
-    await rm(dir, { recursive: true, force: true });
-  }
-});
-
-test("a run that proved nothing keeps nothing", async () => {
-  const dir = await runDirectory(3);
-  try {
-    const removed = await discardOpenPiece(dir, format, { from: 0, to: 535 }, () => true, null);
-    assert.equal(removed, 3, "a run that named nothing had its last piece believed");
-  } finally {
-    await rm(dir, { recursive: true, force: true });
-  }
-});
-
-test("only inside the stretch the ended run was given", async () => {
-  // Several runs write into one directory, kept apart by their intervals. The
-  // highest file overall may belong to a run that is still going.
-  const dir = await runDirectory(20);
-  try {
-    const removed = await discardOpenPiece(
-      dir, format, { from: 0, to: 10 }, () => true, "segment-00009.mp4"
-    );
-    assert.equal(removed, 10);
-    assert.ok((await readdir(dir)).includes("segment-00020.mp4"), "another run's piece was taken");
-  } finally {
-    await rm(dir, { recursive: true, force: true });
-  }
-});
-
-test("a run given no end never reaches past what it made, so a live run's piece is safe", async () => {
-  // Field 2026-09-06. Three encoders wrote into one directory; the first was
-  // stopped, its stretch was `#0..#-1` — "to the end of the track" — and the
-  // cleanup after it took the highest-numbered file anywhere in that directory,
-  // which a LIVE encoder had just finished. The number is spent for good,
-  // because names only grow, and the picture stood still for 647 seconds.
-  const dir = await mkdtemp(path.join(os.tmpdir(), "open-piece-"));
-  // What the stopped run made: #0 and #1, with #2 left open.
-  await writeFile(path.join(dir, "segment-00000.mp4"), Buffer.alloc(1000, 1));
-  await writeFile(path.join(dir, "segment-00001.mp4"), Buffer.alloc(1000, 1));
-  await writeFile(path.join(dir, "segment-00002.mp4"), Buffer.alloc(0));
-  // What a live encoder, working further along the same track, has finished.
-  await writeFile(path.join(dir, "segment-00040.mp4"), Buffer.alloc(9000, 1));
-
-  const removed = await discardOpenPiece(
-    dir,
-    format,
-    { from: 0, to: -1 },
-    null,
-    "segment-00001.mp4"
-  );
-
-  assert.equal(removed, 2, "its own open piece goes");
-  assert.ok(existsSync(path.join(dir, "segment-00040.mp4")), "the live run's piece stays");
-});
-
-test("a run that named nothing leaves only its own first piece", async () => {
-  // It opened one file and died — 548 ms after starting, in the field. Nothing
-  // above that can be its.
-  const dir = await mkdtemp(path.join(os.tmpdir(), "open-piece-"));
-  await writeFile(path.join(dir, "segment-00010.mp4"), Buffer.alloc(0));
-  await writeFile(path.join(dir, "segment-00011.mp4"), Buffer.alloc(9000, 1));
-
-  const removed = await discardOpenPiece(dir, format, { from: 10, to: -1 }, null, null);
-
-  assert.equal(removed, 10, "the one it opened");
-  assert.ok(existsSync(path.join(dir, "segment-00011.mp4")), "and nothing beyond it");
-});