use super::{sudo_command, sudo_failure, verify_sudo_available};
use crate::error::{IronError, Result};
use std::process::Command;
#[derive(Debug, Clone)]
pub struct PowerMode {
pub id: u32,
pub name: String,
pub is_default: bool,
}
#[derive(Debug, Clone)]
pub struct NVPModelStatus {
pub current: PowerMode,
pub modes: Vec<PowerMode>,
pub default: PowerMode,
}
pub fn is_available() -> bool {
Command::new("which")
.arg("nvpmodel")
.output()
.map(|o| o.status.success())
.unwrap_or(false)
}
pub fn query() -> Result<PowerMode> {
let output = Command::new("nvpmodel")
.arg("-q")
.output()
.map_err(IronError::Io)?;
if !output.status.success() {
return Err(IronError::CommandFailed(
"nvpmodel query failed".to_string(),
));
}
let stdout = String::from_utf8_lossy(&output.stdout);
let mut name = String::new();
let mut id = 0u32;
for (idx, line) in stdout.lines().enumerate() {
if line.contains("NV Power Mode:") {
name = line.split(':').nth(1).unwrap_or("").trim().to_string();
if let Some(next_line) = stdout.lines().nth(idx + 1) {
id = next_line.trim().parse().unwrap_or(0);
}
break;
}
}
Ok(PowerMode {
id,
name,
is_default: false,
})
}
pub fn list_modes() -> Result<NVPModelStatus> {
let output = Command::new("nvpmodel")
.arg("-p")
.arg("--verbose")
.output()
.map_err(IronError::Io)?;
if !output.status.success() {
return Err(IronError::CommandFailed("nvpmodel list failed".to_string()));
}
let stdout = String::from_utf8_lossy(&output.stdout);
let mut modes = Vec::new();
let mut default = PowerMode {
id: 0,
name: String::new(),
is_default: true,
};
for line in stdout.lines() {
if line.contains("PM_CONFIG: DEFAULT=") {
if let Some(default_str) = line.split("DEFAULT=").nth(1) {
if let Some(name_part) = default_str.split('(').next() {
default.name = name_part.to_string();
}
if let Some(id_part) = default_str.split('(').nth(1) {
if let Some(id_str) = id_part.split(')').next() {
default.id = id_str.parse().unwrap_or(0);
}
}
}
}
if line.contains("POWER_MODEL: ID=") {
let mut mode_id = 0u32;
let mut mode_name = String::new();
if let Some(id_str) = line.split("ID=").nth(1) {
if let Some(id_part) = id_str.split_whitespace().next() {
mode_id = id_part.parse().unwrap_or(0);
}
}
if let Some(name_str) = line.split("NAME=").nth(1) {
mode_name = name_str.trim().to_string();
}
modes.push(PowerMode {
id: mode_id,
name: mode_name,
is_default: mode_id == default.id,
});
}
}
let current = query()?;
Ok(NVPModelStatus {
current,
modes,
default,
})
}
pub fn set_mode(mode_id: u32, force: bool) -> Result<()> {
verify_sudo_available()?;
let mut cmd = sudo_command();
cmd.arg("nvpmodel").arg("-m").arg(mode_id.to_string());
let output = if force {
cmd.arg("-f").output()
} else {
cmd.output()
}
.map_err(IronError::Io)?;
if !output.status.success() {
return Err(sudo_failure(&output, "set power mode"));
}
let stdout = String::from_utf8_lossy(&output.stdout);
if stdout.contains("NVPM ERROR") {
return Err(IronError::CommandFailed(
"nvpmodel reported an error".to_string(),
));
}
Ok(())
}
pub fn set_mode_by_name(mode_name: &str, force: bool) -> Result<()> {
let status = list_modes()?;
let mode = status
.modes
.iter()
.find(|m| m.name.eq_ignore_ascii_case(mode_name))
.ok_or_else(|| IronError::InvalidValue(format!("Power mode '{}' not found", mode_name)))?;
set_mode(mode.id, force)
}