feat: improve Wi-Fi networks handling

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

@@ -27,6 +27,8 @@ use std::{
 use thiserror::Error;
 use zbus;
 
+use super::settings::NetworkConnection;
+
 /// Network device
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(tag = "type")]
@@ -78,71 +80,67 @@ 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,
+    /// 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, 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)
-    }
+#[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 ConnectionState {
+    /// The connection is getting activated.
+    Activating,
+    /// The connection is activated.
+    Activated,
+    /// The connection is getting deactivated.
+    Deactivating,
+    #[default]
+    /// The connection is deactivated.
+    Deactivated,
 }
 
 #[derive(Debug, Default, Clone, Copy, PartialEq, Serialize, Deserialize, utoipa::ToSchema)]
@@ -294,6 +292,17 @@ impl From<InvalidDeviceType> for zbus::fdo::Error {
     }
 }
 
+// FIXME: found a better place for the HTTP types.
+//
+// TODO: If the client ignores the additional "state" field, this struct
+// does not need to be here.
+#[derive(Debug, Clone, Serialize, Deserialize, utoipa::ToSchema)]
+pub struct NetworkConnectionWithState {
+    #[serde(flatten)]
+    pub connection: NetworkConnection,
+    pub state: ConnectionState,
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

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

@@ -19,7 +19,7 @@
 // find current contact information at www.suse.com.
 
 use crate::network::model::{AccessPoint, Connection, Device};
-use agama_lib::network::types::DeviceType;
+use agama_lib::network::types::{ConnectionState, DeviceType};
 use tokio::sync::oneshot;
 use uuid::Uuid;
 
@@ -62,6 +62,8 @@ pub enum Action {
     /// Gets all the existent devices
     GetDevices(Responder<Vec<Device>>),
     GetGeneralState(Responder<GeneralState>),
+    /// Connection state changed
+    ChangeConnectionState(String, ConnectionState),
     /// Sets a controller's ports. It uses the Uuid of the controller and the IDs or interface names
     /// of the ports.
     SetPorts(

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

@@ -26,7 +26,7 @@ use crate::network::error::NetworkStateError;
 use agama_lib::network::settings::{
     BondSettings, IEEE8021XSettings, NetworkConnection, WirelessSettings,
 };
-use agama_lib::network::types::{BondMode, DeviceState, DeviceType, Status, SSID};
+use agama_lib::network::types::{BondMode, ConnectionState, DeviceState, DeviceType, Status, SSID};
 use agama_lib::openapi::schemas;
 use cidr::IpInet;
 use serde::{Deserialize, Serialize};
@@ -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.
@@ -515,6 +515,7 @@ pub struct Connection {
     pub config: ConnectionConfig,
     pub ieee_8021x_config: Option<IEEE8021XConfig>,
     pub autoconnect: bool,
+    pub state: ConnectionState,
 }
 
 impl Connection {
@@ -587,6 +588,7 @@ impl Default for Connection {
             config: Default::default(),
             ieee_8021x_config: Default::default(),
             autoconnect: true,
+            state: Default::default(),
         }
     }
 }
@@ -1783,6 +1785,8 @@ pub enum NetworkChange {
     /// original device name, which is especially useful if the
     /// device gets renamed.
     DeviceUpdated(String, Device),
+    /// A connection state has changed.
+    ConnectionStateChanged { id: String, state: ConnectionState },
 }
 
 #[derive(Default, Debug, PartialEq, Clone, Serialize, utoipa::ToSchema)]

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

@@ -31,6 +31,7 @@ mod dbus;
 mod error;
 mod model;
 mod proxies;
+mod streams;
 mod watcher;
 
 pub use adapter::NetworkManagerAdapter;

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)
+    }
 }