From d7489d5d04b65f3f6c39a3ca2b7d5f1cff7df97f Mon Sep 17 00:00:00 2001 From: "NGnius (Graham)" Date: Tue, 7 May 2024 18:40:06 -0400 Subject: [PATCH] Add more logging for #153 --- backend/src/api/handler.rs | 100 ++++++++++++++++++++++++++++++++++++- 1 file changed, 99 insertions(+), 1 deletion(-) diff --git a/backend/src/api/handler.rs b/backend/src/api/handler.rs index 5058eab..dfc065a 100644 --- a/backend/src/api/handler.rs +++ b/backend/src/api/handler.rs @@ -32,6 +32,30 @@ pub enum ApiMessage { UploadCurrentVariant(String, String), // SteamID, Steam username } +impl core::fmt::Display for ApiMessage { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + Self::Battery(x) => write!(f, "Battery;{}", x), + Self::Cpu(x) => write!(f, "Cpu;{}", x), + Self::Gpu(x) => write!(f, "Gpu;{}", x), + Self::General(x) => write!(f, "General;{}", x), + Self::OnResume => write!(f, "OnResume"), + Self::OnPluggedIn => write!(f, "OnPluggedIn"), + Self::OnUnplugged => write!(f, "OnUnplugged"), + Self::OnChargeChange(x) => write!(f, "OnChargeChange({:?})", x), + Self::PowerVibeCheck => write!(f, "PowerVibeCheck"), + Self::WaitForEmptyQueue(_) => write!(f, "WaitForEmptyQueue"), + Self::LoadSettings(path, name, variant, variant_name) => write!(f, "LoadSettings({}, {}, {}, {})", path, name, variant, variant_name), + Self::LoadVariant(variant, variant_name) => write!(f, "LoadVariant({}, {})", variant, variant_name), + Self::LoadMainSettings => write!(f, "LoadMainSettings"), + Self::LoadSystemSettings => write!(f, "LoadSystemSettings"), + Self::GetLimits(_) => write!(f, "GetLimits"), + Self::GetProvider(s, _) => write!(f, "GetProvider({})", s), + Self::UploadCurrentVariant(id, user) => write!(f, "UploadCurrentVariant(id: {}, user: {})", id, user), + } + } +} + pub enum BatteryMessage { SetChargeRate(Option), GetChargeRate(Callback>), @@ -46,6 +70,24 @@ pub enum BatteryMessage { GetChargeLimit(Callback>), } +impl core::fmt::Display for BatteryMessage { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + Self::SetChargeRate(x) => write!(f, "SetChargeRate({:?})", x), + Self::GetChargeRate(_) => write!(f, "GetChargeRate"), + Self::SetChargeMode(x) => write!(f, "SetChargeMode({:?})", x), + Self::GetChargeMode(_) => write!(f, "GetChargeMode"), + Self::ReadChargeFull(_) => write!(f, "ReadChargeFull"), + Self::ReadChargeNow(_) => write!(f, "ReadChargeNow"), + Self::ReadChargeDesign(_) => write!(f, "ReadChargeDesign"), + Self::ReadCurrentNow(_) => write!(f, "ReadCurrentNow"), + Self::ReadChargePower(_) => write!(f, "ReadChargePower"), + Self::SetChargeLimit(x) => write!(f, "SetChargeLimit({:?})", x), + Self::GetChargeLimit(_) => write!(f, "GetChargeLimit"), + } + } +} + impl BatteryMessage { fn process(self, settings: &mut dyn TBattery) -> bool { let dirty = self.is_modify(); @@ -87,6 +129,23 @@ pub enum CpuMessage { GetCpusGovernor(Callback>), } +impl core::fmt::Display for CpuMessage { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + Self::SetCpuOnline(i, x) => write!(f, "SetCpuOnline({}, {})", i, x), + Self::SetCpusOnline(x) => write!(f, "SetCpusOnline({:?})", x), + Self::SetSmt(x, _) => write!(f, "SetChargeMode({})", x), + Self::GetSmt(_) => write!(f, "GetSmt"), + Self::GetCpusOnline(_) => write!(f, "GetCpusOnline"), + Self::SetClockLimits(x, y) => write!(f, "SetClockLimits({}, {:?})", x, y), + Self::GetClockLimits(x, _) => write!(f, "GetClockLimits({})", x), + Self::SetCpuGovernor(i, x) => write!(f, "SetCpuGovernor({}, {})", i, x), + Self::SetCpusGovernor(x) => write!(f, "SetCpusGovernor({:?})", x), + Self::GetCpusGovernor(_) => write!(f, "GetCpusGovernor"), + } + } +} + impl CpuMessage { fn process(self, settings: &mut dyn TCpus) -> bool { let dirty = self.is_modify(); @@ -206,6 +265,19 @@ pub enum GpuMessage { GetMemoryClock(Callback>), } +impl core::fmt::Display for GpuMessage { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + Self::SetPpt(x, y) => write!(f, "SetPpt(fast {:?}, slow {:?})", x, y), + Self::GetPpt(_) => write!(f, "GetPpt"), + Self::SetClockLimits(x) => write!(f, "SetClockLimits({:?})", x), + Self::GetClockLimits(_) => write!(f, "GetClockLimits"), + Self::SetMemoryClock(x) => write!(f, "SetMemoryClock({:?})", x), + Self::GetMemoryClock(_) => write!(f, "GetMemoryClock"), + } + } +} + impl GpuMessage { fn process(self, settings: &mut dyn TGpu) -> bool { let dirty = self.is_modify(); @@ -242,6 +314,21 @@ pub enum GeneralMessage { ApplyNow, } +impl core::fmt::Display for GeneralMessage { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + Self::SetPersistent(x) => write!(f, "SetPersistent({})", x), + Self::GetPersistent(_) => write!(f, "GetPersistent"), + Self::GetCurrentProfileName(_) => write!(f, "GetCurrentProfileName"), + Self::GetPath(_) => write!(f, "GetPath"), + Self::GetCurrentVariant(_) => write!(f, "GetCurrentVariant"), + Self::GetAllVariants(_) => write!(f, "GetAllVariants"), + Self::AddVariant(variant, _) => write!(f, "AddVariant(name: `{}` [...])", variant.name), + Self::ApplyNow => write!(f, "ApplyNow"), + } + } +} + impl GeneralMessage { fn process(self, settings: &mut dyn TGeneral) -> bool { let dirty = self.is_modify(); @@ -285,20 +372,31 @@ fn print_errors(call_name: &str, errors: Vec) { log::error!("Settings {}() err:\n{}", call_name, err_list); } +fn print_messages(msgs: &Vec) { + let mut log_msg = String::new(); + for msg in msgs.iter() { + //use core::fmt::Write; + write!(log_msg, "{}, ", msg).unwrap(); + } + log::info!("Processed messages: [{}]", log_msg); +} + impl ApiMessageHandler { pub fn process_forever(&mut self, settings: &mut Settings) { crate::utility::ioperm_power_ec(); //let mut dirty_echo = true; // set everything twice, to make sure PowerTools wins on race conditions while let Ok(msg) = self.intake.recv() { + let mut messages = vec![msg.to_string()]; // keep messages for logging let mut dirty = self.process(settings, msg); while let Ok(msg) = self.intake.try_recv() { + messages.push(msg.to_string()); dirty |= self.process(settings, msg); } if dirty /*|| dirty_echo */ { //dirty_echo = dirty; // echo only once - + print_messages(&messages); // run on_set if let Err(e) = settings.on_set() { print_errors("on_set", e);