Struct CacheActor 

pub struct CacheActor<B>
where
    B: Backend,
{ /* private fields */ }

Actix actor implements cache logic.

This actor implement only Handler<QueryCache>. Where QueryCache - Actix message with two fields:

• Generic actix message for sending to upstream actor.
• Address of upstream actor

Example

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

#[actix_rt::main]
async fn main() -> Result<(), CacheError> {
    let cache = Cache::new().await?.start();
    Ok(())
}

Implementations

impl<B> CacheActor<B>

where B: Actor + Backend, <B as Actor>::Context: ToEnvelope<B, Get> + ToEnvelope<B, Set> + ToEnvelope<B, Lock> + ToEnvelope<B, Delete>,

pub async fn new() -> Result<CacheActor<RedisBackend>, CacheError>

Initialize new Cache actor with default hitbox_redis::RedisBackend.

pub fn builder() -> CacheBuilder<B>

Creates new CacheBuilder instance for Cache actor configuration.

Trait Implementations

impl<B> Actor for CacheActor<B>

where B: Backend,

type Context = Context<CacheActor<B>>

Actor execution context type

fn started(&mut self, _: &mut Self::Context)

Called when an actor gets polled the first time.

fn stopping(&mut self, ctx: &mut Self::Context) -> Running

Called after an actor is in Actor::Stopping state.

fn stopped(&mut self, ctx: &mut Self::Context)

Called after an actor is stopped.

fn start(self) -> Addr<Self>

where Self: Actor<Context = Context<Self>>,

Start a new asynchronous actor, returning its address.

fn start_in_arbiter<F>(arb: &Arbiter, f: F) -> Addr<Self>

where Self: Actor<Context = Context<Self>>, F: FnOnce(&mut Context<Self>) -> Self + Send + 'static,

Start new actor in arbiter’s thread.

fn create<F>(f: F) -> Addr<Self>

where Self: Actor<Context = Context<Self>>, F: FnOnce(&mut Context<Self>) -> Self,

Start a new asynchronous actor given a Context.

impl<'a, A, M, B> Handler<QueryCache<A, M>> for CacheActor<B>

where B: Actor + Backend, <B as Actor>::Context: ToEnvelope<B, Get> + ToEnvelope<B, Set> + ToEnvelope<B, Lock> + ToEnvelope<B, Delete>, A: Actor + Handler<M> + Send, M: Message + Cacheable + Send + 'static, M::Result: MessageResponse<A, M> + CacheableResponse + Debug + Send, <<M as Message>::Result as CacheableResponse>::Cached: Serialize + DeserializeOwned, <A as Actor>::Context: ToEnvelope<A, M>,

type Result = Pin<Box<dyn Future<Output = Result<<M as Message>::Result, CacheError>>>>

The type of value that this handler will return.

fn handle( &mut self, msg: QueryCache<A, M>, _: &mut Self::Context, ) -> Self::Result

This method is called for every message received by this actor.