Struct RedisBackend 

pub struct RedisBackend { /* private fields */ }

Redis backend powered by the fred client.

Call connect before issuing any cache operations.

Implementations

impl RedisBackend

pub fn builder() -> RedisBackendBuilder

Start building a RedisBackend.

pub async fn connect(&self) -> Result<ConnectHandle, BackendError>

Connect to Redis and wait until the connection is established.

This must be called before any cache operations.

The returned ConnectHandle is fred’s handle to the spawned task that drives the connection (a tokio JoinHandle). Dropping it detaches the task without stopping it: the connection, and any auto-reconnect, keeps running for as long as the backend is alive. The intent presets drop it for that reason. Keep it only to observe how the connection ended: the task resolves when the connection closes for good (on a fail-fast backend, the first dropped connection), with the error that closed it, if any. Do not abort it while the backend is still in use.

Trait Implementations

impl Backend for RedisBackend

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

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

Retrieve the raw bytes stored under key, or None if absent.

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

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

Store value under key, optionally expiring after ttl.

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

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

Remove key and return true if it existed.

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

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

Return true if key exists without fetching the value.

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

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

Return health/status information for this backend.

fn as_lockable(&self) -> Option<&dyn LockableBackend>

Expose this backend’s LockableBackend capability, if it has one.

fn attach_metrics(&self, _provider: MetricsProvider)

Receive the client’s live hit/miss statistics.

impl Debug for RedisBackend

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl LockableBackend for RedisBackend

fn acquire_lock<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 str, timeout_ms: u64, ) -> Pin<Box<dyn Future<Output = Result<Option<String>, BackendError>> + Send + 'async_trait>>

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

Acquire a distributed lock. Returns lock_id if acquired, None if contested.

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

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

Release a distributed lock. Returns true if released. Must release only if lock_id still owns the lock: a late or duplicate release must never free a lock acquired since. Return Ok(false) when lock_id no longer owns the lock; Err only when the outcome is unknown. The single-flight takes Ok as answered and never re-sends it, and re-sends after an Err on the key’s next lock attempt.

impl TtlInspectable for RedisBackend

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

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

Return the remaining TTL for key, or None if the key does not exist or has no expiry.

fn refresh_ttl<'life0, 'life1, 'async_trait>( &'life0 self, _key: &'life1 str, _ttl: Duration, ) -> Pin<Box<dyn Future<Output = Result<bool, BackendError>> + Send + 'async_trait>>

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

Refresh the TTL on an existing key. Default: not supported.