Convert chunk of daemon to use async mutex

daemon/src/ctrl_anime/mod.rs

@@ -1,6 +1,7 @@
 pub mod config;
 pub mod zbus;
 
+use ::zbus::export::futures_util::lock::{Mutex, MutexGuard};
 use ::zbus::SignalContext;
 use async_trait::async_trait;
 use log::{error, info, warn};
@@ -14,12 +15,7 @@ use rog_anime::{
 };
 use rog_platform::{hid_raw::HidRaw, supported::AnimeSupportedFunctions, usb_raw::USBRaw};
 use std::sync::atomic::{AtomicBool, Ordering};
-use std::{
-    convert::TryFrom,
-    error::Error,
-    sync::{Arc, Mutex, MutexGuard},
-    thread::sleep,
-};
+use std::{convert::TryFrom, error::Error, sync::Arc, thread::sleep};
 
 use crate::{error::RogError, GetSupported};
 
@@ -85,6 +81,7 @@ impl CtrlAnime {
 
         // The only reason for this outer thread is to prevent blocking while waiting for the
         // next spawned thread to exit
+        // TODO: turn this in to async task (maybe? COuld still risk blocking main thread)
         std::thread::Builder::new()
             .name("AniMe system thread start".into())
             .spawn(move || {
@@ -95,7 +92,7 @@ impl CtrlAnime {
                 let thread_running;
                 let anime_type;
                 loop {
-                    if let Ok(lock) = inner.try_lock() {
+                    if let Some(lock) = inner.try_lock() {
                         thread_exit = lock.thread_exit.clone();
                         thread_running = lock.thread_running.clone();
                         anime_type = lock.anime_type;
@@ -139,9 +136,10 @@ impl CtrlAnime {
                                                 .ok();
                                             false // Don't exit yet
                                         })
-                                        .map_err(|err| {
-                                            warn!("rog_anime::run_animation:callback {}", err);
-                                            AnimeError::NoFrames
+                                        .map(|r| Ok(r))
+                                        .unwrap_or_else(|| {
+                                            warn!("rog_anime::run_animation:callback failed");
+                                            Err(AnimeError::NoFrames)
                                         })
                                 }) {
                                     warn!("rog_anime::run_animation:Animation {}", err);
@@ -150,7 +148,7 @@ impl CtrlAnime {
                             }
                             ActionData::Image(image) => {
                                 once = false;
-                                if let Ok(lock) = inner.try_lock() {
+                                if let Some(lock) = inner.try_lock() {
                                     lock.write_data_buffer(image.as_ref().clone())
                                         .map_err(|e| error!("{}", e))
                                         .ok();
@@ -171,7 +169,7 @@ impl CtrlAnime {
                     }
                 }
                 // Clear the display on exit
-                if let Ok(lock) = inner.try_lock() {
+                if let Some(lock) = inner.try_lock() {
                     if let Ok(data) =
                         AnimeDataBuffer::from_vec(anime_type, vec![0u8; anime_type.data_length()])
                             .map_err(|e| error!("{}", e))
@@ -249,25 +247,25 @@ impl crate::CtrlTask for CtrlAnimeTask {
             // Loop is required to try an attempt to get the mutex *without* blocking
             // other threads - it is possible to end up with deadlocks otherwise.
             move || loop {
-                if let Ok(lock) = inner1.clone().try_lock() {
+                if let Some(lock) = inner1.try_lock() {
                     run_action(true, lock, inner1.clone());
                     break;
                 }
             },
             move || loop {
-                if let Ok(lock) = inner2.clone().try_lock() {
+                if let Some(lock) = inner2.try_lock() {
                     run_action(false, lock, inner2.clone());
                     break;
                 }
             },
             move || loop {
-                if let Ok(lock) = inner3.clone().try_lock() {
+                if let Some(lock) = inner3.try_lock() {
                     run_action(true, lock, inner3.clone());
                     break;
                 }
             },
             move || loop {
-                if let Ok(lock) = inner4.clone().try_lock() {
+                if let Some(lock) = inner4.try_lock() {
                     run_action(false, lock, inner4.clone());
                     break;
                 }
@@ -281,9 +279,10 @@ impl crate::CtrlTask for CtrlAnimeTask {
 
 pub struct CtrlAnimeReloader(pub Arc<Mutex<CtrlAnime>>);
 
+#[async_trait]
 impl crate::Reloadable for CtrlAnimeReloader {
-    fn reload(&mut self) -> Result<(), RogError> {
-        if let Ok(lock) = self.0.try_lock() {
+    async fn reload(&mut self) -> Result<(), RogError> {
+        if let Some(lock) = self.0.try_lock() {
             lock.node
                 .write_bytes(&pkt_for_set_on(lock.config.awake_enabled))?;
             lock.node.write_bytes(&pkt_for_apply())?;

daemon/src/ctrl_anime/zbus.rs

@@ -1,14 +1,12 @@
-use std::sync::{Arc, Mutex};
-
 use async_trait::async_trait;
 use log::warn;
 use rog_anime::{
     usb::{pkt_for_apply, pkt_for_set_boot, pkt_for_set_on},
     AnimeDataBuffer, AnimePowerStates,
 };
-use zbus::{dbus_interface, Connection, SignalContext};
+use zbus::{dbus_interface, export::futures_util::lock::Mutex, Connection, SignalContext};
 
-use std::sync::atomic::Ordering;
+use std::sync::{atomic::Ordering, Arc};
 
 use super::CtrlAnime;
 
@@ -16,7 +14,7 @@ pub struct CtrlAnimeZbus(pub Arc<Mutex<CtrlAnime>>);
 
 /// The struct with the main dbus methods requires this trait
 #[async_trait]
-impl crate::ZbusAdd for CtrlAnimeZbus {
+impl crate::ZbusRun for CtrlAnimeZbus {
     async fn add_to_server(self, server: &mut Connection) {
         Self::add_to_server_helper(self, "/org/asuslinux/Anime", server).await;
     }
@@ -28,127 +26,105 @@ impl crate::ZbusAdd for CtrlAnimeZbus {
 #[dbus_interface(name = "org.asuslinux.Daemon")]
 impl CtrlAnimeZbus {
     /// Writes a data stream of length. Will force system thread to exit until it is restarted
-    fn write(&self, input: AnimeDataBuffer) -> zbus::fdo::Result<()> {
-        'outer: loop {
-            if let Ok(lock) = self.0.try_lock() {
-                lock.thread_exit.store(true, Ordering::SeqCst);
-                lock.write_data_buffer(input).map_err(|err| {
-                    warn!("rog_anime::run_animation:callback {}", err);
-                    err
-                })?;
-                break 'outer;
-            }
-        }
+    async fn write(&self, input: AnimeDataBuffer) -> zbus::fdo::Result<()> {
+        let lock = self.0.lock().await;
+        lock.thread_exit.store(true, Ordering::SeqCst);
+        lock.write_data_buffer(input).map_err(|err| {
+            warn!("rog_anime::run_animation:callback {}", err);
+            err
+        })?;
         Ok(())
     }
 
     /// Set the global AniMe brightness
-    fn set_brightness(&self, bright: f32) {
-        'outer: loop {
-            if let Ok(mut lock) = self.0.try_lock() {
-                let mut bright = bright;
-                if bright < 0.0 {
-                    bright = 0.0
-                } else if bright > 1.0 {
-                    bright = 1.0;
-                }
-                lock.config.brightness = bright;
-                lock.config.write();
-                break 'outer;
-            }
+    async fn set_brightness(&self, bright: f32) {
+        let mut lock = self.0.lock().await;
+        let mut bright = bright;
+        if bright < 0.0 {
+            bright = 0.0
+        } else if bright > 1.0 {
+            bright = 1.0;
         }
+        lock.config.brightness = bright;
+        lock.config.write();
     }
 
     /// Set whether the AniMe is displaying images/data
     async fn set_on_off(&self, #[zbus(signal_context)] ctxt: SignalContext<'_>, status: bool) {
-        let states;
-        'outer: loop {
-            if let Ok(mut lock) = self.0.try_lock() {
-                lock.node
-                    .write_bytes(&pkt_for_set_on(status))
-                    .map_err(|err| {
-                        warn!("rog_anime::run_animation:callback {}", err);
-                    })
-                    .ok();
-                lock.config.awake_enabled = status;
-                lock.config.write();
+        let mut lock = self.0.lock().await;
+        lock.node
+            .write_bytes(&pkt_for_set_on(status))
+            .map_err(|err| {
+                warn!("rog_anime::run_animation:callback {}", err);
+            })
+            .ok();
+        lock.config.awake_enabled = status;
+        lock.config.write();
 
-                states = Some(AnimePowerStates {
-                    brightness: lock.config.brightness.floor() as u8,
-                    enabled: lock.config.awake_enabled,
-                    boot_anim_enabled: lock.config.boot_anim_enabled,
-                });
-                break 'outer;
-            }
-        }
-        if let Some(state) = states {
-            Self::notify_power_states(&ctxt, state).await.ok();
-        }
+        Self::notify_power_states(
+            &ctxt,
+            AnimePowerStates {
+                brightness: lock.config.brightness.floor() as u8,
+                enabled: lock.config.awake_enabled,
+                boot_anim_enabled: lock.config.boot_anim_enabled,
+            },
+        )
+        .await
+        .ok();
     }
 
     /// Set whether the AniMe will show boot, suspend, or off animations
     async fn set_boot_on_off(&self, #[zbus(signal_context)] ctxt: SignalContext<'_>, on: bool) {
-        let states;
-        'outer: loop {
-            if let Ok(mut lock) = self.0.try_lock() {
-                lock.node
-                    .write_bytes(&pkt_for_set_boot(on))
-                    .map_err(|err| {
-                        warn!("rog_anime::run_animation:callback {}", err);
-                    })
-                    .ok();
-                lock.node
-                    .write_bytes(&pkt_for_apply())
-                    .map_err(|err| {
-                        warn!("rog_anime::run_animation:callback {}", err);
-                    })
-                    .ok();
-                lock.config.boot_anim_enabled = on;
-                lock.config.write();
+        let mut lock = self.0.lock().await;
+        lock.node
+            .write_bytes(&pkt_for_set_boot(on))
+            .map_err(|err| {
+                warn!("rog_anime::run_animation:callback {}", err);
+            })
+            .ok();
+        lock.node
+            .write_bytes(&pkt_for_apply())
+            .map_err(|err| {
+                warn!("rog_anime::run_animation:callback {}", err);
+            })
+            .ok();
+        lock.config.boot_anim_enabled = on;
+        lock.config.write();
 
-                states = Some(AnimePowerStates {
-                    brightness: lock.config.brightness.floor() as u8,
-                    enabled: lock.config.awake_enabled,
-                    boot_anim_enabled: lock.config.boot_anim_enabled,
-                });
-                break 'outer;
-            }
-        }
-        if let Some(state) = states {
-            Self::notify_power_states(&ctxt, state).await.ok();
-        }
+        Self::notify_power_states(
+            &ctxt,
+            AnimePowerStates {
+                brightness: lock.config.brightness.floor() as u8,
+                enabled: lock.config.awake_enabled,
+                boot_anim_enabled: lock.config.boot_anim_enabled,
+            },
+        )
+        .await
+        .ok();
     }
 
     /// The main loop is the base system set action if the user isn't running
     /// the user daemon
-    fn run_main_loop(&self, start: bool) {
+    async fn run_main_loop(&self, start: bool) {
         if start {
-            'outer: loop {
-                if let Ok(lock) = self.0.try_lock() {
-                    lock.thread_exit.store(true, Ordering::SeqCst);
-                    CtrlAnime::run_thread(self.0.clone(), lock.cache.system.clone(), false);
-                    break 'outer;
-                }
-            }
+            let lock = self.0.lock().await;
+            lock.thread_exit.store(true, Ordering::SeqCst);
+            CtrlAnime::run_thread(self.0.clone(), lock.cache.system.clone(), false);
         }
     }
 
     /// Get status of if the AniMe LEDs are on/displaying while system is awake
     #[dbus_interface(property)]
-    fn awake_enabled(&self) -> bool {
-        if let Ok(ctrl) = self.0.try_lock() {
-            return ctrl.config.awake_enabled;
-        }
-        true
+    async fn awake_enabled(&self) -> bool {
+        let lock = self.0.lock().await;
+        return lock.config.awake_enabled;
     }
 
     /// Get the status of if factory system-status animations are enabled
     #[dbus_interface(property)]
-    fn boot_enabled(&self) -> bool {
-        if let Ok(ctrl) = self.0.try_lock() {
-            return ctrl.config.boot_anim_enabled;
-        }
-        true
+    async fn boot_enabled(&self) -> bool {
+        let lock = self.0.lock().await;
+        return lock.config.boot_anim_enabled;
     }
 
     /// Notify listeners of the status of AniMe LED power and factory system-status animations