@dxos/client-services 0.6.13-main.548ca8d → 0.6.13-staging.1e988a3

package/src/packlets/invitations/device-invitation-protocol.test.ts

@@ -2,20 +2,19 @@
 // Copyright 2022 DXOS.org
 //
 
-import { describe, expect, test, onTestFinished } from 'vitest';
+import { expect } from 'chai';
 
 import { asyncChain } from '@dxos/async';
 import { Context } from '@dxos/context';
 import { AlreadyJoinedError } from '@dxos/protocols';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
+import { describe, test, afterTest } from '@dxos/test';
 
 import { type ServiceContext } from '../services';
 import { createPeers, createServiceContext, performInvitation } from '../testing';
 
 const closeAfterTest = async (peer: ServiceContext) => {
-  onTestFinished(async () => {
-    await peer.close();
-  });
+  afterTest(() => peer.close());
   return peer;
 };
 
@@ -23,9 +22,7 @@ describe('services/device', () => {
   test('creates identity', async () => {
     const peer = await createServiceContext();
     await peer.open(new Context());
-    onTestFinished(async () => {
-      await peer.close();
-    });
+    afterTest(() => peer.close());
 
     const identity = await peer.createIdentity();
     expect(identity).not.to.be.undefined;

package/src/packlets/invitations/invitation-guest-extenstion.ts

@@ -12,7 +12,6 @@ import { type Invitation } from '@dxos/protocols/proto/dxos/client/services';
 import { type InvitationHostService, InvitationOptions } from '@dxos/protocols/proto/dxos/halo/invitations';
 import { type ExtensionContext, RpcExtension } from '@dxos/teleport';
 
-import { type FlowLockHolder } from './invitation-state';
 import { tryAcquireBeforeContextDisposed } from './utils';
 
 const OPTIONS_TIMEOUT = 10_000;
@@ -28,13 +27,10 @@ type InvitationGuestExtensionCallbacks = {
 /**
  * Guest's side for a connection to a concrete peer in p2p network during invitation.
  */
-export class InvitationGuestExtension
-  extends RpcExtension<
-    { InvitationHostService: InvitationHostService },
-    { InvitationHostService: InvitationHostService }
-  >
-  implements FlowLockHolder
-{
+export class InvitationGuestExtension extends RpcExtension<
+  { InvitationHostService: InvitationHostService },
+  { InvitationHostService: InvitationHostService }
+> {
   private _ctx = new Context();
   private _remoteOptions?: InvitationOptions;
   private _remoteOptionsTrigger = new Trigger();

package/src/packlets/invitations/invitation-host-extension.ts

@@ -21,7 +21,6 @@ import {
 } from '@dxos/protocols/proto/dxos/halo/invitations';
 import { type ExtensionContext, RpcExtension } from '@dxos/teleport';
 
-import type { FlowLockHolder } from './invitation-state';
 import { stateToString, tryAcquireBeforeContextDisposed } from './utils';
 
 /// Timeout for the options exchange.
@@ -44,13 +43,10 @@ type InvitationHostExtensionCallbacks = {
 /**
  * Host's side for a connection to a concrete peer in p2p network during invitation.
  */
-export class InvitationHostExtension
-  extends RpcExtension<
-    { InvitationHostService: InvitationHostService },
-    { InvitationHostService: InvitationHostService }
-  >
-  implements FlowLockHolder
-{
+export class InvitationHostExtension extends RpcExtension<
+  { InvitationHostService: InvitationHostService },
+  { InvitationHostService: InvitationHostService }
+> {
   /**
    * @internal
    */
@@ -110,11 +106,13 @@ export class InvitationHostExtension
 
         introduce: async (request) => {
           const { profile, invitationId } = request;
+
           const traceId = PublicKey.random().toHex();
           log.trace('dxos.sdk.invitation-handler.host.introduce', trace.begin({ id: traceId }));
 
           const invitation = this._requireActiveInvitation();
           this._assertInvitationState(Invitation.State.CONNECTED);
+
           if (invitationId !== invitation?.invitationId) {
             log.warn('incorrect invitationId', { expected: invitation.invitationId, actual: invitationId });
             this._callbacks.onError(new Error('Incorrect invitationId.'));
@@ -128,6 +126,7 @@ export class InvitationHostExtension
           log('guest introduced themselves', { guestProfile: profile });
           this.guestProfile = profile;
           this._callbacks.onStateUpdate(Invitation.State.READY_FOR_AUTHENTICATION);
+
           this._challenge =
             invitation.authMethod === Invitation.AuthMethod.KNOWN_PUBLIC_KEY ? randomBytes(32) : undefined;
 

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

@@ -2,13 +2,13 @@
 // Copyright 2024 DXOS.org
 //
 
-import { beforeEach, onTestFinished, describe, expect, test } from 'vitest';
+import { expect } from 'chai';
 
 import { type PushStream, sleep, Trigger, waitForCondition } from '@dxos/async';
 import { Context } from '@dxos/context';
 import { PublicKey } from '@dxos/keys';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
-import { openAndClose } from '@dxos/test-utils';
+import { afterTest, describe, openAndClose, test } from '@dxos/test';
 import { range } from '@dxos/util';
 
 import { type InvitationProtocol } from './invitation-protocol';
@@ -34,7 +34,6 @@ type StateUpdateSink = PushStream<Invitation> & {
 
 describe('InvitationHandler', () => {
   let testBuilder: TestBuilder;
-
   beforeEach(() => {
     testBuilder = new TestBuilder();
   });
@@ -164,7 +163,7 @@ describe('InvitationHandler', () => {
       expect(guest.ctx.disposed).to.be.true;
     });
 
-    test('guest gives up after trying with three hosts', { timeout: 20_000 }, async () => {
+    test('guest gives up after trying with three hosts', async () => {
       const hosts: PeerSetup[] = [await createPeer()];
       const [host] = hosts;
       const invitation = await createInvitation(host, { multiUse: true });
@@ -182,7 +181,7 @@ describe('InvitationHandler', () => {
 
       await sleep(10);
       expect(guest.sink.lastState).to.eq(Invitation.State.ERROR);
-    });
+    }).timeout(20_000);
 
     test('single host - many guests', async () => {
       const hosts: PeerSetup[] = [await createPeer()];
@@ -257,14 +256,12 @@ describe('InvitationHandler', () => {
       const space = await peer.dataSpaceManager.createSpace();
       spaceKey = space.key;
     }
-    const invitationHandler = new InvitationsHandler(peer.networkManager, undefined, {
-      teleport: { controlHeartbeatInterval: 250 }, // faster peer failure detection
+    const invitationHandler = new InvitationsHandler(peer.networkManager, {
+      controlHeartbeatInterval: 250, // faster peer failure detection
     });
     const protocol = new SpaceInvitationProtocol(peer.dataSpaceManager, peer.identity, peer.keyring, spaceKey);
     const ctx = new Context();
-    onTestFinished(async () => {
-      await ctx.dispose();
-    });
+    afterTest(() => ctx.dispose());
     const sink = newStateUpdateSink();
     return { ctx, sink, peer, protocol, handler: invitationHandler, spaceKey };
   };
@@ -272,18 +269,14 @@ describe('InvitationHandler', () => {
   const hostInvitation = async (setup: PeerSetup, invitation: Invitation) => {
     await setup.ctx.dispose();
     setup.ctx = new Context();
-    onTestFinished(async () => {
-      await setup.ctx.dispose();
-    });
+    afterTest(() => setup.ctx.dispose());
     setup.handler.handleInvitationFlow(setup.ctx, setup.sink, setup.protocol, invitation);
   };
 
   const acceptInvitation = async (setup: PeerSetup, invitation: Invitation): Promise<Trigger<string>> => {
     await setup.ctx.dispose();
     setup.ctx = new Context();
-    onTestFinished(async () => {
-      await setup.ctx.dispose();
-    });
+    afterTest(() => setup.ctx.dispose());
     const authCodeInput = new Trigger<string>();
     setup.handler.acceptInvitation(setup.ctx, setup.sink, setup.protocol, invitation, authCodeInput);
     return authCodeInput;

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

@@ -2,11 +2,10 @@
 // Copyright 2022 DXOS.org
 //
 
-import { type PushStream, scheduleTask, TimeoutError, type Trigger } from '@dxos/async';
+import { Mutex, type PushStream, scheduleTask, TimeoutError, type Trigger } from '@dxos/async';
 import { INVITATION_TIMEOUT } from '@dxos/client-protocol';
 import { type Context, ContextDisposedError } from '@dxos/context';
 import { createKeyPair, sign } from '@dxos/crypto';
-import { type EdgeHttpClient } from '@dxos/edge-client';
 import { invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
@@ -20,21 +19,17 @@ import { type ExtensionContext, type TeleportExtension, type TeleportParams } fr
 import { trace as _trace } from '@dxos/tracing';
 import { ComplexSet } from '@dxos/util';
 
-import { type EdgeInvitationConfig, EdgeInvitationHandler } from './edge-invitation-handler';
 import { InvitationGuestExtension } from './invitation-guest-extenstion';
 import { InvitationHostExtension, isAuthenticationRequired, MAX_OTP_ATTEMPTS } from './invitation-host-extension';
 import { type InvitationProtocol } from './invitation-protocol';
-import { createGuardedInvitationState } from './invitation-state';
 import { InvitationTopology } from './invitation-topology';
+import { stateToString } from './utils';
 
 const metrics = _trace.metrics;
 
 const MAX_DELEGATED_INVITATION_HOST_TRIES = 3;
 
-export type InvitationConnectionParams = {
-  teleport: Partial<TeleportParams>;
-  edgeInvitations?: EdgeInvitationConfig;
-};
+type InvitationExtension = InvitationHostExtension | InvitationGuestExtension;
 
 /**
  * Generic handler for Halo and Space invitations.
@@ -70,8 +65,7 @@ export class InvitationsHandler {
    */
   constructor(
     private readonly _networkManager: SwarmNetworkManager,
-    private readonly _edgeClient?: EdgeHttpClient,
-    private readonly _connectionParams?: InvitationConnectionParams,
+    private readonly _defaultTeleportParams?: Partial<TeleportParams>,
   ) {}
 
   handleInvitationFlow(
@@ -81,7 +75,7 @@ export class InvitationsHandler {
     invitation: Invitation,
   ): void {
     metrics.increment('dxos.invitation.created');
-    const guardedState = createGuardedInvitationState(ctx, invitation, stream);
+    const guardedState = this._createGuardedState(ctx, invitation, stream);
     // Called for every connecting peer.
     const createExtension = (): InvitationHostExtension => {
       const extension = new InvitationHostExtension(guardedState.mutex, {
@@ -214,7 +208,7 @@ export class InvitationsHandler {
     }
 
     const triedPeersIds = new ComplexSet(PublicKey.hash);
-    const guardedState = createGuardedInvitationState(ctx, invitation, stream);
+    const guardedState = this._createGuardedState(ctx, invitation, stream);
 
     const shouldCancelInvitationFlow = (extension: InvitationGuestExtension) => {
       const isLockedByAnotherConnection = guardedState.mutex.isLocked() && !extension.hasFlowLock();
@@ -316,7 +310,7 @@ export class InvitationsHandler {
 
               // 5. Success.
               log('admitted by host', { ...protocol.toJSON() });
-              guardedState.complete({
+              await guardedState.complete({
                 ...guardedState.current,
                 ...result,
                 state: Invitation.State.SUCCESS,
@@ -352,15 +346,6 @@ export class InvitationsHandler {
       return extension;
     };
 
-    const edgeInvitationHandler = new EdgeInvitationHandler(this._connectionParams?.edgeInvitations, this._edgeClient, {
-      onInvitationSuccess: async (admissionResponse, admissionRequest) => {
-        const result = await protocol.accept(admissionResponse, admissionRequest);
-        log('admitted by edge', { ...protocol.toJSON() });
-        guardedState.complete({ ...guardedState.current, ...result, state: Invitation.State.SUCCESS });
-      },
-    });
-    edgeInvitationHandler.handle(ctx, guardedState, protocol, deviceProfile);
-
     scheduleTask(ctx, async () => {
       const error = protocol.checkInvitation(invitation);
       if (error) {
@@ -404,7 +389,7 @@ export class InvitationsHandler {
       topic: invitation.swarmKey,
       protocolProvider: createTeleportProtocolFactory(async (teleport) => {
         teleport.addExtension('dxos.halo.invitations', extensionFactory());
-      }, this._connectionParams?.teleport),
+      }, this._defaultTeleportParams),
       topology: new InvitationTopology(role),
       label,
     });
@@ -412,6 +397,90 @@ export class InvitationsHandler {
     return swarmConnection;
   }
 
+  /**
+   * A utility object for serializing invitation state changes by multiple concurrent
+   * invitation flow connections.
+   */
+  private _createGuardedState(ctx: Context, invitation: Invitation, stream: PushStream<Invitation>) {
+    // the mutex guards invitation flow on host and guest side, making sure only one flow is currently active
+    // deadlocks seem very unlikely because hosts don't initiate multiple connections
+    // even if this somehow happens that there are 2 guests (A, B) and 2 hosts (1, 2) and:
+    //  A has lock for flow with 1, B has lock for flow with 2
+    //  1 has lock for flow with B, 2 has lock for flow with A
+    // there'll be a 10-second introduction timeout after which connection will be closed and deadlock broken
+    const mutex = new Mutex();
+    let lastActiveExtension: any = null;
+    let currentInvitation = { ...invitation };
+    const isStateChangeAllowed = (extension: InvitationExtension | null) => {
+      if (ctx.disposed || (extension !== null && mutex.isLocked() && !extension.hasFlowLock())) {
+        return false;
+      }
+      // don't allow transitions from a terminal state unless a new extension acquired mutex
+      // handles a case when error occurs (e.g. connection is closed) after we completed the flow
+      // successfully or already reported another error
+      return extension == null || lastActiveExtension !== extension || this._isNotTerminal(currentInvitation.state);
+    };
+    return {
+      mutex,
+      get current() {
+        return currentInvitation;
+      },
+      // disposing context prevents any further state updates
+      complete: (newState: Partial<Invitation>) => {
+        currentInvitation = { ...currentInvitation, ...newState };
+        stream.next(currentInvitation);
+        return ctx.dispose();
+      },
+      set: (extension: InvitationExtension | null, newState: Invitation.State): boolean => {
+        if (isStateChangeAllowed(extension)) {
+          this._logStateUpdate(currentInvitation, extension, newState);
+          currentInvitation = { ...currentInvitation, state: newState };
+          stream.next(currentInvitation);
+          lastActiveExtension = extension;
+          return true;
+        }
+        return false;
+      },
+      error: (extension: InvitationExtension | null, error: any): boolean => {
+        if (isStateChangeAllowed(extension)) {
+          this._logStateUpdate(currentInvitation, extension, Invitation.State.ERROR);
+          currentInvitation = { ...currentInvitation, state: Invitation.State.ERROR };
+          stream.next(currentInvitation);
+          stream.error(error);
+          lastActiveExtension = extension;
+          return true;
+        }
+        return false;
+      },
+    };
+  }
+
+  private _logStateUpdate(invitation: Invitation, actor: any, newState: Invitation.State) {
+    if (this._isNotTerminal(newState)) {
+      log('invitation state update', {
+        actor: actor?.constructor.name,
+        newState: stateToString(newState),
+        oldState: stateToString(invitation.state),
+      });
+    } else {
+      log.info('invitation state update', {
+        actor: actor?.constructor.name,
+        newState: stateToString(newState),
+        oldState: stateToString(invitation.state),
+      });
+    }
+  }
+
+  private _isNotTerminal(currentState: Invitation.State): boolean {
+    return ![
+      Invitation.State.SUCCESS,
+      Invitation.State.ERROR,
+      Invitation.State.CANCELLED,
+      Invitation.State.TIMEOUT,
+      Invitation.State.EXPIRED,
+    ].includes(currentState);
+  }
+
   private async _handleGuestOtpAuth(
     extension: InvitationGuestExtension,
     setState: (newState: Invitation.State) => void,

package/src/packlets/invitations/space-invitation-protocol.test.ts

@@ -2,21 +2,20 @@
 // Copyright 2022 DXOS.org
 //
 
-import { onTestFinished, describe, expect, test } from 'vitest';
+import { expect } from 'chai';
 
 import { asyncChain, Trigger } from '@dxos/async';
 import { raise } from '@dxos/debug';
 import { AlreadyJoinedError } from '@dxos/protocols';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
+import { afterTest, describe, test } from '@dxos/test';
 
 import { type ServiceContext } from '../services';
 import { createIdentity, createPeers } from '../testing';
 import { acceptInvitation, createInvitation, performInvitation } from '../testing/invitation-utils';
 
 const closeAfterTest = async (peer: ServiceContext) => {
-  onTestFinished(async () => {
-    await peer.close();
-  });
+  afterTest(() => peer.close());
   return peer;
 };
 

package/src/packlets/invitations/space-invitation-protocol.ts

@@ -60,13 +60,9 @@ export class SpaceInvitationProtocol implements InvitationProtocol {
   }
 
   getInvitationContext(): Partial<Invitation> & Pick<Invitation, 'kind'> {
-    invariant(this._spaceKey);
-    const space = this._spaceManager.spaces.get(this._spaceKey);
-    invariant(space);
     return {
       kind: Invitation.Kind.SPACE,
       spaceKey: this._spaceKey,
-      spaceId: space.id,
     };
   }
 

package/src/packlets/logging/logging.test.ts

@@ -2,11 +2,12 @@
 // Copyright 2023 DXOS.org
 //
 
-import { afterEach, beforeEach, describe, expect, test } from 'vitest';
+import { expect } from 'chai';
 
 import { Trigger } from '@dxos/async';
 import { log, LogLevel } from '@dxos/log';
 import { type LogEntry } from '@dxos/protocols/proto/dxos/client/services';
+import { beforeEach, describe, test } from '@dxos/test';
 
 import { LoggingServiceImpl } from './logging-service';
 

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

@@ -2,11 +2,12 @@
 // Copyright 2023 DXOS.org
 //
 
-import { afterEach, onTestFinished, beforeEach, describe, expect, test } from 'vitest';
+import { expect } from 'chai';
 
 import { Trigger } from '@dxos/async';
 import { Context } from '@dxos/context';
 import { type NetworkService, ConnectionState } from '@dxos/protocols/proto/dxos/client/services';
+import { afterEach, afterTest, beforeEach, describe, test } from '@dxos/test';
 
 import { NetworkServiceImpl } from './network-service';
 import { type ServiceContext } from '../services';
@@ -40,7 +41,7 @@ describe('NetworkService', () => {
     query.subscribe(({ swarm }) => {
       result.wake(swarm);
     });
-    onTestFinished(() => query.close());
+    afterTest(() => query.close());
     expect(await result.wait()).to.equal(ConnectionState.ONLINE);
 
     result = new Trigger<ConnectionState | undefined>();

package/src/packlets/services/automerge-host.test.ts

@@ -0,0 +1,60 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { expect } from 'chai';
+
+import { asyncTimeout } from '@dxos/async';
+import { AutomergeContext } from '@dxos/echo-db';
+import { AutomergeHost, DataServiceImpl } from '@dxos/echo-pipeline';
+import { IndexMetadataStore } from '@dxos/indexing';
+import { createTestLevel } from '@dxos/kv-store/testing';
+import { afterTest, describe, openAndClose, test } from '@dxos/test';
+
+describe('AutomergeHost', () => {
+  test('automerge context is being synced with host', async () => {
+    //
+    // Setup:
+    // client-services           | <-------------> | client
+    // AutomergeHost             | DataServiceImpl | AutomergeContext
+    // creates repo and document | replicates repo | finds document in repo
+    //
+
+    const level = createTestLevel();
+    await level.open();
+    afterTest(() => level.close());
+
+    const host = new AutomergeHost({
+      db: level,
+      indexMetadataStore: new IndexMetadataStore({ db: level.sublevel('index-metadata') }),
+    });
+    await host.open();
+    afterTest(() => host.close());
+
+    const dataService = new DataServiceImpl({ automergeHost: host, updateIndexes: async () => {} });
+    const client = new AutomergeContext(dataService);
+    await openAndClose(client);
+
+    // Create document in repo.
+    const handle = host.repo.create();
+    const text = 'Hello World!';
+    handle.change((doc: any) => {
+      doc.text = text;
+    });
+
+    // Find document in repo.
+    const doc = client.repo.find<{ text: string }>(handle.url);
+    await asyncTimeout(doc.whenReady(), 1_000);
+    expect(doc.docSync().text).to.equal(text);
+
+    // Changes from client are replicated to host.
+    const newText = 'Goodbye World!!!';
+    doc.change((doc: any) => {
+      doc.text = newText;
+    });
+    await client.flush({ documentIds: [doc.documentId] });
+
+    await asyncTimeout(handle.whenReady(), 1_000);
+    expect(handle.docSync().text).to.equal(newText);
+  });
+});

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

@@ -2,11 +2,9 @@
 // Copyright 2023 DXOS.org
 //
 
-import { describe, test } from 'vitest';
-
 import { MemorySignalManagerContext, MemorySignalManager } from '@dxos/messaging';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
-import { openAndClose } from '@dxos/test-utils';
+import { describe, openAndClose, test } from '@dxos/test';
 
 import { createServiceContext, performInvitation } from '../testing';