package com.zy.core.trace;
|
|
import com.alibaba.fastjson.JSON;
|
import com.zy.asrs.domain.vo.StationTaskTraceEventVo;
|
import com.zy.asrs.domain.vo.StationTaskTraceSegmentVo;
|
import com.zy.asrs.domain.vo.StationTaskTraceVo;
|
import com.zy.asrs.entity.WrkMast;
|
import com.zy.asrs.service.WrkMastService;
|
import com.zy.common.utils.RedisUtil;
|
import com.zy.core.enums.WrkStsType;
|
import com.zy.core.model.command.StationCommand;
|
import com.zy.core.enums.RedisKeyType;
|
import lombok.Data;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Component;
|
|
import java.util.ArrayList;
|
import java.util.Comparator;
|
import java.util.LinkedHashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Objects;
|
import java.util.concurrent.ConcurrentHashMap;
|
|
@Component
|
public class StationTaskTraceRegistry {
|
|
private static final int MAX_EVENT_COUNT = 200;
|
private static final long TERMINAL_KEEP_MS = 30L * 60L * 1000L;
|
private static final String TRACE_CACHE_KEY = RedisKeyType.STATION_TASK_TRACE_REGISTRY.key;
|
|
public static final String STATUS_WAITING = "WAITING";
|
public static final String STATUS_RUNNING = "RUNNING";
|
public static final String STATUS_BLOCKED = "BLOCKED";
|
public static final String STATUS_CANCELLED = "CANCELLED";
|
public static final String STATUS_TIMEOUT = "TIMEOUT";
|
public static final String STATUS_FINISHED = "FINISHED";
|
public static final String STATUS_REROUTED = "REROUTED";
|
|
@Autowired
|
private RedisUtil redisUtil;
|
|
@Autowired
|
private WrkMastService wrkMastService;
|
|
private final Map<Integer, TraceTaskState> taskStateMap = new ConcurrentHashMap<>();
|
private volatile boolean loadedFromRedis = false;
|
|
public TraceRegistration registerPlan(Integer taskNo,
|
String threadImpl,
|
Integer startStationId,
|
Integer currentStationId,
|
Integer finalTargetStationId,
|
List<Integer> localPathStationIds,
|
List<StationTaskTraceSegmentVo> localSegmentList) {
|
if (taskNo == null || taskNo <= 0) {
|
return new TraceRegistration();
|
}
|
|
ensureCacheLoaded();
|
cleanupExpired();
|
TraceTaskState taskState = taskStateMap.computeIfAbsent(taskNo, TraceTaskState::new);
|
TraceRegistration registration = taskState.registerPlan(threadImpl, startStationId, currentStationId, finalTargetStationId,
|
copyIntegerList(localPathStationIds), copySegmentList(localSegmentList));
|
persistState(taskState);
|
return registration;
|
}
|
|
public void markSegmentIssued(Integer taskNo,
|
Integer traceVersion,
|
StationCommand command,
|
String eventType,
|
String message,
|
Map<String, Object> details) {
|
ensureCacheLoaded();
|
TraceTaskState state = taskStateMap.get(taskNo);
|
if (state == null) {
|
return;
|
}
|
state.markSegmentIssued(traceVersion, command, eventType, message, details);
|
persistState(state);
|
}
|
|
public void updateProgress(Integer taskNo,
|
Integer traceVersion,
|
Integer currentStationId,
|
String eventType,
|
String message,
|
Map<String, Object> details) {
|
ensureCacheLoaded();
|
TraceTaskState state = taskStateMap.get(taskNo);
|
if (state == null) {
|
return;
|
}
|
state.updateProgress(traceVersion, currentStationId, eventType, message, details);
|
persistState(state);
|
}
|
|
public void markBlocked(Integer taskNo,
|
Integer traceVersion,
|
Integer currentStationId,
|
Map<String, Object> details) {
|
ensureCacheLoaded();
|
TraceTaskState state = taskStateMap.get(taskNo);
|
if (state == null) {
|
return;
|
}
|
state.markTerminal(traceVersion, STATUS_BLOCKED, currentStationId, currentStationId,
|
"BLOCKED", "输送任务运行堵塞", details);
|
persistState(state);
|
}
|
|
public void markCancelled(Integer taskNo,
|
Integer traceVersion,
|
Integer currentStationId,
|
Map<String, Object> details) {
|
ensureCacheLoaded();
|
TraceTaskState state = taskStateMap.get(taskNo);
|
if (state == null) {
|
return;
|
}
|
state.markTerminal(traceVersion, STATUS_CANCELLED, currentStationId, null,
|
"CANCELLED", "输送任务收到取消信号", details);
|
persistState(state);
|
}
|
|
public void markTimeout(Integer taskNo,
|
Integer traceVersion,
|
Integer currentStationId,
|
Map<String, Object> details) {
|
ensureCacheLoaded();
|
TraceTaskState state = taskStateMap.get(taskNo);
|
if (state == null) {
|
return;
|
}
|
state.markTerminal(traceVersion, STATUS_TIMEOUT, currentStationId, null,
|
"TIMEOUT", "输送任务长时间无法定位当前位置", details);
|
persistState(state);
|
}
|
|
public void markFinished(Integer taskNo,
|
Integer traceVersion,
|
Integer currentStationId,
|
Map<String, Object> details) {
|
ensureCacheLoaded();
|
TraceTaskState state = taskStateMap.get(taskNo);
|
if (state == null) {
|
return;
|
}
|
state.markTerminal(traceVersion, STATUS_FINISHED, currentStationId, null,
|
"FINISHED", "输送任务轨迹完成", details);
|
persistState(state);
|
}
|
|
public void updateLoopHint(Integer taskNo,
|
Boolean loopAlertActive,
|
String loopAlertType,
|
String loopAlertText,
|
Integer loopAlertCount,
|
Map<String, Object> details) {
|
ensureCacheLoaded();
|
TraceTaskState state = taskStateMap.get(taskNo);
|
if (state == null) {
|
return;
|
}
|
state.updateLoopHint(loopAlertActive, loopAlertType, loopAlertText, loopAlertCount, details);
|
persistState(state);
|
}
|
|
public List<StationTaskTraceVo> listLatestTraces() {
|
ensureCacheLoaded();
|
cleanupExpired();
|
reconcileInactiveBusinessTasks();
|
List<StationTaskTraceVo> result = new ArrayList<>();
|
for (TraceTaskState state : taskStateMap.values()) {
|
if (state != null) {
|
result.add(state.toVo());
|
}
|
}
|
result.sort(new Comparator<StationTaskTraceVo>() {
|
@Override
|
public int compare(StationTaskTraceVo a, StationTaskTraceVo b) {
|
long av = a.getUpdatedAt() == null ? 0L : a.getUpdatedAt();
|
long bv = b.getUpdatedAt() == null ? 0L : b.getUpdatedAt();
|
return Long.compare(bv, av);
|
}
|
});
|
return result;
|
}
|
|
public List<StationTaskTraceVo> listActiveTraces() {
|
List<StationTaskTraceVo> latestTraces = listLatestTraces();
|
List<StationTaskTraceVo> result = new ArrayList<>();
|
for (StationTaskTraceVo traceVo : latestTraces) {
|
if (traceVo == null) {
|
continue;
|
}
|
String status = traceVo.getStatus();
|
if (STATUS_WAITING.equals(status)
|
|| STATUS_RUNNING.equals(status)
|
|| STATUS_REROUTED.equals(status)) {
|
result.add(traceVo);
|
}
|
}
|
return result;
|
}
|
|
private void cleanupExpired() {
|
long now = System.currentTimeMillis();
|
for (Map.Entry<Integer, TraceTaskState> entry : taskStateMap.entrySet()) {
|
TraceTaskState state = entry.getValue();
|
if (state != null && state.shouldRemove(now)) {
|
taskStateMap.remove(entry.getKey(), state);
|
removePersistedState(entry.getKey());
|
}
|
}
|
}
|
|
private void reconcileInactiveBusinessTasks() {
|
if (wrkMastService == null) {
|
return;
|
}
|
for (TraceTaskState state : taskStateMap.values()) {
|
if (state == null || state.isTerminal()) {
|
continue;
|
}
|
WrkMast wrkMast;
|
try {
|
wrkMast = wrkMastService.selectByWorkNo(state.taskNo);
|
} catch (Exception ignore) {
|
continue;
|
}
|
if (wrkMast == null) {
|
Integer currentStationId = state.currentStationId != null ? state.currentStationId : state.finalTargetStationId;
|
Map<String, Object> details = new LinkedHashMap<>();
|
details.put("reason", "wrk_missing");
|
state.markTerminal(state.traceVersion, STATUS_FINISHED, currentStationId, null,
|
"AUTO_FINISHED", "输送任务档已不存在，轨迹自动结束", details);
|
persistState(state);
|
continue;
|
}
|
if (isStationTraceActiveWrkStatus(wrkMast.getWrkSts())) {
|
continue;
|
}
|
Integer currentStationId = state.currentStationId != null ? state.currentStationId : state.finalTargetStationId;
|
Map<String, Object> details = new LinkedHashMap<>();
|
details.put("reason", "wrk_status_transition");
|
details.put("wrkSts", wrkMast.getWrkSts());
|
details.put("wrkStsDesc", wrkMast.getWrkSts$());
|
if (isManualWrkStatus(wrkMast.getWrkSts())) {
|
state.markTerminal(state.traceVersion, STATUS_CANCELLED, currentStationId, null,
|
"AUTO_CANCELLED", "输送任务已退出运行，轨迹自动结束", details);
|
} else {
|
state.markTerminal(state.traceVersion, STATUS_FINISHED, currentStationId, null,
|
"AUTO_FINISHED", "输送任务已结束，轨迹自动结束", details);
|
}
|
persistState(state);
|
}
|
}
|
|
private boolean isStationTraceActiveWrkStatus(Long wrkSts) {
|
return Objects.equals(wrkSts, WrkStsType.INBOUND_DEVICE_RUN.sts)
|
|| Objects.equals(wrkSts, WrkStsType.STATION_RUN.sts);
|
}
|
|
private boolean isManualWrkStatus(Long wrkSts) {
|
return Objects.equals(wrkSts, WrkStsType.INBOUND_MANUAL.sts)
|
|| Objects.equals(wrkSts, WrkStsType.OUTBOUND_MANUAL.sts)
|
|| Objects.equals(wrkSts, WrkStsType.LOC_MOVE_MANUAL.sts);
|
}
|
|
private void ensureCacheLoaded() {
|
if (loadedFromRedis) {
|
return;
|
}
|
synchronized (this) {
|
if (loadedFromRedis) {
|
return;
|
}
|
Map<Object, Object> cacheMap = redisUtil == null ? null : redisUtil.hmget(TRACE_CACHE_KEY);
|
if (cacheMap != null && !cacheMap.isEmpty()) {
|
long now = System.currentTimeMillis();
|
for (Map.Entry<Object, Object> entry : cacheMap.entrySet()) {
|
Integer taskNo = parseTaskNo(entry.getKey());
|
TraceSnapshot snapshot = parseSnapshot(entry.getValue(), taskNo);
|
if (snapshot == null || snapshot.getTaskNo() == null) {
|
if (taskNo != null) {
|
removePersistedState(taskNo);
|
}
|
continue;
|
}
|
if (snapshot.isExpired(now)) {
|
removePersistedState(snapshot.getTaskNo());
|
continue;
|
}
|
taskStateMap.put(snapshot.getTaskNo(), TraceTaskState.fromSnapshot(snapshot));
|
}
|
}
|
loadedFromRedis = true;
|
}
|
}
|
|
private void persistState(TraceTaskState state) {
|
if (state == null || state.taskNo == null || redisUtil == null) {
|
return;
|
}
|
redisUtil.hset(TRACE_CACHE_KEY, String.valueOf(state.taskNo), JSON.toJSONString(state.toSnapshot()));
|
}
|
|
private void removePersistedState(Integer taskNo) {
|
if (taskNo == null || redisUtil == null) {
|
return;
|
}
|
redisUtil.hdel(TRACE_CACHE_KEY, String.valueOf(taskNo));
|
}
|
|
private Integer parseTaskNo(Object value) {
|
if (value == null) {
|
return null;
|
}
|
try {
|
return Integer.parseInt(String.valueOf(value));
|
} catch (Exception e) {
|
return null;
|
}
|
}
|
|
private TraceSnapshot parseSnapshot(Object cacheValue, Integer fallbackTaskNo) {
|
if (cacheValue == null) {
|
return null;
|
}
|
try {
|
TraceSnapshot snapshot = JSON.parseObject(String.valueOf(cacheValue), TraceSnapshot.class);
|
if (snapshot != null && snapshot.getTaskNo() == null) {
|
snapshot.setTaskNo(fallbackTaskNo);
|
}
|
return snapshot;
|
} catch (Exception e) {
|
return null;
|
}
|
}
|
|
private static List<Integer> copyIntegerList(List<Integer> source) {
|
List<Integer> result = new ArrayList<>();
|
if (source == null) {
|
return result;
|
}
|
for (Integer item : source) {
|
if (item != null) {
|
result.add(item);
|
}
|
}
|
return result;
|
}
|
|
private static List<StationTaskTraceSegmentVo> copySegmentList(List<StationTaskTraceSegmentVo> source) {
|
List<StationTaskTraceSegmentVo> result = new ArrayList<>();
|
if (source == null) {
|
return result;
|
}
|
for (StationTaskTraceSegmentVo item : source) {
|
if (item == null) {
|
continue;
|
}
|
StationTaskTraceSegmentVo copy = new StationTaskTraceSegmentVo();
|
copy.setSegmentNo(item.getSegmentNo());
|
copy.setSegmentCount(item.getSegmentCount());
|
copy.setStationId(item.getStationId());
|
copy.setTargetStationId(item.getTargetStationId());
|
copy.setSegmentStartIndex(item.getSegmentStartIndex());
|
copy.setSegmentEndIndex(item.getSegmentEndIndex());
|
copy.setSegmentPath(copyIntegerList(item.getSegmentPath()));
|
copy.setIssued(Boolean.TRUE.equals(item.getIssued()));
|
result.add(copy);
|
}
|
return result;
|
}
|
|
private static Map<String, Object> copyDetails(Map<String, Object> source) {
|
Map<String, Object> result = new LinkedHashMap<>();
|
if (source == null || source.isEmpty()) {
|
return result;
|
}
|
for (Map.Entry<String, Object> entry : source.entrySet()) {
|
Object value = entry.getValue();
|
if (value instanceof List) {
|
result.put(entry.getKey(), new ArrayList<>((List<?>) value));
|
} else if (value instanceof Map) {
|
result.put(entry.getKey(), new LinkedHashMap<>((Map<?, ?>) value));
|
} else {
|
result.put(entry.getKey(), value);
|
}
|
}
|
return result;
|
}
|
|
private static List<StationTaskTraceEventVo> copyEventList(List<StationTaskTraceEventVo> source) {
|
List<StationTaskTraceEventVo> result = new ArrayList<>();
|
if (source == null) {
|
return result;
|
}
|
for (StationTaskTraceEventVo item : source) {
|
if (item == null) {
|
continue;
|
}
|
StationTaskTraceEventVo copy = new StationTaskTraceEventVo();
|
copy.setTimestamp(item.getTimestamp());
|
copy.setEventType(item.getEventType());
|
copy.setMessage(item.getMessage());
|
copy.setStatus(item.getStatus());
|
copy.setCurrentStationId(item.getCurrentStationId());
|
copy.setTargetStationId(item.getTargetStationId());
|
copy.setTraceVersion(item.getTraceVersion());
|
copy.setDetails(copyDetails(item.getDetails()));
|
result.add(copy);
|
}
|
return result;
|
}
|
|
private static boolean isTerminalStatus(String status) {
|
return STATUS_BLOCKED.equals(status)
|
|| STATUS_CANCELLED.equals(status)
|
|| STATUS_TIMEOUT.equals(status)
|
|| STATUS_FINISHED.equals(status);
|
}
|
|
@Data
|
public static class TraceRegistration {
|
private Integer traceVersion;
|
private Integer pathOffset;
|
private List<Integer> fullPathStationIds = new ArrayList<>();
|
private boolean rerouted;
|
}
|
|
@Data
|
private static class TraceSnapshot {
|
private Integer taskNo;
|
private String threadImpl;
|
private String status;
|
private Integer traceVersion;
|
private Integer startStationId;
|
private Integer currentStationId;
|
private Integer finalTargetStationId;
|
private Integer blockedStationId;
|
private List<Integer> fullPathStationIds = new ArrayList<>();
|
private List<Integer> issuedStationIds = new ArrayList<>();
|
private List<Integer> passedStationIds = new ArrayList<>();
|
private List<Integer> pendingStationIds = new ArrayList<>();
|
private List<Integer> latestIssuedSegmentPath = new ArrayList<>();
|
private List<StationTaskTraceSegmentVo> segmentList = new ArrayList<>();
|
private Integer issuedSegmentCount;
|
private Integer totalSegmentCount;
|
private Boolean loopAlertActive;
|
private String loopAlertType;
|
private String loopAlertText;
|
private Integer loopAlertCount;
|
private Long updatedAt;
|
private Long terminalExpireAt;
|
private List<StationTaskTraceEventVo> events = new ArrayList<>();
|
|
private boolean isExpired(long now) {
|
return terminalExpireAt != null && terminalExpireAt <= now;
|
}
|
}
|
|
private static class TraceTaskState {
|
|
private final Integer taskNo;
|
private String threadImpl;
|
private String status = STATUS_WAITING;
|
private Integer traceVersion = 0;
|
private Integer startStationId;
|
private Integer currentStationId;
|
private Integer finalTargetStationId;
|
private Integer blockedStationId;
|
private List<Integer> fullPathStationIds = new ArrayList<>();
|
private List<Integer> issuedStationIds = new ArrayList<>();
|
private List<Integer> passedStationIds = new ArrayList<>();
|
private List<Integer> pendingStationIds = new ArrayList<>();
|
private List<Integer> latestIssuedSegmentPath = new ArrayList<>();
|
private List<StationTaskTraceSegmentVo> segmentList = new ArrayList<>();
|
private Integer issuedSegmentCount = 0;
|
private Integer totalSegmentCount = 0;
|
private Boolean loopAlertActive = Boolean.FALSE;
|
private String loopAlertType;
|
private String loopAlertText;
|
private Integer loopAlertCount;
|
private final List<StationTaskTraceEventVo> events = new ArrayList<>();
|
private Long updatedAt = System.currentTimeMillis();
|
private Long terminalExpireAt;
|
|
private TraceTaskState(Integer taskNo) {
|
this.taskNo = taskNo;
|
}
|
|
private synchronized TraceRegistration registerPlan(String threadImpl,
|
Integer startStationId,
|
Integer currentStationId,
|
Integer finalTargetStationId,
|
List<Integer> localPathStationIds,
|
List<StationTaskTraceSegmentVo> localSegmentList) {
|
TraceRegistration registration = new TraceRegistration();
|
boolean firstPlan = this.traceVersion == null || this.traceVersion <= 0;
|
boolean rerouted = !isTerminalStatus(this.status) && this.traceVersion != null && this.traceVersion > 0;
|
int nextTraceVersion = rerouted ? this.traceVersion + 1 : 1;
|
int pathOffset = rerouted ? this.passedStationIds.size() : 0;
|
Integer planCurrentStationId = currentStationId != null ? currentStationId : startStationId;
|
List<Integer> nextFullPath = buildFullPathForRegistration(rerouted, planCurrentStationId, localPathStationIds);
|
List<StationTaskTraceSegmentVo> nextSegmentList = shiftSegments(copySegmentList(localSegmentList), pathOffset);
|
|
this.threadImpl = threadImpl;
|
this.traceVersion = nextTraceVersion;
|
this.startStationId = rerouted && this.startStationId != null ? this.startStationId : startStationId;
|
this.currentStationId = planCurrentStationId;
|
this.finalTargetStationId = finalTargetStationId;
|
this.blockedStationId = null;
|
this.fullPathStationIds = nextFullPath;
|
this.segmentList = nextSegmentList;
|
this.issuedSegmentCount = 0;
|
this.totalSegmentCount = nextSegmentList.size();
|
this.issuedStationIds = new ArrayList<>();
|
this.latestIssuedSegmentPath = new ArrayList<>();
|
this.status = rerouted ? STATUS_REROUTED : STATUS_WAITING;
|
this.terminalExpireAt = null;
|
if (firstPlan) {
|
clearLoopHintState();
|
}
|
rebuildProgress(planCurrentStationId);
|
this.updatedAt = System.currentTimeMillis();
|
|
Map<String, Object> details = new LinkedHashMap<>();
|
details.put("traceVersion", nextTraceVersion);
|
details.put("fullPathStationIds", copyIntegerList(this.fullPathStationIds));
|
details.put("segmentCount", this.totalSegmentCount);
|
details.put("pathOffset", pathOffset);
|
details.put("currentStationId", this.currentStationId);
|
appendLoopHintDetails(details);
|
appendEvent(rerouted ? "REROUTED" : "PLAN_READY",
|
rerouted ? "输送任务路径已重算并续接轨迹" : "输送任务分段计划已建立",
|
details);
|
|
registration.setTraceVersion(nextTraceVersion);
|
registration.setPathOffset(pathOffset);
|
registration.setFullPathStationIds(copyIntegerList(this.fullPathStationIds));
|
registration.setRerouted(rerouted);
|
return registration;
|
}
|
|
private synchronized void markSegmentIssued(Integer traceVersion,
|
StationCommand command,
|
String eventType,
|
String message,
|
Map<String, Object> details) {
|
if (!acceptTraceVersion(traceVersion)) {
|
return;
|
}
|
this.status = STATUS_RUNNING;
|
this.blockedStationId = null;
|
int currentIssued = this.issuedSegmentCount == null ? 0 : this.issuedSegmentCount;
|
int nextIssued = command == null || command.getSegmentNo() == null ? currentIssued : command.getSegmentNo();
|
this.issuedSegmentCount = Math.max(currentIssued, nextIssued);
|
this.latestIssuedSegmentPath = copyIntegerList(command == null ? null : command.getNavigatePath());
|
int segmentEndIndex = command == null || command.getSegmentEndIndex() == null ? -1 : command.getSegmentEndIndex();
|
if (segmentEndIndex >= 0 && !this.fullPathStationIds.isEmpty()) {
|
int end = Math.min(segmentEndIndex + 1, this.fullPathStationIds.size());
|
this.issuedStationIds = copyIntegerList(this.fullPathStationIds.subList(0, end));
|
}
|
this.updatedAt = System.currentTimeMillis();
|
|
Map<String, Object> nextDetails = copyDetails(details);
|
if (command != null) {
|
nextDetails.put("segmentNo", command.getSegmentNo());
|
nextDetails.put("segmentCount", command.getSegmentCount());
|
nextDetails.put("commandStationId", command.getStationId());
|
nextDetails.put("commandTargetStationId", command.getTargetStaNo());
|
nextDetails.put("segmentPath", copyIntegerList(command.getNavigatePath()));
|
nextDetails.put("issuedSegmentCount", this.issuedSegmentCount);
|
nextDetails.put("totalSegmentCount", this.totalSegmentCount);
|
}
|
appendEvent(eventType, message, nextDetails);
|
}
|
|
private synchronized void updateProgress(Integer traceVersion,
|
Integer currentStationId,
|
String eventType,
|
String message,
|
Map<String, Object> details) {
|
if (!acceptTraceVersion(traceVersion)) {
|
return;
|
}
|
boolean changed = !Objects.equals(this.currentStationId, currentStationId);
|
rebuildProgress(currentStationId);
|
if (!isTerminalStatus(this.status)) {
|
this.status = STATUS_RUNNING;
|
this.blockedStationId = null;
|
}
|
this.updatedAt = System.currentTimeMillis();
|
if (changed && eventType != null) {
|
Map<String, Object> nextDetails = copyDetails(details);
|
nextDetails.put("currentStationId", currentStationId);
|
nextDetails.put("passedStationIds", copyIntegerList(this.passedStationIds));
|
nextDetails.put("pendingStationIds", copyIntegerList(this.pendingStationIds));
|
appendEvent(eventType, message, nextDetails);
|
}
|
}
|
|
private synchronized void markTerminal(Integer traceVersion,
|
String terminalStatus,
|
Integer currentStationId,
|
Integer blockedStationId,
|
String eventType,
|
String message,
|
Map<String, Object> details) {
|
if (!acceptTraceVersion(traceVersion)) {
|
return;
|
}
|
if (currentStationId != null) {
|
rebuildProgress(currentStationId);
|
}
|
this.status = terminalStatus;
|
this.blockedStationId = blockedStationId;
|
if (shouldClearPathOnTerminal(terminalStatus)) {
|
clearPathState();
|
}
|
this.updatedAt = System.currentTimeMillis();
|
this.terminalExpireAt = this.updatedAt + TERMINAL_KEEP_MS;
|
|
Map<String, Object> nextDetails = copyDetails(details);
|
nextDetails.put("currentStationId", this.currentStationId);
|
nextDetails.put("blockedStationId", this.blockedStationId);
|
nextDetails.put("passedStationIds", copyIntegerList(this.passedStationIds));
|
nextDetails.put("pendingStationIds", copyIntegerList(this.pendingStationIds));
|
appendEvent(eventType, message, nextDetails);
|
}
|
|
private synchronized void updateLoopHint(Boolean loopAlertActive,
|
String loopAlertType,
|
String loopAlertText,
|
Integer loopAlertCount,
|
Map<String, Object> details) {
|
boolean active = Boolean.TRUE.equals(loopAlertActive)
|
&& loopAlertCount != null
|
&& loopAlertCount > 1
|
&& loopAlertText != null
|
&& !loopAlertText.trim().isEmpty();
|
String nextType = active ? loopAlertType : null;
|
String nextText = active ? loopAlertText.trim() : null;
|
Integer nextCount = active ? loopAlertCount : null;
|
boolean changed = !Objects.equals(this.loopAlertActive, active)
|
|| !Objects.equals(this.loopAlertType, nextType)
|
|| !Objects.equals(this.loopAlertText, nextText)
|
|| !Objects.equals(this.loopAlertCount, nextCount);
|
if (!changed) {
|
return;
|
}
|
|
this.loopAlertActive = active;
|
this.loopAlertType = nextType;
|
this.loopAlertText = nextText;
|
this.loopAlertCount = nextCount;
|
this.updatedAt = System.currentTimeMillis();
|
if (!active) {
|
return;
|
}
|
|
Map<String, Object> nextDetails = copyDetails(details);
|
nextDetails.put("loopAlertActive", Boolean.TRUE);
|
nextDetails.put("loopAlertType", this.loopAlertType);
|
nextDetails.put("loopAlertText", this.loopAlertText);
|
nextDetails.put("loopAlertCount", this.loopAlertCount);
|
appendEvent("LOOP_REPEAT_ALERT", this.loopAlertText, nextDetails);
|
}
|
|
private void clearPathState() {
|
this.fullPathStationIds = new ArrayList<>();
|
this.issuedStationIds = new ArrayList<>();
|
this.passedStationIds = new ArrayList<>();
|
this.pendingStationIds = new ArrayList<>();
|
this.latestIssuedSegmentPath = new ArrayList<>();
|
this.segmentList = new ArrayList<>();
|
this.issuedSegmentCount = 0;
|
this.totalSegmentCount = 0;
|
}
|
|
private boolean shouldClearPathOnTerminal(String terminalStatus) {
|
return STATUS_BLOCKED.equals(terminalStatus)
|
|| STATUS_CANCELLED.equals(terminalStatus);
|
}
|
|
private synchronized boolean shouldRemove(long now) {
|
return terminalExpireAt != null && terminalExpireAt <= now;
|
}
|
|
private synchronized boolean isTerminal() {
|
return isTerminalStatus(this.status);
|
}
|
|
private synchronized StationTaskTraceVo toVo() {
|
StationTaskTraceVo vo = new StationTaskTraceVo();
|
vo.setTaskNo(taskNo);
|
vo.setThreadImpl(threadImpl);
|
vo.setStatus(status);
|
vo.setTraceVersion(traceVersion);
|
vo.setStartStationId(startStationId);
|
vo.setCurrentStationId(currentStationId);
|
vo.setFinalTargetStationId(finalTargetStationId);
|
vo.setBlockedStationId(blockedStationId);
|
vo.setFullPathStationIds(copyIntegerList(fullPathStationIds));
|
vo.setIssuedStationIds(copyIntegerList(issuedStationIds));
|
vo.setPassedStationIds(copyIntegerList(passedStationIds));
|
vo.setPendingStationIds(copyIntegerList(pendingStationIds));
|
vo.setLatestIssuedSegmentPath(copyIntegerList(latestIssuedSegmentPath));
|
vo.setSegmentList(copySegmentListWithIssued(segmentList, issuedSegmentCount));
|
vo.setIssuedSegmentCount(issuedSegmentCount);
|
vo.setTotalSegmentCount(totalSegmentCount);
|
vo.setLoopAlertActive(loopAlertActive);
|
vo.setLoopAlertType(loopAlertType);
|
vo.setLoopAlertText(loopAlertText);
|
vo.setLoopAlertCount(loopAlertCount);
|
vo.setUpdatedAt(updatedAt);
|
vo.setEvents(copyEventList(events));
|
return vo;
|
}
|
|
private synchronized TraceSnapshot toSnapshot() {
|
TraceSnapshot snapshot = new TraceSnapshot();
|
snapshot.setTaskNo(taskNo);
|
snapshot.setThreadImpl(threadImpl);
|
snapshot.setStatus(status);
|
snapshot.setTraceVersion(traceVersion);
|
snapshot.setStartStationId(startStationId);
|
snapshot.setCurrentStationId(currentStationId);
|
snapshot.setFinalTargetStationId(finalTargetStationId);
|
snapshot.setBlockedStationId(blockedStationId);
|
snapshot.setFullPathStationIds(copyIntegerList(fullPathStationIds));
|
snapshot.setIssuedStationIds(copyIntegerList(issuedStationIds));
|
snapshot.setPassedStationIds(copyIntegerList(passedStationIds));
|
snapshot.setPendingStationIds(copyIntegerList(pendingStationIds));
|
snapshot.setLatestIssuedSegmentPath(copyIntegerList(latestIssuedSegmentPath));
|
snapshot.setSegmentList(copySegmentList(segmentList));
|
snapshot.setIssuedSegmentCount(issuedSegmentCount);
|
snapshot.setTotalSegmentCount(totalSegmentCount);
|
snapshot.setLoopAlertActive(loopAlertActive);
|
snapshot.setLoopAlertType(loopAlertType);
|
snapshot.setLoopAlertText(loopAlertText);
|
snapshot.setLoopAlertCount(loopAlertCount);
|
snapshot.setUpdatedAt(updatedAt);
|
snapshot.setTerminalExpireAt(terminalExpireAt);
|
snapshot.setEvents(copyEventList(events));
|
return snapshot;
|
}
|
|
private static TraceTaskState fromSnapshot(TraceSnapshot snapshot) {
|
TraceTaskState state = new TraceTaskState(snapshot.getTaskNo());
|
state.threadImpl = snapshot.getThreadImpl();
|
state.status = snapshot.getStatus() == null ? STATUS_WAITING : snapshot.getStatus();
|
state.traceVersion = snapshot.getTraceVersion() == null ? 0 : snapshot.getTraceVersion();
|
state.startStationId = snapshot.getStartStationId();
|
state.currentStationId = snapshot.getCurrentStationId();
|
state.finalTargetStationId = snapshot.getFinalTargetStationId();
|
state.blockedStationId = snapshot.getBlockedStationId();
|
state.fullPathStationIds = copyIntegerList(snapshot.getFullPathStationIds());
|
state.issuedStationIds = copyIntegerList(snapshot.getIssuedStationIds());
|
state.passedStationIds = copyIntegerList(snapshot.getPassedStationIds());
|
state.pendingStationIds = copyIntegerList(snapshot.getPendingStationIds());
|
state.latestIssuedSegmentPath = copyIntegerList(snapshot.getLatestIssuedSegmentPath());
|
state.segmentList = copySegmentList(snapshot.getSegmentList());
|
state.issuedSegmentCount = snapshot.getIssuedSegmentCount() == null ? 0 : snapshot.getIssuedSegmentCount();
|
state.totalSegmentCount = snapshot.getTotalSegmentCount() == null ? state.segmentList.size() : snapshot.getTotalSegmentCount();
|
state.loopAlertActive = Boolean.TRUE.equals(snapshot.getLoopAlertActive());
|
state.loopAlertType = snapshot.getLoopAlertType();
|
state.loopAlertText = snapshot.getLoopAlertText();
|
state.loopAlertCount = snapshot.getLoopAlertCount();
|
state.updatedAt = snapshot.getUpdatedAt() == null ? System.currentTimeMillis() : snapshot.getUpdatedAt();
|
state.terminalExpireAt = snapshot.getTerminalExpireAt();
|
state.events.clear();
|
state.events.addAll(copyEventList(snapshot.getEvents()));
|
return state;
|
}
|
|
private List<Integer> buildFullPathForRegistration(boolean rerouted,
|
Integer planCurrentStationId,
|
List<Integer> localPathStationIds) {
|
List<Integer> localPath = copyIntegerList(localPathStationIds);
|
if (!rerouted) {
|
if (localPath.isEmpty() && planCurrentStationId != null) {
|
localPath.add(planCurrentStationId);
|
}
|
return localPath;
|
}
|
|
List<Integer> result = new ArrayList<>(copyIntegerList(this.passedStationIds));
|
if (planCurrentStationId != null) {
|
result.add(planCurrentStationId);
|
}
|
if (!localPath.isEmpty()) {
|
int startIdx = 0;
|
if (planCurrentStationId != null && Objects.equals(localPath.get(0), planCurrentStationId)) {
|
startIdx = 1;
|
}
|
for (int i = startIdx; i < localPath.size(); i++) {
|
Integer stationId = localPath.get(i);
|
if (stationId != null) {
|
result.add(stationId);
|
}
|
}
|
}
|
return result;
|
}
|
|
private void rebuildProgress(Integer nextCurrentStationId) {
|
this.currentStationId = nextCurrentStationId;
|
List<Integer> fullPath = copyIntegerList(this.fullPathStationIds);
|
this.passedStationIds = new ArrayList<>();
|
this.pendingStationIds = copyIntegerList(fullPath);
|
int currentIndex = nextCurrentStationId == null ? -1 : fullPath.indexOf(nextCurrentStationId);
|
if (currentIndex < 0) {
|
return;
|
}
|
this.passedStationIds = copyIntegerList(fullPath.subList(0, currentIndex));
|
this.pendingStationIds = copyIntegerList(fullPath.subList(currentIndex + 1, fullPath.size()));
|
}
|
|
private void clearLoopHintState() {
|
this.loopAlertActive = Boolean.FALSE;
|
this.loopAlertType = null;
|
this.loopAlertText = null;
|
this.loopAlertCount = null;
|
}
|
|
private void appendLoopHintDetails(Map<String, Object> details) {
|
if (details == null || !Boolean.TRUE.equals(this.loopAlertActive) || this.loopAlertCount == null || this.loopAlertCount <= 1) {
|
return;
|
}
|
details.put("loopAlertActive", Boolean.TRUE);
|
details.put("loopAlertType", this.loopAlertType);
|
details.put("loopAlertText", this.loopAlertText);
|
details.put("loopAlertCount", this.loopAlertCount);
|
}
|
|
private boolean acceptTraceVersion(Integer incomingTraceVersion) {
|
return incomingTraceVersion != null
|
&& this.traceVersion != null
|
&& incomingTraceVersion.intValue() == this.traceVersion.intValue();
|
}
|
|
private void appendEvent(String eventType, String message, Map<String, Object> details) {
|
if (eventType == null) {
|
return;
|
}
|
StationTaskTraceEventVo event = new StationTaskTraceEventVo();
|
event.setTimestamp(System.currentTimeMillis());
|
event.setEventType(eventType);
|
event.setMessage(message);
|
event.setStatus(this.status);
|
event.setCurrentStationId(this.currentStationId);
|
event.setTargetStationId(this.finalTargetStationId);
|
event.setTraceVersion(this.traceVersion);
|
event.setDetails(copyDetails(details));
|
this.events.add(event);
|
if (this.events.size() > MAX_EVENT_COUNT) {
|
this.events.remove(0);
|
}
|
}
|
|
private List<StationTaskTraceSegmentVo> shiftSegments(List<StationTaskTraceSegmentVo> source, int pathOffset) {
|
List<StationTaskTraceSegmentVo> result = new ArrayList<>();
|
for (StationTaskTraceSegmentVo item : source) {
|
if (item == null) {
|
continue;
|
}
|
StationTaskTraceSegmentVo copy = new StationTaskTraceSegmentVo();
|
copy.setSegmentNo(item.getSegmentNo());
|
copy.setSegmentCount(item.getSegmentCount());
|
copy.setStationId(item.getStationId());
|
copy.setTargetStationId(item.getTargetStationId());
|
copy.setSegmentStartIndex(item.getSegmentStartIndex() == null ? null : item.getSegmentStartIndex() + pathOffset);
|
copy.setSegmentEndIndex(item.getSegmentEndIndex() == null ? null : item.getSegmentEndIndex() + pathOffset);
|
copy.setSegmentPath(copyIntegerList(item.getSegmentPath()));
|
copy.setIssued(Boolean.FALSE);
|
result.add(copy);
|
}
|
return result;
|
}
|
|
private List<StationTaskTraceSegmentVo> copySegmentListWithIssued(List<StationTaskTraceSegmentVo> source, Integer issuedSegmentCount) {
|
List<StationTaskTraceSegmentVo> result = new ArrayList<>();
|
int issuedCount = issuedSegmentCount == null ? 0 : issuedSegmentCount;
|
for (StationTaskTraceSegmentVo item : source) {
|
if (item == null) {
|
continue;
|
}
|
StationTaskTraceSegmentVo copy = new StationTaskTraceSegmentVo();
|
copy.setSegmentNo(item.getSegmentNo());
|
copy.setSegmentCount(item.getSegmentCount());
|
copy.setStationId(item.getStationId());
|
copy.setTargetStationId(item.getTargetStationId());
|
copy.setSegmentStartIndex(item.getSegmentStartIndex());
|
copy.setSegmentEndIndex(item.getSegmentEndIndex());
|
copy.setSegmentPath(copyIntegerList(item.getSegmentPath()));
|
copy.setIssued(item.getSegmentNo() != null && item.getSegmentNo() <= issuedCount);
|
result.add(copy);
|
}
|
return result;
|
}
|
}
|
}
|
