Skip to main content

vss_client_ng/
error.rs

1use crate::types::{ErrorCode, ErrorResponse};
2use prost::{DecodeError, Message};
3use std::error::Error;
4use std::fmt::{Display, Formatter};
5
6/// When there is an error while writing to VSS storage, the response contains a relevant error code.
7/// A mapping from a VSS server error codes. Refer to [`ErrorResponse`] docs for more
8/// information regarding each error code and corresponding use-cases.
9#[derive(Debug)]
10pub enum VssError {
11	/// Please refer to [`ErrorCode::NoSuchKeyException`].
12	NoSuchKeyError(String),
13
14	/// Please refer to [`ErrorCode::InvalidRequestException`].
15	InvalidRequestError(String),
16
17	/// Please refer to [`ErrorCode::ConflictException`].
18	ConflictError(String),
19
20	/// Please refer to [`ErrorCode::AuthException`].
21	AuthError(String),
22
23	/// Please refer to [`ErrorCode::InternalServerException`].
24	InternalServerError(String),
25
26	/// There is an unknown error, it could be a client-side bug, unrecognized error-code, network error
27	/// or something else.
28	InternalError(String),
29}
30
31impl VssError {
32	/// Create new instance of `VssError`
33	pub fn new(status_code: i32, payload: Vec<u8>) -> VssError {
34		match ErrorResponse::decode(&payload[..]) {
35			Ok(error_response) => VssError::from(error_response),
36			Err(e) => {
37				let message = format!(
38					"Unable to decode ErrorResponse from server, HttpStatusCode: {}, DecodeErr: {}",
39					status_code, e
40				);
41				VssError::InternalError(message)
42			},
43		}
44	}
45}
46
47impl Display for VssError {
48	fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
49		match self {
50			VssError::NoSuchKeyError(message) => {
51				write!(f, "Requested key does not exist: {}", message)
52			},
53			VssError::InvalidRequestError(message) => {
54				write!(f, "Request sent to VSS Storage was invalid: {}", message)
55			},
56			VssError::ConflictError(message) => {
57				write!(f, "Potential version conflict in write operation: {}", message)
58			},
59			VssError::AuthError(message) => {
60				write!(f, "Authentication or Authorization failure: {}", message)
61			},
62			VssError::InternalServerError(message) => {
63				write!(f, "InternalServerError: {}", message)
64			},
65			VssError::InternalError(message) => {
66				write!(f, "InternalError: {}", message)
67			},
68		}
69	}
70}
71
72impl Error for VssError {}
73
74impl From<ErrorResponse> for VssError {
75	fn from(error_response: ErrorResponse) -> Self {
76		match error_response.error_code() {
77			ErrorCode::NoSuchKeyException => VssError::NoSuchKeyError(error_response.message),
78			ErrorCode::InvalidRequestException => {
79				VssError::InvalidRequestError(error_response.message)
80			},
81			ErrorCode::ConflictException => VssError::ConflictError(error_response.message),
82			ErrorCode::AuthException => VssError::AuthError(error_response.message),
83			ErrorCode::InternalServerException => {
84				VssError::InternalServerError(error_response.message)
85			},
86			_ => VssError::InternalError(format!(
87				"VSS responded with an unknown error code: {}, message: {}",
88				error_response.error_code, error_response.message
89			)),
90		}
91	}
92}
93
94impl From<DecodeError> for VssError {
95	fn from(err: DecodeError) -> Self {
96		VssError::InternalError(err.to_string())
97	}
98}
99
100impl From<bitreq::Error> for VssError {
101	fn from(err: bitreq::Error) -> Self {
102		VssError::InternalError(err.to_string())
103	}
104}