@dxos/client-services 0.1.22 → 0.1.24-next.6b1f434

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';
@@ -16,6 +17,7 @@ import { WorkerSession } from './worker-session';
 export type CreateSessionParams = {
   appPort: RpcPort;
   systemPort: RpcPort;
+  shellPort: RpcPort;
 };
 
 /**
@@ -37,6 +39,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 +56,10 @@ export class WorkerRuntime {
 
       await this._clientServices.open();
       this._ready.wake(undefined);
+      log('started');
     } catch (err: any) {
       this._ready.wake(err);
+      log.catch(err);
     }
   }
 
@@ -66,17 +71,24 @@ export class WorkerRuntime {
   /**
    * Create a new session.
    */
-  async createSession({ appPort, systemPort }: CreateSessionParams) {
+  async createSession({ appPort, systemPort, shellPort }: 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,
+      shellPort,
       readySignal: this._ready
     });
 

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

@@ -4,19 +4,20 @@
 
 import assert from 'node:assert';
 
-import { Trigger } from '@dxos/async';
+import { asyncTimeout, Trigger } from '@dxos/async';
 import { log, logInfo } from '@dxos/log';
 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;
+  shellPort: RpcPort;
   readySignal: Trigger<Error | undefined>;
   options?: {
     heartbeatInterval: number;
@@ -28,9 +29,10 @@ export type WorkerSessionParams = {
  */
 export class WorkerSession {
   private readonly _clientRpc: ProtoRpcPeer<ClientServices>;
+  private readonly _shellClientRpc: 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,35 +44,35 @@ export class WorkerSession {
   public bridgeService?: BridgeService;
 
   constructor({
-    getServices,
+    getService,
     systemPort,
     appPort,
+    shellPort,
     options = {
       heartbeatInterval: 1_000
     }
   }: WorkerSessionParams) {
     assert(options);
-    assert(getServices);
+    assert(getService);
     this._options = options;
-    this._getServices = getServices;
-
-    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
-      },
-      port: appPort
-    });
+    this._getService = getService;
+
+    const 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)
+    };
+
+    this._clientRpc = createProtoRpcPeer({ exposed: clientServiceBundle, handlers, port: appPort });
+    this._shellClientRpc = createProtoRpcPeer({ exposed: clientServiceBundle, handlers, port: shellPort });
 
     this._iframeRpc = createProtoRpcPeer({
       requested: iframeServiceBundle,
@@ -102,7 +104,7 @@ export class WorkerSession {
 
   async open() {
     log.info('opening..');
-    await Promise.all([this._clientRpc.open(), this._iframeRpc.open()]);
+    await Promise.all([this._clientRpc.open(), this._iframeRpc.open(), this._maybeOpenShell()]);
 
     await this._startTrigger.wait({ timeout: 3_000 });
 
@@ -137,4 +139,12 @@ export class WorkerSession {
 
     await Promise.all([this._clientRpc.close(), this._iframeRpc.close()]);
   }
+
+  private async _maybeOpenShell() {
+    try {
+      await asyncTimeout(this._shellClientRpc.open(), 1_000);
+    } catch {
+      log.info('No shell connected.');
+    }
+  }
 }

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"}