@dxos/client-services 0.1.23 → 0.1.24

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

@@ -2,17 +2,29 @@
 // Copyright 2022 DXOS.org
 //
 
-import assert from 'node:assert';
-
 import { trackLeaks } from '@dxos/async';
 import { Context } from '@dxos/context';
-import { Database, DataPipelineControllerImpl, ISpace, MetadataStore, Space, SnapshotManager } from '@dxos/echo-db';
+import { CredentialConsumer } from '@dxos/credentials';
+import { timed } from '@dxos/debug';
+import {
+  DataPipelineControllerImpl,
+  MetadataStore,
+  Space,
+  SnapshotManager,
+  SigningContext,
+  createMappedFeedWriter
+} from '@dxos/echo-db';
+import { FeedStore } from '@dxos/feed-store';
+import { Keyring } from '@dxos/keyring';
 import { PublicKey } from '@dxos/keys';
 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 { ComplexSet } from '@dxos/util';
 
 import { TrustedKeySetAuthVerifier } from '../identity';
+import { NotarizationPlugin } from './notarization-plugin';
 
 const AUTH_TIMEOUT = 30000;
 
@@ -22,21 +34,35 @@ export type DataSpaceParams = {
   metadataStore: MetadataStore;
   snapshotManager: SnapshotManager;
   presence: Presence;
+  keyring: Keyring;
+  feedStore: FeedStore<FeedMessage>;
+  signingContext: SigningContext;
   memberKey: PublicKey;
   snapshotId?: string | undefined;
 };
 
+const CONTROL_PIPELINE_READY_TIMEFRAME = 3000;
 @trackLeaks('open', 'close')
-export class DataSpace implements ISpace {
+export class DataSpace {
   private readonly _ctx = new Context();
   private readonly _dataPipelineController: DataPipelineControllerImpl;
   private readonly _inner: Space;
   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>;
+
   public readonly authVerifier: TrustedKeySetAuthVerifier;
 
   constructor(params: DataSpaceParams) {
     this._inner = params.inner;
     this._presence = params.presence;
+    this._keyring = params.keyring;
+    this._feedStore = params.feedStore;
+    this._metadataStore = params.metadataStore;
+    this._signingContext = params.signingContext;
     this._dataPipelineController = new DataPipelineControllerImpl({
       modelFactory: params.modelFactory,
       metadataStore: params.metadataStore,
@@ -46,32 +72,31 @@ export class DataSpace implements ISpace {
       feedInfoProvider: (feedKey) => this._inner.spaceState.feeds.get(feedKey),
       snapshotId: params.snapshotId
     });
+
     this.authVerifier = new TrustedKeySetAuthVerifier({
       trustedKeysProvider: () => new ComplexSet(PublicKey.hash, Array.from(this._inner.spaceState.members.keys())),
       update: this._inner.stateUpdate,
       authTimeout: AUTH_TIMEOUT
     });
+
+    this._notarizationPluginConsumer = this._inner.spaceState.registerProcessor(new NotarizationPlugin());
   }
 
   get key() {
     return this._inner.key;
   }
 
-  get inner() {
-    return this._inner;
-  }
-
   get isOpen() {
     return this._inner.isOpen;
   }
 
-  get dataPipelineController(): DataPipelineControllerImpl {
-    return this._dataPipelineController;
+  // TODO(burdon): Can we mark this for debugging only?
+  get inner() {
+    return this._inner;
   }
 
-  get database(): Database {
-    assert(this._dataPipelineController.database);
-    return this._dataPipelineController.database;
+  get dataPipelineController(): DataPipelineControllerImpl {
+    return this._dataPipelineController;
   }
 
   get stateUpdate() {
@@ -82,15 +107,89 @@ export class DataSpace implements ISpace {
     return this._presence;
   }
 
+  get notarizationPlugin() {
+    return this._notarizationPluginConsumer.processor;
+  }
+
   async open() {
+    await this.notarizationPlugin.open();
+    await this._notarizationPluginConsumer.open();
     await this._inner.open();
-    await this._inner.initDataPipeline(this._dataPipelineController);
   }
 
   async close() {
     await this._ctx.dispose();
+
     await this.authVerifier.close();
+
     await this._inner.close();
+    await this._notarizationPluginConsumer.close();
+    await this.notarizationPlugin.close();
+
     await this._presence.destroy();
   }
+
+  async initializeDataPipeline() {
+    await this._inner.controlPipeline.state.waitUntilReachedTargetTimeframe({
+      timeout: CONTROL_PIPELINE_READY_TIMEFRAME
+    });
+
+    await this._createWritableFeeds();
+    this.notarizationPlugin.setWriter(
+      createMappedFeedWriter<Credential, FeedMessage.Payload>(
+        (credential) => ({
+          credential: { credential }
+        }),
+        this._inner.controlPipeline.writer
+      )
+    );
+
+    await this._inner.initDataPipeline(this._dataPipelineController);
+  }
+
+  @timed(10_000)
+  private async _createWritableFeeds() {
+    const credentials: Credential[] = [];
+    if (!this.inner.controlFeedKey) {
+      const controlFeed = await this._feedStore.openFeed(await this._keyring.createKey(), { writable: true });
+      this.inner.setControlFeed(controlFeed);
+
+      credentials.push(
+        await this._signingContext.credentialSigner.createCredential({
+          subject: controlFeed.key,
+          assertion: {
+            '@type': 'dxos.halo.credentials.AdmittedFeed',
+            spaceKey: this.key,
+            deviceKey: this._signingContext.deviceKey,
+            identityKey: this._signingContext.identityKey,
+            designation: AdmittedFeed.Designation.CONTROL
+          }
+        })
+      );
+    }
+    if (!this.inner.dataFeedKey) {
+      const dataFeed = await this._feedStore.openFeed(await this._keyring.createKey(), { writable: true });
+      this.inner.setDataFeed(dataFeed);
+
+      credentials.push(
+        await this._signingContext.credentialSigner.createCredential({
+          subject: dataFeed.key,
+          assertion: {
+            '@type': 'dxos.halo.credentials.AdmittedFeed',
+            spaceKey: this.key,
+            deviceKey: this._signingContext.deviceKey,
+            identityKey: this._signingContext.identityKey,
+            designation: AdmittedFeed.Designation.DATA
+          }
+        })
+      );
+    }
+
+    if (credentials.length > 0) {
+      await this.notarizationPlugin.notarize(credentials);
+    }
+
+    // Set this after credentials are notarized so that on failure we will retry.
+    await this._metadataStore.setWritableFeedKeys(this.key, this.inner.controlFeedKey!, this.inner.dataFeedKey!);
+  }
 }

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

@@ -0,0 +1,81 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { expect } from 'chai';
+
+import { Context } from '@dxos/context';
+import { CredentialGenerator } from '@dxos/credentials';
+import { MockFeedWriter } from '@dxos/feed-store/testing';
+import { Keyring } from '@dxos/keyring';
+import { log } from '@dxos/log';
+import { AdmittedFeed, Credential } from '@dxos/protocols/proto/dxos/halo/credentials';
+import { TestBuilder, TestConnection, TestPeer } from '@dxos/teleport/testing';
+import { afterTest, describe, test } from '@dxos/test';
+
+import { NotarizationPlugin } from './notarization-plugin';
+
+class TestAgent extends TestPeer {
+  private readonly _ctx = new Context();
+
+  feed = new MockFeedWriter<Credential>();
+  notarizationPlugin = new NotarizationPlugin();
+
+  constructor() {
+    super();
+    this.feed.written.on(this._ctx, async ([credential]) => {
+      log('written to feed', { credential });
+      await this.notarizationPlugin.process(credential);
+    });
+  }
+
+  enableWriting() {
+    this.notarizationPlugin.setWriter(this.feed);
+  }
+
+  protected override onOpen(connection: TestConnection): Promise<void> {
+    log('onOpen');
+    connection.teleport.addExtension('dxos.mesh.teleport.notarization', this.notarizationPlugin.createExtension());
+    return super.onOpen(connection);
+  }
+
+  override async destroy(): Promise<void> {
+    await this._ctx.dispose();
+    await super.destroy();
+    await this.notarizationPlugin.close();
+  }
+}
+
+describe('NotarizationPlugin', () => {
+  test('notarize single credential', async () => {
+    const testBuilder = new TestBuilder();
+    afterTest(() => testBuilder.destroy());
+
+    // peer0 is there to test retries.
+    const [_peer0, peer1, peer2] = await testBuilder.createPeers({ factory: () => new TestAgent() });
+    peer1.enableWriting();
+
+    peer1.feed.written.on(async ([credential]) => {
+      log('mock replication', { credential });
+      await peer2.feed.write(credential);
+    });
+
+    await testBuilder.connect(_peer0, peer2);
+
+    const keyring = new Keyring();
+    const generator = new CredentialGenerator(keyring, await keyring.createKey(), await keyring.createKey());
+    const credential = await generator.createFeedAdmission(
+      await keyring.createKey(),
+      await keyring.createKey(),
+      AdmittedFeed.Designation.CONTROL
+    );
+
+    const notarized = peer2.notarizationPlugin.notarize([credential]);
+
+    await testBuilder.connect(peer1, peer2);
+    await notarized;
+
+    expect(peer1.feed.messages.map((c) => c.id)).to.deep.eq([credential.id]);
+    expect(peer2.feed.messages.map((c) => c.id)).to.deep.eq([credential.id]);
+  });
+});

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

@@ -0,0 +1,211 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import assert from 'node:assert';
+
+import { DeferredTask, Event, scheduleTask, TimeoutError, Trigger } from '@dxos/async';
+import { Context } from '@dxos/context';
+import { CredentialProcessor } from '@dxos/credentials';
+import { FeedWriter } from '@dxos/feed-store';
+import { PublicKey } from '@dxos/keys';
+import { log } from '@dxos/log';
+import { schema } from '@dxos/protocols';
+import { Credential } from '@dxos/protocols/proto/dxos/halo/credentials';
+import { NotarizationService, NotarizeRequest } from '@dxos/protocols/proto/dxos/mesh/teleport/notarization';
+import { ExtensionContext, RpcExtension } from '@dxos/teleport';
+import { ComplexMap, ComplexSet, entry } from '@dxos/util';
+
+const RETRY_TIMEOUT = 1000;
+const NOTARIZE_TIMEOUT = 10_000;
+
+/**
+ * See NotarizationService proto.
+ */
+export class NotarizationPlugin implements CredentialProcessor {
+  private readonly _ctx = new Context();
+  private readonly _extensionOpened = new Event();
+
+  private _writer: FeedWriter<Credential> | undefined;
+  private readonly _extensions = new Set<NotarizationTeleportExtension>();
+  private readonly _processedCredentials = new ComplexSet<PublicKey>(PublicKey.hash);
+  private readonly _processCredentialsTriggers = new ComplexMap<PublicKey, Trigger>(PublicKey.hash);
+
+  async open() {}
+
+  async close() {
+    await this._ctx.dispose();
+  }
+
+  /**
+   * Request credentials to be notarized.
+   */
+  async notarize(credentials: Credential[]) {
+    log('notarize', { credentials });
+    assert(
+      credentials.every((credential) => credential.id),
+      'Credentials must have an id'
+    );
+
+    const errors = new Trigger();
+    const ctx = this._ctx.derive({
+      onError: (err) => {
+        log.warn('Notarization error', { err });
+        void ctx.dispose();
+        errors.throw(err);
+      }
+    });
+    scheduleTask(
+      ctx,
+      () => {
+        log.warn('Notarization timeout');
+        void ctx.dispose();
+        errors.throw(new TimeoutError(NOTARIZE_TIMEOUT, 'Notarization timed out'));
+      },
+      NOTARIZE_TIMEOUT
+    );
+
+    const allNotarized = Promise.all(credentials.map((credential) => this._waitUntilProcessed(credential.id!)));
+
+    const peersTried = new Set<NotarizationTeleportExtension>();
+
+    // Repeatable task that tries to notarize credentials with one of the available peers.
+    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 });
+          peersTried.clear();
+          scheduleTask(ctx, () => notarizeTask.schedule(), RETRY_TIMEOUT); // retry with all peers again
+          return;
+        }
+
+        peersTried.add(peer);
+        log('try notarizing', { peer: peer.localPeerId, credentialId: credentials.map((credential) => credential.id) });
+        await peer.rpc.NotarizationService.notarize({
+          credentials: credentials.filter((credential) => !this._processedCredentials.has(credential.id!))
+        });
+        log('success');
+      } catch (err) {
+        log.warn('error notarizing (recoverable)', err);
+        notarizeTask.schedule(); // retry immediately with next peer
+      }
+    });
+
+    notarizeTask.schedule();
+    this._extensionOpened.on(ctx, () => notarizeTask.schedule());
+
+    try {
+      // TODO(dmaretskyi): Abort (context) & timeout.
+      await Promise.race([allNotarized, errors.wait()]);
+      log('done');
+    } finally {
+      await ctx.dispose();
+    }
+  }
+
+  /**
+   * Called with credentials arriving from the control pipeline.
+   */
+  async process(credential: Credential) {
+    if (!credential.id) {
+      return;
+    }
+    this._processCredentialsTriggers.get(credential.id)?.wake();
+    this._processedCredentials.add(credential.id);
+    this._processCredentialsTriggers.delete(credential.id);
+  }
+
+  setWriter(writer: FeedWriter<Credential>) {
+    assert(!this._writer, 'Writer already set.');
+    this._writer = writer;
+  }
+
+  private async _waitUntilProcessed(id: PublicKey) {
+    if (this._processedCredentials.has(id)) {
+      return;
+    }
+    await entry(this._processCredentialsTriggers, id).orInsert(new Trigger()).value.wait();
+  }
+
+  /**
+   * Requests from other peers to notarize credentials.
+   */
+  private async _onNotarize(request: NotarizeRequest) {
+    if (!this._writer) {
+      throw new Error('Writer not set');
+    }
+    for (const credential of request.credentials ?? []) {
+      assert(credential.id, 'Credential must have an id');
+      if (this._processedCredentials.has(credential.id)) {
+        continue;
+      }
+      await this._writer.write(credential);
+    }
+  }
+
+  createExtension() {
+    const extension = new NotarizationTeleportExtension({
+      onOpen: async () => {
+        log('extension opened', { peer: extension.localPeerId });
+        this._extensions.add(extension);
+        this._extensionOpened.emit();
+      },
+      onClose: async () => {
+        log('extension closed', { peer: extension.localPeerId });
+        this._extensions.delete(extension);
+      },
+      onNotarize: this._onNotarize.bind(this)
+    });
+    return extension;
+  }
+}
+
+export type NotarizationTeleportExtensionParams = {
+  onOpen: () => Promise<void>;
+  onClose: () => Promise<void>;
+  onNotarize: (request: NotarizeRequest) => Promise<void>;
+};
+
+export class NotarizationTeleportExtension extends RpcExtension<Services, Services> {
+  constructor(private readonly _params: NotarizationTeleportExtensionParams) {
+    super({
+      requested: {
+        NotarizationService: schema.getService('dxos.mesh.teleport.notarization.NotarizationService')
+      },
+      exposed: {
+        NotarizationService: schema.getService('dxos.mesh.teleport.notarization.NotarizationService')
+      }
+    });
+  }
+
+  protected async getHandlers(): Promise<Services> {
+    return {
+      NotarizationService: {
+        notarize: async (request) => {
+          await this._params.onNotarize(request);
+        }
+      }
+    };
+  }
+
+  override async onOpen(ctx: ExtensionContext) {
+    await super.onOpen(ctx);
+    await this._params.onOpen();
+  }
+
+  override async onClose(err?: Error | undefined) {
+    await this._params.onClose();
+    await super.onClose(err);
+  }
+}
+
+type Services = {
+  NotarizationService: NotarizationService;
+};

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

@@ -11,7 +11,8 @@ import {
   QueryMembersRequest,
   QueryMembersResponse,
   Space,
-  SpacesService
+  SpacesService,
+  WriteCredentialsRequest
 } from '@dxos/protocols/proto/dxos/client/services';
 import { Credential } from '@dxos/protocols/proto/dxos/halo/credentials';
 
@@ -46,4 +47,11 @@ export class SpacesServiceImpl implements SpacesService {
       scheduleTask(ctx, () => processor.open());
     });
   }
+
+  async writeCredentials({ spaceKey, credentials }: WriteCredentialsRequest) {
+    const space = this._spaceManager.spaces.get(spaceKey) ?? raise(new SpaceNotFoundError(spaceKey));
+    for (const credential of credentials ?? []) {
+      await space.controlPipeline.writer.write({ credential: { credential } });
+    }
+  }
 }

package/src/packlets/testing/credential-utils.ts

@@ -0,0 +1,28 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { createCredential } from '@dxos/credentials';
+import { Signer } from '@dxos/crypto';
+import { PublicKey } from '@dxos/keys';
+import { Credential } from '@dxos/protocols/proto/dxos/halo/credentials';
+
+export const createMockCredential = async ({
+  signer,
+  issuer
+}: {
+  signer: Signer;
+  issuer: PublicKey;
+}): Promise<Credential> =>
+  createCredential({
+    signer,
+    issuer,
+    subject: new PublicKey(Buffer.from('test')),
+    assertion: {
+      '@type': 'example.testing.rpc.MessageWithAny',
+      payload: {
+        '@type': 'google.protobuf.Any',
+        value: Buffer.from('test')
+      }
+    }
+  });

package/src/packlets/testing/index.ts

@@ -2,4 +2,6 @@
 // Copyright 2022 DXOS.org
 //
 
+export * from './credential-utils';
 export * from './test-builder';
+export * from './invitation-utils';

package/src/packlets/testing/invitation-utils.ts

@@ -0,0 +1,44 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import assert from 'node:assert';
+
+import { Trigger } from '@dxos/async';
+import { raise } from '@dxos/debug';
+import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
+
+import { InvitationsHandler } from '../invitations';
+
+export const performInvitation = async <T>(host: InvitationsHandler<T>, guest: InvitationsHandler<T>, context: T) => {
+  const done1 = new Trigger<Invitation>(); // peer 1 connected.
+  const done2 = new Trigger<Invitation>(); // peer 2 connected.
+  const observable1 = await host.createInvitation(context, { type: Invitation.Type.INTERACTIVE_TESTING });
+  observable1.subscribe({
+    onConnecting: async (invitation1: Invitation) => {
+      const observable2 = await guest.acceptInvitation(invitation1, { type: Invitation.Type.INTERACTIVE_TESTING });
+      observable2.subscribe({
+        onConnecting: async (invitation2: Invitation) => {
+          assert(invitation1.swarmKey!.equals(invitation2.swarmKey!));
+        },
+        onConnected: async (invitation2: Invitation) => {},
+        onSuccess: (invitation) => {
+          done2.wake(invitation);
+        },
+        onCancelled: () => raise(new Error()),
+        onTimeout: (err: Error) => raise(err),
+        onError: (err: Error) => raise(err)
+      });
+    },
+    onConnected: async (invitation1: Invitation) => {},
+    onCancelled: () => raise(new Error('cancelled')),
+    onSuccess: (invitation) => {
+      done1.wake(invitation);
+    },
+    onTimeout: (err: Error) => raise(err),
+    onError: (err: Error) => raise(err)
+  });
+
+  await done1.wait();
+  await done2.wait();
+};

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

@@ -2,11 +2,17 @@
 // Copyright 2022 DXOS.org
 //
 
-import { expect } from 'chai';
-
 import { Config } from '@dxos/config';
 import { createCredentialSignerWithChain, CredentialGenerator } from '@dxos/credentials';
-import { ISpace, MetadataStore, SigningContext, SnapshotStore, SpaceManager, valueEncoding } from '@dxos/echo-db';
+import {
+  DataPipelineControllerImpl,
+  MetadataStore,
+  SigningContext,
+  SnapshotStore,
+  SpaceManager,
+  valueEncoding
+} from '@dxos/echo-db';
+import { testLocalDatabase } from '@dxos/echo-db/testing';
 import { FeedFactory, FeedStore } from '@dxos/feed-store';
 import { Keyring } from '@dxos/keyring';
 import { MemorySignalManager, MemorySignalManagerContext } from '@dxos/messaging';
@@ -66,20 +72,9 @@ export const createIdentity = async (peer: ServiceContext) => {
 
 // TODO(burdon): Remove @dxos/client-testing.
 // TODO(burdon): Create builder and make configurable.
-export const syncItems = async (space1: ISpace, space2: ISpace) => {
-  {
-    // Check item replicated from 1 => 2.
-    const item1 = await space1.database!.createItem({ type: 'type-1' });
-    const item2 = await space2.database!.waitForItem({ type: 'type-1' });
-    expect(item1.id).to.eq(item2.id);
-  }
-
-  {
-    // Check item replicated from 2 => 1.
-    const item1 = await space2.database!.createItem({ type: 'type-2' });
-    const item2 = await space1.database!.waitForItem({ type: 'type-2' });
-    expect(item1.id).to.eq(item2.id);
-  }
+export const syncItems = async (db1: DataPipelineControllerImpl, db2: DataPipelineControllerImpl) => {
+  await testLocalDatabase(db1, db2);
+  await testLocalDatabase(db2, db1);
 };
 
 export class TestBuilder {
@@ -161,6 +156,7 @@ export const createSigningContext = async (keyring: Keyring): Promise<SigningCon
         credential: await new CredentialGenerator(keyring, identityKey, deviceKey).createDeviceAuthorization(deviceKey)
       },
       deviceKey
-    )
+    ),
+    recordCredential: async () => {} // No-op.
   };
 };