v0.11.1 Network update (#989)

* Minor log bumps

* Initial building of extended RPC methods

* Wire in extended RPC methods

* Merge initial peer management template

* Add a PeerDB and give the peer manager some basic functions

* Initial connection of peer manager

* Add peer manager to lighthouse

* Connect peer manager with new RPC methods

* Correct tests and metadata RPC

Co-authored-by: Diva <divma@protonmail.com>

beacon_node/network/src/router/mod.rs

@@ -47,6 +47,8 @@ pub enum RouterMessage<T: EthSpec> {
     /// A gossip message has been received. The fields are: message id, the peer that sent us this
     /// message and the message itself.
     PubsubMessage(MessageId, PeerId, PubsubMessage<T>),
+    /// The peer manager has requested we re-status a peer.
+    StatusPeer(PeerId),
 }
 
 impl<T: BeaconChainTypes> Router<T> {
@@ -87,9 +89,10 @@ impl<T: BeaconChainTypes> Router<T> {
     /// Handle all messages incoming from the network service.
     fn handle_message(&mut self, message: RouterMessage<T::EthSpec>) {
         match message {
-            // we have initiated a connection to a peer
-            RouterMessage::PeerDialed(peer_id) => {
-                self.processor.on_connect(peer_id);
+            // we have initiated a connection to a peer or the peer manager has requested a
+            // re-status
+            RouterMessage::PeerDialed(peer_id) | RouterMessage::StatusPeer(peer_id) => {
+                self.processor.send_status(peer_id);
             }
             // A peer has disconnected
             RouterMessage::PeerDisconnected(peer_id) => {
@@ -143,7 +146,8 @@ impl<T: BeaconChainTypes> Router<T> {
             RPCRequest::BlocksByRoot(request) => self
                 .processor
                 .on_blocks_by_root_request(peer_id, request_id, request),
-            RPCRequest::Phantom(_) => unreachable!("Phantom never initialised"),
+            RPCRequest::Ping(_) => unreachable!("Ping MUST be handled in the behaviour"),
+            RPCRequest::MetaData(_) => unreachable!("MetaData MUST be handled in the behaviour"),
         }
     }
 
@@ -187,6 +191,12 @@ impl<T: BeaconChainTypes> Router<T> {
                         Some(beacon_block),
                     );
                 }
+                RPCResponse::Pong(_) => {
+                    unreachable!("Ping must be handled in the behaviour");
+                }
+                RPCResponse::MetaData(_) => {
+                    unreachable!("Meta data must be handled in the behaviour");
+                }
             },
             RPCErrorResponse::StreamTermination(response_type) => {
                 // have received a stream termination, notify the processing functions

beacon_node/network/src/router/processor.rs

@@ -114,10 +114,11 @@ impl<T: BeaconChainTypes> Processor<T> {
         self.send_to_sync(SyncMessage::RPCError(peer_id, request_id));
     }
 
-    /// Handle the connection of a new peer.
-    ///
     /// Sends a `Status` message to the peer.
-    pub fn on_connect(&mut self, peer_id: PeerId) {
+    ///
+    /// Called when we first connect to a peer, or when the PeerManager determines we need to
+    /// re-status.
+    pub fn send_status(&mut self, peer_id: PeerId) {
         if let Some(status_message) = status_message(&self.chain) {
             debug!(
                 self.log,
@@ -521,7 +522,7 @@ impl<T: BeaconChainTypes> Processor<T> {
                 }
                 BlockProcessingOutcome::ParentUnknown { .. } => {
                     // Inform the sync manager to find parents for this block
-                    trace!(self.log, "Block with unknown parent received";
+                    debug!(self.log, "Block with unknown parent received";
                             "peer_id" => format!("{:?}",peer_id));
                     self.send_to_sync(SyncMessage::UnknownBlock(peer_id, block));
                 }
@@ -592,7 +593,7 @@ impl<T: BeaconChainTypes> Processor<T> {
                 }
                 AttestationProcessingOutcome::UnknownHeadBlock { beacon_block_root } => {
                     // TODO: Maintain this attestation and re-process once sync completes
-                    trace!(
+                    debug!(
                     self.log,
                     "Attestation for unknown block";
                     "peer_id" => format!("{:?}", peer_id),

beacon_node/network/src/service.rs

@@ -7,7 +7,7 @@ use crate::{
 };
 use beacon_chain::{BeaconChain, BeaconChainTypes};
 use eth2_libp2p::Service as LibP2PService;
-use eth2_libp2p::{rpc::RPCRequest, Enr, Libp2pEvent, MessageId, NetworkGlobals, PeerId, Swarm};
+use eth2_libp2p::{rpc::RPCRequest, BehaviourEvent, Enr, MessageId, NetworkGlobals, PeerId, Swarm};
 use eth2_libp2p::{PubsubMessage, RPCEvent};
 use futures::prelude::*;
 use futures::Stream;
@@ -280,7 +280,7 @@ fn spawn_service<T: BeaconChainTypes>(
         loop {
             match service.libp2p.poll() {
                 Ok(Async::Ready(Some(event))) => match event {
-                    Libp2pEvent::RPC(peer_id, rpc_event) => {
+                    BehaviourEvent::RPC(peer_id, rpc_event) => {
                         // if we received a Goodbye message, drop and ban the peer
                         if let RPCEvent::Request(_, RPCRequest::Goodbye(_)) = rpc_event {
                             peers_to_ban.push(peer_id.clone());
@@ -289,19 +289,25 @@ fn spawn_service<T: BeaconChainTypes>(
                             .try_send(RouterMessage::RPC(peer_id, rpc_event))
                             .map_err(|_| { debug!(log, "Failed to send RPC to router");} )?;
                     }
-                    Libp2pEvent::PeerDialed(peer_id) => {
-                        debug!(log, "Peer Dialed"; "peer_id" => format!("{:?}", peer_id));
+                    BehaviourEvent::PeerDialed(peer_id) => {
+                        debug!(log, "Peer Dialed"; "peer_id" => format!("{}", peer_id));
                         service.router_send
                             .try_send(RouterMessage::PeerDialed(peer_id))
                             .map_err(|_| { debug!(log, "Failed to send peer dialed to router");})?;
                     }
-                    Libp2pEvent::PeerDisconnected(peer_id) => {
-                        debug!(log, "Peer Disconnected";  "peer_id" => format!("{:?}", peer_id));
+                    BehaviourEvent::PeerDisconnected(peer_id) => {
+                        debug!(log, "Peer Disconnected";  "peer_id" => format!("{}", peer_id));
                         service.router_send
                             .try_send(RouterMessage::PeerDisconnected(peer_id))
                             .map_err(|_| { debug!(log, "Failed to send peer disconnect to router");})?;
                     }
-                    Libp2pEvent::PubsubMessage {
+                    BehaviourEvent::StatusPeer(peer_id) => {
+                        debug!(log, "Re-status peer";  "peer_id" => format!("{}", peer_id));
+                        service.router_send
+                            .try_send(RouterMessage::StatusPeer(peer_id))
+                            .map_err(|_| { debug!(log, "Failed to send re-status  peer to router");})?;
+                    }
+                    BehaviourEvent::PubsubMessage {
                         id,
                         source,
                         message,
@@ -329,7 +335,7 @@ fn spawn_service<T: BeaconChainTypes>(
                             }
                         }
                     }
-                    Libp2pEvent::PeerSubscribed(_, _) => {}
+                    BehaviourEvent::PeerSubscribed(_, _) => {}
                 },
                 Ok(Async::Ready(None)) => unreachable!("Stream never ends"),
                 Ok(Async::NotReady) => break,