Files
dbx/crates/dbx-core/src/nacos/service.rs
T

797 lines
31 KiB
Rust

use std::future::Future;
use crate::connection::AppState;
use crate::models::connection::{DatabaseConnectionInfo, DatabaseType};
use crate::nacos::types::*;
pub fn database_info_from_connection(info: &NacosConnectionInfo) -> Option<DatabaseConnectionInfo> {
let product_version = info.server_version.clone().filter(|value| !value.trim().is_empty());
Some(DatabaseConnectionInfo {
product_name: Some("Nacos".to_string()),
product_version,
..DatabaseConnectionInfo::default()
})
}
async fn refresh_access_control_after_mutation(admin: &std::sync::Arc<dyn crate::nacos::port::NacosAdmin>) {
admin.invalidate_access_control_capabilities();
let _ = admin.refresh_access_control_capabilities().await;
}
async fn current_access_control_capabilities(
admin: &std::sync::Arc<dyn crate::nacos::port::NacosAdmin>,
) -> NacosAccessControlCapabilities {
// A synchronous read intentionally treats an expired entry as absent. All
// feature and safety gates therefore go through the refreshing path so a
// stale cache cannot disable the workspace or reopen legacy mutations.
admin.refresh_access_control_capabilities().await
}
fn ensure_access_control_operation(
capabilities: &NacosAccessControlCapabilities,
operation: NacosAccessControlOperation,
) -> Result<(), String> {
let capability = capabilities.operation(operation);
if capability.supported {
return Ok(());
}
let reason = match capability.reason {
Some(NacosCapabilityReason::ImplementationReadOnly) => "implementationReadOnly",
Some(NacosCapabilityReason::VersionUnsupported) => "versionUnsupported",
Some(NacosCapabilityReason::EndpointUnavailable) => "endpointUnavailable",
Some(NacosCapabilityReason::NotVerified) => "notVerified",
Some(NacosCapabilityReason::ConnectionReadOnly) => "connectionReadOnly",
Some(NacosCapabilityReason::PermissionDenied) => "permissionDenied",
None => "notVerified",
};
Err(format!(
"NACOS_ERROR[unsupportedOperation]: Nacos access-control operation {operation:?} is unavailable ({reason})"
))
}
pub async fn nacos_test_connection_core(
state: &AppState,
conn_id: &str,
force_access_control_refresh: bool,
) -> Result<NacosConnectionInfo, String> {
let cfg = state.configs.read().await.get(conn_id).cloned().ok_or("Connection not found")?;
if cfg.db_type != DatabaseType::Nacos {
return Err("Connection is not a Nacos admin connection".to_string());
}
let admin_config = state.nacos_admin_config_for_connection(conn_id, &cfg).await?;
// Keep this probe on the connection's shared adapter so an r-nacos console
// session verified for configuration history can also expose its version.
let admin = state.nacos_registry.get_or_build_config(conn_id, admin_config).await?;
if force_access_control_refresh {
admin.invalidate_access_control_capabilities();
}
admin.inspect_connection().await
}
pub async fn nacos_list_namespaces_core(state: &AppState, conn_id: &str) -> Result<Vec<NacosNamespaceInfo>, String> {
let (admin, fingerprint) = get_admin_with_operation_fingerprint(state, conn_id).await?;
crate::nacos::namespace_access::list_displayable_namespaces(conn_id, fingerprint, admin).await
}
pub async fn nacos_sidebar_snapshot_core(
state: &AppState,
conn_id: &str,
) -> Result<NacosNamespaceSidebarSnapshot, String> {
let visible_scope =
state.configs.read().await.get(conn_id).ok_or("Connection not found")?.visible_databases.clone();
let (admin, fingerprint) = get_admin_with_operation_fingerprint(state, conn_id).await?;
crate::nacos::namespace_access::sidebar_snapshot_with_visible_scope(
conn_id,
fingerprint,
admin,
visible_scope.as_deref(),
)
.await
}
pub async fn nacos_create_namespace_core(
state: &AppState,
conn_id: &str,
req: NacosNamespaceCreate,
) -> Result<(), String> {
ensure_connection_writable(state, conn_id, "Create Nacos namespace").await?;
let admin = get_admin(state, conn_id).await?;
let result = admin.create_namespace(req).await;
if result.is_ok() {
crate::nacos::namespace_access::invalidate(conn_id);
}
result
}
pub async fn nacos_update_namespace_core(
state: &AppState,
conn_id: &str,
req: NacosNamespaceUpdate,
) -> Result<(), String> {
ensure_connection_writable(state, conn_id, "Update Nacos namespace").await?;
let admin = get_admin(state, conn_id).await?;
let result = admin.update_namespace(req).await;
if result.is_ok() {
crate::nacos::namespace_access::invalidate(conn_id);
}
result
}
pub async fn nacos_delete_namespace_core(state: &AppState, conn_id: &str, namespace_id: String) -> Result<(), String> {
ensure_connection_writable(state, conn_id, "Delete Nacos namespace").await?;
let admin = get_admin(state, conn_id).await?;
let result = admin.delete_namespace(namespace_id).await;
if result.is_ok() {
crate::nacos::namespace_access::invalidate(conn_id);
}
result
}
pub async fn nacos_list_configs_core(
state: &AppState,
conn_id: &str,
query: NacosConfigQuery,
) -> Result<NacosConfigList, String> {
let admin = get_admin(state, conn_id).await?;
admin.list_configs(query).await
}
pub async fn nacos_search_config_content_core<F, Fut>(
state: &AppState,
conn_id: &str,
request: NacosContentSearchRequest,
on_progress: F,
) -> Result<NacosContentSearchResult, String>
where
F: Fn(NacosSearchProgress) -> Fut + Send + Sync,
Fut: Future<Output = ()> + Send,
{
let admin = get_admin(state, conn_id).await?;
crate::nacos::search::search_config_content(admin, request, on_progress).await
}
pub fn nacos_cancel_operation_core(operation_id: &str) -> bool {
crate::nacos::search::cancel_operation(operation_id)
}
pub async fn nacos_get_config_core(
state: &AppState,
conn_id: &str,
key: NacosConfigKey,
) -> Result<NacosConfigItem, String> {
let admin = get_admin(state, conn_id).await?;
admin.get_config(key).await
}
pub async fn nacos_publish_config_core(state: &AppState, conn_id: &str, req: NacosConfigUpsert) -> Result<(), String> {
ensure_connection_writable(state, conn_id, "Publish Nacos config").await?;
let admin = get_admin(state, conn_id).await?;
admin.publish_config(req).await
}
pub async fn nacos_delete_config_core(state: &AppState, conn_id: &str, key: NacosConfigKey) -> Result<(), String> {
ensure_connection_writable(state, conn_id, "Delete Nacos config").await?;
let admin = get_admin(state, conn_id).await?;
admin.delete_config(key).await
}
pub async fn nacos_list_config_history_core(
state: &AppState,
conn_id: &str,
query: NacosConfigHistoryQuery,
) -> Result<NacosConfigHistoryList, String> {
let admin = get_admin(state, conn_id).await?;
admin.list_config_history(query).await
}
pub async fn nacos_get_config_history_core(
state: &AppState,
conn_id: &str,
key: NacosConfigHistoryKey,
) -> Result<NacosConfigItem, String> {
let admin = get_admin(state, conn_id).await?;
admin.get_config_history(key).await
}
pub async fn nacos_rollback_config_core(
state: &AppState,
conn_id: &str,
req: NacosConfigRollbackRequest,
) -> Result<(), String> {
ensure_connection_writable(state, conn_id, "Rollback Nacos config").await?;
let admin = get_admin(state, conn_id).await?;
admin.rollback_config(req).await
}
pub async fn nacos_get_rnacos_console_captcha_core(
state: &AppState,
conn_id: &str,
) -> Result<NacosRNacosConsoleCaptcha, String> {
let admin = get_admin(state, conn_id).await?;
admin.get_rnacos_console_captcha().await
}
pub async fn nacos_login_rnacos_console_core(
state: &AppState,
conn_id: &str,
captcha: Option<String>,
) -> Result<(), String> {
let admin = get_admin(state, conn_id).await?;
let result = admin.login_rnacos_console(captcha).await;
if result.is_ok() {
refresh_access_control_after_mutation(&admin).await;
crate::nacos::namespace_access::invalidate(conn_id);
}
result
}
pub async fn nacos_list_users_core(
state: &AppState,
conn_id: &str,
query: NacosUserQuery,
) -> Result<NacosUserList, String> {
let admin = get_admin(state, conn_id).await?;
admin.list_users(query).await
}
pub async fn nacos_create_user_core(state: &AppState, conn_id: &str, req: NacosUserCreate) -> Result<(), String> {
ensure_connection_writable(state, conn_id, "Create Nacos user").await?;
let admin = get_admin(state, conn_id).await?;
let capabilities = current_access_control_capabilities(&admin).await;
ensure_access_control_operation(&capabilities, NacosAccessControlOperation::CreateUser)?;
let result = admin.create_user(req).await;
if result.is_ok() {
refresh_access_control_after_mutation(&admin).await;
crate::nacos::namespace_access::invalidate_all();
}
result
}
pub async fn nacos_update_user_core(state: &AppState, conn_id: &str, req: NacosUserUpdate) -> Result<(), String> {
ensure_connection_writable(state, conn_id, "Update Nacos user").await?;
let admin = get_admin(state, conn_id).await?;
let capabilities = current_access_control_capabilities(&admin).await;
ensure_access_control_operation(&capabilities, NacosAccessControlOperation::UpdateUser)?;
let result = admin.update_user(req).await;
if result.is_ok() {
refresh_access_control_after_mutation(&admin).await;
crate::nacos::namespace_access::invalidate_all();
}
result
}
pub async fn nacos_delete_user_core(state: &AppState, conn_id: &str, username: String) -> Result<(), String> {
ensure_connection_writable(state, conn_id, "Delete Nacos user").await?;
let admin = get_admin(state, conn_id).await?;
let capabilities = current_access_control_capabilities(&admin).await;
if capabilities.enhanced_workspace {
return Err(
"Nacos users in the enhanced workspace must be deleted through the access-control workflow".to_string()
);
}
ensure_access_control_operation(&capabilities, NacosAccessControlOperation::DeleteUser)?;
let result = admin.delete_user(username).await;
if result.is_ok() {
refresh_access_control_after_mutation(&admin).await;
crate::nacos::namespace_access::invalidate_all();
}
result
}
pub async fn nacos_list_role_bindings_core(
state: &AppState,
conn_id: &str,
query: NacosRoleQuery,
) -> Result<NacosRoleList, String> {
let admin = get_admin(state, conn_id).await?;
admin.list_role_bindings(query).await
}
pub async fn nacos_assign_role_core(state: &AppState, conn_id: &str, binding: NacosRoleBinding) -> Result<(), String> {
ensure_connection_writable(state, conn_id, "Assign Nacos role").await?;
let admin = get_admin(state, conn_id).await?;
let capabilities = current_access_control_capabilities(&admin).await;
if capabilities.enhanced_workspace {
return Err(
"Nacos roles in the enhanced workspace must be changed through the access-control workflow".to_string()
);
}
ensure_access_control_operation(&capabilities, NacosAccessControlOperation::AssignRole)?;
let result = admin.assign_role(binding).await;
if result.is_ok() {
refresh_access_control_after_mutation(&admin).await;
crate::nacos::namespace_access::invalidate_all();
}
result
}
pub async fn nacos_remove_role_core(state: &AppState, conn_id: &str, binding: NacosRoleBinding) -> Result<(), String> {
ensure_connection_writable(state, conn_id, "Remove Nacos role").await?;
let admin = get_admin(state, conn_id).await?;
let capabilities = current_access_control_capabilities(&admin).await;
if capabilities.enhanced_workspace {
return Err(
"Nacos roles in the enhanced workspace must be changed through the access-control workflow".to_string()
);
}
ensure_access_control_operation(&capabilities, NacosAccessControlOperation::RemoveRole)?;
if binding.role == "ROLE_ADMIN" {
return Err("The Nacos administrator role cannot be removed through the legacy endpoint".to_string());
}
let result = admin.remove_role(binding).await;
if result.is_ok() {
refresh_access_control_after_mutation(&admin).await;
crate::nacos::namespace_access::invalidate_all();
}
result
}
pub async fn nacos_access_snapshot_core(state: &AppState, conn_id: &str) -> Result<NacosAccessControlSnapshot, String> {
let admin = get_admin(state, conn_id).await?;
if !current_access_control_capabilities(&admin).await.enhanced_workspace {
return Err("The enhanced access-control workspace is unavailable for this Nacos connection".to_string());
}
crate::nacos::access_control::load_snapshot(admin).await
}
pub async fn nacos_start_access_operation_core(
state: &AppState,
conn_id: &str,
req: NacosAccessOperationRequest,
) -> Result<NacosAccessOperationResult, String> {
ensure_connection_writable(state, conn_id, "Manage Nacos access control").await?;
let (admin, fingerprint) = get_admin_with_operation_fingerprint(state, conn_id).await?;
if !current_access_control_capabilities(&admin).await.enhanced_workspace {
return Err("The enhanced access-control workspace is unavailable for this Nacos connection".to_string());
}
let (result, state_changed) =
crate::nacos::access_control::start_operation(conn_id, fingerprint, admin.clone(), req).await?;
if state_changed {
refresh_access_control_after_mutation(&admin).await;
crate::nacos::namespace_access::invalidate_all();
}
Ok(result)
}
pub async fn nacos_get_access_operation_core(
state: &AppState,
conn_id: &str,
operation_id: &str,
) -> Result<NacosAccessOperationResult, String> {
let (_, fingerprint) = get_admin_with_operation_fingerprint(state, conn_id).await?;
crate::nacos::access_control::get_operation(conn_id, &fingerprint, operation_id)
}
pub async fn nacos_retry_access_operation_core(
state: &AppState,
conn_id: &str,
retry: NacosAccessOperationRetry,
) -> Result<NacosAccessOperationResult, String> {
ensure_connection_writable(state, conn_id, "Retry Nacos access-control operation").await?;
let (admin, fingerprint) = get_admin_with_operation_fingerprint(state, conn_id).await?;
let (result, state_changed) =
crate::nacos::access_control::retry_operation(conn_id, fingerprint, admin.clone(), retry).await?;
if state_changed {
refresh_access_control_after_mutation(&admin).await;
crate::nacos::namespace_access::invalidate_all();
}
Ok(result)
}
pub async fn nacos_undo_access_operation_core(
state: &AppState,
conn_id: &str,
operation_id: &str,
) -> Result<NacosAccessOperationResult, String> {
ensure_connection_writable(state, conn_id, "Undo Nacos access-control operation").await?;
let (admin, fingerprint) = get_admin_with_operation_fingerprint(state, conn_id).await?;
let (result, state_changed) =
crate::nacos::access_control::undo_operation(conn_id, fingerprint, admin.clone(), operation_id).await?;
if state_changed {
refresh_access_control_after_mutation(&admin).await;
crate::nacos::namespace_access::invalidate_all();
}
Ok(result)
}
pub async fn nacos_list_services_core(
state: &AppState,
conn_id: &str,
query: NacosServiceQuery,
) -> Result<NacosServiceList, String> {
let admin = get_admin(state, conn_id).await?;
ensure_service_operation(admin.as_ref(), NacosServiceOperation::ListServices)?;
admin.list_services(query).await
}
pub async fn nacos_list_instances_core(
state: &AppState,
conn_id: &str,
query: NacosInstanceQuery,
) -> Result<Vec<NacosInstanceInfo>, String> {
let admin = get_admin(state, conn_id).await?;
ensure_service_operation(admin.as_ref(), NacosServiceOperation::ListInstances)?;
admin.list_instances(query).await
}
pub async fn nacos_get_service_core(
state: &AppState,
conn_id: &str,
query: NacosServiceQuery,
) -> Result<NacosServiceDetail, String> {
let admin = get_admin(state, conn_id).await?;
ensure_service_operation(admin.as_ref(), NacosServiceOperation::GetService)?;
admin.get_service(query).await
}
pub async fn nacos_create_service_core(state: &AppState, conn_id: &str, req: NacosServiceUpsert) -> Result<(), String> {
ensure_connection_writable(state, conn_id, "Create Nacos service").await?;
let admin = get_admin(state, conn_id).await?;
ensure_service_operation(admin.as_ref(), NacosServiceOperation::CreateService)?;
admin.create_service(req).await
}
pub async fn nacos_update_service_core(state: &AppState, conn_id: &str, req: NacosServiceUpsert) -> Result<(), String> {
ensure_connection_writable(state, conn_id, "Update Nacos service").await?;
let admin = get_admin(state, conn_id).await?;
ensure_service_operation(admin.as_ref(), NacosServiceOperation::UpdateService)?;
admin.update_service(req).await
}
pub async fn nacos_delete_service_core(
state: &AppState,
conn_id: &str,
query: NacosServiceQuery,
) -> Result<(), String> {
ensure_connection_writable(state, conn_id, "Delete Nacos service").await?;
let admin = get_admin(state, conn_id).await?;
ensure_service_operation(admin.as_ref(), NacosServiceOperation::DeleteService)?;
ensure_service_operation(admin.as_ref(), NacosServiceOperation::ListInstances)?;
let service_name = query
.service_name
.as_deref()
.map(str::trim)
.filter(|name| !name.is_empty())
.ok_or_else(|| "Nacos service name is required".to_string())?
.to_string();
let instances = admin
.list_instances_for_service_delete(NacosInstanceQuery {
namespace: query.namespace.clone(),
service_name,
group_name: query.group_name.clone(),
clusters: None,
})
.await?;
if !instances.is_empty() {
return Err(format!(
"NACOS_ERROR[serviceNotEmpty]: Nacos service still contains {} instance(s); deregister them before deletion",
instances.len()
));
}
admin.delete_service(query).await
}
pub async fn nacos_update_instance_core(
state: &AppState,
conn_id: &str,
req: NacosInstanceUpdateRequest,
) -> Result<(), String> {
ensure_connection_writable(state, conn_id, "Update Nacos instance").await?;
let admin = get_admin(state, conn_id).await?;
ensure_service_operation(admin.as_ref(), NacosServiceOperation::UpdateInstance)?;
admin.update_instance(req).await
}
pub async fn nacos_register_instance_core(
state: &AppState,
conn_id: &str,
req: NacosInstanceRegistration,
) -> Result<(), String> {
ensure_connection_writable(state, conn_id, "Register Nacos instance").await?;
let admin = get_admin(state, conn_id).await?;
ensure_service_operation(admin.as_ref(), NacosServiceOperation::RegisterInstance)?;
admin.register_instance(req).await
}
pub async fn nacos_deregister_instance_core(
state: &AppState,
conn_id: &str,
req: NacosInstanceRef,
) -> Result<(), String> {
ensure_connection_writable(state, conn_id, "Deregister Nacos instance").await?;
let admin = get_admin(state, conn_id).await?;
ensure_service_operation(admin.as_ref(), NacosServiceOperation::DeregisterInstance)?;
admin.deregister_instance(req).await
}
pub async fn nacos_get_dashboard_core(
state: &AppState,
conn_id: &str,
query: NacosDashboardQuery,
) -> Result<NacosDashboardSnapshot, String> {
let admin = get_admin(state, conn_id).await?;
admin.get_dashboard(query).await
}
pub async fn nacos_raw_request_core(
state: &AppState,
conn_id: &str,
req: NacosRawRequest,
) -> Result<NacosRawResponse, String> {
crate::nacos::http::validate_raw_api_path(&req.path)?;
if !req.method.eq_ignore_ascii_case("GET") {
ensure_connection_writable(state, conn_id, "Run mutating Nacos raw request").await?;
}
let admin = get_admin(state, conn_id).await?;
admin.raw_request(req).await
}
pub(crate) async fn get_admin(
state: &AppState,
conn_id: &str,
) -> Result<std::sync::Arc<dyn crate::nacos::port::NacosAdmin>, String> {
let cfg = state.configs.read().await.get(conn_id).cloned().ok_or("Connection not found")?;
if cfg.db_type != DatabaseType::Nacos {
return Err("Connection is not a Nacos admin connection".to_string());
}
let admin_config = state.nacos_admin_config_for_connection(conn_id, &cfg).await?;
state.nacos_registry.get_or_build_config(conn_id, admin_config).await
}
async fn get_admin_with_operation_fingerprint(
state: &AppState,
conn_id: &str,
) -> Result<(std::sync::Arc<dyn crate::nacos::port::NacosAdmin>, String), String> {
let cfg = state.configs.read().await.get(conn_id).cloned().ok_or("Connection not found")?;
if cfg.db_type != DatabaseType::Nacos {
return Err("Connection is not a Nacos admin connection".to_string());
}
let admin_config = state.nacos_admin_config_for_connection(conn_id, &cfg).await?;
let fingerprint = admin_config.operation_fingerprint();
let admin = state.nacos_registry.get_or_build_config(conn_id, admin_config).await?;
Ok((admin, fingerprint))
}
pub(crate) async fn ensure_connection_writable(state: &AppState, conn_id: &str, action: &str) -> Result<(), String> {
let cfg = state.configs.read().await.get(conn_id).cloned().ok_or("Connection not found")?;
if cfg.read_only {
Err(format!("{action} is blocked because this connection is read-only"))
} else {
Ok(())
}
}
fn ensure_service_operation(
admin: &dyn crate::nacos::port::NacosAdmin,
operation: NacosServiceOperation,
) -> Result<(), String> {
let capabilities = admin.service_capabilities();
let capability = capabilities.operation(operation);
if capability.supported {
return Ok(());
}
let reason = match capability.reason {
Some(NacosCapabilityReason::ImplementationReadOnly) => "implementationReadOnly",
Some(NacosCapabilityReason::VersionUnsupported) => "versionUnsupported",
Some(NacosCapabilityReason::EndpointUnavailable) => "endpointUnavailable",
Some(NacosCapabilityReason::NotVerified) => "notVerified",
Some(NacosCapabilityReason::ConnectionReadOnly) => "connectionReadOnly",
Some(NacosCapabilityReason::PermissionDenied) => "permissionDenied",
None => "notVerified",
};
Err(format!("NACOS_ERROR[unsupportedOperation]: Nacos service operation {operation:?} is unavailable ({reason})"))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn access_control_operation_guard_uses_individual_capabilities() {
let mut capabilities = NacosAccessControlCapabilities::unavailable(NacosCapabilityReason::PermissionDenied);
capabilities.update_user = NacosOperationCapability::supported();
assert!(ensure_access_control_operation(&capabilities, NacosAccessControlOperation::UpdateUser).is_ok());
let error =
ensure_access_control_operation(&capabilities, NacosAccessControlOperation::CreateUser).unwrap_err();
assert!(error.contains("CreateUser"));
assert!(error.contains("permissionDenied"));
}
#[test]
fn core_service_operation_guard_allows_documented_rnacos_v1_writes() {
use crate::nacos::config::{
NacosAdminConfig, NacosAuthConfig, NacosImplementation, NacosMetricsMode, NacosRNacosConsoleAuth,
NacosVersionMode,
};
use crate::nacos::http::NacosOpenApiAdmin;
use crate::nacos::port::NacosAdmin;
let admin = NacosOpenApiAdmin::new(NacosAdminConfig {
implementation: Some(NacosImplementation::RNacos),
server_addr: "http://127.0.0.1:3848".to_string(),
display_server_addr: "http://127.0.0.1:3848".to_string(),
namespace: "public".to_string(),
version_mode: Some(NacosVersionMode::Auto),
api_plane: None,
context_path: "/nacos".to_string(),
managed_namespaces: Vec::new(),
rnacos_console_addr: String::new(),
rnacos_history_enabled: Some(false),
rnacos_console_auth: NacosRNacosConsoleAuth::Inherit,
auth: NacosAuthConfig::None,
tls_skip_verify: false,
metrics_mode: NacosMetricsMode::Disabled,
metrics_url: String::new(),
page_size: 20,
connect_override: None,
})
.unwrap();
assert!(ensure_service_operation(&admin, NacosServiceOperation::ListServices).is_ok());
assert!(ensure_service_operation(&admin, NacosServiceOperation::CreateService).is_ok());
assert!(ensure_service_operation(&admin, NacosServiceOperation::UpdateInstance).is_ok());
assert!(admin.service_capabilities().create_service.supported);
let error = ensure_service_operation(&admin, NacosServiceOperation::DeleteService).unwrap_err();
assert!(error.contains("endpointUnavailable"));
}
#[tokio::test]
async fn raw_mutation_requires_writable_connection_before_adapter_build() {
let dir = std::env::temp_dir().join(format!("dbx-nacos-service-test-{}", uuid::Uuid::new_v4()));
std::fs::create_dir_all(&dir).unwrap();
let storage = crate::storage::Storage::open(&dir.join("storage.db")).await.unwrap();
let state = AppState::new(storage);
let mut cfg = crate::models::connection::ConnectionConfig {
docs_notes_path: None,
id: "nacos-1".to_string(),
name: "Nacos".to_string(),
note: String::new(),
db_type: DatabaseType::Nacos,
driver_profile: None,
driver_label: None,
url_params: None,
agent_java_options: Vec::new(),
host: "127.0.0.1".to_string(),
port: 8848,
username: String::new(),
password: String::new(),
database: None,
default_schema: None,
visible_databases: None,
visible_database_patterns: None,
visible_schemas: None,
show_system_schemas: false,
attached_databases: Vec::new(),
init_script: None,
color: None,
transport_layers: Vec::new(),
connect_timeout_secs: 5,
query_timeout_secs: 30,
idle_timeout_secs: 60,
keepalive_interval_secs: crate::models::connection::default_keepalive_interval_secs(),
ssl: false,
ca_cert_path: String::new(),
client_cert_path: String::new(),
client_key_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(),
redis_key_separator: ":".to_string(),
redis_scan_page_size: None,
redis_database_aliases: Default::default(),
redis_key_templates: Vec::new(),
etcd_endpoints: String::new(),
gbase_server: String::new(),
informix_server: String::new(),
external_config: Some(serde_json::json!({ "serverAddr": "http://127.0.0.1:9" })),
jdbc_driver_class: None,
jdbc_driver_paths: Vec::new(),
one_time: false,
save_password: true,
read_only: true,
is_production: false,
production_databases: Vec::new(),
database_info: None,
};
cfg.read_only = true;
state.configs.write().await.insert(cfg.id.clone(), cfg);
let err = nacos_raw_request_core(
&state,
"nacos-1",
NacosRawRequest { method: "POST".to_string(), path: "/v1/cs/configs".to_string(), query: None, body: None },
)
.await
.unwrap_err();
assert!(err.contains("read-only"));
}
#[tokio::test]
async fn config_rollback_requires_writable_connection_before_adapter_build() {
let dir = std::env::temp_dir().join(format!("dbx-nacos-service-test-{}", uuid::Uuid::new_v4()));
std::fs::create_dir_all(&dir).unwrap();
let storage = crate::storage::Storage::open(&dir.join("storage.db")).await.unwrap();
let state = AppState::new(storage);
let cfg = crate::models::connection::ConnectionConfig {
docs_notes_path: None,
id: "nacos-rollback".to_string(),
name: "Nacos".to_string(),
note: String::new(),
db_type: DatabaseType::Nacos,
driver_profile: None,
driver_label: None,
url_params: None,
agent_java_options: Vec::new(),
host: "127.0.0.1".to_string(),
port: 8848,
username: String::new(),
password: String::new(),
database: None,
default_schema: None,
visible_databases: None,
visible_database_patterns: None,
visible_schemas: None,
show_system_schemas: false,
attached_databases: Vec::new(),
init_script: None,
color: None,
transport_layers: Vec::new(),
connect_timeout_secs: 5,
query_timeout_secs: 30,
idle_timeout_secs: 60,
keepalive_interval_secs: crate::models::connection::default_keepalive_interval_secs(),
ssl: false,
ca_cert_path: String::new(),
client_cert_path: String::new(),
client_key_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(),
redis_key_separator: ":".to_string(),
redis_scan_page_size: None,
redis_database_aliases: Default::default(),
redis_key_templates: Vec::new(),
etcd_endpoints: String::new(),
gbase_server: String::new(),
informix_server: String::new(),
external_config: Some(serde_json::json!({ "serverAddr": "http://127.0.0.1:9" })),
jdbc_driver_class: None,
jdbc_driver_paths: Vec::new(),
one_time: false,
save_password: true,
read_only: true,
is_production: false,
production_databases: Vec::new(),
database_info: None,
};
state.configs.write().await.insert(cfg.id.clone(), cfg);
let err = nacos_rollback_config_core(
&state,
"nacos-rollback",
NacosConfigRollbackRequest {
namespace: None,
data_id: "app.yaml".to_string(),
group: "DEFAULT_GROUP".to_string(),
history_id: "1".to_string(),
nid: None,
},
)
.await
.unwrap_err();
assert!(err.contains("read-only"));
}
}