@dxos/network-manager 0.3.8-next.f4e0086 → 0.3.9-main.03b62b6

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/datachannel/rtc-peer-connection.ts

@@ -2,7 +2,7 @@
 // Copyright 2023 DXOS.org
 //
 
-import node from 'node-datachannel';
+import node, { type SelectedCandidateInfo } from 'node-datachannel';
 import defer, { type DeferredPromise } from 'p-defer';
 
 import { DataChannel } from './rtc-data-channel';
@@ -45,21 +45,17 @@ export class PeerConnection extends EventTarget implements RTCPeerConnection {
     const iceServers = init.iceServers ?? [];
 
     this.#peerConnection = new node.PeerConnection(`peer-${Math.random()}`, {
+      // convert https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/RTCPeerConnection#iceservers to the format expected by https://github.com/murat-dogan/node-datachannel/blob/master/src/peer-connection-wrapper.cpp#L101
       iceServers: iceServers
         .map((server) => {
-          const urls = (Array.isArray(server.urls) ? server.urls : [server.urls]).map((str) => new URL(str));
+          const urls = Array.isArray(server.urls) ? server.urls : [server.urls];
 
           return urls.map((url) => {
-            /** @type {import('../lib/index.js').IceServer} */
-            const iceServer = {
-              hostname: url.hostname,
-              port: parseInt(url.port, 10),
-              username: server.username,
-              password: server.credential,
-              // relayType - how to specify?
-            };
-
-            return iceServer;
+            if (server.username && server.credential) {
+              const [protocol, rest] = url.split(/:(.*)/);
+              return `${protocol}:${server.username}:${server.credential}@${rest}`;
+            }
+            return url;
           });
         })
         .flat(),
@@ -188,6 +184,10 @@ export class PeerConnection extends EventTarget implements RTCPeerConnection {
     this.#peerConnection.addRemoteCandidate(candidate.candidate, candidate.sdpMid ?? '0');
   }
 
+  getSelectedCandidatePair(): { local: SelectedCandidateInfo; remote: SelectedCandidateInfo } | null {
+    return this.#peerConnection.getSelectedCandidatePair();
+  }
+
   addTrack(track: MediaStreamTrack, ...streams: MediaStream[]): RTCRtpSender {
     throw new Error('addTrack Not implemented');
   }
@@ -206,6 +206,14 @@ export class PeerConnection extends EventTarget implements RTCPeerConnection {
     this.#peerConnection.destroy();
   }
 
+  bytesSent(): number {
+    return this.#peerConnection.bytesSent();
+  }
+
+  bytesReceived(): number {
+    return this.#peerConnection.bytesReceived();
+  }
+
   createDataChannel(label: string, dataChannelDict: RTCDataChannelInit = {}): RTCDataChannel {
     const channel = this.#peerConnection.createDataChannel(label, dataChannelDict);
     const dataChannel = new DataChannel(channel, dataChannelDict);

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

@@ -10,7 +10,7 @@ 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 } from './transport';
+import { type Transport, type TransportFactory, type TransportStats } from './transport';
 
 export type LibDataChannelTransportParams = {
   initiator: boolean;
@@ -126,14 +126,18 @@ export class LibDataChannelTransport implements Transport {
       log.debug('dataChannel.onopen');
       const duplex = new Duplex({
         read: () => {},
-        write: (chunk, encoding, callback) => {
+        write: async (chunk, encoding, callback) => {
           // todo wait to open
 
           if (chunk.length > MAX_MESSAGE_SIZE) {
             this.errors.raise(new Error(`message too large: ${chunk.length} > ${MAX_MESSAGE_SIZE}`));
           }
-          dataChannel.send(chunk);
-
+          try {
+            dataChannel.send(chunk);
+          } catch (err: any) {
+            this.errors.raise(err);
+            await this._close();
+          }
           if (this._channel.bufferedAmount > MAX_BUFFERED_AMOUNT) {
             if (this._writeCallback !== null) {
               log.error("consumer trying to write before we're ready for more data");
@@ -233,6 +237,42 @@ 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';
+      });
+  }
+
+  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,
+        };
+      });
+  }
+
   // TODO(nf): add classmethod to call node-datachannel.cleanup() when all instances have been destroyed?
   async destroy(): Promise<void> {
     await this._close();

package/src/transport/memory-transport.ts

@@ -12,7 +12,7 @@ import { log, logInfo } from '@dxos/log';
 import { type Signal } from '@dxos/protocols/proto/dxos/mesh/swarm';
 import { ComplexMap } from '@dxos/util';
 
-import { type Transport, type TransportFactory, type TransportOptions } from './transport';
+import { type Transport, type TransportFactory, type TransportOptions, type TransportStats } from './transport';
 
 // TODO(burdon): Make configurable.
 // Delay (in milliseconds) for data being sent through in-memory connections to simulate network latency.
@@ -166,4 +166,17 @@ export class MemoryTransport implements Transport {
       this._remote.wake(remoteId);
     }
   }
+
+  async getDetails(): Promise<string> {
+    return this._instanceId.toHex();
+  }
+
+  async getStats(): Promise<TransportStats> {
+    return {
+      bytesSent: 0,
+      bytesReceived: 0,
+      packetsSent: 0,
+      packetsReceived: 0,
+    };
+  }
 }

package/src/transport/simplepeer-transport-proxy.ts

@@ -22,7 +22,7 @@ import { ConnectionState, type BridgeEvent, type BridgeService } from '@dxos/pro
 import { type Signal } from '@dxos/protocols/proto/dxos/mesh/swarm';
 import { arrayToBuffer } from '@dxos/util';
 
-import { type Transport, type TransportFactory, type TransportOptions } from './transport';
+import { type Transport, type TransportFactory, type TransportOptions, type TransportStats } from './transport';
 
 const RESP_MIN_THRESHOLD = 500;
 const TIMEOUT_THRESHOLD = 10;
@@ -145,6 +145,14 @@ export class SimplePeerTransportProxy implements Transport {
       .catch((err) => this.errors.raise(decodeError(err)));
   }
 
+  async getDetails(): Promise<string> {
+    return (await this._params.bridgeService.getDetails({ proxyId: this._proxyId })).details;
+  }
+
+  async getStats(): Promise<TransportStats> {
+    return (await this._params.bridgeService.getStats({ proxyId: this._proxyId })).stats as TransportStats;
+  }
+
   // TODO(burdon): Move open from constructor.
   async destroy(): Promise<void> {
     await this._ctx.dispose();

package/src/transport/simplepeer-transport-service.ts

@@ -16,6 +16,10 @@ import {
   type BridgeEvent,
   ConnectionState,
   type CloseRequest,
+  type DetailsRequest,
+  type DetailsResponse,
+  type StatsRequest,
+  type StatsResponse,
 } from '@dxos/protocols/proto/dxos/mesh/bridge';
 import { ComplexMap } from '@dxos/util';
 
@@ -113,6 +117,16 @@ export class SimplePeerTransportService implements BridgeService {
     await this.transports.get(proxyId)!.transport.signal(signal);
   }
 
+  async getDetails({ proxyId }: DetailsRequest): Promise<DetailsResponse> {
+    invariant(this.transports.has(proxyId));
+    return { details: await this.transports.get(proxyId)!.transport.getDetails() };
+  }
+
+  async getStats({ proxyId }: StatsRequest): Promise<StatsResponse> {
+    invariant(this.transports.has(proxyId));
+    return { stats: await this.transports.get(proxyId)!.transport.getStats() };
+  }
+
   async sendData({ proxyId, payload }: DataRequest): Promise<void> {
     if (this.transports.get(proxyId)?.state !== 'OPEN') {
       log.debug('transport is closed');

package/src/transport/simplepeer-transport.ts

@@ -13,7 +13,7 @@ import { log } from '@dxos/log';
 import { ConnectionResetError, ConnectivityError, ProtocolError, UnknownProtocolError, trace } from '@dxos/protocols';
 import { type Signal } from '@dxos/protocols/proto/dxos/mesh/swarm';
 
-import { type Transport, type TransportFactory } from './transport';
+import { type Transport, type TransportFactory, type TransportStats } from './transport';
 import { wrtc } from './webrtc';
 
 export type SimplePeerTransportParams = {
@@ -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);
@@ -71,6 +74,7 @@ export class SimplePeerTransport implements Transport {
         if (err.errorDetail === 'sctp-failure') {
           this.errors.raise(new ConnectionResetError('sctp-failure from RTCError', err));
         } else {
+          log.info('unknown RTCError', { err });
           this.errors.raise(new UnknownProtocolError('unknown RTCError', err));
         }
         // catch more generic simple-peer errors: https://github.com/feross/simple-peer/blob/master/README.md#error-codes
@@ -80,10 +84,12 @@ export class SimplePeerTransport implements Transport {
           case 'ERR_WEBRTC_SUPPORT':
             this.errors.raise(new ProtocolError('WebRTC not supported', err));
             break;
+          case 'ERR_SIGNALING':
+            this.errors.raise(new ConnectivityError('signaling failure', err));
+            break;
           case 'ERR_ICE_CONNECTION_FAILURE':
           case 'ERR_DATA_CHANNEL':
           case 'ERR_CONNECTION_FAILURE':
-          case 'ERR_SIGNALING':
             this.errors.raise(new ConnectivityError('unknown communication failure', err));
             break;
           // errors due to library issues or improper API usage
@@ -109,7 +115,7 @@ export class SimplePeerTransport implements Transport {
           (this._peer as any)._pc.getStats().then((stats: any) => {
             log.info('report after webrtc error', {
               config: this.params.webrtcConfig,
-              stats,
+              stats: Object.fromEntries((stats as any).entries()),
             });
           });
         }
@@ -119,17 +125,77 @@ export class SimplePeerTransport implements Transport {
 
       await this.destroy();
     });
+
     log.trace('dxos.mesh.webrtc-transport.constructor', trace.end({ id: this._instanceId }));
   }
 
+  async getStats(): Promise<TransportStats> {
+    const stats = await this._getStats();
+    if (!stats) {
+      return {
+        bytesSent: 0,
+        bytesReceived: 0,
+        packetsSent: 0,
+        packetsReceived: 0,
+        rawStats: {},
+      };
+    }
+
+    // TODO(nf): transport or candidatePair?
+    return {
+      bytesSent: stats.transport.bytesSent,
+      bytesReceived: stats.transport.bytesReceived,
+      packetsSent: stats.transport.messagesSent,
+      packetsReceived: stats.transport.messagesReceived,
+      rawStats: stats.raw,
+    };
+  }
+
+  async _getStats(): Promise<any> {
+    if (typeof (this._peer as any)?._pc?.getStats !== 'function') {
+      return null;
+    }
+    return await (this._peer as any)._pc.getStats().then((stats: any) => {
+      const statsEntries = Array.from(stats.entries() as any[]);
+      const transport = statsEntries.filter((s: any) => 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 {
+        datachannel: statsEntries.filter((s: any) => s[1].type === 'data-channel')[0][1],
+        transport,
+        selectedCandidatePair,
+        remoteCandidate,
+        raw: Object.fromEntries(stats.entries()),
+      };
+    });
+  }
+
+  async getDetails(): Promise<string> {
+    const stats = await this._getStats();
+    const rc = stats?.remoteCandidate;
+    if (!rc) {
+      return 'unavailable';
+    }
+
+    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}`;
+  }
+
   async destroy() {
     log('closing...');
     if (this._closed) {
       return;
     }
-    this._closed = true;
     this._disconnectStreams();
     this._peer!.destroy();
+    this._closed = true;
     this.closed.emit();
     log('closed');
   }

package/src/transport/tcp-transport.browser.ts

@@ -5,7 +5,7 @@
 import { Event } from '@dxos/async';
 import { ErrorStream } from '@dxos/debug';
 
-import { type Transport, type TransportFactory } from './transport';
+import { type Transport, type TransportFactory, type TransportStats } from './transport';
 
 // NOTE: Browser stub.
 
@@ -25,4 +25,12 @@ export class TcpTransport implements Transport {
   signal() {
     throw new Error('Method not implemented.');
   }
+
+  async getStats(): Promise<TransportStats> {
+    throw new Error('Method not implemented.');
+  }
+
+  async getDetails(): Promise<string> {
+    throw new Error('Method not implemented.');
+  }
 }

package/src/transport/tcp-transport.ts

@@ -9,7 +9,7 @@ import { ErrorStream } from '@dxos/debug';
 import { log } from '@dxos/log';
 import { type Signal } from '@dxos/protocols/proto/dxos/mesh/swarm';
 
-import { type Transport, type TransportFactory, type TransportOptions } from './transport';
+import { type Transport, type TransportFactory, type TransportOptions, type TransportStats } from './transport';
 
 export const TcpTransportFactory: TransportFactory = {
   createTransport: (params) => new TcpTransport(params),
@@ -87,6 +87,24 @@ export class TcpTransport implements Transport {
     socket.connect({ port: payload.port, host: 'localhost' });
   }
 
+  async getDetails(): Promise<string> {
+    if (this.options.initiator) {
+      const { port, address } = this._server?.address() as AddressInfo;
+      return `LISTEN ${address}:${port}`;
+    }
+    const { port, address } = this._socket?.address() as AddressInfo;
+    return `ACCEPT ${address}:${port}`;
+  }
+
+  async getStats(): Promise<TransportStats> {
+    return {
+      bytesSent: 0,
+      bytesReceived: 0,
+      packetsSent: 0,
+      packetsReceived: 0,
+    };
+  }
+
   private _handleSocket(socket: Socket) {
     log('handling socket', { remotePort: socket.remotePort, localPort: socket.localPort });
     this._socket = socket;

package/src/transport/transport.ts

@@ -4,6 +4,7 @@
 
 import { type Event } from '@dxos/async';
 import { type ErrorStream } from '@dxos/debug';
+import { type PublicKey } from '@dxos/keys';
 import { type Signal } from '@dxos/protocols/proto/dxos/mesh/swarm';
 
 export enum TransportKind {
@@ -22,6 +23,14 @@ export interface Transport {
   connected: Event;
   errors: ErrorStream;
 
+  /**
+   * Transport-specfic stats.
+   */
+  getStats(): Promise<TransportStats>;
+  /**
+   * Transport-specfic connection details.
+   */
+  getDetails(): Promise<string>;
   destroy(): Promise<void>;
   signal(signal: Signal): void;
 }
@@ -43,6 +52,8 @@ export type TransportOptions = {
   sendSignal: (signal: Signal) => Promise<void>; // TODO(burdon): Remove async?
 
   timeout?: number;
+
+  sessionId?: PublicKey;
 };
 
 /**
@@ -51,3 +62,11 @@ export type TransportOptions = {
 export interface TransportFactory {
   createTransport(options: TransportOptions): Transport;
 }
+
+export type TransportStats = {
+  bytesSent: number;
+  bytesReceived: number;
+  packetsSent: number;
+  packetsReceived: number;
+  rawStats?: any;
+};

package/src/wire-protocol.ts

@@ -23,7 +23,7 @@ export type WireProtocolProvider = (params: WireProtocolParams) => WireProtocol;
 export interface WireProtocol {
   stream: Duplex;
 
-  open(): Promise<void>;
+  open(sessionId?: PublicKey): Promise<void>;
   close(): Promise<void>;
   abort(): Promise<void>;
 }
@@ -40,8 +40,8 @@ export const createTeleportProtocolFactory = (
     const teleport = new Teleport(params);
     return {
       stream: teleport.stream,
-      open: async () => {
-        await teleport.open();
+      open: async (sessionId?: PublicKey) => {
+        await teleport.open(sessionId);
         await onConnection(teleport);
       },
       close: async () => {