From b6ac1f177b78092e70254f7777c5f37faf134a23 Mon Sep 17 00:00:00 2001 From: t8y2 <1156263951@qq.com> Date: Fri, 29 May 2026 23:29:27 +0800 Subject: [PATCH] refactor(agent): consolidate driver architecture --- crates/dbx-core/src/agent_catalog.rs | 265 +++++++++++++ crates/dbx-core/src/agent_connection.rs | 274 +++++++++++++ crates/dbx-core/src/agent_manager.rs | 104 +++-- crates/dbx-core/src/agent_runtime.rs | 89 +++++ crates/dbx-core/src/agent_service.rs | 359 ++++++++++++++++-- crates/dbx-core/src/connection.rs | 191 +--------- crates/dbx-core/src/database_capabilities.rs | 40 +- crates/dbx-core/src/lib.rs | 3 + crates/dbx-core/tests/agent_service.rs | 107 +++++- .../dbx-core/tests/database_capabilities.rs | 14 +- crates/dbx-web/src/routes/agents.rs | 292 ++------------ src-tauri/src/commands/agents.rs | 326 +--------------- src-tauri/src/commands/connection.rs | 9 +- 13 files changed, 1179 insertions(+), 894 deletions(-) create mode 100644 crates/dbx-core/src/agent_catalog.rs create mode 100644 crates/dbx-core/src/agent_connection.rs create mode 100644 crates/dbx-core/src/agent_runtime.rs diff --git a/crates/dbx-core/src/agent_catalog.rs b/crates/dbx-core/src/agent_catalog.rs new file mode 100644 index 0000000000..56881aac8e --- /dev/null +++ b/crates/dbx-core/src/agent_catalog.rs @@ -0,0 +1,265 @@ +use crate::models::connection::DatabaseType; + +#[derive(Debug, Clone, Copy, PartialEq)] +pub struct AgentCatalogEntry { + pub db_type: DatabaseType, + pub key: &'static str, + pub label: &'static str, + pub store_visible: bool, + pub profiles: &'static [AgentDriverProfile], +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct AgentDriverProfile { + pub profile: &'static str, + pub key: &'static str, + pub label: &'static str, + pub store_visible: bool, +} + +const ORACLE_PROFILES: &[AgentDriverProfile] = + &[AgentDriverProfile { profile: "oracle-10g", key: "oracle-10g", label: "Oracle 10g", store_visible: true }]; + +const AGENT_CATALOG: &[AgentCatalogEntry] = &[ + AgentCatalogEntry { + db_type: DatabaseType::Dameng, + key: "dameng", + label: "达梦 DM8", + store_visible: true, + profiles: &[], + }, + AgentCatalogEntry { + db_type: DatabaseType::Kingbase, + key: "kingbase", + label: "人大金仓 KingbaseES", + store_visible: true, + profiles: &[], + }, + AgentCatalogEntry { + db_type: DatabaseType::Highgo, + key: "highgo", + label: "瀚高 HighGo", + store_visible: true, + profiles: &[], + }, + AgentCatalogEntry { + db_type: DatabaseType::Vastbase, + key: "vastbase", + label: "Vastbase", + store_visible: true, + profiles: &[], + }, + AgentCatalogEntry { + db_type: DatabaseType::Goldendb, + key: "goldendb", + label: "GoldenDB", + store_visible: true, + profiles: &[], + }, + AgentCatalogEntry { + db_type: DatabaseType::Databricks, + key: "databricks", + label: "Databricks SQL", + store_visible: true, + profiles: &[], + }, + AgentCatalogEntry { + db_type: DatabaseType::SapHana, + key: "saphana", + label: "SAP HANA", + store_visible: true, + profiles: &[], + }, + AgentCatalogEntry { + db_type: DatabaseType::Teradata, + key: "teradata", + label: "Teradata", + store_visible: true, + profiles: &[], + }, + AgentCatalogEntry { + db_type: DatabaseType::Vertica, + key: "vertica", + label: "Vertica", + store_visible: true, + profiles: &[], + }, + AgentCatalogEntry { + db_type: DatabaseType::Firebird, + key: "firebird", + label: "Firebird", + store_visible: true, + profiles: &[], + }, + AgentCatalogEntry { + db_type: DatabaseType::Exasol, + key: "exasol", + label: "Exasol", + store_visible: true, + profiles: &[], + }, + AgentCatalogEntry { + db_type: DatabaseType::OceanbaseOracle, + key: "oceanbase-oracle", + label: "OceanBase Oracle Mode", + store_visible: true, + profiles: &[], + }, + AgentCatalogEntry { + db_type: DatabaseType::Gbase, + key: "gbase", + label: "GBase", + store_visible: true, + profiles: &[], + }, + AgentCatalogEntry { + db_type: DatabaseType::Access, + key: "access", + label: "Microsoft Access", + store_visible: true, + profiles: &[], + }, + AgentCatalogEntry { + db_type: DatabaseType::Oracle, + key: "oracle", + label: "Oracle", + store_visible: true, + profiles: ORACLE_PROFILES, + }, + AgentCatalogEntry { db_type: DatabaseType::H2, key: "h2", label: "H2", store_visible: true, profiles: &[] }, + AgentCatalogEntry { + db_type: DatabaseType::Snowflake, + key: "snowflake", + label: "Snowflake", + store_visible: true, + profiles: &[], + }, + AgentCatalogEntry { + db_type: DatabaseType::Trino, + key: "trino", + label: "Trino (Presto)", + store_visible: true, + profiles: &[], + }, + AgentCatalogEntry { + db_type: DatabaseType::Hive, + key: "hive", + label: "Apache Hive", + store_visible: true, + profiles: &[], + }, + AgentCatalogEntry { db_type: DatabaseType::Db2, key: "db2", label: "IBM DB2", store_visible: true, profiles: &[] }, + AgentCatalogEntry { + db_type: DatabaseType::Informix, + key: "informix", + label: "IBM Informix", + store_visible: true, + profiles: &[], + }, + AgentCatalogEntry { + db_type: DatabaseType::Neo4j, + key: "neo4j", + label: "Neo4j", + store_visible: true, + profiles: &[], + }, + AgentCatalogEntry { + db_type: DatabaseType::Cassandra, + key: "cassandra", + label: "Apache Cassandra", + store_visible: true, + profiles: &[], + }, + AgentCatalogEntry { + db_type: DatabaseType::Bigquery, + key: "bigquery", + label: "Google BigQuery", + store_visible: true, + profiles: &[], + }, + AgentCatalogEntry { + db_type: DatabaseType::Kylin, + key: "kylin", + label: "Apache Kylin", + store_visible: true, + profiles: &[], + }, + AgentCatalogEntry { + db_type: DatabaseType::Sundb, + key: "sundb", + label: "SunDB", + store_visible: true, + profiles: &[], + }, + AgentCatalogEntry { + db_type: DatabaseType::Yashandb, + key: "yashandb", + label: "崖山 YashanDB", + store_visible: true, + profiles: &[], + }, + AgentCatalogEntry { + db_type: DatabaseType::Tdengine, + key: "tdengine", + label: "TDengine", + store_visible: true, + profiles: &[], + }, + AgentCatalogEntry { + db_type: DatabaseType::MongoDb, + key: "mongodb", + label: "MongoDB (Legacy)", + store_visible: true, + profiles: &[], + }, + AgentCatalogEntry { + db_type: DatabaseType::Iris, + key: "iris", + label: "InterSystems IRIS", + store_visible: false, + profiles: &[], + }, +]; + +pub fn entries() -> &'static [AgentCatalogEntry] { + AGENT_CATALOG +} + +pub fn agent_key(db_type: &DatabaseType, driver_profile: Option<&str>) -> Option<&'static str> { + let entry = entry_for_db_type(db_type)?; + if let Some(driver_profile) = driver_profile { + if let Some(profile) = entry.profiles.iter().find(|profile| profile.profile == driver_profile) { + return Some(profile.key); + } + } + Some(entry.key) +} + +pub fn is_agent_type(db_type: &DatabaseType) -> bool { + entry_for_db_type(db_type).is_some() +} + +pub fn driver_store_entries() -> impl Iterator { + entries().iter().flat_map(|entry| { + let base = entry.store_visible.then_some((entry.key, entry.label)); + let profiles = + entry.profiles.iter().filter(|profile| profile.store_visible).map(|profile| (profile.key, profile.label)); + base.into_iter().chain(profiles) + }) +} + +pub fn label_for_key(agent_key: &str) -> Option<&'static str> { + for entry in entries() { + if entry.key == agent_key { + return Some(entry.label); + } + if let Some(profile) = entry.profiles.iter().find(|profile| profile.key == agent_key) { + return Some(profile.label); + } + } + None +} + +fn entry_for_db_type(db_type: &DatabaseType) -> Option<&'static AgentCatalogEntry> { + entries().iter().find(|entry| entry.db_type == *db_type) +} diff --git a/crates/dbx-core/src/agent_connection.rs b/crates/dbx-core/src/agent_connection.rs new file mode 100644 index 0000000000..9c0c913fa9 --- /dev/null +++ b/crates/dbx-core/src/agent_connection.rs @@ -0,0 +1,274 @@ +use percent_encoding::{percent_decode_str, utf8_percent_encode, NON_ALPHANUMERIC}; + +use crate::models::connection::{ConnectionConfig, DatabaseType}; + +pub fn agent_connect_params(config: &ConnectionConfig, host: &str, port: u16, database: &str) -> serde_json::Value { + let agent_database = if config.db_type == DatabaseType::MongoDb { + mongo_agent_database(config, database) + } else { + database.to_string() + }; + let connection_string = if config.db_type == DatabaseType::MongoDb { + config.connection_url_with_host(host, port) + } else if config.db_type == DatabaseType::Oracle { + oracle_jdbc_connection_string(config, host, port, database) + } else if matches!(config.db_type, DatabaseType::Kingbase | DatabaseType::Highgo | DatabaseType::Vastbase) { + postgres_like_agent_jdbc_connection_string(config, host, port, database) + } else if config.db_type == DatabaseType::SapHana { + sap_hana_jdbc_connection_string(config, host, port, database) + } else { + config.connection_string.as_deref().unwrap_or("").to_string() + }; + + serde_json::json!({ + "host": host, + "port": port, + "database": agent_database, + "username": config.username, + "password": config.password, + "url_params": config.url_params.as_deref().unwrap_or(""), + "connection_string": connection_string, + }) +} + +fn mongo_agent_database(config: &ConnectionConfig, database: &str) -> String { + if let Some(database) = non_empty_database(database) { + return database.to_string(); + } + if let Some(database) = config.database.as_deref().and_then(non_empty_database) { + return database.to_string(); + } + if let Some(database) = config.connection_string.as_deref().and_then(mongo_uri_database) { + return database; + } + "admin".to_string() +} + +fn non_empty_database(database: &str) -> Option<&str> { + let database = database.trim(); + (!database.is_empty()).then_some(database) +} + +fn mongo_uri_database(uri: &str) -> Option { + let rest = uri.strip_prefix("mongodb://").or_else(|| uri.strip_prefix("mongodb+srv://"))?; + let (_, after_hosts) = rest.split_once('/')?; + let database = after_hosts.split(['?', '#']).next()?.trim(); + if database.is_empty() { + return None; + } + Some(percent_decode_str(database).decode_utf8_lossy().into_owned()) +} + +pub fn mongo_legacy_error_with_auth_hint(err: &str) -> String { + let Some(source_start) = err.find("source='") else { + return err.to_string(); + }; + if !err.contains("Exception authenticating MongoCredential") || err.contains("Current authentication database:") { + return err.to_string(); + } + let source = &err[source_start + "source='".len()..]; + let Some(source_end) = source.find('\'') else { + return err.to_string(); + }; + let source = &source[..source_end]; + format!( + "{err}\n\nCurrent authentication database: {source}. If this user was created in admin, set Authentication database to admin or add authSource=admin to URL params." + ) +} + +fn oracle_jdbc_connection_string(config: &ConnectionConfig, host: &str, port: u16, database: &str) -> String { + let database = database.trim(); + if database.is_empty() { + return config.connection_string.as_deref().unwrap_or("").to_string(); + } + + if config.oracle_connection_type.as_deref() == Some("sid") { + format!("jdbc:oracle:thin:@{host}:{port}:{database}") + } else { + format!("jdbc:oracle:thin:@//{host}:{port}/{database}") + } +} + +fn postgres_like_agent_jdbc_connection_string( + config: &ConnectionConfig, + host: &str, + port: u16, + database: &str, +) -> String { + let scheme = match config.db_type { + DatabaseType::Kingbase => "kingbase8", + DatabaseType::Highgo => "highgo", + DatabaseType::Vastbase => "vastbase", + _ => unreachable!("postgres-like agent JDBC URL requested for {:?}", config.db_type), + }; + let base = format!("jdbc:{scheme}://{host}:{port}/{}", database.trim()); + append_agent_url_params(base, config.url_params.as_deref()) +} + +pub fn should_retry_oracle_with_10g_driver(config: &ConnectionConfig, err: &str) -> bool { + if config.db_type != DatabaseType::Oracle { + return false; + } + if config.driver_profile.as_deref() == Some("oracle-10g") { + return false; + } + let normalized = err.to_lowercase(); + normalized.contains("ora-12541") || normalized.contains("no listener") || err.contains("没有监听程序") +} + +pub fn oracle_alternate_connect_config(config: &ConnectionConfig, err: &str) -> Option { + if !should_retry_oracle_with_10g_driver(config, err) { + return None; + } + + let mut retry = config.clone(); + retry.oracle_connection_type = + Some(if config.oracle_connection_type.as_deref() == Some("sid") { "service_name" } else { "sid" }.to_string()); + Some(retry) +} + +fn sap_hana_jdbc_connection_string(config: &ConnectionConfig, host: &str, port: u16, database: &str) -> String { + let database = database.trim(); + let params = config.url_params.as_deref().unwrap_or("").trim().trim_start_matches('?'); + let has_database_name = params + .split(['&', ';']) + .any(|part| part.split_once('=').map(|(key, _)| key.eq_ignore_ascii_case("databaseName")).unwrap_or(false)); + + let mut query_parts = Vec::new(); + if !database.is_empty() && !has_database_name { + query_parts.push(format!("databaseName={}", utf8_percent_encode(database, NON_ALPHANUMERIC))); + } + if !params.is_empty() { + query_parts.push(params.to_string()); + } + + if query_parts.is_empty() { + format!("jdbc:sap://{host}:{port}") + } else { + format!("jdbc:sap://{host}:{port}/?{}", query_parts.join("&")) + } +} + +fn append_agent_url_params(base: String, params: Option<&str>) -> String { + let params = params.unwrap_or("").trim().trim_start_matches(['?', '&']); + if params.is_empty() { + return base; + } + let separator = if base.contains('?') { '&' } else { '?' }; + format!("{base}{separator}{params}") +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::models::connection::{ + default_connect_timeout_secs, default_query_timeout_secs, default_ssh_connect_timeout_secs, ProxyType, + }; + + fn config(db_type: DatabaseType, database: Option<&str>) -> ConnectionConfig { + ConnectionConfig { + id: "conn".to_string(), + name: "Connection".to_string(), + db_type, + driver_profile: None, + driver_label: None, + url_params: None, + host: "127.0.0.1".to_string(), + port: 3306, + username: "user".to_string(), + password: "secret".to_string(), + database: database.map(str::to_string), + visible_databases: None, + attached_databases: Vec::new(), + color: None, + ssh_enabled: false, + ssh_host: String::new(), + ssh_port: 22, + ssh_user: String::new(), + ssh_password: String::new(), + ssh_key_path: String::new(), + ssh_key_passphrase: String::new(), + ssh_expose_lan: false, + ssh_connect_timeout_secs: default_ssh_connect_timeout_secs(), + connect_timeout_secs: default_connect_timeout_secs(), + query_timeout_secs: default_query_timeout_secs(), + proxy_enabled: false, + proxy_type: ProxyType::Socks5, + proxy_host: String::new(), + proxy_port: 1080, + proxy_username: String::new(), + proxy_password: String::new(), + ssl: false, + ca_cert_path: String::new(), + sysdba: false, + oracle_connection_type: None, + connection_string: None, + redis_connection_mode: None, + redis_sentinel_master: String::new(), + redis_sentinel_nodes: String::new(), + redis_sentinel_username: String::new(), + redis_sentinel_password: String::new(), + redis_sentinel_tls: false, + redis_cluster_nodes: String::new(), + external_config: None, + jdbc_driver_class: None, + jdbc_driver_paths: Vec::new(), + one_time: false, + } + } + + #[test] + fn mongodb_database_falls_back_to_uri_database() { + let mut cfg = config(DatabaseType::MongoDb, None); + cfg.connection_string = Some("mongodb://user:secret@127.0.0.1:27017/app_db?authSource=admin".to_string()); + + let params = agent_connect_params(&cfg, "127.0.0.1", 27017, ""); + + assert_eq!(params["database"], "app_db"); + } + + #[test] + fn mongo_auth_hint_preserves_original_error() { + let err = "Agent RPC error: Exception authenticating MongoCredential{mechanism=SCRAM-SHA-1, userName='rwuser', source='admin'}"; + + let hinted = mongo_legacy_error_with_auth_hint(err); + + assert!(hinted.starts_with(err)); + assert!(hinted.contains("Current authentication database: admin")); + } + + #[test] + fn oracle_url_uses_sid_or_service_name() { + let mut cfg = config(DatabaseType::Oracle, Some("ORCL")); + cfg.oracle_connection_type = Some("sid".to_string()); + + let sid = agent_connect_params(&cfg, "oracle.example.com", 1521, "ORCL"); + assert_eq!(sid["connection_string"], "jdbc:oracle:thin:@oracle.example.com:1521:ORCL"); + + cfg.oracle_connection_type = Some("service_name".to_string()); + let service = agent_connect_params(&cfg, "oracle.example.com", 1521, "ORCL"); + assert_eq!(service["connection_string"], "jdbc:oracle:thin:@//oracle.example.com:1521/ORCL"); + } + + #[test] + fn oracle_listener_errors_can_switch_descriptor() { + let mut cfg = config(DatabaseType::Oracle, Some("ORCL")); + cfg.driver_profile = Some("oracle".to_string()); + cfg.oracle_connection_type = Some("service_name".to_string()); + + let retry = oracle_alternate_connect_config(&cfg, "ORA-12541: TNS:no listener").unwrap(); + + assert_eq!(retry.oracle_connection_type.as_deref(), Some("sid")); + assert!(oracle_alternate_connect_config(&retry, "ORA-01017: invalid username/password").is_none()); + } + + #[test] + fn sap_hana_url_includes_selected_database_and_params() { + let mut cfg = config(DatabaseType::SapHana, Some("TENANT1")); + cfg.url_params = Some("encrypt=true".to_string()); + + let params = agent_connect_params(&cfg, "hana.example.com", 30013, "TENANT1"); + + assert_eq!(params["connection_string"], "jdbc:sap://hana.example.com:30013/?databaseName=TENANT1&encrypt=true"); + } +} diff --git a/crates/dbx-core/src/agent_manager.rs b/crates/dbx-core/src/agent_manager.rs index 12ec8b3a55..d1b66b62b7 100644 --- a/crates/dbx-core/src/agent_manager.rs +++ b/crates/dbx-core/src/agent_manager.rs @@ -4,7 +4,6 @@ use std::path::{Path, PathBuf}; use serde::{Deserialize, Serialize}; use tokio::sync::Mutex; -use crate::database_capabilities; use crate::db::agent_driver::{AgentDriverClient, AgentMethod}; use crate::models::connection::DatabaseType; @@ -121,6 +120,41 @@ mod tests { assert_eq!(resolve_system_java_path(Some(path.as_os_str())).unwrap(), system_java); } + + #[tokio::test] + async fn runtime_gateway_returns_existing_missing_driver_error() { + let manager = test_manager("missing-driver"); + + let err = match manager.spawn(&DatabaseType::H2, None).await { + Ok(_) => panic!("missing driver should fail"), + Err(err) => err, + }; + + assert_eq!(err, "h2 driver is not installed. Please install it from the Driver Manager."); + } + + #[tokio::test] + async fn runtime_gateway_returns_existing_missing_java_error() { + let manager = test_manager("missing-java"); + let jar = manager.driver_jar_path("h2"); + touch(&jar); + + let err = match manager.spawn(&DatabaseType::H2, None).await { + Ok(_) => panic!("missing Java runtime should fail"), + Err(err) => err, + }; + + assert_eq!(err, "JRE 21 runtime is not installed. Please install it from the Driver Manager."); + } + + #[tokio::test] + async fn runtime_gateway_resolves_profile_specific_keys() { + let manager = test_manager("profile-key"); + + assert_eq!(AgentManager::db_type_to_agent_key(&DatabaseType::Oracle, Some("oracle-10g")), Some("oracle-10g")); + assert_eq!(AgentManager::db_type_to_agent_key(&DatabaseType::Oracle, None), Some("oracle")); + manager.stop_daemon_by_key("oracle-10g").await; + } } #[derive(Debug, Clone, Serialize, Deserialize)] @@ -215,7 +249,7 @@ pub struct DriverStoreUsage { pub struct AgentManager { base_dir: PathBuf, app_version: String, - daemons: Mutex>, + pub(crate) daemons: Mutex>, } impl Default for AgentManager { @@ -394,15 +428,19 @@ impl AgentManager { } pub async fn stop_daemons(&self) { - self.daemons.lock().await.clear(); + crate::agent_runtime::stop_daemons(self).await; + } + + pub async fn stop_daemon_by_key(&self, agent_key: &str) { + crate::agent_runtime::stop_daemon_by_key(self, agent_key).await; } pub fn db_type_to_agent_key(db_type: &DatabaseType, driver_profile: Option<&str>) -> Option<&'static str> { - database_capabilities::agent_key(db_type, driver_profile) + crate::agent_runtime::db_type_to_agent_key(db_type, driver_profile) } pub fn is_agent_type(db_type: &DatabaseType) -> bool { - database_capabilities::is_agent_type(db_type) + crate::agent_runtime::is_agent_type(db_type) } pub async fn spawn( @@ -410,21 +448,7 @@ impl AgentManager { db_type: &DatabaseType, driver_profile: Option<&str>, ) -> Result { - let key = Self::db_type_to_agent_key(db_type, driver_profile) - .ok_or_else(|| format!("{:?} is not an agent-driven database type", db_type))?; - - let state = self.load_state(); - let jre_key = state.installed_drivers.get(key).map(|d| d.jre.as_str()).unwrap_or(DEFAULT_JRE_KEY); - - if !self.is_driver_installed(key) { - return Err(format!("{key} driver is not installed. Please install it from the Driver Manager.")); - } - - let java = self.resolve_java_runtime(&state, jre_key)?.to_string_lossy().to_string(); - let jar = self.driver_jar_path(key).to_string_lossy().to_string(); - let mut client = AgentDriverClient::spawn(&java, &jar).await?; - client.try_optional_handshake(self.agent_app_version()).await; - Ok(client) + crate::agent_runtime::spawn_connection_client(self, db_type, driver_profile).await } pub async fn call_daemon( @@ -434,43 +458,7 @@ impl AgentManager { method: &str, params: serde_json::Value, ) -> Result { - let key = Self::db_type_to_agent_key(db_type, driver_profile) - .ok_or_else(|| format!("{:?} is not an agent-driven database type", db_type))? - .to_string(); - - let mut daemons = self.daemons.lock().await; - - if !daemons.contains_key(&key) { - let state = self.load_state(); - let jre_key = state.installed_drivers.get(&key).map(|d| d.jre.as_str()).unwrap_or(DEFAULT_JRE_KEY); - - if !self.is_driver_installed(&key) { - return Err(format!("{key} driver is not installed. Please install it from the Driver Manager.")); - } - let java = self.resolve_java_runtime(&state, jre_key)?.to_string_lossy().to_string(); - let jar = self.driver_jar_path(&key).to_string_lossy().to_string(); - let mut client = AgentDriverClient::spawn(&java, &jar).await?; - client.try_optional_handshake(self.agent_app_version()).await; - daemons.insert(key.clone(), client); - } - - let client = daemons.get_mut(&key).unwrap(); - match client.call::(method, params.clone()).await { - Ok(result) => Ok(result), - Err(e) => { - log::warn!("[agent] daemon call failed, respawning: {e}"); - daemons.remove(&key); - let state = self.load_state(); - let jre_key = state.installed_drivers.get(&key).map(|d| d.jre.as_str()).unwrap_or(DEFAULT_JRE_KEY); - let java = self.resolve_java_runtime(&state, jre_key)?.to_string_lossy().to_string(); - let jar = self.driver_jar_path(&key).to_string_lossy().to_string(); - let mut new_client = AgentDriverClient::spawn(&java, &jar).await?; - new_client.try_optional_handshake(self.agent_app_version()).await; - let result = new_client.call::(method, params).await?; - daemons.insert(key, new_client); - Ok(result) - } - } + crate::agent_runtime::call_daemon(self, db_type, driver_profile, method, params).await } pub async fn call_daemon_method( @@ -480,7 +468,7 @@ impl AgentManager { method: AgentMethod, params: serde_json::Value, ) -> Result { - self.call_daemon(db_type, driver_profile, method.as_str(), params).await + crate::agent_runtime::call_daemon_method(self, db_type, driver_profile, method, params).await } pub async fn download_file(url: &str, dest: &Path) -> Result<(), String> { diff --git a/crates/dbx-core/src/agent_runtime.rs b/crates/dbx-core/src/agent_runtime.rs new file mode 100644 index 0000000000..d55677d372 --- /dev/null +++ b/crates/dbx-core/src/agent_runtime.rs @@ -0,0 +1,89 @@ +use serde::de::DeserializeOwned; + +use crate::agent_manager::{AgentManager, DEFAULT_JRE_KEY}; +use crate::database_capabilities; +use crate::db::agent_driver::{AgentDriverClient, AgentMethod}; +use crate::models::connection::DatabaseType; + +pub fn db_type_to_agent_key(db_type: &DatabaseType, driver_profile: Option<&str>) -> Option<&'static str> { + database_capabilities::agent_key(db_type, driver_profile) +} + +pub fn is_agent_type(db_type: &DatabaseType) -> bool { + database_capabilities::is_agent_type(db_type) +} + +pub async fn stop_daemons(manager: &AgentManager) { + manager.daemons.lock().await.clear(); +} + +pub async fn stop_daemon_by_key(manager: &AgentManager, agent_key: &str) { + manager.daemons.lock().await.remove(agent_key); +} + +pub async fn spawn_connection_client( + manager: &AgentManager, + db_type: &DatabaseType, + driver_profile: Option<&str>, +) -> Result { + let key = db_type_to_agent_key(db_type, driver_profile) + .ok_or_else(|| format!("{:?} is not an agent-driven database type", db_type))?; + spawn_client_for_key(manager, key).await +} + +pub async fn call_daemon( + manager: &AgentManager, + db_type: &DatabaseType, + driver_profile: Option<&str>, + method: &str, + params: serde_json::Value, +) -> Result { + let key = db_type_to_agent_key(db_type, driver_profile) + .ok_or_else(|| format!("{:?} is not an agent-driven database type", db_type))? + .to_string(); + + let mut daemons = manager.daemons.lock().await; + + if !daemons.contains_key(&key) { + let client = spawn_client_for_key(manager, &key).await?; + daemons.insert(key.clone(), client); + } + + let client = daemons.get_mut(&key).unwrap(); + match client.call::(method, params.clone()).await { + Ok(result) => Ok(result), + Err(err) => { + log::warn!("[agent] daemon call failed, respawning: {err}"); + daemons.remove(&key); + let mut new_client = spawn_client_for_key(manager, &key).await?; + let result = new_client.call::(method, params).await?; + daemons.insert(key, new_client); + Ok(result) + } + } +} + +pub async fn call_daemon_method( + manager: &AgentManager, + db_type: &DatabaseType, + driver_profile: Option<&str>, + method: AgentMethod, + params: serde_json::Value, +) -> Result { + call_daemon(manager, db_type, driver_profile, method.as_str(), params).await +} + +async fn spawn_client_for_key(manager: &AgentManager, key: &str) -> Result { + let state = manager.load_state(); + let jre_key = state.installed_drivers.get(key).map(|driver| driver.jre.as_str()).unwrap_or(DEFAULT_JRE_KEY); + + if !manager.is_driver_installed(key) { + return Err(format!("{key} driver is not installed. Please install it from the Driver Manager.")); + } + + let java = manager.resolve_java_runtime(&state, jre_key)?.to_string_lossy().to_string(); + let jar = manager.driver_jar_path(key).to_string_lossy().to_string(); + let mut client = AgentDriverClient::spawn(&java, &jar).await?; + client.try_optional_handshake(manager.agent_app_version()).await; + Ok(client) +} diff --git a/crates/dbx-core/src/agent_service.rs b/crates/dbx-core/src/agent_service.rs index bd5069938a..67fa2f4676 100644 --- a/crates/dbx-core/src/agent_service.rs +++ b/crates/dbx-core/src/agent_service.rs @@ -1,6 +1,7 @@ use std::io::Read; use std::path::{Path, PathBuf}; +use crate::agent_catalog; use crate::agent_manager::{ AgentDriverInfo, AgentManager, AgentRegistry, InstalledDriver, JavaRuntimeMode, DEFAULT_JRE_KEY, }; @@ -11,47 +12,45 @@ const REGISTRY_R2_PATH: &str = "agents/agent-registry.json"; static REGISTRY_CACHE: std::sync::LazyLock>> = std::sync::LazyLock::new(|| tokio::sync::Mutex::new(None)); -pub const AGENT_TYPES: &[(&str, &str)] = &[ - ("dameng", "达梦 DM8"), - ("kingbase", "人大金仓 KingbaseES"), - ("highgo", "瀚高 HighGo"), - ("vastbase", "Vastbase"), - ("goldendb", "GoldenDB"), - ("databricks", "Databricks SQL"), - ("saphana", "SAP HANA"), - ("teradata", "Teradata"), - ("vertica", "Vertica"), - ("firebird", "Firebird"), - ("exasol", "Exasol"), - ("oceanbase-oracle", "OceanBase Oracle Mode"), - ("gbase", "GBase"), - ("access", "Microsoft Access"), - ("oracle", "Oracle"), - ("oracle-10g", "Oracle 10g"), - ("h2", "H2"), - ("snowflake", "Snowflake"), - ("trino", "Trino (Presto)"), - ("hive", "Apache Hive"), - ("db2", "IBM DB2"), - ("informix", "IBM Informix"), - ("neo4j", "Neo4j"), - ("cassandra", "Apache Cassandra"), - ("bigquery", "Google BigQuery"), - ("kylin", "Apache Kylin"), - ("sundb", "SunDB"), - ("yashandb", "崖山 YashanDB"), - ("tdengine", "TDengine"), - ("mongodb", "MongoDB (Legacy)"), -]; +#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, PartialEq, Eq)] +pub struct AgentProgressEvent { + pub step: String, + #[serde(skip_serializing_if = "Option::is_none")] + pub downloaded: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub total: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub db_type: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub current: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub total_drivers: Option, +} + +impl AgentProgressEvent { + pub fn step(step: impl Into) -> Self { + Self { step: step.into(), downloaded: None, total: None, db_type: None, current: None, total_drivers: None } + } + + pub fn transfer(step: impl Into, downloaded: u64, total: u64) -> Self { + Self { downloaded: Some(downloaded), total: Some(total), ..Self::step(step) } + } + + pub fn with_batch(mut self, db_type: Option<&str>, current: Option, total_drivers: Option) -> Self { + self.db_type = db_type.map(ToString::to_string); + self.current = current; + self.total_drivers = total_drivers; + self + } +} pub fn build_agent_list(am: &AgentManager, registry: Option<&AgentRegistry>) -> Vec { let local_state = am.load_state(); - AGENT_TYPES - .iter() + agent_catalog::driver_store_entries() .map(|(key, label)| { let installed = am.is_driver_installed(key); - let local = local_state.installed_drivers.get(*key); - let remote = registry.and_then(|r| r.drivers.get(*key)); + let local = local_state.installed_drivers.get(key); + let remote = registry.and_then(|r| r.drivers.get(key)); let jre_key = remote .map(|r| r.jre.clone()) .or_else(|| local.map(|l| l.jre.clone())) @@ -144,6 +143,288 @@ pub async fn invalidate_registry_cache() { *REGISTRY_CACHE.lock().await = None; } +pub async fn install_agent_driver( + am: &AgentManager, + db_type: &str, + progress: impl Fn(AgentProgressEvent), +) -> Result<(), String> { + install_agent_driver_with_batch(am, db_type, &progress, None, None).await +} + +pub async fn upgrade_all_agent_drivers( + am: &AgentManager, + progress: impl Fn(AgentProgressEvent), +) -> Result { + let registry = fetch_registry().await?; + let agents = build_agent_list(am, Some(®istry)); + let updatable: Vec<&AgentDriverInfo> = agents.iter().filter(|agent| agent.update_available).collect(); + let total = updatable.len() as u32; + + for (index, agent) in updatable.iter().enumerate() { + install_agent_driver_from_registry( + am, + ®istry, + &agent.db_type, + &progress, + Some((index + 1) as u32), + Some(total), + ) + .await?; + } + + progress(AgentProgressEvent::step("all-done")); + Ok(total) +} + +pub async fn uninstall_agent_driver(am: &AgentManager, db_type: &str) -> Result<(), String> { + let jar_path = am.driver_jar_path(db_type); + if jar_path.exists() { + std::fs::remove_file(&jar_path).map_err(|err| err.to_string())?; + } + if let Some(driver_dir) = jar_path.parent() { + if driver_dir.exists() { + std::fs::remove_dir_all(driver_dir).map_err(|err| err.to_string())?; + } + } + let mut local_state = am.load_state(); + local_state.installed_drivers.remove(db_type); + am.save_state(&local_state)?; + am.stop_daemon_by_key(db_type).await; + Ok(()) +} + +pub async fn uninstall_agent_jre(am: &AgentManager, jre_key: &str) -> Result<(), String> { + let local_state = am.load_state(); + let dependents: Vec<&str> = local_state + .installed_drivers + .iter() + .filter(|(_, driver)| driver.jre == jre_key) + .map(|(k, _)| k.as_str()) + .collect(); + if !dependents.is_empty() { + return Err(format!("JRE {} 正在被以下驱动使用: {},请先卸载这些驱动", jre_key, dependents.join(", "))); + } + let jre_dir = am.jre_dir(jre_key); + if jre_dir.exists() { + std::fs::remove_dir_all(&jre_dir).map_err(|err| format!("Failed to remove JRE: {err}"))?; + } + let mut local_state = am.load_state(); + local_state.jre_versions.remove(jre_key); + am.save_state(&local_state)?; + am.stop_daemons().await; + Ok(()) +} + +pub async fn reinstall_agent_jre( + am: &AgentManager, + jre_key: &str, + progress: impl Fn(AgentProgressEvent), +) -> Result<(), String> { + let registry = fetch_registry().await?; + let jre_info = registry.resolve_jre(jre_key).ok_or_else(|| format!("No JRE definition for version: {jre_key}"))?; + let platform = AgentManager::current_platform(); + let platform_jre = jre_info + .platforms + .get(platform) + .ok_or_else(|| format!("No JRE {jre_key} available for platform: {platform}"))?; + let jre_archive = am.base_dir().join("jre-download.tar.gz"); + download_with_progress( + &progress, + "jre", + &platform_jre.url, + &github_url_to_r2_path(&platform_jre.url, "jre"), + &jre_archive, + platform_jre.size, + None, + None, + None, + ) + .await?; + let jre_dir = am.jre_dir(jre_key); + if jre_dir.exists() { + std::fs::remove_dir_all(&jre_dir).map_err(|err| format!("Failed to remove old JRE: {err}"))?; + } + extract_tar_gz(&jre_archive, &jre_dir)?; + std::fs::remove_file(&jre_archive).ok(); + let mut local_state = am.load_state(); + local_state.jre_versions.insert(jre_key.to_string(), jre_info.version.clone()); + am.save_state(&local_state)?; + am.stop_daemons().await; + progress(AgentProgressEvent::step("done")); + Ok(()) +} + +pub fn import_agents_from_zip( + am: &AgentManager, + zip_path: &Path, + progress: impl Fn(AgentProgressEvent), +) -> Result { + import_offline_zip(am, zip_path, |p| { + progress(AgentProgressEvent { + step: p.step, + downloaded: Some(p.current as u64), + total: Some(p.total as u64), + db_type: Some(p.label), + current: Some(p.current), + total_drivers: Some(p.total), + }); + }) +} + +async fn install_agent_driver_with_batch( + am: &AgentManager, + db_type: &str, + progress: &impl Fn(AgentProgressEvent), + current: Option, + total_drivers: Option, +) -> Result<(), String> { + match fetch_registry().await { + Ok(registry) => { + install_agent_driver_from_registry(am, ®istry, db_type, progress, current, total_drivers).await + } + Err(registry_err) => { + if let Some(local_jar) = find_local_agent_jar(db_type) { + install_local_agent(am, db_type, local_jar)?; + am.stop_daemon_by_key(db_type).await; + progress(AgentProgressEvent::step("done")); + return Ok(()); + } + Err(registry_err) + } + } +} + +async fn install_agent_driver_from_registry( + am: &AgentManager, + registry: &AgentRegistry, + db_type: &str, + progress: &impl Fn(AgentProgressEvent), + current: Option, + total_drivers: Option, +) -> Result<(), String> { + let Some(driver) = registry.drivers.get(db_type) else { + if let Some(local_jar) = find_local_agent_jar(db_type) { + install_local_agent(am, db_type, local_jar)?; + am.stop_daemon_by_key(db_type).await; + progress(AgentProgressEvent::step("done")); + return Ok(()); + } + return Err(format!("Unknown driver type: {db_type}")); + }; + let jre_key = &driver.jre; + let needs_jre = jre_needs_install(am, registry, jre_key); + + if needs_jre { + let jre_info = + registry.resolve_jre(jre_key).ok_or_else(|| format!("No JRE definition for version: {jre_key}"))?; + let platform = AgentManager::current_platform(); + let platform_jre = jre_info + .platforms + .get(platform) + .ok_or_else(|| format!("No JRE {jre_key} available for platform: {platform}"))?; + let jre_archive = am.base_dir().join("jre-download.tar.gz"); + progress(AgentProgressEvent::transfer("jre", 0, platform_jre.size).with_batch( + Some(db_type), + current, + total_drivers, + )); + download_with_progress( + progress, + "jre", + &platform_jre.url, + &github_url_to_r2_path(&platform_jre.url, "jre"), + &jre_archive, + platform_jre.size, + Some(db_type), + current, + total_drivers, + ) + .await?; + progress(AgentProgressEvent::transfer("jre-extract", 0, 0).with_batch(Some(db_type), current, total_drivers)); + let jre_dir = am.jre_dir(jre_key); + if jre_dir.exists() { + std::fs::remove_dir_all(&jre_dir).map_err(|err| format!("Failed to remove old JRE: {err}"))?; + } + extract_tar_gz(&jre_archive, &jre_dir)?; + std::fs::remove_file(&jre_archive).ok(); + } + + let jar_path = am.driver_jar_path(db_type); + progress(AgentProgressEvent::transfer("driver", 0, driver.jar.size).with_batch( + Some(db_type), + current, + total_drivers, + )); + download_with_progress( + progress, + "driver", + &driver.jar.url, + &github_url_to_r2_path(&driver.jar.url, "driver"), + &jar_path, + driver.jar.size, + Some(db_type), + current, + total_drivers, + ) + .await?; + + let mut local_state = am.load_state(); + if let Some(jre_info) = registry.resolve_jre(jre_key) { + local_state.jre_versions.insert(jre_key.clone(), jre_info.version.clone()); + } + local_state.installed_drivers.insert( + db_type.to_string(), + InstalledDriver { + version: driver.version.clone(), + installed_at: chrono::Utc::now().to_rfc3339(), + jre: jre_key.clone(), + }, + ); + am.save_state(&local_state)?; + am.stop_daemon_by_key(db_type).await; + progress(AgentProgressEvent::step("done")); + Ok(()) +} + +async fn download_with_progress( + progress: &impl Fn(AgentProgressEvent), + step: &str, + url: &str, + r2_path: &str, + dest: &std::path::Path, + total_size: u64, + db_type: Option<&str>, + current: Option, + total_drivers: Option, +) -> Result<(), String> { + if let Some(parent) = dest.parent() { + std::fs::create_dir_all(parent).map_err(|err| err.to_string())?; + } + let tmp = download_temp_path(dest); + let client = reqwest::Client::builder() + .timeout(std::time::Duration::from_secs(300)) + .build() + .map_err(|err| format!("Failed to create HTTP client: {err}"))?; + let mut resp = crate::race_download(&client, url, r2_path, "dbx-agent-manager") + .await + .map_err(|err| format!("Failed to download {url}: {err}"))?; + let content_length = resp.content_length().unwrap_or(total_size); + let mut file = std::fs::File::create(&tmp).map_err(|err| format!("Failed to create temp file: {err}"))?; + let mut downloaded = 0; + while let Some(chunk) = resp.chunk().await.map_err(|err| format!("Download stream error: {err}"))? { + std::io::Write::write_all(&mut file, &chunk).map_err(|err| format!("Failed to write chunk: {err}"))?; + downloaded += chunk.len() as u64; + progress(AgentProgressEvent::transfer(step, downloaded, content_length).with_batch( + db_type, + current, + total_drivers, + )); + } + std::io::Write::flush(&mut file).map_err(|err| format!("Failed to flush temp file: {err}"))?; + drop(file); + replace_download(&tmp, dest) +} + pub fn github_url_to_r2_path(github_url: &str, category: &str) -> String { let filename = github_url.rsplit('/').next().unwrap_or(github_url); match category { @@ -314,11 +595,7 @@ pub fn import_offline_zip( step: "driver".into(), current, total, - label: AGENT_TYPES - .iter() - .find(|(k, _)| *k == db_type) - .map(|(_, l)| l.to_string()) - .unwrap_or_else(|| db_type.clone()), + label: agent_catalog::label_for_key(db_type).unwrap_or(db_type).to_string(), }); let jar_path = am.driver_jar_path(db_type); diff --git a/crates/dbx-core/src/connection.rs b/crates/dbx-core/src/connection.rs index e7eb39ed03..5f7437e130 100644 --- a/crates/dbx-core/src/connection.rs +++ b/crates/dbx-core/src/connection.rs @@ -1,4 +1,3 @@ -use percent_encoding::{percent_decode_str, utf8_percent_encode, NON_ALPHANUMERIC}; use std::collections::HashMap; use std::path::PathBuf; use std::sync::Arc; @@ -7,6 +6,10 @@ use tokio::sync::RwLock; use mysql_async::prelude::Queryable; use mysql_async::Row as MysqlRow; +use crate::agent_connection::{ + agent_connect_params, mongo_legacy_error_with_auth_hint, oracle_alternate_connect_config, + should_retry_oracle_with_10g_driver, +}; use crate::database_capabilities; use crate::db; use crate::db::agent_driver::AgentMethod; @@ -769,162 +772,6 @@ fn native_postgres_url_config(config: &ConnectionConfig) -> Option serde_json::Value { - let agent_database = if config.db_type == DatabaseType::MongoDb { - mongo_agent_database(config, database) - } else { - database.to_string() - }; - let connection_string = if config.db_type == DatabaseType::MongoDb { - config.connection_url_with_host(host, port) - } else if config.db_type == DatabaseType::Oracle { - oracle_jdbc_connection_string(config, host, port, database) - } else if matches!(config.db_type, DatabaseType::Kingbase | DatabaseType::Highgo | DatabaseType::Vastbase) { - postgres_like_agent_jdbc_connection_string(config, host, port, database) - } else if config.db_type == DatabaseType::SapHana { - sap_hana_jdbc_connection_string(config, host, port, database) - } else { - config.connection_string.as_deref().unwrap_or("").to_string() - }; - - serde_json::json!({ - "host": host, - "port": port, - "database": agent_database, - "username": config.username, - "password": config.password, - "url_params": config.url_params.as_deref().unwrap_or(""), - "connection_string": connection_string, - }) -} - -fn mongo_agent_database(config: &ConnectionConfig, database: &str) -> String { - if let Some(database) = non_empty_database(database) { - return database.to_string(); - } - if let Some(database) = config.database.as_deref().and_then(non_empty_database) { - return database.to_string(); - } - if let Some(database) = config.connection_string.as_deref().and_then(mongo_uri_database) { - return database; - } - "admin".to_string() -} - -fn non_empty_database(database: &str) -> Option<&str> { - let database = database.trim(); - (!database.is_empty()).then_some(database) -} - -fn mongo_uri_database(uri: &str) -> Option { - let rest = uri.strip_prefix("mongodb://").or_else(|| uri.strip_prefix("mongodb+srv://"))?; - let (_, after_hosts) = rest.split_once('/')?; - let database = after_hosts.split(['?', '#']).next()?.trim(); - if database.is_empty() { - return None; - } - Some(percent_decode_str(database).decode_utf8_lossy().into_owned()) -} - -pub fn mongo_legacy_error_with_auth_hint(err: &str) -> String { - let Some(source_start) = err.find("source='") else { - return err.to_string(); - }; - if !err.contains("Exception authenticating MongoCredential") || err.contains("Current authentication database:") { - return err.to_string(); - } - let source = &err[source_start + "source='".len()..]; - let Some(source_end) = source.find('\'') else { - return err.to_string(); - }; - let source = &source[..source_end]; - format!( - "{err}\n\nCurrent authentication database: {source}. If this user was created in admin, set Authentication database to admin or add authSource=admin to URL params." - ) -} - -fn oracle_jdbc_connection_string(config: &ConnectionConfig, host: &str, port: u16, database: &str) -> String { - let database = database.trim(); - if database.is_empty() { - return config.connection_string.as_deref().unwrap_or("").to_string(); - } - - if config.oracle_connection_type.as_deref() == Some("sid") { - format!("jdbc:oracle:thin:@{host}:{port}:{database}") - } else { - format!("jdbc:oracle:thin:@//{host}:{port}/{database}") - } -} - -fn postgres_like_agent_jdbc_connection_string( - config: &ConnectionConfig, - host: &str, - port: u16, - database: &str, -) -> String { - let scheme = match config.db_type { - DatabaseType::Kingbase => "kingbase8", - DatabaseType::Highgo => "highgo", - DatabaseType::Vastbase => "vastbase", - _ => unreachable!("postgres-like agent JDBC URL requested for {:?}", config.db_type), - }; - let base = format!("jdbc:{scheme}://{host}:{port}/{}", database.trim()); - append_agent_url_params(base, config.url_params.as_deref()) -} - -pub fn should_retry_oracle_with_10g_driver(config: &ConnectionConfig, err: &str) -> bool { - if config.db_type != DatabaseType::Oracle { - return false; - } - if config.driver_profile.as_deref() == Some("oracle-10g") { - return false; - } - let normalized = err.to_lowercase(); - normalized.contains("ora-12541") || normalized.contains("no listener") || err.contains("没有监听程序") -} - -pub fn oracle_alternate_connect_config(config: &ConnectionConfig, err: &str) -> Option { - if !should_retry_oracle_with_10g_driver(config, err) { - return None; - } - - let mut retry = config.clone(); - retry.oracle_connection_type = - Some(if config.oracle_connection_type.as_deref() == Some("sid") { "service_name" } else { "sid" }.to_string()); - Some(retry) -} - -fn sap_hana_jdbc_connection_string(config: &ConnectionConfig, host: &str, port: u16, database: &str) -> String { - let database = database.trim(); - let params = config.url_params.as_deref().unwrap_or("").trim().trim_start_matches('?'); - let has_database_name = params - .split(['&', ';']) - .any(|part| part.split_once('=').map(|(key, _)| key.eq_ignore_ascii_case("databaseName")).unwrap_or(false)); - - let mut query_parts = Vec::new(); - if !database.is_empty() && !has_database_name { - query_parts.push(format!("databaseName={}", utf8_percent_encode(database, NON_ALPHANUMERIC))); - } - if !params.is_empty() { - query_parts.push(params.to_string()); - } - - if query_parts.is_empty() { - format!("jdbc:sap://{host}:{port}") - } else { - format!("jdbc:sap://{host}:{port}/?{}", query_parts.join("&")) - } -} - -fn append_agent_url_params(base: String, params: Option<&str>) -> String { - let params = params.unwrap_or("").trim().trim_start_matches(['?', '&']); - if params.is_empty() { - return base; - } - let separator = if base.contains('?') { '&' } else { '?' }; - format!("{base}{separator}{params}") -} - fn duckdb_paths_match(left: &str, right: &str) -> bool { let left = expand_tilde(left); let right = expand_tilde(right); @@ -1004,9 +851,13 @@ async fn detect_ob_oracle_mode(config: &ConnectionConfig, pool: &db::mysql::MySq #[cfg(test)] mod tests { use super::{ - agent_connect_params, connection_url_for_endpoint, database_connection_config, metadata_connection_config, + connection_url_for_endpoint, database_connection_config, metadata_connection_config, redacted_connection_url_for_endpoint, uses_tcp_probe, AppState, PoolKind, }; + use crate::agent_connection::{ + agent_connect_params, mongo_legacy_error_with_auth_hint, oracle_alternate_connect_config, + should_retry_oracle_with_10g_driver, + }; use crate::db; use crate::models::connection::{default_connect_timeout_secs, ConnectionConfig, DatabaseType, ProxyType}; use crate::schema; @@ -1113,7 +964,7 @@ mod tests { let err = "Agent RPC error: Exception authenticating MongoCredential{mechanism=SCRAM-SHA-1, userName='rwuser', source='gray_lite_twin_fat'}"; assert_eq!( - super::mongo_legacy_error_with_auth_hint(err), + mongo_legacy_error_with_auth_hint(err), "Agent RPC error: Exception authenticating MongoCredential{mechanism=SCRAM-SHA-1, userName='rwuser', source='gray_lite_twin_fat'}\n\nCurrent authentication database: gray_lite_twin_fat. If this user was created in admin, set Authentication database to admin or add authSource=admin to URL params." ); } @@ -1205,20 +1056,14 @@ mod tests { config.db_type = DatabaseType::Oracle; config.driver_profile = Some("oracle".to_string()); - assert!(super::should_retry_oracle_with_10g_driver( - &config, - "Agent RPC error (-1): ORA-12541: TNS:no listener" - )); - assert!(super::should_retry_oracle_with_10g_driver(&config, "host xxx port 1521 中没有监听程序")); + assert!(should_retry_oracle_with_10g_driver(&config, "Agent RPC error (-1): ORA-12541: TNS:no listener")); + assert!(should_retry_oracle_with_10g_driver(&config, "host xxx port 1521 中没有监听程序")); config.driver_profile = Some("oracle-10g".to_string()); - assert!(!super::should_retry_oracle_with_10g_driver( - &config, - "Agent RPC error (-1): ORA-12541: TNS:no listener" - )); + assert!(!should_retry_oracle_with_10g_driver(&config, "Agent RPC error (-1): ORA-12541: TNS:no listener")); config.driver_profile = Some("oracle".to_string()); - assert!(!super::should_retry_oracle_with_10g_driver( + assert!(!should_retry_oracle_with_10g_driver( &config, "Agent RPC error (-1): ORA-01017: invalid username/password" )); @@ -1231,12 +1076,12 @@ mod tests { config.driver_profile = Some("oracle".to_string()); config.oracle_connection_type = Some("service_name".to_string()); - let retry = super::oracle_alternate_connect_config(&config, "Agent RPC error (-1): ORA-12541: TNS:no listener") + let retry = oracle_alternate_connect_config(&config, "Agent RPC error (-1): ORA-12541: TNS:no listener") .expect("listener errors should allow alternate descriptor retry"); assert_eq!(retry.driver_profile.as_deref(), Some("oracle")); assert_eq!(retry.oracle_connection_type.as_deref(), Some("sid")); - let service_retry = super::oracle_alternate_connect_config( + let service_retry = oracle_alternate_connect_config( &retry, "Agent RPC error (-1): ORA-12541: host xxx port 1521 中没有监听程序", ) @@ -1250,10 +1095,10 @@ mod tests { config.db_type = DatabaseType::Oracle; config.driver_profile = Some("oracle".to_string()); - assert!(super::oracle_alternate_connect_config(&config, "ORA-01017: invalid username/password").is_none()); + assert!(oracle_alternate_connect_config(&config, "ORA-01017: invalid username/password").is_none()); config.driver_profile = Some("oracle-10g".to_string()); - assert!(super::oracle_alternate_connect_config(&config, "ORA-12541: TNS:no listener").is_none()); + assert!(oracle_alternate_connect_config(&config, "ORA-12541: TNS:no listener").is_none()); } #[test] diff --git a/crates/dbx-core/src/database_capabilities.rs b/crates/dbx-core/src/database_capabilities.rs index e4b3185f7c..d982647d96 100644 --- a/crates/dbx-core/src/database_capabilities.rs +++ b/crates/dbx-core/src/database_capabilities.rs @@ -1,46 +1,12 @@ +use crate::agent_catalog; use crate::models::connection::DatabaseType; pub fn agent_key(db_type: &DatabaseType, driver_profile: Option<&str>) -> Option<&'static str> { - match db_type { - DatabaseType::Dameng => Some("dameng"), - DatabaseType::Kingbase => Some("kingbase"), - DatabaseType::Highgo => Some("highgo"), - DatabaseType::Vastbase => Some("vastbase"), - DatabaseType::Goldendb => Some("goldendb"), - DatabaseType::Yashandb => Some("yashandb"), - DatabaseType::Databricks => Some("databricks"), - DatabaseType::SapHana => Some("saphana"), - DatabaseType::Teradata => Some("teradata"), - DatabaseType::Vertica => Some("vertica"), - DatabaseType::Firebird => Some("firebird"), - DatabaseType::Exasol => Some("exasol"), - DatabaseType::OceanbaseOracle => Some("oceanbase-oracle"), - DatabaseType::Gbase => Some("gbase"), - DatabaseType::Oracle => match driver_profile { - Some("oracle-10g") => Some("oracle-10g"), - _ => Some("oracle"), - }, - DatabaseType::H2 => Some("h2"), - DatabaseType::Snowflake => Some("snowflake"), - DatabaseType::Trino => Some("trino"), - DatabaseType::Hive => Some("hive"), - DatabaseType::Db2 => Some("db2"), - DatabaseType::Informix => Some("informix"), - DatabaseType::Neo4j => Some("neo4j"), - DatabaseType::Cassandra => Some("cassandra"), - DatabaseType::Bigquery => Some("bigquery"), - DatabaseType::Kylin => Some("kylin"), - DatabaseType::Sundb => Some("sundb"), - DatabaseType::MongoDb => Some("mongodb"), - DatabaseType::Tdengine => Some("tdengine"), - DatabaseType::Iris => Some("iris"), - DatabaseType::Access => Some("access"), - _ => None, - } + agent_catalog::agent_key(db_type, driver_profile) } pub fn is_agent_type(db_type: &DatabaseType) -> bool { - agent_key(db_type, None).is_some() + agent_catalog::is_agent_type(db_type) } pub fn is_single_connection_pool(db_type: &DatabaseType) -> bool { diff --git a/crates/dbx-core/src/lib.rs b/crates/dbx-core/src/lib.rs index 6b95d0c237..ffe6263d35 100644 --- a/crates/dbx-core/src/lib.rs +++ b/crates/dbx-core/src/lib.rs @@ -1,4 +1,7 @@ +pub mod agent_catalog; +pub mod agent_connection; pub mod agent_manager; +pub mod agent_runtime; pub mod agent_service; pub mod ai; pub mod cloud_sync; diff --git a/crates/dbx-core/tests/agent_service.rs b/crates/dbx-core/tests/agent_service.rs index e1af38c9dd..15d77fe086 100644 --- a/crates/dbx-core/tests/agent_service.rs +++ b/crates/dbx-core/tests/agent_service.rs @@ -1,8 +1,10 @@ use dbx_core::agent_manager::{ AgentManager, AgentRegistry, ArtifactInfo, DriverInfo, InstalledDriver, JreInfo, DEFAULT_JRE_KEY, }; -use dbx_core::agent_service::{build_agent_list, github_url_to_r2_path, jre_needs_install, local_agent_jar_candidates}; -use dbx_core::agent_service::{is_app_version_compatible, replace_download}; +use dbx_core::agent_service::{ + build_agent_list, github_url_to_r2_path, import_agent_jar, import_agents_from_zip, is_app_version_compatible, + jre_needs_install, local_agent_jar_candidates, replace_download, uninstall_agent_driver, AgentProgressEvent, +}; fn test_manager(name: &str) -> AgentManager { let dir = std::env::temp_dir().join(format!("dbx-agent-service-{name}-{}", uuid::Uuid::new_v4())); @@ -173,3 +175,104 @@ fn atomic_replace_moves_download_into_place() { assert!(!tmp.exists()); std::fs::remove_dir_all(dir).ok(); } + +#[test] +fn agent_progress_event_serializes_backward_compatible_fields() { + let event = AgentProgressEvent::transfer("driver", 512, 1024).with_batch(Some("h2"), Some(1), Some(2)); + + let value = serde_json::to_value(event).unwrap(); + + assert_eq!(value["step"], "driver"); + assert_eq!(value["downloaded"], 512); + assert_eq!(value["total"], 1024); + assert_eq!(value["db_type"], "h2"); + assert_eq!(value["current"], 1); + assert_eq!(value["total_drivers"], 2); +} + +#[test] +fn local_jar_import_updates_driver_state() { + let manager = test_manager("local-import"); + let source = test_path("local-import-source").join("dbx-agent-h2.jar"); + std::fs::create_dir_all(source.parent().unwrap()).unwrap(); + std::fs::write(&source, b"jar").unwrap(); + + import_agent_jar(&manager, "h2", &source).unwrap(); + + assert_eq!(std::fs::read(manager.driver_jar_path("h2")).unwrap(), b"jar"); + let state = manager.load_state(); + let installed = state.installed_drivers.get("h2").unwrap(); + assert_eq!(installed.version, "0.1.0-local"); + assert_eq!(installed.jre, DEFAULT_JRE_KEY); +} + +#[tokio::test] +async fn uninstall_driver_removes_artifact_and_state() { + let manager = test_manager("uninstall"); + let jar_path = manager.driver_jar_path("h2"); + std::fs::create_dir_all(jar_path.parent().unwrap()).unwrap(); + std::fs::write(&jar_path, b"jar").unwrap(); + manager + .save_state(&dbx_core::agent_manager::AgentState { + installed_drivers: [( + "h2".to_string(), + InstalledDriver { + version: "0.1.0".to_string(), + installed_at: "2026-05-18T00:00:00Z".to_string(), + jre: DEFAULT_JRE_KEY.to_string(), + }, + )] + .into_iter() + .collect(), + ..Default::default() + }) + .unwrap(); + + uninstall_agent_driver(&manager, "h2").await.unwrap(); + + assert!(!jar_path.exists()); + assert!(!manager.load_state().installed_drivers.contains_key("h2")); +} + +#[test] +fn offline_zip_import_emits_progress_and_updates_state() { + let manager = test_manager("offline-progress"); + let zip_path = test_path("offline-progress-zip").join("agents.zip"); + std::fs::create_dir_all(zip_path.parent().unwrap()).unwrap(); + write_offline_driver_zip(&zip_path, "h2", "0.2.0"); + let events = std::sync::Mutex::new(Vec::new()); + + let result = import_agents_from_zip(&manager, &zip_path, |event| { + events.lock().unwrap().push(event); + }) + .unwrap(); + + assert_eq!(result.drivers_installed, vec!["h2"]); + assert_eq!(std::fs::read(manager.driver_jar_path("h2")).unwrap(), b"jar"); + assert_eq!(manager.load_state().installed_drivers.get("h2").unwrap().version, "0.2.0"); + let events = events.lock().unwrap(); + assert!(events.iter().any(|event| event.step == "driver" && event.db_type.as_deref() == Some("H2"))); +} + +fn write_offline_driver_zip(path: &std::path::Path, db_type: &str, version: &str) { + let file = std::fs::File::create(path).unwrap(); + let mut zip = zip::ZipWriter::new(file); + let options = zip::write::SimpleFileOptions::default().compression_method(zip::CompressionMethod::Stored); + let registry = serde_json::json!({ + "drivers": { + db_type: { + "version": version, + "label": db_type, + "min_app_version": "0.1.0", + "jre": DEFAULT_JRE_KEY, + "jar": { "url": format!("https://example.com/dbx-agent-{db_type}.jar"), "size": 3 } + } + } + }); + + zip.start_file("agent-registry.json", options).unwrap(); + std::io::Write::write_all(&mut zip, registry.to_string().as_bytes()).unwrap(); + zip.start_file(format!("drivers/dbx-agent-{db_type}.jar"), options).unwrap(); + std::io::Write::write_all(&mut zip, b"jar").unwrap(); + zip.finish().unwrap(); +} diff --git a/crates/dbx-core/tests/database_capabilities.rs b/crates/dbx-core/tests/database_capabilities.rs index e87a475408..8e854b5894 100644 --- a/crates/dbx-core/tests/database_capabilities.rs +++ b/crates/dbx-core/tests/database_capabilities.rs @@ -1,4 +1,4 @@ -use dbx_core::agent_service::AGENT_TYPES; +use dbx_core::agent_catalog; use dbx_core::database_capabilities::{ agent_key, is_agent_type, is_metadata_connection_scoped, is_single_connection_pool, skips_tcp_probe, }; @@ -192,7 +192,17 @@ fn driver_manifest_matches_agent_driver_store_entries() { expected.insert(profile.agent_key.as_str(), profile.label.as_str()); } } - let actual: std::collections::BTreeMap<&str, &str> = AGENT_TYPES.iter().copied().collect(); + let actual: std::collections::BTreeMap<&str, &str> = agent_catalog::driver_store_entries().collect(); assert_eq!(actual, expected); } + +#[test] +fn catalog_marks_runtime_only_agent_entries_explicitly() { + let runtime_only: Vec<&str> = + agent_catalog::entries().iter().filter(|entry| !entry.store_visible).map(|entry| entry.key).collect(); + + assert_eq!(runtime_only, vec!["iris"]); + assert!(is_agent_type(&DatabaseType::Iris)); + assert_eq!(agent_key(&DatabaseType::Iris, None), Some("iris")); +} diff --git a/crates/dbx-web/src/routes/agents.rs b/crates/dbx-web/src/routes/agents.rs index 91ff5205e3..a1e9e081a6 100644 --- a/crates/dbx-web/src/routes/agents.rs +++ b/crates/dbx-web/src/routes/agents.rs @@ -4,13 +4,12 @@ use axum::extract::{Multipart, Path, State}; use axum::response::sse::{Event, Sse}; use axum::Json; use dbx_core::agent_manager::{ - AgentDriverInfo, AgentManager, AgentRegistry, AgentState, DriverStoreUsage, InstalledDriver, JavaRuntimeConfig, - JavaRuntimeMode, DEFAULT_JRE_KEY, + AgentDriverInfo, AgentState, DriverStoreUsage, JavaRuntimeConfig, JavaRuntimeMode, DEFAULT_JRE_KEY, }; use dbx_core::agent_service::{ - build_agent_list, download_temp_path, fetch_registry, find_local_agent_jar, github_url_to_r2_path, - import_offline_zip, install_local_agent, invalidate_registry_cache, jre_needs_install, replace_download, - OfflineImportProgress, + build_agent_list, fetch_registry, import_agents_from_zip as import_agents_from_zip_core, install_agent_driver, + invalidate_registry_cache, reinstall_agent_jre, uninstall_agent_driver, uninstall_agent_jre, + upgrade_all_agent_drivers, AgentProgressEvent, }; use futures::Stream; use serde::Deserialize; @@ -57,23 +56,17 @@ pub async fn install_agent( Json(req): Json, ) -> Result, AppError> { let tx = progress_sender(&state, "global").await; - install_agent_core(&state.app.agent_manager, &req.db_type, &tx, None, None).await.map_err(AppError)?; + install_agent_driver(&state.app.agent_manager, &req.db_type, |event| send_progress_event(&tx, event)) + .await + .map_err(AppError)?; Ok(Json(serde_json::json!({ "ok": true }))) } pub async fn upgrade_all_agents(State(state): State>) -> Result, AppError> { let tx = progress_sender(&state, "global").await; - let am = &state.app.agent_manager; - let registry = fetch_registry().await.map_err(AppError)?; - let agents = build_agent_list(am, Some(®istry)); - let updatable: Vec<&AgentDriverInfo> = agents.iter().filter(|agent| agent.update_available).collect(); - let total = updatable.len() as u32; - - for (index, agent) in updatable.iter().enumerate() { - install_agent_from_registry(am, ®istry, &agent.db_type, &tx, Some((index + 1) as u32), Some(total)).await?; - } - - send_progress(&tx, serde_json::json!({ "step": "all-done" })); + let total = upgrade_all_agent_drivers(&state.app.agent_manager, |event| send_progress_event(&tx, event)) + .await + .map_err(AppError)?; Ok(Json(serde_json::json!({ "count": total }))) } @@ -81,19 +74,7 @@ pub async fn uninstall_agent( State(state): State>, Json(req): Json, ) -> Result, AppError> { - let am = &state.app.agent_manager; - let jar_path = am.driver_jar_path(&req.db_type); - if jar_path.exists() { - std::fs::remove_file(&jar_path).map_err(|err| AppError(err.to_string()))?; - } - if let Some(driver_dir) = jar_path.parent() { - if driver_dir.exists() { - std::fs::remove_dir_all(driver_dir).map_err(|err| AppError(err.to_string()))?; - } - } - let mut local_state = am.load_state(); - local_state.installed_drivers.remove(&req.db_type); - am.save_state(&local_state).map_err(AppError)?; + uninstall_agent_driver(&state.app.agent_manager, &req.db_type).await.map_err(AppError)?; Ok(Json(serde_json::json!({ "ok": true }))) } @@ -150,24 +131,13 @@ pub async fn import_agents_from_zip( std::fs::write(&zip_path, &data).map_err(|err| AppError(err.to_string()))?; let tx = progress_sender(&state, "global").await; - let result = import_offline_zip(&state.app.agent_manager, &zip_path, |p: OfflineImportProgress| { - send_progress( - &tx, - serde_json::json!({ - "step": p.step, - "downloaded": p.current as u64, - "total": p.total as u64, - "db_type": p.label, - "current": p.current, - "total_drivers": p.total, - }), - ); - }) - .map_err(AppError); + let result = + import_agents_from_zip_core(&state.app.agent_manager, &zip_path, |event| send_progress_event(&tx, event)) + .map_err(AppError); let _ = std::fs::remove_file(&zip_path); let result = result?; - send_progress(&tx, serde_json::json!({ "step": "done" })); + send_progress_event(&tx, AgentProgressEvent::step("done")); return Ok(Json(serde_json::json!({ "count": result.drivers_installed.len() as u32 }))); } @@ -213,9 +183,11 @@ pub async fn reinstall_jre( Json(req): Json, ) -> Result, AppError> { let tx = progress_sender(&state, "global").await; - reinstall_jre_core(&state.app.agent_manager, req.jre_key.as_deref().unwrap_or(DEFAULT_JRE_KEY), &tx) - .await - .map_err(AppError)?; + reinstall_agent_jre(&state.app.agent_manager, req.jre_key.as_deref().unwrap_or(DEFAULT_JRE_KEY), |event| { + send_progress_event(&tx, event); + }) + .await + .map_err(AppError)?; Ok(Json(serde_json::json!({ "ok": true }))) } @@ -224,20 +196,7 @@ pub async fn uninstall_jre( Json(req): Json, ) -> Result, AppError> { let key = req.jre_key.as_deref().unwrap_or(DEFAULT_JRE_KEY); - let am = &state.app.agent_manager; - let local_state = am.load_state(); - let dependents: Vec<&str> = - local_state.installed_drivers.iter().filter(|(_, driver)| driver.jre == key).map(|(k, _)| k.as_str()).collect(); - if !dependents.is_empty() { - return Err(AppError(format!("JRE {} 正在被以下驱动使用: {},请先卸载这些驱动", key, dependents.join(", ")))); - } - let jre_dir = am.jre_dir(key); - if jre_dir.exists() { - std::fs::remove_dir_all(&jre_dir).map_err(|err| AppError(format!("Failed to remove JRE: {err}")))?; - } - let mut local_state = am.load_state(); - local_state.jre_versions.remove(key); - am.save_state(&local_state).map_err(AppError)?; + uninstall_agent_jre(&state.app.agent_manager, key).await.map_err(AppError)?; Ok(Json(serde_json::json!({ "ok": true }))) } @@ -260,211 +219,8 @@ async fn progress_sender(state: &WebState, operation_id: &str) -> broadcast::Sen .clone() } -async fn install_agent_core( - am: &AgentManager, - db_type: &str, - tx: &broadcast::Sender, - current: Option, - total_drivers: Option, -) -> Result<(), String> { - match fetch_registry().await { - Ok(registry) => install_agent_from_registry(am, ®istry, db_type, tx, current, total_drivers).await, - Err(registry_err) => { - if let Some(local_jar) = find_local_agent_jar(db_type) { - install_local_agent(am, db_type, local_jar)?; - send_progress(tx, serde_json::json!({ "step": "done" })); - return Ok(()); - } - Err(registry_err) - } +fn send_progress_event(tx: &broadcast::Sender, event: AgentProgressEvent) { + if let Ok(payload) = serde_json::to_string(&event) { + let _ = tx.send(payload); } } - -async fn install_agent_from_registry( - am: &AgentManager, - registry: &AgentRegistry, - db_type: &str, - tx: &broadcast::Sender, - current: Option, - total_drivers: Option, -) -> Result<(), String> { - let Some(driver) = registry.drivers.get(db_type) else { - if let Some(local_jar) = find_local_agent_jar(db_type) { - install_local_agent(am, db_type, local_jar)?; - send_progress(tx, serde_json::json!({ "step": "done" })); - return Ok(()); - } - return Err(format!("Unknown driver type: {db_type}")); - }; - let jre_key = &driver.jre; - let needs_jre = jre_needs_install(am, registry, jre_key); - if needs_jre { - let jre_info = - registry.resolve_jre(jre_key).ok_or_else(|| format!("No JRE definition for version: {jre_key}"))?; - let platform = AgentManager::current_platform(); - let platform_jre = jre_info - .platforms - .get(platform) - .ok_or_else(|| format!("No JRE {jre_key} available for platform: {platform}"))?; - let jre_archive = am.base_dir().join("jre-download.tar.gz"); - send_install_progress(tx, "jre", 0, platform_jre.size, Some(db_type), current, total_drivers); - download_with_progress( - tx, - "jre", - &platform_jre.url, - &github_url_to_r2_path(&platform_jre.url, "jre"), - &jre_archive, - platform_jre.size, - Some(db_type), - current, - total_drivers, - ) - .await?; - send_install_progress(tx, "jre-extract", 0, 0, Some(db_type), current, total_drivers); - let jre_dir = am.jre_dir(jre_key); - if jre_dir.exists() { - std::fs::remove_dir_all(&jre_dir).map_err(|err| format!("Failed to remove old JRE: {err}"))?; - } - extract_archive(&jre_archive, &jre_dir)?; - std::fs::remove_file(&jre_archive).ok(); - } - - let jar_path = am.driver_jar_path(db_type); - send_install_progress(tx, "driver", 0, driver.jar.size, Some(db_type), current, total_drivers); - download_with_progress( - tx, - "driver", - &driver.jar.url, - &github_url_to_r2_path(&driver.jar.url, "driver"), - &jar_path, - driver.jar.size, - Some(db_type), - current, - total_drivers, - ) - .await?; - - let mut local_state = am.load_state(); - if let Some(jre_info) = registry.resolve_jre(jre_key) { - local_state.jre_versions.insert(jre_key.clone(), jre_info.version.clone()); - } - local_state.installed_drivers.insert( - db_type.to_string(), - InstalledDriver { - version: driver.version.clone(), - installed_at: chrono::Utc::now().to_rfc3339(), - jre: jre_key.clone(), - }, - ); - am.save_state(&local_state)?; - send_progress(tx, serde_json::json!({ "step": "done" })); - Ok(()) -} - -async fn reinstall_jre_core(am: &AgentManager, jre_key: &str, tx: &broadcast::Sender) -> Result<(), String> { - let registry = fetch_registry().await?; - let jre_info = registry.resolve_jre(jre_key).ok_or_else(|| format!("No JRE definition for version: {jre_key}"))?; - let platform = AgentManager::current_platform(); - let platform_jre = jre_info - .platforms - .get(platform) - .ok_or_else(|| format!("No JRE {jre_key} available for platform: {platform}"))?; - let jre_archive = am.base_dir().join("jre-download.tar.gz"); - download_with_progress( - tx, - "jre", - &platform_jre.url, - &github_url_to_r2_path(&platform_jre.url, "jre"), - &jre_archive, - platform_jre.size, - None, - None, - None, - ) - .await?; - let jre_dir = am.jre_dir(jre_key); - if jre_dir.exists() { - std::fs::remove_dir_all(&jre_dir).map_err(|err| format!("Failed to remove old JRE: {err}"))?; - } - extract_archive(&jre_archive, &jre_dir)?; - std::fs::remove_file(&jre_archive).ok(); - let mut local_state = am.load_state(); - local_state.jre_versions.insert(jre_key.to_string(), jre_info.version.clone()); - am.save_state(&local_state)?; - send_progress(tx, serde_json::json!({ "step": "done" })); - Ok(()) -} - -async fn download_with_progress( - tx: &broadcast::Sender, - step: &str, - url: &str, - r2_path: &str, - dest: &std::path::Path, - total_size: u64, - db_type: Option<&str>, - current: Option, - total_drivers: Option, -) -> Result<(), String> { - if let Some(parent) = dest.parent() { - std::fs::create_dir_all(parent).map_err(|err| err.to_string())?; - } - let tmp = download_temp_path(dest); - let client = reqwest::Client::builder() - .timeout(std::time::Duration::from_secs(300)) - .build() - .map_err(|err| format!("Failed to create HTTP client: {err}"))?; - let mut resp = dbx_core::race_download(&client, url, r2_path, "dbx-agent-manager") - .await - .map_err(|err| format!("Failed to download {url}: {err}"))?; - let content_length = resp.content_length().unwrap_or(total_size); - let mut file = std::fs::File::create(&tmp).map_err(|err| format!("Failed to create temp file: {err}"))?; - let mut downloaded = 0; - while let Some(chunk) = resp.chunk().await.map_err(|err| format!("Download stream error: {err}"))? { - std::io::Write::write_all(&mut file, &chunk).map_err(|err| format!("Failed to write chunk: {err}"))?; - downloaded += chunk.len() as u64; - send_install_progress(tx, step, downloaded, content_length, db_type, current, total_drivers); - } - std::io::Write::flush(&mut file).map_err(|err| format!("Failed to flush temp file: {err}"))?; - drop(file); - replace_download(&tmp, dest) -} - -fn send_install_progress( - tx: &broadcast::Sender, - step: &str, - downloaded: u64, - total: u64, - db_type: Option<&str>, - current: Option, - total_drivers: Option, -) { - let mut payload = serde_json::json!({ "step": step, "downloaded": downloaded, "total": total }); - if let Some(value) = db_type { - payload["db_type"] = serde_json::json!(value); - } - if let Some(value) = current { - payload["current"] = serde_json::json!(value); - } - if let Some(value) = total_drivers { - payload["total_drivers"] = serde_json::json!(value); - } - send_progress(tx, payload); -} - -fn send_progress(tx: &broadcast::Sender, payload: serde_json::Value) { - let _ = tx.send(payload.to_string()); -} - -fn extract_archive(archive: &std::path::Path, dest: &std::path::Path) -> Result<(), String> { - use std::process::Command; - std::fs::create_dir_all(dest).map_err(|err| err.to_string())?; - let status = Command::new("tar") - .args(["xzf", &archive.to_string_lossy(), "-C", &dest.to_string_lossy(), "--strip-components=1"]) - .status() - .map_err(|err| format!("Failed to extract archive: {err}"))?; - if !status.success() { - return Err("Failed to extract JRE archive".to_string()); - } - Ok(()) -} diff --git a/src-tauri/src/commands/agents.rs b/src-tauri/src/commands/agents.rs index 1d50d9875b..8a0fe51af2 100644 --- a/src-tauri/src/commands/agents.rs +++ b/src-tauri/src/commands/agents.rs @@ -2,14 +2,11 @@ use std::sync::Arc; use tauri::{Emitter, State}; -use dbx_core::agent_manager::{ - AgentDriverInfo, AgentManager, DriverStoreUsage, InstalledDriver, JavaRuntimeConfig, JavaRuntimeMode, - DEFAULT_JRE_KEY, -}; +use dbx_core::agent_manager::{AgentDriverInfo, DriverStoreUsage, JavaRuntimeConfig, JavaRuntimeMode, DEFAULT_JRE_KEY}; use dbx_core::agent_service::{ - build_agent_list, download_temp_path, fetch_registry, find_local_agent_jar, github_url_to_r2_path, - import_agent_jar, import_offline_zip, install_local_agent, invalidate_registry_cache, jre_needs_install, - replace_download, OfflineImportProgress, + build_agent_list, fetch_registry, import_agent_jar, import_agents_from_zip as import_agents_from_zip_core, + install_agent_driver, invalidate_registry_cache, reinstall_agent_jre, uninstall_agent_driver, uninstall_agent_jre, + upgrade_all_agent_drivers, AgentProgressEvent, }; use dbx_core::connection::AppState; @@ -35,212 +32,19 @@ pub async fn install_agent( state: State<'_, Arc>, db_type: String, ) -> Result<(), String> { - let am = &state.agent_manager; - let registry = match fetch_registry().await { - Ok(registry) => registry, - Err(registry_err) => { - if let Some(local_jar) = find_local_agent_jar(&db_type) { - install_local_agent(am, &db_type, local_jar)?; - let _ = app.emit("agent-install-progress", serde_json::json!({ "step": "done" })); - return Ok(()); - } - return Err(registry_err); - } - }; - - let Some(driver) = registry.drivers.get(&db_type) else { - if let Some(local_jar) = find_local_agent_jar(&db_type) { - install_local_agent(am, &db_type, local_jar)?; - let _ = app.emit("agent-install-progress", serde_json::json!({ "step": "done" })); - return Ok(()); - } - return Err(format!("Unknown driver type: {db_type}")); - }; - let jre_key = &driver.jre; - let needs_jre = jre_needs_install(am, ®istry, jre_key); - - if needs_jre { - let jre_info = - registry.resolve_jre(jre_key).ok_or_else(|| format!("No JRE definition for version: {jre_key}"))?; - let platform = AgentManager::current_platform(); - let platform_jre = jre_info - .platforms - .get(platform) - .ok_or_else(|| format!("No JRE {jre_key} available for platform: {platform}"))?; - let jre_archive = am.base_dir().join("jre-download.tar.gz"); - let _ = app.emit( - "agent-install-progress", - serde_json::json!({ - "step": "jre", "downloaded": 0u64, "total": platform_jre.size, - }), - ); - download_with_progress( - &app, - "jre", - &platform_jre.url, - &github_url_to_r2_path(&platform_jre.url, "jre"), - &jre_archive, - platform_jre.size, - ) - .await?; - let _ = app.emit( - "agent-install-progress", - serde_json::json!({ - "step": "jre-extract", "downloaded": 0u64, "total": 0u64, - }), - ); - let jre_dir = am.jre_dir(jre_key); - if jre_dir.exists() { - std::fs::remove_dir_all(&jre_dir).map_err(|e| format!("Failed to remove old JRE: {e}"))?; - } - extract_archive(&jre_archive, &jre_dir)?; - std::fs::remove_file(&jre_archive).ok(); - } - - let jar_path = am.driver_jar_path(&db_type); - let _ = app.emit( - "agent-install-progress", - serde_json::json!({ - "step": "driver", "downloaded": 0u64, "total": driver.jar.size, - }), - ); - download_with_progress( - &app, - "driver", - &driver.jar.url, - &github_url_to_r2_path(&driver.jar.url, "driver"), - &jar_path, - driver.jar.size, - ) - .await?; - - let mut local_state = am.load_state(); - if let Some(jre_info) = registry.resolve_jre(jre_key) { - local_state.jre_versions.insert(jre_key.clone(), jre_info.version.clone()); - } - local_state.installed_drivers.insert( - db_type, - InstalledDriver { - version: driver.version.clone(), - installed_at: chrono::Utc::now().to_rfc3339(), - jre: jre_key.clone(), - }, - ); - am.save_state(&local_state)?; - let _ = app.emit("agent-install-progress", serde_json::json!({ "step": "done" })); - Ok(()) + let app_handle = app.clone(); + install_agent_driver(&state.agent_manager, &db_type, move |event| emit_agent_progress(&app_handle, event)).await } #[tauri::command] pub async fn upgrade_all_agents(app: tauri::AppHandle, state: State<'_, Arc>) -> Result { - let am = &state.agent_manager; - let registry = fetch_registry().await?; - let agents = build_agent_list(am, Some(®istry)); - let updatable: Vec<&AgentDriverInfo> = agents.iter().filter(|a| a.update_available).collect(); - let total_drivers = updatable.len() as u32; - if total_drivers == 0 { - return Ok(0); - } - - for (i, agent) in updatable.iter().enumerate() { - let current = (i + 1) as u32; - let db_type = &agent.db_type; - let driver = registry.drivers.get(db_type).ok_or_else(|| format!("Unknown driver type: {db_type}"))?; - let jre_key = &driver.jre; - let needs_jre = jre_needs_install(am, ®istry, jre_key); - - if needs_jre { - let jre_info = - registry.resolve_jre(jre_key).ok_or_else(|| format!("No JRE definition for version: {jre_key}"))?; - let platform = AgentManager::current_platform(); - let platform_jre = jre_info - .platforms - .get(platform) - .ok_or_else(|| format!("No JRE {jre_key} available for platform: {platform}"))?; - let jre_archive = am.base_dir().join("jre-download.tar.gz"); - let _ = app.emit( - "agent-install-progress", - serde_json::json!({ - "step": "jre", "downloaded": 0u64, "total": platform_jre.size, - "db_type": db_type, "current": current, "total_drivers": total_drivers, - }), - ); - download_with_progress( - &app, - "jre", - &platform_jre.url, - &github_url_to_r2_path(&platform_jre.url, "jre"), - &jre_archive, - platform_jre.size, - ) - .await?; - let _ = app.emit( - "agent-install-progress", - serde_json::json!({ - "step": "jre-extract", "downloaded": 0u64, "total": 0u64, - "db_type": db_type, "current": current, "total_drivers": total_drivers, - }), - ); - let jre_dir = am.jre_dir(jre_key); - if jre_dir.exists() { - std::fs::remove_dir_all(&jre_dir).map_err(|e| format!("Failed to remove old JRE: {e}"))?; - } - extract_archive(&jre_archive, &jre_dir)?; - std::fs::remove_file(&jre_archive).ok(); - } - - let jar_path = am.driver_jar_path(db_type); - let _ = app.emit( - "agent-install-progress", - serde_json::json!({ - "step": "driver", "downloaded": 0u64, "total": driver.jar.size, - "db_type": db_type, "current": current, "total_drivers": total_drivers, - }), - ); - download_with_progress( - &app, - "driver", - &driver.jar.url, - &github_url_to_r2_path(&driver.jar.url, "driver"), - &jar_path, - driver.jar.size, - ) - .await?; - - let mut local_state = am.load_state(); - if let Some(jre_info) = registry.resolve_jre(jre_key) { - local_state.jre_versions.insert(jre_key.clone(), jre_info.version.clone()); - } - local_state.installed_drivers.insert( - db_type.clone(), - InstalledDriver { - version: driver.version.clone(), - installed_at: chrono::Utc::now().to_rfc3339(), - jre: jre_key.clone(), - }, - ); - am.save_state(&local_state)?; - } - - let _ = app.emit("agent-install-progress", serde_json::json!({ "step": "all-done" })); - Ok(total_drivers) + let app_handle = app.clone(); + upgrade_all_agent_drivers(&state.agent_manager, move |event| emit_agent_progress(&app_handle, event)).await } #[tauri::command] pub async fn uninstall_agent(state: State<'_, Arc>, db_type: String) -> Result<(), String> { - let am = &state.agent_manager; - let jar_path = am.driver_jar_path(&db_type); - if jar_path.exists() { - std::fs::remove_file(&jar_path).map_err(|e| e.to_string())?; - } - let driver_dir = jar_path.parent().unwrap(); - if driver_dir.exists() { - std::fs::remove_dir_all(driver_dir).map_err(|e| e.to_string())?; - } - let mut local_state = am.load_state(); - local_state.installed_drivers.remove(&db_type); - am.save_state(&local_state)?; - Ok(()) + uninstall_agent_driver(&state.agent_manager, &db_type).await } #[tauri::command] @@ -280,21 +84,7 @@ pub async fn set_agent_java_runtime_config( #[tauri::command] pub async fn uninstall_jre(state: State<'_, Arc>, jre_key: String) -> Result<(), String> { - let am = &state.agent_manager; - let local_state = am.load_state(); - let dependents: Vec<&str> = - local_state.installed_drivers.iter().filter(|(_, d)| d.jre == jre_key).map(|(k, _)| k.as_str()).collect(); - if !dependents.is_empty() { - return Err(format!("JRE {} 正在被以下驱动使用: {},请先卸载这些驱动", jre_key, dependents.join(", "))); - } - let jre_dir = am.jre_dir(&jre_key); - if jre_dir.exists() { - std::fs::remove_dir_all(&jre_dir).map_err(|e| format!("Failed to remove JRE: {e}"))?; - } - let mut local_state = am.load_state(); - local_state.jre_versions.remove(&jre_key); - am.save_state(&local_state)?; - Ok(()) + uninstall_agent_jre(&state.agent_manager, &jre_key).await } #[tauri::command] @@ -312,21 +102,9 @@ pub async fn import_agents_from_zip( let am = &state.agent_manager; let zip_path = std::path::PathBuf::from(&path); let app_handle = app.clone(); - let result = import_offline_zip(am, &zip_path, |p: OfflineImportProgress| { - let _ = app_handle.emit( - "agent-install-progress", - serde_json::json!({ - "step": p.step, - "downloaded": p.current as u64, - "total": p.total as u64, - "db_type": p.label, - "current": p.current, - "total_drivers": p.total, - }), - ); - })?; + let result = import_agents_from_zip_core(am, &zip_path, |event| emit_agent_progress(&app_handle, event))?; let count = result.drivers_installed.len() as u32; - let _ = app.emit("agent-install-progress", serde_json::json!({ "step": "done" })); + emit_agent_progress(&app, AgentProgressEvent::step("done")); Ok(count) } @@ -345,83 +123,11 @@ pub async fn reinstall_jre( state: State<'_, Arc>, jre_key: Option, ) -> Result<(), String> { - let am = &state.agent_manager; let key = jre_key.as_deref().unwrap_or(DEFAULT_JRE_KEY); - let registry = fetch_registry().await?; - let jre_info = registry.resolve_jre(key).ok_or_else(|| format!("No JRE definition for version: {key}"))?; - let platform = AgentManager::current_platform(); - let platform_jre = - jre_info.platforms.get(platform).ok_or_else(|| format!("No JRE {key} available for platform: {platform}"))?; - let jre_archive = am.base_dir().join("jre-download.tar.gz"); - download_with_progress( - &app, - "jre", - &platform_jre.url, - &github_url_to_r2_path(&platform_jre.url, "jre"), - &jre_archive, - platform_jre.size, - ) - .await?; - let jre_dir = am.jre_dir(key); - if jre_dir.exists() { - std::fs::remove_dir_all(&jre_dir).map_err(|e| format!("Failed to remove old JRE: {e}"))?; - } - extract_archive(&jre_archive, &jre_dir)?; - std::fs::remove_file(&jre_archive).ok(); - let mut local_state = am.load_state(); - local_state.jre_versions.insert(key.to_string(), jre_info.version.clone()); - am.save_state(&local_state)?; - let _ = app.emit("agent-install-progress", serde_json::json!({ "step": "done" })); - Ok(()) + let app_handle = app.clone(); + reinstall_agent_jre(&state.agent_manager, key, move |event| emit_agent_progress(&app_handle, event)).await } -async fn download_with_progress( - app: &tauri::AppHandle, - step: &str, - url: &str, - r2_path: &str, - dest: &std::path::Path, - total_size: u64, -) -> Result<(), String> { - if let Some(parent) = dest.parent() { - std::fs::create_dir_all(parent).map_err(|e| e.to_string())?; - } - let tmp = download_temp_path(dest); - let client = reqwest::Client::builder() - .timeout(std::time::Duration::from_secs(300)) - .build() - .map_err(|e| format!("Failed to create HTTP client: {e}"))?; - - let resp = dbx_core::race_download(&client, url, r2_path, "dbx-agent-manager") - .await - .map_err(|e| format!("Failed to download {url}: {e}"))?; - - let content_length = resp.content_length().unwrap_or(total_size); - let mut file = std::fs::File::create(&tmp).map_err(|e| format!("Failed to create temp file: {e}"))?; - let mut downloaded: u64 = 0; - let mut bytes = resp; - while let Some(chunk) = bytes.chunk().await.map_err(|e| format!("Download stream error: {e}"))? { - std::io::Write::write_all(&mut file, &chunk).map_err(|e| format!("Failed to write chunk: {e}"))?; - downloaded += chunk.len() as u64; - let _ = app.emit( - "agent-install-progress", - serde_json::json!({ "step": step, "downloaded": downloaded, "total": content_length }), - ); - } - std::io::Write::flush(&mut file).map_err(|e| format!("Failed to flush temp file: {e}"))?; - drop(file); - replace_download(&tmp, dest) -} - -fn extract_archive(archive: &std::path::Path, dest: &std::path::Path) -> Result<(), String> { - use std::process::Command; - std::fs::create_dir_all(dest).map_err(|e| e.to_string())?; - let status = Command::new("tar") - .args(["xzf", &archive.to_string_lossy(), "-C", &dest.to_string_lossy(), "--strip-components=1"]) - .status() - .map_err(|e| format!("Failed to extract archive: {e}"))?; - if !status.success() { - return Err("Failed to extract JRE archive".to_string()); - } - Ok(()) +fn emit_agent_progress(app: &tauri::AppHandle, event: AgentProgressEvent) { + let _ = app.emit("agent-install-progress", event); } diff --git a/src-tauri/src/commands/connection.rs b/src-tauri/src/commands/connection.rs index 340cac3b4e..1d0de2284c 100644 --- a/src-tauri/src/commands/connection.rs +++ b/src-tauri/src/commands/connection.rs @@ -1,10 +1,13 @@ use std::sync::Arc; use tauri::State; +pub use dbx_core::agent_connection::{ + agent_connect_params, mongo_legacy_error_with_auth_hint, oracle_alternate_connect_config, + should_retry_oracle_with_10g_driver, +}; pub use dbx_core::connection::{ - agent_connect_params, connection_url_for_endpoint, expand_tilde, metadata_connection_config, - mongo_legacy_error_with_auth_hint, oracle_alternate_connect_config, probe_connection_endpoint, - redacted_connection_url_for_endpoint, should_retry_oracle_with_10g_driver, AppState, MysqlMode, PoolKind, + connection_url_for_endpoint, expand_tilde, metadata_connection_config, probe_connection_endpoint, + redacted_connection_url_for_endpoint, AppState, MysqlMode, PoolKind, }; use dbx_core::database_capabilities; use dbx_core::db;