refactor: extract type RemoteClientAddr

Author: josecelano

packages/http-tracker-core/src/event/mod.rs

@@ -6,6 +6,8 @@ use torrust_tracker_metrics::label_name;
 use torrust_tracker_primitives::peer::PeerAnnouncement;
 use torrust_tracker_primitives::service_binding::ServiceBinding;
 
+use crate::services::RemoteClientAddr;
+
 pub mod sender;
 
 /// A HTTP core event.
@@ -29,12 +31,9 @@ pub struct ConnectionContext {
 
 impl ConnectionContext {
     #[must_use]
-    pub fn new(client_ip_addr: IpAddr, opt_client_port: Option<u16>, server_service_binding: ServiceBinding) -> Self {
+    pub fn new(remote_client_addr: RemoteClientAddr, server_service_binding: ServiceBinding) -> Self {
         Self {
-            client: ClientConnectionContext {
-                ip_addr: client_ip_addr,
-                port: opt_client_port,
-            },
+            client: ClientConnectionContext { remote_client_addr },
             server: ServerConnectionContext {
                 service_binding: server_service_binding,
             },
@@ -43,12 +42,12 @@ impl ConnectionContext {
 
     #[must_use]
     pub fn client_ip_addr(&self) -> IpAddr {
-        self.client.ip_addr
+        self.client.ip_addr()
     }
 
     #[must_use]
     pub fn client_port(&self) -> Option<u16> {
-        self.client.port
+        self.client.port()
     }
 
     #[must_use]
@@ -59,10 +58,19 @@ impl ConnectionContext {
 
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub struct ClientConnectionContext {
-    ip_addr: IpAddr,
+    remote_client_addr: RemoteClientAddr,
+}
+
+impl ClientConnectionContext {
+    #[must_use]
+    pub fn ip_addr(&self) -> IpAddr {
+        self.remote_client_addr.ip
+    }
 
-    /// It's provided if you use the `torrust-axum-http-tracker-server` crate.
-    port: Option<u16>,
+    #[must_use]
+    pub fn port(&self) -> Option<u16> {
+        self.remote_client_addr.port
+    }
 }
 
 #[derive(Debug, PartialEq, Eq, Clone)]
@@ -96,6 +104,7 @@ pub mod test {
     use torrust_tracker_primitives::service_binding::Protocol;
 
     use super::Event;
+    use crate::services::RemoteClientAddr;
     use crate::tests::sample_info_hash;
 
     #[must_use]
@@ -134,8 +143,7 @@ pub mod test {
 
         let event1 = Event::TcpAnnounce {
             connection: ConnectionContext::new(
-                remote_client_ip,
-                Some(8080),
+                RemoteClientAddr::new(remote_client_ip, Some(8080)),
                 ServiceBinding::new(Protocol::HTTP, SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 7070)).unwrap(),
             ),
             info_hash,
@@ -144,8 +152,7 @@ pub mod test {
 
         let event2 = Event::TcpAnnounce {
             connection: ConnectionContext::new(
-                IpAddr::V4(Ipv4Addr::new(127, 0, 0, 2)),
-                Some(8080),
+                RemoteClientAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 2)), Some(8080)),
                 ServiceBinding::new(Protocol::HTTP, SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 7070)).unwrap(),
             ),
             info_hash,

packages/http-tracker-core/src/services/announce.rs

@@ -7,7 +7,6 @@
 //!
 //! It also sends an [`http_tracker_core::event::Event`]
 //! because events are specific for the HTTP tracker.
-use std::net::IpAddr;
 use std::panic::Location;
 use std::sync::Arc;
 
@@ -24,7 +23,7 @@ use torrust_tracker_primitives::core::AnnounceData;
 use torrust_tracker_primitives::peer::PeerAnnouncement;
 use torrust_tracker_primitives::service_binding::ServiceBinding;
 
-use super::resolve_remote_client_ip;
+use super::{resolve_remote_client_addr, RemoteClientAddr};
 use crate::event;
 use crate::event::Event;
 
@@ -79,22 +78,20 @@ impl AnnounceService {
 
         self.authorize(announce_request.info_hash).await?;
 
-        let (remote_client_ip, opt_remote_client_port) =
-            resolve_remote_client_ip(self.core_config.net.on_reverse_proxy, client_ip_sources)?;
+        let remote_client_addr = resolve_remote_client_addr(self.core_config.net.on_reverse_proxy, client_ip_sources)?;
 
-        let mut peer = peer_from_request(announce_request, &remote_client_ip);
+        let mut peer = peer_from_request(announce_request, &remote_client_addr.ip);
 
         let peers_wanted = Self::peers_wanted(announce_request);
 
         let announce_data = self
             .announce_handler
-            .announce(&announce_request.info_hash, &mut peer, &remote_client_ip, &peers_wanted)
+            .announce(&announce_request.info_hash, &mut peer, &remote_client_addr.ip, &peers_wanted)
             .await?;
 
         self.send_event(
             announce_request.info_hash,
-            remote_client_ip,
-            opt_remote_client_port,
+            remote_client_addr,
             server_service_binding.clone(),
             peer,
         )
@@ -130,14 +127,13 @@ impl AnnounceService {
     async fn send_event(
         &self,
         info_hash: InfoHash,
-        remote_client_ip: IpAddr,
-        opt_peer_ip_port: Option<u16>,
+        remote_client_addr: RemoteClientAddr,
         server_service_binding: ServiceBinding,
         announcement: PeerAnnouncement,
     ) {
         if let Some(http_stats_event_sender) = self.opt_http_stats_event_sender.as_deref() {
             let event = Event::TcpAnnounce {
-                connection: event::ConnectionContext::new(remote_client_ip, opt_peer_ip_port, server_service_binding),
+                connection: event::ConnectionContext::new(remote_client_addr, server_service_binding),
                 info_hash,
                 announcement,
             };
@@ -323,6 +319,7 @@ mod tests {
             MockHttpStatsEventSender,
         };
         use crate::services::announce::AnnounceService;
+        use crate::services::RemoteClientAddr;
         use crate::tests::{sample_info_hash, sample_peer, sample_peer_using_ipv4, sample_peer_using_ipv6};
 
         #[tokio::test]
@@ -383,7 +380,10 @@ mod tests {
                     announcement.peer_addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(126, 0, 0, 1)), 8080);
 
                     let expected_event = Event::TcpAnnounce {
-                        connection: ConnectionContext::new(remote_client_ip, Some(8080), server_service_binding.clone()),
+                        connection: ConnectionContext::new(
+                            RemoteClientAddr::new(remote_client_ip, Some(8080)),
+                            server_service_binding.clone(),
+                        ),
                         info_hash: sample_info_hash(),
                         announcement,
                     };
@@ -457,7 +457,10 @@ mod tests {
                     );
 
                     let expected_event = Event::TcpAnnounce {
-                        connection: ConnectionContext::new(remote_client_ip, Some(8080), server_service_binding.clone()),
+                        connection: ConnectionContext::new(
+                            RemoteClientAddr::new(remote_client_ip, Some(8080)),
+                            server_service_binding.clone(),
+                        ),
                         info_hash: sample_info_hash(),
                         announcement: peer_announcement,
                     };
@@ -504,7 +507,10 @@ mod tests {
                 .expect_send_event()
                 .with(predicate::function(move |event| {
                     let expected_event = Event::TcpAnnounce {
-                        connection: ConnectionContext::new(remote_client_ip, Some(8080), server_service_binding.clone()),
+                        connection: ConnectionContext::new(
+                            RemoteClientAddr::new(remote_client_ip, Some(8080)),
+                            server_service_binding.clone(),
+                        ),
                         info_hash: sample_info_hash(),
                         announcement: peer,
                     };

packages/http-tracker-core/src/services/mod.rs

@@ -12,15 +12,28 @@ use bittorrent_http_tracker_protocol::v1::services::peer_ip_resolver::{self, Cli
 pub mod announce;
 pub mod scrape;
 
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub struct RemoteClientAddr {
+    pub ip: IpAddr,
+    pub port: Option<u16>,
+}
+
+impl RemoteClientAddr {
+    #[must_use]
+    pub fn new(ip: IpAddr, port: Option<u16>) -> Self {
+        Self { ip, port }
+    }
+}
+
 /// Resolves the client's real IP address considering proxy headers
 ///
 /// # Errors
 ///
 /// This function returns an error if the IP address cannot be resolved.
-pub fn resolve_remote_client_ip(
+pub fn resolve_remote_client_addr(
     on_reverse_proxy: bool,
     client_ip_sources: &ClientIpSources,
-) -> Result<(IpAddr, Option<u16>), PeerIpResolutionError> {
+) -> Result<RemoteClientAddr, PeerIpResolutionError> {
     let ip = match peer_ip_resolver::invoke(on_reverse_proxy, client_ip_sources) {
         Ok(peer_ip) => Ok(peer_ip),
         Err(error) => Err(error),
@@ -34,5 +47,5 @@ pub fn resolve_remote_client_ip(
         None
     };
 
-    Ok((ip, port))
+    Ok(RemoteClientAddr { ip, port })
 }

packages/http-tracker-core/src/services/scrape.rs

@@ -7,7 +7,6 @@
 //!
 //! It also sends an [`http_tracker_core::statistics::event::Event`]
 //! because events are specific for the HTTP tracker.
-use std::net::IpAddr;
 use std::sync::Arc;
 
 use bittorrent_http_tracker_protocol::v1::requests::scrape::Scrape;
@@ -20,7 +19,7 @@ use torrust_tracker_configuration::Core;
 use torrust_tracker_primitives::core::ScrapeData;
 use torrust_tracker_primitives::service_binding::ServiceBinding;
 
-use super::resolve_remote_client_ip;
+use super::{resolve_remote_client_addr, RemoteClientAddr};
 use crate::event;
 use crate::event::{ConnectionContext, Event};
 
@@ -82,11 +81,9 @@ impl ScrapeService {
             self.scrape_handler.scrape(&scrape_request.info_hashes).await?
         };
 
-        let (remote_client_ip, opt_client_port) =
-            resolve_remote_client_ip(self.core_config.net.on_reverse_proxy, client_ip_sources)?;
+        let remote_client_addr = resolve_remote_client_addr(self.core_config.net.on_reverse_proxy, client_ip_sources)?;
 
-        self.send_event(remote_client_ip, opt_client_port, server_service_binding.clone())
-            .await;
+        self.send_event(remote_client_addr, server_service_binding.clone()).await;
 
         Ok(scrape_data)
     }
@@ -103,15 +100,10 @@ impl ScrapeService {
         false
     }
 
-    async fn send_event(
-        &self,
-        original_peer_ip: IpAddr,
-        opt_original_peer_port: Option<u16>,
-        server_service_binding: ServiceBinding,
-    ) {
+    async fn send_event(&self, remote_client_addr: RemoteClientAddr, server_service_binding: ServiceBinding) {
         if let Some(http_stats_event_sender) = self.opt_http_stats_event_sender.as_deref() {
             let event = Event::TcpScrape {
-                connection: ConnectionContext::new(original_peer_ip, opt_original_peer_port, server_service_binding),
+                connection: ConnectionContext::new(remote_client_addr, server_service_binding),
             };
 
             tracing::debug!("Sending TcpScrape event: {:?}", event);
@@ -271,6 +263,7 @@ mod tests {
             initialize_services_with_configuration, sample_info_hashes, sample_peer, MockHttpStatsEventSender,
         };
         use crate::services::scrape::ScrapeService;
+        use crate::services::RemoteClientAddr;
         use crate::tests::sample_info_hash;
         use crate::{event, statistics};
 
@@ -342,8 +335,7 @@ mod tests {
                 .expect_send_event()
                 .with(eq(Event::TcpScrape {
                     connection: ConnectionContext::new(
-                        IpAddr::V4(Ipv4Addr::new(126, 0, 0, 1)),
-                        Some(8080),
+                        RemoteClientAddr::new(IpAddr::V4(Ipv4Addr::new(126, 0, 0, 1)), Some(8080)),
                         ServiceBinding::new(Protocol::HTTP, SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 7070))
                             .unwrap(),
                     ),
@@ -394,8 +386,10 @@ mod tests {
                 .expect_send_event()
                 .with(eq(Event::TcpScrape {
                     connection: ConnectionContext::new(
-                        IpAddr::V6(Ipv6Addr::new(0x6969, 0x6969, 0x6969, 0x6969, 0x6969, 0x6969, 0x6969, 0x6969)),
-                        Some(8080),
+                        RemoteClientAddr::new(
+                            IpAddr::V6(Ipv6Addr::new(0x6969, 0x6969, 0x6969, 0x6969, 0x6969, 0x6969, 0x6969, 0x6969)),
+                            Some(8080),
+                        ),
                         server_service_binding,
                     ),
                 }))
@@ -453,6 +447,7 @@ mod tests {
             initialize_services_with_configuration, sample_info_hashes, sample_peer, MockHttpStatsEventSender,
         };
         use crate::services::scrape::ScrapeService;
+        use crate::services::RemoteClientAddr;
         use crate::tests::sample_info_hash;
         use crate::{event, statistics};
 
@@ -518,8 +513,7 @@ mod tests {
                 .expect_send_event()
                 .with(eq(Event::TcpScrape {
                     connection: ConnectionContext::new(
-                        IpAddr::V4(Ipv4Addr::new(126, 0, 0, 1)),
-                        Some(8080),
+                        RemoteClientAddr::new(IpAddr::V4(Ipv4Addr::new(126, 0, 0, 1)), Some(8080)),
                         ServiceBinding::new(Protocol::HTTP, SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 7070))
                             .unwrap(),
                     ),
@@ -570,8 +564,10 @@ mod tests {
                 .expect_send_event()
                 .with(eq(Event::TcpScrape {
                     connection: ConnectionContext::new(
-                        IpAddr::V6(Ipv6Addr::new(0x6969, 0x6969, 0x6969, 0x6969, 0x6969, 0x6969, 0x6969, 0x6969)),
-                        Some(8080),
+                        RemoteClientAddr::new(
+                            IpAddr::V6(Ipv6Addr::new(0x6969, 0x6969, 0x6969, 0x6969, 0x6969, 0x6969, 0x6969, 0x6969)),
+                            Some(8080),
+                        ),
                         server_service_binding,
                     ),
                 }))

packages/http-tracker-core/src/statistics/event/handler.rs

@@ -77,6 +77,7 @@ mod tests {
     use torrust_tracker_primitives::service_binding::{Protocol, ServiceBinding};
 
     use crate::event::{ConnectionContext, Event};
+    use crate::services::RemoteClientAddr;
     use crate::statistics::event::handler::handle_event;
     use crate::statistics::repository::Repository;
     use crate::tests::{sample_info_hash, sample_peer_using_ipv4, sample_peer_using_ipv6};
@@ -91,8 +92,7 @@ mod tests {
         handle_event(
             Event::TcpAnnounce {
                 connection: ConnectionContext::new(
-                    remote_client_ip,
-                    Some(8080),
+                    RemoteClientAddr::new(remote_client_ip, Some(8080)),
                     ServiceBinding::new(Protocol::HTTP, SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 7070)).unwrap(),
                 ),
                 info_hash: sample_info_hash(),
@@ -115,8 +115,7 @@ mod tests {
         handle_event(
             Event::TcpScrape {
                 connection: ConnectionContext::new(
-                    IpAddr::V4(Ipv4Addr::new(127, 0, 0, 2)),
-                    Some(8080),
+                    RemoteClientAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 2)), Some(8080)),
                     ServiceBinding::new(Protocol::HTTP, SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 7070)).unwrap(),
                 ),
             },
@@ -139,8 +138,7 @@ mod tests {
         handle_event(
             Event::TcpAnnounce {
                 connection: ConnectionContext::new(
-                    remote_client_ip,
-                    Some(8080),
+                    RemoteClientAddr::new(remote_client_ip, Some(8080)),
                     ServiceBinding::new(Protocol::HTTP, SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 7070)).unwrap(),
                 ),
                 info_hash: sample_info_hash(),
@@ -163,8 +161,10 @@ mod tests {
         handle_event(
             Event::TcpScrape {
                 connection: ConnectionContext::new(
-                    IpAddr::V6(Ipv6Addr::new(0x6969, 0x6969, 0x6969, 0x6969, 0x6969, 0x6969, 0x6969, 0x6969)),
-                    Some(8080),
+                    RemoteClientAddr::new(
+                        IpAddr::V6(Ipv6Addr::new(0x6969, 0x6969, 0x6969, 0x6969, 0x6969, 0x6969, 0x6969, 0x6969)),
+                        Some(8080),
+                    ),
                     ServiceBinding::new(Protocol::HTTP, SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 7070)).unwrap(),
                 ),
             },