Struct RedisCache 

pub struct RedisCache { /* private fields */ }

A Cache implementation backed by Redis.

Values are stored as JSON blobs. Multiple replicas share the same Redis namespace so writes on replica A are immediately visible on replica B, and invalidations propagate within a single round-trip.

Use autumn_web::cache::insert_cached and autumn_web::cache::get_cached (or equivalently the #[cached] macro) to store and retrieve values — both functions handle JSON serialization transparently. The plain autumn_web::cache::insert / get functions perform only in-memory downcasts and will miss on cross-replica reads. CacheResponseLayer is safe to use because it stores response entries through the serialized path.

Runtime requirement

The sync Cache methods bridge to async Redis calls with tokio::task::block_in_place. They need a multi-thread Tokio runtime, and panic on a current-thread runtime (for example the default #[tokio::test] flavor).

Cache::invalidate_async and Cache::invalidate_namespace_async are real async calls. They work on any runtime and do not hold a worker. Framework invalidation (generated repositories, coherence::invalidate_namespace_async) uses them.

Invalidation errors

Invalidation retries with InvalidationRetry. The async methods return the final error. The sync invalidate and clear cannot return it, so they log it with warn! and count it in autumn_cache_invalidation_failures_total.

Implementations

impl RedisCache

pub async fn connect( url: &str, key_prefix: impl Into<String>, ) -> Result<Self, RedisCacheError>

Connect using an explicit URL and key prefix.

Errors

Returns RedisCacheError::Connection if the initial connection fails.

pub async fn from_config( config: &CacheRedisConfig, ) -> Result<Self, RedisCacheError>

Build a RedisCache from the [cache] section of autumn.toml.

Errors

Returns RedisCacheError::MissingUrl if cache.redis.url is absent. Returns RedisCacheError::Connection on connection failure.

pub const fn with_invalidation_retry(self, retry: InvalidationRetry) -> Self

Set the retry policy for invalidation. See InvalidationRetry.

Trait Implementations

impl Cache for RedisCache

fn get_value(&self, key: &str) -> Option<Arc<dyn Any + Send + Sync>>

Retrieves a value from Redis and returns it as RawCacheBytes.

Callers using autumn_web::cache::get_cached (which the #[cached] macro generates) will have the bytes automatically deserialized into the concrete return type V via serde_json. Direct callers that need the concrete type should also use get_cached rather than get_value.

fn insert_value(&self, key: &str, value: Arc<dyn Any + Send + Sync>)

Stores a value in Redis by serializing the most common primitive types.

For arbitrary serde types — including structs and collections — use insert_raw_bytes (called automatically by autumn_web::cache::insert_cached) instead. Unknown types are silently skipped here because autumn_web::cache::insert_cached will have already written the serialized form via insert_raw_bytes.

fn insert_raw_bytes(&self, key: &str, bytes: Vec<u8>, ttl: Option<Duration>)

Stores pre-serialized JSON bytes in Redis, applying the TTL when provided.

This is the primary write path for #[cached]-annotated functions (via autumn_web::cache::insert_cached). It handles all serde::Serialize types, including structs and collections that insert_value cannot serialize from an erased Arc<dyn Any>.

When ttl is Some, the entry is stored with millisecond precision so Redis expires it automatically, matching the TTL declared on #[cached].

fn try_get_value( &self, key: &str, ) -> Result<Option<Arc<dyn Any + Send + Sync>>, CacheBackendError>

As Cache::get_value, but a Redis error is an error, not a miss.

fn try_insert_raw_bytes( &self, key: &str, bytes: Vec<u8>, ttl: Option<Duration>, ) -> Result<(), CacheBackendError>

As Cache::insert_raw_bytes, but a failed write is an error.

fn try_invalidate(&self, key: &str) -> Result<(), InvalidationError>

As Cache::invalidate, but the final error is returned. It is not added to the invalidation failure counter. A reserved key is refused. Like invalidate, this needs a multi-thread runtime.

fn shares_fill_epoch(&self) -> bool

RedisCache keeps a shared fill epoch per namespace.

fn fill_epoch(&self, namespace: &str) -> FillEpoch

Reads the namespace’s shared epoch (one GET). A missing key is 0. A Redis error is FillEpoch::Unavailable, so the fill skips its insert.

fn insert_raw_bytes_if_epoch( &self, key: &str, bytes: Vec<u8>, ttl: Option<Duration>, namespace: &str, sampled: u64, ) -> bool

Stores the bytes through one Lua call that compares the epoch first. An error counts as not stored: the cost is one extra miss.

fn invalidate(&self, key: &str)

Sync DEL with retries. The final error is logged with warn! and counted, because this method cannot return it. Prefer Cache::invalidate_async.

fn invalidate_namespace(&self, namespace: &str) -> bool

Sync namespace sweep. Returns false when the sweep failed after all retries. The caller owns that false, so it is not counted here.

fn invalidate_async<'a>( &'a self, key: &'a str, ) -> CacheFuture<'a, Result<(), InvalidationError>>

Async DEL with retries. No block_in_place, so it works on a current-thread runtime. Returns the final error.

fn invalidate_namespace_async<'a>( &'a self, namespace: &'a str, ) -> CacheFuture<'a, Result<(), InvalidationError>>

Async namespace sweep with retries. Returns the final error.

fn try_acquire_fill_lock( &self, key: &str, token: &str, ttl: Duration, ) -> FillLockStatus

Acquires a cross-replica fill lock via SET NX PX. Redis errors are treated as FillLockStatus::Held (fail closed toward “someone else may be filling”) — the caller’s lock_wait_timeout bounds how long it waits before falling back to filling locally.

fn release_fill_lock(&self, key: &str, token: &str)

Releases the fill lock only if token still owns it (compare-and-delete via a Lua script), so a caller can never release a lock another replica has since taken over after this caller’s lock expired.

fn clear(&self)

Remove all entries.

impl Clone for RedisCache

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.