qdone 2.0.28-alpha → 2.0.30-alpha

package/commonjs/src/scheduler/queueManager.js

@@ -2,55 +2,18 @@
 /**
  * Component to manange what queues are being listened to and in what order.
  */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueueManager = void 0;
-var chalk_1 = __importDefault(require("chalk"));
-var debug_1 = __importDefault(require("debug"));
-var qrlCache_js_1 = require("../qrlCache.js");
-var idleQueues_js_1 = require("../idleQueues.js");
-var debug = (0, debug_1.default)('qdone:queueManager');
-var QueueManager = /** @class */ (function () {
-    function QueueManager(opt, queues, resolveSeconds) {
-        if (resolveSeconds === void 0) { resolveSeconds = 10; }
+const chalk_1 = __importDefault(require("chalk"));
+const debug_1 = __importDefault(require("debug"));
+const qrlCache_js_1 = require("../qrlCache.js");
+const idleQueues_js_1 = require("../idleQueues.js");
+const debug = (0, debug_1.default)('qdone:queueManager');
+class QueueManager {
+    constructor(opt, queues, resolveSeconds = 10) {
         this.opt = opt;
         this.queues = queues;
         this.resolveSeconds = resolveSeconds;
@@ -62,173 +25,136 @@ var QueueManager = /** @class */ (function () {
     }
     // Sends a queue to the icehouse, where it waits for a while before being
     // checked again
-    QueueManager.prototype.updateIcehouse = function (qrl, emptyReceive) {
-        var foundEntry = !!this.icehouse[qrl];
-        var _a = this.icehouse[qrl] || {
+    updateIcehouse(qrl, emptyReceive) {
+        const foundEntry = !!this.icehouse[qrl];
+        const { lastCheck, secondsToWait, numEmptyReceives } = this.icehouse[qrl] || {
             lastCheck: new Date(),
             secondsToWait: Math.round(20 + 10 * Math.random()),
             numEmptyReceives: 0 + emptyReceive
-        }, lastCheck = _a.lastCheck, secondsToWait = _a.secondsToWait, numEmptyReceives = _a.numEmptyReceives;
+        };
         if (emptyReceive) {
-            var now = new Date();
-            var secondsElapsed = lastCheck - now;
-            var minWait = 10;
-            var maxWait = 600;
-            var baseSeconds = Math.pow(numEmptyReceives, 2) * 20;
-            var jitterSeconds = Math.round((Math.random() - 0.5) * baseSeconds);
-            var newSecondsToWait = Math.max(minWait, Math.min(maxWait, baseSeconds + jitterSeconds));
-            var newEntry = { lastCheck: now, secondsToWait: newSecondsToWait, numEmptyReceives: numEmptyReceives + 1 };
+            const now = new Date();
+            const secondsElapsed = lastCheck - now;
+            const minWait = 10;
+            const maxWait = 120;
+            const baseSeconds = numEmptyReceives ** 2 * 20;
+            const jitterSeconds = Math.round((Math.random() - 0.5) * baseSeconds);
+            const newSecondsToWait = Math.max(minWait, Math.min(maxWait, baseSeconds + jitterSeconds));
+            const newEntry = { lastCheck: now, secondsToWait: newSecondsToWait, numEmptyReceives: numEmptyReceives + 1 };
             this.icehouse[qrl] = newEntry;
             if (this.opt.verbose) {
                 console.error(chalk_1.default.blue('Sending queue to icehouse'), qrl, chalk_1.default.blue('for'), newSecondsToWait, chalk_1.default.blue('seconds'));
             }
-            debug({ foundEntry: foundEntry, newEntry: newEntry, lastCheck: lastCheck, secondsToWait: secondsToWait, now: now, secondsElapsed: secondsElapsed, maxWait: maxWait, minWait: minWait, baseSeconds: baseSeconds, jitterSeconds: jitterSeconds });
+            debug({ foundEntry, newEntry, lastCheck, secondsToWait, now, secondsElapsed, maxWait, minWait, baseSeconds, jitterSeconds });
         }
         else {
             delete this.icehouse[qrl];
         }
-    };
+    }
     // Returns true if the queue should be kept in the icehouse
-    QueueManager.prototype.keepInIcehouse = function (qrl, now) {
+    keepInIcehouse(qrl, now) {
         if (this.icehouse[qrl]) {
-            var _a = this.icehouse[qrl], lastCheck = _a.lastCheck, secondsToWait = _a.secondsToWait;
-            var secondsElapsed = Math.round((now - lastCheck) / 1000);
-            debug({ icehouseCheck: { qrl: qrl, lastCheck: lastCheck, secondsToWait: secondsToWait, secondsElapsed: secondsElapsed } });
-            var letOut = secondsElapsed > secondsToWait;
-            if (letOut && this.opt.verbose) {
-                console.error(chalk_1.default.blue('Coming out of icehouse:'), qrl);
+            const { lastCheck, secondsToWait } = this.icehouse[qrl];
+            const secondsElapsed = Math.round((now - lastCheck) / 1000);
+            debug({ icehouseCheck: { qrl, lastCheck, secondsToWait, secondsElapsed } });
+            const letOut = secondsElapsed > secondsToWait;
+            if (letOut) {
+                delete this.icehouse[qrl];
+                if (this.opt.verbose) {
+                    console.error(chalk_1.default.blue('Coming out of icehouse:'), qrl);
+                }
             }
             return !letOut;
         }
         else {
             return false;
         }
-    };
-    QueueManager.prototype.resolveQueues = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var qnames, pairs, now, filteredPairs, activePairs;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        clearTimeout(this.resolveTimeout);
-                        if (this.shutdownRequested)
-                            return [2 /*return*/];
-                        this.resolveTimeout = setTimeout(function () {
-                            _this.resolvePromise = _this.resolveQueues();
-                        }, this.resolveSeconds * 1000);
-                        if (this.opt.verbose) {
-                            console.error(chalk_1.default.blue('Will resolve queues again in ' + this.resolveSeconds + ' seconds'));
-                        }
-                        qnames = this.queues.map(function (queue) { return (0, qrlCache_js_1.normalizeQueueName)(queue, _this.opt); });
-                        return [4 /*yield*/, (0, qrlCache_js_1.getQnameUrlPairs)(qnames, this.opt)];
-                    case 1:
-                        pairs = _a.sent();
-                        if (this.opt.verbose)
-                            console.error(chalk_1.default.blue('Resolving queues:'));
-                        if (this.shutdownRequested)
-                            return [2 /*return*/];
-                        now = new Date();
-                        filteredPairs = pairs
-                            // first failed
-                            .filter(function (_a) {
-                            var qname = _a.qname, qrl = _a.qrl;
-                            var suf = _this.opt.failSuffix + (_this.opt.fifo ? '.fifo' : '');
-                            var isFailQueue = qname.slice(-suf.length) === suf;
-                            return _this.opt.includeFailed ? true : !isFailQueue;
-                        })
-                            // next fifo
-                            .filter(function (_a) {
-                            var qname = _a.qname, qrl = _a.qrl;
-                            var isFifo = qname.endsWith('.fifo');
-                            return _this.opt.fifo ? isFifo : true;
-                        })
-                            // then icehouse
-                            .filter(function (_a) {
-                            var qname = _a.qname, qrl = _a.qrl;
-                            return !_this.keepInIcehouse(qrl, now);
-                        });
-                        activePairs = [];
-                        if (!this.opt.activeOnly) return [3 /*break*/, 3];
-                        if (this.opt.verbose) {
-                            console.error(chalk_1.default.blue('  checking active only'));
-                        }
-                        return [4 /*yield*/, Promise.all(filteredPairs.map(function (_a) {
-                                var qname = _a.qname, qrl = _a.qrl;
-                                return __awaiter(_this, void 0, void 0, function () {
-                                    var idle;
-                                    return __generator(this, function (_b) {
-                                        switch (_b.label) {
-                                            case 0: return [4 /*yield*/, (0, idleQueues_js_1.cheapIdleCheck)(qname, qrl, this.opt)];
-                                            case 1:
-                                                idle = (_b.sent()).result.idle;
-                                                debug({ idle: idle, qname: qname });
-                                                if (!idle)
-                                                    activePairs.push({ qname: qname, qrl: qrl });
-                                                return [2 /*return*/];
-                                        }
-                                    });
-                                });
-                            }))];
-                    case 2:
-                        _a.sent();
-                        _a.label = 3;
-                    case 3:
-                        if (this.shutdownRequested)
-                            return [2 /*return*/];
-                        // Figure out which queues we want to listen on, choosing between active and
-                        // all, filtering out failed queues if the user wants that
-                        this.selectedPairs = (this.opt.activeOnly ? activePairs : filteredPairs);
-                        // Randomize order
-                        this.selectedPairs.sort(function () { return 0.5 - Math.random(); });
-                        if (this.opt.verbose)
-                            console.error(chalk_1.default.blue('  selected:\n  ') + this.selectedPairs.map(function (_a) {
-                                var qname = _a.qname;
-                                return qname;
-                            }).join('\n  '));
-                        debug('selectedPairs', this.selectedPairs);
-                        // Finished resolving
-                        if (this.opt.verbose) {
-                            console.error(chalk_1.default.blue('Done resolving'));
-                            console.error();
-                        }
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
+    }
+    async resolveQueues() {
+        clearTimeout(this.resolveTimeout);
+        if (this.shutdownRequested)
+            return;
+        this.resolveTimeout = setTimeout(() => {
+            this.resolvePromise = this.resolveQueues();
+        }, this.resolveSeconds * 1000);
+        if (this.opt.verbose) {
+            console.error(chalk_1.default.blue('Will resolve queues again in ' + this.resolveSeconds + ' seconds'));
+        }
+        // Start processing
+        const qnames = this.queues.map(queue => (0, qrlCache_js_1.normalizeQueueName)(queue, this.opt));
+        const pairs = await (0, qrlCache_js_1.getQnameUrlPairs)(qnames, this.opt);
+        if (this.opt.verbose)
+            console.error(chalk_1.default.blue('Resolving queues:'), pairs.map(({ qname }) => qname));
+        if (this.shutdownRequested)
+            return;
+        // Filter out queues
+        const now = new Date();
+        const filteredPairs = pairs
+            // first failed
+            .filter(({ qname, qrl }) => {
+            const suf = this.opt.failSuffix + (this.opt.fifo ? '.fifo' : '');
+            const isFailQueue = qname.slice(-suf.length) === suf;
+            return this.opt.includeFailed ? true : !isFailQueue;
+        })
+            // next fifo
+            .filter(({ qname, qrl }) => {
+            const isFifo = qname.endsWith('.fifo');
+            return this.opt.fifo ? isFifo : true;
+        })
+            // next dead
+            .filter(({ qname, qrl }) => {
+            const isFifo = qname.endsWith('.fifo');
+            const isDead = isFifo ? qname.endsWith('_dead.fifo') : qname.endsWith('_dead');
+            return !isDead;
+        })
+            // then icehouse
+            .filter(({ qname, qrl }) => !this.keepInIcehouse(qrl, now));
+        // Figure out which pairs are active
+        const activePairs = [];
+        if (this.opt.activeOnly) {
+            if (this.opt.verbose) {
+                console.error(chalk_1.default.blue('  checking active only'));
+            }
+            await Promise.all(filteredPairs.map(async ({ qname, qrl }) => {
+                const { result: { idle } } = await (0, idleQueues_js_1.cheapIdleCheck)(qname, qrl, this.opt);
+                debug({ idle, qname });
+                if (!idle)
+                    activePairs.push({ qname, qrl });
+            }));
+        }
+        if (this.shutdownRequested)
+            return;
+        // Figure out which queues we want to listen on, choosing between active and
+        // all, filtering out failed queues if the user wants that
+        this.selectedPairs = (this.opt.activeOnly ? activePairs : filteredPairs);
+        // Randomize order
+        this.selectedPairs.sort(() => 0.5 - Math.random());
+        if (this.opt.verbose)
+            console.error(chalk_1.default.blue('  selected:\n  ') + this.selectedPairs.map(({ qname }) => qname).join('\n  '));
+        debug('selectedPairs', this.selectedPairs);
+        // Finished resolving
+        if (this.opt.verbose) {
+            console.error(chalk_1.default.blue('Done resolving'));
+            console.error();
+        }
+    }
     // Return the next queue in the lineup
-    QueueManager.prototype.nextPair = function () {
-        var pair = this.selectedPairs.shift();
+    nextPair() {
+        const pair = this.selectedPairs.shift();
         this.selectedPairs.push(pair);
         return pair;
-    };
-    QueueManager.prototype.getPairs = function () {
-        var _this = this;
-        var now = new Date();
-        return this.selectedPairs.filter(function (_a) {
-            var qname = _a.qname, qrl = _a.qrl;
-            return !_this.keepInIcehouse(qrl, now);
-        });
-    };
-    QueueManager.prototype.shutdown = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        this.shutdownRequested = true;
-                        clearTimeout(this.resolveTimeout);
-                        if (this.opt.verbose) {
-                            console.error(chalk_1.default.blue('Waiting for queues to resolve'));
-                        }
-                        return [4 /*yield*/, this.resolvePromise];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    return QueueManager;
-}());
+    }
+    getPairs() {
+        const now = new Date();
+        return this.selectedPairs.filter(({ qname, qrl }) => !this.keepInIcehouse(qrl, now));
+    }
+    async shutdown() {
+        this.shutdownRequested = true;
+        clearTimeout(this.resolveTimeout);
+        if (this.opt.verbose) {
+            console.error(chalk_1.default.blue('Waiting for queues to resolve'));
+        }
+        await this.resolvePromise;
+    }
+}
 exports.QueueManager = QueueManager;

package/commonjs/src/scheduler/systemMonitor.js

@@ -5,45 +5,41 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SystemMonitor = void 0;
-var SystemMonitor = /** @class */ (function () {
-    function SystemMonitor(reportCallback, reportSeconds) {
-        if (reportSeconds === void 0) { reportSeconds = 1; }
+class SystemMonitor {
+    constructor(reportCallback, reportSeconds = 1) {
         this.reportCallback = reportCallback || console.log;
         this.reportSeconds = reportSeconds;
         this.measurements = [];
         this.measure();
         this.reportLatency();
     }
-    SystemMonitor.prototype.measure = function () {
-        var _this = this;
+    measure() {
         clearTimeout(this.measureTimeout);
-        var start = new Date();
-        this.measureTimeout = setTimeout(function () {
-            var latency = new Date() - start;
-            _this.measurements.push(latency);
-            if (_this.measurements.length > 1000)
-                _this.measurements.shift();
-            _this.measure();
+        const start = new Date();
+        this.measureTimeout = setTimeout(() => {
+            const latency = new Date() - start;
+            this.measurements.push(latency);
+            if (this.measurements.length > 1000)
+                this.measurements.shift();
+            this.measure();
         });
-    };
-    SystemMonitor.prototype.getLatency = function () {
-        return this.measurements.length ? this.measurements.reduce(function (a, b) { return a + b; }, 0) / this.measurements.length : 0;
-    };
-    SystemMonitor.prototype.reportLatency = function () {
-        var _this = this;
+    }
+    getLatency() {
+        return this.measurements.length ? this.measurements.reduce((a, b) => a + b, 0) / this.measurements.length : 0;
+    }
+    reportLatency() {
         clearTimeout(this.reportTimeout);
-        this.reportTimeout = setTimeout(function () {
-            var latency = _this.getLatency();
+        this.reportTimeout = setTimeout(() => {
+            const latency = this.getLatency();
             // console.log({ latency })
-            if (_this.reportCallback)
-                _this.reportCallback(latency);
-            _this.reportLatency();
+            if (this.reportCallback)
+                this.reportCallback(latency);
+            this.reportLatency();
         }, this.reportSeconds * 1000);
-    };
-    SystemMonitor.prototype.shutdown = function () {
+    }
+    shutdown() {
         clearTimeout(this.measureTimeout);
         clearTimeout(this.reportTimeout);
-    };
-    return SystemMonitor;
-}());
+    }
+}
 exports.SystemMonitor = SystemMonitor;