mirror of
https://github.com/Corfirean/coa-server-manager.git
synced 2026-11-19 03:25:56 +00:00
Fix settings input, client launch, server repair and simultaneous realms
This commit is contained in:
1 parent
162bfd1e04
commit
c02c635463
48 files changed
+1218
-72
No files matched your search
@@ -0,0 +1,43 @@
|
||||
//! Probe only a disposable fixture: enable both worlds, verify isolation, gracefully stop both.
|
||||
use coa_core::{Error, Result, driver::{self, Verb}, realms::{self, Mode}, multiworld, process::{self, ServiceState}};
|
||||
use std::path::PathBuf;
|
||||
|
||||
fn main() -> Result<()> {
|
||||
let root = PathBuf::from(std::env::args().nth(1).ok_or_else(|| Error::Invalid("fixture path required".into()))?);
|
||||
if !root.file_name().is_some_and(|n| n.to_string_lossy().contains("fixture")) { return Err(Error::Invalid("Refusing a non-fixture server.".into())); }
|
||||
let action = std::env::args().nth(2).unwrap_or_else(|| "smoke".into());
|
||||
if action == "stop" { driver::run(&root, Verb::StopAll)?; return Ok(()); }
|
||||
driver::run(&root, Verb::StopAll)?;
|
||||
if action == "wildcard" { realms::select(&root, Mode::Wildcard)?; }
|
||||
multiworld::set_enabled(&root, true)?;
|
||||
let result = (|| {
|
||||
let out = driver::run(&root, Verb::StartAll)?;
|
||||
if !out.ok { return Err(Error::Invalid(out.output)); }
|
||||
let first = process::observe(&root, &coa_core::layout::read_ports(&root));
|
||||
let second_root = multiworld::root(&root);
|
||||
let second = process::observe(&second_root, &coa_core::layout::read_ports(&second_root));
|
||||
assert_eq!(first.world.state, ServiceState::Running);
|
||||
assert_eq!(second.world.state, ServiceState::Running);
|
||||
assert_ne!(first.world.pid, second.world.pid);
|
||||
assert_ne!(first.world.port, second.world.port);
|
||||
assert!(second.mysql.pid.is_none() && second.auth.pid.is_none());
|
||||
let db = coa_core::db::Db::from_repack(&root, coa_core::db::Account::Admin)?;
|
||||
let realms = db.query("SELECT id,port,flag FROM acore_auth.realmlist WHERE id IN (1,2) ORDER BY id;")?;
|
||||
println!("Two distinct world PIDs; shared auth/MySQL; realm rows:\n{realms}");
|
||||
for mode in [Mode::Coa, Mode::Wildcard] {
|
||||
let problems = coa_core::schema_check::check(&db.clone().for_realm(mode), &root)?;
|
||||
println!("{}: {} database problems", mode.name(), problems.len());
|
||||
for p in problems.iter().take(5) { println!("{}.{}.{}: {}", p.database, p.table, p.column, p.detail); }
|
||||
}
|
||||
assert!(multiworld::set_enabled(&root, false).is_err());
|
||||
assert!(realms::select(&root, Mode::Wildcard).is_err());
|
||||
Ok(())
|
||||
})();
|
||||
let stopped = driver::run(&root, Verb::StopAll)?;
|
||||
if !stopped.ok { return Err(Error::Invalid(stopped.output)); }
|
||||
assert!(!multiworld::is_running(&root));
|
||||
assert_eq!(process::observe(&root, &coa_core::layout::read_ports(&root)).mysql.state, ServiceState::Stopped);
|
||||
result?;
|
||||
println!("Both worlds shut down before the shared database.");
|
||||
Ok(())
|
||||
}
|
||||
@@ -0,0 +1,62 @@
|
||||
//! Signed-package repair smoke test. Only a disposable fixture may be used.
|
||||
use std::path::PathBuf;
|
||||
use base64::{engine::general_purpose::STANDARD, Engine};
|
||||
use ed25519_dalek::{Signer, SigningKey};
|
||||
use coa_core::{Result, Error, fsx, package::{self, BuildOptions}, manifest::{Kind, Migration}, registry::{InstallKind, InstallMeta, MetaDir, metadata_dir_for}, pkgsource::Source, realms::Mode};
|
||||
|
||||
fn main() -> Result<()> {
|
||||
let root = PathBuf::from(std::env::args().nth(1).ok_or_else(|| Error::Invalid("fixture path required".into()))?);
|
||||
if !root.file_name().is_some_and(|n| n.to_string_lossy().contains("fixture")) { return Err(Error::Invalid("Refusing a non-fixture server.".into())); }
|
||||
let work = tempfile::tempdir()?;
|
||||
let base_tree = work.path().join("base-tree");
|
||||
let update_tree = work.path().join("update-tree");
|
||||
let base_pkg = work.path().join("base-pkg");
|
||||
let update_pkg = work.path().join("update-pkg");
|
||||
let probe = "Core/reference/repair-e2e.txt";
|
||||
fsx::atomic_write(&base_tree.join(probe), b"base")?;
|
||||
fsx::atomic_write(&update_tree.join(probe), b"correct official file")?;
|
||||
let sql = "CREATE TABLE IF NOT EXISTS acore_world.manager_repair_probe (id INT PRIMARY KEY); INSERT IGNORE INTO acore_world.manager_repair_probe VALUES (42);";
|
||||
let id = "20261004_repair_e2e";
|
||||
fsx::atomic_write(&update_tree.join(format!("_migrations/world/{id}.sql")), sql.as_bytes())?;
|
||||
let options = |kind, version: &str, migrations| BuildOptions { kind, version: version.into(), core_commit: None, built_at: "fixture".into(), part_size: 1 << 20, bots_commit: None, migrations };
|
||||
let base = package::build(&base_tree, &base_pkg, &options(Kind::Base, "1.0.0", vec![]), &|_| {})?;
|
||||
let update = package::build(&update_tree, &update_pkg, &options(Kind::Update, "1.0.1", vec![Migration { id: id.into(), db: "world".into(), sha256: fsx::sha256_bytes(sql.as_bytes()), destructive: false }]), &|_| {})?;
|
||||
// A test-only trust key, unrelated to production signing material.
|
||||
let key = SigningKey::from_bytes(&[23; 32]);
|
||||
let public = STANDARD.encode(key.verifying_key().as_bytes());
|
||||
for pkg in [&base_pkg, &update_pkg] {
|
||||
fsx::atomic_write(&pkg.join("manifest.json.sig"), STANDARD.encode(key.sign(&std::fs::read(pkg.join("manifest.json"))?).to_bytes()).as_bytes())?;
|
||||
}
|
||||
let dir = metadata_dir_for(&root)?;
|
||||
let mut meta = InstallMeta::new(InstallKind::New, &root);
|
||||
meta.core.version = Some(update.version.clone());
|
||||
MetaDir::create(&root, &meta)?;
|
||||
fsx::atomic_write_json(&dir.join("manifests/base.json"), &base)?;
|
||||
fsx::atomic_write_json(&dir.join("manifests/update-1.0.1.json"), &update)?;
|
||||
fsx::atomic_write(&root.join(probe), b"corrupted")?;
|
||||
let settings = std::fs::read(root.join("Settings/repack.json"))?;
|
||||
let counts = coa_core::backup::with_database(&root, |db| db.query("SELECT COUNT(*) FROM acore_auth.account; SELECT COUNT(*) FROM acore_characters.characters; SELECT COUNT(*) FROM acore_characters_wildcard.characters;"))?;
|
||||
let report = coa_core::repair::run(&root, &dir, &Source::Dir(base_pkg), &Source::Dir(update_pkg), &public, &|s,p| println!("{p}% {s}"))?;
|
||||
assert_eq!(std::fs::read(root.join(probe))?, b"correct official file");
|
||||
assert!(report.error.is_none(), "{:?}", report.error);
|
||||
assert_eq!(report.applied.len(), 2, "Migration must run in both worlds");
|
||||
assert!(report.database.iter().all(|d| d.problems.is_empty() && d.migrations.iter().all(|m| m.status == coa_core::migrations::Status::Applied)));
|
||||
assert_eq!(std::fs::read(root.join("Settings/repack.json"))?, settings);
|
||||
assert!(coa_core::backup::verify(&dir, &report.backup)?.ok);
|
||||
coa_core::backup::with_database(&root, |db| {
|
||||
assert_eq!(db.query("SELECT COUNT(*) FROM acore_auth.account; SELECT COUNT(*) FROM acore_characters.characters; SELECT COUNT(*) FROM acore_characters_wildcard.characters;")?, counts);
|
||||
for mode in [Mode::Coa, Mode::Wildcard] {
|
||||
assert_eq!(db.clone().for_realm(mode).query("SELECT id FROM acore_world.manager_repair_probe;")?, "42");
|
||||
}
|
||||
// Corrupt only the second realm, proving that checks read its actual schema.
|
||||
let wildcard = db.clone().for_realm(Mode::Wildcard);
|
||||
wildcard.query("ALTER TABLE acore_characters.character_action DROP COLUMN type;")?;
|
||||
let problems = coa_core::schema_check::check(&wildcard, &root)?;
|
||||
assert!(problems.iter().any(|p| p.table == "character_action" && p.column == "type"));
|
||||
assert!(coa_core::schema_check::check(&db.clone().for_realm(Mode::Coa), &root)?.is_empty());
|
||||
wildcard.query("ALTER TABLE acore_characters.character_action ADD COLUMN type TINYINT UNSIGNED NOT NULL DEFAULT 0;")?;
|
||||
Ok(())
|
||||
})?;
|
||||
println!("Repair verified: signed file restored, both realms migrated, backup valid, accounts/characters/settings preserved, missing column isolated to its realm.");
|
||||
Ok(())
|
||||
}
|
||||
@@ -0,0 +1,26 @@
|
||||
//! Check full schema contracts and blocking custom columns, only against a disposable fixture.
|
||||
use coa_core::{Result, Error, backup, schema_check, realms::Mode};
|
||||
use std::path::PathBuf;
|
||||
fn main() -> Result<()> {
|
||||
let root = PathBuf::from(std::env::args().nth(1).ok_or_else(|| Error::Invalid("fixture path required".into()))?);
|
||||
if !root.file_name().is_some_and(|n| n.to_string_lossy().contains("fixture")) { return Err(Error::Invalid("Refusing a non-fixture server.".into())); }
|
||||
backup::with_database(&root, |db| {
|
||||
let coa = db.clone().for_realm(Mode::Coa);
|
||||
let wildcard = db.clone().for_realm(Mode::Wildcard);
|
||||
assert!(schema_check::check(&coa, &root)?.is_empty());
|
||||
assert!(schema_check::check(&wildcard, &root)?.is_empty());
|
||||
let reference = tempfile::tempdir()?;
|
||||
schema_check::capture(&coa, reference.path())?;
|
||||
assert!(schema_check::check(&coa, reference.path())?.is_empty());
|
||||
wildcard.query("ALTER TABLE acore_characters.character_action ADD COLUMN manager_required INT NOT NULL;")?;
|
||||
let result = (|| {
|
||||
assert!(schema_check::check(&wildcard, &root)?.iter().any(|p| p.table == "character_action" && p.column == "manager_required"));
|
||||
assert!(schema_check::check(&coa, &root)?.is_empty());
|
||||
Ok(())
|
||||
})();
|
||||
wildcard.query("ALTER TABLE acore_characters.character_action DROP COLUMN manager_required;")?;
|
||||
result
|
||||
})?;
|
||||
println!("Full schema contract and a blocking NOT NULL column verified; second-realm corruption does not affect CoA checks.");
|
||||
Ok(())
|
||||
}
|
||||
@@ -162,7 +162,7 @@ pub fn with_database<T>(root: &Path, f: impl FnOnce(&Db) -> Result<T>) -> Result
|
||||
let result = f(&db);
|
||||
if !mysql_was_up {
|
||||
let now = process::observe(root, &read_ports(root));
|
||||
if now.world.state == ServiceState::Stopped && now.auth.state == ServiceState::Stopped {
|
||||
if now.world.state == ServiceState::Stopped && now.auth.state == ServiceState::Stopped && !crate::multiworld::is_running(root) {
|
||||
let _ = driver::run(root, Verb::StopAll);
|
||||
}
|
||||
}
|
||||
@@ -338,7 +338,7 @@ pub fn restore_database(root: &Path, meta: &Path, id: &str, name: &str) -> Resul
|
||||
return Err(Error::Invalid("This backup is damaged and cannot be restored.".into()));
|
||||
}
|
||||
let now = process::observe(root, &read_ports(root));
|
||||
if now.world.state != ServiceState::Stopped || now.auth.state != ServiceState::Stopped {
|
||||
if now.world.state != ServiceState::Stopped || now.auth.state != ServiceState::Stopped || crate::multiworld::is_running(root) {
|
||||
return Err(Error::Invalid("Stop the server before restoring a database.".into()));
|
||||
}
|
||||
let live = if name.contains('-') { db::schema_of(name)? } else { point.realm.schema(name)? };
|
||||
|
||||
@@ -0,0 +1,170 @@
|
||||
{
|
||||
"character_inventory": [
|
||||
"guid",
|
||||
"bag",
|
||||
"slot",
|
||||
"item"
|
||||
],
|
||||
"characters": [
|
||||
"guid",
|
||||
"account",
|
||||
"name",
|
||||
"race",
|
||||
"class",
|
||||
"gender",
|
||||
"level",
|
||||
"xp",
|
||||
"money",
|
||||
"skin",
|
||||
"face",
|
||||
"hairStyle",
|
||||
"hairColor",
|
||||
"facialStyle",
|
||||
"bankSlots",
|
||||
"restState",
|
||||
"playerFlags",
|
||||
"map",
|
||||
"instance_id",
|
||||
"instance_mode_mask",
|
||||
"position_x",
|
||||
"position_y",
|
||||
"position_z",
|
||||
"orientation",
|
||||
"trans_x",
|
||||
"trans_y",
|
||||
"trans_z",
|
||||
"trans_o",
|
||||
"transguid",
|
||||
"taximask",
|
||||
"cinematic",
|
||||
"totaltime",
|
||||
"leveltime",
|
||||
"rest_bonus",
|
||||
"logout_time",
|
||||
"is_logout_resting",
|
||||
"resettalents_cost",
|
||||
"resettalents_time",
|
||||
"extra_flags",
|
||||
"stable_slots",
|
||||
"at_login",
|
||||
"zone",
|
||||
"death_expire_time",
|
||||
"taxi_path",
|
||||
"arenaPoints",
|
||||
"totalHonorPoints",
|
||||
"todayHonorPoints",
|
||||
"yesterdayHonorPoints",
|
||||
"totalKills",
|
||||
"todayKills",
|
||||
"yesterdayKills",
|
||||
"chosenTitle",
|
||||
"knownCurrencies",
|
||||
"watchedFaction",
|
||||
"drunk",
|
||||
"health",
|
||||
"power1",
|
||||
"power2",
|
||||
"power3",
|
||||
"power4",
|
||||
"power5",
|
||||
"power6",
|
||||
"power7",
|
||||
"latency",
|
||||
"talentGroupsCount",
|
||||
"activeTalentGroup",
|
||||
"exploredZones",
|
||||
"equipmentCache",
|
||||
"ammoId",
|
||||
"knownTitles",
|
||||
"actionBars",
|
||||
"grantableLevels",
|
||||
"innTriggerId",
|
||||
"extraBonusTalentCount"
|
||||
],
|
||||
"character_spell": [
|
||||
"guid",
|
||||
"spell",
|
||||
"specMask"
|
||||
],
|
||||
"character_skills": [
|
||||
"guid",
|
||||
"skill",
|
||||
"value",
|
||||
"max"
|
||||
],
|
||||
"character_homebind": [
|
||||
"guid",
|
||||
"mapId",
|
||||
"zoneId",
|
||||
"posX",
|
||||
"posY",
|
||||
"posZ"
|
||||
],
|
||||
"character_reputation": [
|
||||
"guid",
|
||||
"faction",
|
||||
"standing",
|
||||
"flags"
|
||||
],
|
||||
"character_action": [
|
||||
"guid",
|
||||
"spec",
|
||||
"button",
|
||||
"action",
|
||||
"type"
|
||||
],
|
||||
"character_talent": [
|
||||
"guid",
|
||||
"spell",
|
||||
"specMask"
|
||||
],
|
||||
"item_instance": [
|
||||
"itemEntry",
|
||||
"owner_guid",
|
||||
"creatorGuid",
|
||||
"giftCreatorGuid",
|
||||
"count",
|
||||
"duration",
|
||||
"charges",
|
||||
"flags",
|
||||
"enchantments",
|
||||
"randomPropertyId",
|
||||
"durability",
|
||||
"playedTime",
|
||||
"text",
|
||||
"guid"
|
||||
],
|
||||
"character_stats": [
|
||||
"guid",
|
||||
"maxhealth",
|
||||
"maxpower1",
|
||||
"maxpower2",
|
||||
"maxpower3",
|
||||
"maxpower4",
|
||||
"maxpower5",
|
||||
"maxpower6",
|
||||
"maxpower7",
|
||||
"strength",
|
||||
"agility",
|
||||
"stamina",
|
||||
"intellect",
|
||||
"spirit",
|
||||
"armor",
|
||||
"resHoly",
|
||||
"resFire",
|
||||
"resNature",
|
||||
"resFrost",
|
||||
"resShadow",
|
||||
"resArcane",
|
||||
"blockPct",
|
||||
"dodgePct",
|
||||
"parryPct",
|
||||
"critPct",
|
||||
"rangedCritPct",
|
||||
"spellCritPct",
|
||||
"attackPower",
|
||||
"rangedAttackPower",
|
||||
"spellPower",
|
||||
"resilience"
|
||||
]
|
||||
}
|
||||
@@ -218,12 +218,17 @@ pub fn build(p: &Params, say: &dyn Fn(&str)) -> Result<()> {
|
||||
db.query(&sql)?;
|
||||
// 2. characters: a brand-new schema from the core's base scripts
|
||||
db.query("DROP DATABASE IF EXISTS `acore_characters`; CREATE DATABASE `acore_characters` CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;")?;
|
||||
// The ledger lives in world, so dropping characters does not clear its migration history.
|
||||
// Never carry that history into a freshly rebuilt character database.
|
||||
if db.tables("acore_world")?.iter().any(|t| t == "coa_manager_migrations") {
|
||||
db.query("DELETE FROM acore_world.coa_manager_migrations WHERE `db`='characters';")?;
|
||||
}
|
||||
for f in &base_chars {
|
||||
db.run_sql_file("acore_characters", f)?;
|
||||
}
|
||||
// 3. every migration up to the core commit (already-recorded ones are skipped)
|
||||
let before = status(db, &migrations)?;
|
||||
let pending: Vec<_> = migrations.iter().zip(&before).filter(|(_, i)| i.status == Status::Pending).map(|(m, _)| m.clone()).collect();
|
||||
let pending: Vec<_> = migrations.iter().zip(&before).filter(|(_, i)| i.status != Status::Applied).map(|(m, _)| m.clone()).collect();
|
||||
say(&format!("Applying {} database updates", pending.len()));
|
||||
let report = apply_pending(db, &pending, &staging, &|| Ok("(scratch database)".into()))?;
|
||||
if let Some((id, why)) = report.failed {
|
||||
@@ -251,6 +256,7 @@ pub fn build(p: &Params, say: &dyn Fn(&str)) -> Result<()> {
|
||||
if accounts != "0" || chars != "0" || templates != 21 {
|
||||
return Err(Error::Invalid(format!("The database is not clean ({accounts} accounts, {chars} player characters, {templates} templates).")));
|
||||
}
|
||||
crate::schema_check::capture(db, out)?;
|
||||
Ok(())
|
||||
})?;
|
||||
|
||||
|
||||
@@ -101,6 +101,7 @@ impl Db {
|
||||
}
|
||||
|
||||
pub fn for_realm(mut self, realm: crate::realms::Mode) -> Self { self.realm = realm; self }
|
||||
pub fn realm(&self) -> crate::realms::Mode { self.realm }
|
||||
|
||||
pub fn realm_schema<'a>(&self, name: &'a str) -> &'a str {
|
||||
if self.realm == crate::realms::Mode::Wildcard {
|
||||
|
||||
@@ -64,7 +64,9 @@ pub fn run(root: &Path, meta: &InstallMeta) -> Report {
|
||||
|
||||
let ports = layout::read_ports(root);
|
||||
let o = process::observe(root, &ports);
|
||||
for (title, s) in [("Database", &o.mysql), ("Login server", &o.auth), ("World server", &o.world)] {
|
||||
let mut services = vec![("Database", &o.mysql), ("Login server", &o.auth), ("World server", &o.world)];
|
||||
if let Some(second) = &o.secondary_world { services.push(("Second world", second)); }
|
||||
for (title, s) in services {
|
||||
let (lvl, text) = match (s.state, &s.conflict) {
|
||||
(ServiceState::Running, _) => (Level::Ok, "Running".to_string()),
|
||||
(_, Some(conf)) => (Level::Fail, format!("Port {} is used by another program (process {}).", conf.port, conf.pid)),
|
||||
@@ -124,6 +126,8 @@ pub struct FileProblem {
|
||||
pub fn verify_managed(root: &Path, meta: &InstallMeta) -> Vec<FileProblem> {
|
||||
let mut out = Vec::new();
|
||||
for (rel, want) in &meta.original_hashes {
|
||||
let lower = rel.replace('\\', "/").to_lowercase();
|
||||
if lower.starts_with("mysql/data/") || lower.starts_with("settings/") || lower.starts_with("core/configs/") && !lower.ends_with(".dist") { continue; }
|
||||
let Ok(p) = fsx::safe_join(root, rel) else { continue };
|
||||
match fsx::sha256_file(&p) {
|
||||
Err(_) => out.push(FileProblem { path: rel.clone(), kind: "missing" }),
|
||||
@@ -241,6 +245,9 @@ pub fn export_package(root: &Path, meta_dir: &Path, manager_log: &Path, meta: &I
|
||||
if let Ok(b) = fs::read(root.join("RELEASE.json")) {
|
||||
add("RELEASE.json", redact(&String::from_utf8_lossy(&b)).as_bytes())?;
|
||||
}
|
||||
if let Ok(b) = fs::read(meta_dir.join("logs/database-checks.json")) {
|
||||
add("database-checks.json", redact(&String::from_utf8_lossy(&b)).as_bytes())?;
|
||||
}
|
||||
zip.finish().map_err(|e| Error::Invalid(e.to_string()))?;
|
||||
Ok(n)
|
||||
}
|
||||
|
||||
@@ -17,6 +17,7 @@ use crate::fsx;
|
||||
pub enum Verb {
|
||||
StartAll,
|
||||
StartMysql,
|
||||
StartWorld,
|
||||
StopAll,
|
||||
}
|
||||
|
||||
@@ -25,13 +26,14 @@ impl Verb {
|
||||
match self {
|
||||
Verb::StartAll => "start-all",
|
||||
Verb::StartMysql => "start-mysql",
|
||||
Verb::StartWorld => "start-world",
|
||||
Verb::StopAll => "stop-all",
|
||||
}
|
||||
}
|
||||
|
||||
fn timeout(self) -> Duration {
|
||||
match self {
|
||||
Verb::StartAll => Duration::from_secs(420),
|
||||
Verb::StartAll | Verb::StartWorld => Duration::from_secs(420),
|
||||
Verb::StartMysql => Duration::from_secs(120),
|
||||
Verb::StopAll => Duration::from_secs(240),
|
||||
}
|
||||
@@ -83,6 +85,7 @@ pub fn run(root: &Path, verb: Verb) -> Result<DriverOutcome> {
|
||||
if crate::docker::is_docker(&root) {
|
||||
return crate::docker::run(&root, verb);
|
||||
}
|
||||
if verb == Verb::StopAll { crate::multiworld::stop(&root)?; }
|
||||
if verb == Verb::StartAll {
|
||||
crate::realms::before_start(&root)?;
|
||||
if root.join("Settings/realm-profile.json").exists() {
|
||||
@@ -146,6 +149,7 @@ pub fn run(root: &Path, verb: Verb) -> Result<DriverOutcome> {
|
||||
}
|
||||
};
|
||||
tracing::info!(?verb, ok, ?code, "driver: launcher verb finished");
|
||||
if ok && verb == Verb::StartAll { crate::multiworld::start(&root)?; }
|
||||
Ok(DriverOutcome { ok, exit_code, code, human: code.map(ErrorCode::human), output })
|
||||
}
|
||||
|
||||
|
||||
@@ -78,13 +78,21 @@ fn run_elevated(commands: &[String]) -> Result<()> {
|
||||
|
||||
/// Make sure both rules exist (adds only the missing ones) and confirm afterwards.
|
||||
pub fn ensure_rules(ports: &Ports) -> Result<Status> {
|
||||
ensure_rules_with_secondary(ports, None)
|
||||
}
|
||||
|
||||
pub fn ensure_rules_with_secondary(ports: &Ports, secondary: Option<u16>) -> Result<Status> {
|
||||
let have = status();
|
||||
let cmds = plan(ports, &have);
|
||||
let mut cmds = plan(ports, &have);
|
||||
let second_name = secondary.map(|port| format!("CoA Server Manager - Second World {port}"));
|
||||
if let (Some(port), Some(name)) = (secondary, &second_name) {
|
||||
if !rule_exists(name) { cmds.push(add_cmd(name, port)); }
|
||||
}
|
||||
if !cmds.is_empty() {
|
||||
run_elevated(&cmds)?;
|
||||
}
|
||||
let now = status();
|
||||
if now.auth && now.world {
|
||||
if now.auth && now.world && second_name.as_ref().is_none_or(|name| rule_exists(name)) {
|
||||
Ok(now)
|
||||
} else {
|
||||
Err(Error::Invalid("The firewall rules could not be confirmed after the change.".into()))
|
||||
|
||||
@@ -118,7 +118,8 @@ pub fn apply_realm_address(root: &Path, host: &str) -> Result<()> {
|
||||
}
|
||||
let db = Db::from_repack(root, Account::Admin)?;
|
||||
let realm = crate::realms::state(root)?.active.realm_id();
|
||||
db.query(&format!("UPDATE acore_auth.realmlist SET address='{host}', localAddress='{host}' WHERE id={realm};"))?;
|
||||
let where_realms = if crate::realms::state(root)?.simultaneous { "id IN (1,2)".into() } else { format!("id={realm}") };
|
||||
db.query(&format!("UPDATE acore_auth.realmlist SET address='{host}', localAddress='{host}' WHERE {where_realms};"))?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
|
||||
@@ -261,6 +261,13 @@ pub fn install_base(p: &Params, report: &dyn Fn(Step)) -> Result<Installed> {
|
||||
package::extract(&parts_dir, &m, &staging_root, &|done, total| say("Unpacking", 50 + (done * 30 / total.max(1)) as u8, None))?;
|
||||
say("Preparing database", 82, None);
|
||||
bootstrap_database(&staging_root)?;
|
||||
crate::backup::with_database(&staging_root, |db| {
|
||||
let problems = crate::schema_check::check(db, &staging_root)?;
|
||||
if let Some(p) = problems.first() {
|
||||
return Err(Error::Invalid(format!("The packaged database is incomplete: {}.{}.{}: {}.", p.database, p.table, p.column, p.detail)));
|
||||
}
|
||||
Ok(())
|
||||
})?;
|
||||
fs::remove_file(staging_root.join(MARKER))?;
|
||||
|
||||
// 4. Commit: the only moment the destination changes.
|
||||
|
||||
@@ -24,6 +24,9 @@ pub mod population;
|
||||
pub mod process;
|
||||
pub mod manifest;
|
||||
pub mod migrations;
|
||||
pub mod multiworld;
|
||||
pub mod repair;
|
||||
pub mod schema_check;
|
||||
pub mod net;
|
||||
pub mod package;
|
||||
pub mod ra;
|
||||
|
||||
@@ -123,19 +123,29 @@ pub fn status(store: &dyn Store, list: &[Migration]) -> Result<Vec<Item>> {
|
||||
Ok(list
|
||||
.iter()
|
||||
.map(|m| {
|
||||
let row = rows.iter().find(|r| r.db == m.db && r.id == m.id);
|
||||
// Manager records are appended after the core's updates table and are authoritative.
|
||||
let row = recorded(&rows, m);
|
||||
let changed = row.is_some_and(|r| hash_changed(r, m));
|
||||
Item {
|
||||
id: m.id.clone(),
|
||||
db: m.db.clone(),
|
||||
status: row.map(|r| r.status).unwrap_or(Status::Pending),
|
||||
status: if changed { Status::Failed } else { row.map(|r| r.status).unwrap_or(Status::Pending) },
|
||||
destructive: m.destructive,
|
||||
baseline: row.map(|r| r.baseline).unwrap_or(false),
|
||||
error: row.and_then(|r| r.error.clone()),
|
||||
error: if changed { Some("An already applied SQL file changed. Publish a new migration instead of replaying it.".into()) } else { row.and_then(|r| r.error.clone()) },
|
||||
}
|
||||
})
|
||||
.collect())
|
||||
}
|
||||
|
||||
fn recorded<'a>(rows: &'a [LedgerRow], m: &Migration) -> Option<&'a LedgerRow> {
|
||||
rows.iter().rev().find(|r| r.db == m.db && r.id == m.id)
|
||||
}
|
||||
|
||||
fn hash_changed(row: &LedgerRow, m: &Migration) -> bool {
|
||||
row.status == Status::Applied && row.sha256 != "0".repeat(64) && !row.sha256.eq_ignore_ascii_case(&m.sha256)
|
||||
}
|
||||
|
||||
/// Record migrations as already present without running them (adopting an existing server whose database
|
||||
/// was brought up to date by hand).
|
||||
pub fn baseline(store: &dyn Store, list: &[Migration]) -> Result<usize> {
|
||||
@@ -163,7 +173,12 @@ pub struct ApplyReport {
|
||||
pub fn apply_pending(store: &dyn Store, list: &[Migration], dir: &Path, snapshot: &dyn Fn() -> Result<String>) -> Result<ApplyReport> {
|
||||
let rows = store.load()?;
|
||||
// The list order is the release's order of application (released updates, then pending, then modules).
|
||||
let todo: Vec<&Migration> = list.iter().filter(|m| !rows.iter().any(|r| r.db == m.db && r.id == m.id && r.status == Status::Applied)).collect();
|
||||
for m in list {
|
||||
if recorded(&rows, m).is_some_and(|r| hash_changed(r, m)) {
|
||||
return Err(Error::Invalid(format!("Applied database update {} ({}) has a different checksum. A new migration is required; it was not replayed.", m.id, m.db)));
|
||||
}
|
||||
}
|
||||
let todo: Vec<&Migration> = list.iter().filter(|m| recorded(&rows, m).is_none_or(|r| r.status != Status::Applied)).collect();
|
||||
|
||||
// Resolve and verify every file before running anything.
|
||||
let mut files = Vec::new();
|
||||
@@ -254,6 +269,27 @@ mod tests {
|
||||
panic!("no snapshot expected")
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn manager_failure_overrides_an_old_core_update_record() {
|
||||
let (d, list) = setup(&[("characters", "same_id", "SELECT 1;")]);
|
||||
let store = Mem::default();
|
||||
let old = LedgerRow { db: "characters".into(), id: "same_id".into(), sha256: "0".repeat(64), status: Status::Applied, error: None, baseline: true };
|
||||
let failed = LedgerRow { sha256: list[0].sha256.clone(), status: Status::Failed, error: Some("previous failure".into()), baseline: false, ..old.clone() };
|
||||
store.rows.borrow_mut().extend([old, failed]);
|
||||
assert_eq!(status(&store, &list).unwrap()[0].status, Status::Failed);
|
||||
assert_eq!(apply_pending(&store, &list, d.path(), &no_snapshot).unwrap().applied, ["same_id"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn changed_applied_sql_is_reported_and_never_replayed() {
|
||||
let (d, list) = setup(&[("characters", "same_id", "SELECT 1;")]);
|
||||
let store = Mem::default();
|
||||
store.rows.borrow_mut().push(LedgerRow { db: "characters".into(), id: "same_id".into(), sha256: "a".repeat(64), status: Status::Applied, error: None, baseline: false });
|
||||
assert_eq!(status(&store, &list).unwrap()[0].status, Status::Failed);
|
||||
assert!(apply_pending(&store, &list, d.path(), &no_snapshot).is_err());
|
||||
assert!(store.ran.borrow().is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn applies_in_order_once_and_records_the_ledger() {
|
||||
let (d, list) = setup(&[("world", "2026_09_01_00_a", "CREATE TABLE t (id INT);"), ("world", "2026_09_02_00_b", "ALTER TABLE t ADD c INT;")]);
|
||||
|
||||
@@ -0,0 +1,160 @@
|
||||
//! A second supervised world with isolated configs, logs and ports; auth and MySQL remain shared.
|
||||
use std::{collections::BTreeMap, fs, path::{Path, PathBuf}};
|
||||
use crate::{Error, Result, fsx, realms::{self, Mode, RealmState}, driver::{self, Verb}, process::{self, ServiceState}};
|
||||
|
||||
pub fn root(main: &Path) -> PathBuf { main.join(".realms/secondary") }
|
||||
|
||||
pub fn is_running(main: &Path) -> bool {
|
||||
let second = root(main);
|
||||
if !second.exists() { return false; }
|
||||
let status = process::observe(&second, &crate::layout::read_ports(&second));
|
||||
status.world.state != ServiceState::Stopped
|
||||
|| ["supervisor", "relay"].iter().any(|n| process::read_state_record(&second, n).is_some_and(|p| process::is_alive(&p)))
|
||||
}
|
||||
|
||||
fn copy_tree(from: &Path, to: &Path) -> Result<()> {
|
||||
fs::create_dir_all(to)?;
|
||||
for entry in fs::read_dir(from)? {
|
||||
let entry = entry?;
|
||||
if entry.file_name() == "Logs" || entry.file_name() == "reports" || entry.file_name() == "__pycache__" { continue; }
|
||||
if entry.file_type()?.is_symlink() { return Err(Error::Invalid("A linked runtime file cannot be used for a second realm.".into())); }
|
||||
let target = fsx::ensure_within(to, &to.join(entry.file_name()))?;
|
||||
if entry.file_type()?.is_dir() { copy_tree(&entry.path(), &target)?; }
|
||||
else if !target.is_file() || fsx::sha256_file(&entry.path())? != fsx::sha256_file(&target)? { fs::copy(entry.path(), target)?; }
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn set_enabled(main: &Path, enabled: bool) -> Result<realms::View> {
|
||||
if enabled && !cfg!(windows) { return Err(Error::Invalid("Simultaneous realms currently require Windows.".into())); }
|
||||
if enabled {
|
||||
if !realms::view(main)?.supported { return Err(Error::Invalid("Update the server to a build with Wildcard support first.".into())); }
|
||||
secondary_launcher(&fs::read_to_string(main.join("Scripts/manage.py"))?)?;
|
||||
}
|
||||
let status = process::observe(main, &crate::layout::read_ports(main));
|
||||
if status.world.state != ServiceState::Stopped || status.auth.state != ServiceState::Stopped || is_running(main) {
|
||||
return Err(Error::Invalid("Stop both realms before changing simultaneous startup.".into()));
|
||||
}
|
||||
let original = realms::state(main)?.active;
|
||||
if enabled && !realms::state(main)?.wildcard_created {
|
||||
realms::select(main, Mode::Wildcard)?;
|
||||
if original != Mode::Wildcard { realms::select(main, original)?; }
|
||||
}
|
||||
let mut s = realms::state(main)?;
|
||||
if enabled {
|
||||
let p = crate::layout::read_ports(main);
|
||||
let mut reserved = vec![p.mysql, p.auth, p.world, p.ra];
|
||||
let mut choose = |saved: Option<u16>, near: u16| -> Result<u16> {
|
||||
if let Some(port) = saved.filter(|p| *p > 0 && !reserved.contains(p)) { reserved.push(port); return Ok(port); }
|
||||
let port = (near.saturating_add(1)..=u16::MAX).find(|p| !reserved.contains(p) && std::net::TcpListener::bind(("127.0.0.1", *p)).is_ok())
|
||||
.ok_or_else(|| Error::Invalid("No free port for the second realm.".into()))?;
|
||||
reserved.push(port); Ok(port)
|
||||
};
|
||||
s.secondary_world_port = Some(choose(s.secondary_world_port, p.world)?);
|
||||
s.secondary_ra_port = Some(choose(s.secondary_ra_port, p.ra)?);
|
||||
}
|
||||
s.simultaneous = enabled;
|
||||
fsx::atomic_write_json(&main.join("Settings/realm-profile.json"), &s)?;
|
||||
realms::view(main)
|
||||
}
|
||||
|
||||
fn prepare(main: &Path) -> Result<PathBuf> {
|
||||
if is_running(main) { return Err(Error::Invalid("The second realm is still running; stop it before preparing its files.".into())); }
|
||||
let s = realms::state(main)?;
|
||||
let mode = if s.active == Mode::Coa { Mode::Wildcard } else { Mode::Coa };
|
||||
let second = fsx::ensure_within(main, &root(main))?;
|
||||
for folder in ["Runtime", "BugReport", "mysql/bin"] { copy_tree(&main.join(folder), &fsx::ensure_within(&second, &second.join(folder))?)?; }
|
||||
if main.join("Core/reference").is_dir() { copy_tree(&main.join("Core/reference"), &fsx::ensure_within(&second, &second.join("Core/reference"))?)?; }
|
||||
for entry in fs::read_dir(main.join("Core"))? {
|
||||
let entry = entry?;
|
||||
if entry.file_type()?.is_file() && (entry.file_name() == "worldserver.exe" || entry.path().extension().is_some_and(|x| x == "dll")) {
|
||||
fs::create_dir_all(second.join("Core"))?;
|
||||
fs::copy(entry.path(), fsx::ensure_within(&second, &second.join("Core").join(entry.file_name()))?)?;
|
||||
}
|
||||
}
|
||||
let files: BTreeMap<String, Vec<u8>> = fsx::read_json(&main.join(format!("Settings/realm-profiles/{}.json", mode.name())))?;
|
||||
// A previous secondary run may have used the other realm's module files.
|
||||
for path in crate::backup::config_files(&second) {
|
||||
if path.starts_with("Core/configs/") && path.ends_with(".conf") && !files.contains_key(&path) {
|
||||
fs::remove_file(fsx::ensure_within(&second, &fsx::safe_join(&second, &path)?)?)?;
|
||||
}
|
||||
}
|
||||
for (path, bytes) in files {
|
||||
if !(path.starts_with("Core/configs/") && path.ends_with(".conf") || path.starts_with("Settings/") && path.ends_with(".template")) {
|
||||
return Err(Error::Invalid("Invalid secondary realm configuration path.".into()));
|
||||
}
|
||||
let text = String::from_utf8(bytes).map_err(|_| Error::Invalid("Invalid realm config encoding.".into()))?;
|
||||
let shared = main.to_string_lossy().replace('\\', "/");
|
||||
let text = text.replace("@DATA@", &format!("{shared}/Data"))
|
||||
.replace("@ASCENSION_DBC@", &format!("{shared}/Data/dbc/Ascension"))
|
||||
.replace("@MYSQL_EXE@", &format!("{shared}/mysql/bin/mysql.exe"));
|
||||
let text = if path == "Settings/worldserver.conf.template" {
|
||||
let main_conf = crate::config::parser::ConfFile::parse_bytes(&fs::read(main.join(&path))?)?;
|
||||
let mut other_conf = crate::config::parser::ConfFile::parse_bytes(text.as_bytes())?;
|
||||
if let Some(bind) = main_conf.get("BindIP") { other_conf.set("BindIP", bind, &[]); }
|
||||
other_conf.set("Ra.IP", "\"127.0.0.1\"", &[]);
|
||||
other_conf.to_text()
|
||||
} else if path == "Core/configs/modules/coa.conf" {
|
||||
let mut conf = crate::config::parser::ConfFile::parse_bytes(text.as_bytes())?;
|
||||
if crate::friends::bind_is_open(main) { conf.set("CoA.AllowRemoteClients", "1", &[]); }
|
||||
conf.to_text()
|
||||
} else { text };
|
||||
fsx::atomic_write(&fsx::ensure_within(&second, &fsx::safe_join(&second, &path)?)?, text.as_bytes())?;
|
||||
}
|
||||
let mut cfg: serde_json::Value = fsx::read_json(&main.join("Settings/repack.json"))?;
|
||||
cfg["worldPort"] = s.secondary_world_port.ok_or_else(|| Error::Invalid("Second realm world port is missing.".into()))?.into();
|
||||
cfg["raPort"] = s.secondary_ra_port.ok_or_else(|| Error::Invalid("Second realm console port is missing.".into()))?.into();
|
||||
fsx::atomic_write_json(&second.join("Settings/repack.json"), &cfg)?;
|
||||
fsx::atomic_write(&second.join("Settings/database.json"), &fs::read(main.join("Settings/database.json"))?)?;
|
||||
fsx::atomic_write_json(&second.join("Settings/realm-profile.json"), &RealmState { active: mode, wildcard_created: true, ..Default::default() })?;
|
||||
let source = fs::read_to_string(main.join("Scripts/manage.py"))?;
|
||||
let source = secondary_launcher(&source)?;
|
||||
fsx::atomic_write(&second.join("Scripts/manage.py"), source.as_bytes())?;
|
||||
Ok(second)
|
||||
}
|
||||
|
||||
fn secondary_launcher(source: &str) -> Result<String> {
|
||||
let marker = "def start_world(config, offset):\n start_mysql(config)";
|
||||
let source = source.replace("\r\n", "\n");
|
||||
if !source.contains(marker) { return Err(Error::Invalid("The launcher does not support a shared database world. Update the server first.".into())); }
|
||||
Ok(source.replace(marker, "def start_world(config, offset):\n mysql(admin=\"ping\")"))
|
||||
}
|
||||
|
||||
pub fn start(main: &Path) -> Result<()> {
|
||||
if !realms::state(main)?.simultaneous { return Ok(()); }
|
||||
if is_running(main) {
|
||||
let second = root(main);
|
||||
if process::observe(&second, &crate::layout::read_ports(&second)).world.state == ServiceState::Running { return Ok(()); }
|
||||
return Err(Error::Invalid("The second realm is still starting or stopping.".into()));
|
||||
}
|
||||
let second = prepare(main)?;
|
||||
let out = driver::run(&second, Verb::StartWorld)?;
|
||||
if !out.ok { return Err(Error::Invalid(format!("The second realm did not start: {}", out.output))); }
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn stop(main: &Path) -> Result<()> {
|
||||
let second = root(main);
|
||||
if !second.join("Scripts/manage.py").exists() {
|
||||
if is_running(main) { return Err(Error::Invalid("The running second realm's launcher is missing. The shared database was left running.".into())); }
|
||||
return Ok(());
|
||||
}
|
||||
// Its state has no auth/MySQL records: the shared database remains up until the primary world stops.
|
||||
if is_running(main) {
|
||||
let out = driver::run(&second, Verb::StopAll)?;
|
||||
if !out.ok || is_running(main) { return Err(Error::Invalid(format!("The second realm could not stop; the database was left running: {}", out.output))); }
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
#[test]
|
||||
fn secondary_never_starts_the_shared_database() {
|
||||
let patched = secondary_launcher("def start_world(config, offset):\r\n start_mysql(config)\r\n wait_ready('world', 8086)\r\n").unwrap();
|
||||
assert!(patched.contains("mysql(admin=\"ping\")"));
|
||||
assert!(!patched.contains("start_mysql(config)"));
|
||||
assert!(secondary_launcher("def start_world(): pass").is_err());
|
||||
}
|
||||
}
|
||||
@@ -23,6 +23,7 @@ pub const BOOTSTRAP_CREDENTIALS: &str = "Settings/database.bootstrap.json";
|
||||
|
||||
/// Files that never belong in a shipped package: per-install state, logs, secrets, old binaries.
|
||||
pub fn excluded(rel: &str) -> bool {
|
||||
if rel.replace('\\', "/").to_lowercase().starts_with(".realms/") { return true; }
|
||||
let l = rel.to_lowercase();
|
||||
let name = l.rsplit('/').next().unwrap_or("");
|
||||
l.starts_with(".state/")
|
||||
|
||||
@@ -61,6 +61,7 @@ pub struct Observed {
|
||||
pub mysql: ServiceStatus,
|
||||
pub auth: ServiceStatus,
|
||||
pub world: ServiceStatus,
|
||||
pub secondary_world: Option<ServiceStatus>,
|
||||
}
|
||||
|
||||
pub fn read_state_record(root: &Path, name: &str) -> Option<ProcessIdentity> {
|
||||
@@ -298,10 +299,15 @@ pub fn observe(root: &Path, ports: &Ports) -> Observed {
|
||||
}
|
||||
let listen = listeners();
|
||||
let (world, auth, mysql) = crate::layout::executables(root);
|
||||
let secondary = crate::multiworld::root(root);
|
||||
let secondary_world = if crate::realms::state(root).is_ok_and(|s| s.simultaneous) || crate::multiworld::is_running(root) {
|
||||
Some(service(&secondary, "world-secondary", secondary.join("Core/worldserver.exe"), crate::layout::read_ports(&secondary).world, &listen))
|
||||
} else { None };
|
||||
Observed {
|
||||
mysql: service(root, "mysql", mysql, ports.mysql, &listen),
|
||||
auth: service(root, "auth", auth, ports.auth, &listen),
|
||||
world: service(root, "world", world, ports.world, &listen),
|
||||
secondary_world,
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -41,6 +41,12 @@ impl Mode {
|
||||
pub struct RealmState {
|
||||
pub active: Mode,
|
||||
pub wildcard_created: bool,
|
||||
#[serde(default)]
|
||||
pub simultaneous: bool,
|
||||
#[serde(default)]
|
||||
pub secondary_world_port: Option<u16>,
|
||||
#[serde(default)]
|
||||
pub secondary_ra_port: Option<u16>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize)]
|
||||
@@ -49,6 +55,9 @@ pub struct View {
|
||||
pub wildcard_created: bool,
|
||||
pub supported: bool,
|
||||
pub recovery_pending: bool,
|
||||
pub simultaneous: bool,
|
||||
pub secondary_world_port: Option<u16>,
|
||||
pub secondary_running: bool,
|
||||
}
|
||||
|
||||
pub fn state(root: &Path) -> Result<RealmState> {
|
||||
@@ -61,7 +70,7 @@ pub fn view(root: &Path) -> Result<View> {
|
||||
// Inspect the binary itself; templates or an old log cannot prove installed support.
|
||||
let supported = fs::read(root.join("Core/worldserver.exe"))?
|
||||
.windows(b"Wildcard synergy settings".len()).any(|w| w == b"Wildcard synergy settings");
|
||||
Ok(View { active: s.active, wildcard_created: s.wildcard_created, supported, recovery_pending: root.join(JOURNAL).exists() })
|
||||
Ok(View { active: s.active, wildcard_created: s.wildcard_created, supported, recovery_pending: root.join(JOURNAL).exists(), simultaneous: s.simultaneous, secondary_world_port: s.secondary_world_port, secondary_running: crate::multiworld::is_running(root) })
|
||||
}
|
||||
|
||||
pub fn guard_module(root: &Path, id: &str) -> Result<()> {
|
||||
@@ -138,7 +147,7 @@ struct Journal { before: RealmState, files: Files }
|
||||
|
||||
fn require_world_stopped(root: &Path) -> Result<()> {
|
||||
let observed = process::observe(root, &layout::read_ports(root));
|
||||
if observed.world.state != process::ServiceState::Stopped || observed.auth.state != process::ServiceState::Stopped {
|
||||
if observed.world.state != process::ServiceState::Stopped || observed.auth.state != process::ServiceState::Stopped || crate::multiworld::is_running(root) {
|
||||
return Err(Error::Invalid("Stop the server before switching realms. Your characters will be saved.".into()));
|
||||
}
|
||||
Ok(())
|
||||
@@ -258,11 +267,22 @@ pub fn prepare_launcher(root: &Path) -> Result<()> {
|
||||
let path = root.join("Scripts/manage.py");
|
||||
let source = fs::read_to_string(&path)?;
|
||||
let patched = patch_launcher(&source)?;
|
||||
if patched != source { fsx::atomic_write(&path, patched.as_bytes())?; }
|
||||
if patched != source {
|
||||
fsx::atomic_write(&path, patched.as_bytes())?;
|
||||
// A Manager-owned transformation is still pristine for subsequent updates and file checks.
|
||||
if let Ok(dir) = crate::registry::metadata_dir_for(root) {
|
||||
if let Ok((_, mut meta)) = crate::registry::MetaDir::open(&dir) {
|
||||
if meta.original_hashes.get("Scripts/manage.py").is_some_and(|hash| hash == &fsx::sha256_bytes(source.as_bytes())) {
|
||||
meta.original_hashes.insert("Scripts/manage.py".into(), fsx::sha256_bytes(patched.as_bytes()));
|
||||
fsx::atomic_write_json(&dir.join("install.json"), &meta)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn patch_launcher(source: &str) -> Result<String> {
|
||||
pub(crate) fn patch_launcher(source: &str) -> Result<String> {
|
||||
if source.contains("# coa-manager-realm-profiles-v1") { return Ok(source.into()); }
|
||||
let replacements = [
|
||||
("(\"WorldDatabaseInfo\", \"acore_world\")", "(\"WorldDatabaseInfo\", \"acore_world_wildcard\" if coa_realm() == 'wildcard' else \"acore_world\")"),
|
||||
@@ -288,6 +308,8 @@ pub fn before_start(root: &Path) -> Result<()> {
|
||||
let s = state(root)?;
|
||||
if !root.join(STATE).exists() { return Ok(()); }
|
||||
prepare_launcher(root)?;
|
||||
if s.simultaneous && !view(root)?.supported { return Err(Error::Invalid("The installed server build does not support simultaneous Wildcard startup.".into())); }
|
||||
if s.simultaneous { fsx::atomic_write_json(&snapshot(root, s.active), &configs(root)?)?; }
|
||||
if s.active == Mode::Wildcard {
|
||||
if !view(root)?.supported { return Err(Error::Invalid("The installed server build does not support Wildcard.".into())); }
|
||||
let path = root.join("Core/configs/modules/mod_coa_playerbots.conf");
|
||||
@@ -304,6 +326,11 @@ pub fn setup_realmlist(root: &Path) -> Result<()> {
|
||||
let db = Db::from_repack(root, Account::Admin)?;
|
||||
let port = layout::read_ports(root).world;
|
||||
db.query(&format!("INSERT INTO acore_auth.realmlist (id,name,address,localAddress,localSubnetMask,port,icon,flag,timezone,gamebuild) SELECT 2,'Wildcard',address,localAddress,localSubnetMask,{port},icon,2,timezone,gamebuild FROM acore_auth.realmlist WHERE id=1 ON DUPLICATE KEY UPDATE port={port}; UPDATE acore_auth.realmlist SET flag=2 WHERE id IN (1,2) AND id<>{};", s.active.realm_id()))?;
|
||||
if s.simultaneous {
|
||||
let second = s.secondary_world_port.ok_or_else(|| Error::Invalid("Second realm port is missing.".into()))?;
|
||||
let (coa, wildcard) = if s.active == Mode::Coa { (port, second) } else { (second, port) };
|
||||
db.query(&format!("UPDATE acore_auth.realmlist SET port=CASE id WHEN 1 THEN {coa} ELSE {wildcard} END,flag=0 WHERE id IN (1,2);"))?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -358,7 +385,7 @@ mod tests {
|
||||
#[test]
|
||||
fn wildcard_blocks_bot_settings_and_enable_calls() {
|
||||
let t = tempfile::tempdir().unwrap();
|
||||
fsx::atomic_write_json(&t.path().join(STATE), &RealmState { active: Mode::Wildcard, wildcard_created: true }).unwrap();
|
||||
fsx::atomic_write_json(&t.path().join(STATE), &RealmState { active: Mode::Wildcard, wildcard_created: true, ..Default::default() }).unwrap();
|
||||
assert!(crate::modules::set_enabled(t.path(), t.path(), "companions", true).is_err());
|
||||
assert!(crate::config::save(t.path(), t.path(), crate::config::Scope::Bots, &BTreeMap::new()).is_err());
|
||||
assert!(guard_module(t.path(), "content-scaling").is_ok());
|
||||
@@ -368,4 +395,28 @@ mod tests {
|
||||
fn unknown_launcher_is_refused_without_partial_patching() {
|
||||
assert!(patch_launcher("print('custom launcher')").is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn managed_launcher_patch_remains_pristine_but_external_edits_conflict() {
|
||||
let d = tempfile::tempdir().unwrap();
|
||||
let root = d.path().join("server");
|
||||
let source = "(\"WorldDatabaseInfo\", \"acore_world\")\n(\"CharacterDatabaseInfo\", \"acore_characters\")\nSET name='AzerothCore',address=\nWHERE id=1;\nmysql(\"UPDATE acore_auth.realmlist SET flag=0\nif __name__ == \"__main__\":\n";
|
||||
fsx::atomic_write(&root.join("Scripts/manage.py"), source.as_bytes()).unwrap();
|
||||
let mut meta = crate::registry::InstallMeta::new(crate::registry::InstallKind::New, &root);
|
||||
meta.original_hashes.insert("Scripts/manage.py".into(), fsx::sha256_bytes(source.as_bytes()));
|
||||
let dir = crate::registry::MetaDir::create(&root, &meta).unwrap();
|
||||
prepare_launcher(&root).unwrap();
|
||||
let (_, meta) = crate::registry::MetaDir::open(&dir.root).unwrap();
|
||||
assert!(crate::diag::verify_managed(&root, &meta).is_empty());
|
||||
let manifest: crate::manifest::Manifest = serde_json::from_value(serde_json::json!({
|
||||
"schema": 1, "kind": "update", "version": "2.0.0", "core": {"commit": null}, "builtAt": "fixture", "minManagerVersion": "0.1.0",
|
||||
"files": [{"path":"Scripts/manage.py","sha256":fsx::sha256_bytes(b"next release"),"size":12,"owner":"core","policy":"replace"}]
|
||||
})).unwrap();
|
||||
assert_eq!(crate::update::plan(&root, &meta, &manifest, &BTreeMap::new(), None).unwrap()[0].action, crate::update::Action::Replace);
|
||||
let mut modified = fs::read(root.join("Scripts/manage.py")).unwrap();
|
||||
modified.extend_from_slice(b"# custom edit\n");
|
||||
fsx::atomic_write(&root.join("Scripts/manage.py"), &modified).unwrap();
|
||||
prepare_launcher(&root).unwrap();
|
||||
assert_eq!(crate::update::plan(&root, &meta, &manifest, &BTreeMap::new(), None).unwrap()[0].action, crate::update::Action::Conflict);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,182 @@
|
||||
//! 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 env = RepackEnv { root, meta_dir: dir };
|
||||
env.ensure_stopped()?;
|
||||
if crate::update::unfinished(dir).is_some() { return Err(Error::Invalid("Resolve the unfinished update before repairing the server.".into())); }
|
||||
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;
|
||||
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);
|
||||
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())),
|
||||
};
|
||||
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)?;
|
||||
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());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,83 @@
|
||||
//! Read-only database structure checks. A release can ship a contract captured from its clean database.
|
||||
use std::collections::{BTreeMap, BTreeSet};
|
||||
use std::path::Path;
|
||||
use serde::{Deserialize, Serialize};
|
||||
use crate::{db::Db, error::Result, fsx};
|
||||
|
||||
pub const CONTRACT: &str = "Scripts/database-schema.json";
|
||||
type Columns = BTreeMap<String, BTreeMap<String, BTreeMap<String, String>>>;
|
||||
|
||||
#[derive(Debug, Serialize, Deserialize)]
|
||||
pub struct Contract {
|
||||
pub schema: u32,
|
||||
pub columns: Columns,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize)]
|
||||
pub struct Problem { pub database: String, pub table: String, pub column: String, pub detail: String }
|
||||
|
||||
fn read_columns(db: &Db, kind: &str) -> Result<BTreeMap<String, BTreeMap<String, String>>> {
|
||||
let schema = db.realm_schema(crate::db::schema_of(kind)?);
|
||||
let text = db.query(&format!("SELECT TABLE_NAME,COLUMN_NAME,CONCAT(COLUMN_TYPE,'|',IS_NULLABLE,'|',IF(COLUMN_DEFAULT IS NULL,'<NULL>',HEX(COLUMN_DEFAULT)),'|',IF(EXTRA='','<NONE>',HEX(EXTRA))) FROM information_schema.COLUMNS WHERE TABLE_SCHEMA='{schema}' ORDER BY TABLE_NAME,ORDINAL_POSITION;"))?;
|
||||
let mut tables: BTreeMap<String, BTreeMap<String, String>> = BTreeMap::new();
|
||||
for line in text.lines() {
|
||||
let fields: Vec<_> = line.split('\t').collect();
|
||||
if fields.len() == 3 { tables.entry(fields[0].into()).or_default().insert(fields[1].into(), fields[2].into()); }
|
||||
}
|
||||
Ok(tables)
|
||||
}
|
||||
|
||||
pub fn capture(db: &Db, root: &Path) -> Result<()> {
|
||||
let mut columns = Columns::new();
|
||||
for kind in ["auth", "characters", "world"] { columns.insert(kind.into(), read_columns(db, kind)?); }
|
||||
fsx::atomic_write_json(&root.join(CONTRACT), &Contract { schema: 1, columns })
|
||||
}
|
||||
|
||||
pub fn check(db: &Db, root: &Path) -> Result<Vec<Problem>> {
|
||||
let contract = if root.join(CONTRACT).is_file() {
|
||||
let contract: Contract = fsx::read_json(&root.join(CONTRACT))?;
|
||||
if contract.schema != 1 { return Err(crate::Error::Invalid("Unsupported database schema contract.".into())); }
|
||||
contract
|
||||
} else {
|
||||
// Older packages have no full contract. Check the columns used by initial character saves.
|
||||
let tables: BTreeMap<String, Vec<String>> = serde_json::from_str(include_str!("character-save-columns.json"))?;
|
||||
Contract { schema: 1, columns: BTreeMap::from([("characters".into(), tables.into_iter().map(|(t, cols)| (t, cols.into_iter().map(|c| (c, String::new())).collect())).collect())]) }
|
||||
};
|
||||
let mut problems = Vec::new();
|
||||
for (kind, expected) in &contract.columns {
|
||||
let actual = read_columns(db, kind)?;
|
||||
for (table, cols) in expected {
|
||||
if matches!(table.as_str(), "updates" | "updates_include" | "coa_manager_migrations") { continue; }
|
||||
if !actual.contains_key(table) {
|
||||
problems.push(Problem { database: kind.clone(), table: table.clone(), column: String::new(), detail: "Missing table".into() });
|
||||
continue;
|
||||
}
|
||||
for (column, want) in cols {
|
||||
let found = actual[table].get(column);
|
||||
if found.is_none() || (!want.is_empty() && found != Some(want)) {
|
||||
problems.push(Problem { database: kind.clone(), table: table.clone(), column: column.clone(), detail: found.map(|s| format!("Expected {want}, found {s}")).unwrap_or_else(|| "Missing column".into()) });
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
// A custom NOT NULL column without a default can reject every INSERT even when all standard columns exist.
|
||||
let supplied: BTreeMap<String, Vec<String>> = serde_json::from_str(include_str!("character-save-columns.json"))?;
|
||||
let schema = db.realm_schema("acore_characters");
|
||||
let required = db.query(&format!("SELECT TABLE_NAME,COLUMN_NAME FROM information_schema.COLUMNS WHERE TABLE_SCHEMA='{schema}' AND IS_NULLABLE='NO' AND COLUMN_DEFAULT IS NULL AND EXTRA NOT LIKE '%auto_increment%' AND EXTRA NOT LIKE '%GENERATED%';"))?;
|
||||
for (table, column) in required.lines().filter_map(|l| l.split_once('\t')) {
|
||||
if supplied.get(table).is_some_and(|cols| !cols.iter().any(|c| c == column)) {
|
||||
problems.push(Problem { database: "characters".into(), table: table.into(), column: column.into(), detail: "Required column has no default and is not supplied by character creation".into() });
|
||||
}
|
||||
}
|
||||
// Check every CoA class represented in the starting data, rather than one arbitrary pair.
|
||||
if db.realm() == crate::realms::Mode::Coa {
|
||||
let rows = db.query("SELECT race,class FROM acore_world.playercreateinfo;")?;
|
||||
let pairs: BTreeSet<_> = rows.lines().filter_map(|l| l.split_once('\t')).map(|(a,b)| (a.to_owned(),b.to_owned())).collect();
|
||||
for class in 12..=32 {
|
||||
if !pairs.iter().any(|(_, c)| c == &class.to_string()) {
|
||||
problems.push(Problem { database: "world".into(), table: "playercreateinfo".into(), column: String::new(), detail: format!("No starting data for CoA class {class}") });
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(problems)
|
||||
}
|
||||
@@ -330,7 +330,14 @@ pub fn apply(p: &Params, report: &dyn Fn(&str, u8)) -> Result<Outcome> {
|
||||
meta.core.version = Some(m.version.clone());
|
||||
meta.core.commit = m.core.commit.clone().or(meta.core.commit);
|
||||
for op in &txn.ops {
|
||||
meta.original_hashes.insert(op.path.clone(), op.new_sha256.clone());
|
||||
let hash = if op.path == "Scripts/manage.py" {
|
||||
let staged = fs::read_to_string(tree.join(&op.path)).ok().and_then(|s| crate::realms::patch_launcher(&s).ok());
|
||||
match (staged, fs::read(root.join(&op.path))) {
|
||||
(Some(expected), Ok(actual)) if expected.as_bytes() == actual => fsx::sha256_bytes(&actual),
|
||||
_ => op.new_sha256.clone(),
|
||||
}
|
||||
} else { op.new_sha256.clone() };
|
||||
meta.original_hashes.insert(op.path.clone(), hash);
|
||||
if !meta.managed_files.contains(&op.path) {
|
||||
meta.managed_files.push(op.path.clone());
|
||||
}
|
||||
@@ -462,7 +469,7 @@ impl Env for RepackEnv<'_> {
|
||||
fn ensure_stopped(&self) -> Result<()> {
|
||||
use crate::process::{observe, ServiceState};
|
||||
let o = observe(self.root, &crate::layout::read_ports(self.root));
|
||||
if o.world.state != ServiceState::Stopped || o.auth.state != ServiceState::Stopped {
|
||||
if o.world.state != ServiceState::Stopped || o.auth.state != ServiceState::Stopped || crate::multiworld::is_running(self.root) {
|
||||
return Err(Error::Invalid("Stop the server before updating it; files cannot be replaced while it is running.".into()));
|
||||
}
|
||||
Ok(())
|
||||
@@ -492,6 +499,17 @@ impl Env for RepackEnv<'_> {
|
||||
result.applied.extend(extra.applied);
|
||||
result.failed = extra.failed;
|
||||
if result.snapshot.is_none() { result.snapshot = extra.snapshot; }
|
||||
if result.failed.is_none() {
|
||||
if let Some(p) = crate::schema_check::check(&other_db, root)?.first() {
|
||||
return Err(Error::Invalid(format!("Database validation failed on {}: {}.{}: {}", other.name(), p.table, p.column, p.detail)));
|
||||
}
|
||||
}
|
||||
}
|
||||
if result.failed.is_none() {
|
||||
let problems = crate::schema_check::check(db, root)?;
|
||||
if let Some(p) = problems.first() {
|
||||
return Err(Error::Invalid(format!("Database validation failed: {}.{}.{}: {} ({} problems).", p.database, p.table, p.column, p.detail, problems.len())));
|
||||
}
|
||||
}
|
||||
Ok(result)
|
||||
})
|
||||
@@ -516,7 +534,7 @@ impl Env for RepackEnv<'_> {
|
||||
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(180);
|
||||
loop {
|
||||
let o = observe(self.root, &ports);
|
||||
if o.mysql.state == ServiceState::Running && o.auth.state == ServiceState::Running && o.world.state == ServiceState::Running {
|
||||
if o.mysql.state == ServiceState::Running && o.auth.state == ServiceState::Running && o.world.state == ServiceState::Running && o.secondary_world.as_ref().is_none_or(|s| s.state == ServiceState::Running) {
|
||||
break true;
|
||||
}
|
||||
if std::time::Instant::now() > deadline {
|
||||
|
||||
@@ -44,6 +44,12 @@ fn run() -> Result<(), String> {
|
||||
let e = |x: coa_core::Error| x.to_string();
|
||||
let part = a.get("part-size").and_then(|v| v.parse().ok()).unwrap_or(DEFAULT_PART_SIZE);
|
||||
match cmd.as_str() {
|
||||
"schema-contract" => {
|
||||
let repack = PathBuf::from(need(&a, "repack")?);
|
||||
let tree = PathBuf::from(need(&a, "tree")?);
|
||||
coa_core::backup::with_database(&repack, |db| coa_core::schema_check::capture(db, &tree)).map_err(e)?;
|
||||
println!("database schema contract captured");
|
||||
}
|
||||
"pack-base" => {
|
||||
let opts = BuildOptions { kind: Kind::Base, version: need(&a, "version")?.clone(), core_commit: a.get("core-commit").cloned(), built_at: chrono_now(), part_size: part, bots_commit: a.get("bots-commit").cloned(), migrations: vec![] };
|
||||
let m = build(&PathBuf::from(need(&a, "tree")?), &PathBuf::from(need(&a, "out")?), &opts, &|s| eprintln!("{s}")).map_err(e)?;
|
||||
|
||||
Reference in new issue
Block a user