AskaEth
d95c9664c6
P2-1：wizard.slint 的 Forge/NeoForge 提示还写着「需要 installer processors：本轮请用 ull install」， 改成「需要 installer processors（首装会外调 java，约 1–3 分钟）」；全仓再扫一遍 「ull install / 显式拒装 / 终端跑」等措辞，user-facing 文案已无残留（余下命中全是 OptiFine/LiteLoader 的正确说明与测试注释）。 P2-2：进度条在处理器依赖库下完那一刻就满格（36/36），随后加载器库的 29 个文件才被计入 → 100% 回落再涨回，且 bytes_total 用 .max() 与文件数对不上。 - Meter 新增 expect(files, bytes)：文件数与字节都 saturating_add； - install_loader 在处理器段之前就把加载器库的文件/字节一次预记账（两段之和）， 加载器库阶段只剩切阶段文案，不再记账； - Reporter::expect 改为委托 Meter::expect，处理器依赖库沿用同一条曲线； - 回归测试钉住：预记账后 files_total=95、bytes_total=17MB、ratio 不再满格， 处理器库下完仍是中间态，加载器库下完才到 100%。 真机重截 + 识图：D:/tmp/ull-m45-shots/forge-mid-fixed-25s.png —— 同一时刻面板 36/65 文件、3.4 MB/15.3 MB、进度条只填了约一半（旧图 36/36 + 满格）。
394 lines
15 KiB
Rust
394 lines
15 KiB
Rust
//! 安装：新建实例向导 / 下载页「安装」→ 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;
|