#[cfg(test)]
use super::SegConfig;
use super::{SegMap, SegTree};
use crate::codec::Codec;
use crate::error::{DbError, DbResult};
use crate::hook::TypedWriteHook;
use crate::hook::WriteHook;
use crate::key::Key;
use std::hash::Hash;
use std::marker::PhantomData;
use std::ops::ControlFlow;
struct ByteHook<'a, K, T, C, H> {
codec: &'a C,
hook: &'a H,
marker: PhantomData<fn() -> (K, T)>,
}
impl<K: Key, T, C: Codec<T>, H: TypedWriteHook<K, T>> WriteHook<K> for ByteHook<'_, K, T, C, H> {
const NEEDS_INIT: bool = false;
const NEEDS_WRITE: bool = H::NEEDS_WRITE;
const PROJECTS: bool = true;
const COUNTS: bool = true;
fn on_write(&self, key: &K, old: Option<&[u8]>, new: Option<&[u8]>) {
if !H::NEEDS_WRITE {
return;
}
let decode = |b: &[u8]| {
self.codec
.decode_from(b)
.map_err(|e| tracing::warn!(error=%e, "segmented on_write decode failed"))
.ok()
};
let old = old.and_then(decode);
let new = new.and_then(decode);
self.hook.on_write(key, old.as_ref(), new.as_ref());
}
fn project(
&self,
key: &K,
_: Option<&[u8]>,
new: Option<&[u8]>,
sink: &mut crate::ProjectionSink<'_>,
) -> DbResult<()> {
if let Some(bytes) = new {
self.hook
.project(key, &self.codec.decode_from(bytes)?, sink)?;
}
Ok(())
}
fn counter_project(
&self,
key: &K,
_: Option<&[u8]>,
new: Option<&[u8]>,
sink: &mut crate::CounterSink<'_>,
) -> DbResult<()> {
if let Some(bytes) = new {
self.hook
.counter_project(key, &self.codec.decode_from(bytes)?, sink)?;
}
Ok(())
}
}
#[cfg(feature = "test-faults")]
pub(crate) fn crash_at(boundary: &str) {
if std::env::var("ARMDB_MIGRATION_CRASH").ok().as_deref() == Some(boundary) {
std::process::exit(71);
}
}
macro_rules! impl_segmented_projections {
($facade:ident $(, $managed:meta)?) => {
impl<K, T, C, H> $facade<K, T, C, H>
where
K: Key + Hash + Eq + Send + Sync + 'static,
C: Codec<T>,
H: TypedWriteHook<K, T>,
{
$(#[$managed])?
pub(crate) fn migrate_rows(
&self,
f: impl Fn(&K, &T) -> crate::MigrateAction<T>,
) -> DbResult<usize> {
use crate::seg::index_migration::*;
let seg = self.hook.projection_targets().filter(|t| t.has_segmented());
let (rows, bytes) = self.effective_projection_limits();
let mut batch = MigrationBatch::new(batch_max_entries(), BATCH_MAX_BYTES);
let mut batch_no = 0u64;
let mut changed = 0usize;
let mut failure = None;
self.core().scan(&mut |row| {
let step = (|| -> DbResult<()> {
let (key, old_bytes) = row?;
let old = self.codec.decode_from(&old_bytes)?;
let action = f(&key, &old);
if matches!(action, crate::MigrateAction::Keep) {
return Ok(());
}
self.check_own_migration_action()?;
let new_bytes = match &action {
crate::MigrateAction::Update(new) => Some(self.codec.encode(new)?),
_ => None,
};
drop(action);
drop(old);
changed += 1;
let ops = match seg {
None => Vec::new(),
Some(targets) => {
let plan = crate::projection::diff_projection_bytes(
&self.byte_hook(),
targets,
rows,
bytes,
&key,
Some(&old_bytes),
new_bytes.as_deref(),
)?;
plan.check_segmented_ownership(key.as_bytes())?;
plan.segmented_ops()
}
};
if ops.is_empty() {
return self.apply_source_action(&key, new_bytes.as_deref());
}
let action = match new_bytes {
Some(b) => SourceAction::Put(b),
None => SourceAction::Delete,
};
let entry = BatchEntry {
key: key.as_bytes().to_vec(),
action,
ops,
};
if batch.must_drain_before(&entry) {
batch_no += 1;
self.apply_migration_batch(batch_no, batch.drain())?;
}
if batch.push(entry) {
batch_no += 1;
self.apply_migration_batch(batch_no, batch.drain())?;
}
Ok(())
})();
match step {
Ok(()) => ControlFlow::Continue(()),
Err(e) => {
failure = Some(e);
ControlFlow::Break(())
}
}
});
if let Some(e) = failure {
return Err(e);
}
if !batch.is_empty() {
batch_no += 1;
self.apply_migration_batch(batch_no, batch.drain())?;
}
Ok(changed)
}
fn apply_source_action(&self, key: &K, new: Option<&[u8]>) -> DbResult<()> {
let admission = crate::seg::freeze::Admission::until_seal_fails(&self.core().config)?;
match new {
Some(b) => self.core().put_with(key, b, admission),
None => self.core().delete_with(key, admission),
}
}
fn apply_migration_batch(
&self,
_batch_no: u64,
entries: Vec<crate::seg::index_migration::BatchEntry>,
) -> DbResult<()> {
let allocated = entries.capacity() * std::mem::size_of::<crate::seg::index_migration::BatchEntry>()
+ entries.iter().map(|entry| {
entry.key.capacity()
+ match &entry.action {
crate::seg::index_migration::SourceAction::Put(value) => value.capacity(),
crate::seg::index_migration::SourceAction::Delete => 0,
}
+ entry.ops.capacity() * std::mem::size_of::<crate::seg::index_migration::DerivedOp>()
+ entry.ops.iter().map(|op| op.key.capacity() + op.value.as_ref().map_or(0, Vec::capacity)).sum::<usize>()
}).sum::<usize>();
metrics::histogram!("armdb.seg.index_migration.batch_allocated_bytes", "collection" => self.name()).record(allocated as f64);
let targets = self
.hook
.projection_targets()
.ok_or(DbError::Internal("batch without targets"))?;
let mut touched: Vec<&'static str> = Vec::new();
for e in &entries {
for op in &e.ops {
let handle = targets
.segmented()
.find(|h| h.name == op.target)
.ok_or(DbError::UndeclaredIndexTarget { index: op.target })?;
let _cap = crate::index_maintenance::IndexMaintenance::enter(op.target);
match &op.value {
Some(v) => handle.inner.put_bytes(&op.key, v)?,
None => handle.inner.delete_bytes(&op.key)?,
}
if !touched.contains(&op.target) {
touched.push(op.target);
}
}
}
#[cfg(feature = "test-faults")]
crate::seg::projections::crash_at(&format!("segidx:derived:{_batch_no}"));
for name in &touched {
let handle = targets
.segmented()
.find(|h| h.name == *name)
.expect("touched target is declared");
handle.inner.durable_flush()?;
metrics::counter!("armdb.seg.index_migration.durable_flushes", "collection" => self.name(), "target" => *name).increment(1);
}
#[cfg(feature = "test-faults")]
crate::seg::projections::crash_at(&format!("segidx:flushed:{_batch_no}"));
for (_i, e) in entries.into_iter().enumerate() {
let key = K::from_bytes(&e.key);
match e.action {
crate::seg::index_migration::SourceAction::Put(b) => {
self.apply_source_action(&key, Some(&b))?
}
crate::seg::index_migration::SourceAction::Delete => {
self.apply_source_action(&key, None)?
}
}
#[cfg(feature = "test-faults")]
crate::seg::projections::crash_at(&format!("segidx:source:{_batch_no}:{}", _i + 1));
}
Ok(())
}
fn byte_hook(&self) -> ByteHook<'_, K, T, C, H> {
ByteHook {
codec: &self.codec,
hook: &self.hook,
marker: PhantomData,
}
}
pub fn hook_active(&self) -> bool {
H::NEEDS_WRITE
|| self.hook.projection_targets().is_some()
|| self.hook.counter_targets().is_some()
|| H::EMITS
}
pub(crate) fn facade_guard(&self) -> DbResult<()> {
if self.hook_active() {
Err(DbError::SegHookRequiresTx {
collection: self.name(),
})
} else {
Ok(())
}
}
pub fn effective_projection_limits(&self) -> (usize, usize) {
let (rows, bytes) = self.hook.projection_limits();
(
rows.min(crate::projection::DEFAULT_MAX_PROJECTED_ROWS),
bytes.min(crate::projection::DEFAULT_MAX_PROJECTED_BYTES),
)
}
$(#[$managed])?
fn scan_bytes(&self, visit: &mut dyn FnMut(&K, &[u8]) -> DbResult<()>) -> DbResult<()> {
let mut failure = None;
self.core().scan(&mut |row| match row.and_then(|(k, v)| {
crate::projection::reconcile_value_read_fault()?;
visit(&k, &v)
}) {
Ok(()) => ControlFlow::Continue(()),
Err(e) => {
failure = Some(e);
ControlFlow::Break(())
}
});
failure.map_or(Ok(()), Err)
}
$(#[$managed])?
pub(crate) fn backfill_index_target(&self, name: &'static str) -> DbResult<u64> {
let Some(targets) = self.hook.projection_targets() else {
return Ok(0);
};
let Some(handle) = targets.segmented().find(|h| h.name == name) else {
return Err(DbError::Internal("backfill: undeclared segmented target"));
};
let (rows, bytes) = self.effective_projection_limits();
let mut written = 0u64;
self.scan_bytes(&mut |key, value| {
let mut sink = crate::ProjectionSink::new(targets, rows, bytes);
self.byte_hook().project(key, None, Some(value), &mut sink)?;
for row in sink.rows() {
if targets.segmented().any(|h| h.name == row.target) {
crate::projection::check_owned_key(row.target, &row.key, key.as_bytes())?;
}
}
for row in sink.rows().iter().filter(|r| r.target == name) {
let _cap = crate::index_maintenance::IndexMaintenance::enter(name);
handle.inner.put_bytes(&row.key, &row.value)?;
written += 1;
#[cfg(feature = "test-faults")]
crate::seg::projections::crash_at(&format!("segidx:backfill:{written}"));
}
Ok(())
})?;
handle.inner.durable_flush()?;
#[cfg(feature = "test-faults")]
crate::seg::projections::crash_at("segidx:backfill-flushed");
Ok(written)
}
$(#[$managed])?
pub(crate) fn reconcile_projections(&self) -> DbResult<()> {
let Some(targets) = self.hook.projection_targets() else {
return Ok(());
};
let (rows, bytes) = self.effective_projection_limits();
crate::projection::reconcile_carrier_projections(
targets,
|emit| {
self.scan_bytes(&mut |key, value| {
let mut sink = crate::ProjectionSink::new(targets, rows, bytes);
self.byte_hook()
.project(key, None, Some(value), &mut sink)?;
for row in sink.rows() {
emit(row.target, &row.key, &row.value)?;
}
Ok(())
})
},
true,
)
}
$(#[$managed])?
pub(crate) fn reconcile_counters(&self) -> DbResult<u64> {
let Some(targets) = self.hook.counter_targets() else {
return Ok(0);
};
crate::counter::recount(
|key, value: &[u8], sink| {
self.byte_hook()
.counter_project(key, None, Some(value), sink)
},
targets,
self.effective_projection_limits(),
&mut |visit| self.scan_bytes(visit),
)
}
$(#[$managed])?
pub(crate) fn counter_target_names(&self) -> Vec<&'static str> {
self.hook
.counter_targets()
.map(|t| t.all().map(|m| m.collection_name()).collect())
.unwrap_or_default()
}
pub(crate) fn fire_event(&self, event: &(K, Option<Vec<u8>>, Option<Vec<u8>>)) {
self.byte_hook()
.on_write(&event.0, event.1.as_deref(), event.2.as_deref());
}
pub(crate) fn project_bytes(
&self,
key: &K,
old: Option<&[u8]>,
new: Option<&[u8]>,
) -> DbResult<Vec<crate::txn::participant::TxDerivedWrite>> {
let Some(targets) = self.hook.projection_targets() else {
return Ok(Vec::new());
};
let (rows, bytes) = self.effective_projection_limits();
let plan = crate::projection::diff_projection_bytes(
&self.byte_hook(),
targets,
rows,
bytes,
key,
old,
new,
)?;
plan.check_segmented_ownership(key.as_bytes())?;
plan.into_tx_derived(targets)
}
pub(crate) fn counter_bytes(
&self,
key: &K,
old: Option<&[u8]>,
new: Option<&[u8]>,
) -> DbResult<Vec<crate::txn::participant::TxCounterDelta>> {
let Some(targets) = self.hook.counter_targets() else {
return Ok(Vec::new());
};
let (rows, bytes) = self.effective_projection_limits();
let deltas = crate::counter::diff_counters_bytes(
&self.byte_hook(),
targets,
rows,
bytes,
key,
old,
new,
)?;
crate::counter::into_tx_counter_deltas(targets, deltas)
}
}
};
}
impl_segmented_projections!(SegMap);
impl_segmented_projections!(SegTree);
#[cfg(test)]
mod tests {
use super::*;
use crate::armour::Db;
use crate::counter_tests::Group;
use crate::seg::testkit::{TestKey, TextCodec, key_of, meta};
use crate::{Config, IndexTargets, NoHook, Projected, RapiraCodec};
#[test]
fn segmented_projection_decode_failure_preserves_orphans() {
let dir = tempfile::tempdir().unwrap();
let db = Db::open_test(dir.path()).unwrap();
let index = db
.open_var_typed_map::<Group, RapiraCodec, _>(Config::test(), NoHook, &[])
.unwrap();
let target = index.clone();
let hook = Projected::<TestKey, String>::new(
IndexTargets::new().with_index(&index),
move |_, value, sink| {
let n: u64 = value.parse().unwrap();
sink.row(&target, n.to_be_bytes(), Group { member_count: n })
},
);
let map = SegMap::open_deferred(
&dir.path().join("source"),
meta(),
SegConfig::test(),
TextCodec,
hook,
)
.unwrap();
for n in 0..20 {
map.core()
.put(&key_of(n), n.to_string().as_bytes())
.unwrap();
}
let mut order = Vec::new();
map.core().scan(&mut |row| {
order.push(row.unwrap().0);
ControlFlow::Continue(())
});
let bad = order.last().unwrap();
map.core().put(bad, &[0xff]).unwrap();
index
.put(&999u64.to_be_bytes(), &Group { member_count: 999 })
.unwrap();
let result = map.reconcile_projections();
assert!(index.try_get(&999u64.to_be_bytes()).unwrap().is_some());
assert!(matches!(result, Err(DbError::CorruptedEntry { .. })));
map.core().put(bad, b"500").unwrap();
map.reconcile_projections().unwrap();
assert!(index.try_get(&999u64.to_be_bytes()).unwrap().is_none());
assert!(index.try_get(&500u64.to_be_bytes()).unwrap().is_some());
}
#[test]
fn tree_reconcile_decode_failure_preserves_orphans() {
let dir = tempfile::tempdir().unwrap();
let db = Db::open_test(dir.path()).unwrap();
let index = db
.open_var_typed_map::<Group, RapiraCodec, _>(Config::test(), NoHook, &[])
.unwrap();
let target = index.clone();
let hook = Projected::<TestKey, String>::new(
IndexTargets::new().with_index(&index),
move |_, value, sink| {
let n: u64 = value.parse().unwrap();
sink.row(&target, n.to_be_bytes(), Group { member_count: n })
},
);
let map = crate::seg::SegTree::open_deferred(
&dir.path().join("source"),
meta(),
&[],
false,
SegConfig::test(),
TextCodec,
hook,
)
.unwrap();
for n in 0..300 {
map.core()
.put(&key_of(n), n.to_string().as_bytes())
.unwrap();
}
let mut order = Vec::new();
map.core().scan(&mut |row| {
order.push(row.unwrap().0);
ControlFlow::Continue(())
});
let bad = order.last().unwrap();
map.core().put(bad, &[0xff]).unwrap();
index
.put(&999u64.to_be_bytes(), &Group { member_count: 999 })
.unwrap();
map.seal().unwrap();
assert!(map.core().seal_oldest().unwrap());
map.try_get(&order[0]).unwrap();
let before = (map.stats().cache_hits, map.stats().cache_misses);
assert!(matches!(
map.project_bytes(bad, Some(&[0xff]), Some(b"500")),
Err(DbError::CorruptedEntry { .. })
));
let result = map.reconcile_projections();
assert_eq!((map.stats().cache_hits, map.stats().cache_misses), before);
assert!(index.try_get(&999u64.to_be_bytes()).unwrap().is_some());
assert!(matches!(result, Err(DbError::CorruptedEntry { .. })));
map.core().put(bad, b"500").unwrap();
map.reconcile_projections().unwrap();
assert_eq!((map.stats().cache_hits, map.stats().cache_misses), before);
assert!(index.try_get(&999u64.to_be_bytes()).unwrap().is_none());
assert!(index.try_get(&500u64.to_be_bytes()).unwrap().is_some());
}
}