@resolveio/server-lib 22.2.43 → 22.2.46

package/managers/worker-dispatcher.manager.js

@@ -272,8 +272,61 @@ var WorkerDispatcherManager = /** @class */ (function () {
             this.dispatchQueue();
         }
     };
-    WorkerDispatcherManager.prototype.disconnectWorker = function (workerId) {
+    WorkerDispatcherManager.prototype.failActiveWorkerTask = function (task, reason) {
+        var _a;
+        if (!task || !task.taskId) {
+            return;
+        }
+        var pendingTask = this._pendingTasks.get(task.taskId);
+        if (pendingTask) {
+            clearTimeout(pendingTask.timeout);
+            if (pendingTask.promise) {
+                pendingTask.promise.reject(reason);
+            }
+            this._pendingTasks.delete(task.taskId);
+        }
+        this._taskTimings.delete(task.taskId);
+        if (this._clientRequests[task.taskId]) {
+            delete this._clientRequests[task.taskId];
+        }
+        if (!((_a = task.userContext) === null || _a === void 0 ? void 0 : _a.id_ws) || task.messageId === undefined || task.messageId === null) {
+            return;
+        }
+        var clientWS = this._websocketManager ? this._websocketManager.getWebSocket(task.userContext.id_ws) : null;
+        if (!clientWS) {
+            return;
+        }
+        var response = {
+            messageId: task.messageId,
+            hasError: true,
+            data: reason
+        };
+        this._websocketManager.send(clientWS, response);
+    };
+    WorkerDispatcherManager.prototype.disconnectWorker = function (workerId, reason) {
+        var e_4, _a;
+        var _b;
+        if (reason === void 0) { reason = 'Worker disconnected.'; }
+        var worker = this._workers.find(function (w) { return w.id === workerId; });
         this._workers = this._workers.filter(function (w) { return w.id !== workerId; });
+        if (!worker || !((_b = worker.activeTasks) === null || _b === void 0 ? void 0 : _b.length)) {
+            return;
+        }
+        var activeTasks = __spreadArray([], __read(worker.activeTasks), false);
+        worker.activeTasks = [];
+        try {
+            for (var activeTasks_1 = __values(activeTasks), activeTasks_1_1 = activeTasks_1.next(); !activeTasks_1_1.done; activeTasks_1_1 = activeTasks_1.next()) {
+                var activeTask = activeTasks_1_1.value;
+                this.failActiveWorkerTask(activeTask, reason);
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (activeTasks_1_1 && !activeTasks_1_1.done && (_a = activeTasks_1.return)) _a.call(activeTasks_1);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
     };
     WorkerDispatcherManager.prototype.hasWorkers = function () {
         return this._workers.length > 0;
@@ -545,7 +598,7 @@ var WorkerDispatcherManager = /** @class */ (function () {
      * The main loop that assigns tasks from _taskQueue to any worker that has capacity.
      */
     WorkerDispatcherManager.prototype.dispatchQueue = function () {
-        var e_4, _a;
+        var e_5, _a;
         var _this = this;
         if (!this._taskQueue.length) {
             return;
@@ -576,7 +629,7 @@ var WorkerDispatcherManager = /** @class */ (function () {
         while (this._taskQueue.length > 0) {
             var assigned = false;
             try {
-                for (var priorityMatchers_1 = (e_4 = void 0, __values(priorityMatchers)), priorityMatchers_1_1 = priorityMatchers_1.next(); !priorityMatchers_1_1.done; priorityMatchers_1_1 = priorityMatchers_1.next()) {
+                for (var priorityMatchers_1 = (e_5 = void 0, __values(priorityMatchers)), priorityMatchers_1_1 = priorityMatchers_1.next(); !priorityMatchers_1_1.done; priorityMatchers_1_1 = priorityMatchers_1.next()) {
                     var matcher = priorityMatchers_1_1.value;
                     if (tryAssignTask(matcher)) {
                         assigned = true;
@@ -584,12 +637,12 @@ var WorkerDispatcherManager = /** @class */ (function () {
                     }
                 }
             }
-            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+            catch (e_5_1) { e_5 = { error: e_5_1 }; }
             finally {
                 try {
                     if (priorityMatchers_1_1 && !priorityMatchers_1_1.done && (_a = priorityMatchers_1.return)) _a.call(priorityMatchers_1);
                 }
-                finally { if (e_4) throw e_4.error; }
+                finally { if (e_5) throw e_5.error; }
             }
             if (!assigned) {
                 this.logNoWorkerAvailability();
@@ -871,17 +924,11 @@ var WorkerDispatcherManager = /** @class */ (function () {
             this.logWorkerEvent('workerTaskAssigned', logPayload);
         }
         var timeoutHandle = setTimeout(function () {
-            var pending = _this._pendingTasks.get(task.taskId);
             var timeoutAt = Date.now();
             var queuedAt = timing.queuedAt;
             var queueWaitMs = queuedAt ? (0, common_1.round)(dispatchedAt - queuedAt) : null;
             var dispatchToTimeoutMs = (0, common_1.round)(timeoutAt - dispatchedAt);
-            if (pending) {
-                if (pending.promise) {
-                    pending.promise.reject('Task timed out after 2m in WorkerDispatcherManager for method: ' + task.method);
-                }
-                _this._pendingTasks.delete(task.taskId);
-            }
+            var timeoutMessage = 'Task timed out after 2m in WorkerDispatcherManager for method: ' + task.method;
             var publicationInfo = _this.getPublicationLogInfo(task.method, task.params);
             var logPayload = {
                 taskId: task.taskId,
@@ -901,17 +948,18 @@ var WorkerDispatcherManager = /** @class */ (function () {
                 Object.assign(logPayload, publicationInfo);
             }
             _this.logWorkerEvent('workerTaskTimeout', logPayload);
-            worker.activeTasks = worker.activeTasks.filter(function (a) { return a.taskId !== task.taskId; });
-            _this._taskTimings.delete(task.taskId);
-            if (task.userContext && task.userContext.id_ws) {
-                var timeoutRes = {
-                    messageId: task.messageId,
-                    hasError: true,
-                    data: 'Task timed out after 2m in WorkerDispatcherManager for method: ' + task.method
-                };
-                var clientWS = _this._websocketManager.getWebSocket(task.userContext.id_ws);
-                if (clientWS) {
-                    _this._websocketManager.send(clientWS, timeoutRes);
+            _this.disconnectWorker(worker.id, timeoutMessage);
+            if (worker.ws && worker.ws.readyState !== WebSocket.CLOSED) {
+                try {
+                    worker.ws.close();
+                }
+                catch (_a) {
+                    try {
+                        worker.ws.terminate();
+                    }
+                    catch (_b) {
+                        // Ignore socket cleanup errors after timeout.
+                    }
                 }
             }
         }, method.timeoutOverride || (1000 * 60 * 2));
@@ -938,7 +986,7 @@ var WorkerDispatcherManager = /** @class */ (function () {
         }
     };
     WorkerDispatcherManager.prototype.logNoWorkerAvailability = function () {
-        var e_5, _a;
+        var e_6, _a;
         var _this = this;
         if (!this.shouldDebug()) {
             return;
@@ -981,12 +1029,12 @@ var WorkerDispatcherManager = /** @class */ (function () {
                 _loop_1(task);
             }
         }
-        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        catch (e_6_1) { e_6 = { error: e_6_1 }; }
         finally {
             try {
                 if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
             }
-            finally { if (e_5) throw e_5.error; }
+            finally { if (e_6) throw e_6.error; }
         }
     };
     WorkerDispatcherManager.prototype.shouldDebug = function () {
@@ -1165,22 +1213,18 @@ var WorkerDispatcherManager = /** @class */ (function () {
         if (ws.readyState !== WebSocket.OPEN) {
             if (typeof payload !== 'string') {
                 var task_1 = payload;
-                this._taskQueue.unshift(task_1);
-                this.dispatchQueue();
-                this.disconnectWorker(ws['id_worker']);
-                ws.close();
-                var pendingTask = this._pendingTasks.get(task_1.taskId);
-                if (pendingTask) {
-                    clearTimeout(pendingTask.timeout);
-                    this._pendingTasks.delete(task_1.taskId);
-                    if (pendingTask.promise) {
-                        pendingTask.promise.reject('Worker socket not open.');
-                    }
+                this.disconnectWorker(ws['id_worker'], 'Worker socket not open for method: ' + task_1.method);
+                try {
+                    ws.close();
                 }
+                catch (_a) { }
             }
             else {
-                this.disconnectWorker(ws['id_worker']);
-                ws.close();
+                this.disconnectWorker(ws['id_worker'], 'Worker socket not open.');
+                try {
+                    ws.close();
+                }
+                catch (_b) { }
             }
             return;
         }
@@ -1189,8 +1233,11 @@ var WorkerDispatcherManager = /** @class */ (function () {
                 ws.send(payload);
             }
             catch (err) {
-                this.disconnectWorker(ws['id_worker']);
-                ws.close();
+                this.disconnectWorker(ws['id_worker'], 'Failed to send worker payload: ' + (err === null || err === void 0 ? void 0 : err.toString()));
+                try {
+                    ws.close();
+                }
+                catch (_c) { }
                 console.error('Failed to send worker payload:', err);
             }
             return;
@@ -1201,22 +1248,15 @@ var WorkerDispatcherManager = /** @class */ (function () {
             ws.send(payloadBuffer);
         }
         catch (err) {
-            this._taskQueue.unshift(task);
-            this.dispatchQueue();
             if (this._methodManager.getEnableDebug()) {
                 console.log(new Date(), 'Sending to Server', task);
             }
-            this.disconnectWorker(ws['id_worker']);
-            ws.close();
-            console.error('Failed to send worker response:', err);
-            var pendingTask = this._pendingTasks.get(task.taskId);
-            if (pendingTask) {
-                clearTimeout(pendingTask.timeout);
-                this._pendingTasks.delete(task.taskId);
-                if (pendingTask.promise) {
-                    pendingTask.promise.reject('Failed to send worker response: ' + (err === null || err === void 0 ? void 0 : err.toString()));
-                }
+            this.disconnectWorker(ws['id_worker'], 'Failed to send worker response for method: ' + task.method);
+            try {
+                ws.close();
             }
+            catch (_d) { }
+            console.error('Failed to send worker response:', err);
         }
     };
     return WorkerDispatcherManager;