fix(phase-5): AC-7 服务端半边——京东上架失败重试复位 biz_jd_publish_item 明细行(v1.5 蓝图 Phase 5 消欠账)——新增 TaskItemsResetSpi(modules/task/spi,task侧不import业务模块,依赖方向 jd→task 与 ClientTaskRetrySpi 同族),TaskInPlaceRetryService 在任务头 CAS 复位成功后按 moduleType 调用;JdPublishTaskItemsResetSpiImpl 把 FAILED/PUBLISHING 行复位 PENDING 并清旧 publish_error,SUCCESS 行不动(AC-4 已发布不重发,客户端断点 done 同口径);刻意不吞异常(半截状态纪律与 clearDeliveredResultUrl 同一);判据:JdPublishTaskItemsResetSpiImplTest 2(wrapper 形状探针:行状态谓词只认 FAILED/PUBLISHING、publish_error 清 NULL)+TaskInPlaceRetryServiceTest +4(复位被调/无匹配跳过/CAS失败不碰明细/复位失败响亮传播)

This commit is contained in:
zwork
2026-11-18 14:04:51 +08:00
parent 1524099d3b
commit 83e9bbe71a
5 changed files with 258 additions and 1 deletions
@@ -0,0 +1,50 @@
package com.nanri.aiimage.modules.jd.service;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.nanri.aiimage.modules.jd.mapper.JdPublishItemMapper;
import com.nanri.aiimage.modules.jd.model.entity.JdPublishItemEntity;
import com.nanri.aiimage.modules.task.spi.TaskItemsResetSpi;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.time.LocalDateTime;
/**
* 京东商品上架的失败重试明细行复位(AC-7 服务端半边,v1.5 Phase 5 消欠账)。
*
* <p>任务头被 {@code TaskInPlaceRetryService} 原地复位成 PENDING 后,明细分批下发
* {@code JdPublishItemMapper.selectPublishableItems} 只出 PENDING 行——上一代留下的
* FAILED/PUBLISHING 行不复位,重试就是空页空跑(蓝图 Phase 2 变更记录登记的欠账)。
* 本实现把 FAILED/PUBLISHING 行复位回 PENDING 并清旧错误文案,让剩余商品重新进入
* 下发候选;SUCCESS 行不动:已发布商品不重发(AC-4),客户端断点 done 集合同口径。
*
* <p>{@code jd_ware_id} 不清:只有 SUCCESS 行才有值,本条不碰 SUCCESS 行;
* 旧 {@code publish_error} 必须清——留着会让用户端面板把「上一代的失败原因」
* 显示在「待发布」行上(进度真源是行级状态聚合,JdPublishBoardService 同源)。
*/
@Slf4j
@Service
@RequiredArgsConstructor
public class JdPublishTaskItemsResetSpiImpl implements TaskItemsResetSpi {
private final JdPublishItemMapper jdPublishItemMapper;
@Override
public String moduleType() {
return JdPublishTaskService.MODULE_TYPE;
}
@Override
public void resetForRetry(Long taskId) {
LocalDateTime now = LocalDateTime.now();
int updated = jdPublishItemMapper.update(null, new LambdaUpdateWrapper<JdPublishItemEntity>()
.eq(JdPublishItemEntity::getTaskId, taskId)
.in(JdPublishItemEntity::getPublishStatus,
JdPublishTaskService.ITEM_FAILED, JdPublishTaskService.ITEM_PUBLISHING)
.set(JdPublishItemEntity::getPublishStatus, JdPublishTaskService.ITEM_PENDING)
.set(JdPublishItemEntity::getPublishError, null)
.set(JdPublishItemEntity::getUpdatedAt, now));
log.info("[jd-publish][retry] 明细行已复位可续跑 taskId={} reset={}", taskId, updated);
}
}
@@ -11,11 +11,13 @@ 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.spi.TaskItemsResetSpi;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.time.LocalDateTime;
import java.util.List;
import com.nanri.aiimage.modules.task.service.support.TaskFailureLedger;
/**
@@ -64,6 +66,7 @@ public class TaskInPlaceRetryService {
private final TaskFileJobService taskFileJobService;
private final TaskFileJobMapper taskFileJobMapper;
private final ResultFileJobHandlerRegistry resultFileJobHandlers;
private final List<TaskItemsResetSpi> itemsResetSpis;
/**
* 把一条失败/已中断任务复位成待执行。幂等:只有当前状态确实是 FAILED/CANCELLED 才动作。
@@ -105,6 +108,9 @@ public class TaskInPlaceRetryService {
log.info("[task-retry] 状态已不是 FAILED/CANCELLED,跳过复位 taskId={}", task.getId());
return false;
}
// 模块侧明细行复位(AC-7 服务端半边):不复位则重试后的明细分批下发是空页、任务空跑。
// 无匹配实现=该模块没有模块侧明细行,什么也不做。
resetModuleItems(task.getId(), task.getModuleType());
// 形状 (a) 与中断代共用这一段:<b>失败代也要清直链</b>(B96-08 第 1 条修法)。
// 旧写法只给中断代清、失败代留直链(本意「上一份可能已经可用」),叠上交付闸
// 「直链非空即跳过」就成了恒定空转:作业复位后 2 秒又被标回 SUCCESS,新一代永远组装不了。
@@ -216,6 +222,23 @@ public class TaskInPlaceRetryService {
}
}
/**
* 模块侧明细行复位(AC-7 服务端半边):京东上架的行级真源在 biz_jd_publish_item,
* 上一代的 FAILED/PUBLISHING 行不复位,重试后的明细分批下发(只出 PENDING 行)就是
* 空页、任务空跑。无匹配实现=该模块没有模块侧明细行可复位,直接跳过。
*
* <p>刻意不吞异常(静默 catch 台账只许减):复位失败会留下「任务已 PENDING、明细没跟上」
* 的半截状态,与 {@link #clearDeliveredResultUrl} 同一纪律——响亮失败让用户当场看到,
* 不做半截继续。
*/
private void resetModuleItems(Long taskId, String moduleType) {
for (TaskItemsResetSpi spi : itemsResetSpis) {
if (moduleType.equals(spi.moduleType())) {
spi.resetForRetry(taskId);
return;
}
}
}
/** 结果行只清错误文案:直链由 {@link #clearDeliveredResultUrl} 在复位前单独清(B96-08)。 */
private void clearResultError(Long taskId, String moduleType) {
try {
@@ -0,0 +1,30 @@
package com.nanri.aiimage.modules.task.spi;
/**
* 失败/中断任务「在原任务上重试」的模块侧明细行复位扩展点(AC-7 服务端半边)。
*
* <p>背景:京东上架(JD_PUBLISH)的行级真源在 {@code biz_jd_publish_item}(V210),
* 任务头被 {@code TaskInPlaceRetryService} 原地复位成 PENDING 后,明细分批下发
* {@code selectPublishableItems} 只出 PENDING 行——上一代留下的 FAILED/PUBLISHING 行
* 不复位,重试后的下发就是空页、任务空跑到判死(v1.5 蓝图 Phase 2 变更记录登记的欠账)。
*
* <p>各模块按需实现本接口,Spring 装配后由 {@code TaskInPlaceRetryService} 在任务头 CAS
* 复位成功后按 {@code moduleType} 建索引调用。task 侧不 import 业务模块(task→业务依赖
* 钉死为 0,{@code ArchitectureBoundaryTest} 同口径),与 {@link ClientTaskRetrySpi} 同族
* 但语义相反:那个是「克隆新任务」的旧路(外观专利等解析载荷可整体复制的模块),
* 这个是「原地续跑」——失败任务重试不克隆(2026-11-01 铁律 26)。
*/
public interface TaskItemsResetSpi {
/** 本实现负责的 moduleType(与 biz_file_task.module_type 一致)。 */
String moduleType();
/**
* 把该任务在模块侧的明细行复位成可续跑态。
*
* <p>仅在任务头 CAS 复位成功后被调用;失败不得吞异常——吞掉会留下
* 「任务已 PENDING、明细还是旧状态」的半截状态,用户重按也修不回来
* (状态闸会拒「只有失败或已中断的任务可以继续」),宁可当场响亮失败。
*/
void resetForRetry(Long taskId);
}
@@ -0,0 +1,73 @@
package com.nanri.aiimage.modules.jd.service;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.nanri.aiimage.modules.jd.mapper.JdPublishItemMapper;
import com.nanri.aiimage.modules.jd.model.entity.JdPublishItemEntity;
import com.nanri.aiimage.testutil.UpdateWrapperProbe;
import org.apache.ibatis.builder.MapperBuilderAssistant;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
import java.util.Map;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.isNull;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
* AC-7 服务端半边(v1.5 Phase 5 消欠账):京东上架失败任务「重试」时,
* {@code biz_jd_publish_item} 的 FAILED/PUBLISHING 行必须复位回 PENDING 并清旧错误文案。
*
* <p>不复位的后果(蓝图 Phase 2 变更记录登记):任务头复位成 PENDING 后,
* 明细分批下发 {@code selectPublishableItems} 只出 PENDING 行——重试就是空页空跑,
* 任务等满 stale 窗口再被判死一次。SUCCESS 行不动(已发布商品不重发,AC-4)。
*/
class JdPublishTaskItemsResetSpiImplTest {
@BeforeAll
static void initMybatisPlusTableInfo() {
TableInfoHelper.initTableInfo(new MapperBuilderAssistant(new MybatisConfiguration(), ""),
JdPublishItemEntity.class);
}
@Test
void moduleType与建单模块一致() {
assertEquals("JD_PUBLISH",
new JdPublishTaskItemsResetSpiImpl(mock(JdPublishItemMapper.class)).moduleType());
}
@Test
void 复位只圈FAILED与PUBLISHING行_清旧错误文案_不碰SUCCESS() {
JdPublishItemMapper mapper = mock(JdPublishItemMapper.class);
when(mapper.update(isNull(), any())).thenReturn(3);
new JdPublishTaskItemsResetSpiImpl(mapper).resetForRetry(34567L);
@SuppressWarnings("unchecked")
ArgumentCaptor<LambdaUpdateWrapper<JdPublishItemEntity>> captor =
ArgumentCaptor.forClass(LambdaUpdateWrapper.class);
verify(mapper).update(isNull(), captor.capture());
LambdaUpdateWrapper<JdPublishItemEntity> wrapper = captor.getValue();
Map<String, Object> sets = UpdateWrapperProbe.setValues(wrapper);
assertEquals("PENDING", sets.get("publish_status"), "复位目标态必须是 PENDING(下发只出 PENDING 行)");
assertTrue(sets.containsKey("publish_error"), "旧失败文案必须清");
assertNull(sets.get("publish_error"), "旧失败文案清成 NULL,不留给待发布行");
assertTrue(sets.containsKey("updated_at"), "行级 updated_at 随复位推进");
// WHERE:按任务圈行;行状态谓词只认 FAILED/PUBLISHING——SUCCESS 行是已发布商品,不重发(AC-4)
assertEquals(34567L, UpdateWrapperProbe.whereEq(wrapper).get("task_id"));
Map<String, Object> params = UpdateWrapperProbe.paramNameValuePairs(wrapper);
assertTrue(params.containsValue("FAILED"), "行状态谓词必须含 FAILED");
assertTrue(params.containsValue("PUBLISHING"), "行状态谓词必须含 PUBLISHING(中断遗留行)");
assertTrue(params.containsValue("PENDING"), "复位目标值在参数册");
}
}
@@ -12,6 +12,7 @@ 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.spi.TaskItemsResetSpi;
import org.apache.ibatis.builder.MapperBuilderAssistant;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
@@ -83,7 +84,16 @@ class TaskInPlaceRetryServiceTest {
TaskChunkMapper chunks, TaskFileJobService jobs,
TaskFileJobMapper jobMapper,
ResultFileJobHandlerRegistry registry) {
return new TaskInPlaceRetryService(mapper, results, chunks, jobs, jobMapper, registry);
return service(mapper, results, chunks, jobs, jobMapper, registry, java.util.List.of());
}
/** AC-7 服务端半边:模块侧明细行复位 SPI(京东上架 JD_PUBLISH)。 */
private static TaskInPlaceRetryService service(FileTaskMapper mapper, FileResultMapper results,
TaskChunkMapper chunks, TaskFileJobService jobs,
TaskFileJobMapper jobMapper,
ResultFileJobHandlerRegistry registry,
java.util.List<TaskItemsResetSpi> itemsResetSpis) {
return new TaskInPlaceRetryService(mapper, results, chunks, jobs, jobMapper, registry, itemsResetSpis);
}
@Test
@@ -118,6 +128,77 @@ class TaskInPlaceRetryServiceTest {
assertFalse(ok);
verify(jobs, never()).resetTerminalFailedForRecovery(anyLong(), any(), anyLong());
}
// ---- AC-7 服务端半边(v1.5 Phase 5):模块侧明细行随任务头一并复位 ----
@Test
void 京东上架重试必须复位模块侧明细行() {
FileTaskMapper mapper = mock(FileTaskMapper.class);
FileResultMapper results = mock(FileResultMapper.class);
TaskFileJobService jobs = mock(TaskFileJobService.class);
when(mapper.update(isNull(), any())).thenReturn(1);
TaskItemsResetSpi jdSpi = mock(TaskItemsResetSpi.class);
when(jdSpi.moduleType()).thenReturn("JD_PUBLISH");
FileTaskEntity task = failedTask();
task.setModuleType("JD_PUBLISH");
service(mapper, results, mock(TaskChunkMapper.class), jobs,
mock(TaskFileJobMapper.class), mock(ResultFileJobHandlerRegistry.class),
java.util.List.of(jdSpi)).retryInPlace(task);
// 明细行随任务头一起回到 PENDING,否则重试后的明细分批下发(只出 PENDING 行)是空页空跑
verify(jdSpi).resetForRetry(eq(32967L));
}
@Test
void 任务头复位失败时不碰模块明细行() {
FileTaskMapper mapper = mock(FileTaskMapper.class);
FileResultMapper results = mock(FileResultMapper.class);
TaskFileJobService jobs = mock(TaskFileJobService.class);
when(mapper.update(isNull(), any())).thenReturn(0);
TaskItemsResetSpi jdSpi = mock(TaskItemsResetSpi.class);
when(jdSpi.moduleType()).thenReturn("JD_PUBLISH");
service(mapper, results, mock(TaskChunkMapper.class), jobs,
mock(TaskFileJobMapper.class), mock(ResultFileJobHandlerRegistry.class),
java.util.List.of(jdSpi)).retryInPlace(failedTask());
verify(jdSpi, never()).resetForRetry(anyLong());
}
@Test
void 无匹配模块的明细复位直接跳过() {
FileTaskMapper mapper = mock(FileTaskMapper.class);
FileResultMapper results = mock(FileResultMapper.class);
TaskFileJobService jobs = mock(TaskFileJobService.class);
when(mapper.update(isNull(), any())).thenReturn(1);
TaskItemsResetSpi jdSpi = mock(TaskItemsResetSpi.class);
when(jdSpi.moduleType()).thenReturn("JD_PUBLISH");
service(mapper, results, mock(TaskChunkMapper.class), jobs,
mock(TaskFileJobMapper.class), mock(ResultFileJobHandlerRegistry.class),
java.util.List.of(jdSpi)).retryInPlace(failedTask());
verify(jdSpi, never()).resetForRetry(anyLong());
}
@Test
void 明细复位失败必须响亮失败不留半截状态() {
FileTaskMapper mapper = mock(FileTaskMapper.class);
FileResultMapper results = mock(FileResultMapper.class);
TaskFileJobService jobs = mock(TaskFileJobService.class);
when(mapper.update(isNull(), any())).thenReturn(1);
TaskItemsResetSpi jdSpi = mock(TaskItemsResetSpi.class);
when(jdSpi.moduleType()).thenReturn("JD_PUBLISH");
org.mockito.Mockito.doThrow(new IllegalStateException("reset failed"))
.when(jdSpi).resetForRetry(anyLong());
FileTaskEntity task = failedTask();
task.setModuleType("JD_PUBLISH");
// 吞掉会留下「任务已 PENDING、明细没跟上」的半截状态,用户重按也修不回来
assertThrows(IllegalStateException.class, () -> service(mapper, results,
mock(TaskChunkMapper.class), jobs, mock(TaskFileJobMapper.class),
mock(ResultFileJobHandlerRegistry.class), java.util.List.of(jdSpi)).retryInPlace(task));
}
// ---- 「继续」(2026-11-03):已中断任务在原任务上复位 ----