gnosis/lighthouse
1
0
Fork 0
mirror of https://github.com/sigp/lighthouse.git synced 2026-03-14 10:22:38 +00:00
Code Issues Packages Projects Releases Wiki Activity

Update libp2p (#2101)

Browse Source 
This is a little bit of a tip-of-the-iceberg PR. It houses a lot of code changes in the libp2p dependency. 

This needs a bit of thorough testing before merging. 

The primary code changes are:
- General libp2p dependency update
- Gossipsub refactor to shift compression into gossipsub providing performance improvements and improved API for handling compression



Co-authored-by: Paul Hauner <paul@paulhauner.com>
This commit is contained in:
Age Manning
2020-12-23 07:53:36 +00:00
parent b5e81eb6b2
commit 2931b05582
22 changed files with 396 additions and 509 deletions
Download Patch File Download Diff File Expand all files Collapse all files

197
beacon_node/network/src/beacon_processor/worker/gossip_methods.rs
View File

@@ -83,7 +83,7 @@ impl<T: BeaconChainTypes> Worker<T> {
// Indicate to the `Network` service that this message is valid and can be
// propagated on the gossip network.
self.propagate_validation_result(message_id, peer_id.clone(), MessageAcceptance::Accept);
self.propagate_validation_result(message_id, peer_id, MessageAcceptance::Accept);
if !should_import {
return;
@@ -160,7 +160,7 @@ impl<T: BeaconChainTypes> Worker<T> {
// Indicate to the `Network` service that this message is valid and can be
// propagated on the gossip network.
self.propagate_validation_result(message_id, peer_id.clone(), MessageAcceptance::Accept);
self.propagate_validation_result(message_id, peer_id, MessageAcceptance::Accept);
metrics::inc_counter(&metrics::BEACON_PROCESSOR_AGGREGATED_ATTESTATION_VERIFIED_TOTAL);
@@ -219,11 +219,7 @@ impl<T: BeaconChainTypes> Worker<T> {
"slot" => verified_block.block.slot(),
"hash" => %verified_block.block_root
);
self.propagate_validation_result(
message_id,
peer_id.clone(),
MessageAcceptance::Accept,
);
self.propagate_validation_result(message_id, peer_id, MessageAcceptance::Accept);
verified_block
}
Err(BlockError::ParentUnknown(block)) => {
@@ -239,7 +235,7 @@ impl<T: BeaconChainTypes> Worker<T> {
debug!(self.log, "Could not verify block for gossip, ignoring the block";
"error" => %e);
// Prevent recurring behaviour by penalizing the peer slightly.
self.gossip_penalize_peer(peer_id.clone(), PeerAction::HighToleranceError);
self.gossip_penalize_peer(peer_id, PeerAction::HighToleranceError);
self.propagate_validation_result(message_id, peer_id, MessageAcceptance::Ignore);
return;
}
@@ -258,11 +254,7 @@ impl<T: BeaconChainTypes> Worker<T> {
| Err(e @ BlockError::GenesisBlock) => {
warn!(self.log, "Could not verify block for gossip, rejecting the block";
"error" => %e);
self.propagate_validation_result(
message_id,
peer_id.clone(),
MessageAcceptance::Reject,
);
self.propagate_validation_result(message_id, peer_id, MessageAcceptance::Reject);
self.gossip_penalize_peer(peer_id, PeerAction::LowToleranceError);
return;
}
@@ -337,11 +329,7 @@ impl<T: BeaconChainTypes> Worker<T> {
let exit = match self.chain.verify_voluntary_exit_for_gossip(voluntary_exit) {
Ok(ObservationOutcome::New(exit)) => exit,
Ok(ObservationOutcome::AlreadyKnown) => {
self.propagate_validation_result(
message_id,
peer_id.clone(),
MessageAcceptance::Ignore,
);
self.propagate_validation_result(message_id, peer_id, MessageAcceptance::Ignore);
debug!(
self.log,
"Dropping exit for already exiting validator";
@@ -360,11 +348,7 @@ impl<T: BeaconChainTypes> Worker<T> {
);
// These errors occur due to a fault in the beacon chain. It is not necessarily
// the fault on the peer.
self.propagate_validation_result(
message_id,
peer_id.clone(),
MessageAcceptance::Ignore,
);
self.propagate_validation_result(message_id, peer_id, MessageAcceptance::Ignore);
// We still penalize a peer slightly to prevent overuse of invalids.
self.gossip_penalize_peer(peer_id, PeerAction::HighToleranceError);
return;
@@ -416,11 +400,7 @@ impl<T: BeaconChainTypes> Worker<T> {
"peer" => %peer_id,
"error" => ?e
);
self.propagate_validation_result(
message_id,
peer_id.clone(),
MessageAcceptance::Ignore,
);
self.propagate_validation_result(message_id, peer_id, MessageAcceptance::Ignore);
// Penalize peer slightly for invalids.
self.gossip_penalize_peer(peer_id, PeerAction::HighToleranceError);
@@ -466,11 +446,7 @@ impl<T: BeaconChainTypes> Worker<T> {
"peer" => %peer_id,
"error" => ?e
);
self.propagate_validation_result(
message_id,
peer_id.clone(),
MessageAcceptance::Ignore,
);
self.propagate_validation_result(message_id, peer_id, MessageAcceptance::Ignore);
// Penalize peer slightly for invalids.
self.gossip_penalize_peer(peer_id, PeerAction::HighToleranceError);
return;
@@ -522,14 +498,10 @@ impl<T: BeaconChainTypes> Worker<T> {
// Peers that are slow or not to spec can spam us with these messages draining our
// bandwidth. We therefore penalize these peers when they do this.
self.gossip_penalize_peer(peer_id.clone(), PeerAction::LowToleranceError);
self.gossip_penalize_peer(peer_id, PeerAction::LowToleranceError);
// Do not propagate these messages.
self.propagate_validation_result(
message_id,
peer_id.clone(),
MessageAcceptance::Ignore,
);
self.propagate_validation_result(message_id, peer_id, MessageAcceptance::Ignore);
}
AttnError::InvalidSelectionProof { .. } | AttnError::InvalidSignature => {
/*
@@ -537,12 +509,8 @@ impl<T: BeaconChainTypes> Worker<T> {
*
* The peer has published an invalid consensus message.
*/
self.propagate_validation_result(
message_id,
peer_id.clone(),
MessageAcceptance::Reject,
);
self.gossip_penalize_peer(peer_id.clone(), PeerAction::LowToleranceError);
self.propagate_validation_result(message_id, peer_id, MessageAcceptance::Reject);
self.gossip_penalize_peer(peer_id, PeerAction::LowToleranceError);
}
AttnError::EmptyAggregationBitfield => {
/*
@@ -552,12 +520,8 @@ impl<T: BeaconChainTypes> Worker<T> {
* violation of the spec nor indication of fault.
*
*/
self.propagate_validation_result(
message_id,
peer_id.clone(),
MessageAcceptance::Reject,
);
self.gossip_penalize_peer(peer_id.clone(), PeerAction::LowToleranceError);
self.propagate_validation_result(message_id, peer_id, MessageAcceptance::Reject);
self.gossip_penalize_peer(peer_id, PeerAction::LowToleranceError);
}
AttnError::AggregatorPubkeyUnknown(_) => {
/*
@@ -573,12 +537,8 @@ impl<T: BeaconChainTypes> Worker<T> {
*
* The peer has published an invalid consensus message.
*/
self.propagate_validation_result(
message_id,
peer_id.clone(),
MessageAcceptance::Reject,
);
self.gossip_penalize_peer(peer_id.clone(), PeerAction::LowToleranceError);
self.propagate_validation_result(message_id, peer_id, MessageAcceptance::Reject);
self.gossip_penalize_peer(peer_id, PeerAction::LowToleranceError);
}
AttnError::AggregatorNotInCommittee { .. } => {
/*
@@ -594,12 +554,8 @@ impl<T: BeaconChainTypes> Worker<T> {
*
* The peer has published an invalid consensus message.
*/
self.propagate_validation_result(
message_id,
peer_id.clone(),
MessageAcceptance::Reject,
);
self.gossip_penalize_peer(peer_id.clone(), PeerAction::LowToleranceError);
self.propagate_validation_result(message_id, peer_id, MessageAcceptance::Reject);
self.gossip_penalize_peer(peer_id, PeerAction::LowToleranceError);
}
AttnError::AttestationAlreadyKnown { .. } => {
/*
@@ -632,10 +588,7 @@ impl<T: BeaconChainTypes> Worker<T> {
"block" => %beacon_block_root,
"type" => ?attestation_type,
);
// We still penalize the peer slightly. We don't want this to be a recurring
// behaviour.
self.gossip_penalize_peer(peer_id.clone(), PeerAction::HighToleranceError);
// This is an allowed behaviour.
self.propagate_validation_result(message_id, peer_id, MessageAcceptance::Ignore);
return;
@@ -646,7 +599,7 @@ impl<T: BeaconChainTypes> Worker<T> {
*
* The peer is not necessarily faulty.
*/
trace!(
debug!(
self.log,
"Prior attestation known";
"peer_id" => %peer_id,
@@ -655,7 +608,7 @@ impl<T: BeaconChainTypes> Worker<T> {
);
// We still penalize the peer slightly. We don't want this to be a recurring
// behaviour.
self.gossip_penalize_peer(peer_id.clone(), PeerAction::HighToleranceError);
self.gossip_penalize_peer(peer_id, PeerAction::HighToleranceError);
self.propagate_validation_result(message_id, peer_id, MessageAcceptance::Ignore);
@@ -668,12 +621,15 @@ impl<T: BeaconChainTypes> Worker<T> {
*
* The peer has published an invalid consensus message.
*/
self.propagate_validation_result(
message_id,
peer_id.clone(),
MessageAcceptance::Reject,
debug!(
self.log,
"Validation Index too high";
"peer_id" => %peer_id,
"block" => %beacon_block_root,
"type" => ?attestation_type,
);
self.gossip_penalize_peer(peer_id.clone(), PeerAction::LowToleranceError);
self.propagate_validation_result(message_id, peer_id, MessageAcceptance::Reject);
self.gossip_penalize_peer(peer_id, PeerAction::LowToleranceError);
}
AttnError::UnknownHeadBlock { beacon_block_root } => {
// Note: its a little bit unclear as to whether or not this block is unknown or
@@ -691,10 +647,7 @@ impl<T: BeaconChainTypes> Worker<T> {
);
// we don't know the block, get the sync manager to handle the block lookup
self.sync_tx
.send(SyncMessage::UnknownBlockHash(
peer_id.clone(),
*beacon_block_root,
))
.send(SyncMessage::UnknownBlockHash(peer_id, *beacon_block_root))
.unwrap_or_else(|_| {
warn!(
self.log,
@@ -722,12 +675,8 @@ impl<T: BeaconChainTypes> Worker<T> {
*
* The peer has published an invalid consensus message.
*/
self.propagate_validation_result(
message_id,
peer_id.clone(),
MessageAcceptance::Reject,
);
self.gossip_penalize_peer(peer_id.clone(), PeerAction::LowToleranceError);
self.propagate_validation_result(message_id, peer_id, MessageAcceptance::Reject);
self.gossip_penalize_peer(peer_id, PeerAction::LowToleranceError);
}
AttnError::BadTargetEpoch => {
/*
@@ -736,12 +685,8 @@ impl<T: BeaconChainTypes> Worker<T> {
*
* The peer has published an invalid consensus message.
*/
self.propagate_validation_result(
message_id,
peer_id.clone(),
MessageAcceptance::Reject,
);
self.gossip_penalize_peer(peer_id.clone(), PeerAction::LowToleranceError);
self.propagate_validation_result(message_id, peer_id, MessageAcceptance::Reject);
self.gossip_penalize_peer(peer_id, PeerAction::LowToleranceError);
}
AttnError::NoCommitteeForSlotAndIndex { .. } => {
/*
@@ -749,12 +694,8 @@ impl<T: BeaconChainTypes> Worker<T> {
*
* The peer has published an invalid consensus message.
*/
self.propagate_validation_result(
message_id,
peer_id.clone(),
MessageAcceptance::Reject,
);
self.gossip_penalize_peer(peer_id.clone(), PeerAction::LowToleranceError);
self.propagate_validation_result(message_id, peer_id, MessageAcceptance::Reject);
self.gossip_penalize_peer(peer_id, PeerAction::LowToleranceError);
}
AttnError::NotExactlyOneAggregationBitSet(_) => {
/*
@@ -762,12 +703,8 @@ impl<T: BeaconChainTypes> Worker<T> {
*
* The peer has published an invalid consensus message.
*/
self.propagate_validation_result(
message_id,
peer_id.clone(),
MessageAcceptance::Reject,
);
self.gossip_penalize_peer(peer_id.clone(), PeerAction::LowToleranceError);
self.propagate_validation_result(message_id, peer_id, MessageAcceptance::Reject);
self.gossip_penalize_peer(peer_id, PeerAction::LowToleranceError);
}
AttnError::AttestsToFutureBlock { .. } => {
/*
@@ -775,12 +712,8 @@ impl<T: BeaconChainTypes> Worker<T> {
*
* The peer has published an invalid consensus message.
*/
self.propagate_validation_result(
message_id,
peer_id.clone(),
MessageAcceptance::Reject,
);
self.gossip_penalize_peer(peer_id.clone(), PeerAction::LowToleranceError);
self.propagate_validation_result(message_id, peer_id, MessageAcceptance::Reject);
self.gossip_penalize_peer(peer_id, PeerAction::LowToleranceError);
}
AttnError::InvalidSubnetId { received, expected } => {
@@ -793,12 +726,8 @@ impl<T: BeaconChainTypes> Worker<T> {
"expected" => ?expected,
"received" => ?received,
);
self.propagate_validation_result(
message_id,
peer_id.clone(),
MessageAcceptance::Reject,
);
self.gossip_penalize_peer(peer_id.clone(), PeerAction::LowToleranceError);
self.propagate_validation_result(message_id, peer_id, MessageAcceptance::Reject);
self.gossip_penalize_peer(peer_id, PeerAction::LowToleranceError);
}
AttnError::Invalid(_) => {
/*
@@ -806,12 +735,8 @@ impl<T: BeaconChainTypes> Worker<T> {
*
* The peer has published an invalid consensus message.
*/
self.propagate_validation_result(
message_id,
peer_id.clone(),
MessageAcceptance::Reject,
);
self.gossip_penalize_peer(peer_id.clone(), PeerAction::LowToleranceError);
self.propagate_validation_result(message_id, peer_id, MessageAcceptance::Reject);
self.gossip_penalize_peer(peer_id, PeerAction::LowToleranceError);
}
AttnError::InvalidTargetEpoch { .. } => {
/*
@@ -819,12 +744,8 @@ impl<T: BeaconChainTypes> Worker<T> {
*
* The peer has published an invalid consensus message.
*/
self.propagate_validation_result(
message_id,
peer_id.clone(),
MessageAcceptance::Reject,
);
self.gossip_penalize_peer(peer_id.clone(), PeerAction::LowToleranceError);
self.propagate_validation_result(message_id, peer_id, MessageAcceptance::Reject);
self.gossip_penalize_peer(peer_id, PeerAction::LowToleranceError);
}
AttnError::InvalidTargetRoot { .. } => {
/*
@@ -832,12 +753,8 @@ impl<T: BeaconChainTypes> Worker<T> {
*
* The peer has published an invalid consensus message.
*/
self.propagate_validation_result(
message_id,
peer_id.clone(),
MessageAcceptance::Reject,
);
self.gossip_penalize_peer(peer_id.clone(), PeerAction::LowToleranceError);
self.propagate_validation_result(message_id, peer_id, MessageAcceptance::Reject);
self.gossip_penalize_peer(peer_id, PeerAction::LowToleranceError);
}
AttnError::TooManySkippedSlots {
head_block_slot,
@@ -856,12 +773,8 @@ impl<T: BeaconChainTypes> Worker<T> {
);
// In this case we wish to penalize gossipsub peers that do this to avoid future
// attestations that have too many skip slots.
self.propagate_validation_result(
message_id,
peer_id.clone(),
MessageAcceptance::Reject,
);
self.gossip_penalize_peer(peer_id.clone(), PeerAction::MidToleranceError);
self.propagate_validation_result(message_id, peer_id, MessageAcceptance::Reject);
self.gossip_penalize_peer(peer_id, PeerAction::MidToleranceError);
}
AttnError::BeaconChainError(e) => {
/*
@@ -877,13 +790,9 @@ impl<T: BeaconChainTypes> Worker<T> {
"peer_id" => %peer_id,
"error" => ?e,
);
self.propagate_validation_result(
message_id,
peer_id.clone(),
MessageAcceptance::Ignore,
);
self.propagate_validation_result(message_id, peer_id, MessageAcceptance::Ignore);
// Penalize the peer slightly
self.gossip_penalize_peer(peer_id.clone(), PeerAction::HighToleranceError);
self.gossip_penalize_peer(peer_id, PeerAction::HighToleranceError);
}
}

4
beacon_node/network/src/beacon_processor/worker/rpc_methods.rs
View File

@@ -116,7 +116,7 @@ impl<T: BeaconChainTypes> Worker<T> {
for root in request.block_roots.iter() {
if let Ok(Some(block)) = self.chain.store.get_block(root) {
self.send_response(
peer_id.clone(),
peer_id,
Response::BlocksByRoot(Some(Box::new(block))),
request_id,
);
@@ -212,7 +212,7 @@ impl<T: BeaconChainTypes> Worker<T> {
{
blocks_sent += 1;
self.send_network_message(NetworkMessage::SendResponse {
peer_id: peer_id.clone(),
peer_id,
response: Response::BlocksByRange(Some(Box::new(block))),
id: request_id,
});

7
beacon_node/network/src/router/processor.rs
View File

@@ -126,11 +126,8 @@ impl<T: BeaconChainTypes> Processor<T> {
// ignore status responses if we are shutting down
if let Ok(status_message) = status_message(&self.chain) {
// Say status back.
self.network.send_response(
peer_id.clone(),
Response::Status(status_message),
request_id,
);
self.network
.send_response(peer_id, Response::Status(status_message), request_id);
}
self.send_beacon_processor_work(BeaconWorkEvent::status_message(peer_id, status))

6
beacon_node/network/src/sync/manager.rs
View File

@@ -713,7 +713,7 @@ impl<T: BeaconChainTypes> SyncManager<T> {
// The sent block is not the correct block, remove the head block and downvote
// the peer
let _ = parent_request.downloaded_blocks.pop();
let peer = parent_request.last_submitted_peer.clone();
let peer = parent_request.last_submitted_peer;
warn!(self.log, "Peer sent invalid parent.";
"peer_id" => %peer,
@@ -759,7 +759,7 @@ impl<T: BeaconChainTypes> SyncManager<T> {
}
Ok(_) | Err(BlockError::BlockIsAlreadyKnown { .. }) => {
let process_id = ProcessId::ParentLookup(
parent_request.last_submitted_peer.clone(),
parent_request.last_submitted_peer,
chain_block_hash,
);
let blocks = parent_request.downloaded_blocks;
@@ -852,7 +852,7 @@ impl<T: BeaconChainTypes> SyncManager<T> {
// We continue to search for the chain of blocks from the same peer. Other peers are not
// guaranteed to have this chain of blocks.
let peer_id = parent_request.last_submitted_peer.clone();
let peer_id = parent_request.last_submitted_peer;
if let Ok(request_id) = self.network.blocks_by_root_request(peer_id, request) {
// if the request was successful add the queue back into self

4
beacon_node/network/src/sync/range_sync/batch.rs
View File

@@ -102,11 +102,11 @@ impl<T: EthSpec> BatchInfo<T> {
);
for attempt in &self.failed_processing_attempts {
peers.insert(attempt.peer_id.clone());
peers.insert(attempt.peer_id);
}
for download in &self.failed_download_attempts {
peers.insert(download.clone());
peers.insert(*download);
}
peers

16
beacon_node/network/src/sync/range_sync/chain.rs
View File

@@ -606,7 +606,7 @@ impl<T: BeaconChainTypes> SyncingChain<T> {
"batch_epoch" => id, "score_adjustment" => %action,
"original_peer" => %attempt.peer_id, "new_peer" => %processed_attempt.peer_id
);
network.report_peer(attempt.peer_id.clone(), action);
network.report_peer(attempt.peer_id, action);
} else {
// The same peer corrected it's previous mistake. There was an error, so we
// negative score the original peer.
@@ -615,7 +615,7 @@ impl<T: BeaconChainTypes> SyncingChain<T> {
"batch_epoch" => id, "score_adjustment" => %action,
"original_peer" => %attempt.peer_id, "new_peer" => %processed_attempt.peer_id
);
network.report_peer(attempt.peer_id.clone(), action);
network.report_peer(attempt.peer_id, action);
}
}
}
@@ -822,11 +822,11 @@ impl<T: BeaconChainTypes> SyncingChain<T> {
let mut priorized_peers = self
.peers
.iter()
.map(|(peer, requests)| (failed_peers.contains(peer), requests.len(), peer))
.map(|(peer, requests)| (failed_peers.contains(peer), requests.len(), *peer))
.collect::<Vec<_>>();
// Sort peers prioritizing unrelated peers with less active requests.
priorized_peers.sort_unstable();
priorized_peers.get(0).map(|&(_, _, peer)| peer.clone())
priorized_peers.get(0).map(|&(_, _, peer)| peer)
};
if let Some(peer) = new_peer {
@@ -846,10 +846,10 @@ impl<T: BeaconChainTypes> SyncingChain<T> {
) -> ProcessingResult {
if let Some(batch) = self.batches.get_mut(&batch_id) {
let request = batch.to_blocks_by_range_request();
match network.blocks_by_range_request(peer.clone(), request, self.id, batch_id) {
match network.blocks_by_range_request(peer, request, self.id, batch_id) {
Ok(request_id) => {
// inform the batch about the new request
batch.start_downloading_from_peer(peer.clone(), request_id)?;
batch.start_downloading_from_peer(peer, request_id)?;
if self
.optimistic_start
.map(|epoch| epoch == batch_id)
@@ -879,7 +879,7 @@ impl<T: BeaconChainTypes> SyncingChain<T> {
warn!(self.log, "Could not send batch request";
"batch_id" => batch_id, "error" => e, &batch);
// register the failed download and check if the batch can be retried
batch.start_downloading_from_peer(peer.clone(), 1)?; // fake request_id is not relevant
batch.start_downloading_from_peer(peer, 1)?; // fake request_id is not relevant
self.peers
.get_mut(&peer)
.map(|request| request.remove(&batch_id));
@@ -922,7 +922,7 @@ impl<T: BeaconChainTypes> SyncingChain<T> {
.iter()
.filter_map(|(peer, requests)| {
if requests.is_empty() {
Some(peer.clone())
Some(*peer)
} else {
None
}