2018-03-29 11:20:54 -07:00
|
|
|
//! Exposes a Result type that propagates one of many different Error types.
|
|
|
|
|
2018-03-26 21:03:26 -07:00
|
|
|
use bincode;
|
2018-03-07 13:47:13 -08:00
|
|
|
use serde_json;
|
|
|
|
use std;
|
|
|
|
use std::any::Any;
|
|
|
|
|
|
|
|
#[derive(Debug)]
|
|
|
|
pub enum Error {
|
|
|
|
IO(std::io::Error),
|
|
|
|
JSON(serde_json::Error),
|
|
|
|
AddrParse(std::net::AddrParseError),
|
|
|
|
JoinError(Box<Any + Send + 'static>),
|
|
|
|
RecvError(std::sync::mpsc::RecvError),
|
|
|
|
RecvTimeoutError(std::sync::mpsc::RecvTimeoutError),
|
2018-03-10 20:09:17 -08:00
|
|
|
Serialize(std::boxed::Box<bincode::ErrorKind>),
|
2018-03-07 13:47:13 -08:00
|
|
|
SendError,
|
2018-03-24 18:01:40 -07:00
|
|
|
Services,
|
2018-03-07 13:47:13 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
pub type Result<T> = std::result::Result<T, Error>;
|
|
|
|
|
|
|
|
impl std::convert::From<std::sync::mpsc::RecvError> for Error {
|
|
|
|
fn from(e: std::sync::mpsc::RecvError) -> Error {
|
|
|
|
Error::RecvError(e)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
impl std::convert::From<std::sync::mpsc::RecvTimeoutError> for Error {
|
|
|
|
fn from(e: std::sync::mpsc::RecvTimeoutError) -> Error {
|
|
|
|
Error::RecvTimeoutError(e)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
impl<T> std::convert::From<std::sync::mpsc::SendError<T>> for Error {
|
|
|
|
fn from(_e: std::sync::mpsc::SendError<T>) -> Error {
|
|
|
|
Error::SendError
|
|
|
|
}
|
|
|
|
}
|
|
|
|
impl std::convert::From<Box<Any + Send + 'static>> for Error {
|
|
|
|
fn from(e: Box<Any + Send + 'static>) -> Error {
|
|
|
|
Error::JoinError(e)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl std::convert::From<std::io::Error> for Error {
|
|
|
|
fn from(e: std::io::Error) -> Error {
|
|
|
|
Error::IO(e)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
impl std::convert::From<serde_json::Error> for Error {
|
|
|
|
fn from(e: serde_json::Error) -> Error {
|
|
|
|
Error::JSON(e)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
impl std::convert::From<std::net::AddrParseError> for Error {
|
|
|
|
fn from(e: std::net::AddrParseError) -> Error {
|
|
|
|
Error::AddrParse(e)
|
|
|
|
}
|
|
|
|
}
|
2018-03-10 20:09:17 -08:00
|
|
|
impl std::convert::From<std::boxed::Box<bincode::ErrorKind>> for Error {
|
|
|
|
fn from(e: std::boxed::Box<bincode::ErrorKind>) -> Error {
|
|
|
|
Error::Serialize(e)
|
|
|
|
}
|
|
|
|
}
|
2018-03-07 13:47:13 -08:00
|
|
|
|
|
|
|
#[cfg(test)]
|
|
|
|
mod tests {
|
|
|
|
use result::Error;
|
2018-03-26 21:03:26 -07:00
|
|
|
use result::Result;
|
|
|
|
use serde_json;
|
|
|
|
use std::io;
|
|
|
|
use std::io::Write;
|
2018-03-07 13:47:13 -08:00
|
|
|
use std::net::SocketAddr;
|
|
|
|
use std::sync::mpsc::RecvError;
|
|
|
|
use std::sync::mpsc::RecvTimeoutError;
|
|
|
|
use std::sync::mpsc::channel;
|
2018-03-26 21:03:26 -07:00
|
|
|
use std::thread;
|
2018-03-07 13:47:13 -08:00
|
|
|
|
|
|
|
fn addr_parse_error() -> Result<SocketAddr> {
|
|
|
|
let r = "12fdfasfsafsadfs".parse()?;
|
|
|
|
Ok(r)
|
|
|
|
}
|
|
|
|
|
|
|
|
fn join_error() -> Result<()> {
|
|
|
|
let r = thread::spawn(|| panic!("hi")).join()?;
|
|
|
|
Ok(r)
|
|
|
|
}
|
|
|
|
fn json_error() -> Result<()> {
|
|
|
|
let r = serde_json::from_slice("=342{;;;;:}".as_bytes())?;
|
|
|
|
Ok(r)
|
|
|
|
}
|
|
|
|
fn send_error() -> Result<()> {
|
|
|
|
let (s, r) = channel();
|
|
|
|
drop(r);
|
|
|
|
s.send(())?;
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn from_test() {
|
|
|
|
assert_matches!(addr_parse_error(), Err(Error::AddrParse(_)));
|
|
|
|
assert_matches!(Error::from(RecvError {}), Error::RecvError(_));
|
|
|
|
assert_matches!(
|
|
|
|
Error::from(RecvTimeoutError::Timeout),
|
|
|
|
Error::RecvTimeoutError(_)
|
|
|
|
);
|
|
|
|
assert_matches!(send_error(), Err(Error::SendError));
|
|
|
|
assert_matches!(join_error(), Err(Error::JoinError(_)));
|
|
|
|
let ioe = io::Error::new(io::ErrorKind::NotFound, "hi");
|
|
|
|
assert_matches!(Error::from(ioe), Error::IO(_));
|
|
|
|
}
|
|
|
|
#[test]
|
|
|
|
fn fmt_test() {
|
|
|
|
write!(io::sink(), "{:?}", addr_parse_error()).unwrap();
|
|
|
|
write!(io::sink(), "{:?}", Error::from(RecvError {})).unwrap();
|
|
|
|
write!(io::sink(), "{:?}", Error::from(RecvTimeoutError::Timeout)).unwrap();
|
|
|
|
write!(io::sink(), "{:?}", send_error()).unwrap();
|
|
|
|
write!(io::sink(), "{:?}", join_error()).unwrap();
|
|
|
|
write!(io::sink(), "{:?}", json_error()).unwrap();
|
|
|
|
write!(
|
|
|
|
io::sink(),
|
|
|
|
"{:?}",
|
|
|
|
Error::from(io::Error::new(io::ErrorKind::NotFound, "hi"))
|
|
|
|
).unwrap();
|
|
|
|
}
|
|
|
|
}
|