@dxos/client-services 0.1.53-main.52ca4e9 → 0.1.53-main.5bcfb84

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

@@ -5,38 +5,30 @@
 import { expect } from 'chai';
 import path from 'node:path';
 
-import { latch } from '@dxos/async';
+import { asyncTimeout, latch } from '@dxos/async';
 import { SpecificCredential, createAdmissionCredentials } from '@dxos/credentials';
-import { AuthStatus, DataServiceSubscriptions } from '@dxos/echo-pipeline';
+import { AuthStatus } from '@dxos/echo-pipeline';
 import { testLocalDatabase } from '@dxos/echo-pipeline/testing';
 import { writeMessages } from '@dxos/feed-store';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
+import { SpaceState } from '@dxos/protocols/proto/dxos/client/services';
 import { Epoch } from '@dxos/protocols/proto/dxos/halo/credentials';
 import { StorageType } from '@dxos/random-access-storage';
-import { afterTest, describe, test } from '@dxos/test';
+import { afterTest, describe, openAndClose, test } from '@dxos/test';
 import { range } from '@dxos/util';
 
-import { createSigningContext, TestBuilder, syncItemsLocal } from '../testing';
-import { DataSpaceManager } from './data-space-manager';
+import { TestBuilder, syncItemsLocal } from '../testing';
 
 describe('DataSpaceManager', () => {
   test('create space', async () => {
     const builder = new TestBuilder();
 
     const peer = builder.createPeer();
-    const identity = await createSigningContext(peer.keyring);
-    const dataSpaceManager = new DataSpaceManager(
-      peer.spaceManager,
-      peer.metadataStore,
-      new DataServiceSubscriptions(),
-      peer.keyring,
-      identity,
-      peer.feedStore,
-    );
-    await dataSpaceManager.open();
-    afterTest(() => dataSpaceManager.close());
-    const space = await dataSpaceManager.createSpace();
+    await peer.createIdentity();
+    await openAndClose(peer.dataSpaceManager);
+
+    const space = await peer.dataSpaceManager.createSpace();
 
     // Process all written mutations.
     await space.inner.controlPipeline.state.waitUntilTimeframe(space.inner.controlPipeline.state.endTimeframe);
@@ -51,62 +43,44 @@ describe('DataSpaceManager', () => {
     const builder = new TestBuilder();
 
     const peer1 = builder.createPeer();
-    const identity1 = await createSigningContext(peer1.keyring);
-    const dataSpaceManager1 = new DataSpaceManager(
-      peer1.spaceManager,
-      peer1.metadataStore,
-      new DataServiceSubscriptions(),
-      peer1.keyring,
-      identity1,
-      peer1.feedStore,
-    );
-    await dataSpaceManager1.open();
-    afterTest(() => dataSpaceManager1.close());
+    await peer1.createIdentity();
 
     const peer2 = builder.createPeer();
-    const identity2 = await createSigningContext(peer2.keyring);
-    const dataSpaceManager2 = new DataSpaceManager(
-      peer2.spaceManager,
-      peer2.metadataStore,
-      new DataServiceSubscriptions(),
-      peer2.keyring,
-      identity2,
-      peer2.feedStore,
-    );
-    await dataSpaceManager2.open();
-    afterTest(() => dataSpaceManager2.close());
+    await peer2.createIdentity();
+
+    await openAndClose(peer1.dataSpaceManager, peer2.dataSpaceManager);
 
-    const space1 = await dataSpaceManager1.createSpace();
+    const space1 = await peer1.dataSpaceManager.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,
+        peer1.identity.credentialSigner,
+        peer2.identity.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({
+    const space2 = await peer2.dataSpaceManager.acceptSpace({
       spaceKey: space1.key,
       genesisFeedKey: space1.inner.genesisFeedKey,
     });
-    await dataSpaceManager2.waitUntilSpaceReady(space2.key);
+    await peer2.dataSpaceManager.waitUntilSpaceReady(space2.key);
 
     log('', {
       peer1: {
-        identity: identity1.identityKey,
-        device: identity1.deviceKey,
+        identity: peer1.identity.identityKey,
+        device: peer1.identity.deviceKey,
         control: space1.inner.controlFeedKey,
         data: space1.inner.dataFeedKey,
       },
       peer2: {
-        identity: identity2.identityKey,
-        device: identity2.deviceKey,
+        identity: peer2.identity.identityKey,
+        device: peer2.identity.deviceKey,
         control: space2.inner.controlFeedKey,
         data: space2.inner.dataFeedKey,
       },
@@ -129,64 +103,47 @@ describe('DataSpaceManager', () => {
 
     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);
+    expect(space1.inner.protocol.sessions.get(peer2.identity.deviceKey)).to.exist;
+    expect(space1.inner.protocol.sessions.get(peer2.identity.deviceKey)?.authStatus).to.equal(AuthStatus.SUCCESS);
+    expect(space2.inner.protocol.sessions.get(peer1.identity.deviceKey)).to.exist;
+    expect(space2.inner.protocol.sessions.get(peer1.identity.deviceKey)?.authStatus).to.equal(AuthStatus.SUCCESS);
   });
 
   test('pub/sub API', async () => {
     const builder = new TestBuilder();
 
     const peer1 = builder.createPeer();
-    const identity1 = await createSigningContext(peer1.keyring);
-    const dataSpaceManager1 = new DataSpaceManager(
-      peer1.spaceManager,
-      peer1.metadataStore,
-      new DataServiceSubscriptions(),
-      peer1.keyring,
-      identity1,
-      peer1.feedStore,
-    );
-    await dataSpaceManager1.open();
-    afterTest(() => dataSpaceManager1.close());
+    await peer1.createIdentity();
 
     const peer2 = builder.createPeer();
-    const identity2 = await createSigningContext(peer2.keyring);
-    const dataSpaceManager2 = new DataSpaceManager(
-      peer2.spaceManager,
-      peer2.metadataStore,
-      new DataServiceSubscriptions(),
-      peer2.keyring,
-      identity2,
-      peer2.feedStore,
-    );
-    await dataSpaceManager2.open();
-    afterTest(() => dataSpaceManager2.close());
+    await peer2.createIdentity();
+    await peer2.dataSpaceManager.open();
+
+    await openAndClose(peer1.dataSpaceManager, peer2.dataSpaceManager);
 
-    const space1 = await dataSpaceManager1.createSpace();
+    const space1 = await peer1.dataSpaceManager.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,
+        peer1.identity.credentialSigner,
+        peer2.identity.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({
+    const space2 = await peer2.dataSpaceManager.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);
+    await peer2.dataSpaceManager.waitUntilSpaceReady(space2.key);
 
     const [receivedMessage, inc] = latch({ count: 1 });
     space2.listen('test', (message) => {
@@ -206,18 +163,9 @@ describe('DataSpaceManager', () => {
       const peer = builder.createPeer({
         storageType: typeof window === 'undefined' ? StorageType.NODE : StorageType.WEBFS,
       });
-      const identity = await createSigningContext(peer.keyring);
-      const dataSpaceManager = new DataSpaceManager(
-        peer.spaceManager,
-        peer.metadataStore,
-        new DataServiceSubscriptions(),
-        peer.keyring,
-        identity,
-        peer.feedStore,
-      );
-      await dataSpaceManager.open();
-      afterTest(() => dataSpaceManager.close());
-      const space = await dataSpaceManager.createSpace();
+      await peer.createIdentity();
+      await openAndClose(peer.dataSpaceManager);
+      const space = await peer.dataSpaceManager.createSpace();
       await space.inner.controlPipeline.state.waitUntilTimeframe(space.inner.controlPipeline.state.endTimeframe);
 
       const feedDataPath = path.join(space.inner.dataPipeline.pipelineState!.feeds[0].key.toHex(), 'data');
@@ -241,24 +189,14 @@ describe('DataSpaceManager', () => {
       afterTest(async () => builder.destroy());
 
       const peer = builder.createPeer();
-      const identity = await createSigningContext(peer.keyring);
+      await peer.createIdentity();
       const epochsNumber = 10;
-      const dataService = new DataServiceSubscriptions();
       let spaceKey: PublicKey;
       {
         // Create space and create epochs in it.s
-        const dataSpaceManager = new DataSpaceManager(
-          peer.spaceManager,
-          peer.metadataStore,
-          dataService,
-          peer.keyring,
-          identity,
-          peer.feedStore,
-        );
-        await dataSpaceManager.open();
-        afterTest(() => dataSpaceManager.close());
-
-        const space = await dataSpaceManager.createSpace();
+        await openAndClose(peer.dataSpaceManager);
+
+        const space = await peer.dataSpaceManager.createSpace();
         spaceKey = space.key;
         await space.inner.controlPipeline.state.waitUntilTimeframe(space.inner.controlPipeline.state.endTimeframe);
 
@@ -267,22 +205,14 @@ describe('DataSpaceManager', () => {
           await space.createEpoch();
         }
         await space.close();
-        await dataSpaceManager.close();
+        await peer.dataSpaceManager.close();
+        peer.props.dataSpaceManager = undefined;
       }
       {
         // Load same space and check if it loads only last epoch.s
-        const dataSpaceManager = new DataSpaceManager(
-          peer.spaceManager,
-          peer.metadataStore,
-          dataService,
-          peer.keyring,
-          identity,
-          peer.feedStore,
-        );
-        await dataSpaceManager.open();
-        afterTest(() => dataSpaceManager.close());
-
-        const space = dataSpaceManager.spaces.get(spaceKey)!;
+        await openAndClose(peer.dataSpaceManager);
+
+        const space = peer.dataSpaceManager.spaces.get(spaceKey)!;
 
         const epochs: number[] = [];
         space.dataPipeline.onNewEpoch.on((epoch: SpecificCredential<Epoch>) => {
@@ -297,4 +227,28 @@ describe('DataSpaceManager', () => {
       }
     });
   });
+
+  describe('activation', () => {
+    test('can activate and deactivate a space', async () => {
+      const builder = new TestBuilder();
+
+      const peer = builder.createPeer();
+      await peer.createIdentity();
+      await openAndClose(peer.dataSpaceManager);
+
+      const space = await peer.dataSpaceManager.createSpace();
+      await space.inner.controlPipeline.state.waitUntilTimeframe(space.inner.controlPipeline.state.endTimeframe);
+      expect(space.state).to.equal(SpaceState.READY);
+
+      await space.deactivate();
+      expect(space.state).to.equal(SpaceState.INACTIVE);
+
+      await space.activate();
+      await asyncTimeout(
+        space.stateUpdate.waitForCondition(() => space.state === SpaceState.READY),
+        500,
+      );
+      await testLocalDatabase(space.dataPipeline);
+    });
+  });
 });

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

@@ -86,7 +86,9 @@ export class DataSpaceManager {
       try {
         log('load space', { spaceMetadata });
         const space = await this._constructSpace(spaceMetadata);
-        space.initializeDataPipelineAsync();
+        if (spaceMetadata.state !== SpaceState.INACTIVE) {
+          space.initializeDataPipelineAsync();
+        }
       } catch (err) {
         log.error('Error loading space', { spaceMetadata, err });
       }
@@ -121,6 +123,7 @@ export class DataSpaceManager {
       genesisFeedKey: controlFeedKey,
       controlFeedKey,
       dataFeedKey,
+      state: SpaceState.ACTIVE,
     };
 
     log('creating space...', { spaceKey });
@@ -217,6 +220,7 @@ export class DataSpaceManager {
 
     const dataSpace = new DataSpace({
       inner: space,
+      initialState: metadata.state === SpaceState.INACTIVE ? SpaceState.INACTIVE : SpaceState.CLOSED,
       metadataStore: this._metadataStore,
       gossip,
       presence,
@@ -226,7 +230,7 @@ export class DataSpaceManager {
       callbacks: {
         beforeReady: async () => {
           log('before space ready', { space: space.key });
-          this._dataServiceSubscriptions.registerSpace(
+          await this._dataServiceSubscriptions.registerSpace(
             space.key,
             dataSpace.dataPipeline.databaseHost!.createDataServiceHost(),
           );
@@ -237,11 +241,17 @@ export class DataSpaceManager {
             this.updated.emit();
           }
         },
+        beforeClose: async () => {
+          log('before space close', { space: space.key });
+          await this._dataServiceSubscriptions.unregisterSpace(space.key);
+        },
       },
       cache: metadata.cache,
     });
 
-    await dataSpace.open();
+    if (metadata.state !== SpaceState.INACTIVE) {
+      await dataSpace.open();
+    }
 
     if (metadata.controlTimeframe) {
       dataSpace.inner.controlPipeline.state.setTargetTimeframe(metadata.controlTimeframe);

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

@@ -2,10 +2,9 @@
 // Copyright 2022 DXOS.org
 //
 
-import { Event, scheduleTask, trackLeaks } from '@dxos/async';
+import { Event, scheduleTask, synchronized, trackLeaks } from '@dxos/async';
 import { AUTH_TIMEOUT } from '@dxos/client-protocol';
 import { cancelWithContext, Context } from '@dxos/context';
-import { CredentialConsumer } from '@dxos/credentials';
 import { timed } from '@dxos/debug';
 import { MetadataStore, Space, createMappedFeedWriter, DataPipeline } from '@dxos/echo-pipeline';
 import { CancelledError, SystemError } from '@dxos/errors';
@@ -36,9 +35,15 @@ export type DataSpaceCallbacks = {
    * Called after transitioning to the ready state.
    */
   afterReady?: () => Promise<void>;
+
+  /**
+   * Called before space gets closed.
+   */
+  beforeClose?: () => Promise<void>;
 };
 
 export type DataSpaceParams = {
+  initialState: SpaceState;
   inner: Space;
   metadataStore: MetadataStore;
   gossip: Gossip;
@@ -52,7 +57,7 @@ export type DataSpaceParams = {
 
 @trackLeaks('open', 'close')
 export class DataSpace {
-  private readonly _ctx = new Context();
+  private _ctx = new Context();
   private readonly _inner: Space;
   private readonly _gossip: Gossip;
   private readonly _presence: Presence;
@@ -60,7 +65,7 @@ export class DataSpace {
   private readonly _feedStore: FeedStore<FeedMessage>;
   private readonly _metadataStore: MetadataStore;
   private readonly _signingContext: SigningContext;
-  private readonly _notarizationPluginConsumer: CredentialConsumer<NotarizationPlugin>;
+  private readonly _notarizationPlugin = new NotarizationPlugin();
   private readonly _callbacks: DataSpaceCallbacks;
   private readonly _cache?: SpaceCache;
 
@@ -94,8 +99,9 @@ export class DataSpace {
       authTimeout: AUTH_TIMEOUT,
     });
 
-    this._notarizationPluginConsumer = this._inner.spaceState.registerProcessor(new NotarizationPlugin());
     this._cache = params.cache;
+
+    this._state = params.initialState;
   }
 
   get key() {
@@ -124,30 +130,44 @@ export class DataSpace {
   }
 
   get notarizationPlugin() {
-    return this._notarizationPluginConsumer.processor;
+    return this._notarizationPlugin;
   }
 
   get cache() {
     return this._cache;
   }
 
+  @synchronized
   async open() {
-    await this.notarizationPlugin.open();
-    await this._notarizationPluginConsumer.open();
+    await this._open();
+  }
+
+  private async _open() {
+    await this._notarizationPlugin.open();
+    await this._inner.spaceState.addCredentialProcessor(this._notarizationPlugin);
     await this._inner.open();
-    this._state = SpaceState.INACTIVE;
+    this._state = SpaceState.CONTROL_ONLY;
+    this.stateUpdate.emit();
+    this.metrics = {};
     this.metrics.open = new Date();
   }
 
+  @synchronized
   async close() {
+    await this._close();
+  }
+
+  private async _close() {
+    await this._callbacks.beforeClose?.();
     this._state = SpaceState.CLOSED;
     await this._ctx.dispose();
+    this._ctx = new Context();
 
     await this.authVerifier.close();
 
     await this._inner.close();
-    await this._notarizationPluginConsumer.close();
-    await this.notarizationPlugin.close();
+    await this._inner.spaceState.removeCredentialProcessor(this._notarizationPlugin);
+    await this._notarizationPlugin.close();
 
     await this._presence.destroy();
   }
@@ -185,7 +205,7 @@ export class DataSpace {
   }
 
   async initializeDataPipeline() {
-    if (this._state !== SpaceState.INACTIVE) {
+    if (this._state !== SpaceState.CONTROL_ONLY) {
       throw new SystemError('Invalid operation');
     }
     this._state = SpaceState.INITIALIZING;
@@ -201,14 +221,16 @@ export class DataSpace {
     log('Writable feeds created');
     this.stateUpdate.emit();
 
-    this.notarizationPlugin.setWriter(
-      createMappedFeedWriter<Credential, FeedMessage.Payload>(
-        (credential) => ({
-          credential: { credential },
-        }),
-        this._inner.controlPipeline.writer,
-      ),
-    );
+    if (!this.notarizationPlugin.hasWriter) {
+      this.notarizationPlugin.setWriter(
+        createMappedFeedWriter<Credential, FeedMessage.Payload>(
+          (credential) => ({
+            credential: { credential },
+          }),
+          this._inner.controlPipeline.writer,
+        ),
+      );
+    }
 
     await this._inner.initializeDataPipeline();
 
@@ -309,4 +331,28 @@ export class DataSpace {
       }
     }
   }
+
+  @synchronized
+  async activate() {
+    if (this._state !== SpaceState.INACTIVE) {
+      throw new SystemError('Invalid operation');
+    }
+
+    await this._metadataStore.setSpaceState(this.key, SpaceState.ACTIVE);
+    await this._open();
+    this.initializeDataPipelineAsync();
+  }
+
+  @synchronized
+  async deactivate() {
+    if (this._state === SpaceState.INACTIVE) {
+      throw new SystemError('Invalid operation');
+    }
+
+    // de-register from data service
+    await this._metadataStore.setSpaceState(this.key, SpaceState.INACTIVE);
+    await this._close();
+    this._state = SpaceState.INACTIVE;
+    this.stateUpdate.emit();
+  }
 }

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

@@ -25,7 +25,7 @@ class TestAgent extends TestPeer {
     super();
     this.feed.written.on(this._ctx, async ([credential]) => {
       log('written to feed', { credential });
-      await this.notarizationPlugin.process(credential);
+      await this.notarizationPlugin.processCredential(credential);
     });
   }
 

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

@@ -68,6 +68,10 @@ export class NotarizationPlugin implements CredentialProcessor {
   private readonly _processedCredentials = new ComplexSet<PublicKey>(PublicKey.hash);
   private readonly _processCredentialsTriggers = new ComplexMap<PublicKey, Trigger>(PublicKey.hash);
 
+  get hasWriter() {
+    return !!this._writer;
+  }
+
   async open() {}
 
   async close() {
@@ -165,7 +169,7 @@ export class NotarizationPlugin implements CredentialProcessor {
   /**
    * Called with credentials arriving from the control pipeline.
    */
-  async process(credential: Credential) {
+  async processCredential(credential: Credential) {
     if (!credential.id) {
       return;
     }

package/src/packlets/spaces/spaces-service.ts

@@ -4,8 +4,10 @@
 
 import { EventSubscriptions, UpdateScheduler, scheduleTask } from '@dxos/async';
 import { Stream } from '@dxos/codec-protobuf';
-import { raise, todo } from '@dxos/debug';
+import { CredentialProcessor } from '@dxos/credentials';
+import { raise } from '@dxos/debug';
 import { DataServiceSubscriptions, SpaceManager, SpaceNotFoundError } from '@dxos/echo-pipeline';
+import { ApiError } from '@dxos/errors';
 import { log } from '@dxos/log';
 import { encodeError } from '@dxos/protocols';
 import {
@@ -15,6 +17,7 @@ import {
   QuerySpacesResponse,
   Space,
   SpaceMember,
+  SpaceState,
   SpacesService,
   SubscribeMessagesRequest,
   UpdateSpaceRequest,
@@ -46,8 +49,23 @@ export class SpacesServiceImpl implements SpacesService {
     return this._serializeSpace(space);
   }
 
-  async updateSpace(request: UpdateSpaceRequest) {
-    todo();
+  async updateSpace({ spaceKey, state }: UpdateSpaceRequest) {
+    const dataSpaceManager = await this._getDataSpaceManager();
+    const space = dataSpaceManager.spaces.get(spaceKey) ?? raise(new SpaceNotFoundError(spaceKey));
+
+    if (state) {
+      switch (state) {
+        case SpaceState.ACTIVE:
+          await space.activate();
+          break;
+
+        case SpaceState.INACTIVE:
+          await space.deactivate();
+          break;
+        default:
+          throw new ApiError('Invalid space state');
+      }
+    }
   }
 
   querySpaces(): Stream<QuerySpacesResponse> {
@@ -124,13 +142,13 @@ export class SpacesServiceImpl implements SpacesService {
     return new Stream(({ ctx, next }) => {
       const space = this._spaceManager.spaces.get(spaceKey) ?? raise(new SpaceNotFoundError(spaceKey));
 
-      const processor = space.spaceState.registerProcessor({
-        process: async (credential) => {
+      const processor: CredentialProcessor = {
+        processCredential: async (credential) => {
           next(credential);
         },
-      });
-      ctx.onDispose(() => processor.close());
-      scheduleTask(ctx, () => processor.open());
+      };
+      ctx.onDispose(() => space.spaceState.removeCredentialProcessor(processor));
+      scheduleTask(ctx, () => space.spaceState.addCredentialProcessor(processor));
     });
   }