Add rpc port sanity checks, fix tests

core/src/rpc.rs

@@ -47,8 +47,7 @@ fn new_response<T>(bank: &Bank, value: T) -> RpcResponse<T> {
 
 #[derive(Debug, Default, Clone)]
 pub struct JsonRpcConfig {
-    pub rpc_ports: Option<(u16, u16)>, // (API, PubSub)
-    pub enable_validator_exit: bool,   // Enable the 'validatorExit' command
+    pub enable_validator_exit: bool, // Enable the 'validatorExit' command
     pub faucet_addr: Option<SocketAddr>,
 }
 

core/src/validator.rs

@@ -63,6 +63,7 @@ pub struct ValidatorConfig {
     pub storage_slots_per_turn: u64,
     pub account_paths: Vec<PathBuf>,
     pub rpc_config: JsonRpcConfig,
+    pub rpc_ports: Option<(u16, u16)>, // (API, PubSub)
     pub snapshot_config: Option<SnapshotConfig>,
     pub max_ledger_slots: Option<u64>,
     pub broadcast_stage_type: BroadcastStageType,
@@ -86,6 +87,7 @@ impl Default for ValidatorConfig {
             max_ledger_slots: None,
             account_paths: Vec::new(),
             rpc_config: JsonRpcConfig::default(),
+            rpc_ports: None,
             snapshot_config: None,
             broadcast_stage_type: BroadcastStageType::Standard,
             enable_partition: None,
@@ -219,30 +221,34 @@ impl Validator {
 
         let subscriptions = Arc::new(RpcSubscriptions::new(&exit));
 
-        let rpc_service = config
-            .rpc_config
-            .rpc_ports
-            .map(|(rpc_port, rpc_pubsub_port)| {
-                (
-                    JsonRpcService::new(
-                        SocketAddr::new(IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0)), rpc_port),
-                        config.rpc_config.clone(),
-                        bank_forks.clone(),
-                        block_commitment_cache.clone(),
-                        blockstore.clone(),
-                        cluster_info.clone(),
-                        genesis_hash,
-                        ledger_path,
-                        storage_state.clone(),
-                        validator_exit.clone(),
-                    ),
-                    PubSubService::new(
-                        &subscriptions,
-                        SocketAddr::new(IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0)), rpc_pubsub_port),
-                        &exit,
-                    ),
-                )
-            });
+        let rpc_service = config.rpc_ports.map(|(rpc_port, rpc_pubsub_port)| {
+            if ContactInfo::is_valid_address(&node.info.rpc) {
+                assert!(ContactInfo::is_valid_address(&node.info.rpc_pubsub));
+                assert_eq!(rpc_port, node.info.rpc.port());
+                assert_eq!(rpc_pubsub_port, node.info.rpc_pubsub.port());
+            } else {
+                assert!(!ContactInfo::is_valid_address(&node.info.rpc_pubsub));
+            }
+            (
+                JsonRpcService::new(
+                    SocketAddr::new(IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0)), rpc_port),
+                    config.rpc_config.clone(),
+                    bank_forks.clone(),
+                    block_commitment_cache.clone(),
+                    blockstore.clone(),
+                    cluster_info.clone(),
+                    genesis_hash,
+                    ledger_path,
+                    storage_state.clone(),
+                    validator_exit.clone(),
+                ),
+                PubSubService::new(
+                    &subscriptions,
+                    SocketAddr::new(IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0)), rpc_pubsub_port),
+                    &exit,
+                ),
+            )
+        });
 
         let (transaction_status_sender, transaction_status_service) =
             if rpc_service.is_some() && !config.transaction_status_service_disabled {
@@ -597,8 +603,11 @@ pub fn new_validator_for_tests() -> (Validator, ContactInfo, Keypair, PathBuf) {
 
     let leader_voting_keypair = Arc::new(voting_keypair);
     let storage_keypair = Arc::new(Keypair::new());
-    let mut config = ValidatorConfig::default();
-    config.transaction_status_service_disabled = true;
+    let config = ValidatorConfig {
+        transaction_status_service_disabled: true,
+        rpc_ports: Some((node.info.rpc.port(), node.info.rpc_pubsub.port())),
+        ..ValidatorConfig::default()
+    };
     let node = Validator::new(
         node,
         &node_keypair,
@@ -699,8 +708,14 @@ mod tests {
 
         let voting_keypair = Arc::new(Keypair::new());
         let storage_keypair = Arc::new(Keypair::new());
-        let mut config = ValidatorConfig::default();
-        config.transaction_status_service_disabled = true;
+        let config = ValidatorConfig {
+            transaction_status_service_disabled: true,
+            rpc_ports: Some((
+                validator_node.info.rpc.port(),
+                validator_node.info.rpc_pubsub.port(),
+            )),
+            ..ValidatorConfig::default()
+        };
         let validator = Validator::new(
             validator_node,
             &Arc::new(validator_keypair),
@@ -733,8 +748,14 @@ mod tests {
                 ledger_paths.push(validator_ledger_path.clone());
                 let voting_keypair = Arc::new(Keypair::new());
                 let storage_keypair = Arc::new(Keypair::new());
-                let mut config = ValidatorConfig::default();
-                config.transaction_status_service_disabled = true;
+                let config = ValidatorConfig {
+                    transaction_status_service_disabled: true,
+                    rpc_ports: Some((
+                        validator_node.info.rpc.port(),
+                        validator_node.info.rpc_pubsub.port(),
+                    )),
+                    ..ValidatorConfig::default()
+                };
                 Validator::new(
                     validator_node,
                     &Arc::new(validator_keypair),

local-cluster/src/local_cluster.rs

@@ -207,6 +207,10 @@ impl LocalCluster {
         let leader_storage_keypair = Arc::new(storage_keypair);
         let leader_voting_keypair = Arc::new(voting_keypair);
         let mut leader_config = config.validator_configs[0].clone();
+        leader_config.rpc_ports = Some((
+            leader_node.info.rpc.port(),
+            leader_node.info.rpc_pubsub.port(),
+        ));
         leader_config.transaction_status_service_disabled = true;
         let leader_server = Validator::new(
             leader_node,
@@ -351,6 +355,10 @@ impl LocalCluster {
         }
 
         let mut config = validator_config.clone();
+        config.rpc_ports = Some((
+            validator_node.info.rpc.port(),
+            validator_node.info.rpc_pubsub.port(),
+        ));
         config.transaction_status_service_disabled = true;
         let voting_keypair = Arc::new(voting_keypair);
         let validator_server = Validator::new(
@@ -658,6 +666,8 @@ impl Cluster for LocalCluster {
         // Update the stored ContactInfo for this node
         let node = Node::new_localhost_with_pubkey(&pubkey);
         cluster_validator_info.info.contact_info = node.info.clone();
+        cluster_validator_info.config.rpc_ports =
+            Some((node.info.rpc.port(), node.info.rpc_pubsub.port()));
         cluster_validator_info
             .config
             .transaction_status_service_disabled = true;

validator/src/main.rs

@@ -684,14 +684,14 @@ pub fn main() {
         expected_shred_version: value_t!(matches, "expected_shred_version", u16).ok(),
         new_hard_forks: hardforks_of(&matches, "hard_forks"),
         rpc_config: JsonRpcConfig {
-            rpc_ports: value_t!(matches, "rpc_port", u16)
-                .ok()
-                .map(|rpc_port| (rpc_port, rpc_port + 1)),
             enable_validator_exit: matches.is_present("enable_rpc_exit"),
             faucet_addr: matches.value_of("rpc_faucet_addr").map(|address| {
                 solana_net_utils::parse_host_port(address).expect("failed to parse faucet address")
             }),
         },
+        rpc_ports: value_t!(matches, "rpc_port", u16)
+            .ok()
+            .map(|rpc_port| (rpc_port, rpc_port + 1)),
         voting_disabled: matches.is_present("no_voting"),
         wait_for_supermajority: !matches.is_present("no_wait_for_supermajority"),
         ..ValidatorConfig::default()
@@ -863,7 +863,7 @@ pub fn main() {
         Node::new_with_external_ip(&identity_keypair.pubkey(), &gossip_addr, dynamic_port_range);
 
     if !private_rpc {
-        if let Some((rpc_port, rpc_pubsub_port)) = validator_config.rpc_config.rpc_ports {
+        if let Some((rpc_port, rpc_pubsub_port)) = validator_config.rpc_ports {
             node.info.rpc = SocketAddr::new(node.info.gossip.ip(), rpc_port);
             node.info.rpc_pubsub = SocketAddr::new(node.info.gossip.ip(), rpc_pubsub_port);
             tcp_ports = vec![rpc_port, rpc_pubsub_port];