Refactor ClientConfig, add serde to it

beacon_node/client/src/client_config.rs

@@ -1,164 +1,69 @@
 use clap::ArgMatches;
-use fork_choice::ForkChoiceAlgorithm;
 use http_server::HttpServerConfig;
 use network::NetworkConfig;
-use slog::error;
+use serde_derive::{Deserialize, Serialize};
 use std::fs;
-use std::net::SocketAddr;
-use std::net::{IpAddr, Ipv4Addr};
 use std::path::PathBuf;
-use types::multiaddr::Protocol;
-use types::multiaddr::ToMultiaddr;
-use types::Multiaddr;
-use types::{ChainSpec, EthSpec, LighthouseTestnetEthSpec};
 
-#[derive(Debug, Clone)]
-pub enum DBType {
-    Memory,
-    Disk,
-}
-
-/// Stores the client configuration for this Lighthouse instance.
-#[derive(Debug, Clone)]
+/// The core configuration of a Lighthouse beacon node.
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ClientConfig {
-    pub data_dir: PathBuf,
-    pub spec: ChainSpec,
-    pub net_conf: network::NetworkConfig,
-    pub fork_choice: ForkChoiceAlgorithm,
-    pub db_type: DBType,
-    pub db_name: PathBuf,
-    pub rpc_conf: rpc::RPCConfig,
-    pub http_conf: HttpServerConfig, //pub ipc_conf:
+    data_dir: String,
+    pub spec: String,
+    pub db_type: String,
+    db_name: String,
+    pub network: network::NetworkConfig,
+    pub rpc: rpc::RPCConfig,
+    pub http: HttpServerConfig, //pub ipc_conf:
 }
 
 impl Default for ClientConfig {
-    /// Build a new lighthouse configuration from defaults.
     fn default() -> Self {
-        let data_dir = {
-            let home = dirs::home_dir().expect("Unable to determine home dir.");
-            home.join(".lighthouse/")
-        };
-        fs::create_dir_all(&data_dir)
-            .unwrap_or_else(|_| panic!("Unable to create {:?}", &data_dir));
-
-        let default_spec = LighthouseTestnetEthSpec::spec();
-        let default_net_conf = NetworkConfig::new(default_spec.boot_nodes.clone());
-
         Self {
-            data_dir: data_dir.clone(),
-            // default to foundation for chain specs
-            spec: default_spec,
-            net_conf: default_net_conf,
-            // default to bitwise LMD Ghost
-            fork_choice: ForkChoiceAlgorithm::BitwiseLMDGhost,
-            // default to memory db for now
-            db_type: DBType::Memory,
-            // default db name for disk-based dbs
-            db_name: data_dir.join("chain_db"),
-            rpc_conf: rpc::RPCConfig::default(),
-            http_conf: HttpServerConfig::default(),
+            data_dir: ".lighthouse".to_string(),
+            spec: "testnet".to_string(),
+            db_type: "disk".to_string(),
+            db_name: "chain_db".to_string(),
+            // Note: there are no default bootnodes specified.
+            // Once bootnodes are established, add them here.
+            network: NetworkConfig::new(vec![]),
+            rpc: rpc::RPCConfig::default(),
+            http: HttpServerConfig::default(),
         }
     }
 }
 
 impl ClientConfig {
-    /// Parses the CLI arguments into a `Config` struct.
-    pub fn parse_args(args: ArgMatches, log: &slog::Logger) -> Result<Self, &'static str> {
-        let mut config = ClientConfig::default();
+    /// Returns the path to which the client may initialize an on-disk database.
+    pub fn db_path(&self) -> Option<PathBuf> {
+        self.data_dir()
+            .and_then(|path| Some(path.join(&self.db_name)))
+    }
 
-        /* Network related arguments */
+    /// Returns the core path for the client.
+    pub fn data_dir(&self) -> Option<PathBuf> {
+        let path = dirs::home_dir()?.join(&self.data_dir);
+        fs::create_dir_all(&path).ok()?;
+        Some(path)
+    }
 
-        // Custom p2p listen port
-        if let Some(port_str) = args.value_of("port") {
-            if let Ok(port) = port_str.parse::<u16>() {
-                config.net_conf.listen_port = port;
-                // update the listening multiaddrs
-                for address in &mut config.net_conf.listen_addresses {
-                    address.pop();
-                    address.append(Protocol::Tcp(port));
-                }
-            } else {
-                error!(log, "Invalid port"; "port" => port_str);
-                return Err("Invalid port");
-            }
-        }
-        // Custom listening address ipv4/ipv6
-        // TODO: Handle list of addresses
-        if let Some(listen_address_str) = args.value_of("listen-address") {
-            if let Ok(listen_address) = listen_address_str.parse::<IpAddr>() {
-                let multiaddr = SocketAddr::new(listen_address, config.net_conf.listen_port)
-                    .to_multiaddr()
-                    .expect("Invalid listen address format");
-                config.net_conf.listen_addresses = vec![multiaddr];
-            } else {
-                error!(log, "Invalid IP Address"; "Address" => listen_address_str);
-                return Err("Invalid IP Address");
-            }
-        }
-
-        // Custom bootnodes
-        if let Some(boot_addresses_str) = args.value_of("boot-nodes") {
-            let boot_addresses_split = boot_addresses_str.split(',');
-            for boot_address in boot_addresses_split {
-                if let Ok(boot_address) = boot_address.parse::<Multiaddr>() {
-                    config.net_conf.boot_nodes.append(&mut vec![boot_address]);
-                } else {
-                    error!(log, "Invalid Bootnode multiaddress"; "Multiaddr" => boot_addresses_str);
-                    return Err("Invalid IP Address");
-                }
-            }
-        }
-
-        /* Filesystem related arguments */
-
-        // Custom datadir
+    /// 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) -> Result<(), &'static str> {
         if let Some(dir) = args.value_of("datadir") {
-            config.data_dir = PathBuf::from(dir.to_string());
+            self.data_dir = dir.to_string();
         };
 
-        /* RPC related arguments */
-
-        if args.is_present("rpc") {
-            config.rpc_conf.enabled = true;
+        if let Some(dir) = args.value_of("db") {
+            self.db_type = dir.to_string();
         }
 
-        if let Some(rpc_address) = args.value_of("rpc-address") {
-            if let Ok(listen_address) = rpc_address.parse::<Ipv4Addr>() {
-                config.rpc_conf.listen_address = listen_address;
-            } else {
-                error!(log, "Invalid RPC listen address"; "Address" => rpc_address);
-                return Err("Invalid RPC listen address");
-            }
-        }
+        self.network.apply_cli_args(args)?;
+        self.rpc.apply_cli_args(args)?;
+        self.http.apply_cli_args(args)?;
 
-        if let Some(rpc_port) = args.value_of("rpc-port") {
-            if let Ok(port) = rpc_port.parse::<u16>() {
-                config.rpc_conf.port = port;
-            } else {
-                error!(log, "Invalid RPC port"; "port" => rpc_port);
-                return Err("Invalid RPC port");
-            }
-        }
-
-        /* HTTP related arguments */
-
-        if args.is_present("http") {
-            config.http_conf.enabled = true;
-        }
-
-        if let Some(listen_address) = args.value_of("http-address") {
-            config.http_conf.listen_address = listen_address.to_string();
-        }
-        if let Some(listen_port) = args.value_of("http-port") {
-            config.http_conf.listen_port = listen_port.to_string();
-        }
-
-        match args.value_of("db") {
-            Some("disk") => config.db_type = DBType::Disk,
-            Some("memory") => config.db_type = DBType::Memory,
-            _ => unreachable!(), // clap prevents this.
-        };
-
-        Ok(config)
+        Ok(())
     }
 }