use std::collections::HashSet;
use std::sync::Arc;
use std::time::{Duration, Instant};
use tracing::{debug, info, warn};
use super::bt_announce::{BtAnnounce, is_udp_tracker};
use super::types::AnnounceEvent;
use crate::engine::udp_tracker_client::SharedUdpClient;
use crate::engine::udp_tracker_manager::UdpTrackerManager;
use crate::http::client_identity::ClientTlsConfig;
use aria2_protocol::bittorrent::tracker::public_list::{PublicTrackerList, TrackerFailureKind};
use aria2_protocol::bittorrent::tracker::udp_tracker_protocol::UdpError;
#[derive(Debug, Clone)]
pub struct AnnounceResult {
pub peers: Vec<(String, u16)>,
pub interval: Duration,
pub seeders: i64,
pub leechers: i64,
pub event: AnnounceEvent,
pub tracker_url: String,
}
#[derive(Debug, Clone, Default)]
pub struct TrackerRuntimeSnapshot {
pub tracker_tiers: Vec<Vec<String>>,
pub current_url: Option<String>,
pub last_attempt_url: Option<String>,
pub announce_ready: bool,
pub all_failed: bool,
pub in_flight: u32,
pub interval_secs: u64,
pub min_interval_secs: u64,
pub seeders: i64,
pub leechers: i64,
pub tracker_id: String,
pub seconds_since_last_success: Option<u64>,
}
pub type SharedTrackerRuntime = Arc<std::sync::RwLock<TrackerRuntimeSnapshot>>;
impl TrackerRuntimeSnapshot {
pub fn from_bt_announce(announce: &BtAnnounce) -> Self {
let announce_list = announce.announce_list();
let tracker_tiers = (0..announce_list.tier_count())
.map(|tier| {
let mut urls = Vec::new();
let mut entry = 0;
while let Some(url) = announce_list.get_tracker_url(tier, entry) {
urls.push(url.clone());
entry += 1;
}
urls
})
.collect();
Self {
tracker_tiers,
current_url: announce.announce_list().get_announce().map(str::to_owned),
last_attempt_url: None,
announce_ready: announce.is_announce_ready(),
all_failed: announce.is_all_announce_failed(),
in_flight: announce.in_flight_announces(),
interval_secs: announce.interval().as_secs(),
min_interval_secs: announce.min_interval().as_secs(),
seeders: announce.complete(),
leechers: announce.incomplete(),
tracker_id: announce.tracker_id().to_string(),
seconds_since_last_success: announce.seconds_since_last_success(),
}
}
}
pub struct TrackerAnnouncer {
announce: BtAnnounce,
stopped_sent: bool,
udp_manager: Option<UdpTrackerManager>,
udp_client: Option<SharedUdpClient>,
last_attempt_tracker_url: Option<String>,
public_tracker_catalog: Option<Arc<PublicTrackerList>>,
public_tracker_urls: HashSet<String>,
last_failure_kind: Option<TrackerFailureKind>,
http_tls: ClientTlsConfig,
tracker_timeout_secs: u64,
tracker_connect_timeout_secs: u64,
stopped_timeout: Duration,
runtime_state: Option<SharedTrackerRuntime>,
}
impl TrackerAnnouncer {
pub fn new(announce_list: &[Vec<String>], announce: &Option<String>) -> Self {
Self {
announce: BtAnnounce::new(announce_list, announce),
stopped_sent: false,
udp_manager: None,
udp_client: None,
last_attempt_tracker_url: None,
public_tracker_catalog: None,
public_tracker_urls: HashSet::new(),
last_failure_kind: None,
http_tls: ClientTlsConfig::default(),
tracker_timeout_secs: 60,
tracker_connect_timeout_secs: 60,
stopped_timeout: Duration::from_secs(crate::constants::BT_TRACKER_STOPPED_TIMEOUT_SECS),
runtime_state: None,
}
}
pub fn with_udp_client(announce: BtAnnounce, udp_client: Option<SharedUdpClient>) -> Self {
Self {
announce,
stopped_sent: false,
udp_manager: None,
udp_client,
last_attempt_tracker_url: None,
public_tracker_catalog: None,
public_tracker_urls: HashSet::new(),
last_failure_kind: None,
http_tls: ClientTlsConfig::default(),
tracker_timeout_secs: 60,
tracker_connect_timeout_secs: 60,
stopped_timeout: Duration::from_secs(crate::constants::BT_TRACKER_STOPPED_TIMEOUT_SECS),
runtime_state: None,
}
}
pub fn set_runtime_snapshot(&mut self, state: SharedTrackerRuntime) {
self.runtime_state = Some(state);
self.publish_runtime_snapshot();
}
pub fn runtime_snapshot(&self) -> TrackerRuntimeSnapshot {
let mut snapshot = TrackerRuntimeSnapshot::from_bt_announce(&self.announce);
snapshot.last_attempt_url = self.last_attempt_tracker_url.clone();
snapshot
}
pub fn publish_runtime_snapshot(&self) {
let Some(state) = self.runtime_state.as_ref() else {
return;
};
let snapshot = self.runtime_snapshot();
if let Ok(mut current) = state.write() {
*current = snapshot;
}
}
pub fn set_udp_client(&mut self, client: SharedUdpClient) {
self.udp_client = Some(client);
}
pub(crate) fn set_http_tls_config(&mut self, config: ClientTlsConfig) {
self.http_tls = config;
}
pub fn set_timeouts(&mut self, request: Duration, connect: Duration) {
self.tracker_timeout_secs = request.as_secs().max(1);
self.tracker_connect_timeout_secs = connect.as_secs().max(1);
}
pub fn set_stopped_timeout(&mut self, timeout: Duration) {
self.stopped_timeout = timeout.max(Duration::from_millis(1));
}
pub fn set_user_defined_interval(&mut self, interval: Duration) {
self.announce.set_user_defined_interval(interval);
}
pub fn set_announce_options(&mut self, force_encryption: bool, external_ip: Option<String>) {
self.announce.set_force_encryption(force_encryption);
self.announce.set_external_ip(external_ip);
}
pub fn is_announce_ready(&self) -> bool {
self.announce.is_announce_ready()
}
pub fn is_default_announce_ready(&self) -> bool {
self.announce.is_default_announce_ready()
}
pub fn next_default_announce_delay(&self) -> Option<std::time::Duration> {
self.announce.next_default_announce_delay()
}
pub fn current_tracker_url(&self) -> Option<&str> {
self.announce.announce_list().get_announce()
}
pub fn last_attempt_tracker_url(&self) -> Option<&str> {
self.last_attempt_tracker_url.as_deref()
}
pub fn set_public_tracker_catalog(
&mut self,
catalog: Arc<PublicTrackerList>,
public_tracker_urls: HashSet<String>,
) {
self.public_tracker_catalog = Some(catalog);
self.public_tracker_urls = public_tracker_urls;
}
pub async fn announce(
&mut self,
info_hash: &[u8; 20],
peer_id: &[u8; 20],
downloaded: u64,
left: u64,
uploaded: u64,
) -> Option<AnnounceResult> {
if !self.announce.is_announce_ready() {
return None;
}
if !self.announce.adjust_announce_list() {
return None;
}
let tracker_url = self.announce.announce_list().get_announce()?.to_string();
self.last_attempt_tracker_url = Some(tracker_url.clone());
self.last_failure_kind = None;
self.publish_runtime_snapshot();
let is_udp = is_udp_tracker(&tracker_url);
let event = self.announce.announce_list().get_event();
let result = if is_udp {
self.announce_udp(info_hash, peer_id, downloaded, left, uploaded, &tracker_url)
.await
} else {
self.announce_http(
info_hash,
peer_id,
downloaded,
left,
uploaded,
event,
&tracker_url,
)
.await
};
self.publish_runtime_snapshot();
if self.public_tracker_urls.contains(&tracker_url)
&& let Some(catalog) = self.public_tracker_catalog.as_ref()
{
if result.is_some() {
catalog.record_success(&tracker_url).await;
} else {
catalog
.record_failure_kind(
&tracker_url,
self.last_failure_kind
.unwrap_or(TrackerFailureKind::MalformedResponse),
)
.await;
}
}
result
}
async fn announce_udp(
&mut self,
info_hash: &[u8; 20],
peer_id: &[u8; 20],
downloaded: u64,
left: u64,
uploaded: u64,
tracker_url: &str, ) -> Option<AnnounceResult> {
let event = self.announce.announce_list().get_event();
let udp_event = self.announce.current_udp_event();
let numwant = self.announce.numwant();
if self.udp_manager.is_none() {
if let Some(ref client) = self.udp_client {
let mgr = UdpTrackerManager::new(Arc::clone(client)).await;
self.udp_manager = Some(mgr);
} else {
match crate::engine::udp_tracker_client::UdpTrackerClient::new(0).await {
Ok(client) => {
let shared = Arc::new(tokio::sync::Mutex::new(client));
self.udp_client = Some(Arc::clone(&shared));
let mgr = UdpTrackerManager::new(shared).await;
self.udp_manager = Some(mgr);
}
Err(e) => {
warn!("[BT] Failed to create UDP tracker client: {}", e);
self.last_failure_kind = Some(TrackerFailureKind::Network);
self.announce.announce_failure();
return None;
}
}
}
}
{
let mgr = self.udp_manager.as_mut()?;
mgr.set_request_timeout(Duration::from_secs(self.tracker_timeout_secs));
mgr.use_tracker_url(tracker_url).await;
}
self.announce.announce_start();
self.publish_runtime_snapshot();
debug!(
"[BT] Announcing to UDP tracker {} (event={:?}, udp_event={})",
tracker_url, event, udp_event
);
let responses = self
.udp_manager
.as_mut()?
.announce(
info_hash,
peer_id,
downloaded as i64,
left as i64,
uploaded as i64,
udp_event,
numwant as i32,
)
.await;
if responses.is_empty() {
warn!("[BT] UDP tracker {} returned no response", tracker_url);
let last_error = self.udp_manager.as_mut()?.last_announce_error().await;
self.last_failure_kind = Some(match last_error {
Some(UdpError::TrackerError) => TrackerFailureKind::TrackerRejected,
Some(UdpError::MalformedResponse) => TrackerFailureKind::MalformedResponse,
Some(UdpError::Network) => TrackerFailureKind::Network,
Some(UdpError::Timeout) | None => TrackerFailureKind::Timeout,
Some(UdpError::Success | UdpError::Shutdown) => {
TrackerFailureKind::MalformedResponse
}
});
self.announce.announce_failure();
return None;
}
let response = &responses[0];
let peers = self.announce.process_udp_announce_response(response);
self.announce.announce_success();
let mut all_peers = peers;
if responses.len() > 1 {
for resp in &responses[1..] {
all_peers.extend_from_slice(&resp.peers);
}
}
all_peers.sort_by(|a, b| a.0.cmp(&b.0).then(a.1.cmp(&b.1)));
all_peers.dedup();
Some(AnnounceResult {
peers: all_peers,
interval: self.announce.interval(),
seeders: self.announce.complete(),
leechers: self.announce.incomplete(),
event,
tracker_url: tracker_url.to_string(),
})
}
#[allow(clippy::too_many_arguments)]
async fn announce_http(
&mut self,
info_hash: &[u8; 20],
peer_id: &[u8; 20],
downloaded: u64,
left: u64,
uploaded: u64,
event: AnnounceEvent,
tracker_url: &str,
) -> Option<AnnounceResult> {
let url = self.announce.get_announce_url_without_adjustment(
info_hash, peer_id, uploaded, downloaded, left, None,
)?;
self.announce.announce_start();
self.publish_runtime_snapshot();
debug!(
"[BT] Announcing to HTTP tracker {} (event={:?})",
tracker_url, event
);
match crate::engine::http_tracker_client::build_tracker_client_with_tls_and_timeouts(
self.tracker_timeout_secs,
self.tracker_connect_timeout_secs,
&self.http_tls,
) {
Ok(client) => {
match client.get(&url).send().await {
Ok(resp) => {
if !resp.status().is_success() {
warn!(
"[BT] HTTP tracker {} returned status {}",
tracker_url,
resp.status()
);
self.last_failure_kind = Some(
if resp.status().is_server_error()
|| matches!(resp.status().as_u16(), 408 | 425 | 429)
{
TrackerFailureKind::RemoteTemporary
} else {
TrackerFailureKind::TrackerRejected
},
);
self.announce.announce_failure();
return None;
}
match resp.bytes().await {
Ok(body) => {
match aria2_protocol::bittorrent::tracker::response::TrackerResponse::parse(&body) {
Ok(tracker_resp) => {
if tracker_resp.is_failure() {
let reason = tracker_resp.failure_reason
.unwrap_or_else(|| "tracker failure".to_string());
warn!("[BT] HTTP tracker {} failure: {}", tracker_url, reason);
self.last_failure_kind =
Some(TrackerFailureKind::TrackerRejected);
self.announce.announce_failure();
return None;
}
match self.announce.process_announce_response(&tracker_resp) {
Ok(peers) => {
self.announce.announce_success();
let interval = self.announce.interval();
let seeders = self.announce.complete();
let leechers = self.announce.incomplete();
Some(AnnounceResult {
peers,
interval,
seeders,
leechers,
event,
tracker_url: tracker_url.to_string(),
})
}
Err(e) => {
warn!(
"[BT] HTTP tracker {} response processing failed: {}",
tracker_url, e
);
self.last_failure_kind =
Some(TrackerFailureKind::MalformedResponse);
self.announce.announce_failure();
None
}
}
}
Err(e) => {
warn!(
"[BT] HTTP tracker {} response parse failed: {}",
tracker_url, e
);
self.last_failure_kind =
Some(TrackerFailureKind::MalformedResponse);
self.announce.announce_failure();
None
}
}
}
Err(e) => {
warn!("[BT] HTTP tracker {} body read failed: {}", tracker_url, e);
self.last_failure_kind = Some(if e.is_timeout() {
TrackerFailureKind::Timeout
} else {
TrackerFailureKind::Network
});
self.announce.announce_failure();
None
}
}
}
Err(e) => {
warn!("[BT] HTTP tracker {} request failed: {}", tracker_url, e);
self.last_failure_kind = Some(if e.is_timeout() {
TrackerFailureKind::Timeout
} else {
TrackerFailureKind::Network
});
self.announce.announce_failure();
None
}
}
}
Err(e) => {
warn!(
"[BT] Failed to build HTTP tracker client for {}: {}",
tracker_url, e
);
self.last_failure_kind = Some(TrackerFailureKind::Network);
self.announce.announce_failure();
None
}
}
}
pub async fn announce_stopped(
&mut self,
info_hash: &[u8; 20],
peer_id: &[u8; 20],
downloaded: u64,
left: u64,
uploaded: u64,
) {
if self.stopped_sent {
return;
}
self.announce.set_runtime_halted(true);
self.publish_runtime_snapshot();
let mut attempts = 0;
const MAX_STOPPED_ATTEMPTS: usize = 5;
let mut sent_successfully = false;
let deadline = Instant::now() + self.stopped_timeout;
while self.announce.is_stopped_announce_ready() && attempts < MAX_STOPPED_ATTEMPTS {
let remaining = deadline.saturating_duration_since(Instant::now());
if remaining.is_zero() {
warn!(
"[BT] Stopped announce budget exhausted after {} attempts",
attempts
);
break;
}
let result = match tokio::time::timeout(
remaining,
self.announce(info_hash, peer_id, downloaded, left, uploaded),
)
.await
{
Ok(result) => result,
Err(_) => {
warn!(
"[BT] Stopped announce timed out after {:?}",
self.stopped_timeout
);
break;
}
};
if let Some(result) = result {
info!(
"[BT] Sent stopped event to {} ({} peers in response)",
result.tracker_url,
result.peers.len()
);
sent_successfully = true;
}
attempts += 1;
}
self.stopped_sent = sent_successfully;
}
pub async fn announce_completed(
&mut self,
info_hash: &[u8; 20],
peer_id: &[u8; 20],
downloaded: u64,
uploaded: u64,
) {
self.announce.set_download_complete(true);
self.publish_runtime_snapshot();
if let Some(result) = self
.announce(info_hash, peer_id, downloaded, 0, uploaded)
.await
{
info!(
"[BT] Sent completed event to {} ({} seeders, {} leechers)",
result.tracker_url, result.seeders, result.leechers
);
}
}
pub fn interval(&self) -> Duration {
self.announce.interval()
}
pub fn min_interval(&self) -> Duration {
self.announce.min_interval()
}
pub fn bt_announce(&self) -> &BtAnnounce {
&self.announce
}
pub fn bt_announce_mut(&mut self) -> &mut BtAnnounce {
&mut self.announce
}
pub fn is_all_announce_failed(&self) -> bool {
self.announce.is_all_announce_failed()
}
pub fn reset_announce(&mut self) {
self.announce.reset_announce();
self.publish_runtime_snapshot();
}
pub fn set_less_than_min_peers(&mut self, less: bool) {
self.announce.set_less_than_min_peers(less);
self.publish_runtime_snapshot();
}
pub fn set_tcp_port(&mut self, port: u16) {
self.announce.set_tcp_port(port);
}
pub fn tcp_port(&self) -> u16 {
self.announce.tcp_port()
}
pub fn set_download_complete(&mut self, complete: bool) {
self.announce.set_download_complete(complete);
self.publish_runtime_snapshot();
}
pub fn set_runtime_halted(&mut self, halted: bool) {
self.announce.set_runtime_halted(halted);
self.publish_runtime_snapshot();
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn runtime_snapshot_publishes_live_tracker_state() {
let first = "http://tracker.example.com/one".to_string();
let second = "udp://tracker.example.com/two".to_string();
let shared = Arc::new(std::sync::RwLock::new(TrackerRuntimeSnapshot::default()));
let mut announcer = TrackerAnnouncer::new(&[vec![first.clone(), second.clone()]], &None);
announcer.set_runtime_snapshot(Arc::clone(&shared));
announcer.last_attempt_tracker_url = Some(second.clone());
announcer.publish_runtime_snapshot();
let snapshot = shared.read().expect("tracker runtime snapshot lock");
assert_eq!(snapshot.tracker_tiers, vec![vec![first, second.clone()]]);
assert_eq!(
snapshot.current_url.as_deref(),
Some("http://tracker.example.com/one")
);
assert_eq!(snapshot.last_attempt_url.as_deref(), Some(second.as_str()));
assert!(snapshot.announce_ready);
assert!(!snapshot.all_failed);
}
#[test]
fn tracker_timeout_options_are_stored_for_both_transports() {
let mut announcer = TrackerAnnouncer::new(
&[vec!["http://tracker.example.com/announce".to_string()]],
&None,
);
announcer.set_timeouts(Duration::from_secs(7), Duration::from_secs(11));
assert_eq!(announcer.tracker_timeout_secs, 7);
assert_eq!(announcer.tracker_connect_timeout_secs, 11);
}
#[test]
fn stopped_timeout_has_a_clear_default_and_can_be_configured() {
let mut announcer = TrackerAnnouncer::new(&[], &None);
assert_eq!(
announcer.stopped_timeout,
Duration::from_secs(crate::constants::BT_TRACKER_STOPPED_TIMEOUT_SECS)
);
announcer.set_stopped_timeout(Duration::ZERO);
assert_eq!(announcer.stopped_timeout, Duration::from_millis(1));
}
#[tokio::test]
async fn stopped_announce_respects_total_shutdown_budget() {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
.await
.expect("bind local tracker test listener");
let address = listener.local_addr().expect("local tracker address");
let server = tokio::spawn(async move {
let (mut socket, _) = listener.accept().await.expect("accept tracker request");
tokio::time::sleep(Duration::from_secs(2)).await;
use tokio::io::AsyncWriteExt;
let _ = socket
.write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n")
.await;
});
let url = format!("http://{address}/announce");
let mut announcer = TrackerAnnouncer::new(&[vec![url]], &None);
announcer.set_timeouts(Duration::from_secs(10), Duration::from_secs(10));
announcer.set_stopped_timeout(Duration::from_millis(100));
announcer.announce.set_runtime_halted(true);
announcer.announce.announce_list_mut().tiers[0].event = AnnounceEvent::Downloading;
let result = tokio::time::timeout(
Duration::from_secs(1),
announcer.announce_stopped(&[0u8; 20], &[1u8; 20], 0, 1, 0),
)
.await;
assert!(result.is_ok(), "stopped announce exceeded shutdown budget");
assert!(!announcer.stopped_sent);
server.await.expect("tracker test server should exit");
}
#[tokio::test]
async fn tracker_request_timeout_aborts_a_slow_http_announce() {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
.await
.expect("bind local tracker test listener");
let address = listener.local_addr().expect("local tracker address");
let server = tokio::spawn(async move {
let (mut socket, _) = listener.accept().await.expect("accept tracker request");
tokio::time::sleep(Duration::from_secs(2)).await;
use tokio::io::AsyncWriteExt;
let _ = socket
.write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n")
.await;
});
let url = format!("http://{address}/announce");
let mut announcer = TrackerAnnouncer::new(&[vec![url]], &None);
announcer.set_timeouts(Duration::from_secs(1), Duration::from_secs(1));
let result = tokio::time::timeout(
Duration::from_secs(4),
announcer.announce(&[0u8; 20], &[1u8; 20], 0, 1, 0),
)
.await
.expect("tracker request should finish within the test deadline");
assert!(result.is_none(), "slow tracker request should time out");
server.await.expect("tracker test server should exit");
}
#[test]
fn test_tracker_announcer_creation() {
let announcer = TrackerAnnouncer::new(&[], &None);
assert!(!announcer.is_announce_ready());
assert!(announcer.is_all_announce_failed());
}
#[test]
fn test_tracker_announcer_with_announce_url() {
let urls = vec![vec!["http://tracker.example.com:6969/announce".to_string()]];
let announcer = TrackerAnnouncer::new(&urls, &None);
assert!(announcer.is_announce_ready());
}
#[test]
fn test_tracker_announcer_udp_detection() {
let urls = vec![vec!["udp://tracker.example.com:6969/announce".to_string()]];
let _announcer = TrackerAnnouncer::new(&urls, &None);
assert!(is_udp_tracker("udp://tracker.example.com:6969/announce"));
assert!(!is_udp_tracker("http://tracker.example.com:6969/announce"));
}
#[test]
fn test_announce_result_fields() {
let result = AnnounceResult {
peers: vec![("10.0.0.1".to_string(), 6881)],
interval: Duration::from_secs(300),
seeders: 5,
leechers: 10,
event: AnnounceEvent::Started,
tracker_url: "udp://tracker.example.com:6969/announce".to_string(),
};
assert_eq!(result.peers.len(), 1);
assert_eq!(result.seeders, 5);
assert_eq!(result.leechers, 10);
}
}