refactor: major client code changes

This does away with `lazy_static` singletons for all the clients, instead putting them all inside a `Clients` struct on the `Ironbar` struct.

Client code has been refactored in places to accommodate this, and module code has been updated to get the clients the new way.

The Wayland client has been re-written from the ground up to remove a lot of the needless complications, provide a nicer interface and reduce some duplicate data.

The MPD music client has been overhauled to use the `mpd_utils` crate, which simplifies the code within Ironbar and should offer more robustness and better recovery when connection is lost to the server.

The launcher module in particular has been affected by the refactor.

src/clients/compositor/hyprland.rs

@@ -6,23 +6,26 @@ use hyprland::dispatch::{Dispatch, DispatchType, WorkspaceIdentifierWithSpecial}
 use hyprland::event_listener::EventListener;
 use hyprland::prelude::*;
 use hyprland::shared::{HyprDataVec, WorkspaceType};
-use lazy_static::lazy_static;
 use tokio::sync::broadcast::{channel, Receiver, Sender};
 use tracing::{debug, error, info};
 
-pub struct EventClient {
+#[derive(Debug)]
+pub struct Client {
     workspace_tx: Sender<WorkspaceUpdate>,
     _workspace_rx: Receiver<WorkspaceUpdate>,
 }
 
-impl EventClient {
-    fn new() -> Self {
+impl Client {
+    pub(crate) fn new() -> Self {
         let (workspace_tx, workspace_rx) = channel(16);
 
-        Self {
+        let instance = Self {
             workspace_tx,
             _workspace_rx: workspace_rx,
-        }
+        };
+
+        instance.listen_workspace_events();
+        instance
     }
 
     fn listen_workspace_events(&self) {
@@ -203,7 +206,7 @@ impl EventClient {
     }
 }
 
-impl WorkspaceClient for EventClient {
+impl WorkspaceClient for Client {
     fn focus(&self, id: String) -> Result<()> {
         let identifier = match id.parse::<i32>() {
             Ok(inum) => WorkspaceIdentifierWithSpecial::Id(inum),
@@ -239,18 +242,6 @@ impl WorkspaceClient for EventClient {
     }
 }
 
-lazy_static! {
-    static ref CLIENT: EventClient = {
-        let client = EventClient::new();
-        client.listen_workspace_events();
-        client
-    };
-}
-
-pub fn get_client() -> &'static EventClient {
-    &CLIENT
-}
-
 fn get_workspace_name(name: WorkspaceType) -> String {
     match name {
         WorkspaceType::Regular(name) => name,

src/clients/compositor/mod.rs

@@ -1,6 +1,8 @@
+use crate::{await_sync, register_client};
 use cfg_if::cfg_if;
 use color_eyre::{Help, Report, Result};
-use std::fmt::{Display, Formatter};
+use std::fmt::{Debug, Display, Formatter};
+use std::sync::Arc;
 use tokio::sync::broadcast;
 use tracing::debug;
 
@@ -44,7 +46,7 @@ impl Compositor {
             }
         } else if std::env::var("HYPRLAND_INSTANCE_SIGNATURE").is_ok() {
             cfg_if! {
-                if #[cfg(feature = "workspaces+hyprland")] { Self::Hyprland}
+                if #[cfg(feature = "workspaces+hyprland")] { Self::Hyprland }
                 else { tracing::error!("Not compiled with Hyprland support"); Self::Unsupported }
             }
         } else {
@@ -52,15 +54,17 @@ impl Compositor {
         }
     }
 
-    /// Gets the workspace client for the current compositor
-    pub fn get_workspace_client() -> Result<&'static (dyn WorkspaceClient + Send)> {
+    /// Creates a new instance of
+    /// the workspace client for the current compositor.
+    pub fn create_workspace_client() -> Result<Arc<dyn WorkspaceClient + Send + Sync>> {
         let current = Self::get_current();
         debug!("Getting workspace client for: {current}");
         match current {
             #[cfg(feature = "workspaces+sway")]
-            Self::Sway => Ok(sway::get_sub_client()),
+            Self::Sway => await_sync(async { sway::Client::new().await })
+                .map(|client| Arc::new(client) as Arc<dyn WorkspaceClient + Send + Sync>),
             #[cfg(feature = "workspaces+hyprland")]
-            Self::Hyprland => Ok(hyprland::get_client()),
+            Self::Hyprland => Ok(Arc::new(hyprland::Client::new())),
             Self::Unsupported => Err(Report::msg("Unsupported compositor")
                 .note("Currently workspaces are only supported by Sway and Hyprland")),
         }
@@ -129,10 +133,12 @@ pub enum WorkspaceUpdate {
     Unknown,
 }
 
-pub trait WorkspaceClient {
+pub trait WorkspaceClient: Debug + Send + Sync {
     /// Requests the workspace with this name is focused.
     fn focus(&self, name: String) -> Result<()>;
 
     /// Creates a new to workspace event receiver.
     fn subscribe_workspace_change(&self) -> broadcast::Receiver<WorkspaceUpdate>;
 }
+
+register_client!(dyn WorkspaceClient, workspaces);

src/clients/compositor/sway.rs

@@ -1,32 +1,35 @@
 use super::{Visibility, Workspace, WorkspaceClient, WorkspaceUpdate};
 use crate::{await_sync, send, spawn};
-use async_once::AsyncOnce;
-use color_eyre::Report;
+use color_eyre::{Report, Result};
 use futures_util::StreamExt;
-use lazy_static::lazy_static;
 use std::sync::Arc;
 use swayipc_async::{Connection, Event, EventType, Node, WorkspaceChange, WorkspaceEvent};
 use tokio::sync::broadcast::{channel, Receiver, Sender};
 use tokio::sync::Mutex;
 use tracing::{info, trace};
 
-pub struct SwayEventClient {
+#[derive(Debug)]
+pub struct Client {
+    client: Arc<Mutex<Connection>>,
     workspace_tx: Sender<WorkspaceUpdate>,
     _workspace_rx: Receiver<WorkspaceUpdate>,
 }
 
-impl SwayEventClient {
-    fn new() -> Self {
+impl Client {
+    pub(crate) async fn new() -> Result<Self> {
+        // Avoid using `arc_mut!` here because we need tokio Mutex.
+        let client = Arc::new(Mutex::new(Connection::new().await?));
+        info!("Sway IPC subscription client connected");
+
         let (workspace_tx, workspace_rx) = channel(16);
 
         {
+            // create 2nd client as subscription takes ownership
+            let client = Connection::new().await?;
             let workspace_tx = workspace_tx.clone();
+
             spawn(async move {
-                let client = Connection::new().await?;
-                info!("Sway IPC subscription client connected");
-
                 let event_types = [EventType::Workspace];
-
                 let mut events = client.subscribe(event_types).await?;
 
                 while let Some(event) = events.next().await {
@@ -43,18 +46,18 @@ impl SwayEventClient {
             });
         }
 
-        Self {
+        Ok(Self {
+            client,
             workspace_tx,
             _workspace_rx: workspace_rx,
-        }
+        })
     }
 }
 
-impl WorkspaceClient for SwayEventClient {
-    fn focus(&self, id: String) -> color_eyre::Result<()> {
+impl WorkspaceClient for Client {
+    fn focus(&self, id: String) -> Result<()> {
         await_sync(async move {
-            let client = get_client().await;
-            let mut client = client.lock().await;
+            let mut client = self.client.lock().await;
             client.run_command(format!("workspace {id}")).await
         })?;
         Ok(())
@@ -65,14 +68,12 @@ impl WorkspaceClient for SwayEventClient {
 
         {
             let tx = self.workspace_tx.clone();
-            await_sync(async {
-                let client = get_client().await;
-                let mut client = client.lock().await;
+            let client = self.client.clone();
+
+            await_sync(async {
+                let mut client = client.lock().await;
+                let workspaces = client.get_workspaces().await.expect("to get workspaces");
 
-                let workspaces = client
-                    .get_workspaces()
-                    .await
-                    .expect("Failed to get workspaces");
                 let event =
                     WorkspaceUpdate::Init(workspaces.into_iter().map(Workspace::from).collect());
 
@@ -84,27 +85,6 @@ impl WorkspaceClient for SwayEventClient {
     }
 }
 
-lazy_static! {
-    static ref CLIENT: AsyncOnce<Arc<Mutex<Connection>>> = AsyncOnce::new(async {
-        let client = Connection::new()
-            .await
-            .expect("Failed to connect to Sway socket");
-        Arc::new(Mutex::new(client))
-    });
-    static ref SUB_CLIENT: SwayEventClient = SwayEventClient::new();
-}
-
-/// Gets the sway IPC client
-async fn get_client() -> Arc<Mutex<Connection>> {
-    let client = CLIENT.get().await;
-    Arc::clone(client)
-}
-
-/// Gets the sway IPC event subscription client
-pub fn get_sub_client() -> &'static SwayEventClient {
-    &SUB_CLIENT
-}
-
 impl From<Node> for Workspace {
     fn from(node: Node) -> Self {
         let visibility = Visibility::from(&node);