routing_logic removal from ParseMiningMessagesFromDownstream and adaptation on roles

Author: GitGab19

protocols/v2/roles-logic-sv2/src/handlers/mining.rs

@@ -73,15 +73,13 @@ pub trait ParseMiningMessagesFromDownstream<
         self_mutex: Arc<Mutex<Self>>,
         message_type: u8,
         payload: &mut [u8],
-        routing_logic: MiningRoutingLogic<Self, Up, Selector, Router>,
     ) -> Result<SendTo<Up>, Error>
     where
         Self: IsMiningDownstream + Sized,
     {
         match Self::handle_message_mining_deserialized(
             self_mutex,
             (message_type, payload).try_into(),
-            routing_logic,
         ) {
             Err(Error::UnexpectedMessage(0)) => Err(Error::UnexpectedMessage(message_type)),
             result => result,
@@ -92,22 +90,15 @@ pub trait ParseMiningMessagesFromDownstream<
     fn handle_message_mining_deserialized(
         self_mutex: Arc<Mutex<Self>>,
         message: Result<Mining<'_>, Error>,
-        routing_logic: MiningRoutingLogic<Self, Up, Selector, Router>,
     ) -> Result<SendTo<Up>, Error>
     where
         Self: IsMiningDownstream + Sized,
     {
-        let (channel_type, is_work_selection_enabled, downstream_mining_data) = self_mutex
-            .safe_lock(|self_| {
-                (
-                    self_.get_channel_type(),
-                    self_.is_work_selection_enabled(),
-                    self_.get_downstream_mining_data(),
-                )
-            })
+        let (channel_type, is_work_selection_enabled) = self_mutex
+            .safe_lock(|self_| (self_.get_channel_type(), self_.is_work_selection_enabled()))
             .map_err(|e| crate::Error::PoisonLock(e.to_string()))?;
         match message {
-            Ok(Mining::OpenStandardMiningChannel(mut m)) => {
+            Ok(Mining::OpenStandardMiningChannel(m)) => {
                 info!(
                     "Received OpenStandardMiningChannel from: {} with id: {}",
                     std::str::from_utf8(m.user_identity.as_ref()).unwrap_or("Unknown identity"),
@@ -124,41 +115,22 @@ pub trait ParseMiningMessagesFromDownstream<
                         OpenMiningChannelError::new_unknown_user(m.get_request_id_as_u32()),
                     )));
                 }
-                let upstream = match routing_logic {
-                    MiningRoutingLogic::None => None,
-                    MiningRoutingLogic::Proxy(r_logic) => {
-                        trace!("On OpenStandardMiningChannel r_logic is: {:?}", r_logic);
-                        let up = r_logic
-                            .safe_lock(|r_logic| {
-                                r_logic.on_open_standard_channel(
-                                    self_mutex.clone(),
-                                    &mut m,
-                                    &downstream_mining_data,
-                                )
-                            })
-                            .map_err(|e| crate::Error::PoisonLock(e.to_string()))?;
-                        trace!("On OpenStandardMiningChannel best candidate is: {:?}", up);
-                        Some(up?)
-                    }
-                    // Variant just used for phantom data is ok to panic
-                    MiningRoutingLogic::_P(_) => panic!("Must use either MiningRoutingLogic::None or MiningRoutingLogic::Proxy for `routing_logic` param"),
-                };
                 trace!(
                     "On OpenStandardMiningChannel channel type is: {:?}",
                     channel_type
                 );
                 match channel_type {
                     SupportedChannelTypes::Standard => self_mutex
-                        .safe_lock(|self_| self_.handle_open_standard_mining_channel(m, upstream))
+                        .safe_lock(|self_| self_.handle_open_standard_mining_channel(m))
                         .map_err(|e| crate::Error::PoisonLock(e.to_string()))?,
                     SupportedChannelTypes::Extended => Err(Error::UnexpectedMessage(
                         MESSAGE_TYPE_OPEN_STANDARD_MINING_CHANNEL,
                     )),
                     SupportedChannelTypes::Group => self_mutex
-                        .safe_lock(|self_| self_.handle_open_standard_mining_channel(m, upstream))
+                        .safe_lock(|self_| self_.handle_open_standard_mining_channel(m))
                         .map_err(|e| crate::Error::PoisonLock(e.to_string()))?,
                     SupportedChannelTypes::GroupAndExtended => self_mutex
-                        .safe_lock(|self_| self_.handle_open_standard_mining_channel(m, upstream))
+                        .safe_lock(|self_| self_.handle_open_standard_mining_channel(m))
                         .map_err(|e| crate::Error::PoisonLock(e.to_string()))?,
                 }
             }
@@ -302,7 +274,6 @@ pub trait ParseMiningMessagesFromDownstream<
     fn handle_open_standard_mining_channel(
         &mut self,
         m: OpenStandardMiningChannel,
-        up: Option<Arc<Mutex<Up>>>,
     ) -> Result<SendTo<Up>, Error>;
 
     /// Handles an `OpenExtendedMiningChannel` message.

roles/jd-client/src/lib/downstream.rs

@@ -260,13 +260,10 @@ impl DownstreamMiningNode {
         let message_type = incoming.get_header().unwrap().msg_type();
         let payload = incoming.payload();
 
-        let routing_logic = roles_logic_sv2::routing_logic::MiningRoutingLogic::None;
-
         let next_message_to_send = ParseMiningMessagesFromDownstream::handle_message_mining(
             self_mutex.clone(),
             message_type,
             payload,
-            routing_logic,
         );
         Self::match_send_to(self_mutex.clone(), next_message_to_send, Some(incoming)).await;
     }
@@ -464,7 +461,6 @@ impl
     fn handle_open_standard_mining_channel(
         &mut self,
         _: OpenStandardMiningChannel,
-        _: Option<Arc<Mutex<UpstreamMiningNode>>>,
     ) -> Result<SendTo<UpstreamMiningNode>, Error> {
         warn!("Ignoring OpenStandardMiningChannel");
         Ok(SendTo::None(None))

roles/mining-proxy/src/lib/downstream_mining.rs

@@ -18,7 +18,9 @@ use roles_logic_sv2::{
     },
     mining_sv2::*,
     parsers::{AnyMessage, Mining, MiningDeviceMessages},
-    routing_logic::{CommonRouter, CommonRoutingLogic, MiningProxyRoutingLogic},
+    routing_logic::{
+        CommonRouter, CommonRoutingLogic, MiningProxyRoutingLogic, MiningRouter, MiningRoutingLogic,
+    },
     utils::Mutex,
 };
 
@@ -30,7 +32,7 @@ pub type EitherFrame = StandardEitherFrame<Message>;
 /// a mining device or a downstream proxy.
 /// A downstream can only be linked with an upstream at a time. Support multi upstreams for
 /// downstream do not make much sense.
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct DownstreamMiningNode {
     id: u32,
     receiver: Receiver<EitherFrame>,
@@ -39,7 +41,7 @@ pub struct DownstreamMiningNode {
     upstream: Option<Arc<Mutex<UpstreamMiningNode>>>,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub enum DownstreamMiningNodeStatus {
     Initializing,
     Paired(CommonDownstreamData),
@@ -193,13 +195,10 @@ impl DownstreamMiningNode {
         let message_type = incoming.get_header().unwrap().msg_type();
         let payload = incoming.payload();
 
-        let routing_logic = super::get_routing_logic();
-
         let next_message_to_send = ParseMiningMessagesFromDownstream::handle_message_mining(
             self_mutex.clone(),
             message_type,
             payload,
-            routing_logic,
         );
 
         match next_message_to_send {
@@ -314,16 +313,40 @@ impl
     fn handle_open_standard_mining_channel(
         &mut self,
         req: OpenStandardMiningChannel,
-        up: Option<Arc<Mutex<UpstreamMiningNode>>>,
     ) -> Result<SendTo<UpstreamMiningNode>, Error> {
-        let channel_id = up
+        let downstream_mining_data = self.get_downstream_mining_data();
+        let routing_logic = super::get_routing_logic();
+
+        let upstream = match routing_logic {
+            MiningRoutingLogic::Proxy(r_logic) => {
+                trace!("On OpenStandardMiningChannel r_logic is: {:?}", r_logic);
+                let up = r_logic
+                    .safe_lock(|r_logic| {
+                        r_logic.on_open_standard_channel(
+                            Arc::new(Mutex::new(self.clone())),
+                            &mut req.clone(),
+                            &downstream_mining_data,
+                        )
+                    })
+                    .map_err(|e| Error::PoisonLock(e.to_string()))?;
+                trace!("On OpenStandardMiningChannel best candidate is: {:?}", up);
+                Some(up?)
+            }
+            // Variant just used for phantom data is ok to panic
+            MiningRoutingLogic::_P(_) => panic!("Must use either MiningRoutingLogic::None or MiningRoutingLogic::Proxy for `routing_logic` param"),
+            _ => unreachable!()
+        };
+
+        let channel_id = upstream
             .as_ref()
             .expect("No upstream initialized")
             .safe_lock(|s| s.channel_ids.safe_lock(|r| r.next()).unwrap())
             .unwrap();
         info!(channel_id);
-        let cloned = up.as_ref().expect("No upstream initialized").clone();
-        up.as_ref()
+        let cloned = upstream.as_ref().expect("No upstream initialized").clone();
+
+        upstream
+            .as_ref()
             .expect("No upstream initialized")
             .safe_lock(|up| {
                 if up.channel_kind.is_extended() {

roles/pool/src/lib/mining_pool/message_handler.rs

@@ -35,7 +35,6 @@ impl ParseMiningMessagesFromDownstream<(), NullDownstreamMiningSelector, NoRouti
     fn handle_open_standard_mining_channel(
         &mut self,
         incoming: OpenStandardMiningChannel,
-        _m: Option<Arc<Mutex<()>>>,
     ) -> Result<SendTo<()>, Error> {
         let header_only = self.downstream_data.header_only;
         let reposnses = self

roles/pool/src/lib/mining_pool/mod.rs

@@ -19,7 +19,6 @@ use roles_logic_sv2::{
     job_creator::JobsCreators,
     mining_sv2::{ExtendedExtranonce, SetNewPrevHash as SetNPH},
     parsers::{AnyMessage, Mining},
-    routing_logic::MiningRoutingLogic,
     template_distribution_sv2::{NewTemplate, SetNewPrevHash, SubmitSolution},
     utils::{CoinbaseOutput as CoinbaseOutput_, Mutex},
 };
@@ -173,7 +172,6 @@ impl Downstream {
             self_mutex.clone(),
             message_type,
             payload,
-            MiningRoutingLogic::None,
         );
         Self::match_send_to(self_mutex, next_message_to_send).await
     }