@torrent-tv/proxy 2.99.8 → 2.99.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@torrent-tv/proxy",
-  "version": "2.99.8",
+  "version": "2.99.10",
   "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/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
       };
     }
 

package/services/transport/tunnel-client.js

@@ -313,6 +313,14 @@ export function createTunnelClient({
           signalRoutes.delete(sessionId);
         }
       }
+      // Closed because this proxy is stopping (`disconnect`), which clears the
+      // connection before its close arrives. Read as a handover, a stopping
+      // proxy said a replacement carried its tunnel while viewers found no
+      // proxy at all (r48, torrent-tv/meta#178).
+      if (stopped) {
+        log(`Tunnel closed (code=${event.code}): this proxy is stopping.`);
+        return;
+      }
       // A connection this one replaced. The server closes it as soon as the
       // replacement registers, which is the whole point of renewing early —
       // there is nothing to report and nothing to reconnect, because the tunnel