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

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

@@ -2,25 +2,29 @@
 // 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';
-import { Presence } from '@dxos/teleport-extension-presence';
+import { GossipMessage } from '@dxos/protocols/proto/dxos/mesh/teleport/gossip';
+import { Gossip, Presence } from '@dxos/teleport-extension-gossip';
 import { ComplexSet } from '@dxos/util';
 
 import { TrustedKeySetAuthVerifier } from '../identity';
@@ -28,42 +32,64 @@ 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;
   metadataStore: MetadataStore;
   snapshotManager: SnapshotManager;
+  gossip: Gossip;
   presence: Presence;
   keyring: Keyring;
   feedStore: FeedStore<FeedMessage>;
   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;
   private readonly _keyring: Keyring;
   private readonly _feedStore: FeedStore<FeedMessage>;
   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,
@@ -90,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() {
@@ -115,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();
@@ -129,12 +158,48 @@ export class DataSpace {
     await this._presence.destroy();
   }
 
+  async postMessage(channel: string, message: any) {
+    return this._gossip.postMessage(channel, message);
+  }
+
+  listen(channel: string, callback: (message: GossipMessage) => void) {
+    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) => ({
@@ -144,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)
@@ -186,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;

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

@@ -4,8 +4,8 @@
 
 import assert from 'node:assert';
 
-import { DeferredTask, Event, scheduleTask, TimeoutError, Trigger } from '@dxos/async';
-import { Context } from '@dxos/context';
+import { DeferredTask, Event, scheduleTask, sleep, TimeoutError, Trigger } from '@dxos/async';
+import { Context, rejectOnDispose } from '@dxos/context';
 import { CredentialProcessor } from '@dxos/credentials';
 import { FeedWriter } from '@dxos/feed-store';
 import { PublicKey } from '@dxos/keys';
@@ -16,8 +16,43 @@ import { NotarizationService, NotarizeRequest } from '@dxos/protocols/proto/dxos
 import { ExtensionContext, RpcExtension } from '@dxos/teleport';
 import { ComplexMap, ComplexSet, entry } from '@dxos/util';
 
-const RETRY_TIMEOUT = 1000;
-const NOTARIZE_TIMEOUT = 10_000;
+const DEFAULT_RETRY_TIMEOUT = 1_000;
+
+const DEFAULT_SUCCESS_DELAY = 1_000;
+
+const DEFAULT_NOTARIZE_TIMEOUT = 10_000;
+
+export type NotarizeParams = {
+  /**
+   * For cancellation.
+   */
+  ctx?: Context;
+
+  /**
+   * Credentials to notarize.
+   */
+  credentials: Credential[];
+
+  /**
+   * Timeout for the whole notarization process.
+   * Set to 0 to disable.
+   * @default {@link DEFAULT_NOTARIZE_TIMEOUT}
+   */
+  timeout?: number;
+
+  /**
+   * Retry timeout.
+   * @default {@link DEFAULT_RETRY_TIMEOUT}
+   */
+  retryTimeout?: number;
+
+  /**
+   * Minimum wait time after a peer confirms successful notarization before attempting with a new peer.
+   * This is to avoid spamming peers with notarization requests.
+   * @default {@link DEFAULT_SUCCESS_DELAY}
+   */
+  successDelay?: number;
+};
 
 /**
  * See NotarizationService proto.
@@ -40,7 +75,13 @@ export class NotarizationPlugin implements CredentialProcessor {
   /**
    * Request credentials to be notarized.
    */
-  async notarize(credentials: Credential[]) {
+  async notarize({
+    ctx: opCtx,
+    credentials,
+    timeout = DEFAULT_NOTARIZE_TIMEOUT,
+    retryTimeout = DEFAULT_RETRY_TIMEOUT,
+    successDelay = DEFAULT_SUCCESS_DELAY
+  }: NotarizeParams) {
     log('notarize', { credentials });
     assert(
       credentials.every((credential) => credential.id),
@@ -55,15 +96,23 @@ export class NotarizationPlugin implements CredentialProcessor {
         errors.throw(err);
       }
     });
-    scheduleTask(
-      ctx,
-      () => {
-        log.warn('Notarization timeout');
-        void ctx.dispose();
-        errors.throw(new TimeoutError(NOTARIZE_TIMEOUT, 'Notarization timed out'));
-      },
-      NOTARIZE_TIMEOUT
-    );
+    opCtx?.onDispose(() => ctx.dispose());
+
+    // Timeout/
+    if (timeout !== 0) {
+      scheduleTask(
+        ctx,
+        () => {
+          log.warn('Notarization timeout', {
+            timeout,
+            peers: Array.from(this._extensions).map((extension) => extension.remotePeerId)
+          });
+          void ctx.dispose();
+          errors.throw(new TimeoutError(timeout, 'Notarization timed out'));
+        },
+        timeout
+      );
+    }
 
     const allNotarized = Promise.all(credentials.map((credential) => this._waitUntilProcessed(credential.id!)));
 
@@ -73,16 +122,15 @@ export class NotarizationPlugin implements CredentialProcessor {
     const notarizeTask = new DeferredTask(ctx, async () => {
       try {
         if (this._extensions.size === 0) {
-          log.warn('No peers to notarize with');
           return; // No peers to try.
         }
 
         // Pick a peer that we haven't tried yet.
         const peer = [...this._extensions].find((peer) => !peersTried.has(peer));
         if (!peer) {
-          log.warn('Exhausted all peers to notarize with', { retryIn: RETRY_TIMEOUT });
+          log.warn('Exhausted all peers to notarize with', { retryIn: retryTimeout });
           peersTried.clear();
-          scheduleTask(ctx, () => notarizeTask.schedule(), RETRY_TIMEOUT); // retry with all peers again
+          scheduleTask(ctx, () => notarizeTask.schedule(), retryTimeout); // retry with all peers again
           return;
         }
 
@@ -92,6 +140,7 @@ export class NotarizationPlugin implements CredentialProcessor {
           credentials: credentials.filter((credential) => !this._processedCredentials.has(credential.id!))
         });
         log('success');
+        await sleep(successDelay); // wait before trying with a new peer
       } catch (err) {
         log.warn('error notarizing (recoverable)', err);
         notarizeTask.schedule(); // retry immediately with next peer
@@ -102,8 +151,7 @@ export class NotarizationPlugin implements CredentialProcessor {
     this._extensionOpened.on(ctx, () => notarizeTask.schedule());
 
     try {
-      // TODO(dmaretskyi): Abort (context) & timeout.
-      await Promise.race([allNotarized, errors.wait()]);
+      await Promise.race([rejectOnDispose(ctx), allNotarized, errors.wait()]);
       log('done');
     } finally {
       await ctx.dispose();

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

@@ -81,7 +81,7 @@ describe('SpacesService', () => {
 
       const spaces = await result.wait();
       expect(spaces).to.be.length(3);
-      expect(spaces).to.deep.equal(existingSpaces);
+      expect(spaces?.map((s) => s.spaceKey)).to.deep.equal(existingSpaces?.map((s) => s.spaceKey));
     });
 
     test('updates when new space is added', async () => {

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

@@ -8,22 +8,26 @@ import { raise, todo } from '@dxos/debug';
 import { DataServiceSubscriptions, SpaceManager, SpaceNotFoundError } from '@dxos/echo-pipeline';
 import { log } from '@dxos/log';
 import {
+  PostMessageRequest,
   QueryCredentialsRequest,
   QuerySpacesResponse,
   Space,
   SpaceMember,
   SpacesService,
-  SpaceStatus,
+  SubscribeMessagesRequest,
   UpdateSpaceRequest,
   WriteCredentialsRequest
 } from '@dxos/protocols/proto/dxos/client/services';
 import { Credential } from '@dxos/protocols/proto/dxos/halo/credentials';
+import { GossipMessage } from '@dxos/protocols/proto/dxos/mesh/teleport/gossip';
 import { humanize, Provider } from '@dxos/util';
 
 import { IdentityManager } from '../identity';
 import { DataSpace } from './data-space';
 import { DataSpaceManager } from './data-space-manager';
 
+const TIMEFRAME_UPDATE_DEBOUNCE_TIME = 500;
+
 /**
  *
  */
@@ -52,29 +56,36 @@ export class SpacesServiceImpl implements SpacesService {
     return new Stream<QuerySpacesResponse>(({ next, ctx }) => {
       const onUpdate = async () => {
         const dataSpaceManager = await this._getDataSpaceManager();
-        const spaces = Array.from(dataSpaceManager.spaces.values())
-          // Skip spaces without data service available.
-          .filter((space) => this._dataServiceSubscriptions.getDataService(space.key))
-          .map((space) => this._transformSpace(space));
+        const spaces = Array.from(dataSpaceManager.spaces.values()).map((space) => this._transformSpace(space));
         log('update', { spaces });
         next({ spaces });
       };
 
-      setTimeout(async () => {
+      scheduleTask(ctx, async () => {
         const dataSpaceManager = await this._getDataSpaceManager();
+
         const subscriptions = new EventSubscriptions();
+        ctx.onDispose(() => subscriptions.clear());
+
         // TODO(dmaretskyi): Create a pattern for subscribing to a set of objects.
         const subscribeSpaces = () => {
           subscriptions.clear();
 
           for (const space of dataSpaceManager.spaces.values()) {
-            if (!this._dataServiceSubscriptions.getDataService(space.key)) {
-              // Skip spaces without data service available.
-              continue;
-            }
-
             subscriptions.add(space.stateUpdate.on(ctx, onUpdate));
             subscriptions.add(space.presence.updated.on(ctx, onUpdate));
+
+            // Pipeline progress.
+            space.inner.controlPipeline.state.timeframeUpdate
+              .debounce(TIMEFRAME_UPDATE_DEBOUNCE_TIME)
+              .on(ctx, onUpdate);
+            if (space.dataPipeline.pipelineState) {
+              subscriptions.add(
+                space.dataPipeline.pipelineState.timeframeUpdate
+                  .debounce(TIMEFRAME_UPDATE_DEBOUNCE_TIME)
+                  .on(ctx, onUpdate)
+              );
+            }
           }
         };
 
@@ -82,12 +93,9 @@ export class SpacesServiceImpl implements SpacesService {
           subscribeSpaces();
           void onUpdate();
         });
+        subscribeSpaces();
 
-        ctx.onDispose(() => subscriptions.clear());
-        scheduleTask(ctx, () => {
-          subscribeSpaces();
-          void onUpdate();
-        });
+        void onUpdate();
       });
 
       if (!this._identityManager.identity) {
@@ -96,6 +104,25 @@ export class SpacesServiceImpl implements SpacesService {
     });
   }
 
+  async postMessage({ spaceKey, channel, message }: PostMessageRequest) {
+    const dataSpaceManager = await this._getDataSpaceManager();
+    const space = dataSpaceManager.spaces.get(spaceKey) ?? raise(new SpaceNotFoundError(spaceKey));
+    await space.postMessage(getChannelId(channel), message);
+  }
+
+  subscribeMessages({ spaceKey, channel }: SubscribeMessagesRequest) {
+    return new Stream<GossipMessage>(({ ctx, next }) => {
+      scheduleTask(ctx, async () => {
+        const dataSpaceManager = await this._getDataSpaceManager();
+        const space = dataSpaceManager.spaces.get(spaceKey) ?? raise(new SpaceNotFoundError(spaceKey));
+        const handle = space.listen(getChannelId(channel), (message) => {
+          next(message);
+        });
+        ctx.onDispose(() => handle.unsubscribe());
+      });
+    });
+  }
+
   queryCredentials({ spaceKey }: QueryCredentialsRequest): Stream<Credential> {
     return new Stream(({ ctx, next }) => {
       const space = this._spaceManager.spaces.get(spaceKey) ?? raise(new SpaceNotFoundError(spaceKey));
@@ -120,7 +147,13 @@ export class SpacesServiceImpl implements SpacesService {
   private _transformSpace(space: DataSpace): Space {
     return {
       spaceKey: space.key,
-      status: space.isOpen ? SpaceStatus.ACTIVE : SpaceStatus.INACTIVE,
+      state: space.state,
+      pipeline: {
+        targetControlTimeframe: space.inner.controlPipeline.state.targetTimeframe,
+        currentControlTimeframe: space.inner.controlPipeline.state.timeframe,
+        currentDataTimeframe: space.dataPipeline.pipelineState?.timeframe,
+        targetDataTimeframe: space.dataPipeline.pipelineState?.targetTimeframe
+      },
       members: Array.from(space.inner.spaceState.members.values()).map((member) => ({
         identity: {
           identityKey: member.key,
@@ -137,3 +170,6 @@ export class SpacesServiceImpl implements SpacesService {
     };
   }
 }
+
+// Add `user-channel` prefix to the channel name, so that it doesn't collide with the internal channels.
+const getChannelId = (channel: string): string => `user-channel/${channel}`;

package/src/packlets/testing/host-test-builder.ts

@@ -7,7 +7,7 @@ import { Config } from '@dxos/config';
 import { createCredentialSignerWithChain, CredentialGenerator } from '@dxos/credentials';
 import {
   SnapshotStore,
-  DataPipelineControllerImpl,
+  DataPipeline,
   MetadataStore,
   SigningContext,
   SpaceManager,
@@ -73,7 +73,7 @@ export const createIdentity = async (peer: ServiceContext) => {
 
 // TODO(burdon): Remove @dxos/client-testing.
 // TODO(burdon): Create builder and make configurable.
-export const syncItemsLocal = async (db1: DataPipelineControllerImpl, db2: DataPipelineControllerImpl) => {
+export const syncItemsLocal = async (db1: DataPipeline, db2: DataPipeline) => {
   await testLocalDatabase(db1, db2);
   await testLocalDatabase(db2, db1);
 };

package/src/packlets/testing/test-builder.ts

@@ -4,12 +4,14 @@
 
 import assert from 'node:assert';
 
-import { asyncTimeout } from '@dxos/async';
-import { Client, ClientServices, ClientServicesProxy, createDefaultModelFactory } from '@dxos/client';
+import { asyncTimeout, Trigger } from '@dxos/async';
+import { Client, ClientServices, ClientServicesProxy, createDefaultModelFactory, Invitation } from '@dxos/client';
 import { Config } from '@dxos/config';
+import { raise } from '@dxos/debug';
 import { DocumentModel } from '@dxos/document-model';
 import { DatabaseBackendProxy, genesisMutation } from '@dxos/echo-db';
 import { PublicKey } from '@dxos/keys';
+import { log } from '@dxos/log';
 import { MemorySignalManager, MemorySignalManagerContext, WebsocketSignalManager } from '@dxos/messaging';
 import { createWebRTCTransportFactory, MemoryTransportFactory, NetworkManager } from '@dxos/network-manager';
 import { Storage } from '@dxos/random-access-storage';
@@ -119,12 +121,12 @@ export const testSpace = async (create: DatabaseBackendProxy, check: DatabaseBac
 
   const result = create.mutate(genesisMutation(objectId, DocumentModel.meta.type));
 
-  await result.getReceipt();
+  await result.batch.getReceipt();
   // TODO(dmaretskiy): await result.waitToBeProcessed()
-  assert(create._itemManager.entities.has(result.objectsCreated[0].id));
+  assert(create._itemManager.entities.has(result.objectsUpdated[0].id));
 
   await asyncTimeout(
-    check._itemManager.update.waitForCondition(() => check._itemManager.entities.has(objectId)),
+    check.itemUpdate.waitForCondition(() => check._itemManager.entities.has(objectId)),
     1000
   );
 
@@ -138,3 +140,41 @@ export const syncItems = async (db1: DatabaseBackendProxy, db2: DatabaseBackendP
   // Check item replicated from 2 => 1.
   await testSpace(db2, db1);
 };
+
+export const joinCommonSpace = async ([initialPeer, ...peers]: Client[], spaceKey?: PublicKey): Promise<PublicKey> => {
+  const rootSpace = spaceKey ? initialPeer.getSpace(spaceKey) : await initialPeer.createSpace();
+  assert(rootSpace, 'Space not found.');
+
+  await Promise.all(
+    peers.map(async (peer) => {
+      const hostDone = new Trigger<Invitation>();
+      const guestDone = new Trigger<Invitation>();
+
+      const hostObservabli = rootSpace.createInvitation({ type: Invitation.Type.INTERACTIVE_TESTING });
+      log('invitation created');
+      hostObservabli.subscribe({
+        onConnecting: (invitation) => {
+          const guestObservable = peer.acceptInvitation(invitation);
+          log('invitation accepted');
+
+          guestObservable.subscribe({
+            onSuccess: (invitation: Invitation) => {
+              guestDone.wake(invitation);
+              log('invitation guestDone');
+            },
+            onError: (err: Error) => raise(err)
+          });
+        },
+        onSuccess: (invitation) => {
+          hostDone.wake(invitation);
+          log('invitation hostDone');
+        },
+        onError: (err) => raise(err)
+      });
+
+      await Promise.all([hostDone.wait(), guestDone.wait()]);
+    })
+  );
+
+  return rootSpace.key;
+};