Update refactor to remove storage access.

Author: tmpfs

crates/account/src/account.rs

@@ -17,8 +17,8 @@ use sos_core::{
     device::{DevicePublicKey, TrustedDevice},
     encode,
     events::{
-        AccountEvent, Event, EventKind, EventLog, EventRecord, ReadEvent,
-        WriteEvent,
+        AccountEvent, DeviceEvent, Event, EventKind, EventLog, EventRecord,
+        ReadEvent, WriteEvent,
     },
     AccountId, Paths, SecretId, UtcDateTime, VaultCommit, VaultId,
 };
@@ -283,6 +283,12 @@ pub trait Account {
         &self,
     ) -> std::result::Result<DevicePublicKey, Self::Error>;
 
+    /// Patch the devices event log.
+    async fn patch_devices_unchecked(
+        &mut self,
+        events: Vec<DeviceEvent>,
+    ) -> std::result::Result<(), Self::Error>;
+
     /// Current device information.
     async fn current_device(
         &self,
@@ -770,6 +776,12 @@ pub trait Account {
         summary: &Summary,
     ) -> std::result::Result<FolderDelete<Self::NetworkResult>, Self::Error>;
 
+    /// Forget a folder from in-memory collections.
+    async fn forget_folder(
+        &mut self,
+        folder_id: &VaultId,
+    ) -> std::result::Result<bool, Self::Error>;
+
     /// Try to load an avatar JPEG image for a contact.
     ///
     /// Looks in the current open folder if no specified folder is given.
@@ -1671,6 +1683,13 @@ impl Account for LocalAccount {
         Ok(authenticated_user.identity()?.device().public_key())
     }
 
+    async fn patch_devices_unchecked(
+        &mut self,
+        events: Vec<DeviceEvent>,
+    ) -> Result<()> {
+        Ok(self.storage.patch_devices_unchecked(events).await?)
+    }
+
     async fn current_device(&self) -> Result<TrustedDevice> {
         let authenticated_user = self.storage.authenticated_user()?;
         Ok(authenticated_user.devices()?.current_device(None))
@@ -2845,6 +2864,10 @@ impl Account for LocalAccount {
         })
     }
 
+    async fn forget_folder(&mut self, folder_id: &VaultId) -> Result<bool> {
+        Ok(self.storage.remove_folder(folder_id).await?)
+    }
+
     #[cfg(feature = "contacts")]
     async fn load_avatar(
         &self,

crates/ipc/src/web_service/web_accounts.rs

@@ -310,10 +310,8 @@ where
                             // Now the storage should have the folder so
                             // we can access the access point and add it to
                             // the search index
-                            let storage = account.storage().await;
-                            let storage = storage.read().await;
                             if let Some(folder) =
-                                storage.folders().get(&folder_id)
+                                account.folder(&folder_id).await.ok()
                             {
                                 let access_point = folder.access_point();
                                 let access_point = access_point.lock().await;
@@ -330,11 +328,7 @@ where
                 }
             }
             ChangeRecords::Folder(folder_id, events) => {
-                let storage = account.storage().await;
-                let mut storage = storage.write().await;
-                if let Some(folder) =
-                    storage.folders_mut().get_mut(&folder_id)
-                {
+                if let Some(folder) = account.folder(&folder_id).await.ok() {
                     let access_point = folder.access_point();
                     let mut access_point = access_point.lock().await;
 
@@ -482,15 +476,13 @@ where
                 }
 
                 {
-                    let accounts = accounts.read().await;
+                    let mut accounts = accounts.write().await;
                     let account = accounts
-                        .iter()
+                        .iter_mut()
                         .find(|a| a.account_id() == &account_id)
                         .ok_or(FileEventError::NoAccount(account_id))?;
 
-                    let storage = account.storage().await;
-                    let mut storage = storage.write().await;
-                    storage.remove_folder(&folder_id).await?;
+                    account.forget_folder(&folder_id).await.ok();
                 }
                 ChangeRecords::Folder(folder_id, vec![])
             } else {
@@ -500,11 +492,10 @@ where
                     .find(|a| a.account_id() == &account_id)
                     .ok_or(FileEventError::NoAccount(account_id))?;
 
-                let storage = account.storage().await;
-                let storage = storage.read().await;
-                let folder = storage
-                    .folders()
-                    .get(&folder_id)
+                let folder = account
+                    .folder(&folder_id)
+                    .await
+                    .ok()
                     .ok_or(FileEventError::NoFolder(folder_id))?;
 
                 let event_log = folder.event_log();
@@ -575,10 +566,8 @@ where
         + Sync
         + 'static,
 {
-    let storage = account.storage().await;
-    let storage = storage.read().await;
-
-    let account_log = storage.account_log().await?;
+    // FIXME: update the error handling to avoid the unwrap
+    let account_log = account.account_log().await.unwrap();
     let mut event_log = account_log.write().await;
     let commit = event_log.tree().last_commit();
 

crates/login/src/identity_folder.rs

@@ -1,11 +1,8 @@
-//! Login identity vault management.
+//! Login identity folder management.
 //!
-//! Provides access to an identity vault containing
-//! the account signing key and delegated passwords used
-//! for folders managed by an account.
-//!
-//! This enables user interfaces to protect both the signing
-//! key and folder passwords using a single primary password.
+//! Provides access to an identity folder containing
+//! delegated passwords used to decrypt folders managed
+//! by an account.
 use crate::device::{DeviceManager, DeviceSigner};
 use crate::{Error, PrivateIdentity, Result, UrnLookup};
 use secrecy::{ExposeSecret, SecretBox, SecretString};
@@ -593,6 +590,8 @@ impl IdentityFolder {
         account_id: AccountId,
         keeper: &AccessPoint,
     ) -> Result<(UrnLookup, PrivateIdentity)> {
+        println!("doing login private identity...");
+
         let (index, identity_secret) =
             Self::lookup_identity_secrets(keeper).await?;
 
@@ -771,15 +770,18 @@ impl IdentityFolder {
     ) -> Result<Self> {
         let mut folder = Folder::new_fs(path).await?;
 
-        let access_point = folder.access_point();
-        let access_point = access_point.lock().await;
-
-        if !access_point.vault().flags().contains(VaultFlags::IDENTITY) {
-            return Err(Error::NotIdentityFolder);
+        {
+            let access_point = folder.access_point();
+            let access_point = access_point.lock().await;
+            if !access_point.vault().flags().contains(VaultFlags::IDENTITY) {
+                return Err(Error::NotIdentityFolder);
+            }
         }
 
         folder.unlock(key).await?;
 
+        let access_point = folder.access_point();
+        let access_point = access_point.lock().await;
         let (index, private_identity) =
             Self::login_private_identity(*account_id, &*access_point).await?;
 
@@ -816,15 +818,18 @@ impl IdentityFolder {
         )
         .await?;
 
-        let access_point = folder.access_point();
-        let access_point = access_point.lock().await;
-
-        if !access_point.vault().flags().contains(VaultFlags::IDENTITY) {
-            return Err(Error::NotIdentityFolder);
+        {
+            let access_point = folder.access_point();
+            let access_point = access_point.lock().await;
+            if !access_point.vault().flags().contains(VaultFlags::IDENTITY) {
+                return Err(Error::NotIdentityFolder);
+            }
         }
 
         folder.unlock(key).await?;
 
+        let access_point = folder.access_point();
+        let access_point = access_point.lock().await;
         let (index, private_identity) =
             Self::login_private_identity(*account_id, &*access_point).await?;
 

crates/net/src/account/network_account.rs

@@ -25,7 +25,7 @@ use sos_protocol::{
     AccountSync, DiffRequest, RemoteSync, RemoteSyncHandler, SyncClient,
     SyncOptions, SyncResult,
 };
-use sos_sdk::events::WriteEvent;
+use sos_sdk::events::{DeviceEvent, WriteEvent};
 use sos_sdk::UtcDateTime;
 use sos_sync::{CreateSet, StorageEventLogs, UpdateSet};
 use sos_vault::{
@@ -744,6 +744,14 @@ impl Account for NetworkAccount {
         Ok(account.device_public_key().await?)
     }
 
+    async fn patch_devices_unchecked(
+        &mut self,
+        events: Vec<DeviceEvent>,
+    ) -> Result<()> {
+        let mut account = self.account.lock().await;
+        Ok(account.patch_devices_unchecked(events).await?)
+    }
+
     async fn current_device(&self) -> Result<TrustedDevice> {
         let account = self.account.lock().await;
         Ok(account.current_device().await?)
@@ -1695,6 +1703,11 @@ impl Account for NetworkAccount {
         Ok(result)
     }
 
+    async fn forget_folder(&mut self, folder_id: &VaultId) -> Result<bool> {
+        let mut account = self.account.lock().await;
+        Ok(account.forget_folder(folder_id).await?)
+    }
+
     #[cfg(feature = "contacts")]
     async fn load_avatar(
         &self,

crates/net/src/pairing/websocket.rs

@@ -9,7 +9,6 @@ use futures::{
 use prost::bytes::Bytes;
 use snow::{Builder, HandshakeState, Keypair, TransportState};
 use sos_account::Account;
-use sos_client_storage::ClientDeviceStorage;
 use sos_core::events::DeviceEvent;
 use sos_core::{AccountId, Origin};
 use sos_protocol::{
@@ -442,9 +441,7 @@ impl<'a> OfferPairing<'a> {
         let events: Vec<DeviceEvent> =
             vec![DeviceEvent::Trust(trusted_device)];
         {
-            let storage = self.account.storage().await;
-            let mut writer = storage.write().await;
-            writer.patch_devices_unchecked(events).await?;
+            self.account.patch_devices_unchecked(events).await?;
         }
 
         // Send the patch to the remote server.

crates/storage/client/src/traits.rs

@@ -99,7 +99,7 @@ pub trait ClientFolderStorage {
         apply_event: bool,
     ) -> Result<Vec<Event>>;
 
-    /// Remove a folder from the cache.
+    /// Remove a folder from memory.
     async fn remove_folder(&mut self, folder_id: &VaultId) -> Result<bool>;
 
     /// List the in-memory folders.

crates/web/src/linked_account.rs

@@ -23,6 +23,7 @@ use sos_protocol::{
     RemoteSyncHandler, SyncClient, SyncOptions,
 };
 use sos_sdk::{
+    events::DeviceEvent,
     prelude::{
         AccessKey, AccountEvent, Cipher, DeviceManager, DevicePublicKey,
         DeviceSigner, EventRecord, KeyDerivation, Paths, PublicIdentity,
@@ -172,6 +173,14 @@ impl Account for LinkedAccount {
         Ok(account.device_public_key().await?)
     }
 
+    async fn patch_devices_unchecked(
+        &mut self,
+        events: Vec<DeviceEvent>,
+    ) -> Result<()> {
+        let mut account = self.account.lock().await;
+        Ok(account.patch_devices_unchecked(events).await?)
+    }
+
     async fn current_device(&self) -> Result<TrustedDevice> {
         let account = self.account.lock().await;
         Ok(account.current_device().await?)
@@ -918,6 +927,11 @@ impl Account for LinkedAccount {
         Ok(result)
     }
 
+    async fn forget_folder(&mut self, folder_id: &VaultId) -> Result<bool> {
+        let mut account = self.account.lock().await;
+        Ok(account.forget_folder(folder_id).await?)
+    }
+
     #[cfg(feature = "contacts")]
     async fn load_avatar(
         &self,

tests/integration/tests/network_account/listen_folder_delete.rs

@@ -71,11 +71,8 @@ async fn network_sync_listen_folder_delete() -> Result<()> {
 
     wait_for_cond(move || wait_files.iter().all(|p| !p.exists())).await;
 
-    let updated_summaries: Vec<Summary> = {
-        let storage = device1.owner.storage().await;
-        let reader = storage.read().await;
-        reader.list_folders().to_vec()
-    };
+    let updated_summaries: Vec<Summary> =
+        device1.owner.list_folders().await?;
     assert_eq!(folders.len(), updated_summaries.len());
 
     assert!(!vfs::try_exists(server_files.remove(0)).await?);

tests/integration/tests/network_account/send_folder_delete.rs

@@ -49,11 +49,7 @@ async fn network_sync_folder_delete() -> Result<()> {
         device.owner.delete_folder(&new_folder).await?;
     assert!(sync_result.first_error().is_none());
 
-    let updated_summaries: Vec<Summary> = {
-        let storage = device.owner.storage().await;
-        let reader = storage.read().await;
-        reader.list_folders().to_vec()
-    };
+    let updated_summaries: Vec<Summary> = device.owner.list_folders().await?;
 
     assert_eq!(folders.len(), updated_summaries.len());
 

tests/utils/src/network.rs

@@ -212,9 +212,7 @@ pub async fn num_events(
     owner: &mut NetworkAccount,
     folder_id: &VaultId,
 ) -> usize {
-    let storage = owner.storage().await;
-    let reader = storage.read().await;
-    let folder = reader.folders().get(folder_id).unwrap();
+    let folder = owner.folder(folder_id).await.unwrap();
     let events = folder.event_log();
     let events = events.read().await;
     events.tree().len()
@@ -234,14 +232,11 @@ pub async fn assert_local_remote_vaults_eq(
     owner: &mut NetworkAccount,
     _provider: &mut RemoteBridge,
 ) -> Result<()> {
-    let storage = owner.storage().await;
-    let reader = storage.read().await;
-
     // Compare vault buffers
     for summary in expected_summaries {
         tracing::debug!(id = %summary.id(), "assert_local_remote_vaults_eq");
 
-        let local_folder = reader.paths().vault_path(summary.id());
+        let local_folder = owner.paths().vault_path(summary.id());
         let remote_folder = server_path.join("vaults").join(format!(
             "{}.{}",
             summary.id(),