feat(rtc_tenclave,kv_store): add key-value store module

This contains in-memory implementations and a property test, so far.

Author: PiDelport

rtc_tenclave/src/kv_store/in_memory.rs

@@ -0,0 +1,51 @@
+//! In-memory implementations of [`KvStore`] (for testing)
+
+use serde::de::DeserializeOwned;
+use serde::Serialize;
+use std::collections::HashMap;
+use std::prelude::v1::*;
+
+use super::{KvStore, StoreResult};
+
+/// In-memory [`KvStore`] using [`HashMap`]
+#[derive(Default)]
+pub struct InMemoryStore<V> {
+    pub(crate) map: HashMap<String, V>,
+}
+
+impl<V> KvStore<V> for InMemoryStore<V>
+where
+    V: Clone,
+{
+    fn load(&self, key: &str) -> StoreResult<Option<V>> {
+        Ok(self.map.get(key).cloned())
+    }
+
+    fn save(&mut self, key: &str, value: V) -> StoreResult<()> {
+        self.map.insert(key.to_string(), value);
+        Ok(())
+    }
+}
+
+/// In-memory [`KvStore`] using [`HashMap`] and [`serde_json`] serialization
+#[derive(Default)]
+pub struct InMemoryJsonStore {
+    pub(crate) map: HashMap<String, Vec<u8>>,
+}
+
+impl<V> KvStore<V> for InMemoryJsonStore
+where
+    V: Serialize + DeserializeOwned,
+{
+    fn load(&self, key: &str) -> StoreResult<Option<V>> {
+        let loaded: Option<&[u8]> = self.map.get(key).map(|v| v.as_slice());
+        let deserialized: Option<V> = loaded.map(serde_json::from_slice).transpose()?;
+        Ok(deserialized)
+    }
+
+    fn save(&mut self, key: &str, value: V) -> StoreResult<()> {
+        let serialized = serde_json::to_vec(&value)?;
+        self.map.insert(key.to_string(), serialized);
+        Ok(())
+    }
+}

rtc_tenclave/src/kv_store/inspect.rs

@@ -0,0 +1,39 @@
+//! Support for inspecting [`KvStore`] instances (for testing and debugging)
+
+use serde::de::DeserializeOwned;
+use serde::Serialize;
+use std::borrow::ToOwned;
+use std::collections::HashMap;
+use std::iter::Iterator;
+
+use super::in_memory::{InMemoryJsonStore, InMemoryStore};
+use super::KvStore;
+
+pub trait InspectStore<V> {
+    fn as_map(&self) -> HashMap<String, V>;
+}
+
+impl<V> InspectStore<V> for InMemoryStore<V>
+where
+    V: Clone,
+{
+    fn as_map(&self) -> HashMap<String, V> {
+        self.map.clone()
+    }
+}
+
+impl<V> InspectStore<V> for InMemoryJsonStore
+where
+    V: Serialize + DeserializeOwned,
+{
+    fn as_map(&self) -> HashMap<String, V> {
+        self.map
+            .keys()
+            .map(|k| {
+                let loaded: Option<V> = self.load(&k).expect(&format!("load {:?} failed!", k));
+                let v: V = loaded.expect(&format!("key missing! {:?}", k));
+                (k.to_owned(), v)
+            })
+            .collect()
+    }
+}

rtc_tenclave/src/kv_store/mod.rs

@@ -0,0 +1,37 @@
+//! Simple key-value store abstraction
+
+use std::boxed::Box;
+use std::error::Error;
+
+type StoreResult<T> = Result<T, Box<dyn Error>>;
+
+/// A key-value store.
+///
+/// These methods borrow key references, and
+///
+pub trait KvStore<V> {
+    // TODO: Use associated type for V?
+
+    /// Load the saved value for `key`, if any.
+    ///
+    /// Return [`None`] if `key` has no previous value.
+    ///
+    fn load(&self, key: &str) -> StoreResult<Option<V>>;
+
+    /// Save a new value for `key`.
+    ///
+    /// This will replace any existing value.
+    ///
+    fn save(&mut self, key: &str, value: V) -> StoreResult<()>;
+
+    // TODO: add update()
+}
+
+#[cfg(test)]
+mod in_memory;
+
+#[cfg(test)]
+mod inspect;
+
+#[cfg(test)]
+mod tests;

rtc_tenclave/src/kv_store/tests.rs

@@ -0,0 +1,46 @@
+//! Tests for [`rtc_tenclave::kv_store`]
+
+use std::collections::HashMap;
+
+use proptest::prelude::*;
+
+use super::in_memory::{InMemoryJsonStore, InMemoryStore};
+use super::inspect::InspectStore;
+use super::KvStore;
+
+/// Verify that executing a sequence of store operations matches a simple model.
+#[test]
+fn prop_store_ops_match_model() {
+    // Strategy to generate store operations: currently, just key / value pairs to save.
+    let store_ops_strategy = {
+        let keys = prop_oneof!(r"[a-z]{0,5}", ".*");
+        let values = prop_oneof!(keys.clone()); // TODO: Non-string values
+
+        // This strategy will generate key / value pairs with multiple values per key,
+        // and shuffle them to have some interleaving, for bugs that depend on that.
+        proptest::collection::hash_map(keys, proptest::collection::vec(values, 0..10), 0..10)
+            .prop_map(flatten_key_values)
+            .prop_shuffle()
+    };
+
+    proptest!(|(store_ops_vec in store_ops_strategy)| {
+        type V = String;
+        let mut store_model: InMemoryStore<V> = InMemoryStore::default();
+        let mut store_model_json: InMemoryJsonStore = InMemoryJsonStore::default();
+        // TODO: FS-based store
+
+        for (k, v) in store_ops_vec {
+            store_model.save(&k, v.clone()).expect("InMemoryStore save failed!");
+            store_model_json.save(&k, v.clone()).expect("InMemoryJsonStore save failed!");
+
+            prop_assert_eq!(store_model.as_map(), store_model_json.as_map());
+        }
+    });
+}
+
+/// Helper: Flatten `{K => [V, …], …}` to `[(K, V), …]`, cloning `K` for each `V`.
+fn flatten_key_values<K: Clone, V>(kvs: HashMap<K, Vec<V>>) -> Vec<(K, V)> {
+    kvs.into_iter()
+        .flat_map(|(k, vs)| vs.into_iter().map(move |v| (k.clone(), v)))
+        .collect()
+}

rtc_tenclave/src/lib.rs

@@ -23,4 +23,5 @@ cfg_if::cfg_if! {
 
 pub mod crypto;
 pub mod enclave;
+pub mod kv_store;
 pub mod util;