Axum HTTP tracker: scrape response in public mode

Cargo.toml

@@ -62,6 +62,7 @@ axum = "0.6.1"
 axum-server = { version = "0.4.4", features = ["tls-rustls"] }
 axum-client-ip = "0.4.0"
 bip_bencode = "0.4.4"
+multimap = "0.8.3"
 
 
 [dev-dependencies]

cSpell.json

@@ -37,6 +37,7 @@
         "Lphant",
         "middlewares",
         "mockall",
+        "multimap",
         "myacicontext",
         "nanos",
         "nextest",

src/http/axum_implementation/extractors/mod.rs

@@ -1,3 +1,4 @@
 pub mod announce_request;
 pub mod peer_ip;
 pub mod remote_client_ip;
+pub mod scrape_request;

src/http/axum_implementation/extractors/peer_ip.rs

@@ -31,7 +31,7 @@ impl From<ResolutionError> for responses::error::Error {
 ///
 /// Will return an error if the peer IP cannot be obtained according to the configuration.
 /// For example, if the IP is extracted from an HTTP header which is missing in the request.
-pub fn assign_ip_address_to_peer(on_reverse_proxy: bool, remote_client_ip: &RemoteClientIp) -> Result<IpAddr, Response> {
+pub fn resolve(on_reverse_proxy: bool, remote_client_ip: &RemoteClientIp) -> Result<IpAddr, Response> {
     if on_reverse_proxy {
         if let Some(ip) = remote_client_ip.right_most_x_forwarded_for {
             Ok(ip)

src/http/axum_implementation/extractors/scrape_request.rs

@@ -0,0 +1,45 @@
+use std::panic::Location;
+
+use axum::async_trait;
+use axum::extract::FromRequestParts;
+use axum::http::request::Parts;
+use axum::response::{IntoResponse, Response};
+
+use crate::http::axum_implementation::query::Query;
+use crate::http::axum_implementation::requests::scrape::{ParseScrapeQueryError, Scrape};
+use crate::http::axum_implementation::responses;
+
+pub struct ExtractRequest(pub Scrape);
+
+#[async_trait]
+impl<S> FromRequestParts<S> for ExtractRequest
+where
+    S: Send + Sync,
+{
+    type Rejection = Response;
+
+    async fn from_request_parts(parts: &mut Parts, _state: &S) -> Result<Self, Self::Rejection> {
+        let raw_query = parts.uri.query();
+
+        if raw_query.is_none() {
+            return Err(responses::error::Error::from(ParseScrapeQueryError::MissingParams {
+                location: Location::caller(),
+            })
+            .into_response());
+        }
+
+        let query = raw_query.unwrap().parse::<Query>();
+
+        if let Err(error) = query {
+            return Err(responses::error::Error::from(error).into_response());
+        }
+
+        let scrape_request = Scrape::try_from(query.unwrap());
+
+        if let Err(error) = scrape_request {
+            return Err(responses::error::Error::from(error).into_response());
+        }
+
+        Ok(ExtractRequest(scrape_request.unwrap()))
+    }
+}

src/http/axum_implementation/handlers/announce.rs

@@ -7,7 +7,7 @@ use axum::response::{IntoResponse, Response};
 use log::debug;
 
 use crate::http::axum_implementation::extractors::announce_request::ExtractRequest;
-use crate::http::axum_implementation::extractors::peer_ip::assign_ip_address_to_peer;
+use crate::http::axum_implementation::extractors::peer_ip;
 use crate::http::axum_implementation::extractors::remote_client_ip::RemoteClientIp;
 use crate::http::axum_implementation::requests::announce::{Announce, Compact, Event};
 use crate::http::axum_implementation::responses::announce;
@@ -24,7 +24,7 @@ pub async fn handle(
 ) -> Response {
     debug!("http announce request: {:#?}", announce_request);
 
-    let peer_ip = match assign_ip_address_to_peer(tracker.config.on_reverse_proxy, &remote_client_ip) {
+    let peer_ip = match peer_ip::resolve(tracker.config.on_reverse_proxy, &remote_client_ip) {
         Ok(peer_ip) => peer_ip,
         Err(err) => return err,
     };

src/http/axum_implementation/handlers/mod.rs

@@ -1,2 +1,3 @@
 pub mod announce;
+pub mod scrape;
 pub mod status;

src/http/axum_implementation/handlers/scrape.rs

@@ -0,0 +1,29 @@
+use std::sync::Arc;
+
+use axum::extract::State;
+use axum::response::{IntoResponse, Response};
+use log::debug;
+
+use crate::http::axum_implementation::extractors::peer_ip;
+use crate::http::axum_implementation::extractors::remote_client_ip::RemoteClientIp;
+use crate::http::axum_implementation::extractors::scrape_request::ExtractRequest;
+use crate::http::axum_implementation::{responses, services};
+use crate::tracker::Tracker;
+
+#[allow(clippy::unused_async)]
+pub async fn handle(
+    State(tracker): State<Arc<Tracker>>,
+    ExtractRequest(scrape_request): ExtractRequest,
+    remote_client_ip: RemoteClientIp,
+) -> Response {
+    debug!("http scrape request: {:#?}", &scrape_request);
+
+    let peer_ip = match peer_ip::resolve(tracker.config.on_reverse_proxy, &remote_client_ip) {
+        Ok(peer_ip) => peer_ip,
+        Err(err) => return err,
+    };
+
+    let scrape_data = services::scrape::invoke(tracker.clone(), &scrape_request.info_hashes, &peer_ip).await;
+
+    responses::scrape::Bencoded::from(scrape_data).into_response()
+}

src/http/axum_implementation/handlers/status.rs

@@ -7,6 +7,6 @@ use crate::http::axum_implementation::resources::ok::Ok;
 use crate::http::axum_implementation::responses::ok;
 
 #[allow(clippy::unused_async)]
-pub async fn get_status_handler(remote_client_ip: RemoteClientIp) -> Json<Ok> {
+pub async fn handle(remote_client_ip: RemoteClientIp) -> Json<Ok> {
     ok::response(&remote_client_ip)
 }