use crate::error::{IronError, Result};
use serde::{Deserialize, Serialize};
use std::path::PathBuf;
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct Config {
pub general: GeneralConfig,
pub gpu: GpuConfig,
pub process: ProcessConfig,
pub chart: ChartConfig,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GeneralConfig {
#[serde(default = "default_update_interval")]
pub update_interval_ms: u32,
#[serde(default)]
pub use_fahrenheit: bool,
#[serde(default = "default_color_scheme")]
pub color_scheme: String,
#[serde(default = "default_encode_decode_timeout")]
pub encode_decode_hiding_timer: u32,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GpuConfig {
#[serde(default)]
pub monitored_gpus: Vec<usize>,
#[serde(default = "default_true")]
pub show_details: bool,
#[serde(default = "default_true")]
pub show_processes: bool,
#[serde(default)]
pub reverse_plot: bool,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ProcessConfig {
#[serde(default = "default_process_columns")]
pub visible_columns: Vec<String>,
#[serde(default = "default_sort_column")]
pub sort_column: String,
#[serde(default)]
pub sort_ascending: bool,
#[serde(default = "default_true")]
pub hide_self: bool,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChartConfig {
#[serde(default = "default_chart_metrics")]
pub metrics: Vec<String>,
#[serde(default = "default_history_length")]
pub history_length: u32,
}
fn default_update_interval() -> u32 {
1000 }
fn default_color_scheme() -> String {
"default".to_string()
}
fn default_encode_decode_timeout() -> u32 {
30 }
fn default_true() -> bool {
true
}
fn default_process_columns() -> Vec<String> {
vec![
"pid".to_string(),
"user".to_string(),
"name".to_string(),
"gpu".to_string(),
"gpu_mem".to_string(),
"cpu".to_string(),
"mem".to_string(),
]
}
fn default_sort_column() -> String {
"gpu_mem".to_string()
}
fn default_chart_metrics() -> Vec<String> {
vec![
"gpu_util".to_string(),
"mem_util".to_string(),
"temperature".to_string(),
"power".to_string(),
]
}
fn default_history_length() -> u32 {
60 }
impl Default for GeneralConfig {
fn default() -> Self {
Self {
update_interval_ms: default_update_interval(),
use_fahrenheit: false,
color_scheme: default_color_scheme(),
encode_decode_hiding_timer: default_encode_decode_timeout(),
}
}
}
impl Default for GpuConfig {
fn default() -> Self {
Self {
monitored_gpus: Vec::new(),
show_details: true,
show_processes: true,
reverse_plot: false,
}
}
}
impl Default for ProcessConfig {
fn default() -> Self {
Self {
visible_columns: default_process_columns(),
sort_column: default_sort_column(),
sort_ascending: false,
hide_self: true,
}
}
}
impl Default for ChartConfig {
fn default() -> Self {
Self {
metrics: default_chart_metrics(),
history_length: default_history_length(),
}
}
}
impl Config {
pub fn default_path() -> Result<PathBuf> {
let config_dir = if cfg!(windows) {
std::env::var("APPDATA")
.map(PathBuf::from)
.unwrap_or_else(|_| PathBuf::from("."))
} else {
std::env::var("HOME")
.map(|home| PathBuf::from(home).join(".config"))
.unwrap_or_else(|_| PathBuf::from(".config"))
};
Ok(config_dir.join("ironmon"))
}
pub fn load() -> Result<Self> {
let config_dir = Self::default_path()?;
let config_file = config_dir.join("config.toml");
let _ = crate::legacy_paths::adopt(&config_file);
if !config_file.exists() {
return Ok(Self::default());
}
let contents = std::fs::read_to_string(&config_file)?;
let config: Config = toml::from_str(&contents)
.map_err(|e| IronError::Parse(format!("Failed to parse config: {}", e)))?;
Ok(config)
}
pub fn load_from(path: &PathBuf) -> Result<Self> {
let contents = std::fs::read_to_string(path)?;
let config: Config = toml::from_str(&contents)
.map_err(|e| IronError::Parse(format!("Failed to parse config: {}", e)))?;
Ok(config)
}
pub fn save(&self) -> Result<()> {
let config_dir = Self::default_path()?;
std::fs::create_dir_all(&config_dir)?;
let config_file = config_dir.join("config.toml");
let contents = toml::to_string_pretty(self)
.map_err(|e| IronError::Other(format!("Failed to serialize config: {}", e)))?;
std::fs::write(&config_file, contents)?;
Ok(())
}
pub fn save_to(&self, path: &PathBuf) -> Result<()> {
let contents = toml::to_string_pretty(self)
.map_err(|e| IronError::Other(format!("Failed to serialize config: {}", e)))?;
std::fs::write(path, contents)?;
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_default_config() {
let config = Config::default();
assert_eq!(config.general.update_interval_ms, 1000);
assert!(!config.general.use_fahrenheit);
assert_eq!(config.general.encode_decode_hiding_timer, 30);
assert!(config.gpu.show_details);
assert!(config.gpu.show_processes);
assert!(config.process.hide_self);
}
#[test]
fn test_config_serialization() {
let config = Config::default();
let toml_str = toml::to_string(&config).unwrap();
let deserialized: Config = toml::from_str(&toml_str).unwrap();
assert_eq!(
config.general.update_interval_ms,
deserialized.general.update_interval_ms
);
assert_eq!(
config.general.use_fahrenheit,
deserialized.general.use_fahrenheit
);
}
}