Struct hitbox_actix::builder::CacheBuilder

pub struct CacheBuilder<B> where
    B: Backend + Actor,  { /* fields omitted */ }

Cache actor configurator.

Example

use actix::prelude::*;
use hitbox_actix::{Cache, RedisBackend, CacheError};

#[actix_rt::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let backend = RedisBackend::new()
        .await?
        .start();
    let cache = Cache::builder()
        .enable()
        .finish(backend)
        .start();
    Ok(())
}

Implementations

impl<B> CacheBuilder<B> where
    B: Backend, 

pub fn enable(self) -> Self

Enable interaction with cache backend. (Default value).

pub fn disable(self) -> Self

Disable interaction with cache backend.

All messages sent to disabled Cache actor passed directly to an upstream actor.

pub fn with_stale(self) -> Self

Enable stale cache mechanics. (Default value).

If CacheActor receives a stale value, it does not return it immediately. It polls data from upstream, and if the upstream returned an error, the CacheActor returns a stale value. If no error occurred in the upstream, then a fresh value is stored in the cache and returned.

pub fn without_stale(self) -> Self

Disable stale cache mechanics.

pub fn with_lock(self) -> Self

Enable cache lock mechanics.

Prevents multiple upstream requests for the same cache key in case of cache data is missing. Only the first request will produce an upstream request. The remaining requests wait for a first upstream response and return updated data. If with_stale is enabled the remaining requests don’t wait for an upstream response and return stale cache data if it exists.

pub fn without_lock(self) -> Self

Disable cache lock mechanics. (Default value).

pub fn finish(self, backend: Addr<B>) -> CacheActor<B>

Instantiate new Cache instance with current configuration and passed backend.

Backend is an Addr of actix Actor which implements Backend trait:

Trait Implementations

impl<B> Default for CacheBuilder<B> where
    B: Backend, 

fn default() -> Self

Returns the “default value” for a type.