feat(agents): concurrent all-agent-driver upgrade

This commit is contained in:
Abeautifulsnow authored and GitHub committed 2026-07-24 23:50:50 +08:00
1 parent 2a99f91099
commit 95db01e359
15 files changed
+1083 -282

No files matched your search

+88 -52
View File
@@ -364,7 +364,9 @@ fn atomic_replace_moves_download_into_place() {
#[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 event = AgentProgressEvent::transfer("driver", 512, 1024)
.with_batch(Some("h2"), Some(1), Some(2))
.with_operation_id("upgrade-123");
let value = serde_json::to_value(event).unwrap();
@@ -374,16 +376,17 @@ fn agent_progress_event_serializes_backward_compatible_fields() {
assert_eq!(value["db_type"], "h2");
assert_eq!(value["current"], 1);
assert_eq!(value["total_drivers"], 2);
assert_eq!(value["operation_id"], "upgrade-123");
}
#[test]
fn local_jar_import_updates_driver_state() {
#[tokio::test]
async 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();
write_test_agent_jar(&source);
import_agent_jar(&manager, "h2", &source).unwrap();
import_agent_jar(&manager, "h2", &source).await.unwrap();
assert_eq!(std::fs::read(manager.driver_jar_path("h2")).unwrap(), std::fs::read(&source).unwrap());
let state = manager.load_state();
@@ -392,22 +395,22 @@ fn local_jar_import_updates_driver_state() {
assert_eq!(installed.jre, DEFAULT_JRE_KEY);
}
#[test]
fn local_jar_import_rejects_corrupt_jar() {
#[tokio::test]
async fn local_jar_import_rejects_corrupt_jar() {
let manager = test_manager("local-import-corrupt");
let source = test_path("local-import-corrupt-source").join("dbx-agent-h2.jar");
std::fs::create_dir_all(source.parent().unwrap()).unwrap();
std::fs::write(&source, b"jar").unwrap();
let err = import_agent_jar(&manager, "h2", &source).unwrap_err();
let err = import_agent_jar(&manager, "h2", &source).await.unwrap_err();
assert!(err.contains("invalid or corrupt"));
assert!(!manager.driver_jar_path("h2").exists());
assert!(!manager.load_state().installed_drivers.contains_key("h2"));
}
#[test]
fn local_native_import_installs_current_platform_executable() {
#[tokio::test]
async fn local_native_import_installs_current_platform_executable() {
let manager = test_manager("local-native-import");
let source = test_path("local-native-import-source").join(if cfg!(windows) {
"dbx-agent-kingbase-windows.exe"
@@ -417,35 +420,35 @@ fn local_native_import_installs_current_platform_executable() {
std::fs::create_dir_all(source.parent().unwrap()).unwrap();
std::fs::write(&source, current_platform_native_binary()).unwrap();
import_agent_driver(&manager, "kingbase", &source).unwrap();
import_agent_driver(&manager, "kingbase", &source).await.unwrap();
assert_eq!(std::fs::read(manager.driver_native_path("kingbase")).unwrap(), std::fs::read(&source).unwrap());
assert!(!manager.driver_jar_path("kingbase").exists());
assert_eq!(manager.load_state().installed_drivers["kingbase"].version, "0.1.0-local");
}
#[test]
fn local_native_import_rejects_wrong_platform_binary() {
#[tokio::test]
async fn local_native_import_rejects_wrong_platform_binary() {
let manager = test_manager("local-native-import-invalid");
let source = test_path("local-native-import-invalid-source").join("dbx-agent-kingbase");
std::fs::create_dir_all(source.parent().unwrap()).unwrap();
std::fs::write(&source, b"not-an-executable").unwrap();
let err = import_agent_driver(&manager, "kingbase", &source).unwrap_err();
let err = import_agent_driver(&manager, "kingbase", &source).await.unwrap_err();
assert!(err.contains(AgentManager::current_platform()));
assert!(!manager.driver_native_path("kingbase").exists());
assert!(!manager.load_state().installed_drivers.contains_key("kingbase"));
}
#[test]
fn local_native_import_rejects_wrong_arch_binary() {
#[tokio::test]
async fn local_native_import_rejects_wrong_arch_binary() {
let manager = test_manager("local-native-wrong-arch");
let native_path = test_path("local-native-wrong-arch-file").join("agent");
std::fs::create_dir_all(native_path.parent().unwrap()).unwrap();
std::fs::write(&native_path, native_binary_for_arch(!cfg!(target_arch = "aarch64"))).unwrap();
let err = import_agent_driver(&manager, "kingbase", &native_path).unwrap_err();
let err = import_agent_driver(&manager, "kingbase", &native_path).await.unwrap_err();
assert!(err.contains("not a"));
assert!(!manager.driver_native_path("kingbase").exists());
@@ -515,8 +518,8 @@ fn clear_download_cache_removes_only_cache_entries() {
assert!(installed_driver.exists());
}
#[test]
fn offline_zip_import_emits_progress_and_updates_state() {
#[tokio::test]
async 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();
@@ -526,6 +529,7 @@ fn offline_zip_import_emits_progress_and_updates_state() {
let result = import_agents_from_zip(&manager, &zip_path, |event| {
events.lock().unwrap().push(event);
})
.await
.unwrap();
assert_eq!(result.drivers_installed, vec!["h2"]);
@@ -533,11 +537,12 @@ fn offline_zip_import_emits_progress_and_updates_state() {
assert!(installed_jar.windows(b"Main-Class:".len()).any(|window| window == b"Main-Class:"));
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")));
// db_type carries the real database key, not the display label.
assert!(events.iter().any(|event| event.step == "driver" && event.db_type.as_deref() == Some("h2")));
}
#[test]
fn offline_zip_import_installs_release_named_jre() {
#[tokio::test]
async fn offline_zip_import_installs_release_named_jre() {
let manager = test_manager("offline-release-jre");
let zip_path = test_path("offline-release-jre-zip").join("agents.zip");
std::fs::create_dir_all(zip_path.parent().unwrap()).unwrap();
@@ -547,6 +552,7 @@ fn offline_zip_import_installs_release_named_jre() {
let result = import_agents_from_zip(&manager, &zip_path, |event| {
events.lock().unwrap().push(event);
})
.await
.unwrap();
assert_eq!(result.jre_installed, vec![DEFAULT_JRE_KEY]);
@@ -556,35 +562,35 @@ fn offline_zip_import_installs_release_named_jre() {
assert!(events.lock().unwrap().iter().any(|event| event.step == "jre-extract"));
}
#[test]
fn offline_zip_import_preserves_existing_jre_when_archive_is_corrupt() {
#[tokio::test]
async fn offline_zip_import_preserves_existing_jre_when_archive_is_corrupt() {
let manager = test_manager("offline-corrupt-jre-preserves-existing");
let root = test_path("offline-corrupt-jre-preserves-existing-zip");
let valid_zip = root.join("valid.zip");
let corrupt_zip = root.join("corrupt.zip");
std::fs::create_dir_all(&root).unwrap();
write_offline_driver_zip_with_jre(&valid_zip, "h2", "0.2.0", "21.0.12");
import_agents_from_zip(&manager, &valid_zip, |_| {}).unwrap();
import_agents_from_zip(&manager, &valid_zip, |_| {}).await.unwrap();
let java_path = manager.jre_java_path(DEFAULT_JRE_KEY);
let original_java = std::fs::read(&java_path).unwrap();
write_offline_driver_zip_with_jre_bytes(&corrupt_zip, "h2", "0.3.0", "21.0.13", b"not-a-tar-gz".to_vec());
let err = import_agents_from_zip(&manager, &corrupt_zip, |_| {}).unwrap_err();
let err = import_agents_from_zip(&manager, &corrupt_zip, |_| {}).await.unwrap_err();
assert!(err.contains("Failed to extract JRE archive"));
assert_eq!(std::fs::read(java_path).unwrap(), original_java);
assert_eq!(manager.load_state().jre_versions.get(DEFAULT_JRE_KEY).map(String::as_str), Some("21.0.12"));
}
#[test]
fn offline_zip_import_preserves_existing_jre_when_driver_is_corrupt() {
#[tokio::test]
async fn offline_zip_import_preserves_existing_jre_when_driver_is_corrupt() {
let manager = test_manager("offline-corrupt-driver-preserves-jre");
let root = test_path("offline-corrupt-driver-preserves-jre-zip");
let valid_zip = root.join("valid.zip");
let corrupt_zip = root.join("corrupt.zip");
std::fs::create_dir_all(&root).unwrap();
write_offline_driver_zip_with_jre(&valid_zip, "h2", "0.2.0", "21.0.12");
import_agents_from_zip(&manager, &valid_zip, |_| {}).unwrap();
import_agents_from_zip(&manager, &valid_zip, |_| {}).await.unwrap();
let java_path = manager.jre_java_path(DEFAULT_JRE_KEY);
let original_java = std::fs::read(&java_path).unwrap();
@@ -596,48 +602,48 @@ fn offline_zip_import_preserves_existing_jre_when_driver_is_corrupt() {
test_jre_archive_bytes(),
b"jar".to_vec(),
);
let err = import_agents_from_zip(&manager, &corrupt_zip, |_| {}).unwrap_err();
let err = import_agents_from_zip(&manager, &corrupt_zip, |_| {}).await.unwrap_err();
assert!(err.contains("invalid or corrupt"));
assert_eq!(std::fs::read(java_path).unwrap(), original_java);
assert_eq!(manager.load_state().jre_versions.get(DEFAULT_JRE_KEY).map(String::as_str), Some("21.0.12"));
}
#[test]
fn offline_zip_import_rejects_corrupt_jar() {
#[tokio::test]
async fn offline_zip_import_rejects_corrupt_jar() {
let manager = test_manager("offline-corrupt-driver");
let zip_path = test_path("offline-corrupt-driver-zip").join("agents.zip");
std::fs::create_dir_all(zip_path.parent().unwrap()).unwrap();
write_offline_driver_zip_with_jar(&zip_path, "h2", "0.2.0", b"jar".to_vec());
let err = import_agents_from_zip(&manager, &zip_path, |_| {}).unwrap_err();
let err = import_agents_from_zip(&manager, &zip_path, |_| {}).await.unwrap_err();
assert!(err.contains("invalid or corrupt"));
assert!(!manager.driver_jar_path("h2").exists());
assert!(!manager.load_state().installed_drivers.contains_key("h2"));
}
#[test]
fn offline_zip_import_preserves_existing_driver_when_jar_is_corrupt() {
#[tokio::test]
async fn offline_zip_import_preserves_existing_driver_when_jar_is_corrupt() {
let manager = test_manager("offline-corrupt-driver-preserves-existing");
let root = test_path("offline-corrupt-driver-preserves-existing-zip");
let valid_zip = root.join("valid.zip");
let corrupt_zip = root.join("corrupt.zip");
std::fs::create_dir_all(&root).unwrap();
write_offline_driver_zip(&valid_zip, "h2", "0.2.0");
import_agents_from_zip(&manager, &valid_zip, |_| {}).unwrap();
import_agents_from_zip(&manager, &valid_zip, |_| {}).await.unwrap();
let original = std::fs::read(manager.driver_jar_path("h2")).unwrap();
write_offline_driver_zip_with_jar(&corrupt_zip, "h2", "0.3.0", b"jar".to_vec());
let err = import_agents_from_zip(&manager, &corrupt_zip, |_| {}).unwrap_err();
let err = import_agents_from_zip(&manager, &corrupt_zip, |_| {}).await.unwrap_err();
assert!(err.contains("invalid or corrupt"));
assert_eq!(std::fs::read(manager.driver_jar_path("h2")).unwrap(), original);
assert_eq!(manager.load_state().installed_drivers["h2"].version, "0.2.0");
}
#[test]
fn offline_zip_import_keeps_legacy_unversioned_jar_compatibility() {
#[tokio::test]
async fn offline_zip_import_keeps_legacy_unversioned_jar_compatibility() {
let manager = test_manager("offline-legacy-jar-zip");
let zip_path = test_path("offline-legacy-jar-zip").join("h2.zip");
std::fs::create_dir_all(zip_path.parent().unwrap()).unwrap();
@@ -662,19 +668,19 @@ fn offline_zip_import_keeps_legacy_unversioned_jar_compatibility() {
std::io::Write::write_all(&mut zip, &jar).unwrap();
zip.finish().unwrap();
import_agents_from_zip(&manager, &zip_path, |_| {}).unwrap();
import_agents_from_zip(&manager, &zip_path, |_| {}).await.unwrap();
assert_eq!(manager.load_state().installed_drivers["h2"].version, "0.1.9");
}
#[test]
fn offline_zip_import_installs_versioned_native_driver_package() {
#[tokio::test]
async fn offline_zip_import_installs_versioned_native_driver_package() {
let manager = test_manager("offline-native-driver-zip");
let zip_path = test_path("offline-native-driver-zip").join("kingbase.zip");
std::fs::create_dir_all(zip_path.parent().unwrap()).unwrap();
write_offline_native_driver_zip(&zip_path, "kingbase", "0.1.34");
let result = import_agents_from_zip(&manager, &zip_path, |_| {}).unwrap();
let result = import_agents_from_zip(&manager, &zip_path, |_| {}).await.unwrap();
assert_eq!(result.drivers_installed, vec!["kingbase"]);
assert_eq!(manager.load_state().installed_drivers["kingbase"].version, "0.1.34");
@@ -682,30 +688,30 @@ fn offline_zip_import_installs_versioned_native_driver_package() {
assert!(!manager.driver_jar_path("kingbase").exists());
}
#[test]
fn offline_zip_import_rejects_native_driver_for_another_platform() {
#[tokio::test]
async fn offline_zip_import_rejects_native_driver_for_another_platform() {
let manager = test_manager("offline-wrong-platform-native-driver-zip");
let zip_path = test_path("offline-wrong-platform-native-driver-zip").join("kingbase.zip");
std::fs::create_dir_all(zip_path.parent().unwrap()).unwrap();
let other_platform = if AgentManager::current_platform() == "windows-x64" { "linux-x64" } else { "windows-x64" };
write_offline_native_driver_zip_for_platform(&zip_path, "kingbase", "0.1.34", other_platform);
let err = import_agents_from_zip(&manager, &zip_path, |_| {}).unwrap_err();
let err = import_agents_from_zip(&manager, &zip_path, |_| {}).await.unwrap_err();
assert!(err.contains("no drivers compatible"));
assert!(err.contains(AgentManager::current_platform()));
assert!(!manager.is_driver_installed("kingbase"));
}
#[test]
fn offline_zip_import_preserves_existing_native_driver_when_binary_is_invalid() {
#[tokio::test]
async fn offline_zip_import_preserves_existing_native_driver_when_binary_is_invalid() {
let manager = test_manager("offline-invalid-native-preserves-existing");
let root = test_path("offline-invalid-native-preserves-existing-zip");
let valid_zip = root.join("valid.zip");
let invalid_zip = root.join("invalid.zip");
std::fs::create_dir_all(&root).unwrap();
write_offline_native_driver_zip(&valid_zip, "kingbase", "0.1.34");
import_agents_from_zip(&manager, &valid_zip, |_| {}).unwrap();
import_agents_from_zip(&manager, &valid_zip, |_| {}).await.unwrap();
let original = std::fs::read(manager.driver_native_path("kingbase")).unwrap();
write_offline_native_driver_zip_with_bytes(
@@ -715,7 +721,7 @@ fn offline_zip_import_preserves_existing_native_driver_when_binary_is_invalid()
AgentManager::current_platform(),
b"not-a-native-agent".to_vec(),
);
let err = import_agents_from_zip(&manager, &invalid_zip, |_| {}).unwrap_err();
let err = import_agents_from_zip(&manager, &invalid_zip, |_| {}).await.unwrap_err();
assert!(err.contains("not a"));
assert_eq!(std::fs::read(manager.driver_native_path("kingbase")).unwrap(), original);
@@ -763,15 +769,15 @@ fn offline_zip_import_rejects_unsafe_entry_path() {
assert!(err.contains("unsafe path"));
}
#[test]
fn offline_zip_import_prefers_native_artifact_over_java_fallback() {
#[tokio::test]
async fn offline_zip_import_prefers_native_artifact_over_java_fallback() {
let manager = test_manager("offline-native-preferred");
let zip_path = test_path("offline-native-preferred-zip").join("kingbase.zip");
std::fs::create_dir_all(zip_path.parent().unwrap()).unwrap();
write_offline_hybrid_driver_zip(&zip_path, "kingbase", "0.1.34");
let plan = inspect_offline_zip(&zip_path).unwrap();
let result = import_agents_from_zip(&manager, &zip_path, |_| {}).unwrap();
let result = import_agents_from_zip(&manager, &zip_path, |_| {}).await.unwrap();
assert_eq!(plan.driver_keys, vec!["kingbase"]);
assert_eq!(result.drivers_installed, vec!["kingbase"]);
@@ -779,6 +785,36 @@ fn offline_zip_import_prefers_native_artifact_over_java_fallback() {
assert!(!manager.driver_jar_path("kingbase").exists());
}
#[tokio::test]
async fn offline_zip_import_progress_carries_real_db_type_not_label() {
// Verify that the AgentProgressEvent.db_type field carries the real
// database key (e.g. "kingbase") rather than the display label
// (e.g. "KingbaseES"), so the frontend per-driver progress routing
// matches.
let manager = test_manager("offline-progress-db-type");
let zip_path = test_path("offline-progress-db-type-zip").join("kingbase.zip");
std::fs::create_dir_all(zip_path.parent().unwrap()).unwrap();
write_offline_native_driver_zip(&zip_path, "kingbase", "0.1.34");
let events = std::sync::Mutex::new(Vec::new());
import_agents_from_zip(&manager, &zip_path, |event| {
events.lock().unwrap().push(event);
})
.await
.unwrap();
let events = events.lock().unwrap();
let driver_events: Vec<_> = events.iter().filter(|e| e.step == "driver").collect();
assert!(!driver_events.is_empty(), "expected at least one driver progress event");
for event in &driver_events {
assert_eq!(
event.db_type.as_deref(),
Some("kingbase"),
"db_type must be the real key 'kingbase', not the display label"
);
}
}
fn write_offline_driver_zip(path: &std::path::Path, db_type: &str, version: &str) {
write_offline_driver_zip_with_jar(path, db_type, version, test_agent_jar_bytes());
}