Crate zeebe

Expand description

A rust client for defining, orchestrating, and monitoring business processes across microservices using Zeebe.

§What is Zeebe?

Zeebe is a workflow engine for microservices orchestration. Zeebe ensures that, once started, flows are always carried out fully, retrying steps in case of failures. Along the way, Zeebe maintains a complete audit log so that the progress of flows can be monitored. Zeebe is fault tolerant and scales seamlessly to handle growing transaction volumes.

§Example

use serde_json::json;
use zeebe::{Client, Job};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create a zeebe client
    let client = Client::from_env()?;

    // Deploy a process
    client
        .deploy_process()
        .with_resource_file("examples/workflows/order-process.bpmn")
        .send()
        .await?;

    // Create a new process instance
    client
        .create_process_instance()
        .with_bpmn_process_id("order-process")
        .with_latest_version()
        .with_variables(json!({"orderId": 31243}))
        .send()
        .await?;

    // Process a job type within the process
    client
        .job_worker()
        .with_job_type("payment-service")
        .with_handler(handle_job)
        .run()
        .await?;

    Ok(())
}

async fn handle_job(client: Client, job: Job) {
    /// your job processing logic...

    let _ = client.complete_job().with_job_key(job.key()).send().await;
}

Or with job success and failure reported for you automatically from your function result:

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

let client = Client::from_env()?;

// 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(data: Data<MyJobData>) -> Result<MyJobResult, MyError> {
   Ok(MyJobResult { result: 42 })
}

// You can run a worker from your function with results auto reported
let job = client
    .job_worker()
    .with_job_type("my-job-type")
    .with_auto_handler(handle_job)
    .run()
    .await?;

// OR you can run a closure and have the results auto reported
let job = client
    .job_worker()
    .with_job_type("my-job-type")
    .with_auto_handler(|my_job_data: Data<MyJobData>| {
        future::ok::<_, MyError>(MyJobResult { result: 42 })
    })
    .run()
    .await?;

Structs§

BrokerInfo: Zeebe broker info
CancelProcessInstanceBuilder: Cancels a running process instance.
CancelProcessInstanceResponse: Canceled process instance data.
Client: Client used to communicate with Zeebe.
ClientConfig: Config for establishing zeebe client.
CompleteJobBuilder: Configuration to complete a job
CompleteJobResponse: Completed job instance data.
CreateProcessInstanceBuilder: Creates and starts an instance of the specified process.
CreateProcessInstanceResponse: Created process instance data.
CreateProcessInstanceWithResultBuilder: Creates and starts an instance of the specified process with result.
CreateProcessInstanceWithResultResponse: Created process instance with result data.
Data: Data that can be extracted from JSON encoded job variables in auto handlers.
DeployProcessBuilder: Deploys one or more process to Zeebe.
DeployProcessResponse: Deployed process data.
FailJobBuilder: Configuration to fail a job
FailJobResponse: Failed job instance data.
Job: An activate Zeebe job that is ready to be worked on by a worker.
JobWorkerBuilder: Configuration for an asynchronous worker process.
Partition: Zeebe partition.
ProcessMetadata: Metadata information about a process.
PublishMessageBuilder: Configuration to publish a message.
PublishMessageResponse: The publish message data.
ResolveIncidentBuilder: Configuration to resolve an incident.
ResolveIncidentResponse: The resolve incident data.
SetVariablesBuilder: Updates all the variables of a particular scope (e.g. process instance, flow element instance) from the given JSON document.
SetVariablesResponse: Set variables data.
State: Worker state that persists across job auto handler invocations.
ThrowErrorBuilder: Configuration to throw an error in the context of a job.
ThrowErrorResponse: Throw error response data.
TopologyBuilder: Request to obtain the current topology of the cluster the gateway is part of.
TopologyResponse: The current topology of the cluster
UpdateJobRetriesBuilder: Updates the number of retries a job has left. This is mostly useful for jobs that have run out of retries, should the underlying problem be solved.
UpdateJobRetriesResponse: Update job retries data.

Enums§

Error: The error type which is returned from zeebe processing failures.

Type Aliases§

Result: The result type returned by zeebe methods.