diff --git a/.github/workflows/sign-local-installer.yml b/.github/workflows/sign-local-installer.yml new file mode 100644 index 0000000..9abba53 --- /dev/null +++ b/.github/workflows/sign-local-installer.yml @@ -0,0 +1,72 @@ +name: sign-local-installer +on: + push: + branches: [release/20261108-manager] + workflow_dispatch: + inputs: + build_run_id: + description: Successful manager-local run in coa-server-build + required: true +permissions: + contents: read + actions: read +jobs: + sign: + if: github.event_name == 'workflow_dispatch' + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v7 + - uses: actions/setup-node@v4 + with: + node-version: 22 + - name: Verify local build provenance + env: + GH_TOKEN: ${{ github.token }} + BUILD_RUN: ${{ inputs.build_run_id }} + run: | + python3 - <<'PY' + import json, os, subprocess + run = os.environ['BUILD_RUN'] + if not run.isdigit(): + raise RuntimeError('Invalid build run') + data = json.loads(subprocess.check_output(['gh', 'api', f'repos/Corfirean/coa-server-build/actions/runs/{run}'])) + if data['conclusion'] != 'success' or data['path'] != '.github/workflows/manager-local.yml': + raise RuntimeError('Not a successful local Manager build') + subprocess.run(['gh', 'run', 'download', run, '-R', 'Corfirean/coa-server-build', '-n', 'unsigned-manager-windows', '-D', '_prepared-manager'], check=True) + from pathlib import Path + import hashlib + root = Path('_prepared-manager') + meta = json.loads((root / 'prepared-source.json').read_text()) + version = json.loads(Path('package.json').read_text())['version'] + name = meta['installer'] + if Path(name).name != name or meta['source'] != os.environ['GITHUB_SHA'] or meta['version'] != version or str(meta['run']) != run: + raise RuntimeError('Installer identity differs') + if hashlib.sha256((root / name).read_bytes()).hexdigest() != meta['sha256']: + raise RuntimeError('Installer hash differs') + PY + - run: npm ci + - name: Sign exact locally compiled bytes + env: + TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY }} + TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY_PASSWORD }} + run: | + node --input-type=module <<'JS' + import { readFileSync, writeFileSync } from 'node:fs'; + import { execFileSync } from 'node:child_process'; + import { createHash } from 'node:crypto'; + const root = '_prepared-manager/'; + const meta = JSON.parse(readFileSync(root + 'prepared-source.json')); + execFileSync('node_modules/.bin/tauri', ['signer', 'sign', '--app-version', meta.version, root + meta.installer], {stdio: 'inherit'}); + if (createHash('sha256').update(readFileSync(root + meta.installer)).digest('hex') !== meta.sha256) throw new Error('Signed bytes changed'); + const signature = readFileSync(root + meta.installer + '.sig', 'utf8').trim(); + const url = `https://github.com/Corfirean/coa-server-manager/releases/download/v${meta.version}/${encodeURIComponent(meta.installer)}`; + writeFileSync(root + 'latest.json', JSON.stringify({version: meta.version, notes: 'See the release notes.', pub_date: new Date().toISOString(), platforms: {'windows-x86_64': {signature, url}}}, null, 2) + '\n'); + meta.signingRun = process.env.GITHUB_RUN_ID; + writeFileSync(root + 'prepared-source.json', JSON.stringify(meta, null, 2) + '\n'); + JS + - uses: actions/upload-artifact@v4 + with: + name: prepared-manager-windows + path: _prepared-manager/* + retention-days: 14 + if-no-files-found: error diff --git a/CHANGELOG.md b/CHANGELOG.md index e1be5ea..30b79a9 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,6 +8,12 @@ Published releases and previews. Pre-release entries do not change the stable up Dates follow GitHub publication (UTC); legacy records retain their archived dates. Newest releases first. +## 0.9.10 — 2026-11-08 + +- Custom Races patch installation recovers from interrupted downloads. + +[Release](https://github.com/Corfirean/coa-server-manager/releases/tag/v0.9.10) · [Source changes](https://github.com/Corfirean/coa-server-manager/compare/v0.9.9...v0.9.10) + ## 0.9.9 — 2026-11-04 - Update and recovery checks use the temporary login port even with a Windows override. diff --git a/Cargo.lock b/Cargo.lock index 8500312..60a1db6 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 be96eef..d7446ad 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/changelog.d/20261031-recover-client-patch-downloads.md b/changelog.d/20261031-recover-client-patch-downloads.md new file mode 100644 index 0000000..1475c82 --- /dev/null +++ b/changelog.d/20261031-recover-client-patch-downloads.md @@ -0,0 +1,7 @@ +--- +area: manager +type: fixed +audience: admins +title: Custom Races patch installation recovers from interrupted downloads +--- +Unfinished downloads resume automatically. Invalid archives in Downloads are skipped without changing them, and damaged cached archives are downloaded again. diff --git a/changelog/history.json b/changelog/history.json index 630df9b..93346be 100644 --- a/changelog/history.json +++ b/changelog/history.json @@ -172,6 +172,7 @@ "Corfirean/coa-server-manager:20261030-window-lifecycle.md", "Corfirean/coa-server-manager:20261031-dungeon-clear-dependency.md", "Corfirean/coa-server-manager:20261031-launcher-diagnostics-export.md", + "Corfirean/coa-server-manager:20261031-recover-client-patch-downloads.md", "Corfirean/coa-server-manager:20261031-server-logging-controls.md", "Corfirean/coa-server-manager:20261031-validation-bot-population.md", "Corfirean/coa-server-manager:20261031-validation-mysql-reuse.md", @@ -900,6 +901,17 @@ ], "commit": "173248efbe24da9b4c1b5ca12fa7580fcd1e8ea7", "compare": "https://github.com/Corfirean/coa-server-manager/compare/v0.9.8...v0.9.9" + }, + { + "tag": "v0.9.10", + "version": "0.9.10", + "date": "2026-11-08", + "url": "https://github.com/Corfirean/coa-server-manager/releases/tag/v0.9.10", + "notes": [ + "Custom Races patch installation recovers from interrupted downloads" + ], + "commit": "711f378ae82f75d3fc64368c042889c773315c54", + "compare": "https://github.com/Corfirean/coa-server-manager/compare/v0.9.9...v0.9.10" } ] } 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/custom_races.rs b/crates/coa-core/src/custom_races.rs index 6b4cb6b..411834f 100644 --- a/crates/coa-core/src/custom_races.rs +++ b/crates/coa-core/src/custom_races.rs @@ -5,7 +5,7 @@ //! into the player's WoW client directory. use std::fs::{self, File}; -use std::io::{self, Read, Write}; +use std::io::{self, Read}; use std::path::{Path, PathBuf}; use serde::{Deserialize, Serialize}; @@ -153,7 +153,10 @@ pub fn sync_bot_races_config(root: &Path, allow_custom_races: bool) -> Result<() let clean = value.trim().trim_matches(['"', '\'']); let owned = String::from_utf8_lossy(&bytes) .contains("CoA Custom: races new random bots never get") - && matches!(clean, EXCLUDED_BOT_RACES_RECOMMENDED | EXCLUDED_BOT_RACES_EXPERIMENTAL); + && matches!( + clean, + EXCLUDED_BOT_RACES_RECOMMENDED | EXCLUDED_BOT_RACES_EXPERIMENTAL + ); if !owned { continue; } @@ -662,134 +665,147 @@ fn stage_root_asset(staging: &Path, relative: &str, reader: &mut impl Read) -> R Ok(relative.to_string()) } -fn verify_archive(path: &Path, filename: &str) -> Result<()> { - let expected = match filename { - "CoA-Custom-1.9.2-Client-1.zip" => { - "a9dd51ed2d90fb048d549602f40f5429d56e2df0df5606a38781b358fa369568" - } - "CoA-Custom-1.9.2-Client-2.zip" => { - "ab084a55509ccbcc2977a06dd0c01fa879973a1892baaacaeb3ff52f3dfc750e" - } - "CoA-Custom-1.9.2-Client-3.zip" => { - "907e267f0ee7038807e626c3c1eca5e12db6c88b747137a23c5fb52eaa1a358e" - } - "CoA-Custom-1.9.2-Client-4.zip" => { - "e0bd87172af989fa50a8e2b08ba4321c72b6265047482f051a1db3b80d55bcaa" - } - "CoA-Custom-1.9.2-Client-5.zip" => { - "73364ad1b58c6342641a848a3b20a835472834f600416606be1470386774ca78" - } +fn archive_job(filename: &str, url: &str, cache: &Path) -> Result { + let (size, sha256) = match filename { + "CoA-Custom-1.9.2-Client-1.zip" => ( + 1_513_021_586, + "a9dd51ed2d90fb048d549602f40f5429d56e2df0df5606a38781b358fa369568", + ), + "CoA-Custom-1.9.2-Client-2.zip" => ( + 1_198_283_005, + "ab084a55509ccbcc2977a06dd0c01fa879973a1892baaacaeb3ff52f3dfc750e", + ), + "CoA-Custom-1.9.2-Client-3.zip" => ( + 1_678_829_573, + "907e267f0ee7038807e626c3c1eca5e12db6c88b747137a23c5fb52eaa1a358e", + ), + "CoA-Custom-1.9.2-Client-4.zip" => ( + 502_385_128, + "e0bd87172af989fa50a8e2b08ba4321c72b6265047482f051a1db3b80d55bcaa", + ), + "CoA-Custom-1.9.2-Client-5.zip" => ( + 168_079_711, + "73364ad1b58c6342641a848a3b20a835472834f600416606be1470386774ca78", + ), _ => return Err(Error::Invalid("Unknown custom races archive.".into())), }; - if fsx::sha256_file(path)? != expected { + Ok(crate::download::Job { + url: url.into(), + dest: cache.join(filename), + sha256: sha256.into(), + size, + }) +} + +fn archive_matches(path: &Path, job: &crate::download::Job) -> bool { + path.metadata() + .is_ok_and(|m| m.is_file() && m.len() == job.size) + && fsx::sha256_file(path).is_ok_and(|hash| hash.eq_ignore_ascii_case(&job.sha256)) +} + +#[cfg(test)] +fn verify_archive(path: &Path, filename: &str) -> Result<()> { + let job = archive_job(filename, "", Path::new(""))?; + if !archive_matches(path, &job) { return Err(Error::Invalid(format!( - "Custom races archive {filename} failed verification. Remove it and try again." + "Custom races archive {filename} failed verification." ))); } Ok(()) } -/// Locate an archive locally in Downloads or cache, or download it from GitHub. +/// User-owned Downloads files are read-only candidates. Only the Manager's cache is repaired. +fn resolve_archive_with( + transport: &dyn crate::download::Transport, + job: &crate::download::Job, + downloads: Option<&Path>, + cancel: &Cancel, + progress: &dyn Fn(crate::download::Progress), +) -> Result { + if cancel.is_set() { + return Err(Error::Invalid("Download cancelled.".into())); + } + if let Some(downloads) = downloads { + let candidate = downloads.join(job.dest.file_name().unwrap_or_default()); + if archive_matches(&candidate, job) { + tracing::info!(path = %candidate.display(), "using verified archive in Downloads"); + progress(crate::download::Progress { + downloaded: job.size, + total: job.size, + bytes_per_sec: 0, + }); + return Ok(candidate); + } + if candidate.exists() { + tracing::warn!(path = %candidate.display(), "ignoring incomplete or unverified archive in Downloads"); + } + } + + let cache = job + .dest + .parent() + .ok_or_else(|| Error::Invalid("Missing archive cache directory.".into()))?; + fs::create_dir_all(cache)?; + // Different installations share this cache; never append to or replace another active download. + use fs4::fs_std::FileExt; + let lock = fs::OpenOptions::new() + .read(true) + .write(true) + .create(true) + .truncate(false) + .open(suffix(&job.dest, "lock"))?; + if !lock.try_lock_exclusive()? { + return Err(Error::Invalid("Another custom races download is using this archive. Wait for it to finish, then retry.".into())); + } + if job.dest.is_file() { + if archive_matches(&job.dest, job) { + progress(crate::download::Progress { + downloaded: job.size, + total: job.size, + bytes_per_sec: 0, + }); + return Ok(job.dest.clone()); + } + tracing::warn!(path = %job.dest.display(), "removing unverified Manager archive cache; downloading again"); + fs::remove_file(&job.dest)?; + } + // The shared downloader resumes .part files and verifies the complete archive before promotion. + // A stale/corrupt prefix may only be detectable after resume: retry once from scratch in that case. + match crate::download::fetch_with(transport, job, cancel, progress) { + Err(Error::HashMismatch { .. }) if !cancel.is_set() => { + tracing::warn!(path = %job.dest.display(), "archive verification failed; retrying a clean download"); + crate::download::fetch_with(transport, job, cancel, progress)?; + } + result => result?, + } + Ok(job.dest.clone()) +} + +/// Locate a verified archive or resume downloading it into the Manager's cache. fn resolve_or_download_archive( filename: &str, url: &str, - client: &reqwest::blocking::Client, + transport: &dyn crate::download::Transport, cancel: &Cancel, report: &dyn Fn(&str, f32), base_percent: f32, percent_slice: f32, ) -> Result { - // 1. Check user Downloads folder - if let Some(userprofile) = std::env::var_os("USERPROFILE") { - let downloads = PathBuf::from(userprofile).join("Downloads"); - let candidate = downloads.join(filename); - if candidate.is_file() { - if let Ok(meta) = candidate.metadata() { - if meta.len() > 1000 { - tracing::info!(path = %candidate.display(), "using existing archive in Downloads"); - verify_archive(&candidate, filename)?; - return Ok(candidate); - } - } - } - } - - // 2. Check temp / cache directory - let cache_dir = std::env::temp_dir().join("coa-client-races"); - fs::create_dir_all(&cache_dir)?; - let target = cache_dir.join(filename); - if target.is_file() { - if let Ok(meta) = target.metadata() { - if meta.len() > 1000 { - verify_archive(&target, filename)?; - return Ok(target); - } - } - } - - // 3. Download from GitHub Releases - report(&format!("Downloading {filename}..."), base_percent); - let part_path = cache_dir.join(format!("{filename}.part")); - - let resp = client - .get(url) - .send() - .map_err(|e| Error::NetworkUnreachable(format!("Could not reach download server: {e}")))?; - - if !resp.status().is_success() { - return Err(Error::NetworkUnreachable(format!( - "Download failed with status {} for {url}", - resp.status() - ))); - } - - let total_bytes = resp.content_length().unwrap_or(0); - let mut downloaded = 0u64; - let mut src = resp; - let mut dst = File::create(&part_path)?; - - let mut buf = [0u8; 64 * 1024]; - let mut last_report = std::time::Instant::now(); - - loop { - if cancel.is_set() { - let _ = fs::remove_file(&part_path); - return Err(Error::Invalid("Operation cancelled.".into())); - } - - let n = src - .read(&mut buf) - .map_err(|e| Error::NetworkUnreachable(format!("Download interrupted: {e}")))?; - if n == 0 { - break; - } - - dst.write_all(&buf[..n])?; - downloaded += n as u64; - - if last_report.elapsed() > std::time::Duration::from_millis(200) { - let ratio = if total_bytes > 0 { - (downloaded as f32 / total_bytes as f32).clamp(0.0, 1.0) - } else { - 0.5 - }; - report( - &format!( - "Downloading {filename} ({:.1} MB)...", - downloaded as f64 / 1_048_576.0 - ), - base_percent + ratio * percent_slice, - ); - last_report = std::time::Instant::now(); - } - } - - dst.flush()?; - drop(dst); - - verify_archive(&part_path, filename)?; - fs::rename(&part_path, &target)?; - Ok(target) + // Report before hashing existing files: otherwise checking a large archive looks like no operation. + report(&format!("Checking {filename}..."), base_percent); + let cache = std::env::temp_dir().join("coa-client-races"); + let downloads = std::env::var_os("USERPROFILE").map(|p| PathBuf::from(p).join("Downloads")); + let job = archive_job(filename, url, &cache)?; + resolve_archive_with(transport, &job, downloads.as_deref(), cancel, &|p| { + let ratio = p.downloaded as f32 / p.total.max(1) as f32; + report( + &format!( + "Downloading {filename} ({:.1} MB)...", + p.downloaded as f64 / 1_048_576.0 + ), + base_percent + ratio.clamp(0.0, 1.0) * percent_slice, + ); + }) } /// Download (if needed) and extract custom races client assets into the target WoW client. @@ -818,11 +834,7 @@ pub fn install_client_patches( fs::create_dir_all(&data_dir)?; // 2. Resolve/download archives (0.05 .. 0.50) - let http = reqwest::blocking::Client::builder() - .user_agent(concat!("CoA-Server-Manager/", env!("CARGO_PKG_VERSION"))) - .timeout(std::time::Duration::from_secs(600)) - .build() - .map_err(|e| Error::Invalid(format!("Cannot prepare downloader: {e}")))?; + let http = crate::download::HttpTransport::with_total_timeout(600)?; let mut resolved_archives = Vec::new(); let n_archives = ARCHIVES.len() as f32; @@ -1113,7 +1125,9 @@ mod tests { serde_json::from_str(include_str!("custom_races_hashes_1_9_1.json")).unwrap(); let files = patch_files(temp.path()).unwrap(); assert_eq!(files.len(), old.len()); - assert!(files.iter().all(|file| old.get(&file.path) == Some(&file.sha256))); + assert!(files + .iter() + .all(|file| old.get(&file.path) == Some(&file.sha256))); assert!(!files.iter().any(|file| file.path.contains("CoAQuestSafe"))); } @@ -1571,11 +1585,179 @@ mod tests { ); } + struct ArchiveTransport { + body: Vec, + ranges: std::sync::Mutex>, + } + + impl crate::download::Transport for ArchiveTransport { + fn get(&self, _: &str, from: u64) -> std::result::Result { + self.ranges.lock().unwrap().push(from); + Ok(crate::download::Reply { + status: if from == 0 { 200 } else { 206 }, + content_range: (from > 0) + .then(|| format!("bytes {from}-{}/{}", self.body.len() - 1, self.body.len())), + body: Box::new(io::Cursor::new(self.body[from as usize..].to_vec())), + }) + } + } + + fn archive_fixture(root: &Path) -> (crate::download::Job, ArchiveTransport) { + use sha2::{Digest, Sha256}; + let body = b"verified archive bytes for recovery tests".to_vec(); + let job = crate::download::Job { + url: "https://example.invalid/patch.zip".into(), + dest: root.join("cache/patch.zip"), + sha256: hex::encode(Sha256::digest(&body)), + size: body.len() as u64, + }; + fs::create_dir_all(job.dest.parent().unwrap()).unwrap(); + ( + job, + ArchiveTransport { + body, + ranges: Default::default(), + }, + ) + } + #[test] - fn corrupt_downloads_are_rejected() { - let temp = tempfile::NamedTempFile::new().unwrap(); - fs::write(temp.path(), b"corrupt archive").unwrap(); - assert!(verify_archive(temp.path(), ARCHIVES[0].0).is_err()); + fn download_uses_verified_user_archive_without_network() { + let temp = tempfile::tempdir().unwrap(); + let (job, transport) = archive_fixture(temp.path()); + let downloads = temp.path().join("Downloads"); + fs::create_dir(&downloads).unwrap(); + let archive = downloads.join("patch.zip"); + fs::write(&archive, &transport.body).unwrap(); + let path = resolve_archive_with( + &transport, + &job, + Some(&downloads), + &Cancel::default(), + &|_| {}, + ) + .unwrap(); + assert_eq!(path, archive); + assert!(transport.ranges.lock().unwrap().is_empty()); + assert!(!job.dest.exists()); + } + + #[test] + fn download_skips_bad_user_archive_and_repairs_bad_cache() { + let temp = tempfile::tempdir().unwrap(); + let (job, transport) = archive_fixture(temp.path()); + let downloads = temp.path().join("Downloads"); + fs::create_dir(&downloads).unwrap(); + let bad = vec![b'x'; transport.body.len()]; + fs::write(downloads.join("patch.zip"), &bad).unwrap(); + fs::write(downloads.join("patch.zip.part"), b"user browser download").unwrap(); + fs::write(&job.dest, &bad).unwrap(); + let path = resolve_archive_with( + &transport, + &job, + Some(&downloads), + &Cancel::default(), + &|_| {}, + ) + .unwrap(); + assert_eq!(path, job.dest); + assert_eq!(fs::read(&path).unwrap(), transport.body); + assert_eq!(fs::read(downloads.join("patch.zip")).unwrap(), bad); + assert_eq!( + fs::read(downloads.join("patch.zip.part")).unwrap(), + b"user browser download" + ); + assert_eq!(*transport.ranges.lock().unwrap(), vec![0]); + } + + #[test] + fn download_resumes_leftover_part_and_verifies_complete_archive() { + let temp = tempfile::tempdir().unwrap(); + let (job, transport) = archive_fixture(temp.path()); + let part = suffix(&job.dest, "part"); + fs::write(&part, &transport.body[..9]).unwrap(); + resolve_archive_with(&transport, &job, None, &Cancel::default(), &|_| {}).unwrap(); + assert_eq!(*transport.ranges.lock().unwrap(), vec![9]); + assert_eq!(fs::read(&job.dest).unwrap(), transport.body); + assert!(!part.exists()); + } + + #[test] + fn download_reuses_good_cache_even_when_user_archive_is_incomplete() { + let temp = tempfile::tempdir().unwrap(); + let (job, transport) = archive_fixture(temp.path()); + let downloads = temp.path().join("Downloads"); + fs::create_dir(&downloads).unwrap(); + fs::write(downloads.join("patch.zip"), b"incomplete").unwrap(); + fs::write(&job.dest, &transport.body).unwrap(); + let path = resolve_archive_with( + &transport, + &job, + Some(&downloads), + &Cancel::default(), + &|_| {}, + ) + .unwrap(); + assert_eq!(path, job.dest); + assert!(transport.ranges.lock().unwrap().is_empty()); + assert_eq!( + fs::read(downloads.join("patch.zip")).unwrap(), + b"incomplete" + ); + } + + #[test] + fn download_restarts_once_when_resumed_prefix_is_corrupt() { + let temp = tempfile::tempdir().unwrap(); + let (job, transport) = archive_fixture(temp.path()); + fs::write(suffix(&job.dest, "part"), b"bad").unwrap(); + resolve_archive_with(&transport, &job, None, &Cancel::default(), &|_| {}).unwrap(); + assert_eq!(*transport.ranges.lock().unwrap(), vec![3, 0]); + assert_eq!(fs::read(&job.dest).unwrap(), transport.body); + } + + #[test] + fn download_promotes_completed_part_without_redownloading() { + let temp = tempfile::tempdir().unwrap(); + let (job, transport) = archive_fixture(temp.path()); + fs::write(suffix(&job.dest, "part"), &transport.body).unwrap(); + resolve_archive_with(&transport, &job, None, &Cancel::default(), &|_| {}).unwrap(); + assert!(transport.ranges.lock().unwrap().is_empty()); + assert_eq!(fs::read(&job.dest).unwrap(), transport.body); + } + + #[test] + fn download_stops_after_one_clean_retry_if_server_bytes_are_invalid() { + let temp = tempfile::tempdir().unwrap(); + let (job, mut transport) = archive_fixture(temp.path()); + transport.body.fill(b'x'); + let result = resolve_archive_with(&transport, &job, None, &Cancel::default(), &|_| {}); + assert!(matches!(result, Err(Error::HashMismatch { .. }))); + assert_eq!(*transport.ranges.lock().unwrap(), vec![0, 0]); + assert!(!job.dest.exists()); + assert!(!suffix(&job.dest, "part").exists()); + } + + #[test] + fn download_does_not_modify_an_archive_owned_by_another_download() { + use fs4::fs_std::FileExt; + let temp = tempfile::tempdir().unwrap(); + let (job, transport) = archive_fixture(temp.path()); + let lock = fs::OpenOptions::new() + .read(true) + .write(true) + .create(true) + .truncate(false) + .open(suffix(&job.dest, "lock")) + .unwrap(); + lock.try_lock_exclusive().unwrap(); + fs::write(suffix(&job.dest, "part"), b"active download").unwrap(); + assert!(resolve_archive_with(&transport, &job, None, &Cancel::default(), &|_| {}).is_err()); + assert_eq!( + fs::read(suffix(&job.dest, "part")).unwrap(), + b"active download" + ); + assert!(transport.ranges.lock().unwrap().is_empty()); } #[test] 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..274b827 --- /dev/null +++ b/crates/coa-core/src/launcher/services.rs @@ -0,0 +1,556 @@ +//! 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)) +} + +/// 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)? { + let asked = ready(root, "world", cfg.ra_port) + .then(|| crate::ra::Ra::connect_to(cfg.ra_port, &cfg.ra_username, &cfg.ra_password)) + .and_then(|r| r.ok()) + .map(|ra| ra.send_without_answer("server shutdown 1s 0")); + match asked { + Some(Ok(())) => progress("Graceful world shutdown requested."), + _ => { + progress("World console unavailable; stopping this repack's recorded world process."); + stop_world_process(&world)?; + } + } + if !wait_stopped(&world, 90) { + 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 80625e8..bd7c679 100644 --- a/crates/coa-core/src/lib.rs +++ b/crates/coa-core/src/lib.rs @@ -32,6 +32,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; @@ -40,6 +41,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 3e45b0a..9cf0c0d 100644 --- a/crates/coa-core/src/update.rs +++ b/crates/coa-core/src/update.rs @@ -408,7 +408,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, } @@ -430,7 +430,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" @@ -626,7 +626,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, )) @@ -988,7 +988,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(), @@ -1080,7 +1080,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.", @@ -2381,9 +2381,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(); @@ -2610,7 +2610,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/src/data/README.md b/src/data/README.md index 143f6a2..c685bbd 100644 --- a/src/data/README.md +++ b/src/data/README.md @@ -36,3 +36,7 @@ Manager 0.9.8 preparation refreshes the bundled server history through 0.261030. The two reviewed upcoming records are in `tools/reviewed-manager-notes.json` and `tools/reviewed-server-notes.json`; every new note has all five translations. These files describe preparation and do not add unpublished releases to canonical history. + +Manager 0.9.10 refreshes the bundled server history through 0.261104.94 from +canonical build commit `a9c6b17c8c1a295680fda4ad4bcdde266357264d` on 2026-11-08. +The reviewed upcoming Manager and server records carry translations in all five languages. diff --git a/src/data/latest-note-translations.json b/src/data/latest-note-translations.json index c300bad..880fa78 100644 --- a/src/data/latest-note-translations.json +++ b/src/data/latest-note-translations.json @@ -37,7 +37,8 @@ "Update validation keeps MySQL running between compatible checks": "При проверке обновления MySQL продолжает работать между совместимыми проверками", "Choose normal logs, errors only or no server logs in maintenance settings": "Выбирайте обычные логи, только ошибки или отключение логов в настройках обслуживания", "Diagnostic exports include launcher stages and lock owner records": "В архив диагностики входят этапы лаунчера и записи о владельцах блокировок", - "Update and recovery checks use the temporary login port even with a Windows override": "Проверка обновления и восстановления использует временный порт входа даже при переопределении в Windows" + "Update and recovery checks use the temporary login port even with a Windows override": "Проверка обновления и восстановления использует временный порт входа даже при переопределении в Windows", + "Custom Races patch installation recovers from interrupted downloads": "Установка патчей дополнительных рас восстанавливается после прерывания загрузки" }, "de": { "Choose Parallel or Global level scaling in module settings": "Parallele oder globale Levelskalierung in den Moduleinstellungen wählen", @@ -76,7 +77,8 @@ "Update validation keeps MySQL running between compatible checks": "Bei der Update-Validierung bleibt MySQL zwischen kompatiblen Prüfungen aktiv", "Choose normal logs, errors only or no server logs in maintenance settings": "In den Wartungseinstellungen normale Protokolle, nur Fehler oder keine Serverprotokolle wählen", "Diagnostic exports include launcher stages and lock owner records": "Diagnoseexporte enthalten Launcher-Schritte und aufgezeichnete Sperrbesitzer", - "Update and recovery checks use the temporary login port even with a Windows override": "Update- und Wiederherstellungsprüfungen verwenden den temporären Anmeldeport auch bei einer Windows-Vorgabe" + "Update and recovery checks use the temporary login port even with a Windows override": "Update- und Wiederherstellungsprüfungen verwenden den temporären Anmeldeport auch bei einer Windows-Vorgabe", + "Custom Races patch installation recovers from interrupted downloads": "Die Installation zusätzlicher Völker setzt unterbrochene Downloads fort" }, "fr": { "Choose Parallel or Global level scaling in module settings": "Choisissez une progression parallèle ou globale des niveaux dans les paramètres du module", @@ -115,7 +117,8 @@ "Update validation keeps MySQL running between compatible checks": "La validation des mises à jour garde MySQL actif entre les vérifications compatibles", "Choose normal logs, errors only or no server logs in maintenance settings": "Choisissez les journaux normaux, les erreurs uniquement ou aucun journal dans les paramètres de maintenance", "Diagnostic exports include launcher stages and lock owner records": "Les exports de diagnostic incluent les étapes de lancement et les propriétaires des verrous", - "Update and recovery checks use the temporary login port even with a Windows override": "Les contrôles de mise à jour et de restauration utilisent le port de connexion temporaire même si Windows en impose un autre" + "Update and recovery checks use the temporary login port even with a Windows override": "Les contrôles de mise à jour et de restauration utilisent le port de connexion temporaire même si Windows en impose un autre", + "Custom Races patch installation recovers from interrupted downloads": "L’installation des races supplémentaires reprend les téléchargements interrompus" }, "es": { "Choose Parallel or Global level scaling in module settings": "Elige escalado de nivel paralelo o global en los ajustes del módulo", @@ -154,7 +157,8 @@ "Update validation keeps MySQL running between compatible checks": "La validación de actualizaciones mantiene MySQL activo entre comprobaciones compatibles", "Choose normal logs, errors only or no server logs in maintenance settings": "Elige registros normales, solo errores o ningún registro en los ajustes de mantenimiento", "Diagnostic exports include launcher stages and lock owner records": "Los archivos de diagnóstico incluyen las etapas del lanzador y los propietarios de bloqueos", - "Update and recovery checks use the temporary login port even with a Windows override": "Las comprobaciones de actualización y recuperación usan el puerto temporal de acceso aunque Windows indique otro" + "Update and recovery checks use the temporary login port even with a Windows override": "Las comprobaciones de actualización y recuperación usan el puerto temporal de acceso aunque Windows indique otro", + "Custom Races patch installation recovers from interrupted downloads": "La instalación de razas adicionales se recupera de descargas interrumpidas" }, "zh": { "Choose Parallel or Global level scaling in module settings": "在模块设置中选择并行或全局等级缩放", @@ -193,7 +197,8 @@ "Update validation keeps MySQL running between compatible checks": "更新验证会在兼容的检查步骤之间保持 MySQL 运行", "Choose normal logs, errors only or no server logs in maintenance settings": "在维护设置中选择普通日志、仅错误或关闭服务器日志", "Diagnostic exports include launcher stages and lock owner records": "诊断导出包含启动器阶段和锁所属进程记录", - "Update and recovery checks use the temporary login port even with a Windows override": "即使 Windows 指定了其他端口,更新和恢复检查也会使用临时登录端口" + "Update and recovery checks use the temporary login port even with a Windows override": "即使 Windows 指定了其他端口,更新和恢复检查也会使用临时登录端口", + "Custom Races patch installation recovers from interrupted downloads": "自定义种族补丁安装可从中断的下载中恢复" } }, "server": { @@ -244,7 +249,17 @@ "Startup and shutdown keep bounded diagnostics of launcher stages": "При запуске и остановке сохраняется ограниченная по объёму диагностика этапов лаунчера", "Database shutdown succeeds when MySQL closes its connection before replying": "Остановка базы завершается успешно, если MySQL закрыл соединение до отправки ответа", "Server startup waits for ports that Windows is still releasing": "При запуске сервер ждёт, пока Windows освободит порт", - "Companions avoid repeating unreachable routes in the open world": "В открытом мире спутники перестают повторять непроходимые маршруты" + "Companions avoid repeating unreachable routes in the open world": "В открытом мире спутники перестают повторять непроходимые маршруты", + "Login server startup works when Windows does not list its listening port": "Сервер входа запускается, даже если Windows не показывает его прослушиваемый порт", + "Updated SQUID's Playerbots to 2.9.4 and refreshed Dungeon Clear": "Обновлены SQUID’s Playerbots до 2.9.4 и Dungeon Clear", + "Electrocutioner is used up by Electrocute and no longer makes it look ready too early": "Electrocute расходует Electrocutioner и больше не выглядит готовым раньше времени", + "The Dungeon Finder boss objective survives a relog": "Цель убийства босса в поиске подземелий сохраняется после повторного входа", + "Vanilla dungeon bosses no longer sleep or mind control tanks and healers": "Боссы классических подземелий больше не усыпляют и не подчиняют танков и лекарей", + "Classic dungeons scale only for Dungeon Finder groups": "Классические подземелья масштабируются только для групп поиска подземелий", + "Darkmaster Gandling raises Risen Students only at 52% health": "Тёмный магистр Гандлинг поднимает восставших студентов только при 52% здоровья", + "Sunken Temple's dragons appear only after the Avatar of Hakkar and Jammal'an": "Драконы Затонувшего храма появляются только после Аватары Хаккара и Джаммал’ана", + "Scaled loot previews survive a map change": "Предпросмотр масштабированной добычи сохраняется при смене карты", + "Updated SQUID Playerbots to 2.9.4": "SQUID Playerbots обновлён до 2.9.4" }, "de": { "Restrict new characters by custom race without changing existing characters": "Neue Charaktere nach zusätzlichem Volk beschränken, ohne bestehende Charaktere zu ändern", @@ -293,7 +308,17 @@ "Startup and shutdown keep bounded diagnostics of launcher stages": "Start und Herunterfahren speichern begrenzte Diagnosedaten der Launcher-Schritte", "Database shutdown succeeds when MySQL closes its connection before replying": "Das Herunterfahren der Datenbank gelingt auch, wenn MySQL die Verbindung vor der Antwort schließt", "Server startup waits for ports that Windows is still releasing": "Beim Start wartet der Server, bis Windows den Port freigibt", - "Companions avoid repeating unreachable routes in the open world": "Gefährten meiden in der offenen Welt wiederholte Versuche auf unpassierbaren Routen" + "Companions avoid repeating unreachable routes in the open world": "Gefährten meiden in der offenen Welt wiederholte Versuche auf unpassierbaren Routen", + "Login server startup works when Windows does not list its listening port": "Der Anmeldeserver startet auch ohne Eintrag seines lauschenden Ports in Windows", + "Updated SQUID's Playerbots to 2.9.4 and refreshed Dungeon Clear": "SQUID’s Playerbots auf 2.9.4 aktualisiert und Dungeon Clear erneuert", + "Electrocutioner is used up by Electrocute and no longer makes it look ready too early": "Electrocute verbraucht Electrocutioner und erscheint nicht mehr vorzeitig einsatzbereit", + "The Dungeon Finder boss objective survives a relog": "Das Bossziel der Dungeonsuche bleibt nach erneutem Einloggen erhalten", + "Vanilla dungeon bosses no longer sleep or mind control tanks and healers": "Bosse klassischer Dungeons versetzen Tanks und Heiler nicht mehr in Schlaf oder Gedankenkontrolle", + "Classic dungeons scale only for Dungeon Finder groups": "Klassische Dungeons skalieren nur für Gruppen der Dungeonsuche", + "Darkmaster Gandling raises Risen Students only at 52% health": "Dunkelmeister Gandling erweckt auferstandene Studenten erst bei 52 % Gesundheit", + "Sunken Temple's dragons appear only after the Avatar of Hakkar and Jammal'an": "Die Drachen im Versunkenen Tempel erscheinen erst nach dem Avatar von Hakkar und Jammal’an", + "Scaled loot previews survive a map change": "Die Vorschau skalierter Beute bleibt beim Kartenwechsel erhalten", + "Updated SQUID Playerbots to 2.9.4": "SQUID Playerbots auf 2.9.4 aktualisiert" }, "fr": { "Restrict new characters by custom race without changing existing characters": "Restreignez les races supplémentaires des nouveaux personnages sans modifier les personnages existants", @@ -342,7 +367,17 @@ "Startup and shutdown keep bounded diagnostics of launcher stages": "Le démarrage et l’arrêt conservent un diagnostic limité des étapes de lancement", "Database shutdown succeeds when MySQL closes its connection before replying": "L’arrêt de la base réussit même si MySQL ferme la connexion avant de répondre", "Server startup waits for ports that Windows is still releasing": "Au démarrage, le serveur attend que Windows libère le port", - "Companions avoid repeating unreachable routes in the open world": "Les compagnons évitent de reprendre les chemins impraticables en monde ouvert" + "Companions avoid repeating unreachable routes in the open world": "Les compagnons évitent de reprendre les chemins impraticables en monde ouvert", + "Login server startup works when Windows does not list its listening port": "Le serveur de connexion démarre même si Windows ne répertorie pas son port d’écoute", + "Updated SQUID's Playerbots to 2.9.4 and refreshed Dungeon Clear": "SQUID’s Playerbots passe en version 2.9.4 et Dungeon Clear est actualisé", + "Electrocutioner is used up by Electrocute and no longer makes it look ready too early": "Electrocute consomme Electrocutioner et ne paraît plus disponible trop tôt", + "The Dungeon Finder boss objective survives a relog": "L’objectif de boss de la recherche de donjons est conservé après reconnexion", + "Vanilla dungeon bosses no longer sleep or mind control tanks and healers": "Les boss des donjons classiques n’endorment plus les tanks et soigneurs et ne contrôlent plus leur esprit", + "Classic dungeons scale only for Dungeon Finder groups": "Les donjons classiques ne s’adaptent que pour les groupes de la recherche de donjons", + "Darkmaster Gandling raises Risen Students only at 52% health": "Le sombre maître Gandling ne relève les étudiants qu’à 52 % de ses points de vie", + "Sunken Temple's dragons appear only after the Avatar of Hakkar and Jammal'an": "Les dragons du Temple englouti n’apparaissent qu’après l’Avatar d’Hakkar et Jammal’an", + "Scaled loot previews survive a map change": "L’aperçu du butin adapté est conservé lors d’un changement de carte", + "Updated SQUID Playerbots to 2.9.4": "SQUID Playerbots passe en version 2.9.4" }, "es": { "Restrict new characters by custom race without changing existing characters": "Restringe las razas adicionales de personajes nuevos sin modificar los existentes", @@ -391,7 +426,17 @@ "Startup and shutdown keep bounded diagnostics of launcher stages": "El inicio y la parada guardan diagnósticos limitados de las etapas del lanzador", "Database shutdown succeeds when MySQL closes its connection before replying": "La parada de la base de datos se completa aunque MySQL cierre la conexión antes de responder", "Server startup waits for ports that Windows is still releasing": "Al iniciarse, el servidor espera a que Windows libere el puerto", - "Companions avoid repeating unreachable routes in the open world": "Los compañeros evitan repetir rutas intransitables en el mundo abierto" + "Companions avoid repeating unreachable routes in the open world": "Los compañeros evitan repetir rutas intransitables en el mundo abierto", + "Login server startup works when Windows does not list its listening port": "El servidor de acceso arranca aunque Windows no muestre su puerto de escucha", + "Updated SQUID's Playerbots to 2.9.4 and refreshed Dungeon Clear": "SQUID’s Playerbots se actualiza a 2.9.4 y se renueva Dungeon Clear", + "Electrocutioner is used up by Electrocute and no longer makes it look ready too early": "Electrocute consume Electrocutioner y ya no parece disponible antes de tiempo", + "The Dungeon Finder boss objective survives a relog": "El objetivo de jefe del buscador de mazmorras se conserva al volver a entrar", + "Vanilla dungeon bosses no longer sleep or mind control tanks and healers": "Los jefes de mazmorras clásicas ya no duermen ni controlan mentalmente a tanques y sanadores", + "Classic dungeons scale only for Dungeon Finder groups": "Las mazmorras clásicas solo se ajustan para grupos del buscador de mazmorras", + "Darkmaster Gandling raises Risen Students only at 52% health": "El Maestro Oscuro Gandling solo alza a los estudiantes resucitados al 52 % de salud", + "Sunken Temple's dragons appear only after the Avatar of Hakkar and Jammal'an": "Los dragones del Templo Sumergido solo aparecen después del Avatar de Hakkar y Jammal’an", + "Scaled loot previews survive a map change": "La vista previa del botín ajustado se conserva al cambiar de mapa", + "Updated SQUID Playerbots to 2.9.4": "SQUID Playerbots se actualiza a 2.9.4" }, "zh": { "Restrict new characters by custom race without changing existing characters": "限制新角色可选的自定义种族,不影响现有角色", @@ -440,7 +485,17 @@ "Startup and shutdown keep bounded diagnostics of launcher stages": "启动和关闭时会保留大小受限的启动器阶段诊断日志", "Database shutdown succeeds when MySQL closes its connection before replying": "即使 MySQL 在回复前关闭连接,数据库关闭操作也能正确完成", "Server startup waits for ports that Windows is still releasing": "服务器启动时会等待 Windows 释放端口", - "Companions avoid repeating unreachable routes in the open world": "伙伴在开放世界中会避免反复尝试无法通行的路线" + "Companions avoid repeating unreachable routes in the open world": "伙伴在开放世界中会避免反复尝试无法通行的路线", + "Login server startup works when Windows does not list its listening port": "即使 Windows 未列出监听端口,登录服务器也能启动", + "Updated SQUID's Playerbots to 2.9.4 and refreshed Dungeon Clear": "已将 SQUID’s Playerbots 更新至 2.9.4,并更新 Dungeon Clear", + "Electrocutioner is used up by Electrocute and no longer makes it look ready too early": "Electrocute 会消耗 Electrocutioner,且不再过早显示为可用", + "The Dungeon Finder boss objective survives a relog": "地下城查找器的首领目标在重新登录后仍会保留", + "Vanilla dungeon bosses no longer sleep or mind control tanks and healers": "经典地下城首领不再使坦克和治疗者沉睡或受到精神控制", + "Classic dungeons scale only for Dungeon Finder groups": "经典地下城仅对通过地下城查找器组成的队伍进行缩放", + "Darkmaster Gandling raises Risen Students only at 52% health": "黑暗院长加丁仅在生命值降至 52% 时唤起复活的学生", + "Sunken Temple's dragons appear only after the Avatar of Hakkar and Jammal'an": "沉没的神庙中的巨龙仅在哈卡的化身和迦玛兰之后出现", + "Scaled loot previews survive a map change": "缩放后的战利品预览在切换地图后仍会保留", + "Updated SQUID Playerbots to 2.9.4": "已将 SQUID Playerbots 更新至 2.9.4" } } } diff --git a/src/data/server-history.json b/src/data/server-history.json index 676d789..598e42f 100644 --- a/src/data/server-history.json +++ b/src/data/server-history.json @@ -1571,6 +1571,143 @@ }, "experimentalFeatures": [], "compare": "https://github.com/Corfirean/coa-server-build/compare/server-0.261030.90...server-0.261101.92" + }, + { + "tag": "server-0.261104.94", + "version": "0.261104.94", + "date": "2026-11-04", + "url": "https://github.com/Corfirean/coa-server-build/releases/tag/server-0.261104.94", + "notes": [ + "Companions avoid repeating unreachable routes in the open world", + "Server startup waits for ports that Windows is still releasing", + "Updated the reviewed CoA upstream snapshot" + ], + "snapshot": "f67a6d8545e4c6ece2f819f9dd2642fe5a81a69c959946a1031859c19b5c4d74", + "components": { + "upstream": { + "repository": "jealous-sound/azerothcore-wotlk-coa", + "ref": "a34c5ad7167b6b2087a678cb4344c6cbe6abb823", + "sha": "a34c5ad7167b6b2087a678cb4344c6cbe6abb823" + }, + "core": { + "repository": "Corfirean/azerothcore-wotlk-coa", + "ref": "14cf375f1e006770b330d3fb89201ace54bfca24", + "sha": "14cf375f1e006770b330d3fb89201ace54bfca24" + }, + "bots": { + "repository": "Corfirean/mod-coa-playerbots", + "ref": "447558bc27d6bb447aaf10eefcb2e85ac2b15c32", + "sha": "447558bc27d6bb447aaf10eefcb2e85ac2b15c32" + }, + "scaling": { + "repository": "Corfirean/mod-coa-content-scaling", + "ref": "3c2febf636bd09087bb278e381b975271a70fdf6", + "sha": "3c2febf636bd09087bb278e381b975271a70fdf6" + }, + "manager": { + "repository": "Corfirean/coa-server-manager", + "ref": "173248efbe24da9b4c1b5ca12fa7580fcd1e8ea7", + "sha": "173248efbe24da9b4c1b5ca12fa7580fcd1e8ea7" + }, + "races": { + "repository": "ilusixn/azerothcore-wotlk-coa", + "ref": "coa-custom-1.9.2", + "sha": "31bd63d309b8b0fb4f1a4d9b793a343b8ac36f1e", + "assets": [ + { + "name": "CoA-Custom-1.9.2-Client-1.zip", + "size": 1513021586, + "digest": "sha256:a9dd51ed2d90fb048d549602f40f5429d56e2df0df5606a38781b358fa369568", + "url": "https://github.com/ilusixn/azerothcore-wotlk-coa/releases/download/coa-custom-1.9.2/CoA-Custom-1.9.2-Client-1.zip" + }, + { + "name": "CoA-Custom-1.9.2-Client-2.zip", + "size": 1198283005, + "digest": "sha256:ab084a55509ccbcc2977a06dd0c01fa879973a1892baaacaeb3ff52f3dfc750e", + "url": "https://github.com/ilusixn/azerothcore-wotlk-coa/releases/download/coa-custom-1.9.2/CoA-Custom-1.9.2-Client-2.zip" + }, + { + "name": "CoA-Custom-1.9.2-Client-3.zip", + "size": 1678829573, + "digest": "sha256:907e267f0ee7038807e626c3c1eca5e12db6c88b747137a23c5fb52eaa1a358e", + "url": "https://github.com/ilusixn/azerothcore-wotlk-coa/releases/download/coa-custom-1.9.2/CoA-Custom-1.9.2-Client-3.zip" + }, + { + "name": "CoA-Custom-1.9.2-Client-4.zip", + "size": 502385128, + "digest": "sha256:e0bd87172af989fa50a8e2b08ba4321c72b6265047482f051a1db3b80d55bcaa", + "url": "https://github.com/ilusixn/azerothcore-wotlk-coa/releases/download/coa-custom-1.9.2/CoA-Custom-1.9.2-Client-4.zip" + }, + { + "name": "CoA-Custom-1.9.2-Client-5.zip", + "size": 168079711, + "digest": "sha256:73364ad1b58c6342641a848a3b20a835472834f600416606be1470386774ca78", + "url": "https://github.com/ilusixn/azerothcore-wotlk-coa/releases/download/coa-custom-1.9.2/CoA-Custom-1.9.2-Client-5.zip" + }, + { + "name": "CoA-Custom-1.9.2-Server.zip", + "size": 53004560, + "digest": "sha256:b893813573a4d3f6a0003c1f174582d3def997f37b402cbca44d53055d2fc1d2", + "url": "https://github.com/ilusixn/azerothcore-wotlk-coa/releases/download/coa-custom-1.9.2/CoA-Custom-1.9.2-Server.zip" + }, + { + "name": "INSTALL-GUIDE.txt", + "size": 3006, + "digest": "sha256:f17e97fafa3225901d1caf8c3b8141293f98fbfb8c9243c0c4717278c60146aa", + "url": "https://github.com/ilusixn/azerothcore-wotlk-coa/releases/download/coa-custom-1.9.2/INSTALL-GUIDE.txt" + }, + { + "name": "PATCH-NOTES-1.9.2.txt", + "size": 2822, + "digest": "sha256:f2fd4693ba181959a572d3fb10a0050e9ff6c4f735b3ab0019c7d16712db28cb", + "url": "https://github.com/ilusixn/azerothcore-wotlk-coa/releases/download/coa-custom-1.9.2/PATCH-NOTES-1.9.2.txt" + } + ] + }, + "squid": { + "repository": "Zyth45/mod-playerbots", + "ref": "v2.8.2", + "sha": "fa4cfd31997367b3e574a2b89b858c4669ff53fb", + "patch": "patches/squid-coa-validation.patch", + "patchSha256": "9b101db17369fb5a6af3f7e99323f7770eb8650ba3b5e9b3970bf09a0ef5d32f" + }, + "build": { + "repository": "Corfirean/coa-server-build", + "ref": "d9aaa5263154473b2fe1623172492f88e6e03d73", + "sha": "d9aaa5263154473b2fe1623172492f88e6e03d73" + }, + "dungeon-clear": { + "repository": "Zyth45/mod-dungeon-clear", + "sha": "9a9d09cf512e0a883af9cda6973445b81c123b13", + "patch": "patches/dungeon-clear-coa-validation.patch", + "patchSha256": "956f278865e22ee75c984ca22ff8238150b5886c9934ddfe64dd9c832c912dcc", + "ref": "9a9d09cf512e0a883af9cda6973445b81c123b13" + }, + "navigation": { + "repository": "Corfirean/azerothcore-wotlk-coa", + "ref": "8b44099f480af0b69c6dfc697e4d388e865e9ffc", + "sha": "8b44099f480af0b69c6dfc697e4d388e865e9ffc", + "sourceRelease": "navigation-20261012", + "manifestSha256": "7f28600735f115792e79a5e8d1c8d78a83a8f5ed14a090c6d87268e49c2bb683", + "archiveSha256": "aa1347a095f85af44b4f592270a0e9314954801fda4578f0147f847e32c24a60", + "assets": [ + { + "name": "navigation.zip.001", + "size": 1500000000, + "sha256": "e3a93903fc8155ee0d92db399ec426769c360bef87c44c07beb7e21cfd892c18", + "url": "https://github.com/Corfirean/coa-server-build/releases/download/navigation-20261012/navigation.zip.001" + }, + { + "name": "navigation.zip.002", + "size": 1377006470, + "sha256": "c1af26ba7f83676278613076c357c4da0a11cfa6ae1ff00003479057c4864471", + "url": "https://github.com/Corfirean/coa-server-build/releases/download/navigation-20261012/navigation.zip.002" + } + ] + } + }, + "experimentalFeatures": [], + "compare": "https://github.com/Corfirean/coa-server-build/compare/server-0.261101.92...server-0.261104.94" } ] } diff --git a/tools/reviewed-manager-notes.json b/tools/reviewed-manager-notes.json index dce9ee7..2a031b9 100644 --- a/tools/reviewed-manager-notes.json +++ b/tools/reviewed-manager-notes.json @@ -1,6 +1,6 @@ { - "version": "0.9.9", + "version": "0.9.10", "notes": [ - "Update and recovery checks use the temporary login port even with a Windows override" + "Custom Races patch installation recovers from interrupted downloads" ] } diff --git a/tools/reviewed-server-notes.json b/tools/reviewed-server-notes.json index 46c385e..b3ff57a 100644 --- a/tools/reviewed-server-notes.json +++ b/tools/reviewed-server-notes.json @@ -1,12 +1,30 @@ { - "core": "14cf375f1e006770b330d3fb89201ace54bfca24", - "bots": "447558bc27d6bb447aaf10eefcb2e85ac2b15c32", - "squid": "fa4cfd31997367b3e574a2b89b858c4669ff53fb", + "components": { + "core": { + "repository": "Corfirean/azerothcore-wotlk-coa", + "sha": "85ecc2122efd4bc168e750ab35c3e3e8d9c49735" + }, + "upstream": { + "repository": "jealous-sound/azerothcore-wotlk-coa", + "sha": "f8955cb9b29042c359a938ff732e4b608dd62ea5" + }, + "bots": { + "repository": "Corfirean/mod-coa-playerbots", + "sha": "0588a8e5cdfe54f81fe47bbb40fc9f75d29662e3" + }, + "scaling": { + "repository": "Corfirean/mod-coa-content-scaling", + "sha": "3c2febf636bd09087bb278e381b975271a70fdf6" + }, + "build": { + "repository": "Corfirean/coa-server-build", + "sha": "ccb121b2a050e9f6eae4e5798dbca1c4ee66264f" + } + }, "notes": [ - "Server startup waits for ports that Windows is still releasing", - "Normal Classic dungeons retain their authored damage at full party size", - "Companions avoid repeating unreachable routes in the open world", + "Login server startup works when Windows does not list its listening port", + "Updated SQUID's Playerbots to 2.9.4 and refreshed Dungeon Clear", + "Updated SQUID Playerbots to 2.9.4", "Updated the reviewed CoA upstream snapshot" - ], - "dungeon-clear": "9a9d09cf512e0a883af9cda6973445b81c123b13" + ] }