Struct WorkerBuilder 

pub struct WorkerBuilder<S, H = (), T = ()>
where
    S: WorkerBuilderState,
    T: Send + Sync + 'static,
{ /* private fields */ }

WorkerBuilder is a builder pattern struct for constructing a Worker instance.

This builder uses the typestate pattern to ensure that all required parameters are set before a Worker can be constructed. The builder enforces proper configuration through its type system.

Type Parameters

• S - The current state of the builder (enforces configuration order)

Examples

struct ExampleSharedState {
    pub increment_me: u32,
}

let state = Arc::new(SharedState(Mutex::new(ExampleSharedState {
       increment_me: 0,
})));

// Client instantiation

client
    .worker()
    .with_job_timeout(Duration::from_secs(60))
    .with_request_timeout(Duration::from_secs(10))
    .with_max_jobs_to_activate(4)
    .with_concurrency_limit(2)
    .with_job_type(String::from("demo-service"))
    .with_state(state)
    .with_handler(|client, job, state| async move {
        let mut lock = state.lock().await;
        lock.increment_me += 1;
        let _ = client.complete_job().with_job_key(job.key()).send().await;
     })
     .build()

Implementations

impl WorkerBuilder<Initial>

pub fn new(client: Client) -> Self

pub fn with_request_timeout( self, request_timeout: Duration, ) -> WorkerBuilder<WithRequestTimeout>

Sets the request timeout for the worker.

The request will be completed when at least one job is activated or after the specified request_timeout.

Arguments

• request_timeout - The duration to wait before the request times out.

Returns

A WorkerBuilder<WithRequestTimeout> instance with the request timeout configured.

Examples found in repository

examples/custom_auto_handler.rs (line 68)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    unsafe { std::env::set_var("RUST_BACKTRACE", "1") };

    // Default configuration using Camunda's docker compose
    // https://github.com/camunda/camunda-platform/blob/5dc74fe71667e18fbb5c8d4694068d662d83ad00/README.md
    let client = Client::builder()
        .with_address("http://localhost", 26500)
        .with_oauth(
            String::from("zeebe"),
            String::from("zecret"),
            String::from(
                "http://localhost:18080/auth/realms/camunda-platform/protocol/openid-connect/token",
            ),
            String::from("zeebe-api"),
            Duration::from_secs(30),
            None,
        )
        .build()
        .await?;

    // Wait until first OAuth token has been retrieved
    client.auth_initialized().await;

    let worker = client
        .worker()
        .with_request_timeout(Duration::from_secs(1))
        .with_job_timeout(Duration::from_secs(1))
        .with_max_jobs_to_activate(1)
        .with_concurrency_limit(1)
        .with_job_type(String::from("placeholder"))
        .with_handler(always_fail)
        .build();

    tokio::join!(worker.run());

    Ok(())
}

examples/pizza.rs (line 138)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    unsafe { std::env::set_var("RUST_BACKTRACE", "1") };

    // Default configuration using Camunda's docker compose
    // https://github.com/camunda/camunda-platform/blob/5dc74fe71667e18fbb5c8d4694068d662d83ad00/README.md
    let client = Client::builder()
        .with_address("http://localhost", 26500)
        .with_oauth(
            String::from("zeebe"),
            String::from("zecret"),
            String::from(
                "http://localhost:18080/auth/realms/camunda-platform/protocol/openid-connect/token",
            ),
            String::from("zeebe-api"),
            Duration::from_secs(30),
            None,
        )
        .build()
        .await?;

    // Wait until first OAuth token has been retrieved
    client.auth_initialized().await;

    // Deploy our pizza ordering process
    // We just discard the result for brevity
    let deploy_resource_response = client
        .deploy_resource()
        .with_resource_file(PathBuf::from("examples/resources/pizza-order.bpmn"))
        .read_resource_files()?
        .send()
        .await?;

    let process_definition_key =
        if let Some(deployment) = deploy_resource_response.deployments().first() {
            match deployment.metadata() {
                Some(metadata) => match metadata {
                    zeebe_rs::Metadata::Process(process_metadata) => {
                        process_metadata.process_definition_key()
                    }
                    _ => {
                        unreachable!("We're only deploying a bpmn here");
                    }
                },
                _ => -1,
            }
        } else {
            -1
        };

    // Let's define our shared state, how much stock we have
    let mut initial_stock = HashMap::new();
    initial_stock.insert(String::from("Pepperoni"), 5);
    initial_stock.insert(String::from("Margherita"), 8);
    initial_stock.insert(String::from("Hawaiian"), 3);
    initial_stock.insert(String::from("Quattro Formaggi"), 0);
    initial_stock.insert(String::from("Vegetarian"), 6);

    let stock = Arc::new(SharedState(Mutex::new(Stock {
        items: initial_stock,
    })));

    // This will share the stock among all the workers confirming orders
    // counting it down for each order.
    let confirm_worker = client
        .worker()
        .with_request_timeout(Duration::from_secs(10))
        .with_job_timeout(Duration::from_secs(10))
        .with_max_jobs_to_activate(4)
        .with_concurrency_limit(2)
        .with_job_type(String::from("confirm_order"))
        .with_state(stock)
        .with_handler(confirm_order)
        .with_fetch_variable(String::from("items"))
        .build();

    // We can reuse the worker builder for sharing some configurations
    let base_worker = client
        .worker()
        .with_request_timeout(Duration::from_secs(10))
        .with_job_timeout(Duration::from_secs(10));

    let bake_worker = base_worker
        .clone()
        .with_max_jobs_to_activate(10)
        .with_concurrency_limit(10)
        .with_job_type(String::from("bake_pizzas"))
        .with_handler(bake_pizzas)
        .build();

    // Handler can be both function callbacks or closures
    // Handlers have to share return type for this to work
    let reject_order_worker = client
        .worker()
        .with_request_timeout(Duration::from_secs(10))
        .with_job_timeout(Duration::from_secs(10))
        .with_max_jobs_to_activate(5)
        .with_concurrency_limit(5)
        .with_job_type(String::from("reject_order"))
        .with_handler(|_client, _job| async move { Ok::<(), WorkerError<()>>(()) })
        .build();

    let deliver_worker = client
        .worker()
        .with_request_timeout(Duration::from_secs(10))
        .with_job_timeout(Duration::from_secs(10))
        .with_max_jobs_to_activate(1)
        .with_concurrency_limit(1)
        .with_job_type(String::from("deliver_order"))
        .with_handler(deliver_order)
        .build();

    let clarify_address_worker = base_worker
        .clone()
        .with_max_jobs_to_activate(5)
        .with_concurrency_limit(5)
        .with_job_type(String::from("call_customer"))
        .with_handler(|client, job| async move {
            let mut customer = job.data::<Customer>().unwrap();

            //Same guy keeps leaving out his address for some reason
            customer.address = String::from("1337 Coolsville, USA");
            if let Ok(req) = client
                .complete_job()
                .with_job_key(job.key())
                .with_variables(customer)
            {
                let _ = req.send().await;
            }
        })
        .build();

    tokio::spawn(place_order(
        client.clone(),
        process_definition_key,
        "Jane Doe",
        "100 Coolsville, USA",
        true,
        vec!["Pepperoni"],
    ));

    tokio::spawn(place_order(
        client.clone(),
        process_definition_key,
        "John Doe",
        "999 NotCoolsville, USA",
        false,
        vec!["Quattro Formaggi"; 100],
    ));

    tokio::spawn(place_order(
        client.clone(),
        process_definition_key,
        "Lorem Ipsum",
        "",
        false,
        vec!["Hawaiian", "Pepperoni"],
    ));

    tokio::spawn(place_order(
        client.clone(),
        process_definition_key,
        "George W Bush",
        "White House",
        true,
        vec!["Burger"],
    ));

    let _ = tokio::join!(
        confirm_worker.run(),
        reject_order_worker.run(),
        bake_worker.run(),
        deliver_worker.run(),
        clarify_address_worker.run(),
    );

    Ok(())
}

impl WorkerBuilder<WithRequestTimeout>

pub fn with_job_timeout( self, timeout: Duration, ) -> WorkerBuilder<WithJobTimeout>

Sets the job timeout for the worker.

A job returned after this call will not be activated by another call until the specified timeout (in milliseconds) has been reached. This ensures that the job is not picked up by another worker before the timeout expires.

Parameters

• timeout: The duration for which the job should be locked.

Returns

A WorkerBuilder<WithJobTimeout> instance with the job timeout configured.

Examples found in repository

examples/custom_auto_handler.rs (line 69)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    unsafe { std::env::set_var("RUST_BACKTRACE", "1") };

    // Default configuration using Camunda's docker compose
    // https://github.com/camunda/camunda-platform/blob/5dc74fe71667e18fbb5c8d4694068d662d83ad00/README.md
    let client = Client::builder()
        .with_address("http://localhost", 26500)
        .with_oauth(
            String::from("zeebe"),
            String::from("zecret"),
            String::from(
                "http://localhost:18080/auth/realms/camunda-platform/protocol/openid-connect/token",
            ),
            String::from("zeebe-api"),
            Duration::from_secs(30),
            None,
        )
        .build()
        .await?;

    // Wait until first OAuth token has been retrieved
    client.auth_initialized().await;

    let worker = client
        .worker()
        .with_request_timeout(Duration::from_secs(1))
        .with_job_timeout(Duration::from_secs(1))
        .with_max_jobs_to_activate(1)
        .with_concurrency_limit(1)
        .with_job_type(String::from("placeholder"))
        .with_handler(always_fail)
        .build();

    tokio::join!(worker.run());

    Ok(())
}

examples/pizza.rs (line 139)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    unsafe { std::env::set_var("RUST_BACKTRACE", "1") };

    // Default configuration using Camunda's docker compose
    // https://github.com/camunda/camunda-platform/blob/5dc74fe71667e18fbb5c8d4694068d662d83ad00/README.md
    let client = Client::builder()
        .with_address("http://localhost", 26500)
        .with_oauth(
            String::from("zeebe"),
            String::from("zecret"),
            String::from(
                "http://localhost:18080/auth/realms/camunda-platform/protocol/openid-connect/token",
            ),
            String::from("zeebe-api"),
            Duration::from_secs(30),
            None,
        )
        .build()
        .await?;

    // Wait until first OAuth token has been retrieved
    client.auth_initialized().await;

    // Deploy our pizza ordering process
    // We just discard the result for brevity
    let deploy_resource_response = client
        .deploy_resource()
        .with_resource_file(PathBuf::from("examples/resources/pizza-order.bpmn"))
        .read_resource_files()?
        .send()
        .await?;

    let process_definition_key =
        if let Some(deployment) = deploy_resource_response.deployments().first() {
            match deployment.metadata() {
                Some(metadata) => match metadata {
                    zeebe_rs::Metadata::Process(process_metadata) => {
                        process_metadata.process_definition_key()
                    }
                    _ => {
                        unreachable!("We're only deploying a bpmn here");
                    }
                },
                _ => -1,
            }
        } else {
            -1
        };

    // Let's define our shared state, how much stock we have
    let mut initial_stock = HashMap::new();
    initial_stock.insert(String::from("Pepperoni"), 5);
    initial_stock.insert(String::from("Margherita"), 8);
    initial_stock.insert(String::from("Hawaiian"), 3);
    initial_stock.insert(String::from("Quattro Formaggi"), 0);
    initial_stock.insert(String::from("Vegetarian"), 6);

    let stock = Arc::new(SharedState(Mutex::new(Stock {
        items: initial_stock,
    })));

    // This will share the stock among all the workers confirming orders
    // counting it down for each order.
    let confirm_worker = client
        .worker()
        .with_request_timeout(Duration::from_secs(10))
        .with_job_timeout(Duration::from_secs(10))
        .with_max_jobs_to_activate(4)
        .with_concurrency_limit(2)
        .with_job_type(String::from("confirm_order"))
        .with_state(stock)
        .with_handler(confirm_order)
        .with_fetch_variable(String::from("items"))
        .build();

    // We can reuse the worker builder for sharing some configurations
    let base_worker = client
        .worker()
        .with_request_timeout(Duration::from_secs(10))
        .with_job_timeout(Duration::from_secs(10));

    let bake_worker = base_worker
        .clone()
        .with_max_jobs_to_activate(10)
        .with_concurrency_limit(10)
        .with_job_type(String::from("bake_pizzas"))
        .with_handler(bake_pizzas)
        .build();

    // Handler can be both function callbacks or closures
    // Handlers have to share return type for this to work
    let reject_order_worker = client
        .worker()
        .with_request_timeout(Duration::from_secs(10))
        .with_job_timeout(Duration::from_secs(10))
        .with_max_jobs_to_activate(5)
        .with_concurrency_limit(5)
        .with_job_type(String::from("reject_order"))
        .with_handler(|_client, _job| async move { Ok::<(), WorkerError<()>>(()) })
        .build();

    let deliver_worker = client
        .worker()
        .with_request_timeout(Duration::from_secs(10))
        .with_job_timeout(Duration::from_secs(10))
        .with_max_jobs_to_activate(1)
        .with_concurrency_limit(1)
        .with_job_type(String::from("deliver_order"))
        .with_handler(deliver_order)
        .build();

    let clarify_address_worker = base_worker
        .clone()
        .with_max_jobs_to_activate(5)
        .with_concurrency_limit(5)
        .with_job_type(String::from("call_customer"))
        .with_handler(|client, job| async move {
            let mut customer = job.data::<Customer>().unwrap();

            //Same guy keeps leaving out his address for some reason
            customer.address = String::from("1337 Coolsville, USA");
            if let Ok(req) = client
                .complete_job()
                .with_job_key(job.key())
                .with_variables(customer)
            {
                let _ = req.send().await;
            }
        })
        .build();

    tokio::spawn(place_order(
        client.clone(),
        process_definition_key,
        "Jane Doe",
        "100 Coolsville, USA",
        true,
        vec!["Pepperoni"],
    ));

    tokio::spawn(place_order(
        client.clone(),
        process_definition_key,
        "John Doe",
        "999 NotCoolsville, USA",
        false,
        vec!["Quattro Formaggi"; 100],
    ));

    tokio::spawn(place_order(
        client.clone(),
        process_definition_key,
        "Lorem Ipsum",
        "",
        false,
        vec!["Hawaiian", "Pepperoni"],
    ));

    tokio::spawn(place_order(
        client.clone(),
        process_definition_key,
        "George W Bush",
        "White House",
        true,
        vec!["Burger"],
    ));

    let _ = tokio::join!(
        confirm_worker.run(),
        reject_order_worker.run(),
        bake_worker.run(),
        deliver_worker.run(),
        clarify_address_worker.run(),
    );

    Ok(())
}

impl WorkerBuilder<WithJobTimeout>

pub fn with_max_jobs_to_activate( self, max_jobs_to_activate: i32, ) -> WorkerBuilder<WithMaxJobs>

Sets the maximum number of jobs to activate in a single request.

Arguments

• max_jobs_to_activate - The maximum number of jobs to activate.

Returns

A WorkerBuilder<WithMaxJobs> instance with the WithMaxJobs state.

Examples found in repository

examples/custom_auto_handler.rs (line 70)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    unsafe { std::env::set_var("RUST_BACKTRACE", "1") };

    // Default configuration using Camunda's docker compose
    // https://github.com/camunda/camunda-platform/blob/5dc74fe71667e18fbb5c8d4694068d662d83ad00/README.md
    let client = Client::builder()
        .with_address("http://localhost", 26500)
        .with_oauth(
            String::from("zeebe"),
            String::from("zecret"),
            String::from(
                "http://localhost:18080/auth/realms/camunda-platform/protocol/openid-connect/token",
            ),
            String::from("zeebe-api"),
            Duration::from_secs(30),
            None,
        )
        .build()
        .await?;

    // Wait until first OAuth token has been retrieved
    client.auth_initialized().await;

    let worker = client
        .worker()
        .with_request_timeout(Duration::from_secs(1))
        .with_job_timeout(Duration::from_secs(1))
        .with_max_jobs_to_activate(1)
        .with_concurrency_limit(1)
        .with_job_type(String::from("placeholder"))
        .with_handler(always_fail)
        .build();

    tokio::join!(worker.run());

    Ok(())
}

examples/pizza.rs (line 140)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    unsafe { std::env::set_var("RUST_BACKTRACE", "1") };

    // Default configuration using Camunda's docker compose
    // https://github.com/camunda/camunda-platform/blob/5dc74fe71667e18fbb5c8d4694068d662d83ad00/README.md
    let client = Client::builder()
        .with_address("http://localhost", 26500)
        .with_oauth(
            String::from("zeebe"),
            String::from("zecret"),
            String::from(
                "http://localhost:18080/auth/realms/camunda-platform/protocol/openid-connect/token",
            ),
            String::from("zeebe-api"),
            Duration::from_secs(30),
            None,
        )
        .build()
        .await?;

    // Wait until first OAuth token has been retrieved
    client.auth_initialized().await;

    // Deploy our pizza ordering process
    // We just discard the result for brevity
    let deploy_resource_response = client
        .deploy_resource()
        .with_resource_file(PathBuf::from("examples/resources/pizza-order.bpmn"))
        .read_resource_files()?
        .send()
        .await?;

    let process_definition_key =
        if let Some(deployment) = deploy_resource_response.deployments().first() {
            match deployment.metadata() {
                Some(metadata) => match metadata {
                    zeebe_rs::Metadata::Process(process_metadata) => {
                        process_metadata.process_definition_key()
                    }
                    _ => {
                        unreachable!("We're only deploying a bpmn here");
                    }
                },
                _ => -1,
            }
        } else {
            -1
        };

    // Let's define our shared state, how much stock we have
    let mut initial_stock = HashMap::new();
    initial_stock.insert(String::from("Pepperoni"), 5);
    initial_stock.insert(String::from("Margherita"), 8);
    initial_stock.insert(String::from("Hawaiian"), 3);
    initial_stock.insert(String::from("Quattro Formaggi"), 0);
    initial_stock.insert(String::from("Vegetarian"), 6);

    let stock = Arc::new(SharedState(Mutex::new(Stock {
        items: initial_stock,
    })));

    // This will share the stock among all the workers confirming orders
    // counting it down for each order.
    let confirm_worker = client
        .worker()
        .with_request_timeout(Duration::from_secs(10))
        .with_job_timeout(Duration::from_secs(10))
        .with_max_jobs_to_activate(4)
        .with_concurrency_limit(2)
        .with_job_type(String::from("confirm_order"))
        .with_state(stock)
        .with_handler(confirm_order)
        .with_fetch_variable(String::from("items"))
        .build();

    // We can reuse the worker builder for sharing some configurations
    let base_worker = client
        .worker()
        .with_request_timeout(Duration::from_secs(10))
        .with_job_timeout(Duration::from_secs(10));

    let bake_worker = base_worker
        .clone()
        .with_max_jobs_to_activate(10)
        .with_concurrency_limit(10)
        .with_job_type(String::from("bake_pizzas"))
        .with_handler(bake_pizzas)
        .build();

    // Handler can be both function callbacks or closures
    // Handlers have to share return type for this to work
    let reject_order_worker = client
        .worker()
        .with_request_timeout(Duration::from_secs(10))
        .with_job_timeout(Duration::from_secs(10))
        .with_max_jobs_to_activate(5)
        .with_concurrency_limit(5)
        .with_job_type(String::from("reject_order"))
        .with_handler(|_client, _job| async move { Ok::<(), WorkerError<()>>(()) })
        .build();

    let deliver_worker = client
        .worker()
        .with_request_timeout(Duration::from_secs(10))
        .with_job_timeout(Duration::from_secs(10))
        .with_max_jobs_to_activate(1)
        .with_concurrency_limit(1)
        .with_job_type(String::from("deliver_order"))
        .with_handler(deliver_order)
        .build();

    let clarify_address_worker = base_worker
        .clone()
        .with_max_jobs_to_activate(5)
        .with_concurrency_limit(5)
        .with_job_type(String::from("call_customer"))
        .with_handler(|client, job| async move {
            let mut customer = job.data::<Customer>().unwrap();

            //Same guy keeps leaving out his address for some reason
            customer.address = String::from("1337 Coolsville, USA");
            if let Ok(req) = client
                .complete_job()
                .with_job_key(job.key())
                .with_variables(customer)
            {
                let _ = req.send().await;
            }
        })
        .build();

    tokio::spawn(place_order(
        client.clone(),
        process_definition_key,
        "Jane Doe",
        "100 Coolsville, USA",
        true,
        vec!["Pepperoni"],
    ));

    tokio::spawn(place_order(
        client.clone(),
        process_definition_key,
        "John Doe",
        "999 NotCoolsville, USA",
        false,
        vec!["Quattro Formaggi"; 100],
    ));

    tokio::spawn(place_order(
        client.clone(),
        process_definition_key,
        "Lorem Ipsum",
        "",
        false,
        vec!["Hawaiian", "Pepperoni"],
    ));

    tokio::spawn(place_order(
        client.clone(),
        process_definition_key,
        "George W Bush",
        "White House",
        true,
        vec!["Burger"],
    ));

    let _ = tokio::join!(
        confirm_worker.run(),
        reject_order_worker.run(),
        bake_worker.run(),
        deliver_worker.run(),
        clarify_address_worker.run(),
    );

    Ok(())
}

impl WorkerBuilder<WithMaxJobs>

pub fn with_concurrency_limit( self, concurrency_limit: u32, ) -> WorkerBuilder<WithConcurrency>

Sets the maximum number of jobs that can be processed concurrently by the worker.

Arguments

• concurrency_limit - The maximum number of jobs that the worker can handle at the same time.

Returns

A WorkerBuilder<WithConcurrency> instance with the concurrency limit set.

Examples found in repository

examples/custom_auto_handler.rs (line 71)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    unsafe { std::env::set_var("RUST_BACKTRACE", "1") };

    // Default configuration using Camunda's docker compose
    // https://github.com/camunda/camunda-platform/blob/5dc74fe71667e18fbb5c8d4694068d662d83ad00/README.md
    let client = Client::builder()
        .with_address("http://localhost", 26500)
        .with_oauth(
            String::from("zeebe"),
            String::from("zecret"),
            String::from(
                "http://localhost:18080/auth/realms/camunda-platform/protocol/openid-connect/token",
            ),
            String::from("zeebe-api"),
            Duration::from_secs(30),
            None,
        )
        .build()
        .await?;

    // Wait until first OAuth token has been retrieved
    client.auth_initialized().await;

    let worker = client
        .worker()
        .with_request_timeout(Duration::from_secs(1))
        .with_job_timeout(Duration::from_secs(1))
        .with_max_jobs_to_activate(1)
        .with_concurrency_limit(1)
        .with_job_type(String::from("placeholder"))
        .with_handler(always_fail)
        .build();

    tokio::join!(worker.run());

    Ok(())
}

examples/pizza.rs (line 141)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    unsafe { std::env::set_var("RUST_BACKTRACE", "1") };

    // Default configuration using Camunda's docker compose
    // https://github.com/camunda/camunda-platform/blob/5dc74fe71667e18fbb5c8d4694068d662d83ad00/README.md
    let client = Client::builder()
        .with_address("http://localhost", 26500)
        .with_oauth(
            String::from("zeebe"),
            String::from("zecret"),
            String::from(
                "http://localhost:18080/auth/realms/camunda-platform/protocol/openid-connect/token",
            ),
            String::from("zeebe-api"),
            Duration::from_secs(30),
            None,
        )
        .build()
        .await?;

    // Wait until first OAuth token has been retrieved
    client.auth_initialized().await;

    // Deploy our pizza ordering process
    // We just discard the result for brevity
    let deploy_resource_response = client
        .deploy_resource()
        .with_resource_file(PathBuf::from("examples/resources/pizza-order.bpmn"))
        .read_resource_files()?
        .send()
        .await?;

    let process_definition_key =
        if let Some(deployment) = deploy_resource_response.deployments().first() {
            match deployment.metadata() {
                Some(metadata) => match metadata {
                    zeebe_rs::Metadata::Process(process_metadata) => {
                        process_metadata.process_definition_key()
                    }
                    _ => {
                        unreachable!("We're only deploying a bpmn here");
                    }
                },
                _ => -1,
            }
        } else {
            -1
        };

    // Let's define our shared state, how much stock we have
    let mut initial_stock = HashMap::new();
    initial_stock.insert(String::from("Pepperoni"), 5);
    initial_stock.insert(String::from("Margherita"), 8);
    initial_stock.insert(String::from("Hawaiian"), 3);
    initial_stock.insert(String::from("Quattro Formaggi"), 0);
    initial_stock.insert(String::from("Vegetarian"), 6);

    let stock = Arc::new(SharedState(Mutex::new(Stock {
        items: initial_stock,
    })));

    // This will share the stock among all the workers confirming orders
    // counting it down for each order.
    let confirm_worker = client
        .worker()
        .with_request_timeout(Duration::from_secs(10))
        .with_job_timeout(Duration::from_secs(10))
        .with_max_jobs_to_activate(4)
        .with_concurrency_limit(2)
        .with_job_type(String::from("confirm_order"))
        .with_state(stock)
        .with_handler(confirm_order)
        .with_fetch_variable(String::from("items"))
        .build();

    // We can reuse the worker builder for sharing some configurations
    let base_worker = client
        .worker()
        .with_request_timeout(Duration::from_secs(10))
        .with_job_timeout(Duration::from_secs(10));

    let bake_worker = base_worker
        .clone()
        .with_max_jobs_to_activate(10)
        .with_concurrency_limit(10)
        .with_job_type(String::from("bake_pizzas"))
        .with_handler(bake_pizzas)
        .build();

    // Handler can be both function callbacks or closures
    // Handlers have to share return type for this to work
    let reject_order_worker = client
        .worker()
        .with_request_timeout(Duration::from_secs(10))
        .with_job_timeout(Duration::from_secs(10))
        .with_max_jobs_to_activate(5)
        .with_concurrency_limit(5)
        .with_job_type(String::from("reject_order"))
        .with_handler(|_client, _job| async move { Ok::<(), WorkerError<()>>(()) })
        .build();

    let deliver_worker = client
        .worker()
        .with_request_timeout(Duration::from_secs(10))
        .with_job_timeout(Duration::from_secs(10))
        .with_max_jobs_to_activate(1)
        .with_concurrency_limit(1)
        .with_job_type(String::from("deliver_order"))
        .with_handler(deliver_order)
        .build();

    let clarify_address_worker = base_worker
        .clone()
        .with_max_jobs_to_activate(5)
        .with_concurrency_limit(5)
        .with_job_type(String::from("call_customer"))
        .with_handler(|client, job| async move {
            let mut customer = job.data::<Customer>().unwrap();

            //Same guy keeps leaving out his address for some reason
            customer.address = String::from("1337 Coolsville, USA");
            if let Ok(req) = client
                .complete_job()
                .with_job_key(job.key())
                .with_variables(customer)
            {
                let _ = req.send().await;
            }
        })
        .build();

    tokio::spawn(place_order(
        client.clone(),
        process_definition_key,
        "Jane Doe",
        "100 Coolsville, USA",
        true,
        vec!["Pepperoni"],
    ));

    tokio::spawn(place_order(
        client.clone(),
        process_definition_key,
        "John Doe",
        "999 NotCoolsville, USA",
        false,
        vec!["Quattro Formaggi"; 100],
    ));

    tokio::spawn(place_order(
        client.clone(),
        process_definition_key,
        "Lorem Ipsum",
        "",
        false,
        vec!["Hawaiian", "Pepperoni"],
    ));

    tokio::spawn(place_order(
        client.clone(),
        process_definition_key,
        "George W Bush",
        "White House",
        true,
        vec!["Burger"],
    ));

    let _ = tokio::join!(
        confirm_worker.run(),
        reject_order_worker.run(),
        bake_worker.run(),
        deliver_worker.run(),
        clarify_address_worker.run(),
    );

    Ok(())
}

impl WorkerBuilder<WithConcurrency>

pub fn with_job_type(self, job_type: String) -> WorkerBuilder<WithJobType>

Sets the job type for the worker.

The job type is defined in the BPMN process, for example: <zeebe:taskDefinition type="payment-service" />.

Parameters

• job_type: A String representing the job type.

Returns

A WorkerBuilder<WithJobType> instance with the job type set.

Examples found in repository

examples/custom_auto_handler.rs (line 72)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    unsafe { std::env::set_var("RUST_BACKTRACE", "1") };

    // Default configuration using Camunda's docker compose
    // https://github.com/camunda/camunda-platform/blob/5dc74fe71667e18fbb5c8d4694068d662d83ad00/README.md
    let client = Client::builder()
        .with_address("http://localhost", 26500)
        .with_oauth(
            String::from("zeebe"),
            String::from("zecret"),
            String::from(
                "http://localhost:18080/auth/realms/camunda-platform/protocol/openid-connect/token",
            ),
            String::from("zeebe-api"),
            Duration::from_secs(30),
            None,
        )
        .build()
        .await?;

    // Wait until first OAuth token has been retrieved
    client.auth_initialized().await;

    let worker = client
        .worker()
        .with_request_timeout(Duration::from_secs(1))
        .with_job_timeout(Duration::from_secs(1))
        .with_max_jobs_to_activate(1)
        .with_concurrency_limit(1)
        .with_job_type(String::from("placeholder"))
        .with_handler(always_fail)
        .build();

    tokio::join!(worker.run());

    Ok(())
}

examples/pizza.rs (line 142)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    unsafe { std::env::set_var("RUST_BACKTRACE", "1") };

    // Default configuration using Camunda's docker compose
    // https://github.com/camunda/camunda-platform/blob/5dc74fe71667e18fbb5c8d4694068d662d83ad00/README.md
    let client = Client::builder()
        .with_address("http://localhost", 26500)
        .with_oauth(
            String::from("zeebe"),
            String::from("zecret"),
            String::from(
                "http://localhost:18080/auth/realms/camunda-platform/protocol/openid-connect/token",
            ),
            String::from("zeebe-api"),
            Duration::from_secs(30),
            None,
        )
        .build()
        .await?;

    // Wait until first OAuth token has been retrieved
    client.auth_initialized().await;

    // Deploy our pizza ordering process
    // We just discard the result for brevity
    let deploy_resource_response = client
        .deploy_resource()
        .with_resource_file(PathBuf::from("examples/resources/pizza-order.bpmn"))
        .read_resource_files()?
        .send()
        .await?;

    let process_definition_key =
        if let Some(deployment) = deploy_resource_response.deployments().first() {
            match deployment.metadata() {
                Some(metadata) => match metadata {
                    zeebe_rs::Metadata::Process(process_metadata) => {
                        process_metadata.process_definition_key()
                    }
                    _ => {
                        unreachable!("We're only deploying a bpmn here");
                    }
                },
                _ => -1,
            }
        } else {
            -1
        };

    // Let's define our shared state, how much stock we have
    let mut initial_stock = HashMap::new();
    initial_stock.insert(String::from("Pepperoni"), 5);
    initial_stock.insert(String::from("Margherita"), 8);
    initial_stock.insert(String::from("Hawaiian"), 3);
    initial_stock.insert(String::from("Quattro Formaggi"), 0);
    initial_stock.insert(String::from("Vegetarian"), 6);

    let stock = Arc::new(SharedState(Mutex::new(Stock {
        items: initial_stock,
    })));

    // This will share the stock among all the workers confirming orders
    // counting it down for each order.
    let confirm_worker = client
        .worker()
        .with_request_timeout(Duration::from_secs(10))
        .with_job_timeout(Duration::from_secs(10))
        .with_max_jobs_to_activate(4)
        .with_concurrency_limit(2)
        .with_job_type(String::from("confirm_order"))
        .with_state(stock)
        .with_handler(confirm_order)
        .with_fetch_variable(String::from("items"))
        .build();

    // We can reuse the worker builder for sharing some configurations
    let base_worker = client
        .worker()
        .with_request_timeout(Duration::from_secs(10))
        .with_job_timeout(Duration::from_secs(10));

    let bake_worker = base_worker
        .clone()
        .with_max_jobs_to_activate(10)
        .with_concurrency_limit(10)
        .with_job_type(String::from("bake_pizzas"))
        .with_handler(bake_pizzas)
        .build();

    // Handler can be both function callbacks or closures
    // Handlers have to share return type for this to work
    let reject_order_worker = client
        .worker()
        .with_request_timeout(Duration::from_secs(10))
        .with_job_timeout(Duration::from_secs(10))
        .with_max_jobs_to_activate(5)
        .with_concurrency_limit(5)
        .with_job_type(String::from("reject_order"))
        .with_handler(|_client, _job| async move { Ok::<(), WorkerError<()>>(()) })
        .build();

    let deliver_worker = client
        .worker()
        .with_request_timeout(Duration::from_secs(10))
        .with_job_timeout(Duration::from_secs(10))
        .with_max_jobs_to_activate(1)
        .with_concurrency_limit(1)
        .with_job_type(String::from("deliver_order"))
        .with_handler(deliver_order)
        .build();

    let clarify_address_worker = base_worker
        .clone()
        .with_max_jobs_to_activate(5)
        .with_concurrency_limit(5)
        .with_job_type(String::from("call_customer"))
        .with_handler(|client, job| async move {
            let mut customer = job.data::<Customer>().unwrap();

            //Same guy keeps leaving out his address for some reason
            customer.address = String::from("1337 Coolsville, USA");
            if let Ok(req) = client
                .complete_job()
                .with_job_key(job.key())
                .with_variables(customer)
            {
                let _ = req.send().await;
            }
        })
        .build();

    tokio::spawn(place_order(
        client.clone(),
        process_definition_key,
        "Jane Doe",
        "100 Coolsville, USA",
        true,
        vec!["Pepperoni"],
    ));

    tokio::spawn(place_order(
        client.clone(),
        process_definition_key,
        "John Doe",
        "999 NotCoolsville, USA",
        false,
        vec!["Quattro Formaggi"; 100],
    ));

    tokio::spawn(place_order(
        client.clone(),
        process_definition_key,
        "Lorem Ipsum",
        "",
        false,
        vec!["Hawaiian", "Pepperoni"],
    ));

    tokio::spawn(place_order(
        client.clone(),
        process_definition_key,
        "George W Bush",
        "White House",
        true,
        vec!["Burger"],
    ));

    let _ = tokio::join!(
        confirm_worker.run(),
        reject_order_worker.run(),
        bake_worker.run(),
        deliver_worker.run(),
        clarify_address_worker.run(),
    );

    Ok(())
}

impl WorkerBuilder<WithJobType>

pub fn with_handler<F, Fut>(self, handler: F) -> WorkerBuilder<WithHandler, F>

where F: Fn(Client, ActivatedJob) -> Fut + Send + 'static, Fut: Future + Send + 'static, Fut::Output: WorkerOutputHandler + Send + 'static,

Sets the handler function for the worker.

Arguments

• handler - A function that takes a Client and an ActivatedJob as arguments and returns a Future that resolves to ().

Returns

Returns a WorkerBuilder with the WithHandler state.

Examples

// You can choose to manually handle returning results from handler functions
async fn example_service(client: Client, job: ActivatedJob) {
    // Your job handling logic here
    // Function has to use the client to return results
    let _ = client.complete_job().with_job_key(job.key()).send().await;
}

client
   .worker()
   .with_job_timeout(Duration::from_secs(5 * 60))
   .with_request_timeout(Duration::from_secs(10))
   .with_max_jobs_to_activate(4)
   .with_concurrency_limit(2)
    .with_job_type(String::from("example-service"))
   .with_handler(example_service)
   ...

If the function is defined to return a Result instead the result is used to automatically set the status of the job.

async fn example_service_with_result(_client: Client, job: ActivatedJob) -> Result<(), WorkerError<()>> {
    Ok(())
}

client
   .worker()
   .with_job_timeout(Duration::from_secs(5 * 60))
   .with_request_timeout(Duration::from_secs(10))
   .with_max_jobs_to_activate(4)
   .with_concurrency_limit(2)
   .with_job_type(String::from("example-service"))
   .with_handler(example_service_with_result)
   ...

This works for closures as well but requires them to be type annotated.

client
    .worker()
    .with_request_timeout(Duration::from_secs(10))
    .with_job_timeout(Duration::from_secs(10))
    .with_max_jobs_to_activate(5)
    .with_concurrency_limit(5)
    .with_job_type(String::from("example_service"))
    .with_handler(|_client, _job| async move { Ok::<(), WorkerError<()>>(()) })
    .build();

Type Parameters

• F - The type of the handler function.
• Fut - The return of F
• Fut::Output - Fut return value that must implement WorkerOutputHandler

Constraints

• F must implement Fn(Client, ActivatedJob) -> Fut and must be Send and 'static.

Examples found in repository

examples/custom_auto_handler.rs (line 73)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    unsafe { std::env::set_var("RUST_BACKTRACE", "1") };

    // Default configuration using Camunda's docker compose
    // https://github.com/camunda/camunda-platform/blob/5dc74fe71667e18fbb5c8d4694068d662d83ad00/README.md
    let client = Client::builder()
        .with_address("http://localhost", 26500)
        .with_oauth(
            String::from("zeebe"),
            String::from("zecret"),
            String::from(
                "http://localhost:18080/auth/realms/camunda-platform/protocol/openid-connect/token",
            ),
            String::from("zeebe-api"),
            Duration::from_secs(30),
            None,
        )
        .build()
        .await?;

    // Wait until first OAuth token has been retrieved
    client.auth_initialized().await;

    let worker = client
        .worker()
        .with_request_timeout(Duration::from_secs(1))
        .with_job_timeout(Duration::from_secs(1))
        .with_max_jobs_to_activate(1)
        .with_concurrency_limit(1)
        .with_job_type(String::from("placeholder"))
        .with_handler(always_fail)
        .build();

    tokio::join!(worker.run());

    Ok(())
}

examples/pizza.rs (line 159)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    unsafe { std::env::set_var("RUST_BACKTRACE", "1") };

    // Default configuration using Camunda's docker compose
    // https://github.com/camunda/camunda-platform/blob/5dc74fe71667e18fbb5c8d4694068d662d83ad00/README.md
    let client = Client::builder()
        .with_address("http://localhost", 26500)
        .with_oauth(
            String::from("zeebe"),
            String::from("zecret"),
            String::from(
                "http://localhost:18080/auth/realms/camunda-platform/protocol/openid-connect/token",
            ),
            String::from("zeebe-api"),
            Duration::from_secs(30),
            None,
        )
        .build()
        .await?;

    // Wait until first OAuth token has been retrieved
    client.auth_initialized().await;

    // Deploy our pizza ordering process
    // We just discard the result for brevity
    let deploy_resource_response = client
        .deploy_resource()
        .with_resource_file(PathBuf::from("examples/resources/pizza-order.bpmn"))
        .read_resource_files()?
        .send()
        .await?;

    let process_definition_key =
        if let Some(deployment) = deploy_resource_response.deployments().first() {
            match deployment.metadata() {
                Some(metadata) => match metadata {
                    zeebe_rs::Metadata::Process(process_metadata) => {
                        process_metadata.process_definition_key()
                    }
                    _ => {
                        unreachable!("We're only deploying a bpmn here");
                    }
                },
                _ => -1,
            }
        } else {
            -1
        };

    // Let's define our shared state, how much stock we have
    let mut initial_stock = HashMap::new();
    initial_stock.insert(String::from("Pepperoni"), 5);
    initial_stock.insert(String::from("Margherita"), 8);
    initial_stock.insert(String::from("Hawaiian"), 3);
    initial_stock.insert(String::from("Quattro Formaggi"), 0);
    initial_stock.insert(String::from("Vegetarian"), 6);

    let stock = Arc::new(SharedState(Mutex::new(Stock {
        items: initial_stock,
    })));

    // This will share the stock among all the workers confirming orders
    // counting it down for each order.
    let confirm_worker = client
        .worker()
        .with_request_timeout(Duration::from_secs(10))
        .with_job_timeout(Duration::from_secs(10))
        .with_max_jobs_to_activate(4)
        .with_concurrency_limit(2)
        .with_job_type(String::from("confirm_order"))
        .with_state(stock)
        .with_handler(confirm_order)
        .with_fetch_variable(String::from("items"))
        .build();

    // We can reuse the worker builder for sharing some configurations
    let base_worker = client
        .worker()
        .with_request_timeout(Duration::from_secs(10))
        .with_job_timeout(Duration::from_secs(10));

    let bake_worker = base_worker
        .clone()
        .with_max_jobs_to_activate(10)
        .with_concurrency_limit(10)
        .with_job_type(String::from("bake_pizzas"))
        .with_handler(bake_pizzas)
        .build();

    // Handler can be both function callbacks or closures
    // Handlers have to share return type for this to work
    let reject_order_worker = client
        .worker()
        .with_request_timeout(Duration::from_secs(10))
        .with_job_timeout(Duration::from_secs(10))
        .with_max_jobs_to_activate(5)
        .with_concurrency_limit(5)
        .with_job_type(String::from("reject_order"))
        .with_handler(|_client, _job| async move { Ok::<(), WorkerError<()>>(()) })
        .build();

    let deliver_worker = client
        .worker()
        .with_request_timeout(Duration::from_secs(10))
        .with_job_timeout(Duration::from_secs(10))
        .with_max_jobs_to_activate(1)
        .with_concurrency_limit(1)
        .with_job_type(String::from("deliver_order"))
        .with_handler(deliver_order)
        .build();

    let clarify_address_worker = base_worker
        .clone()
        .with_max_jobs_to_activate(5)
        .with_concurrency_limit(5)
        .with_job_type(String::from("call_customer"))
        .with_handler(|client, job| async move {
            let mut customer = job.data::<Customer>().unwrap();

            //Same guy keeps leaving out his address for some reason
            customer.address = String::from("1337 Coolsville, USA");
            if let Ok(req) = client
                .complete_job()
                .with_job_key(job.key())
                .with_variables(customer)
            {
                let _ = req.send().await;
            }
        })
        .build();

    tokio::spawn(place_order(
        client.clone(),
        process_definition_key,
        "Jane Doe",
        "100 Coolsville, USA",
        true,
        vec!["Pepperoni"],
    ));

    tokio::spawn(place_order(
        client.clone(),
        process_definition_key,
        "John Doe",
        "999 NotCoolsville, USA",
        false,
        vec!["Quattro Formaggi"; 100],
    ));

    tokio::spawn(place_order(
        client.clone(),
        process_definition_key,
        "Lorem Ipsum",
        "",
        false,
        vec!["Hawaiian", "Pepperoni"],
    ));

    tokio::spawn(place_order(
        client.clone(),
        process_definition_key,
        "George W Bush",
        "White House",
        true,
        vec!["Burger"],
    ));

    let _ = tokio::join!(
        confirm_worker.run(),
        reject_order_worker.run(),
        bake_worker.run(),
        deliver_worker.run(),
        clarify_address_worker.run(),
    );

    Ok(())
}

pub fn with_state<T>( self, state: Arc<SharedState<T>>, ) -> WorkerBuilder<WithState, (), T>

where T: Send + Sync + 'static,

Sets the state that will be shared across all concurrent instances of the worker.

Arguments

• shared_state - An Arc containing the shared state.

Returns

Returns a WorkerStateBuilder with the provided shared state.

Type Parameters

• T - The type of the shared state.

Constraints

• T must be Send, Sync, and 'static.

Examples found in repository

examples/pizza.rs (line 143)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    unsafe { std::env::set_var("RUST_BACKTRACE", "1") };

    // Default configuration using Camunda's docker compose
    // https://github.com/camunda/camunda-platform/blob/5dc74fe71667e18fbb5c8d4694068d662d83ad00/README.md
    let client = Client::builder()
        .with_address("http://localhost", 26500)
        .with_oauth(
            String::from("zeebe"),
            String::from("zecret"),
            String::from(
                "http://localhost:18080/auth/realms/camunda-platform/protocol/openid-connect/token",
            ),
            String::from("zeebe-api"),
            Duration::from_secs(30),
            None,
        )
        .build()
        .await?;

    // Wait until first OAuth token has been retrieved
    client.auth_initialized().await;

    // Deploy our pizza ordering process
    // We just discard the result for brevity
    let deploy_resource_response = client
        .deploy_resource()
        .with_resource_file(PathBuf::from("examples/resources/pizza-order.bpmn"))
        .read_resource_files()?
        .send()
        .await?;

    let process_definition_key =
        if let Some(deployment) = deploy_resource_response.deployments().first() {
            match deployment.metadata() {
                Some(metadata) => match metadata {
                    zeebe_rs::Metadata::Process(process_metadata) => {
                        process_metadata.process_definition_key()
                    }
                    _ => {
                        unreachable!("We're only deploying a bpmn here");
                    }
                },
                _ => -1,
            }
        } else {
            -1
        };

    // Let's define our shared state, how much stock we have
    let mut initial_stock = HashMap::new();
    initial_stock.insert(String::from("Pepperoni"), 5);
    initial_stock.insert(String::from("Margherita"), 8);
    initial_stock.insert(String::from("Hawaiian"), 3);
    initial_stock.insert(String::from("Quattro Formaggi"), 0);
    initial_stock.insert(String::from("Vegetarian"), 6);

    let stock = Arc::new(SharedState(Mutex::new(Stock {
        items: initial_stock,
    })));

    // This will share the stock among all the workers confirming orders
    // counting it down for each order.
    let confirm_worker = client
        .worker()
        .with_request_timeout(Duration::from_secs(10))
        .with_job_timeout(Duration::from_secs(10))
        .with_max_jobs_to_activate(4)
        .with_concurrency_limit(2)
        .with_job_type(String::from("confirm_order"))
        .with_state(stock)
        .with_handler(confirm_order)
        .with_fetch_variable(String::from("items"))
        .build();

    // We can reuse the worker builder for sharing some configurations
    let base_worker = client
        .worker()
        .with_request_timeout(Duration::from_secs(10))
        .with_job_timeout(Duration::from_secs(10));

    let bake_worker = base_worker
        .clone()
        .with_max_jobs_to_activate(10)
        .with_concurrency_limit(10)
        .with_job_type(String::from("bake_pizzas"))
        .with_handler(bake_pizzas)
        .build();

    // Handler can be both function callbacks or closures
    // Handlers have to share return type for this to work
    let reject_order_worker = client
        .worker()
        .with_request_timeout(Duration::from_secs(10))
        .with_job_timeout(Duration::from_secs(10))
        .with_max_jobs_to_activate(5)
        .with_concurrency_limit(5)
        .with_job_type(String::from("reject_order"))
        .with_handler(|_client, _job| async move { Ok::<(), WorkerError<()>>(()) })
        .build();

    let deliver_worker = client
        .worker()
        .with_request_timeout(Duration::from_secs(10))
        .with_job_timeout(Duration::from_secs(10))
        .with_max_jobs_to_activate(1)
        .with_concurrency_limit(1)
        .with_job_type(String::from("deliver_order"))
        .with_handler(deliver_order)
        .build();

    let clarify_address_worker = base_worker
        .clone()
        .with_max_jobs_to_activate(5)
        .with_concurrency_limit(5)
        .with_job_type(String::from("call_customer"))
        .with_handler(|client, job| async move {
            let mut customer = job.data::<Customer>().unwrap();

            //Same guy keeps leaving out his address for some reason
            customer.address = String::from("1337 Coolsville, USA");
            if let Ok(req) = client
                .complete_job()
                .with_job_key(job.key())
                .with_variables(customer)
            {
                let _ = req.send().await;
            }
        })
        .build();

    tokio::spawn(place_order(
        client.clone(),
        process_definition_key,
        "Jane Doe",
        "100 Coolsville, USA",
        true,
        vec!["Pepperoni"],
    ));

    tokio::spawn(place_order(
        client.clone(),
        process_definition_key,
        "John Doe",
        "999 NotCoolsville, USA",
        false,
        vec!["Quattro Formaggi"; 100],
    ));

    tokio::spawn(place_order(
        client.clone(),
        process_definition_key,
        "Lorem Ipsum",
        "",
        false,
        vec!["Hawaiian", "Pepperoni"],
    ));

    tokio::spawn(place_order(
        client.clone(),
        process_definition_key,
        "George W Bush",
        "White House",
        true,
        vec!["Burger"],
    ));

    let _ = tokio::join!(
        confirm_worker.run(),
        reject_order_worker.run(),
        bake_worker.run(),
        deliver_worker.run(),
        clarify_address_worker.run(),
    );

    Ok(())
}

impl<T> WorkerBuilder<WithState, (), T>

where T: Send + Sync + 'static,

pub fn with_handler<F, Fut>( self, handler: F, ) -> WorkerBuilder<WithHandler, (F, Arc<SharedState<T>>), T>

where F: Fn(Client, ActivatedJob, Arc<SharedState<T>>) -> Fut + Send + 'static, Fut: Future + Send + 'static, Fut::Output: WorkerOutputHandler + Send + 'static,

Examples found in repository

examples/pizza.rs (line 144)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    unsafe { std::env::set_var("RUST_BACKTRACE", "1") };

    // Default configuration using Camunda's docker compose
    // https://github.com/camunda/camunda-platform/blob/5dc74fe71667e18fbb5c8d4694068d662d83ad00/README.md
    let client = Client::builder()
        .with_address("http://localhost", 26500)
        .with_oauth(
            String::from("zeebe"),
            String::from("zecret"),
            String::from(
                "http://localhost:18080/auth/realms/camunda-platform/protocol/openid-connect/token",
            ),
            String::from("zeebe-api"),
            Duration::from_secs(30),
            None,
        )
        .build()
        .await?;

    // Wait until first OAuth token has been retrieved
    client.auth_initialized().await;

    // Deploy our pizza ordering process
    // We just discard the result for brevity
    let deploy_resource_response = client
        .deploy_resource()
        .with_resource_file(PathBuf::from("examples/resources/pizza-order.bpmn"))
        .read_resource_files()?
        .send()
        .await?;

    let process_definition_key =
        if let Some(deployment) = deploy_resource_response.deployments().first() {
            match deployment.metadata() {
                Some(metadata) => match metadata {
                    zeebe_rs::Metadata::Process(process_metadata) => {
                        process_metadata.process_definition_key()
                    }
                    _ => {
                        unreachable!("We're only deploying a bpmn here");
                    }
                },
                _ => -1,
            }
        } else {
            -1
        };

    // Let's define our shared state, how much stock we have
    let mut initial_stock = HashMap::new();
    initial_stock.insert(String::from("Pepperoni"), 5);
    initial_stock.insert(String::from("Margherita"), 8);
    initial_stock.insert(String::from("Hawaiian"), 3);
    initial_stock.insert(String::from("Quattro Formaggi"), 0);
    initial_stock.insert(String::from("Vegetarian"), 6);

    let stock = Arc::new(SharedState(Mutex::new(Stock {
        items: initial_stock,
    })));

    // This will share the stock among all the workers confirming orders
    // counting it down for each order.
    let confirm_worker = client
        .worker()
        .with_request_timeout(Duration::from_secs(10))
        .with_job_timeout(Duration::from_secs(10))
        .with_max_jobs_to_activate(4)
        .with_concurrency_limit(2)
        .with_job_type(String::from("confirm_order"))
        .with_state(stock)
        .with_handler(confirm_order)
        .with_fetch_variable(String::from("items"))
        .build();

    // We can reuse the worker builder for sharing some configurations
    let base_worker = client
        .worker()
        .with_request_timeout(Duration::from_secs(10))
        .with_job_timeout(Duration::from_secs(10));

    let bake_worker = base_worker
        .clone()
        .with_max_jobs_to_activate(10)
        .with_concurrency_limit(10)
        .with_job_type(String::from("bake_pizzas"))
        .with_handler(bake_pizzas)
        .build();

    // Handler can be both function callbacks or closures
    // Handlers have to share return type for this to work
    let reject_order_worker = client
        .worker()
        .with_request_timeout(Duration::from_secs(10))
        .with_job_timeout(Duration::from_secs(10))
        .with_max_jobs_to_activate(5)
        .with_concurrency_limit(5)
        .with_job_type(String::from("reject_order"))
        .with_handler(|_client, _job| async move { Ok::<(), WorkerError<()>>(()) })
        .build();

    let deliver_worker = client
        .worker()
        .with_request_timeout(Duration::from_secs(10))
        .with_job_timeout(Duration::from_secs(10))
        .with_max_jobs_to_activate(1)
        .with_concurrency_limit(1)
        .with_job_type(String::from("deliver_order"))
        .with_handler(deliver_order)
        .build();

    let clarify_address_worker = base_worker
        .clone()
        .with_max_jobs_to_activate(5)
        .with_concurrency_limit(5)
        .with_job_type(String::from("call_customer"))
        .with_handler(|client, job| async move {
            let mut customer = job.data::<Customer>().unwrap();

            //Same guy keeps leaving out his address for some reason
            customer.address = String::from("1337 Coolsville, USA");
            if let Ok(req) = client
                .complete_job()
                .with_job_key(job.key())
                .with_variables(customer)
            {
                let _ = req.send().await;
            }
        })
        .build();

    tokio::spawn(place_order(
        client.clone(),
        process_definition_key,
        "Jane Doe",
        "100 Coolsville, USA",
        true,
        vec!["Pepperoni"],
    ));

    tokio::spawn(place_order(
        client.clone(),
        process_definition_key,
        "John Doe",
        "999 NotCoolsville, USA",
        false,
        vec!["Quattro Formaggi"; 100],
    ));

    tokio::spawn(place_order(
        client.clone(),
        process_definition_key,
        "Lorem Ipsum",
        "",
        false,
        vec!["Hawaiian", "Pepperoni"],
    ));

    tokio::spawn(place_order(
        client.clone(),
        process_definition_key,
        "George W Bush",
        "White House",
        true,
        vec!["Burger"],
    ));

    let _ = tokio::join!(
        confirm_worker.run(),
        reject_order_worker.run(),
        bake_worker.run(),
        deliver_worker.run(),
        clarify_address_worker.run(),
    );

    Ok(())
}

impl<H, T> WorkerBuilder<WithHandler, H, T>

where H: JobHandler + Send + Sync + 'static, T: Send + Sync + 'static,

pub fn build(self) -> Worker<H>

Builds a Worker using the collected inputs.

Returns

• Worker - The constructed Worker instance

Examples found in repository

examples/custom_auto_handler.rs (line 74)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    unsafe { std::env::set_var("RUST_BACKTRACE", "1") };

    // Default configuration using Camunda's docker compose
    // https://github.com/camunda/camunda-platform/blob/5dc74fe71667e18fbb5c8d4694068d662d83ad00/README.md
    let client = Client::builder()
        .with_address("http://localhost", 26500)
        .with_oauth(
            String::from("zeebe"),
            String::from("zecret"),
            String::from(
                "http://localhost:18080/auth/realms/camunda-platform/protocol/openid-connect/token",
            ),
            String::from("zeebe-api"),
            Duration::from_secs(30),
            None,
        )
        .build()
        .await?;

    // Wait until first OAuth token has been retrieved
    client.auth_initialized().await;

    let worker = client
        .worker()
        .with_request_timeout(Duration::from_secs(1))
        .with_job_timeout(Duration::from_secs(1))
        .with_max_jobs_to_activate(1)
        .with_concurrency_limit(1)
        .with_job_type(String::from("placeholder"))
        .with_handler(always_fail)
        .build();

    tokio::join!(worker.run());

    Ok(())
}

examples/pizza.rs (line 146)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    unsafe { std::env::set_var("RUST_BACKTRACE", "1") };

    // Default configuration using Camunda's docker compose
    // https://github.com/camunda/camunda-platform/blob/5dc74fe71667e18fbb5c8d4694068d662d83ad00/README.md
    let client = Client::builder()
        .with_address("http://localhost", 26500)
        .with_oauth(
            String::from("zeebe"),
            String::from("zecret"),
            String::from(
                "http://localhost:18080/auth/realms/camunda-platform/protocol/openid-connect/token",
            ),
            String::from("zeebe-api"),
            Duration::from_secs(30),
            None,
        )
        .build()
        .await?;

    // Wait until first OAuth token has been retrieved
    client.auth_initialized().await;

    // Deploy our pizza ordering process
    // We just discard the result for brevity
    let deploy_resource_response = client
        .deploy_resource()
        .with_resource_file(PathBuf::from("examples/resources/pizza-order.bpmn"))
        .read_resource_files()?
        .send()
        .await?;

    let process_definition_key =
        if let Some(deployment) = deploy_resource_response.deployments().first() {
            match deployment.metadata() {
                Some(metadata) => match metadata {
                    zeebe_rs::Metadata::Process(process_metadata) => {
                        process_metadata.process_definition_key()
                    }
                    _ => {
                        unreachable!("We're only deploying a bpmn here");
                    }
                },
                _ => -1,
            }
        } else {
            -1
        };

    // Let's define our shared state, how much stock we have
    let mut initial_stock = HashMap::new();
    initial_stock.insert(String::from("Pepperoni"), 5);
    initial_stock.insert(String::from("Margherita"), 8);
    initial_stock.insert(String::from("Hawaiian"), 3);
    initial_stock.insert(String::from("Quattro Formaggi"), 0);
    initial_stock.insert(String::from("Vegetarian"), 6);

    let stock = Arc::new(SharedState(Mutex::new(Stock {
        items: initial_stock,
    })));

    // This will share the stock among all the workers confirming orders
    // counting it down for each order.
    let confirm_worker = client
        .worker()
        .with_request_timeout(Duration::from_secs(10))
        .with_job_timeout(Duration::from_secs(10))
        .with_max_jobs_to_activate(4)
        .with_concurrency_limit(2)
        .with_job_type(String::from("confirm_order"))
        .with_state(stock)
        .with_handler(confirm_order)
        .with_fetch_variable(String::from("items"))
        .build();

    // We can reuse the worker builder for sharing some configurations
    let base_worker = client
        .worker()
        .with_request_timeout(Duration::from_secs(10))
        .with_job_timeout(Duration::from_secs(10));

    let bake_worker = base_worker
        .clone()
        .with_max_jobs_to_activate(10)
        .with_concurrency_limit(10)
        .with_job_type(String::from("bake_pizzas"))
        .with_handler(bake_pizzas)
        .build();

    // Handler can be both function callbacks or closures
    // Handlers have to share return type for this to work
    let reject_order_worker = client
        .worker()
        .with_request_timeout(Duration::from_secs(10))
        .with_job_timeout(Duration::from_secs(10))
        .with_max_jobs_to_activate(5)
        .with_concurrency_limit(5)
        .with_job_type(String::from("reject_order"))
        .with_handler(|_client, _job| async move { Ok::<(), WorkerError<()>>(()) })
        .build();

    let deliver_worker = client
        .worker()
        .with_request_timeout(Duration::from_secs(10))
        .with_job_timeout(Duration::from_secs(10))
        .with_max_jobs_to_activate(1)
        .with_concurrency_limit(1)
        .with_job_type(String::from("deliver_order"))
        .with_handler(deliver_order)
        .build();

    let clarify_address_worker = base_worker
        .clone()
        .with_max_jobs_to_activate(5)
        .with_concurrency_limit(5)
        .with_job_type(String::from("call_customer"))
        .with_handler(|client, job| async move {
            let mut customer = job.data::<Customer>().unwrap();

            //Same guy keeps leaving out his address for some reason
            customer.address = String::from("1337 Coolsville, USA");
            if let Ok(req) = client
                .complete_job()
                .with_job_key(job.key())
                .with_variables(customer)
            {
                let _ = req.send().await;
            }
        })
        .build();

    tokio::spawn(place_order(
        client.clone(),
        process_definition_key,
        "Jane Doe",
        "100 Coolsville, USA",
        true,
        vec!["Pepperoni"],
    ));

    tokio::spawn(place_order(
        client.clone(),
        process_definition_key,
        "John Doe",
        "999 NotCoolsville, USA",
        false,
        vec!["Quattro Formaggi"; 100],
    ));

    tokio::spawn(place_order(
        client.clone(),
        process_definition_key,
        "Lorem Ipsum",
        "",
        false,
        vec!["Hawaiian", "Pepperoni"],
    ));

    tokio::spawn(place_order(
        client.clone(),
        process_definition_key,
        "George W Bush",
        "White House",
        true,
        vec!["Burger"],
    ));

    let _ = tokio::join!(
        confirm_worker.run(),
        reject_order_worker.run(),
        bake_worker.run(),
        deliver_worker.run(),
        clarify_address_worker.run(),
    );

    Ok(())
}

pub fn with_worker_name(self, worker_name: String) -> Self

Sets the worker name.

Arguments

• worker_name - A String representing the name of the worker.

Returns

• Self - The updated WorkerBuilder instance.

pub fn with_fetch_variable(self, fetch_variable: String) -> Self

Adds a single variable to fetch.

A list of variables to fetch as the job variables; if empty, all visible variables at the time of activation for the scope of the job will be returned

Arguments

• fetch_variable - A String representing the variable to fetch.

Returns

• Self - The updated WorkerBuilder instance.

Examples found in repository

examples/pizza.rs (line 145)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    unsafe { std::env::set_var("RUST_BACKTRACE", "1") };

    // Default configuration using Camunda's docker compose
    // https://github.com/camunda/camunda-platform/blob/5dc74fe71667e18fbb5c8d4694068d662d83ad00/README.md
    let client = Client::builder()
        .with_address("http://localhost", 26500)
        .with_oauth(
            String::from("zeebe"),
            String::from("zecret"),
            String::from(
                "http://localhost:18080/auth/realms/camunda-platform/protocol/openid-connect/token",
            ),
            String::from("zeebe-api"),
            Duration::from_secs(30),
            None,
        )
        .build()
        .await?;

    // Wait until first OAuth token has been retrieved
    client.auth_initialized().await;

    // Deploy our pizza ordering process
    // We just discard the result for brevity
    let deploy_resource_response = client
        .deploy_resource()
        .with_resource_file(PathBuf::from("examples/resources/pizza-order.bpmn"))
        .read_resource_files()?
        .send()
        .await?;

    let process_definition_key =
        if let Some(deployment) = deploy_resource_response.deployments().first() {
            match deployment.metadata() {
                Some(metadata) => match metadata {
                    zeebe_rs::Metadata::Process(process_metadata) => {
                        process_metadata.process_definition_key()
                    }
                    _ => {
                        unreachable!("We're only deploying a bpmn here");
                    }
                },
                _ => -1,
            }
        } else {
            -1
        };

    // Let's define our shared state, how much stock we have
    let mut initial_stock = HashMap::new();
    initial_stock.insert(String::from("Pepperoni"), 5);
    initial_stock.insert(String::from("Margherita"), 8);
    initial_stock.insert(String::from("Hawaiian"), 3);
    initial_stock.insert(String::from("Quattro Formaggi"), 0);
    initial_stock.insert(String::from("Vegetarian"), 6);

    let stock = Arc::new(SharedState(Mutex::new(Stock {
        items: initial_stock,
    })));

    // This will share the stock among all the workers confirming orders
    // counting it down for each order.
    let confirm_worker = client
        .worker()
        .with_request_timeout(Duration::from_secs(10))
        .with_job_timeout(Duration::from_secs(10))
        .with_max_jobs_to_activate(4)
        .with_concurrency_limit(2)
        .with_job_type(String::from("confirm_order"))
        .with_state(stock)
        .with_handler(confirm_order)
        .with_fetch_variable(String::from("items"))
        .build();

    // We can reuse the worker builder for sharing some configurations
    let base_worker = client
        .worker()
        .with_request_timeout(Duration::from_secs(10))
        .with_job_timeout(Duration::from_secs(10));

    let bake_worker = base_worker
        .clone()
        .with_max_jobs_to_activate(10)
        .with_concurrency_limit(10)
        .with_job_type(String::from("bake_pizzas"))
        .with_handler(bake_pizzas)
        .build();

    // Handler can be both function callbacks or closures
    // Handlers have to share return type for this to work
    let reject_order_worker = client
        .worker()
        .with_request_timeout(Duration::from_secs(10))
        .with_job_timeout(Duration::from_secs(10))
        .with_max_jobs_to_activate(5)
        .with_concurrency_limit(5)
        .with_job_type(String::from("reject_order"))
        .with_handler(|_client, _job| async move { Ok::<(), WorkerError<()>>(()) })
        .build();

    let deliver_worker = client
        .worker()
        .with_request_timeout(Duration::from_secs(10))
        .with_job_timeout(Duration::from_secs(10))
        .with_max_jobs_to_activate(1)
        .with_concurrency_limit(1)
        .with_job_type(String::from("deliver_order"))
        .with_handler(deliver_order)
        .build();

    let clarify_address_worker = base_worker
        .clone()
        .with_max_jobs_to_activate(5)
        .with_concurrency_limit(5)
        .with_job_type(String::from("call_customer"))
        .with_handler(|client, job| async move {
            let mut customer = job.data::<Customer>().unwrap();

            //Same guy keeps leaving out his address for some reason
            customer.address = String::from("1337 Coolsville, USA");
            if let Ok(req) = client
                .complete_job()
                .with_job_key(job.key())
                .with_variables(customer)
            {
                let _ = req.send().await;
            }
        })
        .build();

    tokio::spawn(place_order(
        client.clone(),
        process_definition_key,
        "Jane Doe",
        "100 Coolsville, USA",
        true,
        vec!["Pepperoni"],
    ));

    tokio::spawn(place_order(
        client.clone(),
        process_definition_key,
        "John Doe",
        "999 NotCoolsville, USA",
        false,
        vec!["Quattro Formaggi"; 100],
    ));

    tokio::spawn(place_order(
        client.clone(),
        process_definition_key,
        "Lorem Ipsum",
        "",
        false,
        vec!["Hawaiian", "Pepperoni"],
    ));

    tokio::spawn(place_order(
        client.clone(),
        process_definition_key,
        "George W Bush",
        "White House",
        true,
        vec!["Burger"],
    ));

    let _ = tokio::join!(
        confirm_worker.run(),
        reject_order_worker.run(),
        bake_worker.run(),
        deliver_worker.run(),
        clarify_address_worker.run(),
    );

    Ok(())
}

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

Adds multiple variables to fetch.

A list of variables to fetch as the job variables; if empty, all visible variables at the time of activation for the scope of the job will be returned

Arguments

• fetch_variables - A Vec<String> representing the variables to fetch.

Returns

• Self - The updated WorkerBuilder instance.

pub fn with_tenant_id(self, tenant_id: String) -> Self

Adds a single tenant ID.

Arguments

• tenant_id - A String representing the tenant ID.

Returns

• Self - The updated WorkerBuilder instance.

pub fn with_tenant_ids(self, tenant_ids: Vec<String>) -> Self

Adds multiple tenant IDs.

Arguments

• tenant_ids - A Vec<String> representing the tenant IDs.

Returns

• Self - The updated WorkerBuilder instance.

Trait Implementations

impl<S, H: Clone, T> Clone for WorkerBuilder<S, H, T>

where S: WorkerBuilderState + Clone, T: Send + Sync + 'static + Clone,

fn clone(&self) -> WorkerBuilder<S, H, T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.