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
use serde::{Deserialize, Serialize};
use std::{
convert::From,
fmt::{self, Display},
};
use warp::{http::StatusCode, reject::Reject};
use crate::U64;
#[derive(Clone, Debug, Deserialize, Serialize, PartialEq)]
pub struct Error {
pub code: u16,
pub message: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub aptos_ledger_version: Option<U64>,
}
impl Error {
pub fn new(code: StatusCode, message: String) -> Self {
Self {
code: code.as_u16(),
message,
aptos_ledger_version: None,
}
}
pub fn from_anyhow_error(code: StatusCode, err: anyhow::Error) -> Self {
Self::new(code, err.to_string())
}
pub fn bad_request<S: Display>(msg: S) -> Self {
Self::new(StatusCode::BAD_REQUEST, msg.to_string())
}
pub fn not_found<S: Display>(resource: &str, identifier: S, ledger_version: u64) -> Self {
Self::new(
StatusCode::NOT_FOUND,
format!("{} not found by {}", resource, identifier),
)
.aptos_ledger_version(ledger_version)
}
pub fn invalid_param<S: Display>(name: &str, value: S) -> Self {
Self::bad_request(format!("invalid parameter {}: {}", name, value))
}
pub fn invalid_request_body<S: Display>(msg: S) -> Self {
Self::bad_request(format!("invalid request body: {}", msg))
}
pub fn insufficient_storage<S: Display>(msg: S) -> Self {
Self::new(StatusCode::INSUFFICIENT_STORAGE, msg.to_string())
}
pub fn internal(err: anyhow::Error) -> Self {
Self::from_anyhow_error(StatusCode::INTERNAL_SERVER_ERROR, err)
}
pub fn status_code(&self) -> StatusCode {
StatusCode::from_u16(self.code).unwrap_or(StatusCode::INTERNAL_SERVER_ERROR)
}
pub fn aptos_ledger_version(mut self, ledger_version: u64) -> Self {
self.aptos_ledger_version = Some(ledger_version.into());
self
}
}
impl fmt::Display for Error {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}: {}", self.status_code(), &self.message)?;
if let Some(val) = &self.aptos_ledger_version {
write!(f, "\ndiem ledger version: {}", val)?;
}
Ok(())
}
}
impl Reject for Error {}
impl From<anyhow::Error> for Error {
fn from(e: anyhow::Error) -> Self {
Self::internal(e)
}
}
impl From<serde_json::error::Error> for Error {
fn from(err: serde_json::error::Error) -> Self {
Self::internal(err.into())
}
}
#[cfg(test)]
mod tests {
use crate::error::Error;
use warp::http::StatusCode;
#[test]
fn test_to_string() {
let err = Error::new(StatusCode::BAD_REQUEST, "invalid address".to_owned());
assert_eq!(err.to_string(), "400 Bad Request: invalid address")
}
#[test]
fn test_from_anyhow_error_as_internal_error() {
let err = Error::from(anyhow::format_err!("hello"));
assert_eq!(err.to_string(), "500 Internal Server Error: hello")
}
#[test]
fn test_to_string_with_aptos_ledger_version() {
let err = Error::new(StatusCode::BAD_REQUEST, "invalid address".to_owned())
.aptos_ledger_version(123);
assert_eq!(
err.to_string(),
"400 Bad Request: invalid address\ndiem ledger version: 123"
)
}
#[test]
fn test_internal_error() {
let err = Error::internal(anyhow::format_err!("hello"));
assert_eq!(err.to_string(), "500 Internal Server Error: hello")
}
}
