Implement initial pubsub message handling

beacon_node/eth2-libp2p/src/behaviour.rs

@@ -13,11 +13,11 @@ use libp2p::{
     tokio_io::{AsyncRead, AsyncWrite},
     NetworkBehaviour, PeerId,
 };
-use slog::{debug, o};
+use slog::{debug, o, warn};
 use ssz::{ssz_encode, Decodable, DecodeError, Encodable, SszStream};
 use ssz_derive::{Decode, Encode};
 use types::Attestation;
-use types::Topic;
+use types::{Topic, TopicHash};
 
 /// Builds the network behaviour for the libp2p Swarm.
 /// Implements gossipsub message routing.
@@ -48,13 +48,33 @@ impl<TSubstream: AsyncRead + AsyncWrite> NetworkBehaviourEventProcess<GossipsubE
 {
     fn inject_event(&mut self, event: GossipsubEvent) {
         match event {
-            GossipsubEvent::Message(message) => {
-                let gs_message = String::from_utf8_lossy(&message.data);
-                // TODO: Remove this type - debug only
-                self.events
-                    .push(BehaviourEvent::Message(gs_message.to_string()))
+            GossipsubEvent::Message(gs_msg) => {
+                let pubsub_message = match PubsubMessage::ssz_decode(&gs_msg.data, 0) {
+                    //TODO: Punish peer on error
+                    Err(e) => {
+                        warn!(
+                            self.log,
+                            "Received undecodable message from Peer {:?}", gs_msg.source
+                        );
+                        return;
+                    }
+                    Ok((msg, _index)) => msg,
+                };
+
+                self.events.push(BehaviourEvent::GossipMessage {
+                    source: gs_msg.source,
+                    topics: gs_msg.topics,
+                    message: pubsub_message,
+                });
             }
-            _ => {}
+            GossipsubEvent::Subscribed {
+                peer_id: _,
+                topic: _,
+            }
+            | GossipsubEvent::Unsubscribed {
+                peer_id: _,
+                topic: _,
+            } => {}
         }
     }
 }
@@ -125,15 +145,6 @@ impl<TSubstream: AsyncRead + AsyncWrite> Behaviour<TSubstream> {
         }
     }
 
-    /* Behaviour functions */
-
-    /// Publishes a message on the pubsub (gossipsub) behaviour.
-    pub fn publish(&mut self, topic: Topic, message: PubsubMessage) {
-        //encode the message
-        let message_bytes = ssz_encode(&message);
-        self.gossipsub.publish(topic, message_bytes);
-    }
-
     /// Consumes the events list when polled.
     fn poll<TBehaviourIn>(
         &mut self,
@@ -157,6 +168,12 @@ impl<TSubstream: AsyncRead + AsyncWrite> Behaviour<TSubstream> {
     pub fn send_rpc(&mut self, peer_id: PeerId, rpc_event: RPCEvent) {
         self.serenity_rpc.send_rpc(peer_id, rpc_event);
     }
+
+    /// Publishes a message on the pubsub (gossipsub) behaviour.
+    pub fn publish(&mut self, topic: Topic, message: PubsubMessage) {
+        let message_bytes = ssz_encode(&message);
+        self.gossipsub.publish(topic, message_bytes);
+    }
 }
 
 /// The types of events than can be obtained from polling the behaviour.
@@ -165,7 +182,11 @@ pub enum BehaviourEvent {
     PeerDialed(PeerId),
     Identified(PeerId, IdentifyInfo),
     // TODO: This is a stub at the moment
-    Message(String),
+    GossipMessage {
+        source: PeerId,
+        topics: Vec<TopicHash>,
+        message: PubsubMessage,
+    },
 }
 
 /// Gossipsub message providing notification of a new block.

beacon_node/eth2-libp2p/src/lib.rs

@@ -8,12 +8,13 @@ pub mod error;
 pub mod rpc;
 mod service;
 
+pub use behaviour::PubsubMessage;
 pub use config::Config as NetworkConfig;
 pub use libp2p::{
     gossipsub::{GossipsubConfig, GossipsubConfigBuilder},
     PeerId,
 };
-pub use rpc::{HelloMessage, RPCEvent};
+pub use rpc::RPCEvent;
 pub use service::Libp2pEvent;
 pub use service::Service;
 pub use types::multiaddr;

beacon_node/eth2-libp2p/src/service.rs

@@ -1,4 +1,4 @@
-use crate::behaviour::{Behaviour, BehaviourEvent};
+use crate::behaviour::{Behaviour, BehaviourEvent, PubsubMessage};
 use crate::error;
 use crate::multiaddr::Protocol;
 use crate::rpc::RPCEvent;
@@ -16,7 +16,7 @@ use libp2p::{core, secio, PeerId, Swarm, Transport};
 use slog::{debug, info, trace, warn};
 use std::io::{Error, ErrorKind};
 use std::time::Duration;
-use types::TopicBuilder;
+use types::{TopicBuilder, TopicHash};
 
 /// The configuration and state of the libp2p components for the beacon node.
 pub struct Service {
@@ -107,9 +107,17 @@ impl Stream for Service {
                 //Behaviour events
                 Ok(Async::Ready(Some(event))) => match event {
                     // TODO: Stub here for debugging
-                    BehaviourEvent::Message(m) => {
-                        debug!(self.log, "Message received: {}", m);
-                        return Ok(Async::Ready(Some(Libp2pEvent::Message(m))));
+                    BehaviourEvent::GossipMessage {
+                        source,
+                        topics,
+                        message,
+                    } => {
+                        debug!(self.log, "Pubsub message received: {:?}", message);
+                        return Ok(Async::Ready(Some(Libp2pEvent::PubsubMessage {
+                            source,
+                            topics,
+                            message,
+                        })));
                     }
                     BehaviourEvent::RPC(peer_id, event) => {
                         return Ok(Async::Ready(Some(Libp2pEvent::RPC(peer_id, event))));
@@ -173,6 +181,10 @@ pub enum Libp2pEvent {
     PeerDialed(PeerId),
     /// Received information about a peer on the network.
     Identified(PeerId, IdentifyInfo),
-    // TODO: Pub-sub testing only.
-    Message(String),
+    /// Received pubsub message.
+    PubsubMessage {
+        source: PeerId,
+        topics: Vec<TopicHash>,
+        message: PubsubMessage,
+    },
 }