gaspersic/solana
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Drop Error suffix from enum values to avoid the enum_variant_names clippy lint

Browse Source
This commit is contained in:
Michael Vines
2021-06-18 11:47:40 -07:00
committed by mergify[bot]
parent 2b39eb6412
commit 4a12c715a3
12 changed files with 77 additions and 76 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
core/src/broadcast_stage.rs
View File

@ -191,15 +191,15 @@ impl BroadcastStage {
fn handle_error(r: Result<()>, name: &str) -> Option<BroadcastStageReturnType> {
if let Err(e) = r {
match e {
Error::RecvTimeoutError(RecvTimeoutError::Disconnected)
| Error::SendError
| Error::RecvError(RecvError)
| Error::CrossbeamRecvTimeoutError(CrossbeamRecvTimeoutError::Disconnected) => {
Error::RecvTimeout(RecvTimeoutError::Disconnected)
| Error::Send
| Error::Recv(RecvError)
| Error::CrossbeamRecvTimeout(CrossbeamRecvTimeoutError::Disconnected) => {
return Some(BroadcastStageReturnType::ChannelDisconnected);
}
Error::RecvTimeoutError(RecvTimeoutError::Timeout)
| Error::CrossbeamRecvTimeoutError(CrossbeamRecvTimeoutError::Timeout) => (),
Error::ClusterInfoError(ClusterInfoError::NoPeers) => (), // TODO: Why are the unit-tests throwing hundreds of these?
Error::RecvTimeout(RecvTimeoutError::Timeout)
| Error::CrossbeamRecvTimeout(CrossbeamRecvTimeoutError::Timeout) => (),
Error::ClusterInfo(ClusterInfoError::NoPeers) => (), // TODO: Why are the unit-tests throwing hundreds of these?
_ => {
inc_new_counter_error!("streamer-broadcaster-error", 1, 1);
error!("{} broadcaster error: {:?}", name, e);

8
core/src/cluster_info_vote_listener.rs
View File

@ -394,10 +394,10 @@ impl ClusterInfoVoteListener {
would_be_leader,
) {
match e {
Error::CrossbeamRecvTimeoutError(RecvTimeoutError::Disconnected) => {
Error::CrossbeamRecvTimeout(RecvTimeoutError::Disconnected) => {
return Ok(());
}
Error::CrossbeamRecvTimeoutError(RecvTimeoutError::Timeout) => (),
Error::CrossbeamRecvTimeout(RecvTimeoutError::Timeout) => (),
_ => {
error!("thread {:?} error {:?}", thread::current().name(), e);
}
@ -479,8 +479,8 @@ impl ClusterInfoVoteListener {
.add_new_optimistic_confirmed_slots(confirmed_slots.clone());
}
Err(e) => match e {
Error::CrossbeamRecvTimeoutError(RecvTimeoutError::Timeout)
| Error::ReadyTimeoutError => (),
Error::CrossbeamRecvTimeout(RecvTimeoutError::Timeout)
| Error::ReadyTimeout => (),
_ => {
error!("thread {:?} error {:?}", thread::current().name(), e);
}

10
core/src/fetch_stage.rs
View File

@ -85,7 +85,7 @@ impl FetchStage {
inc_new_counter_debug!("fetch_stage-honor_forwards", len);
for packets in batch {
if sendr.send(packets).is_err() {
return Err(Error::SendError);
return Err(Error::Send);
}
}
} else {
@ -140,10 +140,10 @@ impl FetchStage {
Self::handle_forwarded_packets(&forward_receiver, &sender, &poh_recorder)
{
match e {
Error::RecvTimeoutError(RecvTimeoutError::Disconnected) => break,
Error::RecvTimeoutError(RecvTimeoutError::Timeout) => (),
Error::RecvError(_) => break,
Error::SendError => break,
Error::RecvTimeout(RecvTimeoutError::Disconnected) => break,
Error::RecvTimeout(RecvTimeoutError::Timeout) => (),
Error::Recv(_) => break,
Error::Send => break,
_ => error!("{:?}", e),
}
}

50
core/src/result.rs
View File

@ -6,18 +6,18 @@ use solana_ledger::blockstore;
#[derive(Debug)]
pub enum Error {
Io(std::io::Error),
RecvError(std::sync::mpsc::RecvError),
CrossbeamRecvTimeoutError(crossbeam_channel::RecvTimeoutError),
ReadyTimeoutError,
RecvTimeoutError(std::sync::mpsc::RecvTimeoutError),
CrossbeamSendError,
TryCrossbeamSendError,
Recv(std::sync::mpsc::RecvError),
CrossbeamRecvTimeout(crossbeam_channel::RecvTimeoutError),
ReadyTimeout,
RecvTimeout(std::sync::mpsc::RecvTimeoutError),
CrossbeamSend,
TryCrossbeamSend,
Serialize(std::boxed::Box<bincode::ErrorKind>),
ClusterInfoError(cluster_info::ClusterInfoError),
SendError,
BlockstoreError(blockstore::BlockstoreError),
WeightedIndexError(rand::distributions::weighted::WeightedError),
GossipError(GossipError),
ClusterInfo(cluster_info::ClusterInfoError),
Send,
Blockstore(blockstore::BlockstoreError),
WeightedIndex(rand::distributions::weighted::WeightedError),
Gossip(GossipError),
}
pub type Result<T> = std::result::Result<T, Error>;
@ -32,42 +32,42 @@ impl std::error::Error for Error {}
impl std::convert::From<std::sync::mpsc::RecvError> for Error {
fn from(e: std::sync::mpsc::RecvError) -> Error {
Error::RecvError(e)
Error::Recv(e)
}
}
impl std::convert::From<crossbeam_channel::RecvTimeoutError> for Error {
fn from(e: crossbeam_channel::RecvTimeoutError) -> Error {
Error::CrossbeamRecvTimeoutError(e)
Error::CrossbeamRecvTimeout(e)
}
}
impl std::convert::From<crossbeam_channel::ReadyTimeoutError> for Error {
fn from(_e: crossbeam_channel::ReadyTimeoutError) -> Error {
Error::ReadyTimeoutError
Error::ReadyTimeout
}
}
impl std::convert::From<std::sync::mpsc::RecvTimeoutError> for Error {
fn from(e: std::sync::mpsc::RecvTimeoutError) -> Error {
Error::RecvTimeoutError(e)
Error::RecvTimeout(e)
}
}
impl std::convert::From<cluster_info::ClusterInfoError> for Error {
fn from(e: cluster_info::ClusterInfoError) -> Error {
Error::ClusterInfoError(e)
Error::ClusterInfo(e)
}
}
impl<T> std::convert::From<crossbeam_channel::SendError<T>> for Error {
fn from(_e: crossbeam_channel::SendError<T>) -> Error {
Error::CrossbeamSendError
Error::CrossbeamSend
}
}
impl<T> std::convert::From<crossbeam_channel::TrySendError<T>> for Error {
fn from(_e: crossbeam_channel::TrySendError<T>) -> Error {
Error::TryCrossbeamSendError
Error::TryCrossbeamSend
}
}
impl<T> std::convert::From<std::sync::mpsc::SendError<T>> for Error {
fn from(_e: std::sync::mpsc::SendError<T>) -> Error {
Error::SendError
Error::Send
}
}
impl std::convert::From<std::io::Error> for Error {
@ -82,17 +82,17 @@ impl std::convert::From<std::boxed::Box<bincode::ErrorKind>> for Error {
}
impl std::convert::From<blockstore::BlockstoreError> for Error {
fn from(e: blockstore::BlockstoreError) -> Error {
Error::BlockstoreError(e)
Error::Blockstore(e)
}
}
impl std::convert::From<rand::distributions::weighted::WeightedError> for Error {
fn from(e: rand::distributions::weighted::WeightedError) -> Error {
Error::WeightedIndexError(e)
Error::WeightedIndex(e)
}
}
impl std::convert::From<GossipError> for Error {
fn from(e: GossipError) -> Error {
Error::GossipError(e)
Error::Gossip(e)
}
}
@ -116,12 +116,12 @@ mod tests {
#[test]
fn from_test() {
assert_matches!(Error::from(RecvError {}), Error::RecvError(_));
assert_matches!(Error::from(RecvError {}), Error::Recv(_));
assert_matches!(
Error::from(RecvTimeoutError::Timeout),
Error::RecvTimeoutError(_)
Error::RecvTimeout(_)
);
assert_matches!(send_error(), Err(Error::SendError));
assert_matches!(send_error(), Err(Error::Send));
let ioe = io::Error::new(io::ErrorKind::NotFound, "hi");
assert_matches!(Error::from(ioe), Error::Io(_));
}

4
core/src/retransmit_stage.rs
View File

@ -563,8 +563,8 @@ pub fn retransmitter(
&rpc_subscriptions,
) {
match e {
Error::RecvTimeoutError(RecvTimeoutError::Disconnected) => break,
Error::RecvTimeoutError(RecvTimeoutError::Timeout) => (),
Error::RecvTimeout(RecvTimeoutError::Disconnected) => break,
Error::RecvTimeout(RecvTimeoutError::Timeout) => (),
_ => {
inc_new_counter_error!("streamer-retransmit-error", 1, 1);
}

4
core/src/serve_repair.rs
View File

@ -323,7 +323,7 @@ impl ServeRepair {
&mut max_packets,
);
match result {
Err(Error::RecvTimeoutError(_)) | Ok(_) => {}
Err(Error::RecvTimeout(_)) | Ok(_) => {}
Err(err) => info!("repair listener error: {:?}", err),
};
if exit.load(Ordering::Relaxed) {
@ -777,7 +777,7 @@ mod tests {
&None,
&mut outstanding_requests,
);
assert_matches!(rv, Err(Error::ClusterInfoError(ClusterInfoError::NoPeers)));
assert_matches!(rv, Err(Error::ClusterInfo(ClusterInfoError::NoPeers)));
let serve_repair_addr = socketaddr!([127, 0, 0, 1], 1243);
let nxt = ContactInfo {

10
core/src/sigverify_stage.rs
View File

@ -24,10 +24,10 @@ const RECV_BATCH_MAX_GPU: usize = 5_000;
#[derive(Error, Debug)]
pub enum SigVerifyServiceError {
#[error("send packets batch error")]
SendError(#[from] SendError<Vec<Packets>>),
Send(#[from] SendError<Vec<Packets>>),
#[error("streamer error")]
StreamerError(#[from] StreamerError),
Streamer(#[from] StreamerError),
}
type Result<T> = std::result::Result<T, SigVerifyServiceError>;
@ -126,13 +126,13 @@ impl SigVerifyStage {
.spawn(move || loop {
if let Err(e) = Self::verifier(&packet_receiver, &verified_sender, id, &verifier) {
match e {
SigVerifyServiceError::StreamerError(StreamerError::RecvTimeoutError(
SigVerifyServiceError::Streamer(StreamerError::RecvTimeout(
RecvTimeoutError::Disconnected,
)) => break,
SigVerifyServiceError::StreamerError(StreamerError::RecvTimeoutError(
SigVerifyServiceError::Streamer(StreamerError::RecvTimeout(
RecvTimeoutError::Timeout,
)) => (),
SigVerifyServiceError::SendError(_) => {
SigVerifyServiceError::Send(_) => {
break;
}
_ => error!("{:?}", e),

2
core/src/verified_vote_packets.rs
View File

@ -188,7 +188,7 @@ mod tests {
let before = update_version;
assert_matches!(
verified_vote_packets.receive_and_process_vote_packets(&r, &mut update_version, true),
Err(Error::CrossbeamRecvTimeoutError(RecvTimeoutError::Timeout))
Err(Error::CrossbeamRecvTimeout(RecvTimeoutError::Timeout))
);
assert_eq!(before, update_version);
}

6
core/src/window_service.rs
View File

@ -582,12 +582,12 @@ impl WindowService {
H: Fn(),
{
match e {
Error::CrossbeamRecvTimeoutError(RecvTimeoutError::Disconnected) => true,
Error::CrossbeamRecvTimeoutError(RecvTimeoutError::Timeout) => {
Error::CrossbeamRecvTimeout(RecvTimeoutError::Disconnected) => true,
Error::CrossbeamRecvTimeout(RecvTimeoutError::Timeout) => {
handle_timeout();
false
}
Error::CrossbeamSendError => true,
Error::CrossbeamSend => true,
_ => {
handle_error();
error!("thread {:?} error {:?}", thread::current().name(), e);