colonyos 1.0.5

Rust SDK for ColonyOS - build distributed applications with executors that can run anywhere
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
73
74
75
76
77
78
79
80
81

//! Submit Process Example
//!
//! This example demonstrates how to submit a process and wait for its completion.
//!
//! Run with: cargo run --example submit_process

use colonyos::core::{FunctionSpec, SUCCESS, FAILED, WAITING, RUNNING};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let colonyname = "dev";
    let prvkey = "ddf7f7791208083b6a9ed975a72684f6406a269cfa36f1b1c32045c0a71fff05";

    println!("=== Submitting a process ===\n");

    // Create a function spec
    let mut spec = FunctionSpec::new("echo", "cli", colonyname);
    spec.args = vec!["Hello from Rust SDK!".to_string()];
    spec.maxexectime = 60;  // Max 60 seconds to execute
    spec.maxwaittime = 300; // Max 5 minutes waiting in queue
    spec.maxretries = 3;    // Retry up to 3 times on failure

    // Add environment variables
    spec.env.insert("MY_VAR".to_string(), "my_value".to_string());

    // Submit the process
    let process = colonyos::submit(&spec, prvkey).await?;
    println!("Submitted process: {}", process.processid);
    println!("Function: {}", spec.funcname);
    println!("Args: {:?}", spec.args);
    println!("State: WAITING\n");

    // Wait for completion
    println!("Waiting for completion...");
    let mut last_state = WAITING;

    loop {
        let p = colonyos::get_process(&process.processid, prvkey).await?;

        // Print state changes
        if p.state != last_state {
            match p.state {
                WAITING => println!("State: WAITING"),
                RUNNING => println!("State: RUNNING (assigned to executor)"),
                SUCCESS => println!("State: SUCCESS"),
                FAILED => println!("State: FAILED"),
                _ => println!("State: {}", p.state),
            }
            last_state = p.state;
        }

        match p.state {
            SUCCESS => {
                println!("\n=== Process Completed Successfully ===");
                println!("Output: {:?}", p.output);
                if !p.attributes.is_empty() {
                    println!("Attributes:");
                    for attr in &p.attributes {
                        println!("  {}: {}", attr.key, attr.value);
                    }
                }
                break;
            }
            FAILED => {
                println!("\n=== Process Failed ===");
                println!("Errors: {:?}", p.errors);
                break;
            }
            _ => {
                // Still waiting or running
                tokio::time::sleep(tokio::time::Duration::from_millis(500)).await;
            }
        }
    }

    // Clean up - remove the process
    colonyos::remove_process(&process.processid, prvkey).await?;
    println!("\nProcess removed");

    Ok(())
}