Struct RedisCache 

pub struct RedisCache { /* private fields */ }

Available on crate feature cache and crate feature redis-backend and non-WebAssembly only.

Redis cache backend with connection pooling

Stores cached values in Redis for distributed caching. Uses deadpool-redis for efficient connection management.

Implementations

impl RedisCache

pub async fn new(connection_url: impl Into<String>) -> Result<RedisCache, Error>

Create a new Redis cache with the given connection URL

Uses default pool configuration (max_size: 16, timeouts: 5s). For custom pool configuration, use with_pool_config().

Examples

use reinhardt_utils::cache::RedisCache;

let cache = RedisCache::new("redis://localhost:6379").await?;
// Redis cache with connection pooling is now ready

pub fn with_pool_config(config: Config) -> Result<RedisCache, Error>

Create a new Redis cache with custom pool configuration

Examples

use reinhardt_utils::cache::RedisCache;
use deadpool_redis::{Config, Runtime};

let mut config = Config::from_url("redis://localhost:6379");
config.pool = Some(deadpool_redis::PoolConfig::new(32)); // 32 connections

let cache = RedisCache::with_pool_config(config)?;

pub fn pool(&self) -> &Pool<Manager, Connection>

Get the connection pool

pub fn with_default_ttl(self, ttl: Duration) -> RedisCache

Set default TTL for all cache entries

Examples

use reinhardt_utils::cache::RedisCache;
use std::time::Duration;

let cache = RedisCache::new("redis://localhost:6379")
    .await?
    .with_default_ttl(Duration::from_secs(300));
// All cache entries will expire after 300 seconds by default

pub fn with_key_prefix(self, prefix: impl Into<String>) -> RedisCache

Set key prefix for namespacing cache entries

Examples

use reinhardt_utils::cache::RedisCache;

let cache = RedisCache::new("redis://localhost:6379")
    .await?
    .with_key_prefix("myapp");
// All keys will be prefixed with "myapp:"

Trait Implementations

impl Cache for RedisCache

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

where 'life0: 'async_trait, 'life1: 'async_trait, T: for<'de> Deserialize<'de> + Send + 'async_trait, RedisCache: 'async_trait,

Get a value from the cache

fn set<'life0, 'life1, 'life2, 'async_trait, T>( &'life0 self, key: &'life1 str, value: &'life2 T, ttl: Option<Duration>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, T: Serialize + Send + Sync + 'async_trait, RedisCache: 'async_trait,

Set a value in the cache with optional TTL

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

where 'life0: 'async_trait, 'life1: 'async_trait, RedisCache: 'async_trait,

Delete a value from the cache

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

where 'life0: 'async_trait, 'life1: 'async_trait, RedisCache: 'async_trait,

Check if a key exists in the cache

fn clear<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, RedisCache: 'async_trait,

Clear all values from the cache

fn get_many<'life0, 'life1, 'life2, 'async_trait, T>( &'life0 self, keys: &'life1 [&'life2 str], ) -> Pin<Box<dyn Future<Output = Result<HashMap<String, T>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, T: for<'de> Deserialize<'de> + Send + 'async_trait, RedisCache: 'async_trait,

Get multiple values at once

fn set_many<'life0, 'async_trait, T>( &'life0 self, values: HashMap<String, T>, ttl: Option<Duration>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, T: Serialize + Send + Sync + 'async_trait, RedisCache: 'async_trait,

Set multiple values at once

fn delete_many<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, keys: &'life1 [&'life2 str], ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

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

Delete multiple keys at once

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

where 'life0: 'async_trait, 'life1: 'async_trait, RedisCache: 'async_trait,

Increment a numeric value

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

where 'life0: 'async_trait, 'life1: 'async_trait, RedisCache: 'async_trait,

Decrement a numeric value

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.