@torrent-tv/proxy 2.93.0 → 2.93.2

package/package.json

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

package/services/server/wire-outputs.js

@@ -982,7 +982,8 @@ export function wireOutputs({
       index >= window.from && index <= window.to && window.withinSeconds === 0),
     changed: (output, result) => {
       if (result.kind === "terminal") {
-        logger.warn(`encode input output=${output.outputKey} terminal=${result.reason}: ${result.message ?? ""}`);
+        logger.warn(`encode input output=${output.outputKey} terminal=${result.reason}: ${result.message ?? ""}` +
+          (Number.isFinite(result.bytes) ? ` bytes=${result.bytes} capacity=${result.capacity}` : ""));
         parts.serving.invalidateWaits(output);
       }
       parts.encodeRuns.planEncodersSoon();

package/services/torrent/download/DeadlineScheduler.js

@@ -46,6 +46,11 @@ export function peerCanServe(wire, piece) {
     wire.peerPieces?.get(piece);
 }
 
+function peerCanRequest(wire) {
+  return !wire.destroyed &&
+    (!wire.peerChoking || (wire.hasFast && wire.peerAllowedFastSet?.length > 0));
+}
+
 /** Identical map ordering for present requests and conditional future requests. */
 export function compareDownloadCandidates(a, b) {
   return a.deadlineAt - b.deadlineAt || b.priority - a.priority || a.order - b.order || a.piece - b.piece;
@@ -62,11 +67,18 @@ export class DeadlineScheduler {
     this.#store = findStore;
   }
 
-  reconcile(now = Date.now()) {
+  reconcile(now = Date.now(), { torrent = null, wire = null } = {}) {
     if (this.#running) return { requested: 0, reassigned: 0 };
+    // WebTorrent updates each peer in turn. A full or choked peer cannot issue
+    // a request, so its heartbeat must not scan every file's byte availability.
+    if (wire && (!peerCanRequest(wire) ||
+      (wire.requests?.length ?? 0) >= peerRequestCapacity(torrent, wire))) {
+      return { requested: 0, reassigned: 0 };
+    }
     this.#running = true;
     try {
-      return dispatchDownloadCandidates(downloadCandidates(this.#entries(), this.#store), now);
+      const entries = [...this.#entries()].filter(entry => !torrent || entry.torrent === torrent);
+      return dispatchDownloadCandidates(downloadCandidates(entries, this.#store), now, { wire });
     } finally {
       this.#running = false;
     }
@@ -112,7 +124,7 @@ export function downloadCandidates(entries, findStore = pieceStoreOf) {
 }
 
 /** Run against protocol peers or an isolated future-state copy. */
-export function dispatchDownloadCandidates(candidates, now) {
+export function dispatchDownloadCandidates(candidates, now, { wire: changedWire = null } = {}) {
   let requested = 0, reassigned = 0;
   // Rates and advertised limits cannot change during this synchronous pass.
   // Read each peer once, and only inspect torrents once regardless of map size.
@@ -125,15 +137,14 @@ export function dispatchDownloadCandidates(candidates, now) {
     }
     return reading;
   };
-  const usable = wire => !wire.destroyed &&
-    (!wire.peerChoking || (wire.hasFast && wire.peerAllowedFastSet?.length > 0));
-  const available = (torrent, wire) => usable(wire) &&
+  const available = (torrent, wire) => peerCanRequest(wire) &&
     (wire.requests?.length ?? 0) < readingOf(torrent, wire).capacity;
   const completionAt = (torrent, wire, bytes) =>
     requestCompletionAt(wire, bytes, now, readingOf(torrent, wire).speed);
   const writable = new Map();
   for (const torrent of new Set(candidates.map(candidate => candidate.torrent))) {
-    const peers = (torrent.wires ?? []).filter(wire => available(torrent, wire));
+    const peers = (changedWire ? [changedWire] : torrent.wires ?? [])
+      .filter(wire => available(torrent, wire));
     if (peers.length) writable.set(torrent, peers);
   }
   for (const candidate of candidates) {

package/services/torrent/download/registry.js

@@ -58,8 +58,8 @@ export function demandFor(torrent) {
   const entry = { torrent, register, selection: new SwarmSelection({ torrent, register }), withdrawalRevision: 0 };
   if (typeof torrent._request === "function" && typeof torrent._updateWire === "function") {
     entry.previousWireUpdate = torrent._updateWire;
-    torrent._updateWire = () => {
-      if (!publishingSelections) scheduler.reconcile();
+    torrent._updateWire = wire => {
+      if (!publishingSelections) scheduler.reconcile(Date.now(), { torrent, wire });
     };
   }
   byTorrent.set(torrent, entry);

package/services/viewer/DownloadMaps.js

@@ -27,7 +27,7 @@ export class DownloadMaps {
       if (!current || Object.keys(current).some(key => key !== "from" && key !== "to" && !Object.is(zone[key], key === "deadlineAt" ? deadlineAt : current[key]))) changed = true;
       return current ? [{ ...zone, ...current, from: zone.from, to: zone.to, deadlineAt }] : [];
     });
-    file.zones = retained;
+    this.#setZones(file, retained);
     for (const [statement, metadata] of file.metadata) {
       if (metadata.interval && !this.wantsInterval(sourceKey, fileIndex, metadata.interval)) {
         file.metadata.delete(statement);
@@ -47,7 +47,7 @@ export class DownloadMaps {
     const resolved = await this.#resolvePlayback({ sourceKey, fileIndex, durationSeconds, zones: file.sourceZones,
       isCurrent: () => this.#files.get(`${sourceKey}:${fileIndex}`) === file && revision === file.revision });
     if (revision !== file.revision) return;
-    file.zones = resolved;
+    this.#setZones(file, resolved);
     return this.#emit(file);
   }
 
@@ -87,10 +87,10 @@ export class DownloadMaps {
     const sources = [];
     for (const file of this.#files.values()) {
       if (file.sourceKey !== sourceKey) continue;
-      const zones = file.zones.filter(zone => zone.outputKey === outputKey && zone.index === index);
-      if (!zones.length) continue;
+      const ranges = file.inputs.get(outputKey)?.get(index);
+      if (!ranges?.length) continue;
       sources.push({ sourceId: `${sourceKey}:${file.fileIndex}`,
-        ranges: zones.map(zone => ({ start: zone.byteStart, end: zone.byteEnd + 1 })) });
+        ranges });
     }
     return sources.length ? sources : null;
   }
@@ -130,7 +130,7 @@ export class DownloadMaps {
 
   forget(sourceKey, fileIndex, { keepPreparation = false } = {}) {
     const file = this.#file(sourceKey, fileIndex);
-    file.zones = [];
+    this.#setZones(file, []);
     file.sourceZones = [];
     if (!keepPreparation) file.nativeZones = [];
     file.revision++;
@@ -158,12 +158,25 @@ export class DownloadMaps {
     const key = `${sourceKey}:${fileIndex}`;
     let file = this.#files.get(key);
     if (!file) {
-      file = { sourceKey, fileIndex, durationSeconds: 0, zones: [], nativeZones: [], sourceZones: [], revision: 0, epoch: ++this.#nextEpoch, metadata: new Map(), pending: Promise.resolve() };
+      file = { sourceKey, fileIndex, durationSeconds: 0, zones: [], inputs: new Map(), nativeZones: [], sourceZones: [], revision: 0, epoch: ++this.#nextEpoch, metadata: new Map(), pending: Promise.resolve() };
       this.#files.set(key, file);
     }
     return file;
   }
 
+  #setZones(file, zones) {
+    file.zones = zones;
+    file.inputs = new Map();
+    for (const zone of zones) {
+      if (typeof zone.outputKey !== "string" || !Number.isSafeInteger(zone.index)) continue;
+      let output = file.inputs.get(zone.outputKey);
+      if (!output) file.inputs.set(zone.outputKey, output = new Map());
+      let ranges = output.get(zone.index);
+      if (!ranges) output.set(zone.index, ranges = []);
+      ranges.push({ start: zone.byteStart, end: zone.byteEnd + 1 });
+    }
+  }
+
   #emit(file) {
     const zones = [...file.zones, ...file.nativeZones];
     for (const { ranges, requestId, priority, urgent, deadlineAt, order } of file.metadata.values()) {