Rename ClusterInfo::new_with_keypair() to ClusterInfo::new()

core/src/cluster_info.rs

@@ -164,9 +164,9 @@ enum Protocol {
 impl ClusterInfo {
     /// Without a valid keypair gossip will not function. Only useful for tests.
     pub fn new_with_invalid_keypair(node_info: NodeInfo) -> Self {
-        ClusterInfo::new_with_keypair(node_info, Arc::new(Keypair::new()))
+        ClusterInfo::new(node_info, Arc::new(Keypair::new()))
     }
-    pub fn new_with_keypair(node_info: NodeInfo, keypair: Arc<Keypair>) -> Self {
+    pub fn new(node_info: NodeInfo, keypair: Arc<Keypair>) -> Self {
         let mut me = ClusterInfo {
             gossip: CrdsGossip::default(),
             keypair,
@@ -1740,7 +1740,7 @@ mod tests {
         let node_info = NodeInfo::new_localhost(keypair.pubkey(), 0);
         let leader = NodeInfo::new_localhost(leader_keypair.pubkey(), 0);
         let peer = NodeInfo::new_localhost(peer_keypair.pubkey(), 0);
-        let mut cluster_info = ClusterInfo::new_with_keypair(node_info.clone(), Arc::new(keypair));
+        let mut cluster_info = ClusterInfo::new(node_info.clone(), Arc::new(keypair));
         cluster_info.set_leader(leader.id);
         cluster_info.insert_info(peer.clone());
         //check that all types of gossip messages are signed correctly

core/src/fullnode.rs

@@ -120,7 +120,7 @@ impl Fullnode {
         let bank_forks = Arc::new(RwLock::new(bank_forks));
 
         node.info.wallclock = timestamp();
-        let cluster_info = Arc::new(RwLock::new(ClusterInfo::new_with_keypair(
+        let cluster_info = Arc::new(RwLock::new(ClusterInfo::new(
             node.info.clone(),
             keypair.clone(),
         )));

core/src/gossip_service.rs

@@ -58,7 +58,7 @@ pub fn make_listening_node(
     let new_node = Node::new_localhost_with_pubkey(keypair.pubkey());
     let new_node_info = new_node.info.clone();
     let id = new_node.info.id;
-    let mut new_node_cluster_info = ClusterInfo::new_with_keypair(new_node_info, Arc::new(keypair));
+    let mut new_node_cluster_info = ClusterInfo::new(new_node_info, Arc::new(keypair));
     new_node_cluster_info.insert_info(leader.clone());
     new_node_cluster_info.set_leader(leader.id);
     let new_node_cluster_info_ref = Arc::new(RwLock::new(new_node_cluster_info));
@@ -123,17 +123,14 @@ pub fn converge(node: &NodeInfo, num_nodes: usize) -> Vec<NodeInfo> {
 fn make_spy_node(
     leader: &NodeInfo,
     exit: &Arc<AtomicBool>,
-) -> (GossipService, Arc<RwLock<ClusterInfo>>, Pubkey) {
+) -> (GossipService, Arc<RwLock<ClusterInfo>>) {
-    let keypair = Keypair::new();
+    let keypair = Arc::new(Keypair::new());
-    let mut spy = Node::new_localhost_with_pubkey(keypair.pubkey());
+    let (node, gossip_socket) = ClusterInfo::spy_node(&keypair.pubkey());
-    let id = spy.info.id;
+
-    let daddr = "0.0.0.0:0".parse().unwrap();
+    let mut cluster_info = ClusterInfo::new(node, keypair);
-    spy.info.tvu = daddr;
+    cluster_info.insert_info(entry_point.clone());
-    spy.info.rpc = daddr;
+
-    let mut spy_cluster_info = ClusterInfo::new_with_keypair(spy.info, Arc::new(keypair));
+    let cluster_info = Arc::new(RwLock::new(cluster_info));
-    spy_cluster_info.insert_info(leader.clone());
-    spy_cluster_info.set_leader(leader.id);
-    let spy_cluster_info_ref = Arc::new(RwLock::new(spy_cluster_info));
     let gossip_service =
         GossipService::new(&spy_cluster_info_ref, None, None, spy.sockets.gossip, exit);
 

core/src/replay_stage.rs

@@ -361,7 +361,9 @@ mod test {
         let (my_ledger_path, _blockhash) = create_new_tmp_ledger!(&genesis_block);
 
         // Set up the cluster info
-        let cluster_info_me = Arc::new(RwLock::new(ClusterInfo::new_with_invalid_keypair(my_node.info.clone())));
+        let cluster_info_me = Arc::new(RwLock::new(ClusterInfo::new_with_invalid_keypair(
+            my_node.info.clone(),
+        )));
 
         // Set up the replay stage
         {

core/src/replicator.rs

@@ -118,14 +118,10 @@ impl Replicator {
 
         info!("Replicator: id: {}", keypair.pubkey());
         info!("Creating cluster info....");
-        let cluster_info = Arc::new(RwLock::new(ClusterInfo::new_with_invalid_keypair(node.info.clone())));
+        let mut cluster_info = ClusterInfo::new(node.info.clone(), keypair.clone());
-
+        cluster_info.insert_info(leader_info.clone());
-        let leader_pubkey = leader_info.id;
+        cluster_info.set_leader(leader_info.id);
-        {
+        let cluster_info = Arc::new(RwLock::new(cluster_info));
-            let mut cluster_info_w = cluster_info.write().unwrap();
-            cluster_info_w.insert_info(leader_info.clone());
-            cluster_info_w.set_leader(leader_pubkey);
-        }
 
         // Create Blocktree, eventually will simply repurpose the input
         // ledger path as the Blocktree path once we replace the ledger with

core/src/rpc.rs

@@ -437,7 +437,9 @@ mod tests {
             &exit,
         )));
         request_processor.write().unwrap().set_bank(&bank);
-        let cluster_info = Arc::new(RwLock::new(ClusterInfo::new_with_invalid_keypair(NodeInfo::default())));
+        let cluster_info = Arc::new(RwLock::new(ClusterInfo::new_with_invalid_keypair(
+            NodeInfo::default(),
+        )));
         let leader = NodeInfo::new_with_socketaddr(&socketaddr!("127.0.0.1:1234"));
 
         cluster_info.write().unwrap().insert_info(leader.clone());
@@ -638,7 +640,9 @@ mod tests {
                 request_processor.set_bank(&bank);
                 Arc::new(RwLock::new(request_processor))
             },
-            cluster_info: Arc::new(RwLock::new(ClusterInfo::new_with_invalid_keypair(NodeInfo::default()))),
+            cluster_info: Arc::new(RwLock::new(ClusterInfo::new_with_invalid_keypair(
+                NodeInfo::default(),
+            ))),
         };
 
         let req =
@@ -655,7 +659,9 @@ mod tests {
 
     #[test]
     fn test_rpc_get_leader_addr() {
-        let cluster_info = Arc::new(RwLock::new(ClusterInfo::new_with_invalid_keypair(NodeInfo::default())));
+        let cluster_info = Arc::new(RwLock::new(ClusterInfo::new_with_invalid_keypair(
+            NodeInfo::default(),
+        )));
         assert_eq!(
             get_leader_addr(&cluster_info),
             Err(Error {

core/src/rpc_service.rs

@@ -99,7 +99,9 @@ mod tests {
         let (genesis_block, alice) = GenesisBlock::new(10_000);
         let exit = Arc::new(AtomicBool::new(false));
         let bank = Bank::new(&genesis_block);
-        let cluster_info = Arc::new(RwLock::new(ClusterInfo::new_with_invalid_keypair(NodeInfo::default())));
+        let cluster_info = Arc::new(RwLock::new(ClusterInfo::new_with_invalid_keypair(
+            NodeInfo::default(),
+        )));
         let rpc_addr = SocketAddr::new(
             IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0)),
             solana_netutil::find_available_port_in_range((10000, 65535)).unwrap(),

core/src/window_service.rs

@@ -172,7 +172,8 @@ mod test {
         let leader_node = Node::new_localhost();
         let validator_node = Node::new_localhost();
         let exit = Arc::new(AtomicBool::new(false));
-        let mut cluster_info_me = ClusterInfo::new_with_invalid_keypair(validator_node.info.clone());
+        let mut cluster_info_me =
+            ClusterInfo::new_with_invalid_keypair(validator_node.info.clone());
         let me_id = leader_node.info.id;
         cluster_info_me.set_leader(me_id);
         let subs = Arc::new(RwLock::new(cluster_info_me));

replicator/src/main.rs

@@ -5,6 +5,7 @@ use solana::socketaddr;
 use solana_sdk::signature::{read_keypair, Keypair, KeypairUtil};
 use std::net::{Ipv4Addr, SocketAddr};
 use std::process::exit;
+use std::sync::Arc;
 
 fn main() {
     solana_logger::setup();

tests/gossip.rs

@@ -17,13 +17,20 @@ use std::thread::sleep;
 use std::time::Duration;
 
 fn test_node(exit: &Arc<AtomicBool>) -> (Arc<RwLock<ClusterInfo>>, GossipService, UdpSocket) {
-    let keypair = Keypair::new();
+    let keypair = Arc::new(Keypair::new());
-    let mut tn = Node::new_localhost_with_pubkey(keypair.pubkey());
+    let mut test_node = Node::new_localhost_with_pubkey(keypair.pubkey());
-    let cluster_info = ClusterInfo::new_with_keypair(tn.info.clone(), Arc::new(keypair));
+    let cluster_info = Arc::new(RwLock::new(ClusterInfo::new(
-    let c = Arc::new(RwLock::new(cluster_info));
+        test_node.info.clone(),
-    let d = GossipService::new(&c.clone(), None, None, tn.sockets.gossip, exit);
+        keypair,
-    let _ = c.read().unwrap().my_data();
+    )));
-    (c, d, tn.sockets.tvu.pop().unwrap())
+    let gossip_service =
+        GossipService::new(&cluster_info, None, None, test_node.sockets.gossip, exit);
+    let _ = cluster_info.read().unwrap().my_data();
+    (
+        cluster_info,
+        gossip_service,
+        test_node.sockets.tvu.pop().unwrap(),
+    )
 }
 
 /// Test that the network converges.

tests/replicator.rs

@@ -109,7 +109,7 @@ fn test_replicator_startup_basic() {
             );
         }
 
-        let replicator_keypair = Keypair::new();
+        let replicator_keypair = Arc::new(Keypair::new());
 
         info!("giving replicator lamports..");
 
@@ -238,7 +238,7 @@ fn test_replicator_startup_leader_hang() {
     let (replicator_ledger_path, _blockhash) = create_new_tmp_ledger!(&genesis_block);
 
     {
-        let replicator_keypair = Keypair::new();
+        let replicator_keypair = Arc::new(Keypair::new());
 
         info!("starting replicator node");
         let replicator_node = Node::new_localhost_with_pubkey(replicator_keypair.pubkey());
@@ -308,7 +308,7 @@ fn test_replicator_startup_ledger_hang() {
         );
 
         info!("starting replicator node");
-        let bad_keys = Keypair::new();
+        let bad_keys = Arc::new(Keypair::new());
         let mut replicator_node = Node::new_localhost_with_pubkey(bad_keys.pubkey());
 
         // Pass bad TVU sockets to prevent successful ledger download