garage/src/api/error.rs

224 lines
6 KiB
Rust
Raw Normal View History

use std::convert::TryInto;
2020-11-08 14:04:30 +00:00
use err_derive::Error;
use hyper::header::HeaderValue;
use hyper::{HeaderMap, StatusCode};
2020-11-08 14:04:30 +00:00
use garage_util::error::Error as GarageError;
use crate::s3_xml;
2021-03-26 21:32:09 +00:00
/// Errors of this crate
2020-11-08 14:04:30 +00:00
#[derive(Debug, Error)]
pub enum Error {
// Category: internal error
2021-03-26 21:32:09 +00:00
/// Error related to deeper parts of Garage
2020-11-08 14:04:30 +00:00
#[error(display = "Internal error: {}", _0)]
InternalError(#[error(source)] GarageError),
2021-03-26 21:32:09 +00:00
/// Error related to Hyper
2020-11-08 14:04:30 +00:00
#[error(display = "Internal error (Hyper error): {}", _0)]
Hyper(#[error(source)] hyper::Error),
2021-03-26 21:32:09 +00:00
/// Error related to HTTP
2020-11-08 14:04:30 +00:00
#[error(display = "Internal error (HTTP error): {}", _0)]
2021-05-02 21:13:08 +00:00
Http(#[error(source)] http::Error),
2020-11-08 14:04:30 +00:00
// Category: cannot process
2021-03-26 21:32:09 +00:00
/// No proper api key was used, or the signature was invalid
2020-11-08 14:04:30 +00:00
#[error(display = "Forbidden: {}", _0)]
Forbidden(String),
/// Authorization Header Malformed
#[error(display = "Authorization header malformed, expected scope: {}", _0)]
AuthorizationHeaderMalformed(String),
2021-03-26 21:32:09 +00:00
/// The object requested don't exists
2020-11-08 14:04:30 +00:00
#[error(display = "Not found")]
NotFound,
// Category: bad request
2021-04-06 03:25:28 +00:00
/// The request contained an invalid UTF-8 sequence in its path or in other parameters
2020-11-08 14:04:30 +00:00
#[error(display = "Invalid UTF-8: {}", _0)]
2021-05-02 21:13:08 +00:00
InvalidUtf8Str(#[error(source)] std::str::Utf8Error),
2021-02-19 15:44:06 +00:00
2021-03-26 21:32:09 +00:00
/// The request used an invalid path
2021-02-19 15:44:06 +00:00
#[error(display = "Invalid UTF-8: {}", _0)]
2021-05-02 21:13:08 +00:00
InvalidUtf8String(#[error(source)] std::string::FromUtf8Error),
2021-02-19 15:44:06 +00:00
2021-03-26 21:32:09 +00:00
/// Some base64 encoded data was badly encoded
2021-02-19 15:44:06 +00:00
#[error(display = "Invalid base64: {}", _0)]
InvalidBase64(#[error(source)] base64::DecodeError),
2020-11-08 14:04:30 +00:00
2021-03-26 21:32:09 +00:00
/// The client sent invalid XML data
2020-11-08 14:04:30 +00:00
#[error(display = "Invalid XML: {}", _0)]
2021-05-02 21:13:08 +00:00
InvalidXml(String),
2020-11-08 14:04:30 +00:00
2021-03-26 21:32:09 +00:00
/// The client sent a header with invalid value
2020-11-08 14:04:30 +00:00
#[error(display = "Invalid header value: {}", _0)]
InvalidHeader(#[error(source)] hyper::header::ToStrError),
2021-03-26 21:32:09 +00:00
/// The client sent a range header with invalid value
2020-11-08 14:04:30 +00:00
#[error(display = "Invalid HTTP range: {:?}", _0)]
InvalidRange(#[error(from)] (http_range::HttpRangeParseError, u64)),
2020-11-08 14:04:30 +00:00
2021-03-26 21:32:09 +00:00
/// The client sent an invalid request
2020-11-08 14:04:30 +00:00
#[error(display = "Bad request: {}", _0)]
BadRequest(String),
/// The client sent a request for an action not supported by garage
#[error(display = "Unimplemented action: {}", _0)]
NotImplemented(String),
2020-11-08 14:04:30 +00:00
}
2021-03-16 14:58:40 +00:00
impl From<roxmltree::Error> for Error {
fn from(err: roxmltree::Error) -> Self {
2021-05-02 21:13:08 +00:00
Self::InvalidXml(format!("{}", err))
2021-03-16 14:58:40 +00:00
}
}
2021-05-02 20:30:56 +00:00
impl From<quick_xml::de::DeError> for Error {
fn from(err: quick_xml::de::DeError) -> Self {
2021-05-02 21:13:08 +00:00
Self::InvalidXml(format!("{}", err))
2021-05-02 20:30:56 +00:00
}
}
2020-11-08 14:04:30 +00:00
impl Error {
2021-04-06 03:25:28 +00:00
/// Get the HTTP status code that best represents the meaning of the error for the client
2020-11-08 14:04:30 +00:00
pub fn http_status_code(&self) -> StatusCode {
match self {
Error::NotFound => StatusCode::NOT_FOUND,
Error::Forbidden(_) => StatusCode::FORBIDDEN,
Error::InternalError(
GarageError::Timeout
| GarageError::RemoteError(_)
| GarageError::Quorum(_, _, _, _),
) => StatusCode::SERVICE_UNAVAILABLE,
2021-05-02 21:13:08 +00:00
Error::InternalError(_) | Error::Hyper(_) | Error::Http(_) => {
2020-11-08 14:04:30 +00:00
StatusCode::INTERNAL_SERVER_ERROR
}
Error::InvalidRange(_) => StatusCode::RANGE_NOT_SATISFIABLE,
Error::NotImplemented(_) => StatusCode::NOT_IMPLEMENTED,
2020-11-08 14:04:30 +00:00
_ => StatusCode::BAD_REQUEST,
}
}
pub fn aws_code(&self) -> &'static str {
match self {
Error::NotFound => "NoSuchKey",
Error::Forbidden(_) => "AccessDenied",
Error::AuthorizationHeaderMalformed(_) => "AuthorizationHeaderMalformed",
Error::InternalError(
GarageError::Timeout
| GarageError::RemoteError(_)
| GarageError::Quorum(_, _, _, _),
) => "ServiceUnavailable",
2021-05-02 21:13:08 +00:00
Error::InternalError(_) | Error::Hyper(_) | Error::Http(_) => "InternalError",
_ => "InvalidRequest",
}
}
pub fn aws_xml(&self, garage_region: &str, path: &str) -> String {
let error = s3_xml::Error {
code: s3_xml::Value(self.aws_code().to_string()),
message: s3_xml::Value(format!("{}", self)),
resource: Some(s3_xml::Value(path.to_string())),
region: Some(s3_xml::Value(garage_region.to_string())),
};
s3_xml::to_xml_with_header(&error).unwrap_or_else(|_| {
r#"
<?xml version="1.0" encoding="UTF-8"?>
<Error>
<Code>InternalError</Code>
<Message>XML encoding of error failed</Message>
</Error>
"#
.into()
})
}
pub fn add_headers(&self, header_map: &mut HeaderMap<HeaderValue>) {
use hyper::header;
#[allow(clippy::single_match)]
match self {
Error::InvalidRange((_, len)) => {
header_map.append(
header::CONTENT_RANGE,
format!("bytes */{}", len)
.try_into()
.expect("header value only contain ascii"),
);
}
_ => (),
}
}
2020-11-08 14:04:30 +00:00
}
2021-03-26 21:32:09 +00:00
/// Trait to map error to the Bad Request error code
2020-11-08 14:04:30 +00:00
pub trait OkOrBadRequest {
type S;
fn ok_or_bad_request<M: AsRef<str>>(self, reason: M) -> Result<Self::S, Error>;
2020-11-08 14:04:30 +00:00
}
impl<T, E> OkOrBadRequest for Result<T, E>
where
E: std::fmt::Display,
{
type S = T;
fn ok_or_bad_request<M: AsRef<str>>(self, reason: M) -> Result<T, Error> {
2020-11-08 14:04:30 +00:00
match self {
Ok(x) => Ok(x),
Err(e) => Err(Error::BadRequest(format!(
"{}: {}",
reason.as_ref(),
e.to_string()
))),
2020-11-08 14:04:30 +00:00
}
}
}
impl<T> OkOrBadRequest for Option<T> {
type S = T;
fn ok_or_bad_request<M: AsRef<str>>(self, reason: M) -> Result<T, Error> {
2020-11-08 14:04:30 +00:00
match self {
Some(x) => Ok(x),
None => Err(Error::BadRequest(reason.as_ref().to_string())),
2020-11-08 14:04:30 +00:00
}
}
}
2021-03-26 21:32:09 +00:00
/// Trait to map an error to an Internal Error code
2020-11-08 14:04:30 +00:00
pub trait OkOrInternalError {
type S;
fn ok_or_internal_error<M: AsRef<str>>(self, reason: M) -> Result<Self::S, Error>;
2020-11-08 14:04:30 +00:00
}
impl<T, E> OkOrInternalError for Result<T, E>
where
E: std::fmt::Display,
{
type S = T;
fn ok_or_internal_error<M: AsRef<str>>(self, reason: M) -> Result<T, Error> {
2020-11-08 14:04:30 +00:00
match self {
Ok(x) => Ok(x),
Err(e) => Err(Error::InternalError(GarageError::Message(format!(
"{}: {}",
reason.as_ref(),
e
2020-11-08 14:04:30 +00:00
)))),
}
}
}
impl<T> OkOrInternalError for Option<T> {
type S = T;
fn ok_or_internal_error<M: AsRef<str>>(self, reason: M) -> Result<T, Error> {
2020-11-08 14:04:30 +00:00
match self {
Some(x) => Ok(x),
2021-04-23 20:18:00 +00:00
None => Err(Error::InternalError(GarageError::Message(
reason.as_ref().to_string(),
2021-04-23 20:18:00 +00:00
))),
2020-11-08 14:04:30 +00:00
}
}
}