Handle peer dials and propagate to message handler

beacon_node/network/src/message_handler.rs

@@ -4,30 +4,37 @@ use crossbeam_channel::{unbounded as channel, Sender, TryRecvError};
 use futures::future;
 use futures::prelude::*;
 use libp2p::rpc;
-use libp2p::{PeerId, RpcEvent};
+use libp2p::{PeerId, RPCEvent};
 use slog::debug;
+use std::collections::HashMap;
+use std::time::{Duration, Instant};
 use sync::SimpleSync;
 use types::Hash256;
 
+/// Timeout for establishing a HELLO handshake.
+const HELLO_TIMEOUT: Duration = Duration::from_secs(30);
+
 /// Handles messages received from the network and client and organises syncing.
 pub struct MessageHandler {
     sync: SimpleSync,
     //TODO: Implement beacon chain
     //chain: BeaconChain
+    /// A mapping of peers we have sent a HELLO rpc request to
+    hello_requests: HashMap<PeerId, Instant>,
     log: slog::Logger,
 }
 
 /// Types of messages the handler can receive.
 #[derive(Debug, Clone)]
 pub enum HandlerMessage {
-    /// Peer has connected.
-    PeerConnected(PeerId),
+    /// We have initiated a connection to a new peer.
+    PeerDialed(PeerId),
     /// Peer has disconnected,
     PeerDisconnected(PeerId),
     /// A Node message has been received.
     Message(PeerId, NodeMessage),
     /// An RPC response/request has been received.
-    RPC(RpcEvent),
+    RPC(RPCEvent),
 }
 
 impl MessageHandler {
@@ -49,6 +56,7 @@ impl MessageHandler {
         //TODO: Initialise beacon chain
         let mut handler = MessageHandler {
             sync,
+            hello_requests: HashMap::new(),
             log: log.clone(),
         };
 

beacon_node/network/src/messages.rs

@@ -1,11 +1,11 @@
 use libp2p::PeerId;
-use libp2p::{HelloMessage, RpcEvent};
+use libp2p::{HelloMessage, RPCEvent};
 use types::{Hash256, Slot};
 
 /// Messages between nodes across the network.
 #[derive(Debug, Clone)]
 pub enum NodeMessage {
-    RPC(RpcEvent),
+    RPC(RPCEvent),
     BlockRequest,
     // TODO: only for testing - remove
     Message(String),

beacon_node/network/src/service.rs

@@ -108,6 +108,12 @@ fn network_service(
                         .send(HandlerMessage::RPC(rpc_event))
                         .map_err(|_| "failed to send rpc to handler");
                 }
+                Ok(Async::Ready(Some(Libp2pEvent::PeerDialed(peer_id)))) => {
+                    debug!(libp2p_service.log, "Peer Dialed: {:?}", peer_id);
+                    message_handler_send
+                        .send(HandlerMessage::PeerDialed(peer_id))
+                        .map_err(|_| "failed to send rpc to handler");
+                }
                 Ok(Async::Ready(Some(Libp2pEvent::Message(m)))) => debug!(
                     libp2p_service.log,
                     "Network Service: Message received: {}", m