Make BroadcastStage an actual stage

TODO: Why isn't BroadcastStage/RetransmitStage managed by the NCP?

src/broadcast_stage.rs

@@ -7,12 +7,13 @@ use erasure;
 use log::Level;
 use packet::BlobRecycler;
 use result::{Error, Result};
+use service::Service;
 use std::mem;
 use std::net::UdpSocket;
 use std::sync::atomic::AtomicUsize;
 use std::sync::mpsc::RecvTimeoutError;
 use std::sync::{Arc, RwLock};
-use std::thread::{Builder, JoinHandle};
+use std::thread::{self, Builder, JoinHandle};
 use std::time::Duration;
 use streamer::BlobReceiver;
 use window::{self, SharedWindow, WindowIndex, WINDOW_SIZE};
@@ -22,15 +23,15 @@ fn broadcast(
     broadcast_table: &[NodeInfo],
     window: &SharedWindow,
     recycler: &BlobRecycler,
-    r: &BlobReceiver,
+    receiver: &BlobReceiver,
     sock: &UdpSocket,
     transmit_index: &mut WindowIndex,
     receive_index: &mut u64,
 ) -> Result<()> {
     let debug_id = node_info.debug_id();
     let timer = Duration::new(1, 0);
-    let mut dq = r.recv_timeout(timer)?;
+    let mut dq = receiver.recv_timeout(timer)?;
-    while let Ok(mut nq) = r.try_recv() {
+    while let Ok(mut nq) = receiver.try_recv() {
         dq.append(&mut nq);
     }
 
@@ -119,26 +120,19 @@ fn broadcast(
     Ok(())
 }
 
-/// Service to broadcast messages from the leader to layer 1 nodes.
+pub struct BroadcastStage {
-/// See `crdt` for network layer definitions.
+    thread_hdl: JoinHandle<()>,
-/// # Arguments
+}
-/// * `sock` - Socket to send from.
+
-/// * `exit` - Boolean to signal system exit.
+impl BroadcastStage {
-/// * `crdt` - CRDT structure
+    fn run(
-/// * `window` - Cache of blobs that we have broadcast
-/// * `recycler` - Blob recycler.
-/// * `r` - Receive channel for blobs to be retransmitted to all the layer 1 nodes.
-pub fn broadcaster(
         sock: UdpSocket,
         crdt: Arc<RwLock<Crdt>>,
         window: SharedWindow,
         entry_height: u64,
         recycler: BlobRecycler,
-    r: BlobReceiver,
+        receiver: BlobReceiver,
-) -> JoinHandle<()> {
+    ) {
-    Builder::new()
-        .name("solana-broadcaster".to_string())
-        .spawn(move || {
         let mut transmit_index = WindowIndex {
             data: entry_height,
             coding: entry_height,
@@ -152,7 +146,7 @@ pub fn broadcaster(
                 &broadcast_table,
                 &window,
                 &recycler,
-                    &r,
+                &receiver,
                 &sock,
                 &mut transmit_index,
                 &mut receive_index,
@@ -168,6 +162,42 @@ pub fn broadcaster(
                 }
             }
         }
-        })
+    }
-        .unwrap()
+
+    /// Service to broadcast messages from the leader to layer 1 nodes.
+    /// See `crdt` for network layer definitions.
+    /// # Arguments
+    /// * `sock` - Socket to send from.
+    /// * `exit` - Boolean to signal system exit.
+    /// * `crdt` - CRDT structure
+    /// * `window` - Cache of blobs that we have broadcast
+    /// * `recycler` - Blob recycler.
+    /// * `receiver` - Receive channel for blobs to be retransmitted to all the layer 1 nodes.
+    pub fn new(
+        sock: UdpSocket,
+        crdt: Arc<RwLock<Crdt>>,
+        window: SharedWindow,
+        entry_height: u64,
+        recycler: BlobRecycler,
+        receiver: BlobReceiver,
+    ) -> Self {
+        let thread_hdl = Builder::new()
+            .name("solana-broadcaster".to_string())
+            .spawn(move || {
+                Self::run(sock, crdt, window, entry_height, recycler, receiver);
+            })
+            .unwrap();
+
+        BroadcastStage { thread_hdl }
+    }
+}
+
+impl Service for BroadcastStage {
+    fn thread_hdls(self) -> Vec<JoinHandle<()>> {
+        vec![self.thread_hdl]
+    }
+
+    fn join(self) -> thread::Result<()> {
+        self.thread_hdl.join()
+    }
 }

src/fullnode.rs

@@ -1,7 +1,7 @@
 //! The `fullnode` module hosts all the fullnode microservices.
 
 use bank::Bank;
-use broadcast_stage;
+use broadcast_stage::BroadcastStage;
 use crdt::{Crdt, NodeInfo, TestNode};
 use entry::Entry;
 use ledger::read_ledger;
@@ -230,7 +230,7 @@ impl FullNode {
         ).expect("Ncp::new");
         thread_hdls.extend(ncp.thread_hdls());
 
-        let t_broadcast = broadcast_stage::broadcaster(
+        let broadcast_stage = BroadcastStage::new(
             node.sockets.broadcast,
             crdt,
             window,
@@ -238,7 +238,7 @@ impl FullNode {
             blob_recycler.clone(),
             blob_receiver,
         );
-        thread_hdls.extend(vec![t_broadcast]);
+        thread_hdls.extend(broadcast_stage.thread_hdls());
 
         FullNode { exit, thread_hdls }
     }

src/retransmit_stage.rs

@@ -13,8 +13,7 @@ use std::sync::atomic::AtomicUsize;
 use std::sync::mpsc::channel;
 use std::sync::mpsc::RecvTimeoutError;
 use std::sync::{Arc, RwLock};
-use std::thread::Builder;
+use std::thread::{self, Builder, JoinHandle};
-use std::thread::{self, JoinHandle};
 use std::time::Duration;
 use streamer::BlobReceiver;
 use window::{self, SharedWindow};
@@ -49,7 +48,7 @@ fn retransmit(
 /// * `crdt` - This structure needs to be updated and populated by the bank and via gossip.
 /// * `recycler` - Blob recycler.
 /// * `r` - Receive channel for blobs to be retransmitted to all the layer 1 nodes.
-pub fn retransmitter(
+fn retransmitter(
     sock: UdpSocket,
     crdt: Arc<RwLock<Crdt>>,
     recycler: BlobRecycler,