From b57b3873d93a934e168920db8848a73cc98f8668 Mon Sep 17 00:00:00 2001 From: t8y2 <1156263951@qq.com> Date: Fri, 2 Oct 2026 06:41:13 +0000 Subject: [PATCH] fix(jdbc): share embedded H2 runtimes with isolated logical sessions Closes #10923 --- .../dbx-core/src/connection/h2_jdbc_tests.rs | 428 +++++++++++++++++ crates/dbx-core/src/connection/mod.rs | 52 ++- crates/dbx-plugin-runtime/src/plugins.rs | 33 +- .../src/plugins/jdbc_sessions.rs | 182 ++++++++ .../main/java/app/dbx/jdbc/DbxJdbcPlugin.java | 225 +++++++-- .../java/app/dbx/jdbc/H2FileSessionProbe.java | 205 +++++++++ .../app/dbx/jdbc/H2LogicalSessionTest.java | 431 ++++++++++++++++++ .../app/dbx/jdbc/InterSystemsNumericTest.java | 34 +- 8 files changed, 1534 insertions(+), 56 deletions(-) create mode 100644 crates/dbx-core/src/connection/h2_jdbc_tests.rs create mode 100644 crates/dbx-plugin-runtime/src/plugins/jdbc_sessions.rs create mode 100644 plugins/jdbc/src/test/java/app/dbx/jdbc/H2FileSessionProbe.java create mode 100644 plugins/jdbc/src/test/java/app/dbx/jdbc/H2LogicalSessionTest.java diff --git a/crates/dbx-core/src/connection/h2_jdbc_tests.rs b/crates/dbx-core/src/connection/h2_jdbc_tests.rs new file mode 100644 index 0000000000..5dad5aa84e --- /dev/null +++ b/crates/dbx-core/src/connection/h2_jdbc_tests.rs @@ -0,0 +1,428 @@ +use super::*; + +async fn fixture() -> (AppState, std::path::PathBuf) { + use std::os::unix::fs::PermissionsExt; + let (mut state, directory) = super::tests::test_app_state().await; + let plugins = directory.join("plugins"); + let plugin = plugins.join("jdbc"); + std::fs::create_dir_all(&plugin).unwrap(); + let script = plugin.join("driver.py"); + std::fs::write( + &script, + r#"#!/usr/bin/python3 +import json, os, sys +sessions = {} +slow_close = set() +with open(os.path.join(os.path.dirname(__file__), 'pids'), 'a') as pids: + pids.write(str(os.getpid()) + '\n') +for line in sys.stdin: + request = json.loads(line) + method, params = request['method'], request.get('params', {}) + session = params.get('jdbcSessionId', 'legacy') + result = {'pid': os.getpid(), 'session': session} + response = {'id': request['id']} + if method == 'jdbcSessionProtocol': + result = {'version': 2} + elif method == 'openJdbcSession': + sessions[session] = None + if os.path.exists(os.path.join(os.path.dirname(__file__), 'delay-open')): + open(os.path.join(os.path.dirname(__file__), 'opening'), 'w').close() + continue + elif method == 'connect': + if params['connection'].get('username') == 'fail': + response['error'] = {'message': 'connect failed'} + else: + sessions[session] = params['connection']['connection_string'] + if params['connection'].get('username') == 'delay-close': + slow_close.add(session) + elif method == 'closeJdbcSession': + sessions.pop(session, None) + if session in slow_close: + continue + elif method == 'wait': + open(os.path.join(os.path.dirname(__file__), 'waiting'), 'w').close() + continue + elif method == 'exit': + sys.exit(0) + else: + result['url'] = sessions.get(session) + result['session_count'] = len(sessions) + response.setdefault('result', result) + print(json.dumps(response), flush=True) +"#, + ) + .unwrap(); + std::fs::set_permissions(&script, std::fs::Permissions::from_mode(0o755)).unwrap(); + std::fs::write(plugin.join("manifest.json"), serde_json::json!({ + "id": "jdbc", "name": "JDBC", "version": "0.1.41", "protocol_version": 1, + "executable": "driver.py", "drivers": [{"id": "jdbc", "label": "JDBC", "kind": "external", "database_type": "jdbc"}] + }).to_string()).unwrap(); + state.plugins = PluginRegistry::new_with_app_version(plugins, "0.6.30"); + let mut config = super::tests::mysql_config(None); + config.db_type = DatabaseType::Jdbc; + config.connection_string = Some("jdbc:h2:file:./sample;LOCK_TIMEOUT=2000".into()); + config.jdbc_driver_class = Some("org.h2.Driver".into()); + state.configs.write().await.insert(config.id.clone(), config); + (state, directory) +} + +async fn session(state: &AppState, key: &str) -> Arc { + match state.pool_handle(key).await.unwrap() { + PoolKind::ExternalDriver { session, .. } => session, + _ => panic!("expected external JDBC driver"), + } +} + +async fn identity(session: &PluginDriverSession) -> serde_json::Value { + session.invoke("identity", serde_json::json!({})).await.unwrap() +} + +#[tokio::test] +async fn embedded_h2_jdbc_shares_process_but_preserves_pool_and_session_ownership() { + let (state, directory) = fixture().await; + let metadata = state.get_or_create_metadata_pool_for_session("conn", None, None).await.unwrap(); + let first_key = state.get_or_create_pool_for_session("conn", None, Some("tab-a")).await.unwrap(); + let second_key = state.get_or_create_pool_for_session("conn", None, Some("tab-b")).await.unwrap(); + assert_ne!(first_key, second_key); + assert_ne!(metadata, first_key); + let metadata_session = session(&state, &metadata).await; + let first = session(&state, &first_key).await; + let second = session(&state, &second_key).await; + let metadata_identity = identity(&metadata_session).await; + let first_identity = identity(&first).await; + let second_identity = identity(&second).await; + assert_eq!(metadata_identity["pid"], first_identity["pid"]); + assert_eq!(first_identity["pid"], second_identity["pid"]); + assert_ne!(metadata_identity["session"], first_identity["session"]); + assert_ne!(first_identity["session"], second_identity["session"]); + let config = state.configs.read().await["conn"].clone(); + state.test_external_driver_with_info("jdbc", &config).await.unwrap(); + assert_eq!(std::fs::read_to_string(directory.join("plugins/jdbc/pids")).unwrap().lines().count(), 1); + let mut other = state.configs.read().await["conn"].clone(); + other.id = "other".into(); + other.connection_string = Some("jdbc:h2:~/other;MODE=PostgreSQL".into()); + state.configs.write().await.insert(other.id.clone(), other); + let key = state.get_or_create_pool_for_session("other", None, Some("tab-c")).await.unwrap(); + let third = session(&state, &key).await; + let third_identity = identity(&third).await; + assert_eq!(first_identity["pid"], third_identity["pid"]); + assert_ne!(first_identity["session"], third_identity["session"]); + assert_ne!(first_identity["url"], third_identity["url"]); + state.remove_pool_by_key(&first_key).await; + assert!(!first.is_available()); + assert_eq!(identity(&second).await["session"], second_identity["session"]); + let reopened_key = state.get_or_create_pool_for_session("conn", None, Some("tab-a")).await.unwrap(); + assert_eq!(reopened_key, first_key); + let reopened = identity(session(&state, &reopened_key).await.as_ref()).await; + assert_eq!(reopened["pid"], second_identity["pid"]); + assert_ne!(reopened["session"], first_identity["session"]); + state.shutdown(Duration::from_secs(5)).await; + assert!(metadata_session.pid().await.is_none()); + std::fs::remove_dir_all(directory).unwrap(); +} + +#[tokio::test] +async fn embedded_h2_jdbc_failed_connect_cancel_drop_and_last_close_are_isolated() { + let (state, directory) = fixture().await; + let config = state.configs.read().await["conn"].clone(); + let good = state.external_driver_pool("jdbc", &config).await.unwrap(); + let PoolKind::ExternalDriver { session: good, .. } = good else { panic!() }; + let pid = good.pid().await; + let mut bad = config.clone(); + bad.username = "fail".into(); + assert!(state.external_driver_pool("jdbc", &bad).await.is_err()); + assert_eq!(good.pid().await, pid); + identity(&good).await; + let PoolKind::ExternalDriver { session: waiting, .. } = state.external_driver_pool("jdbc", &config).await.unwrap() + else { + panic!() + }; + let pending_session = waiting.clone(); + let pending = + tokio::spawn(async move { pending_session.invoke::("wait", serde_json::json!({})).await }); + tokio::time::timeout(Duration::from_secs(5), async { + while !directory.join("plugins/jdbc/waiting").exists() { + tokio::task::yield_now().await; + } + }) + .await + .unwrap(); + pending.abort(); + assert!(pending.await.unwrap_err().is_cancelled()); + tokio::time::timeout(Duration::from_secs(5), async { + while waiting.is_available() { + tokio::task::yield_now().await; + } + }) + .await + .unwrap(); + identity(&good).await; + drop(waiting); + let PoolKind::ExternalDriver { session: dropped, .. } = state.external_driver_pool("jdbc", &config).await.unwrap() + else { + panic!() + }; + drop(dropped); + good.shutdown().await; + tokio::time::timeout(Duration::from_secs(5), async { + while good.pid().await.is_some() { + tokio::task::yield_now().await; + } + }) + .await + .unwrap(); + let PoolKind::ExternalDriver { session: reopened, .. } = state.external_driver_pool("jdbc", &config).await.unwrap() + else { + panic!() + }; + assert_ne!(reopened.pid().await, pid); + reopened.shutdown().await; + state.shutdown(Duration::from_secs(5)).await; + std::fs::remove_dir_all(directory).unwrap(); +} + +#[tokio::test] +async fn embedded_h2_jdbc_keeps_remote_memory_and_unrelated_drivers_dedicated() { + let (state, directory) = fixture().await; + let mut config = state.configs.read().await["conn"].clone(); + for url in + ["jdbc:h2:tcp://localhost/sample", "jdbc:h2:ssl://localhost/sample", "jdbc:h2:mem:test", "jdbc:other:sample"] + { + config.connection_string = Some(url.into()); + let PoolKind::ExternalDriver { session: first, .. } = + state.external_driver_pool("jdbc", &config).await.unwrap() + else { + panic!() + }; + let PoolKind::ExternalDriver { session: second, .. } = + state.external_driver_pool("jdbc", &config).await.unwrap() + else { + panic!() + }; + assert_ne!(first.pid().await, second.pid().await); + assert_eq!(identity(&first).await["session"], "legacy"); + first.shutdown().await; + second.shutdown().await; + } + state.shutdown(Duration::from_secs(5)).await; + std::fs::remove_dir_all(directory).unwrap(); +} + +#[test] +fn embedded_h2_jdbc_url_scope_preserves_native_and_other_vendor_defaults() { + let mut config = super::tests::mysql_config(None); + config.db_type = DatabaseType::Jdbc; + for url in [ + "jdbc:h2:file:/data/example", + "jdbc:h2:./example", + "jdbc:h2:~/example;AUTO_SERVER=TRUE", + "jdbc:h2:/data/example", + "jdbc:h2:zip:/data/a.zip!/example", + ] { + config.connection_string = Some(url.into()); + assert!(is_embedded_h2_jdbc(&config), "{url}"); + } + for url in [ + "jdbc:h2:tcp://host/db", + "jdbc:h2:ssl://host/db", + "jdbc:h2:mem:", + "jdbc:h2:mem:named", + "jdbc:h2:", + "jdbc:postgresql://host/h2", + ] { + config.connection_string = Some(url.into()); + assert!(!is_embedded_h2_jdbc(&config), "{url}"); + } + config.connection_string = Some("jdbc:h2:file:./example".into()); + config.db_type = DatabaseType::H2; + assert!(!is_embedded_h2_jdbc(&config)); +} + +#[tokio::test] +async fn embedded_h2_jdbc_rejects_old_plugins_and_preserves_selected_driver_runtime() { + let (state, directory) = fixture().await; + let config = state.configs.read().await["conn"].clone(); + let script = directory.join("plugins/jdbc/driver.py"); + let original = std::fs::read_to_string(&script).unwrap(); + std::fs::write(&script, original.replace("'version': 2", "'version': 1")).unwrap(); + let error = state.external_driver_pool("jdbc", &config).await.err().unwrap(); + assert!(error.contains("Update the JDBC plugin")); + let pid = std::fs::read_to_string(directory.join("plugins/jdbc/pids")).unwrap(); + assert!(!std::process::Command::new("kill") + .args(["-0", pid.trim()]) + .stderr(std::process::Stdio::null()) + .status() + .unwrap() + .success()); + std::fs::write(&script, original).unwrap(); + let (first, second) = + tokio::join!(state.external_driver_pool("jdbc", &config), state.external_driver_pool("jdbc", &config)); + let PoolKind::ExternalDriver { session: first, .. } = first.unwrap() else { panic!() }; + let PoolKind::ExternalDriver { session: second, .. } = second.unwrap() else { panic!() }; + assert_eq!(first.pid().await, second.pid().await); + let mut different_driver = config.clone(); + different_driver.jdbc_driver_paths = vec!["other-selected-version.jar".into()]; + let PoolKind::ExternalDriver { session: different, .. } = + state.external_driver_pool("jdbc", &different_driver).await.unwrap() + else { + panic!() + }; + assert_ne!(first.pid().await, different.pid().await); + different.shutdown().await; + first.shutdown().await; + second.shutdown().await; + state.shutdown(Duration::from_secs(5)).await; + std::fs::remove_dir_all(directory).unwrap(); +} + +#[tokio::test] +async fn embedded_h2_jdbc_last_owner_close_can_race_a_new_session() { + let (state, directory) = fixture().await; + let config = state.configs.read().await["conn"].clone(); + for cycle_index in 0..8 { + let PoolKind::ExternalDriver { session: closing, .. } = + state.external_driver_pool("jdbc", &config).await.unwrap() + else { + panic!() + }; + let (_, replacement) = tokio::time::timeout(Duration::from_secs(5), async { + tokio::join!(closing.shutdown(), state.external_driver_pool("jdbc", &config)) + }) + .await + .unwrap(); + let PoolKind::ExternalDriver { session: replacement, .. } = replacement.unwrap() else { panic!() }; + assert!(replacement.is_available(), "cycle {cycle_index}"); + identity(&replacement).await; + replacement.shutdown().await; + assert!(replacement.pid().await.is_none()); + } + state.shutdown(Duration::from_secs(5)).await; + std::fs::remove_dir_all(directory).unwrap(); +} + +#[tokio::test] +async fn embedded_h2_jdbc_cancelled_open_releases_its_member_and_server_state() { + let (state, directory) = fixture().await; + let config = state.configs.read().await["conn"].clone(); + let PoolKind::ExternalDriver { session: survivor, .. } = state.external_driver_pool("jdbc", &config).await.unwrap() + else { + panic!() + }; + std::fs::write(directory.join("plugins/jdbc/delay-open"), "").unwrap(); + { + let opening = state.external_driver_pool("jdbc", &config); + tokio::pin!(opening); + tokio::time::timeout(Duration::from_secs(5), async { + loop { + tokio::select! { + result = &mut opening => panic!("opening unexpectedly finished: {}", result.is_ok()), + _ = tokio::task::yield_now() => { + if directory.join("plugins/jdbc/opening").exists() { break; } + } + } + } + }) + .await + .unwrap(); + } + tokio::time::timeout(Duration::from_secs(5), async { + while identity(&survivor).await["session_count"] != 1 { + tokio::task::yield_now().await; + } + }) + .await + .unwrap(); + survivor.shutdown().await; + assert!(survivor.pid().await.is_none()); + state.shutdown(Duration::from_secs(5)).await; + std::fs::remove_dir_all(directory).unwrap(); +} + +#[tokio::test] +async fn embedded_h2_jdbc_replaces_dead_runtime_with_sibling_handles_still_alive() { + let (state, directory) = fixture().await; + let config = state.configs.read().await["conn"].clone(); + let PoolKind::ExternalDriver { session: first, .. } = state.external_driver_pool("jdbc", &config).await.unwrap() + else { + panic!() + }; + let PoolKind::ExternalDriver { session: sibling, .. } = state.external_driver_pool("jdbc", &config).await.unwrap() + else { + panic!() + }; + let original_pid = first.pid().await; + assert!(first.invoke::("exit", serde_json::json!({})).await.is_err()); + tokio::time::timeout(Duration::from_secs(5), async { + while first.is_available() || sibling.is_available() { + tokio::task::yield_now().await; + } + }) + .await + .unwrap(); + let PoolKind::ExternalDriver { session: replacement, .. } = + state.external_driver_pool("jdbc", &config).await.unwrap() + else { + panic!() + }; + assert_ne!(replacement.pid().await, original_pid); + assert!(replacement.pid().await.is_some()); + tokio::join!(first.shutdown(), sibling.shutdown()); + identity(&replacement).await; + replacement.shutdown().await; + assert!(replacement.pid().await.is_none()); + state.shutdown(Duration::from_secs(5)).await; + std::fs::remove_dir_all(directory).unwrap(); +} + +#[tokio::test] +async fn embedded_h2_jdbc_timeout_and_interrupted_shutdown_finish_session_cleanup() { + let (state, directory) = fixture().await; + let config = state.configs.read().await["conn"].clone(); + let PoolKind::ExternalDriver { session: survivor, .. } = state.external_driver_pool("jdbc", &config).await.unwrap() + else { + panic!() + }; + let PoolKind::ExternalDriver { session: timed, .. } = state.external_driver_pool("jdbc", &config).await.unwrap() + else { + panic!() + }; + let error = timed + .invoke_with_timeout::("wait", serde_json::json!({}), Some(Duration::from_millis(20))) + .await + .unwrap_err(); + assert!(error.contains("timed out")); + assert!(!timed.is_available()); + timed.shutdown().await; + identity(&survivor).await; + let mut delayed = config.clone(); + delayed.username = "delay-close".into(); + let PoolKind::ExternalDriver { session: closing, .. } = state.external_driver_pool("jdbc", &delayed).await.unwrap() + else { + panic!() + }; + let close_session = closing.clone(); + let close = tokio::spawn(async move { + close_session.shutdown().await; + }); + tokio::time::timeout(Duration::from_secs(5), async { + while closing.is_available() { + tokio::task::yield_now().await; + } + }) + .await + .unwrap(); + close.abort(); + assert!(close.await.unwrap_err().is_cancelled()); + identity(&survivor).await; + survivor.shutdown().await; + tokio::time::timeout(Duration::from_secs(5), async { + while survivor.pid().await.is_some() { + tokio::task::yield_now().await; + } + }) + .await + .unwrap(); + closing.shutdown().await; + state.shutdown(Duration::from_secs(5)).await; + std::fs::remove_dir_all(directory).unwrap(); +} diff --git a/crates/dbx-core/src/connection/mod.rs b/crates/dbx-core/src/connection/mod.rs index 70c73d717f..13d805600f 100644 --- a/crates/dbx-core/src/connection/mod.rs +++ b/crates/dbx-core/src/connection/mod.rs @@ -152,6 +152,7 @@ impl PoolKind { fn is_available_for_routing(&self) -> bool { match self { Self::Agent(client) => client.is_runtime_available(), + Self::ExternalDriver { session, .. } => session.is_available(), _ => true, } } @@ -1860,6 +1861,23 @@ impl AppState { config: &ConnectionConfig, ) -> Result { let params = serde_json::json!({ "connection": config }); + if driver_id == "jdbc" && is_embedded_h2_jdbc(config) { + let PoolKind::ExternalDriver { session, .. } = self.external_driver_pool(driver_id, config).await? else { + unreachable!(); + }; + let result = session + .invoke_with_timeout::( + "testConnection", + params, + Some(external_driver_connect_timeout(config)), + ) + .await; + session.shutdown().await; + return result.map(|response| { + ConnectionTestResult::success("Connection successful") + .with_database_info(database_info_from_protocol_value(&response)) + }); + } let env = self.external_driver_runtime_env(driver_id)?; let response = self .plugins @@ -1877,7 +1895,17 @@ impl AppState { pub async fn external_driver_pool(&self, driver_id: &str, config: &ConnectionConfig) -> Result { let env = self.external_driver_runtime_env(driver_id)?; - let session = self.plugins.start_driver_session_for_connection(driver_id, env, &config.name).await?; + let session = if driver_id == "jdbc" && is_embedded_h2_jdbc(config) { + let runtime_key = serde_json::to_string(&( + &config.jdbc_driver_class, + &config.jdbc_driver_paths, + &config.agent_java_options, + )) + .map_err(|error| error.to_string())?; + self.plugins.start_shared_jdbc_session_for_connection(&runtime_key, env, &config.name).await? + } else { + self.plugins.start_driver_session_for_connection(driver_id, env, &config.name).await? + }; let params = serde_json::json!({ "connection": config }); let result = session .invoke_with_timeout::("connect", params, Some(external_driver_connect_timeout(config))) @@ -4515,9 +4543,9 @@ impl AppState { } } PoolKind::PluginConnection(handle) => !handle.is_running(), + PoolKind::ExternalDriver { session, .. } => !session.is_available(), PoolKind::Sqlite(_) | PoolKind::DuckDbWorker(_) - | PoolKind::ExternalDriver { .. } | PoolKind::MessageQueue | PoolKind::Nacos | PoolKind::Consul(_) => false, @@ -6432,6 +6460,22 @@ fn normalize_client_session_id(client_session_id: Option<&str>) -> Option bool { + if config.db_type != DatabaseType::Jdbc { + return false; + } + let Some(url) = config.connection_string.as_deref() else { return false }; + let normalized = url.trim().to_ascii_lowercase(); + let Some(location) = normalized.strip_prefix("jdbc:h2:") else { return false }; + !location.starts_with("tcp:") + && !location.starts_with("ssl:") + && !location.starts_with("mem:") + && !location.is_empty() +} + +#[cfg(all(test, unix))] +mod h2_jdbc_tests; + pub fn task_client_session_id(task_kind: &str, task_id: &str) -> String { format!("{task_kind}:{task_id}") } @@ -7118,7 +7162,7 @@ mod tests { use std::sync::Arc; use std::time::{Duration, Instant}; - fn mysql_config(database: Option<&str>) -> ConnectionConfig { + pub(super) fn mysql_config(database: Option<&str>) -> ConnectionConfig { ConnectionConfig { oracle_oci_nls_lang: None, oracle_oci_tns_admin: None, @@ -8019,7 +8063,7 @@ mod tests { assert_eq!(params["connection_string"], "jdbc:sap://hana.example.com:30013/?databaseName=TENANT1&encrypt=true"); } - async fn test_app_state() -> (AppState, std::path::PathBuf) { + pub(super) async fn test_app_state() -> (AppState, std::path::PathBuf) { let dir = std::env::temp_dir().join(format!("dbx-core-test-{}", uuid::Uuid::new_v4())); std::fs::create_dir_all(&dir).unwrap(); let storage = crate::persistence::test_storage::open(&dir.join("storage.db")).await.unwrap(); diff --git a/crates/dbx-plugin-runtime/src/plugins.rs b/crates/dbx-plugin-runtime/src/plugins.rs index 40ef3baa2c..c3552cefaf 100644 --- a/crates/dbx-plugin-runtime/src/plugins.rs +++ b/crates/dbx-plugin-runtime/src/plugins.rs @@ -10,6 +10,7 @@ mod assets; mod filesystem; mod host; mod installer; +mod jdbc_sessions; mod lifecycle; mod manifest; mod marketplace; @@ -157,6 +158,7 @@ pub struct PluginRegistry { root_dir: PathBuf, app_version: String, lifecycle: PluginLifecycle, + jdbc_runtimes: jdbc_sessions::JdbcRuntimeCache, } impl PluginRegistry { @@ -165,7 +167,12 @@ impl PluginRegistry { } pub fn new_with_app_version(root_dir: PathBuf, app_version: impl Into) -> Self { - Self { root_dir, app_version: app_version.into(), lifecycle: PluginLifecycle::default() } + Self { + root_dir, + app_version: app_version.into(), + lifecycle: PluginLifecycle::default(), + jdbc_runtimes: Default::default(), + } } pub fn lifecycle(&self) -> PluginLifecycle { @@ -381,7 +388,8 @@ fn ensure_plugin_compatible(plugin: &InstalledPlugin) -> Result<(), String> { pub struct PluginDriverSession { sidecar: Arc, driver_id: String, - _activity: lifecycle::PluginUsageGuard, + _activity: Option, + logical: Option>, } impl PluginDriverSession { @@ -393,7 +401,7 @@ impl PluginDriverSession { activity: lifecycle::PluginUsageGuard, ) -> Result { let sidecar = PluginSidecarSession::start(plugin, app_version, env).await?; - Ok(Self { sidecar, driver_id, _activity: activity }) + Ok(Self { sidecar, driver_id, _activity: Some(activity), logical: None }) } pub async fn invoke(&self, method: &str, params: serde_json::Value) -> Result @@ -412,13 +420,24 @@ impl PluginDriverSession { where T: DeserializeOwned, { + if let Some(logical) = &self.logical { + return logical.invoke(method, params, timeout_duration).await; + } self.sidecar.invoke_with_timeout(method, params, Some(&self.driver_id), timeout_duration).await } pub async fn shutdown(&self) { + if let Some(logical) = &self.logical { + logical.close().await; + return; + } self.sidecar.shutdown().await; } + pub fn is_available(&self) -> bool { + self.logical.as_ref().is_none_or(|logical| logical.is_available()) + } + pub async fn pid(&self) -> Option { self.sidecar.pid().await } @@ -446,6 +465,14 @@ impl PluginDriverSession { } } +impl Drop for PluginDriverSession { + fn drop(&mut self) { + if let Some(logical) = &self.logical { + logical.close_in_background(); + } + } +} + #[cfg(test)] mod tests { use std::path::{Path, PathBuf}; diff --git a/crates/dbx-plugin-runtime/src/plugins/jdbc_sessions.rs b/crates/dbx-plugin-runtime/src/plugins/jdbc_sessions.rs new file mode 100644 index 0000000000..542222ea34 --- /dev/null +++ b/crates/dbx-plugin-runtime/src/plugins/jdbc_sessions.rs @@ -0,0 +1,182 @@ +use std::collections::HashMap; +use std::sync::atomic::{AtomicBool, Ordering}; +use std::sync::{Arc, Weak}; +use std::time::Duration; + +use tokio::sync::Mutex; + +use super::{PluginDriverSession, PluginRegistry, PluginRuntimeEnv}; + +#[derive(Clone, Default)] +pub(super) struct JdbcRuntimeCache(Arc>>>); + +impl std::fmt::Debug for JdbcRuntimeCache { + fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("JdbcRuntimeCache") + } +} + +struct JdbcRuntime { + process: Arc, + members: Mutex<(usize, bool)>, +} + +pub(super) struct JdbcLogicalSession { + runtime: Arc, + id: String, + closed: AtomicBool, + operation: Mutex<()>, + close_done: tokio::sync::watch::Sender, +} + +impl PluginRegistry { + pub async fn start_shared_jdbc_session_for_connection( + &self, + runtime_key: &str, + env: PluginRuntimeEnv, + connection_label: &str, + ) -> Result, String> { + let key = serde_json::to_string(&(runtime_key, &env.vars)).map_err(|error| error.to_string())?; + let mut cache = self.jdbc_runtimes.0.lock().await; + cache.retain(|_, runtime| runtime.strong_count() > 0); + let mut runtime = cache.get(&key).and_then(Weak::upgrade); + if let Some(existing) = &runtime { + let mut members = existing.members.lock().await; + if !members.1 && existing.process.sidecar.status().state == super::PluginSessionState::Running { + members.0 += 1; + } else { + existing.process.sidecar.shutdown().await; + members.1 = true; + drop(members); + runtime = None; + } + } + let runtime = match runtime { + Some(runtime) => runtime, + None => { + let process = self.start_driver_session_for_connection("jdbc", env, connection_label).await?; + let mut startup = StartupGuard(Some(process.clone())); + let protocol = process.invoke::("jdbcSessionProtocol", serde_json::json!({})).await; + if !matches!(protocol, Ok(ref value) if value["version"] == 2) { + process.shutdown().await; + startup.0 = None; + return Err("Update the JDBC plugin to a version supporting embedded H2 logical sessions".into()); + } + startup.0 = None; + let runtime = Arc::new(JdbcRuntime { process, members: Mutex::new((1, false)) }); + cache.insert(key, Arc::downgrade(&runtime)); + runtime + } + }; + let logical = Arc::new(JdbcLogicalSession { + runtime: runtime.clone(), + id: uuid::Uuid::new_v4().to_string(), + closed: AtomicBool::new(false), + operation: Mutex::new(()), + close_done: tokio::sync::watch::channel(false).0, + }); + let opened: Result = + logical.invoke("openJdbcSession", serde_json::json!({}), Some(Duration::from_secs(3))).await; + if let Err(error) = opened { + logical.close().await; + return Err(error); + } + Ok(Arc::new(PluginDriverSession { + sidecar: runtime.process.sidecar.clone(), + driver_id: "jdbc".into(), + _activity: None, + logical: Some(logical), + })) + } +} + +impl JdbcLogicalSession { + pub(super) fn is_available(&self) -> bool { + !self.closed.load(Ordering::Acquire) + && self.runtime.process.sidecar.status().state == super::PluginSessionState::Running + } + + pub(super) async fn invoke( + self: &Arc, + method: &str, + mut params: serde_json::Value, + timeout: Option, + ) -> Result { + let _operation = self.operation.lock().await; + if !self.is_available() { + return Err("JDBC logical session is closed; reconnect this session".into()); + } + params + .as_object_mut() + .ok_or("JDBC session parameters must be an object")? + .insert("jdbcSessionId".into(), self.id.clone().into()); + let mut guard = CancelOnDrop(Some(self.clone())); + let request = self.runtime.process.sidecar.invoke_with_timeout(method, params, Some("jdbc"), None); + let result = match timeout { + Some(duration) => tokio::time::timeout(duration, request) + .await + .map_err(|_| "JDBC logical session request timed out".to_string())?, + None => request.await, + }; + guard.0 = None; + result + } + + pub(super) async fn close(self: &Arc) { + self.close_in_background(); + let _ = self.close_done.subscribe().wait_for(|done| *done).await; + } + + pub(super) fn close_in_background(self: &Arc) { + if let Ok(handle) = tokio::runtime::Handle::try_current() { + if self.closed.swap(true, Ordering::AcqRel) { + return; + } + let session = self.clone(); + handle.spawn(async move { + let runtime = &session.runtime; + let _: Result = runtime + .process + .sidecar + .invoke_with_timeout( + "closeJdbcSession", + serde_json::json!({"jdbcSessionId": session.id}), + Some("jdbc"), + Some(Duration::from_secs(3)), + ) + .await; + let mut members = runtime.members.lock().await; + members.0 -= 1; + if members.0 == 0 { + members.1 = true; + runtime.process.sidecar.shutdown().await; + } + session.close_done.send_replace(true); + }); + } + } +} + +struct CancelOnDrop(Option>); + +struct StartupGuard(Option>); + +impl Drop for StartupGuard { + fn drop(&mut self) { + if let Some(process) = self.0.take() { + if let Ok(handle) = tokio::runtime::Handle::try_current() { + handle.spawn(async move { + process.sidecar.shutdown().await; + }); + } + } + } +} + +impl Drop for CancelOnDrop { + fn drop(&mut self) { + if let Some(session) = &self.0 { + session.close_in_background(); + } + } +} diff --git a/plugins/jdbc/src/main/java/app/dbx/jdbc/DbxJdbcPlugin.java b/plugins/jdbc/src/main/java/app/dbx/jdbc/DbxJdbcPlugin.java index 60b912be0b..5e99d4b2e1 100644 --- a/plugins/jdbc/src/main/java/app/dbx/jdbc/DbxJdbcPlugin.java +++ b/plugins/jdbc/src/main/java/app/dbx/jdbc/DbxJdbcPlugin.java @@ -166,11 +166,28 @@ public final class DbxJdbcPlugin { new JdbcDriverQuirkRule("jdbc:taos-rs:", TAOS_QUIRKS) ); private static String registeredDriverKey = ""; + private static String logicalDriverKey; private static Driver registeredDriver; - private static String sharedConnectionKey = ""; - private static Connection sharedConnection; - private static boolean manualTransactionActive; - private static final Map QUERY_SESSIONS = new HashMap<>(); + private static ClassLoader registeredDriverClassLoader; + private static final JdbcConnectionState DEFAULT_CONNECTION_STATE = new JdbcConnectionState(); + private static final ThreadLocal CONNECTION_STATE = + ThreadLocal.withInitial(() -> DEFAULT_CONNECTION_STATE); + private static final Map LOGICAL_SESSIONS = new java.util.concurrent.ConcurrentHashMap<>(); + private static volatile boolean shuttingDown; + + private static final class JdbcConnectionState { + String sharedConnectionKey = ""; + Connection sharedConnection; + boolean manualTransactionActive; + final Map querySessions = new HashMap<>(); + volatile Statement activeStatement; + volatile boolean closing; + final java.util.concurrent.locks.ReentrantLock operation = new java.util.concurrent.locks.ReentrantLock(); + } + + private static JdbcConnectionState connectionState() { + return CONNECTION_STATE.get(); + } record JdbcDriverQuirks( boolean skipExecutionContext, @@ -266,6 +283,7 @@ public final class DbxJdbcPlugin { } public static void main(String[] args) throws Exception { + java.util.concurrent.ExecutorService requests = java.util.concurrent.Executors.newCachedThreadPool(); try ( BufferedReader reader = new BufferedReader(new InputStreamReader(System.in, StandardCharsets.UTF_8)); BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(System.out, StandardCharsets.UTF_8)) @@ -275,21 +293,127 @@ public final class DbxJdbcPlugin { if (line.isBlank()) { continue; } + JsonNode incoming = MAPPER.readTree(line); + if (incoming.path("params").hasNonNull("jdbcSessionId")) { + JdbcConnectionState retainedState = retainLogicalState(incoming); + requests.execute(() -> { + try { + writeResponse(writer, handleRequest(incoming, retainedState)); + } catch (Exception error) { + System.err.println("JDBC session response failed: " + error.getClass().getSimpleName()); + } + }); + continue; + } + if ("close".equals(incoming.path("method").asText())) shuttingDown = true; ObjectNode response = handleLine(line); - writer.write(MAPPER.writeValueAsString(response)); - writer.newLine(); - writer.flush(); + writeResponse(writer, response); if (response.path("_dbx_close").asBoolean(false)) { break; } } } finally { + shuttingDown = true; + for (JdbcConnectionState state : LOGICAL_SESSIONS.values()) { + closeLogicalSession(state); + } + LOGICAL_SESSIONS.clear(); + requests.shutdown(); closeSharedConnection(); } } + private static void writeResponse(BufferedWriter writer, ObjectNode response) throws IOException { + synchronized (writer) { + writer.write(MAPPER.writeValueAsString(response)); + writer.newLine(); + writer.flush(); + } + } + + private static void closeLogicalSession(JdbcConnectionState state) { + state.closing = true; + boolean locked = false; + while (!locked) { + Statement statement = state.activeStatement; + if (statement != null) { + try { + statement.cancel(); + } catch (SQLException ignored) { + } + } + try { + locked = state.operation.tryLock(50, java.util.concurrent.TimeUnit.MILLISECONDS); + } catch (InterruptedException ignored) { + } + } + try { + JdbcConnectionState previous = connectionState(); + CONNECTION_STATE.set(state); + try { + closeSharedConnection(); + } finally { + CONNECTION_STATE.set(previous); + } + } finally { + state.operation.unlock(); + } + } + + private static JdbcConnectionState retainLogicalState(JsonNode request) { + JsonNode params = request.path("params"); + if (!params.hasNonNull("jdbcSessionId") || shuttingDown) return null; + String sessionId = params.path("jdbcSessionId").asText(); + String method = request.path("method").asText(); + if ("openJdbcSession".equals(method)) { + return LOGICAL_SESSIONS.computeIfAbsent(sessionId, ignored -> new JdbcConnectionState()); + } + if ("closeJdbcSession".equals(method)) { + JdbcConnectionState state = LOGICAL_SESSIONS.remove(sessionId); + if (state != null) state.closing = true; + return state; + } + return LOGICAL_SESSIONS.get(sessionId); + } + + private static JsonNode handleLogicalSession(String method, JsonNode params, JsonNode connection, + JdbcConnectionState state) throws Exception { + String id = requireText(params, "jdbcSessionId"); + if ("closeJdbcSession".equals(method)) { + if (state != null) closeLogicalSession(state); + return okResult(); + } + if (state == null) throw new SQLException("Unknown JDBC logical session"); + state.operation.lock(); + try { + if (shuttingDown || state.closing) throw new SQLException("JDBC logical session is closed"); + if ("openJdbcSession".equals(method)) return okResult(); + CONNECTION_STATE.set(state); + try { + registerDrivers(connection); + return handle(method, params, connection); + } catch (Exception | LinkageError error) { + if ("connect".equals(method)) { + closeSharedConnection(); + state.closing = true; + LOGICAL_SESSIONS.remove(id, state); + } + throw error; + } finally { + state.activeStatement = null; + CONNECTION_STATE.remove(); + } + } finally { + state.operation.unlock(); + } + } + private static ObjectNode handleLine(String line) throws Exception { JsonNode request = MAPPER.readTree(line); + return handleRequest(request, retainLogicalState(request)); + } + + private static ObjectNode handleRequest(JsonNode request, JdbcConnectionState retainedState) throws Exception { JsonNode id = request.path("id"); ObjectNode response = MAPPER.createObjectNode(); response.set("id", id.isMissingNode() ? MAPPER.getNodeFactory().numberNode(1) : id); @@ -299,7 +423,19 @@ public final class DbxJdbcPlugin { String method = requireText(request, "method"); JsonNode params = request.path("params"); connection = params.path("connection"); + if ("jdbcSessionProtocol".equals(method)) { + response.set("result", MAPPER.createObjectNode().put("version", 2)); + return response; + } + if (params.hasNonNull("jdbcSessionId")) { + response.set("result", handleLogicalSession(method, params, connection, retainedState)); + return response; + } if ("close".equals(method)) { + for (JdbcConnectionState state : LOGICAL_SESSIONS.values()) { + closeLogicalSession(state); + } + LOGICAL_SESSIONS.clear(); closeSharedConnection(); ObjectNode result = MAPPER.createObjectNode(); result.put("ok", true); @@ -590,9 +726,16 @@ public final class DbxJdbcPlugin { T get() throws SQLException; } - private static void registerDrivers(JsonNode connection) throws Exception { + private static synchronized void registerDrivers(JsonNode connection) throws Exception { String driverKey = driverKey(connection); + if (logicalDriverKey != null && !logicalDriverKey.equals(driverKey)) { + throw new SQLException("JDBC logical sessions require the same selected driver"); + } + if (connectionState() != DEFAULT_CONNECTION_STATE) logicalDriverKey = driverKey; if (driverKey.equals(registeredDriverKey) && registeredDriver != null) { + if (registeredDriverClassLoader != null) { + Thread.currentThread().setContextClassLoader(registeredDriverClassLoader); + } return; } closeSharedConnection(); @@ -612,6 +755,7 @@ public final class DbxJdbcPlugin { ? Thread.currentThread().getContextClassLoader() : new URLClassLoader(urls.toArray(URL[]::new), DbxJdbcPlugin.class.getClassLoader()); Thread.currentThread().setContextClassLoader(loader); + registeredDriverClassLoader = loader; String driverClass = optionalText(connection, "jdbc_driver_class"); if (driverClass != null) { @@ -647,9 +791,10 @@ public final class DbxJdbcPlugin { throw new IllegalArgumentException("JDBC URL is required."); } String key = connectionKey(connection); - if (sharedConnection != null && key.equals(sharedConnectionKey) && !isConnectionClosed(sharedConnection)) { - configureOrdinaryAutoCommit(sharedConnection); - return sharedConnection; + JdbcConnectionState state = connectionState(); + if (state.sharedConnection != null && key.equals(state.sharedConnectionKey) && !isConnectionClosed(state.sharedConnection)) { + configureOrdinaryAutoCommit(state.sharedConnection); + return state.sharedConnection; } closeSharedConnection(); @@ -679,10 +824,10 @@ public final class DbxJdbcPlugin { // Prefer the explicitly registered driver. DriverManager.getConnection only catches // SQLException; Hive/Inceptor drivers may throw UnsupportedOperationException for optional // methods, which aborts connect before the intended driver is reached. - sharedConnection = connectWithRegisteredDriver(url, properties); - sharedConnectionKey = key; - configureOrdinaryAutoCommit(sharedConnection); - return sharedConnection; + state.sharedConnection = connectWithRegisteredDriver(url, properties); + state.sharedConnectionKey = key; + configureOrdinaryAutoCommit(state.sharedConnection); + return state.sharedConnection; } private static Connection connectWithRegisteredDriver(String url, Properties properties) throws SQLException { @@ -732,14 +877,14 @@ public final class DbxJdbcPlugin { } private static void configureOrdinaryAutoCommit(Connection jdbcConnection) throws SQLException { - if (manualTransactionActive || hasActiveQuerySession(jdbcConnection) || jdbcConnection.getAutoCommit()) { + if (connectionState().manualTransactionActive || hasActiveQuerySession(jdbcConnection) || jdbcConnection.getAutoCommit()) { return; } jdbcConnection.setAutoCommit(true); } private static boolean hasActiveQuerySession(Connection jdbcConnection) { - return QUERY_SESSIONS.values().stream().anyMatch(session -> session.connection == jdbcConnection); + return connectionState().querySessions.values().stream().anyMatch(session -> session.connection == jdbcConnection); } private static boolean isPhoenixConnection(JsonNode connection, String url) { @@ -1034,6 +1179,8 @@ public final class DbxJdbcPlugin { boolean bitStringColumns = usesBitStringColumns(connection); boolean fullPrecisionIntegers = usesFullPrecisionIntegers(connection); try (Statement statement = conn.createStatement()) { + connectionState().activeStatement = statement; + if (connectionState().closing) throw new SQLException("JDBC logical session is closed"); applyStatementOptions(statement, maxRows, fetchSize, timeoutSecs, quirks); String trimmedSql = trimStatementSql(sql); String effectiveSql = rewritePhoenixSystemCatalogQuery(connection, conn, trimmedSql); @@ -1080,7 +1227,7 @@ public final class DbxJdbcPlugin { private static ObjectNode beginManualTransaction(JsonNode connection, String database, String schema) throws SQLException { - if (manualTransactionActive) { + if (connectionState().manualTransactionActive) { throw new SQLException("A manual transaction is already active"); } Connection conn = openConnection(connection); @@ -1091,7 +1238,7 @@ public final class DbxJdbcPlugin { } applyExecutionContext(connection, conn, database, schema); conn.setAutoCommit(false); - manualTransactionActive = true; + connectionState().manualTransactionActive = true; return okResult(); } @@ -1113,7 +1260,7 @@ public final class DbxJdbcPlugin { Connection conn = activeManualTransactionConnection(null); conn.commit(); conn.setAutoCommit(true); - manualTransactionActive = false; + connectionState().manualTransactionActive = false; return okResult(); } @@ -1121,18 +1268,19 @@ public final class DbxJdbcPlugin { Connection conn = activeManualTransactionConnection(null); conn.rollback(); conn.setAutoCommit(true); - manualTransactionActive = false; + connectionState().manualTransactionActive = false; return okResult(); } private static Connection activeManualTransactionConnection(JsonNode connection) throws SQLException { - if (!manualTransactionActive || sharedConnection == null || sharedConnection.isClosed()) { + JdbcConnectionState state = connectionState(); + if (!state.manualTransactionActive || state.sharedConnection == null || state.sharedConnection.isClosed()) { throw new SQLException("No manual transaction is active"); } - if (connection != null && !connectionKey(connection).equals(sharedConnectionKey)) { + if (connection != null && !connectionKey(connection).equals(state.sharedConnectionKey)) { throw new SQLException("The manual transaction belongs to a different JDBC connection"); } - return sharedConnection; + return state.sharedConnection; } private static ObjectNode okResult() { @@ -1213,11 +1361,13 @@ public final class DbxJdbcPlugin { Statement statement; try { statement = createPagedQueryStatement(conn); + connectionState().activeStatement = statement; } catch (Exception | LinkageError error) { restorePagedQueryTransaction(conn, restoreAutoCommit); throw error; } try { + if (connectionState().closing) throw new SQLException("JDBC logical session is closed"); applyStatementOptions(statement, maxRows, fetchSize, timeoutSecs, quirks); String trimmedSql = trimStatementSql(sql); String effectiveSql = rewritePhoenixSystemCatalogQuery(connection, conn, trimmedSql); @@ -1260,11 +1410,11 @@ public final class DbxJdbcPlugin { bitStringColumns, usesFullPrecisionIntegers(connection) ); - QUERY_SESSIONS.put(sessionId, session); + connectionState().querySessions.put(sessionId, session); try { return readQuerySessionPage(session, pageSize); } catch (Exception | LinkageError error) { - QUERY_SESSIONS.remove(sessionId); + connectionState().querySessions.remove(sessionId); throw error; } } catch (Exception | LinkageError error) { @@ -1309,7 +1459,7 @@ public final class DbxJdbcPlugin { } private static JsonNode fetchQueryPage(String sessionId, int pageSize) throws SQLException { - QuerySession session = QUERY_SESSIONS.get(sessionId); + QuerySession session = connectionState().querySessions.get(sessionId); if (session == null) { throw new IllegalArgumentException("Unknown query session: " + sessionId); } @@ -1317,6 +1467,8 @@ public final class DbxJdbcPlugin { } private static JsonNode readQuerySessionPage(QuerySession session, int pageSize) throws SQLException { + connectionState().activeStatement = session.statement; + if (connectionState().closing) throw new SQLException("JDBC logical session is closed"); int effectivePageSize = Math.max(1, pageSize); ArrayNode rows = MAPPER.createArrayNode(); boolean truncated = false; @@ -1376,7 +1528,7 @@ public final class DbxJdbcPlugin { } private static boolean closeQuerySession(String sessionId) { - QuerySession session = QUERY_SESSIONS.remove(sessionId); + QuerySession session = connectionState().querySessions.remove(sessionId); if (session == null) { return false; } @@ -1393,7 +1545,7 @@ public final class DbxJdbcPlugin { } private static void closeAllQuerySessions() { - List sessionIds = new ArrayList<>(QUERY_SESSIONS.keySet()); + List sessionIds = new ArrayList<>(connectionState().querySessions.keySet()); for (String sessionId : sessionIds) { closeQuerySession(sessionId); } @@ -3504,22 +3656,23 @@ public final class DbxJdbcPlugin { } private static void closeSharedConnection() { + JdbcConnectionState state = connectionState(); closeAllQuerySessions(); - if (sharedConnection != null) { - if (manualTransactionActive) { + if (state.sharedConnection != null) { + if (state.manualTransactionActive) { try { - sharedConnection.rollback(); + state.sharedConnection.rollback(); } catch (SQLException ignored) { } } try { - sharedConnection.close(); + state.sharedConnection.close(); } catch (SQLException ignored) { } - sharedConnection = null; - sharedConnectionKey = ""; + state.sharedConnection = null; + state.sharedConnectionKey = ""; } - manualTransactionActive = false; + state.manualTransactionActive = false; } private static String driverKey(JsonNode connection) { diff --git a/plugins/jdbc/src/test/java/app/dbx/jdbc/H2FileSessionProbe.java b/plugins/jdbc/src/test/java/app/dbx/jdbc/H2FileSessionProbe.java new file mode 100644 index 0000000000..b43a60880b --- /dev/null +++ b/plugins/jdbc/src/test/java/app/dbx/jdbc/H2FileSessionProbe.java @@ -0,0 +1,205 @@ +package app.dbx.jdbc; + +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.databind.node.ObjectNode; + +import java.io.BufferedReader; +import java.io.BufferedWriter; +import java.io.InputStreamReader; +import java.io.OutputStreamWriter; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.ArrayList; +import java.util.List; +import java.util.concurrent.TimeUnit; + +public final class H2FileSessionProbe { + private static final ObjectMapper JSON = new ObjectMapper(); + + public static void main(String[] args) throws Exception { + if (args.length != 4) throw new IllegalArgumentException("plugin.jar h2-2.1.214.jar temporary-directory baseline|patched|cold"); + Path plugin = Path.of(args[0]).toAbsolutePath(); + Path driver = Path.of(args[1]).toAbsolutePath(); + Path directory = Path.of(args[2]).toAbsolutePath(); + Files.createDirectories(directory); + ObjectNode connection = JSON.createObjectNode(); + connection.put("connection_string", "jdbc:h2:file:" + directory.resolve("ownership") + ";LOCK_TIMEOUT=2000"); + connection.put("jdbc_driver_class", "org.h2.Driver"); + connection.putArray("jdbc_driver_paths").add(driver.toString()); + connection.put("username", "sa"); + if (args[3].equals("cold")) { + coldConcurrentStarts(plugin, connection, directory); + return; + } + try (Sidecar owner = new Sidecar(plugin)) { + if (args[3].equals("baseline")) { + owner.ok("connect", params(connection, null)); + owner.ok("executeQuery", params(connection, null).put("sql", "CREATE TABLE IF NOT EXISTS test(id INT PRIMARY KEY)")); + try (Sidecar competitor = new Sidecar(plugin)) { + JsonNode locked = competitor.call("connect", params(connection, null)); + check(locked.has("error"), "baseline unexpectedly opened the same file in two JVMs"); + check(locked.path("error").path("message").asText().toLowerCase().matches("(?s).*(lock|already in use).*"), locked.toString()); + System.out.println("PASS baseline metadata JVM opens file; tab JVM reports file ownership error"); + } + return; + } + check(owner.ok("jdbcSessionProtocol", JSON.createObjectNode()).path("version").asInt() == 2, "logical session protocol"); + for (String session : List.of("metadata", "a", "b")) { + owner.ok("openJdbcSession", params(connection, session)); + owner.ok("connect", params(connection, session)); + } + query(owner, connection, "metadata", "DROP TABLE IF EXISTS test"); + query(owner, connection, "metadata", "CREATE TABLE test(id INT PRIMARY KEY)"); + owner.ok("listTables", params(connection, "metadata").put("schema", "PUBLIC")); + for (String session : List.of("a", "b")) owner.ok("beginManualTransaction", params(connection, session)); + owner.ok("executeInManualTransaction", params(connection, "a").put("sql", "INSERT INTO test VALUES(1)")); + owner.ok("executeInManualTransaction", params(connection, "b").put("sql", "INSERT INTO test VALUES(2)")); + check(count(owner, connection, "metadata") == 0, "uncommitted rows leaked"); + owner.ok("commitManualTransaction", params(connection, "a")); + check(count(owner, connection, "metadata") == 1, "commit affected another transaction"); + owner.ok("rollbackManualTransaction", params(connection, "b")); + check(count(owner, connection, "metadata") == 1, "rollback affected committed row"); + query(owner, connection, "b", "INSERT INTO test VALUES(3),(4)"); + JsonNode page = owner.ok("executeQueryPage", params(connection, "a").put("sql", "SELECT id FROM test ORDER BY id").put("pageSize", 1)); + String cursor = page.path("session_id").asText(); + check(owner.call("fetchQueryPage", params(connection, "b").put("sessionId", cursor)).has("error"), "foreign cursor accepted"); + check(owner.ok("fetchQueryPage", params(connection, "a").put("sessionId", cursor).put("pageSize", 1)).path("rows").path(0).path(0).asInt() == 3, "cursor paging"); + owner.ok("closeQuerySession", params(connection, "a").put("sessionId", cursor)); + check(owner.call("fetchQueryPage", params(connection, "a").put("sessionId", cursor)).has("error"), "closed cursor accepted"); + ObjectNode missing = connection.deepCopy(); + missing.put("connection_string", "jdbc:h2:file:" + directory.resolve("missing") + ";IFEXISTS=TRUE"); + owner.ok("openJdbcSession", params(missing, "failed")); + check(owner.call("connect", params(missing, "failed")).has("error"), "failed connection accepted"); + check(count(owner, connection, "b") == 3, "failed connect broke another session"); + ObjectNode other = connection.deepCopy(); + other.put("connection_string", "jdbc:h2:file:" + directory.resolve("separate")); + owner.ok("openJdbcSession", params(other, "other")); + owner.ok("connect", params(other, "other")); + check(owner.call("executeQuery", params(other, "other").put("sql", "SELECT * FROM test")).has("error"), "separate files were conflated"); + owner.ok("closeJdbcSession", params(other, "other")); + try (Sidecar competitor = new Sidecar(plugin)) { + check(competitor.call("connect", params(connection, null)).has("error"), "file locking was disabled"); + } + owner.ok("beginManualTransaction", params(connection, "a")); + owner.ok("executeInManualTransaction", params(connection, "a").put("sql", "INSERT INTO test VALUES(99)")); + owner.send("executeInManualTransaction", params(connection, "a").put("sql", "SELECT SUM(X) FROM SYSTEM_RANGE(1, 1000000000)")); + Thread.sleep(100); + owner.send("closeJdbcSession", params(connection, "a")); + JsonNode first = owner.read(); + JsonNode second = owner.read(); + check(first.has("error") || second.has("error"), "cancellation did not reach the active statement"); + check(count(owner, connection, "b") == 3, "cancelled transaction was not rolled back independently"); + owner.ok("closeJdbcSession", params(connection, "b")); + check(count(owner, connection, "metadata") == 3, "closing tab broke metadata"); + owner.ok("closeJdbcSession", params(connection, "metadata")); + System.out.println("PASS patched shared JVM: independent transactions, cursors, cancellation, failures, files and locks"); + } + try (Sidecar reopened = new Sidecar(plugin)) { + reopened.ok("openJdbcSession", params(connection, "reopened")); + reopened.ok("connect", params(connection, "reopened")); + check(count(reopened, connection, "reopened") == 3, "last-runtime teardown/reopen"); + reopened.ok("closeJdbcSession", params(connection, "reopened")); + } + System.out.println("PASS final runtime teardown and file reopen"); + coldConcurrentStarts(plugin, connection, directory); + } + + private static void coldConcurrentStarts(Path plugin, ObjectNode connection, Path directory) throws Exception { + for (int attemptIndex = 0; attemptIndex < 5; attemptIndex++) { + ObjectNode coldConnection = connection.deepCopy(); + coldConnection.put("connection_string", "jdbc:h2:file:" + directory.resolve("cold-" + attemptIndex)); + try (Sidecar owner = new Sidecar(plugin)) { + for (int sessionIndex = 0; sessionIndex < 8; sessionIndex++) { + owner.ok("openJdbcSession", params(coldConnection, "cold-" + sessionIndex)); + } + for (int sessionIndex = 0; sessionIndex < 8; sessionIndex++) { + owner.send("connect", params(coldConnection, "cold-" + sessionIndex)); + } + java.util.Set responseIds = new java.util.HashSet<>(); + for (int responseIndex = 0; responseIndex < 8; responseIndex++) { + JsonNode response = owner.read(); + check(!response.has("error"), "cold start: " + response); + check(responseIds.add(response.path("id").asLong()), "duplicate connect response"); + } + for (int sessionIndex = 0; sessionIndex < 8; sessionIndex++) { + String sessionId = "cold-" + sessionIndex; + query(owner, coldConnection, sessionId, "SELECT 1"); + owner.ok("closeJdbcSession", params(coldConnection, sessionId)); + check(owner.call("connect", params(coldConnection, sessionId)).has("error"), "late connect reopened closed session"); + } + } + } + System.out.println("PASS cold concurrent starts: five fresh JVMs, eight connects each, late connects rejected"); + } + + private static int count(Sidecar process, ObjectNode connection, String session) throws Exception { + return query(process, connection, session, "SELECT COUNT(*) FROM test").path("rows").path(0).path(0).asInt(); + } + + private static JsonNode query(Sidecar process, ObjectNode connection, String session, String sql) throws Exception { + return process.ok("executeQuery", params(connection, session).put("sql", sql)); + } + + private static ObjectNode params(ObjectNode connection, String session) { + ObjectNode params = JSON.createObjectNode(); + params.set("connection", connection); + if (session != null) params.put("jdbcSessionId", session); + return params; + } + + private static void check(boolean condition, String message) { + if (!condition) throw new AssertionError(message); + } + + private static final class Sidecar implements AutoCloseable { + final Process process; + final BufferedReader input; + final BufferedWriter output; + long id; + + Sidecar(Path plugin) throws Exception { + List command = new ArrayList<>(); + command.add(Path.of(System.getProperty("java.home"), "bin", "java").toString()); + command.add("-jar"); + command.add(plugin.toString()); + process = new ProcessBuilder(command).redirectError(ProcessBuilder.Redirect.INHERIT).start(); + input = new BufferedReader(new InputStreamReader(process.getInputStream(), java.nio.charset.StandardCharsets.UTF_8)); + output = new BufferedWriter(new OutputStreamWriter(process.getOutputStream(), java.nio.charset.StandardCharsets.UTF_8)); + } + + void send(String method, ObjectNode params) throws Exception { + ObjectNode request = JSON.createObjectNode().put("id", ++id).put("method", method); + request.set("params", params); + output.write(request.toString()); + output.newLine(); + output.flush(); + } + + JsonNode read() throws Exception { + String line = input.readLine(); + check(line != null, "JDBC process exited before responding"); + return JSON.readTree(line); + } + + JsonNode call(String method, ObjectNode params) throws Exception { send(method, params); return read(); } + + JsonNode ok(String method, ObjectNode params) throws Exception { + JsonNode response = call(method, params); + check(!response.has("error"), response.toString()); + return response.path("result"); + } + + public void close() throws Exception { + if (process.isAlive()) { + call("close", JSON.createObjectNode()); + if (!process.waitFor(5, TimeUnit.SECONDS)) { + process.destroyForcibly(); + throw new AssertionError("JDBC runtime did not terminate"); + } + } + input.close(); + output.close(); + } + } +} diff --git a/plugins/jdbc/src/test/java/app/dbx/jdbc/H2LogicalSessionTest.java b/plugins/jdbc/src/test/java/app/dbx/jdbc/H2LogicalSessionTest.java new file mode 100644 index 0000000000..8650441d09 --- /dev/null +++ b/plugins/jdbc/src/test/java/app/dbx/jdbc/H2LogicalSessionTest.java @@ -0,0 +1,431 @@ +package app.dbx.jdbc; + +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.databind.node.ObjectNode; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.Test; + +import java.lang.reflect.Method; +import java.lang.reflect.Proxy; +import java.sql.*; +import java.util.ArrayList; +import java.util.List; +import java.util.Properties; +import java.util.concurrent.CopyOnWriteArrayList; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.TimeUnit; +import java.util.logging.Logger; + +import static org.junit.jupiter.api.Assertions.*; + +final class H2LogicalSessionTest { + static final ObjectMapper MAPPER = new ObjectMapper(); + static final List PHYSICAL = new CopyOnWriteArrayList<>(); + final List sessions = new ArrayList<>(); + + @AfterEach + void cleanup() throws Exception { + for (String session : sessions) request(session, "closeJdbcSession", null); + request(null, "close", null); + var driverKey = DbxJdbcPlugin.class.getDeclaredField("logicalDriverKey"); + driverKey.setAccessible(true); + driverKey.set(null, null); + PHYSICAL.clear(); + } + + @Test + void coldConcurrentConnectsShareTheFirstDriverRegistration() throws Exception { + var driverField = DbxJdbcPlugin.class.getDeclaredField("registeredDriver"); + driverField.setAccessible(true); + driverField.set(null, null); + var pending = new ArrayList>(); + synchronized (DbxJdbcPlugin.class) { + for (int sessionIndex = 0; sessionIndex < 8; sessionIndex++) { + String sessionId = "cold-" + sessionIndex; + sessions.add(sessionId); + ok(request(sessionId, "openJdbcSession", null)); + pending.add(java.util.concurrent.CompletableFuture.supplyAsync(() -> { + try { return request(sessionId, "connect", null); } + catch (Exception error) { throw new RuntimeException(error); } + })); + } + long deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(5); + while (logicalSessions().size() != 8 && System.nanoTime() < deadline) Thread.yield(); + assertEquals(8, logicalSessions().size()); + } + for (var response : pending) ok(response.get(5, TimeUnit.SECONDS)); + assertEquals(8, PHYSICAL.size()); + } + + private static java.util.Map logicalSessions() throws Exception { + var field = DbxJdbcPlugin.class.getDeclaredField("LOGICAL_SESSIONS"); + field.setAccessible(true); + return (java.util.Map) field.get(null); + } + + @Test + void closedAndFailedSessionsDoNotAccumulateOrReopenOnLateRequests() throws Exception { + connect("metadata"); + ok(request("metadata", "beginManualTransaction", null)); + for (int cycleIndex = 0; cycleIndex < 200; cycleIndex++) { + String sessionId = "cycle-" + cycleIndex; + connect(sessionId); + ok(request(sessionId, "closeJdbcSession", null)); + ok(request(sessionId, "closeJdbcSession", null)); + assertTrue(request(sessionId, "connect", null).has("error")); + assertTrue(request(sessionId, "executeQuery", "SELECT 1").has("error")); + ObjectNode failed = params("failed-" + cycleIndex); + ok(call("openJdbcSession", failed)); + ((ObjectNode) failed.path("connection")).put("connection_string", "jdbc:h2:file:fail"); + assertTrue(call("connect", failed).has("error")); + assertEquals(1, logicalSessions().size()); + } + assertEquals(201, PHYSICAL.size()); + assertFalse(PHYSICAL.get(0).autoCommit); + assertFalse(PHYSICAL.get(0).closed); + ok(request("metadata", "rollbackManualTransaction", null)); + ok(request("metadata", "closeJdbcSession", null)); + assertTrue(logicalSessions().isEmpty()); + } + + @Test + void closeInvalidatesAConnectRetainedAtIngressBeforeItRuns() throws Exception { + ok(request("queued", "openJdbcSession", null)); + ObjectNode queued = MAPPER.createObjectNode().put("id", 1).put("method", "connect"); + queued.set("params", params("queued")); + Method retain = DbxJdbcPlugin.class.getDeclaredMethod("retainLogicalState", JsonNode.class); + retain.setAccessible(true); + Object retained = retain.invoke(null, queued); + ok(request("queued", "closeJdbcSession", null)); + assertTrue(logicalSessions().isEmpty()); + Method handler = DbxJdbcPlugin.class.getDeclaredMethod("handleRequest", JsonNode.class, retained.getClass()); + handler.setAccessible(true); + assertTrue(((JsonNode) handler.invoke(null, queued, retained)).has("error")); + assertTrue(request("queued", "connect", null).has("error")); + assertTrue(PHYSICAL.isEmpty()); + } + + @Test + void closeDuringPhysicalConnectClosesOnlyItsRetainedConnection() throws Exception { + connect("survivor"); + ok(request("in-flight", "openJdbcSession", null)); + FakeDriver.connectStarted = new CountDownLatch(1); + FakeDriver.connectReleased = new CountDownLatch(1); + ObjectNode connectingParams = params("in-flight"); + ((ObjectNode) connectingParams.path("connection")).put("connection_string", "jdbc:h2:file:slow"); + var connecting = java.util.concurrent.CompletableFuture.supplyAsync(() -> { + try { return call("connect", connectingParams); } + catch (Exception error) { throw new RuntimeException(error); } + }); + assertTrue(FakeDriver.connectStarted.await(5, TimeUnit.SECONDS)); + var closing = java.util.concurrent.CompletableFuture.supplyAsync(() -> { + try { return request("in-flight", "closeJdbcSession", null); } + catch (Exception error) { throw new RuntimeException(error); } + }); + long deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(5); + while (logicalSessions().size() != 1 && System.nanoTime() < deadline) Thread.yield(); + assertEquals(1, logicalSessions().size()); + assertTrue(request("in-flight", "connect", null).has("error")); + ok(request("survivor", "executeQuery", "SELECT 1")); + FakeDriver.connectReleased.countDown(); + connecting.get(5, TimeUnit.SECONDS); + ok(closing.get(5, TimeUnit.SECONDS)); + assertEquals(2, PHYSICAL.size()); + assertTrue(PHYSICAL.get(1).closed); + assertFalse(PHYSICAL.get(0).closed); + } + + @Test + void incompatibleDriverCannotReplaceTheLiveDriverOrClassLoader() throws Exception { + connect("owner"); + var loaderField = DbxJdbcPlugin.class.getDeclaredField("registeredDriverClassLoader"); + loaderField.setAccessible(true); + Object loader = loaderField.get(null); + ObjectNode incompatible = params("different"); + ok(call("openJdbcSession", incompatible)); + ((ObjectNode) incompatible.path("connection")).put("jdbc_driver_class", "different.Driver"); + assertTrue(call("connect", incompatible).path("error").path("message").asText().contains("same selected driver")); + assertSame(loader, loaderField.get(null)); + assertEquals(1, logicalSessions().size()); + assertFalse(PHYSICAL.get(0).closed); + ok(request("owner", "executeQuery", "SELECT 1")); + } + + @Test + void isolatesConnectionsTransactionsAndCursorOwnership() throws Exception { + connect("metadata"); + connect("tab-a"); + connect("tab-b"); + assertEquals(3, PHYSICAL.size()); + ok(request("tab-a", "beginManualTransaction", null)); + assertFalse(PHYSICAL.get(1).autoCommit); + assertTrue(PHYSICAL.get(2).autoCommit); + ok(request("tab-b", "beginManualTransaction", null)); + ok(request("tab-a", "commitManualTransaction", null)); + assertEquals(1, PHYSICAL.get(1).commits); + assertEquals(0, PHYSICAL.get(2).commits); + ok(request("tab-b", "rollbackManualTransaction", null)); + assertEquals(1, PHYSICAL.get(2).rollbacks); + JsonNode page = request("tab-a", "executeQueryPage", "SELECT 1"); + ok(page); + String cursor = page.path("result").path("session_id").asText(); + assertFalse(cursor.isBlank()); + ObjectNode params = params("tab-b").put("sessionId", cursor); + assertTrue(call("fetchQueryPage", params).has("error")); + params.put("jdbcSessionId", "tab-a"); + JsonNode next = call("fetchQueryPage", params); + ok(next); + assertEquals(2, next.path("result").path("rows").path(0).path(0).asInt()); + ok(call("closeQuerySession", params)); + assertTrue(call("fetchQueryPage", params).has("error")); + ok(request("tab-a", "closeJdbcSession", null)); + assertTrue(PHYSICAL.get(1).closed); + assertFalse(PHYSICAL.get(0).closed); + assertFalse(PHYSICAL.get(2).closed); + ok(request("tab-b", "executeQuery", "SELECT 1")); + } + + @Test + void failedConnectAndCancellationDoNotCloseOtherSessions() throws Exception { + connect("survivor"); + ObjectNode bad = params("failed"); + ok(call("openJdbcSession", bad)); + ((ObjectNode) bad.path("connection")).put("connection_string", "jdbc:h2:file:fail"); + assertTrue(call("connect", bad).has("error")); + assertFalse(PHYSICAL.get(0).closed); + connect("cancelled"); + Physical cancelled = PHYSICAL.get(1); + var query = java.util.concurrent.CompletableFuture.supplyAsync(() -> { + try { return request("cancelled", "executeQuery", "WAIT"); } + catch (Exception error) { throw new RuntimeException(error); } + }); + assertTrue(cancelled.started.await(5, TimeUnit.SECONDS)); + ok(request("survivor", "executeQuery", "SELECT 1")); + ok(request("cancelled", "closeJdbcSession", null)); + assertTrue(query.get(5, TimeUnit.SECONDS).has("error")); + assertTrue(cancelled.closed); + assertFalse(PHYSICAL.get(0).closed); + assertTrue(request("cancelled", "executeQuery", "SELECT 1").has("error")); + ok(request("survivor", "executeQuery", "SELECT 1")); + } + + @Test + void processColdStartAcceptsEightConnectsBeforeResponsesAreRead() throws Exception { + Process process = startProcess(); + try (var writer = new java.io.BufferedWriter(new java.io.OutputStreamWriter(process.getOutputStream())); + var reader = new java.io.BufferedReader(new java.io.InputStreamReader(process.getInputStream()))) { + for (int sessionIndex = 0; sessionIndex < 8; sessionIndex++) { + send(writer, sessionIndex, "openJdbcSession", params("cold-" + sessionIndex)); + ok(read(reader)); + } + for (int sessionIndex = 0; sessionIndex < 8; sessionIndex++) { + send(writer, sessionIndex + 8, "connect", params("cold-" + sessionIndex)); + } + java.util.Set responseIds = new java.util.HashSet<>(); + for (int responseIndex = 0; responseIndex < 8; responseIndex++) { + JsonNode response = read(reader); + ok(response); + assertTrue(responseIds.add(response.path("id").asInt())); + } + send(writer, 16, "close", MAPPER.createObjectNode()); + ok(read(reader)); + assertTrue(process.waitFor(5, TimeUnit.SECONDS)); + assertEquals(0, process.exitValue()); + } finally { + process.destroyForcibly(); + } + } + + private Process startProcess() throws Exception { + java.util.Set paths = new java.util.LinkedHashSet<>(); + for (Class type : List.of(DbxJdbcPlugin.class, getClass(), ObjectMapper.class, + com.fasterxml.jackson.core.JsonFactory.class, com.fasterxml.jackson.annotation.JsonProperty.class)) { + paths.add(java.nio.file.Path.of(type.getProtectionDomain().getCodeSource().getLocation().toURI()).toString()); + } + for (ClassLoader loader = getClass().getClassLoader(); loader != null; loader = loader.getParent()) { + if (loader instanceof java.net.URLClassLoader urls) { + for (java.net.URL url : urls.getURLs()) paths.add(java.nio.file.Path.of(url.toURI()).toString()); + } + } + return new ProcessBuilder( + java.nio.file.Path.of(System.getProperty("java.home"), "bin", "java").toString(), + "-cp", String.join(java.io.File.pathSeparator, paths), DbxJdbcPlugin.class.getName() + ).redirectError(ProcessBuilder.Redirect.INHERIT).start(); + } + + @Test + void processDispatchesOtherSessionsAndCancellationWhileQueryRuns() throws Exception { + Process process = startProcess(); + try (var writer = new java.io.BufferedWriter(new java.io.OutputStreamWriter(process.getOutputStream())); + var reader = new java.io.BufferedReader(new java.io.InputStreamReader(process.getInputStream()))) { + send(writer, 10, "openJdbcSession", params("a")); + ok(read(reader)); + send(writer, 1, "connect", params("a")); + ok(read(reader)); + send(writer, 11, "openJdbcSession", params("b")); + ok(read(reader)); + send(writer, 2, "connect", params("b")); + ok(read(reader)); + send(writer, 3, "executeQuery", params("a").put("sql", "WAIT")); + send(writer, 4, "executeQuery", params("b").put("sql", "SELECT 1")); + JsonNode survivor = read(reader); + assertEquals(4, survivor.path("id").asInt()); + ok(survivor); + send(writer, 5, "closeJdbcSession", params("a")); + JsonNode first = read(reader); + JsonNode second = read(reader); + assertTrue(first.has("error") || second.has("error")); + send(writer, 6, "closeJdbcSession", params("b")); + ok(read(reader)); + send(writer, 7, "close", MAPPER.createObjectNode()); + ok(read(reader)); + assertTrue(process.waitFor(5, TimeUnit.SECONDS)); + assertEquals(0, process.exitValue()); + } finally { + process.destroyForcibly(); + } + } + + private static void send(java.io.BufferedWriter writer, int id, String method, ObjectNode params) throws Exception { + ObjectNode request = MAPPER.createObjectNode().put("id", id).put("method", method); + request.set("params", params); + writer.write(request.toString()); + writer.newLine(); + writer.flush(); + } + + private static JsonNode read(java.io.BufferedReader reader) throws Exception { + String line = java.util.concurrent.CompletableFuture.supplyAsync(() -> { + try { return reader.readLine(); } + catch (java.io.IOException error) { throw new RuntimeException(error); } + }).get(5, TimeUnit.SECONDS); + assertNotNull(line); + return MAPPER.readTree(line); + } + + void connect(String session) throws Exception { + sessions.add(session); + ok(request(session, "openJdbcSession", null)); + ok(request(session, "connect", null)); + } + + static void ok(JsonNode response) { assertFalse(response.has("error"), response.toString()); } + + static ObjectNode params(String session) { + ObjectNode config = MAPPER.createObjectNode(); + config.put("connection_string", "jdbc:h2:file:sample"); + config.put("jdbc_driver_class", FakeDriver.class.getName()); + ObjectNode params = MAPPER.createObjectNode(); + params.set("connection", config); + if (session != null) params.put("jdbcSessionId", session); + params.put("pageSize", 1); + return params; + } + + static JsonNode request(String session, String method, String sql) throws Exception { + ObjectNode params = params(session); + if (sql != null) params.put("sql", sql); + return call(method, params); + } + + static JsonNode call(String name, ObjectNode params) throws Exception { + Method handler = DbxJdbcPlugin.class.getDeclaredMethod("handleLine", String.class); + handler.setAccessible(true); + ObjectNode request = MAPPER.createObjectNode().put("id", 1).put("method", name); + request.set("params", params); + return (JsonNode) handler.invoke(null, request.toString()); + } + + public static final class FakeDriver implements Driver { + static volatile CountDownLatch connectStarted; + static volatile CountDownLatch connectReleased; + public Connection connect(String url, Properties properties) throws SQLException { + if (!acceptsURL(url)) return null; + if (url.endsWith("fail")) throw new SQLException("connect failed"); + if (url.endsWith("slow")) { + connectStarted.countDown(); + try { + if (!connectReleased.await(5, TimeUnit.SECONDS)) throw new SQLException("connect timed out"); + } catch (InterruptedException error) { + throw new SQLException(error); + } + } + Physical physical = new Physical(); + PHYSICAL.add(physical); + return physical.connection(); + } + public boolean acceptsURL(String url) { return url.startsWith("jdbc:h2:file:"); } + public DriverPropertyInfo[] getPropertyInfo(String url, Properties properties) { return new DriverPropertyInfo[0]; } + public int getMajorVersion() { return 1; } + public int getMinorVersion() { return 0; } + public boolean jdbcCompliant() { return true; } + public Logger getParentLogger() { return Logger.getGlobal(); } + } + + static final class Physical { + boolean autoCommit = true; + boolean closed; + int commits; + int rollbacks; + final CountDownLatch started = new CountDownLatch(1); + final CountDownLatch cancelled = new CountDownLatch(1); + + Connection connection() { + return proxy(Connection.class, (proxyInstance, invokedMethod, arguments) -> switch (invokedMethod.getName()) { + case "getAutoCommit" -> autoCommit; + case "setAutoCommit" -> { autoCommit = (boolean) arguments[0]; yield null; } + case "isClosed" -> closed; + case "close" -> { closed = true; yield null; } + case "commit" -> { commits++; yield null; } + case "rollback" -> { rollbacks++; yield null; } + case "createStatement" -> statement(); + default -> defaultValue(invokedMethod.getReturnType()); + }); + } + + Statement statement() { + ResultSet rs = resultSet(); + return proxy(Statement.class, (proxyInstance, invokedMethod, arguments) -> switch (invokedMethod.getName()) { + case "execute" -> { + if ("WAIT".equals(arguments[0])) { + started.countDown(); + if (!cancelled.await(5, TimeUnit.SECONDS)) throw new SQLException("cancel timed out"); + throw new SQLException("statement cancelled"); + } + yield true; + } + case "getResultSet" -> rs; + case "cancel" -> { cancelled.countDown(); yield null; } + default -> defaultValue(invokedMethod.getReturnType()); + }); + } + + ResultSet resultSet() { + int[] row = { 0 }; + ResultSetMetaData meta = proxy(ResultSetMetaData.class, (proxyInstance, invokedMethod, arguments) -> switch (invokedMethod.getName()) { + case "getColumnCount" -> 1; + case "getColumnType" -> Types.INTEGER; + case "getColumnName", "getColumnLabel" -> "value"; + default -> defaultValue(invokedMethod.getReturnType()); + }); + return proxy(ResultSet.class, (proxyInstance, invokedMethod, arguments) -> switch (invokedMethod.getName()) { + case "next" -> ++row[0] <= 3; + case "getMetaData" -> meta; + case "getObject" -> row[0]; + default -> defaultValue(invokedMethod.getReturnType()); + }); + } + } + + static T proxy(Class type, java.lang.reflect.InvocationHandler handler) { + return type.cast(Proxy.newProxyInstance(H2LogicalSessionTest.class.getClassLoader(), new Class[] { type }, handler)); + } + + static Object defaultValue(Class type) { + if (type == boolean.class) return false; + if (type == int.class) return 0; + if (type == long.class) return 0L; + return null; + } +} diff --git a/plugins/jdbc/src/test/java/app/dbx/jdbc/InterSystemsNumericTest.java b/plugins/jdbc/src/test/java/app/dbx/jdbc/InterSystemsNumericTest.java index 3866329eff..2c7191a432 100644 --- a/plugins/jdbc/src/test/java/app/dbx/jdbc/InterSystemsNumericTest.java +++ b/plugins/jdbc/src/test/java/app/dbx/jdbc/InterSystemsNumericTest.java @@ -40,8 +40,8 @@ final class InterSystemsNumericTest { Fixture fixture = new Fixture(url, type, values, null); JsonNode query = fixture.query("executeQuery"); assertFalse(query.has("error"), query.toString()); - for (int i = 0; i < values.length; i++) { - assertValue(values[i], query.path("result").path("rows").path(i).path(0)); + for (int rowIndex = 0; rowIndex < values.length; rowIndex++) { + assertValue(values[rowIndex], query.path("result").path("rows").path(rowIndex).path(0)); } JsonNode page = fixture.query("executeQueryPage"); int row = 0; @@ -137,12 +137,12 @@ final class InterSystemsNumericTest { } void install() throws Exception { - Connection connection = proxy(Connection.class, (p, m, a) -> switch (m.getName()) { + Connection connection = proxy(Connection.class, (proxyInstance, invokedMethod, arguments) -> switch (invokedMethod.getName()) { case "createStatement" -> statement(); case "getAutoCommit" -> true; - default -> defaultValue(m.getReturnType()); + default -> defaultValue(invokedMethod.getReturnType()); }); - set("registeredDriver", proxy(Driver.class, (p, m, a) -> defaultValue(m.getReturnType()))); + set("registeredDriver", proxy(Driver.class, (proxyInstance, invokedMethod, arguments) -> defaultValue(invokedMethod.getReturnType()))); set("registeredDriverKey", key("driverKey")); set("sharedConnection", connection); set("sharedConnectionKey", key("connectionKey")); @@ -166,23 +166,23 @@ final class InterSystemsNumericTest { Statement statement() { ResultSet result = resultSet(); - return proxy(Statement.class, (p, m, a) -> switch (m.getName()) { + return proxy(Statement.class, (proxyInstance, invokedMethod, arguments) -> switch (invokedMethod.getName()) { case "execute" -> true; case "getResultSet", "executeQuery" -> result; case "close" -> { closedStatements++; yield null; } - default -> defaultValue(m.getReturnType()); + default -> defaultValue(invokedMethod.getReturnType()); }); } ResultSet resultSet() { int[] row = { -1 }; - ResultSetMetaData meta = proxy(ResultSetMetaData.class, (p, m, a) -> switch (m.getName()) { + ResultSetMetaData meta = proxy(ResultSetMetaData.class, (proxyInstance, invokedMethod, arguments) -> switch (invokedMethod.getName()) { case "getColumnCount" -> 1; case "getColumnType" -> type; case "getColumnLabel", "getColumnName" -> "value"; - default -> defaultValue(m.getReturnType()); + default -> defaultValue(invokedMethod.getReturnType()); }); - return proxy(ResultSet.class, (p, m, a) -> switch (m.getName()) { + return proxy(ResultSet.class, (proxyInstance, invokedMethod, arguments) -> switch (invokedMethod.getName()) { case "next" -> ++row[0] < values.length; case "getMetaData" -> meta; case "getBigDecimal" -> { @@ -205,7 +205,7 @@ final class InterSystemsNumericTest { case "getString" -> values[row[0]]; case "getBoolean" -> true; case "getBytes" -> new byte[] { 1, 2 }; - default -> defaultValue(m.getReturnType()); + default -> defaultValue(invokedMethod.getReturnType()); }); } } @@ -219,9 +219,17 @@ final class InterSystemsNumericTest { } private static void set(String name, Object value) throws Exception { - Field field = DbxJdbcPlugin.class.getDeclaredField(name); + Object target = null; + Class owner = DbxJdbcPlugin.class; + if (name.startsWith("sharedConnection")) { + Method method = owner.getDeclaredMethod("connectionState"); + method.setAccessible(true); + target = method.invoke(null); + owner = target.getClass(); + } + Field field = owner.getDeclaredField(name); field.setAccessible(true); - field.set(null, value); + field.set(target, value); } private static T proxy(Class type, InvocationHandler handler) {