test

src/console/clients/udp/app.rs

@@ -60,15 +60,14 @@ use std::net::{SocketAddr, ToSocketAddrs};
 use std::str::FromStr;
 
 use anyhow::Context;
-use aquatic_udp_protocol::Response::{self, AnnounceIpv4, AnnounceIpv6, Connect, Error, Scrape};
-use aquatic_udp_protocol::{Port, TransactionId};
+use aquatic_udp_protocol::{Port, Response, TransactionId};
 use clap::{Parser, Subcommand};
 use log::{debug, LevelFilter};
 use torrust_tracker_primitives::info_hash::InfoHash as TorrustInfoHash;
 use url::Url;
 
 use crate::console::clients::udp::checker;
-use crate::console::clients::udp::responses::{AnnounceResponseDto, ConnectResponseDto, ErrorResponseDto, ScrapeResponseDto};
+use crate::console::clients::udp::responses_print_response_fn_example::print_response;
 
 const ASSIGNED_BY_OS: u16 = 0;
 const RANDOM_TRANSACTION_ID: i32 = -888_840_697;
@@ -169,7 +168,7 @@ async fn handle_scrape(tracker_socket_addr: &SocketAddr, info_hashes: &[TorrustI
         .await
 }
 
-fn print_response(response: Response) -> anyhow::Result<()> {
+/* fn print_response(response: Response) -> anyhow::Result<()> {
     match response {
         Connect(response) => {
             let pretty_json = serde_json::to_string_pretty(&ConnectResponseDto::from(response))
@@ -199,7 +198,7 @@ fn print_response(response: Response) -> anyhow::Result<()> {
     };
 
     Ok(())
-}
+} */
 
 fn parse_socket_addr(tracker_socket_addr_str: &str) -> anyhow::Result<SocketAddr> {
     debug!("Tracker socket address: {tracker_socket_addr_str:#?}");

src/console/clients/udp/mod.rs

@@ -1,3 +1,4 @@
 pub mod app;
 pub mod checker;
 pub mod responses;
+pub mod responses_print_response_fn_example;

src/console/clients/udp/responses_print_response_fn_example.rs

@@ -0,0 +1,140 @@
+//! Aquatic responses are not serializable. These are the serializable wrappers.
+use std::net::{Ipv4Addr, Ipv6Addr};
+
+use anyhow::Context;
+use aquatic_udp_protocol::Response::{self, AnnounceIpv4, AnnounceIpv6, Connect, Error, Scrape};
+use aquatic_udp_protocol::{AnnounceResponse, ConnectResponse, ErrorResponse, Ipv4AddrBytes, Ipv6AddrBytes, ScrapeResponse};
+use serde::Serialize;
+
+pub fn print_response(response: Response) -> anyhow::Result<()> {
+    match response {
+        Connect(response) => {
+            let pretty_json = serde_json::to_string_pretty(&ConnectResponseDto::from(response))
+                .context("connect response JSON serialization")?;
+            println!("{pretty_json}");
+        }
+        AnnounceIpv4(response) => {
+            let pretty_json = serde_json::to_string_pretty(&AnnounceResponseDto::from(response))
+                .context("announce IPv4 response JSON serialization")?;
+            println!("{pretty_json}");
+        }
+        AnnounceIpv6(response) => {
+            let pretty_json = serde_json::to_string_pretty(&AnnounceResponseDto::from(response))
+                .context("announce IPv6 response JSON serialization")?;
+            println!("{pretty_json}");
+        }
+        Scrape(response) => {
+            let pretty_json =
+                serde_json::to_string_pretty(&ScrapeResponseDto::from(response)).context("scrape response JSON serialization")?;
+            println!("{pretty_json}");
+        }
+        Error(response) => {
+            let pretty_json =
+                serde_json::to_string_pretty(&ErrorResponseDto::from(response)).context("error response JSON serialization")?;
+            println!("{pretty_json}");
+        }
+    };
+
+    Ok(())
+}
+
+#[derive(Serialize)]
+pub struct ConnectResponseDto {
+    transaction_id: i32,
+    connection_id: i64,
+}
+
+impl From<ConnectResponse> for ConnectResponseDto {
+    fn from(connect: ConnectResponse) -> Self {
+        Self {
+            transaction_id: connect.transaction_id.0.into(),
+            connection_id: connect.connection_id.0.into(),
+        }
+    }
+}
+
+#[derive(Serialize)]
+pub struct AnnounceResponseDto {
+    transaction_id: i32,
+    announce_interval: i32,
+    leechers: i32,
+    seeders: i32,
+    peers: Vec<String>,
+}
+
+impl From<AnnounceResponse<Ipv4AddrBytes>> for AnnounceResponseDto {
+    fn from(announce: AnnounceResponse<Ipv4AddrBytes>) -> Self {
+        Self {
+            transaction_id: announce.fixed.transaction_id.0.into(),
+            announce_interval: announce.fixed.announce_interval.0.into(),
+            leechers: announce.fixed.leechers.0.into(),
+            seeders: announce.fixed.seeders.0.into(),
+            peers: announce
+                .peers
+                .iter()
+                .map(|peer| format!("{}:{}", Ipv4Addr::from(peer.ip_address), peer.port.0))
+                .collect::<Vec<_>>(),
+        }
+    }
+}
+
+impl From<AnnounceResponse<Ipv6AddrBytes>> for AnnounceResponseDto {
+    fn from(announce: AnnounceResponse<Ipv6AddrBytes>) -> Self {
+        Self {
+            transaction_id: announce.fixed.transaction_id.0.into(),
+            announce_interval: announce.fixed.announce_interval.0.into(),
+            leechers: announce.fixed.leechers.0.into(),
+            seeders: announce.fixed.seeders.0.into(),
+            peers: announce
+                .peers
+                .iter()
+                .map(|peer| format!("{}:{}", Ipv6Addr::from(peer.ip_address), peer.port.0))
+                .collect::<Vec<_>>(),
+        }
+    }
+}
+
+#[derive(Serialize)]
+pub struct ScrapeResponseDto {
+    transaction_id: i32,
+    torrent_stats: Vec<TorrentStats>,
+}
+
+impl From<ScrapeResponse> for ScrapeResponseDto {
+    fn from(scrape: ScrapeResponse) -> Self {
+        Self {
+            transaction_id: scrape.transaction_id.0.into(),
+            torrent_stats: scrape
+                .torrent_stats
+                .iter()
+                .map(|torrent_scrape_statistics| TorrentStats {
+                    seeders: torrent_scrape_statistics.seeders.0.into(),
+                    completed: torrent_scrape_statistics.completed.0.into(),
+                    leechers: torrent_scrape_statistics.leechers.0.into(),
+                })
+                .collect::<Vec<_>>(),
+        }
+    }
+}
+
+#[derive(Serialize)]
+pub struct ErrorResponseDto {
+    transaction_id: i32,
+    message: String,
+}
+
+impl From<ErrorResponse> for ErrorResponseDto {
+    fn from(error: ErrorResponse) -> Self {
+        Self {
+            transaction_id: error.transaction_id.0.into(),
+            message: error.message.to_string(),
+        }
+    }
+}
+
+#[derive(Serialize)]
+struct TorrentStats {
+    seeders: i32,
+    completed: i32,
+    leechers: i32,
+}