orka 0.3.1

An asynchronous, pluggable, and type-safe workflow engine for Rust, designed for orchestrating complex multi-step business processes.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

use orka::{ContextData, OrkaError, Pipeline, PipelineControl, PipelineResult};
use tracing::info;

#[derive(Clone, Debug, Default)]
struct BasicContext {
  message_log: Vec<String>,
  counter: i32,
}

// This example uses `OrkaError` directly as its handler error type. Real applications
// usually define their own error with `#[from] OrkaError`; see `error_handling.rs`.
#[tokio::main]
async fn main() -> Result<(), OrkaError> {
  tracing_subscriber::fmt().with_max_level(tracing::Level::INFO).init();

  info!("--- Basic Pipeline Example ---");

  let mut pipeline = Pipeline::<BasicContext, OrkaError>::new(["step_alpha", "step_beta", "step_gamma"]);

  pipeline
    .on_root("step_alpha", |ctx| async move {
      let mut data = ctx.write();
      data.counter += 1;
      let msg = format!("Alpha executed: counter = {}", data.counter);
      info!("{}", msg);
      data.message_log.push(msg);
      Ok(PipelineControl::Continue)
    })
    .on_root("step_beta", |ctx| async move {
      let mut data = ctx.write();
      data.counter *= 2;
      let msg = format!("Beta executed: counter = {}", data.counter);
      info!("{}", msg);
      data.message_log.push(msg);
      Ok(PipelineControl::Continue)
    })
    .on_root("step_gamma", |ctx| async move {
      let mut data = ctx.write();
      data.counter -= 1;
      let msg = format!("Gamma executed: counter = {}", data.counter);
      info!("{}", msg);
      data.message_log.push(msg);
      Ok(PipelineControl::Continue)
    });

  let pipeline_context = ContextData::new(BasicContext {
    message_log: Vec::new(),
    counter: 5,
  });

  info!("Starting pipeline execution...");
  let result = pipeline.run(pipeline_context.clone()).await?;

  match result {
    PipelineResult::Completed => info!("Pipeline completed successfully!"),
    PipelineResult::Stopped => info!("Pipeline was stopped early."),
    other => info!("Pipeline ended as {:?}.", other),
  }

  let final_context_state = pipeline_context.read();
  info!("Final counter value: {}", final_context_state.counter);
  info!("Execution log:");
  for log_entry in &final_context_state.message_log {
    info!("- {}", log_entry);
  }

  // (5 + 1) * 2 - 1 = 11
  assert_eq!(final_context_state.counter, 11);
  assert_eq!(final_context_state.message_log.len(), 3);

  Ok(())
}