use bail! macro. Fix lncli RPC call

Author: willcl-ark

src/rust-cli/debug.rs

@@ -23,8 +23,10 @@ pub async fn handle_debug_command(
         DebugCommand::GenerateCompose { graph_file_path } => {
             rpc_params
                 .insert("graph_file", graph_file_path.to_str())
-                .context("Add graph file path to params")?;
-            let data = make_rpc_call("generate_compose", rpc_params).await?;
+                .context("Adding graph_file_path to rpc params")?;
+            let data = make_rpc_call("generate_compose", rpc_params)
+                .await
+                .context("Calling generate_compose RPC")?;
             println!("Docker-compose file generated: {:?}", data);
         }
     }

src/rust-cli/general.rs

@@ -26,14 +26,14 @@ pub async fn handle_rpc_commands(
         params.insert("params", p).context("add rpc params")?;
     }
     let data = match node_type {
-        NodeType::LnCli => make_rpc_call("tank_bcli", params)
+        NodeType::LnCli => make_rpc_call("tank_lncli", params)
             .await
-            .context("Failed to make RPC call LnCli")?,
+            .context("make RPC call lncli")?,
         NodeType::BitcoinCli => make_rpc_call("tank_bcli", params)
             .await
-            .context("Failed to make RPC call BitcoinCli")?,
+            .context("make RPC call bitcoin-cli")?,
     };
-    pretty_print_value(&data).context("pretty print result")?;
+    pretty_print_value(&data).context("Pretty print the result")?;
     Ok(())
 }
 
@@ -43,7 +43,7 @@ pub async fn handle_debug_log_command(node: &u64, mut params: ObjectParams) -> a
         .context("add node_index param")?;
     let data = make_rpc_call("tank_debug_log", params)
         .await
-        .context("Failed to make RPC call tank_debug_log")?;
+        .context("make RPC call tank_debug_log")?;
     pretty_print_value(&data).context("pretty print result")?;
     Ok(())
 }

src/rust-cli/graph.rs

@@ -20,7 +20,7 @@ pub enum GraphCommand {
     Create {
         /// Number of nodes in the graph
         number: usize,
-        /// Write graph to a this file path
+        /// Write graph to this file path
         #[arg(short, long)]
         outfile: Option<PathBuf>,
         /// Bitcoin Core version to set on nodes
@@ -263,7 +263,7 @@ pub async fn handle_graph_command(command: &GraphCommand) -> anyhow::Result<()>
             .context("Create a graph")?,
 
         GraphCommand::Validate { graph } => {
-            let _ = validate_schema(graph);
+            let _ = validate_schema(graph).context("Validating graph schema");
         }
     }
     Ok(())

src/rust-cli/image.rs

@@ -1,4 +1,4 @@
-use anyhow::anyhow;
+use anyhow::bail;
 use clap::Subcommand;
 use std::fs;
 use std::process::{Command, Stdio};
@@ -48,7 +48,7 @@ fn run_command(command: &str) -> anyhow::Result<bool> {
     if output.success() {
         Ok(true)
     } else {
-        Err(anyhow!("Command failed"))
+        bail!("Command failed")
     }
 }
 
@@ -75,7 +75,7 @@ fn build_image(
     for arch in &build_arches {
         if !ARCHES.contains(&arch.as_str()) {
             println!("Error: {} is not a supported architecture", arch);
-            return Err(anyhow!("Unsupported architecture: {}", arch));
+            bail!("Unsupported architecture: {}", arch);
         }
     }
 
@@ -92,7 +92,7 @@ fn build_image(
     {
         println!("Directory src/templates does not exist.");
         println!("Please run this script from the project root.");
-        return Err(anyhow!("src/templates directory not found"));
+        bail!("src/templates directory not found");
     }
 
     let builder_name = "bitcoind-builder";
@@ -140,10 +140,8 @@ fn build_image(
 
     match res {
         Ok(true) => Ok(()),
-        Ok(false) => Err(anyhow!(
-            "Build command failed, but no specific error was provided."
-        )),
-        Err(e) => Err(anyhow!("Build command failed with error: {}", e)),
+        Ok(false) => bail!("Build command failed, but no specific error was provided."),
+        Err(e) => bail!("Build command failed with error: {}", e),
     }
 }
 

src/rust-cli/main.rs

@@ -101,7 +101,7 @@ async fn main() -> anyhow::Result<()> {
     if let Some(network_value) = &cli.network {
         rpc_params
             .insert("network", network_value)
-            .context("add network param")?;
+            .context("Adding --network to rpc_params")?;
     }
 
     match &cli.command {

src/rust-cli/network.rs

@@ -1,4 +1,4 @@
-use anyhow::Context;
+use anyhow::{bail, Context};
 use base64::{engine::general_purpose, Engine as _};
 use clap::Subcommand;
 use jsonrpsee::core::params::ObjectParams;
@@ -33,11 +33,11 @@ pub enum NetworkCommand {
 }
 
 fn graph_file_to_b64(graph_file: &PathBuf) -> anyhow::Result<String> {
-    let file_contents = std::fs::read(graph_file).context("Failed to read graph file")?;
+    let file_contents = std::fs::read(graph_file).context("Failed to read graph file from fs")?;
     Ok(general_purpose::STANDARD.encode(file_contents))
 }
 
-fn handle_network_status_response(data: serde_json::Value) {
+fn handle_network_status_response(data: serde_json::Value) -> anyhow::Result<()> {
     if let serde_json::Value::Array(items) = &data {
         for item in items {
             if let (Some(tank_index), Some(bitcoin_status)) = (
@@ -46,12 +46,13 @@ fn handle_network_status_response(data: serde_json::Value) {
             ) {
                 println!("Tank: {:<6} Bitcoin: {}", tank_index, bitcoin_status);
             } else {
-                println!("Error: Response item is missing expected fields");
+                bail!("Error: Response item is missing expected fields");
             }
         }
     } else {
-        println!("Error: Expected an array in the response");
+        bail!("Error: Expected an array in the response");
     }
+    Ok(())
 }
 
 fn handle_network_start_response(data: serde_json::Value) -> anyhow::Result<()> {
@@ -81,6 +82,8 @@ fn handle_network_start_response(data: serde_json::Value) -> anyhow::Result<()>
             ));
         }
         table.printstd();
+    } else {
+        bail!("No warnet table headers found in response")
     }
     // tanks table
     if let Some(tank_headers) = data["tank_headers"].as_array() {
@@ -109,6 +112,8 @@ fn handle_network_start_response(data: serde_json::Value) -> anyhow::Result<()>
             }
         }
         table.printstd();
+    } else {
+        bail!("no tank headers found in response")
     }
     Ok(())
 }
@@ -119,7 +124,8 @@ pub async fn handle_network_command(
 ) -> anyhow::Result<()> {
     let (request, params) = match command {
         NetworkCommand::Start { graph_file, force } => {
-            let b64_graph = graph_file_to_b64(graph_file).context("Read graph file")?;
+            let b64_graph =
+                graph_file_to_b64(graph_file).context("Reading graph file to base 64")?;
             params
                 .insert("graph_file", b64_graph)
                 .context("Add base64 graph file to params")?;
@@ -138,9 +144,12 @@ pub async fn handle_network_command(
 
     let data = make_rpc_call(request, params).await?;
     match request {
-        "network_status" => handle_network_status_response(data),
+        "network_status" => {
+            handle_network_status_response(data).context("Handling network status response")?
+        }
         "network_from_file" => {
-            handle_network_start_response(data.clone())?;
+            handle_network_start_response(data.clone())
+                .context("Handling network start response")?;
         }
         _ => {
             println!("{}", data)

src/rust-cli/scenarios.rs

@@ -1,5 +1,5 @@
 use crate::rpc_call::make_rpc_call;
-use anyhow::Context;
+use anyhow::{bail, Context};
 use base64::{engine::general_purpose, Engine as _};
 use clap::Subcommand;
 use jsonrpsee::core::params::ObjectParams;
@@ -35,7 +35,7 @@ pub enum ScenarioCommand {
 async fn handle_available(params: ObjectParams) -> anyhow::Result<()> {
     let data = make_rpc_call("scenarios_available", params)
         .await
-        .context("Failed to fetch available scenarios")?;
+        .context("Making RPC to fetch available scenarios")?;
     if let serde_json::Value::Array(scenarios) = data {
         let mut table = Table::new();
         table.add_row(row!["Scenario", "Description"]);
@@ -50,7 +50,7 @@ async fn handle_available(params: ObjectParams) -> anyhow::Result<()> {
         }
         table.printstd();
     } else {
-        println!("Unexpected response format.");
+        bail!("Unexpected response format.");
     }
     Ok(())
 }
@@ -68,7 +68,7 @@ async fn handle_run(
         .context("Add additional_args to params")?;
     let data = make_rpc_call("scenarios_run", params)
         .await
-        .context("Failed to run scenario")?;
+        .context("Making RPC call to run scenario with remote file")?;
     println!("{:?}", data);
     Ok(())
 }
@@ -82,21 +82,21 @@ async fn handle_run_file(
     let scenario_base64 = general_purpose::STANDARD.encode(file_contents);
     params
         .insert("scenario_base64", scenario_base64)
-        .context("Add scenario to params")?;
+        .context("Adding scenario to params")?;
     params
         .insert("additional_args", additional_args)
-        .context("Add additional_args to params")?;
+        .context("Adding additional_args to params")?;
     let data = make_rpc_call("scenarios_run_file", params)
         .await
-        .context("Failed to run scenario")?;
+        .context("Making RPC call to run scenario with local file")?;
     println!("{:?}", data);
     Ok(())
 }
 
 async fn handle_active(params: ObjectParams) -> anyhow::Result<()> {
     let data = make_rpc_call("scenarios_list_running", params)
         .await
-        .context("Failed to list running scenarios")?;
+        .context("Making RPC call to list running scenarios")?;
     if let serde_json::Value::Array(scenarios) = data {
         let mut table = Table::new();
         table.add_row(row!["PID", "Command", "Network", "Active"]);
@@ -123,7 +123,7 @@ async fn handle_active(params: ObjectParams) -> anyhow::Result<()> {
         }
         table.printstd();
     } else {
-        println!("Unexpected response format.");
+        bail!("Unexpected response format.");
     }
     Ok(())
 }
@@ -132,11 +132,11 @@ async fn handle_stop(mut params: ObjectParams, pid: &u64) -> anyhow::Result<()>
     params.insert("pid", pid).context("Add pid to params")?;
     let data = make_rpc_call("scenarios_stop", params)
         .await
-        .context("Failed to stop running scenario")?;
+        .context("Making RPC call to stop running scenario")?;
     if let serde_json::Value::String(message) = data {
         println!("{}", message);
     } else {
-        println!("Unexpected response format.");
+        bail!("Unexpected response format.");
     }
     Ok(())
 }