Skip to content

armgit / dbx

Public Imported from GitHub
0

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

fix(jdbc): share embedded H2 runtimes with isolated logical sessions

t8y2b57b3873d93a
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<PluginDriverSession> {
+ 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::<serde_json::Value>("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::<serde_json::Value>("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::<serde_json::Value>("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<ConnectionTestResult, String> {
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::<serde_json::Value>(
+ "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<PoolKind, String> {
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::<serde_json::Value>("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<String
client_session_id.map(str::trim).filter(|session| !session.is_empty()).map(|session| session.replace(':', "_"))
}
+fn is_embedded_h2_jdbc(config: &ConnectionConfig) -> 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<String>) -> 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<PluginSidecarSession>,
driver_id: String,
- _activity: lifecycle::PluginUsageGuard,
+ _activity: Option<lifecycle::PluginUsageGuard>,
+ logical: Option<Arc<jdbc_sessions::JdbcLogicalSession>>,
}
impl PluginDriverSession {
@@ -393,7 +401,7 @@ impl PluginDriverSession {
activity: lifecycle::PluginUsageGuard,
) -> Result<Self, String> {
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<T>(&self, method: &str, params: serde_json::Value) -> Result<T, String>
@@ -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<u32> {
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<Mutex<HashMap<String, Weak<JdbcRuntime>>>>);
+
+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<PluginDriverSession>,
+ members: Mutex<(usize, bool)>,
+}
+
+pub(super) struct JdbcLogicalSession {
+ runtime: Arc<JdbcRuntime>,
+ id: String,
+ closed: AtomicBool,
+ operation: Mutex<()>,
+ close_done: tokio::sync::watch::Sender<bool>,
+}
+
+impl PluginRegistry {
+ pub async fn start_shared_jdbc_session_for_connection(
+ &self,
+ runtime_key: &str,
+ env: PluginRuntimeEnv,
+ connection_label: &str,
+ ) -> Result<Arc<PluginDriverSession>, 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::<serde_json::Value>("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<serde_json::Value, _> =
+ 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<T: serde::de::DeserializeOwned>(
+ self: &Arc<Self>,
+ method: &str,
+ mut params: serde_json::Value,
+ timeout: Option<Duration>,
+ ) -> Result<T, String> {
+ 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>) {
+ self.close_in_background();
+ let _ = self.close_done.subscribe().wait_for(|done| *done).await;
+ }
+
+ pub(super) fn close_in_background(self: &Arc<Self>) {
+ 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<serde_json::Value, _> = 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<Arc<JdbcLogicalSession>>);
+
+struct StartupGuard(Option<Arc<PluginDriverSession>>);
+
+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<String, QuerySession> QUERY_SESSIONS = new HashMap<>();
+ private static ClassLoader registeredDriverClassLoader;
+ private static final JdbcConnectionState DEFAULT_CONNECTION_STATE = new JdbcConnectionState();
+ private static final ThreadLocal<JdbcConnectionState> CONNECTION_STATE =
+ ThreadLocal.withInitial(() -> DEFAULT_CONNECTION_STATE);
+ private static final Map<String, JdbcConnectionState> 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<String, QuerySession> 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<String> sessionIds = new ArrayList<>(QUERY_SESSIONS.keySet());
+ List<String> 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<Long> 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<String> 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> PHYSICAL = new CopyOnWriteArrayList<>();
+ final List<String> 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<java.util.concurrent.CompletableFuture<JsonNode>>();
+ 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<Integer> 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<String> 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> T proxy(Class<T> 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> T proxy(Class<T> type, InvocationHandler handler) {