//! 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 = std::result::Result; #[derive(Default)] struct Log(Vec); impl Log { fn say(&mut self, line: impl Into) { self.0.push(line.into()); } } fn fail(code: ErrorCode, output: impl Into) -> Step { Err(Failure { code, output: output.into(), }) } pub fn run(root: &Path, verb: Verb) -> Result { run_with(&SystemDocker, root, verb) } pub fn run_with(d: &dyn Docker, root: &Path, verb: Verb) -> Result { 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 { 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 { 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, pub started_at: Option, /// "healthy", "unhealthy" or "starting" when the container has a health check. pub health: Option, } 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> { 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 { let Ok(Value::Array(items)) = serde_json::from_str::(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::() { Ok(ip) if !ip.is_unspecified() => ip, _ => IpAddr::V4(Ipv4Addr::LOCALHOST), } } // ------------------------------------------------------------------------------------------------- argument lists fn db_args(cfg: &Config, n: &Names, owner: Option<&str>) -> Vec { let mut a: Vec = ["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 { 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 { 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 { 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 = 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 { 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 { 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 { 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>, running: RefCell>, exited: RefCell>, network: RefCell, image: RefCell, logs: RefCell, unavailable: bool, daemon_error: Option, /// `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, 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 { self.calls .borrow() .iter() .map(|c| c.args.iter().take(2).cloned().collect::>().join(" ")) .collect() } fn calls_of(&self, verb: &str) -> Vec { 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 { 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 = 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 = 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" ); } }