2018-12-06 12:52:47 -08:00
|
|
|
//! The `gossip_service` module implements the network control plane.
|
2018-06-06 16:36:54 -07:00
|
|
|
|
2019-02-20 21:36:08 -08:00
|
|
|
use crate::bank_forks::BankForks;
|
2019-02-07 20:52:39 -08:00
|
|
|
use crate::blocktree::Blocktree;
|
2019-03-07 12:24:30 -08:00
|
|
|
use crate::cluster_info::{ClusterInfo, NodeInfo};
|
2018-12-07 19:16:27 -08:00
|
|
|
use crate::service::Service;
|
|
|
|
use crate::streamer;
|
2019-02-10 16:28:52 -08:00
|
|
|
use solana_sdk::signature::{Keypair, KeypairUtil};
|
2018-05-27 18:21:39 -07:00
|
|
|
use std::net::UdpSocket;
|
2018-07-09 13:53:18 -07:00
|
|
|
use std::sync::atomic::{AtomicBool, Ordering};
|
2018-05-27 18:21:39 -07:00
|
|
|
use std::sync::mpsc::channel;
|
|
|
|
use std::sync::{Arc, RwLock};
|
2019-02-10 16:28:52 -08:00
|
|
|
use std::thread::sleep;
|
2018-07-03 21:14:08 -07:00
|
|
|
use std::thread::{self, JoinHandle};
|
2019-03-06 20:54:43 -08:00
|
|
|
use std::time::{Duration, Instant};
|
2018-05-27 18:21:39 -07:00
|
|
|
|
2018-12-06 12:52:47 -08:00
|
|
|
pub struct GossipService {
|
2018-07-03 21:14:08 -07:00
|
|
|
thread_hdls: Vec<JoinHandle<()>>,
|
2018-05-27 18:21:39 -07:00
|
|
|
}
|
|
|
|
|
2018-12-06 12:52:47 -08:00
|
|
|
impl GossipService {
|
2018-05-27 18:21:39 -07:00
|
|
|
pub fn new(
|
2018-10-08 19:55:54 -07:00
|
|
|
cluster_info: &Arc<RwLock<ClusterInfo>>,
|
2019-02-07 20:52:39 -08:00
|
|
|
blocktree: Option<Arc<Blocktree>>,
|
2019-02-20 21:36:08 -08:00
|
|
|
bank_forks: Option<Arc<RwLock<BankForks>>>,
|
2018-08-28 16:32:40 -07:00
|
|
|
gossip_socket: UdpSocket,
|
2019-03-04 16:33:14 -08:00
|
|
|
exit: &Arc<AtomicBool>,
|
2018-09-03 02:23:43 -07:00
|
|
|
) -> Self {
|
2018-05-27 18:21:39 -07:00
|
|
|
let (request_sender, request_receiver) = channel();
|
2018-08-28 16:32:40 -07:00
|
|
|
let gossip_socket = Arc::new(gossip_socket);
|
2018-05-27 18:21:39 -07:00
|
|
|
trace!(
|
2018-12-06 12:52:47 -08:00
|
|
|
"GossipService: id: {}, listening on: {:?}",
|
2018-11-15 13:23:26 -08:00
|
|
|
&cluster_info.read().unwrap().my_data().id,
|
2018-08-28 16:32:40 -07:00
|
|
|
gossip_socket.local_addr().unwrap()
|
2018-05-27 18:21:39 -07:00
|
|
|
);
|
2019-03-04 20:50:02 -08:00
|
|
|
let t_receiver = streamer::blob_receiver(gossip_socket.clone(), &exit, request_sender);
|
2018-05-27 18:21:39 -07:00
|
|
|
let (response_sender, response_receiver) = channel();
|
2018-12-06 12:52:47 -08:00
|
|
|
let t_responder = streamer::responder("gossip", gossip_socket, response_receiver);
|
2018-10-08 19:55:54 -07:00
|
|
|
let t_listen = ClusterInfo::listen(
|
|
|
|
cluster_info.clone(),
|
2019-02-07 20:52:39 -08:00
|
|
|
blocktree,
|
2018-05-27 18:21:39 -07:00
|
|
|
request_receiver,
|
|
|
|
response_sender.clone(),
|
2019-03-04 20:50:02 -08:00
|
|
|
exit,
|
2019-02-20 21:36:08 -08:00
|
|
|
);
|
2019-03-04 20:50:02 -08:00
|
|
|
let t_gossip = ClusterInfo::gossip(cluster_info.clone(), bank_forks, response_sender, exit);
|
2018-05-27 18:21:39 -07:00
|
|
|
let thread_hdls = vec![t_receiver, t_responder, t_listen, t_gossip];
|
2019-03-04 18:53:03 -08:00
|
|
|
Self { thread_hdls }
|
2018-05-27 18:21:39 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-03-06 17:08:40 -08:00
|
|
|
pub fn discover(
|
|
|
|
entry_point_info: &NodeInfo,
|
|
|
|
num_nodes: usize,
|
2019-03-07 10:13:54 -08:00
|
|
|
) -> Result<(Option<NodeInfo>, Vec<NodeInfo>), &'static str> {
|
2019-03-04 18:53:03 -08:00
|
|
|
let exit = Arc::new(AtomicBool::new(false));
|
2019-03-06 17:08:40 -08:00
|
|
|
let (gossip_service, spy_ref) = make_spy_node(entry_point_info, &exit);
|
|
|
|
let id = spy_ref.read().unwrap().keypair.pubkey();
|
2019-02-10 16:28:52 -08:00
|
|
|
trace!(
|
2019-03-06 13:58:33 -08:00
|
|
|
"discover: spy_node {} looking for at least {} nodes",
|
2019-02-10 16:28:52 -08:00
|
|
|
id,
|
|
|
|
num_nodes
|
|
|
|
);
|
|
|
|
|
|
|
|
// Wait for the cluster to converge
|
2019-03-06 20:54:43 -08:00
|
|
|
let now = Instant::now();
|
|
|
|
let mut i = 0;
|
2019-03-07 10:13:54 -08:00
|
|
|
while now.elapsed() < Duration::from_secs(30) {
|
2019-02-10 16:28:52 -08:00
|
|
|
let rpc_peers = spy_ref.read().unwrap().rpc_peers();
|
2019-03-07 10:13:54 -08:00
|
|
|
if rpc_peers.len() >= num_nodes {
|
2019-03-06 20:54:43 -08:00
|
|
|
info!(
|
2019-03-07 10:13:54 -08:00
|
|
|
"discover success in {}s...\n{}",
|
|
|
|
now.elapsed().as_secs(),
|
|
|
|
spy_ref.read().unwrap().node_info_trace()
|
2019-03-06 20:54:43 -08:00
|
|
|
);
|
2019-03-07 10:13:54 -08:00
|
|
|
|
|
|
|
let leader = spy_ref.read().unwrap().get_gossip_top_leader().cloned();
|
2019-03-04 18:53:03 -08:00
|
|
|
exit.store(true, Ordering::Relaxed);
|
|
|
|
gossip_service.join().unwrap();
|
2019-03-07 10:13:54 -08:00
|
|
|
return Ok((leader, rpc_peers));
|
2019-02-10 16:28:52 -08:00
|
|
|
}
|
2019-03-06 20:54:43 -08:00
|
|
|
if i % 20 == 0 {
|
2019-03-07 10:13:54 -08:00
|
|
|
info!(
|
|
|
|
"discovering...\n{}",
|
|
|
|
spy_ref.read().unwrap().node_info_trace()
|
2019-03-06 20:54:43 -08:00
|
|
|
);
|
|
|
|
}
|
|
|
|
sleep(Duration::from_millis(
|
|
|
|
crate::cluster_info::GOSSIP_SLEEP_MILLIS,
|
|
|
|
));
|
|
|
|
i += 1;
|
2019-02-10 16:28:52 -08:00
|
|
|
}
|
2019-03-07 11:33:15 -08:00
|
|
|
|
|
|
|
exit.store(true, Ordering::Relaxed);
|
|
|
|
gossip_service.join().unwrap();
|
2019-03-07 10:13:54 -08:00
|
|
|
info!(
|
|
|
|
"discover failed...\n{}",
|
|
|
|
spy_ref.read().unwrap().node_info_trace()
|
|
|
|
);
|
2019-03-06 17:08:40 -08:00
|
|
|
Err("Failed to converge")
|
2019-02-10 16:28:52 -08:00
|
|
|
}
|
|
|
|
|
2019-03-06 17:08:40 -08:00
|
|
|
pub fn make_spy_node(
|
|
|
|
entry_point: &NodeInfo,
|
2019-03-04 18:53:03 -08:00
|
|
|
exit: &Arc<AtomicBool>,
|
2019-03-06 19:09:37 -08:00
|
|
|
) -> (GossipService, Arc<RwLock<ClusterInfo>>) {
|
|
|
|
let keypair = Arc::new(Keypair::new());
|
|
|
|
let (node, gossip_socket) = ClusterInfo::spy_node(&keypair.pubkey());
|
2019-03-07 10:28:19 -08:00
|
|
|
let mut cluster_info = ClusterInfo::new(node, keypair);
|
2019-03-06 19:09:37 -08:00
|
|
|
cluster_info.insert_info(entry_point.clone());
|
|
|
|
|
|
|
|
let cluster_info = Arc::new(RwLock::new(cluster_info));
|
2019-03-04 16:33:14 -08:00
|
|
|
let gossip_service =
|
2019-03-06 17:08:40 -08:00
|
|
|
GossipService::new(&cluster_info.clone(), None, None, gossip_socket, &exit);
|
|
|
|
(gossip_service, cluster_info)
|
2019-02-10 16:28:52 -08:00
|
|
|
}
|
|
|
|
|
2018-12-06 12:52:47 -08:00
|
|
|
impl Service for GossipService {
|
2018-09-13 14:00:17 -07:00
|
|
|
type JoinReturnType = ();
|
2018-07-03 21:14:08 -07:00
|
|
|
|
|
|
|
fn join(self) -> thread::Result<()> {
|
2018-09-13 14:00:17 -07:00
|
|
|
for thread_hdl in self.thread_hdls {
|
2018-07-03 21:14:08 -07:00
|
|
|
thread_hdl.join()?;
|
|
|
|
}
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-05-27 18:21:39 -07:00
|
|
|
#[cfg(test)]
|
|
|
|
mod tests {
|
2018-12-06 12:52:47 -08:00
|
|
|
use super::*;
|
2018-12-07 19:16:27 -08:00
|
|
|
use crate::cluster_info::{ClusterInfo, Node};
|
2018-07-09 13:53:18 -07:00
|
|
|
use std::sync::atomic::AtomicBool;
|
2018-05-27 18:21:39 -07:00
|
|
|
use std::sync::{Arc, RwLock};
|
|
|
|
|
2018-05-30 09:50:28 -07:00
|
|
|
#[test]
|
2018-07-09 17:35:23 -07:00
|
|
|
#[ignore]
|
2018-05-30 09:50:28 -07:00
|
|
|
// test that stage will exit when flag is set
|
|
|
|
fn test_exit() {
|
|
|
|
let exit = Arc::new(AtomicBool::new(false));
|
2018-08-28 16:32:40 -07:00
|
|
|
let tn = Node::new_localhost();
|
2019-03-06 13:47:18 -08:00
|
|
|
let cluster_info = ClusterInfo::new_with_invalid_keypair(tn.info.clone());
|
2018-10-08 19:55:54 -07:00
|
|
|
let c = Arc::new(RwLock::new(cluster_info));
|
2019-03-04 16:33:14 -08:00
|
|
|
let d = GossipService::new(&c, None, None, tn.sockets.gossip, &exit);
|
2019-03-04 18:53:03 -08:00
|
|
|
exit.store(true, Ordering::Relaxed);
|
|
|
|
d.join().unwrap();
|
2018-05-27 18:21:39 -07:00
|
|
|
}
|
|
|
|
}
|