diff --git a/.github/workflows/check.yml b/.github/workflows/check.yml index 20d4693..c2309b4 100644 --- a/.github/workflows/check.yml +++ b/.github/workflows/check.yml @@ -26,5 +26,4 @@ jobs: - run: node tools/check-i18n.mjs - run: npm run build - run: node --experimental-strip-types --test tools/*.test.mjs - - run: python -B -m unittest discover -s tools -p test_launcher_bridge.py - run: cargo test --workspace --locked diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index d53e7ed..7df8ba6 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -74,7 +74,6 @@ jobs: - name: Tests run: cargo test --workspace --locked -- --test-threads=1 - run: node --experimental-strip-types --test tools/*.test.mjs - - run: python -B -m unittest discover -s tools -p test_launcher_bridge.py - name: Build and sign (publish only when requested) id: tauri uses: tauri-apps/tauri-action@v0 diff --git a/Cargo.lock b/Cargo.lock index 71de87c..12d2229 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -606,6 +606,7 @@ dependencies = [ "serde_json", "sha1", "sha2", + "socket2", "tar", "tempfile", "thiserror 2.0.21", @@ -618,6 +619,15 @@ dependencies = [ "zstd", ] +[[package]] +name = "coa-launcher" +version = "0.9.10" +dependencies = [ + "coa-core", + "serde_json", + "windows-sys 0.60.2", +] + [[package]] name = "coa-registry-proto" version = "0.1.0" diff --git a/Cargo.toml b/Cargo.toml index e30c6d8..1e55559 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [workspace] resolver = "2" -members = ["crates/coa-core", "crates/coa-release", "crates/coa-registry-proto", "crates/coa-control-proto", "src-tauri"] +members = ["crates/coa-core", "crates/coa-launcher", "crates/coa-release", "crates/coa-registry-proto", "crates/coa-control-proto", "src-tauri"] exclude = ["services/coa-registry", "services/coa-registry-e2e", "services/coa-coordinator", "services/coa-relay"] [workspace.package] diff --git a/crates/coa-core/Cargo.toml b/crates/coa-core/Cargo.toml index 6f12f60..efae212 100644 --- a/crates/coa-core/Cargo.toml +++ b/crates/coa-core/Cargo.toml @@ -5,6 +5,7 @@ edition.workspace = true license.workspace = true [dependencies] +socket2 = "0.6" serde = { version = "1", features = ["derive"] } serde_json = "1" sha2 = "0.10" @@ -37,7 +38,7 @@ rand_core = { version = "0.6", features = ["getrandom"] } ed25519-dalek = { version = "2", features = ["rand_core"] } [target.'cfg(windows)'.dependencies] -windows-sys = { version = "0.60", features = ["Win32_Foundation", "Win32_Storage_FileSystem", "Win32_System_Threading", "Win32_System_SystemInformation", "Win32_System_Diagnostics_ToolHelp", "Win32_NetworkManagement_IpHelper", "Win32_Networking_WinSock", "Win32_Security_Cryptography", "Win32_UI_Shell", "Win32_System_Registry", "Win32_UI_WindowsAndMessaging"] } +windows-sys = { version = "0.60", features = ["Win32_Foundation", "Win32_Storage_FileSystem", "Win32_System_Threading", "Win32_System_Console", "Win32_System_SystemInformation", "Win32_System_Diagnostics_ToolHelp", "Win32_NetworkManagement_IpHelper", "Win32_Networking_WinSock", "Win32_Security_Cryptography", "Win32_UI_Shell", "Win32_System_Registry", "Win32_UI_WindowsAndMessaging"] } [features] testkit = [] diff --git a/crates/coa-core/examples/launcher_e2e.rs b/crates/coa-core/examples/launcher_e2e.rs new file mode 100644 index 0000000..81692f9 --- /dev/null +++ b/crates/coa-core/examples/launcher_e2e.rs @@ -0,0 +1,114 @@ +//! The Rust launcher on a DISPOSABLE repack, side by side with Scripts/manage.py: +//! +//! 1. install the stable server into a new folder on unused ports; +//! 2. coa-launcher start-all, then manage.py status-json must see every service; +//! 3. manage.py stop-all stops what coa-launcher started; +//! 4. manage.py start-all, coa-launcher status-json sees it, coa-launcher stop-all stops it; +//! 5. both stop-alls leave nothing of the repack running. +//! +//! usage: launcher_e2e +use std::path::Path; +use std::process::Command; + +use coa_core::install::{install_base, Params}; +use coa_core::registry::Registry; + +fn free_port() -> u16 { + std::net::TcpListener::bind("127.0.0.1:0").unwrap().local_addr().unwrap().port() +} + +fn run(exe: &Path, args: &[&str]) -> (bool, String) { + let out = Command::new(exe).args(args).output().unwrap(); + let text = String::from_utf8_lossy(&out.stdout).into_owned() + &String::from_utf8_lossy(&out.stderr); + (out.status.success(), text) +} + +fn launcher(root: &Path, exe: &Path, action: &str) -> (bool, String) { + let r = root.to_string_lossy().into_owned(); + let t = std::time::Instant::now(); + let out = run(exe, &["--root", &r, action]); + println!("[coa-launcher {action}] ok={} in {:?}\n{}", out.0, t.elapsed(), indent(&out.1)); + out +} + +fn manage(root: &Path, action: &str) -> (bool, String) { + let python = root.join("Runtime/python/python.exe"); + let script = root.join("Scripts/manage.py").to_string_lossy().into_owned(); + let t = std::time::Instant::now(); + let out = run(&python, &["-B", &script, action]); + println!("[manage.py {action}] ok={} in {:?}\n{}", out.0, t.elapsed(), indent(&out.1)); + out +} + +fn indent(s: &str) -> String { + s.lines().map(|l| format!(" {l}")).collect::>().join("\n") +} + +fn status(out: &str) -> serde_json::Value { + let line = out.lines().rev().find(|l| l.trim_start().starts_with('{')).expect("a JSON status line"); + serde_json::from_str(line).unwrap() +} + +fn all(v: &serde_json::Value, running: bool) -> bool { + ["mysql", "auth", "world", "relay"].iter().all(|k| v[*k] == running) +} + +fn main() { + let a: Vec = std::env::args().skip(1).collect(); + let root = Path::new(&a[0]); + let exe = Path::new(&a[1]); + assert!(a[0].ends_with("-fixture"), "a folder ending in -fixture is required"); + if root.join("Core/worldserver.exe").is_file() { + println!("reusing the installed fixture"); + } else { + install(root); + } + test(root, exe); +} + +fn install(root: &Path) { + assert!(!root.exists(), "a new folder is required"); + let reg_dir = std::env::temp_dir().join("coa-launcher-e2e-registry"); + let _ = std::fs::remove_dir_all(®_dir); + let reg = Registry::at(reg_dir.join("installs.json")); + // what the Manager installs: the stable release's installation image + let image = coa_core::install::Source::Installation(Box::new(coa_core::channels::resolve("stable").expect("stable channel"))); + let installed = install_base( + &Params { source: image, dest: root.into(), trusted_key: coa_core::signing::EMBEDDED_PUBLIC_KEY, registry: ®, cancel: Default::default() }, + &|s| eprintln!(" {:>3}% {}", s.percent, s.step), + ) + .expect("install"); + println!("installed {}", installed.version); + let repack = root.join("Settings/repack.json"); + let mut cfg: serde_json::Value = serde_json::from_slice(&std::fs::read(&repack).unwrap()).unwrap(); + for k in ["mysqlPort", "authPort", "worldPort", "raPort"] { + cfg[k] = free_port().into(); + } + std::fs::write(&repack, serde_json::to_vec_pretty(&cfg).unwrap()).unwrap(); +} + +fn test(root: &Path, exe: &Path) { + // 2. Rust starts, Python sees it + assert!(launcher(root, exe, "start-all").0, "coa-launcher start-all"); + let seen = status(&manage(root, "status-json").1); + assert!(all(&seen, true), "manage.py must see the services coa-launcher started: {seen}"); + // 3. Python stops what Rust started + assert!(manage(root, "stop-all").0, "manage.py stop-all"); + assert!(all(&status(&launcher(root, exe, "status-json").1), false)); + + // 4. Python starts, Rust sees and stops it + assert!(manage(root, "start-all").0, "manage.py start-all"); + let seen = status(&launcher(root, exe, "status-json").1); + assert!(all(&seen, true), "coa-launcher must see the services manage.py started: {seen}"); + assert!(launcher(root, exe, "stop-all").0, "coa-launcher stop-all"); + assert!(all(&status(&manage(root, "status-json").1), false)); + + // 5. Rust alone, a second time (start on a server it stopped) + assert!(launcher(root, exe, "start-all").0); + assert!(launcher(root, exe, "stop-all").0); + let left = coa_core::process::find_by_exe(&root.join("mysql/bin/mysqld.exe")).len() + + coa_core::process::find_by_exe(&root.join("Core/worldserver.exe")).len() + + coa_core::process::find_by_exe(&root.join("Core/authserver.exe")).len(); + assert_eq!(left, 0, "nothing of the repack may be left running"); + println!("LAUNCHER E2E PASS"); +} diff --git a/crates/coa-core/examples/manager_launcher_e2e.rs b/crates/coa-core/examples/manager_launcher_e2e.rs new file mode 100644 index 0000000..0f6e1d2 --- /dev/null +++ b/crates/coa-core/examples/manager_launcher_e2e.rs @@ -0,0 +1,149 @@ +//! The Manager's start/stop (`driver`) on the Rust launcher, on a DISPOSABLE repack: +//! +//! 1. driver start-all: every service runs, the console answers, manage.py is not touched and sees the services; +//! 2. driver stop-all stops everything; +//! 3. manage.py start-all, then driver stop-all stops what Python started; +//! 4. a taken world port fails with the typed "port in use" code (no stderr parsing), then stop-all; +//! 5. driver start-all, then the forced stop; +//! 6. with a realm profile: the realm row gets the profile's name, manage.py is still not edited; +//! 7. nothing of the repack is left running. +//! +//! usage: manager_launcher_e2e +use std::path::Path; +use std::process::Command; +use std::time::Instant; + +use coa_core::driver::{self, Verb}; +use coa_core::error::ErrorCode; +use coa_core::launcher::{services, settings::Settings, state}; + +fn indent(s: &str) -> String { + s.lines().map(|l| format!(" {l}")).collect::>().join("\n") +} + +fn drive(root: &Path, verb: Verb) -> driver::DriverOutcome { + let t = Instant::now(); + let out = driver::run(root, verb).expect("driver"); + println!("[driver {verb:?}] ok={} code={:?} in {:?}\n{}", out.ok, out.code, t.elapsed(), indent(&out.output)); + out +} + +fn manage(root: &Path, action: &str) -> (bool, String) { + let python = root.join("Runtime/python/python.exe"); + let script = root.join("Scripts/manage.py").to_string_lossy().into_owned(); + let t = Instant::now(); + let out = Command::new(python).args(["-B", &script, action]).output().unwrap(); + let text = String::from_utf8_lossy(&out.stdout).into_owned() + &String::from_utf8_lossy(&out.stderr); + println!("[manage.py {action}] ok={} in {:?}\n{}", out.status.success(), t.elapsed(), indent(&text)); + (out.status.success(), text) +} + +fn python_status(root: &Path) -> serde_json::Value { + let (ok, out) = manage(root, "status-json"); + assert!(ok); + let line = out.lines().rev().find(|l| l.trim_start().starts_with('{')).expect("a JSON status line"); + serde_json::from_str(line).unwrap() +} + +fn all(v: &serde_json::Value, running: bool) -> bool { + ["mysql", "auth", "world", "relay"].iter().all(|k| v[*k] == running) +} + +fn nothing_running(root: &Path) -> bool { + ["mysql", "auth", "world", "supervisor", "relay"].iter().all(|n| state::running(root, n).is_none()) + && ["mysql/bin/mysqld.exe", "Core/authserver.exe", "Core/worldserver.exe"] + .iter() + .all(|exe| coa_core::process::find_by_exe(&root.join(exe)).is_empty()) +} + +fn console(root: &Path) -> String { + let cfg = Settings::load(root, 0).unwrap(); + let mut ra = coa_core::ra::Ra::connect_to(cfg.ra_port, &cfg.ra_username, &cfg.ra_password).unwrap(); + ra.run("server info").unwrap() +} + +fn realm_name(root: &Path) -> String { + services::mysql(root, Some("SELECT name FROM acore_auth.realmlist WHERE id=1;"), None).unwrap() +} + +fn main() { + let a: Vec = std::env::args().skip(1).collect(); + let root = Path::new(&a[0]); + assert!(a[0].ends_with("-fixture"), "a folder ending in -fixture is required"); + assert!(nothing_running(root), "the fixture must be stopped before the test"); + let manage_py = root.join("Scripts/manage.py"); + let original = std::fs::read(&manage_py).unwrap(); + let profile = root.join("Settings/realm-profile.json"); + assert!(!profile.exists(), "the fixture starts without a realm profile"); + + // 1 + let started = drive(root, Verb::StartAll); + assert!(started.ok, "start-all"); + assert!(all(&python_status(root), true), "manage.py sees what the Manager started"); + let info = console(root); + println!("[console] {}", info.lines().next().unwrap_or("")); + assert_eq!(std::fs::read(&manage_py).unwrap(), original, "manage.py is not rewritten"); + assert_eq!(realm_name(root), "AzerothCore", "no profile: the launcher's own realm name"); + + let shipped = root.join("Scripts/coa-launcher.exe"); + let supervisor = state::running(root, "supervisor").expect("a supervisor"); + println!("[supervisor] {}", supervisor.exe); + let expected = if shipped.is_file() { "coa-launcher.exe" } else { "python.exe" }; + assert!(supervisor.exe.to_lowercase().ends_with(expected), "the world is supervised by {expected}"); + let relay = state::running(root, "relay").expect("a bug-report relay"); + println!("[relay] {}", relay.exe); + assert!(relay.exe.to_lowercase().ends_with(expected), "the relay is run by {expected}"); + assert!(state::running(root, "relay-ready").is_some_and(|r| r.pid == relay.pid), "the relay reported ready"); + + // 2 + assert!(drive(root, Verb::StopAll).ok, "stop-all"); + assert!(nothing_running(root), "1-2 left something running"); + + // 2b: the repack's Python launcher stops a world the Manager started + assert!(drive(root, Verb::StartAll).ok); + assert!(manage(root, "stop-all").0, "manage.py stops what the Manager started"); + assert!(nothing_running(root), "2b left something running"); + + // 3 + assert!(manage(root, "start-all").0); + assert!(drive(root, Verb::StopAll).ok, "driver stops what manage.py started"); + assert!(nothing_running(root), "3 left something running"); + + // 4 + let cfg = Settings::load(root, 0).unwrap(); + let blocker = std::net::TcpListener::bind(("127.0.0.1", cfg.world_port)).unwrap(); + let refused = drive(root, Verb::StartAll); + assert!(!refused.ok); + assert_eq!(refused.code, Some(ErrorCode::PortInUse), "typed port error"); + assert!(refused.output.contains(&format!("Port {}", cfg.world_port))); + drop(blocker); + assert!(drive(root, Verb::StopAll).ok); + assert!(nothing_running(root), "4 left something running"); + + // 5 + assert!(drive(root, Verb::StartAll).ok); + let t = Instant::now(); + let forced = driver::force_stop(root).expect("force stop"); + println!("[driver force_stop] ok={} in {:?}\n{}", forced.ok, t.elapsed(), indent(&forced.output)); + assert!(forced.ok && forced.output.contains("Force-stopped")); + assert!(nothing_running(root), "5 left something running"); + + // 6 + std::fs::write(&profile, br#"{"active":"coa","wildcard_created":false}"#).unwrap(); + let result = std::panic::catch_unwind(|| { + assert!(drive(root, Verb::StartAll).ok, "start-all with a realm profile"); + assert_eq!(realm_name(root), "Conquest of Azeroth"); + assert_eq!(std::fs::read(&manage_py).unwrap(), original, "manage.py is not edited for a realm profile either"); + assert!(drive(root, Verb::StopAll).ok); + }); + std::fs::remove_file(&profile).unwrap(); + std::fs::write(&manage_py, &original).unwrap(); + if result.is_err() { + let _ = driver::run(root, Verb::StopAll); + panic!("step 6 failed"); + } + + // 7 + assert!(nothing_running(root), "something of the repack is still running"); + println!("PASS: the Manager starts and stops through the Rust launcher, interoperates with manage.py, typed errors"); +} diff --git a/crates/coa-core/examples/relay_equivalence.rs b/crates/coa-core/examples/relay_equivalence.rs new file mode 100644 index 0000000..dab7976 --- /dev/null +++ b/crates/coa-core/examples/relay_equivalence.rs @@ -0,0 +1,170 @@ +//! The Rust bug-report relay against the repack's `BugReport/relay.py`, offline (a scripted service, no network): +//! +//! 1. the same reports and the same service answers give the same `.status` files and journal rows; +//! 2. each relay continues the other's journal: what one delivered is never sent again by the other, and a post the +//! other left in progress is uncertain. +//! +//! usage: relay_equivalence +use std::path::{Path, PathBuf}; +use std::process::Command; +use std::sync::{Arc, Mutex}; + +use coa_core::launcher::relay::{Failure, Relay, Service}; + +const REPORTS: [(&str, &str); 5] = [ + ("1-00000000000000a1", "COABUG1\r\nQuest broken\r\nThe NPC is gone.\r\n"), + ("9-00000000000000b2", "COABUG1\nRate limited\nBody text\n"), + ("3-00000000000000c3", "COABUG1\nRejected\nBody\n"), + ("4-00000000000000d4", "COABUG1\nxy\nTitle too short\n"), + ("5-00000000000000e5", "COABUG1\nUnknown outcome\nBody\n"), +]; + +/// The answers per title, in the vocabulary of both relays. +fn answer(title: &str) -> std::result::Result { + match title { + "Quest broken" => Ok(101), + "Rate limited" => Err(Failure::Limited(60)), + "Rejected" => Err(Failure::Invalid), + _ => Err(Failure::Uncertain), + } +} + +const PYTHON: &str = r#" +import importlib.util, sys, json +from pathlib import Path +spec = importlib.util.spec_from_file_location("relay", sys.argv[1]); relay = importlib.util.module_from_spec(spec); spec.loader.exec_module(relay) +spool = Path(sys.argv[2]); calls = [] +class Fake: + def create(self, title, body): + calls.append(title) + if title == "Quest broken": return 101 + if title == "Rate limited": raise relay.DeliveryError("limited", 60) + if title == "Rejected": raise relay.DeliveryError("invalid") + raise relay.DeliveryError("uncertain") +t = [float(sys.argv[3])] +def clock(): + t[0] += 3 + return t[0] +r = relay.Relay(spool, Fake(), clock=clock) +for path in sorted(spool.glob("*.report")): + r.process(path) +r.close() +print(json.dumps(calls)) +"#; + +struct Scripted(Arc>>); +impl Service for Scripted { + fn create(&self, title: &str, _: &str) -> std::result::Result { + self.0.lock().unwrap().push(title.into()); + answer(title) + } +} + +fn spool(dir: &Path) -> PathBuf { + std::fs::create_dir_all(dir).unwrap(); + for (key, text) in REPORTS { + std::fs::write(dir.join(format!("{key}.report")), text).unwrap(); + } + dir.into() +} + +fn python(repack: &Path, spool: &Path, start: f64) -> Vec { + let out = Command::new(repack.join("Runtime/python/python.exe")) + .args(["-I", "-B", "-c", PYTHON]) + .arg(repack.join("BugReport/relay.py")) + .arg(spool) + .arg(start.to_string()) + .output() + .unwrap(); + assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr)); + serde_json::from_slice(&out.stdout).unwrap() +} + +/// The clock of both relays: `start`, then 3 seconds later at every reading. +fn rust(spool: &Path, start: f64) -> Vec { + let calls = Arc::new(Mutex::new(Vec::new())); + let t = Mutex::new(start); + let clock = move || { + let mut v = t.lock().unwrap(); + *v += 3.0; + *v + }; + let relay = Relay::with_clock(spool, Scripted(calls.clone()), Box::new(clock)).unwrap(); + relay.pass().unwrap(); + drop(relay); + let c = calls.lock().unwrap().clone(); + c +} + +/// `.status` files and journal rows (without the post time). +fn snapshot(spool: &Path) -> (Vec<(String, String)>, Vec) { + let mut statuses: Vec<(String, String)> = std::fs::read_dir(spool) + .unwrap() + .flatten() + .filter(|e| e.path().extension().is_some_and(|x| x == "status")) + .map(|e| (e.file_name().to_string_lossy().into_owned(), std::fs::read_to_string(e.path()).unwrap())) + .collect(); + statuses.sort(); + let db = rusqlite::Connection::open(spool.join("relay.sqlite3")).unwrap(); + let mut q = db.prepare("SELECT key, digest, marker, state, number, next_try FROM deliveries ORDER BY key").unwrap(); + let rows = q + .query_map([], |r| { + Ok(format!( + "{}|{}|{}|{}|{:?}|{}", + r.get::<_, String>(0)?, + r.get::<_, String>(1)?, + r.get::<_, String>(2)?, + r.get::<_, String>(3)?, + r.get::<_, Option>(4)?, + r.get::<_, f64>(5)? + )) + }) + .unwrap() + .map(Result::unwrap) + .collect(); + (statuses, rows) +} + +fn main() { + let repack = PathBuf::from(std::env::args().nth(1).expect("repack folder")); + let work = tempfile::tempdir().unwrap(); + + // 1 + let (a, b) = (spool(&work.path().join("python")), spool(&work.path().join("rust"))); + let py_calls = python(&repack, &a, 1000.0); + let rs_calls = rust(&b, 1000.0); + println!("python posted {py_calls:?}\nrust posted {rs_calls:?}"); + assert_eq!(py_calls, rs_calls, "the same reports are posted"); + let (pa, pb) = (snapshot(&a), snapshot(&b)); + for s in &pa.0 { + println!(" {} = {}", s.0, s.1.trim()); + } + assert_eq!(pa, pb, "the same statuses and journal"); + + + // 2: each continues the other's journal. Before the retry times nothing is sent again; after them only the + // rate-limited report is (created, rejected and uncertain ones never are). + assert!(python(&repack, &b, 1000.0).is_empty(), "Python does not resend what Rust handled"); + assert!(rust(&a, 1000.0).is_empty(), "Rust does not resend what Python handled"); + // Later passes: the queued reports go out, a refused or uncertain one never again. + for start in [5000.0, 6000.0, 7000.0] { + let (p, r) = (python(&repack, &b, start), rust(&a, start)); + println!("at {start}: python on rust's journal posted {p:?}, rust on python's posted {r:?}"); + assert_eq!(p, r, "the same retries"); + assert!(!p.iter().any(|t| t == "Quest broken" || t == "Unknown outcome"), "created and uncertain are final"); + } + assert_eq!(snapshot(&a), snapshot(&b), "the same after a retry by the other relay"); + for dir in [&a, &b] { + let db = rusqlite::Connection::open(dir.join("relay.sqlite3")).unwrap(); + db.execute("UPDATE deliveries SET state='posting' WHERE key='9-00000000000000b2'", []).unwrap(); + } + python(&repack, &b, 9000.0); + rust(&a, 9000.0); + for dir in [&a, &b] { + let db = rusqlite::Connection::open(dir.join("relay.sqlite3")).unwrap(); + let state: String = db.query_row("SELECT state FROM deliveries WHERE key='9-00000000000000b2'", [], |r| r.get(0)).unwrap(); + assert_eq!(state, "uncertain", "an interrupted post is not retried ({})", dir.display()); + } + assert_eq!(snapshot(&a), snapshot(&b), "still the same after the crossover"); + println!("PASS: relay journals, statuses and posts are the same in Python and Rust"); +} diff --git a/crates/coa-core/examples/squid_equivalence.rs b/crates/coa-core/examples/squid_equivalence.rs new file mode 100644 index 0000000..795c9f2 --- /dev/null +++ b/crates/coa-core/examples/squid_equivalence.rs @@ -0,0 +1,103 @@ +//! SQUID database provisioning in Rust gives exactly what Scripts/squid_playerbots.py gives, on a DISPOSABLE repack: +//! the same journals (coa_squid_migrations, coa_squid_pending) in every schema, the same acore_playerbots tables +//! with the same row counts, the same playerbots.conf. Each side starts from the same state (SQUID never +//! provisioned), and a second run of each must change nothing. +//! +//! usage: squid_equivalence +use std::path::Path; +use std::process::Command; + +use coa_core::launcher::{services, squid}; + +fn sql(root: &Path, q: &str) -> String { + services::mysql(root, Some(q), None).unwrap_or_else(|e| panic!("{q}: {e}")) +} + +/// What provisioning leaves behind, comparable between runs. +fn snapshot(root: &Path) -> String { + let mut out = Vec::new(); + for schema in ["acore_characters", "acore_world", "acore_playerbots"] { + let tables = sql(root, &format!("SELECT TABLE_NAME FROM information_schema.TABLES WHERE TABLE_SCHEMA='{schema}' ORDER BY TABLE_NAME;")); + for t in tables.lines() { + if schema != "acore_playerbots" && !t.starts_with("coa_squid") { + continue; + } + let n = sql(root, &format!("SELECT COUNT(*) FROM `{schema}`.`{t}`;")); + out.push(format!("{schema}.{t} rows={n}")); + if t == "coa_squid_migrations" || t == "coa_squid_pending" { + for row in sql(root, &format!("SELECT path, sha256 FROM `{schema}`.`{t}` ORDER BY path;")).lines() { + out.push(format!(" {row}")); + } + } + } + } + let conf = std::fs::read_to_string(root.join("Core/configs/modules/playerbots.conf")).unwrap(); + out.push(format!("playerbots.conf:\n{}", conf.replace("\r\n", "\n"))); + out.join("\n") +} + +fn reset(root: &Path, conf: &[u8]) { + sql(root, "DROP DATABASE IF EXISTS acore_playerbots;"); + for schema in ["acore_characters", "acore_world"] { + sql(root, &format!("DROP TABLE IF EXISTS `{schema}`.coa_squid_migrations, `{schema}`.coa_squid_pending;")); + } + std::fs::write(root.join("Core/configs/modules/playerbots.conf"), conf).unwrap(); +} + +fn python(root: &Path) { + let harness = root.join(".state/squid_harness.py"); + std::fs::write( + &harness, + "import sys, pathlib\nroot = pathlib.Path(sys.argv[1])\nsys.path.insert(0, str(root / 'Scripts'))\nsys.argv = ['manage.py']\nimport manage\nfrom squid_playerbots import prepare_playerbots\nprepare_playerbots(manage.ROOT, manage.settings(), manage.mysql)\n", + ) + .unwrap(); + let out = Command::new(root.join("Runtime/python/python.exe")).arg("-B").arg(&harness).arg(root).output().unwrap(); + assert!(out.status.success(), "python: {}{}", String::from_utf8_lossy(&out.stdout), String::from_utf8_lossy(&out.stderr)); + print!("{}", String::from_utf8_lossy(&out.stdout)); +} + +fn rust(root: &Path) { + let cfg = coa_core::launcher::Settings::load(root, 0).unwrap(); + squid::prepare_playerbots(root, cfg.mysql_port, &|q| services::mysql(root, Some(q), None), &|m| println!("{m}")).unwrap(); +} + +fn main() { + let a: Vec = std::env::args().skip(1).collect(); + let root = Path::new(&a[0]); + let exe = Path::new(&a[1]); + assert!(a[0].ends_with("-fixture")); + let modules = root.join("Core/configs/modules"); + // SQUID on, Companions off + let companions = std::fs::read_to_string(modules.join("mod_coa_playerbots.conf")).unwrap(); + std::fs::write(modules.join("mod_coa_playerbots.conf"), companions.replace("CoaBots.Enable = 1", "CoaBots.Enable = 0")).unwrap(); + let squid_conf = std::fs::read_to_string(modules.join("playerbots.conf")).unwrap().replace("AiPlayerbot.Enabled = 0", "AiPlayerbot.Enabled = 1"); + let r = root.to_string_lossy().into_owned(); + let started = Command::new(exe).args(["--root", &r, "start-mysql"]).output().unwrap(); + assert!(started.status.success(), "{}", String::from_utf8_lossy(&started.stderr)); + + reset(root, squid_conf.as_bytes()); + let t = std::time::Instant::now(); + python(root); + println!("python provisioned in {:?}", t.elapsed()); + let by_python = snapshot(root); + python(root); + assert_eq!(snapshot(root), by_python, "a second Python run changed something"); + + reset(root, squid_conf.as_bytes()); + let t = std::time::Instant::now(); + rust(root); + println!("rust provisioned in {:?}", t.elapsed()); + let by_rust = snapshot(root); + rust(root); + assert_eq!(snapshot(root), by_rust, "a second Rust run changed something"); + + if by_python != by_rust { + std::fs::write(root.join(".state/squid-python.txt"), &by_python).unwrap(); + std::fs::write(root.join(".state/squid-rust.txt"), &by_rust).unwrap(); + panic!("Rust and Python differ: see .state/squid-python.txt and squid-rust.txt"); + } + println!("{} lines of journal/table/config state are identical", by_rust.lines().count()); + let stopped = Command::new(exe).args(["--root", &r, "stop-all"]).output().unwrap(); + assert!(stopped.status.success()); + println!("SQUID EQUIVALENCE PASS"); +} diff --git a/crates/coa-core/src/driver.rs b/crates/coa-core/src/driver.rs index 337f591..b0a4305 100644 --- a/crates/coa-core/src/driver.rs +++ b/crates/coa-core/src/driver.rs @@ -1,11 +1,10 @@ -//! Start/stop of a repack-shaped installation by delegating to the repack's own supervisor -//! (`Runtime\python\python.exe Scripts\manage.py `), which already implements config rendering, the -//! bug-report relay, RA graceful shutdown and readiness. Observation stays native (see `process`). +//! Start/stop of a repack-shaped installation through the repack launcher in this crate +//! ([`crate::launcher`]): config rendering, the services, the world supervisor, graceful shutdown and readiness. +//! It writes the same `.state` records as the repack's `Scripts/manage.py`, so the repack's own launcher and +//! this Manager can be used on the same folder. Observation stays native (see `process`). -use std::io::Read; -use std::path::{Path, PathBuf}; -use std::process::{Command, Stdio}; -use std::time::{Duration, Instant}; +use std::path::Path; +use std::sync::Mutex; use serde::Serialize; @@ -22,22 +21,13 @@ pub enum Verb { } impl Verb { - fn arg(self) -> &'static str { + fn action(self) -> crate::launcher::ops::Action { + use crate::launcher::ops::Action; match self { - Verb::StartAll => "start-all", - Verb::StartMysql => "start-mysql", - Verb::StartWorld => "start-world", - Verb::StopAll => "stop-all", - } - } - - fn timeout(self, _root: &Path) -> Duration { - match self { - // Includes database startup, optional bot provisioning and the shared 25-minute - // world/console wait in launcher_bridge.py, even for older installed scripts. - Verb::StartAll | Verb::StartWorld => Duration::from_secs(3600), - Verb::StartMysql => Duration::from_secs(360), - Verb::StopAll => Duration::from_secs(240), + Verb::StartAll => Action::StartAll, + Verb::StartMysql => Action::StartMysql, + Verb::StartWorld => Action::StartWorld, + Verb::StopAll => Action::StopAll, } } } @@ -52,41 +42,14 @@ pub struct DriverOutcome { pub output: String, } -/// Map the launcher's own messages onto stable error codes. Unknown text stays `Unknown` (details remain visible). -pub fn translate(output: &str) -> ErrorCode { - let o = output.to_lowercase(); - if o.contains("is already used") { - ErrorCode::PortInUse - } else if o.contains("another start/stop action is in progress") - || o.contains("shutdown is still finishing") - { - ErrorCode::OperationInProgress - } else if o.contains("packaged database is missing") - || o.contains("extract the complete repack") - { - ErrorCode::ServerFilesIncomplete - } else if o.contains("stopped during startup") - || o.contains("is still starting") - || o.contains("world startup failed") - { - ErrorCode::StartupFailed - } else if o.contains("invalid port") || o.contains("unresolved placeholder") { - ErrorCode::InvalidConfigValue - } else { - ErrorCode::Unknown - } -} - -fn launcher(root: &Path) -> Result<(PathBuf, PathBuf)> { - let python = root.join("Runtime/python/python.exe"); - let script = root.join("Scripts/manage.py"); - if !python.is_file() || !script.is_file() { +fn has_launcher_settings(root: &Path) -> Result<()> { + if !root.join("Settings/repack.json").is_file() { return Err(Error::Invalid( "This server has no CoA Repack launcher; start/stop is not available for it yet." .into(), )); } - Ok((python, script)) + Ok(()) } /// Run a launcher verb to completion (blocking; call from a worker thread). @@ -205,108 +168,51 @@ fn run_inner_mode( if matches!(verb, Verb::StartAll | Verb::StartWorld) { crate::modules::ensure_bot_exclusivity(&root)?; } - let (python, script) = launcher(&root)?; + has_launcher_settings(&root)?; prepare_headless_world(&root, verb)?; - let original = std::fs::read_to_string(&script)?; - let patched = patch_launcher_imports(&original)?; - if original != patched { - fsx::atomic_write(&script, patched.as_bytes())?; - if let Ok(dir) = crate::registry::metadata_dir_for(&root) { - if let Ok((_, mut meta)) = crate::registry::MetaDir::open(&dir) { - if meta.original_hashes.get("Scripts/manage.py") - == Some(&fsx::sha256_bytes(original.as_bytes())) - { - meta.original_hashes.insert( - "Scripts/manage.py".into(), - fsx::sha256_bytes(patched.as_bytes()), - ); - fsx::atomic_write_json(&dir.join("install.json"), &meta)?; - } - } - } - } - discard_damaged_launcher_state(&root); if matches!(verb, Verb::StopAll | Verb::StartMysql | Verb::StartAll) { recover_mysql_launcher_state(&root, verb != Verb::StopAll)?; } if force { recover_world_for_forced_stop(&root)?; } - let mut cmd = Command::new(&python); - if validating_update { - // Isolated startup must use the port from its temporary auth config. - cmd.env_remove("AC_REALM_SERVER_PORT"); - } - cmd.arg("-B") - .arg("-c") - .arg(LAUNCH_SCRIPT) - .arg(&script) - .arg(if force { "force-stop-all" } else { verb.arg() }) - .current_dir(&root) - .stdin(Stdio::null()) - .stdout(Stdio::piped()) - .stderr(Stdio::piped()); - #[cfg(windows)] - { - use std::os::windows::process::CommandExt; - cmd.creation_flags(0x0800_0000); // CREATE_NO_WINDOW - } - tracing::info!(?verb, root = %root.display(), "driver: starting launcher verb"); - let mut child = cmd.spawn()?; - let mut stdout = child.stdout.take().expect("piped"); - let mut stderr = child.stderr.take().expect("piped"); - let out_t = std::thread::spawn(move || { - let mut s = String::new(); - let _ = stdout.read_to_string(&mut s); - s - }); - let err_t = std::thread::spawn(move || { - let mut s = String::new(); - let _ = stderr.read_to_string(&mut s); - s - }); - let deadline = Instant::now() + verb.timeout(&root); - let status = loop { - if let Some(st) = child.try_wait()? { - break Some(st); - } - if Instant::now() > deadline { - // Never kill the servers themselves: only abandon the launcher process we spawned. - let _ = child.kill(); - break None; - } - std::thread::sleep(Duration::from_millis(200)); - }; - let mut output = out_t.join().unwrap_or_default(); - output.push_str(&err_t.join().unwrap_or_default()); - let mut output = output.trim().to_string(); - if status.is_none() { - output.push_str(&format!( - "\nLauncher {} exceeded its {} second deadline; check the server logs.", - verb.arg(), - verb.timeout(&root).as_secs() - )); - } - let (ok, exit_code) = match status { - Some(st) => (st.success(), st.code()), - None => (false, None), - }; - let code = if ok { - None + let action = if force { + crate::launcher::ops::Action::ForceStopAll } else { - // Log evidence beats the launcher's generic "stopped during startup" message. - let base = if status.is_none() { - ErrorCode::StartupFailed - } else { - translate(&output) - }; - match base { - ErrorCode::StartupFailed | ErrorCode::Unknown => { - Some(crate::health::diagnose_installation(&root).unwrap_or(base)) + verb.action() + }; + tracing::info!(?verb, root = %root.display(), "driver: starting launcher action"); + let lines = Mutex::new(Vec::::new()); + let progress = |line: &str| { + tracing::info!(?verb, "launcher: {line}"); + lines.lock().unwrap_or_else(|e| e.into_inner()).push(line.to_string()); + }; + let result = crate::launcher::Settings::load(&root, 0).and_then(|mut cfg| { + if validating_update { + // Isolated startup must use the port from its temporary auth config. + cfg.env_remove.push("AC_REALM_SERVER_PORT".into()); + } + crate::launcher::ops::run(&root, &cfg, 0, action, None, &progress) + }); + let mut output = lines.into_inner().unwrap_or_else(|e| e.into_inner()).join("\n"); + let ok = result.is_ok(); + let code = match &result { + Ok(()) => None, + Err(error) => { + if !output.is_empty() { + output.push('\n'); + } + output.push_str(&format!("ERROR: {error}")); + // Log evidence beats a generic "stopped during startup". + match error.code() { + ErrorCode::StartupFailed | ErrorCode::Unknown => Some( + crate::health::diagnose_installation(&root).unwrap_or(error.code()), + ), + other => Some(other), } - other => Some(other), } }; + let exit_code = Some(if ok { 0 } else { 1 }); 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] @@ -374,35 +280,6 @@ fn prepare_headless_world(root: &Path, verb: Verb) -> Result<()> { Ok(()) } -/// The launcher keeps one JSON record per service in `.state`. A crash or power loss while it writes one can leave -/// a file of the right length that holds only zero bytes (NTFS keeps the length but not the data), and the launcher -/// then dies on every start with an unreadable record. Such a file carries no information, so remove it: the -/// launcher treats a missing record as "not running". Only empty or all-zero `*.json` files are touched. -pub(crate) fn discard_damaged_launcher_state(root: &Path) -> Vec { - let mut removed = Vec::new(); - let Ok(entries) = std::fs::read_dir(root.join(".state")) else { - return removed; - }; - for entry in entries.flatten() { - let path = entry.path(); - if path - .extension() - .is_none_or(|e| !e.eq_ignore_ascii_case("json")) - || !path.is_file() - { - continue; - } - let Ok(bytes) = std::fs::read(&path) else { - continue; - }; - if bytes.iter().all(|b| *b == 0) && std::fs::remove_file(&path).is_ok() { - tracing::warn!(file = %path.display(), bytes = bytes.len(), "driver: removed a launcher state file damaged by an interrupted write"); - removed.push(path); - } - } - removed -} - /// 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<()> { @@ -453,60 +330,6 @@ fn recover_mysql_launcher_state(root: &Path, prefer_listener: bool) -> Result<() Ok(()) } -const LAUNCH_SCRIPT: &str = include_str!("launcher_bridge.py"); - -pub(crate) fn patch_launcher_imports(text: &str) -> Result { - let line = "sys.path.insert(0, str(Path(__file__).resolve().parent))"; - if !text.contains("from squid_playerbots import") || text.contains(line) { - return Ok(text.into()); - } - let root = "ROOT = Path(__file__).resolve().parents[1]"; - if !text.contains(root) || !text.lines().any(|line| line.trim() == "import sys") { - return Err(Error::Invalid( - "The server launcher cannot load its integration scripts. Repair its program files." - .into(), - )); - } - Ok(text.replacen(root, &format!("{root}\n{line}"), 1)) -} - -pub(crate) fn launcher_matches(signed: &str, actual: &[u8]) -> bool { - if signed.as_bytes() == actual { - return true; - } - if patch_launcher_imports(signed).is_ok_and(|s| s.as_bytes() == actual) { - return true; - } - crate::realms::patch_launcher(signed).is_ok_and(|s| { - s.as_bytes() == actual || patch_launcher_imports(&s).is_ok_and(|p| p.as_bytes() == actual) - }) -} - -/// Recover legacy metadata only when undoing supported Manager edits reproduces the recorded hash. -pub(crate) fn launcher_matches_recorded(recorded: &str, actual: &[u8]) -> bool { - let Ok(text) = std::str::from_utf8(actual) else { - return false; - }; - let without_import = text.replacen( - "ROOT = Path(__file__).resolve().parents[1]\nsys.path.insert(0, str(Path(__file__).resolve().parent))", - "ROOT = Path(__file__).resolve().parents[1]", 1, - ); - for candidate in [ - Some(without_import.clone()), - crate::realms::unpatch_launcher(&without_import), - ] - .into_iter() - .flatten() - { - if crate::fsx::sha256_bytes(candidate.as_bytes()).eq_ignore_ascii_case(recorded) - && launcher_matches(&candidate, actual) - { - return true; - } - } - false -} - pub(crate) fn startup_failure(root: &Path, started: &DriverOutcome) -> String { let code = started .code @@ -608,7 +431,7 @@ mod tests { text.contains("launcher request failed before completion") && text.contains("in progress") ); - assert!(!text.contains("starting launcher verb")); + assert!(!text.contains("starting launcher action")); } #[test] @@ -665,78 +488,10 @@ mod tests { } #[test] - fn slow_world_startup_has_time_with_either_bot_system_without_extending_shutdown() { - let folder = tempfile::tempdir().unwrap(); - let modules = folder.path().join("Core/configs/modules"); - std::fs::create_dir_all(&modules).unwrap(); - std::fs::write( - modules.join("playerbots.conf.dist"), - "AiPlayerbot.Enabled = 1\n", - ) - .unwrap(); - assert_eq!( - Verb::StartAll.timeout(folder.path()), - Duration::from_secs(3600) - ); - assert_eq!( - Verb::StopAll.timeout(folder.path()), - Duration::from_secs(240) - ); - std::fs::write(modules.join("playerbots.conf"), "AiPlayerbot.Enabled = 0\n").unwrap(); - assert_eq!( - Verb::StartWorld.timeout(folder.path()), - Duration::from_secs(3600) - ); - assert_eq!( - Verb::StartMysql.timeout(folder.path()), - Duration::from_secs(360) - ); - } - - #[test] - fn zero_filled_launcher_state_is_discarded_and_valid_state_is_kept() { - let folder = tempfile::tempdir().unwrap(); - let state = folder.path().join(".state"); - std::fs::create_dir_all(&state).unwrap(); - std::fs::write(state.join("mysql.json"), vec![0u8; 116]).unwrap(); - std::fs::write(state.join("configuration.json"), Vec::::new()).unwrap(); - std::fs::write(state.join("world.json"), "{\"pid\": 4}\n").unwrap(); - std::fs::write(state.join("stop-relay"), Vec::::new()).unwrap(); - std::fs::write(state.join("auth.json"), "{\"pid\": 0}").unwrap(); - let mut removed: Vec<_> = discard_damaged_launcher_state(folder.path()) - .iter() - .map(|p| p.file_name().unwrap().to_string_lossy().into_owned()) - .collect(); - removed.sort(); - assert_eq!(removed, ["configuration.json", "mysql.json"]); - assert!( - state.join("world.json").exists() - && state.join("auth.json").exists() - && state.join("stop-relay").exists() - ); - assert!(discard_damaged_launcher_state(folder.path()).is_empty()); - assert!(discard_damaged_launcher_state(&folder.path().join("missing")).is_empty()); - } - - #[test] - fn translates_known_launcher_messages() { - assert_eq!( - translate("RuntimeError: Port 8085 is already used. Stop the other server"), - ErrorCode::PortInUse - ); - assert_eq!( - translate("Another start/stop action is in progress."), - ErrorCode::OperationInProgress - ); - assert_eq!( - translate("The packaged database is missing. Extract the complete repack."), - ErrorCode::ServerFilesIncomplete - ); - assert_eq!( - translate("world stopped during startup. Check its log."), - ErrorCode::StartupFailed - ); - assert_eq!(translate("Exit code -1073741819"), ErrorCode::Unknown); + fn launcher_failures_carry_their_error_code() { + let e = Error::Service(ErrorCode::PortInUse, "Port 8085 is already used (PID 4).".into()); + assert_eq!(e.code(), ErrorCode::PortInUse); + assert_eq!(e.to_string(), "Port 8085 is already used (PID 4)."); } #[test] @@ -779,13 +534,4 @@ mod tests { assert!(!reason.contains("private")); assert!(!reason.contains("Something went wrong")); } - - #[test] - fn launcher_import_fix_is_idempotent_and_retains_other_code() { - let text = "import sys\nROOT = Path(__file__).resolve().parents[1]\nfrom squid_playerbots import validate_bots\ncustom = 42\n"; - let fixed = patch_launcher_imports(text).unwrap(); - assert!(fixed.contains("sys.path.insert(0, str(Path(__file__).resolve().parent))")); - assert!(fixed.ends_with("custom = 42\n")); - assert_eq!(patch_launcher_imports(&fixed).unwrap(), fixed); - } } diff --git a/crates/coa-core/src/error.rs b/crates/coa-core/src/error.rs index 08769d8..5e648f8 100644 --- a/crates/coa-core/src/error.rs +++ b/crates/coa-core/src/error.rs @@ -24,6 +24,9 @@ pub enum Error { UnknownInstallation(String), #[error("{0}")] Invalid(String), + /// A server start or stop failed for a reason the UI can explain (the repack launcher's own errors). + #[error("{1}")] + Service(ErrorCode, String), #[error("package not published: {0}")] PackageNotPublished(String), #[error("download server unreachable: {0}")] @@ -199,6 +202,7 @@ impl Error { Error::PackageNotPublished(_) => ErrorCode::PackageNotPublished, Error::NetworkUnreachable(_) => ErrorCode::NetworkUnreachable, Error::BotModulesConflict => ErrorCode::BotModulesConflict, + Error::Service(code, _) => *code, Error::CompanionTemplatesMissing => ErrorCode::CompanionTemplatesMissing, Error::CompanionCommandUnsupported => ErrorCode::CompanionCommandUnsupported, _ => ErrorCode::Unknown, diff --git a/crates/coa-core/src/launcher/mod.rs b/crates/coa-core/src/launcher/mod.rs new file mode 100644 index 0000000..786583c --- /dev/null +++ b/crates/coa-core/src/launcher/mod.rs @@ -0,0 +1,24 @@ +//! The repack launcher in Rust: what `Scripts/manage.py` does, without Python. +//! +//! Formats on disk stay exactly those of `manage.py`, so the two can be used on the same server during the move +//! (an old `.bat` and a new Manager, or the other way round): +//! +//! * `.state/.json` process records `{pid, exe, created}` (see [`crate::process::ProcessIdentity`]); +//! * `.state/control.lock` one start/stop action at a time: byte 0 locked, as `msvcrt.locking` does; +//! * `.state/control-owner.json`, `.state/configuration.json`, `.state/debug-logs.json`; +//! * the rendered configs (`Core/configs/*.conf`, `mysql/my.ini`, `mysql/admin-client.ini`) byte for byte. +//! +//! State files are written with a flush to disk before they replace the old ones (`manage.py` did not, and a +//! power cut could leave a zero-filled record that stopped every later start). + +pub mod ops; +pub mod relay; +pub mod render; +pub mod services; +pub mod settings; +pub mod spawn; +pub mod squid; +pub mod state; +pub mod world; + +pub use settings::Settings; diff --git a/crates/coa-core/src/launcher/ops.rs b/crates/coa-core/src/launcher/ops.rs new file mode 100644 index 0000000..9e78be8 --- /dev/null +++ b/crates/coa-core/src/launcher/ops.rs @@ -0,0 +1,88 @@ +//! One start/stop action of a repack, with the control lock held (`manage.py main()`): the entry point of both +//! `coa-launcher.exe` and the Manager. + +use std::path::Path; +use std::time::Duration; + +use crate::error::Result; +use crate::launcher::services::{self, Progress}; +use crate::launcher::world::{self, Supervisor}; +use crate::launcher::{render, settings::Settings, squid, state}; + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum Action { + StartAll, + StartMysql, + StartAuth, + StartWorld, + StopAll, + /// Stop the world without its console first (unsaved progress is lost), then everything else. + ForceStopAll, + Prepare, +} + +impl Action { + /// The command name, as the `.bat` files and `manage.py` call it. + pub fn name(self) -> &'static str { + match self { + Action::StartAll => "start-all", + Action::StartMysql => "start-mysql", + Action::StartAuth => "start-auth", + Action::StartWorld => "start-world", + Action::StopAll => "stop-all", + Action::ForceStopAll => "force-stop-all", + Action::Prepare => "prepare", + } + } + + pub fn parse(name: &str) -> Option { + [ + Action::StartAll, + Action::StartMysql, + Action::StartAuth, + Action::StartWorld, + Action::StopAll, + Action::ForceStopAll, + Action::Prepare, + ] + .into_iter() + .find(|a| a.name() == name) + } +} + +/// Run `action`. A started world is supervised by `supervisor`, or by what the repack ships when it is `None`. +pub fn run(root: &Path, cfg: &Settings, offset: i32, action: Action, supervisor: Option<&Supervisor>, progress: Progress) -> Result<()> { + let _lock = state::ControlLock::acquire(root, action.name(), Duration::from_secs(30), progress)?; + match action { + // Shutdown uses the existing client and console settings: the templates may be exactly what a recovery + // needs to replace, so nothing is rendered. + Action::StopAll => return services::stop_all(root, cfg, progress), + Action::ForceStopAll => return services::force_stop_all(root, cfg, progress), + _ => {} + } + if matches!(action, Action::StartAll | Action::StartWorld) { + squid::validate_bots(root)?; + } + render::prepare(root, cfg)?; + if action == Action::Prepare { + return Ok(()); + } + if matches!(action, Action::StartAll | Action::StartMysql) { + services::start_mysql(root, cfg, progress)?; + } + if matches!(action, Action::StartAll | Action::StartAuth) { + services::start_auth(root, cfg, progress)?; + } + if matches!(action, Action::StartAll | Action::StartWorld) { + let shipped; + let supervisor = match supervisor { + Some(s) => s, + None => { + shipped = Supervisor::of(root)?; + &shipped + } + }; + world::start_world(root, cfg, offset, supervisor, progress)?; + } + Ok(()) +} diff --git a/crates/coa-core/src/launcher/relay.rs b/crates/coa-core/src/launcher/relay.rs new file mode 100644 index 0000000..2583b8f --- /dev/null +++ b/crates/coa-core/src/launcher/relay.rs @@ -0,0 +1,493 @@ +//! The bug-report relay (`BugReport/relay.py` and `manage.py relay-worker`): delivers the reports the world +//! writes to `BugReport/reports/*.report` through the CoA report service. +//! +//! On disk everything stays as the Python relay keeps it, so either can take over a spool: the `.status` +//! files the world reads back, the delivery journal `relay.sqlite3` (tables `deliveries` and `settings`), and +//! `relay.lock` (byte 0 locked while a worker runs). A delivery interrupted while it was posting becomes +//! `uncertain` and is never sent again (the service's duplicate filter may have been reset in the meantime). + +use std::path::{Path, PathBuf}; +use std::time::{Duration, SystemTime, UNIX_EPOCH}; + +use rusqlite::{params, Connection, OptionalExtension}; +use sha2::{Digest, Sha256}; + +use crate::error::{Error, Result}; +use crate::launcher::state; + +const REPOSITORY: &str = "jealous-sound/azerothcore-wotlk-coa"; +pub const SERVICE_URL: &str = "https://coa-bug-report.up.railway.app"; +/// Distribution credential for this narrow intake API (the same as relay.py's); not a GitHub token. +pub const DEFAULT_API_KEY: &str = "coa_zRatxUHShOn-HEkoreKGME6sd3DdMG7eKTTKlj2JCK4"; +const MAX_FILE: u64 = 16000; +const MAX_RESPONSE: usize = 64 * 1024; + +/// `[1-9][0-9]{0,9}-[0-9a-f]{16,48}`: the name of a report file (without `.report`). +pub fn valid_key(key: &str) -> bool { + let Some((id, hex)) = key.split_once('-') else { return false }; + (1..=10).contains(&id.len()) + && !id.starts_with('0') + && id.bytes().all(|b| b.is_ascii_digit()) + && (16..=48).contains(&hex.len()) + && hex.bytes().all(|b| b.is_ascii_digit() || (b'a'..=b'f').contains(&b)) +} + +/// Why a delivery did not create an issue. Only fixed local codes: never service bodies, credentials or report +/// content. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum Failure { + /// 202 pending: the service is still creating it. + Pending(u64), + /// 429: try again later. + Limited(u64), + /// The report itself was refused. + Invalid, + /// The service refused this relay (redirect, auth, missing endpoint, GitHub access). + Blocked(u64), + /// The outcome is unknown (network, timeout, unexpected answer). + Uncertain, +} + +/// Where reports go. +pub trait Service { + fn create(&self, title: &str, body: &str) -> std::result::Result; +} + +/// The CoA report service over HTTPS. +pub struct ReportService { + api: String, + key: String, + client: reqwest::blocking::Client, +} + +impl ReportService { + pub fn new(base_url: &str, api_key: &str) -> Result { + if api_key.is_empty() || !api_key.is_ascii() || api_key.chars().any(char::is_whitespace) { + return Err(Error::Invalid("Configure a valid report-service intake key.".into())); + } + let client = reqwest::blocking::Client::builder() + .redirect(reqwest::redirect::Policy::none()) + .timeout(Duration::from_secs(30)) + // One report every few seconds at most: a fresh connection each time, never a stale pooled one. + .pool_max_idle_per_host(0) + .user_agent("CoA-InGame-BugReport/1") + .build() + .map_err(|e| Error::Invalid(format!("The report client could not start: {e}")))?; + Ok(ReportService { api: format!("{base_url}/v1/reports"), key: api_key.into(), client }) + } +} + +/// `Retry-After` in seconds, kept within 1 s .. 1 day; `default` when absent or not a number. +fn retry_delay(retry_after: Option<&str>, default: u64) -> u64 { + retry_after.and_then(|v| v.trim().parse::().ok()).map_or(default, |v| v.clamp(1, 86400) as u64) +} + +/// A JSON object of at most 64 KiB, or nothing. +fn json_object(raw: Option<&[u8]>) -> Option> { + let raw = raw?; + if raw.len() > MAX_RESPONSE { + return None; + } + match serde_json::from_slice(raw).ok()? { + serde_json::Value::Object(map) => Some(map), + _ => None, + } +} + +fn issue_number(data: &serde_json::Map) -> std::result::Result { + let number = data.get("issue_number").and_then(|n| if n.is_u64() { n.as_u64() } else { None }); + match number { + Some(n) + if data.get("status").and_then(|s| s.as_str()) == Some("created") + && (1..=4294967295).contains(&n) + && data.get("issue_url").and_then(|u| u.as_str()) + == Some(format!("https://github.com/{REPOSITORY}/issues/{n}").as_str()) => + { + Ok(n) + } + _ => Err(Failure::Uncertain), + } +} + +/// What a service answer means (relay.py's `create`): the status, its `Retry-After` and its body (`None` when it +/// could not be read or was longer than 64 KiB). +pub fn classify(status: u16, retry_after: Option<&str>, body: Option<&[u8]>) -> std::result::Result { + let field = |data: &serde_json::Map, k: &str| data.get(k).and_then(|v| v.as_str()).map(str::to_owned); + match status { + 200..=202 => { + let data = json_object(body).ok_or(Failure::Uncertain)?; + match status { + 202 if field(&data, "status").as_deref() == Some("pending") => Err(Failure::Pending(retry_delay(retry_after, 2))), + 202 => Err(Failure::Uncertain), + _ => issue_number(&data), + } + } + 429 => Err(Failure::Limited(retry_delay(retry_after, 300))), + 400 | 413 | 415 | 422 => Err(Failure::Invalid), + 301 | 302 | 303 | 307 | 308 | 401 | 403 | 404 | 405 => Err(Failure::Blocked(300)), + 503 => { + let data = json_object(body).unwrap_or_default(); + if field(&data, "status").as_deref() == Some("failed") && field(&data, "error").as_deref() == Some("github_access_denied") { + Err(Failure::Blocked(retry_delay(retry_after, 300))) + } else { + Err(Failure::Uncertain) + } + } + _ => Err(Failure::Uncertain), + } +} + +impl Service for ReportService { + fn create(&self, title: &str, body: &str) -> std::result::Result { + use std::io::Read; + let sent = self + .client + .post(&self.api) + .header("Authorization", format!("Bearer {}", self.key)) + .header("Accept", "application/json") + .header("Content-Type", "application/json") + .body(serde_json::json!({ "title": title, "body": body }).to_string()) + .send(); + let response = sent.map_err(|_| Failure::Uncertain)?; + let status = response.status().as_u16(); + let retry_after = response.headers().get("Retry-After").and_then(|v| v.to_str().ok()).map(str::to_owned); + let mut raw = Vec::new(); + let read = response.take(MAX_RESPONSE as u64 + 1).read_to_end(&mut raw).is_ok() && raw.len() <= MAX_RESPONSE; + classify(status, retry_after.as_deref(), read.then_some(raw.as_slice())) + } +} + +/// A report: `COABUG1\n\n<body>`, checked as the world writes it. +pub struct Report { + pub digest: String, + pub marker: String, + pub title: String, + pub body: String, +} + +pub fn read_report(path: &Path) -> Result<Report> { + let bad = || Error::Invalid("Invalid report file".into()); + let key = path.file_stem().and_then(|s| s.to_str()).ok_or_else(bad)?; + let meta = std::fs::symlink_metadata(path)?; + if !valid_key(key) || meta.file_type().is_symlink() || meta.len() > MAX_FILE { + return Err(bad()); + } + let raw = std::fs::read(path)?; + let text = String::from_utf8(raw.clone()).map_err(|_| bad())?.replace("\r\n", "\n"); + let rest = text.strip_prefix("COABUG1\n").ok_or_else(|| Error::Invalid("Unsupported report format".into()))?; + let invalid = || Error::Invalid("Invalid report content".into()); + let (title, body) = rest.split_once('\n').ok_or_else(invalid)?; + if !(3..=200).contains(&title.len()) + || body.trim().is_empty() + || title.chars().any(|c| (c as u32) < 32) + || body.chars().any(|c| (c as u32) < 32 && !matches!(c, '\r' | '\n' | '\t')) + { + return Err(invalid()); + } + let digest = hex(&Sha256::digest(&raw)); + let id = hex(&Sha256::digest(format!("{key}:{digest}").as_bytes())); + Ok(Report { digest, marker: format!("<!-- coa-report:{id} -->"), title: title.into(), body: body.into() }) +} + +fn hex(bytes: &[u8]) -> String { + bytes.iter().map(|b| format!("{b:02x}")).collect() +} + +/// `<key>.status`: what the world shows the player (`queued`, `created|<issue>`, `failed`, ...). +pub fn write_status(spool: &Path, key: &str, state: &str, number: Option<u64>) -> Result<()> { + let value = match (state, number) { + ("created", Some(n)) => format!("created|{n}"), + ("created", None) => "created|None".into(), + _ => state.to_string(), + }; + let data = format!("{value}\n"); + let destination = spool.join(format!("{key}.status")); + if std::fs::read(&destination).is_ok_and(|d| d == data.as_bytes()) { + return Ok(()); + } + crate::fsx::atomic_write(&destination, data.as_bytes()) +} + +fn now() -> f64 { + SystemTime::now().duration_since(UNIX_EPOCH).map(|d| d.as_secs_f64()).unwrap_or(0.0) +} + +/// The delivery journal of one spool. +pub struct Relay<S: Service> { + spool: PathBuf, + service: S, + db: Connection, + clock: Box<dyn Fn() -> f64 + Send>, +} + +impl<S: Service> Relay<S> { + pub fn open(spool: &Path, service: S) -> Result<Relay<S>> { + Self::with_clock(spool, service, Box::new(now)) + } + + pub fn with_clock(spool: &Path, service: S, clock: Box<dyn Fn() -> f64 + Send>) -> Result<Relay<S>> { + let db = Connection::open(spool.join("relay.sqlite3")).map_err(sql)?; + db.execute_batch( + "PRAGMA synchronous=FULL; + CREATE TABLE IF NOT EXISTS deliveries ( + key TEXT PRIMARY KEY, digest TEXT NOT NULL, marker TEXT NOT NULL, state TEXT NOT NULL, + number INTEGER, attempted REAL NOT NULL DEFAULT 0, next_try REAL NOT NULL DEFAULT 0 + ); + CREATE TABLE IF NOT EXISTS settings (key TEXT PRIMARY KEY, value REAL NOT NULL); + UPDATE deliveries SET state='uncertain' WHERE state='posting';", + ) + .map_err(sql)?; + Ok(Relay { spool: spool.into(), service, db, clock }) + } + + fn set_state(&self, key: &str, state: &str, number: Option<u64>, delay: u64) -> Result<()> { + self.db + .execute( + "UPDATE deliveries SET state=?1, number=?2, next_try=?3 WHERE key=?4", + params![state, number.map(|n| n as i64), (self.clock)() + delay as f64, key], + ) + .map_err(sql)?; + write_status(&self.spool, key, state, number) + } + + fn set_network_gate(&self, delay: u64) -> Result<()> { + self.db + .execute("INSERT OR REPLACE INTO settings VALUES('next_network',?1)", params![(self.clock)() + delay as f64]) + .map_err(sql)?; + Ok(()) + } + + /// Handle one report file; returns its delivery state. + pub fn process(&self, path: &Path) -> Result<String> { + let Some(key) = path.file_stem().and_then(|s| s.to_str()).filter(|k| valid_key(k)) else { + return Ok("ignored".into()); + }; + let report = match read_report(path) { + Ok(r) => r, + Err(_) => { + write_status(&self.spool, key, "failed", None)?; + return Ok("failed".into()); + } + }; + self.db + .execute( + "INSERT OR IGNORE INTO deliveries(key,digest,marker,state) VALUES(?1,?2,?3,'queued')", + params![key, report.digest, report.marker], + ) + .map_err(sql)?; + let (digest, row_state, number, next_try): (String, String, Option<i64>, f64) = self + .db + .query_row("SELECT digest, state, number, next_try FROM deliveries WHERE key=?1", params![key], |r| { + Ok((r.get(0)?, r.get(1)?, r.get(2)?, r.get(3)?)) + }) + .map_err(sql)?; + let number = number.map(|n| n as u64); + if digest != report.digest { + // Never replace an existing delivery or publish edited content under the same ID. + write_status(&self.spool, key, "failed", None)?; + return Ok("changed".into()); + } + if matches!(row_state.as_str(), "created" | "failed" | "uncertain") { + write_status(&self.spool, key, &row_state, number)?; + return Ok(row_state); + } + if next_try > (self.clock)() { + write_status(&self.spool, key, &row_state, None)?; + return Ok(row_state); + } + let gate: Option<f64> = self + .db + .query_row("SELECT value FROM settings WHERE key='next_network'", [], |r| r.get(0)) + .optional() + .map_err(sql)?; + if gate.is_some_and(|g| g > (self.clock)()) { + write_status(&self.spool, key, &row_state, None)?; + return Ok(row_state); + } + self.set_network_gate(5)?; + // A crash after this point needs review: the service's duplicate cache can reset on deploy. + self.db + .execute("UPDATE deliveries SET state='posting', attempted=?1 WHERE key=?2", params![(self.clock)(), key]) + .map_err(sql)?; + match self.service.create(&report.title, &report.body) { + Ok(n) => { + self.set_state(key, "created", Some(n), 0)?; + Ok("created".into()) + } + Err(failure) => { + let (state, delay) = match failure { + Failure::Limited(d) | Failure::Pending(d) => ("queued", d), + Failure::Blocked(d) => ("blocked", d), + Failure::Invalid => ("failed", 300), + Failure::Uncertain => ("uncertain", 300), + }; + self.set_state(key, state, None, delay)?; + if let Failure::Limited(d) | Failure::Blocked(d) = failure { + self.set_network_gate(d)?; + } + Ok(state.into()) + } + } + } + + /// One pass over the spool, in name order. + pub fn pass(&self) -> Result<()> { + let mut reports: Vec<PathBuf> = std::fs::read_dir(&self.spool)? + .flatten() + .map(|e| e.path()) + .filter(|p| p.extension().is_some_and(|x| x == "report")) + .collect(); + reports.sort(); + for path in reports { + self.process(&path)?; + } + Ok(()) + } +} + +fn sql(e: rusqlite::Error) -> Error { + Error::Invalid(format!("The bug-report journal failed ({e}).")) +} + +/// `relay-worker`: deliver reports until the supervisor asks the relay to stop (`.state/stop-relay`). +pub fn worker(root: &Path) -> Result<()> { + let spool = root.join("BugReport/reports"); + std::fs::create_dir_all(&spool)?; + let _lock = state::FileLock::try_acquire(&spool.join("relay.lock"))? + .ok_or_else(|| Error::Invalid("Another bug-report relay is already using this spool.".into()))?; + let key = std::env::var("COA_BUGREPORT_API_KEY").unwrap_or_else(|_| DEFAULT_API_KEY.into()); + let relay = Relay::open(&spool, ReportService::new(SERVICE_URL, &key)?)?; + state::record(root, "relay-ready", std::process::id())?; + println!("Bug-report relay ready. Waiting for in-game reports."); + let stop = state::dir(root).join("stop-relay"); + while !stop.exists() { + relay.pass()?; + for _ in 0..10 { + if stop.exists() { + return Ok(()); + } + std::thread::sleep(Duration::from_millis(500)); + } + } + Ok(()) +} + +#[cfg(test)] +mod tests { + use super::*; + use std::sync::{Arc, Mutex}; + + type Answers = Arc<Mutex<Vec<std::result::Result<u64, Failure>>>>; + + struct Fake(Answers, Arc<Mutex<u32>>); + impl Service for Fake { + fn create(&self, _: &str, _: &str) -> std::result::Result<u64, Failure> { + *self.1.lock().unwrap() += 1; + self.0.lock().unwrap().remove(0) + } + } + + fn report(spool: &Path, key: &str, text: &str) -> PathBuf { + let p = spool.join(format!("{key}.report")); + std::fs::write(&p, text).unwrap(); + p + } + + #[test] + fn keys_follow_the_world_format() { + assert!(valid_key("1-0123456789abcdef")); + assert!(valid_key("4294967295-0123456789abcdef0123456789abcdef0123456789abcdef")); + for bad in ["0-0123456789abcdef", "1-0123456789abcde", "1-0123456789ABCDEF", "12345678901-0123456789abcdef", "x"] { + assert!(!valid_key(bad), "{bad}"); + } + } + + #[test] + fn service_answers_map_like_relay_py() { + let ok = format!(r#"{{"status":"created","issue_number":12,"issue_url":"https://github.com/{REPOSITORY}/issues/12"}}"#); + let cases: Vec<(u16, Option<&str>, Option<&[u8]>, std::result::Result<u64, Failure>)> = vec![ + (201, None, Some(ok.as_bytes()), Ok(12)), + (200, None, Some(ok.as_bytes()), Ok(12)), + (201, None, Some(br#"{"status":"created","issue_number":12,"issue_url":"https://evil/12"}"#), Err(Failure::Uncertain)), + (201, None, Some(br#"{"status":"created","issue_number":0,"issue_url":"x"}"#), Err(Failure::Uncertain)), + (201, None, Some(b"[1]"), Err(Failure::Uncertain)), + (201, None, None, Err(Failure::Uncertain)), + (202, Some("7"), Some(br#"{"status":"pending"}"#), Err(Failure::Pending(7))), + (202, None, Some(br#"{"status":"pending"}"#), Err(Failure::Pending(2))), + (202, None, Some(br#"{"status":"other"}"#), Err(Failure::Uncertain)), + (429, Some("999999"), None, Err(Failure::Limited(86400))), + (429, Some("0"), None, Err(Failure::Limited(1))), + (429, Some("soon"), None, Err(Failure::Limited(300))), + (422, None, None, Err(Failure::Invalid)), + (302, None, None, Err(Failure::Blocked(300))), + (401, None, None, Err(Failure::Blocked(300))), + (503, Some("30"), Some(br#"{"status":"failed","error":"github_access_denied"}"#), Err(Failure::Blocked(30))), + (503, None, Some(b"{}"), Err(Failure::Uncertain)), + (500, None, None, Err(Failure::Uncertain)), + ]; + for (i, (status, retry, body, expected)) in cases.into_iter().enumerate() { + assert_eq!(classify(status, retry, body), expected, "case {i}"); + } + assert!(json_object(Some(&vec![b' '; MAX_RESPONSE + 1])).is_none(), "oversized answers are refused"); + assert!(ReportService::new(SERVICE_URL, "has space").is_err()); + assert!(ReportService::new(SERVICE_URL, "coa_key").is_ok()); + } + + #[test] + fn a_report_is_checked_and_identified_like_relay_py() { + let d = tempfile::tempdir().unwrap(); + let p = report(d.path(), "7-0123456789abcdef", "COABUG1\r\nBroken quest\r\nThe NPC is missing.\r\n"); + let r = read_report(&p).unwrap(); + assert_eq!(r.title, "Broken quest"); + assert_eq!(r.body, "The NPC is missing.\n"); + assert_eq!(r.digest, hex(&Sha256::digest(std::fs::read(&p).unwrap()))); + assert!(r.marker.starts_with("<!-- coa-report:") && r.marker.len() == 16 + 64 + 4); + for bad in ["COABUG2\nTitle\nBody", "COABUG1\nab\nBody", "COABUG1\nTitle\n \n", "COABUG1\nTi\u{7}tle\nBody", "COABUG1\nTitle"] { + std::fs::write(&p, bad).unwrap(); + assert!(read_report(&p).is_err(), "{bad:?}"); + } + } + + #[test] + fn deliveries_follow_the_journal() { + let d = tempfile::tempdir().unwrap(); + let spool = d.path(); + let t = Arc::new(Mutex::new(1000.0f64)); + let calls = Arc::new(Mutex::new(0)); + let answers: Answers = Arc::new(Mutex::new(vec![Err(Failure::Limited(60)), Ok(42)])); + let clock = t.clone(); + let relay = Relay::with_clock(spool, Fake(answers, calls.clone()), Box::new(move || *clock.lock().unwrap())).unwrap(); + let p = report(spool, "7-0123456789abcdef", "COABUG1\nBroken quest\nThe NPC is missing.\n"); + let status = || std::fs::read_to_string(spool.join("7-0123456789abcdef.status")).unwrap(); + assert_eq!(relay.process(&p).unwrap(), "queued", "429 keeps it queued"); + assert_eq!(status(), "queued\n"); + assert_eq!(relay.process(&p).unwrap(), "queued", "not before its retry time"); + assert_eq!(*calls.lock().unwrap(), 1); + *t.lock().unwrap() += 61.0; + assert_eq!(relay.process(&p).unwrap(), "created"); + assert_eq!(status(), "created|42\n"); + assert_eq!(relay.process(&p).unwrap(), "created", "never sent twice"); + assert_eq!(*calls.lock().unwrap(), 2); + std::fs::write(&p, "COABUG1\nBroken quest\nEdited.\n").unwrap(); + assert_eq!(relay.process(&p).unwrap(), "changed"); + relay + .db + .execute("INSERT INTO deliveries(key,digest,marker,state) VALUES('8-0123456789abcdef','x','m','posting')", []) + .unwrap(); + drop(relay); + let reopened = Relay::open(spool, Fake(Arc::new(Mutex::new(vec![])), calls.clone())).unwrap(); + let state: String = + reopened.db.query_row("SELECT state FROM deliveries WHERE key='8-0123456789abcdef'", [], |r| r.get(0)).unwrap(); + assert_eq!(state, "uncertain", "an interrupted post is never retried"); + } + + #[test] + fn a_second_worker_cannot_take_the_spool() { + let d = tempfile::tempdir().unwrap(); + let first = state::FileLock::try_acquire(&d.path().join("relay.lock")).unwrap(); + assert!(first.is_some()); + assert!(state::FileLock::try_acquire(&d.path().join("relay.lock")).unwrap().is_none()); + drop(first); + assert!(state::FileLock::try_acquire(&d.path().join("relay.lock")).unwrap().is_some()); + } +} diff --git a/crates/coa-core/src/launcher/render.rs b/crates/coa-core/src/launcher/render.rs new file mode 100644 index 0000000..a333eeb --- /dev/null +++ b/crates/coa-core/src/launcher/render.rs @@ -0,0 +1,271 @@ +//! `prepare`: the configuration files a repack runs with, rendered from `Settings/*.template` and +//! `Settings/repack.json` (`manage.py prepare()`), byte for byte the same. + +use std::path::{Path, PathBuf}; + +use crate::error::{Error, Result}; +use crate::launcher::{settings::Settings, state}; + +/// Services whose running process blocks moving the folder or changing ports. +const SERVICES: [&str; 5] = ["mysql", "auth", "world", "supervisor", "relay"]; + +/// The root as the servers see it: forward slashes, and the short (8.3) form when the real one has non-Latin +/// letters, which MySQL and the servers do not read reliably from their config files. +pub fn native_root(root: &Path) -> Result<String> { + let mut value = root.to_string_lossy().into_owned(); + if !value.is_ascii() { + if let Some(short) = sys::short_path(root) { + value = short; + } + } + if !value.is_ascii() { + return Err(Error::Invalid( + "Extract the repack to a path with Latin letters, such as C:\\Games\\CoA-Repack.".into(), + )); + } + Ok(value.replace('\\', "/")) +} + +/// Text as Python's text mode reads it: strict UTF-8, Windows and old Mac line ends turned into "\n". +fn read_text(path: &Path) -> Result<String> { + let bytes = std::fs::read(path)?; + let text = String::from_utf8(bytes).map_err(|_| Error::Invalid(format!("{} is not UTF-8 text.", path.display())))?; + Ok(text.replace("\r\n", "\n").replace('\r', "\n")) +} + +/// Text written as Python's text mode writes it on Windows: "\n" becomes "\r\n". +fn windows_text(text: &str) -> Vec<u8> { + if cfg!(windows) { + text.replace('\n', "\r\n").into_bytes() + } else { + text.as_bytes().to_vec() + } +} + +fn placeholders(line: &str) -> Vec<String> { + let mut out = Vec::new(); + let bytes = line.as_bytes(); + let mut i = 0; + while i < bytes.len() { + if bytes[i] == b'@' { + let mut j = i + 1; + while j < bytes.len() && (bytes[j].is_ascii_alphabetic() || bytes[j] == b'_') { + j += 1; + } + if j < bytes.len() && j > i + 1 && bytes[j] == b'@' { + out.push(line[i..=j].to_string()); + i = j + 1; + continue; + } + } + i += 1; + } + out +} + +fn credentials(root: &Path) -> Result<(String, String)> { + let v: serde_json::Value = crate::fsx::read_json(&root.join("Settings/database.json"))?; + let good = |k: &str| { + v.get(k) + .and_then(|x| x.as_str()) + .filter(|s| s.len() == 48 && s.bytes().all(|b| b.is_ascii_digit() || (b'a'..=b'f').contains(&b))) + .map(str::to_string) + }; + match (good("rootPassword"), good("appPassword")) { + (Some(r), Some(a)) => Ok((r, a)), + _ => Err(Error::Invalid("Invalid packaged database configuration.".into())), + } +} + +/// Render every file the repack's services read. Refuses while a service runs and the folder or the ports +/// changed since the last render. +pub fn prepare(root: &Path, config: &Settings) -> Result<Vec<PathBuf>> { + let base = native_root(root)?; + let signature = serde_json::json!({ + "root": root.to_string_lossy(), + "ports": serde_json::Value::Object(config.port_map()), + }); + let previous = state::dir(root).join("configuration.json"); + if previous.exists() { + let recorded: Option<serde_json::Value> = crate::fsx::read_json(&previous).ok(); + if recorded.as_ref() != Some(&signature) && SERVICES.iter().any(|s| state::running(root, s).is_some()) { + return Err(Error::Invalid("Stop this repack before moving its folder or changing its ports.".into())); + } + } + let (root_password, app_password) = credentials(root)?; + for folder in ["Core/configs/modules", "Core/Logs", "BugReport/reports", "BugReport/Logs", "mysql/logs", ".state"] { + std::fs::create_dir_all(root.join(folder))?; + } + let mysql_port = config.mysql_port; + let mut values: Vec<(&str, String)> = vec![ + ("DATA", format!("{base}/Data")), + ("LOGS", format!("{base}/Core/Logs")), + ("ASCENSION_DBC", format!("{base}/Data/dbc/Ascension")), + ("MYSQL_EXE", format!("{base}/mysql/bin/mysql.exe")), + ("AUTH_PORT", config.auth_port.to_string()), + ("WORLD_PORT", config.world_port.to_string()), + ("RA_PORT", config.ra_port.to_string()), + ]; + for (key, db) in [ + ("LoginDatabaseInfo", "acore_auth"), + ("WorldDatabaseInfo", config.realm.world_db), + ("CharacterDatabaseInfo", config.realm.characters_db), + ] { + values.push((key, format!("127.0.0.1;{mysql_port};acore;{app_password};{db}"))); + } + let mut written = Vec::new(); + for (name, target) in [ + ("authserver.conf", "Core/configs/authserver.conf"), + ("worldserver.conf", "Core/configs/worldserver.conf"), + ("mod_ascension_compat.conf", "Core/configs/modules/mod_ascension_compat.conf"), + ] { + let mut text = read_text(&root.join("Settings").join(format!("{name}.template")))?; + for (key, value) in &values { + text = text.replace(&format!("@{key}@"), value); + } + let mut unresolved: Vec<String> = text + .split('\n') + .filter(|l| !l.trim().is_empty() && !l.trim_start().starts_with('#')) + .flat_map(placeholders) + .collect(); + unresolved.sort(); + unresolved.dedup(); + if !unresolved.is_empty() { + return Err(Error::Service( + crate::error::ErrorCode::InvalidConfigValue, + format!("An unresolved placeholder remains in Settings/{name}.template: {}", unresolved.join(", ")), + )); + } + // these three keep "\n" (Python wrote them with newline="\n") + std::fs::write(root.join(target), text.as_bytes())?; + written.push(root.join(target)); + } + let files: [(&str, String); 3] = [ + ( + "Core/configs/modules/coa_bugreport.conf", + format!( + "# Managed by the repack launcher. Enabled whenever worldserver starts.\nCoABugReport.Enable = 1\nCoABugReport.SpoolDirectory = \"{base}/BugReport/reports\"\nCoABugReport.CooldownSeconds = 120\n" + ), + ), + ( + "mysql/my.ini", + format!( + "[mysqld]\nbasedir=\"{base}/mysql\"\ndatadir=\"{base}/mysql/data\"\nport={mysql_port}\nbind-address=127.0.0.1\nmysqlx=0\ncharacter-set-server=utf8mb4\ncollation-server=utf8mb4_unicode_ci\nmax_allowed_packet=128M\ninnodb_buffer_pool_size=256M\nskip-log-bin\nlog-error=\"{base}/mysql/logs/mysql-error.log\"\npid-file=\"{base}/mysql/mysql.pid\"\n" + ), + ), + ( + "mysql/admin-client.ini", + format!( + "[client]\nuser=root\npassword={root_password}\nhost=127.0.0.1\nport={mysql_port}\nprotocol=tcp\ndefault-character-set=utf8mb4\n" + ), + ), + ]; + for (rel, text) in files { + std::fs::write(root.join(rel), windows_text(&text))?; + written.push(root.join(rel)); + } + state::write_json(&previous, &signature)?; + Ok(written) +} + +#[cfg(windows)] +mod sys { + use std::os::windows::ffi::OsStrExt; + use std::path::Path; + use windows_sys::Win32::Storage::FileSystem::GetShortPathNameW; + + pub fn short_path(path: &Path) -> Option<String> { + let wide: Vec<u16> = path.as_os_str().encode_wide().chain(Some(0)).collect(); + let mut buf = vec![0u16; 32768]; + let n = unsafe { GetShortPathNameW(wide.as_ptr(), buf.as_mut_ptr(), buf.len() as u32) }; + (n > 0 && (n as usize) < buf.len()).then(|| String::from_utf16_lossy(&buf[..n as usize])) + } +} + +#[cfg(not(windows))] +mod sys { + pub fn short_path(_: &std::path::Path) -> Option<String> { + None + } +} + +#[cfg(test)] +mod tests { + use super::*; + + pub(crate) fn fixture(root: &Path) { + let w = |rel: &str, text: &[u8]| { + let p = root.join(rel); + std::fs::create_dir_all(p.parent().unwrap()).unwrap(); + std::fs::write(p, text).unwrap(); + }; + w("Settings/repack.json", br#"{"authPort": 3724, "mysqlPort": 3307, "raPassword": "e0c39beaa5c14128", "raPort": 3443, "raUsername": "COAMANAGER", "worldPort": 8085}"#); + w("Settings/database.json", format!(r#"{{"rootPassword": "{}", "appPassword": "{}"}}"#, "a".repeat(48), "0123456789abcdef".repeat(3)).as_bytes()); + w("Settings/authserver.conf.template", b"[authserver]\r\nLoginDatabaseInfo = \"@LoginDatabaseInfo@\"\r\nRealmServerPort = @AUTH_PORT@\r\nLogsDir = \"@LOGS@\"\r\n# @NOT_A_VALUE@ in a comment is fine\r\n"); + w("Settings/worldserver.conf.template", "[worldserver]\nDataDir = \"@DATA@\"\nWorldServerPort = @WORLD_PORT@\nRa.Port = @RA_PORT@\nWorldDatabaseInfo = \"@WorldDatabaseInfo@\"\nCharacterDatabaseInfo = \"@CharacterDatabaseInfo@\"\nMySQLExecutable = \"@MYSQL_EXE@\"\nMotd = \"Ünïcode stays\"\n".as_bytes()); + w("Settings/mod_ascension_compat.conf.template", b"Ascension.DbcDir = \"@ASCENSION_DBC@\"\rOld.Mac = 1\r"); + } + + #[test] + fn placeholders_left_outside_comments_are_refused() { + let d = tempfile::tempdir().unwrap(); + fixture(d.path()); + std::fs::write(d.path().join("Settings/worldserver.conf.template"), "A = @UNKNOWN@\n").unwrap(); + let cfg = Settings::load(d.path(), 0).unwrap(); + let err = prepare(d.path(), &cfg).unwrap_err().to_string(); + assert!(err.contains("worldserver.conf.template: @UNKNOWN@"), "{err}"); + } + + #[test] + fn a_bad_password_file_is_refused() { + let d = tempfile::tempdir().unwrap(); + fixture(d.path()); + std::fs::write(d.path().join("Settings/database.json"), r#"{"rootPassword":"short","appPassword":"x"}"#).unwrap(); + let cfg = Settings::load(d.path(), 0).unwrap(); + assert!(prepare(d.path(), &cfg).unwrap_err().to_string().contains("Invalid packaged database configuration")); + } + + /// Byte-for-byte the same files as the Python launcher. COA_MANAGE_PY = a manage.py to compare with (taken from + /// coa-server-build); skipped without it. + #[test] + fn renders_exactly_what_manage_py_renders() { + let Ok(manage) = std::env::var("COA_MANAGE_PY") else { return }; + let python = std::env::var("COA_PYTHON").unwrap_or_else(|_| "python".into()); + let rust = tempfile::tempdir().unwrap(); + let py = tempfile::tempdir().unwrap(); + for d in [rust.path(), py.path()] { + fixture(d); + } + std::fs::create_dir_all(py.path().join("Scripts")).unwrap(); + std::fs::copy(&manage, py.path().join("Scripts/manage.py")).unwrap(); + // manage.py imports squid_playerbots lazily; prepare does not need it. + let out = std::process::Command::new(&python) + .args(["-I", "-B"]) + .arg(py.path().join("Scripts/manage.py")) + .arg("prepare") + .output() + .unwrap(); + assert!(out.status.success(), "{}{}", String::from_utf8_lossy(&out.stdout), String::from_utf8_lossy(&out.stderr)); + let cfg = Settings::load(rust.path(), 0).unwrap(); + let written = prepare(rust.path(), &cfg).unwrap(); + let root_text = |p: &Path, base: &Path| { + let n = native_root(base).unwrap(); + String::from_utf8(std::fs::read(p).unwrap()).unwrap().replace(&n, "<ROOT>") + }; + for file in &written { + let rel = file.strip_prefix(rust.path()).unwrap(); + assert_eq!( + root_text(file, rust.path()), + root_text(&py.path().join(rel), py.path()), + "{} differs", + rel.display() + ); + } + let sig = |base: &Path| -> serde_json::Value { + let mut v: serde_json::Value = crate::fsx::read_json(&base.join(".state/configuration.json")).unwrap(); + v["root"] = serde_json::Value::Null; + v + }; + assert_eq!(sig(rust.path()), sig(py.path())); + } +} diff --git a/crates/coa-core/src/launcher/services.rs b/crates/coa-core/src/launcher/services.rs new file mode 100644 index 0000000..8b74b6b --- /dev/null +++ b/crates/coa-core/src/launcher/services.rs @@ -0,0 +1,571 @@ +//! Starting, checking and stopping the services of one repack: MySQL, authserver, worldserver +//! (`manage.py start_mysql`, `start_auth`, `stop_all` and their helpers), with the same rules. + +use std::net::{SocketAddr, TcpStream}; +use std::path::{Path, PathBuf}; +use std::process::{Command, Stdio}; +use std::time::{Duration, Instant}; + +use crate::error::{Error, ErrorCode, Result}; +use crate::launcher::{settings::Settings, state}; +use crate::process::ProcessIdentity; + +pub type Progress<'a> = &'a dyn Fn(&str); + +const CREATE_NO_WINDOW: u32 = 0x0800_0000; +const CREATE_NEW_PROCESS_GROUP: u32 = 0x0000_0200; + +fn hidden(cmd: &mut Command) -> &mut Command { + #[cfg(windows)] + { + use std::os::windows::process::CommandExt; + cmd.creation_flags(CREATE_NO_WINDOW | CREATE_NEW_PROCESS_GROUP); + } + cmd +} + +/// Start `exe` with its output appended to `log`, and record it as `name`. `env_remove` are variables of this +/// process the service must not see. +pub fn spawn(root: &Path, name: &str, exe: &Path, args: &[&str], cwd: &Path, log: &Path, env_remove: &[String]) -> Result<ProcessIdentity> { + let child = crate::launcher::spawn::start(exe, args, cwd, log, env_remove)?; + state::record(root, name, child.pid) +} + +// --------------------------------------------------------------------------------------------------------------- +// Ports +// --------------------------------------------------------------------------------------------------------------- + +/// Wait (up to 30 s) until `port` can be bound by a new server. A port with a listening owner is refused at +/// once; a port Windows still holds for a stopped process (a PID-zero row) is waited for. The test bind is +/// exclusive (`SO_EXCLUSIVEADDRUSE`), never a shared one. +pub fn ensure_free(port: u16, progress: Progress) -> Result<()> { + let deadline = Instant::now() + Duration::from_secs(30); + let mut announced = false; + loop { + let mut owners: Vec<u32> = sys::tcp_rows_v4() + .into_iter() + .filter(|r| r.state == sys::LISTEN && r.local_port == port) + .map(|r| r.pid) + .collect(); + owners.sort_unstable(); + owners.dedup(); + if owners.iter().any(|p| *p != 0) { + let list: Vec<String> = owners.iter().map(u32::to_string).collect(); + return Err(Error::Service( + ErrorCode::PortInUse, + format!("Port {port} is already used (PID {}). Stop the other server or change Settings/repack.json.", list.join(", ")), + )); + } + match sys::exclusive_bind(port) { + Ok(()) => return Ok(()), + Err(code) if code == 10013 || code == 10048 => { + if Instant::now() >= deadline { + return Err(Error::Invalid(format!( + "Port {port} remains unavailable after 30 seconds (Windows bind error {code}). No process was stopped. Retry after the previous database shutdown has finished, or check the Windows port reservation." + ))); + } + if !announced { + progress(&format!("Waiting for Windows to release port {port}...")); + announced = true; + } + std::thread::sleep(Duration::from_millis(250)); + } + Err(code) => return Err(Error::Invalid(format!("Port {port} cannot be checked (Windows error {code})."))), + } + } +} + +/// Is the recorded process of `name` serving `port`? Its listener row is the evidence; when a system does not +/// show the owner of a listener, the server side of a fresh loopback connection is (never for MySQL, whose +/// listener has always been visible and which should not get stray connections). +pub fn ready(root: &Path, name: &str, port: u16) -> bool { + let Some(record) = state::running(root, name) else { return false }; + let listening = sys::tcp_rows_v4().iter().any(|r| r.state == sys::LISTEN && r.local_port == port && r.pid == record.pid); + if listening { + return crate::process::is_alive(&record); + } + if name == "mysql" { + return false; + } + accepted_by(port, record.pid) && crate::process::is_alive(&record) +} + +/// Connect to 127.0.0.1:`port` and check that exactly one established server-side row, owned by `pid`, answers +/// that connection. +fn accepted_by(port: u16, pid: u32) -> bool { + let addr: SocketAddr = ([127, 0, 0, 1], port).into(); + let Ok(client) = TcpStream::connect_timeout(&addr, Duration::from_millis(500)) else { return false }; + let Ok(mine) = client.local_addr().map(|a| a.port()) else { return false }; + let me = std::process::id(); + let rows: Vec<sys::TcpRow> = sys::tcp_rows_v4() + .into_iter() + .chain(sys::tcp_rows_v6()) + .filter(|r| r.remote_port == mine && r.remote_loopback && !(r.local_port == mine && r.pid == me)) + .collect(); + rows.len() == 1 && rows[0].state == sys::ESTABLISHED && rows[0].pid == pid +} + +pub fn wait_ready(root: &Path, name: &str, port: u16, seconds: u64) -> Result<()> { + let until = Instant::now() + Duration::from_secs(seconds); + while Instant::now() < until { + if ready(root, name, port) { + return Ok(()); + } + if state::running(root, name).is_none() { + return Err(Error::Service(ErrorCode::StartupFailed, format!("{name} stopped during startup. Check its log."))); + } + std::thread::sleep(Duration::from_millis(500)); + } + Err(Error::Service( + ErrorCode::StartupFailed, + format!("{name} is still starting: its expected TCP listener on port {port} was not found; check its log."), + )) +} + +// --------------------------------------------------------------------------------------------------------------- +// MySQL client +// --------------------------------------------------------------------------------------------------------------- + +/// Run SQL (or a `mysqladmin` command) with the repack's own client and administrator login. +pub fn mysql(root: &Path, sql: Option<&str>, admin: Option<&str>) -> Result<String> { + let exe = root.join(if admin.is_some() { "mysql/bin/mysqladmin.exe" } else { "mysql/bin/mysql.exe" }); + let defaults = format!("--defaults-file={}", root.join("mysql/admin-client.ini").display()); + let mut cmd = Command::new(exe); + hidden(&mut cmd).arg(defaults); + match admin { + Some(a) => cmd.arg(a), + None => cmd.args(["--batch", "--skip-column-names"]), + }; + let payload = sql.map(|s| s.as_bytes().to_vec()); + let timeout = if payload.as_ref().is_some_and(|p| p.len() > 1024 * 1024) { 900 } else { 90 }; + cmd.stdin(if payload.is_some() { Stdio::piped() } else { Stdio::null() }).stdout(Stdio::piped()).stderr(Stdio::piped()); + let mut child = cmd.spawn()?; + if let (Some(data), Some(mut stdin)) = (payload, child.stdin.take()) { + std::thread::spawn(move || { + use std::io::Write; + let _ = stdin.write_all(&data); + }); + } + // Both outputs are read while the client runs: a full pipe would stop it (and look like a timeout). + let read = |pipe: Option<Box<dyn std::io::Read + Send>>| { + std::thread::spawn(move || { + let mut buf = Vec::new(); + if let Some(mut p) = pipe { + let _ = p.read_to_end(&mut buf); + } + buf + }) + }; + let out_reader = read(child.stdout.take().map(|p| Box::new(p) as Box<dyn std::io::Read + Send>)); + let err_reader = read(child.stderr.take().map(|p| Box::new(p) as Box<dyn std::io::Read + Send>)); + let started = Instant::now(); + let failed = |stderr: &[u8]| { + let text = String::from_utf8_lossy(stderr); + let detail = text.lines().rev().find(|l| !l.trim().is_empty()).unwrap_or("").trim().to_string(); + let mut message = "The repack database command failed; check mysql/logs/mysql-error.log.".to_string(); + if !detail.is_empty() { + message.push_str(&format!(" ({detail})")); + } + Error::Invalid(message) + }; + let status = loop { + if let Some(status) = child.try_wait()? { + break status; + } + if started.elapsed() > Duration::from_secs(timeout) { + let _ = child.kill(); + let _ = child.wait(); + let _ = out_reader.join(); + return Err(failed(b"timed out")); + } + std::thread::sleep(Duration::from_millis(50)); + }; + let stdout = out_reader.join().unwrap_or_default(); + let stderr = err_reader.join().unwrap_or_default(); + if !status.success() { + return Err(failed(&stderr)); + } + Ok(String::from_utf8_lossy(&stdout).trim().to_string()) +} + +// --------------------------------------------------------------------------------------------------------------- +// Start and stop +// --------------------------------------------------------------------------------------------------------------- + +pub fn start_mysql(root: &Path, cfg: &Settings, progress: Progress) -> Result<()> { + if cfg.shared_database { + // An extra world uses the main folder's database; it must already run. + return mysql(root, None, Some("ping")).map(|_| ()).map_err(|e| { + Error::Service(ErrorCode::DatabaseNotRunning, format!("The main server's database is not running. {e}")) + }); + } + if state::running(root, "mysql").is_some() { + wait_ready(root, "mysql", cfg.mysql_port, 300)?; + mysql(root, None, Some("ping"))?; + progress("MySQL is already running."); + return Ok(()); + } + ensure_free(cfg.mysql_port, progress)?; + if !root.join("mysql/data/mysql").is_dir() { + return Err(Error::Service(ErrorCode::ServerFilesIncomplete, "The packaged database is missing. Extract the complete repack.".into())); + } + progress("Starting MySQL..."); + let ini = format!("--defaults-file={}", root.join("mysql/my.ini").display()); + spawn(root, "mysql", &root.join("mysql/bin/mysqld.exe"), &[&ini, "--no-monitor"], &root.join("mysql"), &root.join("mysql/logs/startup.log"), &cfg.env_remove)?; + wait_ready(root, "mysql", cfg.mysql_port, 300)?; + mysql(root, None, Some("ping"))?; + mysql( + root, + Some(&format!( + "UPDATE acore_auth.realmlist SET name='{}',address='127.0.0.1',localAddress='127.0.0.1',port={} WHERE id={};", + cfg.realm.name, cfg.world_port, cfg.realm.id + )), + None, + )?; + Ok(()) +} + +pub fn start_auth(root: &Path, cfg: &Settings, progress: Progress) -> Result<()> { + start_mysql(root, cfg, progress)?; + if state::running(root, "auth").is_some() { + wait_ready(root, "auth", cfg.auth_port, 60)?; + progress("Authserver is already running."); + return Ok(()); + } + ensure_free(cfg.auth_port, progress)?; + // An interrupted world startup can leave flag 3, which authserver excludes. + mysql(root, Some(&format!("UPDATE acore_auth.realmlist SET flag=0 WHERE id={};", cfg.realm.id)), None)?; + progress("Starting authserver..."); + spawn(root, "auth", &root.join("Core/authserver.exe"), &["-c", "configs/authserver.conf"], &root.join("Core"), &root.join("Core/Logs/auth-console.log"), &cfg.env_remove)?; + wait_ready(root, "auth", cfg.auth_port, 60) +} + +/// Stop the recorded process, only if it is still that process. +pub fn terminate(record: &ProcessIdentity) -> Result<()> { + if !crate::process::is_alive(record) { + return Ok(()); + } + sys::terminate(record) +} + +pub fn wait_stopped(record: &ProcessIdentity, seconds: u64) -> bool { + let until = Instant::now() + Duration::from_secs(seconds); + while crate::process::is_alive(record) && Instant::now() < until { + std::thread::sleep(Duration::from_millis(250)); + } + !crate::process::is_alive(record) +} + +/// The recorded world, when it is this folder's own `Core/worldserver.exe` (never stop a process only because a +/// record names it). +fn owned_world(root: &Path) -> Result<Option<ProcessIdentity>> { + let Some(world) = state::running(root, "world") else { return Ok(None) }; + let expected = root.join("Core/worldserver.exe"); + let same = std::fs::canonicalize(&world.exe).ok().zip(std::fs::canonicalize(&expected).ok()).is_some_and(|(a, b)| a == b); + if !same { + return Err(Error::Invalid("World process ownership could not be verified; the database was left running.".into())); + } + Ok(Some(world)) +} + +/// Ask the world's console for a graceful shutdown. False when the console is not this world's or does not answer. +fn ask_shutdown(root: &Path, cfg: &Settings) -> bool { + ready(root, "world", cfg.ra_port) + && crate::ra::Ra::connect_to(cfg.ra_port, &cfg.ra_username, &cfg.ra_password) + .and_then(|ra| ra.send_without_answer("server shutdown 1s 0")) + .is_ok() +} + +/// Stop this folder's world without its console (unsaved progress since the last save is lost). +fn stop_world_process(world: &ProcessIdentity) -> Result<()> { + terminate(world).map_err(|_| Error::Invalid("Worldserver could not be stopped safely; its database was left running.".into()))?; + if !wait_stopped(world, 90) { + return Err(Error::Invalid("Worldserver is still stopping; its database was left running.".into())); + } + Ok(()) +} + +/// Stop the world at once, then everything else as [`stop_all`] does. Only when the user asked for it. +pub fn force_stop_all(root: &Path, cfg: &Settings, progress: Progress) -> Result<()> { + if let Some(world) = owned_world(root)? { + stop_world_process(&world)?; + progress("Force-stopped this server's verified world process; unsaved progress may be lost."); + } + stop_all(root, cfg, progress) +} + +/// Stop everything of this repack, world first (gracefully through its console), its database last. An extra +/// world leaves the shared database alone. +pub fn stop_all(root: &Path, cfg: &Settings, progress: Progress) -> Result<()> { + if let Some(world) = owned_world(root)? { + if ask_shutdown(root, cfg) { + progress("Graceful world shutdown requested."); + } else { + progress("World console unavailable; stopping this repack's recorded world process."); + stop_world_process(&world)?; + } + // A console request can be lost (seen when a client disconnected at once). While the world still runs + // and its console still answers, it has not begun to stop: ask again. Asking twice is harmless. + let mut stopped = wait_stopped(&world, 15); + for _ in 0..2 { + if stopped { + break; + } + if ask_shutdown(root, cfg) { + progress("The world has not begun to stop; shutdown requested again."); + } + stopped = wait_stopped(&world, 15); + } + if !stopped && !wait_stopped(&world, 45) { + return Err(Error::Invalid("Worldserver is still stopping; its database has been left running.".into())); + } + } + if let Some(supervisor) = state::running(root, "supervisor") { + if !wait_stopped(&supervisor, 45) { + return Err(Error::Invalid("The report relay is still finishing a request. Try Stop All again shortly.".into())); + } + } + if let Some(relay) = state::running(root, "relay") { + std::fs::write(state::dir(root).join("stop-relay"), b"")?; + if !wait_stopped(&relay, 40) { + return Err(Error::Invalid("The report relay did not finish; it was left running for recovery.".into())); + } + } + if let Some(auth) = state::running(root, "auth") { + terminate(&auth)?; + if !wait_stopped(&auth, 10) { + return Err(Error::Invalid("Authserver did not stop.".into())); + } + } + if let Some(database) = state::running(root, "mysql").filter(|_| !cfg.shared_database) { + let shutdown = mysql(root, None, Some("shutdown")); + if !wait_stopped(&database, 60) { + shutdown?; + return Err(Error::Invalid("MySQL is still stopping; wait before copying the repack.".into())); + } + } + progress("All services from this repack are stopped. It is safe to move or copy this folder."); + Ok(()) +} + +/// Which services run (`manage.py status-json`). +pub fn status(root: &Path) -> serde_json::Value { + let mut out = serde_json::Map::new(); + for name in ["mysql", "auth", "world", "relay"] { + out.insert(name.into(), state::running(root, name).is_some().into()); + } + let debug: bool = crate::fsx::read_json::<serde_json::Value>(&state::dir(root).join("debug-logs.json")) + .ok() + .and_then(|v| v.get("enabled").and_then(|e| e.as_bool())) + .unwrap_or(false); + out.insert("debugLogs".into(), debug.into()); + serde_json::Value::Object(out) +} + +pub fn log_path(root: &Path, name: &str) -> PathBuf { + match name { + "mysql" => root.join("mysql/logs/startup.log"), + "auth" => root.join("Core/Logs/auth-console.log"), + "world" => root.join("Core/Logs/world-console.log"), + "supervisor" => root.join("Core/Logs/supervisor.log"), + _ => root.join("BugReport/Logs/relay.log"), + } +} + +// --------------------------------------------------------------------------------------------------------------- +// Windows +// --------------------------------------------------------------------------------------------------------------- + +#[cfg(windows)] +mod sys { + use crate::error::{Error, Result}; + use crate::process::ProcessIdentity; + use windows_sys::Win32::Foundation::CloseHandle; + use windows_sys::Win32::NetworkManagement::IpHelper::GetExtendedTcpTable; + use windows_sys::Win32::Networking::WinSock::{setsockopt, SOL_SOCKET, SO_EXCLUSIVEADDRUSE}; + use windows_sys::Win32::System::Threading::{OpenProcess, TerminateProcess, PROCESS_QUERY_LIMITED_INFORMATION, PROCESS_TERMINATE}; + + pub const LISTEN: u32 = 2; + pub const ESTABLISHED: u32 = 5; + + pub struct TcpRow { + pub state: u32, + pub local_port: u16, + pub remote_port: u16, + pub remote_loopback: bool, + pub pid: u32, + } + + fn table(af: u32) -> Vec<u8> { + const TCP_TABLE_OWNER_PID_ALL: i32 = 5; + let mut size = 0u32; + let mut buf: Vec<u8> = Vec::new(); + for _ in 0..4 { + let code = unsafe { + GetExtendedTcpTable( + if buf.is_empty() { std::ptr::null_mut() } else { buf.as_mut_ptr().cast() }, + &mut size, + 0, + af, + TCP_TABLE_OWNER_PID_ALL, + 0, + ) + }; + match code { + 0 if !buf.is_empty() => return buf, + 0 | 122 => buf = vec![0u8; size as usize + 4096], + _ => return Vec::new(), + } + } + Vec::new() + } + + fn u32_at(b: &[u8], o: usize) -> u32 { + u32::from_le_bytes(b[o..o + 4].try_into().unwrap()) + } + + pub fn tcp_rows_v4() -> Vec<TcpRow> { + let b = table(2); + let mut out = Vec::new(); + if b.len() < 4 { + return out; + } + for i in 0..u32_at(&b, 0) as usize { + let o = 4 + 24 * i; + if o + 24 > b.len() { + break; + } + let remote = u32_at(&b, o + 12).to_le_bytes(); + out.push(TcpRow { + state: u32_at(&b, o), + local_port: u16::from_be((u32_at(&b, o + 8) & 0xFFFF) as u16), + remote_port: u16::from_be((u32_at(&b, o + 16) & 0xFFFF) as u16), + remote_loopback: remote == [127, 0, 0, 1], + pid: u32_at(&b, o + 20), + }); + } + out + } + + pub fn tcp_rows_v6() -> Vec<TcpRow> { + let b = table(23); + let mut out = Vec::new(); + if b.len() < 4 { + return out; + } + // MIB_TCP6ROW_OWNER_PID: local addr 16, scope 4, local port 4, remote addr 16, scope 4, remote port 4, state 4, pid 4 + for i in 0..u32_at(&b, 0) as usize { + let o = 4 + 56 * i; + if o + 56 > b.len() { + break; + } + let remote = &b[o + 24..o + 40]; + let mapped_loopback = remote[..10].iter().all(|x| *x == 0) && remote[10] == 0xff && remote[11] == 0xff && remote[12..] == [127, 0, 0, 1]; + out.push(TcpRow { + state: u32_at(&b, o + 48), + local_port: u16::from_be((u32_at(&b, o + 20) & 0xFFFF) as u16), + remote_port: u16::from_be((u32_at(&b, o + 44) & 0xFFFF) as u16), + remote_loopback: mapped_loopback, + pid: u32_at(&b, o + 52), + }); + } + out + } + + /// Bind 0.0.0.0:port exclusively and release it. Err carries the Windows socket error. + pub fn exclusive_bind(port: u16) -> std::result::Result<(), i32> { + use socket2::{Domain, Socket, Type}; + use std::os::windows::io::AsRawSocket; + let socket = Socket::new(Domain::IPV4, Type::STREAM, None).map_err(|e| e.raw_os_error().unwrap_or(-1))?; + let one: i32 = 1; + let set = unsafe { + setsockopt(socket.as_raw_socket() as _, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (&one as *const i32).cast(), 4) + }; + if set != 0 { + return Err(std::io::Error::last_os_error().raw_os_error().unwrap_or(-1)); + } + let addr: std::net::SocketAddr = ([0, 0, 0, 0], port).into(); + socket.bind(&addr.into()).map_err(|e| e.raw_os_error().unwrap_or(-1)) + } + + pub fn terminate(record: &ProcessIdentity) -> Result<()> { + unsafe { + let h = OpenProcess(PROCESS_TERMINATE | PROCESS_QUERY_LIMITED_INFORMATION, 0, record.pid); + if h.is_null() { + return Err(Error::Invalid("Unable to stop the repack process.".into())); + } + let same = crate::process::is_alive(record); + let ok = same && TerminateProcess(h, 0) != 0; + CloseHandle(h); + if !ok { + return Err(Error::Invalid("The process changed while stopping it.".into())); + } + } + Ok(()) + } +} + +#[cfg(not(windows))] +mod sys { + use crate::error::{Error, Result}; + use crate::process::ProcessIdentity; + pub const LISTEN: u32 = 2; + pub const ESTABLISHED: u32 = 5; + pub struct TcpRow { + pub state: u32, + pub local_port: u16, + pub remote_port: u16, + pub remote_loopback: bool, + pub pid: u32, + } + pub fn tcp_rows_v4() -> Vec<TcpRow> { + Vec::new() + } + pub fn tcp_rows_v6() -> Vec<TcpRow> { + Vec::new() + } + pub fn exclusive_bind(_: u16) -> std::result::Result<(), i32> { + Ok(()) + } + pub fn terminate(_: &ProcessIdentity) -> Result<()> { + Err(Error::Invalid("not supported".into())) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn a_port_with_a_listener_is_refused_and_a_free_one_passes() { + let held = std::net::TcpListener::bind("0.0.0.0:0").unwrap(); + let port = held.local_addr().unwrap().port(); + let err = ensure_free(port, &|_| {}).unwrap_err().to_string(); + assert!(err.contains(&format!("Port {port} is already used (PID {}", std::process::id())), "{err}"); + drop(held); + ensure_free(port, &|_| {}).unwrap(); + } + + #[test] + fn a_service_is_ready_only_on_its_own_port() { + let d = tempfile::tempdir().unwrap(); + let held = std::net::TcpListener::bind("127.0.0.1:0").unwrap(); + let port = held.local_addr().unwrap().port(); + assert!(!ready(d.path(), "auth", port), "no record yet"); + state::record(d.path(), "auth", std::process::id()).unwrap(); + assert!(ready(d.path(), "auth", port)); + let other = std::net::TcpListener::bind("127.0.0.1:0").unwrap(); + drop(other); + assert!(!ready(d.path(), "auth", port + 1) || port + 1 == 0); + } + + #[test] + fn status_reads_the_records() { + let d = tempfile::tempdir().unwrap(); + state::record(d.path(), "mysql", std::process::id()).unwrap(); + let s = status(d.path()); + assert_eq!(s["mysql"], true); + assert_eq!(s["world"], false); + assert_eq!(s["debugLogs"], false); + } +} diff --git a/crates/coa-core/src/launcher/settings.rs b/crates/coa-core/src/launcher/settings.rs new file mode 100644 index 0000000..14097f4 --- /dev/null +++ b/crates/coa-core/src/launcher/settings.rs @@ -0,0 +1,168 @@ +//! `Settings/repack.json`: ports and the console login of one repack (`manage.py settings()`). + +use std::path::Path; + +use crate::error::{Error, Result}; + +pub const PORT_KEYS: [&str; 4] = ["mysqlPort", "authPort", "worldPort", "raPort"]; + +/// The realm a folder runs: its row in `acore_auth.realmlist` and its two game databases. +/// +/// Without `Settings/realm-profile.json` this is what the repack launcher always did (realm 1 "AzerothCore" on +/// `acore_world`/`acore_characters`). With it, the active profile decides, as the Manager's realm patch of +/// `manage.py` did. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct Realm { + pub id: u32, + pub name: &'static str, + pub world_db: &'static str, + pub characters_db: &'static str, +} + +impl Realm { + pub fn load(root: &Path) -> Result<Realm> { + let path = root.join("Settings/realm-profile.json"); + if !path.exists() { + return Ok(Realm { id: 1, name: "AzerothCore", world_db: "acore_world", characters_db: "acore_characters" }); + } + let v: serde_json::Value = crate::fsx::read_json(&path)?; + Ok(match v.get("active").and_then(|a| a.as_str()).unwrap_or("coa") { + "wildcard" => Realm { id: 2, name: "Wildcard", world_db: "acore_world_wildcard", characters_db: "acore_characters_wildcard" }, + "reborn" => Realm { id: 3, name: "Warcraft Reborn", world_db: "acore_world_reborn", characters_db: "acore_characters_reborn" }, + _ => Realm { id: 1, name: "Conquest of Azeroth", world_db: "acore_world", characters_db: "acore_characters" }, + }) + } +} + +/// An extra world of a server (`<server>/.realms/<name>`): it shares the main folder's database and never +/// starts or stops it. +pub fn is_extra_world(root: &Path) -> bool { + root.parent().and_then(|p| p.file_name()).is_some_and(|n| n == ".realms") +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct Settings { + pub mysql_port: u16, + pub auth_port: u16, + pub world_port: u16, + pub ra_port: u16, + pub ra_username: String, + pub ra_password: String, + pub realm: Realm, + /// The database belongs to the main folder of this server (an extra world): it is only checked, never + /// started. + pub shared_database: bool, + /// Environment variables the started services must not see (for example a port override of the caller). + pub env_remove: Vec<String>, + /// The whole document, for keys this code does not know (kept when it is written back). + pub raw: serde_json::Map<String, serde_json::Value>, +} + +impl Settings { + /// Read `Settings/repack.json`, with every port moved by `offset` (a second world of the same server runs on + /// shifted ports). The same checks as `manage.py`: integer ports in 1025..65535 after the offset, all + /// different. + pub fn load(root: &Path, offset: i32) -> Result<Settings> { + let bytes = std::fs::read(root.join("Settings/repack.json"))?; + let text = String::from_utf8_lossy(&bytes); + let text = text.strip_prefix('\u{feff}').unwrap_or(&text); + let raw: serde_json::Map<String, serde_json::Value> = + serde_json::from_str(text).map_err(|e| Error::Invalid(format!("Settings/repack.json: {e}")))?; + let mut ports = [0u16; 4]; + for (i, key) in PORT_KEYS.iter().enumerate() { + // Python's `type(value) is not int` refuses booleans and floats alike. + let value = raw.get(*key).and_then(|v| v.as_i64()).filter(|_| raw[*key].is_i64() || raw[*key].is_u64()); + let shifted = value.map(|v| v + i64::from(offset)); + match shifted { + Some(p) if p > 1024 && p < 65536 => ports[i] = p as u16, + _ => return Err(Error::Service(crate::error::ErrorCode::InvalidConfigValue, "Invalid port in Settings/repack.json".into())), + } + } + let mut unique = ports.to_vec(); + unique.sort_unstable(); + unique.dedup(); + if unique.len() != 4 { + return Err(Error::Invalid("Each service needs a different port.".into())); + } + let text_of = |k: &str| raw.get(k).and_then(|v| v.as_str()).unwrap_or_default().to_string(); + Ok(Settings { + mysql_port: ports[0], + auth_port: ports[1], + world_port: ports[2], + ra_port: ports[3], + ra_username: text_of("raUsername"), + ra_password: text_of("raPassword"), + realm: Realm::load(root)?, + shared_database: is_extra_world(root), + env_remove: Vec::new(), + raw, + }) + } + + /// `{"mysqlPort": .., "authPort": .., "worldPort": .., "raPort": ..}` as `manage.py` records it in + /// `.state/configuration.json` (the keys of repack.json ending in "Port", in the file's order). + pub fn port_map(&self) -> serde_json::Map<String, serde_json::Value> { + let shifted = [self.mysql_port, self.auth_port, self.world_port, self.ra_port]; + let mut out = serde_json::Map::new(); + for key in self.raw.keys().filter(|k| k.ends_with("Port")) { + let value = PORT_KEYS + .iter() + .position(|p| p == key) + .map(|i| serde_json::Value::from(shifted[i])) + .unwrap_or_else(|| self.raw[key].clone()); + out.insert(key.clone(), value); + } + out + } +} + +#[cfg(test)] +mod tests { + use super::*; + + fn write(dir: &Path, text: &str) { + std::fs::create_dir_all(dir.join("Settings")).unwrap(); + std::fs::write(dir.join("Settings/repack.json"), text).unwrap(); + } + + #[test] + fn ports_are_checked_like_the_python_launcher() { + let d = tempfile::tempdir().unwrap(); + write(d.path(), r#"{"mysqlPort":3307,"authPort":3724,"worldPort":8085,"raPort":3443,"raUsername":"U","raPassword":"P"}"#); + let s = Settings::load(d.path(), 0).unwrap(); + assert_eq!((s.mysql_port, s.auth_port, s.world_port, s.ra_port), (3307, 3724, 8085, 3443)); + assert_eq!(s.ra_username, "U"); + let shifted = Settings::load(d.path(), 10).unwrap(); + assert_eq!(shifted.world_port, 8095); + assert_eq!(shifted.port_map()["worldPort"], serde_json::json!(8095)); + + for bad in [ + r#"{"mysqlPort":1024,"authPort":3724,"worldPort":8085,"raPort":3443}"#, + r#"{"mysqlPort":"3307","authPort":3724,"worldPort":8085,"raPort":3443}"#, + r#"{"mysqlPort":3307.0,"authPort":3724,"worldPort":8085,"raPort":3443}"#, + r#"{"mysqlPort":true,"authPort":3724,"worldPort":8085,"raPort":3443}"#, + r#"{"mysqlPort":3307,"authPort":3307,"worldPort":8085,"raPort":3443}"#, + r#"{"authPort":3724,"worldPort":8085,"raPort":3443}"#, + ] { + write(d.path(), bad); + assert!(Settings::load(d.path(), 0).is_err(), "{bad}"); + } + write(d.path(), "\u{feff}{\"mysqlPort\":3307,\"authPort\":3724,\"worldPort\":8085,\"raPort\":65535}"); + assert!(Settings::load(d.path(), 1).is_err(), "65536 after the offset"); + assert!(Settings::load(d.path(), 0).is_ok(), "a byte order mark is accepted"); + } + + #[test] + fn the_realm_follows_the_active_profile() { + let d = tempfile::tempdir().unwrap(); + assert_eq!(Realm::load(d.path()).unwrap().name, "AzerothCore"); + std::fs::create_dir_all(d.path().join("Settings")).unwrap(); + for (active, id, db) in [("coa", 1, "acore_world"), ("wildcard", 2, "acore_world_wildcard"), ("reborn", 3, "acore_world_reborn")] { + std::fs::write(d.path().join("Settings/realm-profile.json"), format!("{{\"active\":\"{active}\"}}")).unwrap(); + let r = Realm::load(d.path()).unwrap(); + assert_eq!((r.id, r.world_db), (id, db)); + } + assert!(is_extra_world(&d.path().join(".realms/secondary"))); + assert!(!is_extra_world(d.path())); + } +} diff --git a/crates/coa-core/src/launcher/spawn.rs b/crates/coa-core/src/launcher/spawn.rs new file mode 100644 index 0000000..6af680e Binary files /dev/null and b/crates/coa-core/src/launcher/spawn.rs differ diff --git a/crates/coa-core/src/launcher/squid.rs b/crates/coa-core/src/launcher/squid.rs new file mode 100644 index 0000000..1ac0409 --- /dev/null +++ b/crates/coa-core/src/launcher/squid.rs @@ -0,0 +1,398 @@ +//! SQUID Playerbots on a repack (`Scripts/squid_playerbots.py`): the bot modules must not both run, how long a +//! SQUID world may take to start, and its database, provisioned before the world starts. +//! +//! The SQL journals are the ones the Python script keeps, unchanged: `coa_squid_migrations(path, sha256)` and +//! `coa_squid_pending(path, sha256)` in every target schema, and the SQUID installer's `coa_bots_installed`. + +use std::collections::{BTreeMap, BTreeSet}; +use std::path::{Path, PathBuf}; + +use sha1::Digest as _; + +use crate::error::{Error, Result}; + +/// `key = value` lines of a module config (comments and quotes dropped), as `options()` reads them. +pub fn options(path: &Path) -> BTreeMap<String, String> { + let mut out = BTreeMap::new(); + let Ok(bytes) = std::fs::read(path) else { return out }; + let text = String::from_utf8_lossy(&bytes); + let text = text.strip_prefix('\u{feff}').unwrap_or(&text); + for line in text.lines() { + let line = line.trim_start(); + let Some((key, rest)) = line.split_once('=') else { continue }; + let key = key.trim_end(); + if key.is_empty() || key.starts_with('#') || key.contains(char::is_whitespace) { + continue; + } + let value = rest.split('#').next().unwrap_or("").trim(); + out.insert(key.to_string(), value.trim_matches('"').to_string()); + } + out +} + +/// A secondary world shares the primary's package files. +pub fn package_root(root: &Path) -> PathBuf { + let secondary = root.file_name().is_some_and(|n| n == "secondary") + && root.parent().and_then(|p| p.file_name()).is_some_and(|n| n == ".realms"); + if secondary { + root.parent().and_then(Path::parent).map(Path::to_path_buf).unwrap_or_else(|| root.to_path_buf()) + } else { + root.to_path_buf() + } +} + +pub fn module_options(root: &Path, name: &str) -> (PathBuf, BTreeMap<String, String>) { + let folder = root.join("Core/configs/modules"); + let active = folder.join(name); + let mut path = if active.exists() { active } else { folder.join(format!("{name}.dist")) }; + if !path.exists() && name == "playerbots.conf" { + path = package_root(root).join("Core/configs/modules/playerbots.conf.dist"); + } + let values = options(&path); + (path, values) +} + +/// Invalid booleans count as the modules' compiled default: enabled. +pub fn enabled(values: &BTreeMap<String, String>, key: &str) -> bool { + !matches!(values.get(key).map(|v| v.to_ascii_lowercase()).as_deref(), Some("0" | "false" | "no" | "off")) +} + +pub fn validate_bots(root: &Path) -> Result<()> { + let (a, av) = module_options(root, "mod_coa_playerbots.conf"); + let (b, bv) = module_options(root, "playerbots.conf"); + if a.exists() && b.exists() && enabled(&av, "CoaBots.Enable") && enabled(&bv, "AiPlayerbot.Enabled") { + return Err(Error::Invalid( + "CoA Companions and SQUID Playerbots cannot both be enabled. Disable one bot module in Modules or its config.".into(), + )); + } + Ok(()) +} + +/// Seconds a world may take to open its port: SQUID loads its bots first. +pub fn startup_timeout(root: &Path) -> u64 { + let (path, values) = module_options(root, "playerbots.conf"); + if path.exists() && enabled(&values, "AiPlayerbot.Enabled") { + 1500 + } else { + 180 + } +} + +/// Replace (or append) `key = value` lines; the file is written with "\n" line ends. +pub fn set_options(path: &Path, values: &[(&str, String)]) -> Result<()> { + let bytes = std::fs::read(path)?; + let text = String::from_utf8_lossy(&bytes); + let mut text = text.strip_prefix('\u{feff}').unwrap_or(&text).replace("\r\n", "\n"); + for (key, value) in values { + let line = format!("{key} = {value}"); + let mut found = false; + let lines: Vec<String> = text + .split('\n') + .map(|l| { + let t = l.trim_start(); + let matches = t.strip_prefix(key).is_some_and(|rest| rest.trim_start().starts_with('=')); + if matches { + found = true; + line.clone() + } else { + l.to_string() + } + }) + .collect(); + text = lines.join("\n"); + if !found { + text.push('\n'); + text.push_str(&line); + text.push('\n'); + } + } + crate::fsx::atomic_write(path, text.as_bytes()) +} + +fn valid_relative(rel: &str) -> bool { + !rel.is_empty() && rel.bytes().all(|b| b.is_ascii_alphanumeric() || matches!(b, b'_' | b'.' | b'/' | b'-')) +} + +/// Table names a base file creates (`CREATE TABLE [IF NOT EXISTS] name`). +fn created_tables(sql: &str) -> BTreeSet<String> { + let mut out = BTreeSet::new(); + let upper = sql.to_ascii_uppercase(); + let mut from = 0; + while let Some(i) = upper[from..].find("CREATE") { + let start = from + i + "CREATE".len(); + from = start; + let rest = &sql[start..]; + let mut words = rest.split_whitespace(); + if !words.next().is_some_and(|w| w.eq_ignore_ascii_case("TABLE")) { + continue; + } + let mut name = words.next().unwrap_or(""); + if name.eq_ignore_ascii_case("IF") { + let _ = words.next(); // NOT + let _ = words.next(); // EXISTS + name = words.next().unwrap_or(""); + } + let name: String = name.trim_start_matches('`').chars().take_while(|c| c.is_ascii_alphanumeric() || *c == '_').collect(); + if !name.is_empty() { + out.insert(name); + } + } + out +} + +fn sha256_hex(bytes: &[u8]) -> String { + crate::fsx::sha256_bytes(bytes) +} + +fn sha1_hex(bytes: &[u8]) -> String { + let mut h = sha1::Sha1::new(); + h.update(bytes); + h.finalize().iter().map(|b| format!("{b:02x}")).collect() +} + +fn rows(text: &str) -> Vec<(String, String)> { + text.lines().filter_map(|r| r.split_once('\t')).map(|(a, b)| (a.to_string(), b.to_string())).collect() +} + +/// Provision an enabled SQUID without replaying imported base tables (`prepare_playerbots`). `mysql(sql)` runs +/// SQL with the repack's administrator login and returns its output. +pub fn prepare_playerbots(root: &Path, mysql_port: u16, mysql: &dyn Fn(&str) -> Result<String>, progress: &dyn Fn(&str)) -> Result<()> { + let (mut path, values) = module_options(root, "playerbots.conf"); + if !path.exists() || !enabled(&values, "AiPlayerbot.Enabled") { + return Ok(()); + } + validate_bots(root)?; + let sql_root = package_root(root).join("Extras/SquidPlayerbots/sql"); + if !sql_root.join("playerbots/base").is_dir() { + return Err(Error::Invalid("SQUID Playerbots database files are missing. Repair the server installation.".into())); + } + let world = options(&root.join("Core/configs/worldserver.conf")); + let mut schemas: Vec<(&str, String)> = Vec::new(); + for (kind, key) in [("characters", "CharacterDatabaseInfo"), ("world", "WorldDatabaseInfo")] { + let schema = world.get(key).and_then(|v| v.rsplit(';').next()).unwrap_or("").to_string(); + let ok = matches!(schema.as_str(), "acore_world" | "acore_characters" | "acore_world_wildcard" | "acore_characters_wildcard"); + if !ok { + return Err(Error::Invalid("Unsupported world/characters database for SQUID Playerbots.".into())); + } + schemas.push((kind, schema)); + } + schemas.push(("playerbots", "acore_playerbots".into())); + + let list = |schema: &str| -> Result<BTreeSet<String>> { + Ok(mysql(&format!("SELECT TABLE_NAME FROM information_schema.TABLES WHERE TABLE_SCHEMA='{schema}';"))? + .lines() + .map(str::to_string) + .collect()) + }; + let existing_playerbots = list("acore_playerbots")?; + let bookkeeping = ["updates", "updates_include", "version_db_playerbots", "coa_squid_migrations", "coa_bots_installed", "coa_squid_pending"]; + let data_tables: Vec<&String> = existing_playerbots.iter().filter(|t| !bookkeeping.contains(&t.as_str())).collect(); + let mut installer_history = BTreeSet::new(); + if existing_playerbots.contains("coa_bots_installed") { + for name in mysql("SELECT file FROM `acore_playerbots`.coa_bots_installed;")?.lines() { + let mut n = name.replace('\\', "/"); + while n.contains("//") { + n = n.replace("//", "/"); + } + let n = n.trim_matches('/').to_string(); + if n.to_ascii_lowercase().ends_with(".sql") { + installer_history.insert(n); + } + } + } + let mut tables: BTreeMap<&str, BTreeSet<String>> = BTreeMap::new(); + let mut histories: BTreeMap<&str, BTreeMap<String, String>> = BTreeMap::new(); + let mut ledgers: BTreeMap<&str, BTreeMap<String, String>> = BTreeMap::new(); + for (kind, schema) in &schemas { + let t = if *kind == "playerbots" { existing_playerbots.clone() } else { list(schema)? }; + if t.contains("coa_squid_pending") { + let pending = mysql(&format!("SELECT path FROM `{schema}`.coa_squid_pending;"))?; + let pending = pending.trim(); + if !pending.is_empty() { + return Err(Error::Invalid(format!( + "A SQUID base import was interrupted. Restore the database backup or repair the incomplete import before continuing; no SQL was applied: {pending}" + ))); + } + } + let mut history = BTreeMap::new(); + if t.contains("updates") { + for (name, digest) in rows(&mysql(&format!("SELECT name,hash FROM `{schema}`.updates;"))?) { + history.insert(name, digest.to_ascii_lowercase()); + } + } + let mut ledger = BTreeMap::new(); + if t.contains("coa_squid_migrations") { + for (name, digest) in rows(&mysql(&format!("SELECT path,sha256 FROM `{schema}`.coa_squid_migrations;"))?) { + ledger.insert(name, digest); + } + } + tables.insert(kind, t); + histories.insert(kind, history); + ledgers.insert(kind, ledger); + } + if !data_tables.is_empty() && installer_history.is_empty() && histories["playerbots"].is_empty() && ledgers["playerbots"].is_empty() { + for table in data_tables { + let quoted = table.replace('`', "``"); + if mysql(&format!("SELECT EXISTS(SELECT 1 FROM `acore_playerbots`.`{quoted}` LIMIT 1);"))?.trim() == "1" { + return Err(Error::Invalid( + "Existing SQUID data has no recorded installation history. Repair the imported database history before continuing; no SQL was applied.".into(), + )); + } + } + } + mysql("CREATE DATABASE IF NOT EXISTS acore_playerbots CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;")?; + for host in ["localhost", "127.0.0.1"] { + mysql(&format!("GRANT ALL PRIVILEGES ON acore_playerbots.* TO 'acore'@'{host}';"))?; + } + let (_, password) = crate::db::credentials(root)?; + if password.len() != 48 || !password.bytes().all(|b| b.is_ascii_digit() || (b'a'..=b'f').contains(&b)) { + return Err(Error::Invalid("Invalid packaged database configuration.".into())); + } + if path.file_name().is_some_and(|n| n.to_string_lossy().ends_with(".dist")) { + let active = root.join("Core/configs/modules/playerbots.conf"); + std::fs::create_dir_all(active.parent().unwrap())?; + std::fs::write(&active, std::fs::read(&path)?)?; + path = active; + } + set_options( + &path, + &[ + ("PlayerbotsDatabaseInfo", format!("\"127.0.0.1;{mysql_port};acore;{password};acore_playerbots\"")), + ("Playerbots.Updates.EnableDatabases", "0".into()), + ], + )?; + for (kind, schema) in &schemas { + mysql(&format!("CREATE TABLE IF NOT EXISTS `{schema}`.coa_squid_migrations (path VARCHAR(240) PRIMARY KEY, sha256 CHAR(64) NOT NULL);"))?; + mysql(&format!("CREATE TABLE IF NOT EXISTS `{schema}`.coa_squid_pending (path VARCHAR(240) PRIMARY KEY, sha256 CHAR(64) NOT NULL);"))?; + let history = &histories[kind]; + let recorded = ledgers[kind].clone(); + for stage in ["base", "updates", "custom"] { + let mut sources: Vec<PathBuf> = std::fs::read_dir(sql_root.join(kind).join(stage)) + .map(|rd| rd.flatten().map(|e| e.path()).filter(|p| p.extension().is_some_and(|e| e == "sql")).collect()) + .unwrap_or_default(); + sources.sort(); + for source in sources { + let relative = source.strip_prefix(&sql_root).unwrap_or(&source).to_string_lossy().replace('\\', "/"); + if !valid_relative(&relative) { + return Err(Error::Invalid("Invalid SQUID SQL filename.".into())); + } + let bytes = std::fs::read(&source)?; + let digest = sha256_hex(&bytes); + if let Some(previous) = recorded.get(&relative) { + if *previous != digest { + return Err(Error::Invalid(format!("A previously applied SQUID database migration changed: {relative}"))); + } + if stage != "base" { + continue; + } + } + let ledger_sql = if recorded.contains_key(&relative) { + String::new() + } else { + format!("INSERT INTO `{schema}`.coa_squid_migrations VALUES ('{relative}','{digest}');") + }; + let text = String::from_utf8_lossy(&bytes); + let text = text.strip_prefix('\u{feff}').unwrap_or(&text).to_string(); + if stage == "base" { + let definitions = created_tables(&text); + let present: BTreeSet<String> = definitions.intersection(&tables[kind]).cloned().collect(); + if !present.is_empty() && present != definitions { + return Err(Error::Invalid(format!("SQUID base file has only some of its tables. Repair the incomplete database before continuing: {relative}"))); + } + if definitions.is_empty() { + return Err(Error::Invalid(format!("SQUID base file has no recognizable table definitions; repair is required: {relative}"))); + } + if present == definitions { + if !ledger_sql.is_empty() { + mysql(&ledger_sql)?; + } + continue; + } + mysql(&format!("INSERT INTO `{schema}`.coa_squid_pending VALUES ('{relative}','{digest}'); COMMIT;"))?; + let complete = format!("DELETE FROM `{schema}`.coa_squid_pending WHERE path='{relative}' AND sha256='{digest}'; COMMIT;"); + progress(&format!("Importing SQUID {relative} into {schema} ({} bytes); large imports may take several minutes...", bytes.len())); + mysql(&format!("USE `{schema}`;\n{text}\n{ledger_sql}\n{complete}")).map_err(|_| { + Error::Invalid(format!( + "SQUID import failed: {relative} in {schema}. The world server was not started. The incomplete import is recorded; restore a database backup or repair that import before retrying." + )) + })?; + progress(&format!("Imported SQUID {relative}.")); + if let Some(t) = tables.get_mut(kind) { + t.extend(definitions); + } + continue; + } + if installer_history.iter().any(|n| *n == relative || n.ends_with(&format!("/{relative}"))) { + mysql(&ledger_sql)?; + continue; + } + let file_name = source.file_name().unwrap_or_default().to_string_lossy().into_owned(); + if let Some(upstream) = history.get(&file_name) { + let lf = String::from_utf8_lossy(&bytes).replace("\r\n", "\n"); + let accepted = [sha1_hex(&bytes), sha1_hex(lf.as_bytes())]; + if !upstream.is_empty() && !accepted.contains(upstream) { + return Err(Error::Invalid(format!("SQUID update history does not match the shipped SQL: {relative}"))); + } + mysql(&ledger_sql)?; + continue; + } + mysql(&format!("USE `{schema}`;\n{text}\n{ledger_sql}"))?; + } + } + } + Ok(()) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn config_lines_are_read_like_the_python_script() { + let d = tempfile::tempdir().unwrap(); + let p = d.path().join("playerbots.conf"); + std::fs::write(&p, "\u{feff}# comment = 1\nAiPlayerbot.Enabled = 0 # off\n Key.Two=\"quoted\"\nnot a line\nEmpty =\n").unwrap(); + let o = options(&p); + assert_eq!(o.get("AiPlayerbot.Enabled").map(String::as_str), Some("0")); + assert_eq!(o.get("Key.Two").map(String::as_str), Some("quoted")); + assert_eq!(o.get("Empty").map(String::as_str), Some("")); + assert!(!o.contains_key("#")); + assert!(!enabled(&o, "AiPlayerbot.Enabled")); + assert!(enabled(&o, "Missing")); + } + + #[test] + fn both_bot_modules_on_is_refused_and_squid_gets_a_long_startup() { + let d = tempfile::tempdir().unwrap(); + let m = d.path().join("Core/configs/modules"); + std::fs::create_dir_all(&m).unwrap(); + std::fs::write(m.join("mod_coa_playerbots.conf"), "CoaBots.Enable = 1\n").unwrap(); + std::fs::write(m.join("playerbots.conf.dist"), "AiPlayerbot.Enabled = 1\n").unwrap(); + assert!(validate_bots(d.path()).is_err()); + assert_eq!(startup_timeout(d.path()), 1500); + std::fs::write(m.join("playerbots.conf"), "AiPlayerbot.Enabled = 0\n").unwrap(); + validate_bots(d.path()).unwrap(); + assert_eq!(startup_timeout(d.path()), 180); + } + + #[test] + fn options_are_replaced_or_appended() { + let d = tempfile::tempdir().unwrap(); + let p = d.path().join("playerbots.conf"); + std::fs::write(&p, "A = 1\r\n Playerbots.Updates.EnableDatabases = 1\r\n").unwrap(); + set_options(&p, &[("Playerbots.Updates.EnableDatabases", "0".into()), ("PlayerbotsDatabaseInfo", "\"x\"".into())]).unwrap(); + assert_eq!(std::fs::read_to_string(&p).unwrap(), "A = 1\nPlayerbots.Updates.EnableDatabases = 0\n\nPlayerbotsDatabaseInfo = \"x\"\n"); + } + + #[test] + fn base_tables_are_found() { + let t = created_tables("CREATE TABLE IF NOT EXISTS `ai_playerbot_names` (\n id int);\ncreate table playerbots_random_bots(x int);\n-- CREATE INDEX i ON t(x);"); + assert_eq!(t, ["ai_playerbot_names".to_string(), "playerbots_random_bots".to_string()].into_iter().collect()); + } + + #[test] + fn a_secondary_world_uses_the_primary_package() { + assert_eq!(package_root(Path::new("C:/S/.realms/secondary")), Path::new("C:/S")); + assert_eq!(package_root(Path::new("C:/S")), Path::new("C:/S")); + } +} diff --git a/crates/coa-core/src/launcher/state.rs b/crates/coa-core/src/launcher/state.rs new file mode 100644 index 0000000..3e33fc6 --- /dev/null +++ b/crates/coa-core/src/launcher/state.rs @@ -0,0 +1,198 @@ +//! `.state/`: which processes belong to this repack, and the one-action-at-a-time lock. + +use std::fs::{File, OpenOptions}; +use std::io::{Seek, SeekFrom, Write}; +use std::path::{Path, PathBuf}; +use std::time::{Duration, Instant}; + +use crate::error::{Error, Result}; +use crate::fsx; +use crate::process::{self, ProcessIdentity}; + +pub fn dir(root: &Path) -> PathBuf { + root.join(".state") +} + +/// Written like `manage.py atomic_json`: two-space JSON and a newline, now flushed to disk before it replaces +/// the old file. +pub fn write_json(path: &Path, value: &impl serde::Serialize) -> Result<()> { + let mut text = serde_json::to_string_pretty(value)?; + text.push('\n'); + fsx::atomic_write(path, text.as_bytes()) +} + +/// The recorded process of `name` when it is still that process (same executable and start time). A missing, +/// empty or damaged record is no process: `manage.py` failed on those, and every later start with it. +pub fn running(root: &Path, name: &str) -> Option<ProcessIdentity> { + let record = process::read_state_record(root, name)?; + process::is_alive(&record).then_some(record) +} + +/// Record the process `pid` as `name`. Fails when it has already exited. +pub fn record(root: &Path, name: &str, pid: u32) -> Result<ProcessIdentity> { + let identity = process::identity(pid) + .ok_or_else(|| Error::Invalid(format!("{name} exited during startup; check its log.")))?; + write_json(&dir(root).join(format!("{name}.json")), &identity)?; + Ok(identity) +} + +/// Held while one start/stop action runs. Byte 0 of `.state/control.lock` is locked, exactly the region +/// `msvcrt.locking(fd, LK_NBLCK, 1)` locks in `manage.py`, so a Python launcher and this one exclude each other. +pub struct ControlLock { + file: File, + owner: PathBuf, +} + +impl ControlLock { + /// Wait up to `wait` for the lock. `action` is recorded for whoever waits next ("start-all", ...). + pub fn acquire(root: &Path, action: &str, wait: Duration, progress: &dyn Fn(&str)) -> Result<ControlLock> { + let state = dir(root); + std::fs::create_dir_all(&state)?; + let mut file = OpenOptions::new().read(true).append(true).create(true).open(state.join("control.lock"))?; + if file.seek(SeekFrom::End(0))? == 0 { + file.write_all(b"0")?; + file.flush()?; + } + let owner = state.join("control-owner.json"); + let deadline = Instant::now() + wait; + let mut announced = false; + loop { + if sys::try_lock(&file)? { + break; + } + let detail = match fsx::read_json::<serde_json::Value>(&owner) { + Ok(v) if v.get("pid").is_some() && v.get("action").is_some() => { + format!(" PID {}, action {}.", v["pid"], v["action"].as_str().unwrap_or("")) + } + _ => " Owner information is unavailable.".into(), + }; + if Instant::now() >= deadline { + return Err(Error::Service(crate::error::ErrorCode::OperationInProgress, format!("Another start/stop action is in progress.{detail}"))); + } + if !announced { + progress(&format!("Waiting for the current server action.{detail}")); + announced = true; + } + std::thread::sleep(Duration::from_millis(250)); + } + let started = std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .map(|d| d.as_secs_f64()) + .unwrap_or(0.0); + let lock = ControlLock { file, owner }; + write_json( + &lock.owner, + &serde_json::json!({ "pid": std::process::id(), "action": action, "started": started }), + )?; + Ok(lock) + } +} + +/// Byte 0 of a file locked while held (`msvcrt.locking`), for example the bug-report relay's `relay.lock`. +pub struct FileLock { + file: File, +} + +impl FileLock { + /// Take the lock, or `None` when another process (or handle) holds it. + pub fn try_acquire(path: &Path) -> Result<Option<FileLock>> { + let mut file = OpenOptions::new().read(true).append(true).create(true).open(path)?; + if file.seek(SeekFrom::End(0))? == 0 { + file.write_all(b"0")?; + file.flush()?; + } + Ok(sys::try_lock(&file)?.then_some(FileLock { file })) + } +} + +impl Drop for FileLock { + fn drop(&mut self) { + sys::unlock(&self.file); + } +} + +impl Drop for ControlLock { + fn drop(&mut self) { + let _ = std::fs::remove_file(&self.owner); + sys::unlock(&self.file); + } +} + +#[cfg(windows)] +mod sys { + use std::fs::File; + use std::os::windows::io::AsRawHandle; + use windows_sys::Win32::Storage::FileSystem::{LockFile, UnlockFile}; + + /// `LockFile` on byte 0, length 1: the call `msvcrt.locking` makes. Non-blocking. + pub fn try_lock(file: &File) -> std::io::Result<bool> { + let ok = unsafe { LockFile(file.as_raw_handle() as _, 0, 0, 1, 0) }; + if ok != 0 { + return Ok(true); + } + let err = std::io::Error::last_os_error(); + // ERROR_LOCK_VIOLATION (33): someone else holds it. + if err.raw_os_error() == Some(33) { + Ok(false) + } else { + Err(err) + } + } + + pub fn unlock(file: &File) { + unsafe { + UnlockFile(file.as_raw_handle() as _, 0, 0, 1, 0); + } + } +} + +#[cfg(not(windows))] +mod sys { + use std::fs::File; + pub fn try_lock(_: &File) -> std::io::Result<bool> { + Ok(true) + } + pub fn unlock(_: &File) {} +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn a_damaged_record_is_no_process() { + let d = tempfile::tempdir().unwrap(); + std::fs::create_dir_all(dir(d.path())).unwrap(); + std::fs::write(dir(d.path()).join("mysql.json"), [0u8; 116]).unwrap(); + assert!(running(d.path(), "mysql").is_none()); + std::fs::write(dir(d.path()).join("auth.json"), b"").unwrap(); + assert!(running(d.path(), "auth").is_none()); + } + + #[test] + fn this_process_is_recorded_and_found_running() { + let d = tempfile::tempdir().unwrap(); + let me = record(d.path(), "probe", std::process::id()).unwrap(); + assert_eq!(running(d.path(), "probe"), Some(me)); + let text = std::fs::read_to_string(dir(d.path()).join("probe.json")).unwrap(); + assert!(text.starts_with("{\n \"pid\": ") && text.ends_with("}\n"), "{text}"); + } + + #[test] + fn one_action_at_a_time() { + let d = tempfile::tempdir().unwrap(); + let first = ControlLock::acquire(d.path(), "start-all", Duration::from_secs(1), &|_| {}).unwrap(); + let owner: serde_json::Value = fsx::read_json(&dir(d.path()).join("control-owner.json")).unwrap(); + assert_eq!(owner["action"], "start-all"); + let said = std::sync::Mutex::new(Vec::new()); + let second = ControlLock::acquire(d.path(), "stop-all", Duration::from_millis(600), &|m| said.lock().unwrap().push(m.to_string())); + if cfg!(windows) { + let err = second.err().expect("the second action waits and gives up").to_string(); + assert!(err.contains("Another start/stop action is in progress") && err.contains("start-all"), "{err}"); + assert_eq!(said.lock().unwrap().len(), 1); + } + drop(first); + assert!(!dir(d.path()).join("control-owner.json").exists()); + ControlLock::acquire(d.path(), "stop-all", Duration::from_secs(1), &|_| {}).unwrap(); + } +} diff --git a/crates/coa-core/src/launcher/world.rs b/crates/coa-core/src/launcher/world.rs new file mode 100644 index 0000000..5d495aa --- /dev/null +++ b/crates/coa-core/src/launcher/world.rs @@ -0,0 +1,300 @@ +//! The world server and the bug-report relay beside it (`manage.py start_world`, `watch_world`, `wait_relay`), +//! and the detailed-logging switch (`debug_logs`). +//! +//! A world is started through a supervisor process that outlives the caller: it starts `worldserver.exe`, keeps +//! the relay running while the world runs, and stops the relay when the world ends. The supervisor is +//! `coa-launcher.exe watch-world`, or `manage.py watch-world` on a repack that does not ship it yet (both write +//! the same records). The relay itself is still the Python `BugReport/relay.py`, run through the repack's +//! Python, until it is ported too. + +use std::path::{Path, PathBuf}; +use std::time::{Duration, Instant}; + +use crate::error::{Error, ErrorCode, Result}; +use crate::launcher::services::{self, ensure_free, mysql, spawn, start_mysql, wait_ready, Progress}; +use crate::launcher::spawn::Proc; +use crate::launcher::{settings::Settings, squid, state}; + +fn stop_relay_flag(root: &Path) -> std::path::PathBuf { + state::dir(root).join("stop-relay") +} + +/// The relay is up and has finished starting (it records itself as `relay-ready` once it serves). +pub fn wait_relay(root: &Path) -> Result<()> { + let until = Instant::now() + Duration::from_secs(20); + while Instant::now() < until { + if let (Some(relay), Some(ready)) = (state::running(root, "relay"), state::running(root, "relay-ready")) { + if relay == ready { + return Ok(()); + } + } + std::thread::sleep(Duration::from_millis(250)); + } + Err(Error::Invalid("Bug-report relay is not ready; check BugReport/Logs/relay.log.".into())) +} + +/// The process that runs `watch-world` for a started world. +#[derive(Debug, Clone)] +pub enum Supervisor { + /// `coa-launcher.exe` (this crate's launcher). + Launcher(PathBuf), + /// The repack's Python with `Scripts/manage.py`. + Python { python: PathBuf, script: PathBuf }, +} + +impl Supervisor { + /// The supervisor a repack ships: `Scripts/coa-launcher.exe` when present, otherwise its Python launcher. + pub fn of(root: &Path) -> Result<Supervisor> { + let exe = root.join("Scripts/coa-launcher.exe"); + if exe.is_file() { + return Ok(Supervisor::Launcher(exe)); + } + let python = squid::package_root(root).join("Runtime/python/python.exe"); + let script = root.join("Scripts/manage.py"); + if python.is_file() && script.is_file() { + return Ok(Supervisor::Python { python, script }); + } + Err(Error::Service( + ErrorCode::ServerFilesIncomplete, + "This server has no world supervisor (Scripts/coa-launcher.exe or Scripts/manage.py). Repair its program files.".into(), + )) + } +} + +/// How long a world may take to open both of its listeners, together: slow worlds (many bots, a cold disk) are +/// common, and the limit must not depend on the bot module. +const WORLD_STARTUP_SECONDS: u64 = 1500; + +/// Wait until the world's console answers a command (it can listen before it accepts logins). +fn wait_console(root: &Path, cfg: &Settings, until: Instant) -> Result<()> { + let mut last = String::new(); + while Instant::now() < until { + if state::running(root, "world").is_none() { + return Err(Error::Service( + ErrorCode::StartupFailed, + "World startup failed: worldserver stopped before its console accepted commands.".into(), + )); + } + match crate::ra::Ra::connect_to(cfg.ra_port, &cfg.ra_username, &cfg.ra_password).and_then(|mut ra| ra.run("server info")) { + Ok(_) => return Ok(()), + Err(e) => last = e.to_string(), + } + std::thread::sleep(Duration::from_millis(500)); + } + Err(Error::Service(ErrorCode::StartupFailed, format!("World startup failed: its console is still starting. {last}"))) +} + +fn seconds_until(until: Instant) -> u64 { + until.saturating_duration_since(Instant::now()).as_secs() +} + +/// Start the world (and its database, unless it is shared), and wait until its console accepts commands. +pub fn start_world(root: &Path, cfg: &Settings, offset: i32, supervisor: &Supervisor, progress: Progress) -> Result<()> { + start_mysql(root, cfg, progress)?; + squid::validate_bots(root)?; + let until = Instant::now() + Duration::from_secs(squid::startup_timeout(root).max(WORLD_STARTUP_SECONDS)); + if state::running(root, "world").is_some() { + if state::running(root, "supervisor").is_none() { + return Err(Error::Service( + ErrorCode::WorldserverAlreadyRunning, + "Worldserver has no repack supervisor. Use Stop_All_Server.bat before restarting it.".into(), + )); + } + wait_ready(root, "world", cfg.world_port, seconds_until(until))?; + wait_relay(root)?; + wait_console(root, cfg, until)?; + progress("Worldserver and bug-report relay are already running."); + return Ok(()); + } + ensure_free(cfg.world_port, progress)?; + ensure_free(cfg.ra_port, progress)?; + if state::running(root, "supervisor").is_some() || state::running(root, "relay").is_some() { + return Err(Error::Service( + ErrorCode::OperationInProgress, + "The previous world/relay shutdown is still finishing. Try again shortly.".into(), + )); + } + squid::prepare_playerbots(root, cfg.mysql_port, &|sql| mysql(root, Some(sql), None), progress)?; + progress("Starting worldserver and its bug-report relay..."); + let _ = std::fs::remove_file(stop_relay_flag(root)); + let offset_text = offset.to_string(); + let root_text = root.to_string_lossy().into_owned(); + let log = root.join("Core/Logs/supervisor.log"); + match supervisor { + Supervisor::Launcher(exe) => { + spawn(root, "supervisor", exe, &["--root", &root_text, "--port-offset", &offset_text, "watch-world"], root, &log, &cfg.env_remove)? + } + Supervisor::Python { python, script } => { + let script = script.to_string_lossy().into_owned(); + spawn(root, "supervisor", python, &["-B", &script, "--port-offset", &offset_text, "watch-world"], root, &log, &cfg.env_remove)? + } + }; + let first = Instant::now() + Duration::from_secs(20); + while state::running(root, "world").is_none() && Instant::now() < first { + if state::running(root, "supervisor").is_none() { + return Err(Error::Service(ErrorCode::StartupFailed, "World startup failed; check Core/Logs/supervisor.log.".into())); + } + std::thread::sleep(Duration::from_millis(250)); + } + wait_ready(root, "world", cfg.world_port, seconds_until(until))?; + wait_ready(root, "world", cfg.ra_port, seconds_until(until))?; + wait_relay(root)?; + wait_console(root, cfg, until)?; + progress("Worldserver and automatic bug reporting are ready."); + Ok(()) +} + +fn spawn_child(root: &Path, name: &str, exe: &Path, args: &[&str], cwd: &Path, log: &Path) -> Result<Proc> { + // The supervisor was started with the environment its services should have. + let child = crate::launcher::spawn::start(exe, args, cwd, log, &[])?; + state::record(root, name, child.pid)?; + Ok(child) +} + +/// The relay worker: `coa-launcher relay-worker` when the supervisor is the launcher (`launcher`), otherwise the +/// repack's Python running `Scripts/manage.py relay-worker` (BugReport/relay.py). +fn spawn_relay(root: &Path, launcher: Option<&Path>) -> Result<Proc> { + let log = root.join("BugReport/Logs/relay.log"); + if let Some(exe) = launcher { + let root_text = root.to_string_lossy().into_owned(); + return spawn_child(root, "relay", exe, &["--root", &root_text, "relay-worker"], root, &log); + } + let python = squid::package_root(root).join("Runtime/python/python.exe"); + let manage = root.join("Scripts/manage.py"); + if !python.is_file() || !manage.is_file() { + return Err(Error::Invalid("The bug-report relay needs the repack's Python and Scripts/manage.py.".into())); + } + let manage = manage.to_string_lossy().into_owned(); + spawn_child(root, "relay", &python, &["-B", &manage, "relay-worker"], root, &root.join("BugReport/Logs/relay.log")) +} + +/// The supervisor (`watch-world`): run the world, keep the relay alive while it runs, stop the relay after it. +/// `launcher` is the launcher executable that runs the relay (`None`: the Python relay). +pub fn watch_world(root: &Path, launcher: Option<&Path>, log: Progress) -> Result<()> { + squid::validate_bots(root)?; + let world = spawn_child(root, "world", &root.join("Core/worldserver.exe"), &["-c", "configs/worldserver.conf"], &root.join("Core"), &root.join("Core/Logs/world-console.log"))?; + let mut relay: Option<Proc> = None; + while world.try_wait().is_none() { + let dead = relay.as_ref().is_none_or(|r| r.try_wait().is_some()); + if dead { + match spawn_relay(root, launcher) { + Ok(r) => relay = Some(r), + Err(e) => { + log(&format!("Report relay could not start ({e}); retrying.")); + std::thread::sleep(Duration::from_secs(5)); + continue; + } + } + } + std::thread::sleep(Duration::from_secs(2)); + } + std::fs::write(stop_relay_flag(root), b"")?; + if let Some(r) = relay { + let until = Instant::now() + Duration::from_secs(40); + while r.try_wait().is_none() && Instant::now() < until { + std::thread::sleep(Duration::from_millis(250)); + } + if r.try_wait().is_none() { + // An interrupted POST stays uncertain in the relay's journal; it is not resent. + if let Some(record) = state::running(root, "relay") { + services::terminate(&record)?; + } + } + } + Ok(()) +} + +// --------------------------------------------------------------------------------------------------------------- +// Detailed logging (Debug_Logs_On.bat / Debug_Logs_Off.bat) +// --------------------------------------------------------------------------------------------------------------- + +const DEBUG_TEMPLATES: [&str; 2] = ["worldserver.conf.template", "authserver.conf.template"]; + +/// One template line with every logger forced to Trace and the console/server appenders to the most detail. +fn debug_line(line: &str) -> String { + let body = line.strip_prefix('#').unwrap_or(line).trim_start(); + for appender in ["Appender.Console", "Appender.Server"] { + if let Some(rest) = body.strip_prefix(appender).and_then(|r| r.strip_prefix('=')) { + let parts: Vec<&str> = rest.splitn(4, ',').collect(); + if parts.len() == 4 && parts[..3].iter().all(|p| !p.is_empty() && p.bytes().all(|b| b.is_ascii_digit())) { + return format!("{appender}={},6,7,{}", parts[0], parts[3]); + } + } + } + if let Some(rest) = body.strip_prefix("Logger.") { + if let Some((name, value)) = rest.split_once('=') { + if !name.is_empty() && name.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'_' || b == b'.') { + if let Some((level, tail)) = value.split_once(',') { + if !level.is_empty() && level.bytes().all(|b| b.is_ascii_digit()) { + return format!("Logger.{name}=6,{tail}"); + } + } + } + } + } + let t = line.trim_end(); + if let Some(v) = t.strip_prefix("Log.Async.Enable") { + let v = v.trim_start(); + if let Some(n) = v.strip_prefix('=') { + let n = n.trim(); + if !n.is_empty() && n.bytes().all(|b| b.is_ascii_digit()) { + return "Log.Async.Enable = 1".into(); + } + } + } + line.to_string() +} + +/// Turn detailed logging on or off (the templates; services apply it at their next start). Returns the changed +/// templates. +pub fn debug_logs(root: &Path, enable: bool) -> Result<Vec<String>> { + let mut changed = Vec::new(); + for name in DEBUG_TEMPLATES { + let path = root.join("Settings").join(name); + let original = root.join("Settings").join(format!("{name}.original")); + if !original.exists() { + std::fs::write(&original, std::fs::read(&path)?)?; + } + let new_bytes = if enable { + let text = String::from_utf8(std::fs::read(&original)?).map_err(|_| Error::Invalid(format!("{name} is not UTF-8.")))?; + let newline = if text.contains("\r\n") { "\r\n" } else { "\n" }; + let mut out = text.lines().map(debug_line).collect::<Vec<_>>().join(newline); + if text.ends_with('\n') { + out.push_str(newline); + } + out.into_bytes() + } else { + std::fs::read(&original)? + }; + if std::fs::read(&path)? != new_bytes { + std::fs::write(&path, &new_bytes)?; + changed.push(name.to_string()); + } + } + state::write_json(&state::dir(root).join("debug-logs.json"), &serde_json::json!({ "enabled": enable }))?; + Ok(changed) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn detailed_logging_rewrites_loggers_and_restores_the_original() { + let d = tempfile::tempdir().unwrap(); + std::fs::create_dir_all(d.path().join("Settings")).unwrap(); + let world = "Appender.Console=1,3,0\r\nAppender.Server=2,2,0,Server.log,w\r\n#Logger.module=4,Console Server\r\nLogger.root=5,Console Server\r\nLog.Async.Enable = 0\r\nOther = 1\r\n"; + std::fs::write(d.path().join("Settings/worldserver.conf.template"), world).unwrap(); + std::fs::write(d.path().join("Settings/authserver.conf.template"), "Logger.root=2,Console\n").unwrap(); + let changed = debug_logs(d.path(), true).unwrap(); + assert_eq!(changed.len(), 2); + assert_eq!( + std::fs::read_to_string(d.path().join("Settings/worldserver.conf.template")).unwrap(), + "Appender.Console=1,3,0\r\nAppender.Server=2,6,7,Server.log,w\r\nLogger.module=6,Console Server\r\nLogger.root=6,Console Server\r\nLog.Async.Enable = 1\r\nOther = 1\r\n" + ); + assert_eq!(debug_logs(d.path(), true).unwrap().len(), 0, "already on"); + debug_logs(d.path(), false).unwrap(); + assert_eq!(std::fs::read_to_string(d.path().join("Settings/worldserver.conf.template")).unwrap(), world); + assert_eq!(services::status(d.path())["debugLogs"], false); + } +} diff --git a/crates/coa-core/src/launcher_bridge.py b/crates/coa-core/src/launcher_bridge.py deleted file mode 100644 index 3c003a1..0000000 --- a/crates/coa-core/src/launcher_bridge.py +++ /dev/null @@ -1,85 +0,0 @@ -import runpy -import sys -import time -from pathlib import Path - -script = sys.argv[1] -sys.path.insert(0, str(Path(script).resolve().parent)) -sys.argv = sys.argv[1:] -launcher = runpy.run_path(script, run_name="coa_manager_launcher") -original_wait = launcher["wait_ready"] -world_deadline = None - - -def wait_ready(name, port, seconds=180): - global world_deadline - if name == "mysql": - seconds = max(seconds, 300) - elif name == "world": - # Both game and console listeners belong to one startup, including on old repacks. - # Ordinary CoA worlds can load slowly too; this must not depend on SQUID. - if world_deadline is None: - world_deadline = time.monotonic() + max(seconds, 1500) - seconds = max(0, world_deadline - time.monotonic()) - return original_wait(name, port, seconds) - - -launcher["start_mysql"].__globals__["wait_ready"] = wait_ready -if sys.argv[1] in ("stop-all", "force-stop-all"): - shutdown = launcher["stop_all"].__globals__ - class UnsafeShutdown(Exception): - pass - - def stop_owned_world(world): - expected = Path(script).resolve().parents[1] / "Core" / "worldserver.exe" - if Path(world.get("exe", "")) != expected or not shutdown["same_process"](world): - raise UnsafeShutdown("World process ownership could not be verified; the database was left running.") - try: - shutdown["terminate"](world) - except (OSError, RuntimeError) as error: - raise UnsafeShutdown("Worldserver could not be stopped safely; its database was left running.") from error - if not shutdown["wait_stopped"](world, 90): - raise UnsafeShutdown("Worldserver is still stopping; its database was left running.") - - if "ra" in shutdown: - original_ra = shutdown["ra"] - - def shutdown_command(command, config): - try: - return original_ra(command, config) - except (OSError, RuntimeError): - if not command.startswith("server shutdown "): - raise - world = shutdown["process"]("world") - if not world: - return "Worldserver has already stopped." - stop_owned_world(world) - return "Stopped this server's recorded world process without its unavailable console." - - shutdown["ra"] = shutdown_command - config = launcher["settings"]() - with launcher["control_lock"](): - if sys.argv[1] == "force-stop-all": - world = shutdown["process"]("world") - if world: - stop_owned_world(world) - print("Force-stopped this server's verified world process; unsaved progress may be lost.", flush=True) - launcher["stop_all"](config) -else: - launcher["main"]() - if sys.argv[1] in ("start-all", "start-world"): - config = launcher["settings"]() - deadline = world_deadline if world_deadline is not None else time.monotonic() + 1500 - last_error = None - while time.monotonic() < deadline: - if not launcher["process"]("world"): - raise RuntimeError("World startup failed: worldserver stopped before its console accepted commands.") - try: - launcher["ra"]("server info", config) - print("World console is accepting commands.", flush=True) - break - except (OSError, RuntimeError) as error: - last_error = error - time.sleep(0.5) - else: - raise RuntimeError(f"World startup failed: its console is still starting. {last_error}") diff --git a/crates/coa-core/src/legacy_launcher.rs b/crates/coa-core/src/legacy_launcher.rs new file mode 100644 index 0000000..b649040 --- /dev/null +++ b/crates/coa-core/src/legacy_launcher.rs @@ -0,0 +1,222 @@ +//! `Scripts/manage.py` as Managers up to 0.9.10 edited it. +//! +//! Those Managers ran the repack's Python launcher themselves and changed its text: an import fix for their bridge +//! and a realm-profile patch (database and realm row of the active realm). This Manager starts servers with +//! [`crate::launcher`] and never edits the file; it only has to recognise those edits, so that an update or a file +//! check treats a file one of them changed as unmodified. Nothing here writes a file. + +use crate::error::{Error, Result}; + +const LAUNCHER_REALM_REPLACEMENTS: &[(&str, &str)] = &[ + ("(\"WorldDatabaseInfo\", \"acore_world\")", "(\"WorldDatabaseInfo\", \"acore_world_wildcard\" if coa_realm() == 'wildcard' else \"acore_world\")"), + ("(\"CharacterDatabaseInfo\", \"acore_characters\")", "(\"CharacterDatabaseInfo\", \"acore_characters_wildcard\" if coa_realm() == 'wildcard' else \"acore_characters\")"), + ("SET name='AzerothCore',address=", "SET name='{coa_realm_name()}',address="), + ("WHERE id=1;", "WHERE id={coa_realm_id()};"), + ("mysql(\"UPDATE acore_auth.realmlist SET flag=0", "mysql(f\"UPDATE acore_auth.realmlist SET flag=0"), +]; + +const LAUNCHER_REALM_INSERT: &str = "# coa-manager-realm-profiles-v1\ndef coa_realm():\n path = ROOT / 'Settings/realm-profile.json'\n return json.loads(path.read_text(encoding='utf-8')).get('active', 'coa') if path.exists() else 'coa'\n\ndef coa_realm_id():\n return 2 if coa_realm() == 'wildcard' else 1\n\ndef coa_realm_name():\n return 'Wildcard' if coa_realm() == 'wildcard' else 'Conquest of Azeroth'\n\n"; + +fn launcher_insert() -> String { + LAUNCHER_REALM_INSERT + .replace("profiles-v1", "profiles-v2") + .replace( + "return 2 if", + "return 3 if coa_realm() == 'reborn' else 2 if", + ) + .replace( + "return 'Wildcard' if", + "return 'Warcraft Reborn' if coa_realm() == 'reborn' else 'Wildcard' if", + ) +} + +fn launcher_replacements() -> Vec<(&'static str, String)> { + LAUNCHER_REALM_REPLACEMENTS.iter().map(|(from, to)| (*from, to + .replace("\"acore_world_wildcard\" if", "\"acore_world_reborn\" if coa_realm() == 'reborn' else \"acore_world_wildcard\" if") + .replace("\"acore_characters_wildcard\" if", "\"acore_characters_reborn\" if coa_realm() == 'reborn' else \"acore_characters_wildcard\" if"))).collect() +} + +/// The realm-profile patch older Managers wrote. +pub(crate) fn patch_launcher(source: &str) -> Result<String> { + if source.contains("# coa-manager-realm-profiles-v2") { + return Ok(source.into()); + } + if source.contains("# coa-manager-realm-profiles-v1") { + let original = unpatch_launcher(source) + .ok_or_else(|| Error::Invalid("Unrecognised realm launcher patch.".into()))?; + return patch_launcher(&original); + } + let mut out = source.to_string(); + for (from, to) in launcher_replacements() { + if !out.contains(from) { + return Err(Error::Invalid( + "This launcher does not support realm profiles. Update the server package first." + .into(), + )); + } + out = out.replace(from, &to); + } + // Insert before the entry point so ROOT, json and functions are all defined when called. + let marker = "if __name__ == \"__main__\":"; + if !out.contains(marker) { + return Err(Error::Invalid( + "Unrecognised server launcher entry point.".into(), + )); + } + Ok(out.replace(marker, &format!("{}{marker}", launcher_insert()))) +} + +/// Reverse only our exact realm transformation; callers must verify the recovered original hash. +pub(crate) fn unpatch_launcher(source: &str) -> Option<String> { + let (insert, replacements) = if source.contains(&launcher_insert()) { + (launcher_insert(), launcher_replacements()) + } else if source.contains(LAUNCHER_REALM_INSERT) { + ( + LAUNCHER_REALM_INSERT.into(), + LAUNCHER_REALM_REPLACEMENTS + .iter() + .map(|(a, b)| (*a, b.to_string())) + .collect(), + ) + } else { + return None; + }; + let mut original = source.replacen(&insert, "", 1); + for (from, to) in &replacements { + original = original.replace(to, from); + } + let mut check = original.clone(); + for (from, to) in &replacements { + check = check.replace(from, to); + } + check = check.replace( + "if __name__ == \"__main__\":", + &format!("{insert}if __name__ == \"__main__\":"), + ); + (check == source).then_some(original) +} + +/// The import fix older Managers wrote (needed to run manage.py through their bridge). +pub(crate) fn patch_launcher_imports(text: &str) -> Result<String> { + let line = "sys.path.insert(0, str(Path(__file__).resolve().parent))"; + if !text.contains("from squid_playerbots import") || text.contains(line) { + return Ok(text.into()); + } + let root = "ROOT = Path(__file__).resolve().parents[1]"; + if !text.contains(root) || !text.lines().any(|line| line.trim() == "import sys") { + return Err(Error::Invalid( + "The server launcher cannot load its integration scripts. Repair its program files." + .into(), + )); + } + Ok(text.replacen(root, &format!("{root}\n{line}"), 1)) +} + +pub(crate) fn launcher_matches(signed: &str, actual: &[u8]) -> bool { + if signed.as_bytes() == actual { + return true; + } + if patch_launcher_imports(signed).is_ok_and(|s| s.as_bytes() == actual) { + return true; + } + patch_launcher(signed).is_ok_and(|s| { + s.as_bytes() == actual || patch_launcher_imports(&s).is_ok_and(|p| p.as_bytes() == actual) + }) +} + +/// Recover legacy metadata only when undoing supported Manager edits reproduces the recorded hash. +pub(crate) fn launcher_matches_recorded(recorded: &str, actual: &[u8]) -> bool { + let Ok(text) = std::str::from_utf8(actual) else { + return false; + }; + let without_import = text.replacen( + "ROOT = Path(__file__).resolve().parents[1]\nsys.path.insert(0, str(Path(__file__).resolve().parent))", + "ROOT = Path(__file__).resolve().parents[1]", 1, + ); + for candidate in [ + Some(without_import.clone()), + unpatch_launcher(&without_import), + ] + .into_iter() + .flatten() + { + if crate::fsx::sha256_bytes(candidate.as_bytes()).eq_ignore_ascii_case(recorded) + && launcher_matches(&candidate, actual) + { + return true; + } + } + false +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::fsx; + use std::collections::BTreeMap; + use std::fs; + + #[test] + fn old_launcher_upgrades_and_both_patch_versions_are_reversible() { + let original = "(\"WorldDatabaseInfo\", \"acore_world\")\n(\"CharacterDatabaseInfo\", \"acore_characters\")\nSET name='AzerothCore',address=\nWHERE id=1;\nmysql(\"UPDATE acore_auth.realmlist SET flag=0\nif __name__ == \"__main__\":\n"; + let mut old = original.to_string(); + for (from, to) in LAUNCHER_REALM_REPLACEMENTS { + old = old.replace(from, to); + } + old = old.replace( + "if __name__ == \"__main__\":", + &format!("{LAUNCHER_REALM_INSERT}if __name__ == \"__main__\":"), + ); + assert_eq!(unpatch_launcher(&old).as_deref(), Some(original)); + let new = patch_launcher(&old).unwrap(); + assert!(new.contains("acore_world_reborn")); + assert!(new.contains("return 3 if coa_realm() == 'reborn'")); + assert!(new.contains("return 'Warcraft Reborn' if")); + assert_eq!(patch_launcher(&new).unwrap(), new); + assert_eq!(unpatch_launcher(&new).as_deref(), Some(original)); + } + + #[test] + fn unknown_launcher_is_refused_without_partial_patching() { + assert!(patch_launcher("print('custom launcher')").is_err()); + } + + #[test] + fn launcher_import_fix_is_idempotent_and_retains_other_code() { + let text = "import sys\nROOT = Path(__file__).resolve().parents[1]\nfrom squid_playerbots import validate_bots\ncustom = 42\n"; + let fixed = patch_launcher_imports(text).unwrap(); + assert!(fixed.contains("sys.path.insert(0, str(Path(__file__).resolve().parent))")); + assert!(fixed.ends_with("custom = 42\n")); + assert_eq!(patch_launcher_imports(&fixed).unwrap(), fixed); + } + + #[test] + fn a_launcher_patched_by_an_older_manager_stays_pristine_but_external_edits_conflict() { + let d = tempfile::tempdir().unwrap(); + let root = d.path().join("server"); + let source = "(\"WorldDatabaseInfo\", \"acore_world\")\n(\"CharacterDatabaseInfo\", \"acore_characters\")\nSET name='AzerothCore',address=\nWHERE id=1;\nmysql(\"UPDATE acore_auth.realmlist SET flag=0\nif __name__ == \"__main__\":\n"; + fsx::atomic_write(&root.join("Scripts/manage.py"), source.as_bytes()).unwrap(); + // What an older Manager left: the realm patch applied and its hash recorded as the pristine one. + let patched = patch_launcher(source).unwrap(); + fsx::atomic_write(&root.join("Scripts/manage.py"), patched.as_bytes()).unwrap(); + let mut meta = crate::registry::InstallMeta::new(crate::registry::InstallKind::New, &root); + meta.original_hashes.insert("Scripts/manage.py".into(), fsx::sha256_bytes(patched.as_bytes())); + crate::registry::MetaDir::create(&root, &meta).unwrap(); + assert!(crate::diag::verify_managed(&root, &meta).is_empty()); + let manifest: crate::manifest::Manifest = serde_json::from_value(serde_json::json!({ + "schema": 1, "kind": "update", "version": "2.0.0", "core": {"commit": null}, "builtAt": "fixture", "minManagerVersion": "0.1.0", + "files": [{"path":"Scripts/manage.py","sha256":fsx::sha256_bytes(b"next release"),"size":12,"owner":"core","policy":"replace"}] + })).unwrap(); + assert_eq!( + crate::update::plan(&root, &meta, &manifest, &BTreeMap::new(), None).unwrap()[0].action, + crate::update::Action::Replace + ); + let mut modified = fs::read(root.join("Scripts/manage.py")).unwrap(); + modified.extend_from_slice(b"# custom edit\n"); + fsx::atomic_write(&root.join("Scripts/manage.py"), &modified).unwrap(); + assert_eq!( + crate::update::plan(&root, &meta, &manifest, &BTreeMap::new(), None).unwrap()[0].action, + crate::update::Action::Conflict + ); + } +} diff --git a/crates/coa-core/src/lib.rs b/crates/coa-core/src/lib.rs index 8918c16..b401084 100644 --- a/crates/coa-core/src/lib.rs +++ b/crates/coa-core/src/lib.rs @@ -28,6 +28,7 @@ pub mod diag; pub mod docker; pub mod download; pub mod driver; +pub mod legacy_launcher; pub mod error; pub mod firewall; pub mod friends; @@ -36,6 +37,7 @@ pub mod glue_config; pub mod health; pub mod install; pub mod layout; +pub mod launcher; pub mod logging; pub mod server_logging; pub mod manifest; diff --git a/crates/coa-core/src/multiworld.rs b/crates/coa-core/src/multiworld.rs index 5634a36..96df9bb 100644 --- a/crates/coa-core/src/multiworld.rs +++ b/crates/coa-core/src/multiworld.rs @@ -176,7 +176,6 @@ fn set_tree(main: &Path, tree: Tree, enabled: bool) -> Result<realms::View> { } } } - secondary_launcher(&fs::read_to_string(main.join("Scripts/manage.py"))?)?; } let status = process::observe(main, &crate::layout::read_ports(main)); if status.world.state != ServiceState::Stopped @@ -349,25 +348,18 @@ fn prepare(main: &Path, tree: Tree) -> Result<PathBuf> { ..Default::default() }, )?; - let source = fs::read_to_string(main.join("Scripts/manage.py"))?; - let source = secondary_launcher(&source)?; - fsx::atomic_write(&second.join("Scripts/manage.py"), source.as_bytes())?; - Ok(second) -} - -fn secondary_launcher(source: &str) -> Result<String> { - let marker = "def start_world(config, offset):\n start_mysql(config)"; - let source = source.replace("\r\n", "\n"); - if !source.contains(marker) { - return Err(Error::Invalid( - "The launcher does not support a shared database world. Update the server first." - .into(), - )); + // The world supervisor and the bug-report relay of the extra world (the launcher itself runs in the Manager + // and knows that this world shares the main database). + for script in ["Scripts/coa-launcher.exe", "Scripts/manage.py"] { + let target = second.join(script); + if main.join(script).is_file() { + fs::create_dir_all(second.join("Scripts"))?; + fsx::atomic_write(&target, &fs::read(main.join(script))?)?; + } else if target.exists() { + fs::remove_file(&target)?; + } } - Ok(source.replace( - marker, - "def start_world(config, offset):\n mysql(admin=\"ping\")", - )) + Ok(second) } fn start_tree(main: &Path, tree: Tree) -> Result<()> { @@ -408,7 +400,7 @@ pub fn start(main: &Path) -> Result<()> { fn stop_tree(main: &Path, tree: Tree) -> Result<()> { let second = tree_root(main, tree); - if !second.join("Scripts/manage.py").exists() { + if !second.join("Settings/repack.json").exists() { if tree_running(main, tree) { return Err(Error::Invalid(format!( "The running {}'s launcher is missing. The shared database was left running.", @@ -505,12 +497,4 @@ mod tests { assert!(err.contains(expected), "{err}"); assert!(!realms::state(t.path()).unwrap().with_reborn); } - - #[test] - fn secondary_never_starts_the_shared_database() { - let patched = secondary_launcher("def start_world(config, offset):\r\n start_mysql(config)\r\n wait_ready('world', 8086)\r\n").unwrap(); - assert!(patched.contains("mysql(admin=\"ping\")")); - assert!(!patched.contains("start_mysql(config)")); - assert!(secondary_launcher("def start_world(): pass").is_err()); - } } diff --git a/crates/coa-core/src/ra.rs b/crates/coa-core/src/ra.rs index 2523c04..cad0bcd 100644 --- a/crates/coa-core/src/ra.rs +++ b/crates/coa-core/src/ra.rs @@ -88,6 +88,29 @@ impl Ra { self.command(c) } + /// Send a command whose answer does not matter (`server shutdown`). The reply is still read (up to the next + /// prompt, the end of the connection, or a few seconds): closing a socket that holds unread data resets the + /// connection, and the server can then drop the command it has not processed yet. + pub fn send_without_answer(mut self, cmd: &str) -> Result<()> { + let c = crate::console::check_command(cmd)?; + self.stream.write_all(format!("{c}\r\n").as_bytes())?; + self.stream.flush()?; + self.stream.set_read_timeout(Some(Duration::from_secs(10)))?; + let mut seen = Vec::new(); + let mut buf = [0u8; 4096]; + while let Ok(n) = self.stream.read(&mut buf) { + if n == 0 { + break; + } + seen.extend_from_slice(&buf[..n]); + if seen.ends_with(b"AC>") || seen.len() > 1 << 20 { + break; + } + } + let _ = self.stream.shutdown(std::net::Shutdown::Both); + Ok(()) + } + fn command(&mut self, cmd: &str) -> Result<String> { debug_assert!(!cmd.contains(['\r', '\n'])); self.stream.write_all(format!("{cmd}\r\n").as_bytes())?; diff --git a/crates/coa-core/src/realms.rs b/crates/coa-core/src/realms.rs index 32b4fb8..ba5bfb1 100644 --- a/crates/coa-core/src/realms.rs +++ b/crates/coa-core/src/realms.rs @@ -534,8 +534,6 @@ pub fn ensure_created(root: &Path, mode: Mode) -> Result<()> { "Update the server to a build with Warcraft Reborn support first.".into(), )); } - // Verify launcher support before creating databases, as selecting a realm does. - prepare_launcher(root)?; let before = configs(root)?; create_realm(root, &mut s, mode, &before) } @@ -565,8 +563,6 @@ pub fn select(root: &Path, mode: Mode) -> Result<View> { "Disable the realms that start together before switching realms.".into(), )); } - // Verify launcher support before creating databases or changing the selected realm. - prepare_launcher(root)?; let before = configs(root)?; fsx::atomic_write_json(&snapshot(root, s.active), &before)?; create_realm(root, &mut s, mode, &before)?; @@ -608,125 +604,6 @@ pub fn select(root: &Path, mode: Mode) -> Result<View> { view(root) } -/// Adapt the bundled launcher's canonical schema and realm choices without changing its supervision logic. -pub fn prepare_launcher(root: &Path) -> Result<()> { - // A Docker server has no launcher to adapt: the Docker backend reads the active realm itself. - if crate::docker::is_docker(root) { - return Ok(()); - } - let path = root.join("Scripts/manage.py"); - let source = fs::read_to_string(&path)?; - let patched = patch_launcher(&source)?; - if patched != source { - fsx::atomic_write(&path, patched.as_bytes())?; - // A Manager-owned transformation is still pristine for subsequent updates and file checks. - if let Ok(dir) = crate::registry::metadata_dir_for(root) { - if let Ok((_, mut meta)) = crate::registry::MetaDir::open(&dir) { - if meta - .original_hashes - .get("Scripts/manage.py") - .is_some_and(|hash| hash == &fsx::sha256_bytes(source.as_bytes())) - { - meta.original_hashes.insert( - "Scripts/manage.py".into(), - fsx::sha256_bytes(patched.as_bytes()), - ); - fsx::atomic_write_json(&dir.join("install.json"), &meta)?; - } - } - } - } - Ok(()) -} - -const LAUNCHER_REALM_REPLACEMENTS: &[(&str, &str)] = &[ - ("(\"WorldDatabaseInfo\", \"acore_world\")", "(\"WorldDatabaseInfo\", \"acore_world_wildcard\" if coa_realm() == 'wildcard' else \"acore_world\")"), - ("(\"CharacterDatabaseInfo\", \"acore_characters\")", "(\"CharacterDatabaseInfo\", \"acore_characters_wildcard\" if coa_realm() == 'wildcard' else \"acore_characters\")"), - ("SET name='AzerothCore',address=", "SET name='{coa_realm_name()}',address="), - ("WHERE id=1;", "WHERE id={coa_realm_id()};"), - ("mysql(\"UPDATE acore_auth.realmlist SET flag=0", "mysql(f\"UPDATE acore_auth.realmlist SET flag=0"), -]; - -const LAUNCHER_REALM_INSERT: &str = "# coa-manager-realm-profiles-v1\ndef coa_realm():\n path = ROOT / 'Settings/realm-profile.json'\n return json.loads(path.read_text(encoding='utf-8')).get('active', 'coa') if path.exists() else 'coa'\n\ndef coa_realm_id():\n return 2 if coa_realm() == 'wildcard' else 1\n\ndef coa_realm_name():\n return 'Wildcard' if coa_realm() == 'wildcard' else 'Conquest of Azeroth'\n\n"; - -fn launcher_insert() -> String { - LAUNCHER_REALM_INSERT - .replace("profiles-v1", "profiles-v2") - .replace( - "return 2 if", - "return 3 if coa_realm() == 'reborn' else 2 if", - ) - .replace( - "return 'Wildcard' if", - "return 'Warcraft Reborn' if coa_realm() == 'reborn' else 'Wildcard' if", - ) -} - -fn launcher_replacements() -> Vec<(&'static str, String)> { - LAUNCHER_REALM_REPLACEMENTS.iter().map(|(from, to)| (*from, to - .replace("\"acore_world_wildcard\" if", "\"acore_world_reborn\" if coa_realm() == 'reborn' else \"acore_world_wildcard\" if") - .replace("\"acore_characters_wildcard\" if", "\"acore_characters_reborn\" if coa_realm() == 'reborn' else \"acore_characters_wildcard\" if"))).collect() -} - -pub(crate) fn patch_launcher(source: &str) -> Result<String> { - if source.contains("# coa-manager-realm-profiles-v2") { - return Ok(source.into()); - } - if source.contains("# coa-manager-realm-profiles-v1") { - let original = unpatch_launcher(source) - .ok_or_else(|| Error::Invalid("Unrecognised realm launcher patch.".into()))?; - return patch_launcher(&original); - } - let mut out = source.to_string(); - for (from, to) in launcher_replacements() { - if !out.contains(from) { - return Err(Error::Invalid( - "This launcher does not support realm profiles. Update the server package first." - .into(), - )); - } - out = out.replace(from, &to); - } - // Insert before the entry point so ROOT, json and functions are all defined when called. - let marker = "if __name__ == \"__main__\":"; - if !out.contains(marker) { - return Err(Error::Invalid( - "Unrecognised server launcher entry point.".into(), - )); - } - Ok(out.replace(marker, &format!("{}{marker}", launcher_insert()))) -} - -/// Reverse only our exact realm transformation; callers must verify the recovered original hash. -pub(crate) fn unpatch_launcher(source: &str) -> Option<String> { - let (insert, replacements) = if source.contains(&launcher_insert()) { - (launcher_insert(), launcher_replacements()) - } else if source.contains(LAUNCHER_REALM_INSERT) { - ( - LAUNCHER_REALM_INSERT.into(), - LAUNCHER_REALM_REPLACEMENTS - .iter() - .map(|(a, b)| (*a, b.to_string())) - .collect(), - ) - } else { - return None; - }; - let mut original = source.replacen(&insert, "", 1); - for (from, to) in &replacements { - original = original.replace(to, from); - } - let mut check = original.clone(); - for (from, to) in &replacements { - check = check.replace(from, to); - } - check = check.replace( - "if __name__ == \"__main__\":", - &format!("{insert}if __name__ == \"__main__\":"), - ); - (check == source).then_some(original) -} - /// The character-creation model the world server advertises for a realm. Every realm has its own database and its own /// entry on Overview, so it advertises exactly one model: a list such as `"coa wcr"` would let players create /// Warcraft Reborn characters in the Conquest of Azeroth realm. @@ -770,7 +647,6 @@ pub fn before_start(root: &Path) -> Result<()> { if !root.join(STATE).exists() { return Ok(()); } - prepare_launcher(root)?; if s.simultaneous && !view(root)?.supported { return Err(Error::Invalid( "The installed server build does not support simultaneous Wildcard startup.".into(), @@ -1107,26 +983,6 @@ CoA.GameModeMask = 0 assert!(!v.supported); } - #[test] - fn old_launcher_upgrades_and_both_patch_versions_are_reversible() { - let original = "(\"WorldDatabaseInfo\", \"acore_world\")\n(\"CharacterDatabaseInfo\", \"acore_characters\")\nSET name='AzerothCore',address=\nWHERE id=1;\nmysql(\"UPDATE acore_auth.realmlist SET flag=0\nif __name__ == \"__main__\":\n"; - let mut old = original.to_string(); - for (from, to) in LAUNCHER_REALM_REPLACEMENTS { - old = old.replace(from, to); - } - old = old.replace( - "if __name__ == \"__main__\":", - &format!("{LAUNCHER_REALM_INSERT}if __name__ == \"__main__\":"), - ); - assert_eq!(unpatch_launcher(&old).as_deref(), Some(original)); - let new = patch_launcher(&old).unwrap(); - assert!(new.contains("acore_world_reborn")); - assert!(new.contains("return 3 if coa_realm() == 'reborn'")); - assert!(new.contains("return 'Warcraft Reborn' if")); - assert_eq!(patch_launcher(&new).unwrap(), new); - assert_eq!(unpatch_launcher(&new).as_deref(), Some(original)); - } - #[test] fn a_docker_server_is_checked_for_wildcard_support_in_its_own_binary() { let d = tempfile::tempdir().unwrap(); @@ -1157,20 +1013,6 @@ CoA.GameModeMask = 0 assert!(view(d.path()).unwrap().supported); } - #[test] - fn a_docker_server_has_no_launcher_to_adapt() { - let d = tempfile::tempdir().unwrap(); - fs::create_dir_all(d.path().join("Settings")).unwrap(); - // No Scripts/manage.py anywhere: on a repack this fails, on a Docker server there is nothing to do. - assert!(prepare_launcher(d.path()).is_err()); - fs::write( - d.path().join("Settings/docker.json"), - br#"{"project":"t1"}"#, - ) - .unwrap(); - prepare_launcher(d.path()).unwrap(); - } - #[test] fn fresh_wildcard_disables_bots_and_preserves_scaling() { let mut f = Files::new(); @@ -1270,42 +1112,4 @@ CoA.GameModeMask = 0 .is_err()); assert!(guard_module(t.path(), "content-scaling").is_ok()); } - - #[test] - fn unknown_launcher_is_refused_without_partial_patching() { - assert!(patch_launcher("print('custom launcher')").is_err()); - } - - #[test] - fn managed_launcher_patch_remains_pristine_but_external_edits_conflict() { - let d = tempfile::tempdir().unwrap(); - let root = d.path().join("server"); - let source = "(\"WorldDatabaseInfo\", \"acore_world\")\n(\"CharacterDatabaseInfo\", \"acore_characters\")\nSET name='AzerothCore',address=\nWHERE id=1;\nmysql(\"UPDATE acore_auth.realmlist SET flag=0\nif __name__ == \"__main__\":\n"; - fsx::atomic_write(&root.join("Scripts/manage.py"), source.as_bytes()).unwrap(); - let mut meta = crate::registry::InstallMeta::new(crate::registry::InstallKind::New, &root); - meta.original_hashes.insert( - "Scripts/manage.py".into(), - fsx::sha256_bytes(source.as_bytes()), - ); - let dir = crate::registry::MetaDir::create(&root, &meta).unwrap(); - prepare_launcher(&root).unwrap(); - let (_, meta) = crate::registry::MetaDir::open(&dir.root).unwrap(); - assert!(crate::diag::verify_managed(&root, &meta).is_empty()); - let manifest: crate::manifest::Manifest = serde_json::from_value(serde_json::json!({ - "schema": 1, "kind": "update", "version": "2.0.0", "core": {"commit": null}, "builtAt": "fixture", "minManagerVersion": "0.1.0", - "files": [{"path":"Scripts/manage.py","sha256":fsx::sha256_bytes(b"next release"),"size":12,"owner":"core","policy":"replace"}] - })).unwrap(); - assert_eq!( - crate::update::plan(&root, &meta, &manifest, &BTreeMap::new(), None).unwrap()[0].action, - crate::update::Action::Replace - ); - let mut modified = fs::read(root.join("Scripts/manage.py")).unwrap(); - modified.extend_from_slice(b"# custom edit\n"); - fsx::atomic_write(&root.join("Scripts/manage.py"), &modified).unwrap(); - prepare_launcher(&root).unwrap(); - assert_eq!( - crate::update::plan(&root, &meta, &manifest, &BTreeMap::new(), None).unwrap()[0].action, - crate::update::Action::Conflict - ); - } } diff --git a/crates/coa-core/src/update.rs b/crates/coa-core/src/update.rs index a23b8cc..b13da2d 100644 --- a/crates/coa-core/src/update.rs +++ b/crates/coa-core/src/update.rs @@ -403,7 +403,7 @@ pub fn plan( match (fs::read_to_string(tree.join(&f.path)), fs::read(&target)) { (Ok(signed), Ok(actual)) => { fsx::sha256_bytes(signed.as_bytes()) == f.sha256 - && crate::driver::launcher_matches(&signed, &actual) + && crate::legacy_launcher::launcher_matches(&signed, &actual) } _ => false, } @@ -418,7 +418,7 @@ pub fn plan( let manager_launcher = f.path == "Scripts/manage.py" && recorded.is_some_and(|hash| { fs::read(&target).is_ok_and(|bytes| { - crate::driver::launcher_matches_recorded(hash, &bytes) + crate::legacy_launcher::launcher_matches_recorded(hash, &bytes) }) }); if f.path == "Core/worldserver.exe" @@ -614,7 +614,7 @@ fn launcher_already_integrated( if meta.original_hashes.get(&file.path) != Some(&fsx::sha256_bytes(&actual)) { return Ok(false); } - Ok(crate::driver::launcher_matches_recorded( + Ok(crate::legacy_launcher::launcher_matches_recorded( &file.sha256, &actual, )) @@ -968,7 +968,7 @@ fn finish( fs::read_to_string(tree.join(&op.path)), fs::read(root.join(&op.path)), ) { - (Ok(signed), Ok(actual)) if crate::driver::launcher_matches(&signed, &actual) => { + (Ok(signed), Ok(actual)) if crate::legacy_launcher::launcher_matches(&signed, &actual) => { fsx::sha256_bytes(&actual) } _ => op.new_sha256.clone(), @@ -1060,7 +1060,7 @@ pub fn retry_validation( && fs::read_to_string(dir.join("tree").join(&op.path)) .ok() .filter(|s| fsx::sha256_bytes(s.as_bytes()) == file.sha256) - .is_some_and(|s| crate::driver::launcher_matches(&s, &bytes)); + .is_some_and(|s| crate::legacy_launcher::launcher_matches(&s, &bytes)); if actual != file.sha256 && !launcher { return Err(Error::Invalid(format!( "{} changed since the update was applied; use repair or rollback.", @@ -2347,9 +2347,9 @@ mod tests { fn legacy_launcher_world(import_patch: bool) -> World { let w = world(&[("Scripts/manage.py", b"new release launcher")], false); - let mut source = crate::realms::patch_launcher(LEGACY_LAUNCHER).unwrap(); + let mut source = crate::legacy_launcher::patch_launcher(LEGACY_LAUNCHER).unwrap(); if import_patch { - source = crate::driver::patch_launcher_imports(&source).unwrap(); + source = crate::legacy_launcher::patch_launcher_imports(&source).unwrap(); } write(&w.root, "Scripts/manage.py", source.as_bytes()); let (_, mut meta) = MetaDir::open(&w.meta).unwrap(); @@ -2576,7 +2576,7 @@ mod tests { let w = world(&[("Scripts/manage.py", source)], false); run(&w, &Fake::ok(), BTreeMap::new(), None).unwrap(); let integrated = - crate::driver::patch_launcher_imports(std::str::from_utf8(source).unwrap()).unwrap(); + crate::legacy_launcher::patch_launcher_imports(std::str::from_utf8(source).unwrap()).unwrap(); write(&w.root, "Scripts/manage.py", integrated.as_bytes()); let (_, mut meta) = MetaDir::open(&w.meta).unwrap(); meta.original_hashes.insert( diff --git a/crates/coa-launcher/Cargo.toml b/crates/coa-launcher/Cargo.toml new file mode 100644 index 0000000..b4263cf --- /dev/null +++ b/crates/coa-launcher/Cargo.toml @@ -0,0 +1,15 @@ +[package] +name = "coa-launcher" +description = "The CoA repack launcher (Start_All_Server.bat and friends) without Python" +version.workspace = true +edition.workspace = true +license.workspace = true + +[[bin]] +name = "coa-launcher" +path = "src/main.rs" + +[dependencies] +coa-core = { path = "../coa-core" } +serde_json = "1" +windows-sys = { version = "0.60", features = ["Win32_Foundation", "Win32_System_Console"] } diff --git a/crates/coa-launcher/src/main.rs b/crates/coa-launcher/src/main.rs new file mode 100644 index 0000000..4c606cd --- /dev/null +++ b/crates/coa-launcher/src/main.rs @@ -0,0 +1,222 @@ +//! `coa-launcher.exe`: the repack launcher, the same commands as `Scripts/manage.py`. +//! +//! It lives in `<server>/Scripts/` next to manage.py (the server folder is its parent), or takes `--root <folder>`. +//! Errors are printed as `ERROR: <message>` on stderr with exit code 1, exactly like manage.py, because the +//! Manager reads them. + +use std::io::{BufRead, Write}; +use std::path::{Path, PathBuf}; +use std::time::Duration; + +use coa_core::launcher::ops::{self, Action}; +use coa_core::launcher::{services, settings::Settings, state, world}; + +const ACTIONS: [&str; 18] = [ + "start-all", "start-mysql", "start-auth", "start-world", "stop-all", "force-stop-all", "status", "status-json", "create-account", + "create-account-once", "console", "ra-once", "prepare", "watch-world", "relay-worker", "debug-logs-on", + "debug-logs-off", "debug-logs-status", +]; + +fn say(text: &str) { + println!("{text}"); + let _ = std::io::stdout().flush(); +} + +fn usage() -> String { + format!("usage: coa-launcher [--root <server>] [--port-offset N] {{{}}}", ACTIONS.join(",")) +} + +struct Args { + root: PathBuf, + offset: i32, + action: String, +} + +fn parse() -> Result<Args, String> { + let mut root: Option<PathBuf> = None; + let mut offset = 0; + let mut action = None; + let mut it = std::env::args().skip(1); + while let Some(a) = it.next() { + match a.as_str() { + "--root" => root = Some(PathBuf::from(it.next().ok_or_else(usage)?)), + "--port-offset" => offset = it.next().and_then(|v| v.parse().ok()).ok_or_else(usage)?, + _ if ACTIONS.contains(&a.as_str()) && action.is_none() => action = Some(a), + _ => return Err(usage()), + } + } + let root = match root { + Some(r) => r, + None => { + // <server>/Scripts/coa-launcher.exe -> <server> + let exe = std::env::current_exe().map_err(|e| e.to_string())?; + exe.parent().and_then(Path::parent).map(Path::to_path_buf).ok_or("cannot find the server folder")? + } + }; + Ok(Args { root, offset, action: action.ok_or_else(usage)? }) +} + +fn read_line(prompt: &str) -> std::io::Result<String> { + print!("{prompt}"); + std::io::stdout().flush()?; + let mut line = String::new(); + std::io::stdin().lock().read_line(&mut line)?; + Ok(line.trim_end_matches(['\r', '\n']).to_string()) +} + +/// Read a line without showing it (passwords). +fn read_secret(prompt: &str) -> std::io::Result<String> { + #[cfg(windows)] + unsafe { + use windows_sys::Win32::System::Console::{GetConsoleMode, GetStdHandle, SetConsoleMode, ENABLE_ECHO_INPUT, STD_INPUT_HANDLE}; + let h = GetStdHandle(STD_INPUT_HANDLE); + let mut mode = 0; + if GetConsoleMode(h, &mut mode) != 0 { + SetConsoleMode(h, mode & !ENABLE_ECHO_INPUT); + let line = read_line(prompt); + SetConsoleMode(h, mode); + println!(); + return line; + } + } + read_line(prompt) +} + +fn valid_login(text: &str) -> bool { + (1..=16).contains(&text.len()) && text.bytes().all(|b| b.is_ascii_alphanumeric()) +} + +fn ra(cfg: &Settings, root: &Path, command: &str) -> Result<String, String> { + if !services::ready(root, "world", cfg.ra_port) { + return Err("Start this repack's worldserver first.".into()); + } + let mut console = coa_core::ra::Ra::connect_to(cfg.ra_port, &cfg.ra_username, &cfg.ra_password).map_err(|e| e.to_string())?; + console.run(command).map_err(|e| e.to_string()) +} + +fn run(args: Args) -> Result<(), String> { + let root = args.root.as_path(); + let e = |x: coa_core::Error| x.to_string(); + match args.action.as_str() { + "watch-world" => { + let me = std::env::current_exe().map_err(|x| x.to_string())?; + return world::watch_world(root, Some(&me), &|m| say(m)).map_err(e); + } + "relay-worker" => return coa_core::launcher::relay::worker(root).map_err(e), + "debug-logs-status" => { + let on = services::status(root)["debugLogs"].as_bool().unwrap_or(false); + say(&format!("Detailed server logging is {}.", if on { "ON" } else { "off" })); + if on { + say("Every AzerothCore logger is forced to Trace level in Core/Logs (Server.log, Auth.log, world-console.log, auth-console.log). Expect much larger, faster-growing log files."); + } + say("Run Debug_Logs_On.bat / Debug_Logs_Off.bat, then restart the affected service(s) to apply."); + return Ok(()); + } + "debug-logs-on" | "debug-logs-off" => { + let on = args.action == "debug-logs-on"; + let changed = { + let _lock = state::ControlLock::acquire(root, &args.action, Duration::from_secs(30), &|m| say(m)).map_err(e)?; + world::debug_logs(root, on).map_err(e)? + }; + if changed.is_empty() { + say(&format!("Detailed logging was already {}.", if on { "on" } else { "off" })); + } else { + say(&format!("{} detailed logging in: {}", if on { "Enabled" } else { "Restored" }, changed.join(", "))); + } + say("Restart the affected service(s) (Stop_All_Server.bat then Start_All_Server.bat) to apply this."); + return Ok(()); + } + _ => {} + } + let cfg = Settings::load(root, args.offset).map_err(e)?; + match args.action.as_str() { + "console" => { + say("World console. Enter a server command, or exit to close this window."); + loop { + let command = read_line("AC> ").map_err(|x| x.to_string())?; + let command = command.trim(); + if command.eq_ignore_ascii_case("exit") || command.eq_ignore_ascii_case("quit") { + return Ok(()); + } + if !command.is_empty() { + say(&ra(&cfg, root, command)?); + } + } + } + "create-account" => { + let name = read_line("New account name (letters and digits, up to 16): ").map_err(|x| x.to_string())?; + let name = name.trim(); + let password = read_secret("New account password (letters and digits, up to 16): ").map_err(|x| x.to_string())?; + let again = read_secret("Repeat password: ").map_err(|x| x.to_string())?; + if !valid_login(name) || !valid_login(&password) { + return Err("Use 1-16 letters or digits for the account name and password.".into()); + } + if password != again { + return Err("Passwords do not match.".into()); + } + say(&ra(&cfg, root, &format!("account create {name} {password}"))?); + if read_line("Give this account GM permissions? [y/N]: ").map_err(|x| x.to_string())?.trim().eq_ignore_ascii_case("y") { + say(&ra(&cfg, root, &format!("account set gmlevel {name} 3 -1"))?); + } + return Ok(()); + } + "ra-once" => { + let command = read_line("").map_err(|x| x.to_string())?; + let command = command.trim(); + if command.is_empty() { + return Err("No command given.".into()); + } + say(&ra(&cfg, root, command)?); + return Ok(()); + } + "create-account-once" => { + let line = read_line("").map_err(|x| x.to_string())?; + let request: serde_json::Value = serde_json::from_str(&line).map_err(|x| x.to_string())?; + let name = request.get("username").and_then(|v| v.as_str()).unwrap_or("").trim().to_string(); + let password = request.get("password").and_then(|v| v.as_str()).unwrap_or("").to_string(); + if !valid_login(&name) || !valid_login(&password) { + return Err("Use 1-16 letters or digits for the account name and password.".into()); + } + let mut messages = vec![ra(&cfg, root, &format!("account create {name} {password}"))?]; + if request.get("gm").and_then(|v| v.as_bool()).unwrap_or(false) { + messages.push(ra(&cfg, root, &format!("account set gmlevel {name} 3 -1"))?); + } + say(&serde_json::json!({ "messages": messages }).to_string()); + return Ok(()); + } + _ => {} + } + match args.action.as_str() { + "status" | "status-json" => { + let _lock = state::ControlLock::acquire(root, &args.action, Duration::from_secs(30), &|m| say(m)).map_err(e)?; + if args.action == "status-json" { + say(&services::status(root).to_string()); + } else { + for name in ["mysql", "auth", "world", "relay"] { + let line = match state::running(root, name) { + Some(r) => format!("{name:12} running (PID {})", r.pid), + None => format!("{name:12} stopped"), + }; + say(&line); + } + } + return Ok(()); + } + _ => {} + } + let action = Action::parse(&args.action).ok_or_else(usage)?; + let me = world::Supervisor::Launcher(std::env::current_exe().map_err(|x| x.to_string())?); + ops::run(root, &cfg, args.offset, action, Some(&me), &|m| say(m)).map_err(e)?; + if args.action.starts_with("start-") { + say("Use Stop_All_Server.bat to shut down this repack safely."); + } + Ok(()) +} + +fn main() { + let result = parse().and_then(run); + if let Err(message) = result { + eprintln!("ERROR: {message}"); + std::process::exit(1); + } +} diff --git a/tools/test_launcher_bridge.py b/tools/test_launcher_bridge.py deleted file mode 100644 index 94c1637..0000000 --- a/tools/test_launcher_bridge.py +++ /dev/null @@ -1,223 +0,0 @@ -import pathlib -import runpy -import sys -import tempfile -import unittest -import time -from unittest.mock import patch - -BRIDGE = pathlib.Path(__file__).resolve().parents[1] / 'crates/coa-core/src/launcher_bridge.py' - - -class LauncherBridgeTests(unittest.TestCase): - def launch(self, action, body): - with tempfile.TemporaryDirectory() as directory: - script = pathlib.Path(directory) / 'Scripts/manage.py' - script.parent.mkdir() - script.write_text(body, encoding='utf8') - original = runpy.run_path - def capture(*args, **kwargs): - self.launcher = original(*args, **kwargs) - return self.launcher - with patch.object(sys, 'argv', ['bridge', str(script), action]), patch.object(runpy, 'run_path', side_effect=capture): - return original(str(BRIDGE)) - - def shutdown_fixture(self, *, console_error='RuntimeError', stopped=True, foreign=False, same=True, modern=False, terminate_error=False): - return f''' -from pathlib import Path -from contextlib import nullcontext -calls = [] -world = {{'pid': 123, 'created': 456, 'exe': str(Path(__file__).resolve().parents[1] / {'"foreign.exe"' if foreign else '"Core/worldserver.exe"'})}} -def wait_ready(*args): pass -def start_mysql(): raise AssertionError('must not start') -def main(): raise AssertionError('must not prepare') -def settings(): return {{}} -def control_lock(): return nullcontext() -def process(name): return world if name == 'world' else None -def same_process(record): return {same!r} -def ra(command, config): - calls.append('console') - {'raise '+console_error+'("Start this repack worldserver first")' if console_error else 'return "Graceful shutdown"'} -def terminate(record): - assert record is world - calls.append('terminate') - {'raise RuntimeError("identity changed")' if terminate_error else 'pass'} -def wait_stopped(record, seconds): - assert record is world - calls.append('wait') - return {stopped!r} -def stop_all(config): - record = process('world') - if record: - if {modern!r}: - try: ra('server shutdown 1s 0', config) - except (OSError, RuntimeError): terminate(record) - else: - ra('server shutdown 1s 0', config) - if not wait_stopped(record, 60): raise RuntimeError('world still alive') - calls.append('mysql-shutdown') -''' - - def test_unavailable_console_in_restored_legacy_launcher_stops_owned_world_before_mysql(self): - for error in ['RuntimeError', 'OSError']: - with self.subTest(error=error): - result = self.launch('stop-all', self.shutdown_fixture(console_error=error)) - self.assertEqual(result['launcher']['calls'], ['console', 'terminate', 'wait', 'wait', 'mysql-shutdown']) - - def test_force_stop_terminates_only_the_owned_world_before_mysql(self): - body = self.shutdown_fixture(console_error=None) - body = body.replace("return world if name == 'world' else None", "return world if name == 'world' and 'terminate' not in calls else None") - result = self.launch('force-stop-all', body) - self.assertEqual(result['launcher']['calls'], ['terminate', 'wait', 'mysql-shutdown']) - - def test_force_stop_rejects_foreign_or_reused_pids_and_a_world_that_stays_alive(self): - for options, message in [({'foreign': True}, 'ownership could not be verified'), - ({'same': False}, 'ownership could not be verified'), - ({'stopped': False}, 'database was left running')]: - with self.subTest(options=options): - with self.assertRaisesRegex(Exception, message): - self.launch('force-stop-all', self.shutdown_fixture(**options)) - self.assertNotIn('mysql-shutdown', self.launcher['calls']) - - def test_healthy_console_keeps_graceful_shutdown(self): - result = self.launch('stop-all', self.shutdown_fixture(console_error=None)) - self.assertEqual(result['launcher']['calls'], ['console', 'wait', 'mysql-shutdown']) - - def test_foreign_or_reused_process_is_never_terminated_even_by_a_modern_launcher_catch(self): - for modern in [False, True]: - for identity in [{'foreign': True}, {'same': False}]: - with self.subTest(modern=modern, **identity): - with self.assertRaisesRegex(Exception, 'ownership could not be verified'): - self.launch('stop-all', self.shutdown_fixture(modern=modern, **identity)) - self.assertEqual(self.launcher['calls'], ['console']) - - def test_world_that_stays_alive_blocks_database_shutdown(self): - for modern in [False, True]: - with self.subTest(modern=modern): - with self.assertRaisesRegex(Exception, 'database was left running'): - self.launch('stop-all', self.shutdown_fixture(stopped=False, modern=modern)) - self.assertEqual(self.launcher['calls'], ['console', 'terminate', 'wait']) - - def test_termination_identity_failure_leaves_mysql_untouched(self): - for modern in [False, True]: - with self.subTest(modern=modern): - with self.assertRaisesRegex(Exception, 'could not be stopped safely'): - self.launch('stop-all', self.shutdown_fixture(terminate_error=True, modern=modern)) - self.assertEqual(self.launcher['calls'], ['console', 'terminate']) - - def test_slow_mysql_gets_time_to_finish_but_other_waits_are_unchanged(self): - result = self.launch('start-mysql', ''' -calls = [] -def wait_ready(name, port, seconds=180): - calls.append((name, seconds)) - if name == 'mysql' and seconds < 162: - raise RuntimeError('mysql is still starting') -def start_mysql(): - wait_ready('mysql', 12345, 60) -def main(): - start_mysql() - wait_ready('world', 23456, 180) - wait_ready('mysql', 12345, 900) -''') - calls = result['launcher']['calls'] - self.assertEqual(calls[0], ('mysql', 300)) - self.assertEqual(calls[2], ('mysql', 900)) - self.assertEqual(calls[1][0], 'world') - self.assertAlmostEqual(calls[1][1], 1500, delta=1) - - def world_start(self, *, game_at=420, console_at=480, dies_at=None, requested=180): - clock = [0.0] - def sleep(seconds): clock[0] += seconds - body = f''' -import time -calls = [] -dies_at = {dies_at!r} -def wait_ready(name, port, seconds=180): - until = time.monotonic() + seconds - while time.monotonic() < until: - if dies_at is not None and time.monotonic() >= dies_at: - raise RuntimeError('world stopped during startup') - if time.monotonic() >= ({game_at!r} if port == 1 else {console_at!r}): - calls.append(port) - return - time.sleep(0.5) - raise RuntimeError('world is still starting') -def start_mysql(): pass -def settings(): return {{}} -def process(name): return {{'pid': 1}} -def ra(command, config): return 'server info ready' -def main(): - wait_ready('world', 1, {requested}) - wait_ready('world', 2, {requested}) -''' - with patch('time.monotonic', side_effect=lambda: clock[0]), patch('time.sleep', side_effect=sleep): - result = self.launch('start-all', body) - return clock[0], result['launcher']['calls'] - - def test_open_ports_do_not_finish_startup_until_commands_are_processed(self): - clock = [0.0] - def sleep(seconds): clock[0] += seconds - body = """ -import time -calls=[] -def wait_ready(*args): pass -def start_mysql(): pass -def settings(): return {} -def process(name): return {'pid': 1} -def ra(command, config): - calls.append(command) - if time.monotonic() < 5: raise TimeoutError('main loop is loading') - return 'ready' -def main(): - wait_ready('world',1) - wait_ready('world',2) -""" - with patch('time.monotonic', side_effect=lambda: clock[0]), patch('time.sleep', side_effect=sleep): - result=self.launch('start-all',body) - self.assertEqual(clock[0],5) - self.assertEqual(set(result['launcher']['calls']),{'server info'}) - - def test_world_death_after_ports_open_is_a_startup_failure(self): - body=""" -def wait_ready(*args): pass -def start_mysql(): pass -def settings(): return {} -def process(name): return None -def main(): pass -""" - with self.assertRaisesRegex(RuntimeError,'stopped before its console accepted'): - self.launch('start-world',body) - - def test_legacy_coa_world_waits_for_both_ports_after_three_minutes(self): - elapsed, calls = self.world_start() - self.assertEqual((elapsed, calls), (480, [1, 2])) - - def test_console_wait_shares_the_world_deadline(self): - with self.assertRaisesRegex(RuntimeError, 'still starting'): - self.world_start(game_at=1490, console_at=1510) - self.assertEqual(self.launcher['calls'], [1]) - - def test_world_exit_is_reported_without_waiting_out_the_extended_budget(self): - with self.assertRaisesRegex(RuntimeError, 'stopped during startup'): - self.world_start(dies_at=12) - self.assertEqual(self.launcher['calls'], []) - - def test_existing_longer_world_timeout_is_preserved(self): - self.assertEqual(self.world_start(game_at=1600, console_at=1700, requested=1800), (1700, [1, 2])) - - def test_stop_dispatch_does_not_prepare_or_start_anything(self): - result = self.launch('stop-all', ''' -from contextlib import nullcontext -calls = [] -def wait_ready(*args): raise AssertionError('must not wait') -def start_mysql(): raise AssertionError('must not start') -def main(): raise AssertionError('must not prepare') -def settings(): return {'mysqlPort': 12345} -def control_lock(): return nullcontext() -def stop_all(config): calls.append(config['mysqlPort']) -''') - self.assertEqual(result['launcher']['calls'], [12345]) - - -if __name__ == '__main__': - unittest.main()