Online reencryption

Cargo.toml

@@ -80,7 +80,7 @@ version = "1.2.3"
 optional = true
 
 [dependencies.chrono]
-version = "0.4.20"
+version = "0.4.31"
 optional = true
 default-features = false
 features = ["clock", "std"]
@@ -101,14 +101,6 @@ optional = true
 version = "0.34.4"
 optional = true
 
-[dependencies.dbus]
-version = "0.9.0"
-optional = true
-
-[dependencies.dbus-tree]
-version = "0.9.2"
-optional = true
-
 [dependencies.either]
 version = "1.6.1"
 optional = true
@@ -235,6 +227,11 @@ version = "1.0.0"
 optional = true
 features = ["serde", "v4"]
 
+[dependencies.zbus]
+version = "5.12.0"
+optional = true
+features = ["tokio"]
+
 [build-dependencies]
 pkg-config = "0.3.31"
 
@@ -288,7 +285,7 @@ engine = [
     "dep:uuid"
 ]
 default = ["dbus_enabled", "engine"]
-dbus_enabled = ["dep:dbus", "dep:dbus-tree"]
+dbus_enabled = ["dep:zbus"]
 extras = ["dep:pretty-hex"]
 min = ["dep:termios"]
 systemd_compat = ["dep:bindgen"]

src/dbus/blockdev/blockdev_3_0/methods.rs

@@ -0,0 +1,53 @@
+// 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, util::tuple_to_option},
+    engine::{DevUuid, Engine, PoolIdentifier, PoolUuid, RenameAction},
+    stratis::StratisError,
+};
+
+pub async fn set_user_info_method(
+    engine: &Arc<dyn Engine>,
+    uuid: PoolUuid,
+    bd_uuid: DevUuid,
+    new_id_spec: (bool, &str),
+) -> ((bool, DevUuid), u16, String) {
+    let default_return = (false, DevUuid::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.set_blockdev_user_info(
+                &pool_name,
+                bd_uuid,
+                tuple_to_option(new_id_spec)
+            )) {
+                Ok(RenameAction::NoSource) => (
+                    default_return,
+                    DbusErrorEnum::ERROR as u16,
+                    format!("pool doesn't know about block device {bd_uuid}"),
+                ),
+                Ok(RenameAction::Renamed(_)) => (
+                    (true, bd_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/blockdev/blockdev_3_0/mod.rs

@@ -0,0 +1,149 @@
+// 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::{blockdev::shared::blockdev_prop, manager::Manager},
+    engine::{DevUuid, Engine, Lockable, PoolUuid},
+    stratis::StratisResult,
+};
+
+mod methods;
+mod props;
+
+pub use methods::set_user_info_method;
+pub use props::{
+    devnode_prop, hardware_info_prop, init_time_prop, physical_path_prop, pool_prop, tier_prop,
+    total_physical_size_prop, user_info_prop,
+};
+
+pub struct BlockdevR0 {
+    engine: Arc<dyn Engine>,
+    manager: Lockable<Arc<RwLock<Manager>>>,
+    parent_uuid: PoolUuid,
+    uuid: DevUuid,
+}
+
+impl BlockdevR0 {
+    fn new(
+        engine: Arc<dyn Engine>,
+        manager: Lockable<Arc<RwLock<Manager>>>,
+        parent_uuid: PoolUuid,
+        uuid: DevUuid,
+    ) -> Self {
+        BlockdevR0 {
+            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: DevUuid,
+    ) -> StratisResult<()> {
+        let blockdev = Self::new(engine, manager.clone(), parent_uuid, uuid);
+
+        connection.object_server().at(path, blockdev).await?;
+        Ok(())
+    }
+
+    pub async fn unregister(
+        connection: &Arc<Connection>,
+        path: ObjectPath<'_>,
+    ) -> StratisResult<()> {
+        connection
+            .object_server()
+            .remove::<BlockdevR0, _>(path)
+            .await?;
+        Ok(())
+    }
+}
+
+#[interface(name = "org.storage.stratis3.blockdev.r0", introspection_docs = false)]
+impl BlockdevR0 {
+    #[zbus(out_args("changed", "return_code", "return_string"))]
+    async fn set_user_info(&self, id: (bool, &str)) -> ((bool, DevUuid), u16, String) {
+        set_user_info_method(&self.engine, self.parent_uuid, self.uuid, id).await
+    }
+
+    #[zbus(property(emits_changed_signal = "const"))]
+    async fn devnode(&self) -> Result<String, Error> {
+        blockdev_prop(&self.engine, self.parent_uuid, self.uuid, devnode_prop).await
+    }
+
+    #[zbus(property(emits_changed_signal = "const"))]
+    async fn hardware_info(&self) -> Result<(bool, String), Error> {
+        blockdev_prop(
+            &self.engine,
+            self.parent_uuid,
+            self.uuid,
+            hardware_info_prop,
+        )
+        .await
+    }
+
+    #[zbus(property(emits_changed_signal = "false"))]
+    async fn user_info(&self) -> Result<(bool, String), Error> {
+        blockdev_prop(&self.engine, self.parent_uuid, self.uuid, user_info_prop).await
+    }
+
+    #[zbus(property(emits_changed_signal = "const"))]
+    async fn initialization_time(&self) -> Result<u64, Error> {
+        blockdev_prop(&self.engine, self.parent_uuid, self.uuid, init_time_prop)
+            .await
+            .and_then(|r| r)
+    }
+
+    #[zbus(property(emits_changed_signal = "const"))]
+    async fn pool(&self) -> Result<OwnedObjectPath, Error> {
+        pool_prop(self.manager.read().await, self.parent_uuid)
+    }
+
+    #[zbus(property(emits_changed_signal = "const"))]
+    fn uuid(&self) -> DevUuid {
+        self.uuid
+    }
+
+    #[zbus(property(emits_changed_signal = "false"))]
+    async fn tier(&self) -> Result<u16, Error> {
+        blockdev_prop(&self.engine, self.parent_uuid, self.uuid, tier_prop).await
+    }
+
+    #[zbus(property(emits_changed_signal = "const"))]
+    async fn physical_path(&self) -> Result<String, Error> {
+        blockdev_prop(
+            &self.engine,
+            self.parent_uuid,
+            self.uuid,
+            physical_path_prop,
+        )
+        .await
+    }
+
+    #[zbus(property)]
+    async fn total_physical_size(&self) -> Result<String, Error> {
+        blockdev_prop(
+            &self.engine,
+            self.parent_uuid,
+            self.uuid,
+            total_physical_size_prop,
+        )
+        .await
+    }
+}

src/dbus/blockdev/blockdev_3_0/props.rs

@@ -0,0 +1,53 @@
+// 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 tokio::sync::OwnedRwLockReadGuard;
+use zbus::{fdo::Error, zvariant::OwnedObjectPath};
+
+use crate::{
+    dbus::{util::option_to_tuple, Manager},
+    engine::{BlockDev, BlockDevTier, DevUuid, PoolUuid, SharedGuard},
+};
+
+pub fn devnode_prop(_: BlockDevTier, _: DevUuid, dev: &dyn BlockDev) -> String {
+    dev.metadata_path().display().to_string()
+}
+
+pub fn hardware_info_prop(_: BlockDevTier, _: DevUuid, dev: &dyn BlockDev) -> (bool, String) {
+    option_to_tuple(dev.hardware_info().map(|s| s.to_owned()), String::new())
+}
+
+pub fn init_time_prop(_: BlockDevTier, _: DevUuid, dev: &dyn BlockDev) -> Result<u64, Error> {
+    u64::try_from(dev.initialization_time().timestamp()).map_err(|e| Error::Failed(e.to_string()))
+}
+
+pub fn physical_path_prop(_: BlockDevTier, _: DevUuid, dev: &dyn BlockDev) -> String {
+    dev.devnode().display().to_string()
+}
+
+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 total_physical_size_prop(_: BlockDevTier, _: DevUuid, dev: &dyn BlockDev) -> String {
+    (*dev.size().bytes()).to_string()
+}
+
+pub fn tier_prop(tier: BlockDevTier, _: DevUuid, _: &dyn BlockDev) -> u16 {
+    tier as u16
+}
+
+pub fn user_info_prop(_: BlockDevTier, _: DevUuid, dev: &dyn BlockDev) -> (bool, String) {
+    option_to_tuple(dev.user_info().map(|s| s.to_owned()), String::new())
+}