Move rename out of platform_device_loader to platform_filesystem

Author: AureliaDolo

libparsec/crates/platform_device_loader/src/lib.rs

@@ -4,8 +4,8 @@ mod strategy;
 use itertools::Itertools;
 use libparsec_platform_async::stream::StreamExt;
 use libparsec_platform_filesystem::{
-    list_files, load_file, remove_file, save_content, ListFilesError, LoadFileError,
-    RemoveFileError, SaveContentError,
+    list_files, load_file, remove_file, rename_file, save_content, ListFilesError, LoadFileError,
+    RemoveFileError, RenameFileError, SaveContentError,
 };
 pub use strategy::*;
 #[cfg(not(target_arch = "wasm32"))]
@@ -673,7 +673,25 @@ pub async fn archive_device(
         return result;
     }
 
-    platform::archive_device(device_path).await
+    let archive_device_path = get_device_archive_path(device_path);
+
+    log::debug!(
+        "Archiving device {} to {}",
+        device_path.display(),
+        archive_device_path.display()
+    );
+
+    rename_file(device_path, &archive_device_path)
+        .await
+        .map_err(|e| match e {
+            RenameFileError::StorageNotAvailable | RenameFileError::NoSpaceLeft => {
+                ArchiveDeviceError::StorageNotAvailable
+            } // TODO #11955
+            RenameFileError::InvalidParent
+            | RenameFileError::InvalidPath
+            | RenameFileError::NotFound
+            | RenameFileError::Internal(_) => ArchiveDeviceError::Internal(e.into()),
+        })
 }
 
 #[derive(Debug, thiserror::Error)]

libparsec/crates/platform_device_loader/src/native/mod.rs

@@ -7,9 +7,9 @@ use std::path::{Path, PathBuf};
 use uuid::Uuid;
 
 use crate::{
-    encrypt_device, get_device_archive_path, AccountVaultOperationsFetchOpaqueKeyError,
-    AccountVaultOperationsUploadOpaqueKeyError, ArchiveDeviceError, AvailableDevice,
-    DeviceAccessStrategy, DeviceSaveStrategy, LoadCiphertextKeyError, LoadDeviceError,
+    encrypt_device, AccountVaultOperationsFetchOpaqueKeyError,
+    AccountVaultOperationsUploadOpaqueKeyError, AvailableDevice, DeviceAccessStrategy,
+    DeviceSaveStrategy, LoadCiphertextKeyError, LoadDeviceError,
     OpenBaoOperationsFetchOpaqueKeyError, OpenBaoOperationsUploadOpaqueKeyError,
     RemoteOperationServer, SaveDeviceError,
 };
@@ -400,20 +400,6 @@ pub(super) async fn save_device(
     })
 }
 
-pub(super) async fn archive_device(device_path: &Path) -> Result<(), ArchiveDeviceError> {
-    let archive_device_path = get_device_archive_path(device_path);
-
-    log::debug!(
-        "Archiving device {} to {}",
-        device_path.display(),
-        archive_device_path.display()
-    );
-
-    tokio::fs::rename(device_path, archive_device_path)
-        .await
-        .map_err(|e| ArchiveDeviceError::Internal(e.into()))
-}
-
 pub(super) fn is_keyring_available() -> bool {
     // Using "tmp" as user, because keyring-rs forbids the use of empty string
     // due to an issue in macOS. See: https://github.com/hwchen/keyring-rs/pull/87

libparsec/crates/platform_device_loader/src/web/internal.rs

@@ -1,28 +1,18 @@
 // Parsec Cloud (https://parsec.cloud) Copyright (c) BUSL-1.1 2016-present Scille SAS
 
-use std::path::{Path, PathBuf};
+use std::path::PathBuf;
 
 use libparsec_platform_filesystem::save_content;
 use libparsec_types::prelude::*;
 
 use crate::{
-    web::wrapper::OpenOptions, AccountVaultOperationsUploadOpaqueKeyError, AvailableDevice,
-    DeviceSaveStrategy, OpenBaoOperationsUploadOpaqueKeyError, RemoteOperationServer,
-    SaveDeviceError,
+    AccountVaultOperationsUploadOpaqueKeyError, AvailableDevice, DeviceSaveStrategy,
+    OpenBaoOperationsUploadOpaqueKeyError, RemoteOperationServer, SaveDeviceError,
 };
 
-use super::{error::*, wrapper::Directory};
-
-pub struct Storage {
-    root_dir: Directory,
-}
+pub struct Storage {}
 
 impl Storage {
-    pub(crate) async fn new() -> Result<Self, NewStorageError> {
-        let root_dir = Directory::get_root().await?;
-        Ok(Self { root_dir })
-    }
-
     pub(crate) async fn save_device(
         strategy: &DeviceSaveStrategy,
         key_file: PathBuf,
@@ -150,32 +140,4 @@ impl Storage {
             ty: strategy.ty(),
         })
     }
-
-    pub(crate) async fn archive_device(&self, path: &Path) -> Result<(), ArchiveDeviceError> {
-        let old_device = self
-            .root_dir
-            .get_file_from_path(path, None)
-            .await
-            .map_err(ArchiveDeviceError::GetDeviceToArchive)?;
-        let old_data = old_device
-            .read_to_end()
-            .await
-            .map_err(ArchiveDeviceError::ReadDeviceToArchive)?;
-
-        let archive_path = crate::get_device_archive_path(path);
-        let archive_device = self
-            .root_dir
-            .get_file_from_path(&archive_path, Some(OpenOptions::create()))
-            .await
-            .map_err(ArchiveDeviceError::CreateArchiveDevice)?;
-        archive_device
-            .write_all(&old_data)
-            .await
-            .map_err(ArchiveDeviceError::WriteArchiveDevice)?;
-
-        self.root_dir
-            .remove_entry_from_path(path)
-            .await
-            .map_err(Into::into)
-    }
 }

libparsec/crates/platform_device_loader/src/web/mod.rs

@@ -4,12 +4,12 @@ pub(crate) mod error;
 pub(crate) mod internal;
 pub(crate) mod wrapper;
 use libparsec_types::prelude::*;
-use std::path::{Path, PathBuf};
+use std::path::PathBuf;
 
 use crate::{
-    AccountVaultOperationsFetchOpaqueKeyError, ArchiveDeviceError, AvailableDevice,
-    DeviceAccessStrategy, DeviceSaveStrategy, LoadCiphertextKeyError,
-    OpenBaoOperationsFetchOpaqueKeyError, RemoteOperationServer, SaveDeviceError,
+    AccountVaultOperationsFetchOpaqueKeyError, AvailableDevice, DeviceAccessStrategy,
+    DeviceSaveStrategy, LoadCiphertextKeyError, OpenBaoOperationsFetchOpaqueKeyError,
+    RemoteOperationServer, SaveDeviceError,
 };
 use internal::Storage;
 
@@ -110,15 +110,3 @@ pub(super) async fn save_device(
         .await
         .map_err(Into::into)
 }
-
-pub(super) async fn archive_device(device_path: &Path) -> Result<(), ArchiveDeviceError> {
-    let Ok(storage) = Storage::new().await.inspect_err(|e| {
-        log::error!("Failed to access storage: {e}");
-    }) else {
-        return Err(ArchiveDeviceError::StorageNotAvailable);
-    };
-    storage
-        .archive_device(device_path)
-        .await
-        .map_err(Into::into)
-}