use crate::db::{
AppendStep, CompactScope, DbConfig, DbStats, Edge, LogPosition, MountMode, MountStats,
ReadCursor, Replicated, Scan, ScannedEntry, ScannedSector, SectorScanner, SensorDbState,
SpoolStats, sort_by_seq,
};
use crate::entry::{ENTRY_HEADER_SIZE, ENTRY_OVERHEAD, EntryHeader, EntryKind};
use crate::error::Error;
use crate::partition::Partition;
use crate::run::{RUN_FRAME_SIZE, Run, RunFrame, deliver_samples, samples_in};
use crate::schema;
use crate::sector::{
LogId, SECTOR_FOOTER_SIZE, SECTOR_HEADER_SIZE, SectorClass, SectorFooter, SectorHeader,
SectorState, SectorSummary,
};
use crate::typed::SensorData;
use embedded_storage_async::nor_flash::{NorFlash, ReadNorFlash};
use heapless::Vec as HeaplessVec;
use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
struct GeometryAsync<F: ?Sized, const PAGE_SIZE: usize>(core::marker::PhantomData<F>);
impl<F: NorFlash + ?Sized, const PAGE_SIZE: usize> GeometryAsync<F, PAGE_SIZE> {
const PAGE_IS_WRITABLE: () = assert!(
PAGE_SIZE.is_multiple_of(F::WRITE_SIZE),
"PAGE_SIZE must be a multiple of the flash driver's WRITE_SIZE",
);
}
async fn next_entry_async<F: ReadNorFlash>(
scanner: &mut SectorScanner,
flash: &mut F,
header_buf: &mut [u8; ENTRY_HEADER_SIZE],
page_size: usize,
) -> Result<Option<ScannedEntry>, Error> {
let mut step = scanner.begin();
loop {
match step {
Scan::Done => return Ok(None),
Scan::Found(entry) => return Ok(Some(entry)),
Scan::Read(addr) => {
flash.read(addr, &mut header_buf[..]).await?;
step = scanner.feed(header_buf, page_size);
}
}
}
}
async fn accept_entry_async<F: ReadNorFlash>(
flash: &mut F,
sector_offset: u32,
entry: &ScannedEntry,
buf: &mut [u8],
) -> Result<bool, Error> {
let (addr, read_len) = entry.payload_read(sector_offset);
if read_len > buf.len() {
return Ok(false);
}
flash.read(addr, &mut buf[..read_len]).await?;
Ok(entry.accept(buf))
}
pub struct SensorDbAsync<F, const PAGE_SIZE: usize, const MAX_SECTORS: usize> {
flash: F,
state: SensorDbState<PAGE_SIZE, MAX_SECTORS>,
}
impl<F, const PAGE_SIZE: usize, const MAX_SECTORS: usize> core::fmt::Debug
for SensorDbAsync<F, PAGE_SIZE, MAX_SECTORS>
{
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.debug_struct("SensorDbAsync")
.field("base_offset", &self.state.base_offset)
.field("sector_count", &self.state.sector_count)
.field("sector_size", &self.state.sector_size)
.field("mounted", &self.state.mounted)
.field("active_sector", &self.state.active_sector)
.field("total_entries", &self.state.total_entries)
.finish_non_exhaustive()
}
}
impl<F, const PAGE_SIZE: usize, const MAX_SECTORS: usize> SensorDbAsync<F, PAGE_SIZE, MAX_SECTORS>
where
F: NorFlash + ReadNorFlash,
{
pub fn new(
flash: F,
base_offset: u32,
sector_count: u16,
reserved_sectors: u16,
) -> Result<Self, Error> {
Self::with_config(
flash,
DbConfig::new(base_offset, sector_count, reserved_sectors)?,
)
}
pub fn with_config(flash: F, config: DbConfig) -> Result<Self, Error> {
let () = GeometryAsync::<F, PAGE_SIZE>::PAGE_IS_WRITABLE;
Ok(Self {
flash,
state: SensorDbState::new(config, F::ERASE_SIZE as u32)?,
})
}
pub async fn format(&mut self) -> Result<(), Error> {
for i in 0..self.state.sector_count {
self.erase_sector(i).await?;
self.state.sectors[i as usize] = SectorSummary::erased();
self.state.sectors[i as usize].erase_count = 1;
}
self.init_sector(0, 1, 1).await?;
self.state.sectors[0].state = SectorState::Active;
self.state.sectors[0].sequence = 1;
self.state.sectors[0].write_offset = SECTOR_HEADER_SIZE as u32;
self.state.sectors[0].erase_count = 1;
self.state.active_sector = Some(0);
self.state.next_sequence = 2;
self.state.total_entries = 0;
self.state.total_samples = 0;
self.state.mounted = true;
self.state.mount_mode = MountMode::Full;
self.state.epoch_pending = false;
self.state.spool_watermark = LogPosition::BEGINNING;
self.state.spooled_entries = 0;
self.state.spooled_samples = 0;
self.state.dropped_unspooled = 0;
self.state.page_flash_offset = self.state.base_offset;
self.state.page_buf_offset = SECTOR_HEADER_SIZE;
self.state.page_buf_durable = SECTOR_HEADER_SIZE;
self.state.page_buf.fill(0xFF);
let header = self.state.sector_header(1, 1);
self.state.page_buf[..SECTOR_HEADER_SIZE].copy_from_slice(header.as_bytes());
Ok(())
}
pub async fn mount(&mut self) -> Result<MountStats, Error> {
self.mount_with(MountMode::Full).await
}
pub async fn mount_with(&mut self, mode: MountMode) -> Result<MountStats, Error> {
if self.state.mounted {
return Err(Error::AlreadyMounted);
}
let mut stats = MountStats::default();
let mut max_sequence: u32 = 0;
let mut max_epoch: u32 = 0;
let mut valid: HeaplessVec<u16, MAX_SECTORS> = HeaplessVec::new();
for i in 0..self.state.sector_count {
let sector_offset = self.state.sector_offset(i);
let mut header_buf = [0u8; SECTOR_HEADER_SIZE];
self.flash.read(sector_offset, &mut header_buf).await?;
let header =
SectorHeader::read_from_bytes(&header_buf).map_err(|_| Error::CorruptEntry)?;
match header.classify(self.state.log_id) {
SectorClass::Valid => {
let seq = header.sequence.get();
let epoch = header.epoch.get();
self.state.sectors[i as usize].sequence = seq;
self.state.sectors[i as usize].erase_count = header.erase_count.get();
max_sequence = max_sequence.max(seq);
max_epoch = max_epoch.max(epoch);
let _ = valid.push(i);
}
SectorClass::Free => {
self.state.sectors[i as usize] = SectorSummary::erased();
}
SectorClass::Foreign { found } => {
return Err(Error::ForeignVolume {
expected: self.state.log_id_raw(),
found,
});
}
SectorClass::Unsupported { found } => {
return Err(Error::UnsupportedVersion { found });
}
}
}
let newest = valid
.iter()
.copied()
.max_by_key(|i| self.state.sectors[*i as usize].sequence);
let mut newest_sealed = false;
for i in valid.iter().copied() {
let is_newest = Some(i) == newest;
let footer = if self.state.wants_footer(mode, is_newest) {
self.read_sector_footer(i).await?
} else {
None
};
if is_newest {
newest_sealed = footer.is_some();
}
if let Some(footer) = footer.filter(|_| mode != MountMode::Verify) {
self.state.adopt_footer(i, &footer, &mut stats);
} else if mode != MountMode::HeadersOnly || is_newest {
let (scanned, corrupt) = self.scan_sector_entries(i).await?;
self.state.adopt_scan(i, &scanned, corrupt, &mut stats);
} else {
self.state.adopt_unindexed(i);
}
self.state.sectors[i as usize].state = SectorState::Sealed;
stats.sealed_sectors += 1;
}
self.state
.finish_mount(mode, max_sequence, max_epoch, &stats);
if let Some(idx) = newest {
self.state.sectors[idx as usize].state = SectorState::Active;
self.state.active_sector = Some(idx);
stats.sealed_sectors = stats.sealed_sectors.saturating_sub(1);
self.state.epoch_pending = true;
let sector_offset = self.state.sector_offset(idx);
let resume = if newest_sealed {
self.state.footer_offset()
} else {
self.state.sectors[idx as usize].write_offset
};
let page_start = (resume / PAGE_SIZE as u32) * PAGE_SIZE as u32;
self.state.page_flash_offset = sector_offset + page_start;
self.state.page_buf_offset = (resume % PAGE_SIZE as u32) as usize;
self.state.page_buf_durable = self.state.page_buf_offset;
self.state.page_buf.fill(0xFF);
let mut last_dirty: Option<u32> = None;
let mut probe = page_start;
while probe < self.state.footer_offset() {
self.flash
.read(sector_offset + probe, &mut self.state.page_buf)
.await?;
let from = if probe == page_start {
self.state.page_buf_offset
} else {
0
};
if self.state.page_buf[from..].iter().any(|b| *b != 0xFF) {
last_dirty = Some(probe);
}
probe += PAGE_SIZE as u32;
}
match last_dirty {
None if resume < self.state.footer_offset() => {
self.flash
.read(self.state.page_flash_offset, &mut self.state.page_buf)
.await?;
}
None => {}
Some(dirty) => {
self.state.page_flash_offset = sector_offset + dirty + PAGE_SIZE as u32;
self.state.page_buf_offset = 0;
self.state.page_buf_durable = 0;
self.state.page_buf.fill(0xFF);
self.state.sectors[idx as usize].write_offset = dirty + PAGE_SIZE as u32;
}
}
} else {
self.erase_sector(0).await?;
self.init_sector(0, self.state.next_sequence, 1).await?;
self.state.epoch_pending = false;
self.state.sectors[0].state = SectorState::Active;
self.state.sectors[0].sequence = self.state.next_sequence;
self.state.sectors[0].write_offset = SECTOR_HEADER_SIZE as u32;
self.state.sectors[0].erase_count = 1;
self.state.active_sector = Some(0);
self.state.next_sequence += 1;
self.state.page_flash_offset = self.state.base_offset;
self.state.page_buf_offset = SECTOR_HEADER_SIZE;
self.state.page_buf_durable = SECTOR_HEADER_SIZE;
self.state.page_buf.fill(0xFF);
let header = self.state.sector_header(self.state.sectors[0].sequence, 1);
self.state.page_buf[..SECTOR_HEADER_SIZE].copy_from_slice(header.as_bytes());
}
self.state.mounted = true;
Ok(stats)
}
pub async fn append(
&mut self,
sensor_id: u16,
timestamp: u64,
payload: &[u8],
) -> Result<(), Error> {
self.append_entry(
EntryKind::Single,
sensor_id,
timestamp,
timestamp,
1,
&[],
payload,
)
.await
}
pub async fn append_run(&mut self, run: &Run<'_>) -> Result<(), Error> {
let mut frame = [0u8; RUN_FRAME_SIZE];
run.write_frame(&mut frame);
self.append_entry(
EntryKind::Run,
run.sensor_id(),
run.base_timestamp(),
run.span_end(),
run.count(),
&frame,
run.samples(),
)
.await
}
pub async fn append_framed(
&mut self,
header: &EntryHeader,
payload: &[u8],
) -> Result<(), Error> {
match header.kind {
EntryKind::Single => {
self.append(header.sensor_id, header.timestamp, payload)
.await
}
EntryKind::Run => {
let frame = RunFrame::parse(payload).ok_or(Error::CorruptEntry)?;
self.append_entry(
EntryKind::Run,
header.sensor_id,
header.timestamp,
frame.span_end(header.timestamp),
frame.count(),
&[],
payload,
)
.await
}
}
}
#[allow(clippy::too_many_arguments)]
async fn append_entry(
&mut self,
kind: EntryKind,
sensor_id: u16,
timestamp: u64,
span_end: u64,
samples: u32,
head: &[u8],
tail: &[u8],
) -> Result<(), Error> {
if !self.state.mounted {
return Err(Error::NotMounted);
}
let payload_len = head.len() + tail.len();
let entry_size = ENTRY_OVERHEAD + payload_len;
if payload_len > self.max_payload_size() {
return Err(Error::PayloadTooLarge);
}
if self.state.epoch_pending {
match self.seal_and_advance().await {
Ok(()) => {}
Err(Error::NoSpace) => self.state.epoch_pending = false,
Err(e) => return Err(e),
}
}
let mut sealed_once = false;
loop {
match self.state.plan_append(entry_size)? {
AppendStep::Stage => break,
AppendStep::FlushPage => self.flush_page().await?,
AppendStep::Seal => {
if sealed_once {
return Err(Error::PayloadTooLarge);
}
sealed_once = true;
self.seal_and_advance().await?;
}
}
}
self.state
.stage_entry(kind, sensor_id, timestamp, span_end, samples, head, tail)
}
pub async fn sync(&mut self) -> Result<(), Error> {
if !self.state.mounted {
return Err(Error::NotMounted);
}
self.flush_page().await?;
Ok(())
}
pub async fn latest(
&mut self,
sensor_id: u16,
buf: &mut [u8],
) -> Result<Option<(EntryHeader, usize)>, Error> {
self.state.require_reads()?;
let mut sector_order: HeaplessVec<(u16, u32), MAX_SECTORS> = HeaplessVec::new();
for i in 0..self.state.sector_count {
let summary = &self.state.sectors[i as usize];
if summary.state != SectorState::Erased && summary.might_contain_sensor(sensor_id) {
let _ = sector_order.push((i, summary.sequence));
}
}
sort_by_seq(&mut sector_order, |a, b| b.cmp(a));
let mut best: Option<(EntryHeader, usize)> = None;
for (sector_idx, _) in sector_order {
if let Some(result) = self
.find_latest_in_sector(sector_idx, sensor_id, buf)
.await?
{
best = Some(result);
break;
}
}
let min_ts = best.as_ref().map_or(0, |(h, _)| h.timestamp);
if let Some((hdr, len)) = self
.state
.scan_page_buf_for_latest(sensor_id, min_ts, buf)?
{
best = Some((hdr, len));
}
Ok(best)
}
pub async fn query_range<C>(
&mut self,
sensor_id: Option<u16>,
t_start: u64,
t_end: u64,
mut callback: C,
) -> Result<u32, Error>
where
C: FnMut(&EntryHeader, &[u8]) -> bool,
{
self.state.require_reads()?;
let mut count = 0u32;
let mut sector_order: HeaplessVec<(u16, u32), MAX_SECTORS> = HeaplessVec::new();
for i in 0..self.state.sector_count {
let summary = &self.state.sectors[i as usize];
if summary.state != SectorState::Erased
&& summary.entry_count > 0
&& summary.overlaps_time_range(t_start, t_end)
&& sensor_id.is_none_or(|id| summary.might_contain_sensor(id))
{
let _ = sector_order.push((i, summary.sequence));
}
}
sort_by_seq(&mut sector_order, u32::cmp);
let mut entry_buf = [0u8; PAGE_SIZE];
let mut stopped = false;
for (sector_idx, _) in sector_order {
stopped = self
.scan_sector_for_query(
sector_idx,
sensor_id,
t_start,
t_end,
&mut entry_buf,
&mut count,
&mut callback,
)
.await?;
if stopped {
break;
}
}
if !stopped {
self.state.scan_page_buf_for_query(
sensor_id,
t_start,
t_end,
&mut entry_buf,
&mut count,
&mut callback,
);
}
Ok(count)
}
pub async fn query_all<C>(&mut self, sensor_id: Option<u16>, callback: C) -> Result<u32, Error>
where
C: FnMut(&EntryHeader, &[u8]) -> bool,
{
self.query_range(sensor_id, 0, u64::MAX, callback).await
}
pub async fn oldest(
&mut self,
sensor_id: u16,
buf: &mut [u8],
) -> Result<Option<(EntryHeader, usize)>, Error> {
self.state.require_reads()?;
let mut sector_order: HeaplessVec<(u16, u32), MAX_SECTORS> = HeaplessVec::new();
for i in 0..self.state.sector_count {
let summary = &self.state.sectors[i as usize];
if summary.state != SectorState::Erased && summary.might_contain_sensor(sensor_id) {
let _ = sector_order.push((i, summary.sequence));
}
}
sort_by_seq(&mut sector_order, u32::cmp);
for (sector_idx, _) in sector_order {
if let Some((header, payload_len)) = self
.find_oldest_in_sector(sector_idx, sensor_id, buf)
.await?
{
return Ok(Some((header, payload_len)));
}
}
if let Some(result) = self.state.scan_page_buf_for_oldest(sensor_id, buf) {
return Ok(Some(result));
}
Ok(None)
}
pub async fn count(&mut self, sensor_id: Option<u16>) -> Result<u32, Error> {
self.state.require_reads()?;
let Some(target) = sensor_id else {
return Ok(self.state.total_samples);
};
let mut count = 0u32;
for i in 0..self.state.sector_count {
let summary = &self.state.sectors[i as usize];
if summary.state != SectorState::Erased && summary.might_contain_sensor(target) {
count += self.count_sensor_in_sector(i, target).await?;
}
}
count += self.state.count_sensor_in_page_buf(target);
Ok(count)
}
pub async fn compact(&mut self, count: u16, scope: CompactScope) -> Result<u16, Error> {
if !self.state.mounted {
return Err(Error::NotMounted);
}
let mut sealed: HeaplessVec<(u16, u32), MAX_SECTORS> = HeaplessVec::new();
for i in 0..self.state.sector_count {
let summary = &self.state.sectors[i as usize];
if summary.state != SectorState::Sealed {
continue;
}
if scope == CompactScope::SpooledOnly && !self.state.is_fully_spooled(summary) {
continue;
}
let _ = sealed.push((i, summary.sequence));
}
sort_by_seq(&mut sealed, u32::cmp);
let mut erased = 0u16;
for (sector_idx, _) in sealed.iter().take(count as usize) {
let victim = self.state.sectors[*sector_idx as usize];
self.erase_sector(*sector_idx).await?;
self.state.account_eviction(&victim);
self.state.sectors[*sector_idx as usize] = SectorSummary::erased();
self.state.sectors[*sector_idx as usize].erase_count = victim.erase_count;
erased += 1;
}
Ok(erased)
}
pub fn sectors_erased(&self) -> u32 {
self.state.sectors_erased
}
pub fn stats(&self) -> DbStats {
self.state.stats()
}
pub fn is_mounted(&self) -> bool {
self.state.mounted
}
pub fn max_payload_size(&self) -> usize {
PAGE_SIZE - ENTRY_OVERHEAD
}
pub async fn append_value<T: IntoBytes + Immutable>(
&mut self,
sensor_id: u16,
timestamp: u64,
data: &T,
) -> Result<(), Error> {
self.append(sensor_id, timestamp, data.as_bytes()).await
}
pub async fn latest_value<T: FromBytes + KnownLayout>(
&mut self,
sensor_id: u16,
) -> Result<Option<(EntryHeader, T)>, Error> {
let expected_size = core::mem::size_of::<T>();
let mut buf = [0u8; PAGE_SIZE];
match self.latest(sensor_id, &mut buf).await? {
Some((header, payload_len)) => {
if payload_len != expected_size {
return Err(Error::SizeMismatch {
expected: expected_size,
actual: payload_len,
});
}
let value =
T::read_from_bytes(&buf[..payload_len]).map_err(|_| Error::InvalidData)?;
Ok(Some((header, value)))
}
None => Ok(None),
}
}
pub async fn append_sensor<T: SensorData>(
&mut self,
timestamp: u64,
data: &T,
) -> Result<(), Error> {
let framed = schema::tag(data);
self.append(T::SENSOR_ID, timestamp, framed.bytes()).await
}
pub async fn latest_sensor<T: SensorData>(
&mut self,
) -> Result<Option<(EntryHeader, T)>, Error> {
let mut framed = schema::Tagged::<T>::empty();
let found = self.latest(T::SENSOR_ID, framed.bytes_mut()).await?;
schema::untag(found, framed)
}
pub async fn query_sensor<T: SensorData, C>(
&mut self,
t_start: u64,
t_end: u64,
mut callback: C,
) -> Result<u32, Error>
where
C: FnMut(&EntryHeader, &T) -> bool,
{
let mut count = 0u32;
self.query_range(Some(T::SENSOR_ID), t_start, t_end, |header, payload| {
let Some(value) = schema::untag_payload::<T>(payload) else {
return true;
};
count += 1;
callback(header, &value)
})
.await?;
Ok(count)
}
pub async fn query_all_sensor<T: SensorData, C>(&mut self, callback: C) -> Result<u32, Error>
where
C: FnMut(&EntryHeader, &T) -> bool,
{
self.query_sensor(0, u64::MAX, callback).await
}
pub async fn oldest_sensor<T: SensorData>(
&mut self,
) -> Result<Option<(EntryHeader, T)>, Error> {
let mut framed = schema::Tagged::<T>::empty();
let found = self.oldest(T::SENSOR_ID, framed.bytes_mut()).await?;
schema::untag(found, framed)
}
pub async fn count_sensor<T: SensorData>(&mut self) -> Result<u32, Error> {
self.count(Some(T::SENSOR_ID)).await
}
pub async fn read_from<C>(
&mut self,
from: LogPosition,
max_entries: u32,
mut callback: C,
) -> Result<ReadCursor, Error>
where
C: FnMut(LogPosition, &EntryHeader, &[u8]) -> Result<bool, Error>,
{
if !self.state.mounted {
return Err(Error::NotMounted);
}
let mut order: HeaplessVec<(u16, u32), MAX_SECTORS> = HeaplessVec::new();
let mut oldest_seq = u32::MAX;
for i in 0..self.state.sector_count {
let summary = &self.state.sectors[i as usize];
if summary.state == SectorState::Erased {
continue;
}
if summary.sequence < oldest_seq {
oldest_seq = summary.sequence;
}
if summary.sequence >= from.sequence {
let _ = order.push((i, summary.sequence));
}
}
sort_by_seq(&mut order, u32::cmp);
let gap =
from != LogPosition::BEGINNING && oldest_seq != u32::MAX && from.sequence < oldest_seq;
let mut cursor = ReadCursor {
next: from,
entries: 0,
exhausted: false,
gap,
};
if max_entries == 0 {
return Ok(cursor);
}
let mut header_buf = [0u8; ENTRY_HEADER_SIZE];
let mut buf = [0u8; PAGE_SIZE];
let mut stopped = false;
for (sector_idx, seq) in order {
let sector_offset = self.state.sector_offset(sector_idx);
let limit = self.state.sectors[sector_idx as usize].write_offset;
let start = if seq == from.sequence {
from.offset.max(SECTOR_HEADER_SIZE as u32)
} else {
SECTOR_HEADER_SIZE as u32
};
if start >= limit {
continue;
}
let mut scanner = SectorScanner::new(sector_offset, start, limit);
while let Some(entry) =
next_entry_async(&mut scanner, &mut self.flash, &mut header_buf, PAGE_SIZE).await?
{
if !accept_entry_async(&mut self.flash, sector_offset, &entry, &mut buf).await? {
scanner.skip(1);
continue;
}
let position = LogPosition {
sequence: seq,
offset: entry.offset_in_sector,
};
let header = entry.header.to_header();
if !callback(position, &header, &buf[..entry.payload_len])? {
stopped = true;
break;
}
scanner.skip(entry.entry_size);
cursor.entries += 1;
cursor.next = LogPosition {
sequence: seq,
offset: scanner.offset(),
};
if cursor.entries >= max_entries {
stopped = true;
break;
}
}
if stopped {
break;
}
}
cursor.exhausted = !stopped;
Ok(cursor)
}
pub fn drain_unflushed<C>(&mut self, callback: C) -> Result<u32, Error>
where
C: FnMut(&EntryHeader, &[u8]) -> Result<(), Error>,
{
self.state.drain_unflushed(callback)
}
pub fn peek_unflushed<C>(&self, callback: C) -> Result<u32, Error>
where
C: FnMut(&EntryHeader, &[u8]) -> Result<(), Error>,
{
self.state.peek_unflushed(callback)
}
pub async fn sector_epoch_at(&mut self, position: LogPosition) -> Result<Option<u32>, Error> {
if !self.state.mounted {
return Err(Error::NotMounted);
}
let Some(idx) = self.state.sector_at_sequence(position.sequence) else {
return Ok(None);
};
let offset = self.state.sector_offset(idx);
let mut buf = [0u8; SECTOR_HEADER_SIZE];
self.flash.read(offset, &mut buf).await?;
let header = SectorHeader::read_from_bytes(&buf).map_err(|_| Error::CorruptEntry)?;
Ok(header.is_valid().then(|| header.epoch.get()))
}
pub fn mark_as_replica(&mut self) {
self.state.epoch_pending = false;
}
pub fn head_position(&self) -> LogPosition {
self.state.head_position()
}
pub fn tail_position(&self) -> LogPosition {
self.state.tail_position()
}
pub fn note_spooled(&mut self, upto: LogPosition, moved: Replicated) {
self.state.note_spooled(upto, moved);
}
pub async fn restore_spool_watermark(&mut self, upto: LogPosition) -> Result<(), Error> {
let Some(boundary) = self.state.restore_spool_watermark(upto) else {
return Ok(());
};
let counted = self.count_entries_before(boundary, upto.offset).await?;
self.state.add_spooled(counted);
Ok(())
}
pub fn spool_stats(&self) -> SpoolStats {
self.state.spool_stats()
}
pub fn log_id(&self) -> Option<LogId> {
self.state.log_id
}
pub fn epoch(&self) -> u32 {
self.state.epoch
}
pub fn mount_mode(&self) -> MountMode {
self.state.mount_mode
}
pub fn region(&mut self, base: u32, len: u32) -> Result<Partition<&mut F>, Error> {
self.state.check_disjoint(base, len)?;
Partition::new_async(&mut self.flash, base, len)
}
pub fn driver_mut(&mut self) -> &mut F {
&mut self.flash
}
pub fn into_inner(self) -> F {
self.flash
}
async fn erase_sector(&mut self, sector_idx: u16) -> Result<(), Error> {
let offset = self.state.sector_offset(sector_idx);
self.flash
.erase(offset, offset + self.state.sector_size)
.await?;
self.state.sectors_erased = self.state.sectors_erased.saturating_add(1);
Ok(())
}
async fn init_sector(
&mut self,
sector_idx: u16,
sequence: u32,
erase_count: u32,
) -> Result<(), Error> {
let header = self.state.sector_header(sequence, erase_count);
let offset = self.state.sector_offset(sector_idx);
let mut page = [0xFFu8; PAGE_SIZE];
page[..SECTOR_HEADER_SIZE].copy_from_slice(header.as_bytes());
self.flash.write(offset, &page).await?;
Ok(())
}
async fn read_sector_footer(&mut self, sector_idx: u16) -> Result<Option<SectorFooter>, Error> {
let offset = self.state.sector_offset(sector_idx) + self.state.footer_offset();
let mut buf = [0u8; SECTOR_FOOTER_SIZE];
self.flash.read(offset, &mut buf).await?;
let footer = SectorFooter::read_from_bytes(&buf).map_err(|_| Error::CorruptEntry)?;
let sequence = self.state.sectors[sector_idx as usize].sequence;
Ok(footer.describes(sequence).then_some(footer))
}
async fn write_sector_footer(&mut self, sector_idx: u16) -> Result<(), Error> {
debug_assert_eq!(
self.state.page_buf_offset, self.state.page_buf_durable,
"a sector is sealed only with a page buffer that flash already has"
);
let footer = SectorFooter::new(&self.state.sectors[sector_idx as usize]);
let mut page = [0xFFu8; PAGE_SIZE];
page[..SECTOR_FOOTER_SIZE].copy_from_slice(footer.as_bytes());
let offset = self.state.sector_offset(sector_idx) + self.state.footer_offset();
self.flash.write(offset, &page).await?;
Ok(())
}
async fn flush_page(&mut self) -> Result<(), Error> {
let Some(addr) = self.state.commit_target() else {
return Ok(());
};
self.flash.write(addr, &self.state.page_buf).await?;
self.state.mark_page_committed();
self.flash.write(addr, &self.state.page_buf).await?;
self.state.advance_page();
Ok(())
}
async fn seal_and_advance(&mut self) -> Result<(), Error> {
let old_active = self.state.sealing()?;
let _ = self.write_sector_footer(old_active).await;
let plan = self.state.begin_seal(old_active)?;
self.erase_sector(plan.new_active).await?;
self.state.account_seal(&plan);
self.init_sector(plan.new_active, self.state.next_sequence, plan.erase_count)
.await?;
self.state.finish_seal(&plan);
Ok(())
}
async fn scan_sector_entries(
&mut self,
sector_idx: u16,
) -> Result<(ScannedSector, u32), Error> {
let sector_offset = self.state.sector_offset(sector_idx);
let entry_start = SECTOR_HEADER_SIZE as u32;
let mut scanner =
SectorScanner::new(sector_offset, entry_start, self.state.footer_offset());
let mut header_buf = [0u8; ENTRY_HEADER_SIZE];
let mut buf = [0u8; PAGE_SIZE];
let mut found = ScannedSector {
write_offset: entry_start,
..ScannedSector::EMPTY
};
while let Some(entry) =
next_entry_async(&mut scanner, &mut self.flash, &mut header_buf, PAGE_SIZE).await?
{
if !accept_entry_async(&mut self.flash, sector_offset, &entry, &mut buf).await? {
scanner.corrupt_count += 1;
scanner.skip(1);
continue;
}
found.record(&entry, &buf[..entry.payload_len]);
scanner.skip(entry.entry_size);
found.write_offset = scanner.offset();
}
Ok((found, scanner.corrupt_count()))
}
async fn find_latest_in_sector(
&mut self,
sector_idx: u16,
target_sensor: u16,
buf: &mut [u8],
) -> Result<Option<(EntryHeader, usize)>, Error> {
let sector_offset = self.state.sector_offset(sector_idx);
let write_offset = self.state.sectors[sector_idx as usize].write_offset;
let entry_start = SECTOR_HEADER_SIZE as u32;
let mut scanner = SectorScanner::new(sector_offset, entry_start, write_offset);
let mut header_buf = [0u8; ENTRY_HEADER_SIZE];
let mut payload_buf = [0u8; PAGE_SIZE];
let mut latest: Option<(EntryHeader, usize)> = None;
let mut latest_ts = 0u64;
while let Some(entry) =
next_entry_async(&mut scanner, &mut self.flash, &mut header_buf, PAGE_SIZE).await?
{
if !accept_entry_async(&mut self.flash, sector_offset, &entry, &mut payload_buf).await?
{
scanner.skip(1);
continue;
}
if entry.sensor_id() == target_sensor {
let (header, payload) =
entry.edge(&mut payload_buf[..entry.payload_len], Edge::Last);
if header.timestamp >= latest_ts {
let len = payload.len();
if len > buf.len() {
return Err(Error::BufferTooSmall);
}
buf[..len].copy_from_slice(payload);
latest_ts = header.timestamp;
latest = Some((header, len));
}
}
scanner.skip(entry.entry_size);
}
Ok(latest)
}
#[allow(clippy::too_many_arguments)]
async fn scan_sector_for_query<C>(
&mut self,
sector_idx: u16,
sensor_filter: Option<u16>,
t_start: u64,
t_end: u64,
buf: &mut [u8],
count: &mut u32,
callback: &mut C,
) -> Result<bool, Error>
where
C: FnMut(&EntryHeader, &[u8]) -> bool,
{
let sector_offset = self.state.sector_offset(sector_idx);
let write_offset = self.state.sectors[sector_idx as usize].write_offset;
let entry_start = SECTOR_HEADER_SIZE as u32;
let mut scanner = SectorScanner::new(sector_offset, entry_start, write_offset);
let mut header_buf = [0u8; ENTRY_HEADER_SIZE];
while let Some(entry) =
next_entry_async(&mut scanner, &mut self.flash, &mut header_buf, PAGE_SIZE).await?
{
if !accept_entry_async(&mut self.flash, sector_offset, &entry, buf).await? {
scanner.skip(1);
continue;
}
let sensor = entry.sensor_id();
if sensor_filter.is_none_or(|f| f == sensor)
&& deliver_samples(
entry.is_run(),
sensor,
entry.timestamp(),
&mut buf[..entry.payload_len],
t_start,
t_end,
count,
callback,
)
{
return Ok(true);
}
scanner.skip(entry.entry_size);
}
Ok(false)
}
async fn find_oldest_in_sector(
&mut self,
sector_idx: u16,
target_sensor: u16,
buf: &mut [u8],
) -> Result<Option<(EntryHeader, usize)>, Error> {
let sector_offset = self.state.sector_offset(sector_idx);
let write_offset = self.state.sectors[sector_idx as usize].write_offset;
let entry_start = SECTOR_HEADER_SIZE as u32;
let mut scanner = SectorScanner::new(sector_offset, entry_start, write_offset);
let mut header_buf = [0u8; ENTRY_HEADER_SIZE];
let mut payload_buf = [0u8; PAGE_SIZE];
while let Some(entry) =
next_entry_async(&mut scanner, &mut self.flash, &mut header_buf, PAGE_SIZE).await?
{
if !accept_entry_async(&mut self.flash, sector_offset, &entry, &mut payload_buf).await?
{
scanner.skip(1);
continue;
}
if entry.sensor_id() == target_sensor {
let (header, payload) =
entry.edge(&mut payload_buf[..entry.payload_len], Edge::First);
if payload.len() > buf.len() {
return Err(Error::BufferTooSmall);
}
buf[..payload.len()].copy_from_slice(payload);
return Ok(Some((header, payload.len())));
}
scanner.skip(entry.entry_size);
}
Ok(None)
}
async fn count_entries_before(
&mut self,
sector_idx: u16,
offset_limit: u32,
) -> Result<Replicated, Error> {
let sector_offset = self.state.sector_offset(sector_idx);
let entry_count = self.state.sectors[sector_idx as usize].entry_count;
let sample_count = self.state.sectors[sector_idx as usize].sample_count;
let write_offset = self.state.sectors[sector_idx as usize].write_offset;
let entry_start = SECTOR_HEADER_SIZE as u32;
let limit = offset_limit.min(write_offset);
if limit <= entry_start {
return Ok(Replicated::NONE);
}
let mut scanner = SectorScanner::new(sector_offset, entry_start, limit);
let mut header_buf = [0u8; ENTRY_HEADER_SIZE];
let mut buf = [0u8; PAGE_SIZE];
let mut found = Replicated::NONE;
while let Some(entry) =
next_entry_async(&mut scanner, &mut self.flash, &mut header_buf, PAGE_SIZE).await?
{
if !accept_entry_async(&mut self.flash, sector_offset, &entry, &mut buf).await? {
scanner.skip(1);
continue;
}
found.push(samples_in(entry.is_run(), &buf[..entry.payload_len]));
scanner.skip(entry.entry_size);
}
Ok(Replicated {
entries: found.entries.min(entry_count),
samples: found.samples.min(sample_count),
})
}
async fn count_sensor_in_sector(
&mut self,
sector_idx: u16,
target_sensor: u16,
) -> Result<u32, Error> {
let sector_offset = self.state.sector_offset(sector_idx);
let write_offset = self.state.sectors[sector_idx as usize].write_offset;
let entry_start = SECTOR_HEADER_SIZE as u32;
let mut scanner = SectorScanner::new(sector_offset, entry_start, write_offset);
let mut header_buf = [0u8; ENTRY_HEADER_SIZE];
let mut payload_buf = [0u8; PAGE_SIZE];
let mut count = 0u32;
while let Some(entry) =
next_entry_async(&mut scanner, &mut self.flash, &mut header_buf, PAGE_SIZE).await?
{
if !accept_entry_async(&mut self.flash, sector_offset, &entry, &mut payload_buf).await?
{
scanner.skip(1);
continue;
}
if entry.sensor_id() == target_sensor {
count += samples_in(entry.is_run(), &payload_buf[..entry.payload_len]);
}
scanner.skip(entry.entry_size);
}
Ok(count)
}
}
impl<F, const PAGE_SIZE: usize, const MAX_SECTORS: usize> crate::port::LogSinkAsync
for SensorDbAsync<F, PAGE_SIZE, MAX_SECTORS>
where
F: NorFlash + ReadNorFlash,
{
fn append(
&mut self,
sensor_id: u16,
timestamp: u64,
payload: &[u8],
) -> impl core::future::Future<Output = Result<(), Error>> {
SensorDbAsync::append(self, sensor_id, timestamp, payload)
}
fn append_run(
&mut self,
run: &Run<'_>,
) -> impl core::future::Future<Output = Result<(), Error>> {
SensorDbAsync::append_run(self, run)
}
fn sync(&mut self) -> impl core::future::Future<Output = Result<(), Error>> {
SensorDbAsync::sync(self)
}
}
impl<F, const PAGE_SIZE: usize, const MAX_SECTORS: usize> crate::port::LogSourceAsync
for SensorDbAsync<F, PAGE_SIZE, MAX_SECTORS>
where
F: NorFlash + ReadNorFlash,
{
fn latest(
&mut self,
sensor_id: u16,
buf: &mut [u8],
) -> impl core::future::Future<Output = Result<Option<(EntryHeader, usize)>, Error>> {
SensorDbAsync::latest(self, sensor_id, buf)
}
fn oldest(
&mut self,
sensor_id: u16,
buf: &mut [u8],
) -> impl core::future::Future<Output = Result<Option<(EntryHeader, usize)>, Error>> {
SensorDbAsync::oldest(self, sensor_id, buf)
}
fn count(
&mut self,
sensor_id: Option<u16>,
) -> impl core::future::Future<Output = Result<u32, Error>> {
SensorDbAsync::count(self, sensor_id)
}
fn query_range(
&mut self,
sensor_id: Option<u16>,
t_start: u64,
t_end: u64,
callback: &mut dyn FnMut(&EntryHeader, &[u8]) -> bool,
) -> impl core::future::Future<Output = Result<u32, Error>> {
SensorDbAsync::query_range(self, sensor_id, t_start, t_end, callback)
}
}
#[cfg(all(test, feature = "std", feature = "async"))]
mod tests {
extern crate alloc;
use alloc::vec;
use alloc::vec::Vec;
use super::*;
use crate::entry::{ENTRY_CRC_SIZE, EntryHeaderWire, FLAGS_COMMITTED, compute_entry_crc};
use crate::mock::{MockFlash, MockFlashAsync, block_on};
const PAGE: usize = 256;
const SECTOR: usize = 4096;
const SECTORS: usize = 8;
fn make_db() -> SensorDbAsync<MockFlashAsync<PAGE, SECTOR>, PAGE, SECTORS> {
let flash = MockFlashAsync::<PAGE, SECTOR>::new(SECTORS * SECTOR);
let mut db = SensorDbAsync::new(flash, 0, SECTORS as u16, 1).unwrap();
block_on(db.format()).unwrap();
db
}
#[test]
fn async_format_and_mount() {
let flash = MockFlashAsync::<PAGE, SECTOR>::new(SECTORS * SECTOR);
let mut db: SensorDbAsync<_, PAGE, SECTORS> =
SensorDbAsync::new(flash, 0, SECTORS as u16, 1).unwrap();
block_on(db.format()).unwrap();
assert!(db.is_mounted());
assert_eq!(db.stats().total_entries, 0);
}
#[test]
fn async_append_and_latest() {
let mut db = make_db();
let payload = [0xDE, 0xAD, 0xBE, 0xEF];
block_on(db.append(1, 1000, &payload)).unwrap();
block_on(db.append(2, 1001, &[0x42])).unwrap();
block_on(db.append(1, 1002, &[0x01, 0x02])).unwrap();
let mut buf = [0u8; 16];
let (hdr, n) = block_on(db.latest(1, &mut buf)).unwrap().unwrap();
assert_eq!(hdr.sensor_id, 1);
assert_eq!(hdr.timestamp, 1002);
assert_eq!(&buf[..n], &[0x01, 0x02]);
let (hdr2, n2) = block_on(db.latest(2, &mut buf)).unwrap().unwrap();
assert_eq!(hdr2.sensor_id, 2);
assert_eq!(&buf[..n2], &[0x42]);
}
#[test]
fn async_query_range_filters() {
let mut db = make_db();
block_on(db.append(1, 100, &[0x01])).unwrap();
block_on(db.append(1, 200, &[0x02])).unwrap();
block_on(db.append(2, 150, &[0x0A])).unwrap();
block_on(db.append(1, 300, &[0x03])).unwrap();
block_on(db.sync()).unwrap();
let mut results = Vec::new();
let count = block_on(db.query_range(Some(1), 100, 250, |hdr, payload| {
results.push((hdr.timestamp, payload[0]));
true
}))
.unwrap();
assert_eq!(count, 2);
assert_eq!(results, vec![(100, 0x01), (200, 0x02)]);
}
#[test]
fn async_survives_remount() {
let flash = MockFlashAsync::<PAGE, SECTOR>::new(SECTORS * SECTOR);
let mut db: SensorDbAsync<_, PAGE, SECTORS> =
SensorDbAsync::new(flash, 0, SECTORS as u16, 1).unwrap();
block_on(db.format()).unwrap();
block_on(db.append(5, 42, &[0xAA, 0xBB])).unwrap();
block_on(db.append(5, 43, &[0xCC])).unwrap();
block_on(db.sync()).unwrap();
let flash = db.into_inner();
let mut db2: SensorDbAsync<_, PAGE, SECTORS> =
SensorDbAsync::new(flash, 0, SECTORS as u16, 1).unwrap();
let mount_stats = block_on(db2.mount()).unwrap();
assert_eq!(mount_stats.total_entries, 2);
let mut buf = [0u8; 16];
let (hdr, n) = block_on(db2.latest(5, &mut buf)).unwrap().unwrap();
assert_eq!(hdr.timestamp, 43);
assert_eq!(&buf[..n], &[0xCC]);
}
#[test]
fn async_circular_wrap() {
const SMALL: usize = 4;
let flash = MockFlashAsync::<PAGE, SECTOR>::new(SMALL * SECTOR);
let mut db: SensorDbAsync<_, PAGE, SMALL> =
SensorDbAsync::new(flash, 0, SMALL as u16, 1).unwrap();
block_on(db.format()).unwrap();
for i in 0..800u64 {
let payload = (i as u32).to_le_bytes();
block_on(db.append(1, i * 100, &payload)).unwrap();
}
let stats = db.stats();
assert!(stats.total_entries > 0);
assert!(stats.used_sectors <= SMALL as u16);
let mut buf = [0u8; 4];
let (hdr, _) = block_on(db.latest(1, &mut buf)).unwrap().unwrap();
assert_eq!(hdr.timestamp, 799 * 100);
}
#[test]
fn async_compact() {
let mut db = make_db();
for i in 0..50u64 {
block_on(db.append(1, i, &[i as u8])).unwrap();
}
block_on(db.sync()).unwrap();
let before = db.stats();
let freed = block_on(db.compact(1, CompactScope::All)).unwrap();
let after = db.stats();
if before.used_sectors > 1 {
assert!(freed > 0);
assert!(after.free_sectors > before.free_sectors);
}
}
#[test]
fn async_oldest() {
let mut db = make_db();
block_on(db.append(1, 100, &[0x01])).unwrap();
block_on(db.append(1, 200, &[0x02])).unwrap();
block_on(db.append(1, 300, &[0x03])).unwrap();
block_on(db.sync()).unwrap();
let mut buf = [0u8; 16];
let (hdr, n) = block_on(db.oldest(1, &mut buf)).unwrap().unwrap();
assert_eq!(hdr.timestamp, 100);
assert_eq!(&buf[..n], &[0x01]);
}
#[test]
fn async_count() {
let mut db = make_db();
block_on(db.append(1, 100, &[0x01])).unwrap();
block_on(db.append(2, 200, &[0x02])).unwrap();
block_on(db.append(1, 300, &[0x03])).unwrap();
block_on(db.sync()).unwrap();
assert_eq!(block_on(db.count(None)).unwrap(), 3);
assert_eq!(block_on(db.count(Some(1))).unwrap(), 2);
assert_eq!(block_on(db.count(Some(2))).unwrap(), 1);
assert_eq!(block_on(db.count(Some(99))).unwrap(), 0);
}
#[test]
fn async_typed_api() {
use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
#[derive(Debug, Clone, Copy, PartialEq, FromBytes, IntoBytes, KnownLayout, Immutable)]
#[repr(C)]
struct Temp {
celsius: f32,
}
impl SensorData for Temp {
const SENSOR_ID: u16 = 0x01;
}
let mut db = make_db();
block_on(db.append_sensor(1000, &Temp { celsius: 25.5 })).unwrap();
block_on(db.append_sensor(2000, &Temp { celsius: 26.0 })).unwrap();
block_on(db.sync()).unwrap();
let (hdr, val) = block_on(db.latest_sensor::<Temp>()).unwrap().unwrap();
assert_eq!(hdr.timestamp, 2000);
assert_eq!(val.celsius, 26.0);
let (hdr, val) = block_on(db.oldest_sensor::<Temp>()).unwrap().unwrap();
assert_eq!(hdr.timestamp, 1000);
assert_eq!(val.celsius, 25.5);
assert_eq!(block_on(db.count_sensor::<Temp>()).unwrap(), 2);
}
#[test]
fn async_max_payload() {
let mut db = make_db();
let max = db.max_payload_size();
let payload = vec![0x42u8; max];
block_on(db.append(1, 999, &payload)).unwrap();
block_on(db.sync()).unwrap();
let mut buf = vec![0u8; max];
let (hdr, n) = block_on(db.latest(1, &mut buf)).unwrap().unwrap();
assert_eq!(n, max);
assert_eq!(hdr.payload_len as usize, max);
}
#[test]
fn async_rejects_oversized() {
let mut db = make_db();
let too_big = vec![0u8; db.max_payload_size() + 1];
let result = block_on(db.append(1, 100, &too_big));
assert!(result.is_err());
}
#[test]
fn async_scanner_resyncs_past_oversized_false_marker() {
use embedded_storage::nor_flash::NorFlash as SyncNorFlash;
use zerocopy::IntoBytes;
let mut raw = MockFlash::<PAGE, SECTOR>::new(SECTORS * SECTOR);
let mut page = [0xFFu8; PAGE];
let sh = SectorHeader::new(None, 1, 1, 1);
page[..SECTOR_HEADER_SIZE].copy_from_slice(sh.as_bytes());
let e1_off = SECTOR_HEADER_SIZE;
let e1_payload = [0x01u8, 0x02, 0x03, 0x04];
let mut e1 = EntryHeaderWire::new(1, 100, e1_payload.len() as u16);
let e1_crc = compute_entry_crc(&e1, &e1_payload, e1_off as u32);
e1.flags = FLAGS_COMMITTED;
page[e1_off..e1_off + ENTRY_HEADER_SIZE].copy_from_slice(e1.as_bytes());
page[e1_off + ENTRY_HEADER_SIZE..e1_off + ENTRY_HEADER_SIZE + e1_payload.len()]
.copy_from_slice(&e1_payload);
let e1_crc_off = e1_off + ENTRY_HEADER_SIZE + e1_payload.len();
page[e1_crc_off..e1_crc_off + ENTRY_CRC_SIZE].copy_from_slice(&e1_crc.to_le_bytes());
let forged_off = e1_crc_off + ENTRY_CRC_SIZE;
let mut forged = EntryHeaderWire::new(1, 0, 3840);
forged.flags = FLAGS_COMMITTED;
page[forged_off..forged_off + ENTRY_HEADER_SIZE].copy_from_slice(forged.as_bytes());
let e2_off = forged_off + ENTRY_HEADER_SIZE;
let e2_payload = [0x11u8, 0x22, 0x33, 0x44];
let mut e2 = EntryHeaderWire::new(1, 200, e2_payload.len() as u16);
let e2_crc = compute_entry_crc(&e2, &e2_payload, e2_off as u32);
e2.flags = FLAGS_COMMITTED;
page[e2_off..e2_off + ENTRY_HEADER_SIZE].copy_from_slice(e2.as_bytes());
page[e2_off + ENTRY_HEADER_SIZE..e2_off + ENTRY_HEADER_SIZE + e2_payload.len()]
.copy_from_slice(&e2_payload);
let e2_crc_off = e2_off + ENTRY_HEADER_SIZE + e2_payload.len();
page[e2_crc_off..e2_crc_off + ENTRY_CRC_SIZE].copy_from_slice(&e2_crc.to_le_bytes());
raw.write(0, &page).unwrap();
let flash = MockFlashAsync::<PAGE, SECTOR>::wrap(raw);
let mut db: SensorDbAsync<_, PAGE, SECTORS> =
SensorDbAsync::new(flash, 0, SECTORS as u16, 1).unwrap();
let stats = block_on(db.mount()).unwrap();
assert_eq!(
stats.total_entries, 2,
"both real entries found, forged skipped"
);
assert!(
stats.corrupt_entries > 0,
"forged marker counted as corrupt"
);
let mut buf = [0u8; 16];
let (hdr, n) = block_on(db.latest(1, &mut buf)).unwrap().unwrap();
assert_eq!(hdr.timestamp, 200);
assert_eq!(&buf[..n], &e2_payload);
}
#[test]
fn async_restore_spool_watermark_matches_the_blocking_driver() {
use crate::SensorDb;
let mut a = make_db();
let mut b: SensorDb<MockFlash<PAGE, SECTOR>, PAGE, SECTORS> =
SensorDb::new(MockFlash::new(SECTORS * SECTOR), 0, SECTORS as u16, 1).unwrap();
b.format().unwrap();
for i in 0..500u64 {
block_on(a.append(1, i, &[i as u8])).unwrap();
b.append(1, i, &[i as u8]).unwrap();
}
block_on(a.sync()).unwrap();
b.sync().unwrap();
let tail = a.tail_position();
let cut = block_on(a.read_from(tail, 137, |_, _, _| Ok(true)))
.unwrap()
.next;
assert!(
cut.offset > SECTOR_HEADER_SIZE as u32,
"the watermark must fall inside a sector for this test to mean anything"
);
block_on(a.restore_spool_watermark(cut)).unwrap();
b.restore_spool_watermark(cut).unwrap();
assert_eq!(a.spool_stats(), b.spool_stats());
let total = block_on(a.count(None)).unwrap();
assert_eq!(total - a.spool_stats().unspooled_entries, 137);
}
}