2018-03-30 10:43:38 -07:00
|
|
|
//! The `result` module exposes a Result type that propagates one of many different Error types.
|
2018-03-29 11:20:54 -07:00
|
|
|
|
2018-12-07 19:16:27 -08:00
|
|
|
use crate::poh_recorder;
|
2021-01-24 07:47:43 -08:00
|
|
|
use crate::{cluster_info, duplicate_shred};
|
2019-10-31 13:38:50 -07:00
|
|
|
use solana_ledger::block_error;
|
2020-01-13 13:13:52 -08:00
|
|
|
use solana_ledger::blockstore;
|
2020-06-17 08:27:03 -07:00
|
|
|
use solana_runtime::snapshot_utils;
|
2019-03-13 13:37:24 -07:00
|
|
|
use solana_sdk::transaction;
|
2018-03-07 13:47:13 -08:00
|
|
|
use std::any::Any;
|
|
|
|
|
|
|
|
#[derive(Debug)]
|
|
|
|
pub enum Error {
|
2021-02-18 23:42:09 -08:00
|
|
|
Io(std::io::Error),
|
|
|
|
Json(serde_json::Error),
|
2018-03-07 13:47:13 -08:00
|
|
|
AddrParse(std::net::AddrParseError),
|
2018-12-08 21:44:20 -08:00
|
|
|
JoinError(Box<dyn Any + Send + 'static>),
|
2018-03-07 13:47:13 -08:00
|
|
|
RecvError(std::sync::mpsc::RecvError),
|
2019-06-26 18:42:27 -07:00
|
|
|
TryCrossbeamRecvError(crossbeam_channel::TryRecvError),
|
|
|
|
CrossbeamRecvTimeoutError(crossbeam_channel::RecvTimeoutError),
|
2020-07-20 17:29:07 -07:00
|
|
|
ReadyTimeoutError,
|
2018-03-07 13:47:13 -08:00
|
|
|
RecvTimeoutError(std::sync::mpsc::RecvTimeoutError),
|
2019-06-26 18:42:27 -07:00
|
|
|
CrossbeamSendError,
|
2020-09-01 22:06:06 -07:00
|
|
|
TryCrossbeamSendError,
|
2019-02-19 16:17:36 -08:00
|
|
|
TryRecvError(std::sync::mpsc::TryRecvError),
|
2018-03-10 20:09:17 -08:00
|
|
|
Serialize(std::boxed::Box<bincode::ErrorKind>),
|
2019-03-13 13:37:24 -07:00
|
|
|
TransactionError(transaction::TransactionError),
|
2018-10-08 19:55:54 -07:00
|
|
|
ClusterInfoError(cluster_info::ClusterInfoError),
|
2018-03-07 13:47:13 -08:00
|
|
|
SendError,
|
2018-10-18 22:57:48 -07:00
|
|
|
PohRecorderError(poh_recorder::PohRecorderError),
|
2019-10-31 13:38:50 -07:00
|
|
|
BlockError(block_error::BlockError),
|
2020-01-13 13:13:52 -08:00
|
|
|
BlockstoreError(blockstore::BlockstoreError),
|
2019-07-31 17:58:10 -07:00
|
|
|
FsExtra(fs_extra::error::Error),
|
2019-10-18 18:16:06 -07:00
|
|
|
SnapshotError(snapshot_utils::SnapshotError),
|
2020-12-03 06:26:07 -08:00
|
|
|
WeightedIndexError(rand::distributions::weighted::WeightedError),
|
2020-12-08 06:19:01 -08:00
|
|
|
DuplicateNodeInstance,
|
2021-01-24 07:47:43 -08:00
|
|
|
DuplicateShredError(duplicate_shred::Error),
|
2018-03-07 13:47:13 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
pub type Result<T> = std::result::Result<T, Error>;
|
|
|
|
|
2018-08-20 13:03:36 -07:00
|
|
|
impl std::fmt::Display for Error {
|
2018-12-08 21:44:20 -08:00
|
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
2018-08-20 13:03:36 -07:00
|
|
|
write!(f, "solana error")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl std::error::Error for Error {}
|
|
|
|
|
2018-03-07 13:47:13 -08:00
|
|
|
impl std::convert::From<std::sync::mpsc::RecvError> for Error {
|
|
|
|
fn from(e: std::sync::mpsc::RecvError) -> Error {
|
|
|
|
Error::RecvError(e)
|
|
|
|
}
|
|
|
|
}
|
2019-06-26 18:42:27 -07:00
|
|
|
impl std::convert::From<crossbeam_channel::TryRecvError> for Error {
|
|
|
|
fn from(e: crossbeam_channel::TryRecvError) -> Error {
|
|
|
|
Error::TryCrossbeamRecvError(e)
|
|
|
|
}
|
|
|
|
}
|
2019-02-19 16:17:36 -08:00
|
|
|
impl std::convert::From<std::sync::mpsc::TryRecvError> for Error {
|
|
|
|
fn from(e: std::sync::mpsc::TryRecvError) -> Error {
|
|
|
|
Error::TryRecvError(e)
|
|
|
|
}
|
|
|
|
}
|
2019-06-26 18:42:27 -07:00
|
|
|
impl std::convert::From<crossbeam_channel::RecvTimeoutError> for Error {
|
|
|
|
fn from(e: crossbeam_channel::RecvTimeoutError) -> Error {
|
|
|
|
Error::CrossbeamRecvTimeoutError(e)
|
|
|
|
}
|
|
|
|
}
|
2020-07-20 17:29:07 -07:00
|
|
|
impl std::convert::From<crossbeam_channel::ReadyTimeoutError> for Error {
|
|
|
|
fn from(_e: crossbeam_channel::ReadyTimeoutError) -> Error {
|
|
|
|
Error::ReadyTimeoutError
|
|
|
|
}
|
|
|
|
}
|
2018-03-07 13:47:13 -08:00
|
|
|
impl std::convert::From<std::sync::mpsc::RecvTimeoutError> for Error {
|
|
|
|
fn from(e: std::sync::mpsc::RecvTimeoutError) -> Error {
|
|
|
|
Error::RecvTimeoutError(e)
|
|
|
|
}
|
|
|
|
}
|
2019-03-13 13:37:24 -07:00
|
|
|
impl std::convert::From<transaction::TransactionError> for Error {
|
|
|
|
fn from(e: transaction::TransactionError) -> Error {
|
2019-03-13 12:58:44 -07:00
|
|
|
Error::TransactionError(e)
|
2018-04-19 10:32:02 -07:00
|
|
|
}
|
|
|
|
}
|
2018-10-08 19:55:54 -07:00
|
|
|
impl std::convert::From<cluster_info::ClusterInfoError> for Error {
|
|
|
|
fn from(e: cluster_info::ClusterInfoError) -> Error {
|
|
|
|
Error::ClusterInfoError(e)
|
2018-07-05 13:37:13 -07:00
|
|
|
}
|
|
|
|
}
|
2019-06-26 18:42:27 -07:00
|
|
|
impl<T> std::convert::From<crossbeam_channel::SendError<T>> for Error {
|
|
|
|
fn from(_e: crossbeam_channel::SendError<T>) -> Error {
|
|
|
|
Error::CrossbeamSendError
|
|
|
|
}
|
|
|
|
}
|
2020-09-01 22:06:06 -07:00
|
|
|
impl<T> std::convert::From<crossbeam_channel::TrySendError<T>> for Error {
|
|
|
|
fn from(_e: crossbeam_channel::TrySendError<T>) -> Error {
|
|
|
|
Error::TryCrossbeamSendError
|
|
|
|
}
|
|
|
|
}
|
2018-03-07 13:47:13 -08:00
|
|
|
impl<T> std::convert::From<std::sync::mpsc::SendError<T>> for Error {
|
|
|
|
fn from(_e: std::sync::mpsc::SendError<T>) -> Error {
|
|
|
|
Error::SendError
|
|
|
|
}
|
|
|
|
}
|
2018-12-08 21:44:20 -08:00
|
|
|
impl std::convert::From<Box<dyn Any + Send + 'static>> for Error {
|
|
|
|
fn from(e: Box<dyn Any + Send + 'static>) -> Error {
|
2018-03-07 13:47:13 -08:00
|
|
|
Error::JoinError(e)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
impl std::convert::From<std::io::Error> for Error {
|
|
|
|
fn from(e: std::io::Error) -> Error {
|
2021-02-18 23:42:09 -08:00
|
|
|
Error::Io(e)
|
2018-03-07 13:47:13 -08:00
|
|
|
}
|
|
|
|
}
|
2019-07-31 17:58:10 -07:00
|
|
|
impl std::convert::From<fs_extra::error::Error> for Error {
|
|
|
|
fn from(e: fs_extra::error::Error) -> Error {
|
|
|
|
Error::FsExtra(e)
|
|
|
|
}
|
|
|
|
}
|
2018-03-07 13:47:13 -08:00
|
|
|
impl std::convert::From<serde_json::Error> for Error {
|
|
|
|
fn from(e: serde_json::Error) -> Error {
|
2021-02-18 23:42:09 -08:00
|
|
|
Error::Json(e)
|
2018-03-07 13:47:13 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
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-10-18 22:57:48 -07:00
|
|
|
impl std::convert::From<poh_recorder::PohRecorderError> for Error {
|
|
|
|
fn from(e: poh_recorder::PohRecorderError) -> Error {
|
|
|
|
Error::PohRecorderError(e)
|
|
|
|
}
|
|
|
|
}
|
2020-01-13 13:13:52 -08:00
|
|
|
impl std::convert::From<blockstore::BlockstoreError> for Error {
|
|
|
|
fn from(e: blockstore::BlockstoreError) -> Error {
|
|
|
|
Error::BlockstoreError(e)
|
2018-11-15 15:53:31 -08:00
|
|
|
}
|
|
|
|
}
|
2019-10-18 18:16:06 -07:00
|
|
|
impl std::convert::From<snapshot_utils::SnapshotError> for Error {
|
|
|
|
fn from(e: snapshot_utils::SnapshotError) -> Error {
|
|
|
|
Error::SnapshotError(e)
|
|
|
|
}
|
|
|
|
}
|
2020-12-03 06:26:07 -08:00
|
|
|
impl std::convert::From<rand::distributions::weighted::WeightedError> for Error {
|
|
|
|
fn from(e: rand::distributions::weighted::WeightedError) -> Error {
|
|
|
|
Error::WeightedIndexError(e)
|
|
|
|
}
|
|
|
|
}
|
2021-01-24 07:47:43 -08:00
|
|
|
impl std::convert::From<duplicate_shred::Error> for Error {
|
|
|
|
fn from(e: duplicate_shred::Error) -> Error {
|
|
|
|
Error::DuplicateShredError(e)
|
|
|
|
}
|
|
|
|
}
|
2018-03-07 13:47:13 -08:00
|
|
|
|
|
|
|
#[cfg(test)]
|
|
|
|
mod tests {
|
2018-12-07 19:16:27 -08:00
|
|
|
use crate::result::Error;
|
|
|
|
use crate::result::Result;
|
2018-03-26 21:03:26 -07:00
|
|
|
use std::io;
|
|
|
|
use std::io::Write;
|
2018-03-07 13:47:13 -08:00
|
|
|
use std::net::SocketAddr;
|
2018-05-14 08:05:29 -07:00
|
|
|
use std::panic;
|
2018-05-29 20:20:28 -07:00
|
|
|
use std::sync::mpsc::channel;
|
2018-03-07 13:47:13 -08:00
|
|
|
use std::sync::mpsc::RecvError;
|
|
|
|
use std::sync::mpsc::RecvTimeoutError;
|
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> {
|
2020-05-15 09:35:43 -07:00
|
|
|
Ok("12fdfasfsafsadfs".parse()?)
|
2018-03-07 13:47:13 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
fn join_error() -> Result<()> {
|
2018-05-14 08:05:29 -07:00
|
|
|
panic::set_hook(Box::new(|_info| {}));
|
2020-05-15 09:35:43 -07:00
|
|
|
Ok(thread::spawn(|| panic!("hi")).join()?)
|
2018-03-07 13:47:13 -08:00
|
|
|
}
|
|
|
|
fn json_error() -> Result<()> {
|
2020-05-15 09:35:43 -07:00
|
|
|
Ok(serde_json::from_slice(b"=342{;;;;:}")?)
|
2018-03-07 13:47:13 -08:00
|
|
|
}
|
|
|
|
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");
|
2021-02-18 23:42:09 -08:00
|
|
|
assert_matches!(Error::from(ioe), Error::Io(_));
|
2018-03-07 13:47:13 -08:00
|
|
|
}
|
|
|
|
#[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"))
|
2018-12-07 19:01:28 -08:00
|
|
|
)
|
|
|
|
.unwrap();
|
2018-03-07 13:47:13 -08:00
|
|
|
}
|
|
|
|
}
|