@dxos/network-manager 0.1.2 → 0.1.4

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

@@ -3,10 +3,9 @@
 //
 
 import assert from 'assert';
-import SimplePeerConstructor, { Instance as SimplePeer } from 'simple-peer';
+import { Duplex } from 'stream';
 
 import { Stream } from '@dxos/codec-protobuf';
-import { raise } from '@dxos/debug';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 import {
@@ -20,10 +19,12 @@ import {
 } from '@dxos/protocols/proto/dxos/mesh/bridge';
 import { ComplexMap } from '@dxos/util';
 
-import { wrtc } from './webrtc';
+import { WebRTCTransport } from './webrtc-transport';
 
 export class WebRTCTransportService implements BridgeService {
-  protected peers = new ComplexMap<PublicKey, SimplePeer>(PublicKey.hash);
+  private readonly transports = new ComplexMap<PublicKey, { transport: WebRTCTransport; stream: Duplex }>(
+    PublicKey.hash
+  );
 
   // prettier-ignore
   constructor(
@@ -31,14 +32,23 @@ export class WebRTCTransportService implements BridgeService {
   ) {}
 
   open(request: ConnectionRequest): Stream<BridgeEvent> {
-    return new Stream(({ ready, next, close }) => {
-      log(
-        `Creating webrtc connection initiator=${request.initiator} webrtcConfig=${JSON.stringify(this._webrtcConfig)}`
-      );
-      const peer = new SimplePeerConstructor({
+    const rpcStream: Stream<BridgeEvent> = new Stream(({ ready, next, close }) => {
+      const duplex: Duplex = new Duplex({
+        read: () => {},
+        write: function (chunk, _, callback) {
+          next({ data: { payload: chunk } });
+          callback();
+        }
+      });
+
+      const transport = new WebRTCTransport({
         initiator: request.initiator,
-        wrtc: SimplePeerConstructor.WEBRTC_SUPPORT ? undefined : wrtc ?? raise(new Error('wrtc not available')),
-        config: this._webrtcConfig
+        stream: duplex,
+        sendSignal: async (signal) => {
+          next({
+            signal: { payload: signal }
+          });
+        }
       });
 
       next({
@@ -47,23 +57,7 @@ export class WebRTCTransportService implements BridgeService {
         }
       });
 
-      peer.on('data', async (payload) => {
-        next({
-          data: {
-            payload
-          }
-        });
-      });
-
-      peer.on('signal', async (data) => {
-        next({
-          signal: {
-            payload: { json: JSON.stringify(data) }
-          }
-        });
-      });
-
-      peer.on('connect', () => {
+      transport.connected.on(() => {
         next({
           connection: {
             state: ConnectionState.CONNECTED
@@ -71,7 +65,7 @@ export class WebRTCTransportService implements BridgeService {
         });
       });
 
-      peer.on('error', async (err) => {
+      transport.errors.handle((err) => {
         next({
           connection: {
             state: ConnectionState.CLOSED,
@@ -81,7 +75,7 @@ export class WebRTCTransportService implements BridgeService {
         close(err);
       });
 
-      peer.on('close', async () => {
+      transport.closed.on(() => {
         next({
           connection: {
             state: ConnectionState.CLOSED
@@ -90,26 +84,27 @@ export class WebRTCTransportService implements BridgeService {
         close();
       });
 
-      this.peers.set(request.proxyId, peer);
-
       ready();
+      this.transports.set(request.proxyId, { transport, stream: duplex });
     });
+
+    return rpcStream;
   }
 
   async sendSignal({ proxyId, signal }: SignalRequest): Promise<void> {
-    assert(this.peers.has(proxyId), 'Connection not ready to accept signals.');
-    assert(signal.json, 'Signal message must contain signal data.');
-    this.peers.get(proxyId)!.signal(JSON.parse(signal.json));
+    assert(this.transports.has(proxyId));
+    await this.transports.get(proxyId)!.transport.signal(signal);
   }
 
   async sendData({ proxyId, payload }: DataRequest): Promise<void> {
-    assert(this.peers.has(proxyId));
-    this.peers.get(proxyId)!.write(payload);
+    assert(this.transports.has(proxyId));
+    await this.transports.get(proxyId)!.stream.push(payload);
   }
 
   async close({ proxyId }: CloseRequest) {
-    this.peers.get(proxyId)?.destroy();
-    this.peers.delete(proxyId);
+    await this.transports.get(proxyId)?.transport.close();
+    await this.transports.get(proxyId)?.stream.end();
+    this.transports.delete(proxyId);
     log('Closed.');
   }
 }

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

@@ -18,15 +18,11 @@ import { WebRTCTransport } from './webrtc-transport';
 describe('WebRTCTransport', function () {
   // This doesn't clean up correctly and crashes with SIGSEGV / SIGABRT at the end. Probably an issue with wrtc package.
   it('open and close', async function () {
-    const connection = new WebRTCTransport(
-      true,
-      new Duplex(),
-      PublicKey.random(),
-      PublicKey.random(),
-      PublicKey.random(),
-      PublicKey.random(),
-      async (msg) => {}
-    );
+    const connection = new WebRTCTransport({
+      initiator: true,
+      stream: new Duplex(),
+      sendSignal: async () => {}
+    });
 
     let callsCounter = 0;
     const closedCb = () => {
@@ -48,45 +44,36 @@ describe('WebRTCTransport', function () {
     const topic = PublicKey.random();
     const peer1Id = PublicKey.random();
     const peer2Id = PublicKey.random();
-    const sessionId = PublicKey.random();
 
     const plugin1 = new TestProtocolPlugin(peer1Id.asBuffer());
     const protocolProvider1 = testProtocolProvider(topic.asBuffer(), peer1Id.asBuffer(), plugin1);
-    const connection1 = new WebRTCTransport(
-      true,
-      protocolProvider1({
+    const connection1 = new WebRTCTransport({
+      initiator: true,
+      stream: protocolProvider1({
         channel: discoveryKey(topic),
         initiator: true
       }).stream,
-      peer1Id,
-      peer2Id,
-      sessionId,
-      topic,
-      async (msg) => {
+      sendSignal: async (signal) => {
         await sleep(10);
-        await connection2.signal(msg.data.signal);
+        await connection2.signal(signal);
       }
-    );
+    });
     afterTest(() => connection1.close());
     afterTest(() => connection1.errors.assertNoUnhandledErrors());
 
     const plugin2 = new TestProtocolPlugin(peer2Id.asBuffer());
     const protocolProvider2 = testProtocolProvider(topic.asBuffer(), peer2Id.asBuffer(), plugin2);
-    const connection2 = new WebRTCTransport(
-      false,
-      protocolProvider2({
+    const connection2 = new WebRTCTransport({
+      initiator: false,
+      stream: protocolProvider2({
         channel: discoveryKey(topic),
         initiator: false
       }).stream,
-      peer2Id,
-      peer1Id,
-      sessionId,
-      topic,
-      async (msg) => {
+      sendSignal: async (signal) => {
         await sleep(10);
-        await connection1.signal(msg.data.signal);
+        await connection1.signal(signal);
       }
-    );
+    });
     afterTest(() => connection2.close());
     afterTest(() => connection2.errors.assertNoUnhandledErrors());
 

package/src/transport/webrtc-transport.ts

@@ -7,14 +7,19 @@ import SimplePeerConstructor, { Instance as SimplePeer } from 'simple-peer';
 
 import { Event } from '@dxos/async';
 import { ErrorStream, raise } from '@dxos/debug';
-import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { Signal } from '@dxos/protocols/proto/dxos/mesh/swarm';
 
-import { SignalMessage } from '../signal';
 import { Transport, TransportFactory } from './transport';
 import { wrtc } from './webrtc';
 
+export type WebRTCTransportParams = {
+  initiator: boolean;
+  stream: NodeJS.ReadWriteStream;
+  webrtcConfig?: any;
+  sendSignal: (signal: Signal) => Promise<void>;
+};
+
 /**
  * Implements Transport for WebRTC. Uses simple-peer under the hood.
  */
@@ -25,51 +30,27 @@ export class WebRTCTransport implements Transport {
   readonly connected = new Event();
   readonly errors = new ErrorStream();
 
-  constructor(
-    private readonly _initiator: boolean,
-    private readonly _stream: NodeJS.ReadWriteStream,
-    private readonly _ownId: PublicKey,
-    private readonly _remoteId: PublicKey,
-    private readonly _sessionId: PublicKey,
-    private readonly _topic: PublicKey,
-    private readonly _sendSignal: (msg: SignalMessage) => void,
-    private readonly _webrtcConfig?: any
-  ) {
-    log('created connection', {
-      id: this._ownId,
-      topic: this._topic,
-      remoteId: this._remoteId,
-      initiator: this._initiator,
-      config: this._webrtcConfig
-    });
+  constructor(private readonly params: WebRTCTransportParams) {
+    log('created connection', params);
     this._peer = new SimplePeerConstructor({
-      initiator: this._initiator,
+      initiator: this.params.initiator,
       wrtc: SimplePeerConstructor.WEBRTC_SUPPORT ? undefined : wrtc ?? raise(new Error('wrtc not available')),
-      config: this._webrtcConfig
+      config: this.params.webrtcConfig
     });
 
     this._peer.on('signal', async (data) => {
-      try {
-        await this._sendSignal({
-          author: this._ownId,
-          recipient: this._remoteId,
-          sessionId: this._sessionId,
-          topic: this._topic,
-          data: { signal: { json: JSON.stringify(data) } }
-        });
-      } catch (err: any) {
-        this.errors.raise(err);
-      }
+      log('signal', data);
+      await this.params.sendSignal({ json: JSON.stringify(data) });
     });
 
     this._peer.on('connect', () => {
-      log('connected', { id: this._ownId, remoteId: this._remoteId });
-      this._stream.pipe(this._peer!).pipe(this._stream);
+      log('connected');
+      this.params.stream.pipe(this._peer!).pipe(this.params.stream);
       this.connected.emit();
     });
 
     this._peer.on('close', async () => {
-      log('closed', { id: this._ownId, remoteId: this._remoteId });
+      log('closed');
       await this._disconnectStreams();
       this.closed.emit();
     });
@@ -80,14 +61,6 @@ export class WebRTCTransport implements Transport {
     });
   }
 
-  get remoteId() {
-    return this._remoteId;
-  }
-
-  get sessionId() {
-    return this._sessionId;
-  }
-
   get peer() {
     return this._peer;
   }
@@ -96,6 +69,7 @@ export class WebRTCTransport implements Transport {
     log('closing...');
     await this._disconnectStreams();
     this._peer!.destroy();
+    this.closed.emit();
     log('closed');
   }
 
@@ -107,21 +81,15 @@ export class WebRTCTransport implements Transport {
 
   private async _disconnectStreams() {
     // TODO(rzadp): Find a way of unpiping this?
-    this._stream.unpipe?.(this._peer)?.unpipe?.(this._stream);
+    this.params.stream.unpipe?.(this._peer)?.unpipe?.(this.params.stream);
   }
 }
 
 // TODO(dmaretskyi): Convert to class.
 export const createWebRTCTransportFactory = (webrtcConfig?: any): TransportFactory => ({
-  create: (opts) =>
-    new WebRTCTransport( // TODO(burdon): Refactor with to take opts in constructor.
-      opts.initiator,
-      opts.stream,
-      opts.ownId,
-      opts.remoteId,
-      opts.sessionId,
-      opts.topic,
-      opts.sendSignal,
+  create: (params) =>
+    new WebRTCTransport({
+      ...params,
       webrtcConfig
-    )
+    })
 });