@dxos/messaging 0.8.4-main.ae835ea → 0.8.4-main.bc2380dfbc

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

@@ -14,7 +14,6 @@ import { type QueryRequest } from '@dxos/protocols/proto/dxos/edge/signal';
 import { ComplexMap, ComplexSet } from '@dxos/util';
 
 import { type Message, type PeerInfo, PeerInfoHash, type SignalStatus, type SwarmEvent } from '../signal-methods';
-
 import { type SignalManager } from './signal-manager';
 
 /**
@@ -63,7 +62,7 @@ export class MemorySignalManager implements SignalManager {
     this._ctx = new Context();
     this._ctx.onDispose(this._context.swarmEvent.on((data) => this.swarmEvent.emit(data)));
 
-    await Promise.all([...this._joinedSwarms.values()].map((value) => this.join(value)));
+    await Promise.all([...this._joinedSwarms.values()].map((value) => this.join(this._ctx, value)));
   }
 
   async close(): Promise<void> {
@@ -76,7 +75,7 @@ export class MemorySignalManager implements SignalManager {
       [...this._joinedSwarms.values()],
     );
 
-    await Promise.all([...this._joinedSwarms.values()].map((value) => this.leave(value)));
+    await Promise.all([...this._joinedSwarms.values()].map((value) => this.leave(this._ctx, value)));
 
     // assign joined swarms back because .leave() deletes it.
     this._joinedSwarms = joinedSwarmsCopy;
@@ -88,7 +87,7 @@ export class MemorySignalManager implements SignalManager {
     return [];
   }
 
-  async join({ topic, peer }: { topic: PublicKey; peer: PeerInfo }): Promise<void> {
+  async join(_ctx: Context, { topic, peer }: { topic: PublicKey; peer: PeerInfo }): Promise<void> {
     invariant(!this._ctx.disposed, 'Closed');
 
     this._joinedSwarms.add({ topic, peer });
@@ -120,7 +119,7 @@ export class MemorySignalManager implements SignalManager {
     }
   }
 
-  async leave({ topic, peer }: { topic: PublicKey; peer: PeerInfo }): Promise<void> {
+  async leave(_ctx: Context, { topic, peer }: { topic: PublicKey; peer: PeerInfo }): Promise<void> {
     invariant(!this._ctx.disposed, 'Closed');
 
     this._joinedSwarms.delete({ topic, peer });
@@ -141,19 +140,22 @@ export class MemorySignalManager implements SignalManager {
     this._context.swarmEvent.emit(swarmEvent);
   }
 
-  async query(request: QueryRequest): Promise<SwarmResponse> {
+  async query(_ctx: Context, request: QueryRequest): Promise<SwarmResponse> {
     throw new Error('Not implemented');
   }
 
-  async sendMessage({
-    author,
-    recipient,
-    payload,
-  }: {
-    author: PeerInfo;
-    recipient: PeerInfo;
-    payload: Any;
-  }): Promise<void> {
+  async sendMessage(
+    _ctx: Context,
+    {
+      author,
+      recipient,
+      payload,
+    }: {
+      author: PeerInfo;
+      recipient: PeerInfo;
+      payload: Any;
+    },
+  ): Promise<void> {
     log('send message', { author, recipient, ...dec(payload) });
 
     invariant(recipient);

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

@@ -5,12 +5,12 @@
 import { afterAll, beforeAll, describe, test } from 'vitest';
 
 import { asyncTimeout, sleep } from '@dxos/async';
+import { Context } from '@dxos/context';
 import { PublicKey } from '@dxos/keys';
 import { type SignalServerRunner, runTestSignalServer } from '@dxos/signal';
 import { openAndClose } from '@dxos/test-utils';
 
 import { createMessage, expectPeerAvailable, expectReceivedMessage } from '../testing';
-
 import { WebsocketSignalManager } from './websocket-signal-manager';
 
 describe.skip('WebSocketSignalManager', () => {
@@ -40,9 +40,9 @@ describe.skip('WebSocketSignalManager', () => {
     const joined21 = expectPeerAvailable(client2, topic, { peerKey: peer1.toHex() });
     const joined31 = expectPeerAvailable(client3, topic, { peerKey: peer1.toHex() });
 
-    await client1.join({ topic, peer: { peerKey: peer1.toHex() } });
-    await client2.join({ topic, peer: { peerKey: peer2.toHex() } });
-    await client3.join({ topic, peer: { peerKey: peer3.toHex() } });
+    await client1.join(Context.default(), { topic, peer: { peerKey: peer1.toHex() } });
+    await client2.join(Context.default(), { topic, peer: { peerKey: peer2.toHex() } });
+    await client3.join(Context.default(), { topic, peer: { peerKey: peer3.toHex() } });
 
     await Promise.all([joined12, joined13, joined21, joined31]);
   });
@@ -57,8 +57,8 @@ describe.skip('WebSocketSignalManager', () => {
     const joined12 = expectPeerAvailable(client1, topic, { peerKey: peer2.toHex() });
     const joined21 = expectPeerAvailable(client2, topic, { peerKey: peer1.toHex() });
 
-    await client1.join({ topic, peer: { peerKey: peer1.toHex() } });
-    await client2.join({ topic, peer: { peerKey: peer2.toHex() } });
+    await client1.join(Context.default(), { topic, peer: { peerKey: peer1.toHex() } });
+    await client2.join(Context.default(), { topic, peer: { peerKey: peer2.toHex() } });
 
     await asyncTimeout(Promise.all([joined12, joined21]), 1_000);
 
@@ -67,7 +67,7 @@ describe.skip('WebSocketSignalManager', () => {
     const received = expectReceivedMessage(client2.onMessage, message);
     await client2.subscribeMessages({ peerKey: peer2.toHex() });
     await sleep(50);
-    await client1.sendMessage(message);
+    await client1.sendMessage(Context.default(), message);
 
     await asyncTimeout(received, 1_000);
   });
@@ -82,8 +82,8 @@ describe.skip('WebSocketSignalManager', () => {
     const joined12 = expectPeerAvailable(client1, topic, { peerKey: peer2.toHex() });
     const joined21 = expectPeerAvailable(client2, topic, { peerKey: peer1.toHex() });
 
-    await client1.join({ topic, peer: { peerKey: peer1.toHex() } });
-    await client2.join({ topic, peer: { peerKey: peer2.toHex() } });
+    await client1.join(Context.default(), { topic, peer: { peerKey: peer1.toHex() } });
+    await client2.join(Context.default(), { topic, peer: { peerKey: peer2.toHex() } });
 
     await Promise.all([joined12, joined21]);
   });
@@ -98,15 +98,15 @@ describe.skip('WebSocketSignalManager', () => {
     const joined112 = expectPeerAvailable(client1, topic1, { peerKey: peer2.toHex() });
     const joined121 = expectPeerAvailable(client2, topic1, { peerKey: peer1.toHex() });
 
-    await client1.join({ topic: topic1, peer: { peerKey: peer1.toHex() } });
-    await client2.join({ topic: topic1, peer: { peerKey: peer2.toHex() } });
+    await client1.join(Context.default(), { topic: topic1, peer: { peerKey: peer1.toHex() } });
+    await client2.join(Context.default(), { topic: topic1, peer: { peerKey: peer2.toHex() } });
     await Promise.all([joined112, joined121]);
 
     const joined212 = expectPeerAvailable(client1, topic2, { peerKey: peer2.toHex() });
     const joined221 = expectPeerAvailable(client2, topic2, { peerKey: peer1.toHex() });
 
-    await client1.join({ topic: topic2, peer: { peerKey: peer1.toHex() } });
-    await client2.join({ topic: topic2, peer: { peerKey: peer2.toHex() } });
+    await client1.join(Context.default(), { topic: topic2, peer: { peerKey: peer1.toHex() } });
+    await client2.join(Context.default(), { topic: topic2, peer: { peerKey: peer2.toHex() } });
     await Promise.all([joined212, joined221]);
   });
 });

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

@@ -3,11 +3,10 @@
 //
 
 import { Event, sleep, synchronized } from '@dxos/async';
-import { LifecycleState, Resource } from '@dxos/context';
+import { type Context, LifecycleState, Resource } from '@dxos/context';
 import { invariant } from '@dxos/invariant';
-import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
-import { RateLimitExceededError, TimeoutError, trace } from '@dxos/protocols';
+import { RateLimitExceededError, TimeoutError } from '@dxos/protocols';
 import { type Runtime } from '@dxos/protocols/proto/dxos/config';
 import { type SwarmResponse } from '@dxos/protocols/proto/dxos/edge/messenger';
 import { type JoinRequest, type LeaveRequest, type QueryRequest } from '@dxos/protocols/proto/dxos/edge/signal';
@@ -22,7 +21,6 @@ import {
   type SignalStatus,
   type SwarmEvent,
 } from '../signal-methods';
-
 import { type SignalManager } from './signal-manager';
 import { WebsocketSignalManagerMonitor } from './websocket-signal-manager-monitor';
 
@@ -49,8 +47,6 @@ export class WebsocketSignalManager extends Resource implements SignalManager {
 
   readonly onMessage = new Event<Message>();
 
-  private readonly _instanceId = PublicKey.random().toHex();
-
   constructor(
     private readonly _hosts: Runtime.Services.Signal[],
     private readonly _getMetadata?: () => any,
@@ -77,11 +73,8 @@ export class WebsocketSignalManager extends Resource implements SignalManager {
 
   protected override async _open(): Promise<void> {
     log('open signal manager', { hosts: this._hosts });
-    log.trace('dxos.mesh.websocket-signal-manager.open', trace.begin({ id: this._instanceId }));
 
     await safeAwaitAll(this._servers.values(), (server) => server.open());
-
-    log.trace('dxos.mesh.websocket-signal-manager.open', trace.end({ id: this._instanceId }));
   }
 
   protected override async _close(): Promise<void> {
@@ -105,30 +98,30 @@ export class WebsocketSignalManager extends Resource implements SignalManager {
   }
 
   @synchronized
-  async join({ topic, peer }: JoinRequest): Promise<void> {
+  async join(_ctx: Context, { topic, peer }: JoinRequest): Promise<void> {
     log('join', { topic, peer });
     invariant(this._lifecycleState === LifecycleState.OPEN);
-    await this._forEachServer((server) => server.join({ topic, peer }));
+    await this._forEachServer((server) => server.join(_ctx, { topic, peer }));
   }
 
   @synchronized
-  async leave({ topic, peer }: LeaveRequest): Promise<void> {
+  async leave(_ctx: Context, { topic, peer }: LeaveRequest): Promise<void> {
     log('leaving', { topic, peer });
     invariant(this._lifecycleState === LifecycleState.OPEN);
-    await this._forEachServer((server) => server.leave({ topic, peer }));
+    await this._forEachServer((server) => server.leave(_ctx, { topic, peer }));
   }
 
-  async query({ topic }: QueryRequest): Promise<SwarmResponse> {
+  async query(_ctx: Context, { topic }: QueryRequest): Promise<SwarmResponse> {
     throw new Error('Not implemented');
   }
 
-  async sendMessage({ author, recipient, payload }: Message): Promise<void> {
+  async sendMessage(_ctx: Context, { author, recipient, payload }: Message): Promise<void> {
     log('signal', { recipient });
     invariant(this._lifecycleState === LifecycleState.OPEN);
 
     void this._forEachServer(async (server, serverName, index) => {
       void server
-        .sendMessage({ author, recipient, payload })
+        .sendMessage(_ctx, { author, recipient, payload })
         .then(() => this._clearServerFailedFlag(serverName, index))
         .catch((err) => {
           if (err instanceof RateLimitExceededError) {

package/src/signal-methods.ts

@@ -3,7 +3,7 @@
 //
 
 import { type Event } from '@dxos/async';
-import { type Lifecycle } from '@dxos/context';
+import { type Context, type Lifecycle } from '@dxos/context';
 import { type Peer, type SwarmResponse } from '@dxos/protocols/proto/dxos/edge/messenger';
 import {
   type JoinRequest,
@@ -51,22 +51,22 @@ export interface SignalMethods {
   /**
    * Join topic on signal network, to be discoverable by other peers.
    */
-  join: (params: JoinRequest) => Promise<void>;
+  join: (ctx: Context, params: JoinRequest) => Promise<void>;
 
   /**
    * Leave topic on signal network, to stop being discoverable by other peers.
    */
-  leave: (params: LeaveRequest) => Promise<void>;
+  leave: (ctx: Context, params: LeaveRequest) => Promise<void>;
 
   /**
    * Query peers in the swarm without joining it.
    */
-  query: (params: QueryRequest) => Promise<SwarmResponse>;
+  query: (ctx: Context, params: QueryRequest) => Promise<SwarmResponse>;
 
   /**
    * Send message to peer.
    */
-  sendMessage: (message: Message) => Promise<void>;
+  sendMessage: (ctx: Context, message: Message) => Promise<void>;
 
   /**
    * Start receiving messages from peer.

package/src/testing/test-builder.ts

@@ -2,9 +2,10 @@
 // Copyright 2022 DXOS.org
 //
 
+import { type Context } from '@dxos/context';
+
 import { MemorySignalManager, MemorySignalManagerContext, type SignalManager } from '../signal-manager';
 import { type Message } from '../signal-methods';
-
 import { TestPeer } from './test-peer';
 
 export type TestBuilderOptions = {
@@ -25,9 +26,9 @@ export class TestBuilder {
     if (this.options.messageDisruption) {
       // Imitates signal network disruptions (e. g. message doubling, ).
       const trueSend = signalManager.sendMessage.bind(signalManager);
-      signalManager.sendMessage = async (message: Message) => {
+      signalManager.sendMessage = async (ctx: Context, message: Message) => {
         for (const msg of this.options.messageDisruption!(message)) {
-          await trueSend(msg);
+          await trueSend(ctx, msg);
         }
       };
     }

package/src/testing/test-peer.ts

@@ -12,7 +12,6 @@ import { buf } from '@dxos/protocols/buf';
 import { Messenger } from '../messenger';
 import { type SignalManager } from '../signal-manager';
 import { type Message, type PeerInfo } from '../signal-methods';
-
 import { type TestBuilder } from './test-builder';
 import { expectPeerAvailable, expectPeerLeft, expectReceivedMessage } from './utils';
 

package/src/testing/utils.ts

@@ -7,7 +7,6 @@ import { type Any } from '@dxos/codec-protobuf';
 import { PublicKey } from '@dxos/keys';
 
 import { type Message, type PeerInfo, type SignalMethods } from '../signal-methods';
-
 import { PAYLOAD_1 } from './test-messages';
 
 export const expectPeerAvailable = (client: SignalMethods, expectedTopic: PublicKey, peer: PeerInfo) =>