Struct zeebe::JobWorkerBuilder

pub struct JobWorkerBuilder { /* private fields */ }

Configuration for an asynchronous worker process.

Implementations

impl JobWorkerBuilder

pub fn new(client: Client) -> Self

Create a new job worker builder.

pub fn with_job_type<T: Into<String>>(self, job_type: T) -> Self

Set the job type of the worker.

pub fn with_worker_name<T: Into<String>>(self, worker: T) -> Self

Set the worker name (mostly used for logging)

pub fn with_timeout(self, timeout: Duration) -> Self

Set the worker job timeout.

See the requesting jobs docs for more details.

pub fn with_request_timeout(self, request_timeout: Duration) -> Self

Set the worker request timeout.

See the requesting jobs docs for more details.

pub fn with_max_jobs_active(self, max_jobs_active: u32) -> Self

Set the maximum jobs to activate at a time by the worker.

pub fn with_concurrency(self, concurrency: u32) -> Self

Set the max number of jobs to run concurrently.

pub fn with_handler<T, R>(self, handler: T) -> Self where
    T: Fn(Client, Job) -> R + 'static,
    R: Future<Output = ()> + 'static, 

Set the handler function for the worker.

pub fn with_auto_handler<F, T, R, O, E>(self, handler: F) -> Self where
    F: HandlerFactory<T, R, O, E>,
    T: FromJob,
    R: Future<Output = Result<O, E>> + 'static,
    O: Serialize,
    E: Error, 

Set a handler function that completes or fails the job based on the result rather than having to explicitly use the client to report job status.

Examples

use serde::{Deserialize, Serialize};
use thiserror::Error;
use zeebe::{Client, Data};
use futures::future;

let client = Client::new();

// Given an app-specific error
#[derive(Error, Debug)]
enum MyError {
    #[error("unknown error occurred")]
    Unknown,
}

// And app-specific job data
#[derive(Deserialize)]
struct MyJobData {
    my_property: String,
    my_other_property: String,
}

// And app-specific job result
#[derive(Serialize)]
struct MyJobResult {
    result: u32,
}

// Async job handler function
async fn handle_job(client: Client, data: Data<MyJobData>) -> Result<MyJobResult, MyError> {
   Ok(MyJobResult { result: 42 })
}

// Example use with async function
let job = client
    .job_worker()
    .with_job_type("my-job-type")
    .with_auto_handler(handle_job)
    .run()
    .await?;

// Use with closure
let job = client
    .job_worker()
    .with_job_type("my-job-type")
    .with_auto_handler(|client: Client, my_job_data: Data<MyJobData>| {
        future::ok::<_, MyError>(MyJobResult { result: 42 })
    })
    .run()
    .await?;

pub fn with_state<T: 'static>(self, t: T) -> Self

Set state to be persisted across job auto handler invocations.

Examples

use futures::future;
use serde::Serialize;
use std::cell::Cell;
use thiserror::Error;
use zeebe::{Client, State};

#[derive(Error, Debug)]
enum MyError {}

#[derive(Serialize)]
struct MyJobResult {
    result: u32,
}

struct MyJobState {
    total: Cell<u32>,
}

let client = Client::default();

let job_state = MyJobState {
    total: Cell::new(0),
};

let _job = client
    .job_worker()
    .with_job_type("my-job-type")
    .with_auto_handler(|my_job_state: State<MyJobState>| {
        future::ok::<_, MyError>(MyJobResult { result: 42 })
    })
    .with_state(job_state)
    .run()
    .await?;

pub fn with_fetch_variables(self, fetch_variables: Vec<String>) -> Self

Set the list of variables to fetch as the job variables.

By default all visible variables at the time of activation for the scope of the job will be returned.

pub async fn run(self) -> Result<()>

Start the worker as a future. To stop the worker, simply drop the future.

Trait Implementations

impl Debug for JobWorkerBuilder

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

Formats the value using the given formatter.