@dxos/client-services 0.1.23 → 0.1.24

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

@@ -4,21 +4,23 @@
 
 import { Config } from '@dxos/config';
 import { raise } from '@dxos/debug';
+import { DocumentModel } from '@dxos/document-model';
 import { DataServiceImpl } from '@dxos/echo-db';
 import { log } from '@dxos/log';
 import { ModelFactory } from '@dxos/model-factory';
 import { NetworkManager } from '@dxos/network-manager';
-import { ObjectModel } from '@dxos/object-model';
+import { Status } from '@dxos/protocols/proto/dxos/client';
 import { Storage } from '@dxos/random-access-storage';
 import { TextModel } from '@dxos/text-model';
 
-import { SpaceServiceImpl, ProfileServiceImpl, SystemServiceImpl, TracingServiceImpl } from '../deprecated';
+import { SpaceServiceImpl, ProfileServiceImpl, TracingServiceImpl, SystemServiceImpl } from '../deprecated';
 import { DevtoolsServiceImpl, DevtoolsHostEvents } from '../devtools';
 import { DevicesServiceImpl } from '../identity/devices-service-impl';
 import { HaloInvitationsServiceImpl, SpaceInvitationsServiceImpl } from '../invitations';
 import { NetworkServiceImpl } from '../network';
 import { SpacesServiceImpl } from '../spaces';
 import { createStorageObjects } from '../storage';
+import { VaultResourceLock } from '../vault';
 import { ServiceContext } from './service-context';
 import { ClientServicesProvider, ClientServices, clientServiceBundle } from './service-definitions';
 import { ServiceRegistry } from './service-registry';
@@ -26,7 +28,7 @@ import { ServiceRegistry } from './service-registry';
 // TODO(burdon): Factor out to spaces.
 // TODO(burdon): Defaults (with TextModel).
 export const createDefaultModelFactory = () => {
-  return new ModelFactory().registerModel(ObjectModel).registerModel(TextModel);
+  return new ModelFactory().registerModel(DocumentModel).registerModel(TextModel);
 };
 
 type ClientServicesHostParams = {
@@ -34,31 +36,77 @@ type ClientServicesHostParams = {
   modelFactory?: ModelFactory;
   networkManager: NetworkManager;
   storage?: Storage;
+  lockKey?: string;
 };
 
 /**
  * Remote service implementation.
  */
 export class ClientServicesHost implements ClientServicesProvider {
-  private _serviceContext!: ServiceContext;
-  private _serviceRegistry!: ServiceRegistry<ClientServices>;
+  private readonly _resourceLock?: VaultResourceLock;
+  private readonly _serviceRegistry: ServiceRegistry<ClientServices>;
+  private readonly _systemService: SystemServiceImpl;
 
   private readonly _config: Config;
   private readonly _modelFactory: ModelFactory;
   private readonly _networkManager: NetworkManager;
-  private _storage: Storage;
+  private readonly _storage: Storage;
+
+  /**
+   * @internal
+   */
+  _serviceContext!: ServiceContext;
+  private _open = false;
 
   constructor({
     config,
     modelFactory = createDefaultModelFactory(),
     // TODO(burdon): Create ApolloLink abstraction (see Client).
     networkManager,
-    storage = createStorageObjects(config.get('runtime.client.storage', {})!).storage
+    storage = createStorageObjects(config.get('runtime.client.storage', {})!).storage,
+    lockKey
   }: ClientServicesHostParams) {
     this._config = config;
     this._modelFactory = modelFactory;
     this._networkManager = networkManager;
     this._storage = storage;
+
+    this._resourceLock = lockKey
+      ? new VaultResourceLock({
+          lockKey,
+          onAcquire: () => this.open(),
+          onRelease: () => this.close()
+        })
+      : undefined;
+
+    this._systemService = new SystemServiceImpl({
+      config: this._config,
+
+      onInit: async () => {
+        await this._resourceLock?.acquire();
+      },
+
+      onStatus: async () => {
+        if (!this.isOpen) {
+          return { status: Status.INACTIVE };
+        }
+
+        return { status: Status.ACTIVE };
+      },
+
+      onReset: async () => {
+        await this._serviceContext?.reset();
+      }
+    });
+
+    // TODO(burdon): Start to think of DMG (dynamic services).
+    this._serviceRegistry = new ServiceRegistry<ClientServices>(clientServiceBundle, {
+      SystemService: this._systemService
+    });
+  }
+
+  get isOpen() {
+    return this._open;
   }
 
   get descriptors() {
@@ -70,27 +118,21 @@ export class ClientServicesHost implements ClientServicesProvider {
   }
 
   async open() {
-    log('opening...');
-    await this._initialize();
-    await this._serviceContext.open();
-    const deviceKey = this._serviceContext.identityManager.identity?.deviceKey;
-    log('opened', { deviceKey });
-  }
+    if (this._open) {
+      return;
+    }
 
-  async close() {
-    const deviceKey = this._serviceContext.identityManager.identity?.deviceKey;
-    log('closing...', { deviceKey });
-    await this._serviceContext.close();
-    log('closed', { deviceKey });
-  }
+    log('opening...');
 
-  // TODO(burdon): Move into open.
-  async _initialize() {
+    // TODO(wittjosiah): Make re-entrant.
     // TODO(burdon): Break into components.
     this._serviceContext = new ServiceContext(this._storage, this._networkManager, this._modelFactory);
 
     // TODO(burdon): Start to think of DMG (dynamic services).
-    this._serviceRegistry = new ServiceRegistry<ClientServices>(clientServiceBundle, {
+    this._serviceRegistry.setServices({
+      // TODO(burdon): Move to new protobuf definitions.
+      SystemService: this._systemService,
+
       HaloInvitationsService: new HaloInvitationsServiceImpl(
         this._serviceContext.identityManager,
         this._serviceContext.haloInvitations
@@ -112,8 +154,10 @@ export class ClientServicesHost implements ClientServicesProvider {
 
       // TODO(burdon): Move to new protobuf definitions.
       ProfileService: new ProfileServiceImpl(this._serviceContext),
+
+      // TODO(burdon): Port old SubscribeSpaces to QueryServices>
       SpaceService: new SpaceServiceImpl(this._serviceContext),
-      SystemService: new SystemServiceImpl(this._config, this._serviceContext),
+
       TracingService: new TracingServiceImpl(this._config),
       DevtoolsHost: new DevtoolsServiceImpl({
         events: new DevtoolsHostEvents(),
@@ -121,5 +165,23 @@ export class ClientServicesHost implements ClientServicesProvider {
         context: this._serviceContext
       })
     });
+
+    await this._serviceContext.open();
+    this._open = true;
+    const deviceKey = this._serviceContext.identityManager.identity?.deviceKey;
+    log('opened', { deviceKey });
+  }
+
+  async close() {
+    if (!this._open) {
+      return;
+    }
+
+    const deviceKey = this._serviceContext.identityManager.identity?.deviceKey;
+    log('closing...', { deviceKey });
+    this._serviceRegistry.setServices({ SystemService: this._systemService });
+    await this._serviceContext.close();
+    this._open = false;
+    log('closed', { deviceKey });
   }
 }

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

@@ -13,6 +13,7 @@ import { describe, test } from '@dxos/test';
 
 import { SpaceInvitationsProxy, SpaceInvitationsServiceImpl } from '../invitations';
 import { createServiceContext } from '../testing';
+import { ClientServices } from './service-definitions';
 import { ServiceRegistry } from './service-registry';
 
 // TODO(burdon): Create TestService (that doesn't require peers).
@@ -54,7 +55,7 @@ describe('service registry', () => {
 
     const server = createProtoRpcPeer({
       exposed: serviceRegistry.descriptors,
-      handlers: serviceRegistry.services,
+      handlers: serviceRegistry.services as ClientServices,
       port: serverPort
     });
 

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

@@ -11,7 +11,7 @@ export class ServiceRegistry<Services> {
   // prettier-ignore
   constructor (
     private readonly _serviceBundle: ServiceBundle<Services>,
-    private readonly _handlers: Services
+    private _handlers: Partial<Services>
   ) {}
 
   get descriptors() {
@@ -21,4 +21,8 @@ export class ServiceRegistry<Services> {
   get services() {
     return this._handlers;
   }
+
+  setServices(services: Partial<Services>) {
+    this._handlers = services;
+  }
 }

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

@@ -5,16 +5,43 @@
 import { expect } from 'chai';
 
 import { createAdmissionCredentials } from '@dxos/credentials';
+import { DocumentModel } from '@dxos/document-model';
 import { AuthStatus, DataServiceSubscriptions } from '@dxos/echo-db';
 import { writeMessages } from '@dxos/feed-store';
+import { log } from '@dxos/log';
 import { ModelFactory } from '@dxos/model-factory';
-import { ObjectModel } from '@dxos/object-model';
 import { test, describe } from '@dxos/test';
 
 import { createSigningContext, syncItems, TestBuilder } from '../testing';
 import { DataSpaceManager } from './data-space-manager';
 
 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,
+      new ModelFactory().registerModel(DocumentModel),
+      peer.feedStore,
+      peer.snapshotStore
+    );
+    const space = await dataSpaceManager.createSpace();
+
+    // Process all written mutations.
+    await space.inner.controlPipeline.state.waitUntilTimeframe(space.inner.controlPipeline.state.endTimeframe);
+
+    expect(space.inner.spaceState.genesisCredential).to.exist;
+    expect(space.inner.spaceState.members.size).to.equal(1);
+    expect(space.inner.spaceState.feeds.size).to.equal(2);
+    expect(space.inner.protocol.feeds.size).to.equal(2);
+  });
+
   test('sync between peers', async () => {
     const builder = new TestBuilder();
 
@@ -26,7 +53,8 @@ describe('DataSpaceManager', () => {
       new DataServiceSubscriptions(),
       peer1.keyring,
       identity1,
-      new ModelFactory().registerModel(ObjectModel),
+      new ModelFactory().registerModel(DocumentModel),
+      peer1.feedStore,
       peer1.snapshotStore
     );
 
@@ -38,17 +66,13 @@ describe('DataSpaceManager', () => {
       new DataServiceSubscriptions(),
       peer2.keyring,
       identity2,
-      new ModelFactory().registerModel(ObjectModel),
+      new ModelFactory().registerModel(DocumentModel),
+      peer2.feedStore,
       peer1.snapshotStore
     );
 
     const space1 = await dataSpaceManager1.createSpace();
-    const space2 = await dataSpaceManager2.acceptSpace({
-      spaceKey: space1.key,
-      genesisFeedKey: space1.inner.genesisFeedKey,
-      controlFeedKey: await peer2.keyring.createKey(),
-      dataFeedKey: await peer2.keyring.createKey()
-    });
+    await space1.inner.controlPipeline.state.waitUntilTimeframe(space1.inner.controlPipeline.state.endTimeframe);
 
     // Admit peer2 to space1.
     await writeMessages(
@@ -56,15 +80,48 @@ describe('DataSpaceManager', () => {
       await createAdmissionCredentials(
         identity1.credentialSigner,
         identity2.identityKey,
-        identity2.deviceKey,
         space1.key,
-        space2.inner.controlFeedKey,
-        space2.inner.dataFeedKey,
-        space2.inner.genesisFeedKey
+        space1.inner.genesisFeedKey
       )
     );
 
-    await syncItems(space1, space2);
+    // 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
+    });
+
+    log('', {
+      peer1: {
+        identity: identity1.identityKey,
+        device: identity1.deviceKey,
+        control: space1.inner.controlFeedKey,
+        data: space1.inner.dataFeedKey
+      },
+      peer2: {
+        identity: identity2.identityKey,
+        device: identity2.deviceKey,
+        control: space2.inner.controlFeedKey,
+        data: space2.inner.dataFeedKey
+      }
+    });
+
+    await space1.inner.controlPipeline.state.waitUntilTimeframe(space1.inner.controlPipeline.state.endTimeframe);
+    await space2.inner.controlPipeline.state.waitUntilTimeframe(space1.inner.controlPipeline.state.endTimeframe);
+
+    log('', {
+      space1: {
+        timeframe: space1.inner.controlPipeline.state.timeframe,
+        endTimeframe: space1.inner.controlPipeline.state.endTimeframe
+      },
+      space2: {
+        timeframe: space2.inner.controlPipeline.state.timeframe,
+        endTimeframe: space2.inner.controlPipeline.state.endTimeframe
+      }
+    });
+    log.break();
+
+    await syncItems(space1.dataPipelineController, space2.dataPipelineController);
 
     expect(space1.inner.protocol.sessions.get(identity2.deviceKey)).to.exist;
     expect(space1.inner.protocol.sessions.get(identity2.deviceKey)?.authStatus).to.equal(AuthStatus.SUCCESS);

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

@@ -6,8 +6,8 @@ import assert from 'node:assert';
 
 import { Event, synchronized, trackLeaks } from '@dxos/async';
 import { Context } from '@dxos/context';
+import { getCredentialAssertion } from '@dxos/credentials';
 import {
-  AcceptSpaceOptions,
   DataServiceSubscriptions,
   MetadataStore,
   SigningContext,
@@ -17,10 +17,12 @@ import {
   SpaceManager,
   SnapshotManager
 } from '@dxos/echo-db';
+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 { SpaceMetadata } from '@dxos/protocols/proto/dxos/echo/metadata';
 import { Presence } from '@dxos/teleport-extension-presence';
 import { ComplexMap, deferFunction } from '@dxos/util';
@@ -28,6 +30,13 @@ 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;
+};
+
 @trackLeaks('open', 'close')
 export class DataSpaceManager {
   private readonly _ctx = new Context();
@@ -43,6 +52,7 @@ export class DataSpaceManager {
     private readonly _keyring: Keyring,
     private readonly _signingContext: SigningContext,
     private readonly _modelFactory: ModelFactory,
+    private readonly _feedStore: FeedStore<FeedMessage>,
     private readonly _snapshotStore: SnapshotStore
   ) {}
 
@@ -59,10 +69,18 @@ export class DataSpaceManager {
     for (const spaceMetadata of this._metadataStore.spaces) {
       log('load space', { spaceMetadata });
       const space = await this._constructSpace(spaceMetadata);
-      if (spaceMetadata.latestTimeframe) {
+      await space.initializeDataPipeline();
+      if (spaceMetadata.dataTimeframe) {
         log('waiting for latest timeframe', { spaceMetadata });
-        await space.dataPipelineController.waitUntilTimeframe(spaceMetadata.latestTimeframe);
+        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()
+      );
     }
   }
 
@@ -92,9 +110,19 @@ export class DataSpaceManager {
     log('creating space...', { spaceKey });
     const space = await this._constructSpace(metadata);
 
-    await spaceGenesis(this._keyring, this._signingContext, space.inner);
+    const credentials = await spaceGenesis(this._keyring, this._signingContext, space.inner);
     await this._metadataStore.addSpace(metadata);
 
+    const memberCredential = credentials[1];
+    assert(getCredentialAssertion(memberCredential)['@type'] === 'dxos.halo.credentials.SpaceMember');
+    await this._signingContext.recordCredential(memberCredential);
+
+    await space.initializeDataPipeline();
+    this._dataServiceSubscriptions.registerSpace(
+      space.key,
+      space.dataPipelineController.databaseBackend!.createDataServiceHost()
+    );
+
     this.updated.emit();
     return space;
   }
@@ -106,13 +134,17 @@ export class DataSpaceManager {
 
     const metadata: SpaceMetadata = {
       key: opts.spaceKey,
-      genesisFeedKey: opts.genesisFeedKey,
-      controlFeedKey: opts.controlFeedKey,
-      dataFeedKey: opts.dataFeedKey
+      genesisFeedKey: opts.genesisFeedKey
     };
 
     const space = await this._constructSpace(metadata);
     await this._metadataStore.addSpace(metadata);
+    await space.initializeDataPipeline();
+    this._dataServiceSubscriptions.registerSpace(
+      space.key,
+      space.dataPipelineController.databaseBackend!.createDataServiceHost()
+    );
+
     this.updated.emit();
     return space;
   }
@@ -126,6 +158,10 @@ export class DataSpaceManager {
     });
     const snapshotManager = new SnapshotManager(this._snapshotStore);
 
+    const controlFeed =
+      metadata.controlFeedKey && (await this._feedStore.openFeed(metadata.controlFeedKey, { writable: true }));
+    const dataFeed = metadata.dataFeedKey && (await this._feedStore.openFeed(metadata.dataFeedKey, { writable: true }));
+
     const space: Space = await this._spaceManager.constructSpace({
       metadata,
       swarmIdentity: {
@@ -139,8 +175,11 @@ export class DataSpaceManager {
           presence.createExtension({ remotePeerId: session.remotePeerId })
         );
         session.addExtension('dxos.mesh.teleport.objectsync', snapshotManager.objectSync.createExtension());
+        session.addExtension('dxos.mesh.teleport.notarization', dataSpace.notarizationPlugin.createExtension());
       }
     });
+    controlFeed && space.setControlFeed(controlFeed);
+    dataFeed && space.setDataFeed(dataFeed);
 
     const dataSpace = new DataSpace({
       inner: space,
@@ -149,11 +188,13 @@ export class DataSpaceManager {
       snapshotManager,
       presence,
       memberKey: this._signingContext.identityKey,
+      keyring: this._keyring,
+      feedStore: this._feedStore,
+      signingContext: this._signingContext,
       snapshotId: metadata.snapshot
     });
 
     await dataSpace.open();
-    this._dataServiceSubscriptions.registerSpace(space.key, dataSpace.database.createDataServiceHost());
     this._spaces.set(metadata.key, dataSpace);
     return dataSpace;
   }