Files
coa-server-manager/crates/coa-core/src/launcher/settings.rs
T
Дмитрий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

169 lines
7.7 KiB
Rust

//! `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()));
}
}