Merge branch 'main' of https://github.com/Abeautifulsnow/dbx into feat/ai-agent-loop-phase1

This commit is contained in:
runstone committed 2026-06-12 12:00:47 +08:00
commit 453169ae45
25 files changed
+767 -141

No files matched your search

+265 -41
View File
@@ -82,6 +82,12 @@ pub struct RedisClusterPool {
pub password: String,
}
#[derive(Debug, Clone, PartialEq, Eq)]
struct RedisAuthCandidate {
username: String,
password: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct RedisNodeEndpoint {
pub host: String,
@@ -90,15 +96,56 @@ pub struct RedisNodeEndpoint {
pub async fn connect(url: &str, timeout: std::time::Duration) -> Result<redis::aio::MultiplexedConnection, String> {
let client = redis::Client::open(url).map_err(|e| format!("Redis connection failed: {e}"))?;
connect_client_with_timeout(client, timeout, "Redis").await
}
pub async fn connect_standalone(
config: &ConnectionConfig,
host: &str,
port: u16,
timeout: std::time::Duration,
) -> Result<redis::aio::MultiplexedConnection, String> {
let mut last_error = None;
for auth in redis_auth_candidates(&config.username, &config.password) {
let client = redis::Client::open(connection_info(
host,
port,
config.ssl,
config.redis_tls_insecure(),
&auth.username,
&auth.password,
redis_database_index(config),
))
.map_err(|e| format!("Redis connection failed: {e}"))?;
match connect_client_with_timeout(client, timeout, "Redis").await {
Ok(con) => return Ok(con),
Err(err) if last_error.is_none() || is_redis_auth_error(&err) => {
let should_retry = is_redis_auth_error(&err);
last_error = Some(err);
if !should_retry {
break;
}
}
Err(err) => return Err(err),
}
}
Err(last_error.unwrap_or_else(|| "Redis connection failed".to_string()))
}
async fn connect_client_with_timeout(
client: redis::Client,
timeout: std::time::Duration,
label: &str,
) -> Result<redis::aio::MultiplexedConnection, String> {
let mut con = tokio::time::timeout(timeout, client.get_multiplexed_async_connection())
.await
.map_err(|_| format!("Redis connection timed out ({}s)", timeout.as_secs()))?
.map_err(|e| format!("Redis connection failed: {e}"))?;
.map_err(|_| format!("{label} connection timed out ({}s)", timeout.as_secs()))?
.map_err(|e| format!("{label} connection failed: {e}"))?;
tokio::time::timeout(timeout, redis::cmd("PING").query_async::<String>(&mut con))
.await
.map_err(|_| format!("Redis ping timed out ({}s)", timeout.as_secs()))?
.map_err(|e| format!("Redis authentication failed or command rejected: {e}"))?;
.map_err(|_| format!("{label} ping timed out ({}s)", timeout.as_secs()))?
.map_err(|e| format!("{label} authentication failed or command rejected: {e}"))?;
Ok(con)
}
@@ -128,39 +175,66 @@ pub async fn connect_sentinel(config: &ConnectionConfig) -> Result<redis::aio::M
pub async fn connect_cluster(config: &ConnectionConfig) -> Result<RedisClusterPool, String> {
let seed_nodes = redis_cluster_seed_nodes(config)?;
let cluster_nodes: Vec<ConnectionInfo> = seed_nodes
.iter()
.map(|endpoint| {
connection_info(
&endpoint.host,
endpoint.port,
config.ssl,
config.redis_tls_insecure(),
&config.username,
&config.password,
0,
)
})
.collect();
let client = ClusterClient::new(cluster_nodes).map_err(|e| format!("Redis cluster connection failed: {e}"))?;
let mut con = tokio::time::timeout(super::connection_timeout(), client.get_async_connection())
.await
.map_err(|_| format!("Redis cluster connection timed out ({}s)", super::CONNECTION_TIMEOUT_SECS))?
.map_err(|e| format!("Redis cluster connection failed: {e}"))?;
let mut last_error = None;
for auth in redis_auth_candidates(&config.username, &config.password) {
let cluster_nodes: Vec<ConnectionInfo> = seed_nodes
.iter()
.map(|endpoint| {
connection_info(
&endpoint.host,
endpoint.port,
config.ssl,
config.redis_tls_insecure(),
&auth.username,
&auth.password,
0,
)
})
.collect();
let client = ClusterClient::new(cluster_nodes).map_err(|e| format!("Redis cluster connection failed: {e}"))?;
let mut con = match tokio::time::timeout(super::connection_timeout(), client.get_async_connection())
.await
.map_err(|_| format!("Redis cluster connection timed out ({}s)", super::CONNECTION_TIMEOUT_SECS))?
.map_err(|e| format!("Redis cluster connection failed: {e}"))
{
Ok(con) => con,
Err(err) if last_error.is_none() || is_redis_auth_error(&err) => {
let should_retry = is_redis_auth_error(&err);
last_error = Some(err);
if should_retry {
continue;
}
break;
}
Err(err) => return Err(err),
};
tokio::time::timeout(super::connection_timeout(), redis::cmd("PING").query_async::<String>(&mut con))
.await
.map_err(|_| format!("Redis cluster ping timed out ({}s)", super::CONNECTION_TIMEOUT_SECS))?
.map_err(|e| format!("Redis cluster authentication failed or command rejected: {e}"))?;
Ok(RedisClusterPool {
connection: Mutex::new(con),
seed_nodes,
tls: config.ssl,
tls_insecure: config.redis_tls_insecure(),
username: config.username.clone(),
password: config.password.clone(),
})
match tokio::time::timeout(super::connection_timeout(), redis::cmd("PING").query_async::<String>(&mut con))
.await
.map_err(|_| format!("Redis cluster ping timed out ({}s)", super::CONNECTION_TIMEOUT_SECS))?
.map_err(|e| format!("Redis cluster authentication failed or command rejected: {e}"))
{
Ok(_) => {
return Ok(RedisClusterPool {
connection: Mutex::new(con),
seed_nodes,
tls: config.ssl,
tls_insecure: config.redis_tls_insecure(),
username: auth.username,
password: auth.password,
});
}
Err(err) if last_error.is_none() || is_redis_auth_error(&err) => {
let should_retry = is_redis_auth_error(&err);
last_error = Some(err);
if !should_retry {
break;
}
}
Err(err) => return Err(err),
}
}
Err(last_error.unwrap_or_else(|| "Redis cluster connection failed".to_string()))
}
fn redis_sentinel_nodes(config: &ConnectionConfig) -> Result<Vec<ConnectionInfo>, String> {
@@ -273,6 +347,25 @@ fn redis_connection_info(username: &str, password: &str, db: i64) -> RedisConnec
}
}
fn redis_auth_candidates(username: &str, password: &str) -> Vec<RedisAuthCandidate> {
let username = username.trim();
let password = password.trim();
let mut candidates = vec![RedisAuthCandidate { username: username.to_string(), password: password.to_string() }];
if !username.is_empty() && !password.is_empty() {
candidates.push(RedisAuthCandidate { username: String::new(), password: format!("{username}@{password}") });
}
candidates
}
fn redis_database_index(config: &ConnectionConfig) -> i64 {
config.effective_database().and_then(|database| database.parse::<i64>().ok()).unwrap_or(0)
}
fn is_redis_auth_error(error: &str) -> bool {
let error = error.to_ascii_lowercase();
error.contains("auth") || error.contains("wrongpass") || error.contains("invalid username-password")
}
fn non_empty_string(value: &str) -> Option<String> {
let value = value.trim();
if value.is_empty() {
@@ -489,6 +582,7 @@ pub async fn scan_cluster_values_page(
cursor: u64,
pattern: &str,
query: &str,
include_key_matches: bool,
count: usize,
) -> Result<RedisScanResult, String> {
let master_nodes = cluster_master_nodes(pool).await?;
@@ -507,7 +601,7 @@ pub async fn scan_cluster_values_page(
let mut con =
connect_direct_node(endpoint, pool.tls, pool.tls_insecure, &pool.username, &pool.password).await?;
let current_cursor = if index == node_index { node_cursor } else { 0 };
let result = scan_values_page(&mut con, current_cursor, pattern, query, count).await?;
let result = scan_values_page(&mut con, current_cursor, pattern, query, include_key_matches, count).await?;
if !result.keys.is_empty() {
let next_cursor = if result.cursor != 0 {
encode_cluster_cursor(index, result.cursor)?
@@ -869,6 +963,7 @@ pub async fn scan_values_page<C>(
cursor: u64,
pattern: &str,
query: &str,
include_key_matches: bool,
count: usize,
) -> Result<RedisScanResult, String>
where
@@ -892,7 +987,47 @@ where
let (next_cursor, keys) = parse_scan_keys(raw)?;
let mut result = Vec::new();
for key in keys {
let keys: Vec<_> = keys
.into_iter()
.map(|key| {
let key_display = redis_key_bytes_to_display(&key);
let key_raw = redis_key_bytes_to_raw(&key);
let key_matches = include_key_matches && redis_key_matches_query(&key_display, &key_raw, query);
(key, key_display, key_raw, key_matches)
})
.collect();
let mut key_match_types = Vec::new();
if include_key_matches {
let mut pipe = redis::pipe();
let mut key_match_count = 0usize;
for (key, _, _, key_matches) in &keys {
if *key_matches {
pipe.cmd("TYPE").arg(key);
key_match_count += 1;
}
}
if key_match_count > 0 {
key_match_types = pipe.query_async(con).await.unwrap_or_default();
}
}
let mut key_match_type_index = 0usize;
for (key, key_display, key_raw, key_matches) in keys {
if key_matches {
let key_type = key_match_types.get(key_match_type_index).cloned().unwrap_or_else(|| "unknown".to_string());
key_match_type_index += 1;
result.push(RedisKeyInfo {
key_display,
key_raw,
value_preview: redis_key_value_preview(&key_type),
key_type,
ttl: -2,
size: 0,
});
continue;
}
let Ok(value) = get_value(con, &key).await else {
continue;
};
@@ -983,6 +1118,15 @@ fn redis_value_matches_query(value: &serde_json::Value, query: &str) -> bool {
redis_search_value_text(value).to_lowercase().contains(&query.to_lowercase())
}
fn redis_key_matches_query(key_display: &str, key_raw: &str, query: &str) -> bool {
let query = query.trim();
if query.is_empty() {
return false;
}
let query = query.to_lowercase();
key_display.to_lowercase().contains(&query) || key_raw.to_lowercase().contains(&query)
}
fn redis_search_value_text(value: &serde_json::Value) -> String {
match value {
serde_json::Value::String(text) => text.clone(),
@@ -1530,11 +1674,13 @@ mod tests {
use super::{
classify_command, connection_info, decode_cluster_cursor, encode_cluster_cursor, is_redis_json_type,
parse_cluster_slots, parse_command_argv, parse_database_count, parse_redis_endpoint, parse_scan_keys,
parse_stream_entries, redis_command_raw_to_json, redis_json_raw_to_json, redis_json_value_preview,
redis_key_bytes_to_display, redis_key_bytes_to_raw, redis_key_raw_to_bytes, redis_key_value_preview,
redis_raw_to_json, redis_value_contains_binary, redis_value_matches_query, RedisCommandSafety,
parse_stream_entries, redis_auth_candidates, redis_command_raw_to_json, redis_database_index,
redis_json_raw_to_json, redis_json_value_preview, redis_key_bytes_to_display, redis_key_bytes_to_raw,
redis_key_matches_query, redis_key_raw_to_bytes, redis_key_value_preview, redis_raw_to_json,
redis_value_contains_binary, redis_value_matches_query, RedisAuthCandidate, RedisCommandSafety,
RedisNodeEndpoint, RedisRawValue,
};
use crate::models::connection::ConnectionConfig;
use redis::ConnectionAddr;
fn bulk(value: &str) -> RedisRawValue {
@@ -1673,6 +1819,14 @@ mod tests {
assert!(!redis_value_matches_query(&serde_json::json!("Hello Redis"), "mysql"));
}
#[test]
fn matches_redis_keys_case_insensitively() {
assert!(redis_key_matches_query("User:42:Profile", "User:42:Profile", "profile"));
assert!(redis_key_matches_query("binary key", "ff75736572", "FF75"));
assert!(!redis_key_matches_query("User:42:Profile", "User:42:Profile", ""));
assert!(!redis_key_matches_query("User:42:Profile", "User:42:Profile", "order"));
}
#[test]
fn matches_hash_field_name_in_value_search() {
let hash_value = serde_json::json!([
@@ -1754,6 +1908,76 @@ mod tests {
assert!(matches!(info.addr, ConnectionAddr::TcpTls { insecure: true, .. }));
}
#[test]
fn redis_connection_info_preserves_acl_username_and_password() {
let info = connection_info("cache.example.com", 6379, false, false, "app-user", "secret", 0);
assert_eq!(info.redis.username.as_deref(), Some("app-user"));
assert_eq!(info.redis.password.as_deref(), Some("secret"));
}
#[test]
fn redis_auth_candidates_try_username_at_password_fallback() {
let candidates = redis_auth_candidates("app-user", "secret");
assert_eq!(
candidates,
vec![
RedisAuthCandidate { username: "app-user".to_string(), password: "secret".to_string() },
RedisAuthCandidate { username: String::new(), password: "app-user@secret".to_string() },
]
);
}
#[test]
fn redis_database_index_uses_numeric_database_only() {
let mut config = ConnectionConfig {
id: "redis".to_string(),
name: "Redis".to_string(),
db_type: crate::models::connection::DatabaseType::Redis,
driver_profile: None,
driver_label: None,
url_params: None,
host: "cache.example.com".to_string(),
port: 6379,
username: String::new(),
password: String::new(),
database: Some("4".to_string()),
visible_databases: None,
attached_databases: Vec::new(),
color: None,
transport_layers: Vec::new(),
connect_timeout_secs: crate::models::connection::default_connect_timeout_secs(),
query_timeout_secs: crate::models::connection::default_query_timeout_secs(),
idle_timeout_secs: crate::models::connection::default_idle_timeout_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: crate::models::connection::default_redis_key_separator(),
etcd_endpoints: String::new(),
external_config: None,
jdbc_driver_class: None,
jdbc_driver_paths: Vec::new(),
one_time: false,
read_only: false,
};
assert_eq!(redis_database_index(&config), 4);
config.database = Some("not-a-number".to_string());
assert_eq!(redis_database_index(&config), 0);
}
#[test]
fn encodes_and_decodes_cluster_scan_cursor() {
let encoded = encode_cluster_cursor(12, 3456).unwrap();