@dxos/network-manager 0.1.57-main.e87098f → 0.1.57

package/src/transport/libdatachannel-transport.ts

@@ -0,0 +1,252 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { Duplex } from 'stream';
+
+import { Event, Trigger, synchronized } from '@dxos/async';
+import { ErrorStream } from '@dxos/debug';
+import { log } from '@dxos/log';
+import { Signal } from '@dxos/protocols/proto/dxos/mesh/swarm';
+
+import { type PeerConnection } from './datachannel/rtc-peer-connection';
+import { Transport, TransportFactory } from './transport';
+
+export type LibDataChannelTransportParams = {
+  initiator: boolean;
+  stream: NodeJS.ReadWriteStream;
+  webrtcConfig?: RTCConfiguration;
+  sendSignal: (signal: Signal) => Promise<void>;
+};
+
+const DATACHANNEL_LABEL = 'dxos.mesh.transport';
+const MAX_BUFFERED_AMOUNT = 64 * 1024;
+
+// https://viblast.com/blog/2015/2/5/webrtc-data-channel-message-size/
+const MAX_MESSAGE_SIZE = 64 * 1024;
+
+/**
+ * Transport
+ */
+export class LibDataChannelTransport implements Transport {
+  private _closed = false;
+  readonly closed = new Event();
+  private _connected = false;
+  readonly connected = new Event();
+  readonly errors = new ErrorStream();
+  private readonly _peer: Promise<PeerConnection>;
+  private _channel!: RTCDataChannel;
+  private _stream!: Duplex;
+
+  private readonly _readyForCandidates = new Trigger();
+  private _writeCallback: (() => void) | null = null;
+
+  constructor(private readonly params: LibDataChannelTransportParams) {
+    this._peer = (async () => {
+      const { RTCPeerConnection: PeerConnection } = await import('./datachannel');
+      if (this._closed) {
+        this.errors.raise(new Error('connection already closed'));
+      }
+      const peer = new PeerConnection(params.webrtcConfig);
+
+      peer.onicecandidateerror = (event) => {
+        log.error('peer.onicecandidateerror', { event });
+      };
+
+      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?
+      };
+
+      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,
+                  },
+                },
+              },
+            });
+          } catch (err) {
+            log.warn('signaling errror', { err });
+          }
+        }
+      };
+      if (params.initiator) {
+        peer
+          .createOffer()
+          .then(async (offer) => {
+            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);
+        };
+      }
+
+      return peer;
+    })();
+  }
+
+  private handleChannel(dataChannel: RTCDataChannel) {
+    this._channel = dataChannel;
+    this._channel.onopen = () => {
+      log.debug('dataChannel.onopen');
+      const duplex = new Duplex({
+        read: () => {},
+        write: (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);
+
+          if (this._channel.bufferedAmount > MAX_BUFFERED_AMOUNT) {
+            if (this._writeCallback !== null) {
+              log.error("consumer trying to write before we're ready for more data");
+            }
+            this._writeCallback = callback;
+          } else {
+            callback();
+          }
+        },
+      });
+
+      duplex.pipe(this.params.stream).pipe(duplex);
+      this._stream = duplex;
+      this._connected = true;
+      this.connected.emit();
+    };
+
+    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.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?.();
+    };
+  }
+
+  @synchronized
+  private async _close() {
+    if (this._closed) {
+      return;
+    }
+    await this._disconnectStreams();
+    this._closed = true;
+    this.closed.emit();
+  }
+
+  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'));
+            }
+            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;
+
+          case 'candidate':
+            await this._readyForCandidates.wait();
+            await 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);
+      });
+  }
+
+  // TODO(nf): add classmethod to call node-datachannel.cleanup() when all instances have been destroyed?
+  async destroy(): Promise<void> {
+    await this._close();
+  }
+
+  private async _disconnectStreams() {
+    this.params.stream.unpipe?.(this._stream)?.unpipe?.(this.params.stream);
+  }
+}
+
+export const createLibDataChannelTransportFactory = (webrtcConfig?: any): TransportFactory => ({
+  createTransport: (params) =>
+    new LibDataChannelTransport({
+      ...params,
+      webrtcConfig,
+    }),
+});

package/src/transport/{webrtc-transport-proxy.test.ts → simplepeer-transport-proxy-test.ts}

@@ -11,10 +11,10 @@ import { Signal } from '@dxos/protocols/proto/dxos/mesh/swarm';
 import { createLinkedPorts, createProtoRpcPeer, ProtoRpcPeer } from '@dxos/rpc';
 import { afterAll, afterTest, beforeAll, describe, test } from '@dxos/test';
 
-import { WebRTCTransportProxy } from './webrtc-transport-proxy';
-import { WebRTCTransportService } from './webrtc-transport-service';
+import { SimplePeerTransportProxy } from './simplepeer-transport-proxy';
+import { SimplePeerTransportService } from './simplepeer-transport-service';
 
-describe('WebRTCTransportProxy', () => {
+describe('SimplePeerTransportProxy', () => {
   const setupProxy = async ({
     initiator = true,
     stream = new TestStream(),
@@ -27,7 +27,7 @@ describe('WebRTCTransportProxy', () => {
     const [port1, port2] = createLinkedPorts();
 
     // Starting BridgeService
-    const webRTCTransportService: BridgeService = new WebRTCTransportService();
+    const simplePeerTransportService: BridgeService = new SimplePeerTransportService();
 
     // Starting BridgeService
     const rpcService = createProtoRpcPeer({
@@ -35,7 +35,7 @@ describe('WebRTCTransportProxy', () => {
       exposed: {
         BridgeService: schema.getService('dxos.mesh.bridge.BridgeService'),
       },
-      handlers: { BridgeService: webRTCTransportService },
+      handlers: { BridgeService: simplePeerTransportService },
       port: port1,
       noHandshake: true,
       encodingOptions: {
@@ -59,20 +59,20 @@ describe('WebRTCTransportProxy', () => {
     await rpcClient.open();
     afterTest(() => rpcClient.close());
 
-    const webRTCTransportProxy = new WebRTCTransportProxy({
+    const simplePeerTransportProxy = new SimplePeerTransportProxy({
       initiator,
       stream,
       sendSignal,
       bridgeService: rpcClient.rpc.BridgeService,
     });
-    afterTest(async () => await webRTCTransportProxy.destroy());
+    afterTest(async () => await simplePeerTransportProxy.destroy());
 
-    return { webRTCService: rpcService, webRTCTransportProxy };
+    return { simplePeerService: rpcService, SimplePeerTransportProxy: simplePeerTransportProxy };
   };
 
   // This doesn't clean up correctly and crashes with SIGSEGV / SIGABRT at the end. Probably an issue with wrtc package.
   test('open and close', async () => {
-    const { webRTCTransportProxy: connection } = await setupProxy();
+    const { SimplePeerTransportProxy: connection } = await setupProxy();
 
     const wait = connection.closed.waitForCount(1);
     await connection.destroy();
@@ -81,7 +81,7 @@ describe('WebRTCTransportProxy', () => {
 
   test('establish connection and send data through with protocol', async () => {
     const stream1 = new TestStream();
-    const { webRTCTransportProxy: connection1 } = await setupProxy({
+    const { SimplePeerTransportProxy: connection1 } = await setupProxy({
       initiator: true,
       stream: stream1,
       sendSignal: async (signal) => {
@@ -91,7 +91,7 @@ describe('WebRTCTransportProxy', () => {
     afterTest(() => connection1.errors.assertNoUnhandledErrors());
 
     const stream2 = new TestStream();
-    const { webRTCTransportProxy: connection2 } = await setupProxy({
+    const { SimplePeerTransportProxy: connection2 } = await setupProxy({
       initiator: false,
       stream: stream2,
       sendSignal: async (signal) => {
@@ -109,12 +109,12 @@ describe('WebRTCTransportProxy', () => {
     beforeAll(async () => {
       const [port1, port2] = createLinkedPorts();
 
-      const webRTCTransportService: BridgeService = new WebRTCTransportService();
+      const simplePeerTransportService: BridgeService = new SimplePeerTransportService();
       service = createProtoRpcPeer({
         exposed: {
           BridgeService: schema.getService('dxos.mesh.bridge.BridgeService'),
         },
-        handlers: { BridgeService: webRTCTransportService },
+        handlers: { BridgeService: simplePeerTransportService },
         port: port1,
         noHandshake: true,
         encodingOptions: {
@@ -143,7 +143,7 @@ describe('WebRTCTransportProxy', () => {
 
     test('establish connection and send data through with protocol', async () => {
       const stream1 = new TestStream();
-      const proxy1 = new WebRTCTransportProxy({
+      const proxy1 = new SimplePeerTransportProxy({
         initiator: true,
         stream: stream1,
         sendSignal: async (signal) => {
@@ -157,7 +157,7 @@ describe('WebRTCTransportProxy', () => {
       });
 
       const stream2 = new TestStream();
-      const proxy2 = new WebRTCTransportProxy({
+      const proxy2 = new SimplePeerTransportProxy({
         initiator: false,
         stream: stream2,
         sendSignal: async (signal) => {

package/src/transport/{webrtc-transport-proxy.ts → simplepeer-transport-proxy.ts}

@@ -17,7 +17,7 @@ import { arrayToBuffer } from '@dxos/util';
 
 import { Transport, TransportFactory, TransportOptions } from './transport';
 
-export type WebRTCTransportProxyParams = {
+export type SimplePeerTransportProxyParams = {
   initiator: boolean;
   stream: NodeJS.ReadWriteStream;
   bridgeService: BridgeService;
@@ -25,7 +25,7 @@ export type WebRTCTransportProxyParams = {
   sendSignal: (signal: Signal) => Promise<void>;
 };
 
-export class WebRTCTransportProxy implements Transport {
+export class SimplePeerTransportProxy implements Transport {
   private readonly _proxyId = PublicKey.random();
   private readonly _ctx = new Context();
 
@@ -38,7 +38,7 @@ export class WebRTCTransportProxy implements Transport {
 
   // prettier-ignore
   constructor(
-    private readonly _params: WebRTCTransportProxyParams
+    private readonly _params: SimplePeerTransportProxyParams
   ) {
     this._serviceStream = this._params.bridgeService.open({
       proxyId: this._proxyId,
@@ -48,7 +48,7 @@ export class WebRTCTransportProxy implements Transport {
     this._serviceStream.waitUntilReady().then(
       () => {
         this._serviceStream.subscribe(async (event: BridgeEvent) => {
-          log('WebRTCTransportProxy: event', event);
+          log('SimplePeerTransportProxy: event', event);
           if (event.connection) {
             await this._handleConnection(event.connection);
           } else if (event.data) {
@@ -142,9 +142,9 @@ export class WebRTCTransportProxy implements Transport {
 }
 
 // TODO(burdon): Why is this named Proxy?
-export class WebRTCTransportProxyFactory implements TransportFactory {
+export class SimplePeerTransportProxyFactory implements TransportFactory {
   private _bridgeService: BridgeService | undefined;
-  private _connections = new Set<WebRTCTransportProxy>();
+  private _connections = new Set<SimplePeerTransportProxy>();
 
   /**
    * Sets the current BridgeService to be used to open connections.
@@ -160,9 +160,9 @@ export class WebRTCTransportProxyFactory implements TransportFactory {
   }
 
   createTransport(options: TransportOptions): Transport {
-    invariant(this._bridgeService, 'WebRTCTransportProxyFactory is not ready to open connections');
+    invariant(this._bridgeService, 'SimplePeerTransportProxyFactory is not ready to open connections');
 
-    const transport = new WebRTCTransportProxy({
+    const transport = new SimplePeerTransportProxy({
       ...options,
       bridgeService: this._bridgeService,
     });

package/src/transport/{webrtc-transport-service.ts → simplepeer-transport-service.ts}

@@ -19,15 +19,15 @@ import {
 } from '@dxos/protocols/proto/dxos/mesh/bridge';
 import { ComplexMap } from '@dxos/util';
 
-import { WebRTCTransport } from './webrtc-transport';
+import { SimplePeerTransport } from './simplepeer-transport';
 
 type TransportState = {
-  transport: WebRTCTransport;
+  transport: SimplePeerTransport;
   stream: Duplex;
   writeCallbacks: (() => void)[];
 };
 
-export class WebRTCTransportService implements BridgeService {
+export class SimplePeerTransportService implements BridgeService {
   private readonly transports = new ComplexMap<PublicKey, TransportState>(PublicKey.hash);
 
   // prettier-ignore
@@ -51,7 +51,7 @@ export class WebRTCTransportService implements BridgeService {
         },
       });
 
-      const transport = new WebRTCTransport({
+      const transport = new SimplePeerTransport({
         initiator: request.initiator,
         stream: duplex,
         webrtcConfig: this._webrtcConfig,

package/src/transport/{webrtc-transport.test.ts → simplepeer-transport.test.ts}

@@ -7,12 +7,12 @@ import { Duplex } from 'stream';
 import { sleep, TestStream } from '@dxos/async';
 import { afterTest, describe, test } from '@dxos/test';
 
-import { WebRTCTransport } from './webrtc-transport';
+import { SimplePeerTransport } from './simplepeer-transport';
 
-describe('WebRTCTransport', () => {
+describe('SimplePeerTransport', () => {
   // This doesn't clean up correctly and crashes with SIGSEGV / SIGABRT at the end. Probably an issue with wrtc package.
   test('open and close', async () => {
-    const connection = new WebRTCTransport({
+    const connection = new SimplePeerTransport({
       initiator: true,
       stream: new Duplex(),
       sendSignal: async () => {},
@@ -27,7 +27,7 @@ describe('WebRTCTransport', () => {
 
   test('establish connection and send data through with protocol', async () => {
     const stream1 = new TestStream();
-    const connection1 = new WebRTCTransport({
+    const connection1 = new SimplePeerTransport({
       initiator: true,
       stream: stream1,
       sendSignal: async (signal) => {
@@ -39,7 +39,7 @@ describe('WebRTCTransport', () => {
     afterTest(() => connection1.errors.assertNoUnhandledErrors());
 
     const stream2 = new TestStream();
-    const connection2 = new WebRTCTransport({
+    const connection2 = new SimplePeerTransport({
       initiator: false,
       stream: stream2,
       sendSignal: async (signal) => {

package/src/transport/{webrtc-transport.ts → simplepeer-transport.ts}

@@ -3,10 +3,10 @@
 //
 
 import SimplePeerConstructor, { Instance as SimplePeer } from 'simple-peer';
+import invariant from 'tiny-invariant';
 
 import { Event } from '@dxos/async';
 import { ErrorStream, raise } from '@dxos/debug';
-import { invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { trace } from '@dxos/protocols';
@@ -15,47 +15,34 @@ import { Signal } from '@dxos/protocols/proto/dxos/mesh/swarm';
 import { Transport, TransportFactory } from './transport';
 import { wrtc } from './webrtc';
 
-export type WebRTCTransportParams = {
+export type SimplePeerTransportParams = {
   initiator: boolean;
-  // https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/RTCPeerConnection
-  webrtcConfig?: any;
   stream: NodeJS.ReadWriteStream;
-  // TODO(burdon): Rename onSignal.
+  webrtcConfig?: any;
   sendSignal: (signal: Signal) => Promise<void>;
 };
 
-// TODO(burdon): Refs:
-//  https://webrtc.github.io/samples
-//  Simple peer discord.
-
 /**
- * Implements WebRTC transport using simple-peer (used by WebTorrent).
+ * Implements Transport for WebRTC. Uses simple-peer under the hood.
  */
-export class WebRTCTransport implements Transport {
-  private readonly _instanceId = PublicKey.random().toHex();
+export class SimplePeerTransport implements Transport {
   private readonly _peer: SimplePeer;
-
   private _closed = false;
+
   readonly closed = new Event();
   readonly connected = new Event();
   readonly errors = new ErrorStream();
 
-  constructor(private readonly params: WebRTCTransportParams) {
+  private readonly _instanceId = PublicKey.random().toHex();
+
+  constructor(private readonly params: SimplePeerTransportParams) {
     log.trace('dxos.mesh.webrtc-transport.constructor', trace.begin({ id: this._instanceId }));
     log('created connection', params);
-
-    // https://www.npmjs.com/package/simple-peer#api
-    // NOTE: Set localStorage.debug = 'simple-peer*' to enable debug logging. (Or show verbose in Chrome).
-    // View throughput via: chrome://webrtc-internals (data-channel)
     this._peer = new SimplePeerConstructor({
+      channelName: 'dxos.mesh.transport',
       initiator: this.params.initiator,
-      config: this.params.webrtcConfig,
-      // https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/createDataChannel
-      channelConfig: {
-        protocol: 'dxos.mesh',
-      },
-      // Custom WebRTC implementation (for Node); otherwise get-browser-rtc.
       wrtc: SimplePeerConstructor.WEBRTC_SUPPORT ? undefined : wrtc ?? raise(new Error('wrtc not available')),
+      config: this.params.webrtcConfig,
     });
 
     this._peer.on('signal', async (data) => {
@@ -119,10 +106,9 @@ export class WebRTCTransport implements Transport {
   }
 }
 
-// TODO(dmaretskyi): Convert to class.
-export const createWebRTCTransportFactory = (webrtcConfig?: any): TransportFactory => ({
+export const createSimplePeerTransportFactory = (webrtcConfig?: any): TransportFactory => ({
   createTransport: (params) =>
-    new WebRTCTransport({
+    new SimplePeerTransport({
       ...params,
       webrtcConfig,
     }),

package/src/transport/transport.ts

@@ -6,6 +6,13 @@ import { Event } from '@dxos/async';
 import { ErrorStream } from '@dxos/debug';
 import { Signal } from '@dxos/protocols/proto/dxos/mesh/swarm';
 
+export enum TransportKind {
+  SIMPLE_PEER = 'SIMPLE_PEER',
+  LIBDATACHANNEL = 'LIBDATACHANNEL',
+  SIMPLE_PEER_PROXY = 'SIMPLE_PEER_PROXY',
+  MEMORY = 'MEMORY',
+}
+
 /**
  * Abstraction over a P2P connection transport. Currently either WebRTC or in-memory.
  */

package/src/wire-protocol.ts

@@ -23,8 +23,9 @@ export type WireProtocolProvider = (params: WireProtocolParams) => WireProtocol;
 export interface WireProtocol {
   stream: Duplex;
 
-  initialize(): Promise<void>;
-  destroy(): Promise<void>;
+  open(): Promise<void>;
+  close(): Promise<void>;
+  abort(): Promise<void>;
 }
 
 /**
@@ -39,13 +40,16 @@ export const createTeleportProtocolFactory = (
     const teleport = new Teleport(params);
     return {
       stream: teleport.stream,
-      initialize: async () => {
+      open: async () => {
         await teleport.open();
         await onConnection(teleport);
       },
-      destroy: async () => {
+      close: async () => {
         await teleport.close();
       },
+      abort: async () => {
+        await teleport.abort();
+      },
     };
   };
 };