use data_encoding::DecodeError;
use std::io;
use std::path::Path;
use std::str;
use thiserror::Error;
#[derive(Error, Debug, PartialEq, Eq)]
pub enum Error {
#[error("bad signature")]
BadSignature,
#[error("encoding: {0}")]
Encoding(String),
#[error("illegal argument: {0}")]
IllegalArgument(String),
#[error("no supported hash algorithm")]
NoSupportedHashAlgorithm,
#[error("not found")]
NotFound,
#[error("opaque: {0}")]
Opaque(String),
#[error("programming: {0}")]
Programming(String),
#[error("target unavailable")]
TargetUnavailable,
#[error("unknown hash algorithm: {0}")]
UnknownHashAlgorithm(String),
#[error("unknown key type: {0}")]
UnknownKeyType(String),
#[error("verification failure: {0}")]
VerificationFailure(String),
#[error("prefix selection failure: {0}")]
LinkGatheringError(String),
#[error("do Pre-Authentication Encoding failed: {0}")]
PAEParseFailed(String),
}
impl From<serde_json::error::Error> for Error {
fn from(err: serde_json::error::Error) -> Error {
Error::Encoding(format!("JSON: {:?}", err))
}
}
impl Error {
pub fn from_io(err: &io::Error, path: &Path) -> Error {
Error::Opaque(format!("Path {:?} : {:?}", path, err))
}
}
impl From<io::Error> for Error {
fn from(err: io::Error) -> Error {
match err.kind() {
std::io::ErrorKind::NotFound => Error::NotFound,
_ => Error::Opaque(format!("IO: {:?}", err)),
}
}
}
impl From<http::Error> for Error {
fn from(err: http::Error) -> Error {
Error::Opaque(format!("Http: {:?}", err))
}
}
impl From<hyper::Error> for Error {
fn from(err: hyper::Error) -> Error {
Error::Opaque(format!("Hyper: {:?}", err))
}
}
impl From<DecodeError> for Error {
fn from(err: DecodeError) -> Error {
Error::Encoding(format!("{:?}", err))
}
}
impl From<derp::Error> for Error {
fn from(err: derp::Error) -> Error {
Error::Encoding(format!("DER: {:?}", err))
}
}
impl From<tempfile::PersistError> for Error {
fn from(err: tempfile::PersistError) -> Error {
Error::Opaque(format!("Error persisting temp file: {:?}", err))
}
}
impl From<str::Utf8Error> for Error {
fn from(err: str::Utf8Error) -> Error {
Error::Opaque(format!("Parse utf8: {:?}", err))
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn verify_io_error_display_string() {
let err = Error::from(io::Error::from(std::io::ErrorKind::NotFound));
assert_eq!(err.to_string(), "not found");
assert_eq!(Error::NotFound.to_string(), "not found");
let err = Error::from(io::Error::from(std::io::ErrorKind::PermissionDenied));
assert_eq!(err.to_string(), "opaque: IO: Kind(PermissionDenied)");
}
}