@dxos/async 0.8.4-staging.ac66bdf99f → 0.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/async",
-  "version": "0.8.4-staging.ac66bdf99f",
+  "version": "0.9.0",
   "description": "Async utilities.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -8,7 +8,7 @@
     "type": "git",
     "url": "https://github.com/dxos/dxos"
   },
-  "license": "MIT",
+  "license": "FSL-1.1-Apache-2.0",
   "author": "DXOS.org",
   "sideEffects": true,
   "type": "module",
@@ -23,9 +23,6 @@
     }
   },
   "types": "dist/types/src/index.d.ts",
-  "typesVersions": {
-    "*": {}
-  },
   "files": [
     "dist",
     "src"
@@ -33,12 +30,12 @@
   "dependencies": {
     "zen-observable": "^0.10.0",
     "zen-push": "^0.3.1",
-    "@dxos/context": "0.8.4-staging.ac66bdf99f",
-    "@dxos/invariant": "0.8.4-staging.ac66bdf99f",
-    "@dxos/debug": "0.8.4-staging.ac66bdf99f",
-    "@dxos/log": "0.8.4-staging.ac66bdf99f",
-    "@dxos/node-std": "0.8.4-staging.ac66bdf99f",
-    "@dxos/util": "0.8.4-staging.ac66bdf99f"
+    "@dxos/context": "0.9.0",
+    "@dxos/log": "0.9.0",
+    "@dxos/invariant": "0.9.0",
+    "@dxos/debug": "0.9.0",
+    "@dxos/node-std": "0.9.0",
+    "@dxos/util": "0.9.0"
   },
   "devDependencies": {
     "@types/zen-observable": "^0.8.3"

package/src/persistent-lifecycle.test.ts

@@ -57,6 +57,42 @@ describe('ConnectionState', () => {
     expect(timeToTrigger).to.be.greaterThanOrEqual(100);
   });
 
+  test('connection that drops immediately backs off instead of hot-looping', async () => {
+    const startTimes: number[] = [];
+    const maxStarts = 4;
+    const done = new Trigger();
+
+    const persistentLifecycle = new PersistentLifecycle({
+      start: async () => {
+        startTimes.push(Date.now());
+        if (startTimes.length >= maxStarts) {
+          done.wake();
+        }
+      },
+      stop: async () => {},
+      // Simulate the connection dropping the moment it is established.
+      onRestart: async () => {
+        if (startTimes.length < maxStarts) {
+          void persistentLifecycle.scheduleRestart();
+        }
+      },
+    });
+
+    await persistentLifecycle.open();
+    onTestFinished(async () => {
+      await persistentLifecycle.close();
+    });
+
+    // The initial open already performed the first start; simulate its immediate drop.
+    void persistentLifecycle.scheduleRestart();
+    await done.wait({ timeout: 5000 });
+
+    // Successive reconnects must back off (~0, ~100, ~200ms), not fire back-to-back.
+    const gaps = startTimes.slice(1).map((time, index) => time - startTimes[index]);
+    expect(gaps[1]).to.be.greaterThanOrEqual(90);
+    expect(gaps[2]).to.be.greaterThanOrEqual(180);
+  });
+
   test('finish `restart` before close', async () => {
     let restarted = false;
     const persistentLifecycle = new PersistentLifecycle({

package/src/persistent-lifecycle.ts

@@ -13,6 +13,13 @@ import { sleep } from './timeout';
 const INIT_RESTART_DELAY = 100;
 const DEFAULT_MAX_RESTART_DELAY = 5000;
 
+/**
+ * Minimum duration a connection must stay up before it is considered stable and the backoff is
+ * reset. A connection that drops sooner keeps escalating the delay, so an endpoint that accepts
+ * then immediately closes the connection cannot produce a zero-delay reconnect loop.
+ */
+const STABLE_CONNECTION_THRESHOLD = 5000;
+
 export type PersistentLifecycleProps<T> = {
   /**
    * Create connection.
@@ -50,6 +57,7 @@ export class PersistentLifecycle<T> extends Resource {
   private _currentState: T | undefined = undefined;
   private _restartTask?: DeferredTask = undefined;
   private _restartAfter = 0;
+  private _connectedAt: number | undefined = undefined;
 
   constructor({ start, stop, onRestart, maxRestartDelay = DEFAULT_MAX_RESTART_DELAY }: PersistentLifecycleProps<T>) {
     super();
@@ -69,16 +77,26 @@ export class PersistentLifecycle<T> extends Resource {
       try {
         await this._restart();
       } catch (err) {
+        // Suppress noise from restarts that race with shutdown.
+        if (this._ctx?.disposed) {
+          return;
+        }
         log.warn('Restart failed', { err });
         this._restartTask?.schedule();
       }
     });
 
-    this._currentState = await this._start().catch((err) => {
+    try {
+      this._currentState = await this._start();
+      this._connectedAt = Date.now();
+    } catch (err) {
+      // Suppress noise when shutdown was requested while the initial start was in flight.
+      if (this._ctx?.disposed) {
+        return;
+      }
       log.warn('Start failed', { err });
       this._restartTask?.schedule();
-      return undefined;
-    });
+    }
   }
 
   protected override async _close(): Promise<void> {
@@ -89,6 +107,15 @@ export class PersistentLifecycle<T> extends Resource {
 
   private async _restart(): Promise<void> {
     log(`restarting in ${this._restartAfter}ms`, { state: this._lifecycleState });
+
+    // Reset the backoff only if the previous connection stayed up long enough to be considered
+    // stable. A connection that drops shortly after starting must keep escalating the delay,
+    // otherwise reconnects degenerate into a hot loop.
+    if (this._connectedAt !== undefined && Date.now() - this._connectedAt >= STABLE_CONNECTION_THRESHOLD) {
+      this._restartAfter = 0;
+    }
+    this._connectedAt = undefined;
+
     await this._stopCurrentState();
     if (this._lifecycleState !== LifecycleState.OPEN) {
       return;
@@ -101,7 +128,7 @@ export class PersistentLifecycle<T> extends Resource {
       this._currentState = await this._start();
     });
 
-    this._restartAfter = 0;
+    this._connectedAt = Date.now();
     await this._onRestart?.();
   }