dmisys 0.1.0

This is a specialized library designed to output the hardware configuration required by the system, as well as various status information of the current device.
Documentation 
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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224

use std::{
    process::Command,
    fs,
    path::Path
};
use sysinfo::Disks;
use crate::cv;

/// read disk info
fn run_cmd_smartdata(device:&str) -> String {
    let output = Command::new("smartctl")
        .arg("-a")
        .arg(device)
        .output()
        .expect("Failed to execute smartctl");

    String::from_utf8_lossy(&output.stdout).to_string()
}

/// read `samrtctl` command a data
fn run_cmd_smartstatus(device:&str) -> String {
    let output = Command::new("smartctl")
        .arg("-H")   
        .arg(device) 
        .output()
        .expect("Failed to execute smartctl");

    String::from_utf8_lossy(&output.stdout).to_string()
}

fn run_cmd_smartinfo(device: &str) -> String {
    let output = Command::new("smartctl")
        .arg("-i")
        .arg(device)
        .output()
        .expect("Failed to execute smartctl");

    String::from_utf8_lossy(&output.stdout).to_string()
}

/// read this pyhysical disk information
pub fn read_disk_smartinfo(device: &str) -> String {
    let output = run_cmd_smartdata(device);
 
     output
 }

 /// read this pyhysical disk S.M.A.R.T status
pub fn read_disk_smartstatus(device: &str) ->  String {
    let output = run_cmd_smartstatus(device);
    let regex_pattern = r"SMART overall-health self-assessment test result:\s*(\w+)";
    cv::regex_extract(&output,regex_pattern)
}

 /// read this pyhysical disk Rotation Rate
pub fn read_disk_rotationrate(device: &str) ->  String{
    let output = run_cmd_smartinfo(device);
    let regex_pattern = r"Rotation Rate:\s*(.+)";
    cv::regex_extract(&output, regex_pattern)
}

 /// read this pyhysical disk device model
pub fn read_disk_devicemodel(device: &str) -> String {
    let output = run_cmd_smartinfo(device);
    let regex_pattern = r"Device Model:\s*(.+)";
    cv::regex_extract(&output, regex_pattern)
}

 /// read this pyhysical disk firmware version
pub fn read_disk_firmware(device: &str) -> String {
    let output = run_cmd_smartinfo(device);
    let regex_pattern = r"Firmware Version:\s*(.+)";
    cv::regex_extract(&output, regex_pattern)
}

 /// read this pyhysical disk serial number
pub fn read_disk_serial(device: &str) -> String {
    let output = run_cmd_smartinfo(device);
    let regex_pattern = r"Serial Number:\s*(.+)";
    cv::regex_extract(&output, regex_pattern)
}

 /// read this pyhysical disk factor
pub fn read_disk_factor(device: &str) -> String { 
    let output = run_cmd_smartinfo(device);
    let regex_pattern = r"Form Factor:\s*(.+)";
    cv::regex_extract(&output, regex_pattern)
}

 /// read this pyhysical disk sata version
pub fn read_disk_sataver(device: &str) -> String {
    let output = run_cmd_smartinfo(device);
    let regex_pattern = r"SATA Version is:\s*(.+)";
    cv::regex_extract(&output, regex_pattern)
}

 /// read this pyhysical disk total space
pub fn read_disk_totalspace() -> (String, f64) {
    let disks = Disks::new_with_refreshed_list();
    let mut name = String::new(); 
    let mut total_space = 0.0; 

    disks.list().into_iter().for_each(|disk| {
        name = disk.name().to_string_lossy().to_string();
        total_space = cv::bytes_to_gb(disk.total_space()) ; 
    });

    if name.is_empty() {
        name = "Not Found".to_string();
        total_space = 0.0;
    }

    (name, total_space)
}

/// Read disk sector space and return as vector
pub fn read_disk_sectorspace_vec() -> Vec<(String, Option<String>, Option<String>, f64,f64, f64, f64)> {
    let mut disk_info = Vec::new();
    let disks = Disks::new_with_refreshed_list();

    for disk in disks.list() {
        let name = disk.name().to_string_lossy().to_string(); // disk name
        let filesystem = disk.file_system().to_str().map(String::from); // file system
        let mount_point = disk.mount_point().to_str().map(String::from); // mount point
        let total_space = cv::bytes_to_gb(disk.total_space()); // total space
        let used_space = cv::bytes_to_gb(disk.total_space() - disk.available_space()); // used space
        let free_space = cv::bytes_to_gb(disk.available_space()); // free space
        let used_point = cv::percentage_cal(used_space, total_space); // used
       
        if !name.starts_with("overlay") {
            disk_info.push((name, filesystem, mount_point, total_space, used_space,used_point, free_space)); 
        }
    }

    disk_info
}

/// Read disk sector space and return as map
pub fn read_disk_all_vec() -> Vec<(String, f64)> {
    let mut disks_info = Vec::new();
    let block_devices_path = Path::new("/sys/block/");

    if let Ok(entries) = fs::read_dir(block_devices_path) {
        for entry in entries {
            if let Ok(entry) = entry {
                let device_name = entry.file_name().into_string().unwrap();
                
                if !device_name.starts_with("loop") && !device_name.starts_with("ram") {
                    let size_path = block_devices_path.join(&device_name).join("size");
                    if let Ok(size_str) = fs::read_to_string(size_path) {
                        if let Ok(sectors) = size_str.trim().parse::<u64>() {
                            let device_name_str = format!("{}",device_name);
                            let total_size_gb = cv::sectors_to_gb(sectors);
                            disks_info.push((device_name_str, total_size_gb));
                        }
                    }
                }
            }
        }
    }

    if disks_info.is_empty() {
        disks_info.push(("Not Found".to_string(), 0.0));
    }

    disks_info
}

/// Read PyhysicalDrive info and return as vector 
pub fn read_disks_pyhysicaldrive_vec() -> Vec<(String, f64)> {
    let mut disks_info = Vec::new();
    let block_devices_path = Path::new("/sys/block/");
    
    let block_devices_path = Path::new(block_devices_path);
    if let Ok(entries) = fs::read_dir(block_devices_path) {
        for entry in entries {
            if let Ok(entry) = entry {
                let device_name = entry.file_name().into_string().unwrap();

                if device_name.starts_with("nvme") ||  device_name.starts_with("sd") || device_name.starts_with("hd") {
                    let size_path = block_devices_path.join(&device_name).join("size");
                    if let Ok(size_str) = fs::read_to_string(size_path) {
                        if let Ok(sectors) = size_str.trim().parse::<u64>() {
                            let device_name_str = format!("/sys/block/{}",device_name);
                            let total_size_gb = cv::sectors_to_gb(sectors);
                            disks_info.push((device_name_str, total_size_gb));
                        }
                    }
                }
            }
        }
    }

    if disks_info.is_empty() {
        disks_info.push(("Not Found".to_string(), 0.0));
    }

    disks_info
}

/// Read PyhysicalDrive info and return as list
pub fn read_disks_physicaldrive_list() -> Vec<String> {
    let mut disks_info = Vec::new();
    let block_devices_path = Path::new("/sys/block/");

    if let Ok(entries) = fs::read_dir(block_devices_path) {
        for entry in entries {
            if let Ok(entry) = entry {
                let device_name = entry.file_name().into_string().unwrap();
                if device_name.starts_with("nvme") || device_name.starts_with("sd") || device_name.starts_with("hd") {
                    let device_name_str = format!("/dev/{}",device_name);
                    disks_info.push(device_name_str);
                }
            }
        }
    }

    if disks_info.is_empty() {
        disks_info.push("Not Found".to_string());
    }

    disks_info
}