feat(retry): B24 冷却扩围到「不回包/解密失败成片」两形

连接层冷却只认「会话没建立」,而现网 B26 的成片失败是连接已建立的两种形状:
对端在给出响应前收连接、HTTP 200 里行级结论带解密失败。给冷却表加第二条
证据道(同 host 分格、同窗长、同阈值 2),品牌客户端把两形都记进这条道:
不回包按异常即时记证;解密形状先批内开票,批终态只在零可结算结论时按票
记证——一枚干净结论就整票作废,脏品牌名的行级差异证据面保持不变。
冷却期快失败沿用既有整批分支,归因文案单独一条以便交付侧与取证区分。
This commit is contained in:
2026-10-26 14:01:26 +08:00
parent 1d4b4decf3
commit a3f765c458
4 changed files with 390 additions and 9 deletions
@@ -23,6 +23,14 @@ import java.util.concurrent.atomic.AtomicLong;
* {@link #recordConnectFailure}(返回 true 的那方打一条进入冷却的 warn); * {@link #recordConnectFailure}(返回 true 的那方打一条进入冷却的 warn);
* 连接成功或"连上了没答好"(读超时/5xx/解析失败)记 {@link #recordConnected} 清零证据。 * 连接成功或"连上了没答好"(读超时/5xx/解析失败)记 {@link #recordConnected} 清零证据。
* 窗长 {@code <= 0} 表示关闭冷却,全部方法退化为无操作——调用方退回各自的调用内短路行为。 * 窗长 {@code <= 0} 表示关闭冷却,全部方法退化为无操作——调用方退回各自的调用内短路行为。
*
* <p>第二条证据道(B24 扩围,2026-10-26 拍板):{@link #recordNoAnswerFailure} 收的是
* 「连接已建立、但对端没给出可结算的响应」——现网两个形状(BACKLOG B26):16890 卡死后
* 在给出响应前收连接({@code header parser received no bytes}),以及 HTTP 200 里
* {@code query_faild_data} 成片带解密失败。两形都按次即时记证:任何一次可结算结论
* (干净返回/命中侵权/余额不足)都把证据清零,脏品牌名混在好品牌里永远攒不满两条。
* no-answer 道与 connect 道分账:{@link #recordConnected} 只清 connect 证据,
* no-answer 证据由 {@link #clearNoAnswerEvidence} 在调用方自己的批次语义里清。
*/ */
@Component @Component
public class UnreachableCooldown { public class UnreachableCooldown {
@@ -38,6 +46,8 @@ public class UnreachableCooldown {
private static final class State { private static final class State {
final AtomicInteger evidence = new AtomicInteger(); final AtomicInteger evidence = new AtomicInteger();
final AtomicLong cooldownUntilMillis = new AtomicLong(); final AtomicLong cooldownUntilMillis = new AtomicLong();
final AtomicInteger noAnswerEvidence = new AtomicInteger();
final AtomicLong noAnswerCooldownUntilMillis = new AtomicLong();
} }
/** /**
@@ -56,13 +66,31 @@ public class UnreachableCooldown {
return false; return false;
} }
/** 该 host 是否正处冷却窗内:true 时调用方不发请求,直接按既有不可达归因文案快速失败。 */ /** 该 host 是否正处冷却窗内(connect 道或 no-answer 道任一):true 时调用方不发请求,直接按既有不可达归因文案快速失败。 */
public boolean isCoolingDown(String host, long windowMillis) { public boolean isCoolingDown(String host, long windowMillis) {
return connectLaneCooling(host, windowMillis) || noAnswerLaneCooling(host, windowMillis);
}
/** 只问 connect 道:品牌客户端据此在两条快失败分支里选归因文案;两道的窗口径一致。 */
public boolean connectLaneCooling(String host, long windowMillis) {
return laneCooling(host, windowMillis, true);
}
/** 只问 no-answer 道(B24 扩围):品牌客户端据此选用「不回包/解密成片」的归因文案。 */
public boolean noAnswerLaneCooling(String host, long windowMillis) {
return laneCooling(host, windowMillis, false);
}
private boolean laneCooling(String host, long windowMillis, boolean connectLane) {
if (windowMillis <= 0) { if (windowMillis <= 0) {
return false; return false;
} }
State state = states.get(normalizeHost(host)); State state = states.get(normalizeHost(host));
return state != null && state.cooldownUntilMillis.get() > System.currentTimeMillis(); if (state == null) {
return false;
}
AtomicLong until = connectLane ? state.cooldownUntilMillis : state.noAnswerCooldownUntilMillis;
return until.get() > System.currentTimeMillis();
} }
/** /**
@@ -72,22 +100,37 @@ public class UnreachableCooldown {
* 调用方据此打一条进入冷却的 warn,期中快失败不刷屏 * 调用方据此打一条进入冷却的 warn,期中快失败不刷屏
*/ */
public boolean recordConnectFailure(String host, long windowMillis) { public boolean recordConnectFailure(String host, long windowMillis) {
return openWindow(host, windowMillis, true);
}
/**
* no-answer 道证据 +1(B24 扩围):形状由调用方判定——异常侧认「对端在给出响应前
* 关闭连接」,响应侧认「行级结论带解密失败」。窗长/阈值/到期语义与 connect 道同款
* (同格到期一次失败即重进)。
*/
public boolean recordNoAnswerFailure(String host, long windowMillis) {
return openWindow(host, windowMillis, false);
}
private boolean openWindow(String host, long windowMillis, boolean connectLane) {
if (windowMillis <= 0) { if (windowMillis <= 0) {
return false; return false;
} }
State state = states.computeIfAbsent(normalizeHost(host), key -> new State()); State state = states.computeIfAbsent(normalizeHost(host), key -> new State());
if (state.evidence.incrementAndGet() < EVIDENCE_THRESHOLD) { AtomicInteger evidence = connectLane ? state.evidence : state.noAnswerEvidence;
if (evidence.incrementAndGet() < EVIDENCE_THRESHOLD) {
return false; return false;
} }
long now = System.currentTimeMillis(); long now = System.currentTimeMillis();
long previous = state.cooldownUntilMillis.get(); AtomicLong until = connectLane ? state.cooldownUntilMillis : state.noAnswerCooldownUntilMillis;
long previous = until.get();
if (previous > now) { if (previous > now) {
return false; return false;
} }
return state.cooldownUntilMillis.compareAndSet(previous, now + windowMillis); return until.compareAndSet(previous, now + windowMillis);
} }
/** 连接成功或"连上了没答好":证据清零(已开的冷却窗不受影响,等它自然到期)。 */ /** 连接成功或"连上了没答好":connect 道证据清零(已开的冷却窗不受影响,等它自然到期)。 */
public void recordConnected(String host) { public void recordConnected(String host) {
State state = states.get(normalizeHost(host)); State state = states.get(normalizeHost(host));
if (state != null) { if (state != null) {
@@ -95,6 +138,14 @@ public class UnreachableCooldown {
} }
} }
/** no-answer 道证据清零:批次里出现任何一次可结算结论即「服务活着」,重新攒两次证据。 */
public void clearNoAnswerEvidence(String host) {
State state = states.get(normalizeHost(host));
if (state != null) {
state.noAnswerEvidence.set(0);
}
}
/** host 归一:两个 LLM 客户端配的同一网关必须落进同一格,别因尾斜杠/大小写裂成两份。 */ /** host 归一:两个 LLM 客户端配的同一网关必须落进同一格,别因尾斜杠/大小写裂成两份。 */
static String normalizeHost(String host) { static String normalizeHost(String host) {
String normalized = host == null ? "" : host.trim().toLowerCase(); String normalized = host == null ? "" : host.trim().toLowerCase();
@@ -72,6 +72,27 @@ public class BrandCheckClient {
private static final int CONNECT_FAILURE_EVIDENCE = 2; private static final int CONNECT_FAILURE_EVIDENCE = 2;
private static final String REASON_SERVICE_UNREACHABLE = "品牌检测服务不可达(连接未建立,非本行数据问题)"; private static final String REASON_SERVICE_UNREACHABLE = "品牌检测服务不可达(连接未建立,非本行数据问题)";
/**
* 「连上了但不回包」的形状指纹(B24 扩围,2026-10-26 拍板):JDK HttpClient 在对端
* 给出响应前关闭连接时抛的两句原文(2026-10-24 现网 B→A:16890 87/88 条是前者)。
* 读超时不算——那仍是"慢",2026-10-24 立账时按口径故意留在重试有意义的一侧。
*/
private static final java.util.regex.Pattern PEER_CLOSED_WITHOUT_RESPONSE =
java.util.regex.Pattern.compile("header parser received no bytes|EOF reached while reading");
/**
* 「解密失败成片」的形状指纹:16890 侧解密/JSON 解析失败的行级 reason(现网三形——
* {@code 查询或解密失败: …Malformed UTF-8 data}/{@code Expecting value: line 1 column 1}
* /三层嵌套的旧版 {@code 解密失败:} 前缀,见 BACKLOG B26)。
*/
private static final java.util.regex.Pattern DECRYPT_FAILURE_REASON =
java.util.regex.Pattern.compile("解密失败|Expecting value");
/** no-answer 道的解密失败条数:与 connect 道同数字,两次同形且整批零干净结论才是服务在掉。 */
private static final int NO_ANSWER_FAILURE_EVIDENCE = 2;
private static final String REASON_SERVICE_DEGRADED =
"品牌检测服务不可达(解密链路成片失败,非本行数据问题)";
/** /**
* 代理出口被上游拒绝的证据条数:同一批里已有这么多个品牌在换过出口后仍被拒, * 代理出口被上游拒绝的证据条数:同一批里已有这么多个品牌在换过出口后仍被拒,
* 后面的品牌不再发起首轮探针。2026-10-23 现网:16890 每个品牌最多换 2 个 IP, * 后面的品牌不再发起首轮探针。2026-10-23 现网:16890 每个品牌最多换 2 个 IP,
@@ -301,7 +322,7 @@ public class BrandCheckClient {
return outcomes; return outcomes;
} }
long cooldownMillis = Math.max(0, properties.getUnreachableCooldownMillis()); long cooldownMillis = Math.max(0, properties.getUnreachableCooldownMillis());
if (unreachableCooldown.isCoolingDown(properties.getBaseUrl(), cooldownMillis)) { if (unreachableCooldown.connectLaneCooling(properties.getBaseUrl(), cooldownMillis)) {
// 客户端级冷却(B24):上一批已确认连接层不可达,本批连首轮探针都不发。 // 客户端级冷却(B24):上一批已确认连接层不可达,本批连首轮探针都不发。
// 结论与批内短路版逐字一致(每行仍判查询失败、reason 同文案),差别只是不再为 // 结论与批内短路版逐字一致(每行仍判查询失败、reason 同文案),差别只是不再为
// "确认还是断的"每批各烧一轮连接探针;到期后下一批的真实请求兼作探针。 // "确认还是断的"每批各烧一轮连接探针;到期后下一批的真实请求兼作探针。
@@ -312,6 +333,17 @@ public class BrandCheckClient {
} }
return outcomes; return outcomes;
} }
if (unreachableCooldown.noAnswerLaneCooling(properties.getBaseUrl(), cooldownMillis)) {
// B24 扩围(2026-10-26 拍板):上一批已确认「连上了但不回包」或「解密链路成片失败」,
// 本批同样一个请求都不发。行级结论不变(每品牌仍判查询失败),只是归因从空 reason/
// 逐行白等 45~65 秒,换成一条可运维的服务级降级文案;到期后下一批的真实请求兼作探针。
log.warn("[brand-check] NO_ANSWER_COOLDOWN 客户端级冷却中(不回包/解密成片),整批不打上游"
+ " brands={} window={}ms", brands.size(), cooldownMillis);
for (String brand : brands) {
outcomes.put(brand, new BrandCheckOutcome(List.of(), List.of(brand), REASON_SERVICE_DEGRADED));
}
return outcomes;
}
long firstAttemptDeadlineNanos = deadlineNanos == Long.MAX_VALUE long firstAttemptDeadlineNanos = deadlineNanos == Long.MAX_VALUE
? Long.MAX_VALUE ? Long.MAX_VALUE
: deadlineNanos + FIRST_ATTEMPT_QUEUE_GRACE_MILLIS * 1_000_000L; : deadlineNanos + FIRST_ATTEMPT_QUEUE_GRACE_MILLIS * 1_000_000L;
@@ -325,6 +357,9 @@ public class BrandCheckClient {
AtomicInteger connectFailures = new AtomicInteger(); AtomicInteger connectFailures = new AtomicInteger();
// 出口被上游拒绝的证据跨品牌累计:达到阈值后不再给后续品牌发首轮探针。 // 出口被上游拒绝的证据跨品牌累计:达到阈值后不再给后续品牌发首轮探针。
AtomicInteger egressRejections = new AtomicInteger(); AtomicInteger egressRejections = new AtomicInteger();
// no-answer 道的解密形状批内计数(B24 扩围):批终态才记证,见 awaitOutcome 循环后的聚合。
AtomicInteger decryptFailures = new AtomicInteger();
AtomicBoolean sawCleanConclusion = new AtomicBoolean(false);
for (String brand : brands) { for (String brand : brands) {
AtomicBoolean started = new AtomicBoolean(false); AtomicBoolean started = new AtomicBoolean(false);
AtomicBoolean rejected = new AtomicBoolean(false); AtomicBoolean rejected = new AtomicBoolean(false);
@@ -335,7 +370,8 @@ public class BrandCheckClient {
() -> { () -> {
started.set(true); started.set(true);
return checkOneBrand(brand, strategy, deadlineNanos, upstreamRejecting, return checkOneBrand(brand, strategy, deadlineNanos, upstreamRejecting,
proxyUrl, userId, connectFailures, egressRejections); proxyUrl, userId, connectFailures, egressRejections,
decryptFailures, sawCleanConclusion);
}, },
checkExecutor); checkExecutor);
} finally { } finally {
@@ -355,6 +391,20 @@ public class BrandCheckClient {
outcomes.put(brands.get(index), awaitOutcome(brands.get(index), futures.get(index), outcomes.put(brands.get(index), awaitOutcome(brands.get(index), futures.get(index),
startedFlags.get(index), deadlineNanos, firstAttemptDeadlineNanos)); startedFlags.get(index), deadlineNanos, firstAttemptDeadlineNanos));
} }
// 批终态才动 no-answer 表(B24 扩围):一枚可结算结论就整票作废并清零,
// 零干净的批次按票数逐条记证(阈值 2 与 connect 道同数字)。本批请求不受影响——
// 冷却只掐后续批次,行级差异的证据面一字不动。
if (sawCleanConclusion.get()) {
unreachableCooldown.clearNoAnswerEvidence(properties.getBaseUrl());
} else {
for (int i = 0; i < decryptFailures.get(); i++) {
if (unreachableCooldown.recordNoAnswerFailure(properties.getBaseUrl(), cooldownMillis)) {
log.warn("[brand-check] NO_ANSWER_COOLDOWN 批内解密失败 {} 枚且零干净结论,"
+ "进入客户端级冷却 {}ms host={}",
decryptFailures.get(), cooldownMillis, properties.getBaseUrl());
}
}
}
return outcomes; return outcomes;
} }
@@ -366,7 +416,9 @@ public class BrandCheckClient {
private BrandCheckOutcome checkOneBrand(String brand, String strategy, long deadlineNanos, private BrandCheckOutcome checkOneBrand(String brand, String strategy, long deadlineNanos,
AtomicBoolean upstreamRejecting, String proxyUrl, Long userId, AtomicBoolean upstreamRejecting, String proxyUrl, Long userId,
AtomicInteger connectFailures, AtomicInteger connectFailures,
AtomicInteger egressRejections) { AtomicInteger egressRejections,
AtomicInteger decryptFailures,
AtomicBoolean sawCleanConclusion) {
int attempts = Math.max(1, properties.getRetryTimes()); int attempts = Math.max(1, properties.getRetryTimes());
BrandCheckResponse response = null; BrandCheckResponse response = null;
Exception lastFailure = null; Exception lastFailure = null;
@@ -428,6 +480,12 @@ public class BrandCheckClient {
CONNECT_FAILURE_EVIDENCE, brand, attempt, attempts, ex.getMessage()); CONNECT_FAILURE_EVIDENCE, brand, attempt, attempts, ex.getMessage());
break; break;
} }
} else if (isPeerClosedWithoutResponse(ex)) {
// 连上了、对端却在给出响应前把连接收了(B26 主形 header parser received no
// bytes):重试救不回这一形状,按 no-answer 道即时记证;本品牌照旧重试收尾。
log.warn("[brand-check] NO_ANSWER 对端在给出响应前关闭连接 brand={} attempt={}/{} err={}",
brand, attempt, attempts, ex.getMessage());
recordNoAnswerFailure();
} else { } else {
// 连上了只是这次没答好(读超时/解析失败):连接层证据不作数 // 连上了只是这次没答好(读超时/解析失败):连接层证据不作数
connectFailures.set(0); connectFailures.set(0);
@@ -444,6 +502,14 @@ public class BrandCheckClient {
// 拿到响应=连接是通的,证据清零,别跨到下一次真断连时凑数 // 拿到响应=连接是通的,证据清零,别跨到下一次真断连时凑数
connectFailures.set(0); connectFailures.set(0);
unreachableCooldown.recordConnected(properties.getBaseUrl()); unreachableCooldown.recordConnected(properties.getBaseUrl());
if (response != null && !nullToEmpty(response.getQueryFaildData()).isEmpty()
&& isDecryptFailure(response.getReason())) {
// 解密形状(B26 成片主形):先计一条批内票;是否在服务级记证由批终态聚合决定
// ——同批里只要有一枚可结算结论,就认定这是本行数据问题而不是服务在掉。
decryptFailures.incrementAndGet();
} else if (response != null) {
sawCleanConclusion.set(true);
}
if (response != null && nullToEmpty(response.getQueryFaildData()).isEmpty()) { if (response != null && nullToEmpty(response.getQueryFaildData()).isEmpty()) {
// 本次查询完成且无失败项:命中侵权(faild_data)属有效结论,不重试。 // 本次查询完成且无失败项:命中侵权(faild_data)属有效结论,不重试。
return new BrandCheckOutcome(nullToEmpty(response.getFaildData()), List.of(), ""); return new BrandCheckOutcome(nullToEmpty(response.getFaildData()), List.of(), "");
@@ -632,6 +698,37 @@ public class BrandCheckClient {
} }
} }
/** no-answer 道即时记证(不回包形状):达到阈值的那一方打进入冷却的 warn(B24 扩围)。 */
private void recordNoAnswerFailure() {
long cooldownMillis = Math.max(0, properties.getUnreachableCooldownMillis());
if (unreachableCooldown.recordNoAnswerFailure(properties.getBaseUrl(), cooldownMillis)) {
log.warn("[brand-check] NO_ANSWER_COOLDOWN 不回包证据累计到阈值,进入客户端级冷却 {}ms host={}",
cooldownMillis, properties.getBaseUrl());
}
}
/**
* 「连上了但对端在给出响应前关闭连接」(B24 扩围):顺着 cause 链认
* {@link #PEER_CLOSED_WITHOUT_RESPONSE} 那两句 JDK HttpClient 原文。
* 与 {@link #isConnectFailure} 互斥(会话没建立的形状归连接道),读超时不算——
* 那侧注释在 B19 就写死了:慢≠掉。
*/
static boolean isPeerClosedWithoutResponse(Throwable error) {
for (Throwable t = error; t != null && t != t.getCause(); t = t.getCause()) {
String message = t.getMessage();
if (message != null && PEER_CLOSED_WITHOUT_RESPONSE.matcher(message).find()) {
return true;
}
}
return false;
}
/** 「解密链路失败」的行级 reason(B24 扩围):上游已回话、内容解不开,供批终态聚合判定。 */
static boolean isDecryptFailure(String reason) {
String trimmed = reason == null ? "" : reason.trim();
return !trimmed.isEmpty() && DECRYPT_FAILURE_REASON.matcher(trimmed).find();
}
/** /**
* 连接层判定下沉 {@code UnreachableCooldown.isConnectFailure}(B24):判定口径与 * 连接层判定下沉 {@code UnreachableCooldown.isConnectFailure}(B24):判定口径与
* 两个 LLM 客户端共用一份,不再各留包内副本。 * 两个 LLM 客户端共用一份,不再各留包内副本。
@@ -74,4 +74,82 @@ class UnreachableCooldownTest {
assertThat(UnreachableCooldown.isConnectFailure(new RuntimeException("read timeout"))).isFalse(); assertThat(UnreachableCooldown.isConnectFailure(new RuntimeException("read timeout"))).isFalse();
assertThat(UnreachableCooldown.isConnectFailure(null)).isFalse(); assertThat(UnreachableCooldown.isConnectFailure(null)).isFalse();
} }
// ---- no-answer 道(B24 扩围,2026-10-26 拍板):阈值/窗长/到期语义与 connect 道同款 ----
@Test
void twoNoAnswerFailuresEnterCooldownOneDoesNot() {
String host = "http://16890.example";
assertThat(cooldown.recordNoAnswerFailure(host, WINDOW)).isFalse();
assertThat(cooldown.isCoolingDown(host, WINDOW)).isFalse();
assertThat(cooldown.recordNoAnswerFailure(host, WINDOW)).isTrue();
assertThat(cooldown.noAnswerLaneCooling(host, WINDOW)).isTrue();
assertThat(cooldown.isCoolingDown(host, WINDOW)).isTrue();
}
@Test
void noAnswerWindowExpiresAndSingleFailureReenters() throws InterruptedException {
String host = "http://expire-16890.example";
cooldown.recordNoAnswerFailure(host, 50);
cooldown.recordNoAnswerFailure(host, 50);
assertThat(cooldown.noAnswerLaneCooling(host, 50)).isTrue();
Thread.sleep(120);
assertThat(cooldown.noAnswerLaneCooling(host, 50)).isFalse();
// 历史证据不清零:到期后批次再判成片,一次即重进(与 connect 道同拍板口径)
assertThat(cooldown.recordNoAnswerFailure(host, 50)).isTrue();
assertThat(cooldown.noAnswerLaneCooling(host, 50)).isTrue();
}
@Test
void clearNoAnswerEvidenceRequiresTwoFreshFailures() {
String host = "http://clear.example";
cooldown.recordNoAnswerFailure(host, WINDOW);
cooldown.clearNoAnswerEvidence(host);
assertThat(cooldown.recordNoAnswerFailure(host, WINDOW)).isFalse();
assertThat(cooldown.noAnswerLaneCooling(host, WINDOW)).isFalse();
}
@Test
void clearOnlyTouchesNoAnswerEvidenceAndNeverAnOpenedWindow() {
String host = "http://window-stays.example";
cooldown.recordNoAnswerFailure(host, WINDOW);
cooldown.recordNoAnswerFailure(host, WINDOW);
// 已开的窗不因清零提前放行:快失败只按窗长自然到期(connect 道同语义)
cooldown.clearNoAnswerEvidence(host);
assertThat(cooldown.noAnswerLaneCooling(host, WINDOW)).isTrue();
// 到期后靠那一次成片失败重进:清零历史后证据要重新攒满两条,这里只缺一条
cooldown.clearNoAnswerEvidence(host);
assertThat(cooldown.recordNoAnswerFailure(host, WINDOW)).isFalse();
}
@Test
void zeroWindowDisablesNoAnswerLaneToo() {
for (int i = 0; i < 5; i++) {
assertThat(cooldown.recordNoAnswerFailure("http://off.example", 0)).isFalse();
}
assertThat(cooldown.noAnswerLaneCooling("http://off.example", 0)).isFalse();
}
@Test
void connectLaneAndNoAnswerLaneAreSeparateAccounts() {
String host = "http://lanes.example";
cooldown.recordConnectFailure(host, WINDOW);
assertThat(cooldown.noAnswerLaneCooling(host, WINDOW)).isFalse();
cooldown.recordNoAnswerFailure(host, WINDOW);
// 两条道各计各的:一条 connect + 一条 no-answer 都不到阈值
assertThat(cooldown.connectLaneCooling(host, WINDOW)).isFalse();
assertThat(cooldown.noAnswerLaneCooling(host, WINDOW)).isFalse();
cooldown.recordConnectFailure(host, WINDOW);
assertThat(cooldown.connectLaneCooling(host, WINDOW)).isTrue();
assertThat(cooldown.noAnswerLaneCooling(host, WINDOW)).isFalse();
// recordConnected 只清 connect 证据;no-answer 证据必须活过它
cooldown.recordConnected(host);
assertThat(cooldown.recordNoAnswerFailure(host, WINDOW)).isTrue();
assertThat(cooldown.noAnswerLaneCooling(host, WINDOW)).isTrue();
assertThat(cooldown.connectLaneCooling(host, WINDOW)).isTrue();
}
} }
@@ -81,6 +81,161 @@ class BrandCheckClientTest {
} }
} }
// ---- B24 扩围(2026-10-26 拍板):冷却纳入「连上了不回包」与「解密失败成片」两形 ----
/**
* 「连上了但不回包」(B26 主形 {@code header parser received no bytes})按次记进 no-answer 道:
* 首批两条阶梯证据把窗打开,第二批整批快失败、零请求。行级结论仍是查询失败,
* 变的只有归因与耗时。
*/
@Test
void peerClosedWithoutResponseOpensCooldownAndNextBatchHitsZeroProbes() throws Exception {
AtomicInteger connections = new AtomicInteger();
ServerSocket listener = new ServerSocket(0, 16, java.net.InetAddress.getByName("127.0.0.1"));
Thread closer = new Thread(() -> {
while (!listener.isClosed()) {
try (java.net.Socket socket = listener.accept()) {
connections.incrementAndGet();
// 不读不写直接关:JDK HttpClient 在响应解析器处拿到 0 字节
} catch (IOException ignored) {
return;
}
}
}, "no-bytes-closer");
closer.setDaemon(true);
closer.start();
try {
UnreachableCooldown cooldown = new UnreachableCooldown();
BrandCheckProperties props = new BrandCheckProperties();
props.setBaseUrl("http://127.0.0.1:" + listener.getLocalPort());
props.setPath("/brand_check");
props.setRetryTimes(2);
props.setRetryIntervalMillis(1);
props.setUnreachableCooldownMillis(300_000);
BrandCheckClient client =
new BrandCheckClient(props, null, stubbedUserSecrets(), cooldown);
BrandCheckClient.BrandCheckBatchResult first =
client.checkAll(List.of("Apple"), "Terms", 7L);
assertThat(connections.get()).as("首批两条阶梯都真发(no-answer 不改本批重试形状)").isGreaterThanOrEqualTo(2);
assertThat(cooldown.noAnswerLaneCooling(props.getBaseUrl(), 300_000L)).isTrue();
assertThat(first.reason()).doesNotContain("解密链路成片失败");
int connectionsBefore = connections.get();
BrandCheckClient.BrandCheckBatchResult second =
client.checkAll(List.of("Nike"), "Terms", 7L);
assertThat(connections.get()).as("冷却期内一个请求都不该发").isEqualTo(connectionsBefore);
assertThat(second.queryFaildData()).containsExactly("Nike");
assertThat(second.reason()).contains("品牌检测服务不可达(解密链路成片失败,非本行数据问题)");
} finally {
listener.close();
}
}
/**
* 「解密失败成片」在批终态按票记证(阈值 2 与 connect 道同数字):一批两枚脏名真探
* (上游标了不可重试,白等已被既有短路掐住)即开窗,第二批准一个请求不发。
*/
@Test
void decryptShapedBatchOpensCooldownAndNextBatchHitsZeroProbes() throws Exception {
AtomicInteger requests = new AtomicInteger();
HttpServer server = startBrandCheckServer(exchange -> {
requests.incrementAndGet();
respond(exchange, "{\"faild_data\":[],\"query_faild_data\":[\"x\"],"
+ "\"reason\":\"查询或解密失败: 解密失败: Malformed UTF-8 data\",\"retryable\":false}");
});
try {
UnreachableCooldown cooldown = new UnreachableCooldown();
BrandCheckProperties props = new BrandCheckProperties();
props.setBaseUrl("http://127.0.0.1:" + server.getAddress().getPort());
props.setPath("/brand_check");
props.setRetryTimes(2);
props.setRetryIntervalMillis(1);
props.setUnreachableCooldownMillis(300_000);
BrandCheckClient client =
new BrandCheckClient(props, null, stubbedUserSecrets(), cooldown);
client.checkAll(List.of("Small)"), "Terms", 7L);
assertThat(cooldown.noAnswerLaneCooling(props.getBaseUrl(), 300_000L))
.as("一批只有一枚解密票:不到阈值不进冷却").isFalse();
client.checkAll(List.of("XX-Large)", "Small)"), "Terms", 7L);
assertThat(requests.get()).as("两批真发合计至少三枚请求").isGreaterThanOrEqualTo(3);
assertThat(cooldown.noAnswerLaneCooling(props.getBaseUrl(), 300_000L))
.as("零干净批次攒到两条解密票:进入冷却").isTrue();
int requestsBefore = requests.get();
BrandCheckClient.BrandCheckBatchResult cooled =
client.checkAll(List.of("4\" Width x 2\" Height)"), "Terms", 7L);
assertThat(requests.get()).as("冷却期内一个请求都不该发").isEqualTo(requestsBefore);
assertThat(cooled.reason()).contains("品牌检测服务不可达(解密链路成片失败,非本行数据问题)");
} finally {
server.stop(0);
}
}
/**
* 反向对照(行级差异必须保留):脏品牌名混在干净品牌里=本行数据问题,不是服务在掉。
* 零干净结论的条件不成立 ⇒ 永远不进冷却,各品牌照旧各查各的。
*/
@Test
void mixedDecryptFailuresWithCleanBrandsNeverEnterCooldown() throws Exception {
AtomicInteger decryptRequests = new AtomicInteger();
HttpServer server = startBrandCheckServer(exchange -> {
String body = new String(exchange.getRequestBody().readAllBytes(), StandardCharsets.UTF_8);
if (body.contains("Small")) {
decryptRequests.incrementAndGet();
respond(exchange, "{\"faild_data\":[],\"query_faild_data\":[\"Small)\"],"
+ "\"reason\":\"查询或解密失败: 解密失败: Malformed UTF-8 data\"}");
} else {
respond(exchange, "{\"faild_data\":[],\"query_faild_data\":[]}");
}
});
try {
UnreachableCooldown cooldown = new UnreachableCooldown();
BrandCheckProperties props = new BrandCheckProperties();
props.setBaseUrl("http://127.0.0.1:" + server.getAddress().getPort());
props.setPath("/brand_check");
props.setRetryTimes(2);
props.setRetryIntervalMillis(1);
props.setUnreachableCooldownMillis(300_000);
BrandCheckClient client =
new BrandCheckClient(props, null, stubbedUserSecrets(), cooldown);
client.checkAll(List.of("Nike", "Small)"), "Terms", 7L);
client.checkAll(List.of("Apple", "Small)"), "Terms", 7L);
assertThat(cooldown.noAnswerLaneCooling(props.getBaseUrl(), 300_000L)).isFalse();
assertThat(decryptRequests.get())
.as("混批里脏名品牌照旧逐行真查(行级证据面不变)").isGreaterThanOrEqualTo(4);
} finally {
server.stop(0);
}
}
/** 两个形状判定的口径钉死:不回包只认那两句原文,读超时不算;解密形状认现网三形。 */
@Test
void noAnswerPredicatesPinTheLiveShapes() {
assertThat(BrandCheckClient.isPeerClosedWithoutResponse(new ResourceAccessException(
"I/O error on POST request for \"http://47.110.241.161:16890/brand_check\"",
new java.io.IOException("HTTP/1.1 header parser received no bytes")))).isTrue();
assertThat(BrandCheckClient.isPeerClosedWithoutResponse(
new java.io.IOException("EOF reached while reading"))).isTrue();
assertThat(BrandCheckClient.isPeerClosedWithoutResponse(
new SocketTimeoutException("Read timed out"))).isFalse();
assertThat(BrandCheckClient.isPeerClosedWithoutResponse(
new HttpTimeoutException("request timed out"))).isFalse();
assertThat(BrandCheckClient.isPeerClosedWithoutResponse(null)).isFalse();
assertThat(BrandCheckClient.isDecryptFailure("查询或解密失败: 解密失败: Malformed UTF-8 data")).isTrue();
assertThat(BrandCheckClient.isDecryptFailure("解密失败: 解密失败: Malformed UTF-8 data")).isTrue();
assertThat(BrandCheckClient.isDecryptFailure(
"查询或解密失败: Expecting value: line 1 column 1 (char 0)")).isTrue();
assertThat(BrandCheckClient.isDecryptFailure("有 2~3 行抓取失败(未取得商品页数据):B07P5TR7Q5")).isFalse();
assertThat(BrandCheckClient.isDecryptFailure("")).isFalse();
assertThat(BrandCheckClient.isDecryptFailure(null)).isFalse();
}
@Test @Test
void pausedAccountStopsBatchWithoutHittingUpstream() throws Exception { void pausedAccountStopsBatchWithoutHittingUpstream() throws Exception {
AtomicInteger attempts = new AtomicInteger(); AtomicInteger attempts = new AtomicInteger();