@dxos/network-manager 0.1.3 → 0.1.4

package/src/transport/memory-transport.ts

@@ -5,16 +5,14 @@
 import assert from 'node:assert';
 import { Transform } from 'stream';
 
-import { Event } from '@dxos/async';
+import { Event, Trigger } from '@dxos/async';
 import { ErrorStream } from '@dxos/debug';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { Signal } from '@dxos/protocols/proto/dxos/mesh/swarm';
 import { ComplexMap } from '@dxos/util';
 
-import { Transport, TransportFactory } from './transport';
-
-type ConnectionKey = [topic: PublicKey, nodeId: PublicKey, remoteId: PublicKey];
+import { Transport, TransportFactory, TransportOptions } from './transport';
 
 // Delay (in milliseconds) for data being sent through in-memory connections to simulate network latency.
 const MEMORY_TRANSPORT_DELAY = 1;
@@ -36,71 +34,72 @@ const createStreamDelay = (delay: number): NodeJS.ReadWriteStream =>
 // TODO(burdon): Remove static variables.
 export class MemoryTransport implements Transport {
   // TODO(burdon): Remove global properties.
-  private static readonly _connections = new ComplexMap<ConnectionKey, MemoryTransport>(
-    ([topic, nodeId, remoteId]) => topic.toHex() + nodeId.toHex() + remoteId.toHex()
-  );
+  private static readonly _connections = new ComplexMap<PublicKey, MemoryTransport>(PublicKey.hash);
 
   public readonly closed = new Event<void>();
   public readonly connected = new Event<void>();
   public readonly errors = new ErrorStream();
 
-  private readonly _ownKey: ConnectionKey;
-  private readonly _remoteKey: ConnectionKey;
+  private readonly _ownId = PublicKey.random();
+  private _remoteId!: PublicKey;
+  private readonly _remote = new Trigger<PublicKey>();
 
   private readonly _outgoingDelay = createStreamDelay(MEMORY_TRANSPORT_DELAY);
   private readonly _incomingDelay = createStreamDelay(MEMORY_TRANSPORT_DELAY);
 
   private _remoteConnection?: MemoryTransport;
 
-  constructor(
-    private readonly _ownId: PublicKey,
-    private readonly _remoteId: PublicKey,
-    private readonly _sessionId: PublicKey,
-    private readonly _topic: PublicKey,
-    private readonly _stream: NodeJS.ReadWriteStream
-  ) {
-    log('creating', { topic: this._topic, peerId: this._ownId, remoteId: this._remoteId });
-
-    this._ownKey = [this._topic, this._ownId, this._remoteId];
-    this._remoteKey = [this._topic, this._remoteId, this._ownId];
-
-    assert(!MemoryTransport._connections.has(this._ownKey), 'Duplicate memory connection');
-    MemoryTransport._connections.set(this._ownKey, this);
-
-    this._remoteConnection = MemoryTransport._connections.get(this._remoteKey);
-    if (this._remoteConnection) {
-      this._remoteConnection._remoteConnection = this;
-
-      log('connected', { topic: this._topic, peerId: this._ownId, remoteId: this._remoteId });
-      this._stream
-        .pipe(this._outgoingDelay)
-        .pipe(this._remoteConnection._stream)
-        .pipe(this._incomingDelay)
-        .pipe(this._stream);
+  constructor(private readonly params: TransportOptions) {
+    log('creating', this._ownId);
 
-      this.connected.emit();
-      this._remoteConnection.connected.emit();
+    if (this.params.initiator) {
+      setTimeout(async () => this.params.sendSignal({ json: JSON.stringify({ transportId: this._ownId.toHex() }) }));
     }
-  }
 
-  get remoteId(): PublicKey {
-    return this._remoteId;
-  }
-
-  get sessionId(): PublicKey {
-    return this._sessionId;
+    assert(!MemoryTransport._connections.has(this._ownId), 'Duplicate memory connection');
+    MemoryTransport._connections.set(this._ownId, this);
+
+    this._remote.wait().then(
+      (remoteId) => {
+        this._remoteId = remoteId;
+        this._remoteConnection = MemoryTransport._connections.get(this._remoteId);
+        if (this._remoteConnection) {
+          this._remoteConnection._remoteConnection = this;
+          this._remoteConnection._remoteId = this._ownId;
+
+          log('connected', { ownId: this._ownId, remoteId: this._remoteId });
+          this.params.stream
+            .pipe(this._outgoingDelay)
+            .pipe(this._remoteConnection.params.stream)
+            .pipe(this._incomingDelay)
+            .pipe(this.params.stream);
+
+          this.connected.emit();
+          this._remoteConnection.connected.emit();
+        }
+      },
+      async (err) => {
+        log.catch(err);
+      }
+    );
   }
 
   async signal(signal: Signal) {
-    // No-op.
+    const { json } = signal;
+    if (json) {
+      const { transportId } = JSON.parse(json);
+      if (transportId) {
+        this._remote.wake(PublicKey.from(transportId));
+      }
+    }
   }
 
   async close(): Promise<void> {
-    log('closing', { topic: this._topic, peerId: this._ownId, remoteId: this._remoteId });
+    log('closing', this._ownId);
 
-    MemoryTransport._connections.delete(this._ownKey);
+    MemoryTransport._connections.delete(this._ownId);
     if (this._remoteConnection) {
-      MemoryTransport._connections.delete(this._remoteKey);
+      MemoryTransport._connections.delete(this._remoteId);
 
       // TODO(dmaretskyi): Hypercore streams do not seem to have the unpipe method.
       //  NOTE(burdon): Using readable-stream.wrap() might help (see feed-store).
@@ -119,10 +118,10 @@ export class MemoryTransport implements Transport {
     }
 
     this.closed.emit();
-    log('closed', { topic: this._topic });
+    log('closed');
   }
 }
 
 export const MemoryTransportFactory: TransportFactory = {
-  create: (opts) => new MemoryTransport(opts.ownId, opts.remoteId, opts.sessionId, opts.topic, opts.stream)
+  create: (params) => new MemoryTransport(params)
 };

package/src/transport/transport.ts

@@ -4,11 +4,8 @@
 
 import { Event } from '@dxos/async';
 import { ErrorStream } from '@dxos/debug';
-import { PublicKey } from '@dxos/keys';
 import { Signal } from '@dxos/protocols/proto/dxos/mesh/swarm';
 
-import { SignalMessage } from '../signal';
-
 /**
  * Abstraction over a P2P connection transport. Currently either WebRTC or in-memory.
  */
@@ -26,11 +23,6 @@ export type TransportOptions = {
    */
   initiator: boolean;
 
-  ownId: PublicKey;
-  remoteId: PublicKey;
-  sessionId: PublicKey;
-  topic: PublicKey;
-
   /**
    * Wire protocol.
    */
@@ -39,7 +31,7 @@ export type TransportOptions = {
   /**
    * Send a signal message to remote peer.
    */
-  sendSignal: (msg: SignalMessage) => Promise<void>; // TODO(burdon): Remove async?
+  sendSignal: (signal: Signal) => Promise<void>; // TODO(burdon): Remove async?
 };
 
 export interface TransportFactory {

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

@@ -14,10 +14,10 @@ import { PublicKey } from '@dxos/keys';
 import { Protocol } from '@dxos/mesh-protocol';
 import { schema } from '@dxos/protocols';
 import { BridgeService } from '@dxos/protocols/proto/dxos/mesh/bridge';
+import { Signal } from '@dxos/protocols/proto/dxos/mesh/swarm';
 import { createLinkedPorts, createProtoRpcPeer, ProtoRpcPeer } from '@dxos/rpc';
 import { afterTest } from '@dxos/testutils';
 
-import { SignalMessage } from '../signal';
 import { TestProtocolPlugin, testProtocolProvider } from '../testing';
 import { WebRTCTransportProxy } from './webrtc-transport-proxy';
 import { WebRTCTransportService } from './webrtc-transport-service';
@@ -25,27 +25,21 @@ import { WebRTCTransportService } from './webrtc-transport-service';
 describe('WebRTCTransportProxy', function () {
   const setupProxy = async ({
     initiator = true,
-    ownId = PublicKey.random(),
-    remoteId = PublicKey.random(),
-    sessionId = PublicKey.random(),
-    topic = PublicKey.random(),
     stream = new Duplex({ write: () => {}, read: () => {} }),
-    sendSignal = () => {}
+    sendSignal = async () => {}
   }: {
     initiator?: boolean;
-    ownId?: PublicKey;
-    remoteId?: PublicKey;
-    sessionId?: PublicKey;
-    topic?: PublicKey;
     stream?: NodeJS.ReadWriteStream;
-    sendSignal?: (msg: SignalMessage) => void;
+    sendSignal?: (msg: Signal) => Promise<void>;
   } = {}) => {
     const [port1, port2] = createLinkedPorts();
 
+    // Starting BridgeService
     const webRTCTransportService: BridgeService = new WebRTCTransportService();
 
     // Starting BridgeService
-    const webRTCService = createProtoRpcPeer({
+    const rpcService = createProtoRpcPeer({
+      requested: {},
       exposed: {
         BridgeService: schema.getService('dxos.mesh.bridge.BridgeService')
       },
@@ -56,8 +50,8 @@ describe('WebRTCTransportProxy', function () {
         preserveAny: true
       }
     });
-    await webRTCService.open();
-    afterTest(() => webRTCService.close());
+    await rpcService.open();
+    afterTest(() => rpcService.close());
 
     // Starting RPC client
     const rpcClient = createProtoRpcPeer({
@@ -76,16 +70,12 @@ describe('WebRTCTransportProxy', function () {
     const webRTCTransportProxy = new WebRTCTransportProxy({
       initiator,
       stream,
-      ownId,
-      remoteId,
-      sessionId,
-      topic,
       sendSignal,
       bridgeService: rpcClient.rpc.BridgeService
     });
     afterTest(async () => await webRTCTransportProxy.close());
 
-    return { webRTCService, webRTCTransportProxy };
+    return { webRTCService: rpcService, webRTCTransportProxy };
   };
 
   // This doesn't clean up correctly and crashes with SIGSEGV / SIGABRT at the end. Probably an issue with wrtc package.
@@ -116,7 +106,6 @@ describe('WebRTCTransportProxy', 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);
@@ -126,13 +115,9 @@ describe('WebRTCTransportProxy', function () {
         channel: discoveryKey(topic),
         initiator: true
       }).stream,
-      ownId: peer1Id,
-      remoteId: peer2Id,
-      sessionId,
-      topic,
-      sendSignal: async (msg) => {
+      sendSignal: async (signal) => {
         await sleep(10);
-        await connection2.signal(msg.data.signal);
+        await connection2.signal(signal);
       }
     });
     afterTest(() => connection1.errors.assertNoUnhandledErrors());
@@ -145,13 +130,9 @@ describe('WebRTCTransportProxy', function () {
         channel: discoveryKey(topic),
         initiator: false
       }).stream,
-      ownId: peer2Id,
-      remoteId: peer1Id,
-      sessionId,
-      topic,
-      sendSignal: async (msg) => {
+      sendSignal: async (signal) => {
         await sleep(10);
-        await connection1.signal(msg.data.signal);
+        await connection1.signal(signal);
       }
     });
     afterTest(() => connection2.errors.assertNoUnhandledErrors());
@@ -166,7 +147,6 @@ describe('WebRTCTransportProxy', function () {
     plugin2.on('connect', async (protocol) => {
       await plugin2.send(peer1Id.asBuffer(), '{"message": "Hello"}');
     });
-
     await waitForExpect(() => {
       expect(received.length).toBe(2);
       expect(received[0]).toBeInstanceOf(Protocol);
@@ -219,7 +199,6 @@ describe('WebRTCTransportProxy', 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);
@@ -229,13 +208,9 @@ describe('WebRTCTransportProxy', function () {
           channel: discoveryKey(topic),
           initiator: true
         }).stream,
-        ownId: peer1Id,
-        remoteId: peer2Id,
-        sessionId,
-        topic,
-        sendSignal: async (msg) => {
+        sendSignal: async (signal) => {
           await sleep(10);
-          await proxy2.signal(msg.data.signal);
+          await proxy2.signal(signal);
         },
         bridgeService: rpcClient.rpc.BridgeService
       });
@@ -249,13 +224,9 @@ describe('WebRTCTransportProxy', function () {
           channel: discoveryKey(topic),
           initiator: false
         }).stream,
-        ownId: peer2Id,
-        remoteId: peer1Id,
-        sessionId,
-        topic,
-        sendSignal: async (msg) => {
+        sendSignal: async (signal) => {
           await sleep(10);
-          await proxy1.signal(msg.data.signal);
+          await proxy1.signal(signal);
         },
         bridgeService: rpcClient.rpc.BridgeService
       });

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

@@ -12,24 +12,20 @@ import { log } from '@dxos/log';
 import { ConnectionState, BridgeEvent, BridgeService } from '@dxos/protocols/proto/dxos/mesh/bridge';
 import { Signal } from '@dxos/protocols/proto/dxos/mesh/swarm';
 
-import { SignalMessage } from '../signal';
 import { Transport, TransportFactory, TransportOptions } from './transport';
 
-export interface WebRTCTransportProxyParams {
+export type WebRTCTransportProxyParams = {
   initiator: boolean;
   stream: NodeJS.ReadWriteStream;
-  ownId: PublicKey;
-  remoteId: PublicKey;
-  sessionId: PublicKey;
-  topic: PublicKey;
-  sendSignal: (msg: SignalMessage) => void;
   bridgeService: BridgeService;
-}
+  sendSignal: (signal: Signal) => Promise<void>;
+};
 
 export class WebRTCTransportProxy implements Transport {
   readonly closed = new Event();
   private _closed = false;
   readonly connected = new Event();
+
   readonly errors = new ErrorStream();
 
   private _serviceStream!: Stream<BridgeEvent>;
@@ -43,16 +39,16 @@ export class WebRTCTransportProxy implements Transport {
       proxyId: this._proxyId,
       initiator: this._params.initiator
     });
-
     this._serviceStream.waitUntilReady().then(
       () => {
-        this._serviceStream.subscribe(async (msg: BridgeEvent) => {
-          if (msg.connection) {
-            await this._handleConnection(msg.connection);
-          } else if (msg.data) {
-            this._handleData(msg.data);
-          } else if (msg.signal) {
-            await this._handleSignal(msg.signal);
+        this._serviceStream.subscribe(async (event: BridgeEvent) => {
+          log('WebRTCTransportProxy: event', event);
+          if (event.connection) {
+            await this._handleConnection(event.connection);
+          } else if (event.data) {
+            this._handleData(event.data);
+          } else if (event.signal) {
+            await this._handleSignal(event.signal);
           }
         });
 
@@ -94,13 +90,7 @@ export class WebRTCTransportProxy implements Transport {
   }
 
   private async _handleSignal(signalEvent: BridgeEvent.SignalEvent) {
-    await this._params.sendSignal({
-      author: this._params.ownId,
-      recipient: this._params.remoteId,
-      topic: this._params.topic,
-      sessionId: this._params.sessionId,
-      data: { signal: signalEvent.payload }
-    });
+    await this._params.sendSignal(signalEvent.payload);
   }
 
   async signal(signal: Signal): Promise<void> {

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());