Merge branch 'master' into improved-message-validation

beacon_node/network/Cargo.toml

@@ -5,21 +5,21 @@ authors = ["Age Manning <Age@AgeManning.com>"]
 edition = "2018"
 
 [dev-dependencies]
-sloggers = "0.3.2"
+sloggers = "0.3.4"
 
 [dependencies]
 beacon_chain =  { path = "../beacon_chain" }
 store =  { path = "../store" }
 eth2-libp2p =  { path = "../eth2-libp2p" }
 types = { path = "../../eth2/types" }
-slog = { version = "^2.2.3" , features = ["max_level_trace"] }
+slog = { version = "2.5.2", features = ["max_level_trace"] }
 hex = "0.3"
-eth2_ssz = "0.1"
-tree_hash = "0.1"
-futures = "0.1.25"
-error-chain = "0.12.0"
-tokio = "0.1.16"
+eth2_ssz = "0.1.2"
+tree_hash = "0.1.0"
+futures = "0.1.29"
+error-chain = "0.12.1"
+tokio = "0.1.22"
 parking_lot = "0.9.0"
-smallvec = "0.6.10"
+smallvec = "0.6.11"
 state_processing = { path = "../../eth2/state_processing" }
-bls = { path = "../../eth2/utils/bls" }
+bls = { path = "../../eth2/utils/bls" }

beacon_node/network/src/message_handler.rs

@@ -51,7 +51,7 @@ impl<T: BeaconChainTypes + 'static> MessageHandler<T> {
         executor: &tokio::runtime::TaskExecutor,
         log: slog::Logger,
     ) -> error::Result<mpsc::UnboundedSender<HandlerMessage>> {
-        let message_handler_log = log.new(o!("Service"=> "Message Handler"));
+        let message_handler_log = log.new(o!("service"=> "msg_handler"));
         trace!(message_handler_log, "Service starting");
 
         let (handler_send, handler_recv) = mpsc::unbounded_channel();
@@ -146,9 +146,15 @@ impl<T: BeaconChainTypes + 'static> MessageHandler<T> {
     ) {
         // an error could have occurred.
         match error_response {
-            RPCErrorResponse::InvalidRequest(error) => warn!(self.log, "Peer indicated invalid request";"peer_id" => format!("{:?}", peer_id), "error" => error.as_string()),
-            RPCErrorResponse::ServerError(error) => warn!(self.log, "Peer internal server error";"peer_id" => format!("{:?}", peer_id), "error" => error.as_string()),
-            RPCErrorResponse::Unknown(error) => warn!(self.log, "Unknown peer error";"peer" => format!("{:?}", peer_id), "error" => error.as_string()),
+            RPCErrorResponse::InvalidRequest(error) => {
+                warn!(self.log, "Peer indicated invalid request";"peer_id" => format!("{:?}", peer_id), "error" => error.as_string())
+            }
+            RPCErrorResponse::ServerError(error) => {
+                warn!(self.log, "Peer internal server error";"peer_id" => format!("{:?}", peer_id), "error" => error.as_string())
+            }
+            RPCErrorResponse::Unknown(error) => {
+                warn!(self.log, "Unknown peer error";"peer" => format!("{:?}", peer_id), "error" => error.as_string())
+            }
             RPCErrorResponse::Success(response) => {
                 match response {
                     RPCResponse::Hello(hello_message) => {

beacon_node/network/src/service.rs

@@ -10,7 +10,7 @@ use eth2_libp2p::{PubsubMessage, RPCEvent};
 use futures::prelude::*;
 use futures::Stream;
 use parking_lot::Mutex;
-use slog::{debug, info, o, trace};
+use slog::{debug, info, trace};
 use std::sync::Arc;
 use tokio::runtime::TaskExecutor;
 use tokio::sync::{mpsc, oneshot};
@@ -29,15 +29,18 @@ impl<T: BeaconChainTypes + 'static> Service<T> {
         beacon_chain: Arc<BeaconChain<T>>,
         config: &NetworkConfig,
         executor: &TaskExecutor,
-        log: slog::Logger,
+        network_log: slog::Logger,
     ) -> error::Result<(Arc<Self>, mpsc::UnboundedSender<NetworkMessage>)> {
         // build the network channel
         let (network_send, network_recv) = mpsc::unbounded_channel::<NetworkMessage>();
         // launch message handler thread
-        let message_handler_send =
-            MessageHandler::spawn(beacon_chain, network_send.clone(), executor, log.clone())?;
+        let message_handler_send = MessageHandler::spawn(
+            beacon_chain,
+            network_send.clone(),
+            executor,
+            network_log.clone(),
+        )?;
 
-        let network_log = log.new(o!("Service" => "Network"));
         // launch libp2p service
         let libp2p_service = Arc::new(Mutex::new(LibP2PService::new(
             config.clone(),

beacon_node/network/src/sync/simple_sync.rs

@@ -74,7 +74,7 @@ impl<T: BeaconChainTypes> MessageProcessor<T> {
         network_send: mpsc::UnboundedSender<NetworkMessage>,
         log: &slog::Logger,
     ) -> Self {
-        let sync_logger = log.new(o!("Service"=> "Sync"));
+        let sync_logger = log.new(o!("service"=> "sync"));
         let sync_network_context = NetworkContext::new(network_send.clone(), sync_logger.clone());
 
         // spawn the sync thread