feat(duckdb): move support to standalone driver
This commit is contained in:
76 files changed
+5400
-8258
No files matched your search
@@ -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));
|
||||
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -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))
|
||||
}
|
||||
|
||||
Reference in new issue
Block a user