diff --git a/launcher/README.md b/launcher/README.md index b111113f2..3df61cf50 100644 --- a/launcher/README.md +++ b/launcher/README.md @@ -105,6 +105,12 @@ The same binary is a command-line tool; without a subcommand it opens the window horizon-launcher modpack port [--from ] [--version ] get the jars and carry them over horizon-launcher modpack play [--version ] play it as its own profile horizon-launcher modpack remove + horizon-launcher servers [list] the servers hosted from the launcher, and whether they run + horizon-launcher servers create [--name N] [--seed S | --copy-world DIR] [--mode M] [--difficulty D] + [--max-players N] [--open] [--check-accounts] [--player NAME]... --accept-eula + horizon-launcher servers set-up [--version ] copy a prepared version's programs and game files for servers + horizon-launcher servers run -- for example: servers run "My server" -- start + horizon-launcher servers forget take it off the list (its folder stays) horizon-launcher benchmark [--repeats N] measure the launcher (see Performance log) horizon-launcher data [status] what data collection is allowed, the install ID, what waits horizon-launcher data allow|deny performance, crashes, bugs, benchmarks diff --git a/launcher/src/backend.rs b/launcher/src/backend.rs index c416e5777..ee33942b2 100644 --- a/launcher/src/backend.rs +++ b/launcher/src/backend.rs @@ -1313,7 +1313,8 @@ pub fn server_dir(requested: Option) -> PathBuf { .unwrap_or_else(|| data_dir().join("server")) } -fn need_prepared(tag: &str) -> Result<(), String> { +/// Whether `tag` is prepared, with the run-time reports it needs completed when another copy has them. +pub fn need_prepared(tag: &str) -> Result<(), String> { if is_prepared(tag) { complete_reports(&versions_dir(), tag); Ok(()) diff --git a/launcher/src/cli.rs b/launcher/src/cli.rs index a691eb061..a43529db0 100644 --- a/launcher/src/cli.rs +++ b/launcher/src/cli.rs @@ -21,6 +21,58 @@ struct Cli { command: Option, } +#[derive(Subcommand)] +enum ServersCmd { + /// The servers, their folder and whether they run + List, + /// Create a server; with no options it is a new world, survival, normal, 10 players, friends only + Create { + #[arg(long, default_value = "My server")] + name: String, + /// The new world's seed (default: random) + #[arg(long, conflicts_with = "copy_world")] + seed: Option, + /// Start from a copy of this world folder (one of your saves) + #[arg(long)] + copy_world: Option, + #[arg(long, default_value = "survival", value_parser = ["survival", "creative", "adventure", "spectator"])] + mode: String, + #[arg(long, default_value = "normal", value_parser = ["peaceful", "easy", "normal", "hard"])] + difficulty: String, + #[arg(long, default_value_t = 10)] + max_players: u32, + /// Let anyone in (no whitelist) + #[arg(long)] + open: bool, + /// Check players' Minecraft accounts (they must sign in with Microsoft) + #[arg(long)] + check_accounts: bool, + /// Who may join (repeatable); the first becomes an operator + #[arg(long = "player")] + players: Vec, + /// The installed version whose programs and game files servers use, if none are set up yet + #[arg(long)] + version: Option, + /// Agree to the Minecraft EULA (https://aka.ms/MinecraftEULA) + #[arg(long)] + accept_eula: bool, + }, + /// Copy an installed, prepared version's programs and game files for the servers (again) + SetUp { + #[arg(long)] + version: Option, + }, + /// Run a horizon-server command on a server, for example: servers run "My server" -- status + Run { + /// The server's name or folder + server: String, + #[arg(last = true, required = true)] + args: Vec, + }, + /// Take a server off the list (its folder stays) + Forget { server: String }, +} + #[derive(Subcommand)] enum AccountCmd { /// The signed-in accounts and which one plays @@ -205,6 +257,12 @@ enum Cmd { #[command(subcommand)] action: Option, }, + /// Servers hosted with horizon-server (the Servers page): list them, create one, or run any + /// horizon-server command on one + Servers { + #[command(subcommand)] + action: Option, + }, /// Serve the Model Context Protocol on stdin and stdout, for AI agents Mcp, /// Measure the launcher: starts (the first is the cold one), page switching, idle CPU and @@ -465,6 +523,7 @@ fn execute(command: Cmd, as_json: bool) -> Result<(), String> { } } Cmd::Modpack { action } => modpack(action.unwrap_or(ModpackCmd::List), as_json)?, + Cmd::Servers { action } => servers(action.unwrap_or(ServersCmd::List), as_json)?, Cmd::Mcp => unreachable!(), } Ok(()) @@ -657,6 +716,111 @@ fn data(action: DataCmd, as_json: bool) -> Result<(), String> { Ok(()) } +fn servers(action: ServersCmd, as_json: bool) -> Result<(), String> { + use horizon_launcher::servers::{self, NewServer, World}; + let find = |which: &str| { + servers::list() + .into_iter() + .find(|e| e.name == which || e.dir == std::path::Path::new(which)) + .ok_or_else(|| { + format!("No server called {which}: `horizon-launcher servers` lists them") + }) + }; + match action { + ServersCmd::List => { + let list = servers::list(); + if as_json { + json(serde_json::Value::Array( + list.iter() + .map(|e| { + serde_json::json!({ + "name": e.name, "dir": e.dir, + "phase": servers::status(&e.dir).phase, + }) + }) + .collect(), + )); + } else if list.is_empty() { + println!("No server yet: horizon-launcher servers create --accept-eula"); + } + for e in list.iter().filter(|_| !as_json) { + println!( + "{} ({}): {}", + e.name, + e.dir.display(), + servers::status(&e.dir).phase + ); + } + } + ServersCmd::Create { + name, + seed, + copy_world, + mode, + difficulty, + max_players, + open, + check_accounts, + players, + version, + accept_eula, + } => { + let spec = NewServer { + name, + world: match copy_world { + Some(dir) => World::Copy(dir), + None => World::New { + seed: seed.unwrap_or_default(), + }, + }, + game_mode: mode, + difficulty, + max_players, + friends_only: !open, + check_accounts, + players, + eula: accept_eula, + }; + let tag = backend::resolve_version(version.as_deref()).ok(); + let entry = servers::create(&spec, tag.as_deref(), &|l| eprintln!("{l}")) + .map_err(|p| p.message)?; + if as_json { + json(serde_json::json!({ "name": entry.name, "dir": entry.dir })); + } else { + println!("Created {} in {}", entry.name, entry.dir.display()); + } + } + ServersCmd::SetUp { version } => { + let tag = backend::resolve_version(version.as_deref())?; + servers::set_up(&tag)?; + println!( + "Servers run Horizon {}", + servers::runtime_release().unwrap_or(tag) + ); + } + ServersCmd::Run { server, args } => { + let entry = find(&server)?; + let args: Vec<&str> = args.iter().map(String::as_str).collect(); + let status = servers::command(&entry.dir, &args)? + .status() + .map_err(|e| e.to_string())?; + if !status.success() { + return Err(format!("horizon-server exited with {status}")); + } + } + ServersCmd::Forget { server } => { + let entry = find(&server)?; + servers::forget(&entry.dir)?; + println!( + "{} is off the list; its folder stays in {}", + entry.name, + entry.dir.display() + ); + } + } + Ok(()) +} + fn modpack(action: ModpackCmd, as_json: bool) -> Result<(), String> { use horizon_launcher::modpacks::{self, Imported}; use horizon_port_pack::report::Status; diff --git a/launcher/src/lib.rs b/launcher/src/lib.rs index 11023a46d..9e164d9fb 100644 --- a/launcher/src/lib.rs +++ b/launcher/src/lib.rs @@ -4,5 +4,6 @@ pub mod backend; pub mod desktop; pub mod modpacks; pub mod mojang; +pub mod servers; pub mod sources; pub mod telemetry; diff --git a/launcher/src/servers.rs b/launcher/src/servers.rs new file mode 100644 index 000000000..fc72924e1 --- /dev/null +++ b/launcher/src/servers.rs @@ -0,0 +1,954 @@ +//! Servers hosted from the launcher. Every server is a `horizon-server` folder and the launcher drives +//! `horizon-server` (docs/server.md in the repository) rather than its own copy of the logic: `init`, +//! `start`, `stop`, `config set`, `backup`, `restore`, `update`, `service`, and the control API the running +//! supervisor serves on 127.0.0.1 for the live status, the log and console commands. +//! +//! The programs come from an installed Horizon version, laid out as `install.sh` lays them out +//! (`server-runtime/releases/`, `current`, `game-files/`), so `horizon-server update` and its +//! rollback work on them unchanged. The game files are the player's own, copied from the version the +//! launcher prepared: nothing of Mojang's is downloaded or shipped. + +use crate::backend; +use serde::{Deserialize, Serialize}; +use serde_json::{json, Value}; +use std::fs; +use std::path::{Path, PathBuf}; +use std::process::{Command, Stdio}; +use std::time::Duration; + +const PROGRAM: &str = if cfg!(windows) { + "horizon-server.exe" +} else { + "horizon-server" +}; + +/// The Minecraft EULA a server owner agrees to. +pub const EULA_URL: &str = "https://aka.ms/MinecraftEULA"; + +// ----- The list of servers ----------------------------------------------------------------------- + +/// One server the launcher knows: its name and its folder. +#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] +pub struct Entry { + pub name: String, + pub dir: PathBuf, +} + +fn list_file() -> PathBuf { + backend::data_dir().join("servers.json") +} + +/// The servers, in the order they were added; folders that are gone are left out. +pub fn list() -> Vec { + let entries: Vec = fs::read_to_string(list_file()) + .ok() + .and_then(|t| serde_json::from_str(&t).ok()) + .unwrap_or_default(); + entries.into_iter().filter(|e| e.dir.is_dir()).collect() +} + +fn save_list(entries: &[Entry]) -> Result<(), String> { + fs::create_dir_all(backend::data_dir()).map_err(|e| e.to_string())?; + let text = serde_json::to_string_pretty(entries).map_err(|e| e.to_string())?; + fs::write(list_file(), text).map_err(|e| e.to_string()) +} + +/// Adds a server folder to the list (once). +pub fn add(entry: Entry) -> Result<(), String> { + let mut all = list(); + all.retain(|e| e.dir != entry.dir); + all.push(entry); + save_list(&all) +} + +/// Takes a server off the list; its folder stays. +pub fn forget(dir: &Path) -> Result<(), String> { + let mut all = list(); + all.retain(|e| e.dir != dir); + save_list(&all) +} + +/// A folder name for a server name: lower case letters, digits and dashes. +pub fn slug(name: &str) -> String { + let mut out = String::new(); + for c in name.trim().chars() { + if c.is_ascii_alphanumeric() { + out.push(c.to_ascii_lowercase()); + } else if !out.ends_with('-') { + out.push('-'); + } + } + let out = out.trim_matches('-').to_string(); + if out.is_empty() { + "server".into() + } else { + out + } +} + +/// A new folder for a server called `name`, under `servers/` in the data folder. +pub fn new_folder(name: &str) -> PathBuf { + let root = backend::data_dir().join("servers"); + let base = slug(name); + let mut dir = root.join(&base); + let mut n = 2; + while dir.exists() { + dir = root.join(format!("{base}-{n}")); + n += 1; + } + dir +} + +// ----- The programs: an installed Horizon version, laid out as install.sh does --------------------- + +pub fn runtime_root() -> PathBuf { + backend::data_dir().join("server-runtime") +} + +/// `horizon-server` of the release in use, once one is set up. +pub fn program() -> Option { + Some(runtime_root().join("current").join(PROGRAM)).filter(|p| p.is_file()) +} + +/// The release the servers run. +pub fn runtime_release() -> Option { + let target = fs::canonicalize(runtime_root().join("current")).ok()?; + Some(target.file_name()?.to_string_lossy().into_owned()) +} + +/// Where `horizon-server` finds the game files: the folder install.sh keeps across updates. +pub fn game_files(root: &Path, game_version: &str) -> PathBuf { + root.join("game-files/horizon-client").join(game_version) +} + +/// Whether the servers' game files are there. +pub fn game_files_ready() -> bool { + game_files(&runtime_root(), "26.3") + .join("horizon-resources.json") + .is_file() +} + +/// Whether an installed version can host: it ships `horizon-server` and is prepared. +pub fn can_host(tag: &str) -> Result<(), String> { + if !backend::version_dir(tag).join(PROGRAM).is_file() { + return Err(format!( + "Horizon {tag} has no server program. Install a newer version on the Versions page." + )); + } + if !backend::is_prepared(tag) { + return Err(format!( + "Horizon {tag} isn't prepared yet: press Prepare on the Play page (it uses your own Minecraft {})", + backend::game_version(tag) + )); + } + Ok(()) +} + +/// Sets up the servers' programs from the installed version `tag` (if none are yet) and copies its +/// prepared game files for them. Safe to run again: it only refreshes the game files. +pub fn set_up(tag: &str) -> Result<(), String> { + can_host(tag)?; + // The data generator's reports the game reads at run time, as Play checks them. + backend::need_prepared(tag)?; + set_up_in( + &runtime_root(), + &backend::version_dir(tag), + tag, + &backend::game_version(tag), + ) +} + +/// [`set_up`] with its folders given (for tests). +pub fn set_up_in(root: &Path, version: &Path, tag: &str, game_version: &str) -> Result<(), String> { + let releases = root.join("releases"); + fs::create_dir_all(&releases).map_err(|e| format!("{}: {e}", releases.display()))?; + let release = releases.join(tag); + if !root.join("current").exists() { + if !release.join(PROGRAM).is_file() { + let scratch = releases.join(format!(".{tag}.copying")); + let _ = fs::remove_dir_all(&scratch); + copy_release(version, &scratch).map_err(|e| format!("copying {tag}: {e}"))?; + let _ = fs::remove_dir_all(&release); + fs::rename(&scratch, &release).map_err(|e| e.to_string())?; + } + let local = release.join(".local"); + fs::create_dir_all(&local).map_err(|e| e.to_string())?; + let link = local.join("horizon-client"); + if link.symlink_metadata().is_err() { + fs::create_dir_all(root.join("game-files/horizon-client")) + .map_err(|e| e.to_string())?; + point(&link, &root.join("game-files/horizon-client")).map_err(|e| e.to_string())?; + } + point(&root.join("current"), &release).map_err(|e| e.to_string())?; + } + // The game files: a copy (preparing again rewrites files in place), swapped in whole. + let from = version.join(".local/horizon-client").join(game_version); + let to = game_files(root, game_version); + let fresh = to.with_extension("copying"); + let _ = fs::remove_dir_all(&fresh); + copy_dir(&from, &fresh).map_err(|e| format!("copying the game files: {e}"))?; + let old = to.with_extension("old"); + let _ = fs::remove_dir_all(&old); + if to.exists() { + fs::rename(&to, &old).map_err(|e| e.to_string())?; + } + fs::rename(&fresh, &to).map_err(|e| e.to_string())?; + let _ = fs::remove_dir_all(&old); + Ok(()) +} + +/// A release folder without the launcher's own files (its prepared copy and install marker). +fn copy_release(from: &Path, to: &Path) -> std::io::Result<()> { + fs::create_dir_all(to)?; + for entry in fs::read_dir(from)? { + let entry = entry?; + let name = entry.file_name(); + if name == ".local" || name == ".installed" { + continue; + } + let target = to.join(&name); + if entry.file_type()?.is_dir() { + copy_dir(&entry.path(), &target)?; + } else { + fs::copy(entry.path(), &target)?; + } + } + Ok(()) +} + +fn copy_dir(from: &Path, to: &Path) -> std::io::Result<()> { + fs::create_dir_all(to)?; + for entry in fs::read_dir(from)? { + let entry = entry?; + let target = to.join(entry.file_name()); + let kind = entry.file_type()?; + if kind.is_dir() { + copy_dir(&entry.path(), &target)?; + } else if kind.is_file() { + fs::copy(entry.path(), target)?; + } + } + Ok(()) +} + +/// Makes `link` point at the folder `target`, as install.sh (a symbolic link) and install.ps1 (a +/// junction, which needs no admin rights) do. +fn point(link: &Path, target: &Path) -> std::io::Result<()> { + let fresh = link.with_extension("switching"); + let _ = fs::remove_file(&fresh); + #[cfg(unix)] + { + std::os::unix::fs::symlink(target, &fresh)?; + fs::rename(&fresh, link) + } + #[cfg(windows)] + { + let _ = fs::remove_dir(link); + let status = Command::new("cmd") + .args(["/C", "mklink", "/J"]) + .arg(link) + .arg(target) + .stdout(Stdio::null()) + .status()?; + if status.success() { + Ok(()) + } else { + Err(std::io::Error::other("mklink /J failed")) + } + } +} + +// ----- Running horizon-server ------------------------------------------------------------------- + +/// `horizon-server --dir `. +pub fn command(dir: &Path, args: &[&str]) -> Result { + let program = program().ok_or( + "The server programs aren't set up yet: create a server, or press Prepare on its page.", + )?; + let mut cmd = Command::new(program); + cmd.arg("--dir").arg(dir).args(args); + #[cfg(windows)] + std::os::windows::process::CommandExt::creation_flags(&mut cmd, 0x0800_0000); // CREATE_NO_WINDOW + Ok(cmd) +} + +fn supervisor_log(dir: &Path) -> PathBuf { + dir.join("logs/supervisor.log") +} + +fn log_length(dir: &Path) -> u64 { + fs::metadata(supervisor_log(dir)).map_or(0, |m| m.len()) +} + +/// Runs one `horizon-server` command to its end: what it printed, or the problem in plain words. +pub fn run(dir: &Path, args: &[&str]) -> Result { + let since = log_length(dir); + let output = command(dir, args) + .map_err(Problem::plain)? + .stdin(Stdio::null()) + .output() + .map_err(|e| Problem::plain(format!("Couldn't run horizon-server: {e}")))?; + let out = String::from_utf8_lossy(&output.stdout).into_owned(); + if output.status.success() { + Ok(out) + } else { + let err = String::from_utf8_lossy(&output.stderr); + Err(Problem::explain(&format!("{out}\n{err}"), dir, since)) + } +} + +/// Runs a long `horizon-server` command, passing each line it prints to `line`. +pub fn run_streamed(dir: &Path, args: &[&str], line: &dyn Fn(String)) -> Result<(), Problem> { + use std::io::{BufRead, BufReader, Read}; + let since = log_length(dir); + let mut child = command(dir, args) + .map_err(Problem::plain)? + .stdin(Stdio::null()) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()) + .spawn() + .map_err(|e| Problem::plain(format!("Couldn't run horizon-server: {e}")))?; + let mut err = child.stderr.take(); + let errors = std::thread::spawn(move || { + let mut text = String::new(); + if let Some(e) = &mut err { + let _ = e.read_to_string(&mut text); + } + text + }); + let mut out = String::new(); + if let Some(stdout) = child.stdout.take() { + // `start` prints a dot every half second on one line: those aren't lines worth showing. + for l in BufReader::new(stdout).lines().map_while(Result::ok) { + let shown = l + .trim_start_matches(['.', ' ']) + .trim_start_matches("Starting"); + let shown = shown.trim_start_matches('.').trim(); + if !shown.is_empty() { + line(shown.to_string()); + } + out.push_str(&l); + out.push('\n'); + } + } + let status = child.wait().map_err(|e| Problem::plain(e.to_string()))?; + let err = errors.join().unwrap_or_default(); + if status.success() { + Ok(()) + } else { + Err(Problem::explain(&format!("{out}\n{err}"), dir, since)) + } +} + +/// What can be done about a problem, with one button. +#[derive(Clone, Debug, PartialEq)] +pub enum Fix { + /// The port is taken: use this free one. + UsePort(u16), + /// The game files are missing: prepare them (Play page) and copy them for the servers. + Prepare, + /// The EULA isn't agreed to. + AgreeEula, + /// The game's own log says more. + ShowLog, +} + +/// A problem, in plain words. +#[derive(Clone, Debug, PartialEq)] +pub struct Problem { + pub message: String, + pub fix: Option, +} + +impl Problem { + pub fn plain(message: impl Into) -> Self { + Self { + message: message.into(), + fix: None, + } + } + + /// Reads what `horizon-server` (and the game log it points at) said. + /// `since` is the background server's log length before the command: only what it logged after counts. + pub fn explain(output: &str, dir: &Path, since: u64) -> Self { + let log = fs::read(supervisor_log(dir)).unwrap_or_default(); + let new = log.get(since as usize..).unwrap_or_default(); + Self::explain_with(output, &String::from_utf8_lossy(new), dir) + } + + fn explain_with(output: &str, log: &str, dir: &Path) -> Self { + let both = format!("{output}\n{log}"); + let has = |s: &str| both.contains(s); + // Vanilla says FAILED TO BIND TO PORT for any failure while starting; only these are a busy port. + let busy = [ + "already in use", + "Address in use", + "Only one usage of each socket address", + ]; + if busy.iter().any(|b| both.contains(b)) { + let port = config(dir) + .and_then(|c| c["server"]["port"].as_u64()) + .unwrap_or(25565) as u16; + return Self { + message: format!( + "Port {port} is already used by another program (maybe another server). Use a free \ + port instead: friends then add it to the address." + ), + fix: Some(Fix::UsePort(free_port(port + 1, &[]))), + }; + } + if has("no prepared game files") || has("not found next to the resources") { + return Self { + message: + "The server needs the game files from your own Minecraft. Prepare them: it \ + takes a few minutes, once." + .into(), + fix: Some(Fix::Prepare), + }; + } + if has("EULA") && !has("eula=true") { + return Self { + message: "Running a server needs your agreement to the Minecraft EULA.".into(), + fix: Some(Fix::AgreeEula), + }; + } + if has("isn't up after") || has("the server stopped") { + return Self { + message: "The game didn't start. Its log below says why.".into(), + fix: Some(Fix::ShowLog), + }; + } + let said = both + .lines() + .rev() + .find_map(|l| l.strip_prefix("horizon-server: ")) + .map(str::to_string) + .or_else(|| { + output + .lines() + .rev() + .find(|l| !l.trim().is_empty()) + .map(str::to_string) + }) + .unwrap_or_else(|| "horizon-server failed without saying why".into()); + Self::plain(capitalised(&said)) + } +} + +fn capitalised(s: &str) -> String { + let mut c = s.chars(); + match c.next() { + Some(f) => f.to_uppercase().chain(c).collect(), + None => String::new(), + } +} + +// ----- Creating a server ------------------------------------------------------------------------ + +/// The world a new server starts with. +#[derive(Clone, Debug, PartialEq)] +pub enum World { + /// A new world; an empty seed is a random one. + New { seed: String }, + /// A copy of one of the player's worlds (its folder). + Copy(PathBuf), +} + +/// What the Create dialog asks; [`NewServer::default`] alone makes a working server. +#[derive(Clone, Debug, PartialEq)] +pub struct NewServer { + pub name: String, + pub world: World, + pub game_mode: String, + pub difficulty: String, + pub max_players: u32, + /// Only listed players (and operators) may join. + pub friends_only: bool, + /// Check players' Minecraft accounts: they must sign in with Microsoft. + pub check_accounts: bool, + /// Who may join first (whitelisted), and the first of them becomes an operator. + pub players: Vec, + pub eula: bool, +} + +impl Default for NewServer { + fn default() -> Self { + Self { + name: "My server".into(), + world: World::New { + seed: String::new(), + }, + game_mode: "survival".into(), + difficulty: "normal".into(), + max_players: 10, + friends_only: true, + check_accounts: false, + players: Vec::new(), + eula: false, + } + } +} + +/// A port nobody listens on, from `from` up, and not one of `taken`. +pub fn free_port(from: u16, taken: &[u16]) -> u16 { + (from..u16::MAX) + .find(|p| !taken.contains(p) && std::net::TcpListener::bind(("0.0.0.0", *p)).is_ok()) + .unwrap_or(from) +} + +/// The ports the launcher's other servers use: their game port and their web panel. +fn ports_taken() -> Vec { + let mut out = Vec::new(); + for e in list() { + if let Some(c) = config(&e.dir) { + out.extend(c["server"]["port"].as_u64().map(|p| p as u16)); + out.extend( + c["panel"]["bind"] + .as_str() + .and_then(|b| b.rsplit_once(':')) + .and_then(|(_, p)| p.parse::().ok()), + ); + } + } + out +} + +/// The player's worlds (the game home's `saves/`), newest first: their name and folder. +pub fn player_worlds() -> Vec<(String, PathBuf)> { + let saves = backend::game_home().join("saves"); + let mut worlds: Vec<(std::time::SystemTime, String, PathBuf)> = fs::read_dir(saves) + .into_iter() + .flatten() + .flatten() + .filter(|e| e.path().join("level.dat").is_file()) + .map(|e| { + let when = e + .path() + .join("level.dat") + .metadata() + .and_then(|m| m.modified()) + .unwrap_or(std::time::UNIX_EPOCH); + (when, e.file_name().to_string_lossy().into_owned(), e.path()) + }) + .collect(); + worlds.sort_by_key(|w| std::cmp::Reverse(w.0)); + worlds.into_iter().map(|(_, n, p)| (n, p)).collect() +} + +/// The `horizon-server init` arguments for a new server. +pub fn init_args(spec: &NewServer, world: &str, port: u16) -> Vec { + let mut args: Vec = vec!["init".into(), "--yes".into()]; + if spec.eula { + args.push("--eula".into()); + } + args.extend(["--world".into(), world.to_string()]); + if let World::New { seed } = &spec.world { + if !seed.trim().is_empty() { + args.extend(["--seed".into(), seed.trim().to_string()]); + } + } + args.extend(["--port".into(), port.to_string()]); + args.push(if spec.friends_only { + "--whitelist".into() + } else { + "--no-whitelist".into() + }); + if !spec.check_accounts { + args.push("--offline".into()); + } + for p in &spec.players { + args.extend(["--player".into(), p.clone()]); + } + if let Some(first) = spec.players.first() { + args.extend(["--op".into(), first.clone()]); + } + args +} + +/// The `horizon-server config set` arguments that finish a new server. +pub fn settings_args(spec: &NewServer, panel_port: u16) -> Vec { + vec![ + "config".into(), + "set".into(), + format!("world.game_mode={}", spec.game_mode), + format!("world.difficulty={}", spec.difficulty), + format!("server.max_players={}", spec.max_players.clamp(1, 1000)), + format!("server.motd={}", spec.name.trim()), + format!("panel.bind=127.0.0.1:{panel_port}"), + ] +} + +/// Creates a server: its folder, the world (a copy when asked), `init` and the settings, then adds it to +/// the list. `tag` is the installed version whose programs and game files it uses when none are set up. +pub fn create(spec: &NewServer, tag: Option<&str>, log: &dyn Fn(String)) -> Result { + if !spec.eula { + return Err(Problem { + message: "Running a server needs your agreement to the Minecraft EULA.".into(), + fix: Some(Fix::AgreeEula), + }); + } + if program().is_none() || !game_files_ready() { + let tag = tag.ok_or_else(|| { + Problem::plain("Install a Horizon version first (Versions page), then prepare it.") + })?; + log(format!("Setting up the server programs from Horizon {tag}")); + set_up(tag).map_err(|e| { + if e.contains("prepared") { + Problem { + message: e, + fix: Some(Fix::Prepare), + } + } else { + Problem::plain(e) + } + })?; + } + let name = if spec.name.trim().is_empty() { + "My server".to_string() + } else { + spec.name.trim().to_string() + }; + let dir = new_folder(&name); + fs::create_dir_all(&dir).map_err(|e| Problem::plain(e.to_string()))?; + let world = match &spec.world { + World::New { .. } => "world".to_string(), + World::Copy(from) => { + let world = from + .file_name() + .map(|n| slug(&n.to_string_lossy())) + .unwrap_or_else(|| "world".into()); + log(format!("Copying the world {}", from.display())); + copy_world(from, &dir.join(&world)).map_err(|e| { + let _ = fs::remove_dir_all(&dir); + Problem::plain(format!("Couldn't copy the world: {e}")) + })?; + world + } + }; + let taken = ports_taken(); + let port = free_port(25565, &taken); + let panel = free_port(8130, &taken); + let undo = |p: Problem| { + let _ = fs::remove_dir_all(&dir); + p + }; + let init = init_args(spec, &world, port); + log("Writing the server's settings".into()); + run(&dir, &init.iter().map(String::as_str).collect::>()).map_err(undo)?; + let settings = settings_args(spec, panel); + run( + &dir, + &settings.iter().map(String::as_str).collect::>(), + ) + .map_err(undo)?; + let entry = Entry { name, dir }; + add(entry.clone()).map_err(Problem::plain)?; + Ok(entry) +} + +/// A copy of a world folder, without the lock a running game holds. +fn copy_world(from: &Path, to: &Path) -> std::io::Result<()> { + fs::create_dir_all(to)?; + for entry in fs::read_dir(from)? { + let entry = entry?; + let name = entry.file_name(); + if name == "session.lock" { + continue; + } + let target = to.join(&name); + if entry.file_type()?.is_dir() { + copy_world(&entry.path(), &target)?; + } else { + fs::copy(entry.path(), target)?; + } + } + Ok(()) +} + +// ----- A server's files -------------------------------------------------------------------------- + +/// The settings, as `horizon-server config --json` prints them (`None` before `init`, or from a +/// `horizon-server` older than the command). +pub fn config(dir: &Path) -> Option { + if !dir.join("server.toml").is_file() { + return None; + } + let out = run(dir, &["config", "--json"]).ok()?; + serde_json::from_str(out.trim()).ok() +} + +/// What `config set` did: the settings applied now, and those waiting for a restart. +#[derive(Clone, Debug, Default, PartialEq, Deserialize)] +pub struct Applied { + #[serde(default)] + pub applied: Vec, + #[serde(default)] + pub restart: Vec, + #[serde(default)] + pub running: bool, +} + +/// Changes settings through `horizon-server config set` (checked there; nothing is written if one is +/// wrong). +pub fn set_config(dir: &Path, changes: &[(&str, String)]) -> Result { + let pairs: Vec = changes.iter().map(|(k, v)| format!("{k}={v}")).collect(); + let mut args = vec!["config", "set"]; + args.extend(pairs.iter().map(String::as_str)); + args.push("--json"); + let out = run(dir, &args)?; + serde_json::from_str(out.trim()).map_err(|e| Problem::plain(e.to_string())) +} + +/// A list file's names (`whitelist.json`, `ops.json`, `banned-players.json`), as vanilla writes them. +pub fn names(dir: &Path, file: &str) -> Vec { + fs::read_to_string(dir.join(file)) + .ok() + .and_then(|t| serde_json::from_str::>(&t).ok()) + .unwrap_or_default() + .iter() + .filter_map(|e| e["name"].as_str().map(str::to_string)) + .collect() +} + +/// A backup, as `horizon-server backups --json` lists it. +#[derive(Clone, Debug, PartialEq, Deserialize)] +pub struct Backup { + pub name: String, + pub bytes: u64, + #[serde(default)] + pub modified: Option, +} + +pub fn backups(dir: &Path) -> Result, Problem> { + let out = run(dir, &["backups", "--json"])?; + serde_json::from_str(out.trim()).map_err(|e| Problem::plain(e.to_string())) +} + +/// The address friends on the same network type: this computer's LAN address. No packet is sent: the +/// system only picks the interface it would use. +pub fn lan_address() -> Option { + let socket = std::net::UdpSocket::bind("0.0.0.0:0").ok()?; + socket.connect("192.0.2.1:9").ok()?; + let ip = socket.local_addr().ok()?.ip(); + (!ip.is_unspecified() && !ip.is_loopback()).then_some(ip) +} + +/// Whether the server starts at login: the service definition `horizon-server service print` names exists. +pub fn service_installed(dir: &Path) -> bool { + if cfg!(windows) { + let name = format!("horizon-server-{}", service_suffix(dir)); + return Command::new("schtasks") + .args(["/Query", "/TN", &name]) + .stdout(Stdio::null()) + .stderr(Stdio::null()) + .status() + .is_ok_and(|s| s.success()); + } + run(dir, &["service", "print"]) + .ok() + .and_then(|out| { + out.lines() + .next() + .and_then(|l| l.strip_prefix("# ")) + .map(PathBuf::from) + }) + .is_some_and(|p| p.is_file()) +} + +/// horizon-server's service name for a folder, after `horizon-server-`. +fn service_suffix(dir: &Path) -> String { + let folder = dir + .file_name() + .map(|n| n.to_string_lossy().into_owned()) + .unwrap_or_default(); + let clean: String = folder + .chars() + .map(|c| { + if c.is_ascii_alphanumeric() { + c.to_ascii_lowercase() + } else { + '-' + } + }) + .collect(); + let clean = clean.trim_matches('-'); + if clean.is_empty() { + "server".into() + } else { + clean.into() + } +} + +// ----- The running server: its control API ------------------------------------------------------- + +/// The running supervisor's control API (`.horizon/api.json`: its address and token). +#[derive(Clone, Debug)] +pub struct Api { + address: String, + token: String, +} + +impl Api { + /// The API of the server running in `dir`, if one runs. + pub fn open(dir: &Path) -> Option { + let text = fs::read_to_string(dir.join(".horizon/api.json")).ok()?; + let v: Value = serde_json::from_str(&text).ok()?; + Some(Self { + address: v["address"].as_str()?.to_string(), + token: v["token"].as_str()?.to_string(), + }) + } + + pub fn call(&self, method: &str, path: &str, body: Option) -> Result { + let agent = ureq::AgentBuilder::new() + .timeout(Duration::from_secs(10)) + .build(); + let request = agent + .request(method, &format!("http://{}{path}", self.address)) + .set("Authorization", &format!("Bearer {}", self.token)); + let response = match body { + Some(b) => request.send_json(b), + None => request.call(), + }; + match response { + Ok(r) => r.into_json().map_err(|e| e.to_string()), + Err(ureq::Error::Status(_, r)) => { + let v: Value = r.into_json().unwrap_or(Value::Null); + Err(v["error"] + .as_str() + .unwrap_or("the server refused") + .to_string()) + } + Err(e) => Err(e.to_string()), + } + } + + pub fn status(&self) -> Option { + self.call("GET", "/api/v1/status", None) + .ok() + .map(|v| Status::parse(&v)) + } + + /// The log lines after `since`, and the number to ask from next time. + pub fn logs(&self, since: u64) -> Option<(u64, Vec)> { + let v = self + .call("GET", &format!("/api/v1/logs?since={since}"), None) + .ok()?; + let lines = v["lines"] + .as_array()? + .iter() + .filter_map(|l| l.as_str().map(str::to_string)) + .collect(); + Some((v["next"].as_u64().unwrap_or(since), lines)) + } + + /// One console command; what the game answered. + pub fn command(&self, line: &str) -> Result, String> { + let v = self.call("POST", "/api/v1/command", Some(json!({ "line": line })))?; + Ok(v["output"] + .as_array() + .into_iter() + .flatten() + .filter_map(|l| l.as_str().map(str::to_string)) + .collect()) + } + + /// A one-time login link for the web panel. + pub fn panel_link(&self) -> Result { + let v = self.call("POST", "/api/v1/panel/login", None)?; + v["url"] + .as_str() + .map(str::to_string) + .ok_or_else(|| "the panel gave no link".into()) + } +} + +/// A player online. +#[derive(Clone, Debug, Default, PartialEq)] +pub struct Player { + pub name: String, + pub uuid: String, + pub ping: Option, +} + +/// What the supervisor reports. +#[derive(Clone, Debug, Default, PartialEq)] +pub struct Status { + /// starting, running, stopping or restarting (stopped when nothing answers). + pub phase: String, + pub uptime: Option, + pub crashes: u64, + pub last_crash: Option, + pub tps: Option, + pub mspt: Option, + pub players: Vec, + pub max_players: Option, + pub ram_bytes: Option, + pub cpu_percent: Option, + /// Paused because nobody is online (vanilla's pause-when-empty). + pub paused: bool, + /// The release in use and a newer one, when the supervisor found one. + pub release: Option, + pub update_available: Option, + /// An update under way: what it is doing now. + pub update_busy: Option, + /// How the last update went (its message, and whether it worked). + pub update_last: Option<(String, bool)>, +} + +impl Status { + pub fn stopped() -> Self { + Self { + phase: "stopped".into(), + ..Self::default() + } + } + + pub fn parse(v: &Value) -> Self { + let game = &v["sample"]["game"]; + let update = &v["update"]; + Self { + phase: v["phase"].as_str().unwrap_or("stopped").to_string(), + uptime: v["engine_uptime_seconds"].as_u64(), + crashes: v["crashes"].as_u64().unwrap_or(0), + last_crash: v["last_crash"].as_str().map(str::to_string), + tps: game["tps"].as_f64(), + mspt: game["mspt"]["average"].as_f64(), + players: game["players"] + .as_array() + .into_iter() + .flatten() + .map(|p| Player { + name: p["name"].as_str().unwrap_or_default().to_string(), + uuid: p["uuid"].as_str().unwrap_or_default().to_string(), + ping: p["ping"].as_u64(), + }) + .collect(), + max_players: game["max_players"].as_u64(), + ram_bytes: v["sample"]["rss_bytes"].as_u64(), + cpu_percent: v["sample"]["cpu_percent"].as_f64(), + paused: game["paused"] == true, + release: update["installed"].as_str().map(str::to_string), + update_available: update["available"].as_str().map(str::to_string), + update_busy: update["busy"].as_str().map(str::to_string), + update_last: update["last"] + .as_str() + .map(|m| (m.to_string(), update["ok"] != false)), + } + } + + pub fn running(&self) -> bool { + self.phase != "stopped" + } +} + +/// The status of the server in `dir`: what its API says, or stopped. +pub fn status(dir: &Path) -> Status { + Api::open(dir) + .and_then(|api| api.status()) + .unwrap_or_else(Status::stopped) +} + +#[cfg(test)] +#[path = "servers/tests.rs"] +mod tests; diff --git a/launcher/src/servers/tests.rs b/launcher/src/servers/tests.rs new file mode 100644 index 000000000..f096baf3a --- /dev/null +++ b/launcher/src/servers/tests.rs @@ -0,0 +1,225 @@ +use super::*; +use std::io::{BufRead, BufReader, Write}; + +fn scratch(name: &str) -> PathBuf { + let dir = std::env::temp_dir().join(format!("horizon-servers-{name}-{}", std::process::id())); + let _ = fs::remove_dir_all(&dir); + fs::create_dir_all(&dir).unwrap(); + dir +} + +#[test] +fn folder_names_are_plain() { + assert_eq!(slug("Ludo's Survival!"), "ludo-s-survival"); + assert_eq!(slug(" "), "server"); + assert_eq!(slug("Été 2026"), "t-2026"); + assert_eq!(service_suffix(Path::new("/x/My World")), "my-world"); +} + +#[test] +fn create_asks_init_and_config_set() { + let spec = NewServer { + name: "Friends".into(), + world: World::New { + seed: " 12345 ".into(), + }, + players: vec!["Alex".into(), "Steve".into()], + eula: true, + ..NewServer::default() + }; + assert_eq!( + init_args(&spec, "world", 25566).join(" "), + "init --yes --eula --world world --seed 12345 --port 25566 --whitelist --offline \ + --player Alex --player Steve --op Alex" + ); + let open = NewServer { + friends_only: false, + check_accounts: true, + world: World::Copy("/saves/Old".into()), + ..NewServer::default() + }; + assert_eq!( + init_args(&open, "old", 25565).join(" "), + "init --yes --world old --port 25565 --no-whitelist" + ); + assert_eq!( + settings_args(&spec, 8131).join(" "), + "config set world.game_mode=survival world.difficulty=normal server.max_players=10 \ + server.motd=Friends panel.bind=127.0.0.1:8131" + ); +} + +#[cfg(unix)] +#[test] +fn programs_are_laid_out_as_install_sh_does() { + let root = scratch("runtime"); + let version = root.join("versions/v1"); + fs::create_dir_all(version.join(".local/horizon-client/26.3")).unwrap(); + fs::write(version.join(PROGRAM), "server").unwrap(); + fs::write(version.join("horizon-client"), "game").unwrap(); + fs::write(version.join(".installed"), "").unwrap(); + fs::write( + version.join(".local/horizon-client/26.3/horizon-resources.json"), + "{}", + ) + .unwrap(); + let rt = root.join("runtime"); + set_up_in(&rt, &version, "v1", "26.3").unwrap(); + assert_eq!( + fs::read_to_string(rt.join("current").join(PROGRAM)).unwrap(), + "server" + ); + assert!(!rt.join("releases/v1/.installed").exists()); + // The release finds the game files where horizon-server looks: .local beside it. + assert!(rt + .join("current/.local/horizon-client/26.3/horizon-resources.json") + .is_file()); + // Again with newer game files: only they change, swapped in whole. + fs::write( + version.join(".local/horizon-client/26.3/horizon-resources.json"), + "{\"new\":1}", + ) + .unwrap(); + set_up_in(&rt, &version, "v1", "26.3").unwrap(); + assert_eq!( + fs::read_to_string(game_files(&rt, "26.3").join("horizon-resources.json")).unwrap(), + "{\"new\":1}" + ); + assert!(!game_files(&rt, "26.3").with_extension("old").exists()); + fs::remove_dir_all(&root).unwrap(); +} + +#[test] +fn problems_say_what_to_do() { + let dir = scratch("problems"); + let port = Problem::explain_with( + "", + "[Server thread/WARN]: **** FAILED TO BIND TO PORT!\nThe exception was: Address already in use (os error 48)", + &dir, + ); + assert!(port.message.contains("already used"), "{}", port.message); + assert!(matches!(port.fix, Some(Fix::UsePort(p)) if p > 25565)); + let files = Problem::explain_with( + "horizon-server: no prepared game files. Horizon reads them from", + "", + &dir, + ); + assert_eq!(files.fix, Some(Fix::Prepare)); + let reports = Problem::explain_with( + "", + "**** FAILED TO BIND TO PORT!\nThe exception was: registries.json not found next to the resources", + &dir, + ); + assert_eq!(reports.fix, Some(Fix::Prepare)); + let other = Problem::explain_with("horizon-server: a server is already running in x", "", &dir); + assert_eq!(other, Problem::plain("A server is already running in x")); + fs::remove_dir_all(&dir).unwrap(); +} + +#[test] +fn lists_and_status_read_as_vanilla_and_the_supervisor_write_them() { + let dir = scratch("lists"); + fs::write( + dir.join("whitelist.json"), + r#"[{"uuid": "a", "name": "Alex"}, {"uuid": "b", "name": "Steve"}]"#, + ) + .unwrap(); + assert_eq!(names(&dir, "whitelist.json"), ["Alex", "Steve"]); + assert!(names(&dir, "ops.json").is_empty()); + fs::remove_dir_all(&dir).unwrap(); + + let s = Status::parse(&json!({ + "phase": "running", "engine_uptime_seconds": 61, "crashes": 1, "last_crash": "signal: 9", + "sample": { "rss_bytes": 800_000_000u64, "cpu_percent": 3.5, "game": { + "tps": 20.0, "mspt": { "average": 4.2 }, "max_players": 10, "paused": false, + "players": [{ "name": "Alex", "uuid": "u1", "ping": 12 }] } }, + "update": { "installed": "v1", "available": "v2", "busy": null, "last": "Not updated: x", "ok": false } + })); + assert_eq!(s.phase, "running"); + assert_eq!(s.players[0].name, "Alex"); + assert_eq!(s.players[0].ping, Some(12)); + assert_eq!( + (s.tps, s.mspt, s.max_players), + (Some(20.0), Some(4.2), Some(10)) + ); + assert_eq!(s.update_available.as_deref(), Some("v2")); + assert_eq!(s.update_last, Some(("Not updated: x".into(), false))); + assert!(!Status::stopped().running()); +} + +/// The control API: the token goes with every call, and errors come back as the server words them. +#[test] +fn the_api_sends_the_token() { + let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap(); + let address = listener.local_addr().unwrap().to_string(); + let server = std::thread::spawn(move || { + let mut seen = Vec::new(); + for reply in [ + r#"{"phase":"running","sample":{"game":{"players":[]}}}"#, + r#"{"error":"the game didn't answer"}"#, + ] { + let (stream, _) = listener.accept().unwrap(); + let mut reader = BufReader::new(stream.try_clone().unwrap()); + let mut head = String::new(); + loop { + let mut line = String::new(); + reader.read_line(&mut line).unwrap(); + if line == "\r\n" || line.is_empty() { + break; + } + head.push_str(&line); + } + // Read the body too: closing with it unread would reset the connection. + let length = head + .lines() + .find_map(|l| { + l.to_ascii_lowercase() + .strip_prefix("content-length:") + .map(|n| n.trim().parse::().unwrap()) + }) + .unwrap_or(0); + let mut body = vec![0; length]; + std::io::Read::read_exact(&mut reader, &mut body).unwrap(); + seen.push(head); + let code = if reply.contains("error") { + "409 Conflict" + } else { + "200 OK" + }; + let mut stream = stream; + write!( + stream, + "HTTP/1.1 {code}\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{reply}", + reply.len() + ) + .unwrap(); + } + seen + }); + let dir = scratch("api"); + fs::create_dir_all(dir.join(".horizon")).unwrap(); + fs::write( + dir.join(".horizon/api.json"), + json!({ "address": address, "token": "t0k", "pid": 1 }).to_string(), + ) + .unwrap(); + assert_eq!(status(&dir).phase, "running"); + let api = Api::open(&dir).unwrap(); + assert_eq!( + api.command("list").unwrap_err(), + "the game didn't answer".to_string() + ); + let seen = server.join().unwrap(); + assert!( + seen[0].starts_with("GET /api/v1/status HTTP/1.1"), + "{}", + seen[0] + ); + assert!(seen + .iter() + .all(|h| h.to_ascii_lowercase().contains("authorization: bearer t0k"))); + assert!(seen[1].starts_with("POST /api/v1/command")); + fs::remove_dir_all(&dir).unwrap(); + // Nothing answers: stopped. + assert_eq!(status(Path::new("/nonexistent")).phase, "stopped"); +}