feat(http): [#191] add route and extractor for scrape req in Axum HTTP tracker

with only one infohash in the URL:

http://localhost:7070/scrape?info_hash=%3B%24U%04%CF%5F%11%BB%DB%E1%20%1C%EAjk%F4Z%EE%1B%C0

It does not allow more than one infohas yet.

Author: josecelano

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/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/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,19 @@
+use std::sync::Arc;
+
+use axum::extract::State;
+use log::debug;
+
+use crate::http::axum_implementation::extractors::remote_client_ip::RemoteClientIp;
+use crate::http::axum_implementation::extractors::scrape_request::ExtractRequest;
+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,
+) -> String {
+    debug!("http scrape request: {:#?}", &scrape_request);
+
+    format!("{:#?}", &scrape_request)
+}

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)
 }

src/http/axum_implementation/requests/mod.rs

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

src/http/axum_implementation/requests/scrape.rs

@@ -0,0 +1,137 @@
+use std::panic::Location;
+
+use thiserror::Error;
+
+use crate::http::axum_implementation::query::Query;
+use crate::http::axum_implementation::responses;
+use crate::http::percent_encoding::percent_decode_info_hash;
+use crate::located_error::{Located, LocatedError};
+use crate::protocol::info_hash::{ConversionError, InfoHash};
+
+pub type NumberOfBytes = i64;
+
+// Query param name
+const INFO_HASH_SCRAPE_PARAM: &str = "info_hash";
+
+#[derive(Debug, PartialEq)]
+pub struct Scrape {
+    pub info_hashes: Vec<InfoHash>,
+}
+
+#[derive(Error, Debug)]
+pub enum ParseScrapeQueryError {
+    #[error("missing query params for scrape request in {location}")]
+    MissingParams { location: &'static Location<'static> },
+    #[error("missing param {param_name} in {location}")]
+    MissingParam {
+        location: &'static Location<'static>,
+        param_name: String,
+    },
+    #[error("invalid param value {param_value} for {param_name} in {location}")]
+    InvalidParam {
+        param_name: String,
+        param_value: String,
+        location: &'static Location<'static>,
+    },
+    #[error("invalid param value {param_value} for {param_name} in {source}")]
+    InvalidInfoHashParam {
+        param_name: String,
+        param_value: String,
+        source: LocatedError<'static, ConversionError>,
+    },
+}
+
+impl From<ParseScrapeQueryError> for responses::error::Error {
+    fn from(err: ParseScrapeQueryError) -> Self {
+        responses::error::Error {
+            failure_reason: format!("Cannot parse query params for scrape request: {err}"),
+        }
+    }
+}
+
+impl TryFrom<Query> for Scrape {
+    type Error = ParseScrapeQueryError;
+
+    fn try_from(query: Query) -> Result<Self, Self::Error> {
+        Ok(Self {
+            info_hashes: extract_info_hashes(&query)?,
+        })
+    }
+}
+
+fn extract_info_hashes(query: &Query) -> Result<Vec<InfoHash>, ParseScrapeQueryError> {
+    match query.get_param(INFO_HASH_SCRAPE_PARAM) {
+        Some(raw_param) => {
+            let mut info_hashes = vec![];
+
+            // todo: multiple infohashes
+
+            let info_hash = percent_decode_info_hash(&raw_param).map_err(|err| ParseScrapeQueryError::InvalidInfoHashParam {
+                param_name: INFO_HASH_SCRAPE_PARAM.to_owned(),
+                param_value: raw_param.clone(),
+                source: Located(err).into(),
+            })?;
+
+            info_hashes.push(info_hash);
+
+            Ok(info_hashes)
+        }
+        None => {
+            return Err(ParseScrapeQueryError::MissingParam {
+                location: Location::caller(),
+                param_name: INFO_HASH_SCRAPE_PARAM.to_owned(),
+            })
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    mod scrape_request {
+
+        use crate::http::axum_implementation::query::Query;
+        use crate::http::axum_implementation::requests::scrape::{Scrape, INFO_HASH_SCRAPE_PARAM};
+        use crate::protocol::info_hash::InfoHash;
+
+        #[test]
+        fn should_be_instantiated_from_the_url_query_with_only_one_infohash() {
+            let raw_query = Query::from(vec![(
+                INFO_HASH_SCRAPE_PARAM,
+                "%3B%24U%04%CF%5F%11%BB%DB%E1%20%1C%EAjk%F4Z%EE%1B%C0",
+            )])
+            .to_string();
+
+            let query = raw_query.parse::<Query>().unwrap();
+
+            let scrape_request = Scrape::try_from(query).unwrap();
+
+            assert_eq!(
+                scrape_request,
+                Scrape {
+                    info_hashes: vec!["3b245504cf5f11bbdbe1201cea6a6bf45aee1bc0".parse::<InfoHash>().unwrap()],
+                }
+            );
+        }
+
+        mod when_it_is_instantiated_from_the_url_query_params {
+
+            use crate::http::axum_implementation::query::Query;
+            use crate::http::axum_implementation::requests::scrape::{Scrape, INFO_HASH_SCRAPE_PARAM};
+
+            #[test]
+            fn it_should_fail_if_the_query_does_not_include_the_info_hash_param() {
+                let raw_query_without_info_hash = "another_param=NOT_RELEVANT";
+
+                assert!(Scrape::try_from(raw_query_without_info_hash.parse::<Query>().unwrap()).is_err());
+            }
+
+            #[test]
+            fn it_should_fail_if_the_info_hash_param_is_invalid() {
+                let raw_query = Query::from(vec![(INFO_HASH_SCRAPE_PARAM, "INVALID_INFO_HASH_VALUE")]).to_string();
+
+                assert!(Scrape::try_from(raw_query.parse::<Query>().unwrap()).is_err());
+            }
+        }
+    }
+}

src/http/axum_implementation/routes.rs

@@ -4,15 +4,17 @@ use axum::routing::get;
 use axum::Router;
 use axum_client_ip::SecureClientIpSource;
 
-use super::handlers::announce::handle;
-use super::handlers::status::get_status_handler;
+use super::handlers::{announce, scrape, status};
 use crate::tracker::Tracker;
 
 pub fn router(tracker: &Arc<Tracker>) -> Router {
     Router::new()
         // Status
-        .route("/status", get(get_status_handler))
+        .route("/status", get(status::handle))
         // Announce request
-        .route("/announce", get(handle).with_state(tracker.clone()))
+        .route("/announce", get(announce::handle).with_state(tracker.clone()))
+        // Scrape request
+        .route("/scrape", get(scrape::handle).with_state(tracker.clone()))
+        // Add extension to get the client IP from the connection info
         .layer(SecureClientIpSource::ConnectInfo.into_extension())
 }