fix: sharing with friends and the other screens work on a Docker server

Second part of the audit of every screen for a Docker server. What it found, and
what now happens:

- Play with friends. "Servers open" read the BindIP of the configuration files, which
  the containers force to 0.0.0.0, so it was green on a fresh server while who can
  connect is decided by the address the ports are published on (bindAddress in
  docker.json). Opening and closing now edit bindAddress (and set
  CoA.AllowRemoteClients), the open state is read from it, and enabling a mode no
  longer fails on netsh / PowerShell after it already rewrote the files. There is no
  firewall row on Linux (Docker publishes the ports itself); the Windows reply is
  unchanged.
- The "private services" check (Friends and Diagnostics) could never fail on Linux: it
  reads the Windows listener table. For a Docker server it is computed from how the
  ports are published: the database never, the console only on 127.0.0.1, the game
  servers on bindAddress.
- Console, Database tab: read a mysql log file that does not exist; it shows
  `docker logs` of the database container.
- The Overview showed a service that had stopped by itself as "Stopped"; it now says
  "Stopped unexpectedly".
- Settings: a Docker server that was added but never started had no
  worldserver.conf and the page failed; it is created from its template. A talent
  file path outside the Core folder is refused (the container cannot see it).
- Backups of configuration now include docker.json; verifying the files of an
  imported Docker server looked for worldserver.exe and reported it missing.
- Linux locations: the friend package and the diagnostics go to the desktop folder
  (from the user directories file) instead of /tmp, the problem report names the
  distribution, and the size advice for companions reads /proc/meminfo instead of
  assuming 8 GB.

Every Windows branch is the code that was there; the dispatch is the early return on
docker::is_docker (or the host flavor for the firewall).
This commit is contained in:
Fabien F. committed 2026-10-11 08:57:38 +02:00
1 parent 90c308615b
commit dfd8a50975
15 files changed
+360 -14

No files matched your search

+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"));
}
}
+23
View File
@@ -18,9 +18,12 @@ mod cli;
pub mod fixture;
pub mod install;
mod lifecycle;
pub mod logs;
pub mod sharing;
pub use cli::{Call, Docker, Output, SystemDocker};
pub use lifecycle::{check_docker, observe, observe_with, run, run_with};
pub use sharing::{bind_is_open, exposure, set_open};
pub(crate) use lifecycle::destroy;
use std::net::IpAddr;
@@ -186,6 +189,15 @@ pub(crate) fn env_name(key: &str) -> String {
out
}
/// 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!("coa-runtime:{}", &fsx::sha256_bytes(RUNTIME_DOCKERFILE.as_bytes())[..12])
@@ -252,6 +264,17 @@ mod tests {
use super::*;
use std::fs;
#[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 [
+139
View File
@@ -0,0 +1,139 @@
//! 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)?;
}
if let Some(text) = coa_edit {
fsx::atomic_write(&coa_conf, text.as_bytes())?;
}
Ok(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 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));
}
}