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");