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>>, 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, Ctx, Input, Compact, Output, Index> StepWorkerFactory<Ctx, Compact, Input, Output, Index> for WorkerBuilder<Req, Ctx, P, M, StepService<Ctx, Compact, Input, P, Index>>

where Compact: Send + 'static + Sync, P: Backend<Request<StepRequest<Compact, Index>, Ctx>> + 'static + Storage<Job = StepRequest<Compact, Index>> + Clone, M: Layer<StepService<Ctx, Compact, Input, P, Index>> + 'static,

type Source = P

The request source for the worker

type Service = <M as Layer<StepService<Ctx, Compact, Input, P, Index>>>::Service

The service that the worker will run jobs against

type Codec = <P as Backend<Request<StepRequest<Compact, Index>, Ctx>>>::Codec

Represents the codec for the backend bound

fn build_stepped( self, builder: StepBuilder<Ctx, Compact, Input, Output, Self::Codec, Index>, ) -> Worker<Ready<M::Service, P>>

Builds a StepWorkerFactory using a tower service that can be used to generate a new Worker using the build_stepped method

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

where S: Service<Request<Req, Ctx>>, M: Layer<S>, P: Backend<Request<Req, Ctx>>,

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