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
fix(redis): support Valkey cluster logical databases
Guoyu Su1b958c4b3ff3
diff --git a/Cargo.lock b/Cargo.lockindex ce41c67f54..a134230e05 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -262,6 +262,12 @@ dependencies = ["rustversion",]+[[package]]+name = "arcstr"+version = "1.2.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "03918c3dbd7701a85c6b9887732e2921175f26c350b4563841d0958c21d57e6d"+[[package]]name = "argon2"version = "0.5.3"@@ -1527,9 +1533,9 @@ checksum = "1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570"[[package]]name = "combine"-version = "4.6.7"+version = "4.6.8"source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "ba5a308b75df32fe02788e748662718f03fde005016435c444eea572398219fd"+checksum = "cfc320937d09e6de266b31b9afb480f197d7a861be86be7cb2ea7e5d1bfffc5e"dependencies = ["bytes","futures-core",@@ -2429,7 +2435,9 @@ dependencies = ["base64 0.22.1","dbx-driver-support","dbx-types",+ "futures-util","redis",+ "rustls 0.23.43","serde","serde_json","tokio",@@ -5893,7 +5901,7 @@ dependencies = ["darling 0.23.0","heck 0.5.0","manyhow",- "num-bigint",+ "num-bigint 0.4.8","proc-macro-crate 3.5.0","proc-macro2","quote",@@ -5948,7 +5956,7 @@ dependencies = ["getrandom 0.3.4","hex","mysql-common-derive",- "num-bigint",+ "num-bigint 0.4.8","num-traits","regex","rust_decimal",@@ -6099,7 +6107,7 @@ version = "0.4.3"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "35bd024e8b2ff75562e5f34e7f4905839deb4b22955ef5e73d2fea1b9813cb23"dependencies = [- "num-bigint",+ "num-bigint 0.4.8","num-complex","num-integer","num-iter",@@ -6117,6 +6125,16 @@ dependencies = ["num-traits",]+[[package]]+name = "num-bigint"+version = "0.5.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "93e7820bc0a80a0238e650327316f929ba18d5be054b647490a3a6a339f3e7c0"+dependencies = [+ "num-integer",+ "num-traits",+]+[[package]]name = "num-bigint-dig"version = "0.8.6"@@ -6173,7 +6191,7 @@ version = "0.4.2"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "f83d14da390562dca69fc84082e73e548e1ad308d24accdedd2720017cb37824"dependencies = [- "num-bigint",+ "num-bigint 0.4.8","num-integer","num-traits",]@@ -7628,22 +7646,24 @@ dependencies = [[[package]]name = "redis"-version = "0.32.7"+version = "1.7.1"source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "014cc767fefab6a3e798ca45112bccad9c6e0e218fbd49720042716c73cfef44"+checksum = "ed5b98ae99461e02895c3a96a25dbe4d852a3d5e5b815d31d5d9e4b5344d99e9"dependencies = [+ "arcstr",+ "async-lock","bytes","cfg-if","combine","crc16",- "futures-sink",+ "futures-channel","futures-util","itoa","log",- "num-bigint",+ "num-bigint 0.5.1","percent-encoding","pin-project-lite",- "rand 0.9.5",+ "rand 0.10.2","rustls 0.23.43","rustls-native-certs 0.8.4","ryu",@@ -7653,6 +7673,7 @@ dependencies = ["tokio-rustls 0.26.4","tokio-util","url",+ "xxhash-rust",][[package]]@@ -8056,7 +8077,7 @@ dependencies = ["md5","ml-kem","module-lattice",- "num-bigint",+ "num-bigint 0.4.8","p256","p384","p521",@@ -9056,7 +9077,7 @@ version = "0.6.4"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "0d585997b0ac10be3c5ee635f1bab02d512760d14b7c468801ac8a01d9ae5f1d"dependencies = [- "num-bigint",+ "num-bigint 0.4.8","num-traits","thiserror 2.0.19","time",@@ -12113,6 +12134,12 @@ dependencies = ["windows-sys 0.59.0",]+[[package]]+name = "xxhash-rust"+version = "0.8.19"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "550a2b930b62486a393c52d5c3b84bff264b28aa437ed64694d31e93b1757af7"+[[package]]name = "yeslogic-fontconfig-sys"version = "6.0.1"diff --git a/agents/drivers/duckdb/Cargo.lock b/agents/drivers/duckdb/Cargo.lockindex 7ebff28cc4..a6912a495f 100644--- a/agents/drivers/duckdb/Cargo.lock+++ b/agents/drivers/duckdb/Cargo.lock@@ -160,6 +160,12 @@ dependencies = ["rustversion",]+[[package]]+name = "arcstr"+version = "1.2.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "03918c3dbd7701a85c6b9887732e2921175f26c350b4563841d0958c21d57e6d"+[[package]]name = "argon2"version = "0.5.3"@@ -236,7 +242,7 @@ checksum = "b9552f96391c005e6ab449fa941420935e7e062489b12b8b1b08879b2163f5b5"dependencies = ["bytes","half",- "num-bigint",+ "num-bigint 0.4.8","num-traits",]@@ -341,6 +347,17 @@ dependencies = ["regex-syntax",]+[[package]]+name = "async-lock"+version = "3.4.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "290f7f2596bd5b78a9fec8088ccd89180d7f9f55b94b0576823bbbdc72ee8311"+dependencies = [+ "event-listener",+ "event-listener-strategy",+ "pin-project-lite",+]+[[package]]name = "async-trait"version = "0.1.91"@@ -794,9 +811,9 @@ dependencies = [[[package]]name = "combine"-version = "4.6.7"+version = "4.6.8"source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "ba5a308b75df32fe02788e748662718f03fde005016435c444eea572398219fd"+checksum = "cfc320937d09e6de266b31b9afb480f197d7a861be86be7cb2ea7e5d1bfffc5e"dependencies = ["bytes","futures-core",@@ -2060,6 +2077,26 @@ dependencies = ["windows-sys 0.61.2",]+[[package]]+name = "event-listener"+version = "5.4.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "5a23add41df1562121a9393cb065eab5146a1242410f23a644851e90cfd669d2"+dependencies = [+ "parking",+ "pin-project-lite",+]++[[package]]+name = "event-listener-strategy"+version = "0.5.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "8be9f3dfaaffdae2972880079a491a1a8bb7cbed0b8dd7a347f668b4150a3b93"+dependencies = [+ "event-listener",+ "pin-project-lite",+]+[[package]]name = "fallible-iterator"version = "0.2.0"@@ -3547,7 +3584,7 @@ dependencies = ["darling","heck","manyhow",- "num-bigint",+ "num-bigint 0.4.8","proc-macro-crate","proc-macro2","quote",@@ -3602,7 +3639,7 @@ dependencies = ["getrandom 0.3.4","hex","mysql-common-derive",- "num-bigint",+ "num-bigint 0.4.8","num-traits","regex","rust_decimal",@@ -3688,6 +3725,16 @@ dependencies = ["num-traits",]+[[package]]+name = "num-bigint"+version = "0.5.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "93e7820bc0a80a0238e650327316f929ba18d5be054b647490a3a6a339f3e7c0"+dependencies = [+ "num-integer",+ "num-traits",+]+[[package]]name = "num-bigint-dig"version = "0.8.6"@@ -3921,6 +3968,12 @@ dependencies = ["windows-strings",]+[[package]]+name = "parking"+version = "2.2.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "f38d5652c16fde515bb1ecef450ab0f6a219d619a7274976324d5e377f7dceba"+[[package]]name = "parking_lot"version = "0.12.5"@@ -4614,22 +4667,24 @@ dependencies = [[[package]]name = "redis"-version = "0.32.7"+version = "1.7.1"source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "014cc767fefab6a3e798ca45112bccad9c6e0e218fbd49720042716c73cfef44"+checksum = "ed5b98ae99461e02895c3a96a25dbe4d852a3d5e5b815d31d5d9e4b5344d99e9"dependencies = [+ "arcstr",+ "async-lock","bytes","cfg-if","combine","crc16",- "futures-sink",+ "futures-channel","futures-util","itoa","log",- "num-bigint",+ "num-bigint 0.5.1","percent-encoding","pin-project-lite",- "rand 0.9.5",+ "rand 0.10.2","rustls 0.23.42","rustls-native-certs 0.8.4","ryu",@@ -4639,6 +4694,7 @@ dependencies = ["tokio-rustls 0.26.4","tokio-util","url",+ "xxhash-rust",][[package]]@@ -4870,7 +4926,7 @@ dependencies = ["md5","ml-kem","module-lattice",- "num-bigint",+ "num-bigint 0.4.8","p256","p384","p521",@@ -5512,7 +5568,7 @@ version = "0.6.4"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "0d585997b0ac10be3c5ee635f1bab02d512760d14b7c468801ac8a01d9ae5f1d"dependencies = [- "num-bigint",+ "num-bigint 0.4.8","num-traits","thiserror 2.0.19","time",@@ -6993,6 +7049,12 @@ dependencies = ["rustix 1.1.4",]+[[package]]+name = "xxhash-rust"+version = "0.8.19"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "550a2b930b62486a393c52d5c3b84bff264b28aa437ed64694d31e93b1757af7"+[[package]]name = "yoke"version = "0.8.3"diff --git a/crates/dbx-core/Cargo.toml b/crates/dbx-core/Cargo.tomlindex 7bc5367834..191a123123 100644--- a/crates/dbx-core/Cargo.toml+++ b/crates/dbx-core/Cargo.toml@@ -55,7 +55,7 @@ webpki-roots = "0.26"rusqlite = { version = "0.32", default-features = false, features = ["load_extension", "backup", "functions", "column_decltype"] }mysql_async = { version = "0.37", default-features = false, features = ["default-rustls", "client_ed25519", "chrono", "rust_decimal"] }sqlparser = { version = "0.62.0", features = ["visitor"] }-redis = { version = "0.32.2", features = ["tokio-comp", "tls-rustls", "tls-rustls-insecure", "tokio-rustls-comp", "sentinel", "cluster-async"] }+redis = { version = "1.7.1", features = ["tokio-comp", "tls-rustls", "tls-rustls-insecure", "tokio-rustls-comp", "sentinel", "cluster-async"] }rustls = { version = "0.23", features = ["aws-lc-rs"] }rustls-pemfile = "2.2"reqwest = { version = "0.12", default-features = false, features = ["cookies", "json", "stream", "rustls-tls", "socks"] }diff --git a/crates/dbx-core/src/query/redis_ops.rs b/crates/dbx-core/src/query/redis_ops.rsindex 0f8534669f..adfe7b5fb5 100644--- a/crates/dbx-core/src/query/redis_ops.rs+++ b/crates/dbx-core/src/query/redis_ops.rs@@ -21,7 +21,13 @@ pub async fn redis_list_databases_core(let mut con = con.lock().await;redis_driver::list_databases(&mut *con).await}- RedisConnection::Cluster(cluster) => redis_driver::list_cluster_databases(cluster).await,+ RedisConnection::Cluster(cluster) => {+ let databases = redis_driver::list_cluster_databases(cluster).await?;+ if let Some(reason) = redis_driver::cluster_database_diagnostic(cluster).await {+ log::warn!("[redis][databases] {connection_id}: Cannot determine cluster databases: {reason}; allow CONFIG GET cluster-databases on all masters and refresh. db0 remains available");+ }+ Ok(databases)+ }},_ => Err("Not a Redis connection".to_string()),}@@ -63,9 +69,17 @@ pub async fn redis_scan_keys_batch_core(redis_driver::scan_keys_batch(&mut *con, cursor, pattern, count, max_iterations, include_types).await}RedisConnection::Cluster(cluster) => {- redis_driver::ensure_cluster_db(db)?;- redis_driver::scan_cluster_keys_batch(cluster, cursor, pattern, count, max_iterations, include_types)- .await+ redis_driver::ensure_cluster_database(cluster, db).await?;+ redis_driver::scan_cluster_keys_batch_in_db(+ cluster,+ db,+ cursor,+ pattern,+ count,+ max_iterations,+ include_types,+ )+ .await}},_ => Err("Not a Redis connection".to_string()),@@ -93,9 +107,17 @@ pub async fn redis_scan_values_core(redis_driver::scan_values_page(&mut *con, cursor, pattern, query, include_key_matches, count).await}RedisConnection::Cluster(cluster) => {- redis_driver::ensure_cluster_db(db)?;- redis_driver::scan_cluster_values_page(cluster, cursor, pattern, query, include_key_matches, count)- .await+ redis_driver::ensure_cluster_database(cluster, db).await?;+ redis_driver::scan_cluster_values_page_in_db(+ cluster,+ db,+ cursor,+ pattern,+ query,+ include_key_matches,+ count,+ )+ .await}},_ => Err("Not a Redis connection".to_string()),@@ -124,9 +146,14 @@ pub async fn redis_get_value_in_db_core(redis_driver::get_value(&mut *con, &key).await}RedisConnection::Cluster(cluster) => {- redis_driver::ensure_cluster_db(db)?;- let mut con = redis_driver::cluster_key_connection(cluster, &key).await?;- redis_driver::get_value(&mut con, &key).await+ redis_driver::ensure_cluster_database(cluster, db).await?;+ let mut con = redis_driver::cluster_key_connection_in_db(cluster, &key, db).await?;+ redis_driver::get_value_scoped(+ &mut con,+ &key,+ &redis_driver::RedisOperationScope { connection_id: connection_id.to_string(), db },+ )+ .await}}}@@ -152,8 +179,8 @@ pub async fn redis_get_raw_value_in_db_core(redis_driver::get_raw_value(&mut *con, &key).await}RedisConnection::Cluster(cluster) => {- redis_driver::ensure_cluster_db(db)?;- let mut con = redis_driver::cluster_key_connection(cluster, &key).await?;+ redis_driver::ensure_cluster_database(cluster, db).await?;+ let mut con = redis_driver::cluster_key_connection_in_db(cluster, &key, db).await?;redis_driver::get_raw_value(&mut con, &key).await}}@@ -182,8 +209,8 @@ pub async fn redis_get_ttl_in_db_core(redis_driver::get_ttl(&mut *con, &key).await}RedisConnection::Cluster(cluster) => {- redis_driver::ensure_cluster_db(db)?;- let mut con = redis_driver::cluster_key_connection(cluster, &key).await?;+ redis_driver::ensure_cluster_database(cluster, db).await?;+ let mut con = redis_driver::cluster_key_connection_in_db(cluster, &key, db).await?;redis_driver::get_ttl(&mut con, &key).await}}@@ -211,8 +238,8 @@ pub async fn redis_stream_entries_in_db_core(redis_driver::get_stream_entries_page(&mut *con, &key, cursor).await}RedisConnection::Cluster(cluster) => {- redis_driver::ensure_cluster_db(db)?;- let mut con = redis_driver::cluster_key_connection(cluster, &key).await?;+ redis_driver::ensure_cluster_database(cluster, db).await?;+ let mut con = redis_driver::cluster_key_connection_in_db(cluster, &key, db).await?;redis_driver::get_stream_entries_page(&mut con, &key, cursor).await}}@@ -239,8 +266,8 @@ pub async fn redis_stream_groups_in_db_core(redis_driver::get_stream_groups(&mut *con, &key).await}RedisConnection::Cluster(cluster) => {- redis_driver::ensure_cluster_db(db)?;- let mut con = redis_driver::cluster_key_connection(cluster, &key).await?;+ redis_driver::ensure_cluster_database(cluster, db).await?;+ let mut con = redis_driver::cluster_key_connection_in_db(cluster, &key, db).await?;redis_driver::get_stream_groups(&mut con, &key).await}}@@ -269,8 +296,8 @@ pub async fn redis_stream_consumers_in_db_core(redis_driver::get_stream_consumers(&mut *con, &key, &group).await}RedisConnection::Cluster(cluster) => {- redis_driver::ensure_cluster_db(db)?;- let mut con = redis_driver::cluster_key_connection(cluster, &key).await?;+ redis_driver::ensure_cluster_database(cluster, db).await?;+ let mut con = redis_driver::cluster_key_connection_in_db(cluster, &key, db).await?;redis_driver::get_stream_consumers(&mut con, &key, &group).await}}@@ -302,8 +329,8 @@ pub async fn redis_stream_pending_in_db_core(redis_driver::get_stream_pending_page(&mut *con, &key, &group, cursor, consumer.as_deref()).await}RedisConnection::Cluster(cluster) => {- redis_driver::ensure_cluster_db(db)?;- let mut con = redis_driver::cluster_key_connection(cluster, &key).await?;+ redis_driver::ensure_cluster_database(cluster, db).await?;+ let mut con = redis_driver::cluster_key_connection_in_db(cluster, &key, db).await?;redis_driver::get_stream_pending_page(&mut con, &key, &group, cursor, consumer.as_deref()).await}}@@ -342,8 +369,8 @@ pub async fn redis_set_string_in_db_core(redis_driver::set_string(&mut *con, &key, value, ttl).await}RedisConnection::Cluster(cluster) => {- redis_driver::ensure_cluster_db(db)?;- let mut con = redis_driver::cluster_key_connection(cluster, &key).await?;+ redis_driver::ensure_cluster_database(cluster, db).await?;+ let mut con = redis_driver::cluster_key_connection_in_db(cluster, &key, db).await?;redis_driver::set_string(&mut con, &key, value, ttl).await}}@@ -374,8 +401,8 @@ pub async fn redis_delete_key_in_db_core(redis_driver::delete_key(&mut *con, &key).await}RedisConnection::Cluster(cluster) => {- redis_driver::ensure_cluster_db(db)?;- let mut con = redis_driver::cluster_key_connection(cluster, &key).await?;+ redis_driver::ensure_cluster_database(cluster, db).await?;+ let mut con = redis_driver::cluster_key_connection_in_db(cluster, &key, db).await?;redis_driver::delete_key(&mut con, &key).await}}@@ -406,8 +433,8 @@ pub async fn redis_rename_key_in_db_core(redis_driver::rename_key(&mut *con, &key, &new_key).await}RedisConnection::Cluster(cluster) => {- redis_driver::ensure_cluster_db(db)?;- let mut con = redis_driver::cluster_key_connection(cluster, &key).await?;+ redis_driver::ensure_cluster_database(cluster, db).await?;+ let mut con = redis_driver::cluster_key_connection_in_db(cluster, &key, db).await?;redis_driver::rename_key(&mut con, &key, &new_key).await}},@@ -447,8 +474,8 @@ pub async fn redis_hash_set_in_db_core(redis_driver::hash_set(&mut *con, &key, field, value, ttl).await}RedisConnection::Cluster(cluster) => {- redis_driver::ensure_cluster_db(db)?;- let mut con = redis_driver::cluster_key_connection(cluster, &key).await?;+ redis_driver::ensure_cluster_database(cluster, db).await?;+ let mut con = redis_driver::cluster_key_connection_in_db(cluster, &key, db).await?;redis_driver::hash_set(&mut con, &key, field, value, ttl).await}}@@ -480,8 +507,8 @@ pub async fn redis_hash_del_in_db_core(redis_driver::hash_del(&mut *con, &key, field).await}RedisConnection::Cluster(cluster) => {- redis_driver::ensure_cluster_db(db)?;- let mut con = redis_driver::cluster_key_connection(cluster, &key).await?;+ redis_driver::ensure_cluster_database(cluster, db).await?;+ let mut con = redis_driver::cluster_key_connection_in_db(cluster, &key, db).await?;redis_driver::hash_del(&mut con, &key, field).await}}@@ -517,8 +544,8 @@ pub async fn redis_hash_field_update_in_db_core(redis_driver::hash_field_update(&mut *con, &key, old_field, new_field, value).await}RedisConnection::Cluster(cluster) => {- redis_driver::ensure_cluster_db(db)?;- let mut con = redis_driver::cluster_key_connection(cluster, &key).await?;+ redis_driver::ensure_cluster_database(cluster, db).await?;+ let mut con = redis_driver::cluster_key_connection_in_db(cluster, &key, db).await?;redis_driver::hash_field_update(&mut con, &key, old_field, new_field, value).await}}@@ -547,8 +574,8 @@ pub async fn redis_hash_field_set_ttl_in_db_core(redis_driver::set_hash_field_ttl(&mut *con, &key, field, ttl).await}RedisConnection::Cluster(cluster) => {- redis_driver::ensure_cluster_db(db)?;- let mut con = redis_driver::cluster_key_connection(cluster, &key).await?;+ redis_driver::ensure_cluster_database(cluster, db).await?;+ let mut con = redis_driver::cluster_key_connection_in_db(cluster, &key, db).await?;redis_driver::set_hash_field_ttl(&mut con, &key, field, ttl).await}}@@ -577,8 +604,8 @@ pub async fn redis_hash_field_set_expire_at_in_db_core(redis_driver::set_hash_field_expire_at(&mut *con, &key, field, expire_at).await}RedisConnection::Cluster(cluster) => {- redis_driver::ensure_cluster_db(db)?;- let mut con = redis_driver::cluster_key_connection(cluster, &key).await?;+ redis_driver::ensure_cluster_database(cluster, db).await?;+ let mut con = redis_driver::cluster_key_connection_in_db(cluster, &key, db).await?;redis_driver::set_hash_field_expire_at(&mut con, &key, field, expire_at).await}}@@ -617,8 +644,8 @@ pub async fn redis_list_push_in_db_core(redis_driver::list_push(&mut *con, &key, value, ttl).await}RedisConnection::Cluster(cluster) => {- redis_driver::ensure_cluster_db(db)?;- let mut con = redis_driver::cluster_key_connection(cluster, &key).await?;+ redis_driver::ensure_cluster_database(cluster, db).await?;+ let mut con = redis_driver::cluster_key_connection_in_db(cluster, &key, db).await?;redis_driver::list_push(&mut con, &key, value, ttl).await}}@@ -647,8 +674,8 @@ pub async fn redis_list_set_in_db_core(redis_driver::list_set(&mut *con, &key, index, value).await}RedisConnection::Cluster(cluster) => {- redis_driver::ensure_cluster_db(db)?;- let mut con = redis_driver::cluster_key_connection(cluster, &key).await?;+ redis_driver::ensure_cluster_database(cluster, db).await?;+ let mut con = redis_driver::cluster_key_connection_in_db(cluster, &key, db).await?;redis_driver::list_set(&mut con, &key, index, value).await}}@@ -685,8 +712,8 @@ pub async fn redis_list_remove_in_db_core(redis_driver::list_remove(&mut *con, &key, index).await}RedisConnection::Cluster(cluster) => {- redis_driver::ensure_cluster_db(db)?;- let mut con = redis_driver::cluster_key_connection(cluster, &key).await?;+ redis_driver::ensure_cluster_database(cluster, db).await?;+ let mut con = redis_driver::cluster_key_connection_in_db(cluster, &key, db).await?;redis_driver::list_remove(&mut con, &key, index).await}}@@ -725,8 +752,8 @@ pub async fn redis_set_add_in_db_core(redis_driver::set_add(&mut *con, &key, member, ttl).await}RedisConnection::Cluster(cluster) => {- redis_driver::ensure_cluster_db(db)?;- let mut con = redis_driver::cluster_key_connection(cluster, &key).await?;+ redis_driver::ensure_cluster_database(cluster, db).await?;+ let mut con = redis_driver::cluster_key_connection_in_db(cluster, &key, db).await?;redis_driver::set_add(&mut con, &key, member, ttl).await}}@@ -763,8 +790,8 @@ pub async fn redis_set_remove_in_db_core(redis_driver::set_remove(&mut *con, &key, member).await}RedisConnection::Cluster(cluster) => {- redis_driver::ensure_cluster_db(db)?;- let mut con = redis_driver::cluster_key_connection(cluster, &key).await?;+ redis_driver::ensure_cluster_database(cluster, db).await?;+ let mut con = redis_driver::cluster_key_connection_in_db(cluster, &key, db).await?;redis_driver::set_remove(&mut con, &key, member).await}}@@ -794,8 +821,8 @@ pub async fn redis_zadd_in_db_core(redis_driver::zadd(&mut *con, &key, member, score, ttl).await}RedisConnection::Cluster(cluster) => {- redis_driver::ensure_cluster_db(db)?;- let mut con = redis_driver::cluster_key_connection(cluster, &key).await?;+ redis_driver::ensure_cluster_database(cluster, db).await?;+ let mut con = redis_driver::cluster_key_connection_in_db(cluster, &key, db).await?;redis_driver::zadd(&mut con, &key, member, score, ttl).await}}@@ -823,8 +850,8 @@ pub async fn redis_zrem_in_db_core(redis_driver::zrem(&mut *con, &key, member).await}RedisConnection::Cluster(cluster) => {- redis_driver::ensure_cluster_db(db)?;- let mut con = redis_driver::cluster_key_connection(cluster, &key).await?;+ redis_driver::ensure_cluster_database(cluster, db).await?;+ let mut con = redis_driver::cluster_key_connection_in_db(cluster, &key, db).await?;redis_driver::zrem(&mut con, &key, member).await}}@@ -855,8 +882,8 @@ pub async fn redis_zset_update_in_db_core(redis_driver::zset_update(&mut *con, &key, original_member, expected_score, member, score).await}RedisConnection::Cluster(cluster) => {- redis_driver::ensure_cluster_db(db)?;- let mut con = redis_driver::cluster_key_connection(cluster, &key).await?;+ redis_driver::ensure_cluster_database(cluster, db).await?;+ let mut con = redis_driver::cluster_key_connection_in_db(cluster, &key, db).await?;redis_driver::zset_update(&mut con, &key, original_member, expected_score, member, score).await}}@@ -886,8 +913,8 @@ pub async fn redis_stream_add_in_db_core(redis_driver::stream_add(&mut *con, &key, entry_id, &fields, ttl).await}RedisConnection::Cluster(cluster) => {- redis_driver::ensure_cluster_db(db)?;- let mut con = redis_driver::cluster_key_connection(cluster, &key).await?;+ redis_driver::ensure_cluster_database(cluster, db).await?;+ let mut con = redis_driver::cluster_key_connection_in_db(cluster, &key, db).await?;redis_driver::stream_add(&mut con, &key, entry_id, &fields, ttl).await}}@@ -916,8 +943,8 @@ pub async fn redis_json_set_in_db_core(redis_driver::json_set(&mut *con, &key, value, ttl).await}RedisConnection::Cluster(cluster) => {- redis_driver::ensure_cluster_db(db)?;- let mut con = redis_driver::cluster_key_connection(cluster, &key).await?;+ redis_driver::ensure_cluster_database(cluster, db).await?;+ let mut con = redis_driver::cluster_key_connection_in_db(cluster, &key, db).await?;redis_driver::json_set(&mut con, &key, value, ttl).await}}@@ -941,8 +968,8 @@ pub async fn redis_check_json_module_in_db_core(redis_driver::check_json_module(&mut *con).await}RedisConnection::Cluster(cluster) => {- redis_driver::ensure_cluster_db(db)?;- let mut con = redis_driver::cluster_any_connection(cluster).await?;+ redis_driver::ensure_cluster_database(cluster, db).await?;+ let mut con = redis_driver::cluster_any_connection_in_db(cluster, db).await?;redis_driver::check_json_module(&mut con).await}},@@ -969,8 +996,8 @@ pub async fn redis_set_ttl_in_db_core(redis_driver::set_ttl(&mut *con, &key, ttl).await}RedisConnection::Cluster(cluster) => {- redis_driver::ensure_cluster_db(db)?;- let mut con = redis_driver::cluster_key_connection(cluster, &key).await?;+ redis_driver::ensure_cluster_database(cluster, db).await?;+ let mut con = redis_driver::cluster_key_connection_in_db(cluster, &key, db).await?;redis_driver::set_ttl(&mut con, &key, ttl).await}}@@ -998,8 +1025,8 @@ pub async fn redis_set_expire_at_in_db_core(redis_driver::set_expire_at(&mut *con, &key, expire_at).await}RedisConnection::Cluster(cluster) => {- redis_driver::ensure_cluster_db(db)?;- let mut con = redis_driver::cluster_key_connection(cluster, &key).await?;+ redis_driver::ensure_cluster_database(cluster, db).await?;+ let mut con = redis_driver::cluster_key_connection_in_db(cluster, &key, db).await?;redis_driver::set_expire_at(&mut con, &key, expire_at).await}}@@ -1050,12 +1077,12 @@ async fn apply_redis_keys_expiry(redis_driver::set_keys_expiry(&mut *con, &keys, expiry).await}RedisConnection::Cluster(cluster) => {- redis_driver::ensure_cluster_db(db)?;+ redis_driver::ensure_cluster_database(cluster, db).await?;// A cluster pipeline cannot span slots, so every key keeps// its own slot-routed connection, like `redis_delete_keys`.let mut result = RedisKeysExpiryResult::default();for key in &keys {- let mut con = redis_driver::cluster_key_connection(cluster, key).await?;+ let mut con = redis_driver::cluster_key_connection_in_db(cluster, key, db).await?;let applied =redis_driver::set_keys_expiry(&mut con, std::slice::from_ref(key), expiry).await?;result.applied += applied.applied;@@ -1089,10 +1116,10 @@ pub async fn redis_delete_keys_in_db_core(redis_driver::delete_keys(&mut *con, &keys).await}RedisConnection::Cluster(cluster) => {- redis_driver::ensure_cluster_db(db)?;+ redis_driver::ensure_cluster_database(cluster, db).await?;let mut deleted = 0;for key in &keys {- let mut con = redis_driver::cluster_key_connection(cluster, key).await?;+ let mut con = redis_driver::cluster_key_connection_in_db(cluster, key, db).await?;deleted += redis_driver::delete_keys(&mut con, std::slice::from_ref(key)).await?;}Ok(deleted)@@ -1130,7 +1157,7 @@ pub async fn redis_delete_keys_by_pattern_in_db_core(.await}RedisConnection::Cluster(cluster) => {- redis_driver::ensure_cluster_db(db)?;+ redis_driver::ensure_cluster_database(cluster, db).await?;// One node's SCAN only covers its own slots, so the subtree is// scanned node-by-node through the shared cluster cursor and// every key keeps its slot-routed connection, like@@ -1138,8 +1165,9 @@ pub async fn redis_delete_keys_by_pattern_in_db_core(let mut cursor = 0u64;let mut deleted = 0u64;loop {- let page = redis_driver::scan_cluster_keys_batch(+ let page = redis_driver::scan_cluster_keys_batch_in_db(cluster,+ db,cursor,pattern,redis_driver::DELETE_KEYS_BY_PATTERN_SCAN_COUNT,@@ -1149,7 +1177,7 @@ pub async fn redis_delete_keys_by_pattern_in_db_core(.await?;for key in &page.keys {let raw = redis_driver::redis_key_raw_to_bytes(&key.key_raw)?;- let mut con = redis_driver::cluster_key_connection(cluster, &raw).await?;+ let mut con = redis_driver::cluster_key_connection_in_db(cluster, &raw, db).await?;deleted += redis_driver::delete_keys(&mut con, std::slice::from_ref(&raw)).await?;}cursor = page.cursor;@@ -1174,8 +1202,8 @@ pub async fn redis_flush_db_core(state: &AppState, connection_id: &str, db: u32)redis_driver::flush_db(&mut *con).await}RedisConnection::Cluster(cluster) => {- redis_driver::ensure_cluster_db(db)?;- redis_driver::flush_cluster(cluster).await+ redis_driver::ensure_cluster_database(cluster, db).await?;+ redis_driver::flush_cluster_in_db(cluster, db).await}},_ => Err("Not a Redis connection".to_string()),@@ -1198,20 +1226,12 @@ pub async fn redis_execute_command_core(redis_driver::execute_console_command(&mut *con, db, command, skip_safety_check).await}RedisConnection::Cluster(cluster) => {- redis_driver::ensure_cluster_db(db)?;- let mut con = if let Ok(argv) = redis_driver::parse_command_argv(command) {- if let Some(command_name) = argv.first() {- if command_name.eq_ignore_ascii_case("SELECT") {- return Err("Redis Cluster only supports db0; SELECT is not available".to_string());- }- }- if command_may_target_first_key(&argv) {- redis_driver::cluster_key_connection(cluster, argv[1].as_bytes()).await?- } else {- redis_driver::cluster_any_connection(cluster).await?- }+ let argv = cluster_console_argv(command)?;+ redis_driver::ensure_cluster_database(cluster, db).await?;+ let mut con = if command_may_target_first_key(&argv) {+ redis_driver::cluster_key_connection_in_db(cluster, argv[1].as_bytes(), db).await?} else {- redis_driver::cluster_any_connection(cluster).await?+ redis_driver::cluster_any_connection_in_db(cluster, db).await?};redis_driver::execute_command(&mut con, command, skip_safety_check).await}@@ -1220,6 +1240,17 @@ pub async fn redis_execute_command_core(}}+fn cluster_console_argv(command: &str) -> Result<Vec<String>, String> {+ let argv = redis_driver::parse_command_argv(command)?;+ if argv.first().is_some_and(|name| name.eq_ignore_ascii_case("SELECT")) {+ return Err(+ "SELECT is not available on a shared cluster connection; switch databases using the database picker"+ .to_string(),+ );+ }+ Ok(argv)+}+fn command_may_target_first_key(argv: &[String]) -> bool {if argv.len() < 2 {return false;@@ -1254,10 +1285,19 @@ pub async fn redis_load_more_in_db_core(.await}RedisConnection::Cluster(cluster) => {- redis_driver::ensure_cluster_db(db)?;- let mut con = redis_driver::cluster_key_connection(cluster, &key).await?;- redis_driver::load_more_collection(&mut con, &key, key_type, cursor, count, filter, sort_direction)- .await+ redis_driver::ensure_cluster_database(cluster, db).await?;+ let mut con = redis_driver::cluster_key_connection_in_db(cluster, &key, db).await?;+ redis_driver::load_more_collection_scoped(+ &mut con,+ &key,+ key_type,+ cursor,+ count,+ filter,+ sort_direction,+ &redis_driver::RedisOperationScope { connection_id: connection_id.to_string(), db },+ )+ .await}}}@@ -1282,8 +1322,8 @@ pub async fn redis_publish_core(redis_driver::publish_message(&mut *con, channel, message).await}RedisConnection::Cluster(cluster) => {- redis_driver::ensure_cluster_db(db)?;- let mut con = redis_driver::cluster_any_connection(cluster).await?;+ redis_driver::ensure_cluster_database(cluster, db).await?;+ let mut con = redis_driver::cluster_any_connection_in_db(cluster, db).await?;redis_driver::publish_message(&mut con, channel, message).await}},@@ -1372,3 +1412,17 @@ pub async fn redis_cluster_master_nodes_core(_ => Err("Not a Redis connection".to_string()),}}++#[cfg(test)]+mod cluster_database_tests {+ #[test]+ fn cluster_console_rejects_parsed_select_with_picker_guidance() {+ for command in ["SELECT 1", "select 1", "\"SeLeCt\" 1", "SELE\\CT 1"] {+ let error = super::cluster_console_argv(command).unwrap_err();+ assert!(error.contains("database picker"), "{command}: {error}");+ assert!(!error.contains("only supports db0"));+ }+ assert_eq!(super::cluster_console_argv("GET key").unwrap(), ["GET", "key"]);+ assert!(super::cluster_console_argv("\"").is_err());+ }+}diff --git a/crates/dbx-core/tests/redis_cluster_databases.rs b/crates/dbx-core/tests/redis_cluster_databases.rsnew file mode 100644index 0000000000..e1c3dddd3c--- /dev/null+++ b/crates/dbx-core/tests/redis_cluster_databases.rs@@ -0,0 +1,733 @@+//! Opt-in acceptance tests for the disposable issue-1271 three-master fixtures.+//! No test starts servers or touches user DBX data. Three separately gated+//! tests flush fixture db1, disconnect exact test clients, or move one empty slot.++use std::collections::BTreeSet;+use std::sync::Arc;+use std::time::{SystemTime, UNIX_EPOCH};++use dbx_core::connection::{AppState, PoolKind};+use dbx_core::db::redis_driver::{+ cluster_any_connection_in_db, redis_key_bytes_to_raw, RedisClusterConnectionGuard, RedisCollectionPage,+ RedisConnection, RedisValueData,+};+use dbx_core::models::connection::{ConnectionConfig, DatabaseType};+use dbx_core::redis_ops::*;++const ID: &str = "issue-1271-core-live";+const PRIMARY: u16 = 17379;+const TAGS: [&str; 3] = ["dbx1271:delta", "dbx1271:alpha", "dbx1271:beta"];++struct Fixture {+ state: Arc<AppState>,+ // Drop state before removing its isolated metadata/plugin/agent directory.+ _directory: tempfile::TempDir,+ prefix: String,+}++impl Fixture {+ async fn open(port: u16, denied: bool) -> Self {+ assert_eq!(+ std::env::var("DBX_1271_CORE_FIXTURE").as_deref(),+ Ok("disposable-loopback"),+ "Only run against the task-owned disposable loopback fixtures"+ );+ assert!([PRIMARY, 17479, 18379].contains(&port));+ let directory = tempfile::tempdir().unwrap();+ let storage = dbx_core::persistence::test_storage::open(&directory.path().join("storage.db")).await.unwrap();+ let state = Arc::new(AppState::new_with_plugin_and_agent_dir_and_app_version(+ storage,+ directory.path().join("plugins"),+ directory.path().join("agents"),+ "0.0.0-test",+ ));+ let config: ConnectionConfig = serde_json::from_value(serde_json::json!({+ "id": ID, "name": "Disposable cluster database acceptance", "db_type": DatabaseType::Redis,+ "host": "127.0.0.1", "port": port,+ "username": if denied { "dbx1271-no-config" } else { "" },+ "password": if denied { "dbx1271-fixture-only" } else { "" },+ "database": null, "redis_connection_mode": "cluster",+ "redis_cluster_nodes": format!("127.0.0.1:{port},127.0.0.1:{},127.0.0.1:{}", port + 1, port + 2),+ "connect_timeout_secs": 5, "query_timeout_secs": 5,+ "idle_timeout_secs": 60, "keepalive_interval_secs": 0+ }))+ .unwrap();+ state.configs.write().await.insert(ID.to_string(), config);+ state.get_or_create_pool(ID, None).await.expect("connect disposable cluster through core");+ let nanos = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_nanos();+ Self { state, _directory: directory, prefix: format!("dbx1271-core-{}-{nanos}", std::process::id()) }+ }++ fn key(&self, tag: &str, kind: &str) -> String {+ format!("{}:{{{tag}}}:{kind}", self.prefix)+ }++ async fn set(&self, db: u32, key: &str, value: &str) {+ redis_set_string_in_db_core(&self.state, ID, db, &raw(key), value, None).await.unwrap();+ }++ async fn assert_string(&self, db: u32, key: &str, expected: &str) {+ let value = redis_get_value_in_db_core(&self.state, ID, db, &raw(key)).await.unwrap();+ match value.data {+ RedisValueData::String { content, .. } => assert_eq!(content.raw_base64, raw(expected)),+ other => panic!("expected string in db{db}, got {other:?}"),+ }+ }++ async fn cleanup(&self, keys: &[String]) {+ let raws: Vec<_> = keys.iter().map(|key| raw(key)).collect();+ for db in [0, 1] {+ redis_delete_keys_in_db_core(&self.state, ID, db, &raws).await.expect("remove only this run's keys");+ }+ }+}++fn raw(value: &str) -> String {+ redis_key_bytes_to_raw(value.as_bytes())+}++// Independent dedicated connections prove the core getter and setter did not+// both accidentally agree on the wrong DB. Never SELECT a shared core handle.+async fn assert_fresh_master_value(db: u32, key: &str, expected: Option<&str>) {+ let mut owners = 0;+ for port in PRIMARY..=PRIMARY + 2 {+ let client = redis::Client::open(format!("redis://127.0.0.1:{port}/{db}")).unwrap();+ let mut connection = client.get_multiplexed_async_connection().await.unwrap();+ let result: redis::RedisResult<Option<String>> = redis::cmd("GET").arg(key).query_async(&mut connection).await;+ match result {+ Ok(value) => {+ owners += 1;+ assert_eq!(value.as_deref(), expected, "fresh master {port}, db{db}, {key}");+ }+ Err(error) => assert_eq!(+ error.kind(),+ redis::ErrorKind::Server(redis::ServerErrorKind::Moved),+ "unexpected master error: {error}"+ ),+ }+ }+ assert_eq!(owners, 1, "exactly one master must own the key");+}++#[tokio::test]+#[ignore = "requires DBX_1271_CORE_FIXTURE=disposable-loopback and task Valkey 4-DB cluster"]+async fn core_cluster_database_operations_are_isolated_on_all_masters() {+ let fixture = Fixture::open(PRIMARY, false).await;+ let state = &fixture.state;+ let databases = redis_list_databases_core(state, ID).await.unwrap();+ assert_eq!(databases.iter().map(|item| item.db).collect::<Vec<_>>(), [0, 1, 2, 3]);+ assert_eq!(databases[2].keys, Some(0));+ assert_eq!(databases[3].keys, Some(0));+ let mut keys = Vec::new();+ let mut slot_ranges = BTreeSet::new();+ for tag in TAGS {+ let scalar = fixture.key(tag, "string");+ let slot = redis_execute_command_core(state, ID, 0, &format!("CLUSTER KEYSLOT {scalar}"), true)+ .await+ .unwrap()+ .value+ .as_u64()+ .expect("numeric hash slot");+ slot_ranges.insert(if slot <= 5460 {+ 0+ } else if slot <= 10922 {+ 1+ } else {+ 2+ });+ fixture.set(0, &scalar, "db0-sentinel").await;+ fixture.set(1, &scalar, "db1-value").await;+ for _ in 0..5 {+ tokio::join!(+ fixture.assert_string(0, &scalar, "db0-sentinel"),+ fixture.assert_string(1, &scalar, "db1-value")+ );+ }+ assert_fresh_master_value(0, &scalar, Some("db0-sentinel")).await;+ assert_fresh_master_value(1, &scalar, Some("db1-value")).await;+ redis_set_ttl_in_db_core(state, ID, 1, &raw(&scalar), 3600).await.unwrap();+ assert!((3500..=3600).contains(&redis_get_ttl_in_db_core(state, ID, 1, &raw(&scalar)).await.unwrap()));+ assert_eq!(redis_get_ttl_in_db_core(state, ID, 0, &raw(&scalar)).await.unwrap(), -1);+ let renamed = fixture.key(tag, "renamed");+ redis_rename_key_in_db_core(state, ID, 1, &raw(&scalar), &raw(&renamed)).await.unwrap();+ fixture.assert_string(1, &renamed, "db1-value").await;+ fixture.assert_string(0, &scalar, "db0-sentinel").await;+ assert_fresh_master_value(1, &scalar, None).await;+ keys.extend([scalar, renamed]);++ for kind in ["hash", "list", "set", "zset", "stream"] {+ let key = fixture.key(tag, kind);+ for db in [0, 1] {+ let value = format!("db{db}-{kind}");+ let key_raw = raw(&key);+ match kind {+ "hash" => redis_hash_set_in_db_core(state, ID, db, &key_raw, "field", &value, None).await.unwrap(),+ "list" => redis_list_push_in_db_core(state, ID, db, &key_raw, &value, None).await.unwrap(),+ "set" => redis_set_add_in_db_core(state, ID, db, &key_raw, &value, None).await.unwrap(),+ "zset" => redis_zadd_in_db_core(state, ID, db, &key_raw, &value, 1.0, None).await.unwrap(),+ "stream" => redis_stream_add_in_db_core(+ state,+ ID,+ db,+ &key_raw,+ "*",+ vec![("field".into(), value.clone())],+ None,+ )+ .await+ .unwrap(),+ _ => unreachable!(),+ }+ let result = redis_get_value_in_db_core(state, ID, db, &key_raw).await.unwrap();+ match result.data {+ RedisValueData::Hash { items, .. } => assert_eq!(items[0].value.raw_base64, raw(&value)),+ RedisValueData::List { items, .. } => assert_eq!(items[0].value.raw_base64, raw(&value)),+ RedisValueData::Set { items, .. } => assert_eq!(items[0].member.raw_base64, raw(&value)),+ RedisValueData::Zset { items, .. } => assert_eq!(items[0].member.raw_base64, raw(&value)),+ RedisValueData::Stream { entries, .. } => assert_eq!(entries[0].fields[0].value, value),+ other => panic!("unexpected {kind} response: {other:?}"),+ }+ }+ // Re-read db0 after the db1 write, rather than only before it.+ let db0 = redis_get_value_in_db_core(state, ID, 0, &raw(&key)).await.unwrap();+ let encoded = serde_json::to_string(&db0.data).unwrap();+ assert!(encoded.contains(&raw(&format!("db0-{kind}"))) || encoded.contains(&format!("db0-{kind}")));+ keys.push(key);+ }+ }+ assert_eq!(slot_ranges, BTreeSet::from([0, 1, 2]));+ for command in ["SELECT 1", "select 0", "\"SELECT\" 1"] {+ let error = redis_execute_command_core(state, ID, 1, command, true).await.unwrap_err();+ assert!(error.to_lowercase().contains("select"));+ assert!(error.to_lowercase().contains("picker"), "must explain safe database switching: {error}");+ }+ let raws: Vec<_> = keys.iter().map(|key| raw(key)).collect();+ assert_eq!(redis_delete_keys_in_db_core(state, ID, 1, &raws).await.unwrap(), 18);+ for tag in TAGS {+ assert_fresh_master_value(0, &fixture.key(tag, "string"), Some("db0-sentinel")).await;+ assert_fresh_master_value(1, &fixture.key(tag, "renamed"), None).await;+ }+ fixture.cleanup(&keys).await;+}++#[tokio::test]+#[ignore = "requires DBX_1271_CORE_FIXTURE=disposable-loopback and task Valkey 4-DB cluster"]+async fn core_cluster_scan_cursors_reject_other_databases_without_consuming_owner_cursor() {+ let fixture = Fixture::open(PRIMARY, false).await;+ let state = &fixture.state;+ let mut keys = Vec::new();+ for tag in TAGS {+ for index in 0..80 {+ let key = fixture.key(tag, &format!("scan-{index}"));+ fixture.set(0, &key, "db0-sentinel").await;+ fixture.set(1, &key, "db1-match").await;+ keys.push(key);+ }+ }+ let pattern = format!("{}:*", fixture.prefix);+ for value_scan in [false, true] {+ let first = if value_scan {+ redis_scan_values_core(state, ID, 1, 0, &pattern, "db1-match", false, 1).await.unwrap()+ } else {+ redis_scan_keys_core(state, ID, 1, 0, &pattern, 1).await.unwrap()+ };+ assert_ne!(first.cursor, 0, "fixture must exercise a continuation");+ let wrong = if value_scan {+ redis_scan_values_core(state, ID, 0, first.cursor, &pattern, "db1-match", false, 1).await+ } else {+ redis_scan_keys_core(state, ID, 0, first.cursor, &pattern, 1).await+ };+ assert!(wrong.is_err(), "cross-database cursor must fail closed");+ let mut cursor = first.cursor;+ let mut found: BTreeSet<_> = first.keys.into_iter().map(|item| item.key_raw).collect();+ for _ in 0..2000 {+ let page = if value_scan {+ redis_scan_values_core(state, ID, 1, cursor, &pattern, "db1-match", false, 20).await.unwrap()+ } else {+ redis_scan_keys_core(state, ID, 1, cursor, &pattern, 20).await.unwrap()+ };+ found.extend(page.keys.into_iter().map(|item| item.key_raw));+ cursor = page.cursor;+ if cursor == 0 {+ break;+ }+ }+ assert_eq!(cursor, 0, "bounded scan must terminate");+ assert_eq!(found, keys.iter().map(|key| raw(key)).collect());+ }+ fixture.cleanup(&keys).await;+}++#[tokio::test]+#[ignore = "requires DBX_1271_CORE_FIXTURE=disposable-loopback and task Valkey 4-DB cluster"]+async fn core_cluster_collection_cursor_is_database_scoped() {+ let fixture = Fixture::open(PRIMARY, false).await;+ let key = fixture.key(TAGS[0], "paged-hash");+ for db in [0, 1] {+ // 400 compact fields stay listpack-encoded in the stock fixture;+ // HSCAN returns a page larger than DBX's 200-item display limit.+ let mut command = format!("HSET {key}");+ for index in 0..400 {+ command.push_str(&format!(" f{index} db{db}-{index}"));+ }+ redis_execute_command_core(&fixture.state, ID, db, &command, true).await.unwrap();+ }+ let initial = redis_get_value_in_db_core(&fixture.state, ID, 1, &raw(&key)).await.unwrap();+ let (items, cursor) = match initial.data {+ RedisValueData::Hash { items, scan_cursor: Some(cursor), .. } => (items, cursor),+ other => panic!("fixture must produce a buffered hash continuation: {other:?}"),+ };+ assert_eq!(items.len(), 200);+ let wrong = redis_load_more_in_db_core(&fixture.state, ID, 0, &raw(&key), "hash", cursor, 200, None, None).await;+ assert!(wrong.is_err(), "db0 must not consume db1 buffered hash data");+ let other_id = "issue-1271-other-core-connection";+ let mut other_config = fixture.state.configs.read().await.get(ID).unwrap().clone();+ other_config.id = other_id.to_string();+ fixture.state.configs.write().await.insert(other_id.to_string(), other_config);+ fixture.state.get_or_create_pool(other_id, None).await.unwrap();+ let wrong_connection =+ redis_load_more_in_db_core(&fixture.state, other_id, 1, &raw(&key), "hash", cursor, 200, None, None).await;+ assert!(wrong_connection.is_err(), "another connection must not consume the owner cursor");+ let page =+ redis_load_more_in_db_core(&fixture.state, ID, 1, &raw(&key), "hash", cursor, 200, None, None).await.unwrap();+ match page {+ RedisCollectionPage::Hash { items: more, .. } => {+ let found: BTreeSet<_> = items.into_iter().chain(more).map(|item| item.value.raw_base64).collect();+ let expected: BTreeSet<_> = (0..400).map(|index| raw(&format!("db1-{index}"))).collect();+ assert_eq!(found, expected);+ }+ other => panic!("expected hash continuation: {other:?}"),+ }+ fixture.cleanup(&[key]).await;+}++#[tokio::test]+#[ignore = "requires DBX_1271_CORE_FIXTURE=disposable-loopback and all task control clusters"]+async fn core_cluster_capability_controls_and_config_denial_remain_usable() {+ for port in [17479, 18379] {+ let fixture = Fixture::open(port, false).await;+ let databases = redis_list_databases_core(&fixture.state, ID).await.unwrap();+ assert_eq!(databases.iter().map(|item| item.db).collect::<Vec<_>>(), [0]);+ let key = fixture.key(TAGS[0], "control");+ fixture.set(0, &key, "control-db0").await;+ fixture.assert_string(0, &key, "control-db0").await;+ assert!(redis_get_value_in_db_core(&fixture.state, ID, 1, &raw(&key)).await.is_err());+ redis_delete_key_in_db_core(&fixture.state, ID, 0, &raw(&key)).await.unwrap();+ }+ let fixture = Fixture::open(PRIMARY, true).await;+ let databases = redis_list_databases_core(&fixture.state, ID).await.unwrap();+ assert_eq!(databases.iter().map(|item| item.db).collect::<Vec<_>>(), [0]);+ let key = fixture.key(TAGS[0], "acl");+ fixture.set(0, &key, "acl-db0").await;+ fixture.assert_string(0, &key, "acl-db0").await;+ let error = redis_get_value_in_db_core(&fixture.state, ID, 1, &raw(&key)).await.unwrap_err();+ assert!(error.to_uppercase().contains("CONFIG"), "actionable capability error required: {error}");+ redis_delete_key_in_db_core(&fixture.state, ID, 0, &raw(&key)).await.unwrap();+}++#[tokio::test]+#[ignore = "DESTRUCTIVE: also requires DBX_1271_ALLOW_FLUSH=task-primary-db1"]+async fn core_cluster_flush_db1_preserves_db0_on_every_master() {+ assert_eq!(std::env::var("DBX_1271_ALLOW_FLUSH").as_deref(), Ok("task-primary-db1"));+ let fixture = Fixture::open(PRIMARY, false).await;+ let mut keys = Vec::new();+ for tag in TAGS {+ let key = fixture.key(tag, "flush");+ fixture.set(0, &key, "db0-flush-sentinel").await;+ fixture.set(1, &key, "db1-flush-target").await;+ keys.push(key);+ }+ redis_flush_db_core(&fixture.state, ID, 1).await.unwrap();+ for key in &keys {+ fixture.assert_string(0, key, "db0-flush-sentinel").await;+ assert_fresh_master_value(0, key, Some("db0-flush-sentinel")).await;+ assert_fresh_master_value(1, key, None).await;+ }+ fixture.cleanup(&keys).await;+}++fn client_field<'a>(info: &'a str, field: &str) -> &'a str {+ info.split_whitespace()+ .filter_map(|item| item.split_once('='))+ .find_map(|(key, value)| (key == field).then_some(value))+ .unwrap_or_else(|| panic!("CLIENT INFO omitted {field}: {info}"))+}++fn node_route(port: u16) -> redis::cluster_routing::RoutingInfo {+ redis::cluster_routing::RoutingInfo::SingleNode(redis::cluster_routing::SingleNodeRoutingInfo::ByAddress {+ host: "127.0.0.1".to_string(),+ port,+ })+}++#[tokio::test]+#[ignore = "DISCONNECTS EXACT TEST CLIENTS: also requires DBX_1271_ALLOW_RECONNECT=exact-test-clients"]+async fn core_cluster_db1_reconnect_restores_database_on_every_master() {+ assert_eq!(std::env::var("DBX_1271_ALLOW_RECONNECT").as_deref(), Ok("exact-test-clients"));+ let fixture = Fixture::open(PRIMARY, false).await;+ let mut keys = Vec::new();+ for tag in TAGS {+ let key = fixture.key(tag, "reconnect");+ fixture.set(0, &key, "db0-reconnect-sentinel").await;+ fixture.set(1, &key, "db1-reconnect-value").await;+ keys.push(key);+ }+ let pool = fixture.state.pool_handle(ID).await.unwrap();+ let PoolKind::Redis(redis) = &pool else { panic!("expected Redis core pool") };+ let RedisConnection::Cluster(cluster) = redis.as_ref() else { panic!("expected native cluster") };+ let mut connection = match cluster_any_connection_in_db(cluster, 1).await.unwrap() {+ RedisClusterConnectionGuard::Database(connection) => connection,+ _ => panic!("db1 must use the core pool's database-fixed native cluster handle"),+ };+ let name = format!("{}-reconnect-client", fixture.prefix);+ let mut clients = Vec::new();+ for port in PRIMARY..=PRIMARY + 2 {+ connection+ .route_command(redis::cmd("CLIENT").arg("SETNAME").arg(&name).clone(), node_route(port))+ .await+ .unwrap();+ let info: String = redis::from_redis_value(+ connection.route_command(redis::cmd("CLIENT").arg("INFO").clone(), node_route(port)).await.unwrap(),+ )+ .unwrap();+ assert_eq!(client_field(&info, "name"), name);+ assert_eq!(client_field(&info, "db"), "1");+ let id = client_field(&info, "id").parse::<u64>().unwrap();+ assert!(id > 0);+ clients.push((port, id));+ println!("before-reconnect port={port} id={id} db=1 name={name}");+ }+ // Do not kill by address, type, database, or name. Recheck every exact ID+ // immediately before killing; no unrelated app/client can enter this set.+ for &(port, id) in &clients {+ let client = redis::Client::open(format!("redis://127.0.0.1:{port}/0")).unwrap();+ let mut admin = client.get_multiplexed_async_connection().await.unwrap();+ let list: String = redis::cmd("CLIENT").arg("LIST").arg("ID").arg(id).query_async(&mut admin).await.unwrap();+ assert_eq!(list.lines().count(), 1, "exact client must still exist");+ assert_eq!(client_field(&list, "name"), name, "refusing to kill non-test client");+ assert_eq!(client_field(&list, "id"), id.to_string());+ assert_eq!(client_field(&list, "db"), "1");+ let killed: u64 = redis::cmd("CLIENT").arg("KILL").arg("ID").arg(id).query_async(&mut admin).await.unwrap();+ assert_eq!(killed, 1);+ println!("exact-test-client-killed port={port} id={id}");+ }+ tokio::time::timeout(std::time::Duration::from_secs(30), async {+ for &(port, old_id) in &clients {+ let info: String = loop {+ match connection.route_command(redis::cmd("CLIENT").arg("INFO").clone(), node_route(port)).await {+ Ok(value) => break redis::from_redis_value(value).unwrap(),+ Err(_) => tokio::time::sleep(std::time::Duration::from_millis(100)).await,+ }+ };+ let new_id = client_field(&info, "id").parse::<u64>().unwrap();+ assert_ne!(new_id, old_id);+ assert_eq!(client_field(&info, "db"), "1", "new node connection must restore db1");+ println!("after-reconnect port={port} old_id={old_id} new_id={new_id} db=1");+ }+ for key in &keys {+ tokio::join!(+ fixture.assert_string(0, key, "db0-reconnect-sentinel"),+ fixture.assert_string(1, key, "db1-reconnect-value")+ );+ assert_fresh_master_value(0, key, Some("db0-reconnect-sentinel")).await;+ assert_fresh_master_value(1, key, Some("db1-reconnect-value")).await;+ }+ })+ .await+ .expect("database-fixed core handles must recover within 30 seconds");+ fixture.cleanup(&keys).await;+}++type Admins = Vec<(u16, redis::aio::MultiplexedConnection)>;+type SlotMap = Vec<(u16, u16, String)>;++async fn topology_snapshot(admin: &mut redis::aio::MultiplexedConnection) -> Result<SlotMap, String> {+ let info: String = redis::cmd("CLUSTER").arg("INFO").query_async(admin).await.map_err(|e| e.to_string())?;+ for expected in ["cluster_state:ok", "cluster_slots_assigned:16384", "cluster_slots_ok:16384"] {+ if !info.lines().any(|line| line.trim() == expected) {+ return Err(format!("cluster not healthy: missing {expected}; {info}"));+ }+ }+ let nodes: String = redis::cmd("CLUSTER").arg("NODES").query_async(admin).await.map_err(|e| e.to_string())?;+ if nodes.lines().any(|line| line.split_whitespace().skip(8).any(|field| field.starts_with('['))) {+ return Err("cluster has migrating/importing slots".to_string());+ }+ let rows: Vec<Vec<redis::Value>> =+ redis::cmd("CLUSTER").arg("SLOTS").query_async(admin).await.map_err(|e| e.to_string())?;+ let mut slots = Vec::new();+ for row in rows {+ let [start, end, master, ..] = row.as_slice() else { return Err("malformed CLUSTER SLOTS".into()) };+ let start: u16 = redis::from_redis_value(start.clone()).map_err(|e| e.to_string())?;+ let end: u16 = redis::from_redis_value(end.clone()).map_err(|e| e.to_string())?;+ let master: Vec<redis::Value> = redis::from_redis_value(master.clone()).map_err(|e| e.to_string())?;+ let id: String =+ redis::from_redis_value(master.get(2).ok_or("master ID missing")?.clone()).map_err(|e| e.to_string())?;+ slots.push((start, end, id));+ }+ slots.sort_by_key(|row| row.0);+ let mut next = 0_u32;+ for (start, end, _) in &slots {+ if u32::from(*start) != next || end < start {+ return Err("slot map has a gap or overlap".into());+ }+ next = u32::from(*end) + 1;+ }+ if next != 16384 {+ return Err(format!("expected all16384 slots, got {next}"));+ }+ Ok(slots)+}++fn slot_owner(slots: &SlotMap, slot: u16) -> Result<&str, String> {+ slots+ .iter()+ .find(|(start, end, _)| *start <= slot && slot <= *end)+ .map(|(_, _, id)| id.as_str())+ .ok_or_else(|| format!("no owner for slot {slot}"))+}++async fn wait_for_owner(admins: &mut Admins, slot: u16, owner: &str) -> Result<(), String> {+ let mut last = String::new();+ for _ in 0..50 {+ let mut ready = true;+ for (port, admin) in admins.iter_mut() {+ match topology_snapshot(admin).await {+ Ok(slots) if slot_owner(&slots, slot)? == owner => {}+ Ok(_) => {+ ready = false;+ last = format!("port {port} has a different owner");+ }+ Err(error) => {+ ready = false;+ last = format!("port {port}: {error}");+ }+ }+ }+ if ready {+ return Ok(());+ }+ tokio::time::sleep(std::time::Duration::from_millis(100)).await;+ }+ Err(format!("slot {slot} did not converge to {owner}: {last}"))+}++async fn slot_is_empty_everywhere(admins: &mut Admins, slot: u16) -> Result<bool, String> {+ let mut empty = true;+ for (port, admin) in admins.iter_mut() {+ for db in 0..4 {+ redis::cmd("SELECT").arg(db).query_async::<()>(admin).await.map_err(|e| e.to_string())?;+ let mut cursor = 0_u64;+ let mut completed = false;+ for _ in 0..10_000 {+ let (next, keys): (u64, Vec<Vec<u8>>) = redis::cmd("SCAN")+ .arg(cursor)+ .arg("COUNT")+ .arg(1000)+ .query_async(admin)+ .await+ .map_err(|e| e.to_string())?;+ for key in keys {+ let key_slot: u16 = redis::cmd("CLUSTER")+ .arg("KEYSLOT")+ .arg(key)+ .query_async(admin)+ .await+ .map_err(|e| e.to_string())?;+ if key_slot == slot {+ empty = false;+ }+ }+ cursor = next;+ if cursor == 0 {+ completed = true;+ break;+ }+ }+ if !completed {+ return Err(format!("bounded full SCAN did not complete on {port} db{db}"));+ }+ }+ }+ Ok(empty)+}++async fn assign_empty_slot(admins: &mut Admins, slot: u16, owner: &str) -> Result<(), String> {+ // Attempt every node even when one fails, so restoration is not abandoned+ // after a partial update. Caller always checks consensus afterward.+ let mut errors = Vec::new();+ for (port, admin) in admins.iter_mut() {+ if let Err(error) =+ redis::cmd("CLUSTER").arg("SETSLOT").arg(slot).arg("NODE").arg(owner).query_async::<()>(admin).await+ {+ errors.push(format!("{port}: {error}"));+ }+ }+ if errors.is_empty() {+ Ok(())+ } else {+ Err(format!("slot {slot} -> {owner}: {}", errors.join("; ")))+ }+}++async fn delete_slot_test_keys(admins: &mut Admins, keys: &[String]) -> Result<(), String> {+ let mut errors = Vec::new();+ for (port, admin) in admins.iter_mut() {+ for db in [0, 1] {+ if let Err(error) = redis::cmd("SELECT").arg(db).query_async::<()>(admin).await {+ errors.push(format!("{port} db{db} SELECT: {error}"));+ continue;+ }+ for key in keys {+ match redis::cmd("DEL").arg(key).query_async::<u64>(admin).await {+ Ok(_) => {}+ Err(error) if error.kind() == redis::ErrorKind::Server(redis::ServerErrorKind::Moved) => {}+ Err(error) => errors.push(format!("{port} db{db} exact key {key}: {error}")),+ }+ }+ }+ }+ if errors.is_empty() {+ Ok(())+ } else {+ Err(errors.join("; "))+ }+}++async fn assert_topology_core_values(fixture: &Fixture, keys: &[String]) -> Result<(), String> {+ for key in keys {+ for db in [0, 1] {+ let expected = format!("db{db}-slot-value");+ redis_set_string_in_db_core(&fixture.state, ID, db, &raw(key), &expected, None).await?;+ let result = redis_get_value_in_db_core(&fixture.state, ID, db, &raw(key)).await?;+ match result.data {+ RedisValueData::String { content, .. } if content.raw_base64 == raw(&expected) => {}+ other => return Err(format!("wrong slot value in db{db}: {other:?}")),+ }+ }+ // Re-read db0 after db1 writes to detect shared-selection corruption.+ let result = redis_get_value_in_db_core(&fixture.state, ID, 0, &raw(key)).await?;+ match result.data {+ RedisValueData::String { content, .. } if content.raw_base64 == raw("db0-slot-value") => {}+ other => return Err(format!("db1 write changed db0: {other:?}")),+ }+ }+ Ok(())+}++async fn assert_topology_direct_values(admins: &mut Admins, keys: &[String], owner_port: u16) -> Result<(), String> {+ let (_, admin) = admins.iter_mut().find(|(port, _)| *port == owner_port).ok_or("owner admin missing")?;+ for db in [0, 1] {+ redis::cmd("SELECT").arg(db).query_async::<()>(admin).await.map_err(|e| e.to_string())?;+ for key in keys {+ let actual: String = redis::cmd("GET").arg(key).query_async(admin).await.map_err(|e| e.to_string())?;+ if actual != format!("db{db}-slot-value") {+ return Err(format!("owner {owner_port} db{db} wrong value"));+ }+ }+ }+ Ok(())+}++#[tokio::test]+#[ignore = "TOPOLOGY CHANGE: also requires DBX_1271_ALLOW_SLOT_MOVE=one-empty-slot"]+async fn core_cluster_empty_slot_owner_change_preserves_database_and_restores_topology() -> Result<(), String> {+ assert_eq!(std::env::var("DBX_1271_ALLOW_SLOT_MOVE").as_deref(), Ok("one-empty-slot"));+ let fixture = Fixture::open(PRIMARY, false).await;+ let mut admins = Vec::new();+ let mut master_ids = Vec::new();+ let mut baseline = None;+ for port in PRIMARY..=PRIMARY + 2 {+ let client = redis::Client::open(format!("redis://127.0.0.1:{port}/0")).map_err(|e| e.to_string())?;+ let mut admin = client.get_multiplexed_async_connection().await.map_err(|e| e.to_string())?;+ let slots = topology_snapshot(&mut admin).await?;+ if baseline.as_ref().is_some_and(|expected| *expected != slots) {+ return Err("initial maps disagree".into());+ }+ baseline = Some(slots);+ let id: String = redis::cmd("CLUSTER").arg("MYID").query_async(&mut admin).await.map_err(|e| e.to_string())?;+ master_ids.push((port, id));+ admins.push((port, admin));+ }+ let baseline = baseline.ok_or("initial slot map missing")?;+ if baseline.iter().map(|row| &row.2).collect::<BTreeSet<_>>().len() != 3 {+ return Err("expected exactly three masters".into());+ }+ // Warm both native core handles while their cached owner mapping is old.+ let pool = fixture.state.pool_handle(ID).await.ok_or("core pool missing")?;+ let PoolKind::Redis(redis) = &pool else { return Err("not Redis".into()) };+ let RedisConnection::Cluster(cluster) = redis.as_ref() else { return Err("not cluster".into()) };+ for db in [0, 1] {+ drop(cluster_any_connection_in_db(cluster, db).await?);+ }+ let mut chosen = None;+ for attempt in 0..256 {+ let key = fixture.key(&format!("{}-slot-{attempt}", fixture.prefix), "a");+ let slot: u16 = redis::cmd("CLUSTER")+ .arg("KEYSLOT")+ .arg(&key)+ .query_async(&mut admins[0].1)+ .await+ .map_err(|e| e.to_string())?;+ if slot_is_empty_everywhere(&mut admins, slot).await? {+ chosen = Some((slot, vec![key.clone(), format!("{key}:b")]));+ break;+ }+ }+ let (slot, keys) = chosen.ok_or("no verified empty slot found")?;+ let original = slot_owner(&baseline, slot)?.to_string();+ let original_port = master_ids.iter().find(|(_, id)| *id == original).ok_or("original owner unknown")?.0;+ let (new_port, new_owner) = master_ids.iter().find(|(_, id)| *id != original).ok_or("new owner missing")?.clone();+ println!("slot-change planned slot={slot} original={original}@{original_port} new={new_owner}@{new_port}");++ // From this point onward, all fallible work returns Result. No asserts,+ // unwraps or early '?' outside the operation/recovery blocks may bypass cleanup.+ let operation: Result<(), String> = tokio::time::timeout(std::time::Duration::from_secs(30), async {+ assign_empty_slot(&mut admins, slot, &new_owner).await?;+ wait_for_owner(&mut admins, slot, &new_owner).await?;+ assert_topology_core_values(&fixture, &keys).await?;+ assert_topology_direct_values(&mut admins, &keys, new_port).await?;+ println!("slot-change values verified slot={slot} owner={new_owner} db0/db1 distinct");+ Ok(())+ })+ .await+ .unwrap_or_else(|_| Err("slot operation exceeded 30 seconds; proceeding to recovery".into()));+ // This timeout is deliberately separate: timing out the entire test would+ // drop the restoration future instead of guaranteeing a recovery attempt.+ let recovery: Result<(), String> = tokio::time::timeout(std::time::Duration::from_secs(30), async {+ delete_slot_test_keys(&mut admins, &keys).await?;+ if !slot_is_empty_everywhere(&mut admins, slot).await? {+ return Err("refusing to restore a slot containing unexpected keys".into());+ }+ assign_empty_slot(&mut admins, slot, &original).await?;+ wait_for_owner(&mut admins, slot, &original).await?;+ for (_, admin) in admins.iter_mut() {+ let restored = topology_snapshot(admin).await?;+ // Adjacent ranges may stay split; compare semantic owner per slot.+ for candidate in 0..16384 {+ if slot_owner(&restored, candidate)? != slot_owner(&baseline, candidate)? {+ return Err(format!("restoration changed another slot {candidate}"));+ }+ }+ }+ println!("slot-change restored slot={slot} owner={original}; all16384 slots healthy and original");+ Ok(())+ })+ .await+ .unwrap_or_else(|_| Err("slot recovery exceeded 30 seconds; topology must be inspected manually".into()));+ if let Err(error) = recovery {+ return Err(format!("RECOVERY REQUIRED slot={slot} original={original}@{original_port} new={new_owner}@{new_port}; operation={operation:?}; recovery={error}"));+ }+ operation.map_err(|error| format!("slot={slot} original={original}@{original_port} new={new_owner}@{new_port}; topology restored; operation failed: {error}"))?;+ // Topology is restored now. Verify the warmed handles also follow it back.+ let restored_values = tokio::time::timeout(std::time::Duration::from_secs(30), async {+ assert_topology_core_values(&fixture, &keys).await?;+ assert_topology_direct_values(&mut admins, &keys, original_port).await+ })+ .await+ .unwrap_or_else(|_| Err("post-restoration value verification exceeded 30 seconds".into()));+ let cleanup = tokio::time::timeout(std::time::Duration::from_secs(10), delete_slot_test_keys(&mut admins, &keys))+ .await+ .unwrap_or_else(|_| Err(format!("exact-key cleanup exceeded 10 seconds; slot={slot}; keys={keys:?}")));+ restored_values?;+ cleanup+}diff --git a/crates/dbx-driver-redis/Cargo.toml b/crates/dbx-driver-redis/Cargo.tomlindex 6be021a92d..976cce758e 100644--- a/crates/dbx-driver-redis/Cargo.toml+++ b/crates/dbx-driver-redis/Cargo.toml@@ -13,7 +13,11 @@ test-support = []dbx-driver-support = { path = "../dbx-driver-support" }dbx-types = { path = "../dbx-types", default-features = false }base64 = "0.22"-redis = { version = "0.32.2", features = ["tokio-comp", "tls-rustls", "tls-rustls-insecure", "tokio-rustls-comp", "sentinel", "cluster-async"] }+redis = { version = "1.7.1", features = ["tokio-comp", "tls-rustls", "tls-rustls-insecure", "tokio-rustls-comp", "sentinel", "cluster-async"] }serde = { version = "1.0", features = ["derive"] }serde_json = { version = "1.0", features = ["arbitrary_precision", "preserve_order"] }tokio = { version = "1", features = ["full"] }++[dev-dependencies]+futures-util = "0.3"+rustls = { version = "0.23", default-features = false, features = ["aws-lc-rs", "std"] }diff --git a/crates/dbx-driver-redis/src/lib.rs b/crates/dbx-driver-redis/src/lib.rsindex ac9885ccb6..da996f7911 100644--- a/crates/dbx-driver-redis/src/lib.rs+++ b/crates/dbx-driver-redis/src/lib.rs@@ -2,15 +2,18 @@ use base64::Engine;use dbx_driver_support::db::{connection_timeout, json_value_for_js, safe_i64_to_json, CONNECTION_TIMEOUT_SECS};use dbx_types::models::connection::{ConnectionConfig, DatabaseConnectionInfo};use redis::{- aio::ConnectionLike,- cluster::ClusterClient,- cluster_async::ClusterConnection,- sentinel::{Sentinel, SentinelNodeConnectionInfo},- Cmd, ConnectionAddr, ConnectionInfo, FromRedisValue, Pipeline, ProtocolVersion, RedisConnectionInfo, RedisFuture,- TlsMode, Value as RedisRawValue,+ aio::ConnectionLike, cluster::ClusterClient, cluster_async::ClusterConnection, Cmd, ConnectionAddr, ConnectionInfo,+ FromRedisValue, IntoConnectionInfo, Pipeline, ProtocolVersion, RedisConnectionInfo, RedisFuture,+ Value as RedisRawValue,};use serde::{Deserialize, Serialize};-use std::{collections::HashMap, future::Future, sync::OnceLock, time::Duration, time::Instant};+use std::{+ collections::HashMap,+ future::Future,+ sync::{Arc, OnceLock},+ time::Duration,+ time::Instant,+};use tokio::sync::{Mutex, MutexGuard};const STREAM_ENTRY_PAGE_SIZE: usize = 50;@@ -28,6 +31,7 @@ const STRING_PREVIEW_MAX_BYTES: usize = 64 * 1024;const COLLECTION_PAGE_MAX_BYTES: usize = 4 * 1024 * 1024;const COLLECTION_FILTER_SCAN_MAX_ITERATIONS: usize = 10;const DEFAULT_REDIS_DATABASES: u32 = 16;+const MAX_CLUSTER_DATABASE_LIST_ENTRIES: u32 = 10_000;const JS_MAX_SAFE_INTEGER: u64 = 9_007_199_254_740_991;const CLUSTER_CURSOR_NODE_BITS: u64 = 16;const CLUSTER_CURSOR_NODE_MASK: u64 = (1 << CLUSTER_CURSOR_NODE_BITS) - 1;@@ -385,6 +389,8 @@ pub enum RedisConnection {pub fn redis_connection_test_stub() -> RedisConnection {RedisConnection::Cluster(RedisClusterPool {connection: None,+ database_connections: Box::new(tokio::sync::Mutex::new(HashMap::new())),+ database_capability: Box::new(tokio::sync::Mutex::new(None)),seed_nodes: Vec::new(),seed_routes: Vec::new(),slot_ranges: Vec::new(),@@ -397,8 +403,12 @@ pub fn redis_connection_test_stub() -> RedisConnection {})}+type RedisClusterDatabaseConnections = HashMap<u32, Arc<Mutex<Option<ClusterConnection>>>>;+pub struct RedisClusterPool {pub connection: Option<Mutex<ClusterConnection>>,+ database_connections: Box<Mutex<RedisClusterDatabaseConnections>>,+ database_capability: Box<Mutex<Option<ClusterDatabaseCapability>>>,pub seed_nodes: Vec<RedisNodeEndpoint>,pub seed_routes: Vec<RedisNodeRoute>,pub slot_ranges: Vec<RedisClusterSlotRange>,@@ -412,6 +422,9 @@ pub struct RedisClusterPool {#[derive(Debug, Clone)]struct RedisClusterKeyScanSession {+ db: u32,+ value_filter: Option<(String, bool)>,+ total_keys: u64,master_nodes: Vec<RedisNodeEndpoint>,node_cursors: Vec<u64>,node_complete: Vec<bool>,@@ -424,6 +437,9 @@ impl RedisClusterKeyScanSession {fn new(master_nodes: Vec<RedisNodeEndpoint>, pattern: &str) -> Self {let node_count = master_nodes.len();Self {+ db: 0,+ value_filter: None,+ total_keys: 0,master_nodes,node_cursors: vec![0; node_count],node_complete: vec![false; node_count],@@ -449,18 +465,11 @@ impl RedisClusterKeyScanSession {}}-#[derive(Debug)]+#[derive(Debug, Default)]struct RedisClusterScanSessions {- next_cursor: u64,entries: HashMap<u64, RedisClusterKeyScanSession>,}-impl Default for RedisClusterScanSessions {- fn default() -> Self {- Self { next_cursor: 1, entries: HashMap::new() }- }-}-impl RedisClusterScanSessions {fn take(&mut self, cursor: u64) -> Option<RedisClusterKeyScanSession> {self.remove_expired();@@ -487,9 +496,11 @@ impl RedisClusterScanSessions {}fn next_available_cursor(&mut self) -> u64 {+ // Pool-local counters could accept a token from another connection when+ // both pools happen to allocate the same cursor. Allocate process-wide.+ static NEXT_CURSOR: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);loop {- let cursor = self.next_cursor;- self.next_cursor = if cursor >= MAX_SAFE_INTEGER_CURSOR { 1 } else { cursor + 1 };+ let cursor = NEXT_CURSOR.fetch_add(1, std::sync::atomic::Ordering::Relaxed) % MAX_SAFE_INTEGER_CURSOR + 1;if cursor != 0 && !self.entries.contains_key(&cursor) {return cursor;}@@ -511,6 +522,7 @@ enum RedisCollectionOverflowItems {#[derive(Debug, Clone)]struct RedisCollectionOverflowSession {+ scope: RedisOperationScope,key: Vec<u8>,kind: RedisCollectionOverflowKind,filter: Option<String>,@@ -536,6 +548,7 @@ impl RedisCollectionOverflowSessions {fn take_matching(&mut self,cursor: u64,+ scope: &RedisOperationScope,key: &[u8],kind: RedisCollectionOverflowKind,filter: Option<&str>,@@ -543,7 +556,8 @@ impl RedisCollectionOverflowSessions {) -> Option<RedisCollectionOverflowSession> {self.remove_expired();let matches = self.entries.get(&cursor).is_some_and(|session| {- session.key == key+ session.scope == *scope+ && session.key == key&& session.kind == kind&& session.filter.as_deref() == filter&& session.sort_direction.as_deref() == sort_direction@@ -568,6 +582,12 @@ impl RedisCollectionOverflowSessions {fn reinsert(&mut self, cursor: u64, mut session: RedisCollectionOverflowSession) {self.remove_expired();+ while self.entries.len() >= COLLECTION_OVERFLOW_SESSION_LIMIT && !self.entries.contains_key(&cursor) {+ let Some(oldest) = self.entries.iter().min_by_key(|(_, entry)| entry.last_used).map(|(id, _)| *id) else {+ break;+ };+ self.entries.remove(&oldest);+ }session.last_used = Instant::now();self.entries.insert(cursor, session);}@@ -588,6 +608,13 @@ impl RedisCollectionOverflowSessions {}}+/// Stable request identity, independent of mutable SELECT state on a connection.+#[derive(Debug, Clone, Default, PartialEq, Eq)]+pub struct RedisOperationScope {+ pub connection_id: String,+ pub db: u32,+}+fn collection_overflow_sessions() -> &'static Mutex<RedisCollectionOverflowSessions> {static SESSIONS: OnceLock<Mutex<RedisCollectionOverflowSessions>> = OnceLock::new();SESSIONS.get_or_init(|| Mutex::new(RedisCollectionOverflowSessions::default()))@@ -624,6 +651,7 @@ pub struct RedisClusterSlotRange {pub enum RedisClusterConnectionGuard<'a> {Native(MutexGuard<'a, ClusterConnection>),+ Database(ClusterConnection),Direct(redis::aio::MultiplexedConnection),}@@ -643,6 +671,7 @@ impl ConnectionLike for RedisClusterConnectionGuard<'_> {fn req_packed_command<'a>(&'a mut self, cmd: &'a Cmd) -> RedisFuture<'a, RedisRawValue> {match self {RedisClusterConnectionGuard::Native(con) => con.req_packed_command(cmd),+ RedisClusterConnectionGuard::Database(con) => con.req_packed_command(cmd),RedisClusterConnectionGuard::Direct(con) => con.req_packed_command(cmd),}}@@ -655,6 +684,7 @@ impl ConnectionLike for RedisClusterConnectionGuard<'_> {) -> RedisFuture<'a, Vec<RedisRawValue>> {match self {RedisClusterConnectionGuard::Native(con) => con.req_packed_commands(cmd, offset, count),+ RedisClusterConnectionGuard::Database(con) => con.req_packed_commands(cmd, offset, count),RedisClusterConnectionGuard::Direct(con) => con.req_packed_commands(cmd, offset, count),}}@@ -662,6 +692,7 @@ impl ConnectionLike for RedisClusterConnectionGuard<'_> {fn get_db(&self) -> i64 {match self {RedisClusterConnectionGuard::Native(con) => con.get_db(),+ RedisClusterConnectionGuard::Database(con) => con.get_db(),RedisClusterConnectionGuard::Direct(con) => con.get_db(),}}@@ -679,7 +710,7 @@ pub async fn connect_standalone(timeout: std::time::Duration,) -> Result<redis::aio::MultiplexedConnection, String> {let mut last_error = None;- for info in standalone_connection_infos(config, host, port) {+ for info in standalone_connection_infos(config, host, port)? {let client = redis::Client::open(info).map_err(|e| format!("Redis connection failed: {e}"))?;match connect_client_with_timeout(client, timeout, "Redis").await {Ok(con) => return Ok(con),@@ -696,7 +727,11 @@ pub async fn connect_standalone(Err(last_error.unwrap_or_else(|| "Redis connection failed".to_string()))}-fn standalone_connection_infos(config: &ConnectionConfig, host: &str, port: u16) -> Vec<ConnectionInfo> {+fn standalone_connection_infos(+ config: &ConnectionConfig,+ host: &str,+ port: u16,+) -> Result<Vec<ConnectionInfo>, String> {redis_auth_candidates(&config.username, &config.password).into_iter().map(|auth| {@@ -718,7 +753,14 @@ async fn connect_client_with_timeout(timeout: std::time::Duration,label: &str,) -> Result<redis::aio::MultiplexedConnection, String> {- let mut con = tokio::time::timeout(timeout, client.get_multiplexed_async_connection())+ let options = redis_async_connection_config();+ // Type-erase the transport future here: otherwise downstream core operations+ // expand the entire redis-rs TCP/TLS future when proving Send, exceeding the+ // default recursion limit of their integration-test crates. This is not a+ // spawned task; dropping the caller still cancels connection establishment.+ let connect: RedisFuture<'_, redis::aio::MultiplexedConnection> =+ Box::pin(client.get_multiplexed_async_connection_with_config(&options));+ let mut con = tokio::time::timeout(timeout, connect).await.map_err(|_| format!("{label} connection timed out ({}s)", timeout.as_secs()))?.map_err(|e| format!("{label} connection failed: {e}"))?;@@ -733,28 +775,129 @@ async fn connect_client_with_timeout(}pub async fn connect_sentinel(config: &ConnectionConfig) -> Result<redis::aio::MultiplexedConnection, String> {+ connect_sentinel_with_timeout(config, connection_timeout()).await+}++async fn connect_sentinel_with_timeout(+ config: &ConnectionConfig,+ lookup_timeout: Duration,+) -> Result<redis::aio::MultiplexedConnection, String> {let service_name = config.redis_sentinel_master.trim();if service_name.is_empty() {return Err("Redis Sentinel master name is required".to_string());}let nodes = redis_sentinel_nodes(config)?;- let mut sentinel = Sentinel::build(nodes).map_err(|e| format!("Redis Sentinel connection failed: {e}"))?;- let node_connection_info = SentinelNodeConnectionInfo {- tls_mode: redis_tls_mode(config.ssl, config.redis_tls_insecure()),- redis_connection_info: Some(redis_connection_info(&config.username, &config.password, 0)),- };- let client = tokio::time::timeout(- connection_timeout(),- sentinel.async_master_for(service_name, Some(&node_connection_info)),- )- .await- .map_err(|_| format!("Redis Sentinel lookup timed out ({}s)", CONNECTION_TIMEOUT_SECS))?- .map_err(|e| format!("Redis Sentinel master lookup failed: {e}"))?;+ let client = tokio::time::timeout(lookup_timeout, sentinel_master_client(config, &nodes, service_name))+ .await+ .map_err(|_| format!("Redis Sentinel lookup timed out ({}s)", lookup_timeout.as_secs()))?+ .map_err(|e| format!("Redis Sentinel master lookup failed: {e}"))?;connect_client(client).await}+// redis-rs 1.x does not expose timeout configuration for Sentinel's private+// discovery/ROLE connections. Keep the 0.32 discovery contract here so the+// existing outer DBX lookup deadline, not new 500-ms/1-second defaults, applies.+// This is one-shot discovery, not a failover manager.+async fn sentinel_master_client(+ config: &ConnectionConfig,+ nodes: &[ConnectionInfo],+ service_name: &str,+) -> Result<redis::Client, String> {+ let masters = sentinel_masters(nodes).await.map_err(|error| error.to_string())?;+ for master in masters {+ let Some(endpoint) = sentinel_eligible_master(&master, service_name) else { continue };+ let client = redis::Client::open(connection_info(+ &endpoint.host,+ endpoint.port,+ config.ssl,+ config.redis_tls_insecure(),+ &config.username,+ &config.password,+ 0,+ )?)+ .map_err(|error| error.to_string())?;+ let mut con = client+ .get_multiplexed_async_connection_with_config(&redis_async_connection_config())+ .await+ .map_err(|error| error.to_string())?;+ if sentinel_is_master(&mut con).await.map_err(|error| error.to_string())? {+ return Ok(client);+ }+ }+ Err(format!("Master '{service_name}' not found among healthy Sentinel masters"))+}++async fn sentinel_masters(nodes: &[ConnectionInfo]) -> redis::RedisResult<Vec<HashMap<String, String>>> {+ let mut last_error = None;+ for info in nodes {+ let result = async {+ let client = redis::Client::open(info.clone())?;+ let mut con = client.get_multiplexed_async_connection_with_config(&redis_async_connection_config()).await?;+ let result = redis::cmd("SENTINEL").arg("MASTERS").query_async(&mut con).await;+ match result {+ // Match the old Sentinel client's single reconnect on an I/O+ // query failure, followed by trying the next configured node.+ Err(error) if error.is_io_error() || error.is_unrecoverable_error() => {+ let mut con =+ client.get_multiplexed_async_connection_with_config(&redis_async_connection_config()).await?;+ redis::cmd("SENTINEL").arg("MASTERS").query_async(&mut con).await+ }+ result => result,+ }+ }+ .await;+ match result {+ Ok(masters) => return Ok(masters),+ Err(error) => last_error = Some(error),+ }+ }+ Err(last_error.unwrap_or_else(|| {+ redis::RedisError::from((redis::ErrorKind::EmptySentinelList, "At least one Sentinel is required"))+ }))+}++fn sentinel_eligible_master(metadata: &HashMap<String, String>, service_name: &str) -> Option<RedisNodeEndpoint> {+ if metadata.get("name").map(String::as_str) != Some(service_name) {+ return None;+ }+ let flags = metadata.get("flags")?;+ if !flags.contains("master") || flags.contains("s_down") || flags.contains("o_down") {+ return None;+ }+ Some(RedisNodeEndpoint { host: metadata.get("ip")?.clone(), port: metadata.get("port")?.parse().ok()? })+}++async fn sentinel_is_master<C>(con: &mut C) -> redis::RedisResult<bool>+where+ C: ConnectionLike + Send + Sync + Unpin,+{+ let role_error = match redis::cmd("ROLE").query_async::<redis::Role>(con).await {+ Ok(role) => return Ok(matches!(role, redis::Role::Primary { .. })),+ Err(error) => error,+ };+ let fallback = redis::cmd("INFO").arg("REPLICATION").query_async::<String>(con).await.and_then(|info| {+ let roles: HashMap<_, _> = info+ .split("\r\n")+ .filter(|line| !line.trim_start().starts_with('#'))+ .filter_map(|line| line.split_once(':'))+ .collect();+ roles.get("role").map(|role| *role == "master").ok_or_else(|| {+ redis::RedisError::from((redis::ErrorKind::UnexpectedReturnType, "Missing role in INFO REPLICATION"))+ })+ });+ match fallback {+ Ok(is_master) => Ok(is_master),+ // Preserve the original error when ROLE failed for more than an+ // unavailable command; otherwise expose the INFO fallback failure.+ Err(_) if role_error.kind() != redis::ErrorKind::Server(redis::ServerErrorKind::ResponseError) => {+ Err(role_error)+ }+ Err(error) => Err(error),+ }+}+pub async fn discover_sentinel_master(config: &ConnectionConfig,host: &str,@@ -773,7 +916,7 @@ pub async fn discover_sentinel_master(&config.redis_sentinel_username,&config.redis_sentinel_password,0,- ))+ )?).map_err(|e| format!("Redis Sentinel connect failed: {e}"))?;let mut con = connect_client_with_timeout(client, connection_timeout(), "Redis Sentinel").await?;let raw = tokio::time::timeout(@@ -804,7 +947,7 @@ pub async fn connect_cluster(config: &ConnectionConfig) -> Result<RedisClusterPo0,)})- .collect();+ .collect::<Result<_, _>>()?;let client = ClusterClient::new(cluster_nodes).map_err(|e| format!("Redis cluster connection failed: {e}"))?;let mut con = match tokio::time::timeout(connection_timeout(), client.get_async_connection()).await@@ -850,6 +993,8 @@ pub async fn connect_cluster(config: &ConnectionConfig) -> Result<RedisClusterPolet node_routes = identity_routes(&unique_master_nodes(&slot_ranges));return Ok(RedisClusterPool {connection: Some(Mutex::new(con)),+ database_connections: Box::new(tokio::sync::Mutex::new(HashMap::new())),+ database_capability: Box::new(tokio::sync::Mutex::new(None)),seed_nodes,seed_routes,slot_ranges,@@ -916,8 +1061,10 @@ pub async fn connect_routed_cluster(auth: RedisClusterAuth,) -> Result<RedisClusterPool, String> {let seed_nodes = redis_cluster_seed_nodes(config)?;- let mut pool = RedisClusterPool {+ let pool = RedisClusterPool {connection: None,+ database_connections: Box::new(tokio::sync::Mutex::new(HashMap::new())),+ database_capability: Box::new(tokio::sync::Mutex::new(None)),seed_nodes,seed_routes,slot_ranges,@@ -928,9 +1075,6 @@ pub async fn connect_routed_cluster(password: auth.password,scan_sessions: Box::new(Mutex::new(RedisClusterScanSessions::default())),};- if pool.node_routes.is_empty() {- pool.node_routes = identity_routes(&unique_master_nodes(&pool.slot_ranges));- }{let mut con = cluster_any_connection(&pool).await?;redis_ping(&mut con, "Redis cluster", connection_timeout()).await?;@@ -1013,7 +1157,7 @@ fn redis_sentinel_nodes(config: &ConnectionConfig) -> Result<Vec<ConnectionInfo>redis_sentinel_node_endpoints(config)?.iter().map(|endpoint| {- Ok(connection_info(+ connection_info(&endpoint.host,endpoint.port,config.redis_sentinel_tls,@@ -1021,7 +1165,7 @@ fn redis_sentinel_nodes(config: &ConnectionConfig) -> Result<Vec<ConnectionInfo>&config.redis_sentinel_username,&config.redis_sentinel_password,0,- ))+ )}).collect()}@@ -1102,32 +1246,26 @@ fn connection_info(username: &str,password: &str,db: i64,-) -> ConnectionInfo {+) -> Result<ConnectionInfo, String> {let addr = if tls {ConnectionAddr::TcpTls { host: host.to_string(), port, insecure, tls_params: None }} else {ConnectionAddr::Tcp(host.to_string(), port)};- ConnectionInfo { addr, redis: redis_connection_info(username, password, db) }-}--fn redis_tls_mode(tls: bool, insecure: bool) -> Option<TlsMode> {- if !tls {- None- } else if insecure {- Some(TlsMode::Insecure)- } else {- Some(TlsMode::Secure)- }+ addr.into_connection_info()+ .map(|info| info.set_redis_settings(redis_connection_info(username, password, db)))+ .map_err(|error| format!("Redis connection configuration failed: {error}"))}fn redis_connection_info(username: &str, password: &str, db: i64) -> RedisConnectionInfo {- RedisConnectionInfo {- db,- username: non_empty_string(username),- password: non_empty_string(password),- protocol: ProtocolVersion::RESP2,+ let mut info = RedisConnectionInfo::default().set_db(db).set_protocol(ProtocolVersion::RESP2);+ if let Some(username) = non_empty_string(username) {+ info = info.set_username(username);+ }+ if let Some(password) = non_empty_string(password) {+ info = info.set_password(password);}+ info}fn redis_auth_candidates(username: &str, password: &str) -> Vec<RedisAuthCandidate> {@@ -1202,15 +1340,15 @@ fn parse_redis_port(port: &str) -> Result<u16, String> {port.parse::<u16>().map_err(|_| format!("Invalid Redis port '{port}'"))}-async fn connect_client(client: redis::Client) -> Result<redis::aio::MultiplexedConnection, String> {- let mut con = tokio::time::timeout(connection_timeout(), client.get_multiplexed_async_connection())- .await- .map_err(|_| format!("Redis connection timed out ({}s)", CONNECTION_TIMEOUT_SECS))?- .map_err(|e| format!("Redis connection failed: {e}"))?;-- redis_ping(&mut con, "Redis", connection_timeout()).await?;+fn redis_async_connection_config() -> redis::AsyncConnectionConfig {+ // redis-rs 1.x defaults to 1s connection / 500ms response deadlines. Keep DBX's+ // existing outer connection deadline and unrestricted command duration (for+ // blocking commands and large values), as with redis-rs 0.32.+ redis::AsyncConnectionConfig::new().set_connection_timeout(None).set_response_timeout(None)+}- Ok(con)+async fn connect_client(client: redis::Client) -> Result<redis::aio::MultiplexedConnection, String> {+ connect_client_with_timeout(client, connection_timeout(), "Redis").await}pub async fn connect_direct_node(@@ -1220,9 +1358,27 @@ pub async fn connect_direct_node(username: &str,password: &str,) -> Result<redis::aio::MultiplexedConnection, String> {- let client =- redis::Client::open(connection_info(&endpoint.host, endpoint.port, tls, insecure, username, password, 0))- .map_err(|e| format!("Redis connection failed: {e}"))?;+ connect_direct_node_in_db(endpoint, tls, insecure, username, password, 0).await+}++async fn connect_direct_node_in_db(+ endpoint: &RedisNodeEndpoint,+ tls: bool,+ insecure: bool,+ username: &str,+ password: &str,+ db: u32,+) -> Result<redis::aio::MultiplexedConnection, String> {+ let client = redis::Client::open(connection_info(+ &endpoint.host,+ endpoint.port,+ tls,+ insecure,+ username,+ password,+ i64::from(db),+ )?)+ .map_err(|e| format!("Redis connection failed: {e}"))?;connect_client(client).await}@@ -1233,10 +1389,11 @@ pub async fn connect_monitor(timeout: std::time::Duration,) -> Result<redis::aio::Monitor, String> {let mut last_error = String::new();- for info in standalone_connection_infos(config, host, port) {+ for info in standalone_connection_infos(config, host, port)? {let client = redis::Client::open(info).map_err(|error| error.to_string())?;let connect = async {- let mut validation = client.get_multiplexed_async_connection().await?;+ let mut validation =+ client.get_multiplexed_async_connection_with_config(&redis_async_connection_config()).await?;redis::cmd("MONITOR").query_async::<()>(&mut validation).await?;drop(validation);client.get_async_monitor().await@@ -1271,7 +1428,7 @@ pub async fn connect_pubsub(&auth.username,&auth.password,redis_database_index(config),- ))+ )?).map_err(|e| format!("Redis connection failed: {e}"))?;match tokio::time::timeout(timeout, client.get_async_pubsub()).await {Ok(Ok(pubsub)) => return Ok(pubsub),@@ -1329,9 +1486,9 @@ fn parse_database_count(value: redis::Value) -> Option<u32> {};values.windows(2).find_map(|pair| {- let key = String::from_redis_value(&pair[0]).ok()?;+ let key = String::from_redis_value(pair[0].clone()).ok()?;if key.eq_ignore_ascii_case("databases") {- String::from_redis_value(&pair[1]).ok()?.parse().ok()+ String::from_redis_value(pair[1].clone()).ok()?.parse().ok()} else {None}@@ -1402,7 +1559,7 @@ where}fn is_unavailable_db_zero_select(error: &redis::RedisError, db: u32) -> bool {- if db != 0 || error.kind() != redis::ErrorKind::ResponseError {+ if db != 0 || error.kind() != redis::ErrorKind::Server(redis::ServerErrorKind::ResponseError) {return false;}let detail = error.detail().unwrap_or_default().trim_start();@@ -1410,11 +1567,123 @@ fn is_unavailable_db_zero_select(error: &redis::RedisError, db: u32) -> bool {detail.get(..prefix_len).is_some_and(|prefix| prefix.eq_ignore_ascii_case("unknown command"))}-pub fn ensure_cluster_db(db: u32) -> Result<(), String> {- if db == 0 {- Ok(())+#[derive(Debug, Clone, PartialEq, Eq)]+enum ClusterDatabaseCapability {+ Known(u32),+ Unsupported,+ Unknown(String),+}++fn parse_cluster_database_capability(raw: RedisRawValue) -> Result<ClusterDatabaseCapability, String> {+ let entries = match raw {+ RedisRawValue::Array(entries) if entries.is_empty() => return Ok(ClusterDatabaseCapability::Unsupported),+ RedisRawValue::Map(entries) if entries.is_empty() => return Ok(ClusterDatabaseCapability::Unsupported),+ RedisRawValue::Array(entries) if entries.len() == 2 => entries,+ RedisRawValue::Map(mut entries) if entries.len() == 1 => {+ let (key, value) = entries.remove(0);+ vec![key, value]+ }+ _ => return Err("Malformed CONFIG GET cluster-databases response".to_string()),+ };+ if cluster_config_text(&entries[0]) != Some("cluster-databases") {+ return Err("Unexpected CONFIG GET cluster-databases setting".to_string());+ }+ let count = cluster_config_text(&entries[1])+ .filter(|value| !value.is_empty() && value.bytes().all(|byte| byte.is_ascii_digit()))+ .and_then(|value| value.parse::<u32>().ok())+ .filter(|count| *count > 0 && *count <= i32::MAX as u32)+ .ok_or("Invalid cluster-databases count: expected an integer from 1 through 2147483647")?;+ Ok(ClusterDatabaseCapability::Known(count))+}++fn cluster_config_text(value: &RedisRawValue) -> Option<&str> {+ // CONFIG GET returns string keys and values, not generic numeric RESP values.+ match value {+ RedisRawValue::BulkString(bytes) => std::str::from_utf8(bytes).ok(),+ RedisRawValue::SimpleString(text) => Some(text),+ _ => None,+ }+}++fn combine_cluster_database_capabilities(+ capabilities: Vec<ClusterDatabaseCapability>,+) -> Result<ClusterDatabaseCapability, String> {+ let mut known = None;+ let mut unsupported = false;+ let mut unknown = Vec::new();+ for capability in capabilities {+ match capability {+ ClusterDatabaseCapability::Known(count) => {+ if known.is_some_and(|previous| previous != count) || unsupported {+ return Err("Conflicting cluster-databases settings across cluster masters".to_string());+ }+ known = Some(count);+ }+ ClusterDatabaseCapability::Unsupported => {+ if known.is_some() {+ return Err("Conflicting cluster-databases support across cluster masters".to_string());+ }+ unsupported = true;+ }+ ClusterDatabaseCapability::Unknown(reason) => unknown.push(reason),+ }+ }+ if !unknown.is_empty() {+ return Ok(ClusterDatabaseCapability::Unknown(unknown.join("; ")));+ }+ if let Some(count) = known {+ Ok(ClusterDatabaseCapability::Known(count))+ } else if unsupported {+ Ok(ClusterDatabaseCapability::Unsupported)} else {- Err("Redis Cluster only supports db0".to_string())+ Err("Redis cluster has no masters for database discovery".to_string())+ }+}++async fn discover_cluster_database_capability(pool: &RedisClusterPool) -> Result<ClusterDatabaseCapability, String> {+ // An explicit metadata refresh invalidates stale success even if it fails.+ *pool.database_capability.lock().await = None;+ let mut capabilities = Vec::new();+ for endpoint in cluster_master_nodes(pool).await? {+ let mut con = connect_cluster_node(pool, &endpoint).await?;+ let capability = match redis::cmd("CONFIG").arg("GET").arg("cluster-databases").query_async(&mut con).await {+ Ok(raw) => parse_cluster_database_capability(raw)?,+ Err(error) if is_redis_command_denied_error(&error.to_string()) => {+ ClusterDatabaseCapability::Unknown(format!("{}:{}: {error}", endpoint.host, endpoint.port))+ }+ Err(error) => {+ return Err(format!("Database discovery on {}:{} failed: {error}", endpoint.host, endpoint.port))+ }+ };+ capabilities.push(capability);+ }+ let capability = combine_cluster_database_capabilities(capabilities)?;+ *pool.database_capability.lock().await = Some(capability.clone());+ Ok(capability)+}++pub async fn cluster_database_diagnostic(pool: &RedisClusterPool) -> Option<String> {+ match &*pool.database_capability.lock().await {+ Some(ClusterDatabaseCapability::Unknown(reason)) => Some(reason.clone()),+ _ => None,+ }+}++pub async fn ensure_cluster_database(pool: &RedisClusterPool, db: u32) -> Result<(), String> {+ // Permission-limited discovery must never make the existing db0 connection unusable.+ if db == 0 {+ return Ok(());+ }+ let cached = pool.database_capability.lock().await.clone();+ let capability = match cached {+ Some(capability @ ClusterDatabaseCapability::Known(_)) => capability,+ _ => discover_cluster_database_capability(pool).await?,+ };+ match capability {+ ClusterDatabaseCapability::Known(count) if db < count => Ok(()),+ ClusterDatabaseCapability::Known(count) => Err(format!("Database db{db} is outside this cluster's configured range db0–db{}; refresh the database list", count - 1)),+ ClusterDatabaseCapability::Unsupported => Err("This cluster does not expose multiple databases; use db0".to_string()),+ ClusterDatabaseCapability::Unknown(reason) => Err(format!("Cannot verify db{db}: {reason}. Allow CONFIG GET cluster-databases on all masters and refresh the database list; db0 remains available")),}}@@ -1438,9 +1707,64 @@ pub fn decode_cluster_cursor(cursor: u64) -> (usize, u64) {}pub async fn list_cluster_databases(pool: &RedisClusterPool) -> Result<Vec<RedisDatabaseInfo>, String> {+ let capability = discover_cluster_database_capability(pool).await?;+ let count = cluster_database_list_count(&capability)?;let master_nodes = cluster_master_nodes(pool).await?;- let keys = cluster_total_keys(pool, &master_nodes).await;- Ok(vec![RedisDatabaseInfo { db: 0, keys: Some(keys) }])+ let key_counts = cluster_database_key_counts(pool, &master_nodes).await.ok();+ Ok((0..count)+ .map(|db| RedisDatabaseInfo {+ db,+ keys: key_counts.as_ref().map(|counts| counts.get(&db).copied().unwrap_or(0)),+ })+ .collect())+}++fn cluster_database_list_count(capability: &ClusterDatabaseCapability) -> Result<u32, String> {+ let count = match *capability {+ ClusterDatabaseCapability::Known(count) => count,+ _ => 1,+ };+ if count > MAX_CLUSTER_DATABASE_LIST_ENTRIES {+ return Err(format!("This cluster is configured with {count} databases, exceeding the DBX database-list safety limit of {MAX_CLUSTER_DATABASE_LIST_ENTRIES}; no truncated list was returned"));+ }+ Ok(count)+}++fn parse_cluster_keyspace_counts(info: &str) -> Result<HashMap<u32, u64>, String> {+ if !info.lines().any(|line| line.trim() == "# Keyspace") {+ return Err("Missing INFO keyspace section".to_string());+ }+ let mut counts = HashMap::new();+ for line in info.lines().map(str::trim).filter(|line| line.starts_with("db")) {+ let (database, stats) = line.split_once(':').ok_or("Malformed INFO keyspace entry")?;+ let db = database[2..].parse::<u32>().map_err(|_| "Invalid INFO keyspace database")?;+ let keys = stats+ .split(',')+ .find_map(|stat| stat.strip_prefix("keys="))+ .and_then(|keys| keys.parse::<u64>().ok())+ .ok_or("Invalid INFO keyspace key count")?;+ if counts.insert(db, keys).is_some() {+ return Err("Duplicate INFO keyspace database".to_string());+ }+ }+ Ok(counts)+}++async fn cluster_database_key_counts(+ pool: &RedisClusterPool,+ masters: &[RedisNodeEndpoint],+) -> Result<HashMap<u32, u64>, String> {+ let mut totals: HashMap<u32, u64> = HashMap::new();+ for endpoint in masters {+ let mut con = connect_cluster_node(pool, endpoint).await?;+ let info: String =+ redis::cmd("INFO").arg("keyspace").query_async(&mut con).await.map_err(|error| error.to_string())?;+ for (db, keys) in parse_cluster_keyspace_counts(&info)? {+ let total = totals.entry(db).or_default();+ *total = total.checked_add(keys).ok_or("Cluster key count overflow")?;+ }+ }+ Ok(totals)}pub async fn scan_cluster_keys_page(@@ -1470,10 +1794,24 @@ pub async fn scan_cluster_keys_batch(max_iterations: usize,include_types: bool,) -> Result<RedisScanResult, String> {- scan_cluster_keys_batch_with(+ scan_cluster_keys_batch_in_db(pool, 0, cursor, pattern, count, max_iterations, include_types).await+}++pub async fn scan_cluster_keys_batch_in_db(+ pool: &RedisClusterPool,+ db: u32,+ cursor: u64,+ pattern: &str,+ count: usize,+ max_iterations: usize,+ include_types: bool,+) -> Result<RedisScanResult, String> {+ ensure_cluster_database(pool, db).await?;+ scan_cluster_keys_batch_in_db_with(&pool.scan_sessions,|| async { cluster_master_nodes(pool).await },- |endpoint| async move { connect_cluster_node(pool, &endpoint).await },+ |endpoint| async move { connect_cluster_node_in_db(pool, &endpoint, db).await },+ db,cursor,pattern,count,@@ -1483,10 +1821,43 @@ pub async fn scan_cluster_keys_batch(.await}+#[cfg(test)]async fn scan_cluster_keys_batch_with<C, Discover, DiscoverFuture, Connect, ConnectFuture>(+ sessions: &Mutex<RedisClusterScanSessions>,+ discover_master_nodes: Discover,+ connect_node: Connect,+ cursor: u64,+ pattern: &str,+ count: usize,+ max_iterations: usize,+ include_types: bool,+) -> Result<RedisScanResult, String>+where+ C: ConnectionLike + Send + Sync + Unpin,+ Discover: FnMut() -> DiscoverFuture,+ DiscoverFuture: Future<Output = Result<Vec<RedisNodeEndpoint>, String>>,+ Connect: FnMut(RedisNodeEndpoint) -> ConnectFuture,+ ConnectFuture: Future<Output = Result<C, String>>,+{+ scan_cluster_keys_batch_in_db_with(+ sessions,+ discover_master_nodes,+ connect_node,+ 0,+ cursor,+ pattern,+ count,+ max_iterations,+ include_types,+ )+ .await+}++async fn scan_cluster_keys_batch_in_db_with<C, Discover, DiscoverFuture, Connect, ConnectFuture>(sessions: &Mutex<RedisClusterScanSessions>,mut discover_master_nodes: Discover,connect_node: Connect,+ db: u32,cursor: u64,pattern: &str,count: usize,@@ -1505,17 +1876,17 @@ whereif master_nodes.is_empty() {return Ok(RedisScanResult { cursor: 0, keys: Vec::new(), total_keys: 0 });}- (RedisClusterKeyScanSession::new(master_nodes, pattern), false)+ let mut session = RedisClusterKeyScanSession::new(master_nodes, pattern);+ session.db = db;+ (session, false)} else {- let previous_session = sessions.lock().await.take(cursor);- match previous_session {- Some(session) if session.pattern == pattern => (session, true),- Some(session) => {- sessions.lock().await.insert(Some(cursor), session);- return Err(INVALID_CLUSTER_SCAN_CURSOR_ERROR.to_string());- }- None => return Err(INVALID_CLUSTER_SCAN_CURSOR_ERROR.to_string()),+ let mut store = sessions.lock().await;+ store.remove_expired();+ let session = store.entries.get(&cursor).ok_or(INVALID_CLUSTER_SCAN_CURSOR_ERROR)?;+ if session.pattern != pattern || session.db != db || session.value_filter.is_some() {+ return Err(INVALID_CLUSTER_SCAN_CURSOR_ERROR.to_string());}+ (store.take(cursor).ok_or(INVALID_CLUSTER_SCAN_CURSOR_ERROR)?, true)};let include_total_keys = !can_continue;let retry_session = can_continue.then(|| session.clone());@@ -1637,42 +2008,123 @@ pub async fn scan_cluster_values_page(include_key_matches: bool,count: usize,) -> Result<RedisScanResult, String> {- let master_nodes = cluster_master_nodes(pool).await?;- if master_nodes.is_empty() {- return Ok(RedisScanResult { cursor: 0, keys: Vec::new(), total_keys: 0 });- }+ scan_cluster_values_page_in_db(pool, 0, cursor, pattern, query, include_key_matches, count).await+}- let (mut node_index, node_cursor) = decode_cluster_cursor(cursor);- if node_index >= master_nodes.len() {- node_index = 0;- }+pub async fn scan_cluster_values_page_in_db(+ pool: &RedisClusterPool,+ db: u32,+ cursor: u64,+ pattern: &str,+ query: &str,+ include_key_matches: bool,+ count: usize,+) -> Result<RedisScanResult, String> {+ ensure_cluster_database(pool, db).await?;+ scan_cluster_values_page_with(+ &pool.scan_sessions,+ || async { cluster_master_nodes(pool).await },+ |endpoint| async move { connect_cluster_node_in_db(pool, &endpoint, db).await },+ db,+ cursor,+ pattern,+ query,+ include_key_matches,+ count,+ )+ .await+}- let total_keys = cluster_total_keys(pool, &master_nodes).await;- for index in node_index..master_nodes.len() {- let endpoint = &master_nodes[index];- let mut con = connect_cluster_node(pool, endpoint).await?;- let current_cursor = if index == node_index { node_cursor } else { 0 };- 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)?- } else if index + 1 < master_nodes.len() {- encode_cluster_cursor(index + 1, 0)?- } else {+async fn scan_cluster_values_page_with<C, Discover, DiscoverFuture, Connect, ConnectFuture>(+ sessions: &Mutex<RedisClusterScanSessions>,+ mut discover: Discover,+ mut connect: Connect,+ db: u32,+ cursor: u64,+ pattern: &str,+ query: &str,+ include_key_matches: bool,+ count: usize,+) -> Result<RedisScanResult, String>+where+ C: ConnectionLike + Send + Sync + Unpin,+ Discover: FnMut() -> DiscoverFuture,+ DiscoverFuture: Future<Output = Result<Vec<RedisNodeEndpoint>, String>>,+ Connect: FnMut(RedisNodeEndpoint) -> ConnectFuture,+ ConnectFuture: Future<Output = Result<C, String>>,+{+ let filter = Some((query.to_string(), include_key_matches));+ let mut session = if cursor == 0 {+ let mut session = RedisClusterKeyScanSession::new(canonical_cluster_master_nodes(discover().await?), pattern);+ session.db = db;+ session.value_filter = filter.clone();+ session+ } else {+ let mut store = sessions.lock().await;+ store.remove_expired();+ let session = store.entries.get(&cursor).ok_or(INVALID_CLUSTER_SCAN_CURSOR_ERROR)?;+ if session.db != db || session.pattern != pattern || session.value_filter != filter {+ return Err(INVALID_CLUSTER_SCAN_CURSOR_ERROR.to_string());+ }+ store.take(cursor).ok_or(INVALID_CLUSTER_SCAN_CURSOR_ERROR)?+ };+ let retry = session.clone();+ let result = async {+ let mut connections: Vec<Option<C>> =+ std::iter::repeat_with(|| None).take(session.master_nodes.len()).collect();+ if cursor == 0 {+ for (index, endpoint) in session.master_nodes.iter().cloned().enumerate() {+ // Counts are best-effort metadata, not a prerequisite for value search.+ if let Ok(mut con) = connect(endpoint).await {+ let keys = redis::cmd("DBSIZE").query_async::<u64>(&mut con).await.unwrap_or(0);+ session.total_keys += keys;+ connections[index] = Some(con);+ }+ }+ }+ let mut keys = Vec::new();+ while let Some(index) = session.next_unfinished_node_index() {+ if connections[index].is_none() {+ connections[index] = Some(connect(session.master_nodes[index].clone()).await?);+ }+ let con = connections[index].as_mut().ok_or("Redis cluster node connection unavailable")?;+ let page = scan_values_page_inner(+ con,+ session.node_cursors[index],+ pattern,+ query,+ include_key_matches,+ count,+ false,+ )+ .await?;+ session.node_cursors[index] = page.cursor;+ session.node_complete[index] = page.cursor == 0;+ session.advance_after(index);+ keys.extend(page.keys);+ if !keys.is_empty() || page.cursor != 0 {+ break;+ }+ }+ Ok::<_, String>((keys, session.total_keys))+ }+ .await;+ match result {+ Ok((keys, total_keys)) => {+ let cursor = if session.is_complete() {0+ } else {+ sessions.lock().await.insert((cursor != 0).then_some(cursor), session)};- return Ok(RedisScanResult { cursor: next_cursor, keys: result.keys, total_keys });+ Ok(RedisScanResult { cursor, keys, total_keys })}- if result.cursor != 0 {- return Ok(RedisScanResult {- cursor: encode_cluster_cursor(index, result.cursor)?,- keys: Vec::new(),- total_keys,- });+ Err(error) => {+ if cursor != 0 {+ sessions.lock().await.insert(Some(cursor), retry);+ }+ Err(error)}}-- Ok(RedisScanResult { cursor: 0, keys: Vec::new(), total_keys })}pub async fn cluster_master_nodes(pool: &RedisClusterPool) -> Result<Vec<RedisNodeEndpoint>, String> {@@ -1693,25 +2145,19 @@ pub async fn cluster_master_nodes(pool: &RedisClusterPool) -> Result<Vec<RedisNo}pub async fn flush_cluster(pool: &RedisClusterPool) -> Result<(), String> {+ flush_cluster_in_db(pool, 0).await+}++pub async fn flush_cluster_in_db(pool: &RedisClusterPool, db: u32) -> Result<(), String> {+ ensure_cluster_database(pool, db).await?;let master_nodes = cluster_master_nodes(pool).await?;for endpoint in master_nodes {- let mut con = connect_cluster_node(pool, &endpoint).await?;+ let mut con = connect_cluster_node_in_db(pool, &endpoint, db).await?;flush_db(&mut con).await?;}Ok(())}-async fn cluster_total_keys(pool: &RedisClusterPool, master_nodes: &[RedisNodeEndpoint]) -> u64 {- let mut total = 0;- for endpoint in master_nodes {- let Ok(mut con) = connect_cluster_node(pool, endpoint).await else {- continue;- };- total += redis::cmd("DBSIZE").query_async::<u64>(&mut con).await.unwrap_or(0);- }- total-}-async fn cluster_slot_ranges_from_seeds(seed_nodes: &[RedisNodeEndpoint],tls: bool,@@ -1833,7 +2279,48 @@ pub fn unique_master_nodes(slot_ranges: &[RedisClusterSlotRange]) -> Vec<RedisNo}pub async fn cluster_any_connection(pool: &RedisClusterPool) -> Result<RedisClusterConnectionGuard<'_>, String> {+ cluster_any_connection_in_db(pool, 0).await+}++async fn native_cluster_database_connection(pool: &RedisClusterPool, db: u32) -> Result<ClusterConnection, String> {+ let entry = pool.database_connections.lock().await.entry(db).or_default().clone();+ let mut connection = entry.lock().await;+ if let Some(connection) = &*connection {+ return Ok(connection.clone());+ }+ let nodes = pool+ .seed_nodes+ .iter()+ .map(|endpoint| {+ connection_info(+ &endpoint.host,+ endpoint.port,+ pool.tls,+ pool.tls_insecure,+ &pool.username,+ &pool.password,+ i64::from(db),+ )+ })+ .collect::<Result<Vec<_>, _>>()?;+ let client = ClusterClient::builder(nodes).database_id(i64::from(db)).build().map_err(|error| error.to_string())?;+ let initialized = tokio::time::timeout(connection_timeout(), client.get_async_connection())+ .await+ .map_err(|_| format!("Redis cluster db{db} connection timed out"))?+ .map_err(|error| format!("Redis cluster db{db} connection failed: {error}"))?;+ *connection = Some(initialized.clone());+ Ok(initialized)+}++pub async fn cluster_any_connection_in_db(+ pool: &RedisClusterPool,+ db: u32,+) -> Result<RedisClusterConnectionGuard<'_>, String> {+ ensure_cluster_database(pool, db).await?;if let Some(connection) = &pool.connection {+ if db != 0 {+ return native_cluster_database_connection(pool, db).await.map(RedisClusterConnectionGuard::Database);+ }return Ok(RedisClusterConnectionGuard::Native(connection.lock().await));}let endpoint = pool@@ -1842,26 +2329,64 @@ pub async fn cluster_any_connection(pool: &RedisClusterPool) -> Result<RedisClus.or_else(|| pool.seed_routes.first()).map(|route| &route.advertised).ok_or_else(|| "Redis cluster has no routable nodes".to_string())?;- connect_cluster_node(pool, endpoint).await.map(RedisClusterConnectionGuard::Direct)+ connect_cluster_node_in_db(pool, endpoint, db).await.map(RedisClusterConnectionGuard::Direct)}pub async fn cluster_key_connection<'a>(pool: &'a RedisClusterPool,key: &[u8],) -> Result<RedisClusterConnectionGuard<'a>, String> {+ cluster_key_connection_in_db(pool, key, 0).await+}++pub async fn cluster_key_connection_in_db<'a>(+ pool: &'a RedisClusterPool,+ key: &[u8],+ db: u32,+) -> Result<RedisClusterConnectionGuard<'a>, String> {+ ensure_cluster_database(pool, db).await?;if let Some(connection) = &pool.connection {+ if db != 0 {+ return native_cluster_database_connection(pool, db).await.map(RedisClusterConnectionGuard::Database);+ }return Ok(RedisClusterConnectionGuard::Native(connection.lock().await));}let endpoint = cluster_master_for_key(pool, key)?;- connect_cluster_node(pool, &endpoint).await.map(RedisClusterConnectionGuard::Direct)+ connect_cluster_node_in_db(pool, &endpoint, db).await.map(RedisClusterConnectionGuard::Direct)}pub async fn connect_cluster_node(pool: &RedisClusterPool,advertised_endpoint: &RedisNodeEndpoint,) -> Result<redis::aio::MultiplexedConnection, String> {+ connect_cluster_node_in_db(pool, advertised_endpoint, 0).await+}++pub async fn connect_cluster_node_in_db(+ pool: &RedisClusterPool,+ advertised_endpoint: &RedisNodeEndpoint,+ db: u32,+) -> Result<redis::aio::MultiplexedConnection, String> {+ let client = redis::Client::open(cluster_node_connection_info(pool, advertised_endpoint, db)?)+ .map_err(|error| format!("Redis connection failed: {error}"))?;+ connect_client(client).await+}++fn cluster_node_connection_info(+ pool: &RedisClusterPool,+ advertised_endpoint: &RedisNodeEndpoint,+ db: u32,+) -> Result<ConnectionInfo, String> {let connect_endpoint = mapped_cluster_endpoint(pool, advertised_endpoint);- connect_direct_node(&connect_endpoint, pool.tls, pool.tls_insecure, &pool.username, &pool.password).await+ connection_info(+ &connect_endpoint.host,+ connect_endpoint.port,+ pool.tls,+ pool.tls_insecure,+ &pool.username,+ &pool.password,+ i64::from(db),+ )}fn mapped_cluster_endpoint(pool: &RedisClusterPool, advertised_endpoint: &RedisNodeEndpoint) -> RedisNodeEndpoint {@@ -2196,6 +2721,7 @@ pub fn redis_command_raw_to_json(value: RedisRawValue) -> serde_json::Value {}RedisRawValue::BigNumber(value) => serde_json::Value::String(value.to_string()),RedisRawValue::ServerError(error) => serde_json::Value::String(format!("{error:?}")),+ value => serde_json::Value::String(format!("{value:?}")),}}@@ -2532,7 +3058,7 @@ wherelet type_values = con.req_packed_commands(&type_pipe, 0, type_count).await.unwrap_or_default();let key_types = type_values.iter()- .map(|value| String::from_redis_value(value).unwrap_or_else(|_| "unknown".to_string()))+ .map(|value| String::from_redis_value(value.clone()).unwrap_or_else(|_| "unknown".to_string())).collect();let mut ttl_pipe = redis::pipe();@@ -2541,7 +3067,7 @@ where}let ttl_count = ttl_pipe.len();let ttl_values = con.req_packed_commands(&ttl_pipe, 0, ttl_count).await.unwrap_or_default();- let key_ttls = ttl_values.iter().map(|value| i64::from_redis_value(value).unwrap_or(-2)).collect();+ let key_ttls = ttl_values.into_iter().map(|value| i64::from_redis_value(value).unwrap_or(-2)).collect();(key_types, key_ttls)} else {(Vec::new(), Vec::new())@@ -2601,11 +3127,27 @@ pub async fn scan_values_page<C>(include_key_matches: bool,count: usize,) -> Result<RedisScanResult, String>+where+ C: ConnectionLike + Send + Sync + Unpin,+{+ scan_values_page_inner(con, cursor, pattern, query, include_key_matches, count, true).await+}++async fn scan_values_page_inner<C>(+ con: &mut C,+ cursor: u64,+ pattern: &str,+ query: &str,+ include_key_matches: bool,+ count: usize,+ include_total_keys: bool,+) -> Result<RedisScanResult, String>whereC: ConnectionLike + Send + Sync + Unpin,{// Only call DBSIZE on the first page (cursor == 0) to avoid redundant work.- let total_keys: u64 = if cursor == 0 { redis::cmd("DBSIZE").query_async(con).await.unwrap_or(0) } else { 0 };+ let total_keys: u64 =+ if include_total_keys && cursor == 0 { redis::cmd("DBSIZE").query_async(con).await.unwrap_or(0) } else { 0 };if query.trim().is_empty() {return Ok(RedisScanResult { cursor, keys: Vec::new(), total_keys });}@@ -2687,6 +3229,13 @@ where}pub async fn get_value<C>(con: &mut C, key: &[u8]) -> Result<RedisValue, String>+where+ C: ConnectionLike + Send + Sync + Unpin,+{+ get_value_scoped(con, key, &RedisOperationScope::default()).await+}++pub async fn get_value_scoped<C>(con: &mut C, key: &[u8], scope: &RedisOperationScope) -> Result<RedisValue, String>whereC: ConnectionLike + Send + Sync + Unpin,{@@ -2737,7 +3286,7 @@ where}"set" => {let len: u64 = redis::cmd("SCARD").arg(key).query_async(con).await.unwrap_or(0);- let (cursor, items) = sscan_bounded_page(con, key, 0, COLLECTION_PAGE_SIZE, None).await?;+ let (cursor, items) = sscan_bounded_page(con, scope, key, 0, COLLECTION_PAGE_SIZE, None).await?;RedisValueData::Set { items, total: len, scan_cursor: (cursor > 0).then_some(cursor) }}"zset" => {@@ -2750,7 +3299,7 @@ where}"hash" => {let len: u64 = redis::cmd("HLEN").arg(key).query_async(con).await.unwrap_or(0);- let (cursor, mut items) = hscan_bounded_page(con, key, 0, COLLECTION_PAGE_SIZE, None).await?;+ let (cursor, mut items) = hscan_bounded_page(con, scope, key, 0, COLLECTION_PAGE_SIZE, None).await?;attach_hash_field_ttls(con, key, &mut items).await?;RedisValueData::Hash { items, total: len, scan_cursor: (cursor > 0).then_some(cursor) }}@@ -3297,7 +3846,7 @@ where}fn is_unsupported_keepttl_error(error: &redis::RedisError) -> bool {- if error.kind() != redis::ErrorKind::ResponseError {+ if error.kind() != redis::ErrorKind::Server(redis::ServerErrorKind::ResponseError) {return false;}@@ -4014,6 +4563,35 @@ pub async fn load_more_collection<C>(whereC: ConnectionLike + Send + Sync + Unpin,{+ load_more_collection_scoped(+ con,+ key,+ key_type,+ cursor,+ count,+ filter_query,+ sort_direction,+ &RedisOperationScope::default(),+ )+ .await+}++pub async fn load_more_collection_scoped<C>(+ con: &mut C,+ key: &[u8],+ key_type: &str,+ cursor: u64,+ count: usize,+ filter_query: Option<&str>,+ sort_direction: Option<&str>,+ scope: &RedisOperationScope,+) -> Result<RedisCollectionPage, String>+where+ C: ConnectionLike + Send + Sync + Unpin,+{+ if cursor >= COLLECTION_OVERFLOW_CURSOR_START && !matches!(key_type, "hash" | "set") {+ return Err("Collection cursor belongs to a different collection type".to_string());+ }let filter_query = filter_query.filter(|query| !query.is_empty());match key_type {"list" => {@@ -4033,9 +4611,9 @@ where}"set" => {let (next_cursor, items) = if let Some(query) = filter_query {- sscan_bounded_page(con, key, cursor, count, Some(query)).await?+ sscan_bounded_page(con, scope, key, cursor, count, Some(query)).await?} else {- sscan_bounded_page(con, key, cursor, count, None).await?+ sscan_bounded_page(con, scope, key, cursor, count, None).await?};Ok(RedisCollectionPage::Set { items, scan_cursor: (next_cursor > 0).then_some(next_cursor) })}@@ -4064,9 +4642,9 @@ where}"hash" => {let (next_cursor, mut items) = if let Some(query) = filter_query {- hscan_bounded_page(con, key, cursor, count, Some(query)).await?+ hscan_bounded_page(con, scope, key, cursor, count, Some(query)).await?} else {- hscan_bounded_page(con, key, cursor, count, None).await?+ hscan_bounded_page(con, scope, key, cursor, count, None).await?};attach_hash_field_ttls(con, key, &mut items).await?;Ok(RedisCollectionPage::Hash { items, scan_cursor: (next_cursor > 0).then_some(next_cursor) })@@ -4260,6 +4838,7 @@ whereasync fn hscan_bounded_page<C>(con: &mut C,+ scope: &RedisOperationScope,key: &[u8],cursor: u64,count: usize,@@ -4269,22 +4848,33 @@ whereC: ConnectionLike + Send + Sync + Unpin,{let count = count.max(1);- if let Some(page) = take_hash_overflow_page(key, cursor, count, filter_query).await {+ if let Some(page) = take_hash_overflow_page(scope, key, cursor, count, filter_query).await {return Ok(page);}-- let (next_cursor, mut items) = if let Some(query) = filter_query {- hscan_filtered_page_raw(con, key, cursor, count, query).await?+ let (scan_cursor, previous_session) =+ take_collection_scan_cursor(scope, key, cursor, RedisCollectionOverflowKind::Hash, filter_query).await?;+ let scanned = if let Some(query) = filter_query {+ hscan_filtered_page_raw(con, key, scan_cursor, count, query).await} else {- hscan_page_raw(con, key, cursor, count, None).await?+ hscan_page_raw(con, key, scan_cursor, count, None).await+ };+ let (next_cursor, mut items) = match scanned {+ Ok(page) => page,+ Err(error) => {+ if let Some(session) = previous_session {+ collection_overflow_sessions().lock().await.reinsert(cursor, session);+ }+ return Err(error);+ }};let page_len = budgeted_page_len(&items, count, hash_item_page_bytes);- let next_cursor = store_hash_overflow_page(key, &mut items, page_len, next_cursor, filter_query).await;+ let next_cursor = store_hash_overflow_page(scope, key, &mut items, page_len, next_cursor, filter_query).await;Ok((next_cursor, items))}async fn sscan_bounded_page<C>(con: &mut C,+ scope: &RedisOperationScope,key: &[u8],cursor: u64,count: usize,@@ -4294,21 +4884,32 @@ whereC: ConnectionLike + Send + Sync + Unpin,{let count = count.max(1);- if let Some(page) = take_set_overflow_page(key, cursor, count, filter_query).await {+ if let Some(page) = take_set_overflow_page(scope, key, cursor, count, filter_query).await {return Ok(page);}-- let (next_cursor, mut items) = if let Some(query) = filter_query {- sscan_filtered_page_raw(con, key, cursor, count, query).await?+ let (scan_cursor, previous_session) =+ take_collection_scan_cursor(scope, key, cursor, RedisCollectionOverflowKind::Set, filter_query).await?;+ let scanned = if let Some(query) = filter_query {+ sscan_filtered_page_raw(con, key, scan_cursor, count, query).await} else {- sscan_page_raw(con, key, cursor, count).await?+ sscan_page_raw(con, key, scan_cursor, count).await+ };+ let (next_cursor, mut items) = match scanned {+ Ok(page) => page,+ Err(error) => {+ if let Some(session) = previous_session {+ collection_overflow_sessions().lock().await.reinsert(cursor, session);+ }+ return Err(error);+ }};let page_len = budgeted_page_len(&items, count, set_item_page_bytes);- let next_cursor = store_set_overflow_page(key, &mut items, page_len, next_cursor, filter_query).await;+ let next_cursor = store_set_overflow_page(scope, key, &mut items, page_len, next_cursor, filter_query).await;Ok((next_cursor, items))}async fn take_hash_overflow_page(+ scope: &RedisOperationScope,key: &[u8],cursor: u64,count: usize,@@ -4319,25 +4920,33 @@ async fn take_hash_overflow_page(}let mut sessions = collection_overflow_sessions().lock().await;- let mut session = sessions.take_matching(cursor, key, RedisCollectionOverflowKind::Hash, filter_query, None)?;+ let mut session =+ sessions.take_matching(cursor, scope, key, RedisCollectionOverflowKind::Hash, filter_query, None)?;let page = match &mut session.items {- RedisCollectionOverflowItems::Hash(items) => {+ RedisCollectionOverflowItems::Hash(items) if !items.is_empty() => {take_vec_page(items, budgeted_page_len(items, count, hash_item_page_bytes))}+ RedisCollectionOverflowItems::Hash(_) => {+ sessions.reinsert(cursor, session);+ return None;+ }RedisCollectionOverflowItems::Set(_) => return None,};let has_buffered_items = match &session.items {RedisCollectionOverflowItems::Hash(items) => !items.is_empty(),RedisCollectionOverflowItems::Set(_) => false,};- let next_cursor = if has_buffered_items { cursor } else { session.followup_cursor };- if has_buffered_items {+ let retain_cursor =+ has_buffered_items || (session.followup_cursor != 0 && scope != &RedisOperationScope::default());+ let next_cursor = if retain_cursor { cursor } else { session.followup_cursor };+ if retain_cursor {sessions.reinsert(cursor, session);}Some((next_cursor, page))}async fn take_set_overflow_page(+ scope: &RedisOperationScope,key: &[u8],cursor: u64,count: usize,@@ -4348,37 +4957,46 @@ async fn take_set_overflow_page(}let mut sessions = collection_overflow_sessions().lock().await;- let mut session = sessions.take_matching(cursor, key, RedisCollectionOverflowKind::Set, filter_query, None)?;+ let mut session =+ sessions.take_matching(cursor, scope, key, RedisCollectionOverflowKind::Set, filter_query, None)?;let page = match &mut session.items {- RedisCollectionOverflowItems::Set(items) => {+ RedisCollectionOverflowItems::Set(items) if !items.is_empty() => {take_vec_page(items, budgeted_page_len(items, count, set_item_page_bytes))}+ RedisCollectionOverflowItems::Set(_) => {+ sessions.reinsert(cursor, session);+ return None;+ }RedisCollectionOverflowItems::Hash(_) => return None,};let has_buffered_items = match &session.items {RedisCollectionOverflowItems::Set(items) => !items.is_empty(),RedisCollectionOverflowItems::Hash(_) => false,};- let next_cursor = if has_buffered_items { cursor } else { session.followup_cursor };- if has_buffered_items {+ let retain_cursor =+ has_buffered_items || (session.followup_cursor != 0 && scope != &RedisOperationScope::default());+ let next_cursor = if retain_cursor { cursor } else { session.followup_cursor };+ if retain_cursor {sessions.reinsert(cursor, session);}Some((next_cursor, page))}async fn store_hash_overflow_page(+ scope: &RedisOperationScope,key: &[u8],items: &mut Vec<RedisHashItem>,count: usize,followup_cursor: u64,filter_query: Option<&str>,) -> u64 {- if items.len() <= count {+ if items.len() <= count && (followup_cursor == 0 || scope == &RedisOperationScope::default()) {return followup_cursor;}- let overflow = items.split_off(count);+ let overflow = items.split_off(count.min(items.len()));let session = RedisCollectionOverflowSession {+ scope: scope.clone(),key: key.to_vec(),kind: RedisCollectionOverflowKind::Hash,filter: filter_query.map(str::to_string),@@ -4391,18 +5009,20 @@ async fn store_hash_overflow_page(}async fn store_set_overflow_page(+ scope: &RedisOperationScope,key: &[u8],items: &mut Vec<RedisSetItem>,count: usize,followup_cursor: u64,filter_query: Option<&str>,) -> u64 {- if items.len() <= count {+ if items.len() <= count && (followup_cursor == 0 || scope == &RedisOperationScope::default()) {return followup_cursor;}- let overflow = items.split_off(count);+ let overflow = items.split_off(count.min(items.len()));let session = RedisCollectionOverflowSession {+ scope: scope.clone(),key: key.to_vec(),kind: RedisCollectionOverflowKind::Set,filter: filter_query.map(str::to_string),@@ -4414,6 +5034,27 @@ async fn store_set_overflow_page(collection_overflow_sessions().lock().await.insert(session)}+async fn take_collection_scan_cursor(+ scope: &RedisOperationScope,+ key: &[u8],+ cursor: u64,+ kind: RedisCollectionOverflowKind,+ filter_query: Option<&str>,+) -> Result<(u64, Option<RedisCollectionOverflowSession>), String> {+ if cursor == 0 {+ return Ok((0, None));+ }+ if let Some(session) =+ collection_overflow_sessions().lock().await.take_matching(cursor, scope, key, kind, filter_query, None)+ {+ return Ok((session.followup_cursor, Some(session)));+ }+ if cursor >= COLLECTION_OVERFLOW_CURSOR_START || scope != &RedisOperationScope::default() {+ return Err("Collection cursor is invalid, expired, or belongs to a different connection/database".to_string());+ }+ Ok((cursor, None))+}+/// How many leading items fit in one page, honouring both the item count and the byte budget.////// Always returns at least one item so a member larger than the whole budget still loads (and@@ -4658,63 +5299,914 @@ fn parse_scan_hash_entries(items.push(RedisHashItem { field, value, field_ttl: None });}- Ok((cursor, items))-}--fn parse_scan_members(raw: RedisRawValue) -> Result<(u64, Vec<RedisSetItem>), String> {- let RedisRawValue::Array(parts) = raw else {- return Err("Invalid SCAN response".to_string());- };- if parts.len() != 2 {- return Err("Invalid SCAN response".to_string());+ Ok((cursor, items))+}++fn parse_scan_members(raw: RedisRawValue) -> Result<(u64, Vec<RedisSetItem>), String> {+ let RedisRawValue::Array(parts) = raw else {+ return Err("Invalid SCAN response".to_string());+ };+ if parts.len() != 2 {+ return Err("Invalid SCAN response".to_string());+ }++ let cursor = redis_value_to_string(parts[0].clone())+ .ok_or("Invalid cursor")?+ .parse::<u64>()+ .map_err(|_| "Invalid cursor".to_string())?;++ let RedisRawValue::Array(entries) = &parts[1] else {+ return Err("Invalid SCAN entries".to_string());+ };++ let items = entries+ .iter()+ .filter_map(|value| {+ redis_value_to_bytes(value.clone()).map(|bytes| RedisSetItem { member: redis_blob_from_bytes(&bytes) })+ })+ .collect();++ Ok((cursor, items))+}++#[cfg(test)]+mod tests {+ use base64::Engine;+ use std::time::Duration;+ use std::{+ collections::{HashMap, VecDeque},+ future::ready,+ sync::{+ atomic::{AtomicUsize, Ordering},+ Arc, Mutex as StdMutex,+ },+ };++ use super::{+ classify_command, connection_info, decode_cluster_cursor, encode_cluster_cursor, is_redis_auth_error,+ is_redis_command_denied_error, is_redis_json_type, parse_cluster_slots, parse_command_argv,+ parse_database_count, parse_redis_endpoint, parse_scan_keys, parse_stream_consumers, parse_stream_entries,+ parse_stream_groups, parse_stream_pending_entries, redis_auth_candidates, redis_blob_display_text,+ redis_blob_from_bytes, redis_cluster_slot, redis_command_raw_to_json, redis_database_index,+ redis_key_bytes_to_display, redis_key_bytes_to_raw, redis_key_matches_query, redis_key_raw_to_bytes,+ redis_key_value_preview, redis_sentinel_master_endpoint, redis_value_matches_query, redis_value_to_bytes,+ standalone_connection_infos, RedisAuthCandidate, RedisBlob, RedisBlobEncoding, RedisClusterSlotRange,+ RedisCollectionPage, RedisCommandSafety, RedisHashItem, RedisListItem, RedisNodeEndpoint, RedisNodeRoute,+ RedisRawValue, RedisSetItem, RedisStreamConsumer, RedisStreamEntry, RedisStreamField, RedisStreamGroup,+ RedisStreamPendingEntry, RedisValue, RedisValueData, RedisZsetItem,+ };+ use dbx_types::models::connection::ConnectionConfig;+ use redis::{aio::ConnectionLike, Cmd, ConnectionAddr, Pipeline, RedisFuture};++ #[test]+ fn cluster_database_capability_is_strict_and_cluster_specific() {+ use super::ClusterDatabaseCapability as Capability;+ for count in [1, 4, i32::MAX as u32] {+ assert_eq!(+ super::parse_cluster_database_capability(RedisRawValue::Array(vec![+ bulk("cluster-databases"),+ bulk(&count.to_string())+ ]))+ .unwrap(),+ Capability::Known(count)+ );+ }+ assert_eq!(+ super::parse_cluster_database_capability(RedisRawValue::Array(vec![])).unwrap(),+ Capability::Unsupported+ );+ assert_eq!(+ super::parse_cluster_database_capability(RedisRawValue::Map(vec![(bulk("cluster-databases"), bulk("4"))]))+ .unwrap(),+ Capability::Known(4)+ );+ for raw in [+ RedisRawValue::Nil,+ RedisRawValue::Array(vec![bulk("databases"), bulk("16")]),+ RedisRawValue::Array(vec![bulk("cluster-databases")]),+ RedisRawValue::Array(vec![bulk("cluster-databases"), bulk("4"), bulk("extra")]),+ ] {+ assert!(super::parse_cluster_database_capability(raw).is_err());+ }+ for count in ["0", "-1", "2147483648", "4294967295", "4294967296", "4.0", " 4", ""] {+ assert!(+ super::parse_cluster_database_capability(RedisRawValue::Array(vec![+ bulk("cluster-databases"),+ bulk(count)+ ]))+ .is_err(),+ "{count}"+ );+ }+ assert_eq!(+ super::combine_cluster_database_capabilities(vec![Capability::Known(4), Capability::Known(4)]).unwrap(),+ Capability::Known(4)+ );+ assert!(super::combine_cluster_database_capabilities(vec![Capability::Known(4), Capability::Known(8)]).is_err());+ assert!(+ super::combine_cluster_database_capabilities(vec![Capability::Known(1), Capability::Unsupported]).is_err()+ );+ assert!(super::combine_cluster_database_capabilities(vec![]).is_err());+ assert_eq!(+ super::combine_cluster_database_capabilities(vec![+ Capability::Known(4),+ Capability::Unknown("node: NOPERM".to_string())+ ])+ .unwrap(),+ Capability::Unknown("node: NOPERM".to_string())+ );+ for raw in [+ RedisRawValue::Double(4.0),+ RedisRawValue::Boolean(true),+ RedisRawValue::Int(4),+ RedisRawValue::VerbatimString { format: redis::VerbatimFormat::Text, text: "4".to_string() },+ RedisRawValue::Nil,+ RedisRawValue::Okay,+ RedisRawValue::BulkString(vec![0xff]),+ ] {+ assert!(super::parse_cluster_database_capability(RedisRawValue::Array(vec![+ bulk("cluster-databases"),+ raw+ ]))+ .is_err());+ }+ assert!(super::parse_cluster_database_capability(RedisRawValue::Map(vec![(+ RedisRawValue::VerbatimString {+ format: redis::VerbatimFormat::Text,+ text: "cluster-databases".to_string()+ },+ bulk("4")+ )]))+ .is_err());+ }++ #[test]+ fn cluster_database_keyspace_counts_require_trustworthy_metadata() {+ assert_eq!(+ super::parse_cluster_keyspace_counts("# Keyspace\r\ndb0:keys=3,expires=0\r\ndb1:keys=2,expires=0\r\n")+ .unwrap(),+ HashMap::from([(0, 3), (1, 2)])+ );+ assert!(super::parse_cluster_keyspace_counts("# Keyspace\r\n").unwrap().is_empty());+ for info in [+ "",+ "db0:keys=3",+ "# Keyspace\r\ndb0:expires=1",+ "# Keyspace\r\ndb0:keys=no",+ "# Keyspace\r\ndb0:keys=1\r\ndb0:keys=2",+ ] {+ assert!(super::parse_cluster_keyspace_counts(info).is_err(), "{info}");+ }+ }++ #[test]+ fn cluster_database_list_limit_is_separate_from_server_configuration_range() {+ assert_eq!(+ super::cluster_database_list_count(&super::ClusterDatabaseCapability::Known(10_000)).unwrap(),+ 10_000+ );+ let error = super::cluster_database_list_count(&super::ClusterDatabaseCapability::Known(10_001)).unwrap_err();+ assert!(error.contains("10001"));+ assert!(error.contains("10000"));+ assert!(error.contains("DBX"));+ assert!(super::parse_cluster_database_capability(RedisRawValue::Array(vec![+ bulk("cluster-databases"),+ bulk("10001")+ ]))+ .is_ok());+ }++ #[tokio::test]+ async fn cluster_database_bounds_and_db_zero_do_not_require_network() {+ let super::RedisConnection::Cluster(pool) = super::redis_connection_test_stub() else { unreachable!() };+ *pool.database_capability.lock().await = Some(super::ClusterDatabaseCapability::Known(4));+ super::ensure_cluster_database(&pool, 3).await.unwrap();+ assert!(super::ensure_cluster_database(&pool, 4).await.unwrap_err().contains("range"));+ *pool.database_capability.lock().await = Some(super::ClusterDatabaseCapability::Unknown("denied".to_string()));+ super::ensure_cluster_database(&pool, 0).await.unwrap();+ assert_eq!(super::cluster_database_diagnostic(&pool).await.as_deref(), Some("denied"));+ }++ #[test]+ fn cluster_node_connection_options_keep_database_transport_auth_and_tls() {+ let super::RedisConnection::Cluster(mut pool) = super::redis_connection_test_stub() else { unreachable!() };+ let advertised = RedisNodeEndpoint { host: "remote.invalid".to_string(), port: 7000 };+ pool.node_routes.push(RedisNodeRoute {+ advertised: advertised.clone(),+ connect: RedisNodeEndpoint { host: "127.0.0.1".to_string(), port: 17000 },+ });+ pool.username = "acl-user".to_string();+ pool.password = "acl-password".to_string();+ let info = super::cluster_node_connection_info(&pool, &advertised, 3).unwrap();+ assert!(matches!(info.addr(), ConnectionAddr::Tcp(host, 17000) if host == "127.0.0.1"));+ assert_eq!(info.redis_settings().db(), 3);+ assert_eq!(info.redis_settings().username(), Some("acl-user"));+ assert_eq!(info.redis_settings().password(), Some("acl-password"));+ pool.tls = true;+ pool.tls_insecure = true;+ let info = super::cluster_node_connection_info(&pool, &advertised, 2).unwrap();+ assert!(+ matches!(info.addr(), ConnectionAddr::TcpTls { host, port: 17000, insecure: true, .. } if host == "127.0.0.1")+ );+ assert_eq!(info.redis_settings().db(), 2);+ let fallback = super::cluster_node_connection_info(+ &pool,+ &RedisNodeEndpoint { host: "unmapped.invalid".to_string(), port: 7001 },+ 2,+ )+ .unwrap();+ assert!(+ matches!(fallback.addr(), ConnectionAddr::TcpTls { host, port: 7001, insecure: true, .. } if host == "unmapped.invalid")+ );+ assert_eq!(fallback.redis_settings().db(), 2);+ }++ #[tokio::test]+ async fn cluster_value_scan_counts_all_masters_and_preserves_total_on_continuation() {+ let sessions = tokio::sync::Mutex::new(super::RedisClusterScanSessions::default());+ let masters = vec![+ RedisNodeEndpoint { host: "node-a".to_string(), port: 1 },+ RedisNodeEndpoint { host: "node-b".to_string(), port: 2 },+ RedisNodeEndpoint { host: "node-c".to_string(), port: 3 },+ ];+ let mut connections = HashMap::from([+ (+ masters[0].clone(),+ FakeRedisConnection::new(vec![+ RedisRawValue::Int(10),+ scan_response("0", vec!["needle:a"]),+ bulk("string"),+ ]),+ ),+ (masters[1].clone(), FakeRedisConnection::new(vec![RedisRawValue::Int(20)])),+ (masters[2].clone(), FakeRedisConnection::new(vec![RedisRawValue::Int(30)])),+ ]);+ let first = super::scan_cluster_values_page_with(+ &sessions,+ || ready(Ok(masters.clone())),+ |endpoint| ready(connections.remove(&endpoint).ok_or("unexpected reconnect".to_string())),+ 1,+ 0,+ "*",+ "needle",+ true,+ 1,+ )+ .await+ .unwrap();+ assert_eq!(first.total_keys, 60);+ assert_eq!(first.keys.len(), 1);+ assert_ne!(first.cursor, 0);+ let next = super::scan_cluster_values_page_with(+ &sessions,+ || ready(Err("unexpected rediscovery".to_string())),+ |_| ready(Ok(FakeRedisConnection::new(vec![scan_response("0", vec![])]))),+ 1,+ first.cursor,+ "*",+ "needle",+ true,+ 1,+ )+ .await+ .unwrap();+ assert_eq!(next.total_keys, 60);+ assert_eq!(next.cursor, 0);+ }++ #[tokio::test]+ async fn cluster_value_scan_count_denial_does_not_prevent_search() {+ let mut store = super::RedisClusterScanSessions::default();+ let previous = store.insert(None, super::RedisClusterKeyScanSession::new(vec![], "existing"));+ let sessions = tokio::sync::Mutex::new(store);+ let master = RedisNodeEndpoint { host: "count-node".to_string(), port: 7001 };+ let page = super::scan_cluster_values_page_with(+ &sessions,+ || ready(Ok(vec![master.clone()])),+ |_| {+ ready(Ok(FakeRedisConnection::with_results(vec![+ Err(noperm("dbsize")),+ Ok(scan_response("0", vec!["needle:a"])),+ Ok(bulk("string")),+ Ok(RedisRawValue::Int(-1)),+ Ok(bulk("needle value")),+ ])))+ },+ 1,+ 0,+ "*",+ "needle",+ false,+ 1,+ )+ .await+ .unwrap();+ assert_eq!(page.total_keys, 0);+ assert_eq!(page.keys.len(), 1);+ assert_eq!(page.keys[0].value_preview, "needle value");+ assert_eq!(page.cursor, 0);+ let sessions = sessions.lock().await;+ assert_eq!(sessions.entries.len(), 1);+ assert!(sessions.entries.contains_key(&previous));+ }++ #[tokio::test]+ async fn cluster_value_scan_retries_count_connection_but_propagates_scan_failures() {+ for scan_failure in [false, true] {+ let sessions = tokio::sync::Mutex::new(super::RedisClusterScanSessions::default());+ let master = RedisNodeEndpoint { host: "count-node".to_string(), port: 7001 };+ let mut attempts = 0;+ let result = super::scan_cluster_values_page_with(+ &sessions,+ || ready(Ok(vec![master.clone()])),+ |_| {+ attempts += 1;+ ready(if attempts == 1 {+ Err("count connection unavailable".to_string())+ } else if scan_failure {+ Ok(FakeRedisConnection::with_results(vec![Err(noperm("scan"))]))+ } else {+ Ok(FakeRedisConnection::new(vec![scan_response("0", vec!["needle:a"]), bulk("string")]))+ })+ },+ 1,+ 0,+ "*",+ "needle",+ true,+ 1,+ )+ .await;+ assert_eq!(attempts, 2);+ if scan_failure {+ assert_eq!(result.unwrap_err(), noperm("scan").to_string());+ } else {+ let page = result.unwrap();+ assert_eq!(page.total_keys, 0);+ assert_eq!(page.keys.len(), 1);+ }+ assert!(sessions.lock().await.entries.is_empty());+ }++ let sessions = tokio::sync::Mutex::new(super::RedisClusterScanSessions::default());+ let mut attempts = 0;+ let error = super::scan_cluster_values_page_with::<FakeRedisConnection, _, _, _, _>(+ &sessions,+ || ready(Ok(vec![RedisNodeEndpoint { host: "unavailable".to_string(), port: 7001 }])),+ |_| {+ attempts += 1;+ ready(Err("scan connection unavailable".to_string()))+ },+ 1,+ 0,+ "*",+ "needle",+ true,+ 1,+ )+ .await+ .unwrap_err();+ assert_eq!(attempts, 2);+ assert_eq!(error, "scan connection unavailable");+ assert!(sessions.lock().await.entries.is_empty());+ }++ #[tokio::test]+ async fn cluster_key_cursor_rejects_wrong_database_without_consuming_session() {+ let mut store = super::RedisClusterScanSessions::default();+ let mut session =+ super::RedisClusterKeyScanSession::new(vec![RedisNodeEndpoint { host: "test".to_string(), port: 1 }], "*");+ session.db = 1;+ let cursor = store.insert(None, session);+ let sessions = tokio::sync::Mutex::new(store);+ let result = super::scan_cluster_keys_batch_in_db_with::<FakeRedisConnection, _, _, _, _>(+ &sessions,+ || ready(Err("unexpected discovery".to_string())),+ |_| ready(Err("unexpected connection".to_string())),+ 0,+ cursor,+ "*",+ 1,+ 1,+ false,+ )+ .await;+ assert_eq!(result.unwrap_err(), super::INVALID_CLUSTER_SCAN_CURSOR_ERROR);+ assert!(sessions.lock().await.entries.contains_key(&cursor));+ let result = super::scan_cluster_keys_batch_in_db_with(+ &sessions,+ || ready(Err("unexpected discovery".to_string())),+ |_| ready(Ok(FakeRedisConnection::new(vec![scan_response("0", vec![])]))),+ 1,+ cursor,+ "*",+ 1,+ 1,+ false,+ )+ .await+ .unwrap();+ assert_eq!(result.cursor, 0);+ }++ #[tokio::test]+ async fn cluster_value_cursor_rejects_scope_and_filter_mismatch_and_restores_on_failure() {+ let mut store = super::RedisClusterScanSessions::default();+ let mut session =+ super::RedisClusterKeyScanSession::new(vec![RedisNodeEndpoint { host: "test".to_string(), port: 1 }], "*");+ session.db = 1;+ session.value_filter = Some(("needle".to_string(), false));+ session.node_cursors[0] = 42;+ let cursor = store.insert(None, session);+ let sessions = tokio::sync::Mutex::new(store);+ for (db, query, include_keys, token) in [+ (0, "needle", false, cursor),+ (1, "other", false, cursor),+ (1, "needle", true, cursor),+ (1, "needle", false, cursor + 1_000_000),+ ] {+ let error = super::scan_cluster_values_page_with::<FakeRedisConnection, _, _, _, _>(+ &sessions,+ || ready(Err("unexpected discovery".to_string())),+ |_| ready(Err("unexpected connection".to_string())),+ db,+ token,+ "*",+ query,+ include_keys,+ 1,+ )+ .await+ .unwrap_err();+ assert_eq!(error, super::INVALID_CLUSTER_SCAN_CURSOR_ERROR);+ assert_eq!(sessions.lock().await.entries.get(&cursor).unwrap().node_cursors[0], 42);+ }+ let error = super::scan_cluster_values_page_with::<FakeRedisConnection, _, _, _, _>(+ &sessions,+ || ready(Err("unexpected discovery".to_string())),+ |_| ready(Err("network failed".to_string())),+ 1,+ cursor,+ "*",+ "needle",+ false,+ 1,+ )+ .await+ .unwrap_err();+ assert_eq!(error, "network failed");+ assert_eq!(sessions.lock().await.entries.get(&cursor).unwrap().node_cursors[0], 42);+ let result = super::scan_cluster_values_page_with(+ &sessions,+ || ready(Err("unexpected discovery".to_string())),+ |_| ready(Ok(FakeRedisConnection::new(vec![scan_response("0", vec![])]))),+ 1,+ cursor,+ "*",+ "needle",+ false,+ 1,+ )+ .await+ .unwrap();+ assert_eq!(result.cursor, 0);+ }++ #[test]+ fn cluster_cursor_ids_do_not_collide_across_connection_pools() {+ let mut first = super::RedisClusterScanSessions::default();+ let mut second = super::RedisClusterScanSessions::default();+ let session = super::RedisClusterKeyScanSession::new(vec![], "*");+ let first_id = first.insert(None, session.clone());+ let second_id = second.insert(None, session);+ assert_ne!(first_id, second_id);+ assert!(second.take(first_id).is_none());+ assert!(second.take(second_id).is_some());+ }++ #[tokio::test]+ async fn collection_overflow_is_connection_and_database_scoped() {+ let scope = super::RedisOperationScope { connection_id: "overflow-scope-test".to_string(), db: 1 };+ let pairs = (0..202).map(|index| (format!("field:{index}"), format!("value:{index}"))).collect();+ let mut con = FakeRedisConnection::new(vec![+ bulk("hash"),+ RedisRawValue::Int(-1),+ RedisRawValue::Int(202),+ hscan_response_owned("0", pairs),+ httl_response(200, -1),+ ]);+ let value = super::get_value_scoped(&mut con, b"scoped-hash", &scope).await.unwrap();+ let RedisValueData::Hash { scan_cursor: Some(cursor), .. } = value.data else {+ panic!("expected overflow");+ };+ for wrong_scope in [+ super::RedisOperationScope { db: 0, ..scope.clone() },+ super::RedisOperationScope { connection_id: "another-connection".to_string(), ..scope.clone() },+ ] {+ let mut wrong = FakeRedisConnection::new(vec![]);+ assert!(super::load_more_collection_scoped(+ &mut wrong,+ b"scoped-hash",+ "hash",+ cursor,+ 1,+ None,+ None,+ &wrong_scope+ )+ .await+ .is_err());+ assert!(wrong.commands.is_empty());+ }+ let mut continuation = FakeRedisConnection::new(vec![httl_response(1, 30)]);+ let page = super::load_more_collection_scoped(+ &mut continuation,+ b"scoped-hash",+ "hash",+ cursor,+ 1,+ None,+ None,+ &scope,+ )+ .await+ .unwrap();+ let RedisCollectionPage::Hash { items, scan_cursor } = page else {+ panic!("expected hash");+ };+ assert_eq!(items[0].field, redis_blob_from_bytes(b"field:200"));+ assert_eq!(items[0].field_ttl, Some(30));+ assert_eq!(scan_cursor, Some(cursor));+ assert_eq!(continuation.command_count("HSCAN"), 0);+ super::collection_overflow_sessions().lock().await.entries.get_mut(&cursor).unwrap().last_used =+ std::time::Instant::now() - super::COLLECTION_OVERFLOW_SESSION_TTL;+ let mut expired = FakeRedisConnection::new(vec![]);+ assert!(super::load_more_collection_scoped(+ &mut expired,+ b"scoped-hash",+ "hash",+ cursor,+ 1,+ None,+ None,+ &scope+ )+ .await+ .is_err());+ assert!(expired.commands.is_empty());+ }++ #[tokio::test]+ async fn set_overflow_rejects_unknown_and_foreign_tokens_without_server_scan() {+ let scope = super::RedisOperationScope { connection_id: "set-scope-test".to_string(), db: 1 };+ let mut con = FakeRedisConnection::new(vec![RedisRawValue::Array(vec![+ bulk("0"),+ RedisRawValue::Array(vec![bulk("a"), bulk("b")]),+ ])]);+ let page =+ super::load_more_collection_scoped(&mut con, b"scoped-set", "set", 0, 1, None, None, &scope).await.unwrap();+ let RedisCollectionPage::Set { scan_cursor: Some(cursor), .. } = page else {+ panic!("expected set overflow");+ };+ let mut wrong = FakeRedisConnection::new(vec![]);+ for token in [cursor, super::MAX_SAFE_INTEGER_CURSOR] {+ assert!(super::load_more_collection_scoped(+ &mut wrong,+ b"scoped-set",+ "set",+ token,+ 1,+ None,+ None,+ &super::RedisOperationScope { db: 0, ..scope.clone() }+ )+ .await+ .is_err());+ }+ assert!(wrong.commands.is_empty());+ let page = super::load_more_collection_scoped(&mut wrong, b"scoped-set", "set", cursor, 1, None, None, &scope)+ .await+ .unwrap();+ let RedisCollectionPage::Set { items, scan_cursor } = page else {+ panic!("expected set");+ };+ assert_eq!(items[0].member, redis_blob_from_bytes(b"b"));+ assert_eq!(scan_cursor, None);+ assert!(wrong.commands.is_empty());}- let cursor = redis_value_to_string(parts[0].clone())- .ok_or("Invalid cursor")?- .parse::<u64>()- .map_err(|_| "Invalid cursor".to_string())?;-- let RedisRawValue::Array(entries) = &parts[1] else {- return Err("Invalid SCAN entries".to_string());- };-- let items = entries- .iter()- .filter_map(|value| {- redis_value_to_bytes(value.clone()).map(|bytes| RedisSetItem { member: redis_blob_from_bytes(&bytes) })- })- .collect();-- Ok((cursor, items))-}+ #[tokio::test]+ async fn native_collection_cursors_reject_foreign_scope_key_kind_and_filter() {+ for key_type in ["hash", "set"] {+ let scope = super::RedisOperationScope { connection_id: format!("native-{key_type}"), db: 1 };+ let response = if key_type == "hash" {+ hscan_response("128", vec![("field", "value")])+ } else {+ scan_response("128", vec!["member"])+ };+ let mut first = FakeRedisConnection::new(vec![response, httl_response(1, -1)]);+ let page = super::load_more_collection_scoped(&mut first, b"key", key_type, 0, 2, None, None, &scope)+ .await+ .unwrap();+ let cursor = match page {+ RedisCollectionPage::Hash { scan_cursor, .. } | RedisCollectionPage::Set { scan_cursor, .. } => {+ scan_cursor.unwrap()+ }+ _ => panic!("expected collection"),+ };+ assert!(cursor >= super::COLLECTION_OVERFLOW_CURSOR_START);+ let mut wrong = FakeRedisConnection::new(vec![]);+ let other_kind = if key_type == "hash" { "set" } else { "hash" };+ for (wrong_scope, wrong_key, wrong_kind, wrong_filter) in [+ (super::RedisOperationScope { db: 0, ..scope.clone() }, b"key".as_slice(), key_type, None),+ (+ super::RedisOperationScope { connection_id: "foreign".to_string(), ..scope.clone() },+ b"key".as_slice(),+ key_type,+ None,+ ),+ (scope.clone(), b"other".as_slice(), key_type, None),+ (scope.clone(), b"key".as_slice(), other_kind, None),+ (scope.clone(), b"key".as_slice(), key_type, Some("filter")),+ ] {+ assert!(super::load_more_collection_scoped(+ &mut wrong,+ wrong_key,+ wrong_kind,+ cursor,+ 2,+ wrong_filter,+ None,+ &wrong_scope+ )+ .await+ .is_err());+ }+ assert!(super::load_more_collection_scoped(&mut wrong, b"key", key_type, 128, 2, None, None, &scope)+ .await+ .is_err());+ assert!(wrong.commands.is_empty());+ let response = if key_type == "hash" {+ hscan_response("0", vec![("next", "value")])+ } else {+ scan_response("0", vec!["next"])+ };+ let mut owner = FakeRedisConnection::new(vec![response, httl_response(1, -1)]);+ let page = super::load_more_collection_scoped(&mut owner, b"key", key_type, cursor, 2, None, None, &scope)+ .await+ .unwrap();+ assert!(owner.commands[0].contains("\r\n128\r\n"));+ match page {+ RedisCollectionPage::Hash { items, scan_cursor } => {+ assert_eq!(items[0].field, redis_blob_from_bytes(b"next"));+ assert_eq!(scan_cursor, None);+ }+ RedisCollectionPage::Set { items, scan_cursor } => {+ assert_eq!(items[0].member, redis_blob_from_bytes(b"next"));+ assert_eq!(scan_cursor, None);+ }+ _ => panic!("expected collection"),+ }+ assert!(!super::collection_overflow_sessions().lock().await.entries.contains_key(&cursor));+ }+ }-#[cfg(test)]-mod tests {- use base64::Engine;- use std::{- collections::{HashMap, VecDeque},- future::ready,- sync::{- atomic::{AtomicUsize, Ordering},- Arc, Mutex as StdMutex,- },- };+ #[tokio::test]+ async fn scoped_collection_overflow_keeps_followup_scoped_and_retries_failed_scan() {+ for key_type in ["hash", "set"] {+ let scope = super::RedisOperationScope { connection_id: format!("followup-{key_type}"), db: 1 };+ let response = if key_type == "hash" {+ hscan_response("128", vec![("one", "value"), ("two", "value")])+ } else {+ scan_response("128", vec!["one", "two"])+ };+ let mut first = FakeRedisConnection::new(vec![response, httl_response(1, -1)]);+ let page = super::load_more_collection_scoped(&mut first, b"key", key_type, 0, 1, None, None, &scope)+ .await+ .unwrap();+ let cursor = match page {+ RedisCollectionPage::Hash { scan_cursor, .. } | RedisCollectionPage::Set { scan_cursor, .. } => {+ scan_cursor.unwrap()+ }+ _ => panic!("expected collection"),+ };+ let mut buffered = FakeRedisConnection::new(vec![httl_response(1, -1)]);+ let page =+ super::load_more_collection_scoped(&mut buffered, b"key", key_type, cursor, 1, None, None, &scope)+ .await+ .unwrap();+ match page {+ RedisCollectionPage::Hash { scan_cursor, .. } | RedisCollectionPage::Set { scan_cursor, .. } => {+ assert_eq!(scan_cursor, Some(cursor));+ }+ _ => panic!("expected collection"),+ }+ assert_eq!(buffered.command_count("HSCAN") + buffered.command_count("SSCAN"), 0);+ let mut wrong = FakeRedisConnection::new(vec![]);+ assert!(super::load_more_collection_scoped(+ &mut wrong,+ b"key",+ key_type,+ cursor,+ 1,+ None,+ None,+ &super::RedisOperationScope { db: 0, ..scope.clone() }+ )+ .await+ .is_err());+ assert!(wrong.commands.is_empty());+ let mut failed = FakeRedisConnection::with_results(vec![Err(redis::RedisError::from((+ redis::ErrorKind::Io,+ "temporary scan failure",+ )))]);+ assert!(super::load_more_collection_scoped(&mut failed, b"key", key_type, cursor, 1, None, None, &scope)+ .await+ .is_err());+ assert!(super::collection_overflow_sessions().lock().await.entries.contains_key(&cursor));+ let response = if key_type == "hash" {+ hscan_response("0", vec![("three", "value")])+ } else {+ scan_response("0", vec!["three"])+ };+ let mut retry = FakeRedisConnection::new(vec![response, httl_response(1, -1)]);+ let page = super::load_more_collection_scoped(&mut retry, b"key", key_type, cursor, 1, None, None, &scope)+ .await+ .unwrap();+ match page {+ RedisCollectionPage::Hash { items, scan_cursor } => {+ assert_eq!(items[0].field, redis_blob_from_bytes(b"three"));+ assert_eq!(scan_cursor, None);+ }+ RedisCollectionPage::Set { items, scan_cursor } => {+ assert_eq!(items[0].member, redis_blob_from_bytes(b"three"));+ assert_eq!(scan_cursor, None);+ }+ _ => panic!("expected collection"),+ }+ assert!(retry.commands[0].contains("\r\n128\r\n"));+ }+ }- use super::{- classify_command, connection_info, decode_cluster_cursor, encode_cluster_cursor, is_redis_auth_error,- is_redis_command_denied_error, is_redis_json_type, parse_cluster_slots, parse_command_argv,- parse_database_count, parse_redis_endpoint, parse_scan_keys, parse_stream_consumers, parse_stream_entries,- parse_stream_groups, parse_stream_pending_entries, redis_auth_candidates, redis_blob_display_text,- redis_blob_from_bytes, redis_cluster_slot, redis_command_raw_to_json, redis_database_index,- redis_key_bytes_to_display, redis_key_bytes_to_raw, redis_key_matches_query, redis_key_raw_to_bytes,- redis_key_value_preview, redis_sentinel_master_endpoint, redis_value_matches_query, redis_value_to_bytes,- standalone_connection_infos, RedisAuthCandidate, RedisBlob, RedisBlobEncoding, RedisClusterSlotRange,- RedisCollectionPage, RedisCommandSafety, RedisHashItem, RedisListItem, RedisNodeEndpoint, RedisNodeRoute,- RedisRawValue, RedisSetItem, RedisStreamConsumer, RedisStreamEntry, RedisStreamField, RedisStreamGroup,- RedisStreamPendingEntry, RedisValue, RedisValueData, RedisZsetItem,- };- use dbx_types::models::connection::ConnectionConfig;- use redis::{aio::ConnectionLike, Cmd, ConnectionAddr, Pipeline, RedisFuture};+ #[tokio::test]+ #[ignore = "requires approved disposable Valkey multi-DB, default-one and Redis cluster fixtures"]+ async fn cluster_databases_live_native_mapped_and_permission_controls() {+ let mut config = redis_test_connection_config();+ config.host = "127.0.0.1".to_string();+ config.port =+ std::env::var("DBX_TEST_VALKEY_CLUSTER_PORT").expect("DBX_TEST_VALKEY_CLUSTER_PORT").parse().unwrap();+ config.username.clear();+ config.password.clear();+ let pool = super::connect_cluster(&config).await.unwrap();+ assert!(pool.database_connections.lock().await.is_empty());+ let databases = super::list_cluster_databases(&pool).await.unwrap();+ assert_eq!(databases.iter().map(|database| database.db).collect::<Vec<_>>(), vec![0, 1, 2, 3]);+ assert!(databases.iter().all(|database| database.keys.is_some()));+ assert!(+ pool.database_connections.lock().await.is_empty(),+ "listing must not create one cluster connection per database"+ );+ let mut keys = Vec::new();+ for (index, range) in pool.slot_ranges.iter().enumerate() {+ let key = (0..100_000)+ .map(|candidate| format!("dbx1271:driver-live:{}:{index}:{candidate}", std::process::id()))+ .find(|key| (range.start..=range.end).contains(&redis_cluster_slot(key.as_bytes())))+ .unwrap();+ for db in [0, 1] {+ let mut con = super::cluster_key_connection_in_db(&pool, key.as_bytes(), db).await.unwrap();+ redis::cmd("SET")+ .arg(&key)+ .arg(format!("db{db}:master{index}"))+ .query_async::<()>(&mut con)+ .await+ .unwrap();+ }+ keys.push(key);+ }+ assert_eq!(keys.len(), 3);+ assert_eq!(pool.database_connections.lock().await.len(), 1);+ let cold = super::connect_cluster(&config).await.unwrap();+ super::list_cluster_databases(&cold).await.unwrap();+ assert!(cold.database_connections.lock().await.is_empty());+ let cold_ref = &cold;+ let cold_values = futures_util::future::join_all(keys.iter().map(|key| async move {+ let mut con = super::cluster_key_connection_in_db(cold_ref, key.as_bytes(), 1).await.unwrap();+ redis::cmd("GET").arg(key).query_async::<String>(&mut con).await.unwrap()+ }))+ .await;+ for (index, value) in cold_values.iter().enumerate() {+ assert_eq!(value, &format!("db1:master{index}"));+ }+ assert_eq!(cold.database_connections.lock().await.len(), 1);+ for (index, key) in keys.iter().enumerate() {+ for _ in 0..10 {+ let pool_ref = &pool;+ let read = |db| async move {+ let mut con = super::cluster_key_connection_in_db(pool_ref, key.as_bytes(), db).await.unwrap();+ redis::cmd("GET").arg(key).query_async::<String>(&mut con).await.unwrap()+ };+ let (zero, one) = tokio::join!(read(0), read(1));+ assert_eq!(zero, format!("db0:master{index}"));+ assert_eq!(one, format!("db1:master{index}"));+ }+ }+ let forwarded_port: u16 =+ std::env::var("DBX_TEST_VALKEY_FORWARDED_PORT").expect("DBX_TEST_VALKEY_FORWARDED_PORT").parse().unwrap();+ let routes = pool+ .node_routes+ .iter()+ .map(|route| RedisNodeRoute {+ advertised: route.advertised.clone(),+ connect: RedisNodeEndpoint {+ host: "127.0.0.1".to_string(),+ port: forwarded_port + route.advertised.port - config.port,+ },+ })+ .collect::<Vec<_>>();+ let mapped = super::connect_routed_cluster(+ &config,+ routes.clone(),+ pool.slot_ranges.clone(),+ routes,+ super::RedisClusterAuth { username: String::new(), password: String::new() },+ )+ .await+ .unwrap();+ let mapped_databases = super::list_cluster_databases(&mapped).await.unwrap();+ assert_eq!(mapped_databases.len(), 4);+ for (index, key) in keys.iter().enumerate() {+ let mut con = super::cluster_key_connection_in_db(&mapped, key.as_bytes(), 1).await.unwrap();+ assert_eq!(+ redis::cmd("GET").arg(key).query_async::<String>(&mut con).await.unwrap(),+ format!("db1:master{index}")+ );+ }+ for db in [0, 1] {+ let mut cursor = 0;+ let mut found = Vec::new();+ loop {+ let page = super::scan_cluster_keys_batch_in_db(+ &mapped,+ db,+ cursor,+ &format!("dbx1271:driver-live:{}:*", std::process::id()),+ 100,+ 3,+ false,+ )+ .await+ .unwrap();+ found.extend(page.keys);+ cursor = page.cursor;+ if cursor == 0 {+ break;+ }+ }+ assert_eq!(found.len(), 3);+ }+ let pattern = format!("dbx1271:driver-live:{}:*", std::process::id());+ let mut cursor = 0;+ let mut found = Vec::new();+ loop {+ let page = super::scan_cluster_values_page_in_db(&mapped, 1, cursor, &pattern, "db1:master", false, 100)+ .await+ .unwrap();+ assert_eq!(Some(page.total_keys), mapped_databases[1].keys);+ found.extend(page.keys);+ cursor = page.cursor;+ if cursor == 0 {+ break;+ }+ assert!(super::scan_cluster_values_page_in_db(&mapped, 0, cursor, &pattern, "db1:master", false, 100)+ .await+ .is_err());+ }+ assert_eq!(found.len(), 3);+ let mut denied_config = config.clone();+ denied_config.username = "dbx1271-no-config".to_string();+ denied_config.password = "dbx1271-fixture-only".to_string();+ let denied = super::connect_cluster(&denied_config).await.unwrap();+ assert_eq!(super::list_cluster_databases(&denied).await.unwrap().len(), 1);+ let diagnostic = super::cluster_database_diagnostic(&denied).await.unwrap();+ assert!(is_redis_command_denied_error(&diagnostic), "{diagnostic}");+ let mut con = super::cluster_key_connection_in_db(&denied, keys[0].as_bytes(), 0).await.unwrap();+ assert_eq!(redis::cmd("GET").arg(&keys[0]).query_async::<String>(&mut con).await.unwrap(), "db0:master0");+ assert!(super::ensure_cluster_database(&denied, 1).await.unwrap_err().contains("CONFIG"));+ for variable in ["DBX_TEST_VALKEY_DEFAULT_CLUSTER_PORT", "DBX_TEST_REDIS_CONTROL_CLUSTER_PORT"] {+ let mut control_config = config.clone();+ control_config.port = std::env::var(variable).expect(variable).parse().unwrap();+ let control = super::connect_cluster(&control_config).await.unwrap();+ assert_eq!(super::list_cluster_databases(&control).await.unwrap().len(), 1);+ assert!(super::ensure_cluster_database(&control, 1).await.is_err());+ super::cluster_any_connection_in_db(&control, 0).await.unwrap();+ }+ for db in [0, 1] {+ for key in &keys {+ let mut con = super::cluster_key_connection_in_db(&pool, key.as_bytes(), db).await.unwrap();+ redis::cmd("DEL").arg(key).query_async::<u64>(&mut con).await.unwrap();+ }+ }+ }struct FakeRedisConnection {responses: VecDeque<redis::RedisResult<RedisRawValue>>,@@ -4841,10 +6333,323 @@ mod tests {}fn noperm(command: &str) -> redis::RedisError {- redis::make_extension_error(- "NOPERM".to_string(),- Some(format!("this user has no permissions to run the '{command}' command")),+ redis::parse_redis_value(+ format!("-NOPERM this user has no permissions to run the '{command}' command\r\n").as_bytes(),+ )+ .unwrap()+ .extract_error()+ .unwrap_err()+ }++ #[test]+ fn parsed_server_errors_preserve_compatibility_classification() {+ let error =+ |response: &str| redis::parse_redis_value(response.as_bytes()).unwrap().extract_error().unwrap_err();+ let unknown_select = error("-ERR unknown command 'SELECT'\r\n");+ assert!(super::is_unavailable_db_zero_select(&unknown_select, 0));+ assert!(!super::is_unavailable_db_zero_select(&unknown_select, 1));+ assert!(super::is_unsupported_keepttl_error(&error("-ERR syntax error\r\n")));+ for response in [+ "-NOPERM unknown command SELECT syntax error\r\n",+ "-WRONGPASS syntax error\r\n",+ "-READONLY syntax error\r\n",+ "-WRONGTYPE syntax error\r\n",+ ] {+ let error = error(response);+ assert!(!super::is_unavailable_db_zero_select(&error, 0));+ assert!(!super::is_unsupported_keepttl_error(&error));+ }+ let denied_ping = noperm("ping").to_string();+ assert!(super::is_redis_command_denied_error(&denied_ping));+ assert!(!super::is_redis_auth_error(&denied_ping));+ assert!(super::is_redis_auth_error(&error("-WRONGPASS invalid username-password pair\r\n").to_string()));+ assert!(super::is_hash_field_update_acl_compatibility_error(&noperm("eval")));+ assert!(!super::is_hash_field_update_acl_compatibility_error(&noperm("unrelated")));+ }++ #[tokio::test]+ async fn connection_keeps_dbx_deadline_and_allows_slow_responses() {+ use tokio::io::{AsyncBufReadExt, AsyncReadExt, AsyncWriteExt, BufReader};+ let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();+ let address = listener.local_addr().unwrap();+ let server = tokio::spawn(async move {+ let (stream, _) = listener.accept().await.unwrap();+ let (reader, mut writer) = stream.into_split();+ let mut reader = BufReader::new(reader);+ // A valid handshake slower than redis-rs 1.x's new 1-second default.+ tokio::time::sleep(Duration::from_millis(1100)).await;+ loop {+ let mut line = String::new();+ if reader.read_line(&mut line).await.unwrap() == 0 {+ break;+ }+ let count: usize = line.trim().strip_prefix('*').unwrap().parse().unwrap();+ let mut args = Vec::new();+ for _ in 0..count {+ line.clear();+ reader.read_line(&mut line).await.unwrap();+ let len: usize = line.trim().strip_prefix('$').unwrap().parse().unwrap();+ let mut arg = vec![0; len + 2];+ reader.read_exact(&mut arg).await.unwrap();+ arg.truncate(len);+ args.push(arg);+ }+ if args[0] == b"GET" {+ // Commands may legitimately exceed the new 500-ms default.+ tokio::time::sleep(Duration::from_millis(650)).await;+ writer.write_all(b"$3\r\n\x00\xffA\r\n").await.unwrap();+ break;+ }+ writer.write_all(if args[0] == b"PING" { b"+PONG\r\n" } else { b"+OK\r\n" }).await.unwrap();+ }+ });+ let mut con = super::connect(&format!("redis://{address}"), Duration::from_secs(3)).await.unwrap();+ let value: Vec<u8> =+ tokio::time::timeout(Duration::from_secs(3), redis::cmd("GET").arg("slow").query_async(&mut con))+ .await+ .unwrap()+ .unwrap();+ assert_eq!(value, b"\x00\xffA");+ server.await.unwrap();++ let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();+ let error = super::connect(&format!("redis://{}", listener.local_addr().unwrap()), Duration::from_millis(30))+ .await+ .unwrap_err();+ assert!(error.contains("connection timed out"));+ }++ struct SentinelMockReply {+ command: &'static str,+ response: Vec<u8>,+ delay: Duration,+ }++ impl SentinelMockReply {+ fn immediate(command: &'static str, response: &[u8]) -> Self {+ Self { command, response: response.to_vec(), delay: Duration::ZERO }+ }+ }++ async fn sentinel_mock(+ auth: Option<(&str, &str)>,+ scripts: Vec<Vec<SentinelMockReply>>,+ ) -> (std::net::SocketAddr, tokio::task::JoinHandle<()>) {+ use tokio::io::{AsyncBufReadExt, AsyncReadExt, AsyncWriteExt, BufReader};+ let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();+ let address = listener.local_addr().unwrap();+ let auth = auth.map(|(username, password)| {+ vec![b"AUTH".to_vec(), username.as_bytes().to_vec(), password.as_bytes().to_vec()]+ });+ let server = tokio::spawn(async move {+ for script in scripts {+ let (stream, _) = listener.accept().await.unwrap();+ let (reader, mut writer) = stream.into_split();+ let mut reader = BufReader::new(reader);+ let mut script = VecDeque::from(script);+ let mut authenticated = auth.is_none();+ while !script.is_empty() {+ let mut line = String::new();+ reader.read_line(&mut line).await.unwrap();+ let count: usize = line.trim().strip_prefix('*').unwrap().parse().unwrap();+ let mut args = Vec::new();+ for _ in 0..count {+ line.clear();+ reader.read_line(&mut line).await.unwrap();+ let len: usize = line.trim().strip_prefix('$').unwrap().parse().unwrap();+ let mut arg = vec![0; len + 2];+ reader.read_exact(&mut arg).await.unwrap();+ arg.truncate(len);+ args.push(arg);+ }+ match args[0].as_slice() {+ b"AUTH" => {+ assert_eq!(Some(&args), auth.as_ref());+ authenticated = true;+ writer.write_all(b"+OK\r\n").await.unwrap();+ }+ b"CLIENT" => writer.write_all(b"+OK\r\n").await.unwrap(),+ _ => {+ assert!(authenticated);+ let reply = script.pop_front().unwrap();+ assert_eq!(args[0], reply.command.as_bytes());+ tokio::time::sleep(reply.delay).await;+ if !reply.response.is_empty() {+ writer.write_all(&reply.response).await.unwrap();+ }+ // An empty response intentionally drops the socket.+ }+ }+ }+ }+ });+ (address, server)+ }++ fn sentinel_masters_response(port: u16) -> Vec<u8> {+ let port = port.to_string();+ let fields = ["name", "dbx1271master", "ip", "127.0.0.1", "port", &port, "flags", "master"];+ let mut response = format!("*1\r\n*{}\r\n", fields.len());+ for field in fields {+ response.push_str(&format!("${}\r\n{}\r\n", field.len(), field));+ }+ response.into_bytes()+ }++ #[tokio::test]+ async fn sentinel_discovery_and_role_keep_dbx_deadline_and_separate_credentials() {+ let role = b"*3\r\n$6\r\nmaster\r\n:0\r\n*0\r\n";+ let (master, master_server) = sentinel_mock(+ Some(("master-user", "master-password")),+ vec![+ vec![SentinelMockReply { command: "ROLE", response: role.to_vec(), delay: Duration::from_millis(650) }],+ vec![SentinelMockReply::immediate("PING", b"+PONG\r\n")],+ ],+ )+ .await;+ let (sentinel, sentinel_server) = sentinel_mock(+ Some(("sentinel-user", "sentinel-password")),+ vec![vec![SentinelMockReply {+ command: "SENTINEL",+ response: sentinel_masters_response(master.port()),+ delay: Duration::from_millis(650),+ }]],+ )+ .await;+ let mut config = redis_test_connection_config();+ config.redis_sentinel_nodes = sentinel.to_string();+ config.redis_sentinel_master = "dbx1271master".to_string();+ config.redis_sentinel_username = "sentinel-user".to_string();+ config.redis_sentinel_password = "sentinel-password".to_string();+ config.username = "master-user".to_string();+ config.password = "master-password".to_string();+ super::connect_sentinel_with_timeout(&config, Duration::from_secs(5)).await.unwrap();+ sentinel_server.await.unwrap();+ master_server.await.unwrap();+ }++ #[tokio::test]+ async fn sentinel_lookup_outer_deadline_is_still_enforced() {+ // The open socket never sends a handshake response.+ let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();+ let mut config = redis_test_connection_config();+ config.redis_sentinel_nodes = listener.local_addr().unwrap().to_string();+ config.redis_sentinel_master = "dbx1271master".to_string();+ let error = super::connect_sentinel_with_timeout(&config, Duration::from_millis(30)).await.unwrap_err();+ assert!(error.contains("Redis Sentinel lookup timed out"));+ }++ #[test]+ fn sentinel_master_filter_preserves_service_flags_and_endpoint_validation() {+ let valid: HashMap<String, String> =+ [("name", "service"), ("ip", "127.0.0.1"), ("port", "6379"), ("flags", "master")]+ .into_iter()+ .map(|(key, value)| (key.to_string(), value.to_string()))+ .collect();+ assert_eq!(super::sentinel_eligible_master(&valid, "service").unwrap().port, 6379);+ assert!(super::sentinel_eligible_master(&valid, "missing").is_none());+ for (field, value) in [+ ("flags", "slave"),+ ("flags", "master,s_down"),+ ("flags", "master,o_down"),+ ("port", "bad"),+ ("port", "65536"),+ ] {+ let mut metadata = valid.clone();+ metadata.insert(field.to_string(), value.to_string());+ assert!(super::sentinel_eligible_master(&metadata, "service").is_none());+ }+ for field in ["name", "ip", "port", "flags"] {+ let mut metadata = valid.clone();+ metadata.remove(field);+ assert!(super::sentinel_eligible_master(&metadata, "service").is_none());+ }+ }++ #[test]+ fn sentinel_node_options_keep_tls_and_credentials_separate_from_master() {+ let mut config = redis_test_connection_config();+ config.redis_sentinel_nodes = "sentinel.example:26379".to_string();+ config.redis_sentinel_username = "sentinel-user".to_string();+ config.redis_sentinel_password = "sentinel-secret".to_string();+ config.username = "master-user".to_string();+ config.password = "master-secret".to_string();+ config.ssl = true;+ config.redis_sentinel_tls = false;+ let nodes = super::redis_sentinel_nodes(&config).unwrap();+ assert!(matches!(nodes[0].addr(), ConnectionAddr::Tcp(_, 26379)));+ assert_eq!(nodes[0].redis_settings().username(), Some("sentinel-user"));+ assert_eq!(nodes[0].redis_settings().password(), Some("sentinel-secret"));+ assert_eq!(nodes[0].redis_settings().db(), 0);++ config.ssl = false;+ config.redis_sentinel_tls = true;+ config.url_params = Some("tls_insecure=true".to_string());+ let nodes = super::redis_sentinel_nodes(&config).unwrap();+ assert!(matches!(nodes[0].addr(), ConnectionAddr::TcpTls { insecure: true, .. }));+ assert_eq!(nodes[0].redis_settings().username(), Some("sentinel-user"));+ }++ #[tokio::test]+ async fn sentinel_role_fallback_and_error_priority_match_previous_client() {+ let parsed_error =+ |response: &str| redis::parse_redis_value(response.as_bytes()).unwrap().extract_error().unwrap_err();+ let unknown = || parsed_error("-ERR unknown command 'ROLE'\r\n");+ let primary = RedisRawValue::Array(vec![bulk("master"), RedisRawValue::Int(0), RedisRawValue::Array(vec![])]);+ let replica = RedisRawValue::Array(vec![+ bulk("slave"),+ bulk("127.0.0.1"),+ RedisRawValue::Int(6379),+ bulk("connected"),+ RedisRawValue::Int(0),+ ]);+ let mut con = FakeRedisConnection::new(vec![primary]);+ assert!(super::sentinel_is_master(&mut con).await.unwrap());+ assert_eq!(con.command_count("INFO"), 0);+ let mut con = FakeRedisConnection::new(vec![replica]);+ assert!(!super::sentinel_is_master(&mut con).await.unwrap());+ assert_eq!(con.command_count("INFO"), 0);+ for role in ["master", "slave"] {+ let mut con = FakeRedisConnection::with_results(vec![+ Err(unknown()),+ Ok(bulk(&format!("# Replication\r\nrole:{role}\r\n"))),+ ]);+ assert_eq!(super::sentinel_is_master(&mut con).await.unwrap(), role == "master");+ }+ // The old client also accepts successful INFO after a denied ROLE.+ let mut con = FakeRedisConnection::with_results(vec![Err(noperm("role")), Ok(bulk("role:master\r\n"))]);+ assert!(super::sentinel_is_master(&mut con).await.unwrap());+ let mut con = FakeRedisConnection::with_results(vec![Err(unknown()), Err(noperm("info"))]);+ assert!(super::sentinel_is_master(&mut con).await.unwrap_err().detail().unwrap().contains("info"));+ let mut con = FakeRedisConnection::with_results(vec![Err(noperm("role")), Err(noperm("info"))]);+ assert!(super::sentinel_is_master(&mut con).await.unwrap_err().detail().unwrap().contains("role"));+ let mut con = FakeRedisConnection::with_results(vec![Err(unknown()), Ok(bulk("# no role\r\n"))]);+ assert!(super::sentinel_is_master(&mut con).await.unwrap_err().to_string().contains("Missing role"));+ let io = redis::RedisError::from(std::io::Error::new(std::io::ErrorKind::ConnectionReset, "reset"));+ let mut con = FakeRedisConnection::with_results(vec![Err(io), Err(noperm("info"))]);+ assert!(super::sentinel_is_master(&mut con).await.unwrap_err().is_io_error());+ }++ #[tokio::test]+ async fn sentinel_discovery_retries_io_once_and_tries_next_node_on_error() {+ let empty_masters = b"*0\r\n";+ let (first, first_server) = sentinel_mock(+ None,+ vec![+ vec![SentinelMockReply::immediate("SENTINEL", b"")],+ vec![SentinelMockReply::immediate("SENTINEL", b"-NOPERM sentinel denied\r\n")],+ ],)+ .await;+ let (second, second_server) =+ sentinel_mock(None, vec![vec![SentinelMockReply::immediate("SENTINEL", empty_masters)]]).await;+ let nodes = [first, second]+ .into_iter()+ .map(|node| connection_info("127.0.0.1", node.port(), false, false, "", "", 0).unwrap())+ .collect::<Vec<_>>();+ assert!(super::sentinel_masters(&nodes).await.unwrap().is_empty());+ first_server.await.unwrap();+ second_server.await.unwrap();}fn text_blob(value: &str) -> RedisBlob {@@ -4904,7 +6709,7 @@ mod tests {#[tokio::test]async fn db0_console_command_continues_when_select_is_unavailable() {let select_error = redis::RedisError::from((- redis::ErrorKind::ResponseError,+ redis::ErrorKind::Server(redis::ServerErrorKind::ResponseError),"An error was signalled by the server","unknown command 'select', with args beginning with: '0'".to_string(),));@@ -4932,7 +6737,7 @@ mod tests {#[tokio::test]async fn console_command_does_not_ignore_unavailable_select_for_nonzero_db() {let select_error = redis::RedisError::from((- redis::ErrorKind::ResponseError,+ redis::ErrorKind::Server(redis::ServerErrorKind::ResponseError),"An error was signalled by the server","unknown command 'select', with args beginning with: '1'".to_string(),));@@ -4949,13 +6754,13 @@ mod tests {async fn console_command_propagates_non_compatibility_select_errors() {let errors = vec![redis::RedisError::from((- redis::ErrorKind::ResponseError,+ redis::ErrorKind::Server(redis::ServerErrorKind::ResponseError),"An error was signalled by the server","invalid DB index".to_string(),)),noperm("SELECT"),redis::RedisError::from((redis::ErrorKind::AuthenticationFailed, "Authentication failed")),- redis::RedisError::from((redis::ErrorKind::ParseError, "Invalid response")),+ redis::RedisError::from((redis::ErrorKind::Parse, "Invalid response")),redis::RedisError::from(std::io::Error::new(std::io::ErrorKind::ConnectionReset, "connection reset")),];@@ -4971,7 +6776,7 @@ mod tests {#[tokio::test]async fn strict_database_selection_keeps_unavailable_select_error() {let select_error = redis::RedisError::from((- redis::ErrorKind::ResponseError,+ redis::ErrorKind::Server(redis::ServerErrorKind::ResponseError),"An error was signalled by the server","unknown command 'select'".to_string(),));@@ -5315,7 +7120,7 @@ mod tests {async fn large_hash_value_stays_bounded_when_httl_is_unsupported() {let pairs = (0..512).map(|index| (format!("field:{index}"), format!("value:{index}"))).collect();let unsupported = redis::RedisError::from((- redis::ErrorKind::ResponseError,+ redis::ErrorKind::Server(redis::ServerErrorKind::ResponseError),"An error was signalled by the server","unknown command 'HTTL'".to_string(),));@@ -5858,7 +7663,7 @@ mod tests {#[tokio::test]async fn set_string_falls_back_to_pttl_and_px_when_keepttl_is_unsupported() {let unsupported = redis::RedisError::from((- redis::ErrorKind::ResponseError,+ redis::ErrorKind::Server(redis::ServerErrorKind::ResponseError),"An error was signalled by the server","syntax error".to_string(),));@@ -5879,7 +7684,7 @@ mod tests {#[tokio::test]async fn set_string_fallback_keeps_persistent_keys_persistent() {let unsupported = redis::RedisError::from((- redis::ErrorKind::ResponseError,+ redis::ErrorKind::Server(redis::ServerErrorKind::ResponseError),"An error was signalled by the server","syntax error".to_string(),));@@ -5899,7 +7704,7 @@ mod tests {#[tokio::test]async fn set_string_does_not_fallback_for_unrelated_errors() {let read_only = redis::RedisError::from((- redis::ErrorKind::ReadOnly,+ redis::ErrorKind::Server(redis::ServerErrorKind::ReadOnly),"The server is read-only","You can't write against a read only replica".to_string(),));@@ -6362,6 +8167,8 @@ mod tests {let forwarded = RedisNodeEndpoint { host: "127.0.0.1".to_string(), port: 17_000 };let pool = super::RedisClusterPool {connection: None,+ database_connections: Box::new(tokio::sync::Mutex::new(HashMap::new())),+ database_capability: Box::new(tokio::sync::Mutex::new(None)),seed_nodes: vec![advertised.clone()],seed_routes: Vec::new(),slot_ranges: Vec::new(),@@ -6813,7 +8620,11 @@ mod tests {async fn hash_search_optional_lookup_errors_fall_back_without_hiding_real_failures() {for error in [noperm("hget"),- redis::RedisError::from((redis::ErrorKind::ResponseError, "ERR", "unknown command 'HGET'".to_string())),+ redis::RedisError::from((+ redis::ErrorKind::Server(redis::ServerErrorKind::ResponseError),+ "ERR",+ "unknown command 'HGET'".to_string(),+ )),] {let mut con =FakeRedisConnection::with_results(vec![Err(error), Ok(hscan_response("0", vec![("field", "wanted")]))]);@@ -6821,9 +8632,9 @@ mod tests {assert_eq!(items.len(), 1);}for error in [- redis::RedisError::from((redis::ErrorKind::IoError, "disconnected")),+ redis::RedisError::from((redis::ErrorKind::Io, "disconnected")),redis::RedisError::from((redis::ErrorKind::AuthenticationFailed, "WRONGPASS")),- redis::RedisError::from((redis::ErrorKind::TypeError, "WRONGTYPE")),+ redis::RedisError::from((redis::ErrorKind::UnexpectedReturnType, "WRONGTYPE")),] {let mut con = FakeRedisConnection::with_results(vec![Err(error)]);assert!(super::hscan_filtered_page_raw(&mut con, b"hash", 0, 200, "wanted").await.is_err());@@ -7224,7 +9035,7 @@ mod tests {assert_eq!(items[0].field_ttl, None);let mut con = FakeRedisConnection::with_results(vec![Err(redis::RedisError::from((- redis::ErrorKind::ResponseError,+ redis::ErrorKind::Server(redis::ServerErrorKind::ResponseError),"server error","unrelated discovery failure".to_string(),)))]);@@ -7269,7 +9080,7 @@ mod tests {#[tokio::test]async fn hash_load_more_degrades_when_field_ttl_is_unsupported() {let unsupported = redis::RedisError::from((- redis::ErrorKind::ResponseError,+ redis::ErrorKind::Server(redis::ServerErrorKind::ResponseError),"An error was signalled by the server","unknown command 'HTTL'".to_string(),));@@ -7397,8 +9208,13 @@ mod tests {"WRONGTYPE Operation against a key holding the wrong kind of value","Invalid argument: hash field expiration is not supported by legacy hash encoding: extra failure",] {- let error =- || redis::RedisError::from((redis::ErrorKind::ResponseError, "server error", detail.to_string()));+ let error = || {+ redis::RedisError::from((+ redis::ErrorKind::Server(redis::ServerErrorKind::ResponseError),+ "server error",+ detail.to_string(),+ ))+ };let mut con = FakeRedisConnection::with_results(vec![Err(error())]);assert!(super::hash_set(&mut con, b"hash", "field", "value", None).await.unwrap_err().contains(detail));assert_eq!(con.command_count("HSET"), 0);@@ -7636,7 +9452,7 @@ mod tests {#[tokio::test]async fn hash_set_degrades_when_field_ttl_is_rejected_as_unknown_redis_command() {let unsupported = redis::RedisError::from((- redis::ErrorKind::ResponseError,+ redis::ErrorKind::Server(redis::ServerErrorKind::ResponseError),"An error was signalled by the server","unknown redis command HTTL".to_string(),));@@ -7772,7 +9588,7 @@ mod tests {#[tokio::test]async fn hash_field_update_falls_back_when_cluster_rejects_field_ttl_script() {let rejection = redis::RedisError::from((- redis::ErrorKind::ResponseError,+ redis::ErrorKind::Server(redis::ServerErrorKind::ResponseError),"An error was signalled by the server","bad lua script for redis cluster, redis.call/pcall unknown redis command HTTL".to_string(),));@@ -7790,7 +9606,7 @@ mod tests {#[tokio::test]async fn hash_field_update_falls_back_for_renames_when_cluster_rejects_field_ttl_script() {let rejection = redis::RedisError::from((- redis::ErrorKind::ResponseError,+ redis::ErrorKind::Server(redis::ServerErrorKind::ResponseError),"An error was signalled by the server","bad lua script for redis cluster, redis.call/pcall unknown redis command HTTL".to_string(),));@@ -7949,7 +9765,7 @@ mod tests {let error = super::zset_update(&mut con, b"scores", "alice", "10", "alicia", "20").await.unwrap_err();- assert!(error.contains("NOPERM"));+ assert!(error.to_ascii_uppercase().contains("NOPERM"));assert_eq!(con.command_count("EVAL"), 1);assert_eq!(con.commands.len(), 1);}@@ -8249,17 +10065,17 @@ mod tests {#[test]fn redis_connection_info_marks_tls_as_insecure_when_requested() {- let info = connection_info("cache.example.com", 6379, true, true, "default", "secret", 0);+ let info = connection_info("cache.example.com", 6379, true, true, "default", "secret", 0).unwrap();- assert!(matches!(info.addr, ConnectionAddr::TcpTls { insecure: true, .. }));+ 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);+ let info = connection_info("cache.example.com", 6379, false, false, "app-user", "secret", 0).unwrap();- assert_eq!(info.redis.username.as_deref(), Some("app-user"));- assert_eq!(info.redis.password.as_deref(), Some("secret"));+ assert_eq!(info.redis_settings().username(), Some("app-user"));+ assert_eq!(info.redis_settings().password(), Some("secret"));}#[test]@@ -8296,27 +10112,27 @@ mod tests {#[test]fn standalone_connection_infos_cover_no_auth_acl_fallback_tls_and_database() {let mut config = redis_test_connection_config();- let no_auth = standalone_connection_infos(&config, "127.0.0.1", 6379);+ let no_auth = standalone_connection_infos(&config, "127.0.0.1", 6379).unwrap();assert_eq!(no_auth.len(), 1);- assert_eq!(no_auth[0].redis.username, None);- assert_eq!(no_auth[0].redis.password, None);- assert_eq!(no_auth[0].redis.db, 0);+ assert_eq!(no_auth[0].redis_settings().username(), None);+ assert_eq!(no_auth[0].redis_settings().password(), None);+ assert_eq!(no_auth[0].redis_settings().db(), 0);config.username = "app-user".to_string();config.password = "secret".to_string();config.database = Some("4".to_string());config.ssl = true;config.url_params = Some("tls_insecure=true".to_string());- let infos = standalone_connection_infos(&config, "cache.example.com", 6380);+ let infos = standalone_connection_infos(&config, "cache.example.com", 6380).unwrap();assert_eq!(infos.len(), 2);- assert!(matches!(infos[0].addr, ConnectionAddr::TcpTls { port: 6380, insecure: true, .. }));- assert_eq!(infos[0].redis.username.as_deref(), Some("app-user"));- assert_eq!(infos[0].redis.password.as_deref(), Some("secret"));- assert_eq!(infos[0].redis.db, 4);- assert_eq!(infos[1].redis.username, None);- assert_eq!(infos[1].redis.password.as_deref(), Some("app-user@secret"));- assert_eq!(infos[1].redis.db, 4);+ assert!(matches!(infos[0].addr(), ConnectionAddr::TcpTls { port: 6380, insecure: true, .. }));+ assert_eq!(infos[0].redis_settings().username(), Some("app-user"));+ assert_eq!(infos[0].redis_settings().password(), Some("secret"));+ assert_eq!(infos[0].redis_settings().db(), 4);+ assert_eq!(infos[1].redis_settings().username(), None);+ assert_eq!(infos[1].redis_settings().password(), Some("app-user@secret"));+ assert_eq!(infos[1].redis_settings().db(), 4);}#[test]@@ -8329,6 +10145,61 @@ mod tests {assert_eq!(redis_database_index(&config), 0);}+ #[tokio::test]+ #[ignore = "requires disposable standalone/Sentinel/TLS fixtures via DBX_TEST_REDIS_*_PORT"]+ async fn redis_client_migration_live_connections() {+ use futures_util::StreamExt;+ // Match the application entrypoints when workspace builds enable both rustls providers.+ let _ = rustls::crypto::aws_lc_rs::default_provider().install_default();+ let port = |name| std::env::var(name).unwrap().parse::<u16>().unwrap();+ let timeout = Duration::from_secs(5);+ let mut config = redis_test_connection_config();+ config.host = "127.0.0.1".to_string();+ config.port = port("DBX_TEST_REDIS_PORT");+ let mut con = super::connect_standalone(&config, &config.host, config.port, timeout).await.unwrap();+ let mut pubsub = super::connect_pubsub(&config, &config.host, config.port, timeout).await.unwrap();+ let channel = format!("dbx1271:migration:{}", std::process::id());+ pubsub.subscribe(&channel).await.unwrap();+ let payload = b"\x00\xffmigration";+ redis::cmd("PUBLISH").arg(&channel).arg(payload).query_async::<usize>(&mut con).await.unwrap();+ let message = tokio::time::timeout(timeout, pubsub.on_message().next()).await.unwrap().unwrap();+ assert_eq!(message.get_payload_bytes(), payload);+ pubsub.unsubscribe(&channel).await.unwrap();+ drop(pubsub);++ let mut monitor = super::connect_monitor(&config, &config.host, config.port, timeout).await.unwrap();+ redis::cmd("PING").arg(&channel).query_async::<String>(&mut con).await.unwrap();+ let mut stream = monitor.on_message::<String>();+ tokio::time::timeout(timeout, async {+ loop {+ let message = stream.next().await.unwrap();+ if message.contains(&channel) {+ assert!(message.contains("PING"));+ break;+ }+ }+ })+ .await+ .unwrap();+ drop(stream);+ drop(monitor);++ config.redis_sentinel_nodes = format!("127.0.0.1:{}", port("DBX_TEST_REDIS_SENTINEL_PORT"));+ config.redis_sentinel_master = "dbx1271master".to_string();+ let mut master = super::connect_sentinel(&config).await.unwrap();+ assert_eq!(redis::cmd("PING").query_async::<String>(&mut master).await.unwrap(), "PONG");+ let role: RedisRawValue = redis::cmd("ROLE").query_async(&mut master).await.unwrap();+ let RedisRawValue::Array(role) = role else { panic!("expected ROLE array") };+ assert_eq!(role[0], bulk("master"));++ config.ssl = true;+ let tls_port = port("DBX_TEST_REDIS_TLS_PORT");+ assert!(super::connect_standalone(&config, &config.host, tls_port, timeout).await.is_err());+ config.url_params = Some("tls_insecure=true".to_string());+ let mut tls = super::connect_standalone(&config, &config.host, tls_port, timeout).await.unwrap();+ assert_eq!(redis::cmd("PING").query_async::<String>(&mut tls).await.unwrap(), "PONG");+ }+fn redis_test_connection_config() -> ConnectionConfig {ConnectionConfig {oracle_oci_nls_lang: None,diff --git a/crates/dbx-web/Cargo.toml b/crates/dbx-web/Cargo.tomlindex 805983cb95..f50d824200 100644--- a/crates/dbx-web/Cargo.toml+++ b/crates/dbx-web/Cargo.toml@@ -27,7 +27,7 @@ embed-static = ["dep:rust-embed", "dep:mime_guess"][dependencies]dbx-core = { path = "../dbx-core", default-features = false, features = ["openapi"] }dbx-mcp = { path = "../dbx-mcp", default-features = false }-redis = { version = "0.32", features = ["tokio-comp"] }+redis = { version = "1.7.1", features = ["tokio-comp"] }axum = { version = "0.8", features = ["multipart", "ws"] }tower-http = { version = "0.6", features = ["cors", "fs", "compression-gzip", "trace"] }tokio = { version = "1", features = ["full"] }diff --git a/src-tauri/Cargo.toml b/src-tauri/Cargo.tomlindex d77ac31029..ff67819c78 100644--- a/src-tauri/Cargo.toml+++ b/src-tauri/Cargo.toml@@ -52,7 +52,7 @@ tauri-plugin-shell = "2"tauri-plugin-updater = "=2.10.1"tauri-plugin-process = "2"tauri-plugin-window-state = "2"-redis = { version = "0.32.2", features = ["tokio-comp", "tls-rustls", "tokio-rustls-comp", "cluster-async"] }+redis = { version = "1.7.1", features = ["tokio-comp", "tls-rustls", "tokio-rustls-comp", "cluster-async"] }rustls = { version = "0.23", features = ["aws-lc-rs"] }portpicker = "0.1.1"tiberius = { version = "0.12.3", default-features = false, features = ["tds73", "chrono", "rust_decimal", "rustls", "sql-browser-tokio"] }