@dxos/network-manager 2.33.9-dev.7d11f506 → 2.33.9-dev.9bbef4e2

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

@@ -6,164 +6,144 @@ import { expect, mockFn } from 'earljs';
 import { it as test, describe } from 'mocha';
 import waitForExpect from 'wait-for-expect';
 
-import { Awaited, sleep } from '@dxos/async';
+import { sleep } from '@dxos/async';
 import { PublicKey } from '@dxos/protocols';
-import { createTestBroker } from '@dxos/signal';
-import { randomInt } from '@dxos/util';
+import { createTestBroker, TestBroker } from '@dxos/signal';
+import { afterTest } from '@dxos/testutils';
 
-import { Answer, Message } from '../proto/gen/dxos/mesh/signal';
+import { SignalMessage } from '../proto/gen/dxos/mesh/signalMessage';
 import { SignalClient } from './signal-client';
 
-describe('SignalApi', () => {
-  let topic: PublicKey;
-  let peer1: PublicKey;
-  let peer2: PublicKey;
-  let api1: SignalClient;
-  let api2: SignalClient;
+describe('SignalClient', () => {
+  let broker1: TestBroker;
 
-  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;
+  let broker2: TestBroker;
 
   before(async () => {
-    broker1 = await createTestBroker(signalApiPort1);
-    // broker2 = await createTestBroker(signalApiPort2);
-  });
-
-  beforeEach(() => {
-    topic = PublicKey.random();
-    peer1 = PublicKey.random();
-    peer2 = PublicKey.random();
+    broker1 = await createTestBroker();
+    // broker2 = await await createTestBroker(signalApiPort2);
   });
 
-  after(async function () {
-    this.timeout(0);
-    await api1.close();
-    await broker1.stop();
+  after(() => {
+    broker1.stop();
     // code await broker2.stop();
   });
 
   test('message between 2 clients', async () => {
-    const signalMock1 = mockFn<(msg: Message) => Promise<void>>()
+    const topic = PublicKey.random();
+    const peer1 = PublicKey.random();
+    const peer2 = PublicKey.random();
+    const signalMock1 = mockFn<(msg: SignalMessage) => Promise<void>>()
       .resolvesTo();
-    api1 = new SignalClient(signalApiUrl1, (async () => {}) as any, signalMock1);
-    api2 = new SignalClient(signalApiUrl1, (async () => {}) as any, (async () => {}) as any);
+    const api1 = new SignalClient(broker1.url(), signalMock1);
+    afterTest(() => api1.close());
+    const api2 = new SignalClient(broker1.url(), (async () => {}) as any);
+    afterTest(() => api2.close());
 
     await api1.join(topic, peer1);
     await api2.join(topic, peer2);
 
-    const msg: Message = {
+    const msg: SignalMessage = {
       id: peer2,
       remoteId: peer1,
       sessionId: PublicKey.random(),
       topic,
-      data: { signal: { json: "foo: 'bar'" } }
+      data: { signal: { json: JSON.stringify({ 'asd': 'asd' }) } }
     };
     await api2.signal(msg);
-
     await waitForExpect(() => {
       expect(signalMock1).toHaveBeenCalledWith([msg]);
     }, 4_000);
-  }).timeout(5_000);
+  }).timeout(500);
 
   test('join', async () => {
-    api1 = new SignalClient(signalApiUrl1, (async () => {}) as any, async () => {});
+    const topic = PublicKey.random();
+    const peer1 = PublicKey.random();
+    const peer2 = PublicKey.random();
+    const api1 = new SignalClient(broker1.url(), async () => {});
+    afterTest(() => api1.close());
+    const api2 = new SignalClient(broker1.url(), async () => {});
+    afterTest(() => api2.close());
 
-    const join = await api1.join(topic, peer1);
-    expect(join).toEqual([peer1]);
-
-    const join2 = await api1.join(topic, peer2);
-    expect(join2).toEqual([peer1, peer2]);
-  }).timeout(1_000);
-
-  test('offer', async () => {
-    const offerMock = mockFn<(msg: Message) => Promise<Answer>>()
-      .resolvesTo({ accept: true });
-    api1 = new SignalClient(signalApiUrl1, offerMock, async () => {});
+    const promise1 = api1.swarmEvent.waitFor(([, swarmEvent]) => !!swarmEvent.peerAvailable && peer2.equals(swarmEvent.peerAvailable.peer));
+    const promise2 = api2.swarmEvent.waitFor(([, swarmEvent]) => !!swarmEvent.peerAvailable && peer1.equals(swarmEvent.peerAvailable.peer));
 
     await api1.join(topic, peer1);
+    await api2.join(topic, peer2);
 
-    const offer: Message = {
-      data: { offer: {} },
-      id: peer2,
-      remoteId: peer1,
-      sessionId: PublicKey.random(),
-      topic
-    };
-    const offerResult = await api1.offer(offer);
-    expect(offerResult).toEqual({ accept: true });
-    expect(offerMock).toHaveBeenCalledWith([offer]);
-  }).timeout(5_000);
+    await promise1;
+    await promise2;
+  }).timeout(500);
 
-  test('signal', async () => {
-    const signalMock = mockFn<(msg: Message) => Promise<void>>()
+  test('signal to self', async () => {
+    const topic = PublicKey.random();
+    const peer1 = PublicKey.random();
+    const peer2 = PublicKey.random();
+    const signalMock = mockFn<(msg: SignalMessage) => Promise<void>>()
       .resolvesTo();
-    api1 = new SignalClient(signalApiUrl1, (async () => {}) as any, signalMock);
+    const api1 = new SignalClient(broker1.url(), signalMock);
+    afterTest(() => api1.close());
 
     await api1.join(topic, peer1);
 
-    const msg: Message = {
+    const msg: SignalMessage = {
       id: peer2,
       remoteId: peer1,
       sessionId: PublicKey.random(),
       topic,
-      data: { signal: { json: 'bar' } }
+      data: { signal: { json: JSON.stringify({ 'asd': 'asd' }) } }
     };
     await api1.signal(msg);
 
     await waitForExpect(() => {
       expect(signalMock).toHaveBeenCalledWith([msg]);
     }, 4_000);
-  }).timeout(5_000);
+  }).timeout(500);
 
   test.skip('join across multiple signal servers', async () => {
+    const topic = PublicKey.random();
+    const peer1 = PublicKey.random();
+    const peer2 = PublicKey.random();
     // This feature is not implemented yet.
-    api1 = new SignalClient(signalApiUrl1, (async () => {}) as any, async () => {});
-    api2 = new SignalClient(signalApiUrl2, (async () => {}) as any, async () => {});
+    const api1 = new SignalClient(broker1.url(), async () => {});
+    afterTest(() => api1.close());
+    const api2 = new SignalClient(broker2.url(), async () => {});
+    afterTest(() => api2.close());
 
     await api1.join(topic, peer1);
     await api2.join(topic, peer2);
 
-    await waitForExpect(async () => {
-      const peers = await api2.lookup(topic);
-      expect(peers.length).toEqual(2);
-    }, 4_000);
+    // await waitForExpect(async () => {
+    //   const peers = await api2.lookup(topic);
+    //   expect(peers.length).toEqual(2);
+    // }, 4_000);
 
-    await waitForExpect(async () => {
-      const peers = await api1.lookup(topic);
-      expect(peers.length).toEqual(2);
-    }, 4_000);
+    // await waitForExpect(async () => {
+    //   const peers = await api1.lookup(topic);
+    //   expect(peers.length).toEqual(2);
+    // }, 4_000);
   }).timeout(5_000);
 
   // Skip because communication between signal servers is not yet implemented.
   test.skip('newly joined peer can receive signals from other signal servers', async () => {
-    const offerMock = mockFn<(msg: Message) => Promise<Answer>>()
-      .resolvesTo({ accept: true });
-    const signalMock = mockFn<(msg: Message) => Promise<void>>()
+    const topic = PublicKey.random();
+    const peer1 = PublicKey.random();
+    const peer2 = PublicKey.random();
+    const signalMock = mockFn<(msg: SignalMessage) => Promise<void>>()
       .resolvesTo();
 
-    api1 = new SignalClient(signalApiUrl1, offerMock, async () => {});
-    api2 = new SignalClient(signalApiUrl2, (async () => {}) as any, signalMock);
+    const api1 = new SignalClient(broker1.url(), async () => {});
+    afterTest(() => api1.close());
+    const api2 = new SignalClient(broker2.url(), signalMock);
+    afterTest(() => api2.close());
 
     await api1.join(topic, peer1);
     await sleep(3000);
     await api2.join(topic, peer2);
 
     const sessionId = PublicKey.random();
-    const answer = await api2.offer({
-      remoteId: peer1,
-      id: peer2,
-      topic,
-      sessionId,
-      data: { offer: {} }
-    });
-    expect(answer).toEqual({ accept: true });
 
-    const msg: Message = {
+    const msg: SignalMessage = {
       id: peer2,
       remoteId: peer1,
       sessionId,
@@ -176,4 +156,4 @@ describe('SignalApi', () => {
       expect(signalMock).toHaveBeenCalledWith([msg]);
     }, 4_000);
   }).timeout(5_000);
-}).timeout(10_000);
+});

package/src/signal/signal-client.ts

@@ -2,24 +2,55 @@
 // Copyright 2020 DXOS.org
 //
 
+import assert from 'assert';
 import debug from 'debug';
 
-import { Event } from '@dxos/async';
+import { Event, synchronized } from '@dxos/async';
+import { Any, Stream } from '@dxos/codec-protobuf';
 import { PublicKey } from '@dxos/protocols';
+import { ComplexMap, SubscriptionGroup } from '@dxos/util';
 
-import { Answer, Message } from '../proto/gen/dxos/mesh/signal';
+import { schema } from '../proto/gen';
+import { Message, SwarmEvent } from '../proto/gen/dxos/mesh/signal';
+import { SignalMessage } from '../proto/gen/dxos/mesh/signalMessage';
 import { SignalApi } from './signal-api';
-import { WebsocketRpc } from './websocket-rpc';
+import { SignalRPCClient } from './signal-rpc-client';
 
 const log = debug('dxos:network-manager:signal-client');
 
 const DEFAULT_RECONNECT_TIMEOUT = 1000;
 
+enum State {
+  /** Connection is being established. */
+  CONNECTING = 'CONNECTING',
+
+  /** Connection is being re-established. */
+  RE_CONNECTING = 'RE_CONNECTING',
+
+  /** Connected. */
+  CONNECTED = 'CONNECTED',
+
+  /** Server terminated the connection. Socket will be reconnected. */
+  DISCONNECTED = 'DISCONNECTED',
+
+  /** Socket was closed. */
+  CLOSED = 'CLOSED'
+}
+
+export type Status = {
+  host: string
+  state: State
+  error?: string
+  reconnectIn: number
+  connectionStarted: number
+  lastStateChange: number
+}
+
 /**
  * Establishes a websocket connection to signal server and provides RPC methods.
  */
 export class SignalClient {
-  private _state = SignalApi.State.CONNECTING;
+  private _state = State.CONNECTING;
 
   private _lastError?: Error;
 
@@ -40,28 +71,29 @@ export class SignalClient {
 
   private _reconnectIntervalId?: NodeJS.Timeout;
 
-  private _client!: WebsocketRpc;
+  private _client!: SignalRPCClient;
 
-  private _clientCleanup: (() => void)[] = [];
+  private _cleanupSubscriptions = new SubscriptionGroup();
+  readonly statusChanged = new Event<Status>();
 
-  readonly statusChanged = new Event<SignalApi.Status>();
   readonly commandTrace = new Event<SignalApi.CommandTrace>();
+  readonly swarmEvent = new Event<[topic: PublicKey, swarmEvent: SwarmEvent]>();
 
+  private readonly _swarmStreams = new ComplexMap<PublicKey, Stream<SwarmEvent>>(key => key.toHex());
+  private readonly _messageStreams = new ComplexMap<PublicKey, Stream<Message>>(key => key.toHex());
   /**
    * @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: Message) => Promise<Answer>,
-    private readonly _onSignal: (message: Message) => Promise<void>
+    private readonly _onSignal: (message: SignalMessage) => Promise<void>
   ) {
-    this._setState(SignalApi.State.CONNECTING);
+    this._setState(State.CONNECTING);
     this._createClient();
   }
 
-  private _setState (newState: SignalApi.State) {
+  private _setState (newState: State) {
     this._state = newState;
     this._lastStateChange = Date.now();
     log(`Signal state changed ${JSON.stringify(this.getStatus())}`);
@@ -71,107 +103,88 @@ export class SignalClient {
   private _createClient () {
     this._connectionStarted = Date.now();
     try {
-      this._client = new WebsocketRpc(this._host);
+      this._client = new SignalRPCClient(this._host);
     } catch (error: any) {
-      if (this._state === SignalApi.State.RE_CONNECTING) {
+      if (this._state === State.RE_CONNECTING) {
         this._reconnectAfter *= 2;
       }
 
       this._lastError = error;
-      this._setState(SignalApi.State.DISCONNECTED);
+      this._setState(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: Message) => 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._cleanupSubscriptions.push(this._client.connected.on(() => {
       this._lastError = undefined;
       this._reconnectAfter = DEFAULT_RECONNECT_TIMEOUT;
-      this._setState(SignalApi.State.CONNECTED);
+      this._setState(State.CONNECTED);
     }));
 
-    this._clientCleanup.push(this._client.error.on(error => {
+    this._cleanupSubscriptions.push(this._client.error.on(error => {
       log(`Socket error: ${error.message}`);
-      if (this._state === SignalApi.State.CLOSED) {
+      if (this._state === State.CLOSED) {
         return;
       }
 
-      if (this._state === SignalApi.State.RE_CONNECTING) {
+      if (this._state === State.RE_CONNECTING) {
         this._reconnectAfter *= 2;
       }
 
       this._lastError = error;
-      this._setState(SignalApi.State.DISCONNECTED);
+      this._setState(State.DISCONNECTED);
 
       this._reconnect();
     }));
 
-    this._clientCleanup.push(this._client.disconnected.on(() => {
+    this._cleanupSubscriptions.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) {
+      if (this._state !== State.CONNECTING && this._state !== State.RE_CONNECTING) {
         return;
       }
 
-      if (this._state === SignalApi.State.RE_CONNECTING) {
+      if (this._state === State.RE_CONNECTING) {
         this._reconnectAfter *= 2;
       }
 
-      this._setState(SignalApi.State.DISCONNECTED);
+      this._setState(State.DISCONNECTED);
       this._reconnect();
     }));
-
-    this._clientCleanup.push(this._client.commandTrace.on(trace => this.commandTrace.emit(trace)));
   }
 
   private _reconnect () {
+    log(`Reconnecting in ${this._reconnectAfter}ms`);
     if (this._reconnectIntervalId !== undefined) {
       console.error('Signal api already reconnecting.');
       return;
     }
-    if (this._state === SignalApi.State.CLOSED) {
+    if (this._state === State.CLOSED) {
       return;
     }
 
     this._reconnectIntervalId = setTimeout(() => {
       this._reconnectIntervalId = undefined;
 
-      this._clientCleanup.forEach(cb => cb());
-      this._clientCleanup = [];
+      this._cleanupSubscriptions.unsubscribe();
 
       // Close client if it wasn't already closed.
       this._client.close().catch(() => {});
 
-      this._setState(SignalApi.State.RE_CONNECTING);
+      this._setState(State.RE_CONNECTING);
       this._createClient();
     }, this._reconnectAfter);
   }
 
   async close () {
-    this._clientCleanup.forEach(cb => cb());
-    this._clientCleanup = [];
+    this._cleanupSubscriptions.unsubscribe();
 
     if (this._reconnectIntervalId !== undefined) {
       clearTimeout(this._reconnectIntervalId);
     }
 
     await this._client.close();
-    this._setState(SignalApi.State.CLOSED);
+    this._setState(State.CLOSED);
+    log('Closed.');
   }
 
   getStatus (): SignalApi.Status {
@@ -185,52 +198,72 @@ export class SignalClient {
     };
   }
 
-  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 join (topic: PublicKey, peerId: PublicKey): Promise<void> {
+    log(`Join: topic=${topic} peerId=${peerId}`);
+    await this._subscribeMessages(peerId);
+    await this._subscribeSwarmEvents(topic, peerId);
   }
 
   async leave (topic: PublicKey, peerId: PublicKey): Promise<void> {
-    await this._client.call('leave', {
-      id: peerId.asBuffer(),
-      topic: topic.asBuffer()
-    });
+    log(`Leave: topic=${topic} peerId=${peerId}`);
+
+    this._swarmStreams.get(topic)?.close();
+    this._swarmStreams.delete(topic);
+
+    this._messageStreams.get(topic)?.close();
+    this._messageStreams.delete(topic);
   }
 
-  async lookup (topic: PublicKey): Promise<PublicKey[]> {
-    const peers: Buffer[] = await this._client.call('lookup', {
-      topic: topic.asBuffer()
-    });
-    return peers.map(id => PublicKey.from(id));
+  async signal (message: SignalMessage): Promise<void> {
+    const payload: Any = {
+      type_url: 'dxos.mesh.signalMessage.SignalMessage',
+      value: schema.getCodecForType('dxos.mesh.signalMessage.SignalMessage').encode(message)
+    };
+    return this._client.sendMessage(message.id, message.remoteId, payload);
   }
 
-  /**
-   * Routes an offer to the other peer's _onOffer callback.
-   * @returns Other peer's _onOffer callback return value.
-   */
-  async offer (msg: Message): Promise<Answer> {
-    return this._client.call('offer', {
-      id: msg.id?.asBuffer(),
-      remoteId: msg.remoteId?.asBuffer(),
-      topic: msg.topic?.asBuffer(),
-      sessionId: msg.sessionId?.asBuffer(),
-      data: msg.data
+  @synchronized
+  private async _subscribeSwarmEvents (topic: PublicKey, peerId: PublicKey): Promise<void> {
+    assert(!this._swarmStreams.has(topic));
+    const swarmStream = await this._client.join(topic, peerId);
+    // Subscribing to swarm events.
+    // TODO(mykola): What happens when the swarm stream is closed? Maybe send leave event for each peer?
+    swarmStream.subscribe((swarmEvent: SwarmEvent) => {
+      this.swarmEvent.emit([topic, swarmEvent]);
+    });
+
+    // Saving swarm stream.
+    this._swarmStreams.set(topic, swarmStream);
+
+    this._cleanupSubscriptions.push(() => {
+      swarmStream.close();
+      this._swarmStreams.delete(topic);
     });
   }
 
-  /**
-   * Routes an offer to the other peer's _onSignal callback.
-   */
-  async signal (payload: Message): 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
+  private async _subscribeMessages (peerId: PublicKey) {
+    // Subscribing to messages.
+    const messageStream = await this._client.receiveMessages(peerId);
+    messageStream.subscribe(async (message: Message) => {
+      if (message.payload.type_url === 'dxos.mesh.signalMessage.SignalMessage') {
+        const signalMessage = schema.getCodecForType('dxos.mesh.signalMessage.SignalMessage').decode(message.payload.value);
+        log('Message received: ' + JSON.stringify(signalMessage));
+        assert(signalMessage.remoteId.equals(peerId));
+        await this._onSignal(signalMessage);
+      } else {
+        log('Unknown message type: ' + message.payload.type_url);
+      }
+    });
+
+    // Saving message stream.
+    if (!this._messageStreams.has(peerId)) {
+      this._messageStreams.set(peerId, messageStream);
+    }
+
+    this._cleanupSubscriptions.push(() => {
+      messageStream.close();
+      this._messageStreams.delete(peerId);
     });
   }
+
 }