@torrent-tv/proxy 2.87.7 → 2.87.9

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 2.87.9
+
+- **Fix**: Stop refreshing late sidecar metadata when the completed header read reports no audio tracks.
+
+## 2.87.8
+
+- **Fix**: Keep a viewer registered until every data channel on its WebRTC connection closes, and ignore a closing connection after the viewer has identified themselves on a replacement connection.
+
 ## 2.87.7
 
 - **Fix**: Refresh audio metadata for sidecar tracks after a delayed container-header read, keeping the existing track numbers and rendition count stable.

package/package.json

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

package/services/media/playback-planner.js

@@ -445,7 +445,7 @@ export function createPlaybackPlanner({
           tracks: tracks
             .filter((track) => track?.type === "audio")
             .sort((left, right) => (left.declaredIndex ?? 0) - (right.declaredIndex ?? 0)),
-          complete: Array.isArray(tracks) && tracks.length > 0
+          complete: Array.isArray(tracks)
         }))
         .catch((error) => {
           logger.info(`audio tracks: "${label}" could not be read (${error?.message ?? error})`);

package/services/transport/data-channel-handler.js

@@ -312,7 +312,7 @@ function makeSendQueueWatcher({ log, getTransportSnapshot, witness, usrsctpState
      *
      * @returns {void}
      */
-    const stop = () => {
+    const stop = (because = "the transport stopped answering") => {
       if (stopped) {
         return;
       }
@@ -332,7 +332,7 @@ function makeSendQueueWatcher({ log, getTransportSnapshot, witness, usrsctpState
         // because the first does not always come: a peer connection can die
         // without `onClosed`, which is why this watch was written in the first
         // place.
-        onConnectionGone?.(sessionId, "the transport stopped answering");
+        onConnectionGone?.(sessionId, because);
       }
     };
     // Independent of the queue: the transport's own counters, sampled for as
@@ -697,6 +697,16 @@ export function createDataChannelHandler({
    * @type {Map<string, Set<string>>}
    */
   const viewersOnConnection = new Map();
+  /**
+   * The newest connection currently carrying each viewer's identity.
+   *
+   * A reconnect can open its channels before the old connection finishes
+   * closing. The old connection must not release a viewer who has already
+   * identified themselves on the replacement.
+   *
+   * @type {Map<string, string>}
+   */
+  const connectionOfViewer = new Map();
 
   /**
    * Everyone on this connection has gone, because the connection has.
@@ -716,6 +726,10 @@ export function createDataChannelHandler({
       return;
     }
     for (const consumerId of viewers) {
+      if (connectionOfViewer.get(consumerId) !== sessionId) {
+        continue;
+      }
+      connectionOfViewer.delete(consumerId);
       onLog?.(`[dc] Session ${sessionId.slice(0, 8)}: viewer ${consumerId} left — ${because}`);
       try {
         onViewerGone(consumerId, because);
@@ -997,6 +1011,7 @@ export function createDataChannelHandler({
         const isNew = !known.has(message.consumerId);
         known.add(message.consumerId);
         viewersOnConnection.set(sessionId, known);
+        connectionOfViewer.set(message.consumerId, sessionId);
         channelOfViewer.set(message.consumerId, channel);
         if (isNew) {
           log(`[dc] Session ${tag}: viewer ${message.consumerId} is on this connection`);
@@ -1030,7 +1045,7 @@ export function createDataChannelHandler({
     });
 
     channel.onClosed(() => {
-      stopWatchdog();
+      stopWatchdog("the connection closed");
       deliveryProbe.detach(sessionId, channel);
       for (const entry of partials.values()) {
         clearTimeout(entry.timer);
@@ -1038,11 +1053,9 @@ export function createDataChannelHandler({
       partials.clear();
       forgetChannel(channel);
       log(`[dc] Session ${tag}: channel closed`);
-      // The ordinary way a viewer leaves, and the only one that is immediate.
-      // Everything else — a silence long enough to be called an absence, the
-      // transport's own counters going quiet — is a backstop for this event
-      // failing to arrive.
-      connectionGone(sessionId, "the connection closed");
+      // One closed data channel does not mean the peer connection is gone:
+      // media, control and probe channels can close independently. The shared
+      // transport watcher calls `connectionGone` when its last channel closes.
     });
 
     channel.onError((err) => {

package/test/data-channel-viewer-lifecycle.test.js

@@ -0,0 +1,92 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createDataChannelHandler } from "../services/transport/data-channel-handler.js";
+
+class FakeDataChannel {
+  constructor(label) {
+    this.label = label;
+    this.messages = [];
+    this.closed = null;
+  }
+
+  getLabel() {
+    return this.label;
+  }
+
+  onMessage(callback) {
+    this.message = callback;
+  }
+
+  onClosed(callback) {
+    this.closed = callback;
+  }
+
+  onError() {}
+
+  sendMessage(message) {
+    this.messages.push(message);
+  }
+
+  close() {
+    this.closed?.();
+  }
+}
+
+test("a viewer remains present until every data channel on the connection closes", () => {
+  const gone = [];
+  const handler = createDataChannelHandler({
+    proxyPort: 9090,
+    getTransportSnapshot: () => ({ bytesSent: 0, bytesReceived: 0 }),
+    onViewerGone: (consumerId, reason) => gone.push({ consumerId, reason })
+  });
+  const media = new FakeDataChannel("proxy");
+  const control = new FakeDataChannel("proxy-control");
+  const probe = new FakeDataChannel("proxy-fast");
+
+  handler.handleChannel("peer-session", media);
+  handler.handleChannel("peer-session", control);
+  handler.handleChannel("peer-session", probe);
+  control.message(JSON.stringify({ type: "viewer", consumerId: "viewer-1" }));
+
+  control.close();
+  assert.deepEqual(gone, [], "closing the control channel alone does not release the viewer");
+
+  media.close();
+  assert.deepEqual(gone, [], "the viewer remains while the probe channel is still open");
+
+  probe.close();
+  assert.deepEqual(gone, [
+    { consumerId: "viewer-1", reason: "the connection closed" }
+  ]);
+});
+
+test("a closing connection does not release a viewer already named on its replacement", () => {
+  const gone = [];
+  const handler = createDataChannelHandler({
+    proxyPort: 9090,
+    getTransportSnapshot: () => ({ bytesSent: 0, bytesReceived: 0 }),
+    onViewerGone: (consumerId, reason) => gone.push({ consumerId, reason })
+  });
+  const oldControl = new FakeDataChannel("proxy-control");
+  const oldMedia = new FakeDataChannel("proxy");
+  const newControl = new FakeDataChannel("proxy-control");
+  const newMedia = new FakeDataChannel("proxy");
+
+  handler.handleChannel("old-peer", oldControl);
+  handler.handleChannel("old-peer", oldMedia);
+  oldControl.message(JSON.stringify({ type: "viewer", consumerId: "viewer-1" }));
+  handler.handleChannel("new-peer", newControl);
+  handler.handleChannel("new-peer", newMedia);
+  newControl.message(JSON.stringify({ type: "viewer", consumerId: "viewer-1" }));
+
+  oldControl.close();
+  oldMedia.close();
+  assert.deepEqual(gone, [], "the old connection no longer owns the viewer");
+
+  newControl.close();
+  assert.deepEqual(gone, [], "the replacement still has its media channel");
+  newMedia.close();
+  assert.deepEqual(gone, [
+    { consumerId: "viewer-1", reason: "the connection closed" }
+  ]);
+});