Struct background_jobs::WorkerConfig

pub struct WorkerConfig<State, M> where
    State: 'static + Clone,  { /* private fields */ }

Worker Configuration

This type is used for configuring and creating workers to process jobs. Before starting the workers, register Job types with this struct. This worker registration allows for different worker processes to handle different sets of workers.

Implementations

impl<State> WorkerConfig<State, Managed> where
    State: 'static + Clone, 

pub fn new_managed<S>(
    storage: S,
    state_fn: impl Fn(QueueHandle) -> State + Send + Sync + 'static
) -> WorkerConfig<State, Managed> where
    S: 'static + Storage + Send + Sync, 

Create a new managed WorkerConfig

The supplied function should return the State required by the jobs intended to be processed. The function must be sharable between threads, but the state itself does not have this requirement.

pub fn start(self) -> Manager

Start the workers on a managed arbiter, and return the manager struct

impl<State> WorkerConfig<State, Unmanaged> where
    State: 'static + Clone, 

pub fn new<S>(
    storage: S,
    state_fn: impl Fn(QueueHandle) -> State + Send + Sync + 'static
) -> WorkerConfig<State, Unmanaged> where
    S: 'static + Storage + Send + Sync, 

Create a new WorkerConfig in the current arbiter

The supplied function should return the State required by the jobs intended to be processed. The function must be sharable between threads, but the state itself does not have this requirement.

pub fn new_in_arbiter<S>(
    arbiter: ArbiterHandle,
    storage: S,
    state_fn: impl Fn(QueueHandle) -> State + Send + Sync + 'static
) -> WorkerConfig<State, Unmanaged> where
    S: 'static + Storage + Send + Sync, 

Create a new WorkerConfig in the provided arbiter

The supplied function should return the State required by the jobs intended to be processed. The function must be sharable between threads, but the state itself does not have this requirement.

pub fn start(self) -> QueueHandle

Start the workers in the provided arbiter

impl<State, M> WorkerConfig<State, M> where
    State: 'static + Clone, 

pub fn register<J>(self) -> WorkerConfig<State, M> where
    J: Job<State = State>, 

Register a Job with the worker

This enables the worker to handle jobs associated with this processor. If a processor is not registered, none of it’s jobs will be run, even if another processor handling the same job queue is registered.

pub fn set_worker_count(self, queue: &str, count: u64) -> WorkerConfig<State, M>

Set the number of workers to run for a given queue

This does not spin up any additional threads. The Arbiter the workers are spawned onto will handle processing all workers, regardless of how many are configured.

By default, 4 workers are spawned

Trait Implementations

impl<State, M> Clone for WorkerConfig<State, M> where
    State: Clone + 'static,
    M: Clone, 

pub fn clone(&self) -> WorkerConfig<State, M>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.