From 973128216aed753f33683a70996fd627cb9d2e1f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E9=BB=84=E8=87=AA=E8=BE=BE?= <980324341@qq.com> Date: Thu, 22 Oct 2026 14:12:44 +0800 Subject: [PATCH] =?UTF-8?q?fix(task-retry):=20=E5=8E=9F=E4=BB=B6=E8=A2=AB?= =?UTF-8?q?=E8=BF=9F=E5=88=B0=E5=9B=9E=E4=BC=A0=E5=A4=8D=E6=B4=BB=E5=90=8E?= =?UTF-8?q?=E5=81=9C=E6=8E=89=E9=87=8D=E5=A4=8D=E5=AD=90=E4=BB=BB=E5=8A=A1?= =?UTF-8?q?=EF=BC=8C=E9=81=BF=E5=85=8D=E5=90=8C=E4=B8=80=E4=BB=BD=E6=B4=BB?= =?UTF-8?q?=E8=B7=91=E4=B8=A4=E9=81=8D?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 现网 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,非空跑。 --- .../task/model/vo/TaskRetryBatchVo.java | 3 + .../task/service/TaskResumeService.java | 117 ++++++++++++++++-- .../task/service/TaskRetryEligibility.java | 18 ++- .../task/service/TaskResumeServiceTest.java | 92 ++++++++++++++ .../service/TaskRetryEligibilityTest.java | 20 +++ 5 files changed, 239 insertions(+), 11 deletions(-) diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/task/model/vo/TaskRetryBatchVo.java b/backend-java/src/main/java/com/nanri/aiimage/modules/task/model/vo/TaskRetryBatchVo.java index ea696d412..5b2d189f8 100644 --- a/backend-java/src/main/java/com/nanri/aiimage/modules/task/model/vo/TaskRetryBatchVo.java +++ b/backend-java/src/main/java/com/nanri/aiimage/modules/task/model/vo/TaskRetryBatchVo.java @@ -15,6 +15,8 @@ public class TaskRetryBatchVo { private int skippedExisting; private int skippedForceMajeure; private int failed; + /** 本轮停掉的「原件已复活」重复子任务数(dryRun 下是"将会停")。 */ + private int stoppedDuplicateChildren; private List candidateTaskIds; private List 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; diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/task/service/TaskResumeService.java b/backend-java/src/main/java/com/nanri/aiimage/modules/task/service/TaskResumeService.java index aa6378be9..fec9e1000 100644 --- a/backend-java/src/main/java/com/nanri/aiimage/modules/task/service/TaskResumeService.java +++ b/backend-java/src/main/java/com/nanri/aiimage/modules/task/service/TaskResumeService.java @@ -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} 负责把解析输入与载荷一起克隆过去。 * - *

不可抗力不重试:LLM 密钥/代理 IP 欠费、服务宕机、账号自动登录失败等,重跑不会改变结果, - * 还会白烧外部额度。判据集中在 {@link TaskRetryEligibility}。 + *

不重试的两类:一是不可抗力——LLM 密钥/代理 IP 欠费、服务宕机、账号自动登录失败等, + * 重跑不会改变结果,还会白烧外部额度;二是系统自己刚停掉的重复子任务(见 + * {@link #DUPLICATE_STOP_REASON}),再克隆等于把双跑捡回来。判据都集中在 {@link TaskRetryEligibility}。 * *

幂等:同一原任务已有重试子任务({@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 LIVE_STATUSES = + List.of(TaskStatuses.FileTask.PENDING, TaskStatuses.FileTask.RUNNING); + + /** + * 停掉重复子任务时写的文案。判据集中在 {@link TaskRetryEligibility}:这条文案命中即不再克隆, + * 否则"停掉一份"会被下一轮巡检重新克隆成两份,收口动作自己喂自己。 + * + *

状态取 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)之后,停掉它名下仍活着的重试子任务。 + * + *

为什么做在巡检里、而不是塞进复活路径:{@code SimilarAsinStaleReopenSupport} 是在 + * {@code SimilarAsinTaskService} 里现场 new 出来的,多一个依赖就得动那个 1900+ 行的类 + * (它在可读性基线里是被点名的对象);而"父子两条都活着=重复劳动"这个口径与模块无关, + * 收在这里一次覆盖所有复活入口,还顺带把已有的存量对子收掉。代价是最长滞后一个巡检周期(2 分钟)。 + * + *

留原件、停子任务:复活是客户端拿着真实分片回来触发的,那份数据在原件上;子任务只是重复的一份。 + * + * @return 实际落库停止的条数;dryRun 下只计数不落库,返回 0 + */ + private int stopDuplicateChildren(boolean dryRun, ResumeStats stats) { + List liveChildren = fileTaskMapper.selectList(new LambdaQueryWrapper() + .isNotNull(FileTaskEntity::getResumeOfTaskId) + .in(FileTaskEntity::getStatus, LIVE_STATUSES) + .orderByAsc(FileTaskEntity::getId) + .last("limit " + DUPLICATE_SWEEP_LIMIT)); + if (liveChildren == null || liveChildren.isEmpty()) { + return 0; + } + Set originIds = new LinkedHashSet<>(); + for (FileTaskEntity child : liveChildren) { + // 查询已按 isNotNull 收窄,但这里再挡一次:别拿 null 去拼 selectBatchIds。 + if (child.getResumeOfTaskId() != null) { + originIds.add(child.getResumeOfTaskId()); + } + } + if (originIds.isEmpty()) { + return 0; + } + Map 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() + .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 resolveRequestedTypes(List requested) { Set 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 candidateTaskIds = new ArrayList<>(); /** 实际克隆出的新任务 id。 */ diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/task/service/TaskRetryEligibility.java b/backend-java/src/main/java/com/nanri/aiimage/modules/task/service/TaskRetryEligibility.java index e2f1c5db7..9ad10128f 100644 --- a/backend-java/src/main/java/com/nanri/aiimage/modules/task/service/TaskRetryEligibility.java +++ b/backend-java/src/main/java/com/nanri/aiimage/modules/task/service/TaskRetryEligibility.java @@ -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 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; } diff --git a/backend-java/src/test/java/com/nanri/aiimage/modules/task/service/TaskResumeServiceTest.java b/backend-java/src/test/java/com/nanri/aiimage/modules/task/service/TaskResumeServiceTest.java index 08588aaa6..c3cfadda2 100644 --- a/backend-java/src/test/java/com/nanri/aiimage/modules/task/service/TaskResumeServiceTest.java +++ b/backend-java/src/test/java/com/nanri/aiimage/modules/task/service/TaskResumeServiceTest.java @@ -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()); + } + /** * 开机必须把重试的生效配置打出来。 * diff --git a/backend-java/src/test/java/com/nanri/aiimage/modules/task/service/TaskRetryEligibilityTest.java b/backend-java/src/test/java/com/nanri/aiimage/modules/task/service/TaskRetryEligibilityTest.java index 824ccb5fe..1e7e250f5 100644 --- a/backend-java/src/test/java/com/nanri/aiimage/modules/task/service/TaskRetryEligibilityTest.java +++ b/backend-java/src/test/java/com/nanri/aiimage/modules/task/service/TaskRetryEligibilityTest.java @@ -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("客户端回传中断")); + } }