@dxos/client-services 0.1.23 → 0.1.24

package/src/packlets/vault/iframe-host-runtime.ts

@@ -0,0 +1,112 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { Trigger } from '@dxos/async';
+import { Config } from '@dxos/config';
+import { log, logInfo } from '@dxos/log';
+import { MemorySignalManager, MemorySignalManagerContext, WebsocketSignalManager } from '@dxos/messaging';
+import { createWebRTCTransportFactory, NetworkManager } from '@dxos/network-manager';
+import { createProtoRpcPeer, ProtoRpcPeer, RpcPort } from '@dxos/rpc';
+import { MaybePromise } from '@dxos/util';
+
+import { clientServiceBundle, ClientServices, ClientServicesHost } from '../services';
+
+const LOCK_KEY = 'DXOS_RESOURCE_LOCK';
+
+export type IFrameHostRuntimeParams = {
+  configProvider: () => MaybePromise<Config>;
+  appPort: RpcPort;
+};
+
+/**
+ * Runs the client services in the main thread.
+ *
+ * Holds a lock over the client services such that only one instance can run at a time.
+ * This should only be used when SharedWorker is not available.
+ */
+export class IFrameHostRuntime {
+  private readonly _configProvider: () => MaybePromise<Config>;
+  private readonly _transportFactory = createWebRTCTransportFactory();
+  private readonly _ready = new Trigger<Error | undefined>();
+  private readonly _getService: <Service>(
+    find: (services: Partial<ClientServices>) => Service | undefined
+  ) => Promise<Service>;
+
+  private readonly _appPort: RpcPort;
+  private _clientServices!: ClientServicesHost;
+  private _clientRpc!: ProtoRpcPeer<ClientServices>;
+  private _config!: Config;
+
+  @logInfo
+  public origin?: string;
+
+  constructor({ configProvider, appPort }: IFrameHostRuntimeParams) {
+    this._configProvider = configProvider;
+    this._appPort = appPort;
+    this._getService = async (find) => {
+      const error = await this._ready.wait();
+      if (error) {
+        throw error;
+      }
+
+      const service = await find(this._clientServices.services);
+      if (!service) {
+        throw new Error('Service not found');
+      }
+
+      return service;
+    };
+  }
+
+  async start() {
+    log('starting...');
+    try {
+      this._config = await this._configProvider();
+      const signalServer = this._config.get('runtime.services.signal.server');
+      this._clientServices = new ClientServicesHost({
+        lockKey: LOCK_KEY,
+        config: this._config,
+        networkManager: new NetworkManager({
+          log: true,
+          signalManager: signalServer
+            ? new WebsocketSignalManager([signalServer])
+            : new MemorySignalManager(new MemorySignalManagerContext()), // TODO(dmaretskyi): Inject this context.
+          transportFactory: this._transportFactory
+        })
+      });
+
+      this._clientRpc = createProtoRpcPeer({
+        exposed: clientServiceBundle,
+        handlers: {
+          DataService: async () => await this._getService((services) => services.DataService),
+          DevicesService: async () => await this._getService((services) => services.DevicesService),
+          DevtoolsHost: async () => await this._getService((services) => services.DevtoolsHost),
+          HaloInvitationsService: async () => await this._getService((services) => services.HaloInvitationsService),
+          NetworkService: async () => await this._getService((services) => services.NetworkService),
+          ProfileService: async () => await this._getService((services) => services.ProfileService),
+          SpaceInvitationsService: async () => await this._getService((services) => services.SpaceInvitationsService),
+          SpaceService: async () => await this._getService((services) => services.SpaceService),
+          SpacesService: async () => await this._getService((services) => services.SpacesService),
+          SystemService: async () => await this._getService((services) => services.SystemService),
+          TracingService: async () => await this._getService((services) => services.TracingService)
+        },
+        port: this._appPort
+      });
+
+      await Promise.all([this._clientServices.open(), this._clientRpc.open()]);
+      this._ready.wake(undefined);
+      log('started');
+    } catch (err: any) {
+      this._ready.wake(err);
+      log.catch(err);
+    }
+  }
+
+  async stop() {
+    log('stopping...');
+    await this._clientRpc.close();
+    await this._clientServices.close();
+    log('stopped');
+  }
+}

package/src/packlets/vault/{iframe-runtime.ts → iframe-proxy-runtime.ts}

@@ -9,7 +9,7 @@ import { createProtoRpcPeer, ProtoRpcPeer, RpcPort } from '@dxos/rpc';
 import { iframeServiceBundle, WorkerServiceBundle, workerServiceBundle } from './services';
 
 // NOTE: Keep as RpcPorts to avoid dependency on @dxos/rpc-tunnel so we don't depend on browser-specific apis.
-export type IframeRuntimeParams = {
+export type IFrameProxyRuntimeParams = {
   systemPort: RpcPort;
   workerAppPort: RpcPort;
   windowAppPort: RpcPort;
@@ -18,14 +18,14 @@ export type IframeRuntimeParams = {
 /**
  * Manages the client connection to the shared worker.
  */
-export class IFrameRuntime {
+export class IFrameProxyRuntime {
   private readonly _systemPort: RpcPort;
   private readonly _windowAppPort: RpcPort;
   private readonly _workerAppPort: RpcPort;
   private readonly _systemRpc: ProtoRpcPeer<WorkerServiceBundle>;
   private readonly _transportService = new WebRTCTransportService();
 
-  constructor({ systemPort, workerAppPort, windowAppPort }: IframeRuntimeParams) {
+  constructor({ systemPort, workerAppPort, windowAppPort }: IFrameProxyRuntimeParams) {
     this._systemPort = systemPort;
     this._windowAppPort = windowAppPort;
     this._workerAppPort = workerAppPort;

package/src/packlets/vault/index.ts

@@ -2,6 +2,9 @@
 // Copyright 2022 DXOS.org
 //
 
-export * from './iframe-runtime';
+export * from './iframe-host-runtime';
+export * from './iframe-proxy-runtime';
+export * from './services';
+export * from './vault-resource-lock';
 export * from './worker-runtime';
 export * from './worker-session';

package/src/packlets/vault/vault-resource-lock.ts

@@ -0,0 +1,76 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { asyncTimeout, Trigger } from '@dxos/async';
+import { log } from '@dxos/log';
+import { MaybePromise } from '@dxos/util';
+
+enum Message {
+  ACQUIRING = 'acquiring'
+}
+
+export type VaultResourceLockOptions = {
+  lockKey: string;
+  onAcquire?: () => MaybePromise<void>;
+  onRelease?: () => MaybePromise<void>;
+};
+
+export class VaultResourceLock {
+  private readonly _broadcastChannel = new BroadcastChannel('vault-resource-lock');
+  private readonly _lockKey: string;
+  private readonly _onAcquire: VaultResourceLockOptions['onAcquire'];
+  private readonly _onRelease: VaultResourceLockOptions['onRelease'];
+  private _releaseTrigger = new Trigger();
+
+  constructor({ lockKey, onAcquire, onRelease }: VaultResourceLockOptions) {
+    this._lockKey = lockKey;
+    this._onAcquire = onAcquire;
+    this._onRelease = onRelease;
+    this._broadcastChannel.onmessage = this._onMessage.bind(this);
+  }
+
+  async acquire() {
+    this._broadcastChannel.postMessage({
+      message: Message.ACQUIRING
+    });
+
+    try {
+      await asyncTimeout(this._requestLock(), 3_000);
+    } catch {
+      await this._requestLock(true);
+    }
+  }
+
+  async release() {
+    this._releaseTrigger.wake();
+  }
+
+  private _onMessage(event: MessageEvent<any>) {
+    if (event.data.message === Message.ACQUIRING) {
+      this._releaseTrigger.wake();
+    }
+  }
+
+  private async _requestLock(steal = false) {
+    log('requesting lock...', { steal });
+    const acquired = new Trigger();
+
+    void navigator.locks
+      .request(this._lockKey, { steal }, async () => {
+        await this._onAcquire?.();
+        acquired.wake();
+        this._releaseTrigger = new Trigger();
+        await this._releaseTrigger.wait();
+        log('releasing lock...');
+        await this._onRelease?.();
+        log('released lock');
+      })
+      .catch(async () => {
+        await this._onRelease?.();
+      });
+
+    await acquired.wait();
+    log('recieved lock', { steal });
+  }
+}

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

@@ -4,6 +4,7 @@
 
 import { Trigger } from '@dxos/async';
 import { Config } from '@dxos/config';
+import { log } from '@dxos/log';
 import { MemorySignalManager, MemorySignalManagerContext, WebsocketSignalManager } from '@dxos/messaging';
 import { NetworkManager, WebRTCTransportProxyFactory } from '@dxos/network-manager';
 import { RpcPort } from '@dxos/rpc';
@@ -37,6 +38,7 @@ export class WorkerRuntime {
   ) { }
 
   async start() {
+    log('starting...');
     try {
       this._config = await this._configProvider();
       const signalServer = this._config.get('runtime.services.signal.server');
@@ -53,8 +55,10 @@ export class WorkerRuntime {
 
       await this._clientServices.open();
       this._ready.wake(undefined);
+      log('started');
     } catch (err: any) {
       this._ready.wake(err);
+      log.catch(err);
     }
   }
 
@@ -68,12 +72,18 @@ export class WorkerRuntime {
    */
   async createSession({ appPort, systemPort }: CreateSessionParams) {
     const session = new WorkerSession({
-      getServices: async () => {
+      getService: async (find) => {
         const error = await this._ready.wait();
-        if (error !== undefined) {
+        if (error) {
           throw error;
         }
-        return this._clientServices;
+
+        const service = find(this._clientServices.services);
+        if (!service) {
+          throw new Error('Service not found');
+        }
+
+        return service;
       },
       appPort,
       systemPort,

package/src/packlets/vault/worker-session.ts

@@ -10,11 +10,11 @@ import { BridgeService } from '@dxos/protocols/proto/dxos/mesh/bridge';
 import { createProtoRpcPeer, ProtoRpcPeer, RpcPort } from '@dxos/rpc';
 import { Callback } from '@dxos/util';
 
-import { clientServiceBundle, ClientServices, ClientServicesHost } from '../services';
+import { clientServiceBundle, ClientServices } from '../services';
 import { IframeServiceBundle, iframeServiceBundle, workerServiceBundle } from './services';
 
 export type WorkerSessionParams = {
-  getServices: () => Promise<ClientServicesHost>;
+  getService: <Service>(find: (services: Partial<ClientServices>) => Service | undefined) => Promise<Service>;
   systemPort: RpcPort;
   appPort: RpcPort;
   readySignal: Trigger<Error | undefined>;
@@ -30,7 +30,7 @@ export class WorkerSession {
   private readonly _clientRpc: ProtoRpcPeer<ClientServices>;
   private readonly _iframeRpc: ProtoRpcPeer<IframeServiceBundle>;
   private readonly _startTrigger = new Trigger();
-  private readonly _getServices: () => Promise<ClientServicesHost>;
+  private readonly _getService: WorkerSessionParams['getService'];
   private readonly _options: NonNullable<WorkerSessionParams['options']>;
   private _heartbeatTimer?: NodeJS.Timeout;
 
@@ -42,7 +42,7 @@ export class WorkerSession {
   public bridgeService?: BridgeService;
 
   constructor({
-    getServices,
+    getService,
     systemPort,
     appPort,
     options = {
@@ -50,24 +50,24 @@ export class WorkerSession {
     }
   }: WorkerSessionParams) {
     assert(options);
-    assert(getServices);
+    assert(getService);
     this._options = options;
-    this._getServices = getServices;
+    this._getService = getService;
 
     this._clientRpc = createProtoRpcPeer({
       exposed: clientServiceBundle,
       handlers: {
-        HaloInvitationsService: async () => (await this._getServices()).services.HaloInvitationsService,
-        DevicesService: async () => (await this._getServices()).services.DevicesService,
-        SpaceInvitationsService: async () => (await this._getServices()).services.SpaceInvitationsService,
-        SpacesService: async () => (await this._getServices()).services.SpacesService,
-        NetworkService: async () => (await this._getServices()).services.NetworkService,
-        SpaceService: async () => (await this._getServices()).services.SpaceService,
-        DataService: async () => (await this._getServices()).services.DataService,
-        ProfileService: async () => (await this._getServices()).services.ProfileService,
-        SystemService: async () => (await this._getServices()).services.SystemService,
-        DevtoolsHost: async () => (await this._getServices()).services.DevtoolsHost,
-        TracingService: async () => (await this._getServices()).services.TracingService
+        DataService: async () => await this._getService((services) => services.DataService),
+        DevicesService: async () => await this._getService((services) => services.DevicesService),
+        DevtoolsHost: async () => await this._getService((services) => services.DevtoolsHost),
+        HaloInvitationsService: async () => await this._getService((services) => services.HaloInvitationsService),
+        NetworkService: async () => await this._getService((services) => services.NetworkService),
+        ProfileService: async () => await this._getService((services) => services.ProfileService),
+        SpaceInvitationsService: async () => await this._getService((services) => services.SpaceInvitationsService),
+        SpaceService: async () => await this._getService((services) => services.SpaceService),
+        SpacesService: async () => await this._getService((services) => services.SpacesService),
+        SystemService: async () => await this._getService((services) => services.SystemService),
+        TracingService: async () => await this._getService((services) => services.TracingService)
       },
       port: appPort
     });

package/dist/types/src/packlets/vault/iframe-runtime.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"iframe-runtime.d.ts","sourceRoot":"","sources":["../../../../../src/packlets/vault/iframe-runtime.ts"],"names":[],"mappings":"AAMA,OAAO,EAAoC,OAAO,EAAE,MAAM,WAAW,CAAC;AAKtE,oBAAY,mBAAmB,GAAG;IAChC,UAAU,EAAE,OAAO,CAAC;IACpB,aAAa,EAAE,OAAO,CAAC;IACvB,aAAa,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF;;GAEG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAU;IACtC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAU;IACzC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAU;IACzC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAoC;IAC/D,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAgC;gBAEtD,EAAE,UAAU,EAAE,aAAa,EAAE,aAAa,EAAE,EAAE,mBAAmB;IAwBvE,IAAI,CAAC,MAAM,EAAE,MAAM;IAKnB,KAAK;CAIZ"}