blockworks-foundation
/
solana-with-rpc-optimizations
mirror of https://github.com/blockworks-foundation/solana-with-rpc-optimizations.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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

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
Show Stats 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);

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>,
}
/// Nested message and enum types in `RowFilter`.
#[allow(clippy::enum_variant_names)]
pub mod row_filter {
/// A RowFilter which sends rows through several RowFilters in sequence.
#[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)]
pub enum Error {
#[error("AccessToken error: {0}")]
AccessTokenError(String),
#[error("AccessToken: {0}")]
AccessToken(String),
#[error("Certificate error: {0}")]
CertificateError(String),
#[error("Certificate: {0}")]
Certificate(String),
#[error("I/O Error: {0}")]
IoError(std::io::Error),
#[error("I/O: {0}")]
Io(std::io::Error),
#[error("Transport error: {0}")]
TransportError(tonic::transport::Error),
#[error("Transport: {0}")]
Transport(tonic::transport::Error),
#[error("Invalid URI {0}: {1}")]
InvalidUri(String, String),
@ -67,28 +67,28 @@ pub enum Error {
#[error("Object is corrupt: {0}")]
ObjectCorrupt(String),
#[error("RPC error: {0}")]
RpcError(tonic::Status),
#[error("RPC: {0}")]
Rpc(tonic::Status),
#[error("Timeout error")]
TimeoutError,
#[error("Timeout")]
Timeout,
}
impl std::convert::From<std::io::Error> for Error {
fn from(err: std::io::Error) -> Self {
Self::IoError(err)
Self::Io(err)
}
}
impl std::convert::From<tonic::transport::Error> for Error {
fn from(err: tonic::transport::Error) -> Self {
Self::TransportError(err)
Self::Transport(err)
}
}
impl std::convert::From<tonic::Status> for Error {
fn from(err: tonic::Status) -> Self {
Self::RpcError(err)
Self::Rpc(err)
}
}
@ -137,7 +137,7 @@ impl BigTableConnection {
Scope::BigTableData
})
.await
.map_err(Error::AccessTokenError)?;
.map_err(Error::AccessToken)?;
let table_prefix = format!(
"projects/{}/instances/{}/tables/",
@ -151,7 +151,7 @@ impl BigTableConnection {
.tls_config(
ClientTlsConfig::new()
.ca_certificate(
root_ca_certificate::load().map_err(Error::CertificateError)?,
root_ca_certificate::load().map_err(Error::Certificate)?,
)
.domain_name("bigtable.googleapis.com"),
)?;
@ -265,7 +265,7 @@ impl BigTable {
while let Some(res) = rrr.message().await? {
if let Some(timeout) = self.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() {

8
streamer/src/streamer.rs
View File

@ -21,10 +21,10 @@ pub enum StreamerError {
Io(#[from] std::io::Error),
#[error("receive timeout error")]
RecvTimeoutError(#[from] RecvTimeoutError),
RecvTimeout(#[from] RecvTimeoutError),
#[error("send packets error")]
SendError(#[from] SendError<Packets>),
Send(#[from] SendError<Packets>),
}
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 {
if let Err(e) = recv_send(&sock, &r) {
match e {
StreamerError::RecvTimeoutError(RecvTimeoutError::Disconnected) => break,
StreamerError::RecvTimeoutError(RecvTimeoutError::Timeout) => (),
StreamerError::RecvTimeout(RecvTimeoutError::Disconnected) => break,
StreamerError::RecvTimeout(RecvTimeoutError::Timeout) => (),
_ => {
errors += 1;
last_error = Some(e);