Add multi-profile per-game functionality for #82, change to JSON to RON format

backend/Cargo.lock

@@ -153,7 +153,7 @@ version = "0.64.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c4243e6031260db77ede97ad86c27e501d646a27ab57b59a574f725d98ab1fb4"
 dependencies = [
- "bitflags",
+ "bitflags 1.3.2",
  "cexpr",
  "clang-sys",
  "lazy_static",
@@ -175,6 +175,15 @@ version = "1.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
+[[package]]
+name = "bitflags"
+version = "2.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "327762f6e5a765692301e5bb513e0d9fef63be86bbc14528052b1cd3e6f03e07"
+dependencies = [
+ "serde",
+]
+
 [[package]]
 name = "block-buffer"
 version = "0.10.4"
@@ -599,7 +608,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f3e372db8e5c0d213e0cd0b9be18be2aca3d44cf2fe30a9d46a65581cd454584"
 dependencies = [
  "base64 0.13.1",
- "bitflags",
+ "bitflags 1.3.2",
  "bytes",
  "headers-core",
  "http",
@@ -1059,6 +1068,7 @@ dependencies = [
  "limits_core",
  "log",
  "regex",
+ "ron",
  "serde",
  "serde_json",
  "simplelog",
@@ -1161,6 +1171,18 @@ version = "0.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e5ea92a5b6195c6ef2a0295ea818b312502c6fc94dde986c5553242e18fd4ce2"
 
+[[package]]
+name = "ron"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b91f7eff05f748767f183df4320a63d6936e9c6107d97c9e6bdd9784f4289c94"
+dependencies = [
+ "base64 0.21.2",
+ "bitflags 2.4.1",
+ "serde",
+ "serde_derive",
+]
+
 [[package]]
 name = "rustc-demangle"
 version = "0.1.23"

backend/Cargo.toml

@@ -15,6 +15,7 @@ readme = "../README.md"
 usdpl-back = { version = "0.10.1", features = ["blocking"] }#, path = "../../usdpl-rs/usdpl-back"}
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
+ron = "0.8"
 sysfuss = { version = "0.2", features = ["derive"] }#,path = "../../sysfs-nav"}
 
 # async

backend/src/api/general.rs

@@ -55,18 +55,34 @@ pub fn load_settings(
     sender: Sender<ApiMessage>,
 ) -> impl Fn(super::ApiParameterType) -> super::ApiParameterType {
     let sender = Mutex::new(sender); // Sender is not Sync; this is required for safety
-    let setter = move |path: u64, name: String| {
+    let setter = move |id: u64, name: String, variant: u64, variant_name: Option<String>| {
         sender
             .lock()
             .unwrap()
-            .send(ApiMessage::LoadSettings(path, name))
+            .send(ApiMessage::LoadSettings(id, name, variant, variant_name.unwrap_or_else(|| crate::consts::DEFAULT_SETTINGS_VARIANT_NAME.to_owned())))
             .expect("load_settings send failed")
     };
     move |params_in: super::ApiParameterType| {
         if let Some(Primitive::String(id)) = params_in.get(0) {
             if let Some(Primitive::String(name)) = params_in.get(1) {
-                setter(id.parse().unwrap_or_default(), name.to_owned());
+                if let Some(Primitive::F64(variant_id)) = params_in.get(2) {
-                vec![true.into()]
+                    if let Some(Primitive::String(variant_name)) = params_in.get(3) {
+                        setter(id.parse().unwrap_or_default(),
+                               name.to_owned(),
+                               *variant_id as _,
+                               Some(variant_name.to_owned()));
+                        vec![true.into()]
+                    } else {
+                        setter(id.parse().unwrap_or_default(),
+                               name.to_owned(),
+                               *variant_id as _,
+                               None);
+                        vec![true.into()]
+                    }
+                } else {
+                    log::warn!("load_settings missing variant id parameter");
+                    vec!["load_settings missing variant id parameter".into()]
+                }
             } else {
                 log::warn!("load_settings missing name parameter");
                 vec!["load_settings missing name parameter".into()]

backend/src/api/handler.rs

@@ -5,7 +5,6 @@ use crate::persist::SettingsJson;
 use crate::settings::{
     MinMax, OnPowerEvent, OnResume, OnSet, PowerMode, Settings, TBattery, TCpus, TGeneral, TGpu,
 };
-use crate::utility::unwrap_maybe_fatal;
 
 type Callback<T> = Box<dyn FnOnce(T) + Send>;
 
@@ -23,7 +22,7 @@ pub enum ApiMessage {
     OnChargeChange(f64), // battery fill amount: 0 = empty, 1 = full
     PowerVibeCheck,
     WaitForEmptyQueue(Callback<()>),
-    LoadSettings(u64, String), // (path, name)
+    LoadSettings(u64, String, u64, String), // (path, name, variant, variant name)
     LoadMainSettings,
     LoadSystemSettings,
     GetLimits(Callback<super::SettingsLimits>),
@@ -287,21 +286,14 @@ impl ApiMessageHandler {
                 log::debug!("api_worker is saving...");
                 let is_persistent = *settings.general.persistent();
                 let save_path =
-                    crate::utility::settings_dir().join(settings.general.get_path().clone());
+                    crate::utility::settings_dir().join(settings.general.get_path());
                 if is_persistent {
                     let settings_clone = settings.json();
                     let save_json: SettingsJson = settings_clone.into();
-                    unwrap_maybe_fatal(save_json.save(&save_path), "Failed to save settings");
+                    if let Err(e) = crate::persist::FileJson::update_variant_or_create(&save_path, save_json, settings.general.get_name().to_owned()) {
-                    if let Some(event) = &settings.general.on_event().on_save {
+                        log::error!("Failed to create/update settings file {}: {}", save_path.display(), e);
-                        if !event.is_empty() {
-                            unwrap_maybe_fatal(
-                                std::process::Command::new("/bin/bash")
-                                    .args(&["-c", event])
-                                    .spawn(),
-                                "Failed to start on_save event command",
-                            );
-                        }
                     }
+                    //unwrap_maybe_fatal(save_json.save(&save_path), "Failed to save settings");
                     log::debug!("Saved settings to {}", save_path.display());
                     if let Err(e) = crate::utility::chown_settings_dir() {
                         log::error!("Failed to change config dir permissions: {}", e);
@@ -375,9 +367,9 @@ impl ApiMessageHandler {
                 self.on_empty.push(callback);
                 false
             }
-            ApiMessage::LoadSettings(id, name) => {
+            ApiMessage::LoadSettings(id, name, variant_id, variant_name) => {
                 let path = format!("{}.json", id);
-                match settings.load_file(path.into(), name, false) {
+                match settings.load_file(path.into(), name, variant_id, variant_name, false) {
                     Ok(success) => log::info!("Loaded settings file? {}", success),
                     Err(e) => log::warn!("Load file err: {}", e),
                 }
@@ -387,6 +379,8 @@ impl ApiMessageHandler {
                 match settings.load_file(
                     crate::consts::DEFAULT_SETTINGS_FILE.into(),
                     crate::consts::DEFAULT_SETTINGS_NAME.to_owned(),
+                    0,
+                    crate::consts::DEFAULT_SETTINGS_VARIANT_NAME.to_owned(),
                     true,
                 ) {
                     Ok(success) => log::info!("Loaded main settings file? {}", success),
@@ -395,7 +389,7 @@ impl ApiMessageHandler {
                 true
             }
             ApiMessage::LoadSystemSettings => {
-                settings.load_system_default(settings.general.get_name().to_owned());
+                settings.load_system_default(settings.general.get_name().to_owned(), settings.general.get_variant_id(), settings.general.get_variant_name().to_owned());
                 true
             }
             ApiMessage::GetLimits(cb) => {

backend/src/consts.rs

@@ -5,6 +5,7 @@ pub const PACKAGE_VERSION: &'static str = env!("CARGO_PKG_VERSION");
 
 pub const DEFAULT_SETTINGS_FILE: &str = "default_settings.json";
 pub const DEFAULT_SETTINGS_NAME: &str = "Main";
+pub const DEFAULT_SETTINGS_VARIANT_NAME: &str = "Primary";
 
 pub const LIMITS_FILE: &str = "limits_cache.json";
 pub const LIMITS_OVERRIDE_FILE: &str = "limits_override.json";

backend/src/main.rs

@@ -75,12 +75,20 @@ fn main() -> Result<(), ()> {
     let _limits_handle = crate::settings::limits_worker_spawn();
 
     let mut loaded_settings =
-        persist::SettingsJson::open(utility::settings_dir().join(DEFAULT_SETTINGS_FILE))
+        persist::FileJson::open(utility::settings_dir().join(DEFAULT_SETTINGS_FILE))
-            .map(|settings| settings::Settings::from_json(settings, DEFAULT_SETTINGS_FILE.into()))
+            .map(|mut file| file.variants.remove("0")
+                .map(|settings| settings::Settings::from_json(DEFAULT_SETTINGS_NAME.into(), settings, DEFAULT_SETTINGS_FILE.into()))
+                .unwrap_or_else(|| settings::Settings::system_default(
+                    DEFAULT_SETTINGS_FILE.into(),
+                    DEFAULT_SETTINGS_NAME.into(),
+                    0,
+                    DEFAULT_SETTINGS_VARIANT_NAME.into())))
             .unwrap_or_else(|_| {
                 settings::Settings::system_default(
                     DEFAULT_SETTINGS_FILE.into(),
                     DEFAULT_SETTINGS_NAME.into(),
+                    0,
+                    DEFAULT_SETTINGS_VARIANT_NAME.into(),
                 )
             });
 

backend/src/persist/error.rs

@@ -1,10 +1,10 @@
 #[derive(Debug)]
-pub enum JsonError {
+pub enum SerdeError {
-    Serde(serde_json::Error),
+    Serde(RonError),
     Io(std::io::Error),
 }
 
-impl std::fmt::Display for JsonError {
+impl std::fmt::Display for SerdeError {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {
             Self::Serde(e) => (e as &dyn std::fmt::Display).fmt(f),
@@ -12,3 +12,32 @@ impl std::fmt::Display for JsonError {
         }
     }
 }
+
+impl std::error::Error for SerdeError {}
+
+#[derive(Debug)]
+pub enum RonError {
+    General(ron::error::Error),
+    Spanned(ron::error::SpannedError),
+}
+
+impl std::fmt::Display for RonError {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        match self {
+            Self::General(e) => (e as &dyn std::fmt::Display).fmt(f),
+            Self::Spanned(e) => (e as &dyn std::fmt::Display).fmt(f),
+        }
+    }
+}
+
+impl From<ron::error::Error> for RonError {
+    fn from(value: ron::error::Error) -> Self {
+        Self::General(value)
+    }
+}
+
+impl From<ron::error::SpannedError> for RonError {
+    fn from(value: ron::error::SpannedError) -> Self {
+        Self::Spanned(value)
+    }
+}

backend/src/persist/file.rs

@@ -0,0 +1,62 @@
+use std::collections::HashMap;
+
+use serde::{Deserialize, Serialize};
+
+use super::SerdeError;
+use super::SettingsJson;
+
+#[derive(Serialize, Deserialize)]
+pub struct FileJson {
+    pub version: u64,
+    pub name: String,
+    pub variants: HashMap<String, SettingsJson>,
+}
+
+impl FileJson {
+    pub fn save<P: AsRef<std::path::Path>>(&self, path: P) -> Result<(), SerdeError> {
+        let path = path.as_ref();
+
+        if !self.variants.is_empty() {
+            if let Some(parent) = path.parent() {
+                std::fs::create_dir_all(parent).map_err(SerdeError::Io)?;
+            }
+            let mut file = std::fs::File::create(path).map_err(SerdeError::Io)?;
+            ron::ser::to_writer_pretty(&mut file, &self, crate::utility::ron_pretty_config()).map_err(|e| SerdeError::Serde(e.into()))
+        } else {
+            if path.exists() {
+                // remove settings file when persistence is turned off, to prevent it from be loaded next time.
+                std::fs::remove_file(path).map_err(SerdeError::Io)
+            } else {
+                Ok(())
+            }
+        }
+    }
+
+    pub fn open<P: AsRef<std::path::Path>>(path: P) -> Result<Self, SerdeError> {
+        let mut file = std::fs::File::open(path).map_err(SerdeError::Io)?;
+        ron::de::from_reader(&mut file).map_err(|e| SerdeError::Serde(e.into()))
+    }
+
+    pub fn update_variant_or_create<P: AsRef<std::path::Path>>(path: P, setting: SettingsJson, given_name: String) -> Result<(), SerdeError> {
+        if !setting.persistent {
+            return Ok(())
+        }
+        let path = path.as_ref();
+
+        let file = if path.exists() {
+            let mut file = Self::open(path)?;
+            file.variants.insert(setting.variant.to_string(), setting);
+            file
+        } else {
+            let mut setting_variants = HashMap::with_capacity(1);
+            setting_variants.insert(setting.variant.to_string(), setting);
+            Self {
+                version: 0,
+                name: given_name,
+                variants: setting_variants,
+            }
+        };
+
+        file.save(path)
+    }
+}

backend/src/persist/general.rs

@@ -2,38 +2,18 @@ use std::default::Default;
 
 use serde::{Deserialize, Serialize};
 
-use super::JsonError;
 use super::{BatteryJson, CpuJson, DriverJson, GpuJson};
 
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct OnEventJson {
-    pub on_save: Option<String>,
-    pub on_load: Option<String>,
-    pub on_set: Option<String>,
-    pub on_resume: Option<String>,
-}
-
-impl Default for OnEventJson {
-    fn default() -> Self {
-        Self {
-            on_save: None,
-            on_load: None,
-            on_set: None,
-            on_resume: None,
-        }
-    }
-}
-
 #[derive(Serialize, Deserialize)]
 pub struct SettingsJson {
     pub version: u64,
     pub name: String,
+    pub variant: u64,
     pub persistent: bool,
     pub cpus: Vec<CpuJson>,
     pub gpu: GpuJson,
     pub battery: BatteryJson,
     pub provider: Option<DriverJson>,
-    pub events: Option<OnEventJson>,
 }
 
 impl Default for SettingsJson {
@@ -41,42 +21,16 @@ impl Default for SettingsJson {
         Self {
             version: 0,
             name: crate::consts::DEFAULT_SETTINGS_NAME.to_owned(),
+            variant: 0,
             persistent: false,
             cpus: Vec::with_capacity(8),
             gpu: GpuJson::default(),
             battery: BatteryJson::default(),
             provider: None,
-            events: None,
         }
     }
 }
 
-impl SettingsJson {
-    pub fn save<P: AsRef<std::path::Path>>(&self, path: P) -> Result<(), JsonError> {
-        let path = path.as_ref();
-
-        if self.persistent {
-            if let Some(parent) = path.parent() {
-                std::fs::create_dir_all(parent).map_err(JsonError::Io)?;
-            }
-            let mut file = std::fs::File::create(path).map_err(JsonError::Io)?;
-            serde_json::to_writer_pretty(&mut file, &self).map_err(JsonError::Serde)
-        } else {
-            if path.exists() {
-                // remove settings file when persistence is turned off, to prevent it from be loaded next time.
-                std::fs::remove_file(path).map_err(JsonError::Io)
-            } else {
-                Ok(())
-            }
-        }
-    }
-
-    pub fn open<P: AsRef<std::path::Path>>(path: P) -> Result<Self, JsonError> {
-        let mut file = std::fs::File::open(path).map_err(JsonError::Io)?;
-        serde_json::from_reader(&mut file).map_err(JsonError::Serde)
-    }
-}
-
 #[derive(Serialize, Deserialize, Clone)]
 pub struct MinMaxJson<T> {
     pub max: Option<T>,

backend/src/persist/mod.rs

@@ -2,13 +2,15 @@ mod battery;
 mod cpu;
 mod driver;
 mod error;
+mod file;
 mod general;
 mod gpu;
 
 pub use battery::{BatteryEventJson, BatteryJson};
 pub use cpu::CpuJson;
 pub use driver::DriverJson;
-pub use general::{MinMaxJson, OnEventJson, SettingsJson};
+pub use file::FileJson;
+pub use general::{MinMaxJson, SettingsJson};
 pub use gpu::GpuJson;
 
-pub use error::JsonError;
+pub use error::{SerdeError, RonError};

backend/src/settings/detect/auto_detect.rs

@@ -10,7 +10,7 @@ use crate::settings::{Driver, General, TBattery, TCpus, TGeneral, TGpu, Provider
 fn get_limits() -> limits_core::json_v2::Base {
     let limits_path = super::utility::limits_path();
     match File::open(&limits_path) {
-        Ok(f) => match serde_json::from_reader(f) {
+        Ok(f) => match ron::de::from_reader(f) {
             Ok(lim) => lim,
             Err(e) => {
                 log::warn!(
@@ -35,7 +35,7 @@ fn get_limits() -> limits_core::json_v2::Base {
 fn get_limits_overrides() -> Option<Limits> {
     let limits_override_path = super::utility::limits_override_path();
     match File::open(&limits_override_path) {
-        Ok(f) => match serde_json::from_reader(f) {
+        Ok(f) => match ron::de::from_reader(f) {
             Ok(lim) => Some(lim),
             Err(e) => {
                 log::warn!(
@@ -63,6 +63,8 @@ pub fn auto_detect_provider() -> DriverJson {
         None,
         crate::utility::settings_dir().join("autodetect.json"),
         "".to_owned(),
+        0,
+        crate::consts::DEFAULT_SETTINGS_VARIANT_NAME.to_owned(),
     )
     .battery
     .provider();
@@ -72,16 +74,19 @@ pub fn auto_detect_provider() -> DriverJson {
 
 /// Device detection logic
 pub fn auto_detect0(
-    settings_opt: Option<SettingsJson>,
+    settings_opt: Option<&SettingsJson>,
     json_path: std::path::PathBuf,
     name: String,
+    variant_id: u64,
+    variant_name: String,
 ) -> Driver {
     let mut general_driver = Box::new(General {
         persistent: false,
         path: json_path,
         name,
+        variant_id,
+        variant_name,
         driver: DriverJson::AutoDetect,
-        events: Default::default(),
     });
 
     let cpu_info: String = usdpl_back::api::files::read_single("/proc/cpuinfo").unwrap_or_default();

backend/src/settings/detect/limits_worker.rs

@@ -15,7 +15,7 @@ pub fn spawn() -> JoinHandle<()> {
                 // try to load limits from file, fallback to built-in default
                 let base = if limits_path.exists() {
                     match std::fs::File::open(&limits_path) {
-                        Ok(f) => match serde_json::from_reader(f) {
+                        Ok(f) => match ron::de::from_reader(f) {
                             Ok(b) => b,
                             Err(e) => {
                                 log::error!("Cannot parse {}: {}", limits_path.display(), e);
@@ -72,7 +72,7 @@ pub fn get_limits_cached() -> Base {
     let limits_path = super::utility::limits_path();
     if limits_path.is_file() {
         match std::fs::File::open(&limits_path) {
-            Ok(f) => match serde_json::from_reader(f) {
+            Ok(f) => match ron::de::from_reader(f) {
                 Ok(b) => b,
                 Err(e) => {
                     log::error!("Cannot parse {}: {}", limits_path.display(), e);
@@ -93,7 +93,7 @@ pub fn get_limits_cached() -> Base {
 fn save_base(new_base: &Base, path: impl AsRef<std::path::Path>) {
     let limits_path = path.as_ref();
     match std::fs::File::create(&limits_path) {
-        Ok(f) => match serde_json::to_writer_pretty(f, &new_base) {
+        Ok(f) => match ron::ser::to_writer_pretty(f, &new_base, crate::utility::ron_pretty_config()) {
             Ok(_) => log::info!("Successfully saved new limits to {}", limits_path.display()),
             Err(e) => log::error!(
                 "Failed to save limits json to file `{}`: {}",

backend/src/settings/driver.rs

@@ -10,15 +10,17 @@ pub struct Driver {
 
 impl Driver {
     pub fn init(
-        settings: SettingsJson,
+        name: String,
+        settings: &SettingsJson,
         json_path: std::path::PathBuf,
     ) -> Self {
         let name_bup = settings.name.clone();
-        auto_detect0(Some(settings), json_path, name_bup)
+        let id_bup = settings.variant;
+        auto_detect0(Some(settings), json_path, name, id_bup, name_bup)
     }
 
-    pub fn system_default(json_path: std::path::PathBuf, name: String) -> Self {
+    pub fn system_default(json_path: std::path::PathBuf, name: String, variant_id: u64, variant_name: String) -> Self {
-        auto_detect0(None, json_path, name)
+        auto_detect0(None, json_path, name, variant_id, variant_name)
     }
 }
 

backend/src/settings/general.rs

@@ -4,7 +4,7 @@ use std::path::PathBuf;
 //use super::{Battery, Cpus, Gpu};
 use super::{OnResume, OnSet, SettingError};
 use super::{TBattery, TCpus, TGeneral, TGpu};
-use crate::persist::SettingsJson;
+use crate::persist::{SettingsJson, FileJson};
 //use crate::utility::unwrap_lock;
 
 const LATEST_VERSION: u64 = 0;
@@ -33,44 +33,19 @@ pub struct General {
     pub persistent: bool,
     pub path: PathBuf,
     pub name: String,
+    pub variant_id: u64,
+    pub variant_name: String,
     pub driver: crate::persist::DriverJson,
-    pub events: crate::persist::OnEventJson,
 }
 
 impl OnSet for General {
     fn on_set(&mut self) -> Result<(), Vec<SettingError>> {
-        if let Some(event) = &self.events.on_set {
-            if !event.is_empty() {
-                std::process::Command::new("/bin/bash")
-                    .args(&["-c", event])
-                    .spawn()
-                    .map_err(|e| {
-                        vec![SettingError {
-                            msg: format!("on_set event command error: {}", e),
-                            setting: SettingVariant::General,
-                        }]
-                    })?;
-            }
-        }
         Ok(())
     }
 }
 
 impl OnResume for General {
     fn on_resume(&self) -> Result<(), Vec<SettingError>> {
-        if let Some(event) = &self.events.on_resume {
-            if !event.is_empty() {
-                std::process::Command::new("/bin/bash")
-                    .args(&["-c", event])
-                    .spawn()
-                    .map_err(|e| {
-                        vec![SettingError {
-                            msg: format!("on_resume event command error: {}", e),
-                            setting: SettingVariant::General,
-                        }]
-                    })?;
-            }
-        }
         Ok(())
     }
 }
@@ -106,12 +81,24 @@ impl TGeneral for General {
         self.name = name;
     }
 
-    fn provider(&self) -> crate::persist::DriverJson {
+    fn get_variant_id(&self) -> u64 {
-        self.driver.clone()
+        self.variant_id
     }
 
-    fn on_event(&self) -> &crate::persist::OnEventJson {
+    fn variant_id(&mut self, id: u64) {
-        &self.events
+        self.variant_id = id;
+    }
+
+    fn get_variant_name(&self) -> &'_ str {
+        &self.variant_name
+    }
+
+    fn variant_name(&mut self, name: String) {
+        self.variant_name = name;
+    }
+
+    fn provider(&self) -> crate::persist::DriverJson {
+        self.driver.clone()
     }
 }
 
@@ -155,8 +142,8 @@ impl OnSet for Settings {
 
 impl Settings {
     #[inline]
-    pub fn from_json(other: SettingsJson, json_path: PathBuf) -> Self {
+    pub fn from_json(name: String, other: SettingsJson, json_path: PathBuf) -> Self {
-        let x = super::Driver::init(other, json_path.clone());
+        let x = super::Driver::init(name, &other, json_path.clone());
         log::info!(
             "Loaded settings with drivers general:{:?},cpus:{:?},gpu:{:?},battery:{:?}",
             x.general.provider(),
@@ -172,8 +159,8 @@ impl Settings {
         }
     }
 
-    pub fn system_default(json_path: PathBuf, name: String) -> Self {
+    pub fn system_default(json_path: PathBuf, name: String, variant_id: u64, variant_name: String) -> Self {
-        let driver = super::Driver::system_default(json_path, name);
+        let driver = super::Driver::system_default(json_path, name, variant_id, variant_name);
         Self {
             general: driver.general,
             cpus: driver.cpus,
@@ -182,26 +169,40 @@ impl Settings {
         }
     }
 
-    pub fn load_system_default(&mut self, name: String) {
+    pub fn load_system_default(&mut self, name: String, variant_id: u64, variant_name: String) {
-        let driver = super::Driver::system_default(self.general.get_path().to_owned(), name);
+        let driver = super::Driver::system_default(self.general.get_path().to_owned(), name, variant_id, variant_name);
         self.cpus = driver.cpus;
         self.gpu = driver.gpu;
         self.battery = driver.battery;
         self.general = driver.general;
     }
 
+    pub fn get_variant<'a>(settings_file: &'a FileJson, variant_id: u64, variant_name: String) -> Result<&'a SettingsJson, SettingError> {
+        if let Some(variant) = settings_file.variants.get(&variant_id.to_string()) {
+            Ok(variant)
+        } else {
+            Err(SettingError {
+                msg: format!("Cannot get non-existent variant `{}` (id:{})", variant_name, variant_id),
+                setting: SettingVariant::General,
+            })
+        }
+    }
+
     pub fn load_file(
         &mut self,
         filename: PathBuf,
         name: String,
+        variant: u64,
+        variant_name: String,
         system_defaults: bool,
     ) -> Result<bool, SettingError> {
         let json_path = crate::utility::settings_dir().join(&filename);
         if json_path.exists() {
-            let settings_json = SettingsJson::open(&json_path).map_err(|e| SettingError {
+            let file_json = FileJson::open(&json_path).map_err(|e| SettingError {
-                msg: e.to_string(),
+                msg: format!("Failed to open settings {}: {}", json_path.display(), e),
                 setting: SettingVariant::General,
             })?;
+            let settings_json = Self::get_variant(&file_json, variant, variant_name)?;
             if !settings_json.persistent {
                 log::warn!(
                     "Loaded persistent config `{}` ({}) with persistent=false",
@@ -211,7 +212,7 @@ impl Settings {
                 *self.general.persistent() = false;
                 self.general.name(name);
             } else {
-                let x = super::Driver::init(settings_json, json_path.clone());
+                let x = super::Driver::init(name, settings_json, json_path.clone());
                 log::info!("Loaded settings with drivers general:{:?},cpus:{:?},gpu:{:?},battery:{:?}", x.general.provider(), x.cpus.provider(), x.gpu.provider(), x.battery.provider());
                 self.general = x.general;
                 self.cpus = x.cpus;
@@ -220,24 +221,15 @@ impl Settings {
             }
         } else {
             if system_defaults {
-                self.load_system_default(name);
+                self.load_system_default(name, variant, variant_name);
             } else {
                 self.general.name(name);
+                self.general.variant_name(variant_name);
             }
             *self.general.persistent() = false;
         }
         self.general.path(filename);
-        if let Some(event) = &self.general.on_event().on_load {
+        self.general.variant_id(variant);
-            if !event.is_empty() {
-                std::process::Command::new("/bin/bash")
-                    .args(&["-c", event])
-                    .spawn()
-                    .map_err(|e| SettingError {
-                        msg: format!("on_save event command error: {}", e),
-                        setting: SettingVariant::General,
-                    })?;
-            }
-        }
         Ok(*self.general.persistent())
     }
 
@@ -275,13 +267,13 @@ impl Settings {
     pub fn json(&self) -> SettingsJson {
         SettingsJson {
             version: LATEST_VERSION,
-            name: self.general.get_name().to_owned(),
+            name: self.general.get_variant_name().to_owned(),
+            variant: self.general.get_variant_id(),
             persistent: self.general.get_persistent(),
             cpus: self.cpus.json(),
             gpu: self.gpu.json(),
             battery: self.battery.json(),
             provider: Some(self.general.provider()),
-            events: Some(self.general.on_event().clone()),
         }
     }
 }

backend/src/settings/traits.rs

@@ -109,9 +109,15 @@ pub trait TGeneral: OnSet + OnResume + OnPowerEvent + Debug + Send {
 
     fn name(&mut self, name: String);
 
-    fn provider(&self) -> crate::persist::DriverJson;
+    fn get_variant_id(&self) -> u64;
 
-    fn on_event(&self) -> &'_ crate::persist::OnEventJson;
+    fn variant_id(&mut self, id: u64);
+
+    fn get_variant_name(&self) -> &'_ str;
+
+    fn variant_name(&mut self, name: String);
+
+    fn provider(&self) -> crate::persist::DriverJson;
 }
 
 pub trait TBattery: OnSet + OnResume + OnPowerEvent + Debug + Send {

backend/src/utility.rs

@@ -1,19 +1,8 @@
-use std::fmt::Display;
 //use std::sync::{LockResult, MutexGuard};
 //use std::fs::{Permissions, metadata};
 use std::io::{Read, Write};
 use std::os::unix::fs::PermissionsExt;
 
-pub fn unwrap_maybe_fatal<T: Sized, E: Display>(result: Result<T, E>, message: &str) -> T {
-    match result {
-        Ok(x) => x,
-        Err(e) => {
-            log::error!("{}: {}", message, e);
-            panic!("{}: {}", message, e);
-        }
-    }
-}
-
 /*pub fn unwrap_lock<'a, T: Sized>(
     result: LockResult<MutexGuard<'a, T>>,
     lock_name: &str,
@@ -27,6 +16,12 @@ pub fn unwrap_maybe_fatal<T: Sized, E: Display>(result: Result<T, E>, message: &
     }
 }*/
 
+pub fn ron_pretty_config() -> ron::ser::PrettyConfig {
+    ron::ser::PrettyConfig::default()
+        .struct_names(true)
+        .compact_arrays(true)
+}
+
 pub fn settings_dir() -> std::path::PathBuf {
     usdpl_back::api::dirs::home()
         .unwrap_or_else(|| "/tmp/".into())

src/backend.ts

@@ -247,8 +247,13 @@ export async function getGeneralPersistent(): Promise<boolean> {
     return (await call_backend("GENERAL_get_persistent", []))[0];
 }
 
-export async function loadGeneralSettings(id: string, name: string): Promise<boolean> {
+export async function loadGeneralSettings(id: string, name: string, variant_id: number, variant_name: string | undefined): Promise<boolean> {
-    return (await call_backend("GENERAL_load_settings", [id, name]))[0];
+    if (variant_name) {
+        return (await call_backend("GENERAL_load_settings", [id, name, variant_id, variant_name]))[0];
+    } else {
+        return (await call_backend("GENERAL_load_settings", [id, name, variant_id]))[0];
+    }
+
 }
 
 export async function loadGeneralDefaultSettings(): Promise<boolean> {

src/index.tsx

@@ -191,7 +191,7 @@ const reload = function() {
       backend.log(backend.LogLevel.Info, "RegisterForGameActionStart callback(" + actionType + ", " + id + ")");
       // don't use gameInfo.appid, haha
       backend.resolve(
-        backend.loadGeneralSettings(id.toString(), gameInfo.display_name),
+        backend.loadGeneralSettings(id.toString(), gameInfo.display_name, 0, undefined),
         (ok: boolean) => {backend.log(backend.LogLevel.Debug, "Loading settings ok? " + ok)}
       );
   });