streamer send destination metrics for repair, gossip (#21564)

core/src/lib.rs

@@ -52,6 +52,7 @@ pub mod sigverify;
 pub mod sigverify_shreds;
 pub mod sigverify_stage;
 pub mod snapshot_packager_service;
+pub mod stats_reporter_service;
 pub mod system_monitor_service;
 pub mod tower_storage;
 pub mod tpu;

core/src/serve_repair_service.rs

@@ -5,7 +5,11 @@ use {
     solana_streamer::{socket::SocketAddrSpace, streamer},
     std::{
         net::UdpSocket,
-        sync::{atomic::AtomicBool, mpsc::channel, Arc, RwLock},
+        sync::{
+            atomic::AtomicBool,
+            mpsc::{channel, Sender},
+            Arc, RwLock,
+        },
         thread::{self, JoinHandle},
     },
 };
@@ -20,6 +24,7 @@ impl ServeRepairService {
         blockstore: Option<Arc<Blockstore>>,
         serve_repair_socket: UdpSocket,
         socket_addr_space: SocketAddrSpace,
+        stats_reporter_sender: Sender<Box<dyn FnOnce() + Send>>,
         exit: &Arc<AtomicBool>,
     ) -> Self {
         let (request_sender, request_receiver) = channel();
@@ -44,6 +49,7 @@ impl ServeRepairService {
             serve_repair_socket,
             response_receiver,
             socket_addr_space,
+            Some(stats_reporter_sender),
         );
         let t_listen = ServeRepair::listen(
             serve_repair.clone(),

core/src/stats_reporter_service.rs

@@ -0,0 +1,53 @@
+use std::{
+    result::Result,
+    sync::{
+        atomic::{AtomicBool, Ordering},
+        mpsc::{Receiver, RecvTimeoutError},
+        Arc,
+    },
+    thread::{self, Builder, JoinHandle},
+    time::Duration,
+};
+
+pub struct StatsReporterService {
+    thread_hdl: JoinHandle<()>,
+}
+
+impl StatsReporterService {
+    pub fn new(
+        reporting_receiver: Receiver<Box<dyn FnOnce() + Send>>,
+        exit: &Arc<AtomicBool>,
+    ) -> Self {
+        let exit = exit.clone();
+        let thread_hdl = Builder::new()
+            .name("solana-stats-reporter".to_owned())
+            .spawn(move || loop {
+                if exit.load(Ordering::Relaxed) {
+                    return;
+                }
+                if let Err(e) = Self::receive_reporting_func(&reporting_receiver) {
+                    match e {
+                        RecvTimeoutError::Disconnected => break,
+                        RecvTimeoutError::Timeout => (),
+                    }
+                }
+            })
+            .unwrap();
+
+        Self { thread_hdl }
+    }
+
+    pub fn join(self) -> thread::Result<()> {
+        self.thread_hdl.join()?;
+        Ok(())
+    }
+
+    fn receive_reporting_func(
+        r: &Receiver<Box<dyn FnOnce() + Send>>,
+    ) -> Result<(), RecvTimeoutError> {
+        let timer = Duration::new(1, 0);
+        let func = r.recv_timeout(timer)?;
+        func();
+        Ok(())
+    }
+}

core/src/validator.rs

@@ -14,6 +14,7 @@ use {
         serve_repair_service::ServeRepairService,
         sigverify,
         snapshot_packager_service::SnapshotPackagerService,
+        stats_reporter_service::StatsReporterService,
         system_monitor_service::{verify_udp_stats_access, SystemMonitorService},
         tower_storage::TowerStorage,
         tpu::{Tpu, DEFAULT_TPU_COALESCE_MS},
@@ -276,6 +277,7 @@ pub struct Validator {
     cache_block_meta_service: Option<CacheBlockMetaService>,
     system_monitor_service: Option<SystemMonitorService>,
     sample_performance_service: Option<SamplePerformanceService>,
+    stats_reporter_service: StatsReporterService,
     gossip_service: GossipService,
     serve_repair_service: ServeRepairService,
     completed_data_sets_service: CompletedDataSetsService,
@@ -697,12 +699,17 @@ impl Validator {
                 Some(node.info.shred_version),
             )),
         };
+
+        let (stats_reporter_sender, stats_reporter_receiver) = channel();
+        let stats_reporter_service = StatsReporterService::new(stats_reporter_receiver, &exit);
+
         let gossip_service = GossipService::new(
             &cluster_info,
             Some(bank_forks.clone()),
             node.sockets.gossip,
             config.gossip_validators.clone(),
             should_check_duplicate_instance,
+            Some(stats_reporter_sender.clone()),
             &exit,
         );
         let serve_repair = Arc::new(RwLock::new(ServeRepair::new(cluster_info.clone())));
@@ -711,6 +718,7 @@ impl Validator {
             Some(blockstore.clone()),
             node.sockets.serve_repair,
             socket_addr_space,
+            stats_reporter_sender,
             &exit,
         );
 
@@ -904,6 +912,7 @@ impl Validator {
 
         *start_progress.write().unwrap() = ValidatorStartProgress::Running;
         Self {
+            stats_reporter_service,
             gossip_service,
             serve_repair_service,
             json_rpc_service,
@@ -1028,6 +1037,9 @@ impl Validator {
         self.serve_repair_service
             .join()
             .expect("serve_repair_service");
+        self.stats_reporter_service
+            .join()
+            .expect("stats_reporter_service");
         self.tpu.join().expect("tpu");
         self.tvu.join().expect("tvu");
         self.completed_data_sets_service