feature(session): add deadpool-redis compatibility

actix-session/CHANGES.md

@@ -12,8 +12,12 @@
 ## 0.9.0
 
 - Remove use of `async-trait` on `SessionStore` trait.
+- Add `deadpool-redis` dependency; Implement `deadpool_redis::Pool` for `RedisSessionStore`. [#381]
+- Update `actix-redis` dependency to `0.13`.
 - Minimum supported Rust version (MSRV) is now 1.75.
 
+[#381]: https://github.com/actix/actix-extras/pull/381
+
 ## 0.8.0
 
 - Set secure attribute when adding a session removal cookie.

actix-session/Cargo.toml

@@ -23,6 +23,7 @@ cookie-session = []
 redis-session = ["dep:redis", "dep:rand"]
 redis-session-native-tls = ["redis-session", "redis/tokio-native-tls-comp"]
 redis-session-rustls = ["redis-session", "redis/tokio-rustls-comp"]
+redis-dp-session = ["dep:deadpool-redis", "dep:rand"]
 
 [dependencies]
 actix-service = "2"
@@ -39,6 +40,9 @@ tracing = { version = "0.1.30", default-features = false, features = ["log"] }
 # redis-session
 redis = { version = "0.26", default-features = false, features = ["tokio-comp", "connection-manager"], optional = true }
 
+# redis-dp-session
+deadpool-redis = { version = "0.14", optional = true }
+
 [dev-dependencies]
 actix-session = { path = ".", features = ["cookie-session", "redis-session"] }
 actix-test = "0.1.0-beta.10"

actix-session/src/storage/mod.rs

@@ -3,17 +3,17 @@
 #[cfg(feature = "cookie-session")]
 mod cookie;
 mod interface;
-#[cfg(feature = "redis-session")]
+#[cfg(any(feature = "redis-session", feature = "redis-dp-session"))]
 mod redis_rs;
 mod session_key;
-#[cfg(feature = "redis-session")]
+#[cfg(any(feature = "redis-session", feature = "redis-dp-session"))]
 mod utils;
 
 #[cfg(feature = "cookie-session")]
 pub use self::cookie::CookieSessionStore;
-#[cfg(feature = "redis-session")]
+#[cfg(any(feature = "redis-session", feature = "redis-dp-session"))]
 pub use self::redis_rs::{RedisSessionStore, RedisSessionStoreBuilder};
-#[cfg(feature = "redis-session")]
+#[cfg(any(feature = "redis-session", feature = "redis-dp-session"))]
 pub use self::utils::generate_session_key;
 pub use self::{
     interface::{LoadError, SaveError, SessionStore, UpdateError},

actix-session/src/storage/redis_rs.rs

@@ -2,7 +2,11 @@ use std::sync::Arc;
 
 use actix_web::cookie::time::Duration;
 use anyhow::Error;
-use redis::{aio::ConnectionManager, AsyncCommands, Cmd, FromRedisValue, RedisResult, Value};
+#[cfg(not(feature = "redis-session"))]
+use deadpool_redis::{redis, Pool};
+#[cfg(feature = "redis-session")]
+use redis::aio::ConnectionManager;
+use redis::{AsyncCommands, Cmd, FromRedisValue, RedisResult, Value};
 
 use super::SessionKey;
 use crate::storage::{
@@ -56,14 +60,28 @@ use crate::storage::{
 /// # })
 /// ```
 ///
+/// # Deadpool Redis
+///
+/// ```ignore
+/// use actix_session::storage::RedisSessionStore;
+/// use deadpool_redis::{Config, Runtime};
+///
+/// let redis_cfg = Config::from_url("redis://127.0.0.1:6379");
+/// let redis_pool = redis_cfg.create_pool(Some(Runtime::Tokio1)).unwrap();
+/// let store = RedisSessionStore::new(redis_pool.clone());
+/// ```
+///
 /// # Implementation notes
 /// `RedisSessionStore` leverages [`redis-rs`] as Redis client.
 ///
 /// [`redis-rs`]: https://github.com/mitsuhiko/redis-rs
 #[derive(Clone)]
 pub struct RedisSessionStore {
     configuration: CacheConfiguration,
+    #[cfg(feature = "redis-session")]
     client: ConnectionManager,
+    #[cfg(not(feature = "redis-session"))]
+    pool: Pool,
 }
 
 #[derive(Clone)]
@@ -83,31 +101,53 @@ impl RedisSessionStore {
     /// A fluent API to configure [`RedisSessionStore`].
     /// It takes as input the only required input to create a new instance of [`RedisSessionStore`] - a
     /// connection string for Redis.
+    #[cfg(feature = "redis-session")]
     pub fn builder<S: Into<String>>(connection_string: S) -> RedisSessionStoreBuilder {
         RedisSessionStoreBuilder {
             configuration: CacheConfiguration::default(),
             connection_string: connection_string.into(),
         }
     }
 
+    /// A fluent API to configure [`RedisSessionStore`].
+    /// It takes as input the only required input to create a new instance of [`RedisSessionStore`] - a
+    /// pool object for Redis.
+    #[cfg(not(feature = "redis-session"))]
+    pub fn builder<P: Into<Pool>>(pool: P) -> RedisSessionStoreBuilder {
+        RedisSessionStoreBuilder {
+            configuration: CacheConfiguration::default(),
+            pool: pool.into(),
+        }
+    }
+
     /// Create a new instance of [`RedisSessionStore`] using the default configuration.
     /// It takes as input the only required input to create a new instance of [`RedisSessionStore`] - a
     /// connection string for Redis.
-    pub async fn new<S: Into<String>>(
-        connection_string: S,
-    ) -> Result<RedisSessionStore, anyhow::Error> {
+    #[cfg(feature = "redis-session")]
+    pub async fn new<S: Into<String>>(connection_string: S) -> Result<RedisSessionStore, Error> {
         Self::builder(connection_string).build().await
     }
+
+    /// Create a new instance of [`RedisSessionStore`] using the default configuration.
+    /// It takes as input the only required input to create a new instance of [`RedisSessionStore`] - a
+    /// pool object for Redis.
+    #[cfg(not(feature = "redis-session"))]
+    pub fn new<P: Into<Pool>>(pool: P) -> RedisSessionStore {
+        Self::builder(pool).build()
+    }
 }
 
 /// A fluent builder to construct a [`RedisSessionStore`] instance with custom configuration
 /// parameters.
 ///
-/// [`RedisSessionStore`]: crate::storage::RedisSessionStore
+/// [`RedisSessionStore`]: RedisSessionStore
 #[must_use]
 pub struct RedisSessionStoreBuilder {
-    connection_string: String,
     configuration: CacheConfiguration,
+    #[cfg(feature = "redis-session")]
+    connection_string: String,
+    #[cfg(not(feature = "redis-session"))]
+    pool: Pool,
 }
 
 impl RedisSessionStoreBuilder {
@@ -121,13 +161,27 @@ impl RedisSessionStoreBuilder {
     }
 
     /// Finalise the builder and return a [`RedisSessionStore`] instance.
-    pub async fn build(self) -> Result<RedisSessionStore, anyhow::Error> {
+    ///
+    /// [`RedisSessionStore`]: RedisSessionStore
+    #[cfg(feature = "redis-session")]
+    pub async fn build(self) -> Result<RedisSessionStore, Error> {
         let client = ConnectionManager::new(redis::Client::open(self.connection_string)?).await?;
         Ok(RedisSessionStore {
             configuration: self.configuration,
             client,
         })
     }
+
+    /// Finalise the builder and return a [`RedisSessionStore`] instance.
+    ///
+    /// [`RedisSessionStore`]: RedisSessionStore
+    #[cfg(not(feature = "redis-session"))]
+    pub fn build(self) -> RedisSessionStore {
+        RedisSessionStore {
+            configuration: self.configuration,
+            pool: self.pool,
+        }
+    }
 }
 
 impl SessionStore for RedisSessionStore {
@@ -190,7 +244,7 @@ impl SessionStore for RedisSessionStore {
 
         let cache_key = (self.configuration.cache_keygen)(session_key.as_ref());
 
-        let v: redis::Value = self
+        let v: Value = self
             .execute_command(redis::cmd("SET").arg(&[
                 &cache_key,
                 &body,
@@ -226,15 +280,23 @@ impl SessionStore for RedisSessionStore {
     async fn update_ttl(&self, session_key: &SessionKey, ttl: &Duration) -> Result<(), Error> {
         let cache_key = (self.configuration.cache_keygen)(session_key.as_ref());
 
+        #[cfg(feature = "redis-session")]
         self.client
             .clone()
             .expire::<_, ()>(&cache_key, ttl.whole_seconds())
             .await?;
 
+        #[cfg(not(feature = "redis-session"))]
+        self.pool
+            .get()
+            .await?
+            .expire(&cache_key, ttl.whole_seconds())
+            .await?;
+
         Ok(())
     }
 
-    async fn delete(&self, session_key: &SessionKey) -> Result<(), anyhow::Error> {
+    async fn delete(&self, session_key: &SessionKey) -> Result<(), Error> {
         let cache_key = (self.configuration.cache_keygen)(session_key.as_ref());
 
         self.execute_command::<()>(redis::cmd("DEL").arg(&[&cache_key]))
@@ -264,8 +326,14 @@ impl RedisSessionStore {
     async fn execute_command<T: FromRedisValue>(&self, cmd: &mut Cmd) -> RedisResult<T> {
         let mut can_retry = true;
 
+        #[cfg(feature = "redis-session")]
+        let client = &mut self.client.clone();
+
+        #[cfg(not(feature = "redis-session"))]
+        let client = &mut self.pool.get().await.unwrap();
+
         loop {
-            match cmd.query_async(&mut self.client.clone()).await {
+            match cmd.query_async(client).await {
                 Ok(value) => return Ok(value),
                 Err(err) => {
                     if can_retry && err.is_connection_dropped() {
@@ -291,14 +359,27 @@ mod tests {
     use std::collections::HashMap;
 
     use actix_web::cookie::time;
+    #[cfg(not(feature = "redis-session"))]
+    use deadpool_redis::{Config, Runtime};
 
     use super::*;
     use crate::test_helpers::acceptance_test_suite;
 
     async fn redis_store() -> RedisSessionStore {
-        RedisSessionStore::new("redis://127.0.0.1:6379")
-            .await
-            .unwrap()
+        #[cfg(feature = "redis-session")]
+        {
+            RedisSessionStore::new("redis://127.0.0.1:6379")
+                .await
+                .unwrap()
+        }
+
+        #[cfg(not(feature = "redis-session"))]
+        {
+            let redis_pool = Config::from_url("redis://127.0.0.1:6379")
+                .create_pool(Some(Runtime::Tokio1))
+                .unwrap();
+            RedisSessionStore::new(redis_pool.clone())
+        }
     }
 
     #[actix_web::test]
@@ -318,12 +399,25 @@ mod tests {
     async fn loading_an_invalid_session_state_returns_deserialization_error() {
         let store = redis_store().await;
         let session_key = generate_session_key();
+
+        #[cfg(feature = "redis-session")]
         store
             .client
             .clone()
             .set::<_, _, ()>(session_key.as_ref(), "random-thing-which-is-not-json")
             .await
             .unwrap();
+
+        #[cfg(not(feature = "redis-session"))]
+        store
+            .pool
+            .get()
+            .await
+            .unwrap()
+            .set::<_, _, ()>(session_key.as_ref(), "random-thing-which-is-not-json")
+            .await
+            .unwrap();
+
         assert!(matches!(
             store.load(&session_key).await.unwrap_err(),
             LoadError::Deserialization(_),