Testnet compatible network upgrade (#587)

* Create libp2p instance

* Change logger to stdlog

* test_connection initial commit

* Add gossipsub test

* Delete tests in network crate

* Add test module

* Clean tests

* Remove dependency on discovery

* Working publish between 2 nodes
TODO: Publish should be called just once

* Working 2 peer gossipsub test with additional events

* Cleanup test

* Add rpc test

* Star topology discovery WIP

* build_nodes builds and connects n nodes. Increase nodes in gossipsub test

* Add unsubscribe method and expose reference to gossipsub object for gossipsub tests

* Add gossipsub message forwarding test

* Fix gossipsub forward test

* Test improvements
* Remove discovery tests
* Simplify gossipsub forward test topology
* Add helper functions for topology building

* Clean up tests

* Update naming to new network spec

* Correct ssz encoding of protocol names

* Further additions to network upgrade

* Initial network spec update WIP

* Temp commit

* Builds one side of the streamed RPC responses

* Temporary commit

* Propagates streaming changes up into message handler

* Intermediate network update

* Partial update in upgrading to the new network spec

* Update dependencies, remove redundant deps

* Correct sync manager for block stream handling

* Re-write of RPC handler, improves efficiency and corrects bugs

* Stream termination update

* Completed refactor of rpc handler

* Remove crates

* Correct compile issues associated with test merge

* Build basic tests and testing structure for eth2-libp2p

* Enhance RPC tests and add logging

* Complete RPC testing framework and STATUS test

* Decoding bug fixes, log improvements, stream test

* Clean up RPC handler logging

* Decoder bug fix, empty block stream test

* Add BlocksByRoot RPC test

* Add Goodbye RPC test

* Syncing and stream handling bug fixes and performance improvements

* Applies discv5 bug fixes

* Adds DHT IP filtering for lighthouse - currently disabled

* Adds randomized network propagation as a CLI arg

* Add disconnect functionality

* Adds attestation handling and parent lookup

* Adds RPC error handling for the sync manager

* Allow parent's blocks to be already processed

* Update github workflow

* Adds reviewer suggestions

beacon_node/eth2-libp2p/src/rpc/mod.rs

@@ -9,29 +9,32 @@ use handler::RPCHandler;
 use libp2p::core::ConnectedPoint;
 use libp2p::swarm::{
     protocols_handler::ProtocolsHandler, NetworkBehaviour, NetworkBehaviourAction, PollParameters,
+    SubstreamProtocol,
 };
 use libp2p::{Multiaddr, PeerId};
-pub use methods::{ErrorMessage, HelloMessage, RPCErrorResponse, RPCResponse, RequestId};
+pub use methods::{
+    ErrorMessage, RPCErrorResponse, RPCResponse, RequestId, ResponseTermination, StatusMessage,
+};
 pub use protocol::{RPCError, RPCProtocol, RPCRequest};
 use slog::o;
 use std::marker::PhantomData;
+use std::time::Duration;
 use tokio::io::{AsyncRead, AsyncWrite};
 
 pub(crate) mod codec;
 mod handler;
 pub mod methods;
 mod protocol;
-// mod request_response;
 
 /// The return type used in the behaviour and the resultant event from the protocols handler.
 #[derive(Debug)]
 pub enum RPCEvent {
-    /// A request that was received from the RPC protocol. The first parameter is a sequential
+    /// An inbound/outbound request for RPC protocol. The first parameter is a sequential
     /// id which tracks an awaiting substream for the response.
     Request(RequestId, RPCRequest),
-
-    /// A response that has been received from the RPC protocol. The first parameter returns
-    /// that which was sent with the corresponding request.
+    /// A response that is being sent or has been received from the RPC protocol. The first parameter returns
+    /// that which was sent with the corresponding request, the second is a single chunk of a
+    /// response.
     Response(RequestId, RPCErrorResponse),
     /// An Error occurred.
     Error(RequestId, RPCError),
@@ -50,9 +53,9 @@ impl RPCEvent {
 impl std::fmt::Display for RPCEvent {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            RPCEvent::Request(id, req) => write!(f, "RPC Request(Id: {}, {})", id, req),
-            RPCEvent::Response(id, res) => write!(f, "RPC Response(Id: {}, {})", id, res),
-            RPCEvent::Error(id, err) => write!(f, "RPC Request(Id: {}, Error: {:?})", id, err),
+            RPCEvent::Request(id, req) => write!(f, "RPC Request(id: {}, {})", id, req),
+            RPCEvent::Response(id, res) => write!(f, "RPC Response(id: {}, {})", id, res),
+            RPCEvent::Error(id, err) => write!(f, "RPC Request(id: {}, error: {:?})", id, err),
         }
     }
 }
@@ -65,7 +68,7 @@ pub struct RPC<TSubstream> {
     /// Pins the generic substream.
     marker: PhantomData<(TSubstream)>,
     /// Slog logger for RPC behaviour.
-    _log: slog::Logger,
+    log: slog::Logger,
 }
 
 impl<TSubstream> RPC<TSubstream> {
@@ -74,7 +77,7 @@ impl<TSubstream> RPC<TSubstream> {
         RPC {
             events: Vec::new(),
             marker: PhantomData,
-            _log: log,
+            log: log,
         }
     }
 
@@ -97,7 +100,11 @@ where
     type OutEvent = RPCMessage;
 
     fn new_handler(&mut self) -> Self::ProtocolsHandler {
-        Default::default()
+        RPCHandler::new(
+            SubstreamProtocol::new(RPCProtocol),
+            Duration::from_secs(30),
+            &self.log,
+        )
     }
 
     // handled by discovery