libvault 0.2.2

the libvault is modified from RustyVault
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

use std::{any::Any, sync::Arc};

use super::{Storage, StorageEntry, barrier::SecurityBarrier};
use crate::errors::RvError;

pub struct BarrierView {
    barrier: Arc<dyn SecurityBarrier>,
    prefix: String,
}

#[async_trait::async_trait]
impl Storage for BarrierView {
    async fn list(&self, prefix: &str) -> Result<Vec<String>, RvError> {
        self.sanity_check(prefix)?;
        self.barrier.list(self.expand_key(prefix).as_str()).await
    }

    async fn get(&self, key: &str) -> Result<Option<StorageEntry>, RvError> {
        self.sanity_check(key)?;
        let storage_entry = self.barrier.get(self.expand_key(key).as_str()).await?;
        if let Some(entry) = storage_entry {
            Ok(Some(StorageEntry {
                key: self.truncate_key(entry.key.as_str()),
                value: entry.value,
            }))
        } else {
            Ok(None)
        }
    }

    async fn put(&self, entry: &StorageEntry) -> Result<(), RvError> {
        self.sanity_check(entry.key.as_str())?;
        let nested = StorageEntry {
            key: self.expand_key(entry.key.as_str()),
            value: entry.value.clone(),
        };
        self.barrier.put(&nested).await
    }

    async fn delete(&self, key: &str) -> Result<(), RvError> {
        self.sanity_check(key)?;
        self.barrier.delete(self.expand_key(key).as_str()).await
    }

    async fn lock(&self, lock_name: &str) -> Result<Box<dyn Any>, RvError> {
        self.barrier.lock(lock_name).await
    }
}

impl BarrierView {
    pub fn new(barrier: Arc<dyn SecurityBarrier>, prefix: &str) -> Self {
        Self {
            barrier,
            prefix: prefix.to_string(),
        }
    }

    pub fn new_sub_view(&self, prefix: &str) -> Self {
        Self {
            barrier: self.barrier.clone(),
            prefix: self.expand_key(prefix),
        }
    }

    pub async fn get_keys(&self) -> Result<Vec<String>, RvError> {
        let mut paths = vec!["".to_string()];
        let mut keys = Vec::new();
        while !paths.is_empty() {
            let n = paths.len();
            let curr = paths[n - 1].to_owned();
            paths.pop();

            let items = self.list(curr.as_str()).await?;
            for p in items {
                let path = format!("{curr}{p}");
                if p.ends_with('/') {
                    paths.push(path);
                } else {
                    keys.push(path.to_owned());
                }
            }
        }
        keys.sort();
        Ok(keys)
    }

    pub async fn clear(&self) -> Result<(), RvError> {
        let keys = self.get_keys().await?;
        for key in keys {
            self.delete(key.as_str()).await?
        }
        Ok(())
    }

    pub fn as_storage(&self) -> &dyn Storage {
        self
    }

    fn sanity_check(&self, key: &str) -> Result<(), RvError> {
        if key.contains("..") || key.starts_with('/') {
            Err(RvError::ErrBarrierKeySanityCheckFailed)
        } else {
            Ok(())
        }
    }

    fn expand_key(&self, suffix: &str) -> String {
        format!("{}{}", self.prefix, suffix)
    }

    fn truncate_key(&self, full: &str) -> String {
        if let Some(result) = full.strip_prefix(self.prefix.as_str()) {
            result.to_string()
        } else {
            full.to_string()
        }
    }
}