zebflow 0.9.1

Reactive web automation platform — pipelines, templates, and real-time collaboration in a single binary.
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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

//! Trait definitions for whole-pipeline execution backends.

use std::fmt;
use std::sync::Arc;

use async_trait::async_trait;
use serde::{Deserialize, Serialize};
use serde_json::Value;

use crate::infra::execution::handle::ExecutionHandle;
use crate::infra::execution::placement::PlacementPolicy;

/// Named execution backend kinds reserved by the architecture.
#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum ExecutionBackendKind {
    ResidentLocal,
    ResidentWorker,
    DockerJob,
    K8sJob,
    SparkSubmit,
}

/// Portable execution profile vocabulary stored in project-level configuration and migration plans.
///
/// This intentionally hides whether resident execution resolves to a local process or a remote
/// worker. That resolution is environment-owned and should happen later during placement.
#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)]
#[serde(rename_all = "snake_case")]
pub enum ExecutionProfileKind {
    /// Long-lived resident runtime, local or remote depending on placement.
    #[default]
    Resident,
    /// One isolated Docker-style job/container per execution.
    DockerJob,
    /// One Kubernetes Job/Pod per execution.
    K8sJob,
    /// One Spark-submit style execution.
    SparkSubmit,
}

impl ExecutionBackendKind {
    /// Portable execution profile represented by this concrete backend.
    pub fn profile_kind(self) -> ExecutionProfileKind {
        match self {
            Self::ResidentLocal | Self::ResidentWorker => ExecutionProfileKind::Resident,
            Self::DockerJob => ExecutionProfileKind::DockerJob,
            Self::K8sJob => ExecutionProfileKind::K8sJob,
            Self::SparkSubmit => ExecutionProfileKind::SparkSubmit,
        }
    }
}

/// Execution request passed to a backend.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ExecutionRequest {
    /// Owner identifier.
    pub owner: String,
    /// Project identifier.
    pub project: String,
    /// Canonical pipeline file path.
    pub file_rel_path: String,
    /// JSON payload supplied to the run.
    #[serde(default)]
    pub input: Value,
    /// Optional placement hint or policy.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub placement: Option<PlacementPolicy>,
    /// Backend-specific metadata.
    #[serde(default)]
    pub metadata: Value,
}

/// Backend execution error.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct ExecutionError {
    /// Stable error code.
    pub code: String,
    /// Human-readable explanation.
    pub message: String,
}

impl ExecutionError {
    /// Build a new execution error.
    pub fn new(code: impl Into<String>, message: impl Into<String>) -> Self {
        Self {
            code: code.into(),
            message: message.into(),
        }
    }

    /// Convenience constructor for scaffold backends that are not yet implemented.
    pub fn not_implemented(name: &str) -> Self {
        Self::new(
            "EXECUTION_BACKEND_NOT_IMPLEMENTED",
            format!("execution backend '{name}' is not implemented yet"),
        )
    }
}

impl fmt::Display for ExecutionError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}: {}", self.code, self.message)
    }
}

impl std::error::Error for ExecutionError {}

/// Contract for whole-pipeline execution backends.
#[async_trait]
pub trait ExecutionBackend: Send + Sync {
    /// Stable backend identifier.
    fn id(&self) -> &'static str;

    /// Backend kind for routing and serialization.
    fn kind(&self) -> ExecutionBackendKind;

    /// Start executing a whole-pipeline request.
    async fn execute(&self, request: ExecutionRequest) -> Result<ExecutionHandle, ExecutionError>;
}

/// Shared backend trait object.
pub type DynExecutionBackend = Arc<dyn ExecutionBackend>;