feat(跟价): 循环轮次卡死兜底回收,挂 stale-check 巡检线

跟价轮次的推进(下一店/下一轮/收尾)全部由前端页面驱动,页面一关就再没有
任何东西推进它,轮次永久停在 RUNNING。生产库存量 146 条 RUNNING 中 125 条
是这种僵尸,最早的可追溯到 4 月。

判据刻意不落在 loop_run.updated_at:子任务长跑期间轮次表根本不被刷新
(心跳只写 biz_file_task 与 Redis),正在正常跟价的轮次同样表现为 updated_at
陈旧,按它判死会误杀长任务。改为落在 active_task_id 指向的子任务上:
active 为空超阈值 / 子任务行不存在 → 判失败;子任务已终态但轮次没推进 →
复用 syncLoopRunAfterChildTerminal 补推进;子任务仍在跑则交给跟价子任务判死线。
用户已请求停止的一律落 STOPPED,与 dispatchNext 既有语义一致。

刻意不做自动续跑:跟价是写操作(会真实改价),让用户早已关掉页面的轮次
自己跑起来风险不可接受。
This commit is contained in:
2026-09-23 00:11:26 +08:00
parent d583585fa7
commit 8d73377b25
5 changed files with 527 additions and 4 deletions
@@ -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);
}
@@ -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),
@@ -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;
/**
* 跟价轮次卡死回收契约。
*
* <p>核心是「不能拿 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<String, Object> 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<String, Object> 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<String, Object> 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<String, Object> selectParams() {
ArgumentCaptor<Wrapper<PriceTrackLoopRunEntity>> captor = wrapperCaptor();
verify(loopRunMapper).selectList(captor.capture());
return paramsOf(captor.getValue());
}
private Map<String, Object> updateParams() {
ArgumentCaptor<Wrapper<PriceTrackLoopRunEntity>> captor = wrapperCaptor();
verify(loopRunMapper).update(isNull(), captor.capture());
return paramsOf(captor.getValue());
}
@SuppressWarnings("unchecked")
private static ArgumentCaptor<Wrapper<PriceTrackLoopRunEntity>> wrapperCaptor() {
return ArgumentCaptor.forClass(Wrapper.class);
}
/**
* 读取 wrapper 参数容器:MyBatis-Plus 是在生成 SQL 片段时才把参数写进
* paramNameValuePairs,故先触发一次。
*/
@SuppressWarnings("unchecked")
private static Map<String, Object> paramsOf(Wrapper<PriceTrackLoopRunEntity> wrapper) {
wrapper.getSqlSegment();
if (wrapper instanceof LambdaUpdateWrapper) {
((LambdaUpdateWrapper<PriceTrackLoopRunEntity>) wrapper).getSqlSet();
}
Map<String, Object> params =
(Map<String, Object>) ReflectionTestUtils.getField(wrapper, "paramNameValuePairs");
assertNotNull(params, "wrapper 参数容器字段名可能已变化(paramNameValuePairs)");
return params;
}
}