@dxos/network-manager 0.1.0

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

@@ -0,0 +1,290 @@
+//
+// Copyright 2020 DXOS.org
+//
+
+// @dxos/mocha platform=nodejs
+
+import expect from 'expect';
+import { Duplex } from 'stream';
+import waitForExpect from 'wait-for-expect';
+
+import { sleep } from '@dxos/async';
+import { discoveryKey } from '@dxos/crypto';
+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 { 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';
+
+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 = () => {}
+  }: {
+    initiator?: boolean;
+    ownId?: PublicKey;
+    remoteId?: PublicKey;
+    sessionId?: PublicKey;
+    topic?: PublicKey;
+    stream?: NodeJS.ReadWriteStream;
+    sendSignal?: (msg: SignalMessage) => void;
+  } = {}) => {
+    const [port1, port2] = createLinkedPorts();
+
+    const webRTCTransportService: BridgeService = new WebRTCTransportService();
+
+    // Starting BridgeService
+    const webRTCService = createProtoRpcPeer({
+      requested: {},
+      exposed: {
+        BridgeService: schema.getService('dxos.mesh.bridge.BridgeService')
+      },
+      handlers: { BridgeService: webRTCTransportService },
+      port: port1,
+      noHandshake: true,
+      encodingOptions: {
+        preserveAny: true
+      }
+    });
+    await webRTCService.open();
+    afterTest(() => webRTCService.close());
+
+    // Starting RPC client
+    const rpcClient = createProtoRpcPeer({
+      requested: {
+        BridgeService: schema.getService('dxos.mesh.bridge.BridgeService')
+      },
+      exposed: {},
+      handlers: {},
+      port: port2,
+      noHandshake: true,
+      encodingOptions: {
+        preserveAny: true
+      }
+    });
+    await rpcClient.open();
+    afterTest(() => rpcClient.close());
+
+    const webRTCTransportProxy = new WebRTCTransportProxy({
+      initiator,
+      stream,
+      ownId,
+      remoteId,
+      sessionId,
+      topic,
+      sendSignal,
+      bridgeService: rpcClient.rpc.BridgeService
+    });
+    afterTest(async () => await webRTCTransportProxy.close());
+
+    return { webRTCService, webRTCTransportProxy };
+  };
+
+  // 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 { webRTCTransportProxy: connection } = await setupProxy();
+
+    let callsCounter = 0;
+    const closedCb = () => {
+      callsCounter++;
+    };
+    connection.closed.once(closedCb);
+
+    await sleep(10); // Let simple-peer process events.
+    await connection.close();
+
+    await sleep(1); // Process events.
+
+    expect(callsCounter).toEqual(1);
+  })
+    .timeout(1_000)
+    .retries(3);
+
+  it('establish connection and send data through with protocol', async function () {
+    if (mochaExecutor.environment !== 'nodejs') {
+      this.skip();
+    }
+
+    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 { webRTCTransportProxy: connection1 } = await setupProxy({
+      initiator: true,
+      stream: protocolProvider1({
+        channel: discoveryKey(topic),
+        initiator: true
+      }).stream,
+      ownId: peer1Id,
+      remoteId: peer2Id,
+      sessionId,
+      topic,
+      sendSignal: async (msg) => {
+        await sleep(10);
+        await connection2.signal(msg.data.signal);
+      }
+    });
+    afterTest(() => connection1.errors.assertNoUnhandledErrors());
+
+    const plugin2 = new TestProtocolPlugin(peer2Id.asBuffer());
+    const protocolProvider2 = testProtocolProvider(topic.asBuffer(), peer2Id.asBuffer(), plugin2);
+    const { webRTCTransportProxy: connection2 } = await setupProxy({
+      initiator: false,
+      stream: protocolProvider2({
+        channel: discoveryKey(topic),
+        initiator: false
+      }).stream,
+      ownId: peer2Id,
+      remoteId: peer1Id,
+      sessionId,
+      topic,
+      sendSignal: async (msg) => {
+        await sleep(10);
+        await connection1.signal(msg.data.signal);
+      }
+    });
+    afterTest(() => connection2.errors.assertNoUnhandledErrors());
+
+    const received: any[] = [];
+    const mockReceive = (p: Protocol, s: string) => {
+      received.push(p, s);
+      return undefined;
+    };
+    plugin1.on('receive', mockReceive);
+
+    plugin2.on('connect', async (protocol) => {
+      await plugin2.send(peer1Id.asBuffer(), '{"message": "Hello"}');
+    });
+
+    await waitForExpect(() => {
+      expect(received.length).toBe(2);
+      expect(received[0]).toBeInstanceOf(Protocol);
+      expect(received[1]).toBe('{"message": "Hello"}');
+    });
+  })
+    .timeout(2_000)
+    .retries(3);
+
+  describe('Multiplexing', function () {
+    let service: any;
+    let rpcClient: ProtoRpcPeer<{ BridgeService: BridgeService }>;
+
+    before(async function () {
+      const [port1, port2] = createLinkedPorts();
+
+      const webRTCTransportService: BridgeService = new WebRTCTransportService();
+      service = createProtoRpcPeer({
+        requested: {},
+        exposed: {
+          BridgeService: schema.getService('dxos.mesh.bridge.BridgeService')
+        },
+        handlers: { BridgeService: webRTCTransportService },
+        port: port1,
+        noHandshake: true,
+        encodingOptions: {
+          preserveAny: true
+        }
+      });
+      await service.open();
+
+      rpcClient = createProtoRpcPeer({
+        requested: {
+          BridgeService: schema.getService('dxos.mesh.bridge.BridgeService')
+        },
+        exposed: {},
+        handlers: {},
+        port: port2,
+        noHandshake: true,
+        encodingOptions: {
+          preserveAny: true
+        }
+      });
+      await rpcClient.open();
+    });
+
+    after(async function () {
+      await service?.close();
+      await rpcClient?.close();
+    });
+
+    it('establish connection and send data through with protocol', async 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 proxy1 = new WebRTCTransportProxy({
+        initiator: true,
+        stream: protocolProvider1({
+          channel: discoveryKey(topic),
+          initiator: true
+        }).stream,
+        ownId: peer1Id,
+        remoteId: peer2Id,
+        sessionId,
+        topic,
+        sendSignal: async (msg) => {
+          await sleep(10);
+          await proxy2.signal(msg.data.signal);
+        },
+        bridgeService: rpcClient.rpc.BridgeService
+      });
+      afterTest(() => proxy1.errors.assertNoUnhandledErrors());
+
+      const plugin2 = new TestProtocolPlugin(peer2Id.asBuffer());
+      const protocolProvider2 = testProtocolProvider(topic.asBuffer(), peer2Id.asBuffer(), plugin2);
+      const proxy2 = new WebRTCTransportProxy({
+        initiator: false,
+        stream: protocolProvider2({
+          channel: discoveryKey(topic),
+          initiator: false
+        }).stream,
+        ownId: peer2Id,
+        remoteId: peer1Id,
+        sessionId,
+        topic,
+        sendSignal: async (msg) => {
+          await sleep(10);
+          await proxy1.signal(msg.data.signal);
+        },
+        bridgeService: rpcClient.rpc.BridgeService
+      });
+      afterTest(() => proxy2.errors.assertNoUnhandledErrors());
+
+      const received: any[] = [];
+      const mockReceive = (p: Protocol, s: string) => {
+        received.push(p, s);
+        return undefined;
+      };
+      plugin1.on('receive', mockReceive);
+
+      plugin2.on('connect', async (protocol) => {
+        await plugin2.send(peer1Id.asBuffer(), '{"message": "Hello"}');
+      });
+
+      await waitForExpect(() => {
+        expect(received.length).toBe(2);
+        expect(received[0]).toBeInstanceOf(Protocol);
+        expect(received[1]).toBe('{"message": "Hello"}');
+      });
+    })
+      .timeout(5_000)
+      .retries(3);
+  });
+});

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

@@ -0,0 +1,167 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import assert from 'assert';
+
+import { Event } from '@dxos/async';
+import { Stream } from '@dxos/codec-protobuf';
+import { ErrorStream } from '@dxos/debug';
+import { PublicKey } from '@dxos/keys';
+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 {
+  initiator: boolean;
+  stream: NodeJS.ReadWriteStream;
+  ownId: PublicKey;
+  remoteId: PublicKey;
+  sessionId: PublicKey;
+  topic: PublicKey;
+  sendSignal: (msg: SignalMessage) => void;
+  bridgeService: BridgeService;
+}
+
+export class WebRTCTransportProxy implements Transport {
+  readonly closed = new Event();
+  private _closed = false;
+  readonly connected = new Event();
+  readonly errors = new ErrorStream();
+
+  private _serviceStream!: Stream<BridgeEvent>;
+  private readonly _proxyId = PublicKey.random();
+
+  // prettier-ignore
+  constructor(
+    private readonly _params: WebRTCTransportProxyParams
+  ) {
+    this._serviceStream = this._params.bridgeService.open({
+      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._params.stream.on('data', async (data: Uint8Array) => {
+          try {
+            await this._params.bridgeService.sendData({
+              proxyId: this._proxyId,
+              payload: data
+            });
+          } catch (err: any) {
+            log.catch(err);
+          }
+        });
+      },
+      (error) => log.catch(error)
+    );
+  }
+
+  private async _handleConnection(connectionEvent: BridgeEvent.ConnectionEvent): Promise<void> {
+    if (connectionEvent.error) {
+      this.errors.raise(new Error(connectionEvent.error));
+    }
+
+    switch (connectionEvent.state) {
+      case ConnectionState.CONNECTED: {
+        this.connected.emit();
+        break;
+      }
+      case ConnectionState.CLOSED: {
+        await this.close();
+        break;
+      }
+    }
+  }
+
+  private _handleData(dataEvent: BridgeEvent.DataEvent) {
+    // NOTE: This must be a Buffer otherwise hypercore-protocol breaks.
+    this._params.stream.write(Buffer.from(dataEvent.payload));
+  }
+
+  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 }
+    });
+  }
+
+  async signal(signal: Signal): Promise<void> {
+    await this._params.bridgeService.sendSignal({
+      proxyId: this._proxyId,
+      signal
+    });
+  }
+
+  async close(): Promise<void> {
+    if (this._closed) {
+      return;
+    }
+    this._serviceStream.close();
+    try {
+      await this._params.bridgeService.close({ proxyId: this._proxyId });
+    } catch (err: any) {
+      log.catch(err);
+    }
+    this.closed.emit();
+    this._closed = true;
+  }
+
+  /**
+   * Called when underlying proxy service becomes unavailable.
+   */
+  forceClose() {
+    this._serviceStream.close();
+    this.closed.emit();
+    this._closed = true;
+  }
+}
+
+export class WebRTCTransportProxyFactory implements TransportFactory {
+  private _bridgeService: BridgeService | undefined;
+  private _connections = new Set<WebRTCTransportProxy>();
+
+  /**
+   * Sets the current BridgeService to be used to open connections.
+   * Calling this method will close any existing connections.
+   */
+  setBridgeService(bridgeService: BridgeService | undefined): this {
+    this._bridgeService = bridgeService;
+    for (const connection of this._connections) {
+      connection.forceClose();
+    }
+
+    return this;
+  }
+
+  create(options: TransportOptions): Transport {
+    assert(this._bridgeService, 'WebRTCTransportProxyFactory is not ready to open connections');
+
+    const transport = new WebRTCTransportProxy({
+      ...options,
+      bridgeService: this._bridgeService
+    });
+
+    this._connections.add(transport);
+    transport.closed.on(() => this._connections.delete(transport));
+
+    return transport;
+  }
+}

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

@@ -0,0 +1,115 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import assert from 'assert';
+import SimplePeerConstructor, { Instance as SimplePeer } from 'simple-peer';
+
+import { Stream } from '@dxos/codec-protobuf';
+import { raise } from '@dxos/debug';
+import { PublicKey } from '@dxos/keys';
+import { log } from '@dxos/log';
+import {
+  BridgeService,
+  ConnectionRequest,
+  SignalRequest,
+  DataRequest,
+  BridgeEvent,
+  ConnectionState,
+  CloseRequest
+} from '@dxos/protocols/proto/dxos/mesh/bridge';
+import { ComplexMap } from '@dxos/util';
+
+import { wrtc } from './webrtc';
+
+export class WebRTCTransportService implements BridgeService {
+  protected peers = new ComplexMap<PublicKey, SimplePeer>(PublicKey.hash);
+
+  // prettier-ignore
+  constructor(
+    private readonly _webrtcConfig?: any
+  ) {}
+
+  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({
+        initiator: request.initiator,
+        wrtc: SimplePeerConstructor.WEBRTC_SUPPORT ? undefined : wrtc ?? raise(new Error('wrtc not available')),
+        config: this._webrtcConfig
+      });
+
+      next({
+        connection: {
+          state: ConnectionState.CONNECTING
+        }
+      });
+
+      peer.on('data', async (payload) => {
+        next({
+          data: {
+            payload
+          }
+        });
+      });
+
+      peer.on('signal', async (data) => {
+        next({
+          signal: {
+            payload: { json: JSON.stringify(data) }
+          }
+        });
+      });
+
+      peer.on('connect', () => {
+        next({
+          connection: {
+            state: ConnectionState.CONNECTED
+          }
+        });
+      });
+
+      peer.on('error', async (err) => {
+        next({
+          connection: {
+            state: ConnectionState.CLOSED,
+            error: err.toString()
+          }
+        });
+        close(err);
+      });
+
+      peer.on('close', async () => {
+        next({
+          connection: {
+            state: ConnectionState.CLOSED
+          }
+        });
+        close();
+      });
+
+      this.peers.set(request.proxyId, peer);
+
+      ready();
+    });
+  }
+
+  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));
+  }
+
+  async sendData({ proxyId, payload }: DataRequest): Promise<void> {
+    assert(this.peers.has(proxyId));
+    this.peers.get(proxyId)!.write(payload);
+  }
+
+  async close({ proxyId }: CloseRequest) {
+    this.peers.get(proxyId)?.destroy();
+    this.peers.delete(proxyId);
+    log('Closed.');
+  }
+}

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

@@ -0,0 +1,112 @@
+//
+// Copyright 2020 DXOS.org
+//
+
+import expect from 'expect';
+import { Duplex } from 'stream';
+import waitForExpect from 'wait-for-expect';
+
+import { sleep } from '@dxos/async';
+import { discoveryKey } from '@dxos/crypto';
+import { PublicKey } from '@dxos/keys';
+import { Protocol } from '@dxos/mesh-protocol';
+import { afterTest } from '@dxos/testutils';
+
+import { TestProtocolPlugin, testProtocolProvider } from '../testing';
+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) => {}
+    );
+
+    let callsCounter = 0;
+    const closedCb = () => {
+      callsCounter++;
+    };
+    connection.closed.once(closedCb);
+
+    await sleep(10); // Let simple-peer process events.
+    await connection.close();
+
+    await sleep(10); // Process events.
+
+    expect(callsCounter).toEqual(1);
+  })
+    .timeout(1_000)
+    .retries(3);
+
+  it('establish connection and send data through with protocol', async 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({
+        channel: discoveryKey(topic),
+        initiator: true
+      }).stream,
+      peer1Id,
+      peer2Id,
+      sessionId,
+      topic,
+      async (msg) => {
+        await sleep(10);
+        await connection2.signal(msg.data.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({
+        channel: discoveryKey(topic),
+        initiator: false
+      }).stream,
+      peer2Id,
+      peer1Id,
+      sessionId,
+      topic,
+      async (msg) => {
+        await sleep(10);
+        await connection1.signal(msg.data.signal);
+      }
+    );
+    afterTest(() => connection2.close());
+    afterTest(() => connection2.errors.assertNoUnhandledErrors());
+
+    const received: any[] = [];
+    const mockReceive = (p: Protocol, s: string) => {
+      received.push(p, s);
+      return undefined;
+    };
+    plugin1.on('receive', mockReceive);
+
+    plugin2.on('connect', async (protocol) => {
+      await plugin2.send(peer1Id.asBuffer(), '{"message": "Hello"}');
+    });
+
+    await waitForExpect(() => {
+      expect(received.length).toBe(2);
+      expect(received[0]).toBeInstanceOf(Protocol);
+      expect(received[1]).toBe('{"message": "Hello"}');
+    });
+  })
+    .timeout(2_000)
+    .retries(3);
+});