@torrent-tv/proxy 2.107.49 → 2.107.50

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@torrent-tv/proxy",
-  "version": "2.107.49",
+  "version": "2.107.50",
   "description": "Torrent proxy client that exposes webseed-like HTTP stream endpoint.",
   "license": "GPL-3.0-or-later",
   "repository": {

package/services/{server/WaitLedger.js → encode/OutputWaitLedger.js}

@@ -58,6 +58,23 @@ export class WaitLedger {
   /** @type {Map<string, Map<string, number>>} */
   #counts = new Map();
 
+  /** @type {Map<string, object>} */
+  #owners = new Map();
+
+  /**
+   * Begin a live output-key lifetime. Reopening a key starts a clean history;
+   * the returned identity lets a held response prove that it still belongs to
+   * this lifetime when it eventually completes.
+   *
+   * @param {string} key
+   * @param {object} identity
+   */
+  open(key, identity) {
+    if (!key || !identity || this.#owners.get(key) === identity) return;
+    this.forget(key);
+    this.#owners.set(key, identity);
+  }
+
   /**
    * Somebody waited this long for something the map ranked this highly.
    *
@@ -66,11 +83,13 @@ export class WaitLedger {
    * @param {number} rank - The map's rank for the thing waited for.
    * @param {number} topRank - The highest rank the map states, so the rank can
    *   be read as a position rather than as an absolute number.
+   * @param {object} [identity] - The output-key lifetime that started this wait.
    */
-  note(key, waitedMs, rank, topRank) {
+  note(key, waitedMs, rank, topRank, identity = undefined) {
     if (!key || !Number.isFinite(waitedMs) || waitedMs < 0) {
       return;
     }
+    if (identity !== undefined && this.#owners.get(key) !== identity) return;
     const band = bandOf(rank, topRank);
     let byBand = this.#waits.get(key);
     if (!byBand) {
@@ -128,15 +147,26 @@ export class WaitLedger {
 
   /**
    * @param {string} key
+   * @param {object} [identity] - Ignore release from an older output lifetime.
    */
-  forget(key) {
+  forget(key, identity = undefined) {
+    if (identity !== undefined && this.#owners.get(key) !== identity) return false;
     this.#waits.delete(key);
     this.#counts.delete(key);
+    if (identity === undefined || this.#owners.get(key) === identity) this.#owners.delete(key);
+    return true;
+  }
+
+  /** Release every record owned by this proxy before its shutdown completes. */
+  clear() {
+    this.#waits.clear();
+    this.#counts.clear();
+    this.#owners.clear();
+  }
+
+  /** Number of output keys with retained measurements. */
+  get size() {
+    return this.#waits.size;
   }
 }
 
-/**
- * One ledger for the process, because the question is asked in two layers and
- * the answer is comparable only if the scale is the same.
- */
-export const waits = new WaitLedger();

package/services/encode/output/OutputCatalog.js

@@ -26,7 +26,11 @@ export class OutputCatalog {
 
   #byId = new Map();
   #lifetime = new Map();
+  /** @type {Map<string, object>} */
+  #waitIdentities = new Map();
   #now;
+  #waitIdentityStarted;
+  #waitIdentityEnded;
 
   /**
    * @param {object} [params]
@@ -35,11 +39,15 @@ export class OutputCatalog {
    *   source file is, which the torrent reports.
    * @param {(address: string) => { index: number, size: number }} [params.largestPieceOf]
    *   The biggest piece an output has made, which the disk knows.
+   * @param {(address: string, identity: object) => void} [params.waitIdentityStarted]
+   * @param {(address: string, identity: object) => void} [params.waitIdentityEnded]
    */
   constructor({
     now = Date.now,
     fileLengthOf = () => 0,
-    largestPieceOf = () => ({ index: -1, size: 0 })
+    largestPieceOf = () => ({ index: -1, size: 0 }),
+    waitIdentityStarted = () => {},
+    waitIdentityEnded = () => {}
   } = {}) {
     this.#now = now;
     // Two facts this catalog needs and does not own, taken as plain functions
@@ -48,15 +56,22 @@ export class OutputCatalog {
     // it is part of the output itself (`OutputSpec`).
     this.fileLengthOf = fileLengthOf;
     this.largestPieceOf = largestPieceOf;
+    this.#waitIdentityStarted = waitIdentityStarted;
+    this.#waitIdentityEnded = waitIdentityEnded;
   }
 
   set(id, output) {
     const known = this.#byId.get(id);
+    const oldAddress = known?.outputKey;
     this.#byId.set(id, output);
     if (known !== output) {
       const at = this.#now();
       this.#lifetime.set(id, { startedAt: at, lastAccessedAt: at });
     }
+    if (known !== output && oldAddress !== output?.outputKey) {
+      this.#forgetWaitIdentityIfUnused(oldAddress);
+    }
+    this.#openWaitIdentity(output?.outputKey);
     return this;
   }
 
@@ -69,13 +84,42 @@ export class OutputCatalog {
   }
 
   delete(id) {
+    const output = this.#byId.get(id);
     this.#lifetime.delete(id);
-    return this.#byId.delete(id);
+    const deleted = this.#byId.delete(id);
+    if (deleted) this.#forgetWaitIdentityIfUnused(output?.outputKey);
+    return deleted;
   }
 
   clear() {
+    const addresses = new Set([...this.#byId.values()].map(output => output?.outputKey).filter(Boolean));
     this.#lifetime.clear();
     this.#byId.clear();
+    for (const address of addresses) this.#forgetWaitIdentityIfUnused(address);
+  }
+
+  /** The shared active lifetime for the output addressed by a live session. */
+  waitIdentity(id) {
+    const output = this.#byId.get(id);
+    return output ? this.#waitIdentities.get(output.outputKey) ?? null : null;
+  }
+
+  #openWaitIdentity(address) {
+    if (typeof address !== "string" || !address || this.#waitIdentities.has(address)) return;
+    const identity = {};
+    this.#waitIdentities.set(address, identity);
+    this.#waitIdentityStarted(address, identity);
+  }
+
+  #forgetWaitIdentityIfUnused(address) {
+    if (typeof address !== "string" || !address) return;
+    for (const output of this.#byId.values()) {
+      if (output?.outputKey === address) return;
+    }
+    const identity = this.#waitIdentities.get(address);
+    if (!identity) return;
+    this.#waitIdentities.delete(address);
+    this.#waitIdentityEnded(address, identity);
   }
 
   touch(outputOrId, at = this.#now()) {

package/services/server/OutputLifecycle.js

@@ -55,7 +55,7 @@ export class OutputLifecycle {
   #host;
 
   /**
-   * @param {object} host - `retention`, `outputNeeded`, `outputWriting`, `outputReading`, `planEncodersSoon`, `now`, `invalidateWaits`, `segmentFormatOfKey`, `viewerSegmentsOn`, `budgetTimer`, `cleanupTimer`, `encodeRuns`, `keyframeTables`, `machineBudget`, `outputTimes`, `outputs`, `returns`, `segmentStore`, `sessionTtlMs`, `sourceFiles`, `timelines`, `viewers`
+   * @param {object} host - `retention`, `outputNeeded`, `outputWriting`, `outputReading`, `planEncodersSoon`, `now`, `invalidateWaits`, `clearWaits`, `segmentFormatOfKey`, `viewerSegmentsOn`, `budgetTimer`, `cleanupTimer`, `encodeRuns`, `keyframeTables`, `machineBudget`, `outputTimes`, `outputs`, `returns`, `segmentStore`, `sessionTtlMs`, `sourceFiles`, `timelines`, `viewers`
    */
   constructor(host) {
     this.#host = host;
@@ -267,6 +267,7 @@ export class OutputLifecycle {
     for (const sessionId of activeIds) {
       await this.disposeSession(sessionId);
     }
+    this.#host.clearWaits?.();
     // Everything this process owns, root included. See SegmentStore.dropAll.
     this.#host.segmentStore.dropAll("the proxy is shutting down");
   }

package/services/server/SegmentServing.js

@@ -78,6 +78,20 @@ export class SegmentServing {
     state.waitListeners.clear();
   }
 
+  /** Identity of the live output-key lifetime named by this session. */
+  waitIdentity(sessionId) {
+    return this.#host.outputs.waitIdentity(sessionId);
+  }
+
+  /** Record a completed wait through the ledger operation wired by the server. */
+  noteWait(ranked, waitedMs, identity) {
+    this.#host.noteWait?.(ranked, waitedMs, identity);
+  }
+
+  waitBandOf(rank, topRank) {
+    return this.#host.waitBandOf?.(rank, topRank) ?? "later";
+  }
+
   /** Observe storage and lifecycle before a request checks file availability. */
   subscribeFileChange(sessionId) {
     const output = isOutputName(sessionId) ? this.#host.outputs.get(sessionId) : null;

package/services/server/transcode-session-files.js

@@ -1,6 +1,4 @@
 import { logger } from "../../utils/logger.js";
-import { bandOf, waits } from "./WaitLedger.js";
-
 /**
  * Which viewer is asking, or an empty string where the transport names nobody.
  *
@@ -84,6 +82,12 @@ export async function serveSessionFile(req, reply, { serving, viewerRequests, se
   // a plain HTTP transport, where no loader of ours builds the URL, and then
   // the single shared position decides as it always did.
   const consumerId = consumerOf(req);
+  // Hold the output-key lifetime that this request entered. Disposal followed
+  // by reopening the same key must not let its old completion write into the
+  // new output's measurements.
+  const waitIdentity = typeof serving.waitIdentity === "function"
+    ? serving.waitIdentity(sessionId)
+    : undefined;
   // Readiness or a terminal state ends the wait. A caller leaving cancels it;
   // elapsed time is not evidence that media preparation failed.
   const holdStartedAt = Date.now();
@@ -132,11 +136,12 @@ export async function serveSessionFile(req, reply, { serving, viewerRequests, se
     // like, and without them the table would hold only the failures.
     const ranked = result.ranked ?? null;
     if (ranked) {
-      waits.note(ranked.address, heldMs, ranked.rank, ranked.topRank);
+      serving.noteWait?.(ranked, heldMs, waitIdentity);
     }
     logger.info(
       `[hold] ${fileName} ${outcome} after ${heldMs}ms` +
-      (ranked ? ` (the map wants it ${bandOf(ranked.rank, ranked.topRank)}, rank ${ranked.rank} of ${ranked.topRank})` : "")
+      (ranked ? ` (the map wants it ${serving.waitBandOf?.(ranked.rank, ranked.topRank) ?? "later"}, ` +
+        `rank ${ranked.rank} of ${ranked.topRank})` : "")
     );
   }
 

package/services/server/wire-outputs.js

@@ -10,7 +10,7 @@
 
 import { logger } from "../../utils/logger.js";
 import { KeyframeTables } from "../media/KeyframeTables.js";
-import { waits } from "./WaitLedger.js";
+import { bandOf, WaitLedger } from "../encode/OutputWaitLedger.js";
 import { readEndedChildrenCpuSeconds, readMachineState, readProcessCpuSeconds, readProxyCpuSeconds, readSystemCpu, shareOfMachine } from "../encode/host-load.js";
 import { minimumBufferFrom } from "../torrent/supply-margin.js";
 import { PriorityOrchestrator } from "../viewer/PriorityOrchestrator.js";
@@ -244,6 +244,9 @@ export function wireOutputs({
     // Told when an encoder starts or ends: the room this host has for one more
     // encode changes with it, and the server chooses proxies by that room.
     onEncodersChanged = null}) {
+  // Long-lived wait diagnostics belong to this wired output graph: each live
+  // output key owns its record, and the graph releases it at the last session.
+  const waits = new WaitLedger();
   const parts = {};
   const audioDescriptionOf = (output) => (getCachedAudioTracks?.({
     sourceKey: output.file.sourceKey, fileIndex: output.spec.grid?.fileIndex ?? output.file.fileIndex
@@ -552,6 +555,9 @@ export function wireOutputs({
     get lookaheadSeconds() { return parts.lookaheadSeconds; },
     get outputTimes() { return parts.outputTimes; },
     get outputs() { return parts.outputs; },
+    noteWait: (ranked, waitedMs, identity) =>
+      waits.note(ranked.address, waitedMs, ranked.rank, ranked.topRank, identity),
+    waitBandOf: bandOf,
     get segmentStore() { return parts.segmentStore; },
     get startupWaitMs() { return parts.startupWaitMs; },
     get viewers() { return parts.viewers; },
@@ -565,6 +571,7 @@ export function wireOutputs({
     outputReading: key => parts.segmentStore.isReading(key) || parts.viewers.responsesHold(key),
     planEncodersSoon: () => parts.encodeRuns.planEncodersSoon(),
     invalidateWaits: (output) => parts.serving.invalidateWaits(output),
+    clearWaits: () => waits.clear(),
     segmentFormatOfKey,
     // Where the viewers of one output stand, in its segments: what the store
     // the output retention policy reads to give disk back in the right order.
@@ -960,7 +967,9 @@ export function wireOutputs({
   // belongs to, the steps, the soundtracks, the height a step is named by.
   parts.outputs = new OutputCatalog({
     fileLengthOf: (session) => parts.hostLoad.fileLengthByKey.get(session.file.key) ?? 0,
-    largestPieceOf: (address) => parts.segmentStore.largestPiece(address)
+    largestPieceOf: (address) => parts.segmentStore.largestPiece(address),
+    waitIdentityStarted: (address, identity) => waits.open(address, identity),
+    waitIdentityEnded: (address, identity) => waits.forget(address, identity)
   });
   // Where produced segments live, addressed by WHAT they are rather than by
   // which session's encoder wrote them. Two sessions of one output — two