Files
coa-server-manager/crates/coa-core/src/multiworld.rs
T

165 lines
9.5 KiB
Rust

//! A second supervised world with isolated configs, logs and ports; auth and MySQL remain shared.
use std::{collections::BTreeMap, fs, path::{Path, PathBuf}};
use crate::{Error, Result, fsx, realms::{self, Mode, RealmState}, driver::{self, Verb}, process::{self, ServiceState}};
pub fn root(main: &Path) -> PathBuf { main.join(".realms/secondary") }
pub fn is_running(main: &Path) -> bool {
let second = root(main);
if !second.exists() { return false; }
let status = process::observe(&second, &crate::layout::read_ports(&second));
status.world.state != ServiceState::Stopped
|| ["supervisor", "relay"].iter().any(|n| process::read_state_record(&second, n).is_some_and(|p| process::is_alive(&p)))
}
fn copy_tree(from: &Path, to: &Path) -> Result<()> {
fs::create_dir_all(to)?;
for entry in fs::read_dir(from)? {
let entry = entry?;
if entry.file_name() == "Logs" || entry.file_name() == "reports" || entry.file_name() == "__pycache__" { continue; }
if entry.file_type()?.is_symlink() { return Err(Error::Invalid("A linked runtime file cannot be used for a second realm.".into())); }
let target = fsx::ensure_within(to, &to.join(entry.file_name()))?;
if entry.file_type()?.is_dir() { copy_tree(&entry.path(), &target)?; }
else if !target.is_file() || fsx::sha256_file(&entry.path())? != fsx::sha256_file(&target)? { fs::copy(entry.path(), target)?; }
}
Ok(())
}
pub fn set_enabled(main: &Path, enabled: bool) -> Result<realms::View> {
if enabled && !cfg!(windows) { return Err(Error::Invalid("Simultaneous realms currently require Windows.".into())); }
if enabled {
if !realms::view(main)?.supported { return Err(Error::Invalid("Update the server to a build with Wildcard support first.".into())); }
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 || status.auth.state != ServiceState::Stopped || is_running(main) {
return Err(Error::Invalid("Stop both realms before changing simultaneous startup.".into()));
}
let original = realms::state(main)?.active;
if enabled && !realms::state(main)?.wildcard_created {
realms::select(main, Mode::Wildcard)?;
if original != Mode::Wildcard { realms::select(main, original)?; }
}
let mut s = realms::state(main)?;
if enabled {
let p = crate::layout::read_ports(main);
let mut reserved = vec![p.mysql, p.auth, p.world, p.ra];
let mut choose = |saved: Option<u16>, near: u16| -> Result<u16> {
if let Some(port) = saved.filter(|p| *p > 0 && !reserved.contains(p)) { reserved.push(port); return Ok(port); }
let port = (near.saturating_add(1)..=u16::MAX).find(|p| !reserved.contains(p) && std::net::TcpListener::bind(("127.0.0.1", *p)).is_ok())
.ok_or_else(|| Error::Invalid("No free port for the second realm.".into()))?;
reserved.push(port); Ok(port)
};
s.secondary_world_port = Some(choose(s.secondary_world_port, p.world)?);
s.secondary_ra_port = Some(choose(s.secondary_ra_port, p.ra)?);
}
s.simultaneous = enabled;
fsx::atomic_write_json(&main.join("Settings/realm-profile.json"), &s)?;
realms::view(main)
}
fn prepare(main: &Path) -> Result<PathBuf> {
if is_running(main) { return Err(Error::Invalid("The second realm is still running; stop it before preparing its files.".into())); }
let s = realms::state(main)?;
let mode = if s.active == Mode::Coa { Mode::Wildcard } else { Mode::Coa };
let second = fsx::ensure_within(main, &root(main))?;
for folder in ["Runtime", "BugReport", "mysql/bin"] { copy_tree(&main.join(folder), &fsx::ensure_within(&second, &second.join(folder))?)?; }
if main.join("Scripts/squid_playerbots.py").is_file() {
fs::create_dir_all(second.join("Scripts"))?;
fs::copy(main.join("Scripts/squid_playerbots.py"), second.join("Scripts/squid_playerbots.py"))?;
}
if main.join("Core/reference").is_dir() { copy_tree(&main.join("Core/reference"), &fsx::ensure_within(&second, &second.join("Core/reference"))?)?; }
for entry in fs::read_dir(main.join("Core"))? {
let entry = entry?;
if entry.file_type()?.is_file() && (entry.file_name() == "worldserver.exe" || entry.path().extension().is_some_and(|x| x == "dll")) {
fs::create_dir_all(second.join("Core"))?;
fs::copy(entry.path(), fsx::ensure_within(&second, &second.join("Core").join(entry.file_name()))?)?;
}
}
let files: BTreeMap<String, Vec<u8>> = fsx::read_json(&main.join(format!("Settings/realm-profiles/{}.json", mode.name())))?;
// A previous secondary run may have used the other realm's module files.
for path in crate::backup::config_files(&second) {
if path.starts_with("Core/configs/") && path.ends_with(".conf") && !files.contains_key(&path) {
fs::remove_file(fsx::ensure_within(&second, &fsx::safe_join(&second, &path)?)?)?;
}
}
for (path, bytes) in files {
if !(path.starts_with("Core/configs/") && path.ends_with(".conf") || path.starts_with("Settings/") && path.ends_with(".template")) {
return Err(Error::Invalid("Invalid secondary realm configuration path.".into()));
}
let text = String::from_utf8(bytes).map_err(|_| Error::Invalid("Invalid realm config encoding.".into()))?;
let shared = main.to_string_lossy().replace('\\', "/");
let text = text.replace("@DATA@", &format!("{shared}/Data"))
.replace("@ASCENSION_DBC@", &format!("{shared}/Data/dbc/Ascension"))
.replace("@MYSQL_EXE@", &format!("{shared}/mysql/bin/mysql.exe"));
let text = if path == "Settings/worldserver.conf.template" {
let main_conf = crate::config::parser::ConfFile::parse_bytes(&fs::read(main.join(&path))?)?;
let mut other_conf = crate::config::parser::ConfFile::parse_bytes(text.as_bytes())?;
if let Some(bind) = main_conf.get("BindIP") { other_conf.set("BindIP", bind, &[]); }
other_conf.set("Ra.IP", "\"127.0.0.1\"", &[]);
other_conf.to_text()
} else if path == "Core/configs/modules/coa.conf" {
let mut conf = crate::config::parser::ConfFile::parse_bytes(text.as_bytes())?;
if crate::friends::bind_is_open(main) { conf.set("CoA.AllowRemoteClients", "1", &[]); }
conf.to_text()
} else { text };
fsx::atomic_write(&fsx::ensure_within(&second, &fsx::safe_join(&second, &path)?)?, text.as_bytes())?;
}
let mut cfg: serde_json::Value = fsx::read_json(&main.join("Settings/repack.json"))?;
cfg["worldPort"] = s.secondary_world_port.ok_or_else(|| Error::Invalid("Second realm world port is missing.".into()))?.into();
cfg["raPort"] = s.secondary_ra_port.ok_or_else(|| Error::Invalid("Second realm console port is missing.".into()))?.into();
fsx::atomic_write_json(&second.join("Settings/repack.json"), &cfg)?;
fsx::atomic_write(&second.join("Settings/database.json"), &fs::read(main.join("Settings/database.json"))?)?;
fsx::atomic_write_json(&second.join("Settings/realm-profile.json"), &RealmState { active: mode, wildcard_created: true, ..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())); }
Ok(source.replace(marker, "def start_world(config, offset):\n mysql(admin=\"ping\")"))
}
pub fn start(main: &Path) -> Result<()> {
if !realms::state(main)?.simultaneous { return Ok(()); }
if is_running(main) {
let second = root(main);
if process::observe(&second, &crate::layout::read_ports(&second)).world.state == ServiceState::Running { return Ok(()); }
return Err(Error::Invalid("The second realm is still starting or stopping.".into()));
}
let second = prepare(main)?;
let out = driver::run(&second, Verb::StartWorld)?;
if !out.ok { return Err(Error::Invalid(format!("The second realm did not start: {}", out.output))); }
Ok(())
}
pub fn stop(main: &Path) -> Result<()> {
let second = root(main);
if !second.join("Scripts/manage.py").exists() {
if is_running(main) { return Err(Error::Invalid("The running second realm's launcher is missing. The shared database was left running.".into())); }
return Ok(());
}
// Its state has no auth/MySQL records: the shared database remains up until the primary world stops.
if is_running(main) {
let out = driver::run(&second, Verb::StopAll)?;
if !out.ok || is_running(main) { return Err(Error::Invalid(format!("The second realm could not stop; the database was left running: {}", out.output))); }
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
#[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());
}
}