feat: improve Wi-Fi networks handling

rust/agama-lib/src/network/types.rs

@@ -78,71 +78,40 @@ pub enum DeviceType {
     Bridge = 6,
 }
 
-// For now this mirrors NetworkManager, because it was less mental work than coming up with
-// what exactly Agama needs. Expected to be adapted.
-#[derive(Debug, Default, Clone, Copy, PartialEq, Serialize, Deserialize, utoipa::ToSchema)]
+/// Network device state.
+#[derive(
+    Default,
+    Serialize,
+    Deserialize,
+    Debug,
+    PartialEq,
+    Eq,
+    Clone,
+    Copy,
+    strum::Display,
+    strum::EnumString,
+    utoipa::ToSchema,
+)]
+#[strum(serialize_all = "camelCase")]
 #[serde(rename_all = "camelCase")]
 pub enum DeviceState {
     #[default]
-    Unknown = 0,
-    Unmanaged = 10,
-    Unavailable = 20,
-    Disconnected = 30,
-    Prepare = 40,
-    Config = 50,
-    NeedAuth = 60,
-    IpConfig = 70,
-    IpCheck = 80,
-    Secondaries = 90,
-    Activated = 100,
-    Deactivating = 110,
-    Failed = 120,
-}
-#[derive(Debug, Error, PartialEq)]
-#[error("Invalid state: {0}")]
-pub struct InvalidDeviceState(String);
-
-impl TryFrom<u8> for DeviceState {
-    type Error = InvalidDeviceState;
-
-    fn try_from(value: u8) -> Result<Self, Self::Error> {
-        match value {
-            0 => Ok(DeviceState::Unknown),
-            10 => Ok(DeviceState::Unmanaged),
-            20 => Ok(DeviceState::Unavailable),
-            30 => Ok(DeviceState::Disconnected),
-            40 => Ok(DeviceState::Prepare),
-            50 => Ok(DeviceState::Config),
-            60 => Ok(DeviceState::NeedAuth),
-            70 => Ok(DeviceState::IpConfig),
-            80 => Ok(DeviceState::IpCheck),
-            90 => Ok(DeviceState::Secondaries),
-            100 => Ok(DeviceState::Activated),
-            110 => Ok(DeviceState::Deactivating),
-            120 => Ok(DeviceState::Failed),
-            _ => Err(InvalidDeviceState(value.to_string())),
-        }
-    }
-}
-impl fmt::Display for DeviceState {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let name = match &self {
-            DeviceState::Unknown => "unknown",
-            DeviceState::Unmanaged => "unmanaged",
-            DeviceState::Unavailable => "unavailable",
-            DeviceState::Disconnected => "disconnected",
-            DeviceState::Prepare => "prepare",
-            DeviceState::Config => "config",
-            DeviceState::NeedAuth => "need_auth",
-            DeviceState::IpConfig => "ip_config",
-            DeviceState::IpCheck => "ip_check",
-            DeviceState::Secondaries => "secondaries",
-            DeviceState::Activated => "activated",
-            DeviceState::Deactivating => "deactivating",
-            DeviceState::Failed => "failed",
-        };
-        write!(f, "{}", name)
-    }
+    /// The device's state is unknown.
+    Unknown,
+    /// The device is recognized but not managed by Agama.
+    Unmanaged,
+    /// The device is detected but it cannot be used (wireless switched off, missing firmware, etc.).
+    Unavailable,
+    /// The device is connecting to the network.
+    Connecting,
+    /// The device is successfully connected to the network.
+    Connected,
+    /// The device is disconnecting from the network.
+    Disconnecting,
+    /// The device is disconnected from the network.
+    Disconnected,
+    /// The device failed to connect to a network.
+    Failed,
 }
 
 #[derive(Debug, Default, Clone, Copy, PartialEq, Serialize, Deserialize, utoipa::ToSchema)]

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

@@ -455,6 +455,7 @@ mod tests {
 /// Network state
 #[serde_as]
 #[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize, utoipa::ToSchema)]
+#[serde(rename_all = "camelCase")]
 pub struct GeneralState {
     pub hostname: String,
     pub connectivity: bool,
@@ -479,7 +480,7 @@ pub struct AccessPoint {
 /// Network device
 #[serde_as]
 #[skip_serializing_none]
-#[derive(Default, Debug, Clone, Serialize, utoipa::ToSchema)]
+#[derive(Default, Debug, Clone, PartialEq, Serialize, utoipa::ToSchema)]
 #[serde(rename_all = "camelCase")]
 pub struct Device {
     pub name: String,
@@ -491,7 +492,6 @@ pub struct Device {
     // Connection.id
     pub connection: Option<String>,
     pub state: DeviceState,
-    pub state_reason: u8,
 }
 
 /// Represents a known network connection.

rust/agama-server/src/network/nm/builder.rs

@@ -35,6 +35,8 @@ use anyhow::Context;
 use cidr::IpInet;
 use std::{collections::HashMap, net::IpAddr, str::FromStr};
 
+use super::model::NmDeviceState;
+
 /// Builder to create a [Device] from its corresponding NetworkManager D-Bus representation.
 pub struct DeviceFromProxyBuilder<'a> {
     connection: zbus::Connection,
@@ -57,21 +59,14 @@ impl<'a> DeviceFromProxyBuilder<'a> {
             .try_into()
             .context("Unsupported device type: {device_type}")?;
 
-        let state = self.proxy.state().await? as u8;
-        let (_, state_reason) = self.proxy.state_reason().await?;
-        let state: DeviceState = state
-            .try_into()
-            .context("Unsupported device state: {state}")?;
-
         let mut device = Device {
             name: self.proxy.interface().await?,
+            state: self.device_state_from_proxy().await?,
             type_,
-            state,
-            state_reason: state_reason as u8,
             ..Default::default()
         };
 
-        if state == DeviceState::Activated {
+        if device.state == DeviceState::Connected {
             device.ip_config = self.build_ip_config().await?;
         }
 
@@ -249,4 +244,44 @@ impl<'a> DeviceFromProxyBuilder<'a> {
 
         Some(id.to_string())
     }
+
+    /// Map the combination of state + reason to the Agama set of states.
+    ///
+    /// See https://www.networkmanager.dev/docs/api/latest/nm-dbus-types.html#NMDeviceState
+    /// and https://www.networkmanager.dev/docs/api/latest/nm-dbus-types.html#NMDeviceStateReason
+    /// for further information.
+    async fn device_state_from_proxy(&self) -> Result<DeviceState, ServiceError> {
+        const USER_REQUESTED: u32 = 39;
+
+        let (state, reason) = self.proxy.state_reason().await?;
+        let state: NmDeviceState = (state as u8)
+            .try_into()
+            .context("Unsupported device state: {state}")?;
+
+        let device_state = match state {
+            NmDeviceState::Unknown => DeviceState::Unknown,
+            NmDeviceState::Unmanaged => DeviceState::Unmanaged,
+            NmDeviceState::Unavailable => DeviceState::Unavailable,
+            NmDeviceState::Prepare
+            | NmDeviceState::IpConfig
+            | NmDeviceState::NeedAuth
+            | NmDeviceState::Config
+            | NmDeviceState::Secondaries
+            | NmDeviceState::IpCheck => DeviceState::Connecting,
+            NmDeviceState::Activated => DeviceState::Connected,
+            NmDeviceState::Deactivating => DeviceState::Disconnecting,
+            NmDeviceState::Disconnected => {
+                // If the connection failed, NetworkManager sets the state to "disconnected".
+                // Let's consider it a problem unless it was requested by the user.
+                if reason == USER_REQUESTED {
+                    DeviceState::Disconnected
+                } else {
+                    DeviceState::Failed
+                }
+            }
+            NmDeviceState::Failed => DeviceState::Failed,
+        };
+
+        Ok(device_state)
+    }
 }

rust/agama-server/src/network/nm/client.rs

@@ -31,7 +31,10 @@ use super::proxies::{
     AccessPointProxy, ActiveConnectionProxy, ConnectionProxy, DeviceProxy, NetworkManagerProxy,
     SettingsProxy, WirelessProxy,
 };
-use crate::network::model::{AccessPoint, Connection, Device, GeneralState};
+use crate::network::model::{
+    AccessPoint, Connection, ConnectionConfig, Device, GeneralState, SecurityProtocol,
+};
+use agama_lib::dbus::get_optional_property;
 use agama_lib::error::ServiceError;
 use agama_lib::network::types::{DeviceType, SSID};
 use log;
@@ -200,11 +203,11 @@ impl<'a> NetworkManagerClient<'a> {
             }
 
             let settings = proxy.get_settings().await?;
-
             let controller = controller_from_dbus(&settings)?;
 
             match connection_from_dbus(settings) {
                 Ok(mut connection) => {
+                    Self::add_secrets(&mut connection.config, &proxy).await?;
                     if let Some(controller) = controller {
                         controlled_by.insert(connection.uuid, controller.to_string());
                     }
@@ -366,4 +369,30 @@ impl<'a> NetworkManagerClient<'a> {
 
         Ok(None)
     }
+
+    /// Ancillary function to add secrets to a connection.
+    ///
+    /// TODO: add support for more security protocols.
+    pub async fn add_secrets(
+        config: &mut ConnectionConfig,
+        proxy: &ConnectionProxy<'_>,
+    ) -> Result<(), ServiceError> {
+        let ConnectionConfig::Wireless(ref mut wireless) = config else {
+            return Ok(());
+        };
+
+        if wireless.security == SecurityProtocol::WPA2 {
+            match proxy.get_secrets("802-11-wireless-security").await {
+                Ok(secrets) => {
+                    if let Some(secret) = secrets.get("802-11-wireless-security") {
+                        wireless.password = get_optional_property(&secret, "psk")?;
+                    }
+                }
+                Err(error) => {
+                    tracing::error!("Could not read connection secrets: {:?}", error);
+                }
+            }
+        }
+        Ok(())
+    }
 }

rust/agama-server/src/network/nm/model.rs

@@ -111,6 +111,52 @@ impl TryFrom<NmDeviceType> for DeviceType {
     }
 }
 
+/// Device state
+#[derive(Default, Debug, PartialEq, Copy, Clone)]
+pub enum NmDeviceState {
+    #[default]
+    Unknown = 0,
+    Unmanaged = 10,
+    Unavailable = 20,
+    Disconnected = 30,
+    Prepare = 40,
+    Config = 50,
+    NeedAuth = 60,
+    IpConfig = 70,
+    IpCheck = 80,
+    Secondaries = 90,
+    Activated = 100,
+    Deactivating = 110,
+    Failed = 120,
+}
+
+#[derive(Debug, thiserror::Error, PartialEq)]
+#[error("Invalid state: {0}")]
+pub struct InvalidNmDeviceState(String);
+
+impl TryFrom<u8> for NmDeviceState {
+    type Error = InvalidNmDeviceState;
+
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        match value {
+            0 => Ok(NmDeviceState::Unknown),
+            10 => Ok(NmDeviceState::Unmanaged),
+            20 => Ok(NmDeviceState::Unavailable),
+            30 => Ok(NmDeviceState::Disconnected),
+            40 => Ok(NmDeviceState::Prepare),
+            50 => Ok(NmDeviceState::Config),
+            60 => Ok(NmDeviceState::NeedAuth),
+            70 => Ok(NmDeviceState::IpConfig),
+            80 => Ok(NmDeviceState::IpCheck),
+            90 => Ok(NmDeviceState::Secondaries),
+            100 => Ok(NmDeviceState::Activated),
+            110 => Ok(NmDeviceState::Deactivating),
+            120 => Ok(NmDeviceState::Failed),
+            _ => Err(InvalidNmDeviceState(value.to_string())),
+        }
+    }
+}
+
 /// Key management
 ///
 /// Using the newtype pattern around an String is enough. For proper support, we might replace this

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

@@ -327,6 +327,11 @@ impl<T: Adapter> NetworkSystemServer<T> {
                 return Ok(Some(NetworkChange::DeviceAdded(*device)));
             }
             Action::UpdateDevice(name, device) => {
+                if let Some(old_device) = self.state.get_device(&name) {
+                    if old_device == device.as_ref() {
+                        return Ok(None);
+                    }
+                }
                 self.state.update_device(&name, *device.clone())?;
                 return Ok(Some(NetworkChange::DeviceUpdated(name, *device)));
             }

rust/agama-server/tests/network_service.rs

@@ -89,7 +89,7 @@ async fn test_network_state() -> Result<(), Box<dyn Error>> {
     let response = network_service.oneshot(request).await?;
     assert_eq!(response.status(), StatusCode::OK);
     let body = body_to_string(response.into_body()).await;
-    assert!(body.contains(r#""wireless_enabled":false"#));
+    assert!(body.contains(r#""wirelessEnabled":false"#));
     Ok(())
 }
 

web/src/assets/styles/index.scss

@@ -387,6 +387,13 @@ label.pf-m-disabled + .pf-v6-c-check__description {
   justify-self: flex-start;
 }
 
+// Fix select toggle icon visibility by creating more space at the end :/
+.pf-v6-c-form-control > select {
+  --pf-v6-c-form-control--PaddingInlineEnd: calc(
+    var(--pf-v6-c-form-control__select--PaddingInlineEnd) * 3
+  );
+}
+
 .pf-v6-c-check {
   row-gap: var(--pf-t--global--spacer--xs);
   align-content: baseline;
@@ -401,6 +408,10 @@ label.pf-m-disabled + .pf-v6-c-check__description {
   --pf-v6-c-list--m-inline--ColumnGap: var(--pf-t--global--spacer--md);
 }
 
+.pf-v6-c-data-list li.pf-m-clickable {
+  --pf-v6-c-data-list__item--hover--BackgroundColor: var(--agm-t--action--background--color--hover);
+}
+
 // Nested content inside forms should respect parent grid gap
 .pf-v6-c-form [class*="pf-v6-u-mx"] {
   display: grid;

web/src/components/layout/Icon.tsx

@@ -43,8 +43,10 @@ import Lock from "@icons/lock.svg?component";
 import ManageAccounts from "@icons/manage_accounts.svg?component";
 import Menu from "@icons/menu.svg?component";
 import MoreVert from "@icons/more_vert.svg?component";
+import NetworkWifi from "@icons/network_wifi.svg?component";
+import NetworkWifi1Bar from "@icons/network_wifi_1_bar.svg?component";
+import NetworkWifi3Bar from "@icons/network_wifi_3_bar.svg?component";
 import SettingsEthernet from "@icons/settings_ethernet.svg?component";
-import SignalCellularAlt from "@icons/signal_cellular_alt.svg?component";
 import Warning from "@icons/warning.svg?component";
 import Visibility from "@icons/visibility.svg?component";
 import VisibilityOff from "@icons/visibility_off.svg?component";
@@ -71,8 +73,10 @@ const icons = {
   manage_accounts: ManageAccounts,
   menu: Menu,
   more_vert: MoreVert,
+  network_wifi: NetworkWifi,
+  network_wifi_1_bar: NetworkWifi1Bar,
+  network_wifi_3_bar: NetworkWifi3Bar,
   settings_ethernet: SettingsEthernet,
-  signal_cellular_alt: SignalCellularAlt,
   visibility: Visibility,
   visibility_off: VisibilityOff,
   warning: Warning,