refactor(p2p_channels_rpc): Combine all action types of the p2p_channels_rpc module into the parent action type

Author: tizoc

node/src/effects.rs

@@ -6,9 +6,7 @@ use crate::consensus::consensus_effects;
 use crate::event_source::event_source_effects;
 use crate::external_snark_worker::external_snark_worker_effects;
 use crate::logger::logger_effects;
-use crate::p2p::channels::rpc::{
-    P2pChannelsRpcRequestSendAction, P2pChannelsRpcTimeoutAction, P2pRpcKind, P2pRpcRequest,
-};
+use crate::p2p::channels::rpc::{P2pChannelsRpcAction, P2pRpcKind, P2pRpcRequest};
 use crate::p2p::connection::incoming::P2pConnectionIncomingTimeoutAction;
 use crate::p2p::connection::outgoing::{
     P2pConnectionOutgoingRandomInitAction, P2pConnectionOutgoingReconnectAction,
@@ -69,7 +67,7 @@ pub fn effects<S: Service>(store: &mut Store<S>, action: ActionWithMeta) {
 
             let state = store.state();
             for (peer_id, id) in state.p2p.peer_rpc_timeouts(state.time()) {
-                store.dispatch(P2pChannelsRpcTimeoutAction { peer_id, id });
+                store.dispatch(P2pChannelsRpcAction::Timeout { peer_id, id });
             }
 
             // TODO(binier): remove once ledger communication is async.
@@ -182,7 +180,7 @@ fn p2p_request_best_tip_if_needed<S: Service>(store: &mut Store<S>) {
                 .map(|(peer_id, p)| (*peer_id, p.channels.rpc.next_local_rpc_id()))
                 .last()
             {
-                store.dispatch(P2pChannelsRpcRequestSendAction {
+                store.dispatch(P2pChannelsRpcAction::RequestSend {
                     peer_id,
                     id,
                     request: P2pRpcRequest::BestTipWithProof,

node/src/event_source/event_source_effects.rs

@@ -8,7 +8,7 @@ use crate::action::CheckTimeoutsAction;
 use crate::block_producer::vrf_evaluator::BlockProducerVrfEvaluatorEvaluationSuccessAction;
 use crate::external_snark_worker::ExternalSnarkWorkerEvent;
 use crate::p2p::channels::best_tip::P2pChannelsBestTipAction;
-use crate::p2p::channels::rpc::P2pChannelsRpcReadyAction;
+use crate::p2p::channels::rpc::P2pChannelsRpcAction;
 use crate::p2p::channels::snark_job_commitment::P2pChannelsSnarkJobCommitmentAction;
 use crate::p2p::channels::{ChannelId, P2pChannelsMessageReceivedAction};
 use crate::p2p::connection::incoming::{
@@ -185,7 +185,7 @@ pub fn event_source_effects<S: Service>(store: &mut Store<S>, action: EventSourc
                             }
                             ChannelId::Rpc => {
                                 // TODO(binier): maybe dispatch success and then ready.
-                                store.dispatch(P2pChannelsRpcReadyAction { peer_id });
+                                store.dispatch(P2pChannelsRpcAction::Ready { peer_id });
                             }
                         },
                     },

node/src/logger/logger_effects.rs

@@ -420,40 +420,48 @@ pub fn logger_effects<S: Service>(store: &Store<S>, action: ActionWithMetaRef<'_
                     _ => {}
                 },
                 P2pChannelsAction::Rpc(action) => match action {
-                    P2pChannelsRpcAction::Init(action) => {
+                    P2pChannelsRpcAction::Init { peer_id } => {
                         openmina_core::log::debug!(
                             meta.time();
                             kind = kind.to_string(),
-                            summary = format!("peer_id: {}", action.peer_id),
-                            peer_id = action.peer_id.to_string()
+                            summary = format!("peer_id: {peer_id}", ),
+                            peer_id = peer_id.to_string()
                         );
                     }
-                    P2pChannelsRpcAction::Ready(action) => {
+                    P2pChannelsRpcAction::Ready { peer_id } => {
                         openmina_core::log::debug!(
                             meta.time();
                             kind = kind.to_string(),
-                            summary = format!("peer_id: {}", action.peer_id),
-                            peer_id = action.peer_id.to_string()
+                            summary = format!("peer_id: {peer_id}", ),
+                            peer_id = peer_id.to_string()
                         );
                     }
-                    P2pChannelsRpcAction::RequestSend(action) => {
+                    P2pChannelsRpcAction::RequestSend {
+                        peer_id,
+                        id,
+                        request,
+                    } => {
                         openmina_core::log::debug!(
                             meta.time();
                             kind = kind.to_string(),
-                            summary = format!("peer_id: {}, rpc_id: {}, kind: {:?}", action.peer_id, action.id, action.request.kind()),
-                            peer_id = action.peer_id.to_string(),
-                            rpc_id = action.id.to_string(),
-                            trace_request = serde_json::to_string(&action.request).ok()
+                            summary = format!("peer_id: {peer_id}, rpc_id: {id}, kind: {:?}", request.kind()),
+                            peer_id = peer_id.to_string(),
+                            rpc_id = id.to_string(),
+                            trace_request = serde_json::to_string(request).ok()
                         );
                     }
-                    P2pChannelsRpcAction::ResponseReceived(action) => {
+                    P2pChannelsRpcAction::ResponseReceived {
+                        peer_id,
+                        id,
+                        response,
+                    } => {
                         openmina_core::log::debug!(
                             meta.time();
                             kind = kind.to_string(),
-                            summary = format!("peer_id: {}, rpc_id: {}", action.peer_id, action.id),
-                            peer_id = action.peer_id.to_string(),
-                            rpc_id = action.id.to_string(),
-                            trace_response = serde_json::to_string(&action.response).ok()
+                            summary = format!("peer_id: {peer_id}, rpc_id: {id}"),
+                            peer_id = peer_id.to_string(),
+                            rpc_id = id.to_string(),
+                            trace_response = serde_json::to_string(response).ok()
                         );
                     }
                     _ => {}

node/src/p2p/channels/rpc/p2p_channels_rpc_actions.rs

@@ -1,52 +1,13 @@
 use super::*;
 
-impl redux::EnablingCondition<crate::State> for P2pChannelsRpcInitAction {
-    fn is_enabled(&self, state: &crate::State) -> bool {
-        self.is_enabled(&state.p2p)
-    }
-}
-
-impl redux::EnablingCondition<crate::State> for P2pChannelsRpcPendingAction {
-    fn is_enabled(&self, state: &crate::State) -> bool {
-        self.is_enabled(&state.p2p)
-    }
-}
-
-impl redux::EnablingCondition<crate::State> for P2pChannelsRpcReadyAction {
-    fn is_enabled(&self, state: &crate::State) -> bool {
-        self.is_enabled(&state.p2p)
-    }
-}
-
-impl redux::EnablingCondition<crate::State> for P2pChannelsRpcRequestSendAction {
-    fn is_enabled(&self, state: &crate::State) -> bool {
-        self.is_enabled(&state.p2p)
-    }
-}
-
-impl redux::EnablingCondition<crate::State> for P2pChannelsRpcTimeoutAction {
-    fn is_enabled(&self, state: &crate::State) -> bool {
-        self.is_enabled(&state.p2p)
-            && state
-                .p2p
-                .is_peer_rpc_timed_out(&self.peer_id, self.id, state.time())
-    }
-}
-
-impl redux::EnablingCondition<crate::State> for P2pChannelsRpcResponseReceivedAction {
-    fn is_enabled(&self, state: &crate::State) -> bool {
-        self.is_enabled(&state.p2p)
-    }
-}
-
-impl redux::EnablingCondition<crate::State> for P2pChannelsRpcRequestReceivedAction {
-    fn is_enabled(&self, state: &crate::State) -> bool {
-        self.is_enabled(&state.p2p)
-    }
-}
-
-impl redux::EnablingCondition<crate::State> for P2pChannelsRpcResponseSendAction {
-    fn is_enabled(&self, state: &crate::State) -> bool {
-        self.is_enabled(&state.p2p)
+impl redux::EnablingCondition<crate::State> for P2pChannelsRpcAction {
+    fn is_enabled(&self, state: &crate::State) -> bool {
+        match self {
+            Self::Timeout { peer_id, id } => {
+                self.is_enabled(&state.p2p)
+                    && state.p2p.is_peer_rpc_timed_out(peer_id, *id, state.time())
+            }
+            _ => self.is_enabled(&state.p2p),
+        }
     }
 }

node/src/p2p/mod.rs

@@ -103,11 +103,4 @@ impl_into_global_action!(channels::snark::P2pChannelsSnarkAction);
 
 impl_into_global_action!(channels::snark_job_commitment::P2pChannelsSnarkJobCommitmentAction);
 
-impl_into_global_action!(channels::rpc::P2pChannelsRpcInitAction);
-impl_into_global_action!(channels::rpc::P2pChannelsRpcPendingAction);
-impl_into_global_action!(channels::rpc::P2pChannelsRpcReadyAction);
-impl_into_global_action!(channels::rpc::P2pChannelsRpcRequestSendAction);
-impl_into_global_action!(channels::rpc::P2pChannelsRpcTimeoutAction);
-impl_into_global_action!(channels::rpc::P2pChannelsRpcResponseReceivedAction);
-impl_into_global_action!(channels::rpc::P2pChannelsRpcRequestReceivedAction);
-impl_into_global_action!(channels::rpc::P2pChannelsRpcResponseSendAction);
+impl_into_global_action!(channels::rpc::P2pChannelsRpcAction);