pearl 0.21.0

Pearl is a low level blob-based I/O library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

use super::prelude::*;
use super::utils::block_on;
pub(crate) use crate::blob::header::Header as BlobHeader;
use crate::blob::index::FileIndexTrait;
pub(crate) use crate::blob::index::{header::IndexHeader, BPTreeFileIndex};
use crate::blob::FileName;
pub(crate) use crate::record::{Header, Record};
pub use crate::BloomConfig;

/// Validate index file
pub fn validate_index<K>(path: &Path) -> AnyResult<()>
where
    for<'a> K: Key<'a> + 'static,
{
    use blob::index::HEADER_VERSION;

    static_assertions::const_assert_eq!(HEADER_VERSION, 6);
    let header = read_index_header(path)?;
    let blob_path = path.with_extension("blob");
    let blob_size = if blob_path.exists() {
        blob_path.metadata()?.len()
    } else {
        if let Some(path) = path.to_str() {
            warn!("blob file doesn't exist for {}", path);
        } else {
            warn!("blob file doesn't exist for index");
        }
        header.blob_size()
    };
    let headers = if header.version() < HEADER_VERSION {
        return Err(ToolsError::index_header_validation_error(format!(
            "Index version is outdated. Passed version: {}, latest version: {}",
            header.version(),
            HEADER_VERSION
        ))
        .into());
    } else if header.version() == HEADER_VERSION {
        block_on(async {
            let index =
                BPTreeFileIndex::<K>::from_file(FileName::from_path(path)?, IoDriver::new_sync())
                    .await?;
            let res = index.get_records_headers(blob_size).await?;
            AnyResult::<_>::Ok(res.0)
        })??
    } else {
        return Err(ToolsError::index_header_validation_error("unknown header version").into());
    };
    for (_, headers) in headers {
        for header in headers {
            header.validate()?;
        }
    }
    Ok(())
}

/// Validate blob file
pub fn validate_blob(path: &Path) -> AnyResult<()> {
    let mut reader = BlobReader::from_path(&path)?;
    reader.read_header()?;
    while !reader.is_eof() {
        reader.read_record(false)?;
    }
    Ok(())
}