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。
TypeScript aicliclickhousedatabasedatabase-clientdatabase-managementdockerguimcpmongodbmysqlpostgresqlredisrustsql-serversqlitetaurivue
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.rsindex 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.rsindex 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";