@dxos/messaging 0.8.4-main.dedc0f3 → 0.8.4-main.dfabb4ec29

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

@@ -3,8 +3,8 @@
 //
 
 import { Event, scheduleMicroTask } from '@dxos/async';
-import { Resource, cancelWithContext } from '@dxos/context';
-import { type EdgeConnection, protocol } from '@dxos/edge-client';
+import { type Context, Resource, cancelWithContext } from '@dxos/context';
+import { type EdgeConnection, EdgeIdentityChangedError, protocol } from '@dxos/edge-client';
 import { invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
@@ -21,7 +21,6 @@ import { type SwarmResponse } from '@dxos/protocols/proto/dxos/edge/messenger';
 import { ComplexMap, ComplexSet } from '@dxos/util';
 
 import { type Message, type PeerInfo, PeerInfoHash, type SwarmEvent } from '../signal-methods';
-
 import { type SignalManager } from './signal-manager';
 
 export class EdgeSignalManager extends Resource implements SignalManager {
@@ -60,7 +59,7 @@ export class EdgeSignalManager extends Resource implements SignalManager {
   /**
    * Warning: PeerInfo is inferred from edgeConnection.
    */
-  async join({ topic, peer }: { topic: PublicKey; peer: PeerInfo }): Promise<void> {
+  async join(ctx: Context, { topic, peer }: { topic: PublicKey; peer: PeerInfo }): Promise<void> {
     if (!this._matchSelfPeerInfo(peer)) {
       // NOTE: Could only join swarm with the same peer info as the edge connection.
       log.warn('ignoring peer info on join request', {
@@ -77,6 +76,7 @@ export class EdgeSignalManager extends Resource implements SignalManager {
 
     this._swarmPeers.set(topic, { lastState: peer.state, joinedPeers: new ComplexSet<PeerInfo>(PeerInfoHash) });
     await this._edgeConnection.send(
+      ctx,
       protocol.createMessage(SwarmRequestSchema, {
         serviceId: EdgeService.SWARM,
         source: createMessageSource(topic, peer),
@@ -85,24 +85,35 @@ export class EdgeSignalManager extends Resource implements SignalManager {
     );
   }
 
-  async leave({ topic, peer }: { topic: PublicKey; peer: PeerInfo }): Promise<void> {
+  async leave(ctx: Context, { topic, peer }: { topic: PublicKey; peer: PeerInfo }): Promise<void> {
     this._swarmPeers.delete(topic);
-    await this._edgeConnection.send(
-      protocol.createMessage(SwarmRequestSchema, {
-        serviceId: EdgeService.SWARM,
-        source: createMessageSource(topic, peer),
-        payload: { action: SwarmRequestAction.LEAVE, swarmKeys: [topic.toHex()] },
-      }),
-    );
+    try {
+      await this._edgeConnection.send(
+        ctx,
+        protocol.createMessage(SwarmRequestSchema, {
+          serviceId: EdgeService.SWARM,
+          source: createMessageSource(topic, peer),
+          payload: { action: SwarmRequestAction.LEAVE, swarmKeys: [topic.toHex()] },
+        }),
+      );
+    } catch (err) {
+      if (err instanceof EdgeIdentityChangedError) {
+        // Note: On edge identity change, the connection is closed and EDGE will remove us from the swarm.
+        //       So we should just delete the swarm from _swarmPeers.
+        return;
+      }
+      throw err;
+    }
   }
 
-  async query({ topic }: { topic: PublicKey }): Promise<SwarmResponse> {
+  async query(ctx: Context, { topic }: { topic: PublicKey }): Promise<SwarmResponse> {
     const response = cancelWithContext(
       this._ctx,
       this.swarmState.waitFor((state) => state.swarmKey === topic.toHex()),
     );
 
     await this._edgeConnection.send(
+      ctx,
       protocol.createMessage(SwarmRequestSchema, {
         serviceId: EdgeService.SWARM,
         source: createMessageSource(topic, {
@@ -116,7 +127,7 @@ export class EdgeSignalManager extends Resource implements SignalManager {
     return response;
   }
 
-  async sendMessage(message: Message): Promise<void> {
+  async sendMessage(ctx: Context, message: Message): Promise<void> {
     if (!this._matchSelfPeerInfo(message.author)) {
       // NOTE: Could only join swarm with the same peer info as the edge connection.
       log.warn('ignoring author on send request', {
@@ -126,6 +137,7 @@ export class EdgeSignalManager extends Resource implements SignalManager {
     }
 
     await this._edgeConnection.send(
+      ctx,
       protocol.createMessage(bufWkt.AnySchema, {
         serviceId: EdgeService.SIGNAL,
         source: message.author,
@@ -219,7 +231,7 @@ export class EdgeSignalManager extends Resource implements SignalManager {
   private async _rejoinAllSwarms(): Promise<void> {
     log('rejoin swarms', { swarms: Array.from(this._swarmPeers.keys()) });
     for (const [topic, { lastState }] of this._swarmPeers.entries()) {
-      await this.join({
+      await this.join(this._ctx, {
         topic,
         peer: {
           peerKey: this._edgeConnection.peerKey,

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) =>