Struct apalis_core::builder::WorkerBuilder

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

Allows building a Worker. Usually the output is Worker<Ready>

Implementations

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

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

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

impl<J, S, M, Serv> WorkerBuilder<J, S, M, Serv>

pub fn stream<NS: Stream<Item = Result<Option<Request<NJ>>, Error>> + Send + 'static, NJ>( self, stream: NS, ) -> WorkerBuilder<NJ, NS, M, Serv>

Consume a stream directly

pub fn with_storage<NS: Storage<Job = NJ>, NJ>( self, storage: NS, ) -> WorkerBuilder<NJ, NS, M, Serv>

Set the source to a Storage

pub fn with_mq<NS: MessageQueue<NJ>, NJ>( self, message_queue: NS, ) -> WorkerBuilder<NJ, NS, M, Serv>

Set the source to a MessageQueue

pub fn source<NS: Backend<Request<NJ>>, NJ>( self, backend: NS, ) -> WorkerBuilder<NJ, NS, M, Serv>

Set the source to a generic backend that implements only Backend

impl<Request, Stream, M, Serv> WorkerBuilder<Request, Stream, M, Serv>

pub fn chain<NewLayer>( self, f: impl Fn(ServiceBuilder<M>) -> ServiceBuilder<NewLayer>, ) -> WorkerBuilder<Request, Stream, NewLayer, Serv>

Allows of decorating the service that consumes jobs. Allows adding multiple tower middleware

pub fn layer<U>( self, layer: U, ) -> WorkerBuilder<Request, Stream, Stack<U, M>, Serv>

where M: Layer<U>,

Allows adding a single layer tower middleware

pub fn data<D>( self, data: D, ) -> WorkerBuilder<Request, Stream, Stack<Data<D>, M>, Serv>

where M: Layer<Data<D>>,

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

Trait Implementations

impl<Req, Source, Middleware, Serv> Debug for WorkerBuilder<Req, Source, Middleware, Serv>

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

Formats the value using the given formatter.

impl<Req: Send + 'static + Sync, P: Backend<Request<Req>> + 'static, M, S> WorkerFactory<Req, S> for WorkerBuilder<Req, P, M, S>

where S: Service<Request<Req>> + Send + 'static + Clone + Sync, S::Future: Send, S::Response: 'static, P::Layer: Layer<S>, M: Layer<<P::Layer as Layer<S>>::Service> + 'static,

fn build(self, service: S) -> Worker<Ready<Self::Service, P>>

Build a worker, given a tower service

type Source = P

The request source for the worker

type Service = <M as Layer<<<P as Backend<Request<Req>>>::Layer as Layer<S>>::Service>>::Service

The service that the worker will run jobs against