Remove rediscluster cache backend

Note: Also fixed some of the queue tests, which should match
based on the _queue_ configuration, not the cache config.

Author: jaymell

server/svix-server/src/cfg.rs

@@ -193,7 +193,7 @@ pub struct ConfigurationInner {
 fn validate_config_complete(config: &ConfigurationInner) -> Result<(), ValidationError> {
     match config.cache_type {
         CacheType::None | CacheType::Memory => {}
-        CacheType::Redis | CacheType::RedisCluster | CacheType::RedisClusterUnpooled => {
+        CacheType::Redis | CacheType::RedisClusterUnpooled => {
             if config.cache_dsn().is_none() {
                 return Err(ValidationError {
                     code: Cow::from("missing field"),
@@ -266,7 +266,6 @@ impl ConfigurationInner {
             CacheType::None => CacheBackend::None,
             CacheType::Memory => CacheBackend::Memory,
             CacheType::Redis => CacheBackend::Redis(self.cache_dsn().expect(err)),
-            CacheType::RedisCluster => CacheBackend::RedisCluster(self.cache_dsn().expect(err)),
             CacheType::RedisClusterUnpooled => {
                 CacheBackend::RedisClusterUnpooled(self.cache_dsn().expect(err))
             }
@@ -306,7 +305,6 @@ pub enum CacheBackend<'a> {
     None,
     Memory,
     Redis(&'a str),
-    RedisCluster(&'a str),
     RedisClusterUnpooled(&'a str),
 }
 
@@ -339,7 +337,6 @@ pub enum QueueType {
 pub enum CacheType {
     Memory,
     Redis,
-    RedisCluster,
     RedisClusterUnpooled,
     None,
 }

server/svix-server/src/core/cache/redis.rs

@@ -114,7 +114,6 @@ mod tests {
 
     async fn get_pool(redis_dsn: &str, cfg: &crate::cfg::Configuration) -> RedisPool {
         match cfg.cache_type {
-            CacheType::RedisCluster => crate::redis::new_redis_pool_clustered(redis_dsn, cfg).await,
             CacheType::RedisClusterUnpooled => {
                 crate::redis::new_redis_clustered_unpooled(redis_dsn).await
             }

server/svix-server/src/lib.rs

@@ -113,10 +113,6 @@ pub async fn run_with_prefix(
             let mgr = crate::redis::new_redis_pool(dsn, &cfg).await;
             cache::redis::new(mgr)
         }
-        CacheBackend::RedisCluster(dsn) => {
-            let mgr = crate::redis::new_redis_pool_clustered(dsn, &cfg).await;
-            cache::redis::new(mgr)
-        }
         CacheBackend::RedisClusterUnpooled(dsn) => {
             let mgr = crate::redis::new_redis_clustered_unpooled(dsn).await;
             cache::redis::new(mgr)

server/svix-server/src/queue/redis.rs

@@ -355,23 +355,20 @@ pub mod tests {
 
     use super::{migrate_list, migrate_list_to_stream, migrate_sset, new_pair_inner};
     use crate::{
-        cfg::{CacheType, Configuration},
+        cfg::{Configuration, QueueType},
         core::types::{ApplicationId, EndpointId, MessageAttemptTriggerType, MessageId},
         queue::{MessageTask, QueueTask, TaskQueueConsumer, TaskQueueProducer},
         redis::RedisPool,
     };
 
     async fn get_pool(cfg: &Configuration) -> RedisPool {
-        match cfg.cache_type {
-            CacheType::RedisCluster => {
+        match cfg.queue_type {
+            QueueType::RedisCluster => {
                 crate::redis::new_redis_pool_clustered(cfg.redis_dsn.as_deref().unwrap(), cfg).await
             }
-            CacheType::Redis => {
+            QueueType::Redis => {
                 crate::redis::new_redis_pool(cfg.redis_dsn.as_deref().unwrap(), cfg).await
             }
-            CacheType::RedisClusterUnpooled => {
-                crate::redis::new_redis_clustered_unpooled(cfg.redis_dsn.as_deref().unwrap()).await
-            }
             _ => {
                 panic!("This test should only be run when redis is configured as the queue backend")
             }

server/svix-server/src/redis/mod.rs

@@ -245,7 +245,6 @@ mod tests {
 
     async fn get_pool(redis_dsn: &str, cfg: &Configuration) -> RedisPool {
         match cfg.cache_type {
-            CacheType::RedisCluster => super::new_redis_pool_clustered(redis_dsn, cfg).await,
             CacheType::RedisClusterUnpooled => super::new_redis_clustered_unpooled(redis_dsn).await,
             CacheType::Redis => super::new_redis_pool(redis_dsn, cfg).await,
             _ => panic!(

server/svix-server/tests/it/message_app.rs

@@ -12,7 +12,7 @@ use svix_server::{
         message_app::AppEndpointKey,
         types::{BaseId, OrganizationId},
     },
-    redis::{new_redis_clustered_unpooled, new_redis_pool, new_redis_pool_clustered},
+    redis::{new_redis_clustered_unpooled, new_redis_pool},
 };
 
 use crate::utils::{
@@ -69,10 +69,6 @@ async fn test_app_deletion() {
             let mgr = new_redis_pool(dsn, &cfg).await;
             cache::redis::new(mgr)
         }
-        CacheBackend::RedisCluster(dsn) => {
-            let mgr = new_redis_pool_clustered(dsn, &cfg).await;
-            cache::redis::new(mgr)
-        }
         CacheBackend::RedisClusterUnpooled(dsn) => {
             let mgr = new_redis_clustered_unpooled(dsn).await;
             cache::redis::new(mgr)
@@ -157,10 +153,6 @@ async fn test_endp_deletion() {
             let mgr = new_redis_pool(dsn, &cfg).await;
             cache::redis::new(mgr)
         }
-        CacheBackend::RedisCluster(dsn) => {
-            let mgr = new_redis_pool_clustered(dsn, &cfg).await;
-            cache::redis::new(mgr)
-        }
         CacheBackend::RedisClusterUnpooled(dsn) => {
             let mgr = new_redis_clustered_unpooled(dsn).await;
             cache::redis::new(mgr)

server/svix-server/tests/it/redis_queue.rs

@@ -8,25 +8,24 @@ use std::{str::FromStr, time::Duration};
 
 use redis::AsyncCommands as _;
 use svix_server::{
-    cfg::{CacheType, Configuration},
+    cfg::{Configuration, QueueType},
     core::types::{ApplicationId, EndpointId, MessageAttemptTriggerType, MessageId},
     queue::{
         new_pair, MessageTask, QueueTask, TaskQueueConsumer, TaskQueueDelivery, TaskQueueProducer,
     },
-    redis::{new_redis_clustered_unpooled, new_redis_pool, new_redis_pool_clustered, RedisPool},
+    redis::{new_redis_pool, new_redis_pool_clustered, RedisPool},
 };
 
 // TODO: Don't copy this from the Redis queue test directly, place the fn somewhere both can access
-pub async fn get_pool(cfg: Configuration) -> RedisPool {
-    match cfg.cache_type {
-        CacheType::RedisCluster => {
-            new_redis_pool_clustered(cfg.redis_dsn.as_ref().unwrap().as_str(), &cfg).await
+async fn get_pool(cfg: &Configuration) -> RedisPool {
+    match cfg.queue_type {
+        QueueType::RedisCluster => {
+            new_redis_pool_clustered(cfg.redis_dsn.as_deref().unwrap(), cfg).await
         }
-        CacheType::RedisClusterUnpooled => {
-            new_redis_clustered_unpooled(cfg.redis_dsn.as_ref().unwrap().as_str()).await
+        QueueType::Redis => new_redis_pool(cfg.redis_dsn.as_deref().unwrap(), cfg).await,
+        _ => {
+            panic!("This test should only be run when redis is configured as the queue backend")
         }
-        CacheType::Redis => new_redis_pool(cfg.redis_dsn.as_ref().unwrap().as_str(), &cfg).await,
-        _ => panic!("This test should only be run when redis is configured as the cache provider"),
     }
 }
 
@@ -44,7 +43,7 @@ async fn test_many_queue_consumers_inner(prefix: &str, delay: Option<Duration>)
 
     // This test assumes an empty queue, so load Redis and delete the test key
     {
-        let pool = get_pool(cfg.clone()).await;
+        let pool = get_pool(&cfg).await;
         let mut conn = pool.get().await.unwrap();
 
         let _: () = conn