diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/service/AppearancePatentTaskCacheService.java b/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/service/AppearancePatentTaskCacheService.java index 7cd170125..2dff0e081 100644 --- a/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/service/AppearancePatentTaskCacheService.java +++ b/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/service/AppearancePatentTaskCacheService.java @@ -4,10 +4,13 @@ import com.nanri.aiimage.modules.appearancepatent.model.dto.AppearancePatentResu import com.nanri.aiimage.modules.task.service.AbstractPendingRowTaskCacheService; import com.fasterxml.jackson.databind.ObjectMapper; import lombok.extern.slf4j.Slf4j; +import org.springframework.data.redis.core.Cursor; +import org.springframework.data.redis.core.ScanOptions; import org.springframework.data.redis.core.StringRedisTemplate; import org.springframework.stereotype.Service; import java.time.Duration; +import java.util.ArrayList; import java.util.List; /** @@ -36,9 +39,45 @@ public class AppearancePatentTaskCacheService extends AbstractPendingRowTaskCach super("appearance-patent", AppearancePatentResultRowDto.class, stringRedisTemplate, objectMapper); } + /** 单次清理最多删除多少枚逐行标记(游标侧的安全阀,防止把一次清理变成无界扫描)。 */ + private static final int ROW_MARK_DELETE_LIMIT = 20_000; + @Override protected void deleteExtraTaskCacheKeys(Long taskId) { - stringRedisTemplate.delete(processedRowsKey(taskId)); + // B74-01:这里原本删的是 processedRowsKey(taskId)——一枚**从不被写入**的基键。 + // 真实完成标记是逐行键 ...:processed-rows:{taskId}:{rowKey},所以"清了任务缓存" + // 一枚行标记都清不掉:任务清完后 24 小时内重建,行仍被标记挡着不再检测, + // 声称保护但不保护。逐行键没有索引,只能按前缀游标扫;用 SCAN 而不是 KEYS + // (KEYS 在生产 redis 上是阻塞命令)。 + String pattern = processedRowsKey(taskId) + ":*"; + List found = new ArrayList<>(); + try (Cursor cursor = stringRedisTemplate.scan( + ScanOptions.scanOptions().match(pattern).count(500).build())) { + while (cursor != null && cursor.hasNext()) { + String key = cursor.next(); + if (key != null && !key.isBlank()) { + found.add(key); + } + if (found.size() >= ROW_MARK_DELETE_LIMIT) { + log.warn("[appearance-patent-cache] 行标记清理已达单轮上限,剩余由 TTL 兜底 " + + "taskId={} limit={}", taskId, ROW_MARK_DELETE_LIMIT); + break; + } + } + } catch (Exception ex) { + // 与本类其余降级口径一致:清不掉就报出来,别让调用方以为"已经清干净了"。 + log.warn("[appearance-patent-cache] delete row marks degraded taskId={} pattern={} msg={}", + taskId, pattern, ex.getMessage()); + return; + } + if (found.isEmpty()) { + return; + } + // 逐行键一起删:基键顺手也删一次(今天它依然不存在,但形状上它是这一族的目录名)。 + found.add(processedRowsKey(taskId)); + stringRedisTemplate.delete(found); + log.info("[appearance-patent-cache] 行标记已随任务缓存清理 taskId={} rowMarks={}", + taskId, found.size() - 1); } /** @@ -58,7 +97,11 @@ public class AppearancePatentTaskCacheService extends AbstractPendingRowTaskCach } Boolean first = stringRedisTemplate.opsForValue().setIfAbsent( inFlightRowKey(taskId, rowKey), "1", IN_FLIGHT_TTL); - return first == null || first; + // B74-01:Redis 回 null(管道/事务态、集群未回包)不等于"抢到了"。旧写法 + // `first == null || first` 把「没抢到」读成「抢到了」,同一行可能被两个入口同时发出去 + // ——重复计费,且两路各自 CAS 同一行。读不出就按未抢到处理,让下一轮重新申领。 + // 注意这不同于 Redis 抛异常:真降级在下面的 catch 里放行,由持久化层 isJudged 兜底。 + return Boolean.TRUE.equals(first); } catch (Exception ex) { log.warn("[appearance-patent-cache] begin row inspection degraded taskId={} rowKey={} msg={}", taskId, rowKey, ex.getMessage()); // Redis 降级时放行,由持久化层的 AppearancePatentRowOutcome.isJudged 判据兜底去重。 diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/service/support/AppearancePatentLlmBatchPipeline.java b/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/service/support/AppearancePatentLlmBatchPipeline.java index 7225abb75..a0b397318 100644 --- a/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/service/support/AppearancePatentLlmBatchPipeline.java +++ b/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/service/support/AppearancePatentLlmBatchPipeline.java @@ -208,7 +208,15 @@ public class AppearancePatentLlmBatchPipeline { Set landedKeys = mergeLlmRowsIntoChunks(task, llmRows, batchRows, rowKeyIndex); // 完成标记只能打在真正落库的行上——这是「发版重启会不会丢行」的分界线 if (batchAnswered) { - List landed = batchRowKeys.stream().filter(landedKeys::contains).toList(); + // B74-01:landed(被塞回某个分片载荷)与 isJudged(有结论列)是两套判据, + // 谁说了算必须只有一个。候选侧(collectPendingLlmCandidates)用的是 isJudged, + // 所以完成标记也必须只打给 isJudged 认的行——否则一行拿到 24 小时标记却没有 + // 结论列:它既不再是候选(被标记挡着),也没结论可出,只能等补检把标记连根撤掉。 + Set judgedKeys = judgedRowKeys(llmRows); + List landed = batchRowKeys.stream() + .filter(landedKeys::contains) + .filter(judgedKeys::contains) + .toList(); if (!landed.isEmpty()) { taskCacheService.completeRowInspection(task.getId(), landed); } @@ -547,6 +555,32 @@ public class AppearancePatentLlmBatchPipeline { return rowKeyer.apply(row); } + /** + * 本批里「已经有结论」的行键。候选侧({@code collectPendingLlmCandidates})与完成标记侧 + * 共用同一枚 {@link AppearancePatentRowOutcome#isJudged},这就是 B74-01 要的同源判据: + * 「谁说了算」只能有一个,否则一行会同时「被标记挡住不再是候选」且「没有结论列可出」。 + * + *

唯一的例外是 {@code terminalizeRoundExhaustedRows}:那里的行是按**轮次上限**终态化的 + * (结论列写着「重发轮次已达上限」),它的完成标记正是有界路径的收口闸门,按 isJudged 再筛 + * 会让这些行永远回到候选——那才是无界循环。 + */ + private Set judgedRowKeys(List rows) { + Set keys = new LinkedHashSet<>(); + if (rows == null) { + return keys; + } + for (AppearancePatentResultRowDto row : rows) { + if (row == null || !AppearancePatentRowOutcome.isJudged(row)) { + continue; + } + String key = rowKey(row); + if (key != null && !key.isBlank()) { + keys.add(key); + } + } + return keys; + } + private Map readChunkRows(TaskChunkEntity chunk) { return chunkRowReader.apply(chunk); } diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/service/support/AppearancePatentTaskOwnership.java b/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/service/support/AppearancePatentTaskOwnership.java index ed4a87a8b..38cea00e6 100644 --- a/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/service/support/AppearancePatentTaskOwnership.java +++ b/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/service/support/AppearancePatentTaskOwnership.java @@ -4,6 +4,7 @@ import com.fasterxml.jackson.databind.ObjectMapper; import com.nanri.aiimage.common.exception.TaskOwnerMismatchException; import com.nanri.aiimage.config.InstanceMetadata; import com.nanri.aiimage.modules.task.model.entity.FileTaskEntity; +import com.nanri.aiimage.modules.task.service.support.TaskOwnerJsonFallback; import lombok.extern.slf4j.Slf4j; import java.util.Objects; @@ -82,17 +83,9 @@ public class AppearancePatentTaskOwnership { if (task.getOwnerInstanceId() != null && !task.getOwnerInstanceId().isBlank()) { return task.getOwnerInstanceId(); } - if (task.getResultJson() == null || task.getResultJson().isBlank()) { - return null; - } - try { - String owner = objectMapper.readTree(task.getResultJson()).path("ownerInstanceId").asText(""); - return owner.isBlank() ? null : owner; - } catch (Exception ex) { - log.warn("[appearance-patent] read task owner failed taskId={} err={}", - task.getId(), ex.getMessage()); - return null; - } + // 回落口径四台共用一处(B74-04):本台此前只读 result_json,店铺采集读 request_json, + // 同一条列缺失的行在两台眼里会有两个归属。 + return TaskOwnerJsonFallback.ownerFrom(task, objectMapper, "appearance-patent"); } public String ownerFromScopeKey(String scopeKey) { diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/publish/service/PublishTaskService.java b/backend-java/src/main/java/com/nanri/aiimage/modules/publish/service/PublishTaskService.java index ebb77fb65..57b2b0a05 100644 --- a/backend-java/src/main/java/com/nanri/aiimage/modules/publish/service/PublishTaskService.java +++ b/backend-java/src/main/java/com/nanri/aiimage/modules/publish/service/PublishTaskService.java @@ -34,6 +34,7 @@ import com.nanri.aiimage.modules.publish.model.vo.PublishTaskBatchVo; import com.nanri.aiimage.modules.publish.model.vo.PublishTaskDetailVo; import com.nanri.aiimage.modules.publish.model.vo.PublishTaskVo; import com.nanri.aiimage.modules.task.mapper.FileResultMapper; +import com.nanri.aiimage.modules.task.service.support.TaskOwnerJsonFallback; import com.nanri.aiimage.modules.task.mapper.FileTaskMapper; import com.nanri.aiimage.modules.task.mapper.TaskChunkMapper; import com.nanri.aiimage.modules.task.mapper.TaskScopeStateMapper; @@ -1339,20 +1340,8 @@ public class PublishTaskService extends AbstractFileTaskPipeline if (column != null && !column.isBlank()) { return column.trim(); } - if (task.getResultJson() == null || task.getResultJson().isBlank()) { - return null; - } - try { - JsonNode root = objectMapper.readTree(task.getResultJson()); - if (root == null) { - return null; - } - String owner = root.path("ownerInstanceId").asText(""); - return owner.isBlank() ? null : owner; - } catch (Exception ex) { - log.warn("[publish] read task owner failed taskId={} msg={}", task.getId(), safeMessage(ex)); - return null; - } + // 回落口径四台共用一处(B74-04) + return TaskOwnerJsonFallback.ownerFrom(task, objectMapper, "publish"); } private String currentInstanceId() { diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/shopdatacrawl/service/ShopDataCrawlTaskService.java b/backend-java/src/main/java/com/nanri/aiimage/modules/shopdatacrawl/service/ShopDataCrawlTaskService.java index 401b50189..3fc79e7d1 100644 --- a/backend-java/src/main/java/com/nanri/aiimage/modules/shopdatacrawl/service/ShopDataCrawlTaskService.java +++ b/backend-java/src/main/java/com/nanri/aiimage/modules/shopdatacrawl/service/ShopDataCrawlTaskService.java @@ -30,6 +30,7 @@ import com.nanri.aiimage.modules.shopdatacrawl.model.vo.ShopDataCrawlResultItemV import com.nanri.aiimage.modules.shopdatacrawl.spi.DuplicateCheckRefreshPort; import com.nanri.aiimage.modules.productrisk.model.vo.ProductRiskDashboardVo; import com.nanri.aiimage.modules.task.mapper.FileResultMapper; +import com.nanri.aiimage.modules.task.service.support.TaskOwnerJsonFallback; import com.nanri.aiimage.modules.task.mapper.FileTaskMapper; import com.nanri.aiimage.modules.task.mapper.TaskChunkMapper; import com.nanri.aiimage.modules.task.mapper.TaskScopeStateMapper; @@ -3111,8 +3112,12 @@ public class ShopDataCrawlTaskService extends AbstractFileTaskPipeline本台此前只回落到 request_json,而另外三台回落到 result_json——列缺失的存量行 + * (实测 RUNNING 任务里 39 行)因此在不同校验里会算出不同归属,这正是 2026-11-02 + * 互斥死锁的家族形状。回落顺序现在只有一个出处。 */ public String ownerInstanceIdOf(FileTaskEntity task) { if (task != null && !blank(task.getOwnerInstanceId())) { @@ -3126,14 +3131,7 @@ public class ShopDataCrawlTaskService extends AbstractFileTaskPipeline inFlightJobIds = ConcurrentHashMap.newKeySet(); + public TaskFileJobEntity enqueueAssembleResult(Long taskId, String moduleType, Long resultId, String scopeKey) { if (taskId == null || taskId <= 0 || moduleType == null || moduleType.isBlank() || resultId == null || resultId <= 0) { return null; @@ -446,6 +454,7 @@ public class TaskFileJobService { .last("limit " + Math.max(1, Math.min(limit, 200)))); int reset = 0; int skippedForeignOwner = 0; + int skippedInFlight = 0; List exhaustedJobs = new ArrayList<>(); List eventJobIds = new ArrayList<>(); List exhaustedJobIds = new ArrayList<>(); @@ -507,6 +516,12 @@ public class TaskFileJobService { job.getId(), job.getTaskId(), rowOwner, currentInstanceId); continue; } + if (isInFlight(job.getId())) { + skippedInFlight++; + log.debug("[task-file-job] stuck reset 跳过本机正在执行的作业 jobId={} taskId={} stuckRequeueCount={}", + job.getId(), job.getTaskId(), job.getStuckRequeueCount()); + continue; + } LocalDateTime now = LocalDateTime.now(); int stuckCount = job.getStuckRequeueCount() == null ? 0 : job.getStuckRequeueCount(); if (stuckCount >= MAX_STUCK_REQUEUE) { @@ -588,9 +603,9 @@ public class TaskFileJobService { exhaustedJobs.add(refreshed == null ? originalJobsById.get(jobId) : refreshed); } } - if (skippedForeignOwner > 0) { - log.info("[task-file-job] stuck reset 按归属跳过其它实例的 RUNNING 作业 skipped={} current={} scanned={}", - skippedForeignOwner, currentInstanceId, jobs.size()); + if (skippedForeignOwner > 0 || skippedInFlight > 0) { + log.info("[task-file-job] stuck reset 活性豁免 skippedForeignOwner={} skippedInFlight={} current={} scanned={}", + skippedForeignOwner, skippedInFlight, currentInstanceId, jobs.size()); } return new StuckJobResetResult(reset, List.copyOf(exhaustedJobs)); } @@ -760,6 +775,45 @@ public class TaskFileJobService { .set(TaskFileJobEntity::getUpdatedAt, now)); } + /** + * 执行线程进入 {@code process} 时登记(B74-02)。登记点必须在 {@code activateRunningClaim} + * 成功之后——claim 过期没 executing 的行本来就该被扫描回收。 + */ + public void markInFlight(Long jobId) { + if (jobId != null && jobId > 0) { + inFlightJobIds.add(jobId); + } + } + + /** 执行线程退出(含异常与终态收口)后注销;漏注销会让这一行永远不被回收,所以调用方必须放 finally。 */ + public void clearInFlight(Long jobId) { + if (jobId != null) { + inFlightJobIds.remove(jobId); + } + } + + /** + * 「本机有线程正在跑这一行」——卡死扫描据此不重排、不累加 {@code stuck_requeue_count}。 + * + *

为什么必须由扫描问执行侧,而不是把 stuck 阈值抬大(B74-02 的二选一,2026-11-03 按读数定的): + * 心跳在父任务终态时按 CR-08 刻意停止续期({@code TaskResultFileJobWorker#startJobHeartbeat} + * 的 {@code stage=TERMINAL_STOP_RENEW}),此时执行线程还在跑但 {@code updated_at} 从此冻结—— + * 冻结是无限期的,不是「比 5 分钟长一点」。所以阈值抬到 16 分钟也只是把 20 次计满的时间 + * 从 100 分钟拖到 320 分钟,形状不变。2026-11-03 现网实证:jobId=23815/taskId=33179 + * 06:07:20 到 {@code stuckRequeueCount=20},06:08 复位恢复、09:20 又同样两条——同一个 + * 「既不失败也不完成」的环。抬阈值还会把真遗骸的回收从 5 分钟拖到十几分钟,两头都输。 + * + *

与刚收口的跨实例归属守卫是同一判据的两半:那一半管「别的机器在跑」,这一半管「本机在跑」。 + */ + public boolean isInFlight(Long jobId) { + return jobId != null && inFlightJobIds.contains(jobId); + } + + /** 供用例断言登记面;生产路径不应依赖它做决策。 */ + public int inFlightCount() { + return inFlightJobIds.size(); + } + public boolean deferRunning(Long jobId, String message) { if (jobId == null || jobId <= 0) { return false; diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/task/service/TaskHeartbeatPositionService.java b/backend-java/src/main/java/com/nanri/aiimage/modules/task/service/TaskHeartbeatPositionService.java index 0fc316569..115fd8a8d 100644 --- a/backend-java/src/main/java/com/nanri/aiimage/modules/task/service/TaskHeartbeatPositionService.java +++ b/backend-java/src/main/java/com/nanri/aiimage/modules/task/service/TaskHeartbeatPositionService.java @@ -362,10 +362,30 @@ public class TaskHeartbeatPositionService { long now = Instant.now().toEpochMilli(); String storedFingerprint = stored == null ? "" : value(stored, "pos"); long unchangedSince = stored == null ? 0L : parseMillis(stored.get("at")); - if (!fingerprint.equals(storedFingerprint) || unchangedSince <= 0L) { + boolean snapshotMissing = stored == null || stored.isEmpty(); + if (!snapshotMissing && !fingerprint.equals(storedFingerprint)) { + // 指纹真的变了=客户端主线程还在干活,起点重锚在「现在」。 writeStallSnapshot(stallKey, fingerprint, now, staleWindowMinutes); return StallState.ADVANCING; } + if (snapshotMissing || unchangedSince <= 0L) { + // B74-03:这两种形状原先与「指纹变了」共用同一个 ADVANCING 出口,等于把 + // 「没有证据」当成「证据表明在推进」。现网实证(2026-11-02 任务 33179,20:20–21:02 + // 每 2 分钟一条「客户端仍在推进」而 lastResultAt 已 3h48m 不动):本键 TTL 是 + // max(60, window×3)=9 小时,键一过期就重锚到 now,于是每 9 小时白送一轮完整豁免窗口, + // 沉默的客户端永远封不了口。 + // 分流做法:锚点重建成**客户端最后一次上报**的时刻(位置哈希自己的 at,由 record() + // 每次心跳刷新),拿不到才退回 now;随后照走同一条时间判据,豁免长度由真实沉默时长决定, + // 而不是由「键什么时候消失」决定。客户端确在心跳时 anchor 就是新鲜的 ⇒ 仍判 ADVANCING, + // 这一侧不会把还在采集的任务判死(28919 的教训记在 isClientAdvancing 的注释上)。 + long reportedAt = positionReportedAtMillis(taskId); + long anchor = reportedAt > 0L ? reportedAt : now; + log.info("[heartbeat-position] 停滞锚点重建 taskId={} reason={} anchor={} anchorAgeMs={}", + taskId, snapshotMissing ? "snapshot-missing" : "stamp-unreadable", + anchor, now - anchor); + writeStallSnapshot(stallKey, fingerprint, anchor, staleWindowMinutes); + unchangedSince = anchor; + } long unchangedMillis = now - unchangedSince; if (unchangedMillis >= Duration.ofMinutes(staleWindowMinutes).toMillis()) { return StallState.STALLED; @@ -375,6 +395,22 @@ public class TaskHeartbeatPositionService { return StallState.ADVANCING; } + /** + * 客户端最后一次上报位置的时刻(毫秒),读不到返回 0。 + * + *

与 {@link #readProgressFingerprint} 读的是同一枚哈希,只是多取一个 {@code at} 字段—— + * 那里只取计数与文本,所以这一枚时间戳此前没有任何人读过,B74-03 的锚点也就一直错到 now 上。 + */ + private long positionReportedAtMillis(Long taskId) { + try { + Map entries = stringRedisTemplate.opsForHash().entries(KEY_PREFIX + taskId); + return entries == null ? 0L : parseMillis(entries.get("at")); + } catch (Exception ex) { + log.warn("[heartbeat-position] 读取位置上报时刻失败 taskId={} msg={}", taskId, ex.getMessage()); + return 0L; + } + } + /** * 便捷判定:客户端是否仍在推进(位置文本仍在变)。 * diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/task/service/TaskResultFileJobWorker.java b/backend-java/src/main/java/com/nanri/aiimage/modules/task/service/TaskResultFileJobWorker.java index 5b2b18d05..78ac742fa 100644 --- a/backend-java/src/main/java/com/nanri/aiimage/modules/task/service/TaskResultFileJobWorker.java +++ b/backend-java/src/main/java/com/nanri/aiimage/modules/task/service/TaskResultFileJobWorker.java @@ -269,15 +269,24 @@ public class TaskResultFileJobWorker { return; } AtomicBoolean parentTerminalObserved = new AtomicBoolean(false); + // B74-02:向作业服务登记「本机线程正在跑这一行」。父任务终态时心跳会刻意停续期 + // (stage=TERMINAL_STOP_RENEW),updated_at 从此无限期冻结,卡死扫描若只看时间戳就会 + // 每 5 分钟给还在跑的执行线程记一次 stuck_requeue_count,20 次把还能出表的单判死 + // (2026-11-03 现网 jobId=23815/taskId=33179 正是这个环)。注销必须在 finally。 + taskFileJobService.markInFlight(job.getId()); ScheduledFuture heartbeat = startJobHeartbeat(job, parentTerminalObserved); try { processInternal(job); } finally { heartbeat.cancel(false); - // CR-08:心跳只负责停续期;终态判定必须等执行线程退出后再做。 - // 此时若 markSuccess 已落库,finishAfterExecution 会保留 SUCCESS; - // 只有执行线程没写出成功状态的行才判死并留给兜底扫描出部分结果。 - finishAfterExecution(job, parentTerminalObserved); + try { + // CR-08:心跳只负责停续期;终态判定必须等执行线程退出后再做。 + // 此时若 markSuccess 已落库,finishAfterExecution 会保留 SUCCESS; + // 只有执行线程没写出成功状态的行才判死并留给兜底扫描出部分结果。 + finishAfterExecution(job, parentTerminalObserved); + } finally { + taskFileJobService.clearInFlight(job.getId()); + } } } diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/task/service/support/TaskOwnerJsonFallback.java b/backend-java/src/main/java/com/nanri/aiimage/modules/task/service/support/TaskOwnerJsonFallback.java new file mode 100644 index 000000000..b861ce805 --- /dev/null +++ b/backend-java/src/main/java/com/nanri/aiimage/modules/task/service/support/TaskOwnerJsonFallback.java @@ -0,0 +1,67 @@ +package com.nanri.aiimage.modules.task.service.support; + +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.nanri.aiimage.modules.task.model.entity.FileTaskEntity; +import lombok.extern.slf4j.Slf4j; + +/** + * 任务归属实例的 JSON 回落——四台(外观专利/相似ASIN/发布/店铺采集)共用的唯一出处(B74-04)。 + * + *

列优先是铁律 28 定的:任务转交后只有 {@code owner_instance_id} 会被更新,JSON 快照停在 + * parse 那一刻。但「列缺失时读哪一枚 JSON」此前四处各写各的——三台读 {@code result_json}, + * 店铺采集读 {@code request_json}。同一条存量行(实测 RUNNING 任务里 {@code owner_instance_id} + * 为空的有 39 行)在四台眼里因此可以算出两个归属,正是 2026-11-02 互斥死锁的家族形状。 + * + *

顺序固定为 {@code result_json → request_json}:前者是 parse/交付快照(正档),后者是提交时 + * 最旧的一手,只有正档确实没有时才作参考,并且必须留下 WARN——它一旦生效就说明列与正档都没写上。 + */ +@Slf4j +public final class TaskOwnerJsonFallback { + + /** owner 字段名:四台读取与写入侧(payload/result_json)共用同一个拼写。 */ + public static final String OWNER_FIELD = "ownerInstanceId"; + + private TaskOwnerJsonFallback() { + } + + /** + * @param logTag 所属模块的日志前缀,便于现网分辨是哪一台走到了回落 + * @return 归属实例 id;两枚快照都读不出时返回 null(调用方按「无归属」放行) + */ + public static String ownerFrom(FileTaskEntity task, ObjectMapper objectMapper, String logTag) { + if (task == null || objectMapper == null) { + return null; + } + String fromResult = read(task.getResultJson(), objectMapper); + if (fromResult != null) { + return fromResult; + } + String fromRequest = read(task.getRequestJson(), objectMapper); + if (fromRequest != null) { + log.warn("[{}] 任务归属落到 request_json 提交快照 taskId={} owner={} —— " + + "只有 owner_instance_id 列与 result_json 都读不出时才走到这里", + logTag, task.getId(), fromRequest); + } + return fromRequest; + } + + private static String read(String json, ObjectMapper objectMapper) { + if (json == null || json.isBlank()) { + return null; + } + try { + JsonNode root = objectMapper.readTree(json); + if (root == null) { + return null; + } + String owner = root.path(OWNER_FIELD).asText(""); + return owner.isBlank() ? null : owner.trim(); + } catch (Exception ex) { + // 读不出归属=不认领,绝不抛:抛出去会把一次正常的状态检查变成 500。 + // 但必须报出来——静默返回 null 会被调用方读成"这行没有归属"从而放行。 + log.warn("[owner-fallback] 解析任务归属快照失败 msg={}", ex.getMessage()); + return null; + } + } +} diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/usersecret/service/UserApiSecretService.java b/backend-java/src/main/java/com/nanri/aiimage/modules/usersecret/service/UserApiSecretService.java index 0a2861395..7e8958881 100644 --- a/backend-java/src/main/java/com/nanri/aiimage/modules/usersecret/service/UserApiSecretService.java +++ b/backend-java/src/main/java/com/nanri/aiimage/modules/usersecret/service/UserApiSecretService.java @@ -696,10 +696,12 @@ public class UserApiSecretService implements UserSecretCleanupPort { continue; } try { - String groupKey = inspectionGroupKey(row); + // 解密提到分组之前:分组键要看链接内容才能认出「这行和那行是同一个账号」 + // (B73-03)。这是本机 AES,不走网络,代价与一次真实提取不可同日而语。 + String plainKey = normalize(cryptoService.decrypt(row.getSecretValue())); + String groupKey = inspectionGroupKey(row, plainKey); UserApiSecretCheckService.CheckOutcome outcome = outcomeBySecret.get(groupKey); if (outcome == null) { - String plainKey = normalize(cryptoService.decrypt(row.getSecretValue())); outcome = plainKey.isEmpty() ? new UserApiSecretCheckService.CheckOutcome( UserApiSecretCheckService.STATUS_FAILED, @@ -755,12 +757,62 @@ public class UserApiSecretService implements UserSecretCleanupPort { return summary; } - /** 巡检分组键:同模块 + 同密文视为同一把密钥。密文确定性加密,无需解密即可分组。 */ - private String inspectionGroupKey(UserApiSecretEntity row) { + /** + * 巡检分组键。 + * + *

代理类凭据按供应商账号分组(B73-03):旧写法 {@code moduleKey|channel|密文} + * 把同一把青果 key 在多模块/多行配置时算成不同的组,每组都要真打一次提取;而青果整个账号 + * 只有 1 条通道(2026-11-02 用户在控制台核实),第一枪还占着,后面每一枪必然 + * {@code channel_busy} —— 巡检自己把用户的代理打成了「代理异常」。现在折成 + * (供应商, 提取域, 归一化 query):参数顺序不同、多余参数不同都算同一把 key,同账号只出一枪。 + * + *

非链接型凭据照旧 {@code moduleKey|channel|密文}:同一串 LLM 密钥在龙抬头与贞贞上 + * 是两次独立探测,合并会拿 A 的结论冒充 B —— 那一侧不能跟着一起折。 + * + *

分组键会进管理员告警的聚合面,所以账号身份只落摘要,链接里的账密明文绝不落进去。 + */ + private String inspectionGroupKey(UserApiSecretEntity row, String plainValue) { + String accountIdentity = proxyAccountIdentity(plainValue); + if (accountIdentity != null) { + return "proxy-account|" + accountIdentity; + } // 渠道参与分组:同一串密钥在龙抬头与贞贞上是两次独立探测,合并会拿 A 的结论冒充 B return row.getModuleKey() + '|' + (row.getChannel() == null ? "" : row.getChannel()) + '|' + row.getSecretValue(); } + /** + * 提取链接的账号身份=(供应商, 提取域, 排序后的 query) 的摘要;不是链接型凭据时返回 null。 + * + *

返回 null 是让调用方退回逐行分组,而不是硬造一个组——把 LLM 密钥误当链接合并才是真事故。 + */ + private String proxyAccountIdentity(String plainValue) { + if (plainValue == null || plainValue.isBlank()) { + return null; + } + URI uri; + try { + uri = new URI(plainValue.trim()); + } catch (Exception ex) { + log.warn("[user-secret] 巡检分组键解析不出链接,退回逐行分组 msg={}", ex.getMessage()); + return null; + } + String host = uri.getHost(); + if (host == null || !host.contains(".")) { + return null; + } + ProxyProvider provider = ProxyProvider.detectFromUrl(plainValue); + String query = uri.getQuery() == null ? "" : sortedQuery(uri.getQuery()); + return sha256Hex((provider == null ? "unknown" : provider.name()) + + '|' + host.toLowerCase(java.util.Locale.ROOT) + '|' + query); + } + + /** query 参数按原文排序,好让「同一把 key 写成不同参数顺序」落到同一个组。 */ + private static String sortedQuery(String rawQuery) { + String[] parts = rawQuery.split("&"); + java.util.Arrays.sort(parts); + return String.join("&", parts); + } + /** * 巡检告警判定:欠费(insufficient_balance)→ error 级 secret_balance; * 密钥无效/被拒(invalid_key/forbidden)→ warning 级 secret_invalid; diff --git a/backend-java/src/test/java/com/nanri/aiimage/modules/appearancepatent/service/AppearancePatentRowMarkTimingTest.java b/backend-java/src/test/java/com/nanri/aiimage/modules/appearancepatent/service/AppearancePatentRowMarkTimingTest.java index 7c7e2438c..72e71c9a0 100644 --- a/backend-java/src/test/java/com/nanri/aiimage/modules/appearancepatent/service/AppearancePatentRowMarkTimingTest.java +++ b/backend-java/src/test/java/com/nanri/aiimage/modules/appearancepatent/service/AppearancePatentRowMarkTimingTest.java @@ -235,6 +235,32 @@ class AppearancePatentRowMarkTimingTest { verify(taskCacheService).releaseRowInspection(TASK_ID, List.of("r2")); } + /** + * B74-01:landed(被塞回分片载荷)与 isJudged(有结论列)必须同源,谁说了算只能有一个。 + * + *

发 2 行回 2 行、两行都落进分片,但 r2 只带 patentRisk——三列结论全空。旧写法按 landed + * 给它打 24 小时完成标记,于是它既不再是候选(被自己的标记挡着)又没有可出的结论, + * 只能等补检把标记连根撤掉才回来(现网 33179 的形状)。现在把完成标记打给 isJudged + * 不认的行即红。 + */ + @Test + void landedButUnjudgedRowDoesNotGetACompletionMark() throws Exception { + String halfJudged = "[{\"rowToken\":\"r1\",\"asin\":\"B0A0000001\",\"title\":\"RUNNING SHOE\"," + + "\"url\":\"http://img/1.jpg\",\"groupKey\":\"g1\"," + + "\"titleRisk\":\"无侵权\",\"appearanceRisk\":\"无侵权\",\"conclusion\":\"无侵权\"}," + + "{\"rowToken\":\"r2\",\"asin\":\"B0A0000002\",\"title\":\"COTTON BAG\"," + + "\"url\":\"http://img/2.jpg\",\"groupKey\":\"g2\",\"patentRisk\":\"无侵权\"}]"; + when(taskCacheService.beginRowInspection(eq(TASK_ID), anyString())).thenReturn(true); + when(llmClient.inspectRows(any(), any(), any())).thenReturn(rows(halfJudged)); + stubMergeWrite(2); + + submit(); + + verify(taskCacheService).completeRowInspection(TASK_ID, List.of("r1")); + verify(taskCacheService, never()).completeRowInspection(TASK_ID, List.of("r2")); + verify(taskCacheService).releaseRowInspection(TASK_ID, List.of("r2")); + } + /** 回来的行一个都落不进分片(rowToken 被网关改写):整批都不能算完成。 */ @Test void rowsThatMatchNoChunkRowStayRetryable() throws Exception { diff --git a/backend-java/src/test/java/com/nanri/aiimage/modules/appearancepatent/service/AppearancePatentTaskCacheServiceRowMarkTest.java b/backend-java/src/test/java/com/nanri/aiimage/modules/appearancepatent/service/AppearancePatentTaskCacheServiceRowMarkTest.java index d3cee947a..d04e063a3 100644 --- a/backend-java/src/test/java/com/nanri/aiimage/modules/appearancepatent/service/AppearancePatentTaskCacheServiceRowMarkTest.java +++ b/backend-java/src/test/java/com/nanri/aiimage/modules/appearancepatent/service/AppearancePatentTaskCacheServiceRowMarkTest.java @@ -20,6 +20,7 @@ import static org.junit.jupiter.api.Assertions.assertTrue; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anyString; import static org.mockito.Mockito.lenient; +import static org.mockito.Mockito.mock; import static org.mockito.Mockito.never; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; @@ -221,4 +222,50 @@ class AppearancePatentTaskCacheServiceRowMarkTest { assertEquals(0L, cache.rowInspectionRounds(TASK_ID, ROW_KEY)); } + + /** + * B74-01:Redis 回 null(管道/事务态、集群未回包)必须按**没抢到**处理。 + * + *

旧写法 {@code return first == null || first;} 把「读不出」读成「抢到了」,同一行可能被 + * 两个入口同时发出去(双扣用户 LLM 次数、两路各自 CAS 同一行)。这与"Redis 抛异常"是两条路: + * 真降级在 catch 里放行,由持久化层 isJudged 兜底(见 beginAllowsRowThroughWhenRedisFails)。 + */ + @Test + void beginTreatsNullReplyAsNotClaimed() { + when(valueOperations.setIfAbsent(anyString(), anyString(), any(Duration.class))).thenReturn(null); + + assertFalse(cache.beginRowInspection(TASK_ID, ROW_KEY), + "null 不是 true:读不出就不能声称拿到了这一行"); + } + + /** + * B74-01:清任务缓存必须删掉**真实存在**的逐行完成标记。 + * + *

旧实现删的是 {@code processedRowsKey(taskId)} 这枚从不被写入的基键=删空气, + * 任务清完后 24 小时内重建,行仍被标记挡着不再检测——声称保护但不保护。 + */ + @Test + @SuppressWarnings("unchecked") + void deleteTaskCacheRemovesTheRealPerRowMarks() { + org.springframework.data.redis.core.Cursor cursor = + mock(org.springframework.data.redis.core.Cursor.class); + when(cursor.hasNext()).thenReturn(true, true, false); + when(cursor.next()).thenReturn( + "appearance-patent:task:processed-rows:" + TASK_ID + ":r1", + "appearance-patent:task:processed-rows:" + TASK_ID + ":r2"); + when(redisTemplate.scan(any())).thenReturn(cursor); + + cache.deleteTaskCache(TASK_ID); + + ArgumentCaptor> deleted = + ArgumentCaptor.forClass(java.util.Collection.class); + verify(redisTemplate).delete(deleted.capture()); + assertTrue(deleted.getValue().contains( + "appearance-patent:task:processed-rows:" + TASK_ID + ":r1"), + "逐行标记必须被真的删掉,否则「清完缓存」只是一句注释"); + assertTrue(deleted.getValue().contains( + "appearance-patent:task:processed-rows:" + TASK_ID + ":r2")); + assertTrue(deleted.getValue().contains("appearance-patent:task:processed-rows:" + TASK_ID), + "基键一并清掉(今天它仍不存在,但它是这一族的目录名,不该留在册上)"); + } } diff --git a/backend-java/src/test/java/com/nanri/aiimage/modules/task/service/TaskFileJobOwnerHandOffTest.java b/backend-java/src/test/java/com/nanri/aiimage/modules/task/service/TaskFileJobOwnerHandOffTest.java index 5407942ed..633ffdf89 100644 --- a/backend-java/src/test/java/com/nanri/aiimage/modules/task/service/TaskFileJobOwnerHandOffTest.java +++ b/backend-java/src/test/java/com/nanri/aiimage/modules/task/service/TaskFileJobOwnerHandOffTest.java @@ -284,4 +284,46 @@ class TaskFileJobOwnerHandOffTest { assertEquals(1, result.resetCount(), "后管那枚人工复位按钮点的就是「把它排回去」,不得被归属守卫悄悄拒掉"); } + + // ==================== B74-02 本机执行活性豁免(与上面「他机在跑」是同一判据的两半) ==================== + + @Test + void test_本机正在执行的作业不得被卡死扫描重排或判死() { + // 现网形状:2026-11-03 jobId=23815/taskId=33179 在 06:07:20 到 stuckRequeueCount=20, + // 而执行线程一直在跑——父任务终态后心跳按 CR-08 刻意停续期,updated_at 从此无限期冻结, + // 扫描只看时间戳就每 5 分钟扣一次计数。抬阈值救不了它(冻结不是「比 5 分钟长一点」)。 + TaskFileJobEntity ownRunning = job(23815L, 33179L, "RUNNING", TASK_OWNER); + ownRunning.setStuckRequeueCount(20); + when(taskFileJobMapper.selectList(any())).thenReturn(List.of(ownRunning)); + + service.markInFlight(23815L); + TaskFileJobService.StuckJobResetResult result = + service.resetStuckRunningJobsDetailed(5, 10, TASK_OWNER); + + assertEquals(0, result.resetCount()); + assertTrue(result.exhaustedJobs().isEmpty(), + "线程还在跑就不许把它判死:判死后 markSuccess 的 .eq(status,RUNNING) 会丢掉成功状态"); + verify(taskFileJobMapper, never()).update(isNull(), any(LambdaUpdateWrapper.class)); + verify(applicationEventPublisher, never()).publishEvent(any()); + } + + @Test + void test_注销之后同一行必须回到可回收形状() { + // 登记面必须是"线程在跑期间"这一有界区间:漏注销=这行永远不被回收,遗骸比误判更贵。 + TaskFileJobEntity ownRunning = job(23815L, 33179L, "RUNNING", TASK_OWNER); + ownRunning.setStuckRequeueCount(3); + when(taskFileJobMapper.selectList(any())).thenReturn(List.of(ownRunning)); + when(taskFileJobMapper.update(isNull(), any(LambdaUpdateWrapper.class))).thenReturn(1); + when(taskFileJobMapper.selectBatchIds(any())).thenReturn(List.of(ownRunning)); + + service.markInFlight(23815L); + service.clearInFlight(23815L); + assertFalse(service.isInFlight(23815L)); + + TaskFileJobService.StuckJobResetResult result = + service.resetStuckRunningJobsDetailed(5, 10, TASK_OWNER); + + assertEquals(1, result.resetCount(), "注销后必须照旧被回收,活性豁免不是豁免的通行证"); + assertEquals(0, service.inFlightCount()); + } } diff --git a/backend-java/src/test/java/com/nanri/aiimage/modules/task/service/TaskHeartbeatPositionStallExitsSnapshotTest.java b/backend-java/src/test/java/com/nanri/aiimage/modules/task/service/TaskHeartbeatPositionStallExitsSnapshotTest.java index e3cbe6165..c11f80f15 100644 --- a/backend-java/src/test/java/com/nanri/aiimage/modules/task/service/TaskHeartbeatPositionStallExitsSnapshotTest.java +++ b/backend-java/src/test/java/com/nanri/aiimage/modules/task/service/TaskHeartbeatPositionStallExitsSnapshotTest.java @@ -177,4 +177,56 @@ class TaskHeartbeatPositionStallExitsSnapshotTest { verify(hash, never()).putAll(eq(STALL_KEY), any()); verify(redis, org.mockito.Mockito.never()).expire(eq(STALL_KEY), any(Duration.class)); } + + // ==================== B74-03 分流(2026-11-03 按现网取证改判;更新即登记,不静默) ==================== + + private void givenPositionTextAt(String text, long reportedAtMillis) { + Map position = new HashMap<>(); + position.put("progressText", text); + position.put("at", String.valueOf(reportedAtMillis)); + when(hash.entries(POSITION_KEY)).thenReturn(position); + } + + @Test + void 停滞快照缺失但客户端已沉默超窗_不得再白送一轮豁免() { + // 现网形状(2026-11-02 任务 33179):本键 TTL = max(60, window×3) = 9 小时,键一消失 + // 旧代码就把起点重锚到 now 并直接放行,于是每 9 小时白送一轮完整豁免窗口,沉默的客户端永远封不了口。 + long anchor = Instant.now().toEpochMilli() - Duration.ofMinutes(40).toMillis(); + givenPositionTextAt("正在抓取第 3 页", anchor); + when(hash.entries(STALL_KEY)).thenReturn(new HashMap<>()); + + assertThat(service.evaluateStall(7L, 30L)) + .as("键消失只是没人记账,不等于「证据表明在推进」;最后一次上报已在 30 分钟窗口外 ⇒ STALLED") + .isEqualTo(TaskHeartbeatPositionService.StallState.STALLED); + + org.mockito.ArgumentCaptor> written = + org.mockito.ArgumentCaptor.forClass((Class) Map.class); + verify(hash).putAll(eq(STALL_KEY), written.capture()); + assertThat(written.getValue().get("at")) + .as("重建的锚点必须锚到客户端最后一次上报时刻;锚到 now 就是每轮重发免死牌") + .isEqualTo(String.valueOf(anchor)); + } + + @Test + void 快照在而时间戳读不出_走同一条时间判据_不再借用真进展出口() { + long anchor = Instant.now().toEpochMilli() - Duration.ofMinutes(45).toMillis(); + givenPositionTextAt("正在抓取第 3 页", anchor); + when(hash.entries(STALL_KEY)).thenReturn(stallSnapshot("正在抓取第 3 页", 0L)); + + assertThat(service.evaluateStall(7L, 30L)) + .as("`at` 读不出(管道/事务态)与「指纹变了」共用出口就是 B74-03 的病灶本体;" + + "分流后两种形状都必须落到真实沉默时长上") + .isEqualTo(TaskHeartbeatPositionService.StallState.STALLED); + } + + @Test + void 客户端仍在心跳时锚点重建照旧放行_分流不得把判死线提前() { + givenPositionText("正在抓取第 3 页"); + when(hash.entries(STALL_KEY)).thenReturn(new HashMap<>()); + + assertThat(service.evaluateStall(7L, 30L)) + .as("分流只吃掉「白送的豁免」:客户端刚刚上报过 ⇒ 锚点就是新鲜的,仍判 ADVANCING。" + + "把仍在采集的任务判死会丢整批分片(28919 教训写在 isClientAdvancing 注释上)") + .isEqualTo(TaskHeartbeatPositionService.StallState.ADVANCING); + } } diff --git a/backend-java/src/test/java/com/nanri/aiimage/modules/task/service/TaskOwnerReadSourceGuardrailTest.java b/backend-java/src/test/java/com/nanri/aiimage/modules/task/service/TaskOwnerReadSourceGuardrailTest.java index c0b7d9841..3362943f0 100644 --- a/backend-java/src/test/java/com/nanri/aiimage/modules/task/service/TaskOwnerReadSourceGuardrailTest.java +++ b/backend-java/src/test/java/com/nanri/aiimage/modules/task/service/TaskOwnerReadSourceGuardrailTest.java @@ -70,6 +70,47 @@ class TaskOwnerReadSourceGuardrailTest { // 真正不允许的是反过来——只读快照,那正是相似ASIN 与发布当时的形状。 } + /** + * B74-04 的另一半尺子:上面那支只钉住「列优先」,没钉「列缺失时读哪枚 JSON」。 + * + *

四台此前各有写法——三台回落 result_json、店铺采集回落 request_json,列缺失的存量行 + * (实测 RUNNING 里 39 行)在不同校验里算出不同归属。回落顺序现在只有 + * {@code TaskOwnerJsonFallback} 一个出处:任何一台改回本地读法,本格即红。 + */ + @ParameterizedTest(name = "{0} 的任务归属回落必须走唯一出处") + @CsvSource({ + "AppearancePatentTaskOwnership.java", + "SimilarAsinTaskOwnershipSupport.java", + "PublishTaskService.java", + "ShopDataCrawlTaskService.java", + }) + void fallbackMustDelegateToOneSharedSource(String fileName) { + String source = SourceScan.withoutComments(SourceScan.sourceText(fileName)); + + assertThat(source) + .as(fileName + " 不得再有本地的任务归属 JSON 回落写法(result_json 侧)") + .doesNotContain("readTree(task.getResultJson()).path(\"ownerInstanceId\")"); + assertThat(source) + .as(fileName + " 不得再有本地的任务归属 JSON 回落写法(request_json 侧)") + .doesNotContain("readTree(task.getRequestJson()).path(\"ownerInstanceId\")"); + assertThat(source) + .as(fileName + " 必须经 TaskOwnerJsonFallback 读回落,四台共用同一个顺序") + .contains("TaskOwnerJsonFallback.ownerFrom("); + } + + @Test + void 回落顺序在唯一出处里钉死_result_json_先于_request_json() { + String source = SourceScan.withoutComments(SourceScan.sourceText("TaskOwnerJsonFallback.java")); + int resultRead = source.indexOf("task.getResultJson()"); + int requestRead = source.indexOf("task.getRequestJson()"); + + assertThat(resultRead).as("正档必须真的读 result_json").isGreaterThan(-1); + assertThat(requestRead).as("提交快照仍作次档(列与正档都没写上时还得兜住)").isGreaterThan(-1); + assertThat(resultRead) + .as("result_json 必须先于 request_json:它是 parse/交付快照,request_json 是提交时最旧的一手") + .isLessThan(requestRead); + } + @Test void 转交作业的目标实例必须来自异常携带的任务当前_owner() { String source = SourceScan.withoutComments(SourceScan.sourceText("TaskResultFileJobWorker.java")); diff --git a/backend-java/src/test/java/com/nanri/aiimage/modules/task/service/TaskResultFileJobWorkerStuckScanTest.java b/backend-java/src/test/java/com/nanri/aiimage/modules/task/service/TaskResultFileJobWorkerStuckScanTest.java index 793e7e466..c755c0dde 100644 --- a/backend-java/src/test/java/com/nanri/aiimage/modules/task/service/TaskResultFileJobWorkerStuckScanTest.java +++ b/backend-java/src/test/java/com/nanri/aiimage/modules/task/service/TaskResultFileJobWorkerStuckScanTest.java @@ -30,6 +30,7 @@ import com.nanri.aiimage.modules.task.mapper.FileResultMapper; import com.nanri.aiimage.modules.task.model.entity.TaskFileJobEntity; import com.nanri.aiimage.modules.withdraw.service.WithdrawTaskService; import org.junit.jupiter.api.Test; +import org.mockito.InOrder; import org.springframework.boot.context.event.ApplicationReadyEvent; import org.springframework.context.event.EventListener; @@ -52,6 +53,7 @@ import static org.mockito.ArgumentMatchers.contains; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.after; import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.inOrder; import static org.mockito.Mockito.never; import static org.mockito.Mockito.timeout; import static org.mockito.Mockito.times; @@ -536,6 +538,60 @@ class TaskResultFileJobWorkerStuckScanTest { verify(taskFileJobService, never()).markFailureFinalized(any(), anyString()); } + /** + * B74-02 活性登记的半边判据:登记必须在 {@code activateRunningClaim} 成功之后、执行之前, + * 注销必须在 finally——顺序反了要么把没跑起来的行登记成在飞(永不可回收),要么让还在跑的行 + * 被扫描扣计数(现网 jobId=23815/taskId=33179 的形状)。 + */ + @Test + void test_执行线程在跑期间登记在飞且退出必注销() throws Exception { + TaskResultFileJobWorker worker = buildWorker(); + TaskFileJobEntity job = runningJob(91L, 19L, "SIMILAR_ASIN"); + TaskFileJobEntity claim = runningJob(91L, 19L, "SIMILAR_ASIN"); + claim.setUpdatedAt(LocalDateTime.now()); + when(taskFileJobService.activateRunningClaim(claim)).thenReturn(true); + + invokeProcessClaimedWithHeartbeat(worker, job, claim); + + InOrder inOrder = inOrder(taskFileJobService); + inOrder.verify(taskFileJobService).activateRunningClaim(claim); + inOrder.verify(taskFileJobService).markInFlight(91L); + inOrder.verify(taskFileJobService).clearInFlight(91L); + } + + @Test + void test_claim已过期时不得登记在飞() throws Exception { + // 队里的 claim 在执行前就过期(行已被扫描翻走)——这一行不归本机跑,登记它等于永久豁免。 + TaskResultFileJobWorker worker = buildWorker(); + TaskFileJobEntity job = runningJob(92L, 20L, "SIMILAR_ASIN"); + TaskFileJobEntity claim = runningJob(92L, 20L, "SIMILAR_ASIN"); + claim.setUpdatedAt(LocalDateTime.now()); + when(taskFileJobService.activateRunningClaim(claim)).thenReturn(false); + + invokeProcessClaimedWithHeartbeat(worker, job, claim); + + verify(taskFileJobService, never()).markInFlight(92L); + verify(taskFileJobService, never()).clearInFlight(92L); + } + + private static TaskFileJobEntity runningJob(Long id, Long taskId, String moduleType) { + TaskFileJobEntity entity = new TaskFileJobEntity(); + entity.setId(id); + entity.setTaskId(taskId); + entity.setModuleType(moduleType); + entity.setStatus("RUNNING"); + return entity; + } + + private static void invokeProcessClaimedWithHeartbeat(TaskResultFileJobWorker worker, + TaskFileJobEntity job, + TaskFileJobEntity claim) throws Exception { + java.lang.reflect.Method method = TaskResultFileJobWorker.class.getDeclaredMethod( + "processClaimedWithHeartbeat", TaskFileJobEntity.class, TaskFileJobEntity.class); + method.setAccessible(true); + method.invoke(worker, job, claim); + } + private static void setLong(TaskResultFileJobWorker worker, String fieldName, long value) throws Exception { Field field = TaskResultFileJobWorker.class.getDeclaredField(fieldName); field.setAccessible(true); diff --git a/backend-java/src/test/java/com/nanri/aiimage/modules/usersecret/service/UserApiSecretServiceTest.java b/backend-java/src/test/java/com/nanri/aiimage/modules/usersecret/service/UserApiSecretServiceTest.java index c3858fe21..5d3653eb6 100644 --- a/backend-java/src/test/java/com/nanri/aiimage/modules/usersecret/service/UserApiSecretServiceTest.java +++ b/backend-java/src/test/java/com/nanri/aiimage/modules/usersecret/service/UserApiSecretServiceTest.java @@ -1102,6 +1102,56 @@ class UserApiSecretServiceTest { assertThat(inspectionWrites.values()).containsOnly("passed"); } + /** + * B73-03:代理凭据的分组身份=**供应商账号**,不是「哪个模块里的哪一行配置」。 + * + *

同一把青果 key 只是参数顺序写得不一样(或配在两行上),旧口径按 moduleKey|channel|密文 + * 算成两组 ⇒ 一轮真打两枪提取;而青果整个账号只有 1 条通道(2026-11-02 用户在控制台核实), + * 第一枪还占着 ⇒ 第二枪必然 channel_busy,巡检自己把用户的代理打成「代理异常」。 + * 现在折成 (供应商, 提取域, 归一化 query) ⇒ 同账号只出一枪。 + */ + @Test + void schedulerProbesSameProxyAccountOnceAcrossParamOrder() { + UserApiSecretService service = newService(); + String linkA = "enc:https://overseas.proxy.qg.net/get?key=QK&pwd=QP"; + String linkB = "enc:https://overseas.proxy.qg.net/get?pwd=QP&key=QK"; + stubInspectionStore(Map.of( + 11L, storedRow(11L, "proxy", linkA), + 12L, storedRow(12L, "proxy", linkB))); + when(checkService.probe(any(), anyString(), any())).thenReturn(outcome("passed", "ok", "代理可用", 120)); + when(mapper.selectList(any())).thenReturn(List.of( + inspectionRow(1L, 11L, "proxy", linkA), + inspectionRow(2L, 12L, "proxy", linkB)), List.of()); + + var summary = service.checkAllForScheduler(500, 20); + + verify(checkService, times(1)).probe(any(), anyString(), any()); + assertThat(summary.probed()).isEqualTo(1); + assertThat(summary.checked()).isEqualTo(2); + assertThat(inspectionWrites.keySet()).containsExactlyInAnyOrder(11L, 12L); + } + + /** + * 另一半边界:非链接型凭据(LLM 密钥)**不得**跟着一起折—— + * 同一串密钥在两个模块/两条渠道上是两次独立探测,合并会拿 A 的结论冒充 B。 + */ + @Test + void schedulerKeepsPerModuleGroupingForNonLinkSecrets() { + UserApiSecretService service = newService(); + String sharedApiKey = "enc:sk-shared-LLMKEY"; + stubInspectionStore(Map.of( + 11L, storedRow(11L, "similar-asin", sharedApiKey), + 12L, storedRow(12L, "appearance-patent", sharedApiKey))); + when(checkService.probe(any(), anyString(), any())).thenReturn(outcome("passed", "ok", "可用", 90)); + when(mapper.selectList(any())).thenReturn(List.of( + inspectionRow(1L, 11L, "similar-asin", sharedApiKey), + inspectionRow(2L, 12L, "appearance-patent", sharedApiKey)), List.of()); + + service.checkAllForScheduler(500, 20); + + verify(checkService, times(2)).probe(any(), anyString(), any()); + } + /** 失败结论同样整组复用:否则一把欠费的 key 会按账号数重复付费提取。 */ @Test void schedulerReusesFailedOutcomeAcrossSharedSecretGroup() { diff --git a/backend-java/src/test/java/com/nanri/aiimage/testutil/SourceScanTest.java b/backend-java/src/test/java/com/nanri/aiimage/testutil/SourceScanTest.java index b2d0fe9e6..ada7edea8 100644 --- a/backend-java/src/test/java/com/nanri/aiimage/testutil/SourceScanTest.java +++ b/backend-java/src/test/java/com/nanri/aiimage/testutil/SourceScanTest.java @@ -39,7 +39,7 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy; * 那条数是 {@code grep -rl 'sourceText('} 数出来的,而第 9 支是 {@code SourceScan.java:22} 里 * {@code public static String sourceText(String fileName)} 这行被调方自己的声明——它不是调用点。 * 所以真实形状是 调用点/调用方/引用方三类数各自成立(2026-10-28 v1.1 Phase 0 起调用方 16 支、 - * 裸名 23 个,增量逐笔登记在 {@code REGISTERED_BARE_NAMES} 的注释里)。下面第 3 格把这些数同时钉住, + * 裸名 24 个,增量逐笔登记在 {@code REGISTERED_BARE_NAMES} 的注释里)。下面第 3 格把这些数同时钉住, * 免得下一个人拿 {@code grep} 再数一遍又把声明算进去。

*/ class SourceScanTest { @@ -82,7 +82,14 @@ class SourceScanTest { // TaskOwnerReadSourceGuardrailTest 要钉「被拒时必须先改挂再退回」这一枚顺序, // 顺序错在 deferRunning 把行翻成 PENDING 之后 handOffToOwner 的 CAS 就打不中, // 用 mock 造不出这个先后(它要跑的正是 catch 块里两行的次序),只能打在源码连线上。 - "TaskResultFileJobWorker.java"); + "TaskResultFileJobWorker.java", + // —— 2026-11-03 Phase 2 ④(B74-04 归属回落收成唯一出处)追加(1 名)—— + // TaskOwnerReadSourceGuardrailTest 除了钉「列优先」,还必须钉住回落顺序本身: + // 四台此前各读各的 JSON(三台 result_json、店铺采集 request_json),列缺失的存量行 + // 因此能算出两个归属。回落口径合并成 TaskOwnerJsonFallback 一处之后,判据只能打在 + // "那一处确实按 result_json → request_json 的顺序读"这条源码连线上——mock 造不出 + // "谁先谁后",四份夹具各测一遍照样全绿。 + "TaskOwnerJsonFallback.java"); @TempDir Path tmp; @@ -98,7 +105,7 @@ class SourceScanTest { } @Test - void census_唯一裸名恰为23且与已登记集合相等() { + void census_唯一裸名恰为24且与已登记集合相等() { Set found = SourceScan.censusSourceTextCallSites().stream() .map(SourceScan.CallSite::bareName) .collect(Collectors.toSet()); @@ -106,7 +113,7 @@ class SourceScanTest { assertThat(found) .as("唯一裸名集合必须与类头台账逐字相等——多一个说明有人新引了单文件口径,少一个说明尺子漏扫") .isEqualTo(REGISTERED_BARE_NAMES) - .hasSize(23); + .hasSize(24); } @Test