From 6296120dadc9088e7c2318358abf4b8bdef01ad2 Mon Sep 17 00:00:00 2001
From: Junjie <fallin.jie@qq.com>
Date: 星期二, 24 三月 2026 17:02:32 +0800
Subject: [PATCH] refactor: unify station reroute execution flow
---
src/main/java/com/zy/core/utils/StationOperateProcessUtils.java | 1057 +++++++++++++++++++++++++++++++++++++++++++++++-----------
1 files changed, 853 insertions(+), 204 deletions(-)
diff --git a/src/main/java/com/zy/core/utils/StationOperateProcessUtils.java b/src/main/java/com/zy/core/utils/StationOperateProcessUtils.java
index f988dd1..c54062f 100644
--- a/src/main/java/com/zy/core/utils/StationOperateProcessUtils.java
+++ b/src/main/java/com/zy/core/utils/StationOperateProcessUtils.java
@@ -19,6 +19,8 @@
import com.zy.common.service.CommonService;
import com.zy.common.utils.NavigateUtils;
import com.zy.common.utils.RedisUtil;
+import com.zy.core.move.StationMoveCoordinator;
+import com.zy.core.move.StationMoveSession;
import com.zy.core.News;
import com.zy.core.cache.MessageQueue;
import com.zy.core.cache.SlaveConnection;
@@ -27,6 +29,7 @@
import com.zy.core.model.Task;
import com.zy.core.model.command.StationCommand;
import com.zy.core.model.protocol.StationProtocol;
+import com.zy.core.model.protocol.StationTaskBufferItem;
import com.zy.core.service.StationTaskLoopService;
import com.zy.core.thread.StationThread;
import org.springframework.beans.factory.annotation.Autowired;
@@ -38,8 +41,9 @@
public class StationOperateProcessUtils {
private static final int LOOP_LOAD_RESERVE_EXPIRE_SECONDS = 120;
private static final int OUT_ORDER_DISPATCH_LIMIT_SECONDS = 2;
+ private static final int STATION_COMMAND_DISPATCH_DEDUP_SECONDS = 10;
private static final int STATION_IDLE_RECOVER_SECONDS = 10;
- private static final int STATION_IDLE_RECOVER_LIMIT_SECONDS = 10;
+ private static final int STATION_IDLE_RECOVER_LIMIT_SECONDS = 30;
private static final int STATION_IDLE_TRACK_EXPIRE_SECONDS = 60 * 60;
private static final long STATION_MOVE_RESET_WAIT_MS = 1000L;
private static final String IDLE_RECOVER_CLEARED_MEMO = "idleRecoverRerouteCleared";
@@ -72,6 +76,8 @@
private StationTaskLoopService stationTaskLoopService;
@Autowired
private WrkAnalysisService wrkAnalysisService;
+ @Autowired
+ private StationMoveCoordinator stationMoveCoordinator;
//鎵ц杈撻�佺珯鐐瑰叆搴撲换鍔�
public synchronized void stationInExecute() {
@@ -156,7 +162,7 @@
wrkMast.setModiTime(now);
if (wrkMastService.updateById(wrkMast)) {
wrkAnalysisService.markInboundStationStart(wrkMast, now);
- MessageQueue.offer(SlaveType.Devp, basDevp.getDevpNo(), new Task(2, command));
+ offerDevpCommandWithDedup(basDevp.getDevpNo(), command, "stationInExecute");
News.info("杈撻�佺珯鐐瑰叆搴撳懡浠や笅鍙戞垚鍔燂紝绔欑偣鍙�={}锛屽伐浣滃彿={}锛屽懡浠ゆ暟鎹�={}", stationId, wrkMast.getWrkNo(), JSON.toJSONString(command));
redisUtil.set(RedisKeyType.STATION_IN_EXECUTE_LIMIT.key + stationId, "lock", 5);
loadGuardState.reserveLoopTask(loopHitResult.getLoopNo());
@@ -250,7 +256,16 @@
wrkMast.setModiTime(now);
if (wrkMastService.updateById(wrkMast)) {
wrkAnalysisService.markOutboundStationStart(wrkMast, now);
- MessageQueue.offer(SlaveType.Devp, stationObjModel.getDeviceNo(), new Task(2, command));
+ boolean offered = offerDevpCommandWithDedup(stationObjModel.getDeviceNo(), command, "crnStationOutExecute");
+ if (offered && stationMoveCoordinator != null) {
+ stationMoveCoordinator.recordDispatch(
+ wrkMast.getWrkNo(),
+ stationProtocol.getStationId(),
+ "crnStationOutExecute",
+ command,
+ false
+ );
+ }
News.info("杈撻�佺珯鐐瑰嚭搴撳懡浠や笅鍙戞垚鍔燂紝绔欑偣鍙�={}锛屽伐浣滃彿={}锛屽懡浠ゆ暟鎹�={}", stationProtocol.getStationId(), wrkMast.getWrkNo(), JSON.toJSONString(command));
redisUtil.set(RedisKeyType.STATION_OUT_EXECUTE_LIMIT.key + stationProtocol.getStationId(), "lock", 5);
redisUtil.del(RedisKeyType.CRN_OUT_TASK_COMPLETE_STATION_INFO.key + wrkMast.getWrkNo());
@@ -318,7 +333,7 @@
wrkMast.setSystemMsg("");
wrkMast.setIoTime(new Date());
if (wrkMastService.updateById(wrkMast)) {
- MessageQueue.offer(SlaveType.Devp, stationObjModel.getDeviceNo(), new Task(2, command));
+ offerDevpCommandWithDedup(stationObjModel.getDeviceNo(), command, "dualCrnStationOutExecute");
notifyUtils.notify(String.valueOf(SlaveType.Devp), stationObjModel.getDeviceNo(), String.valueOf(wrkMast.getWrkNo()), wrkMast.getWmsWrkNo(), NotifyMsgType.STATION_OUT_TASK_RUN, null);
News.info("杈撻�佺珯鐐瑰嚭搴撳懡浠や笅鍙戞垚鍔燂紝绔欑偣鍙�={}锛屽伐浣滃彿={}锛屽懡浠ゆ暟鎹�={}", stationProtocol.getStationId(), wrkMast.getWrkNo(), JSON.toJSONString(command));
redisUtil.set(RedisKeyType.STATION_OUT_EXECUTE_LIMIT.key + stationProtocol.getStationId(), "lock", 5);
@@ -370,6 +385,9 @@
if (wrkMast == null || wrkMast.getWrkNo() == null) {
return;
}
+ if (stationMoveCoordinator != null) {
+ stationMoveCoordinator.finishSession(wrkMast.getWrkNo());
+ }
Date now = new Date();
wrkMast.setWrkSts(WrkStsType.STATION_RUN_COMPLETE.sts);
wrkMast.setIoTime(now);
@@ -417,6 +435,9 @@
}
if (complete) {
+ if (stationMoveCoordinator != null) {
+ stationMoveCoordinator.finishSession(wrkNo);
+ }
wrkMast.setWrkSts(WrkStsType.COMPLETE_OUTBOUND.sts);
wrkMast.setIoTime(new Date());
wrkMastService.updateById(wrkMast);
@@ -462,123 +483,25 @@
}
redisUtil.set(RedisKeyType.CHECK_STATION_RUN_BLOCK_LIMIT_.key + stationProtocol.getTaskNo(), "lock", 15);
- if (wrkMast.getIoType() == WrkIoType.IN.id && runBlockReassignLocStationList.contains(stationProtocol.getStationId())) {
- //绔欑偣澶勪簬閲嶆柊鍒嗛厤搴撲綅鍖哄煙
- //杩愯鍫靛锛岄噸鏂扮敵璇蜂换鍔�
- String response = wmsOperateUtils.applyReassignTaskLocNo(wrkMast.getWrkNo(), stationProtocol.getStationId());
- if (Cools.isEmpty(response)) {
- News.taskError(wrkMast.getWrkNo(), "璇锋眰WMS閲嶆柊鍒嗛厤搴撲綅鎺ュ彛澶辫触锛屾帴鍙ｆ湭鍝嶅簲锛侊紒锛乺esponse锛歿}", response);
- continue;
- }
- JSONObject jsonObject = JSON.parseObject(response);
- if (jsonObject.getInteger("code").equals(200)) {
- StartupDto dto = jsonObject.getObject("data", StartupDto.class);
-
- String sourceLocNo = wrkMast.getLocNo();
- String locNo = dto.getLocNo();
-
- LocMast sourceLocMast = locMastService.queryByLoc(sourceLocNo);
- if (sourceLocMast == null) {
- News.taskInfo(wrkMast.getWrkNo(), "搴撲綅鍙�:{} 婧愬簱浣嶄俊鎭笉瀛樺湪", sourceLocNo);
- continue;
- }
-
- if (!sourceLocMast.getLocSts().equals("S")) {
- News.taskInfo(wrkMast.getWrkNo(), "搴撲綅鍙�:{} 婧愬簱浣嶇姸鎬佷笉澶勪簬鍏ュ簱棰勭害", sourceLocNo);
- continue;
- }
-
- LocMast locMast = locMastService.queryByLoc(locNo);
- if (locMast == null) {
- News.taskInfo(wrkMast.getWrkNo(), "搴撲綅鍙�:{} 鐩爣搴撲綅淇℃伅涓嶅瓨鍦�", locNo);
- continue;
- }
-
- if (!locMast.getLocSts().equals("O")) {
- News.taskInfo(wrkMast.getWrkNo(), "搴撲綅鍙�:{} 鐩爣搴撲綅鐘舵�佷笉澶勪簬绌哄簱浣�", locNo);
- continue;
- }
-
- FindCrnNoResult findCrnNoResult = commonService.findCrnNoByLocNo(locNo);
- if (findCrnNoResult == null) {
- News.taskInfo(wrkMast.getWrkNo(), "{}宸ヤ綔,鏈尮閰嶅埌鍫嗗灈鏈�", wrkMast.getWrkNo());
- continue;
- }
- Integer crnNo = findCrnNoResult.getCrnNo();
-
- Integer targetStationId = commonService.findInStationId(findCrnNoResult, stationProtocol.getStationId());
- if (targetStationId == null) {
- News.taskInfo(wrkMast.getWrkNo(), "{}绔欑偣,鎼滅储鍏ュ簱绔欑偣澶辫触", stationProtocol.getStationId());
- continue;
- }
-
- StationCommand command = stationThread.getCommand(StationCommandType.MOVE, wrkMast.getWrkNo(), stationProtocol.getStationId(), targetStationId, 0);
- if (command == null) {
- News.taskInfo(wrkMast.getWrkNo(), "{}宸ヤ綔,鑾峰彇杈撻�佺嚎鍛戒护澶辫触", wrkMast.getWrkNo());
- continue;
- }
-
- //鏇存柊婧愬簱浣�
- sourceLocMast.setLocSts("O");
- sourceLocMast.setModiTime(new Date());
- locMastService.updateById(sourceLocMast);
-
- //鏇存柊鐩爣搴撲綅
- locMast.setLocSts("S");
- locMast.setModiTime(new Date());
- locMastService.updateById(locMast);
-
- //鏇存柊宸ヤ綔妗ｆ暟鎹�
- wrkMast.setLocNo(locNo);
- wrkMast.setStaNo(targetStationId);
-
- if (findCrnNoResult.getCrnType().equals(SlaveType.Crn)) {
- wrkMast.setCrnNo(crnNo);
- } else if (findCrnNoResult.getCrnType().equals(SlaveType.DualCrn)) {
- wrkMast.setDualCrnNo(crnNo);
- } else {
- throw new CoolException("鏈煡璁惧绫诲瀷");
- }
-
- if (wrkMastService.updateById(wrkMast)) {
- MessageQueue.offer(SlaveType.Devp, basDevp.getDevpNo(), new Task(2, command));
- }
- } else {
- News.error("璇锋眰WMS鎺ュ彛澶辫触锛侊紒锛乺esponse锛歿}", response);
- }
- } else {
- //杩愯鍫靛锛岄噸鏂拌绠楄矾绾�
- Double pathLenFactor = resolveOutboundPathLenFactor(wrkMast);
- OutOrderDispatchDecision dispatchDecision = resolveOutboundDispatchDecision(
- stationProtocol.getStationId(),
- wrkMast,
- outOrderStationIds,
- pathLenFactor
- );
- Integer moveStaNo = dispatchDecision == null ? null : dispatchDecision.getTargetStationId();
- if (moveStaNo == null || Objects.equals(moveStaNo, stationProtocol.getStationId())) {
- continue;
- }
-
- StationCommand command = stationThread.getRunBlockRerouteCommand(
- wrkMast.getWrkNo(),
- stationProtocol.getStationId(),
- moveStaNo,
- 0,
- pathLenFactor
- );
- if (command == null) {
- News.taskInfo(wrkMast.getWrkNo(),
- "杈撻�佺珯鐐瑰牭濉為噸瑙勫垝鏈壘鍒板彲涓嬪彂璺嚎锛屽綋鍓嶇珯鐐�={}锛岀洰鏍囩珯鐐�={}",
- stationProtocol.getStationId(),
- moveStaNo);
- continue;
- }
-
- MessageQueue.offer(SlaveType.Devp, basDevp.getDevpNo(), new Task(2, command));
- syncOutOrderWatchState(wrkMast, stationProtocol.getStationId(), outOrderStationIds, dispatchDecision, command);
- News.info("杈撻�佺珯鐐瑰牭濉炲悗閲嶆柊璁＄畻璺緞鍛戒护涓嬪彂鎴愬姛锛岀珯鐐瑰彿={}锛屽伐浣滃彿={}锛屽懡浠ゆ暟鎹�={}", stationProtocol.getStationId(), wrkMast.getWrkNo(), JSON.toJSONString(command));
+ if (shouldUseRunBlockDirectReassign(wrkMast, stationProtocol.getStationId(), runBlockReassignLocStationList)) {
+ executeRunBlockDirectReassign(basDevp, stationThread, stationProtocol, wrkMast);
+ continue;
}
+
+ Double pathLenFactor = resolveOutboundPathLenFactor(wrkMast);
+ RerouteContext context = RerouteContext.create(
+ RerouteSceneType.RUN_BLOCK_REROUTE,
+ basDevp,
+ stationThread,
+ stationProtocol,
+ wrkMast,
+ outOrderStationIds,
+ pathLenFactor,
+ "checkStationRunBlock_reroute"
+ ).withRunBlockCommand()
+ .withCancelSessionBeforeDispatch()
+ .withResetSegmentCommandsBeforeDispatch();
+ executeSharedReroute(context);
}
}
}
@@ -675,39 +598,21 @@
continue;
}
- if (isWatchingCircleArrival(wrkMast.getWrkNo(), stationProtocol.getStationId())) {
- continue;
- }
-
Double pathLenFactor = resolveOutboundPathLenFactor(wrkMast);
- OutOrderDispatchDecision dispatchDecision = resolveOutboundDispatchDecision(
- stationProtocol.getStationId(),
+ RerouteContext context = RerouteContext.create(
+ RerouteSceneType.OUT_ORDER,
+ basDevp,
+ stationThread,
+ stationProtocol,
wrkMast,
outOrderStationIds,
- pathLenFactor
- );
- Integer moveStaNo = dispatchDecision == null ? null : dispatchDecision.getTargetStationId();
- if (moveStaNo == null || Objects.equals(moveStaNo, stationProtocol.getStationId())) {
- continue;
- }
-
- StationCommand command = buildOutboundMoveCommand(
- stationThread,
- wrkMast,
- stationProtocol.getStationId(),
- moveStaNo,
- pathLenFactor
- );
- if (command == null) {
- News.taskInfo(wrkMast.getWrkNo(), "鑾峰彇杈撻�佺嚎鍛戒护澶辫触");
- continue;
- }
- if (!tryAcquireOutOrderDispatchLock(wrkMast.getWrkNo(), stationProtocol.getStationId())) {
- continue;
- }
- syncOutOrderWatchState(wrkMast, stationProtocol.getStationId(), outOrderStationIds, dispatchDecision, command);
- MessageQueue.offer(SlaveType.Devp, stationObjModel.getDeviceNo(), new Task(2, command));
- News.info(dispatchDecision.isCircle() ? "{}浠诲姟杩涜缁曞湀" : "{}浠诲姟鐩存帴鍘荤洰鏍囩偣", wrkMast.getWrkNo());
+ pathLenFactor,
+ "checkStationOutOrder"
+ ).withDispatchDeviceNo(stationObjModel.getDeviceNo())
+ .withSuppressDispatchGuard()
+ .withOutOrderDispatchLock()
+ .withResetSegmentCommandsBeforeDispatch();
+ executeSharedReroute(context);
}
}
}
@@ -754,35 +659,20 @@
if (Objects.equals(stationProtocol.getStationId(), wrkMast.getStaNo())) {
continue;
}
-
Double pathLenFactor = resolveOutboundPathLenFactor(wrkMast);
- OutOrderDispatchDecision dispatchDecision = resolveOutboundDispatchDecision(
- stationProtocol.getStationId(),
+ RerouteContext context = RerouteContext.create(
+ RerouteSceneType.WATCH_CIRCLE,
+ basDevp,
+ stationThread,
+ stationProtocol,
wrkMast,
outOrderList,
- pathLenFactor
- );
- Integer moveStaNo = dispatchDecision == null ? null : dispatchDecision.getTargetStationId();
- if (moveStaNo == null || Objects.equals(moveStaNo, stationProtocol.getStationId())) {
- continue;
- }
-
- StationCommand command = buildOutboundMoveCommand(
- stationThread,
- wrkMast,
- stationProtocol.getStationId(),
- moveStaNo,
- pathLenFactor
- );
- if (command == null) {
- News.taskInfo(wrkMast.getWrkNo(), "鑾峰彇杈撻�佺嚎鍛戒护澶辫触");
- continue;
- }
- if (!tryAcquireOutOrderDispatchLock(wrkMast.getWrkNo(), stationProtocol.getStationId())) {
- continue;
- }
- syncOutOrderWatchState(wrkMast, stationProtocol.getStationId(), outOrderList, dispatchDecision, command);
- MessageQueue.offer(SlaveType.Devp, basDevp.getDevpNo(), new Task(2, command));
+ pathLenFactor,
+ "watchCircleStation"
+ ).withSuppressDispatchGuard()
+ .withOutOrderDispatchLock()
+ .withResetSegmentCommandsBeforeDispatch();
+ executeSharedReroute(context);
}
}
}
@@ -803,6 +693,216 @@
0,
normalizePathLenFactor(pathLenFactor)
);
+ }
+
+ RerouteCommandPlan buildRerouteCommandPlan(RerouteContext context,
+ RerouteDecision decision) {
+ if (context == null) {
+ return RerouteCommandPlan.skip("missing-context");
+ }
+ if (decision == null) {
+ return RerouteCommandPlan.skip("missing-decision");
+ }
+ if (decision.skip()) {
+ return RerouteCommandPlan.skip(decision.skipReason());
+ }
+ if (context.stationThread() == null || context.stationProtocol() == null || context.wrkMast() == null) {
+ return RerouteCommandPlan.skip("missing-runtime-dependency");
+ }
+ Integer currentStationId = context.stationProtocol().getStationId();
+ Integer targetStationId = decision.targetStationId();
+ if (currentStationId == null || targetStationId == null) {
+ return RerouteCommandPlan.skip("missing-target-station");
+ }
+ if (Objects.equals(currentStationId, targetStationId)) {
+ return RerouteCommandPlan.skip("same-station");
+ }
+
+ StationCommand command = context.useRunBlockCommand()
+ ? context.stationThread().getRunBlockRerouteCommand(
+ context.wrkMast().getWrkNo(),
+ currentStationId,
+ targetStationId,
+ 0,
+ context.pathLenFactor()
+ )
+ : buildOutboundMoveCommand(
+ context.stationThread(),
+ context.wrkMast(),
+ currentStationId,
+ targetStationId,
+ context.pathLenFactor()
+ );
+ if (command == null) {
+ if (context.sceneType() == RerouteSceneType.RUN_BLOCK_REROUTE) {
+ News.taskInfo(context.wrkMast().getWrkNo(),
+ "杈撻�佺珯鐐瑰牭濉為噸瑙勫垝鏈壘鍒板彲涓嬪彂璺嚎锛屽綋鍓嶇珯鐐�={}锛岀洰鏍囩珯鐐�={}",
+ currentStationId,
+ targetStationId);
+ } else if (context.sceneType() == RerouteSceneType.IDLE_RECOVER) {
+ News.taskInfo(context.wrkMast().getWrkNo(),
+ "绔欑偣浠诲姟鍋滅暀瓒呮椂鍚庨噸绠楄矾寰勫け璐ワ紝褰撳墠绔欑偣={}锛岀洰鏍囩珯鐐�={}",
+ currentStationId,
+ targetStationId);
+ } else {
+ News.taskInfo(context.wrkMast().getWrkNo(), "鑾峰彇杈撻�佺嚎鍛戒护澶辫触");
+ }
+ return RerouteCommandPlan.skip("missing-command");
+ }
+ return RerouteCommandPlan.dispatch(command, decision, context.dispatchScene());
+ }
+
+ RerouteExecutionResult executeReroutePlan(RerouteContext context,
+ RerouteCommandPlan plan) {
+ if (context == null) {
+ return RerouteExecutionResult.skip("missing-context");
+ }
+ if (plan == null) {
+ return RerouteExecutionResult.skip("missing-plan");
+ }
+ if (plan.skip()) {
+ return RerouteExecutionResult.skip(plan.skipReason());
+ }
+ StationProtocol stationProtocol = context.stationProtocol();
+ if (stationProtocol == null) {
+ return RerouteExecutionResult.skip("missing-station-protocol");
+ }
+ Integer taskNo = stationProtocol.getTaskNo();
+ Integer stationId = stationProtocol.getStationId();
+ if (taskNo == null || taskNo <= 0 || stationId == null) {
+ return RerouteExecutionResult.skip("invalid-station-task");
+ }
+ if (context.checkRecentDispatch()
+ && shouldSkipIdleRecoverForRecentDispatch(taskNo, stationId)) {
+ return RerouteExecutionResult.skip("recent-dispatch");
+ }
+ if (countCurrentTaskBufferCommands(stationProtocol.getTaskBufferItems(), taskNo) > 0) {
+ if (context.sceneType() == RerouteSceneType.IDLE_RECOVER) {
+ News.info("杈撻�佺珯鐐逛换鍔″仠鐣欒秴鏃讹紝浣嗙紦瀛樺尯浠嶅瓨鍦ㄥ綋鍓嶄换鍔″懡浠わ紝宸茶烦杩囬噸绠椼�傜珯鐐瑰彿={}锛屽伐浣滃彿={}锛屽綋鍓嶄换鍔″懡浠ゆ暟={}",
+ stationId,
+ taskNo,
+ countCurrentTaskBufferCommands(stationProtocol.getTaskBufferItems(), taskNo));
+ }
+ return RerouteExecutionResult.skip("buffer-has-current-task");
+ }
+ if (context.checkSuppressDispatch()
+ && stationMoveCoordinator != null
+ && stationMoveCoordinator.shouldSuppressDispatch(taskNo, stationId, plan.command())) {
+ return RerouteExecutionResult.skip("dispatch-suppressed");
+ }
+ if (context.requireOutOrderDispatchLock()
+ && !tryAcquireOutOrderDispatchLock(taskNo, stationId)) {
+ return RerouteExecutionResult.skip("out-order-lock");
+ }
+
+ if (context.cancelSessionBeforeDispatch() && stationMoveCoordinator != null) {
+ stationMoveCoordinator.cancelSession(taskNo);
+ }
+ if (!isBlank(context.executionLockKey())) {
+ Object lock = redisUtil.get(context.executionLockKey());
+ if (lock != null) {
+ return RerouteExecutionResult.skip("scene-lock");
+ }
+ redisUtil.set(context.executionLockKey(), "lock", context.executionLockSeconds());
+ }
+ if (context.resetSegmentCommandsBeforeDispatch()) {
+ resetSegmentMoveCommandsBeforeReroute(taskNo);
+ }
+
+ int clearedCommandCount = 0;
+ if (context.clearIdleIssuedCommands()) {
+ clearedCommandCount = clearIssuedMoveCommandsDuringIdleStay(context.idleTrack(), taskNo, stationId);
+ }
+
+ boolean offered = offerDevpCommandWithDedup(context.dispatchDeviceNo(), plan.command(), plan.dispatchScene());
+ if (!offered) {
+ return RerouteExecutionResult.skip("dispatch-dedup");
+ }
+
+ applyRerouteDispatchEffects(context, plan, clearedCommandCount);
+ return RerouteExecutionResult.dispatched(plan.command(), clearedCommandCount);
+ }
+
+ RerouteDecision resolveSharedRerouteDecision(RerouteContext context) {
+ if (context == null || context.wrkMast() == null || context.stationProtocol() == null) {
+ return RerouteDecision.skip("missing-runtime-dependency");
+ }
+ Integer currentStationId = context.stationProtocol().getStationId();
+ if (currentStationId == null) {
+ return RerouteDecision.skip("missing-current-station");
+ }
+
+ if (context.sceneType() == RerouteSceneType.IDLE_RECOVER
+ && !Objects.equals(context.wrkMast().getWrkSts(), WrkStsType.STATION_RUN.sts)) {
+ Integer targetStationId = context.wrkMast().getStaNo();
+ return targetStationId == null || Objects.equals(targetStationId, currentStationId)
+ ? RerouteDecision.skip("same-station")
+ : RerouteDecision.proceed(targetStationId);
+ }
+
+ OutOrderDispatchDecision dispatchDecision = resolveOutboundDispatchDecision(
+ currentStationId,
+ context.wrkMast(),
+ context.outOrderStationIds(),
+ context.pathLenFactor()
+ );
+ Integer targetStationId = dispatchDecision == null ? null : dispatchDecision.getTargetStationId();
+ if (targetStationId == null || Objects.equals(targetStationId, currentStationId)) {
+ return RerouteDecision.skip("same-station");
+ }
+ return RerouteDecision.proceed(targetStationId, dispatchDecision);
+ }
+
+ private RerouteExecutionResult executeSharedReroute(RerouteContext context) {
+ RerouteDecision decision = resolveSharedRerouteDecision(context);
+ if (decision.skip()) {
+ return RerouteExecutionResult.skip(decision.skipReason());
+ }
+ RerouteCommandPlan plan = buildRerouteCommandPlan(context, decision);
+ return executeReroutePlan(context, plan);
+ }
+
+ private void applyRerouteDispatchEffects(RerouteContext context,
+ RerouteCommandPlan plan,
+ int clearedCommandCount) {
+ if (context == null || plan == null || plan.command() == null || context.wrkMast() == null || context.stationProtocol() == null) {
+ return;
+ }
+ WrkMast wrkMast = context.wrkMast();
+ StationProtocol stationProtocol = context.stationProtocol();
+ OutOrderDispatchDecision dispatchDecision = plan.decision() == null ? null : plan.decision().dispatchDecision();
+
+ syncOutOrderWatchState(wrkMast, stationProtocol.getStationId(), context.outOrderStationIds(), dispatchDecision, plan.command());
+ if (stationMoveCoordinator != null) {
+ stationMoveCoordinator.recordDispatch(
+ wrkMast.getWrkNo(),
+ stationProtocol.getStationId(),
+ plan.dispatchScene(),
+ plan.command(),
+ dispatchDecision != null && dispatchDecision.isCircle()
+ );
+ }
+ if (context.sceneType() == RerouteSceneType.IDLE_RECOVER) {
+ saveStationTaskIdleTrack(new StationTaskIdleTrack(wrkMast.getWrkNo(), stationProtocol.getStationId(), System.currentTimeMillis()));
+ News.info("杈撻�佺珯鐐逛换鍔″仠鐣檣}绉掓湭杩愯锛屽凡閲嶆柊璁＄畻璺緞骞堕噸鍚繍琛岋紝绔欑偣鍙�={}锛岀洰鏍囩珯={}锛屽伐浣滃彿={}锛屾竻鐞嗘棫鍒嗘鍛戒护鏁�={}锛屽懡浠ゆ暟鎹�={}",
+ STATION_IDLE_RECOVER_SECONDS,
+ stationProtocol.getStationId(),
+ plan.command().getTargetStaNo(),
+ wrkMast.getWrkNo(),
+ clearedCommandCount,
+ JSON.toJSONString(plan.command()));
+ return;
+ }
+ if (context.sceneType() == RerouteSceneType.RUN_BLOCK_REROUTE) {
+ News.info("杈撻�佺珯鐐瑰牭濉炲悗閲嶆柊璁＄畻璺緞鍛戒护涓嬪彂鎴愬姛锛岀珯鐐瑰彿={}锛屽伐浣滃彿={}锛屽懡浠ゆ暟鎹�={}",
+ stationProtocol.getStationId(),
+ wrkMast.getWrkNo(),
+ JSON.toJSONString(plan.command()));
+ return;
+ }
+ if (context.sceneType() == RerouteSceneType.OUT_ORDER) {
+ News.info(dispatchDecision != null && dispatchDecision.isCircle() ? "{}浠诲姟杩涜缁曞湀" : "{}浠诲姟鐩存帴鍘荤洰鏍囩偣", wrkMast.getWrkNo());
+ }
}
private List<NavigateNode> calcOutboundNavigatePath(WrkMast wrkMast,
@@ -1253,8 +1353,39 @@
}
private boolean isWatchingCircleArrival(Integer wrkNo, Integer stationId) {
+ if (stationMoveCoordinator != null) {
+ StationMoveSession session = stationMoveCoordinator.loadSession(wrkNo);
+ if (session != null && session.isActive() && stationId != null) {
+ if (stationId.equals(session.getNextDecisionStationId())) {
+ return true;
+ }
+ if (session.containsStation(stationId)) {
+ return false;
+ }
+ }
+ }
StationCommand command = getWatchCircleCommand(wrkNo);
return command != null && stationId != null && stationId.equals(command.getTargetStaNo());
+ }
+
+ private boolean isWatchingCircleTransit(Integer wrkNo, Integer stationId) {
+ if (stationMoveCoordinator != null) {
+ StationMoveSession session = stationMoveCoordinator.loadSession(wrkNo);
+ if (session != null && session.isActive() && stationId != null) {
+ if (stationId.equals(session.getNextDecisionStationId())) {
+ return false;
+ }
+ if (session.containsStation(stationId)) {
+ return true;
+ }
+ }
+ }
+ StationCommand command = getWatchCircleCommand(wrkNo);
+ if (command == null || stationId == null || Objects.equals(stationId, command.getTargetStaNo())) {
+ return false;
+ }
+ List<Integer> navigatePath = command.getNavigatePath();
+ return navigatePath != null && navigatePath.contains(stationId);
}
private StationCommand getWatchCircleCommand(Integer wrkNo) {
@@ -1299,6 +1430,9 @@
}
StationTaskIdleTrack idleTrack = touchStationTaskIdleTrack(stationProtocol.getTaskNo(), stationProtocol.getStationId());
+ if (shouldSkipIdleRecoverForRecentDispatch(stationProtocol.getTaskNo(), stationProtocol.getStationId())) {
+ return;
+ }
if (idleTrack == null || !idleTrack.isTimeout(STATION_IDLE_RECOVER_SECONDS)) {
return;
}
@@ -1312,41 +1446,143 @@
if (lock != null) {
return;
}
-
Double pathLenFactor = resolveOutboundPathLenFactor(wrkMast);
- OutOrderDispatchDecision dispatchDecision = null;
- Integer moveStaNo;
- if (Objects.equals(wrkMast.getWrkSts(), WrkStsType.STATION_RUN.sts)) {
- dispatchDecision = resolveOutboundDispatchDecision(stationProtocol.getStationId(), wrkMast, outOrderList, pathLenFactor);
- moveStaNo = dispatchDecision == null ? null : dispatchDecision.getTargetStationId();
- } else {
- moveStaNo = wrkMast.getStaNo();
- }
- if (moveStaNo == null || Objects.equals(moveStaNo, stationProtocol.getStationId())) {
- return;
- }
-
- redisUtil.set(RedisKeyType.CHECK_STATION_IDLE_RECOVER_LIMIT_.key + stationProtocol.getTaskNo(), "lock", STATION_IDLE_RECOVER_LIMIT_SECONDS);
- resetSegmentMoveCommandsBeforeReroute(stationProtocol.getTaskNo());
- int clearedCommandCount = clearIssuedMoveCommandsDuringIdleStay(idleTrack, stationProtocol.getTaskNo(), stationProtocol.getStationId());
-
- StationCommand command = buildOutboundMoveCommand(
+ RerouteContext context = RerouteContext.create(
+ RerouteSceneType.IDLE_RECOVER,
+ basDevp,
stationThread,
+ stationProtocol,
wrkMast,
- stationProtocol.getStationId(),
- moveStaNo,
- pathLenFactor
+ outOrderList,
+ pathLenFactor,
+ "checkStationIdleRecover"
+ ).withCancelSessionBeforeDispatch()
+ .withExecutionLock(RedisKeyType.CHECK_STATION_IDLE_RECOVER_LIMIT_.key + stationProtocol.getTaskNo(), STATION_IDLE_RECOVER_LIMIT_SECONDS)
+ .withResetSegmentCommandsBeforeDispatch()
+ .clearIdleIssuedCommands(idleTrack);
+ executeSharedReroute(context);
+ }
+
+ boolean shouldUseRunBlockDirectReassign(WrkMast wrkMast,
+ Integer stationId,
+ List<Integer> runBlockReassignLocStationList) {
+ return wrkMast != null
+ && Objects.equals(wrkMast.getIoType(), WrkIoType.IN.id)
+ && stationId != null
+ && runBlockReassignLocStationList != null
+ && runBlockReassignLocStationList.contains(stationId);
+ }
+
+ private void executeRunBlockDirectReassign(BasDevp basDevp,
+ StationThread stationThread,
+ StationProtocol stationProtocol,
+ WrkMast wrkMast) {
+ if (basDevp == null || stationThread == null || stationProtocol == null || wrkMast == null) {
+ return;
+ }
+ int currentTaskBufferCommandCount = countCurrentTaskBufferCommands(
+ stationProtocol.getTaskBufferItems(),
+ stationProtocol.getTaskNo()
);
- if (command == null) {
- News.taskInfo(wrkMast.getWrkNo(), "绔欑偣浠诲姟鍋滅暀瓒呮椂鍚庨噸绠楄矾寰勫け璐ワ紝褰撳墠绔欑偣={}锛岀洰鏍囩珯鐐�={}", stationProtocol.getStationId(), moveStaNo);
+ if (currentTaskBufferCommandCount > 0) {
+ News.info("杈撻�佺珯鐐硅繍琛屽牭濉為噸鍒嗛厤宸茶烦杩囷紝缂撳瓨鍖轰粛瀛樺湪褰撳墠浠诲姟鍛戒护銆傜珯鐐瑰彿={}锛屽伐浣滃彿={}锛屽綋鍓嶄换鍔″懡浠ゆ暟={}",
+ stationProtocol.getStationId(),
+ stationProtocol.getTaskNo(),
+ currentTaskBufferCommandCount);
+ return;
+ }
+ if (stationMoveCoordinator != null) {
+ stationMoveCoordinator.cancelSession(wrkMast.getWrkNo());
+ }
+ String response = wmsOperateUtils.applyReassignTaskLocNo(wrkMast.getWrkNo(), stationProtocol.getStationId());
+ if (Cools.isEmpty(response)) {
+ News.taskError(wrkMast.getWrkNo(), "璇锋眰WMS閲嶆柊鍒嗛厤搴撲綅鎺ュ彛澶辫触锛屾帴鍙ｆ湭鍝嶅簲锛侊紒锛乺esponse锛歿}", response);
+ return;
+ }
+ JSONObject jsonObject = JSON.parseObject(response);
+ if (!jsonObject.getInteger("code").equals(200)) {
+ News.error("璇锋眰WMS鎺ュ彛澶辫触锛侊紒锛乺esponse锛歿}", response);
return;
}
- MessageQueue.offer(SlaveType.Devp, basDevp.getDevpNo(), new Task(2, command));
- syncOutOrderWatchState(wrkMast, stationProtocol.getStationId(), outOrderList, dispatchDecision, command);
- saveStationTaskIdleTrack(new StationTaskIdleTrack(wrkMast.getWrkNo(), stationProtocol.getStationId(), System.currentTimeMillis()));
- News.info("杈撻�佺珯鐐逛换鍔″仠鐣檣}绉掓湭杩愯锛屽凡閲嶆柊璁＄畻璺緞骞堕噸鍚繍琛岋紝绔欑偣鍙�={}锛岀洰鏍囩珯={}锛屽伐浣滃彿={}锛屾竻鐞嗘棫鍒嗘鍛戒护鏁�={}锛屽懡浠ゆ暟鎹�={}",
- STATION_IDLE_RECOVER_SECONDS, stationProtocol.getStationId(), moveStaNo, wrkMast.getWrkNo(), clearedCommandCount, JSON.toJSONString(command));
+ StartupDto dto = jsonObject.getObject("data", StartupDto.class);
+ String sourceLocNo = wrkMast.getLocNo();
+ String locNo = dto.getLocNo();
+
+ LocMast sourceLocMast = locMastService.queryByLoc(sourceLocNo);
+ if (sourceLocMast == null) {
+ News.taskInfo(wrkMast.getWrkNo(), "搴撲綅鍙�:{} 婧愬簱浣嶄俊鎭笉瀛樺湪", sourceLocNo);
+ return;
+ }
+ if (!sourceLocMast.getLocSts().equals("S")) {
+ News.taskInfo(wrkMast.getWrkNo(), "搴撲綅鍙�:{} 婧愬簱浣嶇姸鎬佷笉澶勪簬鍏ュ簱棰勭害", sourceLocNo);
+ return;
+ }
+
+ LocMast locMast = locMastService.queryByLoc(locNo);
+ if (locMast == null) {
+ News.taskInfo(wrkMast.getWrkNo(), "搴撲綅鍙�:{} 鐩爣搴撲綅淇℃伅涓嶅瓨鍦�", locNo);
+ return;
+ }
+ if (!locMast.getLocSts().equals("O")) {
+ News.taskInfo(wrkMast.getWrkNo(), "搴撲綅鍙�:{} 鐩爣搴撲綅鐘舵�佷笉澶勪簬绌哄簱浣�", locNo);
+ return;
+ }
+
+ FindCrnNoResult findCrnNoResult = commonService.findCrnNoByLocNo(locNo);
+ if (findCrnNoResult == null) {
+ News.taskInfo(wrkMast.getWrkNo(), "{}宸ヤ綔,鏈尮閰嶅埌鍫嗗灈鏈�", wrkMast.getWrkNo());
+ return;
+ }
+ Integer crnNo = findCrnNoResult.getCrnNo();
+
+ Integer targetStationId = commonService.findInStationId(findCrnNoResult, stationProtocol.getStationId());
+ if (targetStationId == null) {
+ News.taskInfo(wrkMast.getWrkNo(), "{}绔欑偣,鎼滅储鍏ュ簱绔欑偣澶辫触", stationProtocol.getStationId());
+ return;
+ }
+
+ StationCommand command = stationThread.getCommand(StationCommandType.MOVE, wrkMast.getWrkNo(), stationProtocol.getStationId(), targetStationId, 0);
+ if (command == null) {
+ News.taskInfo(wrkMast.getWrkNo(), "{}宸ヤ綔,鑾峰彇杈撻�佺嚎鍛戒护澶辫触", wrkMast.getWrkNo());
+ return;
+ }
+
+ sourceLocMast.setLocSts("O");
+ sourceLocMast.setModiTime(new Date());
+ locMastService.updateById(sourceLocMast);
+
+ locMast.setLocSts("S");
+ locMast.setModiTime(new Date());
+ locMastService.updateById(locMast);
+
+ wrkMast.setLocNo(locNo);
+ wrkMast.setStaNo(targetStationId);
+
+ if (findCrnNoResult.getCrnType().equals(SlaveType.Crn)) {
+ wrkMast.setCrnNo(crnNo);
+ } else if (findCrnNoResult.getCrnType().equals(SlaveType.DualCrn)) {
+ wrkMast.setDualCrnNo(crnNo);
+ } else {
+ throw new CoolException("鏈煡璁惧绫诲瀷");
+ }
+
+ if (!wrkMastService.updateById(wrkMast)) {
+ return;
+ }
+ boolean offered = offerDevpCommandWithDedup(basDevp.getDevpNo(), command, "checkStationRunBlock_direct");
+ if (!offered) {
+ return;
+ }
+ if (stationMoveCoordinator != null) {
+ stationMoveCoordinator.recordDispatch(
+ wrkMast.getWrkNo(),
+ stationProtocol.getStationId(),
+ "checkStationRunBlock_direct",
+ command,
+ false
+ );
+ }
}
private boolean canRecoverIdleStationTask(WrkMast wrkMast, Integer currentStationId) {
@@ -1358,6 +1594,29 @@
}
return Objects.equals(wrkMast.getWrkSts(), WrkStsType.INBOUND_STATION_RUN.sts)
|| Objects.equals(wrkMast.getWrkSts(), WrkStsType.STATION_RUN.sts);
+ }
+
+ private boolean shouldSkipIdleRecoverForRecentDispatch(Integer taskNo, Integer stationId) {
+ if (stationMoveCoordinator == null || taskNo == null || taskNo <= 0 || stationId == null) {
+ return false;
+ }
+ StationMoveSession session = stationMoveCoordinator.loadSession(taskNo);
+ if (session == null || !session.isActive() || session.getLastIssuedAt() == null) {
+ return false;
+ }
+ if (!Objects.equals(stationId, session.getCurrentStationId())
+ && !Objects.equals(stationId, session.getDispatchStationId())) {
+ return false;
+ }
+ long elapsedMs = System.currentTimeMillis() - session.getLastIssuedAt();
+ long thresholdMs = STATION_IDLE_RECOVER_SECONDS * 1000L;
+ if (elapsedMs >= thresholdMs) {
+ return false;
+ }
+ saveStationTaskIdleTrack(new StationTaskIdleTrack(taskNo, stationId, System.currentTimeMillis()));
+ News.info("杈撻�佺珯鐐逛换鍔″垰瀹屾垚鍛戒护涓嬪彂锛屽凡璺宠繃鍋滅暀閲嶇畻銆傜珯鐐瑰彿={}锛屽伐浣滃彿={}锛岃窛涓婃涓嬪彂={}ms锛宺outeVersion={}",
+ stationId, taskNo, elapsedMs, session.getRouteVersion());
+ return true;
}
private void resetSegmentMoveCommandsBeforeReroute(Integer taskNo) {
@@ -1373,6 +1632,69 @@
} catch (Exception ignore) {
}
redisUtil.del(key);
+ }
+
+ private int countCurrentTaskBufferCommands(List<StationTaskBufferItem> taskBufferItems, Integer currentTaskNo) {
+ if (taskBufferItems == null || taskBufferItems.isEmpty() || currentTaskNo == null || currentTaskNo <= 0) {
+ return 0;
+ }
+ int count = 0;
+ for (StationTaskBufferItem item : taskBufferItems) {
+ if (item == null || item.getTaskNo() == null) {
+ continue;
+ }
+ if (currentTaskNo.equals(item.getTaskNo())) {
+ count++;
+ }
+ }
+ return count;
+ }
+
+ private boolean offerDevpCommandWithDedup(Integer deviceNo, StationCommand command, String scene) {
+ if (deviceNo == null || command == null) {
+ return false;
+ }
+ String dedupKey = buildStationCommandDispatchDedupKey(deviceNo, command);
+ if (redisUtil != null) {
+ Object lock = redisUtil.get(dedupKey);
+ if (lock != null) {
+ News.info("杈撻�佺珯鐐瑰懡浠ょ煭鏃堕噸澶嶆淳鍙戯紝宸茶烦杩囥�俿cene={}锛宒eviceNo={}锛宼askNo={}锛宻tationId={}锛宼argetStaNo={}锛宑ommandType={}",
+ scene,
+ deviceNo,
+ command.getTaskNo(),
+ command.getStationId(),
+ command.getTargetStaNo(),
+ command.getCommandType());
+ return false;
+ }
+ redisUtil.set(dedupKey, "lock", STATION_COMMAND_DISPATCH_DEDUP_SECONDS);
+ }
+ boolean offered = MessageQueue.offer(SlaveType.Devp, deviceNo, new Task(2, command));
+ if (!offered && redisUtil != null) {
+ redisUtil.del(dedupKey);
+ }
+ return offered;
+ }
+
+ private String buildStationCommandDispatchDedupKey(Integer deviceNo, StationCommand command) {
+ return RedisKeyType.STATION_COMMAND_DISPATCH_DEDUP_.key
+ + deviceNo + "_"
+ + command.getTaskNo() + "_"
+ + command.getStationId() + "_"
+ + (stationMoveCoordinator == null ? Integer.toHexString(buildFallbackPathSignature(command).hashCode())
+ : stationMoveCoordinator.buildPathSignatureHash(command));
+ }
+
+ private String buildFallbackPathSignature(StationCommand command) {
+ if (command == null) {
+ return "";
+ }
+ return String.valueOf(command.getCommandType())
+ + "_" + command.getStationId()
+ + "_" + command.getTargetStaNo()
+ + "_" + command.getNavigatePath()
+ + "_" + command.getLiftTransferPath()
+ + "_" + command.getOriginalNavigatePath();
}
private int clearIssuedMoveCommandsDuringIdleStay(StationTaskIdleTrack idleTrack,
@@ -1690,6 +2012,333 @@
return pathLenFactor;
}
+ enum RerouteSceneType {
+ RUN_BLOCK_REROUTE,
+ IDLE_RECOVER,
+ OUT_ORDER,
+ WATCH_CIRCLE
+ }
+
+ static final class RerouteDecision {
+ private final boolean skip;
+ private final String skipReason;
+ private final Integer targetStationId;
+ private final OutOrderDispatchDecision dispatchDecision;
+
+ private RerouteDecision(boolean skip,
+ String skipReason,
+ Integer targetStationId,
+ OutOrderDispatchDecision dispatchDecision) {
+ this.skip = skip;
+ this.skipReason = skipReason;
+ this.targetStationId = targetStationId;
+ this.dispatchDecision = dispatchDecision;
+ }
+
+ static RerouteDecision skip(String reason) {
+ return new RerouteDecision(true, reason, null, null);
+ }
+
+ static RerouteDecision proceed(Integer targetStationId) {
+ return new RerouteDecision(false, null, targetStationId, null);
+ }
+
+ static RerouteDecision proceed(Integer targetStationId,
+ OutOrderDispatchDecision dispatchDecision) {
+ return new RerouteDecision(false, null, targetStationId, dispatchDecision);
+ }
+
+ boolean skip() {
+ return skip;
+ }
+
+ String skipReason() {
+ return skipReason;
+ }
+
+ Integer targetStationId() {
+ return targetStationId;
+ }
+
+ OutOrderDispatchDecision dispatchDecision() {
+ return dispatchDecision;
+ }
+ }
+
+ static final class RerouteContext {
+ private final RerouteSceneType sceneType;
+ private final BasDevp basDevp;
+ private final StationThread stationThread;
+ private final StationProtocol stationProtocol;
+ private final WrkMast wrkMast;
+ private final List<Integer> outOrderStationIds;
+ private final Double pathLenFactor;
+ private final String dispatchScene;
+ private Integer dispatchDeviceNo;
+ private boolean useRunBlockCommand;
+ private boolean checkSuppressDispatch;
+ private boolean requireOutOrderDispatchLock;
+ private boolean cancelSessionBeforeDispatch;
+ private boolean resetSegmentCommandsBeforeDispatch;
+ private boolean clearIdleIssuedCommands;
+ private boolean checkRecentDispatch;
+ private String executionLockKey;
+ private int executionLockSeconds;
+ private StationTaskIdleTrack idleTrack;
+
+ private RerouteContext(RerouteSceneType sceneType,
+ BasDevp basDevp,
+ StationThread stationThread,
+ StationProtocol stationProtocol,
+ WrkMast wrkMast,
+ List<Integer> outOrderStationIds,
+ Double pathLenFactor,
+ String dispatchScene) {
+ this.sceneType = sceneType;
+ this.basDevp = basDevp;
+ this.stationThread = stationThread;
+ this.stationProtocol = stationProtocol;
+ this.wrkMast = wrkMast;
+ this.outOrderStationIds = outOrderStationIds == null ? Collections.emptyList() : outOrderStationIds;
+ this.pathLenFactor = pathLenFactor;
+ this.dispatchScene = dispatchScene;
+ this.dispatchDeviceNo = basDevp == null ? null : basDevp.getDevpNo();
+ }
+
+ static RerouteContext create(RerouteSceneType sceneType,
+ BasDevp basDevp,
+ StationThread stationThread,
+ StationProtocol stationProtocol,
+ WrkMast wrkMast,
+ List<Integer> outOrderStationIds,
+ Double pathLenFactor,
+ String dispatchScene) {
+ return new RerouteContext(sceneType, basDevp, stationThread, stationProtocol, wrkMast, outOrderStationIds, pathLenFactor, dispatchScene);
+ }
+
+ RerouteContext withDispatchDeviceNo(Integer dispatchDeviceNo) {
+ this.dispatchDeviceNo = dispatchDeviceNo;
+ return this;
+ }
+
+ RerouteContext withRunBlockCommand() {
+ this.useRunBlockCommand = true;
+ return this;
+ }
+
+ RerouteContext withSuppressDispatchGuard() {
+ this.checkSuppressDispatch = true;
+ return this;
+ }
+
+ RerouteContext withOutOrderDispatchLock() {
+ this.requireOutOrderDispatchLock = true;
+ return this;
+ }
+
+ RerouteContext withCancelSessionBeforeDispatch() {
+ this.cancelSessionBeforeDispatch = true;
+ return this;
+ }
+
+ RerouteContext withResetSegmentCommandsBeforeDispatch() {
+ this.resetSegmentCommandsBeforeDispatch = true;
+ return this;
+ }
+
+ RerouteContext clearIdleIssuedCommands(StationTaskIdleTrack idleTrack) {
+ this.clearIdleIssuedCommands = true;
+ this.idleTrack = idleTrack;
+ return this;
+ }
+
+ RerouteContext withRecentDispatchGuard() {
+ this.checkRecentDispatch = true;
+ return this;
+ }
+
+ RerouteContext withExecutionLock(String executionLockKey, int executionLockSeconds) {
+ this.executionLockKey = executionLockKey;
+ this.executionLockSeconds = executionLockSeconds;
+ return this;
+ }
+
+ RerouteSceneType sceneType() {
+ return sceneType;
+ }
+
+ BasDevp basDevp() {
+ return basDevp;
+ }
+
+ StationThread stationThread() {
+ return stationThread;
+ }
+
+ StationProtocol stationProtocol() {
+ return stationProtocol;
+ }
+
+ WrkMast wrkMast() {
+ return wrkMast;
+ }
+
+ List<Integer> outOrderStationIds() {
+ return outOrderStationIds;
+ }
+
+ Double pathLenFactor() {
+ return pathLenFactor;
+ }
+
+ String dispatchScene() {
+ return dispatchScene;
+ }
+
+ Integer dispatchDeviceNo() {
+ return dispatchDeviceNo;
+ }
+
+ boolean useRunBlockCommand() {
+ return useRunBlockCommand;
+ }
+
+ boolean checkSuppressDispatch() {
+ return checkSuppressDispatch;
+ }
+
+ boolean requireOutOrderDispatchLock() {
+ return requireOutOrderDispatchLock;
+ }
+
+ boolean cancelSessionBeforeDispatch() {
+ return cancelSessionBeforeDispatch;
+ }
+
+ boolean resetSegmentCommandsBeforeDispatch() {
+ return resetSegmentCommandsBeforeDispatch;
+ }
+
+ boolean clearIdleIssuedCommands() {
+ return clearIdleIssuedCommands;
+ }
+
+ boolean checkRecentDispatch() {
+ return checkRecentDispatch;
+ }
+
+ String executionLockKey() {
+ return executionLockKey;
+ }
+
+ int executionLockSeconds() {
+ return executionLockSeconds;
+ }
+
+ StationTaskIdleTrack idleTrack() {
+ return idleTrack;
+ }
+ }
+
+ static final class RerouteCommandPlan {
+ private final boolean skip;
+ private final String skipReason;
+ private final StationCommand command;
+ private final RerouteDecision decision;
+ private final String dispatchScene;
+
+ private RerouteCommandPlan(boolean skip,
+ String skipReason,
+ StationCommand command,
+ RerouteDecision decision,
+ String dispatchScene) {
+ this.skip = skip;
+ this.skipReason = skipReason;
+ this.command = command;
+ this.decision = decision;
+ this.dispatchScene = dispatchScene;
+ }
+
+ static RerouteCommandPlan skip(String reason) {
+ return new RerouteCommandPlan(true, reason, null, null, null);
+ }
+
+ static RerouteCommandPlan dispatch(StationCommand command,
+ RerouteDecision decision,
+ String dispatchScene) {
+ return new RerouteCommandPlan(false, null, command, decision, dispatchScene);
+ }
+
+ boolean skip() {
+ return skip;
+ }
+
+ String skipReason() {
+ return skipReason;
+ }
+
+ StationCommand command() {
+ return command;
+ }
+
+ RerouteDecision decision() {
+ return decision;
+ }
+
+ String dispatchScene() {
+ return dispatchScene;
+ }
+ }
+
+ static final class RerouteExecutionResult {
+ private final boolean skipped;
+ private final String skipReason;
+ private final boolean dispatched;
+ private final StationCommand command;
+ private final int clearedCommandCount;
+
+ private RerouteExecutionResult(boolean skipped,
+ String skipReason,
+ boolean dispatched,
+ StationCommand command,
+ int clearedCommandCount) {
+ this.skipped = skipped;
+ this.skipReason = skipReason;
+ this.dispatched = dispatched;
+ this.command = command;
+ this.clearedCommandCount = clearedCommandCount;
+ }
+
+ static RerouteExecutionResult skip(String reason) {
+ return new RerouteExecutionResult(true, reason, false, null, 0);
+ }
+
+ static RerouteExecutionResult dispatched(StationCommand command,
+ int clearedCommandCount) {
+ return new RerouteExecutionResult(false, null, true, command, clearedCommandCount);
+ }
+
+ boolean skipped() {
+ return skipped;
+ }
+
+ String skipReason() {
+ return skipReason;
+ }
+
+ boolean dispatched() {
+ return dispatched;
+ }
+
+ StationCommand command() {
+ return command;
+ }
+
+ int clearedCommandCount() {
+ return clearedCommandCount;
+ }
+ }
+
private static class OutOrderDispatchDecision {
private final Integer targetStationId;
private final boolean circle;
--
Gitblit v1.9.1