4423198119

Build # 4423198119

Build Type

push

github

Committed by GitHub

Commit Message

Bump geo from 0.23.1 to 0.24.0 (#1207)

Run Details

28601 of 39109 relevant lines covered (73.13%)

51246.35 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

80.29

/dozer-cache/src/cache/lmdb/utils.rs

use std::{
    fs,
    ops::Deref,
    path::{Path, PathBuf},
};

use crate::errors::CacheError;
use dozer_storage::{
    lmdb::EnvironmentFlags,
    lmdb_storage::{LmdbEnvironmentManager, LmdbEnvironmentOptions},
};
use tempdir::TempDir;

use super::cache::CacheOptions;

#[allow(clippy::type_complexity)]
pub fn init_env(
    options: &CacheOptions,
    create_if_not_exist: bool,
) -> Result<(LmdbEnvironmentManager, (PathBuf, String), Option<TempDir>), CacheError> {
    if create_if_not_exist {
        create_env(options)
    } else {
        let (env, (base_path, name), temp_dir) = open_env(options)?;
        Ok((env, (base_path.to_path_buf(), name.to_string()), temp_dir))
    }
}

#[allow(clippy::type_complexity)]
fn create_env(
    options: &CacheOptions,
) -> Result<(LmdbEnvironmentManager, (PathBuf, String), Option<TempDir>), CacheError> {
    let (base_path, name, temp_dir) = match &options.path {
        None => {
            let base_path =
                TempDir::new("dozer").map_err(|e| CacheError::Io("tempdir".into(), e))?;
            (
                base_path.path().to_path_buf(),
                "dozer-cache",
                Some(base_path),
            )
        }
        Some((base_path, name)) => {
            fs::create_dir_all(base_path).map_err(|e| CacheError::Io(base_path.clone(), e))?;
            (base_path.clone(), name.deref(), None)
        }
    };

    let options = LmdbEnvironmentOptions::new(
        options.max_db_size,
        options.max_readers,
        options.max_size,
        EnvironmentFlags::empty(),
    );

    Ok((
        LmdbEnvironmentManager::create(&base_path, name, options)?,
        (base_path, name.to_string()),
        temp_dir,
    ))
}

#[allow(clippy::type_complexity)]
fn open_env(
    options: &CacheOptions,
) -> Result<(LmdbEnvironmentManager, (&Path, &str), Option<TempDir>), CacheError> {
    let (base_path, name) = options
        .path
        .as_ref()
        .ok_or(CacheError::PathNotInitialized)?;

    let env_options = LmdbEnvironmentOptions::new(
        options.max_db_size,
        options.max_readers,
        options.max_size,
        EnvironmentFlags::READ_ONLY,
    );

    Ok((
        LmdbEnvironmentManager::create(base_path, name, env_options)?,
        (base_path, name),
        None,
    ))
}

#[cfg(test)]
mod tests {
    use dozer_storage::{
        lmdb::{Cursor, DatabaseFlags, RoCursor, Transaction, WriteFlags},
        lmdb_storage::CreateDatabase,
    };
    use dozer_types::types::Field;

    use super::*;

    fn cursor_dump(mut cursor: RoCursor) -> Vec<(&[u8], &[u8])> {
        cursor
            .iter_dup()
            .flatten()
            .collect::<dozer_storage::lmdb::Result<Vec<_>>>()
            .unwrap()
    }

    #[test]
    fn duplicate_test_nested() {
        let mut env = create_env(&Default::default()).unwrap().0;

        let db = env
            .create_database(
                Some("test"),
                Some(DatabaseFlags::DUP_SORT | DatabaseFlags::INTEGER_KEY),
            )
            .unwrap();

        let txn = env.create_txn().unwrap();
        let mut master_txn = txn.write();
        let txn = master_txn.txn_mut();

        let mut c_txn = txn.begin_nested_txn().unwrap();

        let items: Vec<(i64, &[u8])> = vec![
            (1, b"a"),
            (2, b"a"),
            (3, b"a"),
            (1, b"b"),
            (2, b"b"),
            (3, b"b"),
            (1, b"c"),
            (2, b"c"),
            (3, b"c"),
            (1, b"e"),
            (2, b"e"),
            (3, b"e"),
        ];
        for (key, data) in &items {
            let key = [
                "idx".as_bytes().to_vec(),
                Field::Int(*key).encode(),
                key.to_be_bytes().to_vec(),
            ]
            .join("#".as_bytes());
            c_txn.put(db, &key, data, WriteFlags::empty()).unwrap();
        }
        c_txn.commit().unwrap();
        master_txn.commit_and_renew().unwrap();

        let rtxn = master_txn.txn();

        let cursor = rtxn.open_ro_cursor(db).unwrap();
        let vals = cursor_dump(cursor);
        assert_eq!(vals.len(), items.len(), "must have duplicate records");
    }
}

1	use std::{
2	fs,
3	ops::Deref,
4	path::{Path, PathBuf},
5	};
6
7	use crate::errors::CacheError;
8	use dozer_storage::{
9	lmdb::EnvironmentFlags,
10	lmdb_storage::{LmdbEnvironmentManager, LmdbEnvironmentOptions},
11	};
12	use tempdir::TempDir;
13
14	use super::cache::CacheOptions;
15
16	#[allow(clippy::type_complexity)]	×
17	pub fn init_env(	2,582✔
18	options: &CacheOptions,	2,582✔
19	create_if_not_exist: bool,	2,582✔
20	) -> Result<(LmdbEnvironmentManager, (PathBuf, String), Option<TempDir>), CacheError> {	2,582✔
21	if create_if_not_exist {	2,582✔
22	create_env(options)	872✔
23	} else {
24	let (env, (base_path, name), temp_dir) = open_env(options)?;	1,710✔
25	Ok((env, (base_path.to_path_buf(), name.to_string()), temp_dir))	1,710✔
26	}	×
27	}	2,582✔
28		×
29	#[allow(clippy::type_complexity)]
30	fn create_env(	873✔
31	options: &CacheOptions,	873✔
32	) -> Result<(LmdbEnvironmentManager, (PathBuf, String), Option<TempDir>), CacheError> {	873✔
33	let (base_path, name, temp_dir) = match &options.path {	873✔
34	None => {	×
35	let base_path =	17✔
36	TempDir::new("dozer").map_err(\|e\| CacheError::Io("tempdir".into(), e))?;	17✔
37	(	17✔
38	base_path.path().to_path_buf(),	17✔
39	"dozer-cache",	17✔
40	Some(base_path),	17✔
41	)	17✔
42	}	×
43	Some((base_path, name)) => {	856✔
44	fs::create_dir_all(base_path).map_err(\|e\| CacheError::Io(base_path.clone(), e))?;	856✔
45	(base_path.clone(), name.deref(), None)	856✔
46	}	×
47	};	×
48		×
49	let options = LmdbEnvironmentOptions::new(	873✔
50	options.max_db_size,	873✔
51	options.max_readers,	873✔
52	options.max_size,	873✔
53	EnvironmentFlags::empty(),	873✔
54	);	873✔
55		873✔
56	Ok((	873✔
57	LmdbEnvironmentManager::create(&base_path, name, options)?,	873✔
58	(base_path, name.to_string()),	879✔
59	temp_dir,	879✔
60	))	×
61	}	879✔
62		×
63	#[allow(clippy::type_complexity)]	×
64	fn open_env(	1,710✔
65	options: &CacheOptions,	1,710✔
66	) -> Result<(LmdbEnvironmentManager, (&Path, &str), Option<TempDir>), CacheError> {	1,710✔
67	let (base_path, name) = options	1,710✔
68	.path	1,710✔
69	.as_ref()	1,710✔
70	.ok_or(CacheError::PathNotInitialized)?;	1,710✔
71		×
72	let env_options = LmdbEnvironmentOptions::new(	1,710✔
73	options.max_db_size,	1,710✔
74	options.max_readers,	1,710✔
75	options.max_size,	1,710✔
76	EnvironmentFlags::READ_ONLY,	1,710✔
77	);	1,710✔
78		1,710✔
79	Ok((	1,710✔
80	LmdbEnvironmentManager::create(base_path, name, env_options)?,	1,710✔
81	(base_path, name),	1,710✔
82	None,	1,710✔
83	))	×
84	}	1,710✔
85		×
86	#[cfg(test)]	×
87	mod tests {	×
88	use dozer_storage::{	×
89	lmdb::{Cursor, DatabaseFlags, RoCursor, Transaction, WriteFlags},	×
90	lmdb_storage::CreateDatabase,	×
91	};	×
92	use dozer_types::types::Field;	×
93
94	use super::*;	×
95		×
96	fn cursor_dump(mut cursor: RoCursor) -> Vec<(&[u8], &[u8])> {	1✔
97	cursor	1✔
98	.iter_dup()	1✔
99	.flatten()	1✔
100	.collect::<dozer_storage::lmdb::Result<Vec<_>>>()	1✔
101	.unwrap()	1✔
102	}	1✔
103		×
104	#[test]	1✔
105	fn duplicate_test_nested() {	1✔
106	let mut env = create_env(&Default::default()).unwrap().0;	1✔
107		1✔
108	let db = env	1✔
109	.create_database(	1✔
110	Some("test"),	1✔
111	Some(DatabaseFlags::DUP_SORT \| DatabaseFlags::INTEGER_KEY),	1✔
112	)	1✔
113	.unwrap();	1✔
114		1✔
115	let txn = env.create_txn().unwrap();	1✔
116	let mut master_txn = txn.write();	1✔
117	let txn = master_txn.txn_mut();	1✔
118		1✔
119	let mut c_txn = txn.begin_nested_txn().unwrap();	1✔
120		1✔
121	let items: Vec<(i64, &[u8])> = vec![	1✔
122	(1, b"a"),	1✔
123	(2, b"a"),	1✔
124	(3, b"a"),	1✔
125	(1, b"b"),	1✔
126	(2, b"b"),	1✔
127	(3, b"b"),	1✔
128	(1, b"c"),	1✔
129	(2, b"c"),	1✔
130	(3, b"c"),	1✔
131	(1, b"e"),	1✔
132	(2, b"e"),	1✔
133	(3, b"e"),	1✔
134	];	1✔
135	for (key, data) in &items {	13✔
136	let key = [	12✔
137	"idx".as_bytes().to_vec(),	12✔
138	Field::Int(*key).encode(),	12✔
139	key.to_be_bytes().to_vec(),	12✔
140	]	12✔
141	.join("#".as_bytes());	12✔
142	c_txn.put(db, &key, data, WriteFlags::empty()).unwrap();	12✔
143	}	12✔
144	c_txn.commit().unwrap();	1✔
145	master_txn.commit_and_renew().unwrap();	1✔
146		1✔
147	let rtxn = master_txn.txn();	1✔
148		1✔
149	let cursor = rtxn.open_ro_cursor(db).unwrap();	1✔
150	let vals = cursor_dump(cursor);	1✔
151	assert_eq!(vals.len(), items.len(), "must have duplicate records");	1✔
152	}	1✔
153	}	×

getdozer / dozer / 4423198119

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous