Skip to content

armgit / dbx

Public Imported from GitHub
0

25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。

fix(dameng): tolerate java 8 runtime and require java 21

zipg288ba78c7ac9
diff --git a/crates/dbx-driver-agent/src/agent_driver.rs b/crates/dbx-driver-agent/src/agent_driver.rs
index 57fee4cf7f..7eba6c03b4 100644
--- a/crates/dbx-driver-agent/src/agent_driver.rs
+++ b/crates/dbx-driver-agent/src/agent_driver.rs
@@ -12,6 +12,7 @@ use serde::{Deserialize, Serialize};
use serde_json::Value;
use tokio_util::sync::CancellationToken;
+use crate::agent_manager::AGENT_JAVA_TOO_OLD_MESSAGE;
use crate::agent_recovery::{RecoveryDecision, RecoveryPolicy, RecoveryScope};
use crate::models::connection::DatabaseConnectionInfo;
@@ -874,8 +875,6 @@ const AGENT_EXIT_DIAGNOSTIC_WAIT_MS: u64 = 1_000;
const AGENT_EXIT_DIAGNOSTIC_POLL_MS: u64 = 10;
const SHARED_RUNTIME_IDLE_GRACE_SECS: u64 = 30;
const AGENT_JAVA_OPTS_ENV: &str = "DBX_AGENT_JAVA_OPTS";
-const AGENT_JAVA_TOO_OLD_MESSAGE: &str =
- "Agent requires Java 21, but DBX started it with an older Java runtime. Use DBX managed JRE 21 or select a Java 21 executable in Driver Manager.";
pub struct AgentDriverClient {
child: Option<Child>,
@@ -3182,7 +3181,14 @@ fn agent_java_args_with_extra_opts(
extra_opts: Option<&str>,
extra_java_args: &[String],
) -> Vec<String> {
+ // Java 8 and older reject the module flags below while starting up
+ // ("Unrecognized option: --add-opens=..."), so the agent dies before it can
+ // load a class and the real diagnosis (agent bytecode needs Java 21) is
+ // replaced by a cryptic JVM error. Ignoring unrecognized VM options keeps
+ // the start attempt going everywhere: pre-9 runtimes ignore the module
+ // flags, Java 9+ still receives them.
let mut args = vec![
+ "-XX:+IgnoreUnrecognizedVMOptions",
"-Dfile.encoding=UTF-8",
"-Dsun.stdout.encoding=UTF-8",
"-Dsun.stderr.encoding=UTF-8",
@@ -3512,8 +3518,13 @@ fn is_agent_rpc_response_error(message: &str) -> bool {
fn agent_process_error_hint(stderr: &str) -> Option<&'static str> {
let lower = stderr.to_ascii_lowercase();
+ // Any class-version mismatch means the selected runtime is older than the
+ // agent bytecode (Java 21 / class file 65). Match the JVM wording variants
+ // independently because the stderr tail keeps only the last lines, and a
+ // long stack trace can push the exception header out of the sample.
if lower.contains("unsupportedclassversionerror")
- && (lower.contains("class file version 65.0") || lower.contains("only recognizes class file versions up to"))
+ || lower.contains("only recognizes class file versions up to")
+ || lower.contains("class file version 65.0")
{
return Some(AGENT_JAVA_TOO_OLD_MESSAGE);
}
@@ -3568,17 +3579,17 @@ mod tests {
use super::{
agent_close_query_session_params, agent_error_from_legacy, agent_handshake_params, agent_java_args,
agent_java_args_with_extra, agent_java_args_with_extra_opts, agent_object_source_params,
- agent_object_source_params_with_relation, agent_proxy_env_vars, agent_schema_params, agent_schema_table_params,
- agent_supports_capability, agent_transaction_params, append_legacy_error_context, decode_agent_response,
- format_agent_process_error, format_agent_startup_error, is_agent_rpc_response_error,
+ agent_object_source_params_with_relation, agent_process_error_hint, agent_proxy_env_vars, agent_schema_params,
+ agent_schema_table_params, agent_supports_capability, agent_transaction_params, append_legacy_error_context,
+ decode_agent_response, format_agent_process_error, format_agent_startup_error, is_agent_rpc_response_error,
is_unsupported_handshake_error, legacy_agent_call_error, mongo_collection_params, mongo_database_params,
mongo_document_id_params, parse_agent_java_opts, read_agent_json_response, read_agent_line,
read_agent_line_with_limit, start_stderr_collector, validate_dameng_java_system_properties, AgentCallError,
AgentCapability, AgentDriverClient, AgentErrorCategory, AgentErrorContext, AgentErrorStage, AgentHandshake,
AgentKvMethod, AgentLaunchSpec, AgentMethod, AgentOperationOutcome, AgentRuntimeClient,
AgentSessionDisposition, AgentTableReadCloseParams, AgentTableReadPageParams, AgentTableReadStartParams,
- MongoAgentMethod, StderrTail, AGENT_PROTOCOL_VERSION, AGENT_STDOUT_NOISE_SAMPLE_CHARS,
- MAX_CONSECUTIVE_AGENT_STDOUT_NOISE_LINES,
+ MongoAgentMethod, StderrTail, AGENT_JAVA_TOO_OLD_MESSAGE, AGENT_PROTOCOL_VERSION,
+ AGENT_STDOUT_NOISE_SAMPLE_CHARS, MAX_CONSECUTIVE_AGENT_STDOUT_NOISE_LINES,
};
use crate::agent_recovery::{RecoveryDecision, RecoveryPolicy, RecoveryScope};
use std::io::Cursor;
@@ -4022,6 +4033,60 @@ mod tests {
assert!(!args.iter().any(|arg| arg == "--add-opens=java.base/java.net=ALL-UNNAMED"));
}
+ #[test]
+ fn agent_java_args_tolerate_runtimes_without_module_support() {
+ // Regression: a Java 8 runtime rejects "--add-opens=..." while starting
+ // up, so connecting with a driver that adds module flags failed with
+ // "Unrecognized option: --add-opens=..." instead of the actionable
+ // "this driver needs Java 21" message.
+ for jar in [
+ "/tmp/dbx/drivers/dameng/agent.jar",
+ "/tmp/dbx/drivers/ignite/agent.jar",
+ "/tmp/dbx/drivers/highgo/agent.jar",
+ ] {
+ let args = agent_java_args(jar);
+ let ignore_unrecognized = args
+ .iter()
+ .position(|arg| arg == "-XX:+IgnoreUnrecognizedVMOptions")
+ .unwrap_or_else(|| panic!("{jar} should tolerate runtimes without module support"));
+ let first_module_flag = args
+ .iter()
+ .position(|arg| arg.starts_with("--add-opens="))
+ .unwrap_or_else(|| panic!("{jar} should still open the JDK modules it needs"));
+
+ assert!(
+ ignore_unrecognized < first_module_flag,
+ "module flags must be preceded by the ignore flag: {args:?}"
+ );
+ }
+ }
+
+ #[test]
+ fn agent_process_error_hint_matches_java_8_startup_failure() {
+ // Captured from a real Java 8 runtime that was handed the module flags.
+ let module_rejection = "Unrecognized option: --add-opens=java.base/java.net=ALL-UNNAMED\n\
+ Error: Could not create the Java Virtual Machine.\n\
+ Error: A fatal exception has occurred. Program will exit.";
+ assert_eq!(agent_process_error_hint(module_rejection), None);
+
+ let full_class_version = "Error: A JNI error has occurred, please check your installation and try again\n\
+ Exception in thread \"main\" java.lang.UnsupportedClassVersionError: com/dbx/agent/dameng/DamengAgent has been compiled by a more recent version of the Java Runtime (class file version 65.0), this version of the Java Runtime only recognizes class file versions up to 52.0\n\
+ \tat sun.launcher.LauncherHelper.checkAndLoadMain(LauncherHelper.java:634)";
+ assert_eq!(agent_process_error_hint(full_class_version), Some(AGENT_JAVA_TOO_OLD_MESSAGE));
+
+ // Only the last stderr lines survive in the tail, so anything from the
+ // class-version failure is enough on its own.
+ assert_eq!(
+ agent_process_error_hint("java.lang.UnsupportedClassVersionError"),
+ Some(AGENT_JAVA_TOO_OLD_MESSAGE)
+ );
+ assert_eq!(
+ agent_process_error_hint("this version of the Java Runtime only recognizes class file versions up to 52.0"),
+ Some(AGENT_JAVA_TOO_OLD_MESSAGE)
+ );
+ assert_eq!(agent_process_error_hint("java.net.ConnectException: Connection refused"), None);
+ }
+
#[test]
fn agent_java_args_open_jdk_internals_for_ignite() {
let args = agent_java_args("/tmp/dbx/drivers/ignite/agent.jar");
diff --git a/crates/dbx-driver-agent/src/agent_manager.rs b/crates/dbx-driver-agent/src/agent_manager.rs
index b69c67b472..975269fc6c 100644
--- a/crates/dbx-driver-agent/src/agent_manager.rs
+++ b/crates/dbx-driver-agent/src/agent_manager.rs
@@ -3,7 +3,9 @@ use std::fs::File;
use std::io::Read;
use std::ops::Deref;
use std::path::{Path, PathBuf};
+use std::process::Stdio;
use std::sync::{Arc, Mutex as StdMutex};
+use std::time::{Duration, Instant};
use serde::{Deserialize, Serialize};
use tokio::sync::Mutex;
@@ -14,9 +16,20 @@ use crate::db::agent_driver::{
use crate::models::connection::DatabaseType;
pub const DEFAULT_JRE_KEY: &str = "21";
+/// Every Java artifact DBX runs itself (driver agents and the JDBC plugin) is
+/// compiled for Java 21, so an older runtime cannot load any of them.
+pub const MINIMUM_JAVA_MAJOR_VERSION: u32 = 21;
+/// Shown when the selected Java runtime is older than the agent bytecode.
+/// Kept verbatim in sync with the desktop error catalog
+/// (apps/desktop/src/i18n/backend-errors.ts -> connection.agentJavaTooOld).
+pub const AGENT_JAVA_TOO_OLD_MESSAGE: &str =
+ "Agent requires Java 21, but DBX started it with an older Java runtime. Use DBX managed JRE 21 or select a Java 21 executable in Driver Manager.";
pub const SQLITE_WORKER_DRIVER_KEY: &str = "sqlite-worker";
pub const SQLITE_WORKER_NATIVE_PLATFORMS: &[&str] = &["linux-x64", "linux-aarch64"];
pub const DOWNLOAD_CACHE_DIR_NAME: &str = "download-cache";
+/// `java -version` is only needed for runtimes without a `release` file; the
+/// probe must never block a connect or a settings save on a broken executable.
+pub const JAVA_VERSION_PROBE_TIMEOUT_SECS: u64 = 5;
pub const DOWNLOAD_CACHE_MAX_AGE_DAYS: u64 = 7;
pub type OperationLockTable = StdMutex<std::collections::HashMap<String, Arc<Mutex<()>>>>;
@@ -254,6 +267,126 @@ mod tests {
assert_eq!(manager.resolve_java_runtime(&state, DEFAULT_JRE_KEY).unwrap(), java);
}
+ fn temp_dir(name: &str) -> PathBuf {
+ let dir = std::env::temp_dir().join(format!("dbx-agent-manager-{name}-{}", uuid::Uuid::new_v4()));
+ fs::create_dir_all(&dir).unwrap();
+ dir
+ }
+
+ #[test]
+ fn parses_java_major_versions() {
+ assert_eq!(parse_java_major_version("1.8.0_504"), Some(8));
+ assert_eq!(parse_java_major_version("1.7.0_80"), Some(7));
+ assert_eq!(parse_java_major_version("21.0.10"), Some(21));
+ assert_eq!(parse_java_major_version("17.0.18+9"), Some(17));
+ assert_eq!(parse_java_major_version("\"11.0.2\""), Some(11));
+ assert_eq!(parse_java_major_version("9"), Some(9));
+ assert_eq!(parse_java_major_version("not-a-version"), None);
+ assert_eq!(parse_java_major_version(""), None);
+ }
+
+ #[test]
+ fn parses_java_version_output() {
+ assert_eq!(
+ parse_java_version_output(
+ "openjdk version \"1.8.0_504\"\nOpenJDK Runtime Environment (build 1.8.0_504-b01)"
+ )
+ .as_deref(),
+ Some("1.8.0_504")
+ );
+ assert_eq!(parse_java_version_output("java version \"21.0.10\" 2026-01-20 LTS").as_deref(), Some("21.0.10"));
+ assert_eq!(parse_java_version_output("command not found"), None);
+ }
+
+ #[test]
+ fn reads_java_version_from_release_file_in_both_layouts() {
+ let home = temp_dir("release-flat");
+ let flat_java = home.join("bin").join(java_executable_name());
+ touch(&flat_java);
+ fs::write(home.join("release"), "IMPLEMENTOR=\"Eclipse Adoptium\"\nJAVA_VERSION=\"1.8.0_504\"\n").unwrap();
+
+ assert_eq!(AgentManager::java_major_version(&flat_java), Some(8));
+
+ let bundle = temp_dir("release-bundle");
+ let bundle_java = bundle.join("Contents").join("Home").join("bin").join(java_executable_name());
+ touch(&bundle_java);
+ fs::write(bundle.join("Contents").join("Home").join("release"), "JAVA_VERSION=\"21.0.10\"\n").unwrap();
+
+ assert_eq!(AgentManager::java_major_version(&bundle_java), Some(21));
+ }
+
+ #[cfg(unix)]
+ #[test]
+ fn probes_java_version_when_release_file_is_missing() {
+ use std::os::unix::fs::PermissionsExt;
+
+ let home = temp_dir("probe-version");
+ let java = home.join("bin").join("java");
+ fs::create_dir_all(java.parent().unwrap()).unwrap();
+ fs::write(&java, "#!/bin/sh\necho 'openjdk version \"1.8.0_504\"' >&2\n").unwrap();
+ fs::set_permissions(&java, fs::Permissions::from_mode(0o755)).unwrap();
+
+ assert_eq!(AgentManager::java_major_version(&java), Some(8));
+ }
+
+ #[test]
+ fn rejects_java_runtime_older_than_the_agent_bytecode() {
+ let manager = test_manager("old-custom-java");
+ let java = manager.base_dir().join("jre8").join("bin").join(java_executable_name());
+ touch(&java);
+ // The reported case: a Java 8 runtime (a system Java or an imported JRE)
+ // rejects the agent's --add-opens flags before any class is loaded.
+ fs::write(java.parent().unwrap().parent().unwrap().join("release"), "JAVA_VERSION=\"1.8.0_504\"\n").unwrap();
+ let state = AgentState {
+ java_runtime: JavaRuntimeConfig {
+ mode: JavaRuntimeMode::Custom,
+ custom_java_path: Some(java.to_string_lossy().to_string()),
+ },
+ ..AgentState::default()
+ };
+
+ let err = manager.resolve_java_runtime(&state, DEFAULT_JRE_KEY).unwrap_err();
+
+ assert!(err.starts_with(AGENT_JAVA_TOO_OLD_MESSAGE), "unexpected error: {err}");
+ assert!(err.contains("Detected Java 8"));
+ }
+
+ #[test]
+ fn accepts_java_runtime_matching_the_agent_bytecode() {
+ let manager = test_manager("new-custom-java");
+ let java = manager.base_dir().join("jre21").join("bin").join(java_executable_name());
+ touch(&java);
+ fs::write(java.parent().unwrap().parent().unwrap().join("release"), "JAVA_VERSION=\"21.0.10\"\n").unwrap();
+ let state = AgentState {
+ java_runtime: JavaRuntimeConfig {
+ mode: JavaRuntimeMode::Custom,
+ custom_java_path: Some(java.to_string_lossy().to_string()),
+ },
+ ..AgentState::default()
+ };
+
+ assert_eq!(manager.resolve_java_runtime(&state, DEFAULT_JRE_KEY).unwrap(), java);
+ }
+
+ #[test]
+ fn keeps_runtimes_with_unknown_version_usable() {
+ // Wrapper scripts and stripped runtimes cannot be probed; they must still
+ // resolve so that the spawn-time diagnostics stay in charge.
+ let manager = test_manager("unknown-custom-java");
+ let java = manager.base_dir().join("wrapper").join("bin").join(java_executable_name());
+ touch(&java);
+ let state = AgentState {
+ java_runtime: JavaRuntimeConfig {
+ mode: JavaRuntimeMode::Custom,
+ custom_java_path: Some(java.to_string_lossy().to_string()),
+ },
+ ..AgentState::default()
+ };
+
+ assert_eq!(AgentManager::java_major_version(&java), None);
+ assert_eq!(manager.resolve_java_runtime(&state, DEFAULT_JRE_KEY).unwrap(), java);
+ }
+
#[test]
fn resolves_custom_java_runtime_when_configured() {
let manager = test_manager("custom");
@@ -1135,21 +1268,39 @@ impl AgentManager {
}
}
+ /// Major version of the Java runtime at `java_path`, or `None` when it
+ /// cannot be determined (wrapper scripts, stripped runtimes, unknown
+ /// layouts). An undetectable runtime is never rejected: the spawn-time
+ /// diagnostics in `agent_driver` still explain a failed start.
+ pub fn java_major_version(java_path: &Path) -> Option<u32> {
+ let key = java_path.canonicalize().unwrap_or_else(|_| java_path.to_path_buf());
+ if let Ok(cache) = java_version_cache().lock() {
+ if let Some(cached) = cache.get(&key) {
+ return *cached;
+ }
+ }
+ let detected = detect_java_major_version(&key);
+ if let Ok(mut cache) = java_version_cache().lock() {
+ cache.insert(key, detected);
+ }
+ detected
+ }
+
pub fn resolve_java_runtime(&self, state: &AgentState, jre_key: &str) -> Result<PathBuf, String> {
- match state.java_runtime.mode {
+ let java = match state.java_runtime.mode {
JavaRuntimeMode::Managed => {
if !self.is_jre_installed(jre_key) {
return Err(format!(
"JRE {jre_key} runtime is not installed. Please install it from the Driver Manager."
));
}
- Ok(self.jre_java_path(jre_key))
+ self.jre_java_path(jre_key)
}
JavaRuntimeMode::System => {
let java_home = std::env::var_os(JAVA_HOME_ENV);
let path_var = std::env::var_os(PATH_ENV);
resolve_system_java_path(java_home.as_deref(), path_var.as_deref())
- .ok_or_else(|| system_java_missing_error(java_home.as_deref(), path_var.as_deref()))
+ .ok_or_else(|| system_java_missing_error(java_home.as_deref(), path_var.as_deref()))?
}
JavaRuntimeMode::Custom => {
let path = state
@@ -1159,9 +1310,11 @@ impl AgentManager {
.map(str::trim)
.filter(|path| !path.is_empty())
.ok_or_else(|| "Custom Java runtime path is empty. Please choose a Java executable.".to_string())?;
- resolve_custom_java_path(path)
+ resolve_custom_java_path(path)?
}
- }
+ };
+ ensure_supported_java_runtime(&java)?;
+ Ok(java)
}
pub async fn stop_daemons(&self) {
@@ -1370,6 +1523,113 @@ fn resolve_custom_java_path(path: &str) -> Result<PathBuf, String> {
.ok_or_else(|| format!("Custom Java runtime does not exist or is not a Java executable: {}", raw.display()))
}
+/// Rejects a runtime that cannot load DBX's Java artifacts before any agent
+/// process is spawned, so the user gets actionable guidance instead of a raw
+/// JVM startup failure (a Java 8 runtime dies on the `--add-opens` flags with
+/// "Unrecognized option: --add-opens=...").
+fn ensure_supported_java_runtime(java_path: &Path) -> Result<(), String> {
+ let Some(major) = AgentManager::java_major_version(java_path) else {
+ return Ok(());
+ };
+ if major >= MINIMUM_JAVA_MAJOR_VERSION {
+ return Ok(());
+ }
+ Err(format!("{AGENT_JAVA_TOO_OLD_MESSAGE} Detected Java {major} at {}.", java_path.display()))
+}
+
+fn java_version_cache() -> &'static StdMutex<std::collections::HashMap<PathBuf, Option<u32>>> {
+ static CACHE: std::sync::OnceLock<StdMutex<std::collections::HashMap<PathBuf, Option<u32>>>> =
+ std::sync::OnceLock::new();
+ CACHE.get_or_init(Default::default)
+}
+
+fn detect_java_major_version(java_path: &Path) -> Option<u32> {
+ if let Some(major) = read_java_release_version(java_path).and_then(|version| parse_java_major_version(&version)) {
+ return Some(major);
+ }
+ let output = probe_java_version_output(java_path)?;
+ let version = parse_java_version_output(&output)?;
+ parse_java_major_version(&version)
+}
+
+/// Reads `JAVA_VERSION` from the `release` file of the Java home that contains
+/// `java_path`, which avoids starting a JVM just to learn the version. Walks a
+/// few levels up to cover both the `<home>/bin/java` and the macOS bundle
+/// `<home>/Contents/Home/bin/java` layouts.
+fn read_java_release_version(java_path: &Path) -> Option<String> {
+ let bin_dir = java_path.parent()?;
+ for ancestor in bin_dir.ancestors().take(4) {
+ let Ok(contents) = std::fs::read_to_string(ancestor.join("release")) else {
+ continue;
+ };
+ if let Some(version) = parse_release_java_version(&contents) {
+ return Some(version);
+ }
+ }
+ None
+}
+
+fn parse_release_java_version(contents: &str) -> Option<String> {
+ contents
+ .lines()
+ .find_map(|line| line.strip_prefix("JAVA_VERSION="))
+ .map(|value| value.trim().trim_matches('"').to_string())
+ .filter(|value| !value.is_empty())
+}
+
+/// Extracts the version from `java -version` output, e.g.
+/// `openjdk version "1.8.0_504"` or `java version "21.0.10" 2024-01-16 LTS`.
+fn parse_java_version_output(output: &str) -> Option<String> {
+ output.lines().find_map(|line| {
+ let (_, rest) = line.split_once("version ")?;
+ let quoted = rest.trim_start().strip_prefix('"')?;
+ quoted.split('"').next().filter(|value| !value.is_empty()).map(str::to_string)
+ })
+}
+
+/// `1.8.0_504` -> 8, `21.0.10` -> 21, `9` -> 9.
+fn parse_java_major_version(version: &str) -> Option<u32> {
+ let cleaned = version.trim().trim_matches('"');
+ let mut parts = cleaned.split(['.', '_', '-', '+']);
+ let first = parts.next()?.parse::<u32>().ok()?;
+ if first == 1 {
+ parts.next()?.parse::<u32>().ok()
+ } else {
+ Some(first)
+ }
+}
+
+/// Runs `java -version` (which writes to stderr) for runtimes that ship no
+/// `release` file. Bounded by a timeout so a broken executable can never hang a
+/// connect or a settings save.
+fn probe_java_version_output(java_path: &Path) -> Option<String> {
+ let mut child = crate::process::new_std_command(java_path)
+ .arg("-version")
+ .stdin(Stdio::null())
+ .stdout(Stdio::piped())
+ .stderr(Stdio::piped())
+ .spawn()
+ .ok()?;
+ let deadline = Instant::now() + Duration::from_secs(JAVA_VERSION_PROBE_TIMEOUT_SECS);
+ loop {
+ match child.try_wait() {
+ Ok(Some(_)) => break,
+ Ok(None) if Instant::now() < deadline => std::thread::sleep(Duration::from_millis(10)),
+ _ => {
+ let _ = child.kill();
+ let _ = child.wait();
+ return None;
+ }
+ }
+ }
+ let output = child.wait_with_output().ok()?;
+ let mut text = String::from_utf8_lossy(&output.stderr).into_owned();
+ if text.trim().is_empty() {
+ text = String::from_utf8_lossy(&output.stdout).into_owned();
+ }
+ Some(text)
+}
+
const JAVA_HOME_ENV: &str = "JAVA_HOME";
const PATH_ENV: &str = "PATH";