fix(采集数据): 心跳落库节流改按任务自身计时;空结果文件不再冒充成功

两处独立缺陷,同一场事故(task 31253:已完成 + 总进度 25% + 下载是空白):

1) lastProgressFlushMillis 是单例上的一个全局时间戳,却被用来做每支任务的心跳
   落库节流(注释里写的「任务级」是意图,不是实现)。约 20 支采集任务并跑时,
   任一任务的落库都会重置它,于是「心跳内容不变」的那支永远落在别人刚刷过的窗口
   里被丢弃,updated_at 停止前进,30 分钟陈旧巡检把还在正常回传分片的活任务判死
   ——21:52 被 stale 收尾,而客户端 20:47 还在回传第 19 个分片。计时改成读任务
   自身的 updated_at,并在每次心跳 :479 的重读上自然成立,不需要额外 catch
   (CatchSilenceRatchetTest 的口径同批核过)。

2) 结果文件组装没有任何空表守卫:明细 sheet 唯一数据源 biz_task_result_item 为
   0 行时,仍然出表(4373 字节纯表头、111ms)、上传、写 row_count=0 并把任务标成
   SUCCESS。现在写出行数与表内行数不一致、或表内 0 行而计数有行,一律抛异常让作业
   重试,宁可不给文件也不给一张空表。全部行被过滤(计数也是 0)仍是合法空结果。

3) 组装阶段重算的 finalRowCount 此前从不落库——persistStats 只改内存实体,紧随的
   唯一那条 UPDATE 不含 result_json,界面上的「保留 N 行」于是永远停在组装前的插入
   计数(31253 表里 0 行仍显示 93;对照 31300 表里 292 行计数却写 130)。补进同一条
   条件更新。
This commit is contained in:
2026-10-18 17:12:28 +08:00
parent d22a9e2164
commit e90e5e7f64
3 changed files with 178 additions and 34 deletions
@@ -4,6 +4,7 @@ import cn.hutool.core.io.FileUtil;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.modules.notification.service.NotificationDispatchService;
import com.nanri.aiimage.modules.task.mapper.FileResultMapper;
import com.nanri.aiimage.modules.task.mapper.FileTaskMapper;
@@ -25,11 +26,13 @@ import org.mockito.junit.jupiter.MockitoExtension;
import java.io.File;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.ArgumentMatchers.isNull;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@@ -49,6 +52,7 @@ class CollectDataPartialResultNoticeTest {
@Mock private FileTaskMapper fileTaskMapper;
@Mock private FileResultMapper fileResultMapper;
@Mock private com.nanri.aiimage.modules.task.mapper.TaskResultItemMapper taskResultItemMapper;
@Mock private CollectDataExcelAssemblyService excelAssemblyService;
@Mock private OssStorageService ossStorageService;
@Mock private NotificationDispatchService notificationDispatchService;
@@ -102,6 +106,8 @@ class CollectDataPartialResultNoticeTest {
when(fileTaskMapper.selectById(TASK_ID)).thenReturn(taskWithQueryFailedRows(7));
when(fileResultMapper.selectById(5001L)).thenReturn(result());
when(excelAssemblyService.writeWorkbookStreaming(any(), any(), any(), any())).thenReturn(12L);
// 空明细守卫按明细表行数校验:happy path 下表内行数与写出行数一致。
when(taskResultItemMapper.selectCount(any())).thenReturn(12L);
when(ossStorageService.uploadResultFile(any(), anyString())).thenReturn("collect-data/29991.xlsx");
// 条件更新返回 1:任务翻成成功,这条「部分缺失」通知才会推给用户
when(fileTaskMapper.update(isNull(), any())).thenReturn(1);
@@ -138,6 +144,8 @@ class CollectDataPartialResultNoticeTest {
when(fileTaskMapper.selectById(TASK_ID)).thenReturn(taskWithQueryFailedRows(7));
when(fileResultMapper.selectById(5001L)).thenReturn(result());
when(excelAssemblyService.writeWorkbookStreaming(any(), any(), any(), any())).thenReturn(12L);
// 空明细守卫按明细表行数校验:happy path 下表内行数与写出行数一致。
when(taskResultItemMapper.selectCount(any())).thenReturn(12L);
when(ossStorageService.uploadResultFile(any(), anyString())).thenReturn("collect-data/29991.xlsx");
when(fileTaskMapper.update(isNull(), any())).thenReturn(0);
@@ -146,4 +154,58 @@ class CollectDataPartialResultNoticeTest {
verify(notificationDispatchService, org.mockito.Mockito.never())
.pushPartialResult(anyLong(), anyLong(), anyString(), anyString(), anyString());
}
/** 空明细守卫:明细表有 20 行而本次只写出 12 行=静默丢行,必须让作业重试而不是出缺行文件。 */
@Test
void 明细缺行时不得上传文件并把任务标成功() {
when(fileTaskMapper.selectById(TASK_ID)).thenReturn(taskWithQueryFailedRows(0));
when(fileResultMapper.selectById(5001L)).thenReturn(result());
when(excelAssemblyService.writeWorkbookStreaming(any(), any(), any(), any())).thenReturn(12L);
when(taskResultItemMapper.selectCount(any())).thenReturn(20L);
assertThatThrownBy(() -> service.processResultFileJob(job()))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("仅写出 12 行");
verify(ossStorageService, never()).uploadResultFile(any(), anyString());
verify(fileTaskMapper, never()).update(isNull(), any());
}
/**
* 空明细守卫:task 31253 的形状——result_json 的插入计数写着 93,明细表却一行都没有,
* 于是产出一份 4373 字节的纯表头 xlsx、row_count=0,任务仍被标成「已完成」。
* 计数与唯一数据源对不上账时不许出表。
*/
@Test
void 计数有行而明细表为空时不得出空文件() {
FileTaskEntity task = taskWithQueryFailedRows(0);
task.setResultJson("{\"finalRowCount\":93}");
when(fileTaskMapper.selectById(TASK_ID)).thenReturn(task);
when(fileResultMapper.selectById(5001L)).thenReturn(result());
when(excelAssemblyService.writeWorkbookStreaming(any(), any(), any(), any())).thenReturn(0L);
when(taskResultItemMapper.selectCount(any())).thenReturn(0L);
assertThatThrownBy(() -> service.processResultFileJob(job()))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("明细表为空");
verify(ossStorageService, never()).uploadResultFile(any(), anyString());
}
/** 合法空结果:明细表 0 行且计数也是 0(全部行被过滤掉),照常出表并标成功。 */
@Test
void 全部行被过滤时空表仍合法出表() {
FileTaskEntity task = taskWithQueryFailedRows(0);
task.setResultJson("{}");
when(fileTaskMapper.selectById(TASK_ID)).thenReturn(task);
when(fileResultMapper.selectById(5001L)).thenReturn(result());
when(excelAssemblyService.writeWorkbookStreaming(any(), any(), any(), any())).thenReturn(0L);
when(taskResultItemMapper.selectCount(any())).thenReturn(0L);
when(ossStorageService.uploadResultFile(any(), anyString())).thenReturn("collect-data/29991.xlsx");
when(fileTaskMapper.update(isNull(), any())).thenReturn(1);
service.processResultFileJob(job());
verify(ossStorageService).uploadResultFile(any(), anyString());
}
}
@@ -16,6 +16,7 @@ import org.mockito.Spy;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.test.util.ReflectionTestUtils;
import java.time.LocalDateTime;
import java.util.concurrent.atomic.AtomicInteger;
import static org.assertj.core.api.Assertions.assertThat;
@@ -34,6 +35,9 @@ import static org.mockito.Mockito.when;
* (submitResult 的 done/error/普通 chunk、failTask、finalizeStaleTasks)
* 强制执行一次持久化,最终进度不丢失。persistStats 内容感知:
* 序列化结果与既有 result_json 逐字节一致时不重写,重复心跳零 UPDATE。
*
* 节流计时一律按任务自身(updated_at),不再共享服务上的全局时间戳——全局计时会被并发
* 任务互相重置,把内容不变的心跳饿死成永不落库,进而被陈旧巡检误杀(见并发回归用例)。
*/
@ExtendWith(MockitoExtension.class)
class CollectDataProgressThrottleTest {
@@ -96,9 +100,8 @@ class CollectDataProgressThrottleTest {
assertThat(task.getResultJson()).contains("\"totalRows\":10");
assertThat(task.getResultJson()).contains("\"processedRows\":1");
// 窗口到期后的心跳再次持久化(节流窗口重置)。
ReflectionTestUtils.setField(service, "lastProgressFlushMillis",
System.currentTimeMillis() - 61_000L);
// 窗口到期后的心跳再次持久化(该任务自身计时到期)。
task.setUpdatedAt(LocalDateTime.now().minusSeconds(61));
TaskHeartbeatRequest third = new TaskHeartbeatRequest();
third.setCurrent(2);
third.setTotal(10);
@@ -109,8 +112,8 @@ class CollectDataProgressThrottleTest {
@Test
void test_task_055_merge_progress_normal_multiple_items() {
// 多任务批量:节流窗口全局共享,窗口内多任务多心跳合并为 1 次落库,
// 无重复 UPDATE;窗口到期后各任务依次补写最新值,进度不丢失。
// 多任务批量:节流窗口**按任务各自计时**——每支任务在自己的窗口内合并写,
// 别人刚落库不构成把我合并掉的理由。
ReflectionTestUtils.setField(service, "progressThrottleMillis", 60_000L);
ReflectionTestUtils.setField(service, "progressDirtyWindowMillis", 60_000L);
FileTaskEntity taskA = runningTask(11L);
@@ -127,24 +130,55 @@ class CollectDataProgressThrottleTest {
heartbeat(service, 11L, 2, 10);
heartbeat(service, 12L, 2, 10);
// 窗口内 4 次 changed 心跳只落库 1 次(首条),其余合并写。
verify(fileTaskMapper, times(1)).updateById(any(FileTaskEntity.class));
// 窗口到期后:A 补写最新值,B 仍被合并。
ReflectionTestUtils.setField(service, "lastProgressFlushMillis",
System.currentTimeMillis() - 61_000L);
heartbeat(service, 11L, 3, 10);
// 每支任务首条 changed 心跳各落库 1 次,其后的窗口内心跳合并写 → 共 2 次。
verify(fileTaskMapper, times(2)).updateById(any(FileTaskEntity.class));
assertThat(taskA.getResultJson()).contains("\"processedRows\":1");
assertThat(taskB.getResultJson()).contains("\"processedRows\":1");
// A 自身窗口到期后补写最新值;B 仍在自己窗口内,继续被合并。
taskA.setUpdatedAt(LocalDateTime.now().minusSeconds(61));
heartbeat(service, 11L, 3, 10);
verify(fileTaskMapper, times(3)).updateById(any(FileTaskEntity.class));
assertThat(taskA.getResultJson()).contains("\"processedRows\":3");
// B 窗口到期后同样补写,两任务最终进度均为最新值。
ReflectionTestUtils.setField(service, "lastProgressFlushMillis",
System.currentTimeMillis() - 61_000L);
// B 自身窗口到期后同样补写,两任务最终进度均为最新值。
taskB.setUpdatedAt(LocalDateTime.now().minusSeconds(61));
heartbeat(service, 12L, 3, 10);
verify(fileTaskMapper, times(3)).updateById(any(FileTaskEntity.class));
verify(fileTaskMapper, times(4)).updateById(any(FileTaskEntity.class));
assertThat(taskB.getResultJson()).contains("\"processedRows\":3");
}
@Test
void test_task_055_并发任务不得饿死单任务的updated_at() {
// 回归 task 31253:节流计时曾是单例上的一个全局时间戳,约 20 支采集任务并跑时
// 任一任务的落库都会重置它,于是「心跳内容不变」的那支永远落在别人刚刷过的窗口里
// 被丢弃,updated_at 停止前进,30 分钟陈旧巡检把还在正常回传分片的活任务判死。
// 现在计时取任务自身:只要该任务自己的窗口到期,就必须有人替它把 updated_at 顶上去。
ReflectionTestUtils.setField(service, "progressThrottleMillis", 60_000L);
ReflectionTestUtils.setField(service, "progressDirtyWindowMillis", 30_000L);
FileTaskEntity busy = runningTask(71L); // 一直有新进度的邻居任务
FileTaskEntity stuck = runningTask(72L); // 长时间卡在一个关键词、心跳内容不变
stuck.setUpdatedAt(LocalDateTime.now().minusMinutes(20));
when(fileTaskMapper.selectById(71L)).thenReturn(busy);
when(fileTaskMapper.selectById(72L)).thenReturn(stuck);
when(taskDistributedLockService.acquire(CollectDataService.MODULE_TYPE, 71L, 5_000L))
.thenReturn(lockHandle);
when(taskDistributedLockService.acquire(CollectDataService.MODULE_TYPE, 72L, 5_000L))
.thenReturn(lockHandle);
// 邻居任务连续刷了 5 次,把「全局窗口」反复重置——旧实现正是死在这里。
for (int i = 1; i <= 5; i++) {
busy.setUpdatedAt(LocalDateTime.now().minusSeconds(61)); // 让它每次都够格落库
heartbeat(service, 71L, i, 10);
}
assertThat(busy.getUpdatedAt()).isAfter(LocalDateTime.now().minusSeconds(5));
// 内容完全相同的重复心跳,仍必须靠自身脏窗口把 updated_at 顶上去。
heartbeat(service, 72L, 2, 8);
heartbeat(service, 72L, 2, 8);
assertThat(stuck.getUpdatedAt()).isAfter(LocalDateTime.now().minusSeconds(5));
}
@Test
void test_task_055_merge_progress_normal_repeated_operation_is_idempotent() {
// 幂等:内容未变化的重复心跳不触发 UPDATE;节流窗口内合并写后
@@ -194,8 +228,7 @@ class CollectDataProgressThrottleTest {
verify(fileTaskMapper, times(1)).updateById(any(FileTaskEntity.class));
// 窗口到期后补写最新值(processedRows=4),不丢失。
ReflectionTestUtils.setField(service, "lastProgressFlushMillis",
System.currentTimeMillis() - 61_000L);
task.setUpdatedAt(LocalDateTime.now().minusSeconds(61));
heartbeat(service, 31L, 4, 21);
verify(fileTaskMapper, times(2)).updateById(any(FileTaskEntity.class));
assertThat(task.getResultJson()).contains("\"processedRows\":4");
@@ -219,8 +252,7 @@ class CollectDataProgressThrottleTest {
// 窗口内 100 次心跳只落库 1 次,无无界 UPDATE 累积;窗口到期后补写最新值。
verify(fileTaskMapper, times(1)).updateById(any(FileTaskEntity.class));
assertThat(task.getResultJson()).contains("\"processedRows\":1");
ReflectionTestUtils.setField(service, "lastProgressFlushMillis",
System.currentTimeMillis() - 61_000L);
task.setUpdatedAt(LocalDateTime.now().minusSeconds(61));
heartbeat(service, 41L, 100, 100);
verify(fileTaskMapper, times(2)).updateById(any(FileTaskEntity.class));
assertThat(task.getResultJson()).contains("\"processedRows\":100");
@@ -272,7 +304,11 @@ class CollectDataProgressThrottleTest {
.hasMessage("db down");
verify(lockHandle, times(1)).close();
// 恢复后心跳重试:窗口未到期,落库一次成功,进度持久化。
// 恢复后心跳重试:落库一次成功,进度持久化。
// 写失败时库里的 updated_at 并未前进,真实链路每条心跳都在 :479 重新 selectById,
// 读到的仍是旧值 ⇒ 会立刻补刷。本用例的 mock 复用同一个实体实例,故先把它退回
// 「库里那一版」——否则测的是对象别名,不是这条重读语义。
task.setUpdatedAt(null);
heartbeat(service, 61L, 2, 10);
verify(fileTaskMapper, times(2)).updateById(any(FileTaskEntity.class));
assertThat(task.getResultJson()).contains("\"processedRows\":2");