zecfoundation
/
parity-zcash
mirror of https://github.com/ZcashFoundation/parity-zcash.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

hash incoming headers without holding sync lock

This commit is contained in:
Svyatoslav Nikolsky 2019-04-05 12:05:09 +03:00
parent 0f6ff605d7
commit 92b0774cc6
4 changed files with 14 additions and 16 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
sync/src/inbound_connection.rs
View File

@ -1,4 +1,4 @@
use chain::{IndexedTransaction, IndexedBlock};
use chain::{IndexedTransaction, IndexedBlock, IndexedBlockHeader};
use message::types;
use p2p::{InboundSyncConnection, InboundSyncConnectionRef, InboundSyncConnectionStateRef};
use types::{PeersRef, LocalNodeRef, PeerIndex, RequestId};
@ -103,7 +103,8 @@ impl InboundSyncConnection for InboundConnection {
return;
}
self.node.on_headers(self.peer_index, message);
let headers = message.headers.into_iter().map(IndexedBlockHeader::from_raw).collect();
self.node.on_headers(self.peer_index, headers);
}
fn on_mempool(&self, message: types::MemPool) {

8
sync/src/local_node.rs
View File

@ -2,7 +2,7 @@ use std::sync::Arc;
use parking_lot::{Mutex, Condvar};
use time;
use futures::{lazy, finished};
use chain::{IndexedTransaction, IndexedBlock};
use chain::{IndexedTransaction, IndexedBlock, IndexedBlockHeader};
use keys::Address;
use message::types;
use miner::BlockAssembler;
@ -94,9 +94,9 @@ impl<U, V> LocalNode<U, V> where U: Server, V: Client {
}
/// When headers message is received
pub fn on_headers(&self, peer_index: PeerIndex, message: types::Headers) {
trace!(target: "sync", "Got `headers` message from peer#{}. Headers len: {}", peer_index, message.headers.len());
self.client.on_headers(peer_index, message);
pub fn on_headers(&self, peer_index: PeerIndex, headers: Vec<IndexedBlockHeader>) {
trace!(target: "sync", "Got `headers` message from peer#{}. Headers len: {}", peer_index, headers.len());
self.client.on_headers(peer_index, headers);
}
/// When transaction is received

8
sync/src/synchronization_client.rs
View File

@ -1,6 +1,6 @@
use std::sync::Arc;
use parking_lot::Mutex;
use chain::{IndexedTransaction, IndexedBlock};
use chain::{IndexedTransaction, IndexedBlock, IndexedBlockHeader};
use message::types;
use synchronization_executor::TaskExecutor;
use synchronization_verifier::{Verifier, TransactionVerificationSink};
@ -124,7 +124,7 @@ pub trait Client : Send + Sync + 'static {
fn on_connect(&self, peer_index: PeerIndex);
fn on_disconnect(&self, peer_index: PeerIndex);
fn on_inventory(&self, peer_index: PeerIndex, message: types::Inv);
fn on_headers(&self, peer_index: PeerIndex, message: types::Headers);
fn on_headers(&self, peer_index: PeerIndex, headers: Vec<IndexedBlockHeader>);
fn on_block(&self, peer_index: PeerIndex, block: IndexedBlock);
fn on_transaction(&self, peer_index: PeerIndex, transaction: IndexedTransaction);
fn on_notfound(&self, peer_index: PeerIndex, message: types::NotFound);
@ -160,8 +160,8 @@ impl<T, U> Client for SynchronizationClient<T, U> where T: TaskExecutor, U: Veri
self.core.lock().on_inventory(peer_index, message);
}
fn on_headers(&self, peer_index: PeerIndex, message: types::Headers) {
let headers_to_verify = self.core.lock().on_headers(peer_index, message);
fn on_headers(&self, peer_index: PeerIndex, headers: Vec<IndexedBlockHeader>) {
let headers_to_verify = self.core.lock().on_headers(peer_index, headers);
if let Some(headers_to_verify) = headers_to_verify {
self.light_verifier.verify_headers(peer_index, headers_to_verify);
}

9
sync/src/synchronization_client_core.rs
View File

@ -72,7 +72,7 @@ pub trait ClientCore {
fn on_connect(&mut self, peer_index: PeerIndex);
fn on_disconnect(&mut self, peer_index: PeerIndex);
fn on_inventory(&self, peer_index: PeerIndex, message: types::Inv);
fn on_headers(&mut self, peer_index: PeerIndex, message: types::Headers) -> Option<Vec<IndexedBlockHeader>>;
fn on_headers(&mut self, peer_index: PeerIndex, headers: Vec<IndexedBlockHeader>) -> Option<Vec<IndexedBlockHeader>>;
fn on_block(&mut self, peer_index: PeerIndex, block: IndexedBlock) -> Option<VecDeque<PartiallyVerifiedBlock>>;
fn on_transaction(&mut self, peer_index: PeerIndex, transaction: IndexedTransaction) -> Option<VecDeque<IndexedTransaction>>;
fn on_notfound(&mut self, peer_index: PeerIndex, message: types::NotFound);
@ -254,11 +254,8 @@ impl<T> ClientCore for SynchronizationClientCore<T> where T: TaskExecutor {
}
/// Try to queue synchronization of unknown blocks when blocks headers are received.
fn on_headers(&mut self, peer_index: PeerIndex, message: types::Headers) -> Option<Vec<IndexedBlockHeader>> {
assert!(!message.headers.is_empty(), "This must be checked in incoming connection");
// transform to indexed headers
let headers: Vec<_> = message.headers.into_iter().map(IndexedBlockHeader::from_raw).collect();
fn on_headers(&mut self, peer_index: PeerIndex, headers: Vec<IndexedBlockHeader>) -> Option<Vec<IndexedBlockHeader>> {
assert!(! headers.is_empty(), "This must be checked in incoming connection");
// update peers to select next tasks
self.peers_tasks.on_headers_received(peer_index);