Alternative to rocksdb: Added jammdb as another lightweight option for wallet storage

bindings/core/Cargo.toml

@@ -32,5 +32,6 @@ ledger_nano = [ "iota-sdk/ledger_nano" ]
 mqtt = [ "iota-sdk/mqtt" ]
 participation = [ "iota-sdk/participation" ]
 rocksdb = [ "iota-sdk/rocksdb" ]
+jammdb = ["iota-sdk/jammdb"]
 storage = [ "iota-sdk/storage" ]
 stronghold = [ "iota-sdk/stronghold" ]

sdk/Cargo.toml

@@ -82,6 +82,7 @@ reqwest = { version = "0.11.18", default-features = false, features = [
 rocksdb = { version = "0.21.0", default-features = false, features = [
     "lz4",
 ], optional = true }
+jammdb = { version = "0.10.0", optional = true}
 rumqttc = { version = "0.22.0", default-features = false, features = [
     "websocket",
 ], optional = true }
@@ -146,6 +147,7 @@ mqtt = ["std", "regex", "rumqttc", "dep:once_cell"]
 participation = ["storage"]
 pow = ["std", "num_cpus", "iota-crypto/curl-p"]
 rand = ["dep:rand"]
+jammdb = ["dep:jammdb", "storage"]
 rocksdb = ["dep:rocksdb", "storage"]
 serde = [
     "serde_repr",

sdk/src/wallet/core/builder.rs

@@ -15,7 +15,7 @@
 use super::operations::storage::SaveLoadWallet;
 #[cfg(feature = "events")]
 use crate::wallet::events::EventEmitter;
-#[cfg(all(feature = "storage", not(feature = "rocksdb")))]
+#[cfg(all(feature = "storage", not(feature = "rocksdb"), not(feature = "jammdb")))]
 use crate::wallet::storage::adapter::memory::Memory;
 #[cfg(feature = "storage")]
 use crate::wallet::{
@@ -134,14 +134,16 @@
             }
         }
 
-        #[cfg(all(feature = "rocksdb", feature = "storage"))]
+        #[cfg(all(not(feature = "jammdb"), feature = "rocksdb", feature = "storage"))]
         let storage =
             crate::wallet::storage::adapter::rocksdb::RocksdbStorageAdapter::new(storage_options.path.clone())?;
-        #[cfg(all(not(feature = "rocksdb"), feature = "storage"))]
+        #[cfg(all(not(feature = "rocksdb"), feature = "jammdb", feature = "storage"))]
+        let storage = crate::wallet::storage::adapter::jammdb::JammdbStorageAdapter::new(storage_options.path.clone())?;
+        #[cfg(all(not(feature = "rocksdb"), not(feature = "jammdb"), feature = "storage"))]
         let storage = Memory::default();
 
         #[cfg(feature = "storage")]
         let mut storage_manager = StorageManager::new(storage, storage_options.encryption_key.clone()).await?;
 
         #[cfg(feature = "storage")]
         let read_manager_builder = Self::load(&storage_manager).await?;

sdk/src/wallet/error.rs

@@ -189,3 +189,10 @@ impl From<rocksdb::Error> for Error {
         Self::Storage(error.to_string())
     }
 }
+
+#[cfg(feature = "jammdb")]
+impl From<jammdb::Error> for Error {
+    fn from(error: jammdb::Error) -> Self {
+        Self::Storage(error.to_string())
+    }
+}

sdk/src/wallet/storage/adapter/jammdb.rs

@@ -0,0 +1,83 @@
+// Copyright 2020 IOTA Stiftung
+// SPDX-License-Identifier: Apache-2.0
+
+use super::StorageAdapter;
+use jammdb::{OpenOptions, DB};
+use std::{
+    fmt::Debug,
+    path::{Path, PathBuf},
+    sync::Arc,
+};
+use tokio::sync::Mutex;
+
+/// The storage id.
+pub const STORAGE_ID: &str = "JammDB";
+
+const BUCKET_NAME: &str = "storage";
+
+impl Debug for JammdbStorageAdapter {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "JammDbStorageAdapter")
+    }
+}
+
+/// Key value storage adapter.
+pub struct JammdbStorageAdapter {
+    db: Arc<Mutex<DB>>,
+}
+
+impl JammdbStorageAdapter {
+    /// Initialises the storage adapter.
+    pub fn new(path: impl AsRef<Path>) -> crate::wallet::Result<Self> {
+        let mut db_path = PathBuf::from("./sdk-wallet.db");
+        let dir_path = path.as_ref().to_string_lossy().to_string();
+        let mut temp_path = PathBuf::from(dir_path);
+        if path.as_ref().is_dir() {
+            temp_path.push(db_path);
+        }
+        db_path = temp_path;
+        let db = OpenOptions::new().pagesize(4096).num_pages(32).open(db_path)?;
+        // create a default bucket
+        let tx = db.tx(true)?;
+        let bucket = tx.get_or_create_bucket(BUCKET_NAME)?;
+        bucket.put("INITIAL_KEY", "INIT_VALUE")?; // needs some initial value
+        tx.commit()?;
+        Ok(Self {
+            db: Arc::new(Mutex::new(db)),
+        })
+    }
+}
+
+#[async_trait::async_trait]
+impl StorageAdapter for JammdbStorageAdapter {
+    type Error = crate::wallet::Error;
+
+    async fn get_bytes(&self, key: &str) -> Result<Option<Vec<u8>>, Self::Error> {
+        let db = self.db.lock().await;
+        let tx = db.tx(false)?;
+        let bucket = tx.get_bucket(BUCKET_NAME)?;
+        match bucket.get(key) {
+            Some(r) => Ok(Some(r.kv().value().into())),
+            None => Ok(None),
+        }
+    }
+
+    async fn set_bytes(&self, key: &str, record: &[u8]) -> Result<(), Self::Error> {
+        let db = self.db.lock().await;
+        let tx = db.tx(true)?;
+        let bucket = tx.get_bucket(BUCKET_NAME)?;
+        bucket.put(key, record)?;
+        tx.commit()?;
+        Ok(())
+    }
+
+    async fn delete(&self, key: &str) -> crate::wallet::Result<()> {
+        let db = self.db.lock().await;
+        let tx = db.tx(true)?;
+        let bucket = tx.get_bucket(BUCKET_NAME)?;
+
+        bucket.delete(key)?;
+        tx.commit()?;
+        Ok(())
+    }
+}

sdk/src/wallet/storage/adapter/mod.rs

@@ -4,9 +4,16 @@
 pub mod memory;
 /// RocksDB storage adapter.
 #[cfg(feature = "rocksdb")]
+#[cfg(not(feature = "jammdb"))]
 #[cfg_attr(docsrs, doc(cfg(feature = "rocksdb")))]
 pub mod rocksdb;
 
+/// JammDB storage adapter.
+#[cfg(feature = "jammdb")]
+#[cfg(not(feature = "rocksdb"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "jammdb")))]
+pub mod jammdb;
+
 use async_trait::async_trait;
 
 use crate::client::storage::StorageAdapter;

sdk/src/wallet/storage/constants.rs

@@ -4,14 +4,20 @@
 /// The default storage path.
 pub const DEFAULT_STORAGE_PATH: &str = "./storage";
 
+/// The default RocksDB storage path.
+#[cfg(feature = "jammdb")]
+pub(crate) const JAMMDB_FOLDERNAME: &str = "walletdb";
+
 /// The default RocksDB storage path.
 #[cfg(feature = "rocksdb")]
 pub(crate) const ROCKSDB_FOLDERNAME: &str = "walletdb";
 
 pub const fn default_storage_path() -> &'static str {
-    #[cfg(feature = "rocksdb")]
+    #[cfg(all(not(feature = "jammdb"), feature = "rocksdb"))]
     return ROCKSDB_FOLDERNAME;
-    #[cfg(not(feature = "rocksdb"))]
+    #[cfg(all(not(feature = "rocksdb"), feature = "jammdb"))]
+    return JAMMDB_FOLDERNAME;
+    #[cfg(all(not(feature = "rocksdb"), not(feature = "jammdb")))]
     DEFAULT_STORAGE_PATH
 }
 

sdk/src/wallet/storage/kind.rs

@@ -9,7 +9,12 @@
 pub enum StorageKind {
     /// RocksDB storage.
     #[cfg(feature = "rocksdb")]
+    #[cfg(not(feature = "jammdb"))]
     Rocksdb,
+    /// JammDB storage
+    #[cfg(feature = "jammdb")]
+    #[cfg(not(feature = "rocksdb"))]
+    Jammdb,
     /// Storage backed by a Map in memory.
     Memory,
     /// Wasm storage.
@@ -18,12 +23,16 @@
 }
 
 impl Default for StorageKind {
     fn default() -> Self {
         #[cfg(feature = "rocksdb")]
+        #[cfg(not(feature = "jammdb"))]
         return Self::Rocksdb;
+        #[cfg(feature = "jammdb")]
+        #[cfg(not(feature = "rocksdb"))]
+        return Self::Jammdb;
         #[cfg(target_family = "wasm")]
         return Self::Wasm;
-        #[cfg(not(any(feature = "rocksdb", target_family = "wasm")))]
+        #[cfg(not(any(feature = "rocksdb", target_family = "wasm", feature = "jammdb")))]
         Self::Memory
     }
 }