use std::sync::{
Arc, Weak,
atomic::{AtomicU64, Ordering},
};
use crate::{
Timestamp,
drive::registry::{Registry, RetireOrigin, RetiredLedger, Retirement, RootKey, Stamp},
};
use super::{RetiredMirror, RetiredRow, RetiredStore, RetiredStoreError};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub struct KeeperReport {
pub recorded: u64,
pub erased: u64,
pub refused: u64,
}
#[derive(Debug, Default)]
struct Counters {
recorded: AtomicU64,
erased: AtomicU64,
refused: AtomicU64,
}
impl Counters {
fn report(&self) -> KeeperReport {
KeeperReport {
recorded: self.recorded.load(Ordering::Relaxed),
erased: self.erased.load(Ordering::Relaxed),
refused: self.refused.load(Ordering::Relaxed),
}
}
}
pub struct Keeper<Root> {
owed: flume::Sender<(Root, Retirement)>,
counters: Arc<Counters>,
}
impl<Root> core::fmt::Debug for Keeper<Root> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.debug_struct("Keeper")
.field("queued", &self.owed.len())
.field("report", &self.counters.report())
.finish()
}
}
impl<Root> Keeper<Root>
where
Root: RootKey,
{
#[must_use]
pub fn new(
store: Arc<dyn RetiredStore<Root>>,
mirror: Arc<RetiredMirror<Root>>,
registry: Weak<Registry<Root>>,
) -> (Self, KeeperBody<Root>) {
let (owed, taken) = flume::unbounded();
let counters = Arc::new(Counters::default());
let seat = Self {
owed,
counters: Arc::clone(&counters),
};
let body = KeeperBody {
taken,
store,
mirror,
registry,
counters,
};
(seat, body)
}
#[must_use = "the body is what performs the writes; a dropped one leaves the ledger untouched"]
pub fn seated(
registry: &Arc<Registry<Root>>,
store: Arc<dyn RetiredStore<Root>>,
mirror: Arc<RetiredMirror<Root>>,
) -> Option<KeeperBody<Root>> {
let (seat, body) = Self::new(store, mirror, Arc::downgrade(registry));
registry
.installing(Arc::new(seat) as Arc<dyn RetiredLedger<Root>>)
.then_some(body)
}
#[inline]
#[must_use]
pub fn report(&self) -> KeeperReport {
self.counters.report()
}
#[inline]
#[must_use]
pub fn queued(&self) -> usize {
self.owed.len()
}
}
impl<Root> RetiredLedger<Root> for Keeper<Root>
where
Root: RootKey,
{
#[inline]
fn owed(&self, key: &Root, act: Retirement) {
let _gone = self.owed.send((key.clone(), act));
}
}
pub struct KeeperBody<Root: RootKey> {
taken: flume::Receiver<(Root, Retirement)>,
store: Arc<dyn RetiredStore<Root>>,
mirror: Arc<RetiredMirror<Root>>,
registry: Weak<Registry<Root>>,
counters: Arc<Counters>,
}
impl<Root: RootKey> core::fmt::Debug for KeeperBody<Root> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.debug_struct("KeeperBody")
.field("queued", &self.taken.len())
.field("report", &self.counters.report())
.finish()
}
}
impl<Root: RootKey> KeeperBody<Root> {
pub async fn run(self) {
while let Ok((key, act)) = self.taken.recv_async().await {
self.perform(&key, act).await;
}
}
pub async fn perform(&self, key: &Root, act: Retirement) {
match act {
Retirement::Recorded {
at,
origin,
late_tails,
} => self.recorded(key, at, origin, late_tails).await,
Retirement::Erased => self.erased(key).await,
}
}
async fn recorded(&self, key: &Root, at: Timestamp, origin: RetireOrigin, late_tails: bool) {
let row = RetiredRow::new(key.clone(), at, origin, late_tails);
if self.refused(self.store.record(&row).await) {
return;
}
self.mirror.mark(key.clone());
self.counters.recorded.fetch_add(1, Ordering::Relaxed);
}
async fn erased(&self, key: &Root) {
if self.refused(self.store.erase(key).await) {
return;
}
self.mirror.unmark(key.clone());
self.counters.erased.fetch_add(1, Ordering::Relaxed);
if let Some(registry) = self.registry.upgrade() {
let _told = registry.restored(key, Stamp::now());
}
}
fn refused(&self, outcome: Result<(), RetiredStoreError>) -> bool {
let Err(refusal) = outcome else {
return false;
};
self.counters.refused.fetch_add(1, Ordering::Relaxed);
#[cfg(feature = "tracing")]
{
let engine = core::error::Error::source(&refusal).map(ToString::to_string);
tracing::error!(
verb = refusal.verb(),
table = refusal.table(),
error = %refusal,
engine = engine.as_deref().unwrap_or("—"),
"the retired ledger refused an act; the mirror was not moved"
);
}
#[cfg(not(feature = "tracing"))]
let _unreported = refusal;
true
}
#[inline]
#[must_use]
pub fn report(&self) -> KeeperReport {
self.counters.report()
}
}
pub async fn rebuild<Root>(
store: &dyn RetiredStore<Root>,
registry: &Registry<Root>,
mirror: &RetiredMirror<Root>,
) -> Result<usize, RetiredStoreError>
where
Root: RootKey,
{
store.ready().await?;
let rows = store.roll().await?;
let read = rows.len();
for row in rows {
registry.rebuilt(row.key(), row.at(), row.origin().clone(), row.late_tails());
mirror.mark(row.into_key());
}
Ok(read)
}