refactor: get rid of let _ = pattern

zhangsoledad · Apr 10, 2019 · 641f146 · 641f146
1 parent d600e92
commit 641f146
Show file tree

Hide file tree

Showing 17 changed files with 135 additions and 42 deletions.
diff --git a/core/src/script.rs b/core/src/script.rs
@@ -25,7 +25,7 @@ fn prefix_hex(bytes: &[u8]) -> String {
     let mut dst = vec![0u8; bytes.len() * 2 + 2];
     dst[0] = b'0';
     dst[1] = b'x';
-    let _ = hex_encode(bytes, &mut dst[2..]);
+    hex_encode(bytes, &mut dst[2..]).expect("hex encode buffer checked");
     unsafe { String::from_utf8_unchecked(dst) }
 }
 

diff --git a/network/src/network.rs b/network/src/network.rs
@@ -231,7 +231,9 @@ impl NetworkState {
 
     // A workaround method for `add_node` rpc call, need to re-write it after new p2p lib integration.
     pub fn add_node(&self, peer_id: &PeerId, address: Multiaddr) {
-        let _ = self.peer_store().add_discovered_addr(peer_id, address);
+        if !self.peer_store().add_discovered_addr(peer_id, address) {
+            warn!(target: "network", "add_node failed {:?}", peer_id);
+        }
     }
 
     fn to_external_url(&self, addr: &Multiaddr) -> String {

diff --git a/network/src/protocols/discovery.rs b/network/src/protocols/discovery.rs
@@ -200,10 +200,14 @@ impl Stream for DiscoveryService {
                                     _ => true,
                                 })
                                 .collect::<Multiaddr>();
-                            let _ = self
+
+                            if !self
                                 .network_state
                                 .peer_store()
-                                .add_discovered_addr(&peer_id, addr);
+                                .add_discovered_addr(&peer_id, addr)
+                            {
+                                warn!(target: "network", "add_discovered_addr failed {:?}", peer_id);
+                            }
                         }
                     }
                 }

diff --git a/network/src/protocols/identify.rs b/network/src/protocols/identify.rs
@@ -1,16 +1,15 @@
 // use crate::peer_store::Behaviour;
 use crate::NetworkState;
-use std::collections::HashMap;
-use std::sync::Arc;
-
-use log::{debug, trace};
+use log::{debug, trace, warn};
 use p2p::{
     multiaddr::{Multiaddr, Protocol},
     secio::PeerId,
     service::SessionType,
     utils::{is_reachable, multiaddr_to_socketaddr},
 };
 use p2p_identify::{Callback, MisbehaveResult, Misbehavior};
+use std::collections::HashMap;
+use std::sync::Arc;
 
 const MAX_RETURN_LISTEN_ADDRS: usize = 10;
 
@@ -59,7 +58,9 @@ impl Callback for IdentifyCallback {
             .insert(peer_id.clone(), addrs.clone());
         let peer_store = self.network_state.peer_store();
         for addr in addrs {
-            let _ = peer_store.add_discovered_addr(&peer_id, addr);
+            if !peer_store.add_discovered_addr(&peer_id, addr) {
+                warn!(target: "network", "add_discovered_addr failed {:?}", peer_id);
+            }
         }
     }
 
@@ -101,10 +102,14 @@ impl Callback for IdentifyCallback {
         {
             debug!(target: "network", "identify add transformed addr: {:?}", transformed_addr);
             let local_peer_id = self.network_state.local_peer_id();
-            let _ = self
+
+            if !self
                 .network_state
                 .peer_store()
-                .add_discovered_addr(local_peer_id, transformed_addr);
+                .add_discovered_addr(local_peer_id, transformed_addr)
+            {
+                warn!(target: "network", "add_discovered_addr failed {:?}", local_peer_id);
+            }
         }
         // NOTE: for future usage
         MisbehaveResult::Continue

diff --git a/rpc/src/module/miner.rs b/rpc/src/module/miner.rs
@@ -11,7 +11,7 @@ use flatbuffers::FlatBufferBuilder;
 use jsonrpc_core::{Error, Result};
 use jsonrpc_derive::rpc;
 use jsonrpc_types::{Block, BlockTemplate};
-use log::debug;
+use log::{debug, warn};
 use numext_fixed_hash::H256;
 use std::collections::HashSet;
 use std::sync::Arc;
@@ -72,7 +72,10 @@ impl<CI: ChainIndex + 'static> MinerRpc for MinerRpcImpl<CI> {
                             RelayMessage::build_compact_block(fbb, &block, &HashSet::new());
                         fbb.finish(message, None);
                         for peer in nc.connected_peers() {
-                            let _ = nc.send(peer, fbb.finished_data().to_vec());
+                            let ret = nc.send(peer, fbb.finished_data().to_vec());
+                            if ret.is_err() {
+                                warn!(target: "rpc", "relay block error {:?}", ret);
+                            }
                         }
                     },
                 );

diff --git a/rpc/src/module/pool.rs b/rpc/src/module/pool.rs
@@ -12,7 +12,7 @@ use flatbuffers::FlatBufferBuilder;
 use jsonrpc_core::Result;
 use jsonrpc_derive::rpc;
 use jsonrpc_types::Transaction;
-use log::debug;
+use log::{debug, warn};
 use numext_fixed_hash::H256;
 
 #[rpc]
@@ -61,7 +61,10 @@ impl<CI: ChainIndex + 'static> PoolRpc for PoolRpcImpl<CI> {
                     |mut nc| {
                         for peer in nc.connected_peers() {
                             debug!(target: "rpc", "relay transaction {} to peer#{}", tx_hash, peer);
-                            let _ = nc.send(peer, fbb.finished_data().to_vec());
+                            let ret = nc.send(peer, fbb.finished_data().to_vec());
+                            if ret.is_err() {
+                                warn!(target: "rpc", "relay transaction error {:?}", ret);
+                            }
                         }
                     },
                 );

diff --git a/rpc/src/module/trace.rs b/rpc/src/module/trace.rs
@@ -13,7 +13,7 @@ use flatbuffers::FlatBufferBuilder;
 use jsonrpc_core::Result;
 use jsonrpc_derive::rpc;
 use jsonrpc_types::Transaction;
-use log::debug;
+use log::{debug, warn};
 use numext_fixed_hash::H256;
 
 #[rpc]
@@ -60,7 +60,10 @@ impl<CI: ChainIndex + 'static> TraceRpc for TraceRpcImpl<CI> {
                     |mut nc| {
                         for peer in nc.connected_peers() {
                             debug!(target: "rpc", "relay transaction {} to peer#{}", tx_hash, peer);
-                            let _ = nc.send(peer, fbb.finished_data().to_vec());
+                            let ret = nc.send(peer, fbb.finished_data().to_vec());
+                            if ret.is_err() {
+                                warn!(target: "rpc", "relay transaction error {:?}", ret);
+                            }
                         }
                     },
                 );

diff --git a/sync/src/net_time_checker.rs b/sync/src/net_time_checker.rs
@@ -94,8 +94,10 @@ impl CKBProtocolHandler for NetTimeProtocol {
     fn received(&self, nc: Box<CKBProtocolContext>, peer: PeerIndex, data: Bytes) {
         if nc.session_info(peer).map(|s| s.peer.is_outbound()) != Some(true) {
             info!(target: "network", "Peer {} is not outbound but sends us time message", peer);
-            let _ = nc.report_peer(peer, Behaviour::UnexpectedMessage);
-            return;
+            let ret = nc.report_peer(peer, Behaviour::UnexpectedMessage);
+            if ret.is_err() {
+                warn!(target: "network", "report_peer peer {:?} UnexpectedMessage error {:?}", peer, ret);
+            }
         }
 
         let timestamp = match get_root::<TimeMessage>(&data)
@@ -106,7 +108,10 @@ impl CKBProtocolHandler for NetTimeProtocol {
             Some(timestamp) => timestamp,
             None => {
                 info!(target: "network", "Peer {} sends us malformed message", peer);
-                let _ = nc.report_peer(peer, Behaviour::UnexpectedMessage);
+                let ret = nc.report_peer(peer, Behaviour::UnexpectedMessage);
+                if ret.is_err() {
+                    warn!(target: "network", "report_peer peer {:?} UnexpectedMessage error  {:?}", peer, ret);
+                }
                 return;
             }
         };
@@ -128,7 +133,10 @@ impl CKBProtocolHandler for NetTimeProtocol {
             let fbb = &mut FlatBufferBuilder::new();
             let message = TimeMessage::build_time(fbb, now);
             fbb.finish(message, None);
-            let _ = nc.send(peer, fbb.finished_data().to_vec());
+            let ret = nc.send(peer, fbb.finished_data().to_vec());
+            if ret.is_err() {
+                warn!(target: "network", "NetTimeProtocol connected init msg send error {:?}", ret);
+            }
         }
     }
     fn disconnected(&self, _nc: Box<CKBProtocolContext>, _peer: PeerIndex) {}

diff --git a/sync/src/relayer/block_proposal_process.rs b/sync/src/relayer/block_proposal_process.rs
@@ -4,6 +4,7 @@ use ckb_shared::index::ChainIndex;
 use ckb_traits::chain_provider::ChainProvider;
 use ckb_util::TryInto;
 use failure::Error as FailureError;
+use log::warn;
 
 pub struct BlockProposalProcess<'a, CI: ChainIndex + 'a> {
     message: &'a BlockProposal<'a>,
@@ -22,10 +23,13 @@ where
         let chain_state = self.relayer.shared.chain_state().lock();
         let txs = FlatbuffersVectorIterator::new(cast!(self.message.transactions())?);
         for tx in txs {
-            let _ = chain_state.add_tx_to_pool(
+            let ret = chain_state.add_tx_to_pool(
                 TryInto::try_into(tx)?,
                 self.relayer.shared.consensus().max_block_cycles(),
             );
+            if ret.is_err() {
+                warn!(target: "relay", "BlockProposal add_tx_to_pool error {:?}", ret)
+            }
         }
         Ok(())
     }

diff --git a/sync/src/relayer/compact_block_process.rs b/sync/src/relayer/compact_block_process.rs
@@ -10,6 +10,7 @@ use ckb_verification::{HeaderResolverWrapper, HeaderVerifier, Verifier};
 use failure::Error as FailureError;
 use flatbuffers::FlatBufferBuilder;
 use fnv::FnvHashMap;
+use log::warn;
 use numext_fixed_hash::H256;
 use std::sync::Arc;
 
@@ -94,7 +95,11 @@ where
                     .collect::<Vec<_>>(),
             );
             fbb.finish(message, None);
-            let _ = self.nc.send(self.peer, fbb.finished_data().to_vec());
+            let ret = self.nc.send(self.peer, fbb.finished_data().to_vec());
+
+            if ret.is_err() {
+                warn!(target: "relay", "CompactBlockProcess relay error {:?}", ret);
+            }
         }
         Ok(())
     }

diff --git a/sync/src/relayer/get_block_proposal_process.rs b/sync/src/relayer/get_block_proposal_process.rs
@@ -5,6 +5,7 @@ use ckb_shared::index::ChainIndex;
 use ckb_util::TryInto;
 use failure::Error as FailureError;
 use flatbuffers::FlatBufferBuilder;
+use log::warn;
 
 pub struct GetBlockProposalProcess<'a, CI: ChainIndex + 'a> {
     message: &'a GetBlockProposal<'a>,
@@ -62,7 +63,10 @@ where
         let message = RelayMessage::build_block_proposal(fbb, &transactions);
         fbb.finish(message, None);
 
-        let _ = self.nc.send(self.peer, fbb.finished_data().to_vec());
+        let ret = self.nc.send(self.peer, fbb.finished_data().to_vec());
+        if ret.is_err() {
+            warn!(target: "relay", "GetBlockProposalProcess response error {:?}", ret);
+        }
         Ok(())
     }
 }
diff --git a/sync/src/relayer/get_block_transactions_process.rs b/sync/src/relayer/get_block_transactions_process.rs
@@ -5,7 +5,7 @@ use ckb_shared::index::ChainIndex;
 use ckb_util::TryInto;
 use failure::Error as FailureError;
 use flatbuffers::FlatBufferBuilder;
-use log::debug;
+use log::{debug, warn};
 
 pub struct GetBlockTransactionsProcess<'a, CI: ChainIndex + 'a> {
     message: &'a GetBlockTransactions<'a>,
@@ -49,7 +49,10 @@ where
             let message = RelayMessage::build_block_transactions(fbb, &hash, &transactions);
             fbb.finish(message, None);
 
-            let _ = self.nc.send(self.peer, fbb.finished_data().to_vec());
+            let ret = self.nc.send(self.peer, fbb.finished_data().to_vec());
+            if ret.is_err() {
+                warn!(target: "relay", "GetBlockTransactionsProcess response error {:?}", ret);
+            }
         }
 
         Ok(())

diff --git a/sync/src/relayer/mod.rs b/sync/src/relayer/mod.rs
@@ -33,6 +33,7 @@ use ckb_util::Mutex;
 use failure::Error as FailureError;
 use flatbuffers::FlatBufferBuilder;
 use fnv::{FnvHashMap, FnvHashSet};
+use log::warn;
 use log::{debug, info};
 use numext_fixed_hash::H256;
 use std::collections::HashSet;
@@ -128,7 +129,11 @@ where
 
     fn process(&self, nc: &mut CKBProtocolContext, peer: PeerIndex, message: RelayMessage) {
         if self.try_process(nc, peer, message).is_err() {
-            let _ = nc.report_peer(peer, Behaviour::UnexpectedMessage);
+            let ret = nc.report_peer(peer, Behaviour::UnexpectedMessage);
+
+            if ret.is_err() {
+                warn!(target: "network", "report_peer peer {:?} UnexpectedMessage error {:?}", peer, ret);
+            }
         }
     }
 
@@ -158,7 +163,10 @@ where
             RelayMessage::build_get_block_proposal(fbb, block.header.number(), &unknown_ids);
         fbb.finish(message, None);
 
-        let _ = nc.send(peer, fbb.finished_data().to_vec());
+        let ret = nc.send(peer, fbb.finished_data().to_vec());
+        if ret.is_err() {
+            warn!(target: "relay", "relay get_block_proposal error {:?}", ret);
+        }
     }
 
     pub fn accept_block(&self, nc: &mut CKBProtocolContext, peer: PeerIndex, block: &Arc<Block>) {
@@ -170,7 +178,10 @@ where
 
             for peer_id in nc.connected_peers() {
                 if peer_id != peer {
-                    let _ = nc.send(peer_id, fbb.finished_data().to_vec());
+                    let ret = nc.send(peer_id, fbb.finished_data().to_vec());
+                    if ret.is_err() {
+                        warn!(target: "relay", "relay compact_block error {:?}", ret);
+                    }
                 }
             }
         } else {
@@ -279,7 +290,11 @@ where
                 RelayMessage::build_block_proposal(fbb, &txs.into_iter().collect::<Vec<_>>());
             fbb.finish(message, None);
 
-            let _ = nc.send(peer, fbb.finished_data().to_vec());
+            let ret = nc.send(peer, fbb.finished_data().to_vec());
+
+            if ret.is_err() {
+                warn!(target: "relay", "send block_proposal error {:?}", ret);
+            }
         }
     }
 
@@ -305,7 +320,10 @@ where
             Ok(msg) => msg,
             _ => {
                 info!(target: "sync", "Peer {} sends us a malformed message", peer);
-                let _ = nc.report_peer(peer, Behaviour::UnexpectedMessage);
+                let ret = nc.report_peer(peer, Behaviour::UnexpectedMessage);
+                if ret.is_err() {
+                    warn!(target: "network", "report_peer peer {:?} UnexpectedMessage error  {:?}", peer, ret);
+                }
                 return;
             }
         };

diff --git a/sync/src/relayer/transaction_process.rs b/sync/src/relayer/transaction_process.rs
@@ -9,7 +9,7 @@ use ckb_util::TryInto;
 use ckb_verification::TransactionError;
 use failure::Error as FailureError;
 use flatbuffers::FlatBufferBuilder;
-use log::debug;
+use log::{debug, warn};
 use std::time::Duration;
 
 const DEFAULT_BAN_TIME: Duration = Duration::from_secs(3600 * 24 * 3);
@@ -64,7 +64,11 @@ where
                             .get(&peer)
                             .map_or(true, |filter| filter.contains(&tx))
                     {
-                        let _ = self.nc.send(peer, fbb.finished_data().to_vec());
+                        let ret = self.nc.send(peer, fbb.finished_data().to_vec());
+
+                        if ret.is_err() {
+                            warn!(target: "relay", "relay Transaction error {:?}", ret);
+                        }
                     }
                 }
             }

diff --git a/sync/src/synchronizer/get_blocks_process.rs b/sync/src/synchronizer/get_blocks_process.rs
@@ -5,7 +5,7 @@ use ckb_shared::index::ChainIndex;
 use ckb_util::TryInto;
 use failure::Error as FailureError;
 use flatbuffers::FlatBufferBuilder;
-use log::debug;
+use log::{debug, warn};
 
 pub struct GetBlocksProcess<'a, CI: ChainIndex + 'a> {
     message: &'a GetBlocks<'a>,
@@ -59,12 +59,18 @@ where
                     let message =
                         SyncMessage::build_filtered_block(fbb, &block, &transactions_index);
                     fbb.finish(message, None);
-                    let _ = self.nc.send(self.peer, fbb.finished_data().to_vec());
+                    let ret = self.nc.send(self.peer, fbb.finished_data().to_vec());
+                    if ret.is_err() {
+                        warn!(target: "relay", "response GetBlocks error {:?}", ret);
+                    }
                 } else {
                     let fbb = &mut FlatBufferBuilder::new();
                     let message = SyncMessage::build_block(fbb, &block);
                     fbb.finish(message, None);
-                    let _ = self.nc.send(self.peer, fbb.finished_data().to_vec());
+                    let ret = self.nc.send(self.peer, fbb.finished_data().to_vec());
+                    if ret.is_err() {
+                        warn!(target: "relay", "response GetBlocks error {:?}", ret);
+                    }
                 }
             } else {
                 // TODO response not found