@dxos/network-manager 0.6.5 → 0.6.6-staging.23d123d

package/src/swarm/connection.ts

@@ -3,7 +3,7 @@
 //
 
 import { DeferredTask, Event, sleep, scheduleTask, scheduleTaskInterval, synchronized, Trigger } from '@dxos/async';
-import { Context, cancelWithContext } from '@dxos/context';
+import { Context, cancelWithContext, ContextDisposedError } from '@dxos/context';
 import { ErrorStream } from '@dxos/debug';
 import { invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
@@ -381,7 +381,11 @@ export class Connection {
       });
     } catch (err) {
       // TODO(nf): determine why instanceof doesn't work here
-      if (err instanceof CancelledError || (err instanceof Error && err.message?.includes('CANCELLED'))) {
+      if (
+        err instanceof CancelledError ||
+        err instanceof ContextDisposedError ||
+        (err instanceof Error && err.message?.includes('CANCELLED'))
+      ) {
         return;
       }
 

package/src/transport/libdatachannel-transport.ts

@@ -11,6 +11,7 @@ import { log } from '@dxos/log';
 import { type Signal } from '@dxos/protocols/proto/dxos/mesh/swarm';
 
 import { type Transport, type TransportFactory, type TransportOptions, type TransportStats } from './transport';
+import { type IceProvider } from '../signal';
 
 const DATACHANNEL_LABEL = 'dxos.mesh.transport';
 const MAX_BUFFERED_AMOUNT = 64 * 1024;
@@ -20,11 +21,22 @@ const MAX_MESSAGE_SIZE = 64 * 1024;
 
 export type LibDataChannelTransportOptions = TransportOptions & {
   webrtcConfig?: RTCConfiguration;
+  iceProvider?: IceProvider;
 };
 
-export const createLibDataChannelTransportFactory = (webrtcConfig?: any): TransportFactory => ({
-  createTransport: (options) => new LibDataChannelTransport({ ...options, webrtcConfig }),
-});
+export const createLibDataChannelTransportFactory = (
+  webrtcConfig?: RTCConfiguration,
+  iceProvider?: IceProvider,
+): TransportFactory => {
+  return {
+    createTransport: (options) =>
+      new LibDataChannelTransport({
+        ...options,
+        webrtcConfig,
+        iceProvider,
+      }),
+  };
+};
 
 /**
  * Transport
@@ -64,12 +76,16 @@ export class LibDataChannelTransport implements Transport {
     const { RTCPeerConnection } = (await importESM('node-datachannel/polyfill'))
       .default as typeof import('node-datachannel/polyfill');
 
+    const providedIceServers = await this._options.iceProvider?.getIceServers();
+
     // workaround https://github.com/murat-dogan/node-datachannel/pull/207
-    if (this._options.webrtcConfig) {
-      this._options.webrtcConfig.iceServers = this._options.webrtcConfig.iceServers ?? [];
-    } else {
-      this._options.webrtcConfig = { iceServers: [] };
+    if (!this._options.webrtcConfig) {
+      this._options.webrtcConfig = {};
     }
+    this._options.webrtcConfig.iceServers = [
+      ...(this._options.webrtcConfig.iceServers ?? []),
+      ...(providedIceServers ?? []),
+    ];
 
     this._peer = new RTCPeerConnection(this._options.webrtcConfig);
 

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

@@ -24,6 +24,7 @@ import {
 import { ComplexMap } from '@dxos/util';
 
 import { SimplePeerTransport } from './simplepeer-transport';
+import { type IceProvider } from '../signal';
 
 type TransportState = {
   transport: SimplePeerTransport;
@@ -35,7 +36,10 @@ type TransportState = {
 export class SimplePeerTransportService implements BridgeService {
   private readonly transports = new ComplexMap<PublicKey, TransportState>(PublicKey.hash);
 
-  constructor(private readonly _webrtcConfig?: any) {}
+  constructor(
+    private readonly _webrtcConfig?: RTCConfiguration,
+    private readonly _iceProvider?: IceProvider,
+  ) {}
 
   open(request: ConnectionRequest): Stream<BridgeEvent> {
     const rpcStream: Stream<BridgeEvent> = new Stream(({ ready, next, close }) => {
@@ -62,6 +66,7 @@ export class SimplePeerTransportService implements BridgeService {
             signal: { payload: signal },
           });
         },
+        iceProvider: this._iceProvider,
       });
 
       // TODO(burdon): Async.

package/src/transport/simplepeer-transport.ts

@@ -6,7 +6,7 @@
 import SimplePeerConstructor, { type Instance as SimplePeer } from 'simple-peer';
 import invariant from 'tiny-invariant';
 
-import { Event } from '@dxos/async';
+import { Event, synchronized } from '@dxos/async';
 import { ErrorStream, raise } from '@dxos/debug';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
@@ -15,20 +15,30 @@ import { type Signal } from '@dxos/protocols/proto/dxos/mesh/swarm';
 
 import { type Transport, type TransportFactory, type TransportOptions, type TransportStats } from './transport';
 import { wrtc } from './webrtc';
+import { type IceProvider } from '../signal';
 
 export type SimplePeerTransportParams = TransportOptions & {
-  webrtcConfig?: any;
+  webrtcConfig?: RTCConfiguration;
+  iceProvider?: IceProvider;
 };
 
-export const createSimplePeerTransportFactory = (webrtcConfig?: any): TransportFactory => ({
-  createTransport: (options) => new SimplePeerTransport({ ...options, webrtcConfig }),
+export const createSimplePeerTransportFactory = (
+  webrtcConfig?: RTCConfiguration,
+  iceProvider?: IceProvider,
+): TransportFactory => ({
+  createTransport: (options) =>
+    new SimplePeerTransport({
+      ...options,
+      webrtcConfig,
+      iceProvider,
+    }),
 });
 
 /**
  * Implements Transport for WebRTC. Uses simple-peer under the hood.
  */
 export class SimplePeerTransport implements Transport {
-  private readonly _peer: SimplePeer;
+  private _peer?: SimplePeer = undefined;
   private _closed = false;
   private _piped = false;
 
@@ -46,9 +56,81 @@ export class SimplePeerTransport implements Transport {
   /**
    * @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);
+  constructor(private readonly _params: SimplePeerTransportParams) {}
+
+  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.packetsSent,
+      packetsReceived: stats.transport.packetsReceived,
+      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}`;
+  }
+
+  @synchronized
+  async open() {
+    log.trace('dxos.mesh.webrtc-transport.open', trace.begin({ id: this._instanceId }));
+    log('created connection', { params: this._params });
+
+    const providedIceServers = await this._params.iceProvider?.getIceServers();
+    if (!this._params.webrtcConfig) {
+      this._params.webrtcConfig = {};
+    }
+    this._params.webrtcConfig.iceServers = [
+      ...(this._params.webrtcConfig.iceServers ?? []),
+      ...(providedIceServers ?? []),
+    ];
+
     this._peer = new SimplePeerConstructor({
       channelName: 'dxos.mesh.transport',
       initiator: this._params.initiator,
@@ -132,70 +214,10 @@ export class SimplePeerTransport implements Transport {
       await this.close();
     });
 
-    log.trace('dxos.mesh.webrtc-transport.constructor', trace.end({ id: this._instanceId }));
+    log.trace('dxos.mesh.webrtc-transport.open', 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.packetsSent,
-      packetsReceived: stats.transport.packetsReceived,
-      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 open() {}
-
+  @synchronized
   async close() {
     log('closing...');
     if (this._closed) {
@@ -208,12 +230,14 @@ export class SimplePeerTransport implements Transport {
     log('closed');
   }
 
+  @synchronized
   async onSignal(signal: Signal) {
     if (this._closed) {
       return; // Ignore signals after close.
     }
 
     invariant(signal.payload.data, 'Signal message must contain signal data.');
+    invariant(this._peer, 'Peer must be initialized before receiving signals.');
     this._peer.signal(signal.payload.data);
   }