2022-08-10 01:56:22 +01:00
|
|
|
use std::convert::Into;
|
|
|
|
use std::path::PathBuf;
|
|
|
|
use std::sync::{Arc, Mutex};
|
2022-07-30 21:33:31 +01:00
|
|
|
|
2022-08-10 01:56:22 +01:00
|
|
|
use super::{Battery, Cpu, Gpu};
|
|
|
|
use super::{OnResume, OnSet, SettingError};
|
|
|
|
use crate::persist::{CpuJson, SettingsJson};
|
|
|
|
use crate::utility::unwrap_lock;
|
2022-07-30 21:33:31 +01:00
|
|
|
|
|
|
|
const LATEST_VERSION: u64 = 0;
|
|
|
|
|
2022-08-10 01:56:22 +01:00
|
|
|
#[derive(Debug, Clone, Copy)]
|
|
|
|
pub enum SettingVariant {
|
|
|
|
Battery,
|
|
|
|
Cpu,
|
|
|
|
Gpu,
|
|
|
|
General,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl std::fmt::Display for SettingVariant {
|
|
|
|
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
|
|
|
|
match self {
|
|
|
|
Self::Battery => write!(f, "Battery"),
|
|
|
|
Self::Cpu => write!(f, "CPU"),
|
|
|
|
Self::Gpu => write!(f, "GPU"),
|
|
|
|
Self::General => write!(f, "General"),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-07-30 21:33:31 +01:00
|
|
|
#[derive(Debug, Clone)]
|
2022-08-10 01:56:22 +01:00
|
|
|
pub struct General {
|
2022-07-30 21:33:31 +01:00
|
|
|
pub persistent: bool,
|
2022-08-10 01:56:22 +01:00
|
|
|
pub path: PathBuf,
|
|
|
|
pub name: String,
|
2022-07-30 21:33:31 +01:00
|
|
|
}
|
|
|
|
|
2022-08-26 22:00:43 +01:00
|
|
|
impl OnSet for General {
|
|
|
|
fn on_set(&mut self) -> Result<(), SettingError> {
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-08-10 01:56:22 +01:00
|
|
|
#[derive(Debug, Clone)]
|
|
|
|
pub struct Settings {
|
|
|
|
pub general: Arc<Mutex<General>>,
|
|
|
|
pub cpus: Arc<Mutex<Vec<Cpu>>>,
|
|
|
|
pub gpu: Arc<Mutex<Gpu>>,
|
|
|
|
pub battery: Arc<Mutex<Battery>>,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl OnSet for Settings {
|
|
|
|
fn on_set(&mut self) -> Result<(), SettingError> {
|
|
|
|
unwrap_lock(self.battery.lock(), "battery").on_set()?;
|
|
|
|
{
|
|
|
|
// cpu lock scope
|
|
|
|
let mut cpu_lock = unwrap_lock(self.cpus.lock(), "cpu");
|
|
|
|
for cpu in cpu_lock.iter_mut() {
|
|
|
|
cpu.on_set()?;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
unwrap_lock(self.gpu.lock(), "gpu").on_set()?;
|
2022-09-01 01:18:15 +01:00
|
|
|
unwrap_lock(self.general.lock(), "general").on_set()?;
|
2022-08-10 01:56:22 +01:00
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Settings {
|
2022-07-30 21:33:31 +01:00
|
|
|
#[inline]
|
2022-08-10 01:56:22 +01:00
|
|
|
pub fn from_json(other: SettingsJson, json_path: PathBuf) -> Self {
|
2022-07-30 21:33:31 +01:00
|
|
|
match other.version {
|
|
|
|
0 => Self {
|
2022-08-10 01:56:22 +01:00
|
|
|
general: Arc::new(Mutex::new(General {
|
|
|
|
persistent: other.persistent,
|
|
|
|
path: json_path,
|
|
|
|
name: other.name,
|
|
|
|
})),
|
|
|
|
cpus: Arc::new(Mutex::new(Self::convert_cpus(other.cpus, other.version))),
|
|
|
|
gpu: Arc::new(Mutex::new(Gpu::from_json(other.gpu, other.version))),
|
|
|
|
battery: Arc::new(Mutex::new(Battery::from_json(other.battery, other.version))),
|
2022-07-30 21:33:31 +01:00
|
|
|
},
|
|
|
|
_ => Self {
|
2022-08-10 01:56:22 +01:00
|
|
|
general: Arc::new(Mutex::new(General {
|
|
|
|
persistent: other.persistent,
|
|
|
|
path: json_path,
|
|
|
|
name: other.name,
|
|
|
|
})),
|
|
|
|
cpus: Arc::new(Mutex::new(Self::convert_cpus(other.cpus, other.version))),
|
|
|
|
gpu: Arc::new(Mutex::new(Gpu::from_json(other.gpu, other.version))),
|
|
|
|
battery: Arc::new(Mutex::new(Battery::from_json(other.battery, other.version))),
|
|
|
|
},
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn convert_cpus(mut cpus: Vec<CpuJson>, version: u64) -> Vec<Cpu> {
|
|
|
|
let mut result = Vec::with_capacity(cpus.len());
|
2022-09-06 02:56:15 +01:00
|
|
|
let max_cpus = Cpu::cpu_count();
|
2022-08-10 01:56:22 +01:00
|
|
|
for (i, cpu) in cpus.drain(..).enumerate() {
|
2022-09-06 02:56:15 +01:00
|
|
|
// prevent having more CPUs than available
|
|
|
|
if let Some(max_cpus) = max_cpus {
|
|
|
|
if i == max_cpus {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2022-08-10 01:56:22 +01:00
|
|
|
result.push(Cpu::from_json(cpu, version, i));
|
|
|
|
}
|
2022-09-06 02:56:15 +01:00
|
|
|
if let Some(max_cpus) = max_cpus {
|
|
|
|
if result.len() != max_cpus {
|
|
|
|
let mut sys_cpus = Cpu::system_default();
|
|
|
|
for i in result.len()..sys_cpus.len() {
|
|
|
|
result.push(sys_cpus.remove(i));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2022-08-10 01:56:22 +01:00
|
|
|
result
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn system_default(json_path: PathBuf) -> Self {
|
|
|
|
Self {
|
|
|
|
general: Arc::new(Mutex::new(General {
|
|
|
|
persistent: false,
|
|
|
|
path: json_path,
|
2022-09-01 01:18:15 +01:00
|
|
|
name: crate::consts::DEFAULT_SETTINGS_NAME.to_owned(),
|
2022-08-10 01:56:22 +01:00
|
|
|
})),
|
|
|
|
cpus: Arc::new(Mutex::new(Cpu::system_default())),
|
|
|
|
gpu: Arc::new(Mutex::new(Gpu::system_default())),
|
|
|
|
battery: Arc::new(Mutex::new(Battery::system_default())),
|
|
|
|
}
|
|
|
|
}
|
2022-08-26 22:00:43 +01:00
|
|
|
|
2022-09-05 19:24:01 +01:00
|
|
|
pub fn load_file(&self, filename: PathBuf, name: String) -> Result<bool, SettingError> {
|
|
|
|
let json_path = crate::utility::settings_dir().join(filename);
|
2022-08-26 22:00:43 +01:00
|
|
|
let mut general_lock = unwrap_lock(self.general.lock(), "general");
|
|
|
|
if json_path.exists() {
|
|
|
|
let settings_json = SettingsJson::open(&json_path).map_err(|e| SettingError {
|
|
|
|
msg: e.to_string(),
|
|
|
|
setting: SettingVariant::General,
|
|
|
|
})?;
|
2022-10-05 01:49:02 +01:00
|
|
|
if !settings_json.persistent {
|
|
|
|
log::warn!("Loaded persistent config `{}` with persistent=false", json_path.display());
|
|
|
|
general_lock.persistent = false;
|
|
|
|
general_lock.name = settings_json.name;
|
|
|
|
return Ok(false);
|
|
|
|
}
|
2022-08-26 22:00:43 +01:00
|
|
|
let new_cpus = Self::convert_cpus(settings_json.cpus, settings_json.version);
|
|
|
|
let new_gpu = Gpu::from_json(settings_json.gpu, settings_json.version);
|
|
|
|
let new_battery = Battery::from_json(settings_json.battery, settings_json.version);
|
|
|
|
{
|
|
|
|
let mut cpu_lock = unwrap_lock(self.cpus.lock(), "cpu");
|
|
|
|
*cpu_lock = new_cpus; // TODO does this overwrite the contents of the lock as expected?
|
|
|
|
}
|
|
|
|
{
|
|
|
|
let mut gpu_lock = unwrap_lock(self.gpu.lock(), "gpu");
|
|
|
|
*gpu_lock = new_gpu;
|
|
|
|
}
|
|
|
|
{
|
|
|
|
let mut battery_lock = unwrap_lock(self.battery.lock(), "battery");
|
|
|
|
*battery_lock = new_battery;
|
|
|
|
}
|
|
|
|
general_lock.persistent = true;
|
|
|
|
general_lock.name = settings_json.name;
|
|
|
|
} else {
|
|
|
|
general_lock.persistent = false;
|
|
|
|
general_lock.name = name;
|
|
|
|
}
|
|
|
|
general_lock.path = json_path;
|
|
|
|
Ok(general_lock.persistent)
|
|
|
|
}
|
2022-08-10 01:56:22 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
impl OnResume for Settings {
|
|
|
|
fn on_resume(&self) -> Result<(), SettingError> {
|
2022-09-11 16:37:26 +01:00
|
|
|
log::debug!("Locking settings for on_resume");
|
2022-08-10 01:56:22 +01:00
|
|
|
unwrap_lock(self.battery.lock(), "battery").on_resume()?;
|
2022-09-11 16:37:26 +01:00
|
|
|
log::debug!("Got battery lock");
|
2022-08-10 01:56:22 +01:00
|
|
|
{
|
2022-09-11 16:37:26 +01:00
|
|
|
let cpu_lock = unwrap_lock(self.cpus.lock(), "cpu");
|
|
|
|
log::debug!("Got cpus lock");
|
|
|
|
for cpu in cpu_lock.iter() {
|
2022-08-10 01:56:22 +01:00
|
|
|
cpu.on_resume()?;
|
2022-07-30 21:33:31 +01:00
|
|
|
}
|
|
|
|
}
|
2022-08-10 01:56:22 +01:00
|
|
|
unwrap_lock(self.gpu.lock(), "gpu").on_resume()?;
|
2022-09-11 16:37:26 +01:00
|
|
|
log::debug!("Got gpu lock");
|
2022-08-10 01:56:22 +01:00
|
|
|
Ok(())
|
2022-07-30 21:33:31 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Into<SettingsJson> for Settings {
|
|
|
|
#[inline]
|
2022-08-10 01:56:22 +01:00
|
|
|
fn into(self) -> SettingsJson {
|
2022-09-01 01:18:15 +01:00
|
|
|
log::debug!("Locking settings to convert into json");
|
|
|
|
let gen_lock = unwrap_lock(self.general.lock(), "general");
|
|
|
|
log::debug!("Got general lock");
|
|
|
|
let cpu_lock = unwrap_lock(self.cpus.lock(), "cpu");
|
|
|
|
log::debug!("Got cpus lock");
|
|
|
|
let gpu_lock = unwrap_lock(self.gpu.lock(), "gpu");
|
|
|
|
log::debug!("Got gpu lock");
|
|
|
|
let batt_lock = unwrap_lock(self.battery.lock(), "battery");
|
|
|
|
log::debug!("Got battery lock");
|
2022-07-30 21:33:31 +01:00
|
|
|
SettingsJson {
|
|
|
|
version: LATEST_VERSION,
|
2022-09-01 01:18:15 +01:00
|
|
|
name: gen_lock.name.clone(),
|
|
|
|
persistent: gen_lock.persistent,
|
|
|
|
cpus: cpu_lock
|
2022-08-10 01:56:22 +01:00
|
|
|
.clone()
|
|
|
|
.drain(..)
|
|
|
|
.map(|cpu| cpu.into())
|
|
|
|
.collect(),
|
2022-09-01 01:18:15 +01:00
|
|
|
gpu: gpu_lock.clone().into(),
|
|
|
|
battery: batt_lock.clone().into(),
|
2022-07-30 21:33:31 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|