Struct persist::file::FileLog

pub struct FileLog {
    base_dir: Option<PathBuf>,
    dataz: Arc<Mutex<FileLogCore>>,
    seqno: Range<SeqNo>,
    buf: Vec<u8>,
}

A naive implementation of Log backed by files.

Fields

base_dir: Option<PathBuf>

dataz: Arc<Mutex<FileLogCore>>

seqno: Range<SeqNo>

buf: Vec<u8>

Implementations

impl FileLog

const DATA_PATH: &'static str

const LOCKFILE_PATH: &'static str

const METADATA_PATH: &'static str

pub fn new<P: AsRef<Path>>(
    base_dir: P,
    lock_info: LockInfo
) -> Result<Self, Error>

Returns a new FileLog which stores files under the given dir.

To ensure directory-wide mutual exclusion, a LOCK file is placed in base_dir at construction time. If this file already exists (indicating that another FileLog is already using the dir), an error is returned from new.

The contents of lock_info are stored in the LOCK file and should include anything that would help debug an unexpected LOCK file, such as version, ip, worker number, etc.

The data is stored in a separate file, and is formatted as a sequential list of chunks corresponding to each write. Each chunk consists of: length - A 64 bit unsigned int (little-endian) indicating the size of data. data - length bytes of data. sequence_number - A 64 bit unsigned int (little-endian) indicating the sequence number assigned to data.

Additionally, the metadata about the last truncated sequence number is stored in a metadata file, which only ever contains a single 64 bit unsigned integer (also little-endian) that indicates the most recently truncated offset (ie all offsets less than this are truncated).

fn lockfile_path(base_dir: &Path) -> PathBuf

fn data_path(base_dir: &Path) -> PathBuf

fn metadata_path(base_dir: &Path) -> PathBuf

fn ensure_open(&self) -> Result<PathBuf, Error>

Trait Implementations

impl Debug for FileLog

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

Formats the value using the given formatter.

impl Log for FileLog

fn truncate(&mut self, upper: SeqNo) -> Result<(), Error>

Logically truncates the log so that future reads ignore writes at sequence numbers less than upper.

TODO: actually reclaim disk space as part of truncating.

fn write_sync(&mut self, buf: Vec<u8>) -> Result<SeqNo, Error>

Synchronously appends an entry.

fn snapshot<F>(&self, logic: F) -> Result<Range<SeqNo>, Error> where
    F: FnMut(SeqNo, &[u8]) -> Result<(), Error>, 

Returns a consistent snapshot of all written but not yet truncated entries.

fn close(&mut self) -> Result<bool, Error>

Synchronously closes the log, releasing exclusive-writer locks and causing all future commands to error.