fix(appearance-patent): 续跑新一代交完后复位上一代已交付的出表作业并清直链

现网 33924(专利4.xlsx,200 行,11-10 17:42 → 11-11 04:08 判死「客户端已上传完全部
结果,但结果文件未能生成」)的链路,按 B 机 java 日志逐条对上:

  00:45 首轮交完 → 01:18 原任务复位重试(代数 3)摘掉已交付的 SUCCESS 作业,但
  biz_file_result.result_file_url 仍在 → 01:18:04 出表侧「结果文件已交付,跳过重复组装」
  把作业标回 SUCCESS → 02:19 客户端重新认领 → 03:33–03:37 全 200 组重采完
  (completed=true, llmDone=false)→ enqueueAssembleResult 原样返回 01:18 那份 SUCCESS,
  scheduleLlmPipelineForSubmittedChunk 一句话都不打地 return ⇒ 检测与出表一步没走,
  心跳停 30 分钟被判死。

两处修:
- AppearancePatentDeliveredRearmSupport(新,3A 拆薄第十四笔):摘作业时同时把结果行的
  result_file_url / result_file_size 清空(文件本体仍留在对象存储),「是否已交付」这一个
  判定由恢复探针与「继续」复位共用
- AppearancePatentLlmSubmissionSupport:拿回的作业是 SUCCESS 时不再静默返回——若本代
  分片已交完(submissionComplete)就先复位上一代再重新 enqueue;半批不复位(半批复位会让
  组装读到半批行,覆盖率闸门反过来把这轮出表判死)
- 主类只留委派,行数 893→871(可读棘轮只许减)

用例:AppearancePatentRearmDeliveredJobTest(2,清直链/无交付作业不动结果行)、
AppearancePatentResumedRoundRearmTest(3,交完才复位、半批不复位、首轮 PENDING 不受影响)。
四支相关套件 25 例全绿;快检闸门 overall=pass。
This commit is contained in:
2026-11-12 10:27:24 +08:00
parent 5390503f7a
commit faa08a6138
6 changed files with 350 additions and 35 deletions
@@ -0,0 +1,118 @@
package com.nanri.aiimage.modules.appearancepatent.service;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.ibatis.builder.MapperBuilderAssistant;
import org.junit.jupiter.api.BeforeAll;
import com.nanri.aiimage.common.service.DistributedJobLockService;
import com.nanri.aiimage.config.AppearancePatentProperties;
import com.nanri.aiimage.config.InstanceMetadata;
import com.nanri.aiimage.config.StorageProperties;
import com.nanri.aiimage.common.task.TaskStatuses;
import com.nanri.aiimage.modules.appearancepatent.client.AppearancePatentLlmClient;
import com.nanri.aiimage.modules.file.service.LocalFileStorageService;
import com.nanri.aiimage.modules.task.mapper.FileResultMapper;
import com.nanri.aiimage.modules.task.mapper.FileTaskMapper;
import com.nanri.aiimage.modules.task.mapper.TaskChunkMapper;
import com.nanri.aiimage.modules.task.mapper.TaskScopeStateMapper;
import com.nanri.aiimage.modules.task.model.entity.FileResultEntity;
import com.nanri.aiimage.modules.task.model.entity.TaskFileJobEntity;
import com.nanri.aiimage.modules.task.service.TaskDistributedLockService;
import com.nanri.aiimage.modules.task.service.TaskFileJobService;
import com.nanri.aiimage.modules.task.service.TaskHeartbeatPositionService;
import com.nanri.aiimage.modules.task.service.TaskProgressLightAssembler;
import com.nanri.aiimage.modules.task.service.TaskProgressSnapshotService;
import com.nanri.aiimage.modules.task.service.TransientPayloadStorageService;
import com.nanri.aiimage.modules.usersecret.service.UserApiSecretService;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.transaction.PlatformTransactionManager;
import java.util.List;
import java.util.Map;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.isNull;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
* 「继续」摘除上一轮交付的出表作业时,必须同时清掉结果行上的直链。
*
* <p>只删作业不清直链等于没摘:出表侧「结果文件已交付,跳过重复组装」只认
* {@code result_file_url} 非空,重建出来的 PENDING 作业几十毫秒后又被标回 SUCCESS,
* 新一代分片永远轮不到出表(2026-11-11 现网 33924,链路口径见 {@code StaleTaskDeathReason})。
*/
class AppearancePatentRearmDeliveredJobTest {
private static final long TASK_ID = 33924L;
private static final long RESULT_ID = 36854L;
private static final String MODULE = AppearancePatentTaskService.MODULE_TYPE;
private final FileTaskMapper fileTaskMapper = mock(FileTaskMapper.class);
private final FileResultMapper fileResultMapper = mock(FileResultMapper.class);
private final TaskFileJobService taskFileJobService = mock(TaskFileJobService.class);
private AppearancePatentTaskService service;
/** LambdaUpdateWrapper 要 TableInfo 缓存才能把方法引用翻成列名;单测里手工灌一次。 */
@BeforeAll
static void initLambdaCache() {
TableInfoHelper.initTableInfo(
new MapperBuilderAssistant(new MybatisConfiguration(), ""), FileResultEntity.class);
}
@BeforeEach
void setUp() {
service = new AppearancePatentTaskService(
mock(LocalFileStorageService.class), null,
mock(com.nanri.aiimage.common.service.ResultDownloadResolver.class),
mock(StorageProperties.class), fileTaskMapper, fileResultMapper,
mock(TaskScopeStateMapper.class), mock(TaskChunkMapper.class), new ObjectMapper(),
mock(AppearancePatentLlmClient.class), mock(AppearancePatentTaskCacheService.class),
mock(AppearancePatentProperties.class), taskFileJobService,
mock(TaskProgressSnapshotService.class), mock(TaskHeartbeatPositionService.class),
mock(TransientPayloadStorageService.class), mock(PlatformTransactionManager.class),
mock(DistributedJobLockService.class), mock(TaskDistributedLockService.class),
mock(InstanceMetadata.class), mock(TaskProgressLightAssembler.class),
mock(UserApiSecretService.class));
}
private static TaskFileJobEntity deliveredJob() {
TaskFileJobEntity job = new TaskFileJobEntity();
job.setId(24539L);
job.setTaskId(TASK_ID);
job.setModuleType(MODULE);
job.setStatus(TaskStatuses.Job.SUCCESS);
job.setResultId(RESULT_ID);
return job;
}
@Test
void 摘除已交付作业时必须清掉直链与字节数() {
when(taskFileJobService.findAssembleJobsByTaskIds(MODULE, List.of(TASK_ID)))
.thenReturn(Map.of(24539L, deliveredJob()));
service.rearmDeliveredAssembleJobForResume(TASK_ID);
verify(taskFileJobService).deleteResultJobs(TASK_ID, MODULE, RESULT_ID);
verify(fileResultMapper, times(1)).update(isNull(), any(LambdaUpdateWrapper.class));
}
@Test
void 没有已交付作业时不动结果行() {
when(taskFileJobService.findAssembleJobsByTaskIds(MODULE, List.of(TASK_ID)))
.thenReturn(Map.of());
service.rearmDeliveredAssembleJobForResume(TASK_ID);
verify(fileResultMapper, never()).update(isNull(), any(LambdaUpdateWrapper.class));
verify(fileResultMapper, never()).updateById(any(FileResultEntity.class));
}
}
@@ -409,7 +409,8 @@ class AppearancePatentTaskServiceDelegationTest {
service.rearmDeliveredAssembleJobForResume(33228L);
// 只删作业行、不动结果行:下一轮 enqueueAssembleResult 走 existing==null 分支重建 PENDING 并补发派发事件
// 删作业行 + 清结果行直链:下一轮 enqueueAssembleResult 走 existing==null 分支重建 PENDING 并补发派发事件;
// 直链不清则出表侧「结果文件已交付,跳过重复组装」会立刻把它标回 SUCCESS(33924)
verify(taskFileJobService).deleteResultJobs(33228L, AppearancePatentTaskService.MODULE_TYPE, 6600L);
}
@@ -0,0 +1,114 @@
package com.nanri.aiimage.modules.appearancepatent.service.support;
import com.nanri.aiimage.common.task.TaskStatuses;
import com.nanri.aiimage.modules.appearancepatent.model.dto.AppearancePatentParsedPayloadDto;
import com.nanri.aiimage.modules.appearancepatent.service.AppearancePatentTaskService;
import com.nanri.aiimage.modules.appearancepatent.service.support.AppearancePatentChunkSubmissionSupport.SubmitContext;
import com.nanri.aiimage.modules.task.mapper.FileTaskMapper;
import com.nanri.aiimage.modules.task.model.entity.FileResultEntity;
import com.nanri.aiimage.modules.task.model.entity.FileTaskEntity;
import com.nanri.aiimage.modules.task.model.entity.TaskChunkEntity;
import com.nanri.aiimage.modules.task.model.entity.TaskFileJobEntity;
import com.nanri.aiimage.modules.task.service.TaskFileJobService;
import com.nanri.aiimage.modules.usersecret.service.UserApiSecretService;
import org.junit.jupiter.api.Test;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
* 续跑新一代交完后,上一代「已交付」的出表作业必须被复位。
*
* <p>回归背景(2026-11-11 现网 33924):原任务复位重试(代数 3/3)后客户端又把 200 组全采了一遍,
* 末分片 03:37:54 交完 done=true,但 {@code enqueueAssembleResult} 原样返回 01:18 那份 SUCCESS
* 作业 ⇒ 旧写法在这里一句日志都没有地 return,检测与出表一步没走,30 分钟后按
* 「客户端已上传完全部结果,但结果文件未能生成」判死。底座 .ne SUCCESS 的早退是刻意的
* (没人要求重做时不许替换用户可能已经下载的成品),本方法就是「要求重做」的那一处。
*/
class AppearancePatentResumedRoundRearmTest {
private static final long TASK_ID = 33924L;
private static final long RESULT_ID = 36854L;
private static final String MODULE = AppearancePatentTaskService.MODULE_TYPE;
private final FileTaskMapper fileTaskMapper = mock(FileTaskMapper.class);
private final TaskFileJobService taskFileJobService = mock(TaskFileJobService.class);
private final AtomicInteger rearms = new AtomicInteger();
private AppearancePatentLlmSubmissionSupport support(boolean submissionComplete) {
FileTaskEntity task = new FileTaskEntity();
task.setId(TASK_ID);
task.setModuleType(MODULE);
task.setStatus(TaskStatuses.FileTask.RUNNING);
when(fileTaskMapper.selectById(TASK_ID)).thenReturn(task);
TaskChunkEntity chunk = new TaskChunkEntity();
FileResultEntity result = new FileResultEntity();
result.setId(RESULT_ID);
AppearancePatentLlmSubmissionSupport support = new AppearancePatentLlmSubmissionSupport(
MODULE, fileTaskMapper, taskFileJobService,
id -> List.of(chunk), ignored -> 200, (ignored, rows) -> result,
(a, b, c, d) -> { },
id -> submissionComplete, id -> { }, id -> rearms.incrementAndGet(),
ignored -> MODULE + ":server-121",
ignored -> (AppearancePatentParsedPayloadDto) null,
mock(UserApiSecretService.class), value -> value);
return support;
}
private static TaskFileJobEntity job(long id, String status) {
TaskFileJobEntity job = new TaskFileJobEntity();
job.setId(id);
job.setStatus(status);
return job;
}
@Test
void 上一代已交付且本代已交完时必须复位并重新排队() {
when(taskFileJobService.enqueueAssembleResult(eq(TASK_ID), eq(MODULE), eq(RESULT_ID), anyString()))
.thenReturn(job(24539L, TaskStatuses.Job.SUCCESS),
job(24600L, TaskStatuses.Job.PENDING));
support(true).scheduleLlmPipelineForSubmittedChunk(
new SubmitContext(fileTaskMapper.selectById(TASK_ID), null, null, 19, true, null));
assertEquals(1, rearms.get(), "上一代 SUCCESS 作业必须先被摘掉,否则新一代永远排不上");
verify(taskFileJobService, times(2))
.enqueueAssembleResult(eq(TASK_ID), eq(MODULE), eq(RESULT_ID), anyString());
verify(taskFileJobService).requeue(eq(24600L), anyString());
}
@Test
void 本代还没交完时不得复位_半批会读到半批行() {
when(taskFileJobService.enqueueAssembleResult(eq(TASK_ID), eq(MODULE), eq(RESULT_ID), anyString()))
.thenReturn(job(24539L, TaskStatuses.Job.SUCCESS));
support(false).scheduleLlmPipelineForSubmittedChunk(
new SubmitContext(fileTaskMapper.selectById(TASK_ID), null, null, 5, false, null));
assertEquals(0, rearms.get(), "没交完就复位,组装会读到半批行");
verify(taskFileJobService, never()).requeue(eq(24539L), anyString());
}
@Test
void 正常首轮未交付作业不受影响() {
when(taskFileJobService.enqueueAssembleResult(eq(TASK_ID), eq(MODULE), eq(RESULT_ID), anyString()))
.thenReturn(job(24539L, TaskStatuses.Job.PENDING));
support(true).scheduleLlmPipelineForSubmittedChunk(
new SubmitContext(fileTaskMapper.selectById(TASK_ID), null, null, 19, true, null));
assertEquals(0, rearms.get(), "首轮的 PENDING 作业不该被当成上一代成品");
verify(taskFileJobService).requeue(eq(24539L), anyString());
}
}