Deleted swimos_store. Removed dead code.

Author: horned-sphere

runtime/swimos_rocks_store/Cargo.toml

@@ -4,13 +4,12 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
+swimos_api = { path = "../../api/swimos_api" }
 swimos_model = { path = "../../api/swimos_model" }
-swimos_store = { path = "../swimos_store" }
 rocksdb = { workspace = true }
 futures = { workspace = true }
 swimos_utilities = { path = "../../swimos_utilities", features = ["io", "circular_buffer", "future"] }
 swimos_form = { path = "../../api/swimos_form" }
-swimos_api = { path = "../../api/swimos_api" }
 tokio = { workspace = true, features = ["sync"] }
 futures-util = { workspace = true }
 bytes = { workspace = true }

runtime/swimos_rocks_store/src/agent/mock/mod.rs

@@ -12,11 +12,12 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use swimos_api::error::StoreError;
+
 use crate::agent::{NodeStore, SwimNodeStore};
+use crate::nostore::NoRange;
 use crate::plane::mock::MockPlaneStore;
 use crate::server::{StoreEngine, StoreKey};
-use swimos_store::nostore::NoRange;
-use swimos_store::StoreError;
 
 #[derive(Clone, Debug)]
 pub struct MockNodeStore {

runtime/swimos_rocks_store/src/agent/mod.rs

@@ -12,6 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#[cfg(test)]
 pub mod mock;
 
 use std::fmt::{Debug, Formatter};
@@ -20,14 +21,13 @@ use std::sync::Arc;
 use bytes::BytesMut;
 use futures::future::{ready, BoxFuture};
 use futures::FutureExt;
-use swimos_api::persistence::{NodePersistence, PlanePersistence};
+use swimos_api::error::StoreError;
+use swimos_api::persistence::{NodePersistence, PlanePersistence, RangeConsumer};
 use swimos_model::Text;
 
 use crate::plane::PlaneStore;
 use crate::server::{StoreEngine, StoreKey};
 
-use swimos_store::{RangeConsumer, StoreError};
-
 /// A trait for defining store engines which open stores for nodes.
 ///
 /// Node stores are responsible for ensuring that the data models that they open for their lanes

runtime/swimos_rocks_store/src/engine/iterator.rs

@@ -12,39 +12,11 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use rocksdb::{DBIteratorWithThreadMode, DBRawIterator, DBWithThreadMode, SingleThreaded};
-use swimos_store::{EngineIterator, EnginePrefixIterator, IteratorKey, KeyValue, KvBytes};
-use swimos_store::{RangeConsumer, StoreError};
-
-pub struct RocksPrefixIterator<'p> {
-    delegate: DBIteratorWithThreadMode<'p, DBWithThreadMode<SingleThreaded>>,
-}
-
-impl<'p> From<DBIteratorWithThreadMode<'p, DBWithThreadMode<SingleThreaded>>>
-    for RocksPrefixIterator<'p>
-{
-    fn from(delegate: DBIteratorWithThreadMode<'p, DBWithThreadMode<SingleThreaded>>) -> Self {
-        RocksPrefixIterator { delegate }
-    }
-}
-
-impl<'d> EnginePrefixIterator for RocksPrefixIterator<'d> {
-    fn next(&mut self) -> Option<Result<KvBytes, StoreError>> {
-        self.delegate
-            .next()
-            .map(|r| r.map_err(|e| StoreError::Delegate(Box::new(e))))
-    }
-}
-
-pub struct RocksIterator<'d> {
-    iter: DBRawIterator<'d>,
-}
-
-impl<'d> From<DBRawIterator<'d>> for RocksIterator<'d> {
-    fn from(iter: DBRawIterator<'d>) -> Self {
-        RocksIterator { iter }
-    }
-}
+use rocksdb::DBRawIterator;
+use swimos_api::{
+    error::StoreError,
+    persistence::{KeyValue, RangeConsumer},
+};
 
 pub struct RocksRawPrefixIterator<'d> {
     first: bool,
@@ -74,35 +46,3 @@ impl<'d> RangeConsumer for RocksRawPrefixIterator<'d> {
         }
     }
 }
-
-impl<'d> EngineIterator for RocksIterator<'d> {
-    fn seek_to(&mut self, key: IteratorKey) -> Result<bool, StoreError> {
-        match key {
-            IteratorKey::Start => self.iter.seek_to_first(),
-            IteratorKey::End => self.iter.seek_to_last(),
-            IteratorKey::ToKey(key) => self.iter.seek(key),
-        }
-        self.valid()
-    }
-
-    fn seek_next(&mut self) {
-        self.iter.next();
-    }
-
-    fn key(&self) -> Option<&[u8]> {
-        self.iter.key()
-    }
-
-    fn value(&self) -> Option<&[u8]> {
-        self.iter.value()
-    }
-
-    fn valid(&self) -> Result<bool, StoreError> {
-        if !self.iter.valid() {
-            self.iter
-                .status()
-                .map_err(|e| StoreError::Delegate(Box::new(e)))?;
-        }
-        Ok(self.iter.valid())
-    }
-}

runtime/swimos_rocks_store/src/engine/mod.rs

@@ -17,17 +17,17 @@ mod tests;
 
 mod iterator;
 
-pub use iterator::{RocksIterator, RocksPrefixIterator, RocksRawPrefixIterator};
+pub use iterator::RocksRawPrefixIterator;
 
 use rocksdb::{ColumnFamily, ColumnFamilyDescriptor, ReadOptions};
 use rocksdb::{Options, DB};
 use std::path::Path;
 use std::sync::Arc;
-use swimos_store::EnginePrefixIterator;
-use swimos_store::{
-    serialize_u64, EngineInfo, Keyspace, KeyspaceByteEngine, KeyspaceResolver, Keyspaces, Store,
-    StoreBuilder, StoreError, MAX_ID_SIZE,
-};
+use swimos_api::error::StoreError;
+
+use crate::keyspaces::{Keyspace, KeyspaceByteEngine, KeyspaceResolver, Keyspaces};
+use crate::store::{Store, StoreBuilder};
+use crate::utils::{serialize_u64, MAX_ID_SIZE};
 
 /// A Rocks database engine.
 ///
@@ -37,47 +37,14 @@ pub struct RocksEngine {
     pub(crate) delegate: Arc<DB>,
 }
 
+impl Store for RocksEngine {}
+
 impl RocksEngine {
     pub fn new(delegate: DB) -> RocksEngine {
         RocksEngine {
             delegate: Arc::new(delegate),
         }
     }
-
-    /// Returns an iterator over the entire store.
-    pub fn iterator<'a: 'b, 'b>(
-        &'a self,
-        space: &'b <Self as KeyspaceResolver>::ResolvedKeyspace,
-    ) -> Result<RocksIterator<'b>, StoreError> {
-        let mut iter = self.delegate.raw_iterator_cf(space);
-        iter.seek_to_first();
-
-        Ok(iter.into())
-    }
-
-    /// Returns an iterator for all of the elements in the keyspace `space` that have keys that are
-    /// prefixed by `prefix` and with the default iterator options.
-    pub fn prefix_iterator<'a: 'b, 'b>(
-        &'a self,
-        space: &'b <Self as KeyspaceResolver>::ResolvedKeyspace,
-        prefix: &'b [u8],
-    ) -> Result<RocksPrefixIterator<'b>, StoreError> {
-        let it = self.delegate.prefix_iterator_cf(space, prefix);
-        Ok(it.into())
-    }
-}
-
-impl Store for RocksEngine {
-    fn path(&self) -> &Path {
-        self.delegate.path()
-    }
-
-    fn engine_info(&self) -> EngineInfo {
-        EngineInfo {
-            path: self.path().to_string_lossy().to_string(),
-            kind: "RocksDB".to_string(),
-        }
-    }
 }
 
 impl KeyspaceResolver for RocksEngine {
@@ -201,40 +168,6 @@ impl KeyspaceByteEngine for RocksEngine {
         })
     }
 
-    fn get_prefix_range<F, K, V, S>(
-        &self,
-        keyspace: S,
-        prefix: &[u8],
-        map_fn: F,
-    ) -> Result<Option<Vec<(K, V)>>, StoreError>
-    where
-        F: for<'i> Fn(&'i [u8], &'i [u8]) -> Result<(K, V), StoreError>,
-        S: Keyspace,
-    {
-        let resolved = self
-            .resolve_keyspace(&keyspace)
-            .ok_or(StoreError::KeyspaceNotFound)?;
-        let mut it = self.prefix_iterator(resolved, prefix)?;
-        let mut data = Vec::new();
-
-        loop {
-            match it.next() {
-                Some(Ok((key, value))) => {
-                    let mapped = map_fn(key.as_ref(), value.as_ref())?;
-                    data.push(mapped);
-                }
-                Some(Err(e)) => return Err(e),
-                _ => break,
-            }
-        }
-
-        if data.is_empty() {
-            Ok(None)
-        } else {
-            Ok(Some(data))
-        }
-    }
-
     fn delete_key_range<S>(
         &self,
         keyspace: S,