feat(credential): 凭据不可自愈 ⇒ 行失败 + 整单终态 + 用户端弹窗(服务端五面)

用户口径(2026-11-12,34061 取证后):没余额要退成失败、直接中断任务、并弹窗提示;
所有涉及代理 IP / LLM 密钥的特性都一样。范围=服务端全部特性,客户端下批。

- 判据唯一出处 common/retry/CredentialFatalClassifier(致命:LLM 欠费/密钥失效、
  代理未配置/套餐到期/余额不足/密钥无效;非致命:channel_busy、无空闲通道、冷却、
  超时、5xx、限流、出口被拒、技术性、上游不可用);落终态唯一出口
  modules/task/service/CredentialFatalTaskCloser(重读现状态、拒碰 TERMINAL、可重入)。
  外观专利与相似ASIN 原先逐字重复的 terminalizeOnFatalLlmFailure 改为委托,不留第二份。
- 五面接线:外观专利/相似ASIN、跟价 updateTaskStatusFromLatestRows、
  店铺采集 tryFinalizeTask、采集数据 submitResult。判死后回执一律回读库里状态
  (采集数据内存 task 停在 RUNNING 会让采集端继续为死路买出口 IP)。
- 行级诚实:凭据致命行不计入已判,回退路不再拿原始标题伪造「侵权/成功」。
- 用户端:credential-fatal-notice.ts(判据)+ credential-fatal-alert.ts(按 taskId:kind
  去重)+ CredentialFatalAlert.vue 挂 App.vue;轻量轮询不带文案 ⇒ 跟价/采集数据在失败
  终态补一次重型 batch,店铺 batch 补任务级 taskErrorMessage(只给 FAILED、截断 300 字)。
- 三处真死日志按巡检签名正形写「改判死」(scripts/_prod_watch.py 只认 改判死|接管判死),
  否则判死数不进账本。
- TaskFailureCategoryGuardrailTest:写点搬进收口器 ⇒ 登记 CredentialFatalTaskCloser,
  下限 47→46、updateById 总量 160→159(搬点,不是新增写法)。

判据:CredentialFatalClassifierTest(16)、CollectDataCredentialFatalTest(3)、
PriceTrackTaskServiceTest(8)、ShopDataCrawlScopeMergeTest(11)、
ShopDataCrawlProgressQueryTest(9)、credential-fatal-notice.test.ts(9)、
credential-fatal-alert.test.ts(6)。后端整量 5,464 例 / 0 失败 / 19 skipped。

未纳入本笔:BrandAppearancePatentTab.vue、BrandSimilarAsinTab.vue、TaskItemCard.vue
与两个 Tab 里的按钮/徽章 CSS —— 另一路会话在飞改动,按并发纪律不卷进来。
This commit is contained in:
2026-11-12 18:10:10 +08:00
parent f5f40cd2ea
commit 64e94458c9
37 changed files with 1781 additions and 111 deletions
@@ -0,0 +1,151 @@
package com.nanri.aiimage.common.retry;
import com.nanri.aiimage.modules.brand.support.BrandCheckFailureNotice;
import com.nanri.aiimage.modules.task.service.TaskRetryEligibility;
import java.util.List;
import java.util.Locale;
/**
* 「凭据坏了、再跑多少次都是同一个结果」这一类失败的唯一判据,以及该给用户看的那句动作。
*
* <p>用户口径(2026-11-12,34061 取证后):任何特性只要用到 LLM 密钥或代理 IP,遇到<b>不可自愈</b>的
* 凭据故障都必须三件事一起做——行落失败并写真实原因、任务立即中断为终态、用户端弹窗一次。
* 判据只此一处:外观专利、货源查询、跟价、店铺采集、采集数据都从这里取,不各自抄一份字面量表
* (抄了就会改一处静默失效,与 {@link TaskRetryEligibility} 的注释同一条理由)。
*
* <p>代理侧的分档<b>不另立词汇表</b>:{@link BrandCheckFailureNotice} 已经按"未配置 / 套餐耗尽 /
* 冷却 / 出口被拒 / 技术性 / 上游"六档分过品牌检测的原始原因(2026-10-20 起就是那张表)。
* 这里只认它的前两档为致命,后四档一律继续重试——冷却与出口被拒是短时现象、上游不可用会自己恢复,
* 拿它们判死就是让用户整单给一次抖动陪葬(铁律 27(c))。
*
* <p>LLM 那半边走 {@link TaskRetryEligibility.Category#BALANCE}(欠费与密钥失效同族)。
* LLM 专属字样<b>先于</b>品牌侧判:品牌侧的「余额不足」与 LLM 的「余额欠费」都落在同一批中文词上,
* 顺序反了就会把"代理套餐没钱了"说成"上游 LLM 账户欠费"——2026-10-27 用户点名要避免的那种误导。
*/
public final class CredentialFatalClassifier {
/** 凭据故障的两种来源:给用户的那句动作不同。 */
public enum Kind {
/** 上游 LLM 账户欠费/额度耗尽,或 LLM 密钥本身失效。 */
LLM_CREDENTIAL,
/** 代理提取:套餐到期、余额不足、密钥/链接不可用,或根本没配置。 */
PROXY_CREDENTIAL
}
/**
* LLM 侧「钱/密钥」硬字样:与 {@code LlmBalanceGuard} 的余额识别、{@code TaskRetryEligibility.KEY_MARKERS}
* 同一套词,加 {@code 余额欠费}/{@code 额度不足} 这两个中文签。
*
* <p>刻意<b>不</b>收裸「llm」或裸「余额不足」:任何一条 LLM 报错都带 {@code LLM} 三个字母
* ({@code LLM 网关无应答}、{@code LLM http 502}),拿它当凭据判据会把一次抖动判成终态;
* 「余额不足」是品牌侧套餐与 LLM 侧欠费共用的词,得靠品牌词汇表先分档。
*/
private static final List<String> LLM_CREDENTIAL_MARKERS = List.of(
"insufficient_user_quota", "insufficient_quota", "insufficient balance", "insufficient_funds",
"wallet balance insufficient", "quota exceeded",
"预扣费额度", "余额欠费", "额度不足",
"密钥无效", "密钥失效", "无效的密钥", "密钥不可用",
"invalid api key", "invalid_api_key", "api key 无效", "apikey 无效");
/**
* 代理侧「凭据本身不可用」的硬字样:与品牌侧词汇表无关的那些提供商失败码。
*
* <p>必须先于 {@link BrandCheckFailureNotice} 判:青果的 {@code API_AUTH_DENY} 常和「提取失败」
* 出现在同一句里,而品牌侧把「提取失败」归 TECHNICAL(补测轮会再来)——顺序反了,
* 一条注定失败的鉴权错就被说成"技术性失败、等等再试"。
*/
private static final List<String> PROXY_HARD_CREDENTIAL_MARKERS = List.of(
"未配置代理", "代理地址为空", "代理链接为空",
"invalid_key", "unavailable_key", "key_block", "api_auth_deny", "access_deny");
/** 代理侧专名/字面:只用于把一句泛化的「余额不足」判给代理而不是 LLM。 */
private static final List<String> PROXY_CREDENTIAL_MARKERS = List.of(
"代理", "提取链接", "提取分钟数", "青果", "qg.net", "jikip", "极客", "套餐",
"invalid_key", "unavailable_key", "key_block", "api_auth_deny", "access_deny");
/**
* 明确「外部自己会恢复」的字样:命中一律不致命。
*
* <p>刻意<b>不</b>放裸数字(429/502/503/504):上游欠费原文里带着账户号({@code 用户[151502]}),
* 裸 {@code contains("502")} 会把一条真欠费判成 5xx 抖动——放过这一单,用户就又回到"只见失败、不见原因"。
*/
private static final List<String> SELF_HEALING_MARKERS = List.of(
"no_available_channel", "没有可用的空闲通道", "channel_busy", "通道被占", "通道已满",
"冷却", "cooldown", "稍后重试",
"timeout", "timed out", "超时",
"too many requests", "rate limited", "限流",
"bad gateway", "service unavailable", "gateway timeout",
"connection refused", "连接被拒绝", "不可达", "unreachable",
"页面无效", "风控墙", "人机验证");
/** 代理侧终态动作句(与 {@link LlmBalanceGuard#TASK_TERMINAL_GUIDANCE} 同形:谁的问题、做了什么、下一步)。 */
public static final String PROXY_TERMINAL_GUIDANCE =
"任务已终止:代理 IP 套餐已到期或余额不足、或提取链接不可用(未配置/密钥无效),"
+ "不是你本次上传的数据问题;已停止后续采集与检测,以免继续空跑并消耗额度。"
+ "请到账号的代理设置里充值、续期或更换提取链接后重新发起任务。";
private CredentialFatalClassifier() {
}
/** @return null=可以继续重试;非 null=不可自愈,按该档处置 */
public static Kind kind(String failureMessage) {
if (failureMessage == null || failureMessage.isBlank()) {
return null;
}
// 本仓自己写下的两条终态句先认出来(原文比对,模板里有大写 LLM/IP):它们各自都提到
// 「密钥/代理出口」,让下面的词汇表去猜,存量单重读时就会在 LLM 与代理之间来回翻。
if (failureMessage.contains(LlmBalanceGuard.TASK_TERMINAL_GUIDANCE)) {
return Kind.LLM_CREDENTIAL;
}
if (failureMessage.contains(PROXY_TERMINAL_GUIDANCE)) {
return Kind.PROXY_CREDENTIAL;
}
String text = failureMessage.toLowerCase(Locale.ROOT);
if (containsAny(text, SELF_HEALING_MARKERS)) {
return null;
}
if (containsAny(text, LLM_CREDENTIAL_MARKERS)) {
return Kind.LLM_CREDENTIAL;
}
if (containsAny(text, PROXY_HARD_CREDENTIAL_MARKERS)) {
return Kind.PROXY_CREDENTIAL;
}
BrandCheckFailureNotice.Kind brand = BrandCheckFailureNotice.classify(failureMessage);
if (brand == BrandCheckFailureNotice.Kind.PROXY_NOT_CONFIGURED
|| brand == BrandCheckFailureNotice.Kind.PROXY_PACKAGE_EXHAUSTED) {
return Kind.PROXY_CREDENTIAL;
}
// 品牌侧认得的技术性/冷却/出口被拒三类:补测轮会自己再来,不进终态。
if (brand != BrandCheckFailureNotice.Kind.UPSTREAM) {
return null;
}
// 兜底:还没被任何一张词汇表认出来的欠费/密钥形状,按走 BALANCE 判死,
// 靠有没有代理专名决定给哪句动作。判不出 BALANCE 就是普通可重试失败。
if (TaskRetryEligibility.forceMajeureCategory(failureMessage) != TaskRetryEligibility.Category.BALANCE) {
return null;
}
return containsAny(text, PROXY_CREDENTIAL_MARKERS) ? Kind.PROXY_CREDENTIAL : Kind.LLM_CREDENTIAL;
}
/** 只要"要不要判死"的那一问。 */
public static boolean isFatal(String failureMessage) {
return kind(failureMessage) != null;
}
/** 给定档位的终态动作句;这是写进 {@code biz_file_task.error_message} 尾巴的那一段。 */
public static String guidance(Kind kind) {
return kind == Kind.PROXY_CREDENTIAL
? PROXY_TERMINAL_GUIDANCE
: LlmBalanceGuard.TASK_TERMINAL_GUIDANCE;
}
private static boolean containsAny(String text, List<String> markers) {
for (String marker : markers) {
if (text.contains(marker)) {
return true;
}
}
return false;
}
}
@@ -11,6 +11,7 @@ import com.nanri.aiimage.config.AppearancePatentProperties;
import com.nanri.aiimage.config.HttpClientPool;
import com.nanri.aiimage.metrics.ExternalCallMetricsRecorder;
import com.nanri.aiimage.modules.appearancepatent.model.dto.AppearancePatentResultRowDto;
import com.nanri.aiimage.modules.appearancepatent.service.support.AppearancePatentRowOutcome;
import com.nanri.aiimage.modules.appearancepatent.service.support.AppearancePatentSheetBuilder;
import com.nanri.aiimage.modules.brand.client.BrandCheckClient;
import com.nanri.aiimage.modules.usersecret.service.UserSecretUsageService;
@@ -60,7 +61,8 @@ public class AppearancePatentLlmClient {
private static final int MAX_LLM_RESPONSE_BYTES = 16 * 1024 * 1024;
private static final String INFRINGEMENT = "侵权";
private static final String NO_INFRINGEMENT = "无侵权";
private static final String BRAND_QUERY_FAILED = "商标查询失败";
/** 文案唯一定义在 {@link AppearancePatentRowOutcome}(出表侧要用同一串判"这格是不是判定")。 */
private static final String BRAND_QUERY_FAILED = AppearancePatentRowOutcome.BRAND_QUERY_FAILED;
/**
* 整批待查词无一返回结果时的文案,与逐行的「商标查询失败」区分开。
*
@@ -83,14 +85,16 @@ public class AppearancePatentLlmClient {
private static final int LLM_CONNECT_FAILURE_EVIDENCE = 2;
/** 连接层判定不可达时交付给行级的原因文案:说清是运维故障,不是这行数据的问题。 */
static final String REASON_LLM_UNREACHABLE = "LLM 服务不可达(连接未建立,非本行数据问题)";
private static final String APPEARANCE_ANOMALY = "外观识别异常";
private static final String APPEARANCE_ANOMALY = AppearancePatentRowOutcome.APPEARANCE_ANOMALY;
/**
* 我们<b>根本没发出图片请求</b>时的外观维标签(无图片/无标题,或商标维先失败跳过外观那一步)。
* 与 {@link #APPEARANCE_ANOMALY}(发了请求、上游没给出可用结论)必须分开:
* 2026-11-12 任务 34061 的交付件里 987 行外观维写着「外观识别异常」、而「外观原因」整格空白,
* 用户只能把它读成图片识别没认出来,真实原因(LLM 上游欠费、外观那一步压根没跑)得运维去翻日志。
*/
static final String APPEARANCE_NOT_RUN = "未执行外观检测";
static final String APPEARANCE_NOT_RUN = AppearancePatentRowOutcome.APPEARANCE_NOT_RUN;
/** 商标维命中但外观维没跑时的结论后缀(结论列不许写成裸「侵权」,见 {@link #buildConclusion})。 */
static final String APPEARANCE_NOT_RUN_SUFFIX = "外观维未执行";
static final String APPEARANCE_SKIPPED_NO_DATA = "未执行外观检测:本行没有标题或图片链接,未发出图片识别请求";
static final String PATENT_SKIPPED_REASON = "未执行专利检测:外观维未执行";
/** 商标维先失败时跳过外观那一步的原因前缀,后面接商标维自己的原话。 */
@@ -1250,9 +1254,17 @@ public class AppearancePatentLlmClient {
}
String buildConclusion(String titleRisk, String appearanceRisk, String fallbackConclusion) {
if (isInfringement(titleRisk) || isInfringement(appearanceRisk)) {
if (isInfringement(appearanceRisk)) {
return INFRINGEMENT;
}
if (isInfringement(titleRisk)) {
// 商标维命中是真的(品牌库确实回了词),但外观维压根没跑时不许把整行结论写成裸「侵权」:
// 34061 里 158 行就是这么变成「成功」的——图片识别一次没做,结论列却只说侵权。
// 写成「商标侵权·外观维未执行」既保住命中的信息,又让它读起来就是一次没跑完的检测。
return hasAppearanceVerdict(appearanceRisk)
? INFRINGEMENT
: "商标" + INFRINGEMENT + APPEARANCE_NOT_RUN_SUFFIX;
}
if (isNoInfringement(titleRisk) && isNoInfringement(appearanceRisk)) {
return NO_INFRINGEMENT;
}
@@ -1268,6 +1280,14 @@ public class AppearancePatentLlmClient {
return firstNonBlank(fallbackConclusion, "");
}
/** 外观维真的判过才配当"整行结论"的一半;判据与出表侧同一句话。 */
private boolean hasAppearanceVerdict(String appearanceRisk) {
String normalized = normalize(appearanceRisk);
return !normalized.isBlank()
&& !AppearancePatentSheetBuilder.isTechnicalLlmFailure(normalized)
&& !AppearancePatentRowOutcome.isNoVerdictText(normalized);
}
private static final Pattern NO_INFRINGEMENT_WORDING = Pattern.compile(
"(?:无侵权|未侵权|不侵权|没有侵权|非侵权|(?:未发现|无明显|不存在|不构成|未构成|不涉及|未涉及)[^。;;]*侵权)"); // 否定措辞优先,裸 contains("侵权") 会反判
private boolean isInfringement(String value) {
@@ -194,7 +194,7 @@ public class AppearancePatentLlmBatchPipeline {
apiHost, () -> llmClient.inspectRows(batchRows, prompt, apiKey));
} catch (Exception ex) {
String message = firstNonBlank(ex.getMessage(), "LLM 检测失败");
if (AppearancePatentResultJobSupport.isFatalLlmArrearsFailure(message)) {
if (AppearancePatentResultJobSupport.isFatalCredentialFailure(message)) {
fatalLlmMessage = message;
}
log.warn("[appearance-patent] llm batch failed taskId={} jobId={} rows={} batch={}/{} fatalLlmArrears={} err={}",
@@ -240,7 +240,7 @@ public class AppearancePatentLlmBatchPipeline {
// 按次付费买出口 IP(2026-10-27 B46 现网形状)。所以这里既停批(不再发下一批),
// 又把「落终态」交给宿主:FileTaskMapper 与收尾口径在它手里,且这一步发生在
// 作业执行线程,不是心跳线程(铁律 8)。
log.warn("[appearance-patent] LLM 上游欠费/密钥失效,停止后续批次并把任务落终态"
log.warn("[appearance-patent] LLM 上游欠费/密钥失效或代理不可用,停止后续批次并把任务落终态"
+ " taskId={} jobId={} batch={}/{} pendingRows={} err={}",
task.getId(), job.getId(), batchIndex, batchTotal,
Math.max(0, submitLimit - i), fatalLlmMessage);
@@ -2,7 +2,6 @@ package com.nanri.aiimage.modules.appearancepatent.service.support;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.retry.LlmBalanceGuard;
import com.nanri.aiimage.common.task.TaskStatuses;
import com.nanri.aiimage.common.task.GroupResultPropagator;
import com.nanri.aiimage.config.AppearancePatentProperties;
@@ -23,10 +22,11 @@ import com.nanri.aiimage.modules.task.model.entity.FileTaskEntity;
import com.nanri.aiimage.modules.task.model.entity.TaskChunkEntity;
import com.nanri.aiimage.modules.task.model.entity.TaskFileJobEntity;
import com.nanri.aiimage.modules.task.model.entity.TaskScopeStateEntity;
import com.nanri.aiimage.common.retry.CredentialFatalClassifier;
import com.nanri.aiimage.modules.task.service.CredentialFatalTaskCloser;
import com.nanri.aiimage.modules.task.service.TaskDistributedLockService;
import com.nanri.aiimage.modules.task.service.TaskFileJobService;
import com.nanri.aiimage.modules.task.service.TaskFinalizeSupport;
import com.nanri.aiimage.modules.task.service.TaskRetryEligibility;
import com.nanri.aiimage.modules.task.service.support.TaskFailureLedger;
import lombok.extern.slf4j.Slf4j;
import org.apache.poi.xssf.streaming.SXSSFWorkbook;
@@ -52,6 +52,8 @@ public class AppearancePatentResultJobSupport {
private static final String STATUS_RUNNING = TaskStatuses.FileTask.RUNNING;
private static final String STATUS_FAILED = TaskStatuses.FileTask.FAILED;
/** 日志前缀与模块内其余落点同形。 */
private static final String LOG_TAG = "appearance-patent";
private static final String CONTENT_TYPE_XLSX = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
private static final String CONTENT_TYPE_ZIP = "application/zip";
@@ -265,18 +267,19 @@ public class AppearancePatentResultJobSupport {
}
/**
* 只认「上游账户欠费 / LLM 密钥失效」这一类不可自愈的失败。分类口径复用
* {@link TaskRetryEligibility}(它已经是"不可抗力不克隆重跑"的唯一判据),不再抄第二份字面量表。
* 只认「凭据不可自愈」这一类失败:上游 LLM 账户欠费/密钥失效、代理提取套餐/链接不可用。
* 判据在 {@link CredentialFatalClassifier} 一处(2026-11-12 起外观专利、货源、跟价、店铺采集、
* 采集数据共用它),不再抄第二份字面量表。
*
* <p>刻意只取 {@code BALANCE}:连接不可达({@code SERVICE_DOWN})、429 限流、5xx 抖动、
* 抓取缺口都属「外部会自己恢复或补传能救」,判宽了就是拿用户的任务给一次网络抖动陪葬。
* <p>刻意放行连通性失败({@code SERVICE_DOWN})、429 限流、5xx 抖动、通道被占、风控墙与抓取缺口:
* 它们属「外部会自己恢复或补传能救」,判宽了就是拿用户的任务给一次网络抖动陪葬。
*/
static boolean isFatalLlmArrearsFailure(String errorMessage) {
return TaskRetryEligibility.forceMajeureCategory(errorMessage) == TaskRetryEligibility.Category.BALANCE;
static boolean isFatalCredentialFailure(String errorMessage) {
return CredentialFatalClassifier.isFatal(errorMessage);
}
/**
* 上游余额欠费/密钥失效 → 任务<b>立即</b>落终态 FAILED。
* 凭据不可自愈 → 任务<b>立即</b>落终态 FAILED。
*
* <p>为什么必须由 Java 侧落终态(2026-10-27 现网):{@code f3445c21} 只做到「行级不再重试三次、
* 归因写对」,任务本身仍停在 RUNNING/WAIT_LLM 等 Python 继续回传分片。采集端
@@ -286,46 +289,14 @@ public class AppearancePatentResultJobSupport {
*
* <p>判定发生在作业执行线程(LLM 批次就在这里跑),不在心跳线程(铁律 8)。
* 写之前重读一次库里的现状态:已 SUCCESS/COMPLETED/CANCELLED/FAILED 的一律不动(铁律 14),
* 本方法因此可重入,停放期间同一任务被多个入口命中欠费也只写一次。
* 落库与文案在 {@link CredentialFatalTaskCloser},本方法因此可重入。
*/
public void terminalizeOnFatalLlmFailure(FileTaskEntity task, String failureMessage) {
if (task == null || task.getId() == null) {
return;
}
if (!isFatalLlmArrearsFailure(failureMessage)) {
// 兜底闸:调用方判宽了也不许把可恢复的失败写成终态
return;
}
FileTaskEntity current = fileTaskMapper.selectById(task.getId());
String currentStatus = current != null ? current.getStatus() : task.getStatus();
if (TaskStatuses.FileTask.TERMINAL.contains(currentStatus)) {
log.info("[appearance-patent] 任务已是终态,欠费归因不改写状态 taskId={} status={}",
task.getId(), currentStatus);
return;
}
String terminalMessage = fatalLlmTerminalMessage(failureMessage);
task.setStatus(STATUS_FAILED);
task.setSuccessFileCount(0);
task.setFailedFileCount(1);
task.setErrorMessage(terminalMessage);
task.setFailureCategory(TaskFailureLedger.categoryOf(task.getErrorMessage()));
task.setUpdatedAt(LocalDateTime.now());
task.setFinishedAt(LocalDateTime.now());
fileTaskMapper.updateById(task);
taskCacheService.deleteTaskCache(task.getId());
log.warn("[appearance-patent] LLM 上游欠费/密钥失效,任务落终态 FAILED 以停止为空转的行继续买出口 IP"
+ " taskId={} err={}", task.getId(), terminalMessage);
credentialFatalCloser().closeIfFatal(task, failureMessage);
}
/**
* 终态文案 = 生产者原文(客户端的欠费归因 + 上游 lastErr)+ 可执行动作,
* 原文一个字都不在这里重写;文案里没有「稍后重试」,欠费不会被说成抖动。
*/
static String fatalLlmTerminalMessage(String failureMessage) {
String raw = failureMessage == null ? "" : failureMessage.trim();
return raw.isEmpty()
? LlmBalanceGuard.TASK_TERMINAL_GUIDANCE
: raw + ";" + LlmBalanceGuard.TASK_TERMINAL_GUIDANCE;
private CredentialFatalTaskCloser credentialFatalCloser() {
return new CredentialFatalTaskCloser(LOG_TAG, fileTaskMapper, taskCacheService::deleteTaskCache);
}
public FileResultEntity findOrCreateResultRecordForAssembly(FileTaskEntity task, int rowCount) {
@@ -44,6 +44,20 @@ public final class AppearancePatentRowOutcome {
public static final String NO_DATA_TEXT = "该行未采集到数据(标题与图片都没有),无法检测";
/**
* 「这一格不是判定,而是没判成」的三族文案(唯一定义处,客户端与出表侧都引这里)。
*
* <p>2026-11-12 任务 34061:上游 LLM 余额见底,外观维一步都没发出去,但这三族文案此前都被
* {@link #isUsableField} 当成「有结论」——覆盖率算满、状态列还可能写「成功」(回退行拿整条标题
* 去品牌库蒙到一个「侵权」)。用户口径:没跑就是没跑,行必须是失败。
*/
/** 商标维查询失败(含整批不可用的长文案),前缀保持不变:状态列与补检都按它判。 */
public static final String BRAND_QUERY_FAILED = "商标查询失败";
/** 我们<b>根本没发出图片请求</b>时的外观维标签。 */
public static final String APPEARANCE_NOT_RUN = "未执行外观检测";
/** 请求发出去了、上游没给出可用结论。 */
public static final String APPEARANCE_ANOMALY = "外观识别异常";
private AppearancePatentRowOutcome() {
}
@@ -65,7 +79,27 @@ public final class AppearancePatentRowOutcome {
public static boolean isUsableField(String value) {
String normalized = AppearancePatentSheetBuilder.normalize(value);
return !normalized.isBlank() && !AppearancePatentSheetBuilder.isTechnicalLlmFailure(normalized);
return !normalized.isBlank()
&& !AppearancePatentSheetBuilder.isTechnicalLlmFailure(normalized)
&& !isNoVerdictText(normalized);
}
/**
* 这一格是不是「没判成」而不是判定:商标查询失败、外观没跑、外观异常、未取得结果、未完成检测。
*
* <p>单独成方法是为了让"覆盖率算不算这行"与"状态列写不写成功"共用同一句话,
* 而不是两处各写一遍字面量(34061 里两处就各判各的:覆盖率算满,状态列写成功)。
*/
public static boolean isNoVerdictText(String value) {
String normalized = AppearancePatentSheetBuilder.normalize(value);
if (normalized.isBlank()) {
return true;
}
return normalized.contains(BRAND_QUERY_FAILED)
|| normalized.contains(APPEARANCE_NOT_RUN)
|| normalized.contains(APPEARANCE_ANOMALY)
|| normalized.contains(AppearancePatentSheetBuilder.NO_RESULT_TEXT)
|| normalized.contains(NOT_INSPECTED_TEXT);
}
/**
@@ -126,7 +126,7 @@ public final class AppearancePatentSheetBuilder {
row.createCell(col++).setCellValue(titleRiskCell);
row.createCell(col++).setCellValue(appearanceRiskCell);
row.createCell(col++).setCellValue(conclusionCell);
row.createCell(col).setCellValue(resolveResultStatus(conclusionCell));
row.createCell(col).setCellValue(resolveResultStatus(conclusionCell, appearanceRiskCell));
}
writeReasonSheet(workbook, headerStyle, rowsToWrite, resultMap, finder);
}
@@ -294,8 +294,29 @@ public final class AppearancePatentSheetBuilder {
* 历史缺陷:曾按「结论非空即成功」,于是结论列写着"商标查询失败"、状态列却写"成功"。
* 带 {@link #PENDING_REVIEW_SUFFIX} 的结论含「侵权」二字,必须排在字面判定之前判掉,
* 否则「外观无侵权·商标待复核」会被读成成功。
*
* <p>单参版本只看结论串,保留给只拿到结论的历史调用方与单测;出表侧走
* {@link #resolveResultStatus(String, String)},多读一眼外观维(34061 那 158 行就是这么漏的)。
*/
public static String resolveResultStatus(String conclusion) {
return resolveResultStatus(conclusion, null);
}
/**
* 状态列口径(带外观维读数):<b>外观检测压根没跑的行不许写「成功」</b>。
*
* <p>2026-11-12 任务 34061 的反面样本:上游 LLM 余额见底,外观维一步都没发出去,
* 但回退路拿整条原始标题去品牌库查了一次,命中「阿凡达」的行 titleRisk=侵权 ⇒ 结论列=侵权,
* 状态列于是写成「成功」——1000 行里有 158 行是"图片识别一次没做却显示成功"。
* 结论列含「侵权」是必要不充分条件:外观维必须真的给出过判定(不是「未执行外观检测」/
* 「外观识别异常」/「未取得检测结果」/技术性失败)。
*
* @param appearanceRisk 外观维格子最终写给用户的那串字;null=调用方只给结论(历史单参口径)
*/
public static String resolveResultStatus(String conclusion, String appearanceRisk) {
if (appearanceRisk != null && !hasAppearanceVerdict(appearanceRisk)) {
return "失败";
}
String normalized = conclusion == null ? "" : conclusion.trim();
if (normalized.isBlank() || isTechnicalLlmFailure(normalized)) {
return "失败";
@@ -306,6 +327,14 @@ public final class AppearancePatentSheetBuilder {
return normalized.contains("侵权") ? "成功" : "失败";
}
/** 外观维有没有真的判过:判据在 {@link AppearancePatentRowOutcome#isNoVerdictText},与覆盖率同一句话。 */
public static boolean hasAppearanceVerdict(String appearanceRisk) {
String normalized = normalize(appearanceRisk);
return !normalized.isBlank()
&& !isTechnicalLlmFailure(normalized)
&& !AppearancePatentRowOutcome.isNoVerdictText(normalized);
}
/**
* 只按当前直连 LLM 客户端会写入的文案判定技术性失败。早期 Coze 工作流特征串已随直连改造移除:
* 按 "coze" 子串匹配会把品牌词 "Cozee Bay" 误判成调用失败,真结论被清空。
@@ -63,6 +63,8 @@ import com.nanri.aiimage.modules.task.model.entity.TaskChunkEntity;
import com.nanri.aiimage.modules.task.model.entity.TaskFileJobEntity;
import com.nanri.aiimage.modules.task.model.entity.TaskResultItemEntity;
import com.nanri.aiimage.modules.task.model.entity.TaskScopeStateEntity;
import com.nanri.aiimage.common.retry.CredentialFatalClassifier;
import com.nanri.aiimage.modules.task.service.CredentialFatalTaskCloser;
import com.nanri.aiimage.modules.task.service.TaskDistributedLockService;
import com.nanri.aiimage.modules.task.service.TaskFileJobService;
import com.nanri.aiimage.modules.task.service.TaskHeartbeatPositionService;
@@ -979,6 +981,15 @@ public class CollectDataService extends AbstractFileTaskPipeline<CollectDataResu
return buildSubmitVo(task, result, chunkIndex, chunkTotal, request, 0);
}
// 凭据不可自愈(未配置代理/套餐到期/余额不足):这一批的品牌检测整批查不了,
// 后面每一批都会在同一条死路上再跑一遍。整单立即判死,让采集端下一跳收手
// (2026-11-12 用户口径「没余额要退成失败,且直接中断任务」)。
if (!brandOutcome.queryFailed().isEmpty() && closeOnFatalCredential(task, brandOutcome.reason())) {
// 内存里的 task 还停在上面刚翻成的 RUNNING,收口器只改了库里的行。
// 回执里的 taskStatus 是采集端决定"还要不要下一批"的唯一信号,必须回读。
return buildSubmitVo(fileTaskMapper.selectById(taskId), result, chunkIndex, chunkTotal, request, 0);
}
CollectDataStats stats = loadStats(task);
stats.receivedRows += rows.size();
stats.currentChunkRows = rows.size();
@@ -1469,6 +1480,27 @@ public class CollectDataService extends AbstractFileTaskPipeline<CollectDataResu
return count != null && count > 0L;
}
/**
* 品牌检测整批查不了且原因不可自愈(未配置代理/套餐耗尽/密钥不可用)→ 整单判死。
*
* <p>为什么不能只留下 `brandQueryFailedCount` 让它跑成成功:2026-11-12 的用户口径是
* 「没余额要退成失败」——那一整批行既不进结果也不算无效品牌,用户拿到的是一张空表 +
* 一句「会在补测轮重试」,而补测轮对配置类原因重跑一万次都一样(现网 32573 两轮 0 净增)。
* 判据共用 {@link CredentialFatalClassifier};冷却/出口被拒/上游不可用照旧只补测不判死。
*
* @return true=本次已把任务写成终态
*/
private boolean closeOnFatalCredential(FileTaskEntity task, String rawReason) {
CredentialFatalClassifier.Kind kind = CredentialFatalClassifier.kind(rawReason);
if (kind == null) {
return false;
}
log.warn("[collect-data] 品牌检测命中凭据不可自愈({}),整单改判死 taskId={} reason={}",
kind, task.getId(), rawReason);
return new CredentialFatalTaskCloser("collect-data", fileTaskMapper, null)
.close(task, rawReason, kind);
}
private CollectDataSubmitResultVo buildSubmitVo(FileTaskEntity task,
FileResultEntity result,
int chunkIndex,
@@ -33,6 +33,8 @@ import com.nanri.aiimage.modules.task.model.entity.FileResultEntity;
import com.nanri.aiimage.modules.task.model.entity.FileTaskEntity;
import com.nanri.aiimage.modules.task.model.entity.TaskFileJobEntity;
import com.nanri.aiimage.modules.task.service.AbstractModuleTaskCacheService;
import com.nanri.aiimage.common.retry.CredentialFatalClassifier;
import com.nanri.aiimage.modules.task.service.CredentialFatalTaskCloser;
import com.nanri.aiimage.modules.task.service.TaskDistributedLockService;
import com.nanri.aiimage.modules.task.service.TaskFileJobService;
import com.nanri.aiimage.modules.task.service.TaskFinalizeSupport;
@@ -2216,6 +2218,15 @@ public class PriceTrackTaskService extends AbstractShopPayloadTaskPipeline<Price
}
private void updateTaskStatusFromLatestRows(FileTaskEntity task, List<FileResultEntity> latest) {
// 凭据不可自愈(LLM 欠费/密钥失效、代理套餐/链接不可用):整单立即判死,
// 不等剩余店铺跑完——剩下的每一家都会在同一条死路上再跑一遍,白等还白烧出口
// (2026-11-12 用户口径「没余额要退成失败,且直接中断任务」)。
if (closeOnFatalCredential(task, latest)) {
// 内存里的 task.status 还是 RUNNING(收口器只改了库),清缓存要按刚落定的终态问
cleanupTaskCacheIfTerminal(task.getId(), "FAILED");
priceTrackLoopRunService.syncLoopRunAfterChildTerminal(task.getId());
return;
}
String oldStatus = task.getStatus();
int ok = 0;
int fail = 0;
@@ -2297,6 +2308,34 @@ public class PriceTrackTaskService extends AbstractShopPayloadTaskPipeline<Price
}
}
/**
* 任一结果行带着「不可自愈的凭据故障」就整单判死。
*
* <p>行级 error 是客户端回传的原话(LLM 欠费的 403 原文、代理套餐到期、未配置代理),
* 判据共用 {@link CredentialFatalClassifier}——跟价与外观专利、货源的判据必须是同一套,
* 否则同一句话在两面一边判死一边继续跑。库里已是终态时返回 false,交回既有行账逻辑(铁律 14)。
*/
private boolean closeOnFatalCredential(FileTaskEntity task, List<FileResultEntity> latest) {
if (task == null || latest == null || latest.isEmpty()) {
return false;
}
for (FileResultEntity row : latest) {
String error = row == null ? null : row.getErrorMessage();
CredentialFatalClassifier.Kind kind = CredentialFatalClassifier.kind(error);
if (kind == null) {
continue;
}
log.warn("[price-track] 结果行命中凭据不可自愈({}),整单改判死 taskId={} err={}",
kind, task.getId(), error);
return credentialFatalCloser().close(task, error, kind);
}
return false;
}
private CredentialFatalTaskCloser credentialFatalCloser() {
return new CredentialFatalTaskCloser("price-track", fileTaskMapper, null);
}
private boolean isResultAwaitingFileAssembly(FileResultEntity result, TaskFileJobEntity job) {
if (result == null) {
return false;
@@ -57,6 +57,17 @@ public class ShopDataCrawlResultItemVo {
@Schema(description = "抓取或任务失败原因;无错误时为空", example = "紫鸟页面加载超时")
private String error;
/**
* 任务级失败原因(截断 300 字),只在任务落 FAILED 时带。
*
* <p>为什么不能只靠上面那个行级 {@code error}:凭据不可自愈(未配置代理/套餐到期/LLM 欠费)
* 是<b>整单</b>判死(2026-11-12 铁律 29),收口器只写 {@code biz_file_task.error_message},
* 每个店铺行本身没有被标失败。没有这个字段,用户端在终态那刻拿不到任何原因,
* 「已中断」就变成一句话都不说的静默失败。
*/
@Schema(description = "任务级失败原因(整单判死时为那句话,截断 300 字);任务未失败时为空", example = "任务已终止:代理 IP 套餐已到期…")
private String taskErrorMessage;
@Schema(description = "结果记录创建时间,ISO 本地日期时间", example = "2026-07-25T10:00:00")
private LocalDateTime createdAt;
@@ -41,6 +41,8 @@ import com.nanri.aiimage.modules.task.model.entity.FileTaskEntity;
import com.nanri.aiimage.modules.task.model.entity.TaskFileJobEntity;
import com.nanri.aiimage.modules.task.model.entity.TaskScopeStateEntity;
import com.nanri.aiimage.modules.task.service.AbstractModuleTaskCacheService;
import com.nanri.aiimage.common.retry.CredentialFatalClassifier;
import com.nanri.aiimage.modules.task.service.CredentialFatalTaskCloser;
import com.nanri.aiimage.modules.task.service.TaskDistributedLockService;
import com.nanri.aiimage.modules.task.service.TaskFileJobService;
import com.nanri.aiimage.modules.task.service.TaskFinalizeSupport;
@@ -102,6 +104,8 @@ public class ShopDataCrawlTaskService extends AbstractFileTaskPipeline<ShopDataC
private static final int MAX_DAILY_AGGREGATION_ATTEMPTS = 3;
/** 历史列表单页条数上限。 */
private static final int HISTORY_MAX_PAGE_SIZE = 100;
/** 进度批量里任务级失败原因的截断长度:够说清是哪一处要改,不把轮询响应体撑大。 */
private static final int TASK_FAILED_REASON_MAX = 300;
private static final String INTERRUPTED_MESSAGE = "Python 在该店铺结果提交完成前中断";
private static final String PARTIAL_RESULT_MESSAGE = "Python 中断,已保留已回传的部分数据";
private static final String RESULT_CHUNK_SCOPE_PREFIX = "result-chunks:";
@@ -807,6 +811,11 @@ public class ShopDataCrawlTaskService extends AbstractFileTaskPipeline<ShopDataC
mergePayloadIntoSnapshot(snapshot, cached);
if (!blank(cached.getError())) {
// 凭据不可自愈(代理套餐/链接不可用、LLM 欠费):整单立即判死。
// 剩下的店铺会在同一条死路上各跑一遍,白等还白烧出口(2026-11-12 用户口径)。
if (closeOnFatalCredential(task, cached.getError())) {
return true;
}
markResultFailed(row, cached.getError());
applyFailureToSnapshot(snapshot, cached.getError());
taskCacheService.removeShopMergedPayload(taskId, row.getSourceFilename());
@@ -1393,6 +1402,7 @@ public class ShopDataCrawlTaskService extends AbstractFileTaskPipeline<ShopDataC
item.setTaskStatus(task == null ? null : task.getStatus());
item.setSuccess(toSuccessFlag(row.getSuccess(), null));
item.setError(row.getErrorMessage());
item.setTaskErrorMessage(taskFailedReason(task));
item.setCreatedAt(row.getCreatedAt());
item.setFinishedAt(task == null ? null : task.getFinishedAt());
item.setOutputFilename(row.getResultFilename());
@@ -1403,6 +1413,23 @@ public class ShopDataCrawlTaskService extends AbstractFileTaskPipeline<ShopDataC
return list;
}
/**
* 任务级失败原因,只给已 FAILED 的任务带(截断 300 字)。
*
* <p>整单判死(凭据不可自愈)只写 {@code biz_file_task.error_message},每个店铺行本身没有被标失败,
* 所以进度批量必须把这句话带出去,否则用户端在终态那刻拿不到任何原因。
*/
private static String taskFailedReason(FileTaskEntity task) {
if (task == null || !"FAILED".equals(task.getStatus())) {
return null;
}
String message = task.getErrorMessage();
if (message == null || message.isBlank()) {
return null;
}
return message.length() <= TASK_FAILED_REASON_MAX ? message : message.substring(0, TASK_FAILED_REASON_MAX);
}
private Map<Long, ShopDataCrawlResultItemVo> indexSnapshotByResultId(List<ShopDataCrawlResultItemVo> snapshots) {
Map<Long, ShopDataCrawlResultItemVo> map = new LinkedHashMap<>();
if (snapshots == null) {
@@ -1416,6 +1443,23 @@ public class ShopDataCrawlTaskService extends AbstractFileTaskPipeline<ShopDataC
return map;
}
/**
* 店铺级 error 命中「不可自愈的凭据故障」就整单判死(2026-11-12 用户口径:没余额/没代理要退成失败
* 且直接中断)。判据共用 {@link CredentialFatalClassifier},与外观专利、货源、跟价同一套。
*
* @return true=本次已把任务写成终态(调用方立即返回,别再用行账覆盖)
*/
private boolean closeOnFatalCredential(FileTaskEntity task, String rowError) {
CredentialFatalClassifier.Kind kind = CredentialFatalClassifier.kind(rowError);
if (kind == null) {
return false;
}
log.warn("[shop-data-crawl] 店铺回传命中凭据不可自愈({}),整单改判死 taskId={} err={}",
kind, task.getId(), rowError);
return new CredentialFatalTaskCloser("shop-data-crawl", fileTaskMapper, null)
.close(task, rowError, kind);
}
private void updateTaskStatusFromRows(FileTaskEntity task, List<FileResultEntity> rows) {
long successCount = rows.stream().filter(row -> Integer.valueOf(RESULT_SUCCESS).equals(row.getSuccess())).count();
long failedCount = rows.stream().filter(row -> Integer.valueOf(RESULT_FAILED).equals(row.getSuccess())).count();
@@ -8,7 +8,6 @@ import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.common.retry.LlmBalanceGuard;
import com.nanri.aiimage.common.task.TaskStatuses;
import com.nanri.aiimage.common.task.LockSkipWitness;
import com.nanri.aiimage.common.service.DistributedJobLockService;
@@ -67,11 +66,12 @@ import com.nanri.aiimage.modules.task.model.entity.FileTaskEntity;
import com.nanri.aiimage.modules.task.model.entity.TaskFileJobEntity;
import com.nanri.aiimage.modules.task.model.entity.TaskChunkEntity;
import com.nanri.aiimage.modules.task.model.entity.TaskScopeStateEntity;
import com.nanri.aiimage.common.retry.CredentialFatalClassifier;
import com.nanri.aiimage.modules.task.service.CredentialFatalTaskCloser;
import com.nanri.aiimage.modules.task.service.TaskFileJobService;
import com.nanri.aiimage.modules.task.service.TaskDistributedLockService;
import com.nanri.aiimage.modules.task.service.TaskHeartbeatPositionService;
import com.nanri.aiimage.modules.task.service.TaskProgressSnapshotService;
import com.nanri.aiimage.modules.task.service.TaskRetryEligibility;
import com.nanri.aiimage.modules.task.service.support.TaskFailureLedger;
import com.nanri.aiimage.modules.task.service.TaskVisibleFailureNotice;
import com.nanri.aiimage.modules.task.service.TransientPayloadStorageService;
@@ -113,6 +113,8 @@ import java.util.function.Supplier;
public class SimilarAsinTaskService implements SimilarAsinPipelineHost {
public static final String MODULE_TYPE = "SIMILAR_ASIN";
/** 日志前缀(共用件的日志里要能分清是哪一面落的口)。 */
private static final String LOG_TAG = "similar-asin";
private static final String STATUS_PENDING = "PENDING";
private static final String STATUS_RUNNING = "RUNNING";
private static final String STATUS_SUCCESS = "SUCCESS";
@@ -1591,49 +1593,23 @@ public class SimilarAsinTaskService implements SimilarAsinPipelineHost {
}
/**
* 上游 LLM 账户欠费/密钥失效 → 任务<b>立即</b>落终态 FAILED(2026-10-31,口径与外观专利 2026-10-27 那条一致)。
* 凭据不可自愈(上游 LLM 账户欠费/密钥失效、代理套餐/链接不可用)→ 任务<b>立即</b>落终态 FAILED
* (2026-10-31 与外观专利同口径;2026-11-12 起判据与落库都收进共用件)。
*
* <p>为什么必须由 Java 侧落终态:{@code maixiang similar_worker} 只看 {@code /task/heartbeat} 的
* {@code alive}({@code similar_worker.py:249}),任务还停在 RUNNING 它就看不到判决,会继续为
* 永远进不了 LLM 的行<b>按次付费买出口 IP</b>。任务一终态,{@code TaskHeartbeatService} 才对该任务
* 回 {@code alive=false},worker 下一跳收手。
*
* <p>判据只取 {@link TaskRetryEligibility.Category#BALANCE}(欠费与 LLM 密钥失效同族,复用既有唯一
* 判据、不抄第二份字面量表):连接不可达(SERVICE_DOWN)、429 限流、5xx 抖动、抓取缺口都属
* "外部会自己恢复或补传能救",判宽了就是拿用户的整单给一次网络抖动陪葬。写之前重读库里现状态,
* 已终态的一律不动(铁律 14),本方法因此可重入。
* <p>判据在 {@link CredentialFatalClassifier}(唯一出处),落库与文案在
* {@link CredentialFatalTaskCloser};连接不可达、429 限流、5xx 抖动、通道被占、抓取缺口都属
* "外部会自己恢复或补传能救",不会被判死。写之前重读库里现状态,已终态的一律不动(铁律 14),
* 本方法因此可重入。
*/
@Override
public void terminalizeOnFatalLlmFailure(FileTaskEntity task, String failureMessage) {
if (task == null || task.getId() == null) {
return;
}
if (TaskRetryEligibility.forceMajeureCategory(failureMessage) != TaskRetryEligibility.Category.BALANCE) {
return;
}
FileTaskEntity current = fileTaskMapper.selectById(task.getId());
String currentStatus = current != null ? current.getStatus() : task.getStatus();
if (TaskStatuses.FileTask.TERMINAL.contains(currentStatus)) {
log.info("[similar-asin] 任务已是终态,欠费归因不改写状态 taskId={} status={}", task.getId(), currentStatus);
return;
}
String raw = failureMessage == null ? "" : failureMessage.trim();
task.setStatus(STATUS_FAILED);
task.setSuccessFileCount(0);
task.setFailedFileCount(1);
// 生产者原文一个字都不在这里重写(支持同学要对着上游响应体查根因);界面上那句中文由
// TaskVisibleFailureNotice 在出口处给,英文原文与上游账户号不进界面。
String terminalText = raw.isEmpty()
? LlmBalanceGuard.TASK_TERMINAL_GUIDANCE
: raw + ";" + LlmBalanceGuard.TASK_TERMINAL_GUIDANCE;
task.setErrorMessage(terminalText);
task.setFailureCategory(TaskFailureLedger.categoryOf(terminalText));
task.setUpdatedAt(LocalDateTime.now());
task.setFinishedAt(LocalDateTime.now());
fileTaskMapper.updateById(task);
taskCacheService.deleteTaskCache(task.getId());
log.warn("[similar-asin] LLM 上游欠费/密钥失效,任务落终态 FAILED 以停止为空转的行继续买出口 IP"
+ " taskId={} err={}", task.getId(), task.getErrorMessage());
new CredentialFatalTaskCloser(LOG_TAG, fileTaskMapper, taskCacheService::deleteTaskCache)
.closeIfFatal(task, failureMessage);
}
@Override
@@ -1,6 +1,7 @@
package com.nanri.aiimage.modules.similarasin.service.support;
import com.nanri.aiimage.modules.similarasin.model.dto.SimilarAsinResultRowDto;
import com.nanri.aiimage.common.retry.CredentialFatalClassifier;
import java.util.ArrayList;
import java.util.Collection;
@@ -152,6 +153,12 @@ public final class SimilarAsinResultTextSupport {
if (row == null) {
return "失败";
}
// 凭据不可自愈(LLM 欠费/密钥失效、代理套餐/链接不可用):图片采到了也没判过,
// 行必须是失败并带上真因——2026-11-12 用户口径「没余额要退成失败」。排在图片判定之前,
// 否则采集端拿到的货源图会把一行"从没检测过"的行染成成功。
if (CredentialFatalClassifier.isFatal(row.getError()) || CredentialFatalClassifier.isFatal(row.getReason())) {
return "失败";
}
if (hasText(row.getMainUrl()) || hasText(row.getPuzzleImg1()) || hasText(row.getPuzzleImg2())) {
return "成功";
}
@@ -0,0 +1,103 @@
package com.nanri.aiimage.modules.task.service;
import com.nanri.aiimage.common.retry.CredentialFatalClassifier;
import com.nanri.aiimage.common.task.TaskStatuses;
import com.nanri.aiimage.modules.task.mapper.FileTaskMapper;
import com.nanri.aiimage.modules.task.model.entity.FileTaskEntity;
import com.nanri.aiimage.modules.task.service.support.TaskFailureLedger;
import lombok.extern.slf4j.Slf4j;
import java.time.LocalDateTime;
import java.util.function.LongConsumer;
/**
* 凭据不可自愈(LLM 欠费/密钥失效、代理套餐/链接不可用)→ 任务<b>立即</b>落终态 FAILED。
*
* <p>为什么必须由 Java 侧落终态(2026-10-27 外观专利、2026-10-31 货源查询两笔现网的共同结论):
* 采集端只看 {@code /task/heartbeat} 的 {@code alive},看不到终态就会继续为那些永远进不了 LLM
* 的行<b>按次付费买出口 IP</b>。任务一终态,心跳对其返回 {@code alive=false},worker 下一跳收手。
* 2026-11-12 用户据此把这条从"外观专利/货源查询两步"扩成"所有涉及 LLM 密钥与代理 IP 的特性"。
*
* <p>判据与文案都从 {@link CredentialFatalClassifier} 取,本类只管"写下去"这一件事:
* 重读库里现状态(已终态的一律不动,铁律 14,因此可重入)、置 FAILED/successFileCount=0/
* failedFileCount=1/errorMessage/failureCategory/finishedAt、清模块缓存。
*
* <p>无状态、按调用现取(与外观专利 {@code resultJobSupport()} 同一先例):缓存清理是模块自己的事,
* 由调用方以 {@code cacheEvictor} 交进来,不在这个类里认任何一个模块的缓存实现。
*/
@Slf4j
public final class CredentialFatalTaskCloser {
private static final String STATUS_FAILED = TaskStatuses.FileTask.FAILED;
private final String logTag;
private final FileTaskMapper fileTaskMapper;
private final LongConsumer cacheEvictor;
/**
* @param logTag 模块日志前缀(如 {@code appearance-patent}),与各面既有日志同形
* @param cacheEvictor 模块任务缓存清理;没有就传 null
*/
public CredentialFatalTaskCloser(String logTag, FileTaskMapper fileTaskMapper, LongConsumer cacheEvictor) {
this.logTag = logTag;
this.fileTaskMapper = fileTaskMapper;
this.cacheEvictor = cacheEvictor;
}
/**
* 判据+落终态一步到位。
*
* @return true=本次真的把任务写成了终态;false=不致命或库里已是终态
*/
public boolean closeIfFatal(FileTaskEntity task, String failureMessage) {
CredentialFatalClassifier.Kind kind = CredentialFatalClassifier.kind(failureMessage);
return kind != null && close(task, failureMessage, kind);
}
/**
* 已确定档位时直接落终态(调用方自己已经判过,避免同一句话判两遍)。
*/
public boolean close(FileTaskEntity task, String failureMessage, CredentialFatalClassifier.Kind kind) {
if (task == null || task.getId() == null) {
return false;
}
if (kind == null) {
// 兜底闸:调用方判宽了也不许把可恢复的失败写成终态
return false;
}
FileTaskEntity current = fileTaskMapper.selectById(task.getId());
String currentStatus = current != null ? current.getStatus() : task.getStatus();
// 空状态的实体(测试/未落库形状)没有终态可言;TERMINAL 是不可变 Set,contains(null) 直接 NPE
if (currentStatus != null && TaskStatuses.FileTask.TERMINAL.contains(currentStatus)) {
log.info("[{}] 任务已是终态,凭据归因不改写状态 taskId={} status={}", logTag, task.getId(), currentStatus);
return false;
}
String terminalMessage = terminalMessage(failureMessage, kind);
task.setStatus(STATUS_FAILED);
task.setSuccessFileCount(0);
task.setFailedFileCount(1);
task.setErrorMessage(terminalMessage);
task.setFailureCategory(TaskFailureLedger.categoryOf(terminalMessage));
LocalDateTime now = LocalDateTime.now();
task.setUpdatedAt(now);
task.setFinishedAt(now);
fileTaskMapper.updateById(task);
if (cacheEvictor != null) {
cacheEvictor.accept(task.getId());
}
log.warn("[{}] 凭据不可自愈({}),任务落终态 FAILED 以停止为空转的行继续买出口 IP"
+ " taskId={} err={}", logTag, kind, task.getId(), terminalMessage);
return true;
}
/**
* 终态文案 = 生产者原文(支持同学要对着上游响应体查根因)+ 可执行动作。
* 原文一个字都不在这里重写;文案里没有「稍后重试」,欠费不会被说成抖动。
* 界面那一层由 {@link TaskVisibleFailureNotice} 换成纯中文动作句(原文里的账户号与余额不进界面)。
*/
public static String terminalMessage(String failureMessage, CredentialFatalClassifier.Kind kind) {
String raw = failureMessage == null ? "" : failureMessage.trim();
String guidance = CredentialFatalClassifier.guidance(kind);
return raw.isEmpty() ? guidance : raw + ";" + guidance;
}
}
@@ -50,11 +50,20 @@ public final class TaskRetryEligibility {
}
}
/** 余额/套餐类:覆盖 jikip 代理与 LLM 中转两种欠费文案。 */
/**
* 余额/套餐类:覆盖 jikip 代理与 LLM 中转两种欠费文案。
*
* <p>2026-11-12 补三族:① 钱包型欠费({@code insufficient_funds} / {@code wallet balance insufficient},
* 2026-11-11 现网形状,{@code LlmBalanceGuard} 已认、这里漏了,自动重试会照跑);② 代理套餐
* {@code 套餐到期};③ 根本没配代理(品牌检测回的原文,见 {@code BrandCheckClient.NO_PROXY_REASON})——
* 这三族都是「不修外部条件、重跑必然同结果」,放进本类才不会被 {@code TaskResumeService} 反复复位。
*/
private static final List<String> BALANCE_MARKERS = List.of(
"余额不足", "欠费", "套餐不存在", "套餐已过期", "套餐过期", "未开通",
"insufficient_user_quota", "insufficient_quota", "quota exceeded",
"预扣费额度");
"余额不足", "欠费", "套餐不存在", "套餐已过期", "套餐过期", "套餐到期", "未开通",
"insufficient_user_quota", "insufficient_quota", "insufficient_funds",
"wallet balance insufficient", "quota exceeded",
"预扣费额度",
"未配置代理", "代理地址为空", "代理链接为空");
/** LLM 密钥本身失效(区别于欠费)。 */
private static final List<String> KEY_MARKERS = List.of(
@@ -1,5 +1,6 @@
package com.nanri.aiimage.modules.task.service;
import com.nanri.aiimage.common.retry.CredentialFatalClassifier;
import com.nanri.aiimage.common.retry.LlmBalanceGuard;
import com.nanri.aiimage.modules.task.model.entity.FileTaskEntity;
@@ -34,7 +35,7 @@ public final class TaskVisibleFailureNotice {
*/
public static String forHistoryRow(FileTaskEntity task, String rowError) {
String stored = task == null ? null : task.getErrorMessage();
if (isFatalArrears(stored)) {
if (isWholeTaskVerdict(stored)) {
return forStoredMessage(stored);
}
String row = trimToNull(rowError);
@@ -46,11 +47,17 @@ public final class TaskVisibleFailureNotice {
if (raw == null) {
return null;
}
if (raw.contains(CredentialFatalClassifier.PROXY_TERMINAL_GUIDANCE)) {
// 代理侧那句是 2026-11-12 起由 CredentialFatalTaskCloser 写进尾巴的本仓文案:
// 前半截原文可能带着上游英文码与用户代理链接片段,同样不该进界面。换成本仓的纯中文句,
// 且必须是代理那一句——换成 LLM 那句就是 2026-10-27 用户点名要避免的误导。
return CredentialFatalClassifier.PROXY_TERMINAL_GUIDANCE;
}
return isFatalArrears(raw) ? LlmBalanceGuard.TASK_TERMINAL_GUIDANCE : raw;
}
/**
* 这条库里原文是不是<b>整单</b>的不可抗力结论(上游账户欠费 / LLM 密钥失效)。
* 这条库里原文是不是<b>整单</b>的不可抗力结论(上游账户/密钥欠费、代理套餐或链接不可用)。
*
* <p>收尾路径拿它决定「新文案能不能覆盖旧结论」:欠费判死的单后来被一次带空错误串的收尾
* 盖掉,界面上就又回到「只见失败、不见原因」,采集端也会以为这单还能跑。
@@ -60,8 +67,8 @@ public final class TaskVisibleFailureNotice {
}
/**
* 这条库里原文是不是<b>本仓自己写下</b>的 LLM 欠费/密钥失效归因(生产者句 {@code REASON_LLM_BALANCE_DUE}
* 或终态句 {@code TASK_TERMINAL_GUIDANCE} 命中其一)。
* 这条库里原文是不是<b>本仓自己写下</b>的凭据终态结论(LLM 那两句 {@code REASON_LLM_BALANCE_DUE} /
* {@code TASK_TERMINAL_GUIDANCE},或代理那句 {@code PROXY_TERMINAL_GUIDANCE})。
*
* <p>刻意<b>不</b>用 {@link TaskRetryEligibility.Category#BALANCE} 当这里的判据:那一类还涵盖
* jikip <b>代理 IP</b>欠费与套餐过期("余额不足"/"套餐不存在"),拿它换句子会把"代理出口没钱了"
@@ -73,7 +80,8 @@ public final class TaskVisibleFailureNotice {
return false;
}
return errorMessage.contains(LlmBalanceGuard.REASON_LLM_BALANCE_DUE)
|| errorMessage.contains(LlmBalanceGuard.TASK_TERMINAL_GUIDANCE);
|| errorMessage.contains(LlmBalanceGuard.TASK_TERMINAL_GUIDANCE)
|| errorMessage.contains(CredentialFatalClassifier.PROXY_TERMINAL_GUIDANCE);
}
private static String trimToNull(String value) {