feat: init cloud-cli

Author: QuakeWang

Cargo.lock

@@ -0,0 +1,15 @@
+[package]
+name = "cloud-cli"
+version = "0.1.0"
+edition = "2024"
+
+[[bin]]
+name = "cloud-cli"
+path = "src/main.rs"
+
+[dependencies]
+anyhow = "1.0"
+chrono = "0.4"
+dialoguer = "0.11"
+console = "0.15"
+wait-timeout = "0.2.1"

Cargo.toml

@@ -0,0 +1,31 @@
+# cloud-cli
+
+`cloud-cli` is a command-line tool designed to simplify the management and diagnosis of server-side applications. It provides an interactive menu to access various diagnostic tools, making it easier for developers and system administrators to troubleshoot processes.
+
+## Features
+
+The tool is organized into two main categories:
+
+### FE (Frontend/Java Applications)
+
+- **`jstack`**: Prints Java thread stack traces for a given Java process, helping to diagnose hangs and deadlocks.
+- **`jmap`**: Generates heap dumps and provides memory statistics for a Java process, useful for analyzing memory leaks.
+
+### BE (Backend/General Processes)
+
+- **`pstack`**: Displays the stack trace for any running process, offering insights into its execution state.
+- **`get_be_vars`**: Retrieves and displays the environment variables of a running process.
+
+## Usage
+
+To run the application, execute the binary. An interactive menu will appear, allowing you to select the desired diagnostic tool.
+
+```sh
+./cloud-cli
+```
+
+## Releases
+
+This project uses GitHub Actions to automatically build and release binaries for Linux (`x86_64` and `aarch64`). When a new version is tagged (e.g., `v1.0.0`), a new release is created.
+
+You can download the latest pre-compiled binaries from the [GitHub Releases](https://github.com/QuakeWang/cloud-cli/releases) page.

README.md

@@ -0,0 +1,166 @@
+use crate::error::{CliError, Result};
+use std::env;
+use std::path::PathBuf;
+
+/// Configuration for the cloud-cli application
+#[derive(Debug, Clone)]
+pub struct Config {
+    pub jdk_path: PathBuf,
+    pub output_dir: PathBuf,
+    pub timeout_seconds: u64,
+    pub no_progress_animation: bool,
+}
+
+// Environment variable names
+const ENV_JDK_PATH: &str = "JDK_PATH";
+const ENV_OUTPUT_DIR: &str = "OUTPUT_DIR";
+const ENV_TIMEOUT: &str = "CLOUD_CLI_TIMEOUT";
+const ENV_NO_PROGRESS: &str = "CLOUD_CLI_NO_PROGRESS";
+
+impl Default for Config {
+    fn default() -> Self {
+        Self {
+            jdk_path: PathBuf::from("/opt/jdk"),
+            output_dir: PathBuf::from("/opt/selectdb/information"),
+            timeout_seconds: 60,
+            no_progress_animation: false,
+        }
+    }
+}
+
+impl Config {
+    /// Creates a new configuration instance from environment variables
+    pub fn new() -> Self {
+        let mut config = Self::default();
+        config.load_from_env();
+        config
+    }
+
+    /// Loads configuration from environment variables
+    fn load_from_env(&mut self) {
+        if let Ok(jdk_path) = env::var(ENV_JDK_PATH) {
+            self.jdk_path = PathBuf::from(jdk_path);
+        }
+
+        if let Ok(output_dir) = env::var(ENV_OUTPUT_DIR) {
+            self.output_dir = PathBuf::from(output_dir);
+        }
+
+        if let Ok(timeout) = env::var(ENV_TIMEOUT) {
+            if let Ok(timeout) = timeout.parse::<u64>() {
+                self.timeout_seconds = timeout;
+            }
+        }
+
+        self.no_progress_animation = env::var(ENV_NO_PROGRESS)
+            .map(|v| v == "1" || v.to_lowercase() == "true")
+            .unwrap_or(false);
+    }
+
+    pub fn with_jdk_path<P: Into<PathBuf>>(mut self, path: P) -> Self {
+        self.jdk_path = path.into();
+        self
+    }
+
+    pub fn with_output_dir<P: Into<PathBuf>>(mut self, path: P) -> Self {
+        self.output_dir = path.into();
+        self
+    }
+
+    pub fn with_timeout(mut self, seconds: u64) -> Self {
+        self.timeout_seconds = seconds;
+        self
+    }
+
+    pub fn with_progress_animation(mut self, enable: bool) -> Self {
+        self.no_progress_animation = !enable;
+        self
+    }
+
+    pub fn validate(&self) -> Result<()> {
+        self.validate_jdk_path()?;
+        self.validate_output_dir()?;
+        self.validate_timeout()?;
+        Ok(())
+    }
+
+    fn validate_jdk_path(&self) -> Result<()> {
+        if !self.jdk_path.exists() {
+            return Err(CliError::ConfigError(format!(
+                "JDK path does not exist: {}. Set {ENV_JDK_PATH} environment variable or ensure default path exists.",
+                self.jdk_path.display()
+            )));
+        }
+
+        let jmap_path = self.get_jmap_path();
+        let jstack_path = self.get_jstack_path();
+
+        if !jmap_path.exists() {
+            return Err(CliError::ConfigError(format!(
+                "jmap not found: {}. Please verify JDK installation.",
+                jmap_path.display()
+            )));
+        }
+
+        if !jstack_path.exists() {
+            return Err(CliError::ConfigError(format!(
+                "jstack not found: {}. Please verify JDK installation.",
+                jstack_path.display()
+            )));
+        }
+
+        Ok(())
+    }
+
+    fn validate_output_dir(&self) -> Result<()> {
+        if self.output_dir.exists() {
+            let test_file = self.output_dir.join(".write_test");
+            match std::fs::File::create(&test_file) {
+                Ok(_) => {
+                    let _ = std::fs::remove_file(test_file);
+                }
+                Err(e) => {
+                    return Err(CliError::ConfigError(format!(
+                        "Output directory is not writable: {}. Error: {e}",
+                        self.output_dir.display()
+                    )));
+                }
+            }
+        }
+        Ok(())
+    }
+
+    fn validate_timeout(&self) -> Result<()> {
+        if self.timeout_seconds == 0 {
+            return Err(CliError::ConfigError("Timeout cannot be zero".to_string()));
+        }
+        if self.timeout_seconds > 3600 {
+            return Err(CliError::ConfigError(
+                "Timeout cannot exceed 3600 seconds (1 hour)".to_string(),
+            ));
+        }
+        Ok(())
+    }
+
+    pub fn ensure_output_dir(&self) -> Result<()> {
+        if let Err(e) = std::fs::create_dir_all(&self.output_dir) {
+            return Err(CliError::ConfigError(format!(
+                "Failed to create output directory: {}. Error: {e}",
+                self.output_dir.display()
+            )));
+        }
+        Ok(())
+    }
+
+    pub fn get_jmap_path(&self) -> PathBuf {
+        self.jdk_path.join("bin/jmap")
+    }
+
+    pub fn get_jstack_path(&self) -> PathBuf {
+        self.jdk_path.join("bin/jstack")
+    }
+
+    pub fn get_timeout_millis(&self) -> u64 {
+        self.timeout_seconds * 1000
+    }
+}

src/config.rs

@@ -0,0 +1,49 @@
+use dialoguer;
+use std::fmt;
+
+#[derive(Debug)]
+pub enum CliError {
+    ProcessNotFound(String),
+    ProcessExecutionFailed(String),
+    ToolExecutionFailed(String),
+    IoError(std::io::Error),
+    InvalidInput(String),
+    ConfigError(String),
+    GracefulExit,
+}
+
+impl fmt::Display for CliError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            CliError::ProcessNotFound(msg) => write!(f, "Process not found: {msg}"),
+            CliError::ProcessExecutionFailed(msg) => write!(f, "Process execution failed: {msg}"),
+            CliError::ToolExecutionFailed(msg) => write!(f, "Tool execution failed: {msg}"),
+            CliError::IoError(err) => write!(f, "IO error: {err}"),
+            CliError::InvalidInput(msg) => write!(f, "Invalid input: {msg}"),
+            CliError::ConfigError(msg) => write!(f, "Configuration error: {msg}"),
+            CliError::GracefulExit => write!(f, "Graceful exit"),
+        }
+    }
+}
+
+impl std::error::Error for CliError {}
+
+impl From<std::io::Error> for CliError {
+    fn from(err: std::io::Error) -> Self {
+        CliError::IoError(err)
+    }
+}
+
+impl From<anyhow::Error> for CliError {
+    fn from(err: anyhow::Error) -> Self {
+        CliError::ToolExecutionFailed(err.to_string())
+    }
+}
+
+impl From<dialoguer::Error> for CliError {
+    fn from(err: dialoguer::Error) -> Self {
+        CliError::InvalidInput(err.to_string())
+    }
+}
+
+pub type Result<T> = std::result::Result<T, CliError>;

src/error.rs

@@ -0,0 +1,74 @@
+use crate::config::Config;
+use crate::error::{CliError, Result};
+use std::process::{Command, Output};
+use std::time::Duration;
+use wait_timeout::ChildExt;
+
+/// Executes a command with standardized error handling
+pub fn execute_command(command: &mut Command, tool_name: &str) -> Result<Output> {
+    let output = command.output().map_err(|e| {
+        CliError::ToolExecutionFailed(format!("Failed to execute {tool_name}: {e}"))
+    })?;
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        let stdout = String::from_utf8_lossy(&output.stdout);
+        let error_msg = if !stderr.is_empty() {
+            stderr.to_string()
+        } else if !stdout.is_empty() {
+            stdout.to_string()
+        } else {
+            format!(
+                "Command failed with exit code: {}",
+                output.status.code().unwrap_or(-1)
+            )
+        };
+        return Err(CliError::ToolExecutionFailed(format!(
+            "{tool_name} failed: {error_msg}"
+        )));
+    }
+
+    Ok(output)
+}
+
+/// Executes a command with timeout based on configuration
+pub fn execute_command_with_timeout(
+    command: &mut Command,
+    tool_name: &str,
+    config: &Config,
+) -> Result<Output> {
+    let mut child = command
+        .spawn()
+        .map_err(|e| CliError::ToolExecutionFailed(format!("Failed to start {tool_name}: {e}")))?;
+
+    let timeout = Duration::from_millis(config.get_timeout_millis());
+
+    match child.wait_timeout(timeout).map_err(|e| {
+        CliError::ToolExecutionFailed(format!("Error waiting for {tool_name} process: {e}"))
+    })? {
+        // Process completed within timeout
+        Some(status) => {
+            if !status.success() {
+                return Err(CliError::ToolExecutionFailed(format!(
+                    "{tool_name} failed with exit code: {}",
+                    status.code().unwrap_or(-1)
+                )));
+            }
+
+            Ok(Output {
+                status,
+                stdout: Vec::new(),
+                stderr: Vec::new(),
+            })
+        }
+        None => {
+            // Kill the process
+            let _ = child.kill();
+
+            Err(CliError::ToolExecutionFailed(format!(
+                "{tool_name} timed out after {} seconds",
+                config.timeout_seconds
+            )))
+        }
+    }
+}