Merge branch 'rpc_testing_2' into lc-reqresp

Author: GeemoCandama

beacon_node/lighthouse_network/src/rpc/codec/mod.rs

@@ -1,8 +1,10 @@
 pub(crate) mod base;
 pub(crate) mod ssz_snappy;
 
-use self::base::{BaseInboundCodec, BaseOutboundCodec};
-use self::ssz_snappy::{SSZSnappyInboundCodec, SSZSnappyOutboundCodec};
+use self::base::BaseInboundCodec;
+pub use self::base::BaseOutboundCodec;
+use self::ssz_snappy::SSZSnappyInboundCodec;
+pub use self::ssz_snappy::SSZSnappyOutboundCodec;
 use crate::rpc::protocol::RPCError;
 use crate::rpc::{InboundRequest, OutboundRequest, RPCCodedResponse};
 use libp2p::bytes::BytesMut;

beacon_node/lighthouse_network/src/rpc/handler.rs

@@ -45,7 +45,7 @@ const MAX_INBOUND_SUBSTREAMS: usize = 32;
 
 /// Identifier of inbound and outbound substreams from the handler's perspective.
 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
-pub struct SubstreamId(usize);
+pub struct SubstreamId(pub usize);
 
 type InboundSubstream<TSpec> = InboundFramed<NegotiatedSubstream, TSpec>;
 
@@ -133,7 +133,7 @@ where
     log: slog::Logger,
 }
 
-enum HandlerState {
+pub enum HandlerState {
     /// The handler is active. All messages are sent and received.
     Active,
     /// The handler is shutting_down.
@@ -164,17 +164,17 @@ struct InboundInfo<TSpec: EthSpec> {
 }
 
 /// Contains the information the handler keeps on established outbound substreams.
-struct OutboundInfo<Id, TSpec: EthSpec> {
+pub struct OutboundInfo<Id, TSpec: EthSpec> {
     /// State of the substream.
-    state: OutboundSubstreamState<TSpec>,
+    pub state: OutboundSubstreamState<TSpec>,
     /// Key to keep track of the substream's timeout via `self.outbound_substreams_delay`.
-    delay_key: delay_queue::Key,
+    pub delay_key: delay_queue::Key,
     /// Info over the protocol this substream is handling.
-    proto: Protocol,
+    pub proto: Protocol,
     /// Number of chunks to be seen from the peer's response.
-    remaining_chunks: Option<u64>,
+    pub remaining_chunks: Option<u64>,
     /// `Id` as given by the application that sent the request.
-    req_id: Id,
+    pub req_id: Id,
 }
 
 /// State of an inbound substream connection.

beacon_node/lighthouse_network/src/rpc/mod.rs

@@ -5,7 +5,6 @@
 //! syncing.
 
 use futures::future::FutureExt;
-use handler::{HandlerEvent, RPCHandler};
 use libp2p::core::connection::ConnectionId;
 use libp2p::swarm::{
     handler::ConnectionHandler, NetworkBehaviour, NetworkBehaviourAction, NotifyHandler,
@@ -20,17 +19,23 @@ use std::task::{Context, Poll};
 use std::time::Duration;
 use types::{EthSpec, ForkContext};
 
-pub(crate) use handler::HandlerErr;
 pub(crate) use methods::{MetaData, MetaDataV1, MetaDataV2, Ping, RPCCodedResponse, RPCResponse};
-pub(crate) use protocol::{InboundRequest, RPCProtocol};
+pub(crate) use protocol::InboundRequest;
 
-pub use handler::SubstreamId;
+pub use codec::{BaseOutboundCodec, OutboundCodec, SSZSnappyOutboundCodec};
+pub use handler::{
+    HandlerErr, HandlerEvent, HandlerState,
+    OutboundInfo, OutboundSubstreamState, RPCHandler, SubstreamId,
+};
 pub use methods::{
     BlocksByRangeRequest, BlocksByRootRequest, GoodbyeReason, LightClientBootstrapRequest, MaxRequestBlocks,
     RPCResponseErrorCode, ResponseTermination, StatusMessage, MAX_REQUEST_BLOCKS,
 };
-pub(crate) use outbound::OutboundRequest;
-pub use protocol::{max_rpc_size, Protocol, RPCError};
+pub use outbound::OutboundFramed;
+pub use outbound::OutboundRequest;
+pub use protocol::{
+    max_rpc_size, Encoding, Protocol, ProtocolId, RPCError, RPCProtocol, Version,
+};
 
 use self::config::OutboundRateLimiterConfig;
 use self::self_limiter::SelfRateLimiter;

beacon_node/lighthouse_network/src/rpc/protocol.rs

@@ -352,10 +352,7 @@ impl ProtocolId {
                 <MetaDataV1<T> as Encode>::ssz_fixed_len(),
                 <MetaDataV2<T> as Encode>::ssz_fixed_len(),
             ),
-            Protocol::LightClientBootstrap => RpcLimits::new(
-                <LightClientBootstrapRequest as Encode>::ssz_fixed_len(),
-                <LightClientBootstrapRequest as Encode>::ssz_fixed_len(),
-            ),
+            Protocol::LightClientBootstrap => rpc_block_limits_by_fork(fork_context.current_fork()),
             Protocol::LightClientOptimisticUpdate => RpcLimits::new(
                 <LightClientOptimisticUpdate<T> as Encode>::ssz_fixed_len(),
                 <LightClientOptimisticUpdate<T> as Encode>::ssz_fixed_len(),