use std::sync::Arc;
use std::time::Duration;
use tokio::sync::RwLock;
use tracing::{debug, info, trace, warn};
use super::lookup::iterative_find_node;
use super::message::DhtMessageBuilder;
use super::node::DhtNode;
use super::routing_table::RoutingTable;
use super::socket::DhtSocket;
use super::task::DhtTask;
use super::tracker::TransactionTracker;
#[derive(Clone)]
pub struct DhtTaskContext {
pub self_id: [u8; 20],
pub routing_table: Arc<RwLock<RoutingTable>>,
pub socket: DhtSocket,
pub tracker: Arc<TransactionTracker>,
pub query_timeout: Duration,
}
impl std::fmt::Debug for DhtTaskContext {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("DhtTaskContext")
.field("self_id", &hex::encode(self.self_id))
.field("query_timeout", &self.query_timeout)
.finish()
}
}
#[derive(Debug)]
pub struct PingTask {
ctx: DhtTaskContext,
remote_node: DhtNode,
max_retry: u32,
timeout: Duration,
}
impl PingTask {
pub fn new(ctx: DhtTaskContext, remote_node: DhtNode, max_retry: u32) -> Self {
Self {
timeout: ctx.query_timeout,
ctx,
remote_node,
max_retry,
}
}
}
#[async_trait::async_trait]
impl DhtTask for PingTask {
async fn run(self: Box<Self>) {
let addr = self.remote_node.addr;
let node_id = self.remote_node.id;
for attempt in 0..=self.max_retry {
if attempt > 0 {
debug!(
attempt,
max_retry = self.max_retry,
"PingTask retrying node {}",
hex::encode(node_id),
);
}
let msg = DhtMessageBuilder::ping(0, &self.ctx.self_id);
let encoded = match msg.encode() {
Ok(e) => e,
Err(e) => {
warn!("PingTask: encode error for {}: {}", hex::encode(node_id), e);
return;
}
};
if let Err(e) = self.ctx.socket.send_to(addr, &encoded).await {
debug!("PingTask: send error to {}: {}", hex::encode(node_id), e);
return;
}
let mut buf = [0u8; 4096];
match self
.ctx
.socket
.recv_with_timeout(&mut buf, self.timeout)
.await
{
Ok((len, _from)) if len > 0 => {
if let Ok(response) = super::message::DhtMessage::decode(&buf[..len])
&& response.is_response()
{
trace!("PingTask: node {} responded", hex::encode(node_id));
let mut rt = self.ctx.routing_table.write().await;
rt.mark_good(&node_id);
return;
}
}
_ => {
}
}
}
debug!(
"PingTask: node {} timed out after {} attempts",
hex::encode(node_id),
self.max_retry + 1
);
let mut rt = self.ctx.routing_table.write().await;
rt.mark_bad(&node_id);
}
fn name(&self) -> &'static str {
"PingTask"
}
}
#[derive(Debug)]
pub struct BucketRefreshTask {
ctx: DhtTaskContext,
force_refresh: bool,
}
impl BucketRefreshTask {
pub fn new(ctx: DhtTaskContext, force_refresh: bool) -> Self {
Self { ctx, force_refresh }
}
}
#[async_trait::async_trait]
impl DhtTask for BucketRefreshTask {
async fn run(self: Box<Self>) {
let targets = {
let rt = self.ctx.routing_table.read().await;
if self.force_refresh {
rt.get_all_buckets()
.iter()
.map(|b| b.get_random_node_id())
.collect::<Vec<_>>()
} else {
rt.refresh_buckets()
}
};
if targets.is_empty() {
trace!("BucketRefreshTask: no buckets need refresh");
return;
}
info!(count = targets.len(), "Dispatching bucket refresh lookups");
for target in targets {
let rt = Arc::clone(&self.ctx.routing_table);
let result = iterative_find_node(
&target,
&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());
}
}
trace!(
target = %hex::encode(target),
nodes_contacted = result.nodes_contacted,
"Bucket refresh lookup completed"
);
}
}
fn name(&self) -> &'static str {
"BucketRefreshTask"
}
}
#[derive(Debug)]
pub struct NodeLookupTask {
ctx: DhtTaskContext,
target_id: [u8; 20],
}
impl NodeLookupTask {
pub fn new(ctx: DhtTaskContext, target_id: [u8; 20]) -> Self {
Self { ctx, target_id }
}
}
#[async_trait::async_trait]
impl DhtTask for NodeLookupTask {
async fn run(self: Box<Self>) {
let rt = Arc::clone(&self.ctx.routing_table);
let result = iterative_find_node(
&self.target_id,
&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());
}
}
debug!(
target = %hex::encode(self.target_id),
closest = result.closest_nodes.len(),
contacted = result.nodes_contacted,
"NodeLookupTask completed"
);
}
fn name(&self) -> &'static str {
"NodeLookupTask"
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_task_context_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),
};
assert_eq!(ctx.self_id, [0u8; 20]);
}
}