@dxos/client-services 0.8.4-main.ef1bc66f44 → 0.8.4-main.f466a3d56e

package/src/packlets/services/feed-syncer.ts

@@ -8,11 +8,13 @@ import * as Effect from 'effect/Effect';
 import * as Schema from 'effect/Schema';
 
 import { AsyncTask, scheduleTask } from '@dxos/async';
-import { Resource } from '@dxos/context';
+import { Context, Resource } from '@dxos/context';
 import { type EdgeConnection, MessageSchema } from '@dxos/edge-client';
 import { RuntimeProvider } from '@dxos/effect';
 import { type FeedStore, SyncClient } from '@dxos/feed';
-import { type SpaceId } from '@dxos/keys';
+import { invariant } from '@dxos/invariant';
+import { SpaceId } from '@dxos/keys';
+import { log } from '@dxos/log';
 import { FeedProtocol } from '@dxos/protocols';
 import { EdgeService } from '@dxos/protocols';
 import { createBuf } from '@dxos/protocols/buf';
@@ -24,7 +26,9 @@ const encoder = new Encoder({ tagUint8Array: false, useRecords: false });
 
 const DEFAULT_MESSAGE_BLOCKS_LIMIT = 50;
 const DEFAULT_SYNC_CONCURRENCY = 5;
-const DEFAULT_POLLING_INTERVAL = 10_000;
+const DEFAULT_POLLING_INTERVAL = 5_000;
+const DEFAULT_POLL_REQUEST_THROTTLE_MS = 250;
+const MAX_BLOCKING_SYNC_ITERATIONS = 100;
 
 interface FeedSyncerOptions {
   runtime: RuntimeProvider.RuntimeProvider<SqlClient.SqlClient | SqlTransaction.SqlTransaction>;
@@ -34,10 +38,9 @@ interface FeedSyncerOptions {
   getSpaceIds: () => SpaceId[];
 
   /**
-   * Namespace to sync.
+   * Namespaces to sync.
    */
-  // TODO(dmaretskyi): Syncing only one namespace is supported.
-  syncNamespace: string;
+  syncNamespaces: string[];
 
   /**
    * Maximum number of blocks to sync in a single message.
@@ -56,13 +59,20 @@ interface FeedSyncerOptions {
    * @default 10 seconds
    */
   pollingInterval?: number;
+
+  /**
+   * Minimum delay between externally requested best-effort polls.
+   * @default 250 ms
+   */
+  pollRequestThrottleMs?: number;
 }
 
 export class FeedSyncer extends Resource {
-  readonly #syncNamespace: string;
+  readonly #syncNamespaces: string[];
   readonly #messageBlocksLimit: number;
   readonly #syncConcurrency: number;
   readonly #pollingInterval: number;
+  readonly #pollRequestThrottleMs: number;
 
   readonly #runtime: RuntimeProvider.RuntimeProvider<SqlClient.SqlClient | SqlTransaction.SqlTransaction>;
   readonly #feedStore: FeedStore;
@@ -73,6 +83,8 @@ export class FeedSyncer extends Resource {
   #spacesToPoll = new Set<SpaceId>();
   /** Last time full poll was completed. */
   #lastFullPoll: number | null = null;
+  #throttledPollScheduled = false;
+  #lastRequestedPollAt: number | null = null;
 
   constructor(options: FeedSyncerOptions) {
     super();
@@ -85,10 +97,11 @@ export class FeedSyncer extends Resource {
       sendMessage: this.#sendMessage.bind(this),
     });
     this.#getSpaceIds = options.getSpaceIds;
-    this.#syncNamespace = options.syncNamespace;
+    this.#syncNamespaces = options.syncNamespaces;
     this.#messageBlocksLimit = options.messageBlocksLimit ?? DEFAULT_MESSAGE_BLOCKS_LIMIT;
     this.#syncConcurrency = options.syncConcurrency ?? DEFAULT_SYNC_CONCURRENCY;
     this.#pollingInterval = options.pollingInterval ?? DEFAULT_POLLING_INTERVAL;
+    this.#pollRequestThrottleMs = options.pollRequestThrottleMs ?? DEFAULT_POLL_REQUEST_THROTTLE_MS;
   }
 
   protected override async _open(): Promise<void> {
@@ -101,14 +114,28 @@ export class FeedSyncer extends Resource {
         if (service !== EdgeService.QUEUE_REPLICATOR) {
           return;
         }
+        log('feed sync edge ingress', {
+          serviceId: msg.serviceId,
+          payloadByteLength: msg.payload?.value?.byteLength,
+        });
         const handleMessageEffect = Effect.gen(this, function* () {
           const decoded = yield* Effect.try({
             try: () => cborXdecode(msg.payload!.value),
             catch: (error) => new Error(`Failed to decode feed sync message: ${error}`),
           });
-          const payload = yield* Schema.decodeUnknown(FeedProtocol.ProtocolMessage)(decoded);
+          const payload = yield* Schema.validate(FeedProtocol.ProtocolMessage)(decoded);
           yield* this.#syncClient.handleMessage(payload);
-        });
+        }).pipe(
+          Effect.tapError((cause) =>
+            Effect.sync(() =>
+              log('feed sync edge message handling failed', {
+                serviceId: msg.serviceId,
+                payloadByteLength: msg.payload?.value?.byteLength,
+                cause: cause instanceof Error ? cause.message : String(cause),
+              }),
+            ),
+          ),
+        );
 
         void RuntimeProvider.runPromise(this.#runtime)(handleMessageEffect);
       }),
@@ -116,7 +143,12 @@ export class FeedSyncer extends Resource {
 
     this._ctx.onDispose(
       // NOTE: This will fire immediately if the connection is already open.
-      this.#edgeClient.onReconnected(async () => {}),
+      this.#edgeClient.onReconnected(async () => {
+        log('feed sync edge reconnected', {
+          peerKey: this.#edgeClient.peerKey,
+          identityKey: this.#edgeClient.identityKey,
+        });
+      }),
     );
 
     this.#feedStore.onNewBlocks.on(this._ctx, () => {
@@ -127,6 +159,7 @@ export class FeedSyncer extends Resource {
     await this.#pushTask.open();
 
     this.#resetSpacesToPoll();
+    this.#pollTask.schedule();
   }
 
   protected override async _close(): Promise<void> {
@@ -134,6 +167,87 @@ export class FeedSyncer extends Resource {
     await this.#pushTask.close();
   }
 
+  /**
+   * Schedules a best-effort pull without blocking the caller.
+   */
+  schedulePoll(): void {
+    this.#resetSpacesToPoll();
+    if (this.#throttledPollScheduled) {
+      return;
+    }
+
+    const now = Date.now();
+    const delay =
+      this.#lastRequestedPollAt == null
+        ? 0
+        : Math.max(this.#pollRequestThrottleMs - (now - this.#lastRequestedPollAt), 0);
+    this.#throttledPollScheduled = true;
+    scheduleTask(
+      this._ctx,
+      () => {
+        this.#throttledPollScheduled = false;
+        this.#lastRequestedPollAt = Date.now();
+        this.#pollTask.schedule();
+      },
+      delay,
+    );
+  }
+
+  /**
+   * Performs queue sync and blocks until there are no pending sync batches.
+   */
+  async syncBlocking(
+    ctx: Context,
+    {
+      spaceId,
+      subspaceTag,
+      shouldPush = true,
+      shouldPull = true,
+    }: {
+      spaceId: SpaceId;
+      subspaceTag: string;
+      shouldPush?: boolean;
+      shouldPull?: boolean;
+    },
+  ): Promise<void> {
+    invariant(SpaceId.isValid(spaceId));
+    invariant(FeedProtocol.isWellKnownNamespace(subspaceTag));
+    if (!shouldPush && !shouldPull) {
+      return;
+    }
+
+    await RuntimeProvider.runPromise(this.#runtime)(
+      Effect.gen(this, function* () {
+        let done = false;
+        let iterations = 0;
+        while (!done) {
+          done = true;
+          if (shouldPull) {
+            const pullResult = yield* this.#syncClient.pull(ctx, {
+              spaceId,
+              feedNamespace: subspaceTag,
+              limit: this.#messageBlocksLimit,
+            });
+            done &&= pullResult.done;
+          }
+
+          if (shouldPush) {
+            const pushResult = yield* this.#syncClient.push(ctx, {
+              spaceId,
+              feedNamespace: subspaceTag,
+              limit: this.#messageBlocksLimit,
+            });
+            done &&= pushResult.done;
+          }
+          iterations++;
+          if (iterations > MAX_BLOCKING_SYNC_ITERATIONS) {
+            throw new Error('Blocking sync exceeded max iterations.');
+          }
+        }
+      }),
+    );
+  }
+
   #resetSpacesToPoll(): void {
     this.#spacesToPoll.clear();
     this.#getSpaceIds().forEach((spaceId) => {
@@ -142,20 +256,44 @@ export class FeedSyncer extends Resource {
     this.#lastFullPoll = Date.now();
   }
 
-  #sendMessage(message: FeedProtocol.QueryRequest | FeedProtocol.AppendRequest): Effect.Effect<void, unknown, never> {
+  #sendMessage(
+    ctx: Context,
+    message: FeedProtocol.QueryRequest | FeedProtocol.AppendRequest,
+  ): Effect.Effect<void, unknown, never> {
     return Effect.gen(this, function* () {
       const encoded = encoder.encode(message);
+      const serviceId = this.#getTargetServiceId(message);
+      const rpcTag = 'blocks' in message ? 'AppendRequest' : 'QueryRequest';
+      log('feed sync edge rpc outgoing', {
+        tag: rpcTag,
+        serviceId,
+        payloadByteLength: encoded.byteLength,
+        spaceId: message.spaceId,
+        feedNamespace: message.feedNamespace,
+        requestId: message.requestId,
+      });
       yield* Effect.tryPromise(async () =>
         this.#edgeClient.send(
+          ctx,
           createBuf(MessageSchema, {
             source: {
               identityKey: this.#edgeClient.identityKey,
               peerKey: this.#edgeClient.peerKey,
             },
-            serviceId: this.#getTargetServiceId(message),
+            serviceId,
             payload: { value: bufferToArray(encoded) },
           }),
         ),
+      ).pipe(
+        Effect.tapError((cause) =>
+          Effect.sync(() =>
+            log('feed sync edge send failed', {
+              serviceId,
+              tag: rpcTag,
+              cause: cause instanceof Error ? cause.message : String(cause),
+            }),
+          ),
+        ),
       );
     });
   }
@@ -173,12 +311,18 @@ export class FeedSyncer extends Resource {
         this.#spacesToPoll,
         (spaceId) =>
           Effect.gen(this, function* () {
-            const { done } = yield* this.#syncClient.pull({
-              spaceId,
-              feedNamespace: this.#syncNamespace,
-              limit: this.#messageBlocksLimit,
-            });
-            if (done) {
+            let doneForAllNamespaces = true;
+            for (const feedNamespace of this.#syncNamespaces) {
+              const { done } = yield* this.#syncClient.pull(this._ctx, {
+                spaceId,
+                feedNamespace,
+                limit: this.#messageBlocksLimit,
+              });
+              if (!done) {
+                doneForAllNamespaces = false;
+              }
+            }
+            if (doneForAllNamespaces) {
               this.#spacesToPoll.delete(spaceId);
             }
           }),
@@ -210,12 +354,18 @@ export class FeedSyncer extends Resource {
         this.#getSpaceIds(),
         (spaceId) =>
           Effect.gen(this, function* () {
-            const { done } = yield* this.#syncClient.push({
-              spaceId,
-              feedNamespace: this.#syncNamespace,
-              limit: this.#messageBlocksLimit,
-            });
-            if (!done) {
+            let doneForAllNamespaces = true;
+            for (const feedNamespace of this.#syncNamespaces) {
+              const { done } = yield* this.#syncClient.push(this._ctx, {
+                spaceId,
+                feedNamespace,
+                limit: this.#messageBlocksLimit,
+              });
+              if (!done) {
+                doneForAllNamespaces = false;
+              }
+            }
+            if (!doneForAllNamespaces) {
               // Keep pushing until all blocks are pushed.
               this.#pushTask.schedule();
             }

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

@@ -4,6 +4,7 @@
 
 import { describe, test } from 'vitest';
 
+import { Context } from '@dxos/context';
 import { MemorySignalManager, MemorySignalManagerContext } from '@dxos/messaging';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
 import { openAndClose } from '@dxos/test-utils';
@@ -19,7 +20,7 @@ describe('services/ServiceContext', () => {
     const device2 = await createOpenServiceContext(networkContext);
     await Promise.all(performInvitation({ host: device1, guest: device2, options: { kind: Invitation.Kind.DEVICE } }));
 
-    const space1 = await device1.dataSpaceManager!.createSpace();
+    const space1 = await device1.dataSpaceManager!.createSpace(new Context());
     await device2.dataSpaceManager!.waitUntilSpaceReady(space1!.key);
     const space2 = await device2.dataSpaceManager!.spaces.get(space1.key);
     await space2!.inner.controlPipeline.state.waitUntilTimeframe(space1.inner.controlPipeline.state.timeframe);
@@ -35,7 +36,7 @@ describe('services/ServiceContext', () => {
 
     const identity2 = await createOpenServiceContext(networkContext);
     await identity2.createIdentity();
-    const space1 = await identity2.dataSpaceManager!.createSpace();
+    const space1 = await identity2.dataSpaceManager!.createSpace(new Context());
     await Promise.all(
       performInvitation({
         host: identity2,