jleony/nanoreth
1
0
Fork 0
mirror of https://github.com/hl-archive-node/nanoreth.git synced 2025-12-06 10:59:55 +00:00
Code Issues Packages Projects Releases Wiki Activity

feat: support DNS in reth.toml for trusted_nodes (#9864)

Browse Source
This commit is contained in:
Luca Provini
2024-07-31 14:20:19 +02:00
committed by GitHub
parent f9ed57d6a6
commit fcbdbf361b
11 changed files with 83 additions and 53 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
crates/net/network/Cargo.toml
View File

@ -91,6 +91,7 @@ alloy-provider= { workspace = true, features = ["admin-api"] }
# misc
serial_test.workspace = true
tempfile.workspace = true
url.workspace = true
## Benchmarks
pprof = { workspace = true, features = ["criterion", "flamegraph"] }

47
crates/net/network/src/peers.rs
View File

@ -34,7 +34,7 @@ use tokio::{
time::{Instant, Interval},
};
use tokio_stream::wrappers::UnboundedReceiverStream;
use tracing::trace;
use tracing::{trace, warn};
/// A communication channel to the [`PeersManager`] to apply manual changes to the peer set.
#[derive(Clone, Debug)]
@ -155,11 +155,18 @@ impl PeersManager {
let mut peers = HashMap::with_capacity(trusted_nodes.len() + basic_nodes.len());
let mut trusted_peer_ids = HashSet::with_capacity(trusted_nodes.len());
for NodeRecord { address, tcp_port, udp_port, id } in trusted_nodes {
trusted_peer_ids.insert(id);
peers.entry(id).or_insert_with(|| {
Peer::trusted(PeerAddr::new_with_ports(address, tcp_port, Some(udp_port)))
});
for trusted_peer in trusted_nodes {
match trusted_peer.resolve_blocking() {
Ok(NodeRecord { address, tcp_port, udp_port, id }) => {
trusted_peer_ids.insert(id);
peers.entry(id).or_insert_with(|| {
Peer::trusted(PeerAddr::new_with_ports(address, tcp_port, Some(udp_port)))
});
}
Err(err) => {
warn!(target: "net::peers", ?err, "Failed to resolve trusted peer");
}
}
}
for NodeRecord { address, tcp_port, udp_port, id } in basic_nodes {
@ -1328,14 +1335,13 @@ mod tests {
session::PendingSessionHandshakeError,
PeersConfig,
};
use reth_discv4::NodeRecord;
use reth_eth_wire::{
errors::{EthHandshakeError, EthStreamError, P2PHandshakeError, P2PStreamError},
DisconnectReason,
};
use reth_net_banlist::BanList;
use reth_network_api::{Direction, ReputationChangeKind};
use reth_network_peers::PeerId;
use reth_network_peers::{PeerId, TrustedPeer};
use reth_network_types::{peers::reputation::DEFAULT_REPUTATION, BackoffKind};
use reth_primitives::B512;
use std::{
@ -1347,6 +1353,7 @@ mod tests {
task::{Context, Poll},
time::Duration,
};
use url::Host;
struct PeerActionFuture<'a> {
peers: &'a mut PeersManager,
@ -2290,12 +2297,12 @@ mod tests {
async fn test_trusted_peers_are_prioritized() {
let trusted_peer = PeerId::random();
let trusted_sock = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 1, 2)), 8008);
let config = PeersConfig::test().with_trusted_nodes(HashSet::from([NodeRecord {
address: IpAddr::V4(Ipv4Addr::new(127, 0, 1, 2)),
let config = PeersConfig::test().with_trusted_nodes(vec![TrustedPeer {
host: Host::Ipv4(Ipv4Addr::new(127, 0, 1, 2)),
tcp_port: 8008,
udp_port: 8008,
id: trusted_peer,
}]));
}]);
let mut peers = PeersManager::new(config);
let basic_peer = PeerId::random();
@ -2329,12 +2336,12 @@ mod tests {
let trusted_peer = PeerId::random();
let trusted_sock = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 1, 2)), 8008);
let config = PeersConfig::test()
.with_trusted_nodes(HashSet::from([NodeRecord {
address: IpAddr::V4(Ipv4Addr::new(127, 0, 1, 2)),
.with_trusted_nodes(vec![TrustedPeer {
host: Host::Ipv4(Ipv4Addr::new(127, 0, 1, 2)),
tcp_port: 8008,
udp_port: 8008,
id: trusted_peer,
}]))
}])
.with_trusted_nodes_only(true);
let mut peers = PeersManager::new(config);
@ -2366,12 +2373,12 @@ mod tests {
async fn test_incoming_with_trusted_nodes_only() {
let trusted_peer = PeerId::random();
let config = PeersConfig::test()
.with_trusted_nodes(HashSet::from([NodeRecord {
address: IpAddr::V4(Ipv4Addr::new(127, 0, 1, 2)),
.with_trusted_nodes(vec![TrustedPeer {
host: Host::Ipv4(Ipv4Addr::new(127, 0, 1, 2)),
tcp_port: 8008,
udp_port: 8008,
id: trusted_peer,
}]))
}])
.with_trusted_nodes_only(true);
let mut peers = PeersManager::new(config);
@ -2399,12 +2406,12 @@ mod tests {
async fn test_incoming_without_trusted_nodes_only() {
let trusted_peer = PeerId::random();
let config = PeersConfig::test()
.with_trusted_nodes(HashSet::from([NodeRecord {
address: IpAddr::V4(Ipv4Addr::new(127, 0, 1, 2)),
.with_trusted_nodes(vec![TrustedPeer {
host: Host::Ipv4(Ipv4Addr::new(127, 0, 1, 2)),
tcp_port: 8008,
udp_port: 8008,
id: trusted_peer,
}]))
}])
.with_trusted_nodes_only(false);
let mut peers = PeersManager::new(config);

29
crates/net/network/tests/it/connect.rs
View File

@ -15,12 +15,13 @@ use reth_network_p2p::{
headers::client::{HeadersClient, HeadersRequest},
sync::{NetworkSyncUpdater, SyncState},
};
use reth_network_peers::{mainnet_nodes, NodeRecord};
use reth_network_peers::{mainnet_nodes, NodeRecord, TrustedPeer};
use reth_provider::test_utils::NoopProvider;
use reth_transaction_pool::test_utils::testing_pool;
use secp256k1::SecretKey;
use std::{collections::HashSet, net::SocketAddr, time::Duration};
use tokio::task;
use url::Host;
#[tokio::test(flavor = "multi_thread")]
async fn test_establish_connections() {
@ -594,13 +595,18 @@ async fn test_disconnect_incoming_when_exceeded_incoming_connections() {
#[tokio::test(flavor = "multi_thread")]
async fn test_always_accept_incoming_connections_from_trusted_peers() {
reth_tracing::init_test_tracing();
let peer1 = new_random_peer(10, HashSet::new()).await;
let peer2 = new_random_peer(0, HashSet::new()).await;
let peer1 = new_random_peer(10, vec![]).await;
let peer2 = new_random_peer(0, vec![]).await;
// setup the peer with max_inbound = 1, and add other_peer_3 as trust nodes
let peer =
new_random_peer(0, HashSet::from([NodeRecord::new(peer2.local_addr(), *peer2.peer_id())]))
.await;
let trusted_peer2 = TrustedPeer {
host: Host::Ipv4(peer2.local_addr().ip().to_string().parse().unwrap()),
tcp_port: peer2.local_addr().port(),
udp_port: peer2.local_addr().port(),
id: *peer2.peer_id(),
};
let peer = new_random_peer(0, vec![trusted_peer2.clone()]).await;
let handle = peer.handle().clone();
let peer1_handle = peer1.handle().clone();
@ -634,11 +640,11 @@ async fn test_always_accept_incoming_connections_from_trusted_peers() {
#[tokio::test(flavor = "multi_thread")]
async fn test_rejected_by_already_connect() {
reth_tracing::init_test_tracing();
let other_peer1 = new_random_peer(10, HashSet::new()).await;
let other_peer2 = new_random_peer(10, HashSet::new()).await;
let other_peer1 = new_random_peer(10, vec![]).await;
let other_peer2 = new_random_peer(10, vec![]).await;
// setup the peer with max_inbound = 2
let peer = new_random_peer(2, HashSet::new()).await;
let peer = new_random_peer(2, vec![]).await;
let handle = peer.handle().clone();
let other_peer_handle1 = other_peer1.handle().clone();
@ -671,10 +677,7 @@ async fn test_rejected_by_already_connect() {
assert_eq!(handle.num_connected_peers(), 2);
}
async fn new_random_peer(
max_in_bound: usize,
trusted_nodes: HashSet<NodeRecord>,
) -> NetworkManager {
async fn new_random_peer(max_in_bound: usize, trusted_nodes: Vec<TrustedPeer>) -> NetworkManager {
let secret_key = SecretKey::new(&mut rand::thread_rng());
let peers_config =
PeersConfig::default().with_max_inbound(max_in_bound).with_trusted_nodes(trusted_nodes);