Add port and gossip options to solana-test-validator (#16696)

validator/src/bin/solana-test-validator.rs

@@ -179,6 +179,44 @@ fn main() {
                        If the ledger already exists then this parameter is silently ignored",
                 ),
         )
+        .arg(
+            Arg::with_name("gossip_port")
+                .long("gossip-port")
+                .value_name("PORT")
+                .takes_value(true)
+                .help("Gossip port number for the validator"),
+        )
+        .arg(
+            Arg::with_name("gossip_host")
+                .long("gossip-host")
+                .value_name("HOST")
+                .takes_value(true)
+                .validator(solana_net_utils::is_host)
+                .help(
+                    "Gossip DNS name or IP address for the validator to advertise in gossip \
+                       [default: 127.0.0.1]",
+                ),
+        )
+        .arg(
+            Arg::with_name("dynamic_port_range")
+                .long("dynamic-port-range")
+                .value_name("MIN_PORT-MAX_PORT")
+                .takes_value(true)
+                .validator(solana_validator::port_range_validator)
+                .help(
+                    "Range to use for dynamically assigned ports \
+                    [default: 1024-65535]",
+                ),
+        )
+        .arg(
+            Arg::with_name("bind_address")
+                .long("bind-address")
+                .value_name("HOST")
+                .takes_value(true)
+                .validator(solana_net_utils::is_host)
+                .default_value("0.0.0.0")
+                .help("IP address to bind the validator ports [default: 0.0.0.0]"),
+        )
         .arg(
             Arg::with_name("clone_account")
                 .long("clone")
@@ -240,6 +278,25 @@ fn main() {
     let rpc_port = value_t_or_exit!(matches, "rpc_port", u16);
     let faucet_port = value_t_or_exit!(matches, "faucet_port", u16);
     let slots_per_epoch = value_t!(matches, "slots_per_epoch", Slot).ok();
+    let gossip_host = matches.value_of("gossip_host").map(|gossip_host| {
+        solana_net_utils::parse_host(gossip_host).unwrap_or_else(|err| {
+            eprintln!("Failed to parse --gossip-host: {}", err);
+            exit(1);
+        })
+    });
+    let gossip_port = value_t!(matches, "gossip_port", u16).ok();
+    let dynamic_port_range = matches.value_of("dynamic_port_range").map(|port_range| {
+        solana_net_utils::parse_port_range(port_range).unwrap_or_else(|| {
+            eprintln!("Failed to parse --dynamic-port-range");
+            exit(1);
+        })
+    });
+    let bind_address = matches.value_of("bind_address").map(|bind_address| {
+        solana_net_utils::parse_host(bind_address).unwrap_or_else(|err| {
+            eprintln!("Failed to parse --bind-address: {}", err);
+            exit(1);
+        })
+    });
 
     let faucet_addr = Some(SocketAddr::new(
         IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0)),
@@ -467,6 +524,22 @@ fn main() {
         ));
     }
 
+    if let Some(gossip_host) = gossip_host {
+        genesis.gossip_host(gossip_host);
+    }
+
+    if let Some(gossip_port) = gossip_port {
+        genesis.gossip_port(gossip_port);
+    }
+
+    if let Some(dynamic_port_range) = dynamic_port_range {
+        genesis.port_range(dynamic_port_range);
+    }
+
+    if let Some(bind_address) = bind_address {
+        genesis.bind_ip_addr(bind_address);
+    }
+
     match genesis.start_with_mint_address(mint_address) {
         Ok(test_validator) => {
             if let Some(dashboard) = dashboard {

validator/src/lib.rs

@@ -1,5 +1,5 @@
 #![allow(clippy::integer_arithmetic)]
-pub use solana_core::test_validator;
+pub use solana_core::{cluster_info::MINIMUM_VALIDATOR_PORT_RANGE_WIDTH, test_validator};
 use {
     console::style,
     indicatif::{ProgressBar, ProgressDrawTarget, ProgressStyle},
@@ -75,6 +75,22 @@ pub fn port_validator(port: String) -> Result<(), String> {
         .map_err(|e| format!("{:?}", e))
 }
 
+pub fn port_range_validator(port_range: String) -> Result<(), String> {
+    if let Some((start, end)) = solana_net_utils::parse_port_range(&port_range) {
+        if end - start < MINIMUM_VALIDATOR_PORT_RANGE_WIDTH {
+            Err(format!(
+                "Port range is too small.  Try --dynamic-port-range {}-{}",
+                start,
+                start + MINIMUM_VALIDATOR_PORT_RANGE_WIDTH
+            ))
+        } else {
+            Ok(())
+        }
+    } else {
+        Err("Invalid port range".to_string())
+    }
+}
+
 /// Creates a new process bar for processing that will take an unknown amount of time
 pub fn new_spinner_progress_bar() -> ProgressBar {
     let progress_bar = ProgressBar::new(42);

validator/src/main.rs

@@ -21,9 +21,7 @@ use {
         DEFAULT_MAX_LEDGER_SHREDS, DEFAULT_MIN_MAX_LEDGER_SHREDS,
     },
     solana_core::{
-        cluster_info::{
-            ClusterInfo, Node, MINIMUM_VALIDATOR_PORT_RANGE_WIDTH, VALIDATOR_PORT_RANGE,
-        },
+        cluster_info::{ClusterInfo, Node, VALIDATOR_PORT_RANGE},
         contact_info::ContactInfo,
         gossip_service::GossipService,
         poh_service,
@@ -296,22 +294,6 @@ fn wait_for_restart_window(
     Ok(())
 }
 
-fn port_range_validator(port_range: String) -> Result<(), String> {
-    if let Some((start, end)) = solana_net_utils::parse_port_range(&port_range) {
-        if end - start < MINIMUM_VALIDATOR_PORT_RANGE_WIDTH {
-            Err(format!(
-                "Port range is too small.  Try --dynamic-port-range {}-{}",
-                start,
-                start + MINIMUM_VALIDATOR_PORT_RANGE_WIDTH
-            ))
-        } else {
-            Ok(())
-        }
-    } else {
-        Err("Invalid port range".to_string())
-    }
-}
-
 fn hash_validator(hash: String) -> Result<(), String> {
     Hash::from_str(&hash)
         .map(|_| ())
@@ -1298,7 +1280,7 @@ pub fn main() {
                 .value_name("MIN_PORT-MAX_PORT")
                 .takes_value(true)
                 .default_value(default_dynamic_port_range)
-                .validator(port_range_validator)
+                .validator(solana_validator::port_range_validator)
                 .help("Range to use for dynamically assigned ports"),
         )
         .arg(