Use the attributes-based D-Bus API to prevent storage deadlocks

rust/Cargo.toml

@@ -16,6 +16,7 @@ members = [
     "agama-server",
     "agama-software",
     "agama-storage",
+    "agama-storage-client",
     "agama-transfer",
     "agama-utils",
     "agama-users",

rust/agama-bootloader/Cargo.toml

@@ -6,6 +6,7 @@ edition.workspace = true
 
 [dependencies]
 agama-utils = { path = "../agama-utils" }
+agama-storage-client = { path = "../agama-storage-client" }
 anyhow = "1.0.99"
 async-trait = "0.1.89"
 gettext-rs = { version = "0.7.2", features = ["gettext-system"] }

rust/agama-bootloader/src/client.rs

@@ -22,12 +22,10 @@
 
 use std::collections::HashMap;
 
-use agama_utils::api::bootloader::Config;
+use agama_storage_client::message;
+use agama_utils::{actor::Handler, api::bootloader::Config};
 use async_trait::async_trait;
 use serde::{Deserialize, Serialize};
-use zbus::Connection;
-
-use crate::dbus::BootloaderProxy;
 
 /// Errors that can occur when using the Bootloader client.
 #[derive(thiserror::Error, Debug)]
@@ -38,6 +36,8 @@ pub enum Error {
     /// Error parsing or generating JSON data.
     #[error("Passed json data is not correct: {0}")]
     InvalidJson(#[from] serde_json::Error),
+    #[error("Storage D-Bus server error: {0}")]
+    DBusClient(#[from] agama_storage_client::Error),
 }
 
 /// Trait defining the interface for the Bootloader client.
@@ -71,28 +71,27 @@ pub type ClientResult<T> = Result<T, Error>;
 
 /// Client to connect to Agama's D-Bus API for Bootloader management.
 #[derive(Clone)]
-pub struct Client<'a> {
-    bootloader_proxy: BootloaderProxy<'a>,
+pub struct Client {
+    storage_dbus: Handler<agama_storage_client::Service>,
     kernel_args: HashMap<String, String>,
 }
 
-impl<'a> Client<'a> {
-    pub async fn new(connection: Connection) -> ClientResult<Client<'a>> {
-        let bootloader_proxy = BootloaderProxy::new(&connection).await?;
-
+impl Client {
+    pub async fn new(storage_dbus: Handler<agama_storage_client::Service>) -> ClientResult<Client> {
         Ok(Self {
-            bootloader_proxy,
+            storage_dbus,
             kernel_args: HashMap::new(),
         })
     }
 }
 
 #[async_trait]
-impl<'a> BootloaderClient for Client<'a> {
+impl BootloaderClient for Client {
     async fn get_config(&self) -> ClientResult<Config> {
-        let serialized_string = self.bootloader_proxy.get_config().await?;
-        let settings = serde_json::from_str(serialized_string.as_str())?;
-        Ok(settings)
+        Ok(self
+            .storage_dbus
+            .call(message::bootloader::GetConfig)
+            .await?)
     }
 
     async fn set_config(&self, config: &Config) -> ClientResult<()> {
@@ -103,8 +102,9 @@ impl<'a> BootloaderClient for Client<'a> {
         tracing::info!("sending bootloader config {:?}", full_config);
         // ignore return value as currently it does not fail and who knows what future brings
         // but it should not be part of result and instead transformed to Issue
-        self.bootloader_proxy
-            .set_config(serde_json::to_string(&full_config)?.as_str())
+        let value = serde_json::to_value(&full_config)?;
+        self.storage_dbus
+            .call(message::bootloader::SetConfig::new(value))
             .await?;
         Ok(())
     }

rust/agama-bootloader/src/lib.rs

@@ -39,6 +39,5 @@ pub mod service;
 pub use service::{Service, Starter};
 
 pub mod client;
-mod dbus;
 pub mod message;
 pub mod test_utils;

rust/agama-bootloader/src/service.rs

@@ -35,6 +35,8 @@ pub enum Error {
     Actor(#[from] actor::Error),
     #[error(transparent)]
     Client(#[from] client::Error),
+    #[error("Storage D-Bus server error: {0}")]
+    DBusClient(#[from] agama_storage_client::Error),
 }
 
 /// Builds and spawns the bootloader service.
@@ -67,7 +69,13 @@ impl Starter {
     pub async fn start(self) -> Result<Handler<Service>, Error> {
         let client = match self.client {
             Some(client) => client,
-            None => Box::new(Client::new(self.connection.clone()).await?),
+            None => {
+                let storage_dbus =
+                    agama_storage_client::service::Starter::new(self.connection.clone())
+                        .start()
+                        .await?;
+                Box::new(Client::new(storage_dbus).await?)
+            }
         };
         let service = Service { client };
         let handler = actor::spawn(service);

rust/agama-iscsi/Cargo.toml

@@ -7,6 +7,7 @@ edition.workspace = true
 [dependencies]
 agama-utils = { path = "../agama-utils" }
 agama-storage = { path = "../agama-storage" }
+agama-storage-client = { path = "../agama-storage-client" }
 thiserror = "2.0.16"
 async-trait = "0.1.89"
 zbus = "5.7.1"

rust/agama-iscsi/src/client.rs

@@ -18,21 +18,23 @@
 // To contact SUSE LLC about this file by physical or electronic mail, you may
 // find current contact information at www.suse.com.
 
-//! Implements a client to access Agama's D-Bus API related to Bootloader management.
+//! Implements a client to access Agama's D-Bus API related to iSCSI management.
 
-use crate::dbus::ISCSIProxy;
+use agama_storage_client::message;
+use agama_utils::actor::Handler;
 use agama_utils::api::iscsi::Config;
 use agama_utils::api::iscsi::DiscoverConfig;
 use async_trait::async_trait;
 use serde_json::Value;
-use zbus::Connection;
 
 #[derive(Debug, thiserror::Error)]
 pub enum Error {
     #[error(transparent)]
     DBus(#[from] zbus::Error),
     #[error(transparent)]
     Json(#[from] serde_json::Error),
+    #[error("Storage D-Bus server error: {0}")]
+    DBusClient(#[from] agama_storage_client::Error),
 }
 
 pub enum DiscoverResult {
@@ -49,23 +51,24 @@ pub trait ISCSIClient {
 }
 
 #[derive(Clone)]
-pub struct Client<'a> {
-    proxy: ISCSIProxy<'a>,
+pub struct Client {
+    storage_dbus: Handler<agama_storage_client::Service>,
 }
 
-impl<'a> Client<'a> {
-    pub async fn new(connection: Connection) -> Result<Client<'a>, Error> {
-        let proxy = ISCSIProxy::new(&connection).await?;
-        Ok(Self { proxy })
+impl Client {
+    pub async fn new(
+        storage_dbus: Handler<agama_storage_client::Service>,
+    ) -> Result<Client, Error> {
+        Ok(Self { storage_dbus })
     }
 }
 
 #[async_trait]
-impl<'a> ISCSIClient for Client<'a> {
+impl ISCSIClient for Client {
     async fn discover(&self, config: DiscoverConfig) -> Result<DiscoverResult, Error> {
         let result = self
-            .proxy
-            .discover(serde_json::to_string(&config)?.as_str())
+            .storage_dbus
+            .call(message::iscsi::Discover::new(config))
             .await?;
         match result {
             0 => Ok(DiscoverResult::Success),
@@ -74,26 +77,16 @@ impl<'a> ISCSIClient for Client<'a> {
     }
 
     async fn get_system(&self) -> Result<Option<Value>, Error> {
-        let serialized_system = self.proxy.get_system().await?;
-        let system: Value = serde_json::from_str(serialized_system.as_str())?;
-        match system {
-            Value::Null => Ok(None),
-            _ => Ok(Some(system)),
-        }
+        Ok(self.storage_dbus.call(message::iscsi::GetSystem).await?)
     }
 
     async fn get_config(&self) -> Result<Option<Config>, Error> {
-        let serialized_config = self.proxy.get_config().await?;
-        let value: Value = serde_json::from_str(serialized_config.as_str())?;
-        match value {
-            Value::Null => Ok(None),
-            _ => Ok(Some(Config(value))),
-        }
+        Ok(self.storage_dbus.call(message::iscsi::GetConfig).await?)
     }
 
     async fn set_config(&self, config: Option<Config>) -> Result<(), Error> {
-        self.proxy
-            .set_config(serde_json::to_string(&config)?.as_str())
+        self.storage_dbus
+            .call(message::iscsi::SetConfig::new(config))
             .await?;
         Ok(())
     }

rust/agama-iscsi/src/lib.rs

@@ -25,7 +25,6 @@ pub mod client;
 pub mod message;
 pub mod test_utils;
 
-mod dbus;
 mod monitor;
 
 use agama_storage as storage;

rust/agama-iscsi/src/monitor.rs

@@ -18,10 +18,8 @@
 // To contact SUSE LLC about this file by physical or electronic mail, you may
 // find current contact information at www.suse.com.
 
-use crate::{
-    dbus::{ISCSIProxy, ProgressChanged, ProgressFinished, SystemChanged},
-    storage,
-};
+use crate::storage;
+use agama_storage_client::proxies::{ISCSIProxy, ProgressChanged, ProgressFinished, SystemChanged};
 use agama_utils::{
     actor::Handler,
     api::{
@@ -130,7 +128,7 @@ impl Monitor {
 
     async fn handle_progress_changed(&self, signal: ProgressChanged) -> Result<(), Error> {
         let args = signal.args()?;
-        let progress_data = serde_json::from_str::<ProgressData>(args.progress)?;
+        let progress_data = serde_json::from_str::<ProgressData>(args.serialized_progress)?;
         self.progress
             .call(progress::message::SetProgress::new(progress_data.into()))
             .await?;

rust/agama-iscsi/src/service.rs

@@ -40,6 +40,8 @@ pub enum Error {
     Client(#[from] client::Error),
     #[error(transparent)]
     Monitor(#[from] monitor::Error),
+    #[error("Storage D-Bus server error: {0}")]
+    DBusClient(#[from] agama_storage_client::Error),
 }
 
 pub struct Starter {
@@ -74,7 +76,13 @@ impl Starter {
     pub async fn start(self) -> Result<Handler<Service>, Error> {
         let client = match self.client {
             Some(client) => client,
-            None => Box::new(Client::new(self.connection.clone()).await?),
+            None => {
+                let storage_dbus =
+                    agama_storage_client::service::Starter::new(self.connection.clone())
+                        .start()
+                        .await?;
+                Box::new(Client::new(storage_dbus).await?)
+            }
         };
         let service = Service { client };
         let handler = actor::spawn(service);

rust/agama-manager/src/service.rs

@@ -722,6 +722,7 @@ impl MessageHandler<message::SetConfig> for Service {
     /// Sets the user configuration with the given values.
     async fn handle(&mut self, message: message::SetConfig) -> Result<(), Error> {
         checks::check_stage(&self.progress, Stage::Configuring).await?;
+        tracing::debug!("DEBUG: SetConfig handler (calling set_config)");
         self.set_config(message.config).await
     }
 }

rust/agama-manager/src/tasks/runner.rs

@@ -410,12 +410,14 @@ impl SetConfigAction {
                 self.progress
                     .call(progress::message::Next::new(Scope::Manager))
                     .await?;
-                self.storage
+                let future = self
+                    .storage
                     .call(storage::message::SetConfig::new(
                         Arc::clone(product),
                         config.storage.clone(),
                     ))
                     .await?;
+                let _ = future.await;
 
                 // call bootloader always after storage to ensure that bootloader reflect new storage settings
                 self.progress

rust/agama-s390/Cargo.toml

@@ -7,6 +7,7 @@ edition.workspace = true
 [dependencies]
 agama-utils = { path = "../agama-utils" }
 agama-storage = { path = "../agama-storage" }
+agama-storage-client = { path = "../agama-storage-client" }
 thiserror = "2.0.16"
 async-trait = "0.1.89"
 zbus = "5.7.1"

rust/agama-s390/src/dasd.rs

@@ -23,5 +23,3 @@ pub use client::Client;
 
 pub mod monitor;
 pub use monitor::Monitor;
-
-mod dbus;