AskaEth
3d9372029e
clippy --all-targets -D warnings 报 very complex type（RefCell<Vec<(usize, String, Vec<String>, usize)>>）， 抽 pub(super) type StepView 别名，语义不变。
273 lines
8.2 KiB
Rust
273 lines
8.2 KiB
Rust
//! 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,
|
|
}
|
|
}
|