emailengine-app 2.68.1 → 2.70.0

package/lib/outbox.js

@@ -3,6 +3,28 @@
 const { submitQueue, redis } = require('./db');
 const { REDIS_PREFIX } = require('../lib/consts');
 
+function formatQueueEntry(job) {
+    let scheduled = job.timestamp + (Number(job.opts.delay) || 0);
+
+    let backoffDelay = Number(job.opts.backoff && job.opts.backoff.delay) || 0;
+    // attemptsMade already includes the failed attempt, so the retry delay is 2^(attemptsMade-1) * base
+    let nextAttempt = job.attemptsMade ? Math.round(job.processedOn + Math.pow(2, job.attemptsMade - 1) * backoffDelay) : scheduled;
+
+    if (job.opts.attempts <= job.attemptsMade) {
+        nextAttempt = false;
+    }
+
+    return Object.assign(job.data, {
+        created: new Date(Number(job.data.created || job.timestamp)).toISOString(),
+        //status: job.name,
+        progress: job.progress,
+        attemptsMade: job.attemptsMade,
+        attempts: job.opts.attempts,
+        scheduled: new Date(scheduled).toISOString(),
+        nextAttempt: nextAttempt ? new Date(nextAttempt).toISOString() : false
+    });
+}
+
 async function list(options) {
     options = options || {};
     let page = Number(options.page) || 0;
@@ -23,26 +45,7 @@ async function list(options) {
         try {
             let job = await submitQueue.getJob(jobId);
             if (job) {
-                let scheduled = job.timestamp + (Number(job.opts.delay) || 0);
-
-                let backoffDelay = Number(job.opts.backoff && job.opts.backoff.delay) || 0;
-                let nextAttempt = job.attemptsMade ? Math.round(job.processedOn + Math.pow(2, job.attemptsMade) * backoffDelay) : scheduled;
-
-                if (job.opts.attempts <= job.attemptsMade) {
-                    nextAttempt = false;
-                }
-
-                messages.push(
-                    Object.assign(job.data, {
-                        created: new Date(Number(job.created || job.timestamp)).toISOString(),
-                        //status: job.name,
-                        progress: job.progress,
-                        attemptsMade: job.attemptsMade,
-                        attempts: job.opts.attempts,
-                        scheduled: new Date(scheduled).toISOString(),
-                        nextAttempt: nextAttempt ? new Date(nextAttempt).toISOString() : false
-                    })
-                );
+                messages.push(formatQueueEntry(job));
             }
         } catch (err) {
             logger.error({ msg: 'Failed to retrieve message info from outbox', jobId, err });
@@ -105,15 +108,6 @@ async function get(options) {
         return false;
     }
 
-    let scheduled = job.timestamp + (Number(job.opts.delay) || 0);
-
-    let backoffDelay = Number(job.opts.backoff && job.opts.backoff.delay) || 0;
-    let nextAttempt = job.attemptsMade ? Math.round(job.processedOn + Math.pow(2, job.attemptsMade) * backoffDelay) : scheduled;
-
-    if (job.opts.attempts <= job.attemptsMade) {
-        nextAttempt = false;
-    }
-
     try {
         let queueEntryBuf = await redis.hgetBuffer(`${REDIS_PREFIX}iaq:${job.data.account}`, job.data.queueId);
         if (!queueEntryBuf) {
@@ -124,17 +118,7 @@ async function get(options) {
         throw err;
     }
 
-    let response = Object.assign(job.data, {
-        created: new Date(Number(job.created || job.timestamp)).toISOString(),
-        //status: job.name,
-        progress: job.progress,
-        attemptsMade: job.attemptsMade,
-        attempts: job.opts.attempts,
-        scheduled: new Date(scheduled).toISOString(),
-        nextAttempt: nextAttempt ? new Date(nextAttempt).toISOString() : false
-    });
-
-    return response;
+    return formatQueueEntry(job);
 }
 
 module.exports = { list, del, get };

package/lib/redis-operations.js

@@ -228,7 +228,7 @@ class RedisTransaction {
      * @returns {Promise<Array>} Array of values from successful commands
      */
     async execOrThrow() {
-        const { results, values, error } = await this.exec();
+        const { values, error } = await this.exec();
 
         if (error) {
             throw error;

package/lib/reject-worker-calls.js

@@ -0,0 +1,42 @@
+'use strict';
+
+/**
+ * Reject every pending cross-thread call routed to a worker thread that has
+ * terminated. Without this, a call placed against a worker that then crashes or
+ * is force-restarted keeps waiting until its own timeout fires - which can be
+ * minutes (the submitMessage floor) or hours (a large X-EE-Timeout). Rejecting
+ * here lets the caller fail fast with a retryable error the instant the worker
+ * is known to be gone.
+ *
+ * The stored `reject` wrapper clears the entry's timeout, so we only need to
+ * drop the entry from the queue and invoke it.
+ *
+ * @param {Map} callQueue - mid -> { resolve, reject, timer, worker }
+ * @param {Worker} worker - The terminated worker thread
+ * @param {Error} err - Rejection reason. May be a shared instance reused across
+ *   concurrent rejections, so callers must not attach per-call fields to it.
+ * @returns {number} Number of pending calls that were rejected
+ */
+function rejectWorkerCalls(callQueue, worker, err) {
+    let rejected = 0;
+
+    // Deleting the current entry while iterating a Map is safe in JS.
+    for (let [mid, entry] of callQueue) {
+        if (entry.worker !== worker) {
+            continue;
+        }
+
+        callQueue.delete(mid);
+        try {
+            entry.reject(err);
+        } catch (rejectErr) {
+            // A consumer that throws synchronously from its rejection path must
+            // not stop us from cleaning up the remaining pending calls.
+        }
+        rejected++;
+    }
+
+    return rejected;
+}
+
+module.exports = { rejectWorkerCalls };