@dxos/edge-client 0.6.9 → 0.6.10-main.bbdfaa4

package/src/persistent-lifecycle.ts

@@ -0,0 +1,106 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { DeferredTask, sleep, synchronized } from '@dxos/async';
+import { cancelWithContext, LifecycleState, Resource } from '@dxos/context';
+import { warnAfterTimeout } from '@dxos/debug';
+import { log } from '@dxos/log';
+
+const INIT_RESTART_DELAY = 100;
+const DEFAULT_MAX_RESTART_DELAY = 5000;
+
+export type PersistentLifecycleParams = {
+  /**
+   * Create connection.
+   * If promise resolves successfully, connection is considered established.
+   */
+  start: () => Promise<void>;
+
+  /**
+   * Reset connection to initial state.
+   */
+  stop: () => Promise<void>;
+
+  /**
+   * Called after successful start.
+   */
+  onRestart?: () => Promise<void>;
+
+  /**
+   * Maximum delay between restartion attempts.
+   * Default: 5000ms
+   */
+  maxRestartDelay?: number;
+};
+
+/**
+ * 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>;
+  private readonly _onRestart?: () => Promise<void>;
+  private readonly _maxRestartDelay: number;
+
+  private _restartTask?: DeferredTask = undefined;
+  private _restartAfter = 0;
+
+  constructor({ start, stop, onRestart, maxRestartDelay = DEFAULT_MAX_RESTART_DELAY }: PersistentLifecycleParams) {
+    super();
+    this._start = start;
+    this._stop = stop;
+    this._onRestart = onRestart;
+    this._maxRestartDelay = maxRestartDelay;
+  }
+
+  @synchronized
+  protected override async _open() {
+    this._restartTask = new DeferredTask(this._ctx, async () => {
+      try {
+        await this._restart();
+      } catch (err) {
+        log.warn('Restart failed', { err });
+        this._restartTask?.schedule();
+      }
+    });
+    await this._start().catch((err) => {
+      log.warn('Start failed', { err });
+      this._restartTask?.schedule();
+    });
+  }
+
+  protected override async _close() {
+    await this._restartTask?.join();
+    await this._stop();
+    this._restartTask = undefined;
+  }
+
+  private async _restart() {
+    log(`restarting in ${this._restartAfter}ms`, { state: this._lifecycleState });
+    await this._stop();
+    if (this._lifecycleState !== LifecycleState.OPEN) {
+      return;
+    }
+    await cancelWithContext(this._ctx!, sleep(this._restartAfter));
+    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());
+
+    this._restartAfter = 0;
+    await this._onRestart?.();
+  }
+
+  /**
+   * Scheduling restart should be done from outside.
+   */
+  @synchronized
+  scheduleRestart() {
+    if (this._lifecycleState !== LifecycleState.OPEN) {
+      return;
+    }
+    this._restartTask!.schedule();
+  }
+}

package/src/protocol.test.ts

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

package/src/test-utils.ts

@@ -0,0 +1,49 @@
+//
+// 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}`,
+  };
+};

package/src/websocket.test.ts

@@ -0,0 +1,35 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { expect } from 'chai';
+import WebSocket from 'isomorphic-ws';
+
+import { Trigger, TriggerState } from '@dxos/async';
+import { describe, test } from '@dxos/test';
+
+import { createTestWsServer } from './test-utils';
+
+describe('WebSocket', () => {
+  test('swap `onclose` handler ', async () => {
+    const { endpoint } = await createTestWsServer();
+    const ws = new WebSocket(endpoint);
+    const opened = new Trigger();
+    ws.onopen = () => {
+      opened.wake();
+    };
+    const closeCalled1 = new Trigger();
+    ws.onclose = () => {
+      closeCalled1.wake();
+    };
+    const closeCalled2 = new Trigger();
+    ws.onclose = () => {
+      closeCalled2.wake();
+    };
+
+    await opened.wait();
+    ws.close();
+    await closeCalled2.wait();
+    expect(closeCalled1.state === TriggerState.WAITING).is.true;
+  });
+});

package/dist/types/src/client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../src/client.ts"],"names":[],"mappings":"AAOA,OAAO,EAAkB,QAAQ,EAAE,KAAK,SAAS,EAAE,MAAM,eAAe,CAAC;AAEzE,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,YAAY,CAAC;AAG5C,OAAO,EAAE,KAAK,OAAO,EAAiB,MAAM,4CAA4C,CAAC;AAGzF,OAAO,EAAE,KAAK,QAAQ,EAAgB,MAAM,YAAY,CAAC;AAIzD,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAEzE,MAAM,WAAW,cAAe,SAAQ,QAAQ,CAAC,SAAS,CAAC;IACzD,IAAI,IAAI,IAAI,GAAG,CAAC;IAChB,IAAI,WAAW,IAAI,SAAS,CAAC;IAC7B,IAAI,SAAS,IAAI,SAAS,CAAC;IAC3B,IAAI,MAAM,IAAI,OAAO,CAAC;IACtB,WAAW,CAAC,MAAM,EAAE;QAAE,SAAS,EAAE,SAAS,CAAC;QAAC,WAAW,EAAE,SAAS,CAAA;KAAE,GAAG,IAAI,CAAC;IAC5E,WAAW,CAAC,QAAQ,EAAE,eAAe,GAAG,MAAM,IAAI,CAAC;IACnD,IAAI,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACvC;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,QAAQ,CAAC;CACrB,CAAC;AAEF;;GAEG;AAGH,qBAAa,UAAW,SAAQ,QAAS,YAAW,cAAc;IAQ9D,OAAO,CAAC,YAAY;IACpB,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAT1B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA8B;IACzD,OAAO,CAAC,UAAU,CAAC,CAA4B;IAC/C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAW;IACrC,OAAO,CAAC,MAAM,CAAiB;IAC/B,OAAO,CAAC,GAAG,CAAC,CAAwB;gBAG1B,YAAY,EAAE,SAAS,EACvB,UAAU,EAAE,SAAS,EACZ,OAAO,EAAE,eAAe;IAO3C,IAAW,IAAI;;;;MAMd;IAED,IAAI,WAAW,cAEd;IAED,IAAI,SAAS,cAEZ;IAED,IAAW,MAAM,YAEhB;IAED,WAAW,CAAC,EAAE,SAAS,EAAE,WAAW,EAAE,EAAE;QAAE,SAAS,EAAE,SAAS,CAAC;QAAC,WAAW,EAAE,SAAS,CAAA;KAAE;IAUjF,WAAW,CAAC,QAAQ,EAAE,eAAe,GAAG,MAAM,IAAI;IAKzD;;OAEG;cACsB,KAAK;IAa9B;;OAEG;cACsB,MAAM;YAOjB,cAAc;YAwCd,eAAe;IAM7B;;;OAGG;IAEU,IAAI,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;CAOnD"}

package/src/client.ts

@@ -1,179 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import WebSocket from 'isomorphic-ws';
-
-import { Trigger } from '@dxos/async';
-import { LifecycleState, Resource, type Lifecycle } from '@dxos/context';
-import { invariant } from '@dxos/invariant';
-import { type PublicKey } from '@dxos/keys';
-import { log } from '@dxos/log';
-import { buf } from '@dxos/protocols/buf';
-import { type Message, MessageSchema } from '@dxos/protocols/buf/dxos/edge/messenger_pb';
-
-import { protocol } from './defs';
-import { type Protocol, toUint8Array } from './protocol';
-
-const DEFAULT_TIMEOUT = 5_000;
-
-export type MessageListener = (message: Message) => void | Promise<void>;
-
-export interface EdgeConnection extends Required<Lifecycle> {
-  get info(): any;
-  get identityKey(): PublicKey;
-  get deviceKey(): PublicKey;
-  get isOpen(): boolean;
-  setIdentity(params: { deviceKey: PublicKey; identityKey: PublicKey }): void;
-  addListener(listener: MessageListener): () => void;
-  send(message: Message): Promise<void>;
-}
-
-export type MessengerConfig = {
-  socketEndpoint: string;
-  timeout?: number;
-  protocol?: Protocol;
-};
-
-/**
- * Messenger client.
- */
-// TODO(dmaretskyi): Rename EdgeClient.
-// TODO(mykola): Handle reconnections.
-export class EdgeClient extends Resource implements EdgeConnection {
-  private readonly _listeners = new Set<MessageListener>();
-  private _reconnect?: Promise<void> = undefined;
-  private readonly _protocol: Protocol;
-  private _ready = new Trigger();
-  private _ws?: WebSocket = undefined;
-
-  constructor(
-    private _identityKey: PublicKey,
-    private _deviceKey: PublicKey,
-    private readonly _config: MessengerConfig,
-  ) {
-    super();
-    this._protocol = this._config.protocol ?? protocol;
-  }
-
-  // TODO(burdon): Attach logging.
-  public get info() {
-    return {
-      open: this.isOpen,
-      identity: this._identityKey,
-      device: this._deviceKey,
-    };
-  }
-
-  get identityKey() {
-    return this._identityKey;
-  }
-
-  get deviceKey() {
-    return this._deviceKey;
-  }
-
-  public get isOpen() {
-    return this._lifecycleState === LifecycleState.OPEN;
-  }
-
-  setIdentity({ deviceKey, identityKey }: { deviceKey: PublicKey; identityKey: PublicKey }) {
-    this._deviceKey = deviceKey;
-    this._identityKey = identityKey;
-    this._reconnect = this._closeWebSocket()
-      .then(async () => {
-        await this._openWebSocket();
-      })
-      .catch((err) => log.catch(err));
-  }
-
-  public addListener(listener: MessageListener): () => void {
-    this._listeners.add(listener);
-    return () => this._listeners.delete(listener);
-  }
-
-  /**
-   * Open connection to messaging service.
-   */
-  protected override async _open() {
-    await this._reconnect;
-    if (this._ws) {
-      return;
-    }
-    invariant(this._deviceKey && this._identityKey);
-    log.info('opening...', { info: this.info });
-
-    // TODO: handle reconnects
-    await this._openWebSocket();
-    log.info('opened', { info: this.info });
-  }
-
-  /**
-   * Close connection and free resources.
-   */
-  protected override async _close() {
-    log('closing...', { deviceKey: this._deviceKey });
-    await this._reconnect;
-    await this._closeWebSocket();
-    log('closed', { deviceKey: this._deviceKey });
-  }
-
-  private async _openWebSocket() {
-    const url = new URL(`/ws/${this._identityKey.toHex()}/${this._deviceKey.toHex()}`, this._config.socketEndpoint);
-    this._ws = new WebSocket(url);
-    Object.assign<WebSocket, Partial<WebSocket>>(this._ws, {
-      onopen: () => {
-        log('opened', this.info);
-        this._ready.wake();
-      },
-
-      onclose: () => {
-        log('closed', this.info);
-      },
-
-      onerror: (event) => {
-        log.catch(event.error, this.info);
-        this._ready.throw(event.error);
-      },
-
-      /**
-       * https://developer.mozilla.org/en-US/docs/Web/API/MessageEvent/data
-       */
-      onmessage: async (event) => {
-        const data = await toUint8Array(event.data);
-        const message = buf.fromBinary(MessageSchema, data);
-        log('received', { deviceKey: this._deviceKey, payload: protocol.getPayloadType(message) });
-        if (message) {
-          for (const listener of this._listeners) {
-            try {
-              await listener(message);
-            } catch (err) {
-              log.error('processing', { err, payload: protocol.getPayloadType(message) });
-            }
-          }
-        }
-      },
-    });
-
-    await this._ready.wait({ timeout: this._config.timeout ?? DEFAULT_TIMEOUT });
-  }
-
-  private async _closeWebSocket() {
-    this._ready.reset();
-    this._ws!.close();
-    this._ws = undefined;
-  }
-
-  /**
-   * Send message.
-   * NOTE: The message is guaranteed to be delivered but the service must respond with a message to confirm processing.
-   */
-  // TODO(burdon): Implement ACK?
-  public async send(message: Message): Promise<void> {
-    await this._ready.wait({ timeout: this._config.timeout ?? DEFAULT_TIMEOUT });
-    invariant(this._ws);
-    invariant(!message.source || message.source.peerKey === this._deviceKey.toHex());
-    log('sending...', { deviceKey: this._deviceKey, payload: protocol.getPayloadType(message) });
-    this._ws.send(buf.toBinary(MessageSchema, message));
-  }
-}