@dxos/network-manager 0.3.9-main.320ebac → 0.3.9-main.35264cb

package/src/topology/mmst-topology.ts

@@ -10,6 +10,9 @@ import { log } from '@dxos/log';
 
 import { type SwarmController, type Topology } from './topology';
 
+const MIN_UPDATE_INTERVAL = 1000 * 10;
+const MAX_CHANGES_PER_UPDATE = 1;
+
 export interface MMSTTopologyOptions {
   /**
    * Number of connections the peer will originate by itself.
@@ -36,6 +39,8 @@ export class MMSTTopology implements Topology {
 
   private _sampleCollected = false;
 
+  private _lastAction = new Date(0);
+
   constructor({ originateConnections = 2, maxPeers = 4, sampleSize = 10 }: MMSTTopologyOptions = {}) {
     this._originateConnections = originateConnections;
     this._maxPeers = maxPeers;
@@ -74,22 +79,45 @@ export class MMSTTopology implements Topology {
     invariant(this._controller, 'Not initialized');
     const { connected, candidates, ownPeerId } = this._controller.getState();
 
+    // TODO(nf): does this rate limiting/flap dampening logic belong here or in the SwarmController?
     if (connected.length > this._maxPeers) {
       // Disconnect extra peers.
+      log(`disconnect ${connected.length - this._maxPeers} peers.`);
       const sorted = sortByXorDistance(connected, ownPeerId)
         .reverse()
         .slice(0, this._maxPeers - connected.length);
-      for (const peer of sorted) {
-        log(`Disconnect ${peer}.`);
-        this._controller.disconnect(peer);
+      invariant(sorted.length === 0);
+
+      if (sorted.length > MAX_CHANGES_PER_UPDATE) {
+        log(`want to disconnect ${sorted.length} peers but limited to ${MAX_CHANGES_PER_UPDATE}`);
+      }
+
+      if (Date.now() - this._lastAction.getTime() > MIN_UPDATE_INTERVAL) {
+        for (const peer of sorted.slice(0, MAX_CHANGES_PER_UPDATE)) {
+          log(`Disconnect ${peer}.`);
+          this._controller.disconnect(peer);
+        }
+        this._lastAction = new Date();
+      } else {
+        log('rate limited discconnect');
       }
     } else if (connected.length < this._originateConnections) {
       // Connect new peers to reach desired quota.
+      log(`connect ${this._originateConnections - connected.length} peers.`);
       const sample = candidates.sort(() => Math.random() - 0.5).slice(0, this._sampleSize);
       const sorted = sortByXorDistance(sample, ownPeerId).slice(0, this._originateConnections - connected.length);
-      for (const peer of sorted) {
-        log(`Connect ${peer}.`);
-        this._controller.connect(peer);
+
+      if (sorted.length > MAX_CHANGES_PER_UPDATE) {
+        log(`want to connect ${sorted.length} peers but limited to ${MAX_CHANGES_PER_UPDATE}`);
+      }
+      if (Date.now() - this._lastAction.getTime() > MIN_UPDATE_INTERVAL) {
+        for (const peer of sorted.slice(0, MAX_CHANGES_PER_UPDATE)) {
+          log(`Connect ${peer}.`);
+          this._controller.connect(peer);
+        }
+        this._lastAction = new Date();
+      } else {
+        log('rate limited connect');
       }
     }
   }

package/src/transport/index.ts

@@ -7,6 +7,5 @@ export * from './transport';
 export * from './simplepeer-transport';
 export * from './simplepeer-transport-service';
 export * from './simplepeer-transport-proxy';
-export * from './datachannel';
 export * from './libdatachannel-transport';
 export * from './tcp-transport';

package/src/transport/libdatachannel-transport.test.ts

@@ -2,10 +2,6 @@
 // Copyright 2023 DXOS.org
 //
 
-//
-// Copyright 2020 DXOS.org
-//
-
 import { Duplex } from 'stream';
 
 import { sleep, TestStream } from '@dxos/async';

package/src/transport/libdatachannel-transport.ts

@@ -9,7 +9,6 @@ import { ErrorStream } from '@dxos/debug';
 import { log } from '@dxos/log';
 import { type Signal } from '@dxos/protocols/proto/dxos/mesh/swarm';
 
-import { type PeerConnection } from './datachannel/rtc-peer-connection';
 import { type Transport, type TransportFactory, type TransportStats } from './transport';
 
 export type LibDataChannelTransportParams = {
@@ -34,7 +33,7 @@ export class LibDataChannelTransport implements Transport {
   private _connected = false;
   readonly connected = new Event();
   readonly errors = new ErrorStream();
-  private readonly _peer: Promise<PeerConnection>;
+  private readonly _peer: Promise<RTCPeerConnection>;
   private _channel!: RTCDataChannel;
   private _stream!: Duplex;
 
@@ -43,11 +42,20 @@ export class LibDataChannelTransport implements Transport {
 
   constructor(private readonly params: LibDataChannelTransportParams) {
     this._peer = (async () => {
-      const { RTCPeerConnection: PeerConnection } = await import('./datachannel');
+      /* eslint-disable @typescript-eslint/consistent-type-imports */
+      const { RTCPeerConnection } = (await importESM('node-datachannel/polyfill'))
+        .default as typeof import('node-datachannel/polyfill');
+      /* eslint-enable @typescript-eslint/consistent-type-imports */
       if (this._closed) {
         this.errors.raise(new Error('connection already closed'));
       }
-      const peer = new PeerConnection(params.webrtcConfig);
+      // workaround https://github.com/murat-dogan/node-datachannel/pull/207
+      if (params.webrtcConfig) {
+        params.webrtcConfig.iceServers = params.webrtcConfig.iceServers ?? [];
+      } else {
+        params.webrtcConfig = { iceServers: [] };
+      }
+      const peer = new RTCPeerConnection(params.webrtcConfig);
 
       peer.onicecandidateerror = (event) => {
         log.error('peer.onicecandidateerror', { event });
@@ -84,10 +92,14 @@ export class LibDataChannelTransport implements Transport {
           }
         }
       };
+
       if (params.initiator) {
         peer
           .createOffer()
           .then(async (offer) => {
+            if (this._closed) {
+              return;
+            }
             if (peer.connectionState !== 'connecting') {
               log.error('i am initiator but peer not in state connecting', { peer });
               this.errors.raise(new Error('invalid state: peer is initiator, but other peer not in state connecting'));
@@ -184,6 +196,12 @@ export class LibDataChannelTransport implements Transport {
       return;
     }
     await this._disconnectStreams();
+    const peer = await this._peer;
+    try {
+      peer.close();
+    } catch (err: any) {
+      this.errors.raise(err);
+    }
     this._closed = true;
     this.closed.emit();
   }
@@ -238,39 +256,60 @@ export class LibDataChannelTransport implements Transport {
   }
 
   async getDetails(): Promise<string> {
-    return this._peer
-      .then(async (peer) => {
-        const cp = await peer.getSelectedCandidatePair();
-        if (!cp) {
-          return 'unavailable';
-        }
-        return `${cp.remote.address}:${cp.remote.port}/${cp.remote.transportType} ${cp.remote.type}`;
-      })
-      .catch((err) => {
-        log.catch(err);
-        return 'unavailable';
-      });
+    const stats = await this._getStats();
+    const rc = stats?.remoteCandidate;
+    if (!rc) {
+      return 'unavailable';
+    }
+
+    if (rc.candidateType === 'relay') {
+      return `${rc.ip}:${rc.port} relay for ${rc.relatedAddress}:${rc.relatedPort}`;
+    }
+    return `${rc.ip}:${rc.port} ${rc.candidateType}`;
+  }
+
+  async _getStats(): Promise<any> {
+    return this._peer.then(async (peer) => {
+      const stats = await peer.getStats();
+
+      const statsEntries = Array.from((stats as any).entries() as any[]);
+      const transport = statsEntries.filter((s) => s[1].type === 'transport')[0][1];
+      const candidatePair = statsEntries.filter((s: any) => s[0] === transport.selectedCandidatePairId);
+      let selectedCandidatePair: any;
+      let remoteCandidate: any;
+      if (candidatePair.length > 0) {
+        selectedCandidatePair = candidatePair[0][1];
+        remoteCandidate = statsEntries.filter((s: any) => s[0] === selectedCandidatePair.remoteCandidateId)[0][1];
+      }
+
+      return {
+        transport,
+        selectedCandidatePair,
+        remoteCandidate,
+        raw: Object.fromEntries(stats as any),
+      };
+    });
   }
 
   async getStats(): Promise<TransportStats> {
-    return this._peer
-      .then((peer) => {
-        return {
-          bytesSent: peer.bytesSent(),
-          bytesReceived: peer.bytesReceived(),
-          packetsSent: 0,
-          packetsReceived: 0,
-        };
-      })
-      .catch((err) => {
-        log.catch(err);
-        return {
-          bytesSent: 0,
-          bytesReceived: 0,
-          packetsSent: 0,
-          packetsReceived: 0,
-        };
-      });
+    const stats = await this._getStats();
+    if (!stats) {
+      return {
+        bytesSent: 0,
+        bytesReceived: 0,
+        packetsSent: 0,
+        packetsReceived: 0,
+        rawStats: {},
+      };
+    }
+
+    return {
+      bytesSent: stats.transport.bytesSent,
+      bytesReceived: stats.transport.bytesReceived,
+      packetsSent: 0,
+      packetsReceived: 0,
+      rawStats: stats.raw,
+    };
   }
 
   // TODO(nf): add classmethod to call node-datachannel.cleanup() when all instances have been destroyed?
@@ -290,3 +329,6 @@ export const createLibDataChannelTransportFactory = (webrtcConfig?: any): Transp
       webrtcConfig,
     }),
 });
+
+// eslint-disable-next-line no-new-func
+const importESM = Function('path', 'return import(path)');

package/src/transport/simplepeer-transport.ts

@@ -37,6 +37,9 @@ export class SimplePeerTransport implements Transport {
 
   private readonly _instanceId = PublicKey.random().toHex();
 
+  /**
+   * @params opts.config formatted as per https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/RTCPeerConnection
+   */
   constructor(private readonly params: SimplePeerTransportParams) {
     log.trace('dxos.mesh.webrtc-transport.constructor', trace.begin({ id: this._instanceId }));
     log('created connection', params);
@@ -142,8 +145,8 @@ export class SimplePeerTransport implements Transport {
     return {
       bytesSent: stats.transport.bytesSent,
       bytesReceived: stats.transport.bytesReceived,
-      packetsSent: stats.transport.messagesSent,
-      packetsReceived: stats.transport.messagesReceived,
+      packetsSent: stats.transport.packetsSent,
+      packetsReceived: stats.transport.packetsReceived,
       rawStats: stats.raw,
     };
   }
@@ -179,8 +182,8 @@ export class SimplePeerTransport implements Transport {
       return 'unavailable';
     }
 
-    if (rc.relay) {
-      return `${rc.ip}:${rc.port}/${rc.protocol} relay for XXX ${rc.candidateType}`;
+    if (rc.candidateType === 'relay') {
+      return `${rc.ip}:${rc.port}/${rc.protocol} relay for ${rc.relatedAddress}:${rc.relatedPort}`;
     }
     return `${rc.ip}:${rc.port}/${rc.protocol} ${rc.candidateType}`;
   }
@@ -190,7 +193,6 @@ export class SimplePeerTransport implements Transport {
     if (this._closed) {
       return;
     }
-    this._closed = true;
     this._disconnectStreams();
     this._peer!.destroy();
     this._closed = true;