bitask 0.1.1

Bitask is a Rust implementation of Bitcask, a log-structured key-value store optimized for high-performance reads and writes.
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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

use std::sync::{Arc, Mutex};
use std::thread;
use tempfile::tempdir;

#[test]
fn test_concurrent_reads() -> anyhow::Result<()> {
    let temp = tempdir()?;
    let db = bitask::db::Bitask::open(temp.path())?;
    let db = Arc::new(Mutex::new(db));

    // Setup test data
    db.lock()
        .unwrap()
        .put(b"key1".to_vec(), b"value1".to_vec())?;

    let mut handles = vec![];
    for _ in 0..10 {
        let db_clone = Arc::clone(&db);
        let handle = thread::spawn(move || {
            let value = db_clone.lock().unwrap().ask(b"key1").unwrap();
            assert_eq!(value, b"value1");
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    Ok(())
}

#[test]
fn test_concurrent_writes() -> anyhow::Result<()> {
    let temp = tempdir()?;
    let db = bitask::db::Bitask::open(temp.path())?;
    let db = Arc::new(Mutex::new(db));
    let mut handles = vec![];

    // Create multiple writer threads
    for i in 0..10 {
        let db_clone = Arc::clone(&db);
        let handle = thread::spawn(move || {
            let key = format!("key{}", i).into_bytes();
            let value = format!("value{}", i).into_bytes();
            db_clone.lock().unwrap().put(key, value).unwrap();
        });
        handles.push(handle);
    }

    // Wait for all writes to complete
    for handle in handles {
        handle.join().unwrap();
    }

    // Verify all writes succeeded
    for i in 0..10 {
        let key = format!("key{}", i).into_bytes();
        let expected = format!("value{}", i).into_bytes();
        let value = db.lock().unwrap().ask(&key)?;
        assert_eq!(value, expected);
    }

    Ok(())
}

#[test]
fn test_concurrent_mixed_operations() -> anyhow::Result<()> {
    let temp = tempdir()?;
    let db = bitask::db::Bitask::open(temp.path())?;
    let db = Arc::new(Mutex::new(db));
    let mut handles = vec![];

    // Setup initial data
    db.lock()
        .unwrap()
        .put(b"shared_key".to_vec(), b"initial_value".to_vec())?;

    // Create threads that do mixed operations
    for i in 0..10 {
        let db_clone = Arc::clone(&db);
        let handle = thread::spawn(move || {
            if i % 2 == 0 {
                // Even threads write
                let key = format!("key{}", i).into_bytes();
                let value = format!("value{}", i).into_bytes();
                db_clone.lock().unwrap().put(key, value).unwrap();
            } else {
                // Odd threads read
                let _ = db_clone.lock().unwrap().ask(b"shared_key").unwrap();
            }
        });
        handles.push(handle);
    }

    // Wait for all operations to complete
    for handle in handles {
        handle.join().unwrap();
    }

    // Verify writes succeeded
    for i in (0..10).step_by(2) {
        let key = format!("key{}", i).into_bytes();
        let expected = format!("value{}", i).into_bytes();
        let value = db.lock().unwrap().ask(&key)?;
        assert_eq!(value, expected);
    }

    Ok(())
}