Struct FileLog 

pub struct FileLog { /* private fields */ }

Filesystem append log. Each append is flushed and fsynced before returning.

The file descriptor remains open for the lifetime of the log. An in-memory (t, byte offset, frame length) index is built during recovery, extended on append, and used to read only the frames selected by a range scan.

A crash mid-append leaves a torn, never-acked record at the tail; open truncates it away so replay stops at the durability point of the last acked transaction and later appends extend a clean tail.

Implementations

impl FileLog

pub fn open(path: impl AsRef<Path>) -> Result<Self, LogError>

Opens or creates a log file, dropping any torn tail left by a crash.

Errors

Returns an error if the file cannot be created or a fully written record is corrupt.

pub fn open_sealed( path: impl AsRef<Path>, cipher: Arc<LogCipher>, ) -> Result<Self, LogError>

Opens or creates a log whose record payloads are sealed under cipher.

A single-file log has no lease versions, so its records bind lease version 0 — the same number VersionedLog gives a pre-HA {name}.log.

Errors

Returns an error if the file cannot be created, a fully written record is corrupt, or a record cannot be authenticated.

Trait Implementations

impl TransactionLog for FileLog

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.