fix(cr2-backend): 工作台包凭据拒绝与并发幂等、会话/任务终态收口

- CR-02/05/21:confirm 前解包拒绝凭据文件、清理被拒对象;V176 版本唯一键;并发 confirm 幂等
- CR-07/08/09/10:登录世代回读再签、心跳只停续期、终态任务不被失败回调改写、告警先推送再推进基线
- CR-11:品牌 Gating 写操作限平台超管
- CR-18:关键词分页钳制 + V177 四表 DDL
- CR-20:中断恢复标志并上抛
- catch 棘轮按 9 处新增逐条点名更新基线

定向 154 例全绿(0 fail / 0 skip);V174/V175 未回改。
This commit is contained in:
2026-10-26 11:33:25 +08:00
parent 688910f738
commit b5e4c45add
24 changed files with 1206 additions and 41 deletions
@@ -260,13 +260,27 @@ public class AuthService {
return authProperties.getCookieName();
}
/** 登录推进世代;返回 0 行说明用户行已消失,不能再签发一个「世代比库还新」的令牌。 */
/**
* 登录推进世代;返回 0 行说明用户行已消失,不能再签发一个「世代比库还新」的令牌。
*
* <p>CR-07:自增用原子 UPDATE,但令牌必须按<b>回读到的库值</b>签发。两路并发登录
* 都读到 N 时,库里会被推到 N+2;若各自按内存 N+1 签,两张 token 都落后一代,
* 登录成功后第一次请求就被 session_epoch 校验打成 401。回读牺牲「两张 token 世代
* 完全相同」的极端情形,换取任何一张都不会低于库值。</p>
*/
private void advanceSessionEpoch(LoginUserEntity user) {
int updated = loginUserMapper.incrementSessionEpoch(user.getId());
if (updated != 1) {
log.warn("[auth] 登录推进会话世代失败 userId={} updated={}", user.getId(), updated);
throw new BusinessException(500, "登录状态更新失败,请重试");
}
LoginUserEntity refreshed = loginUserMapper.selectById(user.getId());
if (refreshed != null && refreshed.getSessionEpoch() != null) {
user.setSessionEpoch(refreshed.getSessionEpoch());
return;
}
// 自增已成功却回读不到(极端主从延迟/半提交):退回内存 +1 只作防御,
// 不掩盖问题——下一轮校验会按库值把 stale token 拒掉。
long current = user.getSessionEpoch() == null ? 0L : user.getSessionEpoch();
user.setSessionEpoch(current + 1);
}
@@ -1,8 +1,10 @@
package com.nanri.aiimage.modules.brandgating.controller;
import com.nanri.aiimage.common.api.ApiResponse;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.common.security.DeviceSessionPolicy;
import com.nanri.aiimage.modules.brandgating.model.dto.BrandGatingAddRequest;
import com.nanri.aiimage.modules.brandgating.model.dto.BrandGatingImportRequest;
import com.nanri.aiimage.modules.brandgating.model.dto.BrandGatingStatusRequest;
@@ -20,6 +22,7 @@ import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
@@ -40,6 +43,7 @@ import org.springframework.web.bind.annotation.RestController;
*/
@RestController
@RequiredArgsConstructor
@Slf4j
@RequestMapping("/api/admin/brand-gating")
@Tag(name = "品牌Gating库(后台)", description = "品牌Gating库的列表/筛选/统计、单条新增、启停、删除与批量导入。")
public class BrandGatingController {
@@ -79,7 +83,7 @@ public class BrandGatingController {
public ApiResponse<BrandGatingAddResultVo> add(
HttpServletRequest request,
@Valid @RequestBody BrandGatingAddRequest body) {
requireBrandGatingAccess(request);
requirePlatformSuperAdmin(request);
return ApiResponse.success(brandGatingService.add(body));
}
@@ -88,7 +92,7 @@ public class BrandGatingController {
public ApiResponse<BrandGatingDeleteResultVo> delete(
HttpServletRequest request,
@PathVariable("id") Long id) {
requireBrandGatingAccess(request);
requirePlatformSuperAdmin(request);
return ApiResponse.success(brandGatingService.delete(id));
}
@@ -98,7 +102,7 @@ public class BrandGatingController {
HttpServletRequest request,
@PathVariable("id") Long id,
@Valid @RequestBody BrandGatingStatusRequest body) {
requireBrandGatingAccess(request);
requirePlatformSuperAdmin(request);
return ApiResponse.success(brandGatingService.updateStatus(id, body.getStatus()));
}
@@ -107,13 +111,31 @@ public class BrandGatingController {
public ApiResponse<BrandGatingImportResultVo> importRows(
HttpServletRequest request,
@RequestBody BrandGatingImportRequest body) {
requireBrandGatingAccess(request);
requirePlatformSuperAdmin(request);
return ApiResponse.success(brandGatingService.importRows(body));
}
/** 逐端点把门:登录态 + 「品牌Gating库」后台菜单权限(admin_brand_gating)。 */
/** 只读端点:登录态 + 「品牌Gating库」后台菜单权限(admin_brand_gating)。 */
private void requireBrandGatingAccess(HttpServletRequest request) {
AdminUserEntity operator = adminAuthSupport.requireUser(request);
permissionMenuService.requireConsolePageAccess(operator, DENIAL_MESSAGE, PERMISSION_KEY);
}
/**
* 写端点(新增/启停/删除/批量导入):在菜单权限之上再要求平台超级管理员。
*
* <p>CR-11:{@code biz_brand_gating} 全平台共享、没有 company_id;任一公司管理员被授予
* {@code admin_brand_gating} 后就能物理删除/启停影响全平台的 gating 行。读保持原口径,
* 写收窄到平台超管(与 {@code AdminDeviceLogController.requireSuperAdmin} 同一判据)。</p>
*/
private AdminUserEntity requirePlatformSuperAdmin(HttpServletRequest request) {
AdminUserEntity operator = adminAuthSupport.requireUser(request);
permissionMenuService.requireConsolePageAccess(operator, DENIAL_MESSAGE, PERMISSION_KEY);
if (!DeviceSessionPolicy.isSuper(adminAuthSupport.currentRole(operator))) {
log.warn("[brand-gating] 非平台超管写操作被拒 userId={} username={} role={}",
operator.getId(), operator.getUsername(), adminAuthSupport.currentRole(operator));
throw new BusinessException(403, "仅平台超级管理员可以修改品牌Gating库");
}
return operator;
}
}
@@ -24,6 +24,9 @@ import java.io.InputStream;
import java.net.URI;
import java.net.URLDecoder;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.HexFormat;
@@ -351,6 +354,37 @@ public class OssStorageService {
return HexFormat.of().formatHex(digest.digest());
}
/**
* 把工作台客户端包流式落到本地临时文件,供 confirm 阶段做 zip 内容检查(CR-02)。
*
* <p>包体上限 512MB,不能整包读入内存;下载按 1MB 块流式拷贝,临时文件由调用方负责删除。
* 该方法只做传输,不做内容判定。</p>
*/
public Path downloadWorkbenchClientObjectToTempFile(String objectKey) {
requireWorkbenchClientKey(objectKey);
Path temp = null;
try {
temp = Files.createTempFile("workbench-client-package-", ".zip");
try (InputStream stream = buildClient().getObject(GetObjectArgs.builder()
.bucket(publicClientBucket())
.object(objectKey)
.build())) {
Files.copy(stream, temp, StandardCopyOption.REPLACE_EXISTING);
}
return temp;
} catch (Exception ex) {
if (temp != null) {
try {
Files.deleteIfExists(temp);
} catch (Exception cleanupFailure) {
log.warn("[oss] 清理工作台安装包临时文件失败 path={} err={}",
temp, cleanupFailure.getMessage());
}
}
throw storageFailure("download", objectKey, ex);
}
}
/** 工作台客户端包公开下载 URL:优先 download-endpoint(主机 B 反代回源),未配置回退 public-endpoint。 */
public String getWorkbenchClientDownloadUrl(String objectKey) {
requireWorkbenchClientKey(objectKey);
@@ -28,6 +28,12 @@ public class KeywordUsageAdminService {
private static final long DEFAULT_PAGE_SIZE = 15;
private static final long MAX_PAGE_SIZE = 100;
/**
* 页码上限(CR-18):三表 UNION 的深分页本身昂贵,且 {@code (page-1)*pageSize}
* 在 {@code page=Long.MAX_VALUE} 时会溢出成负数,生成 {@code LIMIT -N,15} 直接 500。
* 这里钳到安全上限;10000 页 × 100 条 = 100 万行,已远超实际可翻范围。
*/
private static final long MAX_PAGE = 10_000;
private static final List<String> BASE_COUNTRIES = List.of("英国", "德国", "法国", "西班牙", "意大利");
private final KeywordUsageAdminMapper keywordUsageAdminMapper;
@@ -100,7 +106,7 @@ public class KeywordUsageAdminService {
filter.setUser(trimToNull(user));
filter.setCountry(normalizeCountry(country));
filter.setKeyword(trimToNull(keyword));
long safePage = page == null || page < 1 ? 1 : page;
long safePage = page == null || page < 1 ? 1 : Math.min(page, MAX_PAGE);
long safeSize = pageSize == null ? DEFAULT_PAGE_SIZE : Math.min(Math.max(pageSize, 1), MAX_PAGE_SIZE);
filter.setOffset((safePage - 1) * safeSize);
filter.setLimit(safeSize);
@@ -3033,6 +3033,13 @@ public class ShopDataCrawlTaskService extends AbstractFileTaskPipeline<ShopDataC
FileTaskEntity task = fileTaskMapper.selectById(job.getTaskId());
if (task == null || !MODULE_TYPE.equals(task.getModuleType())) return;
ensureTaskOwnedByCurrentInstance(task, "fail shop data crawl result file job");
// CR-09:终态守卫。终态父任务上仍可能遗留 PENDING/RUNNING 的结果作业,
// 兜底扫描走到这里时不能把已 SUCCESS/CANCELLED/FAILED 的任务无条件改写成 FAILED。
if (isTerminalTaskStatus(task.getStatus())) {
log.info("[shop-data-crawl] skip result job failure because parent task is terminal taskId={} status={} jobId={}",
task.getId(), task.getStatus(), job.getId());
return;
}
FileResultEntity row = job.getResultId() == null ? null : fileResultMapper.selectById(job.getResultId());
if (row != null && MODULE_TYPE.equals(row.getModuleType())) markResultFailed(row, message);
List<FileResultEntity> rows = listScopeRows(job.getTaskId());
@@ -264,6 +264,11 @@ public class SimilarAsinLlmService {
for (int i = 0; i < futures.size(); i++) {
try {
merged.add(FutureDeadline.await(futures.get(i), futureDeadlineMillis(), "LLM 单行处理"));
} catch (InterruptedException ex) {
// CR-20:中断不是「这一行失败」。恢复中断标志并向上抛,不能落入下面的
// 宽泛 Exception 分支把 InterruptedException 吞掉(worker 会继续跑完剩余行)。
Thread.currentThread().interrupt();
throw new IllegalStateException("LLM 单行等待被中断", ex);
} catch (Exception ex) {
log.warn("[similar-asin][llm] row failed index={} asin={} err={}",
i, rows.get(i).getAsin(), failureMessage(ex));
@@ -206,7 +206,8 @@ public class TaskResultFileJobWorker {
processClaimedWithHeartbeat(job, claim);
}
private ScheduledFuture<?> startJobHeartbeat(TaskFileJobEntity job) {
private ScheduledFuture<?> startJobHeartbeat(TaskFileJobEntity job,
AtomicBoolean parentTerminalObserved) {
long interval = Math.max(1000L, heartbeatIntervalMillis);
AtomicBoolean terminalStopped = new AtomicBoolean(false);
return jobHeartbeatExecutor.scheduleWithFixedDelay(() -> {
@@ -216,6 +217,7 @@ public class TaskResultFileJobWorker {
try {
if (taskFileJobService.isOwningTaskTerminal(job.getTaskId())) {
if (terminalStopped.compareAndSet(false, true)) {
parentTerminalObserved.set(true);
TaskDistributedLockService.LockHandle handle = activeLockHandles.get(job.getId());
if (handle != null) {
// 良性停续期:父任务已终态,不是续期失败,不能打 renewalLost=true 造成假告警
@@ -223,9 +225,11 @@ public class TaskResultFileJobWorker {
}
// 终态后不再 touchRunning:否则 job 的 updated_at 一直被刷新,
// job 级 stuck 扫描永远看不到这行,成为不可回收的 RUNNING 遗骸。
// 判死但不打 terminal_callback_at:留给兜底扫描出部分结果,失败任务仍可下载。
taskFileJobService.markFailedPermanentAwaitingFallback(job, "父任务已终态,结果作业不再执行");
log.info("[task-file-job] parent task terminal; stopped renewal and failed job jobId={} taskId={} moduleType={} stage=TERMINAL_STOP_RENEW",
// CR-08:这里只停续期/停心跳,**不判死**。执行线程可能正在写完整结果,
// 心跳抢先把行翻成 FAILED 会让随后的 markSuccess(.eq(status,RUNNING))
// 丢掉成功状态,下一次兜底扫描立刻出部分结果。终态判定统一放到
// processClaimedWithHeartbeat 的 finally —— 执行线程退出后再看这一行。
log.info("[task-file-job] parent task terminal; stopped renewal, waiting for execution thread jobId={} taskId={} moduleType={} stage=TERMINAL_STOP_RENEW",
job.getId(), job.getTaskId(), job.getModuleType());
}
return;
@@ -250,14 +254,35 @@ public class TaskResultFileJobWorker {
job.getId(), job.getTaskId(), job.getModuleType(), claim.getUpdatedAt());
return;
}
ScheduledFuture<?> heartbeat = startJobHeartbeat(job);
AtomicBoolean parentTerminalObserved = new AtomicBoolean(false);
ScheduledFuture<?> heartbeat = startJobHeartbeat(job, parentTerminalObserved);
try {
processInternal(job);
} finally {
heartbeat.cancel(false);
// CR-08:心跳只负责停续期;终态判定必须等执行线程退出后再做。
// 此时若 markSuccess 已落库,finishAfterExecution 会保留 SUCCESS;
// 只有执行线程没写出成功状态的行才判死并留给兜底扫描出部分结果。
finishAfterExecution(job, parentTerminalObserved);
}
}
/** 执行线程退出后的终态收口:心跳期间观察到父任务终态才触发,绝不覆盖已落库的 SUCCESS。 */
void finishAfterExecution(TaskFileJobEntity job, AtomicBoolean parentTerminalObserved) {
if (job == null || !parentTerminalObserved.get()) {
return;
}
TaskFileJobEntity latest = taskFileJobService.findById(job.getId());
if (latest != null && "SUCCESS".equals(latest.getStatus())) {
log.info("[task-file-job] parent task terminal after execution but job already succeeded; keep success jobId={} taskId={} moduleType={} stage=TERMINAL_KEEP_SUCCESS",
job.getId(), job.getTaskId(), job.getModuleType());
return;
}
taskFileJobService.markFailedPermanentAwaitingFallback(job, "父任务已终态,结果作业不再执行");
log.info("[task-file-job] parent task terminal after execution; failed job for fallback jobId={} taskId={} moduleType={} stage=TERMINAL_AFTER_EXECUTION",
job.getId(), job.getTaskId(), job.getModuleType());
}
private void processInternal(TaskFileJobEntity job) {
long startedAt = System.currentTimeMillis();
try {
@@ -162,15 +162,31 @@ public class CostGuardScheduler {
} else if (crossed(before.proxy, platform.proxy, threshold)) {
reason = platformReason(platform.proxy, threshold);
}
baselineStore.put(PLATFORM_USER_ID, new CostGuardBaselineStore.Baseline(
platform.proxy, platform.llmCalls, platform.llmTokens, nowMillis));
if (reason == null) {
baselineStore.put(PLATFORM_USER_ID, new CostGuardBaselineStore.Baseline(
platform.proxy, platform.llmCalls, platform.llmTokens, nowMillis));
return;
}
int pushed = notificationDispatchService.pushToAdmins(NotificationService.SCENE_COST_GUARD,
NotificationService.LEVEL_WARNING, "平台自费代理提取超告警线",
reason + "。这笔消耗没有归属账号、不能自动暂停,请检查 cookie 生成器 / 平台兜底池的提取链接档位。",
"cost_guard_platform_proxy:" + LocalDate.now(), null);
// CR-10:告警先推送成功、再推进基线。先 put 后 push 时,推送抛异常/返回 0
// 会让当天基线已越过阈值,下一轮 crossed 不再成立,告警永久丢失。
int pushed;
try {
pushed = notificationDispatchService.pushToAdmins(NotificationService.SCENE_COST_GUARD,
NotificationService.LEVEL_WARNING, "平台自费代理提取超告警线",
reason + "。这笔消耗没有归属账号、不能自动暂停,请检查 cookie 生成器 / 平台兜底池的提取链接档位。",
"cost_guard_platform_proxy:" + LocalDate.now(), null);
} catch (RuntimeException ex) {
log.warn("[cost-guard] 平台自费告警推送失败,本轮不推进基线待下轮重试 次数={} 阈值={} err={}",
platform.proxy, threshold, ex.getMessage());
return;
}
if (pushed <= 0) {
log.warn("[cost-guard] 平台自费告警没有落库到任何管理员,本轮不推进基线待下轮重试 次数={} 阈值={}",
platform.proxy, threshold);
return;
}
baselineStore.put(PLATFORM_USER_ID, new CostGuardBaselineStore.Baseline(
platform.proxy, platform.llmCalls, platform.llmTokens, nowMillis));
log.warn("[cost-guard] 平台自费代理提取告警 次数={} 阈值={} 管理员落库={}",
platform.proxy, threshold, pushed);
}
@@ -8,12 +8,17 @@ import com.nanri.aiimage.modules.workbenchclient.model.entity.WorkbenchClientPac
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.dao.DuplicateKeyException;
import org.springframework.stereotype.Service;
import java.io.IOException;
import java.math.BigInteger;
import java.nio.file.Files;
import java.nio.file.Path;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
@@ -22,6 +27,8 @@ import java.util.Map;
import java.util.Set;
import java.util.UUID;
import java.util.regex.Pattern;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
/**
* 数富AI工作台客户端安装/更新包管理。
@@ -48,6 +55,24 @@ public class WorkbenchClientPackageService {
/** 直传预签名默认有效期:90MB 级包在慢公网入口上传时,3 分钟窗口会在途过期。 */
private static final int DEFAULT_PRESIGN_EXPIRY_SECONDS = 3600;
/**
* 安装包内禁止出现的凭据文件基名(大小写不敏感)。
*
* <p>CR-02:工作台安装包是免登录公开下载的,包内一旦带 {@code kw_share_cfg.json}
* 这类文件就等于把 API 口令连同下载链接一起公开。此清单只做发布前硬拒绝,
* 真实凭据轮换由工作台客户端仓库完成(本仓不打包它)。</p>
*/
private static final Set<String> FORBIDDEN_CREDENTIAL_NAMES = Set.of(
"kw_share_cfg.json", ".env", ".netrc", ".git-credentials",
"id_rsa", "id_dsa", "id_ecdsa", "id_ed25519");
/** 凭据类后缀:私钥/证书/密钥库,命中任意一个即拒绝。 */
private static final List<String> FORBIDDEN_CREDENTIAL_SUFFIXES =
List.of(".pem", ".key", ".p12", ".pfx", ".jks", ".keystore");
/** zip 条目数上限:只读中央目录,但仍要防病态包把 confirm 拖成分钟级。 */
private static final int MAX_ZIP_ENTRIES = 200_000;
/** 允许配置覆盖;上下限防止误配成 0 或过长窗口。 */
@Value("${aiimage.workbench-client.presign-expiry-seconds:3600}")
private int presignExpirySeconds = DEFAULT_PRESIGN_EXPIRY_SECONDS;
@@ -131,6 +156,10 @@ public class WorkbenchClientPackageService {
* 签发直传预签名:对象 key 由「毫秒时间戳 + 随机 UUID + 安全版本号」组成。
* UUID 是 CR-08 的修复点:只靠毫秒时间戳时,多实例时钟相同或同毫秒两名管理员
* 上传同一版本会生成同一个 key,后一次 PUT 覆盖前一次对象、先确认的 DB 行摘要失效。
*
* <p>CR-21:返回的上传 URL 视为<b>一次性凭据</b>——任何拿到它的人都能在 TTL 内写对象。
* 3600 秒是覆盖慢公网 90MB 级包上传的最小必要窗口,只存在响应体里,
* <b>不得写入日志、审计文本或异常信息</b>;确认完成后即失效,不提供续签。</p>
*/
public Map<String, Object> presignPackage(String fileName, String version) {
String normalizedName = requireZipFileName(fileName);
@@ -155,6 +184,11 @@ public class WorkbenchClientPackageService {
/**
* 直传确认:校验对象存在、大小上限、版本号与对象名一致,服务端复算 sha256 后落库。
* <p>sha256 为空或长度不对直接拒绝——宁可让管理员重传,也不让客户端拿到没有锚点的包。
* <p>CR-02:落库前把对象流式落到临时文件、用 {@link ZipFile} 只读扫描条目名;
* 包内出现 {@code kw_share_cfg.json}、{@code .env}、{@code *.pem}、{@code *.key}
* 等凭据文件即拒绝并清理已上传对象,避免公开桶里出现带口令的安装包。
* <p>CR-05:同 objectKey 并发 confirm 幂等返回已登记行;同 version 不同 objectKey
* 由数据库唯一键 {@code uk_workbench_client_version} 兜底,冲突时清理对象并返回业务错误。
*/
public Map<String, Object> confirmPackage(String objectKey, String fileName, String version) {
if (objectKey == null || !objectKey.startsWith(OBJECT_KEY_PREFIX)) {
@@ -170,10 +204,7 @@ public class WorkbenchClientPackageService {
throw new BusinessException("版本号与上传对象不匹配,请重新上传");
}
// 幂等:重复 confirm 同一对象返回已登记行,不再报错(CR-08)
WorkbenchClientPackageEntity existing = packageMapper.selectOne(
new LambdaQueryWrapper<WorkbenchClientPackageEntity>()
.eq(WorkbenchClientPackageEntity::getObjectKey, objectKey)
.last("LIMIT 1"));
WorkbenchClientPackageEntity existing = findByObjectKey(objectKey);
if (existing != null) {
log.info("[workbench-client] 直传确认幂等命中 id={} objectKey={}", existing.getId(), objectKey);
return toItemMap(existing);
@@ -197,9 +228,11 @@ public class WorkbenchClientPackageService {
Long sameVersion = packageMapper.selectCount(new LambdaQueryWrapper<WorkbenchClientPackageEntity>()
.eq(WorkbenchClientPackageEntity::getVersion, normalizedVersion));
if (sameVersion != null && sameVersion > 0) {
// 同版本不同字节会让已升级的装机按版本号比较后不升级,客户端还会拿到错误摘要
// 同版本不同字节会让已升级的装机按版本号比较后不升级,客户端还会拿到错误摘要。
// 拒绝时必须清理对象:512MB 级残留留在公开桶可被反复触发耗存储(CR-05)。
log.warn("[workbench-client] 直传确认失败:版本已存在 version={} objectKey={}",
normalizedVersion, objectKey);
removeRejectedObject(objectKey);
throw new BusinessException("该版本已存在,请提升版本号或先删除旧包");
}
WorkbenchClientPackageEntity latest = newest();
@@ -207,8 +240,11 @@ public class WorkbenchClientPackageService {
// 按上传时间取最新时,低版本后传会顶掉当前更新目标,已升级装机反而被判"无需更新"
log.warn("[workbench-client] 直传确认失败:版本低于当前最新 version={} latest={} objectKey={}",
normalizedVersion, latest.getVersion(), objectKey);
removeRejectedObject(objectKey);
throw new BusinessException("版本号不能低于当前最新版本 " + latest.getVersion());
}
// 内容检查排在版本/大小之后:先做便宜判定,避免为大包白下载一遍
rejectCredentialFiles(objectKey);
String sha256 = ossStorageService.workbenchClientObjectSha256(objectKey);
if (sha256 == null || sha256.length() != 64) {
log.warn("[workbench-client] 直传确认失败:摘要计算异常 objectKey={} sha256={}", objectKey, sha256);
@@ -221,13 +257,124 @@ public class WorkbenchClientPackageService {
entity.setObjectKey(objectKey);
entity.setFileSize(size);
entity.setSha256(sha256);
packageMapper.insert(entity);
try {
packageMapper.insert(entity);
} catch (DuplicateKeyException duplicate) {
// 同 objectKey 并发 confirm:另一线程已登记,按幂等返回(CR-05)
WorkbenchClientPackageEntity concurrent = findByObjectKey(objectKey);
if (concurrent != null) {
log.info("[workbench-client] 并发直传确认幂等命中 id={} objectKey={}",
concurrent.getId(), objectKey);
return toItemMap(concurrent);
}
// 同 version 不同 objectKey:唯一键 uk_workbench_client_version 拦下后一行
log.warn("[workbench-client] 直传确认失败:版本并发冲突 version={} objectKey={}",
normalizedVersion, objectKey);
removeRejectedObject(objectKey);
throw new BusinessException("该版本已存在,请提升版本号或先删除旧包");
}
log.info("[workbench-client] 客户端包登记成功 id={} version={} fileName={} bytes={} sha256={}",
entity.getId(), normalizedVersion, normalizedName, size, sha256);
WorkbenchClientPackageEntity saved = packageMapper.selectById(entity.getId());
return toItemMap(saved == null ? entity : saved);
}
private WorkbenchClientPackageEntity findByObjectKey(String objectKey) {
return packageMapper.selectOne(new LambdaQueryWrapper<WorkbenchClientPackageEntity>()
.eq(WorkbenchClientPackageEntity::getObjectKey, objectKey)
.last("LIMIT 1"));
}
/**
* 发布前内容检查:把对象流式落到临时文件,只读扫描 zip 条目名。
*
* <p>不整包读入内存、不解压内容;{@link ZipFile} 只读中央目录。命中凭据文件或
* 非法 zip 时删除已上传对象,确保公开桶里不会留下不可登记的大对象。</p>
*/
private void rejectCredentialFiles(String objectKey) {
Path packageFile = ossStorageService.downloadWorkbenchClientObjectToTempFile(objectKey);
try (ZipFile zipFile = new ZipFile(packageFile.toFile())) {
Enumeration<? extends ZipEntry> entries = zipFile.entries();
int scanned = 0;
while (entries.hasMoreElements()) {
ZipEntry entry = entries.nextElement();
if (++scanned > MAX_ZIP_ENTRIES) {
log.warn("[workbench-client] 直传确认拒绝:zip 条目数超限 objectKey={} limit={}",
objectKey, MAX_ZIP_ENTRIES);
removeRejectedObject(objectKey);
throw new BusinessException("安装包内文件条目过多,请重新打包上传");
}
if (entry.isDirectory()) {
continue;
}
String baseName = baseName(entry.getName());
if (isCredentialFileName(baseName)) {
log.warn("[workbench-client] 直传确认拒绝:安装包含凭据文件 objectKey={} entry={}",
objectKey, entry.getName());
removeRejectedObject(objectKey);
throw new BusinessException("安装包内含凭据配置文件(" + baseName
+ "),禁止发布,请移除后重新打包上传");
}
}
} catch (BusinessException ex) {
throw ex;
} catch (IOException ex) {
log.warn("[workbench-client] 直传确认失败:安装包不是有效 zip objectKey={} err={}",
objectKey, ex.getMessage());
removeRejectedObject(objectKey);
throw new BusinessException("上传的安装包不是有效的 zip 文件,请重新打包上传");
} finally {
deleteTempQuietly(packageFile);
}
}
private static String baseName(String entryName) {
if (entryName == null) {
return "";
}
String normalized = entryName.replace('\\', '/');
int slash = normalized.lastIndexOf('/');
return slash < 0 ? normalized : normalized.substring(slash + 1);
}
private static boolean isCredentialFileName(String fileName) {
String lower = fileName == null ? "" : fileName.trim().toLowerCase(Locale.ROOT);
if (lower.isEmpty()) {
return false;
}
if (FORBIDDEN_CREDENTIAL_NAMES.contains(lower) || lower.startsWith(".env.")) {
return true;
}
for (String suffix : FORBIDDEN_CREDENTIAL_SUFFIXES) {
if (lower.endsWith(suffix)) {
return true;
}
}
return false;
}
/** 拒绝分支统一清对象;清理失败只告警,不让业务错误被存储异常盖掉。 */
private void removeRejectedObject(String objectKey) {
try {
ossStorageService.removeWorkbenchClientObject(objectKey);
} catch (RuntimeException ex) {
log.warn("[workbench-client] 清理被拒安装包对象失败 objectKey={} err={}",
objectKey, ex.getMessage());
}
}
private void deleteTempQuietly(Path packageFile) {
if (packageFile == null) {
return;
}
try {
Files.deleteIfExists(packageFile);
} catch (IOException ex) {
log.warn("[workbench-client] 删除安装包临时文件失败 path={} err={}",
packageFile, ex.getMessage());
}
}
/**
* 按 id 批量删除记录;MinIO 对象仅在删除后无任何剩余记录引用时才清除。
* <p>最新包被删后,客户端下次检查自动回落到上一版(按上传时间取最新)。
@@ -0,0 +1,23 @@
-- =============================================================
-- 迁移 V176__workbench_client_package_version_unique
-- 立账:ops 仓 docs/audit/CODE_REVIEW_REPORT.md CR-05(2026-10-26)
--
-- 1. 变更目的:给「数富AI工作台客户端包」的版本号加唯一约束。
-- confirmPackage 原实现是 SELECT COUNT(version) 再 INSERT,两步之间无数据库
-- 约束保护:两名管理员并发确认同一版本、不同 objectKey 时,两次 count 都读到 0,
-- 最终落两行同 version、不同 sha256 的记录,客户端会拿到错误的完整性锚点。
--
-- 2. 口径:
-- - 唯一键名 uk_workbench_client_version,列 version;
-- - objectKey 已有 uk_workbench_client_object_key(V167),两把唯一键各守一条
-- 并发路径:同对象幂等、同版本拒绝;
-- - 线上只读核验(2026-10-26):当前 7 行、7 个不同 version,无重复,可安全加键。
--
-- 3. 影响表与数据量:biz_workbench_client_package 加一把唯一索引;表为 KB 级字典表。
--
-- 4. 回滚(如需):ALTER TABLE `biz_workbench_client_package`
-- DROP INDEX `uk_workbench_client_version`;
-- =============================================================
ALTER TABLE `biz_workbench_client_package`
ADD UNIQUE KEY `uk_workbench_client_version` (`version`);
@@ -0,0 +1,79 @@
-- =============================================================
-- 迁移 V177__keyword_usage_tables
-- 立账:ops 仓 docs/audit/CODE_REVIEW_REPORT.md CR-18(2026-10-26)
--
-- 1. 变更目的:给「关键词使用记录」依赖的四张表补 Flyway DDL。
-- keyword_usage / keyword_add_log / keyword_delete_log / keyword_share 在现网主库
-- 早已存在(桌面 Tkinter 工具与 web 版共用),此前没有入库的建表脚本;新环境首次
-- 打开管理后台会因表缺失直接 500。本迁移只服务新环境,线上四表已存在。
--
-- 2. 口径:
-- - 一律 CREATE TABLE IF NOT EXISTS,线上重跑逐条 no-op;
-- - 字段按 KeywordUsageAdminMapper.xml / KeywordShareMapper.xml 与
-- KeywordUsageEntity / KeywordAddLogEntity / KeywordDeleteLogEntity /
-- KeywordShareEntity 逐列核对,不臆造业务列;
-- - keyword_share 与 keyword_usage 的 uk_comp_cw(company_id, country, keyword)
-- 是既有 UPSERT(ON DUPLICATE KEY UPDATE)与删除/标记语义的依赖键,必须一并建;
-- - keyword_delete_log 只留痕,不建唯一键(同一词可被反复添加/删除)。
--
-- 3. 影响表与数据量:新环境建 4 张空表;已有环境 4 条 no-op。
--
-- 4. 回滚(如需,按依赖顺序):
-- DROP TABLE IF EXISTS `keyword_usage`;
-- DROP TABLE IF EXISTS `keyword_add_log`;
-- DROP TABLE IF EXISTS `keyword_delete_log`;
-- DROP TABLE IF EXISTS `keyword_share`;
-- =============================================================
CREATE TABLE IF NOT EXISTS `keyword_share` (
`id` BIGINT NOT NULL AUTO_INCREMENT,
`country` VARCHAR(32) NOT NULL COMMENT '国家(英国/德国/法国/西班牙/意大利等)',
`keyword` VARCHAR(255) NOT NULL COMMENT '关键词',
`chinese` VARCHAR(255) DEFAULT NULL COMMENT '中文释义',
`ktype` VARCHAR(64) DEFAULT NULL COMMENT '关键词类型',
`source` VARCHAR(64) DEFAULT NULL COMMENT '来源',
`category` VARCHAR(128) DEFAULT NULL COMMENT '一级类目',
`sub_category` VARCHAR(128) DEFAULT NULL COMMENT '二级类目',
`category_l3` VARCHAR(128) DEFAULT NULL COMMENT '三级类目',
`category_l4` VARCHAR(128) DEFAULT NULL COMMENT '四级类目',
`user_name` VARCHAR(128) NOT NULL DEFAULT '' COMMENT '添加人',
`add_time` DATETIME DEFAULT NULL COMMENT '添加时间',
`company_id` BIGINT NOT NULL DEFAULT 1 COMMENT '公司隔离键',
PRIMARY KEY (`id`),
UNIQUE KEY `uk_comp_cw` (`company_id`, `country`, `keyword`),
KEY `idx_keyword_share_company_category` (`company_id`, `category`, `sub_category`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='五国关键词共享-词本体';
CREATE TABLE IF NOT EXISTS `keyword_usage` (
`id` BIGINT NOT NULL AUTO_INCREMENT,
`country` VARCHAR(32) NOT NULL COMMENT '国家',
`keyword` VARCHAR(255) NOT NULL COMMENT '关键词',
`user_name` VARCHAR(128) NOT NULL DEFAULT '' COMMENT '使用者',
`used_time` DATETIME DEFAULT NULL COMMENT '最近使用时间',
`company_id` BIGINT NOT NULL DEFAULT 1 COMMENT '公司隔离键',
PRIMARY KEY (`id`),
UNIQUE KEY `uk_comp_cw` (`company_id`, `country`, `keyword`),
KEY `idx_keyword_usage_company_time` (`company_id`, `used_time`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='五国关键词共享-使用状态';
CREATE TABLE IF NOT EXISTS `keyword_add_log` (
`id` BIGINT NOT NULL AUTO_INCREMENT,
`country` VARCHAR(32) NOT NULL COMMENT '国家',
`keyword` VARCHAR(255) NOT NULL COMMENT '关键词',
`user_name` VARCHAR(128) NOT NULL DEFAULT '' COMMENT '添加人',
`add_time` DATETIME DEFAULT NULL COMMENT '添加时间',
`company_id` BIGINT NOT NULL DEFAULT 1 COMMENT '公司隔离键',
PRIMARY KEY (`id`),
KEY `idx_keyword_add_log_company_time` (`company_id`, `add_time`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='五国关键词共享-添加留痕';
CREATE TABLE IF NOT EXISTS `keyword_delete_log` (
`id` BIGINT NOT NULL AUTO_INCREMENT,
`country` VARCHAR(32) NOT NULL COMMENT '国家',
`keyword` VARCHAR(255) NOT NULL COMMENT '关键词',
`user_name` VARCHAR(128) NOT NULL DEFAULT '' COMMENT '删除人',
`delete_time` DATETIME DEFAULT NULL COMMENT '删除时间',
`company_id` BIGINT NOT NULL DEFAULT 1 COMMENT '公司隔离键',
PRIMARY KEY (`id`),
KEY `idx_keyword_delete_log_company_time` (`company_id`, `delete_time`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='五国关键词共享-删除留痕';
@@ -49,8 +49,9 @@ class CatchSilenceRatchetTest {
// 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;
static final int GIVEN_NOT_RETHROW = 569;
static final int GIVEN_NOT_RETHROW = 573;
static final int GIVEN_LOG_ONLY = 249;
static final int GIVEN_EMPTY = 56;
@@ -120,8 +121,28 @@ class CatchSilenceRatchetTest {
* 逐行链路的缓存,缺结果的行会走单行回退,所以等待侧超时不需要炸掉整条任务。</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。
*/
static final int STRICT_TOTAL = 1015;
static final int STRICT_TOTAL = 1024;
/**
* 重抛型 catch 的**下限**(不是上限):本轮把两处吞异常改成重抛之后实测 388。
* 这一格只能涨不能跌——它是"异常会往外走"的总量,把它钉成"只许减"就等于拦着别人修吞异常。
@@ -207,8 +228,14 @@ class CatchSilenceRatchetTest {
* {@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,保留基线待下轮重试)。
* 四处的误差方向都是「不让清理/告警失败掩盖主错误」,不是把异常静默吞掉。
*/
static final int STRICT_NOT_RETHROW = 569;
static final int STRICT_NOT_RETHROW = 573;
/**
* 10-17 抬 172 -> 173,出处就是上面点名过的 {@code TaskHeartbeatLivenessService.stamp()}:
* 块体只有「取到 key 名 + log.warn」一句,写心跳证据失败时既不重试也不抛出——
@@ -221,8 +248,11 @@ class CatchSilenceRatchetTest {
* 两个超时出口之一(两处形状相同,其中一处按块内语句判定落进本格,另一处因复位中断位
* 多一条语句只进 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 锚点;主错误由外层重抛,清理失败不得盖掉它。
*/
static final int STRICT_LOG_ONLY = 176; // 严格口径:块内每条顶层语句都是 log 调用才算
static final int STRICT_LOG_ONLY = 179; // 严格口径:块内每条顶层语句都是 log 调用才算
static final int STRICT_EMPTY = 56;
/**
@@ -0,0 +1,43 @@
package com.nanri.aiimage.config;
import org.junit.jupiter.api.Test;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.List;
import java.util.stream.Stream;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
/** CR-18:V177 给关键词使用记录四张表补新环境可用的 Flyway DDL。 */
class KeywordUsageTablesMigrationV177Test {
private static final Path DB_DIR =
Path.of(System.getProperty("user.dir"), "src/main/resources/db");
private static Path migration() throws IOException {
try (Stream<Path> files = Files.list(DB_DIR)) {
List<Path> hits = files
.filter(p -> p.getFileName().toString().startsWith("V177__"))
.toList();
assertEquals(1, hits.size(), "V177 必须恰好一个迁移文件");
return hits.get(0);
}
}
@Test
void createsAllFourKeywordTablesIdempotently() throws IOException {
String sql = Files.readString(migration());
assertTrue(sql.contains("迁移 V177__keyword_usage_tables"), "头注释版本必须与文件名一致");
for (String table : List.of("keyword_usage", "keyword_add_log", "keyword_delete_log", "keyword_share")) {
assertTrue(sql.contains("CREATE TABLE IF NOT EXISTS `" + table + "`"),
"缺少新环境建表(必须 IF NOT EXISTS,线上已存在): " + table);
}
assertTrue(sql.contains("UNIQUE KEY `uk_comp_cw` (`company_id`, `country`, `keyword`)"),
"keyword_share/keyword_usage 的 UPSERT 依赖 (company_id,country,keyword) 唯一键");
assertTrue(sql.contains("`company_id` BIGINT NOT NULL DEFAULT 1"),
"四张表都必须带公司隔离键");
}
}
@@ -103,7 +103,8 @@ class TaskResultFileJobWorkerLogAuditTest {
// 2026-10-24 B28:父任务终态后不再领取/执行/续期,三条出口各有一个阶段字面量。
List<String> allowed = List.of("SKIP_OWNER", "REQUEUE", "WAIT_LLM", "DEFER", "SUCCESS",
"SUCCESS_LOST", "ORPHAN", "FAILED", "FINALIZE", "HEARTBEAT", "FALLBACK",
"TERMINAL_SKIP", "TERMINAL_AFTER_LOCK", "TERMINAL_STOP_RENEW");
"TERMINAL_SKIP", "TERMINAL_AFTER_LOCK", "TERMINAL_STOP_RENEW",
"TERMINAL_KEEP_SUCCESS", "TERMINAL_AFTER_EXECUTION");
for (String l : perJob) {
if (l.contains("stage=")) {
int idx = l.indexOf("stage=");
@@ -0,0 +1,40 @@
package com.nanri.aiimage.config;
import org.junit.jupiter.api.Test;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.List;
import java.util.stream.Stream;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
/** CR-05:V176 用数据库唯一键兜住「同 version 不同 objectKey」的并发登记。 */
class WorkbenchClientPackageVersionUniqueMigrationV176Test {
private static final Path DB_DIR =
Path.of(System.getProperty("user.dir"), "src/main/resources/db");
private static Path migration() throws IOException {
try (Stream<Path> files = Files.list(DB_DIR)) {
List<Path> hits = files
.filter(p -> p.getFileName().toString().startsWith("V176__"))
.toList();
assertEquals(1, hits.size(), "V176 必须恰好一个迁移文件");
return hits.get(0);
}
}
@Test
void addsUniqueKeyOnVersionWithoutTouchingAppliedMigrations() throws IOException {
String sql = Files.readString(migration());
assertTrue(sql.contains("迁移 V176__workbench_client_package_version_unique"),
"头注释版本必须与文件名一致");
assertTrue(sql.contains("ALTER TABLE `biz_workbench_client_package`"),
"只在客户端包表上加键");
assertTrue(sql.contains("ADD UNIQUE KEY `uk_workbench_client_version` (`version`)"),
"同版本并发登记必须由数据库唯一键兜底");
}
}
@@ -106,6 +106,30 @@ class AuthServiceTest {
// ---------- check_login:被顶下线必须拦截且不续期 ----------
@Test
void loginSignsTokenWithSessionEpochReadBackFromDatabase() {
// CR-07:并发登录时库里的世代可能已被另一路推到 N+2;内存 +1 会签出 stale token,
// 登录成功后第一次请求立刻 401。令牌必须用自增后回读到的库值。
Fixture f = fixture(true);
LoginUserEntity user = f.user("devA");
user.setSessionEpoch(0L);
LoginUserEntity refreshed = f.user("devA");
refreshed.setSessionEpoch(41L);
when(f.loginUserMapper.selectOne(any())).thenReturn(user);
when(f.loginUserMapper.selectById(7L)).thenReturn(refreshed);
when(f.passwordEncoder.matches("pwd", "hash")).thenReturn(true);
when(f.jwtService.issue(eq(7L), anyString(), anyString(), anyLong())).thenReturn("jwt-token");
LoginRequest request = new LoginRequest();
request.setUsername("u7");
request.setPassword("pwd");
request.setDeviceId("devB");
f.service.login(request);
verify(f.jwtService).issue(7L, "u7", "devB", 41L);
}
@Test
void checkLoginRejectsSupersededDeviceWithoutRenewal() {
Fixture f = fixture(true);
@@ -0,0 +1,109 @@
package com.nanri.aiimage.modules.brandgating.controller;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.modules.brandgating.model.dto.BrandGatingAddRequest;
import com.nanri.aiimage.modules.brandgating.model.dto.BrandGatingImportRequest;
import com.nanri.aiimage.modules.brandgating.model.dto.BrandGatingStatusRequest;
import com.nanri.aiimage.modules.brandgating.model.vo.BrandGatingPageVo;
import com.nanri.aiimage.modules.brandgating.service.BrandGatingService;
import com.nanri.aiimage.modules.permission.service.PermissionMenuService;
import jakarta.servlet.http.HttpServletRequest;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
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.eq;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
* CR-11:{@code biz_brand_gating} 全平台共享,写操作只允许平台超级管理员;
* 公司管理员(即使持有 admin_brand_gating 菜单)只能读。
*/
@ExtendWith(MockitoExtension.class)
class BrandGatingControllerTest {
@Mock private BrandGatingService brandGatingService;
@Mock private AdminAuthSupport adminAuthSupport;
@Mock private PermissionMenuService permissionMenuService;
@Mock private HttpServletRequest request;
private BrandGatingController controller;
private AdminUserEntity companyAdmin;
private AdminUserEntity platformSuperAdmin;
@BeforeEach
void setUp() {
controller = new BrandGatingController(brandGatingService, adminAuthSupport, permissionMenuService);
companyAdmin = user(51L, "company-admin", "company_super_admin");
platformSuperAdmin = user(1L, "root", "super_admin");
when(adminAuthSupport.requireUser(request)).thenReturn(companyAdmin);
}
@Test
@DisplayName("公司管理员写操作全部 403:新增/删除/启停/批量导入都不触碰业务层")
void companyAdminCannotWrite() {
when(adminAuthSupport.currentRole(companyAdmin)).thenReturn("company_super_admin");
BrandGatingStatusRequest status = new BrandGatingStatusRequest();
status.setStatus(1);
assertForbidden(() -> controller.add(request, new BrandGatingAddRequest()));
assertForbidden(() -> controller.delete(request, 9L));
assertForbidden(() -> controller.updateStatus(request, 9L, status));
assertForbidden(() -> controller.importRows(request, new BrandGatingImportRequest()));
verify(brandGatingService, never()).add(any());
verify(brandGatingService, never()).delete(any());
verify(brandGatingService, never()).updateStatus(any(), any());
verify(brandGatingService, never()).importRows(any());
}
@Test
@DisplayName("只读查询不受影响:公司管理员有 admin_brand_gating 菜单即可分页")
void companyAdminStillReads() {
when(brandGatingService.page(any(), any(), any(), any(), any(), any(), any()))
.thenReturn(new BrandGatingPageVo());
controller.page(request, null, null, null, null, null, 1L, 10L);
verify(permissionMenuService).requireConsolePageAccess(
eq(companyAdmin), any(), eq("admin_brand_gating"));
verify(brandGatingService).page(any(), any(), any(), any(), any(), any(), any());
}
@Test
@DisplayName("平台超管写操作放行")
void superAdminCanWrite() {
when(adminAuthSupport.requireUser(request)).thenReturn(platformSuperAdmin);
when(adminAuthSupport.currentRole(platformSuperAdmin)).thenReturn("super_admin");
BrandGatingAddRequest body = new BrandGatingAddRequest();
controller.add(request, body);
verify(brandGatingService).add(body);
}
private static void assertForbidden(org.junit.jupiter.api.function.Executable action) {
assertThatThrownBy(action::execute)
.isInstanceOf(BusinessException.class)
.satisfies(ex -> assertThat(((BusinessException) ex).getCode()).isEqualTo(403));
}
private static AdminUserEntity user(long id, String username, String role) {
AdminUserEntity user = new AdminUserEntity();
user.setId(id);
user.setUsername(username);
user.setRole(role);
user.setIsAdmin(1);
return user;
}
}
@@ -464,16 +464,20 @@ class BrandGatingServiceTest {
}
@Test
@DisplayName("控制器契约:独立菜单用 admin_brand_gating 权限键、逐端点 requireUser + requireConsolePageAccess 把门")
void controllerGatesEveryEndpointWithPermissionKey() throws Exception {
@DisplayName("控制器契约:读用 admin_brand_gating 菜单权限,写再收窄到平台超管(CR-11)")
void controllerGatesReadsWithMenuAndWritesWithPlatformSuperAdmin() throws Exception {
String source = Files.readString(Path.of(
"src/main/java/com/nanri/aiimage/modules/brandgating/controller/BrandGatingController.java"),
StandardCharsets.UTF_8);
assertThat(source).contains("PERMISSION_KEY = \"admin_brand_gating\"");
assertThat(source).contains("adminAuthSupport.requireUser(request)");
assertThat(source).contains("requireConsolePageAccess(operator, DENIAL_MESSAGE, PERMISSION_KEY)");
// 6 个端点方法都必须先过把门助手
long gated = source.split("requireBrandGatingAccess\\(request\\);", -1).length - 1;
assertThat(gated).isEqualTo(6);
// 2 个只读端点(page/stats)继续走菜单权限
long readGated = source.split("requireBrandGatingAccess\\(request\\);", -1).length - 1;
assertThat(readGated).isEqualTo(2);
// 4 个写端点(add/delete/status/import)叠加平台超管闸门
long writeGated = source.split("requirePlatformSuperAdmin\\(request\\);", -1).length - 1;
assertThat(writeGated).isEqualTo(4);
assertThat(source).contains("DeviceSessionPolicy.isSuper(adminAuthSupport.currentRole(operator))");
}
}
@@ -81,6 +81,37 @@ class KeywordUsageAdminServiceTest {
verify(keywordUsageAdminMapper, never()).countUsageRows(any());
}
@Test
@DisplayName("CR-18:page=Long.MAX_VALUE 必须钳到安全上限,offset 不得溢出为负")
void hugePageIsClampedToSafeOffset() {
when(keywordUsageAdminMapper.countUsageRows(any())).thenReturn(0L);
when(keywordUsageAdminMapper.countCopy(any())).thenReturn(0L);
when(keywordUsageAdminMapper.countCopyExisting(any())).thenReturn(0L);
when(keywordUsageAdminMapper.countAdd(any())).thenReturn(0L);
when(keywordUsageAdminMapper.selectUsageRows(any())).thenReturn(List.of());
service.usage(1L, null, null, null, null, Long.MAX_VALUE, 15L);
ArgumentCaptor<KeywordUsageFilterQuery> captor = ArgumentCaptor.forClass(KeywordUsageFilterQuery.class);
verify(keywordUsageAdminMapper).selectUsageRows(captor.capture());
assertThat(captor.getValue().getOffset()).isEqualTo(149_985L)
.isNotNegative();
assertThat(captor.getValue().getLimit()).isEqualTo(15L);
}
@Test
@DisplayName("CR-18:删除记录页同样钳制 page,offset 不溢出")
void hugePageIsClampedForDeletes() {
when(keywordUsageAdminMapper.countDeletes(any())).thenReturn(0L);
when(keywordUsageAdminMapper.selectDeleteRows(any())).thenReturn(List.of());
service.deletes(1L, null, null, null, Long.MAX_VALUE, 100L);
ArgumentCaptor<KeywordUsageFilterQuery> captor = ArgumentCaptor.forClass(KeywordUsageFilterQuery.class);
verify(keywordUsageAdminMapper).selectDeleteRows(captor.capture());
assertThat(captor.getValue().getOffset()).isEqualTo(999_900L).isNotNegative();
}
@Test
@DisplayName("分页参数:page<1 归一为 1,page_size 上限 100")
void pageParamsAreClamped() {
@@ -91,6 +91,34 @@ class ShopDataCrawlTaskServiceOwnerTest {
verify(ossStorageService).deleteObject("result/shared.xlsx");
}
@Test
void resultFileJobFailureNeverRewritesTerminalParentTask() {
// CR-09:终态父任务可能遗留 PENDING/RUNNING 结果作业;失败回调不得把
// SUCCESS/CANCELLED/FAILED 无条件改写成 FAILED。
com.nanri.aiimage.modules.task.service.TaskDistributedLockService.LockHandle lock =
org.mockito.Mockito.mock(com.nanri.aiimage.modules.task.service.TaskDistributedLockService.LockHandle.class);
when(taskDistributedLockService.acquire("SHOP_DATA_CRAWL", 21L)).thenReturn(lock);
FileTaskEntity task = new FileTaskEntity();
task.setId(21L);
task.setModuleType("SHOP_DATA_CRAWL");
when(fileTaskMapper.selectById(21L)).thenReturn(task);
com.nanri.aiimage.modules.task.model.entity.TaskFileJobEntity job =
new com.nanri.aiimage.modules.task.model.entity.TaskFileJobEntity();
job.setId(901L);
job.setTaskId(21L);
job.setModuleType("SHOP_DATA_CRAWL");
for (String terminal : java.util.List.of("SUCCESS", "CANCELLED", "FAILED")) {
task.setStatus(terminal);
service.handleResultFileJobFailure(job, "retry exhausted");
assertEquals(terminal, task.getStatus(), "终态父任务不得被失败回调改写: " + terminal);
}
verify(fileTaskMapper, never()).updateById(any(FileTaskEntity.class));
verify(fileResultMapper, never()).updateById(any(com.nanri.aiimage.modules.task.model.entity.FileResultEntity.class));
}
private FileTaskEntity task(String owner) {
FileTaskEntity task = new FileTaskEntity();
task.setId(1L);
@@ -271,6 +271,45 @@ class SimilarAsinLlmServiceTest {
assertNull(result.get(0).getPuzzleImg1());
}
@Test
void inspectRowsRestoresInterruptFlagWhenAwaitIsInterrupted() throws Exception {
// CR-20:等待被中断时不能落入 catch (Exception) 吞掉;必须恢复中断标志并向上抛。
java.util.concurrent.CountDownLatch entered = new java.util.concurrent.CountDownLatch(1);
java.util.concurrent.CountDownLatch release = new java.util.concurrent.CountDownLatch(1);
SimilarAsinLlmClient client = mock(SimilarAsinLlmClient.class);
when(client.hasApiKey("k")).thenReturn(true);
when(client.invokeChat(anyString(), anyString(), anyString(), anyString())).thenAnswer(invocation -> {
entered.countDown();
release.await(5, java.util.concurrent.TimeUnit.SECONDS);
return "{\"first\":\"类目A\",\"second\":\"类目B\"}";
});
SimilarAsinLlmService service = service(client);
SimilarAsinResultRowDto row = rowOf("B01", "A");
java.util.concurrent.atomic.AtomicReference<Throwable> failure =
new java.util.concurrent.atomic.AtomicReference<>();
Thread caller = new Thread(() -> {
try {
service.inspectRows(List.of(row), "", "k", false, true);
} catch (Throwable ex) {
failure.set(ex);
}
}, "interrupt-await-test");
try {
caller.start();
assertTrue(entered.await(5, java.util.concurrent.TimeUnit.SECONDS),
"worker 必须先真正阻塞在等待上");
caller.interrupt();
caller.join(5_000L);
assertFalse(caller.isAlive(), "中断后等待必须立刻返回,不能继续等 worker");
assertTrue(failure.get() instanceof IllegalStateException,
"中断必须向上抛出,不能被 catch(Exception) 吞成行级失败: " + failure.get());
assertTrue(caller.isInterrupted(), "中断标志必须恢复(Thread.currentThread().interrupt())");
} finally {
release.countDown();
}
}
@Test
void imageCompareStopsOnStockAndFillsFields() {
// 第 1 次 chat:合并类目调用一次给出一级+二级名称(Java 按名回查取真实 ID);第 2 次:合规检查。
@@ -353,9 +353,9 @@ class TaskResultFileJobWorkerStuckScanTest {
}
@Test
void terminalParentHeartbeatStopsTouchingAndFailsJob() throws Exception {
// 父任务在 worker 执行中变终态:心跳不得再 touchRunning(否则 stuck 扫描永远看不到),
// 并主动把 job 收口为 FAILED;终态回调留给兜底扫描出部分结果,失败任务仍可下载。
void terminalParentHeartbeatStopsTouchingButLeavesTerminalVerdictToExecutionThread() throws Exception {
// CR-08:父任务在 worker 执行中变终态:心跳只停续期、停 touchRunning,
// 不再抢先把仍在执行的 job 翻成 FAILED——否则执行线程的 markSuccess 会被丢弃。
TaskResultFileJobWorker worker = buildWorker();
setLong(worker, "heartbeatIntervalMillis", 10L);
TaskFileJobEntity job = new TaskFileJobEntity();
@@ -363,23 +363,158 @@ class TaskResultFileJobWorkerStuckScanTest {
job.setTaskId(15L);
job.setModuleType("SIMILAR_ASIN");
job.setStatus("RUNNING");
TaskDistributedLockService.LockHandle lock = mock(TaskDistributedLockService.LockHandle.class);
Field handlesField = TaskResultFileJobWorker.class.getDeclaredField("activeLockHandles");
handlesField.setAccessible(true);
@SuppressWarnings("unchecked")
java.util.Map<Long, TaskDistributedLockService.LockHandle> handles =
(java.util.Map<Long, TaskDistributedLockService.LockHandle>) handlesField.get(worker);
handles.put(77L, lock);
when(taskFileJobService.isOwningTaskTerminal(15L)).thenReturn(true);
java.lang.reflect.Method method = TaskResultFileJobWorker.class
.getDeclaredMethod("startJobHeartbeat", TaskFileJobEntity.class);
.getDeclaredMethod("startJobHeartbeat", TaskFileJobEntity.class,
java.util.concurrent.atomic.AtomicBoolean.class);
method.setAccessible(true);
java.util.concurrent.ScheduledFuture<?> future =
(java.util.concurrent.ScheduledFuture<?>) method.invoke(worker, job);
(java.util.concurrent.ScheduledFuture<?>) method.invoke(worker, job,
new java.util.concurrent.atomic.AtomicBoolean(false));
try {
// heartbeat 间隔下限 1000ms,首轮在 1s 后才跑;给足调度余量
verify(taskFileJobService, timeout(3000))
.markFailedPermanentAwaitingFallback(eq(job), contains("父任务已终态"));
verify(lock, timeout(3000)).stopRenewal("parent-task-terminal", false);
verify(taskFileJobService, after(150).never()).touchRunning(77L);
verify(taskFileJobService, never())
.markFailedPermanentAwaitingFallback(any(), anyString());
} finally {
future.cancel(true);
}
}
@Test
void terminalVerdictAfterExecutionKeepsSuccessWrittenByTheExecutionThread() throws Exception {
// 竞态的另一半:心跳观察到终态时执行线程仍可能成功落库;退出后的收口必须保留 SUCCESS。
TaskResultFileJobWorker worker = buildWorker();
TaskFileJobEntity job = new TaskFileJobEntity();
job.setId(78L);
job.setTaskId(16L);
job.setModuleType("SIMILAR_ASIN");
TaskFileJobEntity success = new TaskFileJobEntity();
success.setId(78L);
success.setTaskId(16L);
success.setModuleType("SIMILAR_ASIN");
success.setStatus("SUCCESS");
when(taskFileJobService.findById(78L)).thenReturn(success);
worker.finishAfterExecution(job, new java.util.concurrent.atomic.AtomicBoolean(true));
verify(taskFileJobService, never()).markFailedPermanentAwaitingFallback(any(), anyString());
}
@Test
void terminalVerdictAfterExecutionFailsJobWhenExecutionDidNotSucceed() throws Exception {
TaskResultFileJobWorker worker = buildWorker();
TaskFileJobEntity job = new TaskFileJobEntity();
job.setId(79L);
job.setTaskId(17L);
job.setModuleType("SIMILAR_ASIN");
TaskFileJobEntity running = new TaskFileJobEntity();
running.setId(79L);
running.setTaskId(17L);
running.setStatus("RUNNING");
when(taskFileJobService.findById(79L)).thenReturn(running);
worker.finishAfterExecution(job, new java.util.concurrent.atomic.AtomicBoolean(true));
verify(taskFileJobService).markFailedPermanentAwaitingFallback(job, "父任务已终态,结果作业不再执行");
}
/**
* 真实竞态:执行线程还在跑时心跳发现父任务终态,随后执行线程成功落库。
* 心跳不得抢翻 FAILED,退出后的收口必须保留 SUCCESS。
*/
@Test
void heartbeatTerminalRaceDoesNotDiscardExecutionThreadSuccess() throws Exception {
java.util.concurrent.CountDownLatch entered = new java.util.concurrent.CountDownLatch(1);
java.util.concurrent.CountDownLatch release = new java.util.concurrent.CountDownLatch(1);
java.util.concurrent.atomic.AtomicBoolean terminal = new java.util.concurrent.atomic.AtomicBoolean(false);
ResultFileJobHandler handler = new ResultFileJobHandler() {
@Override
public String moduleType() {
return "RACE_TEST";
}
@Override
public boolean process(TaskFileJobEntity job) {
entered.countDown();
try {
release.await(5, java.util.concurrent.TimeUnit.SECONDS);
} catch (InterruptedException ex) {
Thread.currentThread().interrupt();
return false;
}
return true;
}
};
ResultFileJobHandlerRegistry registry = new ResultFileJobHandlerRegistry(List.of(handler));
TaskResultFileJobWorker worker = new TaskResultFileJobWorker(
taskFileJobService, taskDistributedLockService, mock(FileResultMapper.class),
mock(TaskFileJobLocalDispatcher.class), instanceMetadata, registry);
setLong(worker, "heartbeatIntervalMillis", 10L);
TaskFileJobEntity job = new TaskFileJobEntity();
job.setId(80L);
job.setTaskId(18L);
job.setModuleType("RACE_TEST");
job.setStatus("RUNNING");
TaskFileJobEntity claim = new TaskFileJobEntity();
claim.setId(80L);
claim.setTaskId(18L);
claim.setModuleType("RACE_TEST");
claim.setStatus("RUNNING");
claim.setUpdatedAt(LocalDateTime.now());
TaskFileJobEntity success = new TaskFileJobEntity();
success.setId(80L);
success.setTaskId(18L);
success.setModuleType("RACE_TEST");
success.setStatus("SUCCESS");
TaskDistributedLockService.LockHandle lock = mock(TaskDistributedLockService.LockHandle.class);
when(taskFileJobService.isOwningTaskTerminal(18L)).thenAnswer(invocation -> terminal.get());
when(taskFileJobService.activateRunningClaim(claim)).thenReturn(true);
when(taskDistributedLockService.acquire("RACE_TEST", 18L,
TaskDistributedLockService.DEFAULT_WAIT_MILLIS)).thenReturn(lock);
when(taskFileJobService.findById(80L))
.thenReturn(job, job, success);
when(taskFileJobService.markSuccess(job, null)).thenReturn(true);
java.lang.reflect.Method method = TaskResultFileJobWorker.class.getDeclaredMethod(
"processClaimedWithHeartbeat", TaskFileJobEntity.class, TaskFileJobEntity.class);
method.setAccessible(true);
java.util.concurrent.ExecutorService runner = java.util.concurrent.Executors.newSingleThreadExecutor();
try {
java.util.concurrent.Future<?> run = runner.submit(() -> {
try {
method.invoke(worker, job, claim);
} catch (Exception ex) {
throw new IllegalStateException(ex);
}
});
assertTrue(entered.await(5, java.util.concurrent.TimeUnit.SECONDS),
"执行线程必须已进入 handler");
terminal.set(true);
// heartbeat 间隔下限 1000ms;留足一轮调度余量,让心跳先看到终态
Thread.sleep(1500L);
verify(taskFileJobService, never()).markFailedPermanentAwaitingFallback(any(), anyString());
release.countDown();
run.get(5, java.util.concurrent.TimeUnit.SECONDS);
verify(taskFileJobService).markSuccess(job, null);
verify(taskFileJobService, never()).markFailedPermanentAwaitingFallback(any(), anyString());
} finally {
release.countDown();
runner.shutdownNow();
}
}
/**
* 终态兜底出表只在归属实例做:非归属实例若抢先 markFailureFinalized,归属机的
* fallbackAssembleOnFailure 就永远跑不到,失败任务的结果文件也就永远不生成。
@@ -126,6 +126,48 @@ class CostGuardSchedulerTest {
anyString(), contains("平台自费"), anyString(), isNull());
}
@Test
void platformAlertWithoutAnyAdminPersistedDoesNotAdvanceBaselineAndRetries() {
// CR-10:推送返回 0(没有管理员落库)时基线不得推进,否则下一轮 crossed 不再成立、告警永久丢失。
when(usageMapper.sumByUserAndModule(any(LocalDate.class)))
.thenReturn(List.of(row(0L, "proxy", 2_500, 0)));
when(notificationDispatchService.pushToAdmins(
eq(NotificationService.SCENE_COST_GUARD), eq(NotificationService.LEVEL_WARNING),
anyString(), contains("平台自费"), anyString(), isNull()))
.thenReturn(0, 1);
scheduler.runOnce();
assertThat(baselineStore.get(0L)).isNull();
scheduler.runOnce();
assertThat(baselineStore.get(0L).proxy).isEqualTo(2_500L);
scheduler.runOnce();
verify(notificationDispatchService, org.mockito.Mockito.times(2)).pushToAdmins(
eq(NotificationService.SCENE_COST_GUARD), eq(NotificationService.LEVEL_WARNING),
anyString(), contains("平台自费"), anyString(), isNull());
}
@Test
void platformAlertPushExceptionDoesNotAdvanceBaselineAndRetries() {
when(usageMapper.sumByUserAndModule(any(LocalDate.class)))
.thenReturn(List.of(row(0L, "proxy", 2_500, 0)));
when(notificationDispatchService.pushToAdmins(
eq(NotificationService.SCENE_COST_GUARD), eq(NotificationService.LEVEL_WARNING),
anyString(), contains("平台自费"), anyString(), isNull()))
.thenThrow(new IllegalStateException("redis down"))
.thenReturn(1);
scheduler.runOnce();
assertThat(baselineStore.get(0L)).isNull();
scheduler.runOnce();
assertThat(baselineStore.get(0L).proxy).isEqualTo(2_500L);
verify(notificationDispatchService, org.mockito.Mockito.times(2)).pushToAdmins(
eq(NotificationService.SCENE_COST_GUARD), eq(NotificationService.LEVEL_WARNING),
anyString(), contains("平台自费"), anyString(), isNull());
}
@Test
void llmCallsWindowJumpPauses() {
when(usageMapper.sumByUserAndModule(any(LocalDate.class)))
@@ -1,20 +1,42 @@
package com.nanri.aiimage.modules.workbenchclient.service;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.conditions.AbstractWrapper;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.modules.file.service.oss.OssStorageService;
import com.nanri.aiimage.modules.workbenchclient.mapper.WorkbenchClientPackageMapper;
import com.nanri.aiimage.modules.workbenchclient.model.entity.WorkbenchClientPackageEntity;
import ch.qos.logback.classic.Logger;
import ch.qos.logback.classic.spi.ILoggingEvent;
import ch.qos.logback.core.read.ListAppender;
import org.apache.ibatis.builder.MapperBuilderAssistant;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;
import org.slf4j.LoggerFactory;
import org.springframework.dao.DuplicateKeyException;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -40,10 +62,33 @@ class WorkbenchClientPackageServiceTest {
private final WorkbenchClientPackageMapper packageMapper = mock(WorkbenchClientPackageMapper.class);
private final OssStorageService ossStorageService = mock(OssStorageService.class);
@TempDir
Path tempDir;
private WorkbenchClientPackageService service() {
return new WorkbenchClientPackageService(packageMapper, ossStorageService);
}
/** 每次调用返回一个新的合法 zip:confirm 扫描后会把临时文件删掉,不能复用同一个路径。 */
private void stubCleanZip() {
when(ossStorageService.downloadWorkbenchClientObjectToTempFile(anyString()))
.thenAnswer(invocation -> zip("ShuFuAI/app.exe", "ShuFuAI/readme.txt"));
}
private Path zip(String... entries) {
Path file = tempDir.resolve("pkg-" + UUID.randomUUID() + ".zip");
try (ZipOutputStream out = new ZipOutputStream(Files.newOutputStream(file))) {
for (String entry : entries) {
out.putNextEntry(new ZipEntry(entry));
out.write("test".getBytes(java.nio.charset.StandardCharsets.UTF_8));
out.closeEntry();
}
return file;
} catch (IOException ex) {
throw new IllegalStateException(ex);
}
}
@BeforeAll
static void initializeMybatisMetadata() {
TableInfoHelper.initTableInfo(
@@ -103,6 +148,7 @@ class WorkbenchClientPackageServiceTest {
void confirmRecomputesSha256BeforeInsert() {
String objectKey = PREFIX + "20261024100000123-1.2.3.zip";
when(ossStorageService.workbenchClientObjectSize(objectKey)).thenReturn(1234L);
stubCleanZip();
when(ossStorageService.workbenchClientObjectSha256(objectKey)).thenReturn(SHA);
when(ossStorageService.getWorkbenchClientDownloadUrl(objectKey))
.thenReturn("https://download.aishufu.top/client/" + objectKey);
@@ -153,11 +199,13 @@ class WorkbenchClientPackageServiceTest {
void confirmRejectsDuplicateVersionToPreventSameVersionDifferentBytes() {
String objectKey = PREFIX + "20261024100000123-uuid-1.2.3.zip";
when(ossStorageService.workbenchClientObjectSize(objectKey)).thenReturn(1234L);
stubCleanZip();
when(packageMapper.selectCount(any())).thenReturn(1L);
assertThrows(BusinessException.class, () -> service().confirmPackage(
objectKey, "ShuFuAI-Workbench-1.2.3.zip", "1.2.3"));
verify(ossStorageService).removeWorkbenchClientObject(objectKey);
verify(ossStorageService, never()).workbenchClientObjectSha256(anyString());
verify(packageMapper, never()).insert(any(WorkbenchClientPackageEntity.class));
}
@@ -166,6 +214,7 @@ class WorkbenchClientPackageServiceTest {
void confirmRejectsVersionLowerThanCurrentLatest() {
String objectKey = PREFIX + "20261024100000123-uuid-1.2.2.zip";
when(ossStorageService.workbenchClientObjectSize(objectKey)).thenReturn(1234L);
stubCleanZip();
when(packageMapper.selectCount(any())).thenReturn(0L);
// 第一次 selectOne 是幂等查(无同对象),第二次才是取当前最新版本
when(packageMapper.selectOne(any()))
@@ -175,10 +224,222 @@ class WorkbenchClientPackageServiceTest {
objectKey, "ShuFuAI-Workbench-1.2.2.zip", "1.2.2"));
assertTrue(ex.getMessage().contains("1.2.3"));
verify(ossStorageService).removeWorkbenchClientObject(objectKey);
verify(ossStorageService, never()).workbenchClientObjectSha256(anyString());
verify(packageMapper, never()).insert(any(WorkbenchClientPackageEntity.class));
}
@Test
void confirmRejectsPackageContainingKeywordShareCredentialConfig() {
// CR-02:公开下载的安装包内不得出现 kw_share_cfg.json(明文 API 口令载体)
String objectKey = PREFIX + "20261024100000123-uuid-1.2.3.zip";
when(ossStorageService.workbenchClientObjectSize(objectKey)).thenReturn(1234L);
when(ossStorageService.downloadWorkbenchClientObjectToTempFile(objectKey))
.thenReturn(zip("ShuFuAI/app.exe", "ShuFuAI/config/kw_share_cfg.json"));
BusinessException ex = assertThrows(BusinessException.class, () -> service().confirmPackage(
objectKey, "ShuFuAI-Workbench-1.2.3.zip", "1.2.3"));
assertTrue(ex.getMessage().contains("kw_share_cfg.json"), "错误里要点名命中的凭据文件");
verify(ossStorageService).removeWorkbenchClientObject(objectKey);
verify(ossStorageService, never()).workbenchClientObjectSha256(anyString());
verify(packageMapper, never()).insert(any(WorkbenchClientPackageEntity.class));
}
@Test
void confirmRejectsEnvAndPemFiles() {
String objectKey = PREFIX + "20261024100000123-uuid-1.2.3.zip";
when(ossStorageService.workbenchClientObjectSize(objectKey)).thenReturn(1234L);
when(ossStorageService.downloadWorkbenchClientObjectToTempFile(objectKey))
.thenReturn(zip("ShuFuAI/app.exe", "deploy/.env", "cert/server.pem"));
assertThrows(BusinessException.class, () -> service().confirmPackage(
objectKey, "ShuFuAI-Workbench-1.2.3.zip", "1.2.3"));
verify(ossStorageService).removeWorkbenchClientObject(objectKey);
verify(packageMapper, never()).insert(any(WorkbenchClientPackageEntity.class));
}
@Test
void confirmRejectsNonZipPayloadAndCleansItUp() throws Exception {
String objectKey = PREFIX + "20261024100000123-uuid-1.2.3.zip";
Path notZip = tempDir.resolve("not-a-zip.zip");
Files.writeString(notZip, "this is not a zip");
when(ossStorageService.workbenchClientObjectSize(objectKey)).thenReturn(1234L);
when(ossStorageService.downloadWorkbenchClientObjectToTempFile(objectKey)).thenReturn(notZip);
assertThrows(BusinessException.class, () -> service().confirmPackage(
objectKey, "ShuFuAI-Workbench-1.2.3.zip", "1.2.3"));
verify(ossStorageService).removeWorkbenchClientObject(objectKey);
verify(packageMapper, never()).insert(any(WorkbenchClientPackageEntity.class));
}
@Test
void presignDoesNotLogTheOneTimeUploadUrl() {
// CR-21:预签名 URL 是一次性凭据,不得出现在日志里
String secretUrl = "https://oss.aishufu.top/client/workbench-client/versions/put?X-Amz-Signature=SECRET-URL-999";
when(ossStorageService.presignWorkbenchClientUpload(anyString(), eq(3600))).thenReturn(secretUrl);
when(ossStorageService.getWorkbenchClientDownloadUrl(anyString())).thenReturn("download");
Logger logger = (Logger) LoggerFactory.getLogger(WorkbenchClientPackageService.class);
ListAppender<ILoggingEvent> appender = new ListAppender<>();
appender.start();
logger.addAppender(appender);
try {
Map<String, Object> result = service().presignPackage("pkg.zip", "1.2.3");
assertEquals(secretUrl, result.get("upload_url"));
String logs = String.join("\n", appender.list.stream()
.map(ILoggingEvent::getFormattedMessage).toList());
assertFalse(logs.contains("SECRET-URL-999"), "预签名 URL 不得入日志: " + logs);
} finally {
logger.detachAppender(appender);
}
}
@Test
void concurrentConfirmsOfSameObjectKeyAreIdempotent() throws Exception {
String objectKey = PREFIX + "20261024100000123-uuid-1.2.3.zip";
when(ossStorageService.workbenchClientObjectSize(objectKey)).thenReturn(1234L);
when(ossStorageService.workbenchClientObjectSha256(objectKey)).thenReturn(SHA);
when(ossStorageService.getWorkbenchClientDownloadUrl(anyString())).thenReturn("");
stubCleanZip();
Map<String, WorkbenchClientPackageEntity> rows = new ConcurrentHashMap<>();
AtomicLong nextId = new AtomicLong(99L);
CountDownLatch insertBarrier = new CountDownLatch(2);
when(packageMapper.selectOne(any())).thenAnswer(invocation -> findRow(invocation.getArgument(0), rows));
when(packageMapper.selectCount(any())).thenReturn(0L);
when(packageMapper.insert(any(WorkbenchClientPackageEntity.class))).thenAnswer(invocation -> {
WorkbenchClientPackageEntity entity = invocation.getArgument(0);
insertBarrier.countDown();
assertTrue(insertBarrier.await(5, TimeUnit.SECONDS), "两路必须都到达 insert 才构成并发");
synchronized (rows) {
if (rows.containsKey(entity.getObjectKey())) {
throw new DuplicateKeyException("uk_workbench_client_object_key");
}
entity.setId(nextId.incrementAndGet());
rows.put(entity.getObjectKey(), entity);
return 1;
}
});
when(packageMapper.selectById(any())).thenAnswer(invocation -> rows.values().stream()
.filter(row -> row.getId().equals(invocation.getArgument(0))).findFirst().orElse(null));
List<Object> results = runConcurrently(
() -> service().confirmPackage(objectKey, "ShuFuAI-Workbench-1.2.3.zip", "1.2.3"),
() -> service().confirmPackage(objectKey, "ShuFuAI-Workbench-1.2.3.zip", "1.2.3"));
assertEquals(1, rows.size(), "同 objectKey 并发 confirm 只能落一行");
for (Object result : results) {
assertTrue(result instanceof Map, "两路都应幂等成功: " + result);
}
assertEquals(((Map<?, ?>) results.get(0)).get("id"), ((Map<?, ?>) results.get(1)).get("id"));
}
@Test
void concurrentConfirmsOfSameVersionDifferentObjectsAllowOnlyOneRow() throws Exception {
String keyA = PREFIX + "20261024100000123-aaa-1.2.3.zip";
String keyB = PREFIX + "20261024100000123-bbb-1.2.3.zip";
when(ossStorageService.workbenchClientObjectSize(anyString())).thenReturn(1234L);
when(ossStorageService.workbenchClientObjectSha256(anyString())).thenReturn(SHA);
when(ossStorageService.getWorkbenchClientDownloadUrl(anyString())).thenReturn("");
stubCleanZip();
Map<String, WorkbenchClientPackageEntity> rows = new ConcurrentHashMap<>();
AtomicLong nextId = new AtomicLong(99L);
CountDownLatch countBarrier = new CountDownLatch(2);
CountDownLatch insertBarrier = new CountDownLatch(2);
AtomicInteger countCalls = new AtomicInteger();
when(packageMapper.selectCount(any())).thenAnswer(invocation -> {
if (countCalls.incrementAndGet() <= 2) {
countBarrier.countDown();
assertTrue(countBarrier.await(5, TimeUnit.SECONDS), "两路都必须先读到 0 才能复现竞态");
}
return 0L;
});
when(packageMapper.selectOne(any())).thenAnswer(invocation -> findRow(invocation.getArgument(0), rows));
when(packageMapper.insert(any(WorkbenchClientPackageEntity.class))).thenAnswer(invocation -> {
WorkbenchClientPackageEntity entity = invocation.getArgument(0);
insertBarrier.countDown();
assertTrue(insertBarrier.await(5, TimeUnit.SECONDS), "两路必须都到达 insert 才构成并发");
synchronized (rows) {
if (rows.containsKey(entity.getObjectKey())) {
throw new DuplicateKeyException("uk_workbench_client_object_key");
}
if (rows.values().stream().anyMatch(row -> row.getVersion().equals(entity.getVersion()))) {
throw new DuplicateKeyException("uk_workbench_client_version");
}
entity.setId(nextId.incrementAndGet());
rows.put(entity.getObjectKey(), entity);
return 1;
}
});
when(packageMapper.selectById(any())).thenAnswer(invocation -> rows.values().stream()
.filter(row -> row.getId().equals(invocation.getArgument(0))).findFirst().orElse(null));
List<Object> results = runConcurrently(
() -> service().confirmPackage(keyA, "ShuFuAI-Workbench-1.2.3.zip", "1.2.3"),
() -> service().confirmPackage(keyB, "ShuFuAI-Workbench-1.2.3.zip", "1.2.3"));
assertEquals(1, rows.size(), "同 version 不同 objectKey 并发 confirm 只能落一行");
long success = results.stream().filter(Map.class::isInstance).count();
long rejected = results.stream().filter(BusinessException.class::isInstance).count();
assertEquals(1, success, "必须恰好一路成功: " + results);
assertEquals(1, rejected, "第二路必须是明确的业务错误而非 500: " + results);
// 失败那一路的 512MB 级对象必须被清理,不能悬挂在公开桶
verify(ossStorageService).removeWorkbenchClientObject(anyString());
}
private static WorkbenchClientPackageEntity findRow(Object wrapper,
Map<String, WorkbenchClientPackageEntity> rows) {
if (!(wrapper instanceof AbstractWrapper<?, ?, ?> query)) {
return null;
}
String sql = query.getSqlSegment();
if (sql == null || !sql.contains("object_key")) {
return null;
}
for (Object value : query.getParamNameValuePairs().values()) {
if (value instanceof String key && rows.containsKey(key)) {
return rows.get(key);
}
}
return null;
}
private static List<Object> runConcurrently(ThrowingSupplier first, ThrowingSupplier second)
throws Exception {
CountDownLatch start = new CountDownLatch(1);
ExecutorService pool = Executors.newFixedThreadPool(2);
try {
Future<Object> a = pool.submit(() -> {
start.await();
try {
return first.get();
} catch (Exception ex) {
return ex;
}
});
Future<Object> b = pool.submit(() -> {
start.await();
try {
return second.get();
} catch (Exception ex) {
return ex;
}
});
start.countDown();
return List.of(a.get(10, TimeUnit.SECONDS), b.get(10, TimeUnit.SECONDS));
} finally {
pool.shutdownNow();
}
}
@FunctionalInterface
private interface ThrowingSupplier {
Object get() throws Exception;
}
@Test
void versionComparisonHandlesDifferentSegmentCounts() {
assertTrue(WorkbenchClientPackageService.versionIsLower("1.2.3", "1.2.10"));