Add Error handling

Author: sh-oo-bi

src/main.rs

@@ -1,15 +1,32 @@
 use rand::Rng;
 use serde::Serialize;
 use std::collections::HashMap;
-use warp::{Filter, Rejection};
+use warp::{http::StatusCode, reject::Reject, Filter, Rejection, Reply};
 
 #[derive(Debug, Serialize)]
 struct Randnum {
     num: i32,
 }
 
+#[derive(Debug)]
+enum Error {
+    ParseError(std::num::ParseIntError),
+    BadRange,
+}
+
+impl Reject for Error {}
+
+impl std::fmt::Display for Error {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        match *self {
+            Error::ParseError(ref err) => write!(f, "Cannot parse parameter: {}", err),
+            Error::BadRange => write!(f, "BadRange"),
+        }
+    }
+}
+
 impl Randnum {
-    fn new(start: Option<i32>, end: Option<i32>) -> Self {
+    fn new(start: Option<i32>, end: Option<i32>) -> Result<Self, Rejection> {
         let start = match start {
             Some(n) => n,
             _ => 1,
@@ -20,29 +37,45 @@ impl Randnum {
             _ => 1000,
         };
 
+        if start <= 0 || end <= 0 || end < start {
+            return Err(warp::reject::custom(Error::BadRange));
+        }
+
         let random = {
             let mut rng = rand::thread_rng();
             rng.gen_range(start..=end)
         };
 
-        Self { num: random }
+        Ok(Self { num: random })
+    }
+}
+
+async fn return_error(r: Rejection) -> Result<impl Reply, Rejection> {
+    if let Some(error) = r.find::<Error>() {
+        Ok(warp::reply::with_status(
+            error.to_string(),
+            StatusCode::RANGE_NOT_SATISFIABLE,
+        ))
+    } else {
+        Ok(warp::reply::with_status(
+            "Route not found".to_string(),
+            StatusCode::NOT_FOUND,
+        ))
     }
 }
 
-async fn get_random(params: HashMap<String, String>) -> Result<impl warp::Reply, Rejection> {
+async fn get_random(params: HashMap<String, String>) -> Result<impl Reply, Rejection> {
     let start = match params.get("start") {
-        Some(n) => Some(n.parse::<i32>().expect("Could not parse start")),
+        Some(n) => Some(n.parse::<i32>().map_err(Error::ParseError)?),
         None => None,
     };
 
     let end = match params.get("end") {
-        Some(n) => Some(n.parse::<i32>().expect("Could not parse end")),
+        Some(n) => Some(n.parse::<i32>().map_err(Error::ParseError)?),
         None => None,
     };
 
-    println!("start:{:?}, end:{:?}", start, end);
-
-    let random_number = Randnum::new(start, end);
+    let random_number = Randnum::new(start, end)?;
 
     Ok(warp::reply::json(&random_number))
 }
@@ -55,6 +88,7 @@ async fn main() {
         .and(warp::query())
         .and_then(get_random);
 
-    let route = get_random;
-    warp::serve(route).run(([127, 0, 0, 1], 1337)).await;
+    let routes = get_random.recover(return_error);
+
+    warp::serve(routes).run(([127, 0, 0, 1], 1337)).await;
 }