@dxos/network-manager 0.4.10-main.fd4f2a3 → 0.4.10-next.71cec10

package/src/transport/libdatachannel-transport.ts

@@ -6,146 +6,196 @@ import { Duplex } from 'stream';
 
 import { Event, Trigger, synchronized } from '@dxos/async';
 import { ErrorStream } from '@dxos/debug';
+import { invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
 import { type Signal } from '@dxos/protocols/proto/dxos/mesh/swarm';
 
-import { type Transport, type TransportFactory, type TransportStats } from './transport';
-
-export type LibDataChannelTransportParams = {
-  initiator: boolean;
-  stream: NodeJS.ReadWriteStream;
-  webrtcConfig?: RTCConfiguration;
-  sendSignal: (signal: Signal) => Promise<void>;
-};
+import { type Transport, type TransportFactory, type TransportOptions, type TransportStats } from './transport';
 
 const DATACHANNEL_LABEL = 'dxos.mesh.transport';
 const MAX_BUFFERED_AMOUNT = 64 * 1024;
 
-// https://viblast.com/blog/2015/2/5/webrtc-data-channel-message-size/
+// https://viblast.com/blog/2015/2/5/webrtc-data-channel-message-size
 const MAX_MESSAGE_SIZE = 64 * 1024;
 
+export type LibDataChannelTransportOptions = TransportOptions & {
+  webrtcConfig?: RTCConfiguration;
+};
+
+export const createLibDataChannelTransportFactory = (webrtcConfig?: any): TransportFactory => ({
+  createTransport: (options) => new LibDataChannelTransport({ ...options, webrtcConfig }),
+});
+
 /**
  * Transport
  */
+// TODO(burdon): Purpose (e.g., platform).
 export class LibDataChannelTransport implements Transport {
   private static _instanceCount = 0;
+
+  private _peer?: RTCPeerConnection;
+  private _channel!: RTCDataChannel;
+  private _stream!: Duplex;
+
   private _closed = false;
-  readonly closed = new Event();
   private _connected = false;
+
+  private _writeCallback: (() => void) | null = null;
+  private readonly _readyForCandidates = new Trigger();
+
+  readonly closed = new Event();
   readonly connected = new Event();
   readonly errors = new ErrorStream();
-  private readonly _peer: Promise<RTCPeerConnection>;
-  private _channel!: RTCDataChannel;
-  private _stream!: Duplex;
 
-  private readonly _readyForCandidates = new Trigger();
-  private _writeCallback: (() => void) | null = null;
+  constructor(private readonly _options: LibDataChannelTransportOptions) {}
 
-  constructor(private readonly params: LibDataChannelTransportParams) {
-    this._peer = (async () => {
-      /* 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'));
-      }
-      // 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);
-      LibDataChannelTransport._instanceCount++;
+  get isOpen() {
+    return !!this._peer && !this._closed;
+  }
 
-      peer.onicecandidateerror = (event) => {
-        log.error('peer.onicecandidateerror', { event });
-      };
+  async open() {
+    if (this._closed) {
+      // TODO(burdon): Make idempotent?
+      this.errors.raise(new Error('connection already closed'));
+    }
 
-      peer.onconnectionstatechange = (event) => {
-        log.debug('peer.onconnectionstatechange', {
-          event,
-          peerConnectionState: peer.connectionState,
-          transportConnectionState: this._connected,
-        });
-        // TODO(nf): throw error if datachannel does not connect after some time?
-      };
+    // TODO(burdon): Move to factory?
+    /* eslint-disable @typescript-eslint/consistent-type-imports */
+    const { RTCPeerConnection } = (await importESM('node-datachannel/polyfill'))
+      .default as typeof import('node-datachannel/polyfill');
 
-      peer.onicecandidate = async (event) => {
-        log.debug('peer.onicecandidate', { event });
-        if (event.candidate) {
-          try {
-            await params.sendSignal({
-              payload: {
-                data: {
-                  type: 'candidate',
-                  candidate: {
-                    candidate: event.candidate.candidate,
-                    // these fields never seem to be not null, but connecting to Chrome doesn't work if they are
-                    sdpMLineIndex: event.candidate.sdpMLineIndex ?? 0,
-                    sdpMid: event.candidate.sdpMid ?? 0,
-                  },
+    // 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: [] };
+    }
+
+    this._peer = new RTCPeerConnection(this._options.webrtcConfig);
+
+    this._peer.onicecandidateerror = (event) => {
+      log.error('peer.onicecandidateerror', { event });
+    };
+
+    this._peer.onconnectionstatechange = (event) => {
+      log.debug('peer.onconnectionstatechange', {
+        event,
+        peerConnectionState: this._peer?.connectionState,
+        transportConnectionState: this._connected,
+      });
+      // TODO(nf): throw error if datachannel does not connect after some time?
+      // TODO(burdon): Restart ICE.
+    };
+
+    this._peer.onicecandidate = async (event) => {
+      log.debug('peer.onicecandidate', { event });
+      if (event.candidate) {
+        try {
+          await this._options.sendSignal({
+            payload: {
+              data: {
+                type: 'candidate',
+                candidate: {
+                  candidate: event.candidate.candidate,
+                  // These fields never seem to be not null, but connecting to Chrome doesn't work if they are.
+                  sdpMLineIndex: event.candidate.sdpMLineIndex ?? 0,
+                  sdpMid: event.candidate.sdpMid ?? 0,
                 },
               },
-            });
-          } catch (err) {
-            log.info('signaling errror', { err });
+            },
+          });
+        } catch (err) {
+          log.info('signaling error', { err });
+        }
+      }
+    };
+
+    if (this._options.initiator) {
+      invariant(this._peer, 'not open');
+      // TODO(burdon): Deprecated negotiation pattern?
+      //  https://developer.mozilla.org/en-US/docs/Web/API/WebRTC_API/Perfect_negotiation
+      this._peer
+        .createOffer()
+        .then(async (offer) => {
+          if (this._closed) {
+            return;
           }
+
+          if (this._peer?.connectionState !== 'connecting') {
+            log.error('peer not connecting', { peer: this._peer });
+            this.errors.raise(new Error('invalid state: peer is initiator, but other peer not in state connecting'));
+          }
+
+          log.debug('creating offer', { peer: this._peer, offer });
+          await this._peer!.setLocalDescription(offer);
+          await this._options.sendSignal({ payload: { data: { type: offer.type, sdp: offer.sdp } } });
+        })
+        .catch((err) => {
+          this.errors.raise(err);
+        });
+
+      this._handleChannel(this._peer.createDataChannel(DATACHANNEL_LABEL));
+
+      log.debug('created data channel');
+      this._peer.ondatachannel = () => {
+        this.errors.raise(new Error('unexpected ondatachannel event for initiator'));
+      };
+    } else {
+      this._peer.ondatachannel = (event) => {
+        log.debug('peer.ondatachannel (non-initiator)', { event });
+        // TODO(nf): should the label contain some identifier?
+        if (event.channel.label !== DATACHANNEL_LABEL) {
+          this.errors.raise(new Error(`unexpected channel label ${event.channel.label}`));
         }
+
+        this._handleChannel(event.channel);
       };
+    }
 
-      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'));
-            }
-            log.debug(`im the initiator, creating offer, peer is in state ${peer.connectionState}`, { offer });
-            await peer.setLocalDescription(offer);
-            await params.sendSignal({ payload: { data: { type: offer.type, sdp: offer.sdp } } });
-            return offer;
-          })
-          .catch((err) => {
-            this.errors.raise(err);
-          });
-        this.handleChannel(peer.createDataChannel(DATACHANNEL_LABEL));
-        log.debug('created data channel');
-        peer.ondatachannel = (event) => {
-          this.errors.raise(new Error('got ondatachannel when i am the initiator?'));
-        };
-      } else {
-        peer.ondatachannel = (event) => {
-          log.debug('peer.ondatachannel (non-initiator)', { event });
-          // TODO(nf): should the label contain some identifier?
-          if (event.channel.label !== DATACHANNEL_LABEL) {
-            this.errors.raise(new Error(`unexpected channel label ${event.channel.label}`));
-          }
-          this.handleChannel(event.channel);
-        };
-      }
+    LibDataChannelTransport._instanceCount++;
+  }
 
-      return peer;
-    })();
+  async close() {
+    await this._close();
+    if (--LibDataChannelTransport._instanceCount === 0) {
+      (await importESM('node-datachannel')).cleanup();
+    }
   }
 
-  private handleChannel(dataChannel: RTCDataChannel) {
+  @synchronized
+  private async _close() {
+    if (this._closed) {
+      return;
+    }
+    await this._disconnectStreams();
+
+    try {
+      this._peer?.close();
+    } catch (err: any) {
+      this.errors.raise(err);
+    }
+
+    this._peer = undefined;
+    this._closed = true;
+    this.closed.emit();
+  }
+
+  /**
+   * Handle data channel events.
+   */
+  private _handleChannel(dataChannel: RTCDataChannel) {
     this._channel = dataChannel;
+
     this._channel.onopen = () => {
-      log.debug('dataChannel.onopen');
+      log.debug('channel.onopen');
       const duplex = new Duplex({
         read: () => {},
         write: async (chunk, encoding, callback) => {
-          // todo wait to open
-
+          // TODO(nf): Wait to open.
           if (chunk.length > MAX_MESSAGE_SIZE) {
             this.errors.raise(new Error(`message too large: ${chunk.length} > ${MAX_MESSAGE_SIZE}`));
           }
+
           try {
             dataChannel.send(chunk);
           } catch (err: any) {
@@ -154,7 +204,7 @@ export class LibDataChannelTransport implements Transport {
           }
           if (this._channel.bufferedAmount > MAX_BUFFERED_AMOUNT) {
             if (this._writeCallback !== null) {
-              log.error("consumer trying to write before we're ready for more data");
+              log.error('consumer trying to write before we are ready for more data');
             }
             this._writeCallback = callback;
           } else {
@@ -163,98 +213,86 @@ export class LibDataChannelTransport implements Transport {
         },
       });
 
-      duplex.pipe(this.params.stream).pipe(duplex);
+      duplex.pipe(this._options.stream).pipe(duplex);
       this._stream = duplex;
       this._connected = true;
       this.connected.emit();
     };
 
+    this._channel.onclose = async (err) => {
+      log.info('channel.onclose', { err });
+      await this._close();
+    };
+
     this._channel.onerror = async (err) => {
       this.errors.raise(new Error('channel error: ' + err.toString()));
       await this._close();
     };
-    this._channel.onclose = async (err) => {
-      log.info('channel onclose', { err });
-      await this._close();
+
+    this._channel.onbufferedamountlow = () => {
+      const cb = this._writeCallback;
+      this._writeCallback = null;
+      cb?.();
     };
+
     this._channel.onmessage = (event) => {
       let data = event.data;
       if (data instanceof ArrayBuffer) {
         data = Buffer.from(data);
       }
-      this._stream.push(data);
-    };
 
-    this._channel.onbufferedamountlow = () => {
-      const cb = this._writeCallback;
-      this._writeCallback = null;
-      cb?.();
+      this._stream.push(data);
     };
   }
 
-  @synchronized
-  private async _close() {
-    if (this._closed) {
-      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();
-  }
+  async onSignal(signal: Signal) {
+    invariant(this._peer, 'not open');
 
-  signal(signal: Signal): void {
-    this._peer
-      .then(async (peer) => {
-        const data = signal.payload.data;
-        switch (data.type) {
-          case 'offer': {
-            if ((await this._peer).connectionState !== 'new') {
-              log.error('received offer but peer not in state new', { peer });
-              this.errors.raise(new Error('invalid signalling state: received offer when peer is not in state new'));
-              break;
-            }
-            try {
-              await peer.setRemoteDescription({ type: data.type, sdp: data.sdp });
-              const answer = await peer.createAnswer();
-              await peer.setLocalDescription(answer);
-              await this.params.sendSignal({ payload: { data: { type: answer.type, sdp: answer.sdp } } });
-              this._readyForCandidates.wake();
-            } catch (err) {
-              log.error("can't handle offer from signalling server", { err });
-              this.errors.raise(new Error('error handling offer'));
-            }
+    try {
+      const data = signal.payload.data;
+      switch (data.type) {
+        case 'offer': {
+          if (this._peer.connectionState !== 'new') {
+            log.error('received offer but peer not in state new', { peer: this._peer });
+            this.errors.raise(new Error('invalid signalling state: received offer when peer is not in state new'));
             break;
           }
 
-          case 'answer':
-            try {
-              await peer.setRemoteDescription({ type: data.type, sdp: data.sdp });
-              this._readyForCandidates.wake();
-            } catch (err) {
-              log.error("can't handle answer from signalling server", { err });
-              this.errors.raise(new Error('error handling answer'));
-            }
-            break;
+          try {
+            await this._peer.setRemoteDescription({ type: data.type, sdp: data.sdp });
+            const answer = await this._peer.createAnswer();
+            await this._peer.setLocalDescription(answer);
+            await this._options.sendSignal({ payload: { data: { type: answer.type, sdp: answer.sdp } } });
+            this._readyForCandidates.wake();
+          } catch (err) {
+            log.error('cannot handle offer from signalling server', { err });
+            this.errors.raise(new Error('error handling offer'));
+          }
+          break;
+        }
 
-          case 'candidate':
-            await this._readyForCandidates.wait();
-            await peer.addIceCandidate({ candidate: data.candidate.candidate });
-            break;
+        case 'answer':
+          try {
+            await this._peer.setRemoteDescription({ type: data.type, sdp: data.sdp });
+            this._readyForCandidates.wake();
+          } catch (err) {
+            log.error('cannot handle answer from signalling server', { err });
+            this.errors.raise(new Error('error handling answer'));
+          }
+          break;
 
-          default:
-            log.error('unhandled signal type', { type: data.type, signal });
-            this.errors.raise(new Error(`unhandled signal type ${data.type}`));
-        }
-      })
-      .catch((err) => {
-        log.catch(err);
-      });
+        case 'candidate':
+          await this._readyForCandidates.wait();
+          await this._peer.addIceCandidate({ candidate: data.candidate.candidate });
+          break;
+
+        default:
+          log.error('unhandled signal type', { type: data.type, signal });
+          this.errors.raise(new Error(`unhandled signal type ${data.type}`));
+      }
+    } catch (err) {
+      log.catch(err);
+    }
   }
 
   async getDetails(): Promise<string> {
@@ -267,30 +305,8 @@ export class LibDataChannelTransport implements Transport {
     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),
-      };
-    });
+    return `${rc.ip}:${rc.port} ${rc.candidateType}`;
   }
 
   async getStats(): Promise<TransportStats> {
@@ -314,25 +330,31 @@ export class LibDataChannelTransport implements Transport {
     };
   }
 
-  async destroy(): Promise<void> {
-    await this._close();
-    if (--LibDataChannelTransport._instanceCount === 0) {
-      (await importESM('node-datachannel')).cleanup();
+  async _getStats(): Promise<any> {
+    invariant(this._peer, 'not open');
+    const stats = await this._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),
+    };
   }
 
   private async _disconnectStreams() {
-    this.params.stream.unpipe?.(this._stream)?.unpipe?.(this.params.stream);
+    this._options.stream.unpipe?.(this._stream)?.unpipe?.(this._options.stream);
   }
 }
 
-export const createLibDataChannelTransportFactory = (webrtcConfig?: any): TransportFactory => ({
-  createTransport: (params) =>
-    new LibDataChannelTransport({
-      ...params,
-      webrtcConfig,
-    }),
-});
-
 // eslint-disable-next-line no-new-func
 const importESM = Function('path', 'return import(path)');

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

@@ -14,7 +14,7 @@ import { MemoryTransport } from './memory-transport';
 //  Attempted to log "Ignoring unsupported ICE candidate.".
 
 // TODO(burdon): Move to TestBuilder.
-const createPair = () => {
+const createPair = async () => {
   const topic = PublicKey.random();
   const peer1Id = PublicKey.random();
   const peer2Id = PublicKey.random();
@@ -23,26 +23,29 @@ const createPair = () => {
   const connection1 = new MemoryTransport({
     stream: stream1,
     sendSignal: async (signal) => {
-      await connection2.signal(signal);
+      await connection2.onSignal(signal);
     },
     initiator: true,
   });
 
-  afterTest(() => connection1.destroy());
+  afterTest(() => connection1.close());
   afterTest(() => connection1.errors.assertNoUnhandledErrors());
 
   const stream2 = new TestStream();
   const connection2 = new MemoryTransport({
     stream: stream2,
     sendSignal: async (signal) => {
-      await connection1.signal(signal);
+      await connection1.onSignal(signal);
     },
     initiator: false,
   });
 
-  afterTest(() => connection2.destroy());
+  afterTest(() => connection2.close());
   afterTest(() => connection2.errors.assertNoUnhandledErrors());
 
+  await connection1.open();
+  await connection2.open();
+
   return {
     connection1,
     connection2,
@@ -56,14 +59,14 @@ const createPair = () => {
 
 describe('MemoryTransport', () => {
   test('establish connection and send data through with protocol', async () => {
-    const { stream1, stream2 } = createPair();
+    const { stream1, stream2 } = await createPair();
     await TestStream.assertConnectivity(stream1, stream2);
   });
 
   test('10 pairs of peers connecting at the same time', async () => {
     await Promise.all(
       range(10).map(async () => {
-        const { stream1, stream2 } = createPair();
+        const { stream1, stream2 } = await createPair();
         await TestStream.assertConnectivity(stream1, stream2);
       }),
     );