Merge current master into portable characters while retaining 0.7.0

This commit is contained in:
Дмитрий committed 2026-10-19 13:47:05 +05:00
commit f40c0e1324
114 files changed
+6694 -600

No files matched your search

+1 -1
View File
@@ -171,7 +171,7 @@ pub fn preflight(
}
}
fn data_problems(data_dir: &Path) -> Vec<crate::install::Problem> {
pub(crate) fn data_problems(data_dir: &Path) -> Vec<crate::install::Problem> {
let s = data_dir.to_string_lossy();
if !data_dir.is_absolute() || s.contains(':') {
return vec![problem(
+111
View File
@@ -297,6 +297,10 @@ fn start(d: &dyn Docker, root: &Path, cfg: &Config, with_game: bool, log: &mut L
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);
@@ -315,9 +319,51 @@ fn start(d: &dyn Docker, root: &Path, cfg: &Config, with_game: bool, log: &mut L
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));
@@ -508,6 +554,30 @@ fn database_env(s: &Secrets, world: bool, realm: crate::realms::Mode) -> Vec<(St
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 {
@@ -948,6 +1018,8 @@ mod tests {
}
out(0, "containerid\n", "")
}
["update", "--restart", _, _] => out(0, "", ""),
["exec", ..] => out(0, "", ""),
["stop", "--time", _, name] => {
self.running.borrow_mut().remove(*name);
self.exited
@@ -1016,6 +1088,17 @@ mod tests {
["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"
@@ -1119,6 +1202,34 @@ mod tests {
.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 {
+72
View File
@@ -0,0 +1,72 @@
//! The database of a Docker server has no log file in the server folder: MySQL writes to its container's output.
use super::cli::{Call, Docker, SystemDocker};
use super::Config;
use crate::console::Line;
use crate::error::{Error, Result};
use std::path::Path;
use std::time::Duration;
/// The last lines MySQL wrote (what `docker logs` returns), filtered and classified like the lines of a log file.
pub fn database_log(root: &Path, filter: Option<&str>, max_lines: usize) -> Result<Vec<Line>> {
database_log_with(&SystemDocker, root, filter, max_lines)
}
pub fn database_log_with(d: &dyn Docker, root: &Path, filter: Option<&str>, max_lines: usize) -> Result<Vec<Line>> {
let name = Config::load(root)?.names().db;
// Ask for more than wanted: the filter may drop most of them.
let tail = (max_lines * 4).clamp(200, 8000).to_string();
let out = d.run(&Call::new(&["logs", "--tail", &tail, &name], Duration::from_secs(20)))?;
if !out.ok() {
return Err(Error::Invalid("This log does not exist yet.".into()));
}
// MySQL writes to the error stream.
Ok(crate::console::lines_from_text(&format!("{}\n{}", out.stderr, out.stdout), filter, max_lines))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::docker::cli::Output;
use std::cell::RefCell;
struct Fake {
out: Output,
calls: RefCell<Vec<Vec<String>>>,
}
impl Docker for Fake {
fn run(&self, call: &Call) -> Result<Output> {
self.calls.borrow_mut().push(call.args.clone());
Ok(self.out.clone())
}
}
fn root() -> (tempfile::TempDir, std::path::PathBuf) {
let d = tempfile::tempdir().unwrap();
let root = d.path().join("srv");
std::fs::create_dir_all(root.join("Settings")).unwrap();
std::fs::write(root.join("Settings/docker.json"), r#"{"project":"t1"}"#).unwrap();
(d, root)
}
#[test]
fn the_database_log_is_what_the_container_printed() {
let (_d, root) = root();
let fake = Fake { out: Output { code: Some(0), stdout: "2026-10-04T10:00:00Z [System] ready\n".into(), stderr: "2026-10-04T10:00:01Z [ERROR] [MY-010] boom\n2026-10-04T10:00:02Z [Warning] slow\n".into() }, calls: Default::default() };
let lines = database_log_with(&fake, &root, None, 100).unwrap();
assert_eq!(fake.calls.borrow()[0][..2], ["logs", "--tail"]);
assert_eq!(fake.calls.borrow()[0].last().unwrap(), "coa-t1-db");
assert_eq!(lines.len(), 3);
assert!(lines.iter().any(|l| l.text.contains("boom") && l.level == crate::console::Level::Error));
let only = database_log_with(&fake, &root, Some("slow"), 100).unwrap();
assert_eq!(only.len(), 1);
}
#[test]
fn a_database_that_never_ran_has_no_log_yet() {
let (_d, root) = root();
let fake = Fake { out: Output { code: Some(1), stdout: String::new(), stderr: "Error: No such container: coa-t1-db".into() }, calls: Default::default() };
assert!(database_log_with(&fake, &root, None, 10).unwrap_err().to_string().contains("does not exist yet"));
}
}
+183
View File
@@ -18,10 +18,13 @@ mod cli;
pub mod fixture;
pub mod install;
mod lifecycle;
pub mod logs;
pub mod sharing;
pub use cli::{Call, Docker, Output, SystemDocker};
pub(crate) use lifecycle::destroy;
pub use lifecycle::{check_docker, observe, observe_with, run, run_with};
pub use sharing::{bind_is_open, exposure, set_open};
use std::net::IpAddr;
use std::path::Path;
@@ -170,6 +173,103 @@ pub fn ensure_main_configs(root: &Path) -> Result<Vec<String>> {
Ok(created)
}
/// Settings the Docker backend gives the containers as environment variables. The core reads `AC_<KEY>` before the
/// configuration file, so a value written to the file for one of these keys is silently ignored. They are what makes the
/// containers work (where things are inside them, listening on every interface, the console, no built-in database
/// updater, the databases); the owner has no use for them and the screens do not offer them.
pub(crate) const FORCED_KEYS: [&str; 12] = [
"BindIP",
"WorldServerPort",
"RealmServerPort",
"LogsDir",
"DataDir",
"Updates.EnableDatabases",
"Ra.Enable",
"Ra.IP",
"Ra.Port",
"LoginDatabaseInfo",
"WorldDatabaseInfo",
"CharacterDatabaseInfo",
];
/// Is this setting fixed by the Docker backend (see `FORCED_KEYS`)?
pub fn managed_setting(key: &str) -> bool {
FORCED_KEYS.iter().any(|k| k.eq_ignore_ascii_case(key))
}
/// The environment variable the core reads for a setting: `AC_` and the key in upper snake case, a `_` between a lower-case
/// letter and a capital, and at letter / digit boundaries (the core's `IniKeyToEnvVarKey`).
#[cfg(test)]
pub(crate) fn env_name(key: &str) -> String {
let chars: Vec<char> = key.chars().collect();
let mut out = String::from("AC_");
for (i, &c) in chars.iter().enumerate() {
if matches!(c, ' ' | '.' | '-') {
out.push('_');
continue;
}
out.push(c.to_ascii_uppercase());
if let Some(&next) = chars.get(i + 1) {
let split = (!c.is_ascii_uppercase() && next.is_ascii_uppercase())
|| (!c.is_ascii_digit() && next.is_ascii_digit())
|| (c.is_ascii_digit()
&& !next.is_ascii_digit()
&& !matches!(next, ' ' | '.' | '-'));
if split {
out.push('_');
}
}
}
out
}
/// The folder mounted as the game data of this Docker server.
pub fn game_data_dir(root: &Path) -> Result<std::path::PathBuf> {
Ok(Config::load(root)?.data_path(root))
}
/// Point a Docker server at another game data folder (used in place, read-only). The containers are recreated at the next
/// start, so the servers must be stopped: a running one keeps the folder it has.
pub fn set_game_data(root: &Path, path: &Path) -> Result<()> {
let problems = install::data_problems(path);
if !problems.is_empty() {
return Err(Error::Invalid(
problems
.iter()
.map(|p| p.message.clone())
.collect::<Vec<_>>()
.join(" "),
));
}
let observed = crate::process::observe(root, &crate::layout::read_ports(root));
let busy = |s: &crate::process::ServiceStatus| {
matches!(
s.state,
crate::process::ServiceState::Running
| crate::process::ServiceState::Starting
| crate::process::ServiceState::Stopping
)
};
if busy(&observed.world) || busy(&observed.auth) {
return Err(Error::Invalid(
"Stop the server before changing the game data folder.".into(),
));
}
let mut cfg = Config::load(root)?;
cfg.data_dir = Some(path.to_string_lossy().into_owned());
cfg.validate()?;
fsx::atomic_write_json(&root.join(MARKER), &cfg)
}
/// A reason a value cannot work on a Docker server, for settings that name a path: the server runs in a container that sees only
/// its own `Core` folder (as `/srv/core`, its working directory), so a path elsewhere on this computer does not exist for it.
pub fn setting_problem(key: &str, raw: &str) -> Option<&'static str> {
let raw = raw.trim().trim_matches('"');
let outside = Path::new(raw).is_absolute() && !raw.starts_with("/srv/core/");
(key.eq_ignore_ascii_case("CoaBots.TalentBuildsPath") && !raw.is_empty() && outside)
.then_some("must be a path inside the server's Core folder (for example reference/ascensionsidekick-level-builds.json), because the server runs in a container that cannot see other folders")
}
/// Name of the runtime image: it follows the content of its Dockerfile, so changing the libraries builds a new image.
pub(crate) fn runtime_image() -> String {
format!(
@@ -287,6 +387,89 @@ mod tests {
use super::*;
use std::fs;
#[cfg(unix)]
#[test]
fn the_game_data_folder_can_be_changed_when_the_servers_are_stopped() {
let d = tempfile::tempdir().unwrap();
let root = d.path().join("srv");
std::fs::create_dir_all(root.join("Settings")).unwrap();
std::fs::write(
root.join(MARKER),
r#"{"project":"t1","dataDir":"/old/data"}"#,
)
.unwrap();
let good = d.path().join("data");
std::fs::create_dir_all(good.join("dbc")).unwrap();
std::fs::create_dir_all(good.join("maps")).unwrap();
assert_eq!(
game_data_dir(&root).unwrap(),
std::path::PathBuf::from("/old/data")
);
set_game_data(&root, &good).unwrap();
assert_eq!(game_data_dir(&root).unwrap(), good);
assert_eq!(
Config::load(&root).unwrap().project,
"t1",
"the other settings are kept"
);
// A folder that does not look like game data is refused and nothing changes.
let empty = d.path().join("empty");
std::fs::create_dir_all(&empty).unwrap();
assert!(set_game_data(&root, &empty).is_err());
assert_eq!(game_data_dir(&root).unwrap(), good);
assert!(set_game_data(&root, std::path::Path::new("relative/dir")).is_err());
}
#[cfg(unix)]
#[test]
fn a_path_outside_the_core_folder_is_refused_for_a_docker_server() {
let key = "CoaBots.TalentBuildsPath";
assert!(setting_problem(key, "reference/builds.json").is_none());
assert!(setting_problem(key, "").is_none());
assert!(setting_problem(key, "\"/srv/core/reference/builds.json\"").is_none());
assert!(setting_problem(key, "/home/ana/builds.json").is_some());
assert!(
setting_problem("Rate.XP.Kill", "/home/ana/x").is_none(),
"only settings that name a path"
);
}
#[test]
fn setting_names_become_the_variables_the_core_reads() {
for (key, var) in [
("BindIP", "AC_BIND_IP"),
("Ra.Enable", "AC_RA_ENABLE"),
("Ra.IP", "AC_RA_IP"),
("Updates.EnableDatabases", "AC_UPDATES_ENABLE_DATABASES"),
("WorldServerPort", "AC_WORLD_SERVER_PORT"),
("LoginDatabaseInfo", "AC_LOGIN_DATABASE_INFO"),
("DataDir", "AC_DATA_DIR"),
(
"Dynamic.XP.Reminder.Interval",
"AC_DYNAMIC_XP_REMINDER_INTERVAL",
),
("EtherealBazaar.Enable", "AC_ETHEREAL_BAZAAR_ENABLE"),
] {
assert_eq!(env_name(key), var, "{key}");
}
}
#[test]
fn the_settings_called_managed_are_exactly_the_variables_the_containers_get() {
// If a variable is added to the containers without being listed here (or the other way round), a screen would
// offer a setting that does nothing, or hide one that works.
let given: std::collections::BTreeSet<String> =
lifecycle::forced_variables().into_iter().collect();
let listed: std::collections::BTreeSet<String> =
FORCED_KEYS.iter().map(|k| env_name(k)).collect();
assert_eq!(given, listed);
assert!(
managed_setting("ra.enable")
&& managed_setting("Updates.EnableDatabases")
&& !managed_setting("PlayerLimit")
);
}
#[test]
fn the_main_configs_are_created_from_their_templates_and_never_overwritten() {
let d = tempfile::tempdir().unwrap();
+149
View File
@@ -0,0 +1,149 @@
//! Sharing a Docker server with friends. Who can reach the game is decided by the address the container ports are
//! published on (`bindAddress` in `Settings/docker.json`): `127.0.0.1` is this computer only, anything else is the network.
//! The `BindIP` of the configuration files is forced to `0.0.0.0` inside the containers and changes nothing, so the
//! repack's way of opening the servers (editing `BindIP`) is replaced here. The database is never published and the server
//! console is only ever published on the loopback address.
use std::fs;
use std::net::IpAddr;
use std::path::{Path, PathBuf};
use super::{Config, MARKER};
use crate::config::parser::ConfFile;
use crate::config::{take_snapshot, Scope};
use crate::error::Result;
use crate::fsx;
use crate::layout::Ports;
use crate::net::Exposure;
use crate::process::{ServiceState, ServiceStatus};
fn is_open(cfg: &Config) -> bool {
cfg.bind_address.parse::<IpAddr>().map(|ip| !ip.is_loopback()).unwrap_or(false)
}
/// Whether the login and world servers are published beyond this computer.
pub fn bind_is_open(root: &Path) -> bool {
Config::load(root).map(|c| is_open(&c)).unwrap_or(false)
}
/// Publish the login and world servers beyond this computer (`0.0.0.0`) or only on it (`127.0.0.1`). An address the owner chose
/// by hand (for example one network card) is kept when opening. Returns true if anything changed, which needs a restart of
/// the containers. The old files are snapshotted.
pub fn set_open(root: &Path, meta: &Path, open: bool) -> Result<bool> {
let mut cfg = Config::load(root)?;
let mut originals: Vec<(PathBuf, Vec<u8>)> = Vec::new();
let mut changed = false;
if is_open(&cfg) != open {
originals.push((root.join(MARKER), fs::read(root.join(MARKER))?));
cfg.bind_address = if open { "0.0.0.0" } else { "127.0.0.1" }.into();
changed = true;
}
// Friends connect from other addresses, and the server only applies the CoA client protocol to loopback unless remote clients
// are allowed; opening switches that on (closing leaves it, it only matters while the servers listen beyond this computer).
let coa_conf = root.join("Core/configs/modules/coa.conf");
let mut coa_edit = None;
if open {
if let Ok(bytes) = fs::read(&coa_conf) {
let mut conf = ConfFile::parse_bytes(&bytes)?;
if conf.get("CoA.AllowRemoteClients").map(str::trim) != Some("1") {
conf.set("CoA.AllowRemoteClients", "1", &["Set by CoA Server Manager together with the friends mode"]);
originals.push((coa_conf.clone(), bytes));
coa_edit = Some(conf.to_text());
}
}
}
if !changed && coa_edit.is_none() {
return Ok(false);
}
take_snapshot(meta, Scope::Server, if open { "before opening the servers to friends" } else { "before closing the servers to friends" }, &originals)?;
if changed {
fsx::atomic_write_json(&root.join(MARKER), &cfg)?;
}
let remote_changed = coa_edit.is_some();
if let Some(text) = coa_edit {
fsx::atomic_write(&coa_conf, text.as_bytes())?;
}
Ok(changed || remote_changed)
}
/// What each service can be reached from, computed from how the containers publish their ports: the database is never published,
/// the console only on the loopback address, the game servers on `bindAddress`.
pub fn exposure(root: &Path, ports: &Ports) -> Vec<Exposure> {
let open = bind_is_open(root);
let observed = crate::process::observe(root, ports);
let up = |s: &ServiceStatus| matches!(s.state, ServiceState::Running | ServiceState::Starting);
vec![
Exposure { port: ports.mysql, what: "database", listening: up(&observed.mysql), reachable_from_network: false },
Exposure { port: ports.ra, what: "server console", listening: up(&observed.world), reachable_from_network: false },
Exposure { port: ports.auth, what: "login server", listening: up(&observed.auth), reachable_from_network: open && up(&observed.auth) },
Exposure { port: ports.world, what: "game world", listening: up(&observed.world), reachable_from_network: open && up(&observed.world) },
]
}
#[cfg(test)]
mod tests {
use super::*;
fn server(bind: Option<&str>) -> (tempfile::TempDir, PathBuf, PathBuf) {
let d = tempfile::tempdir().unwrap();
let root = d.path().join("srv");
let meta = d.path().join("srv.manager");
fs::create_dir_all(root.join("Settings")).unwrap();
fs::create_dir_all(root.join("Core/configs/modules")).unwrap();
fs::create_dir_all(&meta).unwrap();
let extra = bind.map(|b| format!(r#","bindAddress":"{b}""#)).unwrap_or_default();
fs::write(root.join(MARKER), format!(r#"{{"project":"t1"{extra}}}"#)).unwrap();
fs::write(root.join("Core/configs/modules/coa.conf"), "CoA.Enable = 1\n").unwrap();
(d, root, meta)
}
#[test]
fn opening_and_closing_changes_the_published_address_and_allows_remote_clients() {
let (_d, root, meta) = server(None);
assert!(!bind_is_open(&root));
assert!(set_open(&root, &meta, true).unwrap(), "a restart is needed");
assert!(bind_is_open(&root));
assert_eq!(Config::load(&root).unwrap().bind_address, "0.0.0.0");
assert!(fs::read_to_string(root.join("Core/configs/modules/coa.conf")).unwrap().contains("CoA.AllowRemoteClients = 1"));
assert!(!set_open(&root, &meta, true).unwrap(), "nothing left to change");
assert!(set_open(&root, &meta, false).unwrap());
assert!(!bind_is_open(&root));
assert_eq!(Config::load(&root).unwrap().bind_address, "127.0.0.1");
}
#[test]
fn enabling_remote_client_protocol_requires_restart_even_when_ports_are_open() {
let (_d, root, meta) = server(Some("0.0.0.0"));
fs::write(root.join("Core/configs/modules/coa.conf"), "CoA.Enable = 1\nCoA.AllowRemoteClients = 0\n").unwrap();
assert!(set_open(&root, &meta, true).unwrap());
assert_eq!(Config::load(&root).unwrap().bind_address, "0.0.0.0");
assert!(!set_open(&root, &meta, true).unwrap());
}
#[test]
fn an_address_chosen_by_hand_is_kept_when_opening_and_other_settings_survive() {
let (_d, root, meta) = server(Some("192.168.1.20"));
assert!(bind_is_open(&root), "any address but the loopback is the network");
set_open(&root, &meta, true).unwrap();
let cfg = Config::load(&root).unwrap();
assert_eq!(cfg.bind_address, "192.168.1.20");
assert_eq!(cfg.project, "t1");
}
#[test]
fn the_old_settings_are_snapshotted_before_a_change() {
let (_d, root, meta) = server(None);
set_open(&root, &meta, true).unwrap();
assert_eq!(crate::config::list_snapshots(&meta).len(), 1);
}
#[test]
fn the_database_and_the_console_are_never_reported_reachable() {
let (_d, root, _meta) = server(Some("0.0.0.0"));
let rows = exposure(&root, &Ports::default());
let by = |what: &str| rows.iter().find(|e| e.what == what).unwrap();
assert!(!by("database").reachable_from_network && !by("server console").reachable_from_network);
// Nothing runs in this test (docker is not asked to start anything), so nothing is reachable yet.
assert!(rows.iter().all(|e| !e.reachable_from_network));
}
}