@dxos/client-services 0.6.13-main.ed424a1 → 0.6.13

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

@@ -2,18 +2,14 @@
 // Copyright 2023 DXOS.org
 //
 
-import { DeferredTask, Event, scheduleTask, sleep, TimeoutError, Trigger, scheduleMicroTask } from '@dxos/async';
-import { type Context, rejectOnDispose, Resource } from '@dxos/context';
-import { type CredentialProcessor, verifyCredential } from '@dxos/credentials';
-import { type EdgeHttpClient } from '@dxos/edge-client';
+import { DeferredTask, Event, scheduleTask, sleep, TimeoutError, Trigger } from '@dxos/async';
+import { Context, rejectOnDispose } from '@dxos/context';
+import { type CredentialProcessor } from '@dxos/credentials';
 import { type FeedWriter } from '@dxos/feed-store';
 import { invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
-import { type SpaceId } from '@dxos/keys';
-import { logInfo, log } from '@dxos/log';
-import { EdgeCallFailedError } from '@dxos/protocols';
+import { log } from '@dxos/log';
 import { schema } from '@dxos/protocols/proto';
-import { type Runtime } from '@dxos/protocols/proto/dxos/config';
 import { type Credential } from '@dxos/protocols/proto/dxos/halo/credentials';
 import { type NotarizationService, type NotarizeRequest } from '@dxos/protocols/proto/dxos/mesh/teleport/notarization';
 import { type ExtensionContext, RpcExtension } from '@dxos/teleport';
@@ -25,21 +21,8 @@ const DEFAULT_SUCCESS_DELAY = 1_000;
 
 const DEFAULT_NOTARIZE_TIMEOUT = 10_000;
 
-const DEFAULT_ACTIVE_EDGE_POLLING_INTERVAL = 3_000;
-
-const MAX_EDGE_RETRIES = 2;
-
 const WRITER_NOT_SET_ERROR_CODE = 'WRITER_NOT_SET';
 
-const credentialCodec = schema.getCodecForType('dxos.halo.credentials.Credential');
-
-export type NotarizationPluginParams = {
-  spaceId: SpaceId;
-  edgeClient?: EdgeHttpClient;
-  edgeFeatures?: Runtime.Client.EdgeFeatures;
-  activeEdgePollingInterval?: number;
-};
-
 export type NotarizeParams = {
   /**
    * For cancellation.
@@ -70,17 +53,13 @@ export type NotarizeParams = {
    * @default {@link DEFAULT_SUCCESS_DELAY}
    */
   successDelay?: number;
-
-  /**
-   * A random amount of time before making or retrying an edge request to help prevent large bursts of requests.
-   */
-  edgeRetryJitter?: number;
 };
 
 /**
  * See NotarizationService proto.
  */
-export class NotarizationPlugin extends Resource implements CredentialProcessor {
+export class NotarizationPlugin implements CredentialProcessor {
+  private readonly _ctx = new Context();
   private readonly _extensionOpened = new Event();
 
   private _writer: FeedWriter<Credential> | undefined;
@@ -88,54 +67,13 @@ export class NotarizationPlugin extends Resource implements CredentialProcessor
   private readonly _processedCredentials = new ComplexSet<PublicKey>(PublicKey.hash);
   private readonly _processCredentialsTriggers = new ComplexMap<PublicKey, Trigger>(PublicKey.hash);
 
-  private _activeEdgePollingIntervalHandle: any | undefined = undefined;
-  private readonly _activeEdgePollingInterval: number;
-
-  @logInfo
-  private readonly _spaceId: SpaceId;
-
-  private readonly _edgeClient: EdgeHttpClient | undefined;
-
-  constructor(params: NotarizationPluginParams) {
-    super();
-    this._spaceId = params.spaceId;
-    this._activeEdgePollingInterval = params.activeEdgePollingInterval ?? DEFAULT_ACTIVE_EDGE_POLLING_INTERVAL;
-    if (params.edgeClient && params.edgeFeatures?.feedReplicator) {
-      this._edgeClient = params.edgeClient;
-    }
-  }
-
-  setActiveEdgePollingEnabled(enabled: boolean) {
-    invariant(this.isOpen);
-    const client = this._edgeClient;
-    invariant(client);
-    if (enabled && !this._activeEdgePollingIntervalHandle) {
-      this._activeEdgePollingIntervalHandle = setInterval(() => {
-        if (this._writer) {
-          this._notarizePendingEdgeCredentials(client, this._writer);
-        }
-      }, this._activeEdgePollingInterval);
-    } else if (!enabled && this._activeEdgePollingIntervalHandle) {
-      clearInterval(this._activeEdgePollingIntervalHandle);
-      this._activeEdgePollingIntervalHandle = undefined;
-    }
-  }
-
   get hasWriter() {
     return !!this._writer;
   }
 
-  protected override async _open() {
-    if (this._edgeClient && this._writer) {
-      this._notarizePendingEdgeCredentials(this._edgeClient, this._writer);
-    }
-  }
+  async open() {}
 
-  protected override async _close() {
-    if (this._activeEdgePollingIntervalHandle) {
-      clearInterval(this._activeEdgePollingIntervalHandle);
-      this._activeEdgePollingIntervalHandle = undefined;
-    }
+  async close() {
     await this._ctx.dispose();
   }
 
@@ -148,7 +86,6 @@ export class NotarizationPlugin extends Resource implements CredentialProcessor
     timeout = DEFAULT_NOTARIZE_TIMEOUT,
     retryTimeout = DEFAULT_RETRY_TIMEOUT,
     successDelay = DEFAULT_SUCCESS_DELAY,
-    edgeRetryJitter,
   }: NotarizeParams) {
     log('notarize', { credentials });
     invariant(
@@ -166,35 +103,24 @@ export class NotarizationPlugin extends Resource implements CredentialProcessor
     });
     opCtx?.onDispose(() => ctx.dispose());
 
+    // Timeout/
     if (timeout !== 0) {
-      this._scheduleTimeout(ctx, errors, timeout);
+      scheduleTask(
+        ctx,
+        () => {
+          log.warn('Notarization timeout', {
+            timeout,
+            peers: Array.from(this._extensions).map((extension) => extension.remotePeerId),
+          });
+          void ctx.dispose();
+          errors.throw(new TimeoutError(timeout, 'Notarization timed out'));
+        },
+        timeout,
+      );
     }
 
     const allNotarized = Promise.all(credentials.map((credential) => this._waitUntilProcessed(credential.id!)));
 
-    this._tryNotarizeCredentialsWithPeers(ctx, credentials, { retryTimeout, successDelay });
-
-    if (this._edgeClient) {
-      this._tryNotarizeCredentialsWithEdge(ctx, this._edgeClient, credentials, {
-        retryTimeout,
-        successDelay,
-        jitter: edgeRetryJitter,
-      });
-    }
-
-    try {
-      await Promise.race([rejectOnDispose(ctx), allNotarized, errors.wait()]);
-      log('done');
-    } finally {
-      await ctx.dispose();
-    }
-  }
-
-  private _tryNotarizeCredentialsWithPeers(
-    ctx: Context,
-    credentials: Credential[],
-    { retryTimeout, successDelay }: NotarizationTimeouts,
-  ) {
     const peersTried = new Set<NotarizationTeleportExtension>();
 
     // Repeatable task that tries to notarize credentials with one of the available peers.
@@ -219,7 +145,6 @@ export class NotarizationPlugin extends Resource implements CredentialProcessor
           credentials: credentials.filter((credential) => !this._processedCredentials.has(credential.id!)),
         });
         log('success');
-
         await sleep(successDelay); // wait before trying with a new peer
       } catch (err: any) {
         if (!ctx.disposed && !err.message.includes(WRITER_NOT_SET_ERROR_CODE)) {
@@ -231,31 +156,13 @@ export class NotarizationPlugin extends Resource implements CredentialProcessor
 
     notarizeTask.schedule();
     this._extensionOpened.on(ctx, () => notarizeTask.schedule());
-  }
 
-  private _tryNotarizeCredentialsWithEdge(
-    ctx: Context,
-    client: EdgeHttpClient,
-    credentials: Credential[],
-    timeouts: NotarizationTimeouts & { jitter?: number },
-  ) {
-    const encodedCredentials = credentials.map((credential) => {
-      const binary = credentialCodec.encode(credential);
-      return Buffer.from(binary).toString('base64');
-    });
-    scheduleTask(ctx, async () => {
-      try {
-        await client.notarizeCredentials(
-          this._spaceId,
-          { credentials: encodedCredentials },
-          { retry: { count: MAX_EDGE_RETRIES, timeout: timeouts.retryTimeout, jitter: timeouts.jitter } },
-        );
-
-        log('edge notarization success');
-      } catch (error: any) {
-        handleEdgeError(error);
-      }
-    });
+    try {
+      await Promise.race([rejectOnDispose(ctx), allNotarized, errors.wait()]);
+      log('done');
+    } finally {
+      await ctx.dispose();
+    }
   }
 
   /**
@@ -273,44 +180,6 @@ export class NotarizationPlugin extends Resource implements CredentialProcessor
   setWriter(writer: FeedWriter<Credential>) {
     invariant(!this._writer, 'Writer already set.');
     this._writer = writer;
-    if (this._edgeClient) {
-      this._notarizePendingEdgeCredentials(this._edgeClient, writer);
-    }
-  }
-
-  /**
-   * The method is used only for adding agent feeds to spaces.
-   * When an agent is created we can admit them into all the existing spaces. In case the operation fails
-   * this method will fix it on the next space open.
-   * Given how rarely this happens there's no need to poll the endpoint.
-   */
-  private _notarizePendingEdgeCredentials(client: EdgeHttpClient, writer: FeedWriter<Credential>) {
-    scheduleMicroTask(this._ctx, async () => {
-      try {
-        const response = await client.getCredentialsForNotarization(this._spaceId, {
-          retry: { count: MAX_EDGE_RETRIES },
-        });
-
-        const credentials = response.awaitingNotarization.credentials;
-        if (!credentials.length) {
-          log('edge did not return credentials for notarization');
-          return;
-        }
-
-        log('got edge credentials for notarization', { count: credentials.length });
-
-        const decodedCredentials = credentials.map((credential) => {
-          const binary = Buffer.from(credential, 'base64');
-          return credentialCodec.decode(binary);
-        });
-
-        await this._notarizeCredentials(writer, decodedCredentials);
-
-        log.info('notarized edge credentials', { count: decodedCredentials.length });
-      } catch (error: any) {
-        handleEdgeError(error);
-      }
-    });
   }
 
   private async _waitUntilProcessed(id: PublicKey) {
@@ -327,20 +196,12 @@ export class NotarizationPlugin extends Resource implements CredentialProcessor
     if (!this._writer) {
       throw new Error(WRITER_NOT_SET_ERROR_CODE);
     }
-    await this._notarizeCredentials(this._writer, request.credentials ?? []);
-  }
-
-  private async _notarizeCredentials(writer: FeedWriter<Credential>, credentials: Credential[]) {
-    for (const credential of credentials) {
+    for (const credential of request.credentials ?? []) {
       invariant(credential.id, 'Credential must have an id');
       if (this._processedCredentials.has(credential.id)) {
         continue;
       }
-      const verificationResult = await verifyCredential(credential);
-      if (verificationResult.kind === 'fail') {
-        throw new Error(`Credential verification failed: ${verificationResult.errors.join('\n')}.`);
-      }
-      await writer.write(credential);
+      await this._writer.write(credential);
     }
   }
 
@@ -359,31 +220,8 @@ export class NotarizationPlugin extends Resource implements CredentialProcessor
     });
     return extension;
   }
-
-  private _scheduleTimeout(ctx: Context, errors: Trigger, timeout: number) {
-    scheduleTask(
-      ctx,
-      () => {
-        log.warn('Notarization timeout', {
-          timeout,
-          peers: Array.from(this._extensions).map((extension) => extension.remotePeerId),
-        });
-        void ctx.dispose();
-        errors.throw(new TimeoutError(timeout, 'Notarization timed out'));
-      },
-      timeout,
-    );
-  }
 }
 
-const handleEdgeError = (error: any) => {
-  if (!(error instanceof EdgeCallFailedError) || error.errorData) {
-    log.catch(error);
-  } else {
-    log.info('Edge notarization failure', { reason: error.reason });
-  }
-};
-
 export type NotarizationTeleportExtensionParams = {
   onOpen: () => Promise<void>;
   onClose: () => Promise<void>;
@@ -423,11 +261,6 @@ export class NotarizationTeleportExtension extends RpcExtension<Services, Servic
   }
 }
 
-type NotarizationTimeouts = {
-  retryTimeout: number;
-  successDelay: number;
-};
-
 type Services = {
   NotarizationService: NotarizationService;
 };

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

@@ -2,17 +2,21 @@
 // Copyright 2023 DXOS.org
 //
 
-import { afterEach, onTestFinished, beforeEach, describe, expect, test } from 'vitest';
+import chai, { expect } from 'chai';
+import chaiAsPromised from 'chai-as-promised';
 
 import { Trigger } from '@dxos/async';
 import { Context } from '@dxos/context';
 import { PublicKey } from '@dxos/keys';
 import { type Space, type SpacesService } from '@dxos/protocols/proto/dxos/client/services';
+import { afterEach, afterTest, beforeEach, describe, test } from '@dxos/test';
 
 import { SpacesServiceImpl } from './spaces-service';
 import { type ServiceContext } from '../services';
 import { createServiceContext } from '../testing';
 
+chai.use(chaiAsPromised);
+
 describe('SpacesService', () => {
   let serviceContext: ServiceContext;
   let spacesService: SpacesService;
@@ -32,7 +36,7 @@ describe('SpacesService', () => {
 
   describe('createSpace', () => {
     test('fails if no identity is available', async () => {
-      await expect(spacesService.createSpace()).rejects.toBeInstanceOf(Error);
+      await expect(spacesService.createSpace()).to.be.rejectedWith();
     });
 
     test('creates a new space', async () => {
@@ -52,7 +56,7 @@ describe('SpacesService', () => {
       query.subscribe(({ spaces }) => {
         result.wake(spaces);
       });
-      onTestFinished(() => query.close());
+      afterTest(() => query.close());
       expect(await result.wait()).to.be.length(0);
     });
 
@@ -69,7 +73,7 @@ describe('SpacesService', () => {
       query.subscribe(({ spaces }) => {
         result.wake(spaces);
       });
-      onTestFinished(() => query.close());
+      afterTest(() => query.close());
 
       const spaces = await result.wait();
       expect(spaces).to.be.length(3);
@@ -83,7 +87,7 @@ describe('SpacesService', () => {
       query.subscribe(({ spaces }) => {
         result.wake(spaces);
       });
-      onTestFinished(() => query.close());
+      afterTest(() => query.close());
       expect(await result.wait()).to.be.length(0);
 
       result.reset();

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

@@ -60,7 +60,7 @@ export class SpacesServiceImpl implements SpacesService {
     return this._serializeSpace(space);
   }
 
-  async updateSpace({ spaceKey, state, edgeReplication }: UpdateSpaceRequest) {
+  async updateSpace({ spaceKey, state }: UpdateSpaceRequest) {
     const dataSpaceManager = await this._getDataSpaceManager();
     const space = dataSpaceManager.spaces.get(spaceKey) ?? raise(new SpaceNotFoundError(spaceKey));
 
@@ -77,10 +77,6 @@ export class SpacesServiceImpl implements SpacesService {
           throw new ApiError('Invalid space state');
       }
     }
-
-    if (edgeReplication !== undefined) {
-      await dataSpaceManager.setSpaceEdgeReplicationSetting(spaceKey, edgeReplication);
-    }
   }
 
   async updateMemberRole(request: UpdateMemberRoleRequest): Promise<void> {
@@ -312,7 +308,6 @@ export class SpacesServiceImpl implements SpacesService {
       creator: space.inner.spaceState.creator?.key,
       cache: space.cache,
       metrics: space.metrics,
-      edgeReplication: space.getEdgeReplicationSetting(),
     };
   }
 

package/src/packlets/storage/storage.ts

@@ -14,6 +14,7 @@ import { getRootPath } from './util';
 // TODO(burdon): Factor out.
 export const createStorageObjects = (config: Runtime.Client.Storage) => {
   const { persistent = false, keyStore, dataStore } = config ?? {};
+
   if (persistent && dataStore === StorageDriver.RAM) {
     throw new InvalidConfigError('RAM storage cannot be used in persistent mode.');
   }

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

@@ -2,11 +2,12 @@
 // Copyright 2023 DXOS.org
 //
 
-import { beforeEach, describe, expect, test } from 'vitest';
+import { expect } from 'chai';
 
 import { Event, Trigger } from '@dxos/async';
 import { Config } from '@dxos/config';
 import { type SystemService, SystemStatus, type QueryStatusResponse } from '@dxos/protocols/proto/dxos/client/services';
+import { beforeEach, describe, test } from '@dxos/test';
 
 import { SystemServiceImpl } from './system-service';
 

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

@@ -6,7 +6,8 @@ import { type Config } from '@dxos/config';
 import { Context } from '@dxos/context';
 import { createCredentialSignerWithChain, CredentialGenerator } from '@dxos/credentials';
 import { failUndefined } from '@dxos/debug';
-import { EchoHost, MetadataStore, SpaceManager, valueEncoding, MeshEchoReplicator } from '@dxos/echo-pipeline';
+import { EchoHost } from '@dxos/echo-db';
+import { MetadataStore, SpaceManager, valueEncoding, MeshEchoReplicator } from '@dxos/echo-pipeline';
 import { FeedFactory, FeedStore } from '@dxos/feed-store';
 import { Keyring } from '@dxos/keyring';
 import { type LevelDB } from '@dxos/kv-store';
@@ -53,8 +54,8 @@ export const createServiceContext = async ({
   const level = createTestLevel();
   await level.open();
 
-  return new ServiceContext(storage, level, networkManager, signalManager, undefined, undefined, {
-    invitationConnectionDefaultParams: { teleport: { controlHeartbeatInterval: 200 } },
+  return new ServiceContext(storage, level, networkManager, signalManager, undefined, {
+    invitationConnectionDefaultParams: { controlHeartbeatInterval: 200 },
     ...runtimeParams,
   });
 };
@@ -218,10 +219,6 @@ export class TestPeer {
 
   async createIdentity() {
     this._props.signingContext ??= await createSigningContext(this.keyring);
-    this.networkManager.setPeerInfo({
-      identityKey: this._props.signingContext.identityKey.toHex(),
-      peerKey: this._props.signingContext.deviceKey.toHex(),
-    });
   }
 
   async destroy() {

package/src/packlets/worker/worker-runtime.ts

@@ -14,7 +14,7 @@ import {
   WebsocketSignalManager,
   setIdentityTags,
 } from '@dxos/messaging';
-import { RtcTransportProxyFactory } from '@dxos/network-manager';
+import { SimplePeerTransportProxyFactory } from '@dxos/network-manager';
 import { type RpcPort } from '@dxos/rpc';
 import { type MaybePromise } from '@dxos/util';
 
@@ -46,7 +46,7 @@ export class WorkerRuntime {
   private readonly _acquireLock: () => Promise<void>;
   private readonly _releaseLock: () => void;
   private readonly _onStop?: () => Promise<void>;
-  private readonly _transportFactory = new RtcTransportProxyFactory();
+  private readonly _transportFactory = new SimplePeerTransportProxyFactory();
   private readonly _ready = new Trigger<Error | undefined>();
   private readonly _sessions = new Set<WorkerSession>();
   private readonly _clientServices!: ClientServicesHost;

package/src/version.ts

@@ -1 +1,5 @@
-export const DXOS_VERSION = "0.6.13-main.ed424a1";
+//
+// Copyright 2023 DXOS.org
+//
+
+export const DXOS_VERSION = '0.6.13'; // {x-release-please-version}