diff --git a/src/main/java/com/tongran/agent/client/scheduler/config/SchedulerConfig.java b/src/main/java/com/tongran/agent/client/scheduler/config/SchedulerConfig.java index d65200a..1c4975e 100644 --- a/src/main/java/com/tongran/agent/client/scheduler/config/SchedulerConfig.java +++ b/src/main/java/com/tongran/agent/client/scheduler/config/SchedulerConfig.java @@ -4,6 +4,7 @@ import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.scheduling.annotation.EnableAsync; import org.springframework.scheduling.annotation.EnableScheduling; +import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor; import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler; import java.util.concurrent.ThreadPoolExecutor; @@ -24,14 +25,31 @@ public class SchedulerConfig { scheduler.setRemoveOnCancelPolicy(true); return scheduler; } +// @Bean("taskExecutor") +// public ThreadPoolTaskScheduler taskExecutor() { +// ThreadPoolTaskScheduler executor = new ThreadPoolTaskScheduler(); +// executor.setPoolSize(50); // 工作线程数 +// executor.setThreadNamePrefix("task-worker-"); +// executor.setAwaitTerminationSeconds(30); +// executor.setWaitForTasksToCompleteOnShutdown(true); +// return executor; +// } @Bean("taskExecutor") - public ThreadPoolTaskScheduler taskExecutor() { - ThreadPoolTaskScheduler executor = new ThreadPoolTaskScheduler(); - executor.setPoolSize(50); // 工作线程数 + public ThreadPoolTaskExecutor taskExecutor() { + ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor(); + // 核心配置 + executor.setCorePoolSize(44); + executor.setMaxPoolSize(60); + executor.setQueueCapacity(100); + executor.setKeepAliveSeconds(60); + // 线程配置 executor.setThreadNamePrefix("task-worker-"); executor.setAwaitTerminationSeconds(30); executor.setWaitForTasksToCompleteOnShutdown(true); + // 拒绝策略 + executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy()); + executor.initialize(); // 重要：必须调用initialize() return executor; } } \ No newline at end of file diff --git a/src/main/java/com/tongran/agent/client/scheduler/service/BusinessTasks.java b/src/main/java/com/tongran/agent/client/scheduler/service/BusinessTasks.java index 7ad7030..6f590a3 100644 --- a/src/main/java/com/tongran/agent/client/scheduler/service/BusinessTasks.java +++ b/src/main/java/com/tongran/agent/client/scheduler/service/BusinessTasks.java @@ -27,16 +27,54 @@ import java.util.concurrent.atomic.AtomicInteger; @Component public class BusinessTasks { - private final AtomicInteger task1Counter = new AtomicInteger(0); - private final AtomicInteger task2Counter = new AtomicInteger(0); - private final AtomicInteger task3Counter = new AtomicInteger(0); - private final AtomicInteger task4Counter = new AtomicInteger(0); - private final AtomicInteger task5Counter = new AtomicInteger(0); - private final AtomicInteger task6Counter = new AtomicInteger(0); - private final AtomicInteger task7Counter = new AtomicInteger(0); - private final AtomicInteger task8Counter = new AtomicInteger(0); - private final AtomicInteger task9Counter = new AtomicInteger(0); - private final AtomicInteger task10Counter = new AtomicInteger(0); + private final AtomicInteger heartbeatTask = new AtomicInteger(0); + private final AtomicInteger cpuTask = new AtomicInteger(0); + private final AtomicInteger diskTask = new AtomicInteger(0); + private final AtomicInteger dockerTask = new AtomicInteger(0); + private final AtomicInteger memoryTask = new AtomicInteger(0); + private final AtomicInteger netTask = new AtomicInteger(0); + private final AtomicInteger pointTask = new AtomicInteger(0); + private final AtomicInteger alarmTask = new AtomicInteger(0); + private final AtomicInteger systemSwapSizeFreeTask = new AtomicInteger(0); + private final AtomicInteger memoryUtilizationTask = new AtomicInteger(0); + private final AtomicInteger systemSwapSizePercentTask = new AtomicInteger(0); + private final AtomicInteger memorySizeAvailableTask = new AtomicInteger(0); + private final AtomicInteger memorySizePercentTask = new AtomicInteger(0); + private final AtomicInteger memorySizeTotalTask = new AtomicInteger(0); + private final AtomicInteger systemSwOsTask = new AtomicInteger(0); + private final AtomicInteger systemSwArchTask = new AtomicInteger(0); + private final AtomicInteger kernelMaxprocTask = new AtomicInteger(0); + private final AtomicInteger procNumRunTask = new AtomicInteger(0); + private final AtomicInteger systemUsersNumTask = new AtomicInteger(0); + private final AtomicInteger systemDiskSizeTotalTask = new AtomicInteger(0); + private final AtomicInteger systemBoottimeTask = new AtomicInteger(0); + private final AtomicInteger systemUnameTask = new AtomicInteger(0); + private final AtomicInteger systemLocaltimeTask = new AtomicInteger(0); + private final AtomicInteger systemUptimeTask = new AtomicInteger(0); + private final AtomicInteger procNumTask = new AtomicInteger(0); + + private final AtomicInteger switchNetTask = new AtomicInteger(0); + private final AtomicInteger switchModuleTask = new AtomicInteger(0); + private final AtomicInteger switchMpuTask = new AtomicInteger(0); + private final AtomicInteger switchPwrTask = new AtomicInteger(0); + private final AtomicInteger switchFanTask = new AtomicInteger(0); + private final AtomicInteger switchSysDescrTask = new AtomicInteger(0); + private final AtomicInteger switchSysObjectIDTask = new AtomicInteger(0); + private final AtomicInteger switchSysUpTimeTask = new AtomicInteger(0); + private final AtomicInteger switchSysContactTask = new AtomicInteger(0); + private final AtomicInteger switchSysNameTask = new AtomicInteger(0); + private final AtomicInteger switchSysLocationTask = new AtomicInteger(0); + private final AtomicInteger switchHwStackSystemMacTask = new AtomicInteger(0); + private final AtomicInteger switchEntIndexTask = new AtomicInteger(0); + private final AtomicInteger switchEntPhysicalNameTask = new AtomicInteger(0); + private final AtomicInteger switchEntPhysicalSoftwareRevTask = new AtomicInteger(0); + private final AtomicInteger switchHwEntityCpuUsageTask = new AtomicInteger(0); + private final AtomicInteger switchHwEntityMemUsageTask = new AtomicInteger(0); + private final AtomicInteger switchHwAveragePowerTask = new AtomicInteger(0); + private final AtomicInteger switchHwCurrentPowerTask = new AtomicInteger(0); + + + protected final SessionManager sessionManager; @@ -85,7 +123,7 @@ public class BusinessTasks { public void heartbeatTask() { long timestamp = System.currentTimeMillis(); timestamp = Math.round(timestamp / 1000.0); - int count = task1Counter.incrementAndGet(); + int count = heartbeatTask.incrementAndGet(); AssertLog.info("心跳定时任务执行 - 时间: {}，task #{}", LocalDateTime.now(), count); // 业务处理 // 判定客户端与服务端是否连接 @@ -111,7 +149,7 @@ public class BusinessTasks { public void cpuTask() { long timestamp = System.currentTimeMillis(); timestamp = Math.round(timestamp / 1000.0); - int count = task2Counter.incrementAndGet(); + int count = cpuTask.incrementAndGet(); AssertLog.info("CPU信息采集定时任务执行 - 时间: {}，task #{}", LocalDateTime.now(), count); // 判定客户端与服务端是否连接 if (Objects.nonNull(sessionManager.getSessionById(GlobalConfig.CLIENT_ID))) { @@ -133,7 +171,7 @@ public class BusinessTasks { public void diskTask() { long timestamp = System.currentTimeMillis(); timestamp = Math.round(timestamp / 1000.0); - int count = task3Counter.incrementAndGet(); + int count = diskTask.incrementAndGet(); AssertLog.info("磁盘信息采集定时任务执行 - 时间: {}，task #{}", LocalDateTime.now(), count); // 判定客户端与服务端是否连接 if (Objects.nonNull(sessionManager.getSessionById(GlobalConfig.CLIENT_ID))) { @@ -157,7 +195,7 @@ public class BusinessTasks { public void dockerTask() { long timestamp = System.currentTimeMillis(); timestamp = Math.round(timestamp / 1000.0); - int count = task4Counter.incrementAndGet(); + int count = dockerTask.incrementAndGet(); AssertLog.info("容器信息采集定时任务执行 - 时间: {}，task #{}", LocalDateTime.now(), count); // 判定客户端与服务端是否连接 if (Objects.nonNull(sessionManager.getSessionById(GlobalConfig.CLIENT_ID))) { @@ -181,7 +219,7 @@ public class BusinessTasks { public void memoryTask() { long timestamp = System.currentTimeMillis(); timestamp = Math.round(timestamp / 1000.0); - int count = task5Counter.incrementAndGet(); + int count = memoryTask.incrementAndGet(); AssertLog.info("内存信息采集定时任务执行 - 时间: {}，task #{}", LocalDateTime.now(), count); // 判定客户端与服务端是否连接 if (Objects.nonNull(sessionManager.getSessionById(GlobalConfig.CLIENT_ID))) { @@ -202,7 +240,7 @@ public class BusinessTasks { @Async("taskExecutor") public void netTask() { long timestamp = AgentUtil.roundMinutes(); - int count = task6Counter.incrementAndGet(); + int count = netTask.incrementAndGet(); AssertLog.info("网络信息采集定时任务执行 - 时间: {}，task #{}", LocalDateTime.now(), count); // 判定客户端与服务端是否连接 if (Objects.nonNull(sessionManager.getSessionById(GlobalConfig.CLIENT_ID))) { @@ -226,7 +264,7 @@ public class BusinessTasks { public void pointTask() { long timestamp = System.currentTimeMillis(); timestamp = Math.round(timestamp / 1000.0); - int count = task7Counter.incrementAndGet(); + int count = pointTask.incrementAndGet(); AssertLog.info("挂载信息采集定时任务执行 - 时间: {}，task #{}", LocalDateTime.now(), count); // 判定客户端与服务端是否连接 if (Objects.nonNull(sessionManager.getSessionById(GlobalConfig.CLIENT_ID))) { @@ -244,71 +282,13 @@ public class BusinessTasks { } /** - * 任务8：交换机信息采集任务 - */ - @Async("taskExecutor") - public void switchBoardTask(String type) { - long timestamp = System.currentTimeMillis(); - timestamp = Math.round(timestamp / 1000.0); -// long timestamp = AgentUtil.roundMinutes(); - int count = task8Counter.incrementAndGet(); - AssertLog.info("交换机信息采集定时任务执行 - 时间: {}，task #{}", LocalDateTime.now(), count); - // 判定客户端与服务端是否连接 - if (Objects.nonNull(sessionManager.getSessionById(GlobalConfig.CLIENT_ID))) { - // 发送交换机信息包 -// List list = switchBoardService.switchBoardList(timestamp); -// String data = JSONArray.toJSONString(list); -// Message message = Message.builder().clientId(GlobalConfig.CLIENT_ID).dataType(MsgEnum.交换机上报.getValue()).data(data).build(); - JSONObject jsonObject = new JSONObject(); - String data = switchBoardService.getSwitchDataByType(type); - if(StringUtils.isNotBlank(data)){ - jsonObject = JSONObject.parseObject(data); - } - jsonObject.put("timestamp", timestamp); - Message message = Message.builder().clientId(GlobalConfig.CLIENT_ID).dataType(MsgEnum.交换机上报.getValue()).data(jsonObject.toString()).build(); - sessionManager.writeAndFlush(sessionManager.getSessionById(GlobalConfig.CLIENT_ID).getChannel(), message); - AssertLog.info("发送交换机信息包={}",JSON.toJSONString(message)); - } - AssertLog.info("交换机信息采集定时任务执行 - task #{} completed", count); - } - - /** - * 任务9：系统机信息采集任务 - */ - @Async("taskExecutor") - public void systemTask(String type) { - long timestamp = System.currentTimeMillis(); - timestamp = Math.round(timestamp / 1000.0); - int count = task9Counter.incrementAndGet(); - AssertLog.info("系统信息采集定时任务执行 - 时间: {}，task #{}", LocalDateTime.now(), count); - // 判定客户端与服务端是否连接 - if (Objects.nonNull(sessionManager.getSessionById(GlobalConfig.CLIENT_ID))) { - // 发送系统信息包 -// SystemVO systemVO = systemService.get(); -// systemVO.setTimestamp(timestamp); -// String data = JSON.toJSONString(systemVO); -// Message message = Message.builder().clientId(GlobalConfig.CLIENT_ID).dataType(MsgEnum.系统其他上报.getValue()).data(data).build(); - JSONObject jsonObject = new JSONObject(); - String data = systemService.otherSystem(type); - if(StringUtils.isNotBlank(data)){ - jsonObject = JSONObject.parseObject(data); - } - jsonObject.put("timestamp", timestamp); - Message message = Message.builder().clientId(GlobalConfig.CLIENT_ID).dataType(MsgEnum.系统其他上报.getValue()).data(jsonObject.toString()).build(); - sessionManager.writeAndFlush(sessionManager.getSessionById(GlobalConfig.CLIENT_ID).getChannel(), message); - AssertLog.info("发送系统信息包={}",JSON.toJSONString(message)); - } - AssertLog.info("系统信息采集定时任务执行 - task #{} completed", count); - } - - /** - * 任务10：告警监控任务 + * 任务8：告警监控任务 */ @Async("taskExecutor") public void alarmTask() { long timestamp = System.currentTimeMillis(); timestamp = Math.round(timestamp / 1000.0); - int count = task10Counter.incrementAndGet(); + int count = alarmTask.incrementAndGet(); AssertLog.info("告警监控定时任务执行 - 时间: {}，task #{}", LocalDateTime.now(), count); // 判定客户端与服务端是否连接 if (Objects.nonNull(sessionManager.getSessionById(GlobalConfig.CLIENT_ID))) { @@ -325,4 +305,969 @@ public class BusinessTasks { AssertLog.info("告警监控定时任务执行 - task #{} completed", count); } + /** + * 任务9：系统机信息采集任务-交换卷/文件的可用空间（字节）采集 + */ + @Async("taskExecutor") + public void systemSwapSizeFreeTask() { + long timestamp = System.currentTimeMillis(); + timestamp = Math.round(timestamp / 1000.0); + int count = systemSwapSizeFreeTask.incrementAndGet(); + AssertLog.info("系统其他信息-交换卷/文件的可用空间采集定时任务执行 - 时间: {}，task #{}", LocalDateTime.now(), count); + // 判定客户端与服务端是否连接 + if (Objects.nonNull(sessionManager.getSessionById(GlobalConfig.CLIENT_ID))) { + JSONObject jsonObject = new JSONObject(); + String data = systemService.otherSystem("systemSwapSizeFreeCollect"); + if(StringUtils.isNotBlank(data)){ + jsonObject = JSONObject.parseObject(data); + } + jsonObject.put("timestamp", timestamp); + Message message = Message.builder().clientId(GlobalConfig.CLIENT_ID).dataType(MsgEnum.系统其他上报.getValue()).data(jsonObject.toString()).build(); + sessionManager.writeAndFlush(sessionManager.getSessionById(GlobalConfig.CLIENT_ID).getChannel(), message); + AssertLog.info("发送系统其他信息-交换卷/文件的可用空间信息包={}",JSON.toJSONString(message)); + } + AssertLog.info("系统其他信息-交换卷/文件的可用空间采集定时任务执行 - task #{} completed", count); + } + + /** + * 任务10：系统机信息采集任务-内存利用率采集 + */ + @Async("taskExecutor") + public void memoryUtilizationTask() { + long timestamp = System.currentTimeMillis(); + timestamp = Math.round(timestamp / 1000.0); + int count = memoryUtilizationTask.incrementAndGet(); + AssertLog.info("系统其他信息-内存利用率采集定时任务执行 - 时间: {}，task #{}", LocalDateTime.now(), count); + // 判定客户端与服务端是否连接 + if (Objects.nonNull(sessionManager.getSessionById(GlobalConfig.CLIENT_ID))) { + // 发送系统信息包 +// SystemVO systemVO = systemService.get(); +// systemVO.setTimestamp(timestamp); +// String data = JSON.toJSONString(systemVO); +// Message message = Message.builder().clientId(GlobalConfig.CLIENT_ID).dataType(MsgEnum.系统其他上报.getValue()).data(data).build(); + JSONObject jsonObject = new JSONObject(); + String data = systemService.otherSystem("memoryUtilizationCollect"); + if(StringUtils.isNotBlank(data)){ + jsonObject = JSONObject.parseObject(data); + } + jsonObject.put("timestamp", timestamp); + Message message = Message.builder().clientId(GlobalConfig.CLIENT_ID).dataType(MsgEnum.系统其他上报.getValue()).data(jsonObject.toString()).build(); + sessionManager.writeAndFlush(sessionManager.getSessionById(GlobalConfig.CLIENT_ID).getChannel(), message); + AssertLog.info("发送系统其他信息-内存利用率信息包={}",JSON.toJSONString(message)); + } + AssertLog.info("系统其他信息-内存利用率采集定时任务执行 - task #{} completed", count); + } + + /** + * 任务11：系统机信息采集任务-可用交换空间百分比采集 + */ + @Async("taskExecutor") + public void systemSwapSizePercentTask() { + long timestamp = System.currentTimeMillis(); + timestamp = Math.round(timestamp / 1000.0); + int count = systemSwapSizePercentTask.incrementAndGet(); + AssertLog.info("系统其他信息-可用交换空间百分比采集定时任务执行 - 时间: {}，task #{}", LocalDateTime.now(), count); + // 判定客户端与服务端是否连接 + if (Objects.nonNull(sessionManager.getSessionById(GlobalConfig.CLIENT_ID))) { + // 发送系统信息包 + JSONObject jsonObject = new JSONObject(); + String data = systemService.otherSystem("systemSwapSizePercentCollect"); + if(StringUtils.isNotBlank(data)){ + jsonObject = JSONObject.parseObject(data); + } + jsonObject.put("timestamp", timestamp); + Message message = Message.builder().clientId(GlobalConfig.CLIENT_ID).dataType(MsgEnum.系统其他上报.getValue()).data(jsonObject.toString()).build(); + sessionManager.writeAndFlush(sessionManager.getSessionById(GlobalConfig.CLIENT_ID).getChannel(), message); + AssertLog.info("发送系统其他信息-可用交换空间百分比信息包={}",JSON.toJSONString(message)); + } + AssertLog.info("系统其他信息-可用交换空间百分比采集定时任务执行 - task #{} completed", count); + } + + /** + * 任务12：系统机信息采集任务-可用内存采集 + */ + @Async("taskExecutor") + public void memorySizeAvailableTask() { + long timestamp = System.currentTimeMillis(); + timestamp = Math.round(timestamp / 1000.0); + int count = memorySizeAvailableTask.incrementAndGet(); + AssertLog.info("系统其他信息-可用内存采集定时任务执行 - 时间: {}，task #{}", LocalDateTime.now(), count); + // 判定客户端与服务端是否连接 + if (Objects.nonNull(sessionManager.getSessionById(GlobalConfig.CLIENT_ID))) { + // 发送系统信息包 + JSONObject jsonObject = new JSONObject(); + String data = systemService.otherSystem("memorySizeAvailableCollect"); + if(StringUtils.isNotBlank(data)){ + jsonObject = JSONObject.parseObject(data); + } + jsonObject.put("timestamp", timestamp); + Message message = Message.builder().clientId(GlobalConfig.CLIENT_ID).dataType(MsgEnum.系统其他上报.getValue()).data(jsonObject.toString()).build(); + sessionManager.writeAndFlush(sessionManager.getSessionById(GlobalConfig.CLIENT_ID).getChannel(), message); + AssertLog.info("发送系统其他信息-可用内存信息包={}",JSON.toJSONString(message)); + } + AssertLog.info("系统其他信息-可用内存采集定时任务执行 - task #{} completed", count); + } + + /** + * 任务13：系统机信息采集任务-可用内存百分比内存采集 + */ + @Async("taskExecutor") + public void memorySizePercentTask() { + long timestamp = System.currentTimeMillis(); + timestamp = Math.round(timestamp / 1000.0); + int count = memorySizePercentTask.incrementAndGet(); + AssertLog.info("系统其他信息-可用内存百分比采集定时任务执行 - 时间: {}，task #{}", LocalDateTime.now(), count); + // 判定客户端与服务端是否连接 + if (Objects.nonNull(sessionManager.getSessionById(GlobalConfig.CLIENT_ID))) { + // 发送系统信息包 + JSONObject jsonObject = new JSONObject(); + String data = systemService.otherSystem("memorySizePercentCollect"); + if(StringUtils.isNotBlank(data)){ + jsonObject = JSONObject.parseObject(data); + } + jsonObject.put("timestamp", timestamp); + Message message = Message.builder().clientId(GlobalConfig.CLIENT_ID).dataType(MsgEnum.系统其他上报.getValue()).data(jsonObject.toString()).build(); + sessionManager.writeAndFlush(sessionManager.getSessionById(GlobalConfig.CLIENT_ID).getChannel(), message); + AssertLog.info("发送系统其他信息-可用内存百分比信息包={}",JSON.toJSONString(message)); + } + AssertLog.info("系统其他信息-可用内存百分比采集定时任务执行 - task #{} completed", count); + } + + /** + * 任务14：系统机信息采集任务-总内存采集 + */ + @Async("taskExecutor") + public void memorySizeTotalTask() { + long timestamp = System.currentTimeMillis(); + timestamp = Math.round(timestamp / 1000.0); + int count = memorySizeTotalTask.incrementAndGet(); + AssertLog.info("系统其他信息-总内存采集定时任务执行 - 时间: {}，task #{}", LocalDateTime.now(), count); + // 判定客户端与服务端是否连接 + if (Objects.nonNull(sessionManager.getSessionById(GlobalConfig.CLIENT_ID))) { + // 发送系统信息包 + JSONObject jsonObject = new JSONObject(); + String data = systemService.otherSystem("memorySizeTotalCollect"); + if(StringUtils.isNotBlank(data)){ + jsonObject = JSONObject.parseObject(data); + } + jsonObject.put("timestamp", timestamp); + Message message = Message.builder().clientId(GlobalConfig.CLIENT_ID).dataType(MsgEnum.系统其他上报.getValue()).data(jsonObject.toString()).build(); + sessionManager.writeAndFlush(sessionManager.getSessionById(GlobalConfig.CLIENT_ID).getChannel(), message); + AssertLog.info("发送系统其他信息-总内存信息包={}",JSON.toJSONString(message)); + } + AssertLog.info("系统其他信息-总内存采集定时任务执行 - task #{} completed", count); + } + + /** + * 任务15：系统机信息采集任务-操作系统采集 + */ + @Async("taskExecutor") + public void systemSwOsTask() { + long timestamp = System.currentTimeMillis(); + timestamp = Math.round(timestamp / 1000.0); + int count = systemSwOsTask.incrementAndGet(); + AssertLog.info("系统其他信息-操作系统采集定时任务执行 - 时间: {}，task #{}", LocalDateTime.now(), count); + // 判定客户端与服务端是否连接 + if (Objects.nonNull(sessionManager.getSessionById(GlobalConfig.CLIENT_ID))) { + // 发送系统信息包 + JSONObject jsonObject = new JSONObject(); + String data = systemService.otherSystem("systemSwOsCollect"); + if(StringUtils.isNotBlank(data)){ + jsonObject = JSONObject.parseObject(data); + } + jsonObject.put("timestamp", timestamp); + Message message = Message.builder().clientId(GlobalConfig.CLIENT_ID).dataType(MsgEnum.系统其他上报.getValue()).data(jsonObject.toString()).build(); + sessionManager.writeAndFlush(sessionManager.getSessionById(GlobalConfig.CLIENT_ID).getChannel(), message); + AssertLog.info("发送系统其他信息-操作系统信息包={}",JSON.toJSONString(message)); + } + AssertLog.info("系统其他信息-操作系统采集定时任务执行 - task #{} completed", count); + } + + /** + * 任务16：系统机信息采集任务-操作系统架构采集 + */ + @Async("taskExecutor") + public void systemSwArchTask() { + long timestamp = System.currentTimeMillis(); + timestamp = Math.round(timestamp / 1000.0); + int count = systemSwArchTask.incrementAndGet(); + AssertLog.info("系统其他信息-操作系统架构采集定时任务执行 - 时间: {}，task #{}", LocalDateTime.now(), count); + // 判定客户端与服务端是否连接 + if (Objects.nonNull(sessionManager.getSessionById(GlobalConfig.CLIENT_ID))) { + // 发送系统信息包 + JSONObject jsonObject = new JSONObject(); + String data = systemService.otherSystem("systemSwArchCollect"); + if(StringUtils.isNotBlank(data)){ + jsonObject = JSONObject.parseObject(data); + } + jsonObject.put("timestamp", timestamp); + Message message = Message.builder().clientId(GlobalConfig.CLIENT_ID).dataType(MsgEnum.系统其他上报.getValue()).data(jsonObject.toString()).build(); + sessionManager.writeAndFlush(sessionManager.getSessionById(GlobalConfig.CLIENT_ID).getChannel(), message); + AssertLog.info("发送系统其他信息-操作系统架构信息包={}",JSON.toJSONString(message)); + } + AssertLog.info("系统其他信息-操作系统架构采集定时任务执行 - task #{} completed", count); + } + + /** + * 任务17：系统机信息采集任务-最大进程数采集 + */ + @Async("taskExecutor") + public void kernelMaxprocTask() { + long timestamp = System.currentTimeMillis(); + timestamp = Math.round(timestamp / 1000.0); + int count = kernelMaxprocTask.incrementAndGet(); + AssertLog.info("系统其他信息-最大进程数采集定时任务执行 - 时间: {}，task #{}", LocalDateTime.now(), count); + // 判定客户端与服务端是否连接 + if (Objects.nonNull(sessionManager.getSessionById(GlobalConfig.CLIENT_ID))) { + // 发送系统信息包 + JSONObject jsonObject = new JSONObject(); + String data = systemService.otherSystem("kernelMaxprocCollect"); + if(StringUtils.isNotBlank(data)){ + jsonObject = JSONObject.parseObject(data); + } + jsonObject.put("timestamp", timestamp); + Message message = Message.builder().clientId(GlobalConfig.CLIENT_ID).dataType(MsgEnum.系统其他上报.getValue()).data(jsonObject.toString()).build(); + sessionManager.writeAndFlush(sessionManager.getSessionById(GlobalConfig.CLIENT_ID).getChannel(), message); + AssertLog.info("发送系统其他信息-最大进程数信息包={}",JSON.toJSONString(message)); + } + AssertLog.info("系统其他信息-最大进程数采集定时任务执行 - task #{} completed", count); + } + + /** + * 任务18：系统机信息采集任务-正在运行的进程数采集 + */ + @Async("taskExecutor") + public void procNumRunTask() { + long timestamp = System.currentTimeMillis(); + timestamp = Math.round(timestamp / 1000.0); + int count = procNumRunTask.incrementAndGet(); + AssertLog.info("系统其他信息-正在运行的进程数采集定时任务执行 - 时间: {}，task #{}", LocalDateTime.now(), count); + // 判定客户端与服务端是否连接 + if (Objects.nonNull(sessionManager.getSessionById(GlobalConfig.CLIENT_ID))) { + // 发送系统信息包 + JSONObject jsonObject = new JSONObject(); + String data = systemService.otherSystem("procNumRunCollect"); + if(StringUtils.isNotBlank(data)){ + jsonObject = JSONObject.parseObject(data); + } + jsonObject.put("timestamp", timestamp); + Message message = Message.builder().clientId(GlobalConfig.CLIENT_ID).dataType(MsgEnum.系统其他上报.getValue()).data(jsonObject.toString()).build(); + sessionManager.writeAndFlush(sessionManager.getSessionById(GlobalConfig.CLIENT_ID).getChannel(), message); + AssertLog.info("发送系统其他信息-正在运行的进程数信息包={}",JSON.toJSONString(message)); + } + AssertLog.info("系统其他信息-正在运行的进程数采集定时任务执行 - task #{} completed", count); + } + + /** + * 任务19：系统机信息采集任务-登录用户数采集 + */ + @Async("taskExecutor") + public void systemUsersNumTask() { + long timestamp = System.currentTimeMillis(); + timestamp = Math.round(timestamp / 1000.0); + int count = systemUsersNumTask.incrementAndGet(); + AssertLog.info("系统其他信息-登录用户数采集定时任务执行 - 时间: {}，task #{}", LocalDateTime.now(), count); + // 判定客户端与服务端是否连接 + if (Objects.nonNull(sessionManager.getSessionById(GlobalConfig.CLIENT_ID))) { + // 发送系统信息包 + JSONObject jsonObject = new JSONObject(); + String data = systemService.otherSystem("systemUsersNumCollect"); + if(StringUtils.isNotBlank(data)){ + jsonObject = JSONObject.parseObject(data); + } + jsonObject.put("timestamp", timestamp); + Message message = Message.builder().clientId(GlobalConfig.CLIENT_ID).dataType(MsgEnum.系统其他上报.getValue()).data(jsonObject.toString()).build(); + sessionManager.writeAndFlush(sessionManager.getSessionById(GlobalConfig.CLIENT_ID).getChannel(), message); + AssertLog.info("发送系统其他信息-登录用户数信息包={}",JSON.toJSONString(message)); + } + AssertLog.info("系统其他信息-登录用户数采集定时任务执行 - task #{} completed", count); + } + + /** + * 任务20：系统机信息采集任务-硬盘总可用空间采集 + */ + @Async("taskExecutor") + public void systemDiskSizeTotalTask() { + long timestamp = System.currentTimeMillis(); + timestamp = Math.round(timestamp / 1000.0); + int count = systemDiskSizeTotalTask.incrementAndGet(); + AssertLog.info("系统其他信息-硬盘总可用空间采集定时任务执行 - 时间: {}，task #{}", LocalDateTime.now(), count); + // 判定客户端与服务端是否连接 + if (Objects.nonNull(sessionManager.getSessionById(GlobalConfig.CLIENT_ID))) { + // 发送系统信息包 + JSONObject jsonObject = new JSONObject(); + String data = systemService.otherSystem("systemDiskSizeTotalCollect"); + if(StringUtils.isNotBlank(data)){ + jsonObject = JSONObject.parseObject(data); + } + jsonObject.put("timestamp", timestamp); + Message message = Message.builder().clientId(GlobalConfig.CLIENT_ID).dataType(MsgEnum.系统其他上报.getValue()).data(jsonObject.toString()).build(); + sessionManager.writeAndFlush(sessionManager.getSessionById(GlobalConfig.CLIENT_ID).getChannel(), message); + AssertLog.info("发送系统其他信息-硬盘总可用空间信息包={}",JSON.toJSONString(message)); + } + AssertLog.info("系统其他信息-硬盘总可用空间采集定时任务执行 - task #{} completed", count); + } + + /** + * 任务21：系统机信息采集任务-系统启动时间采集 + */ + @Async("taskExecutor") + public void systemBoottimeTask() { + long timestamp = System.currentTimeMillis(); + timestamp = Math.round(timestamp / 1000.0); + int count = systemBoottimeTask.incrementAndGet(); + AssertLog.info("系统其他信息-系统启动时间采集定时任务执行 - 时间: {}，task #{}", LocalDateTime.now(), count); + // 判定客户端与服务端是否连接 + if (Objects.nonNull(sessionManager.getSessionById(GlobalConfig.CLIENT_ID))) { + // 发送系统信息包 + JSONObject jsonObject = new JSONObject(); + String data = systemService.otherSystem("systemBoottimeCollect"); + if(StringUtils.isNotBlank(data)){ + jsonObject = JSONObject.parseObject(data); + } + jsonObject.put("timestamp", timestamp); + Message message = Message.builder().clientId(GlobalConfig.CLIENT_ID).dataType(MsgEnum.系统其他上报.getValue()).data(jsonObject.toString()).build(); + sessionManager.writeAndFlush(sessionManager.getSessionById(GlobalConfig.CLIENT_ID).getChannel(), message); + AssertLog.info("发送系统其他信息-系统启动时间信息包={}",JSON.toJSONString(message)); + } + AssertLog.info("系统其他信息-系统启动时间采集定时任务执行 - task #{} completed", count); + } + + /** + * 任务22：系统机信息采集任务-系统描述采集 + */ + @Async("taskExecutor") + public void systemUnameTask() { + long timestamp = System.currentTimeMillis(); + timestamp = Math.round(timestamp / 1000.0); + int count = systemUnameTask.incrementAndGet(); + AssertLog.info("系统其他信息-系统描述采集定时任务执行 - 时间: {}，task #{}", LocalDateTime.now(), count); + // 判定客户端与服务端是否连接 + if (Objects.nonNull(sessionManager.getSessionById(GlobalConfig.CLIENT_ID))) { + // 发送系统信息包 + JSONObject jsonObject = new JSONObject(); + String data = systemService.otherSystem("systemUnameCollect"); + if(StringUtils.isNotBlank(data)){ + jsonObject = JSONObject.parseObject(data); + } + jsonObject.put("timestamp", timestamp); + Message message = Message.builder().clientId(GlobalConfig.CLIENT_ID).dataType(MsgEnum.系统其他上报.getValue()).data(jsonObject.toString()).build(); + sessionManager.writeAndFlush(sessionManager.getSessionById(GlobalConfig.CLIENT_ID).getChannel(), message); + AssertLog.info("发送系统其他信息-系统描述信息包={}",JSON.toJSONString(message)); + } + AssertLog.info("系统其他信息-系统描述采集定时任务执行 - task #{} completed", count); + } + + /** + * 任务23：系统机信息采集任务-系统本地时间采集 + */ + @Async("taskExecutor") + public void systemLocaltimeTask() { + long timestamp = System.currentTimeMillis(); + timestamp = Math.round(timestamp / 1000.0); + int count = systemLocaltimeTask.incrementAndGet(); + AssertLog.info("系统其他信息-系统本地时间采集定时任务执行 - 时间: {}，task #{}", LocalDateTime.now(), count); + // 判定客户端与服务端是否连接 + if (Objects.nonNull(sessionManager.getSessionById(GlobalConfig.CLIENT_ID))) { + // 发送系统信息包 + JSONObject jsonObject = new JSONObject(); + String data = systemService.otherSystem("systemLocaltimeCollect"); + if(StringUtils.isNotBlank(data)){ + jsonObject = JSONObject.parseObject(data); + } + jsonObject.put("timestamp", timestamp); + Message message = Message.builder().clientId(GlobalConfig.CLIENT_ID).dataType(MsgEnum.系统其他上报.getValue()).data(jsonObject.toString()).build(); + sessionManager.writeAndFlush(sessionManager.getSessionById(GlobalConfig.CLIENT_ID).getChannel(), message); + AssertLog.info("发送系统其他信息-系统本地时间信息包={}",JSON.toJSONString(message)); + } + AssertLog.info("系统其他信息-系统本地时间采集定时任务执行 - task #{} completed", count); + } + + /** + * 任务24：系统机信息采集任务-系统正常运行时间采集 + */ + @Async("taskExecutor") + public void systemUptimeTask() { + long timestamp = System.currentTimeMillis(); + timestamp = Math.round(timestamp / 1000.0); + int count = systemUptimeTask.incrementAndGet(); + AssertLog.info("系统其他信息-系统正常运行时间采集定时任务执行 - 时间: {}，task #{}", LocalDateTime.now(), count); + // 判定客户端与服务端是否连接 + if (Objects.nonNull(sessionManager.getSessionById(GlobalConfig.CLIENT_ID))) { + // 发送系统信息包 + JSONObject jsonObject = new JSONObject(); + String data = systemService.otherSystem("systemUptimeCollect"); + if(StringUtils.isNotBlank(data)){ + jsonObject = JSONObject.parseObject(data); + } + jsonObject.put("timestamp", timestamp); + Message message = Message.builder().clientId(GlobalConfig.CLIENT_ID).dataType(MsgEnum.系统其他上报.getValue()).data(jsonObject.toString()).build(); + sessionManager.writeAndFlush(sessionManager.getSessionById(GlobalConfig.CLIENT_ID).getChannel(), message); + AssertLog.info("发送系统其他信息-系统正常运行时间信息包={}",JSON.toJSONString(message)); + } + AssertLog.info("系统其他信息-系统正常运行时间采集定时任务执行 - task #{} completed", count); + } + + /** + * 任务25：系统机信息采集任务-进程数采集 + */ + @Async("taskExecutor") + public void procNumTask() { + long timestamp = System.currentTimeMillis(); + timestamp = Math.round(timestamp / 1000.0); + int count = procNumTask.incrementAndGet(); + AssertLog.info("系统其他信息-进程数采集定时任务执行 - 时间: {}，task #{}", LocalDateTime.now(), count); + // 判定客户端与服务端是否连接 + if (Objects.nonNull(sessionManager.getSessionById(GlobalConfig.CLIENT_ID))) { + // 发送系统信息包 + JSONObject jsonObject = new JSONObject(); + String data = systemService.otherSystem("procNumCollect"); + if(StringUtils.isNotBlank(data)){ + jsonObject = JSONObject.parseObject(data); + } + jsonObject.put("timestamp", timestamp); + Message message = Message.builder().clientId(GlobalConfig.CLIENT_ID).dataType(MsgEnum.系统其他上报.getValue()).data(jsonObject.toString()).build(); + sessionManager.writeAndFlush(sessionManager.getSessionById(GlobalConfig.CLIENT_ID).getChannel(), message); + AssertLog.info("发送系统其他信息-进程数信息包={}",JSON.toJSONString(message)); + } + AssertLog.info("系统其他信息-进程数采集定时任务执行 - task #{} completed", count); + } + + /** + * 任务26：交换机网络采集 + */ + @Async("taskExecutor") + public void switchNetTask() { + long timestamp = AgentUtil.roundMinutes(); + int count = switchNetTask.incrementAndGet(); + AssertLog.info("交换机网络采集定时任务执行 - 时间: {}，task #{}", LocalDateTime.now(), count); + // 判定客户端与服务端是否连接 + if (Objects.nonNull(sessionManager.getSessionById(GlobalConfig.CLIENT_ID))) { + // 发送交换机信息包 + JSONObject jsonObject = new JSONObject(); + String data = switchBoardService.getSwitchDataByType("switchNetCollect"); + if(StringUtils.isNotBlank(data)){ + jsonObject = JSONObject.parseObject(data); + } + jsonObject.put("timestamp", timestamp); + Message message = Message.builder().clientId(GlobalConfig.CLIENT_ID).dataType(MsgEnum.交换机上报.getValue()).data(jsonObject.toString()).build(); + sessionManager.writeAndFlush(sessionManager.getSessionById(GlobalConfig.CLIENT_ID).getChannel(), message); + AssertLog.info("发送交换机网络信息包={}",JSON.toJSONString(message)); + } + AssertLog.info("交换机网络采集定时任务执行 - task #{} completed", count); + } + + /** + * 任务27：交换机光模块采集 + */ + @Async("taskExecutor") + public void switchModuleTask() { + long timestamp = AgentUtil.roundMinutes(); + int count = switchModuleTask.incrementAndGet(); + AssertLog.info("交换机光模块采集定时任务执行 - 时间: {}，task #{}", LocalDateTime.now(), count); + // 判定客户端与服务端是否连接 + if (Objects.nonNull(sessionManager.getSessionById(GlobalConfig.CLIENT_ID))) { + // 发送交换机信息包 + JSONObject jsonObject = new JSONObject(); + String data = switchBoardService.getSwitchDataByType("switchModuleCollect"); + if(StringUtils.isNotBlank(data)){ + jsonObject = JSONObject.parseObject(data); + } + jsonObject.put("timestamp", timestamp); + Message message = Message.builder().clientId(GlobalConfig.CLIENT_ID).dataType(MsgEnum.交换机上报.getValue()).data(jsonObject.toString()).build(); + sessionManager.writeAndFlush(sessionManager.getSessionById(GlobalConfig.CLIENT_ID).getChannel(), message); + AssertLog.info("发送交换机光模块信息包={}",JSON.toJSONString(message)); + } + AssertLog.info("交换机光模块采集定时任务执行 - task #{} completed", count); + } + + /** + * 任务28：交换机MPU采集 + */ + @Async("taskExecutor") + public void switchMpuTask() { + long timestamp = System.currentTimeMillis(); + timestamp = Math.round(timestamp / 1000.0); + int count = switchMpuTask.incrementAndGet(); + AssertLog.info("交换机MPU采集定时任务执行 - 时间: {}，task #{}", LocalDateTime.now(), count); + // 判定客户端与服务端是否连接 + if (Objects.nonNull(sessionManager.getSessionById(GlobalConfig.CLIENT_ID))) { + // 发送交换机信息包 + JSONObject jsonObject = new JSONObject(); + String data = switchBoardService.getSwitchDataByType("switchMpuCollect"); + if(StringUtils.isNotBlank(data)){ + jsonObject = JSONObject.parseObject(data); + } + jsonObject.put("timestamp", timestamp); + Message message = Message.builder().clientId(GlobalConfig.CLIENT_ID).dataType(MsgEnum.交换机上报.getValue()).data(jsonObject.toString()).build(); + sessionManager.writeAndFlush(sessionManager.getSessionById(GlobalConfig.CLIENT_ID).getChannel(), message); + AssertLog.info("发送交换机MPU信息包={}",JSON.toJSONString(message)); + } + AssertLog.info("交换机MPU采集定时任务执行 - task #{} completed", count); + } + + /** + * 任务29：交换机电源采集 + */ + @Async("taskExecutor") + public void switchPwrTask() { + long timestamp = System.currentTimeMillis(); + timestamp = Math.round(timestamp / 1000.0); + int count = switchPwrTask.incrementAndGet(); + AssertLog.info("交换机电源采集定时任务执行 - 时间: {}，task #{}", LocalDateTime.now(), count); + // 判定客户端与服务端是否连接 + if (Objects.nonNull(sessionManager.getSessionById(GlobalConfig.CLIENT_ID))) { + // 发送交换机信息包 + JSONObject jsonObject = new JSONObject(); + String data = switchBoardService.getSwitchDataByType("switchPwrCollect"); + if(StringUtils.isNotBlank(data)){ + jsonObject = JSONObject.parseObject(data); + } + jsonObject.put("timestamp", timestamp); + Message message = Message.builder().clientId(GlobalConfig.CLIENT_ID).dataType(MsgEnum.交换机上报.getValue()).data(jsonObject.toString()).build(); + sessionManager.writeAndFlush(sessionManager.getSessionById(GlobalConfig.CLIENT_ID).getChannel(), message); + AssertLog.info("发送交换机电源信息包={}",JSON.toJSONString(message)); + } + AssertLog.info("交换机电源采集定时任务执行 - task #{} completed", count); + } + + /** + * 任务30：交换机风扇采集 + */ + @Async("taskExecutor") + public void switchFanTask() { + long timestamp = System.currentTimeMillis(); + timestamp = Math.round(timestamp / 1000.0); + int count = switchFanTask.incrementAndGet(); + AssertLog.info("交换机风扇采集采集定时任务执行 - 时间: {}，task #{}", LocalDateTime.now(), count); + // 判定客户端与服务端是否连接 + if (Objects.nonNull(sessionManager.getSessionById(GlobalConfig.CLIENT_ID))) { + // 发送交换机信息包 + JSONObject jsonObject = new JSONObject(); + String data = switchBoardService.getSwitchDataByType("switchFanCollect"); + if(StringUtils.isNotBlank(data)){ + jsonObject = JSONObject.parseObject(data); + } + jsonObject.put("timestamp", timestamp); + Message message = Message.builder().clientId(GlobalConfig.CLIENT_ID).dataType(MsgEnum.交换机上报.getValue()).data(jsonObject.toString()).build(); + sessionManager.writeAndFlush(sessionManager.getSessionById(GlobalConfig.CLIENT_ID).getChannel(), message); + AssertLog.info("发送交换机风扇信息包={}",JSON.toJSONString(message)); + } + AssertLog.info("交换机风扇采集定时任务执行 - task #{} completed", count); + } + + /** + * 任务31：交换机其他信息-系统描述采集 + */ + @Async("taskExecutor") + public void switchSysDescrTask() { + long timestamp = System.currentTimeMillis(); + timestamp = Math.round(timestamp / 1000.0); + int count = switchSysDescrTask.incrementAndGet(); + AssertLog.info("交换机其他信息-系统描述采集定时任务执行 - 时间: {}，task #{}", LocalDateTime.now(), count); + // 判定客户端与服务端是否连接 + if (Objects.nonNull(sessionManager.getSessionById(GlobalConfig.CLIENT_ID))) { + // 发送交换机信息包 + JSONObject jsonObject = new JSONObject(); + String data = switchBoardService.getSwitchDataByType("switchSysDescrCollect"); + if(StringUtils.isNotBlank(data)){ + jsonObject = JSONObject.parseObject(data); + } + jsonObject.put("timestamp", timestamp); + Message message = Message.builder().clientId(GlobalConfig.CLIENT_ID).dataType(MsgEnum.交换机上报.getValue()).data(jsonObject.toString()).build(); + sessionManager.writeAndFlush(sessionManager.getSessionById(GlobalConfig.CLIENT_ID).getChannel(), message); + AssertLog.info("发送交换机其他信息-系统描述信息包={}",JSON.toJSONString(message)); + } + AssertLog.info("交换机其他信息-系统描述采集定时任务执行 - task #{} completed", count); + } + + /** + * 任务32：交换机其他信息-系统ObjectID采集 + */ + @Async("taskExecutor") + public void switchSysObjectIDTask() { + long timestamp = System.currentTimeMillis(); + timestamp = Math.round(timestamp / 1000.0); + int count = switchSysObjectIDTask.incrementAndGet(); + AssertLog.info("交换机其他信息-系统ObjectID采集定时任务执行 - 时间: {}，task #{}", LocalDateTime.now(), count); + // 判定客户端与服务端是否连接 + if (Objects.nonNull(sessionManager.getSessionById(GlobalConfig.CLIENT_ID))) { + // 发送交换机信息包 + JSONObject jsonObject = new JSONObject(); + String data = switchBoardService.getSwitchDataByType("switchSysObjectIDCollect"); + if(StringUtils.isNotBlank(data)){ + jsonObject = JSONObject.parseObject(data); + } + jsonObject.put("timestamp", timestamp); + Message message = Message.builder().clientId(GlobalConfig.CLIENT_ID).dataType(MsgEnum.交换机上报.getValue()).data(jsonObject.toString()).build(); + sessionManager.writeAndFlush(sessionManager.getSessionById(GlobalConfig.CLIENT_ID).getChannel(), message); + AssertLog.info("发送交换机其他信息-系统ObjectID信息包={}",JSON.toJSONString(message)); + } + AssertLog.info("交换机其他信息-系统ObjectID采集定时任务执行 - task #{} completed", count); + } + + /** + * 任务33：交换机其他信息-系统运行时间采集 + */ + @Async("taskExecutor") + public void switchSysUpTimeTask() { + long timestamp = System.currentTimeMillis(); + timestamp = Math.round(timestamp / 1000.0); + int count = switchSysUpTimeTask.incrementAndGet(); + AssertLog.info("交换机其他信息-系统运行时间采集定时任务执行 - 时间: {}，task #{}", LocalDateTime.now(), count); + // 判定客户端与服务端是否连接 + if (Objects.nonNull(sessionManager.getSessionById(GlobalConfig.CLIENT_ID))) { + // 发送交换机信息包 + JSONObject jsonObject = new JSONObject(); + String data = switchBoardService.getSwitchDataByType("switchSysUpTimeCollect"); + if(StringUtils.isNotBlank(data)){ + jsonObject = JSONObject.parseObject(data); + } + jsonObject.put("timestamp", timestamp); + Message message = Message.builder().clientId(GlobalConfig.CLIENT_ID).dataType(MsgEnum.交换机上报.getValue()).data(jsonObject.toString()).build(); + sessionManager.writeAndFlush(sessionManager.getSessionById(GlobalConfig.CLIENT_ID).getChannel(), message); + AssertLog.info("发送交换机其他信息-系统运行时间信息包={}",JSON.toJSONString(message)); + } + AssertLog.info("交换机其他信息-系统运行时间采集定时任务执行 - task #{} completed", count); + } + + /** + * 任务34：交换机其他信息-系统联系信息采集 + */ + @Async("taskExecutor") + public void switchSysContactTask() { + long timestamp = System.currentTimeMillis(); + timestamp = Math.round(timestamp / 1000.0); + int count = switchSysContactTask.incrementAndGet(); + AssertLog.info("交换机其他信息-系统联系信息采集定时任务执行 - 时间: {}，task #{}", LocalDateTime.now(), count); + // 判定客户端与服务端是否连接 + if (Objects.nonNull(sessionManager.getSessionById(GlobalConfig.CLIENT_ID))) { + // 发送交换机信息包 + JSONObject jsonObject = new JSONObject(); + String data = switchBoardService.getSwitchDataByType("switchSysContactCollect"); + if(StringUtils.isNotBlank(data)){ + jsonObject = JSONObject.parseObject(data); + } + jsonObject.put("timestamp", timestamp); + Message message = Message.builder().clientId(GlobalConfig.CLIENT_ID).dataType(MsgEnum.交换机上报.getValue()).data(jsonObject.toString()).build(); + sessionManager.writeAndFlush(sessionManager.getSessionById(GlobalConfig.CLIENT_ID).getChannel(), message); + AssertLog.info("发送交换机其他信息-系统联系信息包={}",JSON.toJSONString(message)); + } + AssertLog.info("交换机其他信息-系统联系信息采集定时任务执行 - task #{} completed", count); + } + + /** + * 任务35：交换机其他信息-系统名称采集 + */ + @Async("taskExecutor") + public void switchSysNameTask() { + long timestamp = System.currentTimeMillis(); + timestamp = Math.round(timestamp / 1000.0); + int count = switchSysNameTask.incrementAndGet(); + AssertLog.info("交换机其他信息-系统名称采集定时任务执行 - 时间: {}，task #{}", LocalDateTime.now(), count); + // 判定客户端与服务端是否连接 + if (Objects.nonNull(sessionManager.getSessionById(GlobalConfig.CLIENT_ID))) { + // 发送交换机信息包 + JSONObject jsonObject = new JSONObject(); + String data = switchBoardService.getSwitchDataByType("switchSysNameCollect"); + if(StringUtils.isNotBlank(data)){ + jsonObject = JSONObject.parseObject(data); + } + jsonObject.put("timestamp", timestamp); + Message message = Message.builder().clientId(GlobalConfig.CLIENT_ID).dataType(MsgEnum.交换机上报.getValue()).data(jsonObject.toString()).build(); + sessionManager.writeAndFlush(sessionManager.getSessionById(GlobalConfig.CLIENT_ID).getChannel(), message); + AssertLog.info("发送交换机其他信息-系统名称信息包={}",JSON.toJSONString(message)); + } + AssertLog.info("交换机其他信息-系统名称信息采集定时任务执行 - task #{} completed", count); + } + + /** + * 任务36：交换机其他信息-系统位置采集 + */ + @Async("taskExecutor") + public void switchSysLocationTask() { + long timestamp = System.currentTimeMillis(); + timestamp = Math.round(timestamp / 1000.0); + int count = switchSysLocationTask.incrementAndGet(); + AssertLog.info("交换机其他信息-系统位置采集定时任务执行 - 时间: {}，task #{}", LocalDateTime.now(), count); + // 判定客户端与服务端是否连接 + if (Objects.nonNull(sessionManager.getSessionById(GlobalConfig.CLIENT_ID))) { + // 发送交换机信息包 + JSONObject jsonObject = new JSONObject(); + String data = switchBoardService.getSwitchDataByType("switchSysLocationCollect"); + if(StringUtils.isNotBlank(data)){ + jsonObject = JSONObject.parseObject(data); + } + jsonObject.put("timestamp", timestamp); + Message message = Message.builder().clientId(GlobalConfig.CLIENT_ID).dataType(MsgEnum.交换机上报.getValue()).data(jsonObject.toString()).build(); + sessionManager.writeAndFlush(sessionManager.getSessionById(GlobalConfig.CLIENT_ID).getChannel(), message); + AssertLog.info("发送交换机其他信息-系统位置信息包={}",JSON.toJSONString(message)); + } + AssertLog.info("交换机其他信息-系统位置采集定时任务执行 - task #{} completed", count); + } + + /** + * 任务37：交换机其他信息-系统MAC地址采集 + */ + @Async("taskExecutor") + public void switchHwStackSystemMacTask() { + long timestamp = System.currentTimeMillis(); + timestamp = Math.round(timestamp / 1000.0); + int count = switchHwStackSystemMacTask.incrementAndGet(); + AssertLog.info("交换机其他信息-系统MAC地址采集定时任务执行 - 时间: {}，task #{}", LocalDateTime.now(), count); + // 判定客户端与服务端是否连接 + if (Objects.nonNull(sessionManager.getSessionById(GlobalConfig.CLIENT_ID))) { + // 发送交换机信息包 + JSONObject jsonObject = new JSONObject(); + String data = switchBoardService.getSwitchDataByType("switchHwStackSystemMacCollect"); + if(StringUtils.isNotBlank(data)){ + jsonObject = JSONObject.parseObject(data); + } + jsonObject.put("timestamp", timestamp); + Message message = Message.builder().clientId(GlobalConfig.CLIENT_ID).dataType(MsgEnum.交换机上报.getValue()).data(jsonObject.toString()).build(); + sessionManager.writeAndFlush(sessionManager.getSessionById(GlobalConfig.CLIENT_ID).getChannel(), message); + AssertLog.info("发送交换机其他信息-系统MAC地址信息包={}",JSON.toJSONString(message)); + } + AssertLog.info("交换机其他信息-系统MAC地址采集定时任务执行 - task #{} completed", count); + } + + /** + * 任务38：交换机其他信息-设备索引采集 + */ + @Async("taskExecutor") + public void switchEntIndexTask() { + long timestamp = System.currentTimeMillis(); + timestamp = Math.round(timestamp / 1000.0); + int count = switchEntIndexTask.incrementAndGet(); + AssertLog.info("交换机其他信息-设备索引采集定时任务执行 - 时间: {}，task #{}", LocalDateTime.now(), count); + // 判定客户端与服务端是否连接 + if (Objects.nonNull(sessionManager.getSessionById(GlobalConfig.CLIENT_ID))) { + // 发送交换机信息包 + JSONObject jsonObject = new JSONObject(); + String data = switchBoardService.getSwitchDataByType("switchEntIndexCollect"); + if(StringUtils.isNotBlank(data)){ + jsonObject = JSONObject.parseObject(data); + } + jsonObject.put("timestamp", timestamp); + Message message = Message.builder().clientId(GlobalConfig.CLIENT_ID).dataType(MsgEnum.交换机上报.getValue()).data(jsonObject.toString()).build(); + sessionManager.writeAndFlush(sessionManager.getSessionById(GlobalConfig.CLIENT_ID).getChannel(), message); + AssertLog.info("发送交换机其他信息-设备索引信息包={}",JSON.toJSONString(message)); + } + AssertLog.info("交换机其他信息-设备索引采集定时任务执行 - task #{} completed", count); + } + + /** + * 任务39：交换机其他信息-设备名称采集 + */ + @Async("taskExecutor") + public void switchEntPhysicalNameTask() { + long timestamp = System.currentTimeMillis(); + timestamp = Math.round(timestamp / 1000.0); + int count = switchEntPhysicalNameTask.incrementAndGet(); + AssertLog.info("交换机其他信息-设备名称采集定时任务执行 - 时间: {}，task #{}", LocalDateTime.now(), count); + // 判定客户端与服务端是否连接 + if (Objects.nonNull(sessionManager.getSessionById(GlobalConfig.CLIENT_ID))) { + // 发送交换机信息包 + JSONObject jsonObject = new JSONObject(); + String data = switchBoardService.getSwitchDataByType("switchEntPhysicalNameCollect"); + if(StringUtils.isNotBlank(data)){ + jsonObject = JSONObject.parseObject(data); + } + jsonObject.put("timestamp", timestamp); + Message message = Message.builder().clientId(GlobalConfig.CLIENT_ID).dataType(MsgEnum.交换机上报.getValue()).data(jsonObject.toString()).build(); + sessionManager.writeAndFlush(sessionManager.getSessionById(GlobalConfig.CLIENT_ID).getChannel(), message); + AssertLog.info("发送交换机其他信息-设备名称信息包={}",JSON.toJSONString(message)); + } + AssertLog.info("交换机其他信息-设备名称采集定时任务执行 - task #{} completed", count); + } + + /** + * 任务40：交换机其他信息-设备软件版本采集 + */ + @Async("taskExecutor") + public void switchEntPhysicalSoftwareRevTask() { + long timestamp = System.currentTimeMillis(); + timestamp = Math.round(timestamp / 1000.0); + int count = switchEntPhysicalSoftwareRevTask.incrementAndGet(); + AssertLog.info("交换机其他信息-设备软件版本采集定时任务执行 - 时间: {}，task #{}", LocalDateTime.now(), count); + // 判定客户端与服务端是否连接 + if (Objects.nonNull(sessionManager.getSessionById(GlobalConfig.CLIENT_ID))) { + // 发送交换机信息包 + JSONObject jsonObject = new JSONObject(); + String data = switchBoardService.getSwitchDataByType("switchEntPhysicalSoftwareRevCollect"); + if(StringUtils.isNotBlank(data)){ + jsonObject = JSONObject.parseObject(data); + } + jsonObject.put("timestamp", timestamp); + Message message = Message.builder().clientId(GlobalConfig.CLIENT_ID).dataType(MsgEnum.交换机上报.getValue()).data(jsonObject.toString()).build(); + sessionManager.writeAndFlush(sessionManager.getSessionById(GlobalConfig.CLIENT_ID).getChannel(), message); + AssertLog.info("发送交换机其他信息-设备软件版本信息包={}",JSON.toJSONString(message)); + } + AssertLog.info("交换机其他信息-设备软件版本采集定时任务执行 - task #{} completed", count); + } + + /** + * 任务41：交换机其他信息-设备CPU使用率采集 + */ + @Async("taskExecutor") + public void switchHwEntityCpuUsageTask() { + long timestamp = System.currentTimeMillis(); + timestamp = Math.round(timestamp / 1000.0); + int count = switchHwEntityCpuUsageTask.incrementAndGet(); + AssertLog.info("交换机其他信息-设备CPU使用率采集定时任务执行 - 时间: {}，task #{}", LocalDateTime.now(), count); + // 判定客户端与服务端是否连接 + if (Objects.nonNull(sessionManager.getSessionById(GlobalConfig.CLIENT_ID))) { + // 发送交换机信息包 + JSONObject jsonObject = new JSONObject(); + String data = switchBoardService.getSwitchDataByType("switchHwEntityCpuUsageCollect"); + if(StringUtils.isNotBlank(data)){ + jsonObject = JSONObject.parseObject(data); + } + jsonObject.put("timestamp", timestamp); + Message message = Message.builder().clientId(GlobalConfig.CLIENT_ID).dataType(MsgEnum.交换机上报.getValue()).data(jsonObject.toString()).build(); + sessionManager.writeAndFlush(sessionManager.getSessionById(GlobalConfig.CLIENT_ID).getChannel(), message); + AssertLog.info("发送交换机其他信息-设备CPU使用率信息包={}",JSON.toJSONString(message)); + } + AssertLog.info("交换机其他信息-设备CPU使用率采集定时任务执行 - task #{} completed", count); + } + + /** + * 任务42：交换机其他信息-设备内存使用率采集 + */ + @Async("taskExecutor") + public void switchHwEntityMemUsageTask() { + long timestamp = System.currentTimeMillis(); + timestamp = Math.round(timestamp / 1000.0); + int count = switchHwEntityMemUsageTask.incrementAndGet(); + AssertLog.info("交换机其他信息-设备内存使用率采集定时任务执行 - 时间: {}，task #{}", LocalDateTime.now(), count); + // 判定客户端与服务端是否连接 + if (Objects.nonNull(sessionManager.getSessionById(GlobalConfig.CLIENT_ID))) { + // 发送交换机信息包 + JSONObject jsonObject = new JSONObject(); + String data = switchBoardService.getSwitchDataByType("switchHwEntityMemUsageCollect"); + if(StringUtils.isNotBlank(data)){ + jsonObject = JSONObject.parseObject(data); + } + jsonObject.put("timestamp", timestamp); + Message message = Message.builder().clientId(GlobalConfig.CLIENT_ID).dataType(MsgEnum.交换机上报.getValue()).data(jsonObject.toString()).build(); + sessionManager.writeAndFlush(sessionManager.getSessionById(GlobalConfig.CLIENT_ID).getChannel(), message); + AssertLog.info("发送交换机其他信息-设备内存使用率信息包={}",JSON.toJSONString(message)); + } + AssertLog.info("交换机其他信息-设备内存使用率采集定时任务执行 - task #{} completed", count); + } + + /** + * 任务43：交换机其他信息-系统平均功率采集 + */ + @Async("taskExecutor") + public void switchHwAveragePowerTask() { + long timestamp = System.currentTimeMillis(); + timestamp = Math.round(timestamp / 1000.0); + int count = switchHwAveragePowerTask.incrementAndGet(); + AssertLog.info("交换机其他信息-系统平均功率采集定时任务执行 - 时间: {}，task #{}", LocalDateTime.now(), count); + // 判定客户端与服务端是否连接 + if (Objects.nonNull(sessionManager.getSessionById(GlobalConfig.CLIENT_ID))) { + // 发送交换机信息包 + JSONObject jsonObject = new JSONObject(); + String data = switchBoardService.getSwitchDataByType("switchHwAveragePowerCollect"); + if(StringUtils.isNotBlank(data)){ + jsonObject = JSONObject.parseObject(data); + } + jsonObject.put("timestamp", timestamp); + Message message = Message.builder().clientId(GlobalConfig.CLIENT_ID).dataType(MsgEnum.交换机上报.getValue()).data(jsonObject.toString()).build(); + sessionManager.writeAndFlush(sessionManager.getSessionById(GlobalConfig.CLIENT_ID).getChannel(), message); + AssertLog.info("发送交换机其他信息-系统平均功率信息包={}",JSON.toJSONString(message)); + } + AssertLog.info("交换机其他信息-系统平均功率采集定时任务执行 - task #{} completed", count); + } + + /** + * 任务44：交换机其他信息-系统实时功率采集 + */ + @Async("taskExecutor") + public void switchHwCurrentPowerTask() { + long timestamp = System.currentTimeMillis(); + timestamp = Math.round(timestamp / 1000.0); + int count = switchHwCurrentPowerTask.incrementAndGet(); + AssertLog.info("交换机其他信息-系统实时功率采集定时任务执行 - 时间: {}，task #{}", LocalDateTime.now(), count); + // 判定客户端与服务端是否连接 + if (Objects.nonNull(sessionManager.getSessionById(GlobalConfig.CLIENT_ID))) { + // 发送交换机信息包 + JSONObject jsonObject = new JSONObject(); + String data = switchBoardService.getSwitchDataByType("switchHwCurrentPowerCollect"); + if(StringUtils.isNotBlank(data)){ + jsonObject = JSONObject.parseObject(data); + } + jsonObject.put("timestamp", timestamp); + Message message = Message.builder().clientId(GlobalConfig.CLIENT_ID).dataType(MsgEnum.交换机上报.getValue()).data(jsonObject.toString()).build(); + sessionManager.writeAndFlush(sessionManager.getSessionById(GlobalConfig.CLIENT_ID).getChannel(), message); + AssertLog.info("发送交换机其他信息-系统实时功率信息包={}",JSON.toJSONString(message)); + } + AssertLog.info("交换机其他信息-系统实时功率采集定时任务执行 - task #{} completed", count); + } + + + + +// +// @Async("taskExecutor") +// public void systemTask(String type) { +// long timestamp = System.currentTimeMillis(); +// timestamp = Math.round(timestamp / 1000.0); +// int count = task9Counter.incrementAndGet(); +// AssertLog.info("系统信息采集定时任务执行 - 时间: {}，task #{}", LocalDateTime.now(), count); +// // 判定客户端与服务端是否连接 +// if (Objects.nonNull(sessionManager.getSessionById(GlobalConfig.CLIENT_ID))) { +// // 发送系统信息包 +//// SystemVO systemVO = systemService.get(); +//// systemVO.setTimestamp(timestamp); +//// String data = JSON.toJSONString(systemVO); +//// Message message = Message.builder().clientId(GlobalConfig.CLIENT_ID).dataType(MsgEnum.系统其他上报.getValue()).data(data).build(); +// JSONObject jsonObject = new JSONObject(); +// String data = systemService.otherSystem(type); +// if(StringUtils.isNotBlank(data)){ +// jsonObject = JSONObject.parseObject(data); +// } +// jsonObject.put("timestamp", timestamp); +// Message message = Message.builder().clientId(GlobalConfig.CLIENT_ID).dataType(MsgEnum.系统其他上报.getValue()).data(jsonObject.toString()).build(); +// sessionManager.writeAndFlush(sessionManager.getSessionById(GlobalConfig.CLIENT_ID).getChannel(), message); +// AssertLog.info("发送系统信息包={}",JSON.toJSONString(message)); +// } +// AssertLog.info("系统信息采集定时任务执行 - task #{} completed", count); +// } + + +// /** +// * 任务8：交换机信息采集任务 +// */ +// @Async("taskExecutor") +// public void switchBoardTask(String type) { +// long timestamp = System.currentTimeMillis(); +// timestamp = Math.round(timestamp / 1000.0); +//// long timestamp = AgentUtil.roundMinutes(); +// int count = task8Counter.incrementAndGet(); +// AssertLog.info("交换机信息采集定时任务执行 - 时间: {}，task #{}", LocalDateTime.now(), count); +// // 判定客户端与服务端是否连接 +// if (Objects.nonNull(sessionManager.getSessionById(GlobalConfig.CLIENT_ID))) { +// // 发送交换机信息包 +//// List list = switchBoardService.switchBoardList(timestamp); +//// String data = JSONArray.toJSONString(list); +//// Message message = Message.builder().clientId(GlobalConfig.CLIENT_ID).dataType(MsgEnum.交换机上报.getValue()).data(data).build(); +// JSONObject jsonObject = new JSONObject(); +// String data = switchBoardService.getSwitchDataByType(type); +// if(StringUtils.isNotBlank(data)){ +// jsonObject = JSONObject.parseObject(data); +// } +// jsonObject.put("timestamp", timestamp); +// Message message = Message.builder().clientId(GlobalConfig.CLIENT_ID).dataType(MsgEnum.交换机上报.getValue()).data(jsonObject.toString()).build(); +// sessionManager.writeAndFlush(sessionManager.getSessionById(GlobalConfig.CLIENT_ID).getChannel(), message); +// AssertLog.info("发送交换机信息包={}",JSON.toJSONString(message)); +// } +// AssertLog.info("交换机信息采集定时任务执行 - task #{} completed", count); +// } + + + + + } \ No newline at end of file diff --git a/src/main/java/com/tongran/agent/client/scheduler/service/DynamicTaskService.java b/src/main/java/com/tongran/agent/client/scheduler/service/DynamicTaskService.java index c88874c..c96fe67 100644 --- a/src/main/java/com/tongran/agent/client/scheduler/service/DynamicTaskService.java +++ b/src/main/java/com/tongran/agent/client/scheduler/service/DynamicTaskService.java @@ -55,16 +55,25 @@ public class DynamicTaskService { lastExecutionTimes.put(taskId, startTime); try { + System.out.printf("开始执行任务: %s, 线程: %s%n", + taskId, Thread.currentThread().getName()); + // 添加前置检查 + if (originalTask == null) { + throw new IllegalArgumentException("原始任务不能为null"); + } originalTask.run(); + System.out.printf("任务 %s 执行成功%n", taskId); } catch (Exception e) { - System.err.println("Task " + taskId + " execution failed: " + e.getMessage()); + System.err.printf("任务 %s 执行失败: %s%n", taskId, e.getMessage()); +// System.err.println("Task " + taskId + " execution failed: " + e.getMessage()); } finally { long endTime = System.currentTimeMillis(); long executionTime = endTime - startTime; taskExecutions.get(taskId).incrementAndGet(); - - System.out.printf("Task %s executed in %dms, total executions: %d%n", - taskId, executionTime, taskExecutions.get(taskId).get()); +// System.out.printf("Task %s executed in %dms, total executions: %d%n", +// taskId, executionTime, taskExecutions.get(taskId).get()); + System.out.printf("任务 %s 执行耗时: %dms, 总执行次数: %d%n", + taskId, executionTime, taskExecutions.get(taskId).get()); } }; } diff --git a/src/main/java/com/tongran/agent/client/service/impl/AgentServiceImpl.java b/src/main/java/com/tongran/agent/client/service/impl/AgentServiceImpl.java index d85890d..3e46227 100644 --- a/src/main/java/com/tongran/agent/client/service/impl/AgentServiceImpl.java +++ b/src/main/java/com/tongran/agent/client/service/impl/AgentServiceImpl.java @@ -144,187 +144,241 @@ public class AgentServiceImpl implements AgentService { } } break; - default: //系统其他采集 - boolean flag = false; - if(StringUtils.equals(type, "systemSwapSizeFreeCollect")){ - if(GlobalConfig.systemSwapSizeFreeCollect != collect || GlobalConfig.systemSwapSizeFreeInterval != interval){ - flag = true; - GlobalConfig.systemSwapSizeFreeCollect = collect; - GlobalConfig.systemSwapSizeFreeInterval = interval; - if(!collect){ - GlobalConfig.systemSwapSizeFreeInterval = 300; - } - } - } - if(StringUtils.equals(type, "memoryUtilizationCollect")){ - if(GlobalConfig.memoryUtilizationCollect != collect || GlobalConfig.memoryUtilizationInterval != interval){ - flag = true; - GlobalConfig.memoryUtilizationCollect = collect; - GlobalConfig.memoryUtilizationInterval = interval; - if(!collect){ - GlobalConfig.memoryUtilizationInterval = 300; - } - } - } - if(StringUtils.equals(type, "systemSwapSizePercentCollect")){ - if(GlobalConfig.systemSwapSizePercentCollect != collect || GlobalConfig.systemSwapSizePercentInterval != interval){ - flag = true; - GlobalConfig.systemSwapSizePercentCollect = collect; - GlobalConfig.systemSwapSizePercentInterval = interval; - if(!collect){ - GlobalConfig.systemSwapSizePercentInterval = 300; - } - } - } - if(StringUtils.equals(type, "memorySizeAvailableCollect")){ - if(GlobalConfig.memorySizeAvailableCollect != collect || GlobalConfig.memorySizeAvailableInterval != interval){ - flag = true; - GlobalConfig.memorySizeAvailableCollect = collect; - GlobalConfig.memorySizeAvailableInterval = interval; - if(!collect){ - GlobalConfig.memorySizeAvailableInterval = 300; - } - } - } - if(StringUtils.equals(type, "memorySizePercentCollect")){ - if(GlobalConfig.memorySizePercentCollect != collect || GlobalConfig.memorySizePercentInterval != interval){ - flag = true; - GlobalConfig.memorySizePercentCollect = collect; - GlobalConfig.memorySizePercentInterval = interval; - if(!collect){ - GlobalConfig.memorySizePercentInterval = 300; - } - } - } - if(StringUtils.equals(type, "memorySizeTotalCollect")){ - if(GlobalConfig.memorySizeTotalCollect != collect || GlobalConfig.memorySizeTotalInterval != interval){ - flag = true; - GlobalConfig.memorySizeTotalCollect = collect; - GlobalConfig.memorySizeTotalInterval = interval; - if(!collect){ - GlobalConfig.memorySizeTotalInterval = 300; - } - } - } - if(StringUtils.equals(type, "systemSwOsCollect")){ - if(GlobalConfig.systemSwOsCollect != collect || GlobalConfig.systemSwOsInterval != interval){ - flag = true; - GlobalConfig.systemSwOsCollect = collect; - GlobalConfig.systemSwOsInterval = interval; - if(!collect){ - GlobalConfig.systemSwOsInterval = 300; - } - } - } - if(StringUtils.equals(type, "systemSwArchCollect")){ - if(GlobalConfig.systemSwArchCollect != collect || GlobalConfig.systemSwArchInterval != interval){ - flag = true; - GlobalConfig.systemSwArchCollect = collect; - GlobalConfig.systemSwArchInterval = interval; - if(!collect){ - GlobalConfig.systemSwArchInterval = 300; - } - } - } - if(StringUtils.equals(type, "kernelMaxprocCollect")){ - if(GlobalConfig.kernelMaxprocCollect != collect || GlobalConfig.kernelMaxprocInterval != interval){ - flag = true; - GlobalConfig.kernelMaxprocCollect = collect; - GlobalConfig.kernelMaxprocInterval = interval; - if(!collect){ - GlobalConfig.kernelMaxprocInterval = 300; - } - } - } - if(StringUtils.equals(type, "procNumRunCollect")){ - if(GlobalConfig.procNumRunCollect != collect || GlobalConfig.procNumRunInterval != interval){ - flag = true; - GlobalConfig.procNumRunCollect = collect; - GlobalConfig.procNumRunInterval = interval; - if(!collect){ - GlobalConfig.procNumRunInterval = 300; - } - } - } - if(StringUtils.equals(type, "systemUsersNumCollect")){ - if(GlobalConfig.systemUsersNumCollect != collect || GlobalConfig.systemUsersNumInterval != interval){ - flag = true; - GlobalConfig.systemUsersNumCollect = collect; - GlobalConfig.systemUsersNumInterval = interval; - if(!collect){ - GlobalConfig.systemUsersNumInterval = 300; - } - } - } - if(StringUtils.equals(type, "systemDiskSizeTotalCollect")){ - if(GlobalConfig.systemDiskSizeTotalCollect != collect || GlobalConfig.systemDiskSizeTotalInterval != interval){ - flag = true; - GlobalConfig.systemDiskSizeTotalCollect = collect; - GlobalConfig.systemDiskSizeTotalInterval = interval; - if(!collect){ - GlobalConfig.systemDiskSizeTotalInterval = 300; - } - } - } - if(StringUtils.equals(type, "systemBoottimeCollect")){ - if(GlobalConfig.systemBoottimeCollect != collect || GlobalConfig.systemBoottimeInterval != interval){ - flag = true; - GlobalConfig.systemBoottimeCollect = collect; - GlobalConfig.systemBoottimeInterval = interval; - if(!collect){ - GlobalConfig.systemBoottimeInterval = 300; - } - } - } - if(StringUtils.equals(type, "systemUnameCollect")){ - if(GlobalConfig.systemUnameCollect != collect || GlobalConfig.systemUnameInterval != interval){ - flag = true; - GlobalConfig.systemUnameCollect = collect; - GlobalConfig.systemUnameInterval = interval; - if(!collect){ - GlobalConfig.systemUnameInterval = 300; - } - } - } - if(StringUtils.equals(type, "systemLocaltimeCollect")){ - if(GlobalConfig.systemLocaltimeCollect != collect || GlobalConfig.systemLocaltimeInterval != interval){ - flag = true; - GlobalConfig.systemLocaltimeCollect = collect; - GlobalConfig.systemLocaltimeInterval = interval; - if(!collect){ - GlobalConfig.systemLocaltimeInterval = 300; - } - } - } - if(StringUtils.equals(type, "systemUptimeCollect")){ - if(GlobalConfig.systemUptimeCollect != collect || GlobalConfig.systemUptimeInterval != interval){ - flag = true; - GlobalConfig.systemUptimeCollect = collect; - GlobalConfig.systemUptimeInterval = c.getInterval(); - if(!collect){ - GlobalConfig.systemUptimeInterval = 300; - } - } - } - if(StringUtils.equals(type, "procNumCollect")){ - if(GlobalConfig.procNumCollect != collect || GlobalConfig.procNumInterval != c.getInterval()){ - flag = true; - GlobalConfig.procNumCollect = collect; - GlobalConfig.procNumInterval = c.getInterval(); - if(!collect){ - GlobalConfig.procNumInterval = 300; - } - } - } - if (flag) { + case "systemSwapSizeFreeCollect": //交换卷/文件的可用空间（字节）采集 + if(GlobalConfig.systemSwapSizeFreeCollect != collect || GlobalConfig.systemSwapSizeFreeInterval != interval){ + GlobalConfig.systemSwapSizeFreeCollect = collect; if(collect){ + GlobalConfig.systemSwapSizeFreeInterval = interval; long milli = AgentUtil.getMillisToNextMinute() + 60000; dynamicTaskService.scheduleTask(type, - () -> businessTasks.systemTask(type), milli, c.getInterval()*1000L); + businessTasks::systemSwapSizeFreeTask, milli, GlobalConfig.systemSwapSizeFreeInterval*1000L); }else{ dynamicTaskService.cancelTask(type); + GlobalConfig.systemSwapSizeFreeInterval = 300; } } + break; + case "memoryUtilizationCollect": //内存利用率采集 + if(GlobalConfig.memoryUtilizationCollect != collect || GlobalConfig.memoryUtilizationInterval != interval){ + GlobalConfig.memoryUtilizationCollect = collect; + if(collect){ + GlobalConfig.memoryUtilizationInterval = interval; + long milli = AgentUtil.getMillisToNextMinute() + 60000; + dynamicTaskService.scheduleTask(type, + businessTasks::memoryUtilizationTask, milli, GlobalConfig.memoryUtilizationInterval*1000L); + }else{ + dynamicTaskService.cancelTask(type); + GlobalConfig.memoryUtilizationInterval = 300; + } + } + break; + case "systemSwapSizePercentCollect": //可用交换空间百分比采集 + if(GlobalConfig.systemSwapSizePercentCollect != collect || GlobalConfig.systemSwapSizePercentInterval != interval){ + GlobalConfig.systemSwapSizePercentCollect = collect; + if(collect){ + GlobalConfig.systemSwapSizePercentInterval = interval; + long milli = AgentUtil.getMillisToNextMinute() + 60000; + dynamicTaskService.scheduleTask(type, + businessTasks::systemSwapSizePercentTask, milli, GlobalConfig.systemSwapSizePercentInterval*1000L); + }else{ + dynamicTaskService.cancelTask(type); + GlobalConfig.systemSwapSizePercentInterval = 300; + } + } + break; + case "memorySizeAvailableCollect": //可用内存采集 + if(GlobalConfig.memorySizeAvailableCollect != collect || GlobalConfig.memorySizeAvailableInterval != interval){ + GlobalConfig.memorySizeAvailableCollect = collect; + if(collect){ + GlobalConfig.memorySizeAvailableInterval = interval; + long milli = AgentUtil.getMillisToNextMinute() + 60000; + dynamicTaskService.scheduleTask(type, + businessTasks::memorySizeAvailableTask, milli, GlobalConfig.memorySizeAvailableInterval*1000L); + }else{ + dynamicTaskService.cancelTask(type); + GlobalConfig.memorySizeAvailableInterval = 300; + } + } + break; + case "memorySizePercentCollect": //可用内存百分比采集 + if(GlobalConfig.memorySizePercentCollect != collect || GlobalConfig.memorySizePercentInterval != interval){ + GlobalConfig.memorySizePercentCollect = collect; + if(collect){ + GlobalConfig.memorySizePercentInterval = interval; + long milli = AgentUtil.getMillisToNextMinute() + 60000; + dynamicTaskService.scheduleTask(type, + businessTasks::memorySizePercentTask, milli, GlobalConfig.memorySizePercentInterval*1000L); + }else{ + dynamicTaskService.cancelTask(type); + GlobalConfig.memorySizePercentInterval = 300; + } + } + break; + case "memorySizeTotalCollect": //总内存采集 + if(GlobalConfig.memorySizeTotalCollect != collect || GlobalConfig.memorySizeTotalInterval != interval){ + GlobalConfig.memorySizeTotalCollect = collect; + if(collect){ + GlobalConfig.memorySizeTotalInterval = interval; + long milli = AgentUtil.getMillisToNextMinute() + 60000; + dynamicTaskService.scheduleTask(type, + businessTasks::memorySizeTotalTask, milli, GlobalConfig.memorySizeTotalInterval*1000L); + }else{ + dynamicTaskService.cancelTask(type); + GlobalConfig.memorySizeTotalInterval = 300; + } + } + break; + case "systemSwOsCollect": //操作系统采集 + if(GlobalConfig.systemSwOsCollect != collect || GlobalConfig.systemSwOsInterval != interval){ + GlobalConfig.systemSwOsCollect = collect; + if(collect){ + GlobalConfig.systemSwOsInterval = interval; + long milli = AgentUtil.getMillisToNextMinute() + 60000; + dynamicTaskService.scheduleTask(type, + businessTasks::systemSwOsTask, milli, GlobalConfig.systemSwOsInterval*1000L); + }else{ + dynamicTaskService.cancelTask(type); + GlobalConfig.systemSwOsInterval = 300; + } + } + break; + case "systemSwArchCollect": //操作系统架构采集 + if(GlobalConfig.systemSwArchCollect != collect || GlobalConfig.systemSwArchInterval != interval){ + GlobalConfig.systemSwArchCollect = collect; + if(collect){ + GlobalConfig.systemSwArchInterval = interval; + long milli = AgentUtil.getMillisToNextMinute() + 60000; + dynamicTaskService.scheduleTask(type, + businessTasks::systemSwArchTask, milli, GlobalConfig.systemSwArchInterval*1000L); + }else{ + dynamicTaskService.cancelTask(type); + GlobalConfig.systemSwArchInterval = 300; + } + } + break; + case "kernelMaxprocCollect": //最大进程数采集 + if(GlobalConfig.kernelMaxprocCollect != collect || GlobalConfig.kernelMaxprocInterval != interval){ + GlobalConfig.kernelMaxprocCollect = collect; + if(collect){ + GlobalConfig.kernelMaxprocInterval = interval; + long milli = AgentUtil.getMillisToNextMinute() + 60000; + dynamicTaskService.scheduleTask(type, + businessTasks::kernelMaxprocTask, milli, GlobalConfig.kernelMaxprocInterval*1000L); + }else{ + dynamicTaskService.cancelTask(type); + GlobalConfig.kernelMaxprocInterval = 300; + } + } + break; + case "procNumRunCollect": //正在运行的进程数采集 + if(GlobalConfig.procNumRunCollect != collect || GlobalConfig.procNumRunInterval != interval){ + GlobalConfig.procNumRunCollect = collect; + if(collect){ + GlobalConfig.procNumRunInterval = interval; + long milli = AgentUtil.getMillisToNextMinute() + 60000; + dynamicTaskService.scheduleTask(type, + businessTasks::procNumRunTask, milli, GlobalConfig.procNumRunInterval*1000L); + }else{ + dynamicTaskService.cancelTask(type); + GlobalConfig.procNumRunInterval = 300; + } + } + break; + case "systemUsersNumCollect": //登录用户数采集 + if(GlobalConfig.systemUsersNumCollect != collect || GlobalConfig.systemUsersNumInterval != interval){ + GlobalConfig.systemUsersNumCollect = collect; + if(collect){ + GlobalConfig.systemUsersNumInterval = interval; + long milli = AgentUtil.getMillisToNextMinute() + 60000; + dynamicTaskService.scheduleTask(type, + businessTasks::systemUsersNumTask, milli, GlobalConfig.systemUsersNumInterval*1000L); + }else{ + dynamicTaskService.cancelTask(type); + GlobalConfig.systemUsersNumInterval = 300; + } + } + break; + case "systemDiskSizeTotalCollect": //硬盘总可用空间采集 + if(GlobalConfig.systemDiskSizeTotalCollect != collect || GlobalConfig.systemDiskSizeTotalInterval != interval){ + GlobalConfig.systemDiskSizeTotalCollect = collect; + if(collect){ + GlobalConfig.systemDiskSizeTotalInterval = interval; + long milli = AgentUtil.getMillisToNextMinute() + 60000; + dynamicTaskService.scheduleTask(type, + businessTasks::systemDiskSizeTotalTask, milli, GlobalConfig.systemDiskSizeTotalInterval*1000L); + }else{ + dynamicTaskService.cancelTask(type); + GlobalConfig.systemDiskSizeTotalInterval = 300; + } + } + break; + case "systemBoottimeCollect": //系统启动时间采集 + if(GlobalConfig.systemBoottimeCollect != collect || GlobalConfig.systemBoottimeInterval != interval){ + GlobalConfig.systemBoottimeCollect = collect; + if(collect){ + GlobalConfig.systemBoottimeInterval = interval; + long milli = AgentUtil.getMillisToNextMinute() + 60000; + dynamicTaskService.scheduleTask(type, + businessTasks::systemBoottimeTask, milli, GlobalConfig.systemBoottimeInterval*1000L); + }else{ + dynamicTaskService.cancelTask(type); + GlobalConfig.systemBoottimeInterval = 300; + } + } + break; + case "systemUnameCollect": //系统描述采集 + if(GlobalConfig.systemUnameCollect != collect || GlobalConfig.systemUnameInterval != interval){ + GlobalConfig.systemUnameCollect = collect; + if(collect){ + GlobalConfig.systemUnameInterval = interval; + long milli = AgentUtil.getMillisToNextMinute() + 60000; + dynamicTaskService.scheduleTask(type, + businessTasks::systemUnameTask, milli, GlobalConfig.systemUnameInterval*1000L); + }else{ + dynamicTaskService.cancelTask(type); + GlobalConfig.systemUnameInterval = 300; + } + } + break; + case "systemLocaltimeCollect": //系统本地时间采集 + if(GlobalConfig.systemLocaltimeCollect != collect || GlobalConfig.systemLocaltimeInterval != interval){ + GlobalConfig.systemLocaltimeCollect = collect; + if(collect){ + GlobalConfig.systemLocaltimeInterval = interval; + long milli = AgentUtil.getMillisToNextMinute() + 60000; + dynamicTaskService.scheduleTask(type, + businessTasks::systemLocaltimeTask, milli, GlobalConfig.systemLocaltimeInterval*1000L); + }else{ + dynamicTaskService.cancelTask(type); + GlobalConfig.systemLocaltimeInterval = 300; + } + } + break; + case "systemUptimeCollect": //系统正常运行时间采集 + if(GlobalConfig.systemUptimeCollect != collect || GlobalConfig.systemUptimeInterval != interval){ + GlobalConfig.systemUptimeCollect = collect; + if(collect){ + GlobalConfig.systemUptimeInterval = interval; + long milli = AgentUtil.getMillisToNextMinute() + 60000; + dynamicTaskService.scheduleTask(type, + businessTasks::systemUptimeTask, milli, GlobalConfig.systemUptimeInterval*1000L); + }else{ + dynamicTaskService.cancelTask(type); + GlobalConfig.systemUptimeInterval = 300; + } + } + break; + default: //系统其他采集 + GlobalConfig.procNumCollect = collect; + if(collect){ + GlobalConfig.procNumInterval = interval; + long milli = AgentUtil.getMillisToNextMinute() + 60000; + dynamicTaskService.scheduleTask(type, + businessTasks::procNumTask, milli, GlobalConfig.procNumInterval*1000L); + }else{ + dynamicTaskService.cancelTask(type); + GlobalConfig.procNumInterval = 300; + } } } } @@ -408,207 +462,270 @@ public class AgentServiceImpl implements AgentService { switch(type) { case "switchNetCollect": //交换机网络采集 if(GlobalConfig.switchNetCollect != collect || GlobalConfig.switchNetInterval != interval){ - flag = true; GlobalConfig.switchNetCollect = collect; -// GlobalConfig.switchNetInterval = interval; -// if(!collect){ -// GlobalConfig.switchNetInterval = 300; -// } + if(collect){ + GlobalConfig.switchNetInterval = 300; + long milli = AgentUtil.millisecondsToNext5Minute(); + dynamicTaskService.scheduleTask(type, + businessTasks::switchNetTask, milli, GlobalConfig.switchNetInterval*1000L); + }else{ + dynamicTaskService.cancelTask(type); + GlobalConfig.switchNetInterval = 300; + } } break; case "switchModuleCollect": //光模块采集 if(GlobalConfig.switchModuleCollect != collect || GlobalConfig.switchModuleInterval != interval){ - flag = true; GlobalConfig.switchModuleCollect = collect; - GlobalConfig.switchModuleInterval = interval; - if(!collect){ + if(collect){ + GlobalConfig.switchModuleInterval = interval; + long milli = AgentUtil.getMillisToNextMinute() + 60000; + dynamicTaskService.scheduleTask(type, + businessTasks::switchModuleTask, milli, GlobalConfig.switchModuleInterval*1000L); + }else{ + dynamicTaskService.cancelTask(type); GlobalConfig.switchModuleInterval = 300; } } break; case "switchMpuCollect": //MPU采集 if(GlobalConfig.switchMpuCollect != collect || GlobalConfig.switchMpuInterval != interval){ - flag = true; GlobalConfig.switchMpuCollect = collect; - GlobalConfig.switchMpuInterval = interval; - if(!collect){ + if(collect){ + GlobalConfig.switchMpuInterval = interval; + long milli = AgentUtil.getMillisToNextMinute() + 60000; + dynamicTaskService.scheduleTask(type, + businessTasks::switchMpuTask, milli, GlobalConfig.switchMpuInterval*1000L); + }else{ + dynamicTaskService.cancelTask(type); GlobalConfig.switchMpuInterval = 300; } } break; case "switchPwrCollect": //电源采集 if(GlobalConfig.switchPwrCollect != collect || GlobalConfig.switchPwrInterval != interval){ - flag = true; GlobalConfig.switchPwrCollect = collect; - GlobalConfig.switchPwrInterval = interval; - if(!collect){ + if(collect){ + GlobalConfig.switchPwrInterval = interval; + long milli = AgentUtil.getMillisToNextMinute() + 60000; + dynamicTaskService.scheduleTask(type, + businessTasks::switchPwrTask, milli, GlobalConfig.switchPwrInterval*1000L); + }else{ + dynamicTaskService.cancelTask(type); GlobalConfig.switchPwrInterval = 300; } } break; case "switchFanCollect": //风扇采集 if(GlobalConfig.switchFanCollect != collect || GlobalConfig.switchFanInterval != interval){ - flag = true; GlobalConfig.switchFanCollect = collect; - GlobalConfig.switchFanInterval = interval; - if(!collect){ + if(collect){ + GlobalConfig.switchFanInterval = interval; + long milli = AgentUtil.getMillisToNextMinute() + 60000; + dynamicTaskService.scheduleTask(type, + businessTasks::switchFanTask, milli, GlobalConfig.switchFanInterval*1000L); + }else{ + dynamicTaskService.cancelTask(type); GlobalConfig.switchFanInterval = 300; } } break; case "switchSysDescrCollect": if(GlobalConfig.switchSysDescrCollect != collect || GlobalConfig.switchSysDescrInterval != interval){ - flag = true; GlobalConfig.switchSysDescrCollect = collect; - GlobalConfig.switchSysDescrInterval = interval; - if(!collect){ + if(collect){ + GlobalConfig.switchSysDescrInterval = interval; + long milli = AgentUtil.getMillisToNextMinute() + 60000; + dynamicTaskService.scheduleTask(type, + businessTasks::switchSysDescrTask, milli, GlobalConfig.switchSysDescrInterval*1000L); + }else{ + dynamicTaskService.cancelTask(type); GlobalConfig.switchSysDescrInterval = 300; } } break; case "switchSysObjectIDCollect": if(GlobalConfig.switchSysObjectIDCollect != collect || GlobalConfig.switchSysObjectIDInterval != interval){ - flag = true; GlobalConfig.switchSysObjectIDCollect = collect; - GlobalConfig.switchSysObjectIDInterval = interval; - if(!collect){ + if(collect){ + GlobalConfig.switchSysObjectIDInterval = interval; + long milli = AgentUtil.getMillisToNextMinute() + 60000; + dynamicTaskService.scheduleTask(type, + businessTasks::switchSysObjectIDTask, milli, GlobalConfig.switchSysObjectIDInterval*1000L); + }else{ + dynamicTaskService.cancelTask(type); GlobalConfig.switchSysObjectIDInterval = 300; } } break; case "switchSysUpTimeCollect": if(GlobalConfig.switchSysUpTimeCollect != collect || GlobalConfig.switchSysUpTimeInterval != interval){ - flag = true; GlobalConfig.switchSysUpTimeCollect = collect; - GlobalConfig.switchSysUpTimeInterval = interval; - if(!collect){ + if(collect){ + GlobalConfig.switchSysUpTimeInterval = interval; + long milli = AgentUtil.getMillisToNextMinute() + 60000; + dynamicTaskService.scheduleTask(type, + businessTasks::switchSysUpTimeTask, milli, GlobalConfig.switchSysUpTimeInterval*1000L); + }else{ + dynamicTaskService.cancelTask(type); GlobalConfig.switchSysUpTimeInterval = 300; } } break; case "switchSysContactCollect": if(GlobalConfig.switchSysContactCollect != collect || GlobalConfig.switchSysContactInterval != interval){ - flag = true; GlobalConfig.switchSysContactCollect = collect; - GlobalConfig.switchSysContactInterval = interval; - if(!collect){ + if(collect){ + GlobalConfig.switchSysContactInterval = interval; + long milli = AgentUtil.getMillisToNextMinute() + 60000; + dynamicTaskService.scheduleTask(type, + businessTasks::switchSysContactTask, milli, GlobalConfig.switchSysContactInterval*1000L); + }else{ + dynamicTaskService.cancelTask(type); GlobalConfig.switchSysContactInterval = 300; } } break; case "switchSysNameCollect": if(GlobalConfig.switchSysNameCollect != collect || GlobalConfig.switchSysNameInterval != interval){ - flag = true; GlobalConfig.switchSysNameCollect = collect; - GlobalConfig.switchSysNameInterval = interval; - if(!collect){ + if(collect){ + GlobalConfig.switchSysNameInterval = interval; + long milli = AgentUtil.getMillisToNextMinute() + 60000; + dynamicTaskService.scheduleTask(type, + businessTasks::switchSysNameTask, milli, GlobalConfig.switchSysNameInterval*1000L); + }else{ + dynamicTaskService.cancelTask(type); GlobalConfig.switchSysNameInterval = 300; } } break; case "switchSysLocationCollect": if(GlobalConfig.switchSysLocationCollect != collect || GlobalConfig.switchSysLocationInterval != interval){ - flag = true; GlobalConfig.switchSysLocationCollect = collect; - GlobalConfig.switchSysLocationInterval = interval; - if(!collect){ + if(collect){ + GlobalConfig.switchSysLocationInterval = interval; + long milli = AgentUtil.getMillisToNextMinute() + 60000; + dynamicTaskService.scheduleTask(type, + businessTasks::switchSysLocationTask, milli, GlobalConfig.switchSysLocationInterval*1000L); + }else{ + dynamicTaskService.cancelTask(type); GlobalConfig.switchSysLocationInterval = 300; } } break; case "switchHwStackSystemMacCollect": if(GlobalConfig.switchHwStackSystemMacCollect != collect || GlobalConfig.switchHwStackSystemMacInterval != interval){ - flag = true; GlobalConfig.switchHwStackSystemMacCollect = collect; - GlobalConfig.switchHwStackSystemMacInterval = interval; - if(!collect){ + if(collect){ + GlobalConfig.switchHwStackSystemMacInterval = interval; + long milli = AgentUtil.getMillisToNextMinute() + 60000; + dynamicTaskService.scheduleTask(type, + businessTasks::switchHwStackSystemMacTask, milli, GlobalConfig.switchHwStackSystemMacInterval*1000L); + }else{ + dynamicTaskService.cancelTask(type); GlobalConfig.switchHwStackSystemMacInterval = 300; } } break; case "switchEntIndexCollect": if(GlobalConfig.switchEntIndexCollect != collect || GlobalConfig.switchEntIndexInterval != interval){ - flag = true; GlobalConfig.switchEntIndexCollect = collect; - GlobalConfig.switchEntIndexInterval = interval; - if(!collect){ + if(collect){ + GlobalConfig.switchEntIndexInterval = interval; + long milli = AgentUtil.getMillisToNextMinute() + 60000; + dynamicTaskService.scheduleTask(type, + businessTasks::switchEntIndexTask, milli, GlobalConfig.switchEntIndexInterval*1000L); + }else{ + dynamicTaskService.cancelTask(type); GlobalConfig.switchEntIndexInterval = 300; } } break; case "switchEntPhysicalNameCollect": if(GlobalConfig.switchEntPhysicalNameCollect != collect || GlobalConfig.switchEntPhysicalNameInterval != interval){ - flag = true; GlobalConfig.switchEntPhysicalNameCollect = collect; - GlobalConfig.switchEntPhysicalNameInterval = interval; - if(!collect){ + if(collect){ + GlobalConfig.switchEntPhysicalNameInterval = interval; + long milli = AgentUtil.getMillisToNextMinute() + 60000; + dynamicTaskService.scheduleTask(type, + businessTasks::switchEntPhysicalNameTask, milli, GlobalConfig.switchEntPhysicalNameInterval*1000L); + }else{ + dynamicTaskService.cancelTask(type); GlobalConfig.switchEntPhysicalNameInterval = 300; } } break; case "switchEntPhysicalSoftwareRevCollect": if(GlobalConfig.switchEntPhysicalSoftwareRevCollect != collect || GlobalConfig.switchEntPhysicalSoftwareRevInterval != interval){ - flag = true; GlobalConfig.switchEntPhysicalSoftwareRevCollect = collect; - GlobalConfig.switchEntPhysicalSoftwareRevInterval = interval; - if(!collect){ + if(collect){ + GlobalConfig.switchEntPhysicalSoftwareRevInterval = interval; + long milli = AgentUtil.getMillisToNextMinute() + 60000; + dynamicTaskService.scheduleTask(type, + businessTasks::switchEntPhysicalSoftwareRevTask, milli, GlobalConfig.switchEntPhysicalSoftwareRevInterval*1000L); + }else{ + dynamicTaskService.cancelTask(type); GlobalConfig.switchEntPhysicalSoftwareRevInterval = 300; } } break; case "switchHwEntityCpuUsageCollect": if(GlobalConfig.switchHwEntityCpuUsageCollect != collect || GlobalConfig.switchHwEntityCpuUsageInterval != interval){ - flag = true; GlobalConfig.switchHwEntityCpuUsageCollect = collect; - GlobalConfig.switchHwEntityCpuUsageInterval = interval; - if(!collect){ + if(collect){ + GlobalConfig.switchHwEntityCpuUsageInterval = interval; + long milli = AgentUtil.getMillisToNextMinute() + 60000; + dynamicTaskService.scheduleTask(type, + businessTasks::switchHwEntityCpuUsageTask, milli, GlobalConfig.switchHwEntityCpuUsageInterval*1000L); + }else{ + dynamicTaskService.cancelTask(type); GlobalConfig.switchHwEntityCpuUsageInterval = 300; } } break; case "switchHwEntityMemUsageCollect": if(GlobalConfig.switchHwEntityMemUsageCollect != collect || GlobalConfig.switchHwEntityMemUsageInterval != interval){ - flag = true; GlobalConfig.switchHwEntityMemUsageCollect = collect; - GlobalConfig.switchHwEntityMemUsageInterval = interval; - if(!collect){ + if(collect){ + GlobalConfig.switchHwEntityMemUsageInterval = interval; + long milli = AgentUtil.getMillisToNextMinute() + 60000; + dynamicTaskService.scheduleTask(type, + businessTasks::switchHwEntityMemUsageTask, milli, GlobalConfig.switchHwEntityMemUsageInterval*1000L); + }else{ + dynamicTaskService.cancelTask(type); GlobalConfig.switchHwEntityMemUsageInterval = 300; } } break; case "switchHwAveragePowerCollect": if(GlobalConfig.switchHwAveragePowerCollect != collect || GlobalConfig.switchHwAveragePowerInterval != interval){ - flag = true; GlobalConfig.switchHwAveragePowerCollect = collect; - GlobalConfig.switchHwAveragePowerInterval = interval; - if(!collect){ + if(collect){ + GlobalConfig.switchHwAveragePowerInterval = interval; + long milli = AgentUtil.getMillisToNextMinute() + 60000; + dynamicTaskService.scheduleTask(type, + businessTasks::switchHwAveragePowerTask, milli, GlobalConfig.switchHwAveragePowerInterval*1000L); + }else{ + dynamicTaskService.cancelTask(type); GlobalConfig.switchHwAveragePowerInterval = 300; } } break; default: //系统其他采集 if(GlobalConfig.switchHwCurrentPowerCollect != collect || GlobalConfig.switchHwCurrentPowerInterval != interval){ - flag = true; GlobalConfig.switchHwCurrentPowerCollect = collect; - GlobalConfig.switchHwCurrentPowerInterval = interval; - if(!collect){ + if(collect){ + GlobalConfig.switchHwCurrentPowerInterval = interval; + long milli = AgentUtil.getMillisToNextMinute() + 60000; + dynamicTaskService.scheduleTask(type, + businessTasks::switchHwCurrentPowerTask, milli, GlobalConfig.switchHwCurrentPowerInterval*1000L); + }else{ + dynamicTaskService.cancelTask(type); GlobalConfig.switchHwCurrentPowerInterval = 300; } } } - if (flag) { - if(collect){ - long milli = AgentUtil.getMillisToNextMinute() + 60000; - if(StringUtils.equals(type,"switchNetCollect")){ - milli = AgentUtil.millisecondsToNext5Minute(); - interval = 300; - } - dynamicTaskService.scheduleTask(type, - () -> businessTasks.switchBoardTask(type), milli, interval*1000L); - }else{ - dynamicTaskService.cancelTask(type); - } - } } } }