hrpc 0.33.29

Common code for hRPC.
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

use std::{
    borrow::Cow,
    error::Error as StdError,
    fmt::{self, Display, Formatter},
};

pub use crate::{decode::DecodeBodyError, proto::Error as HrpcError};
pub use std::io::Error as IoError;

/// Convenience type for `Client` operation result.
pub type ClientResult<T, TransportError> = Result<T, ClientError<TransportError>>;

/// Errors that can occur within `Client` operation.
#[derive(Debug)]
pub enum ClientError<TransportError> {
    /// Occurs if an endpoint returns an error.
    EndpointError {
        /// The hRPC error.
        hrpc_error: HrpcError,
        /// The endpoint for which this error happened.
        endpoint: Cow<'static, str>,
    },
    /// Occurs if the data server responded with could not be decoded.
    MessageDecode(DecodeBodyError),
    /// Occurs if the data server responded with is not supported for decoding.
    ContentNotSupported,
    /// Occures if the underlying transport yields an error.
    Transport(TransportError),
    /// Occurs if the spec implemented on server doesn't match ours.
    ///
    /// The value is the version of the server. If it is `unknown`, it means
    /// that either no version was provided, or the version couldn't be parsed
    /// (ie. if it's an HTTP header).
    IncompatibleSpecVersion(String),
}

impl<TransportError> ClientError<TransportError> {
    /// Map the transport error.
    pub fn map_transport_err<F, NewTransportError>(self, f: F) -> ClientError<NewTransportError>
    where
        F: FnOnce(TransportError) -> NewTransportError,
    {
        match self {
            ClientError::Transport(err) => ClientError::Transport(f(err)),
            ClientError::EndpointError {
                hrpc_error,
                endpoint,
            } => ClientError::EndpointError {
                hrpc_error,
                endpoint,
            },
            ClientError::ContentNotSupported => ClientError::ContentNotSupported,
            ClientError::IncompatibleSpecVersion(server_ver) => {
                ClientError::IncompatibleSpecVersion(server_ver)
            }
            ClientError::MessageDecode(err) => ClientError::MessageDecode(err),
        }
    }
}

impl<TransportError: StdError> Display for ClientError<TransportError> {
    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
        match self {
            ClientError::EndpointError {
                hrpc_error,
                endpoint,
            } => write!(
                f,
                "endpoint {} returned an error '{}': {}",
                endpoint, hrpc_error.identifier, hrpc_error.human_message,
            ),
            ClientError::ContentNotSupported => {
                write!(f, "server responded with a non protobuf response")
            }
            ClientError::MessageDecode(err) => write!(
                f,
                "failed to decode response data as protobuf response: {}",
                err
            ),
            ClientError::Transport(err) => write!(f, "transport error: {}", err),
            ClientError::IncompatibleSpecVersion(server_ver) => {
                write!(
                    f,
                    "server hrpc version ({}) is incompatible with ours ({})",
                    server_ver,
                    crate::HRPC_SPEC_VERSION
                )
            }
        }
    }
}

impl<TransportError> From<DecodeBodyError> for ClientError<TransportError> {
    fn from(err: DecodeBodyError) -> Self {
        ClientError::MessageDecode(err)
    }
}

impl<TransportError: StdError + 'static> StdError for ClientError<TransportError> {
    fn source(&self) -> Option<&(dyn StdError + 'static)> {
        match self {
            ClientError::MessageDecode(err) => Some(err),
            ClientError::Transport(err) => Some(err),
            ClientError::EndpointError { hrpc_error, .. } => Some(hrpc_error),
            _ => None,
        }
    }
}