use std::collections::VecDeque;
use std::net::SocketAddr;
use std::time::{Duration, Instant};
use tracing::{debug, trace, warn};
use super::constants::MESSAGE_TIMEOUT_SECS;
use super::node_id::NodeId;
pub struct TrackerEntry {
target_node_id: NodeId,
target_addr: SocketAddr,
transaction_id: Vec<u8>,
method: String,
dispatched_at: Instant,
timeout: Duration,
}
impl TrackerEntry {
pub fn new(
target_node_id: NodeId,
target_addr: SocketAddr,
transaction_id: Vec<u8>,
method: String,
timeout: Duration,
) -> Self {
Self {
target_node_id,
target_addr,
transaction_id,
method,
dispatched_at: Instant::now(),
timeout,
}
}
pub fn is_timeout(&self) -> bool {
self.dispatched_at.elapsed() >= self.timeout
}
pub fn extend_timeout(&mut self) {
self.dispatched_at = Instant::now();
}
pub fn matches(&self, transaction_id: &[u8], sender_addr: &SocketAddr) -> bool {
self.transaction_id == transaction_id && self.target_addr == *sender_addr
}
pub fn method(&self) -> &str {
&self.method
}
pub fn target_node_id(&self) -> &NodeId {
&self.target_node_id
}
pub fn target_addr(&self) -> SocketAddr {
self.target_addr
}
pub fn transaction_id(&self) -> &[u8] {
&self.transaction_id
}
pub fn elapsed(&self) -> Duration {
self.dispatched_at.elapsed()
}
}
pub struct MatchResult {
pub method: String,
pub target_node_id: NodeId,
pub target_addr: SocketAddr,
pub elapsed: Duration,
}
pub struct TimeoutEntry {
pub target_node_id: NodeId,
pub target_addr: SocketAddr,
pub method: String,
pub elapsed: Duration,
}
pub struct DhtMessageTracker {
entries: VecDeque<TrackerEntry>,
default_timeout: Duration,
}
impl DhtMessageTracker {
pub fn new() -> Self {
Self {
entries: VecDeque::new(),
default_timeout: Duration::from_secs(MESSAGE_TIMEOUT_SECS),
}
}
pub fn with_timeout(timeout: Duration) -> Self {
Self {
entries: VecDeque::new(),
default_timeout: timeout,
}
}
pub fn add_query(
&mut self,
target_node_id: NodeId,
target_addr: SocketAddr,
transaction_id: Vec<u8>,
method: String,
) {
self.add_query_with_timeout(
target_node_id,
target_addr,
transaction_id,
method,
self.default_timeout,
);
}
pub fn add_query_with_timeout(
&mut self,
target_node_id: NodeId,
target_addr: SocketAddr,
transaction_id: Vec<u8>,
method: String,
timeout: Duration,
) {
trace!(
tid = ?transaction_id,
method = %method,
addr = %target_addr,
"Tracking DHT query"
);
let entry = TrackerEntry::new(target_node_id, target_addr, transaction_id, method, timeout);
self.entries.push_back(entry);
}
pub fn match_response(
&mut self,
transaction_id: &[u8],
sender_addr: &SocketAddr,
) -> Option<MatchResult> {
let pos = self
.entries
.iter()
.position(|e| e.matches(transaction_id, sender_addr))?;
let entry = self.entries.remove(pos)?;
let elapsed = entry.elapsed();
debug!(
tid = ?transaction_id,
method = %entry.method,
addr = %sender_addr,
elapsed_ms = elapsed.as_millis(),
"DHT response matched to query"
);
Some(MatchResult {
method: entry.method,
target_node_id: entry.target_node_id,
target_addr: entry.target_addr,
elapsed,
})
}
pub fn handle_timeout(&mut self) -> Vec<TimeoutEntry> {
let mut timed_out = Vec::new();
let mut remaining = VecDeque::with_capacity(self.entries.len());
while let Some(entry) = self.entries.pop_front() {
if entry.is_timeout() {
warn!(
tid = ?entry.transaction_id,
method = %entry.method,
addr = %entry.target_addr,
elapsed = ?entry.elapsed(),
"DHT query timed out"
);
let elapsed = entry.elapsed();
timed_out.push(TimeoutEntry {
target_node_id: entry.target_node_id,
target_addr: entry.target_addr,
method: entry.method,
elapsed,
});
} else {
remaining.push_back(entry);
}
}
self.entries = remaining;
timed_out
}
pub fn count(&self) -> usize {
self.entries.len()
}
pub fn is_empty(&self) -> bool {
self.entries.is_empty()
}
pub fn get_entry(&self, transaction_id: &[u8]) -> Option<&TrackerEntry> {
self.entries
.iter()
.find(|e| e.transaction_id == transaction_id)
}
}
impl Default for DhtMessageTracker {
fn default() -> Self {
Self::new()
}
}
#[cfg(test)]
mod tests {
use std::net::{Ipv4Addr, SocketAddrV4};
use super::*;
fn make_addr(port: u16) -> SocketAddr {
SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::LOCALHOST, port))
}
fn make_node_id(byte: u8) -> NodeId {
let mut id = [0u8; 20];
id[0] = byte;
NodeId(id)
}
#[test]
fn entry_not_timeout_initially() {
let entry = TrackerEntry::new(
NodeId::ZERO,
make_addr(1234),
vec![1, 2, 3, 4],
"ping".into(),
Duration::from_secs(10),
);
assert!(!entry.is_timeout());
}
#[test]
fn entry_matches_same_tid_and_addr() {
let entry = TrackerEntry::new(
make_node_id(1),
make_addr(5000),
vec![0xAA, 0xBB],
"find_node".into(),
Duration::from_secs(10),
);
assert!(entry.matches(&[0xAA, 0xBB], &make_addr(5000)));
}
#[test]
fn entry_no_match_different_tid() {
let entry = TrackerEntry::new(
make_node_id(1),
make_addr(5000),
vec![0xAA, 0xBB],
"find_node".into(),
Duration::from_secs(10),
);
assert!(!entry.matches(&[0xCC, 0xDD], &make_addr(5000)));
}
#[test]
fn entry_no_match_different_addr() {
let entry = TrackerEntry::new(
make_node_id(1),
make_addr(5000),
vec![0xAA, 0xBB],
"find_node".into(),
Duration::from_secs(10),
);
assert!(!entry.matches(&[0xAA, 0xBB], &make_addr(6000)));
}
#[test]
fn entry_extend_timeout_resets_dispatch() {
let mut entry = TrackerEntry::new(
NodeId::ZERO,
make_addr(1234),
vec![1],
"ping".into(),
Duration::from_millis(50),
);
assert!(!entry.is_timeout());
std::thread::sleep(Duration::from_millis(60));
assert!(entry.is_timeout());
entry.extend_timeout();
assert!(!entry.is_timeout());
}
#[test]
fn entry_accessors() {
let entry = TrackerEntry::new(
make_node_id(42),
make_addr(7000),
vec![0x01, 0x02],
"get_peers".into(),
Duration::from_secs(5),
);
assert_eq!(entry.method(), "get_peers");
assert_eq!(entry.target_node_id(), &make_node_id(42));
assert_eq!(entry.target_addr(), make_addr(7000));
assert_eq!(entry.transaction_id(), &[0x01, 0x02]);
}
#[test]
fn tracker_add_and_match() {
let mut tracker = DhtMessageTracker::new();
let addr = make_addr(5000);
let tid = vec![1, 2, 3, 4];
tracker.add_query(make_node_id(1), addr, tid.clone(), "ping".into());
assert_eq!(tracker.count(), 1);
let result = tracker.match_response(&tid, &addr).unwrap();
assert_eq!(result.method, "ping");
assert_eq!(result.target_node_id, make_node_id(1));
assert_eq!(result.target_addr, addr);
assert!(result.elapsed < Duration::from_secs(1));
assert_eq!(tracker.count(), 0);
}
#[test]
fn tracker_no_match_returns_none() {
let mut tracker = DhtMessageTracker::new();
tracker.add_query(make_node_id(1), make_addr(5000), vec![1, 2], "ping".into());
assert!(tracker.match_response(&[1, 2], &make_addr(9999)).is_none());
assert!(tracker.match_response(&[9, 9], &make_addr(5000)).is_none());
let mut empty_tracker = DhtMessageTracker::new();
assert!(
empty_tracker
.match_response(&[1, 2], &make_addr(5000))
.is_none()
);
}
#[test]
fn tracker_multiple_entries_match_correct() {
let mut tracker = DhtMessageTracker::new();
let addr1 = make_addr(5001);
let addr2 = make_addr(5002);
tracker.add_query(make_node_id(1), addr1, vec![1], "ping".into());
tracker.add_query(make_node_id(2), addr2, vec![2], "find_node".into());
tracker.add_query(make_node_id(3), addr1, vec![3], "get_peers".into());
assert_eq!(tracker.count(), 3);
let result = tracker.match_response(&[2], &addr2).unwrap();
assert_eq!(result.method, "find_node");
assert_eq!(tracker.count(), 2);
let result = tracker.match_response(&[1], &addr1).unwrap();
assert_eq!(result.method, "ping");
assert_eq!(tracker.count(), 1);
let result = tracker.match_response(&[3], &addr1).unwrap();
assert_eq!(result.method, "get_peers");
assert!(tracker.is_empty());
}
#[test]
fn tracker_timeout_removes_expired() {
let mut tracker = DhtMessageTracker::with_timeout(Duration::from_millis(30));
tracker.add_query(make_node_id(1), make_addr(5000), vec![1], "ping".into());
tracker.add_query(
make_node_id(2),
make_addr(5001),
vec![2],
"find_node".into(),
);
assert_eq!(tracker.count(), 2);
std::thread::sleep(Duration::from_millis(40));
let timed_out = tracker.handle_timeout();
assert_eq!(timed_out.len(), 2);
assert_eq!(timed_out[0].method, "ping");
assert_eq!(timed_out[1].method, "find_node");
assert!(tracker.is_empty());
}
#[test]
fn tracker_timeout_keeps_non_expired() {
let mut tracker = DhtMessageTracker::new();
tracker.add_query_with_timeout(
make_node_id(1),
make_addr(5000),
vec![1],
"ping".into(),
Duration::from_millis(20),
);
tracker.add_query_with_timeout(
make_node_id(2),
make_addr(5001),
vec![2],
"find_node".into(),
Duration::from_secs(300),
);
std::thread::sleep(Duration::from_millis(30));
let timed_out = tracker.handle_timeout();
assert_eq!(timed_out.len(), 1);
assert_eq!(timed_out[0].method, "ping");
assert_eq!(tracker.count(), 1);
let entry = tracker.get_entry(&[2]).unwrap();
assert_eq!(entry.method(), "find_node");
}
#[test]
fn tracker_timeout_entry_has_elapsed() {
let mut tracker = DhtMessageTracker::with_timeout(Duration::from_millis(10));
tracker.add_query(make_node_id(1), make_addr(5000), vec![1], "ping".into());
std::thread::sleep(Duration::from_millis(20));
let timed_out = tracker.handle_timeout();
assert_eq!(timed_out.len(), 1);
assert!(timed_out[0].elapsed >= Duration::from_millis(10));
}
#[test]
fn tracker_get_entry_by_tid() {
let mut tracker = DhtMessageTracker::new();
tracker.add_query(make_node_id(1), make_addr(5000), vec![0xAA], "ping".into());
tracker.add_query(
make_node_id(2),
make_addr(5001),
vec![0xBB],
"find_node".into(),
);
let entry = tracker.get_entry(&[0xBB]).unwrap();
assert_eq!(entry.method(), "find_node");
assert_eq!(*entry.target_node_id(), make_node_id(2));
assert!(tracker.get_entry(&[0xCC]).is_none());
}
#[test]
fn tracker_match_removes_entry_so_no_double_match() {
let mut tracker = DhtMessageTracker::new();
let addr = make_addr(5000);
tracker.add_query(make_node_id(1), addr, vec![1], "ping".into());
assert!(tracker.match_response(&[1], &addr).is_some());
assert!(tracker.match_response(&[1], &addr).is_none());
}
#[test]
fn tracker_default_impl() {
let tracker = DhtMessageTracker::default();
assert!(tracker.is_empty());
assert_eq!(tracker.count(), 0);
}
}