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

8
core/src/cluster_info_vote_listener.rs
View File

@ -394,10 +394,10 @@ impl ClusterInfoVoteListener {
would_be_leader, would_be_leader,
) { ) {
match e { match e {
Error::CrossbeamRecvTimeoutError(RecvTimeoutError::Disconnected) => { Error::CrossbeamRecvTimeout(RecvTimeoutError::Disconnected) => {
return Ok(()); return Ok(());
} }
Error::CrossbeamRecvTimeoutError(RecvTimeoutError::Timeout) => (), Error::CrossbeamRecvTimeout(RecvTimeoutError::Timeout) => (),
_ => { _ => {
error!("thread {:?} error {:?}", thread::current().name(), e); error!("thread {:?} error {:?}", thread::current().name(), e);
} }
@ -479,8 +479,8 @@ impl ClusterInfoVoteListener {
.add_new_optimistic_confirmed_slots(confirmed_slots.clone()); .add_new_optimistic_confirmed_slots(confirmed_slots.clone());
} }
Err(e) => match e { Err(e) => match e {
Error::CrossbeamRecvTimeoutError(RecvTimeoutError::Timeout) Error::CrossbeamRecvTimeout(RecvTimeoutError::Timeout)
| Error::ReadyTimeoutError => (), | Error::ReadyTimeout => (),
_ => { _ => {
error!("thread {:?} error {:?}", thread::current().name(), e); 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); inc_new_counter_debug!("fetch_stage-honor_forwards", len);
for packets in batch { for packets in batch {
if sendr.send(packets).is_err() { if sendr.send(packets).is_err() {
return Err(Error::SendError); return Err(Error::Send);
} }
} }
} else { } else {
@ -140,10 +140,10 @@ impl FetchStage {
Self::handle_forwarded_packets(&forward_receiver, &sender, &poh_recorder) Self::handle_forwarded_packets(&forward_receiver, &sender, &poh_recorder)
{ {
match e { match e {
Error::RecvTimeoutError(RecvTimeoutError::Disconnected) => break, Error::RecvTimeout(RecvTimeoutError::Disconnected) => break,
Error::RecvTimeoutError(RecvTimeoutError::Timeout) => (), Error::RecvTimeout(RecvTimeoutError::Timeout) => (),
Error::RecvError(_) => break, Error::Recv(_) => break,
Error::SendError => break, Error::Send => break,
_ => error!("{:?}", e), _ => error!("{:?}", e),
} }
} }

50
core/src/result.rs
View File

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

4
core/src/retransmit_stage.rs
View File

@ -563,8 +563,8 @@ pub fn retransmitter(
&rpc_subscriptions, &rpc_subscriptions,
) { ) {
match e { match e {
Error::RecvTimeoutError(RecvTimeoutError::Disconnected) => break, Error::RecvTimeout(RecvTimeoutError::Disconnected) => break,
Error::RecvTimeoutError(RecvTimeoutError::Timeout) => (), Error::RecvTimeout(RecvTimeoutError::Timeout) => (),
_ => { _ => {
inc_new_counter_error!("streamer-retransmit-error", 1, 1); 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, &mut max_packets,
); );
match result { match result {
Err(Error::RecvTimeoutError(_)) | Ok(_) => {} Err(Error::RecvTimeout(_)) | Ok(_) => {}
Err(err) => info!("repair listener error: {:?}", err), Err(err) => info!("repair listener error: {:?}", err),
}; };
if exit.load(Ordering::Relaxed) { if exit.load(Ordering::Relaxed) {
@ -777,7 +777,7 @@ mod tests {
&None, &None,
&mut outstanding_requests, &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 serve_repair_addr = socketaddr!([127, 0, 0, 1], 1243);
let nxt = ContactInfo { 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)] #[derive(Error, Debug)]
pub enum SigVerifyServiceError { pub enum SigVerifyServiceError {
#[error("send packets batch error")] #[error("send packets batch error")]
SendError(#[from] SendError<Vec<Packets>>), Send(#[from] SendError<Vec<Packets>>),
#[error("streamer error")] #[error("streamer error")]
StreamerError(#[from] StreamerError), Streamer(#[from] StreamerError),
} }
type Result<T> = std::result::Result<T, SigVerifyServiceError>; type Result<T> = std::result::Result<T, SigVerifyServiceError>;
@ -126,13 +126,13 @@ impl SigVerifyStage {
.spawn(move || loop { .spawn(move || loop {
if let Err(e) = Self::verifier(&packet_receiver, &verified_sender, id, &verifier) { if let Err(e) = Self::verifier(&packet_receiver, &verified_sender, id, &verifier) {
match e { match e {
SigVerifyServiceError::StreamerError(StreamerError::RecvTimeoutError( SigVerifyServiceError::Streamer(StreamerError::RecvTimeout(
RecvTimeoutError::Disconnected, RecvTimeoutError::Disconnected,
)) => break, )) => break,
SigVerifyServiceError::StreamerError(StreamerError::RecvTimeoutError( SigVerifyServiceError::Streamer(StreamerError::RecvTimeout(
RecvTimeoutError::Timeout, RecvTimeoutError::Timeout,
)) => (), )) => (),
SigVerifyServiceError::SendError(_) => { SigVerifyServiceError::Send(_) => {
break; break;
} }
_ => error!("{:?}", e), _ => error!("{:?}", e),

2
core/src/verified_vote_packets.rs
View File

@ -188,7 +188,7 @@ mod tests {
let before = update_version; let before = update_version;
assert_matches!( assert_matches!(
verified_vote_packets.receive_and_process_vote_packets(&r, &mut update_version, true), 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); assert_eq!(before, update_version);
} }

6
core/src/window_service.rs
View File

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

1
storage-bigtable/proto/google.bigtable.v2.rs
View File

@ -244,6 +244,7 @@ pub struct RowFilter {
pub filter: ::core::option::Option<row_filter::Filter>, pub filter: ::core::option::Option<row_filter::Filter>,
} }
/// Nested message and enum types in `RowFilter`. /// Nested message and enum types in `RowFilter`.
#[allow(clippy::enum_variant_names)]
pub mod row_filter { pub mod row_filter {
/// A RowFilter which sends rows through several RowFilters in sequence. /// A RowFilter which sends rows through several RowFilters in sequence.
#[derive(Clone, PartialEq, ::prost::Message)] #[derive(Clone, PartialEq, ::prost::Message)]

36
storage-bigtable/src/bigtable.rs
View File

@ -40,17 +40,17 @@ pub enum CellData<B, P> {
#[derive(Debug, Error)] #[derive(Debug, Error)]
pub enum Error { pub enum Error {
#[error("AccessToken error: {0}")] #[error("AccessToken: {0}")]
AccessTokenError(String), AccessToken(String),
#[error("Certificate error: {0}")] #[error("Certificate: {0}")]
CertificateError(String), Certificate(String),
#[error("I/O Error: {0}")] #[error("I/O: {0}")]
IoError(std::io::Error), Io(std::io::Error),
#[error("Transport error: {0}")] #[error("Transport: {0}")]
TransportError(tonic::transport::Error), Transport(tonic::transport::Error),
#[error("Invalid URI {0}: {1}")] #[error("Invalid URI {0}: {1}")]
InvalidUri(String, String), InvalidUri(String, String),
@ -67,28 +67,28 @@ pub enum Error {
#[error("Object is corrupt: {0}")] #[error("Object is corrupt: {0}")]
ObjectCorrupt(String), ObjectCorrupt(String),
#[error("RPC error: {0}")] #[error("RPC: {0}")]
RpcError(tonic::Status), Rpc(tonic::Status),
#[error("Timeout error")] #[error("Timeout")]
TimeoutError, Timeout,
} }
impl std::convert::From<std::io::Error> for Error { impl std::convert::From<std::io::Error> for Error {
fn from(err: std::io::Error) -> Self { fn from(err: std::io::Error) -> Self {
Self::IoError(err) Self::Io(err)
} }
} }
impl std::convert::From<tonic::transport::Error> for Error { impl std::convert::From<tonic::transport::Error> for Error {
fn from(err: tonic::transport::Error) -> Self { fn from(err: tonic::transport::Error) -> Self {
Self::TransportError(err) Self::Transport(err)
} }
} }
impl std::convert::From<tonic::Status> for Error { impl std::convert::From<tonic::Status> for Error {
fn from(err: tonic::Status) -> Self { fn from(err: tonic::Status) -> Self {
Self::RpcError(err) Self::Rpc(err)
} }
} }
@ -137,7 +137,7 @@ impl BigTableConnection {
Scope::BigTableData Scope::BigTableData
}) })
.await .await
.map_err(Error::AccessTokenError)?; .map_err(Error::AccessToken)?;
let table_prefix = format!( let table_prefix = format!(
"projects/{}/instances/{}/tables/", "projects/{}/instances/{}/tables/",
@ -151,7 +151,7 @@ impl BigTableConnection {
.tls_config( .tls_config(
ClientTlsConfig::new() ClientTlsConfig::new()
.ca_certificate( .ca_certificate(
root_ca_certificate::load().map_err(Error::CertificateError)?, root_ca_certificate::load().map_err(Error::Certificate)?,
) )
.domain_name("bigtable.googleapis.com"), .domain_name("bigtable.googleapis.com"),
)?; )?;
@ -265,7 +265,7 @@ impl BigTable {
while let Some(res) = rrr.message().await? { while let Some(res) = rrr.message().await? {
if let Some(timeout) = self.timeout { if let Some(timeout) = self.timeout {
if Instant::now().duration_since(started) > timeout { if Instant::now().duration_since(started) > timeout {
return Err(Error::TimeoutError); return Err(Error::Timeout);
} }
} }
for (i, mut chunk) in res.chunks.into_iter().enumerate() { for (i, mut chunk) in res.chunks.into_iter().enumerate() {

8
streamer/src/streamer.rs
View File

@ -21,10 +21,10 @@ pub enum StreamerError {
Io(#[from] std::io::Error), Io(#[from] std::io::Error),
#[error("receive timeout error")] #[error("receive timeout error")]
RecvTimeoutError(#[from] RecvTimeoutError), RecvTimeout(#[from] RecvTimeoutError),
#[error("send packets error")] #[error("send packets error")]
SendError(#[from] SendError<Packets>), Send(#[from] SendError<Packets>),
} }
pub type Result<T> = std::result::Result<T, StreamerError>; pub type Result<T> = std::result::Result<T, StreamerError>;
@ -148,8 +148,8 @@ pub fn responder(name: &'static str, sock: Arc<UdpSocket>, r: PacketReceiver) ->
loop { loop {
if let Err(e) = recv_send(&sock, &r) { if let Err(e) = recv_send(&sock, &r) {
match e { match e {
StreamerError::RecvTimeoutError(RecvTimeoutError::Disconnected) => break, StreamerError::RecvTimeout(RecvTimeoutError::Disconnected) => break,
StreamerError::RecvTimeoutError(RecvTimeoutError::Timeout) => (), StreamerError::RecvTimeout(RecvTimeoutError::Timeout) => (),
_ => { _ => {
errors += 1; errors += 1;
last_error = Some(e); last_error = Some(e);