pub mod bootstrap;
pub mod message_handling;
pub mod task_execution;
use std::net::SocketAddr;
use std::path::PathBuf;
use std::time::Duration;
use tokio::time::{self, MissedTickBehavior};
use tracing::{info, trace, warn};
use super::constants::{
BUCKET_REFRESH_CHECK_INTERVAL_SECS, DHT_MAX_MESSAGE_SIZE, PEER_ANNOUNCE_CHECK_INTERVAL_SECS,
TOKEN_UPDATE_INTERVAL_SECS,
};
use super::dispatcher::DhtDispatcher;
use super::node_id::NodeId;
use super::peer_announce::DhtPeerAnnounceStorage;
use super::receiver::DhtReceiver;
use super::routing_table::RoutingTable;
use super::task::{
self, DhtPingTask, DhtReplaceNodeTask, DhtTaskQueue, LookupKind, LookupResult, LookupState,
TaskExecutor,
};
use super::token_tracker::TokenTracker;
use super::transport::{AddressFamily, DhtTransport};
#[derive(Clone, Debug)]
pub struct DhtEntryPoint {
pub host: String,
pub port: u16,
}
#[derive(Clone, Debug)]
pub struct DhtEngineConfig {
pub listen_addr: String,
pub listen_port: u16,
pub family: AddressFamily,
pub dht_file_path: PathBuf,
pub entry_points: Vec<DhtEntryPoint>,
pub message_timeout_secs: u64,
}
impl Default for DhtEngineConfig {
fn default() -> Self {
Self {
listen_addr: String::new(),
listen_port: 0,
family: AddressFamily::Ipv4,
dht_file_path: PathBuf::from("dht.dat"),
entry_points: Vec::new(),
message_timeout_secs: 10,
}
}
}
pub struct ActiveLookup {
state: LookupState,
}
impl ActiveLookup {
pub fn new(state: LookupState) -> Self {
Self { state }
}
pub fn state(&self) -> &LookupState {
&self.state
}
pub fn state_mut(&mut self) -> &mut LookupState {
&mut self.state
}
pub fn is_done(&self) -> bool {
self.state.is_done()
}
pub fn into_result(self) -> LookupResult {
self.state.into_result()
}
}
pub struct DhtEngine {
local_id: NodeId,
transport: DhtTransport,
routing_table: RoutingTable,
dispatcher: DhtDispatcher,
receiver: DhtReceiver,
peer_announce_storage: DhtPeerAnnounceStorage,
token_tracker: TokenTracker,
task_queue: DhtTaskQueue,
task_executor: TaskExecutor,
active_lookups: Vec<ActiveLookup>,
active_pings: Vec<DhtPingTask>,
active_replace_tasks: Vec<DhtReplaceNodeTask>,
lookup_result_rx: task::LookupResultReceiver,
#[allow(dead_code)]
lookup_result_tx: task::LookupResultSender,
tcp_port: u16,
config: DhtEngineConfig,
bootstrapped: bool,
}
impl DhtEngine {
pub async fn new(config: DhtEngineConfig) -> std::io::Result<Self> {
let transport = DhtTransport::bind(&config.listen_addr, config.listen_port).await?;
let bound_addr = transport.local_addr()?;
info!(
addr = %bound_addr,
family = ?config.family,
"DHT engine initialized"
);
let local_id = Self::load_or_create_local_id(&config.dht_file_path);
let mut routing_table = RoutingTable::new(local_id);
Self::load_routing_table(&config.dht_file_path, &mut routing_table, config.family);
let timeout = Duration::from_secs(config.message_timeout_secs);
let dispatcher = DhtDispatcher::with_timeout(timeout);
let receiver = DhtReceiver::new(local_id);
let peer_announce_storage = DhtPeerAnnounceStorage::new();
let token_tracker = TokenTracker::new();
let task_queue = DhtTaskQueue::new();
let task_executor = TaskExecutor::new(8); let (lookup_result_tx, lookup_result_rx) = task::lookup_result_channel();
let bootstrapped = false;
Ok(Self {
local_id,
transport,
routing_table,
dispatcher,
receiver,
peer_announce_storage,
token_tracker,
task_queue,
task_executor,
active_lookups: Vec::new(),
active_pings: Vec::new(),
active_replace_tasks: Vec::new(),
lookup_result_rx,
lookup_result_tx,
tcp_port: bound_addr.port(),
config,
bootstrapped,
})
}
pub async fn run(&mut self, mut shutdown: tokio::sync::watch::Receiver<bool>) {
if !self.bootstrapped && !self.config.entry_points.is_empty() {
self.bootstrap().await;
}
let mut token_update_interval =
time::interval(Duration::from_secs(TOKEN_UPDATE_INTERVAL_SECS));
token_update_interval.set_missed_tick_behavior(MissedTickBehavior::Delay);
let mut bucket_refresh_interval =
time::interval(Duration::from_secs(BUCKET_REFRESH_CHECK_INTERVAL_SECS));
bucket_refresh_interval.set_missed_tick_behavior(MissedTickBehavior::Delay);
let mut peer_announce_interval =
time::interval(Duration::from_secs(PEER_ANNOUNCE_CHECK_INTERVAL_SECS));
peer_announce_interval.set_missed_tick_behavior(MissedTickBehavior::Delay);
let mut auto_save_interval = time::interval(Duration::from_secs(30 * 60));
auto_save_interval.set_missed_tick_behavior(MissedTickBehavior::Delay);
let mut buf = [0u8; DHT_MAX_MESSAGE_SIZE];
info!("DHT engine main loop started");
loop {
tokio::select! {
_ = shutdown.changed() => {
info!("DHT engine shutting down");
break;
}
result = self.transport.recv_message(&mut buf) => {
match result {
Ok((len, sender)) => {
self.handle_inbound_message(&buf[..len], sender).await;
}
Err(e) => {
warn!(error = %e, "Error receiving DHT message");
}
}
}
result = self.lookup_result_rx.recv() => {
match result {
Some(lookup_result) => {
self.handle_lookup_result(lookup_result).await;
}
None => {
warn!("Lookup result channel closed unexpectedly");
}
}
}
_ = token_update_interval.tick() => {
trace!("Rotating DHT token secrets");
self.token_tracker.update_secret();
}
_ = bucket_refresh_interval.tick() => {
self.bucket_refresh_check();
}
_ = peer_announce_interval.tick() => {
self.peer_announce_check().await;
}
_ = auto_save_interval.tick() => {
self.auto_save();
}
}
}
self.auto_save();
info!("DHT engine stopped");
}
pub fn local_id(&self) -> &NodeId {
&self.local_id
}
pub fn local_addr(&self) -> std::io::Result<SocketAddr> {
self.transport.local_addr()
}
pub fn routing_table(&self) -> &RoutingTable {
&self.routing_table
}
pub fn peer_announce_storage(&self) -> &DhtPeerAnnounceStorage {
&self.peer_announce_storage
}
pub fn announce_local_info_hash(&mut self, info_hash: NodeId) {
self.peer_announce_storage.add_local_info_hash(info_hash);
}
pub fn remove_local_info_hash(&mut self, info_hash: &NodeId) {
self.peer_announce_storage.remove_local_info_hash(info_hash);
}
pub fn lookup_peers(&mut self, info_hash: NodeId) {
let mut state = LookupState::new(info_hash, LookupKind::Peer);
state.startup(&self.routing_table, &self.local_id);
let lookup = ActiveLookup::new(state);
self.active_lookups.push(lookup);
}
pub fn lookup_nodes(&mut self, target: NodeId) {
let mut state = LookupState::new(target, LookupKind::Node);
state.startup(&self.routing_table, &self.local_id);
let lookup = ActiveLookup::new(state);
self.active_lookups.push(lookup);
}
}
impl DhtPeerAnnounceStorage {
#[allow(dead_code)]
fn info_hashes_needing_announce(&self) -> Vec<NodeId> {
self.local_info_hashes().iter().copied().collect()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn config_default_values() {
let config = DhtEngineConfig::default();
assert!(config.listen_addr.is_empty());
assert_eq!(config.listen_port, 0);
assert_eq!(config.family, AddressFamily::Ipv4);
assert_eq!(config.dht_file_path, PathBuf::from("dht.dat"));
assert!(config.entry_points.is_empty());
assert_eq!(config.message_timeout_secs, 10);
}
#[test]
fn entry_point_clone_debug() {
let ep = DhtEntryPoint {
host: "router.bittorrent.com".to_owned(),
port: 6881,
};
let ep2 = ep.clone();
assert_eq!(ep.host, ep2.host);
assert_eq!(ep.port, ep2.port);
let _ = format!("{:?}", ep);
}
}