mod noncanonical;
mod pruning;
#[cfg(test)]
mod test;
use codec::Codec;
use log::trace;
use noncanonical::NonCanonicalOverlay;
use parking_lot::RwLock;
use pruning::{HaveBlock, RefWindow};
use std::{
collections::{hash_map::Entry, HashMap},
fmt,
};
const LOG_TARGET: &str = "state-db";
const LOG_TARGET_PIN: &str = "state-db::pin";
const PRUNING_MODE: &[u8] = b"mode";
const PRUNING_MODE_ARCHIVE: &[u8] = b"archive";
const PRUNING_MODE_ARCHIVE_CANON: &[u8] = b"archive_canonical";
const PRUNING_MODE_CONSTRAINED: &[u8] = b"constrained";
pub(crate) const DEFAULT_MAX_BLOCK_CONSTRAINT: u32 = 256;
pub type DBValue = Vec<u8>;
pub trait Hash:
Send
+ Sync
+ Sized
+ Eq
+ PartialEq
+ Clone
+ Default
+ fmt::Debug
+ Codec
+ std::hash::Hash
+ 'static
{
}
impl<
T: Send
+ Sync
+ Sized
+ Eq
+ PartialEq
+ Clone
+ Default
+ fmt::Debug
+ Codec
+ std::hash::Hash
+ 'static,
> Hash for T
{
}
pub trait MetaDb {
type Error: fmt::Debug;
fn get_meta(&self, key: &[u8]) -> Result<Option<DBValue>, Self::Error>;
}
pub trait NodeDb {
type Key: ?Sized;
type Error: fmt::Debug;
fn get(&self, key: &Self::Key) -> Result<Option<DBValue>, Self::Error>;
}
#[derive(Eq, PartialEq)]
pub enum Error<E> {
Db(E),
StateDb(StateDbError),
}
#[derive(Eq, PartialEq)]
pub enum StateDbError {
Decoding(codec::Error),
InvalidBlock,
InvalidBlockNumber,
InvalidParent,
IncompatiblePruningModes { stored: PruningMode, requested: PruningMode },
TooManySiblingBlocks { number: u64 },
BlockAlreadyExists,
Metadata(String),
BlockUnavailable,
BlockMissing,
}
impl<E> From<StateDbError> for Error<E> {
fn from(inner: StateDbError) -> Self {
Self::StateDb(inner)
}
}
#[derive(Debug)]
pub enum PinError {
InvalidBlock,
}
impl<E: fmt::Debug> From<codec::Error> for Error<E> {
fn from(x: codec::Error) -> Self {
StateDbError::Decoding(x).into()
}
}
impl<E: fmt::Debug> fmt::Debug for Error<E> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
Self::Db(e) => e.fmt(f),
Self::StateDb(e) => e.fmt(f),
}
}
}
impl fmt::Debug for StateDbError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
Self::Decoding(e) => write!(f, "Error decoding sliceable value: {}", e),
Self::InvalidBlock => write!(f, "Trying to canonicalize invalid block"),
Self::InvalidBlockNumber => write!(f, "Trying to insert block with invalid number"),
Self::InvalidParent => write!(f, "Trying to insert block with unknown parent"),
Self::IncompatiblePruningModes { stored, requested } => write!(
f,
"Incompatible pruning modes [stored: {:?}; requested: {:?}]",
stored, requested
),
Self::TooManySiblingBlocks { number } => {
write!(f, "Too many sibling blocks at #{number} inserted")
},
Self::BlockAlreadyExists => write!(f, "Block already exists"),
Self::Metadata(message) => write!(f, "Invalid metadata: {}", message),
Self::BlockUnavailable => {
write!(f, "Trying to get a block record from db while it is not commit to db yet")
},
Self::BlockMissing => write!(f, "Block record is missing from the pruning window"),
}
}
}
#[derive(Default, Debug, Clone)]
pub struct ChangeSet<H: Hash> {
pub inserted: Vec<(H, DBValue)>,
pub deleted: Vec<H>,
}
#[derive(Default, Debug, Clone)]
pub struct CommitSet<H: Hash> {
pub data: ChangeSet<H>,
pub meta: ChangeSet<Vec<u8>>,
}
#[derive(Debug, Clone, Eq, PartialEq)]
pub struct Constraints {
pub max_blocks: Option<u32>,
}
#[derive(Debug, Clone, Eq, PartialEq)]
pub enum PruningMode {
Constrained(Constraints),
ArchiveAll,
ArchiveCanonical,
}
impl PruningMode {
pub fn blocks_pruning(n: u32) -> PruningMode {
PruningMode::Constrained(Constraints { max_blocks: Some(n) })
}
pub fn is_archive(&self) -> bool {
match *self {
PruningMode::ArchiveAll | PruningMode::ArchiveCanonical => true,
PruningMode::Constrained(_) => false,
}
}
pub fn id(&self) -> &[u8] {
match self {
PruningMode::ArchiveAll => PRUNING_MODE_ARCHIVE,
PruningMode::ArchiveCanonical => PRUNING_MODE_ARCHIVE_CANON,
PruningMode::Constrained(_) => PRUNING_MODE_CONSTRAINED,
}
}
pub fn from_id(id: &[u8]) -> Option<Self> {
match id {
PRUNING_MODE_ARCHIVE => Some(Self::ArchiveAll),
PRUNING_MODE_ARCHIVE_CANON => Some(Self::ArchiveCanonical),
PRUNING_MODE_CONSTRAINED => Some(Self::Constrained(Default::default())),
_ => None,
}
}
}
impl Default for PruningMode {
fn default() -> Self {
PruningMode::Constrained(Default::default())
}
}
impl Default for Constraints {
fn default() -> Self {
Self { max_blocks: Some(DEFAULT_MAX_BLOCK_CONSTRAINT) }
}
}
fn to_meta_key<S: Codec>(suffix: &[u8], data: &S) -> Vec<u8> {
let mut buffer = data.encode();
buffer.extend(suffix);
buffer
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum LastCanonicalized {
None,
Block(u64),
NotCanonicalizing,
}
pub struct StateDbSync<BlockHash: Hash, Key: Hash, D: MetaDb> {
mode: PruningMode,
non_canonical: NonCanonicalOverlay<BlockHash, Key>,
pruning: Option<RefWindow<BlockHash, Key, D>>,
pinned: HashMap<BlockHash, u32>,
ref_counting: bool,
}
impl<BlockHash: Hash, Key: Hash, D: MetaDb> StateDbSync<BlockHash, Key, D> {
fn new(
mode: PruningMode,
ref_counting: bool,
db: D,
) -> Result<StateDbSync<BlockHash, Key, D>, Error<D::Error>> {
trace!(target: LOG_TARGET, "StateDb settings: {:?}. Ref-counting: {}", mode, ref_counting);
let non_canonical: NonCanonicalOverlay<BlockHash, Key> = NonCanonicalOverlay::new(&db)?;
let pruning: Option<RefWindow<BlockHash, Key, D>> = match mode {
PruningMode::Constrained(Constraints { max_blocks }) =>
Some(RefWindow::new(db, max_blocks.unwrap_or(0), ref_counting)?),
PruningMode::ArchiveAll | PruningMode::ArchiveCanonical => None,
};
Ok(StateDbSync { mode, non_canonical, pruning, pinned: Default::default(), ref_counting })
}
fn insert_block(
&mut self,
hash: &BlockHash,
number: u64,
parent_hash: &BlockHash,
mut changeset: ChangeSet<Key>,
) -> Result<CommitSet<Key>, Error<D::Error>> {
match self.mode {
PruningMode::ArchiveAll => {
changeset.deleted.clear();
Ok(CommitSet { data: changeset, meta: Default::default() })
},
PruningMode::Constrained(_) | PruningMode::ArchiveCanonical => self
.non_canonical
.insert(hash, number, parent_hash, changeset)
.map_err(Into::into),
}
}
fn canonicalize_block(&mut self, hash: &BlockHash) -> Result<CommitSet<Key>, Error<D::Error>> {
let mut commit = CommitSet::default();
if self.mode == PruningMode::ArchiveAll {
return Ok(commit)
}
let number = self.non_canonical.canonicalize(hash, &mut commit)?;
if self.mode == PruningMode::ArchiveCanonical {
commit.data.deleted.clear();
}
if let Some(ref mut pruning) = self.pruning {
pruning.note_canonical(hash, number, &mut commit)?;
}
self.prune(&mut commit)?;
Ok(commit)
}
fn last_canonicalized(&self) -> LastCanonicalized {
if self.mode == PruningMode::ArchiveAll {
LastCanonicalized::NotCanonicalizing
} else {
self.non_canonical
.last_canonicalized_block_number()
.map(LastCanonicalized::Block)
.unwrap_or_else(|| LastCanonicalized::None)
}
}
fn is_pruned(&self, hash: &BlockHash, number: u64) -> IsPruned {
match self.mode {
PruningMode::ArchiveAll => IsPruned::NotPruned,
PruningMode::ArchiveCanonical | PruningMode::Constrained(_) => {
if self
.non_canonical
.last_canonicalized_block_number()
.map(|c| number > c)
.unwrap_or(true)
{
if self.non_canonical.have_block(hash) {
IsPruned::NotPruned
} else {
IsPruned::Pruned
}
} else {
match self.pruning.as_ref() {
None => IsPruned::MaybePruned,
Some(pruning) => match pruning.have_block(hash, number) {
HaveBlock::No => IsPruned::Pruned,
HaveBlock::Yes => IsPruned::NotPruned,
HaveBlock::Maybe => IsPruned::MaybePruned,
},
}
}
},
}
}
fn prune(&mut self, commit: &mut CommitSet<Key>) -> Result<(), Error<D::Error>> {
if let (&mut Some(ref mut pruning), PruningMode::Constrained(constraints)) =
(&mut self.pruning, &self.mode)
{
loop {
if pruning.window_size() <= constraints.max_blocks.unwrap_or(0) as u64 {
break
}
let pinned = &self.pinned;
match pruning.next_hash() {
Err(Error::StateDb(StateDbError::BlockUnavailable)) => break,
res =>
if res?.map_or(false, |h| pinned.contains_key(&h)) {
break
},
}
match pruning.prune_one(commit) {
Err(Error::StateDb(StateDbError::BlockUnavailable)) => break,
res => res?,
}
}
}
Ok(())
}
fn revert_one(&mut self) -> Option<CommitSet<Key>> {
match self.mode {
PruningMode::ArchiveAll => Some(CommitSet::default()),
PruningMode::ArchiveCanonical | PruningMode::Constrained(_) =>
self.non_canonical.revert_one(),
}
}
fn remove(&mut self, hash: &BlockHash) -> Option<CommitSet<Key>> {
match self.mode {
PruningMode::ArchiveAll => Some(CommitSet::default()),
PruningMode::ArchiveCanonical | PruningMode::Constrained(_) =>
self.non_canonical.remove(hash),
}
}
fn pin<F>(&mut self, hash: &BlockHash, number: u64, hint: F) -> Result<(), PinError>
where
F: Fn() -> bool,
{
match self.mode {
PruningMode::ArchiveAll => Ok(()),
PruningMode::ArchiveCanonical | PruningMode::Constrained(_) => {
let have_block = self.non_canonical.have_block(hash) ||
self.pruning.as_ref().map_or_else(
|| hint(),
|pruning| match pruning.have_block(hash, number) {
HaveBlock::No => false,
HaveBlock::Yes => true,
HaveBlock::Maybe => hint(),
},
);
if have_block {
let refs = self.pinned.entry(hash.clone()).or_default();
if *refs == 0 {
trace!(target: LOG_TARGET_PIN, "Pinned block: {:?}", hash);
self.non_canonical.pin(hash);
}
*refs += 1;
Ok(())
} else {
Err(PinError::InvalidBlock)
}
},
}
}
fn unpin(&mut self, hash: &BlockHash) {
match self.pinned.entry(hash.clone()) {
Entry::Occupied(mut entry) => {
*entry.get_mut() -= 1;
if *entry.get() == 0 {
trace!(target: LOG_TARGET_PIN, "Unpinned block: {:?}", hash);
entry.remove();
self.non_canonical.unpin(hash);
} else {
trace!(target: LOG_TARGET_PIN, "Releasing reference for {:?}", hash);
}
},
Entry::Vacant(_) => {},
}
}
fn sync(&mut self) {
self.non_canonical.sync();
}
pub fn get<DB: NodeDb, Q: ?Sized>(
&self,
key: &Q,
db: &DB,
) -> Result<Option<DBValue>, Error<DB::Error>>
where
Q: AsRef<DB::Key>,
Key: std::borrow::Borrow<Q>,
Q: std::hash::Hash + Eq,
{
if let Some(value) = self.non_canonical.get(key) {
return Ok(Some(value))
}
db.get(key.as_ref()).map_err(Error::Db)
}
}
pub struct StateDb<BlockHash: Hash, Key: Hash, D: MetaDb> {
db: RwLock<StateDbSync<BlockHash, Key, D>>,
}
impl<BlockHash: Hash, Key: Hash, D: MetaDb> StateDb<BlockHash, Key, D> {
pub fn open(
db: D,
requested_mode: Option<PruningMode>,
ref_counting: bool,
should_init: bool,
) -> Result<(CommitSet<Key>, StateDb<BlockHash, Key, D>), Error<D::Error>> {
let stored_mode = fetch_stored_pruning_mode(&db)?;
let selected_mode = match (should_init, stored_mode, requested_mode) {
(true, stored_mode, requested_mode) => {
assert!(stored_mode.is_none(), "The storage has just been initialized. No meta-data is expected to be found in it.");
requested_mode.unwrap_or_default()
},
(false, None, _) =>
return Err(StateDbError::Metadata(
"An existing StateDb does not have PRUNING_MODE stored in its meta-data".into(),
)
.into()),
(false, Some(stored), None) => stored,
(false, Some(stored), Some(requested)) => choose_pruning_mode(stored, requested)?,
};
let db_init_commit_set = if should_init {
let mut cs: CommitSet<Key> = Default::default();
let key = to_meta_key(PRUNING_MODE, &());
let value = selected_mode.id().to_owned();
cs.meta.inserted.push((key, value));
cs
} else {
Default::default()
};
let state_db =
StateDb { db: RwLock::new(StateDbSync::new(selected_mode, ref_counting, db)?) };
Ok((db_init_commit_set, state_db))
}
pub fn pruning_mode(&self) -> PruningMode {
self.db.read().mode.clone()
}
pub fn insert_block(
&self,
hash: &BlockHash,
number: u64,
parent_hash: &BlockHash,
changeset: ChangeSet<Key>,
) -> Result<CommitSet<Key>, Error<D::Error>> {
self.db.write().insert_block(hash, number, parent_hash, changeset)
}
pub fn canonicalize_block(&self, hash: &BlockHash) -> Result<CommitSet<Key>, Error<D::Error>> {
self.db.write().canonicalize_block(hash)
}
pub fn pin<F>(&self, hash: &BlockHash, number: u64, hint: F) -> Result<(), PinError>
where
F: Fn() -> bool,
{
self.db.write().pin(hash, number, hint)
}
pub fn unpin(&self, hash: &BlockHash) {
self.db.write().unpin(hash)
}
pub fn sync(&self) {
self.db.write().sync()
}
pub fn get<DB: NodeDb, Q: ?Sized>(
&self,
key: &Q,
db: &DB,
) -> Result<Option<DBValue>, Error<DB::Error>>
where
Q: AsRef<DB::Key>,
Key: std::borrow::Borrow<Q>,
Q: std::hash::Hash + Eq,
{
self.db.read().get(key, db)
}
pub fn revert_one(&self) -> Option<CommitSet<Key>> {
self.db.write().revert_one()
}
pub fn remove(&self, hash: &BlockHash) -> Option<CommitSet<Key>> {
self.db.write().remove(hash)
}
pub fn last_canonicalized(&self) -> LastCanonicalized {
self.db.read().last_canonicalized()
}
pub fn is_pruned(&self, hash: &BlockHash, number: u64) -> IsPruned {
self.db.read().is_pruned(hash, number)
}
pub fn reset(&self, db: D) -> Result<(), Error<D::Error>> {
let mut state_db = self.db.write();
*state_db = StateDbSync::new(state_db.mode.clone(), state_db.ref_counting, db)?;
Ok(())
}
}
#[derive(Debug, PartialEq, Eq)]
pub enum IsPruned {
Pruned,
NotPruned,
MaybePruned,
}
fn fetch_stored_pruning_mode<D: MetaDb>(db: &D) -> Result<Option<PruningMode>, Error<D::Error>> {
let meta_key_mode = to_meta_key(PRUNING_MODE, &());
if let Some(stored_mode) = db.get_meta(&meta_key_mode).map_err(Error::Db)? {
if let Some(mode) = PruningMode::from_id(&stored_mode) {
Ok(Some(mode))
} else {
Err(StateDbError::Metadata(format!(
"Invalid value stored for PRUNING_MODE: {:02x?}",
stored_mode
))
.into())
}
} else {
Ok(None)
}
}
fn choose_pruning_mode(
stored: PruningMode,
requested: PruningMode,
) -> Result<PruningMode, StateDbError> {
match (stored, requested) {
(PruningMode::ArchiveAll, PruningMode::ArchiveAll) => Ok(PruningMode::ArchiveAll),
(PruningMode::ArchiveCanonical, PruningMode::ArchiveCanonical) =>
Ok(PruningMode::ArchiveCanonical),
(PruningMode::Constrained(_), PruningMode::Constrained(requested)) =>
Ok(PruningMode::Constrained(requested)),
(stored, requested) => Err(StateDbError::IncompatiblePruningModes { requested, stored }),
}
}
#[cfg(test)]
mod tests {
use crate::{
test::{make_changeset, make_db, TestDb},
Constraints, Error, IsPruned, PruningMode, StateDb, StateDbError,
};
use sp_core::H256;
fn make_test_db(settings: PruningMode) -> (TestDb, StateDb<H256, H256, TestDb>) {
let mut db = make_db(&[91, 921, 922, 93, 94]);
let (state_db_init, state_db) =
StateDb::open(db.clone(), Some(settings), false, true).unwrap();
db.commit(&state_db_init);
db.commit(
&state_db
.insert_block(
&H256::from_low_u64_be(1),
1,
&H256::from_low_u64_be(0),
make_changeset(&[1], &[91]),
)
.unwrap(),
);
db.commit(
&state_db
.insert_block(
&H256::from_low_u64_be(21),
2,
&H256::from_low_u64_be(1),
make_changeset(&[21], &[921, 1]),
)
.unwrap(),
);
db.commit(
&state_db
.insert_block(
&H256::from_low_u64_be(22),
2,
&H256::from_low_u64_be(1),
make_changeset(&[22], &[922]),
)
.unwrap(),
);
db.commit(
&state_db
.insert_block(
&H256::from_low_u64_be(3),
3,
&H256::from_low_u64_be(21),
make_changeset(&[3], &[93]),
)
.unwrap(),
);
db.commit(&state_db.canonicalize_block(&H256::from_low_u64_be(1)).unwrap());
db.commit(
&state_db
.insert_block(
&H256::from_low_u64_be(4),
4,
&H256::from_low_u64_be(3),
make_changeset(&[4], &[94]),
)
.unwrap(),
);
db.commit(&state_db.canonicalize_block(&H256::from_low_u64_be(21)).unwrap());
db.commit(&state_db.canonicalize_block(&H256::from_low_u64_be(3)).unwrap());
(db, state_db)
}
#[test]
fn full_archive_keeps_everything() {
let (db, sdb) = make_test_db(PruningMode::ArchiveAll);
assert!(db.data_eq(&make_db(&[1, 21, 22, 3, 4, 91, 921, 922, 93, 94])));
assert_eq!(sdb.is_pruned(&H256::from_low_u64_be(0), 0), IsPruned::NotPruned);
}
#[test]
fn canonical_archive_keeps_canonical() {
let (db, _) = make_test_db(PruningMode::ArchiveCanonical);
assert!(db.data_eq(&make_db(&[1, 21, 3, 91, 921, 922, 93, 94])));
}
#[test]
fn block_record_unavailable() {
let (mut db, state_db) =
make_test_db(PruningMode::Constrained(Constraints { max_blocks: Some(1) }));
for i in &[5, 6] {
db.commit(
&state_db
.insert_block(
&H256::from_low_u64_be(*i),
*i,
&H256::from_low_u64_be(*i - 1),
make_changeset(&[], &[]),
)
.unwrap(),
);
}
let c1 = state_db.canonicalize_block(&H256::from_low_u64_be(4)).unwrap();
assert_eq!(state_db.is_pruned(&H256::from_low_u64_be(3), 3), IsPruned::Pruned);
let c2 = state_db.canonicalize_block(&H256::from_low_u64_be(5)).unwrap();
assert_eq!(state_db.is_pruned(&H256::from_low_u64_be(4), 4), IsPruned::MaybePruned);
db.commit(&c1);
db.commit(&c2);
db.commit(&state_db.canonicalize_block(&H256::from_low_u64_be(6)).unwrap());
assert_eq!(state_db.is_pruned(&H256::from_low_u64_be(4), 4), IsPruned::Pruned);
assert_eq!(state_db.is_pruned(&H256::from_low_u64_be(5), 5), IsPruned::Pruned);
}
#[test]
fn prune_window_0() {
let (db, _) = make_test_db(PruningMode::Constrained(Constraints { max_blocks: Some(0) }));
assert!(db.data_eq(&make_db(&[21, 3, 922, 94])));
}
#[test]
fn prune_window_1() {
let (db, sdb) = make_test_db(PruningMode::Constrained(Constraints { max_blocks: Some(1) }));
assert_eq!(sdb.is_pruned(&H256::from_low_u64_be(0), 0), IsPruned::Pruned);
assert_eq!(sdb.is_pruned(&H256::from_low_u64_be(1), 1), IsPruned::Pruned);
assert_eq!(sdb.is_pruned(&H256::from_low_u64_be(21), 2), IsPruned::Pruned);
assert_eq!(sdb.is_pruned(&H256::from_low_u64_be(22), 2), IsPruned::Pruned);
assert!(db.data_eq(&make_db(&[21, 3, 922, 93, 94])));
}
#[test]
fn prune_window_2() {
let (db, sdb) = make_test_db(PruningMode::Constrained(Constraints { max_blocks: Some(2) }));
assert_eq!(sdb.is_pruned(&H256::from_low_u64_be(0), 0), IsPruned::Pruned);
assert_eq!(sdb.is_pruned(&H256::from_low_u64_be(1), 1), IsPruned::Pruned);
assert_eq!(sdb.is_pruned(&H256::from_low_u64_be(21), 2), IsPruned::NotPruned);
assert_eq!(sdb.is_pruned(&H256::from_low_u64_be(22), 2), IsPruned::Pruned);
assert!(db.data_eq(&make_db(&[1, 21, 3, 921, 922, 93, 94])));
}
#[test]
fn detects_incompatible_mode() {
let mut db = make_db(&[]);
let (state_db_init, state_db) =
StateDb::open(db.clone(), Some(PruningMode::ArchiveAll), false, true).unwrap();
db.commit(&state_db_init);
db.commit(
&state_db
.insert_block(
&H256::from_low_u64_be(0),
0,
&H256::from_low_u64_be(0),
make_changeset(&[], &[]),
)
.unwrap(),
);
let new_mode = PruningMode::Constrained(Constraints { max_blocks: Some(2) });
let state_db_open_result: Result<(_, StateDb<H256, H256, TestDb>), _> =
StateDb::open(db.clone(), Some(new_mode), false, false);
assert!(state_db_open_result.is_err());
}
fn check_stored_and_requested_mode_compatibility(
mode_when_created: Option<PruningMode>,
mode_when_reopened: Option<PruningMode>,
expected_effective_mode_when_reopened: Result<PruningMode, ()>,
) {
let mut db = make_db(&[]);
let (state_db_init, state_db) =
StateDb::<H256, H256, TestDb>::open(db.clone(), mode_when_created, false, true)
.unwrap();
db.commit(&state_db_init);
std::mem::drop(state_db);
let state_db_reopen_result =
StateDb::<H256, H256, TestDb>::open(db.clone(), mode_when_reopened, false, false);
if let Ok(expected_mode) = expected_effective_mode_when_reopened {
let (state_db_init, state_db_reopened) = state_db_reopen_result.unwrap();
db.commit(&state_db_init);
assert_eq!(state_db_reopened.pruning_mode(), expected_mode,)
} else {
assert!(matches!(
state_db_reopen_result,
Err(Error::StateDb(StateDbError::IncompatiblePruningModes { .. }))
));
}
}
#[test]
fn pruning_mode_compatibility() {
for (created, reopened, expected) in [
(None, None, Ok(PruningMode::blocks_pruning(256))),
(None, Some(PruningMode::blocks_pruning(256)), Ok(PruningMode::blocks_pruning(256))),
(None, Some(PruningMode::blocks_pruning(128)), Ok(PruningMode::blocks_pruning(128))),
(None, Some(PruningMode::blocks_pruning(512)), Ok(PruningMode::blocks_pruning(512))),
(None, Some(PruningMode::ArchiveAll), Err(())),
(None, Some(PruningMode::ArchiveCanonical), Err(())),
(Some(PruningMode::blocks_pruning(256)), None, Ok(PruningMode::blocks_pruning(256))),
(
Some(PruningMode::blocks_pruning(256)),
Some(PruningMode::blocks_pruning(256)),
Ok(PruningMode::blocks_pruning(256)),
),
(
Some(PruningMode::blocks_pruning(256)),
Some(PruningMode::blocks_pruning(128)),
Ok(PruningMode::blocks_pruning(128)),
),
(
Some(PruningMode::blocks_pruning(256)),
Some(PruningMode::blocks_pruning(512)),
Ok(PruningMode::blocks_pruning(512)),
),
(Some(PruningMode::blocks_pruning(256)), Some(PruningMode::ArchiveAll), Err(())),
(Some(PruningMode::blocks_pruning(256)), Some(PruningMode::ArchiveCanonical), Err(())),
(Some(PruningMode::ArchiveAll), None, Ok(PruningMode::ArchiveAll)),
(Some(PruningMode::ArchiveAll), Some(PruningMode::blocks_pruning(256)), Err(())),
(Some(PruningMode::ArchiveAll), Some(PruningMode::blocks_pruning(128)), Err(())),
(Some(PruningMode::ArchiveAll), Some(PruningMode::blocks_pruning(512)), Err(())),
(
Some(PruningMode::ArchiveAll),
Some(PruningMode::ArchiveAll),
Ok(PruningMode::ArchiveAll),
),
(Some(PruningMode::ArchiveAll), Some(PruningMode::ArchiveCanonical), Err(())),
(Some(PruningMode::ArchiveCanonical), None, Ok(PruningMode::ArchiveCanonical)),
(Some(PruningMode::ArchiveCanonical), Some(PruningMode::blocks_pruning(256)), Err(())),
(Some(PruningMode::ArchiveCanonical), Some(PruningMode::blocks_pruning(128)), Err(())),
(Some(PruningMode::ArchiveCanonical), Some(PruningMode::blocks_pruning(512)), Err(())),
(Some(PruningMode::ArchiveCanonical), Some(PruningMode::ArchiveAll), Err(())),
(
Some(PruningMode::ArchiveCanonical),
Some(PruningMode::ArchiveCanonical),
Ok(PruningMode::ArchiveCanonical),
),
] {
check_stored_and_requested_mode_compatibility(created, reopened, expected);
}
}
}