Struct KraftLog 

pub struct KraftLog { /* private fields */ }

Implementations

impl KraftLog

pub fn open( dir: impl AsRef<Path>, config: &MetadataLogConfig, ) -> Result<Self, RaftError>

Opens or creates the metadata log in dir, the metadata partition directory __cluster_metadata-0. The segments roll as config says.

Errors

Returns RaftError if the log directory cannot be created or the underlying krabka_log::Log fails to open, and RaftError::PersistedFormat if the high-watermark file has a version this build does not read or has no version marker.

pub fn failure(&self) -> Option<&str>

The first I/O error a write to the metadata log directory returned, or None while every write has succeeded.

pub fn log_start_offset(&self) -> Offset

pub fn log_end_offset(&self) -> Offset

pub fn hwm(&self) -> Offset

pub fn size(&self) -> ByteSize

The size of every segment’s .log file together, Kafka’s UnifiedLog.size, which the metadata log’s size retention weighs.

pub fn append( &mut self, batch: &mut RecordBatch, append_timestamp_ms: i64, ) -> Result<Offset, RaftError>

Leader path: appends a batch stamped with append_timestamp_ms. krabka-log assigns the offset and records the batch’s partition_leader_epoch. Returns the assigned base offset.

The stamp is the batch’s create-time, as Kafka’s BatchAccumulator stamps every batch the raft client appends with the current time. It is what Self::last_committed_timestamp_ms reads back for a snapshot header, and what a follower replicates verbatim through Self::append_at.

Errors

Returns RaftError if the underlying append fails.

pub fn append_at( &mut self, batch: &mut RecordBatch, offset: Offset, ) -> Result<(), RaftError>

Follower path: appends a batch at the leader-assigned offset.

Errors

Returns RaftError if the underlying append fails, for example when offset does not equal the current log end offset.

pub fn read_decoded( &self, offset: Offset, max_size: ByteSize, ) -> Result<Vec<RecordBatch>, RaftError>

Decoded read from offset. The tests and the replication apply path use it.

Errors

Returns RaftError if the underlying read fails.

pub fn timestamp_below(&self, end_offset: Offset) -> Option<i64>

The append timestamp of the last record below end_offset: the max_timestamp of the batch that contains end_offset - 1.

KIP-630 stamps this into SnapshotHeaderRecord’s last_contained_log_timestamp, where Kafka supplies the append time of the last batch the snapshot contains. None when no such record is readable here: the boundary is at or below the log start, because everything under it was pruned or arrived inside an installed snapshot, or it is beyond the log end.

pub fn last_committed_timestamp_ms(&self) -> Option<i64>

The append timestamp of the last committed record (hwm - 1), for the header of a snapshot taken at the high watermark.

pub fn read_committed( &self, offset: Offset, max_size: ByteSize, ) -> Result<RawRead, RaftError>

Serves KIP-595 Fetch: verbatim batch bytes in [offset, min(hwm, log_end)).

Errors

Returns RaftError if the underlying raw read fails.

pub fn advance_hwm(&mut self, new_hwm: Offset)

Advances the high watermark. The move is monotonic, and it never goes past the log end.

pub fn truncate_to(&mut self, offset: Offset) -> Result<(), RaftError>

Truncates the log so that no record at offset >= offset remains, and clamps the HWM down.

Errors

Returns RaftError if the underlying truncation fails.

pub fn prune_to(&mut self, end_offset: Offset) -> Result<(), RaftError>

Prunes the committed prefix below end_offset: it advances the log-start pointer and trims the now-dead segments. This is a no-op when end_offset is at or below the current log start. The leader calls it after it writes a snapshot.

Errors

Returns RaftError if the underlying log operations fail.

pub fn reap_retired_files(&mut self, now: SystemTime) -> Result<(), RaftError>

Deletes the files of every segment that Self::prune_to or Self::install_snapshot retired at least file.delete.delay.ms before now.

A retired segment is renamed to .deleted and stays readable for that delay, Kafka’s 60-second default, as in Kafka’s KafkaRaftLog. Kafka’s scheduler then deletes it. Without this call nothing would: the broker’s retention sweep reaps the partitions it owns, and the metadata log is not one of them, so every cleaning would leave its segments on disk until the node restarted.

The unlinks run on a thread of their own, as the partition writer hands its due deletions to a background task: a metadata segment can be a GiB, and unlinking it on the engine would stall fetches, heartbeats and every controller command behind it. One deletion runs at a time. Each call first collects the one before it, and a failed one hands its remaining files back to the log, which retries them on a later call.

Errors

Returns RaftError if the earlier deletion failed, or if the flush that Log::maintain_deferring_deletions runs first fails. It also returns one if the deletion thread panicked.

pub fn install_snapshot(&mut self, end_offset: Offset) -> Result<(), RaftError>

Replaces the log with an empty log that starts at end_offset, which drops every segment, and sets the high watermark to end_offset. A follower calls it when it installs a fetched snapshot whose end_offset is ahead of its own log.

Errors

Returns RaftError if the underlying reset fails.

Trait Implementations

impl LogView for KraftLog

fn end_offset(&self) -> i64

The log end offset: one offset after the last appended record.

fn last_epoch(&self) -> Epoch

Leader epoch of the last appended record. An empty log gives 0.

fn end_offset_for_epoch(&self, epoch: Epoch) -> LogOffsetMetadata

Kafka’s RaftLog.endOffsetForEpoch: the largest epoch <= epoch that this log holds, and the offset where that epoch ends.