@dxos/client-services 0.1.31 → 0.1.32-next.77d513e

package/src/packlets/services/service-context.test.ts

@@ -18,8 +18,9 @@ describe('services/ServiceContext', () => {
     const device2 = createServiceContext({ signalContext: networkContext });
     await performInvitation(device1.deviceInvitations, device2.deviceInvitations, undefined);
 
+    await device2.dataSpaceManager!.waitUntilSpaceReady(space1!.key);
     const space2 = await device2.dataSpaceManager!.spaces.get(space1.key);
-    await syncItemsLocal(space1.dataPipelineController, space2!.dataPipelineController);
+    await syncItemsLocal(space1.dataPipeline, space2!.dataPipeline);
   });
 
   test('new space is synchronized on device invitations', async () => {
@@ -31,9 +32,9 @@ describe('services/ServiceContext', () => {
     await performInvitation(device1.deviceInvitations, device2.deviceInvitations, undefined);
 
     const space1 = await device1.dataSpaceManager!.createSpace();
-    await device2.dataSpaceManager?.updated.waitForCondition(() => !!device2.dataSpaceManager!.spaces.get(space1.key));
+    await device2.dataSpaceManager!.waitUntilSpaceReady(space1!.key);
     const space2 = await device2.dataSpaceManager!.spaces.get(space1.key);
-    await syncItemsLocal(space1.dataPipelineController, space2!.dataPipelineController);
+    await syncItemsLocal(space1.dataPipeline, space2!.dataPipeline);
   });
 
   test('joined space is synchronized on device invitations', async () => {
@@ -49,8 +50,8 @@ describe('services/ServiceContext', () => {
     const space1 = await identity2.dataSpaceManager!.createSpace();
     await performInvitation(identity2.spaceInvitations!, device1.spaceInvitations!, space1);
 
-    await device2.dataSpaceManager?.updated.waitForCondition(() => !!device2.dataSpaceManager!.spaces.get(space1.key));
+    await device2.dataSpaceManager!.waitUntilSpaceReady(space1!.key);
     const space2 = await device2.dataSpaceManager!.spaces.get(space1.key);
-    await syncItemsLocal(space1.dataPipelineController, space2!.dataPipelineController);
+    await syncItemsLocal(space1.dataPipeline, space2!.dataPipeline);
   });
 });

package/src/packlets/services/service-host.ts

@@ -62,6 +62,7 @@ export class ClientServicesHost {
    * @internal
    */
   _serviceContext!: ServiceContext;
+  private _opening = false;
   private _open = false;
 
   constructor({
@@ -83,7 +84,9 @@ export class ClientServicesHost {
     this._resourceLock = lockKey
       ? new VaultResourceLock({
           lockKey,
-          onAcquire: () => this.open(),
+          onAcquire: () => {
+            this._opening || this.open();
+          },
           onRelease: () => this.close()
         })
       : undefined;
@@ -163,7 +166,8 @@ export class ClientServicesHost {
     assert(this._storage, 'storage not set');
     assert(this._networkManager, 'network manager not set');
 
-    log('opening...');
+    this._opening = true;
+    log('opening...', { lockKey: this._resourceLock?.lockKey });
     await this._resourceLock?.acquire();
 
     // TODO(wittjosiah): Make re-entrant.
@@ -213,6 +217,7 @@ export class ClientServicesHost {
     });
 
     await this._serviceContext.open();
+    this._opening = false;
     this._open = true;
     this._statusUpdate.emit();
     const deviceKey = this._serviceContext.identityManager.identity?.deviceKey;

package/src/packlets/spaces/data-space-manager.test.ts

@@ -11,7 +11,7 @@ import { AuthStatus, DataServiceSubscriptions } from '@dxos/echo-pipeline';
 import { writeMessages } from '@dxos/feed-store';
 import { log } from '@dxos/log';
 import { ModelFactory } from '@dxos/model-factory';
-import { test, describe } from '@dxos/test';
+import { test, describe, afterTest } from '@dxos/test';
 
 import { createSigningContext, HostTestBuilder, syncItemsLocal } from '../testing';
 import { DataSpaceManager } from './data-space-manager';
@@ -32,6 +32,8 @@ describe('DataSpaceManager', () => {
       peer.feedStore,
       peer.snapshotStore
     );
+    await dataSpaceManager.open();
+    afterTest(() => dataSpaceManager.close());
     const space = await dataSpaceManager.createSpace();
 
     // Process all written mutations.
@@ -58,6 +60,8 @@ describe('DataSpaceManager', () => {
       peer1.feedStore,
       peer1.snapshotStore
     );
+    await dataSpaceManager1.open();
+    afterTest(() => dataSpaceManager1.close());
 
     const peer2 = builder.createPeer();
     const identity2 = await createSigningContext(peer2.keyring);
@@ -71,6 +75,8 @@ describe('DataSpaceManager', () => {
       peer2.feedStore,
       peer1.snapshotStore
     );
+    await dataSpaceManager2.open();
+    afterTest(() => dataSpaceManager2.close());
 
     const space1 = await dataSpaceManager1.createSpace();
     await space1.inner.controlPipeline.state.waitUntilTimeframe(space1.inner.controlPipeline.state.endTimeframe);
@@ -91,6 +97,7 @@ describe('DataSpaceManager', () => {
       spaceKey: space1.key,
       genesisFeedKey: space1.inner.genesisFeedKey
     });
+    await dataSpaceManager2.waitUntilSpaceReady(space2.key);
 
     log('', {
       peer1: {
@@ -122,7 +129,7 @@ describe('DataSpaceManager', () => {
     });
     log.break();
 
-    await syncItemsLocal(space1.dataPipelineController, space2.dataPipelineController);
+    await syncItemsLocal(space1.dataPipeline, space2.dataPipeline);
 
     expect(space1.inner.protocol.sessions.get(identity2.deviceKey)).to.exist;
     expect(space1.inner.protocol.sessions.get(identity2.deviceKey)?.authStatus).to.equal(AuthStatus.SUCCESS);
@@ -145,6 +152,8 @@ describe('DataSpaceManager', () => {
       peer1.feedStore,
       peer1.snapshotStore
     );
+    await dataSpaceManager1.open();
+    afterTest(() => dataSpaceManager1.close());
 
     const peer2 = builder.createPeer();
     const identity2 = await createSigningContext(peer2.keyring);
@@ -158,6 +167,8 @@ describe('DataSpaceManager', () => {
       peer2.feedStore,
       peer1.snapshotStore
     );
+    await dataSpaceManager2.open();
+    afterTest(() => dataSpaceManager2.close());
 
     const space1 = await dataSpaceManager1.createSpace();
     await space1.inner.controlPipeline.state.waitUntilTimeframe(space1.inner.controlPipeline.state.endTimeframe);
@@ -179,6 +190,10 @@ describe('DataSpaceManager', () => {
       genesisFeedKey: space1.inner.genesisFeedKey
     });
 
+    // Coincidentally, this also waits until a P2P connection is established between peers.
+    // TODO(dmaretskyi): Refine this to wait for connection specifically.
+    await dataSpaceManager2.waitUntilSpaceReady(space2.key);
+
     const [receivedMessage, inc] = latch({ count: 1 });
     space2.listen('test', (message) => {
       expect(message.channelId).to.equal('test');

package/src/packlets/spaces/data-space-manager.ts

@@ -5,17 +5,18 @@
 import assert from 'node:assert';
 
 import { Event, synchronized, trackLeaks } from '@dxos/async';
-import { Context } from '@dxos/context';
+import { SpaceState } from '@dxos/client';
+import { cancelWithContext, Context } from '@dxos/context';
 import { getCredentialAssertion } from '@dxos/credentials';
 import {
+  DataServiceSubscriptions,
   MetadataStore,
   SigningContext,
+  SnapshotManager,
+  SnapshotStore,
   Space,
   spaceGenesis,
-  SpaceManager,
-  DataServiceSubscriptions,
-  SnapshotManager,
-  SnapshotStore
+  SpaceManager
 } from '@dxos/echo-pipeline';
 import { FeedStore } from '@dxos/feed-store';
 import { Keyring } from '@dxos/keyring';
@@ -25,16 +26,27 @@ import { ModelFactory } from '@dxos/model-factory';
 import { FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
 import { SpaceMetadata } from '@dxos/protocols/proto/dxos/echo/metadata';
 import { Gossip, Presence } from '@dxos/teleport-extension-gossip';
+import { Timeframe } from '@dxos/timeframe';
 import { ComplexMap, deferFunction } from '@dxos/util';
 
 import { createAuthProvider } from '../identity';
 import { DataSpace } from './data-space';
 
-const DATA_PIPELINE_READY_TIMEOUT = 3_000;
-
 export type AcceptSpaceOptions = {
   spaceKey: PublicKey;
   genesisFeedKey: PublicKey;
+
+  /**
+   * Latest known timeframe for the control pipeline.
+   * We will try to catch up to this timeframe before starting the data pipeline.
+   */
+  controlTimeframe?: Timeframe;
+
+  /**
+   * Latest known timeframe for the data pipeline.
+   * We will try to catch up to this timeframe before initializing the database.
+   */
+  dataTimeframe?: Timeframe;
 };
 
 @trackLeaks('open', 'close')
@@ -45,6 +57,8 @@ export class DataSpaceManager {
 
   private readonly _spaces = new ComplexMap<PublicKey, DataSpace>(PublicKey.hash);
 
+  private _isOpen = false;
+
   constructor(
     private readonly _spaceManager: SpaceManager,
     private readonly _metadataStore: MetadataStore,
@@ -63,29 +77,24 @@ export class DataSpaceManager {
 
   @synchronized
   async open() {
+    log('open');
     await this._metadataStore.load();
     log('metadata loaded', { spaces: this._metadataStore.spaces.length });
 
     for (const spaceMetadata of this._metadataStore.spaces) {
       log('load space', { spaceMetadata });
       const space = await this._constructSpace(spaceMetadata);
-      await space.initializeDataPipeline();
-      if (spaceMetadata.dataTimeframe) {
-        log('waiting for latest timeframe', { spaceMetadata });
-        await space.dataPipelineController.pipelineState!.setTargetTimeframe(spaceMetadata.dataTimeframe);
-      }
-      await space.dataPipelineController.pipelineState!.waitUntilReachedTargetTimeframe({
-        timeout: DATA_PIPELINE_READY_TIMEOUT
-      });
-      this._dataServiceSubscriptions.registerSpace(
-        space.key,
-        space.dataPipelineController.databaseBackend!.createDataServiceHost()
-      );
+      space.initializeDataPipelineAsync();
     }
+
+    this._isOpen = true;
+    this.updated.emit();
   }
 
   @synchronized
   async close() {
+    log('close');
+    this._isOpen = false;
     await this._ctx.dispose();
     for (const space of this._spaces.values()) {
       await space.close();
@@ -97,6 +106,7 @@ export class DataSpaceManager {
    */
   @synchronized
   async createSpace() {
+    assert(this._isOpen, 'Not open.');
     const spaceKey = await this._keyring.createKey();
     const controlFeedKey = await this._keyring.createKey();
     const dataFeedKey = await this._keyring.createKey();
@@ -118,10 +128,6 @@ export class DataSpaceManager {
     await this._signingContext.recordCredential(memberCredential);
 
     await space.initializeDataPipeline();
-    this._dataServiceSubscriptions.registerSpace(
-      space.key,
-      space.dataPipelineController.databaseBackend!.createDataServiceHost()
-    );
 
     this.updated.emit();
     return space;
@@ -130,26 +136,43 @@ export class DataSpaceManager {
   // TODO(burdon): Rename join space.
   @synchronized
   async acceptSpace(opts: AcceptSpaceOptions): Promise<DataSpace> {
+    log('accept space', { opts });
+    assert(this._isOpen, 'Not open.');
     assert(!this._spaces.has(opts.spaceKey), 'Space already exists.');
 
     const metadata: SpaceMetadata = {
       key: opts.spaceKey,
-      genesisFeedKey: opts.genesisFeedKey
+      genesisFeedKey: opts.genesisFeedKey,
+      controlTimeframe: opts.controlTimeframe,
+      dataTimeframe: opts.dataTimeframe
     };
 
     const space = await this._constructSpace(metadata);
     await this._metadataStore.addSpace(metadata);
-    await space.initializeDataPipeline();
-    this._dataServiceSubscriptions.registerSpace(
-      space.key,
-      space.dataPipelineController.databaseBackend!.createDataServiceHost()
-    );
+
+    space.initializeDataPipelineAsync();
 
     this.updated.emit();
     return space;
   }
 
+  /**
+   * Wait until the space data pipeline is fully initialized.
+   * Used by invitation handler.
+   * TODO(dmaretskyi): Consider removing.
+   */
+  async waitUntilSpaceReady(spaceKey: PublicKey) {
+    await cancelWithContext(
+      this._ctx,
+      this.updated.waitForCondition(() => {
+        const space = this._spaces.get(spaceKey);
+        return !!space && space.state === SpaceState.READY;
+      })
+    );
+  }
+
   private async _constructSpace(metadata: SpaceMetadata) {
+    log('construct space', { metadata });
     const gossip = new Gossip({
       localPeerId: this._signingContext.deviceKey
     });
@@ -195,10 +218,33 @@ export class DataSpaceManager {
       keyring: this._keyring,
       feedStore: this._feedStore,
       signingContext: this._signingContext,
-      snapshotId: metadata.snapshot
+      snapshotId: metadata.snapshot,
+      callbacks: {
+        beforeReady: async () => {
+          log('before space ready', { space: space.key });
+          this._dataServiceSubscriptions.registerSpace(
+            space.key,
+            dataSpace.dataPipeline.databaseBackend!.createDataServiceHost()
+          );
+        },
+        afterReady: async () => {
+          log('after space ready', { space: space.key, open: this._isOpen });
+          if (this._isOpen) {
+            this.updated.emit();
+          }
+        }
+      }
     });
 
     await dataSpace.open();
+
+    if (metadata.controlTimeframe) {
+      dataSpace.inner.controlPipeline.state.setTargetTimeframe(metadata.controlTimeframe);
+    }
+    if (metadata.dataTimeframe) {
+      dataSpace.dataPipeline.setTargetTimeframe(metadata.dataTimeframe);
+    }
+
     this._spaces.set(metadata.key, dataSpace);
     return dataSpace;
   }

package/src/packlets/spaces/data-space.ts

@@ -2,21 +2,24 @@
 // Copyright 2022 DXOS.org
 //
 
-import { trackLeaks } from '@dxos/async';
+import { Event, scheduleTask, trackLeaks } from '@dxos/async';
+import { SpaceState } from '@dxos/client';
 import { Context } from '@dxos/context';
 import { CredentialConsumer } from '@dxos/credentials';
 import { timed } from '@dxos/debug';
 import {
-  DataPipelineControllerImpl,
   MetadataStore,
   Space,
   SigningContext,
   createMappedFeedWriter,
-  SnapshotManager
+  SnapshotManager,
+  DataPipeline
 } from '@dxos/echo-pipeline';
+import { CancelledError, SystemError } from '@dxos/errors';
 import { FeedStore } from '@dxos/feed-store';
 import { Keyring } from '@dxos/keyring';
 import { PublicKey } from '@dxos/keys';
+import { log } from '@dxos/log';
 import { ModelFactory } from '@dxos/model-factory';
 import { FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
 import { AdmittedFeed, Credential } from '@dxos/protocols/proto/dxos/halo/credentials';
@@ -29,6 +32,18 @@ import { NotarizationPlugin } from './notarization-plugin';
 
 const AUTH_TIMEOUT = 30000;
 
+export type DataSpaceCallbacks = {
+  /**
+   * Called before transitioning to the ready state.
+   */
+  beforeReady?: () => Promise<void>;
+
+  /**
+   * Called after transitioning to the ready state.
+   */
+  afterReady?: () => Promise<void>;
+};
+
 export type DataSpaceParams = {
   inner: Space;
   modelFactory: ModelFactory;
@@ -41,13 +56,13 @@ export type DataSpaceParams = {
   signingContext: SigningContext;
   memberKey: PublicKey;
   snapshotId?: string | undefined;
+  callbacks?: DataSpaceCallbacks;
 };
 
-const CONTROL_PIPELINE_READY_TIMEFRAME = 3000;
 @trackLeaks('open', 'close')
 export class DataSpace {
   private readonly _ctx = new Context();
-  private readonly _dataPipelineController: DataPipelineControllerImpl;
+  private readonly _dataPipeline: DataPipeline;
   private readonly _inner: Space;
   private readonly _gossip: Gossip;
   private readonly _presence: Presence;
@@ -56,18 +71,25 @@ export class DataSpace {
   private readonly _metadataStore: MetadataStore;
   private readonly _signingContext: SigningContext;
   private readonly _notarizationPluginConsumer: CredentialConsumer<NotarizationPlugin>;
+  private readonly _callbacks: DataSpaceCallbacks;
+
+  private _state = SpaceState.CLOSED;
 
   public readonly authVerifier: TrustedKeySetAuthVerifier;
+  public readonly stateUpdate = new Event();
 
   constructor(params: DataSpaceParams) {
     this._inner = params.inner;
+    this._inner.stateUpdate.on(this._ctx, () => this.stateUpdate.emit());
+
     this._gossip = params.gossip;
     this._presence = params.presence;
     this._keyring = params.keyring;
     this._feedStore = params.feedStore;
     this._metadataStore = params.metadataStore;
     this._signingContext = params.signingContext;
-    this._dataPipelineController = new DataPipelineControllerImpl({
+    this._callbacks = params.callbacks ?? {};
+    this._dataPipeline = new DataPipeline({
       modelFactory: params.modelFactory,
       metadataStore: params.metadataStore,
       snapshotManager: params.snapshotManager,
@@ -94,17 +116,17 @@ export class DataSpace {
     return this._inner.isOpen;
   }
 
+  get state(): SpaceState {
+    return this._state;
+  }
+
   // TODO(burdon): Can we mark this for debugging only?
   get inner() {
     return this._inner;
   }
 
-  get dataPipelineController(): DataPipelineControllerImpl {
-    return this._dataPipelineController;
-  }
-
-  get stateUpdate() {
-    return this._inner.stateUpdate;
+  get dataPipeline(): DataPipeline {
+    return this._dataPipeline;
   }
 
   get presence() {
@@ -119,11 +141,14 @@ export class DataSpace {
     await this.notarizationPlugin.open();
     await this._notarizationPluginConsumer.open();
     await this._inner.open();
+    this._state = SpaceState.INACTIVE;
   }
 
   async close() {
+    this._state = SpaceState.CLOSED;
     await this._ctx.dispose();
 
+    await this._dataPipeline.close();
     await this.authVerifier.close();
 
     await this._inner.close();
@@ -141,12 +166,40 @@ export class DataSpace {
     return this._gossip.listen(channel, callback);
   }
 
+  /**
+   * Initialize the data pipeline in a separate task.
+   */
+  initializeDataPipelineAsync() {
+    scheduleTask(this._ctx, async () => {
+      try {
+        await this.initializeDataPipeline();
+      } catch (err) {
+        if (err instanceof CancelledError) {
+          log('Data pipeline initialization cancelled', err);
+          return;
+        }
+
+        log.error('Error initializing data pipeline', err);
+      }
+    });
+  }
+
   async initializeDataPipeline() {
+    if (this._state !== SpaceState.INACTIVE) {
+      throw new SystemError('Invalid operation');
+    }
+    this._state = SpaceState.INITIALIZING;
+
+    // TODO(dmaretskyi): Cancel with context.
     await this._inner.controlPipeline.state.waitUntilReachedTargetTimeframe({
-      timeout: CONTROL_PIPELINE_READY_TIMEFRAME
+      ctx: this._ctx,
+      breakOnStall: false
     });
 
     await this._createWritableFeeds();
+    log('Writable feeds created');
+    this.stateUpdate.emit();
+
     this.notarizationPlugin.setWriter(
       createMappedFeedWriter<Credential, FeedMessage.Payload>(
         (credential) => ({
@@ -156,7 +209,28 @@ export class DataSpace {
       )
     );
 
-    await this._inner.initDataPipeline(this._dataPipelineController);
+    await this._dataPipeline.open({
+      openPipeline: async (start) => {
+        const pipeline = await this._inner.createDataPipeline({ start });
+        await pipeline.start();
+        return pipeline;
+      }
+    });
+
+    log('waiting for data pipeline to reach target timeframe');
+    // Wait for the data pipeline to catch up to its desired timeframe.
+    await this._dataPipeline.pipelineState!.waitUntilReachedTargetTimeframe({
+      ctx: this._ctx,
+      breakOnStall: false
+    });
+
+    log('data pipeline ready');
+    await this._callbacks.beforeReady?.();
+
+    this._state = SpaceState.READY;
+    this.stateUpdate.emit();
+
+    await this._callbacks.afterReady?.();
   }
 
   @timed(10_000)
@@ -198,7 +272,8 @@ export class DataSpace {
     }
 
     if (credentials.length > 0) {
-      await this.notarizationPlugin.notarize(credentials);
+      // Never times out
+      await this.notarizationPlugin.notarize({ ctx: this._ctx, credentials, timeout: 0 });
     }
 
     // Set this after credentials are notarized so that on failure we will retry.

package/src/packlets/spaces/notarization-plugin.test.ts

@@ -70,7 +70,9 @@ describe('NotarizationPlugin', () => {
       AdmittedFeed.Designation.CONTROL
     );
 
-    const notarized = peer2.notarizationPlugin.notarize([credential]);
+    const notarized = peer2.notarizationPlugin.notarize({
+      credentials: [credential]
+    });
 
     await testBuilder.connect(peer1, peer2);
     await notarized;