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

// Command module : <short description>

use crate::connection::hosthandler::ConnectionHandler;
use crate::connection::specification::Privilege;
use crate::error::Error;
use crate::result::apicallresult::{ApiCallResult, ApiCallStatus};
use crate::step::stepchange::StepChange;
use crate::task::moduleblock::Check;
use crate::task::moduleblock::ModuleApiCall;
use crate::task::moduleblock::{Apply, DryRun};
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct CommandBlockExpectedState {
    content: String,
}

impl Check for CommandBlockExpectedState {
    fn check(&self) -> Result<(), Error> {
        Ok(())
    }
}

impl DryRun for CommandBlockExpectedState {
    fn dry_run_block(
        &self,
        _hosthandler: &mut ConnectionHandler,
        privilege: &Privilege,
    ) -> Result<StepChange, Error> {
        let mut changes: Vec<ModuleApiCall> = Vec::new();

        let privilege = privilege.clone();

        changes.push(ModuleApiCall::Command(CommandApiCall {
            cmd: self.content.clone(),
            privilege,
        }));

        return Ok(StepChange::changes(changes));
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CommandApiCall {
    pub cmd: String,
    privilege: Privilege,
}

impl Apply for CommandApiCall {
    fn display(&self) -> String {
        return format!("Run command : {}", self.cmd);
    }

    fn apply_moduleblock_change(&self, hosthandler: &mut ConnectionHandler) -> ApiCallResult {
        let cmd_result = hosthandler
            .run_cmd(self.cmd.as_str(), &self.privilege)
            .unwrap();

        if cmd_result.rc == 0 {
            return ApiCallResult::from(
                Some(cmd_result.rc),
                Some(cmd_result.stdout),
                ApiCallStatus::ChangeSuccessful(String::from("Command successful")),
            );
        } else {
            return ApiCallResult::from(
                Some(cmd_result.rc),
                Some(cmd_result.stdout),
                ApiCallStatus::Failure(String::from("Command failed")),
            );
        }
    }
}