fix(m168): 复审 r2 三项 —— 夹具不再空转、启动不再替英文用户下载、时限不再判慢线下不完
复审 r2（p2-3 / fix-then-merge）三项：
1. **P2-1 爬行服务端是空转的**（`font/tests/support.rs`，从 `tests.rs` 拆出守 400 行）：
`seen.windows(4).any(|w| w == b"\n\n")` 拿 4 字节窗口比 2 字节切片 ⇒ `PartialEq` 先比长度 ⇒
恒 false ⇒ 请求头永远读不完、一个字节不发，用例证明的其实只是「连接挂着被掐断」。上一版
这里是 Python 生成时把 `\r\n` 落成了真实换行字节。现在两处都是转义写法
（`b"\r\n\r\n"` + 完整 CRLF 响应头），并且**把「夹具真的在说话」变成断言**：
`serve_trickle()` 返回 `TrickleProof { header, dripped }`，用例断言「真的发过头」「真的挤过
字节」——否则夹具再坏一次也会绿。拆成两条用例：`a_trickling_candidate_is_cut_by_the_attempt_deadline`
（[爬行, 正常]，300 ms 切断第一个后第二个成功，0.38 s）与
`the_total_deadline_cuts_a_single_crawling_candidate`（单候选 + 400 ms 总预算）。
变异证明：把服务端改成「一个字节都不发」⇒ 两条用例红在「爬行服务端必须真的发出响应头」。
2. **P2-2 启动替英文用户下 17 MiB（真行为 bug）**：
- `fonts::resolve_with` **不再触发下载**（启动那一拍只报告判据）。唯一的触发点收在
`fonts::cjk_for`（`ui/lang.rs::log_cjk`），那一拍的 `setting` 与 `LangChoice` 同源
（ULL_LANG > 配置 > 系统 locale）= 「界面实际用哪种语言」。
- `plan` 把 `is_downloading()` / `Ready` 的闸提到**所有策略之前**：上一版只在 `NeedsDownload`
分支里，"下载中 + Unprobeable" 会把状态改回「无法探测」而线程还在飞，下完又翻回「已就绪」。
当时那条理由（「否则界面停在正在下载」）只对僵死成立 ⇒ worker 现在用 `catch_unwind`
兜底「任何 panic 都写终态」，闸才敢前移。
- 出图通道：新增 `install::set_offline(true)`（`App::with_presenter` 在
`options.screenshot.is_some()` 时调），`plan_with_offline` 在 offline 下永不 `Start`。
于是 `pages/harness/app.rs` 与 `--screenshot` 都不会在 zh-locale 无字体机器上真下 17 MiB。
- 被钉住的旧判据（`Unprobeable + Downloading ⇒ Apply`）改成 `Skip` 并写明旧行为为什么是错的；
新增 `every_strategy_skips_while_a_download_is_in_flight`（四策略打表）与
`the_screenshot_channel_never_starts_a_download`。
3. **P2-3 90 s 单次上限把「慢但能下完」变永久失败**：改 `ATTEMPT_DEADLINE=120 s` /
`TOTAL_DEADLINE=360 s`，并且**最后一个候选拿整个剩余总预算**（前 n-1 个仍 `min(单次, 剩余)`）。
算账写在常量文档里：17 772 300 B / 360 s ≈ 49 KB/s，比 r1 实测最慢那条 IPv6（67~77 KB/s）
还低一档 ⇒ 慢而能下完的线路仍有一次成功机会；健康线路（1.1~16.6 s）在第一/第二个候选就结束。
代价（最坏 6 分钟）也是刻意取舍，写在同一处。
顺手：`i18n::CjkFont::source` 的「尚未钉死」改成指向 `Source::Pinned`；`clock.rs` 与
`general_section.rs` 注释里的 17.0 MB → 16.9 MB。
验证（`CARGO_TARGET_DIR=C:/Temp/ull-target/wt-168`，全量重编；取退出码，不截断）：
- `cargo test -p unlucky-core --all-targets` → **16 个 target / 1189 passed / 0 failed / exit 0**
（lib 625 + setting 115 + 其余 14 个）
- `cargo test -p unlucky-i18n` → 31 passed / 0 failed / exit 0
- `cargo test -p unlucky-app-iced`（含 `no_hardcoded_tokens` integration）→ **693 passed / 0 failed / exit 0**
- `cargo clippy -p unlucky-i18n -p unlucky-core -p unlucky-app-iced --all-targets -- -D warnings` → exit 0
- `cargo fmt --all -- --check` 干净；全仓受检文件 ≤400（本分支最大 361）
This commit is contained in:
AskaEth committed
1 parent
875b792206
commit
b9009c0e61
11 files changed
+440
-199
No files matched your search
@@ -86,6 +86,10 @@ impl App {
|
||||
// 界面语言（M106）：**M92 已经探测对了，问题是一直没人用**——`pages::Model.lang` 此前在
|
||||
// `view::model` 里被写死成 `Lang::En`，于是中文系统上开出来的是全英文界面。
|
||||
let lang = LangState::boot(&bridge, options.screenshot.is_some());
|
||||
// M168（复审 r2 P2-2）：出图通道**不许联网**——`log_cjk` 那一拍会走 `after_probe`，
|
||||
// 一台 zh-locale 且没有中文字体的机器上会真的下 17 MiB，并可能在出图过程中注册新字体
|
||||
// （D30：同一份代码要出同一张图）。产品路径不设这个开关。
|
||||
crate::fonts::install::set_offline(options.screenshot.is_some());
|
||||
let mut view = pages::Model::new(
|
||||
pages::Screen::Instances,
|
||||
width,
|
||||
|
||||
@@ -43,7 +43,7 @@ impl App {
|
||||
self.view_dirty = true;
|
||||
}
|
||||
// 中文字体下载（M168）：后台线程推进，这里只比对快照。变了就重建视图模型 ⇒ 设置页那一行
|
||||
// 从「正在获取中文字体…（17.0 MB）」翻到「已就绪 / 获取失败」，不需要用户再点一下。
|
||||
// 从「正在获取中文字体…（16.9 MB）」翻到「已就绪 / 获取失败」，不需要用户再点一下。
|
||||
let font_status = crate::fonts::install::status();
|
||||
if font_status != self.font_seen {
|
||||
self.font_seen = font_status;
|
||||
|
||||
@@ -224,8 +224,10 @@ pub fn resolve_with(setting: Option<&str>) -> Resolved {
|
||||
// D28 后半：语言 + 中文环境的中文字体策略。`faces` 的 `None` 在这里是「字体库读不出来」，
|
||||
// 适配层会把它翻成 `Unprobeable` 而不是「缺字体」（否则会误触发一次 CDN 下载）。
|
||||
let cjk_report = cjk::probe_with(setting, faces.as_deref());
|
||||
// M168：只有 `NeedsDownload` 才会在这里发起下载（后台线程），其余三路一次网络都不发。
|
||||
install::after_probe(cjk_report.strategy);
|
||||
// **这里不发起下载**（复审 r2 P2-2 ①）：启动那一拍（`boot.rs` / `pages/harness/app.rs`）拿到的
|
||||
// `setting` 是 `None`，只按系统 locale 判——zh-locale + 配置 `en_us` 的机器会在这里就下 17 MiB，
|
||||
// 而随后 `App` 读到配置、把状态翻成「当前界面语言不需要中文字体」，线程却还在下。
|
||||
// 真正的触发点只有一个：[`cjk_for`]（`ui/lang.rs::log_cjk`，那一拍已经知道**生效语言**）。
|
||||
|
||||
Resolved {
|
||||
platform,
|
||||
@@ -235,13 +237,18 @@ pub fn resolve_with(setting: Option<&str>) -> Resolved {
|
||||
}
|
||||
}
|
||||
|
||||
/// 语言切换后的中文策略重算（M106 判据 / M168 触发下载）：`setting` 是配置里 `ui.language` 的
|
||||
/// **显式值**（`None` = 跟随系统，由 [`crate::platform::locale::SystemLocale`] 决定）。
|
||||
/// 语言切换后的中文策略重算（M106 判据）+ **唯一**的下载触发点（M168）：`setting` 是配置里
|
||||
/// `ui.language` 的**显式值**（`None` = 跟随系统，由 [`crate::platform::locale::SystemLocale`] 决定）。
|
||||
///
|
||||
/// 为什么需要它：启动那一轮（[`resolve`]）拿不到配置，只按系统 locale 判。用户在英文系统上
|
||||
/// 手选「简体中文」时，若不复算，策略会停在 `NotNeeded`——界面文字是中文、字体却没有中文字形，
|
||||
/// 那就是白块。复算出的 `NeedsDownload` 现在**真的会去下载**（M168：`install::after_probe`），
|
||||
/// 结果进设置页那一行（`pages::settings::general`）与 stderr 的 `[font] cjk-download …` 日志。
|
||||
/// 那就是白块。
|
||||
///
|
||||
/// **为什么触发只留在这里**（复审 r2 P2-2 ①）：这一拍的 `setting` 与 `LangChoice` 同源
|
||||
/// （`ULL_LANG` > 配置 > 系统 locale），也就是「界面实际用哪种语言」的那一份判据。
|
||||
/// 放在 [`resolve`] 里就会用「系统 locale」代表「用户选择」，zh-locale + 配置 `en_us` 的机器
|
||||
/// 会白下一次 17 MiB。出图通道（`--screenshot`）由 `install::set_offline(true)` 兜住，
|
||||
/// 仍然一次都不发。
|
||||
pub fn cjk_for(setting: Option<&str>) -> CjkReport {
|
||||
let report = cjk::probe_with(setting, system_faces().as_deref());
|
||||
install::after_probe(report.strategy);
|
||||
|
||||
@@ -250,34 +250,54 @@ pub enum Step {
|
||||
|
||||
/// 判据表（判据本体就在这张表的 `match` 里，`after_probe` 不含任何判据）。
|
||||
///
|
||||
/// | 策略 | 当前状态 | 这一步 |
|
||||
/// | 当前状态 | 策略 | 这一步 |
|
||||
/// |---|---|---|
|
||||
/// | `NotNeeded` / `System` / `Unprobeable` | 任意 | `Apply`（零网络） |
|
||||
/// | `NeedsDownload` | 下载中 / 已就绪 | **`Skip`**（幂等：切一次语言不起第二条线程） |
|
||||
/// | `NeedsDownload` | 未判定 / 失败过 / 其它 | `Start`（失败后的重试只能是用户再切一次语言） |
|
||||
/// | **下载中**（任意策略） | 任意 | **`Skip`**（闸在最上面，见下） |
|
||||
/// | `Ready` | 任意 | `Skip`（幂等：已就绪不再发起） |
|
||||
/// | 其它 | `NotNeeded` / `System` / `Unprobeable` | `Apply`（只改状态，零网络） |
|
||||
/// | 其它 | `NeedsDownload` | `Start`（失败过的重试只能由用户再切一次语言触发） |
|
||||
///
|
||||
/// ## 为什么「下载中」要在**所有**策略之前先跳过（复审 r2 P2-2 ②）
|
||||
///
|
||||
/// 上一版把 `is_downloading()` 只放在 `NeedsDownload` 分支里，于是「下载中 + `Unprobeable`」
|
||||
/// 会走 `Apply(Unprobeable)` —— 把状态从「正在下载」改回「无法探测」，而**线程还在飞**：
|
||||
/// 下完之后 `Ready` 又把它盖回去，状态行在 30 秒里来回翻。当时给出的理由是「否则界面会停在
|
||||
/// 正在下载」——那个理由只对**僵死**的 `Downloading` 成立（线程 panic 才会僵死），而在飞是
|
||||
/// 常见情形。僵死那一半现在由 worker 的 `catch_unwind` 兜底（任何 panic 都会写终态），
|
||||
/// 所以「下载中一律 Skip」不再有卡死的风险。
|
||||
///
|
||||
/// `offline = true`（出图通道）时**永不** `Start`：D30 要求同一份代码出同一张图，而下载会额外
|
||||
/// 产生网络流量并可能在出图过程中注册新字体。
|
||||
#[must_use]
|
||||
pub fn plan(strategy: Strategy, current: &CjkInstall) -> Step {
|
||||
pub fn plan_with_offline(strategy: Strategy, current: &CjkInstall, offline: bool) -> Step {
|
||||
if current.is_downloading() || matches!(current, CjkInstall::Ready { .. }) {
|
||||
return Step::Skip;
|
||||
}
|
||||
match strategy {
|
||||
Strategy::NotNeeded => Step::Apply(CjkInstall::NotNeeded),
|
||||
Strategy::System { family } => Step::Apply(CjkInstall::System {
|
||||
family: family.to_owned(),
|
||||
}),
|
||||
Strategy::Unprobeable => Step::Apply(CjkInstall::Unprobeable),
|
||||
Strategy::NeedsDownload(font) => {
|
||||
if current.is_downloading() || matches!(current, CjkInstall::Ready { .. }) {
|
||||
Step::Skip
|
||||
} else {
|
||||
Step::Start(font)
|
||||
}
|
||||
}
|
||||
// 出图通道需要下载 ⇒ **什么都不做**（也不改状态）：写「不需要下载」是谎话，
|
||||
// 写「正在下载」也是谎话（并没有在下载）。
|
||||
Strategy::NeedsDownload(_) if offline => Step::Skip,
|
||||
Strategy::NeedsDownload(font) => Step::Start(font),
|
||||
}
|
||||
}
|
||||
|
||||
/// 同 [`plan_with_offline`]，但按本进程当前的联网策略（生产判据入口）。
|
||||
#[must_use]
|
||||
pub fn plan(strategy: Strategy, current: &CjkInstall) -> Step {
|
||||
plan_with_offline(strategy, current, offline())
|
||||
}
|
||||
|
||||
/// 判据结论 → 现在这一步的结局（生产入口；判据全在 [`plan`]，这里只执行）。
|
||||
///
|
||||
/// * 英文环境 / 系统已有 / 探测不出 → 只更新状态（零网络）；
|
||||
/// * 已经在下载 / 已就绪 → 什么都不做（幂等：切一次语言不会起第二条下载、不会重复注册 17 MiB）；
|
||||
/// * 上次失败过 → 只有再次切语言才会重试（用户显式动作），不会自己反复联网。
|
||||
/// * 英文环境 / 系统已有 / 探测不出 → 只更新状态（零网络）；
|
||||
/// * 上次失败过 → 只有再次切语言才会重试（用户显式动作），不会自己反复联网；
|
||||
/// * 出图通道（[`set_offline`]）→ 永不发起。
|
||||
pub fn after_probe(strategy: Strategy) -> CjkInstall {
|
||||
match plan(strategy, &status()) {
|
||||
Step::Skip => status(),
|
||||
@@ -292,6 +312,24 @@ pub fn after_probe(strategy: Strategy) -> CjkInstall {
|
||||
}
|
||||
}
|
||||
|
||||
/// 本进程是否**禁止**发起字体下载（出图通道用；D30：同一份代码出同一张图）。
|
||||
///
|
||||
/// 为什么需要它：截图/演示通道也会走 `App` 构造 → `lang.log_cjk()` → `cjk_for` → `after_probe`。
|
||||
/// 一台 zh-locale、没有中文字体的机器上，出图会真的下 17 MiB 并在出图过程中注册新字体——
|
||||
/// 这既产生流量，也让「同一份代码出同一张图」不再成立。
|
||||
pub fn set_offline(offline: bool) {
|
||||
OFFLINE.store(offline, std::sync::atomic::Ordering::Relaxed);
|
||||
}
|
||||
|
||||
/// 当前是否处于 [`set_offline`] 的状态。
|
||||
#[must_use]
|
||||
pub fn offline() -> bool {
|
||||
OFFLINE.load(std::sync::atomic::Ordering::Relaxed)
|
||||
}
|
||||
|
||||
/// 进程级联网开关（默认允许）。
|
||||
static OFFLINE: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
|
||||
|
||||
/// 状态变更时记一行（只有真变了才打，避免每秒刷一行）。
|
||||
pub(super) fn update(state: CjkInstall) {
|
||||
let previous = {
|
||||
|
||||
@@ -218,13 +218,78 @@ fn the_idle_strategies_only_apply_state() {
|
||||
family: "SimSun".to_owned()
|
||||
})
|
||||
);
|
||||
// 复审 r2 P2-2 ② 改判：**下载中一律 Skip**，即使策略说「探测不出」。
|
||||
// 上一版在这里断言 `Apply(Unprobeable)`，理由是「否则界面会停在正在下载」——那个理由只对
|
||||
// 僵死成立（线程 panic），而在飞是常见情形：线程还在下，状态却被改成「无法探测」，下完又
|
||||
// 翻回「已就绪」，状态行在几十秒里来回翻。僵死由 worker 的 catch_unwind 兜底。
|
||||
assert_eq!(
|
||||
plan(Strategy::Unprobeable, &CjkInstall::Downloading { bytes: 1 }),
|
||||
Step::Apply(CjkInstall::Unprobeable),
|
||||
"探测不出也要把状态改回来（否则界面会停在「正在下载」）"
|
||||
Step::Skip,
|
||||
"在飞的下载不许被别的策略改写状态"
|
||||
);
|
||||
}
|
||||
|
||||
/// **下载中一律 `Skip`**（复审 r2 P2-2 ②）：四种策略挨个打一遍。
|
||||
///
|
||||
/// 抓得住：把 `is_downloading()` 那道闸挪回 `NeedsDownload` 分支里（上一版就是这样）——
|
||||
/// `Unprobeable` / `NotNeeded` / `System` 三行立刻红。
|
||||
/// 抓不住：worker 真的永不僵死（那要制造 panic，见 `worker` 的 `catch_unwind` 与报告的「没验」）。
|
||||
#[test]
|
||||
fn every_strategy_skips_while_a_download_is_in_flight() {
|
||||
let downloading = CjkInstall::Downloading { bytes: 17_772_300 };
|
||||
for strategy in [
|
||||
Strategy::NeedsDownload(&NOTO_SANS_SC),
|
||||
Strategy::NotNeeded,
|
||||
Strategy::System { family: "SimSun" },
|
||||
Strategy::Unprobeable,
|
||||
] {
|
||||
assert_eq!(
|
||||
plan(strategy, &downloading),
|
||||
Step::Skip,
|
||||
"{strategy:?}：下载中不许改状态、不许起第二条线程"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/// 出图通道（`offline`）**永不发起下载**（D30：同一份代码出同一张图）。
|
||||
///
|
||||
/// 抓得住：删掉 `plan_with_offline` 里 `NeedsDownload(_) if offline => Skip` 那一臂 ⇒ 截图/演示
|
||||
/// 通道会在 zh-locale 且无中文字体的机器上真下 17 MiB，用例在 `Step::Skip` 处红。
|
||||
/// 抓不住：真出图时有没有产生流量（那要真机跑 `--screenshot`，见报告「没验」）。
|
||||
#[test]
|
||||
fn the_screenshot_channel_never_starts_a_download() {
|
||||
assert_eq!(
|
||||
plan_with_offline(
|
||||
Strategy::NeedsDownload(&NOTO_SANS_SC),
|
||||
&CjkInstall::Unknown,
|
||||
true
|
||||
),
|
||||
Step::Skip,
|
||||
"出图通道不许联网"
|
||||
);
|
||||
assert_eq!(
|
||||
plan_with_offline(
|
||||
Strategy::NeedsDownload(&NOTO_SANS_SC),
|
||||
&CjkInstall::Unknown,
|
||||
false
|
||||
),
|
||||
Step::Start(&NOTO_SANS_SC),
|
||||
"正常通道该发起（否则上面那条可能是「永远 Skip」的假绿）"
|
||||
);
|
||||
// 只改状态的三种策略在两条通道里表现一致（它们本来就不联网）。
|
||||
for strategy in [
|
||||
Strategy::NotNeeded,
|
||||
Strategy::System { family: "SimSun" },
|
||||
Strategy::Unprobeable,
|
||||
] {
|
||||
assert_eq!(
|
||||
plan_with_offline(strategy, &CjkInstall::Unknown, false),
|
||||
plan_with_offline(strategy, &CjkInstall::Unknown, true),
|
||||
"{strategy:?}：不联网的策略与通道无关"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/// 截图钉子（D30）：每个 `ULL_FONT_STATUS` 取值都能解析成一档状态，坏值不猜。
|
||||
///
|
||||
/// 抓得住：出图夹具写了一个不存在的取值却静默出「未知」状态的图（报告就会撒谎）。
|
||||
|
||||
@@ -68,11 +68,23 @@ pub(super) fn start(font: &'static font::CjkFont) {
|
||||
|
||||
// 判据说「需要」，这条线程才存在：不需要的三种情形在 `after_probe` 就返回了。
|
||||
std::thread::spawn(move || {
|
||||
let state = ensure_for(
|
||||
Strategy::NeedsDownload(font),
|
||||
&fetcher,
|
||||
®ister_into_font_system,
|
||||
);
|
||||
// **保证写终态**（复审 r2 P2-2 ② 把这条当成「下载中一律 Skip」的前提）：
|
||||
// 线程里任何 panic（库内部、注册路径、OOM 前的 unwrap）都要落成 `Failed`，
|
||||
// 否则状态会永远停在「正在获取中文字体…」而幂等闸又不许别人改它。
|
||||
let state = match std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
|
||||
ensure_for(
|
||||
Strategy::NeedsDownload(font),
|
||||
&fetcher,
|
||||
®ister_into_font_system,
|
||||
)
|
||||
})) {
|
||||
Ok(state) => state,
|
||||
Err(_) => CjkInstall::Failed {
|
||||
class: FetchClass::Disk,
|
||||
message: "字体安装线程 panic（已捕获，状态回到终态；界面继续用系统字体）"
|
||||
.to_owned(),
|
||||
},
|
||||
};
|
||||
// `from_cache` 只认下载器**这次**的结论（复审 r1 次要项）：取之前「文件在不在」会说谎——
|
||||
// 坏缓存会被删掉重下，那时 `has_cached()` 还是 true，而真相是「联网下了一次」。
|
||||
let from_cache = fetcher.was_cached().unwrap_or(false);
|
||||
|
||||
@@ -102,7 +102,7 @@ fn the_font_status_row_speaks_in_four_states_and_two_languages() {
|
||||
assert!(value.contains(reason), "失败原因没进文案：{value}");
|
||||
}
|
||||
|
||||
// 下载中写的是**真实**字节数（17.0 MB），不是假百分比。
|
||||
// 下载中写的是**真实**字节数（17 772 300 B → 16.9 MiB），不是假百分比。
|
||||
let (value, _) = general::font_status(&zh, &CjkInstall::Downloading { bytes: 17_772_300 });
|
||||
assert!(
|
||||
value.contains("16.9 MB"),
|
||||
|
||||
@@ -56,7 +56,7 @@ use super::verify;
|
||||
/// 写进数据根**。
|
||||
pub const MAX_FONT_BYTES: u64 = 32 * 1024 * 1024;
|
||||
|
||||
/// **单次候选尝试**的整体时限（不是连接超时，也不是空闲超时）。
|
||||
/// **非最后一个候选**的单次尝试时限（不是连接超时，也不是空闲超时）。
|
||||
///
|
||||
/// 为什么必须有：引擎的 `read_timeout` 是 30 s **空闲**超时，一条每秒只挤几 KB、但一直在动的
|
||||
/// 连接永远不会被判失败。复审实测过这条路径（同一台机器、同一份文件）：
|
||||
@@ -66,15 +66,31 @@ pub const MAX_FONT_BYTES: u64 = 32 * 1024 * 1024;
|
||||
/// | Fastly 的 IPv6 边缘 | 60 s 只到 4.0 MB（≈67 KB/s，17.7 MB 要 ≈4 分钟） |
|
||||
/// | 同一域名的 IPv4 边缘 | 1.2 s 下完（≈15 MB/s） |
|
||||
///
|
||||
/// 60~180 s 之间取 90 s：健康线路（实测 1.1~16.6 s）绰绰有余，而 75 KB/s 的爬行会在 90 s
|
||||
/// 前被打断，转去下一个候选域。**超时归入网络档**（用户视角是「太慢」，不是「内容不对」）。
|
||||
pub const ATTEMPT_DEADLINE: Duration = Duration::from_secs(90);
|
||||
|
||||
/// 整条取回（所有候选加起来）的总时限。
|
||||
/// 120 s 是「差不多能过、但明显不对就换源」的位置：健康线路（实测 1.1~16.6 s）根本用不到它；
|
||||
/// 而 300 KB/s 以上的线路在 120 s 内能下完 17.7 MB。
|
||||
///
|
||||
/// 候选是一个个试的，每个都有自己的 [`ATTEMPT_DEADLINE`]；总时限是**上限的上限**，防止将来
|
||||
/// 候选列表变长时「N × 90 s」把设置页那一行卡成几分钟。当前两个独立域 ⇒ 实际最坏 3 分钟。
|
||||
pub const TOTAL_DEADLINE: Duration = Duration::from_secs(180);
|
||||
/// ## 为什么**最后一个**候选不吃这个时限（复审 r2 P2-3）
|
||||
///
|
||||
/// 每个候选都从 0 字节重下（不做续传），所以「单次上限」直接就是一条**吞吐门槛**：
|
||||
/// `17 772 300 B / 上限`。第一版把两个候选都卡 90 s ⇒ 门槛 ≈197 KB/s，而 r1 实测那条 IPv6 是
|
||||
/// 67~77 KB/s——**改动前它能用 4 分钟下完，加了时限反而必失败、且重试无意义**。这正是我们想
|
||||
/// 避免的「把慢但当当能成的情况变成永久失败」。
|
||||
///
|
||||
/// 现在的规则（见 [`fetch_blocking_with_limits`]）：前 n-1 个候选各拿
|
||||
/// `min(ATTEMPT_DEADLINE, 剩余)`，**最后一个候选拿整个剩余总预算**。所以只要这条线在
|
||||
/// [`TOTAL_DEADLINE`] 内下得完，它就还有一次老老实实下完的机会；而前面几个候选仍然会被快速换掉。
|
||||
/// **超时归入网络档**（用户视角是「太慢」，不是「内容不对」）。
|
||||
pub const ATTEMPT_DEADLINE: Duration = Duration::from_secs(120);
|
||||
|
||||
/// 整条取回（所有候选加起来）的总时限，也是**最后一个候选**能拿到的预算上限。
|
||||
///
|
||||
/// 取值依据（复审 r2 P2-3 的算术）：17 772 300 B / 360 s ≈ **49 KB/s** —— 比 r1 实测最慢的
|
||||
/// 那条 IPv6 路径（67~77 KB/s）还低一档，于是「慢但当当能下完」的线路仍然有一次成功机会；
|
||||
/// 而任何健康线路（1.1~16.6 s）在第一或第二个候选上就结束了。
|
||||
///
|
||||
/// 代价：最坏情形下用户要在设置页看着「正在获取中文字体…（16.9 MB）」等 6 分钟。这是刻意的
|
||||
/// 取舍——**慢而最终成功**远好过**快而必然失败**（后者要用户自己再来一次，结果一样）。
|
||||
pub const TOTAL_DEADLINE: Duration = Duration::from_secs(360);
|
||||
|
||||
/// 字体取回的失败分类（三层，见模块文档「失败分类为什么是三类」）。
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
@@ -194,8 +210,15 @@ pub fn fetch_blocking_with_limits(
|
||||
)));
|
||||
break;
|
||||
}
|
||||
// 每次尝试给 min(单次上限, 剩余总预算)：两个时限都不许越。
|
||||
let budget = attempt_deadline.min(remaining);
|
||||
// 前 n-1 个候选：`min(单次上限, 剩余)`；**最后一个候选**拿整个剩余总预算。
|
||||
// 为什么对最后一个放宽：每个候选都从 0 字节重下，「单次上限」就是一条吞吐门槛，
|
||||
// 卡死最后一个等于把「慢但能下完」判成永久失败（复审 r2 P2-3 的算术，见 ATTEMPT_DEADLINE）。
|
||||
let is_last = index + 1 == spec.urls.len();
|
||||
let budget = if is_last {
|
||||
remaining
|
||||
} else {
|
||||
attempt_deadline.min(remaining)
|
||||
};
|
||||
let request = DownloadRequest::new(ResourceKind::Other, url.clone(), &final_path)
|
||||
.with_sha256(&spec.sha256)
|
||||
.with_size(spec.bytes);
|
||||
|
||||
@@ -6,108 +6,20 @@
|
||||
//! 外网站点，跑 `cargo test` 不需要网络。真 CDN 的字节有没有变、17 MiB 要下多久，这些**不在**
|
||||
//! 本文件的能力范围内（报告里写明）。
|
||||
|
||||
use std::io::{Read as _, Write as _};
|
||||
use std::net::TcpListener;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::sync::atomic::{AtomicUsize, Ordering};
|
||||
use std::sync::Arc;
|
||||
use std::path::Path;
|
||||
use std::sync::atomic::Ordering;
|
||||
use std::time::Duration;
|
||||
|
||||
use super::super::types::HashAlgo;
|
||||
use super::*;
|
||||
|
||||
/// 每个用例一个独立数据根（共享引擎的登记处是进程级的，键撞了会互相干扰）。
|
||||
fn root(tag: &str) -> PathBuf {
|
||||
static SEQ: AtomicUsize = AtomicUsize::new(0);
|
||||
let seq = SEQ.fetch_add(1, Ordering::SeqCst);
|
||||
let dir = std::env::temp_dir().join(format!("ull-font-{tag}-{}-{seq}", std::process::id()));
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
std::fs::create_dir_all(&dir).expect("建数据根");
|
||||
dir
|
||||
}
|
||||
#[path = "tests/support.rs"]
|
||||
mod support;
|
||||
|
||||
/// 一段「像字体」的字节：sfnt 头 + 一张表记录 + 载荷。
|
||||
///
|
||||
/// 为什么造它而不是塞随机字节：`looks_like_sfnt` 是落盘前的一道闸，测试若拿 HTML 当正常内容，
|
||||
/// 「下载成功」这条路径就永远走不到。
|
||||
fn fake_font(payload: &[u8]) -> Vec<u8> {
|
||||
let mut bytes = Vec::new();
|
||||
bytes.extend_from_slice(b"\x00\x01\x00\x00"); // sfnt 版本
|
||||
bytes.extend_from_slice(&1u16.to_be_bytes()); // numTables
|
||||
bytes.extend_from_slice(&[0u8; 6]); // searchRange / entrySelector / rangeShift
|
||||
bytes.extend_from_slice(b"TEST"); // 表名
|
||||
bytes.extend_from_slice(&0u32.to_be_bytes()); // checksum
|
||||
bytes.extend_from_slice(&28u32.to_be_bytes()); // offset
|
||||
bytes.extend_from_slice(&(payload.len() as u32).to_be_bytes());
|
||||
bytes.extend_from_slice(payload);
|
||||
bytes
|
||||
}
|
||||
|
||||
fn sha256(bytes: &[u8]) -> String {
|
||||
verify::digest_bytes(HashAlgo::Sha256, bytes)
|
||||
}
|
||||
|
||||
/// 回环 HTTP 服务：不管请求什么，都回同一份字节；记下处理了几条请求。
|
||||
///
|
||||
/// 只讲 HTTP/1.1 keep-alive，够用来判「第二次调用有没有再发请求」。
|
||||
fn serve(body: Vec<u8>, expected_requests: usize) -> (String, Arc<AtomicUsize>) {
|
||||
let listener = TcpListener::bind("127.0.0.1:0").expect("绑定回环端口");
|
||||
let addr = listener.local_addr().expect("取端口");
|
||||
let served = Arc::new(AtomicUsize::new(0));
|
||||
let counter = Arc::clone(&served);
|
||||
|
||||
std::thread::spawn(move || {
|
||||
let mut requests = 0usize;
|
||||
while requests < expected_requests {
|
||||
let Ok((mut socket, _)) = listener.accept() else {
|
||||
break;
|
||||
};
|
||||
let _ = socket.set_read_timeout(Some(Duration::from_secs(10)));
|
||||
let mut seen = Vec::new();
|
||||
loop {
|
||||
let mut chunk = [0u8; 1024];
|
||||
match socket.read(&mut chunk) {
|
||||
Ok(0) | Err(_) => break,
|
||||
Ok(read) => seen.extend_from_slice(&chunk[..read]),
|
||||
}
|
||||
if !seen.windows(4).any(|window| window == b"\r\n\r\n") {
|
||||
continue;
|
||||
}
|
||||
requests += 1;
|
||||
counter.store(requests, Ordering::SeqCst);
|
||||
let head = format!(
|
||||
"HTTP/1.1 200 OK\r\nContent-Type: font/ttf\r\nContent-Length: {}\r\n\r\n",
|
||||
body.len()
|
||||
);
|
||||
if socket.write_all(head.as_bytes()).is_err() || socket.write_all(&body).is_err() {
|
||||
break;
|
||||
}
|
||||
seen.clear();
|
||||
if requests >= expected_requests {
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
(format!("http://{addr}/cjk.ttf"), served)
|
||||
}
|
||||
|
||||
/// 一个**不会**有人监听的地址：证明「没联网」比证明「联网成功」更有力。
|
||||
fn dead_url() -> String {
|
||||
let listener = TcpListener::bind("127.0.0.1:0").expect("占一个端口");
|
||||
let addr = listener.local_addr().expect("取端口");
|
||||
drop(listener);
|
||||
format!("http://{addr}/cjk.ttf")
|
||||
}
|
||||
|
||||
fn spec_for(urls: Vec<String>, bytes: &[u8]) -> FontSpec {
|
||||
FontSpec::new(urls, sha256(bytes), bytes.len() as u64).expect("pin 应自洽")
|
||||
}
|
||||
use support::{dead_url, fake_font, root, serve, serve_trickle, sha256, spec_for};
|
||||
|
||||
/// 守卫 ③：**缓存命中不联网**。
|
||||
///
|
||||
/// 抓得住：把 `fetch_blocking` 开头的缓存分支删掉（或改成「只 stat 不校验」以外的任何短路取消）
|
||||
/// —— 那样 URL 指向的死人端口会被真的去连，本用例当场红。
|
||||
/// 抓得住：把 `fetch_blocking` 开头的缓存分支删掉——URL 指向的死人端口会被真的去连，本用例红。
|
||||
/// 抓不住：真机上 17 MiB 文件读盘有多快。
|
||||
#[test]
|
||||
fn cache_hit_never_touches_the_network() {
|
||||
@@ -223,79 +135,78 @@ fn an_html_error_page_is_not_a_font() {
|
||||
std::fs::remove_dir_all(&dir).ok();
|
||||
}
|
||||
|
||||
/// 爬行服务端：回完头之后每 100 ms 只挤 1 字节，**永不结束**。
|
||||
/// 守卫（M168 复审 r2 P2-1/P2-3）：**单次尝试的时限会打断爬行连接并转下一个候选**。
|
||||
///
|
||||
/// 这正是复审 P2-2 实测到的那条路径（IPv6 边缘 ≈67 KB/s，60 s 只到 4 MB）：引擎的
|
||||
/// `read_timeout` 是 30 s **空闲**超时，字节一直在动 ⇒ 引擎自己永远不会判它失败。只有我们
|
||||
/// 那一层的整体时限能打断它。离线（回环）可跑。
|
||||
fn serve_trickle() -> String {
|
||||
let listener = TcpListener::bind("127.0.0.1:0").expect("绑定回环端口");
|
||||
let addr = listener.local_addr().expect("取端口");
|
||||
std::thread::spawn(move || {
|
||||
let Ok((mut socket, _)) = listener.accept() else {
|
||||
return;
|
||||
};
|
||||
let _ = socket.set_read_timeout(Some(Duration::from_secs(5)));
|
||||
// 读掉请求头（不回也行，但要先把请求收干净，否则某些栈会说 RST）。
|
||||
let mut seen = Vec::new();
|
||||
loop {
|
||||
let mut chunk = [0u8; 1024];
|
||||
match socket.read(&mut chunk) {
|
||||
Ok(0) | Err(_) => return,
|
||||
Ok(read) => seen.extend_from_slice(&chunk[..read]),
|
||||
}
|
||||
if seen.windows(4).any(|window| {
|
||||
window
|
||||
== b"
|
||||
|
||||
"
|
||||
}) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
// 声明一个够大的长度，然后开始「爬」：每 100 ms 一个字节。
|
||||
if socket
|
||||
.write_all(
|
||||
b"HTTP/1.1 200 OK
|
||||
Content-Type: font/ttf
|
||||
Content-Length: 1000000
|
||||
|
||||
",
|
||||
)
|
||||
.is_err()
|
||||
{
|
||||
return;
|
||||
}
|
||||
for _ in 0..600 {
|
||||
if socket.write_all(&[0u8]).is_err() {
|
||||
return;
|
||||
}
|
||||
std::thread::sleep(Duration::from_millis(100));
|
||||
}
|
||||
});
|
||||
format!("http://{addr}/cjk.ttf")
|
||||
}
|
||||
|
||||
/// 守卫（M168 复审 P2-2）：**只爬不死的连接由整体时限打断**，不许让界面干等。
|
||||
/// 这个场景现在是真的：第一个候选是 `serve_trickle()`（发真实 CRLF 响应头，之后每 100 ms 一个
|
||||
/// 字节），第二个候选是正常服务端。
|
||||
///
|
||||
/// 抓得住：把 `tokio::time::timeout` 摘掉（只剩引擎的 30 s **空闲**超时）——本用例会一直
|
||||
/// 跑在「每 100 ms 一个字节」的连接上，`started.elapsed() < 4 s` 那条断言直接红（实际会挂到
|
||||
/// 测试框架超时）。也抓得住「超时被归成校验失败」：`class()` 必须还是 `network`。
|
||||
/// 抓不住：90 s/180 s 两个默认值在真网络下够不够（那要真 CDN，见报告「未验」）。
|
||||
/// 抓得住：①`serve_trickle` 的响应头写错（上一版就是这个病：真实换行字节 + 4 字节窗口 ⇒ 恒 false
|
||||
/// ⇒ 一个字节都不发）——那样第一个候选会在**读不到响应头**时按网络错失败，用例里
|
||||
/// `trickle_served` 的「服务端真的发过头」这条断言会红；②`budget` 不是 `min(单次, 剩余)` 而是
|
||||
/// 直接用总预算 ⇒ 本用例会等到总预算（5 s）才换源，`elapsed < 3 s` 红；③时限被归成校验失败。
|
||||
/// 抓不住：默认值（120 s / 360 s）在真弱网下够不够（那要真 CDN，见报告「未验」）。
|
||||
#[test]
|
||||
fn a_trickling_connection_is_cut_by_the_deadline() {
|
||||
let dir = root("deadline");
|
||||
let body = fake_font(b"not what the server sends");
|
||||
let spec = FontSpec::new(vec![serve_trickle()], sha256(&body), body.len() as u64).expect("pin");
|
||||
fn a_trickling_candidate_is_cut_by_the_attempt_deadline() {
|
||||
let dir = root("deadline-attempt");
|
||||
let good = fake_font(b"served by the second candidate");
|
||||
let (good_url, _served) = serve(good.clone(), 4);
|
||||
let (trickle_url, proof) = serve_trickle();
|
||||
let spec = FontSpec::new(
|
||||
vec![trickle_url, good_url],
|
||||
sha256(&good),
|
||||
good.len() as u64,
|
||||
)
|
||||
.expect("pin");
|
||||
|
||||
let started = std::time::Instant::now();
|
||||
let error = fetch_blocking_with_limits(
|
||||
let fetched = fetch_blocking_with_limits(
|
||||
&dir,
|
||||
&spec,
|
||||
Duration::from_millis(300),
|
||||
Duration::from_secs(5),
|
||||
)
|
||||
.expect_err("爬行连接必须被时限打断");
|
||||
.expect("第二个候选应当成功");
|
||||
assert_eq!(fetched.bytes, good);
|
||||
assert!(
|
||||
started.elapsed() < Duration::from_secs(3),
|
||||
"单次上限该在 300 ms 处切断第一个候选，实际 {:?}",
|
||||
started.elapsed()
|
||||
);
|
||||
assert!(cache_path(&dir, &spec).exists());
|
||||
// **这条是「夹具没坏」的判据**（复审 r2 P2-1）：第一个候选必须真的发过响应头、真的挤过字节。
|
||||
// 少了这两条，一个「什么都不发的服务端」也能让本用例绿——那证明的是「连接挂着被掐断」，
|
||||
// 而不是我们想证明的「活着但在爬」。
|
||||
assert!(
|
||||
proof.header.load(Ordering::SeqCst),
|
||||
"爬行服务端必须真的发出响应头"
|
||||
);
|
||||
assert!(
|
||||
proof.dripped.load(Ordering::SeqCst) >= 1,
|
||||
"爬行服务端必须真的挤出过字节（否则引擎的空闲超时那条路径根本没被造出来）"
|
||||
);
|
||||
std::fs::remove_dir_all(&dir).ok();
|
||||
}
|
||||
|
||||
/// 守卫（M168 复审 r2 P2-3）：**总时限**也会打断爬行，且文案说清「超时」、不落盘。
|
||||
///
|
||||
/// 抓得住：总预算被当成「每个候选各给一次」⇒ 本用例会跑到 600 × 100 ms 的爬行结束（≈60 s），
|
||||
/// `elapsed < 4 s` 红；也抓得住超时被归成其它类别（`class()` 必须是 `network`）。
|
||||
/// 抓不住：真网络上的取值合不合适（同上，见「未验」）。
|
||||
#[test]
|
||||
fn the_total_deadline_cuts_a_single_crawling_candidate() {
|
||||
let dir = root("deadline-total");
|
||||
let body = fake_font(b"not what the server sends");
|
||||
let (trickle_url, proof) = serve_trickle();
|
||||
let spec = FontSpec::new(vec![trickle_url], sha256(&body), body.len() as u64).expect("pin");
|
||||
|
||||
let started = std::time::Instant::now();
|
||||
let error = fetch_blocking_with_limits(
|
||||
&dir,
|
||||
&spec,
|
||||
Duration::from_secs(30),
|
||||
Duration::from_millis(400),
|
||||
)
|
||||
.expect_err("总时限必须打断爬行");
|
||||
assert_eq!(error.class(), "network", "超时属于网络档：{error}");
|
||||
assert!(
|
||||
error.message().contains("超时"),
|
||||
@@ -307,6 +218,10 @@ fn a_trickling_connection_is_cut_by_the_deadline() {
|
||||
started.elapsed()
|
||||
);
|
||||
assert!(!cache_path(&dir, &spec).exists(), "超时不许落盘");
|
||||
assert!(
|
||||
proof.dripped.load(Ordering::SeqCst) >= 1,
|
||||
"总时限也该掐在「有字节在动」的连接上，而不是一个不响的端口"
|
||||
);
|
||||
std::fs::remove_dir_all(&dir).ok();
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,177 @@
|
||||
//! `download::font` 的测试夹具（回环 HTTP 服务端 / 假字体字节 / 临时数据根）。
|
||||
//!
|
||||
//! 从 `tests.rs` 拆出只为守 400 行硬线（复审 r2 加了两条时限用例之后越线）。这里只有夹具，
|
||||
//! 断言全在 `tests.rs`——两个回环服务端（`serve` 正常、`serve_trickle` 只爬）是「缓存/校验/时限」
|
||||
//! 三组守卫的地基，改坏它们等于把守卫变成空转（复审 r2 P2-1 就是这么发现上一版的
|
||||
//! CRLF 字面量写坏了的）。
|
||||
|
||||
use std::io::{Read as _, Write as _};
|
||||
use std::net::TcpListener;
|
||||
use std::path::PathBuf;
|
||||
use std::sync::atomic::{AtomicUsize, Ordering};
|
||||
use std::sync::Arc;
|
||||
use std::time::Duration;
|
||||
|
||||
use super::super::super::verify;
|
||||
use super::super::{FontSpec, HashAlgo};
|
||||
|
||||
/// 每个用例一个独立数据根（共享引擎的登记处是进程级的，键撞了会互相干扰）。
|
||||
pub(super) fn root(tag: &str) -> PathBuf {
|
||||
static SEQ: AtomicUsize = AtomicUsize::new(0);
|
||||
let seq = SEQ.fetch_add(1, Ordering::SeqCst);
|
||||
let dir = std::env::temp_dir().join(format!("ull-font-{tag}-{}-{seq}", std::process::id()));
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
std::fs::create_dir_all(&dir).expect("建数据根");
|
||||
dir
|
||||
}
|
||||
|
||||
/// 一段「像字体」的字节：sfnt 头 + 一张表记录 + 载荷。
|
||||
///
|
||||
/// 为什么造它而不是塞随机字节：`looks_like_sfnt` 是落盘前的一道闸，测试若拿 HTML 当正常内容，
|
||||
/// 「下载成功」这条路径就永远走不到。
|
||||
pub(super) fn fake_font(payload: &[u8]) -> Vec<u8> {
|
||||
let mut bytes = Vec::new();
|
||||
bytes.extend_from_slice(b"\x00\x01\x00\x00"); // sfnt 版本
|
||||
bytes.extend_from_slice(&1u16.to_be_bytes()); // numTables
|
||||
bytes.extend_from_slice(&[0u8; 6]); // searchRange / entrySelector / rangeShift
|
||||
bytes.extend_from_slice(b"TEST"); // 表名
|
||||
bytes.extend_from_slice(&0u32.to_be_bytes()); // checksum
|
||||
bytes.extend_from_slice(&28u32.to_be_bytes()); // offset
|
||||
bytes.extend_from_slice(&(payload.len() as u32).to_be_bytes());
|
||||
bytes.extend_from_slice(payload);
|
||||
bytes
|
||||
}
|
||||
|
||||
pub(super) fn sha256(bytes: &[u8]) -> String {
|
||||
verify::digest_bytes(HashAlgo::Sha256, bytes)
|
||||
}
|
||||
|
||||
/// 回环 HTTP 服务：不管请求什么，都回同一份字节；记下处理了几条请求。
|
||||
///
|
||||
/// 只讲 HTTP/1.1 keep-alive，够用来判「第二次调用有没有再发请求」。
|
||||
pub(super) fn serve(body: Vec<u8>, expected_requests: usize) -> (String, Arc<AtomicUsize>) {
|
||||
let listener = TcpListener::bind("127.0.0.1:0").expect("绑定回环端口");
|
||||
let addr = listener.local_addr().expect("取端口");
|
||||
let served = Arc::new(AtomicUsize::new(0));
|
||||
let counter = Arc::clone(&served);
|
||||
|
||||
std::thread::spawn(move || {
|
||||
let mut requests = 0usize;
|
||||
while requests < expected_requests {
|
||||
let Ok((mut socket, _)) = listener.accept() else {
|
||||
break;
|
||||
};
|
||||
let _ = socket.set_read_timeout(Some(Duration::from_secs(10)));
|
||||
let mut seen = Vec::new();
|
||||
loop {
|
||||
let mut chunk = [0u8; 1024];
|
||||
match socket.read(&mut chunk) {
|
||||
Ok(0) | Err(_) => break,
|
||||
Ok(read) => seen.extend_from_slice(&chunk[..read]),
|
||||
}
|
||||
if !seen.windows(4).any(|window| window == b"\r\n\r\n") {
|
||||
continue;
|
||||
}
|
||||
requests += 1;
|
||||
counter.store(requests, Ordering::SeqCst);
|
||||
let head = format!(
|
||||
"HTTP/1.1 200 OK\r\nContent-Type: font/ttf\r\nContent-Length: {}\r\n\r\n",
|
||||
body.len()
|
||||
);
|
||||
if socket.write_all(head.as_bytes()).is_err() || socket.write_all(&body).is_err() {
|
||||
break;
|
||||
}
|
||||
seen.clear();
|
||||
if requests >= expected_requests {
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
(format!("http://{addr}/cjk.ttf"), served)
|
||||
}
|
||||
|
||||
/// 一个**不会**有人监听的地址：证明「没联网」比证明「联网成功」更有力。
|
||||
pub(super) fn dead_url() -> String {
|
||||
let listener = TcpListener::bind("127.0.0.1:0").expect("占一个端口");
|
||||
let addr = listener.local_addr().expect("取端口");
|
||||
drop(listener);
|
||||
format!("http://{addr}/cjk.ttf")
|
||||
}
|
||||
|
||||
/// 爬行服务端的取证计数器：`header` = 真的发过响应头，`dripped` = 真的挤出过几个字节。
|
||||
///
|
||||
/// 为什么把这两个数字**带出去**：这类 `serve_*` 夹具坏掉时，用例会静默变成另一种场景
|
||||
/// （复审 r2 P2-1 就是：请求头永远读不完 ⇒ 一个字节不发 ⇒ 用例证明的是「连接挂着」，而不是
|
||||
/// 「活着但在爬」）。用例拿到这两个数就能断言「服务端确实在说话」。
|
||||
pub(super) struct TrickleProof {
|
||||
/// 响应头是否真的写出去了。
|
||||
pub header: Arc<std::sync::atomic::AtomicBool>,
|
||||
/// 写出去了几个正文字节。
|
||||
pub dripped: Arc<AtomicUsize>,
|
||||
}
|
||||
|
||||
/// 由 URL 候选 + 期望字节算 pin（哈希取这批字节的 sha256）。
|
||||
pub(super) fn spec_for(urls: Vec<String>, bytes: &[u8]) -> FontSpec {
|
||||
FontSpec::new(urls, sha256(bytes), bytes.len() as u64).expect("pin 应自洽")
|
||||
}
|
||||
|
||||
/// 爬行服务端：回完头之后每 100 ms 只挤 1 字节，**永远不结束**。
|
||||
///
|
||||
/// 这就是复审 r1 P2-2 实测到的那条路径（Fastly 的 IPv6 边缘 ≈67 KB/s）：引擎的 `read_timeout`
|
||||
/// 是 30 s **空闲**超时，而字节一直在动 ⇒ 引擎自己永远不会判它失败。只有我们这一层的整体时限
|
||||
/// 能打断它——这条服务端存在的唯一目的就是造出「活着但爬」的连接。
|
||||
///
|
||||
/// 注意这里的 `\r\n` 必须是**转义写法**：上一版这个函数里写成了真实换行字节（`b"\n\n"`，2 字节）
|
||||
/// 却拿 4 字节窗口去比，`PartialEq` 先比长度 ⇒ 恒 false ⇒ 请求头永远读不完、一个字节都不发，
|
||||
/// 用例证明的其实是另一件事（复审 r2 P2-1）。`serve()` 那边的写法是对的，别动它。
|
||||
pub(super) fn serve_trickle() -> (String, TrickleProof) {
|
||||
let header_sent = Arc::new(std::sync::atomic::AtomicBool::new(false));
|
||||
let dripped = Arc::new(AtomicUsize::new(0));
|
||||
let (header_flag, drip_flag) = (Arc::clone(&header_sent), Arc::clone(&dripped));
|
||||
let listener = TcpListener::bind("127.0.0.1:0").expect("绑定回环端口");
|
||||
let addr = listener.local_addr().expect("取端口");
|
||||
std::thread::spawn(move || {
|
||||
let Ok((mut socket, _)) = listener.accept() else {
|
||||
return;
|
||||
};
|
||||
let _ = socket.set_read_timeout(Some(Duration::from_secs(5)));
|
||||
// 先把请求头读干净（不读完就写响应，某些栈会 RST）。
|
||||
let mut seen = Vec::new();
|
||||
loop {
|
||||
let mut chunk = [0u8; 1024];
|
||||
match socket.read(&mut chunk) {
|
||||
Ok(0) | Err(_) => return,
|
||||
Ok(read) => seen.extend_from_slice(&chunk[..read]),
|
||||
}
|
||||
if seen.windows(4).any(|window| window == b"\r\n\r\n") {
|
||||
break;
|
||||
}
|
||||
}
|
||||
// 声明一个够大的长度，然后开始「爬」：每 100 ms 一个字节。
|
||||
if socket
|
||||
.write_all(
|
||||
b"HTTP/1.1 200 OK\r\nContent-Type: font/ttf\r\nContent-Length: 1000000\r\n\r\n",
|
||||
)
|
||||
.is_err()
|
||||
{
|
||||
return;
|
||||
}
|
||||
header_flag.store(true, Ordering::SeqCst);
|
||||
for _ in 0..600 {
|
||||
if socket.write_all(&[0u8]).is_err() {
|
||||
return;
|
||||
}
|
||||
drip_flag.fetch_add(1, Ordering::SeqCst);
|
||||
std::thread::sleep(Duration::from_millis(100));
|
||||
}
|
||||
});
|
||||
(
|
||||
format!("http://{addr}/cjk.ttf"),
|
||||
TrickleProof {
|
||||
header: header_sent,
|
||||
dripped,
|
||||
},
|
||||
)
|
||||
}
|
||||
@@ -97,7 +97,7 @@ pub struct CjkFont {
|
||||
pub license: &'static str,
|
||||
/// 这套字体可用的字重。
|
||||
pub weights: &'static [u16],
|
||||
/// 下载源（尚未钉死）。
|
||||
/// 下载源（URL 候选 + sha256 + 字节数，见 [`Source::Pinned`]）。
|
||||
pub source: Source,
|
||||
}
|
||||
|
||||
|
||||
Reference in new issue
Block a user