@torrent-tv/proxy 2.80.18 → 2.81.0

package/services/piece-store/disk-tier.js

@@ -1,151 +0,0 @@
-/**
- * @file The second tier: pieces that no longer fit in memory.
- *
- * One sparse file per torrent, a piece at `index * chunkLength`. Not the
- * torrent's real files — nobody reads those directly; playback goes through
- * `/stream`, and the data is discarded when the torrent goes idle. A single
- * file by piece index keeps the mapping arithmetic instead of bookkeeping, and
- * sparseness means the untouched gaps cost nothing.
- *
- * Reads take a destination buffer rather than returning a fresh one. That is
- * not a style preference — measured on the field host, an 8 MB piece costs
- * 22.08 ms via `readFile`, which allocates, and **7.63 ms** read into a buffer
- * we already hold. Two thirds of the apparent "disk" cost was allocation.
- */
-
-import fs from "node:fs/promises";
-import { constants } from "node:fs";
-import path from "node:path";
-
-export class DiskTier {
-  #filePath;
-  #chunkLength;
-  /** @type {import("node:fs/promises").FileHandle | null} */
-  #handle = null;
-  /** Piece indices known to be on disk. */
-  #stored = new Set();
-  /** @type {Promise<void> | null} */
-  #opening = null;
-
-  /**
-   * @param {object} params
-   * @param {string} params.directory - Where the backing file lives.
-   * @param {string} params.name - File name, unique per torrent.
-   * @param {number} params.chunkLength - Piece size; fixes the stride on disk.
-   */
-  constructor({ directory, name, chunkLength }) {
-    this.#filePath = path.join(directory, name);
-    this.#chunkLength = chunkLength;
-  }
-
-  /** Where the backing file lives, for logging and cleanup. */
-  get filePath() {
-    return this.#filePath;
-  }
-
-  /** How many pieces are currently held on disk. */
-  get size() {
-    return this.#stored.size;
-  }
-
-  /**
-   * Open the backing file, creating it and its directory if needed.
-   *
-   * Concurrent callers share one open — several evictions can start at once.
-   *
-   * @returns {Promise<import("node:fs/promises").FileHandle>}
-   */
-  async #open() {
-    if (this.#handle) {
-      return this.#handle;
-    }
-    if (!this.#opening) {
-      this.#opening = (async () => {
-        await fs.mkdir(path.dirname(this.#filePath), { recursive: true });
-        // Read/write, created if absent — NOT append mode. Under `a+` POSIX
-        // ignores the position on every write and puts the bytes at the end of
-        // the file, so pieces would pile up in arrival order and each read
-        // would return whichever piece happened to land at that offset.
-        this.#handle = await fs.open(this.#filePath, constants.O_RDWR | constants.O_CREAT);
-      })();
-    }
-    await this.#opening;
-    if (!this.#handle) {
-      throw new Error(`Could not open the piece file at ${this.#filePath}.`);
-    }
-    return this.#handle;
-  }
-
-  /**
-   * @param {number} index
-   * @returns {boolean}
-   */
-  has(index) {
-    return this.#stored.has(index);
-  }
-
-  /**
-   * Write a piece out.
-   *
-   * @param {number} index
-   * @param {Uint8Array} bytes
-   * @returns {Promise<void>}
-   */
-  async write(index, bytes) {
-    const handle = await this.#open();
-    await handle.write(bytes, 0, bytes.length, index * this.#chunkLength);
-    this.#stored.add(index);
-  }
-
-  /**
-   * Read a piece back into a buffer the caller already owns.
-   *
-   * @param {number} index
-   * @param {Uint8Array} target - Destination; its length is what gets read.
-   * @returns {Promise<number>} Bytes read.
-   */
-  async read(index, target) {
-    if (!this.#stored.has(index)) {
-      throw new Error(`Piece ${index} is not on disk.`);
-    }
-    const handle = await this.#open();
-    const { bytesRead } = await handle.read(target, 0, target.length, index * this.#chunkLength);
-    return bytesRead;
-  }
-
-  /**
-   * Forget a piece. The bytes stay on disk until the file is removed — there is
-   * nothing to gain from punching them out, since the file is discarded whole.
-   *
-   * @param {number} index
-   * @returns {void}
-   */
-  forget(index) {
-    this.#stored.delete(index);
-  }
-
-  /**
-   * Close the file, leaving its contents in place.
-   *
-   * @returns {Promise<void>}
-   */
-  async close() {
-    const handle = this.#handle;
-    this.#handle = null;
-    this.#opening = null;
-    if (handle) {
-      await handle.close();
-    }
-  }
-
-  /**
-   * Close and delete the backing file.
-   *
-   * @returns {Promise<void>}
-   */
-  async destroy() {
-    await this.close();
-    this.#stored.clear();
-    await fs.rm(this.#filePath, { force: true });
-  }
-}

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");
-});