use std::collections::BTreeSet;
use std::sync::Arc;
use std::sync::Mutex;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum ClassifiedFailure {
Unreadable,
UnstableDuringRead,
AbortedCircuitBreaker,
ParseFailed,
UnknownOrdering,
TruncatedRequiredDerivation,
PartialParse,
}
impl ClassifiedFailure {
pub const ALL: [ClassifiedFailure; 7] = [
ClassifiedFailure::Unreadable,
ClassifiedFailure::UnstableDuringRead,
ClassifiedFailure::AbortedCircuitBreaker,
ClassifiedFailure::ParseFailed,
ClassifiedFailure::UnknownOrdering,
ClassifiedFailure::TruncatedRequiredDerivation,
ClassifiedFailure::PartialParse,
];
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum AttemptDisposition {
Committed,
Discarded(ClassifiedFailure),
Cancelled,
Superseded,
Panicked,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct AttemptId(pub(crate) u64);
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct AttemptRecord {
pub id: AttemptId,
pub disposition: AttemptDisposition,
}
const MAX_ATTEMPT_RECORDS: usize = 64;
#[derive(Debug, Default)]
pub(crate) struct SupervisorState {
next_attempt: u64,
live: Vec<AttemptId>,
superseded: BTreeSet<AttemptId>,
terminal: BTreeSet<AttemptId>,
records: Vec<AttemptRecord>,
committed: u64,
}
impl SupervisorState {
fn mint(&mut self) -> AttemptId {
let id = AttemptId(self.next_attempt);
self.next_attempt += 1;
self.live.push(id);
id
}
fn terminal_row(&mut self, id: AttemptId, disposition: AttemptDisposition) -> bool {
if !self.terminal.insert(id) {
return false;
}
self.live.retain(|live| *live != id);
self.records.push(AttemptRecord { id, disposition });
if self.records.len() > MAX_ATTEMPT_RECORDS {
self.records.remove(0);
}
true
}
pub(crate) fn is_superseded(&self, id: AttemptId) -> bool {
self.superseded.contains(&id)
}
pub(crate) fn is_terminal(&self, id: AttemptId) -> bool {
self.terminal.contains(&id)
}
pub(crate) fn record_commit(&mut self, id: AttemptId) {
if self.terminal_row(id, AttemptDisposition::Committed) {
self.committed += 1;
}
}
pub(crate) fn record_discard(&mut self, id: AttemptId, cause: ClassifiedFailure) {
self.terminal_row(id, AttemptDisposition::Discarded(cause));
}
pub(crate) fn record_panic(&mut self, id: AttemptId) {
self.terminal_row(id, AttemptDisposition::Panicked);
}
}
#[derive(Debug)]
pub struct SourceSupervisor {
pub(crate) state: Arc<Mutex<SupervisorState>>,
}
#[derive(Debug)]
pub struct LoadAttempt {
pub(crate) id: AttemptId,
pub(crate) state: Arc<Mutex<SupervisorState>>,
}
impl SourceSupervisor {
pub fn new() -> Self {
Self {
state: Arc::new(Mutex::new(SupervisorState::default())),
}
}
pub fn begin_attempt(&self) -> LoadAttempt {
let id = self.state.lock().expect("supervisor lock").mint();
LoadAttempt {
id,
state: Arc::clone(&self.state),
}
}
pub fn retry_trigger(&self, cause: ClassifiedFailure) -> LoadAttempt {
let mut state = self.state.lock().expect("supervisor lock");
if let Some(newest) = state.live.last().copied() {
state.superseded.insert(newest);
state.record_discard(newest, cause);
}
for stale in std::mem::take(&mut state.live) {
state.superseded.insert(stale);
state.terminal_row(stale, AttemptDisposition::Superseded);
}
let id = state.mint();
drop(state);
LoadAttempt {
id,
state: Arc::clone(&self.state),
}
}
pub fn attempt_records(&self) -> Vec<AttemptRecord> {
self.state.lock().expect("supervisor lock").records.clone()
}
pub fn committed_generations(&self) -> u64 {
self.state.lock().expect("supervisor lock").committed
}
}
impl Default for SourceSupervisor {
fn default() -> Self {
Self::new()
}
}
impl LoadAttempt {
pub fn id(&self) -> AttemptId {
self.id
}
pub fn is_superseded(&self) -> bool {
self.state
.lock()
.expect("supervisor lock")
.is_superseded(self.id)
}
pub fn cancel(self) {
self.state
.lock()
.expect("supervisor lock")
.terminal_row(self.id, AttemptDisposition::Cancelled);
}
}