Rust in der Linux-Serververwaltung in der Praxis: Aufbau von Hochleistungs-CLI-Tools

cargo new sysmgr
cd sysmgr

[package]
name = "sysmgr"
version = "0.1.0"
edition = "2021"

[dependencies]
# CLI-Framework
clap = { version = "4.5", features = ["derive"] }
# Asynchrone Laufzeit
tokio = { version = "1.40", features = ["full"] }
# Systeminformationen
sysinfo = "0.31"
# Serialisierung
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
# Terminal-UI
crossterm = "0.28"
# Reguläre Ausdrücke
regex = "1.10"
# Zeitbehandlung
chrono = "0.4"
# Protokollierung
tracing = "0.1"
tracing-subscriber = "0.3"
# Fehlerbehandlung
anyhow = "1.0"
thiserror = "1.0"

// src/cli.rs
use clap::{Parser, Subcommand};

#[derive(Parser)]
#[command(name = "sysmgr")]
#[command(about = "Linux-Serververwaltungstool", version)]
pub struct Cli {
    /// Ausführliche Ausgabe aktivieren
    #[arg(short, long, global = true)]
    pub verbose: bool,

    /// Ausgabeformat
    #[arg(short, long, default_value = "table", global = true)]
    pub format: OutputFormat,

    #[command(subcommand)]
    pub command: Commands,
}

#[derive(Subcommand)]
pub enum Commands {
    /// Systeminformationen anzeigen
    Info {
        /// Informationstyp angeben
        #[arg(short, long)]
        section: Option<InfoSection>,
    },
    /// Prozessverwaltung
    Proc {
        #[command(subcommand)]
        action: ProcAction,
    },
    /// Protokollanalyse
    Log {
        /// Protokolldateipfad
        #[arg(short, long)]
        file: String,
        /// Filter-Schlüsselwort
        #[arg(short, long)]
        keyword: Option<String>,
        /// Fehlerstatistiken berechnen
        #[arg(short, long)]
        stats: bool,
    },
    /// Automatisierungsaufgaben
    Cron {
        #[command(subcommand)]
        action: CronAction,
    },
}

#[derive(Clone, Debug, clap::ValueEnum)]
pub enum InfoSection {
    Cpu,
    Memory,
    Disk,
    Network,
    All,
}

#[derive(Clone, Debug, clap::ValueEnum)]
pub enum OutputFormat {
    Table,
    Json,
    Csv,
}

#[derive(Subcommand)]
pub enum ProcAction {
    /// Prozesse auflisten
    List {
        /// Nach Name filtern
        #[arg(short, long)]
        name: Option<String>,
        /// Nach CPU-Auslastung sortieren
        #[arg(long)]
        sort_by_cpu: bool,
    },
    /// Prozess beenden
    Kill {
        /// Prozess-ID
        pid: u32,
        /// Erzwungenes Beenden
        #[arg(short, long)]
        force: bool,
    },
    /// Prozess überwachen
    Watch {
        /// Prozessname
        name: String,
        /// Aktualisierungsintervall (Sekunden)
        #[arg(short, long, default_value = "2")]
        interval: u64,
    },
}

#[derive(Subcommand)]
pub enum CronAction {
    /// Geplante Aufgaben auflisten
    List,
    /// Geplante Aufgabe hinzufügen
    Add {
        /// Cron-Ausdruck
        schedule: String,
        /// Auszuführender Befehl
        command: String,
    },
    /// Geplante Aufgabe entfernen
    Remove {
        /// Aufgaben-ID
        id: u32,
    },
}

// src/main.rs
mod cli;
mod commands;
mod utils;

use anyhow::Result;
use clap::Parser;
use cli::{Cli, Commands};

#[tokio::main]
async fn main() -> Result<()> {
    let cli = Cli::parse();

    // Protokollierung initialisieren
    if cli.verbose {
        tracing_subscriber::fmt()
            .with_max_level(tracing::Level::DEBUG)
            .init();
    }

    match cli.command {
        Commands::Info { section } => {
            commands::info::run(section, &cli.format).await?;
        }
        Commands::Proc { action } => {
            commands::process::run(action, &cli.format).await?;
        }
        Commands::Log { file, keyword, stats } => {
            commands::log::run(&file, keyword.as_deref(), stats, &cli.format).await?;
        }
        Commands::Cron { action } => {
            commands::cron::run(action, &cli.format).await?;
        }
    }

    Ok(())
}

// src/commands/info.rs
use crate::cli::{InfoSection, OutputFormat};
use anyhow::Result;
use sysinfo::System;
use serde::Serialize;

#[derive(Serialize)]
struct SystemInfo {
    hostname: String,
    os: String,
    kernel: String,
    uptime: u64,
    cpu_count: usize,
    cpu_usage: f32,
    total_memory: u64,
    used_memory: u64,
    total_swap: u64,
    used_swap: u64,
}

pub async fn run(section: Option<InfoSection>, format: &OutputFormat) -> Result<()> {
    let mut sys = System::new_all();
    sys.refresh_all();

    let section = section.unwrap_or(InfoSection::All);

    match section {
        InfoSection::Cpu => print_cpu_info(&sys, format),
        InfoSection::Memory => print_memory_info(&sys, format),
        InfoSection::Disk => print_disk_info(format),
        InfoSection::Network => print_network_info(format),
        InfoSection::All => {
            print_cpu_info(&sys, format);
            println!();
            print_memory_info(&sys, format);
            println!();
            print_disk_info(format);
            println!();
            print_network_info(format);
        }
    }

    Ok(())
}

fn print_cpu_info(sys: &System, format: &OutputFormat) {
    let cpu_count = sys.cpus().len();
    let cpu_usage: f32 = sys.cpus().iter().map(|c| c.cpu_usage()).sum::<f32>() / cpu_count as f32;

    match format {
        OutputFormat::Json => {
            let data = serde_json::json!({
                "cpu_count": cpu_count,
                "cpu_usage_percent": cpu_usage,
                "cpu_brand": sys.cpus().first().map(|c| c.brand()).unwrap_or("Unknown"),
            });
            println!("{}", serde_json::to_string_pretty(&data).unwrap());
        }
        _ => {
            println!("=== CPU-Informationen ===");
            println!("Kernanzahl: {}", cpu_count);
            println!("Auslastung: {:.1}%", cpu_usage);
            if let Some(cpu) = sys.cpus().first() {
                println!("Modell: {}", cpu.brand());
            }
        }
    }
}

fn print_memory_info(sys: &System, format: &OutputFormat) {
    let total = sys.total_memory();
    let used = sys.used_memory();
    let total_swap = sys.total_swap();
    let used_swap = sys.used_swap();

    match format {
        OutputFormat::Json => {
            let data = serde_json::json!({
                "total_memory_mb": total / 1024 / 1024,
                "used_memory_mb": used / 1024 / 1024,
                "memory_usage_percent": (used as f64 / total as f64) * 100.0,
                "total_swap_mb": total_swap / 1024 / 1024,
                "used_swap_mb": used_swap / 1024 / 1024,
            });
            println!("{}", serde_json::to_string_pretty(&data).unwrap());
        }
        _ => {
            println!("=== Speicherinformationen ===");
            println!("Gesamtspeicher: {} MB", total / 1024 / 1024);
            println!("Verwendet: {} MB ({:.1}%)", used / 1024 / 1024, (used as f64 / total as f64) * 100.0);
            println!("Gesamt-Swap: {} MB", total_swap / 1024 / 1024);
            println!("Verwendeter Swap: {} MB", used_swap / 1024 / 1024);
        }
    }
}

fn print_disk_info(format: &OutputFormat) {
    use sysinfo::Disks;

    let disks = Disks::new_with_refreshed_list();

    match format {
        OutputFormat::Json => {
            let data: Vec<_> = disks.iter().map(|d| {
                serde_json::json!({
                    "mount_point": d.mount_point().to_string_lossy(),
                    "filesystem": d.file_system().to_string_lossy(),
                    "total_gb": d.total_space() / 1024 / 1024 / 1024,
                    "available_gb": d.available_space() / 1024 / 1024 / 1024,
                })
            }).collect();
            println!("{}", serde_json::to_string_pretty(&data).unwrap());
        }
        _ => {
            println!("=== Festplatteninformationen ===");
            println!("{:<20} {:<10} {:<10} {:<10}", "Einhängepunkt", "Dateisystem", "Gesamt", "Verfügbar");
            for disk in disks.iter() {
                println!("{:<20} {:<10} {:<8} GB  {:<6} GB",
                    disk.mount_point().to_string_lossy(),
                    disk.file_system().to_string_lossy(),
                    disk.total_space() / 1024 / 1024 / 1024,
                    disk.available_space() / 1024 / 1024 / 1024);
            }
        }
    }
}

fn print_network_info(format: &OutputFormat) {
    use sysinfo::Networks;

    let networks = Networks::new_with_refreshed_list();

    match format {
        OutputFormat::Json => {
            let data: Vec<_> = networks.iter().map(|(name, data)| {
                serde_json::json!({
                    "interface": name,
                    "received_mb": data.total_received() / 1024 / 1024,
                    "transmitted_mb": data.total_transmitted() / 1024 / 1024,
                })
            }).collect();
            println!("{}", serde_json::to_string_pretty(&data).unwrap());
        }
        _ => {
            println!("=== Netzwerkinformationen ===");
            println!("{:<15} {:<15} {:<15}", "Schnittstelle", "Empfangen", "Gesendet");
            for (name, data) in networks.iter() {
                println!("{:<15} {:<10} MB  {:<10} MB",
                    name,
                    data.total_received() / 1024 / 1024,
                    data.total_transmitted() / 1024 / 1024);
            }
        }
    }
}

# Kompilieren
cargo build --release

# Alle Systeminformationen anzeigen
./target/release/sysmgr info

# Nur CPU-Informationen anzeigen
./target/release/sysmgr info --section cpu

# JSON-Format-Ausgabe
./target/release/sysmgr info --format json

# Speicherinformationen anzeigen (JSON)
./target/release/sysmgr info --section memory --format json

// src/commands/process.rs
use crate::cli::{ProcAction, OutputFormat};
use anyhow::Result;
use sysinfo::{System, Process, Pid};
use serde::Serialize;

#[derive(Serialize)]
struct ProcessInfo {
    pid: u32,
    name: String,
    cpu_usage: f32,
    memory_mb: u64,
    status: String,
    user: String,
}

pub async fn run(action: ProcAction, format: &OutputFormat) -> Result<()> {
    match action {
        ProcAction::List { name, sort_by_cpu } => {
            list_processes(name, sort_by_cpu, format).await?;
        }
        ProcAction::Kill { pid, force } => {
            kill_process(pid, force).await?;
        }
        ProcAction::Watch { name, interval } => {
            watch_process(name, interval).await?;
        }
    }
    Ok(())
}

async fn list_processes(
    name_filter: Option<String>,
    sort_by_cpu: bool,
    format: &OutputFormat,
) -> Result<()> {
    let mut sys = System::new_all();
    sys.refresh_all();

    let mut processes: Vec<ProcessInfo> = sys.processes().iter().map(|(pid, proc_)| {
        ProcessInfo {
            pid: pid.as_u32(),
            name: proc_.name().to_string_lossy().to_string(),
            cpu_usage: proc_.cpu_usage(),
            memory_mb: proc_.memory() / 1024 / 1024,
            status: format!("{:?}", proc_.status()),
            user: proc_.user_id().map(|u| u.to_string()).unwrap_or_default(),
        }
    }).collect();

    // Filtern
    if let Some(name) = name_filter {
        processes.retain(|p| p.name.to_lowercase().contains(&name.to_lowercase()));
    }

    // Sortieren
    if sort_by_cpu {
        processes.sort_by(|a, b| b.cpu_usage.partial_cmp(&a.cpu_usage).unwrap());
    } else {
        processes.sort_by_key(|p| p.pid);
    }

    // Ausgabe
    match format {
        OutputFormat::Json => {
            println!("{}", serde_json::to_string_pretty(&processes)?);
        }
        OutputFormat::Csv => {
            println!("PID,NAME,CPU%,MEMORY_MB,STATUS,USER");
            for p in &processes {
                println!("{},{},{:.1},{},{},{}", p.pid, p.name, p.cpu_usage, p.memory_mb, p.status, p.user);
            }
        }
        OutputFormat::Table => {
            println!("{:<8} {:<25} {:<8} {:<10} {:<10} {}", "PID", "Name", "CPU%", "Speicher(MB)", "Status", "Benutzer");
            println!("{}", "-".repeat(80));
            for p in processes.iter().take(50) {
                println!("{:<8} {:<25} {:<8.1} {:<10} {:<10} {}",
                    p.pid, truncate(&p.name, 24), p.cpu_usage, p.memory_mb, p.status, p.user);
            }
            println!("\nInsgesamt {} Prozesse", processes.len());
        }
    }

    Ok(())
}

fn truncate(s: &str, max_len: usize) -> String {
    if s.len() > max_len {
        format!("{}...", &s[..max_len - 3])
    } else {
        s.to_string()
    }
}

async fn kill_process(pid: u32, force: bool) -> Result<()> {
    let mut sys = System::new();
    sys.refresh_processes(sysinfo::ProcessesToUpdate::All, true);

    let pid = Pid::from(pid as usize);

    if let Some(process) = sys.process(pid) {
        if force {
            process.kill();
            println!("Prozess {} erzwungen beendet ({})", pid, process.name().to_string_lossy());
        } else {
            // SIGTERM senden
            #[cfg(unix)]
            {
                use std::process::Command;
                Command::new("kill").arg(pid.to_string()).output()?;
                println!("TERM-Signal an Prozess {} gesendet ({})", pid, process.name().to_string_lossy());
            }
        }
    } else {
        println!("Prozess {} nicht gefunden", pid);
    }

    Ok(())
}

async fn watch_process(name: String, interval: u64) -> Result<()> {
    use std::time::Duration;

    println!("Überwache Prozess: {} (alle {} Sekunden aktualisieren, Strg+C zum Beenden)", name, interval);

    loop {
        let mut sys = System::new();
        sys.refresh_processes(sysinfo::ProcessesToUpdate::All, true);

        let matched: Vec<_> = sys.processes().iter()
            .filter(|(_, p)| p.name().to_string_lossy().to_lowercase().contains(&name.to_lowercase()))
            .collect();

        // Bildschirm löschen
        print!("\x1B[2J\x1B[1;1H");
        println!("=== Prozessmonitor: {} ===", name);
        println!("Zeit: {}", chrono::Local::now().format("%Y-%m-%d %H:%M:%S"));
        println!();

        if matched.is_empty() {
            println!("Keine Prozesse gefunden, die mit '{}' übereinstimmen", name);
        } else {
            println!("{:<8} {:<25} {:<8} {:<10}", "PID", "Name", "CPU%", "Speicher(MB)");
            println!("{}", "-".repeat(55));
            for (pid, proc_) in &matched {
                println!("{:<8} {:<25} {:<8.1} {:<10}",
                    pid, proc_.name().to_string_lossy(),
                    proc_.cpu_usage(),
                    proc_.memory() / 1024 / 1024);
            }
        }

        tokio::time::sleep(Duration::from_secs(interval)).await;
    }
}

# Alle Prozesse auflisten
./target/release/sysmgr proc list

# Nach CPU-Auslastung sortieren
./target/release/sysmgr proc list --sort-by-cpu

# Bestimmten Prozess filtern
./target/release/sysmgr proc list --name nginx

# JSON-Format-Ausgabe
./target/release/sysmgr proc list --format json

# Prozess beenden
./target/release/sysmgr proc kill 1234

# Erzwungen beenden
./target/release/sysmgr proc kill 1234 --force

# Prozess überwachen
./target/release/sysmgr proc watch nginx --interval 5

// src/commands/log.rs
use crate::cli::OutputFormat;
use anyhow::Result;
use regex::Regex;
use serde::Serialize;
use std::collections::HashMap;
use std::fs::File;
use std::io::{BufRead, BufReader};

#[derive(Serialize)]
struct LogStats {
    total_lines: usize,
    error_count: usize,
    warn_count: usize,
    info_count: usize,
    debug_count: usize,
    errors_per_hour: HashMap<String, usize>,
}

pub async fn run(
    file: &str,
    keyword: Option<&str>,
    stats: bool,
    format: &OutputFormat,
) -> Result<()> {
    let file = File::open(file)?;
    let reader = BufReader::new(file);

    if stats {
        analyze_stats(reader, format)?;
    } else if let Some(kw) = keyword {
        filter_lines(reader, kw, format)?;
    } else {
        println!("Bitte geben Sie --keyword oder --stats Argument an");
    }

    Ok(())
}

fn analyze_stats(reader: BufReader<File>, format: &OutputFormat) -> Result<()> {
    let mut stats = LogStats {
        total_lines: 0,
        error_count: 0,
        warn_count: 0,
        info_count: 0,
        debug_count: 0,
        errors_per_hour: HashMap::new(),
    };

    // Regex: Zeitstempel und Protokollebene abgleichen
    let re = Regex::new(r"(?P<timestamp>\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}).*(?P<level>ERROR|WARN|INFO|DEBUG)")?;

    for line in reader.lines() {
        let line = line?;
        stats.total_lines += 1;

        if let Some(caps) = re.captures(&line) {
            let level = caps.name("level").unwrap().as_str();
            let timestamp = caps.name("timestamp").unwrap().as_str();

            match level {
                "ERROR" => {
                    stats.error_count += 1;
                    // Stunde extrahieren
                    if let Some(hour) = timestamp.get(11..13) {
                        *stats.errors_per_hour.entry(hour.to_string()).or_insert(0) += 1;
                    }
                }
                "WARN" => stats.warn_count += 1,
                "INFO" => stats.info_count += 1,
                "DEBUG" => stats.debug_count += 1,
                _ => {}
            }
        }
    }

    match format {
        OutputFormat::Json => {
            println!("{}", serde_json::to_string_pretty(&stats)?);
        }
        _ => {
            println!("=== Protokollstatistiken ===");
            println!("Gesamtzeilen: {}", stats.total_lines);
            println!("ERROR: {}", stats.error_count);
            println!("WARN: {}", stats.warn_count);
            println!("INFO: {}", stats.info_count);
            println!("DEBUG: {}", stats.debug_count);

            if !stats.errors_per_hour.is_empty() {
                println!("\n=== Fehlerverteilung nach Stunde ===");
                let mut hours: Vec<_> = stats.errors_per_hour.iter().collect();
                hours.sort_by_key(|(h, _)| h.clone());
                for (hour, count) in hours {
                    println!("{}:00 - {} Fehler", hour, count);
                }
            }
        }
    }

    Ok(())
}

fn filter_lines(reader: BufReader<File>, keyword: &str, format: &OutputFormat) -> Result<()> {
    let re = Regex::new(&format!("(?i){}", regex::escape(keyword)))?;
    let mut count = 0;

    for line in reader.lines() {
        let line = line?;
        if re.is_match(&line) {
            count += 1;
            match format {
                OutputFormat::Json => {
                    println!("{}", serde_json::json!({"line": count, "content": line}));
                }
                _ => {
                    println!("{}", line);
                }
            }
        }
    }

    eprintln!("\n{} übereinstimmende Zeilen gefunden", count);
    Ok(())
}

# Protokoll analysieren
./target/release/sysmgr log --file /var/log/syslog --stats

# JSON-Format-Statistiken
./target/release/sysmgr log --file /var/log/syslog --stats --format json

# Schlüsselwort filtern
./target/release/sysmgr log --file /var/log/syslog --keyword "error"

# Filtern und JSON ausgeben
./target/release/sysmgr log --file /var/log/syslog --keyword "failed" --format json

// src/commands/cron.rs
use crate::cli::{CronAction, OutputFormat};
use anyhow::Result;
use serde::{Deserialize, Serialize};
use std::fs;
use std::path::PathBuf;

#[derive(Serialize, Deserialize, Debug)]
struct CronJob {
    id: u32,
    schedule: String,
    command: String,
    enabled: bool,
}

#[derive(Serialize, Deserialize, Debug, Default)]
struct CronConfig {
    jobs: Vec<CronJob>,
}

fn config_path() -> PathBuf {
    let home = std::env::var("HOME").unwrap_or_else(|_| ".".to_string());
    PathBuf::from(home).join(".sysmgr").join("cron.json")
}

fn load_config() -> Result<CronConfig> {
    let path = config_path();
    if !path.exists() {
        return Ok(CronConfig::default());
    }
    let content = fs::read_to_string(path)?;
    Ok(serde_json::from_str(&content)?)
}

fn save_config(config: &CronConfig) -> Result<()> {
    let path = config_path();
    if let Some(parent) = path.parent() {
        fs::create_dir_all(parent)?;
    }
    fs::write(path, serde_json::to_string_pretty(config)?)?;
    Ok(())
}

pub async fn run(action: CronAction, format: &OutputFormat) -> Result<()> {
    match action {
        CronAction::List => {
            let config = load_config()?;
            match format {
                OutputFormat::Json => {
                    println!("{}", serde_json::to_string_pretty(&config.jobs)?);
                }
                _ => {
                    println!("{:<5} {:<20} {:<40} {:<8}", "ID", "Zeitplan", "Befehl", "Status");
                    println!("{}", "-".repeat(75));
                    for job in &config.jobs {
                        let status = if job.enabled { "Aktiviert" } else { "Deaktiviert" };
                        println!("{:<5} {:<20} {:<40} {:<8}", job.id, job.schedule, job.command, status);
                    }
                }
            }
        }
        CronAction::Add { schedule, command } => {
            let mut config = load_config()?;
            let new_id = config.jobs.iter().map(|j| j.id).max().unwrap_or(0) + 1;
            config.jobs.push(CronJob {
                id: new_id,
                schedule,
                command,
                enabled: true,
            });
            save_config(&config)?;
            println!("Aufgabe ID {} hinzugefügt", new_id);
        }
        CronAction::Remove { id } => {
            let mut config = load_config()?;
            let initial_len = config.jobs.len();
            config.jobs.retain(|j| j.id != id);
            if config.jobs.len() == initial_len {
                println!("Aufgabe ID nicht gefunden: {}", id);
            } else {
                save_config(&config)?;
                println!("Aufgabe ID {} entfernt", id);
            }
        }
    }
    Ok(())
}

# Geplante Aufgabe hinzufügen
./target/release/sysmgr cron add "0 */6 * * *" "/usr/bin/backup.sh"

# Alle Aufgaben auflisten
./target/release/sysmgr cron list

# JSON-Format-Liste
./target/release/sysmgr cron list --format json

# Aufgabe entfernen
./target/release/sysmgr cron remove 1

# Für Linux x86_64 kompilieren
cargo build --release --target x86_64-unknown-linux-gnu

# Für Linux ARM64 kompilieren
cargo build --release --target aarch64-unknown-linux-gnu

# Für macOS kompilieren
cargo build --release --target x86_64-apple-darwin

# Für Windows kompilieren
cargo build --release --target x86_64-pc-windows-gnu

# musl für statische Verknüpfung verwenden
rustup target add x86_64-unknown-linux-musl
cargo build --release --target x86_64-unknown-linux-musl

# Generierte Binärdatei kann auf jeder Linux-Distribution ausgeführt werden
ls -lh target/x86_64-unknown-linux-musl/release/sysmgr

# Als Debian-Paket mit cargo-deb paketieren
cargo install cargo-deb
cargo deb

# Als RPM mit cargo-generate-rpm paketieren
cargo install cargo-generate-rpm
cargo generate-rpm

# tar.gz-Verteilungspaket generieren
tar -czvf sysmgr-0.1.0-linux-x86_64.tar.gz \
    -C target/release sysmgr

# Cargo.toml
[profile.release]
opt-level = 3
lto = true
codegen-units = 1
panic = "abort"
strip = true

// src/main.rs
#[global_allocator]
static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;

use tokio::io::AsyncBufReadExt;

async fn process_large_log(path: &str) -> Result<()> {
    let file = tokio::fs::File::open(path).await?;
    let reader = tokio::io::BufReader::new(file);
    let mut lines = reader.lines();

    while let Some(line) = lines.next_line().await? {
        // Jede Zeile verarbeiten
    }
    Ok(())
}