Fix Java compiler/runtime selection during preparation
Pair PATH tools from a compatible JDK and always forward its home to external preparers so Java 25 exporters run with a compatible runtime. Co-Authored-By: OpenCode gpt-6.1-sol <noreply@openai.com>
This commit is contained in:
@@ -36,41 +36,64 @@ fn executable(dir: &Path, name: &str) -> PathBuf {
|
||||
})
|
||||
}
|
||||
|
||||
fn on_path(name: &str) -> Option<PathBuf> {
|
||||
std::env::split_paths(&std::env::var_os("PATH")?)
|
||||
.map(|dir| executable(&dir, name))
|
||||
.find(|p| p.is_file())
|
||||
/// Resolve compiler symlinks before picking its sibling runtime. The first `java` on the
|
||||
/// PATH may be an older, runtime-only install; it must not be paired with a newer `javac`.
|
||||
fn path_jdks(path: &OsStr) -> Vec<PathBuf> {
|
||||
std::env::split_paths(path)
|
||||
.map(|dir| executable(&dir, "javac"))
|
||||
.filter(|javac| javac.is_file())
|
||||
.map(|javac| fs::canonicalize(&javac).unwrap_or(javac))
|
||||
.filter_map(|javac| {
|
||||
let bin = javac.parent()?;
|
||||
// macOS's system tools are dispatchers, not a JDK home: JAVA_HOME=/usr
|
||||
// makes them call themselves. /usr/libexec/java_home finds the actual JDK.
|
||||
if bin.file_name()? != "bin"
|
||||
|| (cfg!(target_os = "macos") && bin == Path::new("/usr/bin"))
|
||||
{
|
||||
return None;
|
||||
}
|
||||
Some(bin.parent()?.to_path_buf())
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// The major version `javac -version` reports ("javac 25.0.1" → 25; "javac 1.8.0" → 8).
|
||||
fn javac_major(javac: &Path) -> Result<u32, String> {
|
||||
let output = command(javac)
|
||||
/// The major version `javac -version` or `java -version` reports, including Java 8's `1.8`.
|
||||
fn tool_major(program: &Path, name: &str) -> Result<u32, String> {
|
||||
let output = command(program)
|
||||
.arg("-version")
|
||||
.stdin(Stdio::null())
|
||||
.output()
|
||||
.map_err(|e| format!("{}: {e}", javac.display()))?;
|
||||
.map_err(|e| format!("{}: {e}", program.display()))?;
|
||||
let text = String::from_utf8_lossy(&output.stdout).into_owned()
|
||||
+ &String::from_utf8_lossy(&output.stderr);
|
||||
// macOS ships /usr/bin/java and /usr/bin/javac as placeholders.
|
||||
if text.contains("Unable to locate a Java Runtime") {
|
||||
return Err(format!(
|
||||
"{} is macOS's placeholder (no Java installed)",
|
||||
program.display()
|
||||
));
|
||||
}
|
||||
if !output.status.success() {
|
||||
return Err(format!(
|
||||
"{} -version failed ({}): {}",
|
||||
program.display(),
|
||||
output.status,
|
||||
text.trim()
|
||||
));
|
||||
}
|
||||
let marker = if name == "javac" { "javac" } else { "version" };
|
||||
let version = text
|
||||
.split_whitespace()
|
||||
.skip_while(|w| *w != "javac")
|
||||
.skip_while(|w| *w != marker)
|
||||
.nth(1)
|
||||
.ok_or_else(|| {
|
||||
// macOS ships /usr/bin/javac as a placeholder that only says no Java is installed.
|
||||
if text.contains("Unable to locate a Java Runtime") {
|
||||
format!(
|
||||
"{} is macOS's placeholder (no Java installed)",
|
||||
javac.display()
|
||||
)
|
||||
} else {
|
||||
format!(
|
||||
"{} -version printed no version: {}",
|
||||
javac.display(),
|
||||
text.trim()
|
||||
)
|
||||
}
|
||||
format!(
|
||||
"{} -version printed no version: {}",
|
||||
program.display(),
|
||||
text.trim()
|
||||
)
|
||||
})?;
|
||||
let mut parts = version.split(['.', '-', '+', '_']);
|
||||
let mut parts = version.trim_matches('"').split(['.', '-', '+', '_']);
|
||||
let first: u32 = parts.next().and_then(|p| p.parse().ok()).unwrap_or(0);
|
||||
Ok(if first == 1 {
|
||||
parts.next().and_then(|p| p.parse().ok()).unwrap_or(0)
|
||||
@@ -175,11 +198,10 @@ pub fn minecraft_runtimes(runtime: &Path) -> Vec<PathBuf> {
|
||||
homes
|
||||
}
|
||||
|
||||
/// Finds a JDK with `javac` of at least `major`, the version research-lock.json pins:
|
||||
/// `JAVA_HOME` when it holds one, else `javac` and `java` on the PATH (as the Python preparer
|
||||
/// ran them), else, on macOS, the JDK `/usr/libexec/java_home -v <major>` reports, else the JDK
|
||||
/// homes in `more` (the launcher's pick, Minecraft's own runtimes), else a JDK in the folders
|
||||
/// installers put them in (`jdk_parents`).
|
||||
/// Finds a JDK whose compiler and runtime are both at least `major`, the version
|
||||
/// research-lock.json pins: `JAVA_HOME`, else JDKs on the PATH, else, on macOS, the JDK
|
||||
/// `/usr/libexec/java_home -v <major>` reports, else the homes in `more` (the launcher's pick,
|
||||
/// Minecraft's own runtimes), else the folders installers use (`jdk_parents`).
|
||||
pub fn find(major: i64, more: &[PathBuf]) -> Result<Jdk, String> {
|
||||
let need = format!(
|
||||
"Java {major} is needed (a JDK with javac, e.g. Eclipse Temurin {major}). \
|
||||
@@ -194,8 +216,11 @@ pub fn find(major: i64, more: &[PathBuf]) -> Result<Jdk, String> {
|
||||
"JAVA_HOME",
|
||||
));
|
||||
}
|
||||
if let (Some(javac), Some(java)) = (on_path("javac"), on_path("java")) {
|
||||
candidates.push((javac, java, "PATH"));
|
||||
if let Some(path) = std::env::var_os("PATH") {
|
||||
for home in path_jdks(&path) {
|
||||
let bin = home.join("bin");
|
||||
candidates.push((executable(&bin, "javac"), executable(&bin, "java"), "PATH"));
|
||||
}
|
||||
}
|
||||
if cfg!(target_os = "macos") {
|
||||
if let Ok(out) = command("/usr/libexec/java_home")
|
||||
@@ -239,10 +264,19 @@ pub fn find(major: i64, more: &[PathBuf]) -> Result<Jdk, String> {
|
||||
));
|
||||
continue;
|
||||
}
|
||||
match javac_major(&javac) {
|
||||
Ok(found) if i64::from(found) >= major => return Ok(Jdk { javac, java }),
|
||||
Ok(found) => problems.push(format!("{from} has Java {found} ({})", javac.display())),
|
||||
Err(e) => problems.push(e),
|
||||
let checked = [(&javac, "javac"), (&java, "java")]
|
||||
.into_iter()
|
||||
.try_for_each(|(program, name)| {
|
||||
let found = tool_major(program, name)?;
|
||||
if i64::from(found) >= major {
|
||||
Ok(())
|
||||
} else {
|
||||
Err(format!("{name} {found} ({})", program.display()))
|
||||
}
|
||||
});
|
||||
match checked {
|
||||
Ok(()) => return Ok(Jdk { javac, java }),
|
||||
Err(e) => problems.push(format!("{from}: {e}")),
|
||||
}
|
||||
}
|
||||
if problems.is_empty() {
|
||||
|
||||
@@ -0,0 +1,133 @@
|
||||
//! Each scenario runs in its own process so Java discovery sees a controlled environment.
|
||||
use horizon_prepare::java;
|
||||
use std::{env, fs, path::Path, process::Command};
|
||||
|
||||
const TEST: &str = "selects_a_compatible_compiler_and_runtime";
|
||||
const CHILD: &str = "HORIZON_JAVA_SELECTION_CHILD";
|
||||
const ROOT: &str = "HORIZON_JAVA_SELECTION_ROOT";
|
||||
|
||||
fn tool(bin: &Path, name: &str) -> std::path::PathBuf {
|
||||
bin.join(format!("{name}{}", env::consts::EXE_SUFFIX))
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn selects_a_compatible_compiler_and_runtime() {
|
||||
if let Ok(scenario) = env::var(CHILD) {
|
||||
let root = std::path::PathBuf::from(env::var_os(ROOT).unwrap());
|
||||
if scenario.ends_with("error") {
|
||||
// Use a future compiler version to keep real installed JDKs out of the result.
|
||||
let error = java::find(255, &[]).err().expect("accepted an old runtime");
|
||||
let runtime = if scenario == "legacy-runtime-error" {
|
||||
8
|
||||
} else {
|
||||
21
|
||||
};
|
||||
assert!(error.contains(&format!("java {runtime} (")), "{error}");
|
||||
return;
|
||||
}
|
||||
let jdk = java::find(25, &[]).unwrap();
|
||||
let expected = root.join(if scenario == "target-release" {
|
||||
"newer"
|
||||
} else {
|
||||
"jdk25"
|
||||
});
|
||||
for (actual, name) in [(&jdk.javac, "javac"), (&jdk.java, "java")] {
|
||||
assert_eq!(
|
||||
fs::canonicalize(actual).unwrap(),
|
||||
fs::canonicalize(tool(&expected.join("bin"), name)).unwrap()
|
||||
);
|
||||
}
|
||||
assert_eq!(
|
||||
fs::canonicalize(jdk.home()).unwrap(),
|
||||
fs::canonicalize(expected).unwrap()
|
||||
);
|
||||
let log_path = root.join(format!("{scenario}.log"));
|
||||
let log = fs::File::create(&log_path).unwrap();
|
||||
jdk.java(&[], None, &log).unwrap();
|
||||
assert_eq!(fs::read_to_string(log_path).unwrap().trim(), "java 25.0.1");
|
||||
return;
|
||||
}
|
||||
|
||||
let root = env::temp_dir().join(format!("horizon-java-selection-{}", std::process::id()));
|
||||
fs::create_dir_all(&root).unwrap();
|
||||
let probe = tool(&root, "probe");
|
||||
let output = Command::new("rustc")
|
||||
.arg(Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/support/java_probe.rs"))
|
||||
.arg("-o")
|
||||
.arg(&probe)
|
||||
.output()
|
||||
.unwrap();
|
||||
assert!(
|
||||
output.status.success(),
|
||||
"{}",
|
||||
String::from_utf8_lossy(&output.stderr)
|
||||
);
|
||||
for (home, compiler, runtime) in [
|
||||
("jre21", None, "21.0.1"),
|
||||
("jdk21", Some("21.0.1"), "21.0.1"),
|
||||
("jdk25", Some("25.0.1"), "25.0.1"),
|
||||
("mixed", Some("25.0.1"), "21.0.1"),
|
||||
("failing", Some("25.0.1"), "25.0.1"),
|
||||
("newer", Some("26-ea+1"), "25.0.1"),
|
||||
("future", Some("255.0.1"), "21.0.1"),
|
||||
("legacy", Some("255.0.1"), "1.8.0_442"),
|
||||
] {
|
||||
let bin = root.join(home).join("bin");
|
||||
fs::create_dir_all(&bin).unwrap();
|
||||
for (name, version) in [("javac", compiler), ("java", Some(runtime))] {
|
||||
if let Some(version) = version {
|
||||
fs::copy(&probe, tool(&bin, name)).unwrap();
|
||||
fs::write(bin.join(format!("{name}.version")), version).unwrap();
|
||||
}
|
||||
}
|
||||
}
|
||||
fs::write(root.join("failing/bin/java.exit"), "7").unwrap();
|
||||
let scenarios = vec![
|
||||
("older-runtime", None, vec!["jre21", "jdk25"]),
|
||||
("older-jdk", None, vec!["jdk21", "jdk25"]),
|
||||
("incompatible-home", Some("mixed"), vec!["jdk25"]),
|
||||
("failed-runtime", Some("failing"), vec!["jdk25"]),
|
||||
("target-release", Some("newer"), vec![]),
|
||||
("runtime-error", Some("future"), vec![]),
|
||||
("legacy-runtime-error", Some("legacy"), vec![]),
|
||||
];
|
||||
#[cfg(unix)]
|
||||
let scenarios = {
|
||||
let mut scenarios = scenarios;
|
||||
let bin = root.join("shims/bin");
|
||||
fs::create_dir_all(&bin).unwrap();
|
||||
std::os::unix::fs::symlink(tool(&root.join("jdk25/bin"), "javac"), tool(&bin, "javac"))
|
||||
.unwrap();
|
||||
std::os::unix::fs::symlink(tool(&root.join("jre21/bin"), "java"), tool(&bin, "java"))
|
||||
.unwrap();
|
||||
scenarios.push(("symlinked-path", None, vec!["shims"]));
|
||||
scenarios
|
||||
};
|
||||
for (scenario, home, path) in scenarios {
|
||||
let mut child = Command::new(env::current_exe().unwrap());
|
||||
child
|
||||
.args(["--exact", TEST, "--nocapture"])
|
||||
.env(CHILD, scenario)
|
||||
.env(ROOT, &root)
|
||||
.env(
|
||||
"PATH",
|
||||
env::join_paths(path.iter().map(|home| root.join(home).join("bin"))).unwrap(),
|
||||
)
|
||||
.env("HOME", &root)
|
||||
.env("USERPROFILE", &root)
|
||||
.env("ProgramFiles", &root)
|
||||
.env("ProgramW6432", &root)
|
||||
.env_remove("JAVA_HOME");
|
||||
if let Some(home) = home {
|
||||
child.env("JAVA_HOME", root.join(home));
|
||||
}
|
||||
let output = child.output().unwrap();
|
||||
assert!(
|
||||
output.status.success(),
|
||||
"{scenario}:\n{}\n{}",
|
||||
String::from_utf8_lossy(&output.stdout),
|
||||
String::from_utf8_lossy(&output.stderr)
|
||||
);
|
||||
}
|
||||
fs::remove_dir_all(root).unwrap();
|
||||
}
|
||||
@@ -0,0 +1,21 @@
|
||||
//! A fake Java tool for process-level JDK selection tests; no installed Java is needed.
|
||||
use std::{env, fs, process};
|
||||
|
||||
fn main() {
|
||||
let executable = env::current_exe().unwrap();
|
||||
let bin = executable.parent().unwrap();
|
||||
let tool = executable.file_stem().unwrap().to_str().unwrap();
|
||||
let version = fs::read_to_string(bin.join(format!("{tool}.version"))).unwrap();
|
||||
if env::args().nth(1).as_deref() == Some("-version") {
|
||||
if tool == "javac" {
|
||||
println!("javac {version}");
|
||||
} else {
|
||||
eprintln!("openjdk version \"{version}\"");
|
||||
}
|
||||
} else {
|
||||
println!("{tool} {version}");
|
||||
}
|
||||
if let Ok(status) = fs::read_to_string(bin.join(format!("{tool}.exit"))) {
|
||||
process::exit(status.parse().unwrap());
|
||||
}
|
||||
}
|
||||
+16
-19
@@ -1022,21 +1022,18 @@ fn download_for_owner(
|
||||
}
|
||||
}
|
||||
|
||||
/// A JDK of at least `major` for the preparation. `None` when horizon-prepare finds one by
|
||||
/// itself (JAVA_HOME, the PATH, an installed JDK): the preparation then runs as before, in an
|
||||
/// unchanged environment (a JDK found on the PATH can be a stub such as macOS's
|
||||
/// /usr/bin/javac, whose folder is no Java home: `JAVA_HOME=/usr` makes it call itself
|
||||
/// forever). Else the home of the Java the official launcher downloaded into one of the
|
||||
/// `games` folders, else of Minecraft's own Java downloaded from Mojang into Horizon's game
|
||||
/// folder, the runtime the version JSON at `manifest` names (Mojang's runtimes are whole JDKs).
|
||||
/// The home of a JDK whose compiler and runtime support `major`. Forward even an installed
|
||||
/// JDK to external preparers: older versions may otherwise rediscover incompatible PATH tools.
|
||||
/// Else try the official launcher's Java in `games`, then download the runtime named by
|
||||
/// `manifest` into Horizon's game folder (Mojang's runtimes are whole JDKs).
|
||||
fn java(
|
||||
major: i64,
|
||||
games: &[PathBuf],
|
||||
manifest: &Path,
|
||||
log: &dyn Fn(String),
|
||||
) -> Result<Option<PathBuf>, String> {
|
||||
if horizon_prepare::java::find(major, &[]).is_ok() {
|
||||
return Ok(None);
|
||||
) -> Result<PathBuf, String> {
|
||||
if let Ok(jdk) = horizon_prepare::java::find(major, &[]) {
|
||||
return Ok(jdk.home());
|
||||
}
|
||||
let mut runtimes: Vec<PathBuf> = Vec::new();
|
||||
for home in games
|
||||
@@ -1048,7 +1045,7 @@ fn java(
|
||||
}
|
||||
}
|
||||
let missing = match horizon_prepare::java::find(major, &runtimes) {
|
||||
Ok(jdk) => return Ok(Some(jdk.home())),
|
||||
Ok(jdk) => return Ok(jdk.home()),
|
||||
Err(e) => e,
|
||||
};
|
||||
let component = read_json(manifest)
|
||||
@@ -1073,7 +1070,7 @@ fn java(
|
||||
let home = mojang::java_runtime(&component, &runtime, 8, &fetch, log).map_err(|e| {
|
||||
format!("{missing}\n • Horizon also tried to download Minecraft's own Java from Mojang, but: {e}")
|
||||
})?;
|
||||
horizon_prepare::java::find(major, &[home]).map(|jdk| Some(jdk.home()))
|
||||
horizon_prepare::java::find(major, &[home]).map(|jdk| jdk.home())
|
||||
}
|
||||
|
||||
/// The dynamic loader glibc programs on x86-64 Linux start through.
|
||||
@@ -1196,14 +1193,12 @@ pub fn preparer(
|
||||
import: !reused,
|
||||
minecraft_dir: Some(minecraft.clone()),
|
||||
server_jar: (!reused).then_some(jar),
|
||||
java_home: java_home.clone(),
|
||||
java_home: Some(java_home.clone()),
|
||||
};
|
||||
return Ok((Preparer::InProcess(options), minecraft));
|
||||
}
|
||||
let mut cmd = Command::new(binary);
|
||||
if let Some(home) = &java_home {
|
||||
with_java(&mut cmd, home);
|
||||
}
|
||||
with_java(&mut cmd, &java_home);
|
||||
cmd.current_dir(&dir).arg("--root").arg(&dir);
|
||||
if !reused {
|
||||
cmd.args(["--prepare", "--server-jar"]).arg(&jar);
|
||||
@@ -1212,9 +1207,7 @@ pub fn preparer(
|
||||
return Ok((Preparer::Process(cmd), minecraft));
|
||||
}
|
||||
let mut cmd = Command::new(python.unwrap());
|
||||
if let Some(home) = &java_home {
|
||||
with_java(&mut cmd, home);
|
||||
}
|
||||
with_java(&mut cmd, &java_home);
|
||||
cmd.current_dir(&dir)
|
||||
.args(["-u", "tools/prepare_native_client.py"]);
|
||||
if !reused {
|
||||
@@ -2338,6 +2331,10 @@ impl Settings {
|
||||
#[path = "backend/release_loading_tests.rs"]
|
||||
mod release_loading_tests;
|
||||
|
||||
#[cfg(test)]
|
||||
#[path = "backend/java_tests.rs"]
|
||||
mod java_tests;
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
@@ -0,0 +1,85 @@
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn selected_jdk_reaches_external_preparers() {
|
||||
const CHILD: &str = "HORIZON_LAUNCHER_JAVA_TEST";
|
||||
if let Some(root) = std::env::var_os(CHILD) {
|
||||
let root = PathBuf::from(root);
|
||||
let home = java(25, &[], &root.join("missing.json"), &|_| {}).unwrap();
|
||||
assert_eq!(
|
||||
fs::canonicalize(&home).unwrap(),
|
||||
fs::canonicalize(root.join("jdk25")).unwrap()
|
||||
);
|
||||
// An older preparer invokes Java tools by name; both must now resolve to this JDK.
|
||||
for name in ["java", "javac"] {
|
||||
let mut cmd = crate::process::command(name);
|
||||
with_java(&mut cmd, &home);
|
||||
let output = cmd.arg("-version").output().unwrap();
|
||||
assert!(output.status.success());
|
||||
let text = String::from_utf8_lossy(&output.stdout).into_owned()
|
||||
+ &String::from_utf8_lossy(&output.stderr);
|
||||
assert!(text.contains("25.0.1"), "{name}: {text}");
|
||||
assert_eq!(
|
||||
cmd.get_envs()
|
||||
.find(|(key, _)| *key == "JAVA_HOME")
|
||||
.unwrap()
|
||||
.1,
|
||||
Some(home.as_os_str())
|
||||
);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
let root = std::env::temp_dir().join(format!("horizon-launcher-java-{}", std::process::id()));
|
||||
fs::create_dir_all(&root).unwrap();
|
||||
let executable =
|
||||
|bin: &Path, name: &str| bin.join(format!("{name}{}", std::env::consts::EXE_SUFFIX));
|
||||
let probe = executable(&root, "probe");
|
||||
let source = Path::new(env!("CARGO_MANIFEST_DIR"))
|
||||
.join("../crates/horizon-prepare/tests/support/java_probe.rs");
|
||||
let output = crate::process::command("rustc")
|
||||
.arg(source)
|
||||
.arg("-o")
|
||||
.arg(&probe)
|
||||
.output()
|
||||
.unwrap();
|
||||
assert!(
|
||||
output.status.success(),
|
||||
"{}",
|
||||
String::from_utf8_lossy(&output.stderr)
|
||||
);
|
||||
for (home, compiler, runtime) in [
|
||||
("jre21", None, "21.0.1"),
|
||||
("jdk25", Some("25.0.1"), "25.0.1"),
|
||||
] {
|
||||
let bin = root.join(home).join("bin");
|
||||
fs::create_dir_all(&bin).unwrap();
|
||||
for (name, version) in [("javac", compiler), ("java", Some(runtime))] {
|
||||
if let Some(version) = version {
|
||||
fs::copy(&probe, executable(&bin, name)).unwrap();
|
||||
fs::write(bin.join(format!("{name}.version")), version).unwrap();
|
||||
}
|
||||
}
|
||||
}
|
||||
let output = crate::process::command(std::env::current_exe().unwrap())
|
||||
.args([
|
||||
"--exact",
|
||||
"backend::java_tests::selected_jdk_reaches_external_preparers",
|
||||
"--nocapture",
|
||||
])
|
||||
.env(CHILD, &root)
|
||||
.env_remove("JAVA_HOME")
|
||||
.env(
|
||||
"PATH",
|
||||
std::env::join_paths([root.join("jre21/bin"), root.join("jdk25/bin")]).unwrap(),
|
||||
)
|
||||
.output()
|
||||
.unwrap();
|
||||
assert!(
|
||||
output.status.success(),
|
||||
"{}\n{}",
|
||||
String::from_utf8_lossy(&output.stdout),
|
||||
String::from_utf8_lossy(&output.stderr)
|
||||
);
|
||||
fs::remove_dir_all(root).unwrap();
|
||||
}
|
||||
Reference in New Issue
Block a user