@dxos/network-manager 2.33.8-dev.c77ba621 → 2.33.9-dev.2637427f

package/src/signal/message-router.test.ts

@@ -0,0 +1,334 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import { expect, mockFn } from 'earljs';
+import { it as test, describe } from 'mocha';
+import waitForExpect from 'wait-for-expect';
+
+import { Awaited } from '@dxos/async';
+import { PublicKey } from '@dxos/protocols';
+import { createTestBroker } from '@dxos/signal';
+import { afterTest } from '@dxos/testutils';
+import { randomInt } from '@dxos/util';
+
+import { Answer, Message } from '../proto/gen/dxos/mesh/signal';
+import { MessageRouter } from './message-router';
+import { SignalClient } from './signal-client';
+
+describe('MessageRouter', () => {
+  let topic: PublicKey;
+  let peer1: PublicKey;
+  let peer2: PublicKey;
+
+  let broker1: Awaited<ReturnType<typeof createTestBroker>>;
+  const signalApiPort1 = randomInt(10000, 50000);
+  const signalApiUrl1 = 'http://0.0.0.0:' + signalApiPort1;
+
+  before(async () => {
+    broker1 = await createTestBroker(signalApiPort1);
+  });
+
+  beforeEach(() => {
+    topic = PublicKey.random();
+    peer1 = PublicKey.random();
+    peer2 = PublicKey.random();
+  });
+
+  after(async function () {
+    this.timeout(0);
+    await broker1.stop();
+  });
+
+  const createSignalClientAndMessageRouter = async ({
+    signalApiUrl,
+    onSignal = (async () => { }) as any,
+    onOffer = async () => ({ accept: true })
+  }: {
+    signalApiUrl: string;
+    onSignal?: (msg: Message) => Promise<void>;
+    onOffer?: (msg: Message) => Promise<Answer>;
+  }) => {
+
+    // eslint-disable-next-line prefer-const
+    let api: SignalClient;
+    const router: MessageRouter = new MessageRouter({
+      // todo(mykola): added catch to avoid not finished request.
+      sendMessage: (msg: Message) => api.signal(msg).catch((_) => { }),
+      onSignal: onSignal,
+      onOffer: onOffer
+    });
+    afterTest(() => router.destroy());
+
+    api = new SignalClient(
+      signalApiUrl,
+      (async () => {}) as any,
+      async (msg: Message) => router.receiveMessage(msg)
+    );
+
+    afterTest(() => api.close());
+    return {
+      api,
+      router
+    };
+  };
+
+  test('signaling between 2 clients', async () => {
+    const signalMock1 = mockFn<(msg: Message) => Promise<void>>().resolvesTo();
+    const { api: api1 } = await createSignalClientAndMessageRouter({ signalApiUrl: signalApiUrl1, onSignal: signalMock1 });
+    const { api: api2, router: router2 } = await createSignalClientAndMessageRouter({ signalApiUrl: signalApiUrl1 });
+
+    await api1.join(topic, peer1);
+    await api2.join(topic, peer2);
+
+    const msg: Message = {
+      id: peer2,
+      remoteId: peer1,
+      sessionId: PublicKey.random(),
+      topic,
+      data: { signal: { json: '{"asd": "asd"}' } }
+    };
+    await router2.signal(msg);
+
+    await waitForExpect(() => {
+      expect(signalMock1).toHaveBeenCalledWith([msg]);
+    }, 4_000);
+  }).timeout(5_000);
+
+  test('offer/answer', async () => {
+    const { api: api1, router: router1 } = await createSignalClientAndMessageRouter(
+      {
+        signalApiUrl: signalApiUrl1,
+        onSignal: (async () => { }) as any,
+        onOffer:
+          async () => ({ accept: true })
+      });
+    const { api: api2 } = await createSignalClientAndMessageRouter(
+      {
+        signalApiUrl: signalApiUrl1,
+        onSignal: (async () => { }) as any,
+        onOffer:
+          async () => ({ accept: true })
+      });
+
+    await api1.join(topic, peer1);
+    await api2.join(topic, peer2);
+
+    const answer = await router1.offer({
+      id: peer1,
+      remoteId: peer2,
+      sessionId: PublicKey.random(),
+      topic,
+      data: { offer: { } }
+    });
+    expect(answer.accept).toEqual(true);
+  }).timeout(5_000);
+
+  test('signaling between 3 clients', async () => {
+    const signalMock1 = mockFn<(msg: Message) => Promise<void>>().resolvesTo();
+    const { api: api1, router: router1 } = await createSignalClientAndMessageRouter(
+      {
+        signalApiUrl: signalApiUrl1,
+        onSignal: signalMock1,
+        onOffer:
+          async () => ({ accept: true })
+      });
+    const signalMock2 = mockFn<(msg: Message) => Promise<void>>().resolvesTo();
+    const { api: api2, router: router2 } = await createSignalClientAndMessageRouter(
+      {
+        signalApiUrl: signalApiUrl1,
+        onSignal: signalMock2,
+        onOffer:
+          async () => ({ accept: true })
+      });
+    const signalMock3 = mockFn<(msg: Message) => Promise<void>>().resolvesTo();
+    const { api: api3, router: router3 } = await createSignalClientAndMessageRouter(
+      {
+        signalApiUrl: signalApiUrl1,
+        onSignal: signalMock3,
+        onOffer:
+          async () => ({ accept: true })
+      });
+
+    await api1.join(topic, peer1);
+    await api2.join(topic, peer2);
+    const peer3 = PublicKey.random();
+    await api3.join(topic, peer3);
+
+    // sending signal from peer1 to peer3.
+    const msg1to3: Message = {
+      id: peer1,
+      remoteId: peer3,
+      sessionId: PublicKey.random(),
+      topic,
+      data: { signal: { json: '1to3' } }
+    };
+    await router1.signal(msg1to3);
+    await waitForExpect(() => {
+      expect(signalMock3).toHaveBeenCalledWith([msg1to3]);
+    }, 4_000);
+
+    // sending signal from peer2 to peer3.
+    const msg2to3: Message = {
+      id: peer2,
+      remoteId: peer3,
+      sessionId: PublicKey.random(),
+      topic,
+      data: { signal: { json: '2to3' } }
+    };
+    await router2.signal(msg2to3);
+    await waitForExpect(() => {
+      expect(signalMock3).toHaveBeenCalledWith([msg2to3]);
+    }, 4_000);
+
+    // sending signal from peer3 to peer1.
+    const msg3to1: Message = {
+      id: peer3,
+      remoteId: peer1,
+      sessionId: PublicKey.random(),
+      topic,
+      data: { signal: { json: '3to1' } }
+    };
+    await router3.signal(msg3to1);
+    await waitForExpect(() => {
+      expect(signalMock1).toHaveBeenCalledWith([msg3to1]);
+    }, 4_000);
+  }).timeout(5_000);
+
+  test('two offers', async () => {
+    const { api: api1, router: router1 } = await createSignalClientAndMessageRouter(
+      {
+        signalApiUrl: signalApiUrl1,
+        onSignal: (async () => { }) as any,
+        onOffer:
+          async () => ({ accept: true })
+      });
+    const { api: api2, router: router2 } = await createSignalClientAndMessageRouter(
+      {
+        signalApiUrl: signalApiUrl1,
+        onSignal: (async () => { }) as any,
+        onOffer:
+          async () => ({ accept: true })
+      });
+
+    await api1.join(topic, peer1);
+    await api2.join(topic, peer2);
+
+    // sending offer from peer1 to peer2.
+    const answer1 = await router1.offer({
+      id: peer1,
+      remoteId: peer2,
+      sessionId: PublicKey.random(),
+      topic,
+      data: { offer: {} }
+    });
+    expect(answer1.accept).toEqual(true);
+
+    // sending offer from peer2 to peer1.
+    const answer2 = await router2.offer({
+      id: peer2,
+      remoteId: peer1,
+      sessionId: PublicKey.random(),
+      topic,
+      data: { offer: {} }
+    });
+    expect(answer2.accept).toEqual(true);
+  }).timeout(5_000);
+
+  describe('Reliability', () => {
+    const setup = ({
+      onSignal1 = async () => { },
+      onSignal2 = async () => { },
+      // Imitates signal network disruptions (e. g. message doubling, ).
+      messageDisruption = msg => [msg]
+    }: {
+      onSignal1?: (msg: Message) => Promise<void>;
+      onSignal2?: (msg: Message) => Promise<void>;
+      messageDisruption?: (msg: Message) => Message[];
+    }): {mr1: MessageRouter; mr2: MessageRouter} => {
+
+      const mr1: MessageRouter = new MessageRouter({
+        sendMessage: async msg => messageDisruption(msg).forEach(msg => mr2.receiveMessage(msg)),
+        onOffer: async () => ({ accept: true }),
+        onSignal: onSignal1
+      });
+      afterTest(() => mr1.destroy());
+
+      const mr2: MessageRouter = new MessageRouter({
+        sendMessage: async msg => messageDisruption(msg).forEach(msg => mr1.receiveMessage(msg)),
+        onOffer: async () => ({ accept: true }),
+        onSignal: onSignal2
+      });
+      afterTest(() => mr1.destroy());
+
+      return { mr1, mr2 };
+    };
+
+    test('signaling with non reliable connection', async () => {
+      // Simulate unreliable connection.
+      // Only each 3rd message is sent.
+      let i = 0;
+      const unreliableConnection = (msg: Message): Message[] => {
+        i++;
+        if (i % 3 !== 0) {
+          return [msg];
+        }
+        return [];
+      };
+
+      const received: Message[] = [];
+      const signalMock1 = async (msg: Message) => {
+        received.push(msg);
+      };
+
+      const { mr2 } = await setup({
+        onSignal1: signalMock1,
+        messageDisruption: unreliableConnection
+      });
+
+      // Sending 3 messages.
+      // Setup sends messages directly to between. So we don`t need to specify any ids.
+      Array(3).fill(0).forEach(async () => {
+        await mr2.signal({
+          id: PublicKey.random(),
+          remoteId: PublicKey.random(),
+          sessionId: PublicKey.random(),
+          topic: PublicKey.random(),
+          data: { signal: { json: 'asd' } }
+        });
+      });
+      // expect to receive 3 messages.
+      await waitForExpect(() => {
+        expect(received.length).toEqual(3);
+      }, 4_000);
+    }).timeout(5_000);
+
+    test('ignoring doubled messages', async () => {
+      // Message got doubled going through signal network.
+      const doublingMessage = (msg: Message) => [msg, msg];
+
+      const received: Message[] = [];
+      const signalMock1 = async (msg: Message) => {
+        received.push(msg);
+      };
+
+      const { mr2 } = setup({
+        onSignal1: signalMock1,
+        messageDisruption: doublingMessage
+      });
+
+      // sending message.
+      await mr2.signal({
+        id: PublicKey.random(),
+        remoteId: PublicKey.random(),
+        sessionId: PublicKey.random(),
+        topic: PublicKey.random(),
+        data: { signal: { json: 'asd' } }
+      });
+      // expect to receive 1 message.
+      await waitForExpect(() => {
+        expect(received.length).toEqual(1);
+      }, 4_000);
+    }).timeout(5_000);
+  });
+});

package/src/signal/message-router.ts

@@ -0,0 +1,178 @@
+//
+// Copyright 2020 DXOS.org
+//
+
+import assert from 'assert';
+import debug from 'debug';
+
+import { PublicKey } from '@dxos/protocols';
+import { ComplexMap, ComplexSet, exponentialBackoffInterval, SubscriptionGroup } from '@dxos/util';
+
+import { Answer, Message } from '../proto/gen/dxos/mesh/signal';
+import { SignalMessaging } from './signal-manager';
+
+interface OfferRecord {
+  resolve: (answer: Answer) => void;
+  reject: (error?: Error) => void;
+}
+
+interface MessageRouterOptions {
+  onSignal?: (message: Message) => Promise<void>;
+  sendMessage?: (message: Message) => Promise<void>;
+  onOffer?: (message: Message) => Promise<Answer>;
+  retryDelay?: number;
+  timeout?: number;
+}
+
+const log = debug('dxos:network-manager:message-router');
+/**
+ * Adds offer/answer RPC and reliable messaging.
+ */
+// TODO(mykola): https://github.com/dxos/protocols/issues/1316
+export class MessageRouter implements SignalMessaging {
+  private readonly _offerRecords: ComplexMap<PublicKey, OfferRecord> = new ComplexMap(key => key.toHex());
+  private readonly _onSignal: (message: Message) => Promise<void>;
+  private readonly _sendMessage: (message: Message) => Promise<void>;
+  private readonly _onOffer: (message: Message) => Promise<Answer>;
+
+  private readonly _onAckCallbacks = new ComplexMap<PublicKey, () => void>(key => key.toHex());
+  private readonly _receivedMessages = new ComplexSet<PublicKey>(key => key.toHex());
+  private readonly _retryDelay: number;
+  private readonly _timeout: number;
+
+  private readonly _subscriptions = new SubscriptionGroup();
+
+  constructor ({
+    sendMessage,
+    onSignal,
+    onOffer,
+    retryDelay = 100,
+    timeout = 3000
+  }: MessageRouterOptions = {}) {
+    assert(sendMessage);
+    this._sendMessage = sendMessage;
+    assert(onSignal);
+    this._onSignal = onSignal;
+    assert(onOffer);
+    this._onOffer = onOffer;
+    this._retryDelay = retryDelay;
+    this._timeout = timeout;
+  }
+
+  async receiveMessage (message: Message): Promise<void> {
+    log(`receive message: ${JSON.stringify(message)}`);
+    if (!message.data?.ack) {
+      if (this._receivedMessages.has(message.messageId!)) {
+        return;
+      }
+
+      this._receivedMessages.add(message.messageId!);
+      await this._sendAcknowledgement(message);
+    }
+
+    if (message.data?.offer) {
+      await this._handleOffer(message);
+    } else if (message.data?.answer) {
+      await this._resolveAnswers(message);
+    } else if (message.data?.signal) {
+      await this._handleSignal(message);
+    } else if (message.data?.ack) {
+      await this._handleAcknowledgement(message);
+    }
+  }
+
+  async signal (message: Message): Promise<void> {
+    assert(message.data?.signal);
+    await this._sendReliableMessage(message);
+  }
+
+  async offer (message: Message): Promise<Answer> {
+    message.messageId = PublicKey.random();
+    const promise = new Promise<Answer>((resolve, reject) => {
+      this._offerRecords.set(message.messageId!, { resolve, reject });
+      return this._sendReliableMessage(message);
+    });
+    return promise;
+  }
+
+  private async _sendReliableMessage (message: Message): Promise<PublicKey> {
+    // Setting unique messageId if it not specified yet.
+    message.messageId = message.messageId ?? PublicKey.random();
+    log(`sent message: ${JSON.stringify(message)}`);
+
+    // Setting retry interval if signal was not acknowledged.
+    const cancelRetry = exponentialBackoffInterval(async () => {
+      log(`retrying message: ${JSON.stringify(message)}`);
+      await this._sendMessage(message);
+    }, this._retryDelay);
+
+    const timeout = setTimeout(() => {
+      log('Signal was not delivered!');
+      this._onAckCallbacks.delete(message.messageId!);
+      cancelRetry();
+    }, this._timeout);
+
+    assert(!this._onAckCallbacks.has(message.messageId!));
+    this._onAckCallbacks.set(message.messageId, () => {
+      this._onAckCallbacks.delete(message.messageId!);
+      cancelRetry();
+      clearTimeout(timeout);
+    });
+    this._subscriptions.push(cancelRetry);
+    this._subscriptions.push(() => clearTimeout(timeout));
+
+    await this._sendMessage(message);
+    return message.messageId;
+  }
+
+  private async _resolveAnswers (message: Message): Promise<void> {
+    assert(message.data?.answer?.offerMessageId, 'No offerMessageId');
+    const offerRecord = this._offerRecords.get(message.data.answer.offerMessageId);
+    if (offerRecord) {
+      this._offerRecords.delete(message.data.answer.offerMessageId);
+      assert(message.data?.answer, 'No Answer');
+      log(`resolving answer with ${message.data.answer}`);
+      offerRecord.resolve(message.data.answer);
+    }
+  }
+
+  private async _handleOffer (message: Message): Promise<void> {
+    const answer = await this._onOffer(message);
+    answer.offerMessageId = message.messageId;
+    const answerMessage: Message = {
+      id: message.remoteId,
+      remoteId: message.id,
+      topic: message.topic,
+      sessionId: message.sessionId,
+      data: { answer }
+    };
+    await this._sendReliableMessage(answerMessage);
+  }
+
+  private async _handleSignal (message: Message): Promise<void> {
+    assert(message.messageId);
+    await this._onSignal(message);
+  }
+
+  private async _handleAcknowledgement (message: Message): Promise<void> {
+    assert(message.data?.ack?.messageId);
+    this._onAckCallbacks.get(message.data.ack.messageId)?.();
+  }
+
+  private async _sendAcknowledgement (message: Message): Promise<void> {
+    assert(message.messageId);
+    const ackMessage = {
+      id: message.remoteId,
+      remoteId: message.id,
+      topic: message.topic,
+      sessionId: message.sessionId,
+      data: { ack: { messageId: message.messageId } }
+    };
+    log(`sent ack: ${JSON.stringify(ackMessage)}`);
+    await this._sendMessage(ackMessage);
+  }
+
+  destroy (): void {
+    this._subscriptions.unsubscribe();
+  }
+}

package/src/signal/signal-api.ts

@@ -47,7 +47,13 @@ export namespace SignalApi {
   }
 
   export type SignalMessage = {
+    /**
+     *  Sender's public key.
+     */
     id: PublicKey
+    /**
+     *  Receiver`s public key.
+     */
     remoteId: PublicKey
     topic: PublicKey
     sessionId: PublicKey

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

@@ -11,7 +11,7 @@ import { PublicKey } from '@dxos/protocols';
 import { createTestBroker } from '@dxos/signal';
 import { randomInt } from '@dxos/util';
 
-import { SignalApi } from './signal-api';
+import { Answer, Message } from '../proto/gen/dxos/mesh/signal';
 import { SignalClient } from './signal-client';
 
 describe('SignalApi', () => {
@@ -47,6 +47,30 @@ describe('SignalApi', () => {
     // code await broker2.stop();
   });
 
+  test('message between 2 clients', async () => {
+    const signalMock1 = mockFn<(msg: Message) => Promise<void>>()
+      .resolvesTo();
+    api1 = new SignalClient(signalApiUrl1, (async () => {}) as any, signalMock1);
+    api2 = new SignalClient(signalApiUrl1, (async () => {}) as any, (async () => {}) as any);
+
+    await api1.join(topic, peer1);
+    await api2.join(topic, peer2);
+
+    const msg: Message = {
+      id: peer2,
+      remoteId: peer1,
+      sessionId: PublicKey.random(),
+      topic,
+      data: { signal: { json: "foo: 'bar'" } },
+      messageId: undefined
+    };
+    await api2.signal(msg);
+
+    await waitForExpect(() => {
+      expect(signalMock1).toHaveBeenCalledWith([msg]);
+    }, 4_000);
+  }).timeout(5_000);
+
   test('join', async () => {
     api1 = new SignalClient(signalApiUrl1, (async () => {}) as any, async () => {});
 
@@ -58,14 +82,14 @@ describe('SignalApi', () => {
   }).timeout(1_000);
 
   test('offer', async () => {
-    const offerMock = mockFn<(msg: SignalApi.SignalMessage) => Promise<SignalApi.Answer>>()
+    const offerMock = mockFn<(msg: Message) => Promise<Answer>>()
       .resolvesTo({ accept: true });
     api1 = new SignalClient(signalApiUrl1, offerMock, async () => {});
 
     await api1.join(topic, peer1);
 
-    const offer: SignalApi.SignalMessage = {
-      data: { foo: 'bar' } as any,
+    const offer: Message = {
+      data: { offer: {} },
       id: peer2,
       remoteId: peer1,
       sessionId: PublicKey.random(),
@@ -77,18 +101,19 @@ describe('SignalApi', () => {
   }).timeout(5_000);
 
   test('signal', async () => {
-    const signalMock = mockFn<(msg: SignalApi.SignalMessage) => Promise<void>>()
+    const signalMock = mockFn<(msg: Message) => Promise<void>>()
       .resolvesTo();
     api1 = new SignalClient(signalApiUrl1, (async () => {}) as any, signalMock);
 
     await api1.join(topic, peer1);
 
-    const msg: SignalApi.SignalMessage = {
+    const msg: Message = {
       id: peer2,
       remoteId: peer1,
       sessionId: PublicKey.random(),
       topic,
-      data: { foo: 'bar' } as any
+      data: { signal: { json: 'bar' } },
+      messageId: undefined
     };
     await api1.signal(msg);
 
@@ -118,9 +143,9 @@ describe('SignalApi', () => {
 
   // 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: SignalApi.SignalMessage) => Promise<SignalApi.Answer>>()
+    const offerMock = mockFn<(msg: Message) => Promise<Answer>>()
       .resolvesTo({ accept: true });
-    const signalMock = mockFn<(msg: SignalApi.SignalMessage) => Promise<void>>()
+    const signalMock = mockFn<(msg: Message) => Promise<void>>()
       .resolvesTo();
 
     api1 = new SignalClient(signalApiUrl1, offerMock, async () => {});
@@ -136,16 +161,16 @@ describe('SignalApi', () => {
       id: peer2,
       topic,
       sessionId,
-      data: {}
+      data: { offer: {} }
     });
     expect(answer).toEqual({ accept: true });
 
-    const msg: SignalApi.SignalMessage = {
+    const msg: Message = {
       id: peer2,
       remoteId: peer1,
       sessionId,
       topic,
-      data: { foo: 'bar' } as any
+      data: { offer: { json: 'bar' } }
     };
     await api1.signal(msg);