Struct apalis_core::builder::WorkerBuilder

pub struct WorkerBuilder<T, S, M> { /* private fields */ }

Configure and build a Worker job service.

WorkerBuilder collects all the components and configuration required to build a job service. Once the service is defined, it can be built with build.

Examples

Defining a job service with the default [JobService];

use apalis::prelude::*;
use apalis::sqlite::SqliteStorage;

let sqlite = SqliteStorage::new("sqlite::memory:").await.unwrap();

async fn email_service(job: JobRequest<Email>) -> Result<JobResult, JobError> {
   Ok(JobResult::Success)
}

let addr = WorkerBuilder::new(sqlite)
    .build_fn(email_service)
    .start().await;

Defining a middleware stack

use apalis::layers::{
   extensions::Extension,
   retry::{JobRetryPolicy, RetryLayer},
};

use apalis::WorkerBuilder;
use apalis::sqlite::SqliteStorage;

let sqlite = SqliteStorage::connect("sqlite::memory:").await.unwrap();

#[derive(Clone)]
struct JobState {}

let addr = WorkerBuilder::new(sqlite)
    .layer(RetryLayer::new(JobRetryPolicy))
    .layer(Extension(JobState {}))
    .build()
    .start().await;

Implementations

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

pub fn new(source: S) -> WorkerBuilder<S::Job, S, Identity>where
    S: JobStream,

Build a new WorkerBuilder instance

impl<T, S, M> WorkerBuilder<T, S, M>

pub fn layer<U>(self, layer: U) -> WorkerBuilder<T, S, Stack<U, M>>where
    M: Layer<U>,

Add a new layer T into the WorkerBuilder.

This wraps the inner service with the service provided by a user-defined [Layer]. The provided layer must implement the [Layer] trait.

pub fn filter<P>(
    self,
    predicate: P
) -> WorkerBuilder<T, S, Stack<FilterLayer<P>, M>>where
    M: Layer<FilterLayer<P>>,

Available on crate feature filter only.

Conditionally reject requests based on predicate.

predicate must implement the [Predicate] trait.

This wraps the inner service with an instance of the Filter middleware.

pub fn filter_async<P>(
    self,
    predicate: P
) -> WorkerBuilder<T, S, Stack<AsyncFilterLayer<P>, M>>where
    M: Layer<AsyncFilterLayer<P>>,

Conditionally reject requests based on an asynchronous predicate.

predicate must implement the [AsyncPredicate] trait.

This wraps the inner service with an instance of the [AsyncFilter] middleware. [AsyncFilter]: tower::filter::

pub fn map_response<F>(
    self,
    f: F
) -> WorkerBuilder<T, S, Stack<MapResponseLayer<F>, M>>where
    M: Layer<MapResponseLayer<F>>,

Map one response type to another.

This wraps the inner service with an instance of the MapResponse middleware.

See the documentation for the map_response combinator for details.

pub fn map_err<F>(self, f: F) -> WorkerBuilder<T, S, Stack<MapErrLayer<F>, M>>where
    M: Layer<MapErrLayer<F>>,

Map one error type to another.

This wraps the inner service with an instance of the MapErr middleware.

See the documentation for the map_err combinator for details.

Trait Implementations

impl<T: Debug, S: Debug, M: Debug> Debug for WorkerBuilder<T, S, M>

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

Formats the value using the given formatter.

impl<T, S, M, Ser, Fut> WorkerFactory<Ser> for WorkerBuilder<T, S, M>where
    S: Storage<Output = T> + Unpin + Send + 'static + Sync,
    T: Job + Send + 'static,
    M: Layer<Ser>,
    <M as Layer<Ser>>::Service: Service<JobRequest<T>, Response = JobResult, Error = JobError, Future = Fut> + Unpin + Send + 'static,
    Fut: Future<Output = Result<JobResult, JobError>> + Send,

Available on crate feature storage only.

type Worker = StorageWorker<T, S, <M as Layer<Ser>>::Service>

The worker to build

fn build(self, service: Ser) -> Self::Worker

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