2020-04-19 02:20:43 +00:00
|
|
|
//! A helper library for parsing values from `clap::ArgMatches`.
|
|
|
|
|
|
|
|
use clap::ArgMatches;
|
|
|
|
use eth2_testnet_config::Eth2TestnetConfig;
|
|
|
|
use ssz::Decode;
|
|
|
|
use std::path::PathBuf;
|
|
|
|
use std::str::FromStr;
|
|
|
|
|
2020-04-30 06:19:15 +00:00
|
|
|
pub const BAD_TESTNET_DIR_MESSAGE: &str = "The hard-coded testnet directory was invalid. \
|
|
|
|
This happens when Lighthouse is migrating between spec versions \
|
|
|
|
or when there is no default public network to connect to. \
|
|
|
|
During these times you must specify a --testnet-dir.";
|
|
|
|
|
2020-04-19 02:20:43 +00:00
|
|
|
/// Attempts to load the testnet dir at the path if `name` is in `matches`, returning an error if
|
|
|
|
/// the path cannot be found or the testnet dir is invalid.
|
2020-10-28 22:19:38 +00:00
|
|
|
pub fn parse_testnet_dir(
|
2020-04-19 02:20:43 +00:00
|
|
|
matches: &ArgMatches,
|
|
|
|
name: &'static str,
|
2020-10-28 22:19:38 +00:00
|
|
|
) -> Result<Option<Eth2TestnetConfig>, String> {
|
2020-07-29 06:39:29 +00:00
|
|
|
let path = parse_required::<PathBuf>(matches, name)?;
|
|
|
|
Eth2TestnetConfig::load(path.clone())
|
|
|
|
.map_err(|e| format!("Unable to open testnet dir at {:?}: {}", path, e))
|
|
|
|
.map(Some)
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Attempts to load a hardcoded network config if `name` is in `matches`, returning an error if
|
|
|
|
/// the name is not a valid network name.
|
2020-10-28 22:19:38 +00:00
|
|
|
pub fn parse_hardcoded_network(
|
2020-07-29 06:39:29 +00:00
|
|
|
matches: &ArgMatches,
|
|
|
|
name: &str,
|
2020-10-28 22:19:38 +00:00
|
|
|
) -> Result<Option<Eth2TestnetConfig>, String> {
|
2020-07-29 06:39:29 +00:00
|
|
|
let network_name = parse_required::<String>(matches, name)?;
|
|
|
|
Eth2TestnetConfig::constant(network_name.as_str())
|
2020-04-19 02:20:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// If `name` is in `matches`, parses the value as a path. Otherwise, attempts to find the user's
|
|
|
|
/// home directory and appends `default` to it.
|
|
|
|
pub fn parse_path_with_default_in_home_dir(
|
|
|
|
matches: &ArgMatches,
|
|
|
|
name: &'static str,
|
|
|
|
default: PathBuf,
|
|
|
|
) -> Result<PathBuf, String> {
|
|
|
|
matches
|
|
|
|
.value_of(name)
|
|
|
|
.map(|dir| {
|
|
|
|
dir.parse::<PathBuf>()
|
|
|
|
.map_err(|e| format!("Unable to parse {}: {}", name, e))
|
|
|
|
})
|
|
|
|
.unwrap_or_else(|| {
|
|
|
|
dirs::home_dir()
|
|
|
|
.map(|home| home.join(default))
|
|
|
|
.ok_or_else(|| format!("Unable to locate home directory. Try specifying {}", name))
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Returns the value of `name` or an error if it is not in `matches` or does not parse
|
|
|
|
/// successfully using `std::string::FromStr`.
|
2020-07-29 06:39:29 +00:00
|
|
|
pub fn parse_required<T>(matches: &ArgMatches, name: &str) -> Result<T, String>
|
2020-04-19 02:20:43 +00:00
|
|
|
where
|
|
|
|
T: FromStr,
|
|
|
|
<T as FromStr>::Err: std::fmt::Display,
|
|
|
|
{
|
|
|
|
parse_optional(matches, name)?.ok_or_else(|| format!("{} not specified", name))
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Returns the value of `name` (if present) or an error if it does not parse successfully using
|
|
|
|
/// `std::string::FromStr`.
|
2020-07-29 06:39:29 +00:00
|
|
|
pub fn parse_optional<T>(matches: &ArgMatches, name: &str) -> Result<Option<T>, String>
|
2020-04-19 02:20:43 +00:00
|
|
|
where
|
|
|
|
T: FromStr,
|
|
|
|
<T as FromStr>::Err: std::fmt::Display,
|
|
|
|
{
|
|
|
|
matches
|
|
|
|
.value_of(name)
|
|
|
|
.map(|val| {
|
|
|
|
val.parse()
|
|
|
|
.map_err(|e| format!("Unable to parse {}: {}", name, e))
|
|
|
|
})
|
|
|
|
.transpose()
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Returns the value of `name` or an error if it is not in `matches` or does not parse
|
|
|
|
/// successfully using `ssz::Decode`.
|
|
|
|
///
|
|
|
|
/// Expects the value of `name` to be 0x-prefixed ASCII-hex.
|
|
|
|
pub fn parse_ssz_required<T: Decode>(
|
|
|
|
matches: &ArgMatches,
|
|
|
|
name: &'static str,
|
|
|
|
) -> Result<T, String> {
|
|
|
|
parse_ssz_optional(matches, name)?.ok_or_else(|| format!("{} not specified", name))
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Returns the value of `name` (if present) or an error if it does not parse successfully using
|
|
|
|
/// `ssz::Decode`.
|
|
|
|
///
|
|
|
|
/// Expects the value of `name` (if any) to be 0x-prefixed ASCII-hex.
|
|
|
|
pub fn parse_ssz_optional<T: Decode>(
|
|
|
|
matches: &ArgMatches,
|
|
|
|
name: &'static str,
|
|
|
|
) -> Result<Option<T>, String> {
|
|
|
|
matches
|
|
|
|
.value_of(name)
|
|
|
|
.map(|val| {
|
2020-12-03 01:10:26 +00:00
|
|
|
if let Some(stripped) = val.strip_prefix("0x") {
|
|
|
|
let vec = hex::decode(stripped)
|
2020-04-19 02:20:43 +00:00
|
|
|
.map_err(|e| format!("Unable to parse {} as hex: {:?}", name, e))?;
|
|
|
|
|
|
|
|
T::from_ssz_bytes(&vec)
|
|
|
|
.map_err(|e| format!("Unable to parse {} as SSZ: {:?}", name, e))
|
|
|
|
} else {
|
|
|
|
Err(format!("Unable to parse {}, must have 0x prefix", name))
|
|
|
|
}
|
|
|
|
})
|
|
|
|
.transpose()
|
|
|
|
}
|