//! Repair official files and pending SQL from signed packages without replacing player databases or settings. use std::{collections::BTreeMap, fs, path::Path}; use serde::Serialize; use crate::{Error, Result, fsx, manifest::{Manifest, Kind, FileEntry, ReplacePolicy}, pkgsource::{self, Source}, registry::{InstallMeta, MetaDir}, update::{Env, RepackEnv}, download::Cancel}; #[derive(Debug, Serialize)] pub struct DatabaseCheck { pub realm: crate::realms::Mode, pub migrations: Vec, pub problems: Vec, pub full_schema: bool, } fn installed_manifest(meta: &InstallMeta, dir: &Path) -> Result { let version = meta.core.version.as_deref().ok_or_else(|| Error::Invalid("This imported server has no verified package version. Install an official server package first.".into()))?; let update = dir.join("manifests").join(format!("update-{version}.json")); let bytes = fs::read(if update.exists() { update } else { dir.join("manifests/base.json") })?; let m = Manifest::parse(&bytes)?; if m.version != version { return Err(Error::Invalid("The installed package manifest is missing. Update the server to restore its package information.".into())); } Ok(m) } pub fn check(root: &Path, dir: &Path) -> Result> { let (_, meta) = MetaDir::open(dir)?; let m = installed_manifest(&meta, dir)?; let checks = crate::backup::with_database(root, |db| { let mut modes = vec![crate::realms::Mode::Coa]; if crate::realms::state(root)?.wildcard_created { modes.push(crate::realms::Mode::Wildcard); } let mut checks = Vec::new(); for mode in modes { let db = db.clone().for_realm(mode); let migrations: Vec<_> = m.migrations.iter().filter(|m| mode == crate::realms::Mode::Coa || m.db != "auth").cloned().collect(); checks.push(DatabaseCheck { realm: mode, migrations: crate::migrations::status(&db, &migrations)?, problems: crate::schema_check::check(&db, root)?, full_schema: root.join(crate::schema_check::CONTRACT).exists() }); } Ok(checks) })?; fsx::atomic_write_json(&dir.join("logs/database-checks.json"), &checks)?; Ok(checks) } #[derive(Debug, Serialize)] pub struct Report { pub restored: Vec, pub applied: Vec, pub backup: String, pub database: Vec, pub error: Option, } fn repairable(f: &FileEntry) -> bool { let path = f.path.to_lowercase(); f.owner != crate::manifest::Owner::User && matches!(f.policy, ReplacePolicy::Replace | ReplacePolicy::ReplaceIfPristine) && !path.starts_with("settings/") && !path.starts_with("core/configs/") && !path.starts_with("mysql/data/") && !path.starts_with("_migrations/") } fn restore_files(root: &Path, work: &Path, before: &Path, broken: &[(&FileEntry, bool)]) -> Result> { let mut plan = Vec::new(); // Back up every target before changing the first one, and retain a crash-recovery inventory. for (entry, _) in broken { let target = fsx::ensure_within(root, &fsx::safe_join(root, &entry.path)?)?; let existed = target.is_file(); if existed { let saved = fsx::safe_join(before, &entry.path)?; fs::create_dir_all(saved.parent().unwrap())?; fs::copy(&target, saved)?; } plan.push((entry.path.clone(), existed)); } fsx::atomic_write_json(&before.join("files.json"), &plan)?; let mut restored = Vec::new(); let result: Result<()> = (|| { for (entry, latest) in broken { let target = fsx::ensure_within(root, &fsx::safe_join(root, &entry.path)?)?; let source = fsx::safe_join(&work.join(if *latest { "update" } else { "base" }), &entry.path)?; fsx::atomic_write(&target, &fs::read(&source)?)?; restored.push(entry.path.clone()); } Ok(()) })(); if let Err(e) = result { for (path, existed) in &plan { let target = fsx::ensure_within(root, &fsx::safe_join(root, path)?)?; if *existed { fsx::atomic_write(&target, &fs::read(fsx::safe_join(before, path)?)?)?; } else if target.is_file() { fs::remove_file(target)?; } } return Err(e); } Ok(restored) } pub fn run(root: &Path, dir: &Path, base_source: &Source, update_source: &Source, key: &str, progress: &dyn Fn(&str, u8)) -> Result { let _lock = crate::update::operation_lock(dir)?; let env = RepackEnv { root, meta_dir: dir }; env.ensure_stopped()?; crate::update::ensure_recovered(dir)?; let (_, mut meta) = MetaDir::open(dir)?; progress("Checking signed packages", 2); let (update, _) = pkgsource::fetch_manifest(update_source, key)?; if update.kind != Kind::Update || !update.compatible_with_manager(crate::MANAGER_VERSION) || meta.core.version.as_deref() != Some(&update.version) { return Err(Error::Invalid("Update the server to the latest compatible package before repairing it. Repair never changes its version.".into())); } let (base, _) = pkgsource::fetch_manifest(base_source, key)?; let installed_base = Manifest::parse(&fs::read(dir.join("manifests/base.json"))?)?; if base.kind != Kind::Base || base.version != installed_base.version || base.core.commit != installed_base.core.commit { return Err(Error::Invalid("The matching base package is no longer available. Your server was left unchanged.".into())); } let work = dir.join("staging").join(format!("repair-{}", uuid::Uuid::new_v4())); fs::create_dir_all(&work)?; let result = (|| { let mut files: BTreeMap = base.files.iter().filter(|f| repairable(f)).map(|f| (f.path.clone(), (f, false))).collect(); for f in update.files.iter().filter(|f| repairable(f)) { files.insert(f.path.clone(), (f, true)); } let mut broken = Vec::new(); for (path, (entry, latest)) in files { let target = fsx::ensure_within(root, &fsx::safe_join(root, &path)?)?; if fsx::sha256_file(&target).ok().as_deref() != Some(&entry.sha256) { broken.push((entry, latest)); } } let cancel = Cancel::default(); let update_parts = pkgsource::fetch_parts(update_source, &update, &dir.join("staging/download"), &cancel, &|f,_| progress("Downloading repair files", 5 + (f * 30.0) as u8))?; crate::package::extract(&update_parts, &update, &work.join("update"), &|_,_| {})?; if broken.iter().any(|(_,latest)| !latest) { let base_parts = pkgsource::fetch_parts(base_source, &base, &dir.join("staging/repair-base-download"), &cancel, &|f,_| progress("Downloading base files", 35 + (f * 25.0) as u8))?; crate::package::extract(&base_parts, &base, &work.join("base"), &|_,_| {})?; } // Verify all sources before taking a backup or replacing any target. for (entry, latest) in &broken { let src = fsx::safe_join(&work.join(if *latest { "update" } else { "base" }), &entry.path)?; if fsx::sha256_file(&src)? != entry.sha256 { return Err(Error::Invalid("A repair file failed verification.".into())); } } progress("Backing up before repair", 65); let backup = crate::backup::create(root, dir, crate::backup::Kind::Full, crate::backup::Trigger::Manual, Some("before repair".into()), &|_| {})?.id; env.verify_recovery_point(&crate::backup::get(dir, &backup)?)?; let repair_files: Vec<_> = broken.iter().map(|(file, _)| (*file).clone()).collect(); let mut txn = crate::update::begin_repair(root, dir, &update.version, &backup, &repair_files)?; let before = dir.join("repairs").join(&backup); fs::create_dir_all(&before)?; fsx::require_space(root, broken.iter().map(|(e,_)| e.size.saturating_mul(2)).sum())?; let restored = restore_files(root, &work, &before, &broken)?; for (entry, _) in &broken { meta.original_hashes.insert(entry.path.clone(), entry.sha256.clone()); } fsx::atomic_write_json(&dir.join("install.json"), &meta)?; progress("Repairing pending database updates", 80); crate::update::repair_migrating(dir, &mut txn)?; let (applied, error) = match env.migrate(&update, &work.join("update/_migrations")) { Ok(r) => (r.applied, r.failed.map(|(id,why)| format!("{id}: {why}"))), Err(e) => (Vec::new(), Some(e.to_string())), }; if error.is_some() { crate::update::finish_repair(root, dir, &mut txn, false, &env)?; let report = Report { restored: Vec::new(), applied: Vec::new(), backup, database: check(root, dir)?, error }; fsx::atomic_write_json(&before.join("report.json"), &report)?; return Ok(report); } crate::config::create_missing_module_configs(root)?; progress("Checking database after repair", 95); let database = check(root, dir)?; let report = Report { restored, applied, backup, database, error }; fsx::atomic_write_json(&before.join("report.json"), &report)?; crate::update::finish_repair(root, dir, &mut txn, true, &env)?; progress("Done", 100); Ok(report) })(); // Only the UUID staging directory created above is discarded; backups are retained. let _ = fs::remove_dir_all(work); result } #[cfg(test)] mod tests { use super::*; #[test] fn repair_never_replaces_player_data_or_settings() { for path in ["mysql/data/acore_characters/characters.ibd", "Settings/repack.json", "Core/configs/worldserver.conf", "_migrations/world/x.sql"] { let entry = FileEntry { path: path.into(), sha256: "a".repeat(64), size: 1, owner: crate::manifest::Owner::Core, policy: ReplacePolicy::Replace }; assert!(!repairable(&entry)); } } #[test] fn file_failure_restores_every_original_and_keeps_recovery_inventory() { let d = tempfile::tempdir().unwrap(); let root = d.path().join("server"); let work = d.path().join("work"); let before = d.path().join("before"); fsx::atomic_write(&root.join("Core/a.dll"), b"original").unwrap(); fsx::atomic_write(&work.join("update/Core/a.dll"), b"repaired").unwrap(); let entries: Vec<_> = ["Core/a.dll", "Core/missing.dll"].into_iter().map(|path| FileEntry { path: path.into(), sha256: "a".repeat(64), size: 1, owner: crate::manifest::Owner::Core, policy: ReplacePolicy::Replace }).collect(); assert!(restore_files(&root, &work, &before, &[(&entries[0], true), (&entries[1], true)]).is_err()); assert_eq!(fs::read(root.join("Core/a.dll")).unwrap(), b"original"); assert!(!root.join("Core/missing.dll").exists()); assert!(before.join("files.json").is_file()); } }