Merge #1472: Enrich HTTP core Event::TcpAnnounce event

a422e4e refactor: extract type RemoteClientAddr (Jose Celano)
7ed7500 refactor: extract fn for duplicate code (Jose Celano)
bc02e9b feat: [#1376] add info-hash to bittorrent_http_tracker_core::event::TcpAnnounce (Jose Celano)
657a5d0 refactor: [#1376] remove initial peer state from event. Only the peer IP may change (Jose Celano)
92f049e tests: add tests for HTTP tracker core events comparison (Jose Celano)
4566ad5 test: add test for Peer comparison (Jose Celano)
5d479b7 chore: add logs for sending TcpScrape event (Jose Celano)
a67e137 feat: [#1376] add peer info to TcpAnnounce event (Jose Celano)

Pull request description:

  Added `info_hash` and `announcement` (peer announce request data):

  ```rust
  pub enum Event {
      TcpAnnounce {
          connection: ConnectionContext,
          info_hash: InfoHash,
          announcement: PeerAnnouncement,
      },
      TcpScrape {
          connection: ConnectionContext,
      },
  }
  ```

ACKs for top commit:
  josecelano:
    ACK a422e4e

Tree-SHA512: 8e37284cc2171ed0dc71c791d4ac033a212050955e78f70345ed37ce5e3346ea62da4119b55ba4643b0366375114a5b296af4ced654b0908cff6baba01cdd3ef

Author: josecelano

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

@@ -1,16 +1,26 @@
 use std::net::{IpAddr, SocketAddr};
 
+use bittorrent_primitives::info_hash::InfoHash;
 use torrust_tracker_metrics::label::{LabelSet, LabelValue};
 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.
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub enum Event {
-    TcpAnnounce { connection: ConnectionContext },
-    TcpScrape { connection: ConnectionContext },
+    TcpAnnounce {
+        connection: ConnectionContext,
+        info_hash: InfoHash,
+        announcement: PeerAnnouncement,
+    },
+    TcpScrape {
+        connection: ConnectionContext,
+    },
 }
 
 #[derive(Debug, PartialEq, Eq, Clone)]
@@ -21,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,
             },
@@ -35,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]
@@ -51,10 +58,19 @@ impl ConnectionContext {
 
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub struct ClientConnectionContext {
-    ip_addr: IpAddr,
+    remote_client_addr: RemoteClientAddr,
+}
 
-    /// It's provided if you use the `torrust-axum-http-tracker-server` crate.
-    port: Option<u16>,
+impl ClientConnectionContext {
+    #[must_use]
+    pub fn ip_addr(&self) -> IpAddr {
+        self.remote_client_addr.ip
+    }
+
+    #[must_use]
+    pub fn port(&self) -> Option<u16> {
+        self.remote_client_addr.port
+    }
 }
 
 #[derive(Debug, PartialEq, Eq, Clone)]
@@ -80,3 +96,72 @@ impl From<ConnectionContext> for LabelSet {
         ])
     }
 }
+
+#[cfg(test)]
+pub mod test {
+
+    use torrust_tracker_primitives::peer::Peer;
+    use torrust_tracker_primitives::service_binding::Protocol;
+
+    use super::Event;
+    use crate::services::RemoteClientAddr;
+    use crate::tests::sample_info_hash;
+
+    #[must_use]
+    pub fn events_match(event: &Event, expected_event: &Event) -> bool {
+        match (event, expected_event) {
+            (
+                Event::TcpAnnounce {
+                    connection,
+                    info_hash,
+                    announcement,
+                },
+                Event::TcpAnnounce {
+                    connection: expected_connection,
+                    info_hash: expected_info_hash,
+                    announcement: expected_announcement,
+                },
+            ) => {
+                *connection == *expected_connection
+                    && *info_hash == *expected_info_hash
+                    && announcement.peer_addr == expected_announcement.peer_addr
+            }
+            _ => false,
+        }
+    }
+
+    #[test]
+    fn events_should_be_comparable() {
+        use std::net::{IpAddr, Ipv4Addr, SocketAddr};
+
+        use torrust_tracker_primitives::service_binding::ServiceBinding;
+
+        use crate::event::{ConnectionContext, Event};
+
+        let remote_client_ip = IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1));
+        let info_hash = sample_info_hash();
+
+        let event1 = Event::TcpAnnounce {
+            connection: ConnectionContext::new(
+                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,
+            announcement: Peer::default(),
+        };
+
+        let event2 = Event::TcpAnnounce {
+            connection: ConnectionContext::new(
+                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,
+            announcement: Peer::default(),
+        };
+
+        let event1_clone = event1.clone();
+
+        assert!(event1 == event1_clone);
+        assert!(event1 != event2);
+    }
+}

packages/http-tracker-core/src/lib.rs

@@ -20,7 +20,11 @@ pub const HTTP_TRACKER_LOG_TARGET: &str = "HTTP TRACKER";
 
 #[cfg(test)]
 pub(crate) mod tests {
+    use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr};
+
+    use aquatic_udp_protocol::{AnnounceEvent, NumberOfBytes, PeerId};
     use bittorrent_primitives::info_hash::InfoHash;
+    use torrust_tracker_primitives::{peer, DurationSinceUnixEpoch};
 
     /// # Panics
     ///
@@ -31,4 +35,29 @@ pub(crate) mod tests {
             .parse::<InfoHash>()
             .expect("String should be a valid info hash")
     }
+
+    pub fn sample_peer_using_ipv4() -> peer::Peer {
+        sample_peer()
+    }
+
+    pub fn sample_peer_using_ipv6() -> peer::Peer {
+        let mut peer = sample_peer();
+        peer.peer_addr = SocketAddr::new(
+            IpAddr::V6(Ipv6Addr::new(0x6969, 0x6969, 0x6969, 0x6969, 0x6969, 0x6969, 0x6969, 0x6969)),
+            8080,
+        );
+        peer
+    }
+
+    pub fn sample_peer() -> peer::Peer {
+        peer::Peer {
+            peer_id: PeerId(*b"-qB00000000000000000"),
+            peer_addr: SocketAddr::new(IpAddr::V4(Ipv4Addr::new(126, 0, 0, 1)), 8080),
+            updated: DurationSinceUnixEpoch::new(1_669_397_478_934, 0),
+            uploaded: NumberOfBytes::new(0),
+            downloaded: NumberOfBytes::new(0),
+            left: NumberOfBytes::new(0),
+            event: AnnounceEvent::Started,
+        }
+    }
 }