@lodestar/beacon-node 1.40.0-rc.2 → 1.40.0

package/src/util/queue/itemQueue.ts

@@ -24,6 +24,8 @@ export class JobItemQueue<Args extends any[], R> {
   private readonly metrics?: QueueMetrics;
   private runningJobs = 0;
   private lastYield = 0;
+  /** Resolvers waiting for space in the queue */
+  private spaceWaiters: (() => void)[] = [];
 
   constructor(
     private readonly itemProcessor: (...args: Args) => Promise<R>,
@@ -72,12 +74,57 @@ export class JobItemQueue<Args extends any[], R> {
     });
   }
 
+  /**
+   * Returns a promise that resolves when there is space in the queue.
+   * If the queue already has space, resolves immediately (noop).
+   * Use this to apply backpressure when the caller should wait rather than
+   * have push() throw QUEUE_MAX_LENGTH.
+   */
+  async waitForSpace(): Promise<void> {
+    if (this.opts.signal.aborted) {
+      throw new QueueError({code: QueueErrorCode.QUEUE_ABORTED});
+    }
+
+    if (this.jobs.length < this.opts.maxLength) {
+      return;
+    }
+
+    return new Promise<void>((resolve, reject) => {
+      let settled = false;
+
+      const onAbort = (): void => {
+        if (settled) return;
+        settled = true;
+        const index = this.spaceWaiters.indexOf(wrappedResolve);
+        if (index >= 0) {
+          this.spaceWaiters.splice(index, 1);
+        }
+        reject(new QueueError({code: QueueErrorCode.QUEUE_ABORTED}));
+      };
+
+      const wrappedResolve = (): void => {
+        if (settled) return;
+        settled = true;
+        this.opts.signal.removeEventListener("abort", onAbort);
+        resolve();
+      };
+
+      this.spaceWaiters.push(wrappedResolve);
+      this.opts.signal.addEventListener("abort", onAbort, {once: true});
+
+      // Re-check after attaching listener to close the race window where
+      // signal.abort() fires between the initial check and addEventListener
+      if (this.opts.signal.aborted) onAbort();
+    });
+  }
+
   getItems(): {args: Args; addedTimeMs: number}[] {
     return this.jobs.map((job) => ({args: job.args, addedTimeMs: job.addedTimeMs}));
   }
 
   dropAllJobs = (): void => {
     this.jobs.clear();
+    this.notifySpaceWaiters();
   };
 
   private runJob = async (): Promise<void> => {
@@ -115,10 +162,25 @@ export class JobItemQueue<Args extends any[], R> {
 
     this.runningJobs = Math.max(0, this.runningJobs - 1);
 
+    // Notify any waiters that space is available
+    this.notifySpaceWaiters();
+
     // Potentially run a new job
     void this.runJob();
   };
 
+  private notifySpaceWaiters(): void {
+    // Compute available slots once to avoid thundering herd: resolved waiters
+    // won't push() until the next microtask, so jobs.length doesn't change
+    // inside this loop. Without the cap we'd wake ALL waiters on a single slot.
+    let available = this.opts.maxLength - this.jobs.length;
+    while (available > 0 && this.spaceWaiters.length > 0) {
+      const resolve = this.spaceWaiters.shift();
+      if (resolve) resolve();
+      available--;
+    }
+  }
+
   private abortAllJobs = (): void => {
     while (this.jobs.length > 0) {
       const job = this.jobs.pop();