@dxos/client-services 0.5.0 → 0.5.1-main.0ba1ecb

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

@@ -0,0 +1,87 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { invariant } from '@dxos/invariant';
+import { PublicKey } from '@dxos/keys';
+import { log } from '@dxos/log';
+import type { SwarmController, Topology } from '@dxos/network-manager';
+import { Options } from '@dxos/protocols/proto/dxos/halo/invitations';
+import { ComplexSet } from '@dxos/util';
+
+/**
+ * Hosts are listening on an invitation topic.
+ * They initiate a connection with any new peer if they are not currently in the invitation flow
+ * with another peer (connected.length > 0).
+ * When the invitation flow ends guest leaves the swarm and topology is updated once again,
+ * so we can connect to the next peer we haven't tried yet.
+ * If the peer turns out to be a host or a malicious guest their ID is remembered so that we don't try
+ * to establish a connection with them again.
+ *
+ * Guests don't initiate connections. They accept all connections because if we reject,
+ * the host won't retry their offer.
+ * Even if we started an invitation flow with one host we might want to try other hosts in case
+ * the first one failed due to a network error, so multiple connections are accepted.
+ */
+export class InvitationTopology implements Topology {
+  private _controller?: SwarmController;
+
+  /**
+   * Peers we tried to establish a connection with.
+   * In invitation flow peers are assigned random ids when they join the swarm, so we'll retry
+   * a peer if they reload an invitation.
+   *
+   * Consider keeping a separate set for peers we know are hosts and have some retry timeout
+   * for guests we failed an invitation flow with (potentially due to a network error).
+   */
+  private _seenPeers = new ComplexSet<PublicKey>(PublicKey.hash);
+
+  constructor(private readonly _role: Options.Role) {}
+
+  init(controller: SwarmController): void {
+    invariant(!this._controller, 'Already initialized.');
+    this._controller = controller;
+  }
+
+  update(): void {
+    invariant(this._controller, 'Not initialized.');
+    const { ownPeerId, candidates, connected, allPeers } = this._controller.getState();
+
+    // guests don't initiate connections
+    if (this._role === Options.Role.GUEST) {
+      return;
+    }
+
+    // don't start a connection while we have an active invitation flow
+    if (connected.length > 0) {
+      // update seenPeers here as well in case another host initiated a connection with us
+      connected.forEach((c) => this._seenPeers.add(c));
+      return;
+    }
+
+    const firstUnknownPeer = candidates.find((peerId) => !this._seenPeers.has(peerId));
+    // cleanup
+    this._seenPeers = new ComplexSet<PublicKey>(
+      PublicKey.hash,
+      allPeers.filter((peerId) => this._seenPeers.has(peerId)),
+    );
+    if (firstUnknownPeer != null) {
+      log('invitation connect', { ownPeerId, remotePeerId: firstUnknownPeer });
+      this._controller.connect(firstUnknownPeer);
+      this._seenPeers.add(firstUnknownPeer);
+    }
+  }
+
+  async onOffer(peer: PublicKey): Promise<boolean> {
+    invariant(this._controller, 'Not initialized.');
+    return !this._seenPeers.has(peer);
+  }
+
+  async destroy(): Promise<void> {
+    this._seenPeers.clear();
+  }
+
+  toString() {
+    return `InvitationTopology(${this._role === Options.Role.GUEST ? 'guest' : 'host'})`;
+  }
+}

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

@@ -0,0 +1,361 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+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 { afterTest, describe, openAndClose, test } from '@dxos/test';
+import { range } from '@dxos/util';
+
+import { type InvitationProtocol } from './invitation-protocol';
+import { InvitationsHandler } from './invitations-handler';
+import { SpaceInvitationProtocol } from './space-invitation-protocol';
+import { TestBuilder, type TestPeer } from '../testing';
+
+interface PeerSetup {
+  ctx: Context;
+  peer: TestPeer;
+  sink: StateUpdateSink;
+  protocol: InvitationProtocol;
+  handler: InvitationsHandler;
+  spaceKey: PublicKey;
+}
+
+type StateUpdateSink = PushStream<Invitation> & {
+  sink: Invitation[];
+  lastState: Invitation.State | undefined;
+  hasState(startingFrom: number, state: Invitation.State): boolean;
+  waitFor(state: Invitation.State): Promise<void>;
+};
+
+describe('InvitationHandler', () => {
+  let testBuilder: TestBuilder;
+  beforeEach(() => {
+    testBuilder = new TestBuilder();
+  });
+
+  describe('delegated invitations', () => {
+    for (const multiUse of [false, true]) {
+      test(`base case success multiUse=${multiUse}`, async () => {
+        const host = await createPeer();
+        const invitation = await createInvitation(host, { multiUse });
+        await hostInvitation(host, invitation);
+
+        const guest = await createPeer(host.spaceKey);
+        await performAuth(guest, invitation);
+
+        await sleep(15);
+        expect(guest.ctx.disposed).to.be.true;
+        if (multiUse) {
+          expect(host.ctx.disposed).to.be.false;
+        } else {
+          expect(host.ctx.disposed).to.be.true;
+        }
+      });
+    }
+
+    test('invitation timeout', async () => {
+      const host = await createPeer();
+      const invitation = await createInvitation(host, {
+        timeout: 100,
+      });
+      await hostInvitation(host, invitation);
+
+      const guest = await createPeer(host.spaceKey);
+      await acceptInvitation(guest, invitation);
+
+      await guest.sink.waitFor(Invitation.State.READY_FOR_AUTHENTICATION);
+      await sleep(200);
+      await host.sink.waitFor(Invitation.State.TIMEOUT);
+      await guest.sink.waitFor(Invitation.State.TIMEOUT);
+
+      await sleep(10);
+      expect(host.ctx.disposed).to.be.false;
+      expect(guest.ctx.disposed).to.be.false;
+    });
+
+    test('host ctx active after guest disconnects', async () => {
+      const host = await createPeer();
+      const invitation = await createInvitation(host, {
+        timeout: 100,
+      });
+      await hostInvitation(host, invitation);
+
+      const guest = await createPeer(host.spaceKey);
+      await acceptInvitation(guest, invitation);
+
+      await guest.sink.waitFor(Invitation.State.READY_FOR_AUTHENTICATION);
+      await guest.peer.networkManager.close();
+      await host.sink.waitFor(Invitation.State.ERROR);
+
+      await sleep(10);
+      expect(host.ctx.disposed).to.be.false;
+    });
+
+    test('invitation success after first guest error', async () => {
+      const host = await createPeer();
+      const invitation = await createInvitation(host);
+      await hostInvitation(host, invitation);
+
+      const badGuest = await createPeer(host.spaceKey);
+      await failAuth(badGuest, invitation);
+      await badGuest.sink.waitFor(Invitation.State.ERROR);
+
+      const goodGuest = await createPeer(host.spaceKey);
+      await performAuth(goodGuest, invitation);
+      await host.sink.waitFor(Invitation.State.SUCCESS);
+
+      await sleep(10);
+      expect(goodGuest.ctx.disposed).to.be.true;
+      expect(host.ctx.disposed).to.be.true;
+    });
+
+    test('multiUse invitation with multiple guests', async () => {
+      const host = await createPeer();
+      const invitation = await createInvitation(host, { multiUse: true });
+      await hostInvitation(host, invitation);
+
+      const guest1 = await createPeer(host.spaceKey);
+      await performAuth(guest1, invitation);
+      const guest2 = await createPeer(host.spaceKey);
+      await performAuth(guest2, invitation);
+
+      await sleep(5);
+      [guest1, guest2].forEach((g) => expect(g.ctx.disposed).to.be.true);
+      expect(host.ctx.disposed).to.be.false;
+    });
+
+    test('invitation success after host error with another host', async () => {
+      const host = await createPeer();
+      const invitation = await createInvitation(host, { multiUse: true });
+      await hostInvitation(host, invitation);
+      const anotherHost = await createNewHost(invitation);
+
+      const guest = await createPeer(host.spaceKey);
+      const codeInput = await failAuth(guest, invitation);
+      while (!guest.ctx.disposed) {
+        codeInput.wake(invitation.authCode!);
+        await sleep(10);
+      }
+      await guest.sink.waitFor(Invitation.State.SUCCESS);
+
+      const hostFailed = [host, anotherHost].map((h) => h.sink.hasState(0, Invitation.State.ERROR));
+      expect(hostFailed.sort()).to.deep.eq([false, true]);
+    });
+
+    test('single guest - many hosts', async () => {
+      const hosts: PeerSetup[] = [await createPeer()];
+      const [host] = hosts;
+      const invitation = await createInvitation(host, { multiUse: true });
+      await hostInvitation(host, invitation);
+      for (let i = 0; i < 4; i++) {
+        hosts.push(await createNewHost(invitation));
+      }
+
+      const guest = await createPeer(host.spaceKey);
+      await performAuth(guest, invitation);
+      await guest.sink.waitFor(Invitation.State.SUCCESS);
+      await sleep(10);
+      expect(guest.ctx.disposed).to.be.true;
+    });
+
+    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 });
+      await hostInvitation(host, invitation);
+      for (let i = 0; i < 2; i++) {
+        hosts.push(await createNewHost(invitation));
+      }
+
+      const guest = await createPeer(host.spaceKey);
+      const codeInput = await acceptInvitation(guest, invitation);
+      while (!guest.ctx.disposed) {
+        await failCodeInput(guest, codeInput, invitation);
+        await sleep(10);
+      }
+
+      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()];
+      const [host] = hosts;
+      const invitation = await createInvitation(host, { multiUse: true });
+      await hostInvitation(host, invitation);
+      const guests = await Promise.all(
+        range(5).map(async () => {
+          const guest = await createPeer(host.spaceKey);
+          await performAuth(guest, invitation);
+          return guest;
+        }),
+      );
+
+      await sleep(10);
+      guests.forEach((g) => {
+        expect(g.ctx.disposed).to.be.true;
+        expect(g.sink.lastState).to.eq(Invitation.State.SUCCESS);
+      });
+    });
+
+    test('many guests - many hosts', async () => {
+      const hosts: PeerSetup[] = [await createPeer()];
+      const [host] = hosts;
+      const invitation = await createInvitation(host, { multiUse: true });
+      await hostInvitation(host, invitation);
+      for (let i = 0; i < 4; i++) {
+        hosts.push(await createNewHost(invitation));
+      }
+      const guests = await Promise.all(
+        range(5).map(async () => {
+          const guest = await createPeer(host.spaceKey);
+          await performAuth(guest, invitation);
+          return guest;
+        }),
+      );
+      await sleep(10);
+      guests.forEach((g) => {
+        expect(g.ctx.disposed).to.be.true;
+        expect(g.sink.lastState).to.eq(Invitation.State.SUCCESS);
+      });
+    });
+
+    test('single use invitation - many guests - only one admitted', async () => {
+      const host = await createPeer();
+      const invitation = await createInvitation(host);
+      await hostInvitation(host, invitation);
+      const guests = await Promise.all(
+        range(5).map(async () => {
+          const guest = await createPeer(invitation.spaceKey);
+          const authCodeInput2 = await acceptInvitation(guest, invitation);
+          authCodeInput2.wake(invitation.authCode!);
+          return guest;
+        }),
+      );
+
+      await waitForCondition({
+        condition: () => guests.find((g) => g.sink.lastState === Invitation.State.SUCCESS) != null,
+      });
+      await sleep(40);
+      const success = guests.filter((g) => g.sink.lastState === Invitation.State.SUCCESS);
+      expect(success.length).to.eq(1);
+    });
+  });
+
+  const createPeer = async (spaceKey: PublicKey | null = null): Promise<PeerSetup> => {
+    const peer = testBuilder.createPeer();
+    await peer.createIdentity();
+    await openAndClose(peer.echoHost, peer.dataSpaceManager);
+    if (spaceKey == null) {
+      const space = await peer.dataSpaceManager.createSpace();
+      spaceKey = space.key;
+    }
+    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();
+    afterTest(() => ctx.dispose());
+    const sink = newStateUpdateSink();
+    return { ctx, sink, peer, protocol, handler: invitationHandler, spaceKey };
+  };
+
+  const hostInvitation = async (setup: PeerSetup, invitation: Invitation) => {
+    await setup.ctx.dispose();
+    setup.ctx = new Context();
+    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();
+    afterTest(() => setup.ctx.dispose());
+    const authCodeInput = new Trigger<string>();
+    setup.handler.acceptInvitation(setup.ctx, setup.sink, setup.protocol, invitation, authCodeInput);
+    return authCodeInput;
+  };
+
+  const failAuth = async (setup: PeerSetup, invitation: Invitation) => {
+    const wrongAuthCodeInput = await acceptInvitation(setup, invitation);
+    await setup.sink.waitFor(Invitation.State.READY_FOR_AUTHENTICATION);
+    await failCodeInput(setup, wrongAuthCodeInput, invitation);
+    return wrongAuthCodeInput;
+  };
+
+  const failCodeInput = async (setup: PeerSetup, codeInput: Trigger<string>, invitation: Invitation): Promise<void> => {
+    const checkFrom = setup.sink.sink.length;
+    while (
+      !setup.ctx.disposed &&
+      !setup.sink.hasState(checkFrom, Invitation.State.ERROR) &&
+      !setup.sink.hasState(checkFrom, Invitation.State.CONNECTED)
+    ) {
+      codeInput.wake(invitation.authCode + '1');
+      await sleep(20);
+    }
+  };
+
+  const createNewHost = async (invitation: Invitation): Promise<PeerSetup> => {
+    const newHost = await createPeer(invitation.spaceKey!);
+    await performAuth(newHost, invitation);
+    await sleep(30);
+    await hostInvitation(newHost, invitation);
+    return newHost;
+  };
+
+  const performAuth = async (setup: PeerSetup, invitation: Invitation) => {
+    const authCodeInput2 = await acceptInvitation(setup, invitation);
+    await setup.sink.waitFor(Invitation.State.READY_FOR_AUTHENTICATION);
+    authCodeInput2.wake(invitation.authCode!);
+    await setup.sink.waitFor(Invitation.State.SUCCESS);
+  };
+
+  const newStateUpdateSink = (): StateUpdateSink => {
+    const sink: Invitation[] = [];
+    const hasState = (startingIndex: number, state: Invitation.State): boolean => {
+      return sink
+        .slice(startingIndex)
+        .map((i) => i.state)
+        .includes(state);
+    };
+    return {
+      sink,
+      next: sink.push.bind(sink),
+      error: () => {},
+      complete: () => {},
+      hasState,
+      get lastState() {
+        return sink[sink.length - 1]?.state;
+      },
+      waitFor: async (state: Invitation.State): Promise<void> => {
+        if (sink[sink.length - 1]?.state === state) {
+          return;
+        }
+        const sliceStart = sink.length;
+        await waitForCondition({
+          condition: () => hasState(sliceStart, state),
+        });
+      },
+    } as any;
+  };
+
+  const createInvitation = async (setup: PeerSetup, options?: Partial<Invitation>): Promise<Invitation> => {
+    const observable = await setup.peer.invitationsManager.createInvitation({
+      type: Invitation.Type.DELEGATED,
+      kind: Invitation.Kind.SPACE,
+      authMethod: Invitation.AuthMethod.SHARED_SECRET,
+      spaceKey: setup.spaceKey,
+      multiUse: false,
+      ...options,
+    });
+    // cancel to avoid interfering with invitations-handler direct invocations
+    const invitation = observable.get();
+    await setup.peer.invitationsManager.cancelInvitation(invitation);
+    return { ...invitation, swarmKey: PublicKey.random() };
+  };
+});