#log

Junjie

1 天以前 1cb18ad19e48be2b944b005db1b950a667725fc6

#log

 src/main/java/com/zy/common/utils/NavigateUtils.java

@@ -27,6 +27,7 @@
import com.zy.asrs.service.StationCycleCapacityService;
import com.zy.asrs.service.StationPathPolicyService;
import com.zy.core.News;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Scheduled;
import com.zy.core.model.StationObjModel;
import com.zy.core.model.command.StationCommand;
@@ -53,6 +54,7 @@
import java.util.LinkedHashMap;

@Component
@Slf4j
public class NavigateUtils {

    private static final long STATION_PATH_SLOW_LOG_THRESHOLD_MS = 500L;
@@ -111,29 +113,59 @@
                                                                 Integer endStationId,
                                                                 Integer currentTaskNo,
                                                                 Double pathLenFactor) {
        StationPathResolvedPolicy resolvedPolicy = resolveStationPathPolicy(startStationId, endStationId);
        StationPathRuntimeSnapshot runtimeSnapshot = loadStationPathRuntimeSnapshot(currentTaskNo);
        StationPathSearchContext context = buildStationPathSearchContext(
                startStationId,
                endStationId,
                resolvedPolicy,
                StationPathCalcMode.REROUTE,
                runtimeSnapshot
        );
        if (context.allList.isEmpty()) {
            return new ArrayList<>();
        }
        long totalStartNs = System.nanoTime();
        log.info("站点路径候选计算入口，startStationId={}，endStationId={}，taskNo={}，pathLenFactor={}",
                startStationId, endStationId, currentTaskNo, pathLenFactor);
        try {
            StationPathResolvedPolicy resolvedPolicy = resolveStationPathPolicy(startStationId, endStationId);
            log.info("站点路径候选策略解析完成，startStationId={}，endStationId={}，taskNo={}，matchedRule={}，ruleCode={}，profileCode={}，costMs={}",
                    startStationId,
                    endStationId,
                    currentTaskNo,
                    resolvedPolicy != null && resolvedPolicy.matchedRule(),
                    resolvedPolicy == null || resolvedPolicy.getRuleEntity() == null ? null : resolvedPolicy.getRuleEntity().getRuleCode(),
                    resolvedPolicy == null ? null : resolvedPolicy.getDefaultProfileCode(),
                    elapsedMillis(totalStartNs));
            StationPathRuntimeSnapshot runtimeSnapshot = loadStationPathRuntimeSnapshot(currentTaskNo);
            StationPathSearchContext context = buildStationPathSearchContext(
                    startStationId,
                    endStationId,
                    resolvedPolicy,
                    StationPathCalcMode.REROUTE,
                    runtimeSnapshot
            );
            if (context.allList.isEmpty()) {
                log.warn("站点路径候选计算结束，原因=empty_search_context，startStationId={}，endStationId={}，taskNo={}，totalCostMs={}",
                        startStationId, endStationId, currentTaskNo, elapsedMillis(totalStartNs));
                return new ArrayList<>();
            }

        List<List<NavigateNode>> orderedPathList = orderStationPathCandidates(
                context.allList,
                context.resolvedPolicy,
                currentTaskNo,
                pathLenFactor,
                startStationId,
                endStationId,
                runtimeSnapshot
        );
        return normalizeCandidatePaths(orderedPathList);
            long orderStartNs = System.nanoTime();
            List<List<NavigateNode>> orderedPathList = orderStationPathCandidates(
                    context.allList,
                    context.resolvedPolicy,
                    currentTaskNo,
                    pathLenFactor,
                    startStationId,
                    endStationId,
                    runtimeSnapshot
            );
            List<List<NavigateNode>> normalizedPathList = normalizeCandidatePaths(orderedPathList);
            log.info("站点路径候选计算结束，startStationId={}，endStationId={}，taskNo={}，rawCandidateCount={}，orderedPathCount={}，normalizedPathCount={}，orderCostMs={}，totalCostMs={}",
                    startStationId,
                    endStationId,
                    currentTaskNo,
                    context.allList.size(),
                    orderedPathList == null ? null : orderedPathList.size(),
                    normalizedPathList.size(),
                    elapsedMillis(orderStartNs),
                    elapsedMillis(totalStartNs));
            return normalizedPathList;
        } catch (Exception e) {
            log.error("站点路径候选计算异常，startStationId={}，endStationId={}，taskNo={}，pathLenFactor={}，costMs={}",
                    startStationId, endStationId, currentTaskNo, pathLenFactor, elapsedMillis(totalStartNs), e);
            throw e;
        }
    }

    public Map<Integer, Set<Integer>> loadUndirectedStationGraphSnapshot() {
@@ -2685,6 +2717,8 @@
        }
        Integer lev = startStation.getStationLev();
        stepCostMap.put("loadStartStation", elapsedMillis(stepStartNs));
        log.info("站点路径搜索上下文加载起点完成，startStationId={}，endStationId={}，mode={}，lev={}，costMs={}",
                startStationId, endStationId, calcMode, lev, stepCostMap.get("loadStartStation"));

        stepStartNs = System.nanoTime();
        NavigateSolution navigateSolution = new NavigateSolution();
@@ -2701,6 +2735,16 @@
            throw new CoolException("未找到该 终点 对应的节点");
        }
        stepCostMap.put("loadStationMapAndNode", elapsedMillis(stepStartNs));
        log.info("站点路径搜索上下文加载地图完成，startStationId={}，endStationId={}，mode={}，mapRows={}，startNode=({},{})，endNode=({},{})，costMs={}",
                startStationId,
                endStationId,
                calcMode,
                stationMap.size(),
                startNode.getX(),
                startNode.getY(),
                endNode.getX(),
                endNode.getY(),
                stepCostMap.get("loadStationMapAndNode"));

        stepStartNs = System.nanoTime();
        StationPathProfileConfig profileConfig = resolvedPolicy.getProfileConfig() == null
@@ -2717,6 +2761,14 @@
        int calcMaxPaths = safeInt(profileConfig.getCalcMaxPaths(), 500);
        int calcMaxCost = safeInt(profileConfig.getCalcMaxCost(), 300);
        List<Integer> guideStationSequence = buildGuideStationSequence(startStationId, endStationId, resolvedPolicy.getRuleConfig());
        log.info("站点路径候选枚举开始，startStationId={}，endStationId={}，mode={}，calcMaxDepth={}，calcMaxPaths={}，calcMaxCost={}，guideStationSequence={}",
                startStationId,
                endStationId,
                calcMode,
                calcMaxDepth,
                calcMaxPaths,
                calcMaxCost,
                JSON.toJSONString(guideStationSequence));
        stepStartNs = System.nanoTime();
        List<List<NavigateNode>> allList = navigateSolution.allSimplePaths(
                stationMap,
@@ -2729,6 +2781,12 @@
        );
        stepCostMap.put("allSimplePaths", elapsedMillis(stepStartNs));
        rawCandidateCount = allList.size();
        log.info("站点路径候选枚举完成，startStationId={}，endStationId={}，mode={}，rawCandidateCount={}，costMs={}",
                startStationId,
                endStationId,
                calcMode,
                rawCandidateCount,
                stepCostMap.get("allSimplePaths"));
        if (allList.isEmpty()) {
            logStationPathSearchContextSlow(startStationId, endStationId, calcMode, lev, rawCandidateCount, filteredCandidateCount, stepCostMap, totalStartNs);
            return StationPathSearchContext.empty(resolvedPolicy);
@@ -2738,6 +2796,14 @@
        allList = filterNonAutoStationPaths(allList, statusMap);
        stepCostMap.put("filterNonAutoStation", elapsedMillis(stepStartNs));
        filteredCandidateCount = allList.size();
        log.info("站点路径候选自动状态过滤完成，startStationId={}，endStationId={}，mode={}，rawCandidateCount={}，filteredCandidateCount={}，statusCount={}，costMs={}",
                startStationId,
                endStationId,
                calcMode,
                rawCandidateCount,
                filteredCandidateCount,
                statusMap.size(),
                stepCostMap.get("filterNonAutoStation"));
        if (allList.isEmpty()) {
            News.info("[WCS Debug] 站点路径候选全部被过滤，存在非自动站点,startStationId={},endStationId={}", startStationId, endStationId);
            logStationPathSearchContextSlow(startStationId, endStationId, calcMode, lev, rawCandidateCount, filteredCandidateCount, stepCostMap, totalStartNs);

 src/main/java/com/zy/core/thread/impl/ZyStationV5Thread.java

@@ -311,8 +311,16 @@
                loopEvaluation.getLoopIdentity().getScopeType(),
                loopEvaluation.getLoopIdentity().getLocalStationCount(),
                loopEvaluation.getLoopIdentity().getSourceLoopStationCount());
        log.info("输送线堵塞重规划候选路径计算开始，taskNo={}, stationId={}, targetStationId={}, pathLenFactor={}",
                taskNo, stationId, targetStationId, pathLenFactor);
        List<List<NavigateNode>> candidatePathList = calcCandidatePathNavigateNodes(taskNo, stationId, targetStationId, pathLenFactor);
        long candidatePathNs = System.nanoTime();
        log.info("输送线堵塞重规划候选路径计算完成，taskNo={}, stationId={}, targetStationId={}, candidatePathCount={}, costMs={}",
                taskNo,
                stationId,
                targetStationId,
                candidatePathList == null ? null : candidatePathList.size(),
                nanosToMillis(candidatePathNs - loopEvalNs));
        List<StationCommand> candidateCommandList = new ArrayList<>();
        for (List<NavigateNode> candidatePath : candidatePathList) {
            StationCommand rerouteCommand = buildMoveCommand(taskNo, stationId, targetStationId, palletSize, candidatePath);
@@ -322,6 +330,14 @@
            candidateCommandList.add(rerouteCommand);
        }
        long buildCommandNs = System.nanoTime();
        log.info("输送线堵塞重规划候选命令构建完成，taskNo={}, stationId={}, targetStationId={}, candidatePathCount={}, candidateCommandCount={}, costMs={}, firstCommandPath={}",
                taskNo,
                stationId,
                targetStationId,
                candidatePathList == null ? null : candidatePathList.size(),
                candidateCommandList.size(),
                nanosToMillis(buildCommandNs - candidatePathNs),
                JSON.toJSONString(firstCommandPath(candidateCommandList)));

        StationV5RunBlockReroutePlanner.PlanResult planResult = runBlockReroutePlanner.plan(
                taskNo,
@@ -330,6 +346,14 @@
                candidateCommandList
        );
        long planNs = System.nanoTime();
        log.info("输送线堵塞重规划planner完成，taskNo={}, stationId={}, targetStationId={}, planCount={}, selected={}, issuedRouteCount={}, costMs={}",
                taskNo,
                stationId,
                targetStationId,
                planResult == null ? null : planResult.getPlanCount(),
                planResult != null && planResult.getCommand() != null,
                planResult == null || planResult.getIssuedRoutePathList() == null ? null : planResult.getIssuedRoutePathList().size(),
                nanosToMillis(planNs - buildCommandNs));
        logRunBlockRerouteCost(taskNo,
                stationId,
                targetStationId,
@@ -349,7 +373,11 @@
        StationCommand rerouteCommand = planResult.getCommand();
        if (rerouteCommand != null) {
            if (taskLoopService != null) {
                log.info("输送线堵塞重规划记录环线开始，taskNo={}, stationId={}, targetStationId={}",
                        taskNo, stationId, targetStationId);
                taskLoopService.recordLoopIssue(loopEvaluation, "RUN_BLOCK_REROUTE");
                log.info("输送线堵塞重规划记录环线完成，taskNo={}, stationId={}, targetStationId={}",
                        taskNo, stationId, targetStationId);
            }
            log.info("输送线堵塞重规划选中候选路线，taskNo={}, planCount={}, stationId={}, targetStationId={}, route={}",
                    taskNo, planResult.getPlanCount(), stationId, targetStationId, JSON.toJSONString(rerouteCommand.getNavigatePath()));
@@ -365,6 +393,17 @@
        return null;
    }

    private List<Integer> firstCommandPath(List<StationCommand> candidateCommandList) {
        if (candidateCommandList == null || candidateCommandList.isEmpty()) {
            return new ArrayList<>();
        }
        StationCommand firstCommand = candidateCommandList.get(0);
        if (firstCommand == null || firstCommand.getNavigatePath() == null) {
            return new ArrayList<>();
        }
        return firstCommand.getNavigatePath();
    }

    @Override
    public boolean clearPath(Integer taskNo) {
        if (taskNo == null || taskNo <= 0) {

 src/main/java/com/zy/core/utils/station/StationRerouteProcessor.java

@@ -83,15 +83,22 @@
    private NavigateUtils navigateUtils;

    public void checkStationRunBlock(BasDevp basDevp, Integer stationId) {
        Integer taskNoForLog = null;
        try {
            if (basDevp == null || basDevp.getDevpNo() == null || stationId == null) {
                log.warn("输送站点运行堵塞重规划跳过，原因=missing_input，deviceNo={}，stationId={}",
                        basDevp == null ? null : basDevp.getDevpNo(), stationId);
                return;
            }
            if (shouldSkipRunBlockStation(basDevp, stationId)) {
                log.info("输送站点运行堵塞重规划跳过，原因=skip_station，deviceNo={}，stationId={}",
                        basDevp.getDevpNo(), stationId);
                return;
            }
            StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basDevp.getDevpNo());
            if (stationThread == null) {
                log.warn("输送站点运行堵塞重规划跳过，原因=missing_station_thread，deviceNo={}，stationId={}",
                        basDevp.getDevpNo(), stationId);
                return;
            }

@@ -102,8 +109,24 @@
                    || !stationProtocol.isLoading()
                    || stationProtocol.getTaskNo() <= 0
                    || !stationProtocol.isRunBlock()) {
                log.info("输送站点运行堵塞重规划跳过，原因=status_not_match，deviceNo={}，stationId={}，autoing={}，loading={}，taskNo={}，runBlock={}，targetStaNo={}",
                        basDevp.getDevpNo(),
                        stationId,
                        stationProtocol == null ? null : stationProtocol.isAutoing(),
                        stationProtocol == null ? null : stationProtocol.isLoading(),
                        stationProtocol == null ? null : stationProtocol.getTaskNo(),
                        stationProtocol == null ? null : stationProtocol.isRunBlock(),
                        stationProtocol == null ? null : stationProtocol.getTargetStaNo());
                return;
            }
            taskNoForLog = stationProtocol.getTaskNo();
            log.info("输送站点运行堵塞重规划入口，deviceNo={}，stationId={}，taskNo={}，protocolTargetStaNo={}，taskWriteIdx={}，bufferCommandCount={}",
                    basDevp.getDevpNo(),
                    stationProtocol.getStationId(),
                    taskNoForLog,
                    stationProtocol.getTargetStaNo(),
                    stationProtocol.getTaskWriteIdx(),
                    countCurrentTaskBufferCommands(stationProtocol.getTaskBufferItems(), taskNoForLog));

            List<Integer> runBlockReassignLocStationList = new ArrayList<>();
            for (StationObjModel stationObjModel : basDevp.getRunBlockReassignLocStationList$()) {
@@ -119,11 +142,18 @@

            Object lock = redisUtil.get(RedisKeyType.CHECK_STATION_RUN_BLOCK_LIMIT_.key + stationProtocol.getTaskNo());
            if (lock != null) {
                log.info("输送站点运行堵塞重规划跳过，原因=limit_lock，deviceNo={}，stationId={}，taskNo={}",
                        basDevp.getDevpNo(), stationProtocol.getStationId(), stationProtocol.getTaskNo());
                return;
            }
            redisUtil.set(RedisKeyType.CHECK_STATION_RUN_BLOCK_LIMIT_.key + stationProtocol.getTaskNo(), "lock", 30);

            if (shouldUseRunBlockDirectReassign(wrkMast, stationProtocol.getStationId(), runBlockReassignLocStationList)) {
                log.info("输送站点运行堵塞重规划进入直分支，deviceNo={}，stationId={}，taskNo={}，runBlockReassignStations={}",
                        basDevp.getDevpNo(),
                        stationProtocol.getStationId(),
                        stationProtocol.getTaskNo(),
                        JSON.toJSONString(runBlockReassignLocStationList));
                if (stationMoveCoordinator != null) {
                    stationMoveCoordinator.withTaskDispatchLock(stationProtocol.getTaskNo(),
                            () -> {
@@ -150,9 +180,20 @@
                    .withSuppressDispatchGuard()
                    .withCancelSessionBeforeDispatch()
                    .withResetSegmentCommandsBeforeDispatch();
            executeSharedReroute(context);
            RerouteExecutionResult result = executeSharedReroute(context);
            log.info("输送站点运行堵塞重规划结束，deviceNo={}，stationId={}，taskNo={}，skipped={}，skipReason={}，dispatched={}，clearedCommandCount={}",
                    basDevp.getDevpNo(),
                    stationProtocol.getStationId(),
                    stationProtocol.getTaskNo(),
                    result == null ? null : result.skipped(),
                    result == null ? null : result.skipReason(),
                    result == null ? null : result.dispatched(),
                    result == null ? null : result.clearedCommandCount());
        } catch (Exception e) {
            e.printStackTrace();
            log.error("输送站点运行堵塞重规划异常，deviceNo={}，stationId={}，taskNo={}，error={}",
                    basDevp == null ? null : basDevp.getDevpNo(), stationId, taskNoForLog, e.toString());
            log.error("checkStationRunBlock error, deviceNo={}, stationId={}, taskNo={}",
                    basDevp == null ? null : basDevp.getDevpNo(), stationId, taskNoForLog, e);
        }
    }