Merge branch 'dev' for v1.2.0

backend/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
-name = "powertools-rs"
-version = "1.1.1"
+name = "powertools"
+version = "1.2.0"
 edition = "2021"
 authors = ["NGnius (Graham) <ngniusness@gmail.com>"]
 description = "Backend (superuser) functionality for PowerTools"
@@ -12,7 +12,7 @@ readme = "../README.md"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-usdpl-back = { version = "0.9.1", features = ["blocking"] }#, path = "../../usdpl-rs/usdpl-back"}
+usdpl-back = { version = "0.10.1", features = ["blocking"] }#, path = "../../usdpl-rs/usdpl-back"}
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 
@@ -32,11 +32,12 @@ ryzenadj-rs = { version = "0.1" }
 ureq = { version = "2.5", features = ["json", "gzip", "brotli", "charset"], default-features = false, optional = true }
 
 [features]
-default = ["online"]
+default = ["online", "decky"]
 decky = ["usdpl-back/decky"]
 crankshaft = ["usdpl-back/crankshaft"]
 encrypt = ["usdpl-back/encrypt"]
 online = ["ureq"]
+dev_stuff = []
 
 [profile.release]
 debug = false

backend/build-docker.sh

@@ -8,7 +8,7 @@ cargo --version
 echo "--- Building plugin backend ---"
 cargo build --profile docker
 mkdir -p out
-cp target/release/powertools-rs out/backend
+cp target/release/powertools out/backend
 
 echo " --- Cleaning up ---"
 # remove root-owned target folder

backend/build.sh

@@ -1,10 +1,10 @@
 #!/bin/bash
 
-cargo build --release --target x86_64-unknown-linux-musl
-#cargo build --target x86_64-unknown-linux-musl
+#cargo build --release --target x86_64-unknown-linux-musl
+cargo build --target x86_64-unknown-linux-musl
 #cross build --release
 
 mkdir -p ../bin
-cp ./target/x86_64-unknown-linux-musl/release/powertools-rs ../bin/backend
-#cp ./target/x86_64-unknown-linux-musl/debug/powertools-rs ../bin/backend
-#cp ./target/release/powertools-rs ../bin/backend
+#cp ./target/x86_64-unknown-linux-musl/release/powertools ../bin/backend
+cp ./target/x86_64-unknown-linux-musl/debug/powertools ../bin/backend
+#cp ./target/release/powertools ../bin/backend

backend/src/api/handler.rs

@@ -1,4 +1,5 @@
 use std::sync::mpsc::{self, Receiver, Sender};
+use std::fmt::Write;
 
 use crate::settings::{Settings, TCpus, TGpu, TBattery, TGeneral, OnSet, OnResume, MinMax};
 use crate::persist::SettingsJson;
@@ -216,6 +217,12 @@ pub struct ApiMessageHandler {
     on_empty: Vec<Callback<()>>,
 }
 
+fn print_errors(call_name: &str, errors: Vec<crate::settings::SettingError>) {
+    let mut err_list = String::new();
+    errors.iter().for_each(|e| write!(err_list, "\t{},\n", e).unwrap_or(()));
+    log::error!("Settings {}() err:\n{}", call_name, err_list);
+}
+
 impl ApiMessageHandler {
     pub fn process_forever(&mut self, settings: &mut Settings) {
         let mut dirty_echo = true; // set everything twice, to make sure PowerTools wins on race conditions
@@ -228,7 +235,7 @@ impl ApiMessageHandler {
                 dirty_echo = dirty; // echo only once
                 // run on_set
                 if let Err(e) = settings.on_set() {
-                    log::error!("Settings on_set() err: {}", e);
+                    print_errors("on_set", e);
                 }
                 // do callbacks
                 for func in self.on_empty.drain(..) {
@@ -244,6 +251,9 @@ impl ApiMessageHandler {
                     let save_json: SettingsJson = settings_clone.into();
                     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);
+                    }
                 } else {
                     if save_path.exists() {
                         if let Err(e) = std::fs::remove_file(&save_path) {
@@ -269,7 +279,7 @@ impl ApiMessageHandler {
             ApiMessage::General(x) => x.process(settings.general.as_mut()),
             ApiMessage::OnResume => {
                 if let Err(e) = settings.on_resume() {
-                    log::error!("Settings on_resume() err: {}", e);
+                    print_errors("on_resume", e);
                 }
                 false
             }

backend/src/main.rs

@@ -18,7 +18,6 @@ use usdpl_back::core::serdes::Primitive;
 use usdpl_back::Instance;
 
 fn main() -> Result<(), ()> {
-
     #[cfg(debug_assertions)]
     let log_filepath = usdpl_back::api::dirs::home()
         .unwrap_or_else(|| "/tmp/".into())
@@ -46,6 +45,7 @@ fn main() -> Result<(), ()> {
         },
         Default::default(),
         std::fs::File::create(&log_filepath).unwrap(),
+        //std::fs::File::create("/home/deck/powertools-rs.log").unwrap(),
     )
     .unwrap();
     log::debug!("Logging to: {:?}.", log_filepath);
@@ -55,6 +55,8 @@ fn main() -> Result<(), ()> {
     log::info!("Current dir `{}`", std::env::current_dir().unwrap().display());
     println!("Current dir `{}`", std::env::current_dir().unwrap().display());
 
+    log::info!("home dir: {:?}", usdpl_back::api::dirs::home());
+
     let _limits_handle = crate::settings::limits_worker_spawn();
     log::info!("Detected device automatically, starting with driver: {:?} (This can be overriden)", crate::settings::auto_detect_provider());
 
@@ -71,7 +73,13 @@ fn main() -> Result<(), ()> {
 
     let instance = Instance::new(PORT)
         .register("V_INFO", |_: Vec<Primitive>| {
-            vec![format!("{} v{}", PACKAGE_NAME, PACKAGE_VERSION).into()]
+            #[cfg(debug_assertions)]
+            {vec![format!("v{}-dbg", PACKAGE_VERSION).into()]}
+            #[cfg(not(debug_assertions))]
+            {vec![format!("v{}-rls", PACKAGE_VERSION).into()]}
+        })
+        .register("NAME", |_: Vec<Primitive>| {
+            vec![PACKAGE_NAME.into()]
         })
         .register("LOG", api::general::log_it())
         // battery API functions
@@ -222,11 +230,15 @@ fn main() -> Result<(), ()> {
         .register("GENERAL_idk", api::general::gunter);
 
     if let Err(e) = loaded_settings.on_set() {
-        log::error!("Startup Settings.on_set() error: {}", e);
+        e.iter().for_each(|e| log::error!("Startup Settings.on_set() error: {}", e));
     } else {
         log::info!("Startup Settings.on_set() success");
     }
 
+    if let Err(e) = utility::chown_settings_dir() {
+        log::warn!("Failed to change config dir permissions: {}", e);
+    }
+
     api_worker::spawn(loaded_settings, api_handler);
 
     instance

backend/src/settings/general.rs

@@ -37,13 +37,13 @@ pub struct General {
 }
 
 impl OnSet for General {
-    fn on_set(&mut self) -> Result<(), SettingError> {
+    fn on_set(&mut self) -> Result<(), Vec<SettingError>> {
         Ok(())
     }
 }
 
 impl OnResume for General {
-    fn on_resume(&self) -> Result<(), SettingError> {
+    fn on_resume(&self) -> Result<(), Vec<SettingError>> {
         Ok(())
     }
 }
@@ -91,7 +91,7 @@ pub struct Settings {
 }
 
 impl OnSet for Settings {
-    fn on_set(&mut self) -> Result<(), SettingError> {
+    fn on_set(&mut self) -> Result<(), Vec<SettingError>> {
         self.battery.on_set()?;
         self.cpus.on_set()?;
         self.gpu.on_set()?;
@@ -224,7 +224,7 @@ impl Settings {
 }
 
 impl OnResume for Settings {
-    fn on_resume(&self) -> Result<(), SettingError> {
+    fn on_resume(&self) -> Result<(), Vec<SettingError>> {
         log::debug!("Applying settings for on_resume");
         self.battery.on_resume()?;
         log::debug!("Resumed battery");

backend/src/settings/generic/battery.rs

@@ -52,13 +52,15 @@ impl Battery {
 }
 
 impl OnSet for Battery {
-    fn on_set(&mut self) -> Result<(), SettingError> {
+    fn on_set(&mut self) -> Result<(), Vec<SettingError>> {
+        // TODO
         Ok(())
     }
 }
 
 impl OnResume for Battery {
-    fn on_resume(&self) -> Result<(), SettingError> {
+    fn on_resume(&self) -> Result<(), Vec<SettingError>> {
+        // TODO
         Ok(())
     }
 }

backend/src/settings/generic/cpu.rs

@@ -19,7 +19,8 @@ pub struct Cpus<C: AsMut<Cpu> + AsRef<Cpu> + TCpu> {
 }
 
 impl<C: AsMut<Cpu> + AsRef<Cpu> + TCpu + OnSet> OnSet for Cpus<C> {
-    fn on_set(&mut self) -> Result<(), SettingError> {
+    fn on_set(&mut self) -> Result<(), Vec<SettingError>> {
+        let mut errors = Vec::new();
         if self.smt_capable {
             // toggle SMT
             if self.smt {
@@ -31,7 +32,7 @@ impl<C: AsMut<Cpu> + AsRef<Cpu> + TCpu + OnSet> OnSet for Cpus<C> {
                         ),
                         setting: crate::settings::SettingVariant::Cpu,
                     }
-                })?;
+                }).unwrap_or_else(|e| errors.push(e));
             } else {
                 usdpl_back::api::files::write_single(CPU_SMT_PATH, "off").map_err(|e| {
                     SettingError {
@@ -41,23 +42,32 @@ impl<C: AsMut<Cpu> + AsRef<Cpu> + TCpu + OnSet> OnSet for Cpus<C> {
                         ),
                         setting: crate::settings::SettingVariant::Cpu,
                     }
-                })?;
+                }).unwrap_or_else(|e| errors.push(e));
             }
         }
         for (i, cpu) in self.cpus.as_mut_slice().iter_mut().enumerate() {
             cpu.as_mut().state.do_set_online = self.smt || i % 2 == 0 || !self.smt_capable;
-            cpu.on_set()?;
+            cpu.on_set().unwrap_or_else(|mut e| errors.append(&mut e));
+        }
+        if errors.is_empty() {
+            Ok(())
+        } else {
+            Err(errors)
         }
-        Ok(())
     }
 }
 
 impl<C: AsMut<Cpu> + AsRef<Cpu> + TCpu + OnResume> OnResume for Cpus<C> {
-    fn on_resume(&self) -> Result<(), SettingError> {
+    fn on_resume(&self) -> Result<(), Vec<SettingError>> {
+        let mut errors = Vec::new();
         for cpu in &self.cpus {
-            cpu.on_resume()?;
+            cpu.on_resume().unwrap_or_else(|mut e| errors.append(&mut e));
+        }
+        if errors.is_empty() {
+            Ok(())
+        } else {
+            Err(errors)
         }
-        Ok(())
     }
 }
 
@@ -232,7 +242,8 @@ impl FromGenericCpuInfo for Cpu {
 }
 
 impl Cpu {
-    fn set_all(&mut self) -> Result<(), SettingError> {
+    fn set_all(&mut self) -> Result<(), Vec<SettingError>> {
+        let mut errors = Vec::new();
         // set cpu online/offline
         if self.index != 0 && self.state.do_set_online { // cpu0 cannot be disabled
             let online_path = cpu_online_path(self.index);
@@ -241,7 +252,7 @@ impl Cpu {
                     msg: format!("Failed to write to `{}`: {}", &online_path, e),
                     setting: crate::settings::SettingVariant::Cpu,
                 }
-            })?;
+            }).unwrap_or_else(|e| errors.push(e));
         }
 
         // set governor
@@ -255,9 +266,13 @@ impl Cpu {
                     ),
                     setting: crate::settings::SettingVariant::Cpu,
                 }
-            })?;
+            }).unwrap_or_else(|e| errors.push(e));
+        }
+        if errors.is_empty() {
+            Ok(())
+        } else {
+            Err(errors)
         }
-        Ok(())
     }
 
     /*fn from_sys(cpu_index: usize) -> Self {
@@ -304,14 +319,14 @@ impl Into<CpuJson> for Cpu {
 }
 
 impl OnSet for Cpu {
-    fn on_set(&mut self) -> Result<(), SettingError> {
+    fn on_set(&mut self) -> Result<(), Vec<SettingError>> {
         //self.clamp_all();
         self.set_all()
     }
 }
 
 impl OnResume for Cpu {
-    fn on_resume(&self) -> Result<(), SettingError> {
+    fn on_resume(&self) -> Result<(), Vec<SettingError>> {
         let mut copy = self.clone();
         copy.state.is_resuming = true;
         copy.set_all()

backend/src/settings/generic/gpu.rs

@@ -69,13 +69,13 @@ impl Into<GpuJson> for Gpu {
 }
 
 impl OnSet for Gpu {
-    fn on_set(&mut self) -> Result<(), SettingError> {
+    fn on_set(&mut self) -> Result<(), Vec<SettingError>> {
         Ok(())
     }
 }
 
 impl OnResume for Gpu {
-    fn on_resume(&self) -> Result<(), SettingError> {
+    fn on_resume(&self) -> Result<(), Vec<SettingError>> {
         Ok(())
     }
 }