package com.zy.core.network.fake;
|
|
import com.alibaba.fastjson.JSON;
|
import com.alibaba.fastjson.JSONObject;
|
import com.zy.asrs.entity.DeviceConfig;
|
import com.zy.common.utils.RedisUtil;
|
import com.zy.core.News;
|
import com.zy.core.enums.RedisKeyType;
|
import com.zy.core.enums.StationCommandType;
|
import com.zy.core.model.CommandResponse;
|
import com.zy.core.model.command.StationCommand;
|
import com.zy.core.network.api.ZyStationConnectApi;
|
import com.zy.core.network.entity.ZyStationStatusEntity;
|
|
import java.util.ArrayList;
|
import java.util.Arrays;
|
import java.util.HashSet;
|
import java.util.LinkedHashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Set;
|
import java.util.concurrent.BlockingQueue;
|
import java.util.concurrent.ConcurrentHashMap;
|
import java.util.concurrent.ExecutorService;
|
import java.util.concurrent.Executors;
|
import java.util.concurrent.LinkedBlockingQueue;
|
import java.util.concurrent.ScheduledExecutorService;
|
import java.util.concurrent.ThreadFactory;
|
import java.util.concurrent.TimeUnit;
|
import java.util.concurrent.atomic.AtomicInteger;
|
|
public class ZyStationFakeSegConnect implements ZyStationConnectApi {
|
|
private long getWaitSegmentTimeoutMs() {
|
return FakeConfigSupport.getLong(FakeConfigKeys.FAKE_STATION_SEGMENT_WAIT_TIMEOUT_MS, 30000L);
|
}
|
|
private long getMoveStepDurationMs() {
|
return FakeConfigSupport.getLong(FakeConfigKeys.FAKE_STATION_MOVE_STEP_DURATION_MS, 500L);
|
}
|
|
private long getIdleLoopDelayMs() {
|
return FakeConfigSupport.getLong(FakeConfigKeys.FAKE_STATION_IDLE_LOOP_DELAY_MS, 200L);
|
}
|
|
private long getBlockedLoopDelayMs() {
|
return FakeConfigSupport.getLong(FakeConfigKeys.FAKE_STATION_BLOCKED_LOOP_DELAY_MS, 1000L);
|
}
|
|
private long getInitializeDelayMs() {
|
return FakeConfigSupport.getLong(FakeConfigKeys.FAKE_STATION_INITIALIZE_DELAY_MS, 0L);
|
}
|
|
private long getFinishDelayMs() {
|
return FakeConfigSupport.getLong(FakeConfigKeys.FAKE_STATION_FINISH_DELAY_MS, 0L);
|
}
|
|
private static final String STATUS_WAITING = "WAITING";
|
private static final String STATUS_RUNNING = "RUNNING";
|
private static final String STATUS_BLOCKED = "BLOCKED";
|
private static final String STATUS_CANCELLED = "CANCELLED";
|
private static final String STATUS_TIMEOUT = "TIMEOUT";
|
private static final String STATUS_FINISHED = "FINISHED";
|
|
private static final String SEGMENT_MERGE_APPEND = "APPEND";
|
private static final String SEGMENT_MERGE_REPLACE_TARGET_CHANGED = "REPLACE_TARGET_CHANGED";
|
private static final String SEGMENT_MERGE_REPLACE_REROUTE = "REPLACE_REROUTE";
|
private static final String SEGMENT_MERGE_IGNORE_DISCONNECTED = "IGNORE_DISCONNECTED";
|
private static final String SEGMENT_MERGE_IGNORE_CURRENT_MISSING = "IGNORE_CURRENT_MISSING";
|
|
private final FakeStationStateManager stateManager = new FakeStationStateManager();
|
private final FakeStationMoveEngine moveEngine = new FakeStationMoveEngine(stateManager);
|
private final FakeStationBlockManager blockManager = new FakeStationBlockManager(stateManager);
|
private static final AtomicInteger DEVICE_EXECUTOR_THREAD_SEQ = new AtomicInteger(1);
|
private volatile ScheduledExecutorService loopScheduler = createLoopScheduler();
|
private RedisUtil redisUtil;
|
private final Map<Integer, ExecutorService> deviceExecutors = new ConcurrentHashMap<Integer, ExecutorService>();
|
|
private final Map<Integer, BlockingQueue<StationCommand>> taskQueues = new ConcurrentHashMap<Integer, BlockingQueue<StationCommand>>();
|
private final Map<Integer, Long> taskLastUpdateTime = new ConcurrentHashMap<Integer, Long>();
|
private final Map<Integer, Boolean> taskRunning = new ConcurrentHashMap<Integer, Boolean>();
|
private final Map<Integer, TaskRuntimeContext> taskContexts = new ConcurrentHashMap<Integer, TaskRuntimeContext>();
|
private final Map<Integer, AtomicInteger> taskLoopGenerations = new ConcurrentHashMap<Integer, AtomicInteger>();
|
private final Map<Integer, Object> taskLifecycleLocks = new ConcurrentHashMap<Integer, Object>();
|
private volatile Set<Integer> legalClearStationIds = new HashSet<Integer>();
|
private volatile Set<Integer> barcodeStationIds = new HashSet<Integer>();
|
|
public void addFakeConnect(DeviceConfig deviceConfig, RedisUtil redisUtil) {
|
this.redisUtil = redisUtil;
|
refreshLegalClearStationIds();
|
refreshBarcodeStationIds();
|
stateManager.registerDevice(deviceConfig);
|
}
|
|
@Override
|
public boolean connect() {
|
if (loopScheduler == null || loopScheduler.isShutdown() || loopScheduler.isTerminated()) {
|
loopScheduler = createLoopScheduler();
|
}
|
return true;
|
}
|
|
@Override
|
public boolean disconnect() {
|
ScheduledExecutorService scheduler = loopScheduler;
|
if (scheduler != null) {
|
scheduler.shutdownNow();
|
}
|
for (ExecutorService executor : deviceExecutors.values()) {
|
executor.shutdownNow();
|
}
|
deviceExecutors.clear();
|
taskQueues.clear();
|
taskLastUpdateTime.clear();
|
taskRunning.clear();
|
taskContexts.clear();
|
taskLoopGenerations.clear();
|
taskLifecycleLocks.clear();
|
return true;
|
}
|
|
@Override
|
public List<ZyStationStatusEntity> getStatus(Integer deviceNo) {
|
return stateManager.getStatus(deviceNo);
|
}
|
|
@Override
|
public CommandResponse sendCommand(Integer deviceNo, StationCommand command) {
|
Integer taskNo = command.getTaskNo();
|
if (taskNo == null) {
|
return new CommandResponse(false, "任务号为空");
|
}
|
|
if (command.getCommandType() != StationCommandType.MOVE) {
|
News.info("[WCS Debug] fake sendCommand收到非MOVE命令，deviceNo={}，taskNo={}，stationId={}，targetStaNo={}，commandType={}",
|
deviceNo, taskNo, command.getStationId(), command.getTargetStaNo(), command.getCommandType());
|
getDeviceExecutor(deviceNo).submit(new Runnable() {
|
@Override
|
public void run() {
|
handleCommand(deviceNo, command);
|
}
|
});
|
return new CommandResponse(true, "命令已受理（异步执行）");
|
}
|
|
int loopGeneration = 0;
|
boolean shouldSchedule = false;
|
Object lifecycleLock = getTaskLifecycleLock(taskNo);
|
synchronized (lifecycleLock) {
|
BlockingQueue<StationCommand> queue = taskQueues.computeIfAbsent(taskNo, key -> new LinkedBlockingQueue<StationCommand>());
|
queue.offer(command);
|
taskLastUpdateTime.put(taskNo, System.currentTimeMillis());
|
News.info("[WCS Debug] fake sendCommand入队，deviceNo={}，taskNo={}，stationId={}，targetStaNo={}，segmentNo={}，segmentCount={}，queueSize={}，running={}",
|
deviceNo, taskNo, command.getStationId(), command.getTargetStaNo(), command.getSegmentNo(), command.getSegmentCount(),
|
queue.size(), taskRunning.containsKey(taskNo));
|
|
if (taskRunning.putIfAbsent(taskNo, true) == null) {
|
TaskRuntimeContext context = new TaskRuntimeContext(taskNo, deviceNo, stateManager.getThreadImpl(deviceNo));
|
taskContexts.put(taskNo, context);
|
AtomicInteger generation = taskLoopGenerations.computeIfAbsent(taskNo, key -> new AtomicInteger(0));
|
loopGeneration = generation.incrementAndGet();
|
context.loopGeneration = loopGeneration;
|
shouldSchedule = true;
|
News.info("[WCS Debug] fake task准备启动执行线程，deviceNo={}，taskNo={}，queueSize={}，loopGeneration={}",
|
deviceNo, taskNo, queue.size(), loopGeneration);
|
} else {
|
News.info("[WCS Debug] fake task复用已存在执行线程，deviceNo={}，taskNo={}，queueSize={}",
|
deviceNo, taskNo, queue.size());
|
}
|
}
|
if (shouldSchedule) {
|
scheduleTaskLoop(deviceNo, taskNo, loopGeneration);
|
}
|
|
return new CommandResponse(true, "命令已受理（异步执行）");
|
}
|
|
@Override
|
public CommandResponse sendOriginCommand(String address, short[] data) {
|
return new CommandResponse(true, "原始命令已受理（异步执行）");
|
}
|
|
@Override
|
public CommandResponse clearTaskBufferSlot(Integer deviceNo, Integer stationId, Integer slotIdx) {
|
return stateManager.clearTaskBufferSlot(deviceNo, stationId, slotIdx);
|
}
|
|
@Override
|
public byte[] readOriginCommand(String address, int length) {
|
return new byte[0];
|
}
|
|
|
private ScheduledExecutorService createLoopScheduler() {
|
return Executors.newSingleThreadScheduledExecutor(new ThreadFactory() {
|
@Override
|
public Thread newThread(Runnable runnable) {
|
Thread thread = new Thread(runnable, "fake-station-loop-scheduler");
|
thread.setDaemon(true);
|
return thread;
|
}
|
});
|
}
|
|
private ExecutorService getDeviceExecutor(Integer deviceNo) {
|
return deviceExecutors.computeIfAbsent(deviceNo, key -> Executors.newSingleThreadExecutor(new ThreadFactory() {
|
@Override
|
public Thread newThread(Runnable runnable) {
|
Thread thread = new Thread(runnable,
|
"fake-station-device-" + key + "-" + DEVICE_EXECUTOR_THREAD_SEQ.getAndIncrement());
|
thread.setDaemon(true);
|
return thread;
|
}
|
}));
|
}
|
|
private void scheduleTaskLoop(Integer deviceNo, Integer taskNo, int loopGeneration) {
|
scheduleTaskLoop(deviceNo, taskNo, loopGeneration, 0L);
|
}
|
|
private void scheduleTaskLoop(Integer deviceNo, Integer taskNo, int loopGeneration, long delayMs) {
|
Runnable task = new Runnable() {
|
@Override
|
public void run() {
|
getDeviceExecutor(deviceNo).submit(new Runnable() {
|
@Override
|
public void run() {
|
runTaskLoop(deviceNo, taskNo, loopGeneration);
|
}
|
});
|
}
|
};
|
if (delayMs <= 0L) {
|
task.run();
|
return;
|
}
|
loopScheduler.schedule(task, delayMs, TimeUnit.MILLISECONDS);
|
}
|
|
private void scheduleTaskLoopByDelay(Integer deviceNo, Integer taskNo, int loopGeneration, long delayMs) {
|
scheduleTaskLoop(deviceNo, taskNo, loopGeneration, Math.max(delayMs, 1L));
|
}
|
|
private void runTaskLoop(Integer deviceNo, Integer taskNo, int loopGeneration) {
|
TaskRuntimeContext context = taskContexts.get(taskNo);
|
if (context == null) {
|
News.info("[WCS Debug] fake task忽略无上下文续跑片段，deviceNo={}，taskNo={}，loopGeneration={}",
|
deviceNo, taskNo, loopGeneration);
|
return;
|
}
|
if (!deviceNo.equals(context.deviceNo)) {
|
News.info("[WCS Debug] fake task忽略跨设备续跑片段，taskNo={}，expectedDeviceNo={}，actualDeviceNo={}，loopGeneration={}",
|
taskNo, context.deviceNo, deviceNo, loopGeneration);
|
return;
|
}
|
if (context.loopGeneration != loopGeneration || !isCurrentLoopGeneration(taskNo, loopGeneration)) {
|
News.info("[WCS Debug] fake task忽略过期续跑片段，deviceNo={}，taskNo={}，expectedLoopGeneration={}，actualLoopGeneration={}",
|
deviceNo, taskNo, loopGeneration, context.loopGeneration);
|
return;
|
}
|
News.info("[WCS Debug] fake task进入runTaskLoop，deviceNo={}，taskNo={}，threadImpl={}，queueExists={}，queueSize={}，loopGeneration={}，status={}，initialized={}，currentStationId={}，targetStationId={}，blockedStationId={}，pendingPath={}",
|
deviceNo, taskNo, context.threadImpl, taskQueues.containsKey(taskNo),
|
taskQueues.containsKey(taskNo) && taskQueues.get(taskNo) != null ? taskQueues.get(taskNo).size() : null, loopGeneration,
|
context.status, context.initialized, context.currentStationId, context.finalTargetStationId,
|
context.blockedStationId, context.getPendingStationIds());
|
long nextDelayMs = 0L;
|
boolean shouldContinue = false;
|
try {
|
if (Thread.currentThread().isInterrupted()) {
|
if (!isTerminalStatus(context.status)) {
|
context.status = STATUS_CANCELLED;
|
}
|
} else if (hasTaskReset(taskNo)) {
|
context.status = STATUS_CANCELLED;
|
} else {
|
BlockingQueue<StationCommand> commandQueue = taskQueues.get(taskNo);
|
if (commandQueue == null) {
|
context.status = STATUS_FINISHED;
|
} else {
|
StationCommand command = commandQueue.poll();
|
if (command != null) {
|
taskLastUpdateTime.put(taskNo, System.currentTimeMillis());
|
context.lastCommandAt = System.currentTimeMillis();
|
handleIncomingSegment(deviceNo, context, command);
|
}
|
|
if (!isTerminalStatus(context.status)) {
|
if (!context.pendingPathQueue.isEmpty()) {
|
News.info("[WCS Debug] fake task准备推进，deviceNo={}，taskNo={}，initialized={}，currentStationId={}，targetStationId={}，blockedStationId={}，pendingPath={}",
|
deviceNo, taskNo, context.initialized, context.currentStationId,
|
context.finalTargetStationId, context.blockedStationId, context.getPendingStationIds());
|
if (!context.initialized || context.currentStationId == null) {
|
nextDelayMs = initializeTaskPosition(deviceNo, context);
|
} else {
|
MoveStepResult moveResult = executeNextMove(deviceNo, context);
|
if (!moveResult.shouldContinue()) {
|
context.status = STATUS_FINISHED;
|
}
|
nextDelayMs = moveResult.getNextDelayMs();
|
}
|
} else {
|
News.info("[WCS Debug] fake task进入空闲态，deviceNo={}，taskNo={}，status={}，currentStationId={}，targetStationId={}，blockedStationId={}，pendingPath={}",
|
deviceNo, taskNo, context.status, context.currentStationId,
|
context.finalTargetStationId, context.blockedStationId, context.getPendingStationIds());
|
IdleStepResult idleResult = handleIdleState(deviceNo, context);
|
if (idleResult.isFinished() && !isTerminalStatus(context.status)) {
|
context.status = STATUS_FINISHED;
|
}
|
nextDelayMs = idleResult.getNextDelayMs();
|
}
|
}
|
shouldContinue = !isTerminalStatus(context.status)
|
&& taskQueues.containsKey(taskNo)
|
&& (commandQueue != null);
|
}
|
}
|
} catch (Exception e) {
|
context.status = STATUS_CANCELLED;
|
if (e instanceof InterruptedException) {
|
Thread.currentThread().interrupt();
|
}
|
News.info("[WCS Debug] 任务{}执行异常，当前站点={}，目标站={}，待执行路径={}，异常类型={}，异常信息={}",
|
taskNo, context.currentStationId, context.finalTargetStationId, context.getPendingStationIds(),
|
e.getClass().getSimpleName(), e.getMessage());
|
}
|
|
if (shouldContinue) {
|
if (nextDelayMs > 0L) {
|
scheduleTaskLoopByDelay(deviceNo, taskNo, loopGeneration, nextDelayMs);
|
} else {
|
scheduleTaskLoop(deviceNo, taskNo, loopGeneration);
|
}
|
return;
|
}
|
finishTaskLoop(deviceNo, taskNo, context, loopGeneration);
|
}
|
|
private void finishTaskLoop(Integer deviceNo, Integer taskNo, TaskRuntimeContext context, int loopGeneration) {
|
Object lifecycleLock = getTaskLifecycleLock(taskNo);
|
synchronized (lifecycleLock) {
|
if (context.loopGeneration != loopGeneration || !isCurrentLoopGeneration(taskNo, loopGeneration)) {
|
News.info("[WCS Debug] fake task忽略过期结束清理，deviceNo={}，taskNo={}，expectedLoopGeneration={}，actualLoopGeneration={}",
|
deviceNo, taskNo, loopGeneration, context.loopGeneration);
|
return;
|
}
|
BlockingQueue<StationCommand> queue = taskQueues.get(taskNo);
|
if (queue != null && !queue.isEmpty()) {
|
News.info("[WCS Debug] fake task结束清理前发现新命令，恢复续跑，deviceNo={}，taskNo={}，queueSize={}，loopGeneration={}",
|
deviceNo, taskNo, queue.size(), loopGeneration);
|
scheduleTaskLoop(deviceNo, taskNo, loopGeneration);
|
return;
|
}
|
News.info("[WCS Debug] fake task即将退出runTaskLoop，deviceNo={}，taskNo={}，status={}，queueSizeBeforeCleanup={}，lastCurrentStationId={}，targetStationId={}，loopGeneration={}",
|
deviceNo, taskNo, context.status, queue == null ? null : queue.size(), context.currentStationId, context.finalTargetStationId, loopGeneration);
|
taskQueues.remove(taskNo);
|
taskLastUpdateTime.remove(taskNo);
|
taskRunning.remove(taskNo);
|
taskContexts.remove(taskNo);
|
taskLoopGenerations.remove(taskNo);
|
taskLifecycleLocks.remove(taskNo, lifecycleLock);
|
}
|
|
if (!isTerminalStatus(context.status)) {
|
context.status = STATUS_FINISHED;
|
}
|
traceEvent(deviceNo, context, "TASK_END", "任务执行结束并清理资源",
|
buildDetails("reason", context.status, "loopGeneration", loopGeneration), true);
|
News.info("[WCS Debug] 任务{}执行结束并清理资源，状态={}，loopGeneration={}", taskNo, context.status, loopGeneration);
|
}
|
|
private void handleIncomingSegment(Integer deviceNo, TaskRuntimeContext context, StationCommand command) {
|
if (!deviceNo.equals(context.deviceNo)) {
|
traceEvent(deviceNo, context, "SEGMENT_IGNORED", "路径分段来自不同设备车道，已忽略",
|
buildDetails("expectedDeviceNo", context.deviceNo, "actualDeviceNo", deviceNo,
|
"segmentNo", command.getSegmentNo(), "segmentCount", command.getSegmentCount()), false);
|
return;
|
}
|
List<Integer> newPath = normalizePath(command.getNavigatePath());
|
Integer lastInQueue = getLastInQueue(context.pendingPathQueue);
|
int startIndex = getPathAppendStartIndex(newPath, context.currentStationId, lastInQueue);
|
Integer previousTargetStationId = context.finalTargetStationId;
|
Integer commandTargetStationId = command.getTargetStaNo();
|
boolean targetChanged = commandTargetStationId != null
|
&& !commandTargetStationId.equals(previousTargetStationId);
|
boolean queueEmpty = context.pendingPathQueue.isEmpty();
|
boolean newPathContainsCurrent = context.currentStationId != null && newPath.contains(context.currentStationId);
|
boolean pathConnectedToTail = startIndex >= 0;
|
List<Integer> oldPendingStations = context.getPendingStationIds();
|
boolean shouldClearBarcodeSourceOnReroute = context.currentStationId != null
|
&& context.currentStationId.equals(command.getStationId())
|
&& isBarcodeStation(context.currentStationId)
|
&& previousTargetStationId != null
|
&& previousTargetStationId.equals(context.currentStationId)
|
&& commandTargetStationId != null
|
&& !commandTargetStationId.equals(context.currentStationId);
|
|
context.setStartStationIdIfAbsent(command.getStationId());
|
if (!context.generateBarcode && checkTaskNoInArea(context.taskNo)) {
|
context.generateBarcode = true;
|
}
|
|
traceEvent(deviceNo, context, "SEGMENT_RECEIVED", "收到新的路径分段命令",
|
buildDetails("segmentPath", newPath, "appendStartIndex", startIndex, "currentStationId",
|
context.currentStationId, "queueTailStationId", lastInQueue, "commandStationId",
|
command.getStationId(), "commandTargetStationId", commandTargetStationId,
|
"previousTargetStationId", previousTargetStationId),
|
false);
|
|
if (commandTargetStationId != null) {
|
if (targetChanged) {
|
traceEvent(deviceNo, context, "TARGET_SWITCHED",
|
"任务目标站发生切换: " + previousTargetStationId + " -> " + commandTargetStationId,
|
buildDetails("fromTargetStationId", previousTargetStationId, "toTargetStationId",
|
commandTargetStationId),
|
false);
|
context.arrivalHandled = false;
|
}
|
context.finalTargetStationId = commandTargetStationId;
|
syncCurrentStationTarget(context.taskNo, context.currentStationId, context.finalTargetStationId);
|
}
|
context.segmentNo = command.getSegmentNo();
|
context.segmentCount = command.getSegmentCount();
|
|
boolean tailConnectedAppend = !queueEmpty && pathConnectedToTail;
|
boolean shouldReplace = !tailConnectedAppend && !queueEmpty
|
&& (targetChanged || (!pathConnectedToTail && newPathContainsCurrent));
|
String ignoreReason = null;
|
if (!shouldReplace && !tailConnectedAppend && !newPath.isEmpty() && !pathConnectedToTail) {
|
ignoreReason = newPathContainsCurrent ? SEGMENT_MERGE_IGNORE_DISCONNECTED : SEGMENT_MERGE_IGNORE_CURRENT_MISSING;
|
if (queueEmpty && context.currentStationId == null) {
|
startIndex = 0;
|
} else {
|
traceEvent(deviceNo, context, "SEGMENT_IGNORED", "路径分段无法接入当前运行上下文，已忽略",
|
buildDetails("segmentPath", newPath, "currentStationId", context.currentStationId,
|
"queueTailStationId", lastInQueue, "ignoreReason", ignoreReason,
|
"queueEmpty", queueEmpty, "tailConnectedAppend", tailConnectedAppend,
|
"targetChanged", targetChanged),
|
false);
|
context.latestAppendedPath.clear();
|
return;
|
}
|
}
|
|
if (tailConnectedAppend && startIndex < 0) {
|
startIndex = 0;
|
}
|
|
List<Integer> appendedPath = new ArrayList<Integer>();
|
List<Integer> replacedFuturePath = new ArrayList<Integer>();
|
Integer duplicateHeadStationId = null;
|
String mergeMode = SEGMENT_MERGE_APPEND;
|
if (shouldReplace) {
|
replacedFuturePath = rebuildPendingPathFromCurrent(context, newPath);
|
boolean atTargetAlready = context.currentStationId != null && context.currentStationId.equals(commandTargetStationId);
|
if (context.currentStationId != null && replacedFuturePath.isEmpty() && !atTargetAlready) {
|
traceEvent(deviceNo, context, "SEGMENT_IGNORED", "路径分段无法接入当前运行上下文，已忽略",
|
buildDetails("segmentPath", newPath, "currentStationId", context.currentStationId,
|
"queueTailStationId", lastInQueue, "ignoreReason", SEGMENT_MERGE_IGNORE_CURRENT_MISSING),
|
false);
|
context.latestAppendedPath.clear();
|
return;
|
}
|
replacePendingPathQueue(context, replacedFuturePath);
|
context.replaceLatestPath(replacedFuturePath);
|
mergeMode = targetChanged ? SEGMENT_MERGE_REPLACE_TARGET_CHANGED : SEGMENT_MERGE_REPLACE_REROUTE;
|
traceEvent(deviceNo, context, "SEGMENT_REPLACED",
|
"新的 reroute 路径已覆盖旧 future queue",
|
buildDetails("mergeMode", mergeMode, "currentStationId", context.currentStationId,
|
"previousTargetStationId", previousTargetStationId, "newTargetStationId", commandTargetStationId,
|
"oldQueue", oldPendingStations, "replacedFuturePath", replacedFuturePath,
|
"queueSize", context.pendingPathQueue.size()),
|
false);
|
} else {
|
for (int i = startIndex; i < newPath.size(); i++) {
|
Integer stationId = newPath.get(i);
|
context.pendingPathQueue.offer(stationId);
|
appendedPath.add(stationId);
|
}
|
if (context.currentStationId != null && context.currentStationId.equals(context.pendingPathQueue.peek())) {
|
duplicateHeadStationId = context.pendingPathQueue.poll();
|
if (!appendedPath.isEmpty() && duplicateHeadStationId.equals(appendedPath.get(0))) {
|
appendedPath.remove(0);
|
}
|
}
|
context.appendStitchedPath(appendedPath);
|
traceEvent(deviceNo, context, "SEGMENT_APPENDED",
|
"路径分段已追加到待执行队列，队列长度=" + context.pendingPathQueue.size(),
|
buildDetails("mergeMode", mergeMode, "segmentPath", newPath, "appendedPath", appendedPath,
|
"appendStartIndex", startIndex, "queueSize", context.pendingPathQueue.size(),
|
"tailConnectedAppend", tailConnectedAppend, "targetChanged", targetChanged,
|
"duplicateHeadStationId", duplicateHeadStationId),
|
false);
|
}
|
|
if (duplicateHeadStationId != null) {
|
traceEvent(deviceNo, context, "SEGMENT_TRIMMED", "待执行队列头部重复当前站点，已移除",
|
buildDetails("currentStationId", context.currentStationId,
|
"duplicateHeadStationId", duplicateHeadStationId,
|
"queueSize", context.pendingPathQueue.size(),
|
"remainingPendingPath", context.getPendingStationIds()),
|
false);
|
}
|
|
if (context.currentStationId != null && context.currentStationId.equals(context.pendingPathQueue.peek())) {
|
Integer trimmedHead = context.pendingPathQueue.poll();
|
traceEvent(deviceNo, context, "SEGMENT_TRIMMED", "待执行队列头部仍与当前站点重复，已再次移除",
|
buildDetails("currentStationId", context.currentStationId,
|
"duplicateHeadStationId", trimmedHead,
|
"queueSize", context.pendingPathQueue.size(),
|
"remainingPendingPath", context.getPendingStationIds()),
|
false);
|
}
|
|
context.lastCommandAt = System.currentTimeMillis();
|
|
boolean segmentAccepted = !appendedPath.isEmpty() || !replacedFuturePath.isEmpty()
|
|| (context.currentStationId != null && context.currentStationId.equals(commandTargetStationId))
|
|| (context.currentStationId != null && context.currentStationId.equals(command.getStationId())
|
&& commandTargetStationId != null && commandTargetStationId.equals(context.finalTargetStationId));
|
if (segmentAccepted) {
|
if (shouldClearBarcodeSourceOnReroute && context.currentStationId != null) {
|
Integer currentDeviceNo = stateManager.getDeviceNoByStationId(context.currentStationId);
|
if (currentDeviceNo != null) {
|
guardedClearStationForDispatch(currentDeviceNo, context.currentStationId, context.taskNo, "barcodeSourceRerouteAccepted");
|
traceEvent(deviceNo, context, "SOURCE_STATION_CLEARED", "条码源站已完成任务交接，源站状态已清除",
|
buildDetails("stationId", context.currentStationId,
|
"previousTargetStationId", previousTargetStationId,
|
"newTargetStationId", commandTargetStationId,
|
"mergeMode", mergeMode),
|
false);
|
}
|
}
|
resumeFromCurrentStation(deviceNo, context, mergeMode, appendedPath, replacedFuturePath,
|
shouldClearBarcodeSourceOnReroute);
|
}
|
}
|
|
private long initializeTaskPosition(Integer deviceNo, TaskRuntimeContext context) {
|
Integer nextStationId = context.pendingPathQueue.peek();
|
if (nextStationId == null) {
|
return 0L;
|
}
|
|
if (context.currentStationId == null) {
|
Integer actualCurrentStationId = stateManager.findCurrentStationIdByTask(context.taskNo);
|
if (actualCurrentStationId != null) {
|
context.currentStationId = actualCurrentStationId;
|
context.initialized = true;
|
context.status = STATUS_RUNNING;
|
context.blockedStationId = null;
|
|
Integer actualDeviceNo = stateManager.getDeviceNoByStationId(actualCurrentStationId);
|
if (actualDeviceNo != null) {
|
guardedClearRunBlock(context.taskNo, actualCurrentStationId, actualDeviceNo);
|
}
|
|
trimPendingPathToCurrent(context.pendingPathQueue, actualCurrentStationId);
|
if (actualCurrentStationId.equals(context.pendingPathQueue.peek())) {
|
context.pendingPathQueue.poll();
|
}
|
|
context.addPassedStation(actualCurrentStationId);
|
context.lastStepAt = System.currentTimeMillis();
|
context.lastProgressAt = context.lastStepAt;
|
context.lastProgressStationId = context.currentStationId;
|
guardedPublishTaskLocation(context.taskNo, actualDeviceNo, actualCurrentStationId, true, false);
|
traceEvent(deviceNo, context, "MOVE_INIT", "任务从当前实际站点恢复执行",
|
buildDetails("stationId", actualCurrentStationId, "recovered", true), false);
|
return 0L;
|
}
|
}
|
|
context.currentStationId = nextStationId;
|
Integer currentDeviceNo = stateManager.getDeviceNoByStationId(context.currentStationId);
|
if (currentDeviceNo == null) {
|
context.pendingPathQueue.poll();
|
return 0L;
|
}
|
|
boolean result = moveEngine.initStationMove(context.taskNo, context.currentStationId, currentDeviceNo, context.taskNo,
|
context.finalTargetStationId, true, null);
|
if (!result) {
|
return getIdleLoopDelayMs();
|
}
|
|
context.initialized = true;
|
context.status = STATUS_RUNNING;
|
context.pendingPathQueue.poll();
|
context.addPassedStation(context.currentStationId);
|
context.lastStepAt = System.currentTimeMillis();
|
context.lastProgressAt = context.lastStepAt;
|
context.lastProgressStationId = context.currentStationId;
|
guardedPublishTaskLocation(context.taskNo, currentDeviceNo, context.currentStationId, true, false);
|
traceEvent(deviceNo, context, "MOVE_INIT", "任务初始化起点站点",
|
buildDetails("stationId", context.currentStationId, "recovered", false), false);
|
return Math.max(getInitializeDelayMs(), getMoveStepDurationMs());
|
}
|
|
private MoveStepResult executeNextMove(Integer deviceNo, TaskRuntimeContext context) {
|
Integer nextStationId = context.pendingPathQueue.peek();
|
if (nextStationId == null || context.currentStationId == null) {
|
return MoveStepResult.continueNow();
|
}
|
|
Integer currentDeviceNo = stateManager.getDeviceNoByStationId(context.currentStationId);
|
Integer nextDeviceNo = stateManager.getDeviceNoByStationId(nextStationId);
|
if (currentDeviceNo == null || nextDeviceNo == null) {
|
context.pendingPathQueue.poll();
|
return MoveStepResult.continueNow();
|
}
|
|
boolean moveSuccess = moveEngine.stationMoveToNext(context.taskNo, context.currentStationId, currentDeviceNo,
|
nextStationId, nextDeviceNo, context.taskNo, context.finalTargetStationId);
|
if (moveSuccess) {
|
Integer previousStationId = context.currentStationId;
|
context.currentStationId = nextStationId;
|
context.pendingPathQueue.poll();
|
context.addPassedStation(nextStationId);
|
context.arrivalHandled = false;
|
context.blockedStationId = null;
|
context.status = STATUS_RUNNING;
|
context.lastStepAt = System.currentTimeMillis();
|
context.lastProgressAt = context.lastStepAt;
|
context.lastProgressStationId = context.currentStationId;
|
blockManager.clearBlocked(previousStationId);
|
blockManager.clearBlocked(nextStationId);
|
traceEvent(deviceNo, context, "MOVE_STEP_OK", "任务完成一步站点移动",
|
buildDetails("fromStationId", previousStationId, "toStationId", nextStationId,
|
"remainingPendingPath", context.getPendingStationIds()),
|
false);
|
return MoveStepResult.continueAfter(getBlockedLoopDelayMs());
|
}
|
|
long now = System.currentTimeMillis();
|
boolean sameStationNoProgress = context.currentStationId != null
|
&& context.currentStationId.equals(context.lastProgressStationId);
|
long timeoutMs = blockManager.getFakeRunBlockTimeoutMs(redisUtil);
|
long dwellMs = now - context.lastProgressAt;
|
if (!checkTaskNoInArea(context.taskNo) && blockManager.getFakeAllowCheckBlock(redisUtil)
|
&& !blockManager.isSpecialStation(context.currentStationId)
|
&& !blockManager.isBlocked(context.currentStationId)
|
&& sameStationNoProgress
|
&& dwellMs > timeoutMs) {
|
List<Integer> clearedPendingPath = context.getPendingStationIds();
|
News.info("[WCS Debug] fake task清空待执行路径，原因=RUN_BLOCKED，deviceNo={}，taskNo={}，currentStationId={}，targetStationId={}，blockedStationId={}，pendingBeforeClear={}",
|
deviceNo, context.taskNo, context.currentStationId, context.finalTargetStationId,
|
context.blockedStationId, clearedPendingPath);
|
context.clearPendingPathWithLog(deviceNo, context.taskNo, context.currentStationId,
|
context.finalTargetStationId, context.blockedStationId, "RUN_BLOCKED");
|
guardedRunBlockStation(context.taskNo, context.currentStationId, currentDeviceNo, context.taskNo,
|
context.currentStationId);
|
context.blockedStationId = context.currentStationId;
|
context.status = STATUS_BLOCKED;
|
traceEvent(deviceNo, context, "RUN_BLOCKED", "任务在当前站点停留超时，被标记为堵塞，待执行路径已清空",
|
buildDetails("blockedStationId", context.currentStationId,
|
"lastProgressStationId", context.lastProgressStationId,
|
"dwellMs", dwellMs,
|
"timeoutMs", timeoutMs,
|
"clearedPendingPath", clearedPendingPath), false);
|
return MoveStepResult.continueAfter(getMoveStepDurationMs());
|
}
|
|
context.status = STATUS_WAITING;
|
traceEvent(deviceNo, context, "MOVE_STEP_WAIT", "当前站已更新目标但尚未完成落站，保持当前位置等待下一次推进",
|
buildDetails("currentStationId", context.currentStationId,
|
"nextStationId", nextStationId,
|
"targetStationId", context.finalTargetStationId,
|
"blockedStationId", context.blockedStationId,
|
"pendingPath", context.getPendingStationIds()), false);
|
return MoveStepResult.continueAfter(500L);
|
}
|
|
private void resumeFromCurrentStation(Integer deviceNo, TaskRuntimeContext context, String mergeMode,
|
List<Integer> appendedPath, List<Integer> replacedFuturePath, boolean sourceCleared) {
|
if (context.currentStationId != null) {
|
Integer currentDeviceNo = stateManager.getDeviceNoByStationId(context.currentStationId);
|
if (currentDeviceNo != null) {
|
guardedClearRunBlock(context.taskNo, context.currentStationId, currentDeviceNo);
|
guardedPublishTaskLocation(context.taskNo, currentDeviceNo, context.currentStationId, true, false);
|
}
|
}
|
context.blockedStationId = null;
|
context.status = STATUS_RUNNING;
|
context.lastProgressAt = System.currentTimeMillis();
|
context.lastProgressStationId = context.currentStationId;
|
traceEvent(deviceNo, context, "BLOCK_RESET", "收到新的路径分段，已清除堵塞并重新计时",
|
buildDetails("mergeMode", mergeMode, "currentStationId", context.currentStationId,
|
"targetStationId", context.finalTargetStationId, "queueSize", context.pendingPathQueue.size(),
|
"appendedPath", appendedPath, "replacedFuturePath", replacedFuturePath,
|
"sourceCleared", sourceCleared),
|
false);
|
}
|
|
private boolean shouldAdvanceFromCurrentState(TaskRuntimeContext context) {
|
return context != null
|
&& context.initialized
|
&& context.currentStationId != null
|
&& !context.pendingPathQueue.isEmpty()
|
&& !STATUS_BLOCKED.equals(context.status)
|
&& !STATUS_CANCELLED.equals(context.status)
|
&& !STATUS_TIMEOUT.equals(context.status)
|
&& !STATUS_FINISHED.equals(context.status);
|
}
|
|
private IdleStepResult handleIdleState(Integer deviceNo, TaskRuntimeContext context) {
|
if (shouldAdvanceFromCurrentState(context)) {
|
traceEvent(deviceNo, context, "IDLE_RESUME", "当前站点存在未完成路径，立即从当前站恢复推进",
|
buildDetails("currentStationId", context.currentStationId,
|
"targetStationId", context.finalTargetStationId,
|
"pendingPath", context.getPendingStationIds()), false);
|
context.status = STATUS_RUNNING;
|
return IdleStepResult.waitNext(1L);
|
}
|
|
if (context.currentStationId != null && context.finalTargetStationId != null
|
&& context.currentStationId.equals(context.finalTargetStationId)) {
|
if (!context.arrivalHandled) {
|
boolean barcodeGenerated = false;
|
if (context.generateBarcode) {
|
Integer targetDeviceNo = stateManager.getDeviceNoByStationId(context.finalTargetStationId);
|
if (targetDeviceNo != null) {
|
barcodeGenerated = guardedGenerateStationBarcode(context.taskNo, context.finalTargetStationId,
|
targetDeviceNo);
|
}
|
}
|
context.arrivalHandled = true;
|
context.lastProgressAt = System.currentTimeMillis();
|
context.lastProgressStationId = context.currentStationId;
|
traceEvent(deviceNo, context, "ARRIVED", "任务到达最终目标站点",
|
buildDetails("stationId", context.currentStationId, "barcodeGenerated", barcodeGenerated),
|
false);
|
}
|
|
Integer targetDeviceNo = stateManager.getDeviceNoByStationId(context.finalTargetStationId);
|
if (targetDeviceNo != null) {
|
boolean ownerConflict = stateManager.isFinalStationOwnerConflict(targetDeviceNo, context.finalTargetStationId,
|
context.taskNo);
|
if (ownerConflict) {
|
logFinalStationOwnershipLost(deviceNo, context);
|
context.status = STATUS_BLOCKED;
|
return IdleStepResult.waitNext(getMoveStepDurationMs());
|
}
|
boolean stationCleared = stateManager.isStationClearedForTask(targetDeviceNo, context.finalTargetStationId,
|
context.taskNo);
|
boolean crnTaken = isCrnTakenByTask(context.taskNo);
|
if (stationCleared || crnTaken) {
|
context.status = STATUS_FINISHED;
|
traceEvent(deviceNo, context, "TASK_COMPLETE", "堆垛机已取走货物，任务完成",
|
buildDetails("stationId", context.finalTargetStationId, "stationCleared", stationCleared, "crnTaken", crnTaken), false);
|
return IdleStepResult.finish();
|
}
|
}
|
if (targetDeviceNo != null && !guardedArrivalCompletion(targetDeviceNo, context)) {
|
context.status = STATUS_BLOCKED;
|
return IdleStepResult.waitNext(getMoveStepDurationMs());
|
}
|
|
long dwellMs = System.currentTimeMillis() - context.lastProgressAt;
|
long timeoutMs = blockManager.getFakeRunBlockTimeoutMs(redisUtil);
|
if (!checkTaskNoInArea(context.taskNo) && blockManager.getFakeAllowCheckBlock(redisUtil)
|
&& !blockManager.isSpecialStation(context.currentStationId)
|
&& !blockManager.isBlocked(context.currentStationId)
|
&& dwellMs > timeoutMs) {
|
context.status = STATUS_BLOCKED;
|
context.clearPendingPathWithLog(deviceNo, context.taskNo, context.currentStationId,
|
context.finalTargetStationId, context.blockedStationId, "TARGET_RUN_BLOCKED");
|
guardedRunBlockStation(context.taskNo, context.currentStationId, targetDeviceNo, context.taskNo,
|
context.currentStationId);
|
context.blockedStationId = context.currentStationId;
|
traceEvent(deviceNo, context, "RUN_BLOCKED", "任务到达终点站后停留超时，被标记为堵塞，等待堆垛机取货",
|
buildDetails("blockedStationId", context.currentStationId,
|
"lastProgressStationId", context.lastProgressStationId,
|
"dwellMs", dwellMs,
|
"timeoutMs", timeoutMs), false);
|
return IdleStepResult.waitNext(getMoveStepDurationMs());
|
}
|
|
return IdleStepResult.waitNext(getFinishDelayMs());
|
}
|
|
Long lastTime = taskLastUpdateTime.get(context.taskNo);
|
long waitSegmentTimeoutMs = getWaitSegmentTimeoutMs();
|
if (lastTime != null && System.currentTimeMillis() - lastTime > waitSegmentTimeoutMs) {
|
traceEvent(deviceNo, context, "WAIT_TIMEOUT", "等待新的路径分段超时",
|
buildDetails("timeoutMs", waitSegmentTimeoutMs, "currentStationId", context.currentStationId,
|
"targetStationId", context.finalTargetStationId),
|
false);
|
taskLastUpdateTime.put(context.taskNo, System.currentTimeMillis());
|
}
|
return IdleStepResult.waitNext(getIdleLoopDelayMs());
|
}
|
|
private List<Integer> normalizePath(List<Integer> path) {
|
List<Integer> result = new ArrayList<Integer>();
|
if (path == null) {
|
return result;
|
}
|
for (Integer stationId : path) {
|
if (stationId != null) {
|
result.add(stationId);
|
}
|
}
|
return result;
|
}
|
|
private void trimPendingPathToCurrent(LinkedBlockingQueue<Integer> queue, Integer currentStationId) {
|
if (queue == null || currentStationId == null || queue.isEmpty()) {
|
return;
|
}
|
List<Integer> snapshot = new ArrayList<Integer>(queue);
|
int index = snapshot.indexOf(currentStationId);
|
if (index <= 0) {
|
return;
|
}
|
for (int i = 0; i < index; i++) {
|
queue.poll();
|
}
|
}
|
|
private List<Integer> rebuildPendingPathFromCurrent(TaskRuntimeContext context, List<Integer> newPath) {
|
List<Integer> rebuilt = new ArrayList<Integer>();
|
if (newPath == null || newPath.isEmpty()) {
|
return rebuilt;
|
}
|
Integer currentStationId = context.currentStationId;
|
int startIndex = 0;
|
if (currentStationId != null) {
|
int currentIndex = newPath.indexOf(currentStationId);
|
if (currentIndex < 0) {
|
return rebuilt;
|
}
|
startIndex = currentIndex + 1;
|
}
|
for (int i = startIndex; i < newPath.size(); i++) {
|
rebuilt.add(newPath.get(i));
|
}
|
return rebuilt;
|
}
|
|
private void replacePendingPathQueue(TaskRuntimeContext context, List<Integer> futurePath) {
|
context.pendingPathQueue.clear();
|
if (futurePath == null) {
|
return;
|
}
|
for (Integer stationId : futurePath) {
|
context.pendingPathQueue.offer(stationId);
|
}
|
}
|
|
private boolean hasTaskReset(Integer taskNo) {
|
// 仿真系统不响应外部取消信号（如堵塞重路由触发的 signalSegmentReset），
|
// 避免任务在站点行走过程中被意外清除
|
return false;
|
}
|
|
private Integer getLastInQueue(LinkedBlockingQueue<Integer> queue) {
|
Integer last = null;
|
for (Integer item : queue) {
|
last = item;
|
}
|
return last;
|
}
|
|
private int getPathAppendStartIndex(List<Integer> newPath, Integer currentStationId, Integer lastInQueue) {
|
if (newPath == null || newPath.isEmpty()) {
|
return 0;
|
}
|
|
if (lastInQueue != null) {
|
int idx = newPath.lastIndexOf(lastInQueue);
|
if (idx >= 0) {
|
return idx + 1;
|
}
|
}
|
|
if (currentStationId != null) {
|
int idx = newPath.lastIndexOf(currentStationId);
|
if (idx >= 0) {
|
return idx + 1;
|
}
|
return -1;
|
}
|
|
if (lastInQueue != null) {
|
return -1;
|
}
|
|
return 0;
|
}
|
|
private void syncCurrentStationTarget(Integer taskNo, Integer currentStationId, Integer targetStationId) {
|
if (currentStationId == null || targetStationId == null) {
|
return;
|
}
|
Integer currentDeviceNo = stateManager.getDeviceNoByStationId(currentStationId);
|
if (currentDeviceNo == null) {
|
return;
|
}
|
|
moveEngine.lockStations(currentStationId);
|
try {
|
ZyStationStatusEntity currentStatus = stateManager.findStationStatus(currentDeviceNo, currentStationId);
|
if (currentStatus == null) {
|
return;
|
}
|
|
if (hasOwnerConflict(currentStatus, taskNo)) {
|
logOwnerConflict("syncCurrentStationTarget", currentStationId, currentStatus, taskNo, targetStationId, false,
|
"owner_conflict");
|
return;
|
}
|
|
stateManager.updateStationDataInternal(currentStationId, currentDeviceNo, taskNo, targetStationId, null, null, null);
|
} finally {
|
moveEngine.unlockStations(currentStationId);
|
}
|
}
|
|
private boolean hasOwnerConflict(ZyStationStatusEntity currentStatus, Integer incomingTaskNo) {
|
return currentStatus != null
|
&& currentStatus.isLoading()
|
&& currentStatus.getTaskNo() != null
|
&& currentStatus.getTaskNo() > 0
|
&& (incomingTaskNo == null || !currentStatus.getTaskNo().equals(incomingTaskNo));
|
}
|
|
private void logOwnerConflict(String operation, Integer stationId, ZyStationStatusEntity currentStatus,
|
Integer incomingTaskNo, Integer incomingTargetStationId, boolean finalStation, String reason) {
|
News.info("[WCS Debug] fake station owner冲突，operation={}，stationId={}，currentTaskNo={}，currentLoading={}，currentTargetStaNo={}，incomingTaskNo={}，incomingTargetStaNo={}，finalStation={}，reason={}",
|
operation,
|
stationId,
|
currentStatus == null ? null : currentStatus.getTaskNo(),
|
currentStatus == null ? null : currentStatus.isLoading(),
|
currentStatus == null ? null : currentStatus.getTargetStaNo(),
|
incomingTaskNo,
|
incomingTargetStationId,
|
finalStation,
|
reason);
|
}
|
|
private boolean ensureStationWritable(String operation, Integer deviceNo, Integer stationId,
|
Integer incomingTaskNo, Integer incomingTargetStationId, boolean finalStation) {
|
if (deviceNo == null || stationId == null) {
|
return false;
|
}
|
ZyStationStatusEntity currentStatus = stateManager.findStationStatus(deviceNo, stationId);
|
if (currentStatus == null) {
|
return false;
|
}
|
if (!hasOwnerConflict(currentStatus, incomingTaskNo)) {
|
return true;
|
}
|
logOwnerConflict(operation, stationId, currentStatus, incomingTaskNo, incomingTargetStationId, finalStation,
|
finalStation ? "final_station_owner_conflict" : "owner_conflict");
|
return false;
|
}
|
|
private boolean ensureStationClearable(String operation, Integer deviceNo, Integer stationId, Integer expectedTaskNo,
|
boolean finalStation) {
|
if (deviceNo == null || stationId == null) {
|
return false;
|
}
|
ZyStationStatusEntity currentStatus = stateManager.findStationStatus(deviceNo, stationId);
|
if (currentStatus == null) {
|
return false;
|
}
|
if (!hasOwnerConflict(currentStatus, expectedTaskNo)) {
|
return true;
|
}
|
if (isLegalClearStation(stationId)) {
|
return true;
|
}
|
logOwnerConflict(operation, stationId, currentStatus, expectedTaskNo, currentStatus.getTargetStaNo(), finalStation,
|
"illegal_clear_attempt");
|
return false;
|
}
|
|
private boolean isLegalClearStation(Integer stationId) {
|
if (stationId == null) {
|
return false;
|
}
|
Set<Integer> stationIds = legalClearStationIds;
|
if (stationIds == null || stationIds.isEmpty()) {
|
refreshLegalClearStationIds();
|
stationIds = legalClearStationIds;
|
}
|
return stationIds != null && stationIds.contains(stationId);
|
}
|
|
private boolean isBarcodeStation(Integer stationId) {
|
if (stationId == null) {
|
return false;
|
}
|
Set<Integer> stationIds = barcodeStationIds;
|
if (stationIds == null || stationIds.isEmpty()) {
|
refreshBarcodeStationIds();
|
stationIds = barcodeStationIds;
|
}
|
return stationIds != null && stationIds.contains(stationId);
|
}
|
|
private void refreshLegalClearStationIds() {
|
try {
|
Set<Integer> stationIds = new HashSet<Integer>();
|
|
com.zy.asrs.service.BasCrnpService basCrnpService = com.core.common.SpringUtils.getBean(com.zy.asrs.service.BasCrnpService.class);
|
List<com.zy.asrs.entity.BasCrnp> basCrnps = basCrnpService.list();
|
for (com.zy.asrs.entity.BasCrnp basCrnp : basCrnps) {
|
if (basCrnp == null) {
|
continue;
|
}
|
collectStationIds(stationIds, basCrnp.getInStationList$());
|
collectStationIds(stationIds, basCrnp.getOutStationList$());
|
}
|
|
com.zy.asrs.service.BasDevpService basDevpService = com.core.common.SpringUtils.getBean(com.zy.asrs.service.BasDevpService.class);
|
List<com.zy.asrs.entity.BasDevp> basDevps = basDevpService.list();
|
for (com.zy.asrs.entity.BasDevp basDevp : basDevps) {
|
if (basDevp == null) {
|
continue;
|
}
|
collectStationIds(stationIds, basDevp.getBarcodeStationList$());
|
collectStationIds(stationIds, basDevp.getInStationList$());
|
collectStationIds(stationIds, basDevp.getOutStationList$());
|
}
|
|
legalClearStationIds = stationIds;
|
} catch (Exception e) {
|
News.info("[WCS Debug] fake 合法清站白名单刷新失败，异常类型={}，异常信息={}",
|
e.getClass().getSimpleName(), e.getMessage());
|
}
|
}
|
|
private void refreshBarcodeStationIds() {
|
try {
|
Set<Integer> stationIds = new HashSet<Integer>();
|
com.zy.asrs.service.BasDevpService basDevpService = com.core.common.SpringUtils.getBean(com.zy.asrs.service.BasDevpService.class);
|
List<com.zy.asrs.entity.BasDevp> basDevps = basDevpService.list();
|
for (com.zy.asrs.entity.BasDevp basDevp : basDevps) {
|
if (basDevp == null) {
|
continue;
|
}
|
collectStationIds(stationIds, basDevp.getBarcodeStationList$());
|
}
|
barcodeStationIds = stationIds;
|
} catch (Exception e) {
|
News.info("[WCS Debug] fake 条码站白名单刷新失败，异常类型={}，异常信息={}",
|
e.getClass().getSimpleName(), e.getMessage());
|
}
|
}
|
|
private void collectStationIds(Set<Integer> stationIds, List<com.zy.core.model.StationObjModel> stations) {
|
if (stationIds == null || stations == null || stations.isEmpty()) {
|
return;
|
}
|
for (com.zy.core.model.StationObjModel station : stations) {
|
if (station != null && station.getStationId() != null) {
|
stationIds.add(station.getStationId());
|
}
|
}
|
}
|
|
private boolean isFinalStation(Integer taskNo, Integer stationId) {
|
TaskRuntimeContext context = taskNo == null ? null : taskContexts.get(taskNo);
|
return context != null && stationId != null && stationId.equals(context.finalTargetStationId);
|
}
|
|
private void logFinalStationOwnershipLost(Integer deviceNo, TaskRuntimeContext context) {
|
Integer stationId = context == null ? null : context.finalTargetStationId;
|
Integer targetDeviceNo = stateManager.getDeviceNoByStationId(stationId);
|
ZyStationStatusEntity currentStatus = targetDeviceNo == null ? null : stateManager.snapshotStation(targetDeviceNo, stationId);
|
News.info("[WCS Debug] fake 最终站所有权丢失，taskNo={}，stationId={}，currentTaskNo={}，currentLoading={}，currentTargetStaNo={}，reason={}",
|
context == null ? null : context.taskNo,
|
stationId,
|
currentStatus == null ? null : currentStatus.getTaskNo(),
|
currentStatus == null ? null : currentStatus.isLoading(),
|
currentStatus == null ? null : currentStatus.getTargetStaNo(),
|
"final_station_owner_conflict");
|
traceEvent(deviceNo, context, "FINAL_STATION_OWNER_CONFLICT", "最终站仍有物但所有者已被其他任务覆盖",
|
buildDetails("stationId", stationId,
|
"currentTaskNo", currentStatus == null ? null : currentStatus.getTaskNo(),
|
"currentLoading", currentStatus == null ? null : currentStatus.isLoading(),
|
"currentTargetStaNo", currentStatus == null ? null : currentStatus.getTargetStaNo()), false);
|
}
|
|
private boolean guardedClearStationForDispatch(Integer deviceNo, Integer stationId, Integer expectedTaskNo, String reason) {
|
if (!ensureStationClearable("clearStationForDispatch", deviceNo, stationId, expectedTaskNo,
|
isFinalStation(expectedTaskNo, stationId))) {
|
return false;
|
}
|
stateManager.clearStationForDispatch(deviceNo, stationId, reason);
|
return true;
|
}
|
|
private boolean guardedResetStation(Integer deviceNo, Integer stationId, Integer expectedTaskNo) {
|
if (!ensureStationClearable("resetStation", deviceNo, stationId, expectedTaskNo,
|
isFinalStation(expectedTaskNo, stationId))) {
|
return false;
|
}
|
stateManager.resetStation(deviceNo, stationId);
|
return true;
|
}
|
|
private boolean guardedUpdateStationBarcode(Integer deviceNo, Integer stationId, Integer taskNo, String barcode) {
|
if (!ensureStationWritable("updateStationBarcode", deviceNo, stationId, taskNo, null,
|
isFinalStation(taskNo, stationId))) {
|
return false;
|
}
|
stateManager.updateStationBarcode(deviceNo, stationId, barcode);
|
return true;
|
}
|
|
private boolean guardedGenerateFakeOutStationData(Integer deviceNo, Integer stationId, Integer taskNo) {
|
if (!ensureStationWritable("generateFakeOutStationData", deviceNo, stationId, taskNo, null,
|
isFinalStation(taskNo, stationId))) {
|
News.error("fake 出库站点有物写入被拒绝。deviceNo={}，stationId={}，taskNo={}，reason=station-not-writable",
|
deviceNo, stationId, taskNo);
|
return false;
|
}
|
stateManager.generateFakeOutStationData(deviceNo, stationId);
|
News.info("fake 出库站点有物写入成功。deviceNo={}，stationId={}，taskNo={}，loading=true",
|
deviceNo, stationId, taskNo);
|
return true;
|
}
|
|
private boolean guardedHandoffBarcodeStation(Integer deviceNo, Integer taskNo, Integer stationId, Integer targetStationId) {
|
if (!ensureStationWritable("handoffBarcodeStation", deviceNo, stationId, taskNo, targetStationId,
|
isFinalStation(taskNo, stationId))) {
|
return false;
|
}
|
stateManager.handoffBarcodeStation(deviceNo, taskNo, stationId, targetStationId);
|
return true;
|
}
|
|
private boolean guardedRunBlockStation(Integer taskNo, Integer stationId, Integer deviceNo, Integer ownerTaskNo,
|
Integer targetStationId) {
|
if (!ensureStationWritable("runBlockStation", deviceNo, stationId, ownerTaskNo, targetStationId,
|
isFinalStation(ownerTaskNo, stationId))) {
|
return false;
|
}
|
blockManager.runBlockStation(taskNo, stationId, deviceNo, ownerTaskNo, targetStationId);
|
return true;
|
}
|
|
private boolean guardedClearRunBlock(Integer taskNo, Integer stationId, Integer deviceNo) {
|
if (!ensureStationWritable("clearRunBlock", deviceNo, stationId, taskNo, null,
|
isFinalStation(taskNo, stationId))) {
|
return false;
|
}
|
blockManager.clearRunBlock(stationId, deviceNo);
|
return true;
|
}
|
|
private boolean guardedPublishTaskLocation(Integer taskNo, Integer deviceNo, Integer stationId, boolean loading, boolean runBlock) {
|
if (loading && !ensureStationWritable("publishTaskLocation", deviceNo, stationId, taskNo, null,
|
isFinalStation(taskNo, stationId))) {
|
return false;
|
}
|
stateManager.publishTaskLocation(taskNo, deviceNo, stationId, loading, runBlock);
|
return true;
|
}
|
|
private boolean guardedGenerateStationData(Integer deviceNo, Integer taskNo, Integer stationId, Integer targetStationId) {
|
if (!ensureStationWritable("generateStationData", deviceNo, stationId, taskNo, targetStationId,
|
isFinalStation(taskNo, stationId))) {
|
return false;
|
}
|
stateManager.generateStationData(deviceNo, taskNo, stationId, targetStationId);
|
return true;
|
}
|
|
private boolean guardedSyncCurrentStationTarget(Integer taskNo, Integer currentStationId, Integer targetStationId) {
|
syncCurrentStationTarget(taskNo, currentStationId, targetStationId);
|
return true;
|
}
|
|
private boolean guardedClearTaskLocationIfMatches(Integer taskNo, Integer deviceNo, Integer stationId) {
|
stateManager.clearTaskLocationIfMatches(taskNo, deviceNo, stationId);
|
return true;
|
}
|
|
private boolean guardedPublishCurrentLocation(Integer taskNo, Integer deviceNo, Integer stationId) {
|
return guardedPublishTaskLocation(taskNo, deviceNo, stationId, true, false);
|
}
|
|
private boolean guardedGenerateStationBarcode(Integer taskNo, Integer stationId, Integer deviceNo) {
|
if (!ensureStationWritable("generateStationBarcode", deviceNo, stationId, taskNo, null,
|
isFinalStation(taskNo, stationId))) {
|
return false;
|
}
|
return stateManager.generateStationBarcode(taskNo, stationId, deviceNo);
|
}
|
|
private boolean guardedUpdateStationData(Integer stationId, Integer deviceNo, Integer taskNo, Integer targetStationId,
|
Boolean loading, String barcode, Boolean runBlock) {
|
if ((taskNo != null || Boolean.TRUE.equals(loading))
|
&& !ensureStationWritable("updateStationData", deviceNo, stationId, taskNo, targetStationId,
|
isFinalStation(taskNo, stationId))) {
|
return false;
|
}
|
return stateManager.updateStationDataInternal(stationId, deviceNo, taskNo, targetStationId, loading, barcode, runBlock);
|
}
|
|
private boolean isFinalStationConflict(Integer taskNo, Integer stationId, Integer deviceNo) {
|
return isFinalStation(taskNo, stationId) && stateManager.isOccupiedByOtherLoadingTask(deviceNo, stationId, taskNo);
|
}
|
|
private boolean guardedResetOrClearBlockedStation(Integer taskNo, Integer stationId, Integer deviceNo) {
|
return ensureStationClearable("blockedStationClear", deviceNo, stationId, taskNo, isFinalStation(taskNo, stationId));
|
}
|
|
private boolean guardedStationOccupied(Integer taskNo, Integer stationId, Integer deviceNo) {
|
return !stateManager.isOccupiedByOtherLoadingTask(deviceNo, stationId, taskNo);
|
}
|
|
private boolean guardedFinalStationOwnership(Integer taskNo, Integer stationId, Integer deviceNo) {
|
return !stateManager.isFinalStationOwnerConflict(deviceNo, stationId, taskNo);
|
}
|
|
private boolean guardedFinalStationWritable(Integer taskNo, Integer stationId, Integer deviceNo, String operation) {
|
if (!guardedFinalStationOwnership(taskNo, stationId, deviceNo)) {
|
ZyStationStatusEntity currentStatus = stateManager.snapshotStation(deviceNo, stationId);
|
logOwnerConflict(operation, stationId, currentStatus, taskNo,
|
currentStatus == null ? null : currentStatus.getTargetStaNo(), true,
|
"final_station_owner_conflict");
|
return false;
|
}
|
return true;
|
}
|
|
private boolean guardedFinalStationClearable(Integer taskNo, Integer stationId, Integer deviceNo, String operation) {
|
if (!guardedFinalStationOwnership(taskNo, stationId, deviceNo)) {
|
ZyStationStatusEntity currentStatus = stateManager.snapshotStation(deviceNo, stationId);
|
logOwnerConflict(operation, stationId, currentStatus, taskNo,
|
currentStatus == null ? null : currentStatus.getTargetStaNo(), true,
|
"illegal_clear_attempt");
|
return false;
|
}
|
return true;
|
}
|
|
private boolean shouldTreatAsFinalStationConflict(Integer taskNo, Integer stationId, Integer deviceNo) {
|
return isFinalStation(taskNo, stationId) && stateManager.isFinalStationOwnerConflict(deviceNo, stationId, taskNo);
|
}
|
|
private boolean guardedFinalStationMutation(String operation, Integer taskNo, Integer stationId, Integer deviceNo, Integer targetStationId) {
|
if (shouldTreatAsFinalStationConflict(taskNo, stationId, deviceNo)) {
|
ZyStationStatusEntity currentStatus = stateManager.snapshotStation(deviceNo, stationId);
|
logOwnerConflict(operation, stationId, currentStatus, taskNo, targetStationId, true,
|
"final_station_owner_conflict");
|
return false;
|
}
|
return true;
|
}
|
|
private boolean guardedFinalStationClear(String operation, Integer taskNo, Integer stationId, Integer deviceNo) {
|
if (shouldTreatAsFinalStationConflict(taskNo, stationId, deviceNo)) {
|
ZyStationStatusEntity currentStatus = stateManager.snapshotStation(deviceNo, stationId);
|
logOwnerConflict(operation, stationId, currentStatus, taskNo,
|
currentStatus == null ? null : currentStatus.getTargetStaNo(), true,
|
"illegal_clear_attempt");
|
return false;
|
}
|
return true;
|
}
|
|
private boolean guardedStationWrite(String operation, Integer taskNo, Integer stationId, Integer deviceNo, Integer targetStationId) {
|
if (!guardedFinalStationMutation(operation, taskNo, stationId, deviceNo, targetStationId)) {
|
return false;
|
}
|
return ensureStationWritable(operation, deviceNo, stationId, taskNo, targetStationId, isFinalStation(taskNo, stationId));
|
}
|
|
private boolean guardedStationClear(String operation, Integer taskNo, Integer stationId, Integer deviceNo) {
|
if (!guardedFinalStationClear(operation, taskNo, stationId, deviceNo)) {
|
return false;
|
}
|
return ensureStationClearable(operation, deviceNo, stationId, taskNo, isFinalStation(taskNo, stationId));
|
}
|
|
private boolean guardedStateMutation(String operation, Integer taskNo, Integer stationId, Integer deviceNo, Integer targetStationId,
|
Runnable mutation) {
|
if (!guardedStationWrite(operation, taskNo, stationId, deviceNo, targetStationId)) {
|
return false;
|
}
|
mutation.run();
|
return true;
|
}
|
|
private boolean guardedStateClear(String operation, Integer taskNo, Integer stationId, Integer deviceNo, Runnable mutation) {
|
if (!guardedStationClear(operation, taskNo, stationId, deviceNo)) {
|
return false;
|
}
|
mutation.run();
|
return true;
|
}
|
|
private boolean guardedFinalStationCompletion(Integer deviceNo, TaskRuntimeContext context) {
|
if (context == null || context.finalTargetStationId == null || context.taskNo == null) {
|
return false;
|
}
|
return !stateManager.isFinalStationOwnerConflict(deviceNo, context.finalTargetStationId, context.taskNo);
|
}
|
|
private boolean guardedCurrentStationOwnership(Integer taskNo, Integer currentStationId, Integer currentDeviceNo) {
|
return !stateManager.isOccupiedByOtherLoadingTask(currentDeviceNo, currentStationId, taskNo);
|
}
|
|
private boolean guardedTargetStationOwnership(Integer taskNo, Integer stationId, Integer deviceNo) {
|
return !stateManager.isOccupiedByOtherLoadingTask(deviceNo, stationId, taskNo);
|
}
|
|
private boolean guardedCommandWrite(String operation, Integer taskNo, Integer stationId, Integer deviceNo, Integer targetStationId, Runnable mutation) {
|
if (!guardedStationWrite(operation, taskNo, stationId, deviceNo, targetStationId)) {
|
return false;
|
}
|
mutation.run();
|
return true;
|
}
|
|
private boolean guardedCommandClear(String operation, Integer taskNo, Integer stationId, Integer deviceNo, Runnable mutation) {
|
if (!guardedStationClear(operation, taskNo, stationId, deviceNo)) {
|
return false;
|
}
|
mutation.run();
|
return true;
|
}
|
|
private boolean guardedRunBlockMutation(Integer taskNo, Integer stationId, Integer deviceNo, Integer targetStationId) {
|
return guardedStationWrite("runBlockStation", taskNo, stationId, deviceNo, targetStationId);
|
}
|
|
private boolean guardedClearMutation(Integer taskNo, Integer stationId, Integer deviceNo, String operation) {
|
return guardedStationClear(operation, taskNo, stationId, deviceNo);
|
}
|
|
private boolean guardedArrivalOwnership(Integer deviceNo, TaskRuntimeContext context) {
|
return context != null && context.finalTargetStationId != null && context.taskNo != null
|
&& !stateManager.isFinalStationOwnerConflict(deviceNo, context.finalTargetStationId, context.taskNo);
|
}
|
|
private boolean guardedArrivalStationWritable(Integer deviceNo, TaskRuntimeContext context, String operation) {
|
if (!guardedArrivalOwnership(deviceNo, context)) {
|
logFinalStationOwnershipLost(deviceNo, context);
|
return false;
|
}
|
return true;
|
}
|
|
private boolean guardedArrivalStationClearable(Integer deviceNo, TaskRuntimeContext context, String operation) {
|
if (!guardedArrivalOwnership(deviceNo, context)) {
|
logFinalStationOwnershipLost(deviceNo, context);
|
return false;
|
}
|
return true;
|
}
|
|
private boolean guardedStationMutation(String operation, Integer taskNo, Integer stationId, Integer deviceNo, Integer targetStationId,
|
Runnable mutation, boolean clearOperation) {
|
boolean allowed = clearOperation
|
? guardedStationClear(operation, taskNo, stationId, deviceNo)
|
: guardedStationWrite(operation, taskNo, stationId, deviceNo, targetStationId);
|
if (!allowed) {
|
return false;
|
}
|
mutation.run();
|
return true;
|
}
|
|
private boolean guardedFinalArrivalState(Integer deviceNo, TaskRuntimeContext context) {
|
if (context == null || context.finalTargetStationId == null || context.taskNo == null) {
|
return false;
|
}
|
if (stateManager.isFinalStationOwnerConflict(deviceNo, context.finalTargetStationId, context.taskNo)) {
|
logFinalStationOwnershipLost(deviceNo, context);
|
return false;
|
}
|
return true;
|
}
|
|
private boolean guardedArrivalCompletion(Integer deviceNo, TaskRuntimeContext context) {
|
return guardedFinalArrivalState(deviceNo, context);
|
}
|
|
private boolean guardedStationOwnership(String operation, Integer taskNo, Integer stationId, Integer deviceNo, Integer targetStationId,
|
boolean clearOperation) {
|
return clearOperation
|
? guardedStationClear(operation, taskNo, stationId, deviceNo)
|
: guardedStationWrite(operation, taskNo, stationId, deviceNo, targetStationId);
|
}
|
|
private boolean guardedStationMutationIfAllowed(String operation, Integer taskNo, Integer stationId, Integer deviceNo,
|
Integer targetStationId, boolean clearOperation, Runnable mutation) {
|
if (!guardedStationOwnership(operation, taskNo, stationId, deviceNo, targetStationId, clearOperation)) {
|
return false;
|
}
|
mutation.run();
|
return true;
|
}
|
|
private boolean guardedArrivalStationState(Integer deviceNo, TaskRuntimeContext context) {
|
return guardedFinalArrivalState(deviceNo, context);
|
}
|
|
private boolean guardedMutateFinalStation(String operation, Integer taskNo, Integer stationId, Integer deviceNo,
|
Integer targetStationId, Runnable mutation) {
|
if (!guardedStationWrite(operation, taskNo, stationId, deviceNo, targetStationId)) {
|
return false;
|
}
|
mutation.run();
|
return true;
|
}
|
|
private boolean guardedClearFinalStation(String operation, Integer taskNo, Integer stationId, Integer deviceNo,
|
Runnable mutation) {
|
if (!guardedStationClear(operation, taskNo, stationId, deviceNo)) {
|
return false;
|
}
|
mutation.run();
|
return true;
|
}
|
|
private boolean guardedArrivalState(Integer deviceNo, TaskRuntimeContext context) {
|
if (!guardedFinalArrivalState(deviceNo, context)) {
|
return false;
|
}
|
return true;
|
}
|
|
private boolean guardedCurrentStationWrite(Integer taskNo, Integer currentStationId, Integer currentDeviceNo, Integer targetStationId,
|
String operation) {
|
return guardedStationWrite(operation, taskNo, currentStationId, currentDeviceNo, targetStationId);
|
}
|
|
private boolean guardedCurrentStationClear(Integer taskNo, Integer currentStationId, Integer currentDeviceNo, String operation) {
|
return guardedStationClear(operation, taskNo, currentStationId, currentDeviceNo);
|
}
|
|
private boolean guardedFinalStationWrite(Integer taskNo, Integer stationId, Integer deviceNo, Integer targetStationId, String operation) {
|
return guardedStationWrite(operation, taskNo, stationId, deviceNo, targetStationId);
|
}
|
|
private boolean guardedFinalStationClear(Integer taskNo, Integer stationId, Integer deviceNo, String operation) {
|
return guardedStationClear(operation, taskNo, stationId, deviceNo);
|
}
|
|
private boolean guardedStationBarcodeWrite(Integer deviceNo, Integer stationId, Integer taskNo, String barcode) {
|
return guardedUpdateStationBarcode(deviceNo, stationId, taskNo, barcode);
|
}
|
|
private boolean guardedStationOccupancyWrite(Integer deviceNo, Integer stationId, Integer taskNo, Integer targetStationId,
|
Runnable mutation, String operation) {
|
if (!guardedStationWrite(operation, taskNo, stationId, deviceNo, targetStationId)) {
|
return false;
|
}
|
mutation.run();
|
return true;
|
}
|
|
private boolean guardedStationOccupancyClear(Integer deviceNo, Integer stationId, Integer taskNo,
|
Runnable mutation, String operation) {
|
if (!guardedStationClear(operation, taskNo, stationId, deviceNo)) {
|
return false;
|
}
|
mutation.run();
|
return true;
|
}
|
|
private boolean guardedStationWriteForTask(Integer deviceNo, Integer stationId, Integer taskNo, Integer targetStationId,
|
String operation) {
|
return guardedStationWrite(operation, taskNo, stationId, deviceNo, targetStationId);
|
}
|
|
private boolean guardedStationClearForTask(Integer deviceNo, Integer stationId, Integer taskNo, String operation) {
|
return guardedStationClear(operation, taskNo, stationId, deviceNo);
|
}
|
|
private boolean guardedMutateStationIfOwned(Integer deviceNo, Integer stationId, Integer taskNo, Integer targetStationId,
|
String operation, Runnable mutation) {
|
if (!guardedStationWrite(operation, taskNo, stationId, deviceNo, targetStationId)) {
|
return false;
|
}
|
mutation.run();
|
return true;
|
}
|
|
private boolean guardedClearStationIfOwned(Integer deviceNo, Integer stationId, Integer taskNo, String operation,
|
Runnable mutation) {
|
if (!guardedStationClear(operation, taskNo, stationId, deviceNo)) {
|
return false;
|
}
|
mutation.run();
|
return true;
|
}
|
|
private boolean guardedArrivalVisibility(Integer deviceNo, TaskRuntimeContext context) {
|
return guardedFinalArrivalState(deviceNo, context);
|
}
|
|
private boolean guardedFinalStationNotOverwritten(Integer deviceNo, TaskRuntimeContext context) {
|
return guardedFinalArrivalState(deviceNo, context);
|
}
|
|
private boolean guardedMutateOccupiedStation(String operation, Integer deviceNo, Integer stationId, Integer taskNo,
|
Integer targetStationId, Runnable mutation) {
|
if (!guardedStationWrite(operation, taskNo, stationId, deviceNo, targetStationId)) {
|
return false;
|
}
|
mutation.run();
|
return true;
|
}
|
|
private boolean guardedClearOccupiedStation(String operation, Integer deviceNo, Integer stationId, Integer taskNo,
|
Runnable mutation) {
|
if (!guardedStationClear(operation, taskNo, stationId, deviceNo)) {
|
return false;
|
}
|
mutation.run();
|
return true;
|
}
|
|
private boolean guardedFinalStationStillOwned(Integer deviceNo, TaskRuntimeContext context) {
|
return guardedFinalArrivalState(deviceNo, context);
|
}
|
|
private boolean guardedStateWrite(String operation, Integer deviceNo, Integer stationId, Integer taskNo, Integer targetStationId) {
|
return guardedStationWrite(operation, taskNo, stationId, deviceNo, targetStationId);
|
}
|
|
private boolean guardedStateClear(String operation, Integer deviceNo, Integer stationId, Integer taskNo) {
|
return guardedStationClear(operation, taskNo, stationId, deviceNo);
|
}
|
|
private boolean guardedArrivalOwnerCheck(Integer deviceNo, TaskRuntimeContext context) {
|
return guardedFinalArrivalState(deviceNo, context);
|
}
|
|
private boolean guardedArrivalConflict(Integer deviceNo, TaskRuntimeContext context) {
|
return stateManager.isFinalStationOwnerConflict(deviceNo, context.finalTargetStationId, context.taskNo);
|
}
|
|
private boolean guardedCurrentOwnerCheck(Integer deviceNo, Integer stationId, Integer taskNo) {
|
return !stateManager.isOccupiedByOtherLoadingTask(deviceNo, stationId, taskNo);
|
}
|
|
private boolean guardedMutateStationState(String operation, Integer deviceNo, Integer stationId, Integer taskNo,
|
Integer targetStationId, Runnable mutation) {
|
if (!guardedStationWrite(operation, taskNo, stationId, deviceNo, targetStationId)) {
|
return false;
|
}
|
mutation.run();
|
return true;
|
}
|
|
private boolean guardedClearStationState(String operation, Integer deviceNo, Integer stationId, Integer taskNo,
|
Runnable mutation) {
|
if (!guardedStationClear(operation, taskNo, stationId, deviceNo)) {
|
return false;
|
}
|
mutation.run();
|
return true;
|
}
|
|
private boolean guardedArrivalCompletionState(Integer deviceNo, TaskRuntimeContext context) {
|
return guardedFinalArrivalState(deviceNo, context);
|
}
|
|
private boolean guardedWriteToStation(String operation, Integer deviceNo, Integer stationId, Integer taskNo, Integer targetStationId) {
|
return guardedStationWrite(operation, taskNo, stationId, deviceNo, targetStationId);
|
}
|
|
private boolean guardedClearFromStation(String operation, Integer deviceNo, Integer stationId, Integer taskNo) {
|
return guardedStationClear(operation, taskNo, stationId, deviceNo);
|
}
|
|
private void handleCommand(Integer deviceNo, StationCommand command) {
|
News.info("[WCS Debug] fake 非MOVE命令进入device串行执行，deviceNo={}，stationId={}，targetStaNo={}，commandType={}，命令数据={}",
|
deviceNo, command.getStationId(), command.getTargetStaNo(), command.getCommandType(), JSON.toJSONString(command));
|
Integer taskNo = command.getTaskNo();
|
Integer stationId = command.getStationId();
|
Integer targetStationId = command.getTargetStaNo();
|
|
if (command.getCommandType() == StationCommandType.RESET) {
|
boolean reset = guardedResetStation(deviceNo, stationId, taskNo);
|
News.info("[WCS Debug] fake RESET已通过统一站点锁执行，deviceNo={}，stationId={}，accepted={}", deviceNo, stationId, reset);
|
return;
|
}
|
|
if (command.getCommandType() == StationCommandType.WRITE_INFO) {
|
if (command.getBarcode() != null) {
|
boolean updated = guardedUpdateStationBarcode(deviceNo, stationId, taskNo, command.getBarcode());
|
News.info("[WCS Debug] fake WRITE_INFO条码写入已通过统一站点锁执行，deviceNo={}，stationId={}，barcode={}，accepted={}",
|
deviceNo, stationId, command.getBarcode(), updated);
|
return;
|
}
|
if (taskNo == 9998 && targetStationId == 0) {
|
boolean generated = guardedGenerateFakeOutStationData(deviceNo, stationId, taskNo);
|
News.info("[WCS Debug] fake WRITE_INFO有物写入已通过统一站点锁执行，deviceNo={}，stationId={}，accepted={}", deviceNo, stationId, generated);
|
return;
|
}
|
}
|
|
if (taskNo != null && taskNo > 0 && taskNo != 9999 && taskNo != 9998 && stationId != null
|
&& stationId.equals(targetStationId)) {
|
boolean handedOff = guardedHandoffBarcodeStation(deviceNo, taskNo, stationId, targetStationId);
|
News.info("[WCS Debug] fake 条码站任务交接完成，deviceNo={}，stationId={}，taskNo={}，targetStationId={}，动作=barcodeTaskHandoff，accepted={}",
|
deviceNo, stationId, taskNo, targetStationId, handedOff);
|
}
|
}
|
|
private boolean checkTaskNoInArea(Integer taskNo) {
|
if (taskNo == null || redisUtil == null) {
|
return false;
|
}
|
|
Object fakeTaskNoAreaObj = redisUtil.get(RedisKeyType.FAKE_TASK_NO_AREA.key);
|
if (fakeTaskNoAreaObj == null) {
|
return false;
|
}
|
|
JSONObject data = JSON.parseObject(String.valueOf(fakeTaskNoAreaObj));
|
Integer start = data.getInteger("start");
|
Integer end = data.getInteger("end");
|
if (start == null || end == null) {
|
return false;
|
}
|
return taskNo >= start && taskNo <= end;
|
}
|
|
private Map<String, Object> buildDetails(Object... keyValues) {
|
Map<String, Object> details = new LinkedHashMap<String, Object>();
|
if (keyValues == null) {
|
return details;
|
}
|
for (int i = 0; i + 1 < keyValues.length; i += 2) {
|
Object key = keyValues[i];
|
if (key != null) {
|
details.put(String.valueOf(key), keyValues[i + 1]);
|
}
|
}
|
return details;
|
}
|
|
private void traceEvent(Integer deviceNo, TaskRuntimeContext context, String eventType, String message,
|
Map<String, Object> details, boolean terminal) {
|
if (context != null && context.deviceNo != null && deviceNo != null && !context.deviceNo.equals(deviceNo)) {
|
deviceNo = context.deviceNo;
|
}
|
if (context == null || context.taskNo == null) {
|
return;
|
}
|
Map<String, Object> safeDetails = details == null ? new LinkedHashMap<String, Object>() : new LinkedHashMap<String, Object>(details);
|
if (!safeDetails.containsKey("segmentNo") && context.segmentNo != null) {
|
safeDetails.put("segmentNo", context.segmentNo);
|
}
|
if (!safeDetails.containsKey("segmentCount") && context.segmentCount != null) {
|
safeDetails.put("segmentCount", context.segmentCount);
|
}
|
try {
|
FakeTaskTraceRegistry registry = com.core.common.SpringUtils.getBean(FakeTaskTraceRegistry.class);
|
if (registry != null) {
|
registry.record(context.taskNo, context.threadImpl != null ? context.threadImpl : stateManager.getThreadImpl(deviceNo),
|
context.status, context.startStationId, context.currentStationId, context.finalTargetStationId,
|
context.blockedStationId, context.getStitchedPathStationIds(), context.getPassedStationIds(),
|
context.getPendingStationIds(), context.getLatestAppendedPath(), eventType, message, safeDetails,
|
terminal);
|
}
|
} catch (Exception e) {
|
News.info("[WCS Debug] fake trace记录失败，taskNo={}，eventType={}，异常类型={}，异常信息={}",
|
context.taskNo, eventType, e.getClass().getSimpleName(), e.getMessage());
|
}
|
News.info("[WCS Debug] fake task event，taskNo={}，eventType={}，status={}，currentStationId={}，targetStationId={}，pending={}，details={}",
|
context.taskNo, eventType, context.status, context.currentStationId, context.finalTargetStationId,
|
context.getPendingStationIds(), JSON.toJSONString(safeDetails));
|
}
|
|
private boolean isTerminalStatus(String status) {
|
return STATUS_CANCELLED.equals(status) || STATUS_TIMEOUT.equals(status)
|
|| STATUS_FINISHED.equals(status);
|
}
|
|
private boolean isCurrentLoopGeneration(Integer taskNo, int loopGeneration) {
|
AtomicInteger generation = taskLoopGenerations.get(taskNo);
|
return generation != null && generation.get() == loopGeneration;
|
}
|
|
private Object getTaskLifecycleLock(Integer taskNo) {
|
return taskLifecycleLocks.computeIfAbsent(taskNo, key -> new Object());
|
}
|
|
/**
|
* 检查堆垛机是否已取走指定任务的货物
|
* 通过遍历所有堆垛机设备，检查是否有堆垛机正在执行该任务且已 loaded
|
*/
|
private boolean isCrnTakenByTask(Integer taskNo) {
|
if (taskNo == null || taskNo <= 0) {
|
return false;
|
}
|
try {
|
com.zy.asrs.service.BasCrnpService basCrnpService = com.core.common.SpringUtils.getBean(com.zy.asrs.service.BasCrnpService.class);
|
List<com.zy.asrs.entity.BasCrnp> basCrnps = basCrnpService.list();
|
for (com.zy.asrs.entity.BasCrnp basCrnp : basCrnps) {
|
com.zy.core.thread.CrnThread ct = (com.zy.core.thread.CrnThread) com.zy.core.cache.SlaveConnection.get(
|
com.zy.core.enums.SlaveType.Crn, basCrnp.getCrnNo());
|
if (ct == null) {
|
continue;
|
}
|
com.zy.core.model.protocol.CrnProtocol protocol = ct.getStatus();
|
if (protocol != null && taskNo.equals(protocol.getTaskNo())
|
&& protocol.getLoaded() == 1) {
|
return true;
|
}
|
}
|
} catch (Exception ignore) {
|
}
|
return false;
|
}
|
|
|
private static class MoveStepResult {
|
|
private final boolean shouldContinue;
|
private final long nextDelayMs;
|
|
private MoveStepResult(boolean shouldContinue, long nextDelayMs) {
|
this.shouldContinue = shouldContinue;
|
this.nextDelayMs = nextDelayMs;
|
}
|
|
private static MoveStepResult continueNow() {
|
return new MoveStepResult(true, 0L);
|
}
|
|
private static MoveStepResult continueAfter(long nextDelayMs) {
|
return new MoveStepResult(true, nextDelayMs);
|
}
|
|
private boolean shouldContinue() {
|
return shouldContinue;
|
}
|
|
private long getNextDelayMs() {
|
return nextDelayMs;
|
}
|
}
|
|
private static class IdleStepResult {
|
|
private final boolean finished;
|
private final long nextDelayMs;
|
|
private IdleStepResult(boolean finished, long nextDelayMs) {
|
this.finished = finished;
|
this.nextDelayMs = nextDelayMs;
|
}
|
|
private static IdleStepResult finish() {
|
return new IdleStepResult(true, 0L);
|
}
|
|
private static IdleStepResult waitNext(long nextDelayMs) {
|
return new IdleStepResult(false, nextDelayMs);
|
}
|
|
private boolean isFinished() {
|
return finished;
|
}
|
|
private long getNextDelayMs() {
|
return nextDelayMs;
|
}
|
}
|
|
private static class TaskRuntimeContext {
|
|
private final Integer taskNo;
|
private final Integer deviceNo;
|
private final String threadImpl;
|
private final LinkedBlockingQueue<Integer> pendingPathQueue = new LinkedBlockingQueue<Integer>();
|
private final List<Integer> stitchedPathStationIds = new ArrayList<Integer>();
|
private final List<Integer> passedStationIds = new ArrayList<Integer>();
|
private final List<Integer> latestAppendedPath = new ArrayList<Integer>();
|
|
private Integer startStationId;
|
private Integer currentStationId;
|
private Integer finalTargetStationId;
|
private Integer blockedStationId;
|
private boolean generateBarcode;
|
private boolean initialized;
|
private boolean arrivalHandled;
|
private Integer segmentNo;
|
private Integer segmentCount;
|
private long lastStepAt = System.currentTimeMillis();
|
private long lastCommandAt = System.currentTimeMillis();
|
private long lastProgressAt = System.currentTimeMillis();
|
private Integer lastProgressStationId;
|
private int loopGeneration;
|
private String status = STATUS_WAITING;
|
|
private TaskRuntimeContext(Integer taskNo, Integer deviceNo, String threadImpl) {
|
this.taskNo = taskNo;
|
this.deviceNo = deviceNo;
|
this.threadImpl = threadImpl;
|
}
|
|
private void setStartStationIdIfAbsent(Integer stationId) {
|
if (startStationId == null && stationId != null) {
|
startStationId = stationId;
|
}
|
}
|
|
private void appendStitchedPath(List<Integer> path) {
|
latestAppendedPath.clear();
|
if (path == null) {
|
return;
|
}
|
for (Integer stationId : path) {
|
if (stationId == null) {
|
continue;
|
}
|
latestAppendedPath.add(stationId);
|
if (stitchedPathStationIds.isEmpty()
|
|| !stationId.equals(stitchedPathStationIds.get(stitchedPathStationIds.size() - 1))) {
|
stitchedPathStationIds.add(stationId);
|
}
|
}
|
}
|
|
private void replaceLatestPath(List<Integer> path) {
|
latestAppendedPath.clear();
|
if (path == null) {
|
return;
|
}
|
for (Integer stationId : path) {
|
if (stationId != null) {
|
latestAppendedPath.add(stationId);
|
}
|
}
|
}
|
|
private void clearPendingPath() {
|
pendingPathQueue.clear();
|
latestAppendedPath.clear();
|
}
|
|
private void clearPendingPathWithLog(Integer deviceNo, Integer taskNo, Integer currentStationId,
|
Integer targetStationId, Integer blockedStationId, String reason) {
|
News.info("[WCS Debug] fake task清空待执行路径，原因={}，deviceNo={}，taskNo={}，currentStationId={}，targetStationId={}，blockedStationId={}，pendingBeforeClear={}",
|
reason, deviceNo, taskNo, currentStationId, targetStationId, blockedStationId, getPendingStationIds());
|
clearPendingPath();
|
}
|
|
private void addPassedStation(Integer stationId) {
|
if (stationId == null) {
|
return;
|
}
|
if (passedStationIds.isEmpty()
|
|| !stationId.equals(passedStationIds.get(passedStationIds.size() - 1))) {
|
passedStationIds.add(stationId);
|
}
|
}
|
|
private List<Integer> getPendingStationIds() {
|
return new ArrayList<Integer>(pendingPathQueue);
|
}
|
|
private List<Integer> getPassedStationIds() {
|
return new ArrayList<Integer>(passedStationIds);
|
}
|
|
private List<Integer> getStitchedPathStationIds() {
|
return new ArrayList<Integer>(stitchedPathStationIds);
|
}
|
|
private List<Integer> getLatestAppendedPath() {
|
return new ArrayList<Integer>(latestAppendedPath);
|
}
|
}
|
}
|
