Add alternative to Spy Nodes that can fully participate in Gossip (#4087)

automerge

core/src/cluster_info.rs

@@ -250,7 +250,7 @@ impl ClusterInfo {
             .all_peers()
             .into_iter()
             .map(|(node, last_updated)| {
-                if !ContactInfo::is_valid_address(&node.gossip) {
+                if Self::is_spy_node(&node) {
                     spy_nodes += 1;
                 }
                 fn addr_to_string(addr: &SocketAddr) -> String {
@@ -412,6 +412,12 @@ impl ClusterInfo {
             .collect()
     }
 
+    fn is_spy_node(contact_info: &ContactInfo) -> bool {
+        !ContactInfo::is_valid_address(&contact_info.tpu)
+            || !ContactInfo::is_valid_address(&contact_info.gossip)
+            || !ContactInfo::is_valid_address(&contact_info.tvu)
+    }
+
     fn sort_by_stake<S: std::hash::BuildHasher>(
         peers: &[ContactInfo],
         stakes: &HashMap<Pubkey, u64, S>,
@@ -1377,6 +1383,26 @@ impl ClusterInfo {
             .unwrap()
     }
 
+    /// An alternative to Spy Node that has a valid gossip address and fully participate in Gossip.
+    pub fn gossip_node(id: &Pubkey, gossip_addr: &SocketAddr) -> (ContactInfo, UdpSocket) {
+        let (port, gossip_socket) = Node::get_gossip_port(gossip_addr, FULLNODE_PORT_RANGE);
+        let daddr = socketaddr_any!();
+
+        let node = ContactInfo::new(
+            id,
+            SocketAddr::new(gossip_addr.ip(), port),
+            daddr,
+            daddr,
+            daddr,
+            daddr,
+            daddr,
+            daddr,
+            timestamp(),
+        );
+        (node, gossip_socket)
+    }
+
+    /// A Node with invalid ports to spy on gossip via pull requests
     pub fn spy_node(id: &Pubkey) -> (ContactInfo, UdpSocket) {
         let (_, gossip_socket) = bind_in_range(FULLNODE_PORT_RANGE).unwrap();
         let daddr = socketaddr_any!();
@@ -1638,6 +1664,16 @@ mod tests {
     use std::net::{IpAddr, Ipv4Addr};
     use std::sync::{Arc, RwLock};
 
+    #[test]
+    fn test_gossip_node() {
+        //check that a gossip nodes always show up as spies
+        let (node, _) = ClusterInfo::spy_node(&Pubkey::new_rand());
+        assert!(ClusterInfo::is_spy_node(&node));
+        let (node, _) =
+            ClusterInfo::gossip_node(&Pubkey::new_rand(), &"1.1.1.1:1111".parse().unwrap());
+        assert!(ClusterInfo::is_spy_node(&node));
+    }
+
     #[test]
     fn test_cluster_spy_gossip() {
         //check that gossip doesn't try to push to invalid addresses

core/src/gossip_service.rs

@@ -53,22 +53,24 @@ impl GossipService {
 }
 
 pub fn discover_nodes(
-    gossip_addr: &SocketAddr,
+    entry_point: &SocketAddr,
     num_nodes: usize,
 ) -> std::io::Result<Vec<ContactInfo>> {
-    discover(gossip_addr, Some(num_nodes), Some(30), None)
+    discover(entry_point, Some(num_nodes), Some(30), None, None)
 }
 
 pub fn discover(
-    gossip_addr: &SocketAddr,
+    entry_point: &SocketAddr,
     num_nodes: Option<usize>,
     timeout: Option<u64>,
     find_node: Option<Pubkey>,
+    gossip_addr: Option<&SocketAddr>,
 ) -> std::io::Result<Vec<ContactInfo>> {
     let exit = Arc::new(AtomicBool::new(false));
-    let (gossip_service, spy_ref) = make_spy_node(gossip_addr, &exit);
+    let (gossip_service, spy_ref) = make_gossip_node(entry_point, &exit, gossip_addr);
+
     let id = spy_ref.read().unwrap().keypair.pubkey();
-    info!("Gossip entry point: {:?}", gossip_addr);
+    info!("Gossip entry point: {:?}", entry_point);
     info!("Spy node id: {:?}", id);
 
     let (met_criteria, secs, tvu_peers) = spy(spy_ref.clone(), num_nodes, timeout, find_node);
@@ -153,14 +155,21 @@ fn spy(
     (met_criteria, now.elapsed().as_secs(), tvu_peers)
 }
 
-fn make_spy_node(
-    gossip_addr: &SocketAddr,
+/// 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(
+    entry_point: &SocketAddr,
     exit: &Arc<AtomicBool>,
+    gossip_addr: Option<&SocketAddr>,
 ) -> (GossipService, Arc<RwLock<ClusterInfo>>) {
     let keypair = Arc::new(Keypair::new());
-    let (node, gossip_socket) = ClusterInfo::spy_node(&keypair.pubkey());
+    let (node, gossip_socket) = if let Some(gossip_addr) = gossip_addr {
+        ClusterInfo::gossip_node(&keypair.pubkey(), gossip_addr)
+    } else {
+        ClusterInfo::spy_node(&keypair.pubkey())
+    };
     let mut cluster_info = ClusterInfo::new(node, keypair);
-    cluster_info.set_entrypoint(ContactInfo::new_gossip_entry_point(gossip_addr));
+    cluster_info.set_entrypoint(ContactInfo::new_gossip_entry_point(entry_point));
     let cluster_info = Arc::new(RwLock::new(cluster_info));
     let gossip_service =
         GossipService::new(&cluster_info.clone(), None, None, gossip_socket, &exit);