From 21842952d812db640235becb88de527c17335f58 Mon Sep 17 00:00:00 2001
From: Junjie <fallin.jie@qq.com>
Date: 星期二, 31 三月 2026 18:04:30 +0800
Subject: [PATCH] #
---
src/main/java/com/zy/core/utils/StationOperateProcessUtils.java | 2187 +----------------------------------------------------------
1 files changed, 40 insertions(+), 2,147 deletions(-)
diff --git a/src/main/java/com/zy/core/utils/StationOperateProcessUtils.java b/src/main/java/com/zy/core/utils/StationOperateProcessUtils.java
index 40e4e19..85dc30d 100644
--- a/src/main/java/com/zy/core/utils/StationOperateProcessUtils.java
+++ b/src/main/java/com/zy/core/utils/StationOperateProcessUtils.java
@@ -1,688 +1,74 @@
package com.zy.core.utils;
-import com.alibaba.fastjson.JSON;
-import com.alibaba.fastjson.JSONObject;
-import com.alibaba.fastjson.serializer.SerializerFeature;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
-import com.core.common.Cools;
-import com.core.exception.CoolException;
-import com.zy.asrs.domain.enums.NotifyMsgType;
-import com.zy.asrs.domain.path.StationPathResolvedPolicy;
-import com.zy.asrs.domain.vo.StationCycleCapacityVo;
-import com.zy.asrs.domain.vo.StationCycleLoopVo;
-import com.zy.asrs.entity.*;
-import com.zy.asrs.service.*;
-import com.zy.asrs.utils.NotifyUtils;
-import com.zy.common.entity.FindCrnNoResult;
-import com.zy.common.model.NavigateNode;
-import com.zy.common.model.StartupDto;
-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;
-import com.zy.core.enums.*;
-import com.zy.core.model.StationObjModel;
-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 com.zy.asrs.entity.WrkMast;
+import com.zy.asrs.service.WrkMastService;
+import com.zy.core.enums.WrkIoType;
+import com.zy.core.enums.WrkStsType;
+import com.zy.core.utils.station.StationDispatchLoadSupport;
+import com.zy.core.utils.station.StationOutboundDispatchProcessor;
+import com.zy.core.utils.station.StationRegularDispatchProcessor;
+import com.zy.core.utils.station.StationRerouteProcessor;
+import com.zy.core.utils.station.model.RerouteCommandPlan;
+import com.zy.core.utils.station.model.RerouteContext;
+import com.zy.core.utils.station.model.RerouteDecision;
+import com.zy.core.utils.station.model.RerouteExecutionResult;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
-import java.util.*;
+import java.util.List;
@Component
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 = 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";
-
- @Autowired
- private BasDevpService basDevpService;
@Autowired
private WrkMastService wrkMastService;
@Autowired
- private CommonService commonService;
+ private StationRegularDispatchProcessor stationRegularDispatchProcessor;
@Autowired
- private RedisUtil redisUtil;
+ private StationDispatchLoadSupport stationDispatchLoadSupport;
@Autowired
- private LocMastService locMastService;
+ private StationOutboundDispatchProcessor stationOutboundDispatchProcessor;
@Autowired
- private WmsOperateUtils wmsOperateUtils;
- @Autowired
- private NotifyUtils notifyUtils;
- @Autowired
- private NavigateUtils navigateUtils;
- @Autowired
- private BasStationService basStationService;
- @Autowired
- private StationCycleCapacityService stationCycleCapacityService;
- @Autowired
- private StationPathPolicyService stationPathPolicyService;
- @Autowired
- private BasStationOptService basStationOptService;
- @Autowired
- private StationTaskLoopService stationTaskLoopService;
- @Autowired
- private WrkAnalysisService wrkAnalysisService;
- @Autowired
- private StationMoveCoordinator stationMoveCoordinator;
+ private StationRerouteProcessor stationRerouteProcessor;
//鎵ц杈撻�佺珯鐐瑰叆搴撲换鍔�
public synchronized void stationInExecute() {
- try {
- DispatchLimitConfig baseLimitConfig = getDispatchLimitConfig(null, null);
- int[] currentStationTaskCountRef = new int[]{countCurrentStationTask()};
- LoadGuardState loadGuardState = buildLoadGuardState(baseLimitConfig);
-
- List<BasDevp> basDevps = basDevpService.list(new QueryWrapper<>());
- for (BasDevp basDevp : basDevps) {
- StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basDevp.getDevpNo());
- if (stationThread == null) {
- continue;
- }
-
- Map<Integer, StationProtocol> stationMap = stationThread.getStatusMap();
-
- List<StationObjModel> list = basDevp.getBarcodeStationList$();
- for (StationObjModel entity : list) {
- Integer stationId = entity.getStationId();
- if (!stationMap.containsKey(stationId)) {
- continue;
- }
-
- StationProtocol stationProtocol = stationMap.get(stationId);
- if (stationProtocol == null) {
- continue;
- }
-
- Object lock = redisUtil.get(RedisKeyType.STATION_IN_EXECUTE_LIMIT.key + stationId);
- if (lock != null) {
- continue;
- }
-
- //婊¤冻鑷姩銆佹湁鐗┿�佹湁宸ヤ綔鍙�
- if (stationProtocol.isAutoing()
- && stationProtocol.isLoading()
- && stationProtocol.getTaskNo() > 0
- ) {
- //妫�娴嬩换鍔℃槸鍚︾敓鎴�
- WrkMast wrkMast = wrkMastService.getOne(new QueryWrapper<WrkMast>().eq("barcode", stationProtocol.getBarcode()));
- if (wrkMast == null) {
- continue;
- }
-
- if (!Objects.equals(wrkMast.getWrkSts(), WrkStsType.NEW_INBOUND.sts)) {
- continue;
- }
-
- String locNo = wrkMast.getLocNo();
- FindCrnNoResult findCrnNoResult = commonService.findCrnNoByLocNo(locNo);
- if (findCrnNoResult == null) {
- News.taskInfo(wrkMast.getWrkNo(), "{}宸ヤ綔,鏈尮閰嶅埌鍫嗗灈鏈�", wrkMast.getWrkNo());
- continue;
- }
-
- Integer targetStationId = commonService.findInStationId(findCrnNoResult, stationId);
- if (targetStationId == null) {
- News.taskInfo(wrkMast.getWrkNo(), "{}绔欑偣,鎼滅储鍏ュ簱绔欑偣澶辫触", stationId);
- continue;
- }
-
- DispatchLimitConfig limitConfig = getDispatchLimitConfig(stationProtocol.getStationId(), targetStationId);
- LoopHitResult loopHitResult = findPathLoopHit(limitConfig, stationProtocol.getStationId(), targetStationId, loadGuardState);
-
- if (isDispatchBlocked(limitConfig, currentStationTaskCountRef[0], loadGuardState, loopHitResult.isThroughLoop())) {
- return;
- }
-
- StationCommand command = stationThread.getCommand(StationCommandType.MOVE, wrkMast.getWrkNo(), stationId, targetStationId, 0);
- if (command == null) {
- News.taskInfo(wrkMast.getWrkNo(), "{}宸ヤ綔,鑾峰彇杈撻�佺嚎鍛戒护澶辫触", wrkMast.getWrkNo());
- continue;
- }
-
- Date now = new Date();
- wrkMast.setWrkSts(WrkStsType.INBOUND_STATION_RUN.sts);
- wrkMast.setSourceStaNo(stationProtocol.getStationId());
- wrkMast.setStaNo(targetStationId);
- wrkMast.setSystemMsg("");
- wrkMast.setIoTime(now);
- wrkMast.setModiTime(now);
- if (wrkMastService.updateById(wrkMast)) {
- wrkAnalysisService.markInboundStationStart(wrkMast, now);
- 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());
- saveLoopLoadReserve(wrkMast.getWrkNo(), loopHitResult);
- }
- }
- }
- }
- } catch (Exception e) {
- e.printStackTrace();
- }
+ stationRegularDispatchProcessor.stationInExecute();
}
//鎵ц鍫嗗灈鏈鸿緭閫佺珯鐐瑰嚭搴撲换鍔�
public synchronized void crnStationOutExecute() {
- try {
- DispatchLimitConfig baseLimitConfig = getDispatchLimitConfig(null, null);
- int[] currentStationTaskCountRef = new int[]{countCurrentStationTask()};
- LoadGuardState loadGuardState = buildLoadGuardState(baseLimitConfig);
-
- List<WrkMast> wrkMasts = wrkMastService.list(new QueryWrapper<WrkMast>()
- .eq("wrk_sts", WrkStsType.OUTBOUND_RUN_COMPLETE.sts)
- .isNotNull("crn_no")
- );
- List<Integer> outOrderList = getAllOutOrderList();
-
- for (WrkMast wrkMast : wrkMasts) {
- Object infoObj = redisUtil.get(RedisKeyType.CRN_OUT_TASK_COMPLETE_STATION_INFO.key + wrkMast.getWrkNo());
- if (infoObj == null) {
- News.info("鍑哄簱浠诲姟{}鏁版嵁缂撳瓨涓嶅瓨鍦�", wrkMast.getWrkNo());
- continue;
- }
-
- StationObjModel stationObjModel = JSON.parseObject(infoObj.toString(), StationObjModel.class);
- StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, stationObjModel.getDeviceNo());
- if (stationThread == null) {
- continue;
- }
-
- Map<Integer, StationProtocol> stationMap = stationThread.getStatusMap();
- StationProtocol stationProtocol = stationMap.get(stationObjModel.getStationId());
- if (stationProtocol == null) {
- continue;
- }
-
- Object lock = redisUtil.get(RedisKeyType.STATION_OUT_EXECUTE_LIMIT.key + stationProtocol.getStationId());
- if (lock != null) {
- continue;
- }
-
- //婊¤冻鑷姩銆佹湁鐗┿�佸伐浣滃彿0
- if (stationProtocol.isAutoing()
- && stationProtocol.isLoading()
- && stationProtocol.getTaskNo() == 0
- ) {
- Double pathLenFactor = resolveOutboundPathLenFactor(wrkMast);
- OutOrderDispatchDecision dispatchDecision = resolveOutboundDispatchDecision(
- stationProtocol.getStationId(),
- wrkMast,
- outOrderList,
- pathLenFactor
- );
- Integer moveStaNo = dispatchDecision == null ? null : dispatchDecision.getTargetStationId();
- if (moveStaNo == null) {
- continue;
- }
-
- DispatchLimitConfig limitConfig = getDispatchLimitConfig(stationProtocol.getStationId(), moveStaNo);
- LoopHitResult loopHitResult = findPathLoopHit(limitConfig, stationProtocol.getStationId(), moveStaNo, loadGuardState, wrkMast, pathLenFactor);
-
- if (isDispatchBlocked(limitConfig, currentStationTaskCountRef[0], loadGuardState, loopHitResult.isThroughLoop())) {
- return;
- }
-
- StationCommand command = buildOutboundMoveCommand(
- stationThread,
- wrkMast,
- stationProtocol.getStationId(),
- moveStaNo,
- pathLenFactor
- );
- if (command == null) {
- News.taskInfo(wrkMast.getWrkNo(), "鑾峰彇杈撻�佺嚎鍛戒护澶辫触");
- continue;
- }
-
- Date now = new Date();
- wrkMast.setWrkSts(WrkStsType.STATION_RUN.sts);
- wrkMast.setSystemMsg("");
- wrkMast.setIoTime(now);
- wrkMast.setModiTime(now);
- if (wrkMastService.updateById(wrkMast)) {
- wrkAnalysisService.markOutboundStationStart(wrkMast, now);
- 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());
- currentStationTaskCountRef[0]++;
- loadGuardState.reserveLoopTask(loopHitResult.getLoopNo());
- saveLoopLoadReserve(wrkMast.getWrkNo(), loopHitResult);
- }
- }
- }
- } catch (Exception e) {
- e.printStackTrace();
- }
+ stationOutboundDispatchProcessor.crnStationOutExecute();
}
//鎵ц鍙屽伐浣嶅爢鍨涙満杈撻�佺珯鐐瑰嚭搴撲换鍔�
public synchronized void dualCrnStationOutExecute() {
- try {
- List<WrkMast> wrkMasts = wrkMastService.list(new QueryWrapper<WrkMast>()
- .eq("wrk_sts", WrkStsType.OUTBOUND_RUN_COMPLETE.sts)
- .isNotNull("dual_crn_no")
- );
- for (WrkMast wrkMast : wrkMasts) {
- Object infoObj = redisUtil.get(RedisKeyType.DUAL_CRN_OUT_TASK_STATION_INFO.key + wrkMast.getWrkNo());
- if (infoObj == null) {
- News.info("鍑哄簱浠诲姟{}鏁版嵁缂撳瓨涓嶅瓨鍦�", wrkMast.getWrkNo());
- continue;
- }
-
- StationObjModel stationObjModel = JSON.parseObject(infoObj.toString(), StationObjModel.class);
- StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, stationObjModel.getDeviceNo());
- if (stationThread == null) {
- continue;
- }
-
- Map<Integer, StationProtocol> stationMap = stationThread.getStatusMap();
- StationProtocol stationProtocol = stationMap.get(stationObjModel.getStationId());
- if (stationProtocol == null) {
- continue;
- }
-
- Object lock = redisUtil.get(RedisKeyType.STATION_OUT_EXECUTE_LIMIT.key + stationProtocol.getStationId());
- if (lock != null) {
- continue;
- }
-
- //婊¤冻鑷姩銆佹湁鐗┿�佸伐浣滃彿0
- if (stationProtocol.isAutoing()
- && stationProtocol.isLoading()
- && stationProtocol.getTaskNo() == 0
- ) {
- Double pathLenFactor = resolveOutboundPathLenFactor(wrkMast);
- StationCommand command = buildOutboundMoveCommand(
- stationThread,
- wrkMast,
- stationProtocol.getStationId(),
- wrkMast.getStaNo(),
- pathLenFactor
- );
- if (command == null) {
- News.taskInfo(wrkMast.getWrkNo(), "鑾峰彇杈撻�佺嚎鍛戒护澶辫触");
- continue;
- }
-
- wrkMast.setWrkSts(WrkStsType.STATION_RUN.sts);
- wrkMast.setSystemMsg("");
- wrkMast.setIoTime(new Date());
- if (wrkMastService.updateById(wrkMast)) {
- 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);
- redisUtil.del(RedisKeyType.DUAL_CRN_OUT_TASK_STATION_INFO.key + wrkMast.getWrkNo());
- }
- }
- }
- } catch (Exception e) {
- e.printStackTrace();
- }
+ stationOutboundDispatchProcessor.dualCrnStationOutExecute();
}
//妫�娴嬭緭閫佺珯鐐瑰嚭搴撲换鍔℃墽琛屽畬鎴�
public synchronized void stationOutExecuteFinish() {
- try {
- List<WrkMast> wrkMasts = wrkMastService.list(new QueryWrapper<WrkMast>().eq("wrk_sts", WrkStsType.STATION_RUN.sts));
- for (WrkMast wrkMast : wrkMasts) {
- Integer wrkNo = wrkMast.getWrkNo();
- Integer targetStaNo = wrkMast.getStaNo();
- if (wrkNo == null || targetStaNo == null) {
- continue;
- }
-
- boolean complete = false;
- Integer targetDeviceNo = null;
- BasStation basStation = basStationService.getOne(new QueryWrapper<BasStation>().eq("station_id", targetStaNo));
- if (basStation != null) {
- targetDeviceNo = basStation.getDeviceNo();
- StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basStation.getDeviceNo());
- if (stationThread != null) {
- Map<Integer, StationProtocol> statusMap = stationThread.getStatusMap();
- StationProtocol stationProtocol = statusMap.get(basStation.getStationId());
- if (stationProtocol != null && wrkNo.equals(stationProtocol.getTaskNo())) {
- complete = true;
- }
- }
- }
-
- if (complete) {
- completeStationRunTask(wrkMast, targetDeviceNo);
- }
- }
- } catch (Exception e) {
- e.printStackTrace();
- }
- }
-
- private void completeStationRunTask(WrkMast wrkMast, Integer deviceNo) {
- 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);
- wrkMast.setModiTime(now);
- wrkMastService.updateById(wrkMast);
- wrkAnalysisService.markOutboundStationComplete(wrkMast, now);
- if (deviceNo != null) {
- notifyUtils.notify(String.valueOf(SlaveType.Devp), deviceNo, String.valueOf(wrkMast.getWrkNo()), wrkMast.getWmsWrkNo(), NotifyMsgType.STATION_OUT_TASK_RUN_COMPLETE, null);
- }
- redisUtil.set(RedisKeyType.STATION_OUT_EXECUTE_COMPLETE_LIMIT.key + wrkMast.getWrkNo(), "lock", 60);
+ stationRegularDispatchProcessor.stationOutExecuteFinish();
}
// 妫�娴嬩换鍔¤浆瀹屾垚
public synchronized void checkTaskToComplete() {
- try {
- List<WrkMast> wrkMasts = wrkMastService.list(new QueryWrapper<WrkMast>().eq("wrk_sts", WrkStsType.STATION_RUN_COMPLETE.sts));
- for (WrkMast wrkMast : wrkMasts) {
- Integer wrkNo = wrkMast.getWrkNo();
- Integer targetStaNo = wrkMast.getStaNo();
-
- Object lock = redisUtil.get(RedisKeyType.STATION_OUT_EXECUTE_COMPLETE_LIMIT.key + wrkNo);
- if (lock != null) {
- continue;
- }
-
- boolean complete = false;
- BasStation basStation = basStationService.getOne(new QueryWrapper<BasStation>().eq("station_id", targetStaNo));
- if (basStation == null) {
- continue;
- }
-
- StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basStation.getDeviceNo());
- if (stationThread == null) {
- continue;
- }
-
- Map<Integer, StationProtocol> statusMap = stationThread.getStatusMap();
- StationProtocol stationProtocol = statusMap.get(basStation.getStationId());
- if (stationProtocol == null) {
- continue;
- }
-
- if (!stationProtocol.getTaskNo().equals(wrkNo)) {
- complete = true;
- }
-
- if (complete) {
- if (stationMoveCoordinator != null) {
- stationMoveCoordinator.finishSession(wrkNo);
- }
- wrkMast.setWrkSts(WrkStsType.COMPLETE_OUTBOUND.sts);
- wrkMast.setIoTime(new Date());
- wrkMastService.updateById(wrkMast);
- }
- }
- } catch (Exception e) {
- e.printStackTrace();
- }
+ stationRegularDispatchProcessor.checkTaskToComplete();
}
//妫�娴嬭緭閫佺珯鐐规槸鍚﹁繍琛屽牭濉�
public synchronized void checkStationRunBlock() {
- try {
- List<BasDevp> basDevps = basDevpService.list(new QueryWrapper<>());
- for (BasDevp basDevp : basDevps) {
- StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basDevp.getDevpNo());
- if (stationThread == null) {
- continue;
- }
-
- List<Integer> runBlockReassignLocStationList = new ArrayList<>();
- for (StationObjModel stationObjModel : basDevp.getRunBlockReassignLocStationList$()) {
- runBlockReassignLocStationList.add(stationObjModel.getStationId());
- }
- List<Integer> outOrderStationIds = basDevp.getOutOrderIntList();
-
- List<StationProtocol> list = stationThread.getStatus();
- for (StationProtocol stationProtocol : list) {
- if (stationProtocol.isAutoing()
- && stationProtocol.isLoading()
- && stationProtocol.getTaskNo() > 0
- && stationProtocol.isRunBlock()
- ) {
- WrkMast wrkMast = wrkMastService.selectByWorkNo(stationProtocol.getTaskNo());
- if (wrkMast == null) {
- News.info("杈撻�佺珯鐐瑰彿={} 杩愯闃诲锛屼絾鏃犳硶鎵惧埌瀵瑰簲浠诲姟锛屽伐浣滃彿={}", stationProtocol.getStationId(), stationProtocol.getTaskNo());
- continue;
- }
-
- Object lock = redisUtil.get(RedisKeyType.CHECK_STATION_RUN_BLOCK_LIMIT_.key + stationProtocol.getTaskNo());
- if (lock != null) {
- continue;
- }
- redisUtil.set(RedisKeyType.CHECK_STATION_RUN_BLOCK_LIMIT_.key + stationProtocol.getTaskNo(), "lock", 15);
-
- if (wrkMast.getIoType() == WrkIoType.IN.id && runBlockReassignLocStationList.contains(stationProtocol.getStationId())) {
- //绔欑偣澶勪簬閲嶆柊鍒嗛厤搴撲綅鍖哄煙
- int currentTaskBufferCommandCount = countCurrentTaskBufferCommands(
- stationProtocol.getTaskBufferItems(),
- stationProtocol.getTaskNo()
- );
- if (currentTaskBufferCommandCount > 0) {
- News.info("杈撻�佺珯鐐硅繍琛屽牭濉為噸鍒嗛厤宸茶烦杩囷紝缂撳瓨鍖轰粛瀛樺湪褰撳墠浠诲姟鍛戒护銆傜珯鐐瑰彿={}锛屽伐浣滃彿={}锛屽綋鍓嶄换鍔″懡浠ゆ暟={}",
- stationProtocol.getStationId(),
- stationProtocol.getTaskNo(),
- currentTaskBufferCommandCount);
- continue;
- }
- 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);
- 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)) {
- boolean offered = offerDevpCommandWithDedup(basDevp.getDevpNo(), command, "checkStationRunBlock_direct");
- if (!offered) {
- continue;
- }
- if (stationMoveCoordinator != null) {
- stationMoveCoordinator.recordDispatch(
- wrkMast.getWrkNo(),
- stationProtocol.getStationId(),
- "checkStationRunBlock_direct",
- command,
- false
- );
- }
- }
- } 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;
- }
-
- if (countCurrentTaskBufferCommands(stationProtocol.getTaskBufferItems(), stationProtocol.getTaskNo()) > 0) {
- continue;
- }
-
- StationCommand command = stationThread.getRunBlockRerouteCommand(
- wrkMast.getWrkNo(),
- stationProtocol.getStationId(),
- moveStaNo,
- 0,
- pathLenFactor
- );
- if (command == null) {
- News.taskInfo(wrkMast.getWrkNo(),
- "杈撻�佺珯鐐瑰牭濉為噸瑙勫垝鏈壘鍒板彲涓嬪彂璺嚎锛屽綋鍓嶇珯鐐�={}锛岀洰鏍囩珯鐐�={}",
- stationProtocol.getStationId(),
- moveStaNo);
- continue;
- }
-
- if (stationMoveCoordinator != null) {
- stationMoveCoordinator.cancelSession(wrkMast.getWrkNo());
- }
- resetSegmentMoveCommandsBeforeReroute(wrkMast.getWrkNo());
- boolean offered = offerDevpCommandWithDedup(basDevp.getDevpNo(), command, "checkStationRunBlock_reroute");
- if (!offered) {
- continue;
- }
- syncOutOrderWatchState(wrkMast, stationProtocol.getStationId(), outOrderStationIds, dispatchDecision, command);
- if (stationMoveCoordinator != null) {
- stationMoveCoordinator.recordDispatch(
- wrkMast.getWrkNo(),
- stationProtocol.getStationId(),
- "checkStationRunBlock_reroute",
- command,
- dispatchDecision != null && dispatchDecision.isCircle()
- );
- }
- News.info("杈撻�佺珯鐐瑰牭濉炲悗閲嶆柊璁＄畻璺緞鍛戒护涓嬪彂鎴愬姛锛岀珯鐐瑰彿={}锛屽伐浣滃彿={}锛屽懡浠ゆ暟鎹�={}", stationProtocol.getStationId(), wrkMast.getWrkNo(), JSON.toJSONString(command));
- }
- }
- }
- }
- } catch (Exception e) {
- e.printStackTrace();
- }
+ stationRerouteProcessor.checkStationRunBlock();
}
//妫�娴嬭緭閫佺珯鐐逛换鍔″仠鐣欒秴鏃跺悗閲嶆柊璁＄畻璺緞
public synchronized void checkStationIdleRecover() {
- try {
- List<BasDevp> basDevps = basDevpService.list(new QueryWrapper<>());
- for (BasDevp basDevp : basDevps) {
- StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basDevp.getDevpNo());
- if (stationThread == null) {
- continue;
- }
-
- List<StationProtocol> list = stationThread.getStatus();
- for (StationProtocol stationProtocol : list) {
- if (stationProtocol.isAutoing()
- && stationProtocol.isLoading()
- && stationProtocol.getTaskNo() > 0
- && !stationProtocol.isRunBlock()
- ) {
- checkStationIdleRecover(basDevp, stationThread, stationProtocol, basDevp.getOutOrderIntList());
- }
- }
- }
- } catch (Exception e) {
- e.printStackTrace();
- }
+ stationRerouteProcessor.checkStationIdleRecover();
}
//鑾峰彇杈撻�佺嚎浠诲姟鏁伴噺
public synchronized int getCurrentStationTaskCount() {
- return countCurrentStationTask();
+ return stationDispatchLoadSupport.countCurrentStationTask();
}
public synchronized int getCurrentOutboundTaskCountByTargetStation(Integer stationId) {
@@ -700,1528 +86,35 @@
// 妫�娴嬪嚭搴撴帓搴�
public synchronized void checkStationOutOrder() {
- List<BasDevp> basDevps = basDevpService.list(new QueryWrapper<BasDevp>());
- for (BasDevp basDevp : basDevps) {
- StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basDevp.getDevpNo());
- if (stationThread == null) {
- continue;
- }
- Map<Integer, StationProtocol> statusMap = stationThread.getStatusMap();
- List<StationObjModel> orderList = basDevp.getOutOrderList$();
- List<Integer> outOrderStationIds = basDevp.getOutOrderIntList();
- for (StationObjModel stationObjModel : orderList) {
- StationProtocol stationProtocol = statusMap.get(stationObjModel.getStationId());
- if (stationProtocol == null) {
- continue;
- }
-
- if (!stationProtocol.isAutoing()) {
- continue;
- }
-
- if (!stationProtocol.isLoading()) {
- continue;
- }
-
- if (stationProtocol.getTaskNo() <= 0) {
- continue;
- }
-
- if (!stationProtocol.getStationId().equals(stationProtocol.getTargetStaNo())) {
- continue;
- }
-
- WrkMast wrkMast = wrkMastService.selectByWorkNo(stationProtocol.getTaskNo());
- if (wrkMast == null) {
- continue;
- }
- if (!Objects.equals(wrkMast.getWrkSts(), WrkStsType.STATION_RUN.sts)) {
- continue;
- }
- if (Objects.equals(stationProtocol.getStationId(), wrkMast.getStaNo())) {
- continue;
- }
-
- if (countCurrentTaskBufferCommands(stationProtocol.getTaskBufferItems(), stationProtocol.getTaskNo()) > 0) {
- continue;
- }
-
- 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 = buildOutboundMoveCommand(
- stationThread,
- wrkMast,
- stationProtocol.getStationId(),
- moveStaNo,
- pathLenFactor
- );
- if (command == null) {
- News.taskInfo(wrkMast.getWrkNo(), "鑾峰彇杈撻�佺嚎鍛戒护澶辫触");
- continue;
- }
- if (stationMoveCoordinator != null
- && stationMoveCoordinator.shouldSuppressDispatch(wrkMast.getWrkNo(), stationProtocol.getStationId(), command)) {
- continue;
- }
- if (!tryAcquireOutOrderDispatchLock(wrkMast.getWrkNo(), stationProtocol.getStationId())) {
- continue;
- }
- resetSegmentMoveCommandsBeforeReroute(wrkMast.getWrkNo());
- boolean offered = offerDevpCommandWithDedup(stationObjModel.getDeviceNo(), command, "checkStationOutOrder");
- if (!offered) {
- continue;
- }
- syncOutOrderWatchState(wrkMast, stationProtocol.getStationId(), outOrderStationIds, dispatchDecision, command);
- if (stationMoveCoordinator != null) {
- stationMoveCoordinator.recordDispatch(
- wrkMast.getWrkNo(),
- stationProtocol.getStationId(),
- "checkStationOutOrder",
- command,
- dispatchDecision != null && dispatchDecision.isCircle()
- );
- }
- News.info(dispatchDecision.isCircle() ? "{}浠诲姟杩涜缁曞湀" : "{}浠诲姟鐩存帴鍘荤洰鏍囩偣", wrkMast.getWrkNo());
- }
- }
+ stationRerouteProcessor.checkStationOutOrder();
}
// 鐩戞帶缁曞湀绔欑偣
public synchronized void watchCircleStation() {
- List<BasDevp> basDevps = basDevpService.list(new QueryWrapper<BasDevp>());
- for (BasDevp basDevp : basDevps) {
- StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basDevp.getDevpNo());
- if (stationThread == null) {
- continue;
- }
-
- List<Integer> outOrderList = basDevp.getOutOrderIntList();
-
- for (StationProtocol stationProtocol : stationThread.getStatus()) {
- if (!stationProtocol.isAutoing()) {
- continue;
- }
-
- if (!stationProtocol.isLoading()) {
- continue;
- }
-
- if (stationProtocol.getTaskNo() <= 0) {
- continue;
- }
-
- StationCommand circleCommand = getWatchCircleCommand(stationProtocol.getTaskNo());
- if (circleCommand == null) {
- continue;
- }
- if (!stationProtocol.getStationId().equals(circleCommand.getTargetStaNo())) {
- continue;
- }
-
- WrkMast wrkMast = wrkMastService.selectByWorkNo(stationProtocol.getTaskNo());
- if (wrkMast == null) {
- continue;
- }
- if (!Objects.equals(wrkMast.getWrkSts(), WrkStsType.STATION_RUN.sts)) {
- continue;
- }
- if (Objects.equals(stationProtocol.getStationId(), wrkMast.getStaNo())) {
- continue;
- }
- if (countCurrentTaskBufferCommands(stationProtocol.getTaskBufferItems(), stationProtocol.getTaskNo()) > 0) {
- continue;
- }
-
- Double pathLenFactor = resolveOutboundPathLenFactor(wrkMast);
- OutOrderDispatchDecision dispatchDecision = resolveOutboundDispatchDecision(
- stationProtocol.getStationId(),
- 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 (stationMoveCoordinator != null
- && stationMoveCoordinator.shouldSuppressDispatch(wrkMast.getWrkNo(), stationProtocol.getStationId(), command)) {
- continue;
- }
- if (!tryAcquireOutOrderDispatchLock(wrkMast.getWrkNo(), stationProtocol.getStationId())) {
- continue;
- }
- resetSegmentMoveCommandsBeforeReroute(wrkMast.getWrkNo());
- boolean offered = offerDevpCommandWithDedup(basDevp.getDevpNo(), command, "watchCircleStation");
- if (!offered) {
- continue;
- }
- syncOutOrderWatchState(wrkMast, stationProtocol.getStationId(), outOrderList, dispatchDecision, command);
- if (stationMoveCoordinator != null) {
- stationMoveCoordinator.recordDispatch(
- wrkMast.getWrkNo(),
- stationProtocol.getStationId(),
- "watchCircleStation",
- command,
- dispatchDecision != null && dispatchDecision.isCircle()
- );
- }
- }
- }
+ stationRerouteProcessor.watchCircleStation();
}
- private StationCommand buildOutboundMoveCommand(StationThread stationThread,
- WrkMast wrkMast,
- Integer stationId,
- Integer targetStationId,
- Double pathLenFactor) {
- if (stationThread == null || wrkMast == null) {
- return null;
- }
- return stationThread.getCommand(
- StationCommandType.MOVE,
- wrkMast.getWrkNo(),
- stationId,
- targetStationId,
- 0,
- normalizePathLenFactor(pathLenFactor)
- );
+ RerouteCommandPlan buildRerouteCommandPlan(RerouteContext context,
+ RerouteDecision decision) {
+ return stationRerouteProcessor.buildRerouteCommandPlan(context, decision);
}
- private List<NavigateNode> calcOutboundNavigatePath(WrkMast wrkMast,
- Integer sourceStationId,
- Integer targetStationId,
- Double pathLenFactor) {
- Double normalizedFactor = normalizePathLenFactor(pathLenFactor);
- Integer currentTaskNo = wrkMast == null ? null : wrkMast.getWrkNo();
- if (currentTaskNo == null) {
- return navigateUtils.calcByStationId(sourceStationId, targetStationId, normalizedFactor);
- }
- return navigateUtils.calcByStationId(sourceStationId, targetStationId, currentTaskNo, normalizedFactor);
+ RerouteExecutionResult executeReroutePlan(RerouteContext context,
+ RerouteCommandPlan plan) {
+ return stationRerouteProcessor.executeReroutePlan(context, plan);
}
- private Double resolveOutboundPathLenFactor(WrkMast wrkMast) {
- if (!isBatchOutboundTaskWithSeq(wrkMast)) {
- return 0.0d;
- }
- List<WrkMast> activeBatchTaskList = loadActiveBatchTaskList(wrkMast.getBatch());
- if (activeBatchTaskList.size() <= 1) {
- return 0.0d;
- }
-
- int activeTaskCount = 0;
- int predecessorCount = 0;
- for (WrkMast item : activeBatchTaskList) {
- if (!isFactorCandidateTask(item)) {
- continue;
- }
- activeTaskCount++;
- if (item.getBatchSeq() < wrkMast.getBatchSeq()) {
- predecessorCount++;
- }
- }
- if (activeTaskCount <= 1 || predecessorCount <= 0) {
- return 0.0d;
- }
- return normalizePathLenFactor((double) predecessorCount / (double) (activeTaskCount - 1));
+ RerouteDecision resolveSharedRerouteDecision(RerouteContext context) {
+ return stationRerouteProcessor.resolveSharedRerouteDecision(context);
}
- private boolean isBatchOutboundTaskWithSeq(WrkMast wrkMast) {
- return wrkMast != null
- && Objects.equals(wrkMast.getIoType(), WrkIoType.OUT.id)
- && !Cools.isEmpty(wrkMast.getBatch())
- && wrkMast.getBatchSeq() != null
- && wrkMast.getWrkNo() != null;
- }
-
- private List<WrkMast> loadActiveBatchTaskList(String batch) {
- if (Cools.isEmpty(batch)) {
- return Collections.emptyList();
- }
- return wrkMastService.list(new QueryWrapper<WrkMast>()
- .eq("io_type", WrkIoType.OUT.id)
- .eq("batch", batch)
- .notIn("wrk_sts",
- WrkStsType.STATION_RUN_COMPLETE.sts,
- WrkStsType.COMPLETE_OUTBOUND.sts,
- WrkStsType.SETTLE_OUTBOUND.sts));
- }
-
- private boolean isFactorCandidateTask(WrkMast wrkMast) {
- return wrkMast != null
- && Objects.equals(wrkMast.getIoType(), WrkIoType.OUT.id)
- && wrkMast.getBatchSeq() != null
- && !"taskCancel".equals(wrkMast.getMk());
- }
-
- public List<Integer> getAllOutOrderList() {
- List<Integer> list = new ArrayList<>();
- List<BasDevp> basDevps = basDevpService.list(new QueryWrapper<BasDevp>());
- for (BasDevp basDevp : basDevps) {
- List<Integer> orderList = basDevp.getOutOrderIntList();
- list.addAll(orderList);
- }
- return list;
- }
-
- private OutOrderDispatchDecision resolveOutboundDispatchDecision(Integer currentStationId,
- WrkMast wrkMast,
- List<Integer> outOrderStationIds,
- Double pathLenFactor) {
- if (wrkMast == null || wrkMast.getStaNo() == null) {
- return null;
- }
- if (!shouldApplyOutOrder(wrkMast, outOrderStationIds)) {
- return new OutOrderDispatchDecision(wrkMast.getStaNo(), false);
- }
- Integer dispatchStationId = resolveDispatchOutOrderTarget(
- wrkMast,
- wrkMast.getSourceStaNo(),
- wrkMast.getStaNo(),
- outOrderStationIds,
- pathLenFactor
- );
- if (dispatchStationId == null) {
- return null;
- }
- if (isCurrentOutOrderDispatchStation(currentStationId, wrkMast, outOrderStationIds, pathLenFactor)) {
- return resolveCurrentOutOrderDispatchDecision(currentStationId, wrkMast, outOrderStationIds, pathLenFactor);
- }
- if (!Objects.equals(dispatchStationId, wrkMast.getStaNo())
- && isCurrentOutOrderStation(currentStationId, outOrderStationIds)
- && isWatchingCircleArrival(wrkMast.getWrkNo(), currentStationId)) {
- return new OutOrderDispatchDecision(dispatchStationId, true, null, false);
- }
- return new OutOrderDispatchDecision(dispatchStationId, false);
- }
-
- private OutOrderDispatchDecision resolveCurrentOutOrderDispatchDecision(Integer currentStationId,
- WrkMast wrkMast,
- List<Integer> outOrderStationIds,
- Double pathLenFactor) {
- if (!isCurrentOutOrderDispatchStation(currentStationId, wrkMast, outOrderStationIds, pathLenFactor)) {
- return null;
- }
-
- List<WrkMast> batchWrkList = wrkMastService.list(new QueryWrapper<WrkMast>()
- .eq("io_type", WrkIoType.OUT.id)
- .notIn("wrk_sts",
- WrkStsType.STATION_RUN_COMPLETE.sts,
- WrkStsType.COMPLETE_OUTBOUND.sts,
- WrkStsType.SETTLE_OUTBOUND.sts)
- .eq("batch", wrkMast.getBatch())
- .orderByAsc("batch_seq")
- .orderByAsc("wrk_no"));
- if (batchWrkList.isEmpty()) {
- return new OutOrderDispatchDecision(wrkMast.getStaNo(), false);
- }
-
- WrkMast firstWrkMast = batchWrkList.get(0);
- Integer currentBatchSeq = firstWrkMast.getBatchSeq();
- if (currentBatchSeq == null) {
- News.taskInfo(wrkMast.getWrkNo(), "鎵规:{} 棣栦釜鏈畬鎴愪换鍔＄己灏戞壒娆″簭鍙凤紝褰撳墠浠诲姟鏆備笉鏀捐", wrkMast.getBatch());
- return null;
- }
-
- List<NavigateNode> initPath;
- try {
- initPath = calcOutboundNavigatePath(wrkMast, wrkMast.getSourceStaNo(), wrkMast.getStaNo(), pathLenFactor);
- } catch (Exception e) {
- News.taskInfo(wrkMast.getWrkNo(), "鎵规:{} 璁＄畻鎺掑簭璺緞澶辫触锛屽綋鍓嶇珯鐐�={}", wrkMast.getBatch(), currentStationId);
- return null;
- }
-
- Integer seq = getOutStationBatchSeq(initPath, currentStationId, wrkMast.getBatch());
- boolean toTarget;
- if (seq == null) {
- toTarget = currentBatchSeq.equals(wrkMast.getBatchSeq());
- } else {
- toTarget = Integer.valueOf(seq + 1).equals(wrkMast.getBatchSeq());
- }
- if (toTarget) {
- if (hasReachableOutReleaseSlot(wrkMast, currentStationId, wrkMast.getStaNo(), pathLenFactor)) {
- return new OutOrderDispatchDecision(wrkMast.getStaNo(), false);
- }
- StationTaskLoopService.LoopEvaluation loopEvaluation = evaluateOutOrderLoop(
- wrkMast.getWrkNo(),
- currentStationId,
- outOrderStationIds
- );
- Integer circleTarget = resolveNextCircleOrderTarget(
- wrkMast,
- currentStationId,
- outOrderStationIds,
- loopEvaluation.getExpectedLoopIssueCount(),
- pathLenFactor
- );
- if (circleTarget == null) {
- News.taskInfo(wrkMast.getWrkNo(), "鐩爣绔欏綋鍓嶄笉鍙繘锛屼笖鏈壘鍒板彲鎵ц鐨勪笅涓�鎺掑簭妫�娴嬬偣锛屽綋鍓嶇珯鐐�={}", currentStationId);
- return null;
- }
- return new OutOrderDispatchDecision(circleTarget, true, loopEvaluation, true);
- }
-
- StationTaskLoopService.LoopEvaluation loopEvaluation = evaluateOutOrderLoop(
- wrkMast.getWrkNo(),
- currentStationId,
- outOrderStationIds
- );
- Integer circleTarget = resolveNextCircleOrderTarget(
- wrkMast,
- currentStationId,
- outOrderStationIds,
- loopEvaluation.getExpectedLoopIssueCount(),
- pathLenFactor
- );
- if (circleTarget == null) {
- News.taskInfo(wrkMast.getWrkNo(), "鏈壘鍒板彲鎵ц鐨勪笅涓�鎺掑簭妫�娴嬬偣锛屽綋鍓嶇珯鐐�={}", currentStationId);
- return null;
- }
- return new OutOrderDispatchDecision(circleTarget, true, loopEvaluation, true);
- }
-
- private boolean shouldApplyOutOrder(WrkMast wrkMast, List<Integer> outOrderStationIds) {
- return wrkMast != null
- && wrkMast.getStaNo() != null
- && Objects.equals(wrkMast.getIoType(), WrkIoType.OUT.id)
- && !Cools.isEmpty(wrkMast.getBatch())
- && wrkMast.getBatchSeq() != null
- && outOrderStationIds != null
- && !outOrderStationIds.isEmpty();
- }
-
- private boolean isCurrentOutOrderDispatchStation(Integer currentStationId,
- WrkMast wrkMast,
- List<Integer> outOrderStationIds,
- Double pathLenFactor) {
- if (!shouldApplyOutOrder(wrkMast, outOrderStationIds) || currentStationId == null) {
- return false;
- }
- Integer dispatchStationId = resolveDispatchOutOrderTarget(
- wrkMast,
- wrkMast.getSourceStaNo(),
- wrkMast.getStaNo(),
- outOrderStationIds,
- pathLenFactor
- );
- return dispatchStationId != null
- && !Objects.equals(dispatchStationId, wrkMast.getStaNo())
- && Objects.equals(currentStationId, dispatchStationId);
- }
-
- private boolean isCurrentOutOrderStation(Integer currentStationId,
- List<Integer> outOrderStationIds) {
- return currentStationId != null
- && outOrderStationIds != null
- && outOrderStationIds.contains(currentStationId);
- }
-
- private void syncOutOrderWatchState(WrkMast wrkMast,
- Integer currentStationId,
- List<Integer> outOrderStationIds,
- OutOrderDispatchDecision dispatchDecision,
- StationCommand command) {
- if (dispatchDecision == null || command == null || !shouldApplyOutOrder(wrkMast, outOrderStationIds)) {
- return;
- }
- if (dispatchDecision.isCircle()) {
- saveWatchCircleCommand(wrkMast.getWrkNo(), command);
- if (dispatchDecision.shouldCountLoopIssue()
- && stationTaskLoopService != null
- && dispatchDecision.getLoopEvaluation() != null) {
- stationTaskLoopService.recordLoopIssue(dispatchDecision.getLoopEvaluation(), "OUT_ORDER_CIRCLE");
- }
- } else {
- clearWatchCircleCommand(wrkMast.getWrkNo());
- }
- }
-
- private StationTaskLoopService.LoopEvaluation evaluateOutOrderLoop(Integer taskNo,
- Integer currentStationId,
- List<Integer> outOrderStationIds) {
- if (stationTaskLoopService == null) {
- return new StationTaskLoopService.LoopEvaluation(
- taskNo,
- currentStationId,
- StationTaskLoopService.LoopIdentitySnapshot.empty(),
- 0,
- 0,
- false
- );
- }
- return stationTaskLoopService.evaluateLoop(
- taskNo,
- currentStationId,
- true,
- outOrderStationIds,
- "outOrderCircle"
- );
- }
-
- private Integer resolveDispatchOutOrderTarget(WrkMast wrkMast,
- Integer sourceStationId,
- Integer finalTargetStationId,
- List<Integer> outOrderList,
- Double pathLenFactor) {
- if (finalTargetStationId == null) {
- return null;
- }
- if (sourceStationId == null || outOrderList == null || outOrderList.isEmpty()) {
- return finalTargetStationId;
- }
-
- try {
- List<NavigateNode> nodes = calcOutboundNavigatePath(wrkMast, sourceStationId, finalTargetStationId, pathLenFactor);
- for (int i = nodes.size() - 1; i >= 0; i--) {
- Integer stationId = getStationIdFromNode(nodes.get(i));
- if (stationId == null) {
- continue;
- }
- if (Objects.equals(stationId, finalTargetStationId)) {
- continue;
- }
- if (outOrderList.contains(stationId)) {
- return stationId;
- }
- }
- } catch (Exception ignore) {}
- return finalTargetStationId;
- }
-
- private boolean hasReachableOutReleaseSlot(WrkMast wrkMast,
- Integer currentStationId,
- Integer finalTargetStationId,
- Double pathLenFactor) {
- if (currentStationId == null || finalTargetStationId == null) {
- return true;
- }
-
- try {
- List<NavigateNode> nodes = calcOutboundNavigatePath(wrkMast, currentStationId, finalTargetStationId, pathLenFactor);
- if (nodes == null || nodes.isEmpty()) {
- return true;
- }
-
- for (NavigateNode node : nodes) {
- Integer stationId = getStationIdFromNode(node);
- if (stationId == null || Objects.equals(stationId, currentStationId)) {
- continue;
- }
-
- if (!isPathStationBlocked(stationId)) {
- return true;
- }
- }
- return false;
- } catch (Exception ignore) {
- return true;
- }
- }
-
- private boolean isPathStationBlocked(Integer stationId) {
- if (stationId == null) {
- return true;
- }
-
- BasStation basStation = basStationService.getOne(new QueryWrapper<BasStation>().eq("station_id", stationId));
- if (basStation == null) {
- return true;
- }
-
- StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basStation.getDeviceNo());
- if (stationThread == null) {
- return true;
- }
-
- StationProtocol stationProtocol = stationThread.getStatusMap().get(stationId);
- if (stationProtocol == null) {
- return true;
- }
-
- return !stationProtocol.isAutoing()
- || stationProtocol.isLoading()
- || (stationProtocol.getTaskNo() != null && stationProtocol.getTaskNo() > 0);
- }
-
- private Integer resolveNextCircleOrderTarget(WrkMast wrkMast,
- Integer currentStationId,
- List<Integer> orderedOutStationList,
- Integer expectedLoopIssueCount,
- Double pathLenFactor) {
- if (currentStationId == null || orderedOutStationList == null || orderedOutStationList.size() <= 1) {
- return null;
- }
-
- int startIndex = orderedOutStationList.indexOf(currentStationId);
- int total = orderedOutStationList.size();
- List<CircleTargetCandidate> candidateList = new ArrayList<>();
- for (int offset = 1; offset < total; offset++) {
- int candidateIndex = (startIndex + offset + total) % total;
- Integer candidateStationId = orderedOutStationList.get(candidateIndex);
- if (candidateStationId == null || currentStationId.equals(candidateStationId)) {
- continue;
- }
- try {
- List<NavigateNode> path = calcOutboundNavigatePath(wrkMast, currentStationId, candidateStationId, pathLenFactor);
- if (path != null && !path.isEmpty()) {
- candidateList.add(new CircleTargetCandidate(candidateStationId, path.size(), offset));
- }
- } catch (Exception ignore) {}
- }
- if (candidateList.isEmpty()) {
- return null;
- }
- candidateList.sort(new Comparator<CircleTargetCandidate>() {
- @Override
- public int compare(CircleTargetCandidate left, CircleTargetCandidate right) {
- if (left == right) {
- return 0;
- }
- if (left == null) {
- return 1;
- }
- if (right == null) {
- return -1;
- }
- int pathCompare = Integer.compare(left.getPathLength(), right.getPathLength());
- if (pathCompare != 0) {
- return pathCompare;
- }
- return Integer.compare(left.getOffset(), right.getOffset());
- }
- });
- return resolveGradualCircleTargetByPathLength(expectedLoopIssueCount, candidateList, pathLenFactor);
- }
-
- private Integer resolveGradualCircleTargetByPathLength(Integer expectedLoopIssueCount,
- List<CircleTargetCandidate> candidateList,
- Double pathLenFactor) {
- if (candidateList == null || candidateList.isEmpty()) {
- return null;
- }
-
- List<CircleTargetCandidate> tierList = new ArrayList<>();
- Integer lastPathLength = null;
- for (CircleTargetCandidate candidate : candidateList) {
- if (candidate == null) {
- continue;
- }
- if (lastPathLength == null || !Objects.equals(lastPathLength, candidate.getPathLength())) {
- tierList.add(candidate);
- lastPathLength = candidate.getPathLength();
- }
- }
- if (tierList.isEmpty()) {
- return candidateList.get(0).getStationId();
- }
- int defaultTierIndex = expectedLoopIssueCount == null || expectedLoopIssueCount <= 2
- ? 0
- : Math.min(expectedLoopIssueCount - 2, tierList.size() - 1);
- int factorTierIndex = (int) Math.round(normalizePathLenFactor(pathLenFactor) * (tierList.size() - 1));
- int tierIndex = Math.max(defaultTierIndex, factorTierIndex);
- return tierList.get(tierIndex).getStationId();
- }
-
- private boolean tryAcquireOutOrderDispatchLock(Integer wrkNo, Integer stationId) {
- if (wrkNo == null || wrkNo <= 0 || stationId == null) {
- return true;
- }
- String key = RedisKeyType.STATION_OUT_ORDER_DISPATCH_LIMIT_.key + wrkNo + "_" + stationId;
- Object lock = redisUtil.get(key);
- if (lock != null) {
- return false;
- }
- redisUtil.set(key, "lock", OUT_ORDER_DISPATCH_LIMIT_SECONDS);
- return true;
- }
-
- 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) {
- if (wrkNo == null || wrkNo <= 0) {
- return null;
- }
- Object circleObj = redisUtil.get(RedisKeyType.WATCH_CIRCLE_STATION_.key + wrkNo);
- if (circleObj == null) {
- return null;
- }
- try {
- return JSON.parseObject(circleObj.toString(), StationCommand.class);
- } catch (Exception ignore) {
- return null;
- }
- }
-
- private void saveWatchCircleCommand(Integer wrkNo, StationCommand command) {
- if (wrkNo == null || wrkNo <= 0 || command == null) {
- return;
- }
- redisUtil.set(RedisKeyType.WATCH_CIRCLE_STATION_.key + wrkNo,
- JSON.toJSONString(command, SerializerFeature.DisableCircularReferenceDetect), 60 * 60 * 24);
- }
-
- private void clearWatchCircleCommand(Integer wrkNo) {
- if (wrkNo == null || wrkNo <= 0) {
- return;
- }
- redisUtil.del(RedisKeyType.WATCH_CIRCLE_STATION_.key + wrkNo);
- }
-
- private void checkStationIdleRecover(BasDevp basDevp,
- StationThread stationThread,
- StationProtocol stationProtocol,
- List<Integer> outOrderList) {
- if (stationProtocol == null || stationProtocol.getTaskNo() == null || stationProtocol.getTaskNo() <= 0) {
- return;
- }
- if (!Objects.equals(stationProtocol.getStationId(), stationProtocol.getTargetStaNo())) {
- return;
- }
-
- StationTaskIdleTrack idleTrack = touchStationTaskIdleTrack(stationProtocol.getTaskNo(), stationProtocol.getStationId());
- if (shouldSkipIdleRecoverForRecentDispatch(stationProtocol.getTaskNo(), stationProtocol.getStationId())) {
- return;
- }
- if (idleTrack == null || !idleTrack.isTimeout(STATION_IDLE_RECOVER_SECONDS)) {
- return;
- }
-
- WrkMast wrkMast = wrkMastService.selectByWorkNo(stationProtocol.getTaskNo());
- if (!canRecoverIdleStationTask(wrkMast, stationProtocol.getStationId())) {
- return;
- }
-
- Object lock = redisUtil.get(RedisKeyType.CHECK_STATION_IDLE_RECOVER_LIMIT_.key + stationProtocol.getTaskNo());
- if (lock != null) {
- return;
- }
- int currentTaskBufferCommandCount = countCurrentTaskBufferCommands(
- stationProtocol.getTaskBufferItems(),
- stationProtocol.getTaskNo()
- );
- if (currentTaskBufferCommandCount > 0) {
- News.info("杈撻�佺珯鐐逛换鍔″仠鐣欒秴鏃讹紝浣嗙紦瀛樺尯浠嶅瓨鍦ㄥ綋鍓嶄换鍔″懡浠わ紝宸茶烦杩囬噸绠椼�傜珯鐐瑰彿={}锛屽伐浣滃彿={}锛屽綋鍓嶄换鍔″懡浠ゆ暟={}",
- stationProtocol.getStationId(),
- stationProtocol.getTaskNo(),
- currentTaskBufferCommandCount);
- 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;
- }
-
- if (stationMoveCoordinator != null) {
- stationMoveCoordinator.cancelSession(stationProtocol.getTaskNo());
- }
- 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(
- stationThread,
- wrkMast,
- stationProtocol.getStationId(),
- moveStaNo,
- pathLenFactor
- );
- if (command == null) {
- News.taskInfo(wrkMast.getWrkNo(), "绔欑偣浠诲姟鍋滅暀瓒呮椂鍚庨噸绠楄矾寰勫け璐ワ紝褰撳墠绔欑偣={}锛岀洰鏍囩珯鐐�={}", stationProtocol.getStationId(), moveStaNo);
- return;
- }
-
- boolean offered = offerDevpCommandWithDedup(basDevp.getDevpNo(), command, "checkStationIdleRecover");
- if (!offered) {
- return;
- }
- syncOutOrderWatchState(wrkMast, stationProtocol.getStationId(), outOrderList, dispatchDecision, command);
- if (stationMoveCoordinator != null) {
- stationMoveCoordinator.recordDispatch(
- wrkMast.getWrkNo(),
- stationProtocol.getStationId(),
- "checkStationIdleRecover",
- command,
- dispatchDecision != null && dispatchDecision.isCircle()
- );
- }
- saveStationTaskIdleTrack(new StationTaskIdleTrack(wrkMast.getWrkNo(), stationProtocol.getStationId(), System.currentTimeMillis()));
- News.info("杈撻�佺珯鐐逛换鍔″仠鐣檣}绉掓湭杩愯锛屽凡閲嶆柊璁＄畻璺緞骞堕噸鍚繍琛岋紝绔欑偣鍙�={}锛岀洰鏍囩珯={}锛屽伐浣滃彿={}锛屾竻鐞嗘棫鍒嗘鍛戒护鏁�={}锛屽懡浠ゆ暟鎹�={}",
- STATION_IDLE_RECOVER_SECONDS, stationProtocol.getStationId(), moveStaNo, wrkMast.getWrkNo(), clearedCommandCount, JSON.toJSONString(command));
- }
-
- private boolean canRecoverIdleStationTask(WrkMast wrkMast, Integer currentStationId) {
- if (wrkMast == null || currentStationId == null || wrkMast.getStaNo() == null) {
- return false;
- }
- if (Objects.equals(currentStationId, wrkMast.getStaNo())) {
- return false;
- }
- return Objects.equals(wrkMast.getWrkSts(), WrkStsType.INBOUND_STATION_RUN.sts)
- || Objects.equals(wrkMast.getWrkSts(), WrkStsType.STATION_RUN.sts);
+ boolean shouldUseRunBlockDirectReassign(WrkMast wrkMast,
+ Integer stationId,
+ List<Integer> runBlockReassignLocStationList) {
+ return stationRerouteProcessor.shouldUseRunBlockDirectReassign(wrkMast, stationId, runBlockReassignLocStationList);
}
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;
+ return stationRerouteProcessor.shouldSkipIdleRecoverForRecentDispatch(taskNo, stationId);
}
-
- private void resetSegmentMoveCommandsBeforeReroute(Integer taskNo) {
- if (redisUtil == null || taskNo == null || taskNo <= 0) {
- return;
- }
- String key = RedisKeyType.DEVICE_STATION_MOVE_RESET.key + taskNo;
- redisUtil.set(key, "cancel", 3);
- try {
- Thread.sleep(STATION_MOVE_RESET_WAIT_MS);
- } catch (InterruptedException e) {
- Thread.currentThread().interrupt();
- } 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,
- Integer taskNo,
- Integer stationId) {
- if (basStationOptService == null) {
- return 0;
- }
- List<BasStationOpt> optList;
- try {
- optList = listIssuedMoveCommandsDuringIdleStay(idleTrack, taskNo);
- } catch (Exception e) {
- return 0;
- }
- if (optList == null || optList.isEmpty()) {
- return 0;
- }
-
- Date now = new Date();
- String cleanupMemo = buildIdleRecoverClearedMemo(stationId);
- int clearedCount = 0;
- for (BasStationOpt opt : optList) {
- if (opt == null || opt.getId() == null) {
- continue;
- }
- opt.setSend(0);
- opt.setUpdateTime(now);
- opt.setMemo(appendCleanupMemo(opt.getMemo(), cleanupMemo));
- clearedCount++;
- }
- if (clearedCount > 0) {
- basStationOptService.updateBatchById(optList);
- }
- return clearedCount;
- }
-
- private List<BasStationOpt> listIssuedMoveCommandsDuringIdleStay(StationTaskIdleTrack idleTrack,
- Integer taskNo) {
- if (idleTrack == null || taskNo == null || taskNo <= 0 || idleTrack.firstSeenTime == null || basStationOptService == null) {
- return Collections.emptyList();
- }
- List<BasStationOpt> optList = basStationOptService.list(new QueryWrapper<BasStationOpt>()
- .select("id", "task_no", "send_time", "target_station_id", "memo", "send")
- .eq("task_no", taskNo)
- .eq("mode", String.valueOf(StationCommandType.MOVE))
- .eq("send", 1)
- .ge("send_time", new Date(idleTrack.firstSeenTime))
- .orderByAsc("send_time"));
- if (optList == null || optList.isEmpty()) {
- return Collections.emptyList();
- }
- return optList;
- }
-
- private String buildIdleRecoverClearedMemo(Integer stationId) {
- if (stationId == null) {
- return IDLE_RECOVER_CLEARED_MEMO;
- }
- return IDLE_RECOVER_CLEARED_MEMO + "(stationId=" + stationId + ")";
- }
-
- private String appendCleanupMemo(String memo, String cleanupMemo) {
- if (Cools.isEmpty(cleanupMemo)) {
- return memo;
- }
- if (Cools.isEmpty(memo)) {
- return cleanupMemo;
- }
- if (memo.contains(cleanupMemo)) {
- return memo;
- }
- return memo + " | " + cleanupMemo;
- }
-
- private StationTaskIdleTrack touchStationTaskIdleTrack(Integer taskNo, Integer stationId) {
- if (taskNo == null || taskNo <= 0 || stationId == null) {
- return null;
- }
- long now = System.currentTimeMillis();
- StationTaskIdleTrack idleTrack = getStationTaskIdleTrack(taskNo);
- if (idleTrack == null || !Objects.equals(idleTrack.stationId, stationId)) {
- idleTrack = new StationTaskIdleTrack(taskNo, stationId, now);
- saveStationTaskIdleTrack(idleTrack);
- }
- return idleTrack;
- }
-
- private StationTaskIdleTrack getStationTaskIdleTrack(Integer taskNo) {
- if (taskNo == null || taskNo <= 0) {
- return null;
- }
- Object obj = redisUtil.get(RedisKeyType.STATION_TASK_IDLE_TRACK_.key + taskNo);
- if (obj == null) {
- return null;
- }
- try {
- return JSON.parseObject(obj.toString(), StationTaskIdleTrack.class);
- } catch (Exception e) {
- return null;
- }
- }
-
- private void saveStationTaskIdleTrack(StationTaskIdleTrack idleTrack) {
- if (idleTrack == null || idleTrack.taskNo == null || idleTrack.taskNo <= 0) {
- return;
- }
- redisUtil.set(
- RedisKeyType.STATION_TASK_IDLE_TRACK_.key + idleTrack.taskNo,
- JSON.toJSONString(idleTrack, SerializerFeature.DisableCircularReferenceDetect),
- STATION_IDLE_TRACK_EXPIRE_SECONDS
- );
- }
-
- public Integer getOutStationBatchSeq(List<NavigateNode> pathList, Integer searchStationId, String searchBatch) {
- if (pathList == null || pathList.isEmpty() || searchStationId == null || Cools.isEmpty(searchBatch)) {
- return null;
- }
- List<Integer> checkList = new ArrayList<>();
- for (int i = pathList.size() - 1; i >= 0; i--) {
- NavigateNode node = pathList.get(i);
- JSONObject v = JSONObject.parseObject(node.getNodeValue());
- if (v != null) {
- Integer stationId = v.getInteger("stationId");
- if (searchStationId.equals(stationId)) {
- break;
- } else {
- checkList.add(stationId);
- }
- }
- }
-
- HashMap<String, Integer> batchMap = new HashMap<>();
- for (Integer station : checkList) {
- BasStation basStation = basStationService.getOne(new QueryWrapper<BasStation>().eq("station_id", station));
- if (basStation == null) {
- continue;
- }
-
- StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basStation.getDeviceNo());
- if (stationThread == null) {
- continue;
- }
- Map<Integer, StationProtocol> statusMap = stationThread.getStatusMap();
- StationProtocol checkStationProtocol = statusMap.get(station);
- if (checkStationProtocol == null) {
- continue;
- }
- if (checkStationProtocol.getTaskNo() > 0) {
- WrkMast checkWrkMast = wrkMastService.selectByWorkNo(checkStationProtocol.getTaskNo());
- if (checkWrkMast == null) {
- continue;
- }
-
- if (!Cools.isEmpty(checkWrkMast.getBatch())) {
- batchMap.put(checkWrkMast.getBatch(), checkWrkMast.getBatchSeq());
- }
- }
- }
-
- Integer seq = batchMap.get(searchBatch);
- return seq;
- }
-
- private int countCurrentStationTask() {
- int currentStationTaskCount = 0;
- List<BasDevp> basDevps = basDevpService.list(new QueryWrapper<BasDevp>());
- for (BasDevp basDevp : basDevps) {
- StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basDevp.getDevpNo());
- if (stationThread == null) {
- continue;
- }
-
- for (StationProtocol stationProtocol : stationThread.getStatus()) {
- if (stationProtocol.getTaskNo() > 0) {
- currentStationTaskCount++;
- }
- }
- }
- return currentStationTaskCount;
- }
-
- private boolean isDispatchBlocked(DispatchLimitConfig config,
- int currentStationTaskCount,
- LoadGuardState loadGuardState,
- boolean needReserveLoopLoad) {
- if (config.loopModeEnable) {
- double currentLoad = loadGuardState.currentLoad();
- if (currentLoad >= config.circleMaxLoadLimit) {
- News.warn("褰撳墠鎵胯浇閲忚揪鍒颁笂闄愶紝宸插仠姝㈢珯鐐逛换鍔′笅鍙戙�傚綋鍓嶆壙杞介噺={}锛屼笂闄�={}", formatPercent(currentLoad), formatPercent(config.circleMaxLoadLimit));
- return true;
- }
-
- if (needReserveLoopLoad) {
- double reserveLoad = loadGuardState.loadAfterReserve();
- if (reserveLoad >= config.circleMaxLoadLimit) {
- News.warn("棰勫崰鍚庢壙杞介噺杈惧埌涓婇檺锛屽凡鍋滄绔欑偣浠诲姟涓嬪彂銆傞鍗犲悗鎵胯浇閲�={}锛屼笂闄�={}", formatPercent(reserveLoad), formatPercent(config.circleMaxLoadLimit));
- return true;
- }
- }
- }
- return false;
- }
-
- private LoadGuardState buildLoadGuardState(DispatchLimitConfig config) {
- LoadGuardState state = new LoadGuardState();
- if (!config.loopModeEnable) {
- return state;
- }
-
- StationCycleCapacityVo capacityVo = stationCycleCapacityService.getLatestSnapshot();
- if (capacityVo == null) {
- return state;
- }
-
- state.totalStationCount = toNonNegative(capacityVo.getTotalStationCount());
- Integer occupiedStationCount = capacityVo.getOccupiedStationCount();
- state.projectedTaskStationCount = toNonNegative(occupiedStationCount != null ? occupiedStationCount : capacityVo.getTaskStationCount());
-
- List<StationCycleLoopVo> loopList = capacityVo.getLoopList();
- if (loopList != null) {
- for (StationCycleLoopVo loopVo : loopList) {
- if (loopVo == null || loopVo.getStationIdList() == null) {
- continue;
- }
- Integer loopNo = loopVo.getLoopNo();
- for (Integer stationId : loopVo.getStationIdList()) {
- if (stationId != null) {
- if (loopNo != null) {
- state.stationLoopNoMap.put(stationId, loopNo);
- }
- }
- }
- }
- }
- return state;
- }
-
- private LoopHitResult findPathLoopHit(DispatchLimitConfig config,
- Integer sourceStationId,
- Integer targetStationId,
- LoadGuardState loadGuardState) {
- return findPathLoopHit(config, sourceStationId, targetStationId, loadGuardState, null, null);
- }
-
- private LoopHitResult findPathLoopHit(DispatchLimitConfig config,
- Integer sourceStationId,
- Integer targetStationId,
- LoadGuardState loadGuardState,
- WrkMast wrkMast,
- Double pathLenFactor) {
- if (!config.loopModeEnable) {
- return LoopHitResult.NO_HIT;
- }
- if (sourceStationId == null || targetStationId == null) {
- return LoopHitResult.NO_HIT;
- }
- if (loadGuardState.stationLoopNoMap.isEmpty()) {
- return LoopHitResult.NO_HIT;
- }
-
- try {
- List<NavigateNode> nodes = wrkMast == null
- ? navigateUtils.calcByStationId(sourceStationId, targetStationId)
- : calcOutboundNavigatePath(wrkMast, sourceStationId, targetStationId, pathLenFactor);
- if (nodes == null || nodes.isEmpty()) {
- return LoopHitResult.NO_HIT;
- }
-
- for (NavigateNode node : nodes) {
- Integer stationId = getStationIdFromNode(node);
- if (stationId == null) {
- continue;
- }
- Integer loopNo = loadGuardState.stationLoopNoMap.get(stationId);
- if (loopNo != null) {
- return new LoopHitResult(true, loopNo, stationId);
- }
- }
- } catch (Exception e) {
- return LoopHitResult.NO_HIT;
- }
-
- return LoopHitResult.NO_HIT;
- }
-
- private Integer getStationIdFromNode(NavigateNode node) {
- if (node == null || isBlank(node.getNodeValue())) {
- return null;
- }
- try {
- JSONObject v = JSONObject.parseObject(node.getNodeValue());
- if (v == null) {
- return null;
- }
- return v.getInteger("stationId");
- } catch (Exception e) {
- return null;
- }
- }
-
- private int toNonNegative(Integer value) {
- if (value == null || value < 0) {
- return 0;
- }
- return value;
- }
-
- private Double normalizePathLenFactor(Double pathLenFactor) {
- if (pathLenFactor == null || pathLenFactor < 0.0d) {
- return 0.0d;
- }
- if (pathLenFactor > 1.0d) {
- return 1.0d;
- }
- return pathLenFactor;
- }
-
- private static class OutOrderDispatchDecision {
- private final Integer targetStationId;
- private final boolean circle;
- private final StationTaskLoopService.LoopEvaluation loopEvaluation;
- private final boolean countLoopIssue;
-
- private OutOrderDispatchDecision(Integer targetStationId, boolean circle) {
- this(targetStationId, circle, null, false);
- }
-
- private OutOrderDispatchDecision(Integer targetStationId,
- boolean circle,
- StationTaskLoopService.LoopEvaluation loopEvaluation,
- boolean countLoopIssue) {
- this.targetStationId = targetStationId;
- this.circle = circle;
- this.loopEvaluation = loopEvaluation;
- this.countLoopIssue = countLoopIssue;
- }
-
- private Integer getTargetStationId() {
- return targetStationId;
- }
-
- private boolean isCircle() {
- return circle;
- }
-
- private StationTaskLoopService.LoopEvaluation getLoopEvaluation() {
- return loopEvaluation;
- }
-
- private boolean shouldCountLoopIssue() {
- return countLoopIssue;
- }
- }
-
- private static class CircleTargetCandidate {
- private final Integer stationId;
- private final Integer pathLength;
- private final Integer offset;
-
- private CircleTargetCandidate(Integer stationId, Integer pathLength, Integer offset) {
- this.stationId = stationId;
- this.pathLength = pathLength == null ? 0 : pathLength;
- this.offset = offset == null ? 0 : offset;
- }
-
- private Integer getStationId() {
- return stationId;
- }
-
- private Integer getPathLength() {
- return pathLength;
- }
-
- private Integer getOffset() {
- return offset;
- }
- }
-
- private void saveLoopLoadReserve(Integer wrkNo, LoopHitResult loopHitResult) {
- if (wrkNo == null || wrkNo <= 0 || loopHitResult == null || !loopHitResult.isThroughLoop()) {
- return;
- }
- JSONObject reserveJson = new JSONObject();
- reserveJson.put("wrkNo", wrkNo);
- reserveJson.put("loopNo", loopHitResult.getLoopNo());
- reserveJson.put("hitStationId", loopHitResult.getHitStationId());
- reserveJson.put("createTime", System.currentTimeMillis());
- redisUtil.hset(RedisKeyType.STATION_CYCLE_LOAD_RESERVE.key, String.valueOf(wrkNo), reserveJson.toJSONString());
- redisUtil.expire(RedisKeyType.STATION_CYCLE_LOAD_RESERVE.key, LOOP_LOAD_RESERVE_EXPIRE_SECONDS);
- }
-
- private DispatchLimitConfig getDispatchLimitConfig(Integer startStationId, Integer endStationId) {
- DispatchLimitConfig config = new DispatchLimitConfig();
- Object systemConfigMapObj = redisUtil.get(RedisKeyType.SYSTEM_CONFIG_MAP.key);
- if (systemConfigMapObj instanceof Map) {
- Map<?, ?> systemConfigMap = (Map<?, ?>) systemConfigMapObj;
- config.circleMaxLoadLimit = parseLoadLimit(getConfigValue(systemConfigMap, "circleMaxLoadLimit"), config.circleMaxLoadLimit);
- String loopModeValue = getConfigValue(systemConfigMap, "circleLoopModeEnable");
- if (isBlank(loopModeValue)) {
- loopModeValue = getConfigValue(systemConfigMap, "circleModeEnable");
- }
- if (isBlank(loopModeValue)) {
- loopModeValue = getConfigValue(systemConfigMap, "isCircleMode");
- }
- config.loopModeEnable = parseBoolean(loopModeValue, config.loopModeEnable);
- }
-
- if (stationPathPolicyService != null && startStationId != null && endStationId != null) {
- try {
- StationPathResolvedPolicy resolvedPolicy = stationPathPolicyService.resolvePolicy(startStationId, endStationId);
- if (resolvedPolicy != null && resolvedPolicy.getProfileConfig() != null) {
- config.circleMaxLoadLimit = parseLoadLimit(String.valueOf(resolvedPolicy.getProfileConfig().getCircleMaxLoadLimit()), config.circleMaxLoadLimit);
- }
- } catch (Exception ignore) {
- }
- }
-
- return config;
- }
-
- private String getConfigValue(Map<?, ?> configMap, String key) {
- Object value = configMap.get(key);
- if (value == null) {
- return null;
- }
- return String.valueOf(value).trim();
- }
-
- private boolean parseBoolean(String value, boolean defaultValue) {
- if (isBlank(value)) {
- return defaultValue;
- }
- String lowValue = value.toLowerCase(Locale.ROOT);
- if ("y".equals(lowValue) || "yes".equals(lowValue) || "true".equals(lowValue)
- || "1".equals(lowValue) || "on".equals(lowValue)) {
- return true;
- }
- if ("n".equals(lowValue) || "no".equals(lowValue) || "false".equals(lowValue)
- || "0".equals(lowValue) || "off".equals(lowValue)) {
- return false;
- }
- return defaultValue;
- }
-
- private double parseLoadLimit(String value, double defaultValue) {
- if (isBlank(value)) {
- return defaultValue;
- }
- try {
- String normalized = value.replace("%", "").trim();
- double parsed = Double.parseDouble(normalized);
- if (parsed > 1.0) {
- parsed = parsed / 100.0;
- }
- if (parsed < 0.0) {
- return 0.0;
- }
- if (parsed > 1.0) {
- return 1.0;
- }
- return parsed;
- } catch (Exception e) {
- return defaultValue;
- }
- }
-
- private int parseInt(String value, int defaultValue) {
- if (isBlank(value)) {
- return defaultValue;
- }
- try {
- int parsed = Integer.parseInt(value.trim());
- return parsed < 0 ? defaultValue : parsed;
- } catch (Exception e) {
- return defaultValue;
- }
- }
-
- private String formatPercent(double value) {
- return String.format(Locale.ROOT, "%.1f%%", value * 100.0);
- }
-
- private boolean isBlank(String value) {
- return value == null || value.trim().isEmpty();
- }
-
- private static class DispatchLimitConfig {
- // 鍦堟渶澶ф壙杞借兘鍔涳紝榛樿80%
- private double circleMaxLoadLimit = 0.8d;
- // 鏄惁鍚敤缁曞湀妯″紡锛堜粎鍚敤鏃舵墠鐢熸晥鎵胯浇闄愬埗锛�
- private boolean loopModeEnable = false;
- }
-
- private static class LoadGuardState {
- private int totalStationCount = 0;
- private int projectedTaskStationCount = 0;
- private final Map<Integer, Integer> stationLoopNoMap = new HashMap<>();
-
- private double currentLoad() {
- return calcLoad(this.projectedTaskStationCount, this.totalStationCount);
- }
-
- private double loadAfterReserve() {
- return calcLoad(this.projectedTaskStationCount + 1, this.totalStationCount);
- }
-
- private void reserveLoopTask(Integer loopNo) {
- if (loopNo == null || loopNo <= 0) {
- return;
- }
- if (this.totalStationCount <= 0) {
- return;
- }
- this.projectedTaskStationCount++;
- }
-
- private double calcLoad(int taskCount, int stationCount) {
- if (stationCount <= 0 || taskCount <= 0) {
- return 0.0;
- }
- double load = (double) taskCount / (double) stationCount;
- if (load < 0.0) {
- return 0.0;
- }
- if (load > 1.0) {
- return 1.0;
- }
- return load;
- }
- }
-
- private static class LoopHitResult {
- private static final LoopHitResult NO_HIT = new LoopHitResult(false, null, null);
- private final boolean throughLoop;
- private final Integer loopNo;
- private final Integer hitStationId;
-
- private LoopHitResult(boolean throughLoop, Integer loopNo, Integer hitStationId) {
- this.throughLoop = throughLoop;
- this.loopNo = loopNo;
- this.hitStationId = hitStationId;
- }
-
- private boolean isThroughLoop() {
- return throughLoop;
- }
-
- private Integer getLoopNo() {
- return loopNo;
- }
-
- private Integer getHitStationId() {
- return hitStationId;
- }
- }
-
- private static class StationTaskIdleTrack {
- private Integer taskNo;
- private Integer stationId;
- private Long firstSeenTime;
-
- private StationTaskIdleTrack() {}
-
- private StationTaskIdleTrack(Integer taskNo, Integer stationId, Long firstSeenTime) {
- this.taskNo = taskNo;
- this.stationId = stationId;
- this.firstSeenTime = firstSeenTime;
- }
-
- private boolean isTimeout(int seconds) {
- if (firstSeenTime == null) {
- return false;
- }
- return System.currentTimeMillis() - firstSeenTime >= seconds * 1000L;
- }
-
- public Integer getTaskNo() {
- return taskNo;
- }
-
- public void setTaskNo(Integer taskNo) {
- this.taskNo = taskNo;
- }
-
- public Integer getStationId() {
- return stationId;
- }
-
- public void setStationId(Integer stationId) {
- this.stationId = stationId;
- }
-
- public Long getFirstSeenTime() {
- return firstSeenTime;
- }
-
- public void setFirstSeenTime(Long firstSeenTime) {
- this.firstSeenTime = firstSeenTime;
- }
- }
-
}
--
Gitblit v1.9.1