extern crate serde_json;
use serde_json::error::Error as SerdeJsonError;
use std::{fmt, str};
use std::error::Error as StdError;
use std::ffi::{IntoStringError, NulError};
use std::io::Error;
use std::num::ParseIntError;
use std::string::FromUtf8Error;
use uuid::ParseError;
use ceph_version::CephVersion;
#[derive(Debug)]
pub enum RadosError {
FromUtf8Error(FromUtf8Error),
NulError(NulError),
Error(String),
IoError(Error),
IntoStringError(IntoStringError),
ParseIntError(ParseIntError),
ParseError(ParseError),
SerdeError(SerdeJsonError),
MinVersion(CephVersion, CephVersion),
Parse(String),
}
pub type RadosResult<T> = Result<T, RadosError>;
impl fmt::Display for RadosError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.write_str(self.description())
}
}
impl StdError for RadosError {
fn description(&self) -> &str {
match *self {
RadosError::FromUtf8Error(ref e) => e.description(),
RadosError::NulError(ref e) => e.description(),
RadosError::Error(ref e) => &e,
RadosError::IoError(ref e) => e.description(),
RadosError::IntoStringError(ref e) => e.description(),
RadosError::ParseError(ref e) => e.description(),
RadosError::ParseIntError(ref e) => e.description(),
RadosError::SerdeError(ref e) => e.description(),
RadosError::MinVersion(ref _min, ref _current_version) => "Ceph version is too low",
RadosError::Parse(ref _input) => "An error occurred during parsing",
}
}
fn cause(&self) -> Option<&StdError> {
match *self {
RadosError::FromUtf8Error(ref e) => e.cause(),
RadosError::NulError(ref e) => e.cause(),
RadosError::Error(_) => None,
RadosError::IoError(ref e) => e.cause(),
RadosError::IntoStringError(ref e) => e.cause(),
RadosError::ParseError(ref e) => e.cause(),
RadosError::ParseIntError(ref e) => e.cause(),
RadosError::SerdeError(ref e) => e.cause(),
RadosError::MinVersion(ref _min, ref _current_version) => None,
RadosError::Parse(ref _input) => None
}
}
}
impl RadosError {
pub fn new(err: String) -> RadosError {
RadosError::Error(err)
}
pub fn to_string(&self) -> String {
match *self {
RadosError::FromUtf8Error(ref err) => err.utf8_error().to_string(),
RadosError::NulError(ref err) => err.description().to_string(),
RadosError::Error(ref err) => err.to_string(),
RadosError::IoError(ref err) => err.description().to_string(),
RadosError::IntoStringError(ref err) => err.description().to_string(),
RadosError::ParseError(_) => "Uuid parse error".to_string(),
RadosError::ParseIntError(ref err) => err.description().to_string(),
RadosError::SerdeError(ref err) => err.description().to_string(),
RadosError::MinVersion(ref min, ref current_version) => {
format!("{:?} minimum, your version is {:?}", min, current_version)
},
RadosError::Parse(ref input) => {
format!("Couldn't parse the CephVersion from {}", input)
},
}
}
}
impl From<ParseError> for RadosError {
fn from(err: ParseError) -> RadosError {
RadosError::ParseError(err)
}
}
impl From<ParseIntError> for RadosError {
fn from(err: ParseIntError) -> RadosError {
RadosError::ParseIntError(err)
}
}
impl From<SerdeJsonError> for RadosError {
fn from(err: SerdeJsonError) -> RadosError {
RadosError::SerdeError(err)
}
}
impl From<NulError> for RadosError {
fn from(err: NulError) -> RadosError {
RadosError::NulError(err)
}
}
impl From<FromUtf8Error> for RadosError {
fn from(err: FromUtf8Error) -> RadosError {
RadosError::FromUtf8Error(err)
}
}
impl From<IntoStringError> for RadosError {
fn from(err: IntoStringError) -> RadosError {
RadosError::IntoStringError(err)
}
}
impl From<Error> for RadosError {
fn from(err: Error) -> RadosError {
RadosError::IoError(err)
}
}