cerc-io/lighthouse
16
0
Fork 0
Code Issues 1 Pull Requests Packages Projects Releases Wiki Activity

Implement block imports for sync

Browse Source
This commit is contained in:
Paul Hauner 2019-03-23 18:48:09 +11:00
parent 4b5b5851a6
commit a57a7c2394
No known key found for this signature in database
GPG Key ID: D362883A9218FCC6
6 changed files with 239 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
beacon_node/beacon_chain/src/beacon_chain.rs
View File

@ -46,6 +46,26 @@ pub enum BlockProcessingOutcome {
InvalidBlock(InvalidBlock),
}
impl BlockProcessingOutcome {
/// Returns `true` if the block was objectively invalid and we should disregard the peer who
/// sent it.
pub fn is_invalid(&self) -> bool {
match self {
BlockProcessingOutcome::ValidBlock(_) => false,
BlockProcessingOutcome::InvalidBlock(r) => match r {
InvalidBlock::FutureSlot => true,
InvalidBlock::StateRootMismatch => true,
InvalidBlock::ParentUnknown => false,
InvalidBlock::SlotProcessingError(_) => false,
InvalidBlock::PerBlockProcessingError(e) => match e {
BlockProcessingError::Invalid(_) => true,
BlockProcessingError::BeaconStateError(_) => false,
},
},
}
}
}
pub struct BeaconChain<T: ClientDB + Sized, U: SlotClock, F: ForkChoice> {
pub block_store: Arc<BeaconBlockStore<T>>,
pub state_store: Arc<BeaconStateStore<T>>,
@ -685,10 +705,10 @@ where
// TODO: check the block proposer signature BEFORE doing a state transition. This will
// significantly lower exposure surface to DoS attacks.
// Transition the parent state to the present slot.
// Transition the parent state to the block slot.
let mut state = parent_state;
let previous_block_header = parent_block.block_header();
for _ in state.slot.as_u64()..present_slot.as_u64() {
for _ in state.slot.as_u64()..block.slot.as_u64() {
if let Err(e) = per_slot_processing(&mut state, &previous_block_header, &self.spec) {
return Ok(BlockProcessingOutcome::InvalidBlock(
InvalidBlock::SlotProcessingError(e),

12
beacon_node/network/src/beacon_chain.rs
View File

@ -10,7 +10,7 @@ use beacon_chain::{
use eth2_libp2p::HelloMessage;
use types::{BeaconBlock, BeaconStateError, Epoch, Hash256, Slot};
pub use beacon_chain::BeaconChainError;
pub use beacon_chain::{BeaconChainError, BlockProcessingOutcome};
/// The network's API to the beacon chain.
pub trait BeaconChain: Send + Sync {
@ -34,6 +34,9 @@ pub trait BeaconChain: Send + Sync {
fn hello_message(&self) -> HelloMessage;
fn process_block(&self, block: BeaconBlock)
-> Result<BlockProcessingOutcome, BeaconChainError>;
fn get_block_roots(
&self,
start_slot: Slot,
@ -98,6 +101,13 @@ where
}
}
fn process_block(
&self,
block: BeaconBlock,
) -> Result<BlockProcessingOutcome, BeaconChainError> {
self.process_block(block)
}
fn get_block_roots(
&self,
start_slot: Slot,

11
beacon_node/network/src/message_handler.rs
View File

@ -161,6 +161,17 @@ impl MessageHandler {
&mut self.network_context,
)
}
RPCResponse::BeaconBlockBodies(response) => {
debug!(
self.log,
"BeaconBlockBodies response received"; "peer" => format!("{:?}", peer_id)
);
self.sync.on_beacon_block_bodies_response(
peer_id,
response,
&mut self.network_context,
)
}
// TODO: Handle all responses
_ => panic!("Unknown response: {:?}", response),
}

160
beacon_node/network/src/sync/simple_sync.rs
View File

@ -3,12 +3,12 @@ use crate::message_handler::NetworkContext;
use eth2_libp2p::rpc::methods::*;
use eth2_libp2p::rpc::{RPCRequest, RPCResponse};
use eth2_libp2p::PeerId;
use slog::{debug, error, o, warn};
use slog::{debug, error, info, o, warn};
use ssz::TreeHash;
use std::collections::HashMap;
use std::sync::Arc;
use std::time::Instant;
use types::{BeaconBlockHeader, Epoch, Hash256, Slot};
use std::time::{Duration, Instant};
use types::{BeaconBlock, BeaconBlockBody, BeaconBlockHeader, Epoch, Hash256, Slot};
/// The number of slots that we can import blocks ahead of us, before going into full Sync mode.
const SLOT_IMPORT_TOLERANCE: u64 = 100;
@ -102,7 +102,11 @@ pub struct SimpleSync {
impl SimpleSync {
pub fn new(beacon_chain: Arc<BeaconChain>, log: &slog::Logger) -> Self {
let sync_logger = log.new(o!("Service"=> "Sync"));
let import_queue = ImportQueue::new(beacon_chain.clone(), log.clone());
let queue_item_stale_time = Duration::from_secs(600);
let import_queue =
ImportQueue::new(beacon_chain.clone(), queue_item_stale_time, log.clone());
SimpleSync {
chain: beacon_chain.clone(),
known_peers: HashMap::new(),
@ -229,13 +233,72 @@ impl SimpleSync {
return;
}
let block_roots = self.import_queue.enqueue_headers(response.headers);
let block_roots = self
.import_queue
.enqueue_headers(response.headers, peer_id.clone());
if !block_roots.is_empty() {
self.request_block_bodies(peer_id, BeaconBlockBodiesRequest { block_roots }, network);
}
}
pub fn on_beacon_block_bodies_response(
&mut self,
peer_id: PeerId,
response: BeaconBlockBodiesResponse,
network: &mut NetworkContext,
) {
self.import_queue
.enqueue_bodies(response.block_bodies, peer_id.clone());
self.process_import_queue(network);
}
pub fn process_import_queue(&mut self, network: &mut NetworkContext) {
let mut blocks: Vec<(Hash256, BeaconBlock, PeerId)> = self
.import_queue
.partials
.iter()
.filter_map(|(key, partial)| {
if let Some(_) = partial.body {
let (block, _root) = partial.clone().complete().expect("Body must be Some");
Some((*key, block, partial.sender.clone()))
} else {
None
}
})
.collect();
// Sort the blocks to be in ascending slot order.
blocks.sort_unstable_by(|a, b| a.1.slot.partial_cmp(&b.1.slot).unwrap());
let mut imported_keys = vec![];
for (key, block, sender) in blocks {
match self.chain.process_block(block) {
Ok(outcome) => {
if outcome.is_invalid() {
warn!(self.log, "Invalid block: {:?}", outcome);
network.disconnect(sender);
} else {
imported_keys.push(key)
}
}
Err(e) => {
error!(self.log, "Error during block processing"; "error" => format!("{:?}", e))
}
}
}
println!("imported_keys.len: {:?}", imported_keys.len());
if !imported_keys.is_empty() {
info!(self.log, "Imported {} blocks", imported_keys.len());
for key in imported_keys {
self.import_queue.partials.remove(&key);
}
}
}
fn request_block_roots(
&mut self,
peer_id: PeerId,
@ -298,19 +361,41 @@ pub struct ImportQueue {
pub chain: Arc<BeaconChain>,
/// Partially imported blocks, keyed by the root of `BeaconBlockBody`.
pub partials: HashMap<Hash256, PartialBeaconBlock>,
/// Time before a queue entry is consider state.
pub stale_time: Duration,
/// Logging
log: slog::Logger,
}
impl ImportQueue {
pub fn new(chain: Arc<BeaconChain>, log: slog::Logger) -> Self {
pub fn new(chain: Arc<BeaconChain>, stale_time: Duration, log: slog::Logger) -> Self {
Self {
chain,
partials: HashMap::new(),
stale_time,
log,
}
}
pub fn remove_stale(&mut self) {
let keys: Vec<Hash256> = self
.partials
.iter()
.filter_map(|(key, partial)| {
if partial.inserted + self.stale_time >= Instant::now() {
Some(*key)
} else {
None
}
})
.collect();
keys.iter().for_each(|key| {
self.partials.remove(&key);
});
}
/// Returns `true` if `self.chain` has not yet processed this block.
fn is_new_block(&self, block_root: &Hash256) -> bool {
self.chain
.is_new_block_root(&block_root)
@ -322,9 +407,6 @@ impl ImportQueue {
/// Returns the index of the first new root in the list of block roots.
pub fn first_new_root(&mut self, roots: &[BlockRootSlot]) -> Option<usize> {
for root in roots {
println!("root {}", root.block_root);
}
roots
.iter()
.position(|brs| self.is_new_block(&brs.block_root))
@ -339,14 +421,18 @@ impl ImportQueue {
/// If a `header` is already in the queue, but not yet processed by the chain the block root is
/// included in the output and the `inserted` time for the partial record is set to
/// `Instant::now()`. Updating the `inserted` time stops the partial from becoming stale.
pub fn enqueue_headers(&mut self, headers: Vec<BeaconBlockHeader>) -> Vec<Hash256> {
pub fn enqueue_headers(
&mut self,
headers: Vec<BeaconBlockHeader>,
sender: PeerId,
) -> Vec<Hash256> {
let mut required_bodies: Vec<Hash256> = vec![];
for header in headers {
let block_root = Hash256::from_slice(&header.hash_tree_root()[..]);
if self.is_new_block(&block_root) {
self.insert_partial(block_root, header);
self.insert_header(block_root, header, sender.clone());
required_bodies.push(block_root)
}
}
@ -354,20 +440,60 @@ impl ImportQueue {
required_bodies
}
fn insert_partial(&mut self, block_root: Hash256, header: BeaconBlockHeader) {
self.partials.insert(
header.block_body_root,
PartialBeaconBlock {
/// If there is a matching `header` for this `body`, adds it to the queue.
///
/// If there is no `header` for the `body`, the body is simply discarded.
pub fn enqueue_bodies(&mut self, bodies: Vec<BeaconBlockBody>, sender: PeerId) {
for body in bodies {
self.insert_body(body, sender.clone());
}
}
/// Inserts a header to the queue.
///
/// If the header already exists, the `inserted` time is set to `now` and not other
/// modifications are made.
fn insert_header(&mut self, block_root: Hash256, header: BeaconBlockHeader, sender: PeerId) {
self.partials
.entry(header.block_body_root)
.and_modify(|p| p.inserted = Instant::now())
.or_insert(PartialBeaconBlock {
block_root,
header,
body: None,
inserted: Instant::now(),
},
);
sender,
});
}
/// Updates an existing partial with the `body`.
///
/// If there is no header for the `body`, the body is simply discarded.
fn insert_body(&mut self, body: BeaconBlockBody, sender: PeerId) {
let body_root = Hash256::from_slice(&body.hash_tree_root()[..]);
self.partials.entry(body_root).and_modify(|p| {
if body_root == p.header.block_body_root {
p.body = Some(body);
p.inserted = Instant::now();
p.sender = sender;
}
});
}
}
#[derive(Clone, Debug)]
pub struct PartialBeaconBlock {
pub block_root: Hash256,
pub header: BeaconBlockHeader,
pub body: Option<BeaconBlockBody>,
pub inserted: Instant,
pub sender: PeerId,
}
impl PartialBeaconBlock {
/// Given a `body`, consumes `self` and returns a complete `BeaconBlock` along with its root.
pub fn complete(self) -> Option<(BeaconBlock, Hash256)> {
Some((self.header.into_block(self.body?), self.block_root))
}
}

41
beacon_node/network/tests/tests.rs
View File

@ -77,7 +77,16 @@ impl SyncNode {
match request {
RPCRequest::BeaconBlockHeaders(request) => request,
_ => panic!("Did not get block root request"),
_ => panic!("Did not get block headers request"),
}
}
pub fn get_block_bodies_request(&self) -> BeaconBlockBodiesRequest {
let request = self.recv_rpc_request().expect("No block bodies request");
match request {
RPCRequest::BeaconBlockBodies(request) => request,
_ => panic!("Did not get block bodies request"),
}
}
@ -223,6 +232,29 @@ impl SyncMaster {
self.send_rpc_response(node, response)
}
pub fn respond_to_block_bodies_request(
&mut self,
node: &SyncNode,
request: BeaconBlockBodiesRequest,
) {
let block_bodies: Vec<BeaconBlockBody> = request
.block_roots
.iter()
.map(|root| {
let block = self
.harness
.beacon_chain
.get_block(root)
.expect("Failed to load block")
.expect("Block did not exist");
block.body
})
.collect();
let response = RPCResponse::BeaconBlockBodies(BeaconBlockBodiesResponse { block_bodies });
self.send_rpc_response(node, response)
}
fn send_rpc_response(&mut self, node: &SyncNode, rpc_response: RPCResponse) {
node.send(self.rpc_response(node, rpc_response));
}
@ -311,6 +343,11 @@ fn first_test() {
master.respond_to_block_headers_request(&nodes[0], headers_request);
std::thread::sleep(Duration::from_millis(500));
let bodies_request = nodes[0].get_block_bodies_request();
assert_eq!(bodies_request.block_roots.len(), 2);
master.respond_to_block_bodies_request(&nodes[0], bodies_request);
std::thread::sleep(Duration::from_millis(10000));
runtime.shutdown_now();
}

13
eth2/types/src/beacon_block_header.rs
View File

@ -37,6 +37,19 @@ impl BeaconBlockHeader {
pub fn canonical_root(&self) -> Hash256 {
Hash256::from_slice(&self.hash_tree_root()[..])
}
/// Given a `body`, consumes `self` and returns a complete `BeaconBlock`.
///
/// Spec v0.5.0
pub fn into_block(self, body: BeaconBlockBody) -> BeaconBlock {
BeaconBlock {
slot: self.slot,
previous_block_root: self.previous_block_root,
state_root: self.state_root,
body,
signature: self.signature,
}
}
}
#[cfg(test)]