Wrap HTTP client errors and make converions private

Author: niklasf

src/clients/hyper_client.rs

@@ -1,11 +1,11 @@
 use async_trait::async_trait;
 use http::header::RETRY_AFTER;
-use hyper::{body::HttpBody, client::HttpConnector, Body, Client, Request as HttpRequest};
+use hyper::{Body, Client, Request as HttpRequest, body::HttpBody, client::HttpConnector};
 use hyper_tls::HttpsConnector;
 
 use crate::{
-    clients::{request_builder, WebPushClient, MAX_RESPONSE_SIZE},
-    error::{RetryAfter, WebPushError},
+    clients::{MAX_RESPONSE_SIZE, WebPushClient, request_builder},
+    error::{WebPushError, parse_retry_after},
     message::WebPushMessage,
 };
 
@@ -54,23 +54,25 @@ impl WebPushClient for HyperWebPushClient {
 
         let requesting = self.client.request(request);
 
-        let response = requesting.await?;
+        let response = requesting
+            .await
+            .map_err(|err| WebPushError::ClientError(Box::new(err)))?;
 
         trace!("Response: {:?}", response);
 
         let retry_after = response
             .headers()
             .get(RETRY_AFTER)
             .and_then(|ra| ra.to_str().ok())
-            .and_then(RetryAfter::from_str);
+            .and_then(parse_retry_after);
 
         let response_status = response.status();
         trace!("Response status: {}", response_status);
 
         let mut chunks = response.into_body();
         let mut body = Vec::new();
         while let Some(chunk) = chunks.data().await {
-            body.extend(&chunk?);
+            body.extend(&chunk.map_err(|err| WebPushError::ClientError(Box::new(err)))?);
             if body.len() > MAX_RESPONSE_SIZE {
                 return Err(WebPushError::ResponseTooLarge);
             }

src/clients/isahc_client.rs

@@ -4,8 +4,8 @@ use http::header::RETRY_AFTER;
 use isahc::HttpClient;
 
 use crate::{
-    clients::{request_builder, WebPushClient, MAX_RESPONSE_SIZE},
-    error::{RetryAfter, WebPushError},
+    clients::{MAX_RESPONSE_SIZE, WebPushClient, request_builder},
+    error::{WebPushError, parse_retry_after},
     message::WebPushMessage,
 };
 
@@ -38,7 +38,7 @@ impl IsahcWebPushClient {
     /// Creates a new client. Can fail under resource depletion.
     pub fn new() -> Result<Self, WebPushError> {
         Ok(Self {
-            client: HttpClient::new()?,
+            client: HttpClient::new().map_err(|err| WebPushError::ClientError(Box::new(err)))?,
         })
     }
 }
@@ -55,15 +55,17 @@ impl WebPushClient for IsahcWebPushClient {
 
         let requesting = self.client.send_async(request);
 
-        let response = requesting.await?;
+        let response = requesting
+            .await
+            .map_err(|err| WebPushError::ClientError(Box::new(err)))?;
 
         trace!("Response: {:?}", response);
 
         let retry_after = response
             .headers()
             .get(RETRY_AFTER)
             .and_then(|ra| ra.to_str().ok())
-            .and_then(RetryAfter::from_str);
+            .and_then(parse_retry_after);
 
         let response_status = response.status();
         trace!("Response status: {}", response_status);
@@ -73,7 +75,8 @@ impl WebPushClient for IsahcWebPushClient {
             .into_body()
             .take(MAX_RESPONSE_SIZE as u64 + 1)
             .read_to_end(&mut body)
-            .await?
+            .await
+            .map_err(|err| WebPushError::ClientError(Box::new(err)))?
             > MAX_RESPONSE_SIZE
         {
             return Err(WebPushError::ResponseTooLarge);

src/error.rs

@@ -28,10 +28,13 @@ impl fmt::Display for ErrorInfo {
     }
 }
 
+/// Web push failed.
 #[derive(Debug)]
+#[non_exhaustive]
 pub enum WebPushError {
-    /// An unknown error happened while encrypting or sending the message
-    Unspecified,
+    /// HTTP client error (network, DNS, TLS, protocol-level HTTP) while trying
+    /// to send the notification.
+    ClientError(Box<dyn Error>),
     /// Please provide valid credentials to send the notification
     Unauthorized(ErrorInfo),
     /// Request was badly formed
@@ -93,20 +96,6 @@ impl From<InvalidUri> for WebPushError {
     }
 }
 
-#[cfg(feature = "hyper-client")]
-impl From<hyper::Error> for WebPushError {
-    fn from(_: hyper::Error) -> Self {
-        Self::Unspecified
-    }
-}
-
-#[cfg(feature = "isahc-client")]
-impl From<isahc::Error> for WebPushError {
-    fn from(_: isahc::Error) -> Self {
-        Self::Unspecified
-    }
-}
-
 impl From<IoError> for WebPushError {
     fn from(err: IoError) -> WebPushError {
         WebPushError::Io(err)
@@ -116,7 +105,7 @@ impl From<IoError> for WebPushError {
 impl WebPushError {
     pub fn short_description(&self) -> &'static str {
         match *self {
-            WebPushError::Unspecified => "unspecified",
+            WebPushError::ClientError(_) => "client_error",
             WebPushError::Unauthorized(_) => "unauthorized",
             WebPushError::BadRequest(_) => "bad_request",
             WebPushError::ServerError { .. } => "server_error",
@@ -142,7 +131,7 @@ impl WebPushError {
 impl fmt::Display for WebPushError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            WebPushError::Unspecified => write!(f, "unspecified error"),
+            WebPushError::ClientError(err) => write!(f, "client error: {}", err),
             WebPushError::Unauthorized(info) => write!(f, "unauthorized: {}", info),
             WebPushError::BadRequest(info) => write!(f, "bad request: {}", info),
             WebPushError::ServerError { info, .. } => write!(f, "server error: {}", info),
@@ -168,21 +157,18 @@ impl fmt::Display for WebPushError {
     }
 }
 
-pub struct RetryAfter;
-impl RetryAfter {
-    pub fn from_str(header_value: &str) -> Option<Duration> {
-        if let Ok(seconds) = header_value.parse::<u64>() {
-            Some(Duration::from_secs(seconds))
-        } else {
-            chrono::DateTime::parse_from_rfc2822(header_value)
-                .map(|date_time| {
-                    let systime: SystemTime = date_time.into();
+pub fn parse_retry_after(header_value: &str) -> Option<Duration> {
+    if let Ok(seconds) = header_value.parse::<u64>() {
+        Some(Duration::from_secs(seconds))
+    } else {
+        chrono::DateTime::parse_from_rfc2822(header_value)
+            .map(|date_time| {
+                let systime: SystemTime = date_time.into();
 
-                    systime
-                        .duration_since(SystemTime::now())
-                        .unwrap_or_else(|_| Duration::new(0, 0))
-                })
-                .ok()
-        }
+                systime
+                    .duration_since(SystemTime::now())
+                    .unwrap_or_else(|_| Duration::new(0, 0))
+            })
+            .ok()
     }
 }

src/message.rs

@@ -58,6 +58,7 @@ pub struct WebPushPayload {
     pub content_encoding: ContentEncoding,
 }
 
+/// Urgency of a web push message.
 #[derive(Debug, Deserialize, Serialize, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Default, Hash)]
 #[serde(rename_all = "kebab-case")]
 pub enum Urgency {