Remove old http_server crate

Cargo.toml

@@ -26,7 +26,6 @@ members = [
 	"beacon_node",
 	"beacon_node/store",
 	"beacon_node/client",
-	"beacon_node/http_server",
 	"beacon_node/rest_api",
 	"beacon_node/network",
 	"beacon_node/eth2-libp2p",

beacon_node/client/Cargo.toml

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

beacon_node/client/src/config.rs

@@ -1,6 +1,5 @@
 use crate::Eth2Config;
 use clap::ArgMatches;
-use http_server::HttpServerConfig;
 use network::NetworkConfig;
 use serde_derive::{Deserialize, Serialize};
 use slog::{info, o, Drain};
@@ -25,7 +24,6 @@ pub struct Config {
     pub genesis_state: GenesisState,
     pub network: network::NetworkConfig,
     pub rpc: rpc::RPCConfig,
-    pub http: HttpServerConfig,
     pub rest_api: rest_api::ApiConfig,
 }
 
@@ -59,7 +57,6 @@ impl Default for Config {
             db_name: "chain_db".to_string(),
             network: NetworkConfig::new(),
             rpc: rpc::RPCConfig::default(),
-            http: HttpServerConfig::default(),
             rest_api: rest_api::ApiConfig::default(),
             spec_constants: TESTNET_SPEC_CONSTANTS.into(),
             genesis_state: GenesisState::RecentGenesis {
@@ -143,7 +140,6 @@ impl Config {
 
         self.network.apply_cli_args(args)?;
         self.rpc.apply_cli_args(args)?;
-        self.http.apply_cli_args(args)?;
         self.rest_api.apply_cli_args(args)?;
 
         if let Some(log_file) = args.value_of("logfile") {

beacon_node/client/src/lib.rs

@@ -10,7 +10,6 @@ use beacon_chain::BeaconChain;
 use exit_future::Signal;
 use futures::{future::Future, Stream};
 use network::Service as NetworkService;
-use prometheus::Registry;
 use slog::{error, info, o};
 use slot_clock::SlotClock;
 use std::marker::PhantomData;
@@ -36,8 +35,6 @@ pub struct Client<T: BeaconChainTypes> {
     pub network: Arc<NetworkService<T>>,
     /// Signal to terminate the RPC server.
     pub rpc_exit_signal: Option<Signal>,
-    /// Signal to terminate the HTTP server.
-    pub http_exit_signal: Option<Signal>,
     /// Signal to terminate the slot timer.
     pub slot_timer_exit_signal: Option<Signal>,
     /// Signal to terminate the API
@@ -60,7 +57,6 @@ where
         log: slog::Logger,
         executor: &TaskExecutor,
     ) -> error::Result<Self> {
-        let metrics_registry = Registry::new();
         let store = Arc::new(store);
         let seconds_per_slot = eth2_config.spec.seconds_per_slot;
 
@@ -119,23 +115,6 @@ where
             None
         };
 
-        // Start the `http_server` service.
-        //
-        // Note: presently we are ignoring the config and _always_ starting a HTTP server.
-        let http_exit_signal = if client_config.http.enabled {
-            Some(http_server::start_service(
-                &client_config.http,
-                executor,
-                network_send,
-                beacon_chain.clone(),
-                client_config.db_path().expect("unable to read datadir"),
-                metrics_registry,
-                &log,
-            ))
-        } else {
-            None
-        };
-
         // Start the `rest_api` service
         let api_exit_signal = if client_config.rest_api.enabled {
             match rest_api::start_server(
@@ -184,7 +163,6 @@ where
         Ok(Client {
             _client_config: client_config,
             beacon_chain,
-            http_exit_signal,
             rpc_exit_signal,
             slot_timer_exit_signal: Some(slot_timer_exit_signal),
             api_exit_signal,

beacon_node/http_server/Cargo.toml

@@ -1,23 +0,0 @@
-[package]
-name = "http_server"
-version = "0.1.0"
-authors = ["Paul Hauner <paul@paulhauner.com>"]
-edition = "2018"
-
-[dependencies]
-beacon_chain = { path = "../beacon_chain" }
-iron = "^0.6"
-router = "^0.6"
-network = { path = "../network" }
-types = { path = "../../eth2/types" }
-slot_clock = { path = "../../eth2/utils/slot_clock" }
-persistent = "^0.4"
-prometheus = { version = "^0.6", features = ["process"] }
-clap = "2.32.0"
-futures = "0.1.23"
-serde = "1.0"
-serde_derive = "1.0"
-serde_json = "1.0"
-slog = { version = "^2.2.3" , features = ["max_level_trace"] }
-tokio = "0.1.17"
-exit-future = "0.1.4"

beacon_node/http_server/src/api.rs

@@ -1,71 +0,0 @@
-use crate::{key::BeaconChainKey, map_persistent_err_to_500};
-use beacon_chain::{BeaconChain, BeaconChainTypes};
-use iron::prelude::*;
-use iron::{
-    headers::{CacheControl, CacheDirective, ContentType},
-    status::Status,
-    AfterMiddleware, Handler, IronResult, Request, Response,
-};
-use persistent::Read;
-use router::Router;
-use serde_json::json;
-use std::sync::Arc;
-
-/// Yields a handler for the HTTP API.
-pub fn build_handler<T: BeaconChainTypes + 'static>(
-    beacon_chain: Arc<BeaconChain<T>>,
-) -> impl Handler {
-    let mut router = Router::new();
-
-    router.get("/node/fork", handle_fork::<T>, "fork");
-
-    let mut chain = Chain::new(router);
-
-    // Insert `BeaconChain` so it may be accessed in a request.
-    chain.link(Read::<BeaconChainKey<T>>::both(beacon_chain.clone()));
-    // Set the content-type headers.
-    chain.link_after(SetJsonContentType);
-    // Set the cache headers.
-    chain.link_after(SetCacheDirectives);
-
-    chain
-}
-
-/// Sets the `cache-control` headers on _all_ responses, unless they are already set.
-struct SetCacheDirectives;
-impl AfterMiddleware for SetCacheDirectives {
-    fn after(&self, _req: &mut Request, mut resp: Response) -> IronResult<Response> {
-        // This is run for every requests, AFTER all handlers have been executed
-        if resp.headers.get::<CacheControl>() == None {
-            resp.headers.set(CacheControl(vec![
-                CacheDirective::NoCache,
-                CacheDirective::NoStore,
-            ]));
-        }
-        Ok(resp)
-    }
-}
-
-/// Sets the `content-type` headers on _all_ responses, unless they are already set.
-struct SetJsonContentType;
-impl AfterMiddleware for SetJsonContentType {
-    fn after(&self, _req: &mut Request, mut resp: Response) -> IronResult<Response> {
-        if resp.headers.get::<ContentType>() == None {
-            resp.headers.set(ContentType::json());
-        }
-        Ok(resp)
-    }
-}
-
-fn handle_fork<T: BeaconChainTypes + 'static>(req: &mut Request) -> IronResult<Response> {
-    let beacon_chain = req
-        .get::<Read<BeaconChainKey<T>>>()
-        .map_err(map_persistent_err_to_500)?;
-
-    let response = json!({
-        "fork": beacon_chain.head().beacon_state.fork,
-        "network_id": beacon_chain.spec.network_id
-    });
-
-    Ok(Response::with((Status::Ok, response.to_string())))
-}

beacon_node/http_server/src/key.rs

@@ -1,33 +0,0 @@
-use crate::metrics::LocalMetrics;
-use beacon_chain::{BeaconChain, BeaconChainTypes};
-use iron::typemap::Key;
-use prometheus::Registry;
-use std::marker::PhantomData;
-use std::path::PathBuf;
-use std::sync::Arc;
-
-pub struct BeaconChainKey<T> {
-    _phantom: PhantomData<T>,
-}
-
-impl<T: BeaconChainTypes + 'static> Key for BeaconChainKey<T> {
-    type Value = Arc<BeaconChain<T>>;
-}
-
-pub struct MetricsRegistryKey;
-
-impl Key for MetricsRegistryKey {
-    type Value = Registry;
-}
-
-pub struct LocalMetricsKey;
-
-impl Key for LocalMetricsKey {
-    type Value = LocalMetrics;
-}
-
-pub struct DBPathKey;
-
-impl Key for DBPathKey {
-    type Value = PathBuf;
-}

beacon_node/http_server/src/lib.rs

@@ -1,145 +0,0 @@
-mod api;
-mod key;
-mod metrics;
-
-use beacon_chain::{BeaconChain, BeaconChainTypes};
-use clap::ArgMatches;
-use futures::Future;
-use iron::prelude::*;
-use network::NetworkMessage;
-use prometheus::Registry;
-use router::Router;
-use serde_derive::{Deserialize, Serialize};
-use slog::{info, o, warn};
-use std::path::PathBuf;
-use std::sync::Arc;
-use tokio::runtime::TaskExecutor;
-use tokio::sync::mpsc;
-
-#[derive(PartialEq, Clone, Debug, Serialize, Deserialize)]
-pub struct HttpServerConfig {
-    pub enabled: bool,
-    pub listen_address: String,
-    pub listen_port: String,
-}
-
-impl Default for HttpServerConfig {
-    fn default() -> Self {
-        Self {
-            enabled: false,
-            listen_address: "127.0.0.1".to_string(),
-            listen_port: "5052".to_string(),
-        }
-    }
-}
-
-impl HttpServerConfig {
-    pub fn apply_cli_args(&mut self, args: &ArgMatches) -> Result<(), &'static str> {
-        if args.is_present("http") {
-            self.enabled = true;
-        }
-
-        if let Some(listen_address) = args.value_of("http-address") {
-            self.listen_address = listen_address.to_string();
-        }
-
-        if let Some(listen_port) = args.value_of("http-port") {
-            self.listen_port = listen_port.to_string();
-        }
-
-        Ok(())
-    }
-}
-
-/// Build the `iron` HTTP server, defining the core routes.
-pub fn create_iron_http_server<T: BeaconChainTypes + 'static>(
-    beacon_chain: Arc<BeaconChain<T>>,
-    db_path: PathBuf,
-    metrics_registry: Registry,
-) -> Iron<Router> {
-    let mut router = Router::new();
-
-    // A `GET` request to `/metrics` is handled by the `metrics` module.
-    router.get(
-        "/metrics",
-        metrics::build_handler(beacon_chain.clone(), db_path, metrics_registry),
-        "metrics",
-    );
-
-    // Any request to all other endpoints is handled by the `api` module.
-    router.any("/*", api::build_handler(beacon_chain.clone()), "api");
-
-    Iron::new(router)
-}
-
-/// Start the HTTP service on the tokio `TaskExecutor`.
-pub fn start_service<T: BeaconChainTypes + 'static>(
-    config: &HttpServerConfig,
-    executor: &TaskExecutor,
-    _network_chan: mpsc::UnboundedSender<NetworkMessage>,
-    beacon_chain: Arc<BeaconChain<T>>,
-    db_path: PathBuf,
-    metrics_registry: Registry,
-    log: &slog::Logger,
-) -> exit_future::Signal {
-    let log = log.new(o!("Service"=>"HTTP"));
-
-    // Create:
-    //  - `shutdown_trigger` a one-shot to shut down this service.
-    //  - `wait_for_shutdown` a future that will wait until someone calls shutdown.
-    let (shutdown_trigger, wait_for_shutdown) = exit_future::signal();
-
-    // Create an `iron` http, without starting it yet.
-    let iron = create_iron_http_server(beacon_chain, db_path, metrics_registry);
-
-    // Create a HTTP server future.
-    //
-    // 1. Start the HTTP server
-    // 2. Build an exit future that will shutdown the server when requested.
-    // 3. Return the exit future, so the caller may shutdown the service when desired.
-    let http_service = {
-        let listen_address = format!("{}:{}", config.listen_address, config.listen_port);
-        // Start the HTTP server
-        let server_start_result = iron.http(listen_address.clone());
-
-        if server_start_result.is_ok() {
-            info!(log, "HTTP server running on {}", listen_address);
-        } else {
-            warn!(log, "HTTP server failed to start on {}", listen_address);
-        }
-
-        // Build a future that will shutdown the HTTP server when the `shutdown_trigger` is
-        // triggered.
-        wait_for_shutdown.and_then(move |_| {
-            info!(log, "HTTP server shutting down");
-
-            if let Ok(mut server) = server_start_result {
-                // According to the documentation, `server.close()` "doesn't work" and the server
-                // keeps listening.
-                //
-                // It is being called anyway, because it seems like the right thing to do. If you
-                // know this has negative side-effects, please create an issue to discuss.
-                //
-                // See: https://docs.rs/iron/0.6.0/iron/struct.Listening.html#impl
-                match server.close() {
-                    _ => (),
-                };
-            }
-            info!(log, "HTTP server shutdown complete.");
-            Ok(())
-        })
-    };
-
-    // Attach the HTTP server to the executor.
-    executor.spawn(http_service);
-
-    shutdown_trigger
-}
-
-/// Helper function for mapping a failure to read state to a 500 server error.
-fn map_persistent_err_to_500(e: persistent::PersistentError) -> iron::error::IronError {
-    iron::error::IronError {
-        error: Box::new(e),
-        response: iron::Response::with(iron::status::Status::InternalServerError),
-    }
-}

beacon_node/http_server/src/metrics.rs

@@ -1,72 +0,0 @@
-use crate::{
-    key::{BeaconChainKey, DBPathKey, LocalMetricsKey, MetricsRegistryKey},
-    map_persistent_err_to_500,
-};
-use beacon_chain::{BeaconChain, BeaconChainTypes};
-use iron::prelude::*;
-use iron::{status::Status, Handler, IronResult, Request, Response};
-use persistent::Read;
-use prometheus::{Encoder, Registry, TextEncoder};
-use std::path::PathBuf;
-use std::sync::Arc;
-
-pub use local_metrics::LocalMetrics;
-
-mod local_metrics;
-
-/// Yields a handler for the metrics endpoint.
-pub fn build_handler<T: BeaconChainTypes + 'static>(
-    beacon_chain: Arc<BeaconChain<T>>,
-    db_path: PathBuf,
-    metrics_registry: Registry,
-) -> impl Handler {
-    let mut chain = Chain::new(handle_metrics::<T>);
-
-    let local_metrics = LocalMetrics::new().unwrap();
-    local_metrics.register(&metrics_registry).unwrap();
-
-    chain.link(Read::<BeaconChainKey<T>>::both(beacon_chain));
-    chain.link(Read::<MetricsRegistryKey>::both(metrics_registry));
-    chain.link(Read::<LocalMetricsKey>::both(local_metrics));
-    chain.link(Read::<DBPathKey>::both(db_path));
-
-    chain
-}
-
-/// Handle a request for Prometheus metrics.
-///
-/// Returns a text string containing all metrics.
-fn handle_metrics<T: BeaconChainTypes + 'static>(req: &mut Request) -> IronResult<Response> {
-    let beacon_chain = req
-        .get::<Read<BeaconChainKey<T>>>()
-        .map_err(map_persistent_err_to_500)?;
-
-    let r = req
-        .get::<Read<MetricsRegistryKey>>()
-        .map_err(map_persistent_err_to_500)?;
-
-    let local_metrics = req
-        .get::<Read<LocalMetricsKey>>()
-        .map_err(map_persistent_err_to_500)?;
-
-    let db_path = req
-        .get::<Read<DBPathKey>>()
-        .map_err(map_persistent_err_to_500)?;
-
-    // Update metrics that are calculated on each scrape.
-    local_metrics.update(&beacon_chain, &db_path);
-
-    let mut buffer = vec![];
-    let encoder = TextEncoder::new();
-
-    // Gather `DEFAULT_REGISTRY` metrics.
-    encoder.encode(&prometheus::gather(), &mut buffer).unwrap();
-
-    // Gather metrics from our registry.
-    let metric_families = r.gather();
-    encoder.encode(&metric_families, &mut buffer).unwrap();
-
-    let prom_string = String::from_utf8(buffer).unwrap();
-
-    Ok(Response::with((Status::Ok, prom_string)))
-}

beacon_node/http_server/src/metrics/local_metrics.rs

@@ -1,154 +0,0 @@
-use beacon_chain::{BeaconChain, BeaconChainTypes};
-use prometheus::{IntGauge, Opts, Registry};
-use slot_clock::SlotClock;
-use std::fs;
-use std::path::PathBuf;
-use types::{EthSpec, Slot};
-
-// If set to `true` will iterate and sum the balances of all validators in the state for each
-// scrape.
-const SHOULD_SUM_VALIDATOR_BALANCES: bool = true;
-
-pub struct LocalMetrics {
-    present_slot: IntGauge,
-    present_epoch: IntGauge,
-    best_slot: IntGauge,
-    best_beacon_block_root: IntGauge,
-    justified_beacon_block_root: IntGauge,
-    finalized_beacon_block_root: IntGauge,
-    validator_count: IntGauge,
-    justified_epoch: IntGauge,
-    finalized_epoch: IntGauge,
-    validator_balances_sum: IntGauge,
-    database_size: IntGauge,
-}
-
-impl LocalMetrics {
-    /// Create a new instance.
-    pub fn new() -> Result<Self, prometheus::Error> {
-        Ok(Self {
-            present_slot: {
-                let opts = Opts::new("present_slot", "slot_at_time_of_scrape");
-                IntGauge::with_opts(opts)?
-            },
-            present_epoch: {
-                let opts = Opts::new("present_epoch", "epoch_at_time_of_scrape");
-                IntGauge::with_opts(opts)?
-            },
-            best_slot: {
-                let opts = Opts::new("best_slot", "slot_of_block_at_chain_head");
-                IntGauge::with_opts(opts)?
-            },
-            best_beacon_block_root: {
-                let opts = Opts::new("best_beacon_block_root", "root_of_block_at_chain_head");
-                IntGauge::with_opts(opts)?
-            },
-            justified_beacon_block_root: {
-                let opts = Opts::new(
-                    "justified_beacon_block_root",
-                    "root_of_block_at_justified_head",
-                );
-                IntGauge::with_opts(opts)?
-            },
-            finalized_beacon_block_root: {
-                let opts = Opts::new(
-                    "finalized_beacon_block_root",
-                    "root_of_block_at_finalized_head",
-                );
-                IntGauge::with_opts(opts)?
-            },
-            validator_count: {
-                let opts = Opts::new("validator_count", "number_of_validators");
-                IntGauge::with_opts(opts)?
-            },
-            justified_epoch: {
-                let opts = Opts::new("justified_epoch", "state_justified_epoch");
-                IntGauge::with_opts(opts)?
-            },
-            finalized_epoch: {
-                let opts = Opts::new("finalized_epoch", "state_finalized_epoch");
-                IntGauge::with_opts(opts)?
-            },
-            validator_balances_sum: {
-                let opts = Opts::new("validator_balances_sum", "sum_of_all_validator_balances");
-                IntGauge::with_opts(opts)?
-            },
-            database_size: {
-                let opts = Opts::new("database_size", "size_of_on_disk_db_in_mb");
-                IntGauge::with_opts(opts)?
-            },
-        })
-    }
-
-    /// Registry this instance with the `registry`.
-    pub fn register(&self, registry: &Registry) -> Result<(), prometheus::Error> {
-        registry.register(Box::new(self.present_slot.clone()))?;
-        registry.register(Box::new(self.present_epoch.clone()))?;
-        registry.register(Box::new(self.best_slot.clone()))?;
-        registry.register(Box::new(self.best_beacon_block_root.clone()))?;
-        registry.register(Box::new(self.justified_beacon_block_root.clone()))?;
-        registry.register(Box::new(self.finalized_beacon_block_root.clone()))?;
-        registry.register(Box::new(self.validator_count.clone()))?;
-        registry.register(Box::new(self.finalized_epoch.clone()))?;
-        registry.register(Box::new(self.justified_epoch.clone()))?;
-        registry.register(Box::new(self.validator_balances_sum.clone()))?;
-        registry.register(Box::new(self.database_size.clone()))?;
-
-        Ok(())
-    }
-
-    /// Update the metrics in `self` to the latest values.
-    pub fn update<T: BeaconChainTypes>(&self, beacon_chain: &BeaconChain<T>, db_path: &PathBuf) {
-        let state = &beacon_chain.head().beacon_state;
-
-        let present_slot = beacon_chain
-            .slot_clock
-            .present_slot()
-            .unwrap_or_else(|_| None)
-            .unwrap_or_else(|| Slot::new(0));
-        self.present_slot.set(present_slot.as_u64() as i64);
-        self.present_epoch
-            .set(present_slot.epoch(T::EthSpec::slots_per_epoch()).as_u64() as i64);
-
-        self.best_slot.set(state.slot.as_u64() as i64);
-        self.best_beacon_block_root
-            .set(beacon_chain.head().beacon_block_root.to_low_u64_le() as i64);
-        self.justified_beacon_block_root.set(
-            beacon_chain
-                .head()
-                .beacon_state
-                .current_justified_checkpoint
-                .root
-                .to_low_u64_le() as i64,
-        );
-        self.finalized_beacon_block_root.set(
-            beacon_chain
-                .head()
-                .beacon_state
-                .finalized_checkpoint
-                .root
-                .to_low_u64_le() as i64,
-        );
-        self.validator_count.set(state.validators.len() as i64);
-        self.justified_epoch
-            .set(state.current_justified_checkpoint.epoch.as_u64() as i64);
-        self.finalized_epoch
-            .set(state.finalized_checkpoint.epoch.as_u64() as i64);
-        if SHOULD_SUM_VALIDATOR_BALANCES {
-            self.validator_balances_sum
-                .set(state.balances.iter().sum::<u64>() as i64);
-        }
-        let db_size = if let Ok(iter) = fs::read_dir(db_path) {
-            iter.filter_map(Result::ok)
-                .map(size_of_dir_entry)
-                .fold(0_u64, |sum, val| sum + val)
-        } else {
-            0
-        };
-        self.database_size.set(db_size as i64);
-    }
-}
-
-fn size_of_dir_entry(dir: fs::DirEntry) -> u64 {
-    dir.metadata().map(|m| m.len()).unwrap_or(0)
-}

beacon_node/rest_api/src/config.rs

@@ -18,7 +18,7 @@ impl Default for Config {
         Config {
             enabled: true, // rest_api enabled by default
             listen_address: Ipv4Addr::new(127, 0, 0, 1),
-            port: 1248,
+            port: 5052,
         }
     }
 }

docs/config_examples/beacon-node.toml

@@ -78,14 +78,6 @@ enabled = false
 listen_address = "127.0.0.1"
 port = 5051
 
-#
-# Legacy HTTP server configuration. To be removed.
-#
-[http]
-enabled = false
-listen_address = "127.0.0.1"
-listen_port = "5052"
-
 #
 # RESTful HTTP API server configuration.
 #
@@ -95,4 +87,4 @@ enabled = true
 # The listen port for the HTTP server.
 listen_address = "127.0.0.1"
 # The listen port for the HTTP server.
-port = 1248
+port = 5052