Use async_trait in the network Adapter trait

rust/agama-dbus-server/src/network/adapter.rs

@@ -1,8 +1,10 @@
 use crate::network::NetworkState;
+use async_trait::async_trait;
 use std::error::Error;
 
 /// A trait for the ability to read/write from/to a network service
+#[async_trait]
 pub trait Adapter {
-    fn read(&self) -> Result<NetworkState, Box<dyn Error>>;
-    fn write(&self, network: &NetworkState) -> Result<(), Box<dyn Error>>;
+    async fn read(&self) -> Result<NetworkState, Box<dyn Error>>;
+    async fn write(&self, network: &NetworkState) -> Result<(), Box<dyn Error>>;
 }

rust/agama-dbus-server/src/network/nm/adapter.rs

@@ -4,8 +4,8 @@ use crate::network::{
     Adapter,
 };
 use agama_lib::error::ServiceError;
+use async_trait::async_trait;
 use log;
-use tokio::{runtime::Handle, task};
 
 /// An adapter for NetworkManager
 pub struct NetworkManagerAdapter<'a> {
@@ -27,16 +27,12 @@ impl<'a> NetworkManagerAdapter<'a> {
     }
 }
 
+#[async_trait]
 impl<'a> Adapter for NetworkManagerAdapter<'a> {
-    fn read(&self) -> Result<NetworkState, Box<dyn std::error::Error>> {
-        task::block_in_place(|| {
-            Handle::current().block_on(async {
-                let devices = self.client.devices().await?;
-                let connections = self.client.connections().await?;
-
-                Ok(NetworkState::new(devices, connections))
-            })
-        })
+    async fn read(&self) -> Result<NetworkState, Box<dyn std::error::Error>> {
+        let devices = self.client.devices().await?;
+        let connections = self.client.connections().await?;
+        Ok(NetworkState::new(devices, connections))
     }
 
     /// Writes the connections to NetworkManager.
@@ -46,31 +42,27 @@ impl<'a> Adapter for NetworkManagerAdapter<'a> {
     /// simpler approach.
     ///
     /// * `network`: network model.
-    fn write(&self, network: &NetworkState) -> Result<(), Box<dyn std::error::Error>> {
+    async fn write(&self, network: &NetworkState) -> Result<(), Box<dyn std::error::Error>> {
         // By now, traits do not support async functions. Using `task::block_on` allows
         // to use 'await'.
-        task::block_in_place(|| {
-            Handle::current().block_on(async {
-                for conn in ordered_connections(network) {
-                    if !Self::is_writable(conn) {
-                        continue;
-                    }
+        for conn in ordered_connections(network) {
+            if !Self::is_writable(conn) {
+                continue;
+            }
 
-                    let result = if conn.is_removed() {
-                        self.client.remove_connection(conn.uuid).await
-                    } else {
-                        let ctrl = conn
-                            .controller
-                            .and_then(|uuid| network.get_connection_by_uuid(uuid));
-                        self.client.add_or_update_connection(conn, ctrl).await
-                    };
+            let result = if conn.is_removed() {
+                self.client.remove_connection(conn.uuid).await
+            } else {
+                let ctrl = conn
+                    .controller
+                    .and_then(|uuid| network.get_connection_by_uuid(uuid));
+                self.client.add_or_update_connection(conn, ctrl).await
+            };
 
-                    if let Err(e) = result {
-                        log::error!("Could not process the connection {}: {}", conn.id, e);
-                    }
-                }
-            })
-        });
+            if let Err(e) = result {
+                log::error!("Could not process the connection {}: {}", conn.id, e);
+            }
+        }
         // FIXME: indicate which connections could not be written.
         Ok(())
     }

rust/agama-dbus-server/src/network/system.rs

@@ -33,8 +33,8 @@ impl<T: Adapter> NetworkSystem<T> {
 
     /// Writes the network configuration.
     pub async fn write(&mut self) -> Result<(), Box<dyn Error>> {
-        self.adapter.write(&self.state)?;
-        self.state = self.adapter.read()?;
+        self.adapter.write(&self.state).await?;
+        self.state = self.adapter.read().await?;
         Ok(())
     }
 
@@ -47,7 +47,7 @@ impl<T: Adapter> NetworkSystem<T> {
 
     /// Populates the D-Bus tree with the known devices and connections.
     pub async fn setup(&mut self) -> Result<(), Box<dyn Error>> {
-        self.state = self.adapter.read()?;
+        self.state = self.adapter.read().await?;
         self.tree
             .set_connections(&mut self.state.connections)
             .await?;

rust/agama-dbus-server/tests/network.rs

@@ -11,19 +11,24 @@ use agama_lib::network::{
     types::DeviceType,
     NetworkClient,
 };
+use async_trait::async_trait;
 use cidr::IpInet;
 use std::error::Error;
 use tokio::test;
 
 #[derive(Default)]
 pub struct NetworkTestAdapter(network::NetworkState);
 
+#[async_trait]
 impl Adapter for NetworkTestAdapter {
-    fn read(&self) -> Result<network::NetworkState, Box<dyn std::error::Error>> {
+    async fn read(&self) -> Result<network::NetworkState, Box<dyn std::error::Error>> {
         Ok(self.0.clone())
     }
 
-    fn write(&self, _network: &network::NetworkState) -> Result<(), Box<dyn std::error::Error>> {
+    async fn write(
+        &self,
+        _network: &network::NetworkState,
+    ) -> Result<(), Box<dyn std::error::Error>> {
         unimplemented!("Not used in tests");
     }
 }