Basic networking service with channel

beacon_node/libp2p/src/behaviour.rs

@@ -1,7 +1,7 @@
 use futures::prelude::*;
 use libp2p::{
     core::swarm::{NetworkBehaviourAction, NetworkBehaviourEventProcess},
-    gossipsub::{Gossipsub, GossipsubConfig, GossipsubEvent, GossipsubRpc},
+    gossipsub::{Gossipsub, GossipsubConfig, GossipsubEvent},
     tokio_io::{AsyncRead, AsyncWrite},
     NetworkBehaviour, PeerId,
 };
@@ -9,13 +9,14 @@ use libp2p::{
 /// Builds the network behaviour for the libp2p Swarm.
 /// Implements gossipsub message routing.
 #[derive(NetworkBehaviour)]
+#[behaviour(out_event = "BehaviourEvent", poll_method = "poll")]
 pub struct Behaviour<TSubstream: AsyncRead + AsyncWrite> {
     gossipsub: Gossipsub<TSubstream>,
     // TODO: Add Kademlia for peer discovery
     /// The events generated by this behaviour to be consumed in the swarm poll.
     // We use gossipsub events for now, generalise later.
     #[behaviour(ignore)]
-    events: Vec<GossipsubEvent>,
+    events: Vec<BehaviourEvent>,
 }
 
 // Implement the NetworkBehaviourEventProcess trait so that we can derive NetworkBehaviour for Behaviour
@@ -23,7 +24,15 @@ impl<TSubstream: AsyncRead + AsyncWrite> NetworkBehaviourEventProcess<GossipsubE
     for Behaviour<TSubstream>
 {
     fn inject_event(&mut self, event: GossipsubEvent) {
-        self.events.push(event);
+        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()))
+            }
+            _ => {}
+        }
     }
 }
 
@@ -35,8 +44,10 @@ impl<TSubstream: AsyncRead + AsyncWrite> Behaviour<TSubstream> {
         }
     }
 
-    /// Consume the events list when polled.
-    fn poll(&mut self) -> Async<NetworkBehaviourAction<GossipsubRpc, GossipsubEvent>> {
+    /// Consumes the events list when polled.
+    fn poll<TBehaviourIn>(
+        &mut self,
+    ) -> Async<NetworkBehaviourAction<TBehaviourIn, BehaviourEvent>> {
         if !self.events.is_empty() {
             return Async::Ready(NetworkBehaviourAction::GenerateEvent(self.events.remove(0)));
         }
@@ -44,3 +55,16 @@ impl<TSubstream: AsyncRead + AsyncWrite> Behaviour<TSubstream> {
         Async::NotReady
     }
 }
+
+impl<TSubstream: AsyncRead + AsyncWrite> Behaviour<TSubstream> {
+    pub fn send_message(&self, message: String) {
+        // TODO: Encode and send via gossipsub
+
+    }
+}
+
+/// The types of events than can be obtained from polling the behaviour.
+pub enum BehaviourEvent {
+    // TODO: This is a stub at the moment
+    Message(String),
+}

beacon_node/libp2p/src/error.rs

@@ -0,0 +1,8 @@
+// generates error types
+
+use error_chain::{
+    error_chain, error_chain_processing, impl_error_chain_kind, impl_error_chain_processed,
+    impl_extract_backtrace,
+};
+
+error_chain! {}

beacon_node/libp2p/src/lib.rs

@@ -2,7 +2,8 @@
 /// all required libp2p functionality.
 ///
 /// This crate builds and manages the libp2p services required by the beacon node.
-mod behaviour;
+pub mod behaviour;
+pub mod error;
 mod network_config;
 mod service;
 
@@ -11,6 +12,7 @@ pub use libp2p::{
     PeerId,
 };
 pub use network_config::NetworkConfig;
+pub use service::Libp2pEvent;
 pub use service::Service;
 pub use types::multiaddr;
 pub use types::Multiaddr;

beacon_node/libp2p/src/service.rs

@@ -1,7 +1,9 @@
-use crate::behaviour::Behaviour;
+use crate::behaviour::{Behaviour, BehaviourEvent};
+use crate::error;
 use crate::multiaddr::Protocol;
 use crate::NetworkConfig;
 use futures::prelude::*;
+use futures::Stream;
 use libp2p::core::{
     muxing::StreamMuxerBox,
     nodes::Substream,
@@ -17,13 +19,16 @@ use std::time::Duration;
 /// The configuration and state of the libp2p components for the beacon node.
 pub struct Service {
     /// The libp2p Swarm handler.
-    swarm: Swarm<Boxed<(PeerId, StreamMuxerBox), Error>, Behaviour<Substream<StreamMuxerBox>>>,
+    //TODO: Make this private
+    pub swarm: Swarm<Boxed<(PeerId, StreamMuxerBox), Error>, Behaviour<Substream<StreamMuxerBox>>>,
     /// This node's PeerId.
     local_peer_id: PeerId,
+    /// The libp2p logger handle.
+    pub log: slog::Logger,
 }
 
 impl Service {
-    pub fn new(config: NetworkConfig, log: slog::Logger) -> Self {
+    pub fn new(config: NetworkConfig, log: slog::Logger) -> error::Result<Self> {
         debug!(log, "Libp2p Service starting");
 
         let local_private_key = config.local_private_key;
@@ -50,7 +55,7 @@ impl Service {
                 Err(err) => warn!(log, "Cannot listen on: {} : {:?}", address, err),
             };
         }
-        // connect to boot nodes - these are currently stored as multiadders
+        // connect to boot nodes - these are currently stored as multiaddrs
         // Once we have discovery, can set to peerId
         for bootnode in config.boot_nodes {
             match Swarm::dial_addr(&mut swarm, bootnode.clone()) {
@@ -62,10 +67,36 @@ impl Service {
             };
         }
 
-        Service {
+        Ok(Service {
             local_peer_id,
             swarm,
+            log,
+        })
+    }
+}
+
+impl Stream for Service {
+    type Item = Libp2pEvent;
+    type Error = crate::error::Error;
+
+    fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
+        loop {
+            // TODO: Currently only gossipsub events passed here.
+            // Build a type for more generic events
+            match self.swarm.poll() {
+                Ok(Async::Ready(Some(BehaviourEvent::Message(m)))) => {
+                    // TODO: Stub here for debugging
+                    debug!(self.log, "Message received: {}", m);
+                    return Ok(Async::Ready(Some(Libp2pEvent::Message(m))));
+                }
+                // TODO: Fill with all behaviour events
+                _ => break,
+                Ok(Async::Ready(None)) => unreachable!("Swarm stream shouldn't end"),
+                Ok(Async::NotReady) => break,
+                _ => break,
+            }
         }
+        Ok(Async::NotReady)
     }
 }
 
@@ -103,3 +134,8 @@ fn build_transport(
         .map_err(|err| Error::new(ErrorKind::Other, err))
         .boxed()
 }
+
+/// Events that can be obtained from polling the Libp2p Service.
+pub enum Libp2pEvent {
+    Message(String),
+}