@dxos/network-manager 2.33.5-dev.ebc105f7 → 2.33.5

package/src/network-manager.ts

@@ -15,7 +15,7 @@ import { ConnectionLog } from './connection-log';
 import { InMemorySignalManager, SignalManager, SignalApi, WebsocketSignalManager } from './signal';
 import { Swarm, SwarmMapper } from './swarm';
 import { Topology } from './topology';
-import { createWebRtcTransportFactory, inMemoryTransportFactory } from './transport';
+import { createWebRTCTransportFactory, inMemoryTransportFactory } from './transport';
 
 export type ProtocolProvider = (opts: { channel: Buffer, initiator: boolean}) => Protocol;
 
@@ -37,7 +37,7 @@ export class NetworkManager {
   private readonly _ice?: any[];
   private readonly _swarms = new ComplexMap<PublicKey, Swarm>(key => key.toHex());
   private readonly _maps = new ComplexMap<PublicKey, SwarmMapper>(key => key.toHex());
-  private readonly _signal: SignalManager;
+  private readonly _signalManager: SignalManager;
   private readonly _connectionLog?: ConnectionLog;
 
   public readonly topicsUpdated = new Event<void>();
@@ -47,13 +47,15 @@ export class NetworkManager {
 
     const onOffer = async (message: SignalApi.SignalMessage) =>
       await this._swarms.get(message.topic)?.onOffer(message) ?? { accept: false };
-    this._signal = options.signal
+
+    this._signalManager = options.signal
       ? new WebsocketSignalManager(options.signal, onOffer)
       : new InMemorySignalManager(onOffer);
 
-    this._signal.peerCandidatesChanged.on(([topic, candidates]) =>
-      this._swarms.get(topic)?.onPeerCandidatesChanged(candidates));
-    this._signal.onSignal.on(msg => this._swarms.get(msg.topic)?.onSignal(msg));
+    this._signalManager.peerCandidatesChanged
+      .on(([topic, candidates]) => this._swarms.get(topic)?.onPeerCandidatesChanged(candidates));
+    this._signalManager.onSignal
+      .on(msg => this._swarms.get(msg.topic)?.onSignal(msg));
 
     if (options.log) {
       this._connectionLog = new ConnectionLog();
@@ -61,9 +63,10 @@ export class NetworkManager {
   }
 
   get signal () {
-    return this._signal;
+    return this._signalManager;
   }
 
+  // TODO(burdon): Reconcile with "discoveryKey".
   get topics () {
     return Array.from(this._swarms.keys());
   }
@@ -82,12 +85,12 @@ export class NetworkManager {
 
   joinProtocolSwarm (options: SwarmOptions) {
     // TODO(burdon): Use TS to constrain properties.
-    assert(typeof options === 'object', 'Incorrect arguments format.');
+    assert(typeof options === 'object');
     const { topic, peerId, topology, protocol, presence } = options;
-    assert(PublicKey.isPublicKey(topic), 'Incorrect arguments format.');
-    assert(PublicKey.isPublicKey(peerId), 'Incorrect arguments format.');
-    assert(topology, 'Incorrect arguments format.');
-    assert(typeof protocol === 'function', 'Incorrect arguments format.');
+    assert(PublicKey.isPublicKey(topic));
+    assert(PublicKey.isPublicKey(peerId));
+    assert(topology);
+    assert(typeof protocol === 'function');
 
     log(`Join ${options.topic} as ${options.peerId} with ${options.topology.toString()} topology.`);
     if (this._swarms.has(topic)) {
@@ -95,21 +98,17 @@ export class NetworkManager {
         GreetingCommandPlugin.EXTENSION_NAME, ERR_GREET_ALREADY_CONNECTED_TO_SWARM, `Already connected to swarm ${topic}`);
     }
 
+    // TODO(burdon): Require factory (i.e., don't make InMemorySignalManager by default).
     // TODO(burdon): Bundle common transport related classes.
-    const transportFactory = this._signal instanceof InMemorySignalManager
-      ? inMemoryTransportFactory : createWebRtcTransportFactory({ iceServers: this._ice });
+    const transportFactory = this._signalManager instanceof InMemorySignalManager
+      ? inMemoryTransportFactory : createWebRTCTransportFactory({ iceServers: this._ice });
 
     const swarm = new Swarm(
       topic,
       peerId,
       topology,
       protocol,
-
-      // TODO(burdon): Merge.
-      async offer => this._signal.offer(offer),
-      async msg => this._signal.signal(msg),
-      () => this._signal.lookup(topic),
-
+      this._signalManager,
       transportFactory,
       options.label
     );
@@ -119,7 +118,7 @@ export class NetworkManager {
     });
 
     this._swarms.set(topic, swarm);
-    this._signal.join(topic, peerId);
+    this._signalManager.join(topic, peerId);
     this._maps.set(topic, new SwarmMapper(swarm, presence));
 
     this.topicsUpdated.emit();
@@ -139,7 +138,7 @@ export class NetworkManager {
     const map = this._maps.get(topic)!;
     const swarm = this._swarms.get(topic)!;
 
-    this._signal.leave(topic, swarm.ownPeerId);
+    this._signalManager.leave(topic, swarm.ownPeerId);
 
     map.destroy();
     this._maps.delete(topic);
@@ -168,7 +167,7 @@ export class NetworkManager {
       });
     }
 
-    await this._signal.destroy();
+    await this._signalManager.destroy();
   }
 }
 
@@ -177,6 +176,7 @@ export interface SwarmOptions {
    * Swarm topic.
    */
   topic: PublicKey,
+
   /**
    * This node's peer id.
    */

package/src/signal/in-memory-signal-manager.ts

@@ -8,16 +8,13 @@ import { Event } from '@dxos/async';
 import { PublicKey } from '@dxos/crypto';
 import { ComplexMap, ComplexSet } from '@dxos/util';
 
-import { SignalManager } from './interface';
 import { SignalApi } from './signal-api';
+import { SignalManager } from './signal-manager';
 
 export class InMemorySignalManager implements SignalManager {
   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 (
@@ -32,6 +29,7 @@ export class InMemorySignalManager implements SignalManager {
     if (!state.swarms.has(topic)) {
       state.swarms.set(topic, new ComplexSet(x => x.toHex()));
     }
+
     state.swarms.get(topic)!.add(peerId);
     state.connections.set(peerId, this);
 
@@ -42,6 +40,7 @@ export class InMemorySignalManager implements SignalManager {
     if (!state.swarms.has(topic)) {
       state.swarms.set(topic, new ComplexSet(x => x.toHex()));
     }
+
     state.swarms.get(topic)!.delete(peerId);
   }
 
@@ -54,7 +53,7 @@ export class InMemorySignalManager implements SignalManager {
     return state.connections.get(msg.remoteId)!._onOffer(msg);
   }
 
-  signal (msg: SignalApi.SignalMessage) {
+  async signal (msg: SignalApi.SignalMessage) {
     assert(state.connections.get(msg.remoteId), 'Peer not connected');
     state.connections.get(msg.remoteId)!.onSignal.emit(msg);
   }
@@ -62,10 +61,12 @@ export class InMemorySignalManager implements SignalManager {
   async destroy () {}
 }
 
+// TODO(burdon): Remove global singleton.
 // This is global state for the in-memory signal manager.
 const state = {
   // Mapping from topic to set of peers.
   swarms: new ComplexMap<PublicKey, ComplexSet<PublicKey>>(x => x.toHex()),
+
   // Map of connections for each peer for signaling.
   connections: new ComplexMap<PublicKey, InMemorySignalManager>(x => x.toHex())
 };

package/src/signal/index.ts

@@ -3,7 +3,8 @@
 //
 
 export * from './in-memory-signal-manager';
-export * from './interface';
 export * from './signal-api';
+export * from './signal-client';
+export * from './signal-manager';
 export * from './websocket-rpc';
 export * from './websocket-signal-manager';

package/src/signal/signal-api.ts

@@ -2,235 +2,11 @@
 // Copyright 2020 DXOS.org
 //
 
-import debug from 'debug';
 import { SignalData } from 'simple-peer';
 
-import { Event } from '@dxos/async';
 import { PublicKey } from '@dxos/crypto';
 
-import { WebsocketRpc } from './websocket-rpc';
-
-const log = debug('dxos:network-manager:signal-api');
-
-const DEFAULT_RECONNECT_TIMEOUT = 1000;
-
-/**
- * Establishes a websocket connection to signal server and provides RPC methods.
- */
-export class SignalApi {
-  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
-    });
-  }
-}
+// TODO(burdon): Define message types as protobuf.
 
 export namespace SignalApi {
   export enum State {
@@ -247,19 +23,19 @@ export namespace SignalApi {
     DISCONNECTED = 'DISCONNECTED',
 
     /** Socket was closed. */
-    CLOSED = 'CLOSED',
+    CLOSED = 'CLOSED'
   }
 
-  export interface Status {
-    host: string,
-    state: State,
+  export type Status = {
+    host: string
+    state: State
     error?: string
-    reconnectIn: number,
+    reconnectIn: number
     connectionStarted: number
     lastStateChange: number
   }
 
-  export interface CommandTrace {
+  export type CommandTrace = {
     messageId: string
     host: string
     incoming: boolean
@@ -270,24 +46,15 @@ export namespace SignalApi {
     error?: string
   }
 
-  // TODO(marik-d): Define more concrete types for offer/answer.
-  export interface SignalMessage {
-    id: PublicKey
-    remoteId: PublicKey,
-    topic: PublicKey,
-    sessionId: PublicKey,
-    data: SignalData,
-  }
-
-  export interface OfferMessage {
+  export type SignalMessage = {
     id: PublicKey
-    remoteId: PublicKey,
-    topic: PublicKey,
-    sessionId: PublicKey,
-    data: SignalData,
+    remoteId: PublicKey
+    topic: PublicKey
+    sessionId: PublicKey
+    data: SignalData
   }
 
-  export interface Answer {
+  export type Answer = {
     accept: boolean
   }
 }

package/src/signal/{signal-api.test.ts → signal-client.test.ts}

@@ -12,25 +12,26 @@ import { createTestBroker } from '@dxos/signal';
 import { randomInt } from '@dxos/util';
 
 import { SignalApi } from './signal-api';
+import { SignalClient } from './signal-client';
 
 describe('SignalApi', () => {
   let topic: PublicKey;
   let peer1: PublicKey;
   let peer2: PublicKey;
-  let api: SignalApi;
-  let api2: SignalApi;
+  let api1: SignalClient;
+  let api2: SignalClient;
 
-  let broker: Awaited<ReturnType<typeof createTestBroker>>;
-  const signalApiPort = randomInt(10000, 50000);
-  const signalApiUrl = 'http://0.0.0.0:' + signalApiPort;
+  let broker1: Awaited<ReturnType<typeof createTestBroker>>;
+  const signalApiPort1 = randomInt(10000, 50000);
+  const signalApiUrl1 = 'http://0.0.0.0:' + signalApiPort1;
 
   // code let broker2: ReturnType<typeof createBroker>;
   const signalApiPort2 = randomInt(10000, 50000);
   const signalApiUrl2 = 'http://0.0.0.0:' + signalApiPort2;
 
   before(async () => {
-    broker = await createTestBroker(signalApiPort);
-    // code broker2 = await createTestBroker(signalApiPort2);
+    broker1 = await createTestBroker(signalApiPort1);
+    // broker2 = await createTestBroker(signalApiPort2);
   });
 
   beforeEach(() => {
@@ -41,27 +42,27 @@ describe('SignalApi', () => {
 
   after(async function () {
     this.timeout(0);
-    await api.close();
-    await broker.stop();
+    await api1.close();
+    await broker1.stop();
     // code await broker2.stop();
   });
 
   test('join', async () => {
-    api = new SignalApi(signalApiUrl, (async () => {}) as any, async () => {});
+    api1 = new SignalClient(signalApiUrl1, (async () => {}) as any, async () => {});
 
-    const join = await api.join(topic, peer1);
+    const join = await api1.join(topic, peer1);
     expect(join).toEqual([peer1]);
 
-    const join2 = await api.join(topic, peer2);
+    const join2 = await api1.join(topic, peer2);
     expect(join2).toEqual([peer1, peer2]);
   }).timeout(1_000);
 
   test('offer', async () => {
     const offerMock = mockFn<(msg: SignalApi.SignalMessage) => Promise<SignalApi.Answer>>()
       .resolvesTo({ accept: true });
-    api = new SignalApi(signalApiUrl, offerMock, async () => {});
+    api1 = new SignalClient(signalApiUrl1, offerMock, async () => {});
 
-    await api.join(topic, peer1);
+    await api1.join(topic, peer1);
 
     const offer: SignalApi.SignalMessage = {
       data: { foo: 'bar' } as any,
@@ -70,7 +71,7 @@ describe('SignalApi', () => {
       sessionId: PublicKey.random(),
       topic
     };
-    const offerResult = await api.offer(offer);
+    const offerResult = await api1.offer(offer);
     expect(offerResult).toEqual({ accept: true });
     expect(offerMock).toHaveBeenCalledWith([offer]);
   }).timeout(5_000);
@@ -78,9 +79,9 @@ describe('SignalApi', () => {
   test('signal', async () => {
     const signalMock = mockFn<(msg: SignalApi.SignalMessage) => Promise<void>>()
       .resolvesTo();
-    api = new SignalApi(signalApiUrl, (async () => {}) as any, signalMock);
+    api1 = new SignalClient(signalApiUrl1, (async () => {}) as any, signalMock);
 
-    await api.join(topic, peer1);
+    await api1.join(topic, peer1);
 
     const msg: SignalApi.SignalMessage = {
       id: peer2,
@@ -89,7 +90,7 @@ describe('SignalApi', () => {
       topic,
       data: { foo: 'bar' } as any
     };
-    await api.signal(msg);
+    await api1.signal(msg);
 
     await waitForExpect(() => {
       expect(signalMock).toHaveBeenCalledWith([msg]);
@@ -98,10 +99,10 @@ describe('SignalApi', () => {
 
   test.skip('join across multiple signal servers', async () => {
     // This feature is not implemented yet.
-    api = new SignalApi(signalApiUrl, (async () => {}) as any, async () => {});
-    api2 = new SignalApi(signalApiUrl2, (async () => {}) as any, async () => {});
+    api1 = new SignalClient(signalApiUrl1, (async () => {}) as any, async () => {});
+    api2 = new SignalClient(signalApiUrl2, (async () => {}) as any, async () => {});
 
-    await api.join(topic, peer1);
+    await api1.join(topic, peer1);
     await api2.join(topic, peer2);
 
     await waitForExpect(async () => {
@@ -110,7 +111,7 @@ describe('SignalApi', () => {
     }, 4_000);
 
     await waitForExpect(async () => {
-      const peers = await api.lookup(topic);
+      const peers = await api1.lookup(topic);
       expect(peers.length).toEqual(2);
     }, 4_000);
   }).timeout(5_000);
@@ -122,10 +123,10 @@ describe('SignalApi', () => {
     const signalMock = mockFn<(msg: SignalApi.SignalMessage) => Promise<void>>()
       .resolvesTo();
 
-    api = new SignalApi(signalApiUrl, offerMock, async () => {});
-    api2 = new SignalApi(signalApiUrl2, (async () => {}) as any, signalMock);
+    api1 = new SignalClient(signalApiUrl1, offerMock, async () => {});
+    api2 = new SignalClient(signalApiUrl2, (async () => {}) as any, signalMock);
 
-    await api.join(topic, peer1);
+    await api1.join(topic, peer1);
     await sleep(3000);
     await api2.join(topic, peer2);
 
@@ -146,7 +147,7 @@ describe('SignalApi', () => {
       topic,
       data: { foo: 'bar' } as any
     };
-    await api.signal(msg);
+    await api1.signal(msg);
 
     await waitForExpect(() => {
       expect(signalMock).toHaveBeenCalledWith([msg]);