use std::sync::Mutex;
use std::sync::atomic::{AtomicU64, Ordering};
use super::cursor::{Checkpoint, Cursor};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum Settled {
Answered,
Exhausted,
}
impl Settled {
pub fn at(self, position: u64) -> Outcome {
match self {
Settled::Answered => Outcome::Answered { position },
Settled::Exhausted => Outcome::Exhausted { position },
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum Outcome {
Answered {
position: u64,
},
Exhausted {
position: u64,
},
Skipped {
position: u64,
},
Interrupted,
Unasked,
Unroutable,
}
impl Outcome {
pub fn settled_position(self) -> Option<u64> {
match self {
Outcome::Answered { position }
| Outcome::Exhausted { position }
| Outcome::Skipped { position } => Some(position),
Outcome::Interrupted | Outcome::Unasked | Outcome::Unroutable => None,
}
}
pub fn is_settled(self) -> bool {
self.settled_position().is_some()
}
pub fn name(self) -> &'static str {
match self {
Outcome::Answered { .. } => "answered",
Outcome::Exhausted { .. } => "exhausted",
Outcome::Skipped { .. } => "skipped",
Outcome::Interrupted => "interrupted",
Outcome::Unasked => "unasked",
Outcome::Unroutable => "unroutable",
}
}
}
#[derive(Debug, Default)]
pub struct Settlements {
cursor: Mutex<Cursor>,
answered: AtomicU64,
exhausted: AtomicU64,
skipped: AtomicU64,
interrupted: AtomicU64,
unasked: AtomicU64,
unroutable: AtomicU64,
}
impl Settlements {
pub fn resuming(checkpoint: &Checkpoint) -> Self {
Self {
cursor: Mutex::new(Cursor::from_checkpoint(checkpoint)),
..Self::default()
}
}
pub fn record(&self, outcome: Outcome) {
self.counter(outcome).fetch_add(1, Ordering::Relaxed);
if let Some(position) = outcome.settled_position() {
self.with_cursor(|cursor| cursor.settle(position));
}
}
pub fn record_many(&self, outcome: Outcome, count: u64) {
debug_assert!(
!outcome.is_settled(),
"a settled outcome names one position and cannot stand for many"
);
self.counter(outcome).fetch_add(count, Ordering::Relaxed);
}
pub fn checkpoint(&self) -> Checkpoint {
self.with_cursor(|cursor| cursor.checkpoint())
}
pub fn settled_count(&self) -> u64 {
self.with_cursor(|cursor| cursor.settled_count())
}
pub fn count(&self, outcome: Outcome) -> u64 {
self.counter(outcome).load(Ordering::Relaxed)
}
fn counter(&self, outcome: Outcome) -> &AtomicU64 {
match outcome {
Outcome::Answered { .. } => &self.answered,
Outcome::Exhausted { .. } => &self.exhausted,
Outcome::Skipped { .. } => &self.skipped,
Outcome::Interrupted => &self.interrupted,
Outcome::Unasked => &self.unasked,
Outcome::Unroutable => &self.unroutable,
}
}
fn with_cursor<R>(&self, read: impl FnOnce(&mut Cursor) -> R) -> R {
let mut cursor = self.cursor.lock().unwrap_or_else(|e| e.into_inner());
read(&mut cursor)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn only_an_earned_outcome_carries_a_position() {
assert_eq!(
Outcome::Answered { position: 7 }.settled_position(),
Some(7)
);
assert_eq!(
Outcome::Exhausted { position: 7 }.settled_position(),
Some(7)
);
assert_eq!(Outcome::Skipped { position: 7 }.settled_position(), Some(7));
for assigned in [Outcome::Interrupted, Outcome::Unasked, Outcome::Unroutable] {
assert_eq!(assigned.settled_position(), None, "{}", assigned.name());
assert!(!assigned.is_settled());
}
}
#[test]
fn a_cut_short_sitting_settles_only_what_it_earned() {
let settlements = Settlements::default();
settlements.record(Outcome::Answered { position: 0 });
settlements.record(Outcome::Exhausted { position: 1 });
for _ in 0..500 {
settlements.record(Outcome::Interrupted);
settlements.record(Outcome::Unasked);
}
let checkpoint = settlements.checkpoint();
assert_eq!(checkpoint.watermark, 2);
assert!(checkpoint.settled_above.is_empty());
assert_eq!(settlements.settled_count(), 2);
assert_eq!(settlements.count(Outcome::Interrupted), 500);
}
#[test]
fn unsettled_outcomes_are_counted_rather_than_stored() {
let settlements = Settlements::default();
for _ in 0..100_000 {
settlements.record(Outcome::Unasked);
}
assert_eq!(settlements.count(Outcome::Unasked), 100_000);
assert_eq!(settlements.settled_count(), 0);
assert_eq!(settlements.checkpoint(), Checkpoint::default());
}
#[test]
fn one_unearned_position_stalls_the_watermark() {
let settlements = Settlements::default();
settlements.record(Outcome::Answered { position: 0 });
settlements.record(Outcome::Interrupted);
for position in 2..1_000 {
settlements.record(Outcome::Answered { position });
}
assert_eq!(settlements.checkpoint().watermark, 1);
assert_eq!(settlements.settled_count(), 999);
}
#[test]
fn resuming_keeps_the_earlier_sittings_progress() {
let first = Settlements::default();
for position in 0..10 {
first.record(Outcome::Answered { position });
}
let second = Settlements::resuming(&first.checkpoint());
assert_eq!(second.settled_count(), 10);
assert_eq!(second.count(Outcome::Answered { position: 0 }), 0);
second.record(Outcome::Exhausted { position: 10 });
assert_eq!(second.checkpoint().watermark, 11);
}
}