aerro 0.6.4

Cross-service gRPC error framework for Rust.
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

//! Type-erased fallback for unknown wire types — see spec §5.
//!
//! Like [`crate::ServiceFailure`], the actual state lives behind a single
//! `Box` so `Result<_, RemoteError>` stays pointer-sized.

use bytes::Bytes;
use smallvec::SmallVec;
use tonic::Code;

use crate::{Aerro, Category, Frame, trace::TraceContext};

/// Boxed state of [`RemoteError`]. Exposed only so field access through
/// `Deref`/`DerefMut` (`e.type_id`, `e.frames`, ...) names a public type.
#[derive(Debug)]
pub struct RemoteErrorInner {
    pub category: Category,
    pub type_id: String,
    pub frames: SmallVec<[Frame; 4]>,
    pub trace: TraceContext,
    pub outer_code: Code,
    pub outer_message: String,
    pub(crate) payload_bytes: Bytes,
}

/// Components used to construct a [`RemoteError`] via [`RemoteError::from_parts`].
#[derive(Debug)]
pub struct RemoteErrorParts {
    pub category: Category,
    pub type_id: String,
    pub frames: SmallVec<[Frame; 4]>,
    pub trace: TraceContext,
    pub outer_code: Code,
    pub outer_message: String,
    pub(crate) payload_bytes: Bytes,
}

#[derive(Debug)]
pub struct RemoteError {
    state: Box<RemoteErrorInner>,
}

impl RemoteError {
    pub fn from_parts(parts: RemoteErrorParts) -> Self {
        let RemoteErrorParts {
            category,
            type_id,
            frames,
            trace,
            outer_code,
            outer_message,
            payload_bytes,
        } = parts;
        Self {
            state: Box::new(RemoteErrorInner {
                category,
                type_id,
                frames,
                trace,
                outer_code,
                outer_message,
                payload_bytes,
            }),
        }
    }

    /// Recover a typed variant whose `type_id` is in `E::TYPE_IDS`.
    pub fn downcast<E: Aerro>(&self) -> Option<E> {
        if !E::TYPE_IDS.contains(&self.state.type_id.as_str()) {
            return None;
        }
        E::decode_payload(&self.state.type_id, &self.state.payload_bytes).ok()
    }
}

impl std::ops::Deref for RemoteError {
    type Target = RemoteErrorInner;
    fn deref(&self) -> &RemoteErrorInner {
        &self.state
    }
}

impl std::ops::DerefMut for RemoteError {
    fn deref_mut(&mut self) -> &mut RemoteErrorInner {
        &mut self.state
    }
}

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

impl std::error::Error for RemoteError {}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::test_support::Boom;

    fn make(parts: RemoteErrorParts) -> RemoteError {
        RemoteError::from_parts(parts)
    }

    #[test]
    fn downcast_recovers_known_type() {
        use crate::Exposure;
        let mut buf = Vec::new();
        Boom { x: 7 }
            .encode_payload(Exposure::Internal, &mut buf)
            .unwrap();
        let r = make(RemoteErrorParts {
            category: Category::System,
            type_id: "toy.boom".into(),
            frames: SmallVec::new(),
            trace: TraceContext::default(),
            outer_code: Code::Internal,
            outer_message: "toy.boom".into(),
            payload_bytes: Bytes::from(buf),
        });
        assert_eq!(r.downcast::<Boom>().unwrap().x, 7);
    }

    #[test]
    fn downcast_returns_none_on_mismatch() {
        let r = make(RemoteErrorParts {
            category: Category::Business,
            type_id: "other".into(),
            frames: SmallVec::new(),
            trace: TraceContext::default(),
            outer_code: Code::NotFound,
            outer_message: "x".into(),
            payload_bytes: Bytes::new(),
        });
        assert!(r.downcast::<Boom>().is_none());
    }

    #[test]
    fn remote_error_is_pointer_sized() {
        assert_eq!(
            std::mem::size_of::<RemoteError>(),
            std::mem::size_of::<usize>()
        );
    }
}