Tidy constructors, do not need async anymore.

Author: tmpfs

crates/backend/src/access_point.rs

@@ -29,15 +29,9 @@ impl BackendAccessPoint {
     }
 
     /// Access point that mirrors to disc.
-    pub async fn new_fs<P: AsRef<Path>>(
-        vault: Vault,
-        path: P,
-    ) -> Result<Self> {
-        let mirror = VaultFileWriter::<Error>::new(path).await?;
-        Ok(Self(AccessPoint::<Error>::new_mirror(
-            vault,
-            Box::new(mirror),
-        )))
+    pub fn new_fs<P: AsRef<Path>>(vault: Vault, path: P) -> Self {
+        let mirror = VaultFileWriter::<Error>::new(path);
+        Self(AccessPoint::<Error>::new_mirror(vault, Box::new(mirror)))
     }
 
     /// Access point that mirrors to a database table.
@@ -46,8 +40,7 @@ impl BackendAccessPoint {
         client: Client,
         folder_id: VaultId,
     ) -> Self {
-        let mirror =
-            VaultDatabaseWriter::<Error>::new(client, folder_id).await;
+        let mirror = VaultDatabaseWriter::<Error>::new(client, folder_id);
         Self(AccessPoint::<Error>::new_mirror(vault, Box::new(mirror)))
     }
 }

crates/backend/src/folder.rs

@@ -63,7 +63,7 @@ impl Folder {
             vault
         };
 
-        let mirror = VaultFileWriter::<Error>::new(path.as_ref()).await?;
+        let mirror = VaultFileWriter::<Error>::new(path.as_ref());
         let keeper =
             VaultAccessPoint::<Error>::new_mirror(vault, Box::new(mirror));
 
@@ -125,8 +125,7 @@ impl Folder {
             event_log.apply(vec![&event]).await?;
         }
 
-        let mirror =
-            VaultDatabaseWriter::<Error>::new(client, folder_id).await;
+        let mirror = VaultDatabaseWriter::<Error>::new(client, folder_id);
         let keeper =
             VaultAccessPoint::<Error>::new_mirror(vault, Box::new(mirror));
 

crates/backend/src/vault_writer.rs

@@ -21,15 +21,13 @@ pub enum VaultWriter {
 
 impl VaultWriter {
     /// Create a new database vault writer.
-    pub async fn new_db(client: Client, folder_id: VaultId) -> Self {
-        Self::Database(
-            VaultDatabaseWriter::<Error>::new(client, folder_id).await,
-        )
+    pub fn new_db(client: Client, folder_id: VaultId) -> Self {
+        Self::Database(VaultDatabaseWriter::<Error>::new(client, folder_id))
     }
 
     /// Create a new file system vault writer.
-    pub async fn new_fs<P: AsRef<Path>>(path: P) -> Result<Self> {
-        Ok(Self::FileSystem(VaultFileWriter::<Error>::new(path).await?))
+    pub fn new_fs<P: AsRef<Path>>(path: P) -> Self {
+        Self::FileSystem(VaultFileWriter::<Error>::new(path))
     }
 }
 

crates/backup_archive/src/zip/backup.rs

@@ -453,7 +453,7 @@ impl AccountBackup {
             let identity_vault_file = paths.identity_vault();
 
             let mut access =
-                VaultFileWriter::<Error>::new(identity_vault_file).await?;
+                VaultFileWriter::<Error>::new(identity_vault_file);
             access.set_vault_name(name.clone()).await?;
 
             name

crates/database/src/vault_writer.rs

@@ -44,7 +44,7 @@ where
         + 'static,
 {
     /// Create a new vault database writer.
-    pub async fn new(client: Client, folder_id: VaultId) -> Self {
+    pub fn new(client: Client, folder_id: VaultId) -> Self {
         Self {
             client,
             folder_id,

crates/filesystem/src/vault_writer.rs

@@ -45,12 +45,12 @@ where
         + 'static,
 {
     /// Create a new vault file writer.
-    pub async fn new<P: AsRef<Path>>(path: P) -> Result<Self, E> {
+    pub fn new<P: AsRef<Path>>(path: P) -> Self {
         let file_path = path.as_ref().to_path_buf();
-        Ok(Self {
+        Self {
             file_path,
             marker: std::marker::PhantomData,
-        })
+        }
     }
 
     /// Check the identity bytes and return the byte offset of the

crates/login/src/identity_folder.rs

@@ -152,7 +152,7 @@ impl IdentityFolder {
             .ok_or(Error::NoFolderPassword(*summary.id()))?;
 
         let mut device_keeper =
-            AccessPoint::new_fs(vault, &device_vault_path).await?;
+            AccessPoint::new_fs(vault, &device_vault_path);
         let key: AccessKey = device_password.into();
         device_keeper.unlock(&key).await?;
 
@@ -219,7 +219,7 @@ impl IdentityFolder {
         let mut device_keeper = if mirror {
             let buffer = encode(&vault).await?;
             write_exclusive(&device_vault_path, &buffer).await?;
-            AccessPoint::new_fs(vault, &device_vault_path).await?
+            AccessPoint::new_fs(vault, &device_vault_path)
         } else {
             AccessPoint::new_vault(vault)
         };

crates/net/src/pairing/enrollment.rs

@@ -126,7 +126,7 @@ impl DeviceEnrollment {
         // of the identity vault
         if let Some(account_name) = self.account_name.take() {
             let path = self.paths.identity_vault();
-            let mut file = VaultWriter::new_fs(&path).await?;
+            let mut file = VaultWriter::new_fs(&path);
             file.set_vault_name(account_name).await?;
         }
 

crates/storage/server/src/filesystem/mod.rs

@@ -403,7 +403,7 @@ impl ServerAccountStorage for ServerFileStorage {
     ) -> Result<()> {
         // Update the vault on disc
         let vault_path = self.paths.vault_path(id);
-        let mut access = VaultWriter::new_fs(vault_path).await?;
+        let mut access = VaultWriter::new_fs(vault_path);
         access.set_vault_name(name.to_owned()).await?;
 
         #[cfg(feature = "audit")]

crates/storage/server/src/filesystem/sync.rs

@@ -251,7 +251,7 @@ impl Merge for ServerFileStorage {
                     }
                     AccountEvent::RenameAccount(name) => {
                         let path = self.paths.identity_vault();
-                        let mut file = VaultWriter::new_fs(path).await?;
+                        let mut file = VaultWriter::new_fs(path);
                         file.set_vault_name(name.to_owned()).await?;
                     }
                     AccountEvent::UpdateIdentity(_) => {
@@ -412,7 +412,7 @@ impl Merge for ServerFileStorage {
             for event in events {
                 if let WriteEvent::SetVaultFlags(flags) = event {
                     let path = self.paths.vault_path(folder_id);
-                    let mut writer = VaultWriter::new_fs(path).await?;
+                    let mut writer = VaultWriter::new_fs(path);
                     writer.set_vault_flags(flags).await?;
                 }
             }

tests/integration/tests/audit_trail/client.rs

@@ -10,7 +10,7 @@ use sos_account::{
 use sos_audit::AuditEvent;
 use sos_migrate::import::ImportTarget;
 use sos_sdk::prelude::*;
-use std::path::{Path, PathBuf};
+use std::path::PathBuf;
 
 #[tokio::test]
 async fn audit_trail_client() -> Result<()> {

tests/unit/src/tests/vault_writer/vault_access.rs

@@ -10,7 +10,7 @@ use uuid::Uuid;
 async fn vault_writer_access_filesystem() -> Result<()> {
     let (encryption_key, _, _) = mock::encryption_key()?;
     let (temp, vault, _) = mock::vault_file().await?;
-    let mut vault_access = VaultWriter::new_fs(temp.path()).await?;
+    let mut vault_access = VaultWriter::new_fs(temp.path());
     assert_encrypted_entry(&mut vault_access, vault, &encryption_key).await?;
     temp.close()?;
     Ok(())
@@ -23,7 +23,7 @@ async fn vault_writer_access_database() -> Result<()> {
     let mut db_client = mock::memory_database().await?;
     let vault: Vault = Default::default();
     mock::insert_database_vault(&mut db_client, &vault).await?;
-    let mut vault_access = VaultWriter::new_db(db_client, *vault.id()).await;
+    let mut vault_access = VaultWriter::new_db(db_client, *vault.id());
     assert_encrypted_entry(&mut vault_access, vault, &encryption_key).await?;
     Ok(())
 }

tests/unit/src/tests/vault_writer/vault_file_writer.rs

@@ -10,7 +10,7 @@ async fn vault_writer_file_del_splice() -> Result<()> {
     let (encryption_key, _, _) = mock::encryption_key()?;
     let (temp, vault, _) = mock::vault_file().await?;
 
-    let mut vault_access = VaultFileWriter::<Error>::new(temp.path()).await?;
+    let mut vault_access = VaultFileWriter::<Error>::new(temp.path());
 
     let secrets = [
         ("Note one", "First note"),

tests/unit/src/tests/vault_writer/vault_flags.rs

@@ -6,7 +6,7 @@ use sos_test_utils::mock;
 #[tokio::test]
 async fn vault_writer_flags_filesystem() -> Result<()> {
     let (temp, _, _) = mock::vault_file().await?;
-    let mut vault_access = VaultWriter::new_fs(temp.path()).await?;
+    let mut vault_access = VaultWriter::new_fs(temp.path());
     test_vault_flags(&mut vault_access).await?;
     temp.close()?;
     Ok(())
@@ -17,7 +17,7 @@ async fn vault_writer_flags_database() -> Result<()> {
     let mut db_client = mock::memory_database().await?;
     let vault: Vault = Default::default();
     mock::insert_database_vault(&mut db_client, &vault).await?;
-    let mut vault_access = VaultWriter::new_db(db_client, *vault.id()).await;
+    let mut vault_access = VaultWriter::new_db(db_client, *vault.id());
     test_vault_flags(&mut vault_access).await?;
     Ok(())
 }