Delete dead code

src/vote_stage.rs

@@ -10,23 +10,16 @@ use log::Level;
 use metrics;
 use packet::{BlobRecycler, SharedBlob};
 use result::Result;
-use service::Service;
 use signature::{Keypair, Pubkey};
 use std::result;
-use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
+use std::sync::atomic::AtomicUsize;
 use std::sync::{Arc, RwLock};
-use std::thread::{self, sleep, spawn, JoinHandle};
-use std::time::Duration;
 use streamer::BlobSender;
 use timing;
 use transaction::Transaction;
 
 pub const VOTE_TIMEOUT_MS: u64 = 1000;
 
-pub struct VoteStage {
-    thread_hdl: JoinHandle<()>,
-}
-
 #[derive(Debug, PartialEq, Eq)]
 enum VoteError {
     NoValidLastIdsToVoteOn,
@@ -169,106 +162,23 @@ pub fn send_validator_vote(
     Ok(())
 }
 
-impl VoteStage {
-    pub fn new(
-        keypair: Arc<Keypair>,
-        bank: Arc<Bank>,
-        crdt: Arc<RwLock<Crdt>>,
-        vote_blob_sender: BlobSender,
-        exit: Arc<AtomicBool>,
-    ) -> Self {
-        let blob_recycler = BlobRecycler::default();
-        let thread_hdl = spawn(move || {
-            Self::run(
-                &keypair,
-                &bank,
-                &crdt,
-                &blob_recycler,
-                &vote_blob_sender,
-                &exit,
-            );
-        });
-        VoteStage { thread_hdl }
-    }
-
-    fn run(
-        keypair: &Arc<Keypair>,
-        bank: &Arc<Bank>,
-        crdt: &Arc<RwLock<Crdt>>,
-        blob_recycler: &BlobRecycler,
-        vote_blob_sender: &BlobSender,
-        exit: &Arc<AtomicBool>,
-    ) {
-        while !exit.load(Ordering::Relaxed) {
-            if let Err(err) =
-                send_validator_vote(bank, keypair, crdt, blob_recycler, vote_blob_sender)
-            {
-                info!("Vote failed: {:?}", err);
-            }
-            sleep(Duration::from_millis(VOTE_TIMEOUT_MS));
-        }
-    }
-}
-
-impl Service for VoteStage {
-    type JoinReturnType = ();
-
-    fn join(self) -> thread::Result<()> {
-        self.thread_hdl.join()?;
-        Ok(())
-    }
-}
-
 #[cfg(test)]
 pub mod tests {
     use super::*;
     use bank::Bank;
     use bincode::deserialize;
-    use crdt::{Crdt, Node, NodeInfo};
+    use crdt::{Crdt, NodeInfo};
     use entry::next_entry;
     use hash::{hash, Hash};
     use instruction::Vote;
     use logger;
     use mint::Mint;
-    use service::Service;
-    use signature::{Keypair, KeypairUtil};
-    use std::sync::atomic::AtomicBool;
     use std::sync::mpsc::channel;
     use std::sync::{Arc, RwLock};
+    use std::thread::sleep;
+    use std::time::Duration;
     use transaction::Transaction;
 
-    /// Ensure the VoteStage issues votes at the expected cadence
-    #[test]
-    fn test_vote_cadence() {
-        let keypair = Keypair::new();
-
-        let mint = Mint::new(1234);
-        let bank = Arc::new(Bank::new(&mint));
-
-        let node = Node::new_localhost();
-        let mut crdt = Crdt::new(node.info.clone()).expect("Crdt::new");
-        crdt.set_leader(node.info.id);
-        let (sender, receiver) = channel();
-        let exit = Arc::new(AtomicBool::new(false));
-
-        let vote_stage = VoteStage::new(
-            Arc::new(keypair),
-            bank.clone(),
-            Arc::new(RwLock::new(crdt)),
-            sender,
-            exit.clone(),
-        );
-
-        receiver.recv().unwrap();
-
-        let timeout = Duration::from_millis(VOTE_TIMEOUT_MS * 2);
-        receiver.recv_timeout(timeout).unwrap();
-        receiver.recv_timeout(timeout).unwrap();
-
-        exit.store(true, Ordering::Relaxed);
-        vote_stage.join().expect("join");
-    }
-
     #[test]
     fn test_send_leader_vote() {
         logger::setup();