561efb340e
Prepare used to stop with "Minecraft 26.3 is not in <dir>. Play 26.3 once from
the official launcher, or choose another folder." followed by an unrelated log
line ("Checking Java and your Minecraft install"). It now lists every folder it
looked in with what each one lacks (no such folder, no versions/26.3/26.3.json,
no 26.3.jar) and the two ways out, one per line. A missing client jar is caught
here too, instead of later inside horizon-prepare.
Only a preparer process's "Exited with ..." gets the last log line appended;
the launcher's own errors are full sentences.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2271 lines
87 KiB
Rust
2271 lines
87 KiB
Rust
//! Everything that is not UI: GitHub, installs, resource preparation, the game's processes and
|
||
//! updates. The GUI, the CLI and the MCP server all go through this module. Functions here
|
||
//! block; the GUI runs them on threads and reads their messages.
|
||
use std::fs;
|
||
use std::io::{BufRead, BufReader, Read, Write};
|
||
use std::path::{Path, PathBuf};
|
||
use std::process::{Child, ChildStdin, Command, Stdio};
|
||
use std::sync::mpsc::Sender;
|
||
use std::sync::{Arc, Mutex};
|
||
|
||
pub const REPO: &str = "ludovic111/horizon";
|
||
pub const README_URL: &str = "https://github.com/ludovic111/horizon/blob/main/launcher/README.md";
|
||
/// This launcher's version: the release workflow sets `HORIZON_LAUNCHER_VERSION` from the
|
||
/// `launcher-vX.Y.Z` tag it builds (no version-bump commits); other builds say Cargo.toml's.
|
||
pub const VERSION: &str = version_or(option_env!("HORIZON_LAUNCHER_VERSION"));
|
||
/// Launcher releases are tagged `launcher-vX.Y.Z`; Horizon's own are `vYYYY.MM.DD`.
|
||
pub const LAUNCHER_TAG_PREFIX: &str = "launcher-v";
|
||
|
||
const fn version_or(injected: Option<&'static str>) -> &'static str {
|
||
match injected {
|
||
Some(v) if !v.is_empty() => v,
|
||
_ => env!("CARGO_PKG_VERSION"),
|
||
}
|
||
}
|
||
|
||
#[derive(Clone, Debug, serde::Serialize)]
|
||
pub struct Release {
|
||
pub tag: String,
|
||
pub name: String,
|
||
pub body: String,
|
||
pub date: String,
|
||
pub asset: Option<(String, u64)>,
|
||
}
|
||
|
||
#[cfg(all(target_os = "linux", target_arch = "x86_64"))]
|
||
pub const ASSET: Option<&str> = Some("horizon-linux-x86_64.tar.gz");
|
||
#[cfg(all(target_os = "macos", target_arch = "aarch64"))]
|
||
pub const ASSET: Option<&str> = Some("horizon-macos-arm64.zip");
|
||
#[cfg(all(target_os = "windows", target_arch = "x86_64"))]
|
||
pub const ASSET: Option<&str> = Some("horizon-windows-x64.zip");
|
||
#[cfg(not(any(
|
||
all(target_os = "linux", target_arch = "x86_64"),
|
||
all(target_os = "macos", target_arch = "aarch64"),
|
||
all(target_os = "windows", target_arch = "x86_64")
|
||
)))]
|
||
pub const ASSET: Option<&str> = None;
|
||
|
||
#[cfg(all(target_os = "linux", target_arch = "x86_64"))]
|
||
pub const LAUNCHER_ASSET: Option<&str> = Some("horizon-launcher-linux-x86_64.tar.gz");
|
||
#[cfg(all(target_os = "macos", target_arch = "aarch64"))]
|
||
pub const LAUNCHER_ASSET: Option<&str> = Some("horizon-launcher-macos-arm64.zip");
|
||
#[cfg(all(target_os = "windows", target_arch = "x86_64"))]
|
||
pub const LAUNCHER_ASSET: Option<&str> = Some("horizon-launcher-windows-x64.zip");
|
||
#[cfg(not(any(
|
||
all(target_os = "linux", target_arch = "x86_64"),
|
||
all(target_os = "macos", target_arch = "aarch64"),
|
||
all(target_os = "windows", target_arch = "x86_64")
|
||
)))]
|
||
pub const LAUNCHER_ASSET: Option<&str> = None;
|
||
|
||
const LAUNCHER_BINARY: &str = if cfg!(windows) {
|
||
"horizon-launcher.exe"
|
||
} else {
|
||
"horizon-launcher"
|
||
};
|
||
|
||
const CLIENT: &str = if cfg!(windows) {
|
||
"horizon-client.exe"
|
||
} else {
|
||
"horizon-client"
|
||
};
|
||
|
||
fn agent() -> ureq::Agent {
|
||
ureq::AgentBuilder::new()
|
||
.user_agent(&format!("horizon-launcher/{VERSION}"))
|
||
.build()
|
||
}
|
||
|
||
fn get(url: &str) -> Result<ureq::Response, String> {
|
||
let mut request = agent().get(url);
|
||
// CI runners share addresses and hit GitHub's anonymous rate limit; they pass their own token.
|
||
if let Some(token) = std::env::var("HORIZON_GITHUB_TOKEN")
|
||
.ok()
|
||
.filter(|t| !t.is_empty())
|
||
{
|
||
if url.starts_with("https://api.github.com/") {
|
||
request = request.set("Authorization", &format!("Bearer {token}"));
|
||
}
|
||
}
|
||
request.call().map_err(|e| match e {
|
||
ureq::Error::Status(403, _) => {
|
||
"GitHub's rate limit was reached. Try again in a few minutes.".into()
|
||
}
|
||
ureq::Error::Status(code, _) => format!("{url} answered {code}"),
|
||
ureq::Error::Transport(t) => format!("No connection: {t}"),
|
||
})
|
||
}
|
||
|
||
/// A Horizon game tag: `v` then a digit (`v2026.10.13`). Launcher tags never match.
|
||
pub fn is_game_tag(tag: &str) -> bool {
|
||
tag.strip_prefix('v')
|
||
.is_some_and(|rest| rest.starts_with(|c: char| c.is_ascii_digit()))
|
||
}
|
||
|
||
/// The launcher version in a `launcher-vX.Y.Z` tag, or None for any other tag.
|
||
pub fn launcher_version(tag: &str) -> Option<&str> {
|
||
tag.strip_prefix(LAUNCHER_TAG_PREFIX)
|
||
.filter(|v| v.starts_with(|c: char| c.is_ascii_digit()))
|
||
}
|
||
|
||
/// The numeric parts of a version or tag: `v2026.10.13` and `2026.10.13` give [2026, 10, 13].
|
||
/// Anything after a `-` (a pre-release) is ignored.
|
||
fn version_parts(v: &str) -> Vec<u64> {
|
||
let v = v
|
||
.trim_start_matches(LAUNCHER_TAG_PREFIX)
|
||
.trim_start_matches('v');
|
||
v.split('-')
|
||
.next()
|
||
.unwrap_or("")
|
||
.split('.')
|
||
.map(|p| p.parse().unwrap_or(0))
|
||
.collect()
|
||
}
|
||
|
||
/// Compares two versions part by part, missing parts counting as zero (1.2 == 1.2.0).
|
||
pub fn compare_versions(a: &str, b: &str) -> std::cmp::Ordering {
|
||
let (a, b) = (version_parts(a), version_parts(b));
|
||
(0..a.len().max(b.len()))
|
||
.map(|i| a.get(i).unwrap_or(&0).cmp(b.get(i).unwrap_or(&0)))
|
||
.find(|o| o.is_ne())
|
||
.unwrap_or(std::cmp::Ordering::Equal)
|
||
}
|
||
|
||
/// Every published release of the repository, both kinds, as GitHub's JSON.
|
||
fn release_list() -> Result<serde_json::Value, String> {
|
||
let url = format!("https://api.github.com/repos/{REPO}/releases?per_page=100");
|
||
get(&url)?.into_json().map_err(|e| e.to_string())
|
||
}
|
||
|
||
/// The releases in `list` whose tag passes `keep`, newest first, with the asset named `asset`.
|
||
fn parse_releases(
|
||
list: &serde_json::Value,
|
||
asset: Option<&str>,
|
||
keep: fn(&str) -> bool,
|
||
) -> Vec<Release> {
|
||
let mut out = Vec::new();
|
||
for r in list.as_array().into_iter().flatten() {
|
||
let tag = r["tag_name"].as_str().unwrap_or_default();
|
||
if r["draft"].as_bool().unwrap_or(false) || !keep(tag) {
|
||
continue;
|
||
}
|
||
let found = r["assets"].as_array().into_iter().flatten().find_map(|a| {
|
||
(Some(a["name"].as_str()?) == asset).then(|| {
|
||
Some((
|
||
a["browser_download_url"].as_str()?.to_string(),
|
||
a["size"].as_u64()?,
|
||
))
|
||
})?
|
||
});
|
||
out.push(Release {
|
||
tag: tag.into(),
|
||
name: r["name"].as_str().unwrap_or_default().into(),
|
||
body: r["body"].as_str().unwrap_or_default().replace("\r\n", "\n"),
|
||
date: r["published_at"]
|
||
.as_str()
|
||
.unwrap_or_default()
|
||
.chars()
|
||
.take(10)
|
||
.collect(),
|
||
asset: found,
|
||
});
|
||
}
|
||
out.sort_by(|a, b| compare_versions(&b.tag, &a.tag));
|
||
out
|
||
}
|
||
|
||
fn is_launcher_tag(tag: &str) -> bool {
|
||
launcher_version(tag).is_some()
|
||
}
|
||
|
||
/// Published Horizon releases, newest first. Drafts never reach the anonymous API, and launcher
|
||
/// releases are left out.
|
||
pub fn releases() -> Result<Vec<Release>, String> {
|
||
Ok(parse_releases(&release_list()?, ASSET, is_game_tag))
|
||
}
|
||
|
||
/// Published launcher releases (`launcher-v…`), newest first, with this platform's archive.
|
||
pub fn launcher_releases() -> Result<Vec<Release>, String> {
|
||
Ok(launcher_releases_in(&release_list()?))
|
||
}
|
||
|
||
/// The launcher releases in `list` (the newest 100 releases). Game releases come out several times
|
||
/// a day, so the newest launcher release can be older than all of those: then the newest
|
||
/// `launcher-v` tags are looked up one by one (a draft's tag is skipped: it has no public release).
|
||
fn launcher_releases_in(list: &serde_json::Value) -> Vec<Release> {
|
||
launcher_releases_in_with(list, |url| {
|
||
get(&url)?.into_json().map_err(|e| e.to_string())
|
||
})
|
||
}
|
||
|
||
fn launcher_releases_in_with(
|
||
list: &serde_json::Value,
|
||
json: impl Fn(String) -> Result<serde_json::Value, String>,
|
||
) -> Vec<Release> {
|
||
let found = parse_releases(list, LAUNCHER_ASSET, is_launcher_tag);
|
||
if found.iter().any(|r| r.asset.is_some()) {
|
||
return found;
|
||
}
|
||
let api = format!("https://api.github.com/repos/{REPO}");
|
||
let Ok(refs) = json(format!(
|
||
"{api}/git/matching-refs/tags/{LAUNCHER_TAG_PREFIX}"
|
||
)) else {
|
||
return found;
|
||
};
|
||
for tag in newest_launcher_tags(&refs).into_iter().take(3) {
|
||
if let Ok(release) = json(format!("{api}/releases/tags/{tag}")) {
|
||
let one = parse_releases(
|
||
&serde_json::json!([release]),
|
||
LAUNCHER_ASSET,
|
||
is_launcher_tag,
|
||
);
|
||
if one.iter().any(|r| r.asset.is_some()) {
|
||
return one;
|
||
}
|
||
}
|
||
}
|
||
found
|
||
}
|
||
|
||
/// The `launcher-vX.Y.Z` tags in GitHub's matching-refs answer, newest first.
|
||
fn newest_launcher_tags(refs: &serde_json::Value) -> Vec<String> {
|
||
let mut tags: Vec<String> = refs
|
||
.as_array()
|
||
.into_iter()
|
||
.flatten()
|
||
.filter_map(|r| r["ref"].as_str()?.strip_prefix("refs/tags/"))
|
||
.filter(|t| is_launcher_tag(t))
|
||
.map(String::from)
|
||
.collect();
|
||
tags.sort_by(|a, b| compare_versions(b, a));
|
||
tags
|
||
}
|
||
|
||
/// The newest Horizon release that has a build for this platform.
|
||
pub fn latest(releases: &[Release]) -> Option<&Release> {
|
||
releases.iter().find(|r| r.asset.is_some())
|
||
}
|
||
|
||
/// The community, sponsor and website links, from `launcher/links.json` on main, so they can change
|
||
/// without a launcher release. An empty address hides its button.
|
||
#[derive(Clone, Debug, PartialEq, serde::Serialize)]
|
||
pub struct Links {
|
||
pub discord: String,
|
||
pub sponsor: String,
|
||
pub website: String,
|
||
}
|
||
|
||
impl Default for Links {
|
||
/// What the launcher uses until (or unless) it can read links.json.
|
||
fn default() -> Self {
|
||
Self {
|
||
discord: "https://discord.gg/HcTeMZxe5E".into(),
|
||
sponsor: "https://github.com/sponsors/ludovic111".into(),
|
||
website: "https://playhorizon.dev".into(),
|
||
}
|
||
}
|
||
}
|
||
|
||
impl Links {
|
||
/// Reads links.json. A key that is missing keeps its default, an empty one hides the link,
|
||
/// and text that is not a JSON object gives the defaults.
|
||
pub fn parse(text: &str) -> Self {
|
||
let mut links = Self::default();
|
||
if let Ok(serde_json::Value::Object(map)) = serde_json::from_str(text) {
|
||
for (key, slot) in [
|
||
("discord", &mut links.discord),
|
||
("sponsor", &mut links.sponsor),
|
||
("website", &mut links.website),
|
||
] {
|
||
if let Some(url) = map.get(key).and_then(|v| v.as_str()) {
|
||
*slot = url.trim().to_string();
|
||
}
|
||
}
|
||
}
|
||
links
|
||
}
|
||
}
|
||
|
||
/// The links from main, or the built-in ones when offline.
|
||
pub fn links() -> Links {
|
||
let url = format!("https://raw.githubusercontent.com/{REPO}/main/launcher/links.json");
|
||
get(&url)
|
||
.ok()
|
||
.and_then(|r| r.into_string().ok())
|
||
.map_or_else(Links::default, |text| Links::parse(&text))
|
||
}
|
||
|
||
/// The launcher's data folder; `HORIZON_LAUNCHER_HOME` overrides it (for tests and scripts).
|
||
pub fn data_dir() -> PathBuf {
|
||
if let Some(home) = std::env::var_os("HORIZON_LAUNCHER_HOME").filter(|h| !h.is_empty()) {
|
||
return PathBuf::from(home);
|
||
}
|
||
dirs::data_dir()
|
||
.unwrap_or_else(std::env::temp_dir)
|
||
.join("horizon-launcher")
|
||
}
|
||
|
||
fn versions_dir() -> PathBuf {
|
||
data_dir().join("versions")
|
||
}
|
||
|
||
pub fn version_dir(tag: &str) -> PathBuf {
|
||
versions_dir().join(tag)
|
||
}
|
||
|
||
const COMPLETE: &str = ".installed";
|
||
|
||
/// Installed versions, newest tag first.
|
||
pub fn installed() -> Vec<String> {
|
||
installed_in(&versions_dir())
|
||
}
|
||
|
||
fn installed_in(versions: &Path) -> Vec<String> {
|
||
let mut tags: Vec<String> = fs::read_dir(versions)
|
||
.into_iter()
|
||
.flatten()
|
||
.flatten()
|
||
.filter(|e| e.path().join(COMPLETE).exists())
|
||
.filter_map(|e| e.file_name().into_string().ok())
|
||
.collect();
|
||
tags.sort_by(|a, b| compare_versions(b, a));
|
||
tags
|
||
}
|
||
|
||
fn download(url: &str, size: u64, to: &Path, progress: &impl Fn(f32)) -> Result<(), String> {
|
||
let mut reader = get(url)?.into_reader();
|
||
let mut file = fs::File::create(to).map_err(|e| e.to_string())?;
|
||
let (mut done, mut buf) = (0u64, vec![0u8; 1 << 16]);
|
||
loop {
|
||
let n = reader
|
||
.read(&mut buf)
|
||
.map_err(|e| format!("Download interrupted: {e}"))?;
|
||
if n == 0 {
|
||
return Ok(());
|
||
}
|
||
file.write_all(&buf[..n]).map_err(|e| e.to_string())?;
|
||
done += n as u64;
|
||
progress((done as f32 / size.max(1) as f32).min(1.0) * 0.9);
|
||
}
|
||
}
|
||
|
||
fn unpack(archive: &Path, url: &str, to: &Path) -> Result<(), String> {
|
||
let file = fs::File::open(archive).map_err(|e| e.to_string())?;
|
||
if url.ends_with(".tar.gz") {
|
||
tar::Archive::new(flate2::read::GzDecoder::new(file))
|
||
.unpack(to)
|
||
.map_err(|e| e.to_string())
|
||
} else {
|
||
zip::ZipArchive::new(file)
|
||
.and_then(|mut z| z.extract(to))
|
||
.map_err(|e| e.to_string())
|
||
}
|
||
}
|
||
|
||
/// Downloads and unpacks one release; `progress` gets the fraction done.
|
||
pub fn install(tag: &str, url: &str, size: u64, progress: impl Fn(f32)) -> Result<(), String> {
|
||
if !is_game_tag(tag) {
|
||
return Err(format!("{tag} is not a Horizon release."));
|
||
}
|
||
let root = versions_dir();
|
||
let partial = root.join(format!(".{tag}.partial"));
|
||
let _ = fs::remove_dir_all(&partial);
|
||
fs::create_dir_all(&partial).map_err(|e| e.to_string())?;
|
||
let archive = partial.join("download");
|
||
download(url, size, &archive, &progress)?;
|
||
let unpacked = partial.join("unpacked");
|
||
unpack(&archive, url, &unpacked)?;
|
||
progress(0.97);
|
||
// The archives hold one top folder (horizon-linux-x86_64/...); the version folder is its contents.
|
||
let entries: Vec<_> = fs::read_dir(&unpacked)
|
||
.map_err(|e| e.to_string())?
|
||
.flatten()
|
||
.collect();
|
||
let top = match entries.as_slice() {
|
||
[only] if only.path().is_dir() => only.path(),
|
||
_ => unpacked.clone(),
|
||
};
|
||
if !top.join(CLIENT).exists() {
|
||
return Err(format!("The download has no {CLIENT}"));
|
||
}
|
||
#[cfg(unix)]
|
||
{
|
||
use std::os::unix::fs::PermissionsExt;
|
||
let _ = fs::set_permissions(top.join(CLIENT), fs::Permissions::from_mode(0o755));
|
||
}
|
||
let target = version_dir(tag);
|
||
let _ = fs::remove_dir_all(&target);
|
||
fs::rename(&top, &target).map_err(|e| e.to_string())?;
|
||
fs::write(target.join(COMPLETE), "").map_err(|e| e.to_string())?;
|
||
let _ = fs::remove_dir_all(&partial);
|
||
reuse_prepared(&root, tag);
|
||
progress(1.0);
|
||
Ok(())
|
||
}
|
||
|
||
pub fn remove(tag: &str) -> Result<(), String> {
|
||
fs::remove_dir_all(version_dir(tag)).map_err(|e| e.to_string())
|
||
}
|
||
|
||
/// The Minecraft version a Horizon build targets, from its research-lock.json.
|
||
pub fn game_version(tag: &str) -> String {
|
||
game_version_at(&version_dir(tag))
|
||
}
|
||
|
||
fn read_json(path: &Path) -> Option<serde_json::Value> {
|
||
serde_json::from_str(&fs::read_to_string(path).ok()?).ok()
|
||
}
|
||
|
||
fn game_version_at(dir: &Path) -> String {
|
||
read_json(&dir.join("research-lock.json"))
|
||
.and_then(|v| v["minecraft"]["version"].as_str().map(String::from))
|
||
.unwrap_or_else(|| "26.3".into())
|
||
}
|
||
|
||
pub fn resources(tag: &str) -> PathBuf {
|
||
resources_at(&version_dir(tag))
|
||
}
|
||
|
||
fn resources_at(dir: &Path) -> PathBuf {
|
||
dir.join(".local/horizon-client").join(game_version_at(dir))
|
||
}
|
||
|
||
const RESOURCES_MANIFEST: &str = "horizon-resources.json";
|
||
|
||
pub fn is_prepared(tag: &str) -> bool {
|
||
resources(tag).join(RESOURCES_MANIFEST).exists()
|
||
}
|
||
|
||
/// Whether the resources `from` prepared are the ones preparing `to` would make. The output
|
||
/// depends on the Horizon version, not only on Minecraft's: the manifest records the hashes of
|
||
/// the vanilla exporters it was made with (mods/horizon/src/test/java/.../parity), and the
|
||
/// preparer writes every file and the manifest's `schema`. So both need the same pinned
|
||
/// Minecraft jars (research-lock.json), the same preparer and the same exporter sources. The
|
||
/// preparer is crates/horizon-prepare (its sources ship in the release folder beside the
|
||
/// binary) and tools/prepare_native_client.py (the Python preparer of older versions, a wrapper
|
||
/// of the binary since); a file only one of the two versions has is a different preparer. The
|
||
/// helpers the Python preparer imported (lab.py and the test_*_parity.py modules) change
|
||
/// between releases in how they find and check the player's files, which the output does not
|
||
/// depend on; they are not compared.
|
||
fn resources_compatible(from: &Path, to: &Path, manifest: &serde_json::Value) -> bool {
|
||
let pins = |dir: &Path| {
|
||
read_json(&dir.join("research-lock.json")).map(|lock| {
|
||
["version", "client_sha1", "server_sha1"].map(|k| lock["minecraft"][k].clone())
|
||
})
|
||
};
|
||
let (Some(a), Some(b)) = (pins(from), pins(to)) else {
|
||
return false;
|
||
};
|
||
if a != b || a.iter().any(|v| !v.is_string()) {
|
||
return false;
|
||
}
|
||
let Some(fields) = manifest.as_object() else {
|
||
return false;
|
||
};
|
||
let mut preparer = vec![PathBuf::from("tools/prepare_native_client.py")];
|
||
for dir in [from, to] {
|
||
preparer.extend(files_under(dir, Path::new(PREPARER_CRATE)));
|
||
}
|
||
let same_or_absent = |path: &Path| match (fs::read(from.join(path)), fs::read(to.join(path))) {
|
||
(Ok(a), Ok(b)) => a == b,
|
||
(Err(a), Err(b)) => {
|
||
a.kind() == std::io::ErrorKind::NotFound && b.kind() == std::io::ErrorKind::NotFound
|
||
}
|
||
_ => false,
|
||
};
|
||
if !preparer.iter().all(|p| same_or_absent(p)) {
|
||
return false;
|
||
}
|
||
let mut sources = vec![
|
||
"mods/horizon/src/test/java/dev/horizonlab/parity/VanillaHeightmapOracle.java".to_string(),
|
||
];
|
||
for (_, value) in fields
|
||
.iter()
|
||
.filter(|(key, _)| key.ends_with("_exporters_sha256"))
|
||
{
|
||
let Some(files) = value.as_object() else {
|
||
return false;
|
||
};
|
||
sources.extend(files.keys().cloned());
|
||
}
|
||
let same = |source: &str| {
|
||
let path = Path::new(source);
|
||
path.is_relative()
|
||
&& path
|
||
.components()
|
||
.all(|c| matches!(c, std::path::Component::Normal(_)))
|
||
&& matches!((fs::read(from.join(path)), fs::read(to.join(path))), (Ok(a), Ok(b)) if a == b)
|
||
};
|
||
sources.iter().all(|s| same(s))
|
||
}
|
||
|
||
/// Where a version folder keeps the preparer's sources (the release package copies them).
|
||
const PREPARER_CRATE: &str = "crates/horizon-prepare";
|
||
|
||
/// The files under `dir/relative`, as paths relative to `dir`.
|
||
fn files_under(dir: &Path, relative: &Path) -> Vec<PathBuf> {
|
||
let Ok(entries) = fs::read_dir(dir.join(relative)) else {
|
||
return Vec::new();
|
||
};
|
||
let mut files = Vec::new();
|
||
for entry in entries.flatten() {
|
||
let path = relative.join(entry.file_name());
|
||
match entry.file_type() {
|
||
Ok(t) if t.is_dir() => files.extend(files_under(dir, &path)),
|
||
Ok(_) => files.push(path),
|
||
Err(_) => {}
|
||
}
|
||
}
|
||
files
|
||
}
|
||
|
||
fn copy_dir(from: &Path, to: &Path) -> std::io::Result<()> {
|
||
fs::create_dir_all(to)?;
|
||
for entry in fs::read_dir(from)? {
|
||
let entry = entry?;
|
||
let target = to.join(entry.file_name());
|
||
if entry.file_type()?.is_dir() {
|
||
copy_dir(&entry.path(), &target)?;
|
||
} else {
|
||
fs::copy(entry.path(), target)?;
|
||
}
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
/// After an install: when `tag` is not prepared but another installed version made the same
|
||
/// resources, copies them (not hard links: preparing again rewrites files in place, which would
|
||
/// change both). The player then needs neither their Minecraft folder nor a new preparation to
|
||
/// play a release that only changed Horizon. Returns the version they came from.
|
||
fn reuse_prepared(versions: &Path, tag: &str) -> Option<String> {
|
||
let target = versions.join(tag);
|
||
let to = resources_at(&target);
|
||
if to.join(RESOURCES_MANIFEST).exists() {
|
||
return None;
|
||
}
|
||
let version = game_version_at(&target);
|
||
for other in installed_in(versions).into_iter().filter(|t| t != tag) {
|
||
let source = versions.join(&other);
|
||
if game_version_at(&source) != version {
|
||
continue;
|
||
}
|
||
let from = resources_at(&source);
|
||
let Some(manifest) = read_json(&from.join(RESOURCES_MANIFEST)) else {
|
||
continue;
|
||
};
|
||
if !resources_compatible(&source, &target, &manifest) {
|
||
continue;
|
||
}
|
||
// Copied beside it and renamed when complete: an interrupted copy is never "prepared".
|
||
// The name is this call's own, as the window's start and an install can both copy.
|
||
static COPIES: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
|
||
let n = COPIES.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
|
||
let partial = to.with_file_name(format!(".{version}.partial-{}-{n}", std::process::id()));
|
||
let _ = fs::remove_dir_all(&partial);
|
||
let copied = copy_dir(&from, &partial).and_then(|_| {
|
||
if to.join(RESOURCES_MANIFEST).exists() {
|
||
return Ok(false); // Prepared meanwhile, by another copy or the player.
|
||
}
|
||
let _ = fs::remove_dir_all(&to);
|
||
fs::rename(&partial, &to).map(|_| true)
|
||
});
|
||
let _ = fs::remove_dir_all(&partial);
|
||
match copied {
|
||
Ok(true) => return Some(other),
|
||
Ok(false) => return None,
|
||
Err(_) => {}
|
||
}
|
||
}
|
||
None
|
||
}
|
||
|
||
/// `reuse_prepared` for every installed version that is not prepared, oldest first, so a
|
||
/// version prepared this way can serve the next. Launchers before 0.1.4 installed new versions
|
||
/// without it; this catches those up. Returns each (version, where its resources came from).
|
||
pub fn reuse_prepared_everywhere() -> Vec<(String, String)> {
|
||
reuse_prepared_in(&versions_dir())
|
||
}
|
||
|
||
fn reuse_prepared_in(versions: &Path) -> Vec<(String, String)> {
|
||
let mut tags = installed_in(versions);
|
||
tags.reverse();
|
||
tags.into_iter()
|
||
.filter_map(|tag| reuse_prepared(versions, &tag).map(|from| (tag, from)))
|
||
.collect()
|
||
}
|
||
|
||
/// The official launcher's game directory, where horizon-prepare looks by default.
|
||
pub fn default_minecraft_dir() -> Option<PathBuf> {
|
||
let home = dirs::home_dir()?;
|
||
let dir = if cfg!(target_os = "macos") {
|
||
home.join("Library/Application Support/minecraft")
|
||
} else if cfg!(windows) {
|
||
dirs::config_dir()?.join(".minecraft")
|
||
} else {
|
||
home.join(".minecraft")
|
||
};
|
||
dir.is_dir().then_some(dir)
|
||
}
|
||
|
||
fn found(program: &str, arg: &str) -> bool {
|
||
Command::new(program)
|
||
.arg(arg)
|
||
.stdout(Stdio::null())
|
||
.stderr(Stdio::null())
|
||
.status()
|
||
.is_ok()
|
||
}
|
||
|
||
fn python() -> Option<&'static str> {
|
||
let candidates: &[&'static str] = if cfg!(windows) {
|
||
&["py", "python"]
|
||
} else {
|
||
&["python3", "python"]
|
||
};
|
||
candidates.iter().copied().find(|p| found(p, "--version"))
|
||
}
|
||
|
||
/// How a version's resources are prepared.
|
||
pub enum Preparer {
|
||
/// horizon-prepare, linked into the launcher: the version ships the same preparer sources.
|
||
InProcess(horizon_prepare::Options),
|
||
/// The version's own preparer: its horizon-prepare binary when its sources differ from the
|
||
/// launcher's (a newer or older release), or the Python script of versions made before it.
|
||
Process(Command),
|
||
}
|
||
|
||
/// The version's horizon-prepare binary, when it ships one.
|
||
fn preparer_binary(dir: &Path) -> Option<PathBuf> {
|
||
let binary = dir.join(if cfg!(windows) {
|
||
"horizon-prepare.exe"
|
||
} else {
|
||
"horizon-prepare"
|
||
});
|
||
binary.is_file().then_some(binary)
|
||
}
|
||
|
||
/// What a Minecraft folder lacks of `version`'s files in the official launcher's layout, or
|
||
/// None when it has them.
|
||
fn missing_game_files(minecraft: &Path, version: &str) -> Option<String> {
|
||
if !minecraft.is_dir() {
|
||
return Some("the folder doesn't exist".into());
|
||
}
|
||
let files = [format!("{version}.json"), format!("{version}.jar")];
|
||
let missing: Vec<String> = files
|
||
.iter()
|
||
.filter(|file| {
|
||
!minecraft
|
||
.join("versions")
|
||
.join(version)
|
||
.join(file)
|
||
.is_file()
|
||
})
|
||
.map(|file| format!("versions/{version}/{file}"))
|
||
.collect();
|
||
(!missing.is_empty()).then(|| format!("no {}", missing.join(" or ")))
|
||
}
|
||
|
||
/// The error when no folder has Minecraft `version`: every folder looked in with what it
|
||
/// lacks, and what the player can do about it (#419).
|
||
fn not_found(version: &str, checked: &[(PathBuf, String)]) -> String {
|
||
let mut text = format!("Minecraft {version} was not found. Horizon looked in:");
|
||
for (dir, missing) in checked {
|
||
text += &format!("\n {} ({missing})", dir.display());
|
||
}
|
||
text += &format!(
|
||
"\nTo fix it:\n \
|
||
• Play {version} once in the official Minecraft launcher, then prepare again.\n \
|
||
• Or choose the folder where your launcher keeps Minecraft {version} (Minecraft folder › \
|
||
Choose… in the launcher, --minecraft on the command line)."
|
||
);
|
||
text
|
||
}
|
||
|
||
/// Checks what the preparation needs and picks how to run it. PLAY.txt describes the same
|
||
/// steps: the player's own launcher install, the server jar from that version's own json, and
|
||
/// Java (and Python, for versions before horizon-prepare).
|
||
pub fn preparer(tag: &str, minecraft: &Path, log: &dyn Fn(String)) -> Result<Preparer, String> {
|
||
let version = game_version(tag);
|
||
let dir = version_dir(tag);
|
||
let reused = horizon_prepare::artifacts::reuse_imported(&dir, &|line| log(line.to_string()))?;
|
||
let manifest = minecraft
|
||
.join("versions")
|
||
.join(&version)
|
||
.join(format!("{version}.json"));
|
||
if !reused {
|
||
if let Some(missing) = missing_game_files(minecraft, &version) {
|
||
return Err(not_found(&version, &[(minecraft.to_path_buf(), missing)]));
|
||
}
|
||
}
|
||
let binary = preparer_binary(&dir);
|
||
let python = if binary.is_some() {
|
||
// The JDK the version pins, found as horizon-prepare finds it, so a missing one is
|
||
// reported before the server jar is downloaded.
|
||
let major = read_json(&dir.join("research-lock.json"))
|
||
.and_then(|lock| lock["minecraft"]["java_major"].as_i64())
|
||
.ok_or("The version's research-lock.json has no java_major")?;
|
||
horizon_prepare::java::find(major)?;
|
||
None
|
||
} else {
|
||
let python = python()
|
||
.ok_or("This version prepares with Python: Python 3.10 or newer is needed. Install it, or pick a newer version.")?;
|
||
if !found("java", "-version") {
|
||
return Err(
|
||
"Java 25 is needed (a JDK, e.g. Eclipse Temurin 25). Install it and try again."
|
||
.into(),
|
||
);
|
||
}
|
||
Some(python)
|
||
};
|
||
let jar = data_dir()
|
||
.join("server-jars")
|
||
.join(format!("{version}.jar"));
|
||
if !reused && !jar.exists() {
|
||
let json: serde_json::Value =
|
||
serde_json::from_str(&fs::read_to_string(&manifest).map_err(|e| e.to_string())?)
|
||
.map_err(|e| e.to_string())?;
|
||
let url = json["downloads"]["server"]["url"]
|
||
.as_str()
|
||
.ok_or_else(|| format!("{} has no server download", manifest.display()))?;
|
||
log(format!("Downloading the {version} server jar from Mojang"));
|
||
fs::create_dir_all(jar.parent().unwrap()).map_err(|e| e.to_string())?;
|
||
let mut body = Vec::new();
|
||
get(url)?
|
||
.into_reader()
|
||
.read_to_end(&mut body)
|
||
.map_err(|e| e.to_string())?;
|
||
let partial = jar.with_extension("partial");
|
||
fs::write(&partial, body)
|
||
.and_then(|_| fs::rename(&partial, &jar))
|
||
.map_err(|e| e.to_string())?;
|
||
}
|
||
if let Some(binary) = binary {
|
||
if horizon_prepare::sources_sha256(&dir.join(PREPARER_CRATE)).as_deref()
|
||
== Some(horizon_prepare::SOURCES_SHA256)
|
||
{
|
||
return Ok(Preparer::InProcess(horizon_prepare::Options {
|
||
root: dir,
|
||
import: !reused,
|
||
minecraft_dir: Some(minecraft.to_path_buf()),
|
||
server_jar: (!reused).then_some(jar),
|
||
}));
|
||
}
|
||
let mut cmd = Command::new(binary);
|
||
cmd.current_dir(&dir).arg("--root").arg(&dir);
|
||
if !reused {
|
||
cmd.args(["--prepare", "--server-jar"]).arg(&jar);
|
||
}
|
||
cmd.arg("--minecraft-dir").arg(minecraft);
|
||
return Ok(Preparer::Process(cmd));
|
||
}
|
||
let mut cmd = Command::new(python.unwrap());
|
||
cmd.current_dir(&dir)
|
||
.args(["-u", "tools/prepare_native_client.py"]);
|
||
if !reused {
|
||
cmd.args(["--prepare", "--server-jar"]).arg(&jar);
|
||
}
|
||
cmd.arg("--minecraft-dir").arg(minecraft);
|
||
Ok(Preparer::Process(cmd))
|
||
}
|
||
|
||
/// Copies the pinned version's sounds from the player's own launcher install into the version's
|
||
/// resources (`horizon-prepare sounds`), each line to `log`. Sound is optional, so a launcher
|
||
/// install without them is a line in the log, never a failed preparation. The version's own
|
||
/// preparer does it when it is not the launcher's and knows how; versions from before it read
|
||
/// the sounds where the launcher's preparer puts them.
|
||
pub fn sounds(tag: &str, minecraft: &Path, log: &dyn Fn(String)) {
|
||
let dir = version_dir(tag);
|
||
let own = horizon_prepare::sources_sha256(&dir.join(PREPARER_CRATE)).as_deref()
|
||
== Some(horizon_prepare::SOURCES_SHA256);
|
||
let binary = preparer_binary(&dir).filter(|binary| {
|
||
!own && Command::new(binary)
|
||
.arg("--help")
|
||
.output()
|
||
.is_ok_and(|o| String::from_utf8_lossy(&o.stdout).contains("horizon-prepare sounds"))
|
||
});
|
||
log("Copying the sounds from your Minecraft install".into());
|
||
let result = match binary {
|
||
Some(binary) => Command::new(binary)
|
||
.current_dir(&dir)
|
||
.arg("sounds")
|
||
.arg("--root")
|
||
.arg(&dir)
|
||
.arg("--minecraft-dir")
|
||
.arg(minecraft)
|
||
.output()
|
||
.map_err(|e| e.to_string())
|
||
.and_then(|o| {
|
||
let text = |b: &[u8]| String::from_utf8_lossy(b).trim().to_string();
|
||
for line in text(&o.stdout).lines() {
|
||
log(line.to_string());
|
||
}
|
||
match o.status.success() {
|
||
true => Ok(()),
|
||
false => Err(text(&o.stderr).trim_start_matches("error: ").to_string()),
|
||
}
|
||
}),
|
||
None => std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
|
||
horizon_prepare::sounds(&dir, Some(minecraft), &|line| log(line.to_string()))
|
||
}))
|
||
.unwrap_or_else(|_| Err("The sound copy stopped unexpectedly".into()))
|
||
.map(|_| ()),
|
||
};
|
||
if let Err(e) = result {
|
||
log(format!("No sound (the game will be silent): {e}"));
|
||
}
|
||
}
|
||
|
||
/// Runs `Preparer::InProcess` on this thread, each progress line to `log`. A panic is an
|
||
/// error like any other, so the window never waits on a preparation that died.
|
||
pub fn prepare_in_process(
|
||
options: &horizon_prepare::Options,
|
||
log: &dyn Fn(String),
|
||
) -> Result<(), String> {
|
||
std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
|
||
horizon_prepare::prepare(options, &|line| log(line.to_string()))
|
||
}))
|
||
.unwrap_or_else(|_| Err("The preparation stopped unexpectedly".into()))
|
||
.map(|_| ())
|
||
}
|
||
|
||
/// Where the game keeps saves and options.txt: `HORIZON_HOME`, else `horizon` in the platform's
|
||
/// data folder (~/.local/share/horizon on Linux, as the release folders' horizon.sh uses). It is
|
||
/// never inside a version folder, so installing, updating or removing a version keeps the saves.
|
||
pub fn game_home() -> PathBuf {
|
||
if let Some(home) = std::env::var_os("HORIZON_HOME").filter(|h| !h.is_empty()) {
|
||
return PathBuf::from(home);
|
||
}
|
||
dirs::data_dir()
|
||
.unwrap_or_else(std::env::temp_dir)
|
||
.join("horizon")
|
||
}
|
||
|
||
// ----- Logs and crash reports ---------------------------------------------------------------------
|
||
|
||
/// The game's logs (`latest.log` and the day archives), as it writes them in its home.
|
||
pub fn logs_dir() -> PathBuf {
|
||
game_home().join("logs")
|
||
}
|
||
|
||
/// Where the game writes `crash-<date>_<time>-client.txt` when it crashes.
|
||
pub fn crash_reports_dir() -> PathBuf {
|
||
game_home().join("crash-reports")
|
||
}
|
||
|
||
/// The crash reports in `dir`, oldest first (their names sort by time).
|
||
fn crash_reports_in(dir: &Path) -> Vec<PathBuf> {
|
||
let mut reports: Vec<PathBuf> = fs::read_dir(dir)
|
||
.into_iter()
|
||
.flatten()
|
||
.flatten()
|
||
.map(|e| e.path())
|
||
.filter(|p| {
|
||
p.file_name()
|
||
.and_then(|n| n.to_str())
|
||
.is_some_and(|n| n.starts_with("crash-") && n.ends_with(".txt"))
|
||
})
|
||
.collect();
|
||
reports.sort();
|
||
reports
|
||
}
|
||
|
||
/// The newest crash report, if any.
|
||
pub fn newest_crash_report() -> Option<PathBuf> {
|
||
crash_reports_in(&crash_reports_dir()).pop()
|
||
}
|
||
|
||
/// The newest crash report written at or after `since` (one from the run that started then).
|
||
pub fn crash_report_since(since: std::time::SystemTime) -> Option<PathBuf> {
|
||
crash_report_in_since(&crash_reports_dir(), since)
|
||
}
|
||
|
||
fn crash_report_in_since(dir: &Path, since: std::time::SystemTime) -> Option<PathBuf> {
|
||
crash_reports_in(dir).into_iter().rev().find(|p| {
|
||
fs::metadata(p)
|
||
.and_then(|m| m.modified())
|
||
.is_ok_and(|t| t >= since)
|
||
})
|
||
}
|
||
|
||
/// The error a crash report describes, on one line: the lines between its description and the
|
||
/// stack (`panicked at src/game.rs:10:5: boom`).
|
||
pub fn crash_summary(report: &str) -> Option<String> {
|
||
let mut lines = report
|
||
.lines()
|
||
.skip_while(|l| !l.starts_with("Description:"));
|
||
lines.next()?;
|
||
let error: Vec<&str> = lines
|
||
.skip_while(|l| l.trim().is_empty())
|
||
.take_while(|l| !l.trim().is_empty() && !l.starts_with('\t'))
|
||
.map(str::trim)
|
||
.collect();
|
||
(!error.is_empty()).then(|| error.join(" "))
|
||
}
|
||
|
||
/// The last `lines` lines of `file`, or why it cannot be read.
|
||
fn tail_of(file: &Path, lines: usize) -> Result<String, String> {
|
||
let bytes = fs::read(file).map_err(|e| format!("{}: {e}", file.display()))?;
|
||
let text = String::from_utf8_lossy(&bytes);
|
||
let all: Vec<&str> = text.lines().collect();
|
||
Ok(all[all.len().saturating_sub(lines)..].join("\n") + "\n")
|
||
}
|
||
|
||
/// `logs`: the end of the game's latest.log, or with `crash` its newest crash report. The path
|
||
/// read comes first.
|
||
pub fn read_logs(lines: usize, crash: bool) -> Result<(PathBuf, String), String> {
|
||
if crash {
|
||
let path = newest_crash_report()
|
||
.ok_or_else(|| format!("No crash report in {}.", crash_reports_dir().display()))?;
|
||
let text = fs::read_to_string(&path).map_err(|e| format!("{}: {e}", path.display()))?;
|
||
return Ok((path, text));
|
||
}
|
||
let path = logs_dir().join("latest.log");
|
||
let text = tail_of(&path, lines.max(1))?;
|
||
Ok((path, text))
|
||
}
|
||
|
||
/// Which drawing the game's menus use. Classic is vanilla's own screens, which have no way to
|
||
/// switch back, so the launcher is where the player returns to Horizon's.
|
||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||
pub enum MenuStyle {
|
||
Horizon,
|
||
Classic,
|
||
}
|
||
|
||
impl MenuStyle {
|
||
pub fn name(self) -> &'static str {
|
||
match self {
|
||
MenuStyle::Horizon => "horizon",
|
||
MenuStyle::Classic => "classic",
|
||
}
|
||
}
|
||
|
||
pub fn parse(name: &str) -> Option<Self> {
|
||
match name {
|
||
"horizon" => Some(MenuStyle::Horizon),
|
||
"classic" => Some(MenuStyle::Classic),
|
||
_ => None,
|
||
}
|
||
}
|
||
|
||
/// The style `horizon.txt` holds: Horizon unless it has the line `menuStyle:classic`, as the
|
||
/// game reads it (crates/horizon-client/src/ui_theme.rs).
|
||
fn from_file(text: &str) -> Self {
|
||
if text.lines().any(|l| l.trim() == "menuStyle:classic") {
|
||
MenuStyle::Classic
|
||
} else {
|
||
MenuStyle::Horizon
|
||
}
|
||
}
|
||
|
||
/// `text` with its `menuStyle:` line set to this style and every other line kept.
|
||
fn into_file(self, text: &str) -> String {
|
||
let mut out: Vec<String> = text
|
||
.lines()
|
||
.filter(|l| !l.trim().starts_with("menuStyle:"))
|
||
.map(String::from)
|
||
.collect();
|
||
out.insert(0, format!("menuStyle:{}", self.name()));
|
||
out.join("\n") + "\n"
|
||
}
|
||
}
|
||
|
||
/// The menu style saved in the game home's `horizon.txt` (Horizon when there is none).
|
||
pub fn menu_style() -> MenuStyle {
|
||
MenuStyle::from_file(&fs::read_to_string(game_home().join("horizon.txt")).unwrap_or_default())
|
||
}
|
||
|
||
pub fn set_menu_style(style: MenuStyle) -> Result<(), String> {
|
||
let home = game_home();
|
||
fs::create_dir_all(&home).map_err(|e| e.to_string())?;
|
||
let file = home.join("horizon.txt");
|
||
let text = style.into_file(&fs::read_to_string(&file).unwrap_or_default());
|
||
fs::write(file, text).map_err(|e| e.to_string())
|
||
}
|
||
|
||
pub fn client_command(tag: &str) -> Command {
|
||
let home = game_home();
|
||
let _ = fs::create_dir_all(&home);
|
||
let mut cmd = Command::new(version_dir(tag).join(CLIENT));
|
||
cmd.current_dir(home).arg("--resources").arg(resources(tag));
|
||
// PipeWire remembers volume and mute per application name. The game's own name is
|
||
// "PipeWire ALSA [horizon-client]", shared with development and test runs, where
|
||
// muting it once left every later game silent: played from here it is "Horizon".
|
||
if std::env::var_os("PIPEWIRE_PROPS").is_none() {
|
||
cmd.env(
|
||
"PIPEWIRE_PROPS",
|
||
"{ application.name = \"Horizon\" media.role = \"Game\" }",
|
||
);
|
||
}
|
||
cmd
|
||
}
|
||
|
||
pub fn server_command(tag: &str, folder: &Path) -> Command {
|
||
let mut cmd = Command::new(version_dir(tag).join(CLIENT));
|
||
cmd.current_dir(folder)
|
||
.arg("--resources")
|
||
.arg(resources(tag))
|
||
.args(["--dedicated", "--nogui"]);
|
||
cmd
|
||
}
|
||
|
||
pub fn eula_agreed(folder: &Path) -> bool {
|
||
fs::read_to_string(folder.join("eula.txt"))
|
||
.is_ok_and(|s| s.lines().any(|l| l.trim() == "eula=true"))
|
||
}
|
||
|
||
/// Writes eula.txt as vanilla's server expects it, once the player agreed in the launcher.
|
||
pub fn agree_eula(folder: &Path) -> Result<(), String> {
|
||
fs::create_dir_all(folder).map_err(|e| e.to_string())?;
|
||
let text = "#By changing the setting below to TRUE you are indicating your agreement to our EULA (https://aka.ms/MinecraftEULA).\neula=true\n";
|
||
fs::write(folder.join("eula.txt"), text).map_err(|e| e.to_string())
|
||
}
|
||
|
||
// ----- Shared steps for the front ends -----------------------------------------------------------
|
||
|
||
/// The installed version to use: the one asked for, else the selected one, else the newest.
|
||
pub fn resolve_version(requested: Option<&str>) -> Result<String, String> {
|
||
let installed = installed();
|
||
if let Some(tag) = requested {
|
||
return installed
|
||
.iter()
|
||
.find(|t| *t == tag)
|
||
.cloned()
|
||
.ok_or_else(|| format!("{tag} is not installed."));
|
||
}
|
||
let selected = Settings::load().selected.filter(|s| installed.contains(s));
|
||
selected
|
||
.or_else(|| installed.first().cloned())
|
||
.ok_or_else(|| "No version is installed yet.".into())
|
||
}
|
||
|
||
/// Removes an installed version and moves the selection to the newest one left if needed.
|
||
pub fn remove_version(tag: &str) -> Result<(), String> {
|
||
if !installed().iter().any(|t| t == tag) {
|
||
return Err(format!("{tag} is not installed."));
|
||
}
|
||
remove(tag)?;
|
||
let mut settings = Settings::load();
|
||
if settings.selected.as_deref() == Some(tag) {
|
||
settings.selected = installed().first().cloned();
|
||
settings.save();
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
/// The Minecraft folder to prepare from: the one given, the one chosen in the launcher, or the
|
||
/// official launcher's default. It may be absent when imported files can be reused.
|
||
pub fn minecraft_dir(requested: Option<PathBuf>) -> Result<PathBuf, String> {
|
||
Ok(requested
|
||
.or(Settings::load().minecraft_dir)
|
||
.or_else(default_minecraft_dir)
|
||
.unwrap_or_else(|| horizon_prepare::artifacts::minecraft_dir(None)))
|
||
}
|
||
|
||
/// The server folder: the one given, the one chosen in the launcher, or `server/` in the data folder.
|
||
pub fn server_dir(requested: Option<PathBuf>) -> PathBuf {
|
||
requested
|
||
.or(Settings::load().server_dir)
|
||
.unwrap_or_else(|| data_dir().join("server"))
|
||
}
|
||
|
||
fn need_prepared(tag: &str) -> Result<(), String> {
|
||
if is_prepared(tag) {
|
||
Ok(())
|
||
} else {
|
||
Err(format!(
|
||
"{tag} is not prepared yet. Prepare it first (it needs your own Minecraft {}).",
|
||
game_version(tag)
|
||
))
|
||
}
|
||
}
|
||
|
||
/// The client's command, once its resources are prepared.
|
||
pub fn client(tag: &str) -> Result<Command, String> {
|
||
need_prepared(tag)?;
|
||
let mut cmd = client_command(tag);
|
||
// A sign-in that can't be renewed (no network, expired) still lets the game start, offline.
|
||
if let Err(e) = crate::account::attach_session(&mut cmd, &game_home()) {
|
||
eprintln!("Playing offline: {e}");
|
||
}
|
||
Ok(cmd)
|
||
}
|
||
|
||
/// Start the game straight into a friend's world: `--server friend:CODE`.
|
||
pub fn join_friend(cmd: &mut Command, code: &str) -> Result<(), String> {
|
||
horizon_friends::invite::parse_detailed(code).map_err(|e| e.to_string())?;
|
||
let code: String = code.chars().filter(|c| !c.is_whitespace()).collect();
|
||
cmd.arg("--server")
|
||
.arg(format!("{}{code}", horizon_friends::ADDRESS_PREFIX));
|
||
Ok(())
|
||
}
|
||
|
||
/// The dedicated server's command in `folder`, once prepared and the EULA is agreed to.
|
||
pub fn server(tag: &str, folder: &Path, accept_eula: bool) -> Result<Command, String> {
|
||
need_prepared(tag)?;
|
||
if accept_eula {
|
||
agree_eula(folder)?;
|
||
}
|
||
if !eula_agreed(folder) {
|
||
return Err("Running a server needs your agreement to the Minecraft EULA (https://aka.ms/MinecraftEULA). Accept it to continue.".into());
|
||
}
|
||
fs::create_dir_all(folder).map_err(|e| e.to_string())?;
|
||
Ok(server_command(tag, folder))
|
||
}
|
||
|
||
/// One release's notes: the tag given, or the newest.
|
||
pub fn release_notes(tag: Option<&str>) -> Result<Release, String> {
|
||
let releases = releases()?;
|
||
match tag {
|
||
Some(tag) => releases
|
||
.into_iter()
|
||
.find(|r| r.tag == tag)
|
||
.ok_or_else(|| format!("No Horizon release is tagged {tag}.")),
|
||
None => releases
|
||
.into_iter()
|
||
.next()
|
||
.ok_or_else(|| "No release is published yet.".into()),
|
||
}
|
||
}
|
||
|
||
/// A process whose output is kept: the last `LOG_KEEP` lines, and its result once it ends.
|
||
pub struct Logged {
|
||
pub running: Running,
|
||
pub log: Arc<Mutex<std::collections::VecDeque<String>>>,
|
||
pub exit: Arc<Mutex<Option<Result<(), String>>>>,
|
||
}
|
||
|
||
pub const LOG_KEEP: usize = 2000;
|
||
|
||
impl Logged {
|
||
pub fn start(job: Job, cmd: Command) -> Result<Self, String> {
|
||
let (tx, rx) = std::sync::mpsc::channel();
|
||
let running = spawn(job, cmd, tx)?;
|
||
let log = Arc::new(Mutex::new(std::collections::VecDeque::new()));
|
||
let exit = Arc::new(Mutex::new(None));
|
||
let (l, e) = (log.clone(), exit.clone());
|
||
std::thread::spawn(move || {
|
||
for msg in rx {
|
||
match msg {
|
||
Msg::Line(_, line) => {
|
||
let mut log = l.lock().unwrap();
|
||
log.push_back(line);
|
||
if log.len() > LOG_KEEP {
|
||
log.pop_front();
|
||
}
|
||
}
|
||
Msg::Exit(_, result) => *e.lock().unwrap() = Some(result),
|
||
_ => {}
|
||
}
|
||
}
|
||
});
|
||
Ok(Self { running, log, exit })
|
||
}
|
||
|
||
pub fn finished(&self) -> Option<Result<(), String>> {
|
||
self.exit.lock().unwrap().clone()
|
||
}
|
||
|
||
pub fn tail(&self, lines: usize) -> Vec<String> {
|
||
let log = self.log.lock().unwrap();
|
||
log.iter()
|
||
.skip(log.len().saturating_sub(lines))
|
||
.cloned()
|
||
.collect()
|
||
}
|
||
|
||
pub fn wait(&self) -> Result<(), String> {
|
||
loop {
|
||
if let Some(result) = self.finished() {
|
||
return result;
|
||
}
|
||
std::thread::sleep(std::time::Duration::from_millis(100));
|
||
}
|
||
}
|
||
|
||
/// Asks a server to stop, and kills it if it has not after `grace`.
|
||
pub fn stop(&mut self, grace: std::time::Duration) {
|
||
self.running.send("stop");
|
||
let start = std::time::Instant::now();
|
||
while self.finished().is_none() && start.elapsed() < grace {
|
||
std::thread::sleep(std::time::Duration::from_millis(100));
|
||
}
|
||
if self.finished().is_none() {
|
||
self.running.kill();
|
||
}
|
||
}
|
||
}
|
||
|
||
// ----- Updates -----------------------------------------------------------------------------------
|
||
|
||
/// What a check found: a Horizon build newer than every installed one, and a newer launcher.
|
||
#[derive(Clone, Debug, Default, serde::Serialize)]
|
||
pub struct Updates {
|
||
pub horizon: Option<Release>,
|
||
pub launcher: Option<Release>,
|
||
}
|
||
|
||
/// The newest Horizon release with a build here, if it is newer than every installed version.
|
||
pub fn horizon_update(releases: &[Release], installed: &[String]) -> Option<Release> {
|
||
let newest = latest(releases)?;
|
||
let newer = installed
|
||
.iter()
|
||
.all(|t| compare_versions(&newest.tag, t).is_gt());
|
||
newer.then(|| newest.clone())
|
||
}
|
||
|
||
/// The newest launcher release with an archive for this platform, if newer than this launcher.
|
||
pub fn launcher_update(releases: &[Release]) -> Option<Release> {
|
||
releases
|
||
.iter()
|
||
.find(|r| r.asset.is_some())
|
||
.filter(|r| compare_versions(launcher_version(&r.tag).unwrap_or("0"), VERSION).is_gt())
|
||
.cloned()
|
||
}
|
||
|
||
/// Load the game's release list and both update kinds from the same GitHub response.
|
||
/// Publish the game releases before any fallback lookups for older launcher tags, so those
|
||
/// lookups cannot hold up the release pages or opening animation. A list error reaches both.
|
||
pub fn releases_and_updates(
|
||
on_releases: impl FnOnce(Result<Vec<Release>, String>),
|
||
) -> Result<Updates, String> {
|
||
releases_and_updates_with(release_list, installed, launcher_releases_in, on_releases)
|
||
}
|
||
|
||
fn releases_and_updates_with(
|
||
load: impl FnOnce() -> Result<serde_json::Value, String>,
|
||
installed: impl FnOnce() -> Vec<String>,
|
||
launchers: impl FnOnce(&serde_json::Value) -> Vec<Release>,
|
||
on_releases: impl FnOnce(Result<Vec<Release>, String>),
|
||
) -> Result<Updates, String> {
|
||
let list = match load() {
|
||
Ok(list) => list,
|
||
Err(e) => {
|
||
on_releases(Err(e.clone()));
|
||
return Err(e);
|
||
}
|
||
};
|
||
let releases = parse_releases(&list, ASSET, is_game_tag);
|
||
let horizon = horizon_update(&releases, &installed());
|
||
on_releases(Ok(releases));
|
||
Ok(Updates {
|
||
horizon,
|
||
launcher: launcher_update(&launchers(&list)),
|
||
})
|
||
}
|
||
|
||
/// A fresh release-list request for both kinds of update (plus older-launcher fallback if needed).
|
||
pub fn check_updates() -> Result<Updates, String> {
|
||
releases_and_updates(|_| {})
|
||
}
|
||
|
||
/// Whether a version installed as an update becomes the selected one: only when the player was
|
||
/// on the newest installed version before (or had none).
|
||
pub fn select_after_update(selected: Option<&str>, installed_before: &[String]) -> bool {
|
||
match selected {
|
||
None => true,
|
||
Some(s) => installed_before.first().is_none_or(|newest| newest == s),
|
||
}
|
||
}
|
||
|
||
/// Installs `tag` (or the newest release with "latest"), then updates the selection as
|
||
/// `select_after_update` says when `as_update`, or always selects it otherwise.
|
||
pub fn install_tag(tag: &str, as_update: bool, progress: impl Fn(f32)) -> Result<String, String> {
|
||
let releases = releases()?;
|
||
let release = if tag == "latest" {
|
||
latest(&releases).ok_or("No release has a build for this platform yet.")?
|
||
} else {
|
||
releases
|
||
.iter()
|
||
.find(|r| r.tag == tag)
|
||
.ok_or_else(|| format!("No Horizon release is tagged {tag}."))?
|
||
};
|
||
let (url, size) = release
|
||
.asset
|
||
.clone()
|
||
.ok_or_else(|| format!("{} has no build for this platform.", release.tag))?;
|
||
let before = installed();
|
||
install(&release.tag, &url, size, progress)?;
|
||
let mut settings = Settings::load();
|
||
if !as_update || select_after_update(settings.selected.as_deref(), &before) {
|
||
settings.selected = Some(release.tag.clone());
|
||
settings.save();
|
||
}
|
||
Ok(release.tag.clone())
|
||
}
|
||
|
||
/// The launcher's own path, read once at start: after a self-update the running file is gone.
|
||
pub fn exe_path() -> &'static Path {
|
||
static EXE: std::sync::OnceLock<PathBuf> = std::sync::OnceLock::new();
|
||
EXE.get_or_init(|| std::env::current_exe().unwrap_or_else(|_| PathBuf::from(LAUNCHER_BINARY)))
|
||
}
|
||
|
||
/// Development builds and `HORIZON_LAUNCHER_NO_SELF_UPDATE` never replace themselves.
|
||
pub fn self_update_allowed() -> bool {
|
||
!cfg!(debug_assertions) && std::env::var_os("HORIZON_LAUNCHER_NO_SELF_UPDATE").is_none()
|
||
}
|
||
|
||
/// The version in `horizon-launcher --version`'s output (`horizon-launcher 0.1.5`).
|
||
fn parse_version_output(out: &str) -> Option<&str> {
|
||
out.trim()
|
||
.strip_prefix("horizon-launcher ")
|
||
.map(str::trim)
|
||
.filter(|v| !v.is_empty())
|
||
}
|
||
|
||
/// The version of the launcher binary now at `path`, which is not this process's once another
|
||
/// update (the command line, another window) has replaced the file.
|
||
fn installed_launcher_version(path: &Path) -> Option<String> {
|
||
let mut cmd = Command::new(path);
|
||
cmd.arg("--version")
|
||
.stdin(Stdio::null())
|
||
.stderr(Stdio::null());
|
||
#[cfg(windows)]
|
||
{
|
||
use std::os::windows::process::CommandExt;
|
||
const CREATE_NO_WINDOW: u32 = 0x0800_0000;
|
||
cmd.creation_flags(CREATE_NO_WINDOW);
|
||
}
|
||
let out = cmd.output().ok()?;
|
||
parse_version_output(&String::from_utf8_lossy(&out.stdout)).map(String::from)
|
||
}
|
||
|
||
/// Puts `new` at `exe`, the path this launcher started from. The running process keeps its
|
||
/// file (unlinked) and works on. Unix only: `self_replace` asks the system where the running
|
||
/// binary is, and Linux answers "<path> (deleted)" once the file has been replaced, so a second
|
||
/// update in the same run failed with "No such file or directory". Windows keeps a running
|
||
/// binary locked, so there `self_replace` moves it aside first.
|
||
#[cfg(unix)]
|
||
fn replace_binary(new: &Path, exe: &Path) -> std::io::Result<()> {
|
||
use std::os::unix::fs::PermissionsExt;
|
||
let dir = exe.parent().ok_or_else(|| {
|
||
std::io::Error::new(std::io::ErrorKind::NotFound, "the launcher has no folder")
|
||
})?;
|
||
let name = exe.file_name().unwrap_or_default().to_string_lossy();
|
||
let temp = dir.join(format!(".{name}.update-{}", std::process::id()));
|
||
let mode = fs::metadata(exe).map_or(0o755, |m| m.permissions().mode() | 0o111);
|
||
let result = fs::copy(new, &temp)
|
||
.and_then(|_| fs::set_permissions(&temp, fs::Permissions::from_mode(mode)))
|
||
.and_then(|_| fs::rename(&temp, exe));
|
||
if result.is_err() {
|
||
let _ = fs::remove_file(&temp);
|
||
}
|
||
result
|
||
}
|
||
|
||
#[cfg(not(unix))]
|
||
fn replace_binary(new: &Path, _exe: &Path) -> std::io::Result<()> {
|
||
self_replace::self_replace(new)
|
||
}
|
||
|
||
/// The app bundle the launcher runs from (`…/Horizon.app` for `…/Horizon.app/Contents/MacOS/
|
||
/// horizon-launcher`), or None for a bare binary, as launchers before the .app shipped.
|
||
pub fn app_bundle(exe: &Path) -> Option<&Path> {
|
||
let macos = exe.parent()?;
|
||
let contents = macos.parent()?;
|
||
let app = contents.parent()?;
|
||
(macos.file_name()? == "MacOS"
|
||
&& contents.file_name()? == "Contents"
|
||
&& app.extension()? == "app")
|
||
.then_some(app)
|
||
}
|
||
|
||
/// Finds the first `*.app` folder under `dir`.
|
||
fn find_app(dir: &Path) -> Option<PathBuf> {
|
||
for entry in fs::read_dir(dir).ok()?.flatten() {
|
||
let path = entry.path();
|
||
if path.is_dir() {
|
||
if path.extension().is_some_and(|e| e == "app") {
|
||
return Some(path);
|
||
}
|
||
if let Some(found) = find_app(&path) {
|
||
return Some(found);
|
||
}
|
||
}
|
||
}
|
||
None
|
||
}
|
||
|
||
/// Puts the bundle `new` in place of `app`: copied beside it first (`ditto` keeps its links,
|
||
/// modes and signature), then the old one is moved aside and the new one renamed in, so `app` is
|
||
/// never half written. The running launcher keeps its open files and works on.
|
||
#[cfg(target_os = "macos")]
|
||
fn replace_bundle(new: &Path, app: &Path) -> Result<(), String> {
|
||
let dir = app.parent().ok_or("The app has no folder.")?;
|
||
let name = app.file_name().unwrap_or_default().to_string_lossy();
|
||
let staged = dir.join(format!(".{name}.update-{}", std::process::id()));
|
||
let old = dir.join(format!(".{name}.old-{}", std::process::id()));
|
||
let _ = fs::remove_dir_all(&staged);
|
||
let copied = Command::new("ditto")
|
||
.arg(new)
|
||
.arg(&staged)
|
||
.status()
|
||
.map_err(|e| format!("ditto: {e}"))?;
|
||
if !copied.success() {
|
||
let _ = fs::remove_dir_all(&staged);
|
||
return Err(format!(
|
||
"Could not copy the new app next to {}.",
|
||
app.display()
|
||
));
|
||
}
|
||
fs::rename(app, &old).map_err(|e| {
|
||
let _ = fs::remove_dir_all(&staged);
|
||
format!("Could not move {} aside: {e}", app.display())
|
||
})?;
|
||
if let Err(e) = fs::rename(&staged, app) {
|
||
let _ = fs::rename(&old, app);
|
||
let _ = fs::remove_dir_all(&staged);
|
||
return Err(format!(
|
||
"Could not put the new app at {}: {e}",
|
||
app.display()
|
||
));
|
||
}
|
||
let _ = fs::remove_dir_all(&old);
|
||
Ok(())
|
||
}
|
||
|
||
#[cfg(not(target_os = "macos"))]
|
||
fn replace_bundle(_new: &Path, _app: &Path) -> Result<(), String> {
|
||
Err("App bundles are a macOS thing.".into())
|
||
}
|
||
|
||
/// Downloads a launcher release and puts its binary in place of this one. The running process
|
||
/// keeps working; `restart` starts the new one. When the file there already is that release or
|
||
/// a newer one (updated from the command line or another window), there is nothing to do.
|
||
pub fn self_update(release: &Release, progress: impl Fn(f32)) -> Result<(), String> {
|
||
let (url, size) = release
|
||
.asset
|
||
.clone()
|
||
.ok_or("This launcher release has no build for this platform.")?;
|
||
let target = launcher_version(&release.tag).unwrap_or("0");
|
||
if installed_launcher_version(exe_path())
|
||
.is_some_and(|v| v != VERSION && compare_versions(&v, target).is_ge())
|
||
{
|
||
progress(1.0);
|
||
return Ok(());
|
||
}
|
||
let work = data_dir().join(".launcher-update");
|
||
let _ = fs::remove_dir_all(&work);
|
||
fs::create_dir_all(&work).map_err(|e| e.to_string())?;
|
||
let archive = work.join("download");
|
||
download(&url, size, &archive, &progress)?;
|
||
let unpacked = work.join("unpacked");
|
||
unpack(&archive, &url, &unpacked)?;
|
||
// A launcher inside Horizon.app replaces the whole bundle (its Info.plist, icon and
|
||
// signature belong with the binary); a bare binary, as older launchers are, only the binary,
|
||
// which the macOS archive also holds (Horizon.app/Contents/MacOS/horizon-launcher).
|
||
if let Some(app) = app_bundle(exe_path()) {
|
||
if let Some(new) = find_app(&unpacked) {
|
||
replace_bundle(&new, app)?;
|
||
let _ = fs::remove_dir_all(&work);
|
||
progress(1.0);
|
||
return Ok(());
|
||
}
|
||
}
|
||
let binary =
|
||
find_file(&unpacked, LAUNCHER_BINARY).ok_or("The download has no launcher binary.")?;
|
||
replace_binary(&binary, exe_path()).map_err(|e| {
|
||
format!(
|
||
"Could not replace the launcher at {}: {e}",
|
||
exe_path().display()
|
||
)
|
||
})?;
|
||
let _ = fs::remove_dir_all(&work);
|
||
progress(1.0);
|
||
Ok(())
|
||
}
|
||
|
||
fn find_file(dir: &Path, name: &str) -> Option<PathBuf> {
|
||
for entry in fs::read_dir(dir).ok()?.flatten() {
|
||
let path = entry.path();
|
||
if path.is_dir() {
|
||
if let Some(found) = find_file(&path, name) {
|
||
return Some(found);
|
||
}
|
||
} else if entry.file_name() == name {
|
||
return Some(path);
|
||
}
|
||
}
|
||
None
|
||
}
|
||
|
||
/// Starts the launcher again (the updated binary) with the same arguments in place of this one:
|
||
/// on Unix the process becomes the new binary (exec), on Windows the new one starts and this one
|
||
/// exits. Returns only when the new binary could not start.
|
||
pub fn restart() -> String {
|
||
let mut cmd = Command::new(exe_path());
|
||
cmd.args(std::env::args_os().skip(1));
|
||
#[cfg(unix)]
|
||
let error = {
|
||
use std::os::unix::process::CommandExt;
|
||
cmd.exec()
|
||
};
|
||
#[cfg(not(unix))]
|
||
let error = match cmd.spawn() {
|
||
Ok(_) => std::process::exit(0),
|
||
Err(e) => e,
|
||
};
|
||
format!(
|
||
"Could not start {}: {error}. Close the launcher and open it again.",
|
||
exe_path().display()
|
||
)
|
||
}
|
||
|
||
/// Plain text from markdown, for terminals: headings on their own lines, bullets as "- ",
|
||
/// links followed by their address.
|
||
pub fn markdown_to_text(md: &str) -> String {
|
||
use pulldown_cmark::{Event, Parser, Tag, TagEnd};
|
||
let mut out = String::new();
|
||
let mut links = Vec::new();
|
||
let mut lists: Vec<Option<u64>> = Vec::new();
|
||
for event in Parser::new(md) {
|
||
match event {
|
||
Event::Start(Tag::Item) => {
|
||
let depth = lists.len().saturating_sub(1);
|
||
out.push_str(&" ".repeat(depth));
|
||
match lists.last_mut() {
|
||
Some(Some(n)) => {
|
||
out.push_str(&format!("{n}. "));
|
||
*n += 1;
|
||
}
|
||
_ => out.push_str("- "),
|
||
}
|
||
}
|
||
Event::Start(Tag::List(start)) => {
|
||
if !out.ends_with('\n') && !out.is_empty() {
|
||
out.push('\n');
|
||
}
|
||
lists.push(start)
|
||
}
|
||
Event::End(TagEnd::List(_)) => {
|
||
lists.pop();
|
||
if lists.is_empty() {
|
||
out.push('\n');
|
||
}
|
||
}
|
||
Event::Start(Tag::Link { dest_url, .. }) => links.push(dest_url.to_string()),
|
||
Event::End(TagEnd::Link) => {
|
||
if let Some(url) = links.pop() {
|
||
out.push_str(&format!(" ({url})"));
|
||
}
|
||
}
|
||
Event::End(TagEnd::Heading(_)) => out.push_str("\n\n"),
|
||
Event::End(TagEnd::Paragraph) => {
|
||
out.push_str(if lists.is_empty() { "\n\n" } else { "\n" })
|
||
}
|
||
Event::End(TagEnd::Item) if !out.ends_with('\n') => out.push('\n'),
|
||
Event::End(TagEnd::CodeBlock) => out.push('\n'),
|
||
Event::Text(t) | Event::Code(t) => out.push_str(&t),
|
||
Event::SoftBreak | Event::HardBreak => out.push('\n'),
|
||
Event::Rule => out.push_str("---\n\n"),
|
||
_ => {}
|
||
}
|
||
}
|
||
out.trim_end().to_string() + "\n"
|
||
}
|
||
|
||
/// The first sentence-like line of a release's notes, for a one-line summary.
|
||
pub fn notes_summary(body: &str) -> Option<String> {
|
||
let text = markdown_to_text(body);
|
||
let line = text
|
||
.lines()
|
||
.map(str::trim)
|
||
.find(|l| l.len() > 24 && !l.starts_with("---"))?;
|
||
let line = line.trim_start_matches("- ");
|
||
Some(match line.char_indices().nth(140) {
|
||
Some((i, _)) => format!("{}…", line[..i].trim_end()),
|
||
None => line.to_string(),
|
||
})
|
||
}
|
||
|
||
#[derive(Clone, Copy, PartialEq, Debug)]
|
||
pub enum Job {
|
||
Prepare,
|
||
Client,
|
||
Server,
|
||
}
|
||
|
||
pub enum Msg {
|
||
Releases(Result<Vec<Release>, String>),
|
||
Links(Links),
|
||
Progress(String, f32),
|
||
Installed(String, Result<(), String>),
|
||
Line(Job, String),
|
||
Exit(Job, Result<(), String>),
|
||
Updates(Result<Updates, String>),
|
||
LauncherProgress(f32),
|
||
LauncherUpdated(Result<(), String>),
|
||
/// `reuse_prepared_everywhere` prepared these versions.
|
||
Reused(Vec<(String, String)>),
|
||
/// Whether secrets are kept in the OS keychain (else only until the launcher closes).
|
||
Keychain(bool),
|
||
/// The selected account's session file for the game about to start (none = offline), or
|
||
/// why it could not be renewed.
|
||
Session(Result<Option<PathBuf>, String>),
|
||
}
|
||
|
||
/// A running process; its output arrives as `Msg::Line`, its end as `Msg::Exit`.
|
||
pub struct Running {
|
||
pub child: Arc<Mutex<Child>>,
|
||
pub stdin: Option<ChildStdin>,
|
||
}
|
||
|
||
impl Running {
|
||
pub fn send(&mut self, line: &str) {
|
||
if let Some(stdin) = &mut self.stdin {
|
||
let _ = writeln!(stdin, "{line}");
|
||
let _ = stdin.flush();
|
||
}
|
||
}
|
||
pub fn kill(&self) {
|
||
let _ = self.child.lock().unwrap().kill();
|
||
}
|
||
}
|
||
|
||
pub fn spawn(job: Job, mut cmd: Command, tx: Sender<Msg>) -> Result<Running, String> {
|
||
let mut child = cmd
|
||
.stdin(Stdio::piped())
|
||
.stdout(Stdio::piped())
|
||
.stderr(Stdio::piped())
|
||
.spawn()
|
||
.map_err(|e| format!("Could not start {:?}: {e}", cmd.get_program()))?;
|
||
let stdin = child.stdin.take();
|
||
let mut readers = Vec::new();
|
||
let out = child
|
||
.stdout
|
||
.take()
|
||
.map(|o| Box::new(o) as Box<dyn Read + Send>);
|
||
let err = child
|
||
.stderr
|
||
.take()
|
||
.map(|o| Box::new(o) as Box<dyn Read + Send>);
|
||
for stream in [out, err].into_iter().flatten() {
|
||
let tx = tx.clone();
|
||
readers.push(std::thread::spawn(move || {
|
||
for line in BufReader::new(stream).lines().map_while(Result::ok) {
|
||
let _ = tx.send(Msg::Line(job, line));
|
||
}
|
||
}));
|
||
}
|
||
let child = Arc::new(Mutex::new(child));
|
||
let waited = child.clone();
|
||
std::thread::spawn(move || {
|
||
for r in readers {
|
||
let _ = r.join();
|
||
}
|
||
let status = loop {
|
||
if let Some(s) = waited.lock().unwrap().try_wait().transpose() {
|
||
break s;
|
||
}
|
||
std::thread::sleep(std::time::Duration::from_millis(100));
|
||
};
|
||
let result = match status {
|
||
Ok(s) if s.success() => Ok(()),
|
||
Ok(s) => Err(format!("Exited with {s}")),
|
||
Err(e) => Err(e.to_string()),
|
||
};
|
||
let _ = tx.send(Msg::Exit(job, result));
|
||
});
|
||
Ok(Running { child, stdin })
|
||
}
|
||
|
||
#[derive(Default, serde::Serialize, serde::Deserialize)]
|
||
pub struct Settings {
|
||
pub selected: Option<String>,
|
||
pub minecraft_dir: Option<PathBuf>,
|
||
pub server_dir: Option<PathBuf>,
|
||
/// Unset means on: only a player who turned it off has `false` here. 0.1.1 wrote its
|
||
/// `auto_install` (off by default) for everyone, so this is a new key and that one is ignored.
|
||
#[serde(default)]
|
||
pub install_new_versions: Option<bool>,
|
||
/// Off by default, so the opening animation shows unless the player turns it off.
|
||
#[serde(default)]
|
||
pub skip_opening: bool,
|
||
/// Linux: whether the launcher keeps its entry in the applications menu (`desktop`). Unset
|
||
/// means yes; removing the entry stores `false`, so it doesn't come back on the next start.
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub desktop_entry: Option<bool>,
|
||
}
|
||
|
||
impl Settings {
|
||
pub fn load() -> Self {
|
||
Self::parse(&fs::read_to_string(data_dir().join("settings.json")).unwrap_or_default())
|
||
}
|
||
pub fn parse(text: &str) -> Self {
|
||
serde_json::from_str(text).unwrap_or_default()
|
||
}
|
||
/// Whether the launcher keeps its entry in the applications menu (Linux).
|
||
pub fn desktop_entry(&self) -> bool {
|
||
self.desktop_entry.unwrap_or(true)
|
||
}
|
||
/// Whether new Horizon versions are installed automatically.
|
||
pub fn auto_install(&self) -> bool {
|
||
self.install_new_versions.unwrap_or(true)
|
||
}
|
||
pub fn save(&self) {
|
||
let _ = fs::create_dir_all(data_dir());
|
||
let _ = fs::write(
|
||
data_dir().join("settings.json"),
|
||
serde_json::to_string_pretty(self).unwrap(),
|
||
);
|
||
}
|
||
}
|
||
|
||
#[cfg(test)]
|
||
#[path = "backend/release_loading_tests.rs"]
|
||
mod release_loading_tests;
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
use std::cmp::Ordering::*;
|
||
|
||
#[test]
|
||
fn a_folder_without_the_game_says_what_it_lacks_and_what_to_do() {
|
||
let dir = std::env::temp_dir().join(format!("horizon-missing-{}", std::process::id()));
|
||
let _ = fs::remove_dir_all(&dir);
|
||
assert_eq!(
|
||
missing_game_files(&dir, "26.3").as_deref(),
|
||
Some("the folder doesn't exist")
|
||
);
|
||
fs::create_dir_all(dir.join("versions/26.3")).unwrap();
|
||
assert_eq!(
|
||
missing_game_files(&dir, "26.3").as_deref(),
|
||
Some("no versions/26.3/26.3.json or versions/26.3/26.3.jar")
|
||
);
|
||
fs::write(dir.join("versions/26.3/26.3.json"), "{}").unwrap();
|
||
let missing = missing_game_files(&dir, "26.3").unwrap();
|
||
assert_eq!(missing, "no versions/26.3/26.3.jar");
|
||
let error = not_found("26.3", &[(dir.clone(), missing)]);
|
||
assert!(error.starts_with("Minecraft 26.3 was not found. Horizon looked in:\n"));
|
||
assert!(error.contains(&format!("{} (no versions/26.3/26.3.jar)", dir.display())));
|
||
assert!(error.contains("Play 26.3 once in the official Minecraft launcher"));
|
||
assert!(error.contains("--minecraft on the command line"));
|
||
fs::write(dir.join("versions/26.3/26.3.jar"), "jar").unwrap();
|
||
assert_eq!(missing_game_files(&dir, "26.3"), None);
|
||
fs::remove_dir_all(&dir).unwrap();
|
||
}
|
||
|
||
#[test]
|
||
fn the_game_plays_under_its_own_audio_stream_name() {
|
||
if std::env::var_os("PIPEWIRE_PROPS").is_some() {
|
||
return;
|
||
}
|
||
let cmd = client_command("v2026.10.13");
|
||
let props = cmd
|
||
.get_envs()
|
||
.find(|(k, _)| *k == "PIPEWIRE_PROPS")
|
||
.and_then(|(_, v)| v);
|
||
assert!(props.is_some_and(|v| v
|
||
.to_string_lossy()
|
||
.contains("application.name = \"Horizon\"")));
|
||
}
|
||
|
||
#[test]
|
||
fn tags_never_mix() {
|
||
assert!(is_game_tag("v2026.10.13"));
|
||
assert!(!is_game_tag("launcher-v0.2.0"));
|
||
assert!(!is_game_tag("vnext"));
|
||
assert_eq!(launcher_version("launcher-v0.2.0"), Some("0.2.0"));
|
||
assert_eq!(launcher_version("v2026.10.13"), None);
|
||
assert_eq!(launcher_version("launcher-vx"), None);
|
||
let list = serde_json::json!([
|
||
{"tag_name": "v2026.10.12", "assets": [{"name": "horizon-linux-x86_64.tar.gz", "browser_download_url": "u", "size": 1}]},
|
||
{"tag_name": "launcher-v9.0.0", "assets": [{"name": "horizon-launcher-linux-x86_64.tar.gz", "browser_download_url": "u", "size": 1}]},
|
||
{"tag_name": "v2026.10.13", "assets": []},
|
||
{"tag_name": "launcher-v0.0.1", "draft": true, "assets": []},
|
||
]);
|
||
let game: Vec<_> = parse_releases(&list, ASSET, is_game_tag)
|
||
.into_iter()
|
||
.map(|r| r.tag)
|
||
.collect();
|
||
assert_eq!(game, ["v2026.10.13", "v2026.10.12"]);
|
||
let launcher: Vec<_> = parse_releases(&list, LAUNCHER_ASSET, is_launcher_tag)
|
||
.into_iter()
|
||
.map(|r| r.tag)
|
||
.collect();
|
||
assert_eq!(launcher, ["launcher-v9.0.0"]);
|
||
}
|
||
|
||
/// Rolling a release back (`gh release edit <tag> --draft`, docs/release-flow.md) makes the
|
||
/// previous one the newest again: it is what `install latest` and the update check offer.
|
||
#[test]
|
||
fn withdrawn_release_is_never_offered() {
|
||
let asset = ASSET.unwrap_or("horizon-linux-x86_64.tar.gz");
|
||
let list = serde_json::json!([
|
||
{"tag_name": "v2026.10.15.1", "draft": true, "assets": [{"name": asset, "browser_download_url": "bad", "size": 1}]},
|
||
{"tag_name": "v2026.10.15", "assets": [{"name": asset, "browser_download_url": "good", "size": 1}]},
|
||
{"tag_name": "v2026.10.14", "assets": [{"name": asset, "browser_download_url": "old", "size": 1}]},
|
||
]);
|
||
let releases = parse_releases(&list, Some(asset), is_game_tag);
|
||
assert!(releases.iter().all(|r| r.tag != "v2026.10.15.1"));
|
||
assert_eq!(
|
||
latest(&releases).map(|r| r.tag.as_str()),
|
||
Some("v2026.10.15")
|
||
);
|
||
let offered = |installed: &[&str]| {
|
||
let installed: Vec<String> = installed.iter().map(|t| t.to_string()).collect();
|
||
horizon_update(&releases, &installed).map(|r| r.tag)
|
||
};
|
||
assert_eq!(offered(&["v2026.10.14"]), Some("v2026.10.15".into()));
|
||
assert_eq!(offered(&[]), Some("v2026.10.15".into()));
|
||
// Who installed the withdrawn one is not told to "update" to an older version.
|
||
assert_eq!(offered(&["v2026.10.15.1", "v2026.10.14"]), None);
|
||
}
|
||
|
||
#[test]
|
||
fn the_version_is_the_one_the_release_workflow_injects() {
|
||
assert_eq!(version_or(Some("0.4.2")), "0.4.2");
|
||
assert_eq!(version_or(Some("")), env!("CARGO_PKG_VERSION"));
|
||
assert_eq!(version_or(None), env!("CARGO_PKG_VERSION"));
|
||
assert_eq!(
|
||
VERSION,
|
||
option_env!("HORIZON_LAUNCHER_VERSION")
|
||
.filter(|v| !v.is_empty())
|
||
.unwrap_or(env!("CARGO_PKG_VERSION"))
|
||
);
|
||
// Self-update compares releases with that version: this launcher's own release is no update.
|
||
let r = |tag: String| Release {
|
||
tag,
|
||
name: String::new(),
|
||
body: String::new(),
|
||
date: String::new(),
|
||
asset: Some(("u".into(), 1)),
|
||
};
|
||
assert!(launcher_update(&[r(format!("{LAUNCHER_TAG_PREFIX}{VERSION}"))]).is_none());
|
||
assert_eq!(
|
||
parse_version_output(&format!("horizon-launcher {VERSION}\n")),
|
||
Some(VERSION)
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn launcher_tags_from_matching_refs_newest_first() {
|
||
let refs = serde_json::json!([
|
||
{"ref": "refs/tags/launcher-v0.1.9"},
|
||
{"ref": "refs/tags/launcher-v0.1.10"},
|
||
{"ref": "refs/tags/launcher-vnext"},
|
||
{"ref": "refs/tags/v2026.10.15"},
|
||
{"ref": "refs/tags/launcher-v0.2.0"},
|
||
]);
|
||
assert_eq!(
|
||
newest_launcher_tags(&refs),
|
||
["launcher-v0.2.0", "launcher-v0.1.10", "launcher-v0.1.9"]
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn versions_compare_by_number() {
|
||
assert_eq!(compare_versions("v2026.10.13", "v2026.10.12"), Greater);
|
||
assert_eq!(compare_versions("v2026.9.30", "v2026.10.1"), Less);
|
||
assert_eq!(compare_versions("v2026.10.13.1", "v2026.10.13"), Greater);
|
||
assert_eq!(compare_versions("0.10.0", "0.9.9"), Greater);
|
||
assert_eq!(compare_versions("launcher-v1.2", "1.2.0"), Equal);
|
||
assert_eq!(compare_versions("1.0.0-rc1", "1.0.0"), Equal);
|
||
}
|
||
|
||
#[test]
|
||
fn updates() {
|
||
let r = |tag: &str| Release {
|
||
tag: tag.into(),
|
||
name: String::new(),
|
||
body: String::new(),
|
||
date: String::new(),
|
||
asset: Some(("u".into(), 1)),
|
||
};
|
||
let releases = [r("v2026.10.13"), r("v2026.10.12")];
|
||
assert_eq!(
|
||
horizon_update(&releases, &["v2026.10.12".into()]).map(|r| r.tag),
|
||
Some("v2026.10.13".into())
|
||
);
|
||
assert!(horizon_update(&releases, &["v2026.10.13".into()]).is_none());
|
||
assert!(launcher_update(&[r("launcher-v0.0.1")]).is_none());
|
||
assert!(launcher_update(&[r("launcher-v99.0.0")]).is_some());
|
||
let installed = ["v2026.10.12".to_string(), "v2026.10.1".to_string()];
|
||
assert!(select_after_update(Some("v2026.10.12"), &installed));
|
||
assert!(!select_after_update(Some("v2026.10.1"), &installed));
|
||
assert!(select_after_update(None, &installed));
|
||
}
|
||
|
||
#[test]
|
||
fn new_versions_install_automatically_unless_turned_off() {
|
||
// No settings file, an old one that never mentioned it, and 0.1.1's default `false`.
|
||
assert!(Settings::parse("").auto_install());
|
||
assert!(Settings::parse("{}").auto_install());
|
||
assert!(
|
||
Settings::parse(r#"{"selected": "v2026.10.13", "auto_install": false}"#).auto_install()
|
||
);
|
||
assert!(Settings::parse(r#"{"install_new_versions": true}"#).auto_install());
|
||
assert!(!Settings::parse(r#"{"install_new_versions": false}"#).auto_install());
|
||
// Saving after the player turned it off keeps it off.
|
||
let off = Settings {
|
||
install_new_versions: Some(false),
|
||
..Settings::default()
|
||
};
|
||
assert!(!Settings::parse(&serde_json::to_string(&off).unwrap()).auto_install());
|
||
// The selection rule is unchanged: the new version is selected only from the newest.
|
||
let installed = ["v2026.10.12".to_string(), "v2026.10.1".to_string()];
|
||
assert!(select_after_update(Some("v2026.10.12"), &installed));
|
||
assert!(!select_after_update(Some("v2026.10.1"), &installed));
|
||
}
|
||
|
||
#[test]
|
||
fn links_fall_back_to_the_built_in_ones() {
|
||
let defaults = Links::default();
|
||
assert_eq!(defaults.discord, "https://discord.gg/HcTeMZxe5E");
|
||
assert_eq!(defaults.sponsor, "https://github.com/sponsors/ludovic111");
|
||
assert_eq!(defaults.website, "https://playhorizon.dev");
|
||
// The file on main says the same thing as the defaults.
|
||
let file = Links::parse(
|
||
r#"{"discord": "https://discord.gg/HcTeMZxe5E", "sponsor": "https://github.com/sponsors/ludovic111", "website": "https://playhorizon.dev"}"#,
|
||
);
|
||
assert_eq!(file, defaults);
|
||
// Unreadable or missing, offline included: the defaults.
|
||
assert_eq!(Links::parse(""), defaults);
|
||
assert_eq!(Links::parse("<html>404</html>"), defaults);
|
||
assert_eq!(Links::parse("[1]"), defaults);
|
||
assert_eq!(Links::parse(r#"{"discord": 5}"#), defaults);
|
||
// A key that is missing keeps its default; a new address replaces it; empty hides it.
|
||
assert_eq!(
|
||
Links::parse(r#"{"discord": "https://x.y/z"}"#),
|
||
Links {
|
||
discord: "https://x.y/z".into(),
|
||
..defaults.clone()
|
||
}
|
||
);
|
||
assert_eq!(
|
||
Links::parse(r#"{"discord": "", "sponsor": " "}"#),
|
||
Links {
|
||
discord: String::new(),
|
||
sponsor: String::new(),
|
||
..defaults.clone()
|
||
}
|
||
);
|
||
// A key this launcher does not know is ignored.
|
||
assert_eq!(Links::parse(r#"{"mastodon": "https://x.y/z"}"#), defaults);
|
||
}
|
||
|
||
#[test]
|
||
fn menu_style_file_matches_the_games() {
|
||
assert_eq!(MenuStyle::from_file(""), MenuStyle::Horizon);
|
||
assert_eq!(
|
||
MenuStyle::from_file("menuStyle:horizon\n"),
|
||
MenuStyle::Horizon
|
||
);
|
||
assert_eq!(
|
||
MenuStyle::from_file("menuStyle:classic\n"),
|
||
MenuStyle::Classic
|
||
);
|
||
assert_eq!(
|
||
MenuStyle::from_file("other:1\nmenuStyle:classic\n"),
|
||
MenuStyle::Classic
|
||
);
|
||
assert_eq!(MenuStyle::Classic.into_file(""), "menuStyle:classic\n");
|
||
assert_eq!(
|
||
MenuStyle::Horizon.into_file("menuStyle:classic\nother:1\n"),
|
||
"menuStyle:horizon\nother:1\n"
|
||
);
|
||
assert_eq!(MenuStyle::parse("classic"), Some(MenuStyle::Classic));
|
||
assert_eq!(MenuStyle::parse("vanilla"), None);
|
||
}
|
||
|
||
#[test]
|
||
fn a_new_version_reuses_resources_prepared_by_a_compatible_one() {
|
||
let versions =
|
||
std::env::temp_dir().join(format!("horizon-launcher-test-{}", std::process::id()));
|
||
let _ = fs::remove_dir_all(&versions);
|
||
let oracle = "mods/horizon/src/test/java/dev/horizonlab/parity/VanillaHeightmapOracle.java";
|
||
let camera = "mods/horizon/src/test/java/dev/horizonlab/parity/VanillaCameraOracle.java";
|
||
let collision =
|
||
"mods/horizon/src/test/java/dev/horizonlab/parity/VanillaCollisionOracle.java";
|
||
let write = |tag: &str, path: &str, text: &str| {
|
||
let path = versions.join(tag).join(path);
|
||
fs::create_dir_all(path.parent().unwrap()).unwrap();
|
||
fs::write(path, text).unwrap();
|
||
};
|
||
let release = |tag: &str, minecraft: &str| {
|
||
write(tag, COMPLETE, "");
|
||
let lock = serde_json::json!({"minecraft": {"version": minecraft, "client_sha1": "c", "server_sha1": "s"}});
|
||
write(tag, "research-lock.json", &lock.to_string());
|
||
write(tag, "tools/prepare_native_client.py", "schema 7");
|
||
write(tag, oracle, "heightmap");
|
||
write(tag, collision, "collision");
|
||
write(tag, camera, tag); // Not an exporter: it may change freely.
|
||
};
|
||
let prepared = |tag: &str, minecraft: &str| {
|
||
let manifest =
|
||
serde_json::json!({"schema": 7, "collision_exporters_sha256": {collision: "x"}});
|
||
write(
|
||
tag,
|
||
&format!(".local/horizon-client/{minecraft}/{RESOURCES_MANIFEST}"),
|
||
&manifest.to_string(),
|
||
);
|
||
write(
|
||
tag,
|
||
&format!(".local/horizon-client/{minecraft}/worldgen/biomes.json"),
|
||
"{}",
|
||
);
|
||
};
|
||
let is_prepared = |tag: &str| {
|
||
resources_at(&versions.join(tag))
|
||
.join(RESOURCES_MANIFEST)
|
||
.exists()
|
||
};
|
||
|
||
release("v2026.10.13", "26.3");
|
||
prepared("v2026.10.13", "26.3");
|
||
release("v2026.10.12", "26.2");
|
||
prepared("v2026.10.12", "26.2");
|
||
release("v2026.10.13.1", "26.3");
|
||
assert_eq!(
|
||
reuse_prepared(&versions, "v2026.10.13.1"),
|
||
Some("v2026.10.13".into())
|
||
);
|
||
assert!(is_prepared("v2026.10.13.1"));
|
||
assert!(resources_at(&versions.join("v2026.10.13.1"))
|
||
.join("worldgen/biomes.json")
|
||
.exists());
|
||
let left: Vec<_> = fs::read_dir(versions.join("v2026.10.13.1/.local/horizon-client"))
|
||
.unwrap()
|
||
.flatten()
|
||
.map(|e| e.file_name())
|
||
.collect();
|
||
assert_eq!(left, ["26.3"]);
|
||
// Already prepared: nothing to do.
|
||
assert_eq!(reuse_prepared(&versions, "v2026.10.13.1"), None);
|
||
|
||
// Another Minecraft version, a changed exporter or a changed prepare script: prepare again.
|
||
release("v2026.10.14", "26.4");
|
||
assert_eq!(reuse_prepared(&versions, "v2026.10.14"), None);
|
||
release("v2026.10.15", "26.3");
|
||
write("v2026.10.15", collision, "collision, fixed");
|
||
assert_eq!(reuse_prepared(&versions, "v2026.10.15"), None);
|
||
release("v2026.10.16", "26.3");
|
||
write("v2026.10.16", "tools/prepare_native_client.py", "schema 8");
|
||
assert_eq!(reuse_prepared(&versions, "v2026.10.16"), None);
|
||
assert!(!is_prepared("v2026.10.15") && !is_prepared("v2026.10.16"));
|
||
|
||
// A version an older launcher installed without preparing it is caught up by the sweep
|
||
// that starting the window, `versions` and `update` run; the incompatible ones stay as
|
||
// they are, and a second sweep has nothing to do.
|
||
release("v2026.10.17", "26.3");
|
||
assert_eq!(
|
||
reuse_prepared_in(&versions),
|
||
[("v2026.10.17".to_string(), "v2026.10.13.1".to_string())]
|
||
);
|
||
assert!(is_prepared("v2026.10.17"));
|
||
assert!(!is_prepared("v2026.10.15") && !is_prepared("v2026.10.16"));
|
||
assert!(reuse_prepared_in(&versions).is_empty());
|
||
|
||
// Versions with horizon-prepare: its sources are the preparer, so the same sources
|
||
// reuse each other's resources, and a change or a version without them prepares again.
|
||
let crate_file = "crates/horizon-prepare/src/lib.rs";
|
||
release("v2026.10.18", "26.3");
|
||
write("v2026.10.18", crate_file, "rust preparer");
|
||
assert_eq!(reuse_prepared(&versions, "v2026.10.18"), None);
|
||
prepared("v2026.10.18", "26.3");
|
||
release("v2026.10.19", "26.3");
|
||
write("v2026.10.19", crate_file, "rust preparer");
|
||
assert_eq!(
|
||
reuse_prepared(&versions, "v2026.10.19"),
|
||
Some("v2026.10.18".into())
|
||
);
|
||
release("v2026.10.20", "26.3");
|
||
write("v2026.10.20", crate_file, "rust preparer, changed");
|
||
assert_eq!(reuse_prepared(&versions, "v2026.10.20"), None);
|
||
let _ = fs::remove_dir_all(&versions);
|
||
}
|
||
|
||
#[test]
|
||
fn finds_the_app_bundle_around_the_binary() {
|
||
let exe = Path::new("/Applications/Horizon.app/Contents/MacOS/horizon-launcher");
|
||
assert_eq!(
|
||
app_bundle(exe),
|
||
Some(Path::new("/Applications/Horizon.app"))
|
||
);
|
||
assert_eq!(app_bundle(Path::new("/Users/me/horizon-launcher")), None);
|
||
assert_eq!(
|
||
app_bundle(Path::new("/x/Contents/MacOS/horizon-launcher")),
|
||
None
|
||
);
|
||
let work = std::env::temp_dir().join(format!("horizon-find-app-{}", std::process::id()));
|
||
let _ = fs::remove_dir_all(&work);
|
||
fs::create_dir_all(work.join("dist/Horizon.app/Contents/MacOS")).unwrap();
|
||
assert_eq!(find_app(&work), Some(work.join("dist/Horizon.app")));
|
||
let _ = fs::remove_dir_all(&work);
|
||
}
|
||
|
||
/// The whole update of an app bundle, as the release ships it: signed, zipped with `ditto`,
|
||
/// unpacked by the launcher, swapped in place of the installed one, still valid.
|
||
#[cfg(target_os = "macos")]
|
||
#[test]
|
||
fn an_app_bundle_updates_in_place() {
|
||
use std::os::unix::fs::PermissionsExt;
|
||
let work = std::env::temp_dir().join(format!("horizon-bundle-{}", std::process::id()));
|
||
let _ = fs::remove_dir_all(&work);
|
||
let make = |dir: &Path, version: &str| {
|
||
let app = dir.join("Horizon.app");
|
||
fs::create_dir_all(app.join("Contents/MacOS")).unwrap();
|
||
fs::create_dir_all(app.join("Contents/Resources")).unwrap();
|
||
let bin = app.join("Contents/MacOS/horizon-launcher");
|
||
fs::copy("/usr/bin/true", &bin).unwrap();
|
||
fs::set_permissions(&bin, fs::Permissions::from_mode(0o755)).unwrap();
|
||
fs::write(app.join("Contents/Resources/version"), version).unwrap();
|
||
fs::write(
|
||
app.join("Contents/Info.plist"),
|
||
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<plist version=\"1.0\"><dict>\
|
||
<key>CFBundleExecutable</key><string>horizon-launcher</string>\
|
||
<key>CFBundleIdentifier</key><string>dev.horizon.test</string>\
|
||
<key>CFBundlePackageType</key><string>APPL</string></dict></plist>\n",
|
||
)
|
||
.unwrap();
|
||
let signed = Command::new("codesign")
|
||
.args(["--force", "--sign", "-"])
|
||
.arg(&app)
|
||
.status()
|
||
.unwrap();
|
||
assert!(signed.success());
|
||
app
|
||
};
|
||
let installed = make(&work.join("Applications"), "1.0.0");
|
||
let release = make(&work.join("release"), "2.0.0");
|
||
let zip = work.join("release.zip");
|
||
let zipped = Command::new("ditto")
|
||
.args(["-c", "-k", "--norsrc", "--noextattr", "--keepParent"])
|
||
.arg(&release)
|
||
.arg(&zip)
|
||
.status()
|
||
.unwrap();
|
||
assert!(zipped.success());
|
||
unpack(&zip, "release.zip", &work.join("unpacked")).unwrap();
|
||
let new = find_app(&work.join("unpacked")).unwrap();
|
||
replace_bundle(&new, &installed).unwrap();
|
||
let version = fs::read_to_string(installed.join("Contents/Resources/version")).unwrap();
|
||
assert_eq!(version, "2.0.0");
|
||
let bin = installed.join("Contents/MacOS/horizon-launcher");
|
||
assert!(
|
||
Command::new(&bin).status().unwrap().success(),
|
||
"still executable"
|
||
);
|
||
let valid = Command::new("codesign")
|
||
.args(["--verify", "--strict"])
|
||
.arg(&installed)
|
||
.status()
|
||
.unwrap();
|
||
assert!(valid.success(), "the updated bundle's signature holds");
|
||
let left: Vec<_> = fs::read_dir(work.join("Applications"))
|
||
.unwrap()
|
||
.flatten()
|
||
.map(|e| e.file_name())
|
||
.collect();
|
||
assert_eq!(
|
||
left,
|
||
["Horizon.app"],
|
||
"nothing staged or moved aside is left"
|
||
);
|
||
let _ = fs::remove_dir_all(&work);
|
||
}
|
||
|
||
#[test]
|
||
fn launcher_versions_read_from_the_binary() {
|
||
assert_eq!(
|
||
parse_version_output("horizon-launcher 0.1.5\n"),
|
||
Some("0.1.5")
|
||
);
|
||
assert_eq!(parse_version_output("something else"), None);
|
||
assert_eq!(parse_version_output(""), None);
|
||
// This test binary is not a launcher: no version, so an update goes ahead.
|
||
assert_eq!(
|
||
installed_launcher_version(&std::env::current_exe().unwrap()),
|
||
None
|
||
);
|
||
assert_eq!(
|
||
installed_launcher_version(Path::new("/nonexistent/horizon-launcher")),
|
||
None
|
||
);
|
||
}
|
||
|
||
/// The launcher's file was replaced while it ran (an update from the command line, or an
|
||
/// earlier one): the next replacement still lands at the path it started from.
|
||
#[cfg(unix)]
|
||
#[test]
|
||
fn a_replaced_binary_is_replaced_again_at_its_path() {
|
||
use std::os::unix::fs::PermissionsExt;
|
||
let dir =
|
||
std::env::temp_dir().join(format!("horizon-launcher-replace-{}", std::process::id()));
|
||
let _ = fs::remove_dir_all(&dir);
|
||
fs::create_dir_all(&dir).unwrap();
|
||
let exe = dir.join("horizon-launcher");
|
||
fs::write(&exe, "old").unwrap();
|
||
// Another update swaps the file under the running launcher.
|
||
fs::write(dir.join("other"), "other update").unwrap();
|
||
fs::rename(dir.join("other"), &exe).unwrap();
|
||
fs::write(dir.join("new"), "new").unwrap();
|
||
replace_binary(&dir.join("new"), &exe).unwrap();
|
||
assert_eq!(fs::read_to_string(&exe).unwrap(), "new");
|
||
// The file there keeps its mode, made executable (the swapped-in one was 0644).
|
||
assert_eq!(
|
||
fs::metadata(&exe).unwrap().permissions().mode() & 0o777,
|
||
0o755
|
||
);
|
||
// Gone altogether: it is put back, executable.
|
||
fs::remove_file(&exe).unwrap();
|
||
replace_binary(&dir.join("new"), &exe).unwrap();
|
||
assert_eq!(fs::read_to_string(&exe).unwrap(), "new");
|
||
assert_eq!(
|
||
fs::metadata(&exe).unwrap().permissions().mode() & 0o777,
|
||
0o755
|
||
);
|
||
// No temporary file is left beside it.
|
||
let mut names: Vec<String> = fs::read_dir(&dir)
|
||
.unwrap()
|
||
.flatten()
|
||
.map(|e| e.file_name().to_string_lossy().into_owned())
|
||
.collect();
|
||
names.sort();
|
||
assert_eq!(names, ["horizon-launcher", "new"]);
|
||
let _ = fs::remove_dir_all(&dir);
|
||
}
|
||
|
||
#[test]
|
||
fn crash_reports_are_found_and_summarised() {
|
||
let dir =
|
||
std::env::temp_dir().join(format!("horizon-launcher-crash-{}", std::process::id()));
|
||
let _ = fs::remove_dir_all(&dir);
|
||
let start = std::time::SystemTime::now() - std::time::Duration::from_secs(2);
|
||
assert!(crash_report_in_since(&dir, start).is_none());
|
||
fs::create_dir_all(&dir).unwrap();
|
||
let report = "---- Horizon Crash Report ----\n// Details below.\n\nTime: 2026-10-14 09:05:07\nDescription: Unexpected error\n\npanicked at src/game.rs:10:5:\nboom\n\t0: horizon_client::game::frame\n";
|
||
fs::write(dir.join("crash-2026-10-14_09.05.07-client.txt"), report).unwrap();
|
||
fs::write(dir.join("notes.txt"), "x").unwrap();
|
||
assert_eq!(
|
||
crash_report_in_since(&dir, start).unwrap(),
|
||
dir.join("crash-2026-10-14_09.05.07-client.txt")
|
||
);
|
||
let later = std::time::SystemTime::now() + std::time::Duration::from_secs(60);
|
||
assert!(crash_report_in_since(&dir, later).is_none());
|
||
assert_eq!(
|
||
crash_summary(report).as_deref(),
|
||
Some("panicked at src/game.rs:10:5: boom")
|
||
);
|
||
assert_eq!(crash_summary("no report"), None);
|
||
let log = dir.join("latest.log");
|
||
fs::write(&log, "a\nb\nc\n").unwrap();
|
||
assert_eq!(tail_of(&log, 2).unwrap(), "b\nc\n");
|
||
assert_eq!(tail_of(&log, 100).unwrap(), "a\nb\nc\n");
|
||
assert!(tail_of(&dir.join("missing.log"), 5).is_err());
|
||
let _ = fs::remove_dir_all(&dir);
|
||
}
|
||
|
||
#[test]
|
||
fn plain_notes() {
|
||
let text = markdown_to_text(
|
||
"# Title\n\nSome *words* and [a link](https://x.y).\n\n- one\n- two\n",
|
||
);
|
||
assert_eq!(
|
||
text,
|
||
"Title\n\nSome words and a link (https://x.y).\n\n- one\n- two\n"
|
||
);
|
||
}
|
||
}
|