@dxos/echo-pipeline 0.5.2 → 0.5.3-main.088a2c8

package/src/automerge/mesh-echo-replicator.ts

@@ -0,0 +1,232 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { type Message, cbor } from '@dxos/automerge/automerge-repo';
+import { Resource } from '@dxos/context';
+import { invariant } from '@dxos/invariant';
+import { PublicKey } from '@dxos/keys';
+import { log } from '@dxos/log';
+import { AutomergeReplicator } from '@dxos/teleport-extension-automerge-replicator';
+import { ComplexMap, ComplexSet, defaultMap } from '@dxos/util';
+
+import {
+  type EchoReplicator,
+  type EchoReplicatorContext,
+  type ReplicatorConnection,
+  type ShouldAdvertizeParams,
+} from './echo-replicator';
+
+// TODO(dmaretskyi): Move out of @dxos/echo-pipeline.
+
+/**
+ * Used to replicate with other peers over the network.
+ */
+export class MeshEchoReplicator implements EchoReplicator {
+  private readonly _connections = new Set<MeshReplicatorConnection>();
+  /**
+   * Using automerge peerId as a key.
+   */
+  private readonly _connectionsPerPeer = new Map<string, MeshReplicatorConnection>();
+
+  /**
+   * spaceKey -> deviceKey[]
+   */
+  private readonly _authorizedDevices = new ComplexMap<PublicKey, ComplexSet<PublicKey>>(PublicKey.hash);
+
+  private _context: EchoReplicatorContext | null = null;
+
+  async connect(context: EchoReplicatorContext): Promise<void> {
+    this._context = context;
+  }
+
+  async disconnect() {
+    for (const connection of this._connections) {
+      await connection.close();
+    }
+    this._connections.clear();
+    this._connectionsPerPeer.clear();
+
+    this._context = null;
+  }
+
+  createExtension(): AutomergeReplicator {
+    invariant(this._context);
+
+    const connection: MeshReplicatorConnection = new MeshReplicatorConnection({
+      ownPeerId: this._context.peerId,
+      onRemoteConnected: async () => {
+        log('onRemoteConnected', { peerId: connection.peerId });
+        invariant(this._context);
+
+        if (!this._connectionsPerPeer.has(connection.peerId)) {
+          this._connectionsPerPeer.set(connection.peerId, connection);
+          await connection.enable();
+          this._context.onConnectionOpen(connection);
+        }
+      },
+      onRemoteDisconnected: async () => {
+        log('onRemoteDisconnected', { peerId: connection.peerId });
+        invariant(this._context);
+        this._context.onConnectionClosed(connection);
+        await connection.disable();
+        this._connectionsPerPeer.delete(connection.peerId);
+        this._connections.delete(connection);
+      },
+      shouldAdvertize: async (params: ShouldAdvertizeParams) => {
+        log('shouldAdvertize', { peerId: connection.peerId, documentId: params.documentId });
+        invariant(this._context);
+        try {
+          const spaceKey = await this._context.getContainingSpaceForDocument(params.documentId);
+          if (!spaceKey) {
+            log('space key not found for share policy check', {
+              peerId: connection.peerId,
+              documentId: params.documentId,
+            });
+            return false;
+          }
+
+          const authorizedDevices = this._authorizedDevices.get(spaceKey);
+
+          if (!connection.remoteDeviceKey) {
+            log('device key not found for share policy check', {
+              peerId: connection.peerId,
+              documentId: params.documentId,
+            });
+            return false;
+          }
+
+          const isAuthorized = authorizedDevices?.has(connection.remoteDeviceKey) ?? false;
+          log('share policy check', {
+            localPeer: this._context.peerId,
+            remotePeer: connection.peerId,
+            documentId: params.documentId,
+            deviceKey: connection.remoteDeviceKey,
+            spaceKey,
+            isAuthorized,
+          });
+          return isAuthorized;
+        } catch (err) {
+          log.catch(err);
+          return false;
+        }
+      },
+    });
+    this._connections.add(connection);
+
+    return connection.replicatorExtension;
+  }
+
+  authorizeDevice(spaceKey: PublicKey, deviceKey: PublicKey) {
+    log('authorizeDevice', { spaceKey, deviceKey });
+    defaultMap(this._authorizedDevices, spaceKey, () => new ComplexSet(PublicKey.hash)).add(deviceKey);
+  }
+}
+
+type MeshReplicatorConnectionParams = {
+  ownPeerId: string;
+  onRemoteConnected: () => Promise<void>;
+  onRemoteDisconnected: () => Promise<void>;
+  shouldAdvertize: (params: ShouldAdvertizeParams) => Promise<boolean>;
+};
+
+class MeshReplicatorConnection extends Resource implements ReplicatorConnection {
+  public readable: ReadableStream<Message>;
+  public writable: WritableStream<Message>;
+  public remoteDeviceKey: PublicKey | null = null;
+
+  public readonly replicatorExtension: AutomergeReplicator;
+
+  private _remotePeerId: string | null = null;
+  private _isEnabled = false;
+
+  constructor(private readonly _params: MeshReplicatorConnectionParams) {
+    super();
+
+    let readableStreamController!: ReadableStreamDefaultController<Message>;
+    this.readable = new ReadableStream<Message>({
+      start: (controller) => {
+        readableStreamController = controller;
+        this._ctx.onDispose(() => controller.close());
+      },
+    });
+
+    this.writable = new WritableStream<Message>({
+      write: async (message: Message, controller) => {
+        // TODO(dmaretskyi): Show we block on RPC completing here?
+        this.replicatorExtension.sendSyncMessage({ payload: cbor.encode(message) }).catch((err) => {
+          controller.error(err);
+        });
+      },
+    });
+
+    this.replicatorExtension = new AutomergeReplicator(
+      {
+        peerId: this._params.ownPeerId,
+      },
+      {
+        onStartReplication: async (info, remotePeerId /** Teleport ID */) => {
+          // Note: We store only one extension per peer.
+          //       There can be a case where two connected peers have more than one teleport connection between them
+          //       and each of them uses different teleport connections to send messages.
+          //       It works because we receive messages from all teleport connections and Automerge Repo dedup them.
+          // TODO(mykola): Use only one teleport connection per peer.
+
+          // TODO(dmaretskyi): Critical bug.
+          // - two peers get connected via swarm 1
+          // - they get connected via swarm 2
+          // - swarm 1 gets disconnected
+          // - automerge repo thinks that peer 2 got disconnected even though swarm 2 is still active
+
+          this.remoteDeviceKey = remotePeerId;
+
+          // Set automerge id.
+          this._remotePeerId = info.id;
+
+          log('onStartReplication', { id: info.id, thisPeerId: this.peerId, remotePeerId: remotePeerId.toHex() });
+
+          await this._params.onRemoteConnected();
+        },
+        onSyncMessage: async ({ payload }) => {
+          if (!this._isEnabled) {
+            return;
+          }
+          const message = cbor.decode(payload) as Message;
+          // Note: automerge Repo dedup messages.
+          readableStreamController.enqueue(message);
+        },
+        onClose: async () => {
+          if (!this._isEnabled) {
+            return;
+          }
+          await this._params.onRemoteDisconnected();
+        },
+      },
+    );
+  }
+
+  get peerId(): string {
+    invariant(this._remotePeerId != null, 'Remote peer has not connected yet.');
+    return this._remotePeerId;
+  }
+
+  async shouldAdvertize(params: ShouldAdvertizeParams): Promise<boolean> {
+    return this._params.shouldAdvertize(params);
+  }
+
+  /**
+   * Start exchanging messages with the remote peer.
+   * Call after the remote peer has connected.
+   */
+  async enable() {
+    invariant(this._remotePeerId != null, 'Remote peer has not connected yet.');
+    this._isEnabled = true;
+  }
+
+  /**
+   * Stop exchanging messages with the remote peer.
+   */
+  async disable() {
+    this._isEnabled = false;
+  }
+}

package/src/automerge/migrations.ts

@@ -4,14 +4,14 @@
 
 import { type StorageKey } from '@dxos/automerge/automerge-repo';
 import { IndexedDBStorageAdapter } from '@dxos/automerge/automerge-repo-storage-indexeddb';
-import { type SubLevelDB } from '@dxos/kv-store';
+import { type SublevelDB } from '@dxos/kv-store';
 import { log } from '@dxos/log';
 import { StorageType, type Directory } from '@dxos/random-access-storage';
 
 import { AutomergeStorageAdapter } from './automerge-storage-adapter';
 import { encodingOptions } from './leveldb-storage-adapter';
 
-export const levelMigration = async ({ db, directory }: { db: SubLevelDB; directory: Directory }) => {
+export const levelMigration = async ({ db, directory }: { db: SublevelDB; directory: Directory }) => {
   // Note: Make automigration from previous storage to leveldb here.
   const isNewLevel = !(await db
     .iterator<StorageKey, Uint8Array>({

package/src/space/space-manager.ts

@@ -3,7 +3,7 @@
 //
 
 import { synchronized, trackLeaks } from '@dxos/async';
-import { type DelegateInvitationCredential } from '@dxos/credentials';
+import { type DelegateInvitationCredential, type MemberInfo } from '@dxos/credentials';
 import { failUndefined } from '@dxos/debug';
 import { type FeedStore } from '@dxos/feed-store';
 import { PublicKey } from '@dxos/keys';
@@ -44,6 +44,7 @@ export type ConstructSpaceParams = {
   onAuthorizedConnection: (session: Teleport) => void;
   onAuthFailure?: (session: Teleport) => void;
   onDelegatedInvitationStatusChange: (invitation: DelegateInvitationCredential, isActive: boolean) => Promise<void>;
+  onMemberRolesChanged: (member: MemberInfo[]) => Promise<void>;
 };
 
 /**
@@ -87,6 +88,7 @@ export class SpaceManager {
     onAuthorizedConnection,
     onAuthFailure,
     onDelegatedInvitationStatusChange,
+    onMemberRolesChanged,
     memberKey,
   }: ConstructSpaceParams) {
     log.trace('dxos.echo.space-manager.construct-space', trace.begin({ id: this._instanceId }));
@@ -115,6 +117,7 @@ export class SpaceManager {
       snapshotManager,
       memberKey,
       onDelegatedInvitationStatusChange,
+      onMemberRolesChanged,
     });
     this._spaces.set(space.key, space);
 

package/src/space/space-protocol.ts

@@ -70,6 +70,12 @@ export class SpaceProtocol {
 
   private readonly _feeds = new Set<FeedWrapper<FeedMessage>>();
   private readonly _sessions = new ComplexMap<PublicKey, SpaceProtocolSession>(PublicKey.hash);
+  // TODO(burdon): Move to config (with sensible defaults).
+  private readonly _topology = new MMSTTopology({
+    originateConnections: 4,
+    maxPeers: 10,
+    sampleSize: 20,
+  });
 
   private _connection?: SwarmConnection;
 
@@ -117,13 +123,6 @@ export class SpaceProtocol {
     // TODO(burdon): Document why empty buffer.
     const credentials = await this._swarmIdentity.credentialProvider(Buffer.from(''));
 
-    // TODO(burdon): Move to config (with sensible defaults).
-    const topologyConfig = {
-      originateConnections: 4,
-      maxPeers: 10,
-      sampleSize: 20,
-    };
-
     await this.blobSync.open();
 
     log('starting...');
@@ -132,13 +131,17 @@ export class SpaceProtocol {
       protocolProvider: this._createProtocolProvider(credentials),
       peerId: this._swarmIdentity.peerKey,
       topic,
-      topology: new MMSTTopology(topologyConfig),
+      topology: this._topology,
       label: `swarm ${topic.truncate()} for space ${this._spaceKey.truncate()}`,
     });
 
     log('started');
   }
 
+  public updateTopology() {
+    this._topology.forceUpdate();
+  }
+
   async stop() {
     await this.blobSync.close();
 

package/src/space/space.ts

@@ -3,8 +3,8 @@
 //
 
 import { Event, Mutex, synchronized, trackLeaks } from '@dxos/async';
-import { Resource, type Context, LifecycleState } from '@dxos/context';
-import { type FeedInfo, type DelegateInvitationCredential } from '@dxos/credentials';
+import { type Context, LifecycleState, Resource } from '@dxos/context';
+import { type DelegateInvitationCredential, type FeedInfo, type MemberInfo } from '@dxos/credentials';
 import { type FeedOptions, type FeedWrapper } from '@dxos/feed-store';
 import { invariant } from '@dxos/invariant';
 import { type PublicKey } from '@dxos/keys';
@@ -13,7 +13,7 @@ import type { FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
 import { AdmittedFeed, type Credential } from '@dxos/protocols/proto/dxos/halo/credentials';
 import { type Timeframe } from '@dxos/timeframe';
 import { trace } from '@dxos/tracing';
-import { Callback, type AsyncCallback } from '@dxos/util';
+import { type AsyncCallback, Callback } from '@dxos/util';
 
 import { ControlPipeline } from './control-pipeline';
 import { type SpaceProtocol } from './space-protocol';
@@ -37,6 +37,7 @@ export type SpaceParams = {
   snapshotId?: string | undefined;
 
   onDelegatedInvitationStatusChange: (invitation: DelegateInvitationCredential, isActive: boolean) => Promise<void>;
+  onMemberRolesChanged: (member: MemberInfo[]) => Promise<void>;
 };
 
 export type CreatePipelineParams = {
@@ -109,6 +110,10 @@ export class Space extends Resource {
       log('onDelegatedInvitationRemoved', { invitation });
       await params.onDelegatedInvitationStatusChange(invitation, false);
     });
+    this._controlPipeline.onMemberRoleChanged.set(async (changedMembers) => {
+      log('onMemberRoleChanged', () => ({ changedMembers: changedMembers.map((m) => [m.key, m.role]) }));
+      await params.onMemberRolesChanged(changedMembers);
+    });
 
     // Start replicating the genesis feed.
     this.protocol = params.protocol;

package/src/testing/test-agent-builder.ts

@@ -191,6 +191,7 @@ export class TestAgent {
         );
       },
       onDelegatedInvitationStatusChange: async () => {},
+      onMemberRolesChanged: async () => {},
     });
     await space.setControlFeed(controlFeed);
     await space.setDataFeed(dataFeed);

package/dist/types/src/automerge/mesh-network-adapter.d.ts

@@ -1,18 +0,0 @@
-import { NetworkAdapter, type Message, type PeerId } from '@dxos/automerge/automerge-repo';
-import { AutomergeReplicator } from '@dxos/teleport-extension-automerge-replicator';
-/**
- * Used to replicate with other peers over the network.
- */
-export declare class MeshNetworkAdapter extends NetworkAdapter {
-    private readonly _extensions;
-    private _connected;
-    /**
-     * Emits `ready` event. That signals to `Repo` that it can start using the adapter.
-     */
-    ready(): void;
-    connect(peerId: PeerId): void;
-    send(message: Message): void;
-    disconnect(): void;
-    createExtension(): AutomergeReplicator;
-}
-//# sourceMappingURL=mesh-network-adapter.d.ts.map

package/dist/types/src/automerge/mesh-network-adapter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mesh-network-adapter.d.ts","sourceRoot":"","sources":["../../../../src/automerge/mesh-network-adapter.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,cAAc,EAAE,KAAK,OAAO,EAAE,KAAK,MAAM,EAAQ,MAAM,gCAAgC,CAAC;AAIjG,OAAO,EAAE,mBAAmB,EAAE,MAAM,+CAA+C,CAAC;AAEpF;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,cAAc;IACpD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA+C;IAC3E,OAAO,CAAC,UAAU,CAAiB;IAEnC;;OAEG;IACH,KAAK;IAQI,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAK7B,IAAI,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAO5B,UAAU,IAAI,IAAI;IAI3B,eAAe,IAAI,mBAAmB;CA6DvC"}

package/src/automerge/mesh-network-adapter.ts

@@ -1,107 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { Trigger } from '@dxos/async';
-import { NetworkAdapter, type Message, type PeerId, cbor } from '@dxos/automerge/automerge-repo';
-import { invariant } from '@dxos/invariant';
-import { log } from '@dxos/log';
-import { type PeerInfo } from '@dxos/protocols/proto/dxos/mesh/teleport/automerge';
-import { AutomergeReplicator } from '@dxos/teleport-extension-automerge-replicator';
-
-/**
- * Used to replicate with other peers over the network.
- */
-export class MeshNetworkAdapter extends NetworkAdapter {
-  private readonly _extensions: Map<string, AutomergeReplicator> = new Map();
-  private _connected = new Trigger();
-
-  /**
-   * Emits `ready` event. That signals to `Repo` that it can start using the adapter.
-   */
-  ready() {
-    // NOTE: Emitting `ready` event in NetworkAdapter`s constructor causes a race condition
-    //       because `Repo` waits for `ready` event (which it never receives) before it starts using the adapter.
-    this.emit('ready', {
-      network: this,
-    });
-  }
-
-  override connect(peerId: PeerId): void {
-    this.peerId = peerId;
-    this._connected.wake();
-  }
-
-  override send(message: Message): void {
-    const receiverId = message.targetId;
-    const extension = this._extensions.get(receiverId);
-    invariant(extension, 'Extension not found.');
-    extension.sendSyncMessage({ payload: cbor.encode(message) }).catch((err) => log.catch(err));
-  }
-
-  override disconnect(): void {
-    // No-op
-  }
-
-  createExtension(): AutomergeReplicator {
-    invariant(this.peerId, 'Peer id not set.');
-
-    let peerInfo: PeerInfo;
-    const extension = new AutomergeReplicator(
-      {
-        peerId: this.peerId,
-      },
-      {
-        onStartReplication: async (info, remotePeerId /** Teleport ID */) => {
-          await this._connected.wait();
-
-          // Note: We store only one extension per peer.
-          //       There can be a case where two connected peers have more than one teleport connection between them
-          //       and each of them uses different teleport connections to send messages.
-          //       It works because we receive messages from all teleport connections and Automerge Repo dedup them.
-          // TODO(mykola): Use only one teleport connection per peer.
-
-          // TODO(dmaretskyi): Critical bug.
-          // - two peers get connected via swarm 1
-          // - they get connected via swarm 2
-          // - swarm 1 gets disconnected
-          // - automerge repo thinks that peer 2 got disconnected even though swarm 2 is still active
-
-          log('onStartReplication', { id: info.id, thisPeerId: this.peerId, remotePeerId: remotePeerId.toHex() });
-          if (!this._extensions.has(info.id)) {
-            peerInfo = info;
-            // TODO(mykola): Fix race condition?
-            this._extensions.set(info.id, extension);
-
-            log('peer-candidate', { id: info.id, thisPeerId: this.peerId, remotePeerId: remotePeerId.toHex() });
-            this.emit('peer-candidate', {
-              // TODO(mykola): Hack, stop abusing `peerMetadata` field.
-              peerMetadata: {
-                dxos_deviceKey: remotePeerId.toHex(),
-              } as any,
-              peerId: info.id as PeerId,
-            });
-          }
-        },
-        onSyncMessage: async ({ payload }) => {
-          if (!peerInfo) {
-            return;
-          }
-          const message = cbor.decode(payload) as Message;
-          // Note: automerge Repo dedup messages.
-          this.emit('message', message);
-        },
-        onClose: async () => {
-          if (!peerInfo) {
-            return;
-          }
-          this.emit('peer-disconnected', {
-            peerId: peerInfo.id as PeerId,
-          });
-          this._extensions.delete(peerInfo.id);
-        },
-      },
-    );
-    return extension;
-  }
-}