@dxos/messaging 0.10.0 → 0.11.0

package/dist/lib/chunk-memory-signal-manager.mjs

@@ -0,0 +1,652 @@
+import { Event, TimeoutError, Trigger, 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 TimeoutError$1 } from "@dxos/protocols";
+import { schema } from "@dxos/protocols/proto";
+import { ComplexMap, ComplexSet } from "@dxos/util";
+import { trace } from "@dxos/tracing";
+//#region src/messenger-monitor.ts
+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
+		} });
+	}
+};
+//#endregion
+//#region src/timeouts.ts
+/**
+* Timeout for retrying messages.
+*/
+var MESSAGE_TIMEOUT = 1e4;
+//#endregion
+//#region src/messenger.ts
+var __dxlog_file$1 = "/__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;
+/**
+* Reliable messenger that works trough signal network.
+*/
+var Messenger = class {
+	_monitor = new MessengerMonitor();
+	_signalManager;
+	_listeners = new ComplexMap(({ peerId, payloadType }) => peerId + payloadType);
+	_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;
+		log("opening messenger", void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$1,
+			L: 71,
+			S: this
+		});
+		this._ctx = new Context({ onError: (err) => log.catch(err, void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$1,
+			L: 73,
+			S: this
+		}) }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$1,
+			L: 72
+		});
+		scheduleTaskInterval(this._ctx, async () => {
+			this._performGc();
+		}, RECEIVED_MESSAGES_GC_INTERVAL);
+		this._closed = false;
+		log("opened messenger", void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$1,
+			L: 86,
+			S: this
+		});
+	}
+	async close() {
+		if (this._closed) return;
+		this._closed = true;
+		await this._ctx.dispose();
+	}
+	async sendMessage(ctx, message) {
+		invariant(!this._closed, "Closed", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$1,
+			L: 102,
+			S: this,
+			A: ["!this._closed", "'Closed'"]
+		});
+		const { author, recipient, payload } = message;
+		invariant(recipient, "Recipient is required", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$1,
+			L: 105,
+			S: this,
+			A: ["recipient", "'Recipient is required'"]
+		});
+		const messageContext = this._ctx.derive();
+		const reliablePayload = {
+			messageId: PublicKey.random(),
+			payload
+		};
+		invariant(!this._onAckCallbacks.has(reliablePayload.messageId), void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$1,
+			L: 112,
+			S: this,
+			A: ["!this._onAckCallbacks.has(reliablePayload.messageId!)", ""]
+		});
+		log("send message", {
+			messageId: reliablePayload.messageId,
+			author,
+			recipient
+		}, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$1,
+			L: 113,
+			S: this
+		});
+		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 }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$1,
+				L: 128,
+				S: this
+			});
+			sendAttempts++;
+			await this._encodeAndSend(ctx, {
+				author,
+				recipient,
+				reliablePayload
+			}).catch((err) => log("failed to send message", { err }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$1,
+				L: 131,
+				S: this
+			}));
+		}, this._retryDelay);
+		scheduleTask(messageContext, () => {
+			log("message not delivered", { messageId: reliablePayload.messageId }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$1,
+				L: 140,
+				S: this
+			});
+			this._onAckCallbacks.delete(reliablePayload.messageId);
+			timeoutHit(new TimeoutError$1({
+				message: "signaling message not delivered",
+				cause: new TimeoutError(MESSAGE_TIMEOUT, "Message not delivered")
+			}));
+			messageContext.dispose();
+			this._monitor.recordReliableMessage({
+				sendAttempts,
+				sent: false
+			});
+		}, MESSAGE_TIMEOUT);
+		this._onAckCallbacks.set(reliablePayload.messageId, () => {
+			messageReceived();
+			this._onAckCallbacks.delete(reliablePayload.messageId);
+			messageContext.dispose();
+			this._monitor.recordReliableMessage({
+				sendAttempts,
+				sent: true
+			});
+		});
+		await this._encodeAndSend(ctx, {
+			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", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$1,
+			L: 178,
+			S: this,
+			A: ["!this._closed", "'Closed'"]
+		});
+		invariant(peer.peerKey, "Peer key is required", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$1,
+			L: 179,
+			S: this,
+			A: ["peer.peerKey", "'Peer key is required'"]
+		});
+		const peerKey = peer.peerKey;
+		const unsubscribe = await this._signalManager.subscribeMessages({
+			peer,
+			onMessage: (message) => {
+				if (this._closed) return;
+				log("received message", { from: message.author }, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$1,
+					L: 194,
+					S: this
+				});
+				this._handleMessage(message).catch((err) => log.catch(err, void 0, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$1,
+					L: 195,
+					S: this
+				}));
+			}
+		});
+		const clearDispose = this._ctx.onDispose(unsubscribe);
+		let listeners;
+		if (!payloadType) {
+			listeners = this._defaultListeners.get(peerKey);
+			if (!listeners) {
+				listeners = /* @__PURE__ */ new Set();
+				this._defaultListeners.set(peerKey, listeners);
+			}
+		} else {
+			listeners = this._listeners.get({
+				peerId: peerKey,
+				payloadType
+			});
+			if (!listeners) {
+				listeners = /* @__PURE__ */ new Set();
+				this._listeners.set({
+					peerId: peerKey,
+					payloadType
+				}, listeners);
+			}
+		}
+		listeners.add(onMessage);
+		return { unsubscribe: async () => {
+			clearDispose();
+			listeners.delete(onMessage);
+			await unsubscribe();
+		} };
+	}
+	async _encodeAndSend(ctx, { author, recipient, reliablePayload }) {
+		await this._signalManager.sendMessage(ctx, {
+			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(message) {
+		const { author, recipient, payload } = message;
+		invariant(payload.type_url === "dxos.mesh.messaging.ReliablePayload", void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$1,
+			L: 263,
+			S: this,
+			A: ["payload.type_url === 'dxos.mesh.messaging.ReliablePayload'", ""]
+		});
+		invariant(recipient, "Recipient is required", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$1,
+			L: 264,
+			S: this,
+			A: ["recipient", "'Recipient is required'"]
+		});
+		const reliablePayload = ReliablePayload.decode(payload.value, { preserveAny: true });
+		log("handling message", { messageId: reliablePayload.messageId }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$1,
+			L: 267,
+			S: this
+		});
+		try {
+			await this._sendAcknowledgement(this._ctx, {
+				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, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$1,
+			L: 295,
+			S: this,
+			A: ["payload.type_url === 'dxos.mesh.messaging.Acknowledgement'", ""]
+		});
+		this._onAckCallbacks.get(Acknowledgement.decode(payload.value).messageId)?.();
+	}
+	async _sendAcknowledgement(ctx, { author, recipient, messageId }) {
+		log("sending ACK", {
+			messageId,
+			from: recipient,
+			to: author
+		}, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$1,
+			L: 311,
+			S: this
+		});
+		await this._signalManager.sendMessage(ctx, {
+			author: recipient,
+			recipient: author,
+			payload: {
+				type_url: "dxos.mesh.messaging.Acknowledgement",
+				value: Acknowledgement.encode({ messageId })
+			}
+		});
+	}
+	async _callListeners(message) {
+		const { recipient } = message;
+		invariant(recipient?.peerKey, "Peer key is required", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$1,
+			L: 325,
+			S: this,
+			A: ["recipient?.peerKey", "'Peer key is required'"]
+		});
+		const peerKey = recipient.peerKey;
+		{
+			const defaultListenerMap = this._defaultListeners.get(peerKey);
+			if (defaultListenerMap) for (const listener of defaultListenerMap) await listener(message);
+		}
+		{
+			const listenerMap = this._listeners.get({
+				peerId: 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 }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$1,
+			L: 362,
+			S: this
+		});
+	}
+};
+//#endregion
+//#region src/signal-methods.ts
+var PeerInfoHash = ({ peerKey }) => peerKey;
+//#endregion
+//#region src/signal-manager/memory-signal-manager.ts
+var __dxlog_file = "/__w/dxos/dxos/packages/core/mesh/messaging/src/signal-manager/memory-signal-manager.ts";
+/**
+* Common signaling context that connects multiple MemorySignalManager instances.
+*/
+var MemorySignalManagerContext = class {
+	swarmEvent = new Event();
+	swarms = new ComplexMap(PublicKey.hash);
+	connections = new ComplexMap(PeerInfoHash);
+};
+/**
+* In memory signal manager for testing.
+*/
+var MemorySignalManager = class {
+	_context;
+	statusChanged = new Event();
+	swarmEvent = new Event();
+	/**
+	* Active message subscriptions on this manager. Routing is encapsulated here (DX-1125): a delivered
+	* message is dispatched to every subscription it matches.
+	*/
+	_subscriptions = /* @__PURE__ */ new Set();
+	/**  Will be used to emit SwarmEvents on .open() and .close() */
+	_joinedSwarms = new ComplexSet(({ topic, peer }) => topic.toHex() + peer.peerKey);
+	_ctx;
+	_freezeTrigger = new Trigger().wake();
+	constructor(_context) {
+		this._context = _context;
+		this._ctx = new Context(void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 75
+		});
+		this._ctx.onDispose(this._context.swarmEvent.on((data) => this.swarmEvent.emit(data)));
+	}
+	async open() {
+		if (!this._ctx.disposed) return;
+		this._ctx = new Context(void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 84
+		});
+		this._ctx.onDispose(this._context.swarmEvent.on((data) => this.swarmEvent.emit(data)));
+		await Promise.all([...this._joinedSwarms.values()].map((value) => this.join(this._ctx, value)));
+	}
+	async close() {
+		if (this._ctx.disposed) return;
+		const joinedSwarmsCopy = new ComplexSet(({ topic, peer }) => topic.toHex() + peer.peerKey, [...this._joinedSwarms.values()]);
+		await Promise.all([...this._joinedSwarms.values()].map((value) => this.leave(this._ctx, value)));
+		this._joinedSwarms = joinedSwarmsCopy;
+		await this._ctx.dispose();
+	}
+	getStatus() {
+		return [];
+	}
+	async join(_ctx, { topic, peer }) {
+		invariant(!this._ctx.disposed, "Closed", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 113,
+			S: this,
+			A: ["!this._ctx.disposed", "'Closed'"]
+		});
+		this._joinedSwarms.add({
+			topic,
+			peer
+		});
+		if (!this._context.swarms.has(topic)) this._context.swarms.set(topic, new ComplexSet(PeerInfoHash));
+		this._context.swarms.get(topic).add(peer);
+		this._context.swarmEvent.emit({
+			topic,
+			peerAvailable: {
+				peer,
+				since: /* @__PURE__ */ new Date()
+			}
+		});
+		for (const [topic, peers] of this._context.swarms) Array.from(peers).forEach((peer) => {
+			this.swarmEvent.emit({
+				topic,
+				peerAvailable: {
+					peer,
+					since: /* @__PURE__ */ new Date()
+				}
+			});
+		});
+	}
+	async leave(_ctx, { topic, peer }) {
+		invariant(!this._ctx.disposed, "Closed", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 145,
+			S: this,
+			A: ["!this._ctx.disposed", "'Closed'"]
+		});
+		this._joinedSwarms.delete({
+			topic,
+			peer
+		});
+		if (!this._context.swarms.has(topic)) this._context.swarms.set(topic, new ComplexSet(PeerInfoHash));
+		this._context.swarms.get(topic).delete(peer);
+		const swarmEvent = {
+			topic,
+			peerLeft: { peer }
+		};
+		this._context.swarmEvent.emit(swarmEvent);
+	}
+	async query(_ctx, request) {
+		throw new Error("Not implemented");
+	}
+	async sendMessage(_ctx, message) {
+		invariant(!this._ctx.disposed, "Closed", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 170,
+			S: this,
+			A: ["!this._ctx.disposed", "'Closed'"]
+		});
+		const { author, recipient, tags, payload } = message;
+		invariant(recipient == null !== !tags?.length, "Exactly one of `recipient` or `tags` must be set", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 173,
+			S: this,
+			A: ["(recipient == null) !== !tags?.length", "'Exactly one of `recipient` or `tags` must be set'"]
+		});
+		await this._freezeTrigger.wait();
+		if (recipient != null) {
+			log("send message", {
+				author,
+				recipient,
+				...dec(payload)
+			}, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 178,
+				S: this
+			});
+			const remote = this._context.connections.get(recipient);
+			if (!remote) {
+				log.warn("recipient is not subscribed for messages", {
+					author,
+					recipient
+				}, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file,
+					L: 181,
+					S: this
+				});
+				return;
+			}
+			remote._deliver(message);
+		} else {
+			log("broadcast message", {
+				author,
+				tags,
+				...dec(payload)
+			}, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 187,
+				S: this
+			});
+			for (const manager of new Set(this._context.connections.values())) manager._deliver(message);
+		}
+	}
+	async subscribeMessages({ peer, tags = [], onMessage }) {
+		invariant(!this._ctx.disposed, "Closed", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 195,
+			S: this,
+			A: ["!this._ctx.disposed", "'Closed'"]
+		});
+		log("subscribing", {
+			peer,
+			tags
+		}, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 196,
+			S: this
+		});
+		const subscription = {
+			peerKey: peer.peerKey,
+			tags: new Set(tags),
+			onMessage
+		};
+		this._subscriptions.add(subscription);
+		this._context.connections.set(peer, this);
+		return async () => {
+			log("unsubscribing", {
+				peer,
+				tags
+			}, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 202,
+				S: this
+			});
+			this._subscriptions.delete(subscription);
+			if (![...this._subscriptions].some((sub) => sub.peerKey === peer.peerKey)) this._context.connections.delete(peer);
+		};
+	}
+	freeze() {
+		this._freezeTrigger.reset();
+	}
+	unfreeze() {
+		this._freezeTrigger.wake();
+	}
+	/**
+	* Route a delivered message to this manager's matching subscriptions once it is unfrozen and open.
+	*/
+	_deliver(message) {
+		if (this._ctx.disposed) {
+			log.warn("recipient is disposed", { message }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 224,
+				S: this
+			});
+			return;
+		}
+		this._freezeTrigger.wait().then(() => {
+			if (this._ctx.disposed) {
+				log.warn("recipient is disposed", { message }, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file,
+					L: 232,
+					S: this
+				});
+				return;
+			}
+			log("receive message", {
+				author: message.author,
+				recipient: message.recipient,
+				...dec(message.payload)
+			}, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 236,
+				S: this
+			});
+			for (const subscription of this._subscriptions) if (message.recipient != null) {
+				if (subscription.peerKey === message.recipient.peerKey) subscription.onMessage(message);
+			} else if (message.tags?.some((tag) => subscription.tags.has(tag))) subscription.onMessage(message);
+		}).catch((err) => {
+			log.error("error while waiting for freeze", { err }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 248,
+				S: this
+			});
+		});
+	}
+};
+var dec = (payload) => {
+	if (!payload.type_url.endsWith("ReliablePayload")) return {};
+	const relPayload = schema.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 {};
+};
+//#endregion
+export { Messenger as i, MemorySignalManagerContext as n, PeerInfoHash as r, MemorySignalManager as t };
+
+//# sourceMappingURL=chunk-memory-signal-manager.mjs.map