escher-execution-engine 0.1.2

Production-ready async execution engine for system commands
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
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

// Standalone example - Test execution engine without Tauri
//
// Run with: cargo run --example standalone

use execution_engine::*;
use std::sync::Arc;

use std::collections::HashMap;

#[tokio::main]
async fn main() {
    println!("=== Execution Engine - Standalone Example ===\n");

    // Create engine
    // let config = ExecutionConfig::default();
    let config = ExecutionConfig {
        log_dir: Some(PathBuf::from("/tmp/execution-logs")),
        ..Default::default()
    };
    let engine = Arc::new(ExecutionEngine::new(config).unwrap());

    // Start cleanup task
    engine.clone().start_cleanup_task();

    println!("✓ Engine created and cleanup started\n");

    // Test 1: Simple echo command
    println!("Test 1: Simple echo command");
    let request = ExecutionRequest {
        id: uuid::Uuid::new_v4(),
        command: Command::Shell {
            command: "echo 'Hello from Execution Engine!'".to_string(),
            shell: "/bin/bash".to_string(),
        },
        timeout_ms: Some(5000),
        env: HashMap::new(),
        working_dir: None,
        output_log_path: None,
        metadata: Default::default(),
    };

    let execution_id = engine.execute(request).await.unwrap();
    println!("  Execution ID: {}", execution_id);

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

    let result = engine.get_result(execution_id).await.unwrap();
    println!("  Success: {}", result.success);
    println!("  Output: {}", result.stdout);
    println!();

    // Test 2: Get metrics
    println!("Test 2: Concurrency metrics");
    let max_concurrent = engine.config().max_concurrent_executions;
    let currently_running = engine.running_count().await;
    let available_permits = engine.available_permits();
    println!("  Max concurrent: {}", max_concurrent);
    println!("  Currently running: {}", currently_running);
    println!("  Available slots: {}", available_permits);
    println!();

    // Test 3: List executions
    println!("Test 3: List executions");
    let executions = engine.list_executions().await;
    println!("  Total in memory: {}", executions.len());
    println!();

    // Test 4: Run simple-test.sh script
    println!("Test 4: Run simple-test.sh script");
    let request = ExecutionRequest {
        id: uuid::Uuid::new_v4(),
        command: Command::Shell {
            command: "bash test-scripts/simple-test.sh".to_string(),
            shell: "/bin/bash".to_string(),
        },
        timeout_ms: Some(5000),
        env: HashMap::new(),
        working_dir: None,
        output_log_path: None,
        metadata: Default::default(),
    };

    let execution_id = engine.execute(request).await.unwrap();
    println!("  Script execution ID: {}", execution_id);

    // Wait for completion and get result
    let result = engine.wait_for_completion(execution_id).await.unwrap();
    println!("  Success: {}", result.success);
    println!("  Exit code: {}", result.exit_code);

    if !result.stdout.is_empty() {
        println!("  Stdout:\n{}", result.stdout);
    }

    if !result.stderr.is_empty() {
        println!("  Stderr:\n{}", result.stderr);
    }
    println!();

    println!("=== All tests completed ===");
}