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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

use std::process::Command;
use std::{thread, time};
use tempfile::tempdir;

#[test]
fn test_concurrent_processes_access() -> anyhow::Result<()> {
    let temp = tempdir()?;
    let db_path = temp.path();

    // First process writes data
    let output = Command::new("cargo")
        .args(["run", "--", "put", "--key", "foo", "--value", "bar"])
        .env("BITASK_PATH", db_path.to_str().unwrap())
        .output()?;
    assert!(output.status.success());

    // Second process reads data
    let output = Command::new("cargo")
        .args(["run", "--", "ask", "--key", "foo"])
        .env("BITASK_PATH", db_path.to_str().unwrap())
        .output()?;

    assert!(output.status.success());
    assert_eq!(String::from_utf8_lossy(&output.stdout).trim(), "bar");

    Ok(())
}

#[test]
fn test_process_lock_contention() -> anyhow::Result<()> {
    let temp = tempdir()?;
    let db_path = temp.path();

    // Hold the database open
    let _db = bitask::db::Bitask::open(db_path)?;

    // Try to write using CLI, should fail due to lock
    let output = Command::new("cargo")
        .args(["run", "--", "put", "--key", "foo", "--value", "bar"])
        .env("BITASK_PATH", db_path.to_str().unwrap())
        .output()?;

    assert!(!output.status.success());

    Ok(())
}

#[test]
fn test_process_recovery_after_crash() -> anyhow::Result<()> {
    let temp = tempdir()?;
    let db_path = temp.path();

    // Write initial data
    let output = Command::new("cargo")
        .args(["run", "--", "put", "--key", "foo", "--value", "bar"])
        .env("BITASK_PATH", db_path.to_str().unwrap())
        .output()?;
    assert!(output.status.success());

    // Start a long-running CLI operation that we'll interrupt
    let mut child = Command::new("cargo")
        .args(["run", "--", "put", "--key", "foo2", "--value", "bar2"])
        .env("BITASK_PATH", db_path.to_str().unwrap())
        .spawn()?;

    // Give it time to start but kill before completion
    thread::sleep(time::Duration::from_millis(100));
    child.kill()?;

    // Database should still be readable
    let output = Command::new("cargo")
        .args(["run", "--", "ask", "--key", "foo"])
        .env("BITASK_PATH", db_path.to_str().unwrap())
        .output()?;

    assert!(output.status.success());
    assert_eq!(String::from_utf8_lossy(&output.stdout).trim(), "bar");

    Ok(())
}

#[test]
fn test_lock_file_cleanup() -> anyhow::Result<()> {
    let temp = tempdir()?;
    let db_path = temp.path();
    let lock_path = db_path.join("db.lock");

    // Run a put command
    let output = Command::new("cargo")
        .args(["run", "--", "put", "--key", "foo", "--value", "bar"])
        .env("BITASK_PATH", db_path.to_str().unwrap())
        .output()?;

    assert!(output.status.success());

    // Verify lock file is gone after process exits
    assert!(
        !lock_path.exists(),
        "Lock file still exists after process exit"
    );

    // Try reading the value back
    let output = Command::new("cargo")
        .args(["run", "--", "ask", "--key", "foo"])
        .env("BITASK_PATH", db_path.to_str().unwrap())
        .output()?;

    assert!(output.status.success());
    assert_eq!(String::from_utf8_lossy(&output.stdout).trim(), "bar");

    Ok(())
}

#[test]
fn test_sequential_opens() -> anyhow::Result<()> {
    let temp = tempdir()?;

    // First open
    {
        let _db = bitask::db::Bitask::open(temp.path())?;
        // _db is dropped here at end of scope, releasing the lock
    }

    // Second open should work because first handle was dropped
    {
        let _db = bitask::db::Bitask::open(temp.path())?;
    }

    Ok(())
}