@dxos/edge-client 0.6.13 → 0.6.14-main.1366248

package/src/edge-ws-connection.ts

@@ -0,0 +1,148 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import WebSocket from 'isomorphic-ws';
+
+import { scheduleTask, scheduleTaskInterval } from '@dxos/async';
+import { Context, Resource } from '@dxos/context';
+import { invariant } from '@dxos/invariant';
+import { log, logInfo } from '@dxos/log';
+import { buf } from '@dxos/protocols/buf';
+import { MessageSchema, type Message } from '@dxos/protocols/buf/dxos/edge/messenger_pb';
+
+import { protocol } from './defs';
+import { type EdgeIdentity } from './edge-identity';
+import { toUint8Array } from './protocol';
+
+const SIGNAL_KEEPALIVE_INTERVAL = 5_000;
+
+export type EdgeWsConnectionCallbacks = {
+  onConnected: () => void;
+  onMessage: (message: Message) => void;
+  onRestartRequired: () => void;
+};
+
+export class EdgeWsConnection extends Resource {
+  private _inactivityTimeoutCtx: Context | undefined;
+  private _ws: WebSocket | undefined;
+
+  constructor(
+    private readonly _identity: EdgeIdentity,
+    private readonly _connectionInfo: { url: URL; protocolHeader?: string },
+    private readonly _callbacks: EdgeWsConnectionCallbacks,
+  ) {
+    super();
+  }
+
+  @logInfo
+  public get info() {
+    return {
+      open: this.isOpen,
+      identity: this._identity.identityKey,
+      device: this._identity.peerKey,
+    };
+  }
+
+  public send(message: Message) {
+    invariant(this._ws);
+    log('sending...', { peerKey: this._identity.peerKey, payload: protocol.getPayloadType(message) });
+    this._ws.send(buf.toBinary(MessageSchema, message));
+  }
+
+  protected override async _open() {
+    this._ws = new WebSocket(
+      this._connectionInfo.url,
+      this._connectionInfo.protocolHeader ? [this._connectionInfo.protocolHeader] : [],
+    );
+
+    this._ws.onopen = () => {
+      if (this.isOpen) {
+        log('connected');
+        this._callbacks.onConnected();
+        this._scheduleHeartbeats();
+      } else {
+        log.verbose('connected after becoming inactive', { currentIdentity: this._identity });
+      }
+    };
+    this._ws.onclose = () => {
+      if (this.isOpen) {
+        log('disconnected while being open');
+        this._callbacks.onRestartRequired();
+      }
+    };
+    this._ws.onerror = (event) => {
+      if (this.isOpen) {
+        log.warn('edge connection socket error', { error: event.error, info: event.message });
+        this._callbacks.onRestartRequired();
+      } else {
+        log.verbose('error ignored on closed connection', { error: event.error });
+      }
+    };
+    /**
+     * https://developer.mozilla.org/en-US/docs/Web/API/MessageEvent/data
+     */
+    this._ws.onmessage = async (event) => {
+      if (!this.isOpen) {
+        log.verbose('message ignored on closed connection', { event: event.type });
+        return;
+      }
+      if (event.data === '__pong__') {
+        this._rescheduleHeartbeatTimeout();
+        return;
+      }
+      const data = await toUint8Array(event.data);
+      if (this.isOpen) {
+        const message = buf.fromBinary(MessageSchema, data);
+        log('received', { from: message.source, payload: protocol.getPayloadType(message) });
+        this._callbacks.onMessage(message);
+      }
+    };
+  }
+
+  protected override async _close() {
+    void this._inactivityTimeoutCtx?.dispose().catch(() => {});
+
+    try {
+      this._ws?.close();
+      this._ws = undefined;
+    } catch (err) {
+      if (err instanceof Error && err.message.includes('WebSocket is closed before the connection is established.')) {
+        return;
+      }
+      log.warn('Error closing websocket', { err });
+    }
+  }
+
+  private _scheduleHeartbeats() {
+    invariant(this._ws);
+    scheduleTaskInterval(
+      this._ctx,
+      async () => {
+        // TODO(mykola): use RFC6455 ping/pong once implemented in the browser?
+        // Cloudflare's worker responds to this `without interrupting hibernation`. https://developers.cloudflare.com/durable-objects/api/websockets/#setwebsocketautoresponse
+        this._ws?.send('__ping__');
+      },
+      SIGNAL_KEEPALIVE_INTERVAL,
+    );
+    this._ws.send('__ping__');
+    this._rescheduleHeartbeatTimeout();
+  }
+
+  private _rescheduleHeartbeatTimeout() {
+    if (!this.isOpen) {
+      return;
+    }
+    void this._inactivityTimeoutCtx?.dispose();
+    this._inactivityTimeoutCtx = new Context();
+    scheduleTask(
+      this._inactivityTimeoutCtx,
+      () => {
+        if (this.isOpen) {
+          this._callbacks.onRestartRequired();
+        }
+      },
+      2 * SIGNAL_KEEPALIVE_INTERVAL,
+    );
+  }
+}

package/src/errors.ts

@@ -2,8 +2,14 @@
 // Copyright 2024 DXOS.org
 //
 
-export class WebsocketClosedError extends Error {
+export class EdgeConnectionClosedError extends Error {
   constructor() {
-    super('WebSocket connection closed');
+    super('Edge connection closed.');
+  }
+}
+
+export class EdgeIdentityChangedError extends Error {
+  constructor() {
+    super('Edge identity changed.');
   }
 }

package/src/index.ts

@@ -7,3 +7,7 @@ export * from '@dxos/protocols/buf/dxos/edge/messenger_pb';
 export * from './edge-client';
 export * from './defs';
 export * from './protocol';
+export * from './errors';
+export * from './auth';
+export * from './edge-http-client';
+export * from './edge-identity';

package/src/persistent-lifecycle.test.ts

@@ -2,11 +2,11 @@
 // Copyright 2024 DXOS.org
 //
 
-import { expect } from 'chai';
+import { describe, expect, test } from 'vitest';
 
 import { sleep, Trigger } from '@dxos/async';
 import { log } from '@dxos/log';
-import { describe, openAndClose, test } from '@dxos/test';
+import { openAndClose } from '@dxos/test-utils';
 
 import { PersistentLifecycle } from './persistent-lifecycle';
 

package/src/persistent-lifecycle.ts

@@ -10,17 +10,17 @@ import { log } from '@dxos/log';
 const INIT_RESTART_DELAY = 100;
 const DEFAULT_MAX_RESTART_DELAY = 5000;
 
-export type PersistentLifecycleParams = {
+export type PersistentLifecycleParams<T> = {
   /**
    * Create connection.
    * If promise resolves successfully, connection is considered established.
    */
-  start: () => Promise<void>;
+  start: () => Promise<T | undefined>;
 
   /**
    * Reset connection to initial state.
    */
-  stop: () => Promise<void>;
+  stop: (state: T) => Promise<void>;
 
   /**
    * Called after successful start.
@@ -38,16 +38,17 @@ export type PersistentLifecycleParams = {
  * Handles restarts (e.g. persists connection).
  * Restarts are scheduled with exponential backoff.
  */
-export class PersistentLifecycle extends Resource {
-  private readonly _start: () => Promise<void>;
-  private readonly _stop: () => Promise<void>;
+export class PersistentLifecycle<T> extends Resource {
+  private readonly _start: () => Promise<T | undefined>;
+  private readonly _stop: (state: T) => Promise<void>;
   private readonly _onRestart?: () => Promise<void>;
   private readonly _maxRestartDelay: number;
 
+  private _currentContext: T | undefined = undefined;
   private _restartTask?: DeferredTask = undefined;
   private _restartAfter = 0;
 
-  constructor({ start, stop, onRestart, maxRestartDelay = DEFAULT_MAX_RESTART_DELAY }: PersistentLifecycleParams) {
+  constructor({ start, stop, onRestart, maxRestartDelay = DEFAULT_MAX_RESTART_DELAY }: PersistentLifecycleParams<T>) {
     super();
     this._start = start;
     this._stop = stop;
@@ -65,21 +66,22 @@ export class PersistentLifecycle extends Resource {
         this._restartTask?.schedule();
       }
     });
-    await this._start().catch((err) => {
+    this._currentContext = await this._start().catch((err) => {
       log.warn('Start failed', { err });
       this._restartTask?.schedule();
+      return undefined;
     });
   }
 
   protected override async _close() {
     await this._restartTask?.join();
-    await this._stop();
+    await this._stopCurrentContext();
     this._restartTask = undefined;
   }
 
   private async _restart() {
     log(`restarting in ${this._restartAfter}ms`, { state: this._lifecycleState });
-    await this._stop();
+    await this._stopCurrentContext();
     if (this._lifecycleState !== LifecycleState.OPEN) {
       return;
     }
@@ -87,12 +89,25 @@ export class PersistentLifecycle extends Resource {
     this._restartAfter = Math.min(Math.max(this._restartAfter * 2, INIT_RESTART_DELAY), this._maxRestartDelay);
 
     // May fail if the connection is not established.
-    await warnAfterTimeout(5_000, 'Connection establishment takes too long', () => this._start());
+    await warnAfterTimeout(5_000, 'Connection establishment takes too long', async () => {
+      this._currentContext = await this._start();
+    });
 
     this._restartAfter = 0;
     await this._onRestart?.();
   }
 
+  private async _stopCurrentContext() {
+    if (this._currentContext) {
+      try {
+        await this._stop(this._currentContext);
+      } catch (err) {
+        log.catch(err);
+      }
+      this._currentContext = undefined;
+    }
+  }
+
   /**
    * Scheduling restart should be done from outside.
    */

package/src/protocol.test.ts

@@ -2,7 +2,7 @@
 // Copyright 2024 DXOS.org
 //
 
-import { expect } from 'chai';
+import { describe, expect, test } from 'vitest';
 
 import { buf } from '@dxos/protocols/buf';
 import {
@@ -11,7 +11,6 @@ import {
   SwarmRequestSchema,
   SwarmResponseSchema,
 } from '@dxos/protocols/buf/dxos/edge/messenger_pb';
-import { describe, test } from '@dxos/test';
 
 import { Protocol } from './protocol';
 

package/src/protocol.ts

@@ -4,10 +4,10 @@
 
 import { invariant } from '@dxos/invariant';
 import { buf, bufWkt } from '@dxos/protocols/buf';
-import { type Message, MessageSchema, type Peer as PeerProto } from '@dxos/protocols/buf/dxos/edge/messenger_pb';
+import { type Message, MessageSchema, type PeerSchema } from '@dxos/protocols/buf/dxos/edge/messenger_pb';
 import { bufferToArray } from '@dxos/util';
 
-export type PeerData = Partial<PeerProto>;
+export type PeerData = buf.MessageInitShape<typeof PeerSchema>;
 
 export const getTypename = (typeName: string) => `type.googleapis.com/${typeName}`;
 

package/src/testing/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+export * from './test-utils';

package/src/testing/test-utils.ts

@@ -0,0 +1,117 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import WebSocket from 'isomorphic-ws';
+
+import { Trigger } from '@dxos/async';
+import { log } from '@dxos/log';
+import { buf } from '@dxos/protocols/buf';
+import { MessageSchema, TextMessageSchema, type Message } from '@dxos/protocols/buf/dxos/edge/messenger_pb';
+
+import { protocol } from '../defs';
+import { toUint8Array } from '../protocol';
+
+export const DEFAULT_PORT = 8080;
+
+type TestEdgeWsServerParams = {
+  admitConnection?: Trigger;
+  payloadDecoder?: (payload: Uint8Array) => any;
+  messageHandler?: (payload: any) => Promise<Uint8Array | undefined>;
+};
+
+export const createTestEdgeWsServer = async (port = DEFAULT_PORT, params?: TestEdgeWsServerParams) => {
+  const server = new WebSocket.Server({ port, verifyClient: createConnectionDelayHandler(params) });
+
+  let connection: WebSocket | undefined;
+
+  const messageSink: any[] = [];
+  const messageSourceLog: any[] = [];
+  const closeTrigger = new Trigger();
+  const sendResponseMessage = createResponseSender(() => connection!);
+
+  server.on('connection', (ws) => {
+    connection = ws;
+    ws.on('error', (err) => log.catch(err));
+    ws.on('message', async (data) => {
+      if (String(data) === '__ping__') {
+        ws.send('__pong__');
+        return;
+      }
+      const { request, requestPayload } = await decodeRequest(params, data);
+      messageSourceLog.push(request.source);
+      if (params?.messageHandler) {
+        const responsePayload = await params.messageHandler(requestPayload);
+        if (responsePayload && connection) {
+          sendResponseMessage(request, responsePayload);
+        }
+      }
+      log('message', { payload: requestPayload });
+      messageSink.push(requestPayload);
+    });
+
+    ws.on('close', () => {
+      connection = undefined;
+      closeTrigger.wake();
+    });
+  });
+
+  return {
+    server,
+    messageSink,
+    messageSourceLog,
+    endpoint: `ws://localhost:${port}`,
+    cleanup: () => server.close(),
+    currentConnection: () => connection,
+    sendResponseMessage,
+    sendMessage: (msg: Message) => {
+      connection!.send(buf.toBinary(MessageSchema, msg));
+    },
+    closeConnection: () => {
+      closeTrigger.reset();
+      connection!.close(1011);
+      return closeTrigger.wait();
+    },
+  };
+};
+
+const createConnectionDelayHandler = (params: TestEdgeWsServerParams | undefined) => {
+  return (_: any, callback: (admit: boolean) => void) => {
+    if (params?.admitConnection) {
+      log('delaying edge connection admission');
+      void params.admitConnection.wait().then(() => {
+        callback(true);
+        log('edge connection admitted');
+      });
+    } else {
+      callback(true);
+    }
+  };
+};
+
+const createResponseSender = (connection: () => WebSocket) => {
+  return (request: Message, responsePayload: Uint8Array) => {
+    const recipient = request.source!;
+    connection().send(
+      buf.toBinary(
+        MessageSchema,
+        buf.create(MessageSchema, {
+          source: {
+            identityKey: recipient.identityKey,
+            peerKey: recipient.peerKey,
+          },
+          serviceId: request.serviceId!,
+          payload: { value: responsePayload },
+        }),
+      ),
+    );
+  };
+};
+
+const decodeRequest = async (params: TestEdgeWsServerParams | undefined, data: any) => {
+  const request = buf.fromBinary(MessageSchema, await toUint8Array(data));
+  const requestPayload = params?.payloadDecoder
+    ? params.payloadDecoder(request.payload!.value!)
+    : protocol.getPayload(request, TextMessageSchema);
+  return { request, requestPayload };
+};

package/src/utils.ts

@@ -0,0 +1,10 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+export const getEdgeUrlWithProtocol = (baseUrl: string, protocol: 'http' | 'ws') => {
+  const isSecure = baseUrl.startsWith('https') || baseUrl.startsWith('wss');
+  const url = new URL(baseUrl);
+  url.protocol = protocol + (isSecure ? 's' : '');
+  return url.toString();
+};

package/src/websocket.test.ts

@@ -2,17 +2,18 @@
 // Copyright 2024 DXOS.org
 //
 
-import { expect } from 'chai';
 import WebSocket from 'isomorphic-ws';
+import { describe, expect, test, onTestFinished } from 'vitest';
 
 import { Trigger, TriggerState } from '@dxos/async';
-import { describe, test } from '@dxos/test';
 
-import { createTestWsServer } from './test-utils';
+import { createTestEdgeWsServer } from './testing';
 
 describe('WebSocket', () => {
   test('swap `onclose` handler ', async () => {
-    const { endpoint } = await createTestWsServer();
+    const { endpoint, cleanup } = await createTestEdgeWsServer(8003);
+    onTestFinished(cleanup);
+
     const ws = new WebSocket(endpoint);
     const opened = new Trigger();
     ws.onopen = () => {

package/dist/types/src/test-utils.d.ts

@@ -1,11 +0,0 @@
-import WebSocket from 'isomorphic-ws';
-export declare const DEFAULT_PORT = 8080;
-export declare const createTestWsServer: (port?: number) => Promise<{
-    server: WebSocket.Server;
-    /**
-     * Close the server connection.
-     */
-    error: () => Promise<void>;
-    endpoint: string;
-}>;
-//# sourceMappingURL=test-utils.d.ts.map

package/dist/types/src/test-utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"test-utils.d.ts","sourceRoot":"","sources":["../../../src/test-utils.ts"],"names":[],"mappings":"AAIA,OAAO,SAAS,MAAM,eAAe,CAAC;AAWtC,eAAO,MAAM,YAAY,OAAO,CAAC;AAEjC,eAAO,MAAM,kBAAkB;;IAsB3B;;OAEG;;;EAON,CAAC"}

package/src/test-utils.ts

@@ -1,49 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import WebSocket from 'isomorphic-ws';
-
-import { Trigger } from '@dxos/async';
-import { log } from '@dxos/log';
-import { buf } from '@dxos/protocols/buf';
-import { MessageSchema, TextMessageSchema } from '@dxos/protocols/buf/dxos/edge/messenger_pb';
-import { afterTest } from '@dxos/test';
-
-import { protocol } from './defs';
-import { toUint8Array } from './protocol';
-
-export const DEFAULT_PORT = 8080;
-
-export const createTestWsServer = async (port = DEFAULT_PORT) => {
-  const server = new WebSocket.Server({ port });
-  let connection: WebSocket;
-  const closeTrigger = new Trigger();
-  server.on('connection', (ws) => {
-    connection = ws;
-    ws.on('error', (err) => log.catch(err));
-    ws.on('message', async (data) => {
-      if (String(data) === '__ping__') {
-        ws.send('__pong__');
-        return;
-      }
-      log('message', {
-        payload: protocol.getPayload(buf.fromBinary(MessageSchema, await toUint8Array(data)), TextMessageSchema),
-      });
-    });
-    ws.on('close', () => closeTrigger.wake());
-  });
-
-  afterTest(() => server.close());
-  return {
-    server,
-    /**
-     * Close the server connection.
-     */
-    error: async () => {
-      connection.close(1011);
-      await closeTrigger.wait();
-    },
-    endpoint: `ws://localhost:${port}`,
-  };
-};