mirror of
https://github.com/Corfirean/coa-server-manager.git
synced 2026-11-19 03:25:56 +00:00
150 lines
7.2 KiB
Rust
150 lines
7.2 KiB
Rust
//! 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));
|
|
}
|
|
}
|