path: root/src/api/common_error.rs

use err_derive::Error;
use hyper::StatusCode;

use garage_util::error::Error as GarageError;

/// Errors of this crate
#[derive(Debug, Error)]
pub enum CommonError {
	// ---- INTERNAL ERRORS ----
	/// Error related to deeper parts of Garage
	#[error(display = "Internal error: {}", _0)]
	InternalError(#[error(source)] GarageError),

	/// Error related to Hyper
	#[error(display = "Internal error (Hyper error): {}", _0)]
	Hyper(#[error(source)] hyper::Error),

	/// Error related to HTTP
	#[error(display = "Internal error (HTTP error): {}", _0)]
	Http(#[error(source)] http::Error),

	// ---- GENERIC CLIENT ERRORS ----
	/// Proper authentication was not provided
	#[error(display = "Forbidden: {}", _0)]
	Forbidden(String),

	/// Generic bad request response with custom message
	#[error(display = "Bad request: {}", _0)]
	BadRequest(String),

	// ---- SPECIFIC ERROR CONDITIONS ----
	// These have to be error codes referenced in the S3 spec here:
	// https://docs.aws.amazon.com/AmazonS3/latest/API/ErrorResponses.html#ErrorCodeList
	/// The bucket requested don't exists
	#[error(display = "Bucket not found: {}", _0)]
	NoSuchBucket(String),

	/// Tried to create a bucket that already exist
	#[error(display = "Bucket already exists")]
	BucketAlreadyExists,

	/// Tried to delete a non-empty bucket
	#[error(display = "Tried to delete a non-empty bucket")]
	BucketNotEmpty,

	// Category: bad request
	/// Bucket name is not valid according to AWS S3 specs
	#[error(display = "Invalid bucket name: {}", _0)]
	InvalidBucketName(String),
}

impl CommonError {
	pub fn http_status_code(&self) -> StatusCode {
		match self {
			CommonError::InternalError(
				GarageError::Timeout
				| GarageError::RemoteError(_)
				| GarageError::Quorum(_, _, _, _),
			) => StatusCode::SERVICE_UNAVAILABLE,
			CommonError::InternalError(_) | CommonError::Hyper(_) | CommonError::Http(_) => {
				StatusCode::INTERNAL_SERVER_ERROR
			}
			CommonError::BadRequest(_) => StatusCode::BAD_REQUEST,
			CommonError::Forbidden(_) => StatusCode::FORBIDDEN,
			CommonError::NoSuchBucket(_) => StatusCode::NOT_FOUND,
			CommonError::BucketNotEmpty | CommonError::BucketAlreadyExists => StatusCode::CONFLICT,
			CommonError::InvalidBucketName(_) => StatusCode::BAD_REQUEST,
		}
	}

	pub fn aws_code(&self) -> &'static str {
		match self {
			CommonError::Forbidden(_) => "AccessDenied",
			CommonError::InternalError(
				GarageError::Timeout
				| GarageError::RemoteError(_)
				| GarageError::Quorum(_, _, _, _),
			) => "ServiceUnavailable",
			CommonError::InternalError(_) | CommonError::Hyper(_) | CommonError::Http(_) => {
				"InternalError"
			}
			CommonError::BadRequest(_) => "InvalidRequest",
			CommonError::NoSuchBucket(_) => "NoSuchBucket",
			CommonError::BucketAlreadyExists => "BucketAlreadyExists",
			CommonError::BucketNotEmpty => "BucketNotEmpty",
			CommonError::InvalidBucketName(_) => "InvalidBucketName",
		}
	}

	pub fn bad_request<M: ToString>(msg: M) -> Self {
		CommonError::BadRequest(msg.to_string())
	}
}

pub trait CommonErrorDerivative: From<CommonError> {
	fn internal_error<M: ToString>(msg: M) -> Self {
		Self::from(CommonError::InternalError(GarageError::Message(
			msg.to_string(),
		)))
	}

	fn bad_request<M: ToString>(msg: M) -> Self {
		Self::from(CommonError::BadRequest(msg.to_string()))
	}

	fn forbidden<M: ToString>(msg: M) -> Self {
		Self::from(CommonError::Forbidden(msg.to_string()))
	}
}

/// Trait to map error to the Bad Request error code
pub trait OkOrBadRequest {
	type S;
	fn ok_or_bad_request<M: AsRef<str>>(self, reason: M) -> Result<Self::S, CommonError>;
}

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, CommonError> {
		match self {
			Ok(x) => Ok(x),
			Err(e) => Err(CommonError::BadRequest(format!(
				"{}: {}",
				reason.as_ref(),
				e
			))),
		}
	}
}

impl<T> OkOrBadRequest for Option<T> {
	type S = T;
	fn ok_or_bad_request<M: AsRef<str>>(self, reason: M) -> Result<T, CommonError> {
		match self {
			Some(x) => Ok(x),
			None => Err(CommonError::BadRequest(reason.as_ref().to_string())),
		}
	}
}

/// Trait to map an error to an Internal Error code
pub trait OkOrInternalError {
	type S;
	fn ok_or_internal_error<M: AsRef<str>>(self, reason: M) -> Result<Self::S, CommonError>;
}

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, CommonError> {
		match self {
			Ok(x) => Ok(x),
			Err(e) => Err(CommonError::InternalError(GarageError::Message(format!(
				"{}: {}",
				reason.as_ref(),
				e
			)))),
		}
	}
}

impl<T> OkOrInternalError for Option<T> {
	type S = T;
	fn ok_or_internal_error<M: AsRef<str>>(self, reason: M) -> Result<T, CommonError> {
		match self {
			Some(x) => Ok(x),
			None => Err(CommonError::InternalError(GarageError::Message(
				reason.as_ref().to_string(),
			))),
		}
	}
}