package com.zy.asrs.service;
|
|
import com.alibaba.fastjson.JSON;
|
import com.alibaba.fastjson.serializer.SerializerFeature;
|
import com.zy.asrs.domain.DevicePingSample;
|
import com.zy.asrs.entity.DeviceConfig;
|
import org.springframework.beans.factory.annotation.Value;
|
import org.springframework.stereotype.Service;
|
|
import java.io.BufferedWriter;
|
import java.nio.charset.StandardCharsets;
|
import java.nio.file.Files;
|
import java.nio.file.Path;
|
import java.nio.file.Paths;
|
import java.nio.file.StandardOpenOption;
|
import java.time.Instant;
|
import java.time.LocalDate;
|
import java.time.LocalDateTime;
|
import java.time.ZoneId;
|
import java.time.format.DateTimeFormatter;
|
import java.util.ArrayList;
|
import java.util.Collections;
|
import java.util.Comparator;
|
import java.util.Date;
|
import java.util.LinkedHashMap;
|
import java.util.List;
|
import java.util.Locale;
|
import java.util.Map;
|
import java.util.stream.Stream;
|
|
@Service
|
public class DevicePingFileStorageService {
|
|
private static final ZoneId ZONE_ID = ZoneId.systemDefault();
|
private static final DateTimeFormatter DAY_FORMAT = DateTimeFormatter.ofPattern("yyyyMMdd");
|
private static final DateTimeFormatter HOUR_FORMAT = DateTimeFormatter.ofPattern("HH");
|
private static final DateTimeFormatter TIME_FORMAT = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
|
|
@Value("${devicePingStorage.loggingPath}")
|
private String loggingPath;
|
|
@Value("${devicePingStorage.expireDays:7}")
|
private Integer expireDays;
|
|
@Value("${devicePingStorage.packetSize:-1}")
|
private Integer packetSize;
|
|
public void appendSamples(List<DevicePingSample> samples) {
|
if (samples == null || samples.isEmpty()) {
|
return;
|
}
|
Map<Path, List<DevicePingSample>> grouped = new LinkedHashMap<>();
|
for (DevicePingSample sample : samples) {
|
if (sample == null || sample.getCreateTime() == null) {
|
continue;
|
}
|
grouped.computeIfAbsent(resolveFilePath(sample), k -> new ArrayList<>()).add(sample);
|
}
|
for (Map.Entry<Path, List<DevicePingSample>> entry : grouped.entrySet()) {
|
Path path = entry.getKey();
|
List<DevicePingSample> fileSamples = entry.getValue();
|
fileSamples.sort(Comparator.comparing(DevicePingSample::getCreateTime, Comparator.nullsLast(Date::compareTo)));
|
try {
|
Files.createDirectories(path.getParent());
|
try (BufferedWriter writer = Files.newBufferedWriter(path, StandardCharsets.UTF_8,
|
StandardOpenOption.CREATE, StandardOpenOption.APPEND)) {
|
for (DevicePingSample sample : fileSamples) {
|
writer.write(JSON.toJSONStringWithDateFormat(sample, "yyyy-MM-dd HH:mm:ss", SerializerFeature.WriteDateUseDateFormat));
|
writer.newLine();
|
}
|
}
|
} catch (Exception ignored) {
|
}
|
}
|
}
|
|
public List<String> listDays() {
|
Path baseDir = Paths.get(loggingPath);
|
if (!Files.exists(baseDir)) {
|
return new ArrayList<>();
|
}
|
try {
|
List<String> days = new ArrayList<>();
|
try (Stream<Path> stream = Files.list(baseDir)) {
|
stream
|
.filter(Files::isDirectory)
|
.forEach(path -> {
|
String day = path.getFileName().toString();
|
if (day.length() == 8 && day.chars().allMatch(Character::isDigit)) {
|
days.add(day);
|
}
|
});
|
}
|
days.sort(Comparator.reverseOrder());
|
return days;
|
} catch (Exception ignored) {
|
return new ArrayList<>();
|
}
|
}
|
|
public Map<String, Object> queryTrend(DeviceConfig deviceConfig, long startTime, long endTime, Integer bucketSec) {
|
if (deviceConfig == null || startTime <= 0 || endTime <= 0 || endTime < startTime) {
|
return Collections.emptyMap();
|
}
|
TrendAccumulator summary = new TrendAccumulator();
|
List<Map<String, Object>> series = new ArrayList<>();
|
List<Map<String, Object>> alerts = new ArrayList<>();
|
|
for (Path file : resolveRangeFiles(deviceConfig.getDeviceType(), deviceConfig.getDeviceNo(), startTime, endTime)) {
|
if (!Files.exists(file)) {
|
continue;
|
}
|
try {
|
try (Stream<String> lines = Files.lines(file, StandardCharsets.UTF_8)) {
|
lines.forEach(line -> {
|
if (line == null || line.trim().isEmpty()) {
|
return;
|
}
|
DevicePingSample sample;
|
try {
|
sample = JSON.parseObject(line, DevicePingSample.class);
|
} catch (Exception ex) {
|
return;
|
}
|
if (sample == null || sample.getCreateTime() == null) {
|
return;
|
}
|
long ts = sample.getCreateTime().getTime();
|
if (ts < startTime || ts > endTime) {
|
return;
|
}
|
summary.add(sample);
|
Map<String, Object> point = new LinkedHashMap<>();
|
point.put("time", ts);
|
point.put("timeLabel", formatDateTime(ts));
|
point.put("reachable", Boolean.TRUE.equals(sample.getReachable()));
|
point.put("status", sample.getStatus());
|
point.put("message", sample.getMessage());
|
point.put("latencyMs", sample.getLatencyMs());
|
point.put("avgLatencyMs", sample.getAvgLatencyMs());
|
point.put("minLatencyMs", sample.getMinLatencyMs());
|
point.put("maxLatencyMs", sample.getMaxLatencyMs());
|
point.put("packetSize", resolvePacketSize(sample.getPacketSize()));
|
point.put("probeCount", sample.getProbeCount());
|
point.put("successProbeCount", sample.getSuccessProbeCount());
|
point.put("successRate", round2(summaryRate(sample.getSuccessProbeCount(), sample.getProbeCount())));
|
point.put("failProbeCount", Math.max(0, safeInt(sample.getProbeCount()) - safeInt(sample.getSuccessProbeCount())));
|
series.add(point);
|
if (!"OK".equalsIgnoreCase(safeText(sample.getStatus(), "")) && alerts.size() < 120) {
|
Map<String, Object> alert = new LinkedHashMap<>();
|
alert.put("time", ts);
|
alert.put("timeLabel", formatDateTime(ts));
|
alert.put("status", sample.getStatus());
|
alert.put("message", safeText(sample.getMessage(), "探测失败"));
|
alert.put("ip", sample.getIp());
|
alerts.add(alert);
|
}
|
});
|
}
|
} catch (Exception ignored) {
|
}
|
}
|
|
series.sort(Comparator.comparingLong(item -> Long.parseLong(String.valueOf(item.get("time")))));
|
|
Map<String, Object> device = new LinkedHashMap<>();
|
device.put("deviceType", deviceConfig.getDeviceType());
|
device.put("deviceNo", deviceConfig.getDeviceNo());
|
device.put("ip", deviceConfig.getIp());
|
device.put("port", deviceConfig.getPort());
|
device.put("label", buildDeviceLabel(deviceConfig));
|
device.put("packetSize", resolvePacketSize(summary.latestPacketSize));
|
|
Map<String, Object> summaryMap = new LinkedHashMap<>();
|
summaryMap.put("totalSamples", summary.totalCount);
|
summaryMap.put("successSamples", summary.successCount);
|
summaryMap.put("failSamples", summary.failCount);
|
summaryMap.put("successRate", round2(summary.successRate()));
|
summaryMap.put("avgLatencyMs", summary.latestAvgLatency);
|
summaryMap.put("minLatencyMs", summary.latestMinLatency);
|
summaryMap.put("maxLatencyMs", summary.latestMaxLatency);
|
summaryMap.put("latestStatus", summary.latestStatus);
|
summaryMap.put("latestTime", summary.latestTime);
|
summaryMap.put("latestTimeLabel", summary.latestTime <= 0 ? "" : formatDateTime(summary.latestTime));
|
summaryMap.put("packetSize", resolvePacketSize(summary.latestPacketSize));
|
summaryMap.put("bucketSec", 1);
|
summaryMap.put("startTime", startTime);
|
summaryMap.put("endTime", endTime);
|
summaryMap.put("startTimeLabel", formatDateTime(startTime));
|
summaryMap.put("endTimeLabel", formatDateTime(endTime));
|
|
Map<String, Object> result = new LinkedHashMap<>();
|
result.put("device", device);
|
result.put("summary", summaryMap);
|
result.put("series", series);
|
result.put("alerts", alerts);
|
return result;
|
}
|
|
public Map<String, Object> queryOverview(List<DeviceConfig> deviceConfigs) {
|
List<Map<String, Object>> devices = new ArrayList<>();
|
if (deviceConfigs == null || deviceConfigs.isEmpty()) {
|
Map<String, Object> result = new LinkedHashMap<>();
|
result.put("summary", buildOverviewSummary(devices));
|
result.put("devices", devices);
|
return result;
|
}
|
|
for (DeviceConfig config : deviceConfigs) {
|
DevicePingSample latestSample = findLatestSample(config);
|
Map<String, Object> item = new LinkedHashMap<>();
|
item.put("deviceType", config.getDeviceType());
|
item.put("deviceNo", config.getDeviceNo());
|
item.put("ip", config.getIp());
|
item.put("port", config.getPort());
|
item.put("label", buildDeviceLabel(config));
|
item.put("packetSize", resolvePacketSize(latestSample == null ? null : latestSample.getPacketSize()));
|
if (latestSample == null) {
|
item.put("status", "NO_DATA");
|
item.put("statusText", "暂无数据");
|
item.put("statusLevel", 3);
|
item.put("reachable", false);
|
item.put("successRate", null);
|
item.put("avgLatencyMs", null);
|
item.put("minLatencyMs", null);
|
item.put("maxLatencyMs", null);
|
item.put("latestTime", null);
|
item.put("latestTimeLabel", "--");
|
item.put("message", "");
|
} else {
|
item.put("status", safeText(latestSample.getStatus(), "UNKNOWN"));
|
item.put("statusText", resolveStatusText(latestSample.getStatus()));
|
item.put("statusLevel", resolveStatusLevel(latestSample.getStatus()));
|
item.put("reachable", Boolean.TRUE.equals(latestSample.getReachable()));
|
item.put("successRate", round2(summaryRate(latestSample.getSuccessProbeCount(), latestSample.getProbeCount())));
|
item.put("avgLatencyMs", latestSample.getAvgLatencyMs());
|
item.put("minLatencyMs", latestSample.getMinLatencyMs());
|
item.put("maxLatencyMs", latestSample.getMaxLatencyMs());
|
item.put("latestTime", latestSample.getCreateTime() == null ? null : latestSample.getCreateTime().getTime());
|
item.put("latestTimeLabel", latestSample.getCreateTime() == null ? "--" : formatDateTime(latestSample.getCreateTime().getTime()));
|
item.put("message", safeText(latestSample.getMessage(), ""));
|
}
|
devices.add(item);
|
}
|
|
devices.sort((a, b) -> {
|
int levelDiff = toInt(a.get("statusLevel")) - toInt(b.get("statusLevel"));
|
if (levelDiff != 0) {
|
return levelDiff;
|
}
|
int typeDiff = safeText(String.valueOf(a.get("deviceType")), "").compareTo(safeText(String.valueOf(b.get("deviceType")), ""));
|
if (typeDiff != 0) {
|
return typeDiff;
|
}
|
return Integer.compare(toInt(a.get("deviceNo")), toInt(b.get("deviceNo")));
|
});
|
|
Map<String, Object> result = new LinkedHashMap<>();
|
result.put("summary", buildOverviewSummary(devices));
|
result.put("devices", devices);
|
return result;
|
}
|
|
public void cleanupExpired() {
|
Path baseDir = Paths.get(loggingPath);
|
if (!Files.exists(baseDir) || expireDays == null || expireDays <= 0) {
|
return;
|
}
|
long cutoff = System.currentTimeMillis() - expireDays * 24L * 60L * 60L * 1000L;
|
try {
|
try (Stream<Path> stream = Files.list(baseDir)) {
|
stream
|
.filter(Files::isDirectory)
|
.forEach(path -> {
|
String day = path.getFileName().toString();
|
if (day.length() != 8 || !day.chars().allMatch(Character::isDigit)) {
|
return;
|
}
|
try {
|
LocalDate date = LocalDate.parse(day, DAY_FORMAT);
|
long startOfDay = date.atStartOfDay(ZONE_ID).toInstant().toEpochMilli();
|
if (startOfDay >= cutoff) {
|
return;
|
}
|
try (Stream<Path> walk = Files.walk(path)) {
|
walk.sorted(Comparator.reverseOrder())
|
.forEach(p -> {
|
try {
|
Files.deleteIfExists(p);
|
} catch (Exception ignored) {
|
}
|
});
|
}
|
} catch (Exception ignored) {
|
}
|
});
|
}
|
} catch (Exception ignored) {
|
}
|
}
|
|
private Path resolveFilePath(DevicePingSample sample) {
|
LocalDateTime dateTime = LocalDateTime.ofInstant(sample.getCreateTime().toInstant(), ZONE_ID);
|
String day = DAY_FORMAT.format(dateTime);
|
String hour = HOUR_FORMAT.format(dateTime);
|
String fileName = sample.getDeviceType() + "_" + sample.getDeviceNo() + "_" + day + "_" + hour + ".log";
|
return Paths.get(loggingPath, day, fileName);
|
}
|
|
private List<Path> resolveRangeFiles(String deviceType, Integer deviceNo, long startTime, long endTime) {
|
List<Path> paths = new ArrayList<>();
|
LocalDateTime current = LocalDateTime.ofInstant(Instant.ofEpochMilli(startTime), ZONE_ID)
|
.withMinute(0).withSecond(0).withNano(0);
|
LocalDateTime end = LocalDateTime.ofInstant(Instant.ofEpochMilli(endTime), ZONE_ID)
|
.withMinute(0).withSecond(0).withNano(0);
|
while (!current.isAfter(end)) {
|
String day = DAY_FORMAT.format(current);
|
String hour = HOUR_FORMAT.format(current);
|
String fileName = deviceType + "_" + deviceNo + "_" + day + "_" + hour + ".log";
|
paths.add(Paths.get(loggingPath, day, fileName));
|
current = current.plusHours(1);
|
}
|
return paths;
|
}
|
|
private String formatDateTime(long timestamp) {
|
return TIME_FORMAT.format(LocalDateTime.ofInstant(Instant.ofEpochMilli(timestamp), ZONE_ID));
|
}
|
|
private String buildDeviceLabel(DeviceConfig config) {
|
return String.format(Locale.ROOT, "%s-%s (%s)", safeText(config.getDeviceType(), "-"),
|
config.getDeviceNo() == null ? "-" : String.valueOf(config.getDeviceNo()),
|
safeText(config.getIp(), "-"));
|
}
|
|
private DevicePingSample findLatestSample(DeviceConfig config) {
|
if (config == null || config.getDeviceNo() == null || safeText(config.getDeviceType(), "").isEmpty()) {
|
return null;
|
}
|
List<String> days = listDays();
|
for (String day : days) {
|
Path dayDir = Paths.get(loggingPath, day);
|
if (!Files.exists(dayDir)) {
|
continue;
|
}
|
String prefix = config.getDeviceType() + "_" + config.getDeviceNo() + "_" + day + "_";
|
List<Path> candidates = new ArrayList<>();
|
try (Stream<Path> stream = Files.list(dayDir)) {
|
stream.filter(path -> !Files.isDirectory(path))
|
.filter(path -> {
|
String name = path.getFileName().toString();
|
return name.startsWith(prefix) && name.endsWith(".log");
|
})
|
.forEach(candidates::add);
|
} catch (Exception ignored) {
|
}
|
candidates.sort((a, b) -> b.getFileName().toString().compareTo(a.getFileName().toString()));
|
for (Path candidate : candidates) {
|
DevicePingSample sample = readLastSample(candidate);
|
if (sample != null) {
|
return sample;
|
}
|
}
|
}
|
return null;
|
}
|
|
private DevicePingSample readLastSample(Path file) {
|
try {
|
List<String> lines = Files.readAllLines(file, StandardCharsets.UTF_8);
|
for (int i = lines.size() - 1; i >= 0; i--) {
|
String line = lines.get(i);
|
if (line == null || line.trim().isEmpty()) {
|
continue;
|
}
|
try {
|
DevicePingSample sample = JSON.parseObject(line, DevicePingSample.class);
|
if (sample != null && sample.getCreateTime() != null) {
|
return sample;
|
}
|
} catch (Exception ignored) {
|
}
|
}
|
} catch (Exception ignored) {
|
}
|
return null;
|
}
|
|
private Map<String, Object> buildOverviewSummary(List<Map<String, Object>> devices) {
|
Map<String, Object> summary = new LinkedHashMap<>();
|
long total = devices == null ? 0L : devices.size();
|
long okCount = 0L;
|
long unstableCount = 0L;
|
long offlineCount = 0L;
|
long noDataCount = 0L;
|
long latencyCount = 0L;
|
long latencySum = 0L;
|
Long maxLatency = null;
|
if (devices != null) {
|
for (Map<String, Object> item : devices) {
|
String status = String.valueOf(item.get("status"));
|
if ("OK".equals(status)) {
|
okCount++;
|
} else if ("UNSTABLE".equals(status)) {
|
unstableCount++;
|
} else if ("NO_DATA".equals(status)) {
|
noDataCount++;
|
} else {
|
offlineCount++;
|
}
|
Object avgLatency = item.get("avgLatencyMs");
|
if (avgLatency instanceof Number) {
|
latencySum += ((Number) avgLatency).longValue();
|
latencyCount++;
|
}
|
Object peakLatency = item.get("maxLatencyMs");
|
if (peakLatency instanceof Number) {
|
long candidate = ((Number) peakLatency).longValue();
|
if (maxLatency == null || candidate > maxLatency) {
|
maxLatency = candidate;
|
}
|
}
|
}
|
}
|
summary.put("totalDevices", total);
|
summary.put("okDevices", okCount);
|
summary.put("unstableDevices", unstableCount);
|
summary.put("offlineDevices", offlineCount);
|
summary.put("noDataDevices", noDataCount);
|
summary.put("avgLatencyMs", latencyCount <= 0 ? null : Math.round(latencySum * 100D / latencyCount) / 100D);
|
summary.put("maxLatencyMs", maxLatency);
|
return summary;
|
}
|
|
private String safeText(String value, String defaultValue) {
|
if (value == null || value.trim().isEmpty()) {
|
return defaultValue;
|
}
|
return value.trim();
|
}
|
|
private Double round2(double value) {
|
return Math.round(value * 100D) / 100D;
|
}
|
|
private Integer resolvePacketSize(Integer samplePacketSize) {
|
if (samplePacketSize != null) {
|
return Math.max(-1, samplePacketSize);
|
}
|
return packetSize == null ? -1 : Math.max(-1, packetSize);
|
}
|
|
private double summaryRate(Integer successCount, Integer probeCount) {
|
int total = safeInt(probeCount);
|
if (total <= 0) {
|
return 0D;
|
}
|
return safeInt(successCount) * 100D / total;
|
}
|
|
private int safeInt(Integer value) {
|
return value == null ? 0 : value;
|
}
|
|
private int toInt(Object value) {
|
if (value == null) {
|
return 0;
|
}
|
if (value instanceof Number) {
|
return ((Number) value).intValue();
|
}
|
try {
|
return Integer.parseInt(String.valueOf(value));
|
} catch (Exception ignored) {
|
return 0;
|
}
|
}
|
|
private String resolveStatusText(String status) {
|
if ("OK".equalsIgnoreCase(status)) {
|
return "正常";
|
}
|
if ("UNSTABLE".equalsIgnoreCase(status)) {
|
return "波动";
|
}
|
if ("TIMEOUT".equalsIgnoreCase(status)) {
|
return "超时";
|
}
|
if ("ERROR".equalsIgnoreCase(status)) {
|
return "异常";
|
}
|
if ("NO_DATA".equalsIgnoreCase(status)) {
|
return "暂无数据";
|
}
|
return safeText(status, "未知");
|
}
|
|
private int resolveStatusLevel(String status) {
|
if ("TIMEOUT".equalsIgnoreCase(status) || "ERROR".equalsIgnoreCase(status)) {
|
return 0;
|
}
|
if ("UNSTABLE".equalsIgnoreCase(status)) {
|
return 1;
|
}
|
if ("OK".equalsIgnoreCase(status)) {
|
return 2;
|
}
|
return 3;
|
}
|
|
private static class TrendAccumulator {
|
|
private long totalCount;
|
private long successCount;
|
private long failCount;
|
private Long latestAvgLatency;
|
private Long latestMinLatency;
|
private Long latestMaxLatency;
|
private Integer latestPacketSize;
|
private String latestStatus;
|
private long latestTime;
|
|
private void add(DevicePingSample sample) {
|
totalCount++;
|
if (Boolean.TRUE.equals(sample.getReachable())) {
|
successCount++;
|
} else {
|
failCount++;
|
}
|
if (sample.getCreateTime() != null) {
|
long currentTime = sample.getCreateTime().getTime();
|
if (currentTime >= latestTime) {
|
latestTime = currentTime;
|
latestAvgLatency = sample.getAvgLatencyMs();
|
latestMinLatency = sample.getMinLatencyMs();
|
latestMaxLatency = sample.getMaxLatencyMs();
|
latestPacketSize = sample.getPacketSize();
|
latestStatus = sample.getStatus();
|
}
|
}
|
}
|
|
private Double successRate() {
|
if (totalCount <= 0) {
|
return 0D;
|
}
|
return (successCount * 100D) / totalCount;
|
}
|
}
|
}
|
