Skip to content

The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.

fix(java): provision an isolated runtime for the Java language server (#370)

l0ng-ai9575500dd6e7
diff --git a/crates/ide-host/src/java_runtime.rs b/crates/ide-host/src/java_runtime.rs
new file mode 100644
index 000000000..dde51032e
--- /dev/null
+++ b/crates/ide-host/src/java_runtime.rs
@@ -0,0 +1,183 @@
+//! Automatic runtime provisioning belongs to the host, not SDK discovery.
+use ide_core::{CancellationToken, IdeEvent, SharedSink, TaskId};
+use ide_language::LanguageServerConfig;
+use ide_sdk::java::{jdtls_jdks, jdtls_min_java, jdtls_runtime, language_server_runtimes_dir};
+use parking_lot::{Condvar, Mutex};
+use std::collections::HashSet;
+use std::path::{Path, PathBuf};
+use std::sync::{Arc, LazyLock, Weak};
+use std::time::Duration;
+
+#[derive(Default)]
+struct State {
+ busy: bool,
+ sinks: Vec<Weak<dyn ide_core::EventSink>>,
+ attempted: HashSet<(PathBuf, u32)>,
+}
+
+#[derive(Default)]
+struct Provisioner {
+ state: Mutex<State>,
+ changed: Condvar,
+}
+
+static PROVISIONER: LazyLock<Provisioner> = LazyLock::new(Provisioner::default);
+
+fn needs_download(explicit: bool, suitable: bool, attempted: bool) -> bool {
+ !explicit && !suitable && !attempted
+}
+
+impl Provisioner {
+ fn subscribe(&self, sink: &SharedSink) {
+ let mut state = self.state.lock();
+ state.sinks.retain(|s| s.strong_count() > 0);
+ let weak = Arc::downgrade(sink);
+ if !state.sinks.iter().any(|s| s.ptr_eq(&weak)) {
+ state.sinks.push(weak);
+ }
+ }
+
+ fn emit(&self, event: IdeEvent) {
+ let sinks: Vec<_> = self.state.lock().sinks.iter().filter_map(Weak::upgrade).collect();
+ for sink in sinks {
+ sink.emit(event.clone());
+ }
+ }
+
+ fn run(&self, key: (PathBuf, u32), cancel: &CancellationToken, work: impl FnOnce()) {
+ let mut state = self.state.lock();
+ while state.busy && !cancel.is_cancelled() {
+ self.changed.wait_for(&mut state, Duration::from_millis(100));
+ }
+ if cancel.is_cancelled() || !state.attempted.insert(key) {
+ return;
+ }
+ state.busy = true;
+ drop(state);
+ // Even a panicking installer must release waiters and retain the attempt.
+ struct Flight<'a>(&'a Provisioner);
+ impl Drop for Flight<'_> {
+ fn drop(&mut self) {
+ self.0.state.lock().busy = false;
+ self.0.changed.notify_all();
+ }
+ }
+ let _flight = Flight(self);
+ work();
+ }
+}
+
+pub(crate) fn prepare(
+ cfg: &LanguageServerConfig,
+ data_dir: &Path,
+ explicit: bool,
+ sink: &SharedSink,
+ launch_cancel: &CancellationToken,
+) {
+ let min_java = jdtls_min_java(cfg);
+ let jdks = jdtls_jdks(min_java, data_dir);
+ // A launch environment override is explicit too, even if it is invalid.
+ if !needs_download(explicit || cfg.env.contains_key("JAVA_HOME"), jdtls_runtime(&jdks, min_java).is_some(), false) {
+ return;
+ }
+ PROVISIONER.subscribe(sink);
+ PROVISIONER.run((data_dir.to_path_buf(), min_java), launch_cancel, || {
+ if jdtls_runtime(&jdtls_jdks(min_java, data_dir), min_java).is_some() {
+ return;
+ }
+ let id = TaskId::next();
+ let title = format!("Downloading Java {min_java} language server runtime");
+ // Closing one project must not cancel a download other projects await.
+ let cancel = CancellationToken::new();
+ let _handle = ide_core::task::on_cancel(id, {
+ let cancel = cancel.clone();
+ move || cancel.cancel()
+ });
+ let emit = |message, fraction, done| {
+ PROVISIONER.emit(IdeEvent::Task { id, title: title.clone(), message, fraction, done, cancellable: !done });
+ };
+ emit(Some("Eclipse Temurin".into()), None, false);
+ let result = ide_tools::Tools::new(data_dir).download_java_runtime(
+ min_java,
+ &language_server_runtimes_dir(data_dir),
+ &cancel,
+ &|event| match event {
+ ide_tools::InstallEvent::Line { text } => emit(Some(text), None, false),
+ ide_tools::InstallEvent::Progress { fraction, message } => {
+ emit(Some(message), fraction.map(|f| f as f32), false)
+ }
+ },
+ );
+ emit(result.as_ref().err().map(ToString::to_string), Some(1.0), true);
+ if let Err(error) = result {
+ // The configuration hook retains the existing manual download action.
+ tracing::warn!("automatic jdtls runtime download: {error}");
+ }
+ });
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use std::sync::atomic::{AtomicUsize, Ordering};
+
+ #[test]
+ fn download_decision() {
+ assert!(needs_download(false, false, false));
+ for (explicit, suitable, attempted) in [(true, false, false), (false, true, false), (false, false, true)] {
+ assert!(!needs_download(explicit, suitable, attempted));
+ }
+ }
+
+ #[test]
+ fn simultaneous_projects_share_one_attempt_and_failures_do_not_retry() {
+ let provisioner = Provisioner::default();
+ let calls = AtomicUsize::new(0);
+ let barrier = std::sync::Barrier::new(8);
+ std::thread::scope(|scope| {
+ for _ in 0..8 {
+ scope.spawn(|| {
+ barrier.wait();
+ provisioner.run((PathBuf::from("/data"), 25), &CancellationToken::new(), || {
+ calls.fetch_add(1, Ordering::SeqCst);
+ std::thread::sleep(Duration::from_millis(30));
+ });
+ });
+ }
+ });
+ provisioner.run((PathBuf::from("/data"), 25), &CancellationToken::new(), || panic!("retried"));
+ assert_eq!(calls.load(Ordering::SeqCst), 1);
+ }
+
+ #[test]
+ fn different_versions_are_still_single_flight() {
+ let provisioner = Provisioner::default();
+ let active = AtomicUsize::new(0);
+ let calls = AtomicUsize::new(0);
+ std::thread::scope(|scope| {
+ for feature in [25, 26, 27] {
+ let provisioner = &provisioner;
+ let active = &active;
+ let calls = &calls;
+ scope.spawn(move || {
+ provisioner.run((PathBuf::from("/data"), feature), &CancellationToken::new(), || {
+ assert_eq!(active.fetch_add(1, Ordering::SeqCst), 0);
+ std::thread::sleep(Duration::from_millis(10));
+ calls.fetch_add(1, Ordering::SeqCst);
+ active.fetch_sub(1, Ordering::SeqCst);
+ });
+ });
+ }
+ });
+ assert_eq!(calls.load(Ordering::SeqCst), 3);
+ }
+
+ #[test]
+ fn cancelled_waiter_does_not_consume_an_attempt() {
+ let provisioner = Provisioner::default();
+ let cancel = CancellationToken::new();
+ cancel.cancel();
+ provisioner.run((PathBuf::from("/data"), 25), &cancel, || panic!("cancelled"));
+ assert!(provisioner.state.lock().attempted.is_empty());
+ }
+}
diff --git a/crates/ide-host/src/lib.rs b/crates/ide-host/src/lib.rs
index 294d8a98c..0699b791b 100644
--- a/crates/ide-host/src/lib.rs
+++ b/crates/ide-host/src/lib.rs
@@ -4,6 +4,7 @@
//! runs one on a remote machine and serves it over JSON-RPC ([`rpc`]).
pub mod environment;
+mod java_runtime;
pub mod notebook;
pub mod ops;
mod project;
diff --git a/crates/ide-host/src/project.rs b/crates/ide-host/src/project.rs
index 4e2069795..d8f616550 100644
--- a/crates/ide-host/src/project.rs
+++ b/crates/ide-host/src/project.rs
@@ -126,7 +126,7 @@ impl Host {
let bundles: Vec<PathBuf> =
ide_tools::managed_bundle(&data_dir, "java-debug").into_iter().collect();
let min_java = ide_sdk::java::jdtls_min_java(cfg);
- let jdks = ide_sdk::java::jdtls_jdks(min_java);
+ let jdks = ide_sdk::java::jdtls_jdks(min_java, &data_dir);
let lombok = ide_sdk::lombok::lombok_agent(
server_root,
ide_sdk::lombok::agent_in_args(cfg.args.iter().map(String::as_str)),
@@ -158,6 +158,25 @@ impl Host {
ide_sdk::apply::configure_maven_import(cfg, &root, &excluded_poms);
}));
}
+ {
+ let settings = settings.clone();
+ let root = root.clone();
+ let data_dir = self.data_dir.clone();
+ let sink = sink.clone();
+ lsp.set_prepare_hook(Box::new(move |cfg, _, cancel| {
+ let effective = settings.effective();
+ if cfg.name == "jdtls" {
+ crate::java_runtime::prepare(
+ cfg,
+ &data_dir,
+ !effective.languages.java.jdtls_jdk.trim().is_empty()
+ || ide_sdk::apply::jdtls_jdk(&root, &effective).is_err(),
+ &sink,
+ cancel,
+ );
+ }
+ }));
+ }
{
let settings = settings.clone();
lsp.set_servers_hook(Box::new(move |language, defined| {
diff --git a/crates/ide-lsp/src/lib.rs b/crates/ide-lsp/src/lib.rs
index 403a82193..fc00c840b 100644
--- a/crates/ide-lsp/src/lib.rs
+++ b/crates/ide-lsp/src/lib.rs
@@ -75,6 +75,8 @@ pub type ApplyEditHook = Arc<dyn Fn(WorkspaceEdit) -> bool + Send + Sync>;
/// settings before each launch; receives the server's workspace root.
pub type ConfigFn = dyn Fn(&mut LanguageServerConfig, &Path) + Send + Sync;
pub type ConfigHook = Arc<ConfigFn>;
+/// Prepares dependencies on a blocking worker immediately before launching an installed server.
+pub type PrepareFn = dyn Fn(&LanguageServerConfig, &Path, &CancellationToken) + Send + Sync;
/// The servers a language uses, from its definition's list (user settings
/// disable some and add others).
pub type ServersFn = dyn Fn(&LanguageId, &[LanguageServerConfig]) -> Vec<LanguageServerConfig> + Send + Sync;
@@ -163,6 +165,7 @@ pub struct LspManager {
docs: Mutex<HashMap<DocId, DocState>>,
apply_edit_hook: RwLock<Option<ApplyEditHook>>,
config_hook: RwLock<Option<ConfigHook>>,
+ prepare_hook: RwLock<Option<Arc<PrepareFn>>>,
servers_hook: RwLock<Option<Arc<ServersFn>>>,
candidates_hook: RwLock<Option<Arc<CandidateFn>>>,
shutting_down: AtomicBool,
@@ -291,6 +294,7 @@ impl LspManager {
docs: Mutex::new(HashMap::new()),
apply_edit_hook: RwLock::new(None),
config_hook: RwLock::new(None),
+ prepare_hook: RwLock::new(None),
servers_hook: RwLock::new(None),
candidates_hook: RwLock::new(None),
shutting_down: AtomicBool::new(false),
@@ -408,7 +412,16 @@ impl LspManager {
// The settings hook may touch the filesystem (e.g. scanning for JDKs); TCP
// servers may take a while to start listening.
let launched = tokio::task::spawn_blocking(move || {
- let cfg = me.configured(&tail);
+ let mut cfg = me.configured(&tail);
+ tail.set_effective_config(cfg.clone());
+ let prepare = me.prepare_hook.read().clone();
+ if !cancel.is_cancelled()
+ && me.launcher.available(&cfg, &tail.root)
+ && let Some(prepare) = prepare
+ {
+ prepare(&cfg, &tail.root, &cancel);
+ cfg = me.configured(&tail);
+ }
tail.set_effective_config(cfg.clone());
let root = tail.root.clone();
if let Some(message) = &cfg.launch_error {
@@ -1901,6 +1914,10 @@ impl LspManager {
*self.config_hook.write() = Some(Arc::from(hook));
}
+ pub fn set_prepare_hook(&self, hook: Box<PrepareFn>) {
+ *self.prepare_hook.write() = Some(Arc::from(hook));
+ }
+
/// Installed by `src-tauri` to apply the servers enabled / defined in settings.
pub fn set_servers_hook(&self, hook: Box<ServersFn>) {
*self.servers_hook.write() = Some(Arc::from(hook));
diff --git a/crates/ide-lsp/tests/mock_server.rs b/crates/ide-lsp/tests/mock_server.rs
index 2e57fb675..fca890e8f 100644
--- a/crates/ide-lsp/tests/mock_server.rs
+++ b/crates/ide-lsp/tests/mock_server.rs
@@ -905,6 +905,38 @@ async fn launch_error_fails_without_starting_the_server() {
assert!(!h.statuses("mock").contains(&ServerStatus::Crashed));
}
+#[tokio::test(flavor = "multi_thread")]
+async fn preparation_refreshes_config_and_survives_unchanged_settings() {
+ use std::sync::atomic::AtomicBool;
+ let h = harness(&[("mock", incremental_caps())]);
+ let prepared = Arc::new(AtomicBool::new(false));
+ let started = Arc::new(AtomicUsize::new(0));
+ let (release, wait) = std::sync::mpsc::channel();
+ let wait = Mutex::new(wait);
+ h.mgr.set_config_hook(Box::new({
+ let prepared = prepared.clone();
+ move |cfg, _| {
+ cfg.launch_error = (!prepared.load(Ordering::SeqCst)).then(|| "needs runtime".into());
+ }
+ }));
+ h.mgr.set_prepare_hook(Box::new({
+ let started = started.clone();
+ move |_, _, cancel| {
+ started.fetch_add(1, Ordering::SeqCst);
+ wait.lock().recv_timeout(Duration::from_secs(5)).unwrap();
+ assert!(!cancel.is_cancelled(), "unchanged settings cancelled preparation");
+ prepared.store(true, Ordering::SeqCst);
+ }
+ }));
+ h.open("a.mk", "x");
+ eventually(|| started.load(Ordering::SeqCst) > 0).await;
+ h.mgr.reconfigure().await;
+ release.send(()).unwrap();
+ h.wait_status("mock", ServerStatus::Ready).await;
+ assert_eq!(started.load(Ordering::SeqCst), 1);
+ assert_eq!(h.launcher.state("mock").launches.load(Ordering::SeqCst), 1);
+}
+
#[tokio::test(flavor = "multi_thread")]
async fn settings_changes_reach_servers_without_restarts() {
let h = harness(&[("mock", incremental_caps()), ("extra", incremental_caps())]);
diff --git a/crates/ide-sdk/src/java.rs b/crates/ide-sdk/src/java.rs
index 55a56c090..40659ff31 100644
--- a/crates/ide-sdk/src/java.rs
+++ b/crates/ide-sdk/src/java.rs
@@ -44,6 +44,12 @@ fn children(dir: &Path) -> Vec<PathBuf> {
out
}
+fn jdk_homes(root: &Path) -> impl Iterator<Item = PathBuf> {
+ children(root)
+ .into_iter()
+ .flat_map(|dir| [dir.join("Contents/Home"), dir.join("libexec/openjdk.jdk/Contents/Home"), dir])
+}
+
/// Vendor directories JDK installers use on Windows, under `Program Files`
/// and (per-user installs) `%LOCALAPPDATA%\Programs`.
const WINDOWS_VENDORS: &[&str] =
@@ -106,9 +112,7 @@ fn scan() -> Vec<Jdk> {
if roots[..i].contains(root) {
continue;
}
- for dir in children(root) {
- homes.extend([dir.join("Contents/Home"), dir.join("libexec/openjdk.jdk/Contents/Home"), dir]);
- }
+ homes.extend(jdk_homes(root));
}
// mise keeps a macOS JDK as its bundle (`<version>/Contents/Home`), asdf flattens it.
for (dir, _) in ide_core::version_managers::installs(ide_core::version_managers::Tool::Java) {
@@ -157,12 +161,24 @@ pub fn installed_jdks() -> Arc<[Jdk]> {
/// Like [`installed_jdks`], but while none can run jdtls (on Java `min_java`)
/// the list is rescanned (at most every [`RESCAN_AFTER`]), so a JDK installed
/// after startup is picked up when the server is restarted.
-pub fn jdtls_jdks(min_java: u32) -> Arc<[Jdk]> {
+pub fn jdtls_jdks(min_java: u32, data_dir: &Path) -> Arc<[Jdk]> {
let mut slot = JDKS.lock().unwrap_or_else(|e| e.into_inner());
- match &*slot {
+ let installed = match &*slot {
Some(s) if jdtls_runtime(&s.jdks, min_java).is_some() || s.at.elapsed() < RESCAN_AFTER => s.jdks.clone(),
_ => rescan(&mut slot),
- }
+ };
+ runtime_candidates(&installed, data_dir).into()
+}
+
+/// Runtime-only downloads are never registered as project discovery roots.
+pub fn language_server_runtimes_dir(data_dir: &Path) -> PathBuf {
+ data_dir.join("language-server-runtimes")
+}
+
+fn runtime_candidates(installed: &[Jdk], data_dir: &Path) -> Vec<Jdk> {
+ let mut jdks = installed.to_vec();
+ jdks.extend(jdk_homes(&language_server_runtimes_dir(data_dir)).filter_map(|home| jdk_at(&home)));
+ jdks
}
/// For a server with `max-java`: when the `JAVA_HOME` it would get (its env,
@@ -341,6 +357,14 @@ pub fn configure_jdtls(
cfg.args.push(format!("--jvm-arg=-javaagent:{}", jar.to_string_lossy()));
}
crate::jdtls::add_default_vm_args(&mut cfg.args);
+ let managed = language_server_runtimes_dir(data_dir);
+ let managed = dunce::canonicalize(&managed).unwrap_or(managed);
+ let project_jdks: Vec<_> = project_jdk
+ .into_iter()
+ .chain(jdks)
+ .filter(|jdk| !jdk.home.starts_with(&managed) || project_jdk == Some(*jdk))
+ .cloned()
+ .collect();
let mut all: Vec<Jdk> = Vec::new();
for j in project_jdk.into_iter().chain(jdks).chain(server_jdk) {
if !all.contains(j) {
@@ -361,11 +385,12 @@ pub fn configure_jdtls(
Err(e) => cfg.launch_error = Some(e),
}
}
- let mut runtimes = runtimes(jdks);
- if let Some(project) = project_jdk {
- let home = project.home.to_string_lossy();
+ let mut runtimes = runtimes(&project_jdks);
+ if let Some(project) = project_jdk.or_else(|| pick_jdk(&project_jdks, project_java_version(server_root))) {
+ let name = if project.major == 8 { "JavaSE-1.8".to_owned() } else { format!("JavaSE-{}", project.major) };
for r in &mut runtimes {
- if r["path"] == *home {
+ if r["name"] == name {
+ r["path"] = json!(project.home.to_string_lossy());
r["default"] = json!(true);
}
}
@@ -502,6 +527,58 @@ fn parse_java_version(v: &str) -> Option<u32> {
mod tests {
use super::*;
+ #[test]
+ fn provisioning_runtime_preserves_implicit_project_jdk() {
+ let data = tempfile::tempdir().unwrap();
+ let project_root = data.path().join("tools/jdks");
+ let project_home = project_root.join("temurin-21");
+ std::fs::create_dir_all(project_home.join("bin")).unwrap();
+ std::fs::write(project_home.join("release"), "JAVA_VERSION=\"21.0.1\"\n").unwrap();
+ std::fs::write(java_executable(&project_home), "").unwrap();
+ let project = jdk_at(&project_home).unwrap();
+ let discover = || jdk_homes(&project_root).filter_map(|home| jdk_at(&home)).collect::<Vec<_>>();
+ let installed = discover();
+ assert_eq!(pick_jdk(&installed, None), Some(&project));
+ assert!(jdtls_runtime(&runtime_candidates(&installed, data.path()), 25).is_none());
+ let home = language_server_runtimes_dir(data.path()).join("temurin-25");
+ std::fs::create_dir_all(home.join("bin")).unwrap();
+ std::fs::write(home.join("release"), "JAVA_VERSION=\"25.0.1\"\n").unwrap();
+ std::fs::write(java_executable(&home), "").unwrap();
+ let candidates = runtime_candidates(&installed, data.path());
+ assert_eq!(jdtls_runtime(&candidates, 25).unwrap().major, 25);
+ assert_eq!(jdtls_runtime(&candidates, 21), Some(&project));
+ assert_eq!(pick_jdk(&discover(), None), Some(&project));
+ let explicit = jdk_at(&home).unwrap();
+ assert_eq!(pick_jdk(std::slice::from_ref(&explicit), None), Some(&explicit));
+ let mut cfg: LanguageServerConfig = serde_json::from_value(json!({"name":"jdtls", "command":"jdtls"})).unwrap();
+ configure_jdtls(&mut cfg, data.path(), data.path(), &candidates, None, None, 25, &[], None);
+ assert_eq!(cfg.env["JAVA_HOME"], explicit.home.to_string_lossy());
+ let options = serde_json::to_string(&cfg.initialization_options).unwrap();
+ assert!(!options.contains("temurin-25"), "runtime-only JDK must not become a compiler runtime");
+ assert_eq!(
+ cfg.initialization_options.as_ref().unwrap()["settings"]["java"]["configuration"]["runtimes"][0]["default"]
+ .as_bool(),
+ Some(true)
+ );
+ }
+
+ #[test]
+ fn implicit_compiler_default_matches_project_pick_with_duplicate_versions() {
+ let installed =
+ [Jdk { major: 21, home: PathBuf::from("/jdk21a") }, Jdk { major: 21, home: PathBuf::from("/jdk21b") }];
+ let server = Jdk { major: 25, home: PathBuf::from("/custom-server-runtime") };
+ let mut cfg: LanguageServerConfig = toml::from_str("name = 'jdtls'\ncommand = 'jdtls'").unwrap();
+ configure_jdtls(&mut cfg, Path::new("/p"), Path::new("/data"), &installed, None, Some(&server), 25, &[], None);
+ let opts = serde_json::to_value(cfg.initialization_options.unwrap()).unwrap();
+ assert_eq!(
+ opts["settings"]["java"]["configuration"]["runtimes"],
+ json!([{
+ "name": "JavaSE-21", "path": pick_jdk(&installed, None).unwrap().home, "default": true
+ }])
+ );
+ assert_eq!(cfg.env["JAVA_HOME"], "/custom-server-runtime");
+ }
+
#[test]
fn release_versions() {
assert_eq!(parse_release("IMPLEMENTOR=\"x\"\nJAVA_VERSION=\"21.0.3\"\n"), Some(21));
@@ -544,7 +621,7 @@ mod tests {
let rt = &opts["settings"]["java"]["configuration"]["runtimes"];
assert_eq!(rt[0], json!({ "name": "JavaSE-1.8", "path": "/jdk8" }));
assert_eq!(rt[1], json!({ "name": "JavaSE-21", "path": "/jdk21a" }));
- assert_eq!(rt[2], json!({ "name": "JavaSE-25", "path": "/jdk25" }));
+ assert_eq!(rt[2], json!({ "name": "JavaSE-25", "path": "/jdk25", "default": true }));
assert_eq!(opts["bundles"], json!(["/tools/java-debug/bin/com.microsoft.java.debug.plugin.jar"]));
assert_eq!(cfg.env["JAVA_HOME"], "/jdk25", "first JDK new enough to run jdtls");
assert_eq!(cfg.launch_error, None);
diff --git a/crates/ide-tools/src/jdk.rs b/crates/ide-tools/src/jdk.rs
index b5bcf6db8..0b85718e5 100644
--- a/crates/ide-tools/src/jdk.rs
+++ b/crates/ide-tools/src/jdk.rs
@@ -108,8 +108,28 @@ fn adoptium_arch(arch: Arch) -> &'static str {
/// The latest Temurin JDK build of Java `feature` for `platform`.
pub fn adoptium_assets_url(feature: u32, platform: Platform) -> String {
+ assets_url(feature, platform, ImageType::Jdk)
+}
+
+#[derive(Clone, Copy)]
+enum ImageType {
+ Jdk,
+ Jre,
+}
+
+impl ImageType {
+ fn name(self) -> &'static str {
+ match self {
+ Self::Jdk => "jdk",
+ Self::Jre => "jre",
+ }
+ }
+}
+
+fn assets_url(feature: u32, platform: Platform, image: ImageType) -> String {
+ let image = image.name();
format!(
- "{ADOPTIUM_API}/assets/latest/{feature}/hotspot?architecture={}&image_type=jdk&os={}&vendor=eclipse",
+ "{ADOPTIUM_API}/assets/latest/{feature}/hotspot?architecture={}&image_type={image}&os={}&vendor=eclipse",
adoptium_arch(platform.arch),
adoptium_os(platform.os),
)
@@ -170,12 +190,16 @@ impl AssetVersion {
/// The JDK archive (`.tar.gz` on macOS / Linux, `.zip` on Windows) in an Adoptium
/// `assets/latest` response; `None` when there is no build for the platform.
pub fn adoptium_pick(json: &str, platform: Platform) -> IdeResult<Option<(Download, u32)>> {
+ pick_image(json, platform, ImageType::Jdk)
+}
+
+fn pick_image(json: &str, platform: Platform, image: ImageType) -> IdeResult<Option<(Download, u32)>> {
let assets: Vec<Asset> =
serde_json::from_str(json).map_err(|e| proto(format!("unexpected Adoptium response: {e}")))?;
let ext = if platform.os == Os::Windows { ".zip" } else { ".tar.gz" };
let os = adoptium_os(platform.os);
let found = assets.into_iter().find(|a| {
- a.binary.image_type.as_deref().is_none_or(|t| t == "jdk")
+ a.binary.image_type.as_deref().is_none_or(|t| t == image.name())
&& a.binary.heap_size.as_deref().is_none_or(|h| h == "normal")
&& a.binary.os.as_deref().is_none_or(|o| o == os)
&& a.binary.package.name.ends_with(ext)
@@ -255,14 +279,50 @@ impl Tools {
location: Option<&Path>,
cancel: &CancellationToken,
emit: Emit,
+ ) -> IdeResult<DownloadedJdk> {
+ self.download_java(vendor, feature, location, false, cancel, emit)
+ }
+
+ /// Downloads a runtime for a language server, preferring a JRE. Only a
+ /// platform without a JRE build falls back to a full JDK.
+ pub fn download_java_runtime(
+ &self,
+ feature: u32,
+ location: &Path,
+ cancel: &CancellationToken,
+ emit: Emit,
+ ) -> IdeResult<DownloadedJdk> {
+ self.download_java(TEMURIN, feature, Some(location), true, cancel, emit)
+ }
+
+ #[allow(clippy::too_many_arguments)]
+ fn download_java(
+ &self,
+ vendor: &str,
+ feature: u32,
+ location: Option<&Path>,
+ runtime: bool,
+ cancel: &CancellationToken,
+ emit: Emit,
) -> IdeResult<DownloadedJdk> {
vendor_or_err(vendor)?;
let _guard = InstallGuard::acquire(&format!("jdk-{vendor}-{feature}"))?;
let http = self.http()?;
let location = location.map(Path::to_path_buf).unwrap_or_else(|| self.root.join("jdks"));
emit(InstallEvent::Line { text: format!("Resolving the latest Eclipse Temurin {feature}…") });
- let mut picked =
- adoptium_pick(&http.get_text(&adoptium_assets_url(feature, self.platform), cancel)?, self.platform)?;
+ let mut picked = if runtime {
+ pick_image(
+ &http.get_text_or_empty_on_404(&assets_url(feature, self.platform, ImageType::Jre), cancel)?,
+ self.platform,
+ ImageType::Jre,
+ )?
+ } else {
+ None
+ };
+ if picked.is_none() {
+ picked =
+ adoptium_pick(&http.get_text(&adoptium_assets_url(feature, self.platform), cancel)?, self.platform)?;
+ }
if picked.is_none() && self.platform.os == Os::Mac && self.platform.arch == Arch::Arm64 {
// Java 8 has no Apple Silicon build: the Intel one runs under Rosetta.
let intel = Platform { os: Os::Mac, arch: Arch::X64 };
@@ -376,6 +436,22 @@ mod tests {
assert!(adoptium_pick("{\"errorMessage\":\"x\"}", MAC_ARM).is_err());
}
+ #[test]
+ fn runtime_assets_use_jre_without_changing_jdk_downloads() {
+ for platform in [MAC_ARM, LINUX_X64, WIN_X64] {
+ assert!(assets_url(25, platform, ImageType::Jre).contains("image_type=jre"));
+ assert!(adoptium_assets_url(25, platform).contains("image_type=jdk"));
+ let ext = if platform.os == Os::Windows { "zip" } else { "tar.gz" };
+ let jdk = asset(&format!("java.{ext}"), adoptium_os(platform.os), "normal", "");
+ let jre = jdk.replace("\"image_type\":\"jdk\"", "\"image_type\":\"jre\"");
+ assert!(pick_image(&format!("[{jre}]"), platform, ImageType::Jre).unwrap().is_some());
+ assert!(adoptium_pick(&format!("[{jre}]"), platform).unwrap().is_none());
+ assert!(pick_image(&format!("[{jdk}]"), platform, ImageType::Jre).unwrap().is_none());
+ assert!(pick_image("[]", platform, ImageType::Jre).unwrap().is_none());
+ assert!(pick_image("offline", platform, ImageType::Jre).is_err());
+ }
+ }
+
#[test]
fn java_8_versions_and_dir_names() {
let v = AssetVersion { major: 8, minor: 0, security: 472, openjdk_version: Some("1.8.0_472-b08".into()) };
diff --git a/crates/ide-tools/src/process.rs b/crates/ide-tools/src/process.rs
index 81c44bf92..cd3e15788 100644
--- a/crates/ide-tools/src/process.rs
+++ b/crates/ide-tools/src/process.rs
@@ -221,7 +221,25 @@ impl Http {
/// GETs `url` as text, failing when the response is larger than `max_bytes`.
pub fn get_text_limited(&self, url: &str, max_bytes: Option<u64>, cancel: &CancellationToken) -> IdeResult<String> {
+ self.get_text_response(url, max_bytes, false, cancel)
+ }
+
+ /// Adoptium uses 404 as well as an empty array for absent platform builds.
+ pub fn get_text_or_empty_on_404(&self, url: &str, cancel: &CancellationToken) -> IdeResult<String> {
+ self.get_text_response(url, None, true, cancel)
+ }
+
+ fn get_text_response(
+ &self,
+ url: &str,
+ max_bytes: Option<u64>,
+ empty_on_404: bool,
+ cancel: &CancellationToken,
+ ) -> IdeResult<String> {
let mut cmd = self.base(url);
+ if empty_on_404 {
+ cmd.args(["--write-out", "\n%{http_code}"]);
+ }
if let Some(max) = max_bytes {
cmd.arg("--max-filesize").arg(max.to_string());
}
@@ -246,7 +264,14 @@ impl Http {
None => std::thread::sleep(Duration::from_millis(30)),
}
};
- let body = out_t.join().unwrap_or_default();
+ let mut body = out_t.join().unwrap_or_default();
+ if empty_on_404 && let Some(split) = body.iter().rposition(|b| *b == b'\n') {
+ let code = &body[split + 1..];
+ if code == b"404" {
+ return Ok("[]".into());
+ }
+ body.truncate(split);
+ }
if let Some(max) = max_bytes
&& body.len() as u64 > max
{
@@ -362,6 +387,25 @@ mod tests {
assert!(lines.contains(&"one".to_string()) && lines.contains(&"two".to_string()), "{lines:?}");
}
+ #[cfg(unix)]
+ #[test]
+ fn absent_build_is_empty_but_http_failures_are_not() {
+ use std::os::unix::fs::PermissionsExt;
+ let tmp = tempfile::tempdir().unwrap();
+ let curl = tmp.path().join("curl");
+ let http = Http { curl: curl.clone(), https_only: false };
+ for (code, exit, expected) in [(404, 22, Some("[]")), (200, 0, Some("payload")), (403, 22, None), (0, 7, None)]
+ {
+ std::fs::write(&curl, format!("#!/bin/sh\nprintf 'payload\\n{code:03}'\nexit {exit}\n")).unwrap();
+ std::fs::set_permissions(&curl, std::fs::Permissions::from_mode(0o755)).unwrap();
+ let result = http.get_text_or_empty_on_404("https://example.test/build", &CancellationToken::new());
+ match expected {
+ Some(body) => assert_eq!(result.unwrap(), body),
+ None => assert!(result.is_err()),
+ }
+ }
+ }
+
#[cfg(unix)]
#[test]
fn cancellation_kills_the_child() {
diff --git a/src/features/settings/languages/LanguagePages.tsx b/src/features/settings/languages/LanguagePages.tsx
index a106da639..e507588a1 100644
--- a/src/features/settings/languages/LanguagePages.tsx
+++ b/src/features/settings/languages/LanguagePages.tsx
@@ -240,11 +240,11 @@ export function JavaPage() {
label="JDK"
kind="jdk"
emptyLabel="Auto"
- emptyDetail="the project JDK if new enough, else the first installed JDK that is"
+ emptyDetail="auto-managed; uses an installed JDK or downloads a runtime when needed"
directory
browseTitle="Select JDK Home Directory"
aria-label="Language server JDK"
- hint="Runs jdtls only, like IDEA's JDK for importer; the project keeps compiling and running with the Project JDK. jdtls needs JDK 21 or newer (recent releases 25); Download JDK… in the list fetches one. The jdtls executable itself is set in Language Servers."
+ hint="Runs jdtls only; the project keeps its Project JDK. When empty, a suitable installed JDK is used first, otherwise Eclipse Temurin is downloaded automatically into a separate language-server folder. The jdtls executable itself is set in Language Servers."
/>
<Row
label="JVM options"
diff --git a/src/platform/locales/text/zh.json b/src/platform/locales/text/zh.json
index b9cd13517..a2fef34ea 100644
--- a/src/platform/locales/text/zh.json
+++ b/src/platform/locales/text/zh.json
@@ -1,4 +1,7 @@
{
+ "Downloading Java {0} language server runtime": "正在下载 Java {0} 语言服务器运行时",
+ "auto-managed; uses an installed JDK or downloads a runtime when needed": "自动管理;使用已安装的 JDK,或在需要时自动下载运行时",
+ "Runs jdtls only; the project keeps its Project JDK. When empty, a suitable installed JDK is used first, otherwise Eclipse Temurin is downloaded automatically into a separate language-server folder. The jdtls executable itself is set in Language Servers.": "仅用于运行 jdtls,项目仍使用项目 JDK。留空时优先使用符合要求的已安装 JDK,否则自动将 Eclipse Temurin 下载到独立的语言服务器目录。jdtls 可执行文件在语言服务器设置中配置。",
"Semantic Highlighting": "语义高亮",
"Rainbow Brackets": "彩虹括号",
"Comment with Line Comment": "使用行注释",
@@ -1406,7 +1409,6 @@
"Rerun Search": "重新运行搜索",
"Right Bottom": "右下",
"Right Top": "右上",
- "Runs jdtls only, like IDEA's JDK for importer; the project keeps compiling and running with the Project JDK. jdtls needs JDK 21 or newer (recent releases 25); Download JDK… in the list fetches one. The jdtls executable itself is set in Language Servers.": "仅用于运行 jdtls(类似 IDEA 的「导入器 JDK」);项目仍使用项目 JDK 编译和运行。jdtls 需要 JDK 21 或更高版本(较新版本需要 25);可通过列表中的「下载 JDK…」获取。jdtls 可执行文件本身在「语言服务器」中设置。",
"Language server JDK": "语言服务器 JDK",
"Password": "密码",
"Password:": "密码:",
@@ -2384,7 +2386,6 @@
"not installed in this project": "此项目中未安装",
"or click a line number to set a breakpoint.": "或点击行号设置断点。",
"per module, the JDK of its Java version": "按模块使用与其 Java 版本匹配的 JDK",
- "the project JDK if new enough, else the first installed JDK that is": "项目 JDK 版本足够时使用它,否则使用第一个版本足够的已安装 JDK",
"pip output": "pip 输出",
"places the caret. A line with": "放置光标。包含",
"println! with Debug": "使用 Debug 的 println!",