Struct RedisCache 

pub struct RedisCache { /* private fields */ }

Redis cache store.

Implementations

impl RedisCache

pub async fn new(config: CacheConfig) -> CacheResult<Self>

Create a new Redis cache instance.

Arguments

• config - Cache configuration

Examples

use armature_cache::*;

#[tokio::main]
async fn main() -> Result<(), CacheError> {
    let config = CacheConfig::redis("redis://localhost:6379")?;
    let cache = RedisCache::new(config).await?;
    Ok(())
}

pub fn connection(&self) -> &ConnectionManager

Get the underlying connection manager.

Trait Implementations

impl CacheStore for RedisCache

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

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

Plain SET with no expiry, skipping the default_ttl fallback that set_json applies to a None TTL. See CacheStore::set_json_forever.

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

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

Clear this cache’s keys.

When key_prefix is configured, this is scoped to that prefix: it SCANs for every key matching {key_prefix}:* and removes them with batched UNLINK calls, so it only wipes keys this cache actually wrote — not the whole Redis database/instance. SCAN is cursor-based and non-blocking (unlike KEYS, which is O(N) and stalls the single-threaded server for the entire keyspace); UNLINK reclaims memory off the main thread instead of blocking on DEL.

When no key_prefix is configured, this cache has no distinct slice of the keyspace to scope to, so it falls back to the previous unscoped FLUSHDB behavior — this remains destructive to the entire Redis database/instance, so an unprefixed RedisCache sharing a Redis instance with other services/tenants should not call clear().

fn mget<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, keys: &'life1 [&'life2 str], ) -> Pin<Box<dyn Future<Output = CacheResult<Vec<Option<String>>>> + Send + 'async_trait>>

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

Native multi-get: a single MGET round-trip instead of N GETs.

MGET preserves argument order, so the returned vector matches keys element-for-element, with None for missing keys.

fn mset<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, items: &'life1 [(&'life2 str, String)], ttl: Option<Duration>, ) -> Pin<Box<dyn Future<Output = CacheResult<()>> + Send + 'async_trait>>

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

Native multi-set in a single round-trip.

Without a TTL this is a plain MSET. MSET cannot express per-key expiry, so when a TTL applies we pipeline SET ... EX commands (still one round-trip), preserving the exact per-key TTL semantics of set_json (including the default_ttl fallback).

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

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

Native multi-delete: a single variadic DEL round-trip instead of N.

fn supports_atomic_sets(&self) -> bool

RedisCache backs set_add/set_remove/set_members with native SADD/SREM/SMEMBERS, which are atomic — see CacheStore::supports_atomic_sets.

fn set_add<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, set_key: &'life1 str, member: &'life2 str, ) -> Pin<Box<dyn Future<Output = CacheResult<()>> + Send + 'async_trait>>

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

Native SADD: atomically adds member to a Redis Set, unlike the trait default’s non-atomic get/modify/set. This is what makes crate::invalidation::TaggedCache’s tag index safe to update concurrently from multiple instances sharing this backend.

fn set_remove<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, set_key: &'life1 str, member: &'life2 str, ) -> Pin<Box<dyn Future<Output = CacheResult<()>> + Send + 'async_trait>>

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

Native SREM: atomically removes member from a Redis Set.

fn set_add_many<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, set_key: &'life1 str, members: &'life2 [&'life3 str], ) -> Pin<Box<dyn Future<Output = CacheResult<()>> + Send + 'async_trait>>

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

Variadic SADD key m1 m2 ...: one round-trip for the whole batch rather than one per member.

fn set_remove_many<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, set_key: &'life1 str, members: &'life2 [&'life3 str], ) -> Pin<Box<dyn Future<Output = CacheResult<()>> + Send + 'async_trait>>

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

Variadic SREM key m1 m2 ...: one round-trip for the whole batch.

fn set_members<'life0, 'life1, 'async_trait>( &'life0 self, set_key: &'life1 str, ) -> Pin<Box<dyn Future<Output = CacheResult<Vec<String>>> + Send + 'async_trait>>

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

Native SMEMBERS.

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

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

Get a JSON value from the cache.

fn set_json<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 str, value: String, ttl: Option<Duration>, ) -> Pin<Box<dyn Future<Output = CacheResult<()>> + Send + 'async_trait>>

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

Set a JSON value in the cache.

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

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

Delete a key from the cache.

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

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

Check if a key exists in the cache.

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

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

Get the TTL (time-to-live) of a key.

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

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

Set or update the expiration time for a key.

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

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

Increment a numeric value.

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

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

Decrement a numeric value.

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

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

Get multiple keys in parallel.

fn set_many<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, items: &'life1 [(&'life2 str, String)], ttl: Option<Duration>, ) -> Pin<Box<dyn Future<Output = CacheResult<()>> + Send + 'async_trait>>

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

Set multiple key-value pairs in parallel.

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

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

Delete multiple keys in parallel.

fn exists_many<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, keys: &'life1 [&'life2 str], ) -> Pin<Box<dyn Future<Output = CacheResult<Vec<bool>>> + Send + 'async_trait>>

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

Check existence of multiple keys in parallel.

fn ttl_many<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, keys: &'life1 [&'life2 str], ) -> Pin<Box<dyn Future<Output = CacheResult<Vec<Option<Duration>>>> + Send + 'async_trait>>

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

Get TTL for multiple keys in parallel.

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.