feat(duckdb): move support to standalone driver

This commit is contained in:
t8y2 committed 2026-07-30 00:50:39 +08:00
1 parent ed018dbc77
commit d347c77c3d
76 files changed
+5400 -8258

No files matched your search

+3 -2
View File
@@ -328,6 +328,7 @@ async fn main() {
.route("/agents/runtime/restart", post(routes::agents::restart_driver_runtime))
.route("/agents/install", post(routes::agents::install_agent))
.route("/agents/upgrade-all", post(routes::agents::upgrade_all_agents))
.route("/agents/update-blockers", post(routes::agents::check_agent_update_blockers))
.route("/agents/uninstall", post(routes::agents::uninstall_agent))
.route("/agents/import-offline", post(routes::agents::import_agents_from_zip))
.route("/agents/import-driver", post(routes::agents::import_agent_driver_file))
@@ -747,8 +748,8 @@ async fn main() {
.route("/cloud-sync/snippet/upload", post(routes::cloud_sync::snippet_sync_upload))
.route("/cloud-sync/snippet/download", post(routes::cloud_sync::snippet_sync_download));
// Do not expose DuckDB-only handlers from builds that intentionally omit bundled DuckDB.
#[cfg(feature = "duckdb-bundled")]
// Do not expose DuckDB-only handlers from builds that omit DuckDB sidecar support.
#[cfg(feature = "duckdb-sidecar")]
let api =
api.route("/query/build-duckdb-attach-database-sql", post(routes::query::build_duckdb_attach_database_sql));
+86 -21
View File
@@ -8,13 +8,13 @@ use dbx_core::agent_manager::{
};
use dbx_core::agent_service::{
build_agent_list, clear_agent_download_cache, fetch_registry, import_agent_driver,
import_agents_from_zip as import_agents_from_zip_core, inspect_offline_zip, install_agent_driver,
import_agents_from_package as import_agents_from_package_core, inspect_offline_package, install_agent_driver,
invalidate_registry_cache, reinstall_agent_jre, uninstall_agent_driver, uninstall_agent_jre,
upgrade_all_agent_drivers, AgentProgressEvent, OfflineImportPlan,
};
use dbx_core::driver_runtime::DriverRuntimeSummary;
use futures::Stream;
use serde::Deserialize;
use serde::{Deserialize, Serialize};
use tokio::io::AsyncWriteExt;
use tokio::sync::broadcast;
@@ -41,6 +41,18 @@ pub struct AgentOperationRequest {
pub operation_id: Option<String>,
}
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AgentUpdateBlockersRequest {
pub db_types: Vec<String>,
}
#[derive(Debug, Clone, Serialize)]
pub struct AgentUpdateBlocker {
pub db_type: String,
pub label: String,
}
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct JavaRuntimeRequest {
@@ -138,10 +150,18 @@ pub async fn upgrade_all_agents(
Ok(Json(serde_json::to_value(result).map_err(|err| AppError::from(err.to_string()))?))
}
pub async fn check_agent_update_blockers(
State(state): State<Arc<WebState>>,
Json(req): Json<AgentUpdateBlockersRequest>,
) -> Result<Json<Vec<AgentUpdateBlocker>>, AppError> {
Ok(Json(agent_update_blockers(&state.app, &req.db_types).await))
}
pub async fn uninstall_agent(
State(state): State<Arc<WebState>>,
Json(req): Json<AgentTypeRequest>,
) -> Result<Json<serde_json::Value>, AppError> {
ensure_no_agent_update_blockers(&state.app, std::slice::from_ref(&req.db_type)).await.map_err(AppError::from)?;
uninstall_agent_driver(&state.app.agent_manager, &req.db_type).await.map_err(AppError::from)?;
Ok(Json(serde_json::json!({ "ok": true })))
}
@@ -200,14 +220,13 @@ pub async fn import_agents_from_zip(
}
let file_name = field.file_name().unwrap_or("offline-drivers.zip").to_string();
if !file_name.to_ascii_lowercase().ends_with(".zip") {
return Err(AppError::from("Offline driver package must be a .zip file".to_string()));
}
let zip_path = tmp_dir.join(format!("agent-offline-{}.zip", uuid::Uuid::new_v4()));
let extension = offline_package_extension(&file_name)
.ok_or_else(|| AppError::from("Offline driver package must be a .zip or .tar.zst file".to_string()))?;
let package_path = tmp_dir.join(format!("agent-offline-{}.{}", uuid::Uuid::new_v4(), extension));
let tx = progress_sender(&state, "global").await;
let result = async {
let mut upload = tokio::fs::File::create(&zip_path).await.map_err(|err| AppError::from(err.to_string()))?;
let mut upload =
tokio::fs::File::create(&package_path).await.map_err(|err| AppError::from(err.to_string()))?;
let mut field = field;
while let Some(chunk) = field.chunk().await.map_err(|err| AppError::from(err.to_string()))? {
upload.write_all(&chunk).await.map_err(|err| AppError::from(err.to_string()))?;
@@ -215,16 +234,16 @@ pub async fn import_agents_from_zip(
upload.flush().await.map_err(|err| AppError::from(err.to_string()))?;
drop(upload);
let plan = inspect_offline_zip(&zip_path).map_err(AppError::from)?;
let plan = inspect_offline_package(&package_path).map_err(AppError::from)?;
ensure_no_offline_import_blockers(&state.app, &plan).await.map_err(AppError::from)?;
import_agents_from_zip_core(&state.app.agent_manager, &zip_path, |event| {
import_agents_from_package_core(&state.app.agent_manager, &package_path, |event| {
send_progress_event(&tx, event.with_operation_id(&operation_id))
})
.await
.map_err(AppError::from)
}
.await;
let _ = std::fs::remove_file(&zip_path);
let _ = std::fs::remove_file(&package_path);
let result = result?;
send_progress_event(&tx, AgentProgressEvent::step("done").with_operation_id(&operation_id));
@@ -327,22 +346,46 @@ async fn ensure_no_agent_update_blockers(
state: &dbx_core::connection::AppState,
db_types: &[String],
) -> Result<(), String> {
let candidate_keys: std::collections::HashSet<&str> = db_types.iter().map(String::as_str).collect();
if candidate_keys.is_empty() {
let blockers = update_blockers_from_keys(state.prepare_agent_driver_updates(db_types).await, db_types);
if blockers.is_empty() {
return Ok(());
}
let mut blockers = state
.prepare_agent_driver_updates(db_types)
.await
let labels = blockers.into_iter().map(|blocker| blocker.label).collect::<Vec<_>>().join(", ");
Err(format!("Close these database connections before updating drivers: {labels}"))
}
async fn agent_update_blockers(state: &dbx_core::connection::AppState, db_types: &[String]) -> Vec<AgentUpdateBlocker> {
update_blockers_from_keys(state.active_agent_connection_driver_keys().await, db_types)
}
fn update_blockers_from_keys(
active_keys: std::collections::HashSet<String>,
db_types: &[String],
) -> Vec<AgentUpdateBlocker> {
let candidate_keys: std::collections::HashSet<&str> = db_types.iter().map(String::as_str).collect();
if candidate_keys.is_empty() {
return Vec::new();
}
let mut blockers = active_keys
.into_iter()
.filter(|key| candidate_keys.contains(key.as_str()))
.map(|key| dbx_core::agent_catalog::label_for_key(&key).unwrap_or(&key).to_string())
.map(|db_type| AgentUpdateBlocker {
label: dbx_core::agent_catalog::label_for_key(&db_type).unwrap_or(&db_type).to_string(),
db_type,
})
.collect::<Vec<_>>();
blockers.sort();
if blockers.is_empty() {
Ok(())
blockers.sort_by(|left, right| left.label.cmp(&right.label));
blockers
}
fn offline_package_extension(file_name: &str) -> Option<&'static str> {
let lower_name = file_name.to_ascii_lowercase();
if lower_name.ends_with(".tar.zst") {
Some("tar.zst")
} else if lower_name.ends_with(".zip") {
Some("zip")
} else {
Err(format!("Close these database connections before updating drivers: {}", blockers.join(", ")))
None
}
}
@@ -361,3 +404,25 @@ async fn ensure_no_offline_import_blockers(
}
ensure_no_agent_update_blockers(state, &driver_keys).await
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn update_blockers_include_active_duckdb_connections() {
let active_keys = ["duckdb".to_string(), "oracle".to_string()].into_iter().collect();
let blockers = update_blockers_from_keys(active_keys, &["duckdb".to_string()]);
assert_eq!(blockers.len(), 1);
assert_eq!(blockers[0].db_type, "duckdb");
assert_eq!(blockers[0].label, "DuckDB");
}
#[test]
fn offline_package_extension_accepts_zip_and_tar_zstd() {
assert_eq!(offline_package_extension("dbx-agents.zip"), Some("zip"));
assert_eq!(offline_package_extension("dbx-agent-duckdb.TAR.ZST"), Some("tar.zst"));
assert_eq!(offline_package_extension("dbx-agent-duckdb.zst"), None);
}
}
+2 -2
View File
@@ -142,7 +142,7 @@ pub struct BuildCreateDatabaseSqlRequest {
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
#[cfg(feature = "duckdb-bundled")]
#[cfg(feature = "duckdb-sidecar")]
pub struct BuildDuckDbAttachDatabaseSqlRequest {
pub options: dbx_core::db_admin_sql::DuckDbAttachDatabaseSqlOptions,
}
@@ -647,7 +647,7 @@ pub async fn build_create_database_sql(
dbx_core::db_admin_sql::build_create_database_sql(req.options).map(Json).map_err(AppError::from)
}
#[cfg(feature = "duckdb-bundled")]
#[cfg(feature = "duckdb-sidecar")]
pub async fn build_duckdb_attach_database_sql(Json(req): Json<BuildDuckDbAttachDatabaseSqlRequest>) -> Json<String> {
Json(dbx_core::db_admin_sql::build_duckdb_attach_database_sql(req.options))
}