WIP: refactoring to remove access to storage via account.

Author: tmpfs

crates/account/src/account.rs

@@ -251,6 +251,12 @@ pub trait Account {
     /// User storage paths.
     fn paths(&self) -> Arc<Paths>;
 
+    /// Lookup a folder in the storage.
+    async fn folder(
+        &self,
+        folder_id: &VaultId,
+    ) -> std::result::Result<Folder, Self::Error>;
+
     /// Determine if the account is authenticated.
     async fn is_authenticated(&self) -> bool;
 
@@ -1551,6 +1557,15 @@ impl Account for LocalAccount {
         Arc::clone(&self.paths)
     }
 
+    async fn folder(&self, folder_id: &VaultId) -> Result<Folder> {
+        Ok(self
+            .storage
+            .folders()
+            .get(folder_id)
+            .ok_or(StorageError::CacheNotAvailable(*folder_id))?
+            .clone())
+    }
+
     async fn is_authenticated(&self) -> bool {
         self.storage.is_authenticated()
     }

crates/net/src/account/network_account.rs

@@ -8,7 +8,7 @@ use sos_account::{
     FolderChange, FolderCreate, FolderDelete, LocalAccount, SecretChange,
     SecretDelete, SecretInsert, SecretMove,
 };
-use sos_backend::ServerOrigins;
+use sos_backend::{Folder, ServerOrigins};
 use sos_client_storage::{
     AccessOptions, ClientDeviceStorage, ClientStorage, NewFolderOptions,
 };
@@ -709,6 +709,11 @@ impl Account for NetworkAccount {
         Arc::clone(&self.paths)
     }
 
+    async fn folder(&self, folder_id: &VaultId) -> Result<Folder> {
+        let account = self.account.lock().await;
+        Ok(account.folder(folder_id).await?)
+    }
+
     async fn is_authenticated(&self) -> bool {
         let account = self.account.lock().await;
         account.is_authenticated().await

crates/security_report/src/lib.rs

@@ -46,14 +46,11 @@ where
         .collect();
 
     for target in targets {
-        /*
-        let storage = account.storage().await;
-        let reader = storage.read().await;
+        let folder = account.folder(target.id()).await?;
+        let access_point = folder.access_point();
+        let access_point = access_point.lock().await;
 
-        let folder = reader.folders().get(target.id()).unwrap();
-        let keeper = folder.keeper();
-
-        let vault = keeper.vault();
+        let vault = access_point.vault();
         let mut password_hashes: Vec<(
             SecretId,
             (Option<Entropy>, Vec<u8>),
@@ -63,7 +60,7 @@ where
         if let Some(target) = &options.target {
             secret_security_report::<E>(
                 &target.1,
-                keeper,
+                &*access_point,
                 &mut password_hashes,
                 target.2.as_ref(),
             )
@@ -72,7 +69,7 @@ where
             for secret_id in vault.keys() {
                 secret_security_report::<E>(
                     secret_id,
-                    keeper,
+                    &*access_point,
                     &mut password_hashes,
                     None,
                 )
@@ -93,9 +90,6 @@ where
             hashes.push(hex::encode(sha1));
             records.push(record);
         }
-        */
-
-        todo!("restore security report...");
     }
 
     let database_checks =
@@ -245,7 +239,7 @@ pub struct SecurityReportRecord {
 
 async fn secret_security_report<E>(
     secret_id: &SecretId,
-    keeper: &AccessPoint,
+    access_point: &AccessPoint,
     password_hashes: &mut Vec<(
         SecretId,
         (Option<Entropy>, Vec<u8>),
@@ -258,7 +252,9 @@ where
         + From<sos_backend::StorageError>
         + From<sos_backend::Error>,
 {
-    if let Some((_meta, secret, _)) = keeper.read_secret(secret_id).await? {
+    if let Some((_meta, secret, _)) =
+        access_point.read_secret(secret_id).await?
+    {
         for field in secret.user_data().fields().iter().filter(|field| {
             if let Some(field_id) = target_field {
                 return field_id == field.id();

crates/sos/src/commands/tools/authenticator.rs

@@ -57,16 +57,12 @@ pub async fn run(cmd: Command) -> Result<()> {
                 .await
                 .ok_or(Error::NoAuthenticatorFolder)?;
 
-            todo!("restore auth export ");
+            let folder = owner.folder(authenticator.id()).await?;
+            let access_point = folder.access_point();
+            let access_point = access_point.lock().await;
 
-            /*
-            let storage = owner.storage().await;
-            let storage = storage.read().await;
-            let folder = storage.folders().get(authenticator.id()).unwrap();
-
-            export_authenticator(file, folder.keeper(), qr_codes).await?;
+            export_authenticator(file, &*access_point, qr_codes).await?;
             success("authenticator TOTP secrets exported");
-            */
         }
         Command::Import {
             account,
@@ -109,16 +105,12 @@ pub async fn run(cmd: Command) -> Result<()> {
             };
 
             if let Some(folder) = folder {
-                /*
-                let storage = owner.storage().await;
-                let mut storage = storage.write().await;
-                let folder =
-                    storage.folders_mut().get_mut(folder.id()).unwrap();
-                import_authenticator(file, folder.keeper_mut()).await?;
-                success("authenticator TOTP secrets imported");
-                */
+                let folder = owner.folder(folder.id()).await?;
+                let access_point = folder.access_point();
+                let mut access_point = access_point.lock().await;
 
-                todo!("restore auth import");
+                import_authenticator(file, &mut *access_point).await?;
+                success("authenticator TOTP secrets imported");
             }
         }
     }

crates/web/src/linked_account.rs

@@ -8,7 +8,7 @@ use sos_account::{
     FolderChange, FolderCreate, FolderDelete, LocalAccount, SecretChange,
     SecretDelete, SecretInsert, SecretMove,
 };
-use sos_backend::{AccountEventLog, DeviceEventLog, FolderEventLog};
+use sos_backend::{AccountEventLog, DeviceEventLog, Folder, FolderEventLog};
 use sos_client_storage::{AccessOptions, ClientStorage, NewFolderOptions};
 use sos_core::{
     commit::{CommitHash, CommitState, Comparison},
@@ -137,6 +137,11 @@ impl Account for LinkedAccount {
         self.paths.clone()
     }
 
+    async fn folder(&self, folder_id: &VaultId) -> Result<Folder> {
+        let account = self.account.lock().await;
+        Ok(account.folder(folder_id).await?)
+    }
+
     async fn is_authenticated(&self) -> bool {
         let account = self.account.lock().await;
         account.is_authenticated().await