@torrent-tv/proxy 2.99.9 → 2.99.11

package/package.json

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

package/services/server/ViewerRequests.js

@@ -582,6 +582,10 @@ export class ViewerRequests {
 
   async #playbackReadinessFor(session, consumerId, progress, outputMbps) {
     const now = Date.now();
+    // WHERE AN ANSWER'S TIME GOES, said with each answer. On Home Assistant a
+    // held viewer's answer took 11.2 s while its forecast took 0.1-0.4 s and
+    // the answer crossed the connection in 21 ms (r50, torrent-tv/meta#178).
+    const parts = { enteredAt: performance.now(), statsMs: 0, workerForecastMs: 0, qualityMs: 0 };
     const viewer = consumerId ? this.#host.viewers.get(consumerId) : null;
     const viewerReading = viewer?.linkReading() ?? null;
     const measurement = this.#rateStateFor(session, consumerId);
@@ -629,12 +633,15 @@ export class ViewerRequests {
           continue;
         }
         let stats = null;
+        const statsAt = performance.now();
         try {
           stats = await this.#host.getSourceStats?.(output.file.sourceKey, fileIndex,
             { forecast: !sourceForecasts.has(output.file.sourceKey) }) ?? null;
         } catch {
           stats = null;
         }
+        parts.statsMs += performance.now() - statsAt;
+        parts.workerForecastMs += Number(stats?.forecastMs) || 0;
         if (!sourceForecasts.has(output.file.sourceKey)) sourceForecasts.set(output.file.sourceKey, stats?.downloadForecast ?? { ranges: [] });
         const sharedForecast = sourceForecasts.get(output.file.sourceKey);
         const downloadForecast = sharedForecast.global ? { measuredAt: sharedForecast.measuredAt,
@@ -655,9 +662,11 @@ export class ViewerRequests {
         });
       }
 
+      const qualityAt = performance.now();
       const observedMbps = output === session
         ? outputMbps
         : await this.#host.quality.observedStreamMbps(output);
+      parts.qualityMs += performance.now() - qualityAt;
       const liveRuns = this.#host.encodeRuns.liveRunsOf?.(output) ?? [];
       const processingStarted = liveRuns.some(({ progress }) => progress.processedSeconds > progress.startPositionSeconds);
       const startedAt = liveRuns.find(({ startedAt }) => startedAt > 0)?.startedAt ?? now;
@@ -734,7 +743,11 @@ export class ViewerRequests {
       viewer.subtitle.fileIndex === session.file.fileIndex ? viewer.subtitle : null;
     const startedAt = performance.now();
     const predicted = this.#host.playbackReadiness.predict(input);
-    this.#noteForecast(performance.now() - startedAt, tracks.map(track => track.geometry?.reason ?? "none"));
+    const predictMs = performance.now() - startedAt;
+    this.#noteForecast(predictMs, tracks.map(track => track.geometry?.reason ?? "none"));
+    logger.info(`readiness parts ${session.id} consumer=${consumerId}: source stats ${Math.round(parts.statsMs)}ms ` +
+      `(the torrent thread's arrival forecast ${Math.round(parts.workerForecastMs)}ms), stream rate ${Math.round(parts.qualityMs)}ms, ` +
+      `start forecast ${Math.round(predictMs)}ms, in all ${Math.round(performance.now() - parts.enteredAt)}ms`);
     const forecast = withSubtitleReadiness(predicted, subtitle,
       subtitle ? this.#host.subtitleReadyFor?.(viewer) !== false : true);
     forecast.operations = outputs.flatMap((output, index) => {

package/services/torrent/download/registry.js

@@ -30,19 +30,44 @@ 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. */
+/** The last forecast that finished on the maps it was begun on, and how to tell it still describes them. */
+let latestForecast = null;
+
+/**
+ * The arrival forecast of every live download map, shared by concurrent file
+ * reports.
+ *
+ * ANSWERED WITH THE LAST ONE FINISHED. Each forecast states when it was made
+ * (`measuredAt`), and a newer one is worked out beside the answer whenever the
+ * maps or the held pieces have changed since, one at a time. Awaited afresh on
+ * every report, it 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). Only the first report waits, when
+ * there is no forecast yet. A forecast whose maps change while it is worked out
+ * is not kept.
+ *
+ * @returns {Promise<Map<object, { measuredAt: number, arrivals: Map<number, number | null> }>>}
+ */
 export function forecastDownloads() {
-  if (!futurePending) {
+  if (!futurePending && !latestForecast?.isCurrent()) {
     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]);
-    futurePending = futureDownload(entries, { isCurrent }).then(result =>
-      isCurrent() ? result : new Map()).finally(() => { futurePending = null; });
+    // Kept while no piece has arrived either: a piece forecast to come has
+    // either come, or its time is past and it must be forecast again.
+    const describes = () => isCurrent() && entries.every((entry, index) => entry.verifiedRevision === verified[index]);
+    futurePending = futureDownload(entries, { isCurrent }).then(result => {
+      if (!isCurrent()) return new Map();
+      latestForecast = { result, isCurrent: describes };
+      return result;
+    }).finally(() => { futurePending = null; });
   }
-  return futurePending;
+  return latestForecast ? Promise.resolve(latestForecast.result) : futurePending;
 }
 
 /**
@@ -58,10 +83,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

@@ -472,7 +472,9 @@ async function runCommand(command, params, id) {
       // second interruption has been seen: one wait shows no interval, and an
       // 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 forecastMs = params.forecast === true ? performance.now() - forecastAt : 0;
       const stats = pool.getFileStats(torrent, params.fileIndex);
       const ranges = [];
       if (forecast) for (const [piece, availableAt] of forecast.arrivals) {
@@ -485,7 +487,10 @@ async function runCommand(command, params, id) {
         ...(params.forecast === true ? { downloadForecast: {
           measuredAt: forecast?.measuredAt ?? Date.now(), global: true, ranges
         } } : {}),
-        supply: supplyFiguresFor(torrent?.infoHash, file?.name, params.segmentSeconds ?? 4)
+        supply: supplyFiguresFor(torrent?.infoHash, file?.name, params.segmentSeconds ?? 4),
+        // How long this answer waited for the arrival forecast, which the
+        // caller says beside its own time (ViewerRequests, torrent-tv/meta#178).
+        forecastMs
       };
     }