Merge remote-tracking branch 'origin/main' into feat/server-bench-paper-fabric
# Conflicts: # docs/server.md
This commit is contained in:
Generated
+2
@@ -1563,8 +1563,10 @@ dependencies = [
|
||||
"libc",
|
||||
"serde",
|
||||
"serde_json",
|
||||
"sha2",
|
||||
"toml",
|
||||
"toml_edit",
|
||||
"ureq",
|
||||
"windows-sys 0.61.2",
|
||||
"zip",
|
||||
]
|
||||
|
||||
@@ -43,6 +43,8 @@ Horizon is downloaded only through **the Horizon launcher**: get it from [playho
|
||||
|
||||
**You need** Minecraft: Java Edition installed with the official launcher, with 26.3 played once; Python 3.10 or newer and Java 25 (a JDK, e.g. Eclipse Temurin 25) for the one-time resource preparation; and a GPU with Vulkan on Linux and Windows, or any Apple Silicon Mac.
|
||||
|
||||
**Host a server:** `horizon-server` is one native program with no Java, one settings file, a command line, a web panel, backups and updates that roll back by themselves. It installs with one command (`curl -fsSL https://raw.githubusercontent.com/ludovic111/horizon/main/packaging/server/install.sh | sh` on Linux and macOS, `irm https://raw.githubusercontent.com/ludovic111/horizon/main/packaging/server/install.ps1 | iex` on Windows). The guide is at [playhorizon.dev/server](https://playhorizon.dev/server) ([docs/hosting.md](docs/hosting.md)).
|
||||
|
||||
### The launcher
|
||||
|
||||
<table>
|
||||
|
||||
@@ -17,6 +17,10 @@ serde_json = "1"
|
||||
toml = "1.1"
|
||||
# Edits server.toml in place, keeping the owner's comments and order.
|
||||
toml_edit = "0.25"
|
||||
# Updates: the release from GitHub, checked against the SHA-256 GitHub publishes (both already in the
|
||||
# lockfile, ureq through horizon-server-files).
|
||||
sha2 = "0.10"
|
||||
ureq = { version = "2", default-features = false, features = ["tls"] }
|
||||
# Backups: one zip anyone can open, Windows included.
|
||||
zip = { version = "2", default-features = false, features = ["deflate"] }
|
||||
|
||||
|
||||
@@ -21,6 +21,11 @@
|
||||
</div>
|
||||
</header>
|
||||
|
||||
<p id="update" class="notice" role="status" hidden>
|
||||
<span id="update-text"></span>
|
||||
<button id="update-button" type="button" hidden>Update</button>
|
||||
</p>
|
||||
|
||||
<main id="app" hidden>
|
||||
<section class="charts" aria-label="Last 10 minutes">
|
||||
<figure><figcaption>TPS <b id="tps-now">–</b></figcaption><canvas id="tps" width="320" height="96"></canvas></figure>
|
||||
|
||||
@@ -126,3 +126,17 @@ code { font-family: var(--mono); font-size: 13px; }
|
||||
border-radius: var(--radius);
|
||||
max-width: 90vw;
|
||||
}
|
||||
|
||||
.notice {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
gap: 12px;
|
||||
margin: 16px max(24px, calc((100% - 1152px) / 2)) 0;
|
||||
padding: 10px 14px;
|
||||
border-radius: var(--radius);
|
||||
background: var(--plate-soft);
|
||||
border: 1px solid var(--rule);
|
||||
}
|
||||
.notice.failed {
|
||||
color: var(--danger);
|
||||
}
|
||||
|
||||
@@ -87,6 +87,7 @@ function renderStatus(status) {
|
||||
const parts = [`up ${duration(status.engine_uptime_seconds)}`, `horizon-server ${status.version}`];
|
||||
if (status.crashes) parts.push(`${status.crashes} crash${status.crashes > 1 ? "es" : ""}`);
|
||||
$("summary").textContent = parts.join(" · ");
|
||||
renderUpdate(status.update);
|
||||
|
||||
const players = (game && game.players) || [];
|
||||
$("player-count").textContent = game ? `${players.length} of ${game.max_players}` : "";
|
||||
@@ -108,6 +109,20 @@ function renderStatus(status) {
|
||||
);
|
||||
}
|
||||
|
||||
// Updates (horizon-server update): a newer release, one under way, or how the last one ended.
|
||||
function renderUpdate(update) {
|
||||
const box = $("update");
|
||||
const offer = update && !update.busy && update.available;
|
||||
let text = "";
|
||||
if (update && update.busy) text = `Updating: ${update.busy}…`;
|
||||
else if (offer) text = `Horizon ${update.available} is out (this server runs ${update.installed}).`;
|
||||
else if (update && update.last && !update.ok) text = update.last;
|
||||
box.hidden = !text;
|
||||
box.className = update && update.last && !update.ok && !update.busy && !offer ? "notice failed" : "notice";
|
||||
$("update-text").textContent = text;
|
||||
$("update-button").hidden = !offer;
|
||||
}
|
||||
|
||||
function renderBackups(list) {
|
||||
const key = JSON.stringify(list);
|
||||
if (key === backupsShown) return;
|
||||
@@ -255,6 +270,12 @@ function setUp() {
|
||||
toast(e.message);
|
||||
}
|
||||
});
|
||||
$("update-button").addEventListener("click", async () => {
|
||||
const update = lastStatus && lastStatus.update;
|
||||
if (!update || !update.available) return;
|
||||
if (!confirm(`Update to ${update.available}? The world is backed up, then the game restarts on it (players are disconnected for a moment). If it doesn't come up, the server goes back to ${update.installed} by itself.`)) return;
|
||||
await api("POST", "/api/v1/update", {}).then(() => toast("Updating…"), (e) => toast(e.message));
|
||||
});
|
||||
$("restart").addEventListener("click", async () => {
|
||||
if (!confirm("Restart the game? Players are disconnected for a moment.")) return;
|
||||
await api("POST", "/api/v1/restart").then(() => toast("Restarting…"), (e) => toast(e.message));
|
||||
|
||||
@@ -9,6 +9,9 @@
|
||||
//! - `GET /api/v1/metrics?since=T`: the samples taken after T (seconds since 1970), up to 10 minutes.
|
||||
//! - `GET /api/v1/backups`; `POST /api/v1/backups {"name": "..."}` backs up now; `POST /api/v1/restore
|
||||
//! {"name": "..."}` restarts the game with that backup's world.
|
||||
//! - `POST /api/v1/update {"tag": "...", "timeout": seconds}`: restarts the game on that installed release,
|
||||
//! and goes back to the one in use if it isn't up within the timeout; without a tag, downloads the newest
|
||||
//! release first (update.rs). `GET /api/v1/status` says how it went (`update`).
|
||||
//! - `POST /api/v1/panel/login`: a one-time login link for the web panel (with the token only).
|
||||
|
||||
use crate::{
|
||||
@@ -17,6 +20,7 @@ use crate::{
|
||||
engine,
|
||||
http::{self, Request, Response},
|
||||
panel,
|
||||
update::{self, Install},
|
||||
};
|
||||
use serde_json::{Value, json};
|
||||
use std::{
|
||||
@@ -91,6 +95,25 @@ impl Log {
|
||||
}
|
||||
}
|
||||
|
||||
/// How long a game started on another release has to come up before the switch is undone.
|
||||
pub const UPDATE_TIMEOUT: Duration = Duration::from_secs(300);
|
||||
|
||||
/// Updates and rollbacks (update.rs): what the check found, what is under way, how the last one ended.
|
||||
#[derive(Default)]
|
||||
pub struct Updates {
|
||||
/// A release newer than the one in use, from the last check.
|
||||
pub available: Option<String>,
|
||||
/// What is happening now, or nothing.
|
||||
pub busy: Option<String>,
|
||||
/// How the last update or rollback ended, and whether it went well.
|
||||
pub last: Option<String>,
|
||||
pub ok: bool,
|
||||
/// Counts the updates that ended, so a client can wait for the one it asked for.
|
||||
pub finished: u64,
|
||||
/// The release to restart the game on, and how long it has to come up.
|
||||
pub pending: Option<(String, Duration)>,
|
||||
}
|
||||
|
||||
/// What the supervisor and the API threads share.
|
||||
pub struct Shared {
|
||||
pub dir: PathBuf,
|
||||
@@ -107,10 +130,17 @@ pub struct Shared {
|
||||
pub metrics: Mutex<VecDeque<Value>>,
|
||||
/// The panel's address, login links and sessions.
|
||||
pub panel: Mutex<panel::Auth>,
|
||||
/// The installer's folder this program runs from (none for a build of your own: no updates).
|
||||
pub install: Option<Install>,
|
||||
pub update: Mutex<Updates>,
|
||||
}
|
||||
|
||||
impl Shared {
|
||||
pub fn new(dir: &Path) -> Arc<Self> {
|
||||
Self::with_install(dir, Install::find())
|
||||
}
|
||||
|
||||
pub fn with_install(dir: &Path, install: Option<Install>) -> Arc<Self> {
|
||||
Arc::new(Self {
|
||||
dir: dir.to_owned(),
|
||||
state: Mutex::new(State {
|
||||
@@ -129,8 +159,85 @@ impl Shared {
|
||||
started: Instant::now(),
|
||||
metrics: Mutex::new(VecDeque::new()),
|
||||
panel: Mutex::new(panel::Auth::default()),
|
||||
install,
|
||||
update: Mutex::new(Updates::default()),
|
||||
})
|
||||
}
|
||||
|
||||
/// Ends an update or rollback: its outcome, in the log and in `status`.
|
||||
pub fn finish_update(&self, ok: bool, message: String) {
|
||||
{
|
||||
let mut update = self.update.lock().unwrap();
|
||||
update.busy = None;
|
||||
update.ok = ok;
|
||||
update.finished += 1;
|
||||
if ok {
|
||||
update.available = None;
|
||||
}
|
||||
update.last = Some(message.clone());
|
||||
}
|
||||
crate::supervisor::note(self, if ok { "INFO" } else { "ERROR" }, &message);
|
||||
}
|
||||
|
||||
/// Asks for a restart on the installed release `tag` (the supervisor switches when the game stops).
|
||||
fn switch_to(&self, tag: String, timeout: Duration) {
|
||||
self.update.lock().unwrap().busy = Some(format!("Restarting the game on {tag}"));
|
||||
self.update.lock().unwrap().pending = Some((tag, timeout));
|
||||
self.restart.store(true, Ordering::SeqCst);
|
||||
}
|
||||
|
||||
/// `POST /api/v1/update`: switches to `tag`, or downloads the newest release first.
|
||||
fn start_update(
|
||||
self: &Arc<Self>,
|
||||
tag: Option<String>,
|
||||
timeout: Duration,
|
||||
) -> Result<(), String> {
|
||||
let install = self.install.clone().ok_or(
|
||||
"this horizon-server wasn't installed by install.sh or install.ps1: no updates",
|
||||
)?;
|
||||
{
|
||||
let mut update = self.update.lock().unwrap();
|
||||
if let Some(busy) = &update.busy {
|
||||
return Err(format!("an update is under way: {busy}"));
|
||||
}
|
||||
update.busy = Some("Looking for the newest release".into());
|
||||
}
|
||||
if let Some(tag) = tag {
|
||||
if !install.release(&tag).is_dir() || tag.contains(['/', '\\']) {
|
||||
self.update.lock().unwrap().busy = None;
|
||||
return Err(format!(
|
||||
"{tag} isn't installed (`horizon-server update` downloads it)"
|
||||
));
|
||||
}
|
||||
self.switch_to(tag, timeout);
|
||||
return Ok(());
|
||||
}
|
||||
let shared = self.clone();
|
||||
std::thread::Builder::new()
|
||||
.name("update".into())
|
||||
.spawn(move || {
|
||||
let fetched = (|| {
|
||||
let current = install.current().unwrap_or_default();
|
||||
let release = update::release(None)?;
|
||||
if !update::newer(&release.tag, ¤t) {
|
||||
return Ok(None);
|
||||
}
|
||||
shared.update.lock().unwrap().busy =
|
||||
Some(format!("Downloading {} ({})", release.tag, release.asset));
|
||||
let archive = update::download(&install, &release)?;
|
||||
let unpacked = update::unpack(&install, &archive, &release.tag);
|
||||
let _ = std::fs::remove_file(&archive);
|
||||
unpacked.map(|_| Some(release.tag))
|
||||
})();
|
||||
match fetched {
|
||||
Ok(Some(tag)) => shared.switch_to(tag, timeout),
|
||||
Ok(None) => shared.finish_update(true, "Already on the newest release".into()),
|
||||
Err(e) => shared.finish_update(false, format!("Not updated: {e}")),
|
||||
}
|
||||
})
|
||||
.map_err(|e| e.to_string())?;
|
||||
Ok(())
|
||||
}
|
||||
/// Keeps one sample for the graphs.
|
||||
pub fn record(&self, sample: Value) {
|
||||
let mut metrics = self.metrics.lock().unwrap();
|
||||
@@ -187,6 +294,23 @@ fn status(shared: &Shared) -> Value {
|
||||
"crashes": state.crashes,
|
||||
"last_crash": state.last_crash,
|
||||
"sample": state.sample,
|
||||
"update": updates(shared),
|
||||
})
|
||||
}
|
||||
|
||||
fn updates(shared: &Shared) -> Value {
|
||||
let Some(install) = &shared.install else {
|
||||
return Value::Null;
|
||||
};
|
||||
let update = shared.update.lock().unwrap();
|
||||
json!({
|
||||
"installed": install.current(),
|
||||
"previous": install.previous(),
|
||||
"available": update.available,
|
||||
"busy": update.busy,
|
||||
"last": update.last,
|
||||
"ok": update.ok,
|
||||
"finished": update.finished,
|
||||
})
|
||||
}
|
||||
|
||||
@@ -273,7 +397,7 @@ pub fn start(shared: Arc<Shared>) -> Result<Endpoint, String> {
|
||||
}
|
||||
|
||||
/// The API's routes, for the CLI (with the token) and the panel (with a session).
|
||||
pub fn route(shared: &Shared, request: &Request) -> Response {
|
||||
pub fn route(shared: &Arc<Shared>, request: &Request) -> Response {
|
||||
match (request.method.as_str(), request.path.as_str()) {
|
||||
("GET", "/api/v1/status") => Response::json(200, &status(shared)),
|
||||
("GET", "/api/v1/metrics") => {
|
||||
@@ -354,10 +478,21 @@ pub fn route(shared: &Shared, request: &Request) -> Response {
|
||||
Err(e) => Response::error(404, &e),
|
||||
}
|
||||
}
|
||||
("POST", "/api/v1/update") => {
|
||||
let body: Value = serde_json::from_slice(&request.body).unwrap_or(Value::Null);
|
||||
let timeout = body["timeout"]
|
||||
.as_u64()
|
||||
.map_or(UPDATE_TIMEOUT, Duration::from_secs);
|
||||
match shared.start_update(body["tag"].as_str().map(str::to_owned), timeout) {
|
||||
Ok(()) => Response::json(200, &json!({ "ok": true })),
|
||||
Err(e) => Response::error(409, &e),
|
||||
}
|
||||
}
|
||||
(
|
||||
_,
|
||||
"/api/v1/status" | "/api/v1/logs" | "/api/v1/command" | "/api/v1/stop"
|
||||
| "/api/v1/restart" | "/api/v1/backups" | "/api/v1/restore" | "/api/v1/metrics",
|
||||
| "/api/v1/restart" | "/api/v1/backups" | "/api/v1/restore" | "/api/v1/metrics"
|
||||
| "/api/v1/update",
|
||||
) => Response::error(405, "wrong method"),
|
||||
_ => Response::error(404, "no such endpoint"),
|
||||
}
|
||||
|
||||
@@ -251,6 +251,15 @@ fn describe(status: &Value) -> String {
|
||||
if !usage.is_empty() {
|
||||
out += &format!("{}\n", usage.join(", "));
|
||||
}
|
||||
let update = &status["update"];
|
||||
if let Some(busy) = update["busy"].as_str() {
|
||||
out += &format!("Updating: {busy}\n");
|
||||
} else if let Some(tag) = update["available"].as_str() {
|
||||
out += &format!(
|
||||
"Horizon {tag} is out (this server runs {}): `horizon-server update` installs it\n",
|
||||
update["installed"].as_str().unwrap_or("?")
|
||||
);
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
@@ -429,5 +438,18 @@ mod tests {
|
||||
describe(&json!({ "phase": "starting", "uptime_seconds": 4 })),
|
||||
"Starting, up 4 s\n"
|
||||
);
|
||||
assert_eq!(
|
||||
describe(&json!({
|
||||
"phase": "running",
|
||||
"update": { "installed": "v2026.10.18", "available": "v2026.10.19" }
|
||||
})),
|
||||
"Running\nHorizon v2026.10.19 is out (this server runs v2026.10.18): `horizon-server update` installs it\n"
|
||||
);
|
||||
assert_eq!(
|
||||
describe(
|
||||
&json!({ "phase": "restarting", "update": { "busy": "Starting the game on v2" } })
|
||||
),
|
||||
"Restarting\nUpdating: Starting the game on v2\n"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -20,8 +20,18 @@ fn exe(name: &str) -> String {
|
||||
format!("{name}{}", std::env::consts::EXE_SUFFIX)
|
||||
}
|
||||
|
||||
/// The game program: `engine.path`, else one installed beside `horizon-server`, else one on the PATH.
|
||||
/// The game program: `engine.path`, else one installed beside `horizon-server` (in the release in use when
|
||||
/// it was installed by the installers), else one on the PATH.
|
||||
pub fn program(config: &Config, dir: &Path) -> Result<PathBuf, String> {
|
||||
program_in(config, dir, crate::update::Install::find().as_ref())
|
||||
}
|
||||
|
||||
/// [`program`], for the install `install`.
|
||||
pub fn program_in(
|
||||
config: &Config,
|
||||
dir: &Path,
|
||||
install: Option<&crate::update::Install>,
|
||||
) -> Result<PathBuf, String> {
|
||||
if !config.engine.path.is_empty() {
|
||||
let path = dir.join(&config.engine.path);
|
||||
return path
|
||||
@@ -29,9 +39,12 @@ pub fn program(config: &Config, dir: &Path) -> Result<PathBuf, String> {
|
||||
.then_some(path)
|
||||
.ok_or_else(|| format!("engine.path {} is not a file", config.engine.path));
|
||||
}
|
||||
let beside = std::env::current_exe()
|
||||
.ok()
|
||||
.and_then(|e| e.parent().map(Path::to_path_buf));
|
||||
// Installed: the release `current` points at now, so a switch applies at the next start.
|
||||
let beside = install.map(crate::update::Install::programs).or_else(|| {
|
||||
std::env::current_exe()
|
||||
.ok()
|
||||
.and_then(|e| e.parent().map(Path::to_path_buf))
|
||||
});
|
||||
let path_dirs = std::env::var_os("PATH")
|
||||
.map(|p| std::env::split_paths(&p).collect::<Vec<_>>())
|
||||
.unwrap_or_default();
|
||||
@@ -141,14 +154,18 @@ pub fn resources(config: &Config, dir: &Path, program: Option<&Path>) -> Result<
|
||||
/// Starts the engine in the server folder, with its console and log piped to the supervisor and its status
|
||||
/// on the control endpoint.
|
||||
pub fn spawn(program: &Path, resources: &Path, dir: &Path) -> std::io::Result<Child> {
|
||||
// The game runs in the server folder, so a folder given relative to ours (`--dir srv`) would put its
|
||||
// control endpoint in `srv/srv/.horizon`, which doesn't exist.
|
||||
let dir = std::path::absolute(dir)?;
|
||||
let resources = std::path::absolute(resources)?;
|
||||
let mut command = Command::new(program);
|
||||
command
|
||||
.arg("--resources")
|
||||
.arg(resources)
|
||||
.arg("--control-socket")
|
||||
.arg(control_path(dir))
|
||||
.arg(control_path(&dir))
|
||||
.args(["--dedicated", "--nogui"])
|
||||
.current_dir(dir)
|
||||
.current_dir(&dir)
|
||||
.env("HORIZON_NO_AUDIO", "1")
|
||||
.stdin(Stdio::piped())
|
||||
.stdout(Stdio::piped())
|
||||
@@ -276,6 +293,38 @@ mod tests {
|
||||
);
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn a_relative_folder_reaches_the_game_whole() {
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
// Relative to this process's folder (the crate's, under cargo test), as `--dir srv` gives it.
|
||||
let root = PathBuf::from(format!("reldir-test-{}", std::process::id()));
|
||||
let server = root.join("srv");
|
||||
std::fs::create_dir_all(server.join(".horizon")).unwrap();
|
||||
std::fs::create_dir_all(root.join("res")).unwrap();
|
||||
// A game that checks, from its own folder, the folders it was given.
|
||||
let game = root.join("game");
|
||||
std::fs::write(
|
||||
&game,
|
||||
"#!/bin/sh\nwhile [ $# -gt 0 ]; do case \"$1\" in --resources) r=$2; shift;; \
|
||||
--control-socket) c=$2; shift;; esac; shift; done\n\
|
||||
[ -d \"$r\" ] && [ -d \"$(dirname \"$c\")\" ] && [ -f server.toml ]\n",
|
||||
)
|
||||
.unwrap();
|
||||
std::fs::set_permissions(&game, std::fs::Permissions::from_mode(0o755)).unwrap();
|
||||
std::fs::write(server.join("server.toml"), "").unwrap();
|
||||
let status = spawn(
|
||||
&std::path::absolute(&game).unwrap(),
|
||||
&root.join("res"),
|
||||
&server,
|
||||
)
|
||||
.unwrap()
|
||||
.wait();
|
||||
std::fs::remove_dir_all(&root).unwrap();
|
||||
let status = status.unwrap();
|
||||
assert!(status.success(), "{status}");
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn the_check_runs_the_program() {
|
||||
|
||||
@@ -13,6 +13,7 @@ mod panel;
|
||||
mod service;
|
||||
mod signals;
|
||||
mod supervisor;
|
||||
mod update;
|
||||
|
||||
use std::{path::PathBuf, process::ExitCode};
|
||||
|
||||
@@ -45,6 +46,11 @@ Usage: horizon-server [--dir DIR] <command>
|
||||
with sudo), a launchd agent on macOS, a task at logon on Windows
|
||||
panel A one-time login link for the web panel ([panel] in server.toml; 127.0.0.1:8130 by
|
||||
default)
|
||||
update [--check] [--version TAG] [--timeout SECONDS]
|
||||
Install the newest release (checked against GitHub's SHA-256), back up the world and
|
||||
restart on it; goes back by itself if the game isn't up within the timeout (300 s).
|
||||
--archive FILE --version NAME installs an archive you have
|
||||
rollback Back to the release used before the update
|
||||
import FILE Write server.toml from a vanilla server.properties
|
||||
op NAME, deop NAME
|
||||
whitelist on|off|list, whitelist add|remove NAME
|
||||
@@ -92,6 +98,8 @@ fn main() -> ExitCode {
|
||||
None => Err("restore needs a backup (`horizon-server backups` lists them)".into()),
|
||||
},
|
||||
Some("import") => import(&dir, &args[1..]),
|
||||
Some("update") => update::command(&dir, &args[1..]),
|
||||
Some("rollback") => update::rollback(&dir, &args[1..]),
|
||||
Some(command @ ("op" | "deop" | "whitelist")) => lists::run(&dir, command, &args[1..]),
|
||||
Some(other) => Err(format!(
|
||||
"unknown command {other}; `horizon-server help` lists them"
|
||||
|
||||
@@ -145,7 +145,7 @@ fn secure(response: Response) -> Response {
|
||||
.with("Referrer-Policy", "no-referrer")
|
||||
}
|
||||
|
||||
fn handle(shared: &Shared, address: SocketAddr, request: &Request) -> Response {
|
||||
fn handle(shared: &Arc<Shared>, address: SocketAddr, request: &Request) -> Response {
|
||||
if !request
|
||||
.header("host")
|
||||
.is_some_and(|h| host_allowed(h, address))
|
||||
|
||||
@@ -1,12 +1,13 @@
|
||||
//! `horizon-server run`: writes `server.properties` from `server.toml`, runs the engine with the console on
|
||||
//! stdin, serves the control API, stops the game cleanly on Ctrl-C, SIGTERM or `stop`, and restarts it when
|
||||
//! it crashes (docs/server.md, sections 2 and 7).
|
||||
//! it crashes (docs/server.md, sections 2 and 7). An update restarts the game on another release and goes
|
||||
//! back by itself when the new game doesn't come up.
|
||||
|
||||
use crate::{
|
||||
api::{self, Phase, Shared},
|
||||
backup, config,
|
||||
config::Config,
|
||||
engine, signals,
|
||||
engine, signals, update,
|
||||
};
|
||||
use serde_json::json;
|
||||
use std::{
|
||||
@@ -30,7 +31,7 @@ const STOP_TIMEOUT: Duration = Duration::from_secs(120);
|
||||
|
||||
/// A line from the supervisor, in the game's log format (`[HH:mm:ss] [thread/LEVEL]: message`, local time
|
||||
/// as the game's own lines), on stdout and in the log the API serves.
|
||||
fn note(shared: &Shared, level: &str, message: &str) {
|
||||
pub fn note(shared: &Shared, level: &str, message: &str) {
|
||||
let line = format!(
|
||||
"[{}] [Supervisor/{level}]: {message}",
|
||||
chrono::Local::now().format("%H:%M:%S")
|
||||
@@ -65,6 +66,20 @@ enum Exit {
|
||||
/// Asked to restart (`horizon-server restart`).
|
||||
Restart,
|
||||
Crashed(ExitStatus),
|
||||
/// Started on another release, the game wasn't up in time and was stopped.
|
||||
NotUp,
|
||||
}
|
||||
|
||||
/// A game started on another release that has yet to come up: what to go back to if it doesn't.
|
||||
struct Watch {
|
||||
from: String,
|
||||
to: String,
|
||||
/// The release `previous` named before the switch.
|
||||
previous: Option<String>,
|
||||
/// The backup of the world made just before the switch.
|
||||
backup: String,
|
||||
timeout: Duration,
|
||||
deadline: Instant,
|
||||
}
|
||||
|
||||
pub fn run(dir: &Path) -> Result<(), String> {
|
||||
@@ -97,11 +112,20 @@ pub fn run(dir: &Path) -> Result<(), String> {
|
||||
}
|
||||
sample(shared.clone());
|
||||
schedule_backups(shared.clone());
|
||||
check_updates(shared.clone());
|
||||
let console = console_lines();
|
||||
let mut crashes: Vec<Instant> = Vec::new();
|
||||
let mut watch: Option<Watch> = None;
|
||||
let (mut program, mut resources) = (program, resources);
|
||||
loop {
|
||||
// Read again before every start: edits to server.toml apply on the next restart.
|
||||
// Read again before every start: edits to server.toml apply on the next restart, and so does a
|
||||
// switch to another release.
|
||||
let config = Config::load(dir)?;
|
||||
if let Ok(found) = engine::program_in(&config, dir, shared.install.as_ref())
|
||||
&& let Ok(found_resources) = engine::resources(&config, dir, Some(&found))
|
||||
{
|
||||
(program, resources) = (found, found_resources);
|
||||
}
|
||||
let written = config
|
||||
.write_properties(dir)
|
||||
.map_err(|e| format!("server.properties: {e}"))?;
|
||||
@@ -122,7 +146,11 @@ pub fn run(dir: &Path) -> Result<(), String> {
|
||||
state.engine_pid = Some(child.id());
|
||||
state.engine_started = Some(Instant::now());
|
||||
}
|
||||
let exit = supervise(&shared, &mut child, &console);
|
||||
// The new release's time to come up starts with its game.
|
||||
if let Some(w) = &mut watch {
|
||||
w.deadline = Instant::now() + w.timeout;
|
||||
}
|
||||
let exit = supervise(&shared, &mut child, &console, &mut watch);
|
||||
{
|
||||
let mut state = shared.state.lock().unwrap();
|
||||
state.engine_pid = None;
|
||||
@@ -144,8 +172,25 @@ pub fn run(dir: &Path) -> Result<(), String> {
|
||||
&format!("Could not update server.toml: {e}"),
|
||||
),
|
||||
}
|
||||
// Started on another release, the game never came up: back to the release before.
|
||||
if let Some(w) = watch.take() {
|
||||
let reason = match &exit {
|
||||
Exit::Crashed(status) => format!("the game stopped ({status})"),
|
||||
Exit::NotUp => "the game wasn't up in time".into(),
|
||||
Exit::Stopped => "the game stopped before it was up".into(),
|
||||
Exit::Restart => "the game was restarted before it was up".into(),
|
||||
};
|
||||
roll_back(&shared, dir, &config, &w, &reason);
|
||||
if matches!(exit, Exit::Stopped)
|
||||
&& shared.state.lock().unwrap().phase == Phase::Stopping
|
||||
{
|
||||
return Ok(());
|
||||
}
|
||||
continue;
|
||||
}
|
||||
let status = match exit {
|
||||
Exit::Stopped => return Ok(()),
|
||||
Exit::NotUp => continue,
|
||||
Exit::Restart => {
|
||||
let restore = shared.restore.lock().unwrap().take();
|
||||
if let Some(name) = restore {
|
||||
@@ -162,6 +207,10 @@ pub fn run(dir: &Path) -> Result<(), String> {
|
||||
Err(e) => note(&shared, "ERROR", &format!("Could not restore {name}: {e}")),
|
||||
}
|
||||
}
|
||||
let pending = shared.update.lock().unwrap().pending.take();
|
||||
if let Some((to, timeout)) = pending {
|
||||
watch = switch(&shared, dir, &config, &to, timeout);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
Exit::Crashed(status) => status,
|
||||
@@ -206,6 +255,154 @@ pub fn run(dir: &Path) -> Result<(), String> {
|
||||
}
|
||||
}
|
||||
|
||||
/// With the game stopped: backs the world up, points `current` at the release `to` and checks that its game
|
||||
/// loads on this system. What to watch while it starts; `None` when it stayed on the release it was on.
|
||||
fn switch(
|
||||
shared: &Shared,
|
||||
dir: &Path,
|
||||
config: &Config,
|
||||
to: &str,
|
||||
timeout: Duration,
|
||||
) -> Option<Watch> {
|
||||
let Some(install) = shared.install.as_ref() else {
|
||||
shared.finish_update(
|
||||
false,
|
||||
"Not updated: this horizon-server wasn't installed".into(),
|
||||
);
|
||||
return None;
|
||||
};
|
||||
let Some(from) = install.current() else {
|
||||
shared.finish_update(false, "Not updated: `current` points at no release".into());
|
||||
return None;
|
||||
};
|
||||
let made = backup::file_name(std::time::SystemTime::now(), Some(&update::backup_name(to)))
|
||||
.and_then(|file| backup::create(dir, config, &file).map(|_| file));
|
||||
let backup = match made {
|
||||
Ok(file) => file,
|
||||
Err(e) => {
|
||||
shared.finish_update(false, format!("Stayed on {from}: the backup failed: {e}"));
|
||||
return None;
|
||||
}
|
||||
};
|
||||
note(
|
||||
shared,
|
||||
"INFO",
|
||||
&format!(
|
||||
"Backed up the world to {}/{backup}; switching from {from} to {to}",
|
||||
backup::DIR
|
||||
),
|
||||
);
|
||||
let previous = install.previous();
|
||||
if let Err(e) = install.switch(to) {
|
||||
shared.finish_update(false, format!("Stayed on {from}: {e}"));
|
||||
return None;
|
||||
}
|
||||
if let Err(e) =
|
||||
engine::program_in(config, dir, Some(install)).and_then(|p| engine::check_starts(&p))
|
||||
{
|
||||
let back = install
|
||||
.switch_back(&from, previous.as_deref())
|
||||
.err()
|
||||
.map_or(String::new(), |e| format!(" ({e})"));
|
||||
shared.finish_update(false, format!("Stayed on {from}{back}: {e}"));
|
||||
return None;
|
||||
}
|
||||
shared.update.lock().unwrap().busy = Some(format!("Starting the game on {to}"));
|
||||
Some(Watch {
|
||||
from,
|
||||
to: to.to_owned(),
|
||||
previous,
|
||||
backup,
|
||||
timeout,
|
||||
deadline: Instant::now() + timeout,
|
||||
})
|
||||
}
|
||||
|
||||
/// Undoes a switch whose game never came up: `current` back on the release before, and the world as it
|
||||
/// was just before the switch (the one the new game left is kept in backups/).
|
||||
fn roll_back(shared: &Shared, dir: &Path, config: &Config, w: &Watch, reason: &str) {
|
||||
note(
|
||||
shared,
|
||||
"ERROR",
|
||||
&format!(
|
||||
"The game on {} didn't come up ({reason}): going back to {}",
|
||||
w.to, w.from
|
||||
),
|
||||
);
|
||||
let Some(install) = shared.install.as_ref() else {
|
||||
return;
|
||||
};
|
||||
if let Err(e) = install.switch_back(&w.from, w.previous.as_deref()) {
|
||||
shared.finish_update(
|
||||
false,
|
||||
format!(
|
||||
"{} didn't come up ({reason}), and going back to {} failed: {e}",
|
||||
w.to, w.from
|
||||
),
|
||||
);
|
||||
return;
|
||||
}
|
||||
let world = match backup::restore(dir, config, &w.backup) {
|
||||
Ok(Some(old)) => format!(
|
||||
"; the world is back as it was before the switch (the one {} left is in {})",
|
||||
w.to,
|
||||
old.display()
|
||||
),
|
||||
Ok(None) => "; the world is back as it was before the switch".into(),
|
||||
Err(e) => format!("; the world couldn't be put back from {}: {e}", w.backup),
|
||||
};
|
||||
shared.finish_update(
|
||||
false,
|
||||
format!(
|
||||
"Rolled back to {}: {} didn't come up ({reason}){world}",
|
||||
w.from, w.to
|
||||
),
|
||||
);
|
||||
}
|
||||
|
||||
/// The game is up: it logged `Done` and answered a status request (the sampler's, for this process).
|
||||
fn up(shared: &Shared) -> bool {
|
||||
let state = shared.state.lock().unwrap();
|
||||
state.phase == Phase::Running
|
||||
&& state.engine_pid.is_some()
|
||||
&& state.sample["pid"].as_u64() == state.engine_pid.map(u64::from)
|
||||
&& !state.sample["game"].is_null()
|
||||
}
|
||||
|
||||
/// Looks for a newer release a minute after the start and then every 6 hours (installed servers only;
|
||||
/// `HORIZON_NO_UPDATE_CHECK=1` turns it off). It only tells: updating stays the owner's choice.
|
||||
fn check_updates(shared: Arc<Shared>) {
|
||||
let Some(install) = shared.install.clone() else {
|
||||
return;
|
||||
};
|
||||
if std::env::var_os("HORIZON_NO_UPDATE_CHECK").is_some_and(|v| !v.is_empty() && v != "0") {
|
||||
return;
|
||||
}
|
||||
let _ = thread::Builder::new()
|
||||
.name("update-check".into())
|
||||
.spawn(move || {
|
||||
thread::sleep(Duration::from_secs(60));
|
||||
loop {
|
||||
if let (Ok(release), Some(current)) = (update::release(None), install.current()) {
|
||||
let newer = update::newer(&release.tag, ¤t).then_some(release.tag);
|
||||
let told = shared.update.lock().unwrap().available.clone();
|
||||
if let Some(tag) = newer.as_ref().filter(|t| told.as_ref() != Some(*t)) {
|
||||
note(
|
||||
&shared,
|
||||
"INFO",
|
||||
&format!(
|
||||
"Horizon {tag} is out (this server runs {current}): `horizon-server update` \
|
||||
installs it, and goes back by itself if it doesn't start"
|
||||
),
|
||||
);
|
||||
}
|
||||
shared.update.lock().unwrap().available = newer;
|
||||
}
|
||||
thread::sleep(Duration::from_secs(6 * 3600));
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/// The wait before the restart that follows the `crashes`th recent crash.
|
||||
fn backoff(crashes: usize) -> Duration {
|
||||
let doublings = u32::try_from(crashes.saturating_sub(1))
|
||||
@@ -309,6 +506,7 @@ fn sample(shared: Arc<Shared>) {
|
||||
"players": game.as_ref().and_then(|g| g["players"].as_array().map(Vec::len)),
|
||||
}));
|
||||
shared.state.lock().unwrap().sample = json!({
|
||||
"pid": pid,
|
||||
"rss_bytes": rss,
|
||||
"cpu_percent": cpu_percent,
|
||||
"game": game,
|
||||
@@ -358,7 +556,12 @@ fn schedule_backups(shared: Arc<Shared>) {
|
||||
}
|
||||
|
||||
/// Runs one engine process to its end: console lines in, the log out, and a clean `stop` when asked.
|
||||
fn supervise(shared: &Arc<Shared>, child: &mut Child, console: &mpsc::Receiver<String>) -> Exit {
|
||||
fn supervise(
|
||||
shared: &Arc<Shared>,
|
||||
child: &mut Child,
|
||||
console: &mpsc::Receiver<String>,
|
||||
watch: &mut Option<Watch>,
|
||||
) -> Exit {
|
||||
if let Some(out) = child.stdout.take() {
|
||||
pump(shared, out, false);
|
||||
}
|
||||
@@ -368,8 +571,27 @@ fn supervise(shared: &Arc<Shared>, child: &mut Child, console: &mpsc::Receiver<S
|
||||
let mut stdin = child.stdin.take();
|
||||
let mut stopping: Option<Instant> = None;
|
||||
let mut restart = false;
|
||||
let mut not_up = false;
|
||||
let mut handled = signals::requests();
|
||||
loop {
|
||||
if let Some(w) = watch.as_ref() {
|
||||
if up(shared) {
|
||||
shared.finish_update(
|
||||
true,
|
||||
format!("Now on {} (was {}): the game is up", w.to, w.from),
|
||||
);
|
||||
*watch = None;
|
||||
} else if Instant::now() > w.deadline && stopping.is_none() {
|
||||
note(
|
||||
shared,
|
||||
"WARN",
|
||||
&format!("The game on {} isn't up in time: stopping it", w.to),
|
||||
);
|
||||
not_up = true;
|
||||
stopping = Some(Instant::now());
|
||||
let _ = child.kill();
|
||||
}
|
||||
}
|
||||
while let Ok(line) = console.try_recv() {
|
||||
let command = line.trim().trim_start_matches('/');
|
||||
if command == "stop" && stopping.is_none() {
|
||||
@@ -419,6 +641,7 @@ fn supervise(shared: &Arc<Shared>, child: &mut Child, console: &mpsc::Receiver<S
|
||||
stopping = Some(Instant::now());
|
||||
}
|
||||
match child.try_wait() {
|
||||
Ok(Some(_)) if not_up => return Exit::NotUp,
|
||||
Ok(Some(_)) if restart => return Exit::Restart,
|
||||
Ok(Some(status)) if stopping.is_some() || status.success() => return Exit::Stopped,
|
||||
Ok(Some(status)) => return Exit::Crashed(status),
|
||||
@@ -447,6 +670,142 @@ mod tests {
|
||||
assert_eq!(waits, [5, 10, 20, 40, 80, 160, 300, 300]);
|
||||
}
|
||||
|
||||
/// An install with releases whose game exits with `code` on `--help`, and a server folder with a world.
|
||||
#[cfg(unix)]
|
||||
fn installed(name: &str, releases: &[(&str, i32)]) -> (Arc<Shared>, std::path::PathBuf) {
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
let root =
|
||||
std::env::temp_dir().join(format!("horizon-server-sw-{name}-{}", std::process::id()));
|
||||
let _ = std::fs::remove_dir_all(&root);
|
||||
let root = {
|
||||
std::fs::create_dir_all(&root).unwrap();
|
||||
std::fs::canonicalize(&root).unwrap()
|
||||
};
|
||||
for (tag, code) in releases {
|
||||
let release = root.join("releases").join(tag);
|
||||
std::fs::create_dir_all(&release).unwrap();
|
||||
std::fs::write(release.join("horizon-server"), "").unwrap();
|
||||
let engine = release.join("horizon-engine");
|
||||
std::fs::write(&engine, format!("#!/bin/sh\nexit {code}\n")).unwrap();
|
||||
std::fs::set_permissions(&engine, std::fs::Permissions::from_mode(0o755)).unwrap();
|
||||
}
|
||||
std::os::unix::fs::symlink(
|
||||
root.join("releases").join(releases[0].0),
|
||||
root.join("current"),
|
||||
)
|
||||
.unwrap();
|
||||
let dir = root.join("server");
|
||||
std::fs::create_dir_all(dir.join("world")).unwrap();
|
||||
std::fs::write(dir.join("world/level.dat"), "before").unwrap();
|
||||
let install = update::Install { root };
|
||||
(Shared::with_install(&dir, Some(install)), dir)
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn a_switch_backs_up_then_rolls_back_world_and_release() {
|
||||
let (shared, dir) = installed("rollback", &[("v1", 0), ("v2", 0)]);
|
||||
let install = shared.install.clone().unwrap();
|
||||
let config = Config::default();
|
||||
let watch = switch(&shared, &dir, &config, "v2", Duration::from_secs(60)).unwrap();
|
||||
assert_eq!((watch.from.as_str(), watch.to.as_str()), ("v1", "v2"));
|
||||
assert!(watch.backup.ends_with("-before-v2.zip"), "{}", watch.backup);
|
||||
assert!(dir.join(backup::DIR).join(&watch.backup).is_file());
|
||||
assert_eq!(install.current().as_deref(), Some("v2"));
|
||||
assert_eq!(
|
||||
shared.update.lock().unwrap().busy.as_deref(),
|
||||
Some("Starting the game on v2")
|
||||
);
|
||||
// The new game wrote to the world, then never came up.
|
||||
std::fs::write(dir.join("world/level.dat"), "after").unwrap();
|
||||
roll_back(
|
||||
&shared,
|
||||
&dir,
|
||||
&config,
|
||||
&watch,
|
||||
"the game stopped (exit status: 1)",
|
||||
);
|
||||
assert_eq!(install.current().as_deref(), Some("v1"));
|
||||
// `rollback` won't go to the release that failed.
|
||||
assert_eq!(install.previous(), None);
|
||||
assert_eq!(
|
||||
std::fs::read_to_string(dir.join("world/level.dat")).unwrap(),
|
||||
"before"
|
||||
);
|
||||
let update = shared.update.lock().unwrap();
|
||||
assert!(!update.ok && update.busy.is_none() && update.finished == 1);
|
||||
let last = update.last.as_deref().unwrap();
|
||||
assert!(
|
||||
last.starts_with("Rolled back to v1: v2 didn't come up (the game stopped (exit status: 1)); the world is back"),
|
||||
"{last}"
|
||||
);
|
||||
// The world the new game left is kept.
|
||||
let kept = last.rsplit_once("is in ").unwrap().1.trim_end_matches(')');
|
||||
assert_eq!(
|
||||
std::fs::read_to_string(Path::new(kept).join("level.dat")).unwrap(),
|
||||
"after"
|
||||
);
|
||||
std::fs::remove_dir_all(&install.root).unwrap();
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn a_game_that_cant_load_is_never_switched_to() {
|
||||
let (shared, dir) = installed("unloadable", &[("v1", 0), ("v2", 127)]);
|
||||
let install = shared.install.clone().unwrap();
|
||||
assert!(
|
||||
switch(
|
||||
&shared,
|
||||
&dir,
|
||||
&Config::default(),
|
||||
"v2",
|
||||
Duration::from_secs(60)
|
||||
)
|
||||
.is_none()
|
||||
);
|
||||
assert_eq!(install.current().as_deref(), Some("v1"));
|
||||
let update = shared.update.lock().unwrap();
|
||||
assert!(!update.ok);
|
||||
assert!(
|
||||
update
|
||||
.last
|
||||
.as_deref()
|
||||
.unwrap()
|
||||
.starts_with("Stayed on v1: the game (")
|
||||
);
|
||||
std::fs::remove_dir_all(&install.root).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn up_means_done_and_a_status_reply_from_this_game() {
|
||||
let shared = Shared::with_install(Path::new("."), None);
|
||||
let set = |phase, pid: Option<u32>, sample: serde_json::Value| {
|
||||
let mut state = shared.state.lock().unwrap();
|
||||
(state.phase, state.engine_pid, state.sample) = (phase, pid, sample);
|
||||
};
|
||||
set(
|
||||
Phase::Starting,
|
||||
Some(7),
|
||||
json!({ "pid": 7, "game": { "tps": 20.0 } }),
|
||||
);
|
||||
assert!(!up(&shared));
|
||||
set(Phase::Running, Some(7), json!({ "pid": 7, "game": null }));
|
||||
assert!(!up(&shared));
|
||||
// A sample of the game before the restart doesn't count.
|
||||
set(
|
||||
Phase::Running,
|
||||
Some(8),
|
||||
json!({ "pid": 7, "game": { "tps": 20.0 } }),
|
||||
);
|
||||
assert!(!up(&shared));
|
||||
set(
|
||||
Phase::Running,
|
||||
Some(8),
|
||||
json!({ "pid": 8, "game": { "tps": 20.0 } }),
|
||||
);
|
||||
assert!(up(&shared));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn one_supervisor_per_folder() {
|
||||
let dir = std::env::temp_dir().join(format!("horizon-server-lock-{}", std::process::id()));
|
||||
|
||||
@@ -0,0 +1,763 @@
|
||||
//! Updates and rollbacks (docs/server.md, section 7) for a `horizon-server` installed by install.sh or
|
||||
//! install.ps1: each release in `<dir>/releases/<tag>`, `<dir>/current` pointing at the one in use, and
|
||||
//! `<dir>/previous` naming the one before it. An update downloads the newest release from GitHub, checks it
|
||||
//! against the SHA-256 GitHub publishes for it, unpacks it beside the others and switches `current`; the
|
||||
//! supervisor then restarts the game on it and switches back by itself if the new game doesn't come up.
|
||||
|
||||
use crate::{api::Client, backup, config::Config, engine, supervisor};
|
||||
use serde_json::{Value, json};
|
||||
use std::{
|
||||
io::Read,
|
||||
path::{Path, PathBuf},
|
||||
process::Command,
|
||||
time::{Duration, Instant},
|
||||
};
|
||||
|
||||
const REPO: &str = "ludovic111/horizon";
|
||||
/// The release archives for this computer, most specific first: on Linux the server build (no ALSA or
|
||||
/// udev), else the full game (releases before the server build).
|
||||
const ASSETS: &[&str] = if cfg!(all(target_os = "linux", target_arch = "x86_64")) {
|
||||
&[
|
||||
"horizon-server-linux-x86_64.tar.gz",
|
||||
"horizon-linux-x86_64.tar.gz",
|
||||
]
|
||||
} else if cfg!(all(target_os = "macos", target_arch = "aarch64")) {
|
||||
&["horizon-macos-arm64.zip"]
|
||||
} else if cfg!(all(target_os = "windows", target_arch = "x86_64")) {
|
||||
&["horizon-windows-x64.zip"]
|
||||
} else {
|
||||
&[]
|
||||
};
|
||||
|
||||
fn exe(name: &str) -> String {
|
||||
format!("{name}{}", std::env::consts::EXE_SUFFIX)
|
||||
}
|
||||
|
||||
/// The installer's folder: `releases/`, `current`, `previous` and `game-files/`.
|
||||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||
pub struct Install {
|
||||
pub root: PathBuf,
|
||||
}
|
||||
|
||||
impl Install {
|
||||
/// The install this program runs from, if it runs from one.
|
||||
pub fn find() -> Option<Self> {
|
||||
Self::around(&std::env::current_exe().ok()?)
|
||||
}
|
||||
|
||||
/// The install holding `program` (`<root>/releases/<tag>/horizon-server`, reached directly or through
|
||||
/// `current`).
|
||||
pub fn around(program: &Path) -> Option<Self> {
|
||||
let program = std::fs::canonicalize(program).ok()?;
|
||||
let releases = program.parent()?.parent()?;
|
||||
if releases.file_name()? != "releases" {
|
||||
return None;
|
||||
}
|
||||
let root = releases.parent()?.to_path_buf();
|
||||
root.join("current").is_dir().then_some(Self { root })
|
||||
}
|
||||
|
||||
/// The install, or why there is none to update.
|
||||
pub fn required() -> Result<Self, String> {
|
||||
Self::find().ok_or_else(|| {
|
||||
"this horizon-server wasn't installed by install.sh or install.ps1 (no releases/ and current \
|
||||
around it): update it the way you installed it"
|
||||
.into()
|
||||
})
|
||||
}
|
||||
|
||||
pub fn release(&self, tag: &str) -> PathBuf {
|
||||
self.root.join("releases").join(tag)
|
||||
}
|
||||
|
||||
/// Where the game programs in use are: `current`, so a switch applies at the next start.
|
||||
pub fn programs(&self) -> PathBuf {
|
||||
self.root.join("current")
|
||||
}
|
||||
|
||||
/// The release in use.
|
||||
pub fn current(&self) -> Option<String> {
|
||||
let target = std::fs::canonicalize(self.root.join("current")).ok()?;
|
||||
Some(target.file_name()?.to_string_lossy().into_owned())
|
||||
}
|
||||
|
||||
/// The release used before the current one, if it is still there.
|
||||
pub fn previous(&self) -> Option<String> {
|
||||
let tag = std::fs::read_to_string(self.root.join("previous")).ok()?;
|
||||
let tag = tag.trim();
|
||||
(!tag.is_empty() && self.release(tag).is_dir()).then(|| tag.to_owned())
|
||||
}
|
||||
|
||||
/// Points `current` at the release `tag`, and remembers the one it pointed at as `previous`.
|
||||
pub fn switch(&self, tag: &str) -> Result<(), String> {
|
||||
let target = self.release(tag);
|
||||
if !target.join(exe("horizon-server")).is_file() {
|
||||
return Err(format!("{} holds no horizon-server", target.display()));
|
||||
}
|
||||
if let Some(old) = self.current().filter(|old| old != tag) {
|
||||
std::fs::write(self.root.join("previous"), format!("{old}\n"))
|
||||
.map_err(|e| format!("{}: {e}", self.root.join("previous").display()))?;
|
||||
}
|
||||
point(&self.root.join("current"), &target)
|
||||
.map_err(|e| format!("switching current to {tag}: {e}"))
|
||||
}
|
||||
|
||||
/// Undoes a [`Install::switch`]: `current` back on `from` and `previous` as it was before, so a later
|
||||
/// rollback doesn't go to the release that failed.
|
||||
pub fn switch_back(&self, from: &str, previous: Option<&str>) -> Result<(), String> {
|
||||
point(&self.root.join("current"), &self.release(from))
|
||||
.map_err(|e| format!("switching current back to {from}: {e}"))?;
|
||||
let file = self.root.join("previous");
|
||||
match previous {
|
||||
Some(tag) => std::fs::write(&file, format!("{tag}\n")),
|
||||
None => std::fs::remove_file(&file).or_else(|e| {
|
||||
if e.kind() == std::io::ErrorKind::NotFound {
|
||||
Ok(())
|
||||
} else {
|
||||
Err(e)
|
||||
}
|
||||
}),
|
||||
}
|
||||
.map_err(|e| format!("{}: {e}", file.display()))
|
||||
}
|
||||
}
|
||||
|
||||
/// Makes `link` point at the folder `target`, replacing what it pointed at.
|
||||
#[cfg(unix)]
|
||||
fn point(link: &Path, target: &Path) -> std::io::Result<()> {
|
||||
// A new link renamed over the old one: `current` always points at a whole release.
|
||||
let fresh = link.with_extension("switching");
|
||||
let _ = std::fs::remove_file(&fresh);
|
||||
std::os::unix::fs::symlink(target, &fresh)?;
|
||||
std::fs::rename(&fresh, link)
|
||||
}
|
||||
|
||||
/// Makes `link` a junction to `target` (install.ps1's links: they need no admin rights).
|
||||
#[cfg(windows)]
|
||||
fn point(link: &Path, target: &Path) -> std::io::Result<()> {
|
||||
if link.exists() || link.symlink_metadata().is_ok() {
|
||||
std::fs::remove_dir(link)?;
|
||||
}
|
||||
let status = Command::new("cmd")
|
||||
.arg("/C")
|
||||
.arg("mklink")
|
||||
.arg("/J")
|
||||
.arg(link)
|
||||
.arg(target)
|
||||
.stdout(std::process::Stdio::null())
|
||||
.status()?;
|
||||
if status.success() {
|
||||
Ok(())
|
||||
} else {
|
||||
Err(std::io::Error::other(format!(
|
||||
"mklink /J failed ({status})"
|
||||
)))
|
||||
}
|
||||
}
|
||||
|
||||
/// A release on GitHub: its tag and the archive for this computer.
|
||||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||
pub struct Release {
|
||||
pub tag: String,
|
||||
pub asset: String,
|
||||
pub url: String,
|
||||
pub sha256: String,
|
||||
}
|
||||
|
||||
/// The newest release (or `tag`), from GitHub's API.
|
||||
pub fn release(tag: Option<&str>) -> Result<Release, String> {
|
||||
let url = match tag {
|
||||
Some(tag) => format!("https://api.github.com/repos/{REPO}/releases/tags/{tag}"),
|
||||
None => format!("https://api.github.com/repos/{REPO}/releases/latest"),
|
||||
};
|
||||
let text = ureq::get(&url)
|
||||
.set("Accept", "application/vnd.github+json")
|
||||
.set("User-Agent", "horizon-server")
|
||||
.call()
|
||||
.map_err(|e| match e {
|
||||
ureq::Error::Status(404, _) => format!("no release {} on GitHub", tag.unwrap_or("")),
|
||||
e => format!("GitHub didn't answer: {e}"),
|
||||
})?
|
||||
.into_string()
|
||||
.map_err(|e| format!("GitHub's answer: {e}"))?;
|
||||
pick(&serde_json::from_str(&text).map_err(|e| format!("GitHub's answer: {e}"))?)
|
||||
}
|
||||
|
||||
/// The archive for this computer in a release's JSON, with the SHA-256 GitHub publishes for it.
|
||||
fn pick(release: &Value) -> Result<Release, String> {
|
||||
let tag = release["tag_name"]
|
||||
.as_str()
|
||||
.ok_or("GitHub's answer has no tag")?;
|
||||
let assets = release["assets"].as_array().cloned().unwrap_or_default();
|
||||
let asset = ASSETS
|
||||
.iter()
|
||||
.find_map(|name| assets.iter().find(|a| a["name"] == *name))
|
||||
.ok_or_else(|| {
|
||||
format!(
|
||||
"release {tag} has no archive for this computer ({})",
|
||||
ASSETS.join(", ")
|
||||
)
|
||||
})?;
|
||||
let name = asset["name"].as_str().unwrap_or_default();
|
||||
let sha256 = asset["digest"]
|
||||
.as_str()
|
||||
.and_then(|d| d.strip_prefix("sha256:"))
|
||||
.ok_or_else(|| format!("release {tag} publishes no SHA-256 for {name}"))?;
|
||||
Ok(Release {
|
||||
tag: tag.to_owned(),
|
||||
asset: name.to_owned(),
|
||||
url: asset["browser_download_url"]
|
||||
.as_str()
|
||||
.unwrap_or_default()
|
||||
.to_owned(),
|
||||
sha256: sha256.to_ascii_lowercase(),
|
||||
})
|
||||
}
|
||||
|
||||
/// Whether the release `tag` is newer than `than`: releases are tagged `vYYYY.MM.DD[.N]`, compared
|
||||
/// number by number. A tag that isn't one (an archive installed by hand) is never older than a release.
|
||||
pub fn newer(tag: &str, than: &str) -> bool {
|
||||
let numbers = |t: &str| -> Option<Vec<u64>> {
|
||||
t.strip_prefix('v')?
|
||||
.split('.')
|
||||
.map(|n| n.parse().ok())
|
||||
.collect()
|
||||
};
|
||||
match (numbers(tag), numbers(than)) {
|
||||
(Some(a), Some(b)) => a > b,
|
||||
(Some(_), None) => true,
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
||||
/// Downloads a release's archive into `<root>/downloads/` and checks its SHA-256; the archive's path.
|
||||
pub fn download(install: &Install, release: &Release) -> Result<PathBuf, String> {
|
||||
use sha2::Digest;
|
||||
let folder = install.root.join("downloads");
|
||||
std::fs::create_dir_all(&folder).map_err(|e| format!("{}: {e}", folder.display()))?;
|
||||
let path = folder.join(&release.asset);
|
||||
let part = folder.join(format!("{}.part", release.asset));
|
||||
let result = (|| {
|
||||
let mut reader = ureq::get(&release.url)
|
||||
.set("User-Agent", "horizon-server")
|
||||
.call()
|
||||
.map_err(|e| format!("downloading {}: {e}", release.asset))?
|
||||
.into_reader();
|
||||
let mut file =
|
||||
std::fs::File::create(&part).map_err(|e| format!("{}: {e}", part.display()))?;
|
||||
let mut hasher = sha2::Sha256::new();
|
||||
let mut buffer = vec![0; 1 << 16];
|
||||
loop {
|
||||
let n = reader
|
||||
.read(&mut buffer)
|
||||
.map_err(|e| format!("downloading {}: {e}", release.asset))?;
|
||||
if n == 0 {
|
||||
break;
|
||||
}
|
||||
hasher.update(&buffer[..n]);
|
||||
std::io::Write::write_all(&mut file, &buffer[..n]).map_err(|e| e.to_string())?;
|
||||
}
|
||||
let got: String = hasher
|
||||
.finalize()
|
||||
.iter()
|
||||
.map(|b| format!("{b:02x}"))
|
||||
.collect();
|
||||
if got != release.sha256 {
|
||||
return Err(format!(
|
||||
"{} doesn't match its SHA-256 (got {got}, expected {}): not installed",
|
||||
release.asset, release.sha256
|
||||
));
|
||||
}
|
||||
std::fs::rename(&part, &path).map_err(|e| e.to_string())
|
||||
})();
|
||||
if result.is_err() {
|
||||
let _ = std::fs::remove_file(&part);
|
||||
}
|
||||
result.map(|()| path)
|
||||
}
|
||||
|
||||
/// Unpacks a release archive into `<root>/releases/<tag>`, with its `.local/horizon-client` linked to the
|
||||
/// install's prepared game files (which updates keep), as the installers do. It doesn't switch to it.
|
||||
pub fn unpack(install: &Install, archive: &Path, tag: &str) -> Result<PathBuf, String> {
|
||||
if tag.is_empty() || tag.contains(['/', '\\']) || tag.starts_with('.') {
|
||||
return Err(format!("{tag:?} isn't a release name"));
|
||||
}
|
||||
let target = install.release(tag);
|
||||
if install.current().as_deref() == Some(tag) {
|
||||
return Err(format!("{tag} is the release in use"));
|
||||
}
|
||||
let scratch = install
|
||||
.root
|
||||
.join("releases")
|
||||
.join(format!(".{tag}.unpacking"));
|
||||
let _ = std::fs::remove_dir_all(&scratch);
|
||||
std::fs::create_dir_all(&scratch).map_err(|e| format!("{}: {e}", scratch.display()))?;
|
||||
let result = (|| {
|
||||
let name = archive.to_string_lossy();
|
||||
if name.ends_with(".zip") {
|
||||
let file =
|
||||
std::fs::File::open(archive).map_err(|e| format!("{}: {e}", archive.display()))?;
|
||||
zip::ZipArchive::new(file)
|
||||
.and_then(|mut z| z.extract(&scratch))
|
||||
.map_err(|e| format!("{}: {e}", archive.display()))?;
|
||||
} else if name.ends_with(".tar.gz") || name.ends_with(".tgz") {
|
||||
// tar is on every Linux and macOS, and on Windows 10 and later.
|
||||
let status = Command::new("tar")
|
||||
.arg("-xzf")
|
||||
.arg(archive)
|
||||
.arg("-C")
|
||||
.arg(&scratch)
|
||||
.status()
|
||||
.map_err(|e| format!("tar: {e}"))?;
|
||||
if !status.success() {
|
||||
return Err(format!(
|
||||
"tar couldn't unpack {} ({status})",
|
||||
archive.display()
|
||||
));
|
||||
}
|
||||
} else {
|
||||
return Err(format!(
|
||||
"{} is neither a .tar.gz nor a .zip",
|
||||
archive.display()
|
||||
));
|
||||
}
|
||||
let source = find_program(&scratch, &exe("horizon-server"))
|
||||
.and_then(|p| p.parent().map(Path::to_path_buf))
|
||||
.ok_or_else(|| format!("{} holds no horizon-server", archive.display()))?;
|
||||
#[cfg(unix)]
|
||||
for name in [
|
||||
"horizon-server",
|
||||
"horizon-engine",
|
||||
"horizon-client",
|
||||
"horizon-prepare",
|
||||
] {
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
let path = source.join(name);
|
||||
if path.is_file() {
|
||||
let _ = std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o755));
|
||||
}
|
||||
}
|
||||
if target.exists() {
|
||||
std::fs::remove_dir_all(&target).map_err(|e| format!("{}: {e}", target.display()))?;
|
||||
}
|
||||
std::fs::rename(&source, &target).map_err(|e| format!("{}: {e}", target.display()))?;
|
||||
let game_files = install.root.join("game-files/horizon-client");
|
||||
std::fs::create_dir_all(&game_files).map_err(|e| e.to_string())?;
|
||||
let local = target.join(".local");
|
||||
std::fs::create_dir_all(&local).map_err(|e| e.to_string())?;
|
||||
let link = local.join("horizon-client");
|
||||
if link.symlink_metadata().is_err() {
|
||||
point(&link, &game_files).map_err(|e| format!("{}: {e}", link.display()))?;
|
||||
}
|
||||
Ok(target.clone())
|
||||
})();
|
||||
let _ = std::fs::remove_dir_all(&scratch);
|
||||
result
|
||||
}
|
||||
|
||||
/// The first file called `name` under `dir`, breadth first.
|
||||
fn find_program(dir: &Path, name: &str) -> Option<PathBuf> {
|
||||
let mut queue = std::collections::VecDeque::from([dir.to_path_buf()]);
|
||||
while let Some(folder) = queue.pop_front() {
|
||||
let mut entries: Vec<_> = std::fs::read_dir(&folder).ok()?.flatten().collect();
|
||||
entries.sort_by_key(|e| e.file_name());
|
||||
for entry in entries {
|
||||
let path = entry.path();
|
||||
let kind = entry.file_type().ok()?;
|
||||
if kind.is_file() && entry.file_name() == name {
|
||||
return Some(path);
|
||||
}
|
||||
if kind.is_dir() {
|
||||
queue.push_back(path);
|
||||
}
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
/// A backup name for the world before a switch to `tag` (backup names take letters, digits, - and _).
|
||||
pub fn backup_name(tag: &str) -> String {
|
||||
let clean: String = tag
|
||||
.chars()
|
||||
.map(|c| if c.is_ascii_alphanumeric() { c } else { '-' })
|
||||
.take(48)
|
||||
.collect();
|
||||
format!("before-{clean}")
|
||||
}
|
||||
|
||||
/// `update [--check] [--version TAG] [--archive FILE --version TAG] [--timeout SECONDS]`.
|
||||
pub fn command(dir: &Path, args: &[String]) -> Result<(), String> {
|
||||
let mut check = false;
|
||||
let mut version = None;
|
||||
let mut archive = None;
|
||||
let mut timeout = crate::api::UPDATE_TIMEOUT;
|
||||
let mut it = args.iter();
|
||||
while let Some(arg) = it.next() {
|
||||
let mut value = || {
|
||||
it.next()
|
||||
.cloned()
|
||||
.ok_or_else(|| format!("{arg} needs a value"))
|
||||
};
|
||||
match arg.as_str() {
|
||||
"--check" => check = true,
|
||||
"--version" => version = Some(value()?),
|
||||
"--archive" => archive = Some(PathBuf::from(value()?)),
|
||||
"--timeout" => timeout = seconds(&value()?)?,
|
||||
other => return Err(format!("update: unknown option {other}")),
|
||||
}
|
||||
}
|
||||
let install = Install::required()?;
|
||||
let current = install
|
||||
.current()
|
||||
.ok_or("the installer's `current` points at no release")?;
|
||||
let (tag, archive, downloaded) = match archive {
|
||||
Some(_) if check => return Err("--check looks at GitHub's releases: drop --archive".into()),
|
||||
Some(archive) => {
|
||||
let tag = version
|
||||
.ok_or("--archive needs --version NAME: the release name to install it as")?;
|
||||
(tag, archive, false)
|
||||
}
|
||||
None => {
|
||||
let release = release(version.as_deref())?;
|
||||
if check {
|
||||
if newer(&release.tag, ¤t) {
|
||||
println!(
|
||||
"Horizon {} is out; this server runs {current}. `horizon-server update` installs it.",
|
||||
release.tag
|
||||
);
|
||||
} else {
|
||||
println!(
|
||||
"Up to date: {current} (the newest release is {}).",
|
||||
release.tag
|
||||
);
|
||||
}
|
||||
return Ok(());
|
||||
}
|
||||
if version.is_none() && !newer(&release.tag, ¤t) {
|
||||
println!("Already on the newest release ({current}).");
|
||||
return Ok(());
|
||||
}
|
||||
println!("Downloading Horizon {} ({})...", release.tag, release.asset);
|
||||
let archive = download(&install, &release)?;
|
||||
(release.tag, archive, true)
|
||||
}
|
||||
};
|
||||
if tag == current {
|
||||
println!("Already on {tag}.");
|
||||
return Ok(());
|
||||
}
|
||||
let unpacked = unpack(&install, &archive, &tag);
|
||||
if downloaded {
|
||||
let _ = std::fs::remove_file(&archive);
|
||||
}
|
||||
unpacked?;
|
||||
switch_to(dir, &install, &tag, timeout)
|
||||
}
|
||||
|
||||
/// `rollback [--timeout SECONDS]`: back to the release used before the current one.
|
||||
pub fn rollback(dir: &Path, args: &[String]) -> Result<(), String> {
|
||||
let timeout = match args {
|
||||
[] => crate::api::UPDATE_TIMEOUT,
|
||||
[flag, value] if flag == "--timeout" => seconds(value)?,
|
||||
_ => return Err("rollback takes only --timeout SECONDS".into()),
|
||||
};
|
||||
let install = Install::required()?;
|
||||
let previous = install.previous().ok_or(
|
||||
"no release to go back to: this install hasn't been updated, or the one before is gone",
|
||||
)?;
|
||||
switch_to(dir, &install, &previous, timeout)
|
||||
}
|
||||
|
||||
fn seconds(text: &str) -> Result<Duration, String> {
|
||||
text.parse()
|
||||
.ok()
|
||||
.filter(|&s| s > 0)
|
||||
.map(Duration::from_secs)
|
||||
.ok_or_else(|| format!("--timeout needs a number of seconds (got {text:?})"))
|
||||
}
|
||||
|
||||
/// Switches the install to the release `tag`. A running server restarts on it through its supervisor, which
|
||||
/// goes back by itself if the game isn't up within `timeout`; a stopped one is switched and its game checked.
|
||||
/// Either way the world is backed up first.
|
||||
fn switch_to(dir: &Path, install: &Install, tag: &str, timeout: Duration) -> Result<(), String> {
|
||||
let Some(client) = Client::open(dir)? else {
|
||||
return switch_stopped(dir, install, tag);
|
||||
};
|
||||
let finished = |status: &Value| status["update"]["finished"].as_u64().unwrap_or(0);
|
||||
let before = finished(&client.call("GET", "/api/v1/status", None)?);
|
||||
client
|
||||
.call(
|
||||
"POST",
|
||||
"/api/v1/update",
|
||||
Some(&json!({ "tag": tag, "timeout": timeout.as_secs() })),
|
||||
)
|
||||
.map_err(|e| {
|
||||
if e == "no such endpoint" {
|
||||
"the running server is older than updates: stop it, then run `horizon-server update` again".into()
|
||||
} else {
|
||||
e
|
||||
}
|
||||
})?;
|
||||
print!("Restarting the server on {tag}");
|
||||
// The backup, the stop, the start and, if it fails, the way back.
|
||||
let deadline = Instant::now() + timeout + Duration::from_secs(3600);
|
||||
loop {
|
||||
std::thread::sleep(Duration::from_millis(500));
|
||||
let status = client.call("GET", "/api/v1/status", None)?;
|
||||
if finished(&status) > before {
|
||||
let update = &status["update"];
|
||||
let last = update["last"].as_str().unwrap_or_default().to_owned();
|
||||
if update["ok"] == true {
|
||||
println!("\n{last}");
|
||||
return Ok(());
|
||||
}
|
||||
// Rolled back (or stayed): say so once the game is up again on the release it went back to.
|
||||
let mut phase = status["phase"].as_str().unwrap_or_default().to_owned();
|
||||
let until = Instant::now() + crate::api::UPDATE_TIMEOUT;
|
||||
while phase != "running" && phase != "stopping" && Instant::now() < until {
|
||||
std::thread::sleep(Duration::from_millis(500));
|
||||
print!(".");
|
||||
let _ = std::io::Write::flush(&mut std::io::stdout());
|
||||
phase = client.call("GET", "/api/v1/status", None)?["phase"]
|
||||
.as_str()
|
||||
.unwrap_or_default()
|
||||
.to_owned();
|
||||
}
|
||||
println!();
|
||||
return Err(if phase == "running" {
|
||||
format!("{last}. The game is up again.")
|
||||
} else {
|
||||
last
|
||||
});
|
||||
}
|
||||
if Instant::now() > deadline {
|
||||
println!();
|
||||
return Err(
|
||||
"no word from the server about the update; `horizon-server logs` shows where it is"
|
||||
.into(),
|
||||
);
|
||||
}
|
||||
print!(".");
|
||||
let _ = std::io::Write::flush(&mut std::io::stdout());
|
||||
}
|
||||
}
|
||||
|
||||
/// The switch for a stopped server (or outside any server folder): the world backed up, `current` moved,
|
||||
/// and the new game checked to load on this system, else switched back.
|
||||
fn switch_stopped(dir: &Path, install: &Install, tag: &str) -> Result<(), String> {
|
||||
let from = install
|
||||
.current()
|
||||
.ok_or("the installer's `current` points at no release")?;
|
||||
let server = dir.join(crate::config::FILE).is_file();
|
||||
let _lock = if server {
|
||||
Some(supervisor::lock(dir)?)
|
||||
} else {
|
||||
None
|
||||
};
|
||||
let config = if server {
|
||||
Config::load(dir)?
|
||||
} else {
|
||||
Config::default()
|
||||
};
|
||||
let backed_up = if server {
|
||||
let file = backup::file_name(std::time::SystemTime::now(), Some(&backup_name(tag)))?;
|
||||
backup::create(dir, &config, &file)?;
|
||||
format!(" The world is backed up in {}/{file}.", backup::DIR)
|
||||
} else {
|
||||
String::new()
|
||||
};
|
||||
let previous = install.previous();
|
||||
install.switch(tag)?;
|
||||
if let Err(e) =
|
||||
engine::program_in(&config, dir, Some(install)).and_then(|p| engine::check_starts(&p))
|
||||
{
|
||||
install.switch_back(&from, previous.as_deref())?;
|
||||
return Err(format!("stayed on {from}: {e}"));
|
||||
}
|
||||
println!(
|
||||
"Switched from {from} to {tag}.{backed_up}{} `horizon-server rollback` goes back to {from}.",
|
||||
if server {
|
||||
" The server is stopped: `horizon-server start` runs the new version."
|
||||
} else {
|
||||
""
|
||||
}
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use serde_json::json;
|
||||
|
||||
fn scratch(name: &str) -> PathBuf {
|
||||
let dir = std::env::temp_dir().join(format!(
|
||||
"horizon-server-update-{name}-{}",
|
||||
std::process::id()
|
||||
));
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
std::fs::create_dir_all(&dir).unwrap();
|
||||
dir
|
||||
}
|
||||
|
||||
/// An install as install.sh leaves it, with releases `tags`, the first in use.
|
||||
#[cfg(unix)]
|
||||
fn installed(name: &str, tags: &[&str]) -> Install {
|
||||
// Canonical, as `around` sees it (macOS's temporary folder is behind a link).
|
||||
let root = std::fs::canonicalize(scratch(name)).unwrap();
|
||||
for tag in tags {
|
||||
let release = root.join("releases").join(tag);
|
||||
std::fs::create_dir_all(&release).unwrap();
|
||||
std::fs::write(release.join("horizon-server"), tag).unwrap();
|
||||
}
|
||||
std::os::unix::fs::symlink(root.join("releases").join(tags[0]), root.join("current"))
|
||||
.unwrap();
|
||||
Install { root }
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tags_compare_by_number() {
|
||||
assert!(newer("v2026.10.19", "v2026.10.18.27"));
|
||||
assert!(newer("v2026.10.18.27", "v2026.10.18.9"));
|
||||
assert!(newer("v2026.10.19.1", "v2026.10.19"));
|
||||
assert!(!newer("v2026.10.19", "v2026.10.19"));
|
||||
assert!(!newer("v2026.10.18", "v2026.10.19"));
|
||||
// An archive installed by hand: any release is newer, and it is never newer than one.
|
||||
assert!(newer("v2026.10.19", "local"));
|
||||
assert!(!newer("local", "v2026.10.19"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_archive_for_this_computer_is_picked_with_its_digest() {
|
||||
let asset = |name: &str| {
|
||||
json!({
|
||||
"name": name,
|
||||
"browser_download_url": format!("https://example.invalid/{name}"),
|
||||
"digest": "sha256:ABCDEF",
|
||||
})
|
||||
};
|
||||
let release = json!({
|
||||
"tag_name": "v2026.10.19",
|
||||
"assets": ASSETS.iter().rev().map(|n| asset(n)).chain([asset("other.zip")]).collect::<Vec<_>>(),
|
||||
});
|
||||
if let Some(first) = ASSETS.first() {
|
||||
let picked = pick(&release).unwrap();
|
||||
assert_eq!(picked.tag, "v2026.10.19");
|
||||
// The most specific archive (Linux: the server build), even when listed last.
|
||||
assert_eq!(picked.asset, *first);
|
||||
assert_eq!(picked.sha256, "abcdef");
|
||||
let undigested = json!({ "tag_name": "v1", "assets": [{ "name": first, "browser_download_url": "x" }] });
|
||||
assert!(pick(&undigested).unwrap_err().contains("no SHA-256"));
|
||||
}
|
||||
assert!(
|
||||
pick(&json!({ "tag_name": "v1", "assets": [asset("other.zip")] }))
|
||||
.unwrap_err()
|
||||
.contains("no archive for this computer")
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn backup_names_are_valid() {
|
||||
let name = backup_name("v2026.10.19");
|
||||
assert_eq!(name, "before-v2026-10-19");
|
||||
crate::backup::file_name(std::time::SystemTime::now(), Some(&name)).unwrap();
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn switching_keeps_the_previous_release() {
|
||||
let install = installed("switch", &["v1", "v2"]);
|
||||
let exe = install.root.join("current/horizon-server");
|
||||
assert_eq!(Install::around(&exe), Some(install.clone()));
|
||||
assert_eq!(
|
||||
Install::around(&install.release("v2").join("horizon-server")),
|
||||
Some(install.clone())
|
||||
);
|
||||
assert_eq!(install.current().as_deref(), Some("v1"));
|
||||
assert_eq!(install.previous(), None);
|
||||
install.switch("v2").unwrap();
|
||||
assert_eq!(install.current().as_deref(), Some("v2"));
|
||||
assert_eq!(install.previous().as_deref(), Some("v1"));
|
||||
assert_eq!(std::fs::read_to_string(&exe).unwrap(), "v2");
|
||||
// Undoing it leaves `previous` as it was.
|
||||
install.switch_back("v1", None).unwrap();
|
||||
assert_eq!(install.current().as_deref(), Some("v1"));
|
||||
assert_eq!(install.previous(), None);
|
||||
install.switch("v2").unwrap();
|
||||
// Rolling back is a switch to the previous release, which then becomes the one to go back to.
|
||||
install.switch("v1").unwrap();
|
||||
assert_eq!(install.current().as_deref(), Some("v1"));
|
||||
assert_eq!(install.previous().as_deref(), Some("v2"));
|
||||
// Switching to the release in use changes nothing; to a missing one is refused.
|
||||
install.switch("v1").unwrap();
|
||||
assert_eq!(install.previous().as_deref(), Some("v2"));
|
||||
assert!(
|
||||
install
|
||||
.switch("v3")
|
||||
.unwrap_err()
|
||||
.contains("no horizon-server")
|
||||
);
|
||||
assert_eq!(install.current().as_deref(), Some("v1"));
|
||||
std::fs::remove_dir_all(&install.root).unwrap();
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn an_archive_unpacks_beside_the_others_with_the_game_files_linked() {
|
||||
let install = installed("unpack", &["v1"]);
|
||||
let source = scratch("unpack-source");
|
||||
let inner = source.join("horizon-v2");
|
||||
std::fs::create_dir_all(&inner).unwrap();
|
||||
std::fs::write(inner.join("horizon-server"), "v2").unwrap();
|
||||
std::fs::write(inner.join("horizon-engine"), "engine").unwrap();
|
||||
let archive = source.join("horizon-server-linux-x86_64.tar.gz");
|
||||
let status = Command::new("tar")
|
||||
.arg("-czf")
|
||||
.arg(&archive)
|
||||
.arg("-C")
|
||||
.arg(&source)
|
||||
.arg("horizon-v2")
|
||||
.status()
|
||||
.unwrap();
|
||||
assert!(status.success());
|
||||
let release = unpack(&install, &archive, "v2").unwrap();
|
||||
assert_eq!(release, install.release("v2"));
|
||||
assert_eq!(
|
||||
std::fs::read_to_string(release.join("horizon-engine")).unwrap(),
|
||||
"engine"
|
||||
);
|
||||
{
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
let mode = std::fs::metadata(release.join("horizon-engine"))
|
||||
.unwrap()
|
||||
.permissions()
|
||||
.mode();
|
||||
assert_eq!(mode & 0o111, 0o111);
|
||||
}
|
||||
assert_eq!(
|
||||
std::fs::canonicalize(release.join(".local/horizon-client")).unwrap(),
|
||||
std::fs::canonicalize(install.root.join("game-files/horizon-client")).unwrap()
|
||||
);
|
||||
// Not switched yet; nothing left behind; the release in use can't be unpacked over.
|
||||
assert_eq!(install.current().as_deref(), Some("v1"));
|
||||
assert!(!install.root.join("releases/.v2.unpacking").exists());
|
||||
assert!(
|
||||
unpack(&install, &archive, "v1")
|
||||
.unwrap_err()
|
||||
.contains("in use")
|
||||
);
|
||||
assert!(unpack(&install, &archive, "../x").is_err());
|
||||
let empty = source.join("empty.zip");
|
||||
zip::ZipWriter::new(std::fs::File::create(&empty).unwrap())
|
||||
.finish()
|
||||
.unwrap();
|
||||
assert!(
|
||||
unpack(&install, &empty, "v3")
|
||||
.unwrap_err()
|
||||
.contains("holds no horizon-server")
|
||||
);
|
||||
assert!(!install.release("v3").exists());
|
||||
std::fs::remove_dir_all(&install.root).unwrap();
|
||||
std::fs::remove_dir_all(&source).unwrap();
|
||||
}
|
||||
}
|
||||
+1
-1
@@ -46,4 +46,4 @@ To play, use [the launcher](../launcher/README.md); the project site is [playhor
|
||||
|
||||
## The earlier Java track (no longer developed)
|
||||
|
||||
- [Java performance packs](java-packs.md), with [Vulkan on your Mac](vulkan.md), [collector comparisons](collectors.md), [profiling](profiling.md), [process memory](process-memory.md) and [tick state](tick-state.md); [server quickstart](server-quickstart.txt).
|
||||
- [Java performance packs](java-packs.md), with [Vulkan on your Mac](vulkan.md), [collector comparisons](collectors.md), [profiling](profiling.md), [process memory](process-memory.md) and [tick state](tick-state.md). The Fabric server starter is retired: [host a server](hosting.md) with horizon-server.
|
||||
|
||||
+2
-3
@@ -28,16 +28,15 @@ is not a measured pause total. Use JFR root pause events for pause analysis.
|
||||
The streaming reader is checked against the JDK's event exporter with both
|
||||
default-GC and ZGC fixtures in CI on Windows, Linux and ARM macOS.
|
||||
|
||||
Developer demo and server launchers accept `--gc default`, `--gc g1` or `--gc zgc`.
|
||||
The developer demo launcher accepts `--gc default`, `--gc g1` or `--gc zgc`.
|
||||
For example:
|
||||
|
||||
```sh
|
||||
python3 tools/runtime.py demo --instance .local/runtime/collector-test --heap 6G --gc zgc --compact-headers
|
||||
python3 tools/server.py run --heap 4G --gc zgc
|
||||
python3 tools/test_jfr.py --gc zgc
|
||||
```
|
||||
|
||||
Prepare demo mods/worlds before comparing. The server retains its EULA requirement.
|
||||
Prepare demo mods/worlds before comparing.
|
||||
Options affect only the launched process; they do not change global Java settings.
|
||||
The collector and compact-header experiments can be tested independently.
|
||||
|
||||
|
||||
+22
-3
@@ -204,6 +204,8 @@ horizon-server restore BACKUP [--yes]
|
||||
horizon-server service install|uninstall|print [--system]
|
||||
horizon-server panel a one-time login link for the web panel
|
||||
horizon-server import FILE server.toml from a vanilla server.properties
|
||||
horizon-server update [--check] install the newest release and restart on it (below)
|
||||
horizon-server rollback back to the release before
|
||||
```
|
||||
|
||||
While the server runs, `op`, `whitelist` and `cmd` go to the game's console, so they act exactly as vanilla's
|
||||
@@ -213,14 +215,31 @@ console commands do. While it's stopped, they edit vanilla's files directly. Any
|
||||
The server restarts the game by itself if it crashes: after 5 s, then waiting longer each time, up to 5
|
||||
minutes. It keeps the crash report and gives up after 5 crashes in 10 minutes, and `status` says why.
|
||||
|
||||
Coming: `update` and `rollback`, `console` (attach to a server running in the background), `ban` and
|
||||
`pardon` as their own commands, and `mcp` (an MCP server so an AI assistant can run the server).
|
||||
**Updates** (a server installed with the install script). The server checks for a newer release a minute
|
||||
after it starts and every 6 hours after, and says so in its log, in `status` and in the panel; it never
|
||||
updates by itself. `horizon-server update --check` asks once. `horizon-server update`:
|
||||
|
||||
1. downloads the newest release and checks it against the SHA-256 GitHub publishes for it;
|
||||
2. stops the game, backs up the world (`backups/<time>-before-<release>.zip`) and switches to the new
|
||||
release;
|
||||
3. starts the game on it and waits up to 5 minutes (`--timeout SECONDS`) for it to come up.
|
||||
|
||||
If the new game crashes or doesn't come up in time, the server goes back to the release it was on by itself
|
||||
and puts the world back as it was just before the switch (the world the new game left is kept in
|
||||
`backups/`). `horizon-server rollback` goes back to the release before by hand, keeping the world as it is
|
||||
(it backs it up first). `--version vX.Y.Z` installs a given release, and `--archive FILE --version NAME` an
|
||||
archive you have, such as your own build. A stopped server is switched and starts on the new release next
|
||||
time. Set `HORIZON_NO_UPDATE_CHECK=1` in the server's environment to turn the check off.
|
||||
|
||||
Coming: `console` (attach to a server running in the background), `ban` and `pardon` as their own
|
||||
commands, and `mcp` (an MCP server so an AI assistant can run the server).
|
||||
|
||||
## 6. Web panel
|
||||
|
||||
The panel runs inside `horizon-server` while the server runs. It shows live TPS, MSPT, RAM and CPU graphs for
|
||||
the last 10 minutes, the players with their ping (and a kick button), the console with a command line, and the
|
||||
backups (back up now, restore with a confirmation), with Restart and Stop.
|
||||
backups (back up now, restore with a confirmation), with Restart and Stop. When a newer release is out it says
|
||||
so, with an Update button that runs `horizon-server update` (section 5), and shows how it went.
|
||||
|
||||
```sh
|
||||
horizon-server panel
|
||||
|
||||
+3
-3
@@ -1,6 +1,6 @@
|
||||
# Java performance packs (no longer developed)
|
||||
|
||||
Before the Rust rewrite, Horizon was a lab for Minecraft Java client performance: pinned Fabric performance packs, distant terrain, an original frame and tick recorder, and client and server starter downloads. This track is **no longer developed**. No release downloads are published; build the packs and starters locally with `python3 tools/build_release.py` (see [Build and run](#build-and-run)). This page keeps its documentation.
|
||||
Before the Rust rewrite, Horizon was a lab for Minecraft Java client performance: pinned Fabric performance packs, distant terrain, an original frame and tick recorder, and client and server starter downloads (the server starter is gone: [horizon-server](hosting.md) replaces it). This track is **no longer developed**. No release downloads are published; build the packs and starters locally with `python3 tools/build_release.py` (see [Build and run](#build-and-run)). This page keeps its documentation.
|
||||
|
||||
## Java packs: Mac starter (out of scope)
|
||||
|
||||
@@ -91,9 +91,9 @@ python3 tools/build_mod.py
|
||||
python3 tools/build_release.py
|
||||
```
|
||||
|
||||
Gitignored `dist/` contains twenty packs, our original instrumentation JAR, client/server starter ZIPs and SHA256SUMS. [mods.lock.json](../packs/mods.lock.json) pins mod versions, exact dependency closure, SHA-1/SHA-512 and source/license; [fabric.lock.json](../packs/fabric.lock.json) pins loader/library SHA-256. Packs use the [Modrinth format](https://support.modrinth.com/en/articles/8802351-modrinth-modpack-format-mrpack). They embed only original project code; third-party mods, game and assets download from their publishers.
|
||||
Gitignored `dist/` contains twenty packs, our original instrumentation JAR, the client starter ZIP and SHA256SUMS. [mods.lock.json](../packs/mods.lock.json) pins mod versions, exact dependency closure, SHA-1/SHA-512 and source/license; [fabric.lock.json](../packs/fabric.lock.json) pins loader/library SHA-256. Packs use the [Modrinth format](https://support.modrinth.com/en/articles/8802351-modrinth-modpack-format-mrpack). They embed only original project code; third-party mods, game and assets download from their publishers.
|
||||
|
||||
The server starter uses Lithium/FerriteCore and `/horizonserver bench <label> <seconds>`. [Server instructions](server-quickstart.txt) cover setup and a baseline. Files are prepared before you accept Minecraft's EULA locally. A 50-active-player workload remains to be measured.
|
||||
The Fabric server starter (Lithium/FerriteCore, `tools/server.py`) was retired on 2026-10-19. To host a server, use [horizon-server](hosting.md) ([playhorizon.dev/server](https://playhorizon.dev/server)); its benchmarks are in [server.md](server.md), section 9.
|
||||
|
||||
Local smoke testing uses the game's built-in limited demo; normal play uses Prism's licensed account authentication:
|
||||
|
||||
|
||||
@@ -1,54 +0,0 @@
|
||||
Horizon server @PACK_VERSION@ — Minecraft 26.3, Fabric 0.19.5, Java 25
|
||||
|
||||
Install Python 3.10+ and native Java 25. Extract this ZIP and open a terminal here.
|
||||
This starter never downloads the game: download the Minecraft 26.3 server jar
|
||||
yourself (https://www.minecraft.net/download/server while 26.3 is current), then:
|
||||
|
||||
python3 tools/server.py prepare --server-jar PATH/TO/server.jar
|
||||
|
||||
Read Minecraft's EULA at https://www.minecraft.net/eula. Create/edit
|
||||
.local/server/optimized/eula.txt to contain eula=true if you agree, then:
|
||||
|
||||
python3 tools/server.py run --heap 4G
|
||||
|
||||
Windows: use python in place of python3 if needed. Your server jar, mods and
|
||||
assets stay in .local. No game code, third-party mod JARs or credentials are bundled.
|
||||
Lithium and FerriteCore optimize the original simulation/storage; tick rate and
|
||||
vanilla gameplay rules are retained. No Paper-style gameplay configuration.
|
||||
|
||||
From the server console:
|
||||
horizonserver bench populated-50 120
|
||||
horizonserver stop
|
||||
|
||||
From an operator's in-game chat, prefix each command with /. JSON/CSV reports
|
||||
appear in the instance's horizon-benchmarks directory. They record actual peak
|
||||
players, tick execution durations, observed tick count per elapsed second,
|
||||
JVM heap/GC and platform metadata. meanRate is tick execution capacity, NOT TPS.
|
||||
An idle server does not establish performance for 50 active players.
|
||||
|
||||
Baseline:
|
||||
python3 tools/server.py prepare --baseline
|
||||
python3 tools/server.py run --baseline --heap 4G
|
||||
|
||||
Use separate world copies with the same seed, settings, Java and maximum heap.
|
||||
Only run one at a time unless you give them distinct ports/resources. When
|
||||
benchmarking 50 players include normal exploration, entity farms, redstone and
|
||||
chunk loading; repeat with 1, 10 and 100. Do not change simulation/view distance
|
||||
between matched runs or turn off game logic to manufacture a speedup.
|
||||
This first release has not been validated under a 50-player real workload.
|
||||
|
||||
Optional Java 25 HotSpot experiment: add --compact-headers to the run command.
|
||||
Reports capture the actual compact object header flag and collector names.
|
||||
Compare against the same workload with the flag omitted; object allocation
|
||||
changes do not establish a whole-server RAM/TPS gain.
|
||||
|
||||
Optional collector comparison: select --gc g1 or --gc zgc on the run command.
|
||||
Match world, player activity, heap, Java and header mode; use one collector at a
|
||||
time. gc_time_ms includes collector cycle accounting, not a measured pause total.
|
||||
Use JFR pause events for pause analysis and compare RSS/CPU/TPS together.
|
||||
|
||||
Compare generated reports:
|
||||
python3 tools/compare_benchmarks.py baseline-ticks.json optimized-ticks.json --strict
|
||||
|
||||
Baseline must be a separate instance: --baseline adds no optimizers but doesn't
|
||||
delete mods from an existing optimized instance. Use clean directories.
|
||||
+35
-18
@@ -7,8 +7,9 @@ should beat vanilla, Paper and Fabric + Lithium on TPS/MSPT, RAM, CPU, chunk gen
|
||||
Gameplay stays vanilla: there are no Paper-style rule changes unless the owner turns one on.
|
||||
|
||||
This page covers what the server does today (measured), the design of `horizon-server`, and what ships for the
|
||||
first working version (2026-10-23). It replaces the Java/Fabric starter (`docs/server-quickstart.txt`,
|
||||
`tools/server.py`), which goes once the benchmark below exists.
|
||||
first working version (2026-10-23). It replaced the Java/Fabric starter (`docs/server-quickstart.txt`,
|
||||
`tools/server.py`, retired on 2026-10-19). The owner's guide is docs/hosting.md, also at
|
||||
https://playhorizon.dev/server.
|
||||
|
||||
## 1. Today
|
||||
|
||||
@@ -325,11 +326,12 @@ horizon-server backup [NAME] backups restore <backup> [-
|
||||
horizon-server import <server.properties>
|
||||
horizon-server service install|uninstall|print [--system]
|
||||
horizon-server panel the panel's address and a one-time login link
|
||||
horizon-server update [--check] [--version vX.Y.Z] [--timeout S] rollback [--timeout S]
|
||||
horizon-server update --archive FILE --version NAME an archive you have (your own build)
|
||||
|
||||
Planned:
|
||||
horizon-server console attach: the live log, and send commands (Ctrl-D detaches)
|
||||
horizon-server ban|pardon <player> [reason] ban-ip|pardon-ip <address> (`cmd ban …` works now)
|
||||
horizon-server update [--check] [--version vX.Y.Z] rollback
|
||||
horizon-server import-resources <dir> prepare --server-jar PATH
|
||||
horizon-server mcp MCP server on stdio (section 8)
|
||||
```
|
||||
@@ -350,8 +352,11 @@ line), and backups (list, back up now, restore with confirmation), with restart
|
||||
the supervisor, so it is up exactly when the server is: starting a stopped server stays a command (or the
|
||||
service manager's job). Whitelist and bans go through the console for now.
|
||||
|
||||
**Later:** bans and IP bans, worlds, updates with rollback, `server.properties` import, logs and crash
|
||||
reports, and modpacks (with the modpack work).
|
||||
**Updates:** when a newer release is out, the panel says so with an Update button, which runs the same
|
||||
path as `horizon-server update` (section 7) and then shows how it went.
|
||||
|
||||
**Later:** bans and IP bans, worlds, `server.properties` import, logs and crash reports, and modpacks (with
|
||||
the modpack work).
|
||||
|
||||
**Tech:** one HTML page with plain JS and CSS (`crates/horizon-server/panel/`), embedded in the binary with
|
||||
`include_str!`. No build step, no framework, no CDN. It uses Horizon's design system tokens (`horizon-theme`'s
|
||||
@@ -393,16 +398,29 @@ runtime or new dependency. Server-sent events can replace the polling later if a
|
||||
lines and the engine's crash report (`crash-reports/`), restarts it after 5 s, and doubles the wait up to
|
||||
5 minutes. It gives up after 5 crashes in 10 minutes, so it doesn't loop on a broken world, and shows the
|
||||
reason in `status` and the panel.
|
||||
- **Updates.** `update --check` compares with the latest GitHub release. `update`:
|
||||
1. downloads the server archive and checks its SHA-256;
|
||||
2. backs up the world;
|
||||
3. keeps the current binaries as `.horizon/previous/`;
|
||||
4. swaps in the new ones and restarts;
|
||||
5. watches for `Done` within the start timeout and a first status reply.
|
||||
- **Updates** (`crates/horizon-server/src/update.rs`), for a `horizon-server` installed by `install.sh` or
|
||||
`install.ps1`. Releases ship often (release-flow.md), so updates stay opt-in: a running server looks for a
|
||||
newer release a minute after it starts and then every 6 hours, and only says so, in its log, in `status`
|
||||
and in the panel (`HORIZON_NO_UPDATE_CHECK=1` turns the check off). `update --check` asks GitHub once.
|
||||
`update`:
|
||||
1. downloads the release archive for this computer (on Linux the server build) and checks it against the
|
||||
SHA-256 GitHub publishes for it;
|
||||
2. unpacks it into `<dir>/releases/<tag>`, beside the others, with its game files linked to
|
||||
`<dir>/game-files` as the installers do;
|
||||
3. stops the game, backs up the world (`backups/<time>-before-<tag>.zip`), records the release in use in
|
||||
`<dir>/previous` and points `<dir>/current` at the new one;
|
||||
4. checks that the new game loads on this system (`--help`), then starts it;
|
||||
5. waits until it has logged `Done` and answered a status request, for 300 s (`--timeout`).
|
||||
|
||||
If that check fails, it puts the previous binaries back, restores the world if the new engine touched it,
|
||||
and restarts. `rollback` does the same by hand. Releases ship often (release-flow.md), so updates stay
|
||||
opt-in, with `update --check` in `status` and a notice in the panel.
|
||||
If the new game doesn't load, stops, or isn't up in time, the supervisor goes back by itself: `current`
|
||||
points at the release before, `previous` is left as it was, the world is put back from the backup (the
|
||||
one the new game left is kept in `backups/replaced-<time>/`), and the game starts again on the old
|
||||
release. `rollback` switches to `previous` by hand, through the same path (the world is backed up first
|
||||
and kept as it is). The supervisor keeps running as it was: the new `horizon-server` itself takes over
|
||||
the next time the server starts (`stop` and `start`, or the service's restart). A stopped server is
|
||||
switched and its new game checked to load; it starts on the new release next time. One install serves
|
||||
every server folder on the machine, so each one runs the new release from its next start. Old releases
|
||||
stay in `<dir>/releases/` until they are deleted by hand (keep `current` and `previous`).
|
||||
|
||||
## 8. Control API and MCP
|
||||
|
||||
@@ -411,7 +429,9 @@ runtime or new dependency. Server-sent events can replace the polling later if a
|
||||
`.horizon/api.json`. It's plain HTTP/1.1 on `std::net` (`crates/horizon-server/src/http.rs`), no runtime.
|
||||
- built (PR 2b, 2c): `GET status` (phase, uptime, crashes, RSS, CPU, and the engine's TPS, MSPT
|
||||
average/P50/P95/P99, players, chunks), `GET logs?since=`, `POST command {line}` (returns the output),
|
||||
`POST stop`, `POST restart`, `GET backups`, `POST backups {name}`, `POST restore {name}`;
|
||||
`POST stop`, `POST restart`, `GET backups`, `POST backups {name}`, `POST restore {name}`, `POST update
|
||||
{tag, timeout}` (without a tag: the newest release, downloaded first; `status` has an `update` object
|
||||
that says how it went);
|
||||
- planned: `GET metrics?since=` (the panel's graphs), `GET events` (SSE: log lines and metrics),
|
||||
`GET`/`PATCH config` (server.toml fields, validated).
|
||||
- **Auth.** Every call needs `Authorization: Bearer <token from .horizon/api.json>` (file mode 0600), and the
|
||||
@@ -567,10 +587,7 @@ machine, then published in `benchmarks/`; and item 5.
|
||||
- the Nether and End for remote players;
|
||||
- the headless engine and its RAM win;
|
||||
- a server-only prepare without a JDK;
|
||||
- updates and rollback (the design is above; they ship right after);
|
||||
- a Windows service, hot reload, modpacks in the panel;
|
||||
- the website's "host a server" page;
|
||||
- retiring `tools/server.py` and `docs/server-quickstart.txt` (once the benchmark replaces them).
|
||||
|
||||
Online mode works, so a public server can check accounts. An offline server should still run only on a
|
||||
LAN, a tailnet, or behind a whitelist.
|
||||
|
||||
+3
-11
@@ -1,5 +1,6 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Create downloadable client/server starters and hashes from original project artifacts."""
|
||||
"""Create the downloadable client starter and hashes from original project artifacts. (The Java/Fabric server
|
||||
starter is gone: horizon-server replaces it, docs/hosting.md.)"""
|
||||
|
||||
import hashlib
|
||||
from pathlib import Path
|
||||
@@ -27,15 +28,6 @@ def main():
|
||||
client["Compare-Benchmarks.html"] = viewer
|
||||
(ROOT / "dist/Compare-Benchmarks.html").write_bytes(viewer)
|
||||
build_pack.write_zip(ROOT / "dist" / f"horizon-mac-starter-{version}.zip", client)
|
||||
server = {"LICENSE": client["LICENSE"], "dist/" + mod.name: mod.read_bytes(),
|
||||
"Compare-Benchmarks.html": viewer,
|
||||
"START-HERE.txt": (ROOT / "docs/server-quickstart.txt").read_text().replace("@PACK_VERSION@", version).encode(),
|
||||
"research-lock.json": (ROOT / "research-lock.json").read_bytes()}
|
||||
for name in ["lab.py", "runtime.py", "server.py", "compare_benchmarks.py"]:
|
||||
server["tools/" + name] = (ROOT / "tools" / name).read_bytes()
|
||||
for name in ["mods.lock.json", "fabric.lock.json"]:
|
||||
server["packs/" + name] = (ROOT / "packs" / name).read_bytes()
|
||||
build_pack.write_zip(ROOT / "dist" / f"horizon-server-starter-{version}.zip", server)
|
||||
artifacts = sorted(path for path in (ROOT / "dist").glob("*") if version in path.name)
|
||||
artifacts.append(ROOT / "dist/Compare-Benchmarks.html")
|
||||
checksums = []
|
||||
@@ -43,7 +35,7 @@ def main():
|
||||
if path.suffix in [".jar", ".mrpack", ".zip", ".html"]:
|
||||
checksums.append(hashlib.sha256(path.read_bytes()).hexdigest() + " " + path.name)
|
||||
(ROOT / "dist/SHA256SUMS.txt").write_text("\n".join(checksums) + "\n")
|
||||
print("Built client/server starters and SHA256SUMS.txt")
|
||||
print("Built the client starter and SHA256SUMS.txt")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
|
||||
@@ -1,75 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Prepare/run a vanilla-rules Fabric server with pinned memory and simulation optimizers."""
|
||||
|
||||
import argparse
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import re
|
||||
import shutil
|
||||
import subprocess
|
||||
|
||||
try:
|
||||
from . import lab, runtime
|
||||
except ImportError:
|
||||
import lab
|
||||
import runtime
|
||||
|
||||
ROOT = lab.ROOT
|
||||
|
||||
|
||||
def prepare(instance, baseline=False, server_jar=None):
|
||||
lock, directory = lab.config()
|
||||
launcher = lab.import_server(lock, directory, server_jar)
|
||||
server, libraries = lab.unpack_server(launcher, directory, lock["minecraft"]["version"])
|
||||
libraries = [server, *libraries, *runtime.fabric_libraries()]
|
||||
pack_lock = json.loads((ROOT / "packs/mods.lock.json").read_text())
|
||||
mods = pack_lock["projects"]
|
||||
selection = ["fabric-api"] if baseline else ["fabric-api", "lithium", "ferrite-core"]
|
||||
mod_dir = instance / "mods"
|
||||
mod_dir.mkdir(parents=True, exist_ok=True)
|
||||
for name in selection:
|
||||
entry = mods[name]
|
||||
source = runtime.fetch(entry["url"], ROOT / ".local/pack-cache" / entry["filename"],
|
||||
entry["hashes"]["sha512"], "sha512")
|
||||
shutil.copyfile(source, mod_dir / entry["filename"])
|
||||
original = ROOT / "dist" / f"horizon-{pack_lock['pack_version']}.jar"
|
||||
if not original.exists():
|
||||
raise FileNotFoundError("Build the original mod first with tools/build_mod.py, or use the server starter ZIP")
|
||||
runtime.install_original_mod(original, mod_dir)
|
||||
return libraries
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
parser.add_argument("command", choices=["prepare", "run"])
|
||||
parser.add_argument("--instance", type=Path, default=ROOT / ".local/server/optimized")
|
||||
parser.add_argument("--heap", default="4G")
|
||||
parser.add_argument("--server-jar", type=Path, help="the pinned server jar you downloaded yourself")
|
||||
parser.add_argument("--baseline", action="store_true", help="Use a separate instance for the baseline")
|
||||
parser.add_argument("--compact-headers", action="store_true", help="Enable Java 25 compact object headers for this server process")
|
||||
parser.add_argument("--gc", choices=["default", "g1", "zgc"], default="default", help="Select a collector for this process; default leaves JVM policy in use")
|
||||
args = parser.parse_args()
|
||||
if not re.fullmatch(r"[1-9][0-9]*[MGmg]", args.heap):
|
||||
parser.error("--heap must look like 4G")
|
||||
instance = args.instance.resolve()
|
||||
if args.baseline and args.instance == parser.get_default("instance"):
|
||||
instance = ROOT / ".local/server/baseline"
|
||||
libraries = prepare(instance, args.baseline, args.server_jar)
|
||||
if args.command == "prepare":
|
||||
print(f"Prepared server at {instance}. Read https://www.minecraft.net/eula before setting eula=true locally.")
|
||||
return
|
||||
eula = instance / "eula.txt"
|
||||
if not eula.exists() or not re.search(r"(?m)^\s*eula\s*=\s*true\s*$", eula.read_text()):
|
||||
if not eula.exists():
|
||||
eula.write_text("# Read https://www.minecraft.net/eula then change this value yourself.\neula=false\n")
|
||||
print(f"Server prepared. Read Minecraft's EULA and set eula=true in {eula} before running.")
|
||||
return
|
||||
subprocess.run(["java", *runtime.jvm_options(args.heap, args.compact_headers, args.gc),
|
||||
"--enable-native-access=ALL-UNNAMED",
|
||||
"-cp", os.pathsep.join(map(str, libraries)), "net.fabricmc.loader.impl.launch.knot.KnotServer",
|
||||
"--nogui"], cwd=instance, check=True)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -45,6 +45,7 @@
|
||||
<a href="#patch-notes">Notes</a>
|
||||
<a href="#community">Community</a>
|
||||
<a href="#contributors" data-contributors{{CONTRIBUTORS_HIDDEN}}>Contributors</a>
|
||||
<a href="/server">Server</a>
|
||||
</nav>
|
||||
<div class="nav-end">
|
||||
<button class="theme-toggle" type="button" aria-label="Switch between light and dark"><span data-theme-label>Dark</span></button>
|
||||
@@ -64,6 +65,7 @@
|
||||
<a href="#patch-notes">Patch notes</a>
|
||||
<a href="#community">Community</a>
|
||||
<a href="#contributors" data-contributors{{CONTRIBUTORS_HIDDEN}}>Contributors</a>
|
||||
<a href="/server">Host a server</a>
|
||||
</nav>
|
||||
<div class="menu-foot">
|
||||
<a class="button secondary large" href="https://github.com/ludovic111/horizon">GitHub</a>
|
||||
|
||||
+2
-1
@@ -125,7 +125,8 @@ async function setUpLinks() {
|
||||
|
||||
function setUpNav() {
|
||||
const bar = document.querySelector(".nav");
|
||||
const links = [...document.querySelectorAll(".nav-links a")];
|
||||
// The sections on this page (the nav also links to other pages, such as /server).
|
||||
const links = [...document.querySelectorAll('.nav-links a[href^="#"]')];
|
||||
const sections = links.map((a) => document.querySelector(a.getAttribute("href")));
|
||||
|
||||
let current = null;
|
||||
|
||||
Reference in New Issue
Block a user