Add network routes to API

beacon_node/client/Cargo.toml

@@ -7,6 +7,7 @@ edition = "2018"
 [dependencies]
 beacon_chain = { path = "../beacon_chain" }
 network = { path = "../network" }
+eth2-libp2p = { path = "../eth2-libp2p" }
 rpc = { path = "../rpc" }
 rest_api = { path = "../rest_api" }
 prometheus = "^0.6"

beacon_node/client/src/lib.rs

@@ -48,7 +48,7 @@ pub struct Client<T: BeaconChainTypes> {
 
 impl<T> Client<T>
 where
-    T: BeaconChainTypes + InitialiseBeaconChain<T> + Clone + 'static,
+    T: BeaconChainTypes + InitialiseBeaconChain<T> + Clone + Send + Sync + 'static,
 {
     /// Generate an instance of the client. Spawn and link all internal sub-processes.
     pub fn new(
@@ -122,6 +122,7 @@ where
                 &client_config.rest_api,
                 executor,
                 beacon_chain.clone(),
+                network.clone(),
                 client_config.db_path().expect("unable to read datadir"),
                 &log,
             ) {

beacon_node/client/src/local_bootstrap.rs

@@ -1,3 +1,4 @@
+use eth2_libp2p::Enr;
 use reqwest::{Error as HttpError, Url};
 use types::{BeaconBlock, BeaconState, Checkpoint, EthSpec, Slot};
 
@@ -18,6 +19,7 @@ pub struct BootstrapParams<T: EthSpec> {
     pub finalized_state: BeaconState<T>,
     pub genesis_block: BeaconBlock<T>,
     pub genesis_state: BeaconState<T>,
+    pub enr: Enr,
 }
 
 impl<T: EthSpec> BootstrapParams<T> {
@@ -37,6 +39,7 @@ impl<T: EthSpec> BootstrapParams<T> {
                 .map_err(|e| format!("Unable to get genesis block: {:?}", e))?,
             genesis_state: get_state(url.clone(), genesis_slot)
                 .map_err(|e| format!("Unable to get genesis state: {:?}", e))?,
+            enr: get_enr(url.clone()).map_err(|e| format!("Unable to get ENR: {:?}", e))?,
         })
     }
 }
@@ -97,3 +100,16 @@ fn get_block<T: EthSpec>(mut url: Url, slot: Slot) -> Result<BeaconBlock<T>, Err
         .json()
         .map_err(Into::into)
 }
+
+fn get_enr(mut url: Url) -> Result<Enr, Error> {
+    url.path_segments_mut()
+        .map(|mut url| {
+            url.push("node").push("network").push("enr");
+        })
+        .map_err(|_| Error::UrlCannotBeBase)?;
+
+    reqwest::get(url)?
+        .error_for_status()?
+        .json()
+        .map_err(Into::into)
+}

beacon_node/eth2-libp2p/src/behaviour.rs

@@ -7,6 +7,7 @@ use futures::prelude::*;
 use libp2p::{
     core::identity::Keypair,
     discv5::Discv5Event,
+    enr::Enr,
     gossipsub::{Gossipsub, GossipsubEvent},
     identify::{Identify, IdentifyEvent},
     ping::{Ping, PingConfig, PingEvent},
@@ -78,6 +79,10 @@ impl<TSubstream: AsyncRead + AsyncWrite> Behaviour<TSubstream> {
             log: behaviour_log,
         })
     }
+
+    pub fn discovery(&self) -> &Discovery<TSubstream> {
+        &self.discovery
+    }
 }
 
 // Implement the NetworkBehaviourEventProcess trait so that we can derive NetworkBehaviour for Behaviour

beacon_node/eth2-libp2p/src/discovery.rs

@@ -103,6 +103,10 @@ impl<TSubstream> Discovery<TSubstream> {
         })
     }
 
+    pub fn local_enr(&self) -> &Enr {
+        self.discovery.local_enr()
+    }
+
     /// Manually search for peers. This restarts the discovery round, sparking multiple rapid
     /// queries.
     pub fn discover_peers(&mut self) {
@@ -120,6 +124,11 @@ impl<TSubstream> Discovery<TSubstream> {
         self.connected_peers.len()
     }
 
+    /// The current number of connected libp2p peers.
+    pub fn connected_peer_set(&self) -> &HashSet<PeerId> {
+        &self.connected_peers
+    }
+
     /// Search for new peers using the underlying discovery mechanism.
     fn find_peers(&mut self) {
         // pick a random NodeId

beacon_node/eth2-libp2p/src/lib.rs

@@ -17,6 +17,7 @@ pub use behaviour::PubsubMessage;
 pub use config::{
     Config as NetworkConfig, BEACON_ATTESTATION_TOPIC, BEACON_BLOCK_TOPIC, SHARD_TOPIC_PREFIX,
 };
+pub use libp2p::enr::Enr;
 pub use libp2p::gossipsub::{Topic, TopicHash};
 pub use libp2p::multiaddr;
 pub use libp2p::Multiaddr;

beacon_node/eth2-libp2p/src/service.rs

@@ -15,7 +15,7 @@ use libp2p::core::{
     transport::boxed::Boxed,
     upgrade::{InboundUpgradeExt, OutboundUpgradeExt},
 };
-use libp2p::{core, secio, PeerId, Swarm, Transport};
+use libp2p::{core, enr::Enr, secio, PeerId, Swarm, Transport};
 use slog::{debug, info, trace, warn};
 use std::fs::File;
 use std::io::prelude::*;

beacon_node/network/src/service.rs

@@ -5,7 +5,7 @@ use beacon_chain::{BeaconChain, BeaconChainTypes};
 use core::marker::PhantomData;
 use eth2_libp2p::Service as LibP2PService;
 use eth2_libp2p::Topic;
-use eth2_libp2p::{Libp2pEvent, PeerId};
+use eth2_libp2p::{Enr, Libp2pEvent, PeerId};
 use eth2_libp2p::{PubsubMessage, RPCEvent};
 use futures::prelude::*;
 use futures::Stream;
@@ -64,6 +64,30 @@ impl<T: BeaconChainTypes + 'static> Service<T> {
         Ok((Arc::new(network_service), network_send))
     }
 
+    pub fn local_enr(&self) -> Enr {
+        self.libp2p_service
+            .lock()
+            .swarm
+            .discovery()
+            .local_enr()
+            .clone()
+    }
+
+    pub fn connected_peers(&self) -> usize {
+        self.libp2p_service.lock().swarm.connected_peers()
+    }
+
+    pub fn connected_peer_set(&self) -> Vec<PeerId> {
+        self.libp2p_service
+            .lock()
+            .swarm
+            .discovery()
+            .connected_peer_set()
+            .iter()
+            .cloned()
+            .collect()
+    }
+
     pub fn libp2p_service(&self) -> Arc<Mutex<LibP2PService>> {
         self.libp2p_service.clone()
     }

beacon_node/rest_api/Cargo.toml

@@ -7,6 +7,8 @@ edition = "2018"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 [dependencies]
 beacon_chain = { path = "../beacon_chain" }
+network = { path = "../network" }
+eth2-libp2p = { path = "../eth2-libp2p" }
 store = { path = "../store" }
 version = { path = "../version" }
 serde = { version = "1.0", features = ["derive"] }

beacon_node/rest_api/src/lib.rs

@@ -1,15 +1,18 @@
 #[macro_use]
 extern crate lazy_static;
+extern crate network as client_network;
 
 mod beacon;
 mod config;
 mod helpers;
 mod metrics;
+mod network;
 mod node;
 mod spec;
 mod url_query;
 
 use beacon_chain::{BeaconChain, BeaconChainTypes};
+use client_network::Service as NetworkService;
 pub use config::Config as ApiConfig;
 use hyper::rt::Future;
 use hyper::service::service_fn_ok;
@@ -68,10 +71,11 @@ impl From<state_processing::per_slot_processing::Error> for ApiError {
     }
 }
 
-pub fn start_server<T: BeaconChainTypes + Clone + 'static>(
+pub fn start_server<T: BeaconChainTypes + Clone + Send + Sync + 'static>(
     config: &ApiConfig,
     executor: &TaskExecutor,
     beacon_chain: Arc<BeaconChain<T>>,
+    network_service: Arc<NetworkService<T>>,
     db_path: PathBuf,
     log: &slog::Logger,
 ) -> Result<exit_future::Signal, hyper::Error> {
@@ -99,6 +103,7 @@ pub fn start_server<T: BeaconChainTypes + Clone + 'static>(
         let log = server_log.clone();
         let beacon_chain = server_bc.clone();
         let db_path = db_path.clone();
+        let network_service = network_service.clone();
 
         // Create a simple handler for the router, inject our stateful objects into the request.
         service_fn_ok(move |mut req| {
@@ -109,6 +114,8 @@ pub fn start_server<T: BeaconChainTypes + Clone + 'static>(
             req.extensions_mut()
                 .insert::<Arc<BeaconChain<T>>>(beacon_chain.clone());
             req.extensions_mut().insert::<DBPath>(db_path.clone());
+            req.extensions_mut()
+                .insert::<Arc<NetworkService<T>>>(network_service.clone());
 
             let path = req.uri().path().to_string();
 
@@ -124,6 +131,9 @@ pub fn start_server<T: BeaconChainTypes + Clone + 'static>(
                 (&Method::GET, "/metrics") => metrics::get_prometheus::<T>(req),
                 (&Method::GET, "/node/version") => node::get_version(req),
                 (&Method::GET, "/node/genesis_time") => node::get_genesis_time::<T>(req),
+                (&Method::GET, "/node/network/enr") => network::get_enr::<T>(req),
+                (&Method::GET, "/node/network/peer_count") => network::get_peer_count::<T>(req),
+                (&Method::GET, "/node/network/peers") => network::get_peer_list::<T>(req),
                 (&Method::GET, "/spec") => spec::get_spec::<T>(req),
                 (&Method::GET, "/spec/slots_per_epoch") => spec::get_slots_per_epoch::<T>(req),
                 _ => Err(ApiError::MethodNotAllowed(path.clone())),

beacon_node/rest_api/src/network.rs

@@ -0,0 +1,61 @@
+use crate::{success_response, ApiError, ApiResult, NetworkService};
+use beacon_chain::BeaconChainTypes;
+use eth2_libp2p::{Enr, PeerId};
+use hyper::{Body, Request};
+use std::sync::Arc;
+
+/// HTTP handle to return the Discv5 ENR from the client's libp2p service.
+///
+/// ENR is encoded as base64 string.
+pub fn get_enr<T: BeaconChainTypes + Send + Sync + 'static>(req: Request<Body>) -> ApiResult {
+    let network = req
+        .extensions()
+        .get::<Arc<NetworkService<T>>>()
+        .ok_or_else(|| ApiError::ServerError("NetworkService extension missing".to_string()))?;
+
+    let enr: Enr = network.local_enr();
+
+    Ok(success_response(Body::from(
+        serde_json::to_string(&enr.to_base64())
+            .map_err(|e| ApiError::ServerError(format!("Unable to serialize Enr: {:?}", e)))?,
+    )))
+}
+
+/// HTTP handle to return the number of peers connected in the client's libp2p service.
+pub fn get_peer_count<T: BeaconChainTypes + Send + Sync + 'static>(
+    req: Request<Body>,
+) -> ApiResult {
+    let network = req
+        .extensions()
+        .get::<Arc<NetworkService<T>>>()
+        .ok_or_else(|| ApiError::ServerError("NetworkService extension missing".to_string()))?;
+
+    let connected_peers: usize = network.connected_peers();
+
+    Ok(success_response(Body::from(
+        serde_json::to_string(&connected_peers)
+            .map_err(|e| ApiError::ServerError(format!("Unable to serialize Enr: {:?}", e)))?,
+    )))
+}
+
+/// HTTP handle to return the list of peers connected to the client's libp2p service.
+///
+/// Peers are presented as a list of `PeerId::to_string()`.
+pub fn get_peer_list<T: BeaconChainTypes + Send + Sync + 'static>(req: Request<Body>) -> ApiResult {
+    let network = req
+        .extensions()
+        .get::<Arc<NetworkService<T>>>()
+        .ok_or_else(|| ApiError::ServerError("NetworkService extension missing".to_string()))?;
+
+    let connected_peers: Vec<String> = network
+        .connected_peer_set()
+        .iter()
+        .map(PeerId::to_string)
+        .collect();
+
+    Ok(success_response(Body::from(
+        serde_json::to_string(&connected_peers).map_err(|e| {
+            ApiError::ServerError(format!("Unable to serialize Vec<PeerId>: {:?}", e))
+        })?,
+    )))
+}