Struct RedisCache 

pub struct RedisCache { /* private fields */ }

Redis cache implementation with connection pooling

This struct wraps a Redis ConnectionManager and provides cache operations with automatic key prefixing for namespace isolation.

Connection Management

Uses ConnectionManager which provides:

• Automatic reconnection on connection loss
• Connection health checks
• Async operation support
• Internal connection pooling

Key Prefixing

All keys are automatically prefixed to avoid collisions:

• User provides: "user:123"
• Stored as: "warpdrive:cache:user:123" (if prefix is "warpdrive:cache:")

Implementations

impl RedisCache

pub async fn from_url(url: &str, prefix: String) -> Result<Self>

Create a new Redis cache from connection URL

Parameters

• url: Redis connection URL (e.g., "redis://localhost:6379")
• prefix: Key prefix for namespace isolation (e.g., "warpdrive:cache:")

Errors

Returns an error if:

• URL is invalid
• Cannot connect to Redis server
• Authentication fails

Example

let cache = RedisCache::from_url(
    "redis://localhost:6379/0",
    "myapp:".to_string()
).await?;

pub async fn batch_get(&self, keys: &[String]) -> Result<Vec<Option<Vec<u8>>>>

Batch get multiple keys

Retrieves multiple values in a single round trip using Redis pipelining. This is significantly more efficient than multiple individual GET operations.

Returns

A vector of Option<Vec<u8>> corresponding to the input keys. None indicates the key was not found or expired.

Example

let keys = vec!["user:1".to_string(), "user:2".to_string()];
let values = cache.batch_get(&keys).await?;

for (key, value) in keys.iter().zip(values.iter()) {
    match value {
        Some(data) => println!("{}: {} bytes", key, data.len()),
        None => println!("{}: not found", key),
    }
}

pub async fn batch_delete(&self, keys: &[String]) -> Result<()>

Batch delete multiple keys

Deletes multiple keys in a single round trip using Redis DEL. Returns Ok(()) regardless of whether keys existed.

Example

let keys = vec!["user:1".to_string(), "user:2".to_string()];
cache.batch_delete(&keys).await?;

pub async fn clear_prefix(&self, pattern: &str) -> Result<usize>

Clear all keys matching a pattern

Deletes all keys matching the given pattern (after prefixing). Uses SCAN + DEL for safe iteration without blocking Redis.

Warning

This operation scans the entire keyspace and can be slow on large datasets. Use sparingly and consider the impact on Redis performance.

Parameters

• pattern: Glob-style pattern (e.g., "user:*", "session:*")

Returns

The number of keys deleted.

Example

// Delete all user cache entries
let count = cache.clear_prefix("user:*").await?;
println!("Cleared {} user entries", count);

pub fn connection(&self) -> ConnectionManager

Get connection manager for advanced operations

Provides access to the underlying ConnectionManager for operations not covered by the Cache trait (e.g., INCR, ZADD, etc.).

Example

let mut conn = cache.connection();
let count: i64 = conn.incr("page_views", 1).await?;

Trait Implementations

impl Cache for RedisCache

fn get<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<u8>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Retrieve a value from cache by key

fn set<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, key: &'life1 str, value: &'life2 [u8], ttl_seconds: u64, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Store a value in cache with TTL

fn delete<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Delete a value from cache

fn exists<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Check if a key exists in cache

impl Clone for RedisCache

fn clone(&self) -> RedisCache

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.