use std::collections::HashMap;
use conductor::client::WorkflowStateUpdate;
use conductor::{
Configuration, OrkesClients, StartWorkflowRequest, TaskResult, TaskResultStatus, WorkflowDef,
WorkflowTask,
};
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
tracing_subscriber::fmt::init();
let config = Configuration::default();
let clients = OrkesClients::new(config.clone())?;
let workflow_client = clients.get_workflow_client();
let metadata_client = clients.get_metadata_client();
let http_task = WorkflowTask::http(
"http_ref",
"https://orkes-api-tester.orkesconductor.com/api",
);
let wait_task = WorkflowTask::wait("wait_task_ref");
let wait_case_1 = WorkflowTask::wait("wait_task_ref_1");
let wait_case_2 = WorkflowTask::wait("wait_task_ref_2");
let switch_task = WorkflowTask::switch("switch_ref", "${workflow.variables.case}")
.with_switch_case("case1", vec![wait_case_1])
.with_switch_case("case2", vec![wait_case_2]);
let workflow_def = WorkflowDef::new("sync_task_variable_updates")
.with_description("Demonstrates synchronous state updates")
.with_version(1)
.with_task(http_task)
.with_task(wait_task)
.with_task(switch_task);
metadata_client
.register_or_update_workflow_def(&workflow_def, true)
.await?;
println!("Workflow registered: {}", workflow_def.name);
let request = StartWorkflowRequest::new(&workflow_def.name).with_version(1);
println!("\nStarting workflow and waiting for wait_task_ref...");
let workflow_run = workflow_client
.execute_workflow_with_return_strategy(
&request,
None,
Some("wait_task_ref"),
10,
None,
None,
)
.await?;
let workflow_id = &workflow_run.workflow_id;
println!("Workflow started: {workflow_id}");
println!(
"See execution at: {}/execution/{}",
config.ui_host, workflow_id
);
println!("\nCompleting wait_task_ref and setting variable 'case' to 'case1'...");
let task_result = TaskResult {
status: TaskResultStatus::Completed,
..Default::default()
};
let mut variables = HashMap::new();
variables.insert("case".to_owned(), serde_json::json!("case1"));
let state_update = WorkflowStateUpdate {
task_reference_name: Some("wait_task_ref".to_owned()),
task_result: Some(task_result.clone()),
variables,
};
let workflow_run = workflow_client
.update_state(
workflow_id,
&state_update,
Some(&["wait_task_ref_1".to_owned(), "wait_task_ref_2".to_owned()]),
Some(5),
)
.await?;
println!(
"Workflow status after first update: {:?}",
workflow_run.status
);
let last_task_ref = workflow_run
.tasks
.last()
.map_or("unknown", |t| t.reference_task_name.as_str());
println!("Last task: {last_task_ref} (expected wait_task_ref_1)");
println!("\nCompleting {last_task_ref}...");
let final_update = WorkflowStateUpdate {
task_reference_name: Some(last_task_ref.to_owned()),
task_result: Some(task_result),
variables: HashMap::new(),
};
let final_run = workflow_client
.update_state(workflow_id, &final_update, None, Some(5))
.await?;
println!("Final workflow status: {:?}", final_run.status);
Ok(())
}