2025.9.30 1. 联合前端调试数据产品接口(待完成)

feiyu02

2025-09-30 a3cc1d220f8a1de11874bebceba0130d32157ff1

 src/main/kotlin/cn/flightfeather/supervision/common/executor/BackgroundTaskCtrl.kt

@@ -1,7 +1,8 @@
package cn.flightfeather.supervision.common.executor

import cn.flightfeather.supervision.common.exception.BizException
import cn.flightfeather.supervision.socket.WebSocketSendMessageUtil
import org.springframework.stereotype.Component
import java.time.LocalDateTime
import java.util.concurrent.ConcurrentHashMap
import java.util.concurrent.Executors
import kotlin.jvm.Throws
@@ -20,14 +21,27 @@
    /**
     * 新增任务
     */
    @Throws(IllegalStateException::class)
    @Throws(BizException::class)
    fun newTask(type: BgTaskType, id: String, name: String, task: () -> Boolean): BgTask {
        if (!taskCollection.containsKey(type)) {
            taskCollection[type] = ConcurrentHashMap<String, BgTask>()
        }
        val taskSet = taskCollection[type]!!
        if (taskSet.containsKey(id)) throw IllegalStateException("无法创建任务， 任务[${name}]的id重复")
        val t = BgTask(type, id, name, task)
        // 判断任务id是否存在
        if (taskSet.containsKey(id)) {
            val oldTask = taskSet[id]
            // 当任务已经结束时，直接删除，替换为新任务
            if (oldTask?.taskStatus?.status != TaskStatus.WAITING || oldTask.taskStatus.status != TaskStatus.RUNNING) {
                taskSet.remove(id)
            }
            else {
                throw BizException("无法重复创建任务")
            }
        }
        val t = BgTask(type, id, name, task) { status ->
            // 发送消息
            WebSocketSendMessageUtil.sendBgTaskMessage(status)
        }
        taskSet[id] = t
        return t
    }
@@ -35,24 +49,26 @@
    /**
     * 开始任务
     */
    @Throws(IllegalStateException::class)
    @Throws(BizException::class)
    fun startTask(type: BgTaskType, id: String): BgTask {
        val taskSet = taskCollection[type] ?: throw throw IllegalStateException("无法开启任务，该任务类型[${type.des}]不存在")
        val t = taskSet[id] ?: throw IllegalStateException("无法开启任务，该任务[${id}]不存在")
        val taskSet = taskCollection[type] ?: throw throw BizException("无法开启任务，该任务类型[${type.des}]不存在")
        val t = taskSet[id] ?: throw BizException("无法开启任务，该任务[${id}]不存在")
        return startTask(t)
    }

    @Throws(IllegalStateException::class)
    @Throws(BizException::class)
    fun startTask(task: BgTask): BgTask {
        if (task.taskStatus.status != TaskStatus.WAITING) {
            if (task.taskStatus.status == TaskStatus.RUNNING) {
                throw IllegalStateException("无法开启任务，任务[${task.name}]正在执行")
                throw BizException("无法开启任务，任务[${task.name}]正在执行")
            } else {
                throw IllegalStateException("无法开启任务，任务[${task.name}]已结束")
                throw BizException("无法开启任务，任务[${task.name}]已结束")
            }
        } else {
            task.ready()
            task.future = executorService.submit { task.execute() }
            task.future = executorService.submit {
                task.execute()
            }
            return task
        }
    }
@@ -60,7 +76,7 @@
    /**
     * 新增并开始任务
     */
    @Throws(IllegalStateException::class)
    @Throws(BizException::class)
    fun startNewTask(type: BgTaskType, id: String, name: String, task: () -> Boolean): BgTask {
        val t = newTask(type, id, name, task)
        return startTask(t)
@@ -95,11 +111,11 @@
    /**
     * 强制关闭任务
     */
    @Throws(IllegalStateException::class)
    @Throws(BizException::class)
    fun shutDownTask(type: BgTaskType, id: String?): List<BgTaskStatus?> {
        val taskMap = taskCollection[type] ?: throw IllegalStateException("无法关闭任务，任务类型[${type.des}]未创建")
        val taskMap = taskCollection[type] ?: throw BizException("无法关闭任务，任务类型[${type.des}]未创建")
        return if (id != null) {
            val task = taskMap[id] ?: throw IllegalStateException("无法关闭任务，任务[${id}]不存在")
            val task = taskMap[id] ?: throw BizException("无法关闭任务，任务[${id}]不存在")
            task.shutdown()
            listOf(task.taskStatus)
        } else {
@@ -112,11 +128,11 @@
        }
    }

    @Throws(IllegalStateException::class)
    @Throws(BizException::class)
    fun removeTask(type: BgTaskType, id: String): Boolean {
        val statusList = shutDownTask(type, id)
        if (statusList.isNotEmpty()) {
            val s = statusList.first() ?: throw IllegalStateException("无法移除任务，任务不存在")
            val s = statusList.first() ?: throw BizException("无法移除任务，任务不存在")
            taskCollection[s.type]?.remove(s.id)
            return true
        }