@dxos/network-manager 2.33.5-dev.fa6b779b → 2.33.6-dev.21302cba

package/src/signal/signal-client.ts

@@ -0,0 +1,235 @@
+//
+// Copyright 2020 DXOS.org
+//
+
+import debug from 'debug';
+
+import { Event } from '@dxos/async';
+import { PublicKey } from '@dxos/crypto';
+
+import { SignalApi } from './signal-api';
+import { WebsocketRpc } from './websocket-rpc';
+
+const log = debug('dxos:network-manager:signal-client');
+
+const DEFAULT_RECONNECT_TIMEOUT = 1000;
+
+/**
+ * Establishes a websocket connection to signal server and provides RPC methods.
+ */
+export class SignalClient {
+  private _state = SignalApi.State.CONNECTING;
+
+  private _lastError?: Error;
+
+  /**
+   * Number of milliseconds after which the connection will be attempted again in case of error.
+   */
+  private _reconnectAfter = DEFAULT_RECONNECT_TIMEOUT;
+
+  /**
+   * Timestamp of when the connection attempt was began.
+   */
+  private _connectionStarted = Date.now();
+
+  /**
+   * Timestamp of last state change.
+   */
+  private _lastStateChange = Date.now();
+
+  private _reconnectIntervalId?: NodeJS.Timeout;
+
+  private _client!: WebsocketRpc;
+
+  private _clientCleanup: (() => void)[] = [];
+
+  readonly statusChanged = new Event<SignalApi.Status>();
+  readonly commandTrace = new Event<SignalApi.CommandTrace>();
+
+  /**
+   * @param _host Signal server websocket URL.
+   * @param _onOffer See `SignalApi.offer`.
+   * @param _onSignal See `SignalApi.signal`.
+   */
+  constructor (
+    private readonly _host: string,
+    private readonly _onOffer: (message: SignalApi.SignalMessage) => Promise<SignalApi.Answer>,
+    private readonly _onSignal: (message: SignalApi.SignalMessage) => Promise<void>
+  ) {
+    this._setState(SignalApi.State.CONNECTING);
+    this._createClient();
+  }
+
+  private _setState (newState: SignalApi.State) {
+    this._state = newState;
+    this._lastStateChange = Date.now();
+    log(`Signal state changed ${JSON.stringify(this.getStatus())}`);
+    this.statusChanged.emit(this.getStatus());
+  }
+
+  private _createClient () {
+    this._connectionStarted = Date.now();
+    try {
+      this._client = new WebsocketRpc(this._host);
+    } catch (error: any) {
+      if (this._state === SignalApi.State.RE_CONNECTING) {
+        this._reconnectAfter *= 2;
+      }
+
+      this._lastError = error;
+      this._setState(SignalApi.State.DISCONNECTED);
+      this._reconnect();
+    }
+
+    this._client.addHandler('offer', (message: any) => this._onOffer({
+      id: PublicKey.from(message.id),
+      remoteId: PublicKey.from(message.remoteId),
+      topic: PublicKey.from(message.topic),
+      sessionId: PublicKey.from(message.sessionId),
+      data: message.data
+    }));
+
+    this._client.subscribe('signal', (msg: SignalApi.SignalMessage) => this._onSignal({
+      id: PublicKey.from(msg.id),
+      remoteId: PublicKey.from(msg.remoteId),
+      topic: PublicKey.from(msg.topic),
+      sessionId: PublicKey.from(msg.sessionId),
+      data: msg.data
+    }));
+
+    this._clientCleanup.push(this._client.connected.on(() => {
+      log('Socket connected');
+      this._lastError = undefined;
+      this._reconnectAfter = DEFAULT_RECONNECT_TIMEOUT;
+      this._setState(SignalApi.State.CONNECTED);
+    }));
+
+    this._clientCleanup.push(this._client.error.on(error => {
+      log(`Socket error: ${error.message}`);
+      if (this._state === SignalApi.State.CLOSED) {
+        return;
+      }
+
+      if (this._state === SignalApi.State.RE_CONNECTING) {
+        this._reconnectAfter *= 2;
+      }
+
+      this._lastError = error;
+      this._setState(SignalApi.State.DISCONNECTED);
+
+      this._reconnect();
+    }));
+
+    this._clientCleanup.push(this._client.disconnected.on(() => {
+      log('Socket disconnected');
+      // This is also called in case of error, but we already have disconnected the socket on error, so no need to do anything here.
+      if (this._state !== SignalApi.State.CONNECTING && this._state !== SignalApi.State.RE_CONNECTING) {
+        return;
+      }
+
+      if (this._state === SignalApi.State.RE_CONNECTING) {
+        this._reconnectAfter *= 2;
+      }
+
+      this._setState(SignalApi.State.DISCONNECTED);
+      this._reconnect();
+    }));
+
+    this._clientCleanup.push(this._client.commandTrace.on(trace => this.commandTrace.emit(trace)));
+  }
+
+  private _reconnect () {
+    if (this._reconnectIntervalId !== undefined) {
+      console.error('Signal api already reconnecting.');
+      return;
+    }
+    if (this._state === SignalApi.State.CLOSED) {
+      return;
+    }
+
+    this._reconnectIntervalId = setTimeout(() => {
+      this._reconnectIntervalId = undefined;
+
+      this._clientCleanup.forEach(cb => cb());
+      this._clientCleanup = [];
+
+      // Close client if it wasn't already closed.
+      this._client.close().catch(() => {});
+
+      this._setState(SignalApi.State.RE_CONNECTING);
+      this._createClient();
+    }, this._reconnectAfter);
+  }
+
+  async close () {
+    this._clientCleanup.forEach(cb => cb());
+    this._clientCleanup = [];
+
+    if (this._reconnectIntervalId !== undefined) {
+      clearTimeout(this._reconnectIntervalId);
+    }
+
+    await this._client.close();
+    this._setState(SignalApi.State.CLOSED);
+  }
+
+  getStatus (): SignalApi.Status {
+    return {
+      host: this._host,
+      state: this._state,
+      error: this._lastError?.message,
+      reconnectIn: this._reconnectAfter,
+      connectionStarted: this._connectionStarted,
+      lastStateChange: this._lastStateChange
+    };
+  }
+
+  async join (topic: PublicKey, peerId: PublicKey): Promise<PublicKey[]> {
+    const peers: Buffer[] = await this._client.call('join', {
+      id: peerId.asBuffer(),
+      topic: topic.asBuffer()
+    });
+    return peers.map(id => PublicKey.from(id));
+  }
+
+  async leave (topic: PublicKey, peerId: PublicKey): Promise<void> {
+    await this._client.call('leave', {
+      id: peerId.asBuffer(),
+      topic: topic.asBuffer()
+    });
+  }
+
+  async lookup (topic: PublicKey): Promise<PublicKey[]> {
+    const peers: Buffer[] = await this._client.call('lookup', {
+      topic: topic.asBuffer()
+    });
+    return peers.map(id => PublicKey.from(id));
+  }
+
+  /**
+   * Routes an offer to the other peer's _onOffer callback.
+   * @returns Other peer's _onOffer callback return value.
+   */
+  async offer (payload: SignalApi.SignalMessage): Promise<SignalApi.Answer> {
+    return this._client.call('offer', {
+      id: payload.id.asBuffer(),
+      remoteId: payload.remoteId.asBuffer(),
+      topic: payload.topic.asBuffer(),
+      sessionId: payload.sessionId.asBuffer(),
+      data: payload.data
+    });
+  }
+
+  /**
+   * Routes an offer to the other peer's _onSignal callback.
+   */
+  async signal (payload: SignalApi.SignalMessage): Promise<void> {
+    return this._client.emit('signal', {
+      id: payload.id.asBuffer(),
+      remoteId: payload.remoteId.asBuffer(),
+      topic: payload.topic.asBuffer(),
+      sessionId: payload.sessionId.asBuffer(),
+      data: payload.data
+    });
+  }
+}

package/src/signal/signal-manager.ts

@@ -0,0 +1,39 @@
+//
+// Copyright 2020 DXOS.org
+//
+
+import { Event } from '@dxos/async';
+import { PublicKey } from '@dxos/crypto';
+
+import { SignalApi } from './signal-api';
+
+// TODO(burdon): Document methods.
+export interface SignalConnection {
+  /**
+   * Find peers (triggers async event).
+   */
+  lookup (topic: PublicKey): void
+
+  /**
+   *
+   */
+  // TODO(burdon): Document.
+  offer (msg: SignalApi.SignalMessage): Promise<SignalApi.Answer>
+
+  /**
+   * Send message to peer.
+   */
+  signal (msg: SignalApi.SignalMessage): Promise<void>
+}
+
+export interface SignalManager extends SignalConnection {
+  statusChanged: Event<SignalApi.Status[]>
+  commandTrace: Event<SignalApi.CommandTrace>
+  peerCandidatesChanged: Event<[topic: PublicKey, candidates: PublicKey[]]>
+  onSignal: Event<SignalApi.SignalMessage>
+
+  getStatus (): SignalApi.Status[]
+  join (topic: PublicKey, peerId: PublicKey): void
+  leave (topic: PublicKey, peerId: PublicKey): void
+  destroy(): Promise<void>
+}

package/src/signal/websocket-rpc.ts

@@ -25,19 +25,13 @@ const RPC_TIMEOUT = 3_000;
  */
 export class WebsocketRpc {
   private readonly _connectTrigger = new Trigger();
-
   private readonly _socket: WebSocket;
-
   private readonly _rpc: any;
-
   private _messageId = Date.now();
 
   readonly commandTrace = new Event<SignalApi.CommandTrace>();
-
   readonly connected = new Event();
-
   readonly disconnected = new Event();
-
   readonly error = new Event<Error>();
 
   /**
@@ -58,6 +52,7 @@ export class WebsocketRpc {
         this.error.emit(err);
       }
     };
+
     this._socket.onclose = async () => {
       log(`Disconnected ${this._host}`);
       this.disconnected.emit();
@@ -67,10 +62,12 @@ export class WebsocketRpc {
         this.error.emit(err);
       }
     };
+
     this._socket.onerror = e => {
       log(`Signal socket error ${this._host} ${e.message}`);
       this.error.emit(e.error ?? new Error(e.message));
     };
+
     this._rpc = nanomessagerpc({
       send: async (data: Uint8Array) => {
         await this._connectTrigger.wait();

package/src/signal/websocket-signal-manager.ts

@@ -9,24 +9,25 @@ import { Event, synchronized } from '@dxos/async';
 import { PublicKey } from '@dxos/crypto';
 import { ComplexMap } from '@dxos/util';
 
-import { SignalManager } from './interface';
 import { SignalApi } from './signal-api';
+import { SignalClient } from './signal-client';
+import { SignalManager } from './signal-manager';
 
 const log = debug('dxos:network-manager:websocket-signal-manager');
 
 export class WebsocketSignalManager implements SignalManager {
-  private readonly _servers = new Map<string, SignalApi>();
+  private readonly _servers = new Map<string, SignalClient>();
 
   /** Topics joined: topic => peerId */
-  private readonly _topicsJoined = new ComplexMap<PublicKey, PublicKey>(x => x.toHex());
-
+  private readonly _topicsJoined = new ComplexMap<PublicKey, PublicKey>(topic => topic.toHex());
   private readonly _topicsJoinedPerSignal = new Map<string, ComplexMap<PublicKey, PublicKey>>();
 
   private _reconcileTimeoutId?: NodeJS.Timeout;
 
   readonly statusChanged = new Event<SignalApi.Status[]>();
-
   readonly commandTrace = new Event<SignalApi.CommandTrace>();
+  readonly peerCandidatesChanged = new Event<[topic: PublicKey, candidates: PublicKey[]]>()
+  readonly onSignal = new Event<SignalApi.SignalMessage>();
 
   constructor (
     private readonly _hosts: string[],
@@ -35,13 +36,12 @@ export class WebsocketSignalManager implements SignalManager {
     log(`Created WebsocketSignalManager with signal servers: ${_hosts}`);
     assert(_hosts.length === 1, 'Only a single signaling server connection is supported');
     for (const host of this._hosts) {
-      const server = new SignalApi(
+      const server = new SignalClient(
         host,
-        async (msg) => this._onOffer(msg),
-        async msg => {
-          this.onSignal.emit(msg);
-        }
+        async msg => this._onOffer(msg),
+        async msg => this.onSignal.emit(msg)
       );
+
       this._servers.set(host, server);
       server.statusChanged.on(() => this.statusChanged.emit(this.getStatus()));
       server.commandTrace.on(trace => this.commandTrace.emit(trace));
@@ -143,7 +143,7 @@ export class WebsocketSignalManager implements SignalManager {
     return Array.from(this._servers.values())[0].offer(msg);
   }
 
-  signal (msg: SignalApi.SignalMessage) {
+  async signal (msg: SignalApi.SignalMessage) {
     log(`Signal ${msg.remoteId}`);
     for (const server of this._servers.values()) {
       void server.signal(msg);
@@ -154,8 +154,4 @@ export class WebsocketSignalManager implements SignalManager {
   async destroy () {
     await Promise.all(Array.from(this._servers.values()).map(server => server.close()));
   }
-
-  peerCandidatesChanged = new Event<[topic: PublicKey, candidates: PublicKey[]]>()
-
-  onSignal = new Event<SignalApi.SignalMessage>();
 }

package/src/swarm/connection.ts

@@ -45,15 +45,15 @@ export enum ConnectionState {
   CLOSED = 'CLOSED',
 }
 
+/**
+ * Represents a connection to a remote peer.
+ */
 export class Connection {
   private _state: ConnectionState = ConnectionState.INITIAL;
-
   private _transport: Transport | undefined;
-
   private _bufferedSignals: SignalApi.SignalMessage[] = [];
 
   readonly stateChanged = new Event<ConnectionState>();
-
   readonly errors = new ErrorStream();
 
   constructor (
@@ -110,12 +110,13 @@ export class Connection {
 
     // Replay signals that were received before transport was created.
     for (const signal of this._bufferedSignals) {
-      this._transport.signal(signal);
+      void this._transport.signal(signal); // TODO(burdon): Remove async?
     }
+
     this._bufferedSignals = [];
   }
 
-  signal (msg: SignalApi.SignalMessage) {
+  async signal (msg: SignalApi.SignalMessage) {
     if (!msg.sessionId.equals(this.sessionId)) {
       log('Dropping signal for incorrect session id.');
       return;
@@ -134,7 +135,7 @@ export class Connection {
 
     assert(this._transport, 'Connection not ready to accept signals.');
     log(`${this.ownId} received signal from ${this.remoteId}: ${msg.data.type}`);
-    this._transport.signal(msg);
+    await this._transport.signal(msg);
   }
 
   @synchronized

package/src/swarm/swarm.test.ts

@@ -12,50 +12,57 @@ import { PublicKey } from '@dxos/crypto';
 import { Protocol } from '@dxos/mesh-protocol';
 import { afterTest } from '@dxos/testutils';
 
+import { SignalApi, SignalConnection } from '../signal';
 import { FullyConnectedTopology } from '../topology';
-import { createWebRtcTransportFactory, WebrtcTransport } from '../transport';
+import { createWebRTCTransportFactory, WebRTCTransport } from '../transport';
 import { Swarm } from './swarm';
 
 const log = debug('dxos:network-manager:swarm:test');
 
+class MockSignalConnection implements SignalConnection {
+  constructor (
+    readonly _swarm: () => Swarm,
+    readonly _delay = 10
+  ) {}
+
+  lookup (topic: PublicKey) {}
+
+  async offer (msg: SignalApi.SignalMessage) {
+    await sleep(this._delay);
+    return this._swarm().onOffer(msg);
+  }
+
+  async signal (msg: SignalApi.SignalMessage) {
+    await sleep(this._delay);
+    await this._swarm().onSignal(msg);
+  }
+}
+
 const setup = () => {
   const topic = PublicKey.random();
   const peerId1 = PublicKey.random();
   const peerId2 = PublicKey.random();
+
   const swarm1: Swarm = new Swarm(
     topic,
     peerId1,
     new FullyConnectedTopology(),
     () => new Protocol(),
-    async msg => {
-      await sleep(10); // Simulating network delay.
-      return swarm2.onOffer(msg);
-    },
-    async msg => {
-      await sleep(10); // Simulating network delay.
-      await swarm2.onSignal(msg);
-    },
-    () => {},
-    createWebRtcTransportFactory(),
+    new MockSignalConnection(() => swarm2),
+    createWebRTCTransportFactory(),
     undefined
   );
+
   const swarm2: Swarm = new Swarm(
     topic,
     peerId2,
     new FullyConnectedTopology(),
     () => new Protocol(),
-    async msg => {
-      await sleep(10); // Simulating network delay.
-      return swarm1.onOffer(msg);
-    },
-    async msg => {
-      await sleep(10); // Simulating network delay.
-      await swarm1.onSignal(msg);
-    },
-    () => {},
-    createWebRtcTransportFactory(),
+    new MockSignalConnection(() => swarm1),
+    createWebRTCTransportFactory(),
     undefined
   );
+
   afterTest(async () => {
     await swarm1.destroy();
     await swarm2.destroy();
@@ -84,10 +91,10 @@ test('connects two peers in a swarm', async () => {
   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);
+  (swarm2Connection.transport as WebRTCTransport).peer!.on('data', onData);
 
   const data = Buffer.from('1234');
-  (swarm1Connection.transport as WebrtcTransport).peer!.send(data);
+  (swarm1Connection.transport as WebRTCTransport).peer!.send(data);
   await waitForExpect(() => {
     expect(onData).toHaveBeenCalledWith([data]);
   });
@@ -126,10 +133,10 @@ test('second peer discovered after delay', async () => {
   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);
+  (swarm2Connection.transport as WebRTCTransport).peer!.on('data', onData);
 
   const data = Buffer.from('1234');
-  (swarm1Connection.transport as WebrtcTransport).peer!.send(data);
+  (swarm1Connection.transport as WebRTCTransport).peer!.send(data);
   await waitForExpect(() => {
     expect(onData).toHaveBeenCalledWith([data]);
   });

package/src/swarm/swarm.ts

@@ -11,7 +11,7 @@ import { ErrorStream } from '@dxos/debug';
 import { ComplexMap, ComplexSet } from '@dxos/util';
 
 import { ProtocolProvider } from '../network-manager';
-import { SignalApi } from '../signal';
+import { SignalApi, SignalConnection } from '../signal';
 import { SwarmController, Topology } from '../topology';
 import { TransportFactory } from '../transport';
 import { Topic } from '../types';
@@ -31,9 +31,7 @@ export class Swarm {
   readonly id = PublicKey.random();
 
   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 () {
@@ -62,10 +60,8 @@ export class Swarm {
     private readonly _topic: PublicKey,
     private readonly _ownPeerId: PublicKey,
     private _topology: Topology,
-    private readonly _protocol: ProtocolProvider,
-    private readonly _sendOffer: (message: SignalApi.SignalMessage) => Promise<SignalApi.Answer>,
-    private readonly _sendSignal: (message: SignalApi.SignalMessage) => Promise<void>,
-    private readonly _lookup: () => void,
+    private readonly _protocolProvider: ProtocolProvider,
+    private readonly _signalConnection: SignalConnection,
     private readonly _transportFactory: TransportFactory,
     private readonly _label: string | undefined
   ) {
@@ -148,7 +144,8 @@ export class Swarm {
       log(`Dropping signal message for non-existent connection: topic=${this._topic}, peerId=${message.id}`);
       return;
     }
-    connection.signal(message);
+
+    await connection.signal(message);
   }
 
   async setTopology (newTopology: Topology) {
@@ -185,7 +182,7 @@ export class Swarm {
         this._topology.update();
       },
       lookup: () => {
-        this._lookup();
+        this._signalConnection.lookup(this._topic);
       }
     };
   }
@@ -199,7 +196,7 @@ export class Swarm {
     const sessionId = PublicKey.random();
 
     const connection = this._createConnection(true, remoteId, sessionId);
-    this._sendOffer({
+    this._signalConnection.offer({
       id: this._ownPeerId,
       remoteId,
       sessionId,
@@ -209,7 +206,7 @@ export class Swarm {
       .then(answer => {
         log(`Received answer: ${JSON.stringify(answer)} topic=${this._topic} ownId=${this._ownPeerId} remoteId=${remoteId}`);
         if (connection.state !== ConnectionState.INITIAL) {
-          log('Ignoring answer');
+          log('Ignoring answer.');
           return;
         }
 
@@ -228,12 +225,13 @@ export class Swarm {
       .catch(err => {
         this.errors.raise(err);
       });
+
     this._topology.update();
   }
 
   private _createConnection (initiator: boolean, remoteId: PublicKey, sessionId: PublicKey) {
     log(`Create connection topic=${this._topic} remoteId=${remoteId} initiator=${initiator}`);
-    assert(!this._connections.has(remoteId), 'Peer already connected');
+    assert(!this._connections.has(remoteId), 'Peer already connected.');
 
     const connection = new Connection(
       this._topic,
@@ -241,8 +239,8 @@ export class Swarm {
       remoteId,
       sessionId,
       initiator,
-      this._sendSignal,
-      this._protocol({ channel: discoveryKey(this._topic), initiator }),
+      (msg: SignalApi.SignalMessage) => this._signalConnection.signal(msg),
+      this._protocolProvider({ channel: discoveryKey(this._topic), initiator }),
       this._transportFactory
     );
 
@@ -258,12 +256,14 @@ export class Swarm {
 
     void connection.stateChanged.waitFor(s => s === ConnectionState.CLOSED).then(() => {
       log(`Connection closed topic=${this._topic} remoteId=${remoteId} initiator=${initiator}`);
-      // Connection might have been already closed or replace by a different one. Only remove the connection if it has the same session id.
+      // Connection might have been already closed or replace by a different one.
+      // Only remove the connection if it has the same session id.
       if (this._connections.get(remoteId)?.sessionId.equals(sessionId)) {
         this._connections.delete(remoteId);
         this.connectionRemoved.emit(connection);
       }
     });
+
     return connection;
   }
 
@@ -273,6 +273,7 @@ export class Swarm {
     if (!connection) {
       return;
     }
+
     this._connections.delete(peerId);
     await connection.close();
   }

package/src/transport/in-memory-transport.ts

@@ -79,8 +79,8 @@ export class InMemoryTransport implements Transport {
     return this._sessionId;
   }
 
-  signal (msg: SignalApi.SignalMessage): void {
-    // Does nothing.
+  async signal (msg: SignalApi.SignalMessage) {
+    // No-op.
   }
 
   async close (): Promise<void> {