From 74687ce84e580208f3f50b062d9d8dc79022b79b Mon Sep 17 00:00:00 2001 From: nischit Date: Wed, 11 Feb 2026 18:40:40 +0545 Subject: [PATCH] Revert "redis tls support (#95)" This reverts commit d729f5f72a4988a5edcde79f2f2e577224b241da. --- Cargo.toml | 6 +-- README.md | 4 -- server/Cargo.toml | 3 +- server/DOCKER.md | 6 --- server/src/main.rs | 8 ---- twmq/Cargo.toml | 1 - twmq/src/lib.rs | 47 +++++++-------------- twmq/src/multilane.rs | 65 +++++++---------------------- twmq/tests/basic.rs | 3 +- twmq/tests/basic_hook.rs | 3 +- twmq/tests/delay.rs | 3 +- twmq/tests/idempotency_modes.rs | 3 +- twmq/tests/lease_expiry.rs | 3 +- twmq/tests/multilane_batch_pop.rs | 5 +-- twmq/tests/nack.rs | 3 +- twmq/tests/prune_race_condition.rs | 3 +- twmq/tests/prune_race_random_ids.rs | 5 +-- 17 files changed, 45 insertions(+), 126 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index bf3a2e8..b8fc7cd 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -98,11 +98,7 @@ config = "0.15.11" aws-arn = "0.3.1" # Redis -redis = { version = "0.31.0", features = ["connection-manager", "tls-rustls", "tls-rustls-webpki-roots", "tokio-rustls-comp"] } - -# Rustls (required for TLS crypto provider selection). -# Rustls 0.23 requires exactly one crypto provider feature (ring or aws-lc-rs). -rustls = { version = "0.23.32", default-features = false, features = ["ring"] } +redis = { version = "0.31.0", features = ["tokio-comp", "connection-manager"] } # Dev dependencies criterion = { version = "0.6", features = ["html_reports", "async_tokio"] } \ No newline at end of file diff --git a/README.md b/README.md index 8884e48..41631d5 100644 --- a/README.md +++ b/README.md @@ -147,8 +147,6 @@ thirdweb: redis: url: "redis://localhost:6379" -# For Redis over TLS, use the `rediss://` scheme: -# url: "rediss://localhost:6379" queue: webhook_workers: 50 @@ -168,8 +166,6 @@ export APP__QUEUE__LOCAL_CONCURRENCY=500 # Custom Redis configuration export APP__REDIS__URL="redis://redis-cluster:6379" -# For Redis over TLS, use the `rediss://` scheme: -# export APP__REDIS__URL="rediss://redis-cluster:6379" # Debug logging for development export RUST_LOG="thirdweb_engine=debug,twmq=debug" diff --git a/server/Cargo.toml b/server/Cargo.toml index f368839..d568ffb 100644 --- a/server/Cargo.toml +++ b/server/Cargo.toml @@ -50,5 +50,4 @@ aws-arn = { workspace = true } moka = { workspace = true } engine-eip7702-core = { path = "../eip7702-core" } prometheus = { workspace = true } -thiserror = { workspace = true } -rustls = { workspace = true } \ No newline at end of file +thiserror = { workspace = true } \ No newline at end of file diff --git a/server/DOCKER.md b/server/DOCKER.md index 6f6e066..e50a245 100644 --- a/server/DOCKER.md +++ b/server/DOCKER.md @@ -25,8 +25,6 @@ The following environment variables must be set when running the container: ```bash # Redis Configuration APP__REDIS__URL=redis://localhost:6379 -# For Redis over TLS, use the `rediss://` scheme: -# APP__REDIS__URL=rediss://localhost:6379 # Thirdweb Configuration APP__THIRDWEB__SECRET=your_secret_key_here @@ -70,8 +68,6 @@ Create a `.env` file with your configuration: ```bash # .env file APP__REDIS__URL=redis://localhost:6379 -# For Redis over TLS, use the `rediss://` scheme: -# APP__REDIS__URL=rediss://localhost:6379 APP__THIRDWEB__SECRET=your_secret_key_here APP__THIRDWEB__CLIENT_ID=your_client_id_here APP__THIRDWEB__URLS__RPC=https://your-rpc-url.com @@ -132,8 +128,6 @@ services: - "8080:8080" environment: - APP__REDIS__URL=redis://redis:6379 -# For Redis over TLS, use the `rediss://` scheme: -# - APP__REDIS__URL=rediss://redis:6379 - APP__THIRDWEB__SECRET=${APP__THIRDWEB__SECRET} - APP__THIRDWEB__CLIENT_ID=${APP__THIRDWEB__CLIENT_ID} - APP__THIRDWEB__URLS__RPC=${APP__THIRDWEB__URLS__RPC} diff --git a/server/src/main.rs b/server/src/main.rs index e6dd8a7..4376aec 100644 --- a/server/src/main.rs +++ b/server/src/main.rs @@ -70,14 +70,6 @@ async fn main() -> anyhow::Result<()> { }); let eoa_signer = Arc::new(EoaSigner::new(vault_client.clone(), iaw_client.clone())); let solana_signer = Arc::new(SolanaSigner::new(vault_client.clone(), iaw_client)); - - // Rustls 0.23 requires selecting a process-level CryptoProvider (ring or aws-lc-rs) - // before any TLS client configuration is created (e.g. when using `rediss://`). - // If another crate already installed a provider, this will be a no-op error. - if let Err(e) = rustls::crypto::ring::default_provider().install_default() { - tracing::debug!(error = ?e, "Rustls CryptoProvider already installed"); - } - let redis_client = twmq::redis::Client::open(config.redis.url.as_str())?; let authorization_cache = EoaAuthorizationCache::new( diff --git a/twmq/Cargo.toml b/twmq/Cargo.toml index 3f6227f..9d40caa 100644 --- a/twmq/Cargo.toml +++ b/twmq/Cargo.toml @@ -14,7 +14,6 @@ thiserror = { workspace = true } tracing = { workspace = true } tracing-subscriber = { workspace = true, features = ["env-filter", "fmt"] } futures = { workspace = true } -rustls = { workspace = true } [dev-dependencies] tokio = { workspace = true, features = ["full"] } diff --git a/twmq/src/lib.rs b/twmq/src/lib.rs index da022ba..164d234 100644 --- a/twmq/src/lib.rs +++ b/twmq/src/lib.rs @@ -175,63 +175,52 @@ impl Queue { &self.name } - /// Redis Cluster hash tag used to keep all queue keys in the same slot. - /// See: https://redis.io/docs/latest/operate/oss_and_stack/reference/cluster-spec/#hash-tags - fn redis_hash_tag(&self) -> String { - format!("{{{}}}", self.name()) - } - pub fn pending_list_name(&self) -> String { - format!("twmq:{}:pending", self.redis_hash_tag()) + format!("twmq:{}:pending", self.name()) } pub fn active_hash_name(&self) -> String { - format!("twmq:{}:active", self.redis_hash_tag()) + format!("twmq:{}:active", self.name) } pub fn delayed_zset_name(&self) -> String { - format!("twmq:{}:delayed", self.redis_hash_tag()) + format!("twmq:{}:delayed", self.name) } pub fn success_list_name(&self) -> String { - format!("twmq:{}:success", self.redis_hash_tag()) + format!("twmq:{}:success", self.name) } pub fn failed_list_name(&self) -> String { - format!("twmq:{}:failed", self.redis_hash_tag()) + format!("twmq:{}:failed", self.name) } pub fn job_data_hash_name(&self) -> String { - format!("twmq:{}:jobs:data", self.redis_hash_tag()) + format!("twmq:{}:jobs:data", self.name) } pub fn job_meta_hash_name(&self, job_id: &str) -> String { - format!("twmq:{}:job:{}:meta", self.redis_hash_tag(), job_id) + format!("twmq:{}:job:{}:meta", self.name, job_id) } pub fn job_errors_list_name(&self, job_id: &str) -> String { - format!("twmq:{}:job:{}:errors", self.redis_hash_tag(), job_id) + format!("twmq:{}:job:{}:errors", self.name, job_id) } pub fn job_result_hash_name(&self) -> String { - format!("twmq:{}:jobs:result", self.redis_hash_tag()) + format!("twmq:{}:jobs:result", self.name) } pub fn dedupe_set_name(&self) -> String { - format!("twmq:{}:dedup", self.redis_hash_tag()) + format!("twmq:{}:dedup", self.name) } pub fn pending_cancellation_set_name(&self) -> String { - format!("twmq:{}:pending_cancellations", self.redis_hash_tag()) + format!("twmq:{}:pending_cancellations", self.name) } pub fn lease_key_name(&self, job_id: &str, lease_token: &str) -> String { - format!( - "twmq:{}:job:{}:lease:{}", - self.redis_hash_tag(), - job_id, - lease_token - ) + format!("twmq:{}:job:{}:lease:{}", self.name, job_id, lease_token) } pub async fn push( @@ -312,8 +301,7 @@ impl Queue { let position_string = delay.position.to_string(); let _result: (i32, String) = script - // Redis Cluster: all KEYS must be in the same slot - .key(self.redis_hash_tag()) + .key(&self.name) .key(self.delayed_zset_name()) .key(self.pending_list_name()) .key(self.job_data_hash_name()) @@ -754,8 +742,7 @@ impl Queue { Vec, Vec, ) = script - // Redis Cluster: all KEYS must be in the same slot - .key(self.redis_hash_tag()) + .key(self.name()) .key(self.delayed_zset_name()) .key(self.pending_list_name()) .key(self.active_hash_name()) @@ -1003,8 +990,7 @@ impl Queue { ); let trimmed_count: usize = trim_script - // Redis Cluster: all KEYS must be in the same slot - .key(self.redis_hash_tag()) + .key(self.name()) .key(self.success_list_name()) .key(self.job_data_hash_name()) .key(self.job_result_hash_name()) // results_hash @@ -1182,8 +1168,7 @@ impl Queue { ); let trimmed_count: usize = trim_script - // Redis Cluster: all KEYS must be in the same slot - .key(self.redis_hash_tag()) + .key(self.name()) .key(self.failed_list_name()) .key(self.job_data_hash_name()) .key(self.dedupe_set_name()) diff --git a/twmq/src/multilane.rs b/twmq/src/multilane.rs index a965e5d..5921e0a 100644 --- a/twmq/src/multilane.rs +++ b/twmq/src/multilane.rs @@ -84,89 +84,59 @@ impl MultilaneQueue { &self.queue_id } - /// Redis Cluster hash tag used to keep all multilane keys in the same slot. - fn redis_hash_tag(&self) -> String { - format!("{{{}}}", self.queue_id()) - } - // Redis key naming methods with proper multilane namespacing pub fn lanes_zset_name(&self) -> String { - format!("twmq_multilane:{}:lanes", self.redis_hash_tag()) + format!("twmq_multilane:{}:lanes", self.queue_id) } pub fn lane_pending_list_name(&self, lane_id: &str) -> String { - format!( - "twmq_multilane:{}:lane:{}:pending", - self.redis_hash_tag(), - lane_id - ) + format!("twmq_multilane:{}:lane:{}:pending", self.queue_id, lane_id) } pub fn lane_delayed_zset_name(&self, lane_id: &str) -> String { - format!( - "twmq_multilane:{}:lane:{}:delayed", - self.redis_hash_tag(), - lane_id - ) + format!("twmq_multilane:{}:lane:{}:delayed", self.queue_id, lane_id) } pub fn lane_active_hash_name(&self, lane_id: &str) -> String { - format!( - "twmq_multilane:{}:lane:{}:active", - self.redis_hash_tag(), - lane_id - ) + format!("twmq_multilane:{}:lane:{}:active", self.queue_id, lane_id) } pub fn success_list_name(&self) -> String { - format!("twmq_multilane:{}:success", self.redis_hash_tag()) + format!("twmq_multilane:{}:success", self.queue_id) } pub fn failed_list_name(&self) -> String { - format!("twmq_multilane:{}:failed", self.redis_hash_tag()) + format!("twmq_multilane:{}:failed", self.queue_id) } pub fn job_data_hash_name(&self) -> String { - format!("twmq_multilane:{}:jobs:data", self.redis_hash_tag()) + format!("twmq_multilane:{}:jobs:data", self.queue_id) } pub fn job_meta_hash_name(&self, job_id: &str) -> String { - format!( - "twmq_multilane:{}:job:{}:meta", - self.redis_hash_tag(), - job_id - ) + format!("twmq_multilane:{}:job:{}:meta", self.queue_id, job_id) } pub fn job_errors_list_name(&self, job_id: &str) -> String { - format!( - "twmq_multilane:{}:job:{}:errors", - self.redis_hash_tag(), - job_id - ) + format!("twmq_multilane:{}:job:{}:errors", self.queue_id, job_id) } pub fn job_result_hash_name(&self) -> String { - format!("twmq_multilane:{}:jobs:result", self.redis_hash_tag()) + format!("twmq_multilane:{}:jobs:result", self.queue_id) } pub fn dedupe_set_name(&self) -> String { - format!("twmq_multilane:{}:dedup", self.redis_hash_tag()) + format!("twmq_multilane:{}:dedup", self.queue_id) } pub fn pending_cancellation_set_name(&self) -> String { - format!( - "twmq_multilane:{}:pending_cancellations", - self.redis_hash_tag() - ) + format!("twmq_multilane:{}:pending_cancellations", self.queue_id) } pub fn lease_key_name(&self, job_id: &str, lease_token: &str) -> String { format!( "twmq_multilane:{}:job:{}:lease:{}", - self.redis_hash_tag(), - job_id, - lease_token + self.queue_id, job_id, lease_token ) } @@ -259,8 +229,7 @@ impl MultilaneQueue { .key(self.job_data_hash_name()) .key(self.job_meta_hash_name(&job.id)) .key(self.dedupe_set_name()) - // Redis Cluster: ensure constructed keys match hash-tagged names - .arg(self.redis_hash_tag()) + .arg(&self.queue_id) .arg(lane_id) .arg(&job_options.id) .arg(job_data) @@ -445,8 +414,7 @@ impl MultilaneQueue { .key(self.pending_cancellation_set_name()) .key(self.job_meta_hash_name(job_id)) .key(self.job_data_hash_name()) - // Redis Cluster: ensure constructed keys match hash-tagged names - .arg(self.redis_hash_tag()) + .arg(&self.queue_id) .arg(job_id) .arg(now) .invoke_async(&mut self.redis.clone()) @@ -792,8 +760,7 @@ impl MultilaneQueue { .key(self.pending_cancellation_set_name()) .key(self.failed_list_name()) .key(self.success_list_name()) - // Redis Cluster: ensure constructed keys match hash-tagged names - .arg(self.redis_hash_tag()) + .arg(&self.queue_id) .arg(now) .arg(batch_size) .arg(self.options.lease_duration.as_secs()) diff --git a/twmq/tests/basic.rs b/twmq/tests/basic.rs index 66eae0b..0c5d2f6 100644 --- a/twmq/tests/basic.rs +++ b/twmq/tests/basic.rs @@ -18,8 +18,7 @@ const REDIS_URL: &str = "redis://127.0.0.1:6379/"; // Helper to clean up Redis keys for a given queue name pattern async fn cleanup_redis_keys(conn_manager: &ConnectionManager, queue_name: &str) { let mut conn = conn_manager.clone(); - // twmq queue keys are hash-tagged for Redis Cluster compatibility - let keys_pattern = format!("twmq:{{{queue_name}}}:*"); + let keys_pattern = format!("twmq:{queue_name}:*"); let keys: Vec = redis::cmd("KEYS") .arg(&keys_pattern) diff --git a/twmq/tests/basic_hook.rs b/twmq/tests/basic_hook.rs index 73435ce..0306ac2 100644 --- a/twmq/tests/basic_hook.rs +++ b/twmq/tests/basic_hook.rs @@ -23,8 +23,7 @@ use twmq::{ // Helper to clean up Redis keys for a given queue name pattern async fn cleanup_redis_keys(conn_manager: &ConnectionManager, queue_name: &str) { let mut conn = conn_manager.clone(); - // twmq queue keys are hash-tagged for Redis Cluster compatibility - let keys_pattern = format!("twmq:{{{queue_name}}}:*"); + let keys_pattern = format!("twmq:{queue_name}:*"); let keys: Vec = redis::cmd("KEYS") .arg(&keys_pattern) diff --git a/twmq/tests/delay.rs b/twmq/tests/delay.rs index 1c74ac1..5245188 100644 --- a/twmq/tests/delay.rs +++ b/twmq/tests/delay.rs @@ -23,8 +23,7 @@ const REDIS_URL: &str = "redis://127.0.0.1:6379/"; // Helper to clean up Redis keys async fn cleanup_redis_keys(conn_manager: &ConnectionManager, queue_name: &str) { let mut conn = conn_manager.clone(); - // twmq queue keys are hash-tagged for Redis Cluster compatibility - let keys_pattern = format!("twmq:{{{queue_name}}}:*"); + let keys_pattern = format!("twmq:{queue_name}:*"); let keys: Vec = redis::cmd("KEYS") .arg(&keys_pattern) .query_async(&mut conn) diff --git a/twmq/tests/idempotency_modes.rs b/twmq/tests/idempotency_modes.rs index 7799e6f..ce1d0f3 100644 --- a/twmq/tests/idempotency_modes.rs +++ b/twmq/tests/idempotency_modes.rs @@ -68,8 +68,7 @@ impl DurableExecution for TestJobHandler { // Helper to clean up Redis keys async fn cleanup_redis_keys(conn_manager: &ConnectionManager, queue_name: &str) { let mut conn = conn_manager.clone(); - // twmq queue keys are hash-tagged for Redis Cluster compatibility - let keys_pattern = format!("twmq:{{{queue_name}}}:*"); + let keys_pattern = format!("twmq:{queue_name}:*"); let keys: Vec = redis::cmd("KEYS") .arg(&keys_pattern) diff --git a/twmq/tests/lease_expiry.rs b/twmq/tests/lease_expiry.rs index 5822c66..773c100 100644 --- a/twmq/tests/lease_expiry.rs +++ b/twmq/tests/lease_expiry.rs @@ -23,8 +23,7 @@ const REDIS_URL: &str = "redis://127.0.0.1:6379/"; // Helper to clean up Redis keys async fn cleanup_redis_keys(conn_manager: &ConnectionManager, queue_name: &str) { let mut conn = conn_manager.clone(); - // twmq queue keys are hash-tagged for Redis Cluster compatibility - let keys_pattern = format!("twmq:{{{queue_name}}}:*"); + let keys_pattern = format!("twmq:{queue_name}:*"); let keys: Vec = redis::cmd("KEYS") .arg(&keys_pattern) .query_async(&mut conn) diff --git a/twmq/tests/multilane_batch_pop.rs b/twmq/tests/multilane_batch_pop.rs index 189ce21..3f8c398 100644 --- a/twmq/tests/multilane_batch_pop.rs +++ b/twmq/tests/multilane_batch_pop.rs @@ -90,8 +90,7 @@ impl MultilaneTestHarness { /// Clean up all Redis keys for this test async fn cleanup(&self) { let mut conn = self.queue.redis.clone(); - // twmq multilane keys are hash-tagged for Redis Cluster compatibility - let keys_pattern = format!("twmq_multilane:{{{}}}:*", self.queue_id); + let keys_pattern = format!("twmq_multilane:{}:*", self.queue_id); let keys: Vec = redis::cmd("KEYS") .arg(&keys_pattern) @@ -166,7 +165,7 @@ impl Drop for MultilaneTestHarness { tokio::spawn(async move { let mut conn = redis; - let keys_pattern = format!("twmq_multilane:{{{queue_id}}}:*"); + let keys_pattern = format!("twmq_multilane:{queue_id}:*"); let keys: Vec = redis::cmd("KEYS") .arg(&keys_pattern) .query_async(&mut conn) diff --git a/twmq/tests/nack.rs b/twmq/tests/nack.rs index 8b0fd39..f66cd9f 100644 --- a/twmq/tests/nack.rs +++ b/twmq/tests/nack.rs @@ -26,8 +26,7 @@ const REDIS_URL: &str = "redis://127.0.0.1:6379/"; // Helper to clean up Redis keys async fn cleanup_redis_keys(conn_manager: &ConnectionManager, queue_name: &str) { let mut conn = conn_manager.clone(); - // twmq queue keys are hash-tagged for Redis Cluster compatibility - let keys_pattern = format!("twmq:{{{queue_name}}}:*"); + let keys_pattern = format!("twmq:{queue_name}:*"); let keys: Vec = redis::cmd("KEYS") .arg(&keys_pattern) .query_async(&mut conn) diff --git a/twmq/tests/prune_race_condition.rs b/twmq/tests/prune_race_condition.rs index 3245cc8..c9898f9 100644 --- a/twmq/tests/prune_race_condition.rs +++ b/twmq/tests/prune_race_condition.rs @@ -148,8 +148,7 @@ impl DurableExecution for EoaSimulatorJobHandler { // Helper to clean up Redis keys async fn cleanup_redis_keys(conn_manager: &ConnectionManager, queue_name: &str) { let mut conn = conn_manager.clone(); - // twmq queue keys are hash-tagged for Redis Cluster compatibility - let keys_pattern = format!("twmq:{{{queue_name}}}:*"); + let keys_pattern = format!("twmq:{queue_name}:*"); let keys: Vec = redis::cmd("KEYS") .arg(&keys_pattern) diff --git a/twmq/tests/prune_race_random_ids.rs b/twmq/tests/prune_race_random_ids.rs index b09ad89..fd5e9ea 100644 --- a/twmq/tests/prune_race_random_ids.rs +++ b/twmq/tests/prune_race_random_ids.rs @@ -123,8 +123,7 @@ impl DurableExecution for RandomJobHandler { // Helper to clean up Redis keys async fn cleanup_redis_keys(conn_manager: &ConnectionManager, queue_name: &str) { let mut conn = conn_manager.clone(); - // twmq queue keys are hash-tagged for Redis Cluster compatibility - let keys_pattern = format!("twmq:{{{queue_name}}}:*"); + let keys_pattern = format!("twmq:{queue_name}:*"); let keys: Vec = redis::cmd("KEYS") .arg(&keys_pattern) @@ -240,7 +239,7 @@ async fn test_prune_with_random_ids() { let success_job_ids: Vec = conn.lrange(queue.success_list_name(), 0, -1).await.unwrap(); // Count how many job metadata hashes still exist (should match success list length if pruning works) - let meta_pattern = format!("twmq:{{{}}}:job:*:meta", queue.name()); + let meta_pattern = format!("twmq:{}:job:*:meta", queue.name()); let meta_keys: Vec = redis::cmd("KEYS") .arg(&meta_pattern) .query_async(&mut conn)