Abstracting tracker comms

crates/librqbit/src/torrent_state/live/mod.rs

@@ -57,7 +57,6 @@ use std::{
 
 use anyhow::{bail, Context};
 use backoff::backoff::Backoff;
-use bencode::from_bytes;
 use buffers::{ByteBuf, ByteString};
 use clone_to_owned::CloneToOwned;
 use futures::{stream::FuturesUnordered, StreamExt};
@@ -83,7 +82,6 @@ use tokio::{
 };
 use tokio_util::sync::CancellationToken;
 use tracing::{debug, error, error_span, info, trace, warn};
-use url::Url;
 
 use crate::{
     chunk_tracker::{ChunkMarkingResult, ChunkTracker},
@@ -93,7 +91,6 @@ use crate::{
     },
     session::CheckedIncomingConnection,
     torrent_state::{peer::Peer, utils::atomic_inc},
-    tracker_comms::{TrackerError, TrackerRequest, TrackerRequestEvent, TrackerResponse},
     type_aliases::{PeerHandle, BF},
 };
 
@@ -237,13 +234,6 @@ impl TorrentStateLive {
             cancellation_token,
         });
 
-        for tracker in state.meta.trackers.iter() {
-            state.spawn(
-                error_span!(parent: state.meta.span.clone(), "tracker_monitor", url = tracker.to_string()),
-                state.clone().task_single_tracker_monitor(tracker.clone()),
-            );
-        }
-
         state.spawn(
             error_span!(parent: state.meta.span.clone(), "speed_estimator_updater"),
             {
@@ -297,74 +287,6 @@ impl TorrentStateLive {
         &self.up_speed_estimator
     }
 
-    async fn tracker_one_request(&self, tracker_url: Url) -> anyhow::Result<u64> {
-        let response: reqwest::Response = reqwest::get(tracker_url).await?;
-        if !response.status().is_success() {
-            anyhow::bail!("tracker responded with {:?}", response.status());
-        }
-        let bytes = response.bytes().await?;
-        if let Ok(error) = from_bytes::<TrackerError>(&bytes) {
-            anyhow::bail!(
-                "tracker returned failure. Failure reason: {}",
-                error.failure_reason
-            )
-        };
-        let response = from_bytes::<TrackerResponse>(&bytes)?;
-
-        for peer in response.peers.iter_sockaddrs() {
-            self.add_peer_if_not_seen(peer)?;
-        }
-        Ok(response.interval)
-    }
-
-    async fn task_single_tracker_monitor(
-        self: Arc<Self>,
-        mut tracker_url: Url,
-    ) -> anyhow::Result<()> {
-        let mut event = Some(TrackerRequestEvent::Started);
-        loop {
-            let request = TrackerRequest {
-                info_hash: self.info_hash(),
-                peer_id: self.peer_id(),
-                port: 6778,
-                uploaded: self.get_uploaded_bytes(),
-                downloaded: self.get_downloaded_bytes(),
-                left: self.get_left_to_download_bytes(),
-                compact: true,
-                no_peer_id: false,
-                event,
-                ip: None,
-                numwant: None,
-                key: None,
-                trackerid: None,
-            };
-
-            let request_query = request.as_querystring();
-            tracker_url.set_query(Some(&request_query));
-
-            match self.tracker_one_request(tracker_url.clone()).await {
-                Ok(interval) => {
-                    event = None;
-                    let interval = self
-                        .meta
-                        .options
-                        .force_tracker_interval
-                        .unwrap_or_else(|| Duration::from_secs(interval));
-                    debug!(
-                        "sleeping for {:?} after calling tracker {}",
-                        interval,
-                        tracker_url.host().unwrap()
-                    );
-                    tokio::time::sleep(interval).await;
-                }
-                Err(e) => {
-                    debug!("error calling the tracker {}: {:#}", tracker_url, e);
-                    tokio::time::sleep(Duration::from_secs(60)).await;
-                }
-            };
-        }
-    }
-
     pub(crate) fn add_incoming_peer(
         self: &Arc<Self>,
         checked_peer: CheckedIncomingConnection,