@dxos/edge-client 0.7.5-labs.ea4b4c2 → 0.7.5-labs.f400bbc

package/src/persistent-lifecycle.test.ts

@@ -1,71 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { describe, expect, test } from 'vitest';
-
-import { sleep, Trigger } from '@dxos/async';
-import { log } from '@dxos/log';
-import { openAndClose } from '@dxos/test-utils';
-
-import { PersistentLifecycle } from './persistent-lifecycle';
-
-describe('ConnectionState', () => {
-  test('first reconnect fires immediately', async () => {
-    const triggerCall = new Trigger<number>();
-    const persistentLifecycle = new PersistentLifecycle({
-      start: async () => {
-        triggerCall.wake(Date.now());
-      },
-      stop: async () => {},
-    });
-    await openAndClose(persistentLifecycle);
-
-    const triggerTimestamp = Date.now();
-    persistentLifecycle.scheduleRestart();
-    const timeToTrigger = (await triggerCall.wait({ timeout: 1000 })) - triggerTimestamp;
-    expect(timeToTrigger).to.be.lessThan(50);
-  });
-
-  test('second reconnect fires after 100ms', async () => {
-    let called = 0;
-    const triggerCall = new Trigger<number>();
-
-    const persistentLifecycle = new PersistentLifecycle({
-      start: async () => {
-        called += 1;
-        log.info('called', { called });
-        if (called < 3) {
-          throw new Error('TEST ERROR');
-        }
-        triggerCall.wake(Date.now());
-      },
-      stop: async () => {},
-    });
-
-    await openAndClose(persistentLifecycle);
-
-    const triggerTimestamp = Date.now();
-    await sleep(10);
-    const timeToTrigger = (await triggerCall.wait({ timeout: 1000 })) - triggerTimestamp;
-    expect(timeToTrigger).to.be.greaterThanOrEqual(100);
-  });
-
-  test('finish `restart` before close', async () => {
-    let restarted = false;
-    const persistentLifecycle = new PersistentLifecycle({
-      start: async () => await sleep(100),
-      stop: async () => {},
-      onRestart: async () => {
-        restarted = true;
-      },
-    });
-
-    await persistentLifecycle.open();
-
-    persistentLifecycle.scheduleRestart();
-    await sleep(10);
-    await persistentLifecycle.close();
-    expect(restarted).to.be.true;
-  });
-});

package/src/persistent-lifecycle.ts

@@ -1,121 +0,0 @@
-//
-// 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<T> = {
-  /**
-   * Create connection.
-   * If promise resolves successfully, connection is considered established.
-   */
-  start: () => Promise<T | undefined>;
-
-  /**
-   * Reset connection to initial state.
-   */
-  stop: (state: T) => 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<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<T>) {
-    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();
-      }
-    });
-    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._stopCurrentContext();
-    this._restartTask = undefined;
-  }
-
-  private async _restart() {
-    log(`restarting in ${this._restartAfter}ms`, { state: this._lifecycleState });
-    await this._stopCurrentContext();
-    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', 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.
-   */
-  @synchronized
-  scheduleRestart() {
-    if (this._lifecycleState !== LifecycleState.OPEN) {
-      return;
-    }
-    this._restartTask!.schedule();
-  }
-}