@dxos/messaging 0.6.8-main.3be982f → 0.6.8-staging.77f93a3

package/src/signal-client/signal-client.test.ts

@@ -5,8 +5,8 @@
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 import { expect } from 'earljs';
 
-import { Trigger, asyncTimeout, waitForCondition } from '@dxos/async';
-import { type TaggedType } from '@dxos/codec-protobuf';
+import { asyncTimeout, waitForCondition } from '@dxos/async';
+import { type Any, type TaggedType } from '@dxos/codec-protobuf';
 import { PublicKey } from '@dxos/keys';
 import { type TYPES } from '@dxos/protocols';
 import { runTestSignalServer, type SignalServerRunner } from '@dxos/signal';
@@ -14,10 +14,11 @@ import { afterAll, beforeAll, describe, test, afterTest } from '@dxos/test';
 import { ComplexSet, range } from '@dxos/util';
 
 import { SignalClient } from './signal-client';
+import { type Message, type PeerInfo } from '../signal-methods';
 
 const PAYLOAD: TaggedType<TYPES, 'google.protobuf.Any'> = {
   '@type': 'google.protobuf.Any',
-  type_url: 'dxos.Example',
+  type_url: 'google.protobuf.Any',
   value: Buffer.from('1'),
 };
 
@@ -35,70 +36,76 @@ describe('SignalClient', () => {
   test('message between 2 clients', async () => {
     const [peer1, peer2] = setupPeers({ peerCount: 2 });
 
-    await peer1.client.subscribeMessages(peer1.id);
-    await waitForSubscription(peer1.client, peer1.id);
+    await peer1.client.subscribeMessages(peer1.peerInfo);
+    await waitForSubscription(peer1.client, peer1.peerKey);
 
     const message = createMessage(peer2, peer1);
+    const receivedMessage = peer1.waitForNextMessage();
     await peer2.client.sendMessage(message);
-    expect(await peer1.waitForNextMessage()).toEqual(message);
-  }).timeout(500);
+    expect(await receivedMessage).toEqual(message);
+  });
 
   test('join', async () => {
     const topic = PublicKey.random();
     const [peer1, peer2] = setupPeers({ peerCount: 2 });
 
-    await peer1.client.join({ topic, peerId: peer1.id });
-    await peer2.client.join({ topic, peerId: peer2.id });
+    await peer1.client.join({ topic, peer: peer1.peerInfo });
+    await peer2.client.join({ topic, peer: peer2.peerInfo });
 
-    await peer1.waitForPeer(peer2.id);
-    await peer2.waitForPeer(peer1.id);
-  }).timeout(500);
+    await peer1.waitForPeer(peer2.peerKey);
+    await peer2.waitForPeer(peer1.peerKey);
+  });
 
   test('signal to self', async () => {
     const [peer1, peer2] = setupPeers({ peerCount: 2 });
 
-    await peer1.client.subscribeMessages(peer1.id);
-    await waitForSubscription(peer1.client, peer1.id);
+    await peer1.client.subscribeMessages(peer1.peerInfo);
+    await waitForSubscription(peer1.client, peer1.peerKey);
 
     const message = createMessage(peer2, peer1);
+    const receivedMessage = peer1.waitForNextMessage();
+
     await peer1.client.sendMessage(message);
-    expect(await peer1.waitForNextMessage()).toEqual(message);
-  }).timeout(500);
+    expect(await receivedMessage).toEqual(message);
+  });
 
   test('unsubscribe from messages', async () => {
     const [peer1, peer2] = setupPeers({ peerCount: 2 });
 
-    await peer1.client.subscribeMessages(peer1.id);
-    await peer2.client.subscribeMessages(peer2.id);
-    await waitForSubscription(peer1.client, peer1.id);
+    await peer1.client.subscribeMessages(peer1.peerInfo);
+    await peer2.client.subscribeMessages(peer2.peerInfo);
+    await waitForSubscription(peer1.client, peer1.peerKey);
 
     const message = createMessage(peer2, peer1);
 
     {
+      const receivedMessage = peer1.waitForNextMessage();
       await peer2.client.sendMessage(message);
-      expect(await peer1.waitForNextMessage()).toEqual(message);
+      expect(await receivedMessage).toEqual(message);
     }
 
     // unsubscribing.
-    await peer1.client.unsubscribeMessages(peer1.id);
+    await peer1.client.unsubscribeMessages(peer1.peerInfo);
 
     {
+      const receivedMessage = peer1.waitForNextMessage({ timeout: 200 });
       await peer2.client.sendMessage(message);
-      await expect(peer1.waitForNextMessage({ timeout: 200 })).toBeRejected();
+      await expect(receivedMessage).toBeRejected();
     }
-  }).timeout(1_500);
+  });
 
   test('signal after re-entrance', async () => {
     const [peer1, peer2] = setupPeers({ peerCount: 2 });
 
     const message = createMessage(peer2, peer1);
 
-    await peer1.client.subscribeMessages(peer1.id);
-    await waitForSubscription(peer1.client, peer1.id);
+    await peer1.client.subscribeMessages(peer1.peerInfo);
+    await waitForSubscription(peer1.client, peer1.peerKey);
 
     {
+      const waitMessage = peer1.waitForNextMessage();
       await peer2.client.sendMessage(message);
-      expect(await peer1.waitForNextMessage()).toEqual(message);
+      expect(await waitMessage).toEqual(message);
     }
 
     //
@@ -107,30 +114,26 @@ describe('SignalClient', () => {
 
     await peer1.client.close();
     await peer1.client.open();
-    await waitForSubscription(peer1.client, peer1.id);
+    await waitForSubscription(peer1.client, peer1.peerKey);
 
     {
+      const waitMessage = peer1.waitForNextMessage();
       await peer2.client.sendMessage(message);
-      expect(await peer1.waitForNextMessage()).toEqual(message);
+      expect(await waitMessage).toEqual(message);
     }
-  }).timeout(1_000);
+  });
 
   const setupPeers = (options?: { broker?: SignalServerRunner; peerCount?: number }): TestPeer[] => {
     return range(options?.peerCount ?? 1, () => {
       const peers = new ComplexSet(PublicKey.hash);
-      let nextMessage: any | null = null;
-      const nextMessageTrigger = new Trigger();
-      const id = PublicKey.random();
+      const peerKey = PublicKey.random();
+      const identityKey = PublicKey.random();
       const client = new SignalClient((options?.broker ?? broker1).url());
-      client.onMessage.on(async (msg) => {
-        nextMessage = msg;
-        nextMessageTrigger.wake();
-      });
-      client.swarmEvent.on(async ({ swarmEvent }) => {
+      client.swarmEvent.on(async (swarmEvent) => {
         if (swarmEvent.peerAvailable) {
-          peers.add(PublicKey.from(swarmEvent.peerAvailable.peer));
+          peers.add(PublicKey.from(swarmEvent.peerAvailable.peer.peerKey));
         } else if (swarmEvent.peerLeft) {
-          peers.delete(PublicKey.from(swarmEvent.peerLeft.peer));
+          peers.delete(PublicKey.from(swarmEvent.peerLeft.peer.peerKey));
         }
       });
 
@@ -139,26 +142,25 @@ describe('SignalClient', () => {
         await client.close();
       });
       return {
-        id,
+        peerKey,
+        identityKey,
         client,
-        waitForNextMessage: async (options?: { timeout?: number }) => {
-          if (nextMessage == null) {
-            await nextMessageTrigger.wait(options);
-          }
-          const result = nextMessage!;
-          nextMessageTrigger.reset();
-          nextMessage = null;
-          return result;
+        peerInfo: { peerKey: peerKey.toHex(), identityKey: identityKey.toHex() },
+        waitForNextMessage: async () => {
+          return asyncTimeout(
+            client.onMessage.waitFor(() => true),
+            5000,
+          );
         },
         waitForPeer: (peerId: PublicKey) => waitForCondition({ condition: () => peers.has(peerId) }),
       };
     });
   };
 
-  const createMessage = (from: TestPeer, to: TestPeer, payload: any = PAYLOAD) => {
+  const createMessage = (from: TestPeer, to: TestPeer, payload: Any = PAYLOAD): Message => {
     return {
-      author: from.id,
-      recipient: to.id,
+      author: { peerKey: from.peerKey.toHex() },
+      recipient: { peerKey: to.peerKey.toHex() },
       payload: PAYLOAD,
     };
   };
@@ -172,8 +174,10 @@ describe('SignalClient', () => {
 });
 
 interface TestPeer {
-  id: PublicKey;
+  peerKey: PublicKey;
+  identityKey: PublicKey;
   client: SignalClient;
+  peerInfo: PeerInfo;
   waitForNextMessage: (options?: { timeout?: number }) => Promise<any>;
   waitForPeer: (peerId: PublicKey) => Promise<boolean>;
 }

package/src/signal-client/signal-client.ts

@@ -8,12 +8,18 @@ import { invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { trace } from '@dxos/protocols';
-import { SignalState, type SwarmEvent } from '@dxos/protocols/proto/dxos/mesh/signal';
+import { SignalState } from '@dxos/protocols/proto/dxos/mesh/signal';
 
 import { SignalClientMonitor } from './signal-client-monitor';
 import { SignalLocalState } from './signal-local-state';
 import { SignalRPCClient } from './signal-rpc-client';
-import { type Message, type SignalClientMethods, type SignalStatus } from '../signal-methods';
+import {
+  type PeerInfo,
+  type Message,
+  type SignalClientMethods,
+  type SignalStatus,
+  type SwarmEvent,
+} from '../signal-methods';
 
 const DEFAULT_RECONNECT_TIMEOUT = 100;
 const MAX_RECONNECT_TIMEOUT = 5_000;
@@ -56,7 +62,7 @@ export class SignalClient extends Resource implements SignalClientMethods {
   readonly statusChanged = new Event<SignalStatus>();
 
   public readonly onMessage = new Event<Message>();
-  public readonly swarmEvent = new Event<{ topic: PublicKey; swarmEvent: SwarmEvent }>();
+  public readonly swarmEvent = new Event<SwarmEvent>();
 
   /**
    * @param _host Signal server websocket URL.
@@ -162,36 +168,44 @@ export class SignalClient extends Resource implements SignalClientMethods {
     };
   }
 
-  async join(args: { topic: PublicKey; peerId: PublicKey }): Promise<void> {
-    log('joining', { topic: args.topic, peerId: args.peerId });
+  async join(args: { topic: PublicKey; peer: PeerInfo }): Promise<void> {
+    log('joining', { topic: args.topic, peerId: args.peer.peerKey });
     this._monitor.recordJoin();
-    this.localState.join(args);
+    this.localState.join({ topic: args.topic, peerId: PublicKey.from(args.peer.peerKey) });
     this._reconcileTask?.schedule();
   }
 
-  async leave(args: { topic: PublicKey; peerId: PublicKey }): Promise<void> {
-    log('leaving', { topic: args.topic, peerId: args.peerId });
+  async leave(args: { topic: PublicKey; peer: PeerInfo }): Promise<void> {
+    log('leaving', { topic: args.topic, peerId: args.peer.peerKey });
     this._monitor.recordLeave();
-    this.localState.leave(args);
+    this.localState.leave({ topic: args.topic, peerId: PublicKey.from(args.peer.peerKey) });
   }
 
   async sendMessage(msg: Message): Promise<void> {
     return this._monitor.recordMessageSending(msg, async () => {
       await this._clientReady.wait();
       invariant(this._state === SignalState.CONNECTED, 'Not connected to Signal Server');
-      await this._client!.sendMessage(msg);
+      invariant(msg.author.peerKey, 'Author key required');
+      invariant(msg.recipient.peerKey, 'Recipient key required');
+      await this._client!.sendMessage({
+        author: PublicKey.from(msg.author.peerKey),
+        recipient: PublicKey.from(msg.recipient.peerKey),
+        payload: msg.payload,
+      });
     });
   }
 
-  async subscribeMessages(peerId: PublicKey) {
-    log('subscribing to messages', { peerId });
-    this.localState.subscribeMessages(peerId);
+  async subscribeMessages(peer: PeerInfo) {
+    invariant(peer.peerKey, 'Peer key required');
+    log('subscribing to messages', { peer });
+    this.localState.subscribeMessages(PublicKey.from(peer.peerKey));
     this._reconcileTask?.schedule();
   }
 
-  async unsubscribeMessages(peerId: PublicKey) {
-    log('unsubscribing from messages', { peerId });
-    this.localState.unsubscribeMessages(peerId);
+  async unsubscribeMessages(peer: PeerInfo) {
+    invariant(peer.peerKey, 'Peer key required');
+    log('unsubscribing from messages', { peer });
+    this.localState.unsubscribeMessages(PublicKey.from(peer.peerKey));
   }
 
   private _scheduleReconcileAfterError() {

package/src/signal-client/signal-local-state.ts

@@ -3,21 +3,24 @@
 //
 
 import { asyncTimeout, Event } from '@dxos/async';
-import type { Any, Stream } from '@dxos/codec-protobuf';
+import type { Stream } from '@dxos/codec-protobuf';
 import { cancelWithContext, type Context } from '@dxos/context';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
-import { type Message as SignalMessage, type SwarmEvent } from '@dxos/protocols/proto/dxos/mesh/signal';
+import {
+  type Message as SignalMessage,
+  type SwarmEvent as SwarmEventProto,
+} from '@dxos/protocols/proto/dxos/mesh/signal';
 import { ComplexMap, ComplexSet, safeAwaitAll } from '@dxos/util';
 
 import { type SignalRPCClient } from './signal-rpc-client';
-import type { Message } from '../signal-methods';
+import type { Message, SwarmEvent } from '../signal-methods';
 
 export class SignalLocalState {
   /**
    * Swarm events streams. Keys represent actually joined topic and peerId.
    */
-  private readonly _swarmStreams = new ComplexMap<{ topic: PublicKey; peerId: PublicKey }, Stream<SwarmEvent>>(
+  private readonly _swarmStreams = new ComplexMap<{ topic: PublicKey; peerId: PublicKey }, Stream<SwarmEventProto>>(
     ({ topic, peerId }) => topic.toHex() + peerId.toHex(),
   );
 
@@ -46,8 +49,8 @@ export class SignalLocalState {
   readonly reconciled = new Event();
 
   constructor(
-    private readonly _onMessage: (params: { author: PublicKey; recipient: PublicKey; payload: Any }) => Promise<void>,
-    private readonly _onSwarmEvent: (params: { topic: PublicKey; swarmEvent: SwarmEvent }) => Promise<void>,
+    private readonly _onMessage: (params: Message) => Promise<void>,
+    private readonly _onSwarmEvent: (params: SwarmEvent) => Promise<void>,
   ) {}
 
   async safeCloseStreams(): Promise<{ failureCount: number }> {
@@ -107,10 +110,25 @@ export class SignalLocalState {
       const swarmStream = await asyncTimeout(cancelWithContext(ctx, client.join({ topic, peerId })), 5_000);
       // Subscribing to swarm events.
       // TODO(mykola): What happens when the swarm stream is closed? Maybe send leave event for each peer?
-      swarmStream.subscribe(async (swarmEvent: SwarmEvent) => {
+      swarmStream.subscribe(async (swarmEvent: SwarmEventProto) => {
         if (this._joinedTopics.has({ topic, peerId })) {
           log('swarm event', { swarmEvent });
-          await this._onSwarmEvent({ topic, swarmEvent });
+          const event: SwarmEvent = swarmEvent.peerAvailable
+            ? {
+                topic,
+                peerAvailable: {
+                  ...swarmEvent.peerAvailable,
+                  peer: { peerKey: PublicKey.from(swarmEvent.peerAvailable.peer).toHex() },
+                },
+              }
+            : {
+                topic,
+                peerLeft: {
+                  ...swarmEvent.peerLeft,
+                  peer: { peerKey: PublicKey.from(swarmEvent.peerLeft!.peer).toHex() },
+                },
+              };
+          await this._onSwarmEvent(event);
         }
       });
 
@@ -141,8 +159,8 @@ export class SignalLocalState {
       messageStream.subscribe(async (signalMessage: SignalMessage) => {
         if (this._subscribedMessages.has({ peerId })) {
           const message: Message = {
-            author: PublicKey.from(signalMessage.author),
-            recipient: PublicKey.from(signalMessage.recipient),
+            author: { peerKey: PublicKey.from(signalMessage.author).toHex() },
+            recipient: { peerKey: PublicKey.from(signalMessage.recipient).toHex() },
             payload: signalMessage.payload,
           };
           await this._onMessage(message);

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

@@ -3,68 +3,64 @@
 //
 import { EdgeClient } from '@dxos/edge-client';
 import { PublicKey } from '@dxos/keys';
-import { describe, openAndClose, test } from '@dxos/test';
+import { afterTest, describe, openAndClose, test } from '@dxos/test';
 
-import { EdgeSignal } from './edge-signal-manager';
-import { type Message } from '../signal-methods';
-import { expectPeerAvailable, expectPeerLeft, expectReceivedMessage } from '../testing';
+import { EdgeSignalManager } from './edge-signal-manager';
+import { createMessage, expectReceivedMessage, TestBuilder, type TestBuilderOptions } from '../testing';
 
-// TODO(mykola): Expects wrangler dev on edge repo to run. Skip to pass CI.
+// TODO(mykola): Expects wrangler dev in edge repo to run. Skip to pass CI.
 describe.skip('EdgeSignalManager', () => {
-  const setupPeer = async () => {
-    const [identityKey, deviceKey] = PublicKey.randomSequence();
-
+  const edgeSignalFactory: TestBuilderOptions['signalManagerFactory'] = async (identityKey, deviceKey) => {
     const client = new EdgeClient(identityKey, deviceKey, { socketEndpoint: 'ws://localhost:8787' });
     await openAndClose(client);
-    const edgeSignal = new EdgeSignal({ messengerClient: client });
-    await openAndClose(edgeSignal);
 
-    return { identityKey, deviceKey, client, edgeSignal };
+    return new EdgeSignalManager({ edgeConnection: client });
   };
 
   test('two peers discover each other', async () => {
+    const builder = new TestBuilder({ signalManagerFactory: edgeSignalFactory });
+    afterTest(() => builder.close());
+    const [peer1, peer2] = await builder.createPeers(2);
+
     const topic = PublicKey.random();
-    const peer1 = await setupPeer();
-    const peer2 = await setupPeer();
 
-    const discover12 = expectPeerAvailable(peer1.edgeSignal, topic, peer2.deviceKey);
-    const discover21 = expectPeerAvailable(peer2.edgeSignal, topic, peer1.deviceKey);
+    const discover12 = peer1.waitForPeerAvailable(topic, peer2.peerInfo);
+    const discover21 = peer2.waitForPeerAvailable(topic, peer1.peerInfo);
 
-    await peer1.edgeSignal.join({ topic, peerId: peer1.deviceKey });
-    await peer2.edgeSignal.join({ topic, peerId: peer2.deviceKey });
+    await peer1.signalManager.join({ topic, peer: peer1.peerInfo });
+    await peer2.signalManager.join({ topic, peer: peer2.peerInfo });
 
     await discover12;
     await discover21;
   });
 
   test('join and leave swarm', async () => {
+    const builder = new TestBuilder({ signalManagerFactory: edgeSignalFactory });
+    afterTest(() => builder.close());
+    const [peer1, peer2] = await builder.createPeers(2);
+
     const topic = PublicKey.random();
-    const peer1 = await setupPeer();
-    const peer2 = await setupPeer();
 
-    const discover12 = expectPeerAvailable(peer1.edgeSignal, topic, peer2.deviceKey);
-    const left12 = expectPeerLeft(peer1.edgeSignal, topic, peer2.deviceKey);
+    const discover12 = peer1.waitForPeerAvailable(topic, peer2.peerInfo);
+    const left12 = peer1.waitForPeerLeft(topic, peer2.peerInfo);
 
-    await peer1.edgeSignal.join({ topic, peerId: peer1.deviceKey });
-    await peer2.edgeSignal.join({ topic, peerId: peer2.deviceKey });
+    await peer2.signalManager.join({ topic, peer: peer2.peerInfo });
+    await peer1.signalManager.join({ topic, peer: peer1.peerInfo });
     await discover12;
 
-    await peer2.edgeSignal.leave({ topic, peerId: peer2.deviceKey });
+    await peer2.signalManager.leave({ topic, peer: peer2.peerInfo });
     await left12;
   });
 
   test('message between peers', async () => {
-    const peer1 = await setupPeer();
-    const peer2 = await setupPeer();
-    const message: Message = {
-      author: peer1.deviceKey,
-      recipient: peer2.deviceKey,
-      payload: { type_url: 'google.protobuf.Any', value: Uint8Array.from([1, 2, 3]) },
-    };
-
-    const receivedMessage = expectReceivedMessage(peer2.edgeSignal, message);
-    await peer2.edgeSignal.subscribeMessages(peer2.deviceKey);
-    await peer1.edgeSignal.sendMessage(message);
+    const builder = new TestBuilder({ signalManagerFactory: edgeSignalFactory });
+    afterTest(() => builder.close());
+    const [peer1, peer2] = await builder.createPeers(2);
+    const message = createMessage(peer1.peerInfo, peer2.peerInfo);
+
+    const receivedMessage = expectReceivedMessage(peer2.signalManager.onMessage, message);
+    await peer2.signalManager.subscribeMessages(peer2.peerInfo);
+    await peer1.signalManager.sendMessage(message);
 
     await receivedMessage;
   });