NationTech/harmony
6
0
Fork 1
Code Issues 32 Pull Requests 6 Actions 7 Packages Projects Releases 1 Wiki Activity

chore(inventory_agent): Cargo fmt
Some checks failed
Run Check Script / check (pull_request) Failing after 24s
Details

Browse Source
This commit is contained in:
Jean-Gabriel Gill-Couture 2025-08-19 12:44:49 -04:00
parent 19cb7f73bc
commit 01da8631da
1 changed files with 181 additions and 179 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

360
harmony_inventory_agent/src/hwinfo.rs
View File

@ -115,82 +115,79 @@ impl PhysicalHost {
]) ])
.output() .output()
&& output.status.success() && output.status.success()
&& let Ok(json) = serde_json::from_slice::<Value>(&output.stdout) && let Ok(json) = serde_json::from_slice::<Value>(&output.stdout)
&& let Some(blockdevices) = json.get("blockdevices").and_then(|v| v.as_array()) && let Some(blockdevices) = json.get("blockdevices").and_then(|v| v.as_array())
{ {
for device in blockdevices { for device in blockdevices {
let name = device let name = device
.get("name") .get("name")
.and_then(|v| v.as_str()) .and_then(|v| v.as_str())
.unwrap_or("") .unwrap_or("")
.to_string(); .to_string();
if name.is_empty() { if name.is_empty() {
continue; continue;
} }
let model = device let model = device
.get("model") .get("model")
.and_then(|v| v.as_str()) .and_then(|v| v.as_str())
.map(|s| s.trim().to_string()) .map(|s| s.trim().to_string())
.unwrap_or_default(); .unwrap_or_default();
let serial = device let serial = device
.get("serial") .get("serial")
.and_then(|v| v.as_str()) .and_then(|v| v.as_str())
.map(|s| s.trim().to_string()) .map(|s| s.trim().to_string())
.unwrap_or_default(); .unwrap_or_default();
let size_str = let size_str = device.get("size").and_then(|v| v.as_str()).unwrap_or("0");
device.get("size").and_then(|v| v.as_str()).unwrap_or("0"); let size_bytes = Self::parse_size(size_str).unwrap_or(0);
let size_bytes = Self::parse_size(size_str).unwrap_or(0);
let rotational = device let rotational = device
.get("rota") .get("rota")
.and_then(|v| v.as_bool()) .and_then(|v| v.as_bool())
.unwrap_or(false); .unwrap_or(false);
let wwn = device let wwn = device
.get("wwn") .get("wwn")
.and_then(|v| v.as_str()) .and_then(|v| v.as_str())
.map(|s| s.trim().to_string()) .map(|s| s.trim().to_string())
.filter(|s| !s.is_empty() && s != "null"); .filter(|s| !s.is_empty() && s != "null");
let device_path = Path::new("/sys/block").join(&name); let device_path = Path::new("/sys/block").join(&name);
let mut drive = StorageDrive { let mut drive = StorageDrive {
name: name.clone(), name: name.clone(),
model, model,
serial, serial,
size_bytes, size_bytes,
logical_block_size: Self::read_sysfs_u32( logical_block_size: Self::read_sysfs_u32(
&device_path.join("queue/logical_block_size"), &device_path.join("queue/logical_block_size"),
) )
.unwrap_or(512), .unwrap_or(512),
physical_block_size: Self::read_sysfs_u32( physical_block_size: Self::read_sysfs_u32(
&device_path.join("queue/physical_block_size"), &device_path.join("queue/physical_block_size"),
) )
.unwrap_or(512), .unwrap_or(512),
rotational, rotational,
wwn, wwn,
interface_type: Self::get_interface_type(&name, &device_path), interface_type: Self::get_interface_type(&name, &device_path),
smart_status: Self::get_smart_status(&name), smart_status: Self::get_smart_status(&name),
}; };
// Enhance with additional sysfs info if available // Enhance with additional sysfs info if available
if device_path.exists() { if device_path.exists() {
if drive.model.is_empty() { if drive.model.is_empty() {
drive.model = drive.model = Self::read_sysfs_string(&device_path.join("device/model"));
Self::read_sysfs_string(&device_path.join("device/model"));
}
if drive.serial.is_empty() {
drive.serial =
Self::read_sysfs_string(&device_path.join("device/serial"));
}
}
drives.push(drive);
}
} }
if drive.serial.is_empty() {
drive.serial = Self::read_sysfs_string(&device_path.join("device/serial"));
}
}
drives.push(drive);
}
}
drives drives
} }
@ -206,55 +203,58 @@ impl PhysicalHost {
.args(["-nn", "-d", "::0100", "-J"]) // Storage controllers class with JSON .args(["-nn", "-d", "::0100", "-J"]) // Storage controllers class with JSON
.output() .output()
&& output.status.success() && output.status.success()
&& let Ok(json) = serde_json::from_slice::<Value>(&output.stdout) && let Ok(json) = serde_json::from_slice::<Value>(&output.stdout)
&& let Some(devices) = json.as_array() { && let Some(devices) = json.as_array()
for device in devices { {
if let Some(device_info) = device.as_object() for device in devices {
&& let Some(name) = device_info if let Some(device_info) = device.as_object()
.get("device") && let Some(name) = device_info
.and_then(|v| v.as_object()) .get("device")
.and_then(|v| v.get("name")) .and_then(|v| v.as_object())
.and_then(|v| v.as_str()) .and_then(|v| v.get("name"))
{ .and_then(|v| v.as_str())
controller.name = name.to_string(); {
break; controller.name = name.to_string();
} break;
} }
} }
}
// Fallback to text output if JSON fails // Fallback to text output if JSON fails
if controller.name == "Unknown" if controller.name == "Unknown"
&& let Ok(output) = Command::new("lspci") && let Ok(output) = Command::new("lspci")
.args(["-nn", "-d", "::0100"]) // Storage controllers class .args(["-nn", "-d", "::0100"]) // Storage controllers class
.output() .output()
&& output.status.success() { && output.status.success()
let output_str = String::from_utf8_lossy(&output.stdout); {
if let Some(line) = output_str.lines().next() { let output_str = String::from_utf8_lossy(&output.stdout);
let parts: Vec<&str> = line.split(':').collect(); if let Some(line) = output_str.lines().next() {
if parts.len() > 2 { let parts: Vec<&str> = line.split(':').collect();
controller.name = parts[2].trim().to_string(); if parts.len() > 2 {
} controller.name = parts[2].trim().to_string();
}
} }
}
}
// Try to get driver info from lsmod // Try to get driver info from lsmod
if let Ok(output) = Command::new("lsmod").output() if let Ok(output) = Command::new("lsmod").output()
&& output.status.success() { && output.status.success()
let output_str = String::from_utf8_lossy(&output.stdout); {
for line in output_str.lines() { let output_str = String::from_utf8_lossy(&output.stdout);
if line.contains("ahci") for line in output_str.lines() {
|| line.contains("nvme") if line.contains("ahci")
|| line.contains("megaraid") || line.contains("nvme")
|| line.contains("mpt3sas") || line.contains("megaraid")
{ || line.contains("mpt3sas")
let parts: Vec<&str> = line.split_whitespace().collect(); {
if !parts.is_empty() { let parts: Vec<&str> = line.split_whitespace().collect();
controller.driver = parts[0].to_string(); if !parts.is_empty() {
break; controller.driver = parts[0].to_string();
} break;
} }
} }
} }
}
controller controller
} }
@ -263,53 +263,55 @@ impl PhysicalHost {
let mut modules = Vec::new(); let mut modules = Vec::new();
if let Ok(output) = Command::new("dmidecode").arg("--type").arg("17").output() if let Ok(output) = Command::new("dmidecode").arg("--type").arg("17").output()
&& output.status.success() { && output.status.success()
let output_str = String::from_utf8_lossy(&output.stdout); {
let sections: Vec<&str> = output_str.split("Memory Device").collect(); let output_str = String::from_utf8_lossy(&output.stdout);
let sections: Vec<&str> = output_str.split("Memory Device").collect();
for section in sections.into_iter().skip(1) { for section in sections.into_iter().skip(1) {
let mut module = MemoryModule { let mut module = MemoryModule {
size_bytes: 0, size_bytes: 0,
speed_mhz: None, speed_mhz: None,
manufacturer: None, manufacturer: None,
part_number: None, part_number: None,
serial_number: None, serial_number: None,
rank: None, rank: None,
}; };
for line in section.lines() { for line in section.lines() {
let line = line.trim(); let line = line.trim();
if let Some(size_str) = line.strip_prefix("Size: ") { if let Some(size_str) = line.strip_prefix("Size: ") {
if size_str != "No Module Installed" if size_str != "No Module Installed"
&& let Some((num, unit)) = size_str.split_once(' ') && let Some((num, unit)) = size_str.split_once(' ')
&& let Ok(num) = num.parse::<u64>() { && let Ok(num) = num.parse::<u64>()
module.size_bytes = match unit { {
"MB" => num * 1024 * 1024, module.size_bytes = match unit {
"GB" => num * 1024 * 1024 * 1024, "MB" => num * 1024 * 1024,
"KB" => num * 1024, "GB" => num * 1024 * 1024 * 1024,
_ => 0, "KB" => num * 1024,
}; _ => 0,
} };
} else if let Some(speed_str) = line.strip_prefix("Speed: ") {
if let Some((num, _unit)) = speed_str.split_once(' ') {
module.speed_mhz = num.parse().ok();
}
} else if let Some(man) = line.strip_prefix("Manufacturer: ") {
module.manufacturer = Some(man.to_string());
} else if let Some(part) = line.strip_prefix("Part Number: ") {
module.part_number = Some(part.to_string());
} else if let Some(serial) = line.strip_prefix("Serial Number: ") {
module.serial_number = Some(serial.to_string());
} else if let Some(rank) = line.strip_prefix("Rank: ") {
module.rank = rank.parse().ok();
} }
} } else if let Some(speed_str) = line.strip_prefix("Speed: ") {
if let Some((num, _unit)) = speed_str.split_once(' ') {
if module.size_bytes > 0 { module.speed_mhz = num.parse().ok();
modules.push(module); }
} else if let Some(man) = line.strip_prefix("Manufacturer: ") {
module.manufacturer = Some(man.to_string());
} else if let Some(part) = line.strip_prefix("Part Number: ") {
module.part_number = Some(part.to_string());
} else if let Some(serial) = line.strip_prefix("Serial Number: ") {
module.serial_number = Some(serial.to_string());
} else if let Some(rank) = line.strip_prefix("Rank: ") {
module.rank = rank.parse().ok();
} }
} }
if module.size_bytes > 0 {
modules.push(module);
}
} }
}
modules modules
} }
@ -518,51 +520,51 @@ impl PhysicalHost {
.args(["-j", "-4", "addr", "show", iface_name]) .args(["-j", "-4", "addr", "show", iface_name])
.output() .output()
&& output.status.success() && output.status.success()
&& let Ok(json) = serde_json::from_slice::<Value>(&output.stdout) && let Ok(json) = serde_json::from_slice::<Value>(&output.stdout)
&& let Some(addrs) = json.as_array() { && let Some(addrs) = json.as_array()
for addr_info in addrs { {
if let Some(addr_info_obj) = addr_info.as_object() for addr_info in addrs {
&& let Some(addr_info) = if let Some(addr_info_obj) = addr_info.as_object()
addr_info_obj.get("addr_info").and_then(|v| v.as_array()) && let Some(addr_info) =
{ addr_info_obj.get("addr_info").and_then(|v| v.as_array())
for addr in addr_info { {
if let Some(addr_obj) = addr.as_object() for addr in addr_info {
&& let Some(ip) = if let Some(addr_obj) = addr.as_object()
addr_obj.get("local").and_then(|v| v.as_str()) && let Some(ip) = addr_obj.get("local").and_then(|v| v.as_str())
{ {
ipv4.push(ip.to_string()); ipv4.push(ip.to_string());
}
}
}
} }
} }
}
}
}
// Get IPv6 addresses using JSON output // Get IPv6 addresses using JSON output
if let Ok(output) = Command::new("ip") if let Ok(output) = Command::new("ip")
.args(["-j", "-6", "addr", "show", iface_name]) .args(["-j", "-6", "addr", "show", iface_name])
.output() .output()
&& output.status.success() && output.status.success()
&& let Ok(json) = serde_json::from_slice::<Value>(&output.stdout) && let Ok(json) = serde_json::from_slice::<Value>(&output.stdout)
&& let Some(addrs) = json.as_array() { && let Some(addrs) = json.as_array()
for addr_info in addrs { {
if let Some(addr_info_obj) = addr_info.as_object() for addr_info in addrs {
&& let Some(addr_info) = if let Some(addr_info_obj) = addr_info.as_object()
addr_info_obj.get("addr_info").and_then(|v| v.as_array()) && let Some(addr_info) =
{ addr_info_obj.get("addr_info").and_then(|v| v.as_array())
for addr in addr_info { {
if let Some(addr_obj) = addr.as_object() for addr in addr_info {
&& let Some(ip) = if let Some(addr_obj) = addr.as_object()
addr_obj.get("local").and_then(|v| v.as_str()) && let Some(ip) = addr_obj.get("local").and_then(|v| v.as_str())
{ {
// Skip link-local addresses // Skip link-local addresses
if !ip.starts_with("fe80::") { if !ip.starts_with("fe80::") {
ipv6.push(ip.to_string()); ipv6.push(ip.to_string());
} }
}
}
}
} }
} }
}
}
}
(ipv4, ipv6) (ipv4, ipv6)
} }