Feat/rework cardwire dbus

crates/cardwire-cli/src/args.rs

@@ -36,12 +36,16 @@ pub enum Commands {
 
     #[command(about = "Print the gpu list")]
     List {
-        #[arg(long, help("Print the whole gpu list"), action(ArgAction::SetTrue))]
+        #[arg(
+            long,
+            help("Print the whole pci list"),
+            action(clap::ArgAction::SetTrue)
+        )]
         full: bool,
         #[arg(
             long,
             help("Print the gpu list in json format"),
-            action(ArgAction::SetTrue)
+            action(clap::ArgAction::SetTrue)
         )]
         json: bool,
     },
@@ -55,12 +59,67 @@ pub enum Commands {
         #[command(flatten)]
         action: GpuAction,
     },
+
+    #[command(about = "Manage daemon configuration", arg_required_else_help = true)]
+    Config {
+        #[command(subcommand)]
+        action: ConfigAction,
+    },
+
+    #[command(about = "Manager operations", arg_required_else_help = true)]
+    Manager {
+        #[command(subcommand)]
+        action: ManagerAction,
+    },
+
+    #[command(about = "Debug operations", arg_required_else_help = true)]
+    Debug {
+        #[command(subcommand)]
+        action: DebugAction,
+    },
+
     #[command(about = "Generate shell completions", hide = true)]
     Completion {
         #[arg(help = "The shell to generate the completions for")]
         shell: Shell,
     },
 }
+
+#[derive(Subcommand, Debug)]
+pub enum ConfigAction {
+    #[command(about = "Get or set AutoApplyGpuState")]
+    AutoApplyGpuState {
+        #[arg(help = "Value to set")]
+        set: Option<bool>,
+    },
+    #[command(about = "Get or set ExperimentalNvidiaBlock")]
+    ExperimentalNvidiaBlock {
+        #[arg(help = "Value to set")]
+        set: Option<bool>,
+    },
+    #[command(about = "Get or set BatteryAutoSwitch")]
+    BatteryAutoSwitch {
+        #[arg(help = "Value to set")]
+        set: Option<bool>,
+    },
+    #[command(about = "Save current configuration to file")]
+    Save,
+}
+
+#[derive(Subcommand, Debug)]
+pub enum ManagerAction {
+    #[command(about = "Check if daemon is alive")]
+    Status,
+    #[command(about = "Refresh GPU list in daemon")]
+    RefreshGpu,
+}
+
+#[derive(Subcommand, Debug)]
+pub enum DebugAction {
+    #[command(about = "Run GPU diagnostics")]
+    DiagnosticGpu,
+}
+
 #[derive(ClapArgs, Debug)]
 #[group(required = true, multiple = false)]
 pub struct GpuAction {
@@ -70,6 +129,6 @@ pub struct GpuAction {
     #[arg(long, help = "Unblock a specific gpu")]
     pub unblock: bool,
 
-    #[arg(long, help = "Get gpu status")]
-    pub status: bool,
+    #[arg(long, help = "List open files on the GPU")]
+    pub lsof: bool,
 }

crates/cardwire-cli/src/dbus.rs

@@ -1,7 +1,16 @@
-use crate::display::{GpuDevice, PciDevice};
-use std::collections::BTreeMap;
-
 use zbus::{Proxy, connection::Connection};
+
+#[derive(serde::Deserialize, serde::Serialize, zbus::zvariant::Type, Debug)]
+pub struct DbusGpuDevice {
+    pub name: String,
+    pub pci: String,
+    pub render: u32,
+    pub card: u32,
+    pub default: bool,
+    pub nvidia: bool,
+    pub nvidia_minor: String,
+}
+
 pub struct DaemonClient<'a> {
     proxy: Proxy<'a>,
 }
@@ -19,25 +28,207 @@ impl<'a> DaemonClient<'a> {
         Ok(Self { proxy })
     }
 
+    pub async fn get_managed_objects(
+        &self,
+    ) -> zbus::fdo::Result<
+        std::collections::HashMap<
+            zbus::zvariant::OwnedObjectPath,
+            std::collections::HashMap<
+                zbus::names::OwnedInterfaceName,
+                std::collections::HashMap<String, zbus::zvariant::OwnedValue>,
+            >,
+        >,
+    > {
+        let proxy = zbus::fdo::ObjectManagerProxy::builder(self.proxy.connection())
+            .destination("com.github.opengamingcollective.cardwire")?
+            .path("/com/github/opengamingcollective/cardwire")?
+            .build()
+            .await?;
+        proxy.get_managed_objects().await
+    }
+
+    pub async fn get_device(&self, id: u32) -> zbus::Result<DbusGpuDevice> {
+        let path = format!("/com/github/opengamingcollective/cardwire/Gpu/{}", id);
+        let proxy = zbus::Proxy::new(
+            self.proxy.connection(),
+            "com.github.opengamingcollective.cardwire",
+            path.as_str(),
+            "com.github.opengamingcollective.cardwire.Gpu",
+        )
+        .await?;
+        proxy.call("GetDevice", &()).await
+    }
+
     pub async fn set_mode(&self, mode: &u32) -> zbus::fdo::Result<()> {
-        self.proxy.set_property("Mode", mode).await
+        let proxy = zbus::Proxy::new(
+            self.proxy.connection(),
+            "com.github.opengamingcollective.cardwire",
+            "/com/github/opengamingcollective/cardwire",
+            "com.github.opengamingcollective.cardwire.Mode",
+        )
+        .await
+        .map_err(|e| zbus::fdo::Error::Failed(format!("Failed to create Mode proxy: {}", e)))?;
+        proxy.set_property("Mode", mode).await
     }
 
     pub async fn get_mode(&self) -> zbus::Result<u32> {
-        self.proxy.get_property("Mode").await
+        let proxy = zbus::Proxy::new(
+            self.proxy.connection(),
+            "com.github.opengamingcollective.cardwire",
+            "/com/github/opengamingcollective/cardwire",
+            "com.github.opengamingcollective.cardwire.Mode",
+        )
+        .await?;
+        proxy.get_property("Mode").await
+    }
+
+    pub async fn set_gpu_block(&self, id: u32, blocked: bool) -> zbus::fdo::Result<()> {
+        let path = format!("/com/github/opengamingcollective/cardwire/Gpu/{}", id);
+        let block_proxy = zbus::Proxy::new(
+            self.proxy.connection(),
+            "com.github.opengamingcollective.cardwire",
+            path.as_str(),
+            "com.github.opengamingcollective.cardwire.Gpu",
+        )
+        .await
+        .map_err(|e| zbus::fdo::Error::Failed(format!("Failed to create proxy: {}", e)))?;
+        block_proxy.set_property("Block", &(blocked)).await
+    }
+
+    pub async fn get_status(&self, id: u32) -> zbus::Result<bool> {
+        let path = format!("/com/github/opengamingcollective/cardwire/Gpu/{}", id);
+        let block_proxy = zbus::Proxy::new(
+            self.proxy.connection(),
+            "com.github.opengamingcollective.cardwire",
+            path.as_str(),
+            "com.github.opengamingcollective.cardwire.Gpu",
+        )
+        .await?;
+        block_proxy.get_property("Block").await
+    }
+
+    pub async fn lsof(
+        &self,
+        id: u32,
+    ) -> zbus::Result<std::collections::HashMap<String, Vec<String>>> {
+        let path = format!("/com/github/opengamingcollective/cardwire/Gpu/{}", id);
+        let proxy = zbus::Proxy::new(
+            self.proxy.connection(),
+            "com.github.opengamingcollective.cardwire",
+            path.as_str(),
+            "com.github.opengamingcollective.cardwire.Gpu",
+        )
+        .await?;
+        proxy.call("Lsof", &()).await
+    }
+
+    pub async fn get_auto_apply_gpu_state(&self) -> zbus::Result<bool> {
+        let proxy = zbus::Proxy::new(
+            self.proxy.connection(),
+            "com.github.opengamingcollective.cardwire",
+            "/com/github/opengamingcollective/cardwire",
+            "com.github.opengamingcollective.cardwire.Config",
+        )
+        .await?;
+        proxy.get_property("AutoApplyGpuState").await
+    }
+    pub async fn set_auto_apply_gpu_state(&self, state: bool) -> zbus::fdo::Result<()> {
+        let proxy = zbus::Proxy::new(
+            self.proxy.connection(),
+            "com.github.opengamingcollective.cardwire",
+            "/com/github/opengamingcollective/cardwire",
+            "com.github.opengamingcollective.cardwire.Config",
+        )
+        .await
+        .map_err(|e| zbus::fdo::Error::Failed(e.to_string()))?;
+        proxy.set_property("AutoApplyGpuState", state).await
     }
 
-    pub async fn list_devices(&self) -> zbus::Result<BTreeMap<usize, GpuDevice>> {
-        self.proxy.call("ListDevices", &()).await
+    pub async fn get_experimental_nvidia_block(&self) -> zbus::Result<bool> {
+        let proxy = zbus::Proxy::new(
+            self.proxy.connection(),
+            "com.github.opengamingcollective.cardwire",
+            "/com/github/opengamingcollective/cardwire",
+            "com.github.opengamingcollective.cardwire.Config",
+        )
+        .await?;
+        proxy.get_property("ExperimentalNvidiaBlock").await
     }
-    pub async fn list_devices_pci(&self) -> zbus::Result<BTreeMap<String, PciDevice>> {
-        self.proxy.call("ListDevicesPci", &()).await
+    pub async fn set_experimental_nvidia_block(&self, state: bool) -> zbus::fdo::Result<()> {
+        let proxy = zbus::Proxy::new(
+            self.proxy.connection(),
+            "com.github.opengamingcollective.cardwire",
+            "/com/github/opengamingcollective/cardwire",
+            "com.github.opengamingcollective.cardwire.Config",
+        )
+        .await
+        .map_err(|e| zbus::fdo::Error::Failed(e.to_string()))?;
+        proxy.set_property("ExperimentalNvidiaBlock", state).await
     }
 
-    pub async fn set_gpu_block(&self, id: u32, blocked: bool) -> zbus::Result<()> {
-        self.proxy.call("SetGpuBlock", &(id, blocked)).await
+    pub async fn get_battery_auto_switch(&self) -> zbus::Result<bool> {
+        let proxy = zbus::Proxy::new(
+            self.proxy.connection(),
+            "com.github.opengamingcollective.cardwire",
+            "/com/github/opengamingcollective/cardwire",
+            "com.github.opengamingcollective.cardwire.Config",
+        )
+        .await?;
+        proxy.get_property("BatteryAutoSwitch").await
+    }
+    pub async fn set_battery_auto_switch(&self, state: bool) -> zbus::fdo::Result<()> {
+        let proxy = zbus::Proxy::new(
+            self.proxy.connection(),
+            "com.github.opengamingcollective.cardwire",
+            "/com/github/opengamingcollective/cardwire",
+            "com.github.opengamingcollective.cardwire.Config",
+        )
+        .await
+        .map_err(|e| zbus::fdo::Error::Failed(e.to_string()))?;
+        proxy.set_property("BatteryAutoSwitch", state).await
     }
-    pub async fn get_status(&self, id: u32) -> zbus::Result<String> {
-        self.proxy.call("GetStatus", &id).await
+
+    pub async fn save_to_file(&self) -> zbus::Result<()> {
+        let proxy = zbus::Proxy::new(
+            self.proxy.connection(),
+            "com.github.opengamingcollective.cardwire",
+            "/com/github/opengamingcollective/cardwire",
+            "com.github.opengamingcollective.cardwire.Config",
+        )
+        .await?;
+        proxy.call("SaveToFile", &()).await
+    }
+
+    pub async fn refresh_gpu(&self) -> zbus::Result<()> {
+        let proxy = zbus::Proxy::new(
+            self.proxy.connection(),
+            "com.github.opengamingcollective.cardwire",
+            "/com/github/opengamingcollective/cardwire",
+            "com.github.opengamingcollective.cardwire.Manager",
+        )
+        .await?;
+        proxy.call("RefreshGpu", &()).await
+    }
+
+    pub async fn manager_status(&self) -> zbus::Result<()> {
+        let proxy = zbus::Proxy::new(
+            self.proxy.connection(),
+            "com.github.opengamingcollective.cardwire",
+            "/com/github/opengamingcollective/cardwire",
+            "com.github.opengamingcollective.cardwire.Manager",
+        )
+        .await?;
+        proxy.call("Status", &()).await
+    }
+
+    pub async fn diagnostic_gpu(&self) -> zbus::Result<()> {
+        let proxy = zbus::Proxy::new(
+            self.proxy.connection(),
+            "com.github.opengamingcollective.cardwire",
+            "/com/github/opengamingcollective/cardwire",
+            "com.github.opengamingcollective.cardwire.Debug",
+        )
+        .await?;
+        proxy.call("DiagnosticGpu", &()).await
     }
 }

crates/cardwire-cli/src/display.rs

@@ -10,15 +10,15 @@ use anyhow::{Ok, Result};
 // Here the struct are used to parse the json
 #[derive(serde::Deserialize, serde::Serialize, zbus::zvariant::Type, Debug)]
 pub struct GpuDevice {
-    id: u32,
-    name: String,
-    pci: String,
-    render: u32,
-    card: u32,
-    default: bool,
-    blocked: bool,
-    nvidia: bool,
-    nvidia_minor: String,
+    pub id: u32,
+    pub name: String,
+    pub pci: String,
+    pub render: u32,
+    pub card: u32,
+    pub default: bool,
+    pub blocked: bool,
+    pub nvidia: bool,
+    pub nvidia_minor: String,
 }
 #[derive(serde::Deserialize, serde::Serialize, zbus::zvariant::Type)]
 pub struct PciDevice {
@@ -99,12 +99,12 @@ fn pretty_print_gpu(gpu_list: BTreeMap<usize, GpuDevice>) {
         "-".repeat(default_w),
         "-".repeat(blocked_w),
     );
-    for (_, gpu) in gpu_list {
+    for (id, gpu) in gpu_list {
         let render_full = format!("renderD{}", gpu.render);
         let card_full = format!("card{}", gpu.card);
         println!(
             "{:<id_w$}  {:<name_w$}  {:<pci_w$}  {:<render_w$}  {:<card_w$}  {:<default_w$}  {:<blocked_w$}",
-            gpu.id,
+            id,
             gpu.name,
             gpu.pci,
             render_full,