1use serde::{Deserialize, Serialize};
2use std::collections::HashMap;
3
4#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
6pub enum ExecutionMethod {
7 #[serde(rename = "ssh")]
8 SSH,
9 #[serde(rename = "websocket")]
10 WebSocket,
11}
12
13#[derive(Debug, Clone, Serialize, Deserialize)]
15pub struct SshConfig {
16 pub host: String,
17 pub port: u16,
18 pub username: String,
19 pub password: Option<String>,
20 pub private_key_path: Option<String>,
21 pub session_timeout_seconds: Option<u64>,
22 pub timeout_seconds: Option<u64>,
23}
24
25#[derive(Debug, Clone, Serialize, Deserialize)]
27pub struct WebSocketConfig {
28 pub url: String,
29 pub timeout_seconds: Option<u64>,
30}
31
32#[derive(Debug, Clone, Serialize, Deserialize)]
34pub struct ClientConfig {
35 pub name: String,
36 pub execution_method: ExecutionMethod,
37 pub ssh_config: Option<SshConfig>,
38 pub websocket_config: Option<WebSocketConfig>,
39}
40
41#[derive(Debug, Clone, Serialize, Deserialize)]
43pub struct ExtractRule {
44 pub name: String,
45 pub patterns: Vec<String>, pub source: String, #[serde(default = "default_cascade")]
48 pub cascade: bool, }
50
51fn default_cascade() -> bool {
53 true
54}
55
56#[derive(Debug, Clone, Serialize, Deserialize, Default)]
58pub struct Step {
59 pub name: String,
60 pub script: String,
61 #[serde(default)]
62 pub servers: Vec<String>,
63 pub timeout_seconds: Option<u64>,
64 pub extract: Option<Vec<ExtractRule>>,
65}
66
67#[derive(Debug, Clone, Serialize, Deserialize)]
69pub struct Pipeline {
70 pub name: String,
71 pub steps: Vec<Step>,
72}
73
74#[derive(Debug, Clone, Serialize, Deserialize)]
76pub struct RemoteExecutionConfig {
77 pub variables: Option<HashMap<String, String>>,
78 pub clients: HashMap<String, ClientConfig>,
79 pub pipelines: Vec<Pipeline>,
80 pub default_timeout: Option<u64>,
81}
82
83#[derive(Debug, Clone)]
85pub enum OutputType {
86 Stdout,
87 Stderr,
88 Log,
89}
90
91#[derive(Debug, Clone)]
93pub struct OutputEvent {
94 pub pipeline_name: String,
95 pub server_name: String,
96 pub step: Step, pub output_type: OutputType,
98 pub content: String,
99 pub timestamp: std::time::Instant,
100 pub variables: HashMap<String, String>, }
102
103pub type OutputCallback = std::sync::Arc<dyn Fn(OutputEvent) + Send + Sync>;
105
106#[derive(Debug, Clone, Serialize, Deserialize)]
108pub struct ExecutionResult {
109 pub success: bool,
110 pub stdout: String,
111 pub stderr: String,
112 pub script: String,
113 pub exit_code: i32,
114 pub execution_time_ms: u64,
115 pub error_message: Option<String>,
116}
117
118#[derive(Debug, Clone, Serialize, Deserialize)]
120pub struct StepExecutionResult {
121 pub step_name: String,
122 pub server_name: String,
123 pub execution_result: ExecutionResult,
124 pub overall_success: bool,
125 pub execution_time_ms: u64,
126}
127
128#[derive(Debug, Clone, Serialize, Deserialize)]
130pub struct PipelineExecutionResult {
131 pub pipeline_name: String,
132 pub step_results: Vec<StepExecutionResult>,
133 pub overall_success: bool,
134 pub total_execution_time_ms: u64,
135}