1.更新 MachineProcController 接口和实现

2.更新 MachineTaskController 接口和实现

agent/src/main/java/cn/reghao/bnt/agent/AgentApp.java

@@ -5,8 +5,6 @@ import ch.qos.logback.classic.Logger;
 import ch.qos.logback.classic.LoggerContext;
 import cn.reghao.bnt.agent.config.ConfigFile;
 import cn.reghao.bnt.agent.config.DagentConfig;
-import cn.reghao.bnt.agent.task.ImageCleanTask;
-import cn.reghao.bnt.agent.task.ProcScanTask;
 import cn.reghao.bnt.agent.ws.WsClient;
 import cn.reghao.bnt.common.agent.app.iface.AppDeploy;
 import cn.reghao.bnt.common.agent.app.iface.AppStat;
@@ -30,13 +28,12 @@ import java.net.InetSocketAddress;
 import java.net.Socket;
 import java.nio.charset.StandardCharsets;
 import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.TimeUnit;
 
 @Slf4j
 public class AgentApp {
-	static MessageSender messageSender;
-	static ScheduledExecutorService scheduler = ThreadPoolWrapper.scheduledThreadPool("heartbeat", 5);
-	static Docker docker = new DockerImpl();
+	public static MessageSender messageSender;
+	public static ScheduledExecutorService scheduler = ThreadPoolWrapper.scheduledThreadPool("heartbeat", 5);
+	public static Docker docker = new DockerImpl();
 
 	static void setLogLevel() {
 		LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory();
@@ -71,7 +68,7 @@ public class AgentApp {
 		AppStat appStat = new AppStatImpl(dockerApp);
 
 		if (tryConnect(dagentConfig.getHost(), dagentConfig.getPort())) {
-			messageSender = new WsClient(dagentConfig, scheduler, appDeploy, appStat, docker);
+			messageSender = new WsClient(dagentConfig, appDeploy, appStat);
 			return messageSender;
 		}
 
@@ -107,12 +104,6 @@ public class AgentApp {
 			messageSender.connect();
 		}
 
-		ImageCleanTask cleanTask = new ImageCleanTask(messageSender, docker);
-		scheduler.scheduleAtFixedRate(cleanTask, 1, 8, TimeUnit.HOURS);
-
-		ProcScanTask procScanTask = new ProcScanTask(messageSender, docker);
-		scheduler.scheduleAtFixedRate(procScanTask, 1, 8, TimeUnit.HOURS);
-
 		shutdownGracefully();
 		SingleInstance.onlyOne(60001);
 	}

common/src/main/java/cn/reghao/bnt/common/agent/machine/MachineEvent.java → agent/src/main/java/cn/reghao/bnt/agent/machine/MachineEvent.java

@@ -1,6 +1,10 @@
-package cn.reghao.bnt.common.agent.machine;
+package cn.reghao.bnt.agent.machine;
 
+import cn.reghao.bnt.agent.AgentApp;
+import cn.reghao.bnt.agent.task.ImageCleanTask;
+import cn.reghao.bnt.agent.task.ProcScanTask;
 import cn.reghao.bnt.common.agent.app.iface.AppStat;
+import cn.reghao.bnt.common.docker.Docker;
 import cn.reghao.bnt.common.machine.Machine;
 import cn.reghao.bnt.common.msg.MessageSender;
 import cn.reghao.bnt.common.msg.event.EvtAgentHeartbeat;
@@ -28,14 +32,15 @@ public class MachineEvent {
     private final AppStat appStat;
     private final MessageSender messageSender;
     private final int heartbeatInterval;
+    private final Docker docker;
     
-    public MachineEvent(MessageSender messageSender, Machine machine, AppStat appStat,
-                        ScheduledExecutorService scheduler, int heartbeatInterval) {
+    public MachineEvent(MessageSender messageSender, Machine machine, AppStat appStat, int heartbeatInterval) {
         this.messageSender = messageSender;
         this.machine = machine;
         this.appStat = appStat;
-        this.scheduler = scheduler;
+        this.scheduler = AgentApp.scheduler;
         this.heartbeatInterval = heartbeatInterval;
+        this.docker = AgentApp.docker;
     }
 
     public void agentStart() {
@@ -53,6 +58,7 @@ public class MachineEvent {
             e.printStackTrace();
         }
 
+        startTask();
         agentHeartbeat();
     }
 
@@ -93,4 +99,14 @@ public class MachineEvent {
             pub(eventMessage);
         }
     }
+
+    public void startTask() {
+        ProcScanTask procScanTask = new ProcScanTask(messageSender, docker);
+        scheduler.schedule(procScanTask, 0, TimeUnit.MINUTES);
+        scheduler.scheduleAtFixedRate(procScanTask, 1, 8, TimeUnit.HOURS);
+
+        ImageCleanTask cleanTask = new ImageCleanTask(messageSender, docker);
+        scheduler.schedule(cleanTask, 1, TimeUnit.MINUTES);
+        scheduler.scheduleAtFixedRate(cleanTask, 2, 8, TimeUnit.HOURS);
+    }
 }

agent/src/main/java/cn/reghao/bnt/agent/task/ImageCleanTask.java

@@ -20,10 +20,12 @@ import java.util.stream.Collectors;
  */
 @Slf4j
 public class ImageCleanTask implements Runnable {
+    private final String taskName;
     private final MessageSender messageSender;
     private final Docker docker;
 
     public ImageCleanTask(MessageSender messageSender, Docker docker) {
+        this.taskName = this.getClass().getSimpleName();
         this.messageSender = messageSender;
         this.docker = docker;
     }
@@ -32,7 +34,7 @@ public class ImageCleanTask implements Runnable {
     public void run() {
         String result = "exec ImageCleanTask";
         log.info("{}", result);
-        EvtTaskResult evtTaskResult = new EvtTaskResult(Machine.ID, result);
+        EvtTaskResult evtTaskResult = new EvtTaskResult(Machine.ID, taskName, result);
         try {
             EventMessage evtMsg = EventMessage.evt(evtTaskResult);
             messageSender.send("", evtMsg);
@@ -68,7 +70,7 @@ public class ImageCleanTask implements Runnable {
             docker.imageRm(imageId);
             String[] tags = image.getRepoTags();
             String result = String.format("delete image %s", tags);
-            EvtTaskResult evtTaskResult = new EvtTaskResult(Machine.ID, result);
+            EvtTaskResult evtTaskResult = new EvtTaskResult(Machine.ID, taskName, result);
             EventMessage evtMsg = EventMessage.evt(evtTaskResult);
             messageSender.send("", evtMsg);
         } catch (Exception e) {

agent/src/main/java/cn/reghao/bnt/agent/task/ProcScanTask.java

@@ -26,11 +26,13 @@ import java.util.stream.Collectors;
  */
 @Slf4j
 public class ProcScanTask implements Runnable {
+    private final String taskName;
     private final MessageSender messageSender;
     private final Docker docker;
     private final OperatingSystem os;
 
     public ProcScanTask(MessageSender messageSender, Docker docker) {
+        this.taskName = this.getClass().getSimpleName();
         this.messageSender = messageSender;
         this.docker = docker;
         SystemInfo si = new SystemInfo();
@@ -41,7 +43,7 @@ public class ProcScanTask implements Runnable {
     public void run() {
         String result = "exec ProcScanTask";
         log.info("{}", result);
-        EvtTaskResult evtTaskResult = new EvtTaskResult(Machine.ID, result);
+        EvtTaskResult evtTaskResult = new EvtTaskResult(Machine.ID, taskName, result);
         try {
             EventMessage evtMsg = EventMessage.evt(evtTaskResult);
             messageSender.send("", evtMsg);
@@ -108,7 +110,7 @@ public class ProcScanTask implements Runnable {
         List<SysProcess> listenProcessList = procMap.values().stream()
                 .filter(sysProcess -> !sysProcess.getHostPorts().isEmpty())
                 .collect(Collectors.toList());
-        evtTaskResult = new EvtTaskResult(Machine.ID, listenProcessList);
+        evtTaskResult = new EvtTaskResult(Machine.ID, taskName, listenProcessList);
         try {
             EventMessage evtMsg = EventMessage.evt(evtTaskResult);
             messageSender.send("", evtMsg);

agent/src/main/java/cn/reghao/bnt/agent/ws/WebSocketListenerImpl.java

@@ -1,7 +1,7 @@
 package cn.reghao.bnt.agent.ws;
 
 import cn.reghao.bnt.agent.ws.event.EventCenter;
-import cn.reghao.bnt.common.agent.machine.MachineEvent;
+import cn.reghao.bnt.agent.machine.MachineEvent;
 import cn.reghao.jutil.jdk.event.message.EventMessage;
 import cn.reghao.jutil.jdk.serializer.JdkSerializer;
 import lombok.extern.slf4j.Slf4j;

agent/src/main/java/cn/reghao/bnt/agent/ws/WsClient.java

@@ -4,7 +4,7 @@ import cn.reghao.bnt.agent.config.DagentConfig;
 import cn.reghao.bnt.agent.ws.event.EventCenter;
 import cn.reghao.bnt.common.agent.app.iface.AppDeploy;
 import cn.reghao.bnt.common.agent.app.iface.AppStat;
-import cn.reghao.bnt.common.agent.machine.MachineEvent;
+import cn.reghao.bnt.agent.machine.MachineEvent;
 import cn.reghao.bnt.common.docker.Docker;
 import cn.reghao.bnt.common.machine.Machine;
 import cn.reghao.bnt.common.msg.MessageSender;
@@ -32,17 +32,16 @@ public class WsClient implements MessageSender {
     private boolean retry;
     private int retryCount;
 
-    public WsClient(DagentConfig dagentConfig, ScheduledExecutorService scheduler,
-                    AppDeploy appDeploy, AppStat appStat, Docker docker) {
+    public WsClient(DagentConfig dagentConfig, AppDeploy appDeploy, AppStat appStat) {
         String protocol = dagentConfig.getProtocol();
         String host = dagentConfig.getHost();
         int port = dagentConfig.getPort();
         this.url = String.format("%s://%s:%s/bgws/agent?token=%s", protocol, host, port, Machine.ID);
 
-        EventCenter eventCenter = new EventCenter(this, appDeploy, appStat, docker);
+        EventCenter eventCenter = new EventCenter(this, appDeploy, appStat);
         // 每 60s 发送一次心跳
         int heartbeatInterval = 60;
-        MachineEvent machineEvent = new MachineEvent(this, new Machine(), appStat, scheduler, heartbeatInterval);
+        MachineEvent machineEvent = new MachineEvent(this, new Machine(), appStat, heartbeatInterval);
         this.webSocketListener = new WebSocketListenerImpl(this, eventCenter, machineEvent);
         this.retry = true;
         this.retryCount = 0;

agent/src/main/java/cn/reghao/bnt/agent/ws/event/EventCenter.java

@@ -27,16 +27,16 @@ public class EventCenter {
     private final long startTime;
     private final EventDispatcher dispatcher;
 
-    public EventCenter(MessageSender messageSender, AppDeploy appDeploy, AppStat appStat, Docker docker) {
+    public EventCenter(MessageSender messageSender, AppDeploy appDeploy, AppStat appStat) {
         this.startTime = ManagementFactory.getRuntimeMXBean().getStartTime();
         this.dispatcher = new EventDispatcher();
-        initDispatcher(messageSender, appDeploy, appStat, docker);
+        initDispatcher(messageSender, appDeploy, appStat);
     }
 
-    private void initDispatcher(MessageSender messageSender, AppDeploy appDeploy, AppStat appStat, Docker docker) {
+    private void initDispatcher(MessageSender messageSender, AppDeploy appDeploy, AppStat appStat) {
         dispatcher.register(EvtAppDeploy.class, new EvtAppDeployHandler(messageSender, appDeploy));
         dispatcher.register(EvtAppStat.class, new EvtAppStatHandler(messageSender, appStat));
-        dispatcher.register(EvtDockerOps.class, new EvtDockerHandler(messageSender, docker));
+        dispatcher.register(EvtDockerOps.class, new EvtDockerHandler(messageSender));
     }
 
     public void dispatch(EventMessage eventMessage) {

agent/src/main/java/cn/reghao/bnt/agent/ws/event/handler/EvtDockerHandler.java

@@ -1,5 +1,6 @@
 package cn.reghao.bnt.agent.ws.event.handler;
 
+import cn.reghao.bnt.agent.AgentApp;
 import cn.reghao.bnt.common.docker.Docker;
 import cn.reghao.bnt.common.docker.DockerService;
 import cn.reghao.bnt.common.docker.model.DockerQuery;
@@ -28,9 +29,9 @@ public class EvtDockerHandler extends Handler {
     private final MessageSender messageSender;
     private final DockerService dockerService;
 
-    public EvtDockerHandler(MessageSender messageSender, Docker docker) {
+    public EvtDockerHandler(MessageSender messageSender) {
         this.messageSender = messageSender;
-        this.dockerService = new DockerService(docker);
+        this.dockerService = new DockerService(AgentApp.docker);
     }
 
     @Override

common/src/main/java/cn/reghao/bnt/common/msg/event/EvtTaskResult.java

@@ -17,18 +17,21 @@ import java.util.List;
 @Getter
 public class EvtTaskResult extends Event {
     private String machineId;
+    private String taskName;
     private int resultType;
     private String result;
     private List<SysProcess> listenProcessList;
 
-    public EvtTaskResult(String machineId, String result) {
+    public EvtTaskResult(String machineId, String taskName, String result) {
         this.machineId = machineId;
+        this.taskName = taskName;
         this.resultType = 1;
         this.result = result;
     }
 
-    public EvtTaskResult(String machineId, List<SysProcess> listenProcessList) {
+    public EvtTaskResult(String machineId, String taskName, List<SysProcess> listenProcessList) {
         this.machineId = machineId;
+        this.taskName = taskName;
         this.resultType = 2;
         this.listenProcessList = listenProcessList;
     }

web/src/main/java/cn/reghao/bnt/web/devops/machine/controller/MachineProcController.java

@@ -1,6 +1,6 @@
 package cn.reghao.bnt.web.devops.machine.controller;
 
-import cn.reghao.bnt.web.devops.machine.model.po.MachineProc;
+import cn.reghao.bnt.web.devops.machine.model.vo.MachineProcInfo;
 import cn.reghao.bnt.web.devops.machine.service.MachineProcService;
 import cn.reghao.jutil.web.WebResult;
 import io.swagger.v3.oas.annotations.Operation;
@@ -26,10 +26,10 @@ public class MachineProcController {
         this.machineProcService = machineProcService;
     }
 
-    @Operation(summary = "机器进程列表", description = "N")
+    @Operation(summary = "机器上的服务进程列表", description = "N")
     @GetMapping(value = "", produces = MediaType.APPLICATION_JSON_VALUE)
     public String machineListPage(@RequestParam(value = "machineId") String machineId) {
-        List<MachineProc> machineProcList = machineProcService.getByMachineId(machineId);
+        List<MachineProcInfo> machineProcList = machineProcService.getByMachineId(machineId);
         return WebResult.success(machineProcList);
     }
     

web/src/main/java/cn/reghao/bnt/web/devops/machine/controller/MachineTaskController.java

@@ -0,0 +1,44 @@
+package cn.reghao.bnt.web.devops.machine.controller;
+
+import cn.reghao.bnt.web.devops.machine.model.po.MachineProc;
+import cn.reghao.bnt.web.devops.machine.model.po.MachineTask;
+import cn.reghao.bnt.web.devops.machine.service.MachineProcService;
+import cn.reghao.bnt.web.devops.machine.service.MachineTaskService;
+import cn.reghao.jutil.web.WebResult;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.MediaType;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+/**
+ * @author reghao
+ * @date 2025-12-18 09:31:44
+ */
+@Slf4j
+@Tag(name = "机器任务结果接口")
+@RestController
+@RequestMapping("/api/devops/machine/task")
+public class MachineTaskController {
+    private final MachineTaskService machineTaskService;
+
+    public MachineTaskController(MachineTaskService machineTaskService) {
+        this.machineTaskService = machineTaskService;
+    }
+
+    @Operation(summary = "任务执行结果列表", description = "N")
+    @GetMapping(value = "", produces = MediaType.APPLICATION_JSON_VALUE)
+    public String machineListPage(@RequestParam(value = "machineId") String machineId) {
+        List<MachineTask> machineProcList = machineTaskService.getMachineTasks(machineId);
+        return WebResult.success(machineProcList);
+    }
+
+    @Operation(summary = "清空任务执行结果", description = "N")
+    @PostMapping(value = "/clear", produces = MediaType.APPLICATION_JSON_VALUE)
+    public String clearMachineTask(String machineId) {
+        machineTaskService.clearTask(machineId);
+        return WebResult.success();
+    }
+}

web/src/main/java/cn/reghao/bnt/web/devops/machine/db/repository/MachineProcRepository.java

@@ -1,16 +1,17 @@
 package cn.reghao.bnt.web.devops.machine.db.repository;
 
 import cn.reghao.bnt.web.devops.machine.model.po.MachineProc;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
 
-import java.util.List;
-
 /**
  * @author reghao
  * @date 2025-12-17 15:47:12
  */
 public interface MachineProcRepository extends JpaRepository<MachineProc, Integer>, JpaSpecificationExecutor<MachineProc> {
-    List<MachineProc> findByMachineId(String machineId);
+    void deleteByMachineId(String machineId);
+    Page<MachineProc> findByMachineId(String machineId, Pageable pageable);
     MachineProc findByMachineIdAndBindAddress(String machineId, String bindAddress);
 }

web/src/main/java/cn/reghao/bnt/web/devops/machine/db/repository/MachineTaskRepository.java

@@ -0,0 +1,15 @@
+package cn.reghao.bnt.web.devops.machine.db.repository;
+
+import cn.reghao.bnt.web.devops.machine.model.po.MachineTask;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+
+/**
+ * @author reghao
+ * @date 2025-12-18 09:32:17
+ */
+public interface MachineTaskRepository extends JpaRepository<MachineTask, Integer>, JpaSpecificationExecutor<MachineTask> {
+    Page<MachineTask> findByMachineId(String machineId, Pageable pageable);
+}

web/src/main/java/cn/reghao/bnt/web/devops/machine/model/po/MachineProc.java

@@ -2,17 +2,11 @@ package cn.reghao.bnt.web.devops.machine.model.po;
 
 import cn.reghao.bnt.common.machine.model.SysProcess;
 import cn.reghao.bnt.web.util.BaseEntity;
-import jakarta.persistence.CollectionTable;
-import jakarta.persistence.ElementCollection;
 import jakarta.persistence.Entity;
 import jakarta.persistence.Table;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.Setter;
-import org.hibernate.annotations.LazyCollection;
-import org.hibernate.annotations.LazyCollectionOption;
-
-import java.util.List;
 
 /**
  * @author reghao
@@ -47,15 +41,4 @@ public class MachineProc extends BaseEntity {
         this.containerId = sysProcess.getContainerId();
         this.appId = sysProcess.getAppId();
     }
-
-    public void update(SysProcess sysProcess) {
-        this.pid = sysProcess.getPid();
-        this.name = sysProcess.getName();
-        this.ppid = sysProcess.getPpid();
-        this.cmdLine = sysProcess.getCmdLine();
-        this.startTime = sysProcess.getStartTime();
-        this.user = sysProcess.getUser();
-        this.containerId = sysProcess.getContainerId();
-        this.appId = sysProcess.getAppId();
-    }
 }

web/src/main/java/cn/reghao/bnt/web/devops/machine/model/po/MachineTask.java

@@ -0,0 +1,30 @@
+package cn.reghao.bnt.web.devops.machine.model.po;
+
+import cn.reghao.bnt.common.msg.event.EvtTaskResult;
+import cn.reghao.bnt.web.util.BaseEntity;
+import jakarta.persistence.Entity;
+import jakarta.persistence.Table;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+/**
+ * 机器上执行的定时任务
+ *
+ * @author reghao
+ * @date 2025-12-18 09:05:00
+ */
+@NoArgsConstructor
+@Getter
+@Setter
+@Entity
+@Table(name = "devops_machine_task")
+public class MachineTask extends BaseEntity {
+    private String machineId;
+    private String taskName;
+
+    public MachineTask(EvtTaskResult evtTaskResult) {
+        this.machineId = evtTaskResult.getMachineId();
+        this.taskName = evtTaskResult.getTaskName();
+    }
+}

web/src/main/java/cn/reghao/bnt/web/devops/machine/model/vo/MachineProcInfo.java

@@ -0,0 +1,36 @@
+package cn.reghao.bnt.web.devops.machine.model.vo;
+
+import cn.reghao.bnt.web.devops.machine.model.po.MachineProc;
+import cn.reghao.jutil.jdk.converter.DateTimeConverter;
+import lombok.Getter;
+
+/**
+ * @author reghao
+ * @date 2025-12-18 10:51:45
+ */
+@Getter
+public class MachineProcInfo {
+    private String machineId;
+    private Integer pid;
+    private String name;
+    private Integer ppid;
+    private String cmdLine;
+    private String bindAddress;
+    private String startTime;
+    private String user;
+    private String containerId;
+    private String appId;
+
+    public MachineProcInfo(MachineProc machineProc) {
+        this.machineId = machineProc.getMachineId();
+        this.pid = machineProc.getPid();
+        this.name = machineProc.getName();
+        this.ppid = machineProc.getPpid();
+        this.cmdLine = machineProc.getCmdLine();
+        this.bindAddress = machineProc.getBindAddress();
+        this.startTime = DateTimeConverter.format(machineProc.getStartTime());
+        this.user = machineProc.getUser();
+        this.containerId = machineProc.getContainerId();
+        this.appId = machineProc.getAppId();
+    }
+}

web/src/main/java/cn/reghao/bnt/web/devops/machine/service/MachineProcService.java

@@ -3,6 +3,9 @@ package cn.reghao.bnt.web.devops.machine.service;
 import cn.reghao.bnt.common.machine.model.SysProcess;
 import cn.reghao.bnt.web.devops.machine.db.repository.MachineProcRepository;
 import cn.reghao.bnt.web.devops.machine.model.po.MachineProc;
+import cn.reghao.bnt.web.devops.machine.model.vo.MachineProcInfo;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Sort;
 import org.springframework.stereotype.Service;
 
 import java.util.List;
@@ -21,7 +24,7 @@ public class MachineProcService {
     }
 
     public void saveAll(String machineId, List<SysProcess> listenProcessList) {
-        List<MachineProc> machineProcList1 = machineProcRepository.findByMachineId(machineId);
+        machineProcRepository.deleteByMachineId(machineId);
         List<MachineProc> machineProcList = listenProcessList.stream()
                 .map(sysProcess -> {
                     StringBuilder sb = new StringBuilder();
@@ -30,20 +33,17 @@ public class MachineProcService {
                     }
                     sb.deleteCharAt(sb.length() - 1);
                     String bindAddress = sb.toString();
-
-                    MachineProc machineProcEntity = machineProcRepository.findByMachineIdAndBindAddress(machineId, bindAddress);
-                    if (machineProcEntity != null) {
-                        machineProcEntity.update(sysProcess);
-                        return machineProcEntity;
-                    } else {
-                        return new MachineProc(machineId, sysProcess, bindAddress);
-                    }
+                    return new MachineProc(machineId, sysProcess, bindAddress);
                 })
                 .collect(Collectors.toList());
         machineProcRepository.saveAll(machineProcList);
     }
 
-    public List<MachineProc> getByMachineId(String machineId) {
-        return machineProcRepository.findByMachineId(machineId);
+    public List<MachineProcInfo> getByMachineId(String machineId) {
+        Sort sort = Sort.by(Sort.Direction.DESC, "startTime");
+        PageRequest pageRequest = PageRequest.of(0, 1000, sort);
+        return machineProcRepository.findByMachineId(machineId, pageRequest).stream()
+                .map(MachineProcInfo::new)
+                .collect(Collectors.toList());
     }
 }

web/src/main/java/cn/reghao/bnt/web/devops/machine/service/MachineTaskService.java

@@ -1,10 +1,16 @@
 package cn.reghao.bnt.web.devops.machine.service;
 
 import cn.reghao.bnt.common.msg.event.EvtTaskResult;
+import cn.reghao.bnt.web.devops.machine.db.repository.MachineTaskRepository;
 import cn.reghao.bnt.web.devops.machine.model.po.MachineHost;
+import cn.reghao.bnt.web.devops.machine.model.po.MachineTask;
 import lombok.extern.slf4j.Slf4j;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Sort;
 import org.springframework.stereotype.Service;
 
+import java.util.List;
+
 /**
  * @author reghao
  * @date 2025-12-16 10:55:55
@@ -12,13 +18,24 @@ import org.springframework.stereotype.Service;
 @Slf4j
 @Service
 public class MachineTaskService {
+    private final MachineTaskRepository machineTaskRepository;
     private final MachineQuery machineQuery;
 
-    public MachineTaskService(MachineQuery machineQuery) {
+    public MachineTaskService(MachineTaskRepository machineTaskRepository, MachineQuery machineQuery) {
+        this.machineTaskRepository = machineTaskRepository;
         this.machineQuery = machineQuery;
     }
 
+    public List<MachineTask> getMachineTasks(String machineId) {
+        Sort sort = Sort.by(Sort.Direction.DESC, "createTime");
+        PageRequest pageRequest = PageRequest.of(0, 100, sort);
+        return machineTaskRepository.findByMachineId(machineId, pageRequest).getContent();
+    }
+
     public void handleTaskResult(EvtTaskResult evtTaskResult) {
+        MachineTask machineTask = new MachineTask(evtTaskResult);
+        machineTaskRepository.save(machineTask);
+
         String machineId = evtTaskResult.getMachineId();
         String result = evtTaskResult.getResult();
         MachineHost machineHost = machineQuery.getMachineHost(machineId);
@@ -29,4 +46,13 @@ public class MachineTaskService {
             log.info("machine {} event result -> {}", machineId, result);
         }
     }
+
+    public void clearTask(String machineId) {
+        Sort sort = Sort.by(Sort.Direction.DESC, "createTime");
+        PageRequest pageRequest = PageRequest.of(0, 100, sort);
+        List<MachineTask> list = machineTaskRepository.findByMachineId(machineId, pageRequest).getContent();
+        if (!list.isEmpty()) {
+            machineTaskRepository.deleteAll(list);
+        }
+    }
 }