use crate::entry::EntryHeader;
use crate::error::Error;
pub(crate) const PROMOTE_MAX_BATCHES: u32 = 256;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum WritePolicy {
OnboardFirst,
CardFirst,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum WriteMode {
Onboard,
Draining,
Direct,
}
#[derive(Debug, Clone, Copy)]
pub(crate) struct TierMode {
policy: WritePolicy,
mode: WriteMode,
}
impl TierMode {
pub(crate) fn new(policy: WritePolicy) -> Self {
Self {
policy,
mode: WriteMode::Onboard,
}
}
pub(crate) fn mode(&self) -> WriteMode {
self.mode
}
pub(crate) fn policy(&self) -> WritePolicy {
self.policy
}
pub(crate) fn writes_to_volume(&self) -> bool {
self.mode == WriteMode::Direct
}
pub(crate) fn attached(&mut self) {
self.mode = WriteMode::Draining;
}
pub(crate) fn fell_back(&mut self) {
self.mode = WriteMode::Onboard;
}
pub(crate) fn spooled(&mut self) {
if self.mode != WriteMode::Direct {
self.mode = WriteMode::Draining;
}
}
pub(crate) fn may_promote(&self, attached: bool, faulted: bool) -> bool {
self.policy == WritePolicy::CardFirst
&& self.mode != WriteMode::Direct
&& attached
&& !faulted
}
pub(crate) fn promoted(&mut self) {
self.mode = WriteMode::Direct;
}
pub(crate) fn ready_to_spool(&mut self, attached: bool, faulted: bool) -> Result<bool, Error> {
if faulted {
self.fell_back();
return Err(Error::VolumeLost);
}
if !attached {
self.fell_back();
return Ok(false);
}
Ok(true)
}
}
pub(crate) fn volume_gone(error: &Error) -> bool {
matches!(error, Error::Flash(_) | Error::NotAttached)
}
pub(crate) fn merge(
onboard: Option<(EntryHeader, usize)>,
from_volume: Option<(EntryHeader, usize)>,
alt: &[u8],
buf: &mut [u8],
volume_wins: impl Fn(u64, u64) -> bool,
) -> Result<Option<(EntryHeader, usize)>, Error> {
let take_volume = |vh: EntryHeader, vn: usize, buf: &mut [u8]| {
if vn > buf.len() {
return Err(Error::BufferTooSmall);
}
buf[..vn].copy_from_slice(&alt[..vn]);
Ok(Some((vh, vn)))
};
match (onboard, from_volume) {
(Some((oh, on)), Some((vh, vn))) => {
if volume_wins(vh.timestamp, oh.timestamp) {
take_volume(vh, vn, buf)
} else {
Ok(Some((oh, on)))
}
}
(None, Some((vh, vn))) => take_volume(vh, vn, buf),
(some, None) => Ok(some),
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::entry::EntryKind;
fn header(timestamp: u64) -> EntryHeader {
EntryHeader {
sensor_id: 1,
timestamp,
payload_len: 2,
kind: EntryKind::Single,
}
}
#[test]
fn a_tier_starts_onboard_and_only_card_first_ever_leaves_draining() {
let mut onboard_first = TierMode::new(WritePolicy::OnboardFirst);
assert_eq!(onboard_first.mode(), WriteMode::Onboard);
onboard_first.attached();
assert_eq!(onboard_first.mode(), WriteMode::Draining);
assert!(!onboard_first.writes_to_volume());
assert!(
!onboard_first.may_promote(true, false),
"OnboardFirst never writes direct, however drained the backlog is"
);
let mut card_first = TierMode::new(WritePolicy::CardFirst);
card_first.attached();
assert!(card_first.may_promote(true, false));
card_first.promoted();
assert_eq!(card_first.mode(), WriteMode::Direct);
assert!(card_first.writes_to_volume());
assert!(
!card_first.may_promote(true, false),
"already there, so nothing to drain for"
);
}
#[test]
fn a_pass_over_a_direct_tier_does_not_demote_it() {
let mut tier = TierMode::new(WritePolicy::CardFirst);
tier.attached();
tier.promoted();
tier.spooled();
assert_eq!(tier.mode(), WriteMode::Direct);
let mut draining = TierMode::new(WritePolicy::CardFirst);
draining.attached();
draining.spooled();
assert_eq!(draining.mode(), WriteMode::Draining);
}
#[test]
fn a_missing_volume_is_not_an_error_but_a_faulted_one_is() {
let mut tier = TierMode::new(WritePolicy::CardFirst);
tier.attached();
tier.promoted();
assert_eq!(tier.ready_to_spool(false, false), Ok(false));
assert_eq!(
tier.mode(),
WriteMode::Onboard,
"with no card, appends must stop being aimed at one"
);
tier.attached();
tier.promoted();
assert_eq!(tier.ready_to_spool(true, true), Err(Error::VolumeLost));
assert_eq!(tier.mode(), WriteMode::Onboard);
assert!(
!tier.may_promote(true, true),
"a faulted volume is not a target"
);
tier.attached();
assert_eq!(tier.ready_to_spool(true, false), Ok(true));
}
#[test]
fn only_a_missing_medium_reroutes_a_write() {
assert!(volume_gone(&Error::NotAttached));
assert!(volume_gone(&Error::Flash(
embedded_storage::nor_flash::NorFlashErrorKind::Other
)));
assert!(!volume_gone(&Error::PayloadTooLarge));
assert!(!volume_gone(&Error::NotMounted));
assert!(!volume_gone(&Error::NoSpace));
}
#[test]
fn merge_takes_the_winner_and_leaves_the_loser_alone() {
let alt = [0xAAu8; 8];
let mut buf = [0u8; 8];
let out = merge(
Some((header(10), 2)),
Some((header(20), 4)),
&alt,
&mut buf,
|v, o| v > o,
)
.unwrap()
.unwrap();
assert_eq!(out.0.timestamp, 20);
assert_eq!(&buf[..4], &[0xAA; 4]);
buf = [0u8; 8];
let out = merge(
Some((header(30), 2)),
Some((header(20), 4)),
&alt,
&mut buf,
|v, o| v > o,
)
.unwrap()
.unwrap();
assert_eq!(out.0.timestamp, 30);
assert_eq!(buf, [0u8; 8], "the onboard read already filled it");
let out = merge(
Some((header(30), 2)),
Some((header(20), 4)),
&alt,
&mut buf,
|v, o| v < o,
)
.unwrap()
.unwrap();
assert_eq!(out.0.timestamp, 20);
}
#[test]
fn merge_raises_rather_than_reporting_the_wrong_entry() {
let alt = [0xAAu8; 8];
let mut buf = [0u8; 2];
assert_eq!(
merge(
Some((header(10), 2)),
Some((header(20), 4)),
&alt,
&mut buf,
|v, o| v > o
),
Err(Error::BufferTooSmall),
"silently reporting the onboard entry would answer a different question"
);
assert_eq!(
merge(None, Some((header(20), 4)), &alt, &mut buf, |v, o| v > o),
Err(Error::BufferTooSmall)
);
assert_eq!(
merge(Some((header(10), 2)), None, &alt, &mut buf, |v, o| v > o),
Ok(Some((header(10), 2)))
);
}
}