@dxos/network-manager 2.33.9-dev.e605934d → 2.33.9-dev.eb69ac10

package/src/signal/message-router.ts

@@ -3,9 +3,10 @@
 //
 
 import assert from 'assert';
+import debug from 'debug';
 
 import { PublicKey } from '@dxos/protocols';
-import { ComplexMap } from '@dxos/util';
+import { ComplexMap, ComplexSet, exponentialBackoffInterval, SubscriptionGroup } from '@dxos/util';
 
 import { Answer, Message } from '../proto/gen/dxos/mesh/signal';
 import { SignalMessaging } from './signal-manager';
@@ -16,11 +17,14 @@ interface OfferRecord {
 }
 
 interface MessageRouterOptions {
-  onSignal: (message: Message) => Promise<void>;
-  sendMessage: (message: Message) => Promise<void>;
-  onOffer: (message: Message) => Promise<Answer>;
+  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.
  */
@@ -31,59 +35,144 @@ export class MessageRouter implements SignalMessaging {
   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
-  }: MessageRouterOptions) {
+    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._onSignal(message);
+      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._sendMessage(message);
+    await this._sendReliableMessage(message);
   }
 
   async offer (message: Message): Promise<Answer> {
+    message.messageId = PublicKey.random();
     const promise = new Promise<Answer>((resolve, reject) => {
-      assert(message.sessionId);
-      this._offerRecords.set(message.sessionId, { resolve, reject });
+      this._offerRecords.set(message.messageId!, { resolve, reject });
+      return this._sendReliableMessage(message);
     });
-    await this._sendMessage(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.sessionId);
-    const offerRecord = this._offerRecords.get(message.sessionId);
+    assert(message.data?.answer?.offerMessageId, 'No offerMessageId');
+    const offerRecord = this._offerRecords.get(message.data.answer.offerMessageId);
     if (offerRecord) {
-      this._offerRecords.delete(message.sessionId);
-      assert(message.data?.answer);
+      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);
-    const answerMessage = {
+    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: { answer: answer }
+      data: { ack: { messageId: message.messageId } }
     };
-    await this._sendMessage(answerMessage);
+    log(`sent ack: ${JSON.stringify(ackMessage)}`);
+    await this._sendMessage(ackMessage);
+  }
+
+  destroy (): void {
+    this._subscriptions.unsubscribe();
   }
 }

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

@@ -61,7 +61,8 @@ describe('SignalApi', () => {
       remoteId: peer1,
       sessionId: PublicKey.random(),
       topic,
-      data: { signal: { json: "foo: 'bar'" } }
+      data: { signal: { json: "foo: 'bar'" } },
+      messageId: undefined
     };
     await api2.signal(msg);
 
@@ -111,7 +112,8 @@ describe('SignalApi', () => {
       remoteId: peer1,
       sessionId: PublicKey.random(),
       topic,
-      data: { signal: { json: 'bar' } }
+      data: { signal: { json: 'bar' } },
+      messageId: undefined
     };
     await api1.signal(msg);
 

package/src/signal/signal-client.ts

@@ -5,8 +5,10 @@
 import debug from 'debug';
 
 import { Event } from '@dxos/async';
+import { failUndefined } from '@dxos/debug';
 import { PublicKey } from '@dxos/protocols';
 
+import { schema } from '../proto/gen';
 import { Answer, Message } from '../proto/gen/dxos/mesh/signal';
 import { SignalApi } from './signal-api';
 import { WebsocketRpc } from './websocket-rpc';
@@ -90,13 +92,17 @@ export class SignalClient {
       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._client.subscribe('signal', (msg: SignalMessage) => {
+      return this._onSignal({
+        id: PublicKey.from(msg.id!),
+        remoteId: PublicKey.from(msg.remoteId!),
+        topic: PublicKey.from(msg.topic!),
+        sessionId: PublicKey.from(msg.sessionId!),
+        data: schema.getCodecForType('dxos.mesh.signal.MessageData').decode(msg.data ?? failUndefined()),
+        // Field that MessageRouter adds, so on lower level it not always defined.
+        messageId: msg.messageId ? PublicKey.from(msg.messageId) : undefined
+      });
+    });
 
     this._clientCleanup.push(this._client.connected.on(() => {
       log('Socket connected');
@@ -210,6 +216,7 @@ export class SignalClient {
   /**
    * Routes an offer to the other peer's _onOffer callback.
    * @returns Other peer's _onOffer callback return value.
+   * @deprecated
    */
   async offer (msg: Message): Promise<Answer> {
     return this._client.call('offer', {
@@ -224,13 +231,33 @@ export class SignalClient {
   /**
    * 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
-    });
+  async signal (message: Message): Promise<void> {
+    const signalMessage: SignalMessage = {
+      messageId: message.messageId?.asBuffer(),
+      id: message.id?.asBuffer(),
+      remoteId: message.remoteId?.asBuffer(),
+      topic: message.topic?.asBuffer(),
+      sessionId: message.sessionId?.asBuffer(),
+      data: Buffer.from(schema.getCodecForType('dxos.mesh.signal.MessageData').encode(message.data ?? failUndefined()))
+    };
+    return this._client.emit('signal', signalMessage);
   }
 }
+
+/**
+ * Messages as processed by the signal server.
+ */
+interface SignalMessage{
+  /**
+   * Sender's public key.
+   */
+  id?: Buffer;
+  /**
+   * Receiver`s public key.
+   */
+  remoteId?: Buffer;
+  topic?: Buffer;
+  sessionId?: Buffer;
+  data?: Buffer;
+  messageId?: Buffer;
+}

package/src/signal/websocket-rpc.ts

@@ -2,10 +2,10 @@
 // Copyright 2020 DXOS.org
 //
 
-import assert from 'assert';
 import debug from 'debug';
 import WebSocket from 'isomorphic-ws';
 import nanomessagerpc from 'nanomessage-rpc';
+import assert from 'node:assert';
 import { promisify } from 'util';
 
 import { Event, Trigger, sleep } from '@dxos/async';

package/src/signal/websocket-signal-manager.ts

@@ -2,8 +2,8 @@
 // Copyright 2020 DXOS.org
 //
 
-import assert from 'assert';
 import debug from 'debug';
+import assert from 'node:assert';
 
 import { Event, synchronized } from '@dxos/async';
 import { PublicKey } from '@dxos/protocols';

package/src/swarm/connection.ts

@@ -2,8 +2,8 @@
 // Copyright 2021 DXOS.org
 //
 
-import assert from 'assert';
 import debug from 'debug';
+import assert from 'node:assert';
 
 import { Event, synchronized } from '@dxos/async';
 import { ErrorStream } from '@dxos/debug';

package/src/swarm/swarm.test.ts

@@ -52,12 +52,14 @@ const setup = ({ router = false } = {}) => {
     onSignal: msg => swarm1.onSignal(msg),
     onOffer: msg => swarm1.onOffer(msg)
   });
+  afterTest(() => mr1.destroy());
 
   const mr2: MessageRouter = new MessageRouter({
     sendMessage: msg => mr1.receiveMessage(msg),
     onSignal: msg => swarm2.onSignal(msg),
     onOffer: msg => swarm2.onOffer(msg)
   });
+  afterTest(() => mr2.destroy());
 
   const sm1: SignalMessaging = router ? mr1 : new MockSignalConnection(() => swarm2);
 

package/src/swarm/swarm.ts

@@ -2,8 +2,8 @@
 // Copyright 2020 DXOS.org
 //
 
-import assert from 'assert';
 import debug from 'debug';
+import assert from 'node:assert';
 
 import { Event } from '@dxos/async';
 import { discoveryKey } from '@dxos/crypto';
@@ -101,7 +101,7 @@ export class Swarm {
   }
 
   async onOffer (message: Message): Promise<Answer> {
-    log(`Offer from ${message.id} topic=${this._topic}`);
+    log(`Offer from ${JSON.stringify(message)}`);
     // Id of the peer offering us the connection.
     assert(message.id);
     const remoteId = message.id;

package/src/testing/test-protocol.ts

@@ -4,9 +4,9 @@
 
 // Test/mock Protocol implementation used in network-manager tests.
 
-import assert from 'assert';
 import debug from 'debug';
 import { EventEmitter } from 'events';
+import assert from 'node:assert';
 
 import { Extension, Protocol } from '@dxos/mesh-protocol';
 import { PublicKey } from '@dxos/protocols';

package/src/topology/fully-connected-topology.ts

@@ -2,7 +2,7 @@
 // Copyright 2020 DXOS.org
 //
 
-import assert from 'assert';
+import assert from 'node:assert';
 
 import { PublicKey } from '@dxos/protocols';
 

package/src/topology/mmst-topology.ts

@@ -2,8 +2,8 @@
 // Copyright 2020 DXOS.org
 //
 
-import assert from 'assert';
 import debug from 'debug';
+import assert from 'node:assert';
 import distance from 'xor-distance';
 
 import { PublicKey } from '@dxos/protocols';

package/src/topology/star-topology.ts

@@ -2,8 +2,8 @@
 // Copyright 2020 DXOS.org
 //
 
-import assert from 'assert';
 import debug from 'debug';
+import assert from 'node:assert';
 
 import { PublicKey } from '@dxos/protocols';
 

package/src/transport/in-memory-transport.ts

@@ -2,8 +2,8 @@
 // Copyright 2020 DXOS.org
 //
 
-import assert from 'assert';
 import debug from 'debug';
+import assert from 'node:assert';
 import { Transform } from 'stream';
 
 import { Event } from '@dxos/async';

package/src/transport/webrtc-transport.ts

@@ -3,8 +3,8 @@
 //
 
 import wrtc from '@koush/wrtc';
-import assert from 'assert';
 import debug from 'debug';
+import assert from 'node:assert';
 import SimplePeerConstructor, { Instance as SimplePeer } from 'simple-peer';
 
 import { Event } from '@dxos/async';