use super::{
Backend, BackendCapabilities, BackendError, ConnectionInfo, RawCommandResult, ServerInfo,
};
use crate::types::{
Auth, BackendType, ConnectionConfig, KeyMetadata, KeyScanResult, Value, ValueType,
};
use etcd_client::{Client, GetOptions, KeyValue};
use std::time::{Duration, SystemTime};
pub struct EtcdBackend {
config: ConnectionConfig,
client: Option<Client>,
}
impl EtcdBackend {
pub fn new(config: ConnectionConfig) -> Self {
Self {
config,
client: None,
}
}
fn build_endpoints(&self) -> Vec<String> {
let scheme = if self.config.tls.as_ref().map(|t| t.enabled).unwrap_or(false) {
"https"
} else {
"http"
};
vec![format!(
"{}://{}:{}",
scheme, self.config.host, self.config.port
)]
}
fn has_client(&self) -> bool {
self.client.is_some()
}
fn detect_value_type(data: &[u8]) -> ValueType {
if super::utils::is_json(data) {
ValueType::Json
} else if data.iter().all(|&b| b.is_ascii()) {
ValueType::String
} else {
ValueType::Binary
}
}
fn kv_to_metadata(kv: &KeyValue) -> KeyMetadata {
let name = String::from_utf8_lossy(kv.key()).to_string();
let data = kv.value();
let value_type = Self::detect_value_type(data);
KeyMetadata {
name,
value_type,
size_bytes: data.len() as u64,
ttl: None, last_accessed: Some(SystemTime::now()),
encoding: Some("utf8".to_string()),
}
}
}
#[async_trait::async_trait]
impl Backend for EtcdBackend {
fn backend_type(&self) -> BackendType {
BackendType::Etcd
}
fn capabilities(&self) -> BackendCapabilities {
BackendCapabilities {
supports_ttl: true, supports_scan: true, supports_raw_commands: false, supports_batch_get: true, supports_efficient_pattern_search: true, }
}
async fn connect(&mut self) -> Result<ConnectionInfo, BackendError> {
let endpoints = self.build_endpoints();
let mut options = etcd_client::ConnectOptions::new();
options = options.with_connect_timeout(self.config.timeout);
if let Some(auth) = &self.config.auth {
match auth {
Auth::UserPassword { username, password } => {
options = options.with_user(username, password);
}
Auth::Token(_token) => {
return Err(BackendError::AuthenticationError(
"Token auth not directly supported; use username/password".to_string(),
));
}
Auth::Certificate { .. } => {
return Err(BackendError::AuthenticationError(
"Certificate auth requires TLS configuration".to_string(),
));
}
}
}
let client = tokio::time::timeout(
self.config.timeout,
Client::connect(endpoints.clone(), Some(options)),
)
.await
.map_err(|_| BackendError::Timeout)?
.map_err(|e| BackendError::ConnectionError(e.to_string()))?;
self.client = Some(client);
let version = match self.client.as_mut() {
Some(client) => match client.status().await {
Ok(resp) => resp.version().to_string(),
Err(_) => "unknown".to_string(),
},
None => "unknown".to_string(),
};
Ok(ConnectionInfo {
connected: true,
server_version: version,
address: format!("{}:{}", self.config.host, self.config.port),
})
}
async fn disconnect(&mut self) -> Result<(), BackendError> {
self.client = None;
Ok(())
}
async fn ping(&self) -> Result<Duration, BackendError> {
if !self.has_client() {
return Err(BackendError::ConnectionError("Not connected".to_string()));
}
let start = std::time::Instant::now();
Ok(start.elapsed())
}
async fn info(&self) -> Result<ServerInfo, BackendError> {
if !self.has_client() {
return Err(BackendError::ConnectionError("Not connected".to_string()));
}
Ok(ServerInfo {
version: "etcd v3".to_string(),
uptime: Duration::from_secs(0), memory_used: 0, memory_max: None,
clients_connected: 1,
keys_total: 0, })
}
async fn scan_keys(
&self,
pattern: Option<&str>,
cursor: Option<String>,
limit: usize,
) -> Result<KeyScanResult, BackendError> {
if !self.has_client() {
return Err(BackendError::ConnectionError("Not connected".to_string()));
}
let prefix = pattern.unwrap_or("");
let start_key = cursor.unwrap_or_else(|| prefix.to_string());
let endpoints = self.build_endpoints();
let mut options = etcd_client::ConnectOptions::new();
options = options.with_connect_timeout(self.config.timeout);
if let Some(Auth::UserPassword { username, password }) = &self.config.auth {
options = options.with_user(username, password);
}
let mut client = Client::connect(endpoints, Some(options))
.await
.map_err(|e| BackendError::ConnectionError(e.to_string()))?;
let get_options = GetOptions::new()
.with_prefix()
.with_limit((limit + 1) as i64) .with_keys_only();
let resp = client
.get(start_key.as_bytes(), Some(get_options))
.await
.map_err(|e| BackendError::Internal(e.to_string()))?;
let kvs = resp.kvs();
let has_more = kvs.len() > limit;
let take_count = if has_more { limit } else { kvs.len() };
let mut keys: Vec<KeyMetadata> = Vec::new();
let mut last_key: Option<String> = None;
for kv in kvs.iter().take(take_count) {
let key_str = String::from_utf8_lossy(kv.key()).to_string();
last_key = Some(key_str.clone());
keys.push(KeyMetadata {
name: key_str,
value_type: ValueType::Unknown,
size_bytes: 0,
ttl: None,
last_accessed: Some(SystemTime::now()),
encoding: None,
});
}
let next_cursor = if has_more {
last_key.map(|k| format!("{}\0", k))
} else {
None
};
Ok(KeyScanResult {
keys,
cursor: next_cursor,
has_more,
})
}
async fn search_keys(
&self,
pattern: &str,
limit: usize,
) -> Result<KeyScanResult, BackendError> {
let prefix = pattern.trim_matches('*');
self.scan_keys(Some(prefix), None, limit).await
}
async fn key_count(&self, pattern: Option<&str>) -> Result<u64, BackendError> {
if !self.has_client() {
return Err(BackendError::ConnectionError("Not connected".to_string()));
}
let prefix = pattern.unwrap_or("");
let endpoints = self.build_endpoints();
let mut options = etcd_client::ConnectOptions::new();
options = options.with_connect_timeout(self.config.timeout);
if let Some(Auth::UserPassword { username, password }) = &self.config.auth {
options = options.with_user(username, password);
}
let mut client = Client::connect(endpoints, Some(options))
.await
.map_err(|e| BackendError::ConnectionError(e.to_string()))?;
let get_options = GetOptions::new().with_prefix().with_count_only();
let resp = client
.get(prefix.as_bytes(), Some(get_options))
.await
.map_err(|e| BackendError::Internal(e.to_string()))?;
Ok(resp.count() as u64)
}
async fn key_info(&self, key: &str) -> Result<KeyMetadata, BackendError> {
if !self.has_client() {
return Err(BackendError::ConnectionError("Not connected".to_string()));
}
let endpoints = self.build_endpoints();
let mut options = etcd_client::ConnectOptions::new();
options = options.with_connect_timeout(self.config.timeout);
if let Some(Auth::UserPassword { username, password }) = &self.config.auth {
options = options.with_user(username, password);
}
let mut client = Client::connect(endpoints, Some(options))
.await
.map_err(|e| BackendError::ConnectionError(e.to_string()))?;
let resp = client
.get(key, None)
.await
.map_err(|e| BackendError::Internal(e.to_string()))?;
let kv = resp
.kvs()
.first()
.ok_or_else(|| BackendError::KeyNotFound(key.to_string()))?;
Ok(Self::kv_to_metadata(kv))
}
async fn get(&self, key: &str) -> Result<Value, BackendError> {
if !self.has_client() {
return Err(BackendError::ConnectionError("Not connected".to_string()));
}
let endpoints = self.build_endpoints();
let mut options = etcd_client::ConnectOptions::new();
options = options.with_connect_timeout(self.config.timeout);
if let Some(Auth::UserPassword { username, password }) = &self.config.auth {
options = options.with_user(username, password);
}
let mut client = Client::connect(endpoints, Some(options))
.await
.map_err(|e| BackendError::ConnectionError(e.to_string()))?;
let resp = client
.get(key, None)
.await
.map_err(|e| BackendError::Internal(e.to_string()))?;
let kv = resp
.kvs()
.first()
.ok_or_else(|| BackendError::KeyNotFound(key.to_string()))?;
let data = kv.value().to_vec();
let value_type = Self::detect_value_type(&data);
Ok(Value {
data,
value_type,
encoding: Some("utf8".to_string()),
})
}
async fn get_many(&self, keys: &[String]) -> Result<Vec<(String, Value)>, BackendError> {
if !self.has_client() {
return Err(BackendError::ConnectionError("Not connected".to_string()));
}
let endpoints = self.build_endpoints();
let mut options = etcd_client::ConnectOptions::new();
options = options.with_connect_timeout(self.config.timeout);
if let Some(Auth::UserPassword { username, password }) = &self.config.auth {
options = options.with_user(username, password);
}
let mut client = Client::connect(endpoints, Some(options))
.await
.map_err(|e| BackendError::ConnectionError(e.to_string()))?;
let mut results = Vec::new();
for key in keys {
match client.get(key.as_str(), None).await {
Ok(resp) => {
if let Some(kv) = resp.kvs().first() {
let data = kv.value().to_vec();
let value_type = Self::detect_value_type(&data);
results.push((
key.clone(),
Value {
data,
value_type,
encoding: Some("utf8".to_string()),
},
));
}
}
Err(_) => continue, }
}
Ok(results)
}
async fn set(
&self,
key: &str,
value: &[u8],
ttl: Option<Duration>,
) -> Result<(), BackendError> {
if self.config.read_only {
return Err(BackendError::ReadOnly);
}
if !self.has_client() {
return Err(BackendError::ConnectionError("Not connected".to_string()));
}
let endpoints = self.build_endpoints();
let mut options = etcd_client::ConnectOptions::new();
options = options.with_connect_timeout(self.config.timeout);
if let Some(Auth::UserPassword { username, password }) = &self.config.auth {
options = options.with_user(username, password);
}
let mut client = Client::connect(endpoints, Some(options))
.await
.map_err(|e| BackendError::ConnectionError(e.to_string()))?;
if let Some(ttl_duration) = ttl {
let lease_resp = client
.lease_grant(ttl_duration.as_secs() as i64, None)
.await
.map_err(|e| BackendError::Internal(e.to_string()))?;
let lease_id = lease_resp.id();
let put_options = etcd_client::PutOptions::new().with_lease(lease_id);
client
.put(key, value, Some(put_options))
.await
.map_err(|e| BackendError::Internal(e.to_string()))?;
} else {
client
.put(key, value, None)
.await
.map_err(|e| BackendError::Internal(e.to_string()))?;
}
Ok(())
}
async fn delete(&self, key: &str) -> Result<bool, BackendError> {
if self.config.read_only {
return Err(BackendError::ReadOnly);
}
if !self.has_client() {
return Err(BackendError::ConnectionError("Not connected".to_string()));
}
let endpoints = self.build_endpoints();
let mut options = etcd_client::ConnectOptions::new();
options = options.with_connect_timeout(self.config.timeout);
if let Some(Auth::UserPassword { username, password }) = &self.config.auth {
options = options.with_user(username, password);
}
let mut client = Client::connect(endpoints, Some(options))
.await
.map_err(|e| BackendError::ConnectionError(e.to_string()))?;
let resp = client
.delete(key, None)
.await
.map_err(|e| BackendError::Internal(e.to_string()))?;
Ok(resp.deleted() > 0)
}
async fn execute_raw(&self, _command: &str) -> Result<RawCommandResult, BackendError> {
Err(BackendError::NotSupported)
}
}
#[cfg(test)]
mod tests {
use super::*;
fn create_test_config() -> ConnectionConfig {
ConnectionConfig {
id: "test".to_string(),
name: "Test etcd".to_string(),
backend_type: BackendType::Etcd,
host: "localhost".to_string(),
port: 2379,
auth: None,
database: None,
tls: None,
timeout: Duration::from_secs(5),
read_only: false,
}
}
#[test]
fn test_build_endpoints_basic() {
let backend = EtcdBackend::new(create_test_config());
let endpoints = backend.build_endpoints();
assert_eq!(endpoints, vec!["http://localhost:2379"]);
}
#[test]
fn test_build_endpoints_with_tls() {
let mut config = create_test_config();
config.tls = Some(crate::types::TlsConfig {
enabled: true,
ca_cert_path: None,
verify_hostname: true,
});
let backend = EtcdBackend::new(config);
let endpoints = backend.build_endpoints();
assert_eq!(endpoints, vec!["https://localhost:2379"]);
}
#[test]
fn test_build_endpoints_custom_port() {
let mut config = create_test_config();
config.port = 2380;
let backend = EtcdBackend::new(config);
let endpoints = backend.build_endpoints();
assert_eq!(endpoints, vec!["http://localhost:2380"]);
}
#[test]
fn test_backend_type() {
let backend = EtcdBackend::new(create_test_config());
assert_eq!(backend.backend_type(), BackendType::Etcd);
}
#[test]
fn test_capabilities() {
let backend = EtcdBackend::new(create_test_config());
let caps = backend.capabilities();
assert!(caps.supports_ttl);
assert!(caps.supports_scan);
assert!(!caps.supports_raw_commands);
assert!(caps.supports_batch_get);
assert!(caps.supports_efficient_pattern_search);
}
#[test]
fn test_detect_value_type_json() {
let json_data = b"{\"key\": \"value\"}";
assert_eq!(EtcdBackend::detect_value_type(json_data), ValueType::Json);
}
#[test]
fn test_detect_value_type_string() {
let string_data = b"hello world";
assert_eq!(
EtcdBackend::detect_value_type(string_data),
ValueType::String
);
}
#[test]
fn test_detect_value_type_binary() {
let binary_data = &[0x00, 0xFF, 0x80, 0x90];
assert_eq!(
EtcdBackend::detect_value_type(binary_data),
ValueType::Binary
);
}
#[test]
fn test_has_client_not_connected() {
let backend = EtcdBackend::new(create_test_config());
assert!(!backend.has_client());
}
}