@dxos/network-manager 2.33.9-dev.9246a07b → 2.33.9-dev.9bbef4e2

package/src/signal/message-router.ts

@@ -8,7 +8,7 @@ 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 { Answer, SignalMessage } from '../proto/gen/dxos/mesh/signalMessage';
 import { SignalMessaging } from './signal-manager';
 
 interface OfferRecord {
@@ -17,9 +17,9 @@ interface OfferRecord {
 }
 
 interface MessageRouterOptions {
-  onSignal?: (message: Message) => Promise<void>;
-  sendMessage?: (message: Message) => Promise<void>;
-  onOffer?: (message: Message) => Promise<Answer>;
+  sendMessage?: (message: SignalMessage) => Promise<void>;
+  onOffer?: (message: SignalMessage) => Promise<Answer>;
+  onSignal?: (message: SignalMessage) => Promise<void>;
   retryDelay?: number;
   timeout?: number;
 }
@@ -31,9 +31,9 @@ const log = debug('dxos:network-manager:message-router');
 // 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 _onSignal: (message: SignalMessage) => Promise<void>;
+  private readonly _sendMessage: (message: SignalMessage) => Promise<void>;
+  private readonly _onOffer: (message: SignalMessage) => Promise<Answer>;
 
   private readonly _onAckCallbacks = new ComplexMap<PublicKey, () => void>(key => key.toHex());
   private readonly _receivedMessages = new ComplexSet<PublicKey>(key => key.toHex());
@@ -59,7 +59,7 @@ export class MessageRouter implements SignalMessaging {
     this._timeout = timeout;
   }
 
-  async receiveMessage (message: Message): Promise<void> {
+  async receiveMessage (message: SignalMessage): Promise<void> {
     log(`receive message: ${JSON.stringify(message)}`);
     if (!message.data?.ack) {
       if (this._receivedMessages.has(message.messageId!)) {
@@ -81,12 +81,12 @@ export class MessageRouter implements SignalMessaging {
     }
   }
 
-  async signal (message: Message): Promise<void> {
+  async signal (message: SignalMessage): Promise<void> {
     assert(message.data?.signal);
     await this._sendReliableMessage(message);
   }
 
-  async offer (message: Message): Promise<Answer> {
+  async offer (message: SignalMessage): Promise<Answer> {
     message.messageId = PublicKey.random();
     const promise = new Promise<Answer>((resolve, reject) => {
       this._offerRecords.set(message.messageId!, { resolve, reject });
@@ -95,7 +95,7 @@ export class MessageRouter implements SignalMessaging {
     return promise;
   }
 
-  private async _sendReliableMessage (message: Message): Promise<PublicKey> {
+  private async _sendReliableMessage (message: SignalMessage): Promise<PublicKey> {
     // Setting unique messageId if it not specified yet.
     message.messageId = message.messageId ?? PublicKey.random();
     log(`sent message: ${JSON.stringify(message)}`);
@@ -103,7 +103,11 @@ export class MessageRouter implements SignalMessaging {
     // Setting retry interval if signal was not acknowledged.
     const cancelRetry = exponentialBackoffInterval(async () => {
       log(`retrying message: ${JSON.stringify(message)}`);
-      await this._sendMessage(message);
+      try {
+        await this._sendMessage(message);
+      } catch (error) {
+        log(`ERROR failed to send message: ${error}`);
+      }
     }, this._retryDelay);
 
     const timeout = setTimeout(() => {
@@ -125,7 +129,7 @@ export class MessageRouter implements SignalMessaging {
     return message.messageId;
   }
 
-  private async _resolveAnswers (message: Message): Promise<void> {
+  private async _resolveAnswers (message: SignalMessage): Promise<void> {
     assert(message.data?.answer?.offerMessageId, 'No offerMessageId');
     const offerRecord = this._offerRecords.get(message.data.answer.offerMessageId);
     if (offerRecord) {
@@ -136,10 +140,10 @@ export class MessageRouter implements SignalMessaging {
     }
   }
 
-  private async _handleOffer (message: Message): Promise<void> {
+  private async _handleOffer (message: SignalMessage): Promise<void> {
     const answer = await this._onOffer(message);
     answer.offerMessageId = message.messageId;
-    const answerMessage: Message = {
+    const answerMessage: SignalMessage = {
       id: message.remoteId,
       remoteId: message.id,
       topic: message.topic,
@@ -149,17 +153,17 @@ export class MessageRouter implements SignalMessaging {
     await this._sendReliableMessage(answerMessage);
   }
 
-  private async _handleSignal (message: Message): Promise<void> {
+  private async _handleSignal (message: SignalMessage): Promise<void> {
     assert(message.messageId);
     await this._onSignal(message);
   }
 
-  private async _handleAcknowledgement (message: Message): Promise<void> {
+  private async _handleAcknowledgement (message: SignalMessage): Promise<void> {
     assert(message.data?.ack?.messageId);
     this._onAckCallbacks.get(message.data.ack.messageId)?.();
   }
 
-  private async _sendAcknowledgement (message: Message): Promise<void> {
+  private async _sendAcknowledgement (message: SignalMessage): Promise<void> {
     assert(message.messageId);
     const ackMessage = {
       id: message.remoteId,

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

@@ -6,166 +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'" } },
-      messageId: undefined
+      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' } },
-      messageId: undefined
+      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,
@@ -178,4 +156,4 @@ describe('SignalApi', () => {
       expect(signalMock).toHaveBeenCalledWith([msg]);
     }, 4_000);
   }).timeout(5_000);
-}).timeout(10_000);
+});