Skip to main content

shep_client/dogs/
error.rs

1//! [`ShepherdError`], every way a dog's shepherd can fail it, as one
2//! variant a dog's own error wraps.
3
4use core::fmt;
5
6use crate::{ConnectError, LinkLost, RequestError};
7
8/// Why a dog could not do what it asked its shepherd.
9///
10/// Non-exhaustive: the client may grow a way to fail.
11#[derive(Debug)]
12#[non_exhaustive]
13pub enum ShepherdError {
14    /// No shepherd answered at the socket, or one refused the handshake.
15    Connect(ConnectError),
16    /// A request failed, or the shepherd answered it out of turn.
17    Request(RequestError),
18    /// The link dropped and no shepherd came back inside the dog's budget,
19    /// or a successor refused it.
20    Lost(LinkLost),
21}
22
23impl ShepherdError {
24    /// The [`shep_core::exit`] code a dog stopping on this error exits
25    /// with, the same one `shep` would for the same cause.
26    #[must_use]
27    pub const fn exit_code(&self) -> u8 {
28        match self {
29            Self::Connect(err) => err.exit_code(),
30            Self::Request(err) => err.exit_code(),
31            Self::Lost(lost) => lost.exit_code(),
32        }
33    }
34}
35
36impl fmt::Display for ShepherdError {
37    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
38        match self {
39            Self::Connect(err) => write!(f, "cannot reach the shepherd: {err}"),
40            Self::Request(err) => write!(f, "a request to the shepherd failed: {err}"),
41            Self::Lost(lost) => write!(f, "lost the shepherd: {lost}"),
42        }
43    }
44}
45
46impl core::error::Error for ShepherdError {
47    fn source(&self) -> Option<&(dyn core::error::Error + 'static)> {
48        match self {
49            Self::Connect(err) => Some(err),
50            Self::Request(err) => Some(err),
51            Self::Lost(lost) => Some(lost),
52        }
53    }
54}
55
56impl From<ConnectError> for ShepherdError {
57    fn from(err: ConnectError) -> Self {
58        Self::Connect(err)
59    }
60}
61
62impl From<RequestError> for ShepherdError {
63    fn from(err: RequestError) -> Self {
64        Self::Request(err)
65    }
66}
67
68impl From<LinkLost> for ShepherdError {
69    fn from(lost: LinkLost) -> Self {
70        Self::Lost(lost)
71    }
72}
73
74#[cfg(test)]
75mod tests {
76    use std::time::Duration;
77
78    use shep_core::exit;
79
80    use super::*;
81
82    #[test]
83    fn each_cause_exits_on_its_own_code() {
84        let cases = [
85            (
86                ShepherdError::from(ConnectError::HandshakeClosed),
87                exit::DAEMON_UNREACHABLE,
88            ),
89            (
90                ShepherdError::from(RequestError::Closed),
91                exit::DAEMON_UNREACHABLE,
92            ),
93            (
94                ShepherdError::from(LinkLost::Refused {
95                    daemon_version: None,
96                    message: "too old".to_owned(),
97                }),
98                exit::PROTOCOL_MISMATCH,
99            ),
100            (
101                ShepherdError::from(LinkLost::Budget {
102                    waited: Duration::from_secs(5),
103                }),
104                exit::DAEMON_UNREACHABLE,
105            ),
106        ];
107        for (err, code) in cases {
108            assert_eq!(err.exit_code(), code, "{err}");
109        }
110    }
111
112    #[test]
113    fn the_cause_is_reachable_as_the_source() {
114        use core::error::Error as _;
115        let err = ShepherdError::from(RequestError::Closed);
116        let source = err.source().expect("a wrapped error has a source");
117        assert_eq!(source.to_string(), RequestError::Closed.to_string());
118    }
119}