feat(presenter): 新建 unlucky-presenter，把 host/状态/DTO/设置桥从 app 迁出（M85 第 1 块）
D26（iced 重写）的关键一次性动作：UI 框架无关的宿主层独立成 crate， Slint 版（crates/app）与 iced 版（crates/app-iced）共用，Slint 退役后不再重写一遍。 - 新建 crates/presenter（package `unlucky-presenter` / lib `unlucky_presenter`）， workspace 登记 + crate 文档头写清「这层为什么存在」、对外表面、UI 侧允许/禁止、 iced 接线骨架、以及哪些东西留在了 crates/app 及为什么。 - `git mv`（保留文件历史）迁入：host/（25 文件）、dto/（11 文件）、state.rs(+tests)、 prefs.rs、settings_bridge.rs、toast.rs、router.rs、dialogs.rs、wizard.rs、 mock.rs、mock_data.rs、backend.rs。模块路径与公开 API 名称不变（`host::install` 等）， 内部实现零改动。 - 新增 `theme`：把原本混在 ui_bind/theme_runtime 里的**纯判据**（CONFIG_POLL_TICKS / SYSTEM_THEME_POLL_TICKS / TILE_REGENERATE_STEP / BackgroundKey / tile_viewport / system_theme_value / 两个 poll 判据）抽出来，附 5 个单测；app 侧改成调用它们。 - crates/app 改为消费者：删掉迁走的文件，`crate::host|state|dto|prefs|settings_bridge| toast|router|dialogs|wizard|mock|mock_data|backend` 全部改写为 `unlucky_presenter::*` （64 处），backend.rs 的 config_path/build_backend 提为 pub。 - crates/app-iced 只登记 unlucky-presenter 依赖，本 mission 不接线。 - prefs.rs 的 2 处 slint 文档引用改写；`grep -rn slint crates/presenter` 现在无输出。
This commit is contained in:
AskaEth committed
1 parent
00f132d8ce
commit
f159529936
69 files changed
+441
-129
No files matched your search
@@ -0,0 +1,274 @@
|
||||
//! 账户：三轨统一列表（只读公开字段）+ 离线新增 + 删除/切换 + 微软登录（两条流）。
|
||||
//!
|
||||
//! 凭据红线（D9）：`Credentials` / `MicrosoftSession` 只在本模块与 `launch.rs` 里出现，
|
||||
//! 出口一律是 [`AccountView`] / [`DeviceLoginView`]。
|
||||
//!
|
||||
//! 两条登录流：授权码（[`start_browser_login`]，GUI 默认：拉起系统浏览器 + 本地回调，
|
||||
//! `research/08` §3 方案 A）与设备码（[`start_login`]，无浏览器/CLI 场景）。除了「怎么拿到
|
||||
//! MS access_token」之外完全共用：同一个取消槽位、同一段账户入库、同一个刷新链。
|
||||
//!
|
||||
//! 取消语义：轮询/等回调都跑在 `core` 里、没有取消钩子，所以取消只把面板收回；线程收尾时
|
||||
//! 若发现「已取消」就不入库（避免用户点了取消却凭空多出一个账户）。
|
||||
|
||||
use std::sync::atomic::{AtomicBool, Ordering};
|
||||
use std::sync::Arc;
|
||||
|
||||
use unlucky_core::auth::account::Credentials;
|
||||
use unlucky_core::auth::microsoft::{now_ms, MicrosoftAuth, MicrosoftSession};
|
||||
use unlucky_core::auth::offline::offline_meta;
|
||||
use unlucky_core::auth::{AccountStore, AuthResult};
|
||||
use unlucky_core::download::blocking::block_on;
|
||||
|
||||
use crate::dto::{AccountKind, AccountView, DeviceLoginView};
|
||||
|
||||
use super::env::HostEnv;
|
||||
use super::job::{spawn, HostTask, JobSender};
|
||||
use super::opener;
|
||||
|
||||
/// 账户列表（公开字段）。
|
||||
pub fn accounts(env: &HostEnv, active: Option<&str>) -> Vec<AccountView> {
|
||||
let store = AccountStore::open(env.layout.auth_data());
|
||||
store
|
||||
.accounts()
|
||||
.iter()
|
||||
.map(|meta| AccountView {
|
||||
id: meta.id.as_str().to_string(),
|
||||
name: meta.display_name().to_string(),
|
||||
kind: AccountKind::parse(meta.kind.as_str()),
|
||||
profile_id: meta.profile_id.clone(),
|
||||
login_name: meta.login_name.clone().unwrap_or_default(),
|
||||
created: display_ms(meta.created_at_ms),
|
||||
active: active.is_some_and(|id| id == meta.id.as_str()),
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// 毫秒时间戳 → `2026-10-31 20:12`（UTC；账户列表只用来排序/辨认）。
|
||||
pub fn display_ms(ms: u64) -> String {
|
||||
if ms == 0 {
|
||||
return String::new();
|
||||
}
|
||||
let total_secs = ms / 1000;
|
||||
let days = total_secs / 86_400;
|
||||
let rem = total_secs % 86_400;
|
||||
let (year, month, day) = civil_from_days(i64::try_from(days).unwrap_or(0));
|
||||
format!(
|
||||
"{year:04}-{month:02}-{day:02} {:02}:{:02}",
|
||||
rem / 3_600,
|
||||
(rem % 3_600) / 60
|
||||
)
|
||||
}
|
||||
|
||||
/// Howard Hinnant 的 `civil_from_days`（1970-01-01 为 0）。
|
||||
fn civil_from_days(days: i64) -> (i64, u32, u32) {
|
||||
let z = days + 719_468;
|
||||
let era = if z >= 0 { z } else { z - 146_096 } / 146_097;
|
||||
let doe = z - era * 146_097;
|
||||
let yoe = (doe - doe / 1_460 + doe / 36_524 - doe / 146_096) / 365;
|
||||
let y = yoe + era * 400;
|
||||
let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
|
||||
let mp = (5 * doy + 2) / 153;
|
||||
let d = doy - (153 * mp + 2) / 5 + 1;
|
||||
let m = if mp < 10 { mp + 3 } else { mp - 9 };
|
||||
(if m <= 2 { y + 1 } else { y }, m as u32, d as u32)
|
||||
}
|
||||
|
||||
/// 加一个离线账户。
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// 名字不合法、同名冲突、落盘失败时返回用户可读文案。
|
||||
pub fn add_offline(env: &HostEnv, name: &str) -> Result<String, String> {
|
||||
let name = name.trim();
|
||||
let meta = offline_meta(name, now_ms()).map_err(|error| error.to_string())?;
|
||||
let display = meta.display_name().to_string();
|
||||
let mut store = AccountStore::open(env.layout.auth_data());
|
||||
store
|
||||
.insert(meta, Credentials::Offline)
|
||||
.map_err(|error| format!("添加账户失败：{error}"))?;
|
||||
store
|
||||
.save()
|
||||
.map_err(|error| format!("保存账户失败：{error}"))?;
|
||||
Ok(display)
|
||||
}
|
||||
|
||||
/// 删除账户（按 id 或名字）。
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// 找不到、落盘失败时返回用户可读文案。
|
||||
pub fn remove(env: &HostEnv, key: &str) -> Result<String, String> {
|
||||
let mut store = AccountStore::open(env.layout.auth_data());
|
||||
let meta = store
|
||||
.remove(key)
|
||||
.map_err(|error| format!("删除账户失败：{error}"))?;
|
||||
store
|
||||
.save()
|
||||
.map_err(|error| format!("保存账户失败：{error}"))?;
|
||||
Ok(meta.display_name().to_string())
|
||||
}
|
||||
|
||||
/// 微软登录任务句柄（取消标志 + 账户名回执；两条流共用）。
|
||||
#[derive(Debug, Clone, Default)]
|
||||
pub struct LoginJob {
|
||||
/// 用户点了取消（线程收尾时据此丢弃结果）
|
||||
pub cancelled: Arc<AtomicBool>,
|
||||
}
|
||||
|
||||
impl LoginJob {
|
||||
/// 新建一个未取消的句柄。
|
||||
pub fn new() -> Self {
|
||||
Self {
|
||||
cancelled: Arc::new(AtomicBool::new(false)),
|
||||
}
|
||||
}
|
||||
|
||||
/// 取消。
|
||||
pub fn cancel(&self) {
|
||||
self.cancelled.store(true, Ordering::SeqCst);
|
||||
}
|
||||
|
||||
/// 是否已取消。
|
||||
pub fn is_cancelled(&self) -> bool {
|
||||
self.cancelled.load(Ordering::SeqCst)
|
||||
}
|
||||
}
|
||||
|
||||
/// 起一次设备码登录（后台线程；`present` 时刻发 Waiting 事件）。
|
||||
pub fn start_login(env: HostEnv, tx: JobSender, job: LoginJob) {
|
||||
spawn("msa-login", move || {
|
||||
let auth = match microsoft_auth(&env) {
|
||||
Ok(auth) => auth,
|
||||
Err(message) => return fail(&tx, message),
|
||||
};
|
||||
let tx_prompt = tx.clone();
|
||||
let result = block_on(auth.device_code_login(|prompt| {
|
||||
let _ = tx_prompt.send(HostTask::Login(Box::new(DeviceLoginView::waiting(
|
||||
&prompt.user_code,
|
||||
&prompt.verification_uri,
|
||||
prompt.expires_in.as_secs(),
|
||||
&format!("{}#{}", prompt.verification_uri, prompt.user_code),
|
||||
))));
|
||||
}));
|
||||
finish(&env, &tx, &job, result);
|
||||
});
|
||||
}
|
||||
|
||||
/// 起一次授权码登录（后台线程：绑本地端口 → 拉起系统默认浏览器 → 等回调 → 换链）。
|
||||
///
|
||||
/// 与设备码流共用同一个 [`LoginJob`] 取消槽位、同一段账户入库逻辑，所以两条流的
|
||||
/// 凭据/刷新语义完全一致（`core` 侧也共用 [`unlucky_core::auth::MicrosoftSession`]）。
|
||||
pub fn start_browser_login(env: HostEnv, tx: JobSender, job: LoginJob) {
|
||||
spawn("msa-authcode", move || {
|
||||
let auth = match microsoft_auth(&env) {
|
||||
Ok(auth) => auth,
|
||||
Err(message) => return fail(&tx, message),
|
||||
};
|
||||
let tx_prompt = tx.clone();
|
||||
let result = block_on(auth.authcode_login(|prompt| {
|
||||
// 浏览器拉不起来不是致命错误：面板里还有可复制的授权链接。
|
||||
let opened = opener::open_url(&prompt.authorization_url);
|
||||
let _ = tx_prompt.send(HostTask::Login(Box::new(DeviceLoginView::browser_waiting(
|
||||
&prompt.authorization_url,
|
||||
prompt.timeout.as_secs(),
|
||||
opened.err().as_deref(),
|
||||
))));
|
||||
}));
|
||||
finish(&env, &tx, &job, result);
|
||||
});
|
||||
}
|
||||
|
||||
/// 生产入口的 `MicrosoftAuth`：client id 取环境/构建期，失败日志落 `<数据根>/logs/`。
|
||||
fn microsoft_auth(env: &HostEnv) -> Result<MicrosoftAuth, String> {
|
||||
MicrosoftAuth::from_env()
|
||||
.map(|auth| {
|
||||
auth.with_journal(Some(unlucky_core::auth::AuthJournal::in_logs_dir(
|
||||
env.layout.logs(),
|
||||
)))
|
||||
})
|
||||
.map_err(|error| error.to_string())
|
||||
}
|
||||
|
||||
fn fail(tx: &JobSender, message: String) {
|
||||
let _ = tx.send(HostTask::Login(Box::new(DeviceLoginView::failed(message))));
|
||||
}
|
||||
|
||||
/// 收尾：取消就吞掉结果；成功入库；失败带 core 的诊断文案（M38 的 403 也走这条）。
|
||||
fn finish(env: &HostEnv, tx: &JobSender, job: &LoginJob, result: AuthResult<MicrosoftSession>) {
|
||||
if job.is_cancelled() {
|
||||
let _ = tx.send(HostTask::Login(Box::default()));
|
||||
return;
|
||||
}
|
||||
match result {
|
||||
Ok(session) => match store_session(env, session) {
|
||||
Ok(name) => {
|
||||
let _ = tx.send(HostTask::Login(Box::new(DeviceLoginView::succeeded(&name))));
|
||||
let _ = tx.send(HostTask::Accounts(accounts(env, None)));
|
||||
}
|
||||
Err(message) => fail(tx, message),
|
||||
},
|
||||
Err(error) => fail(tx, error.to_string()),
|
||||
}
|
||||
}
|
||||
|
||||
/// 微软会话入库（元数据 + 凭据分文件，见 `core::auth::AccountStore`）。
|
||||
fn store_session(env: &HostEnv, session: MicrosoftSession) -> Result<String, String> {
|
||||
let meta = unlucky_core::auth::account::AccountMeta::new(
|
||||
unlucky_core::auth::account::AccountKind::Microsoft,
|
||||
session.profile_id.clone(),
|
||||
session.profile_name.clone(),
|
||||
now_ms(),
|
||||
);
|
||||
let name = meta.display_name().to_string();
|
||||
let mut store = AccountStore::open(env.layout.auth_data());
|
||||
store
|
||||
.insert(meta, Credentials::Microsoft(session))
|
||||
.and_then(|()| store.save())
|
||||
.map_err(|error| format!("账户入库失败：{error}"))?;
|
||||
Ok(name)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn time_display_matches_known_timestamps() {
|
||||
assert_eq!(display_ms(0), "");
|
||||
// 1_769_000_000_000 ms = 2026-01-21T12:53:20Z（取整到分钟）
|
||||
assert_eq!(display_ms(1_769_000_000_000), "2026-01-21 12:53");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn offline_add_list_remove_round_trips() {
|
||||
let dir = std::env::temp_dir().join(format!("ull-host-accounts-{}", std::process::id()));
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
let env = HostEnv::at_root(&dir);
|
||||
std::fs::create_dir_all(env.layout.auth_data()).expect("auth 目录");
|
||||
|
||||
let name = add_offline(&env, "Steve").expect("加账户");
|
||||
assert_eq!(name, "Steve");
|
||||
let list = accounts(&env, None);
|
||||
assert_eq!(list.len(), 1);
|
||||
assert_eq!(list[0].kind, AccountKind::Offline);
|
||||
assert!(!list[0].active);
|
||||
|
||||
let active = accounts(&env, Some(list[0].id.as_str()));
|
||||
assert!(active[0].active);
|
||||
|
||||
let removed = remove(&env, "Steve").expect("删账户");
|
||||
assert_eq!(removed, "Steve");
|
||||
assert!(accounts(&env, None).is_empty());
|
||||
assert!(add_offline(&env, " ").is_err());
|
||||
std::fs::remove_dir_all(&dir).ok();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn login_job_cancel_flag_is_shared() {
|
||||
let job = LoginJob::new();
|
||||
let clone = job.clone();
|
||||
assert!(!clone.is_cancelled());
|
||||
job.cancel();
|
||||
assert!(clone.is_cancelled());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,162 @@
|
||||
//! `CoreHost::dispatch` 的指令实现（从 `host/mod.rs` 拆出，守 400 行上限）。
|
||||
//!
|
||||
//! 父模块的私有字段对子模块可见，所以这里直接读写 `self.env` / `self.tx` 等。
|
||||
|
||||
use crate::dto::{AppCommand, Backend, CoreEvent, CreateRequest, LoaderKind};
|
||||
use crate::toast::ToastKind;
|
||||
|
||||
use super::accounts::{self, LoginJob};
|
||||
use super::{game, install, java, launch, logs, settings, versions, CoreHost};
|
||||
|
||||
impl CoreHost {
|
||||
/// 下发一条用户意图（`Backend::dispatch` 的实现体）。
|
||||
pub(super) fn dispatch_command(&mut self, command: AppCommand) {
|
||||
self.dispatch_inner(command);
|
||||
}
|
||||
}
|
||||
impl CoreHost {
|
||||
/// 指令分发（见 `dispatch_command`）。
|
||||
fn dispatch_inner(&mut self, command: AppCommand) {
|
||||
match command {
|
||||
AppCommand::RefreshAll => self.refresh_all(),
|
||||
AppCommand::LaunchInstance(id) => self.start_launch(&id),
|
||||
AppCommand::StopInstance(id) => match self.running_pid(&id) {
|
||||
Some(pid) => match launch::stop(pid) {
|
||||
Ok(()) => self.toast(ToastKind::Info, "已请求停止游戏进程"),
|
||||
Err(reason) => self.toast(ToastKind::Error, reason),
|
||||
},
|
||||
None => self.toast(ToastKind::Warn, "这个实例当前没有在跑"),
|
||||
},
|
||||
AppCommand::ListVersions(_) => versions::spawn_list(self.env.clone(), self.tx.clone()),
|
||||
AppCommand::InstallVersion(version) => {
|
||||
let cancel = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false));
|
||||
self.install_cancel = Some(std::sync::Arc::clone(&cancel));
|
||||
install::spawn_install(
|
||||
self.env.clone(),
|
||||
self.tx.clone(),
|
||||
CreateRequest {
|
||||
name: version.clone(),
|
||||
version,
|
||||
loader: LoaderKind::Vanilla,
|
||||
loader_version: String::new(),
|
||||
},
|
||||
cancel,
|
||||
);
|
||||
}
|
||||
AppCommand::CreateInstance(request) => {
|
||||
let cancel = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false));
|
||||
self.install_cancel = Some(std::sync::Arc::clone(&cancel));
|
||||
install::spawn_install(self.env.clone(), self.tx.clone(), request, cancel);
|
||||
}
|
||||
AppCommand::CancelInstall => {
|
||||
// 取消只在阶段边界生效（core 的下载循环没有取消钩子）：这里先把面板收回，
|
||||
// 后台线程会在下一阶段开始前看到标记并收尾。
|
||||
if let Some(cancel) = &self.install_cancel {
|
||||
cancel.store(true, std::sync::atomic::Ordering::SeqCst);
|
||||
}
|
||||
self.install = None;
|
||||
self.send(CoreEvent::InstallProgress(None));
|
||||
}
|
||||
AppCommand::SetIsolation { id, mode } => {
|
||||
match game::set_isolation(&self.env, &id, &mode) {
|
||||
Ok(()) => {
|
||||
self.toast(ToastKind::Success, "隔离档位已更新");
|
||||
self.refresh_instances();
|
||||
}
|
||||
Err(reason) => self.toast(ToastKind::Error, reason),
|
||||
}
|
||||
}
|
||||
AppCommand::RefreshLogSessions => {
|
||||
self.send(CoreEvent::LogSessionsChanged(logs::sessions(&self.env)));
|
||||
}
|
||||
AppCommand::OpenLogSession(id) => self.open_session(&id),
|
||||
AppCommand::ImportCrashLog(path) => match logs::analyze_crash_file(&path) {
|
||||
Ok((label, report)) => {
|
||||
self.send(CoreEvent::DiagnosisReady(report));
|
||||
self.toast(ToastKind::Info, label);
|
||||
}
|
||||
Err(reason) => self.toast(ToastKind::Warn, reason),
|
||||
},
|
||||
AppCommand::AddOfflineAccount(name) => match accounts::add_offline(&self.env, &name) {
|
||||
Ok(display) => {
|
||||
self.toast(ToastKind::Success, format!("已添加离线账户 {display}"));
|
||||
self.refresh_accounts();
|
||||
}
|
||||
Err(reason) => self.toast(ToastKind::Error, reason),
|
||||
},
|
||||
AppCommand::RemoveAccount(key) => match accounts::remove(&self.env, &key) {
|
||||
Ok(display) => {
|
||||
if self.active_account.as_deref() == Some(key.as_str()) {
|
||||
self.active_account = None;
|
||||
}
|
||||
self.toast(ToastKind::Info, format!("已删除账户 {display}"));
|
||||
self.refresh_accounts();
|
||||
}
|
||||
Err(reason) => self.toast(ToastKind::Error, reason),
|
||||
},
|
||||
AppCommand::SwitchAccount(id) => {
|
||||
self.active_account = Some(id);
|
||||
self.refresh_accounts();
|
||||
self.toast(ToastKind::Info, "已切换启动账户");
|
||||
}
|
||||
AppCommand::StartDeviceLogin => {
|
||||
self.login = Some(LoginJob::new());
|
||||
let job = self.login.clone().unwrap_or_default();
|
||||
self.send(CoreEvent::DeviceLoginChanged(crate::dto::DeviceLoginView {
|
||||
phase: crate::dto::DeviceLoginPhase::Requesting,
|
||||
message: "正在向微软申请设备码…".to_string(),
|
||||
..crate::dto::DeviceLoginView::new()
|
||||
}));
|
||||
accounts::start_login(self.env.clone(), self.tx.clone(), job);
|
||||
}
|
||||
AppCommand::StartBrowserLogin => {
|
||||
self.login = Some(LoginJob::new());
|
||||
let job = self.login.clone().unwrap_or_default();
|
||||
self.send(CoreEvent::DeviceLoginChanged(crate::dto::DeviceLoginView {
|
||||
phase: crate::dto::DeviceLoginPhase::Requesting,
|
||||
message: "正在准备浏览器登录（本地回调端口）…".to_string(),
|
||||
..crate::dto::DeviceLoginView::new()
|
||||
}));
|
||||
accounts::start_browser_login(self.env.clone(), self.tx.clone(), job);
|
||||
}
|
||||
AppCommand::CancelDeviceLogin => {
|
||||
if let Some(job) = &self.login {
|
||||
job.cancel();
|
||||
}
|
||||
self.login = None;
|
||||
self.send(CoreEvent::DeviceLoginChanged(
|
||||
crate::dto::DeviceLoginView::new(),
|
||||
));
|
||||
}
|
||||
AppCommand::InstallJava(vendor) => {
|
||||
self.java_busy = true;
|
||||
self.java_message = format!("正在安装 Java（{vendor}）…");
|
||||
self.refresh_java();
|
||||
java::spawn_install(
|
||||
self.env.clone(),
|
||||
self.tx.clone(),
|
||||
unlucky_core::game::java::JdkVendor::parse(&vendor),
|
||||
);
|
||||
}
|
||||
AppCommand::SetSetting { key, value } => match settings::set(&self.env, &key, &value) {
|
||||
Ok(()) => {
|
||||
self.send(CoreEvent::SettingsChanged(settings::groups(&self.env)));
|
||||
self.java_chain.clear();
|
||||
self.refresh_java();
|
||||
}
|
||||
Err(reason) => self.toast(ToastKind::Error, reason),
|
||||
},
|
||||
AppCommand::DismissNotice(id) => {
|
||||
self.notices.retain(|notice| notice.id != id);
|
||||
self.send(CoreEvent::NoticesChanged(self.notices.clone()));
|
||||
}
|
||||
// AI 对话：agent 的 GUI host 未落地前用脚本回复（不接真实模型）
|
||||
other @ (AppCommand::AskAgent(_) | AppCommand::StopAgent | AppCommand::SetYolo(_)) => {
|
||||
self.chat.dispatch(other);
|
||||
for event in self.chat.drain_events() {
|
||||
self.events.push_back(event);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,126 @@
|
||||
//! 下载引擎与 Java 落点的装配（versions / install / java 三个任务共用）。
|
||||
//!
|
||||
//! 与 CLI `install::build_engine` 同源：内容寻址缓存落 `.ULL/cache/`，地区判定走
|
||||
//! 24h 缓存 + 环境信号（**不做网络探测**，与 D7 的「不探测时」约定一致）。
|
||||
|
||||
use std::path::PathBuf;
|
||||
use std::sync::Arc;
|
||||
|
||||
use unlucky_core::download::cache::now_ms;
|
||||
use unlucky_core::download::region::{decide_from, load_cached, store_cached};
|
||||
use unlucky_core::download::region_system::detect_signals;
|
||||
use unlucky_core::download::{
|
||||
ContentCache, DownloadEngine, EngineConfig, HealthRegistry, MirrorTable,
|
||||
};
|
||||
use unlucky_core::game::java::vendor::JdkVendor;
|
||||
use unlucky_core::game::java::{self, JavaInstallRoot};
|
||||
use unlucky_core::platform::paths::ProcessEnv;
|
||||
|
||||
use super::env::HostEnv;
|
||||
|
||||
/// 建下载引擎（缓存/健康度/地区判定都在数据根里）。
|
||||
pub fn engine(env: &HostEnv) -> DownloadEngine {
|
||||
let cache_root = env.layout.cache();
|
||||
let now = now_ms();
|
||||
let region_path = cache_root.join("region.json");
|
||||
let region = load_cached(®ion_path, now).unwrap_or_else(|| {
|
||||
let profile = decide_from(&detect_signals(), now);
|
||||
let _ = store_cached(®ion_path, &profile);
|
||||
profile
|
||||
});
|
||||
DownloadEngine::new(
|
||||
EngineConfig::default(),
|
||||
Arc::new(MirrorTable::builtin()),
|
||||
Arc::new(region),
|
||||
Arc::new(HealthRegistry::open_in(&cache_root, now)),
|
||||
Arc::new(ContentCache::open(&cache_root)),
|
||||
)
|
||||
}
|
||||
|
||||
/// 是否国内网络（决定默认发行版顺序与镜像优先级）。
|
||||
pub fn domestic(env: &HostEnv) -> bool {
|
||||
engine(env).region().is_domestic()
|
||||
}
|
||||
|
||||
/// 设置里的 `java.vendorPriority`（空 = 按地区默认序）。
|
||||
pub fn java_priority(env: &HostEnv) -> Vec<JdkVendor> {
|
||||
env.store()
|
||||
.effective("java.vendorPriority")
|
||||
.and_then(serde_json::Value::as_array)
|
||||
.map(|items| {
|
||||
let texts: Vec<String> = items
|
||||
.iter()
|
||||
.filter_map(serde_json::Value::as_str)
|
||||
.map(str::to_string)
|
||||
.collect();
|
||||
unlucky_core::game::java::vendor::parse_priority(&texts)
|
||||
})
|
||||
.unwrap_or_default()
|
||||
}
|
||||
|
||||
/// 设置里的 `java.installRoot`（空 = 按数据目录模式派生）。
|
||||
pub fn java_install_override(env: &HostEnv) -> Option<PathBuf> {
|
||||
env.store()
|
||||
.doc()
|
||||
.effective_str("java.installRoot")
|
||||
.map(str::trim)
|
||||
.filter(|text| !text.is_empty())
|
||||
.map(PathBuf::from)
|
||||
}
|
||||
|
||||
/// 托管 JDK 落点（解析失败 → 用户可读文案）。
|
||||
pub fn java_install_root(env: &HostEnv) -> Result<JavaInstallRoot, String> {
|
||||
let override_root = java_install_override(env);
|
||||
JavaInstallRoot::resolve(
|
||||
env.mode(),
|
||||
&env.layout,
|
||||
override_root.as_deref(),
|
||||
env.platform,
|
||||
&ProcessEnv,
|
||||
)
|
||||
.map_err(|error| error.to_string())
|
||||
}
|
||||
|
||||
/// 托管 JDK 可能存在的全部安装根（扫描运行时用）。
|
||||
pub fn java_scan_roots(env: &HostEnv) -> Vec<PathBuf> {
|
||||
java::location::scan_roots(
|
||||
env.mode(),
|
||||
&env.layout,
|
||||
java_install_override(env).as_deref(),
|
||||
env.platform,
|
||||
&ProcessEnv,
|
||||
)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn engine_uses_the_data_root_cache() {
|
||||
let dir = std::env::temp_dir().join(format!("ull-host-engine-{}", std::process::id()));
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
let env = HostEnv::at_root(&dir);
|
||||
std::fs::create_dir_all(env.layout.cache()).expect("cache");
|
||||
let engine = engine(&env);
|
||||
assert_eq!(engine.config().max_concurrency, 64);
|
||||
// 地区判定不联网：只读缓存/信号
|
||||
let _ = domestic(&env);
|
||||
std::fs::remove_dir_all(&dir).ok();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn java_merge_priority_reads_settings() {
|
||||
let dir = std::env::temp_dir().join(format!("ull-host-engine-p-{}", std::process::id()));
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
let env = HostEnv::at_root(&dir);
|
||||
std::fs::create_dir_all(env.layout.config()).expect("config");
|
||||
std::fs::write(
|
||||
env.launcher_config(),
|
||||
r#"{"java":{"vendorPriority":["zulu"]}}"#,
|
||||
)
|
||||
.expect("写配置");
|
||||
assert_eq!(java_priority(&env), vec![JdkVendor::Zulu]);
|
||||
std::fs::remove_dir_all(&dir).ok();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,170 @@
|
||||
//! host 的环境快照：一份 `ResolvedData` + 由其派生的布局视图。
|
||||
//!
|
||||
//! app 自己不解析三模式数据根（那是 `core::platform::data_dir` 的活）；这里只做两件事：
|
||||
//! ①按「exe 同级便携 `launcher.json` 的 `core.*` 四键」拼请求；②把解析结果与
|
||||
//! `Platform` / `DataMode` 打成一个可克隆的结构，交给后台线程。
|
||||
//!
|
||||
//! 截图/演示通道用 [`HostEnv::at_root`] 直接钉一个根（`<root>/.ULL` + `<root>/.minecraft`）。
|
||||
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
use unlucky_core::game::GameLayout;
|
||||
use unlucky_core::platform::data_dir::{DataDirRequest, DataMode, ResolvedData, Resolver};
|
||||
use unlucky_core::platform::layout::LauncherLayout;
|
||||
use unlucky_core::platform::paths::Platform;
|
||||
use unlucky_core::setting::keys::launcher_schema;
|
||||
use unlucky_core::setting::store::SettingStore;
|
||||
|
||||
/// 数据根决定键（与 CLI 的 `DATA_ROOT_KEYS` 同源同义）。
|
||||
pub(crate) const DATA_ROOT_KEYS: [&str; 4] = [
|
||||
"core.data_mode",
|
||||
"core.data_custom_root",
|
||||
"core.launcher_home",
|
||||
"core.game_home",
|
||||
];
|
||||
|
||||
/// host 运行期需要的一切路径/平台信息（可克隆进线程）。
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct HostEnv {
|
||||
/// 数据根解析结果
|
||||
pub data: ResolvedData,
|
||||
/// `.ULL/` 布局
|
||||
pub layout: LauncherLayout,
|
||||
/// `.minecraft/` 布局
|
||||
pub game: GameLayout,
|
||||
/// 平台
|
||||
pub platform: Platform,
|
||||
}
|
||||
|
||||
impl HostEnv {
|
||||
/// 按便携目录的 `core.*` 解析真实数据根；解析不出来返回 `None`（host 退回 mock）。
|
||||
pub fn resolve() -> Option<Self> {
|
||||
let exe_dir = std::env::current_exe()
|
||||
.ok()
|
||||
.and_then(|path| path.parent().map(Path::to_path_buf))?;
|
||||
let request = request_from_portable(&exe_dir);
|
||||
let resolver = Resolver::new(Platform::current(), Some(exe_dir));
|
||||
let data = resolver.resolve_default(&request).ok()?.clone();
|
||||
Some(Self::from_data(data))
|
||||
}
|
||||
|
||||
/// 直接钉一个根：`<root>/.ULL` + `<root>/.minecraft`（截图/演示通道）。
|
||||
///
|
||||
/// 根下已有 `config/launcher.json` 时**尊重其中的 `core.game_home` / `core.launcher_home`**：
|
||||
/// 演示根常用它把游戏目录指到既有真数据上（避免复制几 GB 的 assets/libraries）。
|
||||
pub fn at_root(root: impl AsRef<Path>) -> Self {
|
||||
let root = root.as_ref();
|
||||
let request = request_from_portable(root);
|
||||
let absolute = |path: Option<PathBuf>| path.filter(|path| path.is_absolute());
|
||||
Self::from_data(ResolvedData {
|
||||
mode: DataMode::Portable,
|
||||
launcher_home: absolute(request.launcher_home).unwrap_or_else(|| root.join(".ULL")),
|
||||
game_home: absolute(request.game_home).unwrap_or_else(|| root.join(".minecraft")),
|
||||
redirected_from: None,
|
||||
})
|
||||
}
|
||||
|
||||
/// 由解析结果建环境。
|
||||
pub fn from_data(data: ResolvedData) -> Self {
|
||||
Self {
|
||||
layout: data.layout(),
|
||||
game: GameLayout::new(data.game_home.clone()),
|
||||
platform: Platform::current(),
|
||||
data,
|
||||
}
|
||||
}
|
||||
|
||||
/// `config/launcher.json` 路径。
|
||||
pub fn launcher_config(&self) -> PathBuf {
|
||||
self.layout.launcher_config()
|
||||
}
|
||||
|
||||
/// 设置存储（每次现读一份；写操作自己 save）。
|
||||
pub fn store(&self) -> SettingStore {
|
||||
SettingStore::load(self.launcher_config(), launcher_schema())
|
||||
}
|
||||
|
||||
/// 启动会话根（`.ULL/data/agent/sessions`）。
|
||||
pub fn sessions_root(&self) -> PathBuf {
|
||||
self.layout.agent_sessions()
|
||||
}
|
||||
|
||||
/// 数据目录模式。
|
||||
pub fn mode(&self) -> DataMode {
|
||||
self.data.mode
|
||||
}
|
||||
|
||||
/// 人读一行（设置页「数据」分组展示）。
|
||||
pub fn data_line(&self) -> String {
|
||||
format!(
|
||||
"{} · 启动器 {} · 游戏 {}",
|
||||
self.data.mode,
|
||||
self.data.launcher_home.display(),
|
||||
self.data.game_home.display()
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
/// 便携目录那份 `launcher.json` → 数据根请求（只读 `core.*` 四键）。
|
||||
pub(crate) fn request_from_portable(exe_dir: &Path) -> DataDirRequest {
|
||||
let mut request = DataDirRequest::default();
|
||||
let path = portable_config_path(exe_dir);
|
||||
if !path.is_file() {
|
||||
return request;
|
||||
}
|
||||
let store = SettingStore::load(&path, launcher_schema());
|
||||
let text = |key: &str| store.doc().effective_str(key).map(str::to_string);
|
||||
if let Some(mode) = text(DATA_ROOT_KEYS[0]).as_deref().and_then(DataMode::parse) {
|
||||
request.mode = mode;
|
||||
}
|
||||
if let Some(root) = text(DATA_ROOT_KEYS[1]) {
|
||||
request.custom_root = Some(PathBuf::from(root));
|
||||
}
|
||||
if let Some(home) = text(DATA_ROOT_KEYS[2]) {
|
||||
request.launcher_home = Some(PathBuf::from(home));
|
||||
}
|
||||
if let Some(home) = text(DATA_ROOT_KEYS[3]) {
|
||||
request.game_home = Some(PathBuf::from(home));
|
||||
}
|
||||
request
|
||||
}
|
||||
|
||||
/// `<exe 目录>/.ULL/config/launcher.json`。
|
||||
pub(crate) fn portable_config_path(exe_dir: &Path) -> PathBuf {
|
||||
LauncherLayout::new(exe_dir.join(".ULL")).launcher_config()
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn at_root_splits_launcher_and_game_homes() {
|
||||
let env = HostEnv::at_root("D:/tmp/ull-demo");
|
||||
assert_eq!(env.layout.home(), Path::new("D:/tmp/ull-demo/.ULL"));
|
||||
assert_eq!(env.game.root(), Path::new("D:/tmp/ull-demo/.minecraft"));
|
||||
assert_eq!(env.mode(), DataMode::Portable);
|
||||
assert!(env.data_line().contains("portable"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn portable_request_reads_core_keys_only_when_file_exists() {
|
||||
let dir = std::env::temp_dir().join(format!("ull-host-env-{}", std::process::id()));
|
||||
std::fs::create_dir_all(dir.join(".ULL/config")).expect("建目录");
|
||||
let request = request_from_portable(&dir);
|
||||
assert_eq!(request, DataDirRequest::default());
|
||||
|
||||
std::fs::write(
|
||||
portable_config_path(&dir),
|
||||
r#"{"core":{"data_mode":"custom","data_custom_root":"D:/data/ull"}}"#,
|
||||
)
|
||||
.expect("写配置");
|
||||
let request = request_from_portable(&dir);
|
||||
assert_eq!(request.mode, DataMode::Custom);
|
||||
assert_eq!(
|
||||
request.custom_root.as_deref(),
|
||||
Some(Path::new("D:/data/ull"))
|
||||
);
|
||||
std::fs::remove_dir_all(&dir).ok();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,260 @@
|
||||
//! 实例快照：`profiles.json` + 版本 JSON + 会话索引 + 实例设置 → [`InstanceSummary`]。
|
||||
//!
|
||||
//! 「磁贴上的每个字」都在这里翻译完：版本号取自继承链根、加载器取自版本 id 前缀、
|
||||
//! 最后游玩时间取自会话索引、隔离档位取自实例设置（缺省跟全局 `instances.mode`）。
|
||||
|
||||
use std::collections::BTreeMap;
|
||||
use std::path::Path;
|
||||
|
||||
use unlucky_core::game::install::instance::{
|
||||
read_instance_config, read_profiles, write_instance_config,
|
||||
};
|
||||
use unlucky_core::game::isolation::IsolationMode;
|
||||
use unlucky_core::game::{ProfileList, VersionJson};
|
||||
use unlucky_core::launch::session_index;
|
||||
|
||||
use crate::dto::{
|
||||
InstanceRuntime, InstanceSummary, LoaderInfo, LoaderKind, NoticeLevel, NoticeView,
|
||||
};
|
||||
|
||||
use super::env::HostEnv;
|
||||
|
||||
/// 全局默认隔离档位（`instances.mode`；缺键/坏值按 D20 默认 `isolated`）。
|
||||
pub fn global_mode(env: &HostEnv) -> IsolationMode {
|
||||
env.store()
|
||||
.doc()
|
||||
.effective_str("instances.mode")
|
||||
.and_then(IsolationMode::parse)
|
||||
.unwrap_or_default()
|
||||
}
|
||||
|
||||
/// 读实例清单（文件缺失 = 空列表，不是错误）。
|
||||
pub fn profiles(env: &HostEnv) -> ProfileList {
|
||||
read_profiles(&env.layout).unwrap_or_default()
|
||||
}
|
||||
|
||||
/// 全会话索引里「每个实例最近一次启动」的时间串。
|
||||
pub fn last_played(env: &HostEnv) -> BTreeMap<String, String> {
|
||||
let index = session_index::index_path(&env.sessions_root());
|
||||
let entries = session_index::read_all(&index).unwrap_or_default();
|
||||
let mut map: BTreeMap<String, String> = BTreeMap::new();
|
||||
for entry in entries {
|
||||
if entry.instance_id.is_empty() || entry.started_at.is_empty() {
|
||||
continue;
|
||||
}
|
||||
let current = map.get(&entry.instance_id);
|
||||
if current.is_none_or(|existing| existing.as_str() < entry.started_at.as_str()) {
|
||||
map.insert(entry.instance_id.clone(), entry.started_at);
|
||||
}
|
||||
}
|
||||
map
|
||||
}
|
||||
|
||||
/// 版本 JSON 的继承链根 id + 加载器（读不到返回 `(version_id, 原版)`）。
|
||||
pub fn describe_version(env: &HostEnv, version_id: &str) -> (String, LoaderInfo) {
|
||||
let loader = loader_from_id(version_id);
|
||||
let mut current = version_id.to_string();
|
||||
let mut seen = 0;
|
||||
while seen < 16 {
|
||||
seen += 1;
|
||||
let path = env.game.version_json(¤t);
|
||||
let Ok(text) = std::fs::read_to_string(&path) else {
|
||||
break;
|
||||
};
|
||||
let Ok(json) = VersionJson::from_json_str(&text) else {
|
||||
break;
|
||||
};
|
||||
match json.inherits_from {
|
||||
Some(parent) if !parent.is_empty() => current = parent,
|
||||
_ => break,
|
||||
}
|
||||
}
|
||||
(current, loader)
|
||||
}
|
||||
|
||||
/// 版本 id → 加载器（HMCL 同款命名口径：`1.20.1-forge-47.2.0` / `fabric-loader-0.16.5-1.20.1`）。
|
||||
pub fn loader_from_id(version_id: &str) -> LoaderInfo {
|
||||
let lower = version_id.to_ascii_lowercase();
|
||||
let grab = |marker: &str| -> String {
|
||||
lower
|
||||
.split_once(marker)
|
||||
.map(|(_, rest)| rest.trim_start_matches('-').to_string())
|
||||
.unwrap_or_default()
|
||||
};
|
||||
let (kind, version) = if lower.contains("neoforge") {
|
||||
(LoaderKind::NeoForge, grab("neoforge-"))
|
||||
} else if lower.contains("fabric-loader") {
|
||||
(LoaderKind::Fabric, grab("fabric-loader-"))
|
||||
} else if lower.contains("quilt-loader") {
|
||||
(LoaderKind::Quilt, grab("quilt-loader-"))
|
||||
} else if lower.contains("forge") {
|
||||
(LoaderKind::Forge, grab("forge-"))
|
||||
} else if lower.contains("optifine") {
|
||||
(LoaderKind::OptiFine, grab("optifine"))
|
||||
} else if lower.contains("liteloader") {
|
||||
(LoaderKind::LiteLoader, grab("liteloader-"))
|
||||
} else {
|
||||
(LoaderKind::Vanilla, String::new())
|
||||
};
|
||||
LoaderInfo { kind, version }
|
||||
}
|
||||
|
||||
/// 实例的隔离档位（实例文件优先，缺省显示全局档位）。
|
||||
pub fn isolation_of(env: &HostEnv, id: &str) -> String {
|
||||
let global = global_mode(env);
|
||||
match read_instance_config(&env.layout, id) {
|
||||
Ok(Some(config)) => config.effective_isolation(global).as_str().to_string(),
|
||||
_ => global.as_str().to_string(),
|
||||
}
|
||||
}
|
||||
|
||||
/// 实例快照。
|
||||
pub fn instances(env: &HostEnv) -> Vec<InstanceSummary> {
|
||||
let profiles = profiles(env);
|
||||
let played = last_played(env);
|
||||
profiles
|
||||
.profiles
|
||||
.iter()
|
||||
.map(|profile| {
|
||||
let version_id = profile.version_id.clone();
|
||||
let (mc_version, loader) = describe_version(env, &version_id);
|
||||
InstanceSummary {
|
||||
id: profile.id.as_str().to_string(),
|
||||
name: profile.name.clone(),
|
||||
mc_version,
|
||||
loader,
|
||||
last_played: played.get(profile.id.as_str()).cloned(),
|
||||
runtime: InstanceRuntime::Idle,
|
||||
icon: None,
|
||||
isolation: isolation_of(env, profile.id.as_str()),
|
||||
version_present: env.game.is_version_installed(&version_id),
|
||||
version_id,
|
||||
}
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// 改实例隔离档位（写实例设置文件；不动任何数据）。
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// 实例不存在、文件读不了/写不了时返回用户可读文案。
|
||||
pub fn set_isolation(env: &HostEnv, id: &str, mode: &str) -> Result<(), String> {
|
||||
let parsed = IsolationMode::parse(mode)
|
||||
.ok_or_else(|| format!("未知隔离档位 `{mode}`（isolated / shared）"))?;
|
||||
let profiles = profiles(env);
|
||||
let profile = profiles
|
||||
.profiles
|
||||
.iter()
|
||||
.find(|profile| profile.id.as_str() == id)
|
||||
.ok_or_else(|| format!("找不到实例 `{id}`"))?;
|
||||
let mut config = read_instance_config(&env.layout, id)
|
||||
.map_err(|error| format!("读实例设置失败：{error}"))?
|
||||
.unwrap_or_else(|| {
|
||||
unlucky_core::game::install::instance::InstanceConfig::new(
|
||||
profile.id.as_str(),
|
||||
&profile.version_id,
|
||||
)
|
||||
});
|
||||
config.isolation = Some(match parsed {
|
||||
IsolationMode::Isolated => unlucky_core::game::install::instance::Isolation::Isolated,
|
||||
IsolationMode::Shared => unlucky_core::game::install::instance::Isolation::Shared,
|
||||
});
|
||||
write_instance_config(&env.layout, &config)
|
||||
.map(|_| ())
|
||||
.map_err(|error| format!("写实例设置失败：{error}"))
|
||||
}
|
||||
|
||||
/// 启动前的切换检测：把 M30 的 `ModeChangeWarning` 翻成横幅通知。
|
||||
///
|
||||
/// 只在真启动时调用（会写 `lastModeChange.warned`，保证同一次切换只提示一次）。
|
||||
pub fn mode_change_notice(env: &HostEnv, id: &str) -> Option<NoticeView> {
|
||||
let mut config = read_instance_config(&env.layout, id).ok()??;
|
||||
let warning = config.take_mode_change_warning()?;
|
||||
let _ = write_instance_config(&env.layout, &config);
|
||||
Some(NoticeView::new(
|
||||
&format!("isolation:{id}"),
|
||||
NoticeLevel::Warn,
|
||||
"隔离档位已切换",
|
||||
&warning.message(),
|
||||
))
|
||||
}
|
||||
|
||||
/// 建目录（数据根首次运行时）。
|
||||
pub fn ensure_root(env: &HostEnv) {
|
||||
let _ = env.layout.ensure();
|
||||
let _ = std::fs::create_dir_all(env.game.root());
|
||||
}
|
||||
|
||||
/// 版本本体目录是否存在（启动前快速判断）。
|
||||
pub fn version_present(env: &HostEnv, version_id: &str) -> bool {
|
||||
env.game.is_version_installed(version_id)
|
||||
}
|
||||
|
||||
/// 路径显示成短串（通知/错误文案用）。
|
||||
pub fn short_path(path: &Path) -> String {
|
||||
path.display().to_string()
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn loader_parsing_covers_all_shapes() {
|
||||
let cases = [
|
||||
("1.20.4", LoaderKind::Vanilla, ""),
|
||||
(
|
||||
"fabric-loader-0.16.5-1.20.1",
|
||||
LoaderKind::Fabric,
|
||||
"0.16.5-1.20.1",
|
||||
),
|
||||
(
|
||||
"quilt-loader-0.24.0-1.20.1",
|
||||
LoaderKind::Quilt,
|
||||
"0.24.0-1.20.1",
|
||||
),
|
||||
("1.20.1-forge-47.2.0", LoaderKind::Forge, "47.2.0"),
|
||||
("1.21.1-neoforge-21.1.80", LoaderKind::NeoForge, "21.1.80"),
|
||||
];
|
||||
for (id, kind, version) in cases {
|
||||
let info = loader_from_id(id);
|
||||
assert_eq!(info.kind, kind, "{id}");
|
||||
assert_eq!(info.version, version, "{id}");
|
||||
assert!(!info.badge().is_empty());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn isolation_write_then_read_round_trips() {
|
||||
let dir = std::env::temp_dir().join(format!("ull-host-game-{}", std::process::id()));
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
let env = HostEnv::at_root(&dir);
|
||||
std::fs::create_dir_all(env.layout.config()).expect("config 目录");
|
||||
|
||||
// 直接建一份 profiles.json（register 需要版本本体，这里只测隔离写读）
|
||||
let profiles = ProfileList {
|
||||
profiles: vec![unlucky_core::game::InstanceProfile {
|
||||
id: unlucky_core::game::ProfileId::generate(),
|
||||
name: "demo".to_string(),
|
||||
version_id: "1.20.1".to_string(),
|
||||
game_dir: None,
|
||||
running_dir: None,
|
||||
java_path: None,
|
||||
created_at: None,
|
||||
last_played_at: None,
|
||||
extra: BTreeMap::new(),
|
||||
}],
|
||||
..ProfileList::default()
|
||||
};
|
||||
unlucky_core::game::install::instance::write_profiles(&env.layout, &profiles)
|
||||
.expect("写清单");
|
||||
let id = profiles.profiles[0].id.as_str().to_string();
|
||||
|
||||
assert_eq!(isolation_of(&env, &id), "isolated");
|
||||
set_isolation(&env, &id, "shared").expect("切档位");
|
||||
assert_eq!(isolation_of(&env, &id), "shared");
|
||||
assert!(set_isolation(&env, &id, "nope").is_err());
|
||||
std::fs::remove_dir_all(&dir).ok();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,145 @@
|
||||
//! `HostTask` → `CoreEvent` 的翻译（从 `host/mod.rs` 拆出，守 400 行硬限）。
|
||||
//!
|
||||
//! 父模块的私有字段对子模块可见，所以这里直接读写 `self.tx` / `self.launches` 等。
|
||||
|
||||
use crate::dto::{AppEvent, CoreEvent, InstanceRuntime, LogOutcome};
|
||||
use crate::toast::ToastKind;
|
||||
|
||||
use super::{logs, CoreHost, HostTask, LiveLaunch};
|
||||
|
||||
impl CoreHost {
|
||||
/// 后台消息 → 事件。
|
||||
pub(super) fn handle(&mut self, task: HostTask) {
|
||||
match task {
|
||||
HostTask::Versions(Ok(versions)) => self.send(CoreEvent::VersionListChanged(versions)),
|
||||
HostTask::Versions(Err(reason)) => {
|
||||
self.toast(ToastKind::Warn, format!("拉取版本清单失败：{reason}"));
|
||||
}
|
||||
HostTask::Install(progress) => {
|
||||
self.install = Some(*progress.clone());
|
||||
self.send(CoreEvent::InstallProgress(Some(*progress)));
|
||||
}
|
||||
HostTask::InstallDone { progress, result } => {
|
||||
self.install_cancel = None;
|
||||
self.install = Some(*progress.clone());
|
||||
self.send(CoreEvent::InstallProgress(Some(*progress)));
|
||||
match result {
|
||||
Ok(_) => {
|
||||
self.refresh_instances();
|
||||
self.send(CoreEvent::LogSessionsChanged(logs::sessions(&self.env)));
|
||||
}
|
||||
Err(reason) => self.toast(ToastKind::Error, reason),
|
||||
}
|
||||
}
|
||||
HostTask::Accounts(accounts) => {
|
||||
self.accounts = accounts.clone();
|
||||
self.send(CoreEvent::AccountsChanged(accounts));
|
||||
self.refresh_instances();
|
||||
}
|
||||
HostTask::Login(view) => self.send(CoreEvent::DeviceLoginChanged(*view)),
|
||||
HostTask::Java(page) => self.send(CoreEvent::JavaChanged(*page)),
|
||||
HostTask::Logs {
|
||||
sessions,
|
||||
lines,
|
||||
diagnosis,
|
||||
} => {
|
||||
self.send(CoreEvent::LogSessionsChanged(sessions));
|
||||
self.send(CoreEvent::LogLinesChanged(lines));
|
||||
if let Some(report) = diagnosis {
|
||||
self.send(CoreEvent::DiagnosisReady(report));
|
||||
}
|
||||
}
|
||||
HostTask::Sessions(sessions) => self.send(CoreEvent::LogSessionsChanged(sessions)),
|
||||
HostTask::Tail(batch) => {
|
||||
if batch.running {
|
||||
self.send(CoreEvent::LogLinesChanged(batch.lines));
|
||||
} else {
|
||||
self.send(CoreEvent::LogAppended(*batch));
|
||||
}
|
||||
}
|
||||
HostTask::LaunchStarted {
|
||||
id,
|
||||
session_id,
|
||||
pid,
|
||||
} => {
|
||||
self.pending.remove(&id);
|
||||
self.failed.remove(&id);
|
||||
self.launches.retain(|live| live.instance != id);
|
||||
self.launches.push(LiveLaunch {
|
||||
instance: id.clone(),
|
||||
session: session_id.clone(),
|
||||
pid,
|
||||
});
|
||||
// 实时尾随一次只跟一场（下载页/日志页共用一个滚动窗口）；
|
||||
// 已有别的实例在尾随时不抢占——它的日志仍在 JSONL 里，收尾后可回放。
|
||||
if self.tail.session().is_none() {
|
||||
self.tail.attach(
|
||||
self.env
|
||||
.sessions_root()
|
||||
.join("game")
|
||||
.join(format!("{session_id}.jsonl")),
|
||||
&session_id,
|
||||
);
|
||||
}
|
||||
self.send(CoreEvent::InstanceRuntimeChanged {
|
||||
id,
|
||||
runtime: InstanceRuntime::Running { pid },
|
||||
});
|
||||
}
|
||||
HostTask::Runtime { id, runtime } => {
|
||||
self.send(CoreEvent::InstanceRuntimeChanged { id, runtime });
|
||||
}
|
||||
HostTask::LaunchEnd(finished) => {
|
||||
// 收尾可能发生在 LaunchStarted 之前（build_request / spawn 失败只发
|
||||
// LaunchEnd）：pending 必须在这里也清掉，否则 in_flight 恒真、该实例
|
||||
// 本会话内再也起不来。
|
||||
self.pending.remove(&finished.id);
|
||||
self.launches.retain(|live| live.instance != finished.id);
|
||||
let runtime = if finished.outcome == LogOutcome::Ok {
|
||||
self.failed.remove(&finished.id);
|
||||
InstanceRuntime::Idle
|
||||
} else {
|
||||
// 记住失败原因：随后的 refresh_instances 会重建快照，
|
||||
// 不记的话磁贴的「失败/重试」外观会被 Idle 盖掉。
|
||||
self.failed
|
||||
.insert(finished.id.clone(), finished.summary.clone());
|
||||
InstanceRuntime::Failed {
|
||||
reason: finished.summary.clone(),
|
||||
}
|
||||
};
|
||||
self.send(CoreEvent::InstanceRuntimeChanged {
|
||||
id: finished.id.clone(),
|
||||
runtime,
|
||||
});
|
||||
self.send(CoreEvent::LaunchFinished((*finished).clone()));
|
||||
// 只拆自己那场的尾随：并发时另一实例的实时日志不该被这次收尾掐掉。
|
||||
if self.tail.session() == Some(finished.session.as_str()) {
|
||||
self.tail.detach();
|
||||
}
|
||||
self.send(CoreEvent::LogSessionsChanged(logs::sessions(&self.env)));
|
||||
self.refresh_instances();
|
||||
}
|
||||
HostTask::Crash(report) => {
|
||||
self.send(CoreEvent::DiagnosisReady(*report));
|
||||
}
|
||||
HostTask::Notice(notice) => self.push_notice(*notice),
|
||||
HostTask::Toast(toast) => self.events.push_back(AppEvent::Toast(*toast)),
|
||||
}
|
||||
}
|
||||
|
||||
/// 尾随运行中会话（每 `TAIL_POLL_TICKS` 拍一次）。
|
||||
pub(super) fn poll_tail(&mut self) {
|
||||
let Some((session, lines)) = self.tail.poll() else {
|
||||
return;
|
||||
};
|
||||
if lines.is_empty() {
|
||||
return;
|
||||
}
|
||||
let running = self.launches.iter().any(|live| live.session == session);
|
||||
self.send(CoreEvent::LogAppended(crate::dto::LiveLogBatch {
|
||||
session,
|
||||
lines,
|
||||
running,
|
||||
}));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,103 @@
|
||||
//! 启动身份：选中账户 → `AuthPlaceholders`（**凭据只在这里读，读完即丢**）+ 收尾结局映射。
|
||||
//!
|
||||
//! 与 CLI `commands/identity.rs` 同源：微软轨过期就静默续期并回写凭据（refresh_token 轮换，
|
||||
//! 旧值作废）；零账户回落离线占位，保证没有账户时照样能启动。
|
||||
|
||||
use unlucky_core::auth::account::{AccountKind, Credentials};
|
||||
use unlucky_core::auth::microsoft::MicrosoftAuth;
|
||||
use unlucky_core::auth::offline::offline_login;
|
||||
use unlucky_core::auth::AccountStore;
|
||||
use unlucky_core::download::blocking::block_on;
|
||||
use unlucky_core::game::ProfileId;
|
||||
use unlucky_core::launch::request::AuthPlaceholders;
|
||||
|
||||
use crate::dto::LogOutcome;
|
||||
|
||||
use super::env::HostEnv;
|
||||
|
||||
/// 把选中账户翻成启动占位符（**凭据只在这里读，读完即丢**）。
|
||||
///
|
||||
/// 微软轨：过期就静默续期并回写凭据（refresh_token 轮换，旧值作废）。
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// 账户不存在/凭据类型不符/令牌过期且刷新失败时返回用户可读文案。
|
||||
pub fn resolve(env: &HostEnv, account: Option<&str>) -> Result<(AuthPlaceholders, String), String> {
|
||||
let store = AccountStore::open(env.layout.auth_data());
|
||||
let chosen = match account {
|
||||
Some(key) => store
|
||||
.find(key)
|
||||
.cloned()
|
||||
.ok_or_else(|| format!("找不到账户 `{key}`"))?,
|
||||
None => match store.accounts() {
|
||||
[] => {
|
||||
let uuid = ProfileId::generate().as_str().replace('-', "");
|
||||
return Ok((
|
||||
AuthPlaceholders {
|
||||
player_name: "Player".to_string(),
|
||||
uuid,
|
||||
user_type: "legacy".to_string(),
|
||||
user_properties: "{}".to_string(),
|
||||
..AuthPlaceholders::default()
|
||||
},
|
||||
"未登录账户，按离线占位启动".to_string(),
|
||||
));
|
||||
}
|
||||
[only] => only.clone(),
|
||||
many => return Err(format!("有 {} 个账户，请在账户页选一个再启动", many.len())),
|
||||
},
|
||||
};
|
||||
let line = format!("账户 {}（{}）", chosen.display_name(), chosen.kind.label());
|
||||
match chosen.kind {
|
||||
AccountKind::Offline => {
|
||||
let placeholders =
|
||||
offline_login(&chosen).map_err(|error| format!("离线账户解析失败：{error}"))?;
|
||||
Ok((placeholders, line))
|
||||
}
|
||||
AccountKind::Microsoft => {
|
||||
let Some(Credentials::Microsoft(session)) = store.credentials(&chosen.id) else {
|
||||
return Err(format!(
|
||||
"账户 {} 的微软凭据缺失或类型不符，请重新登录",
|
||||
chosen.display_name()
|
||||
));
|
||||
};
|
||||
let auth =
|
||||
MicrosoftAuth::from_env().map_err(|error| format!("微软登录不可用：{error}"))?;
|
||||
let (fresh, _) = block_on(auth.ensure_fresh(session))
|
||||
.map_err(|error| format!("微软令牌刷新失败：{error}"))?;
|
||||
if &fresh != session {
|
||||
// refresh_token 已轮换：立刻回写，旧值作废。
|
||||
let mut store = AccountStore::open(env.layout.auth_data());
|
||||
let _ = store.update_credentials(&chosen.id, Credentials::Microsoft(fresh.clone()));
|
||||
let _ = store.save();
|
||||
}
|
||||
let placeholders = fresh
|
||||
.to_placeholders()
|
||||
.map_err(|error| format!("微软身份转换失败：{error}"))?;
|
||||
Ok((placeholders, line))
|
||||
}
|
||||
AccountKind::AuthlibInjector => {
|
||||
let Some(Credentials::AuthlibInjector(session)) = store.credentials(&chosen.id) else {
|
||||
return Err(format!(
|
||||
"账户 {} 的第三方凭据缺失或类型不符",
|
||||
chosen.display_name()
|
||||
));
|
||||
};
|
||||
let placeholders = session
|
||||
.to_placeholders()
|
||||
.map_err(|error| format!("第三方身份转换失败：{error}"))?;
|
||||
Ok((placeholders, line))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// `SessionHandle` → 日志页的三种结局。
|
||||
pub fn outcome_of(handle: &unlucky_core::launch::SessionHandle) -> LogOutcome {
|
||||
if handle.exit.silent_failure.is_some() {
|
||||
LogOutcome::SilentFail
|
||||
} else if handle.succeeded() {
|
||||
LogOutcome::Ok
|
||||
} else {
|
||||
LogOutcome::Crashed
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,393 @@
|
||||
//! 安装：新建实例向导 / 下载页「安装」→ core 安装管线 → 登记实例。
|
||||
//!
|
||||
//! 与 CLI `ull install` 同序：`RemoteSource::resolve → InstallPlan::build → execute → register`。
|
||||
//! Forge/NeoForge 多一段 installer processors（[`super::install_processors`]）：
|
||||
//! `ProcessorPlan::build → 依赖库下载 → 选 Java → 串行 java -cp`，**跑完才写版本 JSON**。
|
||||
//! 差异只在线程模型：进度经 [`super::job::HostTask::Install`] 回流（文件计数 + 字节 + 速度/ETA），
|
||||
//! 且整段跑在后台线程里（`block_on` 不占 UI 线程）。
|
||||
//!
|
||||
//! 加载器范围：原版 + Fabric/Quilt/Forge/NeoForge（四家，与 CLI 对齐）。OptiFine/LiteLoader
|
||||
//! 两家 core 侧都还没有安装管线，仍在 GUI 里显式拒装并说清去哪装。
|
||||
//! 失败一律落 `.ULL/logs/install.log`（[`super::install_journal`]），文案里带日志路径。
|
||||
|
||||
use std::path::PathBuf;
|
||||
use std::sync::atomic::{AtomicBool, Ordering};
|
||||
use std::sync::Arc;
|
||||
|
||||
use unlucky_core::addon::loader::{
|
||||
LoaderInstallPlan, LoaderKind as CoreLoaderKind, LoaderPlanInput, LoaderSource,
|
||||
};
|
||||
use unlucky_core::download::blocking::block_on;
|
||||
use unlucky_core::download::cache::now_ms;
|
||||
use unlucky_core::download::DownloadEngine;
|
||||
use unlucky_core::game::arguments::Environment;
|
||||
use unlucky_core::game::install::{
|
||||
execute, InstallError, InstallPlan, InstallReport, PlanInput, RemoteSource,
|
||||
};
|
||||
|
||||
use crate::dto::{CreateRequest, InstallStage, LoaderKind};
|
||||
use crate::toast::{Toast, ToastKind};
|
||||
|
||||
use super::env::HostEnv;
|
||||
use super::install_journal::Journal;
|
||||
use super::install_processors::{self, StageInput};
|
||||
use super::job::{spawn, HostTask, JobSender};
|
||||
use super::meter::{sink_for, Meter};
|
||||
|
||||
/// 文件级并发上限（与 CLI 同值：16 路压满带宽又不至于打爆镜像）。
|
||||
pub const CONCURRENCY: usize = 16;
|
||||
|
||||
/// 用户取消的稳定文案（阶段边界生效）。
|
||||
pub const CANCELLED: &str = "已取消（阶段边界停下；已下载的文件保留，重装会续用）";
|
||||
|
||||
/// 一次安装任务的运行上下文（后台线程内一路传下去，免得每个函数排七八个参数）。
|
||||
struct Job<'a> {
|
||||
env: &'a HostEnv,
|
||||
tx: &'a JobSender,
|
||||
meter: &'a Arc<std::sync::Mutex<Meter>>,
|
||||
cancel: &'a Arc<AtomicBool>,
|
||||
journal: &'a Journal,
|
||||
}
|
||||
|
||||
impl Job<'_> {
|
||||
/// processor 段的进度出口（同一套 channel/meter/journal）。
|
||||
fn reporter(&self) -> install_processors::Reporter<'_> {
|
||||
install_processors::Reporter {
|
||||
tx: self.tx,
|
||||
meter: self.meter,
|
||||
journal: self.journal,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// 加载器徽标（`原版` / `Fabric 0.16.5`）。
|
||||
pub fn loader_label(kind: LoaderKind, version: &str) -> String {
|
||||
if kind == LoaderKind::Vanilla || version.trim().is_empty() {
|
||||
kind.label().to_string()
|
||||
} else {
|
||||
format!("{} {}", kind.label(), version)
|
||||
}
|
||||
}
|
||||
|
||||
/// GUI 侧支持的加载器（五选：原版 + 四家加载器，与 CLI 的 `--loader` 词表一致）。
|
||||
///
|
||||
/// 写成穷举 `matches!` 而不是 `true`：将来 core 加了第六种加载器，这里默认拒绝，
|
||||
/// 由 [`unsupported_reason`] 给出明确说法，而不是让它走进不属于它的安装分支。
|
||||
pub fn supported(kind: LoaderKind) -> bool {
|
||||
matches!(
|
||||
kind,
|
||||
LoaderKind::Vanilla
|
||||
| LoaderKind::Fabric
|
||||
| LoaderKind::Quilt
|
||||
| LoaderKind::Forge
|
||||
| LoaderKind::NeoForge
|
||||
)
|
||||
}
|
||||
|
||||
/// 不支持的加载器 → 给用户的可执行建议。
|
||||
pub fn unsupported_reason(kind: LoaderKind) -> String {
|
||||
format!(
|
||||
"{} 还没有接入安装管线（目前支持原版 + Fabric/Quilt/Forge/NeoForge）；请先在实例页导入已有版本，或换成受支持的加载器。",
|
||||
kind.label()
|
||||
)
|
||||
}
|
||||
|
||||
/// 后台安装（向导提交 / 下载页行内安装共用）。
|
||||
pub fn spawn_install(env: HostEnv, tx: JobSender, request: CreateRequest, cancel: Arc<AtomicBool>) {
|
||||
spawn("install", move || {
|
||||
let meter = Arc::new(std::sync::Mutex::new(Meter::new(&request)));
|
||||
let journal = Journal::open(&env);
|
||||
journal.line(&format!(
|
||||
"—— 开始安装 {}（{} {}）——",
|
||||
request.instance_name(),
|
||||
loader_label(request.loader, ""),
|
||||
request.version
|
||||
));
|
||||
let job = Job {
|
||||
env: &env,
|
||||
tx: &tx,
|
||||
meter: &meter,
|
||||
cancel: &cancel,
|
||||
journal: &journal,
|
||||
};
|
||||
let result = run(&job, &request);
|
||||
let mut progress = meter
|
||||
.lock()
|
||||
.map(|guard| guard.progress.clone())
|
||||
.unwrap_or_else(|_| Meter::new(&request).progress);
|
||||
match result {
|
||||
Ok(name) => {
|
||||
journal.line(&format!("完成：实例 {name} 已登记"));
|
||||
progress.stage = InstallStage::Done;
|
||||
progress.files_done = progress.files_total;
|
||||
progress.message = format!("已安装 {name}（{}）", progress.loader);
|
||||
let _ = tx.send(HostTask::InstallDone {
|
||||
progress: Box::new(progress),
|
||||
result: Ok(name),
|
||||
});
|
||||
let _ = tx.send(HostTask::Toast(Box::new(Toast {
|
||||
id: 0,
|
||||
kind: ToastKind::Success,
|
||||
text: "安装完成，实例已登记".to_string(),
|
||||
remaining_ms: 0,
|
||||
})));
|
||||
}
|
||||
Err(reason) => {
|
||||
let cancelled = reason == CANCELLED;
|
||||
progress.stage = if cancelled {
|
||||
InstallStage::Cancelled
|
||||
} else {
|
||||
InstallStage::Failed
|
||||
};
|
||||
// 失败文案带上日志路径：面板只有一行、Toast 4 秒就消失，
|
||||
// 装日志是用户事后能自己回看的唯一渠道（进度板之外）。
|
||||
let text = if cancelled {
|
||||
reason
|
||||
} else {
|
||||
journal.line(&format!("安装未完成：{reason}"));
|
||||
format!("{reason}（日志：{}）", journal.path().display())
|
||||
};
|
||||
progress.message.clone_from(&text);
|
||||
let _ = tx.send(HostTask::InstallDone {
|
||||
progress: Box::new(progress),
|
||||
result: Err(text),
|
||||
});
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/// 真安装（同步跑完，调用方在后台线程里）。
|
||||
fn run(job: &Job<'_>, request: &CreateRequest) -> Result<String, String> {
|
||||
if request.version.trim().is_empty() {
|
||||
return Err("没有选择版本".to_string());
|
||||
}
|
||||
if !supported(request.loader) {
|
||||
return Err(unsupported_reason(request.loader));
|
||||
}
|
||||
let name = request.instance_name();
|
||||
let env = job.env;
|
||||
let engine = super::engine::engine(env);
|
||||
{
|
||||
let mut guard = job.meter.lock().map_err(|_| "进度锁失效".to_string())?;
|
||||
guard.stage(InstallStage::Planning, "正在解析版本清单…");
|
||||
let _ = job
|
||||
.tx
|
||||
.send(HostTask::Install(Box::new(guard.progress.clone())));
|
||||
}
|
||||
|
||||
if job.cancel.load(Ordering::SeqCst) {
|
||||
return Err(CANCELLED.to_string());
|
||||
}
|
||||
let version_id = if request.loader == LoaderKind::Vanilla {
|
||||
install_vanilla(job, &engine, request)?
|
||||
} else {
|
||||
install_loader(job, &engine, request)?
|
||||
};
|
||||
|
||||
{
|
||||
let mut guard = job.meter.lock().map_err(|_| "进度锁失效".to_string())?;
|
||||
guard.stage(InstallStage::Registering, "正在登记实例…");
|
||||
let _ = job
|
||||
.tx
|
||||
.send(HostTask::Install(Box::new(guard.progress.clone())));
|
||||
}
|
||||
let created_at =
|
||||
unlucky_core::launch::time::format_rfc3339_millis(unlucky_core::launch::time::now());
|
||||
unlucky_core::game::install::instance::register(
|
||||
&env.layout,
|
||||
&name,
|
||||
&version_id,
|
||||
Some(&created_at),
|
||||
)
|
||||
.map_err(|error| format!("登记实例失败：{error}"))?;
|
||||
Ok(name)
|
||||
}
|
||||
|
||||
/// 原版安装（`resolve → plan → [prefetch 资源索引] → execute`）。
|
||||
fn install_vanilla(
|
||||
job: &Job<'_>,
|
||||
engine: &DownloadEngine,
|
||||
request: &CreateRequest,
|
||||
) -> Result<String, String> {
|
||||
let env = job.env;
|
||||
let version = request.version.trim();
|
||||
let meta_cache = env.layout.meta_cache();
|
||||
let now = now_ms();
|
||||
let sink = sink_for(job.tx.clone(), Arc::clone(job.meter));
|
||||
block_on(async {
|
||||
let source = RemoteSource::new(engine, &env.game, &meta_cache, now);
|
||||
let resolved = source.resolve(version).await.map_err(install_error)?;
|
||||
let fetched = match resolved
|
||||
.asset_index
|
||||
.as_ref()
|
||||
.filter(|index| index.url.is_some())
|
||||
{
|
||||
Some(reference) => {
|
||||
let (index, bytes) = source.asset_index(reference).await.map_err(install_error)?;
|
||||
Some((index, env.game.asset_index(&reference.id), bytes))
|
||||
}
|
||||
None => None,
|
||||
};
|
||||
let mut plan = InstallPlan::build(PlanInput {
|
||||
layout: &env.game,
|
||||
version_id: version,
|
||||
resolved: &resolved,
|
||||
asset_index: fetched.as_ref().map(|(index, _, _)| index),
|
||||
environment: &Environment::host(),
|
||||
})
|
||||
.map_err(|error| error.to_string())?;
|
||||
if let Some((_, dest, bytes)) = fetched {
|
||||
plan.prefetch(dest, bytes);
|
||||
}
|
||||
if !plan.is_installable() {
|
||||
return Err(format!(
|
||||
"版本 {version} 装不全：{}",
|
||||
plan.warnings.join("；")
|
||||
));
|
||||
}
|
||||
let (bytes_total, _) = plan.total_bytes();
|
||||
{
|
||||
let mut guard = job.meter.lock().map_err(|_| "进度锁失效".to_string())?;
|
||||
guard.progress.files_total = u64::try_from(plan.file_count()).unwrap_or(u64::MAX);
|
||||
guard.progress.bytes_total = bytes_total;
|
||||
guard.stage(
|
||||
InstallStage::Downloading,
|
||||
&format!("开始下载 {} 个文件…", plan.file_count()),
|
||||
);
|
||||
}
|
||||
if job.cancel.load(Ordering::SeqCst) {
|
||||
return Err(CANCELLED.to_string());
|
||||
}
|
||||
let report = execute(engine, &plan, CONCURRENCY, Some(sink))
|
||||
.await
|
||||
.map_err(install_error)?;
|
||||
ensure_complete(&report)?;
|
||||
Ok::<String, String>(version.to_string())
|
||||
})
|
||||
}
|
||||
|
||||
/// 加载器安装（原版前置 → installer processors → 加载器库 → 版本 JSON 落盘）。
|
||||
fn install_loader(
|
||||
job: &Job<'_>,
|
||||
engine: &DownloadEngine,
|
||||
request: &CreateRequest,
|
||||
) -> Result<String, String> {
|
||||
let env = job.env;
|
||||
let version = request.version.trim();
|
||||
let kind = CoreLoaderKind::parse(request.loader.as_str())
|
||||
.ok_or_else(|| format!("未知加载器 `{}`", request.loader.as_str()))?;
|
||||
let meta_cache = env.layout.meta_cache();
|
||||
let loader_version = request.loader_version.trim().to_string();
|
||||
let explicit = (!loader_version.is_empty()).then_some(loader_version.as_str());
|
||||
let release = block_on(async {
|
||||
LoaderSource::new(engine, &meta_cache)
|
||||
.resolve(kind, version, explicit)
|
||||
.await
|
||||
})
|
||||
.map_err(|error| error.to_string())?;
|
||||
job.journal.line(&format!(
|
||||
"加载器解析：{} {} → {}",
|
||||
release.kind.label(),
|
||||
release.loader_version,
|
||||
release.version_id
|
||||
));
|
||||
|
||||
let plan = LoaderInstallPlan::build(LoaderPlanInput {
|
||||
layout: &env.game,
|
||||
release: &release,
|
||||
environment: &Environment::host(),
|
||||
vanilla_installed: env.game.is_version_installed(version),
|
||||
});
|
||||
if plan.vanilla_install_needed {
|
||||
let mut vanilla = request.clone();
|
||||
vanilla.loader = LoaderKind::Vanilla;
|
||||
install_vanilla(job, engine, &vanilla)?;
|
||||
}
|
||||
// 两段（加载器库 + 处理器依赖库）在动手前一次预记账：进度条只走一条单调曲线，
|
||||
// 处理器依赖库下完不会先满格、再在加载器库开始时回落到一半。
|
||||
{
|
||||
let mut guard = job.meter.lock().map_err(|_| "进度锁失效".to_string())?;
|
||||
let (bytes, _) = plan.install.total_bytes();
|
||||
guard.expect(plan.files().len(), bytes);
|
||||
}
|
||||
// Forge/NeoForge：installer processors 必须先跑完，`execute` 才允许写版本 JSON。
|
||||
if release.requires_installer() {
|
||||
let input = StageInput {
|
||||
kind: release.kind,
|
||||
mc_version: &release.mc_version,
|
||||
version_id: &release.version_id,
|
||||
profile: release.install_profile.as_ref(),
|
||||
installer: release.installer.as_deref(),
|
||||
installed: env.game.is_version_installed(&release.version_id),
|
||||
};
|
||||
// `None` = 这一版不需要跑处理器（版本 JSON 已在盘上 / profile 没有 client 侧步骤），
|
||||
// 进度与日志都由处理器段自己写全，这里只消费返回值。
|
||||
let _ = install_processors::stage(
|
||||
env,
|
||||
engine,
|
||||
&input,
|
||||
&install_processors::CORE,
|
||||
&job.reporter(),
|
||||
job.cancel,
|
||||
)?;
|
||||
}
|
||||
{
|
||||
let mut guard = job.meter.lock().map_err(|_| "进度锁失效".to_string())?;
|
||||
guard.stage(
|
||||
InstallStage::Downloading,
|
||||
&format!("开始下载加载器库（{} 个文件）…", plan.files().len()),
|
||||
);
|
||||
}
|
||||
if job.cancel.load(Ordering::SeqCst) {
|
||||
return Err(CANCELLED.to_string());
|
||||
}
|
||||
let sink = sink_for(job.tx.clone(), Arc::clone(job.meter));
|
||||
let report = block_on(async {
|
||||
execute(engine, &plan.install, CONCURRENCY, Some(sink))
|
||||
.await
|
||||
.map_err(install_error)
|
||||
})?;
|
||||
ensure_complete(&report)?;
|
||||
Ok(release.version_id)
|
||||
}
|
||||
|
||||
/// 安装错误 → 用户可读文案。
|
||||
fn install_error(error: InstallError) -> String {
|
||||
match error.hint() {
|
||||
Some(hint) => format!("{}（{hint}）", error.message()),
|
||||
None => error.message().to_string(),
|
||||
}
|
||||
}
|
||||
|
||||
/// 有文件失败就报错（列前三条明细）。
|
||||
fn ensure_complete(report: &InstallReport) -> Result<(), String> {
|
||||
if report.is_complete() {
|
||||
return Ok(());
|
||||
}
|
||||
let details: Vec<String> = report
|
||||
.failures(3)
|
||||
.iter()
|
||||
.filter_map(|outcome| {
|
||||
outcome
|
||||
.failure
|
||||
.as_ref()
|
||||
.map(|failure| format!("{}：{}", outcome.name, failure.message))
|
||||
})
|
||||
.collect();
|
||||
Err(format!(
|
||||
"{} 个文件没下成（共 {} 个）：{}",
|
||||
report.failed(),
|
||||
report.files.len(),
|
||||
details.join("；")
|
||||
))
|
||||
}
|
||||
|
||||
/// 安装目录的短显示（诊断/Toast 用）。
|
||||
pub fn game_root(env: &HostEnv) -> PathBuf {
|
||||
env.game.root().to_path_buf()
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
#[path = "install_tests.rs"]
|
||||
mod tests;
|
||||
@@ -0,0 +1,79 @@
|
||||
//! 安装过程的可回溯日志（`.ULL/logs/install.log`，一轮一行）。
|
||||
//!
|
||||
//! 起因（M45）：Forge/NeoForge 装失败时，GUI 只有一行 Toast，processor 的 stderr 尾部
|
||||
//! 与「哪一步挂了」在面板一关就没了。这里把安装过程按行追加到 `.ULL/logs/`
|
||||
//! （与 `auth.jsonl` 同一分区），失败文案里带上日志路径，用户能自己回看。
|
||||
//!
|
||||
//! 三条纪律（与 auth 日志同源）：
|
||||
//! 1. **只追加**，不轮转、不截断（体积由「一行一条、只记诊断字段」控制）；
|
||||
//! 2. **只记诊断字段**：阶段、processor 坐标、退出码、已脱敏的 stderr 尾部（core 侧脱敏）；
|
||||
//! 3. **写盘尽力而为**：开不了文件就静默跳过，绝不让日志失败连累安装。
|
||||
|
||||
use std::io::Write;
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
use unlucky_core::launch::time;
|
||||
|
||||
use super::env::HostEnv;
|
||||
|
||||
/// 日志文件名（在 `.ULL/logs/` 下）。
|
||||
pub const INSTALL_LOG_FILE: &str = "install.log";
|
||||
|
||||
/// 一轮安装的日志句柄（`Clone` 很便宜：只有一个路径）。
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Journal {
|
||||
path: PathBuf,
|
||||
}
|
||||
|
||||
impl Journal {
|
||||
/// 按数据根打开（`logs/` 不存在就补建；建不出来只是没有日志）。
|
||||
pub fn open(env: &HostEnv) -> Self {
|
||||
let dir = env.layout.logs();
|
||||
let _ = std::fs::create_dir_all(&dir);
|
||||
Self {
|
||||
path: dir.join(INSTALL_LOG_FILE),
|
||||
}
|
||||
}
|
||||
|
||||
/// 日志路径（失败文案里给用户看）。
|
||||
pub fn path(&self) -> &Path {
|
||||
&self.path
|
||||
}
|
||||
|
||||
/// 追加一行（自动补 RFC3339 时间戳；写失败静默）。
|
||||
pub fn line(&self, text: &str) {
|
||||
let Ok(mut file) = std::fs::OpenOptions::new()
|
||||
.create(true)
|
||||
.append(true)
|
||||
.open(&self.path)
|
||||
else {
|
||||
return;
|
||||
};
|
||||
let _ = writeln!(
|
||||
file,
|
||||
"[{}] {text}",
|
||||
time::format_rfc3339_millis(time::now())
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn lines_are_appended_with_a_timestamp() {
|
||||
let root = std::env::temp_dir().join(format!("ull-install-journal-{}", std::process::id()));
|
||||
let _ = std::fs::remove_dir_all(&root);
|
||||
let env = HostEnv::at_root(&root);
|
||||
let journal = Journal::open(&env);
|
||||
journal.line("第一行");
|
||||
journal.line("第二行");
|
||||
let text = std::fs::read_to_string(journal.path()).expect("日志存在");
|
||||
assert!(text.contains("第一行") && text.contains("第二行"), "{text}");
|
||||
assert_eq!(text.lines().count(), 2);
|
||||
assert!(text.starts_with("[2"), "带时间戳：{text}");
|
||||
assert_eq!(journal.path(), env.layout.logs().join(INSTALL_LOG_FILE));
|
||||
std::fs::remove_dir_all(&root).ok();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,378 @@
|
||||
//! Forge / NeoForge 的 installer processors 段（M45：GUI 与 CLI 行为对齐）。
|
||||
//!
|
||||
//! 顺序与 CLI `ull install --loader forge` 完全一致（`crates/cli/src/commands/install/
|
||||
//! loader_processors.rs`），只是把进度接到 GUI 的回流通道上：
|
||||
//!
|
||||
//! ```text
|
||||
//! ProcessorPlan::build（纯计算：变量表 + 每步 java -cp + 依赖库清单）
|
||||
//! → download_libraries（M27 引擎；进度回流 HostTask::Install）
|
||||
//! → select_java（M33 解析链：托管 > JAVA_HOME > PATH > 扫盘）
|
||||
//! → run（串行 java -cp；每步一条面板文案 + 一行装日志）
|
||||
//! ```
|
||||
//!
|
||||
//! 四条硬约束（与 CLI 同源，GUI 侧一条都不放宽）：
|
||||
//!
|
||||
//! 1. **processors 跑完才允许写版本 JSON**：版本清单存在 = 这版装完了，抢在 processors
|
||||
//! 前写会留下启动必崩却被报成"已安装"的实例（顺序由 `install_loader` 保证）；
|
||||
//! 2. **幂等**：版本 JSON 已在盘上 = 上一轮跑完了，整段跳过；
|
||||
//! 3. **取消在阶段边界生效**：处理器阶段是原子段（串行外调 java，进程内没有取消钩子），
|
||||
//! 进入前与退出后各查一次 `cancel`；
|
||||
//! 4. **失败不静默**：结构化文案（带 `processor_*` 大类码）+ 装日志一行一条，由调用方
|
||||
//! 再补 Toast（`HostTask::InstallDone` 的既有通路）。
|
||||
//!
|
||||
//! 执行后端走 [`Backend`]：真实实现 [`CoreBackend`] 直接转调 core，单测注入 fake，
|
||||
//! 因此「计划怎么组、Java 找不到怎么说、依赖库下漏怎么报」都能在没有网络/没有 JDK
|
||||
//! 的机器上断言。
|
||||
|
||||
use std::path::Path;
|
||||
use std::sync::atomic::{AtomicBool, Ordering};
|
||||
use std::sync::{Arc, Mutex};
|
||||
|
||||
use unlucky_core::addon::loader::forge::InstallProfile;
|
||||
use unlucky_core::addon::loader::processors::{
|
||||
self, ProcessorError, ProcessorPlan, ProcessorPlanInput, ProcessorRun, StepOutcome, StepSink,
|
||||
StepStatus,
|
||||
};
|
||||
use unlucky_core::addon::loader::LoaderKind as CoreLoaderKind;
|
||||
use unlucky_core::download::blocking::block_on;
|
||||
use unlucky_core::download::DownloadEngine;
|
||||
use unlucky_core::game::arguments::Environment;
|
||||
use unlucky_core::game::install::{InstallReport, PlanFile, ProgressSink};
|
||||
use unlucky_core::game::java::{JavaRequirement, JavaRuntime};
|
||||
|
||||
use crate::dto::InstallStage;
|
||||
|
||||
use super::env::HostEnv;
|
||||
use super::install::{CANCELLED, CONCURRENCY};
|
||||
use super::install_journal::Journal;
|
||||
use super::job::{HostTask, JobSender};
|
||||
use super::meter::{sink_for, Meter};
|
||||
|
||||
/// 真实后端（无状态，可以放静态里复用）。
|
||||
pub(super) const CORE: CoreBackend = CoreBackend;
|
||||
|
||||
/// processors 段需要的输入（从 `LoaderRelease` 摘出来，便于单测构造）。
|
||||
pub(super) struct StageInput<'a> {
|
||||
/// 加载器种类（补库时 maven 基址的兜底来源）。
|
||||
pub kind: CoreLoaderKind,
|
||||
/// 目标原版版本。
|
||||
pub mc_version: &'a str,
|
||||
/// loader 版本 id（依赖库落点 + 临时目录名）。
|
||||
pub version_id: &'a str,
|
||||
/// installer 里读出来的 install profile（`requires_installer` 为真时必须有）。
|
||||
pub profile: Option<&'a InstallProfile>,
|
||||
/// installer jar 的磁盘路径。
|
||||
pub installer: Option<&'a Path>,
|
||||
/// 版本 JSON 已在盘上 = 上一轮跑完了，整段跳过（幂等）。
|
||||
pub installed: bool,
|
||||
}
|
||||
|
||||
/// processors 段的执行后端（真实实现转调 core；单测注入 fake）。
|
||||
pub(super) trait Backend {
|
||||
/// 下载 processor 依赖库（M27 引擎：镜像/健康度/退避/校验）。
|
||||
fn download_libraries(
|
||||
&self,
|
||||
engine: &DownloadEngine,
|
||||
files: &[PlanFile],
|
||||
sink: Option<ProgressSink>,
|
||||
) -> InstallReport;
|
||||
/// 按 M33 的解析链挑一个能跑 installer 的 Java。
|
||||
fn select_java(&self, managed: &Path, requirement: &JavaRequirement) -> Option<JavaRuntime>;
|
||||
/// 串行跑 processors。
|
||||
fn run(
|
||||
&self,
|
||||
plan: &ProcessorPlan,
|
||||
java: &JavaRuntime,
|
||||
sink: Option<StepSink>,
|
||||
) -> Result<ProcessorRun, ProcessorError>;
|
||||
}
|
||||
|
||||
/// 真实后端：三件事全部转调 core 的同一个执行器（CLI 用的就是它）。
|
||||
pub(super) struct CoreBackend;
|
||||
|
||||
impl Backend for CoreBackend {
|
||||
fn download_libraries(
|
||||
&self,
|
||||
engine: &DownloadEngine,
|
||||
files: &[PlanFile],
|
||||
sink: Option<ProgressSink>,
|
||||
) -> InstallReport {
|
||||
block_on(processors::download_libraries(
|
||||
engine,
|
||||
files,
|
||||
CONCURRENCY,
|
||||
sink,
|
||||
))
|
||||
}
|
||||
|
||||
fn select_java(&self, managed: &Path, requirement: &JavaRequirement) -> Option<JavaRuntime> {
|
||||
processors::select_java(managed, requirement)
|
||||
}
|
||||
|
||||
fn run(
|
||||
&self,
|
||||
plan: &ProcessorPlan,
|
||||
java: &JavaRuntime,
|
||||
sink: Option<StepSink>,
|
||||
) -> Result<ProcessorRun, ProcessorError> {
|
||||
processors::run(plan, java, sink)
|
||||
}
|
||||
}
|
||||
|
||||
/// 段内的进度出口：进度面板（`HostTask::Install`）+ 装日志。
|
||||
pub(super) struct Reporter<'a> {
|
||||
/// 后台线程 → host 的通道。
|
||||
pub tx: &'a JobSender,
|
||||
/// 进度记账器。
|
||||
pub meter: &'a Arc<Mutex<Meter>>,
|
||||
/// 装日志。
|
||||
pub journal: &'a Journal,
|
||||
}
|
||||
|
||||
impl Reporter<'_> {
|
||||
/// 换阶段并推一条进度。
|
||||
fn stage(&self, stage: InstallStage, message: &str) {
|
||||
let Ok(mut guard) = self.meter.lock() else {
|
||||
return;
|
||||
};
|
||||
guard.stage(stage, message);
|
||||
let _ = self
|
||||
.tx
|
||||
.send(HostTask::Install(Box::new(guard.progress.clone())));
|
||||
}
|
||||
|
||||
/// 先把待下的库记账（文件数 + 已知字节），下载回调再逐个累加。
|
||||
fn expect(&self, files: usize, bytes: u64) {
|
||||
let Ok(mut guard) = self.meter.lock() else {
|
||||
return;
|
||||
};
|
||||
guard.expect(files, bytes);
|
||||
}
|
||||
|
||||
/// 失败留痕（文案由调用方决定怎么呈现；这里只保证日志里有一条）。
|
||||
fn fail(&self, reason: String) -> String {
|
||||
self.journal.line(&format!("失败：{reason}"));
|
||||
reason
|
||||
}
|
||||
}
|
||||
|
||||
/// 跑 Forge / NeoForge 的 installer processors（`Ok(None)` = 这一轮不需要跑）。
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// 元数据缺 profile/installer、依赖库没下全、找不到可用 Java、processor 非零退出、
|
||||
/// 产物没落盘、用户取消时返回给 UI 的文案（已写进装日志）。
|
||||
pub(super) fn stage(
|
||||
env: &HostEnv,
|
||||
engine: &DownloadEngine,
|
||||
input: &StageInput<'_>,
|
||||
backend: &dyn Backend,
|
||||
reporter: &Reporter<'_>,
|
||||
cancel: &Arc<AtomicBool>,
|
||||
) -> Result<Option<ProcessorRun>, String> {
|
||||
if input.installed {
|
||||
reporter.journal.line(&format!(
|
||||
"{} 的版本 JSON 已在盘上，跳过 installer processors",
|
||||
input.version_id
|
||||
));
|
||||
return Ok(None);
|
||||
}
|
||||
let (Some(profile), Some(installer)) = (input.profile, input.installer) else {
|
||||
return Err(reporter.fail(metadata_missing(input)));
|
||||
};
|
||||
reporter.stage(InstallStage::Installing, "正在组 installer 处理器计划…");
|
||||
let scratch = env
|
||||
.layout
|
||||
.cache()
|
||||
.join("processors")
|
||||
.join(safe_name(input.version_id));
|
||||
let plan = ProcessorPlan::build(ProcessorPlanInput {
|
||||
kind: input.kind,
|
||||
mc_version: input.mc_version,
|
||||
version_id: input.version_id,
|
||||
profile,
|
||||
layout: &env.game,
|
||||
installer,
|
||||
scratch: &scratch,
|
||||
environment: &Environment::host(),
|
||||
})
|
||||
.map_err(|error| reporter.fail(diagnostic(&error)))?;
|
||||
for warning in &plan.warnings {
|
||||
reporter.journal.line(&format!("规划告警：{warning}"));
|
||||
}
|
||||
if plan.is_empty() {
|
||||
reporter
|
||||
.journal
|
||||
.line("install profile 没有 client 侧 processor，跳过这一段");
|
||||
return Ok(None);
|
||||
}
|
||||
|
||||
let total = plan.step_count();
|
||||
let bytes = plan.libraries.iter().filter_map(|file| file.size).sum();
|
||||
reporter.expect(plan.libraries.len(), bytes);
|
||||
reporter.stage(
|
||||
InstallStage::Downloading,
|
||||
&format!("下载 installer 依赖库（{} 个文件）…", plan.libraries.len()),
|
||||
);
|
||||
if cancel.load(Ordering::SeqCst) {
|
||||
return Err(CANCELLED.to_string());
|
||||
}
|
||||
let sink = sink_for(reporter.tx.clone(), Arc::clone(reporter.meter));
|
||||
let libraries = backend.download_libraries(engine, &plan.libraries, Some(sink));
|
||||
if !libraries.is_complete() {
|
||||
return Err(reporter.fail(libraries_failed(&libraries)));
|
||||
}
|
||||
|
||||
let managed = env.layout.java_managed();
|
||||
let Some(java) = backend.select_java(&managed, &plan.java_requirement) else {
|
||||
return Err(reporter.fail(java_missing(&plan.java_requirement, &managed)));
|
||||
};
|
||||
reporter.journal.line(&format!(
|
||||
"用 {}（{}）跑 {total} 步 processor",
|
||||
java.binary.display(),
|
||||
java_label(&java)
|
||||
));
|
||||
reporter.stage(
|
||||
InstallStage::Installing,
|
||||
&format!("运行 installer 处理器 0/{total}（{}）…", java_label(&java)),
|
||||
);
|
||||
if cancel.load(Ordering::SeqCst) {
|
||||
return Err(CANCELLED.to_string());
|
||||
}
|
||||
|
||||
let steps = step_sink(
|
||||
reporter.tx.clone(),
|
||||
Arc::clone(reporter.meter),
|
||||
reporter.journal.clone(),
|
||||
total,
|
||||
);
|
||||
let run = backend
|
||||
.run(&plan, &java, Some(steps))
|
||||
.map_err(|error| reporter.fail(diagnostic(&error)))?;
|
||||
for warning in &run.warnings {
|
||||
reporter.journal.line(&format!("执行告警：{warning}"));
|
||||
}
|
||||
reporter.journal.line(&format!(
|
||||
"processors 完成：执行 {} 步、跳过 {} 步",
|
||||
run.executed(),
|
||||
run.skipped()
|
||||
));
|
||||
reporter.stage(
|
||||
InstallStage::Installing,
|
||||
&format!(
|
||||
"installer 处理器完成（执行 {} 步、跳过 {} 步），正在写入版本清单…",
|
||||
run.executed(),
|
||||
run.skipped()
|
||||
),
|
||||
);
|
||||
if cancel.load(Ordering::SeqCst) {
|
||||
return Err(CANCELLED.to_string());
|
||||
}
|
||||
Ok(Some(run))
|
||||
}
|
||||
|
||||
/// 每步完成的回调：面板一行 + 装日志一行。
|
||||
///
|
||||
/// `StepSink` 要求 `'static`，所以这里全持所有权（通道/记账器/日志都是克隆）。
|
||||
fn step_sink(tx: JobSender, meter: Arc<Mutex<Meter>>, journal: Journal, total: usize) -> StepSink {
|
||||
Arc::new(move |outcome: &StepOutcome| {
|
||||
let line = step_line(outcome, total);
|
||||
journal.line(&line);
|
||||
let Ok(mut guard) = meter.lock() else {
|
||||
return;
|
||||
};
|
||||
guard.stage(InstallStage::Installing, &line);
|
||||
let _ = tx.send(HostTask::Install(Box::new(guard.progress.clone())));
|
||||
})
|
||||
}
|
||||
|
||||
/// 一步的进度/日志文案（纯函数，单测直接断言）。
|
||||
pub(super) fn step_line(outcome: &StepOutcome, total: usize) -> String {
|
||||
let suffix = match outcome.status {
|
||||
StepStatus::Skipped => "（产物已就绪，跳过）".to_string(),
|
||||
StepStatus::Executed => format!("（{} ms）", outcome.elapsed_ms),
|
||||
};
|
||||
format!(
|
||||
"installer 处理器 {}/{}：{}{suffix}",
|
||||
outcome.index, total, outcome.label
|
||||
)
|
||||
}
|
||||
|
||||
/// processor 错误 → 用户可读文案（保留 `processor_*` 大类码，便于按码搜日志）。
|
||||
pub(super) fn diagnostic(error: &ProcessorError) -> String {
|
||||
let mut text = format!("{}（{}）", error.message(), error.kind().as_str());
|
||||
if let Some(hint) = error.hint() {
|
||||
text.push_str("；建议：");
|
||||
text.push_str(hint);
|
||||
}
|
||||
text
|
||||
}
|
||||
|
||||
/// 缺 Java 运行时的专用文案（比通用错误多给一条「去哪装」）。
|
||||
pub(super) fn java_missing(requirement: &JavaRequirement, managed: &Path) -> String {
|
||||
format!(
|
||||
"跑 installer 需要 {}，但一个可用的 Java 运行时都没找到；请到「Java」页安装托管 JDK，或把 JAVA_HOME 指向可用的 JDK（托管目录 {}）",
|
||||
requirement.describe(),
|
||||
managed.display()
|
||||
)
|
||||
}
|
||||
|
||||
/// 依赖库没下全 → 列前三条失败明细。
|
||||
pub(super) fn libraries_failed(report: &InstallReport) -> String {
|
||||
let details: Vec<String> = report
|
||||
.failures(3)
|
||||
.iter()
|
||||
.filter_map(|outcome| {
|
||||
outcome
|
||||
.failure
|
||||
.as_ref()
|
||||
.map(|failure| format!("{}：{}", outcome.name, failure.message))
|
||||
})
|
||||
.collect();
|
||||
format!(
|
||||
"installer 依赖库没下全（{} 个失败，共 {} 个）：{}",
|
||||
report.failed(),
|
||||
report.files.len(),
|
||||
details.join("；")
|
||||
)
|
||||
}
|
||||
|
||||
/// 需要 installer 但元数据不全（缓存半截 / 换线路重解析过）。
|
||||
fn metadata_missing(input: &StageInput<'_>) -> String {
|
||||
format!(
|
||||
"{} {} 需要跑 installer processors，但没拿到 install profile / installer 路径；重跑一次即可（元数据缓存可能不完整）",
|
||||
input.kind.label(),
|
||||
input.version_id
|
||||
)
|
||||
}
|
||||
|
||||
/// Java 的一行短标识（`Java 21 · managed`）。
|
||||
fn java_label(java: &JavaRuntime) -> String {
|
||||
match java.major {
|
||||
Some(major) => format!("Java {major} · {}", java.origin.as_str()),
|
||||
None => format!("Java 主版本未知 · {}", java.origin.as_str()),
|
||||
}
|
||||
}
|
||||
|
||||
/// 版本 id → 可做目录名的片段（`+` 与路径分隔符都换掉，与 CLI 同规则）。
|
||||
fn safe_name(raw: &str) -> String {
|
||||
raw.chars()
|
||||
.map(|ch| {
|
||||
if ch.is_ascii_alphanumeric() || matches!(ch, '.' | '-' | '_') {
|
||||
ch
|
||||
} else {
|
||||
'_'
|
||||
}
|
||||
})
|
||||
.collect::<String>()
|
||||
.trim_end_matches('.')
|
||||
.to_string()
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
#[path = "install_processors_fixture.rs"]
|
||||
mod fixture;
|
||||
|
||||
#[cfg(test)]
|
||||
#[path = "install_processors_tests.rs"]
|
||||
mod tests;
|
||||
@@ -0,0 +1,272 @@
|
||||
//! installer processors 段的单测夹具（拆文件守 400 行上限）。
|
||||
//!
|
||||
//! 不需要网络、不需要 JDK、不真的起 java：`Harness` 给一个临时数据根 + 进度通道，
|
||||
//! `Fake` 回放预置的下载/Java/执行结果并记录被调顺序与组出来的命令行。
|
||||
|
||||
use std::cell::RefCell;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
|
||||
use std::sync::mpsc::Receiver;
|
||||
use std::sync::{Arc, Mutex};
|
||||
|
||||
use unlucky_core::addon::loader::forge::{InstallProfile, Processor};
|
||||
use unlucky_core::addon::loader::processors::{
|
||||
ProcessorError, ProcessorPlan, ProcessorRun, StepOutcome, StepSink, StepStatus,
|
||||
};
|
||||
use unlucky_core::addon::loader::LoaderKind as CoreLoaderKind;
|
||||
use unlucky_core::download::{DownloadEngine, DownloadErrorKind};
|
||||
use unlucky_core::game::install::{
|
||||
FileFailure, FileOutcome, FileStatus, InstallReport, PlanFile, ProgressSink,
|
||||
};
|
||||
use unlucky_core::game::java::{JavaOrigin, JavaRequirement, JavaRuntime};
|
||||
|
||||
use super::{Backend, Reporter, StageInput};
|
||||
use crate::dto::{CreateRequest, LoaderKind};
|
||||
use crate::host::env::HostEnv;
|
||||
use crate::host::install_journal::Journal;
|
||||
use crate::host::job::{channel, HostTask, JobSender};
|
||||
use crate::host::meter::Meter;
|
||||
|
||||
static SEQ: AtomicUsize = AtomicUsize::new(0);
|
||||
|
||||
/// 一步的计划视图（序号 / 坐标 / 参数 / classpath 条数）。
|
||||
pub(super) type StepView = (usize, String, Vec<String>, usize);
|
||||
|
||||
/// 一段 cases 的公共环境：临时数据根 + 引擎 + 进度通道。
|
||||
pub(super) struct Harness {
|
||||
dir: PathBuf,
|
||||
pub(super) env: HostEnv,
|
||||
pub(super) engine: DownloadEngine,
|
||||
tx: JobSender,
|
||||
rx: Receiver<HostTask>,
|
||||
pub(super) meter: Arc<Mutex<Meter>>,
|
||||
pub(super) journal: Journal,
|
||||
pub(super) cancel: Arc<AtomicBool>,
|
||||
}
|
||||
|
||||
impl Harness {
|
||||
pub(super) fn new() -> Self {
|
||||
let seq = SEQ.fetch_add(1, Ordering::SeqCst);
|
||||
let dir = std::env::temp_dir().join(format!("ull-proc-{}-{seq}", std::process::id()));
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
let env = HostEnv::at_root(&dir);
|
||||
let engine = crate::host::engine::engine(&env);
|
||||
let request = CreateRequest {
|
||||
version: "1.20.1".to_string(),
|
||||
loader: LoaderKind::Forge,
|
||||
loader_version: "47.2.0".to_string(),
|
||||
name: "proc".to_string(),
|
||||
};
|
||||
let (tx, rx) = channel();
|
||||
Self {
|
||||
journal: Journal::open(&env),
|
||||
meter: Arc::new(Mutex::new(Meter::new(&request))),
|
||||
cancel: Arc::new(AtomicBool::new(false)),
|
||||
dir,
|
||||
env,
|
||||
engine,
|
||||
tx,
|
||||
rx,
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn reporter(&self) -> Reporter<'_> {
|
||||
Reporter {
|
||||
tx: &self.tx,
|
||||
meter: &self.meter,
|
||||
journal: &self.journal,
|
||||
}
|
||||
}
|
||||
|
||||
/// 进度面板收到的所有文案。
|
||||
pub(super) fn messages(&self) -> Vec<String> {
|
||||
self.rx
|
||||
.try_iter()
|
||||
.filter_map(|task| match task {
|
||||
HostTask::Install(progress) => Some(progress.message.clone()),
|
||||
_ => None,
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// 装日志全文。
|
||||
pub(super) fn log(&self) -> String {
|
||||
std::fs::read_to_string(self.journal.path()).unwrap_or_default()
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for Harness {
|
||||
fn drop(&mut self) {
|
||||
std::fs::remove_dir_all(&self.dir).ok();
|
||||
}
|
||||
}
|
||||
|
||||
/// 注入用的假后端：回放预置结果 + 记录调用顺序与被组出来的命令行。
|
||||
pub(super) struct Fake {
|
||||
pub(super) libraries_ok: bool,
|
||||
pub(super) java: Option<JavaRuntime>,
|
||||
pub(super) run_error: Option<ProcessorError>,
|
||||
calls: RefCell<Vec<&'static str>>,
|
||||
steps: RefCell<Vec<StepView>>,
|
||||
}
|
||||
|
||||
impl Fake {
|
||||
pub(super) fn new() -> Self {
|
||||
Self {
|
||||
libraries_ok: true,
|
||||
java: Some(java()),
|
||||
run_error: None,
|
||||
calls: RefCell::new(Vec::new()),
|
||||
steps: RefCell::new(Vec::new()),
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn calls(&self) -> Vec<&'static str> {
|
||||
self.calls.borrow().clone()
|
||||
}
|
||||
|
||||
/// 被组出来的每步（序号 / 坐标 / 参数 / classpath 条数）。
|
||||
pub(super) fn steps(&self) -> Vec<StepView> {
|
||||
self.steps.borrow().clone()
|
||||
}
|
||||
}
|
||||
|
||||
impl Backend for Fake {
|
||||
fn download_libraries(
|
||||
&self,
|
||||
_engine: &DownloadEngine,
|
||||
files: &[PlanFile],
|
||||
_sink: Option<ProgressSink>,
|
||||
) -> InstallReport {
|
||||
self.calls.borrow_mut().push("libraries");
|
||||
let ok = self.libraries_ok;
|
||||
let outcomes = files
|
||||
.iter()
|
||||
.map(|file| FileOutcome {
|
||||
role: file.role,
|
||||
name: file.name.clone(),
|
||||
dest: file.dest.clone(),
|
||||
status: if ok {
|
||||
FileStatus::Skipped
|
||||
} else {
|
||||
FileStatus::Failed
|
||||
},
|
||||
bytes: 0,
|
||||
source: None,
|
||||
failure: (!ok).then(|| FileFailure {
|
||||
kind: DownloadErrorKind::Network,
|
||||
message: "连接超时".to_string(),
|
||||
}),
|
||||
})
|
||||
.collect();
|
||||
InstallReport {
|
||||
files: outcomes,
|
||||
version_json: None,
|
||||
warnings: Vec::new(),
|
||||
}
|
||||
}
|
||||
|
||||
fn select_java(&self, _managed: &Path, _requirement: &JavaRequirement) -> Option<JavaRuntime> {
|
||||
self.calls.borrow_mut().push("java");
|
||||
self.java.clone()
|
||||
}
|
||||
|
||||
fn run(
|
||||
&self,
|
||||
plan: &ProcessorPlan,
|
||||
java: &JavaRuntime,
|
||||
sink: Option<StepSink>,
|
||||
) -> Result<ProcessorRun, ProcessorError> {
|
||||
self.calls.borrow_mut().push("run");
|
||||
*self.steps.borrow_mut() = plan
|
||||
.steps
|
||||
.iter()
|
||||
.map(|step| {
|
||||
(
|
||||
step.index,
|
||||
step.label.clone(),
|
||||
step.args.clone(),
|
||||
step.classpath.len(),
|
||||
)
|
||||
})
|
||||
.collect();
|
||||
if let Some(error) = &self.run_error {
|
||||
return Err(error.clone());
|
||||
}
|
||||
let outcomes: Vec<StepOutcome> = plan
|
||||
.steps
|
||||
.iter()
|
||||
.map(|step| StepOutcome {
|
||||
index: step.index,
|
||||
label: step.label.clone(),
|
||||
status: StepStatus::Executed,
|
||||
outputs: step.outputs.len(),
|
||||
elapsed_ms: 12,
|
||||
stdout_tail: None,
|
||||
stderr_tail: None,
|
||||
})
|
||||
.collect();
|
||||
if let Some(sink) = &sink {
|
||||
for outcome in &outcomes {
|
||||
sink(outcome);
|
||||
}
|
||||
}
|
||||
Ok(ProcessorRun {
|
||||
java: java.clone(),
|
||||
steps: outcomes,
|
||||
warnings: Vec::new(),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// 一个主版本已知的假 Java。
|
||||
pub(super) fn java() -> JavaRuntime {
|
||||
JavaRuntime {
|
||||
binary: PathBuf::from("java"),
|
||||
origin: JavaOrigin::Managed,
|
||||
version: Some("21.0.4".to_string()),
|
||||
major: Some(21),
|
||||
bits: 64,
|
||||
vendor: Some("temurin".to_string()),
|
||||
}
|
||||
}
|
||||
|
||||
/// 一个最小可用的 install profile：一个 client 侧 processor、两个字面量参数。
|
||||
pub(super) fn profile() -> InstallProfile {
|
||||
let mut profile = InstallProfile::default();
|
||||
profile.processors.push(Processor {
|
||||
sides: vec!["client".to_string()],
|
||||
jar: Some("net.minecraftforge:installertools:1.3.0".to_string()),
|
||||
classpath: vec!["net.minecraftforge:jarsplitter:1.1.4".to_string()],
|
||||
args: vec!["--task".to_string(), "'MCP_DATA'".to_string()],
|
||||
..Processor::default()
|
||||
});
|
||||
profile
|
||||
}
|
||||
|
||||
pub(super) fn input<'a>(profile: &'a InstallProfile, installer: &'a Path) -> StageInput<'a> {
|
||||
StageInput {
|
||||
kind: CoreLoaderKind::Forge,
|
||||
mc_version: "1.20.1",
|
||||
version_id: "1.20.1-forge-47.2.0",
|
||||
profile: Some(profile),
|
||||
installer: Some(installer),
|
||||
installed: false,
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn installer() -> PathBuf {
|
||||
PathBuf::from("cache/meta/forge-installer.jar")
|
||||
}
|
||||
|
||||
pub(super) fn outcome(status: StepStatus) -> StepOutcome {
|
||||
StepOutcome {
|
||||
index: 3,
|
||||
label: "net.minecraftforge:installertools:1.3.0".to_string(),
|
||||
status,
|
||||
outputs: 2,
|
||||
elapsed_ms: 1234,
|
||||
stdout_tail: None,
|
||||
stderr_tail: None,
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,213 @@
|
||||
//! host/install_processors.rs 的单测（拆文件守 400 行上限）。
|
||||
//!
|
||||
//! 夹具在 [`super::fixture`]：这里只断言「计划怎么组」「找不到 Java 怎么说」
|
||||
//! 「哪一步挂了怎么报」「进度文案长什么样」。
|
||||
|
||||
use std::path::PathBuf;
|
||||
|
||||
use unlucky_core::addon::loader::forge::InstallProfile;
|
||||
use unlucky_core::addon::loader::processors::{ProcessorError, StepStatus};
|
||||
use unlucky_core::addon::loader::LoaderKind as CoreLoaderKind;
|
||||
use unlucky_core::download::DownloadErrorKind;
|
||||
use unlucky_core::game::install::{FileFailure, FileOutcome, FileRole, FileStatus, InstallReport};
|
||||
use unlucky_core::game::java::JavaRequirement;
|
||||
|
||||
use super::fixture::{input, installer, outcome, profile, Fake, Harness};
|
||||
use super::{diagnostic, java_missing, libraries_failed, stage, step_line, StageInput};
|
||||
|
||||
#[test]
|
||||
fn step_line_names_the_step_and_marks_the_outcome() {
|
||||
let executed = step_line(&outcome(StepStatus::Executed), 9);
|
||||
assert_eq!(
|
||||
executed,
|
||||
"installer 处理器 3/9：net.minecraftforge:installertools:1.3.0（1234 ms）"
|
||||
);
|
||||
let skipped = step_line(&outcome(StepStatus::Skipped), 9);
|
||||
assert!(skipped.contains("产物已就绪"), "{skipped}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn diagnostic_keeps_the_stable_code_and_the_hint() {
|
||||
let failed = ProcessorError::failed("net.minecraftforge:installertools:1.3.0", "1", "boom")
|
||||
.with_hint("确认 Java 版本与磁盘权限");
|
||||
let text = diagnostic(&failed);
|
||||
assert!(text.contains("processor_failed"), "{text}");
|
||||
assert!(text.contains("退出码 1"), "{text}");
|
||||
assert!(text.contains("boom"), "stderr 尾部要留：{text}");
|
||||
assert!(text.contains("建议：确认 Java 版本"), "{text}");
|
||||
|
||||
let plan = diagnostic(&ProcessorError::plan("install profile 缺 `jar`"));
|
||||
assert!(plan.contains("processor_plan"), "{plan}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn java_missing_points_at_the_java_page() {
|
||||
let managed = PathBuf::from("/tmp/.ULL/java");
|
||||
let text = java_missing(&JavaRequirement::table(21, None), &managed);
|
||||
assert!(text.contains("Java 21+"), "{text}");
|
||||
assert!(text.contains("Java」页"), "{text}");
|
||||
assert!(text.contains("JAVA_HOME"), "{text}");
|
||||
assert!(text.contains(&managed.display().to_string()), "{text}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn libraries_failed_lists_at_most_three() {
|
||||
let files: Vec<FileOutcome> = (0..4)
|
||||
.map(|index| FileOutcome {
|
||||
role: FileRole::Library,
|
||||
name: format!("lib{index}.jar"),
|
||||
dest: PathBuf::from(format!("lib{index}.jar")),
|
||||
status: FileStatus::Failed,
|
||||
bytes: 0,
|
||||
source: None,
|
||||
failure: Some(FileFailure {
|
||||
kind: DownloadErrorKind::Network,
|
||||
message: "连接超时".to_string(),
|
||||
}),
|
||||
})
|
||||
.collect();
|
||||
let report = InstallReport {
|
||||
files,
|
||||
version_json: None,
|
||||
warnings: Vec::new(),
|
||||
};
|
||||
let text = libraries_failed(&report);
|
||||
assert!(text.contains("4 个失败，共 4 个"), "{text}");
|
||||
assert!(text.contains("lib0.jar"), "{text}");
|
||||
assert!(!text.contains("lib3.jar"), "最多列三条：{text}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn stage_skips_when_the_version_json_is_already_there() {
|
||||
let h = Harness::new();
|
||||
let installer = installer();
|
||||
let profile = profile();
|
||||
let mut input = input(&profile, &installer);
|
||||
input.installed = true;
|
||||
let fake = Fake::new();
|
||||
let result = stage(&h.env, &h.engine, &input, &fake, &h.reporter(), &h.cancel);
|
||||
assert!(matches!(result, Ok(None)));
|
||||
assert!(fake.calls().is_empty(), "已装完就不该再动网络/Java");
|
||||
assert!(h.log().contains("跳过 installer processors"), "{}", h.log());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn stage_skips_an_empty_processor_list() {
|
||||
let h = Harness::new();
|
||||
let installer = installer();
|
||||
let profile = InstallProfile::default();
|
||||
let input = input(&profile, &installer);
|
||||
let fake = Fake::new();
|
||||
let result = stage(&h.env, &h.engine, &input, &fake, &h.reporter(), &h.cancel);
|
||||
assert!(matches!(result, Ok(None)), "没有 processor 就没这段");
|
||||
assert!(fake.calls().is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn stage_reports_missing_installer_metadata() {
|
||||
let h = Harness::new();
|
||||
let input = StageInput {
|
||||
kind: CoreLoaderKind::Forge,
|
||||
mc_version: "1.20.1",
|
||||
version_id: "1.20.1-forge-47.2.0",
|
||||
profile: None,
|
||||
installer: None,
|
||||
installed: false,
|
||||
};
|
||||
let fake = Fake::new();
|
||||
let err = stage(&h.env, &h.engine, &input, &fake, &h.reporter(), &h.cancel).unwrap_err();
|
||||
assert!(err.contains("install profile"), "{err}");
|
||||
assert!(h.log().contains("失败："), "{}", h.log());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn stage_builds_the_command_line_from_the_install_profile() {
|
||||
let h = Harness::new();
|
||||
let installer = installer();
|
||||
let profile = profile();
|
||||
let input = input(&profile, &installer);
|
||||
let fake = Fake::new();
|
||||
let run = stage(&h.env, &h.engine, &input, &fake, &h.reporter(), &h.cancel)
|
||||
.expect("stage 成功")
|
||||
.expect("应当真的跑了 processors");
|
||||
assert_eq!(run.executed(), 1);
|
||||
let steps = fake.steps();
|
||||
assert_eq!(steps.len(), 1);
|
||||
let (index, label, args, classpath) = &steps[0];
|
||||
assert_eq!(*index, 1);
|
||||
assert_eq!(label, "net.minecraftforge:installertools:1.3.0");
|
||||
assert_eq!(args, &vec!["--task".to_string(), "MCP_DATA".to_string()]);
|
||||
assert_eq!(*classpath, 1, "jar 自己不在 -cp 里（拼命令行时才补）");
|
||||
assert_eq!(fake.calls(), vec!["libraries", "java", "run"]);
|
||||
let messages = h.messages();
|
||||
assert!(
|
||||
messages.iter().any(|m| m.contains("installer 处理器 1/1")),
|
||||
"面板要看到当前处理器：{messages:?}"
|
||||
);
|
||||
assert!(
|
||||
messages
|
||||
.last()
|
||||
.is_some_and(|m| m.contains("正在写入版本清单")),
|
||||
"{messages:?}"
|
||||
);
|
||||
assert!(
|
||||
h.log().contains("processors 完成：执行 1 步"),
|
||||
"{}",
|
||||
h.log()
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn stage_fails_loudly_without_a_usable_java() {
|
||||
let h = Harness::new();
|
||||
let installer = installer();
|
||||
let profile = profile();
|
||||
let input = input(&profile, &installer);
|
||||
let mut fake = Fake::new();
|
||||
fake.java = None;
|
||||
let err = stage(&h.env, &h.engine, &input, &fake, &h.reporter(), &h.cancel).unwrap_err();
|
||||
assert!(err.contains("Java"), "{err}");
|
||||
assert!(err.contains("托管目录"), "{err}");
|
||||
assert_eq!(
|
||||
fake.calls(),
|
||||
vec!["libraries", "java"],
|
||||
"没 Java 就不该起进程"
|
||||
);
|
||||
assert!(h.log().contains("失败："), "{}", h.log());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn stage_fails_loudly_when_a_processor_exits_nonzero() {
|
||||
let h = Harness::new();
|
||||
let installer = installer();
|
||||
let profile = profile();
|
||||
let input = input(&profile, &installer);
|
||||
let mut fake = Fake::new();
|
||||
fake.run_error = Some(ProcessorError::failed(
|
||||
"net.minecraftforge:installertools:1.3.0",
|
||||
"1",
|
||||
"java.lang.NoSuchMethodError",
|
||||
));
|
||||
let err = stage(&h.env, &h.engine, &input, &fake, &h.reporter(), &h.cancel).unwrap_err();
|
||||
assert!(err.contains("processor_failed"), "{err}");
|
||||
assert!(err.contains("NoSuchMethodError"), "{err}");
|
||||
let log = h.log();
|
||||
assert!(log.contains("失败："), "{log}");
|
||||
assert!(log.contains("NoSuchMethodError"), "日志要能回溯：{log}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn stage_reports_incomplete_library_downloads() {
|
||||
let h = Harness::new();
|
||||
let installer = installer();
|
||||
let profile = profile();
|
||||
let input = input(&profile, &installer);
|
||||
let mut fake = Fake::new();
|
||||
fake.libraries_ok = false;
|
||||
let err = stage(&h.env, &h.engine, &input, &fake, &h.reporter(), &h.cancel).unwrap_err();
|
||||
assert!(err.contains("依赖库没下全"), "{err}");
|
||||
assert!(err.contains("连接超时"), "{err}");
|
||||
assert_eq!(fake.calls(), vec!["libraries"], "库没下全就别去选 Java");
|
||||
let progress = h.meter.lock().expect("进度锁").progress.clone();
|
||||
assert!(progress.files_total >= 2, "依赖库要计入文件总数");
|
||||
}
|
||||
@@ -0,0 +1,218 @@
|
||||
//! host/install.rs 的单测（拆文件守 400 行上限）。
|
||||
|
||||
use std::path::PathBuf;
|
||||
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
|
||||
use std::sync::{Arc, Mutex};
|
||||
|
||||
use unlucky_core::game::install::{FileOutcome, FileRole, FileStatus};
|
||||
|
||||
use super::{loader_label, run, supported, unsupported_reason, Job};
|
||||
use crate::dto::{CreateRequest, LoaderKind};
|
||||
use crate::host::env::HostEnv;
|
||||
use crate::host::install_journal::Journal;
|
||||
use crate::host::job::{channel, JobSender};
|
||||
use crate::host::meter::Meter;
|
||||
|
||||
static SEQ: AtomicUsize = AtomicUsize::new(0);
|
||||
|
||||
/// 一个装在临时根里的任务上下文（只走「联网前就返回」的用例）。
|
||||
struct Fixture {
|
||||
dir: PathBuf,
|
||||
env: HostEnv,
|
||||
tx: JobSender,
|
||||
meter: Arc<Mutex<Meter>>,
|
||||
cancel: Arc<AtomicBool>,
|
||||
journal: Journal,
|
||||
}
|
||||
|
||||
impl Fixture {
|
||||
fn new(request: &CreateRequest) -> Self {
|
||||
let seq = SEQ.fetch_add(1, Ordering::SeqCst);
|
||||
let dir =
|
||||
std::env::temp_dir().join(format!("ull-host-install-{}-{seq}", std::process::id()));
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
let env = HostEnv::at_root(&dir);
|
||||
let journal = Journal::open(&env);
|
||||
Self {
|
||||
dir,
|
||||
env,
|
||||
tx: channel().0,
|
||||
meter: Arc::new(Mutex::new(Meter::new(request))),
|
||||
cancel: Arc::new(AtomicBool::new(false)),
|
||||
journal,
|
||||
}
|
||||
}
|
||||
|
||||
fn job(&self) -> Job<'_> {
|
||||
Job {
|
||||
env: &self.env,
|
||||
tx: &self.tx,
|
||||
meter: &self.meter,
|
||||
cancel: &self.cancel,
|
||||
journal: &self.journal,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for Fixture {
|
||||
fn drop(&mut self) {
|
||||
std::fs::remove_dir_all(&self.dir).ok();
|
||||
}
|
||||
}
|
||||
|
||||
fn request(loader: LoaderKind, version: &str) -> CreateRequest {
|
||||
CreateRequest {
|
||||
version: version.to_string(),
|
||||
loader,
|
||||
loader_version: String::new(),
|
||||
name: String::new(),
|
||||
}
|
||||
}
|
||||
|
||||
/// 一个「刚下完」的文件结局（记账用）。
|
||||
fn downloaded(bytes: u64) -> FileOutcome {
|
||||
FileOutcome {
|
||||
role: FileRole::Library,
|
||||
name: "lib.jar".to_string(),
|
||||
dest: PathBuf::from("lib.jar"),
|
||||
status: FileStatus::Downloaded,
|
||||
bytes,
|
||||
source: None,
|
||||
failure: None,
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn progress_is_pre_accounted_across_segments_so_the_bar_never_snaps_to_full() {
|
||||
// M45 r1 P2-2 的回归：处理器依赖库下完那一刻，面板曾显示 36/36 满格 + 3.4MB/10MB，
|
||||
// 之后加载器库的 29 个文件才被计入 → 进度条从 100% 回落到 55% 再涨回去。
|
||||
let request = request(LoaderKind::Forge, "1.20.1");
|
||||
let mut meter = Meter::new(&request);
|
||||
|
||||
// 原版段：30 个文件全下完（install_vanilla 对总量是赋值，不是累加）
|
||||
meter.progress.files_total = 30;
|
||||
meter.progress.bytes_total = 3_000_000;
|
||||
for _ in 0..30 {
|
||||
meter.note(&downloaded(100_000));
|
||||
}
|
||||
assert!((meter.progress.ratio() - 1.0).abs() < f32::EPSILON);
|
||||
|
||||
// install_loader 的顺序：加载器库与处理器依赖库都在动手前一次预记账
|
||||
meter.expect(29, 10_000_000);
|
||||
meter.expect(36, 4_000_000);
|
||||
assert_eq!(meter.progress.files_total, 95, "两段之和一次到位");
|
||||
assert_eq!(
|
||||
meter.progress.bytes_total, 17_000_000,
|
||||
"字节是相加不是取最大"
|
||||
);
|
||||
assert!(
|
||||
meter.progress.ratio() < 0.7,
|
||||
"预记账后不能还停在满格：{}",
|
||||
meter.progress.ratio()
|
||||
);
|
||||
|
||||
// 处理器依赖库 36 个下完 → 仍没满格（加载器库还在后面）
|
||||
for _ in 0..36 {
|
||||
meter.note(&downloaded(110_000));
|
||||
}
|
||||
let ratio = meter.progress.ratio();
|
||||
assert!(
|
||||
(0.6..1.0).contains(&ratio),
|
||||
"回落到中间态而不是满格：{ratio}"
|
||||
);
|
||||
assert!(
|
||||
meter.progress.bytes_done < meter.progress.bytes_total,
|
||||
"字节总量要覆盖已下载量：{}/{}",
|
||||
meter.progress.bytes_done,
|
||||
meter.progress.bytes_total
|
||||
);
|
||||
|
||||
// 加载器库也下完 → 这时候才该是满格
|
||||
for _ in 0..29 {
|
||||
meter.note(&downloaded(340_000));
|
||||
}
|
||||
assert!((meter.progress.ratio() - 1.0).abs() < f32::EPSILON);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn loader_support_matrix_is_explicit() {
|
||||
// M45 语义变更：Forge/NeoForge 从「GUI 显式拒装」扩进受支持集合（走 installer processors）。
|
||||
for kind in [
|
||||
LoaderKind::Vanilla,
|
||||
LoaderKind::Fabric,
|
||||
LoaderKind::Quilt,
|
||||
LoaderKind::Forge,
|
||||
LoaderKind::NeoForge,
|
||||
] {
|
||||
assert!(supported(kind), "{} 应当受支持", kind.label());
|
||||
}
|
||||
// 这两家 core 侧还没有安装管线，仍然显式拒装并说清去哪装。
|
||||
for kind in [LoaderKind::OptiFine, LoaderKind::LiteLoader] {
|
||||
assert!(!supported(kind), "{} 不该被当成可装", kind.label());
|
||||
let reason = unsupported_reason(kind);
|
||||
assert!(reason.contains(kind.label()), "{reason}");
|
||||
assert!(reason.contains("还没有接入"), "{reason}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn forge_install_is_no_longer_refused_at_the_door() {
|
||||
// 旧文案是把用户赶去终端跑 `ull install`；M45 之后 GUI 与 CLI 同一条路径。
|
||||
assert!(supported(LoaderKind::Forge));
|
||||
assert!(supported(LoaderKind::NeoForge));
|
||||
assert_eq!(loader_label(LoaderKind::Forge, "47.2.0"), "Forge 47.2.0");
|
||||
assert_eq!(
|
||||
loader_label(LoaderKind::NeoForge, "21.1.80"),
|
||||
"NeoForge 21.1.80"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn meter_counts_files_and_skips_skipped_bytes() {
|
||||
let request = CreateRequest {
|
||||
version: "1.20.4".to_string(),
|
||||
loader: LoaderKind::Fabric,
|
||||
loader_version: "0.16.5".to_string(),
|
||||
name: "生存".to_string(),
|
||||
};
|
||||
let mut meter = Meter::new(&request);
|
||||
assert_eq!(meter.progress.loader, "Fabric 0.16.5");
|
||||
assert_eq!(meter.progress.instance, "生存");
|
||||
meter.progress.files_total = 2;
|
||||
|
||||
let mut outcome = FileOutcome {
|
||||
role: FileRole::Library,
|
||||
name: "a.jar".to_string(),
|
||||
dest: PathBuf::from("a.jar"),
|
||||
status: FileStatus::Downloaded,
|
||||
bytes: 100,
|
||||
source: Some("bmclapi".to_string()),
|
||||
failure: None,
|
||||
};
|
||||
meter.note(&outcome);
|
||||
assert_eq!(meter.progress.files_done, 1);
|
||||
assert_eq!(meter.progress.bytes_done, 100);
|
||||
|
||||
outcome.status = FileStatus::Skipped;
|
||||
outcome.bytes = 500;
|
||||
meter.note(&outcome);
|
||||
assert_eq!(meter.progress.files_done, 2);
|
||||
assert_eq!(meter.progress.bytes_done, 100, "跳过的文件不计入已下载字节");
|
||||
assert!((meter.progress.ratio() - 1.0).abs() < f32::EPSILON);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn empty_version_is_rejected_before_network() {
|
||||
let request = request(LoaderKind::Vanilla, "");
|
||||
let fixture = Fixture::new(&request);
|
||||
let err = run(&fixture.job(), &request).unwrap_err();
|
||||
assert!(err.contains("没有选择版本"), "{err}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unsupported_loader_is_rejected_before_network() {
|
||||
let request = request(LoaderKind::OptiFine, "1.20.1");
|
||||
let fixture = Fixture::new(&request);
|
||||
let err = run(&fixture.job(), &request).unwrap_err();
|
||||
assert!(err.contains("还没有接入"), "{err}");
|
||||
}
|
||||
@@ -0,0 +1,304 @@
|
||||
//! Java 页：四家发行版 + 回退链可视化 + 本地运行时 + 托管 JDK 安装。
|
||||
//!
|
||||
//! 回退链的两态：
|
||||
//! - **计划链**（还没装）：按生效顺序铺一排「待尝试」，让用户先看清会按什么顺序找；
|
||||
//! - **真实链**（装过一次/装失败）：`core::game::java::ChainLog` 的每跳结局与原因。
|
||||
//!
|
||||
//! 安装走 `java::install`（core 自己跑回退链），host 只负责把 `ChainLog` 翻成 DTO。
|
||||
|
||||
use unlucky_core::game::java::probe::JavaOrigin;
|
||||
use unlucky_core::game::java::source::ChainLog;
|
||||
use unlucky_core::game::java::{self, JdkVendor};
|
||||
|
||||
use crate::dto::{JavaChainOutcome, JavaChainStep, JavaPageView, JavaRuntimeView, JavaVendorView};
|
||||
|
||||
use super::env::HostEnv;
|
||||
use super::job::{spawn, HostTask, JobSender};
|
||||
|
||||
/// 托管 JDK 的默认目标大版本（D13 基准 JDK17）。
|
||||
pub const DEFAULT_JDK_MAJOR: u32 = 17;
|
||||
|
||||
/// 该装哪个大版本：取第一个实例版本的要求，没有实例就给 17。
|
||||
pub fn target_major(env: &HostEnv) -> u32 {
|
||||
let profiles = super::game::profiles(env);
|
||||
profiles
|
||||
.profiles
|
||||
.first()
|
||||
.map(|profile| {
|
||||
java::requirement_for_version(&env.game, &profile.version_id)
|
||||
.minimum
|
||||
.max(8)
|
||||
})
|
||||
.unwrap_or(DEFAULT_JDK_MAJOR)
|
||||
}
|
||||
|
||||
/// 四家发行版的展示行（镜像与吞吐口径与 CLI `ull java vendors` 一致）。
|
||||
pub fn vendors(env: &HostEnv, installed_vendors: &[String]) -> Vec<JavaVendorView> {
|
||||
let domestic = super::engine::domestic(env);
|
||||
let order = java::vendor::order(&super::engine::java_priority(env), domestic);
|
||||
let table = unlucky_core::download::MirrorTable::builtin();
|
||||
order
|
||||
.iter()
|
||||
.enumerate()
|
||||
.map(|(index, vendor)| {
|
||||
let id = vendor.id();
|
||||
JavaVendorView {
|
||||
id: id.to_string(),
|
||||
display: vendor.display().to_string(),
|
||||
rank: u32::try_from(index + 1).unwrap_or(u32::MAX),
|
||||
majors: vendor
|
||||
.hint_majors()
|
||||
.iter()
|
||||
.map(u32::to_string)
|
||||
.collect::<Vec<_>>()
|
||||
.join("/"),
|
||||
sources: sources_of(&table, *vendor),
|
||||
installed: installed_vendors.iter().any(|known| known == id),
|
||||
}
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// 一家的源清单（与 CLI 展示同形）。
|
||||
fn sources_of(table: &unlucky_core::download::MirrorTable, vendor: JdkVendor) -> Vec<String> {
|
||||
match vendor {
|
||||
JdkVendor::Temurin => table
|
||||
.adoptium
|
||||
.iter()
|
||||
.filter(|mirror| mirror.enabled)
|
||||
.map(|mirror| mirror.name.clone())
|
||||
.chain(std::iter::once(
|
||||
"GitHub 官方（国内套 gh-proxy）".to_string(),
|
||||
))
|
||||
.collect(),
|
||||
JdkVendor::Oracle => table
|
||||
.oracle_mirrors()
|
||||
.map(|mirror| format!("{} {}", mirror.name, mirror.base()))
|
||||
.collect(),
|
||||
JdkVendor::Microsoft => vec!["aka.ms → VS CDN（无国内镜像）".to_string()],
|
||||
JdkVendor::Zulu => table
|
||||
.zulu()
|
||||
.map(|zulu| vec![format!("{}（{}）", zulu.api, zulu.measured_speed)])
|
||||
.unwrap_or_default(),
|
||||
}
|
||||
}
|
||||
|
||||
/// 本地运行时（托管 / JAVA_HOME / PATH / 系统安装位置，同一路径只留优先级高者）。
|
||||
pub fn runtimes(env: &HostEnv) -> Vec<JavaRuntimeView> {
|
||||
let roots = super::engine::java_scan_roots(env);
|
||||
let candidates = java::discover::dedupe(java::candidates_in_roots(&roots));
|
||||
candidates
|
||||
.iter()
|
||||
.map(|runtime| JavaRuntimeView {
|
||||
binary: runtime.binary.display().to_string(),
|
||||
version: runtime
|
||||
.version
|
||||
.clone()
|
||||
.unwrap_or_else(|| "版本未知".to_string()),
|
||||
major: runtime.major.unwrap_or(java::DEFAULT_MAJOR),
|
||||
vendor: runtime.vendor.clone().unwrap_or_else(|| "—".to_string()),
|
||||
origin: runtime.origin.category().to_string(),
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// 托管目录（展示「装到哪」）。
|
||||
pub fn managed_roots(env: &HostEnv) -> Vec<String> {
|
||||
super::engine::java_scan_roots(env)
|
||||
.iter()
|
||||
.map(|root| root.display().to_string())
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// 计划链（按生效顺序铺「待尝试」）。
|
||||
pub fn planned_chain(env: &HostEnv) -> Vec<JavaChainStep> {
|
||||
let domestic = super::engine::domestic(env);
|
||||
let order = java::vendor::order(&super::engine::java_priority(env), domestic);
|
||||
order
|
||||
.iter()
|
||||
.map(|vendor| JavaChainStep {
|
||||
vendor: vendor.id().to_string(),
|
||||
outcome: JavaChainOutcome::Pending,
|
||||
detail: String::new(),
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// 真实链（`ChainLog` → DTO）。
|
||||
pub fn chain_steps(log: &ChainLog) -> Vec<JavaChainStep> {
|
||||
log.attempts()
|
||||
.iter()
|
||||
.map(|attempt| JavaChainStep {
|
||||
vendor: attempt.vendor.id().to_string(),
|
||||
outcome: if attempt.ok {
|
||||
JavaChainOutcome::Hit
|
||||
} else if attempt.detail.contains("不支持") {
|
||||
JavaChainOutcome::Skip
|
||||
} else {
|
||||
JavaChainOutcome::Failed
|
||||
},
|
||||
detail: attempt.detail.clone(),
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// 整页快照。
|
||||
pub fn page(env: &HostEnv, chain: Vec<JavaChainStep>, busy: bool, message: &str) -> JavaPageView {
|
||||
let runtimes = runtimes(env);
|
||||
let installed_vendors: Vec<String> = runtimes
|
||||
.iter()
|
||||
.filter(|runtime| runtime.origin == JavaOrigin::Managed.category())
|
||||
.map(|runtime| runtime.vendor.clone())
|
||||
.collect();
|
||||
let vendor_rows = vendors(env, &installed_vendors);
|
||||
let domestic = super::engine::domestic(env);
|
||||
let priority_set = !super::engine::java_priority(env).is_empty();
|
||||
let chain = if chain.is_empty() {
|
||||
planned_chain(env)
|
||||
} else {
|
||||
chain
|
||||
};
|
||||
JavaPageView {
|
||||
region: if domestic { "domestic" } else { "global" }.to_string(),
|
||||
priority_source: if priority_set {
|
||||
"java.vendorPriority"
|
||||
} else {
|
||||
"region_default"
|
||||
}
|
||||
.to_string(),
|
||||
order_text: vendor_rows
|
||||
.iter()
|
||||
.map(|vendor| vendor.display.clone())
|
||||
.collect::<Vec<_>>()
|
||||
.join(" → "),
|
||||
vendors: vendor_rows,
|
||||
chain,
|
||||
runtimes,
|
||||
managed_roots: managed_roots(env),
|
||||
busy,
|
||||
message: message.to_string(),
|
||||
}
|
||||
}
|
||||
|
||||
/// 后台装一个托管 JDK（`vendor` 为空 = 按回退链自己选）。
|
||||
pub fn spawn_install(env: HostEnv, tx: JobSender, vendor: Option<JdkVendor>) {
|
||||
spawn("java-install", move || {
|
||||
let major = target_major(&env);
|
||||
let mut busy = page(&env, Vec::new(), true, &format!("正在安装 Java {major}…"));
|
||||
busy.busy = true;
|
||||
let _ = tx.send(HostTask::Java(Box::new(busy)));
|
||||
|
||||
let engine = super::engine::engine(&env);
|
||||
let root = match super::engine::java_install_root(&env) {
|
||||
Ok(root) => root,
|
||||
Err(reason) => {
|
||||
let _ = tx.send(HostTask::Java(Box::new(page(
|
||||
&env,
|
||||
Vec::new(),
|
||||
false,
|
||||
&format!("解析 Java 安装位置失败：{reason}"),
|
||||
))));
|
||||
return;
|
||||
}
|
||||
};
|
||||
let request = match vendor {
|
||||
Some(vendor) => java::InstallRequest::with_vendor(major, vendor)
|
||||
.with_priority(super::engine::java_priority(&env)),
|
||||
None => {
|
||||
java::InstallRequest::new(major).with_priority(super::engine::java_priority(&env))
|
||||
}
|
||||
};
|
||||
let result =
|
||||
unlucky_core::download::blocking::block_on(java::install(&engine, &root, request));
|
||||
match result {
|
||||
Ok(installed) => {
|
||||
let message = if installed.reused() {
|
||||
format!(
|
||||
"Java {}（{}）已就绪：{}",
|
||||
installed.major,
|
||||
installed.vendor.id(),
|
||||
installed.root.display()
|
||||
)
|
||||
} else {
|
||||
format!(
|
||||
"已安装 Java {}（{}）→ {} · {} 个文件",
|
||||
installed.major,
|
||||
installed.vendor.display(),
|
||||
installed.root.display(),
|
||||
installed.files
|
||||
)
|
||||
};
|
||||
let chain = chain_steps(&installed.chain);
|
||||
let _ = tx.send(HostTask::Java(Box::new(page(&env, chain, false, &message))));
|
||||
}
|
||||
Err(error) => {
|
||||
let _ = tx.send(HostTask::Java(Box::new(page(
|
||||
&env,
|
||||
Vec::new(),
|
||||
false,
|
||||
&format!("Java 安装失败：{error}"),
|
||||
))));
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/// 「安装一个 Java」的 UI 文案（下载页 Java 分组的按钮说明）。
|
||||
pub fn install_hint(env: &HostEnv) -> String {
|
||||
let major = target_major(env);
|
||||
format!("按回退链取一个 Java {major}（托管目录，装完自动被启动链选中）")
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn planned_chain_covers_four_vendors() {
|
||||
let dir = std::env::temp_dir().join(format!("ull-host-java-{}", std::process::id()));
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
let env = HostEnv::at_root(&dir);
|
||||
std::fs::create_dir_all(env.layout.config()).expect("config");
|
||||
let chain = planned_chain(&env);
|
||||
assert_eq!(chain.len(), 4);
|
||||
assert!(chain
|
||||
.iter()
|
||||
.all(|step| step.outcome == JavaChainOutcome::Pending));
|
||||
assert_eq!(chain[0].vendor, "temurin", "国内/国外默认都是 Temurin 第一");
|
||||
std::fs::remove_dir_all(&dir).ok();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn chain_log_maps_to_steps() {
|
||||
let mut log = ChainLog::new();
|
||||
log.skip(
|
||||
JdkVendor::Microsoft,
|
||||
"不支持 Java 8（microsoft 只发 11/17/21/25）",
|
||||
);
|
||||
log.hit(JdkVendor::Temurin, "命中 Adoptium 17");
|
||||
let steps = chain_steps(&log);
|
||||
assert_eq!(steps.len(), 2);
|
||||
assert_eq!(steps[0].outcome, JavaChainOutcome::Skip);
|
||||
assert_eq!(steps[1].outcome, JavaChainOutcome::Hit);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn page_reports_region_and_priority_source() {
|
||||
let dir = std::env::temp_dir().join(format!("ull-host-java-page-{}", std::process::id()));
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
let env = HostEnv::at_root(&dir);
|
||||
std::fs::create_dir_all(env.layout.config()).expect("config");
|
||||
std::fs::write(
|
||||
env.launcher_config(),
|
||||
r#"{"java":{"vendorPriority":["zulu"]}}"#,
|
||||
)
|
||||
.expect("写配置");
|
||||
let page = page(&env, Vec::new(), false, "");
|
||||
assert_eq!(page.priority_source, "java.vendorPriority");
|
||||
assert_eq!(page.vendors[0].id, "zulu");
|
||||
assert_eq!(page.vendors[0].rank, 1);
|
||||
assert!(page.order_text.contains("Azul Zulu"));
|
||||
assert_eq!(page.vendors.len(), 4);
|
||||
std::fs::remove_dir_all(&dir).ok();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,136 @@
|
||||
//! 后台任务的回流消息：`HostTask` 是唯一「线程 → host」的载荷。
|
||||
//!
|
||||
//! 线程只做 core 调用（网络/磁盘），产出的都是 `crate::dto` 的 DTO；
|
||||
//! host 的 `tick` 把它们翻成 [`crate::dto::CoreEvent`]。
|
||||
//! 这样「跨线程传的是什么」在一处看全，也不会出现半成品领域类型漏回 UI。
|
||||
|
||||
use std::sync::mpsc::{Receiver, Sender};
|
||||
|
||||
use crate::dto::{
|
||||
AccountView, DeviceLoginView, DiagnosisReport, InstallProgressView, InstanceId,
|
||||
InstanceRuntime, JavaPageView, LaunchFinished, LiveLogBatch, LogLine, LogOutcome, LogSession,
|
||||
NoticeView, SessionId, VersionSummary,
|
||||
};
|
||||
use crate::toast::Toast;
|
||||
|
||||
/// 后台任务 → host 的消息。
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub enum HostTask {
|
||||
/// 版本清单（下载页）
|
||||
Versions(Result<Vec<VersionSummary>, String>),
|
||||
/// 安装进度（高频，host 只做聚合与转发）
|
||||
Install(Box<InstallProgressView>),
|
||||
/// 安装收尾（成功带实例名，失败带文案）
|
||||
InstallDone {
|
||||
/// 最终进度快照
|
||||
progress: Box<InstallProgressView>,
|
||||
/// 成功时为 `Ok(实例名)`
|
||||
result: Result<String, String>,
|
||||
},
|
||||
/// 账户列表
|
||||
Accounts(Vec<AccountView>),
|
||||
/// 设备码登录状态
|
||||
Login(Box<DeviceLoginView>),
|
||||
/// Java 页（发行版/回退链/运行时）
|
||||
Java(Box<JavaPageView>),
|
||||
/// 日志页快照（会话列表 + 选中会话的行 + 诊断）
|
||||
Logs {
|
||||
/// 会话列表
|
||||
sessions: Vec<LogSession>,
|
||||
/// 选中会话的行
|
||||
lines: Vec<LogLine>,
|
||||
/// 诊断结论
|
||||
diagnosis: Option<DiagnosisReport>,
|
||||
},
|
||||
/// 实时日志增量
|
||||
Tail(Box<LiveLogBatch>),
|
||||
/// 启动开始（pid + 会话 id）
|
||||
LaunchStarted {
|
||||
/// 实例 id
|
||||
id: InstanceId,
|
||||
/// 会话 id
|
||||
session_id: SessionId,
|
||||
/// 进程号
|
||||
pid: u32,
|
||||
},
|
||||
/// 启动阶段推进（磁贴进度环）
|
||||
Runtime {
|
||||
/// 实例 id
|
||||
id: InstanceId,
|
||||
/// 阶段状态
|
||||
runtime: InstanceRuntime,
|
||||
},
|
||||
/// 启动收尾
|
||||
LaunchEnd(Box<LaunchFinished>),
|
||||
/// 崩溃日志导入的分析结论
|
||||
Crash(Box<DiagnosisReport>),
|
||||
/// 横幅通知（隔离切换提示等）
|
||||
Notice(Box<NoticeView>),
|
||||
/// Toast
|
||||
Toast(Box<Toast>),
|
||||
/// 会话列表刷新（只换左栏）
|
||||
Sessions(Vec<LogSession>),
|
||||
}
|
||||
|
||||
/// 后台线程用的发送端（`Sender` 克隆即可）。
|
||||
pub type JobSender = Sender<HostTask>;
|
||||
|
||||
/// host 侧的接收端。
|
||||
pub type JobReceiver = Receiver<HostTask>;
|
||||
|
||||
/// 建一对通道。
|
||||
pub fn channel() -> (JobSender, JobReceiver) {
|
||||
std::sync::mpsc::channel()
|
||||
}
|
||||
|
||||
/// 起一个带名字的后台线程（名字只进 panic 信息，方便定位）。
|
||||
pub fn spawn(name: &str, job: impl FnOnce() + Send + 'static) -> std::thread::JoinHandle<()> {
|
||||
std::thread::Builder::new()
|
||||
.name(format!("ull-host-{name}"))
|
||||
.spawn(job)
|
||||
.unwrap_or_else(|error| panic!("起不来后台线程 {name}: {error}"))
|
||||
}
|
||||
|
||||
/// 人读一行「启动结束」。
|
||||
pub fn launch_summary(outcome: LogOutcome, exit_code: Option<i32>) -> String {
|
||||
match outcome {
|
||||
LogOutcome::Ok => "正常退出".to_string(),
|
||||
LogOutcome::Crashed => match exit_code {
|
||||
Some(code) => format!("崩溃（exit {code}）"),
|
||||
None => "崩溃".to_string(),
|
||||
},
|
||||
LogOutcome::SilentFail => "静默失败（exit 0 但游戏没起来）".to_string(),
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn channel_carries_tasks_across_threads() {
|
||||
let (tx, rx) = channel();
|
||||
let handle = spawn("test", move || {
|
||||
tx.send(HostTask::Toast(Box::new(Toast {
|
||||
id: 1,
|
||||
kind: crate::toast::ToastKind::Info,
|
||||
text: "hi".to_string(),
|
||||
remaining_ms: 0,
|
||||
})))
|
||||
.expect("发送");
|
||||
});
|
||||
handle.join().expect("线程结束");
|
||||
let task = rx.recv().expect("收到");
|
||||
assert!(matches!(task, HostTask::Toast(toast) if toast.text == "hi"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn launch_summary_names_the_outcome() {
|
||||
assert_eq!(launch_summary(LogOutcome::Ok, Some(0)), "正常退出");
|
||||
assert_eq!(
|
||||
launch_summary(LogOutcome::Crashed, Some(1)),
|
||||
"崩溃（exit 1）"
|
||||
);
|
||||
assert!(launch_summary(LogOutcome::SilentFail, Some(0)).contains("静默"));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,353 @@
|
||||
//! 启动全链：实例 → `LaunchRequest` → 子进程 → JSONL 事件流（GUI 版）。
|
||||
//!
|
||||
//! 与 CLI `ull launch` 同源同序（`core` 的 `game::resolve` / `arguments.expand` /
|
||||
//! `launch::adapter::build_request` / `Launcher::spawn`），差异只有两处：
|
||||
//! - **不阻塞 UI**：装配与等待都在后台线程里，进度/日志经 [`super::job::HostTask`] 回流；
|
||||
//! - **身份来自 GUI 选中的账户**（`AccountStore` → `AuthPlaceholders`），凭据只在
|
||||
//! 本模块内被读一次，绝不进 DTO。
|
||||
//!
|
||||
//! 停止：`kill_tree(pid)`（core 的三段式进程树回收），`finish()` 会照常收尾写索引。
|
||||
|
||||
use std::path::PathBuf;
|
||||
|
||||
use unlucky_core::game::arguments::Environment;
|
||||
use unlucky_core::game::install::instance::read_instance_config;
|
||||
use unlucky_core::game::isolation::{derive_game_dir, observe_mode, IsolationMode};
|
||||
use unlucky_core::game::{self, VersionJson};
|
||||
use unlucky_core::launch::adapter::{
|
||||
self, AdapterOptions, AdapterWarning, LibraryInput, SnapshotInput,
|
||||
};
|
||||
use unlucky_core::launch::request::{JavaSelection, LaunchRequest, MemoryOptions};
|
||||
use unlucky_core::launch::time::{format_rfc3339_millis, now};
|
||||
use unlucky_core::launch::tree_kill;
|
||||
use unlucky_core::launch::{Launcher, LauncherConfig};
|
||||
use unlucky_core::platform::paths::ProcessEnv;
|
||||
|
||||
use crate::dto::{
|
||||
InstanceId, InstanceRuntime, LaunchFinished, LaunchStage, LoaderKind, LogOutcome, Progress,
|
||||
};
|
||||
|
||||
use super::env::HostEnv;
|
||||
use super::job::{launch_summary, HostTask, JobSender};
|
||||
|
||||
/// 启动器名（与 CLI `meta::LAUNCHER_NAME` 同值）。
|
||||
pub const LAUNCHER_NAME: &str = "Unlucky Launcher";
|
||||
|
||||
/// 一次启动需要的实例信息。
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
pub struct LaunchTarget {
|
||||
/// 实例 id
|
||||
pub id: InstanceId,
|
||||
/// 实例名
|
||||
pub name: String,
|
||||
/// 绑定的版本 id
|
||||
pub version_id: String,
|
||||
/// 账户 id（`None` = 离线占位）
|
||||
pub account: Option<String>,
|
||||
}
|
||||
|
||||
/// 选中并用起来的 Java（`summary` 给 UI 一行提示）。
|
||||
pub struct JavaPick {
|
||||
/// 交给 adapter 的选择
|
||||
pub selection: JavaSelection,
|
||||
/// 人读一行
|
||||
pub summary: String,
|
||||
}
|
||||
|
||||
/// 选一个能用的 Java：托管 > JAVA_HOME > PATH（`core::game::java` 的探测与优先级）。
|
||||
pub fn pick_java(env: &HostEnv, version_id: &str) -> JavaPick {
|
||||
let store = env.store();
|
||||
let install_root = store
|
||||
.doc()
|
||||
.effective_str("java.installRoot")
|
||||
.map(str::trim)
|
||||
.filter(|text| !text.is_empty())
|
||||
.map(PathBuf::from);
|
||||
let roots = unlucky_core::game::java::location::scan_roots(
|
||||
env.mode(),
|
||||
&env.layout,
|
||||
install_root.as_deref(),
|
||||
env.platform,
|
||||
&ProcessEnv,
|
||||
);
|
||||
let candidates = unlucky_core::game::java::candidates_in_roots(&roots);
|
||||
let required = unlucky_core::game::java::requirement_for_version(&env.game, version_id);
|
||||
let picked = unlucky_core::game::java::pick(&candidates, &required).cloned();
|
||||
match picked {
|
||||
Some(runtime) => {
|
||||
let major = runtime
|
||||
.major
|
||||
.unwrap_or(unlucky_core::game::java::DEFAULT_MAJOR);
|
||||
let summary = format!(
|
||||
"Java {}（{}{}）",
|
||||
runtime.version.clone().unwrap_or_else(|| major.to_string()),
|
||||
runtime.origin.category(),
|
||||
runtime
|
||||
.vendor
|
||||
.as_ref()
|
||||
.map(|vendor| format!(" · {vendor}"))
|
||||
.unwrap_or_default()
|
||||
);
|
||||
JavaPick {
|
||||
selection: JavaSelection::new(runtime.binary, major, runtime.bits),
|
||||
summary,
|
||||
}
|
||||
}
|
||||
None => {
|
||||
let binary = PathBuf::from(unlucky_core::game::java::java_binary_name());
|
||||
let major = required.minimum;
|
||||
JavaPick {
|
||||
selection: JavaSelection::new(binary, major, 64),
|
||||
summary: format!("PATH 上的 Java（未探测到版本，按 Java {major} 启动）"),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// 装配 [`LaunchRequest`]（与 CLI `snapshot::prepare` 同序）。
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// 版本 JSON 缺失/非法、继承链断裂、隔离派生失败时返回用户可读文案。
|
||||
pub fn build_request(
|
||||
env: &HostEnv,
|
||||
target: &LaunchTarget,
|
||||
) -> Result<(LaunchRequest, Vec<String>), String> {
|
||||
let version_id = target.version_id.clone();
|
||||
let manifest_path = env.game.version_json(&version_id);
|
||||
let text = std::fs::read_to_string(&manifest_path)
|
||||
.map_err(|error| format!("读版本 JSON 失败 {}：{error}", manifest_path.display()))?;
|
||||
let manifest =
|
||||
VersionJson::from_json_str(&text).map_err(|error| format!("版本 JSON 非法：{error}"))?;
|
||||
let source = |id: &str| -> Option<VersionJson> {
|
||||
std::fs::read_to_string(env.game.version_json(id))
|
||||
.ok()
|
||||
.and_then(|text| VersionJson::from_json_str(&text).ok())
|
||||
};
|
||||
let resolved =
|
||||
game::resolve(&source, &manifest).map_err(|error| format!("解析继承链失败：{error}"))?;
|
||||
|
||||
let environment = Environment::host();
|
||||
let expanded = resolved
|
||||
.arguments
|
||||
.as_ref()
|
||||
.map(|arguments| arguments.expand(&environment))
|
||||
.unwrap_or_default();
|
||||
|
||||
let mut libraries: Vec<LibraryInput> = Vec::new();
|
||||
for library in resolved.libraries.as_deref().unwrap_or_default() {
|
||||
if !library.applies(&environment) || library.native_classifier(&environment).is_some() {
|
||||
continue;
|
||||
}
|
||||
let Ok(coordinate) = library.coordinate() else {
|
||||
continue;
|
||||
};
|
||||
let path = if library.is_local() {
|
||||
env.game.version_library(&version_id, &coordinate)
|
||||
} else {
|
||||
env.game.library(&coordinate)
|
||||
};
|
||||
libraries.push(LibraryInput::new(path, library.name.clone()));
|
||||
}
|
||||
let natives = unlucky_core::launch::natives::collect(
|
||||
&env.game,
|
||||
&version_id,
|
||||
resolved.libraries.as_deref().unwrap_or_default(),
|
||||
&environment,
|
||||
);
|
||||
|
||||
let game_dir = run_dir(env, target)?;
|
||||
let jar_id = resolved.jar.clone().unwrap_or_else(|| version_id.clone());
|
||||
let assets_root = env.game.assets_dir();
|
||||
let assets_index = resolved
|
||||
.assets
|
||||
.clone()
|
||||
.or_else(|| resolved.asset_index.as_ref().map(|index| index.id.clone()));
|
||||
let snapshot = SnapshotInput {
|
||||
version_id: &version_id,
|
||||
version_name: Some(&target.name),
|
||||
version_type: None,
|
||||
game_version: None,
|
||||
main_class: resolved.main_class.as_deref(),
|
||||
jvm_arguments: &expanded.jvm,
|
||||
game_arguments: &expanded.game,
|
||||
legacy_arguments: resolved.minecraft_arguments.as_deref(),
|
||||
libraries: &libraries,
|
||||
natives: &natives,
|
||||
primary_jar: env.game.version_jar(&jar_id),
|
||||
game_dir,
|
||||
assets_index: assets_index.as_deref(),
|
||||
natives_dir: env.game.natives_dir(&version_id),
|
||||
library_dir: env.game.libraries_dir(),
|
||||
assets_root: assets_root.clone(),
|
||||
game_assets: assets_root,
|
||||
};
|
||||
|
||||
let java = pick_java(env, &version_id);
|
||||
let (auth, identity_line) = super::identity::resolve(env, target.account.as_deref())?;
|
||||
let memory = env
|
||||
.store()
|
||||
.effective("java.default_memory_mb")
|
||||
.and_then(serde_json::Value::as_u64)
|
||||
.and_then(|value| u32::try_from(value).ok());
|
||||
let options = AdapterOptions {
|
||||
java: java.selection,
|
||||
memory: MemoryOptions {
|
||||
min_mb: None,
|
||||
max_mb: memory,
|
||||
},
|
||||
auth,
|
||||
launcher_name: LAUNCHER_NAME.to_string(),
|
||||
launcher_version: env!("CARGO_PKG_VERSION").to_string(),
|
||||
language: "zh-CN".to_string(),
|
||||
..AdapterOptions::strict()
|
||||
};
|
||||
let output = adapter::build_request(&snapshot, options);
|
||||
let mut warnings: Vec<String> = output.warnings.iter().map(describe_warning).collect();
|
||||
warnings.push(java.summary);
|
||||
warnings.push(identity_line);
|
||||
let mut request = output.request;
|
||||
request.instance.id = target.id.clone();
|
||||
request.instance.name = target.name.clone();
|
||||
Ok((request, warnings))
|
||||
}
|
||||
|
||||
/// 派生运行目录（D20 覆盖链：实例 `isolation` > 全局 `instances.mode`）。
|
||||
fn run_dir(env: &HostEnv, target: &LaunchTarget) -> Result<PathBuf, String> {
|
||||
let global = super::game::global_mode(env);
|
||||
let config = read_instance_config(&env.layout, &target.id)
|
||||
.map_err(|error| format!("读实例设置失败：{error}"))?;
|
||||
let derivation = derive_game_dir(&env.game, &target.version_id, global, config.as_ref(), None)
|
||||
.map_err(|error| format!("隔离目录派生失败：{error}"))?;
|
||||
if let Some(mut config) = config {
|
||||
let at = format_rfc3339_millis(now());
|
||||
if observe_mode(&mut config, &env.game, &at, derivation.isolation).unwrap_or(false) {
|
||||
let _ =
|
||||
unlucky_core::game::install::instance::write_instance_config(&env.layout, &config);
|
||||
}
|
||||
}
|
||||
Ok(derivation.game_dir)
|
||||
}
|
||||
|
||||
/// 起一次启动（后台线程；进度/日志/收尾全部走 `HostTask`）。
|
||||
pub fn start(env: HostEnv, tx: JobSender, target: LaunchTarget) {
|
||||
let id = target.id.clone();
|
||||
let tx_progress = tx.clone();
|
||||
super::job::spawn("launch", move || {
|
||||
let _ = tx_progress.send(HostTask::Runtime {
|
||||
id: id.clone(),
|
||||
runtime: InstanceRuntime::Busy {
|
||||
stage: LaunchStage::Launch,
|
||||
progress: Progress { done: 0, total: 1 },
|
||||
},
|
||||
});
|
||||
let (request, warnings) = match build_request(&env, &target) {
|
||||
Ok(ok) => ok,
|
||||
Err(reason) => {
|
||||
let _ = tx.send(HostTask::LaunchEnd(Box::new(LaunchFinished {
|
||||
id,
|
||||
session: String::new(),
|
||||
outcome: LogOutcome::Crashed,
|
||||
summary: format!("启动失败：{reason}"),
|
||||
})));
|
||||
return;
|
||||
}
|
||||
};
|
||||
for warning in &warnings {
|
||||
let _ = tx.send(HostTask::Notice(Box::new(crate::dto::NoticeView::new(
|
||||
&format!("launch-warn:{}", target.id),
|
||||
crate::dto::NoticeLevel::Info,
|
||||
"启动提示",
|
||||
warning,
|
||||
))));
|
||||
}
|
||||
let config = LauncherConfig::new(env.sessions_root())
|
||||
.with_launcher(LAUNCHER_NAME, env!("CARGO_PKG_VERSION"));
|
||||
let session = match Launcher::new(config).spawn(&request) {
|
||||
Ok(session) => session,
|
||||
Err(error) => {
|
||||
let _ = tx.send(HostTask::LaunchEnd(Box::new(LaunchFinished {
|
||||
id,
|
||||
session: String::new(),
|
||||
outcome: LogOutcome::Crashed,
|
||||
summary: format!("启动失败：{error}"),
|
||||
})));
|
||||
return;
|
||||
}
|
||||
};
|
||||
let session_id = session.session_id().to_string();
|
||||
let pid = session.pid();
|
||||
let _ = tx.send(HostTask::LaunchStarted {
|
||||
id: id.clone(),
|
||||
session_id: session_id.clone(),
|
||||
pid,
|
||||
});
|
||||
let _ = tx.send(HostTask::Runtime {
|
||||
id: id.clone(),
|
||||
runtime: InstanceRuntime::Running { pid },
|
||||
});
|
||||
match session.finish() {
|
||||
Ok(handle) => {
|
||||
let outcome = super::identity::outcome_of(&handle);
|
||||
let _ = tx.send(HostTask::LaunchEnd(Box::new(LaunchFinished {
|
||||
id,
|
||||
session: session_id,
|
||||
outcome,
|
||||
summary: format!(
|
||||
"{}（{}，{:.1}s）",
|
||||
launch_summary(outcome, Some(handle.exit.code)),
|
||||
handle.exit.exit_type.as_str(),
|
||||
handle.uptime_ms as f64 / 1000.0
|
||||
),
|
||||
})));
|
||||
}
|
||||
Err(error) => {
|
||||
let _ = tx.send(HostTask::LaunchEnd(Box::new(LaunchFinished {
|
||||
id,
|
||||
session: session_id,
|
||||
outcome: LogOutcome::SilentFail,
|
||||
summary: format!("启动收尾失败：{error}"),
|
||||
})));
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/// 停止一次启动（按 pid 回收进程树；`finish()` 会在后台线程里照常收尾）。
|
||||
pub fn stop(pid: u32) -> Result<(), String> {
|
||||
tree_kill::kill_tree(pid, std::time::Duration::from_secs(3))
|
||||
.map_err(|error| format!("停止进程 {pid} 失败：{error}"))
|
||||
}
|
||||
|
||||
/// 适配层告警 → 人读一行。
|
||||
fn describe_warning(warning: &AdapterWarning) -> String {
|
||||
match warning {
|
||||
AdapterWarning::MissingLibrary { name, path } => {
|
||||
format!("缺少库文件 {name}（{}）", path.display())
|
||||
}
|
||||
AdapterWarning::MissingGameArguments => "版本 JSON 没有游戏参数".to_string(),
|
||||
AdapterWarning::MissingAssetsIndex => "版本 JSON 没有资源索引".to_string(),
|
||||
AdapterWarning::MissingMainClass => "版本 JSON 没有 mainClass".to_string(),
|
||||
AdapterWarning::MissingNativeJar { name, path } => {
|
||||
format!("缺少 natives 构件 {name}（{}）", path.display())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// 加载器 → 适配层的模组加载器标记（GUI 只用于显示，不改命令行）。
|
||||
pub fn loader_label(kind: LoaderKind) -> &'static str {
|
||||
match kind {
|
||||
LoaderKind::Vanilla => "原版",
|
||||
LoaderKind::Fabric => "Fabric",
|
||||
LoaderKind::Quilt => "Quilt",
|
||||
LoaderKind::Forge => "Forge",
|
||||
LoaderKind::NeoForge => "NeoForge",
|
||||
LoaderKind::OptiFine => "OptiFine",
|
||||
LoaderKind::LiteLoader => "LiteLoader",
|
||||
}
|
||||
}
|
||||
|
||||
/// 隔离档位的展示串（`isolated` / `shared`）。
|
||||
pub fn isolation_label(mode: IsolationMode) -> &'static str {
|
||||
mode.as_str()
|
||||
}
|
||||
@@ -0,0 +1,267 @@
|
||||
//! host 启动状态机单测（P2-1/P2-2 的回归网）。
|
||||
//!
|
||||
//! 覆盖三件事：
|
||||
//! 1. `running_pid` 按实例 id 取 pid（并发启动不会把 A 的停止键指到 B）；
|
||||
//! 2. 重复启动守卫（`launches` 已落盘 + `pending` 窗口两态都要挡）；
|
||||
//! 3. `refresh_instances` 重建快照后仍保留真实运行时（Running / Busy / Failed）。
|
||||
|
||||
use unlucky_core::game::install::instance::write_profiles;
|
||||
use unlucky_core::game::{InstanceProfile, ProfileId, ProfileList};
|
||||
|
||||
use super::*;
|
||||
use crate::dto::{LaunchFinished, LogOutcome};
|
||||
use crate::toast::ToastKind;
|
||||
|
||||
/// 临时数据根守卫：测试结束（含断言 panic）时把目录删掉，不留空壳。
|
||||
struct TempRoot(std::path::PathBuf);
|
||||
|
||||
impl Drop for TempRoot {
|
||||
fn drop(&mut self) {
|
||||
let _ = std::fs::remove_dir_all(&self.0);
|
||||
}
|
||||
}
|
||||
|
||||
/// 建一个只有一条实例档案的数据根，返回 `(host, instance_id, 守卫)`。
|
||||
fn host_with_instance(label: &str) -> (CoreHost, String, TempRoot) {
|
||||
let dir = std::env::temp_dir().join(format!(
|
||||
"ull-host-launch-{label}-{}-{}",
|
||||
std::process::id(),
|
||||
line!()
|
||||
));
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
let env = HostEnv::at_root(&dir);
|
||||
std::fs::create_dir_all(env.layout.config()).expect("config 目录");
|
||||
|
||||
let profile = InstanceProfile {
|
||||
id: ProfileId::generate(),
|
||||
name: "demo".to_string(),
|
||||
version_id: "1.20.1".to_string(),
|
||||
game_dir: None,
|
||||
running_dir: None,
|
||||
java_path: None,
|
||||
created_at: None,
|
||||
last_played_at: None,
|
||||
extra: std::collections::BTreeMap::new(),
|
||||
};
|
||||
let id = profile.id.as_str().to_string();
|
||||
let profiles = ProfileList {
|
||||
profiles: vec![profile],
|
||||
..ProfileList::default()
|
||||
};
|
||||
write_profiles(&env.layout, &profiles).expect("写 profiles");
|
||||
(CoreHost::headless(env), id, TempRoot(dir))
|
||||
}
|
||||
|
||||
fn live(instance: &str, session: &str, pid: u32) -> LiveLaunch {
|
||||
LiveLaunch {
|
||||
instance: instance.to_string(),
|
||||
session: session.to_string(),
|
||||
pid,
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn running_pid_is_per_instance_not_a_single_slot() {
|
||||
let (mut host, id, _root) = host_with_instance("pid");
|
||||
host.launches.push(live("a", "s-a", 111));
|
||||
host.launches.push(live("b", "s-b", 222));
|
||||
|
||||
assert_eq!(host.running_pid("a"), Some(111));
|
||||
assert_eq!(host.running_pid("b"), Some(222));
|
||||
assert_eq!(
|
||||
host.running_pid("c"),
|
||||
None,
|
||||
"没启动过的实例不该拿到别人的 pid"
|
||||
);
|
||||
|
||||
// A 收尾后只影响 A：这正是 review r1 P2-1 的场景（旧实现共用一个槽位）。
|
||||
host.launches.retain(|entry| entry.instance != "a");
|
||||
assert_eq!(host.running_pid("a"), None);
|
||||
assert_eq!(host.running_pid("b"), Some(222));
|
||||
|
||||
// 落盘实例默认是 Idle，兜底分支不误报。
|
||||
assert_eq!(host.running_pid(&id), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn duplicate_launch_is_rejected_before_spawning() {
|
||||
let (mut host, id, _root) = host_with_instance("dup");
|
||||
let _ = host.drain_events();
|
||||
host.launches.push(live(&id, "s", 111));
|
||||
|
||||
host.start_launch(&id);
|
||||
|
||||
let events = host.drain_events();
|
||||
assert!(
|
||||
!events.iter().any(|event| matches!(
|
||||
event,
|
||||
AppEvent::Core(CoreEvent::InstanceRuntimeChanged { .. })
|
||||
)),
|
||||
"已在运行/启动中的实例不该再发 Busy（那会起第二个进程）"
|
||||
);
|
||||
assert!(
|
||||
events
|
||||
.iter()
|
||||
.any(|event| matches!(event, AppEvent::Toast(toast) if toast.kind == ToastKind::Warn)),
|
||||
"至少要给用户一条「已经在启动/运行中」的提示"
|
||||
);
|
||||
assert_eq!(host.launches.len(), 1, "启动表不该被重复启动污染");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pending_window_also_blocks_a_second_launch() {
|
||||
let (mut host, id, _root) = host_with_instance("pending");
|
||||
// 走 start_launch 用的同一个入口，模拟「已受理、后台线程还没回报 LaunchStarted」。
|
||||
host.mark_pending(&id);
|
||||
assert!(host.in_flight(&id));
|
||||
|
||||
let _ = host.drain_events();
|
||||
host.start_launch(&id);
|
||||
let events = host.drain_events();
|
||||
assert!(
|
||||
!events.iter().any(|event| matches!(
|
||||
event,
|
||||
AppEvent::Core(CoreEvent::InstanceRuntimeChanged { .. })
|
||||
)),
|
||||
"pending 窗口内重复点启动必须被挡住"
|
||||
);
|
||||
assert_eq!(host.pending.len(), 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn launch_started_registers_and_launch_end_clears() {
|
||||
let (mut host, id, _root) = host_with_instance("cycle");
|
||||
host.mark_pending(&id);
|
||||
|
||||
host.handle(HostTask::LaunchStarted {
|
||||
id: id.clone(),
|
||||
session_id: "20261031T120000-abcd12".to_string(),
|
||||
pid: 4_242,
|
||||
});
|
||||
assert!(!host.pending.contains(&id), "回报后 pending 要清掉");
|
||||
assert_eq!(host.running_pid(&id), Some(4_242));
|
||||
|
||||
host.handle(HostTask::LaunchEnd(Box::new(LaunchFinished {
|
||||
id: id.clone(),
|
||||
session: "20261031T120000-abcd12".to_string(),
|
||||
outcome: LogOutcome::Ok,
|
||||
summary: "正常退出".to_string(),
|
||||
})));
|
||||
assert!(host.launches.is_empty(), "收尾后启动表要清空");
|
||||
assert!(!host.failed.contains_key(&id));
|
||||
assert_eq!(host.running_pid(&id), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn refresh_keeps_running_instances_running() {
|
||||
let (mut host, id, _root) = host_with_instance("refresh-run");
|
||||
host.launches.push(live(&id, "s", 4_242));
|
||||
let _ = host.drain_events();
|
||||
|
||||
host.refresh_instances();
|
||||
|
||||
let instance = instances_from_events(host.drain_events())
|
||||
.into_iter()
|
||||
.find(|instance| instance.id == id)
|
||||
.expect("刷新后应有该实例");
|
||||
assert_eq!(
|
||||
instance.runtime,
|
||||
InstanceRuntime::Running { pid: 4_242 },
|
||||
"刷新（装版本/账户变更/别的实例收尾）不能把在跑实例打回 Idle"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn refresh_keeps_pending_as_busy_and_failed_as_failed() {
|
||||
let (mut host, id, _root) = host_with_instance("refresh-busy");
|
||||
|
||||
// Busy：走 start_launch 用的同一个入口（mark_pending），而不是直接改字段。
|
||||
host.mark_pending(&id);
|
||||
let pending = instances_from_events({
|
||||
host.refresh_instances();
|
||||
host.drain_events()
|
||||
})
|
||||
.into_iter()
|
||||
.find(|instance| instance.id == id)
|
||||
.expect("实例存在");
|
||||
assert!(matches!(
|
||||
pending.runtime,
|
||||
InstanceRuntime::Busy {
|
||||
stage: crate::dto::LaunchStage::Launch,
|
||||
..
|
||||
}
|
||||
));
|
||||
|
||||
// Failed：走唯一真实写入路径 LaunchEnd（不是手动塞 failed 表）。
|
||||
host.handle(HostTask::LaunchEnd(Box::new(LaunchFinished {
|
||||
id: id.clone(),
|
||||
session: "20261031T120000-dead01".to_string(),
|
||||
outcome: LogOutcome::Crashed,
|
||||
summary: "崩溃（exit 1）".to_string(),
|
||||
})));
|
||||
assert!(!host.pending.contains(&id), "LaunchEnd 必须清 pending");
|
||||
assert!(!host.in_flight(&id), "收尾后该实例要能被重新启动");
|
||||
|
||||
let failed = instances_from_events({
|
||||
host.refresh_instances();
|
||||
host.drain_events()
|
||||
})
|
||||
.into_iter()
|
||||
.find(|instance| instance.id == id)
|
||||
.expect("实例存在");
|
||||
assert_eq!(
|
||||
failed.runtime,
|
||||
InstanceRuntime::Failed {
|
||||
reason: "崩溃（exit 1）".to_string()
|
||||
},
|
||||
"失败原因要经得住一次刷新（否则磁贴的「重试」外观会被 Idle 盖掉）"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn launch_end_before_launch_started_still_releases_the_instance() {
|
||||
let (mut host, id, _root) = host_with_instance("fail-early");
|
||||
// build_request / spawn 失败的现场：start_launch 已标 pending、后台线程只发 LaunchEnd。
|
||||
host.mark_pending(&id);
|
||||
assert!(host.in_flight(&id));
|
||||
|
||||
host.handle(HostTask::LaunchEnd(Box::new(LaunchFinished {
|
||||
id: id.clone(),
|
||||
session: String::new(),
|
||||
outcome: LogOutcome::Crashed,
|
||||
summary: "启动失败：找不到 Java".to_string(),
|
||||
})));
|
||||
|
||||
assert!(
|
||||
!host.pending.contains(&id),
|
||||
"LaunchEnd 早于 LaunchStarted 时也必须清 pending（否则该实例本会话再也起不来）"
|
||||
);
|
||||
assert!(!host.in_flight(&id), "失败后要能重试");
|
||||
|
||||
let failed = instances_from_events({
|
||||
host.refresh_instances();
|
||||
host.drain_events()
|
||||
})
|
||||
.into_iter()
|
||||
.find(|instance| instance.id == id)
|
||||
.expect("实例存在");
|
||||
assert_eq!(
|
||||
failed.runtime,
|
||||
InstanceRuntime::Failed {
|
||||
reason: "启动失败：找不到 Java".to_string()
|
||||
},
|
||||
"早失败也要在磁贴上留下「失败/重试」，不能被 Idle 盖掉"
|
||||
);
|
||||
}
|
||||
|
||||
/// 从事件队列里取最后一次 `InstancesChanged`。
|
||||
fn instances_from_events(events: Vec<AppEvent>) -> Vec<crate::dto::InstanceSummary> {
|
||||
events
|
||||
.into_iter()
|
||||
.rev()
|
||||
.find_map(|event| match event {
|
||||
AppEvent::Core(CoreEvent::InstancesChanged(instances)) => Some(instances),
|
||||
_ => None,
|
||||
})
|
||||
.unwrap_or_default()
|
||||
}
|
||||
@@ -0,0 +1,342 @@
|
||||
//! 日志 / 诊断：会话索引 → 会话列表，事件 JSONL → 日志行，规则引擎 → 诊断卡片。
|
||||
//!
|
||||
//! 与 CLI `ull logs` / `ull diagnose` 同源（`launch::session_index` + `diagnose` 规则引擎）：
|
||||
//! 「同一份 jsonl 的两种读法」只有这一处实现（M39 ports/events.rs 的设计）。
|
||||
//! 实时滚动 = host 每拍尾随启动会话的 JSONL（只读新增字节），不额外开第二条事件通道。
|
||||
|
||||
use std::io::{Read, Seek, SeekFrom};
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
use serde_json::Value;
|
||||
use unlucky_core::diagnose::collectors::{ExitSignal, SignalOrigin};
|
||||
use unlucky_core::diagnose::engine::{Diagnoser, DiagnosisInput};
|
||||
use unlucky_core::diagnose::loader::RuleLoader;
|
||||
use unlucky_core::launch::session_index::{self, SessionIndexEntry};
|
||||
|
||||
use crate::dto::{
|
||||
Diagnosis, DiagnosisReport, LogLevel, LogLine, LogOutcome, LogSession, SessionId,
|
||||
};
|
||||
|
||||
use super::env::HostEnv;
|
||||
|
||||
/// 送进规则引擎的默认尾巴行数（与 CLI 同值，避免两条路看到不同证据）。
|
||||
pub const DEFAULT_TAIL: usize = 2000;
|
||||
|
||||
/// 日志页一次最多渲染的行数（超出的截断，避免大文件把 UI 拖死）。
|
||||
pub const MAX_RENDERED_LINES: usize = 2_000;
|
||||
|
||||
/// 会话索引目录（`.ULL/data/agent/sessions`）。
|
||||
pub fn root(env: &HostEnv) -> PathBuf {
|
||||
env.sessions_root()
|
||||
}
|
||||
|
||||
/// 会话列表（新→旧）。
|
||||
pub fn sessions(env: &HostEnv) -> Vec<LogSession> {
|
||||
let index = session_index::index_path(&root(env));
|
||||
let mut entries = session_index::read_all(&index).unwrap_or_default();
|
||||
entries.sort_by(|a, b| b.started_at.cmp(&a.started_at));
|
||||
entries.iter().map(session_of).collect()
|
||||
}
|
||||
|
||||
/// 索引条目 → 左栏会话行。
|
||||
pub fn session_of(entry: &SessionIndexEntry) -> LogSession {
|
||||
LogSession {
|
||||
id: entry.session_id.clone(),
|
||||
instance: if entry.instance_name.is_empty() {
|
||||
entry.instance_id.clone()
|
||||
} else {
|
||||
entry.instance_name.clone()
|
||||
},
|
||||
when: display_time(&entry.started_at),
|
||||
outcome: outcome_of(entry),
|
||||
duration_secs: entry.duration_ms / 1000,
|
||||
}
|
||||
}
|
||||
|
||||
/// 结局：静默失败 > 崩溃（非 0 / crash_found） > 正常。
|
||||
pub fn outcome_of(entry: &SessionIndexEntry) -> LogOutcome {
|
||||
if entry.silent_failure {
|
||||
LogOutcome::SilentFail
|
||||
} else if entry.crash_found
|
||||
|| entry.exit_code.is_some_and(|code| code != 0)
|
||||
|| (entry.exit_code.is_none() && !entry.ended_at.is_empty())
|
||||
{
|
||||
LogOutcome::Crashed
|
||||
} else {
|
||||
LogOutcome::Ok
|
||||
}
|
||||
}
|
||||
|
||||
/// `2026-10-29T19:22:45.123Z` → `10-29 19:22`。
|
||||
pub fn display_time(started_at: &str) -> String {
|
||||
let body = started_at.trim_end_matches('Z');
|
||||
let Some((date, time)) = body.split_once('T') else {
|
||||
return started_at.to_string();
|
||||
};
|
||||
let date = date.get(5..).unwrap_or(date);
|
||||
let time = time.get(..5).unwrap_or(time);
|
||||
format!("{date} {time}")
|
||||
}
|
||||
|
||||
/// 事件流文件路径（`<sessions>/game/<log_path>`）。
|
||||
pub fn event_path(env: &HostEnv, entry: &SessionIndexEntry) -> PathBuf {
|
||||
root(env).join("game").join(&entry.log_path)
|
||||
}
|
||||
|
||||
/// 会话 id 或唯一前缀 → 索引条目。
|
||||
fn find(env: &HostEnv, key: &str) -> Option<SessionIndexEntry> {
|
||||
let index = session_index::index_path(&root(env));
|
||||
let entries = session_index::read_all(&index).ok()?;
|
||||
if let Some(exact) = entries.iter().find(|entry| entry.session_id == key) {
|
||||
return Some(exact.clone());
|
||||
}
|
||||
entries
|
||||
.iter()
|
||||
.find(|entry| entry.session_id.starts_with(key))
|
||||
.cloned()
|
||||
}
|
||||
|
||||
/// 事件 JSON → 一行日志（`stdout`/`stderr` 的 `payload.line`）。
|
||||
pub fn line_of(event: &Value) -> Option<LogLine> {
|
||||
let text = event.pointer("/payload/line").and_then(Value::as_str)?;
|
||||
let kind = event
|
||||
.get("kind")
|
||||
.and_then(Value::as_str)
|
||||
.unwrap_or_default();
|
||||
let level = match event
|
||||
.pointer("/payload/level")
|
||||
.and_then(Value::as_str)
|
||||
.unwrap_or_default()
|
||||
{
|
||||
"error" => LogLevel::Error,
|
||||
"warn" | "warning" => LogLevel::Warn,
|
||||
"debug" | "trace" => LogLevel::Debug,
|
||||
_ => {
|
||||
if kind == "stderr" {
|
||||
LogLevel::Warn
|
||||
} else {
|
||||
LogLevel::Info
|
||||
}
|
||||
}
|
||||
};
|
||||
Some(LogLine {
|
||||
text: text.to_string(),
|
||||
level,
|
||||
})
|
||||
}
|
||||
|
||||
/// 整个事件流 → 日志行（解析失败的行跳过，容忍被 kill 时截断的尾行）。
|
||||
pub fn read_lines(path: &Path) -> Vec<LogLine> {
|
||||
let Ok(text) = std::fs::read_to_string(path) else {
|
||||
return Vec::new();
|
||||
};
|
||||
text.lines()
|
||||
.filter(|line| !line.trim().is_empty())
|
||||
.filter_map(|line| serde_json::from_str::<Value>(line).ok())
|
||||
.filter_map(|event| line_of(&event))
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// 打开一个会话：日志行 + 规则引擎结论。
|
||||
pub fn open(env: &HostEnv, key: &str) -> (Vec<LogLine>, Option<DiagnosisReport>) {
|
||||
let Some(entry) = find(env, key) else {
|
||||
return (Vec::new(), None);
|
||||
};
|
||||
let path = event_path(env, &entry);
|
||||
let lines = read_lines(&path);
|
||||
let diagnosis = diagnose_lines(&entry, &lines);
|
||||
(lines, diagnosis)
|
||||
}
|
||||
|
||||
/// 规则引擎跑一遍（**规则先跑，模型补位**：这里只出规则结论）。
|
||||
pub fn diagnose_lines(entry: &SessionIndexEntry, lines: &[LogLine]) -> Option<DiagnosisReport> {
|
||||
let stderr_text: String = lines
|
||||
.iter()
|
||||
.filter(|line| line.level == LogLevel::Error || line.level == LogLevel::Warn)
|
||||
.map(|line| line.text.as_str())
|
||||
.collect::<Vec<_>>()
|
||||
.join("\n");
|
||||
let body: String = lines
|
||||
.iter()
|
||||
.rev()
|
||||
.take(DEFAULT_TAIL)
|
||||
.map(|line| line.text.as_str())
|
||||
.collect::<Vec<_>>()
|
||||
.into_iter()
|
||||
.rev()
|
||||
.collect::<Vec<_>>()
|
||||
.join("\n");
|
||||
if body.is_empty() {
|
||||
return None;
|
||||
}
|
||||
let error_lines = u32::try_from(
|
||||
lines
|
||||
.iter()
|
||||
.filter(|line| line.level == LogLevel::Error)
|
||||
.count(),
|
||||
)
|
||||
.unwrap_or(u32::MAX);
|
||||
let exit = ExitSignal::classify(
|
||||
entry.exit_code,
|
||||
Some(entry.duration_ms),
|
||||
error_lines,
|
||||
&stderr_text,
|
||||
);
|
||||
let mut input = DiagnosisInput::new().with_exit(exit);
|
||||
input.push_text(SignalOrigin::Stderr, body);
|
||||
let loader = RuleLoader::embedded();
|
||||
let report = Diagnoser::new(loader.rule_set().rules().to_vec()).analyze(&input);
|
||||
let finding = report
|
||||
.findings
|
||||
.first()
|
||||
.or_else(|| report.secondary.first())?;
|
||||
Some(DiagnosisReport {
|
||||
session: entry.session_id.clone(),
|
||||
diagnosis: Diagnosis {
|
||||
rule: finding.rule_id.clone(),
|
||||
title: finding.message.clone(),
|
||||
confidence: confidence_percent(finding.confidence),
|
||||
hint: finding.detail.clone().unwrap_or_else(|| {
|
||||
report
|
||||
.exit
|
||||
.as_ref()
|
||||
.map(|exit| exit.exit_type.as_str().to_string())
|
||||
.unwrap_or_else(|| "未知退出".to_string())
|
||||
}),
|
||||
fix: finding
|
||||
.materialized_actions()
|
||||
.first()
|
||||
.map(|action| action.tool.to_string()),
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
/// 0.0~1.0 → 0~100（四舍五入）。
|
||||
pub fn confidence_percent(confidence: f32) -> u8 {
|
||||
let percent = (confidence.clamp(0.0, 1.0) * 100.0).round();
|
||||
u8::try_from(percent as u32).unwrap_or(100)
|
||||
}
|
||||
|
||||
/// 导入崩溃日志（`hs_err_pid*.log` / `crash-*.txt` / `latest.log`）做规则分析。
|
||||
///
|
||||
/// 文件名含 `hs_err` 时先走 `hs_err::parse`（结构化字段进规则引擎），否则整份文本当信号喂进去。
|
||||
pub fn analyze_crash_file(path: &str) -> Result<(String, DiagnosisReport), String> {
|
||||
let path = Path::new(path);
|
||||
if !path.is_file() {
|
||||
return Err(format!("找不到崩溃日志：{}", path.display()));
|
||||
}
|
||||
let text = std::fs::read_to_string(path).map_err(|error| format!("读崩溃日志失败：{error}"))?;
|
||||
let name = path
|
||||
.file_name()
|
||||
.map(|name| name.to_string_lossy().to_string())
|
||||
.unwrap_or_else(|| "crash.log".to_string());
|
||||
let is_hs_err = name.contains("hs_err");
|
||||
let mut input = DiagnosisInput::new();
|
||||
if is_hs_err {
|
||||
input.push_hs_err(unlucky_core::diagnose::hs_err::parse(&text));
|
||||
}
|
||||
input.push_text(
|
||||
if is_hs_err {
|
||||
SignalOrigin::HsErr
|
||||
} else if name.contains("crash") {
|
||||
SignalOrigin::CrashReport
|
||||
} else {
|
||||
SignalOrigin::LatestLog
|
||||
},
|
||||
text,
|
||||
);
|
||||
let loader = RuleLoader::embedded();
|
||||
let report = Diagnoser::new(loader.rule_set().rules().to_vec()).analyze(&input);
|
||||
let finding = report
|
||||
.findings
|
||||
.first()
|
||||
.or_else(|| report.secondary.first())
|
||||
.ok_or_else(|| "规则引擎没有从这份日志里认出已知问题".to_string())?;
|
||||
Ok((
|
||||
format!("导入的日志：{name}"),
|
||||
DiagnosisReport {
|
||||
session: format!("file:{name}"),
|
||||
diagnosis: Diagnosis {
|
||||
rule: finding.rule_id.clone(),
|
||||
title: finding.message.clone(),
|
||||
confidence: confidence_percent(finding.confidence),
|
||||
hint: finding
|
||||
.detail
|
||||
.clone()
|
||||
.unwrap_or_else(|| "规则引擎命中（详见证据行）".to_string()),
|
||||
fix: finding
|
||||
.materialized_actions()
|
||||
.first()
|
||||
.map(|action| action.tool.to_string()),
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
|
||||
/// 实时尾随器：只读文件新增的字节，解析出完整的 JSON 行。
|
||||
#[derive(Debug, Default)]
|
||||
pub struct Tail {
|
||||
path: Option<PathBuf>,
|
||||
session: Option<SessionId>,
|
||||
offset: u64,
|
||||
}
|
||||
|
||||
impl Tail {
|
||||
/// 开始尾随一个会话。
|
||||
pub fn attach(&mut self, path: PathBuf, session: &str) {
|
||||
self.path = Some(path);
|
||||
self.session = Some(session.to_string());
|
||||
self.offset = 0;
|
||||
}
|
||||
|
||||
/// 停止尾随。
|
||||
pub fn detach(&mut self) {
|
||||
self.path = None;
|
||||
self.session = None;
|
||||
self.offset = 0;
|
||||
}
|
||||
|
||||
/// 当前尾随的会话。
|
||||
pub fn session(&self) -> Option<&str> {
|
||||
self.session.as_deref()
|
||||
}
|
||||
|
||||
/// 读新行（返回 `(会话 id, 新行)`；没有新内容返回 `None`）。
|
||||
pub fn poll(&mut self) -> Option<(String, Vec<LogLine>)> {
|
||||
let path = self.path.clone()?;
|
||||
let session = self.session.clone()?;
|
||||
let file = std::fs::File::open(&path).ok()?;
|
||||
let len = file.metadata().ok()?.len();
|
||||
if len <= self.offset {
|
||||
return None;
|
||||
}
|
||||
let mut file = file;
|
||||
file.seek(SeekFrom::Start(self.offset)).ok()?;
|
||||
let mut buffer = String::new();
|
||||
file.read_to_string(&mut buffer).ok()?;
|
||||
// 只吃到最后一个换行：半行留到下一拍（避免把 JSON 截断解析成脏行）
|
||||
let last_newline = buffer.rfind('\n')?;
|
||||
let complete = &buffer[..=last_newline];
|
||||
self.offset += u64::try_from(complete.len()).unwrap_or(u64::MAX);
|
||||
let lines: Vec<LogLine> = complete
|
||||
.lines()
|
||||
.filter(|line| !line.trim().is_empty())
|
||||
.filter_map(|line| serde_json::from_str::<Value>(line).ok())
|
||||
.filter_map(|event| line_of(&event))
|
||||
.collect();
|
||||
Some((session, lines))
|
||||
}
|
||||
}
|
||||
|
||||
/// 会话是否已收尾（索引里出现 `ended_at` 或文件停止增长超过一拍）。
|
||||
pub fn session_finished(env: &HostEnv, session: &str) -> bool {
|
||||
let index = session_index::index_path(&root(env));
|
||||
session_index::read_all(&index)
|
||||
.unwrap_or_default()
|
||||
.iter()
|
||||
.any(|entry| entry.session_id == session && !entry.ended_at.is_empty())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
#[path = "logs_tests.rs"]
|
||||
mod tests;
|
||||
@@ -0,0 +1,86 @@
|
||||
//! host/logs.rs 的单测（拆文件守 400 行上限）。
|
||||
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn time_display_and_outcomes() {
|
||||
assert_eq!(display_time("2026-10-29T19:22:45.123Z"), "10-29 19:22");
|
||||
assert_eq!(display_time("nope"), "nope");
|
||||
let mut entry = SessionIndexEntry {
|
||||
v: 1,
|
||||
session_id: "s".to_string(),
|
||||
instance_id: String::new(),
|
||||
instance_name: String::new(),
|
||||
game_version: String::new(),
|
||||
started_at: String::new(),
|
||||
ended_at: "2026-10-29T19:22:45Z".to_string(),
|
||||
duration_ms: 1000,
|
||||
exit_code: Some(0),
|
||||
exit_type: Some("normal".to_string()),
|
||||
silent_failure: false,
|
||||
window_detected: true,
|
||||
event_count: 1,
|
||||
log_path: "s.jsonl".to_string(),
|
||||
crash_found: false,
|
||||
diagnosis_top: None,
|
||||
};
|
||||
assert_eq!(outcome_of(&entry), LogOutcome::Ok);
|
||||
entry.exit_code = Some(1);
|
||||
assert_eq!(outcome_of(&entry), LogOutcome::Crashed);
|
||||
entry.silent_failure = true;
|
||||
assert_eq!(outcome_of(&entry), LogOutcome::SilentFail);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn lines_map_levels_and_skip_non_line_events() {
|
||||
let stdout = serde_json::json!({"kind":"stdout","payload":{"line":"hi","level":"info"}});
|
||||
assert_eq!(line_of(&stdout).unwrap().level, LogLevel::Info);
|
||||
let stderr = serde_json::json!({"kind":"stderr","payload":{"line":"boom","level":"error"}});
|
||||
assert_eq!(line_of(&stderr).unwrap().level, LogLevel::Error);
|
||||
let other = serde_json::json!({"kind":"cmd_built","payload":{"argv":[]}});
|
||||
assert!(line_of(&other).is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tail_only_consumes_complete_lines() {
|
||||
let dir = std::env::temp_dir().join(format!("ull-host-tail-{}", std::process::id()));
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
std::fs::create_dir_all(&dir).expect("目录");
|
||||
let path = dir.join("s.jsonl");
|
||||
std::fs::write(
|
||||
&path,
|
||||
"{\"kind\":\"stdout\",\"payload\":{\"line\":\"one\"}}\n",
|
||||
)
|
||||
.expect("写");
|
||||
let mut tail = Tail::default();
|
||||
tail.attach(path.clone(), "s");
|
||||
let (session, lines) = tail.poll().expect("首拍有新行");
|
||||
assert_eq!(session, "s");
|
||||
assert_eq!(lines.len(), 1);
|
||||
assert!(tail.poll().is_none(), "没有新增就不该再产出");
|
||||
|
||||
// 半行不消费
|
||||
let mut text = std::fs::read_to_string(&path).expect("读");
|
||||
text.push_str("{\"kind\":\"stdout\",\"payload\":{\"line\":\"tw");
|
||||
std::fs::write(&path, text).expect("写");
|
||||
assert!(tail.poll().is_none(), "半个 JSON 行不能解析");
|
||||
let mut text = std::fs::read_to_string(&path).expect("读");
|
||||
text.push_str("o\"}}\n");
|
||||
std::fs::write(&path, text).expect("写");
|
||||
let (_, lines) = tail.poll().expect("补全后应产出");
|
||||
assert_eq!(lines[0].text, "two");
|
||||
std::fs::remove_dir_all(&dir).ok();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn crash_import_reports_missing_file() {
|
||||
let err = analyze_crash_file("D:/definitely/missing/hs_err_pid1.log").unwrap_err();
|
||||
assert!(err.contains("找不到崩溃日志"), "{err}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn confidence_percent_is_rounded_and_clamped() {
|
||||
assert_eq!(confidence_percent(0.923), 92);
|
||||
assert_eq!(confidence_percent(-1.0), 0);
|
||||
assert_eq!(confidence_percent(2.0), 100);
|
||||
}
|
||||
@@ -0,0 +1,80 @@
|
||||
//! 安装进度的记账器（文件计数 / 字节 / 速度 / ETA）。
|
||||
//!
|
||||
//! `execute` 的文件级回调已经把每个文件的结局给了我们，这里只做聚合；
|
||||
//! 速度用相邻两次采样的字节差算（core 的事件只给绝对值）。
|
||||
|
||||
use std::sync::Arc;
|
||||
use std::time::Instant;
|
||||
|
||||
use unlucky_core::game::install::{FileOutcome, FileStatus, ProgressSink};
|
||||
|
||||
use crate::dto::{derive_speed, CreateRequest, InstallProgressView, InstallStage};
|
||||
|
||||
use super::install::loader_label;
|
||||
use super::job::{HostTask, JobSender};
|
||||
/// 一次安装的上下文（进度回调共享）。
|
||||
pub(super) struct Meter {
|
||||
pub(super) progress: InstallProgressView,
|
||||
previous: Option<(u64, Instant)>,
|
||||
}
|
||||
|
||||
impl Meter {
|
||||
pub(super) fn new(request: &CreateRequest) -> Self {
|
||||
Self {
|
||||
progress: InstallProgressView::start(
|
||||
&request.version,
|
||||
&request.instance_name(),
|
||||
&loader_label(request.loader, &request.loader_version),
|
||||
),
|
||||
previous: None,
|
||||
}
|
||||
}
|
||||
|
||||
/// 换阶段（重置速度采样）。
|
||||
pub(super) fn stage(&mut self, stage: InstallStage, message: &str) {
|
||||
self.progress.stage = stage;
|
||||
self.progress.message = message.to_string();
|
||||
self.previous = None;
|
||||
}
|
||||
|
||||
/// 预记账一段待下载的文件（文件数 + 字节）。
|
||||
///
|
||||
/// 一次安装可能分几段（原版 / 处理器依赖库 / 加载器库）：每段开工前都先记账，
|
||||
/// 整条进度曲线才是单调的——某一段下完不会先到 100%，再因为下一段的文件被计入而回落。
|
||||
pub(super) fn expect(&mut self, files: usize, bytes: u64) {
|
||||
let files = u64::try_from(files).unwrap_or(u64::MAX);
|
||||
self.progress.files_total = self.progress.files_total.saturating_add(files);
|
||||
self.progress.bytes_total = self.progress.bytes_total.saturating_add(bytes);
|
||||
}
|
||||
|
||||
/// 记账一个文件的结局。
|
||||
pub(super) fn note(&mut self, outcome: &FileOutcome) {
|
||||
self.progress.files_done += 1;
|
||||
if outcome.status != FileStatus::Skipped {
|
||||
self.progress.bytes_done = self.progress.bytes_done.saturating_add(outcome.bytes);
|
||||
}
|
||||
let now = Instant::now();
|
||||
if let Some(previous) = self.previous {
|
||||
if let Some((speed, eta)) = derive_speed(
|
||||
previous,
|
||||
(self.progress.bytes_done, now),
|
||||
self.progress.bytes_total,
|
||||
) {
|
||||
self.progress.speed_bps = speed;
|
||||
self.progress.eta_secs = eta;
|
||||
}
|
||||
}
|
||||
self.previous = Some((self.progress.bytes_done, now));
|
||||
}
|
||||
}
|
||||
|
||||
/// 进度 sink（`execute` 的文件级回调）。
|
||||
pub(super) fn sink_for(tx: JobSender, meter: Arc<std::sync::Mutex<Meter>>) -> ProgressSink {
|
||||
Arc::new(move |outcome: &FileOutcome| {
|
||||
let Ok(mut meter) = meter.lock() else {
|
||||
return;
|
||||
};
|
||||
meter.note(outcome);
|
||||
let _ = tx.send(HostTask::Install(Box::new(meter.progress.clone())));
|
||||
})
|
||||
}
|
||||
@@ -0,0 +1,344 @@
|
||||
//! 真实后端：把 core（game/launch/install/auth/java/diagnose/setting）装配成 GUI 的 host。
|
||||
//!
|
||||
//! 边界：本模块是**整个 presenter crate 里唯一**允许 `use unlucky_core::…` 的地方（连同
|
||||
//! `settings_bridge`）；出口只有 [`crate::dto`] 的快照/事件。线程模型：
|
||||
//!
|
||||
//! ```text
|
||||
//! dispatch(AppCommand) ──► 立即动作（读盘/写设置）或 spawn 后台线程
|
||||
//! 后台线程 ──HostTask──► rx ──tick()──► CoreEvent ──► state.apply()
|
||||
//! tick() 另外每 ~600ms 尾随一次运行中会话的 JSONL（实时日志滚动）
|
||||
//! ```
|
||||
//!
|
||||
//! AI 对话暂时仍由 [`MockBackend`] 提供脚本回复（agent 的 GUI host 是后续 mission）；
|
||||
//! 其余页面全部走真实 core。
|
||||
|
||||
mod accounts;
|
||||
mod dispatch;
|
||||
mod engine;
|
||||
pub mod env;
|
||||
mod game;
|
||||
mod handle;
|
||||
mod identity;
|
||||
mod install;
|
||||
mod install_journal;
|
||||
mod install_processors;
|
||||
mod java;
|
||||
mod job;
|
||||
mod launch;
|
||||
mod logs;
|
||||
mod meter;
|
||||
mod opener;
|
||||
mod settings;
|
||||
mod versions;
|
||||
|
||||
use std::collections::{BTreeMap, BTreeSet, VecDeque};
|
||||
use std::time::Duration;
|
||||
|
||||
use crate::dto::{
|
||||
AccountView, AppCommand, AppEvent, Backend, CoreEvent, DiagnosisReport, InstallProgressView,
|
||||
InstanceRuntime, JavaChainStep, NoticeView,
|
||||
};
|
||||
use crate::mock::MockBackend;
|
||||
use crate::toast::{Toast, ToastKind};
|
||||
|
||||
use accounts::LoginJob;
|
||||
pub use env::HostEnv;
|
||||
use job::{HostTask, JobReceiver, JobSender};
|
||||
|
||||
/// 每拍最多处理的后台消息数（防止一次 tick 吃掉整帧预算）。
|
||||
const MAX_TASKS_PER_TICK: usize = 64;
|
||||
|
||||
/// 实时日志尾随间隔（拍数，33ms/拍 → 约 600ms 一次）。
|
||||
const TAIL_POLL_TICKS: u64 = 18;
|
||||
|
||||
/// 一次在跑的启动（并发启动时按实例 id 区分，停止/尾随都不会串到别的实例）。
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
struct LiveLaunch {
|
||||
instance: String,
|
||||
session: String,
|
||||
pid: u32,
|
||||
}
|
||||
|
||||
/// 真实 host。
|
||||
pub struct CoreHost {
|
||||
env: HostEnv,
|
||||
events: VecDeque<AppEvent>,
|
||||
tx: JobSender,
|
||||
rx: JobReceiver,
|
||||
ticks: u64,
|
||||
/// 当前启动账户 id（内存态；跨会话持久化要 core schema 增键，见 handoff）
|
||||
active_account: Option<String>,
|
||||
accounts: Vec<AccountView>,
|
||||
login: Option<LoginJob>,
|
||||
java_chain: Vec<JavaChainStep>,
|
||||
java_busy: bool,
|
||||
java_message: String,
|
||||
install: Option<InstallProgressView>,
|
||||
notices: Vec<NoticeView>,
|
||||
/// 在跑的启动（实例 → 会话 → pid；支持多个实例同时启动，停止按 id 找正确的 pid）
|
||||
launches: Vec<LiveLaunch>,
|
||||
/// 已受理但后台线程还没回报 `LaunchStarted` 的实例（防「启动中重复点启动」起第二个进程）
|
||||
pending: BTreeSet<String>,
|
||||
/// 上次启动失败的实例与原因（刷新快照时保住磁贴的「失败/重试」外观）
|
||||
failed: BTreeMap<String, String>,
|
||||
/// 实时日志尾随器
|
||||
tail: logs::Tail,
|
||||
/// AI 对话的临时后端（agent GUI host 落地前的占位）
|
||||
chat: MockBackend,
|
||||
/// 当前安装任务的取消标记（阶段边界检查）
|
||||
install_cancel: Option<std::sync::Arc<std::sync::atomic::AtomicBool>>,
|
||||
}
|
||||
|
||||
impl CoreHost {
|
||||
/// 按便携数据根装配；解析不出数据根返回 `None`（调用方退回 mock）。
|
||||
pub fn open() -> Option<Self> {
|
||||
HostEnv::resolve().map(Self::new)
|
||||
}
|
||||
|
||||
/// 用给定环境装配（截图/单测通道）。
|
||||
pub fn new(env: HostEnv) -> Self {
|
||||
Self::build(env, true)
|
||||
}
|
||||
|
||||
/// 单测用：不跑 `refresh_all`（不起版本清单网络线程），其余装配一致。
|
||||
#[cfg(test)]
|
||||
pub(crate) fn headless(env: HostEnv) -> Self {
|
||||
Self::build(env, false)
|
||||
}
|
||||
|
||||
fn build(env: HostEnv, refresh: bool) -> Self {
|
||||
let (tx, rx) = job::channel();
|
||||
game::ensure_root(&env);
|
||||
let mut host = Self {
|
||||
env,
|
||||
events: VecDeque::new(),
|
||||
tx,
|
||||
rx,
|
||||
ticks: 0,
|
||||
active_account: None,
|
||||
accounts: Vec::new(),
|
||||
login: None,
|
||||
java_chain: Vec::new(),
|
||||
java_busy: false,
|
||||
java_message: String::new(),
|
||||
install: None,
|
||||
notices: Vec::new(),
|
||||
launches: Vec::new(),
|
||||
pending: BTreeSet::new(),
|
||||
failed: BTreeMap::new(),
|
||||
tail: logs::Tail::default(),
|
||||
chat: MockBackend::default(),
|
||||
install_cancel: None,
|
||||
};
|
||||
if refresh {
|
||||
host.refresh_all();
|
||||
}
|
||||
host
|
||||
}
|
||||
|
||||
/// 数据根（截图/诊断展示用）。
|
||||
pub fn env(&self) -> &HostEnv {
|
||||
&self.env
|
||||
}
|
||||
|
||||
fn send(&mut self, event: CoreEvent) {
|
||||
self.events.push_back(AppEvent::Core(event));
|
||||
}
|
||||
|
||||
fn toast(&mut self, kind: ToastKind, text: impl Into<String>) {
|
||||
self.events.push_back(AppEvent::Toast(Toast {
|
||||
id: 0,
|
||||
kind,
|
||||
text: text.into(),
|
||||
remaining_ms: 0,
|
||||
}));
|
||||
}
|
||||
|
||||
/// 全量刷新：实例 / 会话 / 账户 / 设置 / Java，并触发一次版本清单拉取。
|
||||
pub fn refresh_all(&mut self) {
|
||||
self.refresh_instances();
|
||||
self.send(CoreEvent::LogSessionsChanged(logs::sessions(&self.env)));
|
||||
self.refresh_accounts();
|
||||
self.send(CoreEvent::SettingsChanged(settings::groups(&self.env)));
|
||||
self.refresh_java();
|
||||
versions::spawn_list(self.env.clone(), self.tx.clone());
|
||||
}
|
||||
|
||||
/// 重建实例快照，并把**真实运行时**盖回去。
|
||||
///
|
||||
/// `game::instances` 只读盘（每条都是 `Idle`），所以在跑的实例必须在重建后按
|
||||
/// host 自己的启动表覆写 `Running{pid}`/`Busy`，否则任意一次刷新（装版本成功、
|
||||
/// 加删账户、另一实例收尾）都会把磁贴打回 Idle：停止键与「运行中」条消失，
|
||||
/// 进程还在跑却再也停不下来。
|
||||
fn refresh_instances(&mut self) {
|
||||
let mut instances = game::instances(&self.env);
|
||||
for instance in &mut instances {
|
||||
if let Some(live) = self
|
||||
.launches
|
||||
.iter()
|
||||
.find(|live| live.instance == instance.id)
|
||||
{
|
||||
instance.runtime = InstanceRuntime::Running { pid: live.pid };
|
||||
} else if self.pending.contains(&instance.id) {
|
||||
instance.runtime = InstanceRuntime::Busy {
|
||||
stage: crate::dto::LaunchStage::Launch,
|
||||
progress: crate::dto::Progress { done: 0, total: 1 },
|
||||
};
|
||||
} else if let Some(reason) = self.failed.get(&instance.id) {
|
||||
instance.runtime = InstanceRuntime::Failed {
|
||||
reason: reason.clone(),
|
||||
};
|
||||
}
|
||||
}
|
||||
self.send(CoreEvent::InstancesChanged(instances));
|
||||
}
|
||||
|
||||
fn refresh_accounts(&mut self) {
|
||||
self.accounts = accounts::accounts(&self.env, self.active_account.as_deref());
|
||||
if self.active_account.is_none() {
|
||||
// 默认选中第一个账户（没有账户时保持 None = 离线占位）
|
||||
self.active_account = self.accounts.first().map(|account| account.id.clone());
|
||||
self.accounts = accounts::accounts(&self.env, self.active_account.as_deref());
|
||||
}
|
||||
self.send(CoreEvent::AccountsChanged(self.accounts.clone()));
|
||||
}
|
||||
|
||||
fn refresh_java(&mut self) {
|
||||
let page = java::page(
|
||||
&self.env,
|
||||
self.java_chain.clone(),
|
||||
self.java_busy,
|
||||
&self.java_message,
|
||||
);
|
||||
self.send(CoreEvent::JavaChanged(page));
|
||||
}
|
||||
|
||||
fn push_notice(&mut self, notice: NoticeView) {
|
||||
self.notices.retain(|existing| existing.id != notice.id);
|
||||
self.notices.push(notice);
|
||||
self.send(CoreEvent::NoticesChanged(self.notices.clone()));
|
||||
}
|
||||
|
||||
/// 打开一个会话（日志行 + 诊断）。
|
||||
fn open_session(&mut self, id: &str) {
|
||||
let (lines, diagnosis) = logs::open(&self.env, id);
|
||||
self.send(CoreEvent::LogLinesChanged(lines));
|
||||
self.send(CoreEvent::DiagnosisReady(diagnosis.unwrap_or(
|
||||
DiagnosisReport {
|
||||
session: id.to_string(),
|
||||
diagnosis: crate::dto::Diagnosis {
|
||||
rule: String::new(),
|
||||
title: "该会话没有命中已知规则".to_string(),
|
||||
confidence: 0,
|
||||
hint: "可点「让 AI 详解」把日志交给模型进一步分析".to_string(),
|
||||
fix: None,
|
||||
},
|
||||
},
|
||||
)));
|
||||
}
|
||||
|
||||
/// 由实例名/版本 id 找启动目标。
|
||||
fn launch_target(&self, id: &str) -> Option<launch::LaunchTarget> {
|
||||
let instance = game::instances(&self.env)
|
||||
.into_iter()
|
||||
.find(|instance| instance.id == id || instance.name == id)?;
|
||||
Some(launch::LaunchTarget {
|
||||
id: instance.id,
|
||||
name: instance.name,
|
||||
version_id: instance.version_id,
|
||||
account: self.active_account.clone(),
|
||||
})
|
||||
}
|
||||
|
||||
/// 某实例是否已在启动/运行（`pending` 与 `launches` 的并集）。
|
||||
///
|
||||
/// 只查 `launches` 不够：`launch::start` 到后台线程回报 `LaunchStarted` 之间有窗口，
|
||||
/// 这期间重复点启动会起第二个进程、并把旧 pid 在启动表里顶掉（旧进程变孤儿）。
|
||||
fn in_flight(&self, key: &str) -> bool {
|
||||
self.pending.contains(key) || self.launches.iter().any(|live| live.instance == key)
|
||||
}
|
||||
|
||||
/// 标记「已受理、等后台线程回报」（`launch::start` 之后的窗口）。
|
||||
///
|
||||
/// 单测也走这个入口而不是直接改 `pending`，保证测的是真实状态流转。
|
||||
fn mark_pending(&mut self, id: &str) {
|
||||
self.pending.insert(id.to_string());
|
||||
self.failed.remove(id);
|
||||
}
|
||||
|
||||
fn start_launch(&mut self, id: &str) {
|
||||
if self.in_flight(id) {
|
||||
self.toast(ToastKind::Warn, "这个实例已经在启动/运行中");
|
||||
return;
|
||||
}
|
||||
let Some(target) = self.launch_target(id) else {
|
||||
self.toast(ToastKind::Error, format!("找不到实例 {id}"));
|
||||
return;
|
||||
};
|
||||
let instance_id = target.id.clone();
|
||||
if self.in_flight(&instance_id) {
|
||||
self.toast(ToastKind::Warn, "这个实例已经在启动/运行中");
|
||||
return;
|
||||
}
|
||||
self.mark_pending(&instance_id);
|
||||
if let Some(notice) = game::mode_change_notice(&self.env, &instance_id) {
|
||||
self.push_notice(notice);
|
||||
}
|
||||
self.send(CoreEvent::InstanceRuntimeChanged {
|
||||
id: instance_id.clone(),
|
||||
runtime: InstanceRuntime::Busy {
|
||||
stage: crate::dto::LaunchStage::Launch,
|
||||
progress: crate::dto::Progress { done: 0, total: 1 },
|
||||
},
|
||||
});
|
||||
launch::start(self.env.clone(), self.tx.clone(), target);
|
||||
}
|
||||
|
||||
/// 某实例在跑的 pid（按实例 id 查启动表；不再有「最近一次启动」这种单槽）。
|
||||
///
|
||||
/// 兜底分支读实例快照的 `Running { pid }`：host 自己发的运行时事件会写回快照，
|
||||
/// 但快照是重建的（`game::instances` 每次 Idle），所以这层只是给将来留的口。
|
||||
fn running_pid(&self, id: &str) -> Option<u32> {
|
||||
if let Some(live) = self.launches.iter().find(|live| live.instance == id) {
|
||||
return Some(live.pid);
|
||||
}
|
||||
game::instances(&self.env)
|
||||
.into_iter()
|
||||
.find(|instance| instance.id == id)
|
||||
.and_then(|instance| match instance.runtime {
|
||||
InstanceRuntime::Running { pid } => Some(pid),
|
||||
_ => None,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl Backend for CoreHost {
|
||||
fn drain_events(&mut self) -> Vec<AppEvent> {
|
||||
self.events.drain(..).collect()
|
||||
}
|
||||
|
||||
fn dispatch(&mut self, command: AppCommand) {
|
||||
self.dispatch_command(command);
|
||||
}
|
||||
|
||||
fn tick(&mut self, elapsed: Duration) {
|
||||
self.chat.tick(elapsed);
|
||||
for event in self.chat.drain_events() {
|
||||
self.events.push_back(event);
|
||||
}
|
||||
for _ in 0..MAX_TASKS_PER_TICK {
|
||||
let Ok(task) = self.rx.try_recv() else {
|
||||
break;
|
||||
};
|
||||
self.handle(task);
|
||||
}
|
||||
self.ticks += 1;
|
||||
if self.ticks.is_multiple_of(TAIL_POLL_TICKS) {
|
||||
self.poll_tail();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
#[path = "launch_state_tests.rs"]
|
||||
mod launch_state_tests;
|
||||
@@ -0,0 +1,72 @@
|
||||
//! 用系统默认浏览器打开授权 URL（授权码流唯一需要宿主做的事）。
|
||||
//!
|
||||
//! core 只负责拼授权 URL 与等本地回调（`core::auth::microsoft::authcode`）；
|
||||
//! 「谁来打开浏览器」是宿主的决定：GUI 走这里，CLI/无浏览器场景仍用设备码流。
|
||||
//!
|
||||
//! 平台差异收在 [`launcher`] 一处，不往业务代码里散写 `cfg` 补丁（`AGENTS.md` §7）。
|
||||
|
||||
use std::process::Command;
|
||||
|
||||
/// 拉起系统默认浏览器打开 `url`（只接受 http/https）。
|
||||
///
|
||||
/// 不等待浏览器退出：用户可能在浏览器里停留几分钟，宿主只关心「有没有拉起来」。
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// URL 不是 http/https，或进程拉不起来时返回用户可读文案。
|
||||
pub fn open_url(url: &str) -> Result<(), String> {
|
||||
if !url.starts_with("https://") && !url.starts_with("http://") {
|
||||
return Err(format!("不是可打开的网址：{url}"));
|
||||
}
|
||||
let (program, args) = launcher(url);
|
||||
Command::new(program)
|
||||
.args(args)
|
||||
.spawn()
|
||||
.map(|_child| ())
|
||||
.map_err(|error| format!("拉起浏览器失败（{program}）：{error}"))
|
||||
}
|
||||
|
||||
#[cfg(target_os = "windows")]
|
||||
fn launcher(url: &str) -> (&'static str, Vec<String>) {
|
||||
// `rundll32` 不用 shell，URL 里的 `&` 不会被当成命令分隔符（`cmd /C start` 会）。
|
||||
(
|
||||
"rundll32",
|
||||
vec!["url.dll,FileProtocolHandler".to_string(), url.to_string()],
|
||||
)
|
||||
}
|
||||
|
||||
#[cfg(target_os = "macos")]
|
||||
fn launcher(url: &str) -> (&'static str, Vec<String>) {
|
||||
("open", vec![url.to_string()])
|
||||
}
|
||||
|
||||
#[cfg(not(any(target_os = "windows", target_os = "macos")))]
|
||||
fn launcher(url: &str) -> (&'static str, Vec<String>) {
|
||||
("xdg-open", vec![url.to_string()])
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::{launcher, open_url};
|
||||
|
||||
#[test]
|
||||
fn rejects_non_http_urls() {
|
||||
assert!(open_url("javascript:alert(1)").is_err());
|
||||
assert!(open_url("").is_err());
|
||||
// 合法 URL 只验命令形态，不在单测里真去拉浏览器。
|
||||
let (program, args) = launcher("http://localhost:1234/auth?code=a&state=b");
|
||||
assert!(!program.is_empty());
|
||||
assert!(args
|
||||
.iter()
|
||||
.any(|arg| arg.contains("http://localhost:1234/auth")));
|
||||
}
|
||||
|
||||
#[cfg(target_os = "windows")]
|
||||
#[test]
|
||||
fn windows_uses_the_file_protocol_handler() {
|
||||
let (program, args) = launcher("https://example.invalid/");
|
||||
assert_eq!(program, "rundll32");
|
||||
assert_eq!(args[0], "url.dll,FileProtocolHandler");
|
||||
assert_eq!(args[1], "https://example.invalid/");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,398 @@
|
||||
//! 设置页分组：按 `core::setting` schema 的键生成行，写回走 `SettingStore::set`。
|
||||
//!
|
||||
//! 三件纪律（AGENTS §6）：
|
||||
//! 1. 读写同一份 `<数据根>/config/launcher.json`（与 `ull config set` / AI `set_config` 同源）；
|
||||
//! 2. 不自己拼 JSON，也不绕 schema（非法键/越界值由 `store.set` 拒绝）；
|
||||
//! 3. 这里只认「键名 + 字符串值」，领域语义留在 core。
|
||||
//!
|
||||
//! 分组 id 与设置页子导航同名：`download` / `java` / `data` / `ai` / `mcp`。
|
||||
|
||||
use serde_json::Value;
|
||||
use unlucky_core::game::java::JdkVendor;
|
||||
|
||||
use crate::dto::{SettingGroupView, SettingRowView};
|
||||
|
||||
use super::env::HostEnv;
|
||||
|
||||
/// 全部设置分组（设置页右栏一次拿全，切分组不再请求）。
|
||||
pub fn groups(env: &HostEnv) -> Vec<SettingGroupView> {
|
||||
vec![
|
||||
download_group(env),
|
||||
java_group(env),
|
||||
data_group(env),
|
||||
ai_group(env),
|
||||
mcp_group(env),
|
||||
]
|
||||
}
|
||||
|
||||
/// 读一个键的字符串值（缺省给空串）。
|
||||
fn text(env: &HostEnv, key: &str) -> String {
|
||||
env.store()
|
||||
.doc()
|
||||
.effective_str(key)
|
||||
.unwrap_or_default()
|
||||
.to_string()
|
||||
}
|
||||
|
||||
/// 读一个键的整数（缺省给 `fallback`）。
|
||||
fn int(env: &HostEnv, key: &str, fallback: i64) -> i64 {
|
||||
env.store()
|
||||
.effective(key)
|
||||
.and_then(Value::as_i64)
|
||||
.unwrap_or(fallback)
|
||||
}
|
||||
|
||||
/// 读一个键的布尔（缺省给 `fallback`）。
|
||||
fn flag(env: &HostEnv, key: &str, fallback: bool) -> bool {
|
||||
env.store()
|
||||
.effective(key)
|
||||
.and_then(Value::as_bool)
|
||||
.unwrap_or(fallback)
|
||||
}
|
||||
|
||||
/// 枚举值在选项表里的序号（找不到给 0）。
|
||||
fn selected(options: &[&str], value: &str) -> i32 {
|
||||
options
|
||||
.iter()
|
||||
.position(|option| *option == value)
|
||||
.map(|index| i32::try_from(index).unwrap_or(0))
|
||||
.unwrap_or(0)
|
||||
}
|
||||
|
||||
/// 下载（D7）：并发/重试/地区/镜像偏好/代理。
|
||||
fn download_group(env: &HostEnv) -> SettingGroupView {
|
||||
let concurrency = int(env, "download.concurrency", 8).to_string();
|
||||
let retry = int(env, "download.retry_limit", 3).to_string();
|
||||
let concurrency_options = ["4", "8", "16"];
|
||||
let retry_options = ["0", "1", "3", "5"];
|
||||
let regions = ["auto", "cn", "global"];
|
||||
let mirrors = ["auto", "official", "mirror"];
|
||||
let proxies = ["none", "system", "manual"];
|
||||
let region_value = text(env, "download.region");
|
||||
let mirror_value = text(env, "download.mirror_preference");
|
||||
let proxy_value = text(env, "download.proxy_mode");
|
||||
SettingGroupView::new("download", "下载与镜像（D7）")
|
||||
.with(SettingRowView::choice(
|
||||
"download.concurrency",
|
||||
"并发数",
|
||||
"同时下载的文件数（海量小文件，16 路足够压满带宽）",
|
||||
&concurrency_options,
|
||||
selected(&concurrency_options, &concurrency),
|
||||
))
|
||||
.with(SettingRowView::choice(
|
||||
"download.retry_limit",
|
||||
"单文件重试次数",
|
||||
"失败后换源重试的上限",
|
||||
&retry_options,
|
||||
selected(&retry_options, &retry),
|
||||
))
|
||||
.with(SettingRowView::choice(
|
||||
"download.region",
|
||||
"地区判定",
|
||||
"auto = 时区+语言+探测；决定是否优先国内镜像",
|
||||
®ions,
|
||||
selected(
|
||||
®ions,
|
||||
if region_value.is_empty() {
|
||||
"auto"
|
||||
} else {
|
||||
®ion_value
|
||||
},
|
||||
),
|
||||
))
|
||||
.with(SettingRowView::choice(
|
||||
"download.mirror_preference",
|
||||
"镜像偏好",
|
||||
"auto = 按健康度评分；official = 官方源优先",
|
||||
&mirrors,
|
||||
selected(
|
||||
&mirrors,
|
||||
if mirror_value.is_empty() {
|
||||
"auto"
|
||||
} else {
|
||||
&mirror_value
|
||||
},
|
||||
),
|
||||
))
|
||||
.with(SettingRowView::choice(
|
||||
"download.proxy_mode",
|
||||
"代理模式",
|
||||
"none / system（跟随系统）/ manual（下面填地址）",
|
||||
&proxies,
|
||||
selected(
|
||||
&proxies,
|
||||
if proxy_value.is_empty() {
|
||||
"none"
|
||||
} else {
|
||||
&proxy_value
|
||||
},
|
||||
),
|
||||
))
|
||||
.with(SettingRowView::text(
|
||||
"download.proxy_url",
|
||||
"HTTP 代理",
|
||||
"manual 模式生效；留空则用系统代理",
|
||||
&text(env, "download.proxy_url"),
|
||||
))
|
||||
.with(SettingRowView::action(
|
||||
"download.action.detect_region",
|
||||
"重新检测地区",
|
||||
"清掉 24h 地区缓存，下次下载重新判定",
|
||||
"detect_region",
|
||||
))
|
||||
}
|
||||
|
||||
/// Java（D13/D23）：自动安装/内存/选路/发行版优先级。
|
||||
fn java_group(env: &HostEnv) -> SettingGroupView {
|
||||
let memory = int(env, "java.default_memory_mb", 2048).to_string();
|
||||
let memory_options = ["1024", "2048", "4096", "8192"];
|
||||
let priority: Vec<String> = env
|
||||
.store()
|
||||
.effective("java.vendorPriority")
|
||||
.and_then(Value::as_array)
|
||||
.map(|items| {
|
||||
items
|
||||
.iter()
|
||||
.filter_map(Value::as_str)
|
||||
.map(str::to_string)
|
||||
.collect()
|
||||
})
|
||||
.unwrap_or_default();
|
||||
let priority_text = if priority.is_empty() {
|
||||
"地区默认序（Temurin → …）".to_string()
|
||||
} else {
|
||||
priority.join(" → ")
|
||||
};
|
||||
let roots = super::engine::java_scan_roots(env);
|
||||
SettingGroupView::new("java", "Java（D13）")
|
||||
.with(SettingRowView::toggle(
|
||||
"java.auto_install",
|
||||
"缺 Java 时自动下载",
|
||||
"按回退链装一个托管 JDK（基准 JDK17）",
|
||||
flag(env, "java.auto_install", true),
|
||||
))
|
||||
.with(SettingRowView::choice(
|
||||
"java.default_memory_mb",
|
||||
"默认最大堆内存",
|
||||
"实例没单独指定时用这个值（MB）",
|
||||
&memory_options,
|
||||
selected(&memory_options, &memory),
|
||||
))
|
||||
.with(SettingRowView::text(
|
||||
"java.selected_path",
|
||||
"指定 Java 可执行文件",
|
||||
"留空 = 自动挑（托管 > JAVA_HOME > PATH）",
|
||||
&text(env, "java.selected_path"),
|
||||
))
|
||||
.with(SettingRowView::text(
|
||||
"java.installRoot",
|
||||
"托管 JDK 安装根",
|
||||
"留空 = 按数据目录模式派生（portable 进数据根 / standard 进系统目录）",
|
||||
&text(env, "java.installRoot"),
|
||||
))
|
||||
.with(SettingRowView::text(
|
||||
"java.extra_args",
|
||||
"附加 JVM 参数",
|
||||
"原样拼到命令行尾部",
|
||||
&text(env, "java.extra_args"),
|
||||
))
|
||||
.with(SettingRowView::read_only(
|
||||
"发行版优先级（java.vendorPriority）",
|
||||
&priority_text,
|
||||
))
|
||||
.with(SettingRowView::read_only(
|
||||
"托管根",
|
||||
&roots
|
||||
.iter()
|
||||
.map(|root| root.display().to_string())
|
||||
.collect::<Vec<_>>()
|
||||
.join(" · "),
|
||||
))
|
||||
}
|
||||
|
||||
/// 数据目录（D6 三模式）。
|
||||
fn data_group(env: &HostEnv) -> SettingGroupView {
|
||||
let modes = ["portable", "standard", "custom"];
|
||||
let mode = env.mode().as_str().to_string();
|
||||
SettingGroupView::new("data", "数据目录（D6 三模式）")
|
||||
.with(SettingRowView::choice(
|
||||
"core.data_mode",
|
||||
"存储模式",
|
||||
"便携（运行目录）/ 标准（系统应用数据目录）/ 自定义",
|
||||
&modes,
|
||||
selected(&modes, &mode),
|
||||
))
|
||||
.with(SettingRowView::text(
|
||||
"core.data_custom_root",
|
||||
"自定义根目录",
|
||||
"custom 模式生效（绝对路径）",
|
||||
&text(env, "core.data_custom_root"),
|
||||
))
|
||||
.with(SettingRowView::read_only(
|
||||
"启动器数据目录",
|
||||
&env.data.launcher_home.display().to_string(),
|
||||
))
|
||||
.with(SettingRowView::read_only(
|
||||
"游戏目录",
|
||||
&env.data.game_home.display().to_string(),
|
||||
))
|
||||
.with(SettingRowView::read_only(
|
||||
"生效模式",
|
||||
&format!("{}（改数据根需重启启动器）", env.mode()),
|
||||
))
|
||||
}
|
||||
|
||||
/// AI（D4）：开关/端点/模型/YOLO。
|
||||
fn ai_group(env: &HostEnv) -> SettingGroupView {
|
||||
let providers = ["openai_compatible", "anthropic", "ollama"];
|
||||
let provider = text(env, "ai.provider");
|
||||
SettingGroupView::new("ai", "AI 助手（D4）")
|
||||
.with(SettingRowView::toggle(
|
||||
"ai.enabled",
|
||||
"启用 AI 助手",
|
||||
"关闭后规则引擎诊断仍可用",
|
||||
flag(env, "ai.enabled", true),
|
||||
))
|
||||
.with(SettingRowView::choice(
|
||||
"ai.provider",
|
||||
"模型端点",
|
||||
"OpenAI 兼容（含本地 llama.cpp）/ Anthropic / Ollama",
|
||||
&providers,
|
||||
selected(
|
||||
&providers,
|
||||
if provider.is_empty() {
|
||||
"openai_compatible"
|
||||
} else {
|
||||
&provider
|
||||
},
|
||||
),
|
||||
))
|
||||
.with(SettingRowView::text(
|
||||
"ai.base_url",
|
||||
"端点 base_url",
|
||||
"如 http://127.0.0.1:8080/v1",
|
||||
&text(env, "ai.base_url"),
|
||||
))
|
||||
.with(SettingRowView::text(
|
||||
"ai.model",
|
||||
"模型名",
|
||||
"如 deepseek-chat",
|
||||
&text(env, "ai.model"),
|
||||
))
|
||||
.with(SettingRowView::toggle(
|
||||
"ai.yolo",
|
||||
"YOLO 模式",
|
||||
"跳过确认弹窗（审计照记；账户/凭据操作永不 YOLO）",
|
||||
flag(env, "ai.yolo", false),
|
||||
))
|
||||
}
|
||||
|
||||
/// M39 的对外 MCP server（默认关、默认只读）。
|
||||
fn mcp_group(env: &HostEnv) -> SettingGroupView {
|
||||
let port = int(env, "agent.mcp.port", 47_823);
|
||||
SettingGroupView::new("mcp", "MCP server（M39）")
|
||||
.with(SettingRowView::toggle(
|
||||
"agent.mcp.enabled",
|
||||
"对外提供 MCP server",
|
||||
"127.0.0.1 上的 Streamable HTTP（stdio 需显式启动）",
|
||||
flag(env, "agent.mcp.enabled", false),
|
||||
))
|
||||
.with(SettingRowView::text(
|
||||
"agent.mcp.port",
|
||||
"端口",
|
||||
"1024~65535，只绑 127.0.0.1",
|
||||
&port.to_string(),
|
||||
))
|
||||
.with(SettingRowView::toggle(
|
||||
"agent.mcp.allow_write",
|
||||
"允许外部客户端写配置",
|
||||
"默认只读；写仍受 schema 白名单与分级确认约束",
|
||||
flag(env, "agent.mcp.allow_write", false),
|
||||
))
|
||||
.with(SettingRowView::read_only(
|
||||
"客户端地址",
|
||||
&format!("http://127.0.0.1:{port}/mcp（令牌见 agent.mcp.token，AI 不可写）"),
|
||||
))
|
||||
}
|
||||
|
||||
/// 写一条设置。`value` 是字符串形态，按 schema 键的类型转换后交 `store.set`。
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// 未知键、值类型不符、越界、落盘失败时返回用户可读文案。
|
||||
pub fn set(env: &HostEnv, key: &str, value: &str) -> Result<(), String> {
|
||||
if key == "download.action.detect_region" {
|
||||
return detect_region(env);
|
||||
}
|
||||
let parsed = parse_value(key, value)?;
|
||||
let mut store = env.store();
|
||||
store
|
||||
.set(key, parsed)
|
||||
.map_err(|error| format!("设置 {key} 失败：{error}"))?;
|
||||
store
|
||||
.save()
|
||||
.map_err(|error| format!("保存设置失败：{error}"))?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// 键 → 正确类型的 JSON 值（schema 会再校验范围/枚举）。
|
||||
fn parse_value(key: &str, value: &str) -> Result<Value, String> {
|
||||
if matches!(key, "download.concurrency" | "download.retry_limit") {
|
||||
let number: u32 = value
|
||||
.trim()
|
||||
.parse()
|
||||
.map_err(|_| format!("{key} 需要整数：{value}"))?;
|
||||
return Ok(Value::from(number));
|
||||
}
|
||||
if matches!(key, "java.default_memory_mb" | "agent.mcp.port") {
|
||||
let number: u32 = value
|
||||
.trim()
|
||||
.parse()
|
||||
.map_err(|_| format!("{key} 需要整数：{value}"))?;
|
||||
return Ok(Value::from(number));
|
||||
}
|
||||
if matches!(
|
||||
key,
|
||||
"java.auto_install"
|
||||
| "ai.enabled"
|
||||
| "ai.yolo"
|
||||
| "agent.mcp.enabled"
|
||||
| "agent.mcp.allow_write"
|
||||
) {
|
||||
let flag = match value.trim().to_ascii_lowercase().as_str() {
|
||||
"1" | "true" | "on" | "yes" => true,
|
||||
"0" | "false" | "off" | "no" => false,
|
||||
_ => return Err(format!("{key} 需要布尔值：{value}")),
|
||||
};
|
||||
return Ok(Value::Bool(flag));
|
||||
}
|
||||
Ok(Value::String(value.to_string()))
|
||||
}
|
||||
|
||||
/// 清掉 24h 地区缓存（下次建引擎重新判定）。
|
||||
fn detect_region(env: &HostEnv) -> Result<(), String> {
|
||||
let path = env.layout.cache().join("region.json");
|
||||
if path.is_file() {
|
||||
std::fs::remove_file(&path).map_err(|error| format!("清地区缓存失败：{error}"))?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// 设置页「重置发行版优先级」用（清空 enum_list）。
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// 落盘失败时返回用户可读文案。
|
||||
pub fn clear_vendor_priority(env: &HostEnv) -> Result<(), String> {
|
||||
let mut store = env.store();
|
||||
store
|
||||
.set("java.vendorPriority", Value::Array(Vec::new()))
|
||||
.and_then(|()| store.save())
|
||||
.map_err(|error| format!("清空发行版优先级失败：{error}"))?;
|
||||
let _ = JdkVendor::ALL;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
#[path = "settings_tests.rs"]
|
||||
mod tests;
|
||||
@@ -0,0 +1,77 @@
|
||||
//! host/settings.rs 的单测（拆文件守 400 行上限）。
|
||||
|
||||
use super::*;
|
||||
|
||||
fn env_in(dir: &std::path::Path) -> HostEnv {
|
||||
std::fs::create_dir_all(dir.join(".ULL/config")).expect("config");
|
||||
HostEnv::at_root(dir)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn groups_cover_the_six_required_areas() {
|
||||
let dir = std::env::temp_dir().join(format!("ull-host-settings-{}", std::process::id()));
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
let env = env_in(&dir);
|
||||
let groups = groups(&env);
|
||||
let ids: Vec<&str> = groups.iter().map(|group| group.id.as_str()).collect();
|
||||
assert_eq!(ids, vec!["download", "java", "data", "ai", "mcp"]);
|
||||
let keys: Vec<&str> = groups
|
||||
.iter()
|
||||
.flat_map(|group| group.rows.iter())
|
||||
.map(|row| row.key.as_str())
|
||||
.collect();
|
||||
for key in [
|
||||
"download.region",
|
||||
"download.mirror_preference",
|
||||
"java.default_memory_mb",
|
||||
"core.data_mode",
|
||||
"agent.mcp.enabled",
|
||||
"agent.mcp.port",
|
||||
"ai.base_url",
|
||||
] {
|
||||
assert!(keys.contains(&key), "缺少 {key}");
|
||||
}
|
||||
std::fs::remove_dir_all(&dir).ok();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn set_parses_types_and_persists() {
|
||||
let dir = std::env::temp_dir().join(format!("ull-host-settings-w-{}", std::process::id()));
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
let env = env_in(&dir);
|
||||
|
||||
set(&env, "download.concurrency", "16").expect("写并发");
|
||||
set(&env, "agent.mcp.enabled", "true").expect("写开关");
|
||||
set(&env, "agent.mcp.port", "48000").expect("写端口");
|
||||
set(&env, "download.region", "cn").expect("写地区");
|
||||
|
||||
let groups = groups(&env);
|
||||
let row = |key: &str| {
|
||||
groups
|
||||
.iter()
|
||||
.flat_map(|g| g.rows.iter())
|
||||
.find(|r| r.key == key)
|
||||
.cloned()
|
||||
};
|
||||
assert_eq!(row("download.concurrency").unwrap().selected, 2);
|
||||
assert!(row("agent.mcp.enabled").unwrap().flag);
|
||||
assert_eq!(row("agent.mcp.port").unwrap().value_text, "48000");
|
||||
assert_eq!(row("download.region").unwrap().selected, 1);
|
||||
|
||||
assert!(set(&env, "download.concurrency", "abc").is_err());
|
||||
assert!(set(&env, "agent.mcp.enabled", "maybe").is_err());
|
||||
std::fs::remove_dir_all(&dir).ok();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn detect_region_action_removes_cache() {
|
||||
let dir = std::env::temp_dir().join(format!("ull-host-settings-r-{}", std::process::id()));
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
let env = env_in(&dir);
|
||||
let path = env.layout.cache().join("region.json");
|
||||
std::fs::create_dir_all(env.layout.cache()).expect("cache");
|
||||
std::fs::write(&path, "{}").expect("写缓存");
|
||||
set(&env, "download.action.detect_region", "").expect("检测");
|
||||
assert!(!path.exists());
|
||||
std::fs::remove_dir_all(&dir).ok();
|
||||
}
|
||||
@@ -0,0 +1,173 @@
|
||||
//! 版本清单（下载页）：远端 manifest（12h 缓存）+ 内嵌 unlisted 清单 → 分类好的行。
|
||||
//!
|
||||
//! 分类口径抄 analyse/03 §2.4：官方 `type` 决定 release/snapshot/远古；远古再按 id
|
||||
//! 前缀拆 classic（`rd-*`）/ old_alpha（`a*`）/ old_beta（`b*`），其余归 unlisted 汇总。
|
||||
//! 拉取失败但有旧缓存时用旧缓存（离线可用），全无才报错。
|
||||
|
||||
use std::collections::BTreeSet;
|
||||
|
||||
use unlucky_core::download::blocking::block_on;
|
||||
use unlucky_core::download::cache::now_ms;
|
||||
use unlucky_core::game::install::RemoteSource;
|
||||
use unlucky_core::game::unlisted;
|
||||
use unlucky_core::game::version::{ReleaseType, RemoteVersion};
|
||||
|
||||
use crate::dto::{AncientKind, VersionKind, VersionSummary};
|
||||
|
||||
use super::env::HostEnv;
|
||||
use super::job::{spawn, HostTask, JobSender};
|
||||
|
||||
/// 版本 id / 官方类型 → 下载页的四种归类。
|
||||
pub fn kind_of(id: &str, release_type: ReleaseType) -> VersionKind {
|
||||
match release_type {
|
||||
ReleaseType::Release => VersionKind::Release,
|
||||
ReleaseType::Snapshot | ReleaseType::Pending | ReleaseType::Unobfuscated => {
|
||||
VersionKind::Snapshot
|
||||
}
|
||||
ReleaseType::OldAlpha | ReleaseType::OldBeta | ReleaseType::Modified => {
|
||||
VersionKind::Ancient(ancient_kind(id))
|
||||
}
|
||||
ReleaseType::Unknown => {
|
||||
if id.starts_with("rd-") || id.starts_with("a") || id.starts_with("b") {
|
||||
VersionKind::Ancient(ancient_kind(id))
|
||||
} else {
|
||||
VersionKind::Release
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// 远古版子类（`rd-*` → classic；`a1.*` → old_alpha；`b1.*` → old_beta；其余 unlisted）。
|
||||
pub fn ancient_kind(id: &str) -> AncientKind {
|
||||
if id.starts_with("rd-") || id.starts_with("inf-") {
|
||||
AncientKind::Classic
|
||||
} else if id.starts_with("a1.") || id.starts_with("a0.") || id.starts_with('a') {
|
||||
AncientKind::OldAlpha
|
||||
} else if id.starts_with("b1.") || id.starts_with('b') {
|
||||
AncientKind::OldBeta
|
||||
} else {
|
||||
AncientKind::Unlisted
|
||||
}
|
||||
}
|
||||
|
||||
/// 发布日期取 `releaseTime` 的日期部分（缺失时退回 `time`，再退回空串）。
|
||||
fn released_of(version: &RemoteVersion) -> String {
|
||||
version
|
||||
.release_time
|
||||
.as_deref()
|
||||
.or(version.time.as_deref())
|
||||
.map(|text| text.get(..10).unwrap_or(text).to_string())
|
||||
.unwrap_or_default()
|
||||
}
|
||||
|
||||
/// 拉清单并翻译成 DTO（安装状态按盘上版本判定）。
|
||||
fn fetch(env: &HostEnv) -> Result<Vec<VersionSummary>, String> {
|
||||
let engine = super::engine::engine(env);
|
||||
let meta_cache = env.layout.meta_cache();
|
||||
let now = now_ms();
|
||||
let (mut list, _freshness) = block_on(async {
|
||||
RemoteSource::new(&engine, &env.game, &meta_cache, now)
|
||||
.manifest(false)
|
||||
.await
|
||||
})
|
||||
.map_err(|error| format!("拉取版本清单失败：{error}"))?;
|
||||
// 内嵌 unlisted 清单先合（同 id 先插入者胜），保证远古版显式可达（09 §G2）。
|
||||
unlisted::merge_into(&mut list);
|
||||
list.sort_newest_first();
|
||||
|
||||
let installed: BTreeSet<String> = env
|
||||
.game
|
||||
.installed_versions()
|
||||
.unwrap_or_default()
|
||||
.into_iter()
|
||||
.collect();
|
||||
Ok(list
|
||||
.versions
|
||||
.iter()
|
||||
.map(|version| VersionSummary {
|
||||
id: version.id.clone(),
|
||||
kind: kind_of(&version.id, version.version_type),
|
||||
released: released_of(version),
|
||||
installed: installed.contains(&version.id),
|
||||
})
|
||||
.collect())
|
||||
}
|
||||
|
||||
/// 后台拉清单（网络在后台线程里，UI 不卡）。
|
||||
pub fn spawn_list(env: HostEnv, tx: JobSender) {
|
||||
spawn("versions", move || {
|
||||
let result = fetch(&env);
|
||||
let _ = tx.send(HostTask::Versions(result));
|
||||
});
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn kinds_follow_official_types() {
|
||||
assert_eq!(
|
||||
kind_of("1.21.9", ReleaseType::Release),
|
||||
VersionKind::Release
|
||||
);
|
||||
assert_eq!(
|
||||
kind_of("1.21.9-pre3", ReleaseType::Snapshot),
|
||||
VersionKind::Snapshot
|
||||
);
|
||||
assert_eq!(
|
||||
kind_of("rd-132211", ReleaseType::OldAlpha),
|
||||
VersionKind::Ancient(AncientKind::Classic)
|
||||
);
|
||||
assert_eq!(
|
||||
kind_of("a1.1.1", ReleaseType::OldAlpha),
|
||||
VersionKind::Ancient(AncientKind::OldAlpha)
|
||||
);
|
||||
assert_eq!(
|
||||
kind_of("b1.7.3", ReleaseType::OldBeta),
|
||||
VersionKind::Ancient(AncientKind::OldBeta)
|
||||
);
|
||||
assert_eq!(
|
||||
kind_of("x-modified", ReleaseType::Modified),
|
||||
VersionKind::Ancient(AncientKind::Unlisted)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn released_uses_date_part() {
|
||||
let version = RemoteVersion {
|
||||
id: "1.20.4".to_string(),
|
||||
version_type: ReleaseType::Release,
|
||||
url: String::new(),
|
||||
time: None,
|
||||
release_time: Some("2023-12-07T12:00:00+00:00".to_string()),
|
||||
sha1: None,
|
||||
size: None,
|
||||
};
|
||||
assert_eq!(released_of(&version), "2023-12-07");
|
||||
let empty = RemoteVersion {
|
||||
id: "x".to_string(),
|
||||
version_type: ReleaseType::Unknown,
|
||||
url: String::new(),
|
||||
time: None,
|
||||
release_time: None,
|
||||
sha1: None,
|
||||
size: None,
|
||||
};
|
||||
assert_eq!(released_of(&empty), "");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unlisted_merge_keeps_ancient_versions_reachable() {
|
||||
// core 的内嵌清单里一定有远古版（`rd-*` / `a1.*` / `b1.*`）
|
||||
let mut list = unlucky_core::game::version::VersionList::default();
|
||||
let added = unlisted::merge_into(&mut list);
|
||||
assert!(added > 0, "内嵌 unlisted 清单不该为空");
|
||||
assert!(
|
||||
list.versions.iter().any(|v| v.id.starts_with("a1.")
|
||||
|| v.id.starts_with("b1.")
|
||||
|| v.id.starts_with("rd-")),
|
||||
"远古版必须显式可达"
|
||||
);
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user