regent-sdk 0.2.0

Multi-paradigm configuration management system as a library
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

use crate::connection::hosthandler::ConnectionHandler;
use crate::error::Error;
use crate::task::taskblock::TaskBlock;
use crate::workflow::stepflow::{StepFlow, StepStatus};
use serde::{Deserialize, Serialize};

/// A TaskFlow withholds all step flows, a flow being being the combination of :
/// - an expected state
/// - changes required to have the host match this expected state
/// - results of actually trying to enforce these changes
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct TaskFlow {
    pub name: Option<String>,
    pub with_sudo: Option<bool>,
    pub step_flows: Vec<StepFlow>,
    pub task_status: TaskStatus,
}

impl TaskFlow {
    pub fn new() -> TaskFlow {
        TaskFlow {
            name: None,
            with_sudo: None,
            step_flows: Vec::new(),
            task_status: TaskStatus::NotRunYet,
        }
    }

    pub fn from(task_block: TaskBlock) -> TaskFlow {
        let mut task_flow = TaskFlow::new();

        for step in task_block.steps.iter() {
            task_flow.step_flows.push(StepFlow::from(step.clone()));
        }
        task_flow.name = task_block.name;
        task_flow.with_sudo = task_block.with_sudo;

        task_flow
    }

    pub fn dry_run(
        &mut self,
        hosthandler: &mut ConnectionHandler,
        tera_context: &mut tera::Context,
    ) -> Result<(), Error> {
        let mut changes_required = false;

        for step_flow in self.step_flows.iter_mut() {
            match step_flow.dry_run(hosthandler, tera_context) {
                Ok(()) => {
                    if let StepStatus::ChangeRequired = step_flow.step_status {
                        changes_required = true;
                    }
                }
                Err(error) => {
                    return Err(error);
                }
            }
        }

        if changes_required {
            self.task_status = TaskStatus::ChangeRequired;
        } else {
            self.task_status = TaskStatus::AlreadyMatched;
        }

        Ok(())
    }

    pub fn apply(
        &mut self,
        hosthandler: &mut ConnectionHandler,
        tera_context: &mut tera::Context,
    ) -> Result<(), Error> {
        let mut task_status = TaskStatus::ApplySuccesful;

        for step_flow in self.step_flows.iter_mut() {
            match step_flow.apply(hosthandler, tera_context) {
                Ok(()) => match &step_flow.step_status {
                    StepStatus::ApplyFailed => {
                        task_status = TaskStatus::ApplyFailed;
                        break;
                    }
                    StepStatus::ApplyFailedButAllowed => {
                        task_status = TaskStatus::ApplyFailedButAllowed;
                    }
                    _ => {}
                },
                Err(error) => {
                    return Err(error);
                }
            }
        }
        self.task_status = task_status;

        Ok(())
    }
}

#[derive(Debug, Clone, Deserialize, Serialize)]
pub enum TaskStatus {
    NotRunYet,
    AlreadyMatched,
    ChangeRequired,
    ApplySuccesful,
    ApplyFailedButAllowed,
    ApplyFailed,
}