refactor: rename UDP tracker server error variants

Author: josecelano

packages/udp-tracker-server/src/error.rs

@@ -17,47 +17,47 @@ pub struct ConnectionCookie(pub ConnectionId);
 pub enum Error {
     /// Error returned when the request is invalid.
     #[error("error parsing request: {request_parse_error:?}")]
-    RequestParseError { request_parse_error: SendableRequestParseError },
+    InvalidRequest { request_parse_error: SendableRequestParseError },
 
     /// Error returned when the domain tracker returns an announce error.
     #[error("tracker announce error: {source}")]
-    UdpAnnounceError { source: UdpAnnounceError },
+    AnnounceFailed { source: UdpAnnounceError },
 
     /// Error returned when the domain tracker returns an scrape error.
     #[error("tracker scrape error: {source}")]
-    UdpScrapeError { source: UdpScrapeError },
+    ScrapeFailed { source: UdpScrapeError },
 
     /// Error returned from a third-party library (`aquatic_udp_protocol`).
     #[error("internal server error: {message}, {location}")]
-    InternalServer {
+    Internal {
         location: &'static Location<'static>,
         message: String,
     },
 
     /// Error returned when tracker requires authentication.
     #[error("domain tracker requires authentication but is not supported in current UDP implementation. Location: {location}")]
-    TrackerAuthenticationRequired { location: &'static Location<'static> },
+    AuthRequired { location: &'static Location<'static> },
 }
 
 impl From<RequestParseError> for Error {
     fn from(request_parse_error: RequestParseError) -> Self {
-        Self::RequestParseError {
+        Self::InvalidRequest {
             request_parse_error: request_parse_error.into(),
         }
     }
 }
 
 impl From<UdpAnnounceError> for Error {
     fn from(udp_announce_error: UdpAnnounceError) -> Self {
-        Self::UdpAnnounceError {
+        Self::AnnounceFailed {
             source: udp_announce_error,
         }
     }
 }
 
 impl From<UdpScrapeError> for Error {
     fn from(udp_scrape_error: UdpScrapeError) -> Self {
-        Self::UdpScrapeError {
+        Self::ScrapeFailed {
             source: udp_scrape_error,
         }
     }

packages/udp-tracker-server/src/event.rs

@@ -129,24 +129,24 @@ pub enum ErrorKind {
 impl From<Error> for ErrorKind {
     fn from(error: Error) -> Self {
         match error {
-            Error::RequestParseError { request_parse_error } => Self::RequestParse(request_parse_error.to_string()),
-            Error::UdpAnnounceError { source } => match source {
+            Error::InvalidRequest { request_parse_error } => Self::RequestParse(request_parse_error.to_string()),
+            Error::AnnounceFailed { source } => match source {
                 UdpAnnounceError::ConnectionCookieError { source } => Self::ConnectionCookie(source.to_string()),
                 UdpAnnounceError::TrackerCoreAnnounceError { source } => match source {
                     AnnounceError::Whitelist(whitelist_error) => Self::Whitelist(whitelist_error.to_string()),
                     AnnounceError::Database(error) => Self::Database(error.to_string()),
                 },
                 UdpAnnounceError::TrackerCoreWhitelistError { source } => Self::Whitelist(source.to_string()),
             },
-            Error::UdpScrapeError { source } => match source {
+            Error::ScrapeFailed { source } => match source {
                 UdpScrapeError::ConnectionCookieError { source } => Self::ConnectionCookie(source.to_string()),
                 UdpScrapeError::TrackerCoreScrapeError { source } => match source {
                     ScrapeError::Whitelist(whitelist_error) => Self::Whitelist(whitelist_error.to_string()),
                 },
                 UdpScrapeError::TrackerCoreWhitelistError { source } => Self::Whitelist(source.to_string()),
             },
-            Error::InternalServer { location: _, message } => Self::InternalServer(message.to_string()),
-            Error::TrackerAuthenticationRequired { location } => Self::TrackerAuthentication(location.to_string()),
+            Error::Internal { location: _, message } => Self::InternalServer(message.to_string()),
+            Error::AuthRequired { location } => Self::TrackerAuthentication(location.to_string()),
         }
     }
 }

packages/udp-tracker-server/src/handlers/mod.rs

@@ -101,7 +101,7 @@ pub(crate) async fn handle_packet(
             Err(e) => {
                 // The request payload could not be parsed, so we handle it as an error.
 
-                let opt_transaction_id = if let Error::RequestParseError { request_parse_error } = e.clone() {
+                let opt_transaction_id = if let Error::InvalidRequest { request_parse_error } = e.clone() {
                     request_parse_error.opt_transaction_id
                 } else {
                     None