Enum ReplayMode 

#[non_exhaustive]
pub enum ReplayMode {
    Strict,
    Resync,
}

What a replay (and the open that follows it) does at a corrupt record in the middle of a log.

use kevy_persist::ReplayMode;

assert_eq!(ReplayMode::default(), ReplayMode::Strict);

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Strict

Stop at the first corrupt record; the open quarantines and truncates everything from there.

use kevy_persist::{Aof, Argv, Fsync, ReplayMode, ReplaySummary, replay_aof_in_place};

let path = std::env::temp_dir().join(format!("mode-strict-doc-{}.aof", std::process::id()));
let mut aof = Aof::open(&path, Fsync::Always)?;
aof.append(&Argv::from(vec![b"SET".to_vec(), b"k".to_vec(), b"v".to_vec()]))?;
drop(aof);
let mut bytes = std::fs::read(&path)?;
*bytes.last_mut().unwrap() ^= 1; // flip a payload bit
std::fs::write(&path, &bytes)?;
let report = replay_aof_in_place(&path, ReplayMode::Strict, ReplaySummary::Quiet, |_| {})?;
assert!(report.corrupt);
assert_eq!(report.commands, 0);

Resync

Hop over a corrupt region to the next record whose checksum holds and keep replaying; the open leaves interior corrupt regions in place and quarantines only the bytes after the last recoverable record. v1 logs have no checksums to anchor on and replay strictly.

use kevy_persist::{Aof, Argv, Fsync, ReplayMode, ReplaySummary, replay_aof_in_place};

let path = std::env::temp_dir().join(format!("mode-resync-doc-{}.aof", std::process::id()));
let mut aof = Aof::open(&path, Fsync::Always)?;
for key in [b"a", b"b"] {
    aof.append(&Argv::from(vec![b"SET".to_vec(), key.to_vec(), b"v".to_vec()]))?;
}
drop(aof);
let mut bytes = std::fs::read(&path)?;
bytes[kevy_persist::AOF2_MAGIC.len() + 12] ^= 1; // damage the first record only
std::fs::write(&path, &bytes)?;
let report = replay_aof_in_place(&path, ReplayMode::Resync, ReplaySummary::Quiet, |_| {})?;
assert!(report.corrupt);
assert_eq!(report.commands, 1, "the record behind the damage still replays");

Trait Implementations

impl Clone for ReplayMode

fn clone(&self) -> ReplayMode

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for ReplayMode

impl Debug for ReplayMode

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

Formats the value using the given formatter.

impl Default for ReplayMode

fn default() -> ReplayMode

Returns the “default value” for a type.

impl Eq for ReplayMode

impl Hash for ReplayMode

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ReplayMode

fn eq(&self, other: &ReplayMode) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for ReplayMode