@torrent-tv/proxy 2.107.32 → 2.107.33

package/package.json

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

package/server.js

@@ -917,7 +917,8 @@ export async function startProxyServer({
     reviseBudget: () => { void outputParts.machineBudget.revise("memory", "media metadata").catch(error => logger.warn(`packet index budget: ${error.message}`)); },
     changed: () => { mediaReads.memoryChanged(); probeReads.memoryChanged(); outputParts.encodeInputs?.memoryChanged(); }
   });
-  const containerOver = async ({ sourceKey, fileIndex, requestId, packetInterval, demand, readPriority }) => {
+  const encodeMetadataRequests = new WeakMap();
+  const containerOver = async ({ sourceKey, fileIndex, requestId, packetInterval, demand, readPriority, signal }) => {
     const record = sourceRegistry.get(sourceKey);
     if (!record) {
       return null;
@@ -927,10 +928,34 @@ export async function startProxyServer({
     if (!file || !(file.length > 0)) {
       return null;
     }
+    let metadataTracker = null;
+    let trackersForSignal = null;
+    const trackerKey = `${sourceKey}:${fileIndex}`;
+    if (readPriority?.requestId && signal) {
+      trackersForSignal = encodeMetadataRequests.get(signal);
+      if (!trackersForSignal) encodeMetadataRequests.set(signal, trackersForSignal = new Map());
+      metadataTracker = trackersForSignal.get(trackerKey);
+      if (!metadataTracker) {
+        metadataTracker = { statements: new Set(), abort: null };
+        metadataTracker.abort = () => {
+          for (const statement of metadataTracker.statements) {
+            void downloadMaps.withdrawMetadata(sourceKey, fileIndex, statement).catch(error =>
+              logger.warn(`encode input demand withdrawal failed: ${error.message}`));
+          }
+          metadataTracker.statements.clear();
+          trackersForSignal.delete(trackerKey);
+          if (trackersForSignal.size === 0) encodeMetadataRequests.delete(signal);
+        };
+        trackersForSignal.set(trackerKey, metadataTracker);
+        if (signal.aborted) metadataTracker.abort();
+        else signal.addEventListener("abort", metadataTracker.abort, { once: true });
+      }
+    }
     const params = {
       sourceKey,
       fileIndex,
       requestId,
+      signal,
       packetInterval,
       readPriority,
       packetMemory: indexMemory.forFile(sourceKey, fileIndex),
@@ -969,9 +994,17 @@ export async function startProxyServer({
         }
         const finished = mediaReads.record(params, statement, result, revision.storage, revision.memory);
         if (statement === "chapters" && result.passive) await downloadMaps.withdrawMetadata(sourceKey, fileIndex, statement);
-        else await downloadMaps.metadata({ sourceKey, fileIndex, statement: requestId ? `${statement}:${requestId}` : statement, result,
-          ...(statement === "chapters" ? { priority: 1, urgent: false, deadlineAt: null } : {}),
-          ...(demand ? { priority: demand.priority, urgent: demand.urgent, deadlineAt: demand.deadlineAt, interval: demand, leadSeconds: demand.leadSeconds ?? 0 } : {}) });
+        else {
+          const metadataStatement = requestId ? `${statement}:${requestId}` : statement;
+          if (metadataTracker && result.kind === "needs-ranges") metadataTracker.statements.add(metadataStatement);
+          if (metadataTracker && result.kind !== "needs-ranges") metadataTracker.statements.delete(metadataStatement);
+          await downloadMaps.metadata({ sourceKey, fileIndex, statement: metadataStatement, result,
+            ...(statement === "chapters" ? { priority: 1, urgent: false, deadlineAt: null } : {}),
+            ...(demand ? { priority: demand.priority, urgent: demand.urgent, deadlineAt: demand.deadlineAt, interval: demand, leadSeconds: demand.leadSeconds ?? 0 } : {}),
+            ...(readPriority?.requestId ? { priority: readPriority.rank, urgent: readPriority.urgent === true,
+              deadlineAt: Number.isFinite(readPriority.deadlineAt) ? readPriority.deadlineAt : Number.POSITIVE_INFINITY,
+              scope: "preparation" } : {}) });
+        }
         if (finished && result.kind === "result") {
           void downloadMaps.refresh(sourceKey, fileIndex).catch(error =>
             logger.warn(`download map source=${sourceKey} file=${fileIndex} metadata refresh failed: ${error?.message ?? error}`));
@@ -1042,7 +1075,8 @@ export async function startProxyServer({
       // reassembled packets otherwise.
       const files = [];
       for (const [fileIndex, choices] of selected) {
-        const params = await containerOver({ sourceKey: output.file.sourceKey, fileIndex, readPriority });
+        const params = await containerOver({ sourceKey: output.file.sourceKey, fileIndex,
+          requestId: readPriority?.requestId, readPriority, signal });
         if (!params) return { kind: "needs-source" };
         if (isCurrent) params.isCurrent = isCurrent;
         if (signal) params.signal = signal;
@@ -1145,6 +1179,7 @@ export async function startProxyServer({
           .finally(() => releaseInput?.());
       }
     },
+    repriceEncodeDemand: demand => downloadMaps.repriceRequest(demand.requestId, demand),
     readEncodeRanges: async (source, ranges, maxBytes) => {
       const torrent = torrentPool.knownTorrent(source.sourceKey);
       return torrent ? torrentPool.readHeldRangesOf(torrent, source.fileIndex, ranges, maxBytes) : null;

package/services/encode/EncodeInputs.js

@@ -56,6 +56,7 @@ export class EncodeInputs {
   #capacity;
   #urgent;
   #rankAt;
+  #demandChanged;
   #log;
   #now;
   /**
@@ -68,7 +69,7 @@ export class EncodeInputs {
   #observeWait;
 
   constructor({ resolve, readRanges, openWholeFile = null, heldRanges = null, reviseBudget, changed, failed, capacity = () => null, urgent = () => true,
-    rankAt = () => null, openOf = () => null, log = () => {}, now = Date.now, stretchCopied = () => {},
+    rankAt = () => null, demandChanged = () => {}, openOf = () => null, log = () => {}, now = Date.now, stretchCopied = () => {},
     observeWait = null }) {
     this.#stretchCopied = stretchCopied;
     this.#observeWait = observeWait;
@@ -83,6 +84,7 @@ export class EncodeInputs {
     this.#capacity = capacity;
     this.#urgent = urgent;
     this.#rankAt = rankAt;
+    this.#demandChanged = demandChanged;
     this.#log = log;
     this.#now = now;
   }
@@ -204,7 +206,12 @@ export class EncodeInputs {
       if (request.output !== output) continue;
       const covered = windows.some(window => request.from <= window.to && request.to >= window.from);
       const unused = starts !== null && request.result?.kind === "result" && !starts.has(request.from);
-      if (covered && !unused) continue;
+      if (covered && !unused) {
+        const current = this.#readPriority(request, request.from, request.from);
+        Object.assign(request.readPriority ??= {}, current);
+        this.#demandChanged(output, request.readPriority);
+        continue;
+      }
       this.#note(request, covered ? "withdrawn: no live run ends before it and no start is placed there"
         : "withdrawn: no wanted window covers it");
       this.#requests.delete(key);
@@ -503,13 +510,15 @@ export class EncodeInputs {
    * @param {object} request
    * @param {number} from
    * @param {number} to
-   * @returns {{ rank: number, serves: number, from: number, to: number }}
+   * @returns {{ rank: number, topRank: number, serves: number, from: number, to: number, urgent?: boolean, deadlineAt?: number, requestId: string }}
    */
   #readPriority(request, from, to) {
     const serves = request.serves ?? request.from;
     const rank = this.#rankAt(request.output, serves);
     return { rank: Number.isFinite(rank?.rank) ? rank.rank : 0, topRank: Number.isFinite(rank?.topRank) ? rank.topRank : 0,
-      serves, from, to };
+      ...(typeof rank?.urgent === "boolean" ? { urgent: rank.urgent } : {}),
+      ...(Number.isFinite(rank?.deadlineAt) ? { deadlineAt: rank.deadlineAt } : {}),
+      serves, from, to, requestId: `encode:${request.key}` };
   }
 
   /**

package/services/encode/EncodeOrchestrator.js

@@ -503,6 +503,11 @@ export class EncodeOrchestrator {
     return this.#demand.rankOf(address, index);
   }
 
+  /** The viewer-derived priority, urgency and due time for one output segment. */
+  demandAt(address, index) {
+    return this.#demand.demandAt(address, index);
+  }
+
   /**
    * How many encoder processes are running on this machine right now, over
    * every output.

package/services/encode/SegmentDemand.js

@@ -92,4 +92,27 @@ export class SegmentDemand {
     }
     return { rank, topRank };
   }
+
+  /**
+   * The viewer-derived demand for one output segment, including its due time.
+   *
+   * @param {string} address
+   * @param {number} index
+   * @param {number} now
+   * @returns {{ rank: number, topRank: number, urgent: boolean, deadlineAt: number }}
+   */
+  demandAt(address, index, now = Date.now()) {
+    const zones = this.mapOn(address);
+    let rank = 0, topRank = 0, urgent = false, deadlineAt = Number.POSITIVE_INFINITY;
+    for (const zone of zones) {
+      topRank = Math.max(topRank, Number.isFinite(zone.priority) ? zone.priority : 0);
+      if (index < zone.from || index > zone.to || !(zone.priority > 0)) continue;
+      rank = Math.max(rank, zone.priority);
+      urgent ||= zone.urgent === true;
+      const due = Number.isFinite(zone.deadlineAt) ? zone.deadlineAt
+        : Number.isFinite(zone.withinSeconds) ? now + Math.max(0, zone.withinSeconds) * 1000 : Number.POSITIVE_INFINITY;
+      deadlineAt = Math.min(deadlineAt, due);
+    }
+    return { rank, topRank, urgent, deadlineAt };
+  }
 }

package/services/server/wire-outputs.js

@@ -228,6 +228,7 @@ export function wireOutputs({
     diagnosticsRoot = "",
     memoryClaimant = null,
     resolveEncodeInput = null,
+    repriceEncodeDemand = null,
     readSourceMedia = null,
     readMetadataActivity = null,
     sourceInputsFor = null,
@@ -1191,7 +1192,12 @@ export function wireOutputs({
     urgent: (output, index) => parts.encodeOrchestrator.wantedSegmentsOn(output.outputKey).some(window =>
       index >= window.from && index <= window.to && window.urgent === true),
     // The piece's rank in the output's own map, said with an input's state.
-    rankAt: (output, index) => parts.encodeOrchestrator?.rankAt?.(output.outputKey ?? "", index) ?? null,
+    rankAt: (output, index) => parts.encodeOrchestrator?.demandAt?.(output.outputKey ?? "", index) ?? null,
+    demandChanged: (_output, demand) => {
+      void Promise.resolve(repriceEncodeDemand?.({ priority: demand.rank, urgent: demand.urgent === true,
+        deadlineAt: Number.isFinite(demand.deadlineAt) ? demand.deadlineAt : Number.POSITIVE_INFINITY,
+        requestId: demand.requestId })).catch(error => logger.warn(`encode input demand repricing failed: ${error.message}`));
+    },
     log: line => logger.info(line),
     observeWait,
     changed: (output, result) => {

package/services/viewer/DownloadMaps.js

@@ -238,6 +238,22 @@ export class DownloadMaps {
     return this.#emit(file);
   }
 
+  /** Reprice source metadata owned by one live encode input request. */
+  repriceRequest(requestId, demand) {
+    const changed = [];
+    for (const file of this.#files.values()) {
+      let fileChanged = false;
+      for (const metadata of file.metadata.values()) {
+        if (metadata.requestId !== requestId) continue;
+        if (Object.keys(demand).every(key => Object.is(metadata[key], demand[key]))) continue;
+        Object.assign(metadata, demand);
+        fileChanged = true;
+      }
+      if (fileChanged) changed.push(this.#emit(file));
+    }
+    return Promise.all(changed);
+  }
+
   forget(sourceKey, fileIndex, { keepPreparation = false } = {}) {
     const file = this.#file(sourceKey, fileIndex);
     this.#setZones(file, []);