Enum ClientStorage

pub enum ClientStorage {
    FileSystem(SyncImpl<ClientFileSystemStorage>),
    Database(SyncImpl<ClientDatabaseStorage>),
}

Client account storage.

Variants

FileSystem(SyncImpl<ClientFileSystemStorage>)

Filesystem storage.

Database(SyncImpl<ClientDatabaseStorage>)

Database storage.

Implementations

impl ClientStorage

pub async fn new_unauthenticated( target: BackendTarget, account_id: &AccountId, ) -> Result<Self, Error>

Create new client storage.

pub async fn new_account( target: BackendTarget, account_id: &AccountId, account_name: String, ) -> Result<Self, Error>

Create a new account in client storage.

The account must not already exist.

Only to be used when fetching account data from a remote during device enrollment.

pub async fn rebuild_folder_vault( target: BackendTarget, account_id: &AccountId, folder_id: &VaultId, ) -> Result<Vec<u8>, Error>

Rebuild the vault for a folder from event logs.

Can be used to repair a vault from a collection of event logs or to convert server-side head-only vaults into the client-side representation.

Authentication

Can be called when the account is not authenticated.

Trait Implementations

impl ClientAccountStorage for ClientStorage

fn import_account<'life0, 'life1, 'async_trait>( &'life0 mut self, account_data: &'life1 CreateSet, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Import an account from a change set of event logs.

fn list_secret_ids<'life0, 'life1, 'async_trait>( &'life0 self, folder_id: &'life1 VaultId, ) -> Pin<Box<dyn Future<Output = Result<Vec<SecretId>, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

List the secret ids for a folder.

fn create_device_vault<'life0, 'life1, 'async_trait>( &'life0 mut self, device_vault: &'life1 [u8], ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Create a device vault from a buffer.

fn delete_account<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Event, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Delete the account for this user.

fn rename_account<'life0, 'async_trait>( &'life0 mut self, account_name: String, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait,

Rename the account.

fn authenticate<'life0, 'async_trait>( &'life0 mut self, authenticated_user: Identity, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait,

Set the storage as authenticated.

fn change_password<'life0, 'life1, 'async_trait>( &'life0 mut self, vault: &'life1 Vault, current_key: AccessKey, new_key: AccessKey, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Change the password for a folder.

fn sign_out<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait,

Sign out the authenticated user.

fn unlock<'life0, 'life1, 'async_trait>( &'life0 mut self, keys: &'life1 FolderKeys, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Unlock all folders.

fn lock<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait,

Lock all folders.

fn unlock_folder<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, folder_id: &'life1 VaultId, key: &'life2 AccessKey, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Unlock a folder.

fn lock_folder<'life0, 'life1, 'async_trait>( &'life0 mut self, id: &'life1 VaultId, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Lock a folder.

fn create_account<'life0, 'life1, 'async_trait>( &'life0 mut self, account: &'life1 AccountPack, ) -> Pin<Box<dyn Future<Output = Result<Vec<Event>, Error>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Create the data for a new account.

fn create_folder<'life0, 'async_trait>( &'life0 mut self, options: NewFolderOptions, ) -> Pin<Box<dyn Future<Output = Result<(Vec<u8>, AccessKey, Summary, AccountEvent), Error>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait,

Create a new folder.

fn delete_folder<'life0, 'life1, 'async_trait>( &'life0 mut self, folder_id: &'life1 VaultId, apply_event: bool, ) -> Pin<Box<dyn Future<Output = Result<Vec<Event>, Error>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Delete a folder.

fn restore_folder<'life0, 'life1, 'async_trait>( &'life0 mut self, records: Vec<EventRecord>, key: &'life1 AccessKey, ) -> Pin<Box<dyn Future<Output = Result<Summary, Error>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Restore a folder from an event log.

fn import_folder<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, buffer: impl 'async_trait + AsRef<[u8]> + Send, key: Option<&'life1 AccessKey>, apply_event: bool, creation_time: Option<&'life2 UtcDateTime>, ) -> Pin<Box<dyn Future<Output = Result<(Event, Summary), Error>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Import a folder into an existing account.

fn history<'life0, 'life1, 'async_trait>( &'life0 self, folder_id: &'life1 VaultId, ) -> Pin<Box<dyn Future<Output = Result<Vec<(CommitHash, UtcDateTime, WriteEvent)>, Error>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get the history of events for a vault.

fn identity_state<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<CommitState, Error>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait,

Commit state of the identity folder.

fn commit_state<'life0, 'life1, 'async_trait>( &'life0 self, folder_id: &'life1 VaultId, ) -> Pin<Box<dyn Future<Output = Result<CommitState, Error>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get the commit state for a folder.

impl ClientBaseStorage for ClientStorage

fn account_id(&self) -> &AccountId

Account identifier.

fn authenticated_user(&self) -> Option<&Identity>

Authenticated user information.

fn authenticated_user_mut(&mut self) -> Option<&mut Identity>

Mutable authenticated user information.

fn paths(&self) -> Arc<Paths>

Computed storage paths.

fn backend_target(&self) -> &BackendTarget

Backend target.

fn is_authenticated(&self) -> bool

Determine if the storage is authenticated.

impl ClientDeviceStorage for ClientStorage

fn devices(&self) -> &IndexSet<TrustedDevice>

Collection of trusted devices.

fn list_trusted_devices(&self) -> Vec<&TrustedDevice>

List trusted devices.

fn patch_devices_unchecked<'life0, 'life1, 'async_trait>( &'life0 mut self, events: &'life1 [DeviceEvent], ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Patch the devices event log.

fn revoke_device<'life0, 'life1, 'async_trait>( &'life0 mut self, public_key: &'life1 DevicePublicKey, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Revoke trust in a device.

impl ClientFolderStorage for ClientStorage

fn folders(&self) -> &HashMap<VaultId, Folder>

In-memory folders.

fn folders_mut(&mut self) -> &mut HashMap<VaultId, Folder>

Mutable in-memory folders.

fn read_vault<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 VaultId, ) -> Pin<Box<dyn Future<Output = Result<Vault, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Read a vault from the storage.

fn read_login_vault<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vault, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Read the login vault from the storage.

fn current_folder(&self) -> Option<Summary>

Currently open folder.

fn open_folder(&self, folder_id: &VaultId) -> Result<ReadEvent, Error>

Mark a folder as the currently open folder.

fn close_folder(&self)

Close the current open folder.

fn read_device_vault<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Option<Vault>, Error>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait,

Read the device vault from the storage.

fn list_folders(&self) -> &[Summary]

List the in-memory folders.

fn find_folder(&self, vault: &FolderRef) -> Option<&Summary>

Find a folder in this storage by reference.

fn find<F>(&self, predicate: F) -> Option<&Summary>

where F: FnMut(&&Summary) -> bool,

Find a folder in this storage using a predicate.

fn update_vault<'life0, 'life1, 'async_trait>( &'life0 mut self, vault: &'life1 Vault, events: Vec<WriteEvent>, ) -> Pin<Box<dyn Future<Output = Result<Vec<u8>, Error>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Update an existing vault by replacing it with a new vault.

fn load_folders<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<&[Summary], Error>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait,

Read folders from storage and create the in-memory event logs for each folder.

fn remove_folder<'life0, 'life1, 'async_trait>( &'life0 mut self, folder_id: &'life1 VaultId, ) -> Pin<Box<dyn Future<Output = Result<bool, Error>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Remove a folder from memory.

fn import_folder_patches<'life0, 'async_trait>( &'life0 mut self, patches: HashMap<VaultId, FolderPatch>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait,

Create folders from a collection of folder patches.

fn compact_folder<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, folder_id: &'life1 VaultId, key: &'life2 AccessKey, ) -> Pin<Box<dyn Future<Output = Result<AccountEvent, Error>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Compact an event log file.

fn rename_folder<'life0, 'life1, 'async_trait>( &'life0 mut self, folder_id: &'life1 VaultId, name: impl 'async_trait + AsRef<str> + Send, ) -> Pin<Box<dyn Future<Output = Result<Event, Error>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Set the name of a folder.

fn update_folder_flags<'life0, 'life1, 'async_trait>( &'life0 mut self, folder_id: &'life1 VaultId, flags: VaultFlags, ) -> Pin<Box<dyn Future<Output = Result<Event, Error>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Update the flags for a folder.

fn description<'life0, 'life1, 'async_trait>( &'life0 self, folder_id: &'life1 VaultId, ) -> Pin<Box<dyn Future<Output = Result<String, Error>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get the description for a folder.

fn set_description<'life0, 'life1, 'async_trait>( &'life0 mut self, folder_id: &'life1 VaultId, description: impl 'async_trait + AsRef<str> + Send, ) -> Pin<Box<dyn Future<Output = Result<WriteEvent, Error>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Set the description of the currently open folder.

impl ForceMerge for ClientStorage

fn force_merge_folder<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, folder_id: &'life1 VaultId, diff: FolderDiff, outcome: &'life2 mut MergeOutcome, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Force merge changes to the files event log.

fn force_merge_identity<'life0, 'life1, 'async_trait>( &'life0 mut self, diff: FolderDiff, outcome: &'life1 mut MergeOutcome, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Force merge changes to the identity folder.

fn force_merge_update<'life0, 'life1, 'async_trait>( &'life0 mut self, update_set: UpdateSet, outcome: &'life1 mut MergeOutcome, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: Send + 'async_trait,

Force merge from a set of updates.

fn force_merge_account<'life0, 'life1, 'async_trait>( &'life0 mut self, diff: Diff<AccountEvent>, outcome: &'life1 mut MergeOutcome, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: Send + 'async_trait,

Force merge changes to the account event log.

fn force_merge_device<'life0, 'life1, 'async_trait>( &'life0 mut self, diff: Diff<DeviceEvent>, outcome: &'life1 mut MergeOutcome, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: Send + 'async_trait,

Force merge changes to the devices event log.

impl Merge for ClientStorage

fn merge_identity<'life0, 'life1, 'async_trait>( &'life0 mut self, diff: FolderDiff, outcome: &'life1 mut MergeOutcome, ) -> Pin<Box<dyn Future<Output = Result<CheckedPatch, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Merge changes to the identity folder.

fn merge_account<'life0, 'life1, 'async_trait>( &'life0 mut self, diff: AccountDiff, outcome: &'life1 mut MergeOutcome, ) -> Pin<Box<dyn Future<Output = Result<(CheckedPatch, HashSet<VaultId>), Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Merge changes to the account event log.

fn merge_device<'life0, 'life1, 'async_trait>( &'life0 mut self, diff: DeviceDiff, outcome: &'life1 mut MergeOutcome, ) -> Pin<Box<dyn Future<Output = Result<CheckedPatch, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Merge changes to the devices event log.

fn merge_folder<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, folder_id: &'life1 VaultId, diff: FolderDiff, outcome: &'life2 mut MergeOutcome, ) -> Pin<Box<dyn Future<Output = Result<(CheckedPatch, Vec<WriteEvent>), Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Merge changes to a folder.

fn compare_identity<'life0, 'life1, 'async_trait>( &'life0 self, state: &'life1 CommitState, ) -> Pin<Box<dyn Future<Output = Result<Comparison, Self::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: Sync + 'async_trait,

Compare the identity folder.

fn compare_account<'life0, 'life1, 'async_trait>( &'life0 self, state: &'life1 CommitState, ) -> Pin<Box<dyn Future<Output = Result<Comparison, Self::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: Sync + 'async_trait,

Compare the account events.

fn compare_device<'life0, 'life1, 'async_trait>( &'life0 self, state: &'life1 CommitState, ) -> Pin<Box<dyn Future<Output = Result<Comparison, Self::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: Sync + 'async_trait,

Compare the device events.

fn compare_folder<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, folder_id: &'life1 Uuid, state: &'life2 CommitState, ) -> Pin<Box<dyn Future<Output = Result<Comparison, Self::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Self: Sync + 'async_trait,

Compare folder events.

fn compare<'life0, 'life1, 'async_trait>( &'life0 mut self, remote_status: &'life1 SyncStatus, ) -> Pin<Box<dyn Future<Output = Result<SyncCompare, Self::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: Send + 'async_trait,

Compare the local state to a remote status.

fn merge<'life0, 'life1, 'async_trait>( &'life0 mut self, diff: SyncDiff, outcome: &'life1 mut MergeOutcome, ) -> Pin<Box<dyn Future<Output = Result<SyncCompare, Self::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: Send + 'async_trait,

Merge a diff into this storage.

impl StorageEventLogs for ClientStorage

type Error = Error

Error type for storage event logs.

fn identity_log<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Arc<RwLock<FolderEventLog>>, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Clone of the identity log.

fn account_log<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Arc<RwLock<AccountEventLog>>, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Clone of the account log.

fn device_log<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Arc<RwLock<DeviceEventLog>>, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Clone of the device log.

fn folder_details<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<IndexSet<Summary>, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Folders managed by this storage.

fn folder_log<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 VaultId, ) -> Pin<Box<dyn Future<Output = Result<Arc<RwLock<FolderEventLog>>, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Folder event log.

impl SyncStorage for ClientStorage

fn is_client_storage(&self) -> bool

Determine if this is client-side storage.

fn sync_status<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<SyncStatus, Self::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Sync status for the storage.

fn create_set<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<CreateSet, Self::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Set of all event logs.

fn debug_account_tree<'life0, 'async_trait>( &'life0 self, account_id: AccountId, ) -> Pin<Box<dyn Future<Output = Result<DebugTree, Self::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Create a debug tree of this account.