@dxos/messaging 0.8.4-main.b97322e → 0.8.4-main.bcb3aa67d6

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

@@ -3,25 +3,26 @@
 //
 
 import { Event, scheduleMicroTask } from '@dxos/async';
-import { cancelWithContext, Resource } 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';
 import { EdgeService } from '@dxos/protocols';
 import { type buf, bufWkt } from '@dxos/protocols/buf';
 import {
-  SwarmRequestSchema,
-  SwarmRequest_Action as SwarmRequestAction,
-  SwarmResponseSchema,
   type Message as EdgeMessage,
   type PeerSchema,
+  SwarmRequest_Action as SwarmRequestAction,
+  SwarmRequestSchema,
+  SwarmResponseSchema,
 } from '@dxos/protocols/buf/dxos/edge/messenger_pb';
 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';
-import { type PeerInfo, type Message, type SwarmEvent, PeerInfoHash } from '../signal-methods';
 
 export class EdgeSignalManager extends Resource implements SignalManager {
   /**
@@ -59,7 +60,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', {
@@ -76,6 +77,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),
@@ -84,24 +86,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, {
@@ -115,7 +128,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', {
@@ -125,6 +138,7 @@ export class EdgeSignalManager extends Resource implements SignalManager {
     }
 
     await this._edgeConnection.send(
+      ctx,
       protocol.createMessage(bufWkt.AnySchema, {
         serviceId: EdgeService.SIGNAL,
         source: message.author,
@@ -218,7 +232,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

@@ -13,8 +13,9 @@ import { type SwarmResponse } from '@dxos/protocols/proto/dxos/edge/messenger';
 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';
-import { type SwarmEvent, type PeerInfo, type SignalStatus, type Message, PeerInfoHash } from '../signal-methods';
 
 /**
  * Common signaling context that connects multiple MemorySignalManager instances.
@@ -62,7 +63,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> {
@@ -75,7 +76,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;
@@ -87,7 +88,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 });
@@ -119,7 +120,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 });
@@ -140,19 +141,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/signal-manager.ts

@@ -5,7 +5,7 @@
 import { type Event } from '@dxos/async';
 import { type Lifecycle } from '@dxos/context';
 
-import { type SignalStatus, type SignalMethods } from '../signal-methods';
+import { type SignalMethods, type SignalStatus } from '../signal-methods';
 
 /**
  * Manages a collection of signaling clients.

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

@@ -5,13 +5,15 @@
 import { afterAll, beforeAll, describe, test } from 'vitest';
 
 import { asyncTimeout, sleep } from '@dxos/async';
+import { Context } from '@dxos/context';
 import { PublicKey } from '@dxos/keys';
-import { runTestSignalServer, type SignalServerRunner } from '@dxos/signal';
+import { type SignalServerRunner, runTestSignalServer } from '@dxos/signal';
 import { openAndClose } from '@dxos/test-utils';
 
-import { WebsocketSignalManager } from './websocket-signal-manager';
 import { createMessage, expectPeerAvailable, expectReceivedMessage } from '../testing';
 
+import { WebsocketSignalManager } from './websocket-signal-manager';
+
 describe.skip('WebSocketSignalManager', () => {
   let broker1: SignalServerRunner;
   let broker2: SignalServerRunner;
@@ -39,9 +41,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]);
   });
@@ -56,8 +58,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);
 
@@ -66,7 +68,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);
   });
@@ -81,8 +83,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]);
   });
@@ -97,15 +99,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,7 +3,7 @@
 //
 
 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';
@@ -13,18 +13,19 @@ import { type SwarmResponse } from '@dxos/protocols/proto/dxos/edge/messenger';
 import { type JoinRequest, type LeaveRequest, type QueryRequest } from '@dxos/protocols/proto/dxos/edge/signal';
 import { BitField, safeAwaitAll } from '@dxos/util';
 
-import { type SignalManager } from './signal-manager';
-import { WebsocketSignalManagerMonitor } from './websocket-signal-manager-monitor';
 import { SignalClient } from '../signal-client';
 import {
-  type PeerInfo,
   type Message,
+  type PeerInfo,
   type SignalClientMethods,
   type SignalMethods,
   type SignalStatus,
   type SwarmEvent,
 } from '../signal-methods';
 
+import { type SignalManager } from './signal-manager';
+import { WebsocketSignalManagerMonitor } from './websocket-signal-manager-monitor';
+
 const MAX_SERVER_FAILURES = 5;
 const WSS_SIGNAL_SERVER_REBOOT_DELAY = 3_000;
 
@@ -104,30 +105,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,14 +3,14 @@
 //
 
 import { type Event } from '@dxos/async';
-import { type Lifecycle } from '@dxos/context';
-import { type SwarmResponse, type Peer } from '@dxos/protocols/proto/dxos/edge/messenger';
+import { type Context, type Lifecycle } from '@dxos/context';
+import { type Peer, type SwarmResponse } from '@dxos/protocols/proto/dxos/edge/messenger';
 import {
+  type JoinRequest,
   type LeaveRequest,
   type Message,
-  type SwarmEvent,
-  type JoinRequest,
   type QueryRequest,
+  type SwarmEvent,
 } from '@dxos/protocols/proto/dxos/edge/signal';
 import { type SignalState } from '@dxos/protocols/proto/dxos/mesh/signal';
 
@@ -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,10 +2,13 @@
 // Copyright 2022 DXOS.org
 //
 
-import { TestPeer } from './test-peer';
-import { type SignalManager, MemorySignalManager, MemorySignalManagerContext } from '../signal-manager';
+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 = {
   signalManagerFactory?: (peer: TestPeer) => Promise<SignalManager>;
   messageDisruption?: (msg: Message) => Message[];
@@ -24,9 +27,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

@@ -9,12 +9,13 @@ import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { buf } from '@dxos/protocols/buf';
 
-import { type TestBuilder } from './test-builder';
-import { expectPeerAvailable, expectPeerLeft, expectReceivedMessage } from './utils';
 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';
+
 export class TestPeer extends Resource {
   public peerId = PublicKey.random();
   public signalManager!: SignalManager;

package/src/testing/utils.ts

@@ -2,12 +2,13 @@
 // Copyright 2022 DXOS.org
 //
 
-import { asyncTimeout, type Event } from '@dxos/async';
+import { type Event, asyncTimeout } from '@dxos/async';
 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';
-import { type SignalMethods, type Message, type PeerInfo } from '../signal-methods';
 
 export const expectPeerAvailable = (client: SignalMethods, expectedTopic: PublicKey, peer: PeerInfo) =>
   asyncTimeout(