pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-04-27 06:57:58 +00:00
Code Issues Packages Projects Releases Wiki Activity

Clean up sc-network (#9761)

Browse Source 
* Clean up sc-network

- Avoid using clone() for the Copy type `PeerId`.
- Use `find_map` for `filter_map` and `next`.
- Use `Self`.

* More on Copy types

* Cargo +nightly fmt --all

* More ..

* fmt

* Revert vec![default_notif_handshake_message]
This commit is contained in:
Liu-Cheng Xu
2021-09-14 02:11:29 +08:00
committed by GitHub
parent 0472a43855
commit 2562f8c65e
37 changed files with 475 additions and 526 deletions
Download Patch File Download Diff File Expand all files Collapse all files
substrate/client/network/src/protocol/sync/blocks.rs
+4 -7
View File
@@ -44,8 +44,8 @@ enum BlockRangeState<B: BlockT> {
impl<B: BlockT> BlockRangeState<B> {
pub fn len(&self) -> NumberFor<B> {
match *self {
BlockRangeState::Downloading { len, .. } => len,
BlockRangeState::Complete(ref blocks) => (blocks.len() as u32).into(),
Self::Downloading { len, .. } => len,
Self::Complete(ref blocks) => (blocks.len() as u32).into(),
}
}
}
@@ -61,7 +61,7 @@ pub struct BlockCollection<B: BlockT> {
impl<B: BlockT> BlockCollection<B> {
/// Create a new instance.
pub fn new() -> Self {
BlockCollection { blocks: BTreeMap::new(), peer_requests: HashMap::new() }
Self { blocks: BTreeMap::new(), peer_requests: HashMap::new() }
}
/// Clear everything.
@@ -90,10 +90,7 @@ impl<B: BlockT> BlockCollection<B> {
self.blocks.insert(
start,
BlockRangeState::Complete(
blocks
.into_iter()
.map(|b| BlockData { origin: Some(who.clone()), block: b })
.collect(),
blocks.into_iter().map(|b| BlockData { origin: Some(who), block: b }).collect(),
),
);
}
substrate/client/network/src/protocol/sync/extra_requests.rs
+19 -23
View File
@@ -67,7 +67,7 @@ pub(crate) struct Metrics {
impl<B: BlockT> ExtraRequests<B> {
pub(crate) fn new(request_type_name: &'static str) -> Self {
ExtraRequests {
Self {
tree: ForkTree::new(),
best_seen_finalized_number: Zero::zero(),
pending_requests: VecDeque::new(),
@@ -132,27 +132,25 @@ impl<B: BlockT> ExtraRequests<B> {
// messages to chain sync.
if let Some(request) = self.active_requests.remove(&who) {
if let Some(r) = resp {
trace!(target: "sync", "Queuing import of {} from {:?} for {:?}",
self.request_type_name,
who,
request,
trace!(target: "sync",
"Queuing import of {} from {:?} for {:?}",
self.request_type_name, who, request,
);
self.importing_requests.insert(request);
return Some((who, request.0, request.1, r))
} else {
trace!(target: "sync", "Empty {} response from {:?} for {:?}",
self.request_type_name,
who,
request,
trace!(target: "sync",
"Empty {} response from {:?} for {:?}",
self.request_type_name, who, request,
);
}
self.failed_requests.entry(request).or_default().push((who, Instant::now()));
self.pending_requests.push_front(request);
} else {
trace!(target: "sync", "No active {} request to {:?}",
self.request_type_name,
who,
trace!(target: "sync",
"No active {} request to {:?}",
self.request_type_name, who,
);
}
None
@@ -227,10 +225,9 @@ impl<B: BlockT> ExtraRequests<B> {
};
if self.tree.finalize_root(&finalized_hash).is_none() {
warn!(target: "sync", "‼️ Imported {:?} {:?} which isn't a root in the tree: {:?}",
finalized_hash,
finalized_number,
self.tree.roots().collect::<Vec<_>>()
warn!(target: "sync",
"‼️ Imported {:?} {:?} which isn't a root in the tree: {:?}",
finalized_hash, finalized_number, self.tree.roots().collect::<Vec<_>>()
);
return true
}
@@ -280,7 +277,7 @@ pub(crate) struct Matcher<'a, B: BlockT> {
impl<'a, B: BlockT> Matcher<'a, B> {
fn new(extras: &'a mut ExtraRequests<B>) -> Self {
Matcher { remaining: extras.pending_requests.len(), extras }
Self { remaining: extras.pending_requests.len(), extras }
}
/// Finds a peer to which a pending request can be sent.
@@ -335,13 +332,12 @@ impl<'a, B: BlockT> Matcher<'a, B> {
}
self.extras.active_requests.insert(peer.clone(), request);
trace!(target: "sync", "Sending {} request to {:?} for {:?}",
self.extras.request_type_name,
peer,
request,
trace!(target: "sync",
"Sending {} request to {:?} for {:?}",
self.extras.request_type_name, peer, request,
);
return Some((peer.clone(), request))
return Some((*peer, request))
}
self.extras.pending_requests.push_back(request);
@@ -594,7 +590,7 @@ mod tests {
let mut peers = HashMap::with_capacity(g.size());
for _ in 0..g.size() {
let ps = ArbitraryPeerSync::arbitrary(g).0;
peers.insert(ps.peer_id.clone(), ps);
peers.insert(ps.peer_id, ps);
}
ArbitraryPeers(peers)
}
substrate/client/network/src/protocol/sync/state.rs
+13 -29
View File
@@ -22,6 +22,7 @@ use crate::{
schema::v1::{StateEntry, StateRequest, StateResponse},
};
use codec::{Decode, Encode};
use log::debug;
use sc_client_api::StorageProof;
use sp_runtime::traits::{Block as BlockT, Header, NumberFor};
use std::sync::Arc;
@@ -55,7 +56,7 @@ pub enum ImportResult<B: BlockT> {
impl<B: BlockT> StateSync<B> {
/// Create a new instance.
pub fn new(client: Arc<dyn Client<B>>, target: B::Header, skip_proof: bool) -> Self {
StateSync {
Self {
client,
target_block: target.hash(),
target_root: target.state_root().clone(),
@@ -71,46 +72,32 @@ impl<B: BlockT> StateSync<B> {
/// Validate and import a state reponse.
pub fn import(&mut self, response: StateResponse) -> ImportResult<B> {
if response.entries.is_empty() && response.proof.is_empty() && !response.complete {
log::debug!(
target: "sync",
"Bad state response",
);
debug!(target: "sync", "Bad state response");
return ImportResult::BadResponse
}
if !self.skip_proof && response.proof.is_empty() {
log::debug!(
target: "sync",
"Missing proof",
);
debug!(target: "sync", "Missing proof");
return ImportResult::BadResponse
}
let complete = if !self.skip_proof {
log::debug!(
target: "sync",
"Importing state from {} trie nodes",
response.proof.len(),
);
debug!(target: "sync", "Importing state from {} trie nodes", response.proof.len());
let proof_size = response.proof.len() as u64;
let proof = match StorageProof::decode(&mut response.proof.as_ref()) {
Ok(proof) => proof,
Err(e) => {
log::debug!(target: "sync", "Error decoding proof: {:?}", e);
debug!(target: "sync", "Error decoding proof: {:?}", e);
return ImportResult::BadResponse
},
};
let (values, complete) =
match self.client.verify_range_proof(self.target_root, proof, &self.last_key) {
Err(e) => {
log::debug!(
target: "sync",
"StateResponse failed proof verification: {:?}",
e,
);
debug!(target: "sync", "StateResponse failed proof verification: {:?}", e);
return ImportResult::BadResponse
},
Ok(values) => values,
};
log::debug!(target: "sync", "Imported with {} keys", values.len());
debug!(target: "sync", "Imported with {} keys", values.len());
if let Some(last) = values.last().map(|(k, _)| k) {
self.last_key = last.clone();
@@ -123,7 +110,7 @@ impl<B: BlockT> StateSync<B> {
self.imported_bytes += proof_size;
complete
} else {
log::debug!(
debug!(
target: "sync",
"Importing state from {:?} to {:?}",
response.entries.last().map(|e| sp_core::hexdisplay::HexDisplay::from(&e.key)),
@@ -142,12 +129,9 @@ impl<B: BlockT> StateSync<B> {
if complete {
self.complete = true;
ImportResult::Import(
self.target_block.clone(),
self.target_block,
self.target_header.clone(),
ImportedState {
block: self.target_block.clone(),
state: std::mem::take(&mut self.state),
},
ImportedState { block: self.target_block, state: std::mem::take(&mut self.state) },
)
} else {
ImportResult::Continue(self.next_request())
@@ -170,12 +154,12 @@ impl<B: BlockT> StateSync<B> {
/// Returns target block number.
pub fn target_block_num(&self) -> NumberFor<B> {
self.target_header.number().clone()
*self.target_header.number()
}
/// Returns target block hash.
pub fn target(&self) -> B::Hash {
self.target_block.clone()
self.target_block
}
/// Returns state sync estimated progress.
substrate/client/network/src/protocol/sync/warp.rs
+2 -3
View File
@@ -66,7 +66,7 @@ impl<B: BlockT> WarpSync<B> {
authorities: warp_sync_provider.current_authorities(),
last_hash,
};
WarpSync { client, warp_sync_provider, phase, total_proof_bytes: 0 }
Self { client, warp_sync_provider, phase, total_proof_bytes: 0 }
}
/// Validate and import a state reponse.
@@ -132,8 +132,7 @@ impl<B: BlockT> WarpSync<B> {
pub fn next_warp_poof_request(&self) -> Option<WarpProofRequest<B>> {
match &self.phase {
Phase::State(_) => None,
Phase::WarpProof { last_hash, .. } =>
Some(WarpProofRequest { begin: last_hash.clone() }),
Phase::WarpProof { last_hash, .. } => Some(WarpProofRequest { begin: *last_hash }),
}
}