Struct hitbox_actix::actor::CacheActor

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

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<Self>

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_default() -> Addr<Self> where
    Self: Actor<Context = Context<Self>> + Default, 

Construct and 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 = ResponseFuture<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.