Implementation of filesystem interfaces

Signed-off-by: mulhern <[email protected]>

Author: mulkieran

src/dbus/filesystem/filesystem_3_0/methods.rs

@@ -0,0 +1,50 @@
+// 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::sync::Arc;
+
+use crate::{
+    dbus::{consts::OK_STRING, types::DbusErrorEnum},
+    engine::{Engine, FilesystemUuid, PoolIdentifier, PoolUuid, RenameAction},
+    stratis::StratisError,
+};
+
+pub async fn set_name_method(
+    engine: &Arc<dyn Engine>,
+    uuid: PoolUuid,
+    fs_uuid: FilesystemUuid,
+    name: &str,
+) -> ((bool, FilesystemUuid), u16, String) {
+    let default_return = (false, FilesystemUuid::nil());
+
+    match engine
+        .get_mut_pool(PoolIdentifier::Uuid(uuid))
+        .await
+        .ok_or_else(|| StratisError::Msg(format!("No pool associated with uuid {uuid}")))
+    {
+        Err(err) => (default_return, DbusErrorEnum::ERROR as u16, err.to_string()),
+        Ok(mut guard) => {
+            let (pool_name, _, pool) = guard.as_mut_tuple();
+            match handle_action!(pool.rename_filesystem(&pool_name, fs_uuid, name)) {
+                Ok(RenameAction::NoSource) => (
+                    default_return,
+                    DbusErrorEnum::ERROR as u16,
+                    format!("pool doesn't know about filesystem {fs_uuid}"),
+                ),
+                Ok(RenameAction::Renamed(_)) => (
+                    // FIXME: send signal
+                    (true, fs_uuid),
+                    DbusErrorEnum::OK as u16,
+                    OK_STRING.to_string(),
+                ),
+                Ok(RenameAction::Identity) => (
+                    default_return,
+                    DbusErrorEnum::OK as u16,
+                    OK_STRING.to_string(),
+                ),
+                Err(err) => (default_return, DbusErrorEnum::ERROR as u16, err.to_string()),
+            }
+        }
+    }
+}

src/dbus/filesystem/filesystem_3_0/mod.rs

@@ -2,6 +2,125 @@
 // 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::sync::Arc;
+
+use tokio::sync::RwLock;
+use zbus::{
+    fdo::Error,
+    interface,
+    zvariant::{ObjectPath, OwnedObjectPath},
+    Connection,
+};
+mod methods;
 mod props;
 
-pub use props::name_prop;
+pub use methods::set_name_method;
+pub use props::{created_prop, devnode_prop, name_prop, pool_prop, size_prop, used_prop};
+
+use crate::{
+    dbus::{filesystem::shared::filesystem_prop, manager::Manager},
+    engine::{Engine, FilesystemUuid, Lockable, Name, PoolUuid},
+    stratis::StratisResult,
+};
+
+pub struct FilesystemR0 {
+    engine: Arc<dyn Engine>,
+    manager: Lockable<Arc<RwLock<Manager>>>,
+    parent_uuid: PoolUuid,
+    uuid: FilesystemUuid,
+}
+
+impl FilesystemR0 {
+    fn new(
+        engine: Arc<dyn Engine>,
+        manager: Lockable<Arc<RwLock<Manager>>>,
+        parent_uuid: PoolUuid,
+        uuid: FilesystemUuid,
+    ) -> Self {
+        FilesystemR0 {
+            engine,
+            manager,
+            parent_uuid,
+            uuid,
+        }
+    }
+
+    pub async fn register(
+        engine: Arc<dyn Engine>,
+        connection: &Arc<Connection>,
+        manager: &Lockable<Arc<RwLock<Manager>>>,
+        path: ObjectPath<'_>,
+        parent_uuid: PoolUuid,
+        uuid: FilesystemUuid,
+    ) -> StratisResult<()> {
+        let filesystem = Self::new(engine, manager.clone(), parent_uuid, uuid);
+
+        connection.object_server().at(path, filesystem).await?;
+        Ok(())
+    }
+
+    pub async fn unregister(
+        connection: &Arc<Connection>,
+        path: ObjectPath<'_>,
+    ) -> StratisResult<()> {
+        connection
+            .object_server()
+            .remove::<FilesystemR0, _>(path)
+            .await?;
+        Ok(())
+    }
+}
+
+#[interface(
+    name = "org.storage.stratis3.filesystem.r0",
+    introspection_docs = false
+)]
+impl FilesystemR0 {
+    #[zbus(out_args("result", "return_code", "return_string"))]
+    #[allow(non_snake_case)]
+    async fn SetName(&self, name: &str) -> ((bool, FilesystemUuid), u16, String) {
+        set_name_method(&self.engine, self.parent_uuid, self.uuid, name).await
+    }
+
+    #[zbus(property(emits_changed_signal = "const"))]
+    #[allow(non_snake_case)]
+    async fn Created(&self) -> Result<String, Error> {
+        filesystem_prop(&self.engine, self.parent_uuid, self.uuid, created_prop).await
+    }
+
+    #[zbus(property(emits_changed_signal = "invalidates"))]
+    #[allow(non_snake_case)]
+    async fn Devnode(&self) -> Result<String, Error> {
+        filesystem_prop(&self.engine, self.parent_uuid, self.uuid, devnode_prop).await
+    }
+
+    #[zbus(property)]
+    #[allow(non_snake_case)]
+    async fn Name(&self) -> Result<Name, Error> {
+        filesystem_prop(&self.engine, self.parent_uuid, self.uuid, name_prop).await
+    }
+
+    #[zbus(property(emits_changed_signal = "const"))]
+    #[allow(non_snake_case)]
+    async fn Pool(&self) -> Result<OwnedObjectPath, Error> {
+        pool_prop(self.manager.read().await, self.parent_uuid)
+    }
+
+    #[zbus(property)]
+    #[allow(non_snake_case)]
+    async fn Size(&self) -> Result<String, Error> {
+        filesystem_prop(&self.engine, self.parent_uuid, self.uuid, size_prop).await
+    }
+
+    #[zbus(property)]
+    #[allow(non_snake_case)]
+    async fn Used(&self) -> Result<(bool, String), Error> {
+        filesystem_prop(&self.engine, self.parent_uuid, self.uuid, used_prop).await
+    }
+
+    #[zbus(property(emits_changed_signal = "const"))]
+    #[allow(non_snake_case)]
+    fn Uuid(&self) -> FilesystemUuid {
+        self.uuid
+    }
+}

src/dbus/filesystem/filesystem_3_0/props.rs

@@ -2,8 +2,53 @@
 // 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 crate::engine::{Filesystem, FilesystemUuid, Name};
+use tokio::sync::OwnedRwLockReadGuard;
 
-pub fn name_prop(name: Name, _: FilesystemUuid, _: &dyn Filesystem) -> Name {
+use chrono::SecondsFormat;
+use zbus::{fdo::Error, zvariant::OwnedObjectPath};
+
+use crate::{
+    dbus::{util::option_to_tuple, Manager},
+    engine::{Filesystem, FilesystemUuid, Name, PoolUuid, SharedGuard},
+};
+
+pub fn created_prop(_: Name, _: Name, _: FilesystemUuid, fs: &dyn Filesystem) -> String {
+    fs.created().to_rfc3339_opts(SecondsFormat::Secs, true)
+}
+
+pub fn devnode_prop(
+    pool_name: Name,
+    fs_name: Name,
+    _: FilesystemUuid,
+    fs: &dyn Filesystem,
+) -> String {
+    fs.path_to_mount_filesystem(&pool_name, &fs_name)
+        .display()
+        .to_string()
+}
+
+pub fn name_prop(_: Name, name: Name, _: FilesystemUuid, _: &dyn Filesystem) -> Name {
     name
 }
+
+pub fn pool_prop(
+    guard: SharedGuard<OwnedRwLockReadGuard<Manager>>,
+    pool_uuid: PoolUuid,
+) -> Result<OwnedObjectPath, Error> {
+    guard
+        .pool_get_path(&pool_uuid)
+        .ok_or_else(|| {
+            Error::Failed(format!(
+                "No object path associated with pool UUID {pool_uuid}"
+            ))
+        })
+        .cloned()
+}
+
+pub fn size_prop(_: Name, _: Name, _: FilesystemUuid, fs: &dyn Filesystem) -> String {
+    (*fs.size()).to_string()
+}
+
+pub fn used_prop(_: Name, _: Name, _: FilesystemUuid, fs: &dyn Filesystem) -> (bool, String) {
+    option_to_tuple(fs.used().ok().map(|u| (*u).to_string()), String::new())
+}

src/dbus/filesystem/filesystem_3_1/mod.rs

@@ -0,0 +1,130 @@
+// 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::sync::Arc;
+
+use tokio::sync::RwLock;
+use zbus::{
+    fdo::Error,
+    interface,
+    zvariant::{ObjectPath, OwnedObjectPath},
+    Connection,
+};
+
+use crate::{
+    dbus::{
+        filesystem::{
+            filesystem_3_0::{
+                created_prop, devnode_prop, name_prop, pool_prop, set_name_method, size_prop,
+                used_prop,
+            },
+            shared::filesystem_prop,
+        },
+        manager::Manager,
+    },
+    engine::{Engine, FilesystemUuid, Lockable, Name, PoolUuid},
+    stratis::StratisResult,
+};
+
+pub struct FilesystemR1 {
+    engine: Arc<dyn Engine>,
+    manager: Lockable<Arc<RwLock<Manager>>>,
+    parent_uuid: PoolUuid,
+    uuid: FilesystemUuid,
+}
+
+impl FilesystemR1 {
+    fn new(
+        engine: Arc<dyn Engine>,
+        manager: Lockable<Arc<RwLock<Manager>>>,
+        parent_uuid: PoolUuid,
+        uuid: FilesystemUuid,
+    ) -> Self {
+        FilesystemR1 {
+            engine,
+            manager,
+            parent_uuid,
+            uuid,
+        }
+    }
+
+    pub async fn register(
+        engine: Arc<dyn Engine>,
+        connection: &Arc<Connection>,
+        manager: &Lockable<Arc<RwLock<Manager>>>,
+        path: ObjectPath<'_>,
+        parent_uuid: PoolUuid,
+        uuid: FilesystemUuid,
+    ) -> StratisResult<()> {
+        let filesystem = Self::new(engine, manager.clone(), parent_uuid, uuid);
+
+        connection.object_server().at(path, filesystem).await?;
+        Ok(())
+    }
+
+    pub async fn unregister(
+        connection: &Arc<Connection>,
+        path: ObjectPath<'_>,
+    ) -> StratisResult<()> {
+        connection
+            .object_server()
+            .remove::<FilesystemR1, _>(path)
+            .await?;
+        Ok(())
+    }
+}
+
+#[interface(
+    name = "org.storage.stratis3.filesystem.r1",
+    introspection_docs = false
+)]
+impl FilesystemR1 {
+    #[zbus(out_args("result", "return_code", "return_string"))]
+    #[allow(non_snake_case)]
+    async fn SetName(&self, name: &str) -> ((bool, FilesystemUuid), u16, String) {
+        set_name_method(&self.engine, self.parent_uuid, self.uuid, name).await
+    }
+
+    #[zbus(property(emits_changed_signal = "const"))]
+    #[allow(non_snake_case)]
+    async fn Created(&self) -> Result<String, Error> {
+        filesystem_prop(&self.engine, self.parent_uuid, self.uuid, created_prop).await
+    }
+
+    #[zbus(property(emits_changed_signal = "invalidates"))]
+    #[allow(non_snake_case)]
+    async fn Devnode(&self) -> Result<String, Error> {
+        filesystem_prop(&self.engine, self.parent_uuid, self.uuid, devnode_prop).await
+    }
+
+    #[zbus(property)]
+    #[allow(non_snake_case)]
+    async fn Name(&self) -> Result<Name, Error> {
+        filesystem_prop(&self.engine, self.parent_uuid, self.uuid, name_prop).await
+    }
+
+    #[zbus(property(emits_changed_signal = "const"))]
+    #[allow(non_snake_case)]
+    async fn Pool(&self) -> Result<OwnedObjectPath, Error> {
+        pool_prop(self.manager.read().await, self.parent_uuid)
+    }
+
+    #[zbus(property)]
+    #[allow(non_snake_case)]
+    async fn Size(&self) -> Result<String, Error> {
+        filesystem_prop(&self.engine, self.parent_uuid, self.uuid, size_prop).await
+    }
+
+    #[zbus(property)]
+    #[allow(non_snake_case)]
+    async fn Used(&self) -> Result<(bool, String), Error> {
+        filesystem_prop(&self.engine, self.parent_uuid, self.uuid, used_prop).await
+    }
+
+    #[zbus(property(emits_changed_signal = "const"))]
+    #[allow(non_snake_case)]
+    fn Uuid(&self) -> FilesystemUuid {
+        self.uuid
+    }
+}