use std::net::SocketAddr;
use std::sync::Arc;
use tracing::{debug, info, trace, warn};
use super::lookup::{announce_to_token_nodes, iterative_get_peers};
use super::message::DhtMessageBuilder;
use super::node::DhtNode;
use super::task::BoxedDhtTask;
use super::task::DhtTask;
use super::task_impl::{BucketRefreshTask, DhtTaskContext, NodeLookupTask, PingTask};
#[derive(Debug)]
pub struct PeerLookupTask {
ctx: DhtTaskContext,
info_hash: [u8; 20],
announce_port: u16,
result_tx: Option<tokio::sync::oneshot::Sender<PeerLookupResult>>,
}
#[derive(Debug, Clone)]
pub struct PeerLookupResult {
pub peers: Vec<SocketAddr>,
pub nodes_contacted: usize,
}
impl PeerLookupTask {
pub fn new(
ctx: DhtTaskContext,
info_hash: [u8; 20],
announce_port: u16,
result_tx: Option<tokio::sync::oneshot::Sender<PeerLookupResult>>,
) -> Self {
Self {
ctx,
info_hash,
announce_port,
result_tx,
}
}
}
#[async_trait::async_trait]
impl DhtTask for PeerLookupTask {
async fn run(self: Box<Self>) {
let rt = Arc::clone(&self.ctx.routing_table);
let result = iterative_get_peers(
&self.info_hash,
&self.ctx.self_id,
&rt,
&self.ctx.socket,
&self.ctx.tracker,
)
.await;
{
let discovered_rt = rt.read().await;
let mut main_rt = self.ctx.routing_table.write().await;
for node in discovered_rt.all_nodes() {
main_rt.insert(node.clone());
}
}
if self.announce_port > 0 && !result.token_nodes.is_empty() {
announce_to_token_nodes(
&self.info_hash,
&self.ctx.self_id,
self.announce_port,
&result.token_nodes,
&self.ctx.socket,
&self.ctx.tracker,
)
.await;
}
debug!(
info_hash = %hex::encode(self.info_hash),
peers = result.peers.len(),
contacted = result.nodes_contacted,
"PeerLookupTask completed"
);
if let Some(tx) = self.result_tx {
let _ = tx.send(PeerLookupResult {
peers: result.peers,
nodes_contacted: result.nodes_contacted,
});
}
}
fn name(&self) -> &'static str {
"PeerLookupTask"
}
}
#[derive(Debug)]
pub struct ReplaceNodeTask {
ctx: DhtTaskContext,
bucket_prefix_length: usize,
new_node: DhtNode,
}
impl ReplaceNodeTask {
pub fn new(ctx: DhtTaskContext, bucket_prefix_length: usize, new_node: DhtNode) -> Self {
Self {
ctx,
bucket_prefix_length,
new_node,
}
}
}
#[async_trait::async_trait]
impl DhtTask for ReplaceNodeTask {
async fn run(self: Box<Self>) {
let (q_id, q_addr) = {
let rt = self.ctx.routing_table.read().await;
let buckets = rt.get_all_buckets();
let bucket = buckets
.iter()
.find(|b| b.prefix_length() == self.bucket_prefix_length);
match bucket {
Some(b) => match b.get_lru_questionable_node() {
Some(node) => (node.id, node.addr),
None => {
trace!(
"ReplaceNodeTask: no questionable node in bucket prefix={}",
self.bucket_prefix_length
);
return;
}
},
None => {
trace!(
"ReplaceNodeTask: bucket not found prefix={}",
self.bucket_prefix_length
);
return;
}
}
};
for attempt in 0..2 {
let msg = DhtMessageBuilder::ping(0, &self.ctx.self_id);
let encoded = match msg.encode() {
Ok(e) => e,
Err(e) => {
warn!("ReplaceNodeTask: encode error: {}", e);
return;
}
};
if let Err(e) = self.ctx.socket.send_to(q_addr, &encoded).await {
debug!(
"ReplaceNodeTask: send error to {}: {}",
hex::encode(q_id),
e
);
return;
}
let mut buf = [0u8; 4096];
match self
.ctx
.socket
.recv_with_timeout(&mut buf, self.ctx.query_timeout)
.await
{
Ok((len, _from)) if len > 0 => {
if let Ok(response) = super::message::DhtMessage::decode(&buf[..len])
&& response.is_response()
{
info!(
"ReplaceNodeTask: ping reply received from {} — node is alive",
hex::encode(q_id)
);
let mut rt = self.ctx.routing_table.write().await;
rt.mark_good(&q_id);
return;
}
}
_ => {
if attempt < 1 {
debug!(
"ReplaceNodeTask: ping timeout from {}, retrying",
hex::encode(q_id)
);
}
}
}
}
info!(
"ReplaceNodeTask: replacing {} with {}",
hex::encode(q_id),
self.new_node.id_hex(),
);
let mut rt = self.ctx.routing_table.write().await;
rt.mark_bad(&q_id);
rt.insert(self.new_node.clone());
}
fn name(&self) -> &'static str {
"ReplaceNodeTask"
}
}
#[derive(Debug)]
pub struct PeerAnnounceTask {
ctx: DhtTaskContext,
info_hash: [u8; 20],
port: u16,
}
impl PeerAnnounceTask {
pub fn new(ctx: DhtTaskContext, info_hash: [u8; 20], port: u16) -> Self {
Self {
ctx,
info_hash,
port,
}
}
}
#[async_trait::async_trait]
impl DhtTask for PeerAnnounceTask {
async fn run(self: Box<Self>) {
debug!(
info_hash = %hex::encode(self.info_hash),
port = self.port,
"PeerAnnounceTask: starting get_peers lookup"
);
let rt = Arc::clone(&self.ctx.routing_table);
let result = iterative_get_peers(
&self.info_hash,
&self.ctx.self_id,
&rt,
&self.ctx.socket,
&self.ctx.tracker,
)
.await;
{
let discovered_rt = rt.read().await;
let mut main_rt = self.ctx.routing_table.write().await;
for node in discovered_rt.all_nodes() {
main_rt.insert(node.clone());
}
}
if result.token_nodes.is_empty() {
debug!(
info_hash = %hex::encode(self.info_hash),
"PeerAnnounceTask: no token nodes found, cannot announce"
);
return;
}
let announced = announce_to_token_nodes(
&self.info_hash,
&self.ctx.self_id,
self.port,
&result.token_nodes,
&self.ctx.socket,
&self.ctx.tracker,
)
.await;
info!(
info_hash = %hex::encode(self.info_hash),
announced,
"PeerAnnounceTask completed"
);
}
fn name(&self) -> &'static str {
"PeerAnnounceTask"
}
}
#[derive(Clone)]
pub struct DhtTaskFactory {
ctx: DhtTaskContext,
}
impl DhtTaskFactory {
pub fn new(ctx: DhtTaskContext) -> Self {
Self { ctx }
}
pub fn create_ping_task(&self, remote_node: DhtNode, max_retry: u32) -> BoxedDhtTask {
Box::new(PingTask::new(self.ctx.clone(), remote_node, max_retry))
}
pub fn create_bucket_refresh_task(&self, force_refresh: bool) -> BoxedDhtTask {
Box::new(BucketRefreshTask::new(self.ctx.clone(), force_refresh))
}
pub fn create_node_lookup_task(&self, target_id: [u8; 20]) -> BoxedDhtTask {
Box::new(NodeLookupTask::new(self.ctx.clone(), target_id))
}
pub fn create_peer_lookup_task(
&self,
info_hash: [u8; 20],
announce_port: u16,
result_tx: Option<tokio::sync::oneshot::Sender<PeerLookupResult>>,
) -> BoxedDhtTask {
Box::new(PeerLookupTask::new(
self.ctx.clone(),
info_hash,
announce_port,
result_tx,
))
}
pub fn create_replace_node_task(
&self,
bucket_prefix_length: usize,
new_node: DhtNode,
) -> BoxedDhtTask {
Box::new(ReplaceNodeTask::new(
self.ctx.clone(),
bucket_prefix_length,
new_node,
))
}
pub fn create_peer_announce_task(&self, info_hash: [u8; 20], port: u16) -> BoxedDhtTask {
Box::new(PeerAnnounceTask::new(self.ctx.clone(), info_hash, port))
}
}
#[cfg(test)]
mod tests {
use super::super::routing_table::RoutingTable;
use super::super::socket::DhtSocket;
use super::super::tracker::TransactionTracker;
use super::*;
use std::time::Duration;
use tokio::sync::RwLock;
#[test]
fn test_task_factory_creation() {
let ctx = DhtTaskContext {
self_id: [0u8; 20],
routing_table: Arc::new(RwLock::new(RoutingTable::new([0u8; 20]))),
socket: DhtSocket::new_test(),
tracker: Arc::new(TransactionTracker::new()),
query_timeout: Duration::from_secs(10),
};
let factory = DhtTaskFactory::new(ctx);
let _ping = factory.create_ping_task(
DhtNode::new([1u8; 20], "127.0.0.1:6881".parse().unwrap()),
0,
);
let _refresh = factory.create_bucket_refresh_task(false);
let _lookup = factory.create_node_lookup_task([2u8; 20]);
let _announce = factory.create_peer_announce_task([3u8; 20], 6881);
}
#[test]
fn test_peer_lookup_result() {
let result = PeerLookupResult {
peers: vec!["127.0.0.1:6881".parse().unwrap()],
nodes_contacted: 5,
};
assert_eq!(result.peers.len(), 1);
assert_eq!(result.nodes_contacted, 5);
}
}