[pbs-devel] [PATCH proxmox-backup 10/26] api2: admin: add mount-device and list endpoint for RemavableDevices

[Hannes Laimer <h.laimer@proxmox.com>]

*mount-device: mounts the removable at the path of the associated
datastore, only done if nothing else is already mounted at that path
*list: returns a list of removable devices and their mounting status

Signed-off-by: Hannes Laimer <h.laimer@proxmox.com>
---
 pbs-api-types/src/removable_device.rs |  21 +++
 src/api2/admin/mod.rs                 |   2 +
 src/api2/admin/removable_device.rs    | 217 ++++++++++++++++++++++++++
 3 files changed, 240 insertions(+)
 create mode 100644 src/api2/admin/removable_device.rs

diff --git a/pbs-api-types/src/removable_device.rs b/pbs-api-types/src/removable_device.rs
index cb1dca11..94f7e977 100644
--- a/pbs-api-types/src/removable_device.rs
+++ b/pbs-api-types/src/removable_device.rs
@@ -56,3 +56,24 @@ impl RemovableDeviceConfig {
         vec!["datastore", &self.store]
     }
 }
+
+#[api(
+    properties: {
+        config: {
+            type: RemovableDeviceConfig,
+        },
+        mounted: {
+            type: bool,
+        },
+    },
+)]
+#[derive(Serialize, Deserialize)]
+#[serde(rename_all = "kebab-case")]
+/// Status of a removable device
+pub struct RemovableDeviceStatus {
+    #[serde(flatten)]
+    pub config: RemovableDeviceConfig,
+
+    /// The device is mounted
+    pub mounted: bool,
+}
diff --git a/src/api2/admin/mod.rs b/src/api2/admin/mod.rs
index 9b6fc9ad..00ff9131 100644
--- a/src/api2/admin/mod.rs
+++ b/src/api2/admin/mod.rs
@@ -8,6 +8,7 @@ pub mod datastore;
 pub mod metrics;
 pub mod namespace;
 pub mod prune;
+pub mod removable_device;
 pub mod sync;
 pub mod traffic_control;
 pub mod verify;
@@ -18,6 +19,7 @@ const SUBDIRS: SubdirMap = &sorted!([
     ("metrics", &metrics::ROUTER),
     ("prune", &prune::ROUTER),
     ("sync", &sync::ROUTER),
+    ("removable-device", &removable_device::ROUTER),
     ("traffic-control", &traffic_control::ROUTER),
     ("verify", &verify::ROUTER),
 ]);
diff --git a/src/api2/admin/removable_device.rs b/src/api2/admin/removable_device.rs
new file mode 100644
index 00000000..53b92ba7
--- /dev/null
+++ b/src/api2/admin/removable_device.rs
@@ -0,0 +1,217 @@
+use std::path::PathBuf;
+
+use anyhow::{bail, Error};
+use proxmox_router::{
+    list_subdirs_api_method, ApiMethod, Permission, Router, RpcEnvironment, RpcEnvironmentType,
+    SubdirMap,
+};
+use proxmox_schema::api;
+use proxmox_section_config::SectionConfigData;
+use proxmox_sys::{sortable, task_log, WorkerTaskContext};
+use serde_json::Value;
+
+use pbs_api_types::{
+    Authid, DataStoreConfig, RemovableDeviceConfig, RemovableDeviceStatus, DATASTORE_SCHEMA,
+    DEVICE_NAME_SCHEMA, PRIV_DATASTORE_AUDIT, PRIV_DATASTORE_MODIFY,
+};
+use pbs_config::{datastore, removable_device, BackupLockGuard, CachedUserInfo};
+use pbs_datastore::ChunkStore;
+use proxmox_rest_server::WorkerTask;
+
+use crate::tools::disks::{DiskManage, DiskUsageQuery};
+
+fn do_mount_removable(
+    _lock: BackupLockGuard,
+    mut device_section_config: SectionConfigData,
+    mut datastore_section_config: SectionConfigData,
+    mut datastore: DataStoreConfig,
+    mut device: RemovableDeviceConfig,
+    worker: Option<&dyn WorkerTaskContext>,
+) -> Result<(), Error> {
+    if DiskManage::new()
+        .mount_info()?
+        .iter()
+        .filter_map(|(_id, entry)| entry.mount_point.to_str())
+        .any(|mount_point| datastore.path.eq(mount_point))
+    {
+        bail!("something is already mounted at '{}'", &datastore.path);
+    };
+
+    crate::tools::disks::mount_by_uuid(&device.uuid, &datastore.path)?;
+    if !device.initialized {
+        if let Some(worker) = worker {
+            task_log!(
+                worker,
+                "Initializing '{}' {} for datastore {}",
+                device.name,
+                device.uuid,
+                datastore.name
+            );
+        }
+        let path: PathBuf = datastore.path.clone().into();
+
+        let backup_user = pbs_config::backup_user()?;
+        if let Err(e) = ChunkStore::create(
+            &datastore.name,
+            path,
+            backup_user.uid,
+            backup_user.gid,
+            worker,
+        ) {
+            crate::tools::disks::unmount_by_mountpoint(&datastore.path)?;
+            return Err(e);
+        }
+        device.initialized = true;
+    }
+    datastore.maintenance_mode = None;
+
+    device_section_config.set_data(&device.name, "removable-device", &device)?;
+    datastore_section_config.set_data(&datastore.name, "datastore", &datastore)?;
+
+    pbs_config::removable_device::save_config(&device_section_config)?;
+    pbs_config::datastore::save_config(&datastore_section_config)?;
+
+    Ok(())
+}
+
+#[api(
+    input: {
+        properties: {
+            store: {
+                schema: DATASTORE_SCHEMA,
+                optional: true,
+            },
+        },
+    },
+    returns: {
+        description: "List configured removable devices and their status.",
+        type: Array,
+        items: { type: RemovableDeviceStatus },
+    },
+    access: {
+        permission: &Permission::Anybody,
+        description: "Requires Datastore.Audit on datastore.",
+    },
+)]
+/// List all removable devices with their status
+pub fn list_removable_devices(
+    store: Option<String>,
+    _param: Value,
+    rpcenv: &mut dyn RpcEnvironment,
+) -> Result<Vec<RemovableDeviceStatus>, Error> {
+    let auth_id: Authid = rpcenv.get_auth_id().unwrap().parse()?;
+    let user_info = CachedUserInfo::new()?;
+
+    let required_privs = PRIV_DATASTORE_AUDIT;
+    let (config, digest) = removable_device::config()?;
+
+    let device_config_iter = config
+        .convert_to_typed_array("removable-device")?
+        .into_iter()
+        .filter(|device: &RemovableDeviceConfig| {
+            let privs = user_info.lookup_privs(&auth_id, &device.acl_path());
+            if privs & required_privs == 0 {
+                return false;
+            }
+            store.as_ref().map_or(true, |store| device.store.eq(store))
+        });
+
+    let mut list = Vec::new();
+
+    for device in device_config_iter {
+        let mounted = DiskUsageQuery::new()
+            .partitions(true)
+            .query()?
+            .iter()
+            .filter_map(|(_path, info)| info.partitions.as_ref())
+            .flatten()
+            .any(|partition| {
+                partition
+                    .uuid
+                    .as_ref()
+                    .map_or(false, |p| p.eq(&device.uuid))
+                    && partition.mounted
+            });
+        list.push(RemovableDeviceStatus {
+            config: device,
+            mounted,
+        });
+    }
+
+    rpcenv["digest"] = hex::encode(&digest).into();
+
+    Ok(list)
+}
+
+#[api(
+    protected: true,
+    input: {
+        properties: {
+            name: {
+                schema: DEVICE_NAME_SCHEMA,
+            }
+        }
+    },
+    access: {
+        permission: &Permission::Anybody,
+        description: "Requires Datastore.Modify on job's datastore.",
+    },
+)]
+/// Mount removable device.
+pub fn mount_removable_device(
+    name: String,
+    _info: &ApiMethod,
+    rpcenv: &mut dyn RpcEnvironment,
+) -> Result<String, Error> {
+    let auth_id: Authid = rpcenv.get_auth_id().unwrap().parse()?;
+    let user_info = CachedUserInfo::new()?;
+
+    let lock = pbs_config::datastore::lock_config()?;
+    let to_stdout = rpcenv.env_type() == RpcEnvironmentType::CLI;
+
+    let (section_config, _digest) = removable_device::config()?;
+    let device_config: RemovableDeviceConfig = section_config.lookup("removable-device", &name)?;
+
+    user_info.check_privs(
+        &auth_id,
+        &device_config.acl_path(),
+        PRIV_DATASTORE_MODIFY,
+        true,
+    )?;
+
+    let (datastore_section_config, _digest) = datastore::config()?;
+    let store: DataStoreConfig =
+        datastore_section_config.lookup("datastore", &device_config.store)?;
+
+    let upid = WorkerTask::new_thread(
+        "mount-device",
+        Some(store.name.to_string()),
+        auth_id.to_string(),
+        to_stdout,
+        move |worker| {
+            do_mount_removable(
+                lock,
+                section_config,
+                datastore_section_config,
+                store,
+                device_config,
+                Some(&worker),
+            )
+        },
+    )?;
+    Ok(upid)
+}
+
+#[sortable]
+const DEVICE_INFO_SUBDIRS: SubdirMap = &[(
+    "mount",
+    &Router::new().post(&API_METHOD_MOUNT_REMOVABLE_DEVICE),
+)];
+
+const DEVICE_INFO_ROUTER: Router = Router::new()
+    .get(&list_subdirs_api_method!(DEVICE_INFO_SUBDIRS))
+    .subdirs(DEVICE_INFO_SUBDIRS);
+
+pub const ROUTER: Router = Router::new()
+    .get(&API_METHOD_LIST_REMOVABLE_DEVICES)
+    .match_all("name", &DEVICE_INFO_ROUTER);
-- 
2.30.2