package com.zy.core.move;
|
|
import com.alibaba.fastjson.JSON;
|
import com.alibaba.fastjson.serializer.SerializerFeature;
|
import com.zy.common.utils.RedisUtil;
|
import com.zy.core.enums.RedisKeyType;
|
import com.zy.core.model.command.StationCommand;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Component;
|
|
import java.nio.charset.StandardCharsets;
|
import java.security.MessageDigest;
|
import java.util.ArrayList;
|
import java.util.Collections;
|
import java.util.LinkedHashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Objects;
|
|
@Component
|
public class StationMoveCoordinator {
|
|
private static final int SESSION_EXPIRE_SECONDS = 60 * 60 * 24;
|
|
@Autowired
|
private StationMoveSessionRegistry sessionRegistry;
|
@Autowired
|
private RedisUtil redisUtil;
|
|
public StationMoveSession loadSession(Integer taskNo) {
|
if (sessionRegistry == null) {
|
return null;
|
}
|
return sessionRegistry.load(taskNo);
|
}
|
|
public boolean isActiveRoute(Integer taskNo, Integer routeVersion) {
|
return sessionRegistry != null && sessionRegistry.isActiveRoute(taskNo, routeVersion);
|
}
|
|
public void markSegmentIssued(Integer taskNo, Integer routeVersion) {
|
if (sessionRegistry != null) {
|
sessionRegistry.markSegmentIssued(taskNo, routeVersion);
|
}
|
}
|
|
public void updateCurrentStation(Integer taskNo, Integer routeVersion, Integer currentStationId) {
|
if (sessionRegistry != null) {
|
sessionRegistry.updateCurrentStation(taskNo, routeVersion, currentStationId);
|
}
|
}
|
|
public void markCancelled(Integer taskNo, Integer routeVersion, Integer currentStationId, String cancelReason) {
|
updateTerminal(taskNo, routeVersion, currentStationId, StationMoveSession.STATUS_CANCELLED, cancelReason);
|
}
|
|
public void markBlocked(Integer taskNo, Integer routeVersion, Integer currentStationId) {
|
updateTerminal(taskNo, routeVersion, currentStationId, StationMoveSession.STATUS_BLOCKED, null);
|
}
|
|
public void markTimeout(Integer taskNo, Integer routeVersion, Integer currentStationId) {
|
updateTerminal(taskNo, routeVersion, currentStationId, StationMoveSession.STATUS_TIMEOUT, null);
|
}
|
|
public void markFinished(Integer taskNo, Integer routeVersion, Integer currentStationId) {
|
updateTerminal(taskNo, routeVersion, currentStationId, StationMoveSession.STATUS_FINISHED, null);
|
}
|
|
public void markCancelPending(Integer taskNo, String cancelReason) {
|
StationMoveSession session = loadSession(taskNo);
|
if (session == null || !session.isActive()) {
|
return;
|
}
|
session.setStatus(StationMoveSession.STATUS_CANCEL_PENDING);
|
session.setCancelReason(cancelReason);
|
saveSession(session);
|
}
|
|
public boolean shouldSuppressDispatch(Integer taskNo, Integer currentStationId, StationCommand candidateCommand) {
|
if (taskNo == null || taskNo <= 0 || currentStationId == null || candidateCommand == null) {
|
return false;
|
}
|
|
StationMoveSession session = loadSession(taskNo);
|
if (session == null || !session.isActive()) {
|
return false;
|
}
|
|
String candidateSignature = buildPathSignature(candidateCommand);
|
if (!isBlank(candidateSignature) && Objects.equals(candidateSignature, session.getPathSignature())) {
|
return true;
|
}
|
|
if (Objects.equals(currentStationId, session.getNextDecisionStationId())) {
|
return false;
|
}
|
|
return session.containsStation(currentStationId);
|
}
|
|
public StationMoveSession recordDispatch(Integer taskNo,
|
Integer dispatchStationId,
|
String triggerName,
|
StationCommand command,
|
boolean circleRoute) {
|
if (taskNo == null || taskNo <= 0 || command == null) {
|
return null;
|
}
|
|
StationMoveSession current = loadSession(taskNo);
|
long now = System.currentTimeMillis();
|
String pathSignature = buildPathSignature(command);
|
List<Integer> fullPathStationIds = resolveFullPathStationIds(command);
|
boolean reuseCurrent = current != null
|
&& current.isActive()
|
&& Objects.equals(current.getDispatchStationId(), dispatchStationId)
|
&& Objects.equals(current.getNextDecisionStationId(), command.getTargetStaNo())
|
&& Objects.equals(current.getPathSignature(), pathSignature);
|
|
StationMoveSession session = reuseCurrent ? current : new StationMoveSession();
|
if (!reuseCurrent) {
|
session.setRouteVersion(current == null || current.getRouteVersion() == null
|
? 1
|
: current.getRouteVersion() + 1);
|
session.setCreatedAt(now);
|
} else if (session.getRouteVersion() == null) {
|
session.setRouteVersion(1);
|
}
|
|
session.setTaskNo(taskNo);
|
session.setThreadImpl(resolveThreadImpl(triggerName));
|
session.setCurrentStationId(dispatchStationId);
|
session.setBusinessTargetStationId(command.getTargetStaNo());
|
session.setCurrentRouteTargetStationId(command.getTargetStaNo());
|
session.setTriggerType(resolveTriggerType(triggerName, circleRoute));
|
session.setDispatchMode(resolveDispatchMode(triggerName, circleRoute));
|
session.setStatus(StationMoveSession.STATUS_RUNNING);
|
session.setDispatchStationId(dispatchStationId);
|
session.setNextDecisionStationId(command.getTargetStaNo());
|
session.setFullPathStationIds(fullPathStationIds);
|
session.setPathSignature(pathSignature);
|
session.setCancelReason(null);
|
session.setUpdatedAt(now);
|
session.setLastIssuedAt(now);
|
|
command.setRouteVersion(session.getRouteVersion());
|
saveSession(session);
|
|
if (circleRoute) {
|
saveLegacyCircleCommand(taskNo, command);
|
} else {
|
clearLegacyCircleCommand(taskNo);
|
}
|
|
return session;
|
}
|
|
public StationMoveSession cancelSession(Integer taskNo) {
|
StationMoveSession session = loadSession(taskNo);
|
if (session == null) {
|
clearLegacyCircleCommand(taskNo);
|
return null;
|
}
|
session.setStatus(StationMoveSession.STATUS_CANCELLED);
|
session.setCancelReason("reroute_cancelled");
|
saveSession(session);
|
clearLegacyCircleCommand(taskNo);
|
return session;
|
}
|
|
public StationMoveSession finishSession(Integer taskNo) {
|
StationMoveSession session = loadSession(taskNo);
|
if (session == null) {
|
clearLegacyCircleCommand(taskNo);
|
return null;
|
}
|
session.setStatus(StationMoveSession.STATUS_FINISHED);
|
saveSession(session);
|
clearLegacyCircleCommand(taskNo);
|
return session;
|
}
|
|
public String buildPathSignature(StationCommand command) {
|
if (command == null) {
|
return "";
|
}
|
Map<String, Object> signature = new LinkedHashMap<>();
|
signature.put("commandType", command.getCommandType() == null ? null : command.getCommandType().name());
|
signature.put("stationId", command.getStationId());
|
signature.put("targetStaNo", command.getTargetStaNo());
|
signature.put("navigatePath", copyIntegerList(command.getNavigatePath()));
|
signature.put("liftTransferPath", copyIntegerList(command.getLiftTransferPath()));
|
signature.put("originalNavigatePath", copyIntegerList(command.getOriginalNavigatePath()));
|
return JSON.toJSONString(signature, SerializerFeature.DisableCircularReferenceDetect);
|
}
|
|
public String buildPathSignatureHash(StationCommand command) {
|
String signature = buildPathSignature(command);
|
if (isBlank(signature)) {
|
return "";
|
}
|
return digest(signature);
|
}
|
|
private void updateTerminal(Integer taskNo,
|
Integer routeVersion,
|
Integer currentStationId,
|
String status,
|
String cancelReason) {
|
if (sessionRegistry == null) {
|
return;
|
}
|
StationMoveSession session = sessionRegistry.load(taskNo);
|
if (session == null || !Objects.equals(session.getRouteVersion(), routeVersion)) {
|
return;
|
}
|
session.setCurrentStationId(currentStationId);
|
session.setStatus(status);
|
session.setCancelReason(cancelReason);
|
saveSession(session);
|
if (StationMoveSession.STATUS_CANCELLED.equals(status)
|
|| StationMoveSession.STATUS_BLOCKED.equals(status)
|
|| StationMoveSession.STATUS_TIMEOUT.equals(status)
|
|| StationMoveSession.STATUS_FINISHED.equals(status)) {
|
clearLegacyCircleCommand(taskNo);
|
}
|
}
|
|
private void saveSession(StationMoveSession session) {
|
if (sessionRegistry != null) {
|
sessionRegistry.save(session);
|
}
|
}
|
|
private void saveLegacyCircleCommand(Integer taskNo, StationCommand command) {
|
if (redisUtil == null || taskNo == null || taskNo <= 0 || command == null) {
|
return;
|
}
|
redisUtil.set(RedisKeyType.WATCH_CIRCLE_STATION_.key + taskNo,
|
JSON.toJSONString(command, SerializerFeature.DisableCircularReferenceDetect),
|
SESSION_EXPIRE_SECONDS);
|
}
|
|
private void clearLegacyCircleCommand(Integer taskNo) {
|
if (redisUtil == null || taskNo == null || taskNo <= 0) {
|
return;
|
}
|
redisUtil.del(RedisKeyType.WATCH_CIRCLE_STATION_.key + taskNo);
|
}
|
|
private List<Integer> resolveFullPathStationIds(StationCommand command) {
|
if (command == null) {
|
return new ArrayList<>();
|
}
|
List<Integer> source = command.getOriginalNavigatePath();
|
if (source == null || source.isEmpty()) {
|
source = command.getNavigatePath();
|
}
|
if (source != null && !source.isEmpty()) {
|
return new ArrayList<>(source);
|
}
|
List<Integer> path = new ArrayList<>();
|
if (command.getStationId() != null) {
|
path.add(command.getStationId());
|
}
|
if (command.getTargetStaNo() != null && !Objects.equals(command.getTargetStaNo(), command.getStationId())) {
|
path.add(command.getTargetStaNo());
|
}
|
return path;
|
}
|
|
private List<Integer> copyIntegerList(List<Integer> source) {
|
if (source == null || source.isEmpty()) {
|
return Collections.emptyList();
|
}
|
return new ArrayList<>(source);
|
}
|
|
private String resolveThreadImpl(String triggerName) {
|
if (triggerName == null) {
|
return null;
|
}
|
if (triggerName.contains("crn")) {
|
return "crn";
|
}
|
if (triggerName.contains("watchCircle")) {
|
return "station";
|
}
|
if (triggerName.contains("checkStationRunBlock")) {
|
return "station";
|
}
|
if (triggerName.contains("checkStationIdleRecover")) {
|
return "station";
|
}
|
if (triggerName.contains("checkStationOutOrder")) {
|
return "station";
|
}
|
return triggerName;
|
}
|
|
private StationMoveTriggerType resolveTriggerType(String triggerName, boolean circleRoute) {
|
if (circleRoute) {
|
return StationMoveTriggerType.WATCH_CIRCLE;
|
}
|
if (triggerName == null) {
|
return StationMoveTriggerType.INITIAL_OUTBOUND;
|
}
|
if (triggerName.contains("checkStationOutOrder")) {
|
return StationMoveTriggerType.OUT_ORDER;
|
}
|
if (triggerName.contains("watchCircle")) {
|
return StationMoveTriggerType.WATCH_CIRCLE;
|
}
|
if (triggerName.contains("checkStationRunBlock")) {
|
return StationMoveTriggerType.RUN_BLOCK;
|
}
|
if (triggerName.contains("checkStationIdleRecover")) {
|
return StationMoveTriggerType.IDLE_RECOVER;
|
}
|
return StationMoveTriggerType.INITIAL_OUTBOUND;
|
}
|
|
private StationMoveDispatchMode resolveDispatchMode(String triggerName, boolean circleRoute) {
|
if (circleRoute) {
|
return StationMoveDispatchMode.CIRCLE;
|
}
|
if (triggerName != null && triggerName.contains("checkStationRunBlock")) {
|
return StationMoveDispatchMode.RUN_BLOCK_REROUTE;
|
}
|
if (triggerName != null && triggerName.contains("checkStationIdleRecover")) {
|
return StationMoveDispatchMode.IDLE_RECOVER_REROUTE;
|
}
|
return StationMoveDispatchMode.DIRECT;
|
}
|
|
private boolean isBlank(String value) {
|
return value == null || value.trim().isEmpty();
|
}
|
|
private String digest(String value) {
|
try {
|
MessageDigest digest = MessageDigest.getInstance("SHA-256");
|
byte[] bytes = digest.digest(value.getBytes(StandardCharsets.UTF_8));
|
StringBuilder builder = new StringBuilder(bytes.length * 2);
|
for (byte b : bytes) {
|
String hex = Integer.toHexString(b & 0xff);
|
if (hex.length() == 1) {
|
builder.append('0');
|
}
|
builder.append(hex);
|
}
|
return builder.toString();
|
} catch (Exception ignore) {
|
return Integer.toHexString(value.hashCode());
|
}
|
}
|
}
|
