@dxos/network-manager 2.33.9-dev.9246a07b → 2.33.9-dev.9bbef4e2

package/src/signal/signal-rpc-client.ts

@@ -0,0 +1,121 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import debug from 'debug';
+import WebSocket from 'isomorphic-ws';
+
+import { Trigger, Event } from '@dxos/async';
+import { Any, Stream } from '@dxos/codec-protobuf';
+import { PublicKey } from '@dxos/protocols';
+import { createBundledRpcClient, ProtoRpcClient } from '@dxos/rpc';
+
+import { schema } from '../proto/gen';
+import { Message, Signal } from '../proto/gen/dxos/mesh/signal';
+interface Services {
+  Signal: Signal
+}
+
+const log = debug('dxos:network-manager:signal-rpc-client');
+
+export class SignalRPCClient {
+  private readonly _socket: WebSocket
+  private readonly _rpc: ProtoRpcClient<Services>
+  private readonly _connectTrigger = new Trigger();
+
+  readonly connected = new Event();
+  readonly disconnected = new Event();
+  readonly error = new Event<Error>();
+
+  constructor (
+    private readonly _url: string
+  ) {
+    this._socket = new WebSocket(this._url);
+    this._socket.onopen = async () => {
+      try {
+        await this._rpc.open();
+        log(`RPC open ${this._url}`);
+        this.connected.emit();
+        this._connectTrigger.wake();
+      } catch (err: any) {
+        this.error.emit(err);
+      }
+    };
+
+    this._socket.onclose = async () => {
+      log(`Disconnected ${this._url}`);
+      this.disconnected.emit();
+      try {
+        await this._rpc.close();
+      } catch (err: any) {
+        this.error.emit(err);
+      }
+    };
+
+    this._socket.onerror = (e: WebSocket.ErrorEvent) => {
+      log(`Signal socket error ${this._url} ${e.message}`);
+      this.error.emit(e.error ?? new Error(e.message));
+    };
+
+    this._rpc = createBundledRpcClient(
+      {
+        Signal: schema.getService('dxos.mesh.signal.Signal')
+      },
+      {
+        noHandshake: true,
+        port: {
+          send: msg => {
+            this._socket.send(msg);
+          },
+          subscribe: cb => {
+            this._socket.onmessage = async (msg: WebSocket.MessageEvent) => {
+              if (typeof Blob !== 'undefined' && msg.data instanceof Blob) {
+                cb(Buffer.from(await msg.data.arrayBuffer()));
+              } else {
+                cb(msg.data as any);
+              }
+            };
+          }
+        }
+      }
+    );
+  }
+
+  async join (topic: PublicKey, peerId: PublicKey) {
+    log('join', topic, peerId);
+    await this._connectTrigger.wait();
+    const swarmStream = this._rpc.rpc.Signal.join({
+      swarm: topic.asUint8Array(),
+      peer: peerId.asUint8Array()
+    });
+    await swarmStream.waitUntilReady();
+    return swarmStream;
+  }
+
+  async receiveMessages (peerId: PublicKey): Promise<Stream<Message>> {
+    await this._connectTrigger.wait();
+    const messageStream = this._rpc.rpc.Signal.receiveMessages({
+      peer: peerId.asUint8Array()
+    });
+    await messageStream.waitUntilReady();
+    return messageStream;
+  }
+
+  async sendMessage (author: PublicKey, recipient: PublicKey, message: Any) {
+    log('sendMessage', author, recipient, message);
+    await this._connectTrigger.wait();
+    await this._rpc.rpc.Signal.sendMessage({
+      author: author.asUint8Array(),
+      recipient: recipient.asUint8Array(),
+      payload: message
+    });
+  }
+
+  async close () {
+    try {
+      await this._rpc.close();
+    } finally {
+      this._socket.close();
+    }
+  }
+}

package/src/swarm/connection.ts

@@ -10,7 +10,7 @@ import { ErrorStream } from '@dxos/debug';
 import { Protocol } from '@dxos/mesh-protocol';
 import { PublicKey } from '@dxos/protocols';
 
-import { Message } from '../proto/gen/dxos/mesh/signal';
+import { SignalMessage } from '../proto/gen/dxos/mesh/signalMessage';
 import { Transport, TransportFactory } from '../transport';
 
 const log = debug('dxos:network-manager:swarm:connection');
@@ -51,7 +51,7 @@ export enum ConnectionState {
 export class Connection {
   private _state: ConnectionState = ConnectionState.INITIAL;
   private _transport: Transport | undefined;
-  private _bufferedSignals: Message[] = [];
+  private _bufferedSignals: SignalMessage[] = [];
 
   readonly stateChanged = new Event<ConnectionState>();
   readonly errors = new ErrorStream();
@@ -62,7 +62,7 @@ export class Connection {
     public readonly remoteId: PublicKey,
     public readonly sessionId: PublicKey,
     public readonly initiator: boolean,
-    private readonly _sendSignal: (msg: Message) => Promise<void>,
+    private readonly _sendSignal: (msg: SignalMessage) => Promise<void>,
     private readonly _protocol: Protocol,
     private readonly _transportFactory: TransportFactory
   ) {}
@@ -116,16 +116,13 @@ export class Connection {
     this._bufferedSignals = [];
   }
 
-  async signal (msg: Message) {
+  async signal (msg: SignalMessage) {
     assert(msg.sessionId);
     if (!msg.sessionId.equals(this.sessionId)) {
       log('Dropping signal for incorrect session id.');
       return;
     }
-    assert(msg.data);
-    if (msg.data.offer && this._state === ConnectionState.INITIATING_CONNECTION) {
-      throw new Error('Invalid state: Cannot send offer to an initiating peer.');
-    }
+    assert(msg.data.signal);
     assert(msg.id?.equals(this.remoteId));
     assert(msg.remoteId?.equals(this.ownId));
 

package/src/swarm/swarm.test.ts

@@ -12,7 +12,7 @@ import { Protocol } from '@dxos/mesh-protocol';
 import { PublicKey } from '@dxos/protocols';
 import { afterTest } from '@dxos/testutils';
 
-import { Message } from '../proto/gen/dxos/mesh/signal';
+import { SignalMessage } from '../proto/gen/dxos/mesh/signalMessage';
 import { SignalMessaging } from '../signal';
 import { MessageRouter } from '../signal/message-router';
 import { FullyConnectedTopology } from '../topology';
@@ -21,175 +21,214 @@ import { Swarm } from './swarm';
 
 const log = debug('dxos:network-manager:swarm:test');
 
-class MockSignalConnection implements SignalMessaging {
-  constructor (
-    readonly _swarm: () => Swarm,
-    readonly _delay = 10
-  ) {}
-
-  async offer (msg: Message) {
-    await sleep(this._delay);
-    return this._swarm().onOffer(msg);
+describe('Swarm', () => {
+  class MockSignalConnection implements SignalMessaging {
+    constructor (
+      readonly _swarm: () => Swarm,
+      readonly _delay = 10
+    ) {}
+
+    async offer (msg: SignalMessage) {
+      await sleep(this._delay);
+      return this._swarm().onOffer(msg);
+    }
+
+    async signal (msg: SignalMessage) {
+      await sleep(this._delay);
+      await this._swarm().onSignal(msg);
+    }
   }
 
-  async signal (msg: Message) {
-    await sleep(this._delay);
-    await this._swarm().onSignal(msg);
-  }
-}
-
-const setup = ({ router = false } = {}) => {
-  const topic = PublicKey.random();
-  const peerId1 = PublicKey.random();
-  const peerId2 = PublicKey.random();
-  // eslint-disable-next-line prefer-const
-  let swarm1: Swarm;
-  // eslint-disable-next-line prefer-const
-  let swarm2: Swarm;
-
-  const mr1: MessageRouter = new MessageRouter({
-    sendMessage: msg => mr2.receiveMessage(msg),
-    onSignal: msg => swarm1.onSignal(msg),
-    onOffer: msg => swarm1.onOffer(msg)
-  });
-  afterTest(() => mr1.destroy());
-
-  const mr2: MessageRouter = new MessageRouter({
-    sendMessage: msg => mr1.receiveMessage(msg),
-    onSignal: msg => swarm2.onSignal(msg),
-    onOffer: msg => swarm2.onOffer(msg)
-  });
-  afterTest(() => mr2.destroy());
-
-  const sm1: SignalMessaging = router ? mr1 : new MockSignalConnection(() => swarm2);
-
-  const sm2: SignalMessaging = router ? mr2 : new MockSignalConnection(() => swarm1);
-
-  swarm1 = new Swarm(
-    topic,
-    peerId1,
-    new FullyConnectedTopology(),
-    () => new Protocol(),
-    sm1,
-    () => {},
-    createWebRTCTransportFactory(),
-    undefined
-  );
-
-  swarm2 = new Swarm(
-    topic,
-    peerId2,
-    new FullyConnectedTopology(),
-    () => new Protocol(),
-    sm2,
-    () => {},
-    createWebRTCTransportFactory(),
-    undefined
-  );
-
-  afterTest(async () => {
+  const setup = ({ router = false } = {}) => {
+    const topic = PublicKey.random();
+    const peerId1 = PublicKey.random();
+    const peerId2 = PublicKey.random();
+    // eslint-disable-next-line prefer-const
+    let swarm1: Swarm;
+    // eslint-disable-next-line prefer-const
+    let swarm2: Swarm;
+
+    const mr1: MessageRouter = new MessageRouter({
+      sendMessage: msg => mr2.receiveMessage(msg),
+      onSignal: msg => swarm1.onSignal(msg),
+      onOffer: msg => swarm1.onOffer(msg)
+    });
+    afterTest(() => mr1.destroy());
+
+    const mr2: MessageRouter = new MessageRouter({
+      sendMessage: msg => mr1.receiveMessage(msg),
+      onSignal: msg => swarm2.onSignal(msg),
+      onOffer: msg => swarm2.onOffer(msg)
+    });
+    afterTest(() => mr2.destroy());
+
+    const sm1: SignalMessaging = router ? mr1 : new MockSignalConnection(() => swarm2);
+
+    const sm2: SignalMessaging = router ? mr2 : new MockSignalConnection(() => swarm1);
+
+    swarm1 = new Swarm(
+      topic,
+      peerId1,
+      new FullyConnectedTopology(),
+      () => new Protocol(),
+      sm1,
+      createWebRTCTransportFactory(),
+      undefined
+    );
+
+    swarm2 = new Swarm(
+      topic,
+      peerId2,
+      new FullyConnectedTopology(),
+      () => new Protocol(),
+      sm2,
+      createWebRTCTransportFactory(),
+      undefined
+    );
+
+    afterTest(async () => {
+      await swarm1.destroy();
+      await swarm2.destroy();
+    });
+
+    return { swarm1, swarm2, peerId1, peerId2 };
+  };
+
+  test('connects two peers in a swarm', async () => {
+    const { swarm1, swarm2, peerId1, peerId2 } = setup();
+
+    expect(swarm1.connections.length).toEqual(0);
+    expect(swarm2.connections.length).toEqual(0);
+
+    const promise = Promise.all([
+      promiseTimeout(swarm1.connected.waitForCount(1), 3000, new Error('Swarm1 connect timeout.')),
+      promiseTimeout(swarm2.connected.waitForCount(1), 3000, new Error('Swarm2 connect timeout.'))
+    ]);
+
+    // Behavior of the Signal Server.
+    swarm1.onSwarmEvent({
+      peerAvailable: {
+        peer: peerId1.asUint8Array(),
+        since: new Date()
+      }
+    });
+
+    swarm1.onSwarmEvent({
+      peerAvailable: {
+        peer: peerId2.asUint8Array(),
+        since: new Date()
+      }
+    });
+
+    log('Candidates changed');
+    await promise;
+    log('Swarms connected');
+
+    const swarm1Connection = swarm1.connections[0];
+    const swarm2Connection = swarm2.connections[0];
+    const onData = mockFn<(data: Buffer) => void>().returns(undefined);
+    (swarm2Connection.transport as WebRTCTransport).peer!.on('data', onData);
+
+    const data = Buffer.from('1234');
+    (swarm1Connection.transport as WebRTCTransport).peer!.send(data);
+    await waitForExpect(() => {
+      expect(onData).toHaveBeenCalledWith([data]);
+    });
+  }).timeout(5_000);
+
+  test('two peers try to originate connections to each other simultaneously', async () => {
+    const { swarm1, swarm2, peerId1, peerId2 } = setup();
+
+    expect(swarm1.connections.length).toEqual(0);
+    expect(swarm2.connections.length).toEqual(0);
+
+    swarm1.onSwarmEvent({
+      peerAvailable: {
+        peer: peerId2.asUint8Array(),
+        since: new Date()
+      }
+    });
+
+    swarm2.onSwarmEvent({
+      peerAvailable: {
+        peer: peerId1.asUint8Array(),
+        since: new Date()
+      }
+    });
+
+    await Promise.all([
+      swarm1.connected.waitForCount(1),
+      swarm2.connected.waitForCount(1)
+    ]);
+  }).timeout(5_000);
+
+  test('second peer discovered after delay', async () => {
+    const { swarm1, swarm2, peerId1, peerId2 } = setup();
+
+    expect(swarm1.connections.length).toEqual(0);
+    expect(swarm2.connections.length).toEqual(0);
+
+    swarm1.onSwarmEvent({
+      peerAvailable: {
+        peer: peerId2.asUint8Array(),
+        since: new Date()
+      }
+    });
+    await sleep(15);
+    swarm2.onSwarmEvent({
+      peerAvailable: {
+        peer: peerId1.asUint8Array(),
+        since: new Date()
+      }
+    });
+
+    await Promise.all([
+      swarm1.connected.waitForCount(1),
+      swarm1.connected.waitForCount(1)
+    ]);
+
+    const swarm1Connection = swarm1.connections[0];
+    const swarm2Connection = swarm2.connections[0];
+    const onData = mockFn<(data: Buffer) => void>().returns(undefined);
+    (swarm2Connection.transport as WebRTCTransport).peer!.on('data', onData);
+
+    const data = Buffer.from('1234');
+    (swarm1Connection.transport as WebRTCTransport).peer!.send(data);
+    await waitForExpect(() => {
+      expect(onData).toHaveBeenCalledWith([data]);
+    });
+  }).timeout(5_000);
+
+  test('swarming with message router', async () => {
+    const { swarm1, swarm2, peerId2 } = setup({ router: true });
+
+    const promise = Promise.all([
+      promiseTimeout(swarm1.connected.waitForCount(1), 3000, new Error('Swarm1 connect timeout.')),
+      promiseTimeout(swarm2.connected.waitForCount(1), 3000, new Error('Swarm2 connect timeout.'))
+    ]);
+
+    swarm1.onSwarmEvent({
+      peerAvailable: {
+        peer: peerId2.asUint8Array(),
+        since: new Date()
+      }
+    });
+
+    log('Candidates changed');
+    await promise;
+    log('Swarms connected');
+
+    const swarm1Connection = swarm1.connections[0];
+    const swarm2Connection = swarm2.connections[0];
+    const onData = mockFn<(data: Buffer) => void>().returns(undefined);
+    (swarm2Connection.transport as WebRTCTransport).peer!.on('data', onData);
+
+    const data = Buffer.from('1234');
+    (swarm1Connection.transport as WebRTCTransport).peer!.send(data);
+    await waitForExpect(() => {
+      expect(onData).toHaveBeenCalledWith([data]);
+    });
     await swarm1.destroy();
     await swarm2.destroy();
-  });
-
-  return { swarm1, swarm2, peerId1, peerId2 };
-};
-
-test('connects two peers in a swarm', async () => {
-  const { swarm1, swarm2, peerId2 } = setup();
-
-  expect(swarm1.connections.length).toEqual(0);
-  expect(swarm2.connections.length).toEqual(0);
-
-  const promise = Promise.all([
-    promiseTimeout(swarm1.connected.waitForCount(1), 3000, new Error('Swarm1 connect timeout.')),
-    promiseTimeout(swarm2.connected.waitForCount(1), 3000, new Error('Swarm2 connect timeout.'))
-  ]);
-
-  swarm1.onPeerCandidatesChanged([peerId2]);
-
-  log('Candidates changed');
-  await promise;
-  log('Swarms connected');
-
-  const swarm1Connection = swarm1.connections[0];
-  const swarm2Connection = swarm2.connections[0];
-  const onData = mockFn<(data: Buffer) => void>().returns(undefined);
-  (swarm2Connection.transport as WebRTCTransport).peer!.on('data', onData);
-
-  const data = Buffer.from('1234');
-  (swarm1Connection.transport as WebRTCTransport).peer!.send(data);
-  await waitForExpect(() => {
-    expect(onData).toHaveBeenCalledWith([data]);
-  });
-}).timeout(5_000);
-
-test('two peers try to originate connections to each other simultaneously', async () => {
-  const { swarm1, swarm2, peerId1, peerId2 } = setup();
-
-  expect(swarm1.connections.length).toEqual(0);
-  expect(swarm2.connections.length).toEqual(0);
-
-  swarm1.onPeerCandidatesChanged([peerId2]);
-  swarm2.onPeerCandidatesChanged([peerId1]);
-
-  await Promise.all([
-    swarm1.connected.waitForCount(1),
-    swarm2.connected.waitForCount(1)
-  ]);
-}).timeout(5_000);
-
-test('second peer discovered after delay', async () => {
-  const { swarm1, swarm2, peerId1, peerId2 } = setup();
-
-  expect(swarm1.connections.length).toEqual(0);
-  expect(swarm2.connections.length).toEqual(0);
-
-  swarm1.onPeerCandidatesChanged([peerId2]);
-  await sleep(15);
-  swarm2.onPeerCandidatesChanged([peerId1]);
-
-  await Promise.all([
-    swarm1.connected.waitForCount(1),
-    swarm1.connected.waitForCount(1)
-  ]);
-
-  const swarm1Connection = swarm1.connections[0];
-  const swarm2Connection = swarm2.connections[0];
-  const onData = mockFn<(data: Buffer) => void>().returns(undefined);
-  (swarm2Connection.transport as WebRTCTransport).peer!.on('data', onData);
-
-  const data = Buffer.from('1234');
-  (swarm1Connection.transport as WebRTCTransport).peer!.send(data);
-  await waitForExpect(() => {
-    expect(onData).toHaveBeenCalledWith([data]);
-  });
-}).timeout(5_000);
-
-test('swarming with message router', async () => {
-  const { swarm1, swarm2, peerId2 } = setup({ router: true });
-
-  const promise = Promise.all([
-    promiseTimeout(swarm1.connected.waitForCount(1), 3000, new Error('Swarm1 connect timeout.')),
-    promiseTimeout(swarm2.connected.waitForCount(1), 3000, new Error('Swarm2 connect timeout.'))
-  ]);
-
-  swarm1.onPeerCandidatesChanged([peerId2]);
-
-  log('Candidates changed');
-  await promise;
-  log('Swarms connected');
-
-  const swarm1Connection = swarm1.connections[0];
-  const swarm2Connection = swarm2.connections[0];
-  const onData = mockFn<(data: Buffer) => void>().returns(undefined);
-  (swarm2Connection.transport as WebRTCTransport).peer!.on('data', onData);
-
-  const data = Buffer.from('1234');
-  (swarm1Connection.transport as WebRTCTransport).peer!.send(data);
-  await waitForExpect(() => {
-    expect(onData).toHaveBeenCalledWith([data]);
-  });
-  await swarm1.destroy();
-  await swarm2.destroy();
-}).timeout(5_000);
+  }).timeout(5_000);
+});

package/src/swarm/swarm.ts

@@ -12,7 +12,8 @@ import { PublicKey } from '@dxos/protocols';
 import { ComplexMap, ComplexSet } from '@dxos/util';
 
 import { ProtocolProvider } from '../network-manager';
-import { Answer, Message } from '../proto/gen/dxos/mesh/signal';
+import { SwarmEvent } from '../proto/gen/dxos/mesh/signal';
+import { Answer, SignalMessage } from '../proto/gen/dxos/mesh/signalMessage';
 import { SignalMessaging } from '../signal';
 import { SwarmController, Topology } from '../topology';
 import { TransportFactory } from '../transport';
@@ -34,7 +35,6 @@ export class Swarm {
 
   private readonly _connections = new ComplexMap<PublicKey, Connection>(x => x.toHex());
   private readonly _discoveredPeers = new ComplexSet<PublicKey>(x => x.toHex());
-  private readonly _peerCandidatesUpdated = new Event();
 
   get connections () {
     return Array.from(this._connections.values());
@@ -64,7 +64,6 @@ export class Swarm {
     private _topology: Topology,
     private readonly _protocolProvider: ProtocolProvider,
     private readonly _signalMessaging: SignalMessaging,
-    private readonly _lookupPeers: (topic: PublicKey) => void,
     private readonly _transportFactory: TransportFactory,
     private readonly _label: string | undefined
   ) {
@@ -87,26 +86,33 @@ export class Swarm {
     return this._topic;
   }
 
-  onPeerCandidatesChanged (candidates: PublicKey[]) {
-    log(`New peers for ${this._topic} ${candidates}`);
-    this._discoveredPeers.clear();
-    for (const candidate of candidates) {
-      if (candidate.equals(this._ownPeerId)) {
-        continue;
+  onSwarmEvent (swarmEvent: SwarmEvent) {
+    log(`Swarm event ${JSON.stringify(swarmEvent)}`);
+    if (swarmEvent.peerAvailable) {
+      const peerId = PublicKey.from(swarmEvent.peerAvailable.peer);
+      log(`New peer for ${this._topic} ${peerId}`);
+      if (!peerId.equals(this._ownPeerId)) {
+        this._discoveredPeers.add(peerId);
       }
-      this._discoveredPeers.add(candidate);
+    } else if (swarmEvent.peerLeft) {
+      this._discoveredPeers.delete(PublicKey.from(swarmEvent.peerLeft.peer));
     }
-    this._peerCandidatesUpdated.emit();
     this._topology.update();
   }
 
-  async onOffer (message: Message): Promise<Answer> {
+  async onOffer (message: SignalMessage): Promise<Answer> {
     log(`Offer from ${JSON.stringify(message)}`);
     // Id of the peer offering us the connection.
     assert(message.id);
     const remoteId = message.id;
-    assert(message.remoteId?.equals(this._ownPeerId));
-    assert(message.topic?.equals(this._topic));
+    if (!message.remoteId?.equals(this._ownPeerId)) {
+      log(`Rejecting offer with incorrect peerId: ${message.remoteId}`);
+      return { accept: false };
+    }
+    if (!message.topic?.equals(this._topic)) {
+      log(`Rejecting offer with incorrect topic: ${message.topic}`);
+      return { accept: false };
+    }
 
     // Check if we are already trying to connect to that peer.
     if (this._connections.has(remoteId)) {
@@ -140,7 +146,7 @@ export class Swarm {
     return { accept };
   }
 
-  async onSignal (message: Message): Promise<void> {
+  async onSignal (message: SignalMessage): Promise<void> {
     log(`Signal ${this._topic} ${JSON.stringify(message)}`);
     assert(message.remoteId?.equals(this._ownPeerId), `Invalid signal peer id expected=${this.ownPeerId}, actual=${message.remoteId}`);
     assert(message.topic?.equals(this._topic));
@@ -186,9 +192,6 @@ export class Swarm {
           this.errors.raise(err);
         }
         this._topology.update();
-      },
-      lookup: () => {
-        this._lookupPeers(this._topic);
       }
     };
   }
@@ -201,6 +204,7 @@ export class Swarm {
 
     const sessionId = PublicKey.random();
 
+    log(`Initiate connection: topic=${this._topic} peerId=${remoteId} sessionId=${sessionId}`);
     const connection = this._createConnection(true, remoteId, sessionId);
     this._signalMessaging.offer({
       id: this._ownPeerId,
@@ -236,7 +240,7 @@ export class Swarm {
   }
 
   private _createConnection (initiator: boolean, remoteId: PublicKey, sessionId: PublicKey) {
-    log(`Create connection topic=${this._topic} remoteId=${remoteId} initiator=${initiator}`);
+    log(`Create connection topic=${this._topic} ownId=${this._ownPeerId} remoteId=${remoteId} initiator=${initiator}`);
     assert(!this._connections.has(remoteId), 'Peer already connected.');
 
     const connection = new Connection(
@@ -245,7 +249,7 @@ export class Swarm {
       remoteId,
       sessionId,
       initiator,
-      (msg: Message) => this._signalMessaging.signal(msg),
+      (msg: SignalMessage) => this._signalMessaging.signal(msg),
       this._protocolProvider({ channel: discoveryKey(this._topic), initiator }),
       this._transportFactory
     );