Merge pull request #10 from catusax/feat/v2

feat: add Cursor

Author: catusax

Diff for: Cargo.lock

@@ -39,7 +39,7 @@ tonic-build = "0.12.3"
 
 [dev-dependencies]
 bollard = "0.18.1"
-tempdir = "0.3.7"
+tempfile = "3.16.0"
 
 [profile.release]
 lto = true

Diff for: Cargo.toml

@@ -244,7 +244,7 @@ mod tests {
     use super::*;
     use crate::net::utils::Address;
     use energon::drand::schemes::DefaultScheme;
-    use tempdir;
+    use tempfile::tempdir;
 
     // #Required permissions
     //
@@ -261,7 +261,7 @@ mod tests {
     #[test]
     fn check_permissions_and_data() {
         // Build absolute path for base folder 'testnet'
-        let temp_dir = tempdir::TempDir::new("permission_test").unwrap();
+        let temp_dir = tempdir().unwrap();
         let base_path = temp_dir
             .path()
             .join("testnet")

Diff for: src/key/store.rs

@@ -0,0 +1,63 @@
+use tonic::async_trait;
+
+use super::MemStore;
+
+use crate::store::{Beacon, BeaconCursor, StorageError, Store};
+
+pub struct MemDbCursor<'a> {
+    pos: usize,
+    store: &'a MemStore,
+}
+
+impl<'a> MemDbCursor<'a> {
+    pub fn new(store: &'a MemStore) -> Self {
+        MemDbCursor { pos: 0, store }
+    }
+}
+
+#[async_trait]
+impl BeaconCursor for MemDbCursor<'_> {
+    async fn first(&mut self) -> Result<Option<Beacon>, StorageError> {
+        match self.store.first().await {
+            Ok(beacon) => {
+                self.pos = 0;
+                Ok(Some(beacon))
+            }
+            Err(StorageError::NotFound) => Ok(None),
+            Err(e) => Err(e),
+        }
+    }
+
+    async fn next(&mut self) -> Result<Option<Beacon>, StorageError> {
+        match self.store.get_at_position(self.pos + 1).await {
+            Ok(beacon) => {
+                self.pos += 1;
+                Ok(Some(beacon))
+            }
+            Err(StorageError::NotFound) => Ok(None),
+            Err(e) => Err(e),
+        }
+    }
+
+    async fn seek(&mut self, round: u64) -> Result<Option<Beacon>, StorageError> {
+        match self.store.get_beacon(round).await {
+            Ok(beacon) => {
+                self.pos = self.store.get_pos(beacon.round).await?;
+                Ok(Some(beacon))
+            }
+            Err(StorageError::NotFound) => Ok(None),
+            Err(e) => Err(e),
+        }
+    }
+
+    async fn last(&mut self) -> Result<Option<Beacon>, StorageError> {
+        match self.store.last().await {
+            Ok(beacon) => {
+                self.pos = self.store.len().await? - 1;
+                Ok(Some(beacon))
+            }
+            Err(StorageError::NotFound) => Ok(None),
+            Err(e) => Err(e),
+        }
+    }
+}