@workglow/job-queue 0.0.109 → 0.0.110

package/dist/browser.js

@@ -512,6 +512,8 @@ class JobQueueWorker {
   pollIntervalMs;
   events = new EventEmitter2;
   running = false;
+  wakeResolve = null;
+  wakeTimer = null;
   activeJobAbortControllers = new Map;
   processingTimes = new Map;
   constructor(jobClass, options) {
@@ -531,11 +533,22 @@ class JobQueueWorker {
     this.processJobs();
     return this;
   }
+  notify() {
+    if (this.wakeResolve) {
+      if (this.wakeTimer) {
+        clearTimeout(this.wakeTimer);
+        this.wakeTimer = null;
+      }
+      this.wakeResolve();
+      this.wakeResolve = null;
+    }
+  }
   async stop() {
     if (!this.running) {
       return this;
     }
     this.running = false;
+    this.notify();
     const size = await this.storage.size(JobStatus3.PROCESSING);
     const sleepTime = Math.max(100, size * 2);
     await sleep(sleepTime);
@@ -585,26 +598,52 @@ class JobQueueWorker {
     return this.storageToClass(job);
   }
   async processJobs() {
-    if (!this.running) {
-      return;
-    }
-    try {
-      await this.checkForAbortingJobs();
-      const canProceed = await this.limiter.canProceed();
-      if (canProceed) {
-        const job = await this.next();
-        if (job) {
-          this.processSingleJob(job);
+    while (this.running) {
+      try {
+        await this.checkForAbortingJobs();
+        const canProceed = await this.limiter.canProceed();
+        if (canProceed) {
+          const job = await this.next();
+          if (job) {
+            this.processSingleJob(job);
+            continue;
+          }
+        }
+        if (canProceed) {
+          const delay = await this.getIdleDelay();
+          await this.waitForWakeOrTimeout(delay);
         } else {
-          await sleep(this.pollIntervalMs);
+          await this.waitForWakeOrTimeout(this.pollIntervalMs);
         }
-      }
-    } finally {
-      if (this.running) {
-        setTimeout(() => this.processJobs(), this.pollIntervalMs);
+      } catch {
+        await sleep(this.pollIntervalMs);
       }
     }
   }
+  async getIdleDelay() {
+    try {
+      const pending = await this.storage.peek(JobStatus3.PENDING, 1);
+      if (pending.length > 0 && pending[0].run_after) {
+        const delay = new Date(pending[0].run_after).getTime() - Date.now();
+        if (delay > 0) {
+          return Math.min(delay, this.pollIntervalMs);
+        }
+      }
+    } catch {}
+    return this.pollIntervalMs;
+  }
+  waitForWakeOrTimeout(timeoutMs) {
+    return new Promise((resolve) => {
+      this.wakeTimer = setTimeout(() => {
+        this.wakeTimer = null;
+        this.wakeResolve = null;
+        resolve();
+      }, timeoutMs);
+      this.wakeResolve = () => {
+        resolve();
+      };
+    });
+  }
   async checkForAbortingJobs() {
     const abortingJobs = await this.storage.peek(JobStatus3.ABORTING);
     for (const jobData of abortingJobs) {
@@ -808,6 +847,7 @@ class JobQueueServer {
   clients = new Set;
   running = false;
   cleanupTimer = null;
+  storageUnsubscribe = null;
   stats = {
     totalJobs: 0,
     completedJobs: 0,
@@ -837,6 +877,13 @@ class JobQueueServer {
     this.running = true;
     this.events.emit("server_start", this.queueName);
     await this.fixupJobs();
+    try {
+      this.storageUnsubscribe = this.storage.subscribeToChanges((change) => {
+        if (change.type === "INSERT" || change.type === "UPDATE" && change.new?.status === JobStatus4.PENDING) {
+          this.notifyWorkers();
+        }
+      });
+    } catch {}
     await Promise.all(this.workers.map((worker) => worker.start()));
     this.startCleanupLoop();
     return this;
@@ -846,6 +893,10 @@ class JobQueueServer {
       return this;
     }
     this.running = false;
+    if (this.storageUnsubscribe) {
+      this.storageUnsubscribe();
+      this.storageUnsubscribe = null;
+    }
     if (this.cleanupTimer) {
       clearTimeout(this.cleanupTimer);
       this.cleanupTimer = null;
@@ -890,6 +941,11 @@ class JobQueueServer {
   removeClient(client) {
     this.clients.delete(client);
   }
+  notifyWorkers() {
+    for (const worker of this.workers) {
+      worker.notify();
+    }
+  }
   on(event, listener) {
     this.events.on(event, listener);
   }
@@ -922,6 +978,7 @@ class JobQueueServer {
       if (this.deleteAfterCompletionMs === 0) {
         await this.storage.delete(jobId);
       }
+      this.notifyWorkers();
     });
     worker.on("job_error", async (jobId, error, errorCode) => {
       this.stats = { ...this.stats, failedJobs: this.stats.failedJobs + 1 };
@@ -930,6 +987,7 @@ class JobQueueServer {
       if (this.deleteAfterFailureMs === 0) {
         await this.storage.delete(jobId);
       }
+      this.notifyWorkers();
     });
     worker.on("job_disabled", async (jobId) => {
       this.stats = { ...this.stats, disabledJobs: this.stats.disabledJobs + 1 };
@@ -938,6 +996,7 @@ class JobQueueServer {
       if (this.deleteAfterDisabledMs === 0) {
         await this.storage.delete(jobId);
       }
+      this.notifyWorkers();
     });
     worker.on("job_retry", (jobId, runAfter) => {
       this.stats = { ...this.stats, retriedJobs: this.stats.retriedJobs + 1 };
@@ -1091,26 +1150,21 @@ var CONCURRENT_JOB_LIMITER = createServiceToken2("jobqueue.limiter.concurrent");
 class ConcurrencyLimiter {
   currentRunningJobs = 0;
   maxConcurrentJobs;
-  timeSliceInMilliseconds;
   nextAllowedStartTime = new Date;
-  constructor(maxConcurrentJobs, timeSliceInMilliseconds = 1000) {
+  constructor(maxConcurrentJobs) {
     this.maxConcurrentJobs = maxConcurrentJobs;
-    this.timeSliceInMilliseconds = timeSliceInMilliseconds;
   }
   async canProceed() {
     return this.currentRunningJobs < this.maxConcurrentJobs && Date.now() >= this.nextAllowedStartTime.getTime();
   }
   async recordJobStart() {
-    if (this.currentRunningJobs < this.maxConcurrentJobs) {
-      this.currentRunningJobs++;
-      this.nextAllowedStartTime = new Date(Date.now() + this.timeSliceInMilliseconds);
-    }
+    this.currentRunningJobs++;
   }
   async recordJobCompletion() {
     this.currentRunningJobs = Math.max(0, this.currentRunningJobs - 1);
   }
   async getNextAvailableTime() {
-    return this.currentRunningJobs < this.maxConcurrentJobs ? new Date : new Date(Date.now() + this.timeSliceInMilliseconds);
+    return this.currentRunningJobs > this.maxConcurrentJobs ? new Date : new Date(Date.now() - 1);
   }
   async setNextAvailableTime(date) {
     if (date > this.nextAllowedStartTime) {
@@ -1348,4 +1402,4 @@ export {
   AbortSignalJobError
 };
 
-//# debugId=E4B5573CEED9ADF864756E2164756E21
+//# debugId=9DE06357F3B3B37164756E2164756E21