Struct WorkerBuilder

pub struct WorkerBuilder<Req, Ctx, 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<M, Serv> WorkerBuilder<(), (), (), M, Serv>

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

👎Deprecated since 0.6.0: Consider using the .backend

Consume a stream directly

pub fn backend<NB: Backend<Request<NJ, Ctx>, Res>, NJ, Res: Send, Ctx>( self, backend: NB, ) -> WorkerBuilder<NJ, Ctx, NB, M, Serv>

where Serv: Service<Request<NJ, Ctx>, Response = Res>,

Set the source to a backend that implements Backend

impl<Req, M, Serv, Ctx> WorkerBuilder<Req, Ctx, (), M, Serv>

pub fn chain<NewLayer>( self, f: impl FnOnce(ServiceBuilder<M>) -> ServiceBuilder<NewLayer>, ) -> WorkerBuilder<Req, Ctx, (), NewLayer, Serv>

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

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

where M: Layer<U>,

Allows adding a single layer tower middleware

pub fn data<D>( self, data: D, ) -> WorkerBuilder<Req, Ctx, (), 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, Ctx, Source, Middleware, Serv> Debug for WorkerBuilder<Req, Ctx, Source, Middleware, Serv>

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

Formats the value using the given formatter.

impl<Req, P, M, S, Ctx> WorkerFactory<Req, Ctx, S> for WorkerBuilder<Req, Ctx, P, M, S>

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

type Source = P

The request source for the worker

type Service = <M as Layer<S>>::Service

The service that the worker will run jobs against

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

Builds a WorkerFactory using a tower service that can be used to generate a new Worker using the build method