minikv 2.0.0

Distributed key-value store with Raft consensus, encryption at rest, and pluggable storage backends.
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

use crate::common::Result;
use crate::coordinator::metadata::{KeyMetadata, MetadataStore};
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum Command {
    PutKey(KeyMetadata),
    DeleteKey(String),
}

impl Command {
    pub fn encode(&self) -> Result<Vec<u8>> {
        bincode::serialize(self)
            .map_err(|e| crate::Error::Internal(format!("cannot encode command: {}", e)))
    }

    pub fn decode(bytes: &[u8]) -> Result<Self> {
        bincode::deserialize(bytes)
            .map_err(|e| crate::Error::Internal(format!("cannot decode command: {}", e)))
    }
}

pub fn apply(store: &MetadataStore, data: &[u8]) {
    if data.is_empty() {
        return;
    }
    let result = match Command::decode(data) {
        Ok(Command::PutKey(meta)) => store.put_key(&meta),
        Ok(Command::DeleteKey(key)) => store.delete_key(&key),
        Err(e) => Err(e),
    };
    if let Err(e) = result {
        tracing::error!("Cannot apply raft entry to the metadata store: {}", e);
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::coordinator::metadata::KeyState;
    use tempfile::tempdir;

    #[test]
    fn commands_update_the_metadata_store() {
        let dir = tempdir().unwrap();
        let store = MetadataStore::open(dir.path().join("meta")).unwrap();
        let meta = KeyMetadata {
            key: "photos/cat.png".to_string(),
            blob_id: "photos/cat.png#1".to_string(),
            replicas: vec!["vol-1".to_string(), "vol-2".to_string()],
            size: 3,
            blake3: "abc".to_string(),
            created_at: 1,
            updated_at: 1,
            state: KeyState::Active,
        };
        apply(&store, &Command::PutKey(meta).encode().unwrap());
        let stored = store.get_key("photos/cat.png").unwrap().unwrap();
        assert_eq!(stored.replicas.len(), 2);

        apply(&store, &[]);
        assert!(store.get_key("photos/cat.png").unwrap().is_some());

        apply(
            &store,
            &Command::DeleteKey("photos/cat.png".to_string())
                .encode()
                .unwrap(),
        );
        assert!(store.get_key("photos/cat.png").unwrap().is_none());
    }
}