Add PoolR0 interface

Author: jbaublitz

;

@@ -0,0 +1,233 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+use std::{
+    collections::HashSet,
+    sync::{atomic::AtomicU64, Arc},
+};
+
+use tokio::sync::RwLock;
+use zbus::{zvariant::ObjectPath, Connection};
+
+use devicemapper::Bytes;
+
+use crate::{
+    dbus::{
+        consts::OK_STRING,
+        filesystem::{register_filesystem, unregister_filesystem},
+        manager::Manager,
+        types::DbusErrorEnum,
+        util::{engine_to_dbus_err_tuple, tuple_to_option},
+    },
+    engine::{Engine, EngineAction, FilesystemUuid, Lockable, PoolIdentifier, PoolUuid, Name, CreateAction},
+    stratis::StratisError,
+};
+
+pub async fn create_filesystems_method<'a>(
+    engine: &Arc<dyn Engine>,
+    connection: &Arc<Connection>,
+    manager: &Lockable<Arc<RwLock<Manager>>>,
+    counter: &Arc<AtomicU64>,
+    pool_uuid: PoolUuid,
+    filesystems: Vec<(&str, (bool, &str))>,
+) -> ((bool, Vec<ObjectPath<'a>>), u16, String) {
+    let default_return = (false, (Vec::new()));
+
+    let filesystem_specs = match filesystems
+        .into_iter()
+        .map(|(name, size_opt)| {
+            let size = tuple_to_option(size_opt)
+                .map(|val| {
+                    val.parse::<u128>().map_err(|_| {
+                        format!("Could not parse filesystem size string {val} to integer value")
+                    })
+                })
+                .transpose()?;
+            Ok((name.to_string(), size.map(Bytes), None))
+        })
+        .collect::<Result<Vec<(String, Option<Bytes>, Option<Bytes>)>, String>>()
+    {
+        Ok(fs_specs) => fs_specs,
+        Err(e) => {
+            let (rc, rs) = (DbusErrorEnum::ERROR as u16, e);
+            return (default_return, rc, rs);
+        }
+    };
+
+    let guard_res = engine
+        .get_mut_pool(PoolIdentifier::Uuid(pool_uuid))
+        .await
+        .ok_or_else(|| StratisError::Msg(format!("No pool associated with uuid {pool_uuid}")));
+    match tokio::task::spawn_blocking(move || {
+        let mut guard = guard_res?;
+        let (name, _, pool) = guard.as_mut_tuple();
+        handle_action!(pool.create_filesystems(
+            name.to_string().as_str(),
+            pool_uuid,
+            filesystem_specs
+                .iter()
+                .map(|(s, b1, b2)| (s.as_str(), *b1, *b2))
+                .collect::<Vec<_>>()
+                .as_slice(),
+        ))
+    })
+    .await
+    {
+        Ok(Ok(changed)) => {
+            let mut object_paths = Vec::new();
+            match changed.changed() {
+                Some(v) => {
+                    for (_, uuid, _) in v {
+                        match register_filesystem(
+                            engine, connection, manager, counter, pool_uuid, uuid,
+                        )
+                        .await
+                        {
+                            Ok(path) => {
+                                object_paths.push(path);
+                            }
+                            Err(e) => {
+                                warn!("Failed to register the filesystem with the D-Bus: {e}; object may not be visible to clients");
+                            }
+                        }
+                    }
+                    (
+                        (true, object_paths),
+                        DbusErrorEnum::OK as u16,
+                        OK_STRING.to_string(),
+                    )
+                }
+                None => (
+                    default_return,
+                    DbusErrorEnum::OK as u16,
+                    OK_STRING.to_string(),
+                ),
+            }
+        }
+        Ok(Err(e)) => {
+            let (rc, rs) = engine_to_dbus_err_tuple(&e);
+            (default_return, rc, rs)
+        }
+        Err(e) => {
+            let (rc, rs) = engine_to_dbus_err_tuple(&StratisError::from(e));
+            (default_return, rc, rs)
+        }
+    }
+}
+
+pub async fn destroy_filesystems_method(
+    engine: &Arc<dyn Engine>,
+    connection: &Arc<Connection>,
+    manager: &Lockable<Arc<RwLock<Manager>>>,
+    pool_uuid: PoolUuid,
+    filesystems: Vec<ObjectPath<'_>>,
+) -> ((bool, Vec<FilesystemUuid>), u16, String) {
+    let default_return = (false, (Vec::new()));
+
+    let uuids = {
+        let lock = manager.read().await;
+        filesystems
+            .iter()
+            .filter_map(|op| lock.filesystem_get_uuid(op))
+            .collect::<HashSet<_>>()
+    };
+
+    let guard_res = engine
+        .get_mut_pool(PoolIdentifier::Uuid(pool_uuid))
+        .await
+        .ok_or_else(|| StratisError::Msg(format!("No pool associated with uuid {pool_uuid}")));
+    match tokio::task::spawn_blocking(move || {
+        let mut guard = guard_res?;
+        let (name, _, pool) = guard.as_mut_tuple();
+        handle_action!(pool.destroy_filesystems(name.to_string().as_str(), &uuids,))
+    })
+    .await
+    {
+        Ok(Ok(changed)) => {
+            let mut uuids = Vec::new();
+            match changed.changed() {
+                Some((v, _)) => {
+                    for op in filesystems.iter() {
+                        match unregister_filesystem(connection, manager, op).await {
+                            Ok(uuid) => {
+                                uuids.push(uuid);
+                            }
+                            Err(e) => {
+                                warn!("Failed to register the filesystem with the D-Bus: {e}; object may not be visible to clients");
+                            }
+                        }
+                    }
+                    ((true, v), DbusErrorEnum::OK as u16, OK_STRING.to_string())
+                }
+                None => (
+                    default_return,
+                    DbusErrorEnum::OK as u16,
+                    OK_STRING.to_string(),
+                ),
+            }
+        }
+        Ok(Err(e)) => {
+            let (rc, rs) = engine_to_dbus_err_tuple(&e);
+            (default_return, rc, rs)
+        }
+        Err(e) => {
+            let (rc, rs) = engine_to_dbus_err_tuple(&StratisError::from(e));
+            (default_return, rc, rs)
+        }
+    }
+}
+
+pub async fn snapshot_filesystems_method<'a>(
+    engine: &Arc<dyn Engine>,
+    connection: &Arc<Connection>,
+    manager: &Lockable<Arc<RwLock<Manager>>>,
+    counter: &Arc<AtomicU64>,
+    pool_uuid: PoolUuid,
+    filesystem: ObjectPath<'_>,
+    snapshot_name: &str,
+) -> ((bool, ObjectPath<'a>), u16, String) {
+    let default_return = (false, ObjectPath::default());
+
+    let fs_uuid = match manager.read().await.filesystem_get_uuid(&filesystem) {
+        Some(u) => u,
+        None => {
+            return (default_return, DbusErrorEnum::ERROR as u16, format!("No filesystem UUID associated with path {filesystem}"));
+        }
+    };
+
+    let guard_res = engine
+        .get_mut_pool(PoolIdentifier::Uuid(pool_uuid))
+        .await
+        .ok_or_else(|| StratisError::Msg(format!("No pool associated with uuid {pool_uuid}")));
+    match tokio::task::spawn_blocking(move || {
+        let mut guard = guard_res?;
+        let (name, _, pool) = guard.as_mut_tuple();
+        handle_action!(pool.snapshot_filesystem(name.to_string().as_str(), pool_uuid, fs_uuid, snapshot_name)).map(|_| ())
+    })
+    .await
+    {
+        Ok(Ok(Crea)) => {
+            let mut uuids = Vec::new();
+            match changed.changed() {
+                Some(uuid) => {
+                    register_filesystem(engine, connection, manager, counter, pool_uuid, fs_uuid);
+                    ((true, v), DbusErrorEnum::OK as u16, OK_STRING.to_string())
+                }
+                None => (
+                    default_return,
+                    DbusErrorEnum::OK as u16,
+                    OK_STRING.to_string(),
+                ),
+            }
+        }
+        Ok(Err(e)) => {
+            let (rc, rs) = engine_to_dbus_err_tuple(&e);
+            (default_return, rc, rs)
+        }
+        Err(e) => {
+            let (rc, rs) = engine_to_dbus_err_tuple(&StratisError::from(e));
+            (default_return, rc, rs)
+        }
+    }
+}

src/dbus/filesystem/filesystem_3_9/mod.rs

@@ -39,6 +39,17 @@ impl FilesystemR9 {
         connection.object_server().at(path, filesystem).await?;
         Ok(())
     }
+
+    pub async fn unregister(
+        connection: &Arc<Connection>,
+        path: ObjectPath<'_>,
+    ) -> StratisResult<()> {
+        connection
+            .object_server()
+            .remove::<FilesystemR9, _>(path)
+            .await?;
+        Ok(())
+    }
 }
 
 #[interface(name = "org.storage.stratis3.filesystem.r9")]

src/dbus/filesystem/mod.rs

@@ -13,7 +13,7 @@ use zbus::{zvariant::ObjectPath, Connection};
 use crate::{
     dbus::{consts, Manager},
     engine::{Engine, FilesystemUuid, Lockable, PoolUuid},
-    stratis::StratisResult,
+    stratis::{StratisError, StratisResult},
 };
 
 mod filesystem_3_0;
@@ -41,3 +41,19 @@ pub async fn register_filesystem<'a>(
 
     Ok(path)
 }
+
+pub async fn unregister_filesystem(
+    connection: &Arc<Connection>,
+    manager: &Lockable<Arc<RwLock<Manager>>>,
+    path: &ObjectPath<'_>,
+) -> StratisResult<FilesystemUuid> {
+    FilesystemR9::unregister(connection, path.clone()).await?;
+
+    let mut lock = manager.write().await;
+    let uuid = lock
+        .filesystem_get_uuid(path)
+        .ok_or_else(|| StratisError::Msg(format!("No UUID associated with path {path}")))?;
+    lock.remove_filesystem(path);
+
+    Ok(uuid)
+}

src/dbus/pool/mod.rs

@@ -21,6 +21,7 @@ mod pool_3_6;
 mod pool_3_9;
 mod shared;
 
+pub use pool_3_0::PoolR0;
 pub use pool_3_9::PoolR9;
 
 pub async fn register_pool<'a>(
@@ -35,15 +36,30 @@ pub async fn register_pool<'a>(
         consts::STRATIS_BASE_PATH,
         counter.fetch_add(1, Ordering::AcqRel),
     ))?;
-    PoolR9::register(
+    if let Err(e) = PoolR0::register(
         engine,
         connection,
         manager,
         counter,
         path.clone(),
         pool_uuid,
     )
-    .await?;
+    .await
+    {
+        warn!("Failed to register interface pool.r0 for pool with UUID {pool_uuid}: {e}");
+    }
+    if let Err(e) = PoolR9::register(
+        engine,
+        connection,
+        manager,
+        counter,
+        path.clone(),
+        pool_uuid,
+    )
+    .await
+    {
+        warn!("Failed to register interface pool.r9 for pool with UUID {pool_uuid}: {e}");
+    }
 
     manager.write().await.add_pool(&path, pool_uuid);
 
@@ -55,13 +71,21 @@ pub async fn unregister_pool(
     manager: &Lockable<Arc<RwLock<Manager>>>,
     path: &ObjectPath<'_>,
 ) -> StratisResult<PoolUuid> {
-    PoolR9::unregister(connection, path.clone()).await?;
+    let uuid = {
+        let mut lock = manager.write().await;
+        let uuid = lock
+            .pool_get_uuid(path)
+            .ok_or_else(|| StratisError::Msg(format!("No UUID associated with path {path}")))?;
+        lock.remove_pool(path);
+        uuid
+    };
 
-    let mut lock = manager.write().await;
-    let uuid = lock
-        .pool_get_uuid(path)
-        .ok_or_else(|| StratisError::Msg(format!("No UUID associated with path {path}")))?;
-    lock.remove_pool(path);
+    if let Err(e) = PoolR0::unregister(connection, path.clone()).await {
+        warn!("Failed to deregister interface pool.r0 for path {path}: {e}");
+    }
+    if let Err(e) = PoolR9::unregister(connection, path.clone()).await {
+        warn!("Failed to deregister interface pool.r9 for path {path}: {e}");
+    }
 
     Ok(uuid)
 }