mace-kv 0.0.33

A fast, cross-platform embedded key-value storage engine with ACID, MVCC, and flash-optimized storage
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

use crate::OpCode;
use std::collections::HashMap;
use std::sync::{Mutex, OnceLock};

#[derive(Clone, Copy)]
pub(crate) enum FailAction {
    Panic,
    IoError,
    Abort,
}

#[derive(Clone, Copy)]
struct Rule {
    action: FailAction,
    nth: Option<u64>,
    hits: u64,
}

struct State {
    raw: String,
    rules: HashMap<String, Rule>,
}

impl State {
    fn new() -> Self {
        Self {
            raw: String::new(),
            rules: HashMap::new(),
        }
    }

    fn refresh(&mut self) {
        let current = std::env::var("MACE_FAILPOINT").unwrap_or_default();
        if current == self.raw {
            return;
        }
        self.raw = current.clone();
        self.rules = parse_rules(&current);
    }

    fn hit(&mut self, name: &str) -> Option<FailAction> {
        self.refresh();
        let rule = self.rules.get_mut(name)?;
        rule.hits += 1;
        if let Some(nth) = rule.nth
            && rule.hits != nth
        {
            return None;
        }
        Some(rule.action)
    }
}

fn parse_rules(raw: &str) -> HashMap<String, Rule> {
    let mut out = HashMap::new();

    for token in raw.split(',') {
        let token = token.trim();
        if token.is_empty() {
            continue;
        }

        let (name, body) = token
            .split_once('=')
            .or_else(|| token.split_once(':'))
            .unwrap_or((token, "panic"));

        if name.is_empty() {
            continue;
        }

        let (action_raw, nth_raw) = body.split_once('@').unwrap_or((body, ""));
        let action = match action_raw {
            "panic" => FailAction::Panic,
            "io" => FailAction::IoError,
            "abort" => FailAction::Abort,
            "off" => continue,
            _ => continue,
        };

        let nth = if nth_raw.is_empty() {
            None
        } else {
            nth_raw.parse::<u64>().ok().filter(|x| *x > 0)
        };

        out.insert(
            name.to_string(),
            Rule {
                action,
                nth,
                hits: 0,
            },
        );
    }

    out
}

fn global_state() -> &'static Mutex<State> {
    static STATE: OnceLock<Mutex<State>> = OnceLock::new();
    STATE.get_or_init(|| Mutex::new(State::new()))
}

pub(crate) fn check(name: &str) -> Result<(), OpCode> {
    let mut lk = global_state().lock().expect("failpoint lock poisoned");
    match lk.hit(name) {
        None => Ok(()),
        Some(FailAction::Panic) => panic!("failpoint panic: {name}"),
        Some(FailAction::Abort) => std::process::abort(),
        Some(FailAction::IoError) => Err(OpCode::IoError),
    }
}

pub(crate) fn crash(name: &str) {
    let mut lk = global_state().lock().expect("failpoint lock poisoned");
    match lk.hit(name) {
        None => {}
        Some(FailAction::Panic) => panic!("failpoint panic: {name}"),
        Some(FailAction::Abort) => std::process::abort(),
        Some(FailAction::IoError) => panic!("failpoint io translated to panic: {name}"),
    }
}