mirror of
https://github.com/Corfirean/coa-server-manager.git
synced 2026-11-19 03:25:56 +00:00
Settings gets two options, one per extra realm; turning on both runs all three realms. Each extra world keeps its own folder, configs, logs and ports (multiworld now handles a set of worlds instead of one second world), and Warcraft Reborn gets its own status card, realm list entry and firewall rule. Starting a server also sets CoA.ClassModel of the realm chosen on Overview to exactly that realm's model, so the shipped "coa wcr" default no longer shows two class models on a Conquest of Azeroth realm. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
1685 lines
59 KiB
Rust
1685 lines
59 KiB
Rust
//! Start, stop and observe the three containers of a Docker installation.
|
|
//!
|
|
//! Start order matters: the database must be healthy before the game servers, and the world server must be listening
|
|
//! before the auth server, because the auth server refuses to run while no realm is online.
|
|
|
|
use std::collections::HashMap;
|
|
use std::net::{IpAddr, Ipv4Addr, SocketAddr};
|
|
use std::path::Path;
|
|
use std::time::Duration;
|
|
|
|
use serde_json::Value;
|
|
|
|
use super::cli::{Call, Docker, SystemDocker};
|
|
use super::{runtime_image, Config, Names, RUNTIME_DOCKERFILE};
|
|
use crate::driver::{DriverOutcome, Verb};
|
|
use crate::error::{ErrorCode, Result};
|
|
use crate::layout::{read_ports, Ports};
|
|
use crate::process::{Observed, ServiceState, ServiceStatus};
|
|
|
|
/// Where the server folder and the game data appear inside the containers.
|
|
const CORE: &str = "/srv/core";
|
|
const DATA: &str = "/srv/data";
|
|
/// Fixed ports inside the containers; the host side comes from `Settings/repack.json`.
|
|
const AUTH_PORT: u16 = 3724;
|
|
const WORLD_PORT: u16 = 8085;
|
|
const RA_PORT: u16 = 3443;
|
|
|
|
const QUICK: Duration = Duration::from_secs(20);
|
|
const POLL: Duration = Duration::from_secs(1);
|
|
const DB_WAIT: u32 = 120;
|
|
const WORLD_WAIT: u32 = 300;
|
|
const AUTH_WAIT: u32 = 60;
|
|
|
|
struct Failure {
|
|
code: ErrorCode,
|
|
output: String,
|
|
}
|
|
|
|
type Step<T> = std::result::Result<T, Failure>;
|
|
|
|
#[derive(Default)]
|
|
struct Log(Vec<String>);
|
|
|
|
impl Log {
|
|
fn say(&mut self, line: impl Into<String>) {
|
|
self.0.push(line.into());
|
|
}
|
|
}
|
|
|
|
fn fail<T>(code: ErrorCode, output: impl Into<String>) -> Step<T> {
|
|
Err(Failure {
|
|
code,
|
|
output: output.into(),
|
|
})
|
|
}
|
|
|
|
pub fn run(root: &Path, verb: Verb) -> Result<DriverOutcome> {
|
|
run_with(&SystemDocker, root, verb)
|
|
}
|
|
|
|
pub fn run_with(d: &dyn Docker, root: &Path, verb: Verb) -> Result<DriverOutcome> {
|
|
let cfg = Config::load(root)?;
|
|
let mut log = Log::default();
|
|
let result = match verb {
|
|
Verb::StartWorld => {
|
|
return Err(crate::Error::Invalid(
|
|
"Starting a secondary world is not supported for Docker servers.".into(),
|
|
))
|
|
}
|
|
Verb::StartAll => start(d, root, &cfg, true, &mut log),
|
|
Verb::StartMysql => start(d, root, &cfg, false, &mut log),
|
|
Verb::StopAll => stop(d, &cfg, &mut log),
|
|
};
|
|
Ok(match result {
|
|
Ok(()) => DriverOutcome {
|
|
ok: true,
|
|
exit_code: Some(0),
|
|
code: None,
|
|
human: None,
|
|
output: log.0.join("\n"),
|
|
},
|
|
Err(f) => {
|
|
log.say(f.output);
|
|
DriverOutcome {
|
|
ok: false,
|
|
exit_code: None,
|
|
code: Some(f.code),
|
|
human: Some(f.code.human()),
|
|
output: log.0.join("\n"),
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------------------------- docker calls
|
|
|
|
/// Run docker; only "docker cannot be started" is an error here, a non-zero exit is returned for the caller to judge.
|
|
fn docker(d: &dyn Docker, args: &[&str], timeout: Duration) -> Step<super::cli::Output> {
|
|
d.run(&Call::new(args, timeout))
|
|
.or_else(|e| fail(ErrorCode::DockerUnavailable, e.to_string()))
|
|
}
|
|
|
|
/// Is docker usable by this user? Returns its version, or the reason in docker's own words.
|
|
pub fn check_docker(d: &dyn Docker) -> Result<String> {
|
|
let mut log = Log::default();
|
|
match preflight(d, &mut log) {
|
|
Ok(()) => Ok(log.0.join(" ")),
|
|
Err(f) => Err(crate::error::Error::Invalid(
|
|
format!("{} {}", f.code.human().message, f.output.trim())
|
|
.trim()
|
|
.to_string(),
|
|
)),
|
|
}
|
|
}
|
|
|
|
/// Remove everything docker holds for an installation: containers, network and the database volume. Used when an
|
|
/// installation fails before it is finished, and later to uninstall. Missing pieces are not an error.
|
|
pub(crate) fn destroy(d: &dyn Docker, cfg: &Config) {
|
|
let n = cfg.names();
|
|
for name in [&n.auth, &n.world, &n.db] {
|
|
let _ = d.run(&Call::new(&["rm", "--force", name], QUICK));
|
|
}
|
|
let _ = d.run(&Call::new(&["network", "rm", &n.network], QUICK));
|
|
let _ = d.run(&Call::new(&["volume", "rm", &n.volume], QUICK));
|
|
}
|
|
|
|
fn preflight(d: &dyn Docker, log: &mut Log) -> Step<()> {
|
|
let o = docker(d, &["version", "--format", "{{.Server.Version}}"], QUICK)?;
|
|
if !o.ok() {
|
|
// Typical causes: the service is stopped, or the user is not allowed to talk to it.
|
|
return fail(ErrorCode::DockerUnavailable, o.text());
|
|
}
|
|
log.say(format!("docker {}", o.stdout.trim()));
|
|
Ok(())
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq)]
|
|
pub(crate) struct Container {
|
|
pub status: String,
|
|
pub exit_code: i64,
|
|
pub oom_killed: bool,
|
|
pub pid: Option<u32>,
|
|
pub started_at: Option<String>,
|
|
/// "healthy", "unhealthy" or "starting" when the container has a health check.
|
|
pub health: Option<String>,
|
|
}
|
|
|
|
impl Container {
|
|
fn running(&self) -> bool {
|
|
self.status == "running"
|
|
}
|
|
}
|
|
|
|
/// State of the named containers that exist (the others are simply absent from the result).
|
|
fn inspect(d: &dyn Docker, names: &[&str]) -> Step<HashMap<String, Container>> {
|
|
let mut args = vec!["inspect"];
|
|
args.extend_from_slice(names);
|
|
let o = docker(d, &args, QUICK)?;
|
|
// docker prints what it found and complains about the rest with a non-zero exit code.
|
|
let found = parse_inspect(&o.stdout);
|
|
if !o.ok()
|
|
&& found.is_empty()
|
|
&& !o.stderr.contains("No such object")
|
|
&& !o.stderr.contains("no such object")
|
|
{
|
|
return fail(ErrorCode::DockerUnavailable, o.text());
|
|
}
|
|
Ok(found)
|
|
}
|
|
|
|
pub(crate) fn parse_inspect(json: &str) -> HashMap<String, Container> {
|
|
let Ok(Value::Array(items)) = serde_json::from_str::<Value>(json) else {
|
|
return HashMap::new();
|
|
};
|
|
items
|
|
.iter()
|
|
.filter_map(|v| {
|
|
let name = v["Name"].as_str()?.trim_start_matches('/').to_string();
|
|
let s = &v["State"];
|
|
Some((
|
|
name,
|
|
Container {
|
|
status: s["Status"].as_str()?.to_string(),
|
|
exit_code: s["ExitCode"].as_i64().unwrap_or(0),
|
|
oom_killed: s["OOMKilled"].as_bool().unwrap_or(false),
|
|
pid: s["Pid"].as_u64().filter(|p| *p > 0).map(|p| p as u32),
|
|
started_at: s["StartedAt"].as_str().map(str::to_string),
|
|
health: s["Health"]["Status"].as_str().map(str::to_string),
|
|
},
|
|
))
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
fn strip_ansi(s: &str) -> String {
|
|
let mut out = String::with_capacity(s.len());
|
|
let mut chars = s.chars().peekable();
|
|
while let Some(c) = chars.next() {
|
|
if c == '\u{1b}' && chars.peek() == Some(&'[') {
|
|
for n in chars.by_ref() {
|
|
if n.is_ascii_alphabetic() {
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
out.push(c);
|
|
}
|
|
}
|
|
out
|
|
}
|
|
|
|
/// Last lines a container wrote, as the technical details of a failure, and the cause they point to.
|
|
fn why_stopped(d: &dyn Docker, name: &str) -> (ErrorCode, String) {
|
|
let text = d
|
|
.run(&Call::new(&["logs", "--tail", "60", name], QUICK))
|
|
.map(|o| strip_ansi(&o.text()))
|
|
.unwrap_or_default();
|
|
(
|
|
crate::health::diagnose(&text).unwrap_or(ErrorCode::StartupFailed),
|
|
format!("--- last lines of {name}\n{text}"),
|
|
)
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------------------ start
|
|
|
|
struct Secrets {
|
|
root: String,
|
|
app: String,
|
|
}
|
|
|
|
fn start(d: &dyn Docker, root: &Path, cfg: &Config, with_game: bool, log: &mut Log) -> Step<()> {
|
|
preflight(d, log)?;
|
|
let n = cfg.names();
|
|
let secrets = crate::db::credentials(root)
|
|
.map(|(root, app)| Secrets { root, app })
|
|
.or_else(|e| fail(ErrorCode::ServerFilesIncomplete, e.to_string()))?;
|
|
let ports = read_ports(root);
|
|
let state = inspect(d, &[&n.db, &n.world, &n.auth])?;
|
|
|
|
if !docker(d, &["network", "inspect", &n.network], QUICK)?.ok() {
|
|
let o = docker(d, &["network", "create", &n.network], QUICK)?;
|
|
if !o.ok() {
|
|
return fail(ErrorCode::StartupFailed, o.text());
|
|
}
|
|
log.say(format!("created network {}", n.network));
|
|
}
|
|
|
|
if !state.get(&n.db).is_some_and(Container::running) {
|
|
remove(d, &n.db);
|
|
let mut call = Call::new(&[], Duration::from_secs(120));
|
|
call.args = db_args(cfg, &n, owner_of(root).as_deref());
|
|
call.env = vec![("MYSQL_ROOT_PASSWORD".into(), secrets.root.clone())];
|
|
let o = d
|
|
.run(&call)
|
|
.or_else(|e| fail(ErrorCode::DockerUnavailable, e.to_string()))?;
|
|
if !o.ok() {
|
|
return fail(ErrorCode::StartupFailed, o.text());
|
|
}
|
|
log.say(format!("started {}", n.db));
|
|
}
|
|
wait_database(d, &n, log)?;
|
|
if !with_game {
|
|
return Ok(());
|
|
}
|
|
|
|
// Realm profiles (CoA / Wildcard): the database is running and healthy here (started and waited for above), which the
|
|
// realm list update below needs. Finish an interrupted switch, then make the realm list say what is selected. The repack's
|
|
// launcher did this when it started; here nothing else would.
|
|
let realm = prepare_realm(root, log)?;
|
|
ensure_image(d, log)?;
|
|
super::ensure_main_configs(root).map_err(|e| Failure {
|
|
code: ErrorCode::ServerFilesIncomplete,
|
|
output: e.to_string(),
|
|
})?;
|
|
std::fs::create_dir_all(root.join("Core/Logs")).map_err(|e| Failure {
|
|
code: ErrorCode::ServerFilesIncomplete,
|
|
output: e.to_string(),
|
|
})?;
|
|
let owner = owner_of(root);
|
|
let host = std::fs::canonicalize(root).unwrap_or_else(|_| root.to_path_buf());
|
|
let host = crate::fsx::canonicalize_lenient(&host).unwrap_or(host);
|
|
|
|
if !state.get(&n.world).is_some_and(Container::running) {
|
|
remove(d, &n.world);
|
|
let mut call = Call::new(&[], Duration::from_secs(60));
|
|
call.args = game_args(
|
|
cfg,
|
|
&n,
|
|
GameKind::World,
|
|
&host,
|
|
&cfg.data_path(&host),
|
|
ports.world,
|
|
ports.ra,
|
|
owner.as_deref(),
|
|
);
|
|
call.env = database_env(&secrets, true, realm);
|
|
run_container(d, &call, &n.world, log)?;
|
|
}
|
|
wait_listening(d, cfg, &n.world, ports.world, WORLD_WAIT, log)?;
|
|
// The core leaves with code 2 for `server restart` and expects a supervisor to start it again (the repack has one). Docker
|
|
// does that for any non-zero exit, but only once the server has come up: a start that fails must stay failed, not loop.
|
|
// A stop by `docker stop` or `server shutdown` (code 0) is never restarted.
|
|
let _ = docker(d, &["update", "--restart", "on-failure:3", &n.world], QUICK);
|
|
|
|
if !state.get(&n.auth).is_some_and(Container::running) {
|
|
remove(d, &n.auth);
|
|
let mut call = Call::new(&[], Duration::from_secs(60));
|
|
call.args = game_args(
|
|
cfg,
|
|
&n,
|
|
GameKind::Auth,
|
|
&host,
|
|
&cfg.data_path(&host),
|
|
ports.auth,
|
|
0,
|
|
owner.as_deref(),
|
|
);
|
|
call.env = database_env(&secrets, false, realm);
|
|
run_container(d, &call, &n.auth, log)?;
|
|
}
|
|
wait_listening(d, cfg, &n.auth, ports.auth, AUTH_WAIT, log)?;
|
|
mark_realm_online(d, &n, &secrets, realm, log);
|
|
Ok(())
|
|
}
|
|
|
|
/// The auth server marks every realm offline when it starts, and the world server (already up, see the order above) only
|
|
/// puts itself back after its next uptime update, ten minutes later by default: until then the client shows "Realm is
|
|
/// Offline". The world is known to be listening here, so say so for the realm it serves. The other realm of a Wildcard
|
|
/// install keeps the offline flag it is given on purpose (`realms::setup_realmlist`).
|
|
fn mark_realm_online(
|
|
d: &dyn Docker,
|
|
n: &Names,
|
|
secrets: &Secrets,
|
|
realm: crate::realms::Mode,
|
|
log: &mut Log,
|
|
) {
|
|
let sql = format!(
|
|
"UPDATE acore_auth.realmlist SET flag = flag & ~2 WHERE id = {};",
|
|
realm.realm_id()
|
|
);
|
|
let mut call = Call::new(
|
|
&[
|
|
"exec",
|
|
"-i",
|
|
"-e",
|
|
"MYSQL_PWD",
|
|
&n.db,
|
|
"mysql",
|
|
"--user=root",
|
|
"--protocol=tcp",
|
|
"--host=127.0.0.1",
|
|
],
|
|
QUICK,
|
|
);
|
|
call.env = vec![("MYSQL_PWD".into(), secrets.root.clone())];
|
|
call.stdin = Some(sql.as_bytes());
|
|
match d.run(&call) {
|
|
Ok(o) if o.ok() => {}
|
|
Ok(o) => log.say(format!(
|
|
"the realm could not be marked online: {}",
|
|
o.text().trim()
|
|
)),
|
|
Err(e) => log.say(format!("the realm could not be marked online: {e}")),
|
|
}
|
|
}
|
|
|
|
fn remove(d: &dyn Docker, name: &str) {
|
|
// A stopped container of the same name is replaced, so its settings always match the files on disk.
|
|
let _ = d.run(&Call::new(&["rm", "-f", name], QUICK));
|
|
}
|
|
|
|
fn run_container(d: &dyn Docker, call: &Call, name: &str, log: &mut Log) -> Step<()> {
|
|
let o = d
|
|
.run(call)
|
|
.or_else(|e| fail(ErrorCode::DockerUnavailable, e.to_string()))?;
|
|
if !o.ok() {
|
|
let text = o.text();
|
|
let code = if text.contains("port is already allocated")
|
|
|| text.contains("address already in use")
|
|
{
|
|
ErrorCode::PortInUse
|
|
} else {
|
|
ErrorCode::StartupFailed
|
|
};
|
|
return fail(code, text);
|
|
}
|
|
log.say(format!("started {name}"));
|
|
Ok(())
|
|
}
|
|
|
|
fn ensure_image(d: &dyn Docker, log: &mut Log) -> Step<()> {
|
|
let image = runtime_image();
|
|
if docker(d, &["image", "inspect", &image], QUICK)?.ok() {
|
|
return Ok(());
|
|
}
|
|
log.say(format!("building {image} (first start only)"));
|
|
let mut call = Call::new(&["build", "--tag", &image, "-"], Duration::from_secs(900));
|
|
call.stdin = Some(RUNTIME_DOCKERFILE.as_bytes());
|
|
let o = d
|
|
.run(&call)
|
|
.or_else(|e| fail(ErrorCode::DockerUnavailable, e.to_string()))?;
|
|
if !o.ok() {
|
|
return fail(ErrorCode::StartupFailed, o.text());
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn wait_database(d: &dyn Docker, n: &Names, log: &mut Log) -> Step<()> {
|
|
for _ in 0..DB_WAIT {
|
|
let state = inspect(d, &[&n.db])?;
|
|
match state.get(&n.db) {
|
|
Some(c) if c.running() && c.health.as_deref() == Some("healthy") => {
|
|
log.say("database is ready");
|
|
return Ok(());
|
|
}
|
|
Some(c) if !c.running() => {
|
|
let (code, text) = why_stopped(d, &n.db);
|
|
return fail(
|
|
if code == ErrorCode::StartupFailed {
|
|
ErrorCode::DatabaseNotRunning
|
|
} else {
|
|
code
|
|
},
|
|
text,
|
|
);
|
|
}
|
|
None => {
|
|
return fail(
|
|
ErrorCode::DatabaseNotRunning,
|
|
"the database container does not exist",
|
|
)
|
|
}
|
|
_ => d.pause(POLL),
|
|
}
|
|
}
|
|
fail(
|
|
ErrorCode::DatabaseNotRunning,
|
|
"the database did not become ready in time",
|
|
)
|
|
}
|
|
|
|
/// Wait until the container accepts connections on its published port; give up when it stops or on timeout.
|
|
fn wait_listening(
|
|
d: &dyn Docker,
|
|
cfg: &Config,
|
|
name: &str,
|
|
port: u16,
|
|
seconds: u32,
|
|
log: &mut Log,
|
|
) -> Step<()> {
|
|
let addr = SocketAddr::new(connect_ip(cfg), port);
|
|
for _ in 0..seconds {
|
|
let state = inspect(d, &[name])?;
|
|
match state.get(name) {
|
|
Some(c) if c.running() => {
|
|
if d.port_open(addr) {
|
|
log.say(format!("{name} is listening on port {port}"));
|
|
return Ok(());
|
|
}
|
|
d.pause(POLL);
|
|
}
|
|
_ => {
|
|
let (code, text) = why_stopped(d, name);
|
|
return fail(code, text);
|
|
}
|
|
}
|
|
}
|
|
let (code, text) = why_stopped(d, name);
|
|
fail(
|
|
code,
|
|
format!("{name} was not listening on port {port} after {seconds} seconds\n{text}"),
|
|
)
|
|
}
|
|
|
|
/// Address to test a published port on from this computer.
|
|
fn connect_ip(cfg: &Config) -> IpAddr {
|
|
match cfg.bind_address.parse::<IpAddr>() {
|
|
Ok(ip) if !ip.is_unspecified() => ip,
|
|
_ => IpAddr::V4(Ipv4Addr::LOCALHOST),
|
|
}
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------- argument lists
|
|
|
|
fn db_args(cfg: &Config, n: &Names, owner: Option<&str>) -> Vec<String> {
|
|
let mut a: Vec<String> = ["run", "--detach", "--name"]
|
|
.iter()
|
|
.map(|s| s.to_string())
|
|
.collect();
|
|
a.push(n.db.clone());
|
|
a.extend([
|
|
"--network".into(),
|
|
n.network.clone(),
|
|
"--network-alias".into(),
|
|
"db".into(),
|
|
]);
|
|
a.extend(["--label".into(), format!("coa.project={}", cfg.project)]);
|
|
match &cfg.mysql_data {
|
|
Some(dir) => {
|
|
// A data directory from a Windows repack: it is written by the person who owns the folder, and its table names
|
|
// were folded to lower case (the repack's setting), which the server must be told because a Linux one does not.
|
|
a.extend(["--volume".into(), format!("{dir}:/var/lib/mysql")]);
|
|
if let Some(o) = owner {
|
|
a.extend(["--user".into(), o.into()]);
|
|
}
|
|
}
|
|
None => a.extend(["--volume".into(), format!("{}:/var/lib/mysql", n.volume)]),
|
|
}
|
|
// The password comes from the environment of the docker client, not from this command line.
|
|
a.extend(["--env".into(), "MYSQL_ROOT_PASSWORD".into()]);
|
|
// "mysqladmin ping" succeeds as soon as the server answers, with or without a login. It must go over TCP, like
|
|
// everything the Manager sends: while a new database initialises, the image first runs a temporary server that
|
|
// answers on its socket but takes no network connection, and a socket ping would call the container healthy for a few
|
|
// seconds in which every TCP connection is still refused.
|
|
a.extend([
|
|
"--health-cmd".into(),
|
|
"mysqladmin ping --protocol=tcp --host=127.0.0.1 --silent".into(),
|
|
]);
|
|
a.extend([
|
|
"--health-interval".into(),
|
|
"5s".into(),
|
|
"--health-timeout".into(),
|
|
"5s".into(),
|
|
"--health-retries".into(),
|
|
"40".into(),
|
|
]);
|
|
a.extend(["--stop-timeout".into(), "60".into()]);
|
|
a.push(cfg.mysql_image.clone());
|
|
if cfg.mysql_data.is_some() {
|
|
a.push("--lower-case-table-names=1".into());
|
|
}
|
|
a
|
|
}
|
|
|
|
#[derive(Clone, Copy, PartialEq)]
|
|
enum GameKind {
|
|
World,
|
|
Auth,
|
|
}
|
|
|
|
/// Connection strings: host;port;user;password;database. They hold the password, so they travel by environment.
|
|
fn database_env(s: &Secrets, world: bool, realm: crate::realms::Mode) -> Vec<(String, String)> {
|
|
let info = |db: &str| format!("db;3306;acore;{};{db}", s.app);
|
|
let mut env = vec![("AC_LOGIN_DATABASE_INFO".to_string(), info("acore_auth"))];
|
|
if world {
|
|
// The databases of the selected realm (the Wildcard realm has its own world and characters databases).
|
|
let schema = |kind: &str| realm.schema(kind).unwrap_or("acore_world");
|
|
env.push(("AC_WORLD_DATABASE_INFO".into(), info(schema("world"))));
|
|
env.push((
|
|
"AC_CHARACTER_DATABASE_INFO".into(),
|
|
info(schema("characters")),
|
|
));
|
|
}
|
|
env
|
|
}
|
|
|
|
/// Every setting variable (`AC_...`) the containers get, for the check that the screens know which settings are fixed.
|
|
#[cfg(test)]
|
|
pub(crate) fn forced_variables() -> Vec<String> {
|
|
let cfg = Config {
|
|
project: "t".into(),
|
|
bind_address: "127.0.0.1".into(),
|
|
mysql_image: "mysql:8.4".into(),
|
|
data_dir: None,
|
|
mysql_data: None,
|
|
};
|
|
let n = cfg.names();
|
|
let mut found = Vec::new();
|
|
for kind in [GameKind::World, GameKind::Auth] {
|
|
let args = game_args(&cfg, &n, kind, Path::new("/s"), Path::new("/d"), 1, 2, None);
|
|
found.extend(args.iter().filter_map(|a| {
|
|
a.strip_prefix("AC_")
|
|
.map(|rest| format!("AC_{}", rest.split('=').next().unwrap()))
|
|
}));
|
|
}
|
|
found.sort();
|
|
found.dedup();
|
|
found
|
|
}
|
|
|
|
/// Realm profiles are only in play once a profile has been chosen on this server (`Settings/realm-profile.json`).
|
|
fn prepare_realm(root: &Path, log: &mut Log) -> Step<crate::realms::Mode> {
|
|
let fail_with = |e: crate::error::Error| Failure {
|
|
code: ErrorCode::StartupFailed,
|
|
output: e.to_string(),
|
|
};
|
|
crate::realms::before_start(root).map_err(fail_with)?;
|
|
let active = crate::realms::state(root).map_err(fail_with)?.active;
|
|
if root.join("Settings/realm-profile.json").exists() {
|
|
crate::realms::setup_realmlist(root).map_err(fail_with)?;
|
|
let db = crate::db::Db::from_repack(root, crate::db::Account::Admin).map_err(fail_with)?;
|
|
db.query("UPDATE acore_auth.realmlist SET name='Conquest of Azeroth' WHERE id=1; UPDATE acore_auth.realmlist SET name='Wildcard' WHERE id=2;").map_err(fail_with)?;
|
|
log.say(format!("realm {}", active.name()));
|
|
}
|
|
Ok(active)
|
|
}
|
|
|
|
fn game_args(
|
|
cfg: &Config,
|
|
n: &Names,
|
|
kind: GameKind,
|
|
host: &Path,
|
|
data: &Path,
|
|
port: u16,
|
|
ra_port: u16,
|
|
owner: Option<&str>,
|
|
) -> Vec<String> {
|
|
let (name, alias, binary, conf, inner_port) = match kind {
|
|
GameKind::World => (
|
|
&n.world,
|
|
"world",
|
|
"./worldserver",
|
|
"configs/worldserver.conf",
|
|
WORLD_PORT,
|
|
),
|
|
GameKind::Auth => (
|
|
&n.auth,
|
|
"auth",
|
|
"./authserver",
|
|
"configs/authserver.conf",
|
|
AUTH_PORT,
|
|
),
|
|
};
|
|
let mut a: Vec<String> = vec![
|
|
"run".into(),
|
|
"--detach".into(),
|
|
"--name".into(),
|
|
name.clone(),
|
|
];
|
|
a.extend([
|
|
"--network".into(),
|
|
n.network.clone(),
|
|
"--network-alias".into(),
|
|
alias.into(),
|
|
]);
|
|
a.extend(["--label".into(), format!("coa.project={}", cfg.project)]);
|
|
if let Some(o) = owner {
|
|
// The server writes logs and configuration into the folder: do it as the person who owns it.
|
|
a.extend(["--user".into(), o.into()]);
|
|
}
|
|
a.extend(["--workdir".into(), CORE.into()]);
|
|
a.extend([
|
|
"--volume".into(),
|
|
format!("{}:{CORE}", host.join("Core").display()),
|
|
]);
|
|
a.extend([
|
|
"--publish".into(),
|
|
format!("{}:{port}:{inner_port}", cfg.bind_address),
|
|
]);
|
|
// Settings that must not depend on the configuration files: where things are inside the container, and listening
|
|
// on every interface of the container (the published address decides who can connect).
|
|
let env = |k: &str, v: &str| ["--env".to_string(), format!("{k}={v}")];
|
|
a.extend(env("AC_BIND_IP", "0.0.0.0"));
|
|
a.extend(env(
|
|
if kind == GameKind::World {
|
|
"AC_WORLD_SERVER_PORT"
|
|
} else {
|
|
"AC_REALM_SERVER_PORT"
|
|
},
|
|
&inner_port.to_string(),
|
|
));
|
|
a.extend(env("AC_LOGS_DIR", &format!("{CORE}/Logs")));
|
|
// The Manager applies database updates itself. The server's own updater would need a `mysql` client program inside
|
|
// the container and stops the server when it cannot find one.
|
|
a.extend(env("AC_UPDATES_ENABLE_DATABASES", "0"));
|
|
if kind == GameKind::World {
|
|
a.extend(["--volume".into(), format!("{}:{DATA}:ro", data.display())]);
|
|
let races = host.join("Data/dbc_races");
|
|
if races.is_dir() && races != data.join("dbc_races") {
|
|
a.extend([
|
|
"--volume".into(),
|
|
format!("{}:{DATA}/dbc_races:ro", races.display()),
|
|
]);
|
|
}
|
|
a.extend(env("AC_DATA_DIR", DATA));
|
|
// The remote console is only ever reachable from this computer.
|
|
a.extend(["--publish".into(), format!("127.0.0.1:{ra_port}:{RA_PORT}")]);
|
|
a.extend(env("AC_RA_ENABLE", "1"));
|
|
a.extend(env("AC_RA_IP", "0.0.0.0"));
|
|
a.extend(env("AC_RA_PORT", &RA_PORT.to_string()));
|
|
// Saving every character can take a while.
|
|
a.extend(["--stop-timeout".into(), "180".into()]);
|
|
a.extend([
|
|
"--env".into(),
|
|
"AC_WORLD_DATABASE_INFO".into(),
|
|
"--env".into(),
|
|
"AC_CHARACTER_DATABASE_INFO".into(),
|
|
]);
|
|
} else {
|
|
a.extend([
|
|
"--restart".into(),
|
|
"on-failure:3".into(),
|
|
"--stop-timeout".into(),
|
|
"30".into(),
|
|
]);
|
|
}
|
|
a.extend(["--env".into(), "AC_LOGIN_DATABASE_INFO".into()]);
|
|
a.push(runtime_image());
|
|
a.extend([binary.to_string(), "-c".into(), conf.into()]);
|
|
a
|
|
}
|
|
|
|
#[cfg(unix)]
|
|
fn owner_of(root: &Path) -> Option<String> {
|
|
use std::os::unix::fs::MetadataExt;
|
|
let m = std::fs::metadata(root).ok()?;
|
|
Some(format!("{}:{}", m.uid(), m.gid()))
|
|
}
|
|
|
|
#[cfg(not(unix))]
|
|
fn owner_of(_root: &Path) -> Option<String> {
|
|
None
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------------------- stop
|
|
|
|
fn stop(d: &dyn Docker, cfg: &Config, log: &mut Log) -> Step<()> {
|
|
preflight(d, log)?;
|
|
let n = cfg.names();
|
|
let state = inspect(d, &[&n.db, &n.world, &n.auth])?;
|
|
// Game servers first, the database last. The world server gets time to save every character.
|
|
for (name, seconds) in [(&n.world, 180u64), (&n.auth, 30), (&n.db, 60)] {
|
|
if state.get(name).is_some_and(Container::running) {
|
|
let t = seconds.to_string();
|
|
let o = docker(
|
|
d,
|
|
&["stop", "--time", &t, name],
|
|
Duration::from_secs(seconds + 30),
|
|
)?;
|
|
if !o.ok() {
|
|
return fail(ErrorCode::StartupFailed, o.text());
|
|
}
|
|
log.say(format!("stopped {name}"));
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------------------------------- observe
|
|
|
|
pub fn observe(root: &Path, ports: &Ports) -> Observed {
|
|
observe_with(&SystemDocker, root, ports)
|
|
}
|
|
|
|
pub fn observe_with(d: &dyn Docker, root: &Path, ports: &Ports) -> Observed {
|
|
let unknown = |name: &'static str, port: u16| ServiceStatus {
|
|
name,
|
|
state: ServiceState::Unknown,
|
|
pid: None,
|
|
port,
|
|
port_ready: false,
|
|
conflict: None,
|
|
uptime_secs: None,
|
|
};
|
|
let Ok(cfg) = Config::load(root) else {
|
|
return Observed {
|
|
mysql: unknown("mysql", ports.mysql),
|
|
auth: unknown("auth", ports.auth),
|
|
world: unknown("world", ports.world),
|
|
secondary_world: None,
|
|
reborn_world: None,
|
|
};
|
|
};
|
|
let n = cfg.names();
|
|
let Ok(state) = inspect(d, &[&n.db, &n.world, &n.auth]) else {
|
|
return Observed {
|
|
mysql: unknown("mysql", ports.mysql),
|
|
auth: unknown("auth", ports.auth),
|
|
world: unknown("world", ports.world),
|
|
secondary_world: None,
|
|
reborn_world: None,
|
|
};
|
|
};
|
|
let ip = connect_ip(&cfg);
|
|
let listening = |c: Option<&Container>, port: u16| {
|
|
c.is_some_and(Container::running) && d.port_open(SocketAddr::new(ip, port))
|
|
};
|
|
Observed {
|
|
mysql: status(
|
|
"mysql",
|
|
state.get(&n.db),
|
|
ports.mysql,
|
|
state
|
|
.get(&n.db)
|
|
.is_some_and(|c| c.health.as_deref() == Some("healthy")),
|
|
),
|
|
auth: status(
|
|
"auth",
|
|
state.get(&n.auth),
|
|
ports.auth,
|
|
listening(state.get(&n.auth), ports.auth),
|
|
),
|
|
world: status(
|
|
"world",
|
|
state.get(&n.world),
|
|
ports.world,
|
|
listening(state.get(&n.world), ports.world),
|
|
),
|
|
secondary_world: None,
|
|
reborn_world: None,
|
|
}
|
|
}
|
|
|
|
fn status(name: &'static str, c: Option<&Container>, port: u16, ready: bool) -> ServiceStatus {
|
|
let Some(c) = c else {
|
|
return ServiceStatus {
|
|
name,
|
|
state: ServiceState::Stopped,
|
|
pid: None,
|
|
port,
|
|
port_ready: false,
|
|
conflict: None,
|
|
uptime_secs: None,
|
|
};
|
|
};
|
|
let state = match c.status.as_str() {
|
|
"running" if ready => ServiceState::Running,
|
|
"running" | "created" | "restarting" => ServiceState::Starting,
|
|
// Stopped by `docker stop` (SIGTERM, then SIGKILL after the grace period) is a normal stop; anything else is a crash.
|
|
"exited"
|
|
if c.exit_code == 0
|
|
|| ((c.exit_code == 137 || c.exit_code == 143) && !c.oom_killed) =>
|
|
{
|
|
ServiceState::Stopped
|
|
}
|
|
"exited" => ServiceState::Crashed,
|
|
_ => ServiceState::Unknown,
|
|
};
|
|
let running = c.running();
|
|
ServiceStatus {
|
|
name,
|
|
state,
|
|
pid: if running { c.pid } else { None },
|
|
port,
|
|
port_ready: running && ready,
|
|
conflict: None,
|
|
uptime_secs: if running {
|
|
c.started_at.as_deref().and_then(uptime_since)
|
|
} else {
|
|
None
|
|
},
|
|
}
|
|
}
|
|
|
|
fn uptime_since(started: &str) -> Option<u64> {
|
|
let t = chrono::DateTime::parse_from_rfc3339(started).ok()?;
|
|
u64::try_from((chrono::Utc::now() - t.with_timezone(&chrono::Utc)).num_seconds()).ok()
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use crate::docker::cli::Output;
|
|
use std::cell::RefCell;
|
|
use std::collections::{BTreeMap, HashSet};
|
|
use std::fs;
|
|
|
|
const ROOT_PW: &str = "rootpw-ZZ1";
|
|
const APP_PW: &str = "apppw-QQ2";
|
|
|
|
/// A tiny in-memory Docker: containers, one network, one image. It answers the few commands the backend uses.
|
|
struct Sim {
|
|
calls: RefCell<Vec<Call2>>,
|
|
running: RefCell<HashSet<String>>,
|
|
exited: RefCell<BTreeMap<String, (i64, bool)>>,
|
|
network: RefCell<bool>,
|
|
image: RefCell<bool>,
|
|
logs: RefCell<String>,
|
|
unavailable: bool,
|
|
daemon_error: Option<String>,
|
|
/// `docker run` of this container fails with this message.
|
|
run_error: Option<(String, String)>,
|
|
/// A container that stops right after it was created, with this exit code.
|
|
dies: Option<(String, i64)>,
|
|
port_open: bool,
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
struct Call2 {
|
|
args: Vec<String>,
|
|
env: Vec<(String, String)>,
|
|
stdin: bool,
|
|
}
|
|
|
|
impl Sim {
|
|
fn new() -> Sim {
|
|
Sim {
|
|
calls: Default::default(),
|
|
running: Default::default(),
|
|
exited: Default::default(),
|
|
network: RefCell::new(false),
|
|
image: RefCell::new(false),
|
|
logs: Default::default(),
|
|
unavailable: false,
|
|
daemon_error: None,
|
|
run_error: None,
|
|
dies: None,
|
|
port_open: true,
|
|
}
|
|
}
|
|
|
|
fn verbs(&self) -> Vec<String> {
|
|
self.calls
|
|
.borrow()
|
|
.iter()
|
|
.map(|c| c.args.iter().take(2).cloned().collect::<Vec<_>>().join(" "))
|
|
.collect()
|
|
}
|
|
|
|
fn calls_of(&self, verb: &str) -> Vec<Call2> {
|
|
self.calls
|
|
.borrow()
|
|
.iter()
|
|
.filter(|c| c.args[0] == verb)
|
|
.cloned()
|
|
.collect()
|
|
}
|
|
|
|
fn inspect_json(&self, names: &[String]) -> (String, bool) {
|
|
let mut items = Vec::new();
|
|
let mut missing = false;
|
|
for n in names {
|
|
if self.running.borrow().contains(n) {
|
|
let health = if n.ends_with("-db") {
|
|
r#","Health":{"Status":"healthy"}"#
|
|
} else {
|
|
""
|
|
};
|
|
items.push(format!(
|
|
r#"{{"Name":"/{n}","State":{{"Status":"running","Running":true,"ExitCode":0,"OOMKilled":false,"Pid":4242,"StartedAt":"2026-10-02T12:27:26.892949316Z"{health}}}}}"#
|
|
));
|
|
} else if let Some((code, oom)) = self.exited.borrow().get(n) {
|
|
items.push(format!(
|
|
r#"{{"Name":"/{n}","State":{{"Status":"exited","Running":false,"ExitCode":{code},"OOMKilled":{oom},"Pid":0,"StartedAt":"2026-10-02T12:27:26.892949316Z"}}}}"#
|
|
));
|
|
} else {
|
|
missing = true;
|
|
}
|
|
}
|
|
(format!("[{}]", items.join(",")), missing)
|
|
}
|
|
}
|
|
|
|
fn out(code: i32, stdout: &str, stderr: &str) -> Output {
|
|
Output {
|
|
code: Some(code),
|
|
stdout: stdout.into(),
|
|
stderr: stderr.into(),
|
|
}
|
|
}
|
|
|
|
impl Docker for Sim {
|
|
fn run(&self, call: &Call) -> Result<Output> {
|
|
self.calls.borrow_mut().push(Call2 {
|
|
args: call.args.clone(),
|
|
env: call.env.clone(),
|
|
stdin: call.stdin.is_some(),
|
|
});
|
|
if self.unavailable {
|
|
return Err(crate::error::Error::Invalid(
|
|
"docker could not be started: No such file or directory".into(),
|
|
));
|
|
}
|
|
let a: Vec<&str> = call.args.iter().map(String::as_str).collect();
|
|
Ok(match a.as_slice() {
|
|
["version", ..] => match &self.daemon_error {
|
|
Some(e) => out(1, "", e),
|
|
None => out(0, "27.3.1\n", ""),
|
|
},
|
|
["network", "inspect", ..] => {
|
|
if *self.network.borrow() {
|
|
out(0, "[]", "")
|
|
} else {
|
|
out(1, "[]", "Error: No such network")
|
|
}
|
|
}
|
|
["network", "create", ..] => {
|
|
*self.network.borrow_mut() = true;
|
|
out(0, "id\n", "")
|
|
}
|
|
["image", "inspect", ..] => {
|
|
if *self.image.borrow() {
|
|
out(0, "[]", "")
|
|
} else {
|
|
out(1, "[]", "Error: No such image")
|
|
}
|
|
}
|
|
["build", ..] => {
|
|
*self.image.borrow_mut() = true;
|
|
out(0, "built", "")
|
|
}
|
|
["inspect", names @ ..] => {
|
|
let names: Vec<String> = names.iter().map(|s| s.to_string()).collect();
|
|
let (json, missing) = self.inspect_json(&names);
|
|
if missing {
|
|
out(1, &json, "Error: No such object: x")
|
|
} else {
|
|
out(0, &json, "")
|
|
}
|
|
}
|
|
["rm", "-f", name] => {
|
|
self.running.borrow_mut().remove(*name);
|
|
self.exited.borrow_mut().remove(*name);
|
|
out(0, "", "")
|
|
}
|
|
["run", ..] => {
|
|
let name = call.args[call.args.iter().position(|x| x == "--name").unwrap() + 1]
|
|
.clone();
|
|
if let Some((n, e)) = &self.run_error {
|
|
if *n == name {
|
|
return Ok(out(125, "", e));
|
|
}
|
|
}
|
|
match &self.dies {
|
|
Some((n, code)) if *n == name => {
|
|
self.exited.borrow_mut().insert(name, (*code, false));
|
|
}
|
|
_ => {
|
|
self.running.borrow_mut().insert(name);
|
|
}
|
|
}
|
|
out(0, "containerid\n", "")
|
|
}
|
|
["update", "--restart", _, _] => out(0, "", ""),
|
|
["exec", ..] => out(0, "", ""),
|
|
["stop", "--time", _, name] => {
|
|
self.running.borrow_mut().remove(*name);
|
|
self.exited
|
|
.borrow_mut()
|
|
.insert(name.to_string(), (0, false));
|
|
out(0, "", "")
|
|
}
|
|
["logs", ..] => out(0, &self.logs.borrow(), ""),
|
|
other => panic!("unexpected docker call: {other:?}"),
|
|
})
|
|
}
|
|
|
|
fn port_open(&self, _addr: SocketAddr) -> bool {
|
|
self.port_open
|
|
}
|
|
|
|
fn pause(&self, _d: Duration) {}
|
|
}
|
|
|
|
fn server(project: &str) -> (tempfile::TempDir, std::path::PathBuf) {
|
|
let d = tempfile::tempdir().unwrap();
|
|
let root = d.path().join("srv");
|
|
fs::create_dir_all(root.join("Settings")).unwrap();
|
|
fs::write(
|
|
root.join("Settings/docker.json"),
|
|
format!(r#"{{"project":"{project}"}}"#),
|
|
)
|
|
.unwrap();
|
|
fs::write(
|
|
root.join("Settings/database.json"),
|
|
format!(r#"{{"rootPassword":"{ROOT_PW}","appPassword":"{APP_PW}"}}"#),
|
|
)
|
|
.unwrap();
|
|
(d, root)
|
|
}
|
|
|
|
fn start_all(sim: &Sim, root: &Path) -> DriverOutcome {
|
|
run_with(sim, root, Verb::StartAll).unwrap()
|
|
}
|
|
|
|
#[test]
|
|
fn a_first_start_creates_the_network_the_image_and_the_containers_in_order() {
|
|
let (_d, root) = server("t1");
|
|
let sim = Sim::new();
|
|
let o = start_all(&sim, &root);
|
|
assert!(o.ok, "{}", o.output);
|
|
let verbs = sim.verbs();
|
|
let at = |needle: &str| {
|
|
verbs
|
|
.iter()
|
|
.position(|v| v.starts_with(needle))
|
|
.unwrap_or_else(|| panic!("{needle} not called: {verbs:?}"))
|
|
};
|
|
assert!(at("version") < at("network create"));
|
|
assert!(
|
|
at("network create") < at("run --detach"),
|
|
"database comes first"
|
|
);
|
|
let runs: Vec<String> = sim
|
|
.calls_of("run")
|
|
.iter()
|
|
.map(|c| c.args[c.args.iter().position(|x| x == "--name").unwrap() + 1].clone())
|
|
.collect();
|
|
assert_eq!(
|
|
runs,
|
|
["coa-t1-db", "coa-t1-world", "coa-t1-auth"],
|
|
"database, then world, then auth"
|
|
);
|
|
let exec = sim.calls_of("exec");
|
|
assert_eq!(
|
|
exec.len(),
|
|
1,
|
|
"the realm is marked online once the auth server is up"
|
|
);
|
|
assert!(exec[0].stdin && exec[0].env == [("MYSQL_PWD".to_string(), ROOT_PW.to_string())]);
|
|
assert!(
|
|
!exec[0].args.iter().any(|a| a.contains(ROOT_PW)),
|
|
"the password is not on the command line"
|
|
);
|
|
assert!(
|
|
at("build") < verbs.iter().rposition(|v| v.starts_with("run")).unwrap(),
|
|
"the runtime image exists before the game servers"
|
|
);
|
|
assert!(
|
|
sim.calls_of("build")[0].stdin,
|
|
"the Dockerfile travels on stdin"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn passwords_travel_by_environment_and_never_on_a_command_line() {
|
|
let (_d, root) = server("t1");
|
|
let sim = Sim::new();
|
|
assert!(start_all(&sim, &root).ok);
|
|
for c in sim.calls.borrow().iter() {
|
|
for arg in &c.args {
|
|
assert!(
|
|
!arg.contains(ROOT_PW) && !arg.contains(APP_PW),
|
|
"secret on a command line: {arg}"
|
|
);
|
|
}
|
|
}
|
|
let runs = sim.calls_of("run");
|
|
assert!(runs[0]
|
|
.env
|
|
.contains(&("MYSQL_ROOT_PASSWORD".into(), ROOT_PW.into())));
|
|
assert!(runs[1]
|
|
.env
|
|
.iter()
|
|
.any(|(k, v)| k == "AC_LOGIN_DATABASE_INFO"
|
|
&& v == &format!("db;3306;acore;{APP_PW};acore_auth")));
|
|
assert!(runs[1]
|
|
.env
|
|
.iter()
|
|
.any(|(k, _)| k == "AC_CHARACTER_DATABASE_INFO"));
|
|
assert!(runs[2]
|
|
.env
|
|
.iter()
|
|
.any(|(k, _)| k == "AC_LOGIN_DATABASE_INFO"));
|
|
assert!(
|
|
!runs[2]
|
|
.env
|
|
.iter()
|
|
.any(|(k, _)| k == "AC_WORLD_DATABASE_INFO"),
|
|
"auth does not need the world database"
|
|
);
|
|
assert!(
|
|
runs[1]
|
|
.args
|
|
.windows(2)
|
|
.any(|w| w == ["--env", "AC_WORLD_DATABASE_INFO"]),
|
|
"name only, the value is in the environment"
|
|
);
|
|
}
|
|
|
|
// Unix only: the folder is a Linux path (a Windows path has a colon, which a Docker folder may not).
|
|
#[cfg(unix)]
|
|
#[test]
|
|
fn a_release_fixture_runs_its_database_on_the_package_data_directory_not_on_a_volume() {
|
|
let (_d, root) = server("t1");
|
|
fs::write(
|
|
root.join("Settings/docker.json"),
|
|
r#"{"project":"t1","mysqlData":"/work/fixture/mysql/data"}"#,
|
|
)
|
|
.unwrap();
|
|
let sim = Sim::new();
|
|
assert!(run_with(&sim, &root, Verb::StartMysql).unwrap().ok);
|
|
let db = &sim.calls_of("run")[0].args;
|
|
assert!(
|
|
db.windows(2)
|
|
.any(|w| w == ["--volume", "/work/fixture/mysql/data:/var/lib/mysql"]),
|
|
"{db:?}"
|
|
);
|
|
assert!(
|
|
!db.iter().any(|a| a.starts_with("coa-t1-db:")),
|
|
"no named volume: {db:?}"
|
|
);
|
|
assert!(
|
|
db.iter().any(|a| a == "--user"),
|
|
"the folder is written by its owner"
|
|
);
|
|
assert_eq!(
|
|
db.last().map(String::as_str),
|
|
Some("--lower-case-table-names=1"),
|
|
"a server option, so after the image name"
|
|
);
|
|
// An installation never gets any of it.
|
|
let (_d2, root2) = server("t2");
|
|
let sim2 = Sim::new();
|
|
assert!(run_with(&sim2, &root2, Verb::StartMysql).unwrap().ok);
|
|
let plain = &sim2.calls_of("run")[0].args;
|
|
assert!(
|
|
plain
|
|
.windows(2)
|
|
.any(|w| w == ["--volume", "coa-t2-db:/var/lib/mysql"]),
|
|
"{plain:?}"
|
|
);
|
|
assert!(!plain
|
|
.iter()
|
|
.any(|a| a == "--lower-case-table-names=1" || a == "--user"));
|
|
}
|
|
|
|
#[test]
|
|
fn the_world_server_is_started_again_when_it_restarts_itself_but_only_once_it_is_up() {
|
|
let (_d, root) = server("t1");
|
|
let sim = Sim::new();
|
|
assert!(start_all(&sim, &root).ok);
|
|
let world_run = sim
|
|
.calls_of("run")
|
|
.into_iter()
|
|
.find(|c| c.args.iter().any(|a| a == "coa-t1-world"))
|
|
.unwrap();
|
|
assert!(
|
|
!world_run.args.iter().any(|a| a == "--restart"),
|
|
"no restart while it is still starting"
|
|
);
|
|
let updates = sim.calls_of("update");
|
|
assert_eq!(updates.len(), 1);
|
|
assert_eq!(
|
|
updates[0].args,
|
|
["update", "--restart", "on-failure:3", "coa-t1-world"]
|
|
);
|
|
let verbs = sim.verbs();
|
|
let pos = |p: &str| verbs.iter().position(|v| v.starts_with(p)).unwrap();
|
|
assert!(
|
|
pos("run --detach") < pos("update"),
|
|
"after the container exists and listens"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn the_containers_use_the_databases_of_the_selected_realm() {
|
|
let s = Secrets {
|
|
root: "r".into(),
|
|
app: "apppw".into(),
|
|
};
|
|
let get = |env: &[(String, String)], k: &str| {
|
|
env.iter().find(|(n, _)| n == k).map(|(_, v)| v.clone())
|
|
};
|
|
let coa = database_env(&s, true, crate::realms::Mode::Coa);
|
|
assert_eq!(
|
|
get(&coa, "AC_WORLD_DATABASE_INFO").unwrap(),
|
|
"db;3306;acore;apppw;acore_world"
|
|
);
|
|
assert_eq!(
|
|
get(&coa, "AC_CHARACTER_DATABASE_INFO").unwrap(),
|
|
"db;3306;acore;apppw;acore_characters"
|
|
);
|
|
let wild = database_env(&s, true, crate::realms::Mode::Wildcard);
|
|
assert_eq!(
|
|
get(&wild, "AC_WORLD_DATABASE_INFO").unwrap(),
|
|
"db;3306;acore;apppw;acore_world_wildcard"
|
|
);
|
|
assert_eq!(
|
|
get(&wild, "AC_CHARACTER_DATABASE_INFO").unwrap(),
|
|
"db;3306;acore;apppw;acore_characters_wildcard"
|
|
);
|
|
let reborn = database_env(&s, true, crate::realms::Mode::Reborn);
|
|
assert_eq!(
|
|
get(&reborn, "AC_WORLD_DATABASE_INFO").unwrap(),
|
|
"db;3306;acore;apppw;acore_world_reborn"
|
|
);
|
|
assert_eq!(
|
|
get(&reborn, "AC_CHARACTER_DATABASE_INFO").unwrap(),
|
|
"db;3306;acore;apppw;acore_characters_reborn"
|
|
);
|
|
assert_eq!(
|
|
get(&reborn, "AC_LOGIN_DATABASE_INFO").unwrap(),
|
|
"db;3306;acore;apppw;acore_auth"
|
|
);
|
|
// Accounts are shared by both realms; the auth server never sees the others.
|
|
assert_eq!(
|
|
get(&wild, "AC_LOGIN_DATABASE_INFO").unwrap(),
|
|
"db;3306;acore;apppw;acore_auth"
|
|
);
|
|
let auth = database_env(&s, false, crate::realms::Mode::Wildcard);
|
|
assert_eq!(auth.len(), 1);
|
|
}
|
|
|
|
#[test]
|
|
fn the_database_is_only_healthy_once_it_takes_tcp_connections() {
|
|
let (_d, root) = server("t1");
|
|
let sim = Sim::new();
|
|
assert!(start_all(&sim, &root).ok);
|
|
let db = &sim.calls_of("run")[0].args;
|
|
let i = db
|
|
.iter()
|
|
.position(|a| a == "--health-cmd")
|
|
.expect("the database has a health check");
|
|
// Found on a new volume: a socket-only ping reported healthy about four seconds before TCP worked.
|
|
assert!(
|
|
db[i + 1].contains("--protocol=tcp") && db[i + 1].contains("--host=127.0.0.1"),
|
|
"{}",
|
|
db[i + 1]
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn the_world_container_is_wired_like_the_repack_layout() {
|
|
let (_d, root) = server("t1");
|
|
let sim = Sim::new();
|
|
assert!(start_all(&sim, &root).ok);
|
|
let world = &sim.calls_of("run")[1].args;
|
|
let has = |s: &str| world.iter().any(|a| a == s);
|
|
assert!(
|
|
has("127.0.0.1:8085:8085"),
|
|
"game port on this computer only by default"
|
|
);
|
|
assert!(
|
|
has("127.0.0.1:3443:3443"),
|
|
"the remote console is never exposed beyond this computer"
|
|
);
|
|
assert!(has("AC_BIND_IP=0.0.0.0") && has("AC_RA_ENABLE=1") && has("AC_RA_IP=0.0.0.0"));
|
|
assert!(
|
|
has("AC_UPDATES_ENABLE_DATABASES=0"),
|
|
"the server's own database updater needs a mysql client the image does not have"
|
|
);
|
|
assert!(sim.calls_of("run")[2]
|
|
.args
|
|
.iter()
|
|
.any(|a| a == "AC_UPDATES_ENABLE_DATABASES=0"));
|
|
assert!(has("AC_DATA_DIR=/srv/data") && has("AC_LOGS_DIR=/srv/core/Logs"));
|
|
assert!(
|
|
world.iter().any(|a| a.ends_with(":/srv/data:ro")),
|
|
"game data is read-only"
|
|
);
|
|
assert!(world
|
|
.iter()
|
|
.any(|a| a.ends_with(":/srv/core") && a.contains("Core")));
|
|
assert!(world.windows(2).any(|w| w == ["--workdir", "/srv/core"]));
|
|
assert!(world.windows(2).any(|w| w == ["--stop-timeout", "180"]));
|
|
let n = world.len();
|
|
assert_eq!(
|
|
&world[n - 3..],
|
|
["./worldserver", "-c", "configs/worldserver.conf"]
|
|
);
|
|
assert!(world[n - 4].starts_with("coa-runtime:"));
|
|
assert!(
|
|
root.join("Core/Logs").is_dir(),
|
|
"created by the Manager so it belongs to the user"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn the_published_address_follows_the_setting() {
|
|
let (_d, root) = server("t1");
|
|
fs::write(
|
|
root.join("Settings/docker.json"),
|
|
r#"{"project":"t1","bindAddress":"0.0.0.0"}"#,
|
|
)
|
|
.unwrap();
|
|
let sim = Sim::new();
|
|
assert!(start_all(&sim, &root).ok);
|
|
let runs = sim.calls_of("run");
|
|
assert!(runs[1].args.iter().any(|a| a == "0.0.0.0:8085:8085"));
|
|
assert!(
|
|
runs[1].args.iter().any(|a| a == "127.0.0.1:3443:3443"),
|
|
"the console stays private"
|
|
);
|
|
assert!(runs[2].args.iter().any(|a| a == "0.0.0.0:3724:3724"));
|
|
}
|
|
|
|
#[test]
|
|
fn custom_host_ports_keep_the_container_listeners_on_the_mapped_ports() {
|
|
let (_d, root) = server("ports");
|
|
let cfg = Config::load(&root).unwrap();
|
|
let n = cfg.names();
|
|
let world = game_args(
|
|
&cfg,
|
|
&n,
|
|
GameKind::World,
|
|
&root,
|
|
&root.join("Data"),
|
|
18085,
|
|
13443,
|
|
None,
|
|
);
|
|
let auth = game_args(
|
|
&cfg,
|
|
&n,
|
|
GameKind::Auth,
|
|
&root,
|
|
&root.join("Data"),
|
|
13724,
|
|
0,
|
|
None,
|
|
);
|
|
assert!(world.iter().any(|a| a == "127.0.0.1:18085:8085"));
|
|
assert!(world.iter().any(|a| a == "127.0.0.1:13443:3443"));
|
|
assert!(world.iter().any(|a| a == "AC_WORLD_SERVER_PORT=8085"));
|
|
assert!(world.iter().any(|a| a == "AC_RA_PORT=3443"));
|
|
assert!(auth.iter().any(|a| a == "127.0.0.1:13724:3724"));
|
|
assert!(auth.iter().any(|a| a == "AC_REALM_SERVER_PORT=3724"));
|
|
}
|
|
|
|
#[test]
|
|
fn a_second_start_leaves_running_containers_alone() {
|
|
let (_d, root) = server("t1");
|
|
let sim = Sim::new();
|
|
assert!(start_all(&sim, &root).ok);
|
|
let before = sim.calls_of("run").len();
|
|
assert!(start_all(&sim, &root).ok);
|
|
assert_eq!(sim.calls_of("run").len(), before, "nothing was recreated");
|
|
}
|
|
|
|
#[test]
|
|
fn start_database_only_does_not_touch_the_game_servers() {
|
|
let (_d, root) = server("t1");
|
|
let sim = Sim::new();
|
|
assert!(run_with(&sim, &root, Verb::StartMysql).unwrap().ok);
|
|
assert_eq!(sim.calls_of("run").len(), 1);
|
|
assert!(sim.calls_of("build").is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn secondary_world_start_is_rejected_without_touching_containers() {
|
|
let (_d, root) = server("t1");
|
|
let sim = Sim::new();
|
|
assert!(run_with(&sim, &root, Verb::StartWorld).is_err());
|
|
assert!(sim.calls.borrow().is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn stop_goes_world_then_auth_then_database_with_time_to_save() {
|
|
let (_d, root) = server("t1");
|
|
let sim = Sim::new();
|
|
assert!(start_all(&sim, &root).ok);
|
|
sim.calls.borrow_mut().clear();
|
|
let o = run_with(&sim, &root, Verb::StopAll).unwrap();
|
|
assert!(o.ok, "{}", o.output);
|
|
let stops: Vec<(String, String)> = sim
|
|
.calls_of("stop")
|
|
.iter()
|
|
.map(|c| (c.args[3].clone(), c.args[2].clone()))
|
|
.collect();
|
|
assert_eq!(
|
|
stops,
|
|
[
|
|
("coa-t1-world".into(), "180".into()),
|
|
("coa-t1-auth".into(), "30".into()),
|
|
("coa-t1-db".into(), "60".into())
|
|
]
|
|
);
|
|
assert!(sim.running.borrow().is_empty());
|
|
// Stopping what is already stopped is fine.
|
|
sim.calls.borrow_mut().clear();
|
|
assert!(run_with(&sim, &root, Verb::StopAll).unwrap().ok);
|
|
assert!(sim.calls_of("stop").is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn docker_not_installed_is_reported_as_unavailable() {
|
|
let (_d, root) = server("t1");
|
|
let mut sim = Sim::new();
|
|
sim.unavailable = true;
|
|
let o = start_all(&sim, &root);
|
|
assert!(!o.ok);
|
|
assert_eq!(o.code, Some(ErrorCode::DockerUnavailable));
|
|
assert!(o.output.contains("could not be started"));
|
|
}
|
|
|
|
#[test]
|
|
fn a_refused_connection_to_the_docker_service_shows_docker_own_words() {
|
|
let (_d, root) = server("t1");
|
|
let mut sim = Sim::new();
|
|
sim.daemon_error =
|
|
Some("permission denied while trying to connect to the Docker daemon socket".into());
|
|
let o = start_all(&sim, &root);
|
|
assert_eq!(o.code, Some(ErrorCode::DockerUnavailable));
|
|
assert!(o.output.contains("permission denied"), "{}", o.output);
|
|
assert!(
|
|
sim.calls_of("run").is_empty(),
|
|
"nothing is started when docker is not usable"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn a_world_server_that_stops_while_starting_reports_the_cause_found_in_its_log() {
|
|
let (_d, root) = server("t1");
|
|
let mut sim = Sim::new();
|
|
sim.dies = Some(("coa-t1-world".into(), 1));
|
|
*sim.logs.borrow_mut() = "\u{1b}[31mCould not connect to MySQL database at db: Can't connect to MySQL server on 'db:3306' (111)\u{1b}[0m".into();
|
|
let o = start_all(&sim, &root);
|
|
assert!(!o.ok);
|
|
assert_eq!(o.code, Some(ErrorCode::DatabaseNotRunning));
|
|
assert!(
|
|
o.output.contains("Can't connect to MySQL server"),
|
|
"{}",
|
|
o.output
|
|
);
|
|
assert!(!o.output.contains('\u{1b}'), "colour codes are removed");
|
|
assert!(
|
|
sim.calls_of("run").len() == 2,
|
|
"auth is not started after a failed world"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn a_port_that_is_taken_is_reported_as_such() {
|
|
let (_d, root) = server("t1");
|
|
let mut sim = Sim::new();
|
|
sim.run_error = Some((
|
|
"coa-t1-world".into(),
|
|
"Bind for 127.0.0.1:8085 failed: port is already allocated".into(),
|
|
));
|
|
let o = start_all(&sim, &root);
|
|
assert_eq!(o.code, Some(ErrorCode::PortInUse));
|
|
}
|
|
|
|
#[test]
|
|
fn a_server_that_never_listens_times_out_with_its_log() {
|
|
let (_d, root) = server("t1");
|
|
let mut sim = Sim::new();
|
|
sim.port_open = false;
|
|
*sim.logs.borrow_mut() = "still loading".into();
|
|
let o = start_all(&sim, &root);
|
|
assert!(!o.ok);
|
|
assert!(
|
|
o.output.contains("was not listening on port 8085")
|
|
&& o.output.contains("still loading"),
|
|
"{}",
|
|
o.output
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn invalid_settings_are_refused_before_anything_runs() {
|
|
for (project, bind, image) in [
|
|
("Bad Name", "127.0.0.1", "mysql:8.4"),
|
|
("", "127.0.0.1", "mysql:8.4"),
|
|
("ok", "not-an-ip", "mysql:8.4"),
|
|
("ok", "127.0.0.1", "mysql:8.4; rm -rf /"),
|
|
("-lead", "127.0.0.1", "mysql:8.4"),
|
|
] {
|
|
let (_d, root) = server("t1");
|
|
fs::write(
|
|
root.join("Settings/docker.json"),
|
|
format!(
|
|
r#"{{"project":"{project}","bindAddress":"{bind}","mysqlImage":"{image}"}}"#
|
|
),
|
|
)
|
|
.unwrap();
|
|
let sim = Sim::new();
|
|
assert!(
|
|
run_with(&sim, &root, Verb::StartAll).is_err(),
|
|
"{project} / {bind} / {image}"
|
|
);
|
|
assert!(sim.calls.borrow().is_empty());
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn inspect_output_is_read_like_docker_prints_it() {
|
|
// Shape taken from `docker inspect` on a stopped database container and a world server.
|
|
let json = r#"[{"Id":"abc","Name":"/coa-t1-db","State":{"Status":"running","Running":true,"Paused":false,"Restarting":false,"OOMKilled":false,"Dead":false,"Pid":2402,"ExitCode":0,"Error":"","StartedAt":"2026-10-02T12:27:26.892949316Z","FinishedAt":"0001-01-01T00:00:00Z","Health":{"Status":"healthy","FailingStreak":0,"Log":[]}}},
|
|
{"Name":"/coa-t1-world","State":{"Status":"exited","Running":false,"OOMKilled":false,"Pid":0,"ExitCode":137,"StartedAt":"2026-10-02T12:40:06.76552263Z"}}]"#;
|
|
let m = parse_inspect(json);
|
|
assert_eq!(m["coa-t1-db"].pid, Some(2402));
|
|
assert_eq!(m["coa-t1-db"].health.as_deref(), Some("healthy"));
|
|
assert_eq!(m["coa-t1-world"].exit_code, 137);
|
|
assert_eq!(m["coa-t1-world"].pid, None);
|
|
assert!(
|
|
parse_inspect("[]").is_empty()
|
|
&& parse_inspect("").is_empty()
|
|
&& parse_inspect("nonsense").is_empty()
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn observation_maps_container_states_to_service_states() {
|
|
let ports = Ports::default();
|
|
let (_d, root) = server("t1");
|
|
|
|
// Nothing created yet.
|
|
let sim = Sim::new();
|
|
let o = observe_with(&sim, &root, &ports);
|
|
assert!([o.mysql.state, o.auth.state, o.world.state]
|
|
.iter()
|
|
.all(|s| *s == ServiceState::Stopped));
|
|
|
|
// Everything up.
|
|
assert!(start_all(&sim, &root).ok);
|
|
let o = observe_with(&sim, &root, &ports);
|
|
assert_eq!(
|
|
(o.mysql.state, o.auth.state, o.world.state),
|
|
(
|
|
ServiceState::Running,
|
|
ServiceState::Running,
|
|
ServiceState::Running
|
|
)
|
|
);
|
|
assert!(o.world.port_ready && o.world.pid == Some(4242) && o.world.uptime_secs.is_some());
|
|
assert_eq!(o.world.port, ports.world);
|
|
|
|
// Running but not listening yet.
|
|
let mut slow = Sim::new();
|
|
slow.port_open = false;
|
|
slow.running.borrow_mut().insert("coa-t1-world".into());
|
|
let o = observe_with(&slow, &root, &ports);
|
|
assert_eq!(o.world.state, ServiceState::Starting);
|
|
assert!(!o.world.port_ready);
|
|
|
|
// Stopped cleanly, killed after the grace period, crashed, killed for lack of memory.
|
|
let mut sim = Sim::new();
|
|
for (name, code, oom) in [
|
|
("coa-t1-db", 0, false),
|
|
("coa-t1-auth", 137, false),
|
|
("coa-t1-world", 1, false),
|
|
] {
|
|
sim.exited.borrow_mut().insert(name.into(), (code, oom));
|
|
}
|
|
let o = observe_with(&sim, &root, &ports);
|
|
assert_eq!(
|
|
(o.mysql.state, o.auth.state, o.world.state),
|
|
(
|
|
ServiceState::Stopped,
|
|
ServiceState::Stopped,
|
|
ServiceState::Crashed
|
|
)
|
|
);
|
|
sim.exited
|
|
.borrow_mut()
|
|
.insert("coa-t1-auth".into(), (137, true));
|
|
assert_eq!(
|
|
observe_with(&sim, &root, &ports).auth.state,
|
|
ServiceState::Crashed
|
|
);
|
|
sim.unavailable = true;
|
|
assert_eq!(
|
|
observe_with(&sim, &root, &ports).world.state,
|
|
ServiceState::Unknown,
|
|
"docker unreachable: unknown, not stopped"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn the_runtime_image_is_named_after_its_dockerfile() {
|
|
let name = runtime_image();
|
|
assert!(
|
|
name.starts_with("coa-runtime:") && name.len() == "coa-runtime:".len() + 12,
|
|
"{name}"
|
|
);
|
|
assert!(
|
|
RUNTIME_DOCKERFILE.contains("libmysqlclient24")
|
|
&& RUNTIME_DOCKERFILE.contains("libreadline8t64")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn a_docker_folder_is_scanned_without_the_repack_files() {
|
|
let (_d, root) = server("t1");
|
|
assert!(crate::docker::is_docker(&root));
|
|
for f in [
|
|
"Core/worldserver",
|
|
"Core/authserver",
|
|
"Core/configs/worldserver.conf",
|
|
"Core/configs/authserver.conf",
|
|
"Data/dbc/x",
|
|
"Data/maps/x",
|
|
] {
|
|
let p = root.join(f);
|
|
fs::create_dir_all(p.parent().unwrap()).unwrap();
|
|
fs::write(p, "x").unwrap();
|
|
}
|
|
let r = crate::layout::scan(&root).unwrap();
|
|
assert_eq!(r.classification, crate::layout::Classification::Healthy);
|
|
assert!(r.worldserver.is_some() && r.authserver.is_some() && !r.modifies_files);
|
|
fs::remove_file(root.join("Core/authserver")).unwrap();
|
|
assert_eq!(
|
|
crate::layout::scan(&root).unwrap().classification,
|
|
crate::layout::Classification::Partial
|
|
);
|
|
fs::remove_file(root.join("Settings/docker.json")).unwrap();
|
|
assert!(
|
|
!crate::docker::is_docker(&root),
|
|
"without the marker it is scanned as a repack"
|
|
);
|
|
}
|
|
}
|