feat(任务恢复): 外观专利接上「补传恢复」;合并冲突保留兜底对象并可诊断

28459 的两个遗留项:
1) 外观专利缺「补传恢复」入口——分片缺失致组装 job 重试耗尽后,客户端补传缺口
   也无法自动重跑,只能人工重置 job。TaskFileJobService 早有
   resetTerminalFailedForRecovery,但只被删除品牌模块接了。现按同一口径在分片
   提交成功后检查并恢复;best-effort,恢复失败不影响补传本身。
2) 合并 CAS 冲突不可诊断且会删掉唯一的兜底对象——原实现每次冲突都删掉刚写入的
   版本化对象,重试耗尽即抛异常、行仍指向旧指针;一旦旧对象也不在,该分片永久
   读不到(28459 的 chunk-462/473/484 正是这个形态)。现在冲突时读回行上当前
   哈希并写进异常与日志;终局失败保留最后一个对象,作为读路径「同槽位兄弟对象」
   兜底的恢复源。外观专利与相似ASIN 同一口径。

测试:新增 17 个用例(补传恢复 8 / 外观专利合并冲突 5 / 相似ASIN 合并冲突 4),
RED 均已确认;全量 mvn test 3099 个 0 失败。
This commit is contained in:
2026-09-17 11:04:38 +08:00
parent c9be8f87d4
commit 4b162d1f38
5 changed files with 659 additions and 8 deletions
@@ -33,6 +33,7 @@ import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.AtomicReference;
@@ -42,10 +43,12 @@ import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.lenient;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@@ -397,4 +400,98 @@ class SimilarAsinTaskServiceChunkMergeLimitTest {
verify(taskChunkMapper, times(1)).update(any(), any());
verify(taskScopeStateMapper, times(0)).insert(any(TaskScopeStateEntity.class));
}
// ===== CAS 冲突处理(2026-09-17 线上任务 28459 遗留项,与外观专利同一口径) =====
/** 冲突重试耗尽:**保留**最后一次写入的对象作读兜底,异常带出期望/当前哈希。 */
@Test
void casConflictExhaustedKeepsLastStoredObjectAsFallback() throws Exception {
TaskChunkEntity chunk = chunk(7L, "hashA", 1, "ptr:chunk-A");
chunk.setPayloadHash("hashA");
stubConflictMerge(chunk, 0);
FileTaskEntity task = new FileTaskEntity();
task.setId(9004L);
Throwable ex = invokeMergeExpectingFailure(task, List.of(row("r1", "B0A0000001", "标题1")));
assertTrue(ex instanceof IllegalStateException, "实际: " + ex);
verify(transientPayloadStorageService).deletePayloadIfPresent("sibling-1");
verify(transientPayloadStorageService).deletePayloadIfPresent("sibling-2");
verify(transientPayloadStorageService, never()).deletePayloadIfPresent("sibling-3");
assertTrue(ex.getMessage().contains("hashA"), "需带出期望哈希,实际: " + ex.getMessage());
assertTrue(ex.getMessage().contains("hashB"), "需带出当前哈希,实际: " + ex.getMessage());
}
/** 冲突后重试成功:被顶替的中间对象删除,最终对象写入行(不删)。 */
@Test
void casConflictThenSuccessDeletesSupersededObjects() throws Exception {
TaskChunkEntity chunk = chunk(7L, "hashA", 1, "ptr:chunk-A");
chunk.setPayloadHash("hashA");
stubConflictMerge(chunk, 0, 0, 1);
FileTaskEntity task = new FileTaskEntity();
task.setId(9004L);
invokeMerge(service, task, "hashA", 1, List.of(row("r1", "B0A0000001", "标题1")));
verify(transientPayloadStorageService).deletePayloadIfPresent("sibling-1");
verify(transientPayloadStorageService).deletePayloadIfPresent("sibling-2");
verify(transientPayloadStorageService, never()).deletePayloadIfPresent("sibling-3");
verify(transientPayloadStorageService).deleteReplacedPayloadIfNeeded(eq("ptr:chunk-A"), eq("sibling-3"));
}
/** 冲突时读回行上的当前哈希供定位(此前只有一句 conflict,线上无法定位)。 */
@Test
void casConflictReadsBackCurrentHashForDiagnostics() throws Exception {
TaskChunkEntity chunk = chunk(7L, "hashA", 1, "ptr:chunk-A");
chunk.setPayloadHash("hashA");
stubConflictMerge(chunk, 0);
FileTaskEntity task = new FileTaskEntity();
task.setId(9004L);
invokeMergeExpectingFailure(task, List.of(row("r1", "B0A0000001", "标题1")));
verify(taskChunkMapper, times(3)).selectById(7L);
}
/** 读回行失败不得掩盖原始冲突:异常信息里给出可读标记。 */
@Test
void casConflictReadBackFailureDoesNotMaskConflict() throws Exception {
TaskChunkEntity chunk = chunk(7L, "hashA", 1, "ptr:chunk-A");
chunk.setPayloadHash("hashA");
stubConflictMerge(chunk, 0);
when(taskChunkMapper.selectById(anyLong())).thenThrow(new IllegalStateException("db down"));
FileTaskEntity task = new FileTaskEntity();
task.setId(9004L);
Throwable ex = invokeMergeExpectingFailure(task, List.of(row("r1", "B0A0000001", "标题1")));
assertTrue(ex.getMessage().contains("读取失败"), "实际: " + ex.getMessage());
}
/** 反射调用会包一层 InvocationTargetException,取根因以便断言业务异常。 */
private Throwable invokeMergeExpectingFailure(FileTaskEntity task, List<SimilarAsinResultRowDto> rows) throws Exception {
try {
invokeMerge(service, task, "hashA", 1, rows);
return null;
} catch (java.lang.reflect.InvocationTargetException ex) {
return ex.getCause();
}
}
/** 冲突场景公共 stub:每次尝试写一个不同的版本化对象,update 按传入序列返回。 */
private void stubConflictMerge(TaskChunkEntity chunk, Integer... updateResults) throws Exception {
when(taskChunkMapper.selectList(any())).thenReturn(List.of(chunk));
when(taskChunkMapper.selectOne(any())).thenReturn(chunk);
when(transientPayloadStorageService.resolvePayload(eq("ptr:chunk-A"), anyString()))
.thenReturn(rowsJson(List.of(row("r0", "B0A0000000", "存量行"))));
AtomicInteger stores = new AtomicInteger();
when(transientPayloadStorageService.storeChunkPayloadVersioned(
anyString(), any(), anyString(), any(), anyString()))
.thenAnswer(inv -> "sibling-" + stores.incrementAndGet());
when(taskChunkMapper.update(any(), any())).thenReturn(updateResults[0], java.util.Arrays.copyOfRange(updateResults, 1, updateResults.length));
TaskChunkEntity current = chunk(7L, "hashB", 1, "ptr:chunk-A");
current.setPayloadHash("hashB");
lenient().when(taskChunkMapper.selectById(7L)).thenReturn(current);
}
}