pict-rs/src/error.rs

207 lines
5.9 KiB
Rust
Raw Normal View History

2021-06-19 19:39:41 +00:00
use actix_web::{http::StatusCode, HttpResponse, ResponseError};
2022-03-29 01:47:46 +00:00
use color_eyre::Report;
2021-09-14 01:22:42 +00:00
pub(crate) struct Error {
2022-03-29 01:47:46 +00:00
inner: color_eyre::Report,
}
impl Error {
fn kind(&self) -> Option<&UploadError> {
self.inner.downcast_ref()
}
2023-07-17 02:51:14 +00:00
pub(crate) fn root_cause(&self) -> &(dyn std::error::Error + 'static) {
self.inner.root_cause()
}
2021-09-14 01:22:42 +00:00
}
impl std::fmt::Debug for Error {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2022-03-29 01:47:46 +00:00
std::fmt::Debug::fmt(&self.inner, f)
2021-09-14 01:22:42 +00:00
}
}
impl std::fmt::Display for Error {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2022-03-29 01:47:46 +00:00
std::fmt::Display::fmt(&self.inner, f)
2021-09-14 01:22:42 +00:00
}
}
impl std::error::Error for Error {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
2022-03-29 01:47:46 +00:00
self.inner.source()
2021-09-14 01:22:42 +00:00
}
}
impl<T> From<T> for Error
where
UploadError: From<T>,
{
fn from(error: T) -> Self {
Error {
2022-03-29 01:47:46 +00:00
inner: Report::from(UploadError::from(error)),
2021-09-14 01:22:42 +00:00
}
}
}
2020-06-06 21:41:17 +00:00
#[derive(Debug, thiserror::Error)]
2020-06-11 16:46:00 +00:00
pub(crate) enum UploadError {
2023-06-23 16:20:55 +00:00
#[error("Couldn't upload file")]
2021-09-14 01:50:51 +00:00
Upload(#[from] actix_form_data::Error),
2020-06-06 21:41:17 +00:00
2022-03-26 21:49:23 +00:00
#[error("Error in DB")]
Repo(#[from] crate::repo::RepoError),
2022-03-26 21:49:23 +00:00
#[error("Error in old sled DB")]
OldSled(#[from] ::sled::Error),
2020-06-06 21:41:17 +00:00
2022-03-26 21:49:23 +00:00
#[error("Error parsing string")]
2020-06-06 21:41:17 +00:00
ParseString(#[from] std::string::FromUtf8Error),
2022-03-26 21:49:23 +00:00
#[error("Error interacting with filesystem")]
2020-06-07 00:29:15 +00:00
Io(#[from] std::io::Error),
2023-07-13 22:42:21 +00:00
#[error("Error validating upload")]
Validation(#[from] crate::validate::ValidationError),
2022-03-26 21:49:23 +00:00
#[error("Error generating path")]
2021-10-19 01:29:06 +00:00
PathGenerator(#[from] storage_path_generator::PathError),
2022-03-26 21:49:23 +00:00
#[error("Error stripping prefix")]
2021-10-19 01:29:06 +00:00
StripPrefix(#[from] std::path::StripPrefixError),
#[error("Error in store")]
Store(#[source] crate::store::StoreError),
2023-07-10 20:29:41 +00:00
#[error("Error in ffmpeg")]
Ffmpeg(#[from] crate::ffmpeg::FfMpegError),
#[error("Error in imagemagick")]
Magick(#[from] crate::magick::MagickError),
#[error("Error in exiftool")]
Exiftool(#[from] crate::exiftool::ExifError),
2023-07-17 19:24:49 +00:00
#[error("pict-rs is in read-only mode")]
ReadOnly,
#[error("Requested file extension cannot be served by source file")]
InvalidProcessExtension,
2021-10-21 02:36:18 +00:00
#[error("Provided process path is invalid")]
ParsePath,
#[error("Failed to acquire the semaphore")]
Semaphore,
2020-06-06 21:41:17 +00:00
#[error("Panic in blocking operation")]
Canceled,
#[error("No files present in upload")]
NoFiles,
2020-06-06 22:43:33 +00:00
#[error("Requested a file that doesn't exist")]
MissingAlias,
#[error("Requested a file that pict-rs lost track of")]
MissingIdentifier,
2020-06-07 00:29:15 +00:00
#[error("Provided token did not match expected token")]
InvalidToken,
2020-06-07 01:44:26 +00:00
#[error("Process endpoint was called with invalid extension")]
UnsupportedProcessExtension,
#[error("Unable to download image, bad response {0}")]
Download(actix_web::http::StatusCode),
2022-03-26 21:49:23 +00:00
#[error("Unable to download image")]
2021-03-10 02:51:03 +00:00
Payload(#[from] awc::error::PayloadError),
#[error("Unable to send request, {0}")]
SendRequest(String),
#[error("Tried to save an image with an already-taken name")]
DuplicateAlias,
2020-06-11 16:46:00 +00:00
2022-03-26 21:49:23 +00:00
#[error("Error in json")]
Json(#[from] serde_json::Error),
#[error("Error in cbor")]
Cbor(#[from] serde_cbor::Error),
#[error("Range header not satisfiable")]
Range,
2022-03-26 21:49:23 +00:00
#[error("Hit limit")]
Limit(#[from] crate::stream::LimitError),
#[error("Response timeout")]
Timeout(#[from] crate::stream::TimeoutError),
}
2021-03-10 02:51:03 +00:00
impl From<awc::error::SendRequestError> for UploadError {
fn from(e: awc::error::SendRequestError) -> Self {
UploadError::SendRequest(e.to_string())
}
2020-06-07 00:29:15 +00:00
}
2021-02-10 22:57:42 +00:00
impl From<actix_web::error::BlockingError> for UploadError {
fn from(_: actix_web::error::BlockingError) -> Self {
UploadError::Canceled
2020-06-06 21:41:17 +00:00
}
}
impl From<tokio::sync::AcquireError> for UploadError {
fn from(_: tokio::sync::AcquireError) -> Self {
UploadError::Semaphore
}
}
impl From<crate::store::StoreError> for UploadError {
fn from(value: crate::store::StoreError) -> Self {
match value {
crate::store::StoreError::Repo(repo_error) => Self::Repo(repo_error),
e => Self::Store(e),
}
}
}
2021-09-14 01:22:42 +00:00
impl ResponseError for Error {
2020-06-06 21:41:17 +00:00
fn status_code(&self) -> StatusCode {
2022-03-29 01:47:46 +00:00
match self.kind() {
Some(
UploadError::DuplicateAlias
| UploadError::Limit(_)
| UploadError::NoFiles
2022-03-29 16:04:56 +00:00
| UploadError::Upload(_)
| UploadError::Store(crate::store::StoreError::Repo(
crate::repo::RepoError::AlreadyClaimed,
))
| UploadError::Repo(crate::repo::RepoError::AlreadyClaimed)
2023-07-13 22:42:21 +00:00
| UploadError::Validation(_)
| UploadError::UnsupportedProcessExtension
2023-07-17 19:24:49 +00:00
| UploadError::InvalidProcessExtension
| UploadError::ReadOnly,
2022-03-29 01:47:46 +00:00
) => StatusCode::BAD_REQUEST,
2023-07-10 20:29:41 +00:00
Some(UploadError::Magick(e)) if e.is_client_error() => StatusCode::BAD_REQUEST,
Some(UploadError::Ffmpeg(e)) if e.is_client_error() => StatusCode::BAD_REQUEST,
Some(UploadError::Exiftool(e)) if e.is_client_error() => StatusCode::BAD_REQUEST,
Some(UploadError::MissingAlias) => StatusCode::NOT_FOUND,
2023-07-10 20:29:41 +00:00
Some(UploadError::Ffmpeg(e)) if e.is_not_found() => StatusCode::NOT_FOUND,
2022-03-29 01:47:46 +00:00
Some(UploadError::InvalidToken) => StatusCode::FORBIDDEN,
Some(UploadError::Range) => StatusCode::RANGE_NOT_SATISFIABLE,
2020-06-06 21:41:17 +00:00
_ => StatusCode::INTERNAL_SERVER_ERROR,
}
}
2021-06-19 19:39:41 +00:00
fn error_response(&self) -> HttpResponse {
2023-07-17 02:51:14 +00:00
HttpResponse::build(self.status_code())
.content_type("application/json")
.body(
serde_json::to_string(&serde_json::json!({ "msg": self.root_cause().to_string() }))
.unwrap_or_else(|_| r#"{"msg":"Request failed"}"#.to_string()),
)
2020-06-06 21:41:17 +00:00
}
}