From 8d73377b25bbe2d37ea0e45445fcf90102f01d52 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E9=BB=84=E8=87=AA=E8=BE=BE?= <980324341@qq.com> Date: Wed, 23 Sep 2026 00:11:26 +0800 Subject: [PATCH] =?UTF-8?q?feat(=E8=B7=9F=E4=BB=B7):=20=E5=BE=AA=E7=8E=AF?= =?UTF-8?q?=E8=BD=AE=E6=AC=A1=E5=8D=A1=E6=AD=BB=E5=85=9C=E5=BA=95=E5=9B=9E?= =?UTF-8?q?=E6=94=B6=EF=BC=8C=E6=8C=82=20stale-check=20=E5=B7=A1=E6=A3=80?= =?UTF-8?q?=E7=BA=BF?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 跟价轮次的推进(下一店/下一轮/收尾)全部由前端页面驱动,页面一关就再没有 任何东西推进它,轮次永久停在 RUNNING。生产库存量 146 条 RUNNING 中 125 条 是这种僵尸,最早的可追溯到 4 月。 判据刻意不落在 loop_run.updated_at:子任务长跑期间轮次表根本不被刷新 (心跳只写 biz_file_task 与 Redis),正在正常跟价的轮次同样表现为 updated_at 陈旧,按它判死会误杀长任务。改为落在 active_task_id 指向的子任务上: active 为空超阈值 / 子任务行不存在 → 判失败;子任务已终态但轮次没推进 → 复用 syncLoopRunAfterChildTerminal 补推进;子任务仍在跑则交给跟价子任务判死线。 用户已请求停止的一律落 STOPPED,与 dispatchNext 既有语义一致。 刻意不做自动续跑:跟价是写操作(会真实改价),让用户早已关掉页面的轮次 自己跑起来风险不可接受。 --- .../service/DeleteBrandStaleTaskService.java | 10 +- .../PriceTrackLoopRunStaleService.java | 246 ++++++++++++++++ .../DeleteBrandStaleTaskServiceTest.java | 9 +- .../service/TaskModuleCoverageTest.java | 2 +- .../PriceTrackLoopRunStaleServiceTest.java | 264 ++++++++++++++++++ 5 files changed, 527 insertions(+), 4 deletions(-) create mode 100644 backend-java/src/main/java/com/nanri/aiimage/modules/pricetrack/service/PriceTrackLoopRunStaleService.java create mode 100644 backend-java/src/test/java/com/nanri/aiimage/modules/pricetrack/service/PriceTrackLoopRunStaleServiceTest.java diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/deletebrand/service/DeleteBrandStaleTaskService.java b/backend-java/src/main/java/com/nanri/aiimage/modules/deletebrand/service/DeleteBrandStaleTaskService.java index baeb27a38..8890b9a52 100644 --- a/backend-java/src/main/java/com/nanri/aiimage/modules/deletebrand/service/DeleteBrandStaleTaskService.java +++ b/backend-java/src/main/java/com/nanri/aiimage/modules/deletebrand/service/DeleteBrandStaleTaskService.java @@ -12,6 +12,7 @@ import com.nanri.aiimage.modules.queryasin.service.QueryAsinTaskService; import com.nanri.aiimage.modules.productrisk.service.ProductRiskTaskService; import com.nanri.aiimage.modules.patroldelete.service.PatrolDeleteTaskCacheService; import com.nanri.aiimage.modules.patroldelete.service.PatrolDeleteTaskService; +import com.nanri.aiimage.modules.pricetrack.service.PriceTrackLoopRunStaleService; import com.nanri.aiimage.modules.pricetrack.service.PriceTrackTaskCacheService; import com.nanri.aiimage.modules.pricetrack.service.PriceTrackTaskService; import com.nanri.aiimage.modules.similarasin.service.SimilarAsinTaskService; @@ -75,6 +76,8 @@ public class DeleteBrandStaleTaskService { private final ProductRiskTaskCacheService productRiskTaskCacheService; private final PriceTrackTaskService priceTrackTaskService; private final PriceTrackTaskCacheService priceTrackTaskCacheService; + /** 跟价循环批次(biz_price_track_loop_run)的卡死轮次兜底回收。 */ + private final PriceTrackLoopRunStaleService priceTrackLoopRunStaleService; private final ShopMatchTaskService shopMatchTaskService; private final ShopMatchTaskCacheService shopMatchTaskCacheService; private final PatrolDeleteTaskService patrolDeleteTaskService; @@ -112,6 +115,10 @@ public class DeleteBrandStaleTaskService { failStaleDeleteBrandTasks(); ProductRiskStaleCheckStats stats = failStaleProductRiskResolveTasks(); PriceTrackStaleCheckStats priceTrackStats = failStalePriceTrackTasks(); + // 跟价轮次(父实体)的卡死回收:上面那条只覆盖 biz_file_task 子任务, + // 轮次本身停 RUNNING 无人管(前端页面一关就再没有任何驱动) + PriceTrackLoopRunStaleService.StaleLoopRunStats priceTrackLoopStats = + priceTrackLoopRunStaleService.failStaleLoopRuns(); ShopMatchStaleCheckStats shopMatchStats = failStaleShopMatchTasks(); ShopMatchStaleCheckStats patrolDeleteStats = failStalePatrolDeleteTasks(); ShopMatchStaleCheckStats queryAsinStats = failStaleQueryAsinTasks(); @@ -126,9 +133,10 @@ public class DeleteBrandStaleTaskService { // 周期每 2 分钟一轮,各模块 summary 合并为单行,避免定期刷屏 // 注意:每段占位符数量必须与实参一致——此前每段 5 个占位符只传 4 个参数, // 导致 withdraw 之后的取值整体错位、末尾 elapsedMs/thread 打成字面量 - log.info("[stale-check] summary product-risk(s={} f={} x={} p={}) price-track(s={} f={} x={} p={}) shop-match(s={} f={} x={} p={}) patrol-delete(s={} f={} x={} p={}) query-asin(s={} f={} x={} p={}) withdraw(s={} f={} x={} p={}) no-upload(c={} f={} x={}) resume(s={} r={} k={} u={}) elapsedMs={} thread={}", + log.info("[stale-check] summary product-risk(s={} f={} x={} p={}) price-track(s={} f={} x={} p={}) price-track-loop(s={} f={} p={} r={} x={}) shop-match(s={} f={} x={} p={}) patrol-delete(s={} f={} x={} p={}) query-asin(s={} f={} x={} p={}) withdraw(s={} f={} x={} p={}) no-upload(c={} f={} x={}) resume(s={} r={} k={} u={}) elapsedMs={} thread={}", stats.scannedTaskCount, stats.finalizedTaskCount, stats.failedTaskCount, stats.skippedTaskCount, priceTrackStats.scannedTaskCount, priceTrackStats.finalizedTaskCount, priceTrackStats.failedTaskCount, priceTrackStats.skippedTaskCount, + priceTrackLoopStats.scannedLoopRunCount, priceTrackLoopStats.failedLoopRunCount, priceTrackLoopStats.stoppedLoopRunCount, priceTrackLoopStats.finalizedLoopRunCount, priceTrackLoopStats.skippedLoopRunCount, shopMatchStats.scannedTaskCount, shopMatchStats.finalizedTaskCount, shopMatchStats.failedTaskCount, shopMatchStats.skippedTaskCount, patrolDeleteStats.scannedTaskCount, patrolDeleteStats.finalizedTaskCount, patrolDeleteStats.failedTaskCount, patrolDeleteStats.skippedTaskCount, queryAsinStats.scannedTaskCount, queryAsinStats.finalizedTaskCount, queryAsinStats.failedTaskCount, queryAsinStats.skippedTaskCount, diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/pricetrack/service/PriceTrackLoopRunStaleService.java b/backend-java/src/main/java/com/nanri/aiimage/modules/pricetrack/service/PriceTrackLoopRunStaleService.java new file mode 100644 index 000000000..41a012a04 --- /dev/null +++ b/backend-java/src/main/java/com/nanri/aiimage/modules/pricetrack/service/PriceTrackLoopRunStaleService.java @@ -0,0 +1,246 @@ +package com.nanri.aiimage.modules.pricetrack.service; + +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper; +import com.nanri.aiimage.modules.pricetrack.mapper.PriceTrackLoopRunMapper; +import com.nanri.aiimage.modules.pricetrack.model.entity.PriceTrackLoopRunEntity; +import com.nanri.aiimage.modules.task.mapper.FileTaskMapper; +import com.nanri.aiimage.modules.task.model.entity.FileTaskEntity; +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.stereotype.Service; + +import java.time.LocalDateTime; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Locale; +import java.util.Map; +import java.util.Set; +import java.util.stream.Collectors; + +/** + * 跟价循环批次(biz_price_track_loop_run)「卡死轮次」的兜底回收。 + * + *

为什么需要:轮次的推进(下一店 / 下一轮 / 收尾)全部由前端页面驱动—— + * 前端在 while 循环里调 dispatch-next 拿子任务、轮询子任务结束后调 child-finished。 + * 页面一关这个驱动就没了,轮次会永久停在 RUNNING:既没有子任务在跑,也没有任何人 + * 来推进它。生产库 2026-09-22 存量 146 条 RUNNING,其中 125 条是这种僵尸, + * 最早的可追溯到 4 月。 + * + *

关键约束:不能拿 loop_run.updated_at 当判据。子任务长跑期间没有任何东西 + * 会刷新轮次表(心跳只写 biz_file_task 与 Redis 的 price-track:task:heartbeat), + * 所以一个正在正常跟价、子任务已跑了 36 小时的轮次,它的 updated_at 同样停在 + * 36 小时前——按 updated_at 判死会误杀长任务。判据必须落在 active_task_id 指向的 + * 那条子任务上。 + * + *

处置分四种: + *

+ * 子任务仍在 RUNNING 的轮次一律跳过:子任务自身由跟价子任务判死线 + * (DeleteBrandStaleTaskService.failStalePriceTrackTasks)负责,它转终态后本服务 + * 下一轮自然接住。 + * + *

刻意不做自动续跑:跟价是写操作(会真实改价),让一个用户早就关掉页面的 + * 轮次自己重新跑起来,风险不可接受。这也与 TaskResumeService 刻意排除写操作模块的 + * 原则一致。 + * + *

由 DeleteBrandStaleTaskService 的 stale-check 巡检线每 2 分钟调用一次 + * (沿用 P1-8 约定:委派式判死统一挂该线,不自建 @Scheduled)。 + */ +@Service +@RequiredArgsConstructor +@Slf4j +public class PriceTrackLoopRunStaleService { + + private static final String STATUS_RUNNING = "RUNNING"; + private static final String STATUS_FAILED = "FAILED"; + private static final String STATUS_STOPPED = "STOPPED"; + + /** 子任务终态集合,与 PriceTrackLoopRunService.isChildTaskTerminal 口径一致。 */ + private static final Set CHILD_TERMINAL_STATUSES = Set.of("SUCCESS", "FAILED", "STOPPED"); + + /** 单轮最多扫描的轮次数,其余留给下一轮(每 2 分钟一次),避免一次扫太多拖慢巡检。 */ + static final int MAX_LOOP_RUNS_PER_SCAN = 200; + + private final PriceTrackLoopRunMapper loopRunMapper; + private final FileTaskMapper fileTaskMapper; + private final PriceTrackLoopRunService loopRunService; + + /** + * 「轮次在等前端派发下一店」超过多少分钟算废弃(默认 120)。 + * + *

这个阈值等于「放弃等待用户回来」的时间:前端把轮次 id 存在 localStorage, + * 用户重新打开页面会自动 resume,所以只要没判死就还能接着跑;判死后用户再打开 + * 会看到失败,需要重新配置店铺重跑。取 2 小时是因为正常的两店间隔只有几秒 + * (前端 while 循环紧接着调 dispatch-next),2 小时足以排除任何正常瞬态。 + */ + @Value("${aiimage.price-track.loop-run-stale-minutes:120}") + private long staleMinutes = 120; + + /** + * 回收卡死的跟价轮次。 + * + * @return 单轮统计,合并进 stale-check 的 summary 日志 + */ + public StaleLoopRunStats failStaleLoopRuns() { + StaleLoopRunStats stats = new StaleLoopRunStats(); + long minutes = Math.max(1L, staleMinutes); + LocalDateTime now = LocalDateTime.now(); + LocalDateTime threshold = now.minusMinutes(minutes); + + // 候选取「RUNNING 且(active 为空但已陈旧,或 active 非空)」: + // active 为空且 updated_at 很新 = 前端正在两店之间正常派发(正常只持续几秒),绝不碰。 + List candidates = loopRunMapper.selectList( + new LambdaQueryWrapper() + .eq(PriceTrackLoopRunEntity::getStatus, STATUS_RUNNING) + .and(w -> w.isNull(PriceTrackLoopRunEntity::getActiveTaskId) + .lt(PriceTrackLoopRunEntity::getUpdatedAt, threshold) + .or().isNotNull(PriceTrackLoopRunEntity::getActiveTaskId)) + .last("limit " + MAX_LOOP_RUNS_PER_SCAN)); + stats.scannedLoopRunCount = candidates.size(); + if (candidates.isEmpty()) { + return stats; + } + + // 批量取子任务,避免逐条 selectById(候选最多 200 条) + Set childIds = candidates.stream() + .map(PriceTrackLoopRunEntity::getActiveTaskId) + .filter(id -> id != null && id > 0) + .collect(Collectors.toSet()); + Map childById = childIds.isEmpty() + ? Map.of() + : fileTaskMapper.selectBatchIds(childIds).stream() + .collect(Collectors.toMap(FileTaskEntity::getId, task -> task, + (a, b) -> a, LinkedHashMap::new)); + + log.info("[stale-check] price-track-loop candidates={} threshold={} staleMinutes={}", + candidates.size(), threshold, minutes); + + for (PriceTrackLoopRunEntity entity : candidates) { + try { + reclaimLoopRun(entity, childById, now, stats); + } catch (Exception ex) { + // 单条失败不影响其余:本轮跳过,2 分钟后下一轮自然重试 + stats.skippedLoopRunCount++; + log.warn("[stale-check] price-track-loop 回收单条失败 loopRunId={} msg={}", + entity.getId(), ex.getMessage(), ex); + } + } + return stats; + } + + /** 单条轮次的回收分流。 */ + private void reclaimLoopRun(PriceTrackLoopRunEntity entity, Map childById, + LocalDateTime now, StaleLoopRunStats stats) { + boolean stopRequested = Boolean.TRUE.equals(entity.getStopRequested()); + Long activeTaskId = entity.getActiveTaskId(); + + // ① active 为空:前端在两店之间停止了(正常只持续几秒,超过阈值说明页面已关且没再打开) + if (activeTaskId == null || activeTaskId <= 0) { + if (stopRequested) { + markStopped(entity, now, stats); + } else { + markFailed(entity, "循环长时间无进展(前端已停止派发下一店),已自动结束", now, stats); + } + return; + } + + FileTaskEntity child = childById.get(activeTaskId); + // ② 子任务行已不存在:事件链已断,用户回来也会在 child-finished 报「子任务不存在」 + if (child == null) { + if (stopRequested) { + markStopped(entity, now, stats); + } else { + markFailed(entity, "循环子任务已不存在,循环已自动结束", now, stats); + } + return; + } + + // ③ 子任务还在跑:判死交给跟价子任务判死线,本轮不动轮次(它终态后下一轮自然接住) + if (!isChildTerminal(child)) { + stats.skippedLoopRunCount++; + return; + } + + // ④ 子任务已终态但轮次仍 RUNNING:前端漏掉了那次 child-finished,服务端补推进 + if (stopRequested) { + // 停止意图优先于补推进(否则点完停止循环还会自己转起来) + markStopped(entity, now, stats); + return; + } + try { + loopRunService.syncLoopRunAfterChildTerminal(activeTaskId); + stats.finalizedLoopRunCount++; + log.info("[stale-check] price-track-loop 补推进漏掉的收尾 loopRunId={} childTaskId={} childStatus={}", + entity.getId(), activeTaskId, child.getStatus()); + } catch (Exception ex) { + // 补推进失败(子任务不属于该循环 / 上下文缺失等)→ 判死,不留孤儿 + markFailed(entity, "循环子任务收尾异常,循环已自动结束", now, stats); + log.warn("[stale-check] price-track-loop 补推进失败改判死 loopRunId={} childTaskId={} msg={}", + entity.getId(), activeTaskId, ex.getMessage()); + } + } + + private void markStopped(PriceTrackLoopRunEntity entity, LocalDateTime now, StaleLoopRunStats stats) { + if (casUpdateStatus(entity.getId(), STATUS_STOPPED, null, now)) { + stats.stoppedLoopRunCount++; + log.info("[stale-check] price-track-loop 回收为已停止 loopRunId={} userId={}", + entity.getId(), entity.getUserId()); + } else { + // 影响 0 行 = 这几秒内已被并发改写(前端刚好推进了轮次),不覆盖 + stats.skippedLoopRunCount++; + } + } + + private void markFailed(PriceTrackLoopRunEntity entity, String reason, LocalDateTime now, StaleLoopRunStats stats) { + if (casUpdateStatus(entity.getId(), STATUS_FAILED, reason, now)) { + stats.failedLoopRunCount++; + log.warn("[stale-check] price-track-loop 判失败 loopRunId={} userId={} round={}/{} shopIndex={} reason={}", + entity.getId(), entity.getUserId(), entity.getCurrentRound(), entity.getTargetRounds(), + entity.getCurrentShopIndex(), reason); + } else { + stats.skippedLoopRunCount++; + } + } + + /** + * 字段级 CAS 更新:只从 RUNNING 改。 + * + *

不用整行 updateById——那会拿读取时的快照覆盖并发写入的字段(前端在这几秒内 + * 刚好推进轮次、或用户刚好点了停止),既有 bindChildTask / requestStop 也出于同样 + * 原因走字段级更新。影响 0 行即视为已被并发改写,调用方按跳过处理。 + */ + private boolean casUpdateStatus(Long loopRunId, String status, String errorMessage, LocalDateTime now) { + return loopRunMapper.update(null, new LambdaUpdateWrapper() + .eq(PriceTrackLoopRunEntity::getId, loopRunId) + .eq(PriceTrackLoopRunEntity::getStatus, STATUS_RUNNING) + .set(PriceTrackLoopRunEntity::getStatus, status) + .set(PriceTrackLoopRunEntity::getActiveTaskId, null) + .set(PriceTrackLoopRunEntity::getErrorMessage, errorMessage) + .set(PriceTrackLoopRunEntity::getFinishedAt, now) + .set(PriceTrackLoopRunEntity::getUpdatedAt, now)) > 0; + } + + private static boolean isChildTerminal(FileTaskEntity child) { + String status = child.getStatus(); + return status != null && CHILD_TERMINAL_STATUSES.contains(status.trim().toUpperCase(Locale.ROOT)); + } + + /** 单轮统计(合并进 stale-check 的 summary 日志,避免定期刷屏)。 */ + public static final class StaleLoopRunStats { + public int scannedLoopRunCount; + /** 补推进(子任务已终态、轮次漏了收尾)的条数。 */ + public int finalizedLoopRunCount; + public int failedLoopRunCount; + public int stoppedLoopRunCount; + public int skippedLoopRunCount; + } +} diff --git a/backend-java/src/test/java/com/nanri/aiimage/modules/deletebrand/service/DeleteBrandStaleTaskServiceTest.java b/backend-java/src/test/java/com/nanri/aiimage/modules/deletebrand/service/DeleteBrandStaleTaskServiceTest.java index fa456fcd3..0786d33b2 100644 --- a/backend-java/src/test/java/com/nanri/aiimage/modules/deletebrand/service/DeleteBrandStaleTaskServiceTest.java +++ b/backend-java/src/test/java/com/nanri/aiimage/modules/deletebrand/service/DeleteBrandStaleTaskServiceTest.java @@ -11,6 +11,7 @@ import com.nanri.aiimage.modules.task.mapper.FileTaskMapper; import com.nanri.aiimage.modules.task.mapper.TaskScopeStateMapper; import com.nanri.aiimage.modules.task.model.dto.TaskScopeLastChunkDto; import com.nanri.aiimage.modules.task.model.entity.FileTaskEntity; +import com.nanri.aiimage.modules.pricetrack.service.PriceTrackLoopRunStaleService; import com.nanri.aiimage.modules.task.service.TaskDistributedLockService; import com.nanri.aiimage.modules.task.service.TaskFileJobService; import com.nanri.aiimage.modules.task.service.TaskHeartbeatPositionService; @@ -61,6 +62,7 @@ class DeleteBrandStaleTaskServiceTest { @Mock private ProductRiskTaskCacheService productRiskTaskCacheService; @Mock private TaskHeartbeatPositionService taskHeartbeatPositionService; @Mock private TaskResumeService taskResumeService; + @Mock private PriceTrackLoopRunStaleService priceTrackLoopRunStaleService; @BeforeAll static void initializeTableInfo() { @@ -379,6 +381,9 @@ class DeleteBrandStaleTaskServiceTest { // 续跑巡检在判死主流程里被调用:默认返回空统计(无中断任务可续跑); // 只有跑到 failStaleRunningTasks 的用例会用到,故 lenient lenient().when(taskResumeService.resumeInterruptedTasks()).thenReturn(new TaskResumeService.ResumeStats()); + // 跟价轮次兜底回收同样在判死主流程里被调用:默认返回空统计 + lenient().when(priceTrackLoopRunStaleService.failStaleLoopRuns()) + .thenReturn(new PriceTrackLoopRunStaleService.StaleLoopRunStats()); } private void noUploadTaskLockAvailable() { @@ -400,8 +405,8 @@ class DeleteBrandStaleTaskServiceTest { return new DeleteBrandStaleTaskService( fileTaskMapper, deleteBrandTaskCacheService, deleteBrandTaskStorageService, deleteBrandRunService, productRiskTaskService, productRiskTaskCacheService, - null, null, null, null, null, null, null, null, null, null, - null, null, null, + null, null, priceTrackLoopRunStaleService, null, null, null, null, null, null, null, + null, null, null, null, deleteBrandProgressProperties, null, taskDistributedLockService, taskFileJobService, null, taskScopeStateMapper, taskHeartbeatPositionService, taskResumeService); } diff --git a/backend-java/src/test/java/com/nanri/aiimage/modules/deletebrand/service/TaskModuleCoverageTest.java b/backend-java/src/test/java/com/nanri/aiimage/modules/deletebrand/service/TaskModuleCoverageTest.java index 05e76fe7e..0b3b5bf12 100644 --- a/backend-java/src/test/java/com/nanri/aiimage/modules/deletebrand/service/TaskModuleCoverageTest.java +++ b/backend-java/src/test/java/com/nanri/aiimage/modules/deletebrand/service/TaskModuleCoverageTest.java @@ -76,7 +76,7 @@ class TaskModuleCoverageTest { private static DeleteBrandStaleTaskService serviceForDelegatedChecks() { return new DeleteBrandStaleTaskService( null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, - null, + null, null, mock(BrandTaskService.class), mock(AppearancePatentTaskService.class), mock(SimilarAsinTaskService.class), diff --git a/backend-java/src/test/java/com/nanri/aiimage/modules/pricetrack/service/PriceTrackLoopRunStaleServiceTest.java b/backend-java/src/test/java/com/nanri/aiimage/modules/pricetrack/service/PriceTrackLoopRunStaleServiceTest.java new file mode 100644 index 000000000..ab8899d93 --- /dev/null +++ b/backend-java/src/test/java/com/nanri/aiimage/modules/pricetrack/service/PriceTrackLoopRunStaleServiceTest.java @@ -0,0 +1,264 @@ +package com.nanri.aiimage.modules.pricetrack.service; + +import com.baomidou.mybatisplus.core.MybatisConfiguration; +import com.baomidou.mybatisplus.core.conditions.Wrapper; +import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper; +import com.baomidou.mybatisplus.core.metadata.TableInfoHelper; +import com.nanri.aiimage.modules.pricetrack.mapper.PriceTrackLoopRunMapper; +import com.nanri.aiimage.modules.pricetrack.model.entity.PriceTrackLoopRunEntity; +import com.nanri.aiimage.modules.task.mapper.FileTaskMapper; +import com.nanri.aiimage.modules.task.model.entity.FileTaskEntity; +import org.apache.ibatis.builder.MapperBuilderAssistant; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.mockito.ArgumentCaptor; +import org.springframework.test.util.ReflectionTestUtils; + +import java.time.LocalDateTime; +import java.util.List; +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.isNull; +import static org.mockito.Mockito.doThrow; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +/** + * 跟价轮次卡死回收契约。 + * + *

核心是「不能拿 loop_run.updated_at 当判据」——子任务长跑期间轮次表不被刷新, + * 正在正常跟价的轮次同样表现为 updated_at 陈旧。判据必须落在 active_task_id 指向的 + * 那条子任务上(存在性 / 终态与否)。 + */ +class PriceTrackLoopRunStaleServiceTest { + + private final PriceTrackLoopRunMapper loopRunMapper = mock(PriceTrackLoopRunMapper.class); + private final FileTaskMapper fileTaskMapper = mock(FileTaskMapper.class); + private final PriceTrackLoopRunService loopRunService = mock(PriceTrackLoopRunService.class); + + @BeforeEach + void initTableInfo() { + // LambdaWrapper 需要实体列缓存,单测无 Spring/MyBatis 上下文,手动初始化 + MybatisConfiguration configuration = new MybatisConfiguration(); + TableInfoHelper.initTableInfo(new MapperBuilderAssistant(configuration, ""), PriceTrackLoopRunEntity.class); + TableInfoHelper.initTableInfo(new MapperBuilderAssistant(configuration, ""), FileTaskEntity.class); + } + + private PriceTrackLoopRunStaleService service() { + PriceTrackLoopRunStaleService svc = + new PriceTrackLoopRunStaleService(loopRunMapper, fileTaskMapper, loopRunService); + ReflectionTestUtils.setField(svc, "staleMinutes", 120L); + return svc; + } + + // ---------- ① active 为空:前端已停,等不到下一店派发 ---------- + + @Test + void active_为空时判失败并清掉_active_task_id() { + when(loopRunMapper.selectList(any())).thenReturn(List.of(loopRun(1L, null, false))); + when(loopRunMapper.update(isNull(), any())).thenReturn(1); + + PriceTrackLoopRunStaleService.StaleLoopRunStats stats = service().failStaleLoopRuns(); + + assertEquals(1, stats.failedLoopRunCount); + assertEquals(1, stats.scannedLoopRunCount); + Map params = updateParams(); + assertTrue(params.containsValue("FAILED"), "应落 FAILED:" + params); + assertTrue(params.containsValue("循环长时间无进展(前端已停止派发下一店),已自动结束")); + // active_task_id 必须一并置空:否则终态行仍指向一个旧子任务,后续反查会误命中 + assertTrue(params.values().stream().anyMatch(v -> v == null), "应清空 active_task_id:" + params); + } + + @Test + void 候选查询携带_updated_at_陈旧阈值_新鲜的空_active_不进候选() { + // 真实过滤发生在 SQL 层,此处断言谓词里确实带了阈值参数(漏了就会把正常瞬态也捞进来) + when(loopRunMapper.selectList(any())).thenReturn(List.of()); + + PriceTrackLoopRunStaleService.StaleLoopRunStats stats = service().failStaleLoopRuns(); + + assertEquals(0, stats.scannedLoopRunCount); + verify(loopRunMapper, never()).update(isNull(), any()); + Map params = selectParams(); + assertTrue(params.values().stream().anyMatch(v -> v instanceof LocalDateTime), + "候选查询应带 updated_at 阈值:" + params); + } + + // ---------- ② 子任务行已不存在:事件链断了 ---------- + + @Test + void 子任务行不存在时判失败() { + when(loopRunMapper.selectList(any())).thenReturn(List.of(loopRun(2L, 99L, false))); + when(fileTaskMapper.selectBatchIds(any())).thenReturn(List.of()); + when(loopRunMapper.update(isNull(), any())).thenReturn(1); + + PriceTrackLoopRunStaleService.StaleLoopRunStats stats = service().failStaleLoopRuns(); + + assertEquals(1, stats.failedLoopRunCount); + assertTrue(updateParams().containsValue("循环子任务已不存在,循环已自动结束")); + verify(loopRunService, never()).syncLoopRunAfterChildTerminal(any()); + } + + // ---------- ③ 子任务已终态:补推进 ---------- + + @Test + void 子任务已终态时补推进而不是判死() { + when(loopRunMapper.selectList(any())).thenReturn(List.of(loopRun(3L, 99L, false))); + when(fileTaskMapper.selectBatchIds(any())).thenReturn(List.of(child(99L, "SUCCESS"))); + + PriceTrackLoopRunStaleService.StaleLoopRunStats stats = service().failStaleLoopRuns(); + + assertEquals(1, stats.finalizedLoopRunCount); + assertEquals(0, stats.failedLoopRunCount); + verify(loopRunService).syncLoopRunAfterChildTerminal(99L); + verify(loopRunMapper, never()).update(isNull(), any()); + } + + @Test + void 补推进抛异常时改判死_不留孤儿() { + when(loopRunMapper.selectList(any())).thenReturn(List.of(loopRun(4L, 99L, false))); + when(fileTaskMapper.selectBatchIds(any())).thenReturn(List.of(child(99L, "FAILED"))); + doThrow(new IllegalStateException("子任务不属于当前循环")) + .when(loopRunService).syncLoopRunAfterChildTerminal(99L); + when(loopRunMapper.update(isNull(), any())).thenReturn(1); + + PriceTrackLoopRunStaleService.StaleLoopRunStats stats = service().failStaleLoopRuns(); + + assertEquals(1, stats.failedLoopRunCount); + assertTrue(updateParams().containsValue("循环子任务收尾异常,循环已自动结束")); + } + + // ---------- ④ 子任务仍在跑:交给子任务判死线,轮次不动 ---------- + + @Test + void 子任务仍在跑时跳过_绝不碰轮次() { + when(loopRunMapper.selectList(any())).thenReturn(List.of(loopRun(5L, 99L, false))); + when(fileTaskMapper.selectBatchIds(any())).thenReturn(List.of(child(99L, "RUNNING"))); + + PriceTrackLoopRunStaleService.StaleLoopRunStats stats = service().failStaleLoopRuns(); + + assertEquals(1, stats.skippedLoopRunCount); + assertEquals(0, stats.failedLoopRunCount); + verify(loopRunMapper, never()).update(isNull(), any()); + verify(loopRunService, never()).syncLoopRunAfterChildTerminal(any()); + } + + // ---------- 用户停止意图优先 ---------- + + @Test + void 用户已请求停止时落_STOPPED_而不是_FAILED() { + when(loopRunMapper.selectList(any())).thenReturn(List.of(loopRun(6L, null, true))); + when(loopRunMapper.update(isNull(), any())).thenReturn(1); + + PriceTrackLoopRunStaleService.StaleLoopRunStats stats = service().failStaleLoopRuns(); + + assertEquals(1, stats.stoppedLoopRunCount); + assertEquals(0, stats.failedLoopRunCount); + Map params = updateParams(); + assertTrue(params.containsValue("STOPPED"), "应落 STOPPED:" + params); + // stop_requested 本就是 true,无需(也不应)改写:只改状态与收尾字段 + assertTrue(!params.containsValue(false)); + } + + @Test + void 停止意图优先于补推进() { + when(loopRunMapper.selectList(any())).thenReturn(List.of(loopRun(7L, 99L, true))); + when(fileTaskMapper.selectBatchIds(any())).thenReturn(List.of(child(99L, "SUCCESS"))); + when(loopRunMapper.update(isNull(), any())).thenReturn(1); + + PriceTrackLoopRunStaleService.StaleLoopRunStats stats = service().failStaleLoopRuns(); + + assertEquals(1, stats.stoppedLoopRunCount); + // 否则点完「停止循环」还会自己转起来 + verify(loopRunService, never()).syncLoopRunAfterChildTerminal(any()); + } + + // ---------- CAS 并发保护 ---------- + + @Test + void CAS_影响0行时计入跳过_不谎报判死数() { + when(loopRunMapper.selectList(any())).thenReturn(List.of(loopRun(8L, null, false))); + // 这几秒内前端刚好推进了轮次,UPDATE 因 status 已不是 RUNNING 而影响 0 行 + when(loopRunMapper.update(isNull(), any())).thenReturn(0); + + PriceTrackLoopRunStaleService.StaleLoopRunStats stats = service().failStaleLoopRuns(); + + assertEquals(0, stats.failedLoopRunCount); + assertEquals(1, stats.skippedLoopRunCount); + } + + @Test + void 单条异常不影响其余条目() { + when(loopRunMapper.selectList(any())).thenReturn(List.of(loopRun(9L, null, false), loopRun(10L, null, false))); + when(loopRunMapper.update(isNull(), any())) + .thenThrow(new IllegalStateException("db down")) + .thenReturn(1); + + PriceTrackLoopRunStaleService.StaleLoopRunStats stats = service().failStaleLoopRuns(); + + assertEquals(1, stats.failedLoopRunCount); + assertEquals(1, stats.skippedLoopRunCount); + } + + // ---------- helpers ---------- + + private static PriceTrackLoopRunEntity loopRun(Long id, Long activeTaskId, boolean stopRequested) { + PriceTrackLoopRunEntity entity = new PriceTrackLoopRunEntity(); + entity.setId(id); + entity.setUserId(7L); + entity.setStatus("RUNNING"); + entity.setActiveTaskId(activeTaskId); + entity.setStopRequested(stopRequested); + entity.setCurrentRound(1); + entity.setTargetRounds(1); + entity.setCurrentShopIndex(0); + entity.setUpdatedAt(LocalDateTime.now().minusHours(3)); + return entity; + } + + private static FileTaskEntity child(Long id, String status) { + FileTaskEntity task = new FileTaskEntity(); + task.setId(id); + task.setModuleType("PRICE_TRACK"); + task.setStatus(status); + return task; + } + + private Map selectParams() { + ArgumentCaptor> captor = wrapperCaptor(); + verify(loopRunMapper).selectList(captor.capture()); + return paramsOf(captor.getValue()); + } + + private Map updateParams() { + ArgumentCaptor> captor = wrapperCaptor(); + verify(loopRunMapper).update(isNull(), captor.capture()); + return paramsOf(captor.getValue()); + } + + @SuppressWarnings("unchecked") + private static ArgumentCaptor> wrapperCaptor() { + return ArgumentCaptor.forClass(Wrapper.class); + } + + /** + * 读取 wrapper 参数容器:MyBatis-Plus 是在生成 SQL 片段时才把参数写进 + * paramNameValuePairs,故先触发一次。 + */ + @SuppressWarnings("unchecked") + private static Map paramsOf(Wrapper wrapper) { + wrapper.getSqlSegment(); + if (wrapper instanceof LambdaUpdateWrapper) { + ((LambdaUpdateWrapper) wrapper).getSqlSet(); + } + Map params = + (Map) ReflectionTestUtils.getField(wrapper, "paramNameValuePairs"); + assertNotNull(params, "wrapper 参数容器字段名可能已变化(paramNameValuePairs)"); + return params; + } +}