passivized_docker_engine_client 0.0.10-alpha

Docker Engine Client - manage and run containers, images, and volumes.
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

use std::fmt::{Display, Formatter};

use crate::imp::api::DockerEngineApiBuilderError;

/// An error occurred during use of the Docker Engine client, and the error
/// is likely a bug of this library, as opposed to an external condition
/// such as a broken TCP connection or a misconfigured container.
#[derive(Debug)]
pub enum DecLibraryError {

    /// Failed to build a request object for the underlying HTTP client library.
    HttpRequestBuilderError(hyper::http::Error),

    /// Failed to encode registry authentication as json.
    RegistryAuthJsonEncodingError(serde_json::Error),

    /// Failed to convert a request into JSON.
    RequestSerializationError(serde_json::Error),

    /// Failed to serialize JSON while building a URL.
    UrlBuilderJsonError(serde_json::Error),

    /// Failed to build a URL.
    UrlBuilderParseError(url::ParseError),

}

impl DecLibraryError {

    pub fn message(&self) -> String {
        match self {
            Self::HttpRequestBuilderError(hyper_error) =>
                format!("Request error: {}", hyper_error),

            Self::RegistryAuthJsonEncodingError(error) =>
                format!("Failed to encode registry authentication as json: {}", error),

            Self::RequestSerializationError(serde_error) =>
                format!("Failed to serialize request body to json: {}", serde_error),

            Self::UrlBuilderJsonError(json_error) =>
                format!("URL builder json encoding failed: {}", json_error),

            Self::UrlBuilderParseError(parse_error) =>
                format!("URL builder failed: {}", parse_error),

        }
    }
}

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

impl From<DockerEngineApiBuilderError> for DecLibraryError {
    fn from(other: DockerEngineApiBuilderError) -> Self {
        match other {
            DockerEngineApiBuilderError::Json(json_error) =>
                DecLibraryError::UrlBuilderJsonError(json_error),

            DockerEngineApiBuilderError::Url(parse_error) =>
                DecLibraryError::UrlBuilderParseError(parse_error)
        }
    }
}

impl From<url::ParseError> for DecLibraryError {
    fn from(other: url::ParseError) -> Self {
        DecLibraryError::UrlBuilderParseError(other)
    }
}

#[cfg(test)]
mod test_error_message_and_display {
    use hyper::StatusCode;
    use super::DecLibraryError;

    fn simulated_json_failure() -> (String, serde_json::Error) {
        let result: Result<i32, serde_json::Error> = serde_json::from_str("");
        let error = result.unwrap_err();
        let message = format!("{}", error);

        (message, error)
    }

    #[test]
    fn request_builder_error() {
        let inner = StatusCode::from_u16(12345)
            .unwrap_err();

        let middle = hyper::http::Error::from(inner);
        let outer = DecLibraryError::HttpRequestBuilderError(middle);

        // This is a bit nonsensical but invalid status code was an easy way to create an error value for a test.
        assert_eq!("Request error: invalid status code", format!("{}", outer));
    }

    #[test]
    fn url_builder_json_encoding_failed() {
        let (message, json_error) = simulated_json_failure();
        let internal_error = DecLibraryError::UrlBuilderJsonError(json_error);

        let expected = format!("URL builder json encoding failed: {}", message);
        let actual = format!("{}", internal_error);

        assert_eq!(expected, actual);
    }
}