use std::collections::HashMap;
use std::net::SocketAddr;
use std::time::{Duration, Instant};
use tracing::{debug, trace};
use super::message::DhtMessage;
const QUERY_TIMEOUT: Duration = Duration::from_secs(10);
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum QueryType {
Ping,
FindNode,
GetPeers,
AnnouncePeer,
}
#[derive(Debug)]
pub struct TrackedResponse {
pub message: DhtMessage,
pub from: SocketAddr,
pub rtt: Duration,
}
struct PendingTransaction {
query_type: QueryType,
target_addr: SocketAddr,
target_id: Option<[u8; 20]>,
#[allow(dead_code)]
info_hash: Option<[u8; 20]>,
#[allow(dead_code)]
token: Option<Vec<u8>>,
response_tx: Option<tokio::sync::oneshot::Sender<TrackedResponse>>,
created_at: Instant,
timeout: Duration,
}
pub struct TransactionTracker {
inner: std::sync::Mutex<TransactionTrackerInner>,
}
struct TransactionTrackerInner {
transactions: HashMap<Vec<u8>, PendingTransaction>,
next_tx_id: u32,
}
impl TransactionTracker {
pub fn new() -> Self {
Self {
inner: std::sync::Mutex::new(TransactionTrackerInner {
transactions: HashMap::new(),
next_tx_id: 1,
}),
}
}
pub fn allocate(
&self,
query_type: QueryType,
target_addr: SocketAddr,
target_id: Option<[u8; 20]>,
info_hash: Option<[u8; 20]>,
timeout: Duration,
) -> (Vec<u8>, tokio::sync::oneshot::Receiver<TrackedResponse>) {
let mut inner = self
.inner
.lock()
.expect("TransactionTracker mutex poisoned");
let tx_id = inner.next_tx_id;
inner.next_tx_id = inner.next_tx_id.wrapping_add(1);
let key = tx_id.to_be_bytes().to_vec();
let (response_tx, response_rx) = tokio::sync::oneshot::channel();
inner.transactions.insert(
key.clone(),
PendingTransaction {
query_type,
target_addr,
target_id,
info_hash,
token: None,
response_tx: Some(response_tx),
created_at: Instant::now(),
timeout,
},
);
(key, response_rx)
}
pub fn handle_response(&self, tx_id: &[u8], response: DhtMessage, from: SocketAddr) -> bool {
let mut inner = self
.inner
.lock()
.expect("TransactionTracker mutex poisoned");
if let Some(mut pending) = inner.transactions.remove(tx_id) {
let rtt = pending.created_at.elapsed();
trace!(
tx_id = %hex::encode(tx_id),
query_type = ?pending.query_type,
rtt_ms = rtt.as_millis(),
"Matched DHT response to pending transaction"
);
if let Some(tx) = pending.response_tx.take() {
let _ = tx.send(TrackedResponse {
message: response,
from,
rtt,
});
}
true
} else {
debug!(
tx_id = %hex::encode(tx_id),
from = %from,
"Received DHT response for unknown transaction"
);
false
}
}
pub fn store_token_for_node(
&self,
node_addr: &SocketAddr,
info_hash: &[u8; 20],
token: Vec<u8>,
) {
let _ = (node_addr, info_hash, token);
}
pub fn handle_timeouts(&self) -> Vec<(SocketAddr, QueryType, Option<[u8; 20]>)> {
let mut inner = self
.inner
.lock()
.expect("TransactionTracker mutex poisoned");
let now = Instant::now();
let mut timed_out = Vec::new();
inner.transactions.retain(|tx_id, pending| {
if now.duration_since(pending.created_at) >= pending.timeout {
debug!(
tx_id = %hex::encode(tx_id),
query_type = ?pending.query_type,
target = %pending.target_addr,
"DHT transaction timed out"
);
timed_out.push((pending.target_addr, pending.query_type, pending.target_id));
false
} else {
true
}
});
timed_out
}
pub fn pending_count(&self) -> usize {
let inner = self
.inner
.lock()
.expect("TransactionTracker mutex poisoned");
inner.transactions.len()
}
pub fn cleanup_expired(&self) -> usize {
let mut inner = self
.inner
.lock()
.expect("TransactionTracker mutex poisoned");
let now = Instant::now();
let max_age = QUERY_TIMEOUT * 3;
let before = inner.transactions.len();
inner
.transactions
.retain(|_, pending| now.duration_since(pending.created_at) < max_age);
before - inner.transactions.len()
}
}
impl Default for TransactionTracker {
fn default() -> Self {
Self::new()
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::bittorrent::dht::message::DhtMessageBuilder;
#[test]
fn test_allocate_and_match() {
let tracker = TransactionTracker::new();
let addr: SocketAddr = "10.0.0.1:6881".parse().unwrap();
let (tx_id, mut rx) =
tracker.allocate(QueryType::Ping, addr, None, None, Duration::from_secs(10));
assert_eq!(tracker.pending_count(), 1);
let response = DhtMessageBuilder::ping_response(&tx_id, &[0xAAu8; 20]);
assert!(tracker.handle_response(&tx_id, response, addr));
assert_eq!(tracker.pending_count(), 0);
let tracked = rx.try_recv().unwrap();
assert!(tracked.message.is_response());
}
#[test]
fn test_unknown_transaction_ignored() {
let tracker = TransactionTracker::new();
let response = DhtMessageBuilder::ping_response(&[0, 0, 0, 99], &[0u8; 20]);
assert!(!tracker.handle_response(
&[0, 0, 0, 99],
response,
"10.0.0.1:6881".parse().unwrap()
));
}
#[test]
fn test_handle_timeouts() {
let tracker = TransactionTracker::new();
let addr: SocketAddr = "10.0.0.2:6881".parse().unwrap();
let (_tx_id, _rx) = tracker.allocate(
QueryType::FindNode,
addr,
Some([1u8; 20]),
None,
Duration::ZERO,
);
std::thread::sleep(std::time::Duration::from_millis(1));
let timed_out = tracker.handle_timeouts();
assert_eq!(timed_out.len(), 1);
assert_eq!(timed_out[0].0, addr);
assert_eq!(timed_out[0].1, QueryType::FindNode);
assert_eq!(tracker.pending_count(), 0);
}
#[test]
fn test_unique_transaction_ids() {
let tracker = TransactionTracker::new();
let addr: SocketAddr = "10.0.0.3:6881".parse().unwrap();
let (id1, _) = tracker.allocate(QueryType::Ping, addr, None, None, QUERY_TIMEOUT);
let (id2, _) = tracker.allocate(QueryType::Ping, addr, None, None, QUERY_TIMEOUT);
assert_ne!(id1, id2);
}
#[tokio::test]
async fn test_oneshot_closed_on_timeout() {
let tracker = TransactionTracker::new();
let addr: SocketAddr = "10.0.0.4:6881".parse().unwrap();
let (_tx_id, mut rx) = tracker.allocate(
QueryType::GetPeers,
addr,
None,
Some([2u8; 20]),
Duration::ZERO,
);
std::thread::sleep(std::time::Duration::from_millis(1));
tracker.handle_timeouts();
use tokio::sync::oneshot::error::TryRecvError;
assert!(matches!(rx.try_recv(), Err(TryRecvError::Closed)));
}
}