Activate peer scoring (#1284)

* Initial score structure

* Peer manager update

* Updates to dialing

* Correct tests

* Correct typos and remove unused function

* Integrate scoring into the network crate

* Clean warnings

* Formatting

* Shift core functionality into the behaviour

* Temp commit

* Shift disconnections into the behaviour

* Temp commit

* Update libp2p and gossipsub

* Remove gossipsub lru cache

* Correct merge conflicts

* Modify handler and correct tests

* Update enr network globals on socket update

* Apply clippy lints

* Add new prysm fingerprint

* More clippy fixes

beacon_node/eth2_libp2p/src/rpc/codec/ssz.rs

@@ -145,7 +145,7 @@ impl<TSpec: EthSpec> Decoder for SSZInboundCodec<TSpec> {
                 },
                 Protocol::MetaData => match self.protocol.version {
                     Version::V1 => {
-                        if packet.len() > 0 {
+                        if !packet.is_empty() {
                             Err(RPCError::InvalidData)
                         } else {
                             Ok(Some(RPCRequest::MetaData(PhantomData)))

beacon_node/eth2_libp2p/src/rpc/codec/ssz_snappy.rs

@@ -74,7 +74,7 @@ impl<TSpec: EthSpec> Encoder<RPCCodedResponse<TSpec>> for SSZSnappyInboundCodec<
         // SSZ encoded bytes should be within `max_packet_size`
         if bytes.len() > self.max_packet_size {
             return Err(RPCError::InternalError(
-                "attempting to encode data > max_packet_size".into(),
+                "attempting to encode data > max_packet_size",
             ));
         }
         // Inserts the length prefix of the uncompressed bytes into dst
@@ -186,7 +186,7 @@ impl<TSpec: EthSpec> Decoder for SSZSnappyInboundCodec<TSpec> {
                     },
                     Protocol::MetaData => match self.protocol.version {
                         Version::V1 => {
-                            if decoded_buffer.len() > 0 {
+                            if !decoded_buffer.is_empty() {
                                 Err(RPCError::InvalidData)
                             } else {
                                 Ok(Some(RPCRequest::MetaData(PhantomData)))

beacon_node/eth2_libp2p/src/rpc/handler.rs

@@ -20,7 +20,7 @@ use std::{
     collections::hash_map::Entry,
     pin::Pin,
     task::{Context, Poll},
-    time::{Duration, Instant},
+    time::Duration,
 };
 use tokio::time::{delay_queue, delay_until, Delay, DelayQueue, Instant as TInstant};
 use types::EthSpec;
@@ -40,19 +40,19 @@ const SHUTDOWN_TIMEOUT_SECS: u8 = 15;
 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 pub struct SubstreamId(usize);
 
-/// An error encoutered by the handler.
+/// An error encountered by the handler.
 pub enum HandlerErr {
-    /// An error ocurred for this peer's request. This can occurr during protocol negotiation,
-    /// message passing, or if the handler identifies that we are sending an error reponse to the peer.
+    /// An error occurred for this peer's request. This can occur during protocol negotiation,
+    /// message passing, or if the handler identifies that we are sending an error response to the peer.
     Inbound {
         /// Id of the peer's request for which an error occurred.
         id: SubstreamId,
         /// Information of the negotiated protocol.
         proto: Protocol,
-        /// The error that ocurred.
+        /// The error that occurred.
         error: RPCError,
     },
-    /// An error ocurred for this request. Such error can occurr during protocol negotiation,
+    /// An error occurred for this request. Such error can occur during protocol negotiation,
     /// message passing, or if we successfully received a response from the peer, but this response
     /// indicates an error.
     Outbound {
@@ -60,7 +60,7 @@ pub enum HandlerErr {
         id: RequestId,
         /// Information of the protocol.
         proto: Protocol,
-        /// The error that ocurred.
+        /// The error that occurred.
         error: RPCError,
     },
 }
@@ -122,9 +122,6 @@ where
     /// State of the handler.
     state: HandlerState,
 
-    /// After the given duration has elapsed, an inactive connection will shutdown.
-    inactive_timeout: Duration,
-
     /// Try to negotiate the outbound upgrade a few times if there is an IO error before reporting the request as failed.
     /// This keeps track of the number of attempts.
     outbound_io_error_retries: u8,
@@ -139,6 +136,7 @@ enum HandlerState {
     /// The handler is shutting_down.
     ///
     /// While in this state the handler rejects new requests but tries to finish existing ones.
+    /// Once the timer expires, all messages are killed.
     ShuttingDown(Delay),
     /// The handler is deactivated. A goodbye has been sent and no more messages are sent or
     /// received.
@@ -278,11 +276,7 @@ impl<TSpec> RPCHandler<TSpec>
 where
     TSpec: EthSpec,
 {
-    pub fn new(
-        listen_protocol: SubstreamProtocol<RPCProtocol<TSpec>>,
-        inactive_timeout: Duration,
-        log: &slog::Logger,
-    ) -> Self {
+    pub fn new(listen_protocol: SubstreamProtocol<RPCProtocol<TSpec>>, log: &slog::Logger) -> Self {
         RPCHandler {
             listen_protocol,
             pending_errors: Vec::new(),
@@ -299,7 +293,6 @@ where
             state: HandlerState::Active,
             max_dial_negotiated: 8,
             keep_alive: KeepAlive::Yes,
-            inactive_timeout,
             outbound_io_error_retries: 0,
             log: log.clone(),
         }
@@ -496,19 +489,21 @@ where
         // Check that we don't have outbound items pending for dialing, nor dialing, nor
         // established. Also check that there are no established inbound substreams.
         // Errors and events need to be reported back, so check those too.
-        let should_shutdown = self.dial_queue.is_empty()
-            && self.outbound_substreams.is_empty()
-            && self.inbound_substreams.is_empty()
-            && self.pending_errors.is_empty()
-            && self.events_out.is_empty()
-            && self.dial_negotiated == 0;
+        let should_shutdown = if let HandlerState::ShuttingDown(_) = self.state {
+            self.dial_queue.is_empty()
+                && self.outbound_substreams.is_empty()
+                && self.inbound_substreams.is_empty()
+                && self.pending_errors.is_empty()
+                && self.events_out.is_empty()
+                && self.dial_negotiated == 0
+        } else {
+            false
+        };
 
         match self.keep_alive {
-            KeepAlive::Yes if should_shutdown => {
-                self.keep_alive = KeepAlive::Until(Instant::now() + self.inactive_timeout);
-            }
+            KeepAlive::Yes if should_shutdown => self.keep_alive = KeepAlive::No,
             KeepAlive::Yes => {} // We continue being active
-            KeepAlive::Until(_) if should_shutdown => {} // Already deemed inactive
+            KeepAlive::Until(_) if should_shutdown => self.keep_alive = KeepAlive::No, // Already deemed inactive
             KeepAlive::Until(_) => {
                 // No longer idle
                 self.keep_alive = KeepAlive::Yes;
@@ -833,7 +828,7 @@ where
                                                     // await flush
                                                     entry.get_mut().0 =
                                                     InboundSubstreamState::ResponsePendingFlush {
-                                                        substream: substream,
+                                                        substream,
                                                         closing,
                                                     };
                                                     drive_stream_further = true;

beacon_node/eth2_libp2p/src/rpc/methods.rs

@@ -116,6 +116,18 @@ pub enum GoodbyeReason {
     /// Error/fault in the RPC.
     Fault = 3,
 
+    /// Teku uses this code for not being able to verify a network.
+    UnableToVerifyNetwork = 128,
+
+    /// The node has too many connected peers.
+    TooManyPeers = 129,
+
+    /// Scored poorly.
+    BadScore = 250,
+
+    /// The peer is banned
+    Banned = 251,
+
     /// Unknown reason.
     Unknown = 0,
 }
@@ -126,6 +138,10 @@ impl From<u64> for GoodbyeReason {
             1 => GoodbyeReason::ClientShutdown,
             2 => GoodbyeReason::IrrelevantNetwork,
             3 => GoodbyeReason::Fault,
+            128 => GoodbyeReason::UnableToVerifyNetwork,
+            129 => GoodbyeReason::TooManyPeers,
+            250 => GoodbyeReason::BadScore,
+            251 => GoodbyeReason::Banned,
             _ => GoodbyeReason::Unknown,
         }
     }
@@ -381,6 +397,10 @@ impl std::fmt::Display for GoodbyeReason {
             GoodbyeReason::ClientShutdown => write!(f, "Client Shutdown"),
             GoodbyeReason::IrrelevantNetwork => write!(f, "Irrelevant Network"),
             GoodbyeReason::Fault => write!(f, "Fault"),
+            GoodbyeReason::UnableToVerifyNetwork => write!(f, "Unable to verify network"),
+            GoodbyeReason::TooManyPeers => write!(f, "Too many peers"),
+            GoodbyeReason::BadScore => write!(f, "Bad Score"),
+            GoodbyeReason::Banned => write!(f, "Banned"),
             GoodbyeReason::Unknown => write!(f, "Unknown Reason"),
         }
     }

beacon_node/eth2_libp2p/src/rpc/mod.rs

@@ -14,7 +14,6 @@ use libp2p::{Multiaddr, PeerId};
 use slog::{debug, o};
 use std::marker::PhantomData;
 use std::task::{Context, Poll};
-use std::time::Duration;
 use types::EthSpec;
 
 pub(crate) use handler::HandlerErr;
@@ -149,7 +148,6 @@ where
             SubstreamProtocol::new(RPCProtocol {
                 phantom: PhantomData,
             }),
-            Duration::from_secs(30),
             &self.log,
         )
     }