refactor: use clap as a commands parser

applications/tari_app_utilities/src/utilities.rs

@@ -205,6 +205,7 @@ pub fn either_to_node_id(either: Either<CommsPublicKey, NodeId>) -> NodeId {
     }
 }
 
+#[derive(Debug)]
 pub struct UniPublicKey(PublicKey);
 
 impl FromStr for UniPublicKey {
@@ -227,6 +228,7 @@ impl From<UniPublicKey> for PublicKey {
     }
 }
 
+#[derive(Debug)]
 pub enum UniNodeId {
     PublicKey(PublicKey),
     NodeId(NodeId),

applications/tari_base_node/Cargo.toml

@@ -24,8 +24,10 @@ tari_shutdown = { path = "../../infrastructure/shutdown" }
 tari_utilities = { git = "https://github.com/tari-project/tari_utilities.git", tag = "v0.3.1" }
 
 anyhow = "1.0.53"
+async-trait = "0.1.52"
 bincode = "1.3.1"
 chrono = { version = "0.4.19", default-features = false }
+clap = { version = "3.1.1", features = ["derive"] }
 config = { version = "0.9.3" }
 crossterm = "0.22"
 derive_more = "0.99.17"
@@ -34,10 +36,11 @@ futures = { version = "^0.3.16", default-features = false, features = ["alloc"]
 log = { version = "0.4.8", features = ["std"] }
 log-mdc = "0.1.0"
 num_cpus = "1"
+nom = "7.1.0"
 regex = "1"
 rustyline = "9.0"
 rustyline-derive = "0.5"
-strum = "0.22"
+strum = { version = "0.22", features = ["derive"] }
 strum_macros = "0.22"
 thiserror = "^1.0.26"
 tokio = { version = "1.11", features = ["signal"] }

applications/tari_base_node/src/commands/args.rs

@@ -1,97 +1 @@
-use std::{
-    iter::Peekable,
-    str::{FromStr, SplitWhitespace},
-};
 
-use tari_utilities::hex::{Hex, HexError};
-use thiserror::Error;
-
-#[derive(Debug, Error)]
-#[error("{name} {reason}")]
-pub struct ArgsError {
-    name: &'static str,
-    reason: ArgsReason,
-}
-
-impl ArgsError {
-    pub fn new(name: &'static str, reason: impl Into<ArgsReason>) -> Self {
-        Self {
-            name,
-            reason: reason.into(),
-        }
-    }
-}
-
-#[derive(Debug, Error)]
-pub enum ArgsReason {
-    #[error("argument required")]
-    Required,
-    #[error("argument can't be parsed: {details}")]
-    NotParsed { details: String },
-    #[error("argument is not valid: {description}")]
-    Inconsistent { description: String },
-}
-
-impl<T: AsRef<str>> From<T> for ArgsReason {
-    fn from(value: T) -> Self {
-        Self::Inconsistent {
-            description: value.as_ref().to_owned(),
-        }
-    }
-}
-
-pub struct Args<'a> {
-    splitted: Peekable<SplitWhitespace<'a>>,
-}
-
-impl<'a> Args<'a> {
-    pub fn split(s: &'a str) -> Self {
-        Self {
-            splitted: s.split_whitespace().peekable(),
-        }
-    }
-
-    // TODO: Remove
-    pub fn shift_one(&mut self) {
-        self.splitted.next();
-    }
-
-    // TODO: Use `next` always
-    pub fn try_take_next<T>(&mut self, name: &'static str) -> Result<Option<T>, ArgsError>
-    where
-        T: FromStr,
-        T::Err: ToString,
-    {
-        match self.splitted.peek().map(|s| s.parse()) {
-            Some(Ok(value)) => Ok(Some(value)),
-            Some(Err(err)) => Err(ArgsError::new(name, ArgsReason::NotParsed {
-                details: err.to_string(),
-            })),
-            None => Ok(None),
-        }
-    }
-
-    pub fn take_next<T>(&mut self, name: &'static str) -> Result<T, ArgsError>
-    where
-        T: FromStr,
-        T::Err: ToString,
-    {
-        match self.try_take_next(name)? {
-            Some(value) => {
-                self.shift_one();
-                Ok(value)
-            },
-            None => Err(ArgsError::new(name, ArgsReason::Required)),
-        }
-    }
-}
-
-pub struct FromHex<T>(pub T);
-
-impl<T: Hex> FromStr for FromHex<T> {
-    type Err = HexError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        T::from_hex(s).map(Self)
-    }
-}

applications/tari_base_node/src/commands/command/ban_peer.rs

@@ -0,0 +1,83 @@
+use std::time::Duration;
+
+use anyhow::Error;
+use async_trait::async_trait;
+use clap::Parser;
+use tari_app_utilities::utilities::UniNodeId;
+use tari_comms::peer_manager::NodeId;
+
+use super::{CommandContext, HandleCommand};
+use crate::LOG_TARGET;
+
+/// Bans a peer
+#[derive(Debug, Parser)]
+pub struct ArgsBan {
+    /// hex public key or emoji id
+    node_id: UniNodeId,
+    /// length of time to ban the peer for in seconds
+    #[clap(default_value_t = std::u64::MAX)]
+    length: u64,
+}
+
+/// Removes a peer ban
+#[derive(Debug, Parser)]
+pub struct ArgsUnban {
+    /// hex public key or emoji id
+    node_id: UniNodeId,
+    /// length of time to ban the peer for in seconds
+    #[clap(default_value_t = std::u64::MAX)]
+    length: u64,
+}
+
+#[async_trait]
+impl HandleCommand<ArgsBan> for CommandContext {
+    async fn handle_command(&mut self, args: ArgsBan) -> Result<(), Error> {
+        let node_id = args.node_id.into();
+        let duration = Duration::from_secs(args.length);
+        self.ban_peer(node_id, duration, true).await
+    }
+}
+
+#[async_trait]
+impl HandleCommand<ArgsUnban> for CommandContext {
+    async fn handle_command(&mut self, args: ArgsUnban) -> Result<(), Error> {
+        let node_id = args.node_id.into();
+        let duration = Duration::from_secs(args.length);
+        self.ban_peer(node_id, duration, false).await
+    }
+}
+
+impl CommandContext {
+    pub async fn ban_peer(&mut self, node_id: NodeId, duration: Duration, must_ban: bool) -> Result<(), Error> {
+        if self.base_node_identity.node_id() == &node_id {
+            println!("Cannot ban our own node");
+        } else if must_ban {
+            // TODO: Use errors
+            match self
+                .connectivity
+                .ban_peer_until(node_id.clone(), duration, "UI manual ban".to_string())
+                .await
+            {
+                Ok(_) => println!("Peer was banned in base node."),
+                Err(err) => {
+                    println!("Failed to ban peer: {:?}", err);
+                    log::error!(target: LOG_TARGET, "Could not ban peer: {:?}", err);
+                },
+            }
+        } else {
+            match self.peer_manager.unban_peer(&node_id).await {
+                Ok(_) => {
+                    println!("Peer ban was removed from base node.");
+                },
+                Err(err) if err.is_peer_not_found() => {
+                    println!("Peer not found in base node");
+                },
+                Err(err) => {
+                    println!("Failed to ban peer: {:?}", err);
+                    log::error!(target: LOG_TARGET, "Could not ban peer: {:?}", err);
+                },
+            }
+        }
+        Ok(())
+    }
+}

applications/tari_base_node/src/commands/command/block_timing.rs

@@ -0,0 +1,48 @@
+use anyhow::Error;
+use async_trait::async_trait;
+use clap::Parser;
+use tari_core::blocks::BlockHeader;
+
+use super::{CommandContext, HandleCommand};
+
+/// Calculates the maximum, minimum, and average time taken to mine a given range of blocks
+#[derive(Debug, Parser)]
+pub struct Args {
+    /// number of blocks from chain tip or start height
+    start: u64,
+    /// end height
+    end: Option<u64>,
+}
+
+#[async_trait]
+impl HandleCommand<Args> for CommandContext {
+    async fn handle_command(&mut self, args: Args) -> Result<(), Error> {
+        // TODO: is that possible to validate it with clap?
+        if args.end.is_none() && args.start < 2 {
+            Err(Error::msg("Number of headers must be at least 2."))
+        } else {
+            self.block_timing(args.start, args.end).await
+        }
+    }
+}
+
+impl CommandContext {
+    pub async fn block_timing(&self, start: u64, end: Option<u64>) -> Result<(), Error> {
+        let headers = self.get_chain_headers(start, end).await?;
+        if !headers.is_empty() {
+            let headers = headers.into_iter().map(|ch| ch.into_header()).rev().collect::<Vec<_>>();
+            let (max, min, avg) = BlockHeader::timing_stats(&headers);
+            println!(
+                "Timing for blocks #{} - #{}",
+                headers.first().unwrap().height,
+                headers.last().unwrap().height
+            );
+            println!("Max block time: {}", max);
+            println!("Min block time: {}", min);
+            println!("Avg block time: {}", avg);
+        } else {
+            println!("No headers found");
+        }
+        Ok(())
+    }
+}

applications/tari_base_node/src/commands/command/check_db.rs

@@ -0,0 +1,63 @@
+use anyhow::Error;
+use async_trait::async_trait;
+use clap::Parser;
+use tokio::io::{self, AsyncWriteExt};
+
+use super::{CommandContext, HandleCommand};
+use crate::LOG_TARGET;
+
+/// Checks the blockchain database for missing blocks and headers
+#[derive(Debug, Parser)]
+pub struct Args {}
+
+#[async_trait]
+impl HandleCommand<Args> for CommandContext {
+    async fn handle_command(&mut self, _: Args) -> Result<(), Error> {
+        self.check_db().await
+    }
+}
+
+impl CommandContext {
+    /// Function to process the check-db command
+    pub async fn check_db(&mut self) -> Result<(), Error> {
+        let meta = self.node_service.get_metadata().await?;
+        let mut height = meta.height_of_longest_chain();
+        let mut missing_blocks = Vec::new();
+        let mut missing_headers = Vec::new();
+        print!("Searching for height: ");
+        // We need to check every header, but not every block.
+        let horizon_height = meta.horizon_block(height);
+        while height > 0 {
+            print!("{}", height);
+            io::stdout().flush().await?;
+            // we can only check till the pruning horizon, 0 is archive node so it needs to check every block.
+            if height > horizon_height {
+                match self.node_service.get_block(height).await {
+                    Err(err) => {
+                        // We need to check the data itself, as FetchMatchingBlocks will suppress any error, only
+                        // logging it.
+                        log::error!(target: LOG_TARGET, "{}", err);
+                        missing_blocks.push(height);
+                    },
+                    Ok(Some(_)) => {},
+                    Ok(None) => missing_blocks.push(height),
+                };
+            }
+            height -= 1;
+            let next_header = self.node_service.get_header(height).await.ok().flatten();
+            if next_header.is_none() {
+                // this header is missing, so we stop here and need to ask for this header
+                missing_headers.push(height);
+            };
+            print!("\x1B[{}D\x1B[K", (height + 1).to_string().chars().count());
+        }
+        println!("Complete");
+        for missing_block in missing_blocks {
+            println!("Missing block at height: {}", missing_block);
+        }
+        for missing_header_height in missing_headers {
+            println!("Missing header at height: {}", missing_header_height)
+        }
+        Ok(())
+    }
+}