linux-optimizer 0.1.0

Linux system optimizer and performance tuning tool
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

// src/metrics/collector.rs
use sysinfo::System;
use crate::metrics::types::SystemMetrics;
use chrono::Utc;

pub struct MetricsCollector {
    sys: System,
}

impl MetricsCollector {
    pub fn new() -> Self {
        Self {
            sys: System::new_all(),
        }
    }
    
    pub fn collect(&mut self) -> SystemMetrics {
        self.sys.refresh_all();
        
        // Memory metrics (bytes to MB)
        let mem_free_mb = self.sys.free_memory() as f64 / 1024.0 / 1024.0;
        let mem_total_mb = self.sys.total_memory() as f64 / 1024.0 / 1024.0;
        let swap_free_mb = self.sys.free_swap() as f64 / 1024.0 / 1024.0;
        let swap_total_mb = self.sys.total_swap() as f64 / 1024.0 / 1024.0;
        
        // CPU load averages (1, 5, 15 minutes)
        let load_avg = System::load_average();
        let cpu_load_1 = load_avg.one;
        let cpu_load_5 = load_avg.five;
        let cpu_load_15 = load_avg.fifteen;
        
        // Simple disk free space estimate (using df command)
        let (disk_free_gb, disk_total_gb) = Self::get_disk_space();
        
        SystemMetrics {
            timestamp: Utc::now().timestamp(),
            mem_free_mb,
            mem_total_mb,
            swap_free_mb,
            swap_total_mb,
            cpu_load_1,
            cpu_load_5,
            cpu_load_15,
            disk_free_gb,
            disk_total_gb,
        }
    }
    
    fn get_disk_space() -> (f64, f64) {
        // Use df command to get disk space for root partition
        let output = std::process::Command::new("df")
            .args(["-B1", "/"])
            .output();
        
        if let Ok(out) = output {
            if let Ok(stdout) = String::from_utf8(out.stdout) {
                let lines: Vec<&str> = stdout.lines().collect();
                if lines.len() >= 2 {
                    let parts: Vec<&str> = lines[1].split_whitespace().collect();
                    if parts.len() >= 4 {
                        let total = parts[1].parse::<u64>().unwrap_or(0) as f64 / 1024.0 / 1024.0 / 1024.0;
                        let free = parts[3].parse::<u64>().unwrap_or(0) as f64 / 1024.0 / 1024.0 / 1024.0;
                        return (free, total);
                    }
                }
            }
        }
        (0.0, 0.0)
    }
}