#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum Policy {
#[default]
Precious,
Evictable { max_bytes: u64 },
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum OnCorrupt {
#[default]
Fail,
Skip,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum Commit {
#[default]
Immediate,
Deferred {
after: usize,
},
}
pub use crate::backend::api::Durability;
#[derive(Debug, Clone)]
pub struct LockerConfig {
pub max_inline: usize,
pub eager_budget: u64,
pub policy: Policy,
pub commit: Commit,
pub durability: Durability,
pub on_corrupt: OnCorrupt,
pub chunk_size: usize,
pub chain: Option<std::sync::Arc<crate::codec::FilterChain>>,
}
impl PartialEq for LockerConfig {
fn eq(&self, other: &Self) -> bool {
self.max_inline == other.max_inline
&& self.eager_budget == other.eager_budget
&& self.policy == other.policy
&& self.commit == other.commit
&& self.durability == other.durability
&& self.on_corrupt == other.on_corrupt
&& self.chunk_size == other.chunk_size
&& self.chain_id() == other.chain_id()
}
}
impl Eq for LockerConfig {}
impl Default for LockerConfig {
fn default() -> Self {
Self {
max_inline: 256 * 1024,
eager_budget: 32 * 1024 * 1024,
policy: Policy::Precious,
commit: Commit::Immediate,
durability: Durability::Immediate,
on_corrupt: OnCorrupt::Fail,
chunk_size: 256 * 1024,
chain: None,
}
}
}
impl LockerConfig {
pub fn with_max_inline(mut self, bytes: usize) -> Self {
self.max_inline = bytes;
self
}
pub fn with_eager_budget(mut self, bytes: u64) -> Self {
self.eager_budget = bytes;
self
}
pub fn with_policy(mut self, policy: Policy) -> Self {
self.policy = policy;
self
}
pub fn with_commit(mut self, commit: Commit) -> Self {
self.commit = commit;
self
}
pub fn with_durability(mut self, durability: Durability) -> Self {
self.durability = durability;
self
}
pub(crate) fn is_eventual(&self) -> bool {
matches!(self.durability, Durability::Eventual)
}
pub fn with_on_corrupt(mut self, on_corrupt: OnCorrupt) -> Self {
self.on_corrupt = on_corrupt;
self
}
pub fn with_chunk_size(mut self, bytes: usize) -> Self {
self.chunk_size = bytes.max(1);
self
}
pub fn with_chain(mut self, chain: std::sync::Arc<crate::codec::FilterChain>) -> Self {
self.chain = Some(chain);
self
}
pub(crate) fn chain_id(&self) -> Option<u8> {
self.chain.as_ref().map(|c| c.id())
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn defaults_are_conservative() {
let c = LockerConfig::default();
assert_eq!(c.max_inline, 256 * 1024);
assert_eq!(c.eager_budget, 32 * 1024 * 1024);
assert_eq!(c.policy, Policy::Precious);
assert_eq!(c.chunk_size, 256 * 1024);
assert_eq!(c.commit, Commit::Immediate);
assert_eq!(c.durability, Durability::Immediate);
}
#[test]
fn durability_is_immediate_unless_asked_otherwise() {
assert_eq!(Durability::default(), Durability::Immediate);
assert!(!LockerConfig::default().is_eventual());
let c = LockerConfig::default().with_durability(Durability::Eventual);
assert_eq!(c.durability, Durability::Eventual);
assert!(c.is_eventual());
}
#[test]
fn writes_are_immediate_unless_asked_otherwise() {
assert_eq!(Commit::default(), Commit::Immediate);
let c = LockerConfig::default().with_commit(Commit::Deferred { after: 8 });
assert_eq!(c.commit, Commit::Deferred { after: 8 });
}
#[test]
fn failing_on_corruption_is_the_default() {
assert_eq!(OnCorrupt::default(), OnCorrupt::Fail);
assert_eq!(LockerConfig::default().on_corrupt, OnCorrupt::Fail);
}
#[test]
fn precious_is_the_default_policy() {
assert_eq!(Policy::default(), Policy::Precious);
}
#[test]
fn builders_compose() {
let c = LockerConfig::default()
.with_max_inline(1024)
.with_eager_budget(2048)
.with_policy(Policy::Evictable { max_bytes: 4096 })
.with_on_corrupt(OnCorrupt::Skip)
.with_chunk_size(64)
.with_durability(Durability::Eventual)
.with_chain(std::sync::Arc::new(crate::codec::FilterChain::raw()));
assert_eq!(c.on_corrupt, OnCorrupt::Skip);
assert_eq!(c.durability, Durability::Eventual);
assert_eq!(c.max_inline, 1024);
assert_eq!(c.eager_budget, 2048);
assert_eq!(c.policy, Policy::Evictable { max_bytes: 4096 });
assert_eq!(c.chunk_size, 64);
assert_eq!(c.chain_id(), Some(0));
}
#[test]
fn configs_compare_a_chain_by_its_id() {
use std::sync::Arc;
let a = LockerConfig::default().with_chain(Arc::new(crate::codec::FilterChain::raw()));
let b = LockerConfig::default().with_chain(Arc::new(crate::codec::FilterChain::raw()));
assert_eq!(a, b);
assert_ne!(a, LockerConfig::default());
}
}