raystack 0.4.0

WIP SkySpark client
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

use crate::auth::AuthError;
use crate::grid::{Grid, ParseJsonGridError};

pub(crate) type Result<T> = std::result::Result<T, Error>;

/// Encapsulates all errors that can occur in this crate.
#[derive(Debug)]
pub struct Error {
    kind: ErrorKind,
}

impl Error {
    /// Return the `ErrorKind` for this error.
    pub fn kind(&self) -> &ErrorKind {
        &self.kind
    }

    /// Return the `ErrorKind` for this error and consume the error.
    pub fn into_kind(self) -> ErrorKind {
        self.kind
    }

    /// Return true if this error encapsulates a Haystack error grid.
    pub fn is_grid(&self) -> bool {
        match self.kind() {
            ErrorKind::Grid { .. } => true,
            _ => false,
        }
    }

    pub(crate) fn new(kind: ErrorKind) -> Self {
        Error { kind }
    }

    pub(crate) fn new_io(msg: String) -> Self {
        Error::new(ErrorKind::Io { msg })
    }

    /// Return the Haystack error grid encapsulated by this error, if this
    /// error was caused by a Haystack error grid.
    pub fn into_grid(self) -> Option<Grid> {
        match self.kind {
            ErrorKind::Grid { err_grid } => Some(err_grid),
            _ => None,
        }
    }
}

impl std::fmt::Display for Error {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let msg = match self.kind() {
            ErrorKind::Auth { err } => {
                format!("Error while authenticating: {}", err)
            }
            ErrorKind::Csv { err } => format!("CSV error: {}", err),
            ErrorKind::Grid { err_grid } => {
                let trace = err_grid
                    .error_trace()
                    .unwrap_or_else(|| "No error trace".to_owned());
                format!("Error grid: {}", trace)
            }
            ErrorKind::Http { err } => format!("HTTP error: {}", err),
            ErrorKind::Io { msg } => format!("IO error: {}", msg),
            ErrorKind::ParseJsonGrid { msg } => {
                format!("Could not parse a grid from JSON: {}", msg)
            }
        };
        write!(f, "Error - {}", msg)
    }
}

/// Describes the kinds of errors that can occur in this crate.
#[derive(Debug)]
pub enum ErrorKind {
    /// An error which occurred during the authorization process.
    Auth { err: AuthError },
    /// An error related to CSVs.
    Csv { err: csv::Error },
    /// The grid contained error information from the server.
    Grid {
        /// The grid which caused this error.
        err_grid: Grid,
    },
    /// An error which originated from the underlying HTTP library.
    Http { err: reqwest::Error },
    /// An IO error.
    Io { msg: String },
    /// An error related to parsing a `Grid`.
    ParseJsonGrid { msg: String },
}

impl std::error::Error for Error {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match self.kind() {
            ErrorKind::Auth { err } => Some(err),
            ErrorKind::Csv { err } => Some(err),
            ErrorKind::Grid { .. } => None,
            ErrorKind::Http { err } => Some(err),
            ErrorKind::Io { .. } => None,
            ErrorKind::ParseJsonGrid { .. } => None,
        }
    }
}

impl From<AuthError> for Error {
    fn from(err: AuthError) -> Self {
        Error::new(ErrorKind::Auth { err })
    }
}

impl From<reqwest::Error> for Error {
    fn from(error: reqwest::Error) -> Self {
        Error::new(ErrorKind::Http { err: error })
    }
}

impl From<ParseJsonGridError> for Error {
    fn from(error: ParseJsonGridError) -> Self {
        Error::new(ErrorKind::ParseJsonGrid { msg: error.msg })
    }
}

impl From<csv::Error> for Error {
    fn from(error: csv::Error) -> Self {
        Error::new(ErrorKind::Csv { err: error })
    }
}