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
@@ -13,6 +13,7 @@ import com.nanri.aiimage.modules.appearancepatent.service.support.AppearancePate
import com.nanri.aiimage.modules.appearancepatent.service.support.AppearancePatentStaleTaskFinalizer;
import com.nanri.aiimage.modules.appearancepatent.service.support.AppearancePatentTaskRecordSupport;
import com.nanri.aiimage.modules.appearancepatent.service.support.AppearancePatentDeliverySupport;
import com.nanri.aiimage.modules.appearancepatent.service.support.AppearancePatentDeliveredRearmSupport;
import com.nanri.aiimage.modules.appearancepatent.service.support.AppearancePatentExcelParser;
import com.nanri.aiimage.common.service.DistributedJobLockService;
import com.nanri.aiimage.config.AppearancePatentProperties;
@@ -95,42 +96,19 @@ public class AppearancePatentTaskService extends AbstractFileTaskPipeline<Appear
}
/**
* 该任务**已出表成功**的组装作业。走底座既有读接口 {@code findAssembleJobsByTaskIds}
* (它按 jobType 过滤 ASSEMBLE_RESULT),不再在 {@code TaskFileJobService} 上开一个同义方法。
* 「继续」的第二半:摘掉上一轮**已交付**的出表作业并清掉结果行直链,让剩余行重新排得上补检。
*
* <p>「是否已交付」这一个判定必须被恢复探针与「继续」复位共用:两者判的不是同一样东西的话,
* 刚点过继续的任务会立刻被探针当成已交付而收尾(33228 的死胡同换个方向再演一遍)。
*/
private List<TaskFileJobEntity> deliveredAssembleJobs(Long taskId) {
return taskFileJobService.findAssembleJobsByTaskIds(MODULE_TYPE, List.of(taskId)).values().stream()
.filter(job -> job != null && STATUS_SUCCESS.equals(job.getStatus()))
.toList();
}
private boolean hasDeliveredAssembleJob(Long taskId) {
return !deliveredAssembleJobs(taskId).isEmpty();
}
/**
* 「继续」的第二半:摘掉上一轮**已交付**的出表作业,让剩余行重新排得上补检。
*
* <p>只清补检预算不够——那行 SUCCESS 留在原地时,Python 超时恢复每 2 分钟走到
* {@code enqueueAssembleResult} 都原样拿回它(底座的 SUCCESS 早退是刻意的:没人要求重做时不许
* 替换用户可能已下载的成品),据此跳过发批,交付闸门于是永远不被评估(2026-11-04 现网 33228:
* 表 11-03 10:50 就出好了、作业恒 SUCCESS、10 行"等待补检轮"、{@code updated_at} 却常新)。
*
* <p>删行而不是 UPDATE 回 PENDING:{@code enqueueAssembleResult} 在 {@code existing == null}
* 的分支里本就建 PENDING、算 owner 并补发派发事件,走现成那条路比在底座之外再抄一遍派发形状稳。
* 结果行 {@code biz_file_result} 与它的直链一行不动,下一轮出表覆盖它——界面确认框承诺的
* 「当前已生成的部分结果文件会被替换」就是这一格。
* <p>「是否已交付」这一个判定被恢复探针与「继续」复位共用;实现与 33228/33924 两轮现网取证见
* {@link AppearancePatentDeliveredRearmSupport}(3A 拆薄第十四笔)。
*/
public void rearmDeliveredAssembleJobForResume(Long taskId) {
deliveredAssembleJobs(taskId).forEach(job -> {
taskFileJobService.deleteResultJobs(taskId, MODULE_TYPE, job.getResultId());
log.warn("[appearance-patent] 继续:已摘除上一轮交付的出表作业,剩余行将重新出表 taskId={} jobId={} resultId={}",
taskId, job.getId(), job.getResultId());
});
deliveredRearmSupport().rearm(taskId);
}
private AppearancePatentDeliveredRearmSupport deliveredRearmSupport() {
return new AppearancePatentDeliveredRearmSupport(MODULE_TYPE, taskFileJobService, fileResultMapper);
}
private static final String STATUS_RUNNING = "RUNNING";
private static final String STATUS_SUCCESS = "SUCCESS";
private static final String STATUS_FAILED = "FAILED";
@@ -578,6 +556,7 @@ public class AppearancePatentTaskService extends AbstractFileTaskPipeline<Appear
this::loadSubmittedChunks, rowReader()::allRowCount,
this::findOrCreateResultRecordForAssembly, this::submitLlmBatches,
this::isResultSubmissionComplete, this::touchJavaSideTaskActivity,
this::rearmDeliveredAssembleJobForResume,
this::buildTaskOwnerScopeKey, payloadSupport()::readParsedPayload,
userApiSecretService, AppearancePatentRowNormalizer::normalize);
}
@@ -590,7 +569,7 @@ public class AppearancePatentTaskService extends AbstractFileTaskPipeline<Appear
return new AppearancePatentStaleTaskFinalizer(
MODULE_TYPE, fileTaskMapper, taskFileJobService,
rowReader()::allRowCount, this::isResultSubmissionComplete,
rowReader()::hasPersistedResultRows, this::hasDeliveredAssembleJob,
rowReader()::hasPersistedResultRows, deliveredRearmSupport()::hasDelivered,
this::markSubmissionCompleteInNewTransaction,
this::loadSubmittedChunks, this::countUninspectedRows,
llmSubmissionSupport()::submitLlmForSubmittedChunk,
@@ -0,0 +1,82 @@
package com.nanri.aiimage.modules.appearancepatent.service.support;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.nanri.aiimage.modules.task.mapper.FileResultMapper;
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.TaskFileJobService;
import lombok.extern.slf4j.Slf4j;
import java.time.LocalDateTime;
import java.util.List;
/**
* 「继续」的第二半:摘掉上一轮**已交付**的出表作业,并把结果行上的直链清掉(3A 拆薄第十四笔)。
*
* <p><b>为什么摘作业还不够。</b>只清补检预算不够——那行 SUCCESS 留在原地时,Python 超时恢复每 2 分钟
* 走到 {@code enqueueAssembleResult} 都原样拿回它(底座的 SUCCESS 早退是刻意的:没人要求重做时不许
* 替换用户可能已下载的成品),据此跳过发批,交付闸门于是永远不被评估(2026-11-04 现网 33228:
* 表 11-03 10:50 就出好了、作业恒 SUCCESS、10 行"等待补检轮"、{@code updated_at} 却常新)。
* 而光删作业行仍不够:{@code AppearancePatentResultJobSupport} 的「结果文件已交付,跳过重复组装」
* 只认 {@code biz_file_result.result_file_url} 非空,重建出来的 PENDING 作业几十毫秒后又会被标回
* SUCCESS。2026-11-11 现网 33924 就是这条链:01:18 复位作业 → 01:18:04 跳过重复组装 → 03:37 二代
* 采完的 200 组无人组装 → 心跳停 30 分钟判死(「客户端已上传完全部结果,但结果文件未能生成」)。
*
* <p><b>删行而不是 UPDATE 回 PENDING</b>:{@code enqueueAssembleResult} 在 {@code existing == null}
* 的分支里本就建 PENDING、算 owner 并补发派发事件,走现成那条路比在底座之外再抄一遍派发形状稳。
* 直链只清空、文件本体仍留在对象存储,下一轮组装完成后覆盖挂新直链——界面确认框承诺的
* 「当前已生成的部分结果文件会被替换」就是这一格。
*
* <p>「是否已交付」这一个判定必须被恢复探针({@link #hasDelivered})与「继续」复位({@link #rearm})
* 共用:两者判的不是同一样东西的话,刚点过继续的任务会立刻被探针当成已交付而收尾
* (33228 的死胡同换个方向再演一遍)。
*/
@Slf4j
public class AppearancePatentDeliveredRearmSupport {
private static final String JOB_STATUS_SUCCESS = "SUCCESS";
private final String moduleType;
private final TaskFileJobService taskFileJobService;
private final FileResultMapper fileResultMapper;
public AppearancePatentDeliveredRearmSupport(String moduleType,
TaskFileJobService taskFileJobService,
FileResultMapper fileResultMapper) {
this.moduleType = moduleType;
this.taskFileJobService = taskFileJobService;
this.fileResultMapper = fileResultMapper;
}
public boolean hasDelivered(Long taskId) {
return !deliveredAssembleJobs(taskId).isEmpty();
}
public void rearm(Long taskId) {
deliveredAssembleJobs(taskId).forEach(job -> {
taskFileJobService.deleteResultJobs(taskId, moduleType, job.getResultId());
clearDeliveredResultPointer(job.getResultId());
log.warn("[appearance-patent] 继续:已摘除上一轮交付的出表作业并清空直链,剩余行将重新出表 taskId={} jobId={} resultId={}",
taskId, job.getId(), job.getResultId());
});
}
/** 该任务**已出表成功**的组装作业。走底座既有读接口 {@code findAssembleJobsByTaskIds}(按 jobType 过滤 ASSEMBLE_RESULT)。 */
private List<TaskFileJobEntity> deliveredAssembleJobs(Long taskId) {
return taskFileJobService.findAssembleJobsByTaskIds(moduleType, List.of(taskId)).values().stream()
.filter(job -> job != null && JOB_STATUS_SUCCESS.equals(job.getStatus()))
.toList();
}
/** 只清直链与字节数(文件本体仍留在对象存储),下一轮组装完成后覆盖挂新直链。 */
private void clearDeliveredResultPointer(Long resultId) {
if (resultId == null) {
return;
}
fileResultMapper.update(null, new LambdaUpdateWrapper<FileResultEntity>()
.eq(FileResultEntity::getId, resultId)
.set(FileResultEntity::getResultFileUrl, null)
.set(FileResultEntity::getResultFileSize, 0L)
.set(FileResultEntity::getUpdatedAt, LocalDateTime.now()));
}
}
@@ -36,6 +36,7 @@ public class AppearancePatentLlmSubmissionSupport {
}
private static final String STATUS_SUCCESS = TaskStatuses.FileTask.SUCCESS;
private static final String JOB_STATUS_SUCCESS = TaskStatuses.Job.SUCCESS;
private final String moduleType;
private final FileTaskMapper fileTaskMapper;
@@ -46,6 +47,7 @@ public class AppearancePatentLlmSubmissionSupport {
private final BatchSubmitter batchSubmitter;
private final Predicate<Long> submissionComplete;
private final Consumer<Long> taskActivityToucher;
private final Consumer<Long> deliveredAssembleRearmer;
private final Function<FileTaskEntity, String> taskOwnerScopeKeyBuilder;
private final Function<FileTaskEntity, AppearancePatentParsedPayloadDto> payloadReader;
private final UserApiSecretService userApiSecretService;
@@ -60,6 +62,7 @@ public class AppearancePatentLlmSubmissionSupport {
BatchSubmitter batchSubmitter,
Predicate<Long> submissionComplete,
Consumer<Long> taskActivityToucher,
Consumer<Long> deliveredAssembleRearmer,
Function<FileTaskEntity, String> taskOwnerScopeKeyBuilder,
Function<FileTaskEntity, AppearancePatentParsedPayloadDto> payloadReader,
UserApiSecretService userApiSecretService,
@@ -73,6 +76,7 @@ public class AppearancePatentLlmSubmissionSupport {
this.batchSubmitter = batchSubmitter;
this.submissionComplete = submissionComplete;
this.taskActivityToucher = taskActivityToucher;
this.deliveredAssembleRearmer = deliveredAssembleRearmer;
this.taskOwnerScopeKeyBuilder = taskOwnerScopeKeyBuilder;
this.payloadReader = payloadReader;
this.userApiSecretService = userApiSecretService;
@@ -134,7 +138,24 @@ public class AppearancePatentLlmSubmissionSupport {
}
TaskFileJobEntity job = taskFileJobService.enqueueAssembleResult(
task.getId(), moduleType, result.getId(), taskOwnerScopeKeyBuilder.apply(task));
if (job == null || "SUCCESS".equals(job.getStatus())) {
if (job != null && JOB_STATUS_SUCCESS.equals(job.getStatus())) {
// 任务仍是 RUNNING(函数开头已把终态 SUCCESS 挡掉)却拿回一份「已交付」的作业:
// 那是上一代的成品,不能用来挡这一代——底座 .ne SUCCESS 的早退是刻意的
// (没人要求重做时不许替换用户可能已经下载的成品),这里就是「要求重做」的那一处。
// 2026-11-11 现网 33924:原任务复位重试(代数 3/3)后又把 200 组全采了一遍,
// 末分片 03:37:54 交完,却因 01:18 那份 SUCCESS 作业原样返回,一句日志都没有地
// 空等 30 分钟被判死。复位必须等本代交完(末分片 done=true)再做:半批就复位会让
// 组装读到半批行,覆盖率闸门反过来把这轮出表判死。
if (!submissionComplete.test(task.getId())) {
return;
}
log.warn("[appearance-patent] 续跑的新一代已交完,复位上一代已交付的出表作业 taskId={} resultId={} jobId={}",
task.getId(), result.getId(), job.getId());
deliveredAssembleRearmer.accept(task.getId());
job = taskFileJobService.enqueueAssembleResult(
task.getId(), moduleType, result.getId(), taskOwnerScopeKeyBuilder.apply(task));
}
if (job == null || JOB_STATUS_SUCCESS.equals(job.getStatus())) {
return;
}
taskFileJobService.requeue(job.getId(), "Appearance patent result uploaded, scheduling LLM/file assembly");
@@ -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());
}
}