goblin-engine 0.1.0

A high-performance async workflow engine for executing scripts in planned sequences with dependency resolution
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
102
103
104
105

use std::time::Duration;
use thiserror::Error;

pub type Result<T> = std::result::Result<T, GoblinError>;

#[derive(Error, Debug)]
pub enum GoblinError {
    #[error("Script not found: {name}")]
    ScriptNotFound { name: String },

    #[error("Plan not found: {name}")]
    PlanNotFound { name: String },

    #[error("Script execution failed: {script} - {message}")]
    ScriptExecutionFailed { script: String, message: String },

    #[error("Script execution timed out: {script} after {timeout:?}")]
    ScriptTimeout { script: String, timeout: Duration },

    #[error("Test failed for script: {script}")]
    TestFailed { script: String },

    #[error("Configuration error: {message}")]
    ConfigError { message: String },

    #[error("IO error: {0}")]
    IoError(#[from] std::io::Error),

    #[error("TOML parsing error: {0}")]
    TomlError(#[from] toml::de::Error),

    #[error("Serialization error: {0}")]
    SerializationError(#[from] toml::ser::Error),

    #[error("Invalid step configuration: {message}")]
    InvalidStepConfig { message: String },

    #[error("Circular dependency detected in plan: {plan}")]
    CircularDependency { plan: String },

    #[error("Missing input dependency: {step} requires {dependency}")]
    MissingDependency { step: String, dependency: String },

    #[error("Engine error: {message}")]
    EngineError { message: String },
}

impl GoblinError {
    pub fn script_not_found(name: impl Into<String>) -> Self {
        Self::ScriptNotFound { name: name.into() }
    }

    pub fn plan_not_found(name: impl Into<String>) -> Self {
        Self::PlanNotFound { name: name.into() }
    }

    pub fn script_execution_failed(script: impl Into<String>, message: impl Into<String>) -> Self {
        Self::ScriptExecutionFailed {
            script: script.into(),
            message: message.into(),
        }
    }

    pub fn script_timeout(script: impl Into<String>, timeout: Duration) -> Self {
        Self::ScriptTimeout {
            script: script.into(),
            timeout,
        }
    }

    pub fn test_failed(script: impl Into<String>) -> Self {
        Self::TestFailed {
            script: script.into(),
        }
    }

    pub fn config_error(message: impl Into<String>) -> Self {
        Self::ConfigError {
            message: message.into(),
        }
    }

    pub fn invalid_step_config(message: impl Into<String>) -> Self {
        Self::InvalidStepConfig {
            message: message.into(),
        }
    }

    pub fn circular_dependency(plan: impl Into<String>) -> Self {
        Self::CircularDependency { plan: plan.into() }
    }

    pub fn missing_dependency(step: impl Into<String>, dependency: impl Into<String>) -> Self {
        Self::MissingDependency {
            step: step.into(),
            dependency: dependency.into(),
        }
    }

    pub fn engine_error(message: impl Into<String>) -> Self {
        Self::EngineError {
            message: message.into(),
        }
    }
}