@torrent-tv/proxy 2.99.10 → 2.99.12

package/package.json

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

package/services/torrent/download/registry.js

@@ -20,6 +20,7 @@ import { SwarmSelection } from "./SwarmSelection.js";
 import { SelectionLimit } from "./SelectionLimit.js";
 import { futureDownload } from "./FutureDownload.js";
 import { urgencyName } from "../demand/index.js";
+import { pieceStoreOf } from "../piece-store-of.js";
 
 /** @type {WeakMap<object, { register: DemandRegister, selection: SwarmSelection }>} */
 const byTorrent = new WeakMap();
@@ -30,19 +31,117 @@ let publishingSelections = false;
 /** What the last reconciliation told the swarm to fetch first, for the pool to say. */
 let firstClassStated = "none";
 
-/** Concurrent file reports share one snapshot of every live download map. */
-export function forecastDownloads() {
-  if (!futurePending) {
-    const entries = [...live];
-    const revisions = entries.map(entry => entry.register.revision);
-    const withdrawals = entries.map(entry => entry.withdrawalRevision);
-    const isCurrent = () => entries.length === live.size && !entries.some((entry, index) =>
-        !live.has(entry) || entry.register.revision !== revisions[index] ||
-        entry.withdrawalRevision !== withdrawals[index]);
-    futurePending = futureDownload(entries, { isCurrent }).then(result =>
-      isCurrent() ? result : new Map()).finally(() => { futurePending = null; });
+/**
+ * The last forecast that finished on the maps it was begun on: its result, the
+ * demand and withdrawal revisions of each torrent it was worked out on, and
+ * whether nothing has changed since; overdue once a missing piece outlived its
+ * forecast time.
+ *
+ * @type {{ result: Map<object, { measuredAt: number, arrivals: Map<number, number | null> }>,
+ *   versions: Map<object, { demand: number, withdrawal: number }>, describes: () => boolean, overdue?: boolean } | null}
+ */
+let latestForecast = null;
+/** Who is told that a forecast failed: this layer decides from demand and storage and writes no log of its own. */
+let reportForecastFailure = () => {};
+
+/**
+ * Say where a failed forecast is reported.
+ *
+ * @param {(error: unknown) => void} report
+ * @returns {void}
+ */
+export function onForecastFailure(report) {
+  reportForecastFailure = report;
+}
+
+/**
+ * When this torrent's wanted pieces are forecast to be held, as far as the last
+ * finished forecast says so for the map it now has; null when that forecast
+ * does not describe it.
+ *
+ * NEVER AWAITED. Awaited afresh on every report, the forecast held a waiting
+ * viewer's answer 3-11.6 s on Home Assistant while it took about a quarter of a
+ * second of work, the machine 83-94 % busy: the page asks again only once
+ * answered, so the hold after a seek to 100 s lasted 52.5 s (r51,
+ * torrent-tv/meta#178). A newer forecast is worked out beside the answer,
+ * one at a time, whenever the maps, the withdrawals or the held pieces have
+ * changed since the last one.
+ *
+ * ONLY FOR THE MAP IT WAS WORKED OUT ON. The order pieces come in follows the
+ * map, so a forecast made before the map changed says nothing of the new one,
+ * and neither does one made before a piece was withdrawn: that piece goes back
+ * into the queue ahead of others. Such a torrent gets null, and the caller
+ * estimates its missing bytes from the measured rate, as before any forecast.
+ *
+ * AND WHAT IS HELD IS READ NOW, FROM THE STORE. A piece held now is available
+ * now whatever was forecast. A piece still missing whose forecast time has
+ * passed did not come when forecast — its peer stopped, or it failed
+ * verification — and is unknown, not available: read as `max(0, at - now)`,
+ * 2.99.11's stale time made a missing piece count as held.
+ *
+ * @param {object} torrent
+ * @param {{ now?: number, findStore?: (torrent: object) => object | null }} [options]
+ * @returns {{ measuredAt: number, arrivals: Map<number, number | null> } | null}
+ */
+export function downloadForecastOf(torrent, { now = Date.now(), findStore = pieceStoreOf } = {}) {
+  const entry = byTorrent.get(torrent);
+  if (!entry) return null;
+  refreshForecast();
+  const forecast = latestForecast?.result.get(torrent);
+  const version = latestForecast?.versions.get(entry);
+  if (!forecast || !version || version.demand !== entry.register.revision ||
+      version.withdrawal !== entry.withdrawalRevision) return null;
+  const store = findStore(torrent);
+  const arrivals = new Map();
+  let overdue = false;
+  for (const [piece, at] of forecast.arrivals) {
+    const held = store?.locationOf ? store.locationOf(piece) !== "missing" : torrent.bitfield?.get(piece) === true;
+    if (!held && Number.isFinite(at) && at <= now) overdue = true;
+    arrivals.set(piece, held ? now : Number.isFinite(at) && at > now ? at : null);
+  }
+  // A piece that did not come when forecast is a change no event announces:
+  // the next forecast is begun on it, as on one.
+  if (overdue) {
+    latestForecast.overdue = true;
+    refreshForecast();
   }
-  return futurePending;
+  return { measuredAt: forecast.measuredAt, arrivals };
+}
+
+/**
+ * Begin a forecast of every live map unless one is being worked out or the
+ * last one still describes them.
+ *
+ * A failed forecast is said and leaves the last one in place; the next report
+ * begins another. Left unhandled, its rejection would end nobody's wait and
+ * reach the thread's own handler as an unhandled rejection.
+ *
+ * @returns {void}
+ */
+function refreshForecast() {
+  if (futurePending || (latestForecast?.describes() && !latestForecast.overdue)) return;
+  const entries = [...live];
+  const revisions = entries.map(entry => entry.register.revision);
+  const withdrawals = entries.map(entry => entry.withdrawalRevision);
+  const verified = entries.map(entry => entry.verifiedRevision);
+  const isCurrent = () => entries.length === live.size && !entries.some((entry, index) =>
+      !live.has(entry) || entry.register.revision !== revisions[index] ||
+      entry.withdrawalRevision !== withdrawals[index]);
+  // Worked out again once a piece has arrived as well: the pieces queued
+  // behind it now come sooner.
+  const describes = () => isCurrent() && entries.every((entry, index) => entry.verifiedRevision === verified[index]);
+  const versions = new Map(entries.map((entry, index) =>
+    [entry, { demand: revisions[index], withdrawal: withdrawals[index] }]));
+  futurePending = futureDownload(entries, { isCurrent }).then(result => {
+    if (isCurrent()) latestForecast = { result, versions, describes };
+  }, error => {
+    try { reportForecastFailure(error); } catch { /* a failing report must not end the next forecast */ }
+  }).finally(() => { futurePending = null; });
+}
+
+/** The forecast being worked out, for checks that wait for it to finish. */
+export function forecastSettled() {
+  return futurePending ?? Promise.resolve();
 }
 
 /**
@@ -58,10 +157,11 @@ export function demandFor(torrent) {
   }
   const register = new DemandRegister();
   const selection = new SwarmSelection({ torrent, register });
-  const entry = { torrent, register, selection, limit: new SelectionLimit({ torrent, register, selection }), withdrawalRevision: 0 };
+  const entry = { torrent, register, selection, limit: new SelectionLimit({ torrent, register, selection }), withdrawalRevision: 0,
+    verifiedRevision: 0 };
   byTorrent.set(torrent, entry);
   live.add(entry);
-  entry.onBytesChanged = () => reconcileAll();
+  entry.onBytesChanged = () => { entry.verifiedRevision++; reconcileAll(); };
   entry.onWithdrawn = () => { entry.withdrawalRevision++; reconcileAll(); };
   torrent.on?.("verified", entry.onBytesChanged);
   torrent.on?.("piece-withdrawn", entry.onWithdrawn);

package/services/torrent/worker/worker.js

@@ -28,7 +28,7 @@ import { Readable } from "node:stream";
 import { heldFileBytes } from "./held-file-bytes.js";
 import { createSendStream } from "./channel.js";
 import { readFragments, supplyFiguresFor } from "./piece-reader.js";
-import { demandFor, forecastDownloads, selectionLimitOf } from "../download/registry.js";
+import { demandFor, downloadForecastOf, onForecastFailure, selectionLimitOf } from "../download/registry.js";
 import { heldRangesOf, ownsItsMemory, readHeldBytes, readHeldRanges } from "./held-bytes.js";
 import { CompletedFiles, completedFilesRoot } from "../../storage/files/CompletedFiles.js";
 import { pieceFromWholeFiles, pieceIsInWholeFiles } from "../../storage/files/piece-from-whole-file.js";
@@ -79,6 +79,8 @@ const { SharedPieceStore, collectStoreStats, findSharedStore, machineReserveByte
 // been asked for anything yet.
 const dhtBootstrap = await resolveDhtBootstrap();
 
+onForecastFailure(error => logger.warn(`download: the arrival forecast failed, the last one stands: ${error?.stack ?? error}`));
+
 const pool = new TorrentPool({
   memoryBytes: workerData?.memoryBytes,
   dhtBootstrap,
@@ -473,7 +475,7 @@ async function runCommand(command, params, id) {
       // interval invented from one point is exactly what this work removes.
       const file = Array.isArray(torrent?.files) ? torrent.files[params.fileIndex] : null;
       const forecastAt = performance.now();
-      const forecast = file && params.forecast === true ? (await forecastDownloads()).get(torrent) : null;
+      const forecast = file && params.forecast === true ? downloadForecastOf(torrent) : null;
       const forecastMs = params.forecast === true ? performance.now() - forecastAt : 0;
       const stats = pool.getFileStats(torrent, params.fileIndex);
       const ranges = [];

package/services/viewer/playback-readiness.js

@@ -350,7 +350,12 @@ export function predictPlaybackReadiness(input = {}) {
       for (const range of source.downloadForecast.ranges ?? []) {
         if (!Number.isFinite(range?.availableAt) || !Number.isSafeInteger(range.start) ||
           !Number.isSafeInteger(range.end) || range.start < 0 || range.end <= range.start) continue;
-        const arrival = Math.max(0, (range.availableAt - now) / 1000);
+        // A forecast time already past says nothing of when the bytes come:
+        // held bytes are in the residence, and missing ones are estimated
+        // below. Read as an arrival at zero, a piece forecast to come and
+        // still missing counted as held (torrent-tv/meta#178).
+        if (range.availableAt <= now) continue;
+        const arrival = (range.availableAt - now) / 1000;
         // The entire protocol piece becomes readable after verification;
         // bytes inside it never arrive proportionally to their file address.
         sourceByteService.get(id).push({ start: range.start, end: range.end, begin: arrival, finish: arrival });