From afe169751f753914f12c86c332e3d5f0b90332d8 Mon Sep 17 00:00:00 2001 From: AskaEth Date: Sun, 8 Nov 2026 09:18:33 +0800 Subject: [PATCH] =?UTF-8?q?fix(m165):=20forget=20=E4=B9=8B=E5=90=8E?= =?UTF-8?q?=E8=AE=A9=E8=87=AA=E6=9B=B4=E6=96=B0=E4=B9=9F=E6=8D=A2=E5=BC=95?= =?UTF-8?q?=E6=93=8E=EF=BC=88=E5=A4=8D=E5=AE=A1=20P2-1=EF=BC=89+=20?= =?UTF-8?q?=E5=8D=A1=E5=8F=A3=E8=AE=A1=E6=95=B0=E4=B8=8E=E7=AB=AF=E5=88=B0?= =?UTF-8?q?=E7=AB=AF=E5=AE=88=E5=8D=AB?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 复审 P2-1（采「修法 1」，不是只改措辞）：`shared::forget` 只让登记处不再持有 那一份，换不掉自更新 `Factory` 里常驻的 Arc —— 于是「重新检测地区」对更新路径 不生效，直到重启。现在设置动作会把 Factory 一起重建。 - presenter/update_state: `Runtime::rebuild_factory` + `CoreHost::refresh_update_factory`； 只换 factory，不动 view/inflight（在飞的 Job 派发时已克隆走装配，重建不打断它） - presenter/dispatch: `SetSetting` 成功且键是「重新检测地区」时调 refresh - presenter/engine: `DETECT_REGION_ACTION` 常量（设置页行 id / set 分派 / dispatch 判断共用）；放这里而不是 settings.rs 是因为后者已到 400 行红线 - core/shared: 文档改准 —— forget 的范围是「登记处不再持有」，长命持有者必须自己重建； 记账从 `engine_for` 移到 `DownloadEngine::new` 这个卡口（分两把锁，避免自锁）， 于是 `constructions` 连绕过登记处另造引擎的调用点也统得住 守卫（都做了变异实证）： - update_tests::detect_region_rebuilds_the_update_factory_engine：走真实命令路径 `AppCommand::SetSetting` → 断言 Factory 换了引擎且指向登记处当前实例；变异（删掉 dispatch 里那句 refresh）→ 红在 Arc::ptr_eq - update_tests::rebuilding_the_factory_does_not_touch_a_running_job：重建不清 inflight、不改快照，在飞 Job 仍能跑完 - addon/http::tests::three_host_request_paths_share_one_engine：连走三条真实宿主路径 （Modrinth 元数据 GET / CF 带 header GET / Java 页渲染）后 constructions == 1； 变异（让 get_via_engine 自己造引擎）→ 红，left:2 right:1 顺带修：settings.rs 在上一提交被推到 403 行、engine.rs 401 行，两者都超 guards.yml 的 file-size 红线（>400 直接失败）。现在 settings.rs 400 / engine.rs 399， 全仓 `*.rs` 复跑「>400」扫描无输出。 验证：core lib 608 过、5 个 download 集成 target 42 过、presenter lib 270 过、 clippy --all-targets 干净、fmt 干净。真站点仍未打（见报告「没验的部分」）。 --- crates/core/src/download/engine.rs | 2 + crates/core/src/download/shared.rs | 74 ++++++++++----- crates/presenter/src/host/addon/http.rs | 111 ++++++++++++++++++++++ crates/presenter/src/host/dispatch.rs | 6 ++ crates/presenter/src/host/engine.rs | 8 ++ crates/presenter/src/host/settings.rs | 9 +- crates/presenter/src/host/update_state.rs | 30 ++++++ crates/presenter/src/host/update_tests.rs | 91 ++++++++++++++++++ 8 files changed, 299 insertions(+), 32 deletions(-) diff --git a/crates/core/src/download/engine.rs b/crates/core/src/download/engine.rs index 1c73895..091521e 100644 --- a/crates/core/src/download/engine.rs +++ b/crates/core/src/download/engine.rs @@ -74,6 +74,8 @@ impl DownloadEngine { let http = http::build_client(&cfg).unwrap_or_else(|_| reqwest::Client::new()); let sem = Arc::new(Semaphore::new(cfg.max_concurrency.max(1))); let seed = now_ms() ^ (u64::from(cfg.max_concurrency as u32) << 32); + // 纯记账（M165）：卡在构造这个点上，才统计得到绕过登记处的调用点（守卫靠 `constructions`）。 + super::shared::record_build(cache.root()); Self { http, cfg, diff --git a/crates/core/src/download/shared.rs b/crates/core/src/download/shared.rs index 5644c34..be5231d 100644 --- a/crates/core/src/download/shared.rs +++ b/crates/core/src/download/shared.rs @@ -26,6 +26,12 @@ //! * **活多久**：跟随进程。登记处**不做淘汰**——淘汰会让后续请求建出第二个引擎，同一个根上 //! 同时存在两条连接池，等于把要修的问题换个地方复现。要让地区判定等「一次性派生值」重算， //! 用 [`forget`] 显式失效（设置页「重新检测地区」就这么做）。 +//! * **`forget` 到什么范围**：只让登记处不再持有那一份。**已经拿到 `Arc` 的人继续用旧的**： +//! 短命请求自然结束（它们的窗口只有一次下载），但**长命持有者必须自己重建**——presenter 的 +//! 自更新子系统（`host::update::Factory`）从 `CoreHost::build` 起就把引擎存在字段里， +//! 只 forget 的话它会一直用旧实例（含旧地区档案）直到进程结束。所以「重新检测地区」那条 +//! 设置动作除了 [`forget`] 还调 `CoreHost::refresh_update_factory()` 把新引擎接过去 +//! （M165 复审 P2-1：这是本模块文档原先说漏的一半）。 //! * **并发多少**：`EngineConfig::default().max_concurrency`（64）现在是**进程级**上限， //! 不再是「每请求 64」。单请求独占时与从前一致；多请求并发时它们分摊这 64 张许可。 //! * **镜像切换 / 失效**：一律走引擎原有的候选规划 + 健康度冷却，本模块不参与判定；唯一可见的 @@ -39,7 +45,7 @@ use std::collections::HashMap; use std::path::{Path, PathBuf}; -use std::sync::{Arc, Mutex, MutexGuard, OnceLock}; +use std::sync::{Arc, Mutex, OnceLock}; use super::cache::{now_ms, ContentCache}; use super::config::EngineConfig; @@ -49,22 +55,19 @@ use super::mirrors::MirrorTable; use super::region::{decide_from, load_cached, store_cached}; use super::region_system::detect_signals; -/// 登记处：缓存根 → 引擎，外加「这个根建过几次引擎」（守卫/诊断用，**不**随淘汰清零）。 -#[derive(Debug, Default)] -struct Registry { - engines: HashMap>, - builds: HashMap, +/// 登记处：缓存根 → 引擎。 +fn registry() -> &'static Mutex>> { + static ENGINES: OnceLock>>> = OnceLock::new(); + ENGINES.get_or_init(|| Mutex::new(HashMap::new())) } -fn registry() -> &'static Mutex { - static REGISTRY: OnceLock> = OnceLock::new(); - REGISTRY.get_or_init(|| Mutex::new(Registry::default())) -} - -fn lock() -> MutexGuard<'static, Registry> { - registry() - .lock() - .unwrap_or_else(|poisoned| poisoned.into_inner()) +/// 「这个根建过几次引擎」的账本（守卫/诊断用，**不**随 [`forget`] 清零）。 +/// +/// 与 [`registry`] **分两把锁**：记账发生在 `DownloadEngine::new` 里（见 [`record_build`]）， +/// 而 [`engine_for`] 是**持着**登记处那把锁去调构造的——合成一把锁就是自己等自己。 +fn ledger() -> &'static Mutex> { + static BUILDS: OnceLock>> = OnceLock::new(); + BUILDS.get_or_init(|| Mutex::new(HashMap::new())) } /// 缓存根的键：去掉尾部分隔符（`D:/x/cache` 与 `D:/x/cache/` 视作同一根）。 @@ -85,35 +88,54 @@ fn key_of(cache_root: &Path) -> PathBuf { #[must_use] pub fn engine_for(cache_root: impl AsRef) -> Arc { let key = key_of(cache_root.as_ref()); - let mut reg = lock(); - if let Some(engine) = reg.engines.get(&key) { + let mut engines = registry() + .lock() + .unwrap_or_else(|poisoned| poisoned.into_inner()); + if let Some(engine) = engines.get(&key) { return Arc::clone(engine); } let engine = Arc::new(build(&key)); - reg.engines.insert(key.clone(), Arc::clone(&engine)); - *reg.builds.entry(key).or_default() += 1; + engines.insert(key, Arc::clone(&engine)); engine } /// 让该数据根的共享引擎失效（下次 [`engine_for`] 重新构造）。 /// -/// 在飞请求持有的 `Arc` 不受影响（它们继续用完手里那个引擎）；之后的新请求拿到新引擎， -/// 于是「重新检测地区」这类一次性派生值能真的重算。返回是否真淘汰了一份。 +/// **只让登记处不再持有那一份**：已经拿到 `Arc` 的人继续用旧的。短命请求自然结束；长命持有者 +/// （presenter 的自更新 `Factory`）必须自己重建，否则它会一直用旧实例——本仓在「重新检测地区」 +/// 的设置动作里调 `CoreHost::refresh_update_factory()` 补上这一步（见模块文档「`forget` 到什么范围」）。 +/// 返回是否真淘汰了一份。 pub fn forget(cache_root: impl AsRef) -> bool { - lock() - .engines + registry() + .lock() + .unwrap_or_else(|poisoned| poisoned.into_inner()) .remove(&key_of(cache_root.as_ref())) .is_some() } -/// 该数据根在本进程里**实际构造过几次引擎**。 +/// 记一笔「这个缓存根上又造了一个引擎」。 +/// +/// **唯一调用点是 [`DownloadEngine::new`]**（不是 [`engine_for`]）：记账卡在构造这个卡口上， +/// 于是 [`constructions`] 统计的是**进程里真实发生过几次构造**，与「谁造的」无关。 +/// 若只在 `engine_for` 里记账，任何绕过登记处、自己 `DownloadEngine::new` 的调用点都统计不到 +/// （M165 复审备注 2 的诉求）。 +pub(crate) fn record_build(cache_root: &Path) { + *ledger() + .lock() + .unwrap_or_else(|poisoned| poisoned.into_inner()) + .entry(key_of(cache_root)) + .or_default() += 1; +} + +/// 该数据根在本进程里**实际构造过几次引擎**（不论谁构造的）。 /// /// 这是给守卫与诊断用的：跨请求复用成立时，同一个根无论被请求多少次，这个数都停在 `1` /// （`forget` 之后每重建一次 +1）。只断言「结果一样」测不出复用——引擎建几次都能下同一个文件。 #[must_use] pub fn constructions(cache_root: impl AsRef) -> usize { - lock() - .builds + ledger() + .lock() + .unwrap_or_else(|poisoned| poisoned.into_inner()) .get(&key_of(cache_root.as_ref())) .copied() .unwrap_or(0) diff --git a/crates/presenter/src/host/addon/http.rs b/crates/presenter/src/host/addon/http.rs index aa315b6..f73368e 100644 --- a/crates/presenter/src/host/addon/http.rs +++ b/crates/presenter/src/host/addon/http.rs @@ -126,3 +126,114 @@ pub(super) fn encode(raw: &str) -> String { } out } + +#[cfg(test)] +mod tests { + use std::io::{Read as _, Write as _}; + use std::net::TcpListener; + use std::time::Duration; + + use unlucky_core::download::shared; + + use super::get; + use crate::host::env::HostEnv; + + /// 离线回环 HTTP 服务：只答固定 JSON，数「处理了几条请求 / 接了几条连接」。 + /// + /// 用 127.0.0.1 而不是真站点：**单测不许打公网**（CI 没网，也不该有）。 + fn loopback(expected_requests: usize) -> (String, std::sync::mpsc::Receiver<(usize, usize)>) { + let listener = TcpListener::bind("127.0.0.1:0").expect("绑定回环端口"); + let addr = listener.local_addr().expect("取端口"); + let (tx, rx) = std::sync::mpsc::channel(); + std::thread::spawn(move || { + let mut conns = 0usize; + let mut requests = 0usize; + while requests < expected_requests { + let Ok((mut socket, _)) = listener.accept() else { + break; + }; + conns += 1; + let _ = socket.set_read_timeout(Some(Duration::from_secs(5))); + 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; + let body = br#"{"ok":true}"#; + let head = format!( + "HTTP/1.1 200 OK\r\nContent-Type: application/json\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 { + let _ = tx.send((conns, requests)); + return; + } + } + } + let _ = tx.send((conns, requests)); + }); + (format!("http://{addr}/v2/search"), rx) + } + + /// 一个只用来放缓存根的临时数据根（`/.ULL/cache`）。 + fn data_root(tag: &str) -> std::path::PathBuf { + static SEQ: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0); + let seq = SEQ.fetch_add(1, std::sync::atomic::Ordering::SeqCst); + let dir = std::env::temp_dir().join(format!("ull-http-{tag}-{}-{seq}", std::process::id())); + let _ = std::fs::remove_dir_all(&dir); + std::fs::create_dir_all(dir.join(".ULL").join("cache")).expect("建缓存根"); + dir + } + + /// **端到端守卫（M165 复审备注 2）**：连走三条真实宿主请求路径，只该构造一个引擎。 + /// + /// 为什么不满足于「再断言一次 `engine()` 复用」：那种断言只钉漏斗本身——将来谁在调用点 + /// 自己 `DownloadEngine::new`，它照旧全绿。这里数的是 `shared::constructions`，而记账卡在 + /// `DownloadEngine::new` 这个卡口上（与谁造的无关），所以只要有一条路径另造引擎就会红。 + /// + /// 三条路径： + /// 1. [`get`] 无 header = 内容库的 Modrinth 元数据 GET（走 `engine.download_bytes`）； + /// 2. [`get`] 带 header = CurseForge 那条（走 `engine.client()`，另一条机制）； + /// 3. `host::java::vendors` = Java 页渲染（走 `domestic()`，非 HTTP 的漏斗消费者）。 + /// + /// 没走 `versions` 清单：它的地址是写死的 launchermeta，单测里要么打真网、要么吃满连接超时 + /// —— 那正是「测试里不该发生的事」，所以选了同样真实但完全离线的三条。 + #[test] + fn three_host_request_paths_share_one_engine() { + let dir = data_root("paths"); + let env = HostEnv::at_root(&dir); + let cache_root = env.layout.cache(); + let (url, counts) = loopback(2); + + let without_headers = get(&env, &url, &[]).expect("Modrinth 元数据 GET"); + let with_headers = get(&env, &url, &[("x-api-key", "test-key")]).expect("CF 带 header GET"); + let vendors = crate::host::java::vendors(&env, &[]); + + assert_eq!( + without_headers, with_headers, + "两条路径读的是同一份回环响应" + ); + assert!(!vendors.is_empty(), "Java 页应有发行版行"); + let (_, requests) = counts + .recv_timeout(Duration::from_secs(10)) + .expect("回环服务应报告计数"); + assert_eq!(requests, 2, "两条 HTTP 路径各发一条请求"); + assert_eq!( + shared::constructions(&cache_root), + 1, + "三条宿主请求路径必须共用同一个引擎（谁绕过漏斗另造一个，这条就红）" + ); + std::fs::remove_dir_all(&dir).ok(); + } +} diff --git a/crates/presenter/src/host/dispatch.rs b/crates/presenter/src/host/dispatch.rs index a8a679d..081d9fd 100644 --- a/crates/presenter/src/host/dispatch.rs +++ b/crates/presenter/src/host/dispatch.rs @@ -219,6 +219,12 @@ impl CoreHost { } AppCommand::SetSetting { key, value } => match settings::set(&self.env, &key, &value) { Ok(()) => { + // 「重新检测地区」：`settings::set` 已经删了 `region.json` 并让共享引擎失效， + // 但自更新的 `Factory` 常驻持有旧引擎 —— 不在这条路径上重建它，自更新会继续 + // 按旧地区档案跑，直到重启（M165 复审 P2-1）。 + if key == super::engine::DETECT_REGION_ACTION { + self.refresh_update_factory(); + } self.send(CoreEvent::SettingsChanged(settings::groups(&self.env))); self.java_chain.clear(); self.refresh_java(); diff --git a/crates/presenter/src/host/engine.rs b/crates/presenter/src/host/engine.rs index 1746d99..3dc1e04 100644 --- a/crates/presenter/src/host/engine.rs +++ b/crates/presenter/src/host/engine.rs @@ -40,6 +40,14 @@ pub fn domestic(env: &HostEnv) -> bool { engine(env).region().is_domestic() } +/// 「重新检测地区」这个动作键（设置页的行 id、`settings::set` 的分派、`dispatch` 里「要不要重建 +/// 自更新 Factory」的判断共用一个真相源）。 +/// +/// 动作不是普通设置：它要清 `region.json`、让 [`forget`] 失效共享引擎，并让自更新的 `Factory` +/// 换引擎（M165 复审 P2-1）——所以三处都得认出它。常量放这里（引擎/地区这一侧），不放已经顶到 +/// 400 行红线的 `settings.rs`。 +pub(super) const DETECT_REGION_ACTION: &str = "download.action.detect_region"; + /// 设置里的 `java.vendorPriority`（空 = 按地区默认序）。 pub fn java_priority(env: &HostEnv) -> Vec { env.store() diff --git a/crates/presenter/src/host/settings.rs b/crates/presenter/src/host/settings.rs index 950ff0e..acb633e 100644 --- a/crates/presenter/src/host/settings.rs +++ b/crates/presenter/src/host/settings.rs @@ -136,7 +136,7 @@ fn download_group(env: &HostEnv) -> SettingGroupView { &text(env, "download.proxy_url"), )) .with(SettingRowView::action( - "download.action.detect_region", + super::engine::DETECT_REGION_ACTION, "重新检测地区", "清掉 24h 地区缓存，下次下载重新判定", "detect_region", @@ -322,7 +322,7 @@ fn mcp_group(env: &HostEnv) -> SettingGroupView { /// /// 未知键、值类型不符、越界、落盘失败时返回用户可读文案。 pub fn set(env: &HostEnv, key: &str, value: &str) -> Result<(), String> { - if key == "download.action.detect_region" { + if key == super::engine::DETECT_REGION_ACTION { return detect_region(env); } let parsed = parse_value(key, value)?; @@ -370,10 +370,7 @@ fn parse_value(key: &str, value: &str) -> Result { } } -/// 清掉 24h 地区缓存（下次建引擎重新判定）。 -/// -/// M165 起引擎是进程级共享的：光删 `region.json` 不够（下次请求根本不会重建引擎）， -/// 必须同时让共享登记处淘汰这一份，否则「重新检测地区」这句话在本次运行里不生效。 +/// 清掉 24h 地区缓存并让共享引擎失效（下次请求重新判定；自更新那份由 `dispatch` 重建 Factory）。 fn detect_region(env: &HostEnv) -> Result<(), String> { let path = env.layout.cache().join("region.json"); if path.is_file() { diff --git a/crates/presenter/src/host/update_state.rs b/crates/presenter/src/host/update_state.rs index 931ee5b..31105df 100644 --- a/crates/presenter/src/host/update_state.rs +++ b/crates/presenter/src/host/update_state.rs @@ -66,6 +66,27 @@ impl Runtime { &self.view } + /// 重建「怎么造 Job」的装配（M165 复审 P2-1）。 + /// + /// 自更新的 `Factory` 常驻持有下载引擎，`download::shared::forget` 换不掉它；「重新检测地区」 + /// 要生效就得把新引擎接过来。只换 `factory`，**不动** `view` / `inflight` / 迁移收据： + /// 后台在飞的那条 Job 在派发时（`begin_check` / `begin_apply` → `Job`）就已经把 factory + /// 克隆进线程了，所以重建**不会**打断正在跑的检查/应用，只影响下一次派发。 + pub fn rebuild_factory(&mut self, env: &HostEnv) { + self.factory = Factory::for_env(env); + } + + /// 装配里那个下载引擎（单测断言「换了引擎」用；`Dir` 形态没有引擎）。 + #[cfg(test)] + pub(super) fn factory_engine( + &self, + ) -> Option<&std::sync::Arc> { + match &self.factory { + Factory::Default { engine, .. } => Some(engine), + Factory::Dir { .. } => None, + } + } + /// 当前快照（克隆给事件/线程）。 #[must_use] pub fn snapshot(&self) -> UpdateView { @@ -222,6 +243,15 @@ impl CoreHost { self.send(CoreEvent::Update(Box::new(view))); } + /// 让自更新子系统手里的引擎跟上共享登记处（M165 复审 P2-1）。 + /// + /// 自更新的 `Factory` 从 `CoreHost::build` 起就把引擎存进字段，`shared::forget` 只让登记处 + /// 不再持有那一份，换不掉它。所以「重新检测地区」除了失效登记处，还必须调本方法，否则自更新 + /// 会继续按**旧地区档案**展开候选，直到进程结束。 + pub(super) fn refresh_update_factory(&mut self) { + self.update.rebuild_factory(&self.env); + } + /// 派一次检查（`manual` = 设置页点的「立即检查」；`false` = 启动时的静默检查）。 pub(super) fn start_update_check(&mut self, manual: bool) { let Some(current) = self.update.current() else { diff --git a/crates/presenter/src/host/update_tests.rs b/crates/presenter/src/host/update_tests.rs index 568127e..a0d3a69 100644 --- a/crates/presenter/src/host/update_tests.rs +++ b/crates/presenter/src/host/update_tests.rs @@ -17,6 +17,7 @@ use std::path::{Path, PathBuf}; use std::sync::atomic::{AtomicU64, Ordering}; +use unlucky_core::download::region::{RegionMode, RegionProfile}; use unlucky_core::download::verify::digest_bytes; use unlucky_core::download::HashAlgo; use unlucky_core::update::{Applied, Channel, Target, Version}; @@ -242,3 +243,93 @@ fn a_higher_version_without_our_platform_is_not_up_to_date() { mod apply; #[path = "update_session_tests.rs"] mod session; + +// ---------------------------------------------------------------- M165 复审 P2-1 +// +// 这两条走的是**真实的命令路径**（`AppCommand::SetSetting` → `dispatch` → `settings::set`）， +// 不是直接调内部函数：要守的正是「动作路径上有没有把该做的事做全」。 + +/// 「重新检测地区」之后，**自更新手里的引擎也要换**。 +/// +/// 自更新的 `Factory` 从 `CoreHost::build` 起就把引擎存在字段里（常驻到进程结束）； +/// `download::shared::forget` 只让登记处不再持有那一份，**换不掉**它。于是只 forget 的话， +/// 自更新会继续按**旧地区档案**展开候选，直到重启——M165 复审 P2-1 的那个洞。 +/// +/// 抓得住的变异：删掉 `host/dispatch.rs` 的 `SetSetting` 成功分支里那句 +/// `self.refresh_update_factory()` ⇒ 本用例红在 `Arc::ptr_eq`（Factory 还是淘汰前那一份）。 +#[test] +fn detect_region_rebuilds_the_update_factory_engine() { + use std::sync::Arc; + use unlucky_core::download::shared; + + let tmp = TempDir::new("region-refresh"); + let env = HostEnv::at_root(tmp.path()); + std::fs::create_dir_all(env.layout.cache()).expect("建缓存目录"); + // 钉一份确定的地区档案：第一次构造不依赖本机时区/语言，断言才有确定的起点。 + let region_path = env.layout.cache().join("region.json"); + unlucky_core::download::region::store_cached( + ®ion_path, + &RegionProfile::pinned(RegionMode::Direct, unlucky_core::download::cache::now_ms()), + ) + .expect("写 region.json"); + + let mut host = crate::host::CoreHost::headless(env.clone()); + let cache_root = env.layout.cache(); + assert_eq!( + shared::constructions(&cache_root), + 1, + "装配时只该造一个引擎" + ); + let before = host + .update + .factory_engine() + .expect("生产装配（Default）应有引擎") + .clone(); + assert_eq!(before.region().mode, RegionMode::Direct); + + host.dispatch_command(crate::dto::AppCommand::SetSetting { + key: "download.action.detect_region".to_string(), + value: String::new(), + }); + + let after = host + .update + .factory_engine() + .expect("重建后仍该有引擎") + .clone(); + assert!( + !Arc::ptr_eq(&before, &after), + "「重新检测地区」必须换掉自更新用的引擎（否则它按旧地区档案跑到进程结束）" + ); + assert!( + Arc::ptr_eq(&after, &crate::host::engine::engine(&env)), + "自更新必须指向登记处的当前引擎，而不是被淘汰的那一份" + ); + assert_eq!( + shared::constructions(&cache_root), + 2, + "淘汰一次 = 多构造一次（既不多也不少）" + ); +} + +/// 重建 `Factory` **不打断**在飞的检查/应用：在跑的那条 `Job` 派发时就已经把装配克隆走了。 +#[test] +fn rebuilding_the_factory_does_not_touch_a_running_job() { + let tmp = TempDir::new("factory-rebuild"); + dir_source(&tmp, &manifest_for("0.9.0", b"new", "notes"), b"new"); + let env = HostEnv::at_root(tmp.path()); + let mut runtime = Runtime::with_factory(&env, factory(&tmp)); + + // 派发一条（模拟「正在查」），再重建装配： + let job = runtime.begin_check(true).expect("应能派发"); + assert!(runtime.inflight()); + runtime.rebuild_factory(&env); + assert!(runtime.inflight(), "重建装配不该清掉在飞标记"); + assert!( + matches!(runtime.view().outcome, UpdateOutcome::Checking), + "重建装配不该改状态快照" + ); + // 在飞那条 Job 仍然可用（它拿着自己那份装配），能正常跑完并回报。 + let outcome = outcome_of(job.check(&version("0.2.2"), Channel::Stable)); + assert_eq!(outcome.as_str(), "available"); +}