Struct Generic 

pub struct Generic<R: Repo, T> { /* private fields */ }

A commitlog generic over the storage backend as well as the type of records its Commits contain.

Implementations

impl<R: Repo, T> Generic<R, T>

pub fn open(repo: R, opts: Options) -> Result<Self>

pub fn epoch(&self) -> u64

Get the current epoch.

See also: Commit::epoch.

pub fn set_epoch(&mut self, epoch: u64) -> Result<Option<Committed>>

Update the current epoch.

Calls Self::commit to flush all data of the previous epoch, and returns the result.

Does nothing if the given epoch is equal to the current epoch.

Errors

If epoch is smaller than the current epoch, an error of kind io::ErrorKind::InvalidInput is returned.

Also see Self::commit.

pub fn commit(&mut self) -> Result<Option<Committed>>

Write the currently buffered data to storage and rotate segments as necessary.

Note that this does not imply that the data is durable, in particular when a filesystem storage backend is used. Call Self::sync to flush any OS buffers to stable storage.

Errors

If an error occurs writing the data, the current Commit buffer is retained, but a new segment is created. Retrying in case of an Err return value thus will write the current data to that new segment.

If this fails, however, the next attempt to create a new segment will fail with io::ErrorKind::AlreadyExists. Encountering this error kind this means that something is seriously wrong underlying storage, and the caller should stop writing to the log.

pub fn sync(&mut self)

Force the currently active segment to be flushed to storage.

Using a filesystem backend, this means to call fsync(2).

Panics

As an fsync failure leaves a file in a more of less undefined state, this method panics in this case, thereby preventing any further writes to the log and forcing the user to re-read the state from disk.

pub fn max_committed_offset(&self) -> Option<u64>

The last transaction offset written to disk, or None if nothing has been written yet.

Note that this does not imply durability: Self::sync may not have been called at this offset.

pub fn min_committed_offset(&self) -> Option<u64>

The first transaction offset written to disk, or None if nothing has been written yet.

pub fn commits_from(&self, offset: u64) -> Commits<R>

pub fn reset(self) -> Result<Self>

pub fn reset_to(self, offset: u64) -> Result<Self>

impl<R: Repo, T: Encode> Generic<R, T>

pub fn append(&mut self, record: T) -> Result<(), T>

pub fn transactions_from<'a, D>( &self, offset: u64, decoder: &'a D, ) -> impl Iterator<Item = Result<Transaction<T>, D::Error>> + 'a

where D: Decoder<Record = T>, D::Error: From<Traversal>, R: 'a, T: 'a,

pub fn fold_transactions_from<D>( &self, offset: u64, decoder: D, ) -> Result<(), D::Error>

where D: Decoder, D::Error: From<Traversal>,

Trait Implementations

impl<R: Debug + Repo, T: Debug> Debug for Generic<R, T>

where R::SegmentWriter: Debug,

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

Formats the value using the given formatter.

impl<R: Repo, T> Drop for Generic<R, T>

fn drop(&mut self)

Executes the destructor for this type.