fix(task-retry): 原件被迟到回传复活后停掉重复子任务,避免同一份活跑两遍

现网 2026-10-22 实测到一对:子任务 31857 RUNNING,而它的原件 31751 也被迟到回传拉回 RUNNING
(SimilarAsinStaleReopenSupport 那一路)。重试面放宽到「所有 FAILED」之后,心跳超时这类
**可翻转的判死**就接到了真金白银上——两遍抓取+两遍 LLM 计费,烧的是用户本人额度。

清账做在巡检开头而不是复活路径里:复活支持是在 SimilarAsinTaskService(基线点名的 1936 行长文件)
现场 new 的,多一个依赖就得动它;而「父子两条都活着=重复劳动」与模块无关,收在这里一次覆盖
所有复活入口,顺带收掉存量对,代价是最长滞后一个巡检周期(2 分钟)。留原件停子任务:复活是客户端
拿着真实分片回来触发的,数据在原件上。

状态取 FAILED 而非 CANCELLED,照 ExpiredAccountTaskStopService 的先例:TaskResultAdmission 只对
FINISHED_ORDERED(SUCCESS/FAILED) 带 40901,客户端据此才删本地副本收口;取消态不在那张表里,
被领走的子任务会陷入「永远送不进也不放手」的补发循环(10-11 那起单设备 14,906 行/天的病理)。
因此 TaskRetryEligibility 补第四类 STOPPED,文案直接引 DUPLICATE_STOP_REASON 常量而非抄字面量——
两处各写一遍,改一处就静默失效、双跑被自己捡回来。

LIVE_STATUSES 引用 TaskStatuses.FileTask 常量:状态词表棘轮判的就是新增内联状态集合字面量,
被它管的对象不该另立一份(这是全量跑出来的红,局部三支类测不到)。

验证:后端全量 4677 例 / 0 红 / 17 skip,rc=0;新增 3 例契约(停对、原件仍 FAILED 时一条都不许停、
dryRun 只数不落库)+ 2 例判据。变异验证:摘掉两处调用点 ⇒ 失败数 1→2,非空跑。
This commit is contained in:
2026-10-22 14:12:44 +08:00
parent cac901df34
commit 973128216a
5 changed files with 239 additions and 11 deletions
@@ -15,6 +15,8 @@ public class TaskRetryBatchVo {
private int skippedExisting;
private int skippedForceMajeure;
private int failed;
/** 本轮停掉的「原件已复活」重复子任务数(dryRun 下是"将会停")。 */
private int stoppedDuplicateChildren;
private List<Long> candidateTaskIds;
private List<Long> retriedTaskIds;
@@ -26,6 +28,7 @@ public class TaskRetryBatchVo {
vo.setSkippedExisting(stats.skippedTaskCount);
vo.setSkippedForceMajeure(stats.forceMajeureSkippedCount);
vo.setFailed(stats.cloneFailedCount);
vo.setStoppedDuplicateChildren(stats.stoppedDuplicateChildCount);
vo.setCandidateTaskIds(List.copyOf(stats.candidateTaskIds));
vo.setRetriedTaskIds(List.copyOf(stats.retriedTaskIds));
return vo;
@@ -1,6 +1,8 @@
package com.nanri.aiimage.modules.task.service;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.nanri.aiimage.common.task.TaskStatuses;
import com.nanri.aiimage.modules.task.mapper.FileTaskMapper;
import com.nanri.aiimage.modules.task.model.entity.FileTaskEntity;
import com.nanri.aiimage.modules.task.spi.ClientTaskRetrySpi;
@@ -26,8 +28,9 @@ import java.util.Set;
* 实测 19 条续跑任务全部失败(长时间无心跳 / 结果为空 / 长期未被领取),根因即此。
* 现在由各模块的 {@link ClientTaskRetrySpi} 负责把解析输入与载荷一起克隆过去。
*
* <p>不可抗力不重试:LLM 密钥/代理 IP 欠费、服务宕机、账号自动登录失败等,重跑不会改变结果,
* 还会白烧外部额度。判据集中在 {@link TaskRetryEligibility}。
* <p>不重试的两类:一是不可抗力——LLM 密钥/代理 IP 欠费、服务宕机、账号自动登录失败等,
* 重跑不会改变结果,还会白烧外部额度;二是系统自己刚停掉的重复子任务(见
* {@link #DUPLICATE_STOP_REASON}),再克隆等于把双跑捡回来。判据都集中在 {@link TaskRetryEligibility}。
*
* <p>幂等:同一原任务已有重试子任务({@code resume_of_task_id} 反查)则跳过,重复扫描安全。
* 代数封顶写在 {@code biz_file_task.resume_attempt}(V129),沿重试链递增。
@@ -38,6 +41,28 @@ public class TaskResumeService {
private static final String STATUS_FAILED = "FAILED";
private static final String CLIENT_INTERRUPT_PREFIX = "客户端异常中断";
/**
* 还没被领走/正在跑的活。原件落在这两态时,它的重试子任务就是同一份活的第二份。
* 取 {@link TaskStatuses} 而不是写字面量:状态词表棘轮({@code TaskStatusVocabularyRatchetTest})
* 判的就是"新增内联状态集合字面量",这里本来就是被它管的对象,不该另立一份。
*/
private static final List<String> LIVE_STATUSES =
List.of(TaskStatuses.FileTask.PENDING, TaskStatuses.FileTask.RUNNING);
/**
* 停掉重复子任务时写的文案。判据集中在 {@link TaskRetryEligibility}:这条文案命中即不再克隆,
* 否则"停掉一份"会被下一轮巡检重新克隆成两份,收口动作自己喂自己。
*
* <p>状态取 FAILED 而不是 CANCELLED,是有意的(照 {@code ExpiredAccountTaskStopService} 的先例):
* 客户端补发结果时 {@code TaskResultAdmission} 只对 {@code FINISHED_ORDERED}(SUCCESS/FAILED)带 40901,
* 异常处理器据此回 {@code success=true} 让客户端删本地副本收口;取消态不在那张表里,
* 已被领走的子任务会陷入"永远送不进、也永远不放手"的补发循环——就是 10-11 那起单设备
* 一天 14,906 行的洪水病理。FAILED 会让这份数据作废,但这一份本来就是重复劳动。
*/
public static final String DUPLICATE_STOP_REASON = "原件已被迟到回传复活,重复的重试子任务已停止";
/** 每轮最多清多少对:重试子任务存量是几十的量级,这里只是给失控时兜个底。 */
private static final int DUPLICATE_SWEEP_LIMIT = 200;
private final FileTaskMapper fileTaskMapper;
/** moduleType → 克隆重试实现;只有注册了本 SPI 的模块才会自动重试。 */
@@ -111,6 +136,8 @@ public class TaskResumeService {
LocalDateTime cutoff = LocalDateTime.now().minusMinutes(Math.max(1L, windowMinutes));
stats.ran = true;
int safeLimit = Math.max(1, limit);
// 清账先于建单:本轮若把"原件复活了"这件事读成"还能再克隆一个",双跑就自己造出来了。
stopDuplicateChildren(false, stats);
stats.unsupportedTaskCount = countUnsupportedInterrupts(cutoff);
return retryFailedSince(cutoff, safeLimit, false, retryHandlers.keySet(), stats);
}
@@ -137,6 +164,7 @@ public class TaskResumeService {
int safeLimit = Math.max(1, Math.min(limit, 500));
LocalDateTime cutoff = LocalDateTime.now().minusHours(safeHours);
stats.ran = true;
stopDuplicateChildren(dryRun, stats);
stats.unsupportedTaskCount = countUnsupportedInterrupts(cutoff);
log.warn("[task-resume] 回填开始 dryRun={} sinceHours={} limit={} types={}",
dryRun, safeHours, safeLimit, types);
@@ -173,12 +201,14 @@ public class TaskResumeService {
stats.skippedTaskCount++;
continue;
}
TaskRetryEligibility.Category forceMajeure =
TaskRetryEligibility.Category notRetryable =
TaskRetryEligibility.forceMajeureCategory(original.getErrorMessage());
if (forceMajeure != null) {
if (notRetryable != null) {
stats.forceMajeureSkippedCount++;
log.info("[task-resume] 不可抗力不重试 taskId={} moduleType={} category={} reason={}",
original.getId(), original.getModuleType(), forceMajeure,
// 这句不再自称"不可抗力":category=STOPPED 是我们自己停的,写成不可抗力会把运维
// 引向"去查欠费和上游",而该查的是双跑收口(B14)。
log.info("[task-resume] 不重试 taskId={} moduleType={} category={} reason={}",
original.getId(), original.getModuleType(), notRetryable,
abbreviate(original.getErrorMessage()));
continue;
}
@@ -220,10 +250,10 @@ public class TaskResumeService {
private void logRetrySummary(ResumeStats stats, LocalDateTime cutoff, int safeLimit) {
log.info("[task-resume] 本轮完成 dryRun={} cutoff={} limit={} scanned={} retried={} skippedExisting={} "
+ "skippedForceMajeure={} cloneFailed={} unsupportedInterrupts={}",
+ "skippedForceMajeure={} cloneFailed={} unsupportedInterrupts={} stoppedDuplicate={}",
stats.dryRun, cutoff, safeLimit, stats.scannedTaskCount, stats.resumedTaskCount,
stats.skippedTaskCount, stats.forceMajeureSkippedCount, stats.cloneFailedCount,
stats.unsupportedTaskCount);
stats.unsupportedTaskCount, stats.stoppedDuplicateChildCount);
}
/**
@@ -257,6 +287,69 @@ public class TaskResumeService {
return count != null && count > 0;
}
/**
* 幂等清账:原件被迟到回传复活(FAILED→RUNNING)之后,停掉它名下仍活着的重试子任务。
*
* <p>为什么做在巡检里、而不是塞进复活路径:{@code SimilarAsinStaleReopenSupport} 是在
* {@code SimilarAsinTaskService} 里现场 new 出来的,多一个依赖就得动那个 1900+ 行的类
* (它在可读性基线里是被点名的对象);而"父子两条都活着=重复劳动"这个口径与模块无关,
* 收在这里一次覆盖所有复活入口,还顺带把已有的存量对子收掉。代价是最长滞后一个巡检周期(2 分钟)。
*
* <p>留原件、停子任务:复活是客户端拿着真实分片回来触发的,那份数据在原件上;子任务只是重复的一份。
*
* @return 实际落库停止的条数;dryRun 下只计数不落库,返回 0
*/
private int stopDuplicateChildren(boolean dryRun, ResumeStats stats) {
List<FileTaskEntity> liveChildren = fileTaskMapper.selectList(new LambdaQueryWrapper<FileTaskEntity>()
.isNotNull(FileTaskEntity::getResumeOfTaskId)
.in(FileTaskEntity::getStatus, LIVE_STATUSES)
.orderByAsc(FileTaskEntity::getId)
.last("limit " + DUPLICATE_SWEEP_LIMIT));
if (liveChildren == null || liveChildren.isEmpty()) {
return 0;
}
Set<Long> originIds = new LinkedHashSet<>();
for (FileTaskEntity child : liveChildren) {
// 查询已按 isNotNull 收窄,但这里再挡一次:别拿 null 去拼 selectBatchIds。
if (child.getResumeOfTaskId() != null) {
originIds.add(child.getResumeOfTaskId());
}
}
if (originIds.isEmpty()) {
return 0;
}
Map<Long, String> originStatuses = new LinkedHashMap<>();
for (FileTaskEntity origin : fileTaskMapper.selectBatchIds(originIds)) {
originStatuses.put(origin.getId(), origin.getStatus());
}
int stopped = 0;
for (FileTaskEntity child : liveChildren) {
String originStatus = originStatuses.get(child.getResumeOfTaskId());
if (originStatus == null || !LIVE_STATUSES.contains(originStatus)) {
continue;
}
stats.stoppedDuplicateChildCount++;
if (dryRun) {
continue;
}
// 带状态条件的 CAS:子任务可能就在这一秒自己跑完,那时它不该被动成 FAILED。
int updated = fileTaskMapper.update(null, new LambdaUpdateWrapper<FileTaskEntity>()
.eq(FileTaskEntity::getId, child.getId())
.in(FileTaskEntity::getStatus, LIVE_STATUSES)
.set(FileTaskEntity::getStatus, STATUS_FAILED)
.set(FileTaskEntity::getErrorMessage, DUPLICATE_STOP_REASON)
.set(FileTaskEntity::getFinishedAt, LocalDateTime.now())
.set(FileTaskEntity::getUpdatedAt, LocalDateTime.now()));
if (updated == 1) {
stopped++;
log.warn("[task-resume] 原件复活⇒停掉重复子任务 original={} 原件状态={} child={} 代数={}/{}",
child.getResumeOfTaskId(), originStatus, child.getId(),
child.getResumeAttempt(), maxAttempt);
}
}
return stopped;
}
private Set<String> resolveRequestedTypes(List<String> requested) {
Set<String> types = new LinkedHashSet<>();
if (requested == null || requested.isEmpty()) {
@@ -291,10 +384,16 @@ public class TaskResumeService {
public int skippedTaskCount;
/** 未注册克隆实现的中断任务数(仅计数,供运维人工重跑)。 */
public int unsupportedTaskCount;
/** 命中不可抗力(欠费/服务宕机/登录不可用)而跳过的数量。 */
/**
* 命中"不重试"判据而跳过的数量:欠费/服务宕机/登录不可用,加上系统自己停掉的重复子任务。
* 字段名沿用 forceMajeure 是历史包袱——改它要牵动 {@code TaskRetryBatchVo} 的 JSON 键与巡检口径,
* 不值这一动;语义以 {@link TaskRetryEligibility.Category} 全集为准。
*/
public int forceMajeureSkippedCount;
/** 克隆过程中失败的数量(缺解析输入、库异常等)。 */
public int cloneFailedCount;
/** 原件已复活、于是被停掉的重复子任务数(dryRun 下是"将会停")。 */
public int stoppedDuplicateChildCount;
/** dry-run 下本可克隆的原任务 id。 */
public final List<Long> candidateTaskIds = new ArrayList<>();
/** 实际克隆出的新任务 id。 */
@@ -21,7 +21,9 @@ public final class TaskRetryEligibility {
/** 上游服务不可用/宕机/连接被拒:等服务恢复。 */
SERVICE_DOWN("服务不可用"),
/** 账号未登录且自动登录失败:等用户重新登录。 */
CREDENTIAL("账号或登录不可用");
CREDENTIAL("账号或登录不可用"),
/** 系统主动停掉的重复子任务:它不是"失败了要重跑",而是"这一份不该再跑",再克隆等于把双跑捡回来。 */
STOPPED("重复子任务已停止");
private final String label;
@@ -56,17 +58,29 @@ public final class TaskRetryEligibility {
"aiprice 未登录", "未登录且自动登录失败", "自动登录失败",
"会话失效且重新登录失败");
/**
* 唯一一条不是"外部条件坏了"的判据:{@code TaskResumeService} 停掉的重复子任务。
* 文案从 {@link TaskResumeService#DUPLICATE_STOP_REASON} 取,不在这里抄一份字面量——
* 两处各写一遍,改一处就静默失效(停掉的子任务会被重新克隆,双跑又回来)。
*/
private static final List<String> STOPPED_MARKERS = List.of(TaskResumeService.DUPLICATE_STOP_REASON);
private TaskRetryEligibility() {
}
/**
* @return null=可重试;非 null=不可抗力分类
* @return null=可重试;非 null=不重试(外部不可抗力,或系统已主动收口)
*/
public static Category forceMajeureCategory(String errorMessage) {
if (errorMessage == null || errorMessage.isBlank()) {
return null;
}
String text = errorMessage.toLowerCase(Locale.ROOT);
// 停止文案先判:它是我们自己写的、语义唯一的一条。留给后面的欠费/宕机类去抢,
// 只会把"这条不该再跑"的日志说成"服务不可用",运维据此调整反了方向。
if (containsAny(text, STOPPED_MARKERS)) {
return Category.STOPPED;
}
if (containsAny(text, BALANCE_MARKERS) || containsAny(text, KEY_MARKERS)) {
return Category.BALANCE;
}
@@ -3,9 +3,13 @@ package com.nanri.aiimage.modules.task.service;
import ch.qos.logback.classic.Logger;
import ch.qos.logback.classic.spi.ILoggingEvent;
import ch.qos.logback.core.read.ListAppender;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.nanri.aiimage.modules.task.mapper.FileTaskMapper;
import com.nanri.aiimage.modules.task.model.entity.FileTaskEntity;
import com.nanri.aiimage.modules.task.spi.ClientTaskRetrySpi;
import org.apache.ibatis.builder.MapperBuilderAssistant;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.slf4j.LoggerFactory;
import org.springframework.test.util.ReflectionTestUtils;
@@ -28,6 +32,18 @@ import static org.mockito.Mockito.when;
*/
class TaskResumeServiceTest {
/**
* 清账那一路要写 {@code LambdaUpdateWrapper.set(...)},它在**调用当场**就要把方法引用解析成列名,
* 没有 TableInfo 缓存直接抛「can not find lambda cache for this entity」;查询 wrapper 只在生成
* SQL 时才解析,mapper 被 mock 掉就碰不到——所以只有含写操作的本类需要这一步。
* 口径抄 {@code ProgressQueryOwnershipOutletTest}。
*/
@BeforeAll
static void initMybatisPlusTableInfo() {
TableInfoHelper.initTableInfo(new MapperBuilderAssistant(new MybatisConfiguration(), ""),
FileTaskEntity.class);
}
private static ClientTaskRetrySpi retrySpi(String moduleType, Long childTaskId) {
return new ClientTaskRetrySpi() {
@Override
@@ -280,6 +296,82 @@ class TaskResumeServiceTest {
assertEquals(List.of(9001L), stats.retriedTaskIds);
}
private static FileTaskEntity liveChild(Long id, Long originId, String status) {
FileTaskEntity child = new FileTaskEntity();
child.setId(id);
child.setModuleType("SIMILAR_ASIN");
child.setUserId(1134L);
child.setStatus(status);
child.setResumeOfTaskId(originId);
child.setResumeAttempt(1);
return child;
}
private static FileTaskEntity taskWithStatus(Long id, String status) {
FileTaskEntity task = new FileTaskEntity();
task.setId(id);
task.setModuleType("SIMILAR_ASIN");
task.setStatus(status);
return task;
}
/**
* 现网 2026-10-22 实测到的那一对:子任务 31857 RUNNING,而它的原件 31751 被迟到回传复活成
* RUNNING——同一份活跑两遍=两遍真实抓取+两遍 LLM 计费,烧的是用户本人的额度。
*/
@Test
void 原件复活后停掉还活着的重复子任务() {
FileTaskMapper mapper = mock(FileTaskMapper.class);
// 清账的扫描在前、克隆候选的扫描在后,所以两次 selectList 要分别给值
when(mapper.selectList(any()))
.thenReturn(List.of(liveChild(31857L, 31751L, "RUNNING")), List.of());
when(mapper.selectBatchIds(any())).thenReturn(List.of(taskWithStatus(31751L, "RUNNING")));
when(mapper.update(any(), any())).thenReturn(1);
ClientTaskRetrySpi spi = mock(ClientTaskRetrySpi.class);
when(spi.moduleType()).thenReturn("SIMILAR_ASIN");
TaskResumeService service = service(mapper, List.of(spi), true, 3);
TaskResumeService.ResumeStats stats = service.resumeInterruptedTasks();
assertEquals(1, stats.stoppedDuplicateChildCount);
verify(mapper).update(any(), any());
verify(spi, never()).cloneForRetry(any());
}
/** 反向对照:原件还是老实的 FAILED(重试的正常形态)时,一条都不许停——否则整个重试机制自己把自己掐了。 */
@Test
void 原件仍是失败态时不动它的子任务() {
FileTaskMapper mapper = mock(FileTaskMapper.class);
when(mapper.selectList(any()))
.thenReturn(List.of(liveChild(31857L, 31751L, "RUNNING")), List.of());
when(mapper.selectBatchIds(any())).thenReturn(List.of(taskWithStatus(31751L, "FAILED")));
ClientTaskRetrySpi spi = mock(ClientTaskRetrySpi.class);
when(spi.moduleType()).thenReturn("SIMILAR_ASIN");
TaskResumeService service = service(mapper, List.of(spi), true, 3);
TaskResumeService.ResumeStats stats = service.resumeInterruptedTasks();
assertEquals(0, stats.stoppedDuplicateChildCount);
verify(mapper, never()).update(any(), any());
}
/** dryRun 只报"将会停几条",不落库——回填端点默认走这条路,先看不能先动。 */
@Test
void 回填dryRun只数重复子任务不落库() {
FileTaskMapper mapper = mock(FileTaskMapper.class);
when(mapper.selectList(any()))
.thenReturn(List.of(liveChild(31857L, 31751L, "PENDING")), List.of());
when(mapper.selectBatchIds(any())).thenReturn(List.of(taskWithStatus(31751L, "RUNNING")));
ClientTaskRetrySpi spi = mock(ClientTaskRetrySpi.class);
when(spi.moduleType()).thenReturn("SIMILAR_ASIN");
TaskResumeService service = service(mapper, List.of(spi), false, 3);
TaskResumeService.ResumeStats stats = service.retryFailedTasks(36, 200, true, null);
assertEquals(1, stats.stoppedDuplicateChildCount);
verify(mapper, never()).update(any(), any());
}
/**
* 开机必须把重试的生效配置打出来。
*
@@ -49,4 +49,24 @@ class TaskRetryEligibilityTest {
assertNull(TaskRetryEligibility.forceMajeureCategory(null));
assertNull(TaskRetryEligibility.forceMajeureCategory(" "));
}
/**
* 系统自己停掉的重复子任务不许再被克隆(B14):否则"停一份"这个收口动作会被下一轮巡检
* 重新克隆成两份,自己喂自己。文案取 {@code TaskResumeService.DUPLICATE_STOP_REASON},
* 不在这里抄字面量——两处各写一遍,改一处就静默失效。
*/
@Test
void 系统停掉的重复子任务不再克隆() {
assertEquals(TaskRetryEligibility.Category.STOPPED,
TaskRetryEligibility.forceMajeureCategory(TaskResumeService.DUPLICATE_STOP_REASON));
assertEquals("重复子任务已停止",
TaskRetryEligibility.skipReason(TaskResumeService.DUPLICATE_STOP_REASON));
}
/** 反向对照:判据认的是那句完整文案,不是"停止"这个字——含"停止"的真实失败必须仍可重试。 */
@Test
void 停止判据不吃邻近文案() {
assertNull(TaskRetryEligibility.forceMajeureCategory("任务被用户手动停止"));
assertNull(TaskRetryEligibility.forceMajeureCategory("客户端回传中断"));
}
}