@torrent-tv/proxy 2.99.7 → 2.99.9

package/package.json

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

package/services/torrent/download/FutureDownload.js

@@ -94,19 +94,20 @@ export async function futureDownload(entries, { now = Date.now(), findStore = pi
         continue;
       }
       const remaining = piece?.missing;
-      const speed = (torrent.wires ?? []).reduce((sum, wire) => {
+      const holders = [];
+      for (const wire of torrent.wires ?? []) {
         // Only a peer that can be asked for it now: one choking us is asked for
         // nothing outside the pieces it allows, whatever it carried before.
-        if (wire.destroyed || !wire.peerPieces?.get(index) || !mayAsk(wire, index)) return sum;
+        if (wire.destroyed || !wire.peerPieces?.get(index) || !mayAsk(wire, index)) continue;
         // What it carried with its queue kept full, where it has been seen so:
         // its speed while our selection gave it little measures our asking
         // (`SelectionLimit`, torrent-tv/meta#178).
         const rate = Number(limit?.capacityOf?.(wire) ?? wire.downloadSpeed?.());
-        return Number.isFinite(rate) && rate > 0 ? sum + rate : sum;
-      }, 0);
-      pending.push({ arrivals, index, ...band, seconds:
-        Number.isSafeInteger(remaining) && remaining > 0 && remaining <= piece.length && speed > 0
-          ? remaining / speed : null });
+        if (Number.isFinite(rate) && rate > 0) holders.push({ wire, rate });
+      }
+      pending.push({ arrivals, index, ...band, holders, remaining:
+        Number.isSafeInteger(remaining) && remaining > 0 && remaining <= piece.length && holders.length > 0
+          ? remaining : null });
       if (++steps % 256 === 0) {
         await nextTurn();
         if (!isCurrent()) return new Map();
@@ -120,15 +121,62 @@ export async function futureDownload(entries, { now = Date.now(), findStore = pi
   // before it have. Charged the whole band's end instead, a band of many
   // segments — the map states one per stretch of a level since 2.97.27 — would
   // put its nearest piece at its farthest piece's time (torrent-tv/meta#178).
+  //
+  // AND IN PARALLEL WHERE THE PEERS DIFFER. A piece is brought by the peers
+  // holding it, each from when it has brought what was asked of it before, and
+  // no sooner than the measured supply of every peer that holds a piece still
+  // to come carries all the bytes ahead of it. Summed one piece after another
+  // at its own holders' speed, a two-hour film whose far pieces each had a few
+  // unchoked holders was forecast to arrive in 127 838 s at 2.33 MB/s, and a
+  // seek was held for 39 s on it (r49, torrent-tv/meta#178). One holder for
+  // every piece gives the sum it was; a piece nobody can be asked for still
+  // leaves every piece after it unknown.
   pending.sort((left, right) => compareBands(left, right) || left.index - right.index);
-  let finish = now;
-  for (const { arrivals, index, seconds } of pending) {
-    finish = finish === null || seconds === null ? null : finish + seconds * 1000;
-    if (finish !== null) arrivals.set(index, finish);
+  const supply = new Map();
+  for (const { holders } of pending) for (const { wire, rate } of holders) supply.set(wire, rate);
+  const total = [...supply.values()].reduce((sum, rate) => sum + rate, 0);
+  const freeAt = new Map();
+  let ahead = 0;
+  let known = true;
+  for (const { arrivals, index, holders, remaining } of pending) {
+    if (!known || remaining === null || !(total > 0)) {
+      known = false;
+      continue;
+    }
+    ahead += remaining;
+    const finish = Math.max(sharedFinish(holders, freeAt, remaining, now), now + ahead / total * 1000);
+    for (const { wire } of holders) freeAt.set(wire, Math.max(freeAt.get(wire) ?? now, finish));
+    arrivals.set(index, finish);
   }
   return isCurrent() ? forecasts : new Map();
 }
 
+/**
+ * When peers bringing `bytes` together finish: each starts when it is free
+ * and brings at its own rate, so the finish is where their combined bytes
+ * reach `bytes` (the earliest of them working alone at first, more joining as
+ * they come free).
+ *
+ * @param {Array<{ wire: object, rate: number }>} holders - Bytes per second.
+ * @param {Map<object, number>} freeAt - Milliseconds.
+ * @param {number} bytes
+ * @param {number} now - Milliseconds.
+ * @returns {number} Milliseconds.
+ */
+function sharedFinish(holders, freeAt, bytes, now) {
+  const starts = holders.map(({ wire, rate }) => ({ at: Math.max(now, freeAt.get(wire) ?? now), rate }))
+    .sort((left, right) => left.at - right.at);
+  let rate = 0;
+  let weighted = 0;
+  for (let index = 0; index < starts.length; index++) {
+    rate += starts[index].rate;
+    weighted += starts[index].rate * starts[index].at;
+    const finish = (bytes * 1000 + weighted) / rate;
+    if (index === starts.length - 1 || finish <= starts[index + 1].at) return finish;
+  }
+  return now;
+}
+
 /**
  * Whether this peer can be asked for this piece now: it is not choking us, or
  * it allows this piece while it does (BEP 6, WebTorrent 2.8.5 `_updateWire`).

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