Enum BackendEventLog 

pub enum BackendEventLog<T>
where
    T: Default + Encodable + Decodable + Send + Sync,
{
    Database(DatabaseEventLog<T, Error>),
    FileSystem(FileSystemEventLog<T, Error>),
}

Generic event log.

Variants

Database(DatabaseEventLog<T, Error>)

Database event log.

FileSystem(FileSystemEventLog<T, Error>)

File system event log.

Implementations

impl BackendEventLog<AccountEvent>

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

Create a new account event log.

impl BackendEventLog<WriteEvent>

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

Create a new folder event log.

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

Create a new login event log.

impl BackendEventLog<DeviceEvent>

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

Create a new device event log.

impl BackendEventLog<FileEvent>

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

Available on crate feature files only.

Create a new file event log.

Trait Implementations

impl<T> EventLog<T> for BackendEventLog<T>

where T: Default + Encodable + Decodable + Send + Sync + 'static,

type Error = Error

Error type.

fn record_stream<'life0, 'async_trait>( &'life0 self, reverse: bool, ) -> Pin<Box<dyn Future<Output = BoxStream<'async_trait, Result<EventRecord, Self::Error>>> + Send + 'async_trait>>

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

Stream of event records.

fn event_stream<'life0, 'async_trait>( &'life0 self, reverse: bool, ) -> Pin<Box<dyn Future<Output = BoxStream<'async_trait, Result<(EventRecord, T), Self::Error>>> + Send + 'async_trait>>

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

Stream of event records and decoded events.

fn diff_checked<'life0, 'async_trait>( &'life0 self, commit: Option<CommitHash>, checkpoint: CommitProof, ) -> Pin<Box<dyn Future<Output = Result<Diff<T>, Self::Error>> + Send + 'async_trait>>

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

Create a checked diff from a commit.

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

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

Create an unchecked diff of all events.

fn diff_events<'life0, 'life1, 'async_trait>( &'life0 self, commit: Option<&'life1 CommitHash>, ) -> Pin<Box<dyn Future<Output = Result<Patch<T>, Self::Error>> + Send + 'async_trait>>

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

Diff of events until a specific commit; does not include the target commit.

fn tree(&self) -> &CommitTree

Commit tree contains the in-memory merkle tree.

fn rewind<'life0, 'life1, 'async_trait>( &'life0 mut self, commit: &'life1 CommitHash, ) -> Pin<Box<dyn Future<Output = Result<Vec<EventRecord>, Self::Error>> + Send + 'async_trait>>

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

Rewind this event log discarding commits after the specific commit.

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

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

Load data from storage to build a commit tree in memory.

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

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

Delete all events from the log file on disc and in-memory.

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

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

Append a collection of events and commit the tree hashes only if all the events were successfully written.

fn apply_records<'life0, 'async_trait>( &'life0 mut self, records: Vec<EventRecord>, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

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

Append raw event records to the event log.

fn patch_checked<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, commit_proof: &'life1 CommitProof, patch: &'life2 Patch<T>, ) -> Pin<Box<dyn Future<Output = Result<CheckedPatch, Self::Error>> + Send + 'async_trait>>

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

Append a patch to this event log only if the head of the tree matches the given proof.

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

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

Replace all events in this event log with the events in the diff.

fn patch_unchecked<'life0, 'life1, 'async_trait>( &'life0 mut self, patch: &'life1 Patch<T>, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

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

Append a patch to this event log.

fn diff_records<'life0, 'life1, 'async_trait>( &'life0 self, commit: Option<&'life1 CommitHash>, ) -> Pin<Box<dyn Future<Output = Result<Vec<EventRecord>, Self::Error>> + Send + 'async_trait>>

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

Diff of event records until a specific commit.

fn version(&self) -> u16

Encoding version.