@dxos/network-manager 0.1.0

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

@@ -0,0 +1,274 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+// @dxos/mocha platform=nodejs
+
+import { expect } from 'earljs';
+import { it, describe } from 'mocha';
+import waitForExpect from 'wait-for-expect';
+
+import { Awaited } from '@dxos/async';
+import { PublicKey } from '@dxos/keys';
+import { Messenger, WebsocketSignalManager } from '@dxos/messaging';
+import { Answer } from '@dxos/protocols/proto/dxos/mesh/swarm';
+import { createTestBroker } from '@dxos/signal';
+import { afterTest } from '@dxos/testutils';
+
+import { MessageRouter } from './message-router';
+import { OfferMessage, SignalMessage } from './signal-messaging';
+
+describe('MessageRouter', function () {
+  let topic: PublicKey;
+
+  let broker1: Awaited<ReturnType<typeof createTestBroker>>;
+
+  before(async function () {
+    broker1 = await createTestBroker();
+  });
+
+  beforeEach(function () {
+    topic = PublicKey.random();
+  });
+
+  after(function () {
+    broker1.stop();
+  });
+
+  const createSignalClientAndMessageRouter = async ({
+    signalApiUrl,
+    onSignal = (async () => {}) as any,
+    onOffer = async () => ({ accept: true }),
+    topic
+  }: {
+    signalApiUrl: string;
+    onSignal?: (msg: SignalMessage) => Promise<void>;
+    onOffer?: (msg: OfferMessage) => Promise<Answer>;
+    topic: PublicKey;
+  }) => {
+    const peerId = PublicKey.random();
+    const signalManager = new WebsocketSignalManager([signalApiUrl]);
+    afterTest(() => signalManager.destroy());
+
+    const messenger = new Messenger({ signalManager });
+    await messenger.listen({
+      peerId,
+      payloadType: 'dxos.mesh.swarm.SwarmMessage',
+      onMessage: async (message) => await router.receiveMessage(message)
+    });
+
+    const router: MessageRouter = new MessageRouter({
+      // todo(mykola): added catch to avoid not finished request.
+      sendMessage: async (message) => await messenger.sendMessage(message),
+      onSignal,
+      onOffer,
+      topic
+    });
+
+    return {
+      peerId,
+      signalManager,
+      router
+    };
+  };
+
+  it('signaling between 2 clients', async () => {
+    const received: SignalMessage[] = [];
+    const signalMock1 = async (msg: SignalMessage) => {
+      received.push(msg);
+    };
+    const { signalManager: signalManager1, peerId: peer1 } = await createSignalClientAndMessageRouter({
+      signalApiUrl: broker1.url(),
+      onSignal: signalMock1,
+      topic
+    });
+    const {
+      signalManager: signalManager2,
+      router: router2,
+      peerId: peer2
+    } = await createSignalClientAndMessageRouter({
+      signalApiUrl: broker1.url(),
+      topic
+    });
+
+    await signalManager1.join({ topic, peerId: peer1 });
+    await signalManager2.join({ topic, peerId: peer2 });
+
+    const msg: SignalMessage = {
+      author: peer2,
+      recipient: peer1,
+      sessionId: PublicKey.random(),
+      topic,
+      data: { signal: { json: JSON.stringify({ asd: 'asd' }) } }
+    };
+    await router2.signal(msg);
+
+    await waitForExpect(() => {
+      expect(received[0]).toBeAnObjectWith(msg);
+    }, 4_000);
+  }).timeout(5_000);
+
+  it('offer/answer', async () => {
+    const {
+      signalManager: signalManager1,
+      router: router1,
+      peerId: peer1
+    } = await createSignalClientAndMessageRouter({
+      signalApiUrl: broker1.url(),
+      onSignal: (async () => {}) as any,
+      onOffer: async () => ({ accept: true }),
+      topic
+    });
+    const { signalManager: signalManager2, peerId: peer2 } = await createSignalClientAndMessageRouter({
+      signalApiUrl: broker1.url(),
+      onSignal: (async () => {}) as any,
+      onOffer: async () => ({ accept: true }),
+      topic
+    });
+
+    await signalManager1.join({ topic, peerId: peer1 });
+    await signalManager2.join({ topic, peerId: peer2 });
+    const answer = await router1.offer({
+      author: peer1,
+      recipient: peer2,
+      sessionId: PublicKey.random(),
+      topic,
+      data: { offer: {} }
+    });
+    expect(answer.accept).toEqual(true);
+  }).timeout(5_000);
+
+  it('signaling between 3 clients', async () => {
+    const received1: SignalMessage[] = [];
+    const signalMock1 = async (msg: SignalMessage) => {
+      received1.push(msg);
+    };
+    const {
+      signalManager: signalManager1,
+      router: router1,
+      peerId: peer1
+    } = await createSignalClientAndMessageRouter({
+      signalApiUrl: broker1.url(),
+      onSignal: signalMock1,
+      onOffer: async () => ({ accept: true }),
+      topic
+    });
+    const received2: SignalMessage[] = [];
+    const signalMock2 = async (msg: SignalMessage) => {
+      received2.push(msg);
+    };
+    const {
+      signalManager: signalManager2,
+      router: router2,
+      peerId: peer2
+    } = await createSignalClientAndMessageRouter({
+      signalApiUrl: broker1.url(),
+      onSignal: signalMock2,
+      onOffer: async () => ({ accept: true }),
+      topic
+    });
+    const received3: SignalMessage[] = [];
+    const signalMock3 = async (msg: SignalMessage) => {
+      received3.push(msg);
+    };
+    const {
+      signalManager: signalManager3,
+      router: router3,
+      peerId: peer3
+    } = await createSignalClientAndMessageRouter({
+      signalApiUrl: broker1.url(),
+      onSignal: signalMock3,
+      onOffer: async () => ({ accept: true }),
+      topic
+    });
+
+    await signalManager1.join({ topic, peerId: peer1 });
+    await signalManager2.join({ topic, peerId: peer2 });
+    await signalManager3.join({ topic, peerId: peer3 });
+
+    // sending signal from peer1 to peer3.
+    const msg1to3: SignalMessage = {
+      author: peer1,
+      recipient: peer3,
+      sessionId: PublicKey.random(),
+      topic,
+      data: { signal: { json: '1to3' } }
+    };
+    await router1.signal(msg1to3);
+    await waitForExpect(() => {
+      expect(received3[0]).toBeAnObjectWith(msg1to3);
+    }, 4_000);
+
+    // sending signal from peer2 to peer3.
+    const msg2to3: SignalMessage = {
+      author: peer2,
+      recipient: peer3,
+      sessionId: PublicKey.random(),
+      topic,
+      data: { signal: { json: '2to3' } }
+    };
+    await router2.signal(msg2to3);
+    await waitForExpect(() => {
+      expect(received3[1]).toBeAnObjectWith(msg2to3);
+    }, 4_000);
+
+    // sending signal from peer3 to peer1.
+    const msg3to1: SignalMessage = {
+      author: peer3,
+      recipient: peer1,
+      sessionId: PublicKey.random(),
+      topic,
+      data: { signal: { json: '3to1' } }
+    };
+    await router3.signal(msg3to1);
+    await waitForExpect(() => {
+      expect(received1[0]).toBeAnObjectWith(msg3to1);
+    }, 4_000);
+  }).timeout(5_000);
+
+  it('two offers', async () => {
+    const {
+      signalManager: signalManager1,
+      router: router1,
+      peerId: peer1
+    } = await createSignalClientAndMessageRouter({
+      signalApiUrl: broker1.url(),
+      onSignal: (async () => {}) as any,
+      onOffer: async () => ({ accept: true }),
+      topic
+    });
+    const {
+      signalManager: signalManager2,
+      router: router2,
+      peerId: peer2
+    } = await createSignalClientAndMessageRouter({
+      signalApiUrl: broker1.url(),
+      onSignal: (async () => {}) as any,
+      onOffer: async () => ({ accept: true }),
+      topic
+    });
+
+    await signalManager1.join({ topic, peerId: peer1 });
+    await signalManager2.join({ topic, peerId: peer2 });
+
+    // sending offer from peer1 to peer2.
+    const answer1 = await router1.offer({
+      author: peer1,
+      recipient: peer2,
+      sessionId: PublicKey.random(),
+      topic,
+      data: { offer: {} }
+    });
+    expect(answer1.accept).toEqual(true);
+
+    // sending offer from peer2 to peer1.
+    const answer2 = await router2.offer({
+      author: peer2,
+      recipient: peer1,
+      sessionId: PublicKey.random(),
+      topic,
+      data: { offer: {} }
+    });
+    expect(answer2.accept).toEqual(true);
+  }).timeout(5_000);
+});

package/src/signal/message-router.ts

@@ -0,0 +1,200 @@
+//
+// Copyright 2020 DXOS.org
+//
+
+import assert from 'assert';
+
+import { Any } from '@dxos/codec-protobuf';
+import { PublicKey } from '@dxos/keys';
+import { log } from '@dxos/log';
+import { schema } from '@dxos/protocols';
+import { Answer, SwarmMessage } from '@dxos/protocols/proto/dxos/mesh/swarm';
+import { ComplexMap, MakeOptional } from '@dxos/util';
+
+import { OfferMessage, SignalMessage, SignalMessaging } from './signal-messaging';
+
+interface OfferRecord {
+  resolve: (answer: Answer) => void;
+  reject: (error?: Error) => void;
+}
+
+interface MessageRouterOptions {
+  sendMessage: (params: { author: PublicKey; recipient: PublicKey; payload: Any }) => Promise<void>;
+  onOffer: (message: OfferMessage) => Promise<Answer>;
+  onSignal: (message: SignalMessage) => Promise<void>;
+  topic: PublicKey;
+}
+
+/**
+ * Adds offer/answer and signal interfaces.
+ */
+export class MessageRouter implements SignalMessaging {
+  private readonly _onSignal: (message: SignalMessage) => Promise<void>;
+  private readonly _sendMessage: (msg: { author: PublicKey; recipient: PublicKey; payload: Any }) => Promise<void>;
+
+  private readonly _onOffer: (message: OfferMessage) => Promise<Answer>;
+  private readonly _topic: PublicKey;
+
+  private readonly _offerRecords: ComplexMap<PublicKey, OfferRecord> = new ComplexMap((key) => key.toHex());
+
+  constructor({ sendMessage, onSignal, onOffer, topic }: MessageRouterOptions) {
+    this._sendMessage = sendMessage;
+    this._onSignal = onSignal;
+    this._onOffer = onOffer;
+    this._topic = topic;
+  }
+
+  async receiveMessage({
+    author,
+    recipient,
+    payload
+  }: {
+    author: PublicKey;
+    recipient: PublicKey;
+    payload: Any;
+  }): Promise<void> {
+    if (payload.type_url !== 'dxos.mesh.swarm.SwarmMessage') {
+      // Ignore not swarm messages.
+      return;
+    }
+    const message: SwarmMessage = schema.getCodecForType('dxos.mesh.swarm.SwarmMessage').decode(payload.value);
+
+    if (!this._topic.equals(message.topic)) {
+      // Ignore messages from wrong topics.
+      return;
+    }
+
+    log('received', { from: author, to: recipient, msg: message });
+
+    if (message.data?.offer) {
+      await this._handleOffer({ author, recipient, message });
+    } else if (message.data?.answer) {
+      await this._resolveAnswers(message);
+    } else if (message.data?.signal) {
+      await this._handleSignal({ author, recipient, message });
+    }
+  }
+
+  async signal(message: SignalMessage): Promise<void> {
+    assert(message.data?.signal);
+    await this._sendReliableMessage({
+      author: message.author,
+      recipient: message.recipient,
+      message
+    });
+  }
+
+  async offer(message: OfferMessage): Promise<Answer> {
+    const networkMessage: SwarmMessage = {
+      ...message,
+      messageId: PublicKey.random()
+    };
+    return new Promise<Answer>((resolve, reject) => {
+      this._offerRecords.set(networkMessage.messageId!, { resolve, reject });
+      return this._sendReliableMessage({
+        author: message.author,
+        recipient: message.recipient,
+        message: networkMessage
+      });
+    });
+  }
+
+  private async _sendReliableMessage({
+    author,
+    recipient,
+    message
+  }: {
+    author: PublicKey;
+    recipient: PublicKey;
+    message: MakeOptional<SwarmMessage, 'messageId'>;
+  }): Promise<void> {
+    const networkMessage: SwarmMessage = {
+      ...message,
+      // Setting unique message_id if it not specified yet.
+      messageId: message.messageId ?? PublicKey.random()
+    };
+
+    log('sending', { from: author, to: recipient, msg: networkMessage });
+    await this._encodeAndSend({ author, recipient, message: networkMessage });
+  }
+
+  private async _encodeAndSend({
+    author,
+    recipient,
+    message
+  }: {
+    author: PublicKey;
+    recipient: PublicKey;
+    message: SwarmMessage;
+  }) {
+    await this._sendMessage({
+      author,
+      recipient,
+      payload: {
+        type_url: 'dxos.mesh.swarm.SwarmMessage',
+        value: schema.getCodecForType('dxos.mesh.swarm.SwarmMessage').encode(message)
+      }
+    });
+  }
+
+  private async _resolveAnswers(message: SwarmMessage): 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: message.data.answer });
+      offerRecord.resolve(message.data.answer);
+    }
+  }
+
+  private async _handleOffer({
+    author,
+    recipient,
+    message
+  }: {
+    author: PublicKey;
+    recipient: PublicKey;
+    message: SwarmMessage;
+  }): Promise<void> {
+    assert(message.data.offer, 'No offer');
+    const offerMessage: OfferMessage = {
+      author,
+      recipient,
+      ...message,
+      data: { offer: message.data.offer }
+    };
+    const answer = await this._onOffer(offerMessage);
+    answer.offerMessageId = message.messageId;
+    await this._sendReliableMessage({
+      author: recipient,
+      recipient: author,
+      message: {
+        topic: message.topic,
+        sessionId: message.sessionId,
+        data: { answer }
+      }
+    });
+  }
+
+  private async _handleSignal({
+    author,
+    recipient,
+    message
+  }: {
+    author: PublicKey;
+    recipient: PublicKey;
+    message: SwarmMessage;
+  }): Promise<void> {
+    assert(message.messageId);
+    assert(message.data.signal, 'No Signal');
+    const signalMessage: SignalMessage = {
+      author,
+      recipient,
+      ...message,
+      data: { signal: message.data.signal }
+    };
+
+    await this._onSignal(signalMessage);
+  }
+}

package/src/signal/signal-connection.ts

@@ -0,0 +1,20 @@
+//
+// Copyright 2020 DXOS.org
+//
+
+import { PublicKey } from '@dxos/keys';
+
+/**
+ * Signal peer discovery interface.
+ */
+export interface SignalConnection {
+  /**
+   * Join topic on signal network, to be discoverable by other peers.
+   */
+  join(params: { topic: PublicKey; peerId: PublicKey }): Promise<void>;
+
+  /**
+   * Leave topic on signal network, to stop being discoverable by other peers.
+   */
+  leave(params: { topic: PublicKey; peerId: PublicKey }): Promise<void>;
+}

package/src/signal/signal-messaging.ts

@@ -0,0 +1,38 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import { PublicKey } from '@dxos/keys';
+import { Answer, Offer, Signal } from '@dxos/protocols/proto/dxos/mesh/swarm';
+
+export interface OfferMessage {
+  author: PublicKey;
+  recipient: PublicKey;
+  topic: PublicKey;
+  sessionId: PublicKey;
+  data: { offer: Offer };
+}
+
+export interface SignalMessage {
+  author: PublicKey;
+  recipient: PublicKey;
+  topic: PublicKey;
+  sessionId: PublicKey;
+  data: { signal: Signal };
+}
+
+/**
+ * Signal peer messaging interface.
+ */
+
+export interface SignalMessaging {
+  /**
+   * Offer/answer RPC.
+   */
+  offer(msg: OfferMessage): Promise<Answer>;
+
+  /**
+   * Reliably send a signal to a peer.
+   */
+  signal(msg: SignalMessage): Promise<void>;
+}