Expose the networking API over HTTP

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

@@ -1,10 +1,15 @@
+use cidr::errors::NetworkParseError;
 use serde::{Deserialize, Serialize};
-use std::{fmt, str};
+use std::{
+    fmt,
+    str::{self, FromStr},
+};
 use thiserror::Error;
 use zbus;
 
 /// Network device
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "type")]
 pub struct Device {
     pub name: String,
     pub type_: DeviceType,
@@ -25,13 +30,21 @@ impl fmt::Display for SSID {
     }
 }
 
+impl FromStr for SSID {
+    type Err = NetworkParseError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(SSID(s.as_bytes().into()))
+    }
+}
+
 impl From<SSID> for Vec<u8> {
     fn from(value: SSID) -> Self {
         value.0
     }
 }
 
-#[derive(Debug, PartialEq, Copy, Clone, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Copy, Clone, Serialize, Deserialize, utoipa::ToSchema)]
 pub enum DeviceType {
     Loopback = 0,
     Ethernet = 1,

rust/agama-server/Cargo.toml

@@ -25,7 +25,7 @@ tokio-stream = "0.1.14"
 gettext-rs = { version = "0.7.0", features = ["gettext-system"] }
 regex = "1.10.2"
 once_cell = "1.18.0"
-macaddr = "1.0"
+macaddr = { version = "1.0", features = ["serde_std"] }
 async-trait = "0.1.75"
 axum = { version = "0.7.4", features = ["ws"] }
 serde_json = "1.0.113"

rust/agama-server/src/network.rs

@@ -45,6 +45,7 @@ pub mod error;
 pub mod model;
 mod nm;
 pub mod system;
+pub mod web;
 
 pub use action::Action;
 pub use adapter::{Adapter, NetworkAdapterError};

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

@@ -1,10 +1,10 @@
-use crate::network::model::Connection;
+use crate::network::model::{AccessPoint, Connection, Device};
 use agama_lib::network::types::DeviceType;
 use tokio::sync::oneshot;
 use uuid::Uuid;
 use zbus::zvariant::OwnedObjectPath;
 
-use super::{error::NetworkStateError, NetworkAdapterError};
+use super::{error::NetworkStateError, model::GeneralState, NetworkAdapterError};
 
 pub type Responder<T> = oneshot::Sender<T>;
 pub type ControllerConnection = (Connection, Vec<String>);
@@ -21,11 +21,18 @@ pub enum Action {
         DeviceType,
         Responder<Result<OwnedObjectPath, NetworkStateError>>,
     ),
-    /// Gets a connection
+    /// Add a new connection
+    NewConnection(
+        Connection,
+        Responder<Result<OwnedObjectPath, NetworkStateError>>,
+    ),
+    /// Gets a connection by its Uuid
     GetConnection(Uuid, Responder<Option<Connection>>),
     /// Gets a connection
+    GetConnections(Responder<Vec<Connection>>),
+    /// Gets a connection path
     GetConnectionPath(Uuid, Responder<Option<OwnedObjectPath>>),
-    /// Gets a connection
+    /// Gets a connection path by id
     GetConnectionPathById(String, Responder<Option<OwnedObjectPath>>),
     /// Get connections paths
     GetConnectionsPaths(Responder<Vec<OwnedObjectPath>>),
@@ -34,19 +41,32 @@ pub enum Action {
         Uuid,
         Responder<Result<ControllerConnection, NetworkStateError>>,
     ),
+    /// Gets all scanned access points
+    GetAccessPoints(Responder<Vec<AccessPoint>>),
+    /// Gets a device by its name
+    GetDevice(String, Responder<Option<Device>>),
+    /// Gets all the existent devices
+    GetDevices(Responder<Vec<Device>>),
+    /// Gets a device path
+    GetDevicePath(String, Responder<Option<OwnedObjectPath>>),
     /// Get devices paths
     GetDevicesPaths(Responder<Vec<OwnedObjectPath>>),
+    GetGeneralState(Responder<GeneralState>),
     /// Sets a controller's ports. It uses the Uuid of the controller and the IDs or interface names
     /// of the ports.
     SetPorts(
         Uuid,
         Box<Vec<String>>,
         Responder<Result<(), NetworkStateError>>,
     ),
-    /// Update a connection (replacing the old one).
+    /// Updates a connection (replacing the old one).
     UpdateConnection(Box<Connection>),
+    /// Updates the general network configuration
+    UpdateGeneralState(GeneralState),
+    /// Forces a wireless networks scan refresh
+    RefreshScan(Responder<Result<(), NetworkAdapterError>>),
     /// Remove the connection with the given Uuid.
-    RemoveConnection(Uuid),
+    RemoveConnection(Uuid, Responder<Result<(), NetworkStateError>>),
     /// Apply the current configuration.
     Apply(Responder<Result<(), NetworkAdapterError>>),
 }

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

@@ -1,3 +1,4 @@
+use crate::network::model::StateConfig;
 use crate::network::NetworkState;
 use agama_lib::error::ServiceError;
 use async_trait::async_trait;
@@ -16,7 +17,7 @@ pub enum NetworkAdapterError {
 /// A trait for the ability to read/write from/to a network service
 #[async_trait]
 pub trait Adapter {
-    async fn read(&self) -> Result<NetworkState, NetworkAdapterError>;
+    async fn read(&self, config: StateConfig) -> Result<NetworkState, NetworkAdapterError>;
     async fn write(&self, network: &NetworkState) -> Result<(), NetworkAdapterError>;
 }
 

rust/agama-server/src/network/dbus/interfaces/connections.rs

@@ -21,7 +21,7 @@ pub struct Connections {
 impl Connections {
     /// Creates a Connections interface object.
     ///
-    /// * `objects`: Objects paths registry.
+    /// * `actions`: sending-half of a channel to send actions.
     pub fn new(actions: UnboundedSender<Action>) -> Self {
         Self {
             actions: Arc::new(Mutex::new(actions)),
@@ -101,7 +101,10 @@ impl Connections {
             .parse()
             .map_err(|_| NetworkStateError::InvalidUuid(uuid.to_string()))?;
         let actions = self.actions.lock().await;
-        actions.send(Action::RemoveConnection(uuid)).unwrap();
+        let (tx, rx) = oneshot::channel();
+        actions.send(Action::RemoveConnection(uuid, tx)).unwrap();
+
+        rx.await.unwrap()?;
         Ok(())
     }
 

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

@@ -130,6 +130,10 @@ impl Tree {
         self.objects.devices_paths()
     }
 
+    pub fn device_path(&self, name: &str) -> Option<OwnedObjectPath> {
+        self.objects.device_path(name).map(|o| o.into())
+    }
+
     /// Returns all connection paths.
     pub fn connections_paths(&self) -> Vec<OwnedObjectPath> {
         self.objects.connections_paths()
@@ -237,6 +241,12 @@ impl ObjectsRegistry {
         path
     }
 
+    /// Returns the path for a device.
+    ///
+    /// * `name`: device name.
+    pub fn device_path(&self, name: &str) -> Option<ObjectPath> {
+        self.devices.get(name).map(|p| p.as_ref())
+    }
     /// Returns the path for a connection.
     ///
     /// * `uuid`: connection ID.