regent-sdk 0.7.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

use std::error::Error;

#[derive(Debug)]
pub enum RegentError {
    FailureToFindGroupContent,
    FailureToParseContent(String),
    FailureToRunCommand(String),
    FailureToEstablishConnection(String),
    FailedInitialization(String),
    FailedTcpBinding(String),
    FailedTaskDryRun(String),
    FailedDryRunEvaluation(String),
    FailedToApplyExpectedState(String),
    FailedToGetSecret(String),
    FailureToConsiderContext(String),
    MissingInitialization(String),
    GroupNotFound,
    MissingGroupsList,
    WorkFlowNotFollowed(String),
    WrongInitialization(String),
    AnyOtherError(String),
    IncoherentExpectedState(String),
    InternalLogicError(String),
    NotConnectedToHost,
    ConnectionLevel(String),
    ProblemWithHostConnection(String),
    SecretsIssue(String),
}

impl std::fmt::Display for RegentError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            RegentError::FailureToFindGroupContent => write!(f, "Failure to find group content"),
            RegentError::FailureToParseContent(e) => write!(f, "Failure to parse content: {}", e),
            RegentError::FailureToRunCommand(e) => write!(f, "Failure to run command: {}", e),
            RegentError::FailureToEstablishConnection(e) => {
                write!(f, "Failure to establish connection: {}", e)
            }
            RegentError::FailedInitialization(e) => write!(f, "Failed initialization: {}", e),
            RegentError::FailedTcpBinding(e) => write!(f, "Failed TCP binding: {}", e),
            RegentError::FailedTaskDryRun(e) => write!(f, "Failed task dry run: {}", e),
            RegentError::FailedDryRunEvaluation(e) => write!(f, "Failed dry run evaluation: {}", e),
            RegentError::FailedToApplyExpectedState(e) => {
                write!(f, "Failed to apply expected state: {}", e)
            }
            RegentError::FailedToGetSecret(e) => write!(f, "Failed to get secret: {}", e),
            RegentError::FailureToConsiderContext(e) => {
                write!(f, "Failure to consider context: {}", e)
            }
            RegentError::MissingInitialization(e) => write!(f, "Missing initialization: {}", e),
            RegentError::GroupNotFound => write!(f, "Group not found"),
            RegentError::MissingGroupsList => write!(f, "Missing groups list"),
            RegentError::WorkFlowNotFollowed(e) => write!(f, "Workflow not followed: {}", e),
            RegentError::WrongInitialization(e) => write!(f, "Wrong initialization: {}", e),
            RegentError::AnyOtherError(e) => write!(f, "Any other error: {}", e),
            RegentError::IncoherentExpectedState(e) => {
                write!(f, "Incoherent expected state: {}", e)
            }
            RegentError::InternalLogicError(e) => write!(f, "Internal logic error: {}", e),
            RegentError::NotConnectedToHost => write!(f, "Not connected to host"),
            RegentError::ConnectionLevel(e) => write!(f, "Connection level: {}", e),
            RegentError::ProblemWithHostConnection(e) => {
                write!(f, "Problem with host connection: {}", e)
            }
            RegentError::SecretsIssue(e) => write!(f, "Issue related to secrets: {}", e),
        }
    }
}

impl Error for RegentError {}