@dxos/messaging 0.6.8-main.3be982f → 0.6.8-staging.63bcb81

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

@@ -2,85 +2,115 @@
 // Copyright 2024 DXOS.org
 //
 
+import { AnySchema } from '@bufbuild/protobuf/wkt';
+
 import { Event } from '@dxos/async';
 import { Resource } from '@dxos/context';
-import { protocol, type EdgeClient } from '@dxos/edge-client';
+import { type EdgeConnection, 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 {
   SwarmRequestSchema,
   SwarmRequest_Action as SwarmRequestAction,
   SwarmResponseSchema,
   type Message as EdgeMessage,
 } from '@dxos/protocols/buf/dxos/edge/messenger_pb';
-import { type SwarmEvent } from '@dxos/protocols/proto/dxos/mesh/signal';
 import { ComplexMap, ComplexSet } from '@dxos/util';
 
-import { type Message, type SignalMethods } from '../signal-methods';
+import { type SignalManager } from './signal-manager';
+import { type PeerInfo, type Message, type SwarmEvent, PeerInfoHash } from '../signal-methods';
 
-const SWARM_SERVICE_ID = 'swarm';
-export class EdgeSignal extends Resource implements SignalMethods {
-  public swarmEvent = new Event<{ topic: PublicKey; swarmEvent: SwarmEvent }>();
+export class EdgeSignalManager extends Resource implements SignalManager {
+  public swarmEvent = new Event<SwarmEvent>();
   public onMessage = new Event<Message>();
 
   /**
-   * swarm key -> peers in the swarm
+   * swarm key -> peerKeys in the swarm
    */
   // TODO(mykola): This class should not contain swarm state. Temporary before network-manager API changes to accept list of peers.
-  private readonly _swarmPeers = new ComplexMap<PublicKey, ComplexSet<PublicKey>>(PublicKey.hash);
-  private readonly _messengerClient: EdgeClient;
+  private readonly _swarmPeers = new ComplexMap<PublicKey, ComplexSet<PeerInfo>>(PublicKey.hash);
+  private readonly _edgeConnection: EdgeConnection;
 
-  constructor({ messengerClient }: { messengerClient: EdgeClient }) {
+  constructor({ edgeConnection }: { edgeConnection: EdgeConnection }) {
     super();
-    this._messengerClient = messengerClient;
+    this._edgeConnection = edgeConnection;
   }
 
   protected override async _open() {
-    this._ctx.onDispose(this._messengerClient.addListener((message) => this._onMessage(message)));
+    this._ctx.onDispose(this._edgeConnection.addListener((message) => this._onMessage(message)));
   }
 
   /**
-   * Warning: PeerId is inferred from messengerClient
+   * Warning: PeerInfo is inferred from edgeConnection.
    */
-  async join({ topic }: { topic: PublicKey; peerId: PublicKey }): Promise<void> {
-    this._swarmPeers.set(topic, new ComplexSet<PublicKey>(PublicKey.hash));
-    await this._messengerClient.send(
+  async join({ 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', {
+        peer,
+        expected: {
+          peerKey: this._edgeConnection.deviceKey.toHex(),
+          identityKey: this._edgeConnection.identityKey.toHex(),
+        },
+      });
+    }
+
+    this._swarmPeers.set(topic, new ComplexSet<PeerInfo>(PeerInfoHash));
+    await this._edgeConnection.send(
       protocol.createMessage(SwarmRequestSchema, {
-        serviceId: SWARM_SERVICE_ID,
+        serviceId: EdgeService.SWARM_SERVICE_ID,
         payload: { action: SwarmRequestAction.JOIN, swarmKeys: [topic.toHex()] },
       }),
     );
   }
 
-  async leave({ topic }: { topic: PublicKey; peerId: PublicKey }): Promise<void> {
+  async leave({ topic, peer }: { topic: PublicKey; peer: PeerInfo }): Promise<void> {
     this._swarmPeers.delete(topic);
-    await this._messengerClient.send(
+    await this._edgeConnection.send(
       protocol.createMessage(SwarmRequestSchema, {
-        serviceId: SWARM_SERVICE_ID,
+        serviceId: EdgeService.SWARM_SERVICE_ID,
         payload: { action: SwarmRequestAction.LEAVE, swarmKeys: [topic.toHex()] },
       }),
     );
   }
 
   async sendMessage(message: Message): Promise<void> {
-    throw new Error('Method not implemented.');
+    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', {
+        author: message.author,
+        expected: { peerKey: this._edgeConnection.deviceKey, identityKey: this._edgeConnection.identityKey },
+      });
+    }
+
+    await this._edgeConnection.send(
+      protocol.createMessage(AnySchema, {
+        serviceId: EdgeService.SIGNAL_SERVICE_ID,
+        source: message.author,
+        target: [message.recipient],
+        payload: { typeUrl: message.payload.type_url, value: message.payload.value },
+      }),
+    );
   }
 
-  async subscribeMessages(peerId: PublicKey): Promise<void> {
-    throw new Error('Method not implemented.');
+  async subscribeMessages(peerInfo: PeerInfo): Promise<void> {
+    // No-op.
   }
 
-  async unsubscribeMessages(peerId: PublicKey): Promise<void> {
-    throw new Error('Method not implemented.');
+  async unsubscribeMessages(peerInfo: PeerInfo): Promise<void> {
+    // No-op.
   }
 
   private _onMessage(message: EdgeMessage) {
-    const type = protocol.getPayloadType(message);
-
-    switch (type) {
-      case SwarmResponseSchema.typeName: {
+    switch (message.serviceId) {
+      case EdgeService.SWARM_SERVICE_ID: {
         this._processSwarmResponse(message);
+        break;
+      }
+      case EdgeService.SIGNAL_SERVICE_ID: {
+        this._processMessage(message);
       }
     }
   }
@@ -95,10 +125,7 @@ export class EdgeSignal extends Resource implements SignalMethods {
     }
     const oldPeers = this._swarmPeers.get(topic)!;
     const timestamp = new Date(Date.parse(message.timestamp));
-    const newPeers = new ComplexSet<PublicKey>(
-      PublicKey.hash,
-      payload.peers.map(({ peerKey }) => PublicKey.from(peerKey)),
-    );
+    const newPeers = new ComplexSet<PeerInfo>(PeerInfoHash, payload.peers);
 
     // Emit new available peers in the swarm.
     for (const peer of newPeers) {
@@ -107,21 +134,46 @@ export class EdgeSignal extends Resource implements SignalMethods {
       }
       this.swarmEvent.emit({
         topic,
-        swarmEvent: { peerAvailable: { peer: peer.asUint8Array(), since: timestamp } },
+        peerAvailable: { peer, since: timestamp },
       });
     }
 
     // Emit peer that left the swarm.
-    for (const peer of oldPeers.values()) {
+    for (const peer of oldPeers) {
       if (newPeers.has(peer)) {
         continue;
       }
       this.swarmEvent.emit({
         topic,
-        swarmEvent: { peerLeft: { peer: peer.asUint8Array() } },
+        peerLeft: { peer },
       });
     }
 
     this._swarmPeers.set(topic, newPeers);
   }
+
+  private _processMessage(message: EdgeMessage) {
+    invariant(protocol.getPayloadType(message) === AnySchema.typeName, 'Wrong payload type');
+    const payload = protocol.getPayload(message, AnySchema);
+    invariant(message.source, 'source is missing');
+    invariant(message.target, 'target is missing');
+    invariant(message.target.length === 1, 'target should have exactly one item');
+
+    this.onMessage.emit({
+      author: message.source,
+      recipient: message.target[0],
+      payload: {
+        type_url: payload.typeUrl,
+        value: payload.value,
+      },
+    });
+  }
+
+  private _matchSelfPeerInfo(peer: PeerInfo) {
+    return (
+      peer &&
+      (peer.peerKey === this._edgeConnection.deviceKey.toHex() ||
+        peer.identityKey === this._edgeConnection.identityKey.toHex())
+    );
+  }
 }

package/src/signal-manager/index.ts

@@ -5,4 +5,5 @@
 export * from './memory-signal-manager';
 export * from './signal-manager';
 export * from './websocket-signal-manager';
+export * from './edge-signal-manager';
 export * from './utils';

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

@@ -9,27 +9,23 @@ import { invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { schema } from '@dxos/protocols';
-import { type SwarmEvent } from '@dxos/protocols/proto/dxos/mesh/signal';
 import { ComplexMap, ComplexSet } from '@dxos/util';
 
 import { type SignalManager } from './signal-manager';
-import { type SignalStatus } from '../signal-methods';
+import { type SwarmEvent, type PeerInfo, type SignalStatus, type Message, PeerInfoHash } from '../signal-methods';
 
 /**
  * Common signaling context that connects multiple MemorySignalManager instances.
  */
 export class MemorySignalManagerContext {
   // Swarm messages.
-  readonly swarmEvent = new Event<{
-    topic: PublicKey;
-    swarmEvent: SwarmEvent;
-  }>();
+  readonly swarmEvent = new Event<SwarmEvent>();
 
   // Mapping from topic to set of peers.
-  readonly swarms = new ComplexMap<PublicKey, ComplexSet<PublicKey>>(PublicKey.hash);
+  readonly swarms = new ComplexMap<PublicKey, ComplexSet<PeerInfo>>(PublicKey.hash);
 
   // Map of connections for each peer for signaling.
-  readonly connections = new ComplexMap<PublicKey, MemorySignalManager>(PublicKey.hash);
+  readonly connections = new ComplexMap<PeerInfo, MemorySignalManager>(PeerInfoHash);
 }
 
 /**
@@ -37,20 +33,13 @@ export class MemorySignalManagerContext {
  */
 export class MemorySignalManager implements SignalManager {
   readonly statusChanged = new Event<SignalStatus[]>();
-  readonly swarmEvent = new Event<{
-    topic: PublicKey;
-    swarmEvent: SwarmEvent;
-  }>();
+  readonly swarmEvent = new Event<SwarmEvent>();
 
-  readonly onMessage = new Event<{
-    author: PublicKey;
-    recipient: PublicKey;
-    payload: Any;
-  }>();
+  readonly onMessage = new Event<Message>();
 
   /**  Will be used to emit SwarmEvents on .open() and .close() */
-  private _joinedSwarms = new ComplexSet<{ topic: PublicKey; peerId: PublicKey }>(
-    ({ topic, peerId }) => topic.toHex() + peerId.toHex(),
+  private _joinedSwarms = new ComplexSet<{ topic: PublicKey; peer: PeerInfo }>(
+    ({ topic, peer }) => topic.toHex() + peer.peerKey,
   );
 
   private _ctx!: Context;
@@ -79,8 +68,8 @@ export class MemorySignalManager implements SignalManager {
       return;
     }
     // save copy of joined swarms.
-    const joinedSwarmsCopy = new ComplexSet<{ topic: PublicKey; peerId: PublicKey }>(
-      ({ topic, peerId }) => topic.toHex() + peerId.toHex(),
+    const joinedSwarmsCopy = new ComplexSet<{ topic: PublicKey; peer: PeerInfo }>(
+      ({ topic, peer }) => topic.toHex() + peer.peerKey,
       [...this._joinedSwarms.values()],
     );
 
@@ -96,63 +85,60 @@ export class MemorySignalManager implements SignalManager {
     return [];
   }
 
-  async join({ topic, peerId }: { topic: PublicKey; peerId: PublicKey }) {
+  async join({ topic, peer }: { topic: PublicKey; peer: PeerInfo }) {
     invariant(!this._ctx.disposed, 'Closed');
 
-    this._joinedSwarms.add({ topic, peerId });
+    this._joinedSwarms.add({ topic, peer });
 
     if (!this._context.swarms.has(topic)) {
-      this._context.swarms.set(topic, new ComplexSet(PublicKey.hash));
+      this._context.swarms.set(topic, new ComplexSet(PeerInfoHash));
     }
 
-    this._context.swarms.get(topic)!.add(peerId);
+    this._context.swarms.get(topic)!.add(peer);
     this._context.swarmEvent.emit({
       topic,
-      swarmEvent: {
-        peerAvailable: {
-          peer: peerId.asUint8Array(),
-          since: new Date(),
-        },
+      peerAvailable: {
+        peer,
+        since: new Date(),
       },
     });
 
     // Emitting swarm events for each peer.
-    for (const [topic, peerIds] of this._context.swarms) {
-      Array.from(peerIds).forEach((peerId) => {
+    for (const [topic, peers] of this._context.swarms) {
+      Array.from(peers).forEach((peer) => {
         this.swarmEvent.emit({
           topic,
-          swarmEvent: {
-            peerAvailable: {
-              peer: peerId.asUint8Array(),
-              since: new Date(),
-            },
+          peerAvailable: {
+            peer,
+            since: new Date(),
           },
         });
       });
     }
   }
 
-  async leave({ topic, peerId }: { topic: PublicKey; peerId: PublicKey }) {
+  async leave({ topic, peer }: { topic: PublicKey; peer: PeerInfo }) {
     invariant(!this._ctx.disposed, 'Closed');
 
-    this._joinedSwarms.delete({ topic, peerId });
+    this._joinedSwarms.delete({ topic, peer });
 
     if (!this._context.swarms.has(topic)) {
-      this._context.swarms.set(topic, new ComplexSet(PublicKey.hash));
+      this._context.swarms.set(topic, new ComplexSet(PeerInfoHash));
     }
 
-    this._context.swarms.get(topic)!.delete(peerId);
+    this._context.swarms.get(topic)!.delete(peer);
 
     const swarmEvent: SwarmEvent = {
+      topic,
       peerLeft: {
-        peer: peerId.asUint8Array(),
+        peer,
       },
     };
 
-    this._context.swarmEvent.emit({ topic, swarmEvent });
+    this._context.swarmEvent.emit(swarmEvent);
   }
 
-  async sendMessage({ author, recipient, payload }: { author: PublicKey; recipient: PublicKey; payload: Any }) {
+  async sendMessage({ author, recipient, payload }: { author: PeerInfo; recipient: PeerInfo; payload: Any }) {
     log('send message', { author, recipient, ...dec(payload) });
 
     invariant(recipient);
@@ -188,14 +174,14 @@ export class MemorySignalManager implements SignalManager {
       });
   }
 
-  async subscribeMessages(peerId: PublicKey) {
-    log('subscribing', { peerId });
-    this._context.connections.set(peerId, this);
+  async subscribeMessages(peerInfo: PeerInfo) {
+    log('subscribing', { peerInfo });
+    this._context.connections.set(peerInfo, this);
   }
 
-  async unsubscribeMessages(peerId: PublicKey) {
-    log('unsubscribing', { peerId });
-    this._context.connections.delete(peerId);
+  async unsubscribeMessages(peerInfo: PeerInfo) {
+    log('unsubscribing', { peerInfo });
+    this._context.connections.delete(peerInfo);
   }
 
   freeze() {

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

@@ -3,16 +3,14 @@
 //
 
 import { type Event } from '@dxos/async';
+import { type Lifecycle } from '@dxos/context';
 
-import { type SignalMethods, type SignalStatus } from '../signal-methods';
+import { type SignalStatus, type SignalMethods } from '../signal-methods';
 
 /**
  * Manages a collection of signaling clients.
  */
-export interface SignalManager extends SignalMethods {
-  open(): Promise<void>;
-  close(): Promise<void>;
-  getStatus(): SignalStatus[];
-
-  statusChanged: Event<SignalStatus[]>;
+export interface SignalManager extends SignalMethods, Required<Lifecycle> {
+  statusChanged?: Event<SignalStatus[]>;
+  getStatus?: () => SignalStatus[];
 }

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

@@ -8,7 +8,7 @@ import { runTestSignalServer, type SignalServerRunner } from '@dxos/signal';
 import { afterAll, beforeAll, describe, test, openAndClose } from '@dxos/test';
 
 import { WebsocketSignalManager } from './websocket-signal-manager';
-import { expectPeerAvailable, expectReceivedMessage } from '../testing';
+import { createMessage, expectPeerAvailable, expectReceivedMessage } from '../testing';
 
 describe('WebSocketSignalManager', () => {
   let broker1: SignalServerRunner;
@@ -40,14 +40,14 @@ describe('WebSocketSignalManager', () => {
 
     const [topic, peer1, peer2, peer3] = PublicKey.randomSequence();
 
-    const joined12 = expectPeerAvailable(client1, topic, peer2);
-    const joined13 = expectPeerAvailable(client1, topic, peer3);
-    const joined21 = expectPeerAvailable(client2, topic, peer1);
-    const joined31 = expectPeerAvailable(client3, topic, peer1);
+    const joined12 = expectPeerAvailable(client1, topic, { peerKey: peer2.toHex() });
+    const joined13 = expectPeerAvailable(client1, topic, { peerKey: peer3.toHex() });
+    const joined21 = expectPeerAvailable(client2, topic, { peerKey: peer1.toHex() });
+    const joined31 = expectPeerAvailable(client3, topic, { peerKey: peer1.toHex() });
 
-    await client1.join({ topic, peerId: peer1 });
-    await client2.join({ topic, peerId: peer2 });
-    await client3.join({ topic, peerId: peer3 });
+    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 Promise.all([joined12, joined13, joined21, joined31]);
   })
@@ -62,22 +62,18 @@ describe('WebSocketSignalManager', () => {
 
     const [topic, peer1, peer2] = PublicKey.randomSequence();
 
-    const joined12 = expectPeerAvailable(client1, topic, peer2);
-    const joined21 = expectPeerAvailable(client2, topic, peer1);
+    const joined12 = expectPeerAvailable(client1, topic, { peerKey: peer2.toHex() });
+    const joined21 = expectPeerAvailable(client2, topic, { peerKey: peer1.toHex() });
 
-    await client1.join({ topic, peerId: peer1 });
-    await client2.join({ topic, peerId: peer2 });
+    await client1.join({ topic, peer: { peerKey: peer1.toHex() } });
+    await client2.join({ topic, peer: { peerKey: peer2.toHex() } });
 
     await asyncTimeout(Promise.all([joined12, joined21]), 1_000);
 
-    const message = {
-      author: peer1,
-      recipient: peer2,
-      payload: { type_url: 'google.protobuf.Any', value: Uint8Array.from([1, 2, 3]) },
-    };
+    const message = createMessage({ peerKey: peer1.toHex() }, { peerKey: peer2.toHex() });
 
-    const received = expectReceivedMessage(client2, message);
-    await client2.subscribeMessages(peer2);
+    const received = expectReceivedMessage(client2.onMessage, message);
+    await client2.subscribeMessages({ peerKey: peer2.toHex() });
     await sleep(50);
     await client1.sendMessage(message);
 
@@ -94,11 +90,11 @@ describe('WebSocketSignalManager', () => {
 
     const [topic, peer1, peer2] = PublicKey.randomSequence();
 
-    const joined12 = expectPeerAvailable(client1, topic, peer2);
-    const joined21 = expectPeerAvailable(client2, topic, peer1);
+    const joined12 = expectPeerAvailable(client1, topic, { peerKey: peer2.toHex() });
+    const joined21 = expectPeerAvailable(client2, topic, { peerKey: peer1.toHex() });
 
-    await client1.join({ topic, peerId: peer1 });
-    await client2.join({ topic, peerId: peer2 });
+    await client1.join({ topic, peer: { peerKey: peer1.toHex() } });
+    await client2.join({ topic, peer: { peerKey: peer2.toHex() } });
 
     await Promise.all([joined12, joined21]);
   })
@@ -113,18 +109,18 @@ describe('WebSocketSignalManager', () => {
 
     const [topic1, topic2, peer1, peer2] = PublicKey.randomSequence();
 
-    const joined112 = expectPeerAvailable(client1, topic1, peer2);
-    const joined121 = expectPeerAvailable(client2, topic1, peer1);
+    const joined112 = expectPeerAvailable(client1, topic1, { peerKey: peer2.toHex() });
+    const joined121 = expectPeerAvailable(client2, topic1, { peerKey: peer1.toHex() });
 
-    await client1.join({ topic: topic1, peerId: peer1 });
-    await client2.join({ topic: topic1, peerId: peer2 });
+    await client1.join({ topic: topic1, peer: { peerKey: peer1.toHex() } });
+    await client2.join({ topic: topic1, peer: { peerKey: peer2.toHex() } });
     await Promise.all([joined112, joined121]);
 
-    const joined212 = expectPeerAvailable(client1, topic2, peer2);
-    const joined221 = expectPeerAvailable(client2, topic2, peer1);
+    const joined212 = expectPeerAvailable(client1, topic2, { peerKey: peer2.toHex() });
+    const joined221 = expectPeerAvailable(client2, topic2, { peerKey: peer1.toHex() });
 
-    await client1.join({ topic: topic2, peerId: peer1 });
-    await client2.join({ topic: topic2, peerId: peer2 });
+    await client1.join({ topic: topic2, peer: { peerKey: peer1.toHex() } });
+    await client2.join({ topic: topic2, peer: { peerKey: peer2.toHex() } });
     await Promise.all([joined212, joined221]);
   })
     .timeout(1_000)