9b4a0607ea
- Define error types for arrays - Propagate low-level errors to tools - Rename array_block.rs to array.rs
134 lines
3.2 KiB
Rust
134 lines
3.2 KiB
Rust
use nom::{multi::count, number::complete::*, IResult};
|
|
use thiserror::Error;
|
|
|
|
use crate::io_engine::BLOCK_SIZE;
|
|
use crate::pdata::btree;
|
|
use crate::pdata::unpack::Unpack;
|
|
|
|
//------------------------------------------
|
|
|
|
const ARRAY_BLOCK_HEADER_SIZE: u32 = 24;
|
|
|
|
pub struct ArrayBlockHeader {
|
|
pub csum: u32,
|
|
pub max_entries: u32,
|
|
pub nr_entries: u32,
|
|
pub value_size: u32,
|
|
pub blocknr: u64,
|
|
}
|
|
|
|
impl Unpack for ArrayBlockHeader {
|
|
fn disk_size() -> u32 {
|
|
ARRAY_BLOCK_HEADER_SIZE
|
|
}
|
|
|
|
fn unpack(data: &[u8]) -> IResult<&[u8], ArrayBlockHeader> {
|
|
let (i, csum) = le_u32(data)?;
|
|
let (i, max_entries) = le_u32(i)?;
|
|
let (i, nr_entries) = le_u32(i)?;
|
|
let (i, value_size) = le_u32(i)?;
|
|
let (i, blocknr) = le_u64(i)?;
|
|
|
|
Ok((
|
|
i,
|
|
ArrayBlockHeader {
|
|
csum,
|
|
max_entries,
|
|
nr_entries,
|
|
value_size,
|
|
blocknr,
|
|
},
|
|
))
|
|
}
|
|
}
|
|
|
|
pub struct ArrayBlock<V: Unpack> {
|
|
pub header: ArrayBlockHeader,
|
|
pub values: Vec<V>,
|
|
}
|
|
|
|
//------------------------------------------
|
|
|
|
#[derive(Error, Clone, Debug)]
|
|
pub enum ArrayError {
|
|
#[error("io_error")]
|
|
IoError,
|
|
|
|
#[error("block error: {0}")]
|
|
BlockError(String),
|
|
|
|
#[error("value error: {0}")]
|
|
ValueError(String),
|
|
|
|
#[error("aggregate: {0:?}")]
|
|
Aggregate(Vec<ArrayError>),
|
|
|
|
#[error("{0:?}, {1}")]
|
|
Path(Vec<u64>, Box<ArrayError>),
|
|
|
|
#[error(transparent)]
|
|
BTreeError(#[from] btree::BTreeError),
|
|
}
|
|
|
|
pub fn array_block_err(path: &[u64], msg: &str) -> ArrayError {
|
|
ArrayError::Path(
|
|
path.to_vec(),
|
|
Box::new(ArrayError::BlockError(msg.to_string())),
|
|
)
|
|
}
|
|
|
|
pub fn value_err(msg: String) -> ArrayError {
|
|
ArrayError::ValueError(msg)
|
|
}
|
|
|
|
pub fn aggregate_error(errs: Vec<ArrayError>) -> ArrayError {
|
|
ArrayError::Aggregate(errs)
|
|
}
|
|
|
|
pub type Result<T> = std::result::Result<T, ArrayError>;
|
|
|
|
//------------------------------------------
|
|
|
|
fn convert_result<'a, V>(path: &[u64], r: IResult<&'a [u8], V>) -> Result<(&'a [u8], V)> {
|
|
r.map_err(|_| array_block_err(path, "parse error"))
|
|
}
|
|
|
|
pub fn unpack_array_block<V: Unpack>(path: &[u64], data: &[u8]) -> Result<ArrayBlock<V>> {
|
|
// TODO: collect errors
|
|
let (i, header) =
|
|
ArrayBlockHeader::unpack(data).map_err(|_| array_block_err(
|
|
path,
|
|
"Couldn't parse array block header"
|
|
))?;
|
|
|
|
// check value_size
|
|
if header.value_size != V::disk_size() {
|
|
return Err(array_block_err(
|
|
path,
|
|
&format!(
|
|
"value_size mismatch: expected {}, was {}",
|
|
V::disk_size(),
|
|
header.value_size
|
|
)
|
|
));
|
|
}
|
|
|
|
// check max_entries
|
|
if header.value_size * header.max_entries + ARRAY_BLOCK_HEADER_SIZE > BLOCK_SIZE as u32 {
|
|
return Err(array_block_err(
|
|
path,
|
|
&format!("max_entries is too large ({})", header.max_entries)
|
|
));
|
|
}
|
|
|
|
// TODO: check nr_entries < max_entries
|
|
|
|
// TODO: check block_nr
|
|
|
|
let (_i, values) = convert_result(path, count(V::unpack, header.nr_entries as usize)(i))?;
|
|
|
|
Ok(ArrayBlock { header, values })
|
|
}
|
|
|
|
//------------------------------------------
|