Refactor: Remove RaftLogReader trait dependency from RaftLogStorage

openraft/src/core/raft_core.rs

@@ -717,7 +717,7 @@ where
             return Ok(());
         }
 
-        let entries = self.log_store.get_log_entries(since..end).await?;
+        let entries = self.log_store.get_log_reader().await.get_log_entries(since..end).await?;
         tracing::debug!(
             entries = display(DisplaySlice::<_>(entries.as_slice())),
             "about to apply"

openraft/src/storage/helper.rs

@@ -15,6 +15,7 @@ use crate::utime::UTime;
 use crate::EffectiveMembership;
 use crate::LogIdOptionExt;
 use crate::MembershipState;
+use crate::RaftLogReader;
 use crate::RaftSnapshotBuilder;
 use crate::RaftState;
 use crate::RaftTypeConfig;
@@ -59,7 +60,8 @@ where
     /// When the Raft node is first started, it will call this interface to fetch the last known
     /// state from stable storage.
     pub async fn get_initial_state(&mut self) -> Result<RaftState<C>, StorageError<C>> {
-        let vote = self.log_store.read_vote().await?;
+        let mut log_reader = self.log_store.get_log_reader().await;
+        let vote = log_reader.read_vote().await?;
         let vote = vote.unwrap_or_default();
 
         let mut committed = self.log_store.read_committed().await?;
@@ -92,7 +94,7 @@ where
 
             tracing::info!("re-apply log {}..{} to state machine", start, end);
 
-            let entries = self.log_store.get_log_entries(start..end).await?;
+            let entries = log_reader.get_log_entries(start..end).await?;
             self.state_machine.apply(entries).await?;
 
             last_applied = committed;
@@ -119,7 +121,7 @@ where
             last_purged_log_id.display(),
             last_log_id.display()
         );
-        let log_ids = LogIdList::load_log_ids(last_purged_log_id, last_log_id, self.log_store).await?;
+        let log_ids = LogIdList::load_log_ids(last_purged_log_id, last_log_id, &mut log_reader).await?;
 
         let snapshot = self.state_machine.get_current_snapshot().await?;
 
@@ -234,10 +236,11 @@ where
         let step = 64;
 
         let mut res = vec![];
+        let mut log_reader = self.log_store.get_log_reader().await;
 
         while start < end {
             let step_start = std::cmp::max(start, end.saturating_sub(step));
-            let entries = self.log_store.try_get_log_entries(step_start..end).await?;
+            let entries = log_reader.try_get_log_entries(step_start..end).await?;
 
             for ent in entries.iter().rev() {
                 if let Some(mem) = ent.get_membership() {

openraft/src/storage/mod.rs

@@ -2,7 +2,7 @@
 
 mod callback;
 mod helper;
-mod log_store_ext;
+mod log_reader_ext;
 mod snapshot_signature;
 mod v2;
 
@@ -11,7 +11,7 @@ use std::fmt::Debug;
 use std::ops::RangeBounds;
 
 pub use helper::StorageHelper;
-pub use log_store_ext::RaftLogReaderExt;
+pub use log_reader_ext::RaftLogReaderExt;
 use openraft_macros::add_async_trait;
 use openraft_macros::since;
 pub use snapshot_signature::SnapshotSignature;

openraft/src/storage/v2.rs

@@ -35,7 +35,7 @@ use crate::Vote;
 ///   write request before a former write request is completed. This rule applies to both `vote` and
 ///   `log` IO. E.g., Saving a vote and appending a log entry must be serialized too.
 #[add_async_trait]
-pub trait RaftLogStorage<C>: RaftLogReader<C> + OptionalSend + OptionalSync + 'static
+pub trait RaftLogStorage<C>: OptionalSend + OptionalSync + 'static
 where C: RaftTypeConfig
 {
     /// Log reader type.

openraft/src/testing/suite.rs

@@ -2,6 +2,7 @@ use std::collections::BTreeSet;
 use std::fmt::Debug;
 use std::future::Future;
 use std::marker::PhantomData;
+use std::ops::RangeBounds;
 use std::time::Duration;
 
 use anyerror::AnyError;
@@ -26,6 +27,8 @@ use crate::LogId;
 use crate::Membership;
 use crate::NodeId;
 use crate::OptionalSend;
+use crate::OptionalSync;
+use crate::RaftLogReader;
 use crate::RaftSnapshotBuilder;
 use crate::RaftTypeConfig;
 use crate::StorageError;
@@ -45,6 +48,54 @@ macro_rules! btreeset {
     }};
 }
 
+/// Allows [`RaftLogStorage`] to access methods provided by [`RaftLogReader`] in ths test.
+trait ReaderExt<C>: RaftLogStorage<C>
+where C: RaftTypeConfig
+{
+    /// Proxy method to invoke [`RaftLogReaderExt::get_log_id`].
+    async fn get_log_id(&mut self, log_index: u64) -> Result<LogId<C::NodeId>, StorageError<C>> {
+        self.get_log_reader().await.get_log_id(log_index).await
+    }
+
+    /// Proxy method to invoke [`RaftLogReaderExt::try_get_log_entry`].
+    async fn try_get_log_entry(&mut self, log_index: u64) -> Result<Option<C::Entry>, StorageError<C>> {
+        self.get_log_reader().await.try_get_log_entry(log_index).await
+    }
+
+    /// Proxy method to invoke [`RaftLogReaderExt::get_log_entries`].
+    async fn get_log_entries<RB: RangeBounds<u64> + Clone + Debug + OptionalSend + OptionalSync>(
+        &mut self,
+        range: RB,
+    ) -> Result<Vec<C::Entry>, StorageError<C>> {
+        self.get_log_reader().await.get_log_entries(range).await
+    }
+
+    /// Proxy method to invoke [`RaftLogReader::try_get_log_entries`].
+    async fn try_get_log_entries<RB: RangeBounds<u64> + Clone + Debug + OptionalSend>(
+        &mut self,
+        range: RB,
+    ) -> Result<Vec<C::Entry>, StorageError<C>> {
+        self.get_log_reader().await.try_get_log_entries(range).await
+    }
+
+    /// Proxy method to invoke [`RaftLogReader::read_vote`].
+    async fn read_vote(&mut self) -> Result<Option<Vote<C::NodeId>>, StorageError<C>> {
+        self.get_log_reader().await.read_vote().await
+    }
+
+    /// Proxy method to invoke [`RaftLogReader::limited_get_log_entries`].
+    async fn limited_get_log_entries(&mut self, start: u64, end: u64) -> Result<Vec<C::Entry>, StorageError<C>> {
+        self.get_log_reader().await.limited_get_log_entries(start, end).await
+    }
+}
+
+impl<C, S> ReaderExt<C> for S
+where
+    C: RaftTypeConfig,
+    S: RaftLogStorage<C>,
+{
+}
+
 /// Test suite to ensure a `RaftStore` impl works as expected.
 ///
 /// Additional traits are required to be implemented by the store builder for testing:

tests/tests/append_entries/t11_append_conflicts.rs

@@ -227,7 +227,7 @@ where
     C: RaftTypeConfig,
     LS: RaftLogStorage<C>,
 {
-    let logs = log_store.get_log_entries(..).await?;
+    let logs = log_store.get_log_reader().await.get_log_entries(..).await?;
     let skip = 0;
     let want: Vec<Entry<openraft_memstore::TypeConfig>> = terms
         .iter()