Implement initial pubsub message handling

beacon_node/network/src/beacon_chain.rs

@@ -7,7 +7,7 @@ use beacon_chain::{
     types::{BeaconState, ChainSpec},
     AggregationOutcome, CheckPoint,
 };
-use eth2_libp2p::HelloMessage;
+use eth2_libp2p::rpc::HelloMessage;
 use types::{Attestation, BeaconBlock, BeaconBlockBody, BeaconBlockHeader, Epoch, Hash256, Slot};
 
 pub use beacon_chain::{BeaconChainError, BlockProcessingOutcome};

beacon_node/network/src/message_handler.rs

@@ -4,7 +4,7 @@ use crate::service::{NetworkMessage, OutgoingMessage};
 use crate::sync::SimpleSync;
 use crossbeam_channel::{unbounded as channel, Sender};
 use eth2_libp2p::{
-    behaviour::IncomingGossip,
+    behaviour::PubsubMessage,
     rpc::{methods::GoodbyeReason, RPCRequest, RPCResponse, RequestId},
     PeerId, RPCEvent,
 };
@@ -41,7 +41,7 @@ pub enum HandlerMessage {
     /// An RPC response/request has been received.
     RPC(PeerId, RPCEvent),
     /// A gossip message has been received.
-    IncomingGossip(PeerId, IncomingGossip),
+    PubsubMessage(PeerId, PubsubMessage),
 }
 
 impl MessageHandler {
@@ -92,7 +92,7 @@ impl MessageHandler {
                 self.handle_rpc_message(peer_id, rpc_event);
             }
             // we have received an RPC message request/response
-            HandlerMessage::IncomingGossip(peer_id, gossip) => {
+            HandlerMessage::PubsubMessage(peer_id, gossip) => {
                 self.handle_gossip(peer_id, gossip);
             }
             //TODO: Handle all messages
@@ -205,13 +205,13 @@ impl MessageHandler {
     }
 
     /// Handle RPC messages
-    fn handle_gossip(&mut self, peer_id: PeerId, gossip_message: IncomingGossip) {
+    fn handle_gossip(&mut self, peer_id: PeerId, gossip_message: PubsubMessage) {
         match gossip_message {
-            IncomingGossip::Block(message) => {
+            PubsubMessage::Block(message) => {
                 self.sync
                     .on_block_gossip(peer_id, message, &mut self.network_context)
             }
-            IncomingGossip::Attestation(message) => {
+            PubsubMessage::Attestation(message) => {
                 self.sync
                     .on_attestation_gossip(peer_id, message, &mut self.network_context)
             }

beacon_node/network/src/service.rs

@@ -3,16 +3,16 @@ use crate::error;
 use crate::message_handler::{HandlerMessage, MessageHandler};
 use crate::NetworkConfig;
 use crossbeam_channel::{unbounded as channel, Sender, TryRecvError};
-use eth2_libp2p::{RPCEvent, PublishMessage};
 use eth2_libp2p::Service as LibP2PService;
 use eth2_libp2p::{Libp2pEvent, PeerId};
+use eth2_libp2p::{PubsubMessage, RPCEvent};
 use futures::prelude::*;
 use futures::sync::oneshot;
 use futures::Stream;
 use slog::{debug, info, o, trace};
 use std::sync::Arc;
 use tokio::runtime::TaskExecutor;
-use types::{BeaconBlock, Topic};
+use types::Topic;
 
 /// Service that handles communication between internal services and the eth2_libp2p network service.
 pub struct Service {
@@ -100,6 +100,7 @@ fn spawn_service(
     Ok(network_exit)
 }
 
+//TODO: Potentially handle channel errors
 fn network_service(
     mut libp2p_service: LibP2PService,
     network_recv: crossbeam_channel::Receiver<NetworkMessage>,
@@ -129,10 +130,17 @@ fn network_service(
                             "We have identified peer: {:?} with {:?}", peer_id, info
                         );
                     }
-                    Libp2pEvent::Message(m) => debug!(
-                        libp2p_service.log,
-                        "Network Service: Message received: {}", m
-                    ),
+                    Libp2pEvent::PubsubMessage {
+                        source,
+                        topics: _,
+                        message,
+                    } => {
+                        //TODO: Decide if we need to propagate the topic upwards. (Potentially for
+                        //attestations)
+                        message_handler_send
+                            .send(HandlerMessage::PubsubMessage(source, message))
+                            .map_err(|_| " failed to send pubsub message to handler")?;
+                    }
                 },
                 Ok(Async::Ready(None)) => unreachable!("Stream never ends"),
                 Ok(Async::NotReady) => break,
@@ -157,17 +165,16 @@ fn network_service(
                         }
                     };
                 }
+                Ok(NetworkMessage::Publish(topic, message)) => {
+                    debug!(log, "Sending pubsub message on topic {:?}", topic);
+                    libp2p_service.swarm.publish(topic, message);
+                }
                 Err(TryRecvError::Empty) => break,
                 Err(TryRecvError::Disconnected) => {
                     return Err(eth2_libp2p::error::Error::from(
                         "Network channel disconnected",
                     ));
-                },
-            Ok(NetworkMessage::Publish(topic, message) => {
-                debug!(log, "Sending message on topic {:?}", topic);
-                libp2p_service.swarm.publish(topic,message)
-
-
+                }
             }
         }
         Ok(Async::NotReady)
@@ -180,8 +187,8 @@ pub enum NetworkMessage {
     /// Send a message to libp2p service.
     //TODO: Define typing for messages across the wire
     Send(PeerId, OutgoingMessage),
-    /// Publish a message to gossipsub
-    Publish(Topic, PublishMessage),
+    /// Publish a message to pubsub mechanism.
+    Publish(Topic, PubsubMessage),
 }
 
 /// Type of outgoing messages that can be sent through the network service.
@@ -192,4 +199,3 @@ pub enum OutgoingMessage {
     //TODO: Remove
     NotifierTest,
 }
-