horizon-server: install scripts, a Docker image, and boot services

- packaging/server/install.sh (Linux, macOS) and install.ps1 (Windows) install the latest release (or
  --version) from GitHub, check the SHA-256 GitHub publishes for it, and keep releases side by side:
  <dir>/current points at the one in use, so an update or a rollback is one link, and the game files
  prepared from the owner's Minecraft stay in <dir>/game-files across updates.
- packaging/server/Dockerfile builds the server and the engine; the prepared game files are mounted
  read-only, and the first start writes server.toml from HORIZON_EULA, HORIZON_WORLD, HORIZON_SEED,
  HORIZON_PORT, HORIZON_WHITELIST, HORIZON_PLAYERS and HORIZON_OP (`init` reads them too).
- `horizon-server service install|uninstall|print` writes and loads a systemd unit (user, or --system),
  a launchd agent, or a Windows task at logon. It runs the installer's launcher, so updates apply on
  the next restart.
- Releases build horizon-server and ship it beside horizon-ctl and horizon-prepare; PLAY.txt says how
  to run a server.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Ludovic Marie
2026-10-16 20:19:57 +02:00
parent 3510764cc6
commit ed6af00ff8
9 changed files with 657 additions and 12 deletions
+5 -4
View File
@@ -109,18 +109,18 @@ jobs:
- name: ALSA and udev headers
if: runner.os == 'Linux'
run: sudo apt-get update && sudo apt-get install -y --no-install-recommends libasound2-dev libudev-dev
- name: Build the client, horizon-ctl and horizon-prepare
run: cargo build --release --locked -p horizon-client --bin horizon-client --bin horizon-ctl -p horizon-prepare --bin horizon-prepare
- name: Build the client, horizon-ctl, horizon-prepare and horizon-server
run: cargo build --release --locked -p horizon-client --bin horizon-client --bin horizon-ctl -p horizon-prepare --bin horizon-prepare -p horizon-server --bin horizon-server
- name: Every program the release folder takes was built
run: |
for binary in horizon-client horizon-ctl horizon-prepare; do
for binary in horizon-client horizon-ctl horizon-prepare horizon-server; do
test -f "target/release/$binary${{ matrix.exe }}" || { echo "::error::target/release/$binary${{ matrix.exe }} is missing"; exit 1; }
done
- name: Only system libraries
# Windows: no non-system DLL (a "DLL not found" dialog on some players' machines). Linux: the standard
# loader and libraries every desktop distribution has. macOS: only the system's own libraries.
run: |
for binary in horizon-client horizon-ctl horizon-prepare; do
for binary in horizon-client horizon-ctl horizon-prepare horizon-server; do
file="target/release/$binary${{ matrix.exe }}"
if [[ "$RUNNER_OS" == macOS ]]; then
others=$(otool -L "$file" | tail -n +2 | awk '{print $1}' | grep -v -E '^(/usr/lib/|/System/Library/)' || true)
@@ -137,6 +137,7 @@ jobs:
"$bin/horizon-ctl${{ matrix.exe }}" --help > /dev/null
"$bin/horizon-prepare${{ matrix.exe }}" --version
"$bin/horizon-prepare${{ matrix.exe }}" --help | grep -q -- '--minecraft-dir'
"$bin/horizon-server${{ matrix.exe }}" --version
- name: Tools from the runner
if: runner.environment == 'self-hosted'
run: bash tools/ci/runner-env.sh
+32
View File
@@ -27,6 +27,38 @@ pub struct Answers {
pub yes: bool,
}
impl Answers {
/// The answers in the environment, for containers: `HORIZON_EULA=true`, `HORIZON_WORLD`,
/// `HORIZON_SEED`, `HORIZON_PORT`, `HORIZON_WHITELIST=true|false`, `HORIZON_PLAYERS` (names separated by
/// commas) and `HORIZON_OP`. Flags given on the command line win.
pub fn from_env() -> Result<Self, String> {
let var = |name: &str| std::env::var(name).ok().filter(|v| !v.is_empty());
let flag = |name: &str| var(name).map(|v| v.eq_ignore_ascii_case("true"));
Ok(Self {
eula: flag("HORIZON_EULA").unwrap_or(false),
world: var("HORIZON_WORLD"),
seed: var("HORIZON_SEED"),
port: var("HORIZON_PORT")
.map(|p| {
p.parse()
.map_err(|_| format!("HORIZON_PORT is {p:?}: use a port number"))
})
.transpose()?,
whitelist: flag("HORIZON_WHITELIST"),
players: var("HORIZON_PLAYERS")
.map(|p| {
p.split([',', ' '])
.filter(|n| !n.is_empty())
.map(str::to_owned)
.collect()
})
.unwrap_or_default(),
op: var("HORIZON_OP"),
yes: false,
})
}
}
struct Prompt {
interactive: bool,
}
+6 -1
View File
@@ -9,6 +9,7 @@ mod engine;
mod http;
mod init;
mod lists;
mod service;
mod signals;
mod supervisor;
@@ -38,6 +39,9 @@ Usage: horizon-server [--dir DIR] <command>
restore BACKUP [--yes]
Put a backup's world in place (the current one is kept in backups/); a running
server restarts with it
service install|uninstall|print [--system]
Start the server at boot or login: a systemd unit on Linux (--system: for every user,
with sudo), a launchd agent on macOS, a task at logon on Windows
import FILE Write server.toml from a vanilla server.properties
op NAME, deop NAME
whitelist on|off|list, whitelist add|remove NAME
@@ -78,6 +82,7 @@ fn main() -> ExitCode {
Some("logs") => logs(&dir, &args[1..]),
Some("backup") => cli::backup(&dir, args.get(1).map(String::as_str)),
Some("backups") => cli::backups(&dir),
Some("service") => service::command(&dir, &args[1..]),
Some("restore") => match args.get(1) {
Some(name) => cli::restore(&dir, name, args[2..].iter().any(|a| a == "--yes")),
None => Err("restore needs a backup (`horizon-server backups` lists them)".into()),
@@ -117,7 +122,7 @@ fn logs(dir: &std::path::Path, args: &[String]) -> Result<(), String> {
}
fn init_answers(args: &[String]) -> Result<init::Answers, String> {
let mut answers = init::Answers::default();
let mut answers = init::Answers::from_env()?;
let mut it = args.iter();
while let Some(arg) = it.next() {
let mut value = |flag: &str| {
+377
View File
@@ -0,0 +1,377 @@
//! `horizon-server service install|uninstall|print`: run the server at boot or login under the system's own
//! service manager (docs/server.md, section 3): a systemd unit on Linux, a launchd agent on macOS, a task at
//! logon on Windows. The service runs `horizon-server run`, which restarts the game if it crashes; the
//! service manager restarts the supervisor itself.
use std::{
path::{Path, PathBuf},
process::Command,
};
/// The service's name for a server folder: `horizon-server-<folder>`, in letters, digits and dashes.
pub fn name(dir: &Path) -> String {
let folder = dir
.file_name()
.map(|n| n.to_string_lossy().into_owned())
.unwrap_or_default();
let mut clean: String = folder
.chars()
.map(|c| {
if c.is_ascii_alphanumeric() {
c.to_ascii_lowercase()
} else {
'-'
}
})
.collect();
clean = clean.trim_matches('-').to_owned();
if clean.is_empty() {
clean = "server".into();
}
format!("horizon-server-{clean}")
}
/// The program the service runs: the `horizon-server` on the PATH (the installer's launcher, which keeps
/// running the current version after an update), else this program.
fn program() -> Result<PathBuf, String> {
let on_path = std::env::var_os("PATH")
.map(|p| std::env::split_paths(&p).collect::<Vec<_>>())
.unwrap_or_default()
.into_iter()
.map(|d| d.join(format!("horizon-server{}", std::env::consts::EXE_SUFFIX)))
.find(|p| p.is_file());
match on_path {
Some(path) => Ok(path),
None => std::env::current_exe().map_err(|e| e.to_string()),
}
}
/// A systemd unit: a user unit, or with `user` a system unit running as that user.
pub fn systemd_unit(program: &Path, dir: &Path, user: Option<&str>) -> String {
let (run_as, wanted_by) = match user {
Some(user) => (format!("User={user}\n"), "multi-user.target"),
None => (String::new(), "default.target"),
};
format!(
"[Unit]
Description=Horizon server in {dir}
Documentation=https://github.com/ludovic111/horizon/blob/main/docs/server.md
Wants=network-online.target
After=network-online.target
[Service]
Type=simple
{run_as}WorkingDirectory={dir}
ExecStart=\"{program}\" --dir \"{dir}\" run
# SIGTERM makes the supervisor stop the game cleanly; saving a big world takes a moment.
TimeoutStopSec=180
Restart=on-failure
RestartSec=10
[Install]
WantedBy={wanted_by}
",
dir = dir.display(),
program = program.display(),
)
}
fn xml(text: &str) -> String {
text.replace('&', "&amp;")
.replace('<', "&lt;")
.replace('>', "&gt;")
}
/// A launchd agent: started at login, and again if the supervisor exits with an error.
pub fn launchd_plist(label: &str, program: &Path, dir: &Path) -> String {
let log = dir.join("logs/supervisor.log");
format!(
r#"<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>Label</key>
<string>{label}</string>
<key>ProgramArguments</key>
<array>
<string>{program}</string>
<string>--dir</string>
<string>{dir}</string>
<string>run</string>
</array>
<key>WorkingDirectory</key>
<string>{dir}</string>
<key>RunAtLoad</key>
<true/>
<key>KeepAlive</key>
<dict>
<key>SuccessfulExit</key>
<false/>
</dict>
<key>ExitTimeOut</key>
<integer>180</integer>
<key>StandardOutPath</key>
<string>{log}</string>
<key>StandardErrorPath</key>
<string>{log}</string>
</dict>
</plist>
"#,
program = xml(&program.display().to_string()),
dir = xml(&dir.display().to_string()),
log = xml(&log.display().to_string()),
)
}
fn home() -> Result<PathBuf, String> {
std::env::var_os("HOME")
.map(PathBuf::from)
.ok_or_else(|| "HOME is not set".into())
}
fn launchd_path(label: &str) -> Result<PathBuf, String> {
Ok(home()?
.join("Library/LaunchAgents")
.join(format!("{label}.plist")))
}
fn launchd_label(dir: &Path) -> String {
format!(
"dev.horizon.server.{}",
name(dir).trim_start_matches("horizon-server-")
)
}
fn systemd_path(service: &str, system: bool) -> Result<PathBuf, String> {
Ok(if system {
PathBuf::from("/etc/systemd/system")
} else {
std::env::var_os("XDG_CONFIG_HOME")
.map_or_else(
|| home().map(|h| h.join(".config")),
|c| Ok(PathBuf::from(c)),
)?
.join("systemd/user")
}
.join(format!("{service}.service")))
}
fn run(program: &str, args: &[&str]) -> Result<(), String> {
let status = Command::new(program)
.args(args)
.status()
.map_err(|e| format!("{program}: {e}"))?;
if status.success() {
Ok(())
} else {
Err(format!("`{program} {}` failed ({status})", args.join(" ")))
}
}
/// A step that may fail harmlessly (stopping what isn't running): its output would only alarm.
fn quiet(program: &str, args: &[&str]) {
let _ = Command::new(program)
.args(args)
.stdout(std::process::Stdio::null())
.stderr(std::process::Stdio::null())
.status();
}
/// What `service print` shows and `service install` writes, and where.
fn definition(dir: &Path, system: bool) -> Result<(PathBuf, String), String> {
let program = program()?;
if cfg!(target_os = "macos") {
if system {
return Err("on macOS the server runs as a login agent: drop --system".into());
}
let label = launchd_label(dir);
Ok((launchd_path(&label)?, launchd_plist(&label, &program, dir)))
} else if cfg!(windows) {
Err(
"on Windows, `service install` creates a task at logon; there is no file to print"
.into(),
)
} else {
let user = system.then(|| std::env::var("USER").unwrap_or_else(|_| "root".into()));
Ok((
systemd_path(&name(dir), system)?,
systemd_unit(&program, dir, user.as_deref()),
))
}
}
pub fn command(dir: &Path, args: &[String]) -> Result<(), String> {
let dir = dir
.canonicalize()
.map_err(|e| format!("{}: {e}", dir.display()))?;
crate::config::Config::load(&dir)?;
let system = args.iter().any(|a| a == "--system");
let service = name(&dir);
match args.first().map(String::as_str) {
Some("print") => {
let (path, text) = definition(&dir, system)?;
println!("# {}\n{text}", path.display());
Ok(())
}
Some("install") => install(&dir, &service, system),
Some("uninstall") => uninstall(&dir, &service, system),
_ => Err("use: service install|uninstall|print [--system]".into()),
}
}
fn install(dir: &Path, service: &str, system: bool) -> Result<(), String> {
if cfg!(windows) {
let program = program()?;
let action = format!("\"{}\" --dir \"{}\" run", program.display(), dir.display());
run(
"schtasks",
&[
"/Create", "/TN", service, "/TR", &action, "/SC", "ONLOGON", "/RL", "LIMITED", "/F",
],
)?;
run("schtasks", &["/Run", "/TN", service])?;
println!("Installed the task {service}: the server starts when you log in, and now.");
return Ok(());
}
let (path, text) = definition(dir, system)?;
if let Some(parent) = path.parent() {
std::fs::create_dir_all(parent).map_err(|e| format!("{}: {e}", parent.display()))?;
}
std::fs::create_dir_all(dir.join("logs")).map_err(|e| e.to_string())?;
std::fs::write(&path, text).map_err(|e| {
format!(
"{}: {e}{}",
path.display(),
if system { " (--system needs sudo)" } else { "" }
)
})?;
if cfg!(target_os = "macos") {
let uid = String::from_utf8_lossy(
&Command::new("id")
.arg("-u")
.output()
.map_err(|e| e.to_string())?
.stdout,
)
.trim()
.to_owned();
quiet(
"launchctl",
&[
"bootout",
&format!("gui/{uid}"),
&path.display().to_string(),
],
);
run(
"launchctl",
&[
"bootstrap",
&format!("gui/{uid}"),
&path.display().to_string(),
],
)?;
println!(
"Installed {}: the server starts at login, and now. Its output: logs/supervisor.log",
path.display()
);
} else {
let scope: &[&str] = if system { &[] } else { &["--user"] };
run("systemctl", &[scope, &["daemon-reload"]].concat())?;
run(
"systemctl",
&[scope, &["enable", "--now", service]].concat(),
)?;
println!(
"Installed {}: the server starts at boot, and now.",
path.display()
);
if !system {
println!(
"To keep it running while you are logged out: loginctl enable-linger $USER. \
Its log: journalctl --user -u {service}"
);
}
}
Ok(())
}
fn uninstall(dir: &Path, service: &str, system: bool) -> Result<(), String> {
if cfg!(windows) {
quiet("schtasks", &["/End", "/TN", service]);
run("schtasks", &["/Delete", "/TN", service, "/F"])?;
println!("Removed the task {service}.");
return Ok(());
}
let (path, _) = definition(dir, system)?;
if cfg!(target_os = "macos") {
let uid = String::from_utf8_lossy(
&Command::new("id")
.arg("-u")
.output()
.map_err(|e| e.to_string())?
.stdout,
)
.trim()
.to_owned();
quiet(
"launchctl",
&[
"bootout",
&format!("gui/{uid}"),
&path.display().to_string(),
],
);
} else {
let scope: &[&str] = if system { &[] } else { &["--user"] };
quiet(
"systemctl",
&[scope, &["disable", "--now", service]].concat(),
);
}
std::fs::remove_file(&path).map_err(|e| format!("{}: {e}", path.display()))?;
if !cfg!(target_os = "macos") {
let scope: &[&str] = if system { &[] } else { &["--user"] };
quiet("systemctl", &[scope, &["daemon-reload"]].concat());
}
println!(
"Removed {}; the server's folder is untouched.",
path.display()
);
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn names_follow_the_folder() {
assert_eq!(
name(Path::new("/srv/My Server!")),
"horizon-server-my-server"
);
assert_eq!(name(Path::new("/")), "horizon-server-server");
}
#[test]
fn units_run_the_supervisor() {
let unit = systemd_unit(
Path::new("/home/a/.local/bin/horizon-server"),
Path::new("/srv/mc"),
Some("mc"),
);
assert!(
unit.contains("ExecStart=\"/home/a/.local/bin/horizon-server\" --dir \"/srv/mc\" run")
);
assert!(unit.contains("User=mc\n"));
assert!(unit.contains("WantedBy=multi-user.target"));
let plist = launchd_plist(
"dev.horizon.server.mc",
Path::new("/opt/h/horizon-server"),
Path::new("/srv/R&D"),
);
assert!(plist.contains("<string>/srv/R&amp;D</string>"));
assert!(plist.contains("<string>/srv/R&amp;D/logs/supervisor.log</string>"));
}
}
+12
View File
@@ -38,3 +38,15 @@ Scripts and AI agents
horizon-ctl mcp is an MCP server for AI agents (stdio; add it to your MCP
client as the command horizon-ctl with the argument mcp). It finds the game
beside it or the version the launcher installed.
Running a server
horizon-server, in this folder, hosts a server with this game as its engine,
using the resources prepared above:
./horizon-server --dir my-server init the EULA, world, seed, port, who may join
./horizon-server --dir my-server start in the background; also stop, restart
./horizon-server --dir my-server status TPS, MSPT, players, RAM and CPU
./horizon-server --dir my-server cmd list
./horizon-server --dir my-server backup also backups, restore
./horizon-server --dir my-server service install start it at boot or login
Its settings are in my-server/server.toml. ./horizon-server help lists every
command; docs/server.md in the repository has the details.
+40
View File
@@ -0,0 +1,40 @@
# horizon-server in a container (docs/server.md, section 3). Build context: the repository root:
# docker build -f packaging/server/Dockerfile -t horizon-server .
#
# The image holds none of Minecraft's files. Prepare them on the host from your own Minecraft 26.3
# (horizon-prepare --prepare, see packaging/PLAY.txt) and mount the folder it writes, read-only:
# docker run -d --name horizon -p 25565:25565 --stop-timeout 180 \
# -v horizon-data:/data \
# -v /path/to/.local/horizon-client/26.3:/opt/horizon/.local/horizon-client/26.3:ro \
# -e HORIZON_EULA=true -e HORIZON_WHITELIST=true -e HORIZON_PLAYERS=Alex,Steve -e HORIZON_OP=Alex \
# horizon-server
#
# HORIZON_EULA=true accepts the Minecraft EULA (https://aka.ms/MinecraftEULA) for this server. The first
# start writes /data/server.toml from HORIZON_* (EULA, WORLD, SEED, PORT, WHITELIST, PLAYERS, OP); later
# starts use the file. Manage it with `docker exec horizon horizon-server status|cmd|backup|logs ...`.
FROM rust:1-slim-bookworm AS build
RUN apt-get update \
&& apt-get install -y --no-install-recommends pkg-config libasound2-dev libudev-dev \
&& rm -rf /var/lib/apt/lists/*
WORKDIR /src
COPY . .
RUN cargo build --release --locked -p horizon-client --bin horizon-client -p horizon-server --bin horizon-server \
&& mkdir /out && cp target/release/horizon-client target/release/horizon-server /out/
FROM debian:bookworm-slim
# The game links ALSA and udev even when it runs headless with no sound.
RUN apt-get update \
&& apt-get install -y --no-install-recommends libasound2 libudev1 \
&& rm -rf /var/lib/apt/lists/* \
&& useradd --system --home-dir /data --shell /usr/sbin/nologin horizon \
&& mkdir -p /data /opt/horizon/.local/horizon-client \
&& chown horizon:horizon /data
COPY --from=build /out/ /opt/horizon/
ENV PATH=/opt/horizon:$PATH \
HORIZON_NO_AUDIO=1
WORKDIR /data
VOLUME /data
EXPOSE 25565
USER horizon
# SIGTERM makes horizon-server stop the game cleanly (it saves first): give it --stop-timeout 180.
CMD ["sh", "-c", "test -f server.toml || horizon-server init --yes || exit 1; exec horizon-server run"]
+79
View File
@@ -0,0 +1,79 @@
# Installs horizon-server (docs/server.md) on Windows: the latest Horizon release, downloaded from GitHub
# Releases and checked against the SHA-256 GitHub publishes for it.
#
# irm https://raw.githubusercontent.com/ludovic111/horizon/main/packaging/server/install.ps1 | iex
# & ([scriptblock]::Create((irm .../install.ps1))) -Version v0.5.0 -Dir D:\Horizon
#
# Releases go to <Dir>\releases\<version>, <Dir>\current points at the one in use, and <Dir>\bin (added to
# your PATH) holds horizon-server.cmd and horizon-prepare.cmd. The game files you prepare from your own
# Minecraft stay in <Dir>\game-files across updates. Nothing of Mojang's is downloaded. No admin rights.
param(
[string]$Version = "latest",
[string]$Dir = (Join-Path $env:LOCALAPPDATA "Horizon")
)
$ErrorActionPreference = "Stop"
$ProgressPreference = "SilentlyContinue"
$Repo = "ludovic111/horizon"
$Asset = "horizon-windows-x64.zip"
if ($env:PROCESSOR_ARCHITECTURE -ne "AMD64") {
throw "No Horizon release for Windows on $env:PROCESSOR_ARCHITECTURE yet: build it from source (docs/server.md)"
}
$Api = if ($Version -eq "latest") { "https://api.github.com/repos/$Repo/releases/latest" }
else { "https://api.github.com/repos/$Repo/releases/tags/$Version" }
$Release = Invoke-RestMethod -Uri $Api -Headers @{ Accept = "application/vnd.github+json" }
$Tag = $Release.tag_name
$Item = $Release.assets | Where-Object { $_.name -eq $Asset } | Select-Object -First 1
if (-not $Item) { throw "Release $Tag has no $Asset" }
if (-not $Item.digest -or -not $Item.digest.StartsWith("sha256:")) { throw "Release $Tag publishes no SHA-256 for $Asset" }
$Digest = $Item.digest.Substring(7)
$Tmp = Join-Path ([IO.Path]::GetTempPath()) ("horizon-install-" + [Guid]::NewGuid())
New-Item -ItemType Directory -Path $Tmp | Out-Null
try {
Write-Host "Downloading Horizon $Tag ($Asset)..."
$Zip = Join-Path $Tmp $Asset
Invoke-WebRequest -Uri $Item.browser_download_url -OutFile $Zip
$Got = (Get-FileHash -Algorithm SHA256 $Zip).Hash.ToLowerInvariant()
if ($Got -ne $Digest.ToLowerInvariant()) {
throw "$Asset doesn't match its SHA-256 (got $Got, expected $Digest): not installed"
}
$Unpacked = Join-Path $Tmp "x"
Expand-Archive -Path $Zip -DestinationPath $Unpacked
$Server = Get-ChildItem -Path $Unpacked -Recurse -Filter "horizon-server.exe" | Select-Object -First 1
if (-not $Server) { throw "$Asset holds no horizon-server.exe (a release from before it existed?)" }
$Releases = Join-Path $Dir "releases"
$GameFiles = Join-Path $Dir "game-files\horizon-client"
$Bin = Join-Path $Dir "bin"
New-Item -ItemType Directory -Force -Path $Releases, $GameFiles, $Bin | Out-Null
$Target = Join-Path $Releases $Tag
if (Test-Path $Target) { Remove-Item -Recurse -Force $Target }
Move-Item -Path $Server.Directory.FullName -Destination $Target
# Prepared game files live outside the release, so updates and rollbacks keep them. Junctions need no
# admin rights, unlike symbolic links.
$Local = Join-Path $Target ".local"
New-Item -ItemType Directory -Force -Path $Local | Out-Null
New-Item -ItemType Junction -Path (Join-Path $Local "horizon-client") -Target $GameFiles | Out-Null
$Current = Join-Path $Dir "current"
if (Test-Path $Current) { (Get-Item $Current).Delete() }
New-Item -ItemType Junction -Path $Current -Target $Target | Out-Null
foreach ($Tool in "horizon-server", "horizon-prepare") {
Set-Content -Path (Join-Path $Bin "$Tool.cmd") -Encoding ASCII -Value "@`"$Current\$Tool.exe`" %*"
}
$UserPath = [Environment]::GetEnvironmentVariable("Path", "User")
if (-not (($UserPath -split ";") -contains $Bin)) {
[Environment]::SetEnvironmentVariable("Path", ($UserPath.TrimEnd(";") + ";" + $Bin).TrimStart(";"), "User")
Write-Host "Added $Bin to your PATH: open a new terminal to use it."
}
Write-Host "Installed Horizon $Tag in $Target."
if (-not (Get-ChildItem -Path $GameFiles -ErrorAction SilentlyContinue)) {
Write-Host "Next, prepare the game files from your own Minecraft 26.3 (it needs Java 25 and the game installed"
Write-Host "once by the official launcher; see docs/server.md):"
Write-Host " horizon-prepare --prepare --server-jar C:\path\to\server.jar"
}
Write-Host "Then set up a server: mkdir my-server; cd my-server; horizon-server init"
} finally {
Remove-Item -Recurse -Force $Tmp -ErrorAction SilentlyContinue
}
+98
View File
@@ -0,0 +1,98 @@
#!/bin/sh
# Installs horizon-server (docs/server.md) on Linux or macOS: the latest Horizon release for this computer,
# downloaded from GitHub Releases and checked against the SHA-256 GitHub publishes for it.
#
# curl -fsSL https://raw.githubusercontent.com/ludovic111/horizon/main/packaging/server/install.sh | sh
# curl -fsSL .../install.sh | sh -s -- --version v0.5.0 --dir /opt/horizon --bin /usr/local/bin
#
# It needs curl, tar or unzip, and sha256sum or shasum; it never asks for sudo (pick folders you can write).
# Releases go to <dir>/releases/<version>, <dir>/current points at the one in use, and <bin>/horizon-server
# runs it. The game files you prepare from your own Minecraft stay in <dir>/game-files across updates.
# Nothing of Mojang's is downloaded.
set -eu
REPO=ludovic111/horizon
VERSION=latest
DIR="${XDG_DATA_HOME:-$HOME/.local/share}/horizon"
BIN="$HOME/.local/bin"
die() { echo "horizon install: $*" >&2; exit 1; }
while [ $# -gt 0 ]; do
case "$1" in
--version) [ $# -ge 2 ] || die "--version needs a tag"; VERSION=$2; shift 2 ;;
--dir) [ $# -ge 2 ] || die "--dir needs a folder"; DIR=$2; shift 2 ;;
--bin) [ $# -ge 2 ] || die "--bin needs a folder"; BIN=$2; shift 2 ;;
-h|--help) sed -n '2,12p' "$0" 2>/dev/null || true; exit 0 ;;
*) die "unknown option $1" ;;
esac
done
case "$(uname -s)-$(uname -m)" in
Linux-x86_64) ASSET=horizon-linux-x86_64.tar.gz ;;
Darwin-arm64) ASSET=horizon-macos-arm64.zip ;;
*) die "no Horizon release for $(uname -s) $(uname -m) yet: build it from source (docs/server.md)" ;;
esac
command -v curl >/dev/null || die "curl is needed"
if command -v sha256sum >/dev/null; then SHA="sha256sum"
elif command -v shasum >/dev/null; then SHA="shasum -a 256"
else die "sha256sum or shasum is needed"; fi
if [ "$VERSION" = latest ]; then API="https://api.github.com/repos/$REPO/releases/latest"
else API="https://api.github.com/repos/$REPO/releases/tags/$VERSION"; fi
JSON=$(curl -fsSL -H "Accept: application/vnd.github+json" "$API") || die "no release $VERSION on GitHub"
TAG=$(printf '%s\n' "$JSON" | sed -n 's/^ "tag_name": "\([^"]*\)".*/\1/p' | head -n 1)
[ -n "$TAG" ] || die "could not read the release's tag"
# The asset's download address and digest, from its block in the release's JSON.
FIELDS=$(printf '%s\n' "$JSON" | awk -v asset="$ASSET" '
/"name": / { line = $0; sub(/.*"name": "/, "", line); sub(/".*/, "", line); current = line }
current == asset && /"digest": / { line = $0; sub(/.*"digest": "sha256:/, "", line); sub(/".*/, "", line); digest = line }
current == asset && /"browser_download_url": / { line = $0; sub(/.*"browser_download_url": "/, "", line); sub(/".*/, "", line); url = line }
END { print url; print digest }')
URL=$(printf '%s\n' "$FIELDS" | sed -n 1p)
DIGEST=$(printf '%s\n' "$FIELDS" | sed -n 2p)
[ -n "$URL" ] || die "release $TAG has no $ASSET"
[ -n "$DIGEST" ] || die "release $TAG publishes no SHA-256 for $ASSET"
TMP=$(mktemp -d)
trap 'rm -rf "$TMP"' EXIT
echo "Downloading Horizon $TAG ($ASSET)..."
curl -fL --progress-bar -o "$TMP/$ASSET" "$URL"
GOT=$($SHA "$TMP/$ASSET" | cut -d' ' -f1)
[ "$GOT" = "$DIGEST" ] || die "$ASSET doesn't match its SHA-256 (got $GOT, expected $DIGEST): not installed"
mkdir -p "$TMP/x"
case "$ASSET" in
*.tar.gz) tar -xzf "$TMP/$ASSET" -C "$TMP/x" ;;
*.zip) command -v unzip >/dev/null || die "unzip is needed"; unzip -q "$TMP/$ASSET" -d "$TMP/x" ;;
esac
SOURCE=$(dirname "$(find "$TMP/x" -name horizon-server -type f | head -n 1)")
[ -x "$SOURCE/horizon-server" ] || die "$ASSET holds no horizon-server (a release from before it existed?)"
RELEASE="$DIR/releases/$TAG"
mkdir -p "$DIR/releases" "$DIR/game-files/horizon-client" "$BIN"
rm -rf "$RELEASE"
mv "$SOURCE" "$RELEASE"
# Prepared game files live outside the release, so updates and rollbacks keep them.
mkdir -p "$RELEASE/.local"
ln -sfn "$DIR/game-files/horizon-client" "$RELEASE/.local/horizon-client"
ln -sfn "$RELEASE" "$DIR/current"
# Small launchers rather than links: the programs find their release folder from where they run.
for tool in horizon-server horizon-prepare; do
printf '#!/bin/sh\nexec "%s/current/%s" "$@"\n' "$DIR" "$tool" > "$BIN/$tool"
chmod +x "$BIN/$tool"
done
echo "Installed Horizon $TAG in $RELEASE; horizon-server and horizon-prepare are in $BIN."
case ":$PATH:" in
*":$BIN:"*) ;;
*) echo "Add $BIN to your PATH, for example: echo 'export PATH=\"$BIN:\$PATH\"' >> ~/.profile" ;;
esac
if [ -z "$(ls -A "$DIR/game-files/horizon-client" 2>/dev/null)" ]; then
echo "Next, prepare the game files from your own Minecraft 26.3 (it needs Java 25 and the game installed once"
echo "by the official launcher; see docs/server.md):"
echo " horizon-prepare --prepare --server-jar /path/to/server.jar"
fi
echo "Then set up a server: mkdir my-server && cd my-server && horizon-server init"
+8 -7
View File
@@ -1,8 +1,8 @@
//! Repository tasks, run with `cargo run -p xtask -- TASK`.
//!
//! `package BINARY OUTDIR`: a playable Horizon folder with the game binary, horizon-ctl and
//! horizon-prepare (built beside it: cargo build --release -p horizon-client --bins -p
//! horizon-prepare), the exporters horizon-prepare compiles, its sources (the launcher compares
//! `package BINARY OUTDIR`: a playable Horizon folder with the game binary, horizon-ctl,
//! horizon-prepare and horizon-server (built beside it: cargo build --release -p horizon-client
//! --bins -p horizon-prepare -p horizon-server), the exporters horizon-prepare compiles, its sources (the launcher compares
//! them to its own), and PLAY.txt. It holds none of Minecraft's files: players prepare those
//! from their own copy. .github/workflows/release.yml makes the release folders with it.
//!
@@ -29,9 +29,10 @@ const ARCHIVED: [&str; 5] = [
];
/// The programs that sit beside the client: horizon-ctl, the command line and MCP server that
/// play the game, and horizon-prepare, which prepares the resources from the player's own
/// Minecraft.
const TOOLS: [&str; 2] = ["horizon-ctl", "horizon-prepare"];
/// play the game, horizon-prepare, which prepares the resources from the player's own
/// Minecraft, and horizon-server, which hosts a server with the client as its engine
/// (docs/server.md).
const TOOLS: [&str; 3] = ["horizon-ctl", "horizon-prepare", "horizon-server"];
fn main() -> ExitCode {
let args: Vec<String> = std::env::args().skip(1).collect();
@@ -234,7 +235,7 @@ fn package(binary: &Path, out: &Path) -> Result<(), String> {
let path = binary.parent().unwrap_or(Path::new("")).join(name);
if !path.is_file() {
return Err(format!(
"{} is missing; build it too: cargo build --release -p horizon-client --bins -p horizon-prepare",
"{} is missing; build it too: cargo build --release -p horizon-client --bins -p horizon-prepare -p horizon-server",
path.display()
));
}