Migrate validator client to clap derive

lighthouse/src/cli.rs

@@ -1,9 +1,12 @@
 use clap::Parser;
 use database_manager::cli::DatabaseManager;
 use serde::{Deserialize, Serialize};
+use validator_client::cli::ValidatorClient;
 
 #[derive(Parser, Clone, Deserialize, Serialize, Debug)]
 pub enum LighthouseSubcommands {
     #[clap(name = "database_manager")]
     DatabaseManager(DatabaseManager),
+    #[clap(name = "validator_client")]
+    ValidatorClient(ValidatorClient),
 }

lighthouse/src/main.rs

@@ -411,7 +411,6 @@ fn main() {
         )
         .subcommand(beacon_node::cli_app())
         .subcommand(boot_node::cli_app())
-        .subcommand(validator_client::cli_app())
         .subcommand(account_manager::cli_app())
         .subcommand(validator_manager::cli_app());
 
@@ -682,81 +681,122 @@ fn run<E: EthSpec>(
         return Ok(());
     }
 
-    if let Ok(LighthouseSubcommands::DatabaseManager(db_manager_config)) =
-        LighthouseSubcommands::from_arg_matches(matches)
-    {
-        info!(log, "Running database manager for {} network", network_name);
-        database_manager::run(matches, &db_manager_config, environment)?;
-        return Ok(());
-    };
-
-    info!(log, "Lighthouse started"; "version" => VERSION);
-    info!(
-        log,
-        "Configured for network";
-        "name" => &network_name
-    );
-
-    match matches.subcommand() {
-        Some(("beacon_node", matches)) => {
+    match LighthouseSubcommands::from_arg_matches(matches) {
+        Ok(LighthouseSubcommands::DatabaseManager(db_manager_config)) => {
+            info!(log, "Running database manager for {} network", network_name);
+            database_manager::run(matches, &db_manager_config, environment)?;
+            return Ok(());
+        }
+        Ok(LighthouseSubcommands::ValidatorClient(validator_client_config)) => {
             let context = environment.core_context();
             let log = context.log().clone();
             let executor = context.executor.clone();
-            let mut config = beacon_node::get_config::<E>(matches, &context)?;
-            config.logger_config = logger_config;
+            let config = validator_client::Config::from_cli(
+                matches,
+                &validator_client_config,
+                context.log(),
+            )
+            .map_err(|e| format!("Unable to initialize validator config: {}", e))?;
             // Dump configs if `dump-config` or `dump-chain-config` flags are set
             clap_utils::check_dump_configs::<_, E>(matches, &config, &context.eth2_config.spec)?;
 
             let shutdown_flag = matches.get_flag("immediate-shutdown");
             if shutdown_flag {
-                info!(log, "Beacon node immediate shutdown triggered.");
+                info!(log, "Validator client immediate shutdown triggered.");
                 return Ok(());
             }
 
             executor.clone().spawn(
                 async move {
-                    if let Err(e) = ProductionBeaconNode::new(context.clone(), config).await {
-                        crit!(log, "Failed to start beacon node"; "reason" => e);
+                    if let Err(e) = ProductionValidatorClient::new(context, config)
+                        .and_then(|mut vc| async move { vc.start_service().await })
+                        .await
+                    {
+                        crit!(log, "Failed to start validator client"; "reason" => e);
                         // Ignore the error since it always occurs during normal operation when
                         // shutting down.
                         let _ = executor
                             .shutdown_sender()
-                            .try_send(ShutdownReason::Failure("Failed to start beacon node"));
+                            .try_send(ShutdownReason::Failure("Failed to start validator client"));
                     }
                 },
-                "beacon_node",
+                "validator_client",
             );
         }
-        Some(("validator_client", matches)) => {
+        Err(_) => (),
+    };
+
+    info!(log, "Lighthouse started"; "version" => VERSION);
+    info!(
+        log,
+        "Configured for network";
+        "name" => &network_name
+    );
+
+    if let Ok(LighthouseSubcommands::ValidatorClient(validator_client_config)) =
+        LighthouseSubcommands::from_arg_matches(matches)
+    {
+        let context = environment.core_context();
+        let log = context.log().clone();
+        let executor = context.executor.clone();
+        let config =
+            validator_client::Config::from_cli(matches, &validator_client_config, context.log())
+                .map_err(|e| format!("Unable to initialize validator config: {}", e))?;
+        // Dump configs if `dump-config` or `dump-chain-config` flags are set
+        clap_utils::check_dump_configs::<_, E>(matches, &config, &context.eth2_config.spec)?;
+
+        let shutdown_flag = matches.get_flag("immediate-shutdown");
+        if shutdown_flag {
+            info!(log, "Validator client immediate shutdown triggered.");
+            return Ok(());
+        }
+
+        executor.clone().spawn(
+            async move {
+                if let Err(e) = ProductionValidatorClient::new(context, config)
+                    .and_then(|mut vc| async move { vc.start_service().await })
+                    .await
+                {
+                    crit!(log, "Failed to start validator client"; "reason" => e);
+                    // Ignore the error since it always occurs during normal operation when
+                    // shutting down.
+                    let _ = executor
+                        .shutdown_sender()
+                        .try_send(ShutdownReason::Failure("Failed to start validator client"));
+                }
+            },
+            "validator_client",
+        );
+    };
+
+    match matches.subcommand() {
+        Some(("beacon_node", matches)) => {
             let context = environment.core_context();
             let log = context.log().clone();
             let executor = context.executor.clone();
-            let config = validator_client::Config::from_cli(matches, context.log())
-                .map_err(|e| format!("Unable to initialize validator config: {}", e))?;
+            let mut config = beacon_node::get_config::<E>(matches, &context)?;
+            config.logger_config = logger_config;
             // Dump configs if `dump-config` or `dump-chain-config` flags are set
             clap_utils::check_dump_configs::<_, E>(matches, &config, &context.eth2_config.spec)?;
 
             let shutdown_flag = matches.get_flag("immediate-shutdown");
             if shutdown_flag {
-                info!(log, "Validator client immediate shutdown triggered.");
+                info!(log, "Beacon node immediate shutdown triggered.");
                 return Ok(());
             }
 
             executor.clone().spawn(
                 async move {
-                    if let Err(e) = ProductionValidatorClient::new(context, config)
-                        .and_then(|mut vc| async move { vc.start_service().await })
-                        .await
-                    {
-                        crit!(log, "Failed to start validator client"; "reason" => e);
+                    if let Err(e) = ProductionBeaconNode::new(context.clone(), config).await {
+                        crit!(log, "Failed to start beacon node"; "reason" => e);
                         // Ignore the error since it always occurs during normal operation when
                         // shutting down.
                         let _ = executor
                             .shutdown_sender()
-                            .try_send(ShutdownReason::Failure("Failed to start validator client"));
+                            .try_send(ShutdownReason::Failure("Failed to start beacon node"));
                     }
                 },
-                "validator_client",
+                "beacon_node",
             );
         }
         _ => {