amaters_net/
error.rs

1//! Error types for the network layer
2
3use thiserror::Error;
4use tonic::{Code, Status};
5
6use crate::proto::errors::{ErrorCategory, ErrorCode};
7
8/// Network layer result type
9pub type NetResult<T> = Result<T, NetError>;
10
11/// Network layer errors
12#[derive(Debug, Error)]
13pub enum NetError {
14    /// Network timeout error
15    #[error("Network timeout: {0}")]
16    Timeout(String),
17
18    /// Connection refused
19    #[error("Connection refused: {0}")]
20    ConnectionRefused(String),
21
22    /// Connection reset
23    #[error("Connection reset: {0}")]
24    ConnectionReset(String),
25
26    /// DNS resolution failed
27    #[error("DNS resolution failed: {0}")]
28    DnsFailure(String),
29
30    /// TLS handshake failed
31    #[error("TLS handshake failed: {0}")]
32    TlsHandshake(String),
33
34    /// Invalid request
35    #[error("Invalid request: {0}")]
36    InvalidRequest(String),
37
38    /// Unsupported protocol version
39    #[error("Unsupported protocol version: {0}")]
40    UnsupportedVersion(String),
41
42    /// Malformed message
43    #[error("Malformed message: {0}")]
44    MalformedMessage(String),
45
46    /// Missing required field
47    #[error("Missing required field: {0}")]
48    MissingField(String),
49
50    /// Authentication failed
51    #[error("Authentication failed: {0}")]
52    AuthFailed(String),
53
54    /// Authentication expired
55    #[error("Authentication expired: {0}")]
56    AuthExpired(String),
57
58    /// Insufficient permissions
59    #[error("Insufficient permissions: {0}")]
60    InsufficientPermissions(String),
61
62    /// Invalid certificate
63    #[error("Invalid certificate: {0}")]
64    InvalidCertificate(String),
65
66    /// Storage error from amaters-core
67    #[error("Storage error: {0}")]
68    Storage(#[from] amaters_core::error::AmateRSError),
69
70    /// Server internal error
71    #[error("Server internal error: {0}")]
72    ServerInternal(String),
73
74    /// Server unavailable
75    #[error("Server unavailable: {0}")]
76    ServerUnavailable(String),
77
78    /// Server overloaded
79    #[error("Server overloaded: {0}")]
80    ServerOverloaded(String),
81
82    /// Server shutting down
83    #[error("Server shutting down: {0}")]
84    ServerShuttingDown(String),
85
86    /// gRPC transport error
87    #[error("gRPC transport error: {0}")]
88    Transport(#[from] tonic::transport::Error),
89
90    /// gRPC status error
91    #[error("gRPC status error: {0}")]
92    GrpcStatus(String),
93
94    /// Unknown error
95    #[error("Unknown error: {0}")]
96    Unknown(String),
97}
98
99impl NetError {
100    /// Get the error code for this error
101    pub fn error_code(&self) -> ErrorCode {
102        match self {
103            NetError::Timeout(_) => ErrorCode::ErrorNetworkTimeout,
104            NetError::ConnectionRefused(_) => ErrorCode::ErrorNetworkConnectionRefused,
105            NetError::ConnectionReset(_) => ErrorCode::ErrorNetworkConnectionReset,
106            NetError::DnsFailure(_) => ErrorCode::ErrorNetworkDnsFailed,
107            NetError::TlsHandshake(_) => ErrorCode::ErrorNetworkTlsHandshake,
108            NetError::InvalidRequest(_) => ErrorCode::ErrorProtocolInvalidRequest,
109            NetError::UnsupportedVersion(_) => ErrorCode::ErrorProtocolUnsupportedVersion,
110            NetError::MalformedMessage(_) => ErrorCode::ErrorProtocolMalformedMessage,
111            NetError::MissingField(_) => ErrorCode::ErrorProtocolMissingField,
112            NetError::AuthFailed(_) => ErrorCode::ErrorAuthFailed,
113            NetError::AuthExpired(_) => ErrorCode::ErrorAuthExpired,
114            NetError::InsufficientPermissions(_) => ErrorCode::ErrorAuthInsufficientPermissions,
115            NetError::InvalidCertificate(_) => ErrorCode::ErrorAuthInvalidCertificate,
116            NetError::Storage(_) => ErrorCode::ErrorStorageIo,
117            NetError::ServerInternal(_) => ErrorCode::ErrorServerInternal,
118            NetError::ServerUnavailable(_) => ErrorCode::ErrorServerUnavailable,
119            NetError::ServerOverloaded(_) => ErrorCode::ErrorServerOverloaded,
120            NetError::ServerShuttingDown(_) => ErrorCode::ErrorServerShuttingDown,
121            NetError::Transport(_) | NetError::GrpcStatus(_) => ErrorCode::ErrorNetworkTimeout,
122            NetError::Unknown(_) => ErrorCode::ErrorUnknown,
123        }
124    }
125
126    /// Get the error category for this error
127    pub fn error_category(&self) -> ErrorCategory {
128        match self {
129            NetError::Timeout(_)
130            | NetError::ConnectionRefused(_)
131            | NetError::ConnectionReset(_)
132            | NetError::ServerUnavailable(_)
133            | NetError::ServerOverloaded(_) => ErrorCategory::CategoryRetryable,
134            NetError::AuthFailed(_) | NetError::AuthExpired(_) => ErrorCategory::CategoryAuth,
135            NetError::InvalidRequest(_)
136            | NetError::MalformedMessage(_)
137            | NetError::MissingField(_)
138            | NetError::InsufficientPermissions(_) => ErrorCategory::CategoryClientError,
139            NetError::ServerInternal(_) | NetError::ServerShuttingDown(_) => {
140                ErrorCategory::CategoryServerError
141            }
142            _ => ErrorCategory::CategoryNonRetryable,
143        }
144    }
145
146    /// Check if this error is retryable
147    pub fn is_retryable(&self) -> bool {
148        matches!(self.error_category(), ErrorCategory::CategoryRetryable)
149    }
150}
151
152/// Convert NetError to gRPC Status
153impl From<NetError> for Status {
154    fn from(err: NetError) -> Self {
155        let code = match &err {
156            NetError::Timeout(_) => Code::DeadlineExceeded,
157            NetError::ConnectionRefused(_) | NetError::ConnectionReset(_) => Code::Unavailable,
158            NetError::DnsFailure(_) | NetError::TlsHandshake(_) => Code::Unavailable,
159            NetError::InvalidRequest(_)
160            | NetError::MalformedMessage(_)
161            | NetError::MissingField(_) => Code::InvalidArgument,
162            NetError::UnsupportedVersion(_) => Code::Unimplemented,
163            NetError::AuthFailed(_) | NetError::InvalidCertificate(_) => Code::Unauthenticated,
164            NetError::AuthExpired(_) => Code::Unauthenticated,
165            NetError::InsufficientPermissions(_) => Code::PermissionDenied,
166            NetError::Storage(_) => Code::Internal,
167            NetError::ServerInternal(_) => Code::Internal,
168            NetError::ServerUnavailable(_) | NetError::ServerOverloaded(_) => Code::Unavailable,
169            NetError::ServerShuttingDown(_) => Code::Unavailable,
170            NetError::Transport(_) => Code::Unavailable,
171            NetError::GrpcStatus(_) => Code::Unknown,
172            NetError::Unknown(_) => Code::Unknown,
173        };
174
175        Status::new(code, err.to_string())
176    }
177}
178
179/// Convert gRPC Status to NetError
180impl From<Status> for NetError {
181    fn from(status: Status) -> Self {
182        match status.code() {
183            Code::DeadlineExceeded => NetError::Timeout(status.message().to_string()),
184            Code::Unavailable => NetError::ServerUnavailable(status.message().to_string()),
185            Code::InvalidArgument => NetError::InvalidRequest(status.message().to_string()),
186            Code::Unimplemented => NetError::UnsupportedVersion(status.message().to_string()),
187            Code::Unauthenticated => NetError::AuthFailed(status.message().to_string()),
188            Code::PermissionDenied => {
189                NetError::InsufficientPermissions(status.message().to_string())
190            }
191            Code::Internal => NetError::ServerInternal(status.message().to_string()),
192            _ => NetError::Unknown(status.message().to_string()),
193        }
194    }
195}
196
197#[cfg(test)]
198mod tests {
199    use super::*;
200
201    #[test]
202    fn test_error_code_mapping() {
203        let err = NetError::Timeout("test".to_string());
204        assert_eq!(err.error_code(), ErrorCode::ErrorNetworkTimeout);
205
206        let err = NetError::AuthFailed("test".to_string());
207        assert_eq!(err.error_code(), ErrorCode::ErrorAuthFailed);
208    }
209
210    #[test]
211    fn test_error_category() {
212        let err = NetError::Timeout("test".to_string());
213        assert_eq!(err.error_category(), ErrorCategory::CategoryRetryable);
214        assert!(err.is_retryable());
215
216        let err = NetError::InvalidRequest("test".to_string());
217        assert_eq!(err.error_category(), ErrorCategory::CategoryClientError);
218        assert!(!err.is_retryable());
219    }
220
221    #[test]
222    fn test_status_conversion() {
223        let err = NetError::Timeout("timeout".to_string());
224        let status: Status = err.into();
225        assert_eq!(status.code(), Code::DeadlineExceeded);
226    }
227
228    #[test]
229    fn test_status_from_error() {
230        let err = NetError::Timeout("timeout".to_string());
231        let status: Status = err.into();
232        assert_eq!(status.code(), Code::DeadlineExceeded);
233
234        let err2 = NetError::GrpcStatus("grpc error".to_string());
235        let status2: Status = err2.into();
236        assert_eq!(status2.code(), Code::Unknown);
237    }
238}
amaters_net/error.rs

amaters_net/
error.rs
