mirror of
https://github.com/Corfirean/coa-server-manager.git
synced 2026-11-19 03:25:56 +00:00
195 lines
11 KiB
Rust
195 lines
11 KiB
Rust
//! 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<crate::migrations::Item>,
|
|
pub problems: Vec<crate::schema_check::Problem>,
|
|
pub full_schema: bool,
|
|
}
|
|
|
|
fn installed_manifest(meta: &InstallMeta, dir: &Path) -> Result<Manifest> {
|
|
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<Vec<DatabaseCheck>> {
|
|
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<String>,
|
|
pub applied: Vec<String>,
|
|
pub backup: String,
|
|
pub database: Vec<DatabaseCheck>,
|
|
pub error: Option<String>,
|
|
}
|
|
|
|
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<Vec<String>> {
|
|
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<Report> {
|
|
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<String, (&FileEntry, bool)> = 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());
|
|
}
|
|
}
|