use super::super::{DhtEngine, DhtEngineConfig};
use crate::bittorrent::dht::message::{DhtMessage, DhtMessageBuilder};
use crate::bittorrent::dht::node::DhtNode;
use crate::bittorrent::dht::persistence::DhtPersistence;
use crate::bittorrent::dht::task::DhtTask;
use crate::bittorrent::dht::task_impl::PingTask;
use std::net::SocketAddr;
use std::sync::Arc;
use std::time::Duration;
use tokio::net::UdpSocket;
#[tokio::test]
async fn get_peers_replaces_a_node_whose_id_changed_at_the_same_endpoint() {
const INFO_HASH: [u8; 20] = [0x34; 20];
let old_node_id = [0xA5; 20];
let new_node_id = [0xB6; 20];
let latest_node_id = [0xC7; 20];
let peer: std::net::SocketAddr = "127.0.0.1:6882".parse().unwrap();
let responder = Arc::new(
UdpSocket::bind("127.0.0.1:0")
.await
.expect("local UDP responder should bind"),
);
let responder_addr = responder.local_addr().expect("responder address");
let responder_task = tokio::spawn(async move {
let mut buf = [0u8; 4096];
let mut get_peers_responses = 0;
while get_peers_responses < 2 {
let (len, from) =
tokio::time::timeout(Duration::from_secs(2), responder.recv_from(&mut buf))
.await
.expect("engine should send its DHT queries")
.expect("local responder should receive UDP packet");
let query = DhtMessage::decode(&buf[..len]).expect("valid KRPC query");
assert!(query.is_query());
let response = match query.q.as_ref().map(|method| method.0.as_str()) {
Some("ping") => DhtMessageBuilder::ping_response(&query.t, &old_node_id),
Some("find_node") => {
DhtMessageBuilder::find_node_response(&query.t, &latest_node_id, &[])
}
Some("get_peers") => {
let args = query.a.as_ref().expect("get_peers query arguments");
assert_eq!(
args.dict_get(b"info_hash").and_then(|v| v.as_bytes()),
Some(&INFO_HASH[..])
);
let response_node_id = if get_peers_responses == 0 {
new_node_id
} else {
latest_node_id
};
get_peers_responses += 1;
DhtMessageBuilder::get_peers_response_with_peers(
&query.t,
&response_node_id,
b"fixture-token",
&[peer],
)
}
method => panic!("unexpected DHT query: {method:?}"),
};
let encoded = response.encode();
responder
.send_to(&encoded, from)
.await
.expect("send DHT response");
}
});
let engine = DhtEngine::start(DhtEngineConfig {
query_timeout: Duration::from_millis(500),
..DhtEngineConfig::local()
})
.await
.expect("DHT engine should start");
engine.add_node(responder_addr).await;
let result = engine
.find_peers(&INFO_HASH)
.await
.expect("get_peers lookup should complete");
assert_eq!(result.peers, vec![peer]);
assert_eq!(result.nodes_contacted, 1);
let lookup = crate::bittorrent::dht::lookup::iterative_get_peers(
&INFO_HASH,
&engine.context.task_context.self_id,
&engine.context.task_context.routing_table,
&engine.context.task_context.socket,
&engine.context.task_context.tracker,
Duration::from_millis(500),
)
.await;
assert_eq!(lookup.peers, vec![peer]);
assert_eq!(lookup.nodes_contacted, 1);
assert_eq!(lookup.token_nodes.len(), 1);
assert_eq!(lookup.token_nodes[0].0, responder_addr);
assert_eq!(lookup.token_nodes[0].1, latest_node_id);
assert_eq!(lookup.token_nodes[0].2, b"fixture-token");
let routing_table = engine.context.task_context.routing_table.read().await;
let nodes = routing_table
.get_all_buckets()
.into_iter()
.flat_map(|bucket| bucket.nodes().iter())
.collect::<Vec<_>>();
assert!(
nodes.iter().all(|node| node.id() != &old_node_id),
"the superseded node ID must be removed after a valid response from the same endpoint"
);
assert!(
nodes.iter().all(|node| node.id() != &new_node_id),
"an intermediate node ID must be replaced when the endpoint changes identity again"
);
assert!(
nodes
.iter()
.any(|node| node.id() == &latest_node_id && node.is_good()),
"the responding node ID must replace the stale identity as a live good node"
);
drop(routing_table);
engine.shutdown_async().await;
responder_task.await.expect("responder task should finish");
}
#[tokio::test]
async fn replacement_ping_persists_the_responding_node_identity() {
const SELF_ID: [u8; 20] = [0xFF; 20];
const CACHED_REPLACEMENT_ID: [u8; 20] = [0x42; 20];
const RESPONDING_NODE_ID: [u8; 20] = [0xC2; 20];
let temp_dir = tempfile::tempdir_in(std::env::current_dir().unwrap())
.expect("DHT snapshot directory should be created in the workspace");
let snapshot_path = temp_dir.path().join("dht.dat");
let old_node = UdpSocket::bind("127.0.0.1:0")
.await
.expect("old DHT node socket should bind");
let old_node_addr = old_node.local_addr().expect("old DHT node address");
let replacement_node = UdpSocket::bind("127.0.0.1:0")
.await
.expect("replacement DHT node socket should bind");
let replacement_node_addr = replacement_node
.local_addr()
.expect("replacement DHT node address");
let mut persisted_nodes = (1..=8u8)
.map(|id| {
let addr = if id == 1 {
old_node_addr
} else {
format!("127.0.0.1:{}", 6000 + u16::from(id))
.parse()
.expect("fixture routing endpoint should parse")
};
DhtNode::new([id; 20], addr)
})
.collect::<Vec<_>>();
DhtPersistence::save_to_file_sync(&snapshot_path, &SELF_ID, &persisted_nodes)
.expect("initial DHT routing snapshot should be saved");
persisted_nodes.clear();
let old_node_task = tokio::spawn(async move {
let mut packet = [0u8; 1024];
let (length, source) =
tokio::time::timeout(Duration::from_secs(2), old_node.recv_from(&mut packet))
.await
.expect("replacement maintenance should ping the questionable node")
.expect("old node should receive UDP");
let query = DhtMessage::decode(&packet[..length]).expect("valid replacement ping");
assert_eq!(
query.q.as_ref().map(|method| method.0.as_str()),
Some("ping")
);
let response = DhtMessageBuilder::ping_response(&query.t, &RESPONDING_NODE_ID);
old_node
.send_to(&response.encode(), source)
.await
.expect("send replacement ping response");
});
let replacement_node_task = tokio::spawn(async move {
let mut packet = [0u8; 1024];
let (length, source) = tokio::time::timeout(
Duration::from_secs(2),
replacement_node.recv_from(&mut packet),
)
.await
.expect("engine should verify the cached replacement candidate")
.expect("replacement node should receive UDP");
let query = DhtMessage::decode(&packet[..length]).expect("valid candidate ping");
assert_eq!(
query.q.as_ref().map(|method| method.0.as_str()),
Some("ping")
);
let response = DhtMessageBuilder::ping_response(&query.t, &CACHED_REPLACEMENT_ID);
replacement_node
.send_to(&response.encode(), source)
.await
.expect("send candidate ping response");
});
let engine = DhtEngine::start(DhtEngineConfig {
self_id: SELF_ID,
dht_file_path: Some(snapshot_path.clone()),
query_timeout: Duration::from_millis(300),
node_contact_interval: Duration::from_secs(3600),
refresh_check_interval: Duration::from_secs(3600),
cleanup_interval: Duration::from_secs(3600),
save_interval: Duration::from_secs(3600),
..DhtEngineConfig::local()
})
.await
.expect("DHT engine should load the persisted routing table");
engine.add_node(replacement_node_addr).await;
assert_eq!(engine.stats().await.cached_nodes, 1);
let (_, replacement_attempts) = engine.evict_nodes().await;
assert_eq!(replacement_attempts, 1);
old_node_task
.await
.expect("old-node response task should finish");
replacement_node_task
.await
.expect("replacement-node response task should finish");
engine
.save_state()
.await
.expect("updated routing table should be persisted");
let saved = DhtPersistence::load_from_file_sync(&snapshot_path)
.expect("updated routing snapshot should be readable");
assert!(
saved
.nodes
.iter()
.any(|node| { node.id == RESPONDING_NODE_ID && node.addr == old_node_addr }),
"the verified identity returned by the replacement ping must be persisted at its source endpoint: {:?}",
saved.nodes
);
assert!(
saved.nodes.iter().all(|node| node.id != [1; 20]),
"the superseded node identity must not remain in the live routing snapshot: {:?}",
saved.nodes
);
engine.shutdown_async().await;
}
#[tokio::test]
async fn nodes_contacted_counts_sent_queries_even_when_nodes_do_not_reply() {
const INFO_HASH: [u8; 20] = [0x42; 20];
let silent_peer = UdpSocket::bind("127.0.0.1:0")
.await
.expect("silent DHT peer should bind");
let silent_peer_addr = silent_peer.local_addr().expect("silent peer address");
let engine = DhtEngine::start(DhtEngineConfig {
query_timeout: Duration::from_millis(40),
..DhtEngineConfig::local()
})
.await
.expect("DHT engine should start");
engine
.context
.task_context
.routing_table
.write()
.await
.insert(DhtNode::unverified([0xE1; 20], silent_peer_addr));
let lookup_engine = Arc::clone(&engine);
let lookup = tokio::spawn(async move { lookup_engine.find_peers(&INFO_HASH).await });
let mut packet = [0u8; 1024];
let (packet_len, _) =
tokio::time::timeout(Duration::from_secs(1), silent_peer.recv_from(&mut packet))
.await
.expect("lookup should send a query to the silent node")
.expect("silent peer should receive the UDP query");
let query = DhtMessage::decode(&packet[..packet_len]).expect("valid DHT query");
assert!(query.is_query());
let result = lookup
.await
.expect("lookup task should finish")
.expect("lookup should return an empty result after timeout");
assert!(result.peers.is_empty());
assert_eq!(result.nodes_contacted, 1);
engine.shutdown_async().await;
}
#[tokio::test]
async fn nodes_contacted_excludes_queries_rejected_by_the_udp_socket() {
const INFO_HASH: [u8; 20] = [0x43; 20];
let engine = DhtEngine::start(DhtEngineConfig {
listen_addr: Some(std::net::Ipv4Addr::LOCALHOST.into()),
..DhtEngineConfig::local()
})
.await
.expect("DHT engine should start with an IPv4 socket");
let ipv6_peer_addr: SocketAddr = "[::1]:6881".parse().expect("IPv6 peer address");
engine
.context
.task_context
.routing_table
.write()
.await
.insert(DhtNode::unverified([0xE2; 20], ipv6_peer_addr));
let result = engine
.find_peers(&INFO_HASH)
.await
.expect("a local send failure should complete the lookup");
assert_eq!(result.nodes_contacted, 0);
engine.shutdown_async().await;
}
#[tokio::test]
async fn peer_lookup_can_announce_with_the_token_from_that_same_lookup() {
const INFO_HASH: [u8; 20] = [0x39; 20];
const ANNOUNCE_PORT: u16 = 51413;
let node_id = [0xD7; 20];
let peer: SocketAddr = "127.0.0.1:6882".parse().unwrap();
let responder = Arc::new(
UdpSocket::bind("127.0.0.1:0")
.await
.expect("local UDP responder should bind"),
);
let responder_addr = responder.local_addr().expect("responder address");
let responder_task = tokio::spawn(async move {
let mut buf = [0u8; 4096];
let mut get_peers_count = 0;
loop {
let (len, from) =
tokio::time::timeout(Duration::from_secs(2), responder.recv_from(&mut buf))
.await
.expect("combined peer lookup should finish its wire exchange")
.expect("local responder should receive UDP packet");
let query = DhtMessage::decode(&buf[..len]).expect("valid KRPC query");
assert!(query.is_query());
let (response, announced) = match query.q.as_ref().map(|method| method.0.as_str()) {
Some("ping") => (DhtMessageBuilder::ping_response(&query.t, &node_id), false),
Some("find_node") => (
DhtMessageBuilder::find_node_response(&query.t, &node_id, &[]),
false,
),
Some("get_peers") => {
get_peers_count += 1;
let args = query.a.as_ref().expect("get_peers query arguments");
assert_eq!(
args.dict_get(b"info_hash")
.and_then(|value| value.as_bytes()),
Some(&INFO_HASH[..])
);
(
DhtMessageBuilder::get_peers_response_with_peers(
&query.t,
&node_id,
b"fixture-token",
&[peer],
),
false,
)
}
Some("announce_peer") => {
assert_eq!(get_peers_count, 1, "announce should reuse one lookup");
let args = query.a.as_ref().expect("announce_peer query arguments");
assert_eq!(
args.dict_get(b"info_hash")
.and_then(|value| value.as_bytes()),
Some(&INFO_HASH[..])
);
assert_eq!(
args.dict_get(b"token").and_then(|value| value.as_bytes()),
Some(&b"fixture-token"[..])
);
assert_eq!(
args.dict_get(b"port").and_then(|value| value.as_int()),
Some(i64::from(ANNOUNCE_PORT))
);
(
DhtMessageBuilder::announce_peer_response(&query.t, &node_id),
true,
)
}
method => panic!("unexpected DHT query: {method:?}"),
};
let encoded = response.encode();
responder
.send_to(&encoded, from)
.await
.expect("send DHT response");
if announced {
break;
}
}
});
let engine = DhtEngine::start(DhtEngineConfig {
query_timeout: Duration::from_millis(500),
..DhtEngineConfig::local()
})
.await
.expect("DHT engine should start");
engine.add_node(responder_addr).await;
let result = engine
.find_peers_and_announce(&INFO_HASH, ANNOUNCE_PORT)
.await
.expect("combined DHT lookup and announce should succeed");
assert_eq!(result.peers, vec![peer]);
assert_eq!(result.nodes_contacted, 1);
responder_task.await.expect("responder task should finish");
engine.shutdown_async().await;
}
#[tokio::test]
async fn ping_timeouts_are_counted_once_and_promote_cached_nodes_at_threshold() {
const QUERY_TIMEOUT: Duration = Duration::from_millis(20);
let unreachable_peer = UdpSocket::bind("127.0.0.1:0")
.await
.expect("loopback DHT peer should bind");
let unreachable_addr = unreachable_peer.local_addr().expect("peer address");
let engine = DhtEngine::start(DhtEngineConfig {
self_id: [0xFF; 20],
query_timeout: QUERY_TIMEOUT,
refresh_check_interval: Duration::from_secs(3_600),
node_contact_interval: Duration::from_secs(3_600),
cleanup_interval: Duration::from_secs(3_600),
save_interval: Duration::from_secs(3_600),
token_rotation_interval: Duration::from_secs(3_600),
..DhtEngineConfig::local()
})
.await
.expect("local DHT engine should start");
let failed_node_id = [1; 20];
{
let mut table = engine.context.task_context.routing_table.write().await;
for i in 1..=8u8 {
let addr = if i == 1 {
unreachable_addr
} else {
format!("127.0.0.1:{}", 7_000 + u16::from(i))
.parse()
.expect("loopback peer address")
};
table.insert(DhtNode::new([i; 20], addr));
}
table.insert(DhtNode::new([0x40; 20], "127.0.0.1:6990".parse().unwrap()));
table.insert(DhtNode::new([0x41; 20], "127.0.0.1:6991".parse().unwrap()));
}
Box::new(PingTask::new(
engine.context.task_context.clone(),
DhtNode::new(failed_node_id, unreachable_addr),
3,
None,
))
.run()
.await;
let stats = engine.stats().await;
assert_eq!(stats.total_nodes, 8);
assert_eq!(stats.bad_nodes, 0);
assert_eq!(stats.cached_nodes, 2);
{
let table = engine.context.task_context.routing_table.read().await;
let node = table
.get_bucket_for(&failed_node_id)
.nodes()
.iter()
.find(|node| node.id() == &failed_node_id)
.expect("four consecutive timeouts must not evict the peer");
assert_eq!(node.failed_count(), 4);
}
Box::new(PingTask::new(
engine.context.task_context.clone(),
DhtNode::new(failed_node_id, unreachable_addr),
0,
None,
))
.run()
.await;
let stats = engine.stats().await;
assert_eq!(stats.total_nodes, 8);
assert_eq!(stats.bad_nodes, 0);
assert_eq!(stats.cached_nodes, 1);
engine.shutdown_async().await;
}
#[tokio::test]
async fn announce_peer_timeout_updates_routing_health_once() {
const QUERY_TIMEOUT: Duration = Duration::from_millis(20);
let unreachable_peer = UdpSocket::bind("127.0.0.1:0")
.await
.expect("local UDP peer should bind");
let unreachable_addr = unreachable_peer.local_addr().expect("peer address");
let engine = DhtEngine::start(DhtEngineConfig {
query_timeout: QUERY_TIMEOUT,
refresh_check_interval: Duration::from_secs(3_600),
node_contact_interval: Duration::from_secs(3_600),
cleanup_interval: Duration::from_secs(3_600),
save_interval: Duration::from_secs(3_600),
token_rotation_interval: Duration::from_secs(3_600),
..DhtEngineConfig::local()
})
.await
.expect("local DHT engine should start");
let node_id = [0x07; 20];
{
let mut table = engine.context.task_context.routing_table.write().await;
table.insert(DhtNode::new(node_id, unreachable_addr));
for _ in 0..3 {
assert!(table.mark_bad(&node_id));
}
}
let token_nodes = [(unreachable_addr, node_id, vec![1, 2, 3])];
let sent_queries = crate::bittorrent::dht::lookup::announce_to_token_nodes(
&[0x22; 20],
&engine.context.task_context.self_id,
6881,
&token_nodes,
&engine.context.task_context.socket,
&engine.context.task_context.tracker,
engine.context.task_context.query_timeout,
)
.await;
assert_eq!(
sent_queries, 1,
"the public count records successful UDP sends"
);
crate::bittorrent::dht::lookup::announce_to_token_nodes_and_update_routing_table(
&[0x22; 20],
6881,
&token_nodes,
&engine.context.task_context,
)
.await;
let table = engine.context.task_context.routing_table.read().await;
let node = table
.get_bucket_for(&node_id)
.nodes()
.iter()
.find(|node| node.id() == &node_id)
.expect("four failures must not evict the node");
assert_eq!(node.failed_count(), 4);
drop(table);
engine.shutdown_async().await;
}