tempest-core 0.0.2

Core utilities and primitives for TempestDB
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

use std::path::PathBuf;

use serde::{Deserialize, Serialize};
use tempest_io::VirtualIo;
use tempest_rt::block_on;

use crate::test_utils::setup_tracing;

use super::*;

#[derive(Debug, Default, PartialEq, Eq, PartialOrd, Ord)]
struct ReplayableCounter(i64);

#[derive(Serialize, Deserialize)]
enum ReplayableCounterEdit {
    Add(i64),
    Set(i64),
}

impl ReplayableCounter {
    fn count(&self) -> i64 {
        self.0
    }
}

impl Replayable for ReplayableCounter {
    type Edit = ReplayableCounterEdit;

    fn apply(&mut self, edit: Self::Edit) {
        match edit {
            ReplayableCounterEdit::Add(v) => self.0 += v,
            ReplayableCounterEdit::Set(v) => self.0 = v,
        }
    }

    fn snapshot(&self) -> Self::Edit {
        ReplayableCounterEdit::Set(self.0)
    }

    fn filename_prefix() -> &'static str {
        "replayable-counter"
    }

    fn initial() -> Self {
        Self(0)
    }
}

#[test]
fn test_journal() {
    setup_tracing();

    let io = VirtualIo::default();
    let dir = PathBuf::from("/journal-dir");
    let config = JournalConfig::default();

    block_on(io, async {
        {
            info!("opening journal");
            // open first journal
            let (journal, join) =
                Journal::<ReplayableCounter, VirtualIo>::new(dir.clone(), config.clone())
                    .await
                    .unwrap();
            assert_eq!(journal.data().count(), ReplayableCounter::initial().count());

            // first edit
            journal.append(ReplayableCounterEdit::Add(1)).await.unwrap();
            assert_eq!(journal.data().count(), 1);

            // second edit
            journal
                .append(ReplayableCounterEdit::Add(-6))
                .await
                .unwrap();
            assert_eq!(journal.data().count(), -5);

            // set to final value
            journal
                .append(ReplayableCounterEdit::Set(42))
                .await
                .unwrap();
            assert_eq!(journal.data().count(), 42);

            drop(journal);
            join.await.unwrap();
        }

        {
            info!("reopening journal");
            // reopen journal — verify replay
            let (journal, join) =
                Journal::<ReplayableCounter, VirtualIo>::new(dir.clone(), config.clone())
                    .await
                    .unwrap();
            assert_eq!(journal.data().count(), 42);

            drop(journal);
            join.await.unwrap();
        }
    });
}