@dxos/echo-db 2.33.4-dev.e8fe40a8 → 2.33.5-dev.22471d71

package/src/parties/data-party.ts

@@ -19,6 +19,7 @@ import { InvitationFactory } from '../invitations';
 import { PartyFeedProvider, PartyProtocolFactory, PartyCore, PartyOptions } from '../pipeline';
 import { createAuthPlugin, createOfflineInvitationPlugin, createAuthenticator, createCredentialsProvider } from '../protocol';
 import { CredentialsSigner } from '../protocol/credentials-signer';
+import { createReplicatorPlugin } from '../protocol/replicator-plugin';
 import { SnapshotStore } from '../snapshots';
 import { CONTACT_DEBOUNCE_INTERVAL } from './party-manager';
 
@@ -173,12 +174,12 @@ export class DataParty {
     this._protocol = new PartyProtocolFactory(
       this._partyCore.key,
       this._networkManager,
-      this._feedProvider,
       deviceKey.publicKey,
       createCredentialsProvider(this._credentialsSigner, this._partyCore.key, writeFeed.key)
     );
 
     await this._protocol.start([
+      createReplicatorPlugin(this._feedProvider),
       createAuthPlugin(createAuthenticator(this._partyCore.processor, this._credentialsSigner), deviceKey.publicKey),
       createOfflineInvitationPlugin(this._invitationManager, deviceKey.publicKey)
     ]);

package/src/pipeline/party-core.test.ts

@@ -16,7 +16,8 @@ import { ObjectModel } from '@dxos/object-model';
 import { createStorage, StorageType } from '@dxos/random-access-multi-storage';
 import { afterTest } from '@dxos/testutils';
 
-import { MetadataStore, PartyFeedProvider, ReplicatorProtocolPluginFactory } from '../pipeline';
+import { MetadataStore, PartyFeedProvider } from '../pipeline';
+import { createReplicatorPlugin } from '../protocol/replicator-plugin';
 import { SnapshotStore } from '../snapshots';
 import { PartyCore } from './party-core';
 
@@ -286,12 +287,8 @@ describe('PartyCore', () => {
     afterTest(async () => party2.close());
 
     createTestProtocolPair(
-      new ReplicatorProtocolPluginFactory(
-        peer1.partyFeedProvider
-      ).createPlugins().map(r => r.createExtension()),
-      new ReplicatorProtocolPluginFactory(
-        partyFeedProvider
-      ).createPlugins().map(r => r.createExtension())
+      [createReplicatorPlugin(peer1.partyFeedProvider).createExtension()],
+      [createReplicatorPlugin(partyFeedProvider).createExtension()]
     );
 
     const item1 = await peer1.party.database.createItem();

package/src/protocol/party-protocol-factory.ts

@@ -4,17 +4,13 @@
 
 import debug from 'debug';
 
-import { synchronized } from '@dxos/async';
 import { discoveryKey, keyToString, PublicKey } from '@dxos/crypto';
-import { FeedKey, PartyKey } from '@dxos/echo-protocol';
-import type { HypercoreFeed } from '@dxos/feed-store';
+import { PartyKey } from '@dxos/echo-protocol';
 import { Protocol } from '@dxos/mesh-protocol';
 import { MMSTTopology, NetworkManager, Plugin } from '@dxos/network-manager';
 import { PresencePlugin } from '@dxos/protocol-plugin-presence';
-import { Replicator } from '@dxos/protocol-plugin-replicator';
 
 import { CredentialsProvider } from '.';
-import { PartyFeedProvider } from '../pipeline/party-feed-provider';
 
 const log = debug('dxos:echo-db:party-protocol-factory');
 
@@ -23,21 +19,15 @@ const log = debug('dxos:echo-db:party-protocol-factory');
  */
 export class PartyProtocolFactory {
   private readonly _presencePlugin = new PresencePlugin(this._peerId.asBuffer());
-  private readonly _replicatorProtocolPluginFactory: ReplicatorProtocolPluginFactory;
 
   private _started = false;
 
   constructor (
     private readonly _partyKey: PartyKey,
     private readonly _networkManager: NetworkManager,
-    private readonly _feedProvider: PartyFeedProvider,
     private readonly _peerId: PublicKey,
     private readonly _credentials: CredentialsProvider
-  ) {
-    // Replication.
-    this._replicatorProtocolPluginFactory =
-      new ReplicatorProtocolPluginFactory(this._feedProvider);
-  }
+  ) {}
 
   async start (plugins: Plugin[]) {
     if (this._started) {
@@ -73,9 +63,8 @@ export class PartyProtocolFactory {
     await this._networkManager.leaveProtocolSwarm(this._partyKey);
   }
 
-  private _createProtocol (channel: any, opts: {initiator: boolean}, extraPlugins: Plugin[]) {
+  private _createProtocol (channel: any, opts: { initiator: boolean }, extraPlugins: Plugin[]) {
     const plugins: Plugin[] = [
-      ...this._replicatorProtocolPluginFactory.createPlugins(),
       ...extraPlugins,
       this._presencePlugin
     ];
@@ -118,45 +107,3 @@ export class PartyProtocolFactory {
     return protocol;
   }
 }
-
-/**
- * Creates the protocol plugin for feed replication.
- */
-export class ReplicatorProtocolPluginFactory {
-  constructor (
-    private readonly _feedProvider: PartyFeedProvider
-  ) {}
-
-  createPlugins () {
-    return [
-      new Replicator({
-        load: async () => {
-          const feeds = this._feedProvider.getFeeds();
-          log(`Loading feeds: ${feeds.map(feed => keyToString(feed.key))}`);
-          return feeds.map((feed) => ({ discoveryKey: feed.feed.discoveryKey }));
-        },
-
-        subscribe: (addFeedToReplicatedSet: (feed: any) => void) => {
-          return this._feedProvider.feedOpened.on(async (feed) => {
-            log(`Adding feed: ${feed.key.toHex()}`);
-            addFeedToReplicatedSet({ discoveryKey: feed.feed.discoveryKey });
-          });
-        },
-
-        replicate: async (remoteFeeds, info) => {
-          // We can ignore remoteFeeds entirely, since the set of feeds we want to replicate is dictated by the Party.
-          // TODO(telackey): Why are we opening feeds? Necessary or belt/braces thinking, or because open party does it?
-          const feeds = this._feedProvider.getFeeds();
-          log(`Replicating: peerId=${info.session}; feeds=${feeds.map(feed => feed.key.toHex())}`);
-          return feeds.map(feed => feed.feed);
-        }
-      })
-    ];
-  }
-
-  @synchronized
-  private async _openFeed (key: FeedKey): Promise<HypercoreFeed> {
-    const descriptor = await this._feedProvider.createOrOpenReadOnlyFeed(key);
-    return descriptor.feed;
-  }
-}

package/src/protocol/replicator-plugin.ts

@@ -0,0 +1,39 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import debug from 'debug';
+
+import { keyToString } from '@dxos/crypto';
+import { Replicator } from '@dxos/protocol-plugin-replicator';
+
+import { PartyFeedProvider } from '../pipeline';
+
+const log = debug('dxos:echo-db:protocol:replicator');
+
+/**
+ * Creates the protocol plugin for feed replication.
+ */
+export const createReplicatorPlugin = (feedProvider: PartyFeedProvider) =>
+  new Replicator({
+    load: async () => {
+      const feeds = feedProvider.getFeeds();
+      log(`Loading feeds: ${feeds.map(feed => keyToString(feed.key))}`);
+      return feeds.map((feed) => ({ discoveryKey: feed.feed.discoveryKey }));
+    },
+
+    subscribe: (addFeedToReplicatedSet: (feed: any) => void) => {
+      return feedProvider.feedOpened.on(async (feed) => {
+        log(`Adding feed: ${feed.key.toHex()}`);
+        addFeedToReplicatedSet({ discoveryKey: feed.feed.discoveryKey });
+      });
+    },
+
+    replicate: async (remoteFeeds, info) => {
+      // We can ignore remoteFeeds entirely, since the set of feeds we want to replicate is dictated by the Party.
+      // TODO(telackey): Why are we opening feeds? Necessary or belt/braces thinking, or because open party does it?
+      const feeds = feedProvider.getFeeds();
+      log(`Replicating: peerId=${info.session}; feeds=${feeds.map(feed => feed.key.toHex())}`);
+      return feeds.map(feed => feed.feed);
+    }
+  });

package/src/testing/benchmark.test.ts

@@ -0,0 +1,30 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import { ObjectModel } from '@dxos/object-model';
+
+import { ECHO } from '../echo';
+
+const ITEMS = 100;
+const MUTATIONS = 1000;
+
+it.skip('Database benchmark', async () => {
+  const echo = new ECHO({ snapshots: false });
+  await echo.open();
+  await echo.halo.createProfile();
+  const party = await echo.createParty();
+
+  const start = Date.now();
+  for (let i = 0; i < ITEMS; i++) {
+    const item = await party.database.createItem({ model: ObjectModel, type: 'test:item' });
+
+    for (let j = 0; j < MUTATIONS; j++) {
+      await item.model.set(`key${j % 100}`, `value-${j}`);
+    }
+
+    console.log(`${i * MUTATIONS}/${ITEMS * MUTATIONS} ${((Date.now() - start) / ((i + 1) * MUTATIONS / 1000)).toFixed(1)} µs/mut ${((i + 1) * MUTATIONS / (Date.now() - start) * 1000).toFixed(1)} mut/s`);
+  }
+
+  await echo.close();
+});