Struct VersionedLog 

pub struct VersionedLog { /* private fields */ }

A transaction log split into per-lease-version files for HA append isolation (see docs/design/log-and-transactor.md).

The active writer under lease version V appends only to {name}.v{V}.log (the pre-HA {name}.log reads as version 0). Readers merge the files in version order and drop any record in an older file whose t is at or past the first record of a later file: such records were appended by a deposed writer after a takeover and were never acknowledged, because acknowledgement re-verifies lease ownership after the durable append. A deposed writer therefore cannot corrupt or fork the log — its stale appends land in a file nobody considers current.

Implementations

impl VersionedLog

pub fn open( dir: impl AsRef<Path>, name: &str, write_version: u64, ) -> Result<Self, LogError>

Opens the log for writing under write_version, creating the version file if needed and dropping any torn tail it carries. Files of other versions are never modified.

Errors

Returns an error if files cannot be read/created or a fully written record is corrupt.

pub fn open_sealed( dir: impl AsRef<Path>, name: &str, write_version: u64, cipher: Arc<LogCipher>, ) -> Result<Self, LogError>

Opens the log for writing with record payloads sealed under cipher.

Every version file is read through the same cipher, and each frame is authenticated against the version of the file holding it.

Errors

Returns an error if files cannot be read/created, a fully written record is corrupt, or a record cannot be authenticated.

pub fn open_read_only( dir: impl AsRef<Path>, name: &str, ) -> Result<Self, LogError>

Opens the log read-only (independent inspection or backup); appends fail.

Errors

Returns an error when the directory cannot be read or a fully written record is corrupt.

pub fn open_read_only_sealed( dir: impl AsRef<Path>, name: &str, cipher: Arc<LogCipher>, ) -> Result<Self, LogError>

Opens the log read-only, opening sealed record payloads with cipher.

Errors

Returns an error when the directory cannot be read, a fully written record is corrupt, or a record cannot be authenticated.

pub fn exists(dir: impl AsRef<Path>, name: &str) -> bool

Reports whether any log file exists for this database.

pub fn delete_all(dir: impl AsRef<Path>, name: &str) -> Result<(), LogError>

Deletes every version file for this database.

Errors

Returns an error when a file cannot be removed.

Trait Implementations

impl TransactionLog for VersionedLog

fn append(&self, record: &TxRecord) -> Result<(), LogError>

Durably appends exactly the next transaction.

fn tx_range( &self, start: u64, end: Option<u64>, ) -> Result<Vec<TxRecord>, LogError>

Returns records in the half-open transaction range [start, end).

fn append_async<'life0, 'life1, 'async_trait>( &'life0 self, record: &'life1 TxRecord, ) -> Pin<Box<dyn Future<Output = Result<(), LogError>> + Send + 'async_trait>>

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

Durably appends exactly the next transaction without blocking an async runtime worker. Synchronous logs use Self::append by default; storage-backed logs override this method and await their backend.

fn append_batch_async<'life0, 'life1, 'async_trait>( &'life0 self, records: &'life1 [TxRecord], ) -> Pin<Box<dyn Future<Output = Result<(), LogError>> + Send + 'async_trait>>

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

Durably appends a contiguous run of transactions under a single durability boundary where the backend supports one (one fsync, one object, one database transaction), so group commit amortizes the per-append cost across the batch. records must be contiguous in t starting at the log’s next expected t; an empty slice is a no-op. The default appends them one at a time; batching backends override this.

fn tx_range_async<'life0, 'async_trait>( &'life0 self, start: u64, end: Option<u64>, ) -> Pin<Box<dyn Future<Output = Result<Vec<TxRecord>, LogError>> + Send + 'async_trait>>

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

Asynchronous form of Self::tx_range.

fn replay(&self) -> Result<Vec<TxRecord>, LogError>

Replays every committed record.

fn replay_async<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<TxRecord>, LogError>> + Send + 'async_trait>>

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

Asynchronously replays every committed record.