Forest tool migration of forest-cli subcommands

src/cli/main.rs

@@ -58,7 +58,6 @@ where
                         Subcommand::Sync(cmd) => cmd.run(config).await,
                         Subcommand::Mpool(cmd) => cmd.run(config).await,
                         Subcommand::State(cmd) => cmd.run(config).await,
-                        Subcommand::Config(cmd) => cmd.run(&config, &mut std::io::stdout()),
                         Subcommand::Send(cmd) => cmd.run(config).await,
                         Subcommand::Info(cmd) => cmd.run(config, opts).await,
                         Subcommand::DB(cmd) => cmd.run(&config).await,
@@ -67,6 +66,15 @@ where
                         Subcommand::Attach(cmd) => cmd.run(config),
                         Subcommand::Shutdown(cmd) => cmd.run(config).await,
                         Subcommand::Car(cmd) => cmd.run().await,
+                        _ => {
+                            let mut s = format!("{:?}", cmd).to_lowercase();
+                            s = s.replace("(", " ");
+                            s = s.replace(")", "");
+                            anyhow::bail!(
+                                "Invalid subcommand: {}. It has been moved to forest-tool binary.",
+                                s
+                            );
+                        }
                     }
                 }
                 Err(e) => {

src/cli/subcommands/db_cmd.rs

@@ -3,26 +3,25 @@
 
 use std::sync::Arc;
 
-use crate::cli_shared::{chain_path, cli::Config};
-use crate::db::db_engine::db_root;
+use crate::cli_shared::cli::Config;
 use crate::rpc_api::progress_api::GetProgressType;
 use crate::rpc_client::{db_ops::db_gc, progress_ops::get_progress};
 use crate::utils::io::ProgressBar;
 use chrono::Utc;
 use clap::Subcommand;
-use tracing::error;
 
-use crate::cli::subcommands::{handle_rpc_err, prompt_confirm};
+use crate::cli::subcommands::handle_rpc_err;
 
 #[derive(Debug, Subcommand)]
 pub enum DBCommands {
-    /// Show DB stats
-    Stats,
     /// Run DB garbage collection
     GC,
-    /// DB Clean up
+
+    // Those subcommands are hidden and only here to help users migrating to forest-tool
+    #[command(hide = true)]
+    Stats,
+    #[command(hide = true)]
     Clean {
-        /// Answer yes to all forest-cli yes/no questions without prompting
         #[arg(long)]
         force: bool,
     },
@@ -31,15 +30,6 @@ pub enum DBCommands {
 impl DBCommands {
     pub async fn run(&self, config: &Config) -> anyhow::Result<()> {
         match self {
-            Self::Stats => {
-                use human_repr::HumanCount;
-
-                let dir = db_root(&chain_path(config));
-                println!("Database path: {}", dir.display());
-                let size = fs_extra::dir::get_size(dir).unwrap_or_default();
-                println!("Database size: {}", size.human_count_bytes());
-                Ok(())
-            }
             Self::GC => {
                 let start = Utc::now();
 
@@ -81,30 +71,11 @@ impl DBCommands {
 
                 Ok(())
             }
-            Self::Clean { force } => {
-                let dir = chain_path(config);
-                if !dir.is_dir() {
-                    println!(
-                        "Aborted. Database path {} is not a valid directory",
-                        dir.display()
-                    );
-                    return Ok(());
-                }
-                println!("Deleting {}", dir.display());
-                if !force && !prompt_confirm() {
-                    println!("Aborted.");
-                    return Ok(());
-                }
-                match fs_extra::dir::remove(&dir) {
-                    Ok(_) => {
-                        println!("Deleted {}", dir.display());
-                        Ok(())
-                    }
-                    Err(err) => {
-                        error!("{err}");
-                        Ok(())
-                    }
-                }
+            _ => {
+                anyhow::bail!(
+                    "Invalid subcommand: db {}. It has been moved to forest-tool binary.",
+                    format!("{:?}", self).to_lowercase()
+                );
             }
         }
     }

src/cli/subcommands/mod.rs

@@ -11,7 +11,6 @@ mod attach_cmd;
 mod auth_cmd;
 mod car_cmd;
 mod chain_cmd;
-mod config_cmd;
 mod db_cmd;
 mod fetch_params_cmd;
 mod info_cmd;
@@ -38,7 +37,7 @@ use tracing::error;
 
 pub(super) use self::{
     archive_cmd::ArchiveCommands, attach_cmd::AttachCommand, auth_cmd::AuthCommands,
-    car_cmd::CarCommands, chain_cmd::ChainCommands, config_cmd::ConfigCommands, db_cmd::DBCommands,
+    car_cmd::CarCommands, chain_cmd::ChainCommands, db_cmd::DBCommands,
     fetch_params_cmd::FetchCommands, mpool_cmd::MpoolCommands, net_cmd::NetCommands,
     send_cmd::SendCommand, shutdown_cmd::ShutdownCommand, snapshot_cmd::SnapshotCommands,
     state_cmd::StateCommands, sync_cmd::SyncCommands, wallet_cmd::WalletCommands,
@@ -56,8 +55,14 @@ pub struct Cli {
     pub cmd: Subcommand,
 }
 
+// This subcommand is hidden and only here to help users migrating to forest-tool
+#[derive(clap::Subcommand, Debug)]
+pub enum ConfigCommands {
+    Dump,
+}
+
 /// Forest binary sub-commands available.
-#[derive(clap::Subcommand)]
+#[derive(clap::Subcommand, Debug)]
 pub enum Subcommand {
     /// Download parameters for generating and verifying proofs for given size
     #[command(name = "fetch-params")]
@@ -91,7 +96,8 @@ pub enum Subcommand {
     #[command(subcommand)]
     State(StateCommands),
 
-    /// Manage node configuration
+    // This subcommand is hidden and only here to help users migrating to forest-tool
+    #[command(hide = true)]
     #[command(subcommand)]
     Config(ConfigCommands),
 
@@ -203,7 +209,7 @@ pub(super) fn print_stdout(out: String) {
         .unwrap();
 }
 
-fn prompt_confirm() -> bool {
+pub fn prompt_confirm() -> bool {
     print!("Do you want to continue? [y/n] ");
     std::io::stdout().flush().unwrap();
     let mut line = String::new();

src/cli_shared/cli/mod.rs

@@ -247,7 +247,7 @@ impl ConfigPath {
     }
 }
 
-fn find_config_path(opts: &CliOpts) -> Option<ConfigPath> {
+pub fn find_config_path(opts: &CliOpts) -> Option<ConfigPath> {
     if let Some(s) = &opts.config {
         return Some(ConfigPath::Cli(PathBuf::from(s)));
     }

src/tool/main.rs

@@ -1,27 +1,50 @@
 // Copyright 2019-2023 ChainSafe Systems
 // SPDX-License-Identifier: Apache-2.0, MIT
 
+use crate::cli_shared::cli::*;
+
 use std::ffi::OsString;
 
 use super::subcommands::Cli;
 use clap::Parser;
 
+use crate::utils::{io::read_file_to_string, io::read_toml};
+
 use super::subcommands::Subcommand;
 
+fn read_config() -> anyhow::Result<Config> {
+    let opts = CliOpts::default();
+    let path = find_config_path(&opts);
+    let cfg: Config = match &path {
+        Some(path) => {
+            // Read from config file
+            let toml = read_file_to_string(path.to_path_buf())?;
+            // Parse and return the configuration file
+            read_toml(&toml)?
+        }
+        None => Config::default(),
+    };
+    Ok(cfg)
+}
+
 pub fn main<ArgT>(args: impl IntoIterator<Item = ArgT>) -> anyhow::Result<()>
 where
     ArgT: Into<OsString> + Clone,
 {
     // Capture Cli inputs
     let Cli { cmd } = Cli::parse_from(args);
 
+    let config = read_config()?;
+
     tokio::runtime::Builder::new_multi_thread()
         .enable_all()
         .build()?
         .block_on(async {
             // Run command
             match cmd {
-                Subcommand::Benchmark(benchmark) => benchmark.run().await,
+                Subcommand::Config(cmd) => cmd.run(&config, &mut std::io::stdout()),
+                Subcommand::Benchmark(cmd) => cmd.run().await,
+                Subcommand::DB(cmd) => cmd.run().await,
             }
         })
 }

src/tool/subcommands/db_cmd.rs

@@ -0,0 +1,74 @@
+// Copyright 2019-2023 ChainSafe Systems
+// SPDX-License-Identifier: Apache-2.0, MIT
+
+use crate::db::db_engine::db_root;
+use clap::Subcommand;
+use std::path::PathBuf;
+use tracing::error;
+
+use crate::cli::subcommands::prompt_confirm;
+
+#[derive(Debug, Subcommand)]
+pub enum DBCommands {
+    /// Show DB stats
+    Stats {
+        #[arg(long)]
+        chain_path: PathBuf,
+    },
+    /// DB Clean up
+    Clean {
+        /// Answer yes to all forest-cli yes/no questions without prompting
+        #[arg(long)]
+        force: bool,
+        #[arg(long)]
+        chain_path: PathBuf,
+    },
+}
+
+impl DBCommands {
+    pub async fn run(&self) -> anyhow::Result<()> {
+        match self {
+            Self::Stats { chain_path } => {
+                use human_repr::HumanCount;
+
+                let dir = db_root(chain_path);
+                if !dir.is_dir() {
+                    println!(
+                        "Aborted. Database path {} is not a valid directory",
+                        dir.display()
+                    );
+                    return Ok(());
+                }
+                println!("Database path: {}", dir.display());
+                let size = fs_extra::dir::get_size(dir).unwrap_or_default();
+                println!("Database size: {}", size.human_count_bytes());
+                Ok(())
+            }
+            Self::Clean { force, chain_path } => {
+                let dir = chain_path;
+                if !dir.is_dir() {
+                    println!(
+                        "Aborted. Database path {} is not a valid directory",
+                        dir.display()
+                    );
+                    return Ok(());
+                }
+                println!("Deleting {}", dir.display());
+                if !force && !prompt_confirm() {
+                    println!("Aborted.");
+                    return Ok(());
+                }
+                match fs_extra::dir::remove(dir) {
+                    Ok(_) => {
+                        println!("Deleted {}", dir.display());
+                        Ok(())
+                    }
+                    Err(err) => {
+                        error!("{err}");
+                        Ok(())
+                    }
+                }
+            }
+        }
+    }
+}

src/tool/subcommands/mod.rs

@@ -2,6 +2,8 @@
 // SPDX-License-Identifier: Apache-2.0, MIT
 
 pub mod benchmark_cmd;
+pub mod config_cmd;
+pub mod db_cmd;
 
 use crate::cli_shared::cli::HELP_MESSAGE;
 use crate::utils::version::FOREST_VERSION_STRING;
@@ -19,7 +21,14 @@ pub struct Cli {
 /// forest-tool sub-commands
 #[derive(clap::Subcommand)]
 pub enum Subcommand {
+    /// Manage node configuration
+    #[command(subcommand)]
+    Config(config_cmd::ConfigCommands),
+
     /// Benchmark various Forest subsystems
     #[command(subcommand)]
     Benchmark(benchmark_cmd::BenchmarkCommands),
+    /// Database management
+    #[command(subcommand)]
+    DB(db_cmd::DBCommands),
 }