dev: located error for http

Author: da2ce7

src/http/error.rs

@@ -1,34 +1,40 @@
+use std::panic::Location;
+
 use thiserror::Error;
 use warp::reject::Reject;
 
+use crate::located_error::LocatedError;
+
 #[derive(Error, Debug)]
 pub enum Error {
-    #[error("internal server error")]
-    InternalServer,
-
-    #[error("info_hash is either missing or invalid")]
-    InvalidInfo,
-
-    #[error("peer_id is either missing or invalid")]
-    InvalidPeerId,
-
-    #[error("could not find remote address")]
-    AddressNotFound,
-
-    #[error("torrent has no peers")]
-    NoPeersFound,
-
-    #[error("torrent not on whitelist")]
-    TorrentNotWhitelisted,
-
-    #[error("peer not authenticated")]
-    PeerNotAuthenticated,
-
-    #[error("invalid authentication key")]
-    PeerKeyNotValid,
-
-    #[error("exceeded info_hash limit")]
-    ExceededInfoHashLimit,
+    #[error("tracker server error: {source}")]
+    TrackerError {
+        source: LocatedError<'static, dyn std::error::Error + Send + Sync>,
+    },
+
+    #[error("internal server error: {message}, {location}")]
+    InternalServer {
+        location: &'static Location<'static>,
+        message: String,
+    },
+
+    #[error("no valid infohashes found, {location}")]
+    EmptyInfoHash { location: &'static Location<'static> },
+
+    #[error("peer_id is either missing or invalid, {location}")]
+    InvalidPeerId { location: &'static Location<'static> },
+
+    #[error("could not find remote address: {message}, {location}")]
+    AddressNotFound {
+        location: &'static Location<'static>,
+        message: String,
+    },
+
+    #[error("too many infohashes: {message}, {location}")]
+    TwoManyInfoHashes {
+        location: &'static Location<'static>,
+        message: String,
+    },
 }
 
 impl Reject for Error {}

src/http/filters.rs

@@ -1,5 +1,6 @@
 use std::convert::Infallible;
 use std::net::{IpAddr, SocketAddr};
+use std::panic::Location;
 use std::str::FromStr;
 use std::sync::Arc;
 
@@ -87,9 +88,14 @@ fn info_hashes(raw_query: &String) -> WebResult<Vec<InfoHash>> {
     }
 
     if info_hashes.len() > MAX_SCRAPE_TORRENTS as usize {
-        Err(reject::custom(Error::ExceededInfoHashLimit))
+        Err(reject::custom(Error::TwoManyInfoHashes {
+            location: Location::caller(),
+            message: format! {"found: {}, but limit is: {}",info_hashes.len(), MAX_SCRAPE_TORRENTS},
+        }))
     } else if info_hashes.is_empty() {
-        Err(reject::custom(Error::InvalidInfo))
+        Err(reject::custom(Error::EmptyInfoHash {
+            location: Location::caller(),
+        }))
     } else {
         Ok(info_hashes)
     }
@@ -114,7 +120,9 @@ fn peer_id(raw_query: &String) -> WebResult<peer::Id> {
 
             // peer_id must be 20 bytes
             if peer_id_bytes.len() != 20 {
-                return Err(reject::custom(Error::InvalidPeerId));
+                return Err(reject::custom(Error::InvalidPeerId {
+                    location: Location::caller(),
+                }));
             }
 
             // clone peer_id_bytes into fixed length array
@@ -128,18 +136,26 @@ fn peer_id(raw_query: &String) -> WebResult<peer::Id> {
 
     match peer_id {
         Some(id) => Ok(id),
-        None => Err(reject::custom(Error::InvalidPeerId)),
+        None => Err(reject::custom(Error::InvalidPeerId {
+            location: Location::caller(),
+        })),
     }
 }
 
 /// Get `PeerAddress` from `RemoteAddress` or Forwarded
 fn peer_addr((on_reverse_proxy, remote_addr, x_forwarded_for): (bool, Option<SocketAddr>, Option<String>)) -> WebResult<IpAddr> {
     if !on_reverse_proxy && remote_addr.is_none() {
-        return Err(reject::custom(Error::AddressNotFound));
+        return Err(reject::custom(Error::AddressNotFound {
+            location: Location::caller(),
+            message: "neither on have remote address or on a reverse proxy".to_string(),
+        }));
     }
 
     if on_reverse_proxy && x_forwarded_for.is_none() {
-        return Err(reject::custom(Error::AddressNotFound));
+        return Err(reject::custom(Error::AddressNotFound {
+            location: Location::caller(),
+            message: "must have a x-forwarded-for when using a reverse proxy".to_string(),
+        }));
     }
 
     if on_reverse_proxy {
@@ -151,7 +167,14 @@ fn peer_addr((on_reverse_proxy, remote_addr, x_forwarded_for): (bool, Option<Soc
         // set client ip to last forwarded ip
         let x_forwarded_ip = *x_forwarded_ips.last().unwrap();
 
-        IpAddr::from_str(x_forwarded_ip).map_err(|_| reject::custom(Error::AddressNotFound))
+        IpAddr::from_str(x_forwarded_ip).map_err(|e| {
+            reject::custom(Error::AddressNotFound {
+                location: Location::caller(),
+                message: format!(
+                    "on remote proxy and unable to parse the last x-forwarded-ip: `{e}`, from `{x_forwarded_for_raw}`"
+                ),
+            })
+        })
     } else {
         Ok(remote_addr.unwrap().ip())
     }

src/http/handlers.rs

@@ -1,6 +1,7 @@
 use std::collections::HashMap;
 use std::convert::Infallible;
 use std::net::IpAddr;
+use std::panic::Location;
 use std::sync::Arc;
 
 use log::debug;
@@ -16,17 +17,18 @@ use crate::tracker::{self, auth, peer, statistics, torrent};
 ///
 /// # Errors
 ///
-/// Will return `ServerError` that wraps the `Error` if unable to `authenticate_request`.
+/// Will return `ServerError` that wraps the `tracker::error::Error` if unable to `authenticate_request`.
 pub async fn authenticate(
     info_hash: &InfoHash,
     auth_key: &Option<auth::Key>,
     tracker: Arc<tracker::Tracker>,
 ) -> Result<(), Error> {
-    tracker.authenticate_request(info_hash, auth_key).await.map_err(|e| match e {
-        tracker::error::Error::TorrentNotWhitelisted { info_hash, location } => Error::TorrentNotWhitelisted,
-        tracker::error::Error::PeerNotAuthenticated { location } => Error::PeerNotAuthenticated,
-        tracker::error::Error::PeerKeyNotValid { key, source } => Error::PeerKeyNotValid,
-    })
+    tracker
+        .authenticate_request(info_hash, auth_key)
+        .await
+        .map_err(|e| Error::TrackerError {
+            source: (Arc::new(e) as Arc<dyn std::error::Error + Send + Sync>).into(),
+        })
 }
 
 /// Handle announce request
@@ -39,9 +41,7 @@ pub async fn handle_announce(
     auth_key: Option<auth::Key>,
     tracker: Arc<tracker::Tracker>,
 ) -> WebResult<impl Reply> {
-    authenticate(&announce_request.info_hash, &auth_key, tracker.clone())
-        .await
-        .map_err(reject::custom)?;
+    authenticate(&announce_request.info_hash, &auth_key, tracker.clone()).await?;
 
     debug!("{:?}", announce_request);
 
@@ -158,7 +158,10 @@ fn send_announce_response(
     if let Some(1) = announce_request.compact {
         match res.write_compact() {
             Ok(body) => Ok(Response::new(body)),
-            Err(_) => Err(reject::custom(Error::InternalServer)),
+            Err(e) => Err(reject::custom(Error::InternalServer {
+                message: e.to_string(),
+                location: Location::caller(),
+            })),
         }
     } else {
         Ok(Response::new(res.write().into()))
@@ -171,7 +174,10 @@ fn send_scrape_response(files: HashMap<InfoHash, response::ScrapeEntry>) -> WebR
 
     match res.write() {
         Ok(body) => Ok(Response::new(body)),
-        Err(_) => Err(reject::custom(Error::InternalServer)),
+        Err(e) => Err(reject::custom(Error::InternalServer {
+            message: e.to_string(),
+            location: Location::caller(),
+        })),
     }
 }
 
@@ -181,15 +187,21 @@ fn send_scrape_response(files: HashMap<InfoHash, response::ScrapeEntry>) -> WebR
 ///
 /// Will not return a error, `Infallible`, but instead  convert the `ServerError` into a `Response`.
 pub fn send_error(r: &Rejection) -> std::result::Result<impl Reply, Infallible> {
-    let body = if let Some(server_error) = r.find::<Error>() {
-        debug!("{:?}", server_error);
+    let warp_reject_error = r.find::<Error>();
+
+    let body = if let Some(error) = warp_reject_error {
+        debug!("{:?}", error);
         response::Error {
-            failure_reason: server_error.to_string(),
+            failure_reason: error.to_string(),
         }
         .write()
     } else {
         response::Error {
-            failure_reason: Error::InternalServer.to_string(),
+            failure_reason: Error::InternalServer {
+                message: "Undefined".to_string(),
+                location: Location::caller(),
+            }
+            .to_string(),
         }
         .write()
     };

tests/http/asserts.rs

@@ -91,7 +91,7 @@ pub async fn assert_invalid_info_hash_error_response(response: Response) {
 
     assert_error_bencoded(
         &response.text().await.unwrap(),
-        "info_hash is either missing or invalid",
+        "no valid infohashes found",
         Location::caller(),
     );
 }
@@ -109,25 +109,21 @@ pub async fn assert_invalid_peer_id_error_response(response: Response) {
 pub async fn assert_torrent_not_in_whitelist_error_response(response: Response) {
     assert_eq!(response.status(), 200);
 
-    assert_error_bencoded(
-        &response.text().await.unwrap(),
-        "torrent not on whitelist",
-        Location::caller(),
-    );
+    assert_error_bencoded(&response.text().await.unwrap(), "is not whitelisted", Location::caller());
 }
 
 pub async fn assert_peer_not_authenticated_error_response(response: Response) {
     assert_eq!(response.status(), 200);
 
-    assert_error_bencoded(&response.text().await.unwrap(), "peer not authenticated", Location::caller());
+    assert_error_bencoded(
+        &response.text().await.unwrap(),
+        "The peer is not authenticated",
+        Location::caller(),
+    );
 }
 
 pub async fn assert_invalid_authentication_key_error_response(response: Response) {
     assert_eq!(response.status(), 200);
 
-    assert_error_bencoded(
-        &response.text().await.unwrap(),
-        "invalid authentication key",
-        Location::caller(),
-    );
+    assert_error_bencoded(&response.text().await.unwrap(), "is not valid", Location::caller());
 }