zeebe 0.4.2

A rust client for defining, orchestrating, and monitoring business processes across microservices using Zeebe.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

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

// Any error that implements `std::error::Error`
#[derive(Error, Debug)]
enum MyError {}

// A type that can be deserialized from job variables data
#[derive(Deserialize)]
struct MyJobData {
    increment: u32,
}

// A result type that can be serialized as job success variables
#[derive(Serialize)]
struct MyJobResult {
    result: u32,
}

// Optional worker state that persists across jobs
struct JobState {
    total: Cell<u32>,
}

// Job handler with arbitrary number of parameters that can be extracted
async fn handle_job(
    job_data: Data<MyJobData>,
    job_state: State<JobState>,
) -> Result<MyJobResult, MyError> {
    let current_total = job_state.total.get();
    let new_total = current_total + job_data.increment;

    job_state.total.set(new_total);

    Ok(MyJobResult { result: new_total })
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();

    // Initialize the worker state
    let job_state = JobState {
        total: Cell::new(0),
    };

    // Run the job
    let _job = client
        .job_worker()
        .with_job_type("my-job-type")
        .with_auto_handler(handle_job)
        .with_state(job_state)
        .run()
        .await?;

    Ok(())
}