use std::sync::Arc;
use std::time::Duration;
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;
#[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,
}
pub struct TrackerAnnouncer {
announce: BtAnnounce,
stopped_sent: bool,
udp_manager: Option<UdpTrackerManager>,
udp_client: Option<SharedUdpClient>,
}
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,
}
}
pub fn with_udp_client(announce: BtAnnounce, udp_client: Option<SharedUdpClient>) -> Self {
Self {
announce,
stopped_sent: false,
udp_manager: None,
udp_client,
}
}
pub fn set_udp_client(&mut self, client: SharedUdpClient) {
self.udp_client = Some(client);
}
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 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();
let is_udp = is_udp_tracker(&tracker_url);
let event = self.announce.announce_list().get_event();
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
}
}
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.announce.announce_failure();
return None;
}
}
}
}
let mgr = self.udp_manager.as_mut()?;
if mgr.endpoint_count() == 0 {
let urls = vec![tracker_url.to_string()];
mgr.parse_tracker_urls(&urls);
}
self.announce.announce_start();
debug!(
"[BT] Announcing to UDP tracker {} (event={:?}, udp_event={})",
tracker_url, event, udp_event
);
let responses = mgr
.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);
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();
debug!(
"[BT] Announcing to HTTP tracker {} (event={:?})",
tracker_url, event
);
match crate::engine::http_tracker_client::build_tracker_client(5) {
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.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.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.announce.announce_failure();
None
}
}
}
Err(e) => {
warn!(
"[BT] HTTP tracker {} response parse failed: {}",
tracker_url, e
);
self.announce.announce_failure();
None
}
}
}
Err(e) => {
warn!("[BT] HTTP tracker {} body read failed: {}", tracker_url, e);
self.announce.announce_failure();
None
}
}
}
Err(e) => {
warn!("[BT] HTTP tracker {} request failed: {}", tracker_url, e);
self.announce.announce_failure();
None
}
}
}
Err(e) => {
warn!(
"[BT] Failed to build HTTP tracker client for {}: {}",
tracker_url, e
);
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);
let mut attempts = 0;
const MAX_STOPPED_ATTEMPTS: usize = 5;
let mut sent_successfully = false;
while self.announce.is_stopped_announce_ready() && attempts < MAX_STOPPED_ATTEMPTS {
if let Some(result) = self
.announce(info_hash, peer_id, downloaded, left, uploaded)
.await
{
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);
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();
}
pub fn set_less_than_min_peers(&mut self, less: bool) {
self.announce.set_less_than_min_peers(less);
}
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);
}
pub fn set_runtime_halted(&mut self, halted: bool) {
self.announce.set_runtime_halted(halted);
}
}
#[cfg(test)]
mod tests {
use super::*;
#[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);
}
}