Stub for torrent_file_from_info_and_bytes

crates/librqbit/src/dht_utils.rs

@@ -16,7 +16,7 @@ use librqbit_core::hash_id::Id20;
 pub enum ReadMetainfoResult<Rx> {
     Found {
         info: TorrentMetaV1Info<ByteBufOwned>,
-        bytes: ByteBufOwned,
+        info_bytes: ByteBufOwned,
         rx: Rx,
         seen: HashSet<SocketAddr>,
     },
@@ -81,7 +81,7 @@ pub async fn read_metainfo_from_peer_receiver<A: Stream<Item = SocketAddr> + Unp
             },
             done = unordered.next(), if !unordered.is_empty() => {
                 match done {
-                    Some(Ok(info)) => return ReadMetainfoResult::Found { info: info.0, bytes: info.1, seen, rx: addrs },
+                    Some(Ok((info, info_bytes))) => return ReadMetainfoResult::Found { info, info_bytes, seen, rx: addrs },
                     Some(Err(e)) => {
                         debug!("{:#}", e);
                     },

crates/librqbit/src/peer_info_reader/mod.rs

@@ -32,7 +32,7 @@ pub(crate) async fn read_metainfo_from_peer(
     peer_connection_options: Option<PeerConnectionOptions>,
     spawner: BlockingSpawner,
     connector: Arc<StreamConnector>,
-) -> anyhow::Result<TorrentAndBytes> {
+) -> anyhow::Result<TorrentAndInfoBytes> {
     let (result_tx, result_rx) = tokio::sync::oneshot::channel::<
         anyhow::Result<(TorrentMetaV1Info<ByteBufOwned>, ByteBufOwned)>,
     >();
@@ -136,13 +136,13 @@ impl HandlerLocked {
     }
 }
 
-pub type TorrentAndBytes = (TorrentMetaV1Info<ByteBufOwned>, ByteBufOwned);
+pub type TorrentAndInfoBytes = (TorrentMetaV1Info<ByteBufOwned>, ByteBufOwned);
 
 struct Handler {
     addr: SocketAddr,
     info_hash: Id20,
     writer_tx: UnboundedSender<WriterRequest>,
-    result_tx: Mutex<Option<tokio::sync::oneshot::Sender<anyhow::Result<TorrentAndBytes>>>>,
+    result_tx: Mutex<Option<tokio::sync::oneshot::Sender<anyhow::Result<TorrentAndInfoBytes>>>>,
     locked: RwLock<Option<HandlerLocked>>,
 }
 

crates/librqbit/src/session.rs

@@ -502,6 +502,15 @@ async fn create_tcp_listener(
     bail!("no free TCP ports in range {port_range:?}");
 }
 
+fn torrent_file_from_info_and_bytes(
+    info: &TorrentMetaV1Info<ByteBufOwned>,
+    info_hash: &Id20,
+    info_bytes: &[u8],
+    trackers: &[String],
+) -> Bytes {
+    todo!()
+}
+
 pub(crate) struct CheckedIncomingConnection {
     pub addr: SocketAddr,
     pub stream: tokio::net::TcpStream,
@@ -986,16 +995,22 @@ impl Session {
                     {
                         ReadMetainfoResult::Found {
                             info,
-                            bytes,
+                            info_bytes,
                             rx,
                             seen,
                         } => {
                             debug!(?info, "received result from DHT");
+                            let trackers = magnet.trackers.into_iter().unique().collect_vec();
                             InternalAddResult {
                                 info_hash,
+                                torrent_bytes: torrent_file_from_info_and_bytes(
+                                    &info,
+                                    &info_hash,
+                                    &info_bytes,
+                                    &trackers,
+                                ),
                                 info,
-                                torrent_bytes: Bytes::from(bytes.0),
+                                trackers,
-                                trackers: magnet.trackers.into_iter().unique().collect(),
                                 peer_rx: Some(rx),
                                 initial_peers: seen.into_iter().collect(),
                             }