Struct apalis_core::storage::StorageWorker

pub struct StorageWorker<T, S: Storage<Output = T>, H> { /* private fields */ }

Available on crate feature storage only.

A queue represents a consumer of a Storage.

A [Service] must be provided to be called when a new job is detected.

Implementations

impl<T, S, H> StorageWorker<T, S, H>where
    T: 'static + Job,
    S: 'static + Storage<Output = T> + Unpin,

pub fn new(storage: S, handler: H) -> Self

Create a new Worker instance

pub fn config(self, config: StorageWorkerConfig) -> StorageWorker<T, S, H>

Set a [WorkerConfig] for Worker

Trait Implementations

impl<T: Debug, S: Debug + Storage<Output = T>, H: Debug> Debug for StorageWorker<T, S, H>

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

Formats the value using the given formatter.

impl<T, S, H, F> Handler<StorageWorkerPulse> for StorageWorker<T, S, H>where
    S: Storage<Output = T> + Unpin + Send + Sync + 'static,
    T: Job + Send + 'static,
    H: Service<JobRequest<T>, Response = JobResult, Error = JobError, Future = F> + Unpin + Send + 'static,
    F: Future<Output = Result<JobResult, JobError>> + Send,

type Result = ()

Available on crate feature worker only.

Result of handler

fn handle<'life0, 'async_trait>(
    &'life0 mut self,
    beat: StorageWorkerPulse
) -> Pin<Box<dyn Future<Output = Self::Result> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Available on crate feature worker only.

Message handler

impl<T, S, H, F> Worker for StorageWorker<T, S, H>where
    S: JobStream<Job = T> + Storage + Unpin + Storage<Output = T> + Send + 'static + Sync,
    T: Job + Send + 'static,
    H: Service<JobRequest<T>, Response = JobResult, Error = JobError, Future = F> + Unpin + Send + 'static,
    F: Future<Output = Result<JobResult, JobError>> + Send,

type Job = T

Available on crate feature worker only.

The job type for the worker

type Service = H

Available on crate feature worker only.

The tower service to process job requests

type Future = F

Available on crate feature worker only.

The future returened by our tower service

fn on_start<'life0, 'life1, 'async_trait>(
    &'life0 mut self,
    ctx: &'life1 mut Context<Self>
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Available on crate feature worker only.

At start hook of worker

fn on_stop<'life0, 'life1, 'async_trait>(
    &'life0 mut self,
    _ctx: &'life1 mut Context<Self>
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Available on crate feature worker only.

At stop hook of worker

fn consume(&mut self) -> JobStreamResult<Self::Job>

Available on crate feature worker only.

Returns a streams of jobs for the worker to consume

fn service(&mut self) -> &mut Self::Service

Available on crate feature worker only.

Returns the service that handles the job

fn handle_job<'life0, 'async_trait>(
    &'life0 mut self,
    job: JobRequest<Self::Job>
) -> Pin<Box<dyn Future<Output = Result<JobResult, JobError>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Available on crate feature worker only.

The way the worker will handle a job

fn manage<'life0, 'async_trait>(
    &'life0 mut self,
    _msg: WorkerManagement
) -> Pin<Box<dyn Future<Output = Result<WorkerStatus, WorkerError>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Available on crate feature worker only.

Manage a worker