Compare commits

..
Author SHA1 Message Date
ДмитрийandClaude Opus 5.5 2e6fcceb05 CI: drop the launcher bridge test (the bridge was removed)
tools/test_launcher_bridge.py tested crates/coa-core/src/launcher_bridge.py,
which the Rust launcher replaced; check.yml and release.yml still ran it, so
the release build failed.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 16:48:17 +05:00
ДмитрийandClaude Opus 5.5 abcc816581 Stop: ask the world again when a shutdown request is lost
A console shutdown request is sometimes lost, and the world then keeps
running until the stop times out. While the world still runs and its
console still answers after 15 s, the launcher asks again (twice at most);
asking twice is harmless. Verified on a disposable repack with the first
World::ShutdownServ call suppressed in a debugger: the second request
stopped the world.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 16:07:54 +05:00
ДмитрийandClaude Opus 5.5 8353b791fb The Manager no longer edits Scripts/manage.py
Repacks ship no .bat files, and the Manager starts servers with
coa-core::launcher, so the realm-profile patch it wrote into manage.py
served no one. It is no longer applied (realm creation, realm switching and
start).

Recognising the edits older Managers made (realm patch, bridge import fix)
moves into legacy_launcher, so updates and file checks still treat such a
file as unmodified. Nothing there writes a file.

manage.py itself stays complete in the repack: Managers up to 0.9.10 run it
through their bridge and patch its text, so it cannot become a thin wrapper
until those Managers are no longer supported.

Verified: coa-core unit tests; examples/manager_launcher_e2e on a disposable
repack (manage.py unchanged after a start with a realm profile).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 13:07:41 +05:00
ДмитрийandClaude Opus 5.5 b81227b0ea Bug-report relay in Rust (coa-launcher relay-worker)
launcher::relay does what BugReport/relay.py and manage.py relay-worker do,
with the same spool: the <key>.status files the world reads, the journal
relay.sqlite3 (deliveries, settings), relay.lock (byte 0) and the
relay-ready record. Service answers map to the same states and retry times;
a post interrupted mid-flight stays uncertain and is never resent.

When coa-launcher.exe supervises a world it runs the relay itself; the
Python supervisor still runs relay.py.

Verified:
- examples/relay_equivalence: the same reports and scripted service answers
  through relay.py and the Rust relay give identical statuses, journal rows
  (including retry times) and posts, and each continues the other's journal.
- examples/manager_launcher_e2e on a disposable repack: supervisor and relay
  are coa-launcher.exe, start/stop interoperates with manage.py.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 12:00:40 +05:00
ДмитрийandClaude Opus 5.5 a9fb982ab0 Console shutdown request reads the reply before closing
send_without_answer closed the socket right after writing "server shutdown".
With the reply still unread, Windows resets the connection, and the world
can drop the command: a world supervised by coa-launcher.exe ignored the
shutdown and the stop timed out after 90 seconds. The reply is now read up
to the next prompt, the end of the connection or 10 seconds.

The E2E also checks which supervisor runs the world and that manage.py
stops a world the Manager started.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 09:38:59 +05:00
ДмитрийandClaude Opus 5.5 a822bfc99b Manager starts and stops servers through the Rust launcher
driver::run now calls coa-core::launcher::ops::run in-process instead of
running Scripts/manage.py through launcher_bridge.py. Failures carry a typed
code (Error::Service) instead of being guessed from stderr text.

Moved into the launcher: realm profiles (realm id, name and databases from
Settings/realm-profile.json), extra worlds sharing the main database,
the shared world startup deadline and console readiness check, the owned-world
check on shutdown, force-stop-all, and an environment block without
AC_REALM_SERVER_PORT for update validation.

The world supervisor is Scripts/coa-launcher.exe when the repack ships it,
otherwise manage.py watch-world. Extra worlds get an unmodified manage.py.
The realm patch of manage.py stays for the repack's own .bat files.

Verified with examples/manager_launcher_e2e on a disposable repack.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 08:45:08 +05:00
ДмитрийandClaude Opus 5.5 1211de5a77 launcher (Rust): services inherit only their log and NUL; MySQL errors carry the server's text
std::process::Command lets a Windows child inherit every inheritable handle of the parent: a
MySQL started by the launcher kept the caller's files and pipes open (found by the SQUID test,
whose log stayed locked). Services now start through CreateProcessW with
PROC_THREAD_ATTRIBUTE_HANDLE_LIST = [log, NUL], as Python's subprocess does. The MySQL client's
outputs are read while it runs (a full pipe stopped it) and its last error line is reported.

E2E on a disposable repack: launcher_e2e PASS again; squid_equivalence PASS: Rust and
squid_playerbots.py leave identical journals, acore_playerbots tables (row counts) and
playerbots.conf (4106 lines), and a second run of either changes nothing.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 07:48:04 +05:00
ДмитрийandClaude Opus 5.5 ee36692db7 launcher (Rust): services, world supervisor, SQUID provisioning, coa-launcher.exe
- services: exclusive-bind port check, readiness by listener row or the server side of a
  loopback connection, MySQL client, start MySQL/auth, stop-all (world through its console,
  database last), status.
- world: start-world through a supervisor process (coa-launcher watch-world) that keeps the
  bug-report relay (still BugReport/relay.py via the repack's Python) alive; detailed logging.
- squid: squid_playerbots.py in Rust with the same journals (coa_squid_migrations,
  coa_squid_pending, coa_bots_installed).
- coa-launcher.exe: the manage.py commands and error texts (the Manager reads them).
- Services no longer inherit the launcher's stdin/stdout/stderr: a server holding the
  output pipe kept whoever read the launcher's output waiting.

E2E (examples/launcher_e2e, disposable stable repack on free ports): coa-launcher start-all ->
manage.py sees and stops it; manage.py start-all -> coa-launcher sees and stops it; a second
Rust-only cycle leaves nothing running.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 07:29:55 +05:00
ДмитрийandClaude Opus 5.5 ee43522019 launcher (Rust): settings, state records, control lock, prepare
First part of moving Scripts/manage.py into coa-core (plan §17, PY-1). Same formats on disk as
manage.py so both can run on one server: .state records, the byte-0 control lock msvcrt.locking
takes, configuration.json. prepare renders byte-for-byte what manage.py renders (checked against
the real script, COA_MANAGE_PY). State files are flushed to disk before they replace the old ones,
and a damaged record counts as no process instead of failing every later start.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 06:58:16 +05:00
55 changed files with 3821 additions and 10790 deletions

No files matched your search

-1
View File
@@ -26,5 +26,4 @@ jobs:
- run: node tools/check-i18n.mjs
- run: npm run build
- run: node --experimental-strip-types --test tools/*.test.mjs
- run: python -B -m unittest discover -s tools -p test_launcher_bridge.py
- run: cargo test --workspace --locked
-1
View File
@@ -74,7 +74,6 @@ jobs:
- name: Tests
run: cargo test --workspace --locked -- --test-threads=1
- run: node --experimental-strip-types --test tools/*.test.mjs
- run: python -B -m unittest discover -s tools -p test_launcher_bridge.py
- name: Build and sign (publish only when requested)
id: tauri
uses: tauri-apps/tauri-action@v0
-12
View File
@@ -8,18 +8,6 @@ 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.13 — 2026-11-15
- The custom races client is updated to Custom Races V2.
[Release](https://github.com/Corfirean/coa-server-manager/releases/tag/v0.9.13) · [Source changes](https://github.com/Corfirean/coa-server-manager/compare/v0.9.12...v0.9.13)
## 0.9.12 — 2026-11-14
- Settings for how much help bots get in dungeons and raids.
[Release](https://github.com/Corfirean/coa-server-manager/releases/tag/v0.9.12) · [Source changes](https://github.com/Corfirean/coa-server-manager/compare/v0.9.10...v0.9.12)
## 0.9.10 — 2026-11-08
- Custom Races patch installation recovers from interrupted downloads.
Generated
+13 -3
View File
@@ -586,7 +586,7 @@ dependencies = [
[[package]]
name = "coa-core"
version = "0.9.13"
version = "0.9.10"
dependencies = [
"base64 0.22.1",
"chrono",
@@ -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"
@@ -634,7 +644,7 @@ dependencies = [
[[package]]
name = "coa-release"
version = "0.9.13"
version = "0.9.10"
dependencies = [
"chrono",
"coa-core",
@@ -643,7 +653,7 @@ dependencies = [
[[package]]
name = "coa-server-manager"
version = "0.9.13"
version = "0.9.10"
dependencies = [
"coa-control-proto",
"coa-core",
+2 -2
View File
@@ -1,10 +1,10 @@
[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]
version = "0.9.13"
version = "0.9.10"
edition = "2021"
license = "AGPL-3.0-only"
@@ -1,7 +0,0 @@
---
area: manager
type: added
audience: admins
title: Settings for how much help bots get in dungeons and raids
---
Bot damage, healing, damage taken and tank threat can now be tuned under Bots, Combat. Everything defaults to 1 (no change); a switch turns the extra help for four hard bosses on.
@@ -1,7 +0,0 @@
---
area: manager
type: fixed
audience: players
title: Turning the custom races client patch on or off takes seconds again
---
V2 has over 7,000 files and switching it could run for many minutes. Now only the files the game itself loads are hidden, and the rest stays in place. A switch that was cut short is undone safely.
@@ -1,7 +0,0 @@
---
area: manager
type: changed
audience: players
title: The custom races client is updated to Custom Races V2
---
The client update installs V2 and starts its own CoACustomRace.exe; Ascension.exe is left as it was. Four archives are the same as in 1.9.2, so a game folder that already had 1.9.2 downloads only the rest.
+1 -25
View File
@@ -176,9 +176,7 @@
"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",
"Corfirean/coa-server-manager:20261103-isolated-login-port.md",
"Corfirean/coa-server-manager:20261107-bot-strength-scaling-settings.md",
"Corfirean/coa-server-manager:20261115-custom-races-v2-client.md"
"Corfirean/coa-server-manager:20261103-isolated-login-port.md"
],
"releases": [
{
@@ -914,28 +912,6 @@
],
"commit": "711f378ae82f75d3fc64368c042889c773315c54",
"compare": "https://github.com/Corfirean/coa-server-manager/compare/v0.9.9...v0.9.10"
},
{
"tag": "v0.9.12",
"version": "0.9.12",
"date": "2026-11-14",
"url": "https://github.com/Corfirean/coa-server-manager/releases/tag/v0.9.12",
"notes": [
"Settings for how much help bots get in dungeons and raids"
],
"commit": "d71c5635e3262a775b400a1c90ac81d7bddcbeaf",
"compare": "https://github.com/Corfirean/coa-server-manager/compare/v0.9.10...v0.9.12"
},
{
"tag": "v0.9.13",
"version": "0.9.13",
"date": "2026-11-15",
"url": "https://github.com/Corfirean/coa-server-manager/releases/tag/v0.9.13",
"notes": [
"The custom races client is updated to Custom Races V2"
],
"commit": "d3527312803fb5a3e1cd48e01496645a8bbc9dcf",
"compare": "https://github.com/Corfirean/coa-server-manager/compare/v0.9.12...v0.9.13"
}
]
}
+2 -1
View File
@@ -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 = []
+114
View File
@@ -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 <new folder ending in -fixture> <coa-launcher.exe>
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::<Vec<_>>().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<String> = 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(&reg_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: &reg, 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");
}
@@ -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 <existing folder ending in -fixture>
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::<Vec<_>>().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<String> = 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");
}
@@ -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 <repack folder with Runtime/python and BugReport/relay.py>
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<u64, Failure> {
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<Mutex<Vec<String>>>);
impl Service for Scripted {
fn create(&self, title: &str, _: &str) -> std::result::Result<u64, Failure> {
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<String> {
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<String> {
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<String>) {
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<i64>>(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");
}
@@ -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 <fixture ending in -fixture> <coa-launcher.exe>
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<String> = 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");
}
+1 -2
View File
@@ -15,8 +15,7 @@ use crate::fsx;
pub use crate::glue_config;
pub const ADDON_NAME: &str = "CoABotUI";
// CoA Custom Races V2 ships its own client (CoACustomRace.exe) next to Ascension.exe and must be started instead.
const EXECUTABLES: [&str; 4] = ["CoACustomRace.exe", "Ascension.exe", "Wow.exe", "WoW.exe"];
const EXECUTABLES: [&str; 3] = ["Ascension.exe", "Wow.exe", "WoW.exe"];
pub fn is_running(client: &Path) -> bool {
if crate::platform::flavor() == crate::platform::Flavor::Docker {
+53 -667
View File
@@ -14,24 +14,14 @@ use crate::download::Cancel;
use crate::error::{Error, Result};
use crate::fsx;
pub const CLIENT_VERSION: &str = "2.0";
pub const CLIENT_VERSION: &str = "1.9.2";
pub const MANIFEST_FILENAME: &str = "custom_races_patch_manifest.txt";
/// Files earlier releases installed that the current release no longer ships (removed on update).
#[cfg(test)]
const RETIRED_FILES: &[&str] = &["Ascension.exe"];
/// The client archives of the coa-custom-2.0 release. The server archive is read only for its client
/// addons (files/addons: subclass interface, dev menu, teleports, spell activation overlay).
pub const ARCHIVES: &[(&str, &str)] = &[
("CoA-Custom-V2-Client-1.zip", "https://github.com/ilusixn/CustomRacesCoa/releases/download/coa-custom-2.0/CoA-Custom-V2-Client-1.zip"),
("CoA-Custom-V2-Client-2.zip", "https://github.com/ilusixn/CustomRacesCoa/releases/download/coa-custom-2.0/CoA-Custom-V2-Client-2.zip"),
("CoA-Custom-V2-Client-3.zip", "https://github.com/ilusixn/CustomRacesCoa/releases/download/coa-custom-2.0/CoA-Custom-V2-Client-3.zip"),
("CoA-Custom-V2-Client-4.zip", "https://github.com/ilusixn/CustomRacesCoa/releases/download/coa-custom-2.0/CoA-Custom-V2-Client-4.zip"),
("CoA-Custom-V2-Client-5.zip", "https://github.com/ilusixn/CustomRacesCoa/releases/download/coa-custom-2.0/CoA-Custom-V2-Client-5.zip"),
("CoA-Custom-V2-Client-6.zip", "https://github.com/ilusixn/CustomRacesCoa/releases/download/coa-custom-2.0/CoA-Custom-V2-Client-6.zip"),
("CoA-Custom-V2-Client-7.zip", "https://github.com/ilusixn/CustomRacesCoa/releases/download/coa-custom-2.0/CoA-Custom-V2-Client-7.zip"),
("CoA-Custom-V2-Client-8.zip", "https://github.com/ilusixn/CustomRacesCoa/releases/download/coa-custom-2.0/CoA-Custom-V2-Client-8.zip"),
("CoA-Custom-V2-Client-9.zip", "https://github.com/ilusixn/CustomRacesCoa/releases/download/coa-custom-2.0/CoA-Custom-V2-Client-9.zip"),
("CoA-Custom-V2-Server.zip", "https://github.com/ilusixn/CustomRacesCoa/releases/download/coa-custom-2.0/CoA-Custom-V2-Server.zip"),
("CoA-Custom-1.9.2-Client-1.zip", "https://github.com/ilusixn/azerothcore-wotlk-coa/releases/download/coa-custom-1.9.2/CoA-Custom-1.9.2-Client-1.zip"),
("CoA-Custom-1.9.2-Client-2.zip", "https://github.com/ilusixn/azerothcore-wotlk-coa/releases/download/coa-custom-1.9.2/CoA-Custom-1.9.2-Client-2.zip"),
("CoA-Custom-1.9.2-Client-3.zip", "https://github.com/ilusixn/azerothcore-wotlk-coa/releases/download/coa-custom-1.9.2/CoA-Custom-1.9.2-Client-3.zip"),
("CoA-Custom-1.9.2-Client-4.zip", "https://github.com/ilusixn/azerothcore-wotlk-coa/releases/download/coa-custom-1.9.2/CoA-Custom-1.9.2-Client-4.zip"),
("CoA-Custom-1.9.2-Client-5.zip", "https://github.com/ilusixn/azerothcore-wotlk-coa/releases/download/coa-custom-1.9.2/CoA-Custom-1.9.2-Client-5.zip"),
];
pub const RACE_MPQS: &[&str] = &[
@@ -45,29 +35,14 @@ pub const RACE_MPQS: &[&str] = &[
"patch-ZE8.MPQ",
"patch-ZE9.MPQ",
"patch-ZEA.MPQ",
"patch-ZES.MPQ",
"patch-ZEZV.MPQ",
"patch-ZEZW.MPQ",
"patch-ZEZX.MPQ",
"patch-ZEZY.MPQ",
"patch-ZEZZ.MPQ",
"patch-ZEZZA.MPQ",
"patch-ZEZZB.MPQ",
"patch-ZEZZC.MPQ",
"patch-ZEZZD.MPQ",
"patch-ZEZZE.MPQ",
"patch-ZEZZF.MPQ",
"patch-ZEZZG.MPQ",
"patch-ZEZZH.MPQ",
"patch-ZEZZI.MPQ",
"patch-ZG.MPQ",
"patch-ZH.MPQ",
"patch-ZHA.MPQ",
"patch-ZHM.MPQ",
"patch-ZJ.MPQ",
"patch-ZK.MPQ",
"patch-ZM.MPQ",
"patch-ZVU.MPQ",
"patch-ZES.MPQ",
"patch-ZJ.MPQ",
"patch-ZZE.MPQ",
"patch-ZZR.MPQ",
"patch-ZZS.MPQ",
@@ -75,187 +50,26 @@ pub const RACE_MPQS: &[&str] = &[
"patch-ZZU.MPQ",
"patch-ZZV.MPQ",
"patch-ZZW.MPQ",
"patch-ZZX.MPQ",
"patch-ZZZ.MPQ",
"patch-ZZZA.MPQ",
"patch-ZK.MPQ",
"patch-ZZX.MPQ",
"patch-ZZZC.MPQ",
"patch-ZZZD.MPQ",
"patch-ZZZA.MPQ",
"patch-ZZZE.MPQ",
"patch-ZZZF.MPQ",
"patch-ZZZG.MPQ",
"patch-ZZZZ.MPQ",
"patch-ZZZZA.MPQ",
"patch-ZZZZB.MPQ",
"patch-ZZZZC.MPQ",
"patch-ZZZZD.MPQ",
"patch-ZZZZE.MPQ",
"patch-ZZZZS.MPQ",
"patch-ZZZZT.MPQ",
"patch-ZZZZW.MPQ",
"patch-ZZZZX.MPQ",
"patch-ZZZZY.MPQ",
"patch-ZZZZZ.MPQ",
"patch-ZZZZZA.MPQ",
"patch-ZZZZZB.MPQ",
"patch-ZZZZZC.MPQ",
"patch-ZZZZZM.MPQ",
"patch-ZZZZZN.MPQ",
"patch-ZZZZZO.MPQ",
"patch-ZZZZZP.MPQ",
"patch-ZZZZZQ.MPQ",
"patch-ZZZZZR.MPQ",
"patch-ZZZZZS.MPQ",
"patch-ZZZZZT.MPQ",
"patch-ZZZZZU.MPQ",
"patch-ZZZZZV.MPQ",
"patch-ZZZZZW.MPQ",
"patch-ZZZZZX.MPQ",
"patch-ZZZZZY.MPQ",
];
pub const RACE_ADDONS: &[&str] = &[
"Ascension_Subclass/Ascension_Subclass.lua",
"Ascension_Subclass/Ascension_Subclass.toc",
"Ascension_Subclass/Bindings.xml",
"Ascension_Subclass/SubclassBar.lua",
"Ascension_Subclass/SubclassCastBar.lua",
"Ascension_Subclass/SubclassChoices.lua",
"Ascension_Subclass/SubclassGlow.lua",
"Ascension_Subclass/SubclassNodes.lua",
"Ascension_Subclass/SubclassOrbs.lua",
"Ascension_Subclass/SubclassPowerBar.lua",
"Ascension_Subclass/SubclassRaceBackground.lua",
"CoAHideArmor/CoAHideArmor.lua",
"CoAHideArmor/CoAHideArmor.toc",
"CoAQuestSafe/CoAQuestSafe.lua",
"CoAQuestSafe/CoAQuestSafe.toc",
"CoAWC2Cursor/CoAWC2Cursor.lua",
"CoAWC2Cursor/CoAWC2Cursor.toc",
"CoA_DevMenu/CoA_DevMenu.lua",
"CoA_DevMenu/CoA_DevMenu.lua.before_v2",
"CoA_DevMenu/CoA_DevMenu.lua.before_v3",
"CoA_DevMenu/CoA_DevMenu.toc",
"CoA_DevMenu/CoA_DevMenu_CoA.lua",
"CoA_DevMenu/CoA_DevMenu_Combat.lua",
"CoA_DevMenu/CoA_DevMenu_Create.lua",
"CoA_DevMenu/CoA_DevMenu_Create.lua.before_v4",
"CoA_DevMenu/CoA_DevMenu_Create.lua.before_v5",
"CoA_DevMenu/CoA_DevMenu_Ext.lua",
"CoA_DevMenu/CoA_DevMenu_Ext.lua.before_v3",
"CoA_DevMenu/CoA_DevMenu_Ext.lua.before_v4",
"CoA_DevMenu/CoA_DevMenu_Help.lua",
"CoA_DevMenu/CoA_DevMenu_Items.lua",
"CoA_DevMenu/CoA_DevMenu_Me.lua",
"CoA_DevMenu/CoA_DevMenu_Server.lua",
"CoA_DevMenu/CoA_DevMenu_Share.lua",
"CoA_DevMenu/EmoteData.lua",
"CoAHideArmor/CoAHideArmor.lua",
"CoAHideArmor/CoAHideArmor.toc",
"CoA_TalentReset/CoA_TalentReset.lua",
"CoA_TalentReset/CoA_TalentReset.toc",
"CoA_Teleports/CoA_Teleports.lua",
"CoA_Teleports/CoA_Teleports.toc",
"CoA_Teleports/TeleportData.lua",
"SpellActivationOverlay-for-CoA/LICENSE",
"SpellActivationOverlay-for-CoA/SpellActivationOverlay-for-CoA.toc",
"SpellActivationOverlay-for-CoA/SpellActivationOverlay.lua",
"SpellActivationOverlay-for-CoA/SpellActivationOverlay.xml",
"SpellActivationOverlay-for-CoA/changelog.md",
"SpellActivationOverlay-for-CoA/classes/barbarian.lua",
"SpellActivationOverlay-for-CoA/classes/bloodmage.lua",
"SpellActivationOverlay-for-CoA/classes/chronomancer.lua",
"SpellActivationOverlay-for-CoA/classes/common.lua",
"SpellActivationOverlay-for-CoA/classes/cultist.lua",
"SpellActivationOverlay-for-CoA/classes/deathknight.lua",
"SpellActivationOverlay-for-CoA/classes/druid.lua",
"SpellActivationOverlay-for-CoA/classes/felsworn.lua",
"SpellActivationOverlay-for-CoA/classes/guardian.lua",
"SpellActivationOverlay-for-CoA/classes/hunter.lua",
"SpellActivationOverlay-for-CoA/classes/knightofxoroth.lua",
"SpellActivationOverlay-for-CoA/classes/mage.lua",
"SpellActivationOverlay-for-CoA/classes/monk.lua",
"SpellActivationOverlay-for-CoA/classes/necromancer.lua",
"SpellActivationOverlay-for-CoA/classes/paladin.lua",
"SpellActivationOverlay-for-CoA/classes/priest.lua",
"SpellActivationOverlay-for-CoA/classes/primalist.lua",
"SpellActivationOverlay-for-CoA/classes/pyromancer.lua",
"SpellActivationOverlay-for-CoA/classes/ranger.lua",
"SpellActivationOverlay-for-CoA/classes/reaper.lua",
"SpellActivationOverlay-for-CoA/classes/rogue.lua",
"SpellActivationOverlay-for-CoA/classes/runemaster.lua",
"SpellActivationOverlay-for-CoA/classes/shaman.lua",
"SpellActivationOverlay-for-CoA/classes/starcaller.lua",
"SpellActivationOverlay-for-CoA/classes/stormbringer.lua",
"SpellActivationOverlay-for-CoA/classes/suncleric.lua",
"SpellActivationOverlay-for-CoA/classes/templar.lua",
"SpellActivationOverlay-for-CoA/classes/tinker.lua",
"SpellActivationOverlay-for-CoA/classes/venomancer.lua",
"SpellActivationOverlay-for-CoA/classes/warlock.lua",
"SpellActivationOverlay-for-CoA/classes/warrior.lua",
"SpellActivationOverlay-for-CoA/classes/witchdoctor.lua",
"SpellActivationOverlay-for-CoA/classes/witchhunter.lua",
"SpellActivationOverlay-for-CoA/components/aura.lua",
"SpellActivationOverlay-for-CoA/components/bucket.lua",
"SpellActivationOverlay-for-CoA/components/display.lua",
"SpellActivationOverlay-for-CoA/components/effect.lua",
"SpellActivationOverlay-for-CoA/components/events.lua",
"SpellActivationOverlay-for-CoA/components/external.lua",
"SpellActivationOverlay-for-CoA/components/glow.lua",
"SpellActivationOverlay-for-CoA/components/hash.lua",
"SpellActivationOverlay-for-CoA/components/item.lua",
"SpellActivationOverlay-for-CoA/components/overlay.lua",
"SpellActivationOverlay-for-CoA/components/project.lua",
"SpellActivationOverlay-for-CoA/components/rune.lua",
"SpellActivationOverlay-for-CoA/components/shutdown.lua",
"SpellActivationOverlay-for-CoA/components/sound.lua",
"SpellActivationOverlay-for-CoA/components/spell.lua",
"SpellActivationOverlay-for-CoA/components/targetspells.lua",
"SpellActivationOverlay-for-CoA/components/targetwatch.lua",
"SpellActivationOverlay-for-CoA/components/tr.lua",
"SpellActivationOverlay-for-CoA/components/trigger.lua",
"SpellActivationOverlay-for-CoA/components/util.lua",
"SpellActivationOverlay-for-CoA/components/variable.lua",
"SpellActivationOverlay-for-CoA/libs/LibActionButton-1.0/LibActionButton-1.0.lua",
"SpellActivationOverlay-for-CoA/libs/LibActionButton-1.0/LibActionButton-1.0.toc",
"SpellActivationOverlay-for-CoA/libs/LibButtonGlow-1.0/LibButtonGlow-1.0.lua",
"SpellActivationOverlay-for-CoA/libs/LibButtonGlow-1.0/LibButtonGlow-1.0.toc",
"SpellActivationOverlay-for-CoA/libs/LibStub/LibStub.lua",
"SpellActivationOverlay-for-CoA/libs/LibStub/LibStub.toc",
"SpellActivationOverlay-for-CoA/options/InterfaceOptionsPanels.lua",
"SpellActivationOverlay-for-CoA/options/InterfaceOptionsPanels.xml",
"SpellActivationOverlay-for-CoA/options/classoptions.lua",
"SpellActivationOverlay-for-CoA/options/db.lua",
"SpellActivationOverlay-for-CoA/options/defaults.lua",
"SpellActivationOverlay-for-CoA/options/glowoptions.lua",
"SpellActivationOverlay-for-CoA/options/overlayoptions.lua",
"SpellActivationOverlay-for-CoA/options/questions.lua",
"SpellActivationOverlay-for-CoA/options/variables.lua",
"SpellActivationOverlay-for-CoA/options/variants.lua",
"SpellActivationOverlay-for-CoA/textures/bandits_guile.blp",
"SpellActivationOverlay-for-CoA/textures/eclipse_moon.blp",
"SpellActivationOverlay-for-CoA/textures/eclipse_sun.blp",
"SpellActivationOverlay-for-CoA/textures/fury_of_stormrage_yellow.blp",
"SpellActivationOverlay-for-CoA/textures/high_tide.blp",
"SpellActivationOverlay-for-CoA/textures/icon64.blp",
"SpellActivationOverlay-for-CoA/textures/maelstrom_weapon_1.blp",
"SpellActivationOverlay-for-CoA/textures/maelstrom_weapon_2.blp",
"SpellActivationOverlay-for-CoA/textures/maelstrom_weapon_3.blp",
"SpellActivationOverlay-for-CoA/textures/maelstrom_weapon_4.blp",
"SpellActivationOverlay-for-CoA/textures/mask.blp",
"SpellActivationOverlay-for-CoA/textures/maskzero.blp",
"SpellActivationOverlay-for-CoA/textures/rkm128.blp",
"SpellActivationOverlay-for-CoA/textures/texname.lua",
"SpellActivationOverlay-for-CoA/textures/thrill_of_the_hunt_1.blp",
"SpellActivationOverlay-for-CoA/textures/thrill_of_the_hunt_2.blp",
"SpellActivationOverlay-for-CoA/textures/thrill_of_the_hunt_3.blp",
"SpellActivationOverlay-for-CoA/variables/actionusable.lua",
"SpellActivationOverlay-for-CoA/variables/aurastacks.lua",
"SpellActivationOverlay-for-CoA/variables/custom.lua",
"SpellActivationOverlay-for-CoA/variables/execute.lua",
"SpellActivationOverlay-for-CoA/variables/holypower.lua",
"SpellActivationOverlay-for-CoA/variables/itemset.lua",
"SpellActivationOverlay-for-CoA/variables/nativesao.lua",
"SpellActivationOverlay-for-CoA/variables/stance.lua",
"SpellActivationOverlay-for-CoA/variables/talent.lua",
"UnBot/OnlineFrame.xml",
];
pub const EXCLUDED_BOT_RACES_RECOMMENDED: &str =
@@ -403,8 +217,6 @@ fn patch_files(client: &Path) -> Result<Vec<PatchFile>> {
include_str!("custom_races_hashes_1_8_3.json")
} else if manifest.lines().any(|line| line == "# CoA Custom 1.9.1") {
include_str!("custom_races_hashes_1_9_1.json")
} else if manifest.lines().any(|line| line == "# CoA Custom 1.9.2") {
include_str!("custom_races_hashes_1_9_2.json")
} else {
include_str!("custom_races_hashes.json")
};
@@ -463,56 +275,8 @@ fn suffix(path: &Path, extension: &str) -> PathBuf {
))
}
/// SHA-256 of a payload file, remembered for this run of the Manager. V2 is 8.7 GB, and every status check and
/// switch verifies all of it; a rename keeps size, creation and write time, while a replaced file changes them.
fn cached_sha256(path: &Path) -> Option<String> {
use std::collections::HashMap;
use std::sync::{Mutex, OnceLock};
use std::time::UNIX_EPOCH;
static HASHES: OnceLock<Mutex<HashMap<(String, u64, u128, u128), String>>> = OnceLock::new();
let meta = fs::metadata(path).ok()?;
let nanos = |time: io::Result<std::time::SystemTime>| {
time.ok()
.and_then(|t| t.duration_since(UNIX_EPOCH).ok())
.map(|d| d.as_nanos())
};
// The name without `.disabled`: switching renames only that suffix.
let name = path.file_name()?.to_string_lossy().to_ascii_lowercase();
let name = name.strip_suffix(".disabled").unwrap_or(&name).to_string();
let key = match (nanos(meta.modified()), nanos(meta.created())) {
(Some(modified), Some(created)) => Some((name, meta.len(), modified, created)),
_ => None,
};
let hashes = HASHES.get_or_init(Mutex::default);
if let Some(hash) = key.as_ref().and_then(|key| hashes.lock().ok()?.get(key).cloned()) {
return Some(hash);
}
let hash = fsx::sha256_file(path).ok()?;
if let (Some(key), Ok(mut hashes)) = (key, hashes.lock()) {
hashes.insert(key, hash.clone());
}
Some(hash)
}
fn matches_patch(path: &Path, file: &PatchFile) -> bool {
path.is_file() && cached_sha256(path).is_some_and(|hash| hash == file.sha256)
}
/// Whether disabling the patch must hide this file. The stock client loads only the MPQs in Data,
/// dinput8.dll and the addons; the rest (Data/Retail, VulkanShaders, the Esteria data files) is read by the
/// custom races executable and its libraries alone, so it stays in place: thousands of renames bought nothing.
/// A file that replaced one of the player's own (an `.original` exists) is always switched.
fn is_switched(client: &Path, file: &PatchFile) -> bool {
let lower = file.path.to_ascii_lowercase();
let entry_point = lower.starts_with("interface/addons/")
|| lower
.strip_prefix("data/")
.is_some_and(|name| !name.contains('/') && name.ends_with(".mpq"))
|| (!lower.contains('/')
&& [".dll", ".exe", ".bat"]
.iter()
.any(|extension| lower.ends_with(extension)));
entry_point || suffix(&client.join(&file.path), "original").is_file()
path.is_file() && fsx::sha256_file(path).is_ok_and(|hash| hash == file.sha256)
}
/// Only complete, verified payloads are reported as enabled or disabled.
@@ -543,11 +307,9 @@ pub fn client_patch_status(client_path: &Path) -> ClientPatchStatus {
ClientPatchState::Enabled
}
Ok(files)
if files.iter().all(|f| {
let active = client_path.join(&f.path);
matches_patch(&suffix(&active, "disabled"), f)
|| (!is_switched(client_path, f) && matches_patch(&active, f))
}) =>
if files
.iter()
.all(|f| matches_patch(&suffix(&client_path.join(&f.path), "disabled"), f)) =>
{
ClientPatchState::Disabled
}
@@ -589,24 +351,9 @@ struct SavedFile {
moved_to: Option<String>,
}
/// One line of the append-only journal. A payload has thousands of files, so the journal is never rewritten:
/// each step adds one synced line, and recovery replays the lines in order.
#[derive(Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
enum JournalRecord {
Saved { path: String, existed: bool },
Moved { index: usize, to: String },
Returned { index: usize },
}
const LEGACY_JOURNAL: &str = "journal.json";
const JOURNAL: &str = "journal.jsonl";
struct PatchTransaction<'a> {
root: &'a Path,
entries: Vec<SavedFile>,
index: std::collections::HashMap<String, usize>,
journal: Option<File>,
finished: bool,
}
@@ -629,102 +376,37 @@ fn move_patch_file(source: &Path, target: &Path) -> io::Result<()> {
fs::remove_file(source)
}
fn append_record(journal: &mut File, record: &JournalRecord) -> Result<()> {
use std::io::Write;
let mut line = serde_json::to_vec(record)?;
line.push(b'\n');
journal.write_all(&line)?;
journal.sync_data()?;
Ok(())
}
/// Replays a journal. A line cut short by a crash is the last one and was never followed by its file
/// operation (each line is synced before the operation it describes), so reading stops there.
fn read_journal(directory: &Path) -> Result<Vec<SavedFile>> {
let legacy = directory.join(LEGACY_JOURNAL);
if legacy.is_file() {
return fsx::read_json(&legacy);
}
let bytes = match fs::read(directory.join(JOURNAL)) {
Ok(bytes) => bytes,
Err(error) if error.kind() == io::ErrorKind::NotFound => return Ok(Vec::new()),
Err(error) => return Err(error.into()),
};
let mut entries: Vec<SavedFile> = Vec::new();
for line in bytes.split(|byte| *byte == b'\n') {
let Ok(record) = serde_json::from_slice::<JournalRecord>(line) else {
break;
};
match record {
JournalRecord::Saved { path, existed } => entries.push(SavedFile {
path,
existed,
moved_to: None,
}),
JournalRecord::Moved { index, to } => {
let entry = entries
.get_mut(index)
.ok_or_else(|| Error::Invalid("Invalid custom races journal.".into()))?;
entry.moved_to = Some(to);
}
JournalRecord::Returned { index } => {
let entry = entries
.get_mut(index)
.ok_or_else(|| Error::Invalid("Invalid custom races journal.".into()))?;
entry.moved_to = None;
}
}
}
Ok(entries)
}
impl<'a> PatchTransaction<'a> {
fn new(root: &'a Path) -> Result<Self> {
recover_patch_transaction(root)?;
let directory = root.join(".coa-races-transaction");
fs::create_dir(&directory)?;
let journal = fs::OpenOptions::new()
.create_new(true)
.append(true)
.open(directory.join(JOURNAL))?;
fs::create_dir(root.join(".coa-races-transaction"))?;
Ok(Self {
root,
entries: Vec::new(),
index: std::collections::HashMap::new(),
journal: Some(journal),
finished: false,
})
}
fn relative(&self, path: &Path) -> Result<String> {
fn save(&mut self, path: &Path) -> Result<()> {
let relative = path
.strip_prefix(self.root)
.map_err(|_| Error::Invalid("Patch path escaped the client directory.".into()))?
.to_string_lossy()
.replace('\\', "/");
fsx::safe_join(self.root, &relative)?;
Ok(relative)
}
fn save(&mut self, path: &Path) -> Result<()> {
let relative = self.relative(path)?;
if self.index.contains_key(&relative) {
if self.entries.iter().any(|entry| entry.path == relative) {
return Ok(());
}
let index = self.entries.len();
let existed = path.is_file();
append_record(
self.journal.as_mut().expect("open journal"),
&JournalRecord::Saved {
path: relative.clone(),
existed,
},
)?;
self.index.insert(relative.clone(), index);
self.entries.push(SavedFile {
path: relative,
existed,
existed: path.is_file(),
moved_to: None,
});
if existed {
fsx::atomic_write_json(
&self.root.join(".coa-races-transaction/journal.json"),
&self.entries,
)?;
if path.is_file() {
move_patch_file(
path,
&self
@@ -749,16 +431,21 @@ impl<'a> PatchTransaction<'a> {
// Save the destination first so recovery restores the moved source before it.
self.save(target)?;
self.save(source)?;
let index = self.index[&self.relative(source)?];
let relative = self.relative(target)?;
append_record(
self.journal.as_mut().expect("open journal"),
&JournalRecord::Moved {
index,
to: relative.clone(),
},
)?;
let index = self
.entries
.iter()
.position(|entry| self.root.join(&entry.path) == source)
.unwrap();
let relative = target
.strip_prefix(self.root)
.map_err(|_| Error::Invalid("Patch path escaped the client directory.".into()))?
.to_string_lossy()
.replace('\\', "/");
self.entries[index].moved_to = Some(relative);
fsx::atomic_write_json(
&self.root.join(".coa-races-transaction/journal.json"),
&self.entries,
)?;
fs::create_dir_all(target.parent().unwrap())?;
move_patch_file(
&self
@@ -776,8 +463,6 @@ impl<'a> PatchTransaction<'a> {
b"committed",
)?;
self.finished = true;
// Windows cannot remove a directory while a file in it is open.
self.journal = None;
fs::remove_dir_all(self.root.join(".coa-races-transaction"))?;
Ok(())
}
@@ -785,7 +470,6 @@ impl<'a> PatchTransaction<'a> {
impl Drop for PatchTransaction<'_> {
fn drop(&mut self) {
if !self.finished {
self.journal = None;
let _ = recover_patch_transaction(self.root);
}
}
@@ -796,19 +480,8 @@ fn recover_patch_transaction(root: &Path) -> Result<()> {
if !directory.is_dir() {
return Ok(());
}
if !directory.join("committed").exists() {
let legacy = directory.join(LEGACY_JOURNAL).is_file();
let mut entries = read_journal(&directory)?;
let mut journal = if legacy {
None
} else {
Some(
fs::OpenOptions::new()
.create(true)
.append(true)
.open(directory.join(JOURNAL))?,
)
};
if !directory.join("committed").exists() && directory.join("journal.json").exists() {
let mut entries: Vec<SavedFile> = fsx::read_json(&directory.join("journal.json"))?;
for index in (0..entries.len()).rev() {
let entry = &entries[index];
let path = fsx::safe_join(root, &entry.path)?;
@@ -820,10 +493,7 @@ fn recover_patch_transaction(root: &Path) -> Result<()> {
}
// Persist recovery progress before restoring the source, making retries safe.
entries[index].moved_to = None;
match journal.as_mut() {
Some(journal) => append_record(journal, &JournalRecord::Returned { index })?,
None => fsx::atomic_write_json(&directory.join(LEGACY_JOURNAL), &entries)?,
}
fsx::atomic_write_json(&directory.join("journal.json"), &entries)?;
}
let entry = &entries[index];
if saved.is_file() {
@@ -835,7 +505,6 @@ fn recover_patch_transaction(root: &Path) -> Result<()> {
fs::remove_file(path)?;
}
}
drop(journal);
}
fs::remove_dir_all(directory)?;
Ok(())
@@ -872,31 +541,6 @@ fn preserve_original(tx: &mut PatchTransaction<'_>, active: &Path) -> Result<()>
tx.copy(active, &original)
}
/// A file the previous release installed and the new one no longer ships (1.9.2's Ascension.exe, which V2
/// replaced with its own CoACustomRace.exe) is removed if it is still ours, and the player's original comes back.
fn retire_dropped_files(
tx: &mut PatchTransaction<'_>,
client: &Path,
previous: &[PatchFile],
payload: &std::collections::BTreeSet<String>,
) -> Result<()> {
for old in previous.iter().filter(|old| !payload.contains(&old.path)) {
let active = fsx::safe_join(client, &old.path)?;
if matches_patch(&active, old) {
tx.save(&active)?;
let original = suffix(&active, "original");
if original.is_file() {
tx.copy(&original, &active)?;
}
}
let disabled = suffix(&active, "disabled");
if matches_patch(&disabled, old) {
tx.save(&disabled)?;
}
}
Ok(())
}
/// Preserve launcher replacements, and switch every file owned by the package.
pub fn set_client_patch_enabled(client: &Path, enabled: bool) -> Result<()> {
if !client.is_dir() {
@@ -926,8 +570,7 @@ pub fn set_client_patch_enabled(client: &Path, enabled: bool) -> Result<()> {
let active = client.join(&file.path);
let disabled = suffix(&active, "disabled");
let original = suffix(&active, "original");
// Data the stock client never reads stays active, and an older Manager's disabled copy comes back.
if enabled || !is_switched(client, &file) {
if enabled {
if active.is_file() && !matches_patch(&active, &file) {
preserve_original(&mut tx, &active)?;
}
@@ -1024,46 +667,26 @@ fn stage_root_asset(staging: &Path, relative: &str, reader: &mut impl Read) -> R
fn archive_job(filename: &str, url: &str, cache: &Path) -> Result<crate::download::Job> {
let (size, sha256) = match filename {
"CoA-Custom-V2-Client-1.zip" => (
"CoA-Custom-1.9.2-Client-1.zip" => (
1_513_021_586,
"a9dd51ed2d90fb048d549602f40f5429d56e2df0df5606a38781b358fa369568",
),
"CoA-Custom-V2-Client-2.zip" => (
"CoA-Custom-1.9.2-Client-2.zip" => (
1_198_283_005,
"ab084a55509ccbcc2977a06dd0c01fa879973a1892baaacaeb3ff52f3dfc750e",
),
"CoA-Custom-V2-Client-3.zip" => (
1_671_130_705,
"0af34199f0739ce086adb0371d3de7c1a0f5ca9c62ecde6b0efe9286e33874a8",
"CoA-Custom-1.9.2-Client-3.zip" => (
1_678_829_573,
"907e267f0ee7038807e626c3c1eca5e12db6c88b747137a23c5fb52eaa1a358e",
),
"CoA-Custom-V2-Client-4.zip" => (
"CoA-Custom-1.9.2-Client-4.zip" => (
502_385_128,
"e0bd87172af989fa50a8e2b08ba4321c72b6265047482f051a1db3b80d55bcaa",
),
"CoA-Custom-V2-Client-5.zip" => (
"CoA-Custom-1.9.2-Client-5.zip" => (
168_079_711,
"73364ad1b58c6342641a848a3b20a835472834f600416606be1470386774ca78",
),
"CoA-Custom-V2-Client-6.zip" => (
1_881_526_537,
"91db79b7b451856fa9e45daea52e0fe1c04676653dd8a88e6627f04ee7b47759",
),
"CoA-Custom-V2-Client-7.zip" => (
734_725_114,
"4c5532d775d206a3b913a6111040bb96b95c683b74c08a6131ed9f38db8e2b39",
),
"CoA-Custom-V2-Client-8.zip" => (
734_216_670,
"bdaa1d047e8767bd5715f1e8465d116220597d9c135a43e2dda02e12ce2e5526",
),
"CoA-Custom-V2-Client-9.zip" => (
195_235_400,
"0764893543084a12d15578fe734f66ba4519740794a6b3b3a38a08594c38c640",
),
"CoA-Custom-V2-Server.zip" => (
63_983_587,
"8970d61eea40f53cea4c27481edd85d2b2647cd32eb88932e0077da3b4a77d23",
),
_ => return Err(Error::Invalid("Unknown custom races archive.".into())),
};
Ok(crate::download::Job {
@@ -1158,17 +781,6 @@ fn resolve_archive_with(
Ok(job.dest.clone())
}
/// The 1.9.2 file name of a V2 archive with the same bytes (same size and SHA-256 in both releases).
fn earlier_name(filename: &str) -> Option<&'static str> {
match filename {
"CoA-Custom-V2-Client-1.zip" => Some("CoA-Custom-1.9.2-Client-1.zip"),
"CoA-Custom-V2-Client-2.zip" => Some("CoA-Custom-1.9.2-Client-2.zip"),
"CoA-Custom-V2-Client-4.zip" => Some("CoA-Custom-1.9.2-Client-4.zip"),
"CoA-Custom-V2-Client-5.zip" => Some("CoA-Custom-1.9.2-Client-5.zip"),
_ => None,
}
}
/// Locate a verified archive or resume downloading it into the Manager's cache.
fn resolve_or_download_archive(
filename: &str,
@@ -1184,16 +796,6 @@ fn resolve_or_download_archive(
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)?;
// V2 republished four 1.9.2 archives byte for byte under new names: reuse a verified 1.9.2 copy.
if let Some(previous) = earlier_name(filename) {
for folder in [Some(cache.as_path()), downloads.as_deref()].into_iter().flatten() {
let candidate = folder.join(previous);
if archive_matches(&candidate, &job) {
tracing::info!(path = %candidate.display(), "using the identical 1.9.2 archive");
return Ok(candidate);
}
}
}
resolve_archive_with(transport, &job, downloads.as_deref(), cancel, &|p| {
let ratio = p.downloaded as f32 / p.total.max(1) as f32;
report(
@@ -1383,8 +985,6 @@ pub fn install_client_patches(
"Custom races archives are missing required runtime files.".into(),
));
}
let payload_paths: std::collections::BTreeSet<String> =
payload.iter().map(|file| file.path.clone()).collect();
let previous = patch_files(client_path)?;
let mut tx = PatchTransaction::new(client_path)?;
for file in payload {
@@ -1417,7 +1017,6 @@ pub fn install_client_patches(
}
}
}
retire_dropped_files(&mut tx, client_path, &previous, &payload_paths)?;
tx.save(&manifest_path)?;
fsx::atomic_write(&manifest_path, manifest_body.as_bytes())?;
tx.finish()?;
@@ -1566,7 +1165,6 @@ mod tests {
("ADDON", base)
} else {
name.strip_prefix("Data/")
.filter(|base| !base.contains('/'))
.map_or(("ROOT", *name), |base| ("MPQ", base))
};
manifest.push_str(&format!(
@@ -1577,165 +1175,6 @@ mod tests {
fs::write(root.join(MANIFEST_FILENAME), manifest).unwrap();
}
const SWITCHED: &[&str] = &[
"Data/patch-ZE1.MPQ",
"dinput8.dll",
"CoACustomRace.exe",
"Start-CoACustomRace.bat",
"Interface/AddOns/CoAHideArmor/CoAHideArmor.lua",
];
const INERT: &[&str] = &[
"Data/Retail/Cache/Retail/wow/decoded/2/strict/id-1.bin",
"Data/Retail/RetailCasc.ini",
"VulkanShaders/a.spv",
"Vulkan/d3d9.dll",
"forever_data/hd_forever_fog.txt",
"EsteriaAppearance.bin",
];
fn client_with(root: &Path, names: &[&str]) {
for name in names {
let path = root.join(name);
fs::create_dir_all(path.parent().unwrap()).unwrap();
fs::write(&path, format!("custom {name}")).unwrap();
}
record_files(root, names);
}
#[test]
fn disabling_hides_only_what_the_stock_client_loads() {
let temp = tempfile::tempdir().unwrap();
let root = temp.path();
let all: Vec<&str> = SWITCHED.iter().chain(INERT).copied().collect();
client_with(root, &all);
set_client_patch_enabled(root, false).unwrap();
for name in SWITCHED {
assert!(!root.join(name).exists(), "{name} stays active");
assert!(suffix(&root.join(name), "disabled").is_file(), "{name}");
}
for name in INERT {
assert!(root.join(name).is_file(), "{name} was moved");
assert!(!suffix(&root.join(name), "disabled").exists(), "{name}");
}
assert_eq!(client_patch_status(root).state, ClientPatchState::Disabled);
set_client_patch_enabled(root, true).unwrap();
assert_eq!(client_patch_status(root).state, ClientPatchState::Enabled);
for name in &all {
assert!(root.join(name).is_file(), "{name}");
}
}
#[test]
fn a_file_that_replaced_the_players_own_is_still_switched() {
let temp = tempfile::tempdir().unwrap();
let root = temp.path();
let name = "Data/Retail/RetailCasc.ini";
client_with(root, &[name]);
fs::write(suffix(&root.join(name), "original"), b"player").unwrap();
set_client_patch_enabled(root, false).unwrap();
assert_eq!(fs::read(root.join(name)).unwrap(), b"player");
assert!(suffix(&root.join(name), "disabled").is_file());
assert_eq!(client_patch_status(root).state, ClientPatchState::Disabled);
}
#[test]
fn a_client_disabled_by_an_older_manager_is_disabled_and_enables() {
let temp = tempfile::tempdir().unwrap();
let root = temp.path();
let all: Vec<&str> = SWITCHED.iter().chain(INERT).copied().collect();
client_with(root, &all);
// 0.9.13 renamed every file of the payload.
for name in &all {
fs::rename(root.join(name), suffix(&root.join(name), "disabled")).unwrap();
}
assert_eq!(client_patch_status(root).state, ClientPatchState::Disabled);
set_client_patch_enabled(root, false).unwrap();
for name in INERT {
assert!(root.join(name).is_file(), "{name} not restored");
}
assert_eq!(client_patch_status(root).state, ClientPatchState::Disabled);
set_client_patch_enabled(root, true).unwrap();
assert_eq!(client_patch_status(root).state, ClientPatchState::Enabled);
}
#[test]
fn a_transaction_left_by_an_older_manager_is_recovered() {
let temp = tempfile::tempdir().unwrap();
let root = temp.path();
let directory = root.join(".coa-races-transaction");
fs::create_dir(&directory).unwrap();
// The source was moved into the journal and then on to its destination when the old Manager stopped.
fs::write(root.join("patch.MPQ.disabled"), b"patch bytes").unwrap();
fs::write(
directory.join(LEGACY_JOURNAL),
r#"[{"path":"patch.MPQ.disabled","existed":false},{"path":"patch.MPQ","existed":true,"moved_to":"patch.MPQ.disabled"}]"#,
)
.unwrap();
recover_patch_transaction(root).unwrap();
assert_eq!(fs::read(root.join("patch.MPQ")).unwrap(), b"patch bytes");
assert!(!root.join("patch.MPQ.disabled").exists());
assert!(!directory.exists());
}
#[test]
fn a_journal_line_cut_short_by_a_crash_is_ignored() {
let temp = tempfile::tempdir().unwrap();
let root = temp.path();
let file = root.join("dinput8.dll");
fs::write(&file, b"previous").unwrap();
let mut tx = PatchTransaction::new(root).unwrap();
tx.save(&file).unwrap();
fs::write(&file, b"replacement").unwrap();
drop(tx.journal.take());
std::mem::forget(tx);
let journal = root.join(".coa-races-transaction").join(JOURNAL);
let mut bytes = fs::read(&journal).unwrap();
bytes.extend_from_slice(br#"{"saved":{"path":"other.dll","exi"#);
fs::write(&journal, bytes).unwrap();
recover_patch_transaction(root).unwrap();
assert_eq!(fs::read(&file).unwrap(), b"previous");
assert!(!root.join(".coa-races-transaction").exists());
}
#[test]
fn switching_a_release_sized_payload_takes_seconds() {
let temp = tempfile::tempdir().unwrap();
let root = temp.path();
let mut names: Vec<String> = (0..7000)
.map(|i| format!("VulkanShaders/shader-{i}.spv"))
.collect();
names.extend((0..80).map(|i| format!("Data/patch-Z{i}.MPQ")));
names.extend((0..140).map(|i| format!("Interface/AddOns/Addon{}/file{i}.lua", i % 9)));
let names: Vec<&str> = names.iter().map(String::as_str).collect();
client_with(root, &names);
let started = std::time::Instant::now();
set_client_patch_enabled(root, false).unwrap();
set_client_patch_enabled(root, true).unwrap();
let elapsed = started.elapsed();
assert_eq!(client_patch_status(root).state, ClientPatchState::Enabled);
// 0.9.13 needed minutes here: it moved every file and rewrote the whole journal after each one.
assert!(elapsed < std::time::Duration::from_secs(60), "{elapsed:?}");
}
#[test]
fn an_update_retires_files_the_new_release_no_longer_ships() {
let temp = tempfile::tempdir().unwrap();
let root = temp.path();
fs::write(root.join("Ascension.exe"), b"1.9.2 client").unwrap();
fs::write(root.join("Ascension.exe.original"), b"player's own client").unwrap();
fs::write(root.join("Wow.exe"), b"changed by the player").unwrap();
let ours = |path: &str, bytes: &[u8]| PatchFile {
path: path.into(),
sha256: hex::encode(<sha2::Sha256 as sha2::Digest>::digest(bytes)),
};
let previous = vec![ours("Ascension.exe", b"1.9.2 client"), ours("Wow.exe", b"old package bytes")];
let mut tx = PatchTransaction::new(root).unwrap();
retire_dropped_files(&mut tx, root, &previous, &Default::default()).unwrap();
tx.finish().unwrap();
assert_eq!(fs::read(root.join("Ascension.exe")).unwrap(), b"player's own client");
assert_eq!(fs::read(root.join("Wow.exe")).unwrap(), b"changed by the player");
}
#[test]
#[ignore = "Requires the downloaded release archives"]
fn bundled_hashes_match_verified_release_archives() {
@@ -1787,28 +1226,6 @@ mod tests {
assert_eq!(actual, expected);
}
#[test]
#[ignore = "Requires COA_UPGRADE_CLIENT: a disposable client with 1.9.2 installed by Manager 0.9.12"]
fn an_installed_1_9_2_client_updates_to_v2_and_gets_its_own_executable_back() {
let root = PathBuf::from(std::env::var_os("COA_UPGRADE_CLIENT").expect("COA_UPGRADE_CLIENT"));
assert_eq!(client_patch_status(&root).version.as_deref(), Some("1.9.2"));
let patched = fs::read(root.join("Ascension.exe")).unwrap();
let original = fs::read(root.join("Ascension.exe.original")).unwrap();
assert_ne!(patched, original);
install_client_patches(&root, &Cancel::default(), &|_, _| {}).unwrap();
let status = client_patch_status(&root);
assert_eq!(status.version.as_deref(), Some(CLIENT_VERSION));
assert_eq!(status.state, ClientPatchState::Enabled);
assert!(root.join("CoACustomRace.exe").is_file());
assert!(root.join("Data/patch-ZZZZZY.MPQ").is_file());
// 1.9.2's patched Ascension.exe is retired and the player's own executable is back.
assert_eq!(fs::read(root.join("Ascension.exe")).unwrap(), original);
uninstall_client_patches(&root).unwrap();
assert_eq!(client_patch_status(&root).state, ClientPatchState::NotInstalled);
assert_eq!(fs::read(root.join("Ascension.exe")).unwrap(), original);
assert!(!root.join("CoACustomRace.exe").exists());
}
#[test]
#[ignore = "Requires the downloaded release archives in the normal download cache"]
fn release_archives_install_toggle_and_uninstall_in_a_disposable_client() {
@@ -1826,30 +1243,8 @@ mod tests {
assert!(root
.join("Interface/AddOns/CoAHideArmor/CoAHideArmor.lua")
.is_file());
// V2: its own client next to the untouched game executable, and the server package's addons.
assert!(root.join("CoACustomRace.exe").is_file());
assert!(root.join("Vulkan/d3d9.dll").is_file());
assert_eq!(fs::read(root.join("Ascension.exe")).unwrap(), b"original game executable");
assert!(root
.join("Interface/AddOns/Ascension_Subclass")
.is_dir());
let started = std::time::Instant::now();
set_client_patch_enabled(root, false).unwrap();
eprintln!("disable took {:?}", started.elapsed());
assert_eq!(client_patch_status(root).state, ClientPatchState::Disabled);
// Only what the stock client loads is hidden; the data its executable alone reads stays put.
assert!(!root.join("CoACustomRace.exe").exists());
assert!(!root.join("dinput8.dll").exists());
assert!(!root.join("Data/patch-ZZZD.MPQ").exists());
assert!(!root.join("Interface/AddOns/CoAHideArmor/CoAHideArmor.lua").exists());
assert!(root.join("Vulkan/d3d9.dll").is_file());
assert!(root.join("Data/Retail/RetailCasc.ini").is_file());
let hidden = patch_files(root)
.unwrap()
.iter()
.filter(|file| suffix(&root.join(&file.path), "disabled").is_file())
.count();
eprintln!("hidden {hidden} of {}", patch_files(root).unwrap().len());
assert_eq!(
fs::read(root.join("Ascension.exe")).unwrap(),
b"original game executable"
@@ -1858,9 +1253,7 @@ mod tests {
fs::read(root.join("Data/patch-T.MPQ")).unwrap(),
b"original game patch"
);
let started = std::time::Instant::now();
set_client_patch_enabled(root, true).unwrap();
eprintln!("enable took {:?}", started.elapsed());
assert_eq!(client_patch_status(root).state, ClientPatchState::Enabled);
uninstall_client_patches(root).unwrap();
assert_eq!(
@@ -1880,7 +1273,6 @@ mod tests {
b"unrelated user patch"
);
assert!(!root.join("Data/patch-ZZZD.MPQ").exists());
assert!(!root.join("CoACustomRace.exe").exists());
}
#[test]
@@ -1925,10 +1317,7 @@ mod tests {
);
assert_ne!(legacy["Data/patch-T.MPQ"], current["Data/patch-T.MPQ"]);
assert!(!files.iter().any(|file| file.path == "Data/patch-ZZW.MPQ"));
assert!(legacy
.keys()
.filter(|key| !RETIRED_FILES.contains(&key.as_str()))
.all(|key| current.contains_key(key)));
assert!(legacy.keys().all(|key| current.contains_key(key)));
}
#[test]
@@ -1944,10 +1333,7 @@ mod tests {
for file in files {
assert_eq!(file.sha256, legacy[&file.path]);
}
assert!(legacy
.keys()
.filter(|key| !RETIRED_FILES.contains(&key.as_str()))
.all(|key| current.contains_key(key)));
assert!(legacy.keys().all(|path| current.contains_key(path)));
assert!(!legacy.contains_key("Data/patch-ZZZD.MPQ"));
assert!(current.contains_key("Data/patch-ZZZD.MPQ"));
let status = client_patch_status(temp.path());
File diff suppressed because it is too large. Load diff
@@ -1,116 +0,0 @@
{
"Ascension.exe": "e2c347019d554a59639e5978fd68e50e906973ab313c6573cc56ca82e8e3c547",
"Data/Retail/Assets/EquipmentFitting/1068-1.bin": "332d2c38b037a118f262bbb3096a01ebfb33c5347e96bbfb64157437b300281b",
"Data/Retail/Assets/EquipmentFitting/60-0.bin": "ffbf6efc9ea09b0c442f048c5bc7b4c5975258045cfddedd9a77a93363312b5e",
"Data/Retail/Assets/EquipmentFitting/60-1.bin": "36ceed2a55756f3322e018938809acea5124351161405058ef27d100173778da",
"Data/Retail/Assets/EquipmentFitting/61-0.bin": "3b302a4055d1e795c451b02e38dfe8007527ee1bc5f926ebcd6ef17f433cd232",
"Data/Retail/Assets/EquipmentFitting/61-1.bin": "c42df399ed99be3c7ce1b5fdb95a873711011713a4cd867bc226a14b1ce0e8ca",
"Data/Retail/Assets/EquipmentFitting/65-0.bin": "8ce3f884ae197d14dff0f955c2cf05abb716742c8aff79f7af1cec5cf7225f04",
"Data/Retail/Assets/EquipmentFitting/68-0.bin": "f1d878f0f943cbdb8025af8daac4a38c1d1e159bd961d9d76f225931c11648ac",
"Data/Retail/Assets/EquipmentFitting/68-1.bin": "2ccbae634384200340c0cc3dca36a7a014a8ddad110598e4470ff1b266576465",
"Data/Retail/Assets/EquipmentFitting/73-0.bin": "5530882678f677ad47987ce906e851338a35f7d9737e3f9d829938027b8af67f",
"Data/Retail/Assets/EquipmentFitting/74-0.bin": "53a7be86b3bfdd6995406c706df3ca091484206d8141cebb39113c714500384a",
"Data/Retail/Assets/EquipmentFitting/74-1.bin": "e688c55a355231978d42480a003c26d379460f5931c2469c119ecb073ea153e1",
"Data/Retail/Assets/EquipmentFitting/75-0.bin": "289abc71c6df0e031a64d62a40e658eaefd37e45373a062ca52f08fbe803500c",
"Data/Retail/Assets/EquipmentFitting/76-0.bin": "63a493e70b91f59ff49f1942d959df986062bd267fe2ba589f344963df771021",
"Data/Retail/Assets/EquipmentFitting/77-0.bin": "b1366ce0dc4f31cb8c8c9705be2da565df4b905224af04b6b88f8c8e9c87e3c9",
"Data/Retail/Assets/EquipmentFitting/78-0.bin": "7b0031fb12ab19020005bdccacca2dd3991349c36949a58b035992585b4134db",
"Data/patch-T.MPQ": "fe597138ab7f56881b5f4f27d6dc9d81bb278b483ca0d91b7207ffd4a5ae7bfd",
"Data/patch-ZE1.MPQ": "69d79dbbea54ec0312c37770debc79c7bc9ce2e21eedef99c03cd8d911955283",
"Data/patch-ZE2.MPQ": "1a41cae77ad730e9cf69e8d63fd12ae3a579418bb550d351fff469573a97ac3c",
"Data/patch-ZE3.MPQ": "b587202c21b6f580682b601b7c2e905fbfa766276e74733db55c1bddbffb7f87",
"Data/patch-ZE5.MPQ": "476b5a1fcf69f64fdb281e3b445362b936d016066ccd12f897acfcf200d6c0cf",
"Data/patch-ZE6.MPQ": "762592c9ed950b4a7b6c7d85d45050b30fa3f35d53e348ee1e1516fdbb7e5484",
"Data/patch-ZE7.MPQ": "de54b0189d242763d2872223419a259b6b8a4b380c24b50a2ef9c6fa44466248",
"Data/patch-ZE8.MPQ": "1bc5691fb84a84f3e7a0a70baaa9192a97b4ec5906ee37c85838ffe08adef934",
"Data/patch-ZE9.MPQ": "d49c94463e9548e76378ce2c0454d8f204f0745c8c0de32b6dce7f0b0fd67c4a",
"Data/patch-ZEA.MPQ": "78fd10ec5262ae2417eba9700d2172553bbc1e5cfb0b597aada8f1753ca46d9d",
"Data/patch-ZES.MPQ": "a2d9348f917f745c7aa25b2eed96efa312f7b2d2f62cb86a4f2eaabc2dfa895f",
"Data/patch-ZG.MPQ": "48979e1fda775f8deb47bffa48e0a468595d4c71286fee518f51dc5801c5ca39",
"Data/patch-ZH.MPQ": "5e1d2fe287053abba703d7af381e10096c6525ba477ffed3971c2fc4f93e919c",
"Data/patch-ZHA.MPQ": "0fc6ebeafe1d14192dc64bafc90bde3c49230df1297f98bf65900a3bcf953617",
"Data/patch-ZHM.MPQ": "317d3ae00f0bd674b358af07544976acb7804aa6d8b19d1788ad96030e8c9bf0",
"Data/patch-ZJ.MPQ": "f821e99add86ef68d108c5ec466328c97677d3ed52f7944e200f3fe38c13b4de",
"Data/patch-ZK.MPQ": "444d0ecb72c1e990509d53e3cfa5b7634c816733533e8a97e5d7f5653ee32cce",
"Data/patch-ZM.MPQ": "424ab1978986e854551633983a94bd15beba6328aabea8c02f98eaa32f6f0b61",
"Data/patch-ZVU.MPQ": "c679b85a2e97344395756b54d2cf6abefe4e80e74944cb55b6e573ad17b7d020",
"Data/patch-ZZE.MPQ": "4b1e289e12c82644cb78f50170e6b5fd53918eb2de834f9e0cebddd81873a8bb",
"Data/patch-ZZR.MPQ": "5a7575e592dc0c8a6913e0d946bbe06fa0ca2e4d817ef1f8548d3d13142bcbd3",
"Data/patch-ZZS.MPQ": "533fd69d5784d83e872a5a28d27301dc9ab5d0cb925f8b2116926854e4a0a5b8",
"Data/patch-ZZT.MPQ": "e60dab63fe5650fdf5f0846ea6d4136219293bcfdad46d9b796697faeff9ab4c",
"Data/patch-ZZU.MPQ": "0311de8f034eae7dec1bd2c92b1fe6c741cbaf53da62c7609cd12b6c37908e47",
"Data/patch-ZZV.MPQ": "3b04008905e7185d165827d68f7ca228dda8272816364f7d71874ecc83b64f0e",
"Data/patch-ZZW.MPQ": "3bbbc72901fd2d662113036485c380701e693f5a39ba9479af306bf2fa2030bd",
"Data/patch-ZZX.MPQ": "4c12608089cfe356f7c8882d66db90239ed3ec8ddd980d91d7a3a488680f3c88",
"Data/patch-ZZZ.MPQ": "566aaadf501af42e29a828b1bc2edbd36d436288fb309fe423bd74b9619bf593",
"Data/patch-ZZZA.MPQ": "57ccbdc0a66000767554ffd194088df6d602ddd8341a141bca8201e7d5435889",
"Data/patch-ZZZC.MPQ": "691a53f6325c2615a64ced0802f18bc4d96e99c62aaa606fc930f9406ee74cdf",
"Data/patch-ZZZD.MPQ": "ca893cf8129f6fd442a63f0697a8ddea88546e3ce71bde713be2cc832b892bc9",
"Data/patch-ZZZE.MPQ": "2e245ee0fe3b913087eed399062fda5843d98b04afac38024f7c64ac3bf43e18",
"Data/patch-ZZZF.MPQ": "40eac695cfcafb598b8376f3b9a61ecc037e4d445b87279cfe387a91edad32c3",
"Data/patch-ZZZZ.MPQ": "860c990db3b4185fdc36e1a001d3ca3507a68253a4506793a115f86eb0892a15",
"EsteriaAppearance.bin": "90d9cfaeaf6de10f014f1d1610ea10453ec9b240255759aea99513cac488a3ec",
"EsteriaAppearance.dll": "88e268d3be9eca3b0644f543d823f4bdcc04a9700a6e8ed73fd2a1260ad191af",
"EsteriaAppearanceGeometry.bin": "19de5b4b4f79778ea5316659efc2f66c6edb6b5149c46efa47c46bfa4ec6904c",
"EsteriaAppearanceMaterials.bin": "f72f027f54a55c05aa0f76b457b97b484fe0e1aedc0e068cc0e0ca53e1878cba",
"EsteriaBanshee.bin": "d3fe66caa6a0ecba96bddb07ac1cbdb915694e87fc1608da0fdabecdf9ffea4d",
"EsteriaBansheeTextures.bin": "837774377ca055e6a5c79c1a4cfd8151e7c1f7ce2c16990b00fd445281137433",
"EsteriaCentaur.bin": "d63f0b7d21cee67d234d134e832fe6d55c398f2b63f9f6c191dcfa9671637185",
"EsteriaCentaurTextures.bin": "837774377ca055e6a5c79c1a4cfd8151e7c1f7ce2c16990b00fd445281137433",
"EsteriaCosmeticWings.bin": "57352c28459d073a29b3014d33b70f3b3756afa37fa9583ef6b30d503422ac3f",
"EsteriaDrakonid.bin": "95440ee9c065ef20bb7fed6158d20623d68745291cedc2726fc746ff54601f95",
"EsteriaDrakonidCoverage.bin": "9cdc227f08329e1245d2b864a996e7a772c96ecdbe5d81925f4d60cdbe4fa11e",
"EsteriaDrakonidTextures.bin": "1ba9133a75dad291d98a068b2dcde01f31a897a1764cd7f3e2c316c288a8f605",
"EsteriaEarthen.bin": "8a0db93ba2d5c756b44ed84f2f7bc7c15eef13be6a7d87baf1383c6c0c624e02",
"EsteriaEthereal.bin": "ada3b7588511a847dd5154d91e3041e9f7f193998b06bfede5e0afc32570b48c",
"EsteriaEtherealTextures.bin": "837774377ca055e6a5c79c1a4cfd8151e7c1f7ce2c16990b00fd445281137433",
"EsteriaFaceless.bin": "1c5a1d7a6b1db6984a8e41bc4804e9f7c50d65dcdbb8c0a9d1a9e8af8c91bd8f",
"EsteriaFacelessTextures.bin": "837774377ca055e6a5c79c1a4cfd8151e7c1f7ce2c16990b00fd445281137433",
"EsteriaGnoll.bin": "cfacc8e681bb8e54a4f01ee9c12a91bf0bd23a23527bb548d4dc21ec1b33eea2",
"EsteriaGnollTextures.bin": "1ba9133a75dad291d98a068b2dcde01f31a897a1764cd7f3e2c316c288a8f605",
"EsteriaHaranir.bin": "59f31d00e372fd2646e1cf0d9d3d5d671b31edd60ff7b862f8d1ce7e53ba1f2f",
"EsteriaHaranirTextures.bin": "99948ca570be2d376f0c67e3b8088739b6fa9f9d2c73985e19f68df77689a229",
"EsteriaHighmountain.bin": "e83349252ad2687ac23fcfc5623db7401cf32e5faf47a5a7be20c2f94b014938",
"EsteriaHozen.bin": "739bc3775388976f5c09bcbf3a98b62d804dff78d545e25a41d07dd99b5fddc5",
"EsteriaHozenTextures.bin": "837774377ca055e6a5c79c1a4cfd8151e7c1f7ce2c16990b00fd445281137433",
"EsteriaKvItems.bin": "fc5f9d86114234b38dbb0e14a6a5ec16249eaa92a73411a7fc371a950549dcce",
"EsteriaKvSkins.bin": "60b2b899f5f83137368514928f92f3b04c0fae058f534c487ddbe913ee4bec18",
"EsteriaKyrian.bin": "9329147f08805ff4003f9e062fea7c6ea8fdd8c4d6a40de63a6d228ebe1b7c9a",
"EsteriaKyrianTextures.bin": "837774377ca055e6a5c79c1a4cfd8151e7c1f7ce2c16990b00fd445281137433",
"EsteriaMantid.bin": "71536dee6c2abd0b0e13f33bc73cad7e6fb1b0fc1f6912a95c55d57bc7ee1787",
"EsteriaMantidTextures.bin": "837774377ca055e6a5c79c1a4cfd8151e7c1f7ce2c16990b00fd445281137433",
"EsteriaNaga.bin": "e87547cff5d09500c294f8b06935d134cdd0bbb962e294a72de09404505bd8b3",
"EsteriaNagaTextures.bin": "57ec560f99c1d48ac1e8f6a797c156513b99e7d349e3071afe405f812d159ae3",
"EsteriaSaberon.bin": "7735c9325c807c5125760d87f323d6b7d4162fb542c1d8b5f435ea2d6b9a4daa",
"EsteriaSaberonCoverage.bin": "9cdc227f08329e1245d2b864a996e7a772c96ecdbe5d81925f4d60cdbe4fa11e",
"EsteriaSaberonTextures.bin": "1ba9133a75dad291d98a068b2dcde01f31a897a1764cd7f3e2c316c288a8f605",
"EsteriaSethrak.bin": "bd14857a8c11fdf8027128763293701586b2102f9a6539d33a727014789fd606",
"EsteriaSethrakTextures.bin": "d2b2cf58087a391f00198008fe871edd400ddf28d54a3a05674df74c5198528a",
"EsteriaSlime.bin": "491e942ceb6abda83c0249afebae7c9c43af3897b35e45fa33d6f9177ecbc177",
"EsteriaSlimeTextures.bin": "837774377ca055e6a5c79c1a4cfd8151e7c1f7ce2c16990b00fd445281137433",
"EsteriaTarasek.bin": "f718444d5ec36f7aff018883486ae1981151fe6e01f5b7781d68d74e9fadfa47",
"EsteriaTarasekTextures.bin": "1ba9133a75dad291d98a068b2dcde01f31a897a1764cd7f3e2c316c288a8f605",
"EsteriaThinHuman.bin": "bc12e5ca2c087ca0a8642ff6cd8e78fe2e1f85928518b12c19b4245a8320585d",
"EsteriaThinHumanTextures.bin": "27488a7494fa9733b53118d1d0f4acef50a9e19004f81f9c8a614b10f4c3fd5e",
"EsteriaTuskarr.bin": "ecbe7ef490ba67eca029a57639192db61238522618491549766fe38529914387",
"EsteriaTuskarrTextures.bin": "e2116c2c83adea079126fd5da765d20da24f044d4f161c4124e4368cb3d6bc71",
"EsteriaVenthyr.bin": "5bcf7804363e59b3c922830d06de17bbd348b9967307f39b7d72bc09f58814eb",
"EsteriaVenthyrTextures.bin": "837774377ca055e6a5c79c1a4cfd8151e7c1f7ce2c16990b00fd445281137433",
"EsteriaVorkai.bin": "d6d2088c7e867b5db437e9afc2d323c22d830c6f84a3598415eedcaa27e2461f",
"EsteriaVorkaiTextures.bin": "837774377ca055e6a5c79c1a4cfd8151e7c1f7ce2c16990b00fd445281137433",
"EsteriaVrykul.bin": "39e2b7b4c67997dbbd34bae840bd606a59290f7f2fc82565a0ba00090335415c",
"EsteriaVrykulTextures.bin": "46098750a0e235724c6e9cc8d9d4e26550aa47bef95fd5f0f82efe5e945bf296",
"EsteriaVulpera.bin": "c5434993b9af4a17d881965e4735cd2ac379e39c7142aac9844adff9528562d4",
"EsteriaVulperaTextures.bin": "1ab844e74684aced2b069f1b91cd563aade45e05bd5e23f866a6c0c301cb098e",
"Interface/AddOns/CoAHideArmor/CoAHideArmor.lua": "8c1c7403524fc9bd56c0809b4101b141da700ba163701209bf1420f2ef106aa7",
"Interface/AddOns/CoAHideArmor/CoAHideArmor.toc": "123580d92fd5ceee258e96296f42c359b7e83cdff151af49c50c6c4e2059677c",
"Interface/AddOns/CoAQuestSafe/CoAQuestSafe.lua": "062de55c91228971553f482fd2c8753f4752993b4e8e49d4ded04fa18b98bde7",
"Interface/AddOns/CoAQuestSafe/CoAQuestSafe.toc": "890bb9d1087e236f4823603f5df3ab0e316dbb65c28feebbda08fb0ab53a408f",
"Interface/AddOns/CoAWC2Cursor/CoAWC2Cursor.lua": "1cf9537ff5f10b77250fea4407aea1008da690afe102ed6ed2dac21f79638cfa",
"Interface/AddOns/CoAWC2Cursor/CoAWC2Cursor.toc": "48ce695dce712b3643ebe13a77e318d623c964acc69479b8fc8cc675099801bf",
"Interface/AddOns/CoA_TalentReset/CoA_TalentReset.lua": "827d756d5948ef918fafaf8b869290b3a1faa4e4cc21b19b512a00d4509f3d41",
"Interface/AddOns/CoA_TalentReset/CoA_TalentReset.toc": "16298c04af68e68d6445e7a11f42aee525dd4145f85d2771ff434fb7c6e95a85",
"dinput8.dll": "f8de78606c241fb3911dce22faf68f5b9f9885b142b183c1e2c09ddc8f7e380c",
"wc2_human.cur": "f609736e29596bb386ef1597b157d211e01a86d32c2a929e256c581c37d71791",
"wc2_orc.cur": "baa512c9b9045762ba35b6e0d35b8f79c54b7649f35cc9c0e0cc8c168a1e5a97"
}
+54 -308
View File
@@ -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 <verb>`), 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::<String>::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<PathBuf> {
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<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;
}
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::<u8>::new()).unwrap();
std::fs::write(state.join("world.json"), "{\"pid\": 4}\n").unwrap();
std::fs::write(state.join("stop-relay"), Vec::<u8>::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);
}
}
+4
View File
@@ -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,
+24
View File
@@ -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/<service>.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;
+88
View File
@@ -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> {
[
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(())
}
+493
View File
@@ -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 `<key>.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<u64, Failure>;
}
/// 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<ReportService> {
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::<i64>().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<serde_json::Map<String, serde_json::Value>> {
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<String, serde_json::Value>) -> std::result::Result<u64, Failure> {
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<u64, Failure> {
let field = |data: &serde_json::Map<String, serde_json::Value>, 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<u64, Failure> {
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<title>\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());
}
}
+271
View File
@@ -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()));
}
}
+571
View File
@@ -0,0 +1,571 @@
//! Starting, checking and stopping the services of one repack: MySQL, authserver, worldserver
//! (`manage.py start_mysql`, `start_auth`, `stop_all` and their helpers), with the same rules.
use std::net::{SocketAddr, TcpStream};
use std::path::{Path, PathBuf};
use std::process::{Command, Stdio};
use std::time::{Duration, Instant};
use crate::error::{Error, ErrorCode, Result};
use crate::launcher::{settings::Settings, state};
use crate::process::ProcessIdentity;
pub type Progress<'a> = &'a dyn Fn(&str);
const CREATE_NO_WINDOW: u32 = 0x0800_0000;
const CREATE_NEW_PROCESS_GROUP: u32 = 0x0000_0200;
fn hidden(cmd: &mut Command) -> &mut Command {
#[cfg(windows)]
{
use std::os::windows::process::CommandExt;
cmd.creation_flags(CREATE_NO_WINDOW | CREATE_NEW_PROCESS_GROUP);
}
cmd
}
/// Start `exe` with its output appended to `log`, and record it as `name`. `env_remove` are variables of this
/// process the service must not see.
pub fn spawn(root: &Path, name: &str, exe: &Path, args: &[&str], cwd: &Path, log: &Path, env_remove: &[String]) -> Result<ProcessIdentity> {
let child = crate::launcher::spawn::start(exe, args, cwd, log, env_remove)?;
state::record(root, name, child.pid)
}
// ---------------------------------------------------------------------------------------------------------------
// Ports
// ---------------------------------------------------------------------------------------------------------------
/// Wait (up to 30 s) until `port` can be bound by a new server. A port with a listening owner is refused at
/// once; a port Windows still holds for a stopped process (a PID-zero row) is waited for. The test bind is
/// exclusive (`SO_EXCLUSIVEADDRUSE`), never a shared one.
pub fn ensure_free(port: u16, progress: Progress) -> Result<()> {
let deadline = Instant::now() + Duration::from_secs(30);
let mut announced = false;
loop {
let mut owners: Vec<u32> = sys::tcp_rows_v4()
.into_iter()
.filter(|r| r.state == sys::LISTEN && r.local_port == port)
.map(|r| r.pid)
.collect();
owners.sort_unstable();
owners.dedup();
if owners.iter().any(|p| *p != 0) {
let list: Vec<String> = owners.iter().map(u32::to_string).collect();
return Err(Error::Service(
ErrorCode::PortInUse,
format!("Port {port} is already used (PID {}). Stop the other server or change Settings/repack.json.", list.join(", ")),
));
}
match sys::exclusive_bind(port) {
Ok(()) => return Ok(()),
Err(code) if code == 10013 || code == 10048 => {
if Instant::now() >= deadline {
return Err(Error::Invalid(format!(
"Port {port} remains unavailable after 30 seconds (Windows bind error {code}). No process was stopped. Retry after the previous database shutdown has finished, or check the Windows port reservation."
)));
}
if !announced {
progress(&format!("Waiting for Windows to release port {port}..."));
announced = true;
}
std::thread::sleep(Duration::from_millis(250));
}
Err(code) => return Err(Error::Invalid(format!("Port {port} cannot be checked (Windows error {code})."))),
}
}
}
/// Is the recorded process of `name` serving `port`? Its listener row is the evidence; when a system does not
/// show the owner of a listener, the server side of a fresh loopback connection is (never for MySQL, whose
/// listener has always been visible and which should not get stray connections).
pub fn ready(root: &Path, name: &str, port: u16) -> bool {
let Some(record) = state::running(root, name) else { return false };
let listening = sys::tcp_rows_v4().iter().any(|r| r.state == sys::LISTEN && r.local_port == port && r.pid == record.pid);
if listening {
return crate::process::is_alive(&record);
}
if name == "mysql" {
return false;
}
accepted_by(port, record.pid) && crate::process::is_alive(&record)
}
/// Connect to 127.0.0.1:`port` and check that exactly one established server-side row, owned by `pid`, answers
/// that connection.
fn accepted_by(port: u16, pid: u32) -> bool {
let addr: SocketAddr = ([127, 0, 0, 1], port).into();
let Ok(client) = TcpStream::connect_timeout(&addr, Duration::from_millis(500)) else { return false };
let Ok(mine) = client.local_addr().map(|a| a.port()) else { return false };
let me = std::process::id();
let rows: Vec<sys::TcpRow> = sys::tcp_rows_v4()
.into_iter()
.chain(sys::tcp_rows_v6())
.filter(|r| r.remote_port == mine && r.remote_loopback && !(r.local_port == mine && r.pid == me))
.collect();
rows.len() == 1 && rows[0].state == sys::ESTABLISHED && rows[0].pid == pid
}
pub fn wait_ready(root: &Path, name: &str, port: u16, seconds: u64) -> Result<()> {
let until = Instant::now() + Duration::from_secs(seconds);
while Instant::now() < until {
if ready(root, name, port) {
return Ok(());
}
if state::running(root, name).is_none() {
return Err(Error::Service(ErrorCode::StartupFailed, format!("{name} stopped during startup. Check its log.")));
}
std::thread::sleep(Duration::from_millis(500));
}
Err(Error::Service(
ErrorCode::StartupFailed,
format!("{name} is still starting: its expected TCP listener on port {port} was not found; check its log."),
))
}
// ---------------------------------------------------------------------------------------------------------------
// MySQL client
// ---------------------------------------------------------------------------------------------------------------
/// Run SQL (or a `mysqladmin` command) with the repack's own client and administrator login.
pub fn mysql(root: &Path, sql: Option<&str>, admin: Option<&str>) -> Result<String> {
let exe = root.join(if admin.is_some() { "mysql/bin/mysqladmin.exe" } else { "mysql/bin/mysql.exe" });
let defaults = format!("--defaults-file={}", root.join("mysql/admin-client.ini").display());
let mut cmd = Command::new(exe);
hidden(&mut cmd).arg(defaults);
match admin {
Some(a) => cmd.arg(a),
None => cmd.args(["--batch", "--skip-column-names"]),
};
let payload = sql.map(|s| s.as_bytes().to_vec());
let timeout = if payload.as_ref().is_some_and(|p| p.len() > 1024 * 1024) { 900 } else { 90 };
cmd.stdin(if payload.is_some() { Stdio::piped() } else { Stdio::null() }).stdout(Stdio::piped()).stderr(Stdio::piped());
let mut child = cmd.spawn()?;
if let (Some(data), Some(mut stdin)) = (payload, child.stdin.take()) {
std::thread::spawn(move || {
use std::io::Write;
let _ = stdin.write_all(&data);
});
}
// Both outputs are read while the client runs: a full pipe would stop it (and look like a timeout).
let read = |pipe: Option<Box<dyn std::io::Read + Send>>| {
std::thread::spawn(move || {
let mut buf = Vec::new();
if let Some(mut p) = pipe {
let _ = p.read_to_end(&mut buf);
}
buf
})
};
let out_reader = read(child.stdout.take().map(|p| Box::new(p) as Box<dyn std::io::Read + Send>));
let err_reader = read(child.stderr.take().map(|p| Box::new(p) as Box<dyn std::io::Read + Send>));
let started = Instant::now();
let failed = |stderr: &[u8]| {
let text = String::from_utf8_lossy(stderr);
let detail = text.lines().rev().find(|l| !l.trim().is_empty()).unwrap_or("").trim().to_string();
let mut message = "The repack database command failed; check mysql/logs/mysql-error.log.".to_string();
if !detail.is_empty() {
message.push_str(&format!(" ({detail})"));
}
Error::Invalid(message)
};
let status = loop {
if let Some(status) = child.try_wait()? {
break status;
}
if started.elapsed() > Duration::from_secs(timeout) {
let _ = child.kill();
let _ = child.wait();
let _ = out_reader.join();
return Err(failed(b"timed out"));
}
std::thread::sleep(Duration::from_millis(50));
};
let stdout = out_reader.join().unwrap_or_default();
let stderr = err_reader.join().unwrap_or_default();
if !status.success() {
return Err(failed(&stderr));
}
Ok(String::from_utf8_lossy(&stdout).trim().to_string())
}
// ---------------------------------------------------------------------------------------------------------------
// Start and stop
// ---------------------------------------------------------------------------------------------------------------
pub fn start_mysql(root: &Path, cfg: &Settings, progress: Progress) -> Result<()> {
if cfg.shared_database {
// An extra world uses the main folder's database; it must already run.
return mysql(root, None, Some("ping")).map(|_| ()).map_err(|e| {
Error::Service(ErrorCode::DatabaseNotRunning, format!("The main server's database is not running. {e}"))
});
}
if state::running(root, "mysql").is_some() {
wait_ready(root, "mysql", cfg.mysql_port, 300)?;
mysql(root, None, Some("ping"))?;
progress("MySQL is already running.");
return Ok(());
}
ensure_free(cfg.mysql_port, progress)?;
if !root.join("mysql/data/mysql").is_dir() {
return Err(Error::Service(ErrorCode::ServerFilesIncomplete, "The packaged database is missing. Extract the complete repack.".into()));
}
progress("Starting MySQL...");
let ini = format!("--defaults-file={}", root.join("mysql/my.ini").display());
spawn(root, "mysql", &root.join("mysql/bin/mysqld.exe"), &[&ini, "--no-monitor"], &root.join("mysql"), &root.join("mysql/logs/startup.log"), &cfg.env_remove)?;
wait_ready(root, "mysql", cfg.mysql_port, 300)?;
mysql(root, None, Some("ping"))?;
mysql(
root,
Some(&format!(
"UPDATE acore_auth.realmlist SET name='{}',address='127.0.0.1',localAddress='127.0.0.1',port={} WHERE id={};",
cfg.realm.name, cfg.world_port, cfg.realm.id
)),
None,
)?;
Ok(())
}
pub fn start_auth(root: &Path, cfg: &Settings, progress: Progress) -> Result<()> {
start_mysql(root, cfg, progress)?;
if state::running(root, "auth").is_some() {
wait_ready(root, "auth", cfg.auth_port, 60)?;
progress("Authserver is already running.");
return Ok(());
}
ensure_free(cfg.auth_port, progress)?;
// An interrupted world startup can leave flag 3, which authserver excludes.
mysql(root, Some(&format!("UPDATE acore_auth.realmlist SET flag=0 WHERE id={};", cfg.realm.id)), None)?;
progress("Starting authserver...");
spawn(root, "auth", &root.join("Core/authserver.exe"), &["-c", "configs/authserver.conf"], &root.join("Core"), &root.join("Core/Logs/auth-console.log"), &cfg.env_remove)?;
wait_ready(root, "auth", cfg.auth_port, 60)
}
/// Stop the recorded process, only if it is still that process.
pub fn terminate(record: &ProcessIdentity) -> Result<()> {
if !crate::process::is_alive(record) {
return Ok(());
}
sys::terminate(record)
}
pub fn wait_stopped(record: &ProcessIdentity, seconds: u64) -> bool {
let until = Instant::now() + Duration::from_secs(seconds);
while crate::process::is_alive(record) && Instant::now() < until {
std::thread::sleep(Duration::from_millis(250));
}
!crate::process::is_alive(record)
}
/// The recorded world, when it is this folder's own `Core/worldserver.exe` (never stop a process only because a
/// record names it).
fn owned_world(root: &Path) -> Result<Option<ProcessIdentity>> {
let Some(world) = state::running(root, "world") else { return Ok(None) };
let expected = root.join("Core/worldserver.exe");
let same = std::fs::canonicalize(&world.exe).ok().zip(std::fs::canonicalize(&expected).ok()).is_some_and(|(a, b)| a == b);
if !same {
return Err(Error::Invalid("World process ownership could not be verified; the database was left running.".into()));
}
Ok(Some(world))
}
/// Ask the world's console for a graceful shutdown. False when the console is not this world's or does not answer.
fn ask_shutdown(root: &Path, cfg: &Settings) -> bool {
ready(root, "world", cfg.ra_port)
&& crate::ra::Ra::connect_to(cfg.ra_port, &cfg.ra_username, &cfg.ra_password)
.and_then(|ra| ra.send_without_answer("server shutdown 1s 0"))
.is_ok()
}
/// Stop this folder's world without its console (unsaved progress since the last save is lost).
fn stop_world_process(world: &ProcessIdentity) -> Result<()> {
terminate(world).map_err(|_| Error::Invalid("Worldserver could not be stopped safely; its database was left running.".into()))?;
if !wait_stopped(world, 90) {
return Err(Error::Invalid("Worldserver is still stopping; its database was left running.".into()));
}
Ok(())
}
/// Stop the world at once, then everything else as [`stop_all`] does. Only when the user asked for it.
pub fn force_stop_all(root: &Path, cfg: &Settings, progress: Progress) -> Result<()> {
if let Some(world) = owned_world(root)? {
stop_world_process(&world)?;
progress("Force-stopped this server's verified world process; unsaved progress may be lost.");
}
stop_all(root, cfg, progress)
}
/// Stop everything of this repack, world first (gracefully through its console), its database last. An extra
/// world leaves the shared database alone.
pub fn stop_all(root: &Path, cfg: &Settings, progress: Progress) -> Result<()> {
if let Some(world) = owned_world(root)? {
if ask_shutdown(root, cfg) {
progress("Graceful world shutdown requested.");
} else {
progress("World console unavailable; stopping this repack's recorded world process.");
stop_world_process(&world)?;
}
// A console request can be lost (seen when a client disconnected at once). While the world still runs
// and its console still answers, it has not begun to stop: ask again. Asking twice is harmless.
let mut stopped = wait_stopped(&world, 15);
for _ in 0..2 {
if stopped {
break;
}
if ask_shutdown(root, cfg) {
progress("The world has not begun to stop; shutdown requested again.");
}
stopped = wait_stopped(&world, 15);
}
if !stopped && !wait_stopped(&world, 45) {
return Err(Error::Invalid("Worldserver is still stopping; its database has been left running.".into()));
}
}
if let Some(supervisor) = state::running(root, "supervisor") {
if !wait_stopped(&supervisor, 45) {
return Err(Error::Invalid("The report relay is still finishing a request. Try Stop All again shortly.".into()));
}
}
if let Some(relay) = state::running(root, "relay") {
std::fs::write(state::dir(root).join("stop-relay"), b"")?;
if !wait_stopped(&relay, 40) {
return Err(Error::Invalid("The report relay did not finish; it was left running for recovery.".into()));
}
}
if let Some(auth) = state::running(root, "auth") {
terminate(&auth)?;
if !wait_stopped(&auth, 10) {
return Err(Error::Invalid("Authserver did not stop.".into()));
}
}
if let Some(database) = state::running(root, "mysql").filter(|_| !cfg.shared_database) {
let shutdown = mysql(root, None, Some("shutdown"));
if !wait_stopped(&database, 60) {
shutdown?;
return Err(Error::Invalid("MySQL is still stopping; wait before copying the repack.".into()));
}
}
progress("All services from this repack are stopped. It is safe to move or copy this folder.");
Ok(())
}
/// Which services run (`manage.py status-json`).
pub fn status(root: &Path) -> serde_json::Value {
let mut out = serde_json::Map::new();
for name in ["mysql", "auth", "world", "relay"] {
out.insert(name.into(), state::running(root, name).is_some().into());
}
let debug: bool = crate::fsx::read_json::<serde_json::Value>(&state::dir(root).join("debug-logs.json"))
.ok()
.and_then(|v| v.get("enabled").and_then(|e| e.as_bool()))
.unwrap_or(false);
out.insert("debugLogs".into(), debug.into());
serde_json::Value::Object(out)
}
pub fn log_path(root: &Path, name: &str) -> PathBuf {
match name {
"mysql" => root.join("mysql/logs/startup.log"),
"auth" => root.join("Core/Logs/auth-console.log"),
"world" => root.join("Core/Logs/world-console.log"),
"supervisor" => root.join("Core/Logs/supervisor.log"),
_ => root.join("BugReport/Logs/relay.log"),
}
}
// ---------------------------------------------------------------------------------------------------------------
// Windows
// ---------------------------------------------------------------------------------------------------------------
#[cfg(windows)]
mod sys {
use crate::error::{Error, Result};
use crate::process::ProcessIdentity;
use windows_sys::Win32::Foundation::CloseHandle;
use windows_sys::Win32::NetworkManagement::IpHelper::GetExtendedTcpTable;
use windows_sys::Win32::Networking::WinSock::{setsockopt, SOL_SOCKET, SO_EXCLUSIVEADDRUSE};
use windows_sys::Win32::System::Threading::{OpenProcess, TerminateProcess, PROCESS_QUERY_LIMITED_INFORMATION, PROCESS_TERMINATE};
pub const LISTEN: u32 = 2;
pub const ESTABLISHED: u32 = 5;
pub struct TcpRow {
pub state: u32,
pub local_port: u16,
pub remote_port: u16,
pub remote_loopback: bool,
pub pid: u32,
}
fn table(af: u32) -> Vec<u8> {
const TCP_TABLE_OWNER_PID_ALL: i32 = 5;
let mut size = 0u32;
let mut buf: Vec<u8> = Vec::new();
for _ in 0..4 {
let code = unsafe {
GetExtendedTcpTable(
if buf.is_empty() { std::ptr::null_mut() } else { buf.as_mut_ptr().cast() },
&mut size,
0,
af,
TCP_TABLE_OWNER_PID_ALL,
0,
)
};
match code {
0 if !buf.is_empty() => return buf,
0 | 122 => buf = vec![0u8; size as usize + 4096],
_ => return Vec::new(),
}
}
Vec::new()
}
fn u32_at(b: &[u8], o: usize) -> u32 {
u32::from_le_bytes(b[o..o + 4].try_into().unwrap())
}
pub fn tcp_rows_v4() -> Vec<TcpRow> {
let b = table(2);
let mut out = Vec::new();
if b.len() < 4 {
return out;
}
for i in 0..u32_at(&b, 0) as usize {
let o = 4 + 24 * i;
if o + 24 > b.len() {
break;
}
let remote = u32_at(&b, o + 12).to_le_bytes();
out.push(TcpRow {
state: u32_at(&b, o),
local_port: u16::from_be((u32_at(&b, o + 8) & 0xFFFF) as u16),
remote_port: u16::from_be((u32_at(&b, o + 16) & 0xFFFF) as u16),
remote_loopback: remote == [127, 0, 0, 1],
pid: u32_at(&b, o + 20),
});
}
out
}
pub fn tcp_rows_v6() -> Vec<TcpRow> {
let b = table(23);
let mut out = Vec::new();
if b.len() < 4 {
return out;
}
// MIB_TCP6ROW_OWNER_PID: local addr 16, scope 4, local port 4, remote addr 16, scope 4, remote port 4, state 4, pid 4
for i in 0..u32_at(&b, 0) as usize {
let o = 4 + 56 * i;
if o + 56 > b.len() {
break;
}
let remote = &b[o + 24..o + 40];
let mapped_loopback = remote[..10].iter().all(|x| *x == 0) && remote[10] == 0xff && remote[11] == 0xff && remote[12..] == [127, 0, 0, 1];
out.push(TcpRow {
state: u32_at(&b, o + 48),
local_port: u16::from_be((u32_at(&b, o + 20) & 0xFFFF) as u16),
remote_port: u16::from_be((u32_at(&b, o + 44) & 0xFFFF) as u16),
remote_loopback: mapped_loopback,
pid: u32_at(&b, o + 52),
});
}
out
}
/// Bind 0.0.0.0:port exclusively and release it. Err carries the Windows socket error.
pub fn exclusive_bind(port: u16) -> std::result::Result<(), i32> {
use socket2::{Domain, Socket, Type};
use std::os::windows::io::AsRawSocket;
let socket = Socket::new(Domain::IPV4, Type::STREAM, None).map_err(|e| e.raw_os_error().unwrap_or(-1))?;
let one: i32 = 1;
let set = unsafe {
setsockopt(socket.as_raw_socket() as _, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (&one as *const i32).cast(), 4)
};
if set != 0 {
return Err(std::io::Error::last_os_error().raw_os_error().unwrap_or(-1));
}
let addr: std::net::SocketAddr = ([0, 0, 0, 0], port).into();
socket.bind(&addr.into()).map_err(|e| e.raw_os_error().unwrap_or(-1))
}
pub fn terminate(record: &ProcessIdentity) -> Result<()> {
unsafe {
let h = OpenProcess(PROCESS_TERMINATE | PROCESS_QUERY_LIMITED_INFORMATION, 0, record.pid);
if h.is_null() {
return Err(Error::Invalid("Unable to stop the repack process.".into()));
}
let same = crate::process::is_alive(record);
let ok = same && TerminateProcess(h, 0) != 0;
CloseHandle(h);
if !ok {
return Err(Error::Invalid("The process changed while stopping it.".into()));
}
}
Ok(())
}
}
#[cfg(not(windows))]
mod sys {
use crate::error::{Error, Result};
use crate::process::ProcessIdentity;
pub const LISTEN: u32 = 2;
pub const ESTABLISHED: u32 = 5;
pub struct TcpRow {
pub state: u32,
pub local_port: u16,
pub remote_port: u16,
pub remote_loopback: bool,
pub pid: u32,
}
pub fn tcp_rows_v4() -> Vec<TcpRow> {
Vec::new()
}
pub fn tcp_rows_v6() -> Vec<TcpRow> {
Vec::new()
}
pub fn exclusive_bind(_: u16) -> std::result::Result<(), i32> {
Ok(())
}
pub fn terminate(_: &ProcessIdentity) -> Result<()> {
Err(Error::Invalid("not supported".into()))
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_port_with_a_listener_is_refused_and_a_free_one_passes() {
let held = std::net::TcpListener::bind("0.0.0.0:0").unwrap();
let port = held.local_addr().unwrap().port();
let err = ensure_free(port, &|_| {}).unwrap_err().to_string();
assert!(err.contains(&format!("Port {port} is already used (PID {}", std::process::id())), "{err}");
drop(held);
ensure_free(port, &|_| {}).unwrap();
}
#[test]
fn a_service_is_ready_only_on_its_own_port() {
let d = tempfile::tempdir().unwrap();
let held = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
let port = held.local_addr().unwrap().port();
assert!(!ready(d.path(), "auth", port), "no record yet");
state::record(d.path(), "auth", std::process::id()).unwrap();
assert!(ready(d.path(), "auth", port));
let other = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
drop(other);
assert!(!ready(d.path(), "auth", port + 1) || port + 1 == 0);
}
#[test]
fn status_reads_the_records() {
let d = tempfile::tempdir().unwrap();
state::record(d.path(), "mysql", std::process::id()).unwrap();
let s = status(d.path());
assert_eq!(s["mysql"], true);
assert_eq!(s["world"], false);
assert_eq!(s["debugLogs"], false);
}
}
+168
View File
@@ -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()));
}
}
Binary file not shown.
+398
View File
@@ -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"));
}
}
+198
View File
@@ -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();
}
}
+300
View File
@@ -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);
}
}
-85
View File
@@ -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}")
+222
View File
@@ -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
);
}
}
+2
View File
@@ -28,6 +28,7 @@ pub mod diag;
pub mod docker;
pub mod download;
pub mod driver;
pub mod legacy_launcher;
pub mod error;
pub mod firewall;
pub mod friends;
@@ -36,6 +37,7 @@ pub mod glue_config;
pub mod health;
pub mod install;
pub mod layout;
pub mod launcher;
pub mod logging;
pub mod server_logging;
pub mod manifest;
+12 -28
View File
@@ -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());
}
}
+23
View File
@@ -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())?;
-196
View File
@@ -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
);
}
}
+8 -8
View File
@@ -403,7 +403,7 @@ pub fn plan(
match (fs::read_to_string(tree.join(&f.path)), fs::read(&target)) {
(Ok(signed), Ok(actual)) => {
fsx::sha256_bytes(signed.as_bytes()) == f.sha256
&& crate::driver::launcher_matches(&signed, &actual)
&& crate::legacy_launcher::launcher_matches(&signed, &actual)
}
_ => false,
}
@@ -418,7 +418,7 @@ pub fn plan(
let manager_launcher = f.path == "Scripts/manage.py"
&& recorded.is_some_and(|hash| {
fs::read(&target).is_ok_and(|bytes| {
crate::driver::launcher_matches_recorded(hash, &bytes)
crate::legacy_launcher::launcher_matches_recorded(hash, &bytes)
})
});
if f.path == "Core/worldserver.exe"
@@ -614,7 +614,7 @@ fn launcher_already_integrated(
if meta.original_hashes.get(&file.path) != Some(&fsx::sha256_bytes(&actual)) {
return Ok(false);
}
Ok(crate::driver::launcher_matches_recorded(
Ok(crate::legacy_launcher::launcher_matches_recorded(
&file.sha256,
&actual,
))
@@ -968,7 +968,7 @@ fn finish(
fs::read_to_string(tree.join(&op.path)),
fs::read(root.join(&op.path)),
) {
(Ok(signed), Ok(actual)) if crate::driver::launcher_matches(&signed, &actual) => {
(Ok(signed), Ok(actual)) if crate::legacy_launcher::launcher_matches(&signed, &actual) => {
fsx::sha256_bytes(&actual)
}
_ => op.new_sha256.clone(),
@@ -1060,7 +1060,7 @@ pub fn retry_validation(
&& fs::read_to_string(dir.join("tree").join(&op.path))
.ok()
.filter(|s| fsx::sha256_bytes(s.as_bytes()) == file.sha256)
.is_some_and(|s| crate::driver::launcher_matches(&s, &bytes));
.is_some_and(|s| crate::legacy_launcher::launcher_matches(&s, &bytes));
if actual != file.sha256 && !launcher {
return Err(Error::Invalid(format!(
"{} changed since the update was applied; use repair or rollback.",
@@ -2347,9 +2347,9 @@ mod tests {
fn legacy_launcher_world(import_patch: bool) -> World {
let w = world(&[("Scripts/manage.py", b"new release launcher")], false);
let mut source = crate::realms::patch_launcher(LEGACY_LAUNCHER).unwrap();
let mut source = crate::legacy_launcher::patch_launcher(LEGACY_LAUNCHER).unwrap();
if import_patch {
source = crate::driver::patch_launcher_imports(&source).unwrap();
source = crate::legacy_launcher::patch_launcher_imports(&source).unwrap();
}
write(&w.root, "Scripts/manage.py", source.as_bytes());
let (_, mut meta) = MetaDir::open(&w.meta).unwrap();
@@ -2576,7 +2576,7 @@ mod tests {
let w = world(&[("Scripts/manage.py", source)], false);
run(&w, &Fake::ok(), BTreeMap::new(), None).unwrap();
let integrated =
crate::driver::patch_launcher_imports(std::str::from_utf8(source).unwrap()).unwrap();
crate::legacy_launcher::patch_launcher_imports(std::str::from_utf8(source).unwrap()).unwrap();
write(&w.root, "Scripts/manage.py", integrated.as_bytes());
let (_, mut meta) = MetaDir::open(&w.meta).unwrap();
meta.original_hashes.insert(
+15
View File
@@ -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"] }
+222
View File
@@ -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);
}
}
+2 -2
View File
@@ -1,12 +1,12 @@
{
"name": "coa-server-manager",
"version": "0.9.13",
"version": "0.9.10",
"lockfileVersion": 3,
"requires": true,
"packages": {
"": {
"name": "coa-server-manager",
"version": "0.9.13",
"version": "0.9.10",
"dependencies": {
"@tauri-apps/api": "^2.12.0",
"@tauri-apps/plugin-dialog": "^2.8.0",
+1 -1
View File
@@ -1,7 +1,7 @@
{
"name": "coa-server-manager",
"private": true,
"version": "0.9.13",
"version": "0.9.10",
"license": "AGPL-3.0-only",
"type": "module",
"scripts": {
-122
View File
@@ -422,128 +422,6 @@
"max": 40,
"unit": "yards"
},
{
"key": "CoaBots.Scaling.Enable",
"type": "bool",
"category": "combat",
"title": "Bot strength help in dungeons and raids",
"description": "Master switch for the multipliers below. They are all 1 (no change) until you raise them.",
"default": true,
"advanced": false,
"restartRequired": "world",
"dangerous": false
},
{
"key": "CoaBots.Scaling.Dungeons",
"type": "bool",
"category": "combat",
"title": "Help in 5-player dungeons",
"description": "Apply the multipliers while a bot is in a 5-player dungeon.",
"default": true,
"advanced": false,
"restartRequired": "world",
"dangerous": false
},
{
"key": "CoaBots.Scaling.Raids",
"type": "bool",
"category": "combat",
"title": "Help in raids",
"description": "Apply the multipliers while a bot is in a raid.",
"default": true,
"advanced": false,
"restartRequired": "world",
"dangerous": false
},
{
"key": "CoaBots.Scaling.Battlegrounds",
"type": "bool",
"category": "combat",
"title": "Help in battlegrounds and arenas",
"description": "Apply the multipliers in battlegrounds and arenas.",
"default": false,
"advanced": true,
"restartRequired": "world",
"dangerous": false
},
{
"key": "CoaBots.Scaling.World",
"type": "bool",
"category": "combat",
"title": "Help in the open world",
"description": "Apply the multipliers outside dungeons and raids. Usually not wanted.",
"default": false,
"advanced": true,
"restartRequired": "world",
"dangerous": false
},
{
"key": "CoaBots.Scaling.DamageDone",
"type": "float",
"category": "combat",
"title": "Bot damage",
"description": "Multiplies the damage bots and their pets deal to creatures. 1 is no change; higher makes content easier.",
"default": 1.0,
"advanced": false,
"restartRequired": "world",
"dangerous": false,
"min": 0.1,
"max": 10,
"unit": "x"
},
{
"key": "CoaBots.Scaling.HealingDone",
"type": "float",
"category": "combat",
"title": "Bot healing",
"description": "Multiplies the healing bots cast. 1 is no change.",
"default": 1.0,
"advanced": false,
"restartRequired": "world",
"dangerous": false,
"min": 0.1,
"max": 10,
"unit": "x"
},
{
"key": "CoaBots.Scaling.DamageTaken",
"type": "float",
"category": "combat",
"title": "Damage taken by bots",
"description": "Multiplies the damage creatures deal to bots. Below 1 bots take less; 1 is no change.",
"default": 1.0,
"advanced": false,
"restartRequired": "world",
"dangerous": false,
"min": 0.1,
"max": 10,
"unit": "x"
},
{
"key": "CoaBots.Scaling.TankThreat",
"type": "float",
"category": "combat",
"title": "Tank threat",
"description": "Extra threat generated by bot tanks so they hold the enemy's attention. 1 is no change.",
"default": 1.0,
"advanced": false,
"restartRequired": "world",
"dangerous": false,
"min": 1,
"max": 10,
"unit": "x"
},
{
"key": "CoaBots.Scaling.BossTuning",
"type": "bool",
"category": "combat",
"title": "Extra help against four bosses",
"description": "Adds stronger multipliers for Loken, the Drakkari Elemental, the Drakkari Colossus and Gal'darah, whom level 60 bots could not beat otherwise. For testing; off by default.",
"default": false,
"advanced": true,
"restartRequired": "world",
"dangerous": false
},
{
"key": "CoaBots.WorldBrain.MountDistanceMin",
"type": "int",
+1 -1
View File
@@ -1,7 +1,7 @@
{
"$schema": "https://schema.tauri.app/config/2",
"productName": "CoA Server Manager",
"version": "0.9.13",
"version": "0.9.10",
"identifier": "com.coa.servermanager",
"build": {
"beforeDevCommand": "npm run dev",
-9
View File
@@ -40,12 +40,3 @@ These files describe preparation and do not add unpublished releases to canonica
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.
Manager 0.9.12 refreshes the bundled server history through 0.261108.95 from
canonical build commit `ca04f96f600481446f97ac611c7f914d786af00b` on 2026-11-14.
The reviewed upcoming Manager and server records carry translations in all five languages.
Manager 0.9.13 refreshes the bundled server history through 0.261114.106 from
canonical build commit `3308e3a957cd9fd1a2cd145a7f023f2cf521c54c` on 2026-11-15.
The reviewed upcoming Manager and server records (Custom Races V2, 213 server notes)
carry translations in all five languages.
File diff suppressed because it is too large. Load diff
-280
View File
@@ -1708,286 +1708,6 @@
},
"experimentalFeatures": [],
"compare": "https://github.com/Corfirean/coa-server-build/compare/server-0.261101.92...server-0.261104.94"
},
{
"tag": "server-0.261108.95",
"version": "0.261108.95",
"date": "2026-11-08",
"url": "https://github.com/Corfirean/coa-server-build/releases/tag/server-0.261108.95",
"notes": [
"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"
],
"snapshot": "0f331e3289864531d19b2eb185080c18ddd9eaa7be9befa28d6f4b50b5dc2a3f",
"components": {
"upstream": {
"repository": "jealous-sound/azerothcore-wotlk-coa",
"ref": "f8955cb9b29042c359a938ff732e4b608dd62ea5",
"sha": "f8955cb9b29042c359a938ff732e4b608dd62ea5"
},
"core": {
"repository": "Corfirean/azerothcore-wotlk-coa",
"ref": "85ecc2122efd4bc168e750ab35c3e3e8d9c49735",
"sha": "85ecc2122efd4bc168e750ab35c3e3e8d9c49735"
},
"bots": {
"repository": "Corfirean/mod-coa-playerbots",
"ref": "0588a8e5cdfe54f81fe47bbb40fc9f75d29662e3",
"sha": "0588a8e5cdfe54f81fe47bbb40fc9f75d29662e3"
},
"scaling": {
"repository": "Corfirean/mod-coa-content-scaling",
"ref": "3c2febf636bd09087bb278e381b975271a70fdf6",
"sha": "3c2febf636bd09087bb278e381b975271a70fdf6"
},
"manager": {
"repository": "Corfirean/coa-server-manager",
"ref": "711f378ae82f75d3fc64368c042889c773315c54",
"sha": "711f378ae82f75d3fc64368c042889c773315c54"
},
"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.9.4",
"sha": "75d1784f66f3c731340a96f72bfbd301974b6ab4",
"patch": "patches/squid-coa-validation.patch",
"patchSha256": "244cd2d8b04b3158665e44f40ebb6d4088a867a052ff5c3a9553d604652fe2d1"
},
"build": {
"repository": "Corfirean/coa-server-build",
"ref": "2e9fee5b953455e39d8acb70cf9bb32ee09e9288",
"sha": "2e9fee5b953455e39d8acb70cf9bb32ee09e9288"
},
"dungeon-clear": {
"repository": "Zyth45/mod-dungeon-clear",
"sha": "081a04f4208056dbb90717a5d10fe1e593943d5b",
"patch": "patches/dungeon-clear-coa-validation.patch",
"patchSha256": "4078f8284ef011142c970cb8e812055e370ba858502de82f86a831d16fe1ec66",
"ref": "081a04f4208056dbb90717a5d10fe1e593943d5b"
},
"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.261104.94...server-0.261108.95"
},
{
"tag": "server-0.261114.106",
"version": "0.261114.106",
"date": "2026-11-14",
"url": "https://github.com/Corfirean/coa-server-build/releases/tag/server-0.261114.106",
"notes": [
"Optional extra strength for bots in dungeons and raids",
"Bot performance metrics and optional scheduling controls are available for testing",
"Database startup can recover when Windows omits its listening port",
"Updated Dungeon Clear to 3.0.0 to match SQUID Playerbots 3.0",
"Automatic world restarts wait for the previous supervisor to finish",
"The server's own Auction House Bot stays in charge when SQUID Playerbots 3.0 is installed",
"Updated SQUID Playerbots to 3.0",
"Updated the reviewed CoA upstream snapshot"
],
"snapshot": "5ecaa04281576af58df11d5d39151cbebb4f2dfb10fffb84098d2809709cb68f",
"components": {
"upstream": {
"repository": "jealous-sound/azerothcore-wotlk-coa",
"ref": "96afaf0f51cc4b37f1eba282bffb1c5aab353de6",
"sha": "96afaf0f51cc4b37f1eba282bffb1c5aab353de6"
},
"core": {
"repository": "Corfirean/azerothcore-wotlk-coa",
"ref": "8850b229fe2653a954a2e753c5a9b293bf4e500b",
"sha": "8850b229fe2653a954a2e753c5a9b293bf4e500b"
},
"bots": {
"repository": "Corfirean/mod-coa-playerbots",
"ref": "30a5a555f56fda8f4ccad14be8438bd0532d85b9",
"sha": "30a5a555f56fda8f4ccad14be8438bd0532d85b9"
},
"scaling": {
"repository": "Corfirean/mod-coa-content-scaling",
"ref": "3c2febf636bd09087bb278e381b975271a70fdf6",
"sha": "3c2febf636bd09087bb278e381b975271a70fdf6"
},
"manager": {
"repository": "Corfirean/coa-server-manager",
"ref": "d71c5635e3262a775b400a1c90ac81d7bddcbeaf",
"sha": "d71c5635e3262a775b400a1c90ac81d7bddcbeaf"
},
"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": "v3.0",
"sha": "4ef5ed9ebe75a330de7df19639a042391e037e15",
"patch": "patches/squid-coa-validation.patch",
"patchSha256": "2cc45bc6555d5bb3e91728840f9de6e73c002c73b270a37732a1499956241c5f"
},
"build": {
"repository": "Corfirean/coa-server-build",
"ref": "be0c1eef3aa4b20c4203dbf54ac66b63d4e6df05",
"sha": "be0c1eef3aa4b20c4203dbf54ac66b63d4e6df05"
},
"dungeon-clear": {
"repository": "Zyth45/mod-dungeon-clear",
"sha": "6efb59eae96bcc0730fc083314dd28d55970bbf4",
"patch": "patches/dungeon-clear-coa-validation.patch",
"patchSha256": "2845d389422e3a59e5c186ecf54b03f64f1dcc22cdef15729b60c354ae72cd6f",
"ref": "6efb59eae96bcc0730fc083314dd28d55970bbf4"
},
"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.261108.95...server-0.261114.106"
}
]
}
-10
View File
@@ -148,16 +148,6 @@
"t": "Suchradius für Ziele",
"d": "Wie weit ein Bot innerhalb eines Zielgebiets nach Questzielen sucht."
},
"CoaBots.Scaling.Enable": {"t": "Stärkehilfe für Bots in Dungeons und Schlachtzügen", "d": "Hauptschalter für die Multiplikatoren unten. Bis du sie erhöhst, sind alle 1 (keine Änderung)."},
"CoaBots.Scaling.Dungeons": {"t": "Hilfe in 5-Spieler-Dungeons", "d": "Multiplikatoren anwenden, solange ein Bot in einem 5-Spieler-Dungeon ist."},
"CoaBots.Scaling.Raids": {"t": "Hilfe in Schlachtzügen", "d": "Multiplikatoren anwenden, solange ein Bot in einem Schlachtzug ist."},
"CoaBots.Scaling.Battlegrounds": {"t": "Hilfe in Schlachtfeldern und Arenen", "d": "Multiplikatoren in Schlachtfeldern und Arenen anwenden."},
"CoaBots.Scaling.World": {"t": "Hilfe in der offenen Welt", "d": "Multiplikatoren außerhalb von Dungeons und Schlachtzügen anwenden. Meist nicht gewünscht."},
"CoaBots.Scaling.DamageDone": {"t": "Schaden der Bots", "d": "Multipliziert den Schaden, den Bots und ihre Begleiter Kreaturen zufügen. 1 heißt keine Änderung; höher macht Inhalte leichter."},
"CoaBots.Scaling.HealingDone": {"t": "Heilung der Bots", "d": "Multipliziert die Heilung, die Bots wirken. 1 heißt keine Änderung."},
"CoaBots.Scaling.DamageTaken": {"t": "Schaden an Bots", "d": "Multipliziert den Schaden, den Kreaturen Bots zufügen. Unter 1 erleiden Bots weniger; 1 heißt keine Änderung."},
"CoaBots.Scaling.TankThreat": {"t": "Bedrohung der Tanks", "d": "Zusätzliche Bedrohung durch Bot-Tanks, damit sie die Aufmerksamkeit der Gegner halten. 1 heißt keine Änderung."},
"CoaBots.Scaling.BossTuning": {"t": "Zusatzhilfe gegen vier Bosse", "d": "Fügt stärkere Multiplikatoren für Loken, den Drakkari-Elementar, den Drakkari-Koloss und Gal'darah hinzu, die Bots der Stufe 60 sonst nicht besiegten. Zum Testen; standardmäßig aus."},
"CoaBots.WorldBrain.EngageRange": {
"t": "Angriffsentfernung",
"d": "Entfernung, ab der ein Bot einen Quest-Gegner bekämpft."
-10
View File
@@ -148,16 +148,6 @@
"t": "Radio de búsqueda de objetivos",
"d": "Hasta dónde examina un bot en busca de objetivos de misión dentro de una zona de objetivo."
},
"CoaBots.Scaling.Enable": {"t": "Ayuda de fuerza para bots en mazmorras y bandas", "d": "Interruptor general de los multiplicadores de abajo. Hasta que los subas, todos valen 1 (sin cambios)."},
"CoaBots.Scaling.Dungeons": {"t": "Ayuda en mazmorras de 5 jugadores", "d": "Aplica los multiplicadores mientras un bot está en una mazmorra de 5 jugadores."},
"CoaBots.Scaling.Raids": {"t": "Ayuda en bandas", "d": "Aplica los multiplicadores mientras un bot está en una banda."},
"CoaBots.Scaling.Battlegrounds": {"t": "Ayuda en campos de batalla y arenas", "d": "Aplica los multiplicadores en campos de batalla y arenas."},
"CoaBots.Scaling.World": {"t": "Ayuda en el mundo abierto", "d": "Aplica los multiplicadores fuera de mazmorras y bandas. Normalmente no se desea."},
"CoaBots.Scaling.DamageDone": {"t": "Daño de los bots", "d": "Multiplica el daño que los bots y sus mascotas infligen a las criaturas. 1 no cambia nada; más alto facilita el contenido."},
"CoaBots.Scaling.HealingDone": {"t": "Curación de los bots", "d": "Multiplica la curación que lanzan los bots. 1 no cambia nada."},
"CoaBots.Scaling.DamageTaken": {"t": "Daño recibido por los bots", "d": "Multiplica el daño que las criaturas infligen a los bots. Por debajo de 1 los bots reciben menos; 1 no cambia nada."},
"CoaBots.Scaling.TankThreat": {"t": "Amenaza de los tanques", "d": "Amenaza extra que generan los tanques bot para mantener la atención de los enemigos. 1 no cambia nada."},
"CoaBots.Scaling.BossTuning": {"t": "Ayuda extra contra cuatro jefes", "d": "Añade multiplicadores más fuertes para Loken, el elemental drakkari, el coloso drakkari y Gal'darah, a quienes los bots de nivel 60 no vencían de otro modo. Para pruebas; desactivado por defecto."},
"CoaBots.WorldBrain.EngageRange": {
"t": "Distancia de enfrentamiento",
"d": "Distancia a la que un bot empieza a combatir a un monstruo de misión."
-10
View File
@@ -148,16 +148,6 @@
"t": "Rayon de recherche des cibles",
"d": "Jusqu’où un bot cherche des cibles de quête dans une zone d’objectif."
},
"CoaBots.Scaling.Enable": {"t": "Aide de puissance pour les bots en donjon et en raid", "d": "Interrupteur général des multiplicateurs ci-dessous. Tant que vous ne les augmentez pas, ils valent tous 1 (aucun changement)."},
"CoaBots.Scaling.Dungeons": {"t": "Aide en donjon à 5 joueurs", "d": "Applique les multiplicateurs tant qu'un bot est dans un donjon à 5 joueurs."},
"CoaBots.Scaling.Raids": {"t": "Aide en raid", "d": "Applique les multiplicateurs tant qu'un bot est dans un raid."},
"CoaBots.Scaling.Battlegrounds": {"t": "Aide en champ de bataille et en arène", "d": "Applique les multiplicateurs en champ de bataille et en arène."},
"CoaBots.Scaling.World": {"t": "Aide en monde ouvert", "d": "Applique les multiplicateurs hors des donjons et des raids. Rarement souhaité."},
"CoaBots.Scaling.DamageDone": {"t": "Dégâts des bots", "d": "Multiplie les dégâts que les bots et leurs familiers infligent aux créatures. 1 : aucun changement ; plus élevé = contenu plus facile."},
"CoaBots.Scaling.HealingDone": {"t": "Soins des bots", "d": "Multiplie les soins lancés par les bots. 1 : aucun changement."},
"CoaBots.Scaling.DamageTaken": {"t": "Dégâts subis par les bots", "d": "Multiplie les dégâts que les créatures infligent aux bots. Sous 1, les bots en subissent moins ; 1 : aucun changement."},
"CoaBots.Scaling.TankThreat": {"t": "Menace des tanks", "d": "Menace supplémentaire générée par les tanks bots, pour qu'ils gardent l'attention des ennemis. 1 : aucun changement."},
"CoaBots.Scaling.BossTuning": {"t": "Aide supplémentaire contre quatre boss", "d": "Ajoute des multiplicateurs plus forts pour Loken, l'élémentaire drakkari, le colosse drakkari et Gal'darah, que les bots de niveau 60 ne battaient pas autrement. Pour les tests ; désactivé par défaut."},
"CoaBots.WorldBrain.EngageRange": {
"t": "Distance d’engagement",
"d": "Distance à laquelle un bot commence à combattre un monstre de quête."
-10
View File
@@ -148,16 +148,6 @@
"t": "Радиус поиска целей",
"d": "Как далеко бот высматривает цели заданий внутри области задачи."
},
"CoaBots.Scaling.Enable": {"t": "Помощь ботам в подземельях и рейдах", "d": "Главный выключатель множителей ниже. Пока вы их не повысите, все равны 1 (без изменений)."},
"CoaBots.Scaling.Dungeons": {"t": "Помощь в подземельях на 5 человек", "d": "Применять множители, пока бот находится в подземелье на 5 человек."},
"CoaBots.Scaling.Raids": {"t": "Помощь в рейдах", "d": "Применять множители, пока бот находится в рейде."},
"CoaBots.Scaling.Battlegrounds": {"t": "Помощь на полях боя и аренах", "d": "Применять множители на полях боя и аренах."},
"CoaBots.Scaling.World": {"t": "Помощь в открытом мире", "d": "Применять множители вне подземелий и рейдов. Обычно не нужно."},
"CoaBots.Scaling.DamageDone": {"t": "Урон ботов", "d": "Умножает урон, который наносят существам боты и их питомцы. 1 — без изменений, больше — проще."},
"CoaBots.Scaling.HealingDone": {"t": "Лечение ботов", "d": "Умножает лечение, которое накладывают боты. 1 — без изменений."},
"CoaBots.Scaling.DamageTaken": {"t": "Урон по ботам", "d": "Умножает урон, который существа наносят ботам. Меньше 1 — боты получают меньше урона, 1 — без изменений."},
"CoaBots.Scaling.TankThreat": {"t": "Угроза танков", "d": "Дополнительная угроза от ботов-танков, чтобы они удерживали внимание врагов. 1 — без изменений."},
"CoaBots.Scaling.BossTuning": {"t": "Дополнительная помощь против четырёх боссов", "d": "Добавляет усиленные множители для Локена, элементаля Драккари, колосса Драккари и Гал'дараха, которых боты 60 уровня иначе не побеждали. Для тестов; по умолчанию выключено."},
"CoaBots.WorldBrain.EngageRange": {
"t": "Дистанция начала боя",
"d": "Расстояние, на котором бот начинает бой с монстром из задания."
-10
View File
@@ -168,16 +168,6 @@
"t": "任务目标搜索半径",
"d": "机器人在目标区域内寻找任务怪或任务道具的扫描范围。"
},
"CoaBots.Scaling.Enable": {"t": "机器人在地下城和团队副本中的强度辅助", "d": "下方倍率的总开关。在你调高之前,所有倍率均为1(无变化)。"},
"CoaBots.Scaling.Dungeons": {"t": "5人地下城辅助", "d": "机器人处于5人地下城时应用倍率。"},
"CoaBots.Scaling.Raids": {"t": "团队副本辅助", "d": "机器人处于团队副本时应用倍率。"},
"CoaBots.Scaling.Battlegrounds": {"t": "战场与竞技场辅助", "d": "在战场和竞技场中应用倍率。"},
"CoaBots.Scaling.World": {"t": "野外辅助", "d": "在地下城和团队副本之外应用倍率。通常不需要。"},
"CoaBots.Scaling.DamageDone": {"t": "机器人伤害", "d": "倍乘机器人及其宠物对生物造成的伤害。1表示无变化;越高内容越容易。"},
"CoaBots.Scaling.HealingDone": {"t": "机器人治疗", "d": "倍乘机器人施放的治疗量。1表示无变化。"},
"CoaBots.Scaling.DamageTaken": {"t": "机器人受到的伤害", "d": "倍乘生物对机器人造成的伤害。低于1时机器人受到的伤害更少;1表示无变化。"},
"CoaBots.Scaling.TankThreat": {"t": "坦克仇恨", "d": "机器人坦克额外产生的仇恨,使其更容易吸引敌人注意。1表示无变化。"},
"CoaBots.Scaling.BossTuning": {"t": "针对四个首领的额外辅助", "d": "为洛肯、达卡莱元素、达卡莱巨像和加尔达拉添加更强的倍率,60级机器人否则无法击败他们。用于测试;默认关闭。"},
"CoaBots.WorldBrain.EngageRange": {
"t": "开战交战距离",
"d": "机器人发现任务目标怪并开始主动进入战斗的距离。"
-10
View File
@@ -38,16 +38,6 @@ R = [
("Healer.CriticalHealPct", "int", "combat", "Emergency heal threshold", "Healers switch to their strongest heals when an ally falls below this health.", 50, 5, 95, "%", False, False),
("WorldBrain.SearchRadius", "int", "openworld", "Target search radius", "How far a bot scans for quest targets inside an objective area.", 50, 10, 300, "yards", True, False),
("WorldBrain.EngageRange", "int", "combat", "Engage distance", "Distance at which a bot starts fighting a quest monster.", 28, 5, 40, "yards", True, False),
("Scaling.Enable", "bool", "combat", "Bot strength help in dungeons and raids", "Master switch for the multipliers below. They are all 1 (no change) until you raise them.", True, None, None, None, False, False),
("Scaling.Dungeons", "bool", "combat", "Help in 5-player dungeons", "Apply the multipliers while a bot is in a 5-player dungeon.", True, None, None, None, False, False),
("Scaling.Raids", "bool", "combat", "Help in raids", "Apply the multipliers while a bot is in a raid.", True, None, None, None, False, False),
("Scaling.Battlegrounds", "bool", "combat", "Help in battlegrounds and arenas", "Apply the multipliers in battlegrounds and arenas.", False, None, None, None, True, False),
("Scaling.World", "bool", "combat", "Help in the open world", "Apply the multipliers outside dungeons and raids. Usually not wanted.", False, None, None, None, True, False),
("Scaling.DamageDone", "float", "combat", "Bot damage", "Multiplies the damage bots and their pets deal to creatures. 1 is no change; higher makes content easier.", 1.0, 0.1, 10, "x", False, False),
("Scaling.HealingDone", "float", "combat", "Bot healing", "Multiplies the healing bots cast. 1 is no change.", 1.0, 0.1, 10, "x", False, False),
("Scaling.DamageTaken", "float", "combat", "Damage taken by bots", "Multiplies the damage creatures deal to bots. Below 1 bots take less; 1 is no change.", 1.0, 0.1, 10, "x", False, False),
("Scaling.TankThreat", "float", "combat", "Tank threat", "Extra threat generated by bot tanks so they hold the enemy's attention. 1 is no change.", 1.0, 1, 10, "x", False, False),
("Scaling.BossTuning", "bool", "combat", "Extra help against four bosses", "Adds stronger multipliers for Loken, the Drakkari Elemental, the Drakkari Colossus and Gal'darah, whom level 60 bots could not beat otherwise. For testing; off by default.", False, None, None, None, True, False),
("WorldBrain.MountDistanceMin", "int", "openworld", "Mount up beyond (min)", "Each bot mounts for trips longer than a personal distance drawn between this and the maximum.", 60, 10, 500, "yards", True, False),
("WorldBrain.MountDistanceMax", "int", "openworld", "Mount up beyond (max)", "Upper end of the personal mount distance.", 95, 10, 500, "yards", True, False),
("WorldBrain.TaxiMinDistance", "int", "openworld", "Use flight paths beyond", "Trips longer than this use a flight path when the bot knows a route.", 900, 100, 10000, "yards", True, False),
+3 -3
View File
@@ -1,6 +1,6 @@
{
"version": "0.9.13",
"version": "0.9.10",
"notes": [
"The custom races client is updated to Custom Races V2"
"Custom Races patch installation recovers from interrupted downloads"
]
}
}
+9 -228
View File
@@ -2,15 +2,15 @@
"components": {
"core": {
"repository": "Corfirean/azerothcore-wotlk-coa",
"sha": "9740ced5c41806115d851ab37ab34f28e1e8b712"
"sha": "85ecc2122efd4bc168e750ab35c3e3e8d9c49735"
},
"upstream": {
"repository": "jealous-sound/azerothcore-wotlk-coa",
"sha": "96afaf0f51cc4b37f1eba282bffb1c5aab353de6"
"sha": "f8955cb9b29042c359a938ff732e4b608dd62ea5"
},
"bots": {
"repository": "Corfirean/mod-coa-playerbots",
"sha": "30a5a555f56fda8f4ccad14be8438bd0532d85b9"
"sha": "0588a8e5cdfe54f81fe47bbb40fc9f75d29662e3"
},
"scaling": {
"repository": "Corfirean/mod-coa-content-scaling",
@@ -18,232 +18,13 @@
},
"build": {
"repository": "Corfirean/coa-server-build",
"sha": "9a122d049e8be457444389e9756936bcdb4e7ef5"
},
"squid": {
"repository": "Zyth45/mod-playerbots",
"ref": "v3.0",
"sha": "4ef5ed9ebe75a330de7df19639a042391e037e15"
},
"races": {
"repository": "ilusixn/CustomRacesCoa",
"ref": "coa-custom-2.0",
"sha": "dae0c661f7197bafd0a42d80866fa8709b3792c9"
"sha": "ccb121b2a050e9f6eae4e5798dbca1c4ee66264f"
}
},
"notes": [
"Test build of the subclass module for two-headed Ogres",
"Thin Twins can earn a subclass through their own quest, the Bravery Badge",
"A two-headed Ogre's ranged subclass can shoot at point-blank range",
"Ogres have a new racial, Tolerance",
"Standard-class Ogres and Thin Humans start with only their own class kit",
"Helmets sit on the Thin Human's head instead of his chest",
"LiveMon shows live damage, healing, crowd control and subclass combo statistics",
"Standard-class Ogres and Thin Twins can take a CoA class as their subclass",
"Thin Human and Two-Headed Ogre are now their own playable races",
"Subclassed relic users can hold a relic beside a ranged weapon",
"Server options to limit subclassing or turn the two subclass races off",
"A standard subclass brings its whole basic kit, skills and weapons",
"Two-Headed Ogres and Thin Humans with a standard class can now pick a subclass",
"Thin Humans find more gold with the Hand-Me-Downs racial",
"Two-Headed Ogres wear helmets on both heads",
"Flying mounts no longer fly in Kalimdor and the Eastern Kingdoms",
"LiveMon's character tab can be closed and goes away for deleted characters",
"Classic classes can be limited to their Wrath of the Lich King abilities",
"Dual Wield shows once in the spellbook",
"Two-Headed Ogres get Subclass Bar 1 for the other head's spells",
"Subclass forms leave Two-Headed Ogres in their own body and turn the twin brother instead",
"CoA subclass trees show their specialization painting in the subclass tab",
"Characters with a subclass no longer get Dual Specialization",
"You can hold only one subclass book and one insight at a time",
"Thin Humans and Two-Headed Ogres get the quests of their starting zone",
"The Bravery Badge and the Book of Origins look and read like a badge and a book",
"Ghost Wolf and Travel Form turn the whole ogre, and the twin brother rides the beast",
"Standard-class mains can spend points in their subclass trees and reset main talents",
"Your subclass's trainer can reset only your subclass talents",
"The Thin Human's cape lies along his back instead of sticking out like a board",
"The twin brother finishes pointing before hopping off and readies his weapon with you",
"The twin brother fights with his melee weapon up close and sits close behind you on mounts",
"The twin brother copies your pose on hover discs, carpets and other unusual mounts",
"Two-Headed Ogres sit in cars and keep their mace drawn after a shot",
"Two-Headed Ogres fight with a weapon in one hand and a gun in the other",
"The Ogre's Agree or Disagree racial now shows what it will do next",
"The Thin Twins' brother turns into a worgen in every subclass Cursed Form",
"Leaps and charges ordered for the Thin Twins' brother move him instead of you",
"CoA classes taken as a subclass get their class mechanics",
"Thin Twins and Two-Headed Ogres keep their weapons in a subclass Cursed Form",
"Hovering a Guardian standard no longer causes a Lua error",
"LiveMon shows specialization names instead of their signature spells",
"Ogre eyes are picked by colour, with a Blind checkbox for each eye",
"Two-headed ogres no longer keep casting after a subclass spell with a cast time",
"Two-headed ogres cast every subclass spell with the left arm",
"The other half only shoots when you attack a target out of melee reach",
"The other head raises her hand while casting and your presses come first",
"Saving talent changes no longer fails for characters with a subclass",
"The second-way quest no longer pops up at level 20",
"Every race can create the standard classes the creation screen offers again",
"Subclass Bar 1 shows cooldowns, charges and casts like a normal action bar",
"Subclass Bar 1 refills itself when you change subclass",
"Subclass Bar 1 appears as soon as you choose a subclass",
"Subclass Bar 1 works like an action bar and can live in Bartender4",
"A subclass can never be the character's own class",
"New characters no longer inherit the subclass of a deleted character",
"Sun Cleric, Barbarian, Bloodmage and Cultist subclass resources use the game's own orbs",
"Shapeshifting no longer takes away the twin brother or the subclass",
"A subclass specialization now teaches the ability its passive promises",
"Subclass stances and forms appear only on the subclass stance bar",
"Subclass vows, auras and formations move to the subclass stance bar",
"The Thin Human's cape rests on his shoulders and moves with them",
"The twin brother gets a real spot in cars and rides along in passenger seats",
"The twin brother puts his weapons away while he wears a subclass shape",
"The Thin Twins' brother now shows the flash and glow of subclass forms",
"The twin brother sneaks along in stealth instead of staying behind",
"The stance button takes a Thin Twin out of a form his brother wears again",
"The Two-Head and Two-Thins tabs show one wide background and the right class icon",
"The Two-Head and Two-Thins trees use the game's own talent nodes",
"Agree or Disagree takes one spellbook slot that changes name and icon",
"Subclass talent trees no longer let you spend more points than you have",
"Your brother stays at your side when you melee with a bow equipped",
"A melee brother stays on your target and keeps fighting",
"The Two-Headed Ogre twists her body less while her other head casts",
"Thin Twins and Two-Headed Ogres are Hero Races that need a level 60 character",
"The Two-Headed Ogre's portrait shows both heads instead of her body",
"Your other half's spells break your stealth, and Running Wild ends when you stealth",
"Spells your other half casts now trigger the class's talents and resources",
"Your other half takes the subclass's Cat, Bear and stance forms on their own",
"Your other head or brother can no longer finish a cast while you run",
"The other head's hand glows while she casts",
"With Play Easy on, your other half uses abilities that cost health",
"New racial passives explain the shared and split resource pools",
"The dressing room works for races without their own background, no extra addon needed",
"Your brother climbs onto your Travel Form or wolf even after a fight",
"When your brother uses Running Wild, you ride on his back",
"In Running Wild you ride on your brother's shoulders",
"Your weapons no longer go missing after a Running Wild ride",
"When both halves use the same resource, their pool is twice as big",
"The subclass window shows every CoA class's own background at full strength",
"You can rearrange Subclass Bar 1 during combat without an error",
"Your other head or brother has a cast bar of their own",
"Choice talents in the subclass window show as one node with two options",
"SpellActivationOverlay can light up Subclass Bar 1",
"Your subclass's resource now shows as an extra bar under your portrait",
"Your other half's resource bar keeps its value when you log out and back in",
"Rage, energy and runic power subclasses now get and use their resource",
"Subclass resource orbs only appear when your subclass specialization can fill them",
"Your subclass specialization comes with its first class talent learned",
"Your main class's key stat now also powers your subclass",
"Subclass talents follow the paths and point requirements of their tree",
"Your summons follow your brother while he walks beside you",
"Your brother rides on the back of your Travel Form cat and moves with it",
"Dressing your twin in the wardrobe no longer causes an addon error",
"Your brother rides on your back in Wargstride",
"A Bloodmage subclass's Cursed Form no longer replaces your own action bar",
"Pressing an active subclass stance or form again turns it off",
"Character select shows your subclass under your class",
"The Two-Headed Ogre's second head no longer pokes through hats",
"Two-Headed Ogres keep aiming between shots instead of idling",
"Two-Headed Ogres who shoot rest their gun on the shoulder when not firing",
"Two-Headed Ogres who shoot themselves aim and fire their gun with the right hand",
"Two-Headed Ogres who shoot fire their bullets from the gun hand",
"The wardrobe shows a Two-Headed Ogre's applied look and her saved outfits apply again",
"The second head's quest mark floats over her head in cities and inns",
"Subclass Bar 1 no longer fills up with Throw, Shoot, Wand and Auto Attack",
"Abilities you learn from your subclass no longer land on your own action bars",
"A caster Two-Headed Ogre keeps her staff in hand while her second head shoots",
"A Two-Headed Ogre's staff keeps its size when she puts it on her back",
"A shooting subclass starts Auto Shot on right-click without logging out first",
"A Hunter subclass keeps Auto Shot going while the main head casts or moves",
"Weapons and armor from a subclass stay usable after logging in again",
"Two-Headed Ogres are Horde again and Thin Twins share Forgotten race rules",
"Thin Humans and Two-Headed Ogres can no longer be created as Hero",
"The Two-Headed Ogre stays in her combat stance between attacks",
"The second-head tab only shows for Two-Headed Ogres and Thin Twins",
"Thin Twins capes no longer show their inside at the shoulders",
"Thin Twins keep short hair under hats",
"Thin Twins keep their face, cape and hat fit with CoA Custom 1.9.2",
"Thin Twins show their class gear in character creation",
"Two-Headed Ogre capes drape over her back",
"CoA Custom 1.9.5 races work on the subclass server",
"With Play easy, cowboy the brother leaves a spent timed form",
"The Two-Headed Ogre casts with a raised fist before her face",
"The second-head client patch is now patch-ZZZZT.MPQ",
"Dual Wield shows once in the spellbook, whichever class teaches it",
"The subclass addon keeps working when the Twins or Ogre are renamed",
"The subclass name shows only on the character tab",
"The Thin Twins' Accursed brother keeps his distance until he takes his cursed form",
"The Thin Twins' brother follows a form's cost, cooldown and duration",
"The Thin Twins' own mana bar no longer flickers",
"Witch Hunter Vault now springs over in a handspring instead of a jump",
"The Twins brother keeps his timed form and no longer takes forms a spell forbids",
"The Twins brother faces his target, leaps in and leaves a form to heal you",
"With Play easy, cowboy, the brother uses his timed forms in a fight",
"Original races no longer look broken in the 64-bit client's character creation",
"Subclasses get their specialization's free passives, like the Pyromancer's draconic form",
"The subclass cast bar no longer gets stuck and can always be Alt-dragged",
"Pick-one talents in the subclass window no longer overlap their neighbours",
"Subclass spells get their rank upgrades, resources and class mechanics",
"Subclass talents that replace a spell now replace it for the subclass too",
"The Thin Twins keep their own hairstyle under hats",
"The Twins brother takes the look of the cursed form he actually uses",
"The Twins brother stands beside you at character select in his own clothes",
"The Twins brother climbs down from your back before taking a form",
"Spells the Twins brother casts no longer play a cast animation on you",
"The Thin Twins brother is now your mirror image",
"The Thin Twins brother can have his own face, hair style and beard",
"A script builds the original races' Vault patches from your own client files",
"The subclass client patch is now built after the release's own patches",
"The mirrored Thin Twins brother is built from the current Thin Twins model",
"Pressing your subclass mount again dismounts you",
"Removing a subclass dismisses the pet it let you summon",
"Removing a Warlock or Paladin subclass no longer unlearns your mounts",
"Removing a subclass no longer leaves its spells in your spellbook",
"A Starcaller subclass shows Lunar Phase as CoA's moon",
"Your twin's or other head's pet gets its own movable pet bar",
"A Ranged Head stands still while the Melee Head is offline",
"A bot plays the missing head of a Two-Players ogre",
"A Ranged Head keeps an echo of its deleted Melee Head's gear",
"Two-Players ogres hold books, pouches and orbs forward in the off hand",
"Two-Players ogres can pair up as Melee Head and Ranged Head",
"Paired Two-Players heads share one body",
"SquidBots Lite no longer prints \"Command 'dc status' does not exist\" at login",
"The subclass action bar no longer causes a blocked-action error in combat",
"Two-Players heads split their abilities into melee for the body and ranged for the rider",
"Two-Players heads gain Agree or Disagree stacks when they fight together",
"Two-Players heads can only be CoA classes",
"The Ranged Head's gear slots are frozen in ice and can no longer be dragged",
"Two-Players heads find the abilities they borrow on their own bar",
"Two-Players ogres can Bonk Heads! together once the heads have agreed long enough",
"Abilities lent between Two-Players heads follow each head's respecs and new spells",
"Two-Players ogres can use Mutate Me! to take the eyes-everywhere look and back",
"A Two-Players ogre fills one party spot and enters dungeons as one player",
"A Two-Players ogre joins a party only when there is room for both heads",
"A Ranged Head's own frame now stands for the shared Two-Players body",
"The Two-Players Ranged Head shares the body's health and both heads get full kill XP",
"The Two-Players Ranged Head shares the body's gear",
"Two-Players heads split quest gold, share one resource pool and keep their head's specs",
"Mobs attacked by the Two-Players Ranged Head now fight the body",
"Two-Players Twins: the second brother rides piggyback on the first, visible as himself",
"Bot plans panel shows what your group's bots are doing and lets you pick their next quest",
"Questing bots do all their quests in one area before moving on",
"The Twins' second brother keeps and wears his own gear on his brother's back",
"A Two-Players twin can call his brother to his side until another player joins him",
"Agree now raises spell and ranged hit too, not only melee hit",
"Two-Players ogres drop their mount when either head attacks",
"The other head's abilities now go on your own action bars",
"A bot body keeps questing, looting and resting after a fight instead of standing still",
"A bot body's SquidBots menu now opens from a button on your own player frame",
"Character select shows a Two-Players head's joined name and its partner's class",
"The Ranged Head now goes into and out of Dungeon Finder dungeons with the body",
"Two-Players can be switched off with Subclass.TwoPlayers.Enable",
"The other head's abilities only cost you resources when they actually go off",
"Character select shows a Two-Players ogre in his Mutate Me look",
"The Ranged Head gets the enchant, gem and suffix stats of the shared gear",
"The Ranged Head of a Two-Headed Ogre no longer pops out of the body at logout",
"A Ranged Head and its bot body are in one party again, so party chat and bot orders work",
"A bot riding as the Ranged Head no longer rests, roams or makes the body sit down",
"The character sheet of a Two-Players head shows the other head's class",
"Two-Players Ogres can fit a carried mount in a window and share the fit",
"Custom Races V2 with 17 new races, subclasses and the Fading Island",
"Updated Custom Races to 2.0"
"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"
]
}
}
-223
View File
@@ -1,223 +0,0 @@
import pathlib
import runpy
import sys
import tempfile
import unittest
import time
from unittest.mock import patch
BRIDGE = pathlib.Path(__file__).resolve().parents[1] / 'crates/coa-core/src/launcher_bridge.py'
class LauncherBridgeTests(unittest.TestCase):
def launch(self, action, body):
with tempfile.TemporaryDirectory() as directory:
script = pathlib.Path(directory) / 'Scripts/manage.py'
script.parent.mkdir()
script.write_text(body, encoding='utf8')
original = runpy.run_path
def capture(*args, **kwargs):
self.launcher = original(*args, **kwargs)
return self.launcher
with patch.object(sys, 'argv', ['bridge', str(script), action]), patch.object(runpy, 'run_path', side_effect=capture):
return original(str(BRIDGE))
def shutdown_fixture(self, *, console_error='RuntimeError', stopped=True, foreign=False, same=True, modern=False, terminate_error=False):
return f'''
from pathlib import Path
from contextlib import nullcontext
calls = []
world = {{'pid': 123, 'created': 456, 'exe': str(Path(__file__).resolve().parents[1] / {'"foreign.exe"' if foreign else '"Core/worldserver.exe"'})}}
def wait_ready(*args): pass
def start_mysql(): raise AssertionError('must not start')
def main(): raise AssertionError('must not prepare')
def settings(): return {{}}
def control_lock(): return nullcontext()
def process(name): return world if name == 'world' else None
def same_process(record): return {same!r}
def ra(command, config):
calls.append('console')
{'raise '+console_error+'("Start this repack worldserver first")' if console_error else 'return "Graceful shutdown"'}
def terminate(record):
assert record is world
calls.append('terminate')
{'raise RuntimeError("identity changed")' if terminate_error else 'pass'}
def wait_stopped(record, seconds):
assert record is world
calls.append('wait')
return {stopped!r}
def stop_all(config):
record = process('world')
if record:
if {modern!r}:
try: ra('server shutdown 1s 0', config)
except (OSError, RuntimeError): terminate(record)
else:
ra('server shutdown 1s 0', config)
if not wait_stopped(record, 60): raise RuntimeError('world still alive')
calls.append('mysql-shutdown')
'''
def test_unavailable_console_in_restored_legacy_launcher_stops_owned_world_before_mysql(self):
for error in ['RuntimeError', 'OSError']:
with self.subTest(error=error):
result = self.launch('stop-all', self.shutdown_fixture(console_error=error))
self.assertEqual(result['launcher']['calls'], ['console', 'terminate', 'wait', 'wait', 'mysql-shutdown'])
def test_force_stop_terminates_only_the_owned_world_before_mysql(self):
body = self.shutdown_fixture(console_error=None)
body = body.replace("return world if name == 'world' else None", "return world if name == 'world' and 'terminate' not in calls else None")
result = self.launch('force-stop-all', body)
self.assertEqual(result['launcher']['calls'], ['terminate', 'wait', 'mysql-shutdown'])
def test_force_stop_rejects_foreign_or_reused_pids_and_a_world_that_stays_alive(self):
for options, message in [({'foreign': True}, 'ownership could not be verified'),
({'same': False}, 'ownership could not be verified'),
({'stopped': False}, 'database was left running')]:
with self.subTest(options=options):
with self.assertRaisesRegex(Exception, message):
self.launch('force-stop-all', self.shutdown_fixture(**options))
self.assertNotIn('mysql-shutdown', self.launcher['calls'])
def test_healthy_console_keeps_graceful_shutdown(self):
result = self.launch('stop-all', self.shutdown_fixture(console_error=None))
self.assertEqual(result['launcher']['calls'], ['console', 'wait', 'mysql-shutdown'])
def test_foreign_or_reused_process_is_never_terminated_even_by_a_modern_launcher_catch(self):
for modern in [False, True]:
for identity in [{'foreign': True}, {'same': False}]:
with self.subTest(modern=modern, **identity):
with self.assertRaisesRegex(Exception, 'ownership could not be verified'):
self.launch('stop-all', self.shutdown_fixture(modern=modern, **identity))
self.assertEqual(self.launcher['calls'], ['console'])
def test_world_that_stays_alive_blocks_database_shutdown(self):
for modern in [False, True]:
with self.subTest(modern=modern):
with self.assertRaisesRegex(Exception, 'database was left running'):
self.launch('stop-all', self.shutdown_fixture(stopped=False, modern=modern))
self.assertEqual(self.launcher['calls'], ['console', 'terminate', 'wait'])
def test_termination_identity_failure_leaves_mysql_untouched(self):
for modern in [False, True]:
with self.subTest(modern=modern):
with self.assertRaisesRegex(Exception, 'could not be stopped safely'):
self.launch('stop-all', self.shutdown_fixture(terminate_error=True, modern=modern))
self.assertEqual(self.launcher['calls'], ['console', 'terminate'])
def test_slow_mysql_gets_time_to_finish_but_other_waits_are_unchanged(self):
result = self.launch('start-mysql', '''
calls = []
def wait_ready(name, port, seconds=180):
calls.append((name, seconds))
if name == 'mysql' and seconds < 162:
raise RuntimeError('mysql is still starting')
def start_mysql():
wait_ready('mysql', 12345, 60)
def main():
start_mysql()
wait_ready('world', 23456, 180)
wait_ready('mysql', 12345, 900)
''')
calls = result['launcher']['calls']
self.assertEqual(calls[0], ('mysql', 300))
self.assertEqual(calls[2], ('mysql', 900))
self.assertEqual(calls[1][0], 'world')
self.assertAlmostEqual(calls[1][1], 1500, delta=1)
def world_start(self, *, game_at=420, console_at=480, dies_at=None, requested=180):
clock = [0.0]
def sleep(seconds): clock[0] += seconds
body = f'''
import time
calls = []
dies_at = {dies_at!r}
def wait_ready(name, port, seconds=180):
until = time.monotonic() + seconds
while time.monotonic() < until:
if dies_at is not None and time.monotonic() >= dies_at:
raise RuntimeError('world stopped during startup')
if time.monotonic() >= ({game_at!r} if port == 1 else {console_at!r}):
calls.append(port)
return
time.sleep(0.5)
raise RuntimeError('world is still starting')
def start_mysql(): pass
def settings(): return {{}}
def process(name): return {{'pid': 1}}
def ra(command, config): return 'server info ready'
def main():
wait_ready('world', 1, {requested})
wait_ready('world', 2, {requested})
'''
with patch('time.monotonic', side_effect=lambda: clock[0]), patch('time.sleep', side_effect=sleep):
result = self.launch('start-all', body)
return clock[0], result['launcher']['calls']
def test_open_ports_do_not_finish_startup_until_commands_are_processed(self):
clock = [0.0]
def sleep(seconds): clock[0] += seconds
body = """
import time
calls=[]
def wait_ready(*args): pass
def start_mysql(): pass
def settings(): return {}
def process(name): return {'pid': 1}
def ra(command, config):
calls.append(command)
if time.monotonic() < 5: raise TimeoutError('main loop is loading')
return 'ready'
def main():
wait_ready('world',1)
wait_ready('world',2)
"""
with patch('time.monotonic', side_effect=lambda: clock[0]), patch('time.sleep', side_effect=sleep):
result=self.launch('start-all',body)
self.assertEqual(clock[0],5)
self.assertEqual(set(result['launcher']['calls']),{'server info'})
def test_world_death_after_ports_open_is_a_startup_failure(self):
body="""
def wait_ready(*args): pass
def start_mysql(): pass
def settings(): return {}
def process(name): return None
def main(): pass
"""
with self.assertRaisesRegex(RuntimeError,'stopped before its console accepted'):
self.launch('start-world',body)
def test_legacy_coa_world_waits_for_both_ports_after_three_minutes(self):
elapsed, calls = self.world_start()
self.assertEqual((elapsed, calls), (480, [1, 2]))
def test_console_wait_shares_the_world_deadline(self):
with self.assertRaisesRegex(RuntimeError, 'still starting'):
self.world_start(game_at=1490, console_at=1510)
self.assertEqual(self.launcher['calls'], [1])
def test_world_exit_is_reported_without_waiting_out_the_extended_budget(self):
with self.assertRaisesRegex(RuntimeError, 'stopped during startup'):
self.world_start(dies_at=12)
self.assertEqual(self.launcher['calls'], [])
def test_existing_longer_world_timeout_is_preserved(self):
self.assertEqual(self.world_start(game_at=1600, console_at=1700, requested=1800), (1700, [1, 2]))
def test_stop_dispatch_does_not_prepare_or_start_anything(self):
result = self.launch('stop-all', '''
from contextlib import nullcontext
calls = []
def wait_ready(*args): raise AssertionError('must not wait')
def start_mysql(): raise AssertionError('must not start')
def main(): raise AssertionError('must not prepare')
def settings(): return {'mysqlPort': 12345}
def control_lock(): return nullcontext()
def stop_all(config): calls.append(config['mysqlPort'])
''')
self.assertEqual(result['launcher']['calls'], [12345])
if __name__ == '__main__':
unittest.main()