Change: external_request() replace the 1st arg ServerState with RaftState

This change let user do more things with a external fn request.

Author: drmingdrmer

openraft/src/core/raft_core.rs

@@ -858,7 +858,7 @@ impl<C: RaftTypeConfig, N: RaftNetworkFactory<C>, S: RaftStorage<C>> RaftCore<C,
                 }
             }
             RaftMsg::ExternalRequest { req } => {
-                req(self.engine.state.server_state, &mut self.storage, &mut self.network);
+                req(&self.engine.state, &mut self.storage, &mut self.network);
             }
             RaftMsg::Elect { server_state_count } => {
                 if server_state_count != Some(self.server_state_count) {

openraft/src/raft.rs

@@ -16,7 +16,6 @@ use tracing::Span;
 
 use crate::config::Config;
 use crate::core::RaftCore;
-use crate::core::ServerState;
 use crate::error::AddLearnerError;
 use crate::error::AppendEntriesError;
 use crate::error::CheckIsLeaderError;
@@ -38,6 +37,7 @@ use crate::MessageSummary;
 use crate::Node;
 use crate::NodeId;
 use crate::RaftNetworkFactory;
+use crate::RaftState;
 use crate::RaftStorage;
 use crate::SnapshotMeta;
 use crate::Vote;
@@ -524,7 +524,7 @@ impl<C: RaftTypeConfig, N: RaftNetworkFactory<C>, S: RaftStorage<C>> Raft<C, N,
     ///
     /// If the API channel is already closed (Raft is in shutdown), then the request functor is
     /// destroyed right away and not called at all.
-    pub fn external_request<F: FnOnce(ServerState, &mut S, &mut N) + Send + 'static>(&self, req: F) {
+    pub fn external_request<F: FnOnce(&RaftState<C::NodeId>, &mut S, &mut N) + Send + 'static>(&self, req: F) {
         let _ignore_error = self.inner.tx_api.send((
             RaftMsg::ExternalRequest { req: Box::new(req) },
             tracing::span::Span::none(), // fire-and-forget, so no span
@@ -667,7 +667,8 @@ pub(crate) enum RaftMsg<C: RaftTypeConfig, N: RaftNetworkFactory<C>, S: RaftStor
     },
 
     ExternalRequest {
-        req: Box<dyn FnOnce(ServerState, &mut S, &mut N) + Send + 'static>,
+        #[allow(clippy::type_complexity)]
+        req: Box<dyn FnOnce(&RaftState<C::NodeId>, &mut S, &mut N) + Send + 'static>,
     },
 
     /// Trigger an election
@@ -930,6 +931,7 @@ impl<C: RaftTypeConfig> ClientWriteRequest<C> {
     serde(bound = "C::R: AppDataResponse")
 )]
 pub struct ClientWriteResponse<C: RaftTypeConfig> {
+    /// The id of the log that is applied.
     pub log_id: LogId<C::NodeId>,
 
     /// Application specific response data.

openraft/tests/fixtures/mod.rs

@@ -57,6 +57,7 @@ use openraft::Raft;
 use openraft::RaftMetrics;
 use openraft::RaftNetwork;
 use openraft::RaftNetworkFactory;
+use openraft::RaftState;
 use openraft::RaftTypeConfig;
 use openraft::ServerState;
 use openraft::StoreExt;
@@ -568,7 +569,7 @@ where
 
     /// Send external request to the particular node.
     pub fn external_request<
-        F: FnOnce(ServerState, &mut StoreExt<C, S>, &mut TypedRaftRouter<C, S>) + Send + 'static,
+        F: FnOnce(&RaftState<C::NodeId>, &mut StoreExt<C, S>, &mut TypedRaftRouter<C, S>) + Send + 'static,
     >(
         &self,
         target: C::NodeId,

openraft/tests/initialize/t20_initialization.rs

@@ -61,7 +61,7 @@ async fn initialization() -> anyhow::Result<()> {
     // (since they are awaited).
     for node in [0, 1, 2] {
         router.external_request(node, |s, _sto, _net| {
-            assert_eq!(s, ServerState::Learner);
+            assert_eq!(s.server_state, ServerState::Learner);
         });
     }
 
@@ -110,7 +110,7 @@ async fn initialization() -> anyhow::Result<()> {
     let mut follower_count = 0;
     for node in [0, 1, 2] {
         let (tx, rx) = oneshot::channel();
-        router.external_request(node, |s, _sm, _net| tx.send(s).unwrap());
+        router.external_request(node, |s, _sm, _net| tx.send(s.server_state).unwrap());
         match rx.await.unwrap() {
             ServerState::Leader => {
                 assert!(!found_leader);
@@ -140,7 +140,7 @@ async fn initialize_err_target_not_include_target() -> anyhow::Result<()> {
 
     for node in [0, 1] {
         router.external_request(node, |s, _sto, _net| {
-            assert_eq!(s, ServerState::Learner);
+            assert_eq!(s.server_state, ServerState::Learner);
         });
     }
 
@@ -174,7 +174,7 @@ async fn initialize_err_not_allowed() -> anyhow::Result<()> {
 
     for node in [0] {
         router.external_request(node, |s, _sto, _net| {
-            assert_eq!(s, ServerState::Learner);
+            assert_eq!(s.server_state, ServerState::Learner);
         });
     }