Struct ClientBuilder 

pub struct ClientBuilder<S: ClientBuilderState> { /* private fields */ }

A builder for configuring and creating a Client.

The ClientBuilder allows you to configure various aspects of the client, such as the endpoint, TLS settings, timeouts, and OAuth configuration.

Implementations

impl ClientBuilder<Initial>

pub fn with_address( self, zeebe_address: &str, port: u16, ) -> ClientBuilder<WithAddress>

Sets the endpoint for the Zeebe client.

Arguments

• zeebe_address - A string slice that holds the address of the Zeebe broker.
• port - A 16-bit unsigned integer that holds the port number of the Zeebe broker.

Returns

A ClientBuilder<WithAddress> instance with the Zeebe endpoint set.

Examples found in repository

examples/hello_client.rs (line 4)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = zeebe_rs::Client::builder()
        .with_address("http://localhost", 26500)
        .build()
        .await?;

    let topology = client.topology().send().await;
    println!("{:?}", topology);

    Ok(())
}

examples/oauth.rs (line 13)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    unsafe { std::env::set_var("RUST_BACKTRACE", "1") };
    let client = zeebe_rs::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?;

    let _ = client.auth_initialized().await;
    let topology = client.topology().send().await;
    println!("{:?}", topology);

    Ok(())
}

examples/custom_auto_handler.rs (line 49)

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/deploy_resource.rs (line 21)

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

    let client = zeebe_rs::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?;

    let _ = client.auth_initialized().await;
    let result = client
        .deploy_resource()
        .with_resource_file(PathBuf::from("./examples/resources/hello_world.bpmn"))
        .read_resource_files()?
        .send()
        .await?;

    println!("{:?}", result);

    let result = client
        .publish_message()
        .with_name(String::from("hello_world"))
        .without_correlation_key()
        .with_variables(HelloWorld {
            hello: String::from("foo"),
        })?
        .send()
        .await?;

    println!("{:?}", result);

    sleep(Duration::from_secs(1)).await;

    let result = client
        .publish_message()
        .with_name(String::from("hello_message"))
        .with_correlation_key(String::from("foo"))
        .send()
        .await?;

    println!("{:?}", result);

    Ok(())
}

examples/pizza.rs (line 79)

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 ClientBuilder<WithAddress>

pub fn with_oauth( self, client_id: String, client_secret: String, auth_url: String, audience: String, auth_timeout: Duration, auth_type: Option<AuthType>, ) -> Self

Configures OAuth authentication for the client.

Arguments

• client_id - The client ID for OAuth authentication.
• client_secret - The client secret for OAuth authentication.
• auth_url - The URL for the OAuth authentication server.
• audience - The audience for the OAuth token.
• auth_timeout - The timeout duration for the OAuth authentication process.
• auth_type - If OAuth credentials should use request body or basic auth, defaults to request body

Returns

A ClientBuilder<WithAddress> instance with OAuth configuration set.

Examples found in repository

examples/oauth.rs (lines 14-23)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    unsafe { std::env::set_var("RUST_BACKTRACE", "1") };
    let client = zeebe_rs::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?;

    let _ = client.auth_initialized().await;
    let topology = client.topology().send().await;
    println!("{:?}", topology);

    Ok(())
}

examples/custom_auto_handler.rs (lines 50-59)

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/deploy_resource.rs (lines 22-31)

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

    let client = zeebe_rs::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?;

    let _ = client.auth_initialized().await;
    let result = client
        .deploy_resource()
        .with_resource_file(PathBuf::from("./examples/resources/hello_world.bpmn"))
        .read_resource_files()?
        .send()
        .await?;

    println!("{:?}", result);

    let result = client
        .publish_message()
        .with_name(String::from("hello_world"))
        .without_correlation_key()
        .with_variables(HelloWorld {
            hello: String::from("foo"),
        })?
        .send()
        .await?;

    println!("{:?}", result);

    sleep(Duration::from_secs(1)).await;

    let result = client
        .publish_message()
        .with_name(String::from("hello_message"))
        .with_correlation_key(String::from("foo"))
        .send()
        .await?;

    println!("{:?}", result);

    Ok(())
}

examples/pizza.rs (lines 80-89)

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_cloud_tls(self) -> Self

Configures TLS for the client root certificates required for Camunda Cloud

Returns

A ClientBuilder<WithAddress> instance with tls configuration set.

pub fn with_tls(self, pem: &Path) -> Result<Self, ClientBuilderError>

Configures TLS for the client using a PEM file.

Arguments

• pem - The path to the PEM file containing the TLS certificate.

Returns

A Result containing either a ClientBuilder<WithAddress> instance with TLS configuration set, or a ClientBuilderError if reading the PEM file fails.

pub async fn build(self) -> Result<Client, ClientBuilderError>

Builds the client with the configured settings.

Returns

A Result containing either a Client instance or a ClientBuilderError if the client could not be built.

Examples found in repository

examples/hello_client.rs (line 5)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = zeebe_rs::Client::builder()
        .with_address("http://localhost", 26500)
        .build()
        .await?;

    let topology = client.topology().send().await;
    println!("{:?}", topology);

    Ok(())
}

examples/oauth.rs (line 24)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    unsafe { std::env::set_var("RUST_BACKTRACE", "1") };
    let client = zeebe_rs::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?;

    let _ = client.auth_initialized().await;
    let topology = client.topology().send().await;
    println!("{:?}", topology);

    Ok(())
}

examples/custom_auto_handler.rs (line 60)

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/deploy_resource.rs (line 32)

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

    let client = zeebe_rs::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?;

    let _ = client.auth_initialized().await;
    let result = client
        .deploy_resource()
        .with_resource_file(PathBuf::from("./examples/resources/hello_world.bpmn"))
        .read_resource_files()?
        .send()
        .await?;

    println!("{:?}", result);

    let result = client
        .publish_message()
        .with_name(String::from("hello_world"))
        .without_correlation_key()
        .with_variables(HelloWorld {
            hello: String::from("foo"),
        })?
        .send()
        .await?;

    println!("{:?}", result);

    sleep(Duration::from_secs(1)).await;

    let result = client
        .publish_message()
        .with_name(String::from("hello_message"))
        .with_correlation_key(String::from("foo"))
        .send()
        .await?;

    println!("{:?}", result);

    Ok(())
}

examples/pizza.rs (line 90)

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_timeout(self, timeout: Duration) -> Self

Sets the timeout duration for the client.

Arguments

• timeout - The timeout duration.

Returns

A ClientBuilder<WithAddress> instance with the timeout configuration set.

pub fn with_keep_alive(self, keep_alive: Duration) -> Self

Sets the keep-alive duration for the client.

Arguments

• keep_alive - The keep-alive duration.

Returns

A ClientBuilder<WithAddress> instance with the keep-alive configuration set.

Trait Implementations

impl<S: Clone + ClientBuilderState> Clone for ClientBuilder<S>

fn clone(&self) -> ClientBuilder<S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: Debug + ClientBuilderState> Debug for ClientBuilder<S>

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

Formats the value using the given formatter.

impl<S: ClientBuilderState + Default> Default for ClientBuilder<S>

fn default() -> Self

Returns the “default value” for a type.