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

package/src/packlets/invitations/space-invitations-handler.test.ts

@@ -28,6 +28,17 @@ describe('services/space-invitations-handler', () => {
 
     const space = await peer.dataSpaceManager!.createSpace();
     expect(peer.dataSpaceManager!.spaces.has(space.key)).to.be.true;
+
+    await space.close();
+  });
+
+  test('genesis & ready', async () => {
+    const [peer] = await asyncChain<ServiceContext>([createIdentity, closeAfterTest])(createPeers(1));
+
+    const space = await peer.dataSpaceManager!.createSpace();
+    expect(peer.dataSpaceManager!.spaces.has(space.key)).to.be.true;
+
+    await peer.dataSpaceManager?.waitUntilSpaceReady(space.key);
     await space.close();
   });
 
@@ -36,7 +47,7 @@ describe('services/space-invitations-handler', () => {
     const space = await peer.dataSpaceManager!.createSpace();
     afterTest(() => space.close());
 
-    await testLocalDatabase(space.dataPipelineController);
+    await testLocalDatabase(space.dataPipeline);
   });
 
   test('invitation with no auth', async () => {
@@ -53,7 +64,10 @@ describe('services/space-invitations-handler', () => {
       expect(space1).not.to.be.undefined;
       expect(space2).not.to.be.undefined;
 
-      await syncItemsLocal(space1.dataPipelineController, space2.dataPipelineController);
+      await host.dataSpaceManager?.waitUntilSpaceReady(space1.key);
+      await guest.dataSpaceManager?.waitUntilSpaceReady(space2.key);
+
+      await syncItemsLocal(space1.dataPipeline, space2.dataPipeline);
 
       await space1.close();
       await space2.close();
@@ -116,7 +130,10 @@ describe('services/space-invitations-handler', () => {
       expect(space1).not.to.be.undefined;
       expect(space2).not.to.be.undefined;
 
-      await syncItemsLocal(space1.dataPipelineController, space2.dataPipelineController);
+      await host.dataSpaceManager?.waitUntilSpaceReady(space1.key);
+      await guest.dataSpaceManager?.waitUntilSpaceReady(space2.key);
+
+      await syncItemsLocal(space1.dataPipeline, space2.dataPipeline);
 
       await space1.close();
       await space2.close();

package/src/packlets/invitations/space-invitations-handler.ts

@@ -177,7 +177,11 @@ export class SpaceInvitationsHandler extends AbstractInvitationsHandler<DataSpac
             // Updating credentials complete.
             complete.wake(deviceKey);
 
-            return { credential: spaceMemberCredential };
+            return {
+              credential: spaceMemberCredential,
+              controlTimeframe: space.inner.controlPipeline.state.timeframe,
+              dataTimeframe: space.dataPipeline.pipelineState?.timeframe
+            };
           } catch (err) {
             // TODO(burdon): Generic RPC callback to report error to client.
             observable.callback.onError(err);
@@ -316,12 +320,13 @@ export class SpaceInvitationsHandler extends AbstractInvitationsHandler<DataSpac
 
               // 4. Send admission credentials to host (with local space keys).
               log('request admission', { guest: this._signingContext.deviceKey });
-              const { credential } = await extension.rpc.SpaceHostService.requestAdmission({
-                identityKey: this._signingContext.identityKey,
-                deviceKey: this._signingContext.deviceKey,
-                controlFeedKey,
-                dataFeedKey
-              });
+              const { credential, controlTimeframe, dataTimeframe } =
+                await extension.rpc.SpaceHostService.requestAdmission({
+                  identityKey: this._signingContext.identityKey,
+                  deviceKey: this._signingContext.deviceKey,
+                  controlFeedKey,
+                  dataFeedKey
+                });
 
               // 4. Create local space.
               const assertion = getCredentialAssertion(credential);
@@ -330,7 +335,9 @@ export class SpaceInvitationsHandler extends AbstractInvitationsHandler<DataSpac
 
               const space = await this._spaceManager.acceptSpace({
                 spaceKey: assertion.spaceKey,
-                genesisFeedKey: assertion.genesisFeedKey
+                genesisFeedKey: assertion.genesisFeedKey,
+                controlTimeframe,
+                dataTimeframe
               });
 
               // Record credential in our HALO.

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

@@ -4,13 +4,14 @@
 
 import { expect } from 'chai';
 
+import { latch } from '@dxos/async';
 import { createAdmissionCredentials } from '@dxos/credentials';
 import { DocumentModel } from '@dxos/document-model';
 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';
@@ -31,6 +32,8 @@ describe('DataSpaceManager', () => {
       peer.feedStore,
       peer.snapshotStore
     );
+    await dataSpaceManager.open();
+    afterTest(() => dataSpaceManager.close());
     const space = await dataSpaceManager.createSpace();
 
     // Process all written mutations.
@@ -57,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);
@@ -70,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);
@@ -90,6 +97,7 @@ describe('DataSpaceManager', () => {
       spaceKey: space1.key,
       genesisFeedKey: space1.inner.genesisFeedKey
     });
+    await dataSpaceManager2.waitUntilSpaceReady(space2.key);
 
     log('', {
       peer1: {
@@ -121,11 +129,78 @@ 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);
     expect(space2.inner.protocol.sessions.get(identity1.deviceKey)).to.exist;
     expect(space2.inner.protocol.sessions.get(identity1.deviceKey)?.authStatus).to.equal(AuthStatus.SUCCESS);
   });
+
+  test('pub/sub API', async () => {
+    const builder = new HostTestBuilder();
+
+    const peer1 = builder.createPeer();
+    const identity1 = await createSigningContext(peer1.keyring);
+    const dataSpaceManager1 = new DataSpaceManager(
+      peer1.spaceManager,
+      peer1.metadataStore,
+      new DataServiceSubscriptions(),
+      peer1.keyring,
+      identity1,
+      new ModelFactory().registerModel(DocumentModel),
+      peer1.feedStore,
+      peer1.snapshotStore
+    );
+    await dataSpaceManager1.open();
+    afterTest(() => dataSpaceManager1.close());
+
+    const peer2 = builder.createPeer();
+    const identity2 = await createSigningContext(peer2.keyring);
+    const dataSpaceManager2 = new DataSpaceManager(
+      peer2.spaceManager,
+      peer2.metadataStore,
+      new DataServiceSubscriptions(),
+      peer2.keyring,
+      identity2,
+      new ModelFactory().registerModel(DocumentModel),
+      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);
+
+    // Admit peer2 to space1.
+    await writeMessages(
+      space1.inner.controlPipeline.writer,
+      await createAdmissionCredentials(
+        identity1.credentialSigner,
+        identity2.identityKey,
+        space1.key,
+        space1.inner.genesisFeedKey
+      )
+    );
+
+    // Accept must be called after admission so that the peer can authenticate for notarization.
+    const space2 = await dataSpaceManager2.acceptSpace({
+      spaceKey: space1.key,
+      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');
+      inc();
+    });
+
+    await space1.postMessage('test', { '@type': 'google.protobuf.Any', test: true });
+    await receivedMessage();
+  });
 });

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';
@@ -24,17 +25,28 @@ import { log } from '@dxos/log';
 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 { Presence } from '@dxos/teleport-extension-presence';
+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,31 +136,51 @@ 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
+    });
     const presence = new Presence({
-      localPeerId: this._signingContext.deviceKey,
-      announceInterval: 1_000,
-      offlineTimeout: 10_000, // TODO(burdon): Config.
-      identityKey: this._signingContext.identityKey
+      announceInterval: 500,
+      offlineTimeout: 5_000, // TODO(burdon): Config.
+      identityKey: this._signingContext.identityKey,
+      gossip
     });
     const snapshotManager = new SnapshotManager(this._snapshotStore);
 
@@ -171,8 +197,8 @@ export class DataSpaceManager {
       },
       onNetworkConnection: (session) => {
         session.addExtension(
-          'dxos.mesh.teleport.presence',
-          presence.createExtension({ remotePeerId: session.remotePeerId })
+          'dxos.mesh.teleport.gossip',
+          gossip.createExtension({ remotePeerId: session.remotePeerId })
         );
         session.addExtension('dxos.mesh.teleport.objectsync', snapshotManager.objectSync.createExtension());
         session.addExtension('dxos.mesh.teleport.notarization', dataSpace.notarizationPlugin.createExtension());
@@ -186,15 +212,39 @@ export class DataSpaceManager {
       modelFactory: this._modelFactory,
       metadataStore: this._metadataStore,
       snapshotManager,
+      gossip,
       presence,
       memberKey: this._signingContext.identityKey,
       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;
   }