Struct RedisBackend 

pub struct RedisBackend<S = BincodeFormat, C = PassthroughCompressor>
where
    S: Format,
    C: Compressor,
{ /* private fields */ }

Redis cache backend for single-node or cluster deployments.

RedisBackend provides a cache backend using Redis as the storage layer. It supports both single-node Redis instances and Redis Cluster (with the cluster feature enabled).

Use RedisBackendBuilder to construct this type.

Type Parameters

• S - Serialization format for cache values. Implements Format. Default: BincodeFormat (compact binary, recommended for production).
• C - Compression strategy for cache values. Implements Compressor. Default: PassthroughCompressor (no compression).

Examples

Basic single-node connection:

use hitbox_redis::{RedisBackend, ConnectionMode};

let backend = RedisBackend::builder()
    .connection(ConnectionMode::single("redis://localhost:6379/"))
    .build()?;

With all configuration options:

use std::time::Duration;
use hitbox_redis::{RedisBackend, ConnectionMode};
use hitbox_backend::CacheKeyFormat;
use hitbox_backend::format::JsonFormat;

let backend = RedisBackend::builder()
    .connection(ConnectionMode::single("redis://localhost:6379/"))
    .username("cache_user")        // Redis 6+ ACL
    .password("secret")
    .label("user-sessions")
    .key_format(CacheKeyFormat::UrlEncoded)
    .value_format(JsonFormat)
    .connection_timeout(Duration::from_secs(5))
    .response_timeout(Duration::from_secs(2))
    .retries(3)
    .build()?;

Cluster connection (requires cluster feature):

use hitbox_redis::{RedisBackend, ConnectionMode};

let backend = RedisBackend::builder()
    .connection(ConnectionMode::cluster([
        "redis://node1:6379",
        "redis://node2:6379",
        "redis://node3:6379",
    ]))
    .build()?;

Performance

• Read operations: Single pipelined request (HMGET + PTTL)
• Write operations: Single pipelined request (HSET + EXPIRE)
• Connection: Established lazily on first use, multiplexed for concurrent access

Caveats

• Connection failure: First cache operation will fail if Redis is unreachable
• Expire time approximation: The expire timestamp returned on read is calculated as now + PTTL, which may drift by the network round-trip time

Implementations

impl RedisBackend<BincodeFormat, PassthroughCompressor>

pub fn builder() -> RedisBackendBuilder<BincodeFormat, PassthroughCompressor>

Creates a new builder for RedisBackend.

Use the builder to configure the connection mode, serialization format, key format, compression, and label. See RedisBackend for examples.

Trait Implementations

impl<S, C> Backend for RedisBackend<S, C>

where S: Format + Send + Sync, C: Compressor + Send + Sync,

fn read<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 CacheKey, ) -> Pin<Box<dyn Future<Output = BackendResult<Option<CacheValue<Raw>>>> + Send + 'async_trait>>

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

Read raw cached data by key.

fn write<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 CacheKey, value: CacheValue<Raw>, ) -> Pin<Box<dyn Future<Output = BackendResult<()>> + Send + 'async_trait>>

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

Write raw data to cache.

fn remove<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 CacheKey, ) -> Pin<Box<dyn Future<Output = BackendResult<DeleteStatus>> + Send + 'async_trait>>

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

Remove data from cache.

fn label(&self) -> BackendLabel

Backend label for metrics and source path composition.

fn value_format(&self) -> &dyn Format

Serialization format for cached values. Default: BincodeFormat.

fn key_format(&self) -> &CacheKeyFormat

Key serialization format. Default: CacheKeyFormat::Bitcode.

fn compressor(&self) -> &dyn Compressor

Compressor for cached values. Default: PassthroughCompressor.

impl<S, C> CacheBackend for RedisBackend<S, C>

where S: Format + Send + Sync, C: Compressor + Send + Sync,

fn get<T>( &self, key: &CacheKey, ctx: &mut SmallBox<dyn Context, S4>, ) -> impl Future<Output = Result<Option<CacheValue<<T as CacheableResponse>::Cached>>, BackendError>> + Send

where T: CacheableResponse, <T as CacheableResponse>::Cached: Cacheable,

Retrieve a typed value from cache.

fn set<T>( &self, key: &CacheKey, value: &CacheValue<<T as CacheableResponse>::Cached>, ctx: &mut SmallBox<dyn Context, S4>, ) -> impl Future<Output = Result<(), BackendError>> + Send

where T: CacheableResponse, <T as CacheableResponse>::Cached: Cacheable,

Store a typed value in cache.

fn delete( &self, key: &CacheKey, _ctx: &mut SmallBox<dyn Context, S4>, ) -> impl Future<Output = Result<DeleteStatus, BackendError>> + Send

Delete a value from cache.

impl<S, C> Clone for RedisBackend<S, C>

where S: Format + Clone, C: Compressor + Clone,

fn clone(&self) -> RedisBackend<S, C>

Returns a duplicate of the value.

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

Performs copy-assignment from source.