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-10-10 16:33:00 -07:00
|
|
|
use crate::cluster_info::{ClusterInfo, VALIDATOR_PORT_RANGE};
|
2019-03-08 17:14:06 -08:00
|
|
|
use crate::contact_info::ContactInfo;
|
2019-05-09 13:43:39 -07:00
|
|
|
use rand::{thread_rng, Rng};
|
2019-05-01 17:14:01 -07:00
|
|
|
use solana_client::thin_client::{create_client, ThinClient};
|
2019-11-14 10:24:53 -08:00
|
|
|
use solana_perf::recycler::Recycler;
|
2020-06-17 08:27:03 -07:00
|
|
|
use solana_runtime::bank_forks::BankForks;
|
2020-09-11 12:00:16 -07:00
|
|
|
use solana_sdk::{
|
|
|
|
pubkey::Pubkey,
|
|
|
|
signature::{Keypair, Signer},
|
|
|
|
};
|
2020-03-17 23:30:23 -07:00
|
|
|
use solana_streamer::streamer;
|
2020-09-11 12:00:16 -07:00
|
|
|
use std::{
|
|
|
|
collections::HashSet,
|
|
|
|
net::{IpAddr, Ipv4Addr, SocketAddr, TcpListener, UdpSocket},
|
|
|
|
sync::{
|
|
|
|
atomic::{AtomicBool, Ordering},
|
|
|
|
mpsc::channel,
|
|
|
|
{Arc, RwLock},
|
|
|
|
},
|
|
|
|
thread::{self, sleep, JoinHandle},
|
|
|
|
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(
|
2020-04-21 12:54:45 -07:00
|
|
|
cluster_info: &Arc<ClusterInfo>,
|
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,
|
2020-09-11 12:00:16 -07:00
|
|
|
gossip_validators: Option<HashSet<Pubkey>>,
|
2021-02-03 08:26:17 -08:00
|
|
|
should_check_duplicate_instance: bool,
|
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: {:?}",
|
2020-04-21 12:54:45 -07:00
|
|
|
&cluster_info.id(),
|
2018-08-28 16:32:40 -07:00
|
|
|
gossip_socket.local_addr().unwrap()
|
2018-05-27 18:21:39 -07:00
|
|
|
);
|
2019-11-14 10:24:53 -08:00
|
|
|
let t_receiver = streamer::receiver(
|
|
|
|
gossip_socket.clone(),
|
|
|
|
&exit,
|
|
|
|
request_sender,
|
2021-02-24 00:15:58 -08:00
|
|
|
Recycler::new_without_limit("gossip-receiver-recycler-shrink-stats"),
|
2019-11-14 10:24:53 -08:00
|
|
|
"gossip_receiver",
|
|
|
|
);
|
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-06-26 00:30:16 -07:00
|
|
|
bank_forks.clone(),
|
2018-05-27 18:21:39 -07:00
|
|
|
request_receiver,
|
|
|
|
response_sender.clone(),
|
2021-02-03 08:26:17 -08:00
|
|
|
should_check_duplicate_instance,
|
2019-03-04 20:50:02 -08:00
|
|
|
exit,
|
2019-02-20 21:36:08 -08:00
|
|
|
);
|
2020-09-11 12:00:16 -07:00
|
|
|
let t_gossip = ClusterInfo::gossip(
|
|
|
|
cluster_info.clone(),
|
|
|
|
bank_forks,
|
|
|
|
response_sender,
|
|
|
|
gossip_validators,
|
|
|
|
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-11-13 10:12:09 -08:00
|
|
|
|
|
|
|
pub fn join(self) -> thread::Result<()> {
|
|
|
|
for thread_hdl in self.thread_hdls {
|
|
|
|
thread_hdl.join()?;
|
|
|
|
}
|
|
|
|
Ok(())
|
|
|
|
}
|
2018-05-27 18:21:39 -07:00
|
|
|
}
|
|
|
|
|
2020-05-14 18:22:47 -07:00
|
|
|
/// Discover Validators in a cluster
|
2019-05-16 07:14:58 -07:00
|
|
|
pub fn discover_cluster(
|
2019-11-16 13:16:28 -08:00
|
|
|
entrypoint: &SocketAddr,
|
2019-04-01 16:11:42 -07:00
|
|
|
num_nodes: usize,
|
2020-05-14 18:22:47 -07:00
|
|
|
) -> std::io::Result<Vec<ContactInfo>> {
|
2019-11-16 13:16:28 -08:00
|
|
|
discover(
|
2020-08-22 14:10:19 -07:00
|
|
|
None,
|
2019-11-16 13:16:28 -08:00
|
|
|
Some(entrypoint),
|
|
|
|
Some(num_nodes),
|
|
|
|
Some(30),
|
|
|
|
None,
|
|
|
|
None,
|
|
|
|
None,
|
2020-05-13 19:37:40 -07:00
|
|
|
0,
|
2019-11-16 13:16:28 -08:00
|
|
|
)
|
2020-05-14 18:22:47 -07:00
|
|
|
.map(|(_all_peers, validators)| validators)
|
2019-04-01 16:11:42 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn discover(
|
2020-08-22 14:10:19 -07:00
|
|
|
keypair: Option<Arc<Keypair>>,
|
2019-11-16 13:16:28 -08:00
|
|
|
entrypoint: Option<&SocketAddr>,
|
2020-05-14 18:22:47 -07:00
|
|
|
num_nodes: Option<usize>, // num_nodes only counts validators, excludes spy nodes
|
2019-04-01 16:11:42 -07:00
|
|
|
timeout: Option<u64>,
|
2019-08-30 16:12:58 -07:00
|
|
|
find_node_by_pubkey: Option<Pubkey>,
|
2019-11-16 13:16:28 -08:00
|
|
|
find_node_by_gossip_addr: Option<&SocketAddr>,
|
2019-11-11 11:42:58 -08:00
|
|
|
my_gossip_addr: Option<&SocketAddr>,
|
2020-05-13 19:37:40 -07:00
|
|
|
my_shred_version: u16,
|
2020-05-14 18:22:47 -07:00
|
|
|
) -> std::io::Result<(Vec<ContactInfo>, Vec<ContactInfo>)> {
|
2020-08-22 14:10:19 -07:00
|
|
|
let keypair = keypair.unwrap_or_else(|| Arc::new(Keypair::new()));
|
|
|
|
|
2019-03-04 18:53:03 -08:00
|
|
|
let exit = Arc::new(AtomicBool::new(false));
|
2021-02-03 08:26:17 -08:00
|
|
|
let (gossip_service, ip_echo, spy_ref) = make_gossip_node(
|
|
|
|
keypair,
|
|
|
|
entrypoint,
|
|
|
|
&exit,
|
|
|
|
my_gossip_addr,
|
|
|
|
my_shred_version,
|
|
|
|
true, // should_check_duplicate_instance,
|
|
|
|
);
|
2019-04-30 16:42:56 -07:00
|
|
|
|
2020-04-21 12:54:45 -07:00
|
|
|
let id = spy_ref.id();
|
2019-11-16 13:16:28 -08:00
|
|
|
info!("Entrypoint: {:?}", entrypoint);
|
|
|
|
info!("Node Id: {:?}", id);
|
|
|
|
if let Some(my_gossip_addr) = my_gossip_addr {
|
|
|
|
info!("Gossip Address: {:?}", my_gossip_addr);
|
|
|
|
}
|
2019-02-10 16:28:52 -08:00
|
|
|
|
2019-11-12 12:37:13 -08:00
|
|
|
let _ip_echo_server = ip_echo.map(solana_net_utils::ip_echo_server);
|
2019-10-24 15:35:33 -07:00
|
|
|
|
2020-05-14 18:22:47 -07:00
|
|
|
let (met_criteria, secs, all_peers, tvu_peers) = spy(
|
2019-08-30 16:12:58 -07:00
|
|
|
spy_ref.clone(),
|
|
|
|
num_nodes,
|
|
|
|
timeout,
|
|
|
|
find_node_by_pubkey,
|
2019-11-11 11:42:58 -08:00
|
|
|
find_node_by_gossip_addr,
|
2019-08-30 16:12:58 -07:00
|
|
|
);
|
2019-04-01 16:11:42 -07:00
|
|
|
|
|
|
|
exit.store(true, Ordering::Relaxed);
|
|
|
|
gossip_service.join().unwrap();
|
|
|
|
|
|
|
|
if met_criteria {
|
|
|
|
info!(
|
|
|
|
"discover success in {}s...\n{}",
|
|
|
|
secs,
|
2020-04-21 12:54:45 -07:00
|
|
|
spy_ref.contact_info_trace()
|
2019-04-01 16:11:42 -07:00
|
|
|
);
|
2020-05-14 18:22:47 -07:00
|
|
|
return Ok((all_peers, tvu_peers));
|
2019-04-01 16:11:42 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
if !tvu_peers.is_empty() {
|
|
|
|
info!(
|
|
|
|
"discover failed to match criteria by timeout...\n{}",
|
2020-04-21 12:54:45 -07:00
|
|
|
spy_ref.contact_info_trace()
|
2019-04-01 16:11:42 -07:00
|
|
|
);
|
2020-05-14 18:22:47 -07:00
|
|
|
return Ok((all_peers, tvu_peers));
|
2019-04-01 16:11:42 -07:00
|
|
|
}
|
|
|
|
|
2020-04-21 12:54:45 -07:00
|
|
|
info!("discover failed...\n{}", spy_ref.contact_info_trace());
|
2019-04-01 16:11:42 -07:00
|
|
|
Err(std::io::Error::new(
|
|
|
|
std::io::ErrorKind::Other,
|
2019-08-13 10:49:48 -07:00
|
|
|
"Discover failed",
|
2019-04-01 16:11:42 -07:00
|
|
|
))
|
|
|
|
}
|
|
|
|
|
2019-05-09 13:43:39 -07:00
|
|
|
/// Creates a ThinClient per valid node
|
2019-05-01 17:14:01 -07:00
|
|
|
pub fn get_clients(nodes: &[ContactInfo]) -> Vec<ThinClient> {
|
|
|
|
nodes
|
|
|
|
.iter()
|
|
|
|
.filter_map(ContactInfo::valid_client_facing_addr)
|
2019-10-10 16:33:00 -07:00
|
|
|
.map(|addrs| create_client(addrs, VALIDATOR_PORT_RANGE))
|
2019-05-01 17:14:01 -07:00
|
|
|
.collect()
|
|
|
|
}
|
|
|
|
|
2019-05-09 13:43:39 -07:00
|
|
|
/// Creates a ThinClient by selecting a valid node at random
|
|
|
|
pub fn get_client(nodes: &[ContactInfo]) -> ThinClient {
|
|
|
|
let nodes: Vec<_> = nodes
|
|
|
|
.iter()
|
|
|
|
.filter_map(ContactInfo::valid_client_facing_addr)
|
|
|
|
.collect();
|
|
|
|
let select = thread_rng().gen_range(0, nodes.len());
|
2019-10-10 16:33:00 -07:00
|
|
|
create_client(nodes[select], VALIDATOR_PORT_RANGE)
|
2019-05-09 13:43:39 -07:00
|
|
|
}
|
|
|
|
|
2019-05-27 20:54:44 -07:00
|
|
|
pub fn get_multi_client(nodes: &[ContactInfo]) -> (ThinClient, usize) {
|
|
|
|
let addrs: Vec<_> = nodes
|
|
|
|
.iter()
|
|
|
|
.filter_map(ContactInfo::valid_client_facing_addr)
|
|
|
|
.collect();
|
2019-09-06 09:07:40 -07:00
|
|
|
let rpc_addrs: Vec<_> = addrs.iter().map(|addr| addr.0).collect();
|
|
|
|
let tpu_addrs: Vec<_> = addrs.iter().map(|addr| addr.1).collect();
|
2020-03-04 21:46:43 -08:00
|
|
|
let (_, transactions_socket) = solana_net_utils::bind_in_range(
|
|
|
|
IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0)),
|
|
|
|
VALIDATOR_PORT_RANGE,
|
|
|
|
)
|
|
|
|
.unwrap();
|
2019-09-06 09:07:40 -07:00
|
|
|
let num_nodes = tpu_addrs.len();
|
2019-05-27 20:54:44 -07:00
|
|
|
(
|
2019-09-06 09:07:40 -07:00
|
|
|
ThinClient::new_from_addrs(rpc_addrs, tpu_addrs, transactions_socket),
|
2019-05-27 20:54:44 -07:00
|
|
|
num_nodes,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
2019-04-01 16:11:42 -07:00
|
|
|
fn spy(
|
2020-04-21 12:54:45 -07:00
|
|
|
spy_ref: Arc<ClusterInfo>,
|
2019-04-01 16:11:42 -07:00
|
|
|
num_nodes: Option<usize>,
|
|
|
|
timeout: Option<u64>,
|
2019-08-30 16:12:58 -07:00
|
|
|
find_node_by_pubkey: Option<Pubkey>,
|
2019-11-16 13:16:28 -08:00
|
|
|
find_node_by_gossip_addr: Option<&SocketAddr>,
|
2020-05-14 18:22:47 -07:00
|
|
|
) -> (bool, u64, Vec<ContactInfo>, Vec<ContactInfo>) {
|
2019-03-06 20:54:43 -08:00
|
|
|
let now = Instant::now();
|
2019-04-01 16:11:42 -07:00
|
|
|
let mut met_criteria = false;
|
2020-04-23 11:46:12 -07:00
|
|
|
let mut all_peers: Vec<ContactInfo> = Vec::new();
|
2019-04-01 16:11:42 -07:00
|
|
|
let mut tvu_peers: Vec<ContactInfo> = Vec::new();
|
2020-02-12 11:16:07 -08:00
|
|
|
let mut i = 1;
|
|
|
|
while !met_criteria {
|
2019-04-01 16:11:42 -07:00
|
|
|
if let Some(secs) = timeout {
|
|
|
|
if now.elapsed() >= Duration::from_secs(secs) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2020-02-12 11:16:07 -08:00
|
|
|
|
2020-04-23 11:46:12 -07:00
|
|
|
all_peers = spy_ref
|
|
|
|
.all_peers()
|
|
|
|
.into_iter()
|
|
|
|
.map(|x| x.0)
|
|
|
|
.collect::<Vec<_>>();
|
2020-04-21 12:54:45 -07:00
|
|
|
tvu_peers = spy_ref.all_tvu_peers().into_iter().collect::<Vec<_>>();
|
2020-02-12 11:16:07 -08:00
|
|
|
|
|
|
|
let found_node_by_pubkey = if let Some(pubkey) = find_node_by_pubkey {
|
2020-04-23 11:46:12 -07:00
|
|
|
all_peers.iter().any(|x| x.id == pubkey)
|
2020-02-12 11:16:07 -08:00
|
|
|
} else {
|
|
|
|
false
|
|
|
|
};
|
|
|
|
|
|
|
|
let found_node_by_gossip_addr = if let Some(gossip_addr) = find_node_by_gossip_addr {
|
2020-04-23 11:46:12 -07:00
|
|
|
all_peers.iter().any(|x| x.gossip == *gossip_addr)
|
2020-02-12 11:16:07 -08:00
|
|
|
} else {
|
|
|
|
false
|
|
|
|
};
|
|
|
|
|
2019-04-01 16:11:42 -07:00
|
|
|
if let Some(num) = num_nodes {
|
2020-04-23 11:46:12 -07:00
|
|
|
// Only consider validators and archives for `num_nodes`
|
2020-05-14 18:22:47 -07:00
|
|
|
let mut nodes: Vec<_> = tvu_peers.iter().collect();
|
2020-04-23 11:46:12 -07:00
|
|
|
nodes.sort();
|
|
|
|
nodes.dedup();
|
|
|
|
|
2020-02-12 11:16:07 -08:00
|
|
|
if nodes.len() >= num {
|
|
|
|
if found_node_by_pubkey || found_node_by_gossip_addr {
|
2019-04-01 16:11:42 -07:00
|
|
|
met_criteria = true;
|
|
|
|
}
|
2020-02-12 11:16:07 -08:00
|
|
|
|
|
|
|
if find_node_by_pubkey.is_none() && find_node_by_gossip_addr.is_none() {
|
2019-08-30 16:12:58 -07:00
|
|
|
met_criteria = true;
|
|
|
|
}
|
2019-04-01 16:11:42 -07:00
|
|
|
}
|
2020-02-12 11:16:07 -08:00
|
|
|
} else if found_node_by_pubkey || found_node_by_gossip_addr {
|
|
|
|
met_criteria = true;
|
2019-02-10 16:28:52 -08:00
|
|
|
}
|
2019-03-06 20:54:43 -08:00
|
|
|
if i % 20 == 0 {
|
2020-04-21 12:54:45 -07:00
|
|
|
info!("discovering...\n{}", spy_ref.contact_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
|
|
|
}
|
2020-05-14 18:22:47 -07:00
|
|
|
(met_criteria, now.elapsed().as_secs(), all_peers, tvu_peers)
|
2019-02-10 16:28:52 -08:00
|
|
|
}
|
|
|
|
|
2019-04-30 16:42:56 -07:00
|
|
|
/// Makes a spy or gossip node based on whether or not a gossip_addr was passed in
|
|
|
|
/// Pass in a gossip addr to fully participate in gossip instead of relying on just pulls
|
|
|
|
fn make_gossip_node(
|
2020-08-22 14:10:19 -07:00
|
|
|
keypair: Arc<Keypair>,
|
2019-11-16 13:16:28 -08:00
|
|
|
entrypoint: Option<&SocketAddr>,
|
2019-03-04 18:53:03 -08:00
|
|
|
exit: &Arc<AtomicBool>,
|
2019-04-30 16:42:56 -07:00
|
|
|
gossip_addr: Option<&SocketAddr>,
|
2020-05-13 19:37:40 -07:00
|
|
|
shred_version: u16,
|
2021-02-03 08:26:17 -08:00
|
|
|
should_check_duplicate_instance: bool,
|
2020-04-21 12:54:45 -07:00
|
|
|
) -> (GossipService, Option<TcpListener>, Arc<ClusterInfo>) {
|
2019-10-24 15:35:33 -07:00
|
|
|
let (node, gossip_socket, ip_echo) = if let Some(gossip_addr) = gossip_addr {
|
2020-05-13 19:37:40 -07:00
|
|
|
ClusterInfo::gossip_node(&keypair.pubkey(), gossip_addr, shred_version)
|
2019-04-30 16:42:56 -07:00
|
|
|
} else {
|
2020-05-13 19:37:40 -07:00
|
|
|
ClusterInfo::spy_node(&keypair.pubkey(), shred_version)
|
2019-04-30 16:42:56 -07:00
|
|
|
};
|
2020-04-21 12:54:45 -07:00
|
|
|
let cluster_info = ClusterInfo::new(node, keypair);
|
2019-11-16 13:16:28 -08:00
|
|
|
if let Some(entrypoint) = entrypoint {
|
|
|
|
cluster_info.set_entrypoint(ContactInfo::new_gossip_entry_point(entrypoint));
|
|
|
|
}
|
2020-04-21 12:54:45 -07:00
|
|
|
let cluster_info = Arc::new(cluster_info);
|
2021-02-03 08:26:17 -08:00
|
|
|
let gossip_service = GossipService::new(
|
|
|
|
&cluster_info,
|
|
|
|
None,
|
|
|
|
gossip_socket,
|
|
|
|
None,
|
|
|
|
should_check_duplicate_instance,
|
|
|
|
&exit,
|
|
|
|
);
|
2019-10-24 15:35:33 -07:00
|
|
|
(gossip_service, ip_echo, cluster_info)
|
2019-02-10 16:28:52 -08:00
|
|
|
}
|
|
|
|
|
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;
|
2020-04-21 12:54:45 -07:00
|
|
|
use std::sync::Arc;
|
2018-05-27 18:21:39 -07:00
|
|
|
|
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());
|
2020-04-21 12:54:45 -07:00
|
|
|
let c = Arc::new(cluster_info);
|
2021-02-03 08:26:17 -08:00
|
|
|
let d = GossipService::new(
|
|
|
|
&c,
|
|
|
|
None,
|
|
|
|
tn.sockets.gossip,
|
|
|
|
None,
|
|
|
|
true, // should_check_duplicate_instance
|
|
|
|
&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
|
|
|
}
|
2019-04-01 16:11:42 -07:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_gossip_services_spy() {
|
|
|
|
let keypair = Keypair::new();
|
2020-10-19 12:12:08 -07:00
|
|
|
let peer0 = solana_sdk::pubkey::new_rand();
|
|
|
|
let peer1 = solana_sdk::pubkey::new_rand();
|
2019-04-01 16:11:42 -07:00
|
|
|
let contact_info = ContactInfo::new_localhost(&keypair.pubkey(), 0);
|
|
|
|
let peer0_info = ContactInfo::new_localhost(&peer0, 0);
|
|
|
|
let peer1_info = ContactInfo::new_localhost(&peer1, 0);
|
2020-05-15 09:35:43 -07:00
|
|
|
let cluster_info = ClusterInfo::new(contact_info, Arc::new(keypair));
|
2019-11-11 11:42:58 -08:00
|
|
|
cluster_info.insert_info(peer0_info.clone());
|
2019-04-01 16:11:42 -07:00
|
|
|
cluster_info.insert_info(peer1_info);
|
|
|
|
|
2020-04-21 12:54:45 -07:00
|
|
|
let spy_ref = Arc::new(cluster_info);
|
2019-04-01 16:11:42 -07:00
|
|
|
|
2020-05-14 18:22:47 -07:00
|
|
|
let (met_criteria, secs, _, tvu_peers) = spy(spy_ref.clone(), None, Some(1), None, None);
|
2019-04-01 16:11:42 -07:00
|
|
|
assert_eq!(met_criteria, false);
|
|
|
|
assert_eq!(secs, 1);
|
2020-04-21 12:54:45 -07:00
|
|
|
assert_eq!(tvu_peers, spy_ref.tvu_peers());
|
2019-04-01 16:11:42 -07:00
|
|
|
|
|
|
|
// Find num_nodes
|
2020-05-14 18:22:47 -07:00
|
|
|
let (met_criteria, _, _, _) = spy(spy_ref.clone(), Some(1), None, None, None);
|
2019-04-01 16:11:42 -07:00
|
|
|
assert_eq!(met_criteria, true);
|
2020-05-14 18:22:47 -07:00
|
|
|
let (met_criteria, _, _, _) = spy(spy_ref.clone(), Some(2), None, None, None);
|
2019-04-01 16:11:42 -07:00
|
|
|
assert_eq!(met_criteria, true);
|
|
|
|
|
|
|
|
// Find specific node by pubkey
|
2020-05-14 18:22:47 -07:00
|
|
|
let (met_criteria, _, _, _) = spy(spy_ref.clone(), None, None, Some(peer0), None);
|
2019-04-01 16:11:42 -07:00
|
|
|
assert_eq!(met_criteria, true);
|
2020-05-14 18:22:47 -07:00
|
|
|
let (met_criteria, _, _, _) = spy(
|
2019-08-30 16:12:58 -07:00
|
|
|
spy_ref.clone(),
|
|
|
|
None,
|
|
|
|
Some(0),
|
2020-10-19 12:12:08 -07:00
|
|
|
Some(solana_sdk::pubkey::new_rand()),
|
2019-08-30 16:12:58 -07:00
|
|
|
None,
|
|
|
|
);
|
2019-04-01 16:11:42 -07:00
|
|
|
assert_eq!(met_criteria, false);
|
|
|
|
|
|
|
|
// Find num_nodes *and* specific node by pubkey
|
2020-05-14 18:22:47 -07:00
|
|
|
let (met_criteria, _, _, _) = spy(spy_ref.clone(), Some(1), None, Some(peer0), None);
|
2019-04-01 16:11:42 -07:00
|
|
|
assert_eq!(met_criteria, true);
|
2020-05-14 18:22:47 -07:00
|
|
|
let (met_criteria, _, _, _) = spy(spy_ref.clone(), Some(3), Some(0), Some(peer0), None);
|
2019-08-30 16:12:58 -07:00
|
|
|
assert_eq!(met_criteria, false);
|
2020-05-14 18:22:47 -07:00
|
|
|
let (met_criteria, _, _, _) = spy(
|
2019-08-30 16:12:58 -07:00
|
|
|
spy_ref.clone(),
|
|
|
|
Some(1),
|
|
|
|
Some(0),
|
2020-10-19 12:12:08 -07:00
|
|
|
Some(solana_sdk::pubkey::new_rand()),
|
2019-08-30 16:12:58 -07:00
|
|
|
None,
|
|
|
|
);
|
2019-04-01 16:11:42 -07:00
|
|
|
assert_eq!(met_criteria, false);
|
2019-08-30 16:12:58 -07:00
|
|
|
|
2019-11-11 11:42:58 -08:00
|
|
|
// Find specific node by gossip address
|
2020-05-14 18:22:47 -07:00
|
|
|
let (met_criteria, _, _, _) =
|
2019-11-16 13:16:28 -08:00
|
|
|
spy(spy_ref.clone(), None, None, None, Some(&peer0_info.gossip));
|
2019-08-30 16:12:58 -07:00
|
|
|
assert_eq!(met_criteria, true);
|
2019-11-16 13:16:28 -08:00
|
|
|
|
2020-05-14 18:22:47 -07:00
|
|
|
let (met_criteria, _, _, _) = spy(
|
2020-05-15 09:35:43 -07:00
|
|
|
spy_ref,
|
2019-08-30 16:12:58 -07:00
|
|
|
None,
|
|
|
|
Some(0),
|
|
|
|
None,
|
2019-11-16 13:16:28 -08:00
|
|
|
Some(&"1.1.1.1:1234".parse().unwrap()),
|
2019-08-30 16:12:58 -07:00
|
|
|
);
|
2019-04-01 16:11:42 -07:00
|
|
|
assert_eq!(met_criteria, false);
|
|
|
|
}
|
2018-05-27 18:21:39 -07:00
|
|
|
}
|