262 lines
8.6 KiB
Rust
262 lines
8.6 KiB
Rust
use bincode;
|
|
use bls::Keypair;
|
|
use clap::ArgMatches;
|
|
use serde_derive::{Deserialize, Serialize};
|
|
use slog::{error, info, o, warn, Drain};
|
|
use std::fs::{self, File, OpenOptions};
|
|
use std::io::{Error, ErrorKind};
|
|
use std::ops::Range;
|
|
use std::path::PathBuf;
|
|
use std::sync::Mutex;
|
|
use types::{test_utils::generate_deterministic_keypair, EthSpec, MainnetEthSpec};
|
|
|
|
pub const DEFAULT_SERVER: &str = "localhost";
|
|
pub const DEFAULT_SERVER_GRPC_PORT: &str = "5051";
|
|
pub const DEFAULT_SERVER_HTTP_PORT: &str = "5052";
|
|
|
|
#[derive(Clone)]
|
|
pub enum KeySource {
|
|
/// Load the keypairs from disk.
|
|
Disk,
|
|
/// Generate the keypairs (insecure, generates predictable keys).
|
|
TestingKeypairRange(Range<usize>),
|
|
}
|
|
|
|
impl Default for KeySource {
|
|
fn default() -> Self {
|
|
KeySource::Disk
|
|
}
|
|
}
|
|
|
|
/// Stores the core configuration for this validator instance.
|
|
#[derive(Clone, Serialize, Deserialize)]
|
|
pub struct Config {
|
|
/// The data directory, which stores all validator databases
|
|
pub data_dir: PathBuf,
|
|
/// The source for loading keypairs
|
|
#[serde(skip)]
|
|
pub key_source: KeySource,
|
|
/// The path where the logs will be outputted
|
|
pub log_file: PathBuf,
|
|
/// The server at which the Beacon Node can be contacted
|
|
pub server: String,
|
|
/// The gRPC port on the server
|
|
pub server_grpc_port: u16,
|
|
/// The HTTP port on the server, for the REST API.
|
|
pub server_http_port: u16,
|
|
/// The number of slots per epoch.
|
|
pub slots_per_epoch: u64,
|
|
}
|
|
|
|
const DEFAULT_PRIVATE_KEY_FILENAME: &str = "private.key";
|
|
|
|
impl Default for Config {
|
|
/// Build a new configuration from defaults.
|
|
fn default() -> Self {
|
|
Self {
|
|
data_dir: PathBuf::from(".lighthouse-validator"),
|
|
key_source: <_>::default(),
|
|
log_file: PathBuf::from(""),
|
|
server: DEFAULT_SERVER.into(),
|
|
server_grpc_port: DEFAULT_SERVER_GRPC_PORT
|
|
.parse::<u16>()
|
|
.expect("gRPC port constant should be valid"),
|
|
server_http_port: DEFAULT_SERVER_GRPC_PORT
|
|
.parse::<u16>()
|
|
.expect("HTTP port constant should be valid"),
|
|
slots_per_epoch: MainnetEthSpec::slots_per_epoch(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Config {
|
|
/// Returns the full path for the client data directory (not just the name of the directory).
|
|
pub fn full_data_dir(&self) -> Option<PathBuf> {
|
|
dirs::home_dir().map(|path| path.join(&self.data_dir))
|
|
}
|
|
|
|
/// Creates the data directory (and any non-existing parent directories).
|
|
pub fn create_data_dir(&self) -> Option<PathBuf> {
|
|
let path = dirs::home_dir()?.join(&self.data_dir);
|
|
fs::create_dir_all(&path).ok()?;
|
|
Some(path)
|
|
}
|
|
|
|
/// Apply the following arguments to `self`, replacing values if they are specified in `args`.
|
|
///
|
|
/// Returns an error if arguments are obviously invalid. May succeed even if some values are
|
|
/// invalid.
|
|
pub fn apply_cli_args(
|
|
&mut self,
|
|
args: &ArgMatches,
|
|
log: &mut slog::Logger,
|
|
) -> Result<(), &'static str> {
|
|
if let Some(datadir) = args.value_of("datadir") {
|
|
self.data_dir = PathBuf::from(datadir);
|
|
};
|
|
|
|
if let Some(log_file) = args.value_of("logfile") {
|
|
self.log_file = PathBuf::from(log_file);
|
|
self.update_logger(log)?;
|
|
};
|
|
|
|
if let Some(srv) = args.value_of("server") {
|
|
self.server = srv.to_string();
|
|
};
|
|
|
|
Ok(())
|
|
}
|
|
|
|
// Update the logger to output in JSON to specified file
|
|
fn update_logger(&mut self, log: &mut slog::Logger) -> Result<(), &'static str> {
|
|
let file = OpenOptions::new()
|
|
.create(true)
|
|
.write(true)
|
|
.truncate(true)
|
|
.open(&self.log_file);
|
|
|
|
if file.is_err() {
|
|
return Err("Cannot open log file");
|
|
}
|
|
let file = file.unwrap();
|
|
|
|
if let Some(file) = self.log_file.to_str() {
|
|
info!(
|
|
*log,
|
|
"Log file specified, output will now be written to {} in json.", file
|
|
);
|
|
} else {
|
|
info!(
|
|
*log,
|
|
"Log file specified output will now be written in json"
|
|
);
|
|
}
|
|
|
|
let drain = Mutex::new(slog_json::Json::default(file)).fuse();
|
|
let drain = slog_async::Async::new(drain).build().fuse();
|
|
*log = slog::Logger::root(drain, o!());
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Reads a single keypair from the given `path`.
|
|
///
|
|
/// `path` should be the path to a directory containing a private key. The file name of `path`
|
|
/// must align with the public key loaded from it, otherwise an error is returned.
|
|
///
|
|
/// An error will be returned if `path` is a file (not a directory).
|
|
fn read_keypair_file(&self, path: PathBuf) -> Result<Keypair, String> {
|
|
if !path.is_dir() {
|
|
return Err("Is not a directory".into());
|
|
}
|
|
|
|
let key_filename: PathBuf = path.join(DEFAULT_PRIVATE_KEY_FILENAME);
|
|
|
|
if !key_filename.is_file() {
|
|
return Err(format!(
|
|
"Private key is not a file: {:?}",
|
|
key_filename.to_str()
|
|
));
|
|
}
|
|
|
|
let mut key_file = File::open(key_filename.clone())
|
|
.map_err(|e| format!("Unable to open private key file: {}", e))?;
|
|
|
|
let key: Keypair = bincode::deserialize_from(&mut key_file)
|
|
.map_err(|e| format!("Unable to deserialize private key: {:?}", e))?;
|
|
|
|
let ki = key.identifier();
|
|
if &ki
|
|
!= &path
|
|
.file_name()
|
|
.ok_or_else(|| "Invalid path".to_string())?
|
|
.to_string_lossy()
|
|
{
|
|
return Err(format!(
|
|
"The validator key ({:?}) did not match the directory filename {:?}.",
|
|
ki,
|
|
path.to_str()
|
|
));
|
|
} else {
|
|
Ok(key)
|
|
}
|
|
}
|
|
|
|
pub fn fetch_keys_from_disk(&self, log: &slog::Logger) -> Result<Vec<Keypair>, String> {
|
|
Ok(
|
|
fs::read_dir(&self.full_data_dir().expect("Data dir must exist"))
|
|
.map_err(|e| format!("Failed to read datadir: {:?}", e))?
|
|
.filter_map(|validator_dir| {
|
|
let path = validator_dir.ok()?.path();
|
|
|
|
if path.is_dir() {
|
|
match self.read_keypair_file(path.clone()) {
|
|
Ok(keypair) => Some(keypair),
|
|
Err(e) => {
|
|
error!(
|
|
log,
|
|
"Failed to parse a validator keypair";
|
|
"error" => e,
|
|
"path" => path.to_str(),
|
|
);
|
|
None
|
|
}
|
|
}
|
|
} else {
|
|
None
|
|
}
|
|
})
|
|
.collect(),
|
|
)
|
|
}
|
|
|
|
pub fn fetch_testing_keypairs(
|
|
&self,
|
|
range: std::ops::Range<usize>,
|
|
) -> Result<Vec<Keypair>, String> {
|
|
Ok(range
|
|
.into_iter()
|
|
.map(generate_deterministic_keypair)
|
|
.collect())
|
|
}
|
|
|
|
/// Loads the keypairs according to `self.key_source`. Will return one or more keypairs, or an
|
|
/// error.
|
|
#[allow(dead_code)]
|
|
pub fn fetch_keys(&self, log: &slog::Logger) -> Result<Vec<Keypair>, String> {
|
|
let keypairs = match &self.key_source {
|
|
KeySource::Disk => self.fetch_keys_from_disk(log)?,
|
|
KeySource::TestingKeypairRange(range) => {
|
|
warn!(log, "Using insecure private keys");
|
|
self.fetch_testing_keypairs(range.clone())?
|
|
}
|
|
};
|
|
|
|
// Check if it's an empty vector, and return none.
|
|
if keypairs.is_empty() {
|
|
Err(
|
|
"No validator keypairs were found, unable to proceed. To generate \
|
|
testing keypairs, see 'testnet range --help'."
|
|
.into(),
|
|
)
|
|
} else {
|
|
Ok(keypairs)
|
|
}
|
|
}
|
|
|
|
/// Saves a keypair to a file inside the appropriate validator directory. Returns the saved path filename.
|
|
#[allow(dead_code)]
|
|
pub fn save_key(&self, key: &Keypair) -> Result<PathBuf, Error> {
|
|
let validator_config_path = self.data_dir.join(key.identifier());
|
|
let key_path = validator_config_path.join(DEFAULT_PRIVATE_KEY_FILENAME);
|
|
|
|
fs::create_dir_all(&validator_config_path)?;
|
|
|
|
let mut key_file = File::create(&key_path)?;
|
|
|
|
bincode::serialize_into(&mut key_file, &key)
|
|
.map_err(|e| Error::new(ErrorKind::InvalidData, e))?;
|
|
Ok(key_path)
|
|
}
|
|
}
|