Enum AppendFsync 

#[non_exhaustive]
pub enum AppendFsync {
    Always,
    EverySec,
    No,
}

When to fsync the AOF to disk. The three values of Redis’s appendfsync.

use kevy_persist::Fsync;

assert_eq!(Fsync::parse("EverySec"), Some(Fsync::EverySec));
assert_eq!(Fsync::Always.as_str(), "always");
assert_eq!(Fsync::default(), Fsync::EverySec);

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.

Always

fsync after every write — safest, slowest.

use kevy_persist::{Aof, Argv, Fsync};

let path = std::env::temp_dir().join(format!("fsync-always-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()]))?;
// on disk before append returned: no tick, no drop needed
assert_eq!(std::fs::metadata(&path)?.len(), aof.size_bytes());

EverySec

fsync about once per second; each crate::Aof::tick (or crate::Aof::maybe_sync) writes the buffer into the kernel. A power loss loses about one second plus the time one fsync takes. The default.

use kevy_persist::{Aof, Fsync};

let path = std::env::temp_dir().join(format!("fsync-everysec-doc-{}.aof", std::process::id()));
let aof = Aof::open(&path, Fsync::default())?;
assert_eq!(aof.fsync_policy(), Fsync::EverySec);
assert_eq!(Fsync::EverySec.as_str(), "everysec");

No

Never fsync explicitly: each crate::Aof::tick writes the buffer into the kernel, and the OS decides when it reaches the disk.

use kevy_persist::{Aof, Fsync};

let path = std::env::temp_dir().join(format!("fsync-no-doc-{}.aof", std::process::id()));
let mut aof = Aof::open(&path, Fsync::Always)?;
aof.set_fsync(Fsync::parse("no").unwrap_or_default())?; // CONFIG SET appendfsync no
assert_eq!(aof.fsync_policy(), Fsync::No);

Implementations

impl Fsync

pub fn as_str(&self) -> &'static str

The Redis spelling (always / everysec / no), as CONFIG GET appendfsync reports it.

assert_eq!(kevy_persist::Fsync::No.as_str(), "no");

pub fn parse(s: &str) -> Option<Fsync>

The inverse of Self::as_str, ignoring ASCII case. None for any other input.

assert_eq!(kevy_persist::Fsync::parse("ALWAYS"), Some(kevy_persist::Fsync::Always));
assert_eq!(kevy_persist::Fsync::parse("sometimes"), None);

Trait Implementations

impl Clone for Fsync

fn clone(&self) -> Fsync

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Fsync

impl Debug for Fsync

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

Formats the value using the given formatter.

impl Default for Fsync

fn default() -> Fsync

Returns the “default value” for a type.

impl Eq for Fsync

impl Hash for Fsync

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 Fsync

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Fsync