feat: refactor the be http response

Author: QuakeWang

src/tools/common/be_webserver.rs src/tools/be/be_http_client.rssrc/tools/common/be_webserver.rs renamed to src/tools/be/be_http_client.rs

@@ -1,10 +1,10 @@
+use super::BeResponseHandler;
+use super::be_http_client;
 use crate::config::Config;
 use crate::error::{CliError, Result};
-use crate::tools::common::be_webserver;
 use crate::tools::{ExecutionResult, Tool};
 use crate::ui;
 use dialoguer::{Input, theme::ColorfulTheme};
-use std::path::PathBuf;
 
 /// Tool to query BE configuration variables
 pub struct BeVarsTool;
@@ -28,13 +28,16 @@ impl Tool for BeVarsTool {
             "Querying BE for variables matching: '{variable_name}'"
         ));
 
-        let result = be_webserver::request_be_webserver_port("/varz", Some(&variable_name));
-        handle_query_result(&variable_name, result);
+        let result = be_http_client::request_be_webserver_port("/varz", Some(&variable_name));
 
-        Ok(ExecutionResult {
-            output_path: PathBuf::from("console_output"),
-            message: format!("Variable query completed for: {variable_name}"),
-        })
+        let handler = BeResponseHandler {
+            success_message: "Query completed!",
+            empty_warning: "No variables found matching '{}'.",
+            error_context: "Failed to query BE",
+            tips: "Ensure the BE service is running and accessible.",
+        };
+
+        handler.handle_console_result(result, &variable_name)
     }
 
     fn requires_pid(&self) -> bool {
@@ -56,22 +59,3 @@ fn prompt_for_variable_name() -> Result<String> {
         Ok(input)
     }
 }
-
-fn handle_query_result(variable_name: &str, result: Result<String>) {
-    match result {
-        Ok(output) => {
-            ui::print_success("Query completed!");
-            println!();
-            ui::print_info("Results:");
-            if output.is_empty() {
-                ui::print_warning(&format!("No variables found matching '{variable_name}'."));
-            } else {
-                println!("{output}");
-            }
-        }
-        Err(e) => {
-            ui::print_error(&format!("Failed to query BE: {e}."));
-            ui::print_info("Tips: Ensure the BE service is running and accessible.");
-        }
-    }
-}

src/tools/be/be_vars.rs

@@ -1,9 +1,12 @@
 mod be_vars;
+mod be_http_client;
 mod jmap;
-mod pipeline_tasks_tool;
+mod pipeline_tasks;
 mod pstack;
+mod response_handler;
 
 pub use be_vars::BeVarsTool;
 pub use jmap::{JmapDumpTool, JmapHistoTool};
-pub use pipeline_tasks_tool::PipelineTasksTool;
+pub use pipeline_tasks::PipelineTasksTool;
 pub use pstack::PstackTool;
+pub use response_handler::BeResponseHandler;

src/tools/be/mod.rs

@@ -0,0 +1,70 @@
+use super::BeResponseHandler;
+use super::be_http_client;
+use crate::config::Config;
+use crate::error::Result;
+use crate::tools::{ExecutionResult, Tool};
+use crate::ui;
+
+/// Tool to fetch running pipeline tasks from BE node
+pub struct PipelineTasksTool;
+
+impl Tool for PipelineTasksTool {
+    fn name(&self) -> &str {
+        "pipeline-tasks"
+    }
+
+    fn description(&self) -> &str {
+        "Get running pipeline tasks from BE node"
+    }
+
+    fn execute(&self, config: &Config, _pid: u32) -> Result<ExecutionResult> {
+        ui::print_info("Fetching running pipeline tasks from BE...");
+
+        let result = be_http_client::request_be_webserver_port("/api/running_pipeline_tasks", None);
+        
+        let handler = BeResponseHandler {
+            success_message: "Pipeline tasks fetched successfully!",
+            empty_warning: "No running pipeline tasks found.",
+            error_context: "Failed to fetch pipeline tasks",
+            tips: "Ensure the BE service is running and accessible.",
+        };
+        
+        // First check if we have a result
+        match &result {
+            Ok(output) => {
+                if output.len() < 100 || output.lines().count() <= 3 {
+                    return handler.handle_console_result(result, "pipeline tasks");
+                }
+                
+                // Otherwise save to file
+                config.ensure_output_dir()?;
+                handler.handle_file_result(config, result, "pipeline_tasks", get_summary)
+            },
+            Err(_) => {
+                // For errors, just use the standard error handling
+                handler.handle_console_result(result, "pipeline tasks")
+            }
+        }
+    }
+
+    fn requires_pid(&self) -> bool {
+        false
+    }
+}
+
+/// Get a summary of the response data for display in the console
+fn get_summary(data: &str) -> String {
+    if data.trim().is_empty() {
+        return "No running pipeline tasks found.".to_string();
+    }
+
+    // Simple summary: show first few lines
+    let preview_lines: Vec<&str> = data.lines().take(10).collect();
+    let preview = preview_lines.join("\n");
+
+    if data.lines().count() > 10 {
+        format!("{}\n... (more content in output file)", preview)
+    } else {
+        preview
+    }
+}

src/tools/be/pipeline_tasks.rs

@@ -0,0 +1,123 @@
+use crate::config::Config;
+use crate::error::Result;
+use crate::tools::ExecutionResult;
+use crate::ui;
+use std::fs;
+use std::path::PathBuf;
+use chrono::Utc;
+
+/// Configuration for handling BE API responses
+pub struct BeResponseHandler<'a> {
+    pub success_message: &'a str,
+    pub empty_warning: &'a str,
+    pub error_context: &'a str,
+    pub tips: &'a str,
+}
+
+impl<'a> BeResponseHandler<'a> {
+    /// Handle response for console-only output (like be_vars)
+    pub fn handle_console_result(
+        &self,
+        result: Result<String>,
+        context: &str,
+    ) -> Result<ExecutionResult> {
+        match result {
+            Ok(output) => {
+                ui::print_success(self.success_message);
+                println!();
+                ui::print_info("Results:");
+
+                if output.is_empty() {
+                    ui::print_warning(&self.empty_warning.replace("{}", context));
+                } else {
+                    println!("{output}");
+                }
+
+                Ok(ExecutionResult {
+                    output_path: PathBuf::from("console_output"),
+                    message: format!("Query completed for: {context}"),
+                })
+            }
+            Err(e) => {
+                ui::print_error(&format!("{}: {e}.", self.error_context));
+                ui::print_info(&format!("Tips: {}", self.tips));
+                Err(e)
+            }
+        }
+    }
+
+    /// Handle response with file output (like pipeline_tasks)
+    pub fn handle_file_result<F>(
+        &self,
+        config: &Config,
+        result: Result<String>,
+        file_prefix: &str,
+        summary_fn: F,
+    ) -> Result<ExecutionResult>
+    where
+        F: Fn(&str) -> String,
+    {
+        match result {
+            Ok(output) => {
+                ui::print_success(self.success_message);
+                println!();
+                ui::print_info("Results:");
+
+                if output.trim().is_empty() {
+                    ui::print_warning(self.empty_warning);
+
+                    Ok(ExecutionResult {
+                        output_path: PathBuf::from("console_output"),
+                        message: "No data found".to_string(),
+                    })
+                } else {
+                    let timestamp = Utc::now().format("%Y%m%d_%H%M%S");
+
+                    let filename = format!("{}_{}.txt", file_prefix, timestamp);
+                    let output_path = config.output_dir.join(filename);
+
+                    fs::write(&output_path, &output)?;
+
+                    println!("{}", summary_fn(&output));
+
+                    let message = format!(
+                        "{} saved to {}",
+                        file_prefix.replace('_', " ").to_title_case(),
+                        output_path.display()
+                    );
+
+                    Ok(ExecutionResult {
+                        output_path,
+                        message,
+                    })
+                }
+            }
+            Err(e) => {
+                ui::print_error(&format!("{}: {e}.", self.error_context));
+                ui::print_info(&format!("Tips: {}", self.tips));
+                Err(e)
+            }
+        }
+    }
+}
+
+trait ToTitleCase {
+    fn to_title_case(&self) -> String;
+}
+
+impl ToTitleCase for str {
+    fn to_title_case(&self) -> String {
+        self.split_whitespace()
+            .map(|word| {
+                let mut chars = word.chars();
+                match chars.next() {
+                    None => String::new(),
+                    Some(first) => {
+                        first.to_uppercase().collect::<String>() + &chars.as_str().to_lowercase()
+                    }
+                }
+            })
+            .collect::<Vec<_>>()
+            .join(" ")
+    }
+}

src/tools/be/pipeline_tasks_tool.rs

@@ -1,2 +1 @@
-pub mod be_webserver;
 pub mod jmap;