feat: add RocksDB variant to EitherReader and EitherWriter

Add RocksDB variants and constructors to EitherReader, EitherWriter, and EitherWriterDestination enums.

**Changes**
- Add `EitherWriterDestination::RocksDB` variant
- Add `EitherWriter::RocksDB` variant (cfg-gated)
- Add `EitherReader::RocksDB` variant (cfg-gated)
- Add `new_storages_history()` constructor for EitherWriter/EitherReader
- Add `new_transaction_hash_numbers()` constructor for EitherWriter/EitherReader

Closes #20278, #20279, #20280

Author: yongkangc

crates/storage/provider/src/either_writer.rs

@@ -3,8 +3,8 @@
 
 use std::ops::Range;
 
-#[cfg(all(unix, feature = "rocksdb"))]
-use crate::{providers::RocksDBProvider, RocksDBProviderFactory};
+#[cfg(feature = "rocksdb")]
+use crate::providers::RocksDBProvider;
 use crate::{
     providers::{StaticFileProvider, StaticFileProviderRWRefMut},
     StaticFileProviderFactory,
@@ -36,16 +36,6 @@ type EitherWriterTy<'a, P, T> = EitherWriter<
     <P as NodePrimitivesProvider>::Primitives,
 >;
 
-#[cfg(all(unix, feature = "rocksdb"))]
-type RocksDBReader = RocksDBProvider;
-#[cfg(not(all(unix, feature = "rocksdb")))]
-type RocksDBReader = ();
-
-#[cfg(all(unix, feature = "rocksdb"))]
-type RocksDBWriter = RocksDBProvider;
-#[cfg(not(all(unix, feature = "rocksdb")))]
-type RocksDBWriter = ();
-
 /// Represents a destination for writing data, either to database, static files, or `RocksDB`.
 #[derive(Debug, Display)]
 pub enum EitherWriter<'a, CURSOR, N> {
@@ -54,7 +44,8 @@ pub enum EitherWriter<'a, CURSOR, N> {
     /// Write to static file
     StaticFile(StaticFileProviderRWRefMut<'a, N>),
     /// Write to `RocksDB`
-    RocksDB(RocksDBWriter),
+    #[cfg(feature = "rocksdb")]
+    RocksDB(RocksDBProvider),
 }
 
 impl<'a> EitherWriter<'a, (), ()> {
@@ -124,37 +115,39 @@ impl<'a> EitherWriter<'a, (), ()> {
         }
     }
 
-    /// Creates a new [`EitherWriter`] for transaction hash numbers based on storage settings.
-    #[cfg(all(unix, feature = "rocksdb"))]
-    pub fn new_transaction_hash_numbers<P>(
-        provider: &'a P,
-    ) -> ProviderResult<EitherWriterTy<'a, P, tables::TransactionHashNumbers>>
+    /// Creates a new [`EitherWriter`] for storages history based on storage settings.
+    #[cfg(feature = "rocksdb")]
+    pub fn new_storages_history<P>(
+        provider: &P,
+        rocksdb: RocksDBProvider,
+    ) -> ProviderResult<EitherWriterTy<'a, P, tables::StoragesHistory>>
     where
-        P: DBProvider + NodePrimitivesProvider + StorageSettingsCache + RocksDBProviderFactory,
+        P: DBProvider + NodePrimitivesProvider + StorageSettingsCache,
         P::Tx: DbTxMut,
     {
-        if provider.cached_storage_settings().transaction_hash_numbers_in_rocksdb {
-            Ok(EitherWriter::RocksDB(provider.rocksdb_provider()))
+        if provider.cached_storage_settings().storages_history_in_rocksdb {
+            Ok(EitherWriter::RocksDB(rocksdb))
         } else {
-            Ok(EitherWriter::Database(
-                provider.tx_ref().cursor_write::<tables::TransactionHashNumbers>()?,
-            ))
+            Ok(EitherWriter::Database(provider.tx_ref().cursor_write::<tables::StoragesHistory>()?))
         }
     }
 
-    /// Creates a new [`EitherWriter`] for storages history based on storage settings.
-    #[cfg(all(unix, feature = "rocksdb"))]
-    pub fn new_storages_history<P>(
-        provider: &'a P,
-    ) -> ProviderResult<EitherWriterTy<'a, P, tables::StoragesHistory>>
+    /// Creates a new [`EitherWriter`] for transaction hash numbers based on storage settings.
+    #[cfg(feature = "rocksdb")]
+    pub fn new_transaction_hash_numbers<P>(
+        provider: &P,
+        rocksdb: RocksDBProvider,
+    ) -> ProviderResult<EitherWriterTy<'a, P, tables::TransactionHashNumbers>>
     where
-        P: DBProvider + NodePrimitivesProvider + StorageSettingsCache + RocksDBProviderFactory,
+        P: DBProvider + NodePrimitivesProvider + StorageSettingsCache,
         P::Tx: DbTxMut,
     {
-        if provider.cached_storage_settings().storages_history_in_rocksdb {
-            Ok(EitherWriter::RocksDB(provider.rocksdb_provider()))
+        if provider.cached_storage_settings().transaction_hash_numbers_in_rocksdb {
+            Ok(EitherWriter::RocksDB(rocksdb))
         } else {
-            Ok(EitherWriter::Database(provider.tx_ref().cursor_write::<tables::StoragesHistory>()?))
+            Ok(EitherWriter::Database(
+                provider.tx_ref().cursor_write::<tables::TransactionHashNumbers>()?,
+            ))
         }
     }
 }
@@ -167,6 +160,7 @@ impl<'a, CURSOR, N: NodePrimitives> EitherWriter<'a, CURSOR, N> {
         match self {
             Self::Database(_) => Ok(()),
             Self::StaticFile(writer) => writer.increment_block(expected_block_number),
+            #[cfg(feature = "rocksdb")]
             Self::RocksDB(_) => Err(ProviderError::UnsupportedProvider),
         }
     }
@@ -181,6 +175,7 @@ impl<'a, CURSOR, N: NodePrimitives> EitherWriter<'a, CURSOR, N> {
         match self {
             Self::Database(_) => Ok(()),
             Self::StaticFile(writer) => writer.ensure_at_block(block_number),
+            #[cfg(feature = "rocksdb")]
             Self::RocksDB(_) => Err(ProviderError::UnsupportedProvider),
         }
     }
@@ -196,6 +191,7 @@ where
         match self {
             Self::Database(cursor) => Ok(cursor.append(tx_num, receipt)?),
             Self::StaticFile(writer) => writer.append_receipt(tx_num, receipt),
+            #[cfg(feature = "rocksdb")]
             Self::RocksDB(_) => Err(ProviderError::UnsupportedProvider),
         }
     }
@@ -210,6 +206,7 @@ where
         match self {
             Self::Database(cursor) => Ok(cursor.append(tx_num, sender)?),
             Self::StaticFile(writer) => writer.append_transaction_sender(tx_num, sender),
+            #[cfg(feature = "rocksdb")]
             Self::RocksDB(_) => Err(ProviderError::UnsupportedProvider),
         }
     }
@@ -227,6 +224,7 @@ where
                 Ok(())
             }
             Self::StaticFile(writer) => writer.append_transaction_senders(senders),
+            #[cfg(feature = "rocksdb")]
             Self::RocksDB(_) => Err(ProviderError::UnsupportedProvider),
         }
     }
@@ -259,6 +257,7 @@ where
 
                 writer.prune_transaction_senders(to_delete, block)?;
             }
+            #[cfg(feature = "rocksdb")]
             Self::RocksDB(_) => return Err(ProviderError::UnsupportedProvider),
         }
 
@@ -274,7 +273,8 @@ pub enum EitherReader<CURSOR, N> {
     /// Read from static file
     StaticFile(StaticFileProvider<N>),
     /// Read from `RocksDB`
-    RocksDB(RocksDBReader),
+    #[cfg(feature = "rocksdb")]
+    RocksDB(RocksDBProvider),
 }
 
 impl EitherReader<(), ()> {
@@ -295,37 +295,39 @@ impl EitherReader<(), ()> {
         }
     }
 
-    /// Creates a new [`EitherReader`] for transaction hash numbers based on storage settings.
-    #[cfg(all(unix, feature = "rocksdb"))]
-    pub fn new_transaction_hash_numbers<P>(
+    /// Creates a new [`EitherReader`] for storages history based on storage settings.
+    #[cfg(feature = "rocksdb")]
+    pub fn new_storages_history<P>(
         provider: &P,
-    ) -> ProviderResult<EitherReaderTy<P, tables::TransactionHashNumbers>>
+        rocksdb: RocksDBProvider,
+    ) -> ProviderResult<EitherReaderTy<P, tables::StoragesHistory>>
     where
-        P: DBProvider + NodePrimitivesProvider + StorageSettingsCache + RocksDBProviderFactory,
+        P: DBProvider + NodePrimitivesProvider + StorageSettingsCache,
         P::Tx: DbTx,
     {
-        if provider.cached_storage_settings().transaction_hash_numbers_in_rocksdb {
-            Ok(EitherReader::RocksDB(provider.rocksdb_provider()))
+        if provider.cached_storage_settings().storages_history_in_rocksdb {
+            Ok(EitherReader::RocksDB(rocksdb))
         } else {
-            Ok(EitherReader::Database(
-                provider.tx_ref().cursor_read::<tables::TransactionHashNumbers>()?,
-            ))
+            Ok(EitherReader::Database(provider.tx_ref().cursor_read::<tables::StoragesHistory>()?))
         }
     }
 
-    /// Creates a new [`EitherReader`] for storages history based on storage settings.
-    #[cfg(all(unix, feature = "rocksdb"))]
-    pub fn new_storages_history<P>(
+    /// Creates a new [`EitherReader`] for transaction hash numbers based on storage settings.
+    #[cfg(feature = "rocksdb")]
+    pub fn new_transaction_hash_numbers<P>(
         provider: &P,
-    ) -> ProviderResult<EitherReaderTy<P, tables::StoragesHistory>>
+        rocksdb: RocksDBProvider,
+    ) -> ProviderResult<EitherReaderTy<P, tables::TransactionHashNumbers>>
     where
-        P: DBProvider + NodePrimitivesProvider + StorageSettingsCache + RocksDBProviderFactory,
+        P: DBProvider + NodePrimitivesProvider + StorageSettingsCache,
         P::Tx: DbTx,
     {
-        if provider.cached_storage_settings().storages_history_in_rocksdb {
-            Ok(EitherReader::RocksDB(provider.rocksdb_provider()))
+        if provider.cached_storage_settings().transaction_hash_numbers_in_rocksdb {
+            Ok(EitherReader::RocksDB(rocksdb))
         } else {
-            Ok(EitherReader::Database(provider.tx_ref().cursor_read::<tables::StoragesHistory>()?))
+            Ok(EitherReader::Database(
+                provider.tx_ref().cursor_read::<tables::TransactionHashNumbers>()?,
+            ))
         }
     }
 }
@@ -356,6 +358,7 @@ where
                     Some(result.map(|sender| (tx_num, sender)))
                 })
                 .collect::<ProviderResult<HashMap<_, _>>>(),
+            #[cfg(feature = "rocksdb")]
             Self::RocksDB(_) => Err(ProviderError::UnsupportedProvider),
         }
     }

crates/storage/provider/src/traits/mod.rs

@@ -8,9 +8,5 @@ pub use reth_chainspec::ChainSpecProvider;
 mod static_file_provider;
 pub use static_file_provider::StaticFileProviderFactory;
 
-mod rocksdb_provider;
-#[cfg(all(unix, feature = "rocksdb"))]
-pub use rocksdb_provider::RocksDBProviderFactory;
-
 mod full;
 pub use full::FullProvider;