mesh_channel/
error.rs

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
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.

//! Remotable errors.

use mesh_protobuf::EncodeAs;
use mesh_protobuf::Protobuf;
use std::fmt;
use std::fmt::Display;

/// An error that can be remoted across a mesh channel.
///
/// This erases the error's type, but preserves the source error chain when sent
/// between processes.
#[derive(Protobuf)]
pub struct RemoteError(EncodeAs<BoxedError, EncodedError>);

type BoxedError = Box<dyn std::error::Error + Send + Sync>;

impl RemoteError {
    /// Returns a new remote error wrapping `error` (including the error's
    /// source).
    pub fn new<T: Into<BoxedError>>(error: T) -> Self {
        Self(error.into().into())
    }
}

impl Display for RemoteError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        Display::fmt(&self.0, f)
    }
}

impl fmt::Debug for RemoteError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt::Debug::fmt(&self.0, f)
    }
}

impl std::error::Error for RemoteError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        self.0.source()
    }
}

/// An error encoded for serialization as a mesh message.
#[derive(Protobuf)]
struct EncodedError {
    errors: Vec<String>,
}

impl From<EncodedError> for BoxedError {
    fn from(error: EncodedError) -> Self {
        Box::new(DecodedError::from(error))
    }
}

impl From<BoxedError> for EncodedError {
    fn from(error: BoxedError) -> Self {
        let mut errors = Vec::new();
        let mut error = error.as_ref() as &dyn std::error::Error;
        loop {
            errors.push(error.to_string());
            if let Some(source) = error.source() {
                error = source;
            } else {
                break;
            }
        }
        Self { errors }
    }
}

/// An error decoded from an [`EncodedError`].
///
/// This is a distinct type so that we can implement
/// [`std::error::Error::source`] for it.
#[derive(Debug)]
struct DecodedError {
    source: Option<Box<DecodedError>>,
    error: String,
}

impl From<EncodedError> for DecodedError {
    fn from(value: EncodedError) -> Self {
        let mut errors = value.errors;
        let last_error = errors.pop().unwrap_or("no error information".to_string());
        let mut decoded = DecodedError {
            source: None,
            error: last_error,
        };
        for error in errors.into_iter().rev() {
            decoded = DecodedError {
                source: Some(Box::new(decoded)),
                error,
            };
        }
        decoded
    }
}

impl Display for DecodedError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str(&self.error)
    }
}

impl std::error::Error for DecodedError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        self.source.as_ref().map(|s| s as _)
    }
}

/// Alias for a [`Result`] with a [`RemoteError`] error.
pub type RemoteResult<T> = Result<T, RemoteError>;