@dxos/echo-pipeline 0.1.35 → 0.1.36

package/src/pipeline/pipeline.test.ts

@@ -2,7 +2,16 @@
 // Copyright 2022 DXOS.org
 //
 
+import expect from 'expect';
+import * as fc from 'fast-check';
+import { inspect } from 'util';
+
+import { asyncTimeout } from '@dxos/async';
 import { checkType } from '@dxos/debug';
+import { FeedStore, FeedWrapper } from '@dxos/feed-store';
+import { PublicKey } from '@dxos/keys';
+import { log } from '@dxos/log';
+import { FeedMessageBlock } from '@dxos/protocols';
 import { FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
 import { describe, test, afterTest } from '@dxos/test';
 import { Timeframe } from '@dxos/timeframe';
@@ -76,4 +85,209 @@ describe('pipeline/Pipeline', () => {
       }
     }
   });
+
+  test
+    .skip('stress', async () => {
+      const builder = new TestFeedBuilder();
+
+      const NUM_AGENTS = 2;
+      const NUM_MESSAGES = 100;
+
+      class Agent {
+        public startingTimeframe = new Timeframe();
+        public pipeline!: Pipeline;
+        public feed!: FeedWrapper<FeedMessage>;
+        public messages: FeedMessageBlock[] = [];
+        public writePromise: Promise<any> = Promise.resolve();
+
+        constructor(public id: string, public feedStore: FeedStore<FeedMessage>) {}
+
+        async open() {
+          const key = await builder.keyring.createKey();
+          this.feed = await this.feedStore.openFeed(key, { writable: true });
+        }
+
+        async start() {
+          this.pipeline = new Pipeline(this.startingTimeframe);
+
+          await this.pipeline.start();
+
+          // NOTE: not awaiting here breaks the test.
+          await Promise.all(this.feedStore.feeds.map((feed) => this.pipeline.addFeed(feed)));
+          this.pipeline.setWriteFeed(this.feed);
+
+          // consume in async task.
+          void this.consume();
+        }
+
+        async stop() {
+          await this.pipeline.stop();
+          this.startingTimeframe = this.pipeline.state.timeframe;
+        }
+
+        async close() {
+          await this.feed.close();
+        }
+
+        write(message: FeedMessage.Payload) {
+          const prev = this.writePromise;
+          const promise = this.pipeline.writer!.write(message);
+          this.writePromise = Promise.all([prev, promise]);
+        }
+
+        async consume() {
+          for await (const msg of this.pipeline.consume()) {
+            this.messages.push(msg);
+          }
+          log('stopped consuming');
+        }
+      }
+
+      type Model = {};
+      type Real = {
+        feedStore: FeedStore<FeedMessage>;
+        agents: Map<string, Agent>;
+      };
+
+      class WriteCommand implements fc.AsyncCommand<Model, Real> {
+        constructor(public agent: string, public count: number) {}
+
+        check = () => true;
+
+        async run(model: Model, real: Real) {
+          console.log(`WriteCommand(${this.agent}, ${this.count})`);
+
+          const agent = real.agents.get(this.agent)!;
+
+          const toWrite = Math.min(this.count, NUM_MESSAGES - agent.feed.length);
+          if (toWrite > 0) {
+            for (const _ of range(toWrite)) {
+              agent.write({}); // Content is not important.
+            }
+          }
+        }
+
+        toString = () => `WriteCommand(${this.agent}, ${this.count})`;
+      }
+
+      class SyncCommand implements fc.AsyncCommand<Model, Real> {
+        check = () => true;
+
+        async run(model: Model, real: Real) {
+          console.log('SyncCommand()');
+          const targets: any = {};
+
+          try {
+            for (const agent of real.agents.values()) {
+              await agent.writePromise;
+            }
+
+            for (const agent of real.agents.values()) {
+              targets[agent.id] = agent.pipeline.state.endTimeframe;
+              if (agent.pipeline.state.endTimeframe.isEmpty()) {
+                console.log('empty endtimeframe', {
+                  id: agent.id,
+                  endTimeframe: agent.pipeline.state.endTimeframe,
+                  feeds: agent.pipeline.getFeeds().map((feed) => [feed.key.toString(), feed.length])
+                });
+              }
+              await asyncTimeout(agent.pipeline.state.waitUntilTimeframe(agent.pipeline.state.endTimeframe), 1000);
+            }
+
+            const tf: Timeframe = real.agents.values().next().value!.pipeline.state.timeframe;
+            for (const agent of real.agents.values()) {
+              expect(agent.pipeline.state.timeframe.equals(tf)).toEqual(true);
+            }
+
+            const totalMessages = real.feedStore.feeds.reduce((acc, feed) => acc + feed.length, 0);
+            for (const agent of real.agents.values()) {
+              expect(agent.messages.length).toEqual(totalMessages);
+            }
+          } catch (err) {
+            console.log(
+              inspect(
+                {
+                  agents: Array.from(real.agents.values()).map((agent) => ({
+                    id: agent.id,
+                    messages: agent.messages.length,
+                    feeds: agent.pipeline.getFeeds().map((feed) => [feed.key, feed.length]),
+                    timeframe: agent.pipeline.state.timeframe,
+                    endTimeframe: agent.pipeline.state.endTimeframe
+                  })),
+                  feeds: real.feedStore.feeds.map((feed) => [feed.key, feed.length]),
+                  targets
+                },
+                false,
+                null,
+                true
+              )
+            );
+            throw err;
+          }
+        }
+
+        toString = () => 'SyncCommand()';
+      }
+
+      class RestartCommand implements fc.AsyncCommand<Model, Real> {
+        constructor(public agent: string) {}
+
+        check = () => true;
+
+        async run(model: Model, real: Real) {
+          console.log(`RestartCommand(${this.agent})`);
+
+          const agent = real.agents.get(this.agent)!;
+
+          await agent.writePromise;
+          await agent.stop();
+          await agent.start();
+        }
+
+        toString = () => `RestartCommand(${this.agent})`;
+      }
+
+      const agentIds = range(NUM_AGENTS).map(() => PublicKey.random().toHex().slice(0, 8));
+      const anAgentId = fc.constantFrom(...agentIds);
+
+      const commands = fc.commands(
+        [
+          fc.tuple(anAgentId, fc.integer({ min: 1, max: 10 })).map(([agent, count]) => new WriteCommand(agent, count)),
+          fc.constant(new SyncCommand()),
+          anAgentId.map((agent) => new RestartCommand(agent))
+        ],
+        { size: 'large' }
+      );
+
+      const model = fc.asyncProperty(commands, async (commands) => {
+        const feedStore = builder.createFeedStore();
+
+        const agents = new Map(agentIds.map((id) => [id, new Agent(id, feedStore)]));
+        await Promise.all(Array.from(agents.values()).map((agent) => agent.open()));
+        await Promise.all(Array.from(agents.values()).map((agent) => agent.start()));
+
+        const setup: fc.ModelRunSetup<Model, Real> = () => ({
+          model: {},
+          real: {
+            feedStore,
+            agents
+          }
+        });
+
+        try {
+          await fc.asyncModelRun(setup, [...commands, new SyncCommand()]);
+        } finally {
+          await Promise.all(Array.from(agents.values()).map((agent) => agent.stop()));
+          await Promise.all(Array.from(agents.values()).map((agent) => agent.close()));
+        }
+      });
+
+      const examples: [commands: Iterable<fc.AsyncCommand<Model, Real, boolean>>][] = [
+        [[new WriteCommand(agentIds[0], 10), new WriteCommand(agentIds[1], 10), new SyncCommand()]],
+        [[new WriteCommand(agentIds[0], 4), new RestartCommand(agentIds[0]), new SyncCommand()]]
+      ];
+
+      await fc.assert(model, { examples });
+    })
+    .timeout(60_000);
 });

package/src/pipeline/pipeline.ts

@@ -4,7 +4,7 @@
 
 import assert from 'node:assert';
 
-import { sleep, Trigger } from '@dxos/async';
+import { sleep, synchronized, Trigger } from '@dxos/async';
 import { Context, rejectOnDispose } from '@dxos/context';
 import { FeedSetIterator, FeedWrapper, FeedWriter } from '@dxos/feed-store';
 import { PublicKey } from '@dxos/keys';
@@ -15,7 +15,7 @@ import { Timeframe } from '@dxos/timeframe';
 
 import { createMappedFeedWriter } from '../common';
 import { createMessageSelector } from './message-selector';
-import { mapFeedIndexesToTimeframe, mapTimeframeToFeedIndexes, TimeframeClock } from './timeframe-clock';
+import { mapFeedIndexesToTimeframe, startAfter, TimeframeClock } from './timeframe-clock';
 
 export type WaitUntilReachedTargetParams = {
   /**
@@ -54,13 +54,14 @@ export class PipelineState {
    * Latest theoretical timeframe based on the last mutation in each feed.
    * NOTE: This might never be reached if the mutation dependencies
    */
+  // TODO(dmaretskyi): Rename `totalTimeframe`? or `lastTimeframe`.
   get endTimeframe() {
     return mapFeedIndexesToTimeframe(
       this._iterator.feeds
-        .filter((feed) => feed.properties.length > 0)
+        .filter((feed) => feed.length > 0)
         .map((feed) => ({
           feedKey: feed.key,
-          index: feed.properties.length - 1
+          index: feed.length - 1
         }))
     );
   }
@@ -69,10 +70,18 @@ export class PipelineState {
     return this._timeframeClock.timeframe;
   }
 
+  get pendingTimeframe() {
+    return this._timeframeClock.pendingTimeframe;
+  }
+
   get targetTimeframe() {
     return this._targetTimeframe ? this._targetTimeframe : new Timeframe();
   }
 
+  get feeds() {
+    return this._iterator.feeds;
+  }
+
   async waitUntilTimeframe(target: Timeframe) {
     await this._timeframeClock.waitUntilReached(target);
   }
@@ -175,7 +184,7 @@ export class Pipeline implements PipelineAccessor {
 
   // Inbound feed stream.
   private readonly _feedSetIterator = new FeedSetIterator<FeedMessage>(createMessageSelector(this._timeframeClock), {
-    start: mapTimeframeToFeedIndexes(this._initialTimeframe),
+    start: startAfter(this._initialTimeframe),
     stallTimeout: 1000
   });
 
@@ -212,6 +221,8 @@ export class Pipeline implements PipelineAccessor {
     return this._feedSetIterator.feeds;
   }
 
+  // NOTE: This cannot be synchronized with `stop` because stop waits for the mutation processing to complete,
+  // which might be opening feeds during the mutation processing, which w
   async addFeed(feed: FeedWrapper<FeedMessage>) {
     await this._feedSetIterator.addFeed(feed);
   }
@@ -233,12 +244,14 @@ export class Pipeline implements PipelineAccessor {
     );
   }
 
+  @synchronized
   async start() {
     log('starting...', {});
     await this._feedSetIterator.open();
     log('started');
   }
 
+  @synchronized
   async stop() {
     log('stopping...', {});
     await this._feedSetIterator.close();
@@ -256,10 +269,11 @@ export class Pipeline implements PipelineAccessor {
 
     for await (const block of this._feedSetIterator) {
       this._processingTrigger.reset();
+      this._timeframeClock.updatePendingTimeframe(PublicKey.from(block.feedKey), block.seq);
       yield block;
       this._processingTrigger.wake();
 
-      this._timeframeClock.updateTimeframe(PublicKey.from(block.feedKey), block.seq);
+      this._timeframeClock.updateTimeframe();
     }
 
     // TODO(burdon): Test re-entrant?

package/src/pipeline/timeframe-clock.ts

@@ -15,23 +15,45 @@ export const mapTimeframeToFeedIndexes = (timeframe: Timeframe): FeedIndex[] =>
 export const mapFeedIndexesToTimeframe = (indexes: FeedIndex[]): Timeframe =>
   new Timeframe(indexes.map(({ feedKey, index }) => [feedKey, index]));
 
+export const startAfter = (timeframe: Timeframe): FeedIndex[] =>
+  timeframe.frames().map(([feedKey, index]) => ({ feedKey, index: index + 1 }));
+
 /**
  * Keeps state of the last timeframe that was processed by ECHO.
  */
 export class TimeframeClock {
   readonly update = new Event<Timeframe>();
 
+  private _pendingTimeframe: Timeframe;
+
   // prettier-ignore
   constructor(
     private _timeframe = new Timeframe()
-  ) {}
+  ) {
+    this._pendingTimeframe = _timeframe;
+  }
 
+  /**
+   * Timeframe that was processed by ECHO.
+   */
   get timeframe() {
     return this._timeframe;
   }
 
-  updateTimeframe(key: PublicKey, seq: number) {
-    this._timeframe = Timeframe.merge(this._timeframe, new Timeframe([[key, seq]]));
+  /**
+   * Timeframe that is currently being processed by ECHO.
+   * Will be equal to `timeframe` after the processing is complete.
+   */
+  get pendingTimeframe() {
+    return this._pendingTimeframe;
+  }
+
+  updatePendingTimeframe(key: PublicKey, seq: number) {
+    this._pendingTimeframe = Timeframe.merge(this._pendingTimeframe, new Timeframe([[key, seq]]));
+  }
+
+  updateTimeframe() {
+    this._timeframe = this._pendingTimeframe;
     this.update.emit(this._timeframe);
   }
 
@@ -42,7 +64,7 @@ export class TimeframeClock {
 
   @timed(5_000)
   async waitUntilReached(target: Timeframe) {
-    log.debug('waitUntilReached', { target, current: this._timeframe });
+    log.info('waitUntilReached', { target, current: this._timeframe });
     await this.update.waitForCondition(() => {
       log('check if reached', {
         target,

package/src/space/data-pipeline.test.ts

@@ -0,0 +1,3 @@
+//
+// Copyright 2023 DXOS.org
+//

package/src/space/data-pipeline.ts

@@ -4,7 +4,7 @@
 
 import assert from 'node:assert';
 
-import { Event, scheduleTask, synchronized, trackLeaks } from '@dxos/async';
+import { scheduleTask, synchronized, trackLeaks } from '@dxos/async';
 import { Context } from '@dxos/context';
 import { FeedInfo } from '@dxos/credentials';
 import { failUndefined } from '@dxos/debug';
@@ -17,7 +17,7 @@ import { SpaceSnapshot } from '@dxos/protocols/proto/dxos/echo/snapshot';
 import { Timeframe } from '@dxos/timeframe';
 
 import { createMappedFeedWriter } from '../common';
-import { DatabaseBackendHost, SnapshotManager } from '../dbhost';
+import { DatabaseHost, SnapshotManager } from '../dbhost';
 import { MetadataStore } from '../metadata';
 import { Pipeline } from '../pipeline';
 
@@ -46,14 +46,14 @@ const MESSAGES_PER_SNAPSHOT = 10;
 const AUTOMATIC_SNAPSHOT_DEBOUNCE_INTERVAL = 5000;
 
 /**
- * Minimum time between recording latest timeframe in metadata.
+ * Minimum time in MS between recording latest timeframe in metadata.
  */
 const TIMEFRAME_SAVE_DEBOUNCE_INTERVAL = 500;
 
 /**
  * Flag to disable automatic local snapshots.
  */
-const DISABLE_SNAPSHOT_CACHE = false;
+const DISABLE_SNAPSHOT_CACHE = true;
 
 /**
  * Controls data pipeline in the space.
@@ -71,12 +71,13 @@ export class DataPipeline {
   private _lastAutomaticSnapshotTimeframe = new Timeframe();
   private _isOpen = false;
 
-  public readonly onTimeframeReached = new Event<Timeframe>();
+  private _lastTimeframeSaveTime = 0;
+  private _lastSnapshotSaveTime = 0;
 
   constructor(private readonly _params: DataPipelineParams) {}
 
   public _itemManager!: ItemManager;
-  public databaseBackend?: DatabaseBackendHost;
+  public databaseBackend?: DatabaseHost;
 
   get isOpen() {
     return this._isOpen;
@@ -106,7 +107,7 @@ export class DataPipeline {
     }
 
     this._spaceContext = spaceContext;
-    if (this._params.snapshotId) {
+    if (this._params.snapshotId && !DISABLE_SNAPSHOT_CACHE) {
       this._snapshot = await this._params.snapshotManager.load(this._params.snapshotId);
       this._lastAutomaticSnapshotTimeframe = this._snapshot?.timeframe ?? new Timeframe();
     }
@@ -122,7 +123,7 @@ export class DataPipeline {
       this._pipeline.writer ?? failUndefined()
     );
 
-    this.databaseBackend = new DatabaseBackendHost(feedWriter, this._snapshot?.database);
+    this.databaseBackend = new DatabaseHost(feedWriter, this._snapshot?.database);
     this._itemManager = new ItemManager(this._params.modelFactory);
 
     // Connect pipeline to the database.
@@ -133,53 +134,9 @@ export class DataPipeline {
       await this._consumePipeline();
     });
 
-    this._createPeriodicSnapshots();
-
     this._isOpen = true;
   }
 
-  private _createPeriodicSnapshots() {
-    // Record last timeframe.
-    this.onTimeframeReached.debounce(TIMEFRAME_SAVE_DEBOUNCE_INTERVAL).on(this._ctx, async () => {
-      await this._saveLatestTimeframe();
-    });
-
-    if (!DISABLE_SNAPSHOT_CACHE) {
-      this.onTimeframeReached.debounce(AUTOMATIC_SNAPSHOT_DEBOUNCE_INTERVAL).on(this._ctx, async () => {
-        const latestTimeframe = this._pipeline?.state.timeframe;
-        if (!latestTimeframe) {
-          return;
-        }
-
-        // Save snapshot.
-        if (
-          latestTimeframe.totalMessages() - this._lastAutomaticSnapshotTimeframe.totalMessages() >
-          MESSAGES_PER_SNAPSHOT
-        ) {
-          const snapshot = await this._saveSnapshot();
-          this._lastAutomaticSnapshotTimeframe = snapshot.timeframe ?? failUndefined();
-          log('save', { snapshot });
-        }
-      });
-    }
-  }
-
-  private async _saveSnapshot() {
-    const snapshot = await this.createSnapshot();
-    const snapshotKey = await this._params.snapshotManager.store(snapshot);
-    await this._params.metadataStore.setSpaceSnapshot(this._params.spaceKey, snapshotKey);
-    return snapshot;
-  }
-
-  private async _saveLatestTimeframe() {
-    const latestTimeframe = this._pipeline?.state.timeframe;
-    log('save latest timeframe', { latestTimeframe, spaceKey: this._params.spaceKey });
-    if (latestTimeframe) {
-      const newTimeframe = Timeframe.merge(this._targetTimeframe ?? new Timeframe(), latestTimeframe);
-      await this._params.metadataStore.setSpaceLatestTimeframe(this._params.spaceKey, newTimeframe);
-    }
-  }
-
   @synchronized
   async close() {
     if (!this._isOpen) {
@@ -188,28 +145,26 @@ export class DataPipeline {
     log('close');
     this._isOpen = false;
 
+    await this._ctx.dispose();
+    await this._pipeline?.stop();
+
+    // NOTE: Make sure the processing is stopped BEFORE we save the snapshot.
     try {
-      await this._saveLatestTimeframe();
-      await this._saveSnapshot();
+      if (this._pipeline) {
+        await this._saveTargetTimeframe(this._pipeline.state.timeframe);
+        if (!DISABLE_SNAPSHOT_CACHE) {
+          await this._saveSnapshot(this._pipeline.state.timeframe);
+        }
+      }
     } catch (err) {
       log.catch(err);
     }
-    await this._ctx.dispose();
-    await this._pipeline?.stop();
+
     await this.databaseBackend?.close();
     await this._itemManager?.destroy();
     await this._params.snapshotManager.close();
   }
 
-  createSnapshot(): SpaceSnapshot {
-    assert(this.databaseBackend, 'Database backend is not initialized.');
-    return {
-      spaceKey: this._params.spaceKey.asUint8Array(),
-      timeframe: this._pipeline?.state.timeframe ?? new Timeframe(),
-      database: this.databaseBackend!.createSnapshot()
-    };
-  }
-
   private async _consumePipeline() {
     assert(this._pipeline, 'Pipeline is not initialized.');
     for await (const msg of this._pipeline.consume()) {
@@ -233,7 +188,9 @@ export class DataPipeline {
               memberKey: feedInfo.assertion.identityKey
             }
           });
-          this.onTimeframeReached.emit(data.timeframe);
+
+          // Timeframe clock is not updated yet
+          await this._noteTargetStateIfNeeded(this._pipeline.state.pendingTimeframe);
         }
       } catch (err: any) {
         log.catch(err);
@@ -241,6 +198,48 @@ export class DataPipeline {
     }
   }
 
+  private _createSnapshot(timeframe: Timeframe): SpaceSnapshot {
+    assert(this.databaseBackend, 'Database backend is not initialized.');
+    return {
+      spaceKey: this._params.spaceKey.asUint8Array(),
+      timeframe,
+      database: this.databaseBackend!.createSnapshot()
+    };
+  }
+
+  private async _saveSnapshot(timeframe: Timeframe) {
+    const snapshot = await this._createSnapshot(timeframe);
+    const snapshotKey = await this._params.snapshotManager.store(snapshot);
+    await this._params.metadataStore.setSpaceSnapshot(this._params.spaceKey, snapshotKey);
+    return snapshot;
+  }
+
+  private async _saveTargetTimeframe(timeframe: Timeframe) {
+    const newTimeframe = Timeframe.merge(this._targetTimeframe ?? new Timeframe(), timeframe);
+    await this._params.metadataStore.setSpaceLatestTimeframe(this._params.spaceKey, newTimeframe);
+    this._targetTimeframe = newTimeframe;
+  }
+
+  private async _noteTargetStateIfNeeded(timeframe: Timeframe) {
+    if (Date.now() - this._lastTimeframeSaveTime > TIMEFRAME_SAVE_DEBOUNCE_INTERVAL) {
+      this._lastTimeframeSaveTime = Date.now();
+
+      await this._saveTargetTimeframe(timeframe);
+    }
+
+    if (
+      !DISABLE_SNAPSHOT_CACHE &&
+      Date.now() - this._lastSnapshotSaveTime > AUTOMATIC_SNAPSHOT_DEBOUNCE_INTERVAL &&
+      timeframe.totalMessages() - this._lastAutomaticSnapshotTimeframe.totalMessages() > MESSAGES_PER_SNAPSHOT
+    ) {
+      this._lastSnapshotSaveTime = Date.now();
+
+      const snapshot = await this._saveSnapshot(timeframe);
+      this._lastAutomaticSnapshotTimeframe = snapshot.timeframe ?? failUndefined();
+      log('save', { snapshot });
+    }
+  }
+
   async waitUntilTimeframe(timeframe: Timeframe) {
     assert(this._pipeline, 'Pipeline is not initialized.');
     await this._pipeline.state.waitUntilTimeframe(timeframe);

package/src/space/space-manager.ts

@@ -48,6 +48,7 @@ export class SpaceManager {
   private readonly _feedStore: FeedStore<FeedMessage>;
   private readonly _networkManager: NetworkManager;
   private readonly _instanceId = PublicKey.random().toHex();
+  public _traceParent?: string;
 
   constructor({ feedStore, networkManager }: SpaceManagerParams) {
     // TODO(burdon): Assert.
@@ -62,7 +63,7 @@ export class SpaceManager {
 
   @synchronized
   async open() {
-    log.trace('dxos.echo.space-manager', trace.begin({ id: this._instanceId }));
+    log.trace('dxos.echo.space-manager', trace.begin({ id: this._instanceId, parentId: this._traceParent }));
   }
 
   @synchronized

package/src/testing/database-test-rig.ts

@@ -4,7 +4,7 @@
 
 import { Event } from '@dxos/async';
 import { DocumentModel } from '@dxos/document-model';
-import { DatabaseBackendProxy, ItemManager } from '@dxos/echo-db';
+import { DatabaseProxy, ItemManager } from '@dxos/echo-db';
 import { PublicKey } from '@dxos/keys';
 import { ModelFactory } from '@dxos/model-factory';
 import { FeedMessageBlock } from '@dxos/protocols';
@@ -14,7 +14,7 @@ import { TextModel } from '@dxos/text-model';
 import { Timeframe } from '@dxos/timeframe';
 import { ComplexMap, isNotNullOrUndefined } from '@dxos/util';
 
-import { DatabaseBackendHost } from '../dbhost';
+import { DatabaseHost } from '../dbhost';
 
 const SPACE_KEY = PublicKey.random();
 
@@ -33,9 +33,9 @@ export class DatabaseTestPeer {
   public readonly modelFactory = new ModelFactory().registerModel(DocumentModel).registerModel(TextModel);
 
   public items!: ItemManager;
-  public proxy!: DatabaseBackendProxy;
+  public proxy!: DatabaseProxy;
 
-  public host!: DatabaseBackendHost;
+  public host!: DatabaseHost;
   public hostItems!: ItemManager;
 
   //
@@ -64,7 +64,7 @@ export class DatabaseTestPeer {
 
   async open() {
     this.hostItems = new ItemManager(this.modelFactory);
-    this.host = new DatabaseBackendHost(
+    this.host = new DatabaseHost(
       {
         write: async (message) => {
           const seq =
@@ -86,7 +86,7 @@ export class DatabaseTestPeer {
     );
     await this.host.open(this.hostItems, this.modelFactory);
 
-    this.proxy = new DatabaseBackendProxy(this.host.createDataServiceHost(), SPACE_KEY);
+    this.proxy = new DatabaseProxy(this.host.createDataServiceHost(), SPACE_KEY);
     this.items = new ItemManager(this.modelFactory);
     await this.proxy.open(this.items, this.modelFactory);
   }