1

api/middleware/schedule/scheduledJobs.js

@@ -43,6 +43,16 @@ class ScheduledJobs {
         this.jobs.push(cleanupOfflineTasksJob);
         console.log('[定时任务] 已启动离线设备任务清理任务');
 
+        // 启动任务超时检查定时任务（每分钟检查一次）
+        const timeoutCheckJob = node_schedule.scheduleJob(config.schedules.monitoringInterval, async () => {
+            await this.checkTaskTimeouts().catch(error => {
+                console.error('[定时任务] 检查任务超时失败:', error);
+            });
+        });
+
+        this.jobs.push(timeoutCheckJob);
+        console.log('[定时任务] 已启动任务超时检查任务');
+
 
         // 执行自动投递任务
         const autoDeliverJob = node_schedule.scheduleJob(config.schedules.autoDeliver, () => {  
@@ -178,6 +188,108 @@ class ScheduledJobs {
         }
     }
 
+    /**
+     * 检查任务超时并强制标记为失败
+     * 检测长时间运行的任务（可能是卡住的），强制标记为失败，释放资源
+     */
+    async checkTaskTimeouts() {
+        try {
+            const Sequelize = require('sequelize');
+            const { task_status, op } = db.models;
+            
+            // 查询所有运行中的任务
+            const runningTasks = await task_status.findAll({
+                where: {
+                    status: 'running'
+                },
+                attributes: ['id', 'sn_code', 'taskType', 'taskName', 'startTime', 'create_time']
+            });
+
+            if (!runningTasks || runningTasks.length === 0) {
+                return;
+            }
+
+            const now = new Date();
+            let timeoutCount = 0;
+
+            for (const task of runningTasks) {
+                const taskData = task.toJSON();
+                const startTime = taskData.startTime ? new Date(taskData.startTime) : (taskData.create_time ? new Date(taskData.create_time) : null);
+                
+                if (!startTime) {
+                    continue;
+                }
+
+                // 获取任务类型的超时时间（默认10分钟）
+                const taskTimeout = config.getTaskTimeout(taskData.taskType) || 10 * 60 * 1000;
+                // 允许额外20%的缓冲时间
+                const maxAllowedTime = taskTimeout * 1.2;
+                const elapsedTime = now.getTime() - startTime.getTime();
+
+                // 如果任务运行时间超过最大允许时间，标记为超时失败
+                if (elapsedTime > maxAllowedTime) {
+                    try {
+                        await task_status.update(
+                            {
+                                status: 'failed',
+                                endTime: now,
+                                duration: elapsedTime,
+                                result: JSON.stringify({
+                                    error: `任务执行超时（运行时间: ${Math.round(elapsedTime / 1000)}秒，超时限制: ${Math.round(maxAllowedTime / 1000)}秒）`,
+                                    timeout: true,
+                                    taskType: taskData.taskType,
+                                    startTime: startTime.toISOString()
+                                }),
+                                progress: 0
+                            },
+                            {
+                                where: { id: taskData.id }
+                            }
+                        );
+
+                        timeoutCount++;
+                        console.warn(`[任务超时检查] 任务 ${taskData.id} (${taskData.taskName}) 运行时间过长，已强制标记为失败`, {
+                            task_id: taskData.id,
+                            sn_code: taskData.sn_code,
+                            taskType: taskData.taskType,
+                            elapsedTime: Math.round(elapsedTime / 1000) + '秒',
+                            maxAllowedTime: Math.round(maxAllowedTime / 1000) + '秒'
+                        });
+
+                        // 如果任务队列中有这个任务，也需要从内存中清理
+                        if (this.taskQueue && typeof this.taskQueue.deviceStatus !== 'undefined') {
+                            const deviceStatus = this.taskQueue.deviceStatus.get(taskData.sn_code);
+                            if (deviceStatus && deviceStatus.currentTask && deviceStatus.currentTask.id === taskData.id) {
+                                // 重置设备状态，允许继续执行下一个任务
+                                deviceStatus.isRunning = false;
+                                deviceStatus.currentTask = null;
+                                deviceStatus.runningCount = Math.max(0, deviceStatus.runningCount - 1);
+                                this.taskQueue.globalRunningCount = Math.max(0, this.taskQueue.globalRunningCount - 1);
+                                
+                                console.log(`[任务超时检查] 已重置设备 ${taskData.sn_code} 的状态，可以继续执行下一个任务`);
+                                
+                                // 尝试继续处理该设备的队列
+                                setTimeout(() => {
+                                    this.taskQueue.processQueue(taskData.sn_code).catch(error => {
+                                        console.error(`[任务超时检查] 继续处理队列失败 (设备: ${taskData.sn_code}):`, error);
+                                    });
+                                }, 100);
+                            }
+                        }
+                    } catch (error) {
+                        console.error(`[任务超时检查] 更新超时任务状态失败 (任务ID: ${taskData.id}):`, error);
+                    }
+                }
+            }
+
+            if (timeoutCount > 0) {
+                console.log(`[任务超时检查] 共检测到 ${timeoutCount} 个超时任务，已强制标记为失败`);
+            }
+        } catch (error) {
+            console.error('[任务超时检查] 执行失败:', error);
+        }
+    }
+
     /**
      * 自动投递任务
      */