Add bonding support

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

@@ -1,5 +1,12 @@
 use crate::network::model::Connection;
 use agama_lib::network::types::DeviceType;
+use tokio::sync::oneshot;
+use uuid::Uuid;
+
+use super::error::NetworkStateError;
+
+pub type Responder<T> = oneshot::Sender<T>;
+pub type ControllerConnection = (Connection, Vec<String>);
 
 /// Networking actions, like adding, updating or removing connections.
 ///
@@ -9,6 +16,16 @@ use agama_lib::network::types::DeviceType;
 pub enum Action {
  /// Add a new connection with the given name and type.
  AddConnection(String, DeviceType),
+ /// Gets a connection
+ GetConnection(Uuid, Responder<Option<Connection>>),
+ /// Gets a controller connection
+ GetController(
+ Uuid,
+ Responder<Result<ControllerConnection, NetworkStateError>>,
+ ),
+ /// Sets a controller's ports. It uses the Uuid of the controller and the IDs or interface names
+ /// of the ports.
+ SetPorts(Uuid, Vec<String>, Responder<Result<(), NetworkStateError>>),
  /// Update a connection (replacing the old one).
  UpdateConnection(Connection),
  /// Remove the connection with the given Uuid.

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

@@ -2,19 +2,22 @@
 //!
 //! This module contains the set of D-Bus interfaces that are exposed by [D-Bus network
 //! service](crate::NetworkService).
+
 use super::ObjectsRegistry;
 use crate::network::{
  action::Action,
  error::NetworkStateError,
  model::{
- Connection as NetworkConnection, Device as NetworkDevice, MacAddress, WirelessConnection,
+ BondConnection, Connection as NetworkConnection, Device as NetworkDevice, MacAddress,
+ WirelessConnection,
  },
 };
 
 use agama_lib::network::types::SSID;
 use std::{str::FromStr, sync::Arc};
-use tokio::sync::mpsc::UnboundedSender;
+use tokio::sync::{mpsc::UnboundedSender, oneshot};
 use tokio::sync::{MappedMutexGuard, Mutex, MutexGuard};
+use uuid::Uuid;
 use zbus::{
  dbus_interface,
  zvariant::{ObjectPath, OwnedObjectPath},
@@ -229,9 +232,31 @@ impl Connection {
  self.get_connection().await.id().to_string()
  }
 
+ /// Connection UUID.
+ ///
+ /// Unique identifier of the network connection. It may or not be the same that the used by the
+ /// backend.
+ #[dbus_interface(property)]
+ pub async fn uuid(&self) -> String {
+ self.get_connection().await.uuid().to_string()
+ }
+
+ #[dbus_interface(property)]
+ pub async fn controller(&self) -> String {
+ let connection = self.get_connection().await;
+ match connection.controller() {
+ Some(uuid) => uuid.to_string(),
+ None => "".to_string(),
+ }
+ }
+
  #[dbus_interface(property)]
  pub async fn interface(&self) -> String {
- self.get_connection().await.interface().to_string()
+ self.get_connection()
+ .await
+ .interface()
+ .unwrap_or("")
+ .to_string()
  }
 
  #[dbus_interface(property)]
@@ -296,6 +321,106 @@ impl Match {
  }
 }
 
+/// D-Bus interface for Bond settings.
+pub struct Bond {
+ actions: Arc<Mutex<UnboundedSender<Action>>>,
+ uuid: Uuid,
+}
+
+impl Bond {
+ /// Creates a Bond interface object.
+ ///
+ /// * `actions`: sending-half of a channel to send actions.
+ /// * `uuid`: connection UUID.
+ pub fn new(actions: UnboundedSender<Action>, uuid: Uuid) -> Self {
+ Self {
+ actions: Arc::new(Mutex::new(actions)),
+ uuid,
+ }
+ }
+
+ /// Gets the bond connection.
+ ///
+ /// Beware that it crashes when it is not a bond connection.
+ async fn get_bond(&self) -> BondConnection {
+ let actions = self.actions.lock().await;
+ let (tx, rx) = oneshot::channel();
+ actions.send(Action::GetConnection(self.uuid, tx)).unwrap();
+ let connection = rx.await.unwrap();
+
+ match connection {
+ Some(NetworkConnection::Bond(config)) => config,
+ _ => panic!("Not a bond connection. This is most probably a bug."),
+ }
+ }
+
+ /// Updates the connection data in the NetworkSystem.
+ ///
+ /// * `connection`: Updated connection.
+ async fn update_connection<'a>(&self, connection: BondConnection) -> zbus::fdo::Result<()> {
+ let actions = self.actions.lock().await;
+ let connection = NetworkConnection::Bond(connection.clone());
+ actions.send(Action::UpdateConnection(connection)).unwrap();
+ Ok(())
+ }
+}
+
+#[dbus_interface(name = "org.opensuse.Agama1.Network.Connection.Bond")]
+impl Bond {
+ /// Bonding mode.
+ #[dbus_interface(property)]
+ pub async fn mode(&self) -> String {
+ let connection = self.get_bond().await;
+ connection.bond.mode.to_string()
+ }
+
+ #[dbus_interface(property)]
+ pub async fn set_mode(&mut self, mode: &str) -> zbus::fdo::Result<()> {
+ let mut connection = self.get_bond().await;
+ connection.set_mode(mode.try_into()?);
+ self.update_connection(connection).await
+ }
+
+ /// List of bonding options.
+ #[dbus_interface(property)]
+ pub async fn options(&self) -> String {
+ let connection = self.get_bond().await;
+ connection.bond.options.to_string()
+ }
+
+ #[dbus_interface(property)]
+ pub async fn set_options(&mut self, opts: &str) -> zbus::fdo::Result<()> {
+ let mut connection = self.get_bond().await;
+ connection.set_options(opts.try_into()?);
+ self.update_connection(connection).await
+ }
+
+ /// List of bond ports.
+ ///
+ /// For the port names, it uses the interface name (preferred) or, as a fallback,
+ /// the connection ID of the port.
+ #[dbus_interface(property)]
+ pub async fn ports(&self) -> zbus::fdo::Result<Vec<String>> {
+ let actions = self.actions.lock().await;
+ let (tx, rx) = oneshot::channel();
+ actions.send(Action::GetController(self.uuid, tx)).unwrap();
+
+ let (_, ports) = rx.await.unwrap()?;
+ Ok(ports)
+ }
+
+ #[dbus_interface(property)]
+ pub async fn set_ports(&mut self, ports: Vec<String>) -> zbus::fdo::Result<()> {
+ let actions = self.actions.lock().await;
+ let (tx, rx) = oneshot::channel();
+ actions
+ .send(Action::SetPorts(self.uuid, ports, tx))
+ .unwrap();
+ let result = rx.await.unwrap();
+ Ok(result?)
+ }
+}
+
 #[dbus_interface(name = "org.opensuse.Agama1.Network.Connection.Match")]
 impl Match {
  /// List of driver names to match.
@@ -477,7 +602,6 @@ impl Wireless {
  connection.wireless.security = security
  .try_into()
  .map_err(|_| NetworkStateError::InvalidSecurityProtocol(security.to_string()))?;
- self.update_connection(connection).await?;
- Ok(())
+ self.update_connection(connection).await
  }
 }

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

@@ -88,6 +88,7 @@ impl Tree {
  let mut objects = self.objects.lock().await;
 
  let orig_id = conn.id().to_owned();
+ let uuid = conn.uuid();
  let (id, path) = objects.register_connection(conn);
  if id != conn.id() {
  conn.set_id(&id)
@@ -112,6 +113,12 @@ impl Tree {
  interfaces::Match::new(self.actions.clone(), Arc::clone(&cloned)),
  )
  .await?;
+
+ if let Connection::Bond(_) = conn {
+ self.add_interface(&path, interfaces::Bond::new(self.actions.clone(), uuid))
+ .await?;
+ }
+
  if let Connection::Wireless(_) = conn {
  self.add_interface(
  &path,
@@ -185,6 +192,7 @@ impl Tree {
  /// * `path`: connection D-Bus path.
  async fn remove_connection_on(&self, path: &str) -> Result<(), ServiceError> {
  let object_server = self.connection.object_server();
+ _ = object_server.remove::<interfaces::Bond, _>(path).await;
  _ = object_server.remove::<interfaces::Wireless, _>(path).await;
  object_server.remove::<interfaces::Ip, _>(path).await?;
  object_server

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

@@ -5,7 +5,7 @@ use uuid::Uuid;
 /// Errors that are related to the network configuration.
 #[derive(Error, Debug)]
 pub enum NetworkStateError {
- #[error("Unknown connection with ID: '{0}'")]
+ #[error("Unknown connection '{0}'")]
  UnknownConnection(String),
  #[error("Invalid connection UUID: '{0}'")]
  InvalidUuid(String),
@@ -21,6 +21,12 @@ pub enum NetworkStateError {
  InvalidSecurityProtocol(String),
  #[error("Adapter error: '{0}'")]
  AdapterError(String),
+ #[error("Invalid bond mode '{0}'")]
+ InvalidBondMode(String),
+ #[error("Invalid bond options")]
+ InvalidBondOptions,
+ #[error("Not a controller connection: '{0}'")]
+ NotControllerConnection(String),
 }
 
 impl From<NetworkStateError> for zbus::fdo::Error {