@dxos/messaging 0.8.3 → 0.8.4-main.1068cf700f

package/dist/lib/neutral/chunk-5MOQVHHI.mjs

@@ -0,0 +1,694 @@
+import "@dxos/node-std/globals";
+
+// src/messenger.ts
+import { TimeoutError, scheduleExponentialBackoffTaskInterval, scheduleTask, scheduleTaskInterval } from "@dxos/async";
+import { Context } from "@dxos/context";
+import { invariant } from "@dxos/invariant";
+import { PublicKey } from "@dxos/keys";
+import { log } from "@dxos/log";
+import { TimeoutError as ProtocolTimeoutError, trace as trace2 } from "@dxos/protocols";
+import { schema } from "@dxos/protocols/proto";
+import { ComplexMap, ComplexSet } from "@dxos/util";
+
+// src/messenger-monitor.ts
+import { trace } from "@dxos/tracing";
+var MessengerMonitor = class {
+  recordMessageAckFailed() {
+    trace.metrics.increment("dxos.mesh.signal.messenger.failed-ack", 1);
+  }
+  recordReliableMessage(params) {
+    trace.metrics.increment("dxos.mesh.signal.messenger.reliable-send", 1, {
+      tags: {
+        success: params.sent,
+        attempts: params.sendAttempts
+      }
+    });
+  }
+};
+
+// src/timeouts.ts
+var MESSAGE_TIMEOUT = 1e4;
+
+// src/messenger.ts
+var __dxlog_file = "/__w/dxos/dxos/packages/core/mesh/messaging/src/messenger.ts";
+var ReliablePayload = schema.getCodecForType("dxos.mesh.messaging.ReliablePayload");
+var Acknowledgement = schema.getCodecForType("dxos.mesh.messaging.Acknowledgement");
+var RECEIVED_MESSAGES_GC_INTERVAL = 12e4;
+var Messenger = class {
+  _monitor = new MessengerMonitor();
+  _signalManager;
+  // { peerId, payloadType } => listeners set
+  _listeners = new ComplexMap(({ peerId, payloadType }) => peerId + payloadType);
+  // peerId => listeners set
+  _defaultListeners = /* @__PURE__ */ new Map();
+  _onAckCallbacks = new ComplexMap(PublicKey.hash);
+  _receivedMessages = new ComplexSet(PublicKey.hash);
+  /**
+  * Keys scheduled to be cleared from _receivedMessages on the next iteration.
+  */
+  _toClear = new ComplexSet(PublicKey.hash);
+  _ctx;
+  _closed = true;
+  _retryDelay;
+  constructor({ signalManager, retryDelay = 1e3 }) {
+    this._signalManager = signalManager;
+    this._retryDelay = retryDelay;
+    this.open();
+  }
+  open() {
+    if (!this._closed) {
+      return;
+    }
+    const traceId = PublicKey.random().toHex();
+    log.trace("dxos.mesh.messenger.open", trace2.begin({
+      id: traceId
+    }), {
+      F: __dxlog_file,
+      L: 72,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    this._ctx = new Context({
+      onError: (err) => log.catch(err, void 0, {
+        F: __dxlog_file,
+        L: 74,
+        S: this,
+        C: (f, a) => f(...a)
+      })
+    }, {
+      F: __dxlog_file,
+      L: 73
+    });
+    this._ctx.onDispose(this._signalManager.onMessage.on(async (message) => {
+      log("received message", {
+        from: message.author
+      }, {
+        F: __dxlog_file,
+        L: 78,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      await this._handleMessage(message);
+    }));
+    scheduleTaskInterval(this._ctx, async () => {
+      this._performGc();
+    }, RECEIVED_MESSAGES_GC_INTERVAL);
+    this._closed = false;
+    log.trace("dxos.mesh.messenger.open", trace2.end({
+      id: traceId
+    }), {
+      F: __dxlog_file,
+      L: 93,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+  }
+  async close() {
+    if (this._closed) {
+      return;
+    }
+    this._closed = true;
+    await this._ctx.dispose();
+  }
+  async sendMessage({ author, recipient, payload }) {
+    invariant(!this._closed, "Closed", {
+      F: __dxlog_file,
+      L: 105,
+      S: this,
+      A: [
+        "!this._closed",
+        "'Closed'"
+      ]
+    });
+    const messageContext = this._ctx.derive();
+    const reliablePayload = {
+      messageId: PublicKey.random(),
+      payload
+    };
+    invariant(!this._onAckCallbacks.has(reliablePayload.messageId), void 0, {
+      F: __dxlog_file,
+      L: 112,
+      S: this,
+      A: [
+        "!this._onAckCallbacks.has(reliablePayload.messageId!)",
+        ""
+      ]
+    });
+    log("send message", {
+      messageId: reliablePayload.messageId,
+      author,
+      recipient
+    }, {
+      F: __dxlog_file,
+      L: 113,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    let messageReceived;
+    let timeoutHit;
+    let sendAttempts = 0;
+    const promise = new Promise((resolve, reject) => {
+      messageReceived = resolve;
+      timeoutHit = reject;
+    });
+    scheduleExponentialBackoffTaskInterval(messageContext, async () => {
+      log("retrying message", {
+        messageId: reliablePayload.messageId
+      }, {
+        F: __dxlog_file,
+        L: 128,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      sendAttempts++;
+      await this._encodeAndSend({
+        author,
+        recipient,
+        reliablePayload
+      }).catch((err) => log("failed to send message", {
+        err
+      }, {
+        F: __dxlog_file,
+        L: 131,
+        S: this,
+        C: (f, a) => f(...a)
+      }));
+    }, this._retryDelay);
+    scheduleTask(messageContext, () => {
+      log("message not delivered", {
+        messageId: reliablePayload.messageId
+      }, {
+        F: __dxlog_file,
+        L: 140,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      this._onAckCallbacks.delete(reliablePayload.messageId);
+      timeoutHit(new ProtocolTimeoutError({
+        message: "signaling message not delivered",
+        cause: new TimeoutError(MESSAGE_TIMEOUT, "Message not delivered")
+      }));
+      void messageContext.dispose();
+      this._monitor.recordReliableMessage({
+        sendAttempts,
+        sent: false
+      });
+    }, MESSAGE_TIMEOUT);
+    this._onAckCallbacks.set(reliablePayload.messageId, () => {
+      messageReceived();
+      this._onAckCallbacks.delete(reliablePayload.messageId);
+      void messageContext.dispose();
+      this._monitor.recordReliableMessage({
+        sendAttempts,
+        sent: true
+      });
+    });
+    await this._encodeAndSend({
+      author,
+      recipient,
+      reliablePayload
+    });
+    return promise;
+  }
+  /**
+  * Subscribes onMessage function to messages that contains payload with payloadType.
+  * @param payloadType if not specified, onMessage will be subscribed to all types of messages.
+  */
+  async listen({ peer, payloadType, onMessage }) {
+    invariant(!this._closed, "Closed", {
+      F: __dxlog_file,
+      L: 178,
+      S: this,
+      A: [
+        "!this._closed",
+        "'Closed'"
+      ]
+    });
+    await this._signalManager.subscribeMessages(peer);
+    let listeners;
+    invariant(peer.peerKey, "Peer key is required", {
+      F: __dxlog_file,
+      L: 182,
+      S: this,
+      A: [
+        "peer.peerKey",
+        "'Peer key is required'"
+      ]
+    });
+    if (!payloadType) {
+      listeners = this._defaultListeners.get(peer.peerKey);
+      if (!listeners) {
+        listeners = /* @__PURE__ */ new Set();
+        this._defaultListeners.set(peer.peerKey, listeners);
+      }
+    } else {
+      listeners = this._listeners.get({
+        peerId: peer.peerKey,
+        payloadType
+      });
+      if (!listeners) {
+        listeners = /* @__PURE__ */ new Set();
+        this._listeners.set({
+          peerId: peer.peerKey,
+          payloadType
+        }, listeners);
+      }
+    }
+    listeners.add(onMessage);
+    return {
+      unsubscribe: async () => {
+        listeners.delete(onMessage);
+      }
+    };
+  }
+  async _encodeAndSend({ author, recipient, reliablePayload }) {
+    await this._signalManager.sendMessage({
+      author,
+      recipient,
+      payload: {
+        type_url: "dxos.mesh.messaging.ReliablePayload",
+        value: ReliablePayload.encode(reliablePayload, {
+          preserveAny: true
+        })
+      }
+    });
+  }
+  async _handleMessage(message) {
+    switch (message.payload.type_url) {
+      case "dxos.mesh.messaging.ReliablePayload": {
+        await this._handleReliablePayload(message);
+        break;
+      }
+      case "dxos.mesh.messaging.Acknowledgement": {
+        await this._handleAcknowledgement({
+          payload: message.payload
+        });
+        break;
+      }
+    }
+  }
+  async _handleReliablePayload({ author, recipient, payload }) {
+    invariant(payload.type_url === "dxos.mesh.messaging.ReliablePayload", void 0, {
+      F: __dxlog_file,
+      L: 240,
+      S: this,
+      A: [
+        "payload.type_url === 'dxos.mesh.messaging.ReliablePayload'",
+        ""
+      ]
+    });
+    const reliablePayload = ReliablePayload.decode(payload.value, {
+      preserveAny: true
+    });
+    log("handling message", {
+      messageId: reliablePayload.messageId
+    }, {
+      F: __dxlog_file,
+      L: 243,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    try {
+      await this._sendAcknowledgement({
+        author,
+        recipient,
+        messageId: reliablePayload.messageId
+      });
+    } catch (err) {
+      this._monitor.recordMessageAckFailed();
+      throw err;
+    }
+    if (this._receivedMessages.has(reliablePayload.messageId)) {
+      return;
+    }
+    this._receivedMessages.add(reliablePayload.messageId);
+    await this._callListeners({
+      author,
+      recipient,
+      payload: reliablePayload.payload
+    });
+  }
+  async _handleAcknowledgement({ payload }) {
+    invariant(payload.type_url === "dxos.mesh.messaging.Acknowledgement", void 0, {
+      F: __dxlog_file,
+      L: 271,
+      S: this,
+      A: [
+        "payload.type_url === 'dxos.mesh.messaging.Acknowledgement'",
+        ""
+      ]
+    });
+    this._onAckCallbacks.get(Acknowledgement.decode(payload.value).messageId)?.();
+  }
+  async _sendAcknowledgement({ author, recipient, messageId }) {
+    log("sending ACK", {
+      messageId,
+      from: recipient,
+      to: author
+    }, {
+      F: __dxlog_file,
+      L: 284,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    await this._signalManager.sendMessage({
+      author: recipient,
+      recipient: author,
+      payload: {
+        type_url: "dxos.mesh.messaging.Acknowledgement",
+        value: Acknowledgement.encode({
+          messageId
+        })
+      }
+    });
+  }
+  async _callListeners(message) {
+    {
+      invariant(message.recipient.peerKey, "Peer key is required", {
+        F: __dxlog_file,
+        L: 298,
+        S: this,
+        A: [
+          "message.recipient.peerKey",
+          "'Peer key is required'"
+        ]
+      });
+      const defaultListenerMap = this._defaultListeners.get(message.recipient.peerKey);
+      if (defaultListenerMap) {
+        for (const listener of defaultListenerMap) {
+          await listener(message);
+        }
+      }
+    }
+    {
+      const listenerMap = this._listeners.get({
+        peerId: message.recipient.peerKey,
+        payloadType: message.payload.type_url
+      });
+      if (listenerMap) {
+        for (const listener of listenerMap) {
+          await listener(message);
+        }
+      }
+    }
+  }
+  _performGc() {
+    const start = performance.now();
+    for (const key of this._toClear.keys()) {
+      this._receivedMessages.delete(key);
+    }
+    this._toClear.clear();
+    for (const key of this._receivedMessages.keys()) {
+      this._toClear.add(key);
+    }
+    const elapsed = performance.now() - start;
+    if (elapsed > 100) {
+      log.warn("GC took too long", {
+        elapsed
+      }, {
+        F: __dxlog_file,
+        L: 333,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    }
+  }
+};
+
+// src/signal-methods.ts
+var PeerInfoHash = ({ peerKey }) => peerKey;
+
+// src/signal-manager/memory-signal-manager.ts
+import { Event, Trigger } from "@dxos/async";
+import { Context as Context2 } from "@dxos/context";
+import { invariant as invariant2 } from "@dxos/invariant";
+import { PublicKey as PublicKey2 } from "@dxos/keys";
+import { log as log2 } from "@dxos/log";
+import { schema as schema2 } from "@dxos/protocols/proto";
+import { ComplexMap as ComplexMap2, ComplexSet as ComplexSet2 } from "@dxos/util";
+var __dxlog_file2 = "/__w/dxos/dxos/packages/core/mesh/messaging/src/signal-manager/memory-signal-manager.ts";
+var MemorySignalManagerContext = class {
+  // Swarm messages.
+  swarmEvent = new Event();
+  // Mapping from topic to set of peers.
+  swarms = new ComplexMap2(PublicKey2.hash);
+  // Map of connections for each peer for signaling.
+  connections = new ComplexMap2(PeerInfoHash);
+};
+var MemorySignalManager = class {
+  _context;
+  statusChanged = new Event();
+  swarmEvent = new Event();
+  onMessage = new Event();
+  /**  Will be used to emit SwarmEvents on .open() and .close() */
+  _joinedSwarms = new ComplexSet2(({ topic, peer }) => topic.toHex() + peer.peerKey);
+  _ctx;
+  // TODO(dmaretskyi): Replace with callback.
+  _freezeTrigger = new Trigger().wake();
+  constructor(_context) {
+    this._context = _context;
+    this._ctx = new Context2(void 0, {
+      F: __dxlog_file2,
+      L: 54
+    });
+    this._ctx.onDispose(this._context.swarmEvent.on((data) => this.swarmEvent.emit(data)));
+  }
+  async open() {
+    if (!this._ctx.disposed) {
+      return;
+    }
+    this._ctx = new Context2(void 0, {
+      F: __dxlog_file2,
+      L: 63
+    });
+    this._ctx.onDispose(this._context.swarmEvent.on((data) => this.swarmEvent.emit(data)));
+    await Promise.all([
+      ...this._joinedSwarms.values()
+    ].map((value) => this.join(value)));
+  }
+  async close() {
+    if (this._ctx.disposed) {
+      return;
+    }
+    const joinedSwarmsCopy = new ComplexSet2(({ topic, peer }) => topic.toHex() + peer.peerKey, [
+      ...this._joinedSwarms.values()
+    ]);
+    await Promise.all([
+      ...this._joinedSwarms.values()
+    ].map((value) => this.leave(value)));
+    this._joinedSwarms = joinedSwarmsCopy;
+    await this._ctx.dispose();
+  }
+  getStatus() {
+    return [];
+  }
+  async join({ topic, peer }) {
+    invariant2(!this._ctx.disposed, "Closed", {
+      F: __dxlog_file2,
+      L: 92,
+      S: this,
+      A: [
+        "!this._ctx.disposed",
+        "'Closed'"
+      ]
+    });
+    this._joinedSwarms.add({
+      topic,
+      peer
+    });
+    if (!this._context.swarms.has(topic)) {
+      this._context.swarms.set(topic, new ComplexSet2(PeerInfoHash));
+    }
+    this._context.swarms.get(topic).add(peer);
+    this._context.swarmEvent.emit({
+      topic,
+      peerAvailable: {
+        peer,
+        since: /* @__PURE__ */ new Date()
+      }
+    });
+    for (const [topic2, peers] of this._context.swarms) {
+      Array.from(peers).forEach((peer2) => {
+        this.swarmEvent.emit({
+          topic: topic2,
+          peerAvailable: {
+            peer: peer2,
+            since: /* @__PURE__ */ new Date()
+          }
+        });
+      });
+    }
+  }
+  async leave({ topic, peer }) {
+    invariant2(!this._ctx.disposed, "Closed", {
+      F: __dxlog_file2,
+      L: 124,
+      S: this,
+      A: [
+        "!this._ctx.disposed",
+        "'Closed'"
+      ]
+    });
+    this._joinedSwarms.delete({
+      topic,
+      peer
+    });
+    if (!this._context.swarms.has(topic)) {
+      this._context.swarms.set(topic, new ComplexSet2(PeerInfoHash));
+    }
+    this._context.swarms.get(topic).delete(peer);
+    const swarmEvent = {
+      topic,
+      peerLeft: {
+        peer
+      }
+    };
+    this._context.swarmEvent.emit(swarmEvent);
+  }
+  async query(request) {
+    throw new Error("Not implemented");
+  }
+  async sendMessage({ author, recipient, payload }) {
+    log2("send message", {
+      author,
+      recipient,
+      ...dec(payload)
+    }, {
+      F: __dxlog_file2,
+      L: 157,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    invariant2(recipient, void 0, {
+      F: __dxlog_file2,
+      L: 159,
+      S: this,
+      A: [
+        "recipient",
+        ""
+      ]
+    });
+    invariant2(!this._ctx.disposed, "Closed", {
+      F: __dxlog_file2,
+      L: 160,
+      S: this,
+      A: [
+        "!this._ctx.disposed",
+        "'Closed'"
+      ]
+    });
+    await this._freezeTrigger.wait();
+    const remote = this._context.connections.get(recipient);
+    if (!remote) {
+      log2.warn("recipient is not subscribed for messages", {
+        author,
+        recipient
+      }, {
+        F: __dxlog_file2,
+        L: 166,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      return;
+    }
+    if (remote._ctx.disposed) {
+      log2.warn("recipient is disposed", {
+        author,
+        recipient
+      }, {
+        F: __dxlog_file2,
+        L: 171,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      return;
+    }
+    remote._freezeTrigger.wait().then(() => {
+      if (remote._ctx.disposed) {
+        log2.warn("recipient is disposed", {
+          author,
+          recipient
+        }, {
+          F: __dxlog_file2,
+          L: 179,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        return;
+      }
+      log2("receive message", {
+        author,
+        recipient,
+        ...dec(payload)
+      }, {
+        F: __dxlog_file2,
+        L: 183,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      remote.onMessage.emit({
+        author,
+        recipient,
+        payload
+      });
+    }).catch((err) => {
+      log2.error("error while waiting for freeze", {
+        err
+      }, {
+        F: __dxlog_file2,
+        L: 188,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    });
+  }
+  async subscribeMessages(peerInfo) {
+    log2("subscribing", {
+      peerInfo
+    }, {
+      F: __dxlog_file2,
+      L: 193,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    this._context.connections.set(peerInfo, this);
+  }
+  async unsubscribeMessages(peerInfo) {
+    log2("unsubscribing", {
+      peerInfo
+    }, {
+      F: __dxlog_file2,
+      L: 198,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    this._context.connections.delete(peerInfo);
+  }
+  freeze() {
+    this._freezeTrigger.reset();
+  }
+  unfreeze() {
+    this._freezeTrigger.wake();
+  }
+};
+var dec = (payload) => {
+  if (!payload.type_url.endsWith("ReliablePayload")) {
+    return {};
+  }
+  const relPayload = schema2.getCodecForType("dxos.mesh.messaging.ReliablePayload").decode(payload.value);
+  if (typeof relPayload?.payload?.data === "object") {
+    return {
+      payload: Object.keys(relPayload?.payload?.data)[0],
+      sessionId: relPayload?.payload?.sessionId
+    };
+  }
+  return {};
+};
+
+export {
+  Messenger,
+  PeerInfoHash,
+  MemorySignalManagerContext,
+  MemorySignalManager
+};
+//# sourceMappingURL=chunk-5MOQVHHI.mjs.map