Struct ate::redo::RedoLog

pub struct RedoLog { /* private fields */ }

Implementations

impl RedoLog

pub async fn rotate(&mut self, header_bytes: Vec<u8>) -> Result<()>

pub fn backup(
    &mut self,
    include_active_files: bool
) -> Result<Pin<Box<dyn Future<Output = Result<()>> + Send + Sync>>>

pub async fn begin_flip(
    &mut self,
    header_bytes: Vec<u8>
) -> Result<FlippedLogFile>

pub async fn finish_flip(
    &mut self,
    flip: FlippedLogFile,
    deferred_write_callback: impl FnMut(LogLookup, EventHeader)
) -> Result<Vec<EventHeaderRaw>, SerializationError>

pub async fn load(&self, hash: AteHash) -> Result<LoadData, LoadError>

pub fn prime(&mut self, records: Vec<(AteHash, Option<Bytes>)>)

pub fn count(&self) -> usize

pub fn size(&self) -> u64

pub fn offset(&self) -> u64

pub fn end(&self) -> LogLookup

pub async fn open(
    cfg: &ConfAte,
    key: &ChainKey,
    flags: OpenFlags,
    header_bytes: Vec<u8>
) -> Result<(RedoLog, VecDeque<LoadData>), SerializationError>

pub async fn open_ext(
    cfg: &ConfAte,
    key: &ChainKey,
    flags: OpenFlags,
    loader: Box<impl Loader>,
    header_bytes: Vec<u8>
) -> Result<RedoLog, SerializationError>

pub fn destroy(&mut self) -> Result<()>

pub fn header(&self, index: u32) -> Vec<u8>

Trait Implementations

impl LogWritable for RedoLog

fn write<'life0, 'life1, 'async_trait>(
    &'life0 mut self,
    evt: &'life1 EventWeakData
) -> Pin<Box<dyn Future<Output = Result<LogLookup, SerializationError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Writes data to the redo log and returns the new offset in bytes

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