Struct WorkerBuilder 

pub struct WorkerBuilder<Args, Ctx, Source, Middleware> { /* private fields */ }

Declaratively builds a Worker

Implementations

impl WorkerBuilder<(), (), (), Identity>

pub fn new<T: AsRef<str>>(name: T) -> WorkerBuilder<(), (), (), Identity>

Build a new WorkerBuilder instance with a name for the worker to build

impl WorkerBuilder<(), (), (), Identity>

pub fn backend<NB, NJ, Ctx>( self, backend: NB, ) -> WorkerBuilder<NJ, Ctx, NB, Identity>

where NB: Backend<Args = NJ, Context = Ctx>,

Set the source to a backend that implements Backend

impl<Args, Ctx, M, B> WorkerBuilder<Args, Ctx, B, M>

where B: Backend<Args = Args>,

pub fn chain<NewLayer>( self, f: impl FnOnce(M) -> NewLayer, ) -> WorkerBuilder<Args, Ctx, B, NewLayer>

Allows of decorating the service that consumes jobs. Allows adding multiple middleware in one call

pub fn layer<U>(self, layer: U) -> WorkerBuilder<Args, Ctx, B, Stack<U, M>>

Allows adding middleware to the layer stack

pub fn data<D>(self, data: D) -> WorkerBuilder<Args, Ctx, B, Stack<Data<D>, M>>

where M: Layer<Data<D>>,

Adds data to the context This will be shared by all requests

impl<Args, Ctx, B, M> WorkerBuilder<Args, Ctx, B, M>

where B: Backend<Args = Args, Context = Ctx>,

Finalizes the builder and constructs a Worker with the provided service

pub fn build<W: IntoWorkerServiceExt<Args, Ctx, Svc, B, M>, Svc>( self, service: W, ) -> Worker<Args, Ctx, B, Svc, M>

where Svc: Service<Task<Args, Ctx, B::IdType>>,

Consumes the builder and a service to construct the final worker

Trait Implementations

impl<Args, B, M, Ctx, Ack, Res> AcknowledgementExt<Args, Ctx, B, M, Ack, Res> for WorkerBuilder<Args, Ctx, B, M>

where M: Layer<AcknowledgeLayer<Ack>>, Ack: Acknowledge<Res, Ctx, B::IdType>, B: Backend<Args = Args, Context = Ctx>,

fn ack_with( self, ack: Ack, ) -> WorkerBuilder<Args, Ctx, B, Stack<AcknowledgeLayer<Ack>, M>>

Add an acknowledgment handler to the worker

impl<Args, P, M, Ctx> CircuitBreaker<Args, Ctx, P, M> for WorkerBuilder<Args, Ctx, P, M>

where P: Backend<Args = Args, Context = Ctx>, M: Layer<CircuitBreakerLayer>,

fn break_circuit_with( self, config: CircuitBreakerConfig, ) -> WorkerBuilder<Args, Ctx, P, Stack<CircuitBreakerLayer, M>>

Allows the worker to break the circuit w in case of failures Allows customizing the CircuitBreakerConfig

fn break_circuit( self, ) -> WorkerBuilder<Args, Ctx, Source, Stack<CircuitBreakerLayer, Middleware>>

Allows the worker to break the circuit in case of failures Uses default configuration

impl<Args, Ctx, Source, Middleware> Debug for WorkerBuilder<Args, Ctx, Source, Middleware>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<Args, P, M, Ctx> EventListenerExt<Args, Ctx, P, M> for WorkerBuilder<Args, Ctx, P, M>

where P: Backend<Args = Args, Context = Ctx>, M: Layer<EventListenerLayer>,

fn on_event<F: Fn(&WorkerContext, &Event) + Send + Sync + 'static>( self, f: F, ) -> WorkerBuilder<Args, Ctx, P, Stack<EventListenerLayer, M>>

Register a callback for worker events

impl<Args, B, M, Ctx> LongRunningExt<Args, Ctx, B, M> for WorkerBuilder<Args, Ctx, B, M>

where M: Layer<LongRunningLayer>, B: Backend<Args = Args, Context = Ctx>,

fn long_running_with_cfg( self, cfg: LongRunningConfig, ) -> WorkerBuilder<Args, Ctx, B, Stack<LongRunningLayer, M>>

Extension for executing long running jobs with a config

fn long_running( self, ) -> WorkerBuilder<Args, Ctx, Source, Stack<LongRunningLayer, Middleware>>

Extension for executing long running jobs

impl<Args, P, M, Ctx, Executor> ParallelizeExt<Args, Ctx, P, M, Executor> for WorkerBuilder<Args, Ctx, P, M>

where P: Backend<Args = Args, Context = Ctx>, M: Layer<ParallelizeLayer<Executor>>,

fn parallelize( self, f: Executor, ) -> WorkerBuilder<Args, Ctx, P, Stack<ParallelizeLayer<Executor>, M>>

Register the executor for parallel task execution.