htsget_storage/
error.rs

1//! Error and result types for htsget-storage.
2//!
3
4use htsget_config::types::HtsGetError;
5use std::io;
6use std::net::AddrParseError;
7use thiserror::Error;
8
9/// The result type for storage.
10pub type Result<T> = core::result::Result<T, StorageError>;
11
12/// Storage error type.
13#[derive(Error, Debug)]
14pub enum StorageError {
15  #[error("wrong key derived from ID: {0}")]
16  InvalidKey(String),
17
18  #[error("key not found in storage: {0}")]
19  KeyNotFound(String),
20
21  #[error("{0}: {1}")]
22  IoError(String, io::Error),
23
24  #[error("server error: {0}")]
25  ServerError(String),
26
27  #[error("invalid input: {0}")]
28  InvalidInput(String),
29
30  #[error("invalid uri: {0}")]
31  InvalidUri(String),
32
33  #[error("invalid address: {0}")]
34  InvalidAddress(AddrParseError),
35
36  #[error("unsupported format: {0}")]
37  UnsupportedFormat(String),
38
39  #[error("internal error: {0}")]
40  InternalError(String),
41
42  #[error("response error: {0}")]
43  ResponseError(String),
44
45  #[cfg(feature = "aws")]
46  #[error("aws error: {0}, with key: {1}")]
47  AwsS3Error(String, String),
48
49  #[error("parsing url: {0}")]
50  UrlParseError(String),
51}
52
53impl From<StorageError> for HtsGetError {
54  fn from(err: StorageError) -> Self {
55    match err {
56      err @ StorageError::InvalidInput(_) => Self::InvalidInput(err.to_string()),
57      err @ (StorageError::KeyNotFound(_)
58      | StorageError::InvalidKey(_)
59      | StorageError::ResponseError(_)) => Self::NotFound(err.to_string()),
60      err @ StorageError::IoError(_, _) => Self::IoError(err.to_string()),
61      err @ StorageError::UnsupportedFormat(_) => Self::UnsupportedFormat(err.to_string()),
62      err @ (StorageError::ServerError(_)
63      | StorageError::InvalidUri(_)
64      | StorageError::InvalidAddress(_)
65      | StorageError::InternalError(_)) => Self::InternalError(err.to_string()),
66      #[cfg(feature = "aws")]
67      err @ StorageError::AwsS3Error(_, _) => Self::IoError(err.to_string()),
68      err @ StorageError::UrlParseError(_) => Self::ParseError(err.to_string()),
69    }
70  }
71}
72
73impl From<StorageError> for io::Error {
74  fn from(err: StorageError) -> Self {
75    match err {
76      StorageError::IoError(_, ref io_error) => Self::new(io_error.kind(), err),
77      err => Self::other(err),
78    }
79  }
80}
81
82impl From<io::Error> for StorageError {
83  fn from(error: io::Error) -> Self {
84    Self::IoError("io error".to_string(), error)
85  }
86}
87
88#[cfg(test)]
89mod tests {
90  use super::*;
91  use htsget_config::types::HtsGetError;
92
93  #[test]
94  fn htsget_error_from_storage_not_found() {
95    let result = HtsGetError::from(StorageError::KeyNotFound("error".to_string()));
96    assert!(matches!(result, HtsGetError::NotFound(_)));
97  }
98
99  #[test]
100  fn htsget_error_from_storage_invalid_key() {
101    let result = HtsGetError::from(StorageError::InvalidKey("error".to_string()));
102    assert!(matches!(result, HtsGetError::NotFound(_)));
103  }
104}