25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。
TypeScript aicliclickhousedatabasedatabase-clientdatabase-managementdockerguimcpmongodbmysqlpostgresqlredisrustsql-serversqlitetaurivue
use std::collections::{HashMap, HashSet};
use std::path::Path;
use std::sync::Arc;
use futures::{stream, StreamExt};
use sha2::{Digest, Sha256};
use crate::connection::AppState;
use crate::nacos::archive::{decode_config_archive, encode_config_archive, MAX_ARCHIVE_BYTES};
use crate::nacos::port::NacosAdmin;
use crate::nacos::search::{begin_operation, finish_operation};
use crate::nacos::service::{ensure_connection_writable, get_admin};
use crate::nacos::types::{
NacosBatchItemResult, NacosBatchPreview, NacosBatchPreviewDiff, NacosBatchPreviewItem, NacosBatchReport,
NacosConfigItem, NacosConfigKey, NacosConfigSelectionScope, NacosConfigSelector, NacosConfigTransferRequest,
NacosConfigUpsert, NacosConflictPolicy,
};
const PAGE_SIZE: u32 = 500;
const DETAIL_CONCURRENCY: usize = 8;
pub async fn export_config_archive(
admin: Arc<dyn NacosAdmin>,
selector: NacosConfigSelector,
destination: &Path,
) -> Result<NacosBatchReport, String> {
let configs = resolve_selector(admin, &selector).await?;
let (configs, bytes) = tokio::task::spawn_blocking(move || {
let bytes = encode_config_archive(&configs)?;
Ok::<_, String>((configs, bytes))
})
.await
.map_err(|error| format!("Failed to encode Nacos configuration archive: {error}"))??;
tokio::fs::write(destination, bytes)
.await
.map_err(|error| format!("Failed to write Nacos configuration archive {}: {error}", destination.display()))?;
let items = configs
.iter()
.map(|config| NacosBatchItemResult {
namespace: config.namespace.clone(),
group: config.group.clone(),
data_id: config.data_id.clone(),
status: "exported".to_string(),
message: None,
})
.collect();
Ok(NacosBatchReport {
operation_id: uuid::Uuid::new_v4().to_string(),
plan_hash: None,
total: configs.len() as u64,
created: 0,
overwritten: 0,
skipped: 0,
failed: 0,
aborted: false,
partial: false,
cancelled: false,
items,
})
}
pub async fn preview_import(
admin: Arc<dyn NacosAdmin>,
target_namespace: &str,
archive_path: &Path,
) -> Result<NacosBatchPreview, String> {
let configs = read_archive(archive_path, target_namespace).await?;
preview_configs(admin, &configs, false).await
}
pub async fn apply_import(
admin: Arc<dyn NacosAdmin>,
target_namespace: &str,
archive_path: &Path,
operation_id: &str,
plan_hash: &str,
policy: &NacosConflictPolicy,
) -> Result<NacosBatchReport, String> {
let configs = read_archive(archive_path, target_namespace).await?;
apply_configs(admin, configs, operation_id, plan_hash, policy).await
}
pub async fn preview_transfer(
source_admin: Arc<dyn NacosAdmin>,
target_admin: Arc<dyn NacosAdmin>,
request: &NacosConfigTransferRequest,
) -> Result<NacosBatchPreview, String> {
let configs = transfer_configs(source_admin, request).await?;
preview_configs(target_admin, &configs, true).await
}
pub async fn apply_transfer(
source_admin: Arc<dyn NacosAdmin>,
target_admin: Arc<dyn NacosAdmin>,
request: &NacosConfigTransferRequest,
plan_hash: &str,
) -> Result<NacosBatchReport, String> {
let configs = transfer_configs(source_admin, request).await?;
apply_configs(target_admin, configs, &request.operation_id, plan_hash, &request.conflict_policy).await
}
pub async fn nacos_export_config_archive_core(
state: &AppState,
conn_id: &str,
selector: NacosConfigSelector,
destination: &Path,
) -> Result<NacosBatchReport, String> {
let admin = get_admin(state, conn_id).await?;
export_config_archive(admin, selector, destination).await
}
pub async fn nacos_preview_config_import_core(
state: &AppState,
conn_id: &str,
target_namespace: &str,
archive_path: &Path,
) -> Result<NacosBatchPreview, String> {
ensure_connection_writable(state, conn_id, "Import Nacos configurations").await?;
let admin = get_admin(state, conn_id).await?;
preview_import(admin, target_namespace, archive_path).await
}
pub async fn nacos_apply_config_import_core(
state: &AppState,
conn_id: &str,
target_namespace: &str,
archive_path: &Path,
operation_id: &str,
plan_hash: &str,
policy: &NacosConflictPolicy,
) -> Result<NacosBatchReport, String> {
ensure_connection_writable(state, conn_id, "Import Nacos configurations").await?;
let admin = get_admin(state, conn_id).await?;
apply_import(admin, target_namespace, archive_path, operation_id, plan_hash, policy).await
}
pub async fn nacos_preview_config_transfer_core(
state: &AppState,
request: &NacosConfigTransferRequest,
) -> Result<NacosBatchPreview, String> {
ensure_connection_writable(state, &request.target_connection_id, "Copy Nacos configurations").await?;
let source_admin = get_admin(state, &request.source_connection_id).await?;
let target_admin = get_admin(state, &request.target_connection_id).await?;
preview_transfer(source_admin, target_admin, request).await
}
pub async fn nacos_apply_config_transfer_core(
state: &AppState,
request: &NacosConfigTransferRequest,
plan_hash: &str,
) -> Result<NacosBatchReport, String> {
ensure_connection_writable(state, &request.target_connection_id, "Copy Nacos configurations").await?;
let source_admin = get_admin(state, &request.source_connection_id).await?;
let target_admin = get_admin(state, &request.target_connection_id).await?;
apply_transfer(source_admin, target_admin, request, plan_hash).await
}
async fn transfer_configs(
source_admin: Arc<dyn NacosAdmin>,
request: &NacosConfigTransferRequest,
) -> Result<Vec<NacosConfigUpsert>, String> {
let target_group = request.target_group.as_deref().map(str::trim).filter(|group| !group.is_empty());
let mut data_id_mappings = validated_data_id_mappings(request)?;
let source = resolve_selector(source_admin, &request.source).await?;
let configs = source
.into_iter()
.map(|config| {
let source_key = (config.group.clone(), config.data_id.clone());
let content = config
.content
.ok_or_else(|| format!("Nacos configuration {}/{} has no content", config.group, config.data_id))?;
let group = target_group.map(str::to_string).unwrap_or(config.group);
let data_id = data_id_mappings.remove(&source_key).unwrap_or(config.data_id);
Ok(NacosConfigUpsert {
namespace: Some(request.target_namespace.clone()),
data_id,
group,
content,
config_type: config.config_type,
app_name: config.app_name,
desc: config.desc,
tags: config.tags,
cas_md5: None,
})
})
.collect::<Result<Vec<_>, String>>()?;
if let Some(((group, data_id), _)) = data_id_mappings.into_iter().next() {
return Err(format!(
"Nacos configuration {group}/{data_id} no longer exists in the selected source configurations"
));
}
let mut target_keys = HashSet::new();
for config in &configs {
let namespace = config.namespace.as_deref().unwrap_or_default();
let key = (namespace, config.group.as_str(), config.data_id.as_str());
if !target_keys.insert(key) {
return Err(format!(
"Multiple selected Nacos configurations map to the same target key {namespace}/{}/{}",
config.group, config.data_id
));
}
}
Ok(configs)
}
fn validated_data_id_mappings(
request: &NacosConfigTransferRequest,
) -> Result<HashMap<(String, String), String>, String> {
if request.data_id_mappings.is_empty() {
return Ok(HashMap::new());
}
if !matches!(request.source.scope, NacosConfigSelectionScope::Selected) {
return Err("Nacos Data ID mappings are only supported for selected configurations".to_string());
}
let selected_keys: HashSet<_> =
request.source.keys.iter().map(|key| (key.group.as_str(), key.data_id.as_str())).collect();
let mut mappings = HashMap::with_capacity(request.data_id_mappings.len());
for mapping in &request.data_id_mappings {
let source_key = (mapping.source_group.as_str(), mapping.source_data_id.as_str());
if !selected_keys.contains(&source_key) {
return Err(format!(
"Nacos configuration {}/{} is not selected for Data ID mapping",
mapping.source_group, mapping.source_data_id
));
}
let target_data_id = mapping.target_data_id.trim();
if target_data_id.is_empty() {
return Err(format!(
"Nacos configuration {}/{} target Data ID cannot be blank",
mapping.source_group, mapping.source_data_id
));
}
if mappings
.insert((mapping.source_group.clone(), mapping.source_data_id.clone()), target_data_id.to_string())
.is_some()
{
return Err(format!(
"Nacos configuration {}/{} has multiple target Data ID mappings",
mapping.source_group, mapping.source_data_id
));
}
}
Ok(mappings)
}
async fn resolve_selector(
admin: Arc<dyn NacosAdmin>,
selector: &NacosConfigSelector,
) -> Result<Vec<NacosConfigItem>, String> {
let keys = match selector.scope {
NacosConfigSelectionScope::Selected => selector
.keys
.iter()
.map(|key| NacosConfigKey {
namespace: Some(selector.namespace.clone()),
data_id: key.data_id.clone(),
group: key.group.clone(),
})
.collect(),
NacosConfigSelectionScope::Filtered | NacosConfigSelectionScope::Namespace => {
let mut query = selector.query.clone().unwrap_or(crate::nacos::types::NacosConfigQuery {
namespace: None,
group: None,
group_contains: false,
data_id: None,
app_name: None,
search: None,
page_no: None,
page_size: None,
});
query.namespace = Some(selector.namespace.clone());
if matches!(selector.scope, NacosConfigSelectionScope::Namespace) {
query.group = None;
query.data_id = None;
query.app_name = None;
query.search = None;
}
let mut keys = Vec::new();
let mut seen = std::collections::HashSet::new();
let mut page_no = 1;
loop {
query.page_no = Some(page_no);
query.page_size = Some(PAGE_SIZE);
let page = admin.list_configs(query.clone()).await?;
let total = page.total_count;
let empty = page.items.is_empty();
let before = keys.len();
keys.extend(page.items.into_iter().filter_map(|item| {
let key = NacosConfigKey {
namespace: Some(selector.namespace.clone()),
data_id: item.data_id,
group: item.group,
};
seen.insert((key.namespace.clone(), key.group.clone(), key.data_id.clone())).then_some(key)
}));
if empty || total == 0 || keys.len() as u64 >= total {
break;
}
if keys.len() == before {
return Err(
"Nacos configuration pagination made no progress; the server repeated a page".to_string()
);
}
page_no = page_no
.checked_add(1)
.ok_or_else(|| "Nacos configuration pagination exceeded the supported page range".to_string())?;
}
keys
}
};
let mut seen = std::collections::HashSet::new();
let keys: Vec<_> = keys
.into_iter()
.filter(|key| seen.insert((key.namespace.clone(), key.group.clone(), key.data_id.clone())))
.collect();
let details = stream::iter(keys)
.map(|key| {
let admin = admin.clone();
async move { admin.get_config(key).await }
})
.buffer_unordered(DETAIL_CONCURRENCY)
.collect::<Vec<_>>()
.await;
let mut configs = details.into_iter().collect::<Result<Vec<_>, _>>()?;
configs.sort_by(|left, right| {
(&left.namespace, &left.group, &left.data_id).cmp(&(&right.namespace, &right.group, &right.data_id))
});
Ok(configs)
}
async fn preview_configs(
admin: Arc<dyn NacosAdmin>,
configs: &[NacosConfigUpsert],
include_diff: bool,
) -> Result<NacosBatchPreview, String> {
let mut items = Vec::with_capacity(configs.len());
let mut target_snapshots = Vec::with_capacity(configs.len());
let mut created = 0;
let mut conflicts = 0;
for config in configs {
let target = existing_config(admin.as_ref(), config).await?;
let status = if target.is_some() {
conflicts += 1;
"conflict"
} else {
created += 1;
"create"
};
let diff = if include_diff {
target.as_ref().and_then(|target| {
target.content.as_ref().map(|before_content| NacosBatchPreviewDiff {
before_content: before_content.clone(),
after_content: config.content.clone(),
format: config.config_type.clone(),
})
})
} else {
None
};
target_snapshots.push(target);
items.push(NacosBatchPreviewItem {
namespace: config.namespace.clone().unwrap_or_default(),
group: config.group.clone(),
data_id: config.data_id.clone(),
status: status.to_string(),
message: None,
diff,
});
}
Ok(NacosBatchPreview {
plan_hash: plan_hash(configs, &target_snapshots),
total: configs.len() as u64,
created,
conflicts,
invalid: 0,
items,
})
}
async fn apply_configs(
admin: Arc<dyn NacosAdmin>,
configs: Vec<NacosConfigUpsert>,
operation_id: &str,
expected_plan_hash: &str,
policy: &NacosConflictPolicy,
) -> Result<NacosBatchReport, String> {
let preview = preview_configs(admin.clone(), &configs, false).await?;
if preview.plan_hash != expected_plan_hash {
return Err(
"NACOS_ERROR[stalePreview]: Nacos import/copy preview is stale; preview again before applying".to_string()
);
}
if matches!(policy, NacosConflictPolicy::Abort) && preview.conflicts > 0 {
return Ok(NacosBatchReport {
operation_id: operation_id.to_string(),
plan_hash: Some(preview.plan_hash),
total: configs.len() as u64,
created: 0,
overwritten: 0,
skipped: configs.len() as u64,
failed: 0,
aborted: true,
partial: false,
cancelled: false,
items: preview
.items
.into_iter()
.map(|item| NacosBatchItemResult {
namespace: item.namespace,
group: item.group,
data_id: item.data_id,
status: "aborted".to_string(),
message: Some("Conflict policy ABORT prevented all writes".to_string()),
})
.collect(),
});
}
let token = begin_operation(operation_id)?;
struct Guard(String);
impl Drop for Guard {
fn drop(&mut self) {
finish_operation(&self.0);
}
}
let _guard = Guard(operation_id.to_string());
let mut report = NacosBatchReport {
operation_id: operation_id.to_string(),
plan_hash: Some(preview.plan_hash),
total: configs.len() as u64,
created: 0,
overwritten: 0,
skipped: 0,
failed: 0,
aborted: false,
partial: false,
cancelled: false,
items: Vec::with_capacity(configs.len()),
};
for (config, preview_item) in configs.into_iter().zip(preview.items) {
if token.is_cancelled() {
report.cancelled = true;
break;
}
let conflict = preview_item.status == "conflict";
if conflict && matches!(policy, NacosConflictPolicy::Skip) {
report.skipped += 1;
report.items.push(batch_result(&config, "skipped", None));
continue;
}
match admin.publish_config(config.clone()).await {
Ok(()) if conflict => {
report.overwritten += 1;
report.items.push(batch_result(&config, "overwritten", None));
}
Ok(()) => {
report.created += 1;
report.items.push(batch_result(&config, "created", None));
}
Err(error) => {
report.failed += 1;
report.items.push(batch_result(&config, "failed", Some(error)));
}
}
}
report.partial =
report.cancelled || report.failed > 0 || report.created + report.overwritten + report.skipped < report.total;
Ok(report)
}
async fn existing_config(
admin: &dyn NacosAdmin,
config: &NacosConfigUpsert,
) -> Result<Option<NacosConfigItem>, String> {
let namespace = config.namespace.clone().unwrap_or_default();
let page = admin
.list_configs(crate::nacos::types::NacosConfigQuery {
namespace: Some(namespace.clone()),
group: Some(config.group.clone()),
group_contains: false,
data_id: Some(config.data_id.clone()),
app_name: None,
search: None,
page_no: Some(1),
page_size: Some(PAGE_SIZE),
})
.await?;
let exists = page.items.iter().any(|item| item.group == config.group && item.data_id == config.data_id);
if !exists {
return Ok(None);
}
admin
.get_config(NacosConfigKey {
namespace: Some(namespace),
data_id: config.data_id.clone(),
group: config.group.clone(),
})
.await
.map(Some)
}
fn plan_hash(configs: &[NacosConfigUpsert], targets: &[Option<NacosConfigItem>]) -> String {
let mut digest = Sha256::new();
digest.update(b"dbx-nacos-batch-plan-v1");
let mut entries = configs.iter().zip(targets.iter()).collect::<Vec<_>>();
entries.sort_by(|(left, _), (right, _)| {
(left.namespace.as_deref().unwrap_or_default(), left.group.as_str(), left.data_id.as_str()).cmp(&(
right.namespace.as_deref().unwrap_or_default(),
right.group.as_str(),
right.data_id.as_str(),
))
});
for (config, target) in entries {
hash_field(&mut digest, config.namespace.as_deref().unwrap_or_default());
hash_field(&mut digest, &config.group);
hash_field(&mut digest, &config.data_id);
hash_field(&mut digest, &config.content);
hash_field(&mut digest, config.config_type.as_deref().unwrap_or_default());
hash_field(&mut digest, config.app_name.as_deref().unwrap_or_default());
hash_field(&mut digest, config.desc.as_deref().unwrap_or_default());
hash_field(&mut digest, config.tags.as_deref().unwrap_or_default());
if let Some(target) = target {
digest.update([1]);
hash_field(&mut digest, target.md5.as_deref().unwrap_or_default());
hash_field(&mut digest, target.content.as_deref().unwrap_or_default());
} else {
digest.update([0]);
}
}
digest.finalize().iter().map(|byte| format!("{byte:02x}")).collect()
}
fn hash_field(digest: &mut Sha256, value: &str) {
digest.update((value.len() as u64).to_be_bytes());
digest.update(value.as_bytes());
}
fn batch_result(config: &NacosConfigUpsert, status: &str, message: Option<String>) -> NacosBatchItemResult {
NacosBatchItemResult {
namespace: config.namespace.clone().unwrap_or_default(),
group: config.group.clone(),
data_id: config.data_id.clone(),
status: status.to_string(),
message,
}
}
async fn read_archive(path: &Path, target_namespace: &str) -> Result<Vec<NacosConfigUpsert>, String> {
let path = path.to_path_buf();
let target_namespace = target_namespace.to_string();
tokio::task::spawn_blocking(move || {
let metadata = std::fs::metadata(&path)
.map_err(|error| format!("Failed to inspect Nacos archive {}: {error}", path.display()))?;
if metadata.len() > MAX_ARCHIVE_BYTES {
return Err("Nacos archive exceeds the 100 MiB limit".to_string());
}
let bytes = std::fs::read(&path)
.map_err(|error| format!("Failed to read Nacos archive {}: {error}", path.display()))?;
decode_config_archive(&bytes, &target_namespace)
})
.await
.map_err(|error| format!("Failed to process Nacos configuration archive: {error}"))?
}
#[cfg(test)]
mod tests {
use std::collections::{HashMap, HashSet};
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::RwLock;
use async_trait::async_trait;
use super::*;
use crate::nacos::types::*;
#[derive(Default)]
struct MockAdmin {
configs: RwLock<HashMap<(String, String, String), NacosConfigItem>>,
failed_data_ids: RwLock<HashSet<String>>,
publish_count: AtomicUsize,
}
impl MockAdmin {
fn insert(&self, item: NacosConfigItem) {
self.configs
.write()
.unwrap()
.insert((item.namespace.clone(), item.group.clone(), item.data_id.clone()), item);
}
fn fail_publish(&self, data_id: &str) {
self.failed_data_ids.write().unwrap().insert(data_id.to_string());
}
}
#[async_trait]
impl NacosAdmin for MockAdmin {
async fn test_connection(&self) -> Result<NacosConnectionInfo, String> {
Err("unused".to_string())
}
async fn list_namespaces(&self) -> Result<Vec<NacosNamespaceInfo>, String> {
Err("unused".to_string())
}
async fn create_namespace(&self, _: NacosNamespaceCreate) -> Result<(), String> {
Err("unused".to_string())
}
async fn update_namespace(&self, _: NacosNamespaceUpdate) -> Result<(), String> {
Err("unused".to_string())
}
async fn list_configs(&self, query: NacosConfigQuery) -> Result<NacosConfigList, String> {
let namespace = query.namespace.unwrap_or_default();
let items: Vec<_> = self
.configs
.read()
.unwrap()
.values()
.filter(|item| item.namespace == namespace)
.filter(|item| query.group.as_ref().is_none_or(|group| item.group == *group))
.filter(|item| query.data_id.as_ref().is_none_or(|data_id| item.data_id == *data_id))
.cloned()
.collect();
Ok(NacosConfigList {
page_no: query.page_no.unwrap_or(1),
page_size: query.page_size.unwrap_or(PAGE_SIZE),
total_count: items.len() as u64,
items,
})
}
async fn search_config_content_page(
&self,
_: &str,
_: &str,
_: u32,
_: u32,
) -> Result<Option<NacosConfigList>, String> {
Err("unused".to_string())
}
async fn get_config(&self, key: NacosConfigKey) -> Result<NacosConfigItem, String> {
self.configs
.read()
.unwrap()
.get(&(key.namespace.unwrap_or_default(), key.group, key.data_id))
.cloned()
.ok_or_else(|| "not found".to_string())
}
async fn publish_config(&self, req: NacosConfigUpsert) -> Result<(), String> {
if self.failed_data_ids.read().unwrap().contains(&req.data_id) {
return Err("simulated publish failure".to_string());
}
self.publish_count.fetch_add(1, Ordering::SeqCst);
let namespace = req.namespace.unwrap_or_default();
self.insert(NacosConfigItem {
data_id: req.data_id,
group: req.group,
namespace,
app_name: req.app_name,
desc: req.desc,
tags: req.tags,
config_type: req.config_type,
md5: None,
encrypted_data_key: None,
content: Some(req.content),
});
Ok(())
}
async fn delete_config(&self, _: NacosConfigKey) -> Result<(), String> {
Err("unused".to_string())
}
async fn list_config_history(&self, _: NacosConfigHistoryQuery) -> Result<NacosConfigHistoryList, String> {
Err("unused".to_string())
}
async fn get_config_history(&self, _: NacosConfigHistoryKey) -> Result<NacosConfigItem, String> {
Err("unused".to_string())
}
async fn rollback_config(&self, _: NacosConfigRollbackRequest) -> Result<(), String> {
Err("unused".to_string())
}
async fn get_rnacos_console_captcha(&self) -> Result<NacosRNacosConsoleCaptcha, String> {
Err("unused".to_string())
}
async fn login_rnacos_console(&self, _: Option<String>) -> Result<(), String> {
Err("unused".to_string())
}
async fn list_services(&self, _: NacosServiceQuery) -> Result<NacosServiceList, String> {
Err("unused".to_string())
}
async fn get_service(&self, _: NacosServiceQuery) -> Result<NacosServiceDetail, String> {
Err("unused".to_string())
}
async fn create_service(&self, _: NacosServiceUpsert) -> Result<(), String> {
Err("unused".to_string())
}
async fn update_service(&self, _: NacosServiceUpsert) -> Result<(), String> {
Err("unused".to_string())
}
async fn delete_service(&self, _: NacosServiceQuery) -> Result<(), String> {
Err("unused".to_string())
}
async fn list_instances(&self, _: NacosInstanceQuery) -> Result<Vec<NacosInstanceInfo>, String> {
Err("unused".to_string())
}
async fn update_instance(&self, _: NacosInstanceUpdateRequest) -> Result<(), String> {
Err("unused".to_string())
}
async fn register_instance(&self, _: NacosInstanceRegistration) -> Result<(), String> {
Err("unused".to_string())
}
async fn deregister_instance(&self, _: NacosInstanceRef) -> Result<(), String> {
Err("unused".to_string())
}
async fn get_dashboard(&self, _: NacosDashboardQuery) -> Result<NacosDashboardSnapshot, String> {
Err("unused".to_string())
}
async fn raw_request(&self, _: NacosRawRequest) -> Result<NacosRawResponse, String> {
Err("unused".to_string())
}
}
fn upsert(data_id: &str, content: &str) -> NacosConfigUpsert {
NacosConfigUpsert {
namespace: Some("target".to_string()),
data_id: data_id.to_string(),
group: "DEFAULT_GROUP".to_string(),
content: content.to_string(),
config_type: Some("text".to_string()),
app_name: None,
desc: None,
tags: None,
cas_md5: None,
}
}
fn existing(data_id: &str, content: &str) -> NacosConfigItem {
NacosConfigItem {
data_id: data_id.to_string(),
group: "DEFAULT_GROUP".to_string(),
namespace: "target".to_string(),
app_name: None,
desc: None,
tags: None,
config_type: Some("text".to_string()),
md5: Some(format!("md5-{content}")),
encrypted_data_key: None,
content: Some(content.to_string()),
}
}
async fn preview_hash(admin: Arc<MockAdmin>, configs: &[NacosConfigUpsert]) -> String {
preview_configs(admin, configs, false).await.unwrap().plan_hash
}
#[tokio::test]
async fn stale_preview_is_rejected_before_any_publish() {
let admin = Arc::new(MockAdmin::default());
let configs = vec![upsert("app", "new")];
let hash = preview_hash(admin.clone(), &configs).await;
admin.insert(existing("app", "concurrent"));
let error = apply_configs(
admin.clone(),
configs,
&uuid::Uuid::new_v4().to_string(),
&hash,
&NacosConflictPolicy::Overwrite,
)
.await
.unwrap_err();
assert!(error.contains("stalePreview"));
assert_eq!(admin.publish_count.load(Ordering::SeqCst), 0);
}
#[tokio::test]
async fn apply_accepts_preview_when_concurrent_source_reads_complete_in_another_order() {
let admin = Arc::new(MockAdmin::default());
let preview_configs = vec![upsert("first", "one"), upsert("second", "two")];
let hash = preview_hash(admin.clone(), &preview_configs).await;
// `resolve_selector` fetches details concurrently, so the same selected
// configurations can reach apply in a different completion order.
let apply_configs_in_completion_order = vec![upsert("second", "two"), upsert("first", "one")];
let report = apply_configs(
admin.clone(),
apply_configs_in_completion_order,
&uuid::Uuid::new_v4().to_string(),
&hash,
&NacosConflictPolicy::Overwrite,
)
.await
.unwrap();
assert_eq!(report.created, 2);
assert_eq!(admin.publish_count.load(Ordering::SeqCst), 2);
}
#[tokio::test]
async fn abort_policy_writes_nothing_when_any_conflict_exists() {
let admin = Arc::new(MockAdmin::default());
admin.insert(existing("conflict", "old"));
let configs = vec![upsert("conflict", "new"), upsert("fresh", "value")];
let hash = preview_hash(admin.clone(), &configs).await;
let report = apply_configs(
admin.clone(),
configs,
&uuid::Uuid::new_v4().to_string(),
&hash,
&NacosConflictPolicy::Abort,
)
.await
.unwrap();
assert!(report.aborted);
assert_eq!(report.skipped, 2);
assert_eq!(admin.publish_count.load(Ordering::SeqCst), 0);
}
#[tokio::test]
async fn skip_and_overwrite_policies_report_per_item_outcomes() {
let skip_admin = Arc::new(MockAdmin::default());
skip_admin.insert(existing("conflict", "old"));
let configs = vec![upsert("conflict", "new"), upsert("fresh", "value")];
let skip_hash = preview_hash(skip_admin.clone(), &configs).await;
let skipped = apply_configs(
skip_admin.clone(),
configs.clone(),
&uuid::Uuid::new_v4().to_string(),
&skip_hash,
&NacosConflictPolicy::Skip,
)
.await
.unwrap();
assert_eq!((skipped.created, skipped.skipped, skipped.overwritten), (1, 1, 0));
assert_eq!(skip_admin.publish_count.load(Ordering::SeqCst), 1);
let overwrite_admin = Arc::new(MockAdmin::default());
overwrite_admin.insert(existing("conflict", "old"));
let overwrite_hash = preview_hash(overwrite_admin.clone(), &configs).await;
let overwritten = apply_configs(
overwrite_admin.clone(),
configs,
&uuid::Uuid::new_v4().to_string(),
&overwrite_hash,
&NacosConflictPolicy::Overwrite,
)
.await
.unwrap();
assert_eq!((overwritten.created, overwritten.skipped, overwritten.overwritten), (1, 0, 1));
assert_eq!(overwrite_admin.publish_count.load(Ordering::SeqCst), 2);
}
#[tokio::test]
async fn publish_failure_keeps_successes_and_marks_report_partial() {
let admin = Arc::new(MockAdmin::default());
admin.fail_publish("bad");
let configs = vec![upsert("good", "value"), upsert("bad", "value")];
let hash = preview_hash(admin.clone(), &configs).await;
let report = apply_configs(
admin.clone(),
configs,
&uuid::Uuid::new_v4().to_string(),
&hash,
&NacosConflictPolicy::Overwrite,
)
.await
.unwrap();
assert_eq!((report.created, report.failed), (1, 1));
assert!(report.partial);
assert_eq!(admin.publish_count.load(Ordering::SeqCst), 1);
}
fn transfer_request(target_group: Option<&str>) -> NacosConfigTransferRequest {
NacosConfigTransferRequest {
operation_id: "op".to_string(),
source_connection_id: "source".to_string(),
target_connection_id: "target".to_string(),
source: NacosConfigSelector {
namespace: "source-ns".to_string(),
scope: NacosConfigSelectionScope::Selected,
keys: vec![NacosConfigKey {
namespace: Some("source-ns".to_string()),
data_id: "app".to_string(),
group: "SOURCE_GROUP".to_string(),
}],
query: None,
},
target_namespace: "target-ns".to_string(),
target_group: target_group.map(str::to_string),
data_id_mappings: Vec::new(),
conflict_policy: NacosConflictPolicy::default(),
}
}
fn data_id_mapping(source_group: &str, source_data_id: &str, target_data_id: &str) -> NacosConfigDataIdMapping {
NacosConfigDataIdMapping {
source_group: source_group.to_string(),
source_data_id: source_data_id.to_string(),
target_data_id: target_data_id.to_string(),
}
}
fn insert_source_config(admin: &MockAdmin, data_id: &str, group: &str, content: &str) {
admin.insert(NacosConfigItem {
data_id: data_id.to_string(),
group: group.to_string(),
namespace: "source-ns".to_string(),
app_name: None,
desc: None,
tags: None,
config_type: Some("text".to_string()),
md5: None,
encrypted_data_key: None,
content: Some(content.to_string()),
});
}
fn source_admin_with_config() -> Arc<MockAdmin> {
let admin = Arc::new(MockAdmin::default());
insert_source_config(&admin, "app", "SOURCE_GROUP", "value");
admin
}
#[tokio::test]
async fn transfer_without_target_group_keeps_the_source_group() {
let source_admin = source_admin_with_config();
let configs = transfer_configs(source_admin, &transfer_request(None)).await.unwrap();
assert_eq!(configs.len(), 1);
assert_eq!(configs[0].group, "SOURCE_GROUP");
}
#[tokio::test]
async fn transfer_with_target_group_overrides_the_source_group() {
let source_admin = source_admin_with_config();
let configs = transfer_configs(source_admin, &transfer_request(Some(" TARGET_GROUP "))).await.unwrap();
assert_eq!(configs.len(), 1);
assert_eq!(configs[0].group, "TARGET_GROUP");
}
#[tokio::test]
async fn transfer_rejects_target_key_collisions_after_group_override() {
let source_admin = source_admin_with_config();
source_admin.insert(NacosConfigItem {
data_id: "app".to_string(),
group: "OTHER_GROUP".to_string(),
namespace: "source-ns".to_string(),
app_name: None,
desc: None,
tags: None,
config_type: Some("text".to_string()),
md5: None,
encrypted_data_key: None,
content: Some("other value".to_string()),
});
let mut request = transfer_request(Some("TARGET_GROUP"));
request.source.keys.push(NacosConfigKey {
namespace: Some("source-ns".to_string()),
data_id: "app".to_string(),
group: "OTHER_GROUP".to_string(),
});
let error = transfer_configs(source_admin, &request).await.unwrap_err();
assert!(error.contains("target-ns/TARGET_GROUP/app"), "unexpected error: {error}");
}
#[tokio::test]
async fn transfer_with_blank_target_group_keeps_the_source_group() {
let source_admin = source_admin_with_config();
let configs = transfer_configs(source_admin, &transfer_request(Some(" "))).await.unwrap();
assert_eq!(configs.len(), 1);
assert_eq!(configs[0].group, "SOURCE_GROUP");
}
#[tokio::test]
async fn transfer_with_data_id_mapping_uses_the_trimmed_target_data_id() {
let source_admin = source_admin_with_config();
let mut request = transfer_request(None);
request.data_id_mappings = vec![data_id_mapping("SOURCE_GROUP", "app", " renamed.yaml ")];
let configs = transfer_configs(source_admin, &request).await.unwrap();
assert_eq!(configs.len(), 1);
assert_eq!(configs[0].data_id, "renamed.yaml");
}
#[tokio::test]
async fn transfer_with_multiple_selected_configs_maps_only_the_edited_data_id() {
let source_admin = source_admin_with_config();
insert_source_config(&source_admin, "worker", "OTHER_GROUP", "worker value");
let mut request = transfer_request(None);
request.source.keys.push(NacosConfigKey {
namespace: Some("source-ns".to_string()),
data_id: "worker".to_string(),
group: "OTHER_GROUP".to_string(),
});
request.data_id_mappings = vec![data_id_mapping("OTHER_GROUP", "worker", "worker-prod")];
let configs = transfer_configs(source_admin, &request).await.unwrap();
assert_eq!(configs.len(), 2);
assert!(configs.iter().any(|config| config.group == "SOURCE_GROUP" && config.data_id == "app"));
assert!(configs.iter().any(|config| config.group == "OTHER_GROUP" && config.data_id == "worker-prod"));
}
#[tokio::test]
async fn transfer_rejects_blank_data_id_mapping() {
let source_admin = source_admin_with_config();
let mut request = transfer_request(None);
request.data_id_mappings = vec![data_id_mapping("SOURCE_GROUP", "app", " ")];
let error = transfer_configs(source_admin, &request).await.unwrap_err();
assert!(error.contains("target Data ID cannot be blank"), "unexpected error: {error}");
}
#[tokio::test]
async fn transfer_rejects_duplicate_mappings_for_the_same_source_key() {
let source_admin = source_admin_with_config();
let mut request = transfer_request(None);
request.data_id_mappings =
vec![data_id_mapping("SOURCE_GROUP", "app", "first"), data_id_mapping("SOURCE_GROUP", "app", "second")];
let error = transfer_configs(source_admin, &request).await.unwrap_err();
assert!(error.contains("multiple target Data ID mappings"), "unexpected error: {error}");
}
#[tokio::test]
async fn transfer_rejects_data_id_mapping_outside_selected_scope() {
let source_admin = source_admin_with_config();
let mut request = transfer_request(None);
request.source.scope = NacosConfigSelectionScope::Filtered;
request.data_id_mappings = vec![data_id_mapping("SOURCE_GROUP", "app", "renamed")];
let error = transfer_configs(source_admin, &request).await.unwrap_err();
assert!(error.contains("only supported for selected"), "unexpected error: {error}");
}
#[tokio::test]
async fn transfer_rejects_data_id_mapping_for_an_unselected_source_key() {
let source_admin = source_admin_with_config();
let mut request = transfer_request(None);
request.data_id_mappings = vec![data_id_mapping("SOURCE_GROUP", "not-selected", "renamed")];
let error = transfer_configs(source_admin, &request).await.unwrap_err();
assert!(error.contains("SOURCE_GROUP/not-selected is not selected"), "unexpected error: {error}");
}
#[tokio::test]
async fn transfer_rejects_a_stale_selected_source_mapping() {
let source_admin = source_admin_with_config();
let mut request = transfer_request(None);
request.source.keys[0].data_id = "deleted".to_string();
request.data_id_mappings = vec![data_id_mapping("SOURCE_GROUP", "deleted", "renamed")];
let error = transfer_configs(source_admin, &request).await.unwrap_err();
assert_eq!(error, "not found");
}
#[tokio::test]
async fn transfer_rejects_target_key_collisions_after_data_id_mapping() {
let source_admin = source_admin_with_config();
insert_source_config(&source_admin, "worker", "SOURCE_GROUP", "worker value");
let mut request = transfer_request(Some("TARGET_GROUP"));
request.source.keys.push(NacosConfigKey {
namespace: Some("source-ns".to_string()),
data_id: "worker".to_string(),
group: "SOURCE_GROUP".to_string(),
});
request.data_id_mappings = vec![data_id_mapping("SOURCE_GROUP", "worker", "app")];
let error = transfer_configs(source_admin, &request).await.unwrap_err();
assert!(error.contains("target-ns/TARGET_GROUP/app"), "unexpected error: {error}");
}
#[tokio::test]
async fn preview_and_apply_share_the_same_mapped_data_id_plan() {
let source_admin = source_admin_with_config();
let target_admin = Arc::new(MockAdmin::default());
let mut request = transfer_request(None);
request.data_id_mappings = vec![data_id_mapping("SOURCE_GROUP", "app", "app-prod")];
let preview = preview_transfer(source_admin.clone(), target_admin.clone(), &request).await.unwrap();
let report = apply_transfer(source_admin, target_admin.clone(), &request, &preview.plan_hash).await.unwrap();
assert_eq!((preview.created, report.created), (1, 1));
let published = target_admin
.get_config(NacosConfigKey {
namespace: Some("target-ns".to_string()),
data_id: "app-prod".to_string(),
group: "SOURCE_GROUP".to_string(),
})
.await
.unwrap();
assert_eq!(published.content.as_deref(), Some("value"));
}
#[tokio::test]
async fn transfer_preview_includes_conflict_content_diff() {
let source_admin = source_admin_with_config();
let target_admin = Arc::new(MockAdmin::default());
target_admin.insert(NacosConfigItem {
data_id: "app".to_string(),
group: "SOURCE_GROUP".to_string(),
namespace: "target-ns".to_string(),
app_name: None,
desc: None,
tags: None,
config_type: Some("text".to_string()),
md5: Some("target-md5".to_string()),
encrypted_data_key: None,
content: Some("old value".to_string()),
});
let preview = preview_transfer(source_admin, target_admin, &transfer_request(None)).await.unwrap();
let diff = preview.items[0].diff.as_ref().expect("conflicting transfer should include a diff");
assert_eq!(preview.items[0].status, "conflict");
assert_eq!(diff.before_content, "old value");
assert_eq!(diff.after_content, "value");
assert_eq!(diff.format.as_deref(), Some("text"));
}
}