use alloc::vec::Vec;
use bytes::Bytes;
use super::Replica;
use crate::api::{Action, Error};
use crate::core_state::CoreState;
use crate::durable::Record;
use crate::types::{NodeId, Slot, Timestamp};
impl Replica {
pub fn emitted_index(&self) -> u64 {
self.emitted
}
pub fn core_state(&self) -> Bytes {
CoreState { next: self.emitted, schedule: self.applied_schedule.clone(), dedup: self.dedup.clone() }
.encode()
}
pub fn compact(&mut self, now: Timestamp, through: Slot, core_state: Bytes) -> Result<(), Error> {
self.begin(now)?;
if self.fenced {
return Err(Error::Fenced);
}
let state = self.check_state(through, &core_state)?;
if state.next > self.emitted {
return Err(Error::InvalidCoreState);
}
if state.next > self.floor {
self.raise_floor(state.next, core_state);
}
self.flush();
Ok(())
}
pub fn install_snapshot(
&mut self,
now: Timestamp,
through: Slot,
core_state: Bytes,
) -> Result<bool, Error> {
self.begin(now)?;
if self.fenced {
return Err(Error::Fenced);
}
let state = self.check_state(through, &core_state)?;
if state.next <= self.emitted {
return Ok(false);
}
self.applied_schedule = state.schedule.clone();
self.schedule = state.schedule;
self.dedup = state.dedup;
self.emitted = state.next;
self.committed = state.next;
let me = self.me;
let inc = self.incarnation;
let done: Vec<_> = self
.outstanding
.iter()
.filter(|(id, _)| self.dedup.contains(me, inc, **id))
.map(|(id, (_, barrier))| (*id, *barrier))
.collect();
for (id, barrier) in done {
self.outstanding.remove(&id);
self.forwarded.remove(&id);
self.actions.push(if barrier {
Action::ReadReady { id, slot: through }
} else {
Action::Committed { id, slot: through }
});
}
let stale: Vec<Slot> = self.proposers.range(..Slot(state.next)).map(|(s, _)| *s).collect();
for slot in stale {
if let Some(a) = self.proposers.remove(&slot)
&& let Some(b) = self.batches.get_mut(&a.batch)
{
b.slot = None;
}
}
self.raise_floor(state.next, core_state);
self.advance_committed();
self.emit_commits();
self.catch_up = None;
if self.peer_committed > self.committed
&& let Some(peer) = self.ahead_peer
{
self.request_catch_up(peer);
}
self.pump();
self.flush();
Ok(true)
}
fn check_state(&self, through: Slot, core_state: &Bytes) -> Result<CoreState, Error> {
let state = CoreState::decode(core_state, &self.cfg.members).map_err(|_| Error::InvalidCoreState)?;
if through.0.checked_add(1) != Some(state.next) || state.next > crate::types::MAX_SLOT {
return Err(Error::InvalidCoreState);
}
Ok(state)
}
fn raise_floor(&mut self, next: u64, core_state: Bytes) {
let floor = Slot(next);
self.floor = next;
self.log = self.log.split_off(&floor);
self.registers = self.registers.split_off(&floor);
self.seen = self.seen.split_off(&floor);
self.next_alloc = self.next_alloc.max(next);
self.snapshot_state = Some(core_state);
self.checkpoint();
}
fn checkpoint(&mut self) {
let mut records = alloc::vec![Record::Incarnation(self.incarnation).encode()];
let reserved = self.reserved_through.or(self.h_floor.checked_sub(1));
if let Some(t) = reserved {
records.push(Record::Reservation { through: Slot(t) }.encode());
}
if let Some(state) = &self.snapshot_state {
records.push(
Record::Compacted { through: Slot(self.floor - 1), core_state: state.clone() }.encode(),
);
}
records.extend(
self.registers
.iter()
.map(|(slot, reg)| Record::Recorder { slot: *slot, reg: reg.clone() }.encode()),
);
records.extend(
self.log
.iter()
.map(|(slot, d)| Record::Decided { slot: *slot, proposal: d.proposal.clone() }.encode()),
);
self.writes = records;
self.replace_next = true;
}
pub(super) fn on_compacted(&mut self, from: NodeId, through: Slot) {
if through.0 < self.committed {
return;
}
let quiet = self.snapshot_asked.is_none_or(|t| t.after(self.cfg.hedge_max) <= self.now);
if quiet {
self.snapshot_asked = Some(self.now);
self.actions.push(Action::SnapshotNeeded { peer: from, through });
}
}
}