kithara-storage 0.0.1-alpha2

mmap-backed storage resource with random-access I/O.
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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

#![forbid(unsafe_code)]

#[cfg(not(target_arch = "wasm32"))]
use std::fs;

mod kithara {
    pub(crate) use kithara_test_macros::test;
}

use kithara_platform::time::Duration;
#[cfg(not(target_arch = "wasm32"))]
use tempfile::TempDir;
use tokio_util::sync::CancellationToken;

use super::core::Atomic;
use crate::{MemOptions, MemResource, Resource, ResourceExt};
#[cfg(not(target_arch = "wasm32"))]
use crate::{MmapOptions, MmapResource, OpenMode};

#[cfg(not(target_arch = "wasm32"))]
fn create_mmap_resource(dir: &TempDir, name: &str) -> MmapResource {
    let path = dir.path().join(name);
    Resource::open(
        CancellationToken::new(),
        MmapOptions {
            path,
            mode: OpenMode::ReadWrite,
            initial_len: Some(4096),
        },
    )
    .unwrap()
}

fn create_mem_resource() -> MemResource {
    Resource::open(CancellationToken::new(), MemOptions::default()).unwrap()
}

#[cfg(not(target_arch = "wasm32"))]
#[kithara::test(timeout(Duration::from_secs(2)))]
fn mmap_write_all_read_into_roundtrip() {
    let dir = TempDir::new().unwrap();
    let res = create_mmap_resource(&dir, "test.bin");
    let atomic = Atomic::new(res);

    let data = b"hello atomic world";
    atomic.write_all(data).unwrap();

    let mut buf = Vec::new();
    let n = atomic.read_into(&mut buf).unwrap();
    assert_eq!(n, data.len());
    assert_eq!(&buf, data);
}

#[cfg(not(target_arch = "wasm32"))]
#[kithara::test(timeout(Duration::from_secs(2)))]
fn mmap_tmp_file_cleaned_up() {
    let dir = TempDir::new().unwrap();
    let res = create_mmap_resource(&dir, "index.bin");
    let atomic = Atomic::new(res);

    atomic.write_all(b"data").unwrap();

    let tmp_files: Vec<_> = fs::read_dir(dir.path())
        .unwrap()
        .filter_map(Result::ok)
        .filter(|e| e.path().to_str().is_some_and(|s| s.contains(".tmp.")))
        .collect();
    assert!(
        tmp_files.is_empty(),
        "tmp files should not remain: {tmp_files:?}"
    );
}

#[kithara::test(timeout(Duration::from_secs(2)))]
fn mem_write_all_read_into_roundtrip() {
    let res = create_mem_resource();
    let atomic = Atomic::new(res);

    let data = b"in-memory data";
    atomic.write_all(data).unwrap();

    let mut buf = Vec::new();
    let n = atomic.read_into(&mut buf).unwrap();
    assert_eq!(n, data.len());
    assert_eq!(&buf, data);
}

#[kithara::test(timeout(Duration::from_secs(2)))]
fn mem_write_all_overwrites_committed_data() {
    let res = create_mem_resource();
    let atomic = Atomic::new(res);

    atomic.write_all(b"first").unwrap();
    atomic.write_all(b"second version").unwrap();

    let mut buf = Vec::new();
    let n = atomic.read_into(&mut buf).unwrap();
    assert_eq!(n, b"second version".len());
    assert_eq!(&buf, b"second version");
}

#[cfg(not(target_arch = "wasm32"))]
#[kithara::test(timeout(Duration::from_secs(2)))]
fn mmap_read_into_empty_returns_zero() {
    let dir = TempDir::new().unwrap();
    let res = create_mmap_resource(&dir, "empty.bin");
    let atomic = Atomic::new(res);

    let mut buf = Vec::new();
    let n = atomic.read_into(&mut buf).unwrap();
    assert_eq!(n, 0);
}

#[cfg(not(target_arch = "wasm32"))]
#[kithara::test(timeout(Duration::from_secs(2)))]
fn mmap_overwrite_atomically() {
    let dir = TempDir::new().unwrap();
    let res = create_mmap_resource(&dir, "overwrite.bin");
    let atomic = Atomic::new(res);

    atomic.write_all(b"first version").unwrap();
    atomic.write_all(b"second version - longer data").unwrap();

    let mut buf = Vec::new();
    let n = atomic.read_into(&mut buf).unwrap();
    assert_eq!(n, b"second version - longer data".len());
    assert_eq!(&buf, b"second version - longer data");
}

#[cfg(not(target_arch = "wasm32"))]
#[kithara::test(timeout(Duration::from_secs(2)))]
fn mmap_path_returns_inner_path() {
    let dir = TempDir::new().unwrap();
    let res = create_mmap_resource(&dir, "path_test.bin");
    let expected = dir.path().join("path_test.bin");
    let atomic = Atomic::new(res);

    assert_eq!(atomic.path(), Some(expected.as_path()));
}

#[kithara::test(timeout(Duration::from_secs(2)))]
fn mem_path_returns_none() {
    let res = create_mem_resource();
    let atomic = Atomic::new(res);

    assert!(atomic.path().is_none());
}