Struct WorkerBuilder 

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

Declaratively builds a Worker

Implementations

impl WorkerBuilder<(), (), Identity>

pub fn new<T: Into<WorkerContext>>(name: T) -> Self

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

impl WorkerBuilder<(), (), Identity>

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

where NB: Backend + BackendConfig<Args = NJ>,

Set the source to a backend that implements Backend

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

where B: Backend,

pub fn chain<NewLayer>( self, f: impl FnOnce(M) -> NewLayer, ) -> WorkerBuilder<Args, 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, B, Stack<U, M>>

Allows adding middleware to the layer stack

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

Adds data to the context

This will be shared by all requests

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

Finalizes the builder and constructs a Worker with the provided service

pub fn build<W, Svc, NB>(self, service: W) -> Worker<Args, W::Backend, Svc, M>

where W: IntoWorkerService<B, Svc, Backend = NB>, B: Backend + BackendConfig, NB: Backend + BackendConfig + Send + Unpin, Svc: Service<NB::Task>, Args: Send + 'static,

Consumes the builder and a service to construct the final worker

Trait Implementations

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

where M: Layer<AcknowledgeLayer<Ack>>, Ack: Acknowledge<Res>, B: Backend,

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

Add an acknowledgment handler to the worker

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

where P: Backend, M: Layer<CircuitBreakerLayer>,

fn break_circuit_with( self, config: CircuitBreakerConfig, ) -> WorkerBuilder<Args, 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, Source, Stack<CircuitBreakerLayer, Middleware>>

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

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

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

Formats the value using the given formatter.

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

where P: Backend,

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

Register a callback for worker events

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

where M: Layer<LongRunningLayer>, B: Backend,

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

Extension for executing long running jobs with a config

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

Extension for executing long running jobs

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

where P: Backend, M: Layer<ParallelizeLayer<Executor>>,

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

Register the executor for parallel task execution.