code restructure

zung_parsers/src/bencode/value.rs

@@ -1,12 +1,10 @@
 use serde::{
+    de::Visitor,
     ser::{SerializeMap, SerializeSeq},
-    Serialize, Serializer,
+    Deserialize, Serialize, Serializer,
 };
 
-use std::{
-    collections::HashMap,
-    fmt::{self},
-};
+use std::{collections::HashMap, fmt};
 
 /// Representation of Bencode values in Rust.
 #[derive(Debug, Clone, PartialEq)]
@@ -71,6 +69,76 @@ impl Serialize for Value {
     }
 }
 
+impl<'de> Deserialize<'de> for Value {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        struct ValueVisitor;
+
+        impl<'de> Visitor<'de> for ValueVisitor {
+            type Value = Value;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                formatter.write_str("a bencode value")
+            }
+
+            fn visit_i64<E>(self, value: i64) -> Result<Value, E>
+            where
+                E: serde::de::Error,
+            {
+                Ok(Value::Integer(value))
+            }
+
+            fn visit_str<E>(self, value: &str) -> Result<Value, E>
+            where
+                E: serde::de::Error,
+            {
+                Ok(Value::String(value.to_owned()))
+            }
+
+            fn visit_bytes<E>(self, value: &[u8]) -> Result<Value, E>
+            where
+                E: serde::de::Error,
+            {
+                // Try to convert to UTF-8 string first
+                match std::str::from_utf8(value) {
+                    Ok(s) => Ok(Value::String(s.to_owned())),
+                    Err(_) => Ok(Value::Bytes(value.to_vec())),
+                }
+            }
+
+            fn visit_seq<A>(self, mut seq: A) -> Result<Value, A::Error>
+            where
+                A: serde::de::SeqAccess<'de>,
+            {
+                let mut values = Vec::new();
+
+                while let Some(value) = seq.next_element()? {
+                    values.push(value);
+                }
+
+                Ok(Value::List(values))
+            }
+
+            fn visit_map<M>(self, mut access: M) -> Result<Value, M::Error>
+            where
+                M: serde::de::MapAccess<'de>,
+            {
+                let mut map = HashMap::new();
+
+                while let Some((key, value)) = access.next_entry()? {
+                    map.insert(key, value);
+                }
+
+                Ok(Value::Dictionary(map))
+            }
+        }
+
+        deserializer.deserialize_any(ValueVisitor)
+    }
+}
+
 pub enum ValueInput<'a> {
     Str(&'a str),
     Bytes(&'a [u8]),

zung_torrent/Cargo.toml

@@ -14,6 +14,8 @@ default = ["client"]
 client = ["dep:colored", "dep:human_bytes"]
 
 [dependencies]
+
+colored = { version = "2.2.0", optional = true }
 anyhow = "1.0.94"
 bytes = { version = "1.9.0", features = ["serde"] }
 clap = { version = "4.5.23", features = ["derive"] }
@@ -24,9 +26,8 @@ rayon = "1.10.0"
 indexmap = "2.7.0"
 rand = "0.8.5"
 tokio = { version = "1.42.0", features = ["full"] }
-
-colored = { version = "2.2.0", optional = true }
 human_bytes = { version = "0.4.3", optional = true }
+reqwest = "0.12.11"
 
 
 serde = { version = "1.0.216", features = ["derive"] }

zung_torrent/src/lib.rs

@@ -8,8 +8,6 @@ pub mod sources;
 
 pub use client::Client;
 pub use client::PeerID;
-use colored::Colorize;
-use futures::StreamExt;
 use meta_info::MetaInfo;
 
 use clap::{Args, Subcommand};
@@ -74,23 +72,13 @@ impl TorrentArgs {
             }
             TorrentCommands::Test { file } => {
                 let torrent = Client::new(file)?;
-                let mut list = torrent
+                let list = torrent
                     .sources()
                     .tracker_requests(torrent.info_hash().as_encoded(), torrent.peer_id())
+                    .await
                     .unwrap();
 
-                // Waits for ALL futures to complete
-                while let Some(result) = list.next().await {
-                    match result {
-                        Ok(a) => match a {
-                            Ok(a) => println!("Connected! {}", a.to_url().unwrap().green()),
-                            Err(e) => println!("{}", e.to_string().red()),
-                        },
-                        Err(e) => {
-                            println!("{}", e.to_string().red())
-                        }
-                    }
-                }
+                println!("{list:#?}");
             }
         }
 

zung_torrent/src/sources/mod.rs

@@ -10,9 +10,7 @@ use crate::{
     PeerID,
 };
 
-use anyhow::Result;
-use futures::stream::FuturesUnordered;
-use tokio::task::JoinHandle;
+use futures::StreamExt;
 
 mod http_seeders;
 mod trackers;
@@ -113,13 +111,11 @@ impl<'a> DownloadSources<'a> {
     /// }
     /// # }
     /// ```
-    pub fn trackers(&self) -> Option<&TrackerList> {
-        if let Self::Trackers { tracker_list } = self {
-            Some(tracker_list)
-        } else if let Self::Hybrid { tracker_list, .. } = self {
-            Some(tracker_list)
-        } else {
-            None
+    pub fn tracker_list(&self) -> Option<&TrackerList> {
+        match self {
+            DownloadSources::Trackers { tracker_list }
+            | DownloadSources::Hybrid { tracker_list, .. } => Some(tracker_list),
+            DownloadSources::HttpSeeders { .. } => None,
         }
     }
 
@@ -189,17 +185,24 @@ impl<'a> DownloadSources<'a> {
         matches!(self, Self::Hybrid { .. })
     }
 
-    pub fn tracker_requests(
+    pub async fn tracker_requests(
         &self,
         info_hash: InfoHashEncoded,
         peer_id: PeerID,
-    ) -> Option<FuturesUnordered<JoinHandle<Result<TrackerRequest>>>> {
-        match self {
-            DownloadSources::Trackers { tracker_list }
-            | DownloadSources::Hybrid { tracker_list, .. } => {
-                Some(tracker_list.generate_requests(info_hash, peer_id))
+    ) -> Option<Vec<TrackerRequest>> {
+        if let Some(list) = self.tracker_list() {
+            let mut result = Vec::with_capacity(list.len());
+            let mut request_futures = list.generate_requests(info_hash, peer_id).await;
+            while let Some(request) = request_futures.next().await {
+                match request {
+                    Ok(Ok(tracker_request)) => result.push(tracker_request),
+                    Err(e) => eprintln!("{e}"),
+                    Ok(Err(e)) => eprintln!("{e}"),
+                }
             }
-            DownloadSources::HttpSeeders { .. } => None,
+            Some(result)
+        } else {
+            None
         }
     }
 }

zung_torrent/src/sources/trackers/mod.rs

@@ -10,14 +10,14 @@
 mod request;
 pub use request::*;
 
-use std::ops::Deref;
 use std::sync::Arc;
+use std::{net::Ipv4Addr, ops::Deref};
 
 use crate::meta_info::InfoHashEncoded;
 use crate::PeerID;
 use anyhow::{bail, Result};
 use futures::stream::FuturesUnordered;
-use tokio::task::JoinHandle;
+use tokio::{net::UdpSocket, task::JoinHandle};
 
 // TODO: Look into SmallStr
 #[derive(Debug)]
@@ -58,6 +58,7 @@ impl Tracker {
 
     pub async fn generate_request(
         &self,
+        socket: Arc<UdpSocket>,
         info_hash: InfoHashEncoded,
         peer_id: PeerID,
     ) -> Result<TrackerRequest> {
@@ -72,10 +73,7 @@ impl Tracker {
                     Some(s) => s.0,
                     None => udp_url,
                 };
-                let connection = UdpConnectRequest::new()
-                    .await?
-                    .connect_with(udp_url)
-                    .await?;
+                let connection = UdpConnectRequest::new(socket).connect_with(udp_url).await?;
 
                 let connection_id = connection.connection_id();
                 Ok(TrackerRequest::Udp {
@@ -111,16 +109,21 @@ impl TrackerList {
     /// Asyncly generates the [`TrackerRequest`]
     ///
     // TODO: Revisit this if there is a faster more efficient way.
-    pub fn generate_requests(
+    pub async fn generate_requests(
         &self,
         info_hash: InfoHashEncoded,
         peer_id: PeerID,
     ) -> FuturesUnordered<JoinHandle<Result<TrackerRequest>>> {
+        let socket = Arc::new(UdpSocket::bind((Ipv4Addr::UNSPECIFIED, 0)).await.unwrap());
+
         self.as_array()
             .iter()
             .cloned() // The clone here is just Arc::clone
             .map(|tracker| {
-                tokio::spawn(async move { tracker.generate_request(info_hash, peer_id).await })
+                let socket = Arc::clone(&socket);
+                tokio::spawn(
+                    async move { tracker.generate_request(socket, info_hash, peer_id).await },
+                )
             })
             .collect()
     }
@@ -155,9 +158,10 @@ mod tracker_tests {
         let sample_url = "http://example.com/announce";
         let info_hash = InfoHash::new(b"test info_hash").as_encoded();
         let peer_id = PeerID::default();
+        let socket = Arc::new(UdpSocket::bind((Ipv4Addr::UNSPECIFIED, 0)).await.unwrap());
         let tracker_request = Tracker::new(sample_url);
         let tracker_request = tracker_request
-            .generate_request(info_hash, peer_id)
+            .generate_request(socket, info_hash, peer_id)
             .await
             .unwrap();
 
@@ -185,9 +189,10 @@ mod tracker_tests {
         let url = "http://example.com/announce";
         let info_hash = InfoHash::new(b"test info_hash").as_encoded();
         let peer_id = PeerID::default();
+        let socket = Arc::new(UdpSocket::bind((Ipv4Addr::UNSPECIFIED, 0)).await.unwrap());
         let tracker_request = Tracker::new(url);
         let tracker_request = tracker_request
-            .generate_request(info_hash, peer_id)
+            .generate_request(socket, info_hash, peer_id)
             .await
             .unwrap();
 
@@ -214,11 +219,11 @@ mod tracker_tests {
     async fn test_bool_as_int_serialization() {
         let url = "http://example.com/announce";
         let info_hash = InfoHash::new(b"test info_hash").as_encoded();
-
+        let socket = Arc::new(UdpSocket::bind((Ipv4Addr::UNSPECIFIED, 0)).await.unwrap());
         let peer_id = PeerID::default();
         let tracker_request = Tracker::new(url);
         let mut tracker_request = tracker_request
-            .generate_request(info_hash, peer_id)
+            .generate_request(socket, info_hash, peer_id)
             .await
             .unwrap();
 
@@ -258,10 +263,11 @@ mod tracker_tests {
     async fn test_optional_parameters() {
         let url = "http://example.com/announce";
         let info_hash = InfoHash::new(b"test info_hash").as_encoded();
+        let socket = Arc::new(UdpSocket::bind((Ipv4Addr::UNSPECIFIED, 0)).await.unwrap());
         let peer_id = PeerID::default();
         let tracker_request = Tracker::new(url);
         let mut tracker_request = tracker_request
-            .generate_request(info_hash, peer_id)
+            .generate_request(socket, info_hash, peer_id)
             .await
             .unwrap();