Files
crawler-plugin/backend-java/src/test/java/com/nanri/aiimage/config/CatchSilenceRatchetTest.java
T

889 lines
73 KiB
Java
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
package com.nanri.aiimage.config;
import com.nanri.aiimage.config.SilentCatchScanner.Kind;
import com.nanri.aiimage.config.SilentCatchScanner.Result;
import com.nanri.aiimage.config.SilentCatchScanner.Site;
import org.junit.jupiter.api.Test;
import java.io.IOException;
import java.io.UncheckedIOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
/**
* catch 静默形状的**只许减**棘轮。
*
* <p>统计三件事(口径写死在这里,防止又变成"把文件数当处数"):
* <ul>
* <li>统计命令:{@code SilentCatchScanner.scanTree(src/main/java)}(本类的 {@link #TREE});</li>
* <li>分母是哪棵树:{@code crawler-plugin/backend-java/src/main/java} 工作树,只算 {@code *.java};</li>
* <li>单位:处(一个 catch 块 = 一处)。</li>
* </ul>
*
* <p>基线来源:2026-10-08 12:0x 实测(HEAD {@code 274ad017})total=1000 / 不重抛=559 /
* 只 log=249 / 空体=56。本轮改动往 main 里加了 **1 处** catch(拒起闸门读基线时的
* {@code catch (IOException e} ⇒ 重抛成 IllegalStateException),它是 RETHROW 形状、
* 不进气味三格,所以 total 基线随之从 1000 抬到 1001;那三格的基线一个字没动。
*
* <p>"只 log" 这一格本轮按严格口径重测得 <b>172</b>(块内每条顶层语句都是 log 调用才算),
* 低于用户给的 249——两边口径不同(宽松版把"log + 紧跟 return null"也算进去)。
* 这里两条都钉:≤249 是验收口径,≤172 是本轮严格口径的实测值,
* 免得日后有人拿"249 还没用完"当额度往里加只 log 的吞异常块。
*/
class CatchSilenceRatchetTest {
/** 分母树:main 源码树(不含测试树——测试里的 catch 是夹具,不是现网出口)。 */
private static final Path TREE = moduleRoot().resolve("src/main/java");
// ==== 验收基线(用户 2026-10-08 12:0x 实测,HEAD 274ad017,单位:处)====
// 10-17 心跳证据两处 fail-open 抬 559 -> 561,逐处出处见 STRICT_NOT_RETHROW 上方注释。
// 10-18 外观专利失败兜底自吞抬 561 -> 562,逐处出处同下。
// 10-24 损耗监控三处带锚点的 fail-open 抬 562 -> 564,逐处出处见 STRICT_NOT_RETHROW 上方注释。
// 10-25 B15 join 无界收口抬 564 -> 569,逐处出处见 STRICT_NOT_RETHROW 上方注释。
// 10-26 第二轮 CR-Fix 2 抬 569 -> 573,逐处出处见 STRICT_NOT_RETHROW 上方注释(4 处必要 fail-open)。
static final int GIVEN_TOTAL = 1000;
// 10-27 「整表都要跑完」专项抬 573 -> 577(2 枚新增不重抛 + 2 枚既有整批抛出改逐条跳过,逐处记名见 STRICT_TOTAL 上方)。
// 10-27 同日第二批抬 577 -> 579(批量入库逐批容错+folder 去重逐条目容错,两处都是 log.warn+计数+continue,
// 逐处记名见 STRICT_TOTAL 上方注释)。
// 10-28 V179 采集被过滤行追溯抬 579 -> 582(审计件三枚:逐批插入容错/回流簿记容错/尾 sheet 降级,
// 逐处记名见 STRICT_TOTAL 上方注释)。
// 10-28 Phase 3 抬 582 -> 585(心跳降级一枚 + 优雅停机两枚中断恢复,逐处记名见 STRICT_TOTAL 上方注释)。
// 10-29 Phase 4D 抬 585 -> 591(AC-17 分片通道六枚 LOG_ONLY:清理/收尾失败不得盖掉主错误,
// 逐处记名见 STRICT_TOTAL 上方注释;EMPTY 一格没涨)。
// 10-30 用户端代理白名单(极客/青果)抬 591 -> 598(7 处逐一记名见 STRICT_TOTAL 上方注释;
// 实测量到 599,多出的 1 格来自已提交的 79b04afd(AdminApiGuardFilter 编码绕过 catch),见同处说明)。
// 10-31 Phase 5.1:证据登记失败回收对象一枚(内层回收失败只 WARN),599 -> 600。
// 10-31 CR 消项:证据保留期清理失败 WARN 兜底 + 任务号溢出回落 task_no,新增 2 处非抛分支,600 -> 602。
// 11-01 失败任务原任务重试:TaskInPlaceRetryService 的 clearResultError / resetAssembleJob
// 两处 WARN 兜底,602 -> 604(logOnly 249 -> 251;严格格 STRICT_LOG_ONLY 190 -> 192)。
// 11-05 密钥余额三面(龙抬头 credits/后管实时查)抬 604 -> 608:五枚新增**全是 NOT_RETHROW**,
// LOG_ONLY 与 EMPTY 一格没涨(逐处记名见 STRICT_TOTAL 上方注释)——改的是"查不到"怎么表达,不是把它藏起来。
// 11-10 v1.3 外观专利无侵权同步链抬 608 -> 611:三枚不重抛(同步服务两枚+控制器内部令牌回退一枚),
// 逐处记名见 STRICT_TOTAL 上方注释;LOG_ONLY 宽口径格 251 没动(宽口径实测已落到 193,离上限很远)。
// 11-14 v1.4 京东数据库抬 611 -> 615:三枚不重抛(Phase 5 后管两处 resolveInternalOperator 返回 null
// + parseAttrGroups 的 attr_json 兜底;Phase 2/4 的 7 枚全是 RETHROW、Phase 2 的 scope 行
// DuplicateKeyException 是 LOG_ONLY,都不占本格),逐处记名见 STRICT_TOTAL 上方注释;
// LOG_ONLY 宽口径格 251 没动(宽口径实测 194,离上限很远)。
// 11-14 v1.5「获取店铺数据」进度条抬 615 -> 616:一枚不重抛(进度查询读 scope.state_json
// 失败 log.warn + 空对象),逐处记名与误差方向见 STRICT_TOTAL 上方注释;LOG_ONLY 一格没动。
// 11-15 京东 B101/B102 收口抬 616 -> 619:三枚不重抛含 log(JdProductQueryService SKU 组合解析
// 与 JdResultIngestService 单行 SKU 跳过两枚落 LOG_ONLY、JdProductSkuIngestService.writeJson
// 序列化是 log+return),出处与误差方向逐处见 STRICT_TOTAL 上方 11-15 段;EMPTY 一格没涨。
static final int GIVEN_NOT_RETHROW = 619;
static final int GIVEN_LOG_ONLY = 251;
static final int GIVEN_EMPTY = 56;
// ==== 本轮严格口径重测(SilentCatchScanner 在同一棵树上跑出来的四个数)====
// total 里含本轮拒起闸门新加的那 1 处:它是 RETHROW 形状(catch (IOException e) ⇒ 抛 IllegalState),
// 所以 rethrow 385→386、total 1000→1001,而气味三格一个都没动:
// notRethrow 559、empty 56 与验收基线**逐字相同**,这就是两套口径互为对账的证据。
/**
* 1000(验收基线)+ 拒起闸门那批新增的 1 处 + {@code BuildInfoLogger.read()} 的 1 处 = 1002。
* BuildInfoLogger 那一处不是吞掉:它打 {@code [build-info-missing]} 的 WARN 并返回可区分的
* "章存在但没盖住"状态,巡检按锚点数得到。抬这一格是为了把出处留在这份 diff 里,
* 而不是让后来人以为基线是自然涨上来的。
* 10-17 再 +2,逐处记名:{@code TaskHeartbeatLivenessService.stamp()}(心跳证据写失败只 WARN,
* 心跳接口不许因证据写不下去而 500)与同类 {@code lastHeartbeatMillis()}(读证据失败一律落到 0=
* 「没有证据」,判死线据此放宽)。两处都是 fail-open 且方向是「少杀一个任务」,与上面
* BuildInfoLogger 同形状;本仓实测基线由 1001 起(原记 1002 留有 1 格无人认领的额度),
* 加这 2 处后实测 1003。
* 10-18 再 +1:{@code AppearancePatentTaskService.fallbackAssembleResultFile()} 的兜底自吞
* (log.warn + return false)——{@code ResultFileJobHandler#fallbackAssembleOnFailure} 的接口
* 契约明确要求「实现应自吞异常(兜底失败只记日志,不影响 job 已终态失败的事实)」,与
* DeleteBrandRunService 同名兜底同形状;Worker 侧另有 catch 双保险,让判死作业的兜底每轮
* stuck 扫描幂等重入。实测 1004。
* 10-24 损耗监控(cost-guard)本笔新增 6 处,逐处点名(同批先写后摘、没留在树上的 6 处:
* SHA-256 指纹改走 {@code DigestUtil.sha256Hex}、env 读数改纯正则前置校验、共享密钥扫描的
* 自吞交给 {@code scan()} 已有的那枚、当日用量读数改成直接抛(客户端把轮询失败当
* 「维持上一次读数」处理,比伪造一组零值诚实)、{@code resume()} 的吞异常改成外抛——
* 它返回 false 时控制器仍回「已继续任务」,那是假成功):
* <ul>
* <li>{@code LlmKeyGate.Gate.acquire()} 两枚:{@code InterruptedException} ⇒ 复位中断位并重抛
* IllegalStateException;{@code RuntimeException} ⇒ 先 {@code permits.release()} 再原样重抛,
* 少了这一处排队令牌就永久漏一个(两枚都是 RETHROW 形状);</li>
* <li>{@code LlmKeyGate.Gate.waitForInterval()} 一枚:同为 InterruptedException 重抛形状;</li>
* <li>{@code CostGuardScheduler.scan()} 一枚:调度线程整轮异常只打 {@code [cost-guard]} WARN,
* 下一轮照跑——让它抛出等于这条监控自己变成噪声源;</li>
* <li>{@code UserTaskGuardService.pause()} 一枚:单个账号的暂停写失败不能中止整轮扫描
* (否则排在这之后的账号这轮全不被检查),下一轮还会再判一次;</li>
* <li>{@code UserTaskGuardService.load()} 一枚:读不到闸门状态按「未暂停」走——数据库抖动
* 不该把全体用户的合法任务一起冻住,真失控由下一轮重新置位。</li>
* </ul>
* 本格实测 1004:这 6 处落进的是 1004 之前已被更早删腾出、无人认领的额度里(上一笔整树实测
* 997,见 RETHROW_FLOOR 上方),所以基线不抬反而按实测收到 1003;**再 +1 是同一时段
* {@code ba20f5ed feat(workbench-client)} 那枚新增 catch,不属本批、也未由本批记名**,
* 该由那一笔自己把出处补进这份 diff。每一处本批的新增都在这里点名。
* 不重抛/只 log/空体三格上限一个字没动。
*
* <p>10-24 Phase 7 EasyExcel→POI 收口再 +4,逐处点名(全部是 RETHROW 形状,气味三格未动):
* <ul>
* <li>{@code ExcelStreamReader.readOoxml} 三枚:{@code OpenXML4JException}(坏包)、
* {@code SAXException}(sheet XML 坏了)、{@code RuntimeException}(POI 解析期异常)
* 全部经 {@code toContractException} 转成 IOException 或原样重抛,不吞;</li>
* <li>{@code ExcelStreamReader.readHssf} 一枚:{@code RuntimeException} 同上收口。</li>
* </ul>
* 这 4 处是替换 EasyExcel 监听器后的等价出口(原实现的 catch 只在 {@code runRead} 一处,
* 但监听器内部另有 POI 的异常分诊);实测 total 1008。
*
* <p>10-25 B15 任务活性收口再 +10(同时替换掉 2 处 join 侧的旧 catch,整树实测 1015),
* 逐处点名——{@code join()} 没有时间界,下面四类出口改成带截止的等待后,超时必须各有去处:
* <ul>
* <li>{@code FutureDeadline.await} 一枚:超时先 cancel 该 future,再重抛带标签的
* TimeoutException(RETHROW);</li>
* <li>{@code AppearancePatentLlmClient.runBatches} 两枚:超时/执行失败与中断都收口成该批
* {@code BatchOutcome} 失败(NOT_RETHROW,替换原来那一枚 {@code catch (Exception)});</li>
* <li>{@code BrandTaskService.buildAndUploadResult} 三枚:超时/中断/执行失败按 IOException
* 或原异常重抛(RETHROW,替换原来那一枚 {@code catch (CompletionException)});</li>
* <li>{@code SimilarAsinLlmService} 的类目与合规两个 prepass 各两枚:超时/执行失败只 WARN
* 并继续(LOG_ONLY),中断复位中断位后退出等待(NOT_RETHROW)。这两处预计算本就是
* 逐行链路的缓存,缺结果的行会走单行回退,所以等待侧超时不需要炸掉整条任务。</li>
* </ul>
* 同批实测 notRethrow 569、logOnly 176、empty 56;气味三格只按这三处实测值抬,形状未放宽。
*
* <p>10-26 抬 1015 -> 1024(第二轮 CR-Fix 2,共 9 处新增 catch,逐处记名):
* <ul>
* <li>{@code WorkbenchClientPackageService.confirmPackage} 一枚:{@code DuplicateKeyException}
* 并发冲突按 objectKey 幂等或转业务错误(RETHROW);</li>
* <li>{@code WorkbenchClientPackageService.rejectCredentialFiles} 两枚:{@code BusinessException}
* 原样重抛、{@code IOException} 清对象后转业务错误(RETHROW);</li>
* <li>{@code WorkbenchClientPackageService.removeRejectedObject} 一枚:{@code RuntimeException}
* 清理失败只 WARN,不让存储异常盖掉业务错误(LOG_ONLY);</li>
* <li>{@code WorkbenchClientPackageService.deleteTempQuietly} 一枚:{@code IOException}
* 删临时文件失败只 WARN(LOG_ONLY);</li>
* <li>{@code OssStorageService.downloadWorkbenchClientObjectToTempFile} 两枚:外层
* {@code Exception} 转 {@code storageFailure} 重抛(RETHROW),内层清理失败只 WARN(LOG_ONLY);</li>
* <li>{@code CostGuardScheduler} 一枚:平台自费告警推送失败只 WARN 并保留基线待下轮重试
* (NOT_RETHROW,log+return);</li>
* <li>{@code SimilarAsinLlmService} 一枚:{@code InterruptedException} 恢复中断位后上抛
* (RETHROW)。</li>
* </ul>
* 9 处均为 CR-02/05/10/20 的必要出口,不是把已有异常改回吞掉;同批实测 total 1024、
* notRethrow 573、logOnly 179、empty 56。
*
* <p>10-27 整表跑完专项抬 1024 -&gt; 1026(用户口径:整表都要跑完,单项坏了跳过它继续下一项,
* 只有 LLM 密钥欠费/失效那一类才允许直接判任务失败),逐处记名:
* <ul>
* <li>{@code BrandTaskStorageService.rebuildAggregate} 一枚:单片载荷读不到时
* log.warn+记跳片号+{@code continue}(NOT_RETHROW)。此前一片抛就把整份聚合丢掉,
* 而三个调用方(finalizeTask/abort/tryRecoverCompletedRunningTask)都没有就地 try,
* 一个坏分片=整任务不产出;同批把 {@code completed} 的判据从 {@code chunks.size()}
* (DB 行数)改成「真正读到的片数」,缺数据不再被判成已收齐。</li>
* <li>{@code AppearancePatentLlmBatchPipeline.collectPendingLlmCandidates} 一枚:
* 同为 log.warn+计数+{@code continue}(NOT_RETHROW)。collect 跑在批循环<b>之前</b>,
* 一抛就走不到循环体内那道 {@code finally releaseRowInspection},本轮已申领的行要挂满
* 处理中 TTL(15 分钟),且 {@code terminalizeRoundExhaustedRows} 跟着一起不执行。</li>
* </ul>
* 另有两枚<b>既有</b> RETHROW 出口按同一口径改成「跳过该项」,形状从 RETHROW 迁入气味两格
* (total 不变、rethrow −2、notRethrow +2、logOnly +2):{@code BrandTaskStorageService.getParsedPayload}
* 与 {@code BrandTaskStorageService.getAllFileAggregates}——两处此前一个文件的缓存/聚合读不到
* 就整批抛,把已读到的其余文件一起抹掉;改后逐条 WARN 跳过,调用方按「尚未收齐」可重试。
* ⚠ 这两处不是把异常静默吞掉:跳过都带 {@code [brand-storage]} 锚点 WARN,且
* {@code BrandTaskStorageServiceFaultToleranceTest} 钉住「其余项照常出」与
* 「全项坏掉仍大声抛」两条,缺数据一律不得冒充已完成。
* 同批实测 total 1026、rethrow 393(仍高于下限 380,本格不动)、notRethrow 577、logOnly 181、empty 56。
*
* <p>10-27 同日第二批(B49 非 ★ 收尾)再抬 total 1026 -&gt; 1028、notRethrow 577 -&gt; 579,逐处记名:
* <ul>
* <li>{@code QueryAsinService.flushInsert} 一枚:ASIN 导入按批 try/catch,坏批点名后其余批照常入库
* (此前坏批直接冒到 {@code runImportTask},后面的批次一个都跑不到),log.warn+计数(NOT_RETHROW);
* 有坏批时任务落 failed——admin 页只在 failed 分支显示 errorMessage,留在 success 就是
* 把"没入库"说成"导入完成"。</li>
* <li>{@code DedupeRunService.packageFolderDedupeResultsAsZip} 一枚:folder 模式逐条目容错,
* 一个都没写进时拒绝交空包(NOT_RETHROW);aborted 仍落 FAILED,非 folder 分支零改动。</li>
* </ul>
* 第三处 {@code PublishTaskService} 只改文案、不加 catch;SUCCESS 的
* {@code file_task.error_message} 保持留空(缺口写 {@code biz_file_result.error_message}),
* 因为 {@code TaskRetryEligibility}/{@code SimilarAsinStaleReopenSupport} 会按 errorMessage
* 字面量分类,写进去等于替一条正常任务编一个失败理由。
* 同批实测 total 1028、rethrow 393(未动)、notRethrow 579、logOnly 181(未动)、empty 56(未动)。
*
* <p>10-28 采集「被过滤行」追溯(V179,结果 Excel 第 3 个 sheet)抬 total 1028 -&gt; 1031,逐处记名。
* 三枚都是<b>审计件不得打掉交付</b>那一形,块体各只有一句带 {@code [collect-data]} 锚点的 WARN:
* <ul>
* <li>{@code CollectDataFilteredRowStore.writeBatch} 一枚:被过滤行按批 INSERT,坏批点名后
* 其余批照常落库(口径照 {@code CollectDataInvalidAsinBatchWriter})。这份明细不参与任何
* 判定,为它打掉用户已采回的数据是拿可追溯性换交付;跳过的批会从四类计数与已落库行数
* 的差里冒出来,sheet 上写「另有 N 行未逐条记录」,不是静默少给。</li>
* <li>{@code CollectDataFilteredRowStore.markResolved} 一枚:补测回流只盖时间戳+追加一句。
* 必要性是实测的——{@code CollectDataBrandRecheckScheduler} 抓住 {@code apply()} 的抛出后
* <b>整组留队重放</b>,这里若外抛,一次簿记失败会让已注入的任务永远重排。</li>
* <li>{@code CollectDataExcelAssemblyService.writeFilteredSheet} 一枚:尾 sheet 读不动就交付
* 前两表、缺这张审计表。同批我先写的第二枚("清单不完整"那行的内层 catch)已删掉:
* 那只是本地 POI 写,写不动说明整份 workbook 都写不动,该由
* {@code writeWorkbookStreaming} 的既有出口处理,与前两张 sheet 同姿势。</li>
* </ul>
*
* <p>10-28 Phase 3(v1.1 后端任务引擎稳定性)抬 total 1031 -&gt; 1034,三处逐条记名:
* <ul>
* <li>{@code TaskHeartbeatService.touchFileTaskIfRunning} 一枚:模块进度写抛任何运行时异常
* (S1-B4 的 40902 就是这一类)都降级成 {@code progressDegraded=true},块体一条 WARN 带
* taskId/moduleType;不接住就等于心跳继续 500/40902,客户端会当"任务不在了"。</li>
* <li>{@code TaskFileJobConfig.taskQueueVirtualThreadExecutor} 的 {@code shutdown()} 一枚:
* await 期间被中断只恢复中断标记(S1-B6 优雅停机),不吞别的东西。</li>
* <li>{@code TaskFileJobConfig.videoQueueExecutor} 一枚:信号量 acquire 被中断只恢复中断标记
* (S1-B2 视频独立许可,照抄 taskQueueExecutor 的既有形状)。</li>
* </ul>
* <p>10-29 Phase 4D(AC-17/S1-F3 大文件分片通道)抬 total 1034 -&gt; 1045,11 枚逐处记名。
* 这一批是"新增通道"而不是"给既有出口补兜":整条 {@code ChunkedUploadService} 与
* {@code WorkbenchClientPackageService} 的分片方法都是新落点,Java 的受检 {@code IOException}
* 使每一段磁盘动作都必须有自己的出口,形状与既有件同口径:
* <ul>
* <li>RETHROW 五枚——{@code ChunkedUploadService.init}(建会话目录失败:先 {@code deleteQuietly}
* 再抛 {@code BusinessException},不留半个会话)、{@code complete}(拼装中途失败:删掉半成品
* 后原样 {@code throw ex},绝不产出半个文件)、{@code readMeta}(元数据损坏直接抛,
* 让调用方重新 init 而不是按坏元数据继续拼)、{@code sha256Digest}(JVM 无 SHA-256 属环境级
* 不可能,抛 {@code IllegalStateException} 带 cause)、{@code WorkbenchClientPackageService
* .completeChunkedPackage}(拼装 IOException 翻成业务文案,500 变可读错误)。</li>
* <li>LOG_ONLY 六枚,块体各只有一句带锚点的 log,误差方向都是"清理/收尾失败不得盖掉主错误"——
* {@code ChunkedUploadService.cleanupStaleSessions} 内层(单条目时间戳读不出,本轮跳过该条)
* 与外层({@code Files.list} 失败,整轮清理放弃但不拦新会话)、
* {@code deleteQuietly} 的逐片删除与整体遍历两枚(残留交给过期回收),
* {@code WorkbenchClientPackageService.abortChunkedPackage} 的两枚(会话已不存在只 INFO;
* 未登记对象清理失败 WARN 带 objectKey,登记成功的对象后端会拒绝清理,不该在这里改口)。</li>
* <li>EMPTY 一格没涨:三处原本写成 {@code catch (IOException ignored) { /* 尽力清理 *\/ }} 的
* 空体已按 10-26 那批的先例改成 WARN 带 path——空体是三类高危出口里最贵的一种,
* 这里宁可让 {@code STRICT_LOG_ONLY} 涨六格,也不给"删除失败连日志都不留"开门。</li>
* </ul>
*
* <p>10-30 用户端代理白名单(极客/青果白名单 API)抬 total 1045 -&gt; 1052,7 枚逐处记名。
* 全部是 NOT_RETHROW(log+return 或纯 return),RETHROW/LOG_ONLY/EMPTY 三格一枚未涨:
* <ul>
* <li>{@code JikipProxyClient.checkAndAddWhitelist} 添加一枚:网络/解析/上游非 0 code 统一折成
* {@code ProxyWhitelistOutcome(false, ...)} 交控制器转可读文案;异常只记类型——RestClient
* 异常消息可能带完整 URL(含套餐 key),禁止回传或落日志。</li>
* <li>{@code JikipProxyClient.checkWhitelist} 查询一枚:查不到(含网络失败)返回 null,
* 由调用方继续尝试添加——查询只是省一次写调用,不能变成添加的前置故障点。</li>
* <li>{@code QingguoProxyClient.checkAndAddWhitelist} 添加一枚与
* {@code QingguoProxyClient.queryContains} 查询一枚:与极客两枚同形状(同一套"先查后加"),
* 异常只记类型——查询串里带用户的青果 Key。</li>
* <li>{@code UserProxyPlanService.decryptQuietly} 一枚:已存套餐 key 解密失败按「未配置」处理
* (返回空串),只记异常类型,绝不把密文/明文写进日志;抛出去只会让整个代理配置页 500。</li>
* <li>{@code PublicIpValidator.normalize} 一枚(仅 return null):正则已拦字面量与段数,
* {@code InetAddress.getByName} 的 {@code UnknownHostException} 表示输入非法,
* 返回 null 让控制器给 400,不是吞供应商/DB 异常。</li>
* <li>{@code ProxyLinkKey.fromUrl} 一枚(仅 return null):提取链接里 {@code key} 的百分号编码
* 坏了就当作没带 key(后续按「未配置」提示重填),不把坏输入升级成整页失败。</li>
* </ul>
* 同批实测 total 1052、rethrow 398、notRethrow 598、logOnly 188(未动)、empty 56(未动)。
* ⚠ 本批提交时整树已是 1053/notRethrow 599:多出的 1 格不属本批——已提交的 79b04afd 在
* {@code AdminApiGuardFilter.decodePath} 增加了「畸形百分号编码保持原样、交给容器 400」的 catch
* (NOT_RETHROW 形状),该笔未抬本基线。这里按整树实测一并包住并在这一行记名。
*
* <p>10-31 v1.2 Phase 3 证据件落点抬 total 1053 -&gt; 1055,两枚逐处记名(都在
* {@code TaskEvidenceService}):
* <ul>
* <li>{@code register} 一枚:{@code IOException | RuntimeException} 记 WARN 后转
* {@code BusinessException}(RETHROW 形状,同时进 rethrow 400);证据件写不进独立桶
* 必须让客户端拿到可读失败,不能登记一条指向空对象的行。</li>
* <li>{@code purgeExpired} 一枚:保留期回收逐行删除,单行删对象/删登记失败只记
* {@code [task-evidence]} WARN 并继续扫下一行(NOT_RETHROW+LOG_ONLY);一行坏数据
* 不该让整轮保留期回收停摆,下一轮还会重试。</li>
* </ul>
* 同批实测 total 1055、rethrow 400、notRethrow 599(未涨,register 是重抛形状)、
* logOnly 189、empty 56。
*
* <p>10-31 Phase 5.1 CR 消项再抬 1055 -&gt; 1057,两枚逐处记名(都在
* {@code TaskEvidenceService.register} 的登记行写入失败兜底):外层 catch 回收已上传对象
* 后转业务错误(RETHROW+rethrow 401);内层 catch 是对象回收本身失败只 WARN
* (LOG_ONLY+logOnly 190)。两处误差方向都是「不让孤儿对象永久占桶」。
*/
// 10-31 CR 消项:版本包/教程包凭据扫描新增 6 处 catch(均转业务异常或带 WARN),1057 -> 1063。
// 11-01 失败任务原任务重试:`TaskInPlaceRetryService` 两处「尽力而为」兜底各记一枚,1063 -> 1065
// (两处都是 LOG_ONLY+notRethrow,所以 logOnly 同步 190 -> 192):
// ① clearResultError:结果行清错误文案失败只 WARN——它只影响界面旧文案,不能因此
// 把已经复位成 PENDING 的任务再打回失败;
// ② resetAssembleJob:复位组装作业失败只 WARN——同理,任务已复位,作业复位失败由
// stuck 扫描兜底,不该阻断用户点出来的这次重试。
// 反向对照:两处都不能改成「吞掉」——WARN 里带 taskId 与异常消息,出问题看得见。
// 11-05 密钥余额三面(龙抬头人民币余额 client/后管实时查余额)抬 1065 -> 1069,五枚全部 NOT_RETHROW,
// LOG_ONLY 与 EMPTY **一格没涨**——每一枚都把"这次没查到"换成界面读得出的状态,而不是只留一行日志:
// ① `LongtaitouBalanceClient.fetch`:网络/上游异常 ⇒ available=false +「余额查询失败」人话 + WARN。
// 反向对照:改成往外抛=一次余额查询把设置页打成 500;改成静默 return=界面显示 ¥0(假绿)。
// ② `LongtaitouBalanceClient.numberOrNull`:金额串(含 `$`/千分位)解析失败 ⇒ 返回 null ⇒
// 上游 credits 不可解析就当"查不到"。这一枚是"美元当人民币"的闸门:回落顶层数字才是真事故。
// ③ `LongtaitouBalanceClient.parseJson`:应答不是可解析 JSON ⇒ null,调用方给「返回的不是可解析的 JSON」。
// ④ `UserSecretBalanceAdminService` 行等待 `TimeoutException`:cancel 该行的 future、该行按
// 「上游未在本轮时间预算内应答」降级,并把 userId 记进 timedOutUserIds 如实上报(不得读成 0)。
// ⑤ 同处 `ExecutionException | InterruptedException`:先复位中断位,再同样按"未应答"降级+记账+WARN。
// 反向对照:④⑤ 若改成"超时给 0"或"catch 后什么都不记",后管那一列就会把"没问到"卖成"没钱"。
// 11-10 v1.3 外观专利无侵权同步链抬 1069 -> 1073(full 档格子,四枚逐处记名,全在本轮四个新文件里):
// ① `AppearancePatentCleanSyncService.syncFromResult`:`catch Exception` 只落一条带堆栈的
// WARN 后返回——AC-3 的核心语义:同步失败绝不反写任务/结果/作业(LOG_ONLY,logOnly 192 -> 193)。
// 反向对照:改成往外抛=一次同步抖动把已成功的出表打成失败(B77 语义敏感区,铁律 14/21 边界)。
// ② 同类 `loadNoInfringementConclusion`:`catch ReflectiveOperationException` ⇒ 返回 null ⇒
// 调用方每次落 error 并停摆——判定常量读不到必须显形停摆、绝不猜值(铁律 30 同形状)。
// ③ `AdminAppearancePatentCleanItemsController.resolveOperator`:`catch BusinessException` ⇒
// 先试内部令牌回退,回退失败把原鉴权异常原样重抛(块内含 throw ⇒ 进重抛格,不吞)。
// ④ 同类 `resolveInternalOperator`:`catch NumberFormatException | BusinessException` ⇒ 返回 null ⇒
// 上层把原 401/403 原样抛回(回退失败必须显形,不吞)。
// 本批复核办法:上限压 0/下限抬 99999 单跑一次,实测 total 1073、rethrow 406、
// notRethrow 611、logOnly 193、empty 56(EMPTY 一格没涨)。
// 11-11 外观专利数据库导出抬 1073 -> 1074,一枚逐处记名:
// `AppearancePatentCleanItemQueryService.writeExportWorkbook`:SXSSF 落盘 catch Exception
// → BusinessException「导出外观专利数据库失败,请稍后重试」(RETHROW 形状,rethrow 406 -> 407,
// 本格与 NOT_RETHROW/LOG_ONLY/EMPTY 都不动)。误差方向:导出请求的 IO 失败必须给用户
// 可读业务错误而不是 500 裸堆栈;反向对照——改成往外抛 IOException=前端拿到 Spring 兜底文案,
// 改成吞掉返回空字节=用户拿到 0 字节 xlsx 还以为导出成功(比报错更贵)。
// 11-14 v1.4 京东数据库抬 1074 -> 1090,十六枚逐处记名(Phase 2 采集域 7 枚与 Phase 4 通用化
// 3 枚随各自 commit 落码、当时未进点名册,Phase 5 收尾跑全量时由本棘轮一次性抓出,此处并册):
// 【Phase 4 通用化预签名,3 枚全 RETHROW】`OssStorageService.presignObjectUpload` /
// `objectSize`(ErrorResponseException 非 404 分支 + Exception 兜底,共 2 枚):全部转
// `storageFailure`——预签名/对撞失败必须给可读业务错误,静默 return null 会让客户端拿
// null uploadUrl 直传炸得更深。
// 【Phase 2 采集域,7 枚】`JdCollectTaskService`:① 建单载荷序列化 `catch Exception` →
// BusinessException(RETHROW);② scope 行 `catch DuplicateKeyException` → log.info 复用
// 先到行(LOG_ONLY +1,并发建单幂等语义,不吞成败);③④ `readCreateRequest` 的
// `catch BusinessException → throw ex` + `catch Exception → BusinessException`(RETHROW,
// 载荷损坏按异常拒绝回传不静默兜)。`JdResultIngestService`:⑤⑥ `parseState`/`writeJson`
// → BusinessException(RETHROW,台账损坏显形);⑦ `toSummary` `catch IllegalArgumentException`
// → BusinessException 带字段消息(RETHROW)。
// 【Phase 5 后管,6 枚】① `AdminJdProductController.resolveOperator` 与 ②
// `AdminJdProductGroupController.resolveOperator`:`catch BusinessException` ⇒ 先试内部令牌
// 回退,回退失败把原鉴权异常原样重抛(RETHROW +2)。③④ 同两文件的
// `resolveInternalOperator`:`catch NumberFormatException | BusinessException` ⇒ 返回 null ⇒
// 上层把原 401/403 原样抛回(NOT_RETHROW +2)。⑤ `JdProductQueryService.parseAttrGroups`:
// attr_json 解析 `catch Exception` ⇒ log.warn 带 productId + 空分组 + 原文透 attrJsonRaw
// 兜底(AC-7 未识别属性不丢弃;NOT_RETHROW +1)。反向对照:改成往外抛=一条脏 attr_json
// 让整行详情 500;改成静默空分组不带原文=用户看到的属性被悄悄吞掉。⑥
// `JdProductQueryService.writeExportWorkbook`:SXSSF 落盘 `catch Exception` →
// BusinessException「导出京东数据库失败,请稍后重试」(RETHROW +1,与 11-11 外观专利导出同款)。
// 本批复核办法:单跑实测 total 1090、notRethrow 614、logOnly 194、empty 56(EMPTY 一格没涨)。
// 11-14 Phase 6.1 CR 修复抬 1090 -> 1091,一枚逐处记名:
// `JdResultIngestService.parseJdTime`:DateTimeParseException → BusinessException
// 「京东时间格式不识别(应为 yyyy-MM-dd HH:mm:ss): <原文>」(RETHROW)。误差方向:
// 客户端回传脏时间戳之前直接 DateTimeParseException 裸抛 = 回传口 500 裸堆栈(P1-3);
// 改成吞掉置 null = 登记时间被悄悄抹掉。
// 11-14 v1.5「获取店铺数据」进度条抬 1091 -> 1092,一枚逐处记名:
// `JdCollectTaskService.parseScopeState`:进度查询读 scope.state_json 时
// `catch Exception` ⇒ log.warn 带原因 + 返回空对象(NOT_RETHROW)。误差方向:
// 改成往外抛 = 一行脏 JSON 把进度查询打成 500、进度条直接红条;改成静默返回空对象
// 不记日志 = 游标损坏永远没人知道。演示面只降级不抛错,但必须有那一行 WARN。
// (相邻的数值解析刻意不用 NumberFormatException 当控制流:改为 1~9 位十进制正则前置,
// 省掉两枚 catch,EMPTY 一格没涨。)
// 11-15 京东 B101/B102 收口(SKU 矩阵+删除链)抬 1092 -> 1097,五枚逐处记名(提交 402447af):
// ① `JdProductDeleteService` 删桶后库行删除失败:log.error 带 productIds(key 清单可从
// 图片登记行重建)后原样重抛(RETHROW)——"桶已删、库行回滚"的裂缝必须响亮显形;
// ② 同处对象删除失败:`throw new BusinessException("桶内对象删除失败,本次未删除任何数据…")`
// (RETHROW)——整批拒绝可安全重试,不做部分删除;
// ③ `JdProductQueryService` SKU saleAttrs JSON 解析失败:log.warn 带 skuId 后返回空 attrs
// (LOG_ONLY,块内仅一句 log)——一行脏组合不把详情页打成 500;
// ④ `JdProductSkuIngestService.writeJson`:组合维度序列化失败 log.warn 后该 SKU 不写组合
// (NOT_RETHROW,log+return,带 [silent-degrade] 锚点)——价格库存照落,不让一个坏维度拖垮整批回传;
// ⑤ `JdResultIngestService` 单行 SKU 形状不合法(price 非数字等):log.warn 后跳过该行
// (LOG_ONLY,块内仅一句 log)——与铁律 21 同形状,脏行不判死整批。
// 本批复核办法:上限压 0/下限抬 99999 单跑本类,实测 total 1097、rethrow 382、
// notRethrow(含 log) 619、logOnly 196(严格口径 +2:③⑤)、empty 56(未涨)。
static final int STRICT_TOTAL = 1097;
/**
* 重抛型 catch 的**下限**(不是上限):本轮把两处吞异常改成重抛之后实测 388。
* 这一格只能涨不能跌——它是"异常会往外走"的总量,把它钉成"只许减"就等于拦着别人修吞异常。
*/
// 10-09 下调 388 -> 387,出处点名:提交 b633bd48「摘 13 处零引用私有方法」删掉了
// DeleteBrandRunService 里一个无人调用的私有方法,它的 catch 体是
// `throw new BusinessException("生成删除品牌结果文件失败: " + ...)` —— 那是 RETHROW 形状,
// 随死代码一起离开树;实测重抛数 387、不重抛与只 log 两数未涨 ⇒ 没有任何一处"异常会往外走"
// 被改回吞掉。这一格的本意是"重抛只许涨不许跌",所以调基线必须带着这样的逐处出处;
// 拿"总数变小了"当理由不算——那种情况下真正要看的是不重抛那一侧有没有涨。
// 10-09 再下调 387 -> 386,出处点名:去重库按公司收口那一笔删掉了 DedupeTotalDataService.deleteFromExcel
// 的两个零调用者重载,其中 `throw new BusinessException("删除 Excel 匹配数据失败", e)` 是 RETHROW 形状,
// 随死代码一起离开树;实测重抛 386、不重抛与只 log 两数未涨(那两格仍绿)=> 没有任何一处「异常会往外走」被改回吞掉。
// 10-19 再下调 386 -> 385,出处点名(用户授权「逐处记名调这一格」):Phase 3 的 3B 迁移把
// ShopDataCrawlTaskService 的私有 `writeJson(Object, String)` 并进底座已有的
// `AbstractFileTaskPipeline.writeJson(ObjectMapper, Object, String)`——那一枚 catch 的体是
// `throw new BusinessException(message)`(RETHROW 形状、不带 cause),本支文案「序列化店铺数据抓取结果分片失败」
// 逐字带到调用点,失败形状与线协议一字未动(golden 的 submit-result 分片各例对撞相等)。
// 四份逐字同名件并成一份 ⇒ 树里少了一处「异常会往外走」的**实例**,不是少了一种会外走的异常;
// 本笔只从树上摘掉这一处 RETHROW 形状的 catch,不重抛侧一个字节没动:同批实测 notRethrow 562、
// logOnly 173、empty 55 三格仍在上限内(未涨)=> 没有任何一处出口被改回吞掉。
// 10-19 再下调 385 -> 383,出处点名(同一项用户授权「逐处记名调这一格」的第二笔,形状与上一笔逐字相同):
// Phase 3 的 3A 迁移把 AppearancePatentTaskService 的两处同名序列化 catch 并进底座
// `AbstractFileTaskPipeline.writeJson(ObjectMapper, Object, String)`——① 私有
// `writeJson(Object, String)`(体是 `throw new BusinessException(message)`,7 个调用点的文案逐字
// 带到调用点);② 建单里那段 `try { setRequestJson(writeValueAsString(request)) … } catch (Exception ex)
// { throw new BusinessException("序列化解析结果失败") }`,失败形状与线协议一字未动。
// 本笔另摘的三枚零调用私有件(abbreviate/resultLookupKeysForResultRows/isHistoryFileBuilding)
// 里没有 catch,所以 RETHROW 只降这两格;不重抛/只 log/空体三格同批复跑未涨(三格判据一条没放宽)。
// 10-19 再下调 383 -> 381,出处点名(同一项用户授权的第三笔,形状与上一笔逐字相同):
// Phase 3 的 3C 迁移把 CollectDataService 的两处序列化 catch 并进底座
// `AbstractFileTaskPipeline.writeJson(ObjectMapper, Object, String)`——① 私有
// `writeJson(Object, String)`(体是 `throw new BusinessException(message)`,唯一调用点的文案
// 「采集结果序列化失败」逐字带到调用点);② 建单 `persistParsedTask` 里那段
// `try { setRequestJson(writeValueAsString(…)) … setResultJson(writeValueAsString(…)) }
// catch (Exception ex) { throw new BusinessException("序列化任务信息失败") }`。
// 两支文案、异常类型、不带 cause 这三条线协议事实一字未动(golden 建单 4 段+回传 15 段逐字节相等)。
// ⚠ 本支还有第三处同形状(`persistStats` 的 try 包 15 行 put 加一次序列化),**这笔没并它**:
// 用户授权的范围是两处,第三处要再降一格须另行记名。不重抛/只 log/空体三格同批复跑未涨
// ——这三格是上限、且常量就等于上一次记下的实测值,所以「绿」本身就证成「未涨过那一数」。
// ⚠ 历史数不等于现状数(本笔踩过,记法留在这里给下一个读的人):total 是**上限**,
// 只在新增加时红,删掉 catch 从不回头核对 ⇒ 常量上方那些「实测 1003/1004」会与现实脱钩。
// 复现办法(本笔实测用过的):把 STRICT_TOTAL 与三格上限临时压到 0、把本格下限抬到 99999,
// 单跑本类一次,断言文案里就是当前整树实测值。本笔读到的数是 **total=998、rethrow=381**;
// 与 1004 差的那 6 格里本笔只占 2(另 4 处是更早几笔静默摘掉的,不在本笔账上、也无从追认)。
// 判据一格未放宽:本格仍按实测下限钉住,四格上限原样不动(要收紧得逐处记名另笔请示)。
// 10-19 再下调 381 -> 380,出处点名(同一项授权的续笔,用户 2026-10-19 拍板「按顺序」第①项):
// 3C 第五笔把 CollectDataService 的**第三处**同形状序列化 catch 并进同一枚底座件——
// `persistStats` 那段 `try { 15 行 payload.put(…) … task.setResultJson(writeValueAsString(payload)) }
// catch (Exception ex) { throw new BusinessException("保存采集统计失败") }`。文案、异常类型、
// 不带 cause 三条线协议事实逐字带到调用点(回传 15 段 golden 逐字节复现,那 15 段每段都过这一格)。
// 并档顺带把捕获面从「建 map +序列化」收回「序列化」:LinkedHashMap.put 对这些值不可能抛,
// 所以没有出口被改回吞掉;不重抛/只 log 两格的上限值恰等于上一次记录的实测值(562/173),
// 绿即证这两格未涨;⚠ empty 那格常量是 56 而上一次记录是 55,绿只证「≤56」、不证未涨——
// 别把这句读成三格都被重新证明过。
// 整树实测(复现办法同上:上限压 0、下限抬 99999 各单跑本类一次):**total=997、rethrow=380**
// (上一笔读的是 998/381,本笔各 −1,与本笔摘掉的那一处 RETHROW 形状对得上账)。
// 11-15 京东 B101/B102 收口上调 380 -> 382,出处见 STRICT_TOTAL 上方 11-15 段:新增 5 枚中
// 2 枚是 RETHROW(删除链的"桶已删、库行回滚"重抛 + 对象删除失败整批拒绝)。
// 这是下限不是上限:重抛枚数变多 = 又有两处异常被改成往外走,只许涨。
static final int RETHROW_FLOOR = 382;
/**
* 10-17 抬 559 -> 561,逐处记名(两处都是新增的 fail-open 证据读写,不是把已有出口改回吞掉):
* 1){@code TaskHeartbeatLivenessService.stamp()}:心跳证据写失败只 WARN——心跳接口不许因为
* 「记不下证据」而 500,那会让客户端整轮心跳线程崩掉,反而制造更多孤儿任务;
* 2){@code TaskHeartbeatLivenessService.lastHeartbeatMillis()}:读证据失败一律落到 0=「没有证据」,
* 判死线据此**放宽**(顶多让任务多活一会儿,最终仍由未启动宽限与 stale-repair 兜底)。
* 两处的误差方向都是「少杀一个任务」,与这一格想拦的「异常到此为止、外面看不见」不同性质;
* 抬格是为了把出处留在这份 diff 里,而不是让后来人以为基线自然涨上来的。
* 10-18 抬 561 -> 562,逐处记名:{@code AppearancePatentTaskService.fallbackAssembleResultFile()}——
* 失败兜底组装的自吞出口(接口契约要求,见 {@code ResultFileJobHandler#fallbackAssembleOnFailure}),
* 与 {@code DeleteBrandRunService.fallbackAssembleResultFile} 同形状、同性质:兜底失败不得掩盖
* 作业已终态失败的事实,也不得打断 stuck 扫描对终态失败作业的幂等重入。形状是 log+return false,
* 因此只进本格与 total,不进 STRICT_LOG_ONLY(严格口径不数 log 后接 return)。
* 10-24 抬 562 -> 564,逐处记名(损耗监控 cost-guard 的三处 fail-open,都带 {@code [cost-guard]}
* 日志锚点、巡检按锚点数得到,不是「异常到此为止外面看不见」那种无声出口):
* 1){@code CostGuardScheduler.scan()}:整轮扫描异常只 WARN——这条监控抛出就等于自己变成
* 现网噪声源,而下一轮 fixedDelay 照跑,暂停判定不会因此停摆;
* 2){@code UserTaskGuardService.pause()}:单个账号的暂停写失败若外抛,{@code runOnce} 的
* 逐账号循环就地中止,排在这之后的账号这一轮全部不被检查(最坏晚一个间隔才暂停=多烧钱);
* 3){@code UserTaskGuardService.load()}:读不到闸门状态按「未暂停」走——一次库抖动不该把
* 全体用户的合法任务一起冻住,真失控由下一轮扫描重新置位(方向是「少冻一个号」)。
* 其中 1)、2) 块体只有一句 log,故同时进 STRICT_LOG_ONLY;3) 是 log+return,不进。
* 同批先写后摘、没留在树上的 6 处静默出口见 total 那一格的点名。
* 10-25 抬 564 -> 569,逐处记名(B15 join 无界收口,共 6 处新增不重抛、替换掉 1 处旧的):
* {@code AppearancePatentLlmClient.runBatches} 两枚(超时/执行失败、中断各收口成该批失败),
* {@code SimilarAsinLlmService} 类目与合规两个 prepass 各两枚(超时/执行失败只 WARN,
* 中断复位中断位后退出等待)。两处预计算的缺行都会走单行回退,不是把已有出口改回吞掉。
* 10-26 抬 569 -> 573(第二轮 CR-Fix 2,4 处新增不重抛,逐处记名):
* {@code WorkbenchClientPackageService.removeRejectedObject}(清理失败只 WARN,不让存储异常
* 盖掉业务错误)、{@code deleteTempQuietly}(删临时文件失败只 WARN)、
* {@code OssStorageService.downloadWorkbenchClientObjectToTempFile} 内层清理(同上)、
* {@code CostGuardScheduler}(平台自费告警推送失败 log+return,保留基线待下轮重试)。
* 四处的误差方向都是「不让清理/告警失败掩盖主错误」,不是把异常静默吞掉。
* 10-27 抬 573 -> 577(「整表都要跑完」专项,4 处不重抛,逐处记名见 STRICT_TOTAL 上方注释):
* 新增 {@code BrandTaskStorageService.rebuildAggregate} 与
* {@code AppearancePatentLlmBatchPipeline.collectPendingLlmCandidates} 两枚逐片跳过;
* 另有 {@code BrandTaskStorageService.getParsedPayload}/{@code getAllFileAggregates} 两枚
* 既有「整批抛出」出口按同口径改成逐条跳过(自 RETHROW 迁入本格)。
* 10-27 同日第二批再抬 577 -&gt; 579(2 枚逐批/逐条目容错:{@code QueryAsinService.flushInsert}
* 与 {@code DedupeRunService.packageFolderDedupeResultsAsZip},块体都是 log.warn+计数,
* 坏项点名、其余照常交付,逐处记名见 STRICT_TOTAL 上方注释)。
* 10-28 再抬 579 -&gt; 582(V179 采集「被过滤行」三枚审计件容错:{@code CollectDataFilteredRowStore.writeBatch}
* 逐批插入、{@code CollectDataFilteredRowStore.markResolved} 回流簿记、
* {@code CollectDataExcelAssemblyService.writeFilteredSheet} 尾 sheet 降级;三处都是带
* {@code [collect-data]} 锚点的 log.warn+善后,块体除第一枚外各带一句状态置位/返回值,
* 逐处记名见 STRICT_TOTAL 上方注释)。
* 10-28 Phase 3 再抬 582 -&gt; 585(后端任务引擎三枚,均为「异常到此为止」的必要形状):
* {@code TaskHeartbeatService.touchFileTaskIfRunning}(S1-B4 进度写降级成 progressDegraded,
* 块体 log.warn 带 taskId/moduleType)、{@code TaskFileJobConfig.taskQueueVirtualThreadExecutor}
* 的 {@code shutdown()} 与 {@code TaskFileJobConfig.videoQueueExecutor}(S1-B6/S1-B2,
* {@code InterruptedException} 只恢复中断标记),逐处记名见 STRICT_TOTAL 上方注释。
* 10-29 Phase 4D 再抬 585 -&gt; 591(AC-17 分片通道六枚 LOG_ONLY,逐处记名见 STRICT_TOTAL 上方注释):
* {@code ChunkedUploadService.cleanupStaleSessions} 内外两枚、{@code deleteQuietly} 逐片与整体两枚、
* {@code WorkbenchClientPackageService.abortChunkedPackage} 的「会话已不存在」INFO 与
* 「未登记对象清理失败」WARN 两枚。六枚的误差方向都是「清理/收尾失败不得盖掉主错误」,
* 主错误由外层重抛;本批 EMPTY 一格没涨(原先三枚空体已按 10-26 先例改成带 path 的 WARN)。
* 10-30 再抬 591 -&gt; 598(用户端代理白名单 7 枚,逐处记名见 STRICT_TOTAL 上方注释):
* 极客/青果各两枚(添加失败折成 {@code ProxyWhitelistOutcome}、查询失败返回 null 继续添加),
* 套餐 key 解密失败按「未配置」处理一枚,IP 校验与提取链接 key 解码各一枚纯 return null。
* 七枚全在用户端配置页的「手动加白名单」链路上,方向都是「选项未配置/输入非法就给可读提示」,
* 没有把服务端主链路异常静默吞掉的出口。
* 复测整树 599:多出的 1 格来自已提交的 79b04afd {@code AdminApiGuardFilter.decodePath}
* (畸形编码保持原样交给容器 400),非本批新增,说明见 STRICT_TOTAL 上方。
*/
// 10-31 Phase 5.1:同 GIVEN_NOT_RETHROW,证据登记补偿回收失败只 WARN,599 -> 600。
// 11-01 失败任务原任务重试:TaskInPlaceRetryService 两处 WARN 兜底(clearResultError /
// resetAssembleJob),严格口径实测 602 -> 604;出处见 STRICT_TOTAL 上方注释。
// 11-05 密钥余额三面:五枚 NOT_RETHROW(1065->1069 那批),严格口径实测 603 -> 608;
// 上一格 604 是**上限**而实测量一直低它一枚,这次新增把那一枚额度用掉又超上去——逐处见 STRICT_TOTAL 上方。
// 11-10 v1.3 同步链:严格口径实测 608 -> 611(三枚不重抛),出处见 STRICT_TOTAL 上方注释。
// 11-14 v1.4 京东数据库后管:严格口径实测 611 -> 614(三枚不重抛:两处 resolveInternalOperator
// 返回 null + parseAttrGroups 的 attr_json 兜底),出处见 STRICT_TOTAL 上方注释。
// 本格含 LOG_ONLY(incl 口径):同批 Phase 2 建单 scope 行那枚 DuplicateKeyException 复用
// 先到行把 LOG_ONLY 抬 193 -> 194 时连带占本格一枚额度 ⇒ 614 -> 615(出处同 STRICT_TOTAL
// 上方注释;这是本格**含 LOG_ONLY** 口径的连带,不是又一枚新的不重抛)。
// 11-14 v1.5「获取店铺数据」进度条:严格口径实测 615 -> 616(一枚不重抛:
// JdCollectTaskService.parseScopeState 读 scope.state_json 失败 log.warn + 空对象,
// 出处与误差方向见 STRICT_TOTAL 上方注释;logOnly 一格没动)。
// 11-15 京东 B101/B102 收口:严格口径实测 616 -> 619(三枚不重抛含 log:两枚落 LOG_ONLY、
// 一枚 log+return,出处见 STRICT_TOTAL 上方 11-15 段)。
static final int STRICT_NOT_RETHROW = 619;
/**
* 10-17 抬 172 -> 173,出处就是上面点名过的 {@code TaskHeartbeatLivenessService.stamp()}:
* 块体只有「取到 key 名 + log.warn」一句,写心跳证据失败时既不重试也不抛出——
* 心跳接口不许因为「记不下证据」而 500。同类的 {@code lastHeartbeatMillis()} 读失败还要
* 落 0 返回,形状是 log+return 默认值,因此不进这一格。
* 10-24 抬 173 -> 175,出处即上面 STRICT_NOT_RETHROW 里点名过的 cost-guard 两处:
* {@code CostGuardScheduler.scan()} 与 {@code UserTaskGuardService.pause()}——块体各只有一句
* {@code log.warn}/{@code log.error},都是带锚点的 fail-open,不是把已有出口改回吞掉。
* 10-25 抬 175 -> 176,出处即上面点名过的 {@code SimilarAsinLlmService} 类目/合规 prepass
* 两个超时出口之一(两处形状相同,其中一处按块内语句判定落进本格,另一处因复位中断位
* 多一条语句只进 NOT_RETHROW)。块体只有一句带 {@code [similar-asin][llm]} 锚点的 WARN,
* 缺结果的行走单行回退,不是无声吞掉。
* 10-26 抬 176 -> 179(第二轮 CR-Fix 2,3 处新增 log-only):{@code WorkbenchClientPackageService}
* 的 removeRejectedObject/deleteTempQuietly 与 {@code OssStorageService} 的临时文件清理内层,
* 三处都只 WARN 且带 path/objectKey 锚点;主错误由外层重抛,清理失败不得盖掉它。
* 10-27 抬 179 -> 181(「整表都要跑完」专项,2 处):{@code BrandTaskStorageService.getParsedPayload}
* 与 {@code getAllFileAggregates} 的逐条跳过出口——块体各只有一句带 {@code [brand-storage]}
* 锚点的 WARN。两处此前是「一个文件坏 ⇒ 整批抛出」,改后其余文件照常返回,坏的那条点名可查;
* 同批 {@code rebuildAggregate} 与外观专利候选收集因块内另有计数/continue 只进 NOT_RETHROW。
* 10-28 抬 181 -> 182(V179 采集「被过滤行」的 {@code CollectDataFilteredRowStore.writeBatch}):
* 块体只有一句带 {@code [collect-data]} 锚点的 WARN(taskId+chunk+err),坏批点名后其余批照常
* 落库。同批另两处({@code markResolved} 追加 return、{@code writeFilteredSheet} 置 incomplete 位)
* 因块内多一句只进 NOT_RETHROW。
* 10-29 Phase 4D 抬 182 -> 188(AC-17 分片通道六枚,逐处记名见 STRICT_TOTAL 上方注释):
* {@code ChunkedUploadService.cleanupStaleSessions} 内外两枚、{@code deleteQuietly} 逐片与整体两枚
* (这四枚原本是 {@code catch (IOException ignored)} 空体,按 10-26 那批先例改成带 path 的 WARN,
* 是「空体换 LOG_ONLY」的迁移而不是新增沉默),加上
* {@code WorkbenchClientPackageService.abortChunkedPackage} 的 INFO 与 WARN 两枚。
* 10-31 抬 188 -> 189:{@code TaskEvidenceService.purgeExpired} 的逐行保留期回收出口,
* 块体只有一句带 {@code [task-evidence]} 锚点的 WARN(id+reason),坏行跳过、其余照删。
* 同日 Phase 5.1 再抬 189 -> 190:登记行落库失败后的对象回收失败只 WARN(同上锚点),
* 主错误仍由外层转业务错误;不吞主错误。
*/
static final int STRICT_LOG_ONLY = 196; // 严格口径:块内每条顶层语句都是 log 调用才算(11-01 重试两处兜底 +2、11-10 v1.3 同步服务 syncFromResult +1、11-14 v1.4 建单 scope 行 DuplicateKeyException 复用先到行 +1,见 STRICT_TOTAL 上方)
static final int STRICT_EMPTY = 56;
/**
* 注释/字符串/文本块里的 {@code "catch ("} 字样条数。本轮实测 **0**——
* 于是"扫描器 total == grep 字面量口径"这条等式是**直接成立**的,不需要中间项。
* 把它单独钉死是因为:一旦有人往日志文案或注释里写 {@code catch (},
* 正确词法会不数它,两口径就此分家,而"≤ 基线"的棘轮对分母变小是沉默的。
*/
static final int BASELINE_DECOY = 0;
private static volatile Result cached;
private static Result tree() {
Result r = cached;
if (r == null) {
synchronized (CatchSilenceRatchetTest.class) {
r = cached;
if (r == null) {
r = SilentCatchScanner.scanTree(TREE);
cached = r;
}
}
}
return r;
}
/**
* 分母自证:扫描器数出的 total 与一份**独立**的简单口径(原始文件里字面量
* {@code "catch ("} 的出现次数,等价于 {@code grep -o "catch (" | wc -l})必须对得上账:
*
* <pre>naive == scanned + decoy</pre>
*
* <p>为什么不是直接 {@code naive == scanned}:字面量口径会把注释里、字符串里、文本块里的
* {@code catch (} 字样也数进去(本轮实测 7 处)。一个**正确**的词法必须不数它们,
* 所以两口径天然差这 7。把差值单独钉住({@link #BASELINE_DECOY})才是有用的断言:
* 词法若写坏、把真代码当字符串吃掉,total 会**变小**而"≤ 基线"照样绿,
* 但那些块会立刻变成 decoy ⇒ decoy 超基线 ⇒ 红。这正是 818 vs 1000 那版 bug 的显形方式。
*/
@Test
void scannerTotalAndDecoyAccountForTheIndependentNaiveCount() {
Map<String, String> raw = readTree();
int naive = SilentCatchScanner.countNaiveLiteral(raw);
List<SilentCatchScanner.Decoy> decoys = SilentCatchScanner.decoyOccurrences(raw);
int scanned = tree().total();
assertEquals(naive, scanned + decoys.size(),
() -> "对不上账:字面量口径 " + naive + " 处,扫描器 " + scanned
+ " 处,注释/字面量里的假 catch " + decoys.size() + " 处。"
+ "两口径的差只能是假 catch,多出来或少出来都说明有一边在漏数");
assertTrue(decoys.size() <= BASELINE_DECOY,
() -> "有 " + decoys.size() + " 处 \"catch (\" 字样落在注释或字符串里(基线 "
+ BASELINE_DECOY + ")。这一旦不为 0,下面那条『两口径直接相等』就得改成带中间项,"
+ "而分母变小对『≤ 基线』的棘轮是沉默的——所以宁可现在就来找一找是谁写的:" + decoys);
assertEquals(naive, scanned,
"扫描器数出的 total 必须等于独立简单口径(grep \"catch (\")的 total");
assertTrue(scanned > 900,
() -> "扫描器只数到 " + scanned + " 处,不像整棵 main 树(词法吃掉大段就会这样)");
assertTrue(naive > 950, () -> "字面量口径只有 " + naive + ",连独立分母都没站住");
}
/**
* 四个数各自 ≤ 基线(只许减)。两套基线一起钉:
* 验收口径(用户给的 1000/559/249/56)与本轮严格口径重测(994/554/170/55)。
* 只钉前者会留下 6/5/79/1 的额度被人当预算花掉,只钉后者则对不上验收数字,所以两把尺都摆在这儿。
*/
@Test
void fourNumbersMustNotGrow() {
Result r = tree();
assertTrue(r.total() <= STRICT_TOTAL,
() -> "catch 总数超过 " + STRICT_TOTAL + "(= 验收基线 " + GIVEN_TOTAL
+ " 再加上 STRICT_TOTAL 常量上方逐处记名的两处评审增量):现在是 " + r.total()
+ "。新增 catch 块要么别加,要么同批减掉一处同形状的");
assertTrue(r.count(Kind.RETHROW) >= RETHROW_FLOOR,
() -> "重抛型 catch 跌到 " + r.count(Kind.RETHROW) + ",低于下限 " + RETHROW_FLOOR
+ "。有人把一处『异常会往外走』的出口改回了吞掉——这一格只许涨不许跌");
assertTrue(r.notRethrowIncludingLogOnly() <= GIVEN_NOT_RETHROW,
() -> "不重抛(块体非空且不含 throw)超过验收基线 " + GIVEN_NOT_RETHROW + ":现在是 "
+ r.notRethrowIncludingLogOnly());
assertTrue(r.notRethrowIncludingLogOnly() <= STRICT_NOT_RETHROW,
() -> "不重抛超过本轮严格口径实测 " + STRICT_NOT_RETHROW + ":现在是 "
+ r.notRethrowIncludingLogOnly() + ",这一格就是「异常到此为止、外面看不见」的总数");
assertTrue(r.count(Kind.LOG_ONLY) <= GIVEN_LOG_ONLY,
() -> "只 log 的吞异常块超过验收基线 " + GIVEN_LOG_ONLY + ":现在是 " + r.count(Kind.LOG_ONLY));
assertTrue(r.count(Kind.LOG_ONLY) <= STRICT_LOG_ONLY,
() -> "只 log 的吞异常块超过本轮严格口径实测 " + STRICT_LOG_ONLY + ":现在是 "
+ r.count(Kind.LOG_ONLY) + "(严格口径=块内每条顶层语句都是 log 调用;"
+ "验收基线 249 那一版把『log 后紧跟 return』也算进来了,所以更宽)");
assertTrue(r.count(Kind.EMPTY) <= GIVEN_EMPTY,
() -> "空体 catch 超过验收基线 " + GIVEN_EMPTY + ":现在是 " + r.count(Kind.EMPTY));
assertTrue(r.count(Kind.EMPTY) <= STRICT_EMPTY,
() -> "空体 catch 超过本轮严格口径实测 " + STRICT_EMPTY + ":现在是 " + r.count(Kind.EMPTY)
+ ",空体是三类高危出口里最贵的一种(连日志都不留)");
}
/**
* 恒等式:total = rethrow + notRethrow(含只 log) + empty。
*
* <p>不这么钉的话,往分类器里加一个"新格子"就能把气味块从三格里悄悄搬走,
* 三个数字同时下降而总噪声一点没少——这正是"内部搬家"绕过棘轮的形状。
*/
@Test
void categoriesPartitionTheWholeDenominator() {
Result r = tree();
int rethrow = r.count(Kind.RETHROW);
int silent = r.notRethrowIncludingLogOnly();
int empty = r.count(Kind.EMPTY);
assertEquals(r.total(), rethrow + silent + empty,
() -> "分类没覆盖全部 catch:total=" + r.total() + " 而 rethrow+notRethrow+empty="
+ (rethrow + silent + empty) + ",有块掉在缝里了");
assertTrue(rethrow > 0 && silent > 0 && empty > 0,
() -> "某一格是 0,说明分类器根本没往那里判过:rethrow=" + rethrow
+ " notRethrow=" + silent + " empty=" + empty);
}
/** 每条气味块都要能定位到 文件:行号——只有标量的棘轮会被"这里加一条那里减一条"绕过去。 */
@Test
void everySilentSiteIsLocatable() {
List<Site> sites = tree().sites();
assertTrue(sites.stream().allMatch(s -> s.line() > 0), "有 catch 的定位行号是 0,清单没法用");
long distinctFiles = tree().byFile().keySet().size();
assertTrue(distinctFiles > 100,
() -> "只有 " + distinctFiles + " 个文件带 catch,分母不像整棵树");
// 单位自证:文件数 != 处数。若两者相等,说明我(或后人)把"每文件一处"当成了口径。
assertTrue(sites.size() != distinctFiles,
() -> "处数(" + sites.size() + ")恰好等于文件数(" + distinctFiles
+ ")——这几乎不可能是真的,倒像是把文件数当成了处数");
}
/**
* 注入自证(正例):内存里造四种形状的 catch,扫描器必须一种都不放过、且判对类。
*
* <p>没有这一条,"四个数都 ≤ 基线"完全可能是恒真的——分类器返回空清单时它照样绿。
*/
@Test
void injectedSitesAreCountedAndClassified() {
Map<String, String> injected = new LinkedHashMap<>();
injected.put("Harness.java", String.join("\n",
"class Harness {",
" void emptyBody() { try { work(); } catch (Exception e) { } }",
" void logOnly() { try { work(); } catch (Exception e) { log.warn(\"skip\"); } }",
" void swallowWithSideEffect() { try { work(); } catch (Exception e) { marks.add(1); } }",
" void rethrows() { try { work(); } catch (Exception e) { throw new IllegalStateException(e); } }",
" void logThenReturn() { try { work(); } catch (Exception e) { log.warn(\"x\"); return; } }",
"}",
""));
Result r = SilentCatchScanner.scanSources(injected);
assertEquals(5, r.total(), "注入的 5 处 catch 没全数出来");
assertEquals(1, r.count(Kind.EMPTY), "空体那处没判成 EMPTY");
assertEquals(1, r.count(Kind.LOG_ONLY), "只有 log 的那处没判成 LOG_ONLY");
assertEquals(2, r.count(Kind.NOT_RETHROW),
"带副作用的不重抛(marks.add / log+return)应是 2 处");
assertEquals(1, r.count(Kind.RETHROW), "重抛那处不该被算成静默");
assertEquals(3, r.notRethrowIncludingLogOnly(),
"不重抛这一格(含只 log)应是 3 处:marks.add 那处 + log 后接 return 那处 + 纯 log 那处"
+ "(空体单列一格,不在这格里)");
// 反证:同一份内容里如果一个字都不加,总数就是 0——证明上面的数字来自注入而非主树
assertEquals(0, SilentCatchScanner.scanSources(Map.of()).total());
}
/**
* 注入自证(词法陷阱):字符字面量与转义引号不许吃掉后半棵树。
*
* <p>这是用户点名的坑:{@code '\"'} 与 {@code '\''} 处理不对,后面的 {@code catch} 就整片消失
* (翻车版扫出 818 vs 真实 1000)。这里用一份小夹具把两种陷阱和真 catch 混在一起,
* 要求扫描器只数到真 catch,同时独立字面量口径必须数到更多——两口径的差值本身就是证据。
*/
@Test
void charLiteralsAndEscapedQuotesDoNotBlindTheLexer() {
// 文本块里的 \\ 会变成一个反斜杠,于是夹具里是货真价实的 \" 与 '\'' 与 '\\'
String trapSource = """
class Trap {
String decoy = "a decoy \\" catch ( inside a string";
char apostrophe = '\\'';
char backChar = '\\\\';
char quoteChar = '"';
String after = "still here";
void real() { try { work(); } catch (Exception e) { marks.add(1); } }
void alsoReal() { try { work(); } catch (IllegalStateException e) { } }
}
""";
Map<String, String> trap = Map.of("Trap.java", trapSource);
int naive = SilentCatchScanner.countNaiveLiteral(trap);
int scanned = SilentCatchScanner.scanSources(trap).total();
assertEquals(2, scanned,
() -> "真 catch 只有 2 处,扫描器数出 " + scanned
+ " 处——字面量一处理错,后面的代码就整段被吞(818 vs 1000 那个形状)");
assertNotEquals(naive, scanned,
"字符串里的 decoy catch 也被数进来了:说明扫描器根本没在剥字符串(两口径此刻必须不同)");
assertTrue(naive > scanned,
() -> "字面量口径(" + naive + ")应大于词法口径(" + scanned + "),因为夹具里埋了一条假 catch");
assertEquals(1, naive - scanned, "两口径的差应当正好是字符串里那一条 decoy");
}
/** 打当前四格计数与假 catch 清单(口径复核用,不产生断言)。 */
@Test
void printCurrentCounts() {
Result r = tree();
Map<String, String> raw = readTree();
System.out.println("CATCH total=" + r.total() + " rethrow=" + r.count(Kind.RETHROW)
+ " notRethrow(incl logOnly)=" + r.notRethrowIncludingLogOnly()
+ " logOnly=" + r.count(Kind.LOG_ONLY) + " empty=" + r.count(Kind.EMPTY)
+ " files=" + r.byFile().size()
+ " naive=" + SilentCatchScanner.countNaiveLiteral(raw)
+ " decoy=" + SilentCatchScanner.decoyOccurrences(raw).size());
System.out.println("DECOY_BEGIN");
SilentCatchScanner.decoyOccurrences(raw).forEach(d ->
System.out.println("DECOY " + d.file() + ":" + d.line() + " | " + d.context()));
System.out.println("DECOY_END");
}
// ==== §2 后端「静默出口成片」那行的**另一半**:三类出口必须含 throw 或显式锚点 ====
/**
* 任务书这一行写的是两件事:①扫描器进测试做只许减棘轮(上面那批用例);②回传/落库/扣次数
* 三类必须含 throw 或显式锚点。<b>②从来没被测过</b>——{@code Site.hasAnchor()} 在扫描器里
* 躺了几天、一个调用者都没有,而那行格子一直按"达标"计。现在把它做成真判据。
*
* <p>锚点约定是 ASCII 的 {@code [tag]}:扫描器的正则是
* {@code \[[A-Za-z0-9_.-]{3,}\]},中文方括号标签根本匹配不上。任务书里写的
* {@code [静默降级]} 属**命名与代码不一致**,这里按代码为准,锚点用 {@code [silent-degrade]}。
*
* <p>台账逐处按文件点名(只钉总数=允许"内部搬家"绕过,见本仓反复出现的那族错误)。
*/
@Test
void threeCategoriesMustRethrowOrCarryAnchor() {
Map<String, Integer> gap = gapLedger(tree().sites());
assertEquals(GAP_LEDGER, gap, () -> "三类静默出口台账变了:实测 " + gap
+ "(合计 " + gap.values().stream().mapToInt(Integer::intValue).sum() + ")"
+ "。新增要逐处记名,收掉要连这个常量一起降。");
assertFalse(gap.isEmpty(), "台账是空的 ⇒ 三类里一处静默出口都没扫到,这条判据恒真");
}
/**
* 注入自证:四种形状要判出三种结果——带 throw 放过、带锚点放过、两者都没有才记缺口,
* 无关类别连进名单都不许进。没有这条,上面那个 assertEquals 可能是"扫描器什么都不返回"的假绿。
*/
@Test
void anchorAndThrowBothCloseTheGapOnlyWhenActuallyPresent() {
Map<String, String> src = new LinkedHashMap<>();
src.put("Feed.java", "class T { void f() { try { report(feed); } "
+ "catch (Exception e) { log.warn(\"feed down\"); } } }");
src.put("Anchored.java", "class T { void f() { try { report(feed); } "
+ "catch (Exception e) { log.warn(\"[silent-degrade] feed down\"); } } }");
src.put("Throwing.java", "class T { void f() { try { report(feed); } "
+ "catch (Exception e) { throw new IllegalStateException(e); } } }");
src.put("Unrelated.java", "class T { void f() { try { socket.close(); } "
+ "catch (Exception e) { log.warn(\"x\"); } } }");
Map<String, Integer> gap = gapLedger(SilentCatchScanner.scanSources(src).sites());
assertEquals(Map.of("Feed.java", 1), gap,
() -> "只该抓到『既没 throw 也没锚点』的那一处,实抓 " + gap);
}
/**
* 三类判据:块体里出现这些字样才算回传/落库/扣次数的出口。
* 名单刻意窄——宁可少收,也不把无关 catch 卷进台账(卷进来会让"只许减"变成没人敢动的死数)。
*/
private static final Map<String, java.util.regex.Pattern> CATEGORY = Map.of(
"回传", java.util.regex.Pattern.compile("回传|report|feed|Result|notify|Notify"),
"落库", java.util.regex.Pattern.compile("\\.save\\(|\\.insert|\\.update|Mapper|Repository|updateById"),
"扣次数", java.util.regex.Pattern.compile("次数|deduct|Deduct|usage|Usage|refund|Refund|balance|Balance"));
/**
* 三类里"既没重抛也没锚点"的那些 catch,按文件计数。
*
* <p>RETHROW 直接排除(那正是我们要的形状);锚点判定走 {@link Site#hasAnchor()},
* 它看的是 rawBody——{@code body} 剥过注释,会把字符串里的 {@code [tag]} 一起剥掉,
* 于是"打了锚点"反而判成没锚点(扫描器 javadoc 里记着这条,别改回去)。
*/
private static Map<String, Integer> gapLedger(List<Site> sites) {
Map<String, Integer> out = new java.util.TreeMap<>();
for (Site s : sites) {
if (s.kind() == Kind.RETHROW) {
continue;
}
boolean hit = false;
for (java.util.regex.Pattern p : CATEGORY.values()) {
if (p.matcher(s.rawBody()).find()) {
hit = true;
break;
}
}
if (hit && !s.hasAnchor()) {
out.merge(s.file(), 1, Integer::sum);
}
}
return out;
}
/** 10-09 实测基线:三类里"吞掉且没有锚点"的 11 处(按文件点名)。收掉一处就往下改。 */
private static final Map<String, Integer> GAP_LEDGER = Map.ofEntries(
Map.entry("com/nanri/aiimage/modules/convert/service/ConvertRunService.java", 1),
Map.entry("com/nanri/aiimage/modules/dedupe/service/DedupeRunService.java", 2),
Map.entry("com/nanri/aiimage/modules/dedupe/service/DedupeTotalDataService.java", 1),
Map.entry("com/nanri/aiimage/modules/deletebrand/service/DeleteBrandRunService.java", 1),
Map.entry("com/nanri/aiimage/modules/deletebrand/service/DeleteBrandTaskStorageService.java", 1),
Map.entry("com/nanri/aiimage/modules/pricetrack/service/PriceTrackTaskService.java", 1),
Map.entry("com/nanri/aiimage/modules/shopmatch/service/ShopMatchTaskService.java", 1),
Map.entry("com/nanri/aiimage/modules/similarasin/service/SimilarAsinImagePrefetchService.java", 1),
Map.entry("com/nanri/aiimage/modules/similarasin/service/support/SimilarAsinPipelineSupport.java", 1),
Map.entry("com/nanri/aiimage/modules/split/service/SplitRunService.java", 1));
private static Map<String, String> readTree() {
Map<String, String> out = new LinkedHashMap<>();
try (var walk = Files.walk(TREE)) {
for (Path p : walk.filter(Files::isRegularFile)
.filter(p -> p.getFileName().toString().endsWith(".java")).sorted().toList()) {
out.put(TREE.relativize(p).toString().replace('\\', '/'),
new String(Files.readAllBytes(p), StandardCharsets.UTF_8));
}
} catch (IOException e) {
throw new UncheckedIOException(e);
}
return out;
}
private static Path moduleRoot() {
Path here = Path.of("").toAbsolutePath();
if (Files.isDirectory(here.resolve("src/main/java"))) {
return here;
}
Path nested = here.resolve("backend-java");
if (Files.isDirectory(nested.resolve("src/main/java"))) {
return nested;
}
throw new IllegalStateException("无法定位 backend-java 模块目录(cwd=" + here + ")");
}
}