Adapt some missing web API methods to the new NetworkSystem

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

@@ -1,17 +1,14 @@
 use super::{
     error::NetworkStateError,
-    model::{Device, StateConfig},
+    model::{AccessPoint, Device, StateConfig},
     NetworkAdapterError,
 };
 use crate::network::{
     dbus::Tree,
     model::{Connection, GeneralState},
     Action, Adapter, NetworkState,
 };
-use agama_lib::{
-    error::ServiceError,
-    network::{settings::NetworkConnection, types::DeviceType},
-};
+use agama_lib::{error::ServiceError, network::types::DeviceType};
 use std::{error::Error, sync::Arc};
 use tokio::sync::{
     mpsc::{self, error::SendError, UnboundedReceiver, UnboundedSender},
@@ -117,9 +114,7 @@ impl<T: Adapter + Send + 'static> NetworkSystem<T> {
 /// It hides the details of the message-passing behind a convenient API.
 #[derive(Clone)]
 pub struct NetworkSystemClient {
-    /// Channel to talk to the server. This field is temporarily public, but it will
-    /// be set to private once web interface is adapted.
-    pub actions: UnboundedSender<Action>,
+    actions: UnboundedSender<Action>,
 }
 
 // TODO: add a NetworkSystemError type
@@ -203,6 +198,21 @@ impl NetworkSystemClient {
         let result = rx.await?;
         Ok(result?)
     }
+
+    /// Returns the collection of access points.
+    pub async fn get_access_points(&self) -> Result<Vec<AccessPoint>, NetworkSystemError> {
+        let (tx, rx) = oneshot::channel();
+        self.actions.send(Action::GetAccessPoints(tx))?;
+        let access_points = rx.await?;
+        Ok(access_points)
+    }
+
+    pub async fn wifi_scan(&self) -> Result<(), NetworkSystemError> {
+        let (tx, rx) = oneshot::channel();
+        self.actions.send(Action::RefreshScan(tx)).unwrap();
+        let result = rx.await?;
+        Ok(result?)
+    }
 }
 
 struct NetworkSystemServer<T: Adapter> {

rust/agama-server/src/network/web.rs

@@ -91,17 +91,11 @@ pub async fn network_service<T: Adapter + std::marker::Send + 'static>(
 #[utoipa::path(get, path = "/network/state", responses(
   (status = 200, description = "Get general network config", body = GenereralState)
 ))]
-async fn general_state(State(state): State<NetworkState>) -> Json<GeneralState> {
-    let (tx, rx) = oneshot::channel();
-    state
-        .network
-        .actions
-        .send(Action::GetGeneralState(tx))
-        .unwrap();
-
-    let state = rx.await.unwrap();
-
-    Json(state)
+async fn general_state(
+    State(state): State<NetworkState>,
+) -> Result<Json<GeneralState>, NetworkError> {
+    let general_state = state.network.get_state().await?;
+    Ok(Json(general_state))
 }
 
 #[utoipa::path(put, path = "/network/state", responses(
@@ -119,28 +113,20 @@ async fn update_general_state(
 #[utoipa::path(get, path = "/network/wifi", responses(
   (status = 200, description = "List of wireless networks", body = Vec<AccessPoint>)
 ))]
-async fn wifi_networks(State(state): State<NetworkState>) -> Json<Vec<AccessPoint>> {
-    let (tx, rx) = oneshot::channel();
-    state.network.actions.send(Action::RefreshScan(tx)).unwrap();
-    let _ = rx.await.unwrap();
-    let (tx, rx) = oneshot::channel();
-    state
-        .network
-        .actions
-        .send(Action::GetAccessPoints(tx))
-        .unwrap();
-
-    let access_points = rx.await.unwrap();
+async fn wifi_networks(
+    State(state): State<NetworkState>,
+) -> Result<Json<Vec<AccessPoint>>, NetworkError> {
+    state.network.wifi_scan().await?;
+    let access_points = state.network.get_access_points().await?;
 
     let mut networks = vec![];
-
     for ap in access_points {
         if !ap.ssid.to_string().is_empty() {
             networks.push(ap);
         }
     }
 
-    Json(networks)
+    Ok(Json(networks))
 }
 
 #[utoipa::path(get, path = "/network/devices", responses(