Fix resource hogging when waiting for role transition

src/fullnode.rs

@@ -23,10 +23,10 @@ use solana_sdk::timing::{duration_as_ms, timestamp};
 use std::net::UdpSocket;
 use std::net::{IpAddr, Ipv4Addr, SocketAddr};
 use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
-use std::sync::mpsc::{channel, Receiver, Sender, SyncSender};
+use std::sync::mpsc::{channel, Receiver, RecvTimeoutError, Sender, SyncSender};
 use std::sync::{Arc, RwLock};
 use std::thread::{spawn, Result};
-use std::time::Instant;
+use std::time::{Duration, Instant};
 
 pub type TvuRotationSender = Sender<TvuReturnType>;
 pub type TvuRotationReceiver = Receiver<TvuReturnType>;
@@ -399,28 +399,34 @@ impl Fullnode {
     }
 
     fn handle_role_transition(&mut self) -> Option<(FullnodeReturnType, u64)> {
+        let timeout = Duration::from_secs(1);
         loop {
             if self.exit.load(Ordering::Relaxed) {
                 return None;
             }
-            let should_be_forwarder = self.role_notifiers.1.try_recv();
-            let should_be_leader = self.role_notifiers.0.try_recv();
-            match should_be_leader {
-                Ok(TvuReturnType::LeaderRotation(tick_height, entry_height, last_entry_id)) => {
-                    self.validator_to_leader(tick_height, entry_height, last_entry_id);
-                    return Some((
-                        FullnodeReturnType::ValidatorToLeaderRotation,
-                        tick_height + 1,
-                    ));
-                }
-                _ => match should_be_forwarder {
+
+            if self.node_services.tpu.is_leader() {
+                let should_be_forwarder = self.role_notifiers.1.recv_timeout(timeout);
+                match should_be_forwarder {
                     Ok(TpuReturnType::LeaderRotation(tick_height)) => {
-                        return Some((self.leader_to_validator(tick_height), tick_height + 1))
+                        return Some((self.leader_to_validator(tick_height), tick_height + 1));
                     }
-                    _ => {
-                        continue;
+                    Err(RecvTimeoutError::Timeout) => continue,
+                    _ => return None,
+                }
+            } else {
+                let should_be_leader = self.role_notifiers.0.recv_timeout(timeout);
+                match should_be_leader {
+                    Ok(TvuReturnType::LeaderRotation(tick_height, entry_height, last_entry_id)) => {
+                        self.validator_to_leader(tick_height, entry_height, last_entry_id);
+                        return Some((
+                            FullnodeReturnType::ValidatorToLeaderRotation,
+                            tick_height + 1,
+                        ));
                     }
-                },
+                    Err(RecvTimeoutError::Timeout) => continue,
+                    _ => return None,
+                }
             }
         }
     }