fix(phase-6.1): CR 六项修复——派发链三件套/登记顺序/判死口凭据化/脏时间可读/UPDATE 段摘死列

This commit is contained in:
2026-11-14 13:53:03 +08:00
parent edeffc26c4
commit 796ec2130f
10 changed files with 346 additions and 32 deletions
@@ -65,8 +65,12 @@ public class JdCollectController {
public ApiResponse<JdIngestChunkVo> submitChunk(
@Parameter(description = "任务 ID", required = true, example = "33890")
@PathVariable Long taskId,
@RequestBody JdIngestChunkRequest request) {
return ApiResponse.success(ingestService.submitChunk(taskId, request));
@RequestBody JdIngestChunkRequest request,
HttpServletRequest httpRequest) {
// P1-2 判死口凭据化:error 上报是唯一能触发整单判死的入口,匿名一律拒绝判死
// (items 落库仍走 PENDING_CONVERGENCE 既有欠账形状)。可信判定单一出口 isTrustedInternalToken。
boolean trustedErrorReporter = adminAuthSupport.isTrustedInternalToken(httpRequest);
return ApiResponse.success(ingestService.submitChunk(taskId, request, trustedErrorReporter));
}
@PostMapping("/tasks/{taskId}/heartbeat")
@@ -72,7 +72,7 @@ public class JdResultIngestService {
private final JdProductImageIngestService jdProductImageIngestService;
private final ObjectMapper objectMapper;
public JdIngestChunkVo submitChunk(Long taskId, JdIngestChunkRequest request) {
public JdIngestChunkVo submitChunk(Long taskId, JdIngestChunkRequest request, boolean trustedErrorReporter) {
if (taskId == null || taskId <= 0) {
throw new BusinessException("taskId 不合法");
}
@@ -84,7 +84,7 @@ public class JdResultIngestService {
throw new BusinessException("任务已结束(" + task.getStatus() + "),回传被拒");
}
if (request.getError() != null && !request.getError().isBlank()) {
return handleErrorReport(task, request.getError().trim());
return handleErrorReport(task, request.getError().trim(), trustedErrorReporter);
}
if (!STATUS_RUNNING.equals(task.getStatus())) {
throw new BusinessException("任务不在运行中(" + task.getStatus() + "),回传被拒");
@@ -102,6 +102,10 @@ public class JdResultIngestService {
int deduped = 0;
int imageCount = 0;
List<JdProductEntity> rows = new ArrayList<>();
// 图片登记延后到 upsert 之后(P0-2):registerTaskImages 按 companyId+taskId+productCode
// 查商品行,首采行在 upsert 前必然不存在 → 登记会被 100% 跳过、图片永远落不了库。
// 这里先收集,行落库后再逐商品登记。
List<PendingImageRegistration> pendingImages = new ArrayList<>();
if (request.getItems() != null) {
for (JdIngestChunkRequest.JdIngestItemDto item : request.getItems()) {
if (item == null || isBlank(item.getProductCode())) {
@@ -116,15 +120,19 @@ public class JdResultIngestService {
continue;
}
rows.add(buildRow(task, companyId, createRequest, item, summary, request.getBatchId(), scope));
// Phase 4:直传完成的图片清单按 statObject 对撞落 biz_jd_product_image(登记链唯一出口
// JdProductImageIngestService,uk_product_image 幂等;商品行未落库时跳过不落孤儿行)。
imageCount += jdProductImageIngestService.registerTaskImages(taskId, companyId,
item.getProductCode().trim(), toImageSpecs(item.getImages()));
pendingImages.add(new PendingImageRegistration(item.getProductCode().trim(),
toImageSpecs(item.getImages())));
}
}
if (!rows.isEmpty()) {
jdProductMapper.upsertBatch(rows);
}
// Phase 4:直传完成的图片清单按 statObject 对撞落 biz_jd_product_image(登记链唯一出口
// JdProductImageIngestService,uk_product_image 幂等)——必须在商品行落库之后执行。
for (PendingImageRegistration pending : pendingImages) {
imageCount += jdProductImageIngestService.registerTaskImages(taskId, companyId,
pending.productCode(), pending.specs());
}
int itemsReceived = mergeScopeState(scope, request, request.getItems() == null ? 0 : request.getItems().size());
if (Boolean.TRUE.equals(request.getIsEnd())) {
finalizeSuccess(task, itemsReceived);
@@ -137,8 +145,17 @@ public class JdResultIngestService {
return vo;
}
/** 铁律 31 分档:京麦登录态失效 → 整单终态;代理/LLM 致命 → CredentialFatalTaskCloser;其余只记录。 */
private JdIngestChunkVo handleErrorReport(FileTaskEntity task, String error) {
/** 铁律 31 分档:京麦登录态失效 → 整单终态;代理/LLM 致命 → CredentialFatalTaskCloser;其余只记录。
*
* <p>P1-2:error 上报是唯一能触发整单判死的入口,只认可信内部凭据(X-Internal-Token,
* 判定单一出口 isTrustedInternalToken)——匿名 error 一律拒绝判死(不碰任务状态),
* 防止枚举 taskId 即可把任意 RUNNING 京东任务判死。</p>
*/
private JdIngestChunkVo handleErrorReport(FileTaskEntity task, String error, boolean trustedErrorReporter) {
if (!trustedErrorReporter) {
log.warn("[{}] 匿名失败上报拒绝判死(缺可信内部凭据)taskId={} err={}", LOG_TAG, task.getId(), error);
return reject("失败上报需要可信内部凭据(X-Internal-Token),已拒绝判死");
}
if (JdStaleTaskService.isJdLoginStateFailure(error)) {
jdStaleTaskService.terminalizeOnJdLoginFatal(task, error);
return reject("京麦登录态失效,任务已终止,请在客户端重新登录京麦");
@@ -316,13 +333,18 @@ public class JdResultIngestService {
}
}
/** 京东侧时间口径 yyyy-MM-dd HH:mm:ss(容 ISO 的 T 分隔,归一后单格式解析;解析失败直接拒批,不静默置空)。 */
private static LocalDateTime parseJdTime(String raw) {
/** 京东侧时间口径 yyyy-MM-dd HH:mm:ss(容 ISO 的 T 分隔,归一后单格式解析;解析失败可读拒批,不静默置空)。 */
static LocalDateTime parseJdTime(String raw) {
if (raw == null || raw.isBlank()) {
return null;
}
return LocalDateTime.parse(raw.trim().replace('T', ' '),
DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
String normalized = raw.trim().replace('T', ' ');
try {
return LocalDateTime.parse(normalized, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
} catch (java.time.format.DateTimeParseException ex) {
// 一行脏时间不许让整批回传 500 裸堆栈:抛可读拒绝(原文进 message,不进堆栈页)。
throw new BusinessException("京东时间格式不识别(应为 yyyy-MM-dd HH:mm:ss): " + normalized);
}
}
private String cursorTab(TaskScopeStateEntity scope) {
@@ -383,4 +405,9 @@ public class JdResultIngestService {
private static final com.fasterxml.jackson.core.type.TypeReference<Map<String, Object>> STATE_TYPE =
new com.fasterxml.jackson.core.type.TypeReference<>() {
};
/** 延后登记的图片明细(P0-2:商品行 upsert 之后才查得到行,登记必须延后)。 */
private record PendingImageRegistration(String productCode,
List<JdProductImageIngestService.JdIngestImageSpec> specs) {
}
}
@@ -0,0 +1,52 @@
package com.nanri.aiimage.modules.jd.service;
import com.nanri.aiimage.modules.jd.model.dto.JdCollectTaskCreateRequest;
import com.nanri.aiimage.modules.task.model.entity.FileTaskEntity;
import com.nanri.aiimage.modules.task.spi.ClientTaskPullSpi;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* 京东店铺采集的客户端兜底拉取实现(v1.4 Phase 6.1 修 P0-1:派发链断头)。
*
* <p>页面推送缺失(只建单没推送 / 推送前关页面 / 纯浏览器打开)时任务会停在 PENDING,
* {@code TaskClientPullService} 认领后由本实现组装可直接入队的载荷。{@code data} 的键集
* 与客户端 {@code jd_base.process_task} 的读取契约同键({@code taskId / shopName /
* listTabs / maxProducts},{@code QUEUE_TYPE} 与客户端 {@code amazon.jd.jd_base.QUEUE_TYPE}
* 同值 {@code jd-shop-collect-run})——两处任意一处漂移,兜底拉下来的任务客户端不识别。</p>
*
* <p>shopName/listTabs/maxProducts 从建单载荷({@code request_json})回读,与页面推送
* 同源;载荷解析失败按 SPI 语义返回 null(调用方会把任务标失败并回写原因),不静默出空载荷。</p>
*/
@Slf4j
@Service
@RequiredArgsConstructor
public class JdTaskPullSpiImpl implements ClientTaskPullSpi {
/** 与客户端 amazon/jd/jd_base.py 的 QUEUE_TYPE 逐字同值(改这里必须同轮改客户端)。 */
public static final String QUEUE_TYPE = "jd-shop-collect-run";
private final JdCollectTaskService collectTaskService;
@Override
public String moduleType() {
return JdCollectTaskService.MODULE_TYPE;
}
@Override
public Map<String, Object> buildQueuePayload(FileTaskEntity task) {
JdCollectTaskCreateRequest create = collectTaskService.readCreateRequest(task);
Map<String, Object> data = new LinkedHashMap<>();
data.put("taskId", task.getId());
data.put("shopName", create.getShopName());
data.put("listTabs", create.getListTabs());
data.put("maxProducts", create.getMaxProducts());
log.info("[jd-collect] 兜底载荷已组装 taskId={} shopName={} tabs={}",
task.getId(), create.getShopName(), create.getListTabs());
return Map.of("type", QUEUE_TYPE, "data", data);
}
}
@@ -41,6 +41,10 @@ AIIMAGE_JD_COLLECT_PAGE_SIZE=50
AIIMAGE_JD_COLLECT_DETAIL_CONCURRENCY=1
AIIMAGE_JD_COLLECT_IMAGE_MAX_PER_PRODUCT=200
AIIMAGE_JD_COLLECT_STALE_MINUTES=60
# 京东采集的客户端兜底拉取白名单(v1.4 P0-1):默认值已含 JD_SHOP_COLLECT(见 application.yml)。
# ⚠ 只有真的要覆盖整个白名单时才设 AIIMAGE_CLIENT_TASK_PULL_MODULE_TYPES——env 变量存在即生效,
# 设成空串会把白名单清空(兜底拉取对 JD 形同关闭)。打开 AIIMAGE_CLIENT_TASK_PULL_ENABLED
# 前先确认客户端版本带兜底拉取线程。
# 任务异常现场证据件(v1.2 Phase 3):独立桶与保留期必须显式配置;桶不得复用 nanri-ai-images。
AIIMAGE_EVIDENCE_OSS_BUCKET=task-evidence
@@ -414,7 +414,10 @@ aiimage:
enabled: ${AIIMAGE_CLIENT_TASK_PULL_ENABLED:false}
# 2026-09-30 外观专利已迁移 Linux 后台执行(内部认领),不再由客户端浏览器兜底执行,
# 因此默认白名单移除 APPEARANCE_PATENT,防止未来误开 enabled 时客户端又抢着抓取。
module-types: ${AIIMAGE_CLIENT_TASK_PULL_MODULE_TYPES:SIMILAR_ASIN,COLLECT_DATA}
# 2026-11-14 v1.4 加 JD_SHOP_COLLECT(P0-1):京东采集只能在本机客户端执行(紫鸟/京麦
# 登录态在桌面机),页面推送缺失时任务会永久停在 PENDING——兜底拉取是它的唯一出路;
# queuePayload 由 JdTaskPullSpiImpl 组装(type=jd-shop-collect-run,与客户端同值)。
module-types: ${AIIMAGE_CLIENT_TASK_PULL_MODULE_TYPES:SIMILAR_ASIN,COLLECT_DATA,JD_SHOP_COLLECT}
min-pending-minutes: ${AIIMAGE_CLIENT_TASK_PULL_MIN_PENDING_MINUTES:5}
limit: ${AIIMAGE_CLIENT_TASK_PULL_LIMIT:5}
# 服务端内部认领(/api/internal/tasks/pull-pending,Linux 后台 worker 专用),
@@ -7,12 +7,16 @@
(R6/AC-5)。后管只读页的分页/筛选 SQL(Phase 5)落同份 XML。 -->
<!-- 同步链唯一写入口(Phase 2 落 JdResultIngestService):多值批量 upsert,
AppearancePatentCleanItemMapper#upsertBatch 同形。刻意不写 company_id/shop_id/
AppearancePatentCleanItemMapper#upsertBatch 同形。刻意不写 company_id/
product_code 的 UPDATE 段(唯一键三元组自身不随更新漂移);
synced_at 在 UPDATE 段显式刷 CURRENT_TIMESTAMP(INSERT 路径走列默认值,
显式传 null 会覆盖掉默认值,故两段口径分开)。
⚠ upsert-only:回传读出 0 行=什么都不写,不得 delete-then-insert 覆盖式重写
(重投递载荷读不准时会抹掉存量,AppearancePatentCleanItemMapper 2026-11-11 实录)。 -->
(重投递载荷读不准时会抹掉存量,AppearancePatentCleanItemMapper 2026-11-11 实录)。
⚠ UPDATE 段不写 image_count / main_image_url(P1-1):buildRow 恒 0/恒 null,
写进 UPDATE 会把登记链 refreshProductImageCount 刷的真实计数抹回 0
(后管「图片数」恒 0);image_count 只由登记侧按表实数刷,main_image_url
是 P2 死列(BACKLOG B98-01)不随更新。 -->
<insert id="upsertBatch">
INSERT INTO biz_jd_product
(company_id, user_id, task_id, shop_id, shop_name, product_code, sku_id,
@@ -44,11 +48,9 @@
list_tab = VALUES(list_tab),
jd_created_at = VALUES(jd_created_at),
jd_updated_at = VALUES(jd_updated_at),
main_image_url = VALUES(main_image_url),
detail_url = VALUES(detail_url),
attr_json = VALUES(attr_json),
attr_count = VALUES(attr_count),
image_count = VALUES(image_count),
collect_batch_id = VALUES(collect_batch_id),
synced_at = CURRENT_TIMESTAMP
</insert>
@@ -352,7 +352,12 @@ class CatchSilenceRatchetTest {
// `JdProductQueryService.writeExportWorkbook`:SXSSF 落盘 `catch Exception` →
// BusinessException「导出京东数据库失败,请稍后重试」(RETHROW +1,与 11-11 外观专利导出同款)。
// 本批复核办法:单跑实测 total 1090、notRethrow 614、logOnly 194、empty 56(EMPTY 一格没涨)。
static final int STRICT_TOTAL = 1090;
// 11-14 Phase 6.1 CR 修复抬 1090 -> 1091,一枚逐处记名:
// `JdResultIngestService.parseJdTime`:DateTimeParseException → BusinessException
// 「京东时间格式不识别(应为 yyyy-MM-dd HH:mm:ss): <原文>」(RETHROW)。误差方向:
// 客户端回传脏时间戳之前直接 DateTimeParseException 裸抛 = 回传口 500 裸堆栈(P1-3);
// 改成吞掉置 null = 登记时间被悄悄抹掉。
static final int STRICT_TOTAL = 1091;
/**
* 重抛型 catch 的**下限**(不是上限):本轮把两处吞异常改成重抛之后实测 388。
* 这一格只能涨不能跌——它是"异常会往外走"的总量,把它钉成"只许减"就等于拦着别人修吞异常。
@@ -35,11 +35,13 @@ import java.util.List;
import java.util.Map;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyList;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.ArgumentMatchers.isNull;
import static org.mockito.Mockito.inOrder;
import static org.mockito.Mockito.lenient;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.when;
@@ -175,7 +177,7 @@ class JdProductSyncServiceTest {
stubHappyPath();
JdIngestChunkVo vo = service.submitChunk(TASK_ID,
chunk(item("10036442942137", "艺考形体服女"), item("10036442942138", "艺考形体服男")));
chunk(item("10036442942137", "艺考形体服女"), item("10036442942138", "艺考形体服男")), true);
assertThat(vo.isAccept()).isTrue();
assertThat(vo.getUpserted()).isEqualTo(2);
@@ -203,8 +205,8 @@ class JdProductSyncServiceTest {
stubHappyPath();
JdIngestChunkRequest request = chunk(item("10036442942137", "艺考形体服女"));
service.submitChunk(TASK_ID, request);
service.submitChunk(TASK_ID, request);
service.submitChunk(TASK_ID, request, true);
service.submitChunk(TASK_ID, request, true);
verify(jdProductMapper, times(2)).upsertBatch(anyList());
verify(jdProductMapper, never()).delete(any(Wrapper.class));
@@ -228,8 +230,8 @@ class JdProductSyncServiceTest {
String xml = Files.readString(Path.of("src/main/resources/mapper/jd/JdProductMapper.xml"));
assertThat(xml).contains("synced_at = CURRENT_TIMESTAMP");
service.submitChunk(TASK_ID, chunk(item("10036442942137", "艺考形体服女")));
service.submitChunk(TASK_ID, chunk(item("10036442942137", "艺考形体服女")));
service.submitChunk(TASK_ID, chunk(item("10036442942137", "艺考形体服女")), true);
service.submitChunk(TASK_ID, chunk(item("10036442942137", "艺考形体服女")), true);
verify(jdProductMapper, times(2)).upsertBatch(anyList());
}
@@ -239,7 +241,7 @@ class JdProductSyncServiceTest {
lenient().when(fileTaskMapper.selectById(TASK_ID)).thenReturn(runningTask());
lenient().when(adminUserMapper.selectById(USER_ID)).thenReturn(owner(null));
JdIngestChunkVo vo = service.submitChunk(TASK_ID, chunk(item("10036442942137", "艺考形体服女")));
JdIngestChunkVo vo = service.submitChunk(TASK_ID, chunk(item("10036442942137", "艺考形体服女")), true);
assertThat(vo.isAccept()).isFalse();
assertThat(vo.getMessage()).contains("归属");
@@ -253,7 +255,7 @@ class JdProductSyncServiceTest {
request.setItems(List.of());
request.setCursor(null);
JdIngestChunkVo vo = service.submitChunk(TASK_ID, request);
JdIngestChunkVo vo = service.submitChunk(TASK_ID, request, true);
assertThat(vo.isAccept()).isTrue();
assertThat(vo.getUpserted()).isZero();
@@ -296,7 +298,7 @@ class JdProductSyncServiceTest {
JdIngestChunkRequest request = chunk(item("10036442942137", "艺考形体服女"));
request.setIsEnd(true);
service.submitChunk(TASK_ID, request);
service.submitChunk(TASK_ID, request, true);
verify(fileTaskMapper).update(isNull(), any(LambdaUpdateWrapper.class));
verify(taskProgressSnapshotService).markTerminal(eq(TASK_ID), eq("JD_SHOP_COLLECT"), eq("SUCCESS"), anyString());
@@ -311,11 +313,76 @@ class JdProductSyncServiceTest {
request.setBatchId("JD20261114-0002");
request.setError("京麦未登录,请重新登录");
JdIngestChunkVo vo = service.submitChunk(TASK_ID, request);
JdIngestChunkVo vo = service.submitChunk(TASK_ID, request, true);
assertThat(vo.isAccept()).isFalse();
assertThat(vo.getMessage()).contains("京麦");
verify(jdProductMapper, never()).upsertBatch(anyList());
verify(jdStaleTaskService).terminalizeOnJdLoginFatal(any(FileTaskEntity.class), anyString());
}
// ---------- Phase 6.1(CR 修复回归) ----------
@Test
void 图片登记必须晚于商品行upsert_P0_2顺序判据() {
// P0-2(CR):registerTaskImages 按 companyId+taskId+productCode 查商品行,
// 登记若先于 upsertBatch 执行,首采行必然不存在 → 图片登记被 100% 跳过。
// InOrder 验证 mock 调用顺序是真判据:登记先于落库即红。
stubHappyPath();
when(jdProductImageIngestService.registerTaskImages(
any(), eq(COMPANY_ID), anyString(), any())).thenReturn(3);
service.submitChunk(TASK_ID,
chunk(item("10036442942137", "艺考形体服女"), item("10036442942138", "艺考形体服男")), true);
org.mockito.InOrder order = inOrder(jdProductMapper, jdProductImageIngestService);
order.verify(jdProductMapper).upsertBatch(anyList());
order.verify(jdProductImageIngestService, times(2)).registerTaskImages(
any(), eq(COMPANY_ID), anyString(), any());
assertThat(jdProductImageIngestService).isNotNull();
}
@Test
void 匿名失败上报拒绝判死_P1_2判据() {
// P1-2(CR):error 上报是唯一能触发整单判死的入口,匿名(trusted=false)一律拒绝,
// 不碰任务状态——防枚举 taskId 即可判死任意 RUNNING 京东任务。
lenient().when(fileTaskMapper.selectById(TASK_ID)).thenReturn(runningTask());
JdIngestChunkRequest request = new JdIngestChunkRequest();
request.setBatchId("JD20261114-0003");
request.setError("京麦未登录,请重新登录");
JdIngestChunkVo vo = service.submitChunk(TASK_ID, request, false);
assertThat(vo.isAccept()).isFalse();
assertThat(vo.getMessage()).contains("凭据");
verify(jdStaleTaskService, never()).terminalizeOnJdLoginFatal(any(FileTaskEntity.class), anyString());
verify(fileTaskMapper, never()).update(isNull(), any(LambdaUpdateWrapper.class));
verify(taskProgressSnapshotService, never()).markTerminal(any(), any(), any(), any());
}
@Test
void 脏时间可读拒批不裸500_P1_3判据() {
assertThatThrownBy(() -> JdResultIngestService.parseJdTime("2026/11/13 14:06"))
.isInstanceOf(com.nanri.aiimage.common.exception.BusinessException.class)
.hasMessageContaining("京东时间格式不识别")
.hasMessageContaining("2026/11/13 14:06");
// 正常与 ISO T 分隔仍解析
assertThat(JdResultIngestService.parseJdTime("2026-11-13 14:06:07"))
.isEqualTo(LocalDateTime.of(2026, 11, 13, 14, 6, 7));
assertThat(JdResultIngestService.parseJdTime("2026-11-13T14:06:07"))
.isEqualTo(LocalDateTime.of(2026, 11, 13, 14, 6, 7));
assertThat(JdResultIngestService.parseJdTime(" ")).isNull();
}
@Test
void upsertBatch更新段不写image_count与main_image_url_P1_1绊线() throws Exception {
// P1-1(CR):buildRow 恒 0/恒 null,写进 UPDATE 段会把登记链刷新的真实计数抹回 0。
String xml = Files.readString(Path.of("src/main/resources/mapper/jd/JdProductMapper.xml"));
String updateSegment = xml.substring(xml.indexOf("ON DUPLICATE KEY UPDATE"));
assertThat(updateSegment)
.as("UPDATE 段不得写 image_count / main_image_url(登记侧按表实数刷,死列不随更新)")
.doesNotContain("image_count = VALUES")
.doesNotContain("main_image_url = VALUES");
assertThat(updateSegment).contains("synced_at = CURRENT_TIMESTAMP");
}
}
@@ -0,0 +1,113 @@
package com.nanri.aiimage.modules.jd.service;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.nanri.aiimage.modules.jd.model.dto.JdCollectTaskCreateRequest;
import com.nanri.aiimage.modules.task.model.entity.FileTaskEntity;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Spy;
import org.mockito.junit.jupiter.MockitoExtension;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.List;
import java.util.Map;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.when;
/**
* v1.4 Phase 6.1 修 P0-1(派发链断头)的判据:兜底拉取 SPI 的载荷形状与白名单接线。
*
* <p>三个 P0 之一的实证形状:建单后没有任何派发路径(页面不推送、白名单不含 JD、无 SPI 实现),
* 任务永久停在 PENDING(submitChunk 只认 RUNNING,判活只扫 RUNNING)。本类钉住修复后的三件:
* ① SPI 载荷 type 与客户端 {@code jd_base.QUEUE_TYPE} 同值;② data 键集与客户端
* {@code process_task} 读取契约同键;③ 白名单默认值含 {@code JD_SHOP_COLLECT}(源码绊线)。
*/
@ExtendWith(MockitoExtension.class)
class JdTaskPullSpiImplTest {
@Mock
private JdCollectTaskService collectTaskService;
@Spy
private ObjectMapper objectMapper = new ObjectMapper();
@InjectMocks
private JdTaskPullSpiImpl spi;
private FileTaskEntity task() {
FileTaskEntity task = new FileTaskEntity();
task.setId(33890L);
task.setUserId(7L);
task.setModuleType("JD_SHOP_COLLECT");
task.setRequestJson("{\"userId\":7,\"shopName\":\"测试旗舰店\",\"listTabs\":[\"ONSALE\",\"OFFSALE\"],\"maxProducts\":0}");
return task;
}
@Test
void 载荷type与客户端QUEUE_TYPE同值且data键集与客户端契约同键() {
when(collectTaskService.readCreateRequest(any(FileTaskEntity.class)))
.thenAnswer(invocation -> {
FileTaskEntity t = invocation.getArgument(0);
return new ObjectMapper().readValue(t.getRequestJson(), JdCollectTaskCreateRequest.class);
});
Map<String, Object> payload = spi.buildQueuePayload(task());
assertThat(payload.get("type"))
.as("type 与客户端 amazon/jd/jd_base.py 的 QUEUE_TYPE 逐字同值")
.isEqualTo("jd-shop-collect-run");
@SuppressWarnings("unchecked")
Map<String, Object> data = (Map<String, Object>) payload.get("data");
assertThat(data.get("taskId")).isEqualTo(33890L);
assertThat(data.get("shopName")).isEqualTo("测试旗舰店");
assertThat(data.get("listTabs")).isEqualTo(List.of("ONSALE", "OFFSALE"));
assertThat(data.get("maxProducts")).isEqualTo(0);
// 客户端 process_task 只读这四键:多键无害,缺键即空跑——所以逐键钉
assertThat(data.keySet())
.as("data 键集与客户端 jd_base.process_task 读取契约同键(taskId/shopName/listTabs/maxProducts)")
.containsExactlyInAnyOrder("taskId", "shopName", "listTabs", "maxProducts");
}
@Test
void 建单载荷缺失按SPI语义返回异常路径而非空载荷() {
FileTaskEntity broken = task();
broken.setRequestJson("{}");
when(collectTaskService.readCreateRequest(any(FileTaskEntity.class)))
.thenThrow(new com.nanri.aiimage.common.exception.BusinessException("任务载荷缺少 shopName,无法定位店铺"));
assertThatThrownBy(() -> spi.buildQueuePayload(broken))
.isInstanceOf(com.nanri.aiimage.common.exception.BusinessException.class);
}
@Test
void 白名单默认值含JD_SHOP_COLLECT_源码绊线() throws Exception {
// P0-1 的第三件:TaskClientPullService 按 module-types 白名单筛任务——白名单不含
// JD_SHOP_COLLECT 时 SPI 装载了也不会被走到(判据读 application.yml,改默认值必须同轮改这里)。
String yml = Files.readString(Path.of("src/main/resources/application.yml"));
int pullStart = yml.indexOf("client-task-pull:");
assertThat(pullStart).as("application.yml 缺 client-task-pull 段").isGreaterThan(0);
// 段落边界 = 下一个顶层键(零缩进行);文件别处也会出现 min-pending-minutes 等
// 字样,按词定位终点会把起点切到终点之后(本测试首跑即踩)。
String rest = yml.substring(pullStart);
int segEnd = rest.length();
for (String line : rest.split("\n")) {
if (line.contains("client-task-pull:")) {
continue;
}
if (!line.isEmpty() && !Character.isWhitespace(line.charAt(0))) {
segEnd = rest.indexOf(line);
break;
}
}
String segment = rest.substring(0, segEnd);
assertThat(segment)
.as("client-task-pull 白名单默认值必须含 JD_SHOP_COLLECT(P0-1:兜底拉取是 LOCAL 任务的唯一出路)")
.contains("JD_SHOP_COLLECT");
}
}
+40 -3
View File
@@ -1,11 +1,14 @@
<script setup lang="ts">
import { reactive, ref } from 'vue'
import { createJdCollectTask, type JdListTab } from '../../shared/api/types/modules/jd-collect.ts'
import { getPywebviewApi } from '../../shared/bridges/pywebview.ts'
/** 京东店铺商品采集建单页(v1.4 AC-1,蓝图 §3.2)。
*
* 页面只做建单:任务落 PENDING、执行通道固定 LOCAL,由本机客户端在已登录京麦的
* 窗口内领取执行;进度与结果到客户端任务列表(或后台「京东数据库」)查看。
* 建单后把 `jd-shop-collect-run` 载荷推进本机客户端队列(v1.4 Phase 6.1 修 P0-1:
* 只建单不推送会让任务永久停在 PENDING——兜底拉取是补救不是主链)。data 键集与
* 客户端 jd_base.process_task 读取契约同键;推送失败不回滚建单,任务可由服务端
* 兜底拉取(TaskClientPullService 白名单含 JD_SHOP_COLLECT)认领。
*/
const form = reactive({
@@ -26,6 +29,29 @@ function buildListTabs(): JdListTab[] {
return tabs
}
/** 建单成功后推送本机队列;返回 null 表示环境无队列能力(浏览器预览),返回 string 表示失败原因。 */
async function pushToClientQueue(
taskId: number,
shopName: string,
tabs: JdListTab[],
maxProducts: number,
): Promise<string | null> {
const api = getPywebviewApi()
if (!api?.enqueue_json) {
return '当前环境未启用任务队列能力(浏览器预览环境不会启动),请在本机客户端中打开本页'
}
const payload = {
type: 'jd-shop-collect-run',
ts: Date.now(),
data: { taskId, shopName, listTabs: tabs, maxProducts },
}
const pushResult = await api.enqueue_json(payload)
if (pushResult?.success) {
return null
}
return pushResult?.error || '推送本机队列失败,任务将由客户端兜底拉取认领'
}
async function submit() {
errorMessage.value = ''
successMessage.value = ''
@@ -41,9 +67,20 @@ async function submit() {
submitting.value = true
try {
const vo = await createJdCollectTask(form.shopName.trim(), tabs, form.maxProducts)
let pushNote = ''
try {
const pushError = await pushToClientQueue(
vo.taskId, form.shopName.trim(), tabs, form.maxProducts)
if (pushError) {
pushNote = ` ${pushError}`
}
} catch (pushErr) {
// 推送自身异常不回滚建单:任务可由服务端兜底拉取认领
pushNote = ` 推送本机队列异常(${pushErr instanceof Error ? pushErr.message : '未知错误'}),任务将由客户端兜底拉取认领`
}
successMessage.value = `建单成功:任务号 ${vo.taskId}${vo.taskNo ? `(${vo.taskNo})` : ''}。` +
'任务由本机客户端执行,请保持客户端在线并已登录京麦;采集进度在客户端任务列表查看,' +
'落库数据到后台「京东数据库」菜单查询。'
'落库数据到后台「京东数据库」菜单查询。' + pushNote
} catch (err) {
errorMessage.value = err instanceof Error ? err.message : '建单失败,请稍后重试'
} finally {