mirror of
https://github.com/sigp/lighthouse.git
synced 2026-03-10 04:01:51 +00:00
b771bbb60c
* Start implementing proto_array
* Add progress
* Add unfinished progress
* Add further progress
* Add progress
* Add tree filtering
* Add half-finished modifications
* Add refactored version
* Tidy, add incomplete LmdGhost impl
* Move impls in LmdGhost trait def
* Remove old reduced_tree fork choice
* Combine two functions in to `compute_deltas`
* Start testing
* Add more compute_deltas tests
* Add fork choice testing
* Add more fork choice testing
* Add more fork choice tests
* Add more testing to proto-array
* Remove old tests
* Modify tests
* Add more tests
* Add more testing
* Add comments and fixes
* Re-organise crate
* Tidy, finish pruning tests
* Add ssz encoding, other pub fns
* Rename lmd_ghost > proto_array_fork_choice
* Integrate proto_array into lighthouse
* Add first pass at fixing filter
* Clean out old comments
* Add more comments
* Attempt to fix prune error
* Adjust TODO
* Fix test compile errors
* Add extra justification change check
* Update cargo.lock
* Fix fork choice test compile errors
* Most remove ffg_update_required
* Fix bug with epoch of attestation votes
* Start adding new test format
* Make fork choice tests declarative
* Create test def concept
* Move test defs into crate
* Add binary, re-org crate
* Shuffle files
* Start adding ffg tests
* Add more fork choice tests
* Add fork choice JSON dumping
* Add more detail to best node error
* Ensure fin+just checkpoints from from same block
* Rename JustificationManager
* Move checkpoint manager into own file
* Tidy
* Add targetted logging for sneaky sync bug
* Fix justified balances bug
* Add cache metrics
* Add metrics for log levels
* Fix bug in checkpoint manager
* Fix compile error in fork choice tests
* Ignore duplicate blocks in fork choice
* Add block to fock choice before db
* Rename on_new_block fn
* Fix spec inconsistency in `CheckpointManager`
* Remove BlockRootTree
* Remove old reduced_tree code fragment
* Add API endpoint for fork choice
* Add more ffg tests
* Remove block_root_tree reminents
* Ensure effective balances are used
* Remove old debugging code, fix API fault
* Add check to ensure parent block is in fork choice
* Update readme dates
* Fix readme
* Tidy checkpoint manager
* Remove fork choice yaml files from repo
* Remove fork choice yaml from repo
* General tidy
* Address majority of Michael's comments
* Tidy bin/lib business
* Remove dangling file
* Undo changes for rpc/handler from master
* Revert "Undo changes for rpc/handler from master"
This reverts commit 876edff0e4.
Co-authored-by: Age Manning <Age@AgeManning.com>
146 lines
4.2 KiB
Rust
146 lines
4.2 KiB
Rust
#[macro_use]
|
|
mod macros;
|
|
#[macro_use]
|
|
extern crate lazy_static;
|
|
extern crate network as client_network;
|
|
|
|
mod advanced;
|
|
mod beacon;
|
|
pub mod config;
|
|
mod consensus;
|
|
mod error;
|
|
mod helpers;
|
|
mod metrics;
|
|
mod network;
|
|
mod node;
|
|
mod response_builder;
|
|
mod router;
|
|
mod spec;
|
|
mod url_query;
|
|
mod validator;
|
|
|
|
use beacon_chain::{BeaconChain, BeaconChainTypes};
|
|
use client_network::NetworkMessage;
|
|
use client_network::Service as NetworkService;
|
|
pub use config::ApiEncodingFormat;
|
|
use error::{ApiError, ApiResult};
|
|
use eth2_config::Eth2Config;
|
|
use hyper::rt::Future;
|
|
use hyper::server::conn::AddrStream;
|
|
use hyper::service::{make_service_fn, service_fn};
|
|
use hyper::{Body, Request, Response, Server};
|
|
use parking_lot::RwLock;
|
|
use slog::{info, warn};
|
|
use std::net::SocketAddr;
|
|
use std::ops::Deref;
|
|
use std::path::PathBuf;
|
|
use std::sync::Arc;
|
|
use tokio::runtime::TaskExecutor;
|
|
use tokio::sync::mpsc;
|
|
use url_query::UrlQuery;
|
|
|
|
pub use crate::helpers::parse_pubkey_bytes;
|
|
pub use beacon::{
|
|
BlockResponse, CanonicalHeadResponse, Committee, HeadBeaconBlock, StateResponse,
|
|
ValidatorRequest, ValidatorResponse,
|
|
};
|
|
pub use config::Config;
|
|
pub use validator::{ValidatorDutiesRequest, ValidatorDuty};
|
|
|
|
pub type BoxFut = Box<dyn Future<Item = Response<Body>, Error = ApiError> + Send>;
|
|
pub type NetworkChannel = Arc<RwLock<mpsc::UnboundedSender<NetworkMessage>>>;
|
|
|
|
pub struct NetworkInfo<T: BeaconChainTypes> {
|
|
pub network_service: Arc<NetworkService<T>>,
|
|
pub network_chan: mpsc::UnboundedSender<NetworkMessage>,
|
|
}
|
|
|
|
// Allowing more than 7 arguments.
|
|
#[allow(clippy::too_many_arguments)]
|
|
pub fn start_server<T: BeaconChainTypes>(
|
|
config: &Config,
|
|
executor: &TaskExecutor,
|
|
beacon_chain: Arc<BeaconChain<T>>,
|
|
network_info: NetworkInfo<T>,
|
|
db_path: PathBuf,
|
|
freezer_db_path: PathBuf,
|
|
eth2_config: Eth2Config,
|
|
log: slog::Logger,
|
|
) -> Result<(exit_future::Signal, SocketAddr), hyper::Error> {
|
|
let inner_log = log.clone();
|
|
let eth2_config = Arc::new(eth2_config);
|
|
|
|
// Define the function that will build the request handler.
|
|
let make_service = make_service_fn(move |_socket: &AddrStream| {
|
|
let beacon_chain = beacon_chain.clone();
|
|
let log = inner_log.clone();
|
|
let eth2_config = eth2_config.clone();
|
|
let network_service = network_info.network_service.clone();
|
|
let network_channel = Arc::new(RwLock::new(network_info.network_chan.clone()));
|
|
let db_path = db_path.clone();
|
|
let freezer_db_path = freezer_db_path.clone();
|
|
|
|
service_fn(move |req: Request<Body>| {
|
|
router::route(
|
|
req,
|
|
beacon_chain.clone(),
|
|
network_service.clone(),
|
|
network_channel.clone(),
|
|
eth2_config.clone(),
|
|
log.clone(),
|
|
db_path.clone(),
|
|
freezer_db_path.clone(),
|
|
)
|
|
})
|
|
});
|
|
|
|
let bind_addr = (config.listen_address, config.port).into();
|
|
let server = Server::bind(&bind_addr).serve(make_service);
|
|
|
|
// Determine the address the server is actually listening on.
|
|
//
|
|
// This may be different to `bind_addr` if bind port was 0 (this allows the OS to choose a free
|
|
// port).
|
|
let actual_listen_addr = server.local_addr();
|
|
|
|
// Build a channel to kill the HTTP server.
|
|
let (exit_signal, exit) = exit_future::signal();
|
|
let inner_log = log.clone();
|
|
let server_exit = exit.and_then(move |_| {
|
|
info!(inner_log, "HTTP service shutdown");
|
|
Ok(())
|
|
});
|
|
// Configure the `hyper` server to gracefully shutdown when the shutdown channel is triggered.
|
|
let inner_log = log.clone();
|
|
let server_future = server
|
|
.with_graceful_shutdown(server_exit)
|
|
.map_err(move |e| {
|
|
warn!(
|
|
inner_log,
|
|
"HTTP server failed to start, Unable to bind"; "address" => format!("{:?}", e)
|
|
)
|
|
});
|
|
|
|
info!(
|
|
log,
|
|
"HTTP API started";
|
|
"address" => format!("{}", actual_listen_addr.ip()),
|
|
"port" => actual_listen_addr.port(),
|
|
);
|
|
|
|
executor.spawn(server_future);
|
|
|
|
Ok((exit_signal, actual_listen_addr))
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub struct DBPath(PathBuf);
|
|
|
|
impl Deref for DBPath {
|
|
type Target = PathBuf;
|
|
|
|
fn deref(&self) -> &Self::Target {
|
|
&self.0
|
|
}
|
|
}
|