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

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

@@ -1,184 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { type MutexGuard, scheduleMicroTask, scheduleTask } from '@dxos/async';
-import { type Context } from '@dxos/context';
-import { ed25519Signature } from '@dxos/crypto';
-import { type EdgeHttpClient } from '@dxos/edge-client';
-import { invariant } from '@dxos/invariant';
-import { SpaceId } from '@dxos/keys';
-import { log } from '@dxos/log';
-import {
-  EdgeAuthChallengeError,
-  EdgeCallFailedError,
-  type JoinSpaceRequest,
-  type JoinSpaceResponseBody,
-} from '@dxos/protocols';
-import { schema } from '@dxos/protocols/proto';
-import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
-import { type DeviceProfileDocument } from '@dxos/protocols/proto/dxos/halo/credentials';
-import {
-  type AdmissionResponse,
-  type AdmissionRequest,
-  type SpaceAdmissionRequest,
-} from '@dxos/protocols/proto/dxos/halo/invitations';
-
-import { type InvitationProtocol } from './invitation-protocol';
-import { type FlowLockHolder, type GuardedInvitationState } from './invitation-state';
-import { tryAcquireBeforeContextDisposed } from './utils';
-
-export interface EdgeInvitationHandlerCallbacks {
-  onInvitationSuccess(response: AdmissionResponse, request: AdmissionRequest): Promise<void>;
-}
-
-export const DEFAULT_REQUEST_RETRY_INTERVAL_MS = 3000;
-export const DEFAULT_REQUEST_RETRY_JITTER_MS = 500;
-
-export type EdgeInvitationConfig = {
-  retryInterval?: number;
-  retryJitter?: number;
-};
-
-export class EdgeInvitationHandler implements FlowLockHolder {
-  private _flowLock: MutexGuard | undefined;
-
-  private readonly _retryInterval: number;
-  private readonly _retryJitter: number;
-
-  constructor(
-    config: EdgeInvitationConfig | undefined,
-    private readonly _client: EdgeHttpClient | undefined,
-    private readonly _callbacks: EdgeInvitationHandlerCallbacks,
-  ) {
-    this._retryInterval = config?.retryInterval ?? DEFAULT_REQUEST_RETRY_INTERVAL_MS;
-    this._retryJitter = config?.retryJitter ?? DEFAULT_REQUEST_RETRY_JITTER_MS;
-  }
-
-  public handle(
-    ctx: Context,
-    guardedState: GuardedInvitationState,
-    protocol: InvitationProtocol,
-    deviceProfile?: DeviceProfileDocument,
-  ) {
-    if (!this._client) {
-      log('edge disabled');
-      return;
-    }
-
-    const invitation = guardedState.current;
-    const spaceId = invitation.spaceId;
-    const canBeHandledByEdge =
-      invitation.authMethod !== Invitation.AuthMethod.SHARED_SECRET &&
-      invitation.type === Invitation.Type.DELEGATED &&
-      invitation.kind === Invitation.Kind.SPACE &&
-      spaceId != null &&
-      SpaceId.isValid(spaceId);
-
-    if (!canBeHandledByEdge) {
-      log('invitation could not be handled by edge', { invitation });
-      return;
-    }
-
-    ctx.onDispose(() => {
-      this._flowLock?.release();
-      this._flowLock = undefined;
-    });
-
-    const tryHandleInvitation = async () => {
-      const admissionRequest = await protocol.createAdmissionRequest(deviceProfile);
-      if (admissionRequest.space) {
-        try {
-          await this._handleSpaceInvitationFlow(ctx, guardedState, admissionRequest.space, spaceId);
-        } catch (error) {
-          if (error instanceof EdgeCallFailedError) {
-            log.info('join space with edge unsuccessful', {
-              reason: error.message,
-              retryable: error.isRetryable,
-              after: error.retryAfterMs ?? this._calculateNextRetryMs(),
-            });
-            if (error.isRetryable) {
-              scheduleTask(ctx, tryHandleInvitation, error.retryAfterMs ?? this._calculateNextRetryMs());
-            }
-          } else {
-            log.info('failed to handle invitation with edge', { error });
-            scheduleTask(ctx, tryHandleInvitation, this._calculateNextRetryMs());
-          }
-        }
-      }
-    };
-    scheduleMicroTask(ctx, tryHandleInvitation);
-  }
-
-  private async _handleSpaceInvitationFlow(
-    ctx: Context,
-    guardedState: GuardedInvitationState,
-    admissionRequest: SpaceAdmissionRequest,
-    spaceId: SpaceId,
-  ) {
-    try {
-      log('edge invitation flow');
-      this._flowLock = await tryAcquireBeforeContextDisposed(ctx, guardedState.mutex);
-      log('edge invitation flow acquired the lock');
-
-      guardedState.set(this, Invitation.State.CONNECTING);
-
-      const response = await this._joinSpaceByInvitation(guardedState, spaceId, {
-        identityKey: admissionRequest.identityKey.toHex(),
-        invitationId: guardedState.current.invitationId,
-      });
-
-      const admissionResponse = await this._mapToAdmissionResponse(response);
-      await this._callbacks.onInvitationSuccess(admissionResponse, { space: admissionRequest });
-    } catch (error) {
-      guardedState.set(this, Invitation.State.ERROR);
-      throw error;
-    } finally {
-      this._flowLock?.release();
-      this._flowLock = undefined;
-    }
-  }
-
-  private async _mapToAdmissionResponse(edgeResponse: JoinSpaceResponseBody): Promise<AdmissionResponse> {
-    const credentialBytes = Buffer.from(edgeResponse.spaceMemberCredential, 'base64');
-    const codec = schema.getCodecForType('dxos.halo.credentials.Credential');
-    return {
-      space: {
-        credential: codec.decode(credentialBytes),
-      },
-    };
-  }
-
-  private async _joinSpaceByInvitation(
-    guardedState: GuardedInvitationState,
-    spaceId: SpaceId,
-    request: JoinSpaceRequest,
-  ): Promise<JoinSpaceResponseBody> {
-    invariant(this._client);
-    try {
-      return await this._client.joinSpaceByInvitation(spaceId, request);
-    } catch (error: any) {
-      if (error instanceof EdgeAuthChallengeError) {
-        guardedState.set(this, Invitation.State.AUTHENTICATING);
-        const publicKey = guardedState.current.guestKeypair?.publicKey;
-        const privateKey = guardedState.current.guestKeypair?.privateKey;
-        if (!privateKey || !publicKey) {
-          throw error;
-        }
-        const signature = await ed25519Signature(privateKey, Buffer.from(error.challenge, 'base64'));
-        request.signature = Buffer.from(signature).toString('base64');
-        return this._client.joinSpaceByInvitation(spaceId, request);
-      } else {
-        throw error;
-      }
-    }
-  }
-
-  public hasFlowLock(): boolean {
-    return this._flowLock != null;
-  }
-
-  private _calculateNextRetryMs() {
-    return this._retryInterval + Math.random() * this._retryJitter;
-  }
-}

package/src/packlets/invitations/invitation-state.ts

@@ -1,111 +0,0 @@
-/**
- * A utility object for serializing invitation state changes by multiple concurrent
- * invitation flow connections.
- */
-//
-// Copyright 2024 DXOS.org
-//
-
-import { Mutex, type PushStream } from '@dxos/async';
-import { type Context } from '@dxos/context';
-import { log } from '@dxos/log';
-import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
-
-import { stateToString } from './utils';
-
-export interface FlowLockHolder {
-  hasFlowLock(): boolean;
-}
-
-export interface GuardedInvitationState {
-  mutex: Mutex;
-  current: Invitation;
-
-  complete(newState: Partial<Invitation>): void;
-  set(lockHolder: FlowLockHolder | null, newState: Invitation.State): boolean;
-  error(lockHolder: FlowLockHolder | null, error: any): boolean;
-}
-
-export const createGuardedInvitationState = (
-  ctx: Context,
-  invitation: Invitation,
-  stream: PushStream<Invitation>,
-): GuardedInvitationState => {
-  // 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 lastActiveLockHolder: FlowLockHolder | null = null;
-  let currentInvitation = { ...invitation };
-  const isStateChangeAllowed = (lockHolder: FlowLockHolder | null) => {
-    if (ctx.disposed || (lockHolder !== null && mutex.isLocked() && !lockHolder.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 lockHolder == null || lastActiveLockHolder !== lockHolder || isNonTerminalState(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: (lockHolder: FlowLockHolder | null, newState: Invitation.State): boolean => {
-      if (isStateChangeAllowed(lockHolder)) {
-        logStateUpdate(currentInvitation, lockHolder, newState);
-        currentInvitation = { ...currentInvitation, state: newState };
-        stream.next(currentInvitation);
-        lastActiveLockHolder = lockHolder;
-        return true;
-      }
-      return false;
-    },
-    error: (lockHolder: FlowLockHolder | null, error: any): boolean => {
-      if (isStateChangeAllowed(lockHolder)) {
-        logStateUpdate(currentInvitation, lockHolder, Invitation.State.ERROR);
-        currentInvitation = { ...currentInvitation, state: Invitation.State.ERROR };
-        stream.next(currentInvitation);
-        stream.error(error);
-        lastActiveLockHolder = lockHolder;
-        return true;
-      }
-      return false;
-    },
-  };
-};
-
-const logStateUpdate = (invitation: Invitation, actor: any, newState: Invitation.State) => {
-  if (isNonTerminalState(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),
-    });
-  }
-};
-
-const isNonTerminalState = (currentState: Invitation.State): boolean => {
-  return ![
-    Invitation.State.SUCCESS,
-    Invitation.State.ERROR,
-    Invitation.State.CANCELLED,
-    Invitation.State.TIMEOUT,
-    Invitation.State.EXPIRED,
-  ].includes(currentState);
-};

package/src/packlets/spaces/edge-feed-replicator.test.ts

@@ -1,253 +0,0 @@
-//
-// Copyright 2022 DXOS.org
-//
-
-import { decode as decodeCbor, encode as encodeCbor } from 'cbor-x';
-import { getRandomPort } from 'get-port-please';
-import { describe, test, onTestFinished, vi, expect } from 'vitest';
-
-import { Trigger, sleep } from '@dxos/async';
-import { Context } from '@dxos/context';
-import { valueEncoding } from '@dxos/echo-pipeline';
-import { createEphemeralEdgeIdentity, EdgeClient, EdgeIdentityChangedError } from '@dxos/edge-client';
-import { createTestEdgeWsServer } from '@dxos/edge-client/testing';
-import { FeedFactory, FeedStore } from '@dxos/feed-store';
-import { type FeedWrapper } from '@dxos/feed-store';
-import { Keyring } from '@dxos/keyring';
-import { SpaceId } from '@dxos/keys';
-import { type FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
-import { createStorage } from '@dxos/random-access-storage';
-import { openAndClose } from '@dxos/test-utils';
-import { Timeframe } from '@dxos/timeframe';
-import { range } from '@dxos/util';
-
-import { EdgeFeedReplicator } from './edge-feed-replicator';
-
-describe('EdgeFeedReplicator', () => {
-  test('requests metadata after connection is open', async () => {
-    const { endpoint, admitConnection, messageSink } = await createEdge();
-    const { messenger, sendSpy } = await createClient(endpoint);
-
-    await attachReplicator(messenger);
-
-    await sleep(50);
-
-    expect(sendSpy).not.toHaveBeenCalled();
-    expect(messageSink.length).toEqual(0);
-
-    admitConnection.wake();
-    await expect.poll(() => sendSpy.mock.calls.length).toEqual(1);
-    expect(messageSink.length).toEqual(1);
-    expect(messageSink[0].type).toEqual('get-metadata');
-  });
-
-  test('replicates if added to a connected client', async () => {
-    const { endpoint, admitConnection, messageSink } = await createEdge();
-    const { messenger } = await createClient(endpoint);
-    admitConnection.wake();
-    await expect.poll(() => messenger.isConnected).toBeTruthy();
-
-    await attachReplicator(messenger);
-    await expect.poll(() => messageSink.length).toEqual(1);
-  });
-
-  test('sends a block', async () => {
-    const { endpoint, admitConnection, messageSink } = await createEdge();
-    const { messenger } = await createClient(endpoint);
-
-    const { feed } = await attachReplicator(messenger);
-
-    admitConnection.wake();
-    await appendMessage(feed);
-
-    await expect.poll(() => messageSink.length).toEqual(2);
-    expect(messageSink[1].type).toEqual('data');
-  });
-
-  test('re-requests metadata on reconnect', async () => {
-    const { endpoint, admitConnection, messageSink } = await createEdge();
-    const { messenger } = await createClient(endpoint);
-
-    await attachReplicator(messenger);
-
-    admitConnection.wake();
-    await expect.poll(() => messageSink.length).toEqual(1);
-
-    await updateIdentity(messenger);
-    await messenger.reconnect.waitForCount(1);
-
-    await expect.poll(() => messageSink.length).toEqual(2);
-    expect(messageSink[1].type).toEqual('get-metadata');
-  });
-
-  test('recovers after query sending failure during identity change', async () => {
-    const { endpoint, admitConnection, messageSink } = await createEdge();
-    const { messenger, sendSpy } = await createClient(endpoint);
-
-    await attachReplicator(messenger);
-
-    sendSpy.mockImplementationOnce(() => {
-      throw new EdgeIdentityChangedError(); // Hard to mock the exact race condition for when this error is thrown
-    });
-    admitConnection.wake();
-
-    await expect.poll(() => sendSpy.mock.calls.length).toEqual(1);
-    expect(messageSink.length).toEqual(0);
-    await updateIdentity(messenger);
-
-    await expect.poll(() => messageSink.length).toEqual(1);
-    expect(messageSink[0].type).toEqual('get-metadata');
-  });
-
-  test('recovers after response sending failure during identity change', async () => {
-    const { endpoint, admitConnection, messageSink, sendResponseMessage } = await createEdge();
-    const { messenger, sendSpy } = await createClient(endpoint);
-
-    const { feed } = await attachReplicator(messenger);
-    await appendMessage(feed);
-
-    sendSpy.mockImplementationOnce(async (request: any) => {
-      sendResponseMessage(request, encodeCbor({ type: 'metadata', feedKey: feed.key.toHex(), length: 0 }));
-      return Promise.resolve();
-    });
-    sendSpy.mockImplementationOnce(async () => {
-      throw new EdgeIdentityChangedError();
-    });
-    admitConnection.wake();
-
-    await expect.poll(() => sendSpy.mock.calls.length).toEqual(2);
-    sendSpy.mockRestore();
-    expect(messageSink.length).toEqual(0);
-    await updateIdentity(messenger);
-
-    await messenger.reconnect.waitForCount(1);
-    await expect.poll(() => messageSink.find((msg) => msg.type === 'data')).toBeDefined();
-  });
-
-  test('propagates errors unrelated to reconnect', async () => {
-    const { endpoint, admitConnection } = await createEdge();
-    const { messenger, sendSpy } = await createClient(endpoint);
-
-    const { replicator } = await attachReplicator(messenger, { skipOpen: true });
-    const raised = new Trigger();
-    await replicator.open(new Context({ onError: () => raised.wake() }));
-    onTestFinished(async () => {
-      await replicator.close();
-    });
-
-    sendSpy.mockImplementationOnce(() => {
-      throw new Error();
-    });
-    admitConnection.wake();
-
-    await raised.wait();
-  });
-
-  test('identity update before connected', async () => {
-    const { endpoint, admitConnection, messageSink } = await createEdge();
-    const { messenger } = await createClient(endpoint);
-
-    await attachReplicator(messenger);
-    await updateIdentity(messenger);
-    await sleep(100);
-    admitConnection.wake();
-
-    await expect.poll(() => messageSink.length).toEqual(2);
-    expect(messageSink.map((m) => m.type)).toStrictEqual(range(2, () => 'get-metadata'));
-  });
-
-  test('block appended during reconnect', async () => {
-    const { endpoint, admitConnection, feedLength } = await createEdge();
-    const { messenger } = await createClient(endpoint);
-
-    const { feed } = await attachReplicator(messenger);
-    admitConnection.wake();
-    await sleep(10);
-
-    admitConnection.reset();
-    await updateIdentity(messenger);
-    await appendMessage(feed);
-    await sleep(20);
-    admitConnection.wake();
-
-    await expect.poll(() => feedLength()).toEqual(1);
-  });
-
-  test('reconnect during block append', async () => {
-    const { endpoint, admitConnection, feedLength } = await createEdge();
-    const { messenger } = await createClient(endpoint);
-
-    const { feed } = await attachReplicator(messenger);
-    admitConnection.wake();
-    await sleep(10);
-
-    void appendMessage(feed);
-    await updateIdentity(messenger);
-
-    await expect.poll(() => feedLength()).toEqual(1);
-  });
-
-  const createEdge = async () => {
-    const port = await getRandomPort('127.0.0.1');
-    let lastBlockIndex = -1;
-    const admitConnection = new Trigger();
-    const { cleanup, endpoint, messageSink, sendResponseMessage } = await createTestEdgeWsServer(port, {
-      admitConnection,
-      payloadDecoder: decodeCbor,
-      messageHandler: async (message: any) => {
-        if (message.type === 'get-metadata') {
-          return encodeCbor({ type: 'metadata', feedKey: message.feedKey, length: lastBlockIndex + 1 });
-        } else {
-          lastBlockIndex = Math.max(lastBlockIndex, message.blocks[message.blocks.length - 1].index);
-        }
-      },
-    });
-    onTestFinished(cleanup);
-
-    return {
-      endpoint,
-      messageSink,
-      admitConnection,
-      sendResponseMessage,
-      feedLength: () => lastBlockIndex + 1,
-    };
-  };
-
-  const createClient = async (endpoint: string) => {
-    const messenger = new EdgeClient(await createEphemeralEdgeIdentity(), { socketEndpoint: endpoint });
-    const sendSpy = vi.spyOn(messenger, 'send');
-    await openAndClose(messenger);
-    return { messenger, sendSpy };
-  };
-
-  const attachReplicator = async (messenger: EdgeClient, options?: { skipOpen?: boolean }) => {
-    const spaceId = SpaceId.random();
-    const feed = await createNewFeed();
-    const replicator = new EdgeFeedReplicator({ messenger, spaceId });
-    await replicator.addFeed(feed);
-    if (!options?.skipOpen) {
-      await openAndClose(replicator);
-    }
-    return { feed, replicator };
-  };
-
-  const createNewFeed = async () => {
-    const storage = createStorage();
-    const keyring = new Keyring();
-    const feedStore = new FeedStore<FeedMessage>({
-      factory: new FeedFactory<FeedMessage>({
-        root: storage.createDirectory(),
-        signer: keyring,
-        hypercore: { valueEncoding },
-      }),
-    });
-    onTestFinished(() => feedStore.close());
-    return feedStore.openFeed(await keyring.createKey(), { writable: true });
-  };
-
-  const updateIdentity = async (messenger: EdgeClient) => {
-    messenger.setIdentity(await createEphemeralEdgeIdentity());
-  };
-
-  const appendMessage = (feed: FeedWrapper<FeedMessage>) => feed.append({ timeframe: new Timeframe() });
-});

package/src/testing/setup.ts

@@ -1,11 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { runTestSignalServer } from '@dxos/signal';
-
-const port = 12004;
-
-export default async () => {
-  await runTestSignalServer({ port, killExisting: true });
-};