block-db 0.2.0

Local, multi-threaded, durable byte DB.
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
65
66
67
68
69

// Authors: Robert Lopez

pub mod assert;
pub mod batch;
pub mod compact;
pub mod free;
pub mod read;
pub mod state;
pub mod write;

use crate::{error::Error, options::BlockDBOptionsBuilder, util::fs::delete_directory, BlockDB};
use state::TestState;
use std::{num::NonZeroUsize, path::PathBuf};

pub struct TestDB {
    pub path: String,
    pub block_db: BlockDB,
    pub test_state: TestState,
    pub chunk_size: usize,
}

impl TestDB {
    pub async fn open(
        name: &str,
        chunk_size: Option<usize>,
        max_file_size: Option<usize>,
    ) -> Result<Self, Error> {
        let path = format!("./test/{name}");
        delete_directory(&PathBuf::from(&path)).await?;

        let chunk_size = chunk_size.unwrap_or(4_096);
        let max_file_size = max_file_size.unwrap_or(4_096_000);

        let block_db = BlockDB::open(
            &path,
            Some(
                BlockDBOptionsBuilder::default()
                    .chunk_size(NonZeroUsize::new(chunk_size).unwrap())
                    .max_file_size(NonZeroUsize::new(max_file_size).unwrap())
                    .build(),
            ),
        )
        .await?;

        Ok(Self {
            path,
            block_db,
            test_state: TestState::default(),
            chunk_size,
        })
    }

    pub async fn re_open(name: &str, test_state: TestState) -> Result<Self, Error> {
        let path = format!("./test/{name}");
        let block_db = BlockDB::open(&path, None).await?;
        let chunk_size = block_db.options_store.chunk_size();

        Ok(Self {
            path,
            block_db,
            test_state,
            chunk_size,
        })
    }

    pub async fn cleanup(self) -> Result<(), Error> {
        delete_directory(&PathBuf::from(self.path)).await
    }
}