Compare commits

...
43 changed files with 1289 additions and 78 deletions

No files matched your search

Generated
+3 -3
View File
@@ -491,7 +491,7 @@ dependencies = [
[[package]]
name = "coa-core"
version = "0.6.16"
version = "0.6.18"
dependencies = [
"base64 0.22.1",
"chrono",
@@ -520,7 +520,7 @@ dependencies = [
[[package]]
name = "coa-release"
version = "0.6.16"
version = "0.6.18"
dependencies = [
"chrono",
"coa-core",
@@ -529,7 +529,7 @@ dependencies = [
[[package]]
name = "coa-server-manager"
version = "0.6.16"
version = "0.6.18"
dependencies = [
"coa-core",
"serde",
+1 -1
View File
@@ -3,7 +3,7 @@ resolver = "2"
members = ["crates/coa-core", "crates/coa-release", "src-tauri"]
[workspace.package]
version = "0.6.16"
version = "0.6.18"
edition = "2021"
license = "AGPL-3.0-only"
@@ -0,0 +1,7 @@
---
area: manager
type: fixed
audience: admins
title: Already running MySQL is recognized before startup readiness checks
---
A verified MySQL listener replaces a stale or supervisor-only launcher record before startup. Existing databases are reused instead of waiting for a port owned by a different process from the same executable.
@@ -0,0 +1,7 @@
---
area: manager
type: changed
audience: admins
title: New servers install the current stable build directly
---
A clean installation downloads the complete package of the selected stable release, including its prepared database. It no longer installs an old base and asks for a separate update. Missing or mismatched full packages stop installation before changing the destination.
@@ -0,0 +1,7 @@
---
area: manager
type: changed
audience: players
title: Install the matching client patches for Grummle
---
Custom race installation includes the new Grummle appearance and voices while retaining the existing race assets. Older installations can still be safely switched off or removed.
@@ -0,0 +1,7 @@
---
area: manager
type: fixed
audience: admins
title: Failed repairs restore the previous server after final verification errors
---
Errors after file replacement now undo the repair using its verified recovery point, including final file or database check errors. If recovery fails, the journal retains the cause and further server actions remain blocked.
@@ -0,0 +1,7 @@
---
area: manager
type: fixed
audience: admins
title: Failed server updates show an error on the Overview screen
---
The error stays visible after the progress bar disappears, with technical details and a copy button. Recovery-state errors are shown there too.
@@ -0,0 +1,7 @@
---
area: manager
type: changed
audience: admins
title: Private update checks show preparation stages and stop failure details
---
Private-copy preparation reports checked and copied file counts, database tests and startup stages. Failed shutdown reports the server folder, remaining processes and launcher reason. Port conflicts identify the owning process and executable.
@@ -0,0 +1,7 @@
---
area: manager
type: fixed
audience: admins
title: Repair recovery copies preserve all bundled database objects and accounts
---
Windows repairs now save a verified copy of stopped MySQL before changing server files or SQL. Recovery preserves procedures, triggers, views and database accounts as well as player rows.
@@ -0,0 +1,7 @@
---
area: manager
type: fixed
audience: admins
title: Server checks report interrupted SQUID database imports
---
Check and Repair now report SQUID pending imports and missing bot character tables separately from package migrations. Interrupted imports retain their records and require verified database recovery.
@@ -0,0 +1,7 @@
---
area: manager
type: fixed
audience: admins
title: Shutdown remains available when startup templates or database records are damaged
---
Stop uses existing shutdown settings instead of rendering startup templates. Missing or stale MySQL records are recovered only from the exact installed executable and its owned port; foreign processes are never adopted.
@@ -0,0 +1,7 @@
---
area: manager
type: fixed
audience: admins
title: Successful server repairs no longer block later server actions
---
Repair verifies restored files before completing its recovery record. Older completed repair records are accepted only when every repaired file still matches its expected content.
@@ -0,0 +1,7 @@
---
area: manager
type: fixed
audience: admins
title: Older servers find a tested intermediate update instead of being blocked
---
When the latest release cannot update an older server directly, Manager offers a signed intermediate release from its compatibility matrix and explains how to continue to the latest version.
+1 -1
View File
@@ -336,7 +336,7 @@ pub fn create(root: &Path, meta: &Path, kind: Kind, trigger: Trigger, label: Opt
return Err(e);
}
};
let mysql_snapshot = if kind == Kind::Full && trigger == Trigger::BeforeUpdate && cfg!(windows) && !crate::docker::is_docker(root) {
let mysql_snapshot = if kind == Kind::Full && matches!(trigger, Trigger::BeforeUpdate | Trigger::BeforeRepair) && cfg!(windows) && !crate::docker::is_docker(root) {
progress("Saving a complete stopped MySQL recovery copy");
match crate::mysql_snapshot::capture(root, &partial) {
Ok(snapshot) => Some(snapshot),
+1 -1
View File
@@ -24,7 +24,7 @@ pub struct Params<'a> {
}
/// Auth tables that hold player data. Everything else (permissions, build info, realmlist) is configuration.
const AUTH_PLAYER_TABLES: [&str; 11] =
pub(crate) const AUTH_PLAYER_TABLES: [&str; 11] =
["account", "account_access", "account_banned", "account_muted", "account_password_history", "ip_banned", "logs", "logs_ip_actions", "realmcharacters", "uptime", "rbac_account_permissions"];
fn copy_dir(src: &Path, dst: &Path, skip: &dyn Fn(&str) -> bool, base: &Path) -> Result<u64> {
+25 -3
View File
@@ -14,7 +14,7 @@ use crate::download::Cancel;
use crate::error::{Error, Result};
use crate::fsx;
pub const CLIENT_VERSION: &str = "1.6";
pub const CLIENT_VERSION: &str = "1.7";
pub const MANIFEST_FILENAME: &str = "custom_races_patch_manifest.txt";
pub const ARCHIVES: &[(&str, &str)] = &[
(
@@ -29,6 +29,10 @@ pub const ARCHIVES: &[(&str, &str)] = &[
"CoA-Custom-1.6-client-part2.zip",
"https://github.com/ilusixn/azerothcore-wotlk-coa/releases/download/coa-custom-1.6/CoA-Custom-1.6-client-part2.zip",
),
(
"CoA-Custom-1.7-client.zip",
"https://github.com/ilusixn/azerothcore-wotlk-coa/releases/download/coa-custom-1.7/CoA-Custom-1.7-client.zip",
),
];
pub const RACE_MPQS: &[&str] = &[
@@ -54,6 +58,9 @@ pub const RACE_MPQS: &[&str] = &[
"patch-ZZR.MPQ",
"patch-ZZS.MPQ",
"patch-ZZT.MPQ",
"patch-ZZU.MPQ",
"patch-ZZV.MPQ",
"patch-ZZW.MPQ",
];
pub const EXCLUDED_BOT_RACES_RECOMMENDED: &str =
@@ -164,7 +171,7 @@ struct PatchFile {
fn patch_files(client: &Path) -> Result<Vec<PatchFile>> {
let manifest = fs::read_to_string(client.join(MANIFEST_FILENAME)).unwrap_or_default();
let hashes = if manifest.lines().any(|line| line == "# CoA Custom 1.5") { include_str!("custom_races_hashes_1_5.json") } else { include_str!("custom_races_hashes.json") };
let hashes = if manifest.lines().any(|line| line == "# CoA Custom 1.5") { include_str!("custom_races_hashes_1_5.json") } else if manifest.lines().any(|line| line == "# CoA Custom 1.6") { include_str!("custom_races_hashes_1_6.json") } else { include_str!("custom_races_hashes.json") };
let bundled: std::collections::BTreeMap<String, String> = serde_json::from_str(hashes)?;
let mut files = std::collections::BTreeMap::new();
for line in manifest.lines() {
@@ -367,6 +374,7 @@ fn verify_archive(path: &Path, filename: &str) -> Result<()> {
"CoA-Custom-1.6-main-20261012-4dd3a4ec.zip" => "dfe802ea70047c129ac2e0aaa557bab3110e3cc6926d36403b8c880a0e310ee4",
"CoA-Custom-1.6-client-part1.zip" => "1dbf1901ad5be61eba66973609df90712ffc78ef9e9b2c8549a5f3e36332bf12",
"CoA-Custom-1.6-client-part2.zip" => "689f7f946b4180fe977dabedc7cfe642e3e7f27431600c64c4dd5b7960b1bc66",
"CoA-Custom-1.7-client.zip" => "ad389ef486f44f269445f80807b25b214c39fc5d21272b5708bfeac8b1efefa0",
_ => return Err(Error::Invalid("Unknown custom races archive.".into())),
};
if fsx::sha256_file(path)? != expected {
@@ -666,7 +674,7 @@ mod tests {
}
#[test]
#[ignore = "Requires the three downloaded release archives"]
#[ignore = "Requires the downloaded release archives"]
fn bundled_hashes_match_verified_release_archives() {
use sha2::{Digest, Sha256};
let folder = PathBuf::from(std::env::var_os("COA_RACES_ARCHIVE_DIR").expect("COA_RACES_ARCHIVE_DIR"));
@@ -705,6 +713,20 @@ mod tests {
assert!(!files.iter().any(|file| file.path == "Data/patch-ZZS.MPQ"));
}
#[test]
fn previous_release_uses_its_own_hashes_for_upgrade_and_removal() {
let temp = tempfile::tempdir().unwrap();
fs::write(temp.path().join(MANIFEST_FILENAME), "# CoA Custom 1.6\n").unwrap();
let legacy: std::collections::BTreeMap<String, String> = serde_json::from_str(include_str!("custom_races_hashes_1_6.json")).unwrap();
let current: std::collections::BTreeMap<String, String> = serde_json::from_str(include_str!("custom_races_hashes.json")).unwrap();
let files = patch_files(temp.path()).unwrap();
assert_eq!(files.len(), legacy.len());
assert_eq!(files.iter().find(|file| file.path == "Data/patch-T.MPQ").unwrap().sha256, legacy["Data/patch-T.MPQ"]);
assert_ne!(legacy["Data/patch-T.MPQ"], current["Data/patch-T.MPQ"]);
assert!(!files.iter().any(|file| file.path == "Data/patch-ZZW.MPQ"));
assert!(legacy.keys().all(|key| current.contains_key(key)));
}
#[test]
fn another_patch_operation_cannot_enter_the_same_client() {
let temp = tempfile::tempdir().unwrap();
+5 -2
View File
@@ -27,7 +27,7 @@
"EsteriaVulpera.bin": "c5434993b9af4a17d881965e4735cd2ac379e39c7142aac9844adff9528562d4",
"EsteriaVulperaTextures.bin": "1ab844e74684aced2b069f1b91cd563aade45e05bd5e23f866a6c0c301cb098e",
"dinput8.dll": "f8de78606c241fb3911dce22faf68f5b9f9885b142b183c1e2c09ddc8f7e380c",
"Data/patch-T.MPQ": "9403e0680c74754eb0cb063718119aa6ace3616f7cecf488c8faf46f22505ae5",
"Data/patch-T.MPQ": "fe597138ab7f56881b5f4f27d6dc9d81bb278b483ca0d91b7207ffd4a5ae7bfd",
"Data/patch-ZE5.MPQ": "476b5a1fcf69f64fdb281e3b445362b936d016066ccd12f897acfcf200d6c0cf",
"Data/patch-ZE6.MPQ": "762592c9ed950b4a7b6c7d85d45050b30fa3f35d53e348ee1e1516fdbb7e5484",
"Data/patch-ZE7.MPQ": "de54b0189d242763d2872223419a259b6b8a4b380c24b50a2ef9c6fa44466248",
@@ -48,5 +48,8 @@
"Data/patch-ZZE.MPQ": "4b1e289e12c82644cb78f50170e6b5fd53918eb2de834f9e0cebddd81873a8bb",
"Data/patch-ZZR.MPQ": "5a7575e592dc0c8a6913e0d946bbe06fa0ca2e4d817ef1f8548d3d13142bcbd3",
"Data/patch-ZZS.MPQ": "533fd69d5784d83e872a5a28d27301dc9ab5d0cb925f8b2116926854e4a0a5b8",
"Data/patch-ZZT.MPQ": "aef3bbe4951333d62fb55224484724fbaa9c35773a19944ffb9935e250cfb59c"
"Data/patch-ZZT.MPQ": "aef3bbe4951333d62fb55224484724fbaa9c35773a19944ffb9935e250cfb59c",
"Data/patch-ZZU.MPQ": "8ee1839415b56d46c6eff7eb4dfbaf6fbafc4c6b29b39380d69f4d827d02a99e",
"Data/patch-ZZV.MPQ": "8d5e61d37008abf70478e5d5f46ec7afb0490b9a643323bd75a1c70cadd63290",
"Data/patch-ZZW.MPQ": "ed452a0a0118c9f4deaf02db753064ac95b6e4a84022bdabd39a7e70d775223f"
}
@@ -0,0 +1,52 @@
{
"Ascension.exe": "e2c347019d554a59639e5978fd68e50e906973ab313c6573cc56ca82e8e3c547",
"EsteriaAppearance.bin": "b3fb7c69b7600c39f888ea1925701be5667097dcb02bb6ddd830e5489306bb50",
"EsteriaAppearance.dll": "392c5a2a25f9a69d705bdf841bb899aab768d4a3ee62734d576286c7198710d8",
"EsteriaAppearanceGeometry.bin": "c95c53ca19c53c3434e12b99c1966f9c015ec3944c46dff7784d5e4ffc472d5d",
"EsteriaAppearanceMaterials.bin": "f72f027f54a55c05aa0f76b457b97b484fe0e1aedc0e068cc0e0ca53e1878cba",
"EsteriaCosmeticWings.bin": "57352c28459d073a29b3014d33b70f3b3756afa37fa9583ef6b30d503422ac3f",
"EsteriaEarthen.bin": "8a0db93ba2d5c756b44ed84f2f7bc7c15eef13be6a7d87baf1383c6c0c624e02",
"EsteriaGnoll.bin": "cfacc8e681bb8e54a4f01ee9c12a91bf0bd23a23527bb548d4dc21ec1b33eea2",
"EsteriaGnollTextures.bin": "1ba9133a75dad291d98a068b2dcde01f31a897a1764cd7f3e2c316c288a8f605",
"EsteriaHaranir.bin": "59f31d00e372fd2646e1cf0d9d3d5d671b31edd60ff7b862f8d1ce7e53ba1f2f",
"EsteriaHaranirTextures.bin": "99948ca570be2d376f0c67e3b8088739b6fa9f9d2c73985e19f68df77689a229",
"EsteriaHighmountain.bin": "e83349252ad2687ac23fcfc5623db7401cf32e5faf47a5a7be20c2f94b014938",
"EsteriaNaga.bin": "e87547cff5d09500c294f8b06935d134cdd0bbb962e294a72de09404505bd8b3",
"EsteriaNagaTextures.bin": "57ec560f99c1d48ac1e8f6a797c156513b99e7d349e3071afe405f812d159ae3",
"EsteriaSaberon.bin": "7735c9325c807c5125760d87f323d6b7d4162fb542c1d8b5f435ea2d6b9a4daa",
"EsteriaSaberonCoverage.bin": "9cdc227f08329e1245d2b864a996e7a772c96ecdbe5d81925f4d60cdbe4fa11e",
"EsteriaSaberonTextures.bin": "1ba9133a75dad291d98a068b2dcde01f31a897a1764cd7f3e2c316c288a8f605",
"EsteriaSethrak.bin": "bd14857a8c11fdf8027128763293701586b2102f9a6539d33a727014789fd606",
"EsteriaSethrakTextures.bin": "d2b2cf58087a391f00198008fe871edd400ddf28d54a3a05674df74c5198528a",
"EsteriaThinHuman.bin": "75794d192ea0c228b3da7bf7d0bdff1119f79d3f9bfef6650cd5e1a2b5d106eb",
"EsteriaThinHumanTextures.bin": "02aeb4c05893d06125b8b58fdb7c2a56fe3d66a7d094706a44b43cb503d1731e",
"EsteriaTuskarr.bin": "ecbe7ef490ba67eca029a57639192db61238522618491549766fe38529914387",
"EsteriaTuskarrTextures.bin": "e2116c2c83adea079126fd5da765d20da24f044d4f161c4124e4368cb3d6bc71",
"EsteriaVrykul.bin": "39e2b7b4c67997dbbd34bae840bd606a59290f7f2fc82565a0ba00090335415c",
"EsteriaVrykulTextures.bin": "46098750a0e235724c6e9cc8d9d4e26550aa47bef95fd5f0f82efe5e945bf296",
"EsteriaVulpera.bin": "c5434993b9af4a17d881965e4735cd2ac379e39c7142aac9844adff9528562d4",
"EsteriaVulperaTextures.bin": "1ab844e74684aced2b069f1b91cd563aade45e05bd5e23f866a6c0c301cb098e",
"dinput8.dll": "f8de78606c241fb3911dce22faf68f5b9f9885b142b183c1e2c09ddc8f7e380c",
"Data/patch-T.MPQ": "9403e0680c74754eb0cb063718119aa6ace3616f7cecf488c8faf46f22505ae5",
"Data/patch-ZE5.MPQ": "476b5a1fcf69f64fdb281e3b445362b936d016066ccd12f897acfcf200d6c0cf",
"Data/patch-ZE6.MPQ": "762592c9ed950b4a7b6c7d85d45050b30fa3f35d53e348ee1e1516fdbb7e5484",
"Data/patch-ZE7.MPQ": "de54b0189d242763d2872223419a259b6b8a4b380c24b50a2ef9c6fa44466248",
"Data/patch-ZE8.MPQ": "1bc5691fb84a84f3e7a0a70baaa9192a97b4ec5906ee37c85838ffe08adef934",
"Data/patch-ZE9.MPQ": "d49c94463e9548e76378ce2c0454d8f204f0745c8c0de32b6dce7f0b0fd67c4a",
"Data/patch-ZES.MPQ": "a2d9348f917f745c7aa25b2eed96efa312f7b2d2f62cb86a4f2eaabc2dfa895f",
"Data/patch-ZG.MPQ": "48979e1fda775f8deb47bffa48e0a468595d4c71286fee518f51dc5801c5ca39",
"Data/patch-ZH.MPQ": "5e1d2fe287053abba703d7af381e10096c6525ba477ffed3971c2fc4f93e919c",
"Data/patch-ZHM.MPQ": "317d3ae00f0bd674b358af07544976acb7804aa6d8b19d1788ad96030e8c9bf0",
"Data/patch-ZJ.MPQ": "f821e99add86ef68d108c5ec466328c97677d3ed52f7944e200f3fe38c13b4de",
"Data/patch-ZM.MPQ": "424ab1978986e854551633983a94bd15beba6328aabea8c02f98eaa32f6f0b61",
"Data/patch-ZVU.MPQ": "c679b85a2e97344395756b54d2cf6abefe4e80e74944cb55b6e573ad17b7d020",
"Data/patch-ZE1.MPQ": "69d79dbbea54ec0312c37770debc79c7bc9ce2e21eedef99c03cd8d911955283",
"Data/patch-ZE2.MPQ": "1a41cae77ad730e9cf69e8d63fd12ae3a579418bb550d351fff469573a97ac3c",
"Data/patch-ZE3.MPQ": "b587202c21b6f580682b601b7c2e905fbfa766276e74733db55c1bddbffb7f87",
"Data/patch-ZEA.MPQ": "78fd10ec5262ae2417eba9700d2172553bbc1e5cfb0b597aada8f1753ca46d9d",
"Data/patch-ZHA.MPQ": "0fc6ebeafe1d14192dc64bafc90bde3c49230df1297f98bf65900a3bcf953617",
"Data/patch-ZZE.MPQ": "4b1e289e12c82644cb78f50170e6b5fd53918eb2de834f9e0cebddd81873a8bb",
"Data/patch-ZZR.MPQ": "5a7575e592dc0c8a6913e0d946bbe06fa0ca2e4d817ef1f8548d3d13142bcbd3",
"Data/patch-ZZS.MPQ": "533fd69d5784d83e872a5a28d27301dc9ab5d0cb925f8b2116926854e4a0a5b8",
"Data/patch-ZZT.MPQ": "aef3bbe4951333d62fb55224484724fbaa9c35773a19944ffb9935e250cfb59c"
}
+53 -2
View File
@@ -144,6 +144,7 @@ fn run_inner(root: &Path, verb: Verb, validating_update: bool) -> Result<DriverO
}
}
discard_damaged_launcher_state(&root);
if matches!(verb, Verb::StopAll | Verb::StartMysql | Verb::StartAll) { recover_mysql_launcher_state(&root, verb != Verb::StopAll)?; }
let mut cmd = Command::new(&python);
cmd.arg("-B").arg("-c").arg(LAUNCH_SCRIPT).arg(&script).arg(verb.arg())
.current_dir(&root).stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::piped());
@@ -180,7 +181,7 @@ fn run_inner(root: &Path, verb: Verb, validating_update: bool) -> Result<DriverO
};
let mut output = out_t.join().unwrap_or_default();
output.push_str(&err_t.join().unwrap_or_default());
let output = output.trim().to_string();
let mut output = output.trim().to_string();
let (ok, exit_code) = match status {
Some(st) => (st.success(), st.code()),
None => (false, None),
@@ -195,6 +196,14 @@ fn run_inner(root: &Path, verb: Verb, validating_update: bool) -> Result<DriverO
other => Some(other),
}
};
if code == Some(ErrorCode::PortInUse) {
let observed = crate::process::observe(&root, &crate::layout::read_ports(&root));
for service in [&observed.mysql, &observed.auth, &observed.world].into_iter().chain(observed.secondary_world.iter()) {
if let Some(conflict) = &service.conflict {
output.push_str(&format!("\nPort {} is used by process {} ({}).", conflict.port, conflict.pid, conflict.exe.as_deref().unwrap_or("executable unavailable")));
}
}
}
tracing::info!(?verb, ok, ?code, "driver: launcher verb finished");
if !ok && !output.is_empty() {
let redacted = crate::diag::redact(&output);
@@ -245,7 +254,37 @@ pub(crate) fn discard_damaged_launcher_state(root: &Path) -> Vec<PathBuf> {
removed
}
const LAUNCH_SCRIPT: &str = "import runpy,sys;from pathlib import Path;script=sys.argv[1];sys.path.insert(0,str(Path(script).resolve().parent));sys.argv=sys.argv[1:];runpy.run_path(script,run_name='__main__')";
/// A lost launcher record must not hide this installation's running MySQL from
/// graceful shutdown. Adopt only the exact executable owning its configured port.
fn recover_mysql_launcher_state(root: &Path, prefer_listener: bool) -> Result<()> {
let observed = crate::process::observe(root, &crate::layout::read_ports(root));
if observed.mysql.state != crate::process::ServiceState::Running || !observed.mysql.port_ready { return Ok(()); }
let Some(pid) = observed.mysql.pid else { return Ok(()); };
let Some(identity) = crate::process::identity(pid) else { return Ok(()); };
let (_, _, executable) = crate::layout::executables(root);
if !crate::process::find_by_exe(&executable).iter().any(|candidate| candidate.same_as(&identity))
|| !crate::process::listeners().contains(&(observed.mysql.port, pid)) { return Ok(()); }
if let Some(saved) = crate::process::read_state_record(root, "mysql") {
if saved.same_as(&identity) { return Ok(()); }
if crate::process::is_alive(&saved) {
// A valid record may describe the MySQL supervisor rather than its
// listening child. The launcher can gracefully stop either record.
if crate::process::find_by_exe(&executable).iter().any(|candidate| candidate.same_as(&saved)) {
if !prefer_listener { return Ok(()); }
} else {
return Err(Error::Invalid("The MySQL launcher record identifies a different live process. No database action was requested.".into()));
}
}
}
let state = root.join(".state/mysql.json");
let previous = root.join(".state/mysql-before-shutdown-recovery.json");
if state.is_file() && !previous.exists() { fsx::atomic_write(&previous, &std::fs::read(&state)?)?; }
fsx::atomic_write_json(&state, &identity)?;
tracing::warn!(pid, root = %root.display(), "Recovered MySQL launcher identity from the installed executable owning its port");
Ok(())
}
const LAUNCH_SCRIPT: &str = "import runpy,sys\nfrom pathlib import Path\nscript=sys.argv[1]\nsys.path.insert(0,str(Path(script).resolve().parent))\nsys.argv=sys.argv[1:]\nif sys.argv[1]=='stop-all':\n launcher=runpy.run_path(script,run_name='coa_manager_shutdown')\n config=launcher['settings']()\n with launcher['control_lock']():\n launcher['stop_all'](config)\nelse:\n runpy.run_path(script,run_name='__main__')";
pub(crate) fn patch_launcher_imports(text: &str) -> Result<String> {
let line = "sys.path.insert(0, str(Path(__file__).resolve().parent))";
@@ -303,6 +342,18 @@ pub(crate) fn startup_failure(root: &Path, started: &DriverOutcome) -> String {
mod tests {
use super::*;
#[cfg(windows)]
#[test]
fn shutdown_recovery_never_adopts_a_foreign_port_listener() {
let root = tempfile::tempdir().unwrap();
let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
fsx::atomic_write_json(&root.path().join("Settings/repack.json"), &serde_json::json!({"mysqlPort":listener.local_addr().unwrap().port()})).unwrap();
recover_mysql_launcher_state(root.path(), false).unwrap();
recover_mysql_launcher_state(root.path(), true).unwrap();
assert!(!root.path().join(".state/mysql.json").exists());
assert!(crate::process::identity(std::process::id()).is_some());
}
#[test]
fn a_blocked_start_is_logged_before_any_launcher_is_spawned() {
use std::io::Write;
+4
View File
@@ -201,6 +201,10 @@ fn bootstrap_database_inner(root: &Path) -> Result<()> {
sql.push_str("FLUSH PRIVILEGES;\n");
db.query(&sql)?;
fsx::atomic_write_json(&target, &serde_json::json!({ "rootPassword": root_pw, "appPassword": app_pw }))?;
fsx::atomic_write(&root.join("mysql/admin-client.ini"), format!(
"[client]\nuser=root\npassword={root_pw}\nhost=127.0.0.1\nport={}\nprotocol=tcp\ndefault-character-set=utf8mb4\n",
crate::layout::read_ports(root).mysql,
).as_bytes())?;
// The server console gets its own account with a random password instead of a shared default.
let console_pw = Db::from_repack(root, Account::Admin)?.provision_service_account()?; // new root password
db::write_console_credentials(root, &console_pw)?;
+1
View File
@@ -44,6 +44,7 @@ pub mod release;
pub mod report;
pub mod release_schema;
pub mod update;
pub mod update_route;
mod update_isolation;
mod mysql_snapshot;
pub mod wine;
+218 -7
View File
@@ -129,6 +129,10 @@ pub(crate) fn inventory(root: &Path) -> Result<BTreeMap<String, String>> {
}
pub(crate) fn copy_verified(source: &Path, target: &Path, files: &BTreeMap<String, String>) -> Result<()> {
copy_verified_with_progress(source, target, files, &|_| {})
}
fn copy_verified_with_progress(source: &Path, target: &Path, files: &BTreeMap<String, String>, report: &dyn Fn(&str)) -> Result<()> {
if target.exists() { return Err(Error::Invalid("Database snapshot destination already exists.".into())); }
let bytes = files.keys().try_fold(0u64, |total, name| -> Result<u64> {
let path = fsx::ensure_within(source, &fsx::safe_join(source, name)?)?;
@@ -138,13 +142,15 @@ pub(crate) fn copy_verified(source: &Path, target: &Path, files: &BTreeMap<Strin
fs::create_dir_all(parent)?;
fsx::require_space(parent, bytes)?;
fs::create_dir(target)?;
for (relative, expected) in files {
for (index, (relative, expected)) in files.iter().enumerate() {
if index % 250 == 0 { report(&format!("Copying private server files: {} of {}", index, files.len())); }
let source_file = fsx::ensure_within(source, &fsx::safe_join(source, relative)?)?;
let target_file = fsx::ensure_within(target, &fsx::safe_join(target, relative)?)?;
fs::create_dir_all(target_file.parent().unwrap())?;
fs::copy(&source_file, &target_file)?;
if fsx::sha256_file(&target_file)? != *expected { return Err(Error::Invalid(format!("Database snapshot file {relative} failed verification."))); }
}
report("Verifying the complete private file copy");
if inventory(target)? != *files { return Err(Error::Invalid("Database snapshot inventory differs.".into())); }
Ok(())
}
@@ -153,15 +159,33 @@ pub(crate) fn stop(root: &Path) -> Result<()> {
let observed = crate::process::observe(root, &crate::layout::read_ports(root));
if [observed.mysql.state, observed.auth.state, observed.world.state].iter().all(|state| *state == crate::process::ServiceState::Stopped)
&& !crate::multiworld::is_running(root) { return Ok(()); }
let outcome = crate::driver::run(root, crate::driver::Verb::StopAll)?;
let outcome = crate::driver::run(root, crate::driver::Verb::StopAll)
.map_err(|error| Error::Invalid(format!("Could not stop server {} before copying or restoring MySQL: {error}", root.display())))?;
let status = crate::process::observe(root, &crate::layout::read_ports(root));
if !outcome.ok || [status.mysql.state, status.auth.state, status.world.state].iter().any(|state| *state != crate::process::ServiceState::Stopped)
|| crate::multiworld::is_running(root) {
return Err(Error::Invalid("The complete server must be stopped before copying or restoring MySQL.".into()));
return Err(Error::Invalid(stop_failure(root, &status, &outcome)));
}
Ok(())
}
fn stop_failure(root: &Path, status: &crate::process::Observed, outcome: &crate::driver::DriverOutcome) -> String {
let mut details = vec![format!("The complete server must be stopped before copying or restoring MySQL. Server: {}.", root.display())];
for service in [&status.mysql, &status.auth, &status.world].into_iter().chain(status.secondary_world.iter()) {
if service.state != crate::process::ServiceState::Stopped {
details.push(format!("{}: {:?}; PID: {}; port: {}.", service.name, service.state, service.pid.map(|pid| pid.to_string()).unwrap_or_else(|| "unknown".into()), service.port));
}
if let Some(conflict) = &service.conflict {
details.push(format!("Port {} is used by process {} ({}).", conflict.port, conflict.pid, conflict.exe.as_deref().unwrap_or("executable unavailable")));
}
}
let output = crate::diag::redact(&outcome.output);
let lines: Vec<_> = output.lines().rev().take(12).collect();
if !lines.is_empty() { details.push(lines.into_iter().rev().collect::<Vec<_>>().join("\n")); }
else if !outcome.ok { details.push(format!("The stop command failed (exit code: {:?}).", outcome.exit_code)); }
details.join("\n")
}
pub(crate) fn stop_previous_rehearsals(meta: &Path) -> Result<()> {
let location = meta.join("rehearsals");
if !location.exists() { return Ok(()); }
@@ -226,7 +250,8 @@ pub(crate) fn verify(point: &Path, snapshot: &Snapshot) -> Result<()> {
Ok(())
}
pub(crate) fn rehearsal_copy(root: &Path, meta: &Path, point: &Path, snapshot: &Snapshot) -> Result<PathBuf> {
pub(crate) fn rehearsal_copy_with_progress(root: &Path, meta: &Path, point: &Path, snapshot: &Snapshot, report: &dyn Fn(&str)) -> Result<PathBuf> {
report("Verifying the database recovery copy before rehearsal");
verify(point, snapshot)?;
let canonical = fsx::canonicalize_lenient(root)?;
let root = canonical.as_path();
@@ -249,11 +274,15 @@ pub(crate) fn rehearsal_copy(root: &Path, meta: &Path, point: &Path, snapshot: &
reject_link(&metadata)?;
let path = fsx::ensure_within(root, &raw)?;
if metadata.is_dir() { directories.push(path); }
else if metadata.is_file() { files.insert(relative, fsx::sha256_file(&path)?); }
else if metadata.is_file() {
files.insert(relative, fsx::sha256_file(&path)?);
if files.len() % 250 == 0 { report(&format!("Preparing the private copy: {} files checked", files.len())); }
}
else { return Err(Error::Invalid("Unsupported rehearsal file.".into())); }
}
}
copy_verified(root, &destination, &files)?;
copy_verified_with_progress(root, &destination, &files, report)?;
report("Restoring MySQL into the private server copy");
copy_snapshot(point, snapshot, &destination.join("mysql/data"))?;
let (_, mut installed) = crate::registry::MetaDir::open(meta)?;
installed.id = uuid::Uuid::new_v4().to_string();
@@ -338,6 +367,175 @@ pub(crate) fn swap(root: &Path, meta: &Path, point: &Path, snapshot: &Snapshot,
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn failed_stop_identifies_the_server_process_and_retains_redacted_launcher_reason() {
use crate::process::{Observed, ServiceStatus, ServiceState};
let stopped = |name| ServiceStatus { name, state: ServiceState::Stopped, pid: None, port: 0, port_ready: false, conflict: None, uptime_secs: None };
let status = Observed { mysql: ServiceStatus { state: ServiceState::Stopping, pid: Some(42), port: 3307, ..stopped("mysql") }, auth: stopped("auth"), world: stopped("world"), secondary_world: None };
let outcome = crate::driver::DriverOutcome { ok: false, exit_code: Some(1), code: None, human: None, output: "MySQL is still stopping; wait before copying the repack.\nrootPassword=hunter2".into() };
let message = stop_failure(Path::new("private-rehearsal/server"), &status, &outcome);
assert!(message.contains("private-rehearsal") && message.contains("PID: 42") && message.contains("3307"));
assert!(message.contains("MySQL is still stopping"));
assert!(!message.contains("hunter2"));
}
#[cfg(windows)]
#[test]
#[ignore = "requires COA_MYSQL_TEST_BIN pointing to a repack with Runtime/python and Scripts/manage.py"]
fn real_shutdown_with_broken_templates_preserves_database_rows() {
use std::process::{Child, Command, Stdio};
use std::os::windows::process::CommandExt;
struct Server(Child);
impl Drop for Server { fn drop(&mut self) { let _ = self.0.kill(); let _ = self.0.wait(); } }
let bin = PathBuf::from(std::env::var("COA_MYSQL_TEST_BIN").unwrap());
let source = bin.parent().unwrap().parent().unwrap();
let temp = tempfile::tempdir().unwrap();
let root = temp.path().join("shutdown-fixture");
copy_verified(&bin, &root.join("mysql/bin"), &inventory(&bin).unwrap()).unwrap();
copy_verified(&source.join("Runtime/python"), &root.join("Runtime/python"), &inventory(&source.join("Runtime/python")).unwrap()).unwrap();
fsx::atomic_write(&root.join("Scripts/manage.py"), &fs::read(source.join("Scripts/manage.py")).unwrap()).unwrap();
let data = root.join("mysql/data");
let executable = root.join("mysql/bin/mysqld.exe");
let initialized = Command::new(&executable).args(["--no-defaults", "--initialize-insecure"])
.arg(format!("--datadir={}", data.display())).creation_flags(0x0800_0000).output().unwrap();
assert!(initialized.status.success(), "{}", String::from_utf8_lossy(&initialized.stderr));
let sockets: Vec<_> = (0..4).map(|_| std::net::TcpListener::bind("127.0.0.1:0").unwrap()).collect();
let ports: Vec<_> = sockets.iter().map(|socket| socket.local_addr().unwrap().port()).collect();
fsx::atomic_write_json(&root.join("Settings/repack.json"), &serde_json::json!({"mysqlPort":ports[0],"authPort":ports[1],"worldPort":ports[2],"raPort":ports[3]})).unwrap();
drop(sockets);
fsx::atomic_write_json(&root.join("Settings/database.json"), &serde_json::json!({"rootPassword":"","appPassword":""})).unwrap();
fsx::atomic_write(&root.join("mysql/admin-client.ini"), format!("[client]\nuser=root\nhost=127.0.0.1\nport={}\nprotocol=tcp\n", ports[0]).as_bytes()).unwrap();
fsx::atomic_write(&root.join("Settings/worldserver.conf.template"), b"WorldDatabaseInfo = @UNKNOWN_DATABASE@\n").unwrap();
let original = fs::read(root.join("Settings/worldserver.conf.template")).unwrap();
let db = crate::db::Db::from_repack(&root, crate::db::Account::Admin).unwrap();
let start = || {
let server = Server(Command::new(&executable).args(["--no-defaults", "--bind-address=127.0.0.1", "--mysqlx=0", "--skip-log-bin"])
.arg(format!("--datadir={}", data.display())).arg(format!("--port={}", ports[0]))
.arg(format!("--log-error={}", root.join("mysql-test.log").display()))
.stdout(Stdio::null()).stderr(Stdio::null()).creation_flags(0x0800_0000).spawn().unwrap());
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(60);
while !db.ping() { assert!(std::time::Instant::now() < deadline); std::thread::sleep(std::time::Duration::from_millis(200)); }
fsx::atomic_write_json(&root.join(".state/mysql.json"), &crate::process::identity(server.0.id()).unwrap()).unwrap();
server
};
let mut server = start();
db.query("CREATE DATABASE acore_characters; CREATE TABLE acore_characters.shutdown_probe(id INT PRIMARY KEY); INSERT INTO acore_characters.shutdown_probe VALUES(73);").unwrap();
db.query("CREATE DATABASE acore_auth; CREATE DATABASE acore_world; CREATE VIEW acore_characters.shutdown_view AS SELECT id FROM acore_characters.shutdown_probe;").unwrap();
let copied_configuration = serde_json::json!({"root":temp.path().join("original-installation"),"ports":{"mysqlPort":ports[0],"authPort":ports[1],"worldPort":ports[2],"raPort":ports[3]}});
fsx::atomic_write_json(&root.join(".state/configuration.json"), &copied_configuration).unwrap();
let meta = crate::registry::metadata_dir_for(&root).unwrap();
crate::registry::MetaDir::create(&root, &crate::registry::InstallMeta::new(crate::registry::InstallKind::New, &root)).unwrap();
let point = crate::backup::create(&root, &meta, crate::backup::Kind::Full, crate::backup::Trigger::BeforeRepair, None, &|_| {}).unwrap();
assert!(point.mysql_snapshot.is_some());
assert!(crate::backup::verify(&meta, &point.id).unwrap().ok);
crate::update::RepackEnv { root: &root, meta_dir: &meta }.verify_recovery_point(&point).unwrap();
assert!(server.0.wait().unwrap().success());
assert_eq!(fs::read(root.join("Settings/worldserver.conf.template")).unwrap(), original);
assert_eq!(fsx::read_json::<serde_json::Value>(&root.join(".state/configuration.json")).unwrap(), copied_configuration);
fs::remove_file(root.join(".state/configuration.json")).unwrap();
let mut restarted = start();
assert_eq!(db.query("SELECT id FROM acore_characters.shutdown_probe;").unwrap(), "73");
fsx::atomic_write_json(&root.join(".state/mysql.json"), &crate::process::identity(std::process::id()).unwrap()).unwrap();
assert!(stop(&root).unwrap_err().to_string().contains("different live process"));
assert_eq!(db.query("SELECT id FROM acore_characters.shutdown_probe;").unwrap(), "73");
fs::remove_file(root.join("Settings/worldserver.conf.template")).unwrap();
fs::remove_file(root.join(".state/mysql.json")).unwrap();
let observed = crate::process::observe(&root, &crate::layout::read_ports(&root));
assert_eq!(observed.mysql.state, crate::process::ServiceState::Running);
assert!(observed.mysql.port_ready);
assert!(crate::process::listeners().contains(&(ports[0], observed.mysql.pid.unwrap())));
stop(&root).unwrap();
assert!(restarted.0.wait().unwrap().success());
let mut third = start();
assert_eq!(db.query("SELECT id FROM acore_characters.shutdown_view;").unwrap(), "73");
db.query("UPDATE acore_characters.shutdown_probe SET id=74;").unwrap();
fsx::atomic_write(&root.join(".state/mysql.json"), b"{truncated").unwrap();
stop(&root).unwrap();
assert!(third.0.wait().unwrap().success());
assert_eq!(fs::read(root.join(".state/mysql-before-shutdown-recovery.json")).unwrap(), b"{truncated");
let point_dir = crate::backup::point_json(&meta, &point.id).unwrap().parent().unwrap().to_path_buf();
let retained = swap(&root, &meta, &point_dir, point.mysql_snapshot.as_ref().unwrap(), false).unwrap();
assert!(retained.is_dir());
let mut recovered = start();
assert_eq!(db.query("SELECT id FROM acore_characters.shutdown_view;").unwrap(), "73");
stop(&root).unwrap();
assert!(recovered.0.wait().unwrap().success());
// Exercise the public Repair pipeline with real signed packages and SQL,
// rather than only the snapshot and journal helpers.
let mut package_server = start();
db.query("CREATE TABLE acore_auth.account(id INT PRIMARY KEY, username VARCHAR(40)); INSERT INTO acore_auth.account VALUES(73,'FIXTURE'); CREATE TABLE acore_auth.realmlist(id INT PRIMARY KEY, name VARCHAR(40), address VARCHAR(40), localAddress VARCHAR(40), port INT, flag INT); INSERT INTO acore_auth.realmlist VALUES(1,'AzerothCore','127.0.0.1','127.0.0.1',18085,0); CREATE TABLE acore_characters.characters(guid INT PRIMARY KEY, account INT, name VARCHAR(40), race INT, class INT); INSERT INTO acore_characters.characters VALUES(73,73,'Fixture',7,14); CREATE TABLE acore_world.playercreateinfo(race INT, class INT, PRIMARY KEY(race,class));").unwrap();
let starts = [1,2,3,4,5,6,7,8,10,11].into_iter().flat_map(|race| (12..=32).map(move |class| format!("({race},{class})"))).collect::<Vec<_>>().join(",");
db.query(&format!("INSERT INTO acore_world.playercreateinfo VALUES {starts};")).unwrap();
let password = "a".repeat(48);
db.query(&format!("ALTER USER 'root'@'localhost' IDENTIFIED BY '{password}';")).unwrap();
fsx::atomic_write_json(&root.join("Settings/database.json"), &serde_json::json!({"rootPassword":password,"appPassword":"b".repeat(48)})).unwrap();
fsx::atomic_write(&root.join("Settings/worldserver.conf.template"), b"WorldDatabaseInfo = @WorldDatabaseInfo@\nCharacterDatabaseInfo = @CharacterDatabaseInfo@\nLoginDatabaseInfo = @LoginDatabaseInfo@\n").unwrap();
fsx::atomic_write(&root.join("Settings/authserver.conf.template"), b"LoginDatabaseInfo = @LoginDatabaseInfo@\n").unwrap();
fsx::atomic_write(&root.join("Settings/mod_ascension_compat.conf.template"), b"Ascension.DbcPath = @ASCENSION_DBC@\n").unwrap();
let startup = crate::driver::run(&root, crate::driver::Verb::StartMysql).unwrap();
assert!(startup.ok, "{}", crate::diag::redact(&startup.output));
let db = crate::db::Db::from_repack(&root, crate::db::Account::Admin).unwrap();
crate::schema_check::capture(&db, &root).unwrap();
assert!(crate::schema_check::check(&db, &root).unwrap().is_empty());
stop(&root).unwrap();
assert!(package_server.0.wait().unwrap().success());
struct StopFixture(PathBuf);
impl Drop for StopFixture { fn drop(&mut self) { let _ = stop(&self.0); } }
let _stop_fixture = StopFixture(root.clone());
use base64::{engine::general_purpose::STANDARD, Engine};
use ed25519_dalek::{Signer, SigningKey};
let key = SigningKey::from_bytes(&[7;32]);
let trusted = STANDARD.encode(key.verifying_key().to_bytes());
let source = temp.path().join("repair-package-source");
fsx::atomic_write(&source.join("Core/reference/repair-probe.dll"), b"official").unwrap();
fsx::atomic_write(&source.join(crate::schema_check::CONTRACT), &fs::read(root.join(crate::schema_check::CONTRACT)).unwrap()).unwrap();
let build = |kind, version: &str, destination: &Path, migrations| {
let manifest = crate::package::build(&source, destination, &crate::package::BuildOptions { kind, version: version.into(), core_commit: None, built_at: "fixture".into(), part_size: 1024*1024, bots_commit: None, migrations }, &|_| {}).unwrap();
let bytes = fs::read(destination.join("manifest.json")).unwrap();
fsx::atomic_write(&destination.join("manifest.json.sig"), STANDARD.encode(key.sign(&bytes).to_bytes()).as_bytes()).unwrap();
manifest
};
let base = temp.path().join("repair-base");
let base_manifest = build(crate::manifest::Kind::Base, "1.0.0", &base, vec![]);
let update = temp.path().join("repair-update");
let update_manifest = build(crate::manifest::Kind::Update, "2.0.0", &update, vec![]);
fsx::atomic_write_json(&meta.join("manifests/base.json"), &base_manifest).unwrap();
fsx::atomic_write_json(&meta.join("manifests/update-2.0.0.json"), &update_manifest).unwrap();
let (_, mut installed) = crate::registry::MetaDir::open(&meta).unwrap();
installed.core.version = Some("2.0.0".into());
fsx::atomic_write_json(&meta.join("install.json"), &installed).unwrap();
fsx::atomic_write(&root.join("Core/reference/repair-probe.dll"), b"broken").unwrap();
let base_source = crate::pkgsource::Source::Dir(base);
let update_source = crate::pkgsource::Source::Dir(update);
let report = crate::repair::run(&root, &meta, &base_source, &update_source, &trusted, &|_,_| {}).unwrap();
assert!(report.error.is_none());
assert!(report.database.iter().all(|check| check.problems.is_empty()));
assert_eq!(fs::read(root.join("Core/reference/repair-probe.dll")).unwrap(), b"official");
crate::update::ensure_recovered(&meta).unwrap();
fsx::atomic_write(&root.join("Core/reference/repair-probe.dll"), b"before verification failure").unwrap();
let error = crate::repair::run(&root, &meta, &base_source, &update_source, &trusted, &|phase,_| {
if phase == "Checking database after repair" { fs::remove_file(root.join("Core/reference/repair-probe.dll")).unwrap(); }
}).unwrap_err();
assert!(error.to_string().contains("repair"));
assert_eq!(fs::read(root.join("Core/reference/repair-probe.dll")).unwrap(), b"before verification failure");
crate::update::ensure_recovered(&meta).unwrap();
let failed_sql = "UPDATE shutdown_probe SET id=75; CREATE TABLE repair_partial(id INT); INVALID SQL;";
fsx::atomic_write(&source.join("_migrations/characters/repair-failure.sql"), failed_sql.as_bytes()).unwrap();
let failing = temp.path().join("repair-failing-update");
let manifest = build(crate::manifest::Kind::Update, "2.0.0", &failing, vec![crate::manifest::Migration { id:"repair-failure".into(), db:"characters".into(), sha256:fsx::sha256_bytes(failed_sql.as_bytes()), compatible_sha256:vec![], destructive:false }]);
fsx::atomic_write_json(&meta.join("manifests/update-2.0.0.json"), &manifest).unwrap();
fsx::atomic_write(&root.join("Core/reference/repair-probe.dll"), b"before failed repair").unwrap();
let report = crate::repair::run(&root, &meta, &base_source, &crate::pkgsource::Source::Dir(failing), &trusted, &|_,_| {}).unwrap();
assert!(report.error.is_some());
assert_eq!(fs::read(root.join("Core/reference/repair-probe.dll")).unwrap(), b"before failed repair");
crate::update::ensure_recovered(&meta).unwrap();
crate::backup::with_database(&root, |db| {
assert_eq!(db.query("SELECT id FROM acore_characters.shutdown_view;")?, "73");
assert_eq!(db.query("SELECT COUNT(*) FROM information_schema.TABLES WHERE TABLE_SCHEMA='acore_characters' AND TABLE_NAME='repair_partial';")?, "0");
assert_eq!(db.query("SELECT username FROM acore_auth.account WHERE id=73;")?, "FIXTURE");
Ok(())
}).unwrap();
}
#[cfg(windows)]
#[test]
#[ignore = "requires COA_MYSQL_TEST_BIN pointing to the bundled MySQL tools"]
@@ -373,6 +571,14 @@ mod tests {
let mut server = start();
db.query("CREATE DATABASE acore_characters; CREATE DATABASE acore_world; CREATE DATABASE acore_auth; CREATE TABLE acore_characters.probe(id INT PRIMARY KEY, note VARCHAR(40)); CREATE TABLE acore_world.probe(id INT NOT NULL DEFAULT 0); INSERT INTO acore_world.probe VALUES(43); CREATE TABLE acore_auth.probe(id INT); INSERT INTO acore_auth.probe VALUES(44); CREATE USER 'fixture_user'@'localhost' IDENTIFIED BY 'fixture'; CREATE TRIGGER acore_characters.probe_insert BEFORE INSERT ON acore_characters.probe FOR EACH ROW SET NEW.note='triggered'; INSERT INTO acore_characters.probe VALUES(42,'original'); CREATE VIEW acore_characters.probe_view AS SELECT c.id,w.id AS world_id FROM acore_characters.probe c CROSS JOIN acore_world.probe w; CREATE PROCEDURE acore_characters.probe_proc() SELECT id FROM acore_characters.probe; CREATE FUNCTION acore_characters.probe_func() RETURNS INT DETERMINISTIC RETURN 73;").unwrap();
assert_eq!(db.recovery_objects("acore_characters").unwrap().len(), 4);
db.query("CREATE TABLE acore_characters.coa_squid_pending(path VARCHAR(255), sha256 CHAR(64)); INSERT INTO acore_characters.coa_squid_pending VALUES('playerbots/base/ai_playerbot_texts.sql', REPEAT('a',64));").unwrap();
let squid_problems = crate::squid::database_problems(&root, crate::realms::Mode::Coa, &|sql| {
assert!(sql.starts_with("SELECT "));
db.query(sql)
}).unwrap();
assert_eq!(squid_problems.len(), 1);
assert!(squid_problems[0].detail.contains("interrupted"));
assert_eq!(db.query("SELECT COUNT(*) FROM acore_characters.coa_squid_pending;").unwrap(), "1");
crate::schema_check::capture(&db, &root).unwrap();
let hash = fsx::sha256_file(&root.join(crate::schema_check::CONTRACT)).unwrap();
db.query("ALTER TABLE acore_world.probe ALTER COLUMN id DROP DEFAULT;").unwrap();
@@ -486,8 +692,13 @@ mod tests {
fsx::atomic_write(&root.join("Core/worldserver.exe"), b"exe").unwrap();
fsx::atomic_write(&root.join("Core/configs/worldserver.conf"), b"conf").unwrap();
fsx::atomic_write(&root.join("Settings/repack.json"), b"{}").unwrap();
let dest = rehearsal_copy(&root, &meta, &point, &snapshot).unwrap();
let phases = std::cell::RefCell::new(Vec::new());
let dest = rehearsal_copy_with_progress(&root, &meta, &point, &snapshot, &|phase| phases.borrow_mut().push(phase.to_string())).unwrap();
assert_eq!(fs::read(dest.join("Core/configs/worldserver.conf")).unwrap(), b"conf");
assert_eq!(fs::read(dest.join("mysql/data/characters.ibd")).unwrap(), b"saved");
let phases = phases.into_inner();
assert!(phases[0].contains("Verifying the database"));
assert!(phases.iter().any(|phase| phase.contains("Copying private server files")));
assert!(phases.last().unwrap().contains("Restoring MySQL"));
}
}
+43
View File
@@ -14,6 +14,7 @@ use crate::signing;
/// Where a package comes from.
#[derive(Debug, Clone)]
pub enum Source {
Installation(Box<Source>),
/// `https://.../` base URL holding manifest.json, manifest.json.sig and the parts.
Url(String),
/// A folder produced by `package::build` plus its `manifest.json.sig` (offline / local installs).
@@ -23,6 +24,7 @@ pub enum Source {
/// Read a small file (manifest, signature) from the source.
pub fn fetch_small(source: &Source, name: &str) -> Result<Vec<u8>> {
match source {
Source::Installation(source) => fetch_small(source, &if matches!(name, "manifest.json" | "manifest.json.sig") { format!("install-{name}") } else { name.into() }),
Source::Dir(d) => Ok(fs::read(fsx::safe_join(d, name)?).map_err(|_| Error::Invalid(format!("{name} was not found in the package folder.")))?),
Source::Url(base) => {
let url = format!("{}/{name}", base.trim_end_matches('/'));
@@ -48,6 +50,14 @@ pub fn fetch_manifest(source: &Source, trusted_key: &str) -> Result<(Manifest, V
let sig = String::from_utf8_lossy(&fetch_small(source, "manifest.json.sig")?).into_owned();
signing::verify(&bytes, &sig, trusted_key)?;
let manifest = Manifest::parse(&bytes)?;
if let Source::Installation(release) = source {
let (update, _) = fetch_manifest(release, trusted_key)?;
if manifest.kind != crate::manifest::Kind::Base || update.kind != crate::manifest::Kind::Update || manifest.version != update.version
|| manifest.core.commit != update.core.commit
|| manifest.bots.as_ref().and_then(|value| value.commit.as_ref()) != update.bots.as_ref().and_then(|value| value.commit.as_ref()) {
return Err(Error::InvalidManifest("The full installation package does not match the selected server release.".into()));
}
}
Ok((manifest, bytes))
}
@@ -68,6 +78,7 @@ pub fn human_bytes(n: u64) -> String {
pub fn fetch_parts(source: &Source, manifest: &Manifest, download_dir: &Path, cancel: &Cancel, report: &dyn Fn(f64, Option<String>)) -> Result<PathBuf> {
let archive = manifest.archive.as_ref().ok_or_else(|| Error::InvalidManifest("manifest has no archive".into()))?;
match source {
Source::Installation(source) => fetch_parts(source, manifest, download_dir, cancel, report),
Source::Dir(d) => Ok(d.clone()),
Source::Url(base) => {
let all: u64 = archive.parts.iter().map(|p| p.size).sum::<u64>().max(1);
@@ -90,6 +101,38 @@ pub fn fetch_parts(source: &Source, manifest: &Manifest, download_dir: &Path, ca
mod tests {
use super::*;
#[test]
fn clean_installation_requires_the_signed_full_image_of_the_selected_release() {
use base64::{engine::general_purpose::STANDARD, Engine};
use ed25519_dalek::{Signer, SigningKey};
let folder = tempfile::tempdir().unwrap();
let signing_key = SigningKey::from_bytes(&[23; 32]);
let key = STANDARD.encode(signing_key.verifying_key().to_bytes());
let source = Source::Installation(Box::new(Source::Dir(folder.path().into())));
let mut manifest = serde_json::json!({"schema": 1, "kind": "update", "version": "0.261014.1",
"core": {"commit": "a".repeat(40)}, "builtAt": "test", "minManagerVersion": "0.6.16",
"files": [], "migrations": [], "archive": null});
let write = |name: &str, value: &serde_json::Value| {
let bytes = serde_json::to_vec(value).unwrap();
fs::write(folder.path().join(name), &bytes).unwrap();
fs::write(folder.path().join(format!("{name}.sig")), STANDARD.encode(signing_key.sign(&bytes).to_bytes())).unwrap();
};
write("manifest.json", &manifest);
assert!(fetch_manifest(&source, &key).is_err());
manifest["kind"] = "base".into();
write("install-manifest.json", &manifest);
assert_eq!(fetch_manifest(&source, &key).unwrap().0.version, "0.261014.1");
manifest["version"] = "0.2.0".into();
write("install-manifest.json", &manifest);
assert!(fetch_manifest(&source, &key).is_err());
manifest["version"] = "0.261014.1".into();
manifest["core"]["commit"] = "b".repeat(40).into();
write("install-manifest.json", &manifest);
assert!(fetch_manifest(&source, &key).is_err());
fs::write(folder.path().join("install-manifest.json"), b"tampered").unwrap();
assert!(fetch_manifest(&source, &key).unwrap_err().to_string().contains("signature"));
}
#[test]
fn sizes_are_shown_in_binary_units() {
assert_eq!(human_bytes(0), "0 B");
+9 -6
View File
@@ -289,15 +289,18 @@ fn service(root: &Path, name: &'static str, exe: PathBuf, port: u16, listen: &[(
}
fn service_with(root: &Path, name: &'static str, exe: PathBuf, alternatives: &[PathBuf], port: u16, listen: &[(u16, u32)]) -> ServiceStatus {
// Prefer the repack's own record when it still matches a live process; otherwise discover by exact exe path.
// Prefer the exact installed executable owning the port; otherwise use a valid record or path discovery.
let norm = |p: &Path| p.to_string_lossy().replace('/', "\\");
let expected: Vec<String> = std::iter::once(&exe).chain(alternatives).map(|p| norm(p)).collect();
let proc = read_state_record(root, name)
.filter(is_alive)
.filter(|r| expected.iter().any(|e| r.exe.eq_ignore_ascii_case(e)))
.or_else(|| std::iter::once(&exe).chain(alternatives).find_map(|p| find_by_exe(p).into_iter().next()));
let owner = listen.iter().find(|(p, _)| *p == port).map(|(_, pid)| *pid);
// MySQL can launch a supervisor and a server with the same executable. The
// listening process is authoritative when its exact installation path matches.
let proc = owner.and_then(identity)
.filter(|record| expected.iter().any(|exe| record.exe.eq_ignore_ascii_case(exe)))
.or_else(|| read_state_record(root, name)
.filter(is_alive)
.filter(|r| expected.iter().any(|e| r.exe.eq_ignore_ascii_case(e))))
.or_else(|| std::iter::once(&exe).chain(alternatives).find_map(|p| find_by_exe(p).into_iter().next()));
let (state, port_ready, conflict) = match (&proc, owner) {
(Some(p), Some(o)) if p.pid == o => (ServiceState::Running, true, None),
(Some(_), _) => (ServiceState::Starting, false, None),
+101 -1
View File
@@ -1,5 +1,6 @@
//! Database acceptance for release packages, using a freshly extracted signed base fixture.
use std::collections::HashSet;
use std::fs;
use std::path::Path;
use crate::{backup, fsx, install, manifest::{Kind, Migration}, migrations, package, pkgsource, release::{self, SqlFile}, schema_check, Error, Result};
@@ -14,6 +15,7 @@ impl crate::update::Env for QualificationEnv<'_> {
fn snapshot(&self) -> Result<String> { self.0.snapshot() }
fn verify_snapshot(&self, id: &str) -> Result<()> { self.0.verify_snapshot(id) }
fn rehearse(&self, manifest: &crate::manifest::Manifest, tree: &Path, items: &[crate::update::PlanItem], point: &str) -> Result<()> { self.0.rehearse(manifest, tree, items, point) }
fn rehearse_with_progress(&self, manifest: &crate::manifest::Manifest, tree: &Path, items: &[crate::update::PlanItem], point: &str, report: &dyn Fn(&str, u8)) -> Result<()> { self.0.rehearse_with_progress(manifest, tree, items, point, report) }
fn restore_snapshot(&self, id: &str) -> Result<()> { self.0.restore_snapshot(id) }
fn migrate(&self, manifest: &crate::manifest::Manifest, staged: &Path) -> Result<crate::migrations::ApplyReport> { self.0.migrate(manifest, staged) }
fn validate(&self) -> Result<()> { self.0.validate() }
@@ -89,6 +91,68 @@ pub fn qualify_upgrade(base: &Path, source: &Path, candidate: &Path, fixture: &P
}))
}
pub fn compose_install(base: &Path, candidate: &Path, fixture: &Path, trusted_key: &str) -> Result<()> {
qualify_upgrade(base, base, candidate, fixture, trusted_key)?;
let fixture = fsx::canonicalize_lenient(fixture)?;
let (_, bytes) = pkgsource::fetch_manifest(&pkgsource::Source::Dir(candidate.into()), trusted_key)?;
let manifest = crate::manifest::Manifest::parse(&bytes)?;
install::with_scratch_ports(&fixture, || backup::with_database(&fixture, |db| {
let players = db.query(&format!("SELECT COUNT(*) FROM acore_characters.characters WHERE account<>{};", crate::companions::TEMPLATE_ACCOUNT))?;
if players.trim() != "0" || crate::companions::template_count(db)? != 21 {
return Err(Error::Invalid("The installation image contains unexpected player characters.".into()));
}
for table in crate::cleanbase::AUTH_PLAYER_TABLES {
if db.tables("acore_auth")?.iter().any(|name| name == table) {
db.query(&format!("DELETE FROM acore_auth.`{table}`;"))?;
}
}
if let Some(problem) = schema_check::check(db, &fixture)?.first() {
return Err(Error::Invalid(format!("Installation image schema mismatch: {}.{}", problem.table, problem.column)));
}
Ok(())
}))?;
fs::remove_file(fixture.join("Core/configs/coa-qualification-user.conf"))?;
let path = fixture.join("Settings/repack.json");
let mut settings: serde_json::Value = fsx::read_json(&path)?;
settings["raPassword"] = "".into();
fsx::atomic_write_json(&path, &settings)?;
fsx::atomic_write_json(&fixture.join("Settings/install-source.json"), &serde_json::json!({
"version": manifest.version, "core": manifest.core, "bots": manifest.bots,
"updateManifestSha256": fsx::sha256_bytes(&bytes),
}))?;
crate::mysql_snapshot::stop(&fixture)?;
fs::remove_file(fixture.join(MARKER))?;
Ok(())
}
pub fn qualify_install(package: &Path, fixture: &Path, trusted_key: &str) -> Result<serde_json::Value> {
use crate::update::Env;
if !cfg!(windows) || fixture.exists()
|| !fixture.file_name().is_some_and(|name| name.to_string_lossy().starts_with("coa-schema-fixture-")) {
return Err(Error::Invalid("Clean installation qualification requires a new disposable Windows fixture.".into()));
}
let fixture = std::path::absolute(fixture)?;
let package = fsx::canonicalize_lenient(package)?;
let (manifest, bytes) = pkgsource::fetch_manifest(&pkgsource::Source::Dir(package.clone()), trusted_key)?;
let registry_dir = tempfile::tempdir()?;
let registry = crate::registry::Registry::at(registry_dir.path().join("registry.json"));
let installed = install::install_base(&install::Params {
source: pkgsource::Source::Dir(package), dest: fixture.clone(), trusted_key,
registry: &registry, cancel: crate::download::Cancel::default(),
}, &|_| {})?;
let metadata = crate::registry::metadata_dir_for(&fixture)?;
let env = QualificationEnv(crate::update::RepackEnv { root: &fixture, meta_dir: &metadata });
env.validate()?;
env.ensure_stopped()?;
crate::mysql_snapshot::stop(&fixture)?;
if installed.version != manifest.version || crate::update::pending_checked(&metadata)?.is_some() {
return Err(Error::Invalid("Clean installation did not finish at the packaged release.".into()));
}
Ok(serde_json::json!({ "schema": 1, "result": "passed", "version": installed.version,
"manifestSha256": fsx::sha256_bytes(&bytes),
"checks": ["clean-install", "signed-full-package", "credential-rotation", "schema-contract", "private-auth-world-startup"] }))
}
pub fn collect(core: &Path, bots: Option<&Path>, repairs: Option<&Path>) -> Result<Vec<SqlFile>> {
let mut files = release::collect_core_sql(core)?;
if let Some(bots) = bots { files.extend(release::collect_bots_sql(bots)?); }
@@ -220,7 +284,15 @@ pub fn validate_startup(fixture: &Path, tree: &Path, base: &Path, trusted_key: &
}
pub fn verify_package(dir: &Path, trusted_key: &str) -> Result<()> {
let (manifest, _) = pkgsource::fetch_manifest(&pkgsource::Source::Dir(dir.into()), trusted_key)?;
verify_package_source(dir, &pkgsource::Source::Dir(dir.into()), trusted_key)
}
pub fn verify_install_package(dir: &Path, trusted_key: &str) -> Result<()> {
verify_package_source(dir, &pkgsource::Source::Installation(Box::new(pkgsource::Source::Dir(dir.into()))), trusted_key)
}
fn verify_package_source(dir: &Path, source: &pkgsource::Source, trusted_key: &str) -> Result<()> {
let (manifest, _) = pkgsource::fetch_manifest(source, trusted_key)?;
if !manifest.files.iter().any(|f| f.path == schema_check::CONTRACT && f.size > 0) {
return Err(Error::Invalid("The release is missing its database schema contract.".into()));
}
@@ -249,6 +321,34 @@ mod tests {
use base64::{engine::general_purpose::STANDARD, Engine};
use ed25519_dalek::{Signer, SigningKey};
#[test]
#[ignore = "Requires a composed disposable installation image"]
fn real_full_package_installs_the_current_version_without_an_update_transaction() {
let image = std::path::PathBuf::from(std::env::var_os("COA_INSTALL_IMAGE_DIR").expect("COA_INSTALL_IMAGE_DIR"));
let provenance: serde_json::Value = fsx::read_json(&image.join("Settings/install-source.json")).unwrap();
let root = tempfile::tempdir().unwrap();
let package = root.path().join("package");
let options = package::BuildOptions {
kind: Kind::Base, version: provenance["version"].as_str().unwrap().into(),
core_commit: provenance["core"]["commit"].as_str().map(String::from),
bots_commit: provenance["bots"]["commit"].as_str().map(String::from),
built_at: "qualification".into(), part_size: package::DEFAULT_PART_SIZE, migrations: vec![],
};
package::build(&image, &package, &options, &|_| {}).unwrap();
let signing_key = SigningKey::generate(&mut rand_core::OsRng);
let bytes = fs::read(package.join("manifest.json")).unwrap();
fs::write(package.join("manifest.json.sig"), STANDARD.encode(signing_key.sign(&bytes).to_bytes())).unwrap();
let trusted_key = STANDARD.encode(signing_key.verifying_key().to_bytes());
let fixture = root.path().join("coa-schema-fixture-clean-install");
let report = qualify_install(&package, &fixture, &trusted_key).unwrap();
assert_eq!(report["version"], provenance["version"]);
assert_eq!(report["result"], "passed");
let metadata = crate::registry::metadata_dir_for(&fixture).unwrap();
let (_, installed) = crate::registry::MetaDir::open(&metadata).unwrap();
assert_eq!(installed.core.version.as_deref(), provenance["version"].as_str());
assert!(!metadata.join("updates").read_dir().is_ok_and(|mut entries| entries.next().is_some()));
}
#[test]
fn relative_startup_fixture_targets_replace_the_original_location() {
let directory = tempfile::Builder::new().prefix("coa-schema-fixture-path-test-").tempdir_in(".").unwrap();
+48 -28
View File
@@ -30,7 +30,9 @@ pub fn check(root: &Path, dir: &Path) -> Result<Vec<DatabaseCheck>> {
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() });
let mut problems = crate::schema_check::check(&db, root)?;
problems.extend(crate::squid::database_problems(root, mode, &|sql| db.query(sql))?);
checks.push(DatabaseCheck { realm: mode, migrations: crate::migrations::status(&db, &migrations)?, problems, full_schema: root.join(crate::schema_check::CONTRACT).exists() });
}
Ok(checks)
})?;
@@ -128,38 +130,56 @@ pub fn run(root: &Path, dir: &Path, base_source: &Source, update_source: &Source
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 backup = crate::backup::create(root, dir, crate::backup::Kind::Full, crate::backup::Trigger::BeforeRepair, Some("before repair".into()), &|phase| progress(phase, 65))?.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 };
let attempt = (|| -> Result<Report> {
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: backup.clone(), 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: backup.clone(), database, error };
fsx::atomic_write_json(&before.join("report.json"), &report)?;
return Ok(report);
crate::update::finish_repair(root, dir, &mut txn, true, &env)?;
progress("Done", 100);
Ok(report)
})();
match attempt {
Ok(report) => Ok(report),
Err(error) if matches!(txn.state, crate::update::State::RolledBack | crate::update::State::Failed) => Err(error),
Err(error) => {
progress("Undoing the failed repair", 95);
let message = match crate::update::finish_repair(root, dir, &mut txn, false, &env) {
Ok(()) => format!("Repair failed: {error}. The original server files and databases were restored from recovery point {backup}."),
Err(recovery) => format!("Repair failed: {error}. Recovery failed: {recovery}. Recovery point {backup} was preserved; resolve the unfinished repair before starting the server."),
};
let failed = Report { restored: Vec::new(), applied: Vec::new(), backup: backup.clone(), database: Vec::new(), error: Some(message.clone()) };
if let Err(report_error) = fsx::atomic_write_json(&dir.join("repairs").join(&backup).join("report.json"), &failed) {
tracing::warn!(%report_error, "Could not persist failed repair report");
}
Err(Error::Invalid(message))
}
}
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);
+56
View File
@@ -1,6 +1,35 @@
use std::path::Path;
use serde::{Deserialize, Serialize};
/// SQUID has its own import ledger, outside the signed package migration ledger.
/// Keep this read-only: a pending base import can contain player data and must not
/// be replayed or cleared merely because the normal schema contract passes.
pub(crate) fn database_problems(root: &Path, mode: crate::realms::Mode, query: &impl Fn(&str) -> crate::Result<String>) -> crate::Result<Vec<crate::schema_check::Problem>> {
let active = root.join("Core/configs/modules/playerbots.conf");
let config = if active.is_file() { active } else { root.join("Core/configs/modules/playerbots.conf.dist") };
let enabled = if config.is_file() {
let conf = crate::config::parser::ConfFile::parse_bytes(&std::fs::read(config)?)?;
!matches!(conf.get("AiPlayerbot.Enabled").unwrap_or("1").trim().trim_matches('"').to_ascii_lowercase().as_str(), "0" | "false" | "no" | "off")
} else { false };
let mut problems = Vec::new();
for schema in [mode.schema("characters")?, mode.schema("world")?, "acore_playerbots"] {
let tables: std::collections::BTreeSet<_> = query(&format!("SELECT TABLE_NAME FROM information_schema.TABLES WHERE TABLE_SCHEMA='{schema}';"))?.lines().map(str::to_owned).collect();
if tables.contains("coa_squid_pending") {
for pending in query(&format!("SELECT path FROM `{schema}`.coa_squid_pending;"))?.lines().filter(|path| !path.is_empty()) {
problems.push(crate::schema_check::Problem { database: schema.into(), table: "coa_squid_pending".into(), column: String::new(), detail: format!("SQUID base import was interrupted: {pending}. File repair and package SQL updates cannot complete this import. Restore a verified database backup from before the import; do not delete the pending record or replay base SQL.") });
}
}
if enabled && schema == mode.schema("characters")? {
for table in ["playerbots_names", "playerbots_guild_names", "playerbots_arena_team_names"] {
if !tables.contains(table) {
problems.push(crate::schema_check::Problem { database: schema.into(), table: table.into(), column: String::new(), detail: "Required SQUID character table is missing. A normal server start provisions it when no interrupted import is present; an interrupted import requires database recovery first.".into() });
}
}
}
}
Ok(problems)
}
#[derive(Debug, Serialize, PartialEq, Eq)]
pub struct Release {
pub tag: Option<String>,
@@ -129,6 +158,33 @@ pub fn validate(field: &Field, value: &str) -> crate::Result<()> {
mod tests {
use super::*;
#[test]
fn database_check_reports_pending_squid_imports_in_each_realm_without_writes() {
let root = tempfile::tempdir().unwrap();
for mode in [crate::realms::Mode::Coa, crate::realms::Mode::Wildcard] {
let problems = database_problems(root.path(), mode, &|sql| {
assert!(sql.starts_with("SELECT "));
if sql.contains("information_schema.TABLES") { Ok("coa_squid_pending".into()) }
else { Ok("playerbots/base/ai_playerbot_texts.sql".into()) }
}).unwrap();
assert_eq!(problems.len(), 3);
assert_eq!(problems[0].database, mode.schema("characters").unwrap());
assert!(problems.iter().all(|p| p.detail.contains("interrupted")));
}
}
#[test]
fn enabled_squid_requires_character_tables_but_disabled_squid_does_not() {
let root = tempfile::tempdir().unwrap();
let config = root.path().join("Core/configs/modules/playerbots.conf");
crate::fsx::atomic_write(&config, b"AiPlayerbot.Enabled = 1\n").unwrap();
let query = |_: &str| Ok(String::new());
assert_eq!(database_problems(root.path(), crate::realms::Mode::Wildcard, &query).unwrap().len(), 3);
crate::fsx::atomic_write(&config, b"AiPlayerbot.Enabled = 0\n").unwrap();
assert!(database_problems(root.path(), crate::realms::Mode::Wildcard, &query).unwrap().is_empty());
crate::fsx::atomic_write(&config, b"AiPlayerbot.Enabled = 1\n").unwrap();
assert!(database_problems(root.path(), crate::realms::Mode::Coa, &|_| Ok("playerbots_names\nplayerbots_guild_names\nplayerbots_arena_team_names".into())).unwrap().is_empty());
}
#[test]
fn a_setting_with_choices_only_accepts_one_of_them() {
let root = tempfile::tempdir().unwrap();
crate::fsx::atomic_write(&root.path().join("Core/configs/modules/playerbots.conf.settings.json"), br#"{"format":1,"settings":[
+146 -5
View File
@@ -93,6 +93,7 @@ pub trait Env {
fn preflight(&self, _manifest: &Manifest) -> Result<()> { Ok(()) }
fn verify_snapshot(&self, _id: &str) -> Result<()> { Ok(()) }
fn rehearse(&self, _manifest: &Manifest, _tree: &Path, _items: &[PlanItem], _point: &str) -> Result<()> { Ok(()) }
fn rehearse_with_progress(&self, manifest: &Manifest, tree: &Path, items: &[PlanItem], point: &str, _report: &dyn Fn(&str, u8)) -> Result<()> { self.rehearse(manifest, tree, items, point) }
/// Create a recovery point for the databases and configuration; returns its id.
fn snapshot(&self) -> Result<String>;
fn restore_snapshot(&self, id: &str) -> Result<()>;
@@ -121,13 +122,32 @@ pub fn load(meta: &Path, id: &str) -> Result<Txn> {
}
fn read_journal(path: &Path) -> Result<Txn> {
let txn: Txn = fsx::read_json(path).map_err(|e| Error::Invalid(format!("Update journal {} cannot be read: {e}. Available recovery copies were preserved.", path.display())))?;
let mut txn: Txn = fsx::read_json(path).map_err(|e| Error::Invalid(format!("Update journal {} cannot be read: {e}. Available recovery copies were preserved.", path.display())))?;
if path.parent().and_then(Path::file_name).and_then(|id| id.to_str()) != Some(txn.id.as_str()) { return Err(Error::Invalid("Update journal identity is inconsistent.".into())); }
txn_dir(path.parent().unwrap(), &txn.id)?;
if let Some(id) = &txn.recovery_point {
if id.is_empty() || !id.chars().all(|c| c.is_ascii_alphanumeric() || matches!(c, '-' | '_' | '.')) || id.contains("..") { return Err(Error::Invalid("Update journal contains an invalid recovery point identity.".into())); }
}
let valid_hash = |hash: &str| hash.len() == 64 && hash.bytes().all(|b| b.is_ascii_hexdigit());
let mut completed_legacy_repair = false;
// Older successful repairs saved Committed without setting done. Recover only that
// specific shape, and only if every repaired file still has its expected bytes.
if txn.state == State::Committed && txn.id.contains("-repair-")
&& txn.message.as_deref() == Some("Repair is in progress.")
&& txn.from_version.as_deref() == Some(txn.to_version.as_str())
&& txn.databases_started && txn.recovery_point.is_some() && txn.recovery_hashes.contains_key("@install")
&& txn.ops.iter().any(|op| !op.done)
&& txn.ops.iter().all(|op| op.started && matches!((op.action, op.had_previous), (Action::Create, false) | (Action::Replace, true)) && valid_hash(&op.new_sha256)) {
let meta_dir = path.parent().and_then(Path::parent).and_then(Path::parent)
.ok_or_else(|| Error::Invalid("Invalid repair journal location.".into()))?;
let (_, installed) = MetaDir::open(meta_dir)?;
let root = Path::new(&installed.server_path);
if fsx::canonicalize_lenient(&crate::registry::metadata_dir_for(root)?)? != fsx::canonicalize_lenient(meta_dir)? {
return Err(Error::Invalid("The repair journal does not belong to its installed server.".into()));
}
complete_repair_ops(root, &mut txn)?;
completed_legacy_repair = true;
}
let mut seen = std::collections::BTreeSet::new();
for op in &txn.ops {
fsx::safe_join(path.parent().unwrap(), &op.path)?;
@@ -140,6 +160,13 @@ fn read_journal(path: &Path) -> Result<Txn> {
}
if txn.recovery_hashes.values().any(|hash| !valid_hash(hash)) { return Err(Error::Invalid("Update journal contains invalid recovery hashes.".into())); }
for key in txn.recovery_hashes.keys().filter(|key| !matches!(key.as_str(), "@install" | "@point")) { fsx::safe_join(path.parent().unwrap(), key)?; }
if completed_legacy_repair {
// Persist the verified completion once: later legitimate updates can change
// these files. Retain the original record for diagnostics and crash recovery.
let original = path.with_file_name("txn-before-repair-completion.json");
if !original.exists() { fsx::atomic_write(&original, &fs::read(path)?)?; }
fsx::atomic_write_json(path, &txn)?;
}
Ok(txn)
}
@@ -269,6 +296,8 @@ pub fn plan(root: &Path, meta: &InstallMeta, manifest: &Manifest, resolutions: &
pub struct Preview {
pub from_version: Option<String>,
pub to_version: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version: Option<String>,
pub items: Vec<PlanItem>,
pub conflicts: Vec<String>,
pub migrations: usize,
@@ -337,6 +366,7 @@ pub fn preview_with(root: &Path, meta: &InstallMeta, source: &Source, trusted_ke
Ok(Preview {
from_version: meta.core.version.clone(),
to_version: m.version.clone(),
latest_version: None,
conflicts: items.iter().filter(|i| i.action == Action::Conflict).map(|i| i.path.clone()).collect(),
items,
migrations: m.migrations.len(),
@@ -377,7 +407,7 @@ fn reject_downgrade(meta: &InstallMeta, manifest: &Manifest) -> Result<()> {
return Err(Error::Invalid(format!("This package targets {} rather than {platform}.", c.platform)));
}
if meta.core.version.as_ref().is_none_or(|version| version != &manifest.version && !c.source_versions.contains(version)) {
return Err(Error::Invalid("This server version is outside the release's tested compatibility matrix.".into()));
return Err(Error::Invalid(format!("Installed server {} is outside the compatibility matrix for {}. Tested source versions: {}.", meta.core.version.as_deref().unwrap_or("unknown"), manifest.version, c.source_versions.join(", "))));
}
}
if let Some(installed) = meta.core.version.as_deref() {
@@ -499,7 +529,7 @@ pub fn apply(p: &Params, report: &dyn Fn(&str, u8)) -> Result<Outcome> {
if point_meta.is_file() { txn.recovery_hashes.insert("@point".into(), fsx::sha256_file(&point_meta)?); }
save(meta_dir, &txn)?;
step(report, "Testing the update on a private copy of your server", 54);
if let Err(error) = p.env.rehearse(&m, &tree, &items, txn.recovery_point.as_deref().unwrap()) {
if let Err(error) = p.env.rehearse_with_progress(&m, &tree, &items, txn.recovery_point.as_deref().unwrap(), report) {
txn.state = State::Failed;
txn.message = Some(format!("The private update rehearsal failed: {error}. The installed server was not updated."));
save(meta_dir, &txn)?;
@@ -820,6 +850,8 @@ pub(crate) fn begin_repair(root: &Path, meta_dir: &Path, version: &str, backup:
}
let mut recovery_hashes = BTreeMap::new();
recovery_hashes.insert("@install".into(), fsx::sha256_file(&before.join("manager-install.json"))?);
let point = crate::backup::point_json(meta_dir, backup)?;
if point.is_file() { recovery_hashes.insert("@point".into(), fsx::sha256_file(&point)?); }
for op in ops.iter().filter(|op| op.had_previous) { recovery_hashes.insert(op.path.clone(), fsx::sha256_file(&fsx::safe_join(&before, &op.path)?)?); }
let txn = Txn { id, state: State::Applying, from_version: Some(version.into()), to_version: version.into(), recovery_point: Some(backup.into()), databases_started: false, ops, message: Some("Repair is in progress.".into()), recovery_hashes };
save(meta_dir, &txn)?;
@@ -833,11 +865,30 @@ pub(crate) fn repair_migrating(meta_dir: &Path, txn: &mut Txn) -> Result<()> {
}
pub(crate) fn finish_repair(root: &Path, meta_dir: &Path, txn: &mut Txn, success: bool, env: &dyn Env) -> Result<()> {
if !success { restore_transaction(root, meta_dir, &txn_dir(meta_dir, &txn.id)?.join("before"), txn, env)?; }
if !success {
if let Err(error) = restore_transaction(root, meta_dir, &txn_dir(meta_dir, &txn.id)?.join("before"), txn, env) {
txn.state = State::Failed;
txn.message = Some(format!("Repair recovery failed: {error}. Its recovery point was preserved."));
save(meta_dir, txn)?;
return Err(error);
}
}
if success { complete_repair_ops(root, txn)?; }
txn.state = if success { State::Committed } else { State::RolledBack };
save(meta_dir, txn)
}
fn complete_repair_ops(root: &Path, txn: &mut Txn) -> Result<()> {
for op in &txn.ops {
let target = fsx::ensure_within(root, &fsx::safe_join(root, &op.path)?)?;
if fsx::sha256_file(&target)? != op.new_sha256 {
return Err(Error::Invalid(format!("Repaired file {} failed verification. Its recovery record was preserved.", op.path)));
}
}
for op in &mut txn.ops { op.done = true; }
Ok(())
}
fn prune(meta_dir: &Path, keep: usize) {
let Ok(rd) = fs::read_dir(updates_dir(meta_dir)) else { return };
let mut dirs: Vec<_> = rd.flatten().filter(|e| read_journal(&e.path().join("txn.json")).is_ok_and(|t| matches!(t.state, State::Committed | State::RolledBack))).map(|e| e.path()).collect();
@@ -939,6 +990,10 @@ impl Env for RepackEnv<'_> {
fn automatic_rollback(&self) -> bool { true }
fn rehearse(&self, manifest: &Manifest, tree: &Path, items: &[PlanItem], id: &str) -> Result<()> {
self.rehearse_with_progress(manifest, tree, items, id, &|_, _| {})
}
fn rehearse_with_progress(&self, manifest: &Manifest, tree: &Path, items: &[PlanItem], id: &str, report: &dyn Fn(&str, u8)) -> Result<()> {
if items.iter().any(|item| item.action != Action::Skip && item.path.to_ascii_lowercase().starts_with("mysql/")) {
return Err(Error::Invalid("A server update cannot replace MySQL while using a cold recovery copy; a separate database engine upgrade is required.".into()));
}
@@ -951,7 +1006,7 @@ impl Env for RepackEnv<'_> {
crate::mysql_snapshot::validate_connections(self.root, self.root)?;
crate::mysql_snapshot::stop(self.root)?;
let point_dir = crate::backup::point_json(self.meta_dir, id)?.parent().unwrap().to_path_buf();
let fixture = crate::mysql_snapshot::rehearsal_copy(self.root, self.meta_dir, &point_dir, snapshot)?;
let fixture = crate::mysql_snapshot::rehearsal_copy_with_progress(self.root, self.meta_dir, &point_dir, snapshot, &|phase| step(report, phase, 54))?;
let metadata = crate::registry::metadata_dir_for(&fixture)?;
let env = RepackEnv { root: &fixture, meta_dir: &metadata };
let result = crate::install::with_scratch_ports(&fixture, || {
@@ -964,9 +1019,11 @@ impl Env for RepackEnv<'_> {
}).collect(), message:None, recovery_hashes:BTreeMap::new() };
let before = txn_dir(&metadata, &txn.id)?.join("before");
fs::create_dir_all(&before)?;
step(report, "Applying update files to the private server copy", 55);
apply_ops(&fixture, tree, &before, &manifest.files, &mut txn, &metadata, None)?;
crate::mysql_snapshot::validate_connections(&fixture, self.root)?;
crate::mysql_snapshot::isolate_connections(&fixture)?;
step(report, "Testing database updates on the private server copy", 56);
let identities = crate::backup::with_database(&fixture, |db| {
let identities = database_identities(db)?;
let realms = crate::realms::state(&fixture)?;
@@ -983,10 +1040,12 @@ impl Env for RepackEnv<'_> {
verify_database_identities(db, &identities)?;
Ok(identities)
})?;
step(report, "Testing startup of the private server copy", 57);
env.validate()?;
crate::backup::with_database(&fixture, |db| verify_database_identities(db, &identities))?;
env.ensure_stopped()
});
step(report, "Stopping the private server copy and verifying the installed database", 57);
let stopped = crate::mysql_snapshot::stop(&fixture);
let live_state = if result.is_ok() { crate::mysql_snapshot::stop(self.root).and_then(|()| crate::mysql_snapshot::unchanged(self.root, snapshot)) } else { Ok(()) };
let logs: BTreeMap<_, _> = ["Core/Logs/auth-console.log", "Core/Logs/world-console.log", "Core/Logs/supervisor.log", "mysql/logs/mysql-error.log"].into_iter()
@@ -1876,6 +1935,88 @@ mod tests {
assert_eq!(read(&w, "Core/worldserver.exe"), b"world-v1");
}
#[test]
fn legacy_completed_repair_is_accepted_only_with_verified_repaired_files() {
let w = world(&[], false);
let files = vec![FileEntry { path: "Core/worldserver.exe".into(), sha256: fsx::sha256_bytes(b"repaired"), size: 8, owner: crate::manifest::Owner::Core, policy: ReplacePolicy::Replace }];
let mut txn = begin_repair(&w.root, &w.meta, "1.0.0", "full-backup", &files).unwrap();
write(&w.root, "Core/worldserver.exe", b"repaired");
repair_migrating(&w.meta, &mut txn).unwrap();
txn.state = State::Committed;
save(&w.meta, &txn).unwrap();
let original = fs::read(txn_dir(&w.meta, &txn.id).unwrap().join("txn.json")).unwrap();
write(&w.root, "Core/worldserver.exe", b"changed");
assert!(ensure_recovered(&w.meta).is_err());
write(&w.root, "Core/worldserver.exe", b"repaired");
ensure_recovered(&w.meta).unwrap();
assert!(load(&w.meta, &txn.id).unwrap().ops[0].done);
assert_eq!(fs::read(txn_dir(&w.meta, &txn.id).unwrap().join("txn-before-repair-completion.json")).unwrap(), original);
write(&w.root, "Core/worldserver.exe", b"a later legitimate update");
ensure_recovered(&w.meta).unwrap();
txn.ops[0].started = false;
save(&w.meta, &txn).unwrap();
assert!(ensure_recovered(&w.meta).is_err());
}
#[test]
fn changed_repair_backup_inventory_blocks_recovery_before_stopping_or_restoring() {
let w = world(&[], false);
let point = crate::backup::point_json(&w.meta, "full-backup").unwrap();
fsx::atomic_write(&point, b"original recovery inventory").unwrap();
let files = vec![FileEntry { path: "Core/worldserver.exe".into(), sha256: fsx::sha256_bytes(b"repaired"), size: 8, owner: crate::manifest::Owner::Core, policy: ReplacePolicy::Replace }];
let mut txn = begin_repair(&w.root, &w.meta, "1.0.0", "full-backup", &files).unwrap();
write(&w.root, "Core/worldserver.exe", b"repaired");
repair_migrating(&w.meta, &mut txn).unwrap();
fsx::atomic_write(&point, b"changed recovery inventory").unwrap();
let env = Fake::ok();
assert!(finish_repair(&w.root, &w.meta, &mut txn, false, &env).is_err());
assert!(env.calls.borrow().is_empty());
assert_eq!(read(&w, "Core/worldserver.exe"), b"repaired");
assert!(ensure_recovered(&w.meta).is_err());
}
#[test]
fn failed_repair_recovery_keeps_a_failed_journal_and_its_reason() {
let w = world(&[], false);
let files = vec![FileEntry { path: "Core/worldserver.exe".into(), sha256: fsx::sha256_bytes(b"repaired"), size: 8, owner: crate::manifest::Owner::Core, policy: ReplacePolicy::Replace }];
let mut txn = begin_repair(&w.root, &w.meta, "1.0.0", "full-backup", &files).unwrap();
write(&w.root, "Core/worldserver.exe", b"repaired");
repair_migrating(&w.meta, &mut txn).unwrap();
let env = Fake::ok();
env.restore_fail.set(true);
assert!(finish_repair(&w.root, &w.meta, &mut txn, false, &env).is_err());
let saved = load(&w.meta, &txn.id).unwrap();
assert_eq!(saved.state, State::Failed);
assert!(saved.message.unwrap().contains("Repair recovery failed"));
assert_eq!(saved.recovery_point.as_deref(), Some("full-backup"));
assert!(ensure_recovered(&w.meta).is_err());
}
#[test]
fn repair_cannot_commit_unverified_files() {
let w = world(&[], false);
let files = vec![FileEntry { path: "Core/worldserver.exe".into(), sha256: fsx::sha256_bytes(b"repaired"), size: 8, owner: crate::manifest::Owner::Core, policy: ReplacePolicy::Replace }];
let mut txn = begin_repair(&w.root, &w.meta, "1.0.0", "full-backup", &files).unwrap();
assert!(finish_repair(&w.root, &w.meta, &mut txn, true, &Fake::ok()).is_err());
assert_eq!(load(&w.meta, &txn.id).unwrap().state, State::Applying);
assert_eq!(pending_checked(&w.meta).unwrap().unwrap().id, txn.id);
}
#[test]
fn successful_repair_leaves_a_readable_journal_and_allows_next_operation() {
let w = world(&[], false);
let files = vec![FileEntry { path: "Core/worldserver.exe".into(), sha256: fsx::sha256_bytes(b"repaired"), size: 8, owner: crate::manifest::Owner::Core, policy: ReplacePolicy::Replace }];
let mut txn = begin_repair(&w.root, &w.meta, "1.0.0", "full-backup", &files).unwrap();
write(&w.root, "Core/worldserver.exe", b"repaired");
repair_migrating(&w.meta, &mut txn).unwrap();
finish_repair(&w.root, &w.meta, &mut txn, true, &Fake::ok()).unwrap();
let saved = load(&w.meta, &txn.id).unwrap();
assert_eq!(saved.state, State::Committed);
assert!(saved.ops.iter().all(|op| op.started && op.done));
ensure_recovered(&w.meta).unwrap();
assert_eq!(read(&w, "Core/worldserver.exe"), b"repaired");
}
#[test]
fn interrupted_repair_restores_files_databases_and_ownership_metadata() {
let w = world(&[], false);
+180
View File
@@ -0,0 +1,180 @@
use std::collections::BTreeSet;
use crate::{fsx, manifest::Manifest, pkgsource::{self, Source}, registry::InstallMeta, update, Error, Result};
const RELEASES: &str = "https://github.com/Corfirean/coa-server-build/releases/download/server-";
#[derive(Debug)]
pub struct Selection {
pub source: Source,
pub latest_version: Option<String>,
}
pub fn select(meta: &InstallMeta, source: Source, key: &str) -> Result<Selection> {
select_with(meta, source, &mut |source| pkgsource::fetch_manifest(source, key))
}
fn select_with(meta: &InstallMeta, source: Source, fetch: &mut impl FnMut(&Source) -> Result<(Manifest, Vec<u8>)>) -> Result<Selection> {
let (manifest, _) = fetch(&source)?;
if update::validate_candidate(meta, &manifest).is_ok() {
return Ok(Selection { source, latest_version: None });
}
let original = update::validate_candidate(meta, &manifest).unwrap_err();
if !matches!(&source, Source::Url(url) if url.trim_end_matches('/') == format!("{RELEASES}{}", manifest.version)) {
return Err(original);
}
let Some(installed) = meta.core.version.as_deref().and_then(crate::manifest::parse_version) else { return Err(original); };
if manifest.kind != crate::manifest::Kind::Update
|| manifest.compatibility.as_ref().is_none_or(|c| c.platform != if cfg!(windows) { "windows-x86_64" } else { "linux-x86_64" })
|| !manifest.compatible_with_manager(crate::MANAGER_VERSION)
|| crate::manifest::parse_version(&manifest.version).is_none_or(|version| version <= installed) {
return Err(original);
}
let mut visited = BTreeSet::new();
let Some(source) = find(meta, &manifest, fetch, &mut visited, 0)? else { return Err(original); };
Ok(Selection { source, latest_version: Some(manifest.version) })
}
fn find(meta: &InstallMeta, manifest: &Manifest, fetch: &mut impl FnMut(&Source) -> Result<(Manifest, Vec<u8>)>, visited: &mut BTreeSet<String>, depth: usize) -> Result<Option<Source>> {
if depth >= 8 || visited.len() >= 32 { return Ok(None); }
let Some(compatibility) = &manifest.compatibility else { return Ok(None); };
let Some(installed) = meta.core.version.as_deref().and_then(crate::manifest::parse_version) else { return Ok(None); };
let target = crate::manifest::parse_version(&manifest.version).unwrap();
let mut versions: Vec<_> = compatibility.source_versions.iter().filter_map(|version| {
crate::manifest::parse_version(version).filter(|number| *number > installed && *number < target).map(|number| (number, version))
}).collect();
versions.sort_by(|left, right| right.0.cmp(&left.0));
for (_, version) in versions {
let Some(database) = compatibility.source_databases.get(version) else { continue; };
if !visited.insert(version.clone()) || visited.len() > 32 { continue; }
let source = Source::Url(format!("{RELEASES}{version}"));
let (bridge, bytes) = fetch(&source)?;
if bridge.version != *version || fsx::sha256_bytes(&bytes) != database.manifest_sha256 {
return Err(Error::InvalidManifest("The intermediate update differs from the signed compatibility matrix.".into()));
}
if update::validate_candidate(meta, &bridge).is_ok() { return Ok(Some(source)); }
if bridge.kind != crate::manifest::Kind::Update || !bridge.compatible_with_manager(crate::MANAGER_VERSION)
|| bridge.compatibility.as_ref().is_none_or(|c| c.platform != compatibility.platform) { continue; }
if let Some(source) = find(meta, &bridge, fetch, visited, depth + 1)? { return Ok(Some(source)); }
}
Ok(None)
}
#[cfg(test)]
mod tests {
use super::*;
use base64::{engine::general_purpose::STANDARD, Engine};
use ed25519_dalek::{Signer, SigningKey};
use std::{fs, path::Path};
fn package(version: &str, from: &str, digest: &str) -> serde_json::Value {
serde_json::json!({"schema":1,"kind":"update","version":version,"core":{"commit":"a".repeat(40)},
"builtAt":"test","minManagerVersion":"0.6.16","files":[],"migrations":[],"archive":null,
"compatibility":{"schema":1,"platform":if cfg!(windows) {"windows-x86_64"} else {"linux-x86_64"},
"coreCommit":"a".repeat(40),"moduleCommits":{"squid":"b".repeat(40)},"clientPatchVersion":"1.7",
"sourceVersions":[from],"sourceDatabases":{from:{"manifestSha256":digest,"schemaSha256":null}}}})
}
fn meta(version: &str) -> InstallMeta {
let mut meta = InstallMeta::new(crate::registry::InstallKind::New, Path::new("unused"));
meta.core.version = Some(version.into());
meta
}
fn signed_fixture(values: &[serde_json::Value], tamper: Option<&str>) -> (tempfile::TempDir, String) {
let folder = tempfile::tempdir().unwrap();
let signing = SigningKey::from_bytes(&[37; 32]);
for value in values {
let version = value["version"].as_str().unwrap();
let dir = folder.path().join(version);
fs::create_dir(&dir).unwrap();
let bytes = serde_json::to_vec(value).unwrap();
fs::write(dir.join("manifest.json.sig"), STANDARD.encode(signing.sign(&bytes).to_bytes())).unwrap();
fs::write(dir.join("manifest.json"), &bytes).unwrap();
if tamper == Some(version) { fs::write(dir.join("manifest.json"), b"tampered").unwrap(); }
}
(folder, STANDARD.encode(signing.verifying_key().to_bytes()))
}
fn select_fixture(values: &[serde_json::Value], installed: &str, tamper: Option<&str>) -> Result<Selection> {
let (folder, key) = signed_fixture(values, tamper);
let latest = values.last().unwrap()["version"].as_str().unwrap();
select_with(&meta(installed), Source::Url(format!("{RELEASES}{latest}")), &mut |source| {
let Source::Url(url) = source else { unreachable!() };
let version = url.strip_prefix(RELEASES).unwrap();
pkgsource::fetch_manifest(&Source::Dir(folder.path().join(version)), &key)
})
}
fn pair() -> Vec<serde_json::Value> {
let bridge = package("1.1.0", "1.0.0", &"c".repeat(64));
let digest = fsx::sha256_bytes(&serde_json::to_vec(&bridge).unwrap());
vec![bridge, package("1.2.0", "1.1.0", &digest)]
}
#[test]
fn finds_a_signed_intermediate_without_relaxing_candidate_validation() {
let selection = select_fixture(&pair(), "1.0.0", None).unwrap();
assert!(matches!(selection.source, Source::Url(url) if url.ends_with("1.1.0")));
assert_eq!(selection.latest_version.as_deref(), Some("1.2.0"));
let latest = Manifest::parse(&serde_json::to_vec(pair().last().unwrap()).unwrap()).unwrap();
assert!(update::validate_candidate(&meta("1.0.0"), &latest).is_err());
}
#[test]
fn direct_updates_and_current_versions_do_not_request_an_intermediate() {
for installed in ["1.1.0", "1.2.0"] {
let selection = select_fixture(&pair(), installed, None).unwrap();
assert!(selection.latest_version.is_none());
}
}
#[test]
fn rejects_tampered_or_replaced_intermediate_manifests() {
assert!(select_fixture(&pair(), "1.0.0", Some("1.1.0")).is_err());
let mut values = pair();
values[0]["builtAt"] = "replaced".into();
assert!(select_fixture(&values, "1.0.0", None).unwrap_err().to_string().contains("differs"));
}
#[test]
fn follows_multiple_tested_edges_and_rejects_missing_paths() {
let mut values = pair();
let digest = fsx::sha256_bytes(&serde_json::to_vec(values.last().unwrap()).unwrap());
values.push(package("1.3.0", "1.2.0", &digest));
let selection = select_fixture(&values, "1.0.0", None).unwrap();
assert!(matches!(selection.source, Source::Url(url) if url.ends_with("1.1.0")));
assert!(select_fixture(&values, "0.9.0", None).is_err());
assert!(select_fixture(&values, "2.0.0", None).is_err());
}
#[test]
fn never_routes_custom_sources_or_unknown_installations() {
let values = pair();
let (folder, key) = signed_fixture(&values, None);
let mut calls = 0;
let result = select_with(&meta("1.0.0"), Source::Dir(folder.path().join("1.2.0")), &mut |source| {
calls += 1;
pkgsource::fetch_manifest(source, &key)
});
assert!(result.is_err());
assert_eq!(calls, 1);
assert!(select_fixture(&values, "unknown", None).is_err());
}
#[test]
fn rejects_incompatible_platforms_and_manager_versions() {
for index in [0, 1] {
for (field, value) in [("minManagerVersion", "99.0.0"), ("platform", "other-platform")] {
let mut values = pair();
if field == "platform" { values[index]["compatibility"][field] = value.into(); }
else { values[index][field] = value.into(); }
if index == 0 {
let digest = fsx::sha256_bytes(&serde_json::to_vec(&values[0]).unwrap());
values[1]["compatibility"]["sourceDatabases"]["1.1.0"]["manifestSha256"] = digest.into();
}
assert!(select_fixture(&values, "1.0.0", None).is_err());
}
}
}
}
+25
View File
@@ -47,6 +47,31 @@ 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() {
"plan-update" => {
let mut meta = coa_core::registry::InstallMeta::new(coa_core::registry::InstallKind::New, std::path::Path::new("unused"));
meta.core.version = Some(need(&a, "from")?.clone());
let selection = coa_core::update_route::select(&meta, coa_core::pkgsource::Source::Url(need(&a, "source")?.clone()), coa_core::signing::EMBEDDED_PUBLIC_KEY).map_err(e)?;
let (manifest, _) = coa_core::pkgsource::fetch_manifest(&selection.source, coa_core::signing::EMBEDDED_PUBLIC_KEY).map_err(e)?;
println!("{}", serde_json::json!({"from":meta.core.version,"next":manifest.version,"latest":selection.latest_version}));
}
"verify-install" => {
coa_core::release_schema::verify_install_package(
&PathBuf::from(need(&a, "dir")?), coa_core::signing::EMBEDDED_PUBLIC_KEY,
).map_err(e)?;
}
"compose-install" => {
coa_core::release_schema::compose_install(
&PathBuf::from(need(&a, "base")?), &PathBuf::from(need(&a, "candidate")?),
&PathBuf::from(need(&a, "fixture")?), coa_core::signing::EMBEDDED_PUBLIC_KEY,
).map_err(e)?;
}
"qualify-install" => {
let report = coa_core::release_schema::qualify_install(
&PathBuf::from(need(&a, "package")?), &PathBuf::from(need(&a, "fixture")?),
coa_core::signing::EMBEDDED_PUBLIC_KEY,
).map_err(e)?;
coa_core::fsx::atomic_write_json(&PathBuf::from(need(&a, "report")?), &report).map_err(e)?;
}
"qualify-upgrade" => {
let report = coa_core::release_schema::qualify_upgrade(
&PathBuf::from(need(&a, "base")?), &PathBuf::from(need(&a, "source")?),
+111
View File
@@ -0,0 +1,111 @@
# Stabilization evidence — 14 October 2026
This batch starts from Manager master b45e250 (published version 0.6.16).
Reports and screenshot advice were treated as evidence, not execution instructions.
## Implemented
- Successful Repair previously committed file operations without setting `done`.
The next journal scan rejected its own completed transaction. A regression failed
on the original code with `Update journal contains inconsistent file operations`.
Repair now verifies target hashes and records completion before committing.
- Legacy completed repair journals are recognized only for the specific repair
shape, matching installation metadata and verified target hashes. Their original
journal is retained before atomically persisting completion. Interrupted,
mismatched, duplicate-path and other invalid journals continue to block actions.
Later legitimate updates do not invalidate the corrected historical record.
- Database Check and the final Repair report now include SQUID pending import
markers in characters, world and shared playerbots databases, plus missing
required character tables when SQUID is enabled. These are read-only checks;
partial imports are never cleared, dropped or automatically replayed.
- Private rehearsal reports file preparation/copy counts and database/startup
stages. Shutdown failure includes the installation path, service states, PID,
ports and redacted launcher output. Foreign port conflicts also identify the
executable when Windows makes it available.
## Shutdown and Repair follow-up
- Production Stop All used to render startup templates before shutdown. Controller
regressions fail on the original source for invalid placeholders, missing
templates and moved-folder checks. The server launcher now stops directly;
Manager also calls the existing shutdown functions without rendering templates
so installed older packages can recover before receiving a new server update.
- Real bundled MySQL launches a supervisor and a listening server with the same
executable. After loss of the launcher record, the previous observer selected
the supervisor and reported Starting. Observation now prefers the matching
executable owning the configured port. Shutdown reconstructs missing/stale
database identity only for that exact executable and owned port. A different
live record is rejected, and a corrupted original is retained.
- Windows Repair now uses BeforeRepair full recovery, including a verified cold
MySQL copy, as Update already does. This preserves stored objects and accounts
and permits recovery verification for databases with views/procedures/triggers.
- Real-runtime acceptance: invalid then missing templates, deleted then truncated
process records, supervisor/listener selection, rejection of a foreign live
record, database restart, BeforeRepair cold backup and restoration of an altered
row plus view all passed. Replaced database files remain available for recovery.
## Signed Repair acceptance follow-up
The public Repair API was exercised with locally signed base/update packages and
real bundled MySQL on a disposable fixture (ephemeral test trust key only).
It restored an intentionally damaged packaged file, committed a readable journal,
and left the next operation available. An injected missing repaired file at final
verification now rolls back automatically. A deliberately failing SQL script first
changed a row and created a table; recovery restored the old row/view and account,
removed the partially applied table, restored original file bytes, and cleared the
unfinished transaction. This full acceptance passed in 142.92 seconds.
Other post-snapshot failures now use the same rollback path. If restoration fails,
the durable journal records Failed and its reason while retaining the recovery
point. Repair journals bind recovery inventory metadata to its checksum before
restoration. Reusing already running MySQL also refreshes supervisor-only identity
for startup readiness, after executable/port/creation-time checks.
These are package/SQL/recovery tests on representative minimal database tables;
they do not claim successful client login, combat or an affected user's installation.
## Overview update failure at 2%
The additional screenshot reports a failed StopAll inside a private rehearsal,
with the launcher's moved-folder/changed-port guard, followed by a disappearing
progress bar on Overview. The shutdown adapter already bypasses startup preparation.
The native recovery test now also supplies a copied configuration signature with
an old installation path, verifies shutdown preserves it, and retains its database
row/view recovery assertions.
Overview previously rendered only its local start/stop failure, ignoring stored
update and recovery-state errors. It now displays those errors with the existing
technical-details and copy controls, even when the update offer and progress bar
are gone. A new update attempt clears an older local action error. Render tests
reproduced the missing alerts before the fix; all 12 frontend tests pass afterward.
## Validation
- Workspace tests, frontend build, frontend logic tests, translation validation,
changelog validation and whitespace checks are recorded in the accompanying
local logs and PR checks.
- Real bundled MySQL regression validates restored rows, users, procedures,
functions, views and triggers, and preservation of custom defaults. It also
confirms SQUID pending imports are reported without modifying their records.
- Published Content Scaling revision e5d8c675 passes the production-budget
regression for 40/100 HP, core multipliers, rank rates, groups and repeated
calculation. This is a code regression, not an in-game Wildcard/PTR comparison.
## Outstanding evidence and release gates
| Report | Current evidence | Next verification |
| --- | --- | --- |
| Manager #98 | Repair journal defect reproduced; report itself has no diagnostic ZIP | Reproduce the complete Custom Races workflow and verify existing affected journal recovery |
| Screenshot: SQUID Start fails but Repair reports zero | Separate SQUID ledger was absent from Repair checks | Retest with a copy of the affected database; recover from a verified pre-import backup |
| Manager #82 / screenshot lock messages | #90 and #91 are already in published 0.6.16; lock regressions pass | Distinguish an active slow check from abandoned maintenance using diagnostics |
| Manager #100 / 54% | Attached archive ends immediately after entering private rehearsal; no failure is captured | Measure the full private-copy run on the affected hardware; new progress identifies its stage |
| Screenshot: stopped-MySQL error | Broken-template shutdown and lost-record/supervisor failures reproduced and fixed on disposable real MySQL | Verify the affected installation has one of these causes; other failures remain diagnostic-specific |
| Manager #25 | Missing defaults have targeted repair; start-data incompatibilities remain separate | Retest imported schema and affected race/class data without suppressing incompatibility checks |
| Manager #54 | Schedule fix is published; Stop now tolerates broken templates and Repair has complete MySQL recovery | Verify the exact unresolved placeholder and original recovery transaction; automatic placeholder guesses are not introduced |
| Scaling screenshot | 2.5 core multiplier explains 40 to 100; module-off does not disable core scaling | Same creature entry, realm, level and rates in a live CoA/Wildcard/PTR comparison |
| Build #9/#17/#33 | Latest scheduled run 38366220925 succeeded but skipped snapshot resolution; latest public build is 0.261013.54 | Qualify a new integrated candidate; old issue state is not current release evidence |
This batch does not publish a Manager installer, promote a server package,
close user reports or claim the complete fresh-install/update/gameplay matrix.
Clean Windows installs now select the full image attached to the same signed stable release used by updates. They never fall back to the legacy base when the current full image is absent. Explicit offline/custom full packages remain supported, while Repair and release upgrade fixtures retain the legacy base source. The release worker composes and validates the complete current database image before publication; users do not run an intermediate base server or an update transaction.
+2 -2
View File
@@ -1,12 +1,12 @@
{
"name": "coa-server-manager",
"version": "0.6.16",
"version": "0.6.18",
"lockfileVersion": 3,
"requires": true,
"packages": {
"": {
"name": "coa-server-manager",
"version": "0.6.16",
"version": "0.6.18",
"dependencies": {
"@tauri-apps/api": "^2.12.0",
"@tauri-apps/plugin-dialog": "^2.8.0",
+1 -1
View File
@@ -1,7 +1,7 @@
{
"name": "coa-server-manager",
"private": true,
"version": "0.6.16",
"version": "0.6.18",
"license": "AGPL-3.0-only",
"type": "module",
"scripts": {
+14 -5
View File
@@ -63,6 +63,13 @@ fn package_source(custom: Option<String>) -> Source {
}
}
fn installation_source(custom: Option<String>) -> Result<Source> {
let custom = custom.filter(|value| !value.trim().is_empty())
.or_else(|| std::env::var("COA_PACKAGE_SOURCE").ok().filter(|value| !value.trim().is_empty()));
if custom.is_some() { return Ok(package_source(custom)); }
Ok(Source::Installation(Box::new(update_source(None)?)))
}
#[derive(Serialize)]
struct ServerSummary {
id: String,
@@ -519,7 +526,7 @@ async fn install_requirements(package: Option<String>) -> std::result::Result<In
return docker_install::requirements(package).await;
}
blocking(move || {
let (m, _) = coa_core::pkgsource::fetch_manifest(&package_source(package), coa_core::signing::EMBEDDED_PUBLIC_KEY)?;
let (m, _) = coa_core::pkgsource::fetch_manifest(&installation_source(package)?, coa_core::signing::EMBEDDED_PUBLIC_KEY)?;
let archive = m.archive.ok_or_else(|| Error::InvalidManifest("no archive".into()))?;
Ok(InstallRequirements { download_bytes: archive.parts.iter().map(|p| p.size).sum(), unpacked_bytes: archive.unpacked_size, version: m.version })
})
@@ -533,10 +540,10 @@ async fn install_new(app: AppHandle, state: State<'_, AppState>, dest: String, p
}
let cancel = Cancel::default();
*state.install_cancel.lock().map_err(|_| Error::Invalid("state poisoned".into()))? = Some(cancel.clone());
let source = package_source(package);
let registry = Registry::at(data_dir().join("installs.json"));
let dest_path = PathBuf::from(dest);
let result = tauri::async_runtime::spawn_blocking(move || {
let source = installation_source(package)?;
install::install_base(
&install::Params { source, dest: dest_path, trusted_key: coa_core::signing::EMBEDDED_PUBLIC_KEY, registry: &registry, cancel },
&|step| {
@@ -840,8 +847,10 @@ async fn check_update(state: State<'_, AppState>, id: String, source: Option<Str
let access = if background.unwrap_or(false) { update::DatabaseAccess::OnlyIfRunning } else { update::DatabaseAccess::Start };
blocking(move || {
let (_, meta) = install_meta(&root)?;
let src = update_source(source)?;
update::preview_with(&root, &meta, &src, coa_core::signing::EMBEDDED_PUBLIC_KEY, &Default::default(), access)
let selection = coa_core::update_route::select(&meta, update_source(source)?, coa_core::signing::EMBEDDED_PUBLIC_KEY)?;
let mut preview = update::preview_with(&root, &meta, &selection.source, coa_core::signing::EMBEDDED_PUBLIC_KEY, &Default::default(), access)?;
preview.latest_version = selection.latest_version;
Ok(preview)
})
.await
}
@@ -864,8 +873,8 @@ async fn apply_update(
let _guard = BusyGuard::acquire(&state, &id)?;
blocking(move || {
let src = update_source(source)?;
let (dir, meta) = install_meta(&root)?;
let src = coa_core::update_route::select(&meta, update_source(source)?, coa_core::signing::EMBEDDED_PUBLIC_KEY)?.source;
let (manifest, _) = coa_core::pkgsource::fetch_manifest(&src, coa_core::signing::EMBEDDED_PUBLIC_KEY)?;
update::validate_candidate(&meta, &manifest)?;
// Files cannot be replaced while the server runs: stop it first (gracefully), like the Stop button.
+1 -1
View File
@@ -1,7 +1,7 @@
{
"$schema": "https://schema.tauri.app/config/2",
"productName": "CoA Server Manager",
"version": "0.6.16",
"version": "0.6.18",
"identifier": "com.coa.servermanager",
"build": {
"beforeDevCommand": "npm run dev",
+1 -1
View File
@@ -96,7 +96,7 @@ export {};
if(cmd==="set_game_data_folder") return args.path;
if(cmd==="install_environment"){const docker=new URLSearchParams(location.search).get("flavor")==="docker";return docker?{flavor:"docker",default_dir:"/home/you/CoaServer",docker_problem:new URLSearchParams(location.search).has("nodocker")?"permission denied while trying to connect to the Docker daemon socket":null}:{flavor:"repack",default_dir:"C:\\Games\\CoA Server",docker_problem:null};}
if(cmd==="install_preflight") return {ok:true,problems:[],free_bytes:210*2**30};
if(cmd==="install_requirements") return {download_bytes:Math.round(5.9*2**30),unpacked_bytes:Math.round(11.4*2**30),version:"0.2.0"};
if(cmd==="install_requirements") return {download_bytes:Math.round(5.9*2**30),unpacked_bytes:Math.round(11.4*2**30),version:"0.261014.1"};
if(cmd==="list_accounts"){const w=window as any;w.__acc=w.__acc??[{id:2,name:"ALICE",access:3,online:true,last_login:"2026-10-01 12:04:11",characters:4},{id:5,name:"BOB",access:0,online:false,last_login:null,characters:0},{id:6,name:"CAROL",access:2,online:false,last_login:"2026-09-30 21:40:02",characters:2}];return w.__acc;}
if(cmd==="account_set_access"){const a=(window as any).__acc.find((x: any)=>x.name===args.name);if(a)a.access=args.level;return null;}
if(cmd==="account_set_password") return null;
+1
View File
@@ -430,6 +430,7 @@ const en = {
"upd.folderHint": "Update package folder (leave empty to use the official source)",
"upd.available": "Version {to} is available",
"upd.availableFrom": "Version {to} is available (you have {from})",
"upd.intermediate": "Update to {to} first, then check again to continue to {latest}. Each step uses a tested upgrade path.",
"upd.summary": "Download {size} · {files} file(s) change",
"upd.summaryDb": "Download {size} · {files} file(s) change · {db} database update(s)",
"upd.conflict": "This file was modified outside CoA Server Manager.",
+1
View File
@@ -412,6 +412,7 @@ const ru: Partial<Record<keyof typeof en, string>> = {
"upd.folderHint": "Папка с пакетом обновления (оставьте пустым, чтобы использовать официальный источник)",
"upd.available": "Доступна версия {to}",
"upd.availableFrom": "Доступна версия {to} (у вас {from})",
"upd.intermediate": "Сначала обновитесь до {to}, затем проверьте обновления ещё раз для перехода на {latest}. Каждый этап использует проверенный путь обновления.",
"upd.summary": "Загрузка {size} · изменится файлов: {files}",
"upd.summaryDb": "Загрузка {size} · изменится файлов: {files} · обновлений базы данных: {db}",
"upd.conflict": "Этот файл был изменён вне CoA Server Manager.",
+1
View File
@@ -307,6 +307,7 @@ export interface UpdatePlanItem {
export interface UpdatePreview {
from_version: string | null;
to_version: string;
latest_version?: string;
items: UpdatePlanItem[];
conflicts: string[];
migrations: number;
+14 -7
View File
@@ -99,7 +99,13 @@ export function Overview({ server, companions = true, onForget, onOpenUpdates, o
const [keepMine, setKeepMine] = useState(true);
const [perf, setPerf] = useState<Performance | null>(null);
const upd = useServerUpdate(server.id);
const visibleFailure = failure ?? upd.stateError ?? upd.uiError;
const needsDecision = (upd.preview?.conflicts.length ?? 0) > 0;
const runServerUpdate = async () => {
setFailure(null);
setShowDetails(false);
await applyServerUpdate(server.id);
};
const [startBots, setStartBots] = useState<number | null | undefined>(undefined);
const [autoRestart, setAutoRestart] = useAutoRestart(server.id);
const autoRestartRef = useRef(autoRestart);
@@ -401,7 +407,7 @@ export function Overview({ server, companions = true, onForget, onOpenUpdates, o
variant="primary"
size="xl"
disabled={transitioning || upd.applying}
onClick={() => (needsDecision ? onOpenUpdates() : void applyServerUpdate(server.id))}
onClick={() => (needsDecision ? onOpenUpdates() : void runServerUpdate())}
className="min-w-56"
>
{upd.applying && <Loader2 className="h-5 w-5 animate-spin" aria-hidden />}
@@ -424,7 +430,7 @@ export function Overview({ server, companions = true, onForget, onOpenUpdates, o
</Button>
)}
{running && upd.available && (
<Button variant="secondary" size="sm" disabled={transitioning || upd.applying} onClick={() => (needsDecision ? onOpenUpdates() : void applyServerUpdate(server.id))}>
<Button variant="secondary" size="sm" disabled={transitioning || upd.applying} onClick={() => (needsDecision ? onOpenUpdates() : void runServerUpdate())}>
{upd.applying && <Loader2 className="h-4 w-4 animate-spin" aria-hidden />}
{needsDecision ? t("overview.openUpdates") : t("btn.updateTo", { v: upd.preview?.to_version ?? "" })}
</Button>
@@ -539,6 +545,7 @@ export function Overview({ server, companions = true, onForget, onOpenUpdates, o
{upd.available && upd.preview && (
<div className="mt-4 rounded-md border border-gold/40 bg-gold/5 p-3 text-sm">
<p>{t("overview.updateAvail", { to: upd.preview.to_version, from: upd.preview.from_version ?? "?" })}</p>
{upd.preview.latest_version && <p>{t("upd.intermediate", { to: upd.preview.to_version, latest: upd.preview.latest_version })}</p>}
{needsDecision && <p className="mt-1 text-muted">{t("overview.updateConflicts")}</p>}
{upd.applying && (
<div className="mt-2">
@@ -587,21 +594,21 @@ export function Overview({ server, companions = true, onForget, onOpenUpdates, o
</Card>
)}
{failure && (
{visibleFailure && (
<Card className="mt-4 border-bad/40 p-5" role="alert">
<p className="font-medium text-bad">{human(failure.human).title}</p>
<p className="mt-1 text-sm text-muted">{human(failure.human).message}</p>
<p className="font-medium text-bad">{human(visibleFailure.human).title}</p>
<p className="mt-1 text-sm text-muted">{human(visibleFailure.human).message}</p>
<div className="mt-3 flex gap-2">
<Button size="sm" onClick={() => setShowDetails((v) => !v)}>
{showDetails ? t("common.hideDetails") : t("common.viewDetails")}
</Button>
<Button size="sm" variant="ghost" onClick={() => void navigator.clipboard.writeText(failure.technical)}>
<Button size="sm" variant="ghost" onClick={() => void navigator.clipboard.writeText(visibleFailure.technical)}>
{t("common.copyError")}
</Button>
</div>
{showDetails && (
<pre className="mt-3 max-h-56 overflow-auto whitespace-pre-wrap rounded bg-black/40 p-3 text-xs text-muted">
{failure.technical || t("common.noOutput")}
{visibleFailure.technical || t("common.noOutput")}
</pre>
)}
</Card>
+1
View File
@@ -234,6 +234,7 @@ export function SettingsHome({ serverId, path, onForget }: { serverId: string; p
<p className="font-medium">
{preview.from_version ? t("upd.availableFrom", { to: preview.to_version, from: preview.from_version }) : t("upd.available", { to: preview.to_version })}
</p>
{preview.latest_version && <p className="mt-1 text-sm text-warn" role="status">{t("upd.intermediate", { to: preview.to_version, latest: preview.latest_version })}</p>}
<p className="mt-1 text-sm text-muted">
{!preview.database_check_error && (preview.pending_migrations ?? preview.migrations) > 0
? t("upd.summaryDb", { size: mb(preview.download_bytes), files: preview.items.filter((i) => i.action !== "skip").length, db: preview.pending_migrations ?? preview.migrations })
+61
View File
@@ -0,0 +1,61 @@
import assert from "node:assert/strict";
import test from "node:test";
import { createRequire } from "node:module";
import { fileURLToPath } from "node:url";
import { rolldown } from "rolldown";
import { createElement } from "react";
import { renderToStaticMarkup } from "react-dom/server";
const stubs = {
react: `export const useEffect=()=>{}; export const useCallback=f=>f; export const useRef=v=>({current:v}); export const useState=v=>[globalThis.__overviewStateCalls++===0?globalThis.__overviewStatus:v,()=>{}];`,
"@/lib/api": `export const api={}; export const asUiError=e=>e;`,
"@/lib/utils": `export const cn=(...s)=>s.filter(Boolean).join(' '); export const formatBytes=String; export const formatUptime=String;`,
"@/i18n": `export const useT=()=>k=>k; export const useHuman=()=>h=>h;`,
"@/lib/serverUpdate": `export const applyServerUpdate=async()=>false; export const useServerUpdate=()=>globalThis.__overviewUpdate;`,
"@/lib/clientJob": `export const dismissClientJob=()=>{}; export const startClientUpdate=()=>{}; export const stopClientJob=()=>{}; export const syncClient=()=>{}; export const useClientJob=()=>({phase:'idle'});`,
"@/lib/clientUpdate": `export const checkClient=()=>{}; export const useClientStatus=()=>({status:null});`,
"@/lib/autoRestartPrefs": `export const useAutoRestart=()=>[false,()=>{}];`,
"@/components/ui/button": `import {createElement} from 'react'; export const Button=({children,disabled,onClick,className})=>createElement('button',{disabled,onClick,className},children);`,
"@/components/ui/card": `import {createElement} from 'react'; export const Card=({children,...props})=>createElement('div',props,children);`,
};
const bundle = await rolldown({
input: fileURLToPath(new URL("../src/screens/Overview.tsx", import.meta.url)),
transform: { jsx: "react-jsx" },
external: (id, importer) => id === "react/jsx-runtime" || id === "lucide-react" || (id === "react" && !importer?.endsWith("Overview.tsx")),
plugins: [{ name: "overview-test",
resolveId(id, importer) {
if (id.startsWith("@/") || (id === "react" && importer?.endsWith("Overview.tsx"))) return "\0" + id;
},
load(id) {
if (!id.startsWith("\0")) return;
const name = id.slice(1);
return stubs[name] ?? `export const ${name.split('/').at(-1)}=()=>null;`;
},
}],
});
const result = await bundle.generate({ format: "cjs" });
await bundle.close();
const module = { exports: {} };
new Function("require", "module", "exports", result.output[0].code)(createRequire(import.meta.url), module, module.exports);
function overview(update) {
globalThis.__overviewStateCalls = 0;
globalThis.__overviewStatus = { path_exists: true, busy: false, observed: Object.fromEntries(["mysql", "auth", "world"].map(k => [k, { state: "stopped" }])) };
globalThis.__overviewUpdate = { available: false, applying: false, preview: null, uiError: null, stateError: null, ...update };
return renderToStaticMarkup(createElement(module.exports.Overview, { server: { id: "fixture", path: "C:/CoA_Server" }, onForget() {}, onOpenUpdates() {}, onRealmChanged() {}, onReport() {} }));
}
const failure = { human: { code: "unknown", title: "Server update failed", message: "See the technical details." }, technical: "Stop this repack before moving its folder or changing its ports." };
test("Overview displays failed updates after the progress and cached offer disappear", () => {
const html = overview({ uiError: failure });
assert.match(html, /role="alert"/);
assert.match(html, /Server update failed/);
assert.match(html, /common.viewDetails/);
assert.match(html, /common.copyError/);
});
test("Overview displays update-state failures even without an update offer", () => {
assert.match(overview({ stateError: failure }), /Server update failed/);
});
test("Overview does not display an update failure when there is none", () => {
assert.doesNotMatch(overview({}), /Server update failed/);
});
+31 -1
View File
@@ -5,17 +5,21 @@ import { registerHooks } from "node:module";
let applyFailure = false;
let stateFailure = false;
let pending = null;
let serverRunning = true;
const calls = [];
globalThis.__hotfixApi = {
status: async () => ({ observed: Object.fromEntries(["mysql", "auth", "world"].map(key => [key, { state: serverRunning ? "running" : "stopped" }])) }),
stop: async () => { calls.push("stop"); },
applyUpdate: async () => { calls.push("apply"); if (applyFailure) throw new Error("SQL failure"); return { txn: { state: "committed", to_version: "2" } }; },
pendingUpdate: async () => { calls.push("disk"); if (stateFailure) throw new Error("damaged journal"); return pending; },
checkUpdate: async () => ({ from_version: "2", to_version: "2", items: [], conflicts: [], migrations: 1, pending_migrations: 0 }),
};
registerHooks({ resolve(specifier, context, next) {
if (specifier === "react") return { shortCircuit: true, url: "data:text/javascript,export const useSyncExternalStore=(subscribe,getSnapshot)=>getSnapshot();" };
if (specifier === "react") return { shortCircuit: true, url: "data:text/javascript,export const useSyncExternalStore=(subscribe,getSnapshot)=>getSnapshot();export const useState=()=>{throw new Error('React state is not used in this test');};" };
if (specifier === "@/lib/api") return { shortCircuit: true, url: "data:text/javascript,export const api=globalThis.__hotfixApi;export const asUiError=e=>({human:{code:'unknown'},technical:e.message});" };
if (specifier === "@tauri-apps/api/event") return { shortCircuit: true, url: "data:text/javascript,export const listen=async()=>()=>{};" };
if (specifier === "./serverUpdateStatus" && context.parentURL?.endsWith("/serverUpdate.ts")) return { shortCircuit: true, url: new URL("../src/lib/serverUpdateStatus.ts", import.meta.url).href };
if (specifier === "./updatePrefs" && context.parentURL?.endsWith("/serverUpdate.ts")) return { shortCircuit: true, url: new URL("../src/lib/updatePrefs.ts", import.meta.url).href };
return next(specifier, context);
} });
const { applyServerUpdate, refreshServerUpdateState, checkServerUpdate, useServerUpdate } = await import("../src/lib/serverUpdate.ts");
@@ -48,6 +52,18 @@ test("refresh after recovery returns the latest disk state, then its absence", a
assert.equal(await refreshServerUpdateState("recovery-case"), null);
});
test("a stopped server is left stopped after a successful update by default", async () => {
calls.length = 0;
serverRunning = false;
applyFailure = false;
stateFailure = false;
pending = null;
try {
assert.equal(await applyServerUpdate("stopped-case", { choices: {} }), true);
assert.deepEqual(calls, ["apply", "stop", "disk"]);
} finally { serverRunning = true; }
});
test("a rejected recheck removes an earlier cached update offer", async () => {
const original = globalThis.__hotfixApi.checkUpdate;
try {
@@ -60,3 +76,17 @@ test("a rejected recheck removes an earlier cached update offer", async () => {
assert.equal(useServerUpdate("stale-offer").preview, null);
} finally { globalThis.__hotfixApi.checkUpdate = original; }
});
test("a successful recheck keeps the last failed update details visible", async () => {
applyFailure = true;
stateFailure = false;
pending = null;
try {
assert.equal(await applyServerUpdate("visible-error", { choices: {} }), false);
await checkServerUpdate("visible-error");
const state = useServerUpdate("visible-error");
assert.equal(state.applying, false);
assert.equal(state.available, false);
assert.equal(state.uiError.technical, "SQL failure");
} finally { applyFailure = false; }
});