fix(phase-6.1): CR-P1 撞款分页溢出钳制+B74-02 在飞登记泄漏收口

Phase 6 全量 Code Review 的后端四处(四面合计 0 个 P0 / 7 个 P1,这是其中两处,另带两处邻接纠偏):

1. `AdminShopDataDuplicateCheckController.parsePage` 补页码上限(CR-18/铁律 15 同形,
   参照 `KeywordUsageAdminService.MAX_PAGE`)。原先只钳下限:`page=11000000 / page_size=200`
   溢出成 `-2094967296`,`Math.min` 之后仍是负数,喂进 `subList(负,负)` 就是 HTTP 500——
   表里有至少一行重复数据就能打出来。这一处是 Phase 5 的 `c8cd75cf6`(B60 行窗)带进来的。
2. `ShopDataDuplicateCheckQueryService` 四处页窗统一走 `windowFrom/windowTo`:溢出发生在
   **那次乘法本身**,只钳边界的话,下一个直接调本服务的调用方(或一支新用例)能把 500
   原样请回来而没有任何尺子知道错在哪。判据 `ShopDataDuplicateCheckPageWindowTest`(5)。
   其中 `page=Integer.MIN_VALUE` 那一格是先咬到修的人自己的:草稿只在 int 上做 `page - 1`,
   MIN_VALUE 会翻成"最后一窗之后"而不是第一窗,必须先把减数升到 long。
3. `TaskResultFileJobWorker`:`markInFlight` 从 try 外挪进 try 内(心跳 executor 在容器关闭时
   `shutdownNow()`,`startJobHeartbeat` 抛 RejectedExecutionException 就跳过 finally,jobId
   永久留在在飞登记里=卡死扫描永远跳过这一行,既不失败也不完成的静默停摆)。
4. `TaskResumeService` 的双读注释纠偏:它写的是**被反向验证打回的那份草稿口径**
   ("有列读列"),留着等于把下一个人引回去把代码改成真 bug。正本口径是
   "文案判得出按文案、判不出才按列"(Phase 2 ✅ 行在册)。

尺子登记:`ShopDataDuplicateCheckPageWindowTest` 已入 ops `scripts/score_ratchet.py` 后端点名册
(不在册=闸门跑不到=等于没被执行,10-29 教训的形状)。

门禁实录:`mvn -o test-compile` rc=0;定向 `mvn -o test -Dtest=ShopDataDuplicateCheckPageWindowTest`
Tests run 5 / Failures 0 / BUILD SUCCESS;后端面无 lint、无入库格式器 ⇒ 如实登记非漏执行。

归属:本笔只圈上述 5 支文件。`modules/usersecret/**` 六支+`V188__user_secret_usage_source.sql`
+`MigratedSqlEquivalenceTest`/`migrated-statements.tsv`、以及 `useLiveTaskBoard.ts`+task-delete
三件,都是另一路会话的在飞件:未 add、未改、未评价。
This commit is contained in:
2026-11-04 02:55:11 +08:00
parent c8cd75cf6c
commit e71fa7fa83
5 changed files with 167 additions and 14 deletions
@@ -329,12 +329,22 @@ public class AdminShopDataDuplicateCheckController {
/**
* 页码上限(CR-18/铁律 15 同形,判据参照 {@code KeywordUsageAdminService.MAX_PAGE})。
* 只钳下限不够:{@code ShopDataDuplicateCheckQueryService} 四处页窗算的都是
* {@code (page - 1) * pageSize},{@code page=11000000 / page_size=200} 会溢出成负数,
* {@code Math.min(负数, total)} 仍是负数,喂给 {@code subList(负, 负)} 直接
* IndexOutOfBounds = HTTP 500(有至少一行重复数据就能触发)。钳到 10000 页 ×
* 本文件最大 page_size 200 = 200 万行,已远超实际可翻范围。
*/
private static final int MAX_PAGE = 10_000;
private static int parsePage(String page) {
if (page == null || page.isBlank()) {
return 1;
}
try {
return Math.max(1, Integer.parseInt(page.trim()));
return clamp(Integer.parseInt(page.trim()), 1, MAX_PAGE);
} catch (NumberFormatException ex) {
throw new BusinessException(400, "page 参数不合法");
}
@@ -198,14 +198,41 @@ public class ShopDataDuplicateCheckQueryService {
"total", 0, "page", page, "page_size", pageSize, "scanned_at", "");
}
/**
* 页窗下界(铁律 15 同形,判据参照 {@code KeywordUsageAdminService} 的 CR-18 注释)。
*
* <p>四处页窗原先算的都是 {@code Math.min((page - 1) * pageSize, total)}:这个乘法先于
* {@code min} 发生,{@code page=11000000 / page_size=200} 溢出成 {@code -2094967296},
* {@code min} 之后仍是负数,喂给 {@code subList(负, 负)} 就是 IndexOutOfBounds = HTTP 500
* ——只要表里有至少一行重复数据就能触发。2026-11-04 Phase 6 CR 在 {@code consoleData}
* 那处抓到(Phase 5 的 B60 行窗改的就是这一位),另外三处同形所以一起收进这里。
*
* <p>先转 {@code long} 再乘:{@code page} 传得再离谱也只会拿到空窗,不会拿到负下标。
* 控制器的 {@code parsePage} 那道钳制(上限 10000)是边界卫生,这一位是**算不坏**本身:
* 只钳边界的话,下一个直接调本服务的调用方(或一支新用例)能把 500 原样请回来,
* 而谁也看不出哪里错了。
*/
private static int windowFrom(int page, int pageSize, int total) {
// `page - 1` 本身也要在 long 上算:page=Integer.MIN_VALUE 时在 int 上会翻成
// +2147483647(="最后一窗之后"),升 long 才是"第一窗"。这一位是本支用例第 4 格
// 当场抓出来的——判据不是装饰,它先咬到了修的人自己。
long start = Math.max(0L, (long) page - 1) * Math.max(0, pageSize);
return (int) Math.min(start, total);
}
/** 页窗上界:同样先升 long,`from` 已 ≤ total,加一档 pageSize 也不越 int。 */
private static int windowTo(int from, int pageSize, int total) {
return (int) Math.min((long) from + Math.max(0, pageSize), total);
}
public Map<String, Object> itemsData(DuplicateScanView view, Set<String> visibleKeys,
int page, int pageSize, String viewMode, Filters filters) {
boolean monitor = "monitor".equals(viewMode);
List<DuplicateItem> cropped = cropItems(view.payload().items(), visibleKeys);
List<DuplicateItem> matched = filterItems(cropped, monitor, filters);
int total = matched.size();
int from = Math.min((page - 1) * pageSize, total);
int to = Math.min(from + pageSize, total);
int from = windowFrom(page, pageSize, total);
int to = windowTo(from, pageSize, total);
List<DuplicateItem> slice = matched.isEmpty() ? List.of()
: new ArrayList<>(matched.subList(from, to));
List<DuplicateShop> shops = cropShops(view.payload().shops(), visibleKeys);
@@ -219,8 +246,8 @@ public class ShopDataDuplicateCheckQueryService {
List<DuplicateItem> matched = filterItems(cropped, true, filters);
matched.sort(detailItemComparator());
int total = matched.size();
int from = Math.min((page - 1) * pageSize, total);
int to = Math.min(from + pageSize, total);
int from = windowFrom(page, pageSize, total);
int to = windowTo(from, pageSize, total);
List<Map<String, Object>> pageItems = new ArrayList<>();
for (int i = from; i < to; i++) {
pageItems.add(detailItem(matched.get(i)));
@@ -265,8 +292,8 @@ public class ShopDataDuplicateCheckQueryService {
}
rows.sort((a, b) -> ledgerCompare(a, b, key, asc));
int total = rows.size();
int from = Math.min((page - 1) * pageSize, total);
int to = Math.min(from + pageSize, total);
int from = windowFrom(page, pageSize, total);
int to = windowTo(from, pageSize, total);
List<Map<String, Object>> slice = new ArrayList<>();
for (int i = from; i < to; i++) {
slice.add(ledgerMap(rows.get(i)));
@@ -310,8 +337,8 @@ public class ShopDataDuplicateCheckQueryService {
rows.sort(Comparator.comparing((DuplicateItem item) -> safe(item.asin())));
List<Map<String, Object>> groups = groupStats(shops, filterItems(cropped, false, filters));
int total = rows.size();
int from = Math.min(Math.max(0, page - 1) * pageSize, total);
int to = Math.min(from + pageSize, total);
int from = windowFrom(page, pageSize, total);
int to = windowTo(from, pageSize, total);
List<DuplicateItem> window = rows.isEmpty() ? List.of() : new ArrayList<>(rows.subList(from, to));
return mapOf("pending", false, "scanned_at", safe(view.scannedAt()), "summary", summary,
"shops", shops, "dup", window, "groups", groups, "total_dup", total,
@@ -273,12 +273,21 @@ public class TaskResultFileJobWorker {
// (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);
// (2026-11-04 CR-P2)登记与心跳都必须在这道 try **内**起:旧形状把 markInFlight
// 放在 try 外、注销放在 finally,而 `startJobHeartbeat` 在容器关闭时会抛
// RejectedExecutionException(jobHeartbeatExecutor 已 shutdownNow)——那一跳直接绕过
// finally,把这个 jobId 永久留在在飞登记里:卡死扫描从此永远跳过这一行,
// 既不失败也不完成=静默停摆,正是下面这段注释本身要防的形状。重启进程才清得掉,
// 而"重启即空"不能当兜底——那等于把这一单无限期挂在"看起来还在跑"上。
ScheduledFuture<?> heartbeat = null;
try {
taskFileJobService.markInFlight(job.getId());
heartbeat = startJobHeartbeat(job, parentTerminalObserved);
processInternal(job);
} finally {
heartbeat.cancel(false);
if (heartbeat != null) {
heartbeat.cancel(false);
}
try {
// CR-08:心跳只负责停续期;终态判定必须等执行线程退出后再做。
// 此时若 markSuccess 已落库,finishAfterExecution 会保留 SUCCESS;
@@ -227,8 +227,12 @@ public class TaskResumeService {
continue;
}
TaskRetryEligibility.Category notRetryable =
// 双读(B51-R1):这行登记过分类就以列为准,没登记才回落到文案——自动续跑
// 是每天真在跑的判死面,不该让"某句话改了措辞"在这种地方动摇历史行的判定。
// 双读(B51-R1)定档是**文案判得出按文案、判不出才按列**,不是"有列读列"
// (2026-11-04 CR 纠正本注释:它写的正是被反向验证打回的那份草稿口径,
// 留着就是把下一个人引回去把代码改成真 bug)。实体写面
// (setErrorMessage+updateById)改文案带不动列,无条件读列=让一列**陈旧**
// 的判决判死当前这一单,比它要修的 bug 更糟;背离时逐字等于加列前的今天。
// 自动续跑是每天真在跑的判死面,更要按这条读。
TaskRetryEligibility.category(original);
if (notRetryable != null) {
stats.forceMajeureSkippedCount++;
@@ -0,0 +1,103 @@
package com.nanri.aiimage.modules.shopduplicatecheck.service;
import com.nanri.aiimage.modules.shopduplicatecheck.TestFixtures;
import com.nanri.aiimage.modules.shopduplicatecheck.mapper.ShopDuplicateCheckSourceMapper;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.util.List;
import java.util.Map;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatCode;
import static org.mockito.Mockito.mock;
/**
* 页窗算式的溢出档(铁律 15;2026-11-04 Phase 6 Code Review 的 CR-P1)。
*
* <p>病灶是 {@code Math.min((page - 1) * pageSize, total)}:乘法先于 {@code min} 发生,
* {@code page=11000000 / page_size=200} 在 int 上溢出成 {@code -2094967296},
* {@code Math.min} 之后还是负数,喂进 {@code subList(负, 负)} 就是 IndexOutOfBounds = HTTP 500。
* 表里只要有至少一行重复数据就能打出来,且四个界面入口(撞款明细/行级详情/台账/console 矩阵)
* 全是同一个形状。这条不是"深分页慢"那种性能问题,是**正确性**问题:管理员翻到最后一页
* 或者被脚本扫一遍,接口就红。
*
* <p>为什么判据打在服务而不是控制器:控制器的 {@code parsePage} 也加了上限钳制(边界卫生),
* 但溢出发生在服务里的那次乘法上——只钳边界的话,下一个直接调本服务的调用方能把 500 原样请回来,
* 而没有任何一把尺子知道错在哪。所以这里打真入口,把「算不坏」钉住。
*/
class ShopDataDuplicateCheckPageWindowTest {
/** 审计给的现网形状:这一对相乘正好跨过 Integer.MAX_VALUE。 */
private static final int OVERFLOW_PAGE = 11_000_000;
private static final int OVERFLOW_SIZE = 200;
private ShopDataDuplicateCheckQueryService service;
private ShopDataDuplicateCheckScanService.DuplicateScanView view;
private ShopDataDuplicateCheckQueryService.Filters noFilter;
@BeforeEach
void setUp() {
service = new ShopDataDuplicateCheckQueryService(mock(ShopDuplicateCheckSourceMapper.class));
view = TestFixtures.view();
noFilter = ShopDataDuplicateCheckQueryService.Filters.clean("", "", "", "", "", "");
}
@Test
void consoleMatrixWithOverflowShapedPageYieldsEmptyWindowNotHttp500() {
// 本 Phase 的 B60 行窗改的就是这一处(c8cd75cf),CR 也是在这里抓到的。
int fullTotal = (int) service.consoleData(view, null, noFilter, 1, 100, "").get("total_dup");
assertThat(fullTotal).isGreaterThan(0);
Map<String, Object> data = service.consoleData(
view, null, noFilter, OVERFLOW_PAGE, OVERFLOW_SIZE, "");
assertThat((List<?>) data.get("dup")).isEmpty();
assertThat(data.get("total_dup")).isEqualTo(fullTotal);
assertThat(data.get("page")).isEqualTo(OVERFLOW_PAGE);
}
@Test
void otherThreeWindowSitesSurviveIntegerMaxValuePage() {
for (int page : new int[]{Integer.MAX_VALUE, OVERFLOW_PAGE, 1_073_741_824}) {
assertThatCode(() -> {
assertThat((List<?>) service.itemsData(view, null, page, 200, "", noFilter).get("items"))
.isEmpty();
assertThat((List<?>) service.detailData(view, null, page, 200, noFilter).get("items"))
.isEmpty();
assertThat((List<?>) service.ledgerData(view, null, page, 200, null, null, noFilter)
.get("items")).isEmpty();
}).as("page=%s 不该把负下标喂给 subList", page).doesNotThrowAnyException();
}
}
@Test
void totalStaysTheUnpaginatedCountBeyondTheLastPage() {
// 「越界页=空窗」与「total 仍是全量」必须同时成立:把 total 跟着窗走,界面会显示"没有重复"。
int fullTotal = (int) service.itemsData(view, null, 1, 1, "", noFilter).get("total");
assertThat(service.itemsData(view, null, 999_999, 100, "", noFilter).get("total"))
.isEqualTo(fullTotal);
assertThat(service.consoleData(view, null, noFilter, 999_999, 100, "").get("total_dup"))
.isEqualTo((int) service.consoleData(view, null, noFilter, 1, 1, "").get("total_dup"));
}
@Test
void pageBelowOneFallsBackToFirstWindowInsteadOfNegativeIndex() {
for (int page : new int[]{0, -1, Integer.MIN_VALUE}) {
List<?> items = (List<?>) service.itemsData(view, null, page, 2, "", noFilter).get("items");
assertThat(items).as("page=%s 应当按第一窗读", page).isNotEmpty();
assertThat((List<?>) service.consoleData(view, null, noFilter, page, 100, "").get("dup"))
.as("page=%s 的 console 矩阵同理", page).isNotEmpty();
}
}
@Test
void middleWindowStillReturnsExactlyPageSizeRowsInOrder() {
// 反向自证:把溢出修成"整窗返回空"这种过头样子,这条会红。
List<?> first = (List<?>) service.itemsData(view, null, 1, 1, "dup", noFilter).get("items");
List<?> second = (List<?>) service.itemsData(view, null, 2, 1, "dup", noFilter).get("items");
assertThat(first).hasSize(1);
assertThat(second).hasSizeLessThanOrEqualTo(1);
assertThat(first).isNotEqualTo(second);
}
}