feat(storage): adding sled, making rocksdb optional

Author: distractedm1nd

Cargo.lock

@@ -8,9 +8,9 @@ authors = [
 ]
 edition = "2024"
 description = "prism is the first trust-minimized key-transparency solution, allowing for automatic verification of service providers via light clients. Powered by Celestia."
-homepage = "https://prism.deltadevs.xyz"
+homepage = "https://prism.rs"
 repository = "https://github.com/deltadevsde/prism"
-license = "MIT"
+license = "AGPL-3.0"
 keywords = ["crypto", "key-transparency"]
 readme = "README.md"
 
@@ -82,8 +82,8 @@ url = { version = "2.5" }
 
 # database
 redis = "0.24.0"
-rocksdb = { version = "0.21.0", features = ["multi-threaded-cf"] }
 redb = "2.6.0"
+sled = "0.34.7"
 
 # async
 async-trait = "0.1.86"
@@ -278,3 +278,8 @@ zero_sized_map_values = "warn"
 # https://davidlattimore.github.io/posts/2024/02/04/speeding-up-the-rust-edit-build-run-cycle.html
 debug = "line-tables-only"
 split-debuginfo = "unpacked"
+
+[profile.bench]
+opt-level = 3
+debug = false
+lto = true

Cargo.toml

@@ -12,6 +12,7 @@ path = "src/main.rs"
 
 [features]
 default = []
+rocksdb = ["prism-storage/rocksdb"]
 test_utils = []
 
 

crates/cli/Cargo.toml

@@ -7,13 +7,17 @@ use prism_errors::{DataAvailabilityError, GeneralError};
 use prism_keys::VerifyingKey;
 use prism_prover::{prover::DEFAULT_MAX_EPOCHLESS_GAP, webserver::WebServerConfig};
 use prism_serde::base64::FromBase64;
+
+#[cfg(feature = "rocksdb")]
+use prism_storage::rocksdb::{RocksDBConfig, RocksDBConnection};
 use prism_storage::{
     Database, RedisConnection,
     database::StorageBackend,
     inmemory::InMemoryDatabase,
     redis::RedisConfig,
-    rocksdb::{RocksDBConfig, RocksDBConnection},
+    sled::{SledConfig, SledConnection},
 };
+
 use prism_telemetry::config::{TelemetryConfig, get_default_telemetry_config};
 use serde::{Deserialize, Serialize};
 use std::{fs, path::Path, str::FromStr, sync::Arc, time::Duration};
@@ -136,7 +140,7 @@ impl Config {
             keystore_path: Some(format!("{}keystore.json", path)),
             network: Network::from_str(network_name).unwrap().config(),
             da_layer: DALayerOption::default(),
-            db: StorageBackend::RocksDB(RocksDBConfig::new(&format!("{}data", path))),
+            db: StorageBackend::Sled(SledConfig::new(&format!("{}data", path))),
             telemetry: Some(get_default_telemetry_config()),
             max_epochless_gap: DEFAULT_MAX_EPOCHLESS_GAP,
         }
@@ -153,20 +157,22 @@ pub enum DALayerOption {
 #[derive(Debug, Default, Clone, Eq, PartialEq, Serialize, Deserialize, ValueEnum)]
 pub enum DBValues {
     #[default]
+    Sled,
+    #[cfg(feature = "rocksdb")]
     RocksDB,
     InMemory,
     Redis,
 }
 
 #[derive(Args, Deserialize, Clone, Debug)]
 pub struct DatabaseArgs {
-    #[arg(long, value_enum, default_value_t = DBValues::RocksDB)]
-    /// Storage backend to use. Default: `rocks-db`
+    #[arg(long, value_enum, default_value_t = DBValues::Sled)]
+    /// Storage backend to use. Default: `sled`
     db_type: DBValues,
 
-    /// Path to the RocksDB database, used when `db_type` is `rocks-db`
+    /// Path to the database, used when `db_type` is `rocks-db` or `sled`
     #[arg(long)]
-    rocksdb_path: Option<String>,
+    db_path: Option<String>,
 
     /// Connection string to Redis, used when `db_type` is `redis`
     #[arg(long, required_if_eq("db_type", "redis"))]
@@ -184,7 +190,7 @@ pub fn load_config(args: CommandArgs) -> Result<Config> {
     )
     .context("Failed to ensure config file exists")?;
 
-    if let Some(rocksdb_path) = &args.database.rocksdb_path {
+    if let Some(rocksdb_path) = &args.database.db_path {
         fs::create_dir_all(rocksdb_path).context("Failed to create RocksDB directory")?;
     }
 
@@ -287,9 +293,14 @@ fn apply_command_line_args(config: Config, args: CommandArgs) -> Config {
             port: args.webserver.port.unwrap_or(webserver_config.port),
         }),
         db: match args.database.db_type {
+            #[cfg(feature = "rocksdb")]
             DBValues::RocksDB => StorageBackend::RocksDB(RocksDBConfig {
                 path: args.database.rocksdb_path.unwrap_or_else(|| format!("{}/data", prism_home)),
             }),
+            DBValues::Sled => StorageBackend::Sled(SledConfig {
+                path: args.database.db_path.unwrap_or_else(|| format!("{}/data", prism_home)),
+                ..SledConfig::default()
+            }),
             DBValues::Redis => StorageBackend::Redis(RedisConfig {
                 connection_string: args.database.redis_url.unwrap_or_default(),
             }),
@@ -314,13 +325,22 @@ fn apply_command_line_args(config: Config, args: CommandArgs) -> Config {
 
 pub fn initialize_db(cfg: &Config) -> Result<Arc<Box<dyn Database>>> {
     match &cfg.db {
+        #[cfg(feature = "rocksdb")]
         StorageBackend::RocksDB(cfg) => {
             let db = RocksDBConnection::new(cfg)
                 .map_err(|e| GeneralError::InitializationError(e.to_string()))
                 .context("Failed to initialize RocksDB")?;
 
             Ok(Arc::new(Box::new(db) as Box<dyn Database>))
         }
+        StorageBackend::Sled(cfg) => {
+            let db = SledConnection::new(cfg)
+                .map_err(|e| GeneralError::InitializationError(e.to_string()))
+                .context("Failed to initialize Sled")?;
+
+            Ok(Arc::new(Box::new(db) as Box<dyn Database>))
+        }
+
         StorageBackend::InMemory => Ok(Arc::new(
             Box::new(InMemoryDatabase::new()) as Box<dyn Database>
         )),

crates/cli/src/cfg.rs

@@ -10,8 +10,13 @@ license.workspace = true
 keywords.workspace = true
 readme.workspace = true
 
+[features]
+default = []
+rocksdb = ["dep:rocksdb"]
+
 [dependencies]
 serde = { workspace = true }
+sled = { workspace = true }
 redis = { workspace = true }
 tracing = { workspace = true }
 anyhow = { workspace = true }
@@ -21,7 +26,10 @@ prism-da = { workspace = true }
 prism-common = { workspace = true }
 prism-serde = { workspace = true }
 auto_impl = { workspace = true }
-rocksdb = { workspace = true }
+rocksdb = { version = "0.21.0", features = [
+  "multi-threaded-cf",
+], optional = true }
 
 [dev-dependencies]
+paste = { workspace = true }
 tempfile.workspace = true

crates/storage/Cargo.toml

@@ -8,9 +8,11 @@ use serde::{Deserialize, Serialize};
 
 #[derive(Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]
 pub enum StorageBackend {
+    #[cfg(feature = "rocksdb")]
     RocksDB(crate::rocksdb::RocksDBConfig),
     InMemory,
     Redis(crate::redis::RedisConfig),
+    Sled(crate::sled::SledConfig),
 }
 
 #[auto_impl(&, Box, Arc)]

crates/storage/src/database.rs

@@ -1,6 +1,9 @@
 pub mod database;
 pub mod inmemory;
 pub mod redis;
+pub mod sled;
+
+#[cfg(feature = "rocksdb")]
 pub mod rocksdb;
 
 #[cfg(test)]

crates/storage/src/lib.rs

@@ -232,7 +232,6 @@ impl TreeWriter for RocksDBConnection {
             let encoded_value =
                 value.as_ref().map(|v| v.encode_to_bytes()).transpose()?.unwrap_or_default();
             let version_bytes = version.to_be_bytes();
-
             batch.put(
                 format!("{}:{}", value_key, version_bytes.to_hex()).as_bytes(),
                 &encoded_value,
@@ -243,69 +242,3 @@ impl TreeWriter for RocksDBConnection {
         Ok(())
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use jmt::{KeyHash, OwnedValue, Version};
-    use tempfile::TempDir;
-
-    fn setup_db() -> (TempDir, RocksDBConnection) {
-        let temp_dir = TempDir::new().unwrap();
-        let cfg = RocksDBConfig::new(temp_dir.path().to_str().unwrap());
-        let db = RocksDBConnection::new(&cfg).unwrap();
-        (temp_dir, db)
-    }
-
-    #[test]
-    fn test_rw_commitment() {
-        let (_temp_dir, db) = setup_db();
-
-        let epoch = 1;
-        let commitment = Digest([1; 32]);
-
-        db.set_commitment(&epoch, &commitment).unwrap();
-        let read_commitment = db.get_commitment(&epoch).unwrap();
-
-        assert_eq!(read_commitment, commitment);
-    }
-
-    #[test]
-    fn test_write_and_read_value() {
-        let (_temp_dir, db) = setup_db();
-
-        let key_hash = KeyHash([1; 32]);
-        let value: OwnedValue = vec![4, 5, 6];
-        let version: Version = 1;
-
-        let mut batch = NodeBatch::default();
-        batch.insert_value(version, key_hash, value.clone());
-
-        db.write_node_batch(&batch).unwrap();
-
-        let read_value = db.get_value_option(version, key_hash).unwrap();
-        assert_eq!(read_value, Some(value));
-    }
-
-    #[test]
-    fn test_get_value_option_with_multiple_versions() {
-        let (_temp_dir, db) = setup_db();
-
-        let key_hash = KeyHash([2; 32]);
-        let value1: OwnedValue = vec![1, 1, 1];
-        let value2: OwnedValue = vec![2, 2, 2];
-
-        let mut batch = NodeBatch::default();
-        batch.insert_value(1, key_hash, value1.clone());
-        batch.insert_value(2, key_hash, value2.clone());
-
-        db.write_node_batch(&batch).unwrap();
-
-        assert_eq!(db.get_value_option(1, key_hash).unwrap(), Some(value1));
-        assert_eq!(
-            db.get_value_option(2, key_hash).unwrap(),
-            Some(value2.clone())
-        );
-        assert_eq!(db.get_value_option(3, key_hash).unwrap(), Some(value2));
-    }
-}