Struct apalis_core::queue::Queue

pub struct Queue<T: Serialize, S: Storage<Output = T>, H> { /* private fields */ }

A queue represents a consumer of a Storage.

A Service must be provided to be called when a new job is detected.

Implementations

impl<T, S, H> Queue<T, S, H> where
    T: 'static + Serialize + Debug + DeserializeOwned,
    S: 'static + Storage<Output = T> + Unpin, 

pub fn new(storage: S, handler: H) -> Self

Trait Implementations

impl<T: 'static, S: 'static, H: 'static, F: 'static> Actor for Queue<T, S, H> where
    S: Storage + Unpin + Storage<Output = T>,
    T: Serialize + Debug + DeserializeOwned + Send,
    H: Service<JobRequest<T>, Response = JobResult, Error = JobError, Future = F> + Unpin + Send + 'static,
    F: Future<Output = Result<JobResult, JobError>>, 

type Context = Context<Queue<T, S, H>>

Actor execution context type

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

Called when an actor gets polled the first time.

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

Called after an actor is stopped.

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

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

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>(wrk: &ArbiterHandle, f: F) -> Addr<Self> where
    Self: Actor<Context = Context<Self>>,
    F: 'static + FnOnce(&mut Context<Self>) -> Self + Send, 

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<T: 'static, S: 'static, H: 'static, F: 'static> Handler<WorkerManagement> for Queue<T, S, H> where
    S: Storage + Unpin + Storage<Output = T>,
    T: Serialize + Debug + DeserializeOwned + Send,
    H: Service<JobRequest<T>, Response = JobResult, Error = JobError, Future = F> + Unpin + Send + 'static,
    F: Future<Output = Result<JobResult, JobError>>, 

type Result = Result<QueueStatus, QueueError>

The type of value that this handler will return.

fn handle(
    &mut self,
    msg: WorkerManagement,
    ctx: &mut Self::Context
) -> Self::Result

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

impl<T: 'static, S: 'static, H: 'static, F: 'static> StreamHandler<Heartbeat> for Queue<T, S, H> where
    S: Storage<Output = T> + Unpin,
    T: Serialize + Debug + DeserializeOwned + Send,
    H: Service<JobRequest<T>, Response = JobResult, Error = JobError, Future = F> + Unpin + Send + 'static,
    F: Future<Output = Result<JobResult, JobError>>, 

fn handle(&mut self, beat: Heartbeat, ctx: &mut Self::Context)

Called for every message emitted by the stream.

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

Called when stream emits first item.

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

Called when stream finishes.

fn add_stream<S>(stream: S, ctx: &mut Self::Context) -> SpawnHandle where
    S: 'static + Stream,
    Self: StreamHandler<<S as Stream>::Item>,
    Self::Context: AsyncContext<Self>, 

Register a Stream to the actor context.