Struct BufferedRaftLog 

pub struct BufferedRaftLog<T>
where
    T: TypeConfig,
{ /* private fields */ }

High-performance buffered Raft log with event-driven architecture

This implementation provides in-memory first access with configurable persistence strategies while ensuring thread safety and avoiding deadlocks.

Key design principles:

• Lock-free reads for 99% of operations
• Event-driven asynchronous processing
• Deadlock prevention through proper error handling
• Memory-efficient batch operations

Implementations

impl<T> BufferedRaftLog<T>

where T: TypeConfig,

pub fn new( node_id: u32, persistence_config: PersistenceConfig, storage: Arc<<T as TypeConfig>::SE>, ) -> (BufferedRaftLog<T>, UnboundedReceiver<IOTask>)

pub fn start( self, receiver: UnboundedReceiver<IOTask>, log_flush_tx: Option<UnboundedSender<RoleEvent>>, ) -> Arc<BufferedRaftLog<T>>

Start the command processor and return an Arc-wrapped instance.

batch_processor runs on a dedicated OS thread (not a tokio worker) so that synchronous RocksDB calls (db.write, flush_wal) never block the async runtime. The thread owns its own new_current_thread runtime — fully independent of the caller’s runtime lifecycle. When the caller’s runtime drops (e.g. at test teardown), the IO thread’s timers and channels are unaffected; it exits cleanly on Shutdown.

pub fn remove_range(&self, range: RangeInclusive<u64>)

Efficient range removal with targeted term index updates O(k + t) where k = number of entries removed, t = number of affected terms

Trait Implementations

impl<T> Debug for BufferedRaftLog<T>

where T: TypeConfig,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<T> Drop for BufferedRaftLog<T>

where T: TypeConfig,

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<T> RaftLog for BufferedRaftLog<T>

where T: TypeConfig,

fn entry(&self, index: u64) -> Result<Option<Entry>, Error>

TODO: not considered the order of configured storage rule also should we remove Result<>?

fn first_entry_id(&self) -> u64

Returns the smallest log index (inclusive).

fn last_entry_id(&self) -> u64

Returns the largest log index (inclusive).

fn durable_index(&self) -> u64

Returns the highest log index confirmed crash-safe on this node.

fn last_entry(&self) -> Option<Entry>

Returns the last log entry.

fn last_log_id(&self) -> Option<LogId>

Returns the LogId (term + index) of the last entry.

fn is_empty(&self) -> bool

Checks if log is empty.

fn entry_term(&self, entry_id: u64) -> Option<u64>

Returns the term of a specific entry.

fn first_index_for_term(&self, term: u64) -> Option<u64>

Finds the first index belonging to a specific term.

fn last_index_for_term(&self, term: u64) -> Option<u64>

Finds the last index belonging to a specific term.

fn pre_allocate_raft_logs_next_index(&self) -> u64

Pre-allocates the next log index atomically.

fn pre_allocate_id_range(&self, count: u64) -> RangeInclusive<u64>

Pre-allocates a contiguous range of log indices atomically.

fn get_entries_range( &self, range: RangeInclusive<u64>, ) -> Result<Vec<Entry>, Error>

Retrieves a contiguous range of log entries.

fn append_entries<'life0, 'async_trait>( &'life0 self, entries: Vec<Entry>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, BufferedRaftLog<T>: 'async_trait,

Appends new entries to the log.

fn insert_batch<'life0, 'async_trait>( &'life0 self, logs: Vec<Entry>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, BufferedRaftLog<T>: 'async_trait,

Alias for append_entries (for backward compatibility).

fn filter_out_conflicts_and_append<'life0, 'async_trait>( &'life0 self, prev_log_index: u64, prev_log_term: u64, new_entries: Vec<Entry>, ) -> Pin<Box<dyn Future<Output = Result<Option<LogId>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, BufferedRaftLog<T>: 'async_trait,

Resolves log conflicts and appends new entries atomically.

fn calculate_majority_matched_index( &self, current_term: u64, commit_index: u64, peer_matched_ids: Vec<u64>, ) -> Option<u64>

Calculates the majority-matched index for commit advancement.

fn purge_logs_up_to<'life0, 'async_trait>( &'life0 self, cutoff_index: LogId, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, BufferedRaftLog<T>: 'async_trait,

Purges committed log entries up to cutoff_index (log compaction).

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

where 'life0: 'async_trait, BufferedRaftLog<T>: 'async_trait,

Forces all pending writes to durable storage.

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

where 'life0: 'async_trait, BufferedRaftLog<T>: 'async_trait,

Resets the entire log storage (destructive operation).

fn load_hard_state(&self) -> Result<Option<HardState>, Error>

Loads persistent state (currentTerm, votedFor).

fn save_hard_state(&self, hard_state: &HardState) -> Result<(), Error>

Saves persistent state (currentTerm, votedFor).

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

where 'life0: 'async_trait, BufferedRaftLog<T>: 'async_trait,

Gracefully closes the log, ensuring all pending IO completes and any background IO threads have exited before returning.

fn wait_durable<'life0, 'async_trait>( &'life0 self, index: u64, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

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

Waits for a specific log index to become durable.