Skip to content

Commit 0b78585

Browse files
alexpyattaevalexpyattaev
committed
adjust some of the crashy tests to use the new port allocation logic
1 parent 3a8a613 commit 0b78585

File tree

4 files changed

+86
-75
lines changed

4 files changed

+86
-75
lines changed

‎gossip/src/cluster_info.rs

+40-39
Original file line numberDiff line numberDiff line change
@@ -52,7 +52,8 @@ use {
5252
solana_ledger::shred::Shred,
5353
solana_net_utils::{
5454
bind_in_range, bind_in_range_with_config, bind_more_with_config, bind_to_unspecified,
55-
bind_to_with_config, find_available_ports_in_range, multi_bind_in_range_with_config,
55+
bind_to_with_config, bind_two_in_range_with_offset_and_config,
56+
find_available_ports_in_range, multi_bind_in_range_with_config,
5657
sockets::{get_gossip_port, localhost_port_range_for_tests},
5758
PortRange, SocketConfig, VALIDATOR_PORT_RANGE,
5859
},
@@ -2422,14 +2423,6 @@ impl Node {
24222423
Self::new_single_bind(pubkey, &gossip_addr, port_range, addr)
24232424
}
24242425

2425-
fn bind_with_config(
2426-
bind_ip_addr: IpAddr,
2427-
port_range: PortRange,
2428-
config: SocketConfig,
2429-
) -> (u16, UdpSocket) {
2430-
bind_in_range_with_config(bind_ip_addr, port_range, config).expect("Failed to bind")
2431-
}
2432-
24332426
#[deprecated(since = "2.3.0", note = "Please use `new_with_external_ip` instead.")]
24342427
pub fn new_single_bind(
24352428
pubkey: &Pubkey,
@@ -2485,47 +2478,49 @@ impl Node {
24852478
)
24862479
.expect("tvu multi_bind");
24872480
let (tvu_quic_port, tvu_quic) =
2488-
Self::bind_with_config(bind_ip_addr, port_range, socket_config);
2489-
let (tpu_port, tpu_sockets) =
2490-
multi_bind_in_range_with_config(bind_ip_addr, port_range, socket_config_reuseport, 32)
2491-
.expect("tpu multi_bind");
2481+
bind_in_range_with_config(bind_ip_addr, port_range, socket_config).expect("TVU QUIC");
2482+
2483+
let ((tpu_port, tpu_sockets), (_tpu_port_quic, tpu_quic)) =
2484+
bind_two_in_range_with_offset_and_config(
2485+
bind_ip_addr,
2486+
port_range,
2487+
QUIC_PORT_OFFSET,
2488+
socket_config_reuseport,
2489+
socket_config_reuseport,
2490+
)
2491+
.expect("TPU primary bind");
2492+
let tpu_sockets = bind_more_with_config(tpu_sockets, 32, socket_config_reuseport).unwrap();
24922493

2493-
let (_tpu_port_quic, tpu_quic) = bind_in_range_with_config(
2494-
bind_ip_addr,
2495-
(tpu_port + QUIC_PORT_OFFSET, tpu_port + QUIC_PORT_OFFSET + 1),
2496-
socket_config_reuseport,
2497-
)
2498-
.expect("TPU quic port bind should succeed");
24992494
let tpu_quic =
25002495
bind_more_with_config(tpu_quic, num_quic_endpoints.get(), socket_config_reuseport)
25012496
.unwrap();
25022497

2503-
let (tpu_forwards_port, tpu_forwards_sockets) =
2504-
multi_bind_in_range_with_config(bind_ip_addr, port_range, socket_config_reuseport, 8)
2498+
let ((tpu_forwards_port, tpu_forwards_sockets), (_, tpu_forwards_quic)) =
2499+
bind_two_in_range_with_offset_and_config(
2500+
bind_ip_addr,
2501+
port_range,
2502+
QUIC_PORT_OFFSET,
2503+
socket_config_reuseport,
2504+
socket_config_reuseport,
2505+
)
2506+
.expect("TPU forwards primary bind");
2507+
let tpu_forwards_sockets =
2508+
bind_more_with_config(tpu_forwards_sockets, 8, socket_config_reuseport)
25052509
.expect("tpu_forwards multi_bind");
2506-
2507-
let (_tpu_forwards_port_quic, tpu_forwards_quic) = bind_in_range_with_config(
2508-
bind_ip_addr,
2509-
(
2510-
tpu_forwards_port + QUIC_PORT_OFFSET,
2511-
tpu_forwards_port + QUIC_PORT_OFFSET + 1,
2512-
),
2513-
socket_config_reuseport,
2514-
)
2515-
.expect("TPU QUIC binding should succeed");
25162510
let tpu_forwards_quic = bind_more_with_config(
25172511
tpu_forwards_quic,
25182512
num_quic_endpoints.get(),
25192513
socket_config_reuseport,
25202514
)
2521-
.unwrap();
2515+
.expect("TPU forwards QUIC");
25222516

25232517
let (tpu_vote_port, tpu_vote_sockets) =
25242518
multi_bind_in_range_with_config(bind_ip_addr, port_range, socket_config_reuseport, 1)
25252519
.expect("tpu_vote multi_bind");
25262520

25272521
let (tpu_vote_quic_port, tpu_vote_quic) =
2528-
Self::bind_with_config(bind_ip_addr, port_range, socket_config_reuseport);
2522+
bind_in_range_with_config(bind_ip_addr, port_range, socket_config_reuseport)
2523+
.expect("TPU vote QUIC");
25292524
let tpu_vote_quic = bind_more_with_config(
25302525
tpu_vote_quic,
25312526
num_quic_endpoints.get(),
@@ -2541,22 +2536,28 @@ impl Node {
25412536
)
25422537
.expect("retransmit multi_bind");
25432538

2544-
let (_, repair) = Self::bind_with_config(bind_ip_addr, port_range, socket_config);
2545-
let (_, repair_quic) = Self::bind_with_config(bind_ip_addr, port_range, socket_config);
2539+
let (_, repair) = bind_in_range_with_config(bind_ip_addr, port_range, socket_config)
2540+
.expect("Repair bind should succeed");
2541+
let (_, repair_quic) = bind_in_range_with_config(bind_ip_addr, port_range, socket_config)
2542+
.expect("Repair QUIC bind should succeed");
25462543

25472544
let (serve_repair_port, serve_repair) =
2548-
Self::bind_with_config(bind_ip_addr, port_range, socket_config);
2545+
bind_in_range_with_config(bind_ip_addr, port_range, socket_config)
2546+
.expect("Serve repair bind should succeed");
25492547
let (serve_repair_quic_port, serve_repair_quic) =
2550-
Self::bind_with_config(bind_ip_addr, port_range, socket_config);
2548+
bind_in_range_with_config(bind_ip_addr, port_range, socket_config)
2549+
.expect("Serve repair QUIC should succeed");
25512550

25522551
let (_, broadcast) =
25532552
multi_bind_in_range_with_config(bind_ip_addr, port_range, socket_config_reuseport, 4)
25542553
.expect("broadcast multi_bind");
25552554

25562555
let (_, ancestor_hashes_requests) =
2557-
Self::bind_with_config(bind_ip_addr, port_range, socket_config);
2556+
bind_in_range_with_config(bind_ip_addr, port_range, socket_config)
2557+
.expect("Ancestor hashes requests bind should succeed");
25582558
let (_, ancestor_hashes_requests_quic) =
2559-
Self::bind_with_config(bind_ip_addr, port_range, socket_config);
2559+
bind_in_range_with_config(bind_ip_addr, port_range, socket_config)
2560+
.expect("Ancestor hashes requests QUIC bind should succeed");
25602561

25612562
// These are client sockets, so the port is set to be 0 because it must be ephimeral.
25622563
let tpu_vote_forwards_client = bind_to_with_config(bind_ip_addr, 0, socket_config).unwrap();

‎net-utils/src/lib.rs

+37-28
Original file line numberDiff line numberDiff line change
@@ -771,20 +771,23 @@ mod tests {
771771

772772
#[test]
773773
fn test_bind() {
774+
let (pr_s, pr_e) = sockets::localhost_port_range_for_tests();
774775
let ip_addr = IpAddr::V4(Ipv4Addr::UNSPECIFIED);
775-
assert_eq!(bind_in_range(ip_addr, (2000, 2001)).unwrap().0, 2000);
776+
let s = bind_in_range(ip_addr, (pr_s, pr_e)).unwrap();
777+
assert_eq!(s.0, pr_s, "bind_in_range should use first available port");
776778
let ip_addr = IpAddr::V4(Ipv4Addr::UNSPECIFIED);
777779
let config = SocketConfig::default().reuseport(true);
778-
let x = bind_to_with_config(ip_addr, 2002, config).unwrap();
779-
let y = bind_to_with_config(ip_addr, 2002, config).unwrap();
780+
let x = bind_to_with_config(ip_addr, pr_s + 1, config).unwrap();
781+
let y = bind_to_with_config(ip_addr, pr_s + 1, config).unwrap();
780782
assert_eq!(
781783
x.local_addr().unwrap().port(),
782784
y.local_addr().unwrap().port()
783785
);
784-
bind_to(ip_addr, 2002, false).unwrap_err();
785-
bind_in_range(ip_addr, (2002, 2003)).unwrap_err();
786+
bind_to(ip_addr, pr_s, false).unwrap_err();
787+
bind_in_range(ip_addr, (pr_s, pr_s + 2)).unwrap_err();
786788

787-
let (port, v) = multi_bind_in_range_with_config(ip_addr, (2010, 2110), config, 10).unwrap();
789+
let (port, v) =
790+
multi_bind_in_range_with_config(ip_addr, (pr_s + 5, pr_e), config, 10).unwrap();
788791
for sock in &v {
789792
assert_eq!(port, sock.local_addr().unwrap().port());
790793
}
@@ -811,36 +814,39 @@ mod tests {
811814

812815
#[test]
813816
fn test_find_available_port_in_range() {
814-
let ip_addr = IpAddr::V4(Ipv4Addr::UNSPECIFIED);
817+
let ip_addr = IpAddr::V4(Ipv4Addr::LOCALHOST);
818+
let (pr_s, pr_e) = sockets::localhost_port_range_for_tests();
815819
assert_eq!(
816-
find_available_port_in_range(ip_addr, (3000, 3001)).unwrap(),
817-
3000
820+
find_available_port_in_range(ip_addr, (pr_s, pr_s + 1)).unwrap(),
821+
pr_s
818822
);
819-
let port = find_available_port_in_range(ip_addr, (3000, 3050)).unwrap();
820-
assert!((3000..3050).contains(&port));
823+
let port = find_available_port_in_range(ip_addr, (pr_s, pr_e)).unwrap();
824+
assert!((pr_s..pr_e).contains(&port));
821825

822826
let _socket = bind_to(ip_addr, port, false).unwrap();
823827
find_available_port_in_range(ip_addr, (port, port + 1)).unwrap_err();
824828
}
825829

826830
#[test]
827831
fn test_bind_common_in_range() {
828-
let ip_addr = IpAddr::V4(Ipv4Addr::UNSPECIFIED);
832+
let ip_addr = IpAddr::V4(Ipv4Addr::LOCALHOST);
833+
let (pr_s, pr_e) = sockets::localhost_port_range_for_tests();
829834
let config = SocketConfig::default();
830835
let (port, _sockets) =
831-
bind_common_in_range_with_config(ip_addr, (3100, 3150), config).unwrap();
832-
assert!((3100..3150).contains(&port));
836+
bind_common_in_range_with_config(ip_addr, (pr_s, pr_e), config).unwrap();
837+
assert!((pr_s..pr_e).contains(&port));
833838

834839
bind_common_in_range_with_config(ip_addr, (port, port + 1), config).unwrap_err();
835840
}
836841

837842
#[test]
838843
fn test_get_public_ip_addr_none() {
839844
solana_logger::setup();
840-
let ip_addr = IpAddr::V4(Ipv4Addr::UNSPECIFIED);
845+
let ip_addr = IpAddr::V4(Ipv4Addr::LOCALHOST);
846+
let (pr_s, pr_e) = sockets::localhost_port_range_for_tests();
841847
let config = SocketConfig::default();
842848
let (_server_port, (server_udp_socket, server_tcp_listener)) =
843-
bind_common_in_range_with_config(ip_addr, (3200, 3300), config).unwrap();
849+
bind_common_in_range_with_config(ip_addr, (pr_s, pr_e), config).unwrap();
844850

845851
let _runtime = ip_echo_server(
846852
server_tcp_listener,
@@ -861,12 +867,13 @@ mod tests {
861867
#[test]
862868
fn test_get_public_ip_addr_reachable() {
863869
solana_logger::setup();
864-
let ip_addr = IpAddr::V4(Ipv4Addr::UNSPECIFIED);
870+
let ip_addr = IpAddr::V4(Ipv4Addr::LOCALHOST);
871+
let port_range = sockets::localhost_port_range_for_tests();
865872
let config = SocketConfig::default();
866873
let (_server_port, (server_udp_socket, server_tcp_listener)) =
867-
bind_common_in_range_with_config(ip_addr, (3200, 3300), config).unwrap();
874+
bind_common_in_range_with_config(ip_addr, port_range, config).unwrap();
868875
let (_client_port, (client_udp_socket, client_tcp_listener)) =
869-
bind_common_in_range_with_config(ip_addr, (3200, 3300), config).unwrap();
876+
bind_common_in_range_with_config(ip_addr, port_range, config).unwrap();
870877

871878
let _runtime = ip_echo_server(
872879
server_tcp_listener,
@@ -896,16 +903,17 @@ mod tests {
896903
#[test]
897904
fn test_verify_ports_tcp_unreachable() {
898905
solana_logger::setup();
899-
let ip_addr = IpAddr::V4(Ipv4Addr::UNSPECIFIED);
906+
let ip_addr = IpAddr::V4(Ipv4Addr::LOCALHOST);
907+
let port_range = sockets::localhost_port_range_for_tests();
900908
let config = SocketConfig::default();
901909
let (_server_port, (server_udp_socket, _server_tcp_listener)) =
902-
bind_common_in_range_with_config(ip_addr, (3200, 3300), config).unwrap();
910+
bind_common_in_range_with_config(ip_addr, port_range, config).unwrap();
903911

904912
// make the socket unreachable by not running the ip echo server!
905913
let server_ip_echo_addr = server_udp_socket.local_addr().unwrap();
906914

907915
let (_, (_client_udp_socket, client_tcp_listener)) =
908-
bind_common_in_range_with_config(ip_addr, (3200, 3300), config).unwrap();
916+
bind_common_in_range_with_config(ip_addr, port_range, config).unwrap();
909917

910918
let rt = runtime();
911919
assert!(!rt.block_on(ip_echo_client::verify_all_reachable_tcp(
@@ -918,16 +926,17 @@ mod tests {
918926
#[test]
919927
fn test_verify_ports_udp_unreachable() {
920928
solana_logger::setup();
921-
let ip_addr = IpAddr::V4(Ipv4Addr::UNSPECIFIED);
929+
let ip_addr = IpAddr::V4(Ipv4Addr::LOCALHOST);
930+
let port_range = sockets::localhost_port_range_for_tests();
922931
let config = SocketConfig::default();
923932
let (_server_port, (server_udp_socket, _server_tcp_listener)) =
924-
bind_common_in_range_with_config(ip_addr, (3200, 3300), config).unwrap();
933+
bind_common_in_range_with_config(ip_addr, port_range, config).unwrap();
925934

926935
// make the socket unreachable by not running the ip echo server!
927936
let server_ip_echo_addr = server_udp_socket.local_addr().unwrap();
928937

929938
let (_correct_client_port, (client_udp_socket, _client_tcp_listener)) =
930-
bind_common_in_range_with_config(ip_addr, (3200, 3300), config).unwrap();
939+
bind_common_in_range_with_config(ip_addr, port_range, config).unwrap();
931940

932941
let rt = runtime();
933942
assert!(!rt.block_on(ip_echo_client::verify_all_reachable_udp(
@@ -941,18 +950,18 @@ mod tests {
941950
#[test]
942951
fn test_verify_many_ports_reachable() {
943952
solana_logger::setup();
944-
let ip_addr = IpAddr::V4(Ipv4Addr::UNSPECIFIED);
953+
let ip_addr = IpAddr::V4(Ipv4Addr::LOCALHOST);
945954
let config = SocketConfig::default();
946955
let mut tcp_listeners = vec![];
947956
let mut udp_sockets = vec![];
948957

949958
let (_server_port, (_, server_tcp_listener)) =
950-
bind_common_in_range_with_config(ip_addr, (3200, 3300), config).unwrap();
959+
bind_common_in_range_with_config(ip_addr, (2200, 2300), config).unwrap();
951960
for _ in 0..MAX_PORT_VERIFY_THREADS * 2 {
952961
let (_client_port, (client_udp_socket, client_tcp_listener)) =
953962
bind_common_in_range_with_config(
954963
ip_addr,
955-
(3300, 3300 + (MAX_PORT_VERIFY_THREADS * 3) as u16),
964+
(2300, 2300 + (MAX_PORT_VERIFY_THREADS * 3) as u16),
956965
config,
957966
)
958967
.unwrap();

‎net-utils/src/sockets.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,7 @@ use {
88

99
const BASE_PORT: u16 = 5000;
1010

11-
/// Retrieve a free 100-port slice for unit tests
11+
/// Retrieve a free 20-port slice for unit tests
1212
///
1313
/// When running under nextest, this will try to provide
1414
/// a unique slice of port numbers (assuming no other nextest processes

‎test-validator/src/lib.rs

+8-7
Original file line numberDiff line numberDiff line change
@@ -29,7 +29,9 @@ use {
2929
blockstore::create_new_ledger, blockstore_options::LedgerColumnOptions,
3030
create_new_tmp_ledger,
3131
},
32-
solana_net_utils::{find_available_ports_in_range, PortRange},
32+
solana_net_utils::{
33+
find_available_ports_in_range, sockets::localhost_port_range_for_tests, PortRange,
34+
},
3335
solana_rpc::{rpc::JsonRpcConfig, rpc_pubsub_service::PubSubConfig},
3436
solana_rpc_client::{nonblocking, rpc_client::RpcClient},
3537
solana_rpc_client_api::request::MAX_MULTIPLE_ACCOUNTS,
@@ -95,14 +97,13 @@ pub struct TestValidatorNodeConfig {
9597

9698
impl Default for TestValidatorNodeConfig {
9799
fn default() -> Self {
98-
const MIN_PORT_RANGE: u16 = 1024;
99-
const MAX_PORT_RANGE: u16 = 65535;
100-
101100
let bind_ip_addr = IpAddr::V4(Ipv4Addr::LOCALHOST);
102-
let port_range = (MIN_PORT_RANGE, MAX_PORT_RANGE);
103-
101+
#[cfg(not(debug_assertions))]
102+
let port_range = solana_net_utils::VALIDATOR_PORT_RANGE;
103+
#[cfg(debug_assertions)]
104+
let port_range = localhost_port_range_for_tests();
104105
Self {
105-
gossip_addr: socketaddr!(Ipv4Addr::LOCALHOST, 0),
106+
gossip_addr: socketaddr!(Ipv4Addr::LOCALHOST, port_range.0),
106107
port_range,
107108
bind_ip_addr,
108109
}

0 commit comments

Comments
 (0)