Replace iron with routerify

Author: rnestler

Cargo.toml

@@ -27,9 +27,8 @@ edition = "2018"
 r2d2 = "^0.8.7"
 redis = { version = "^0.21.1", features = ['r2d2'] }
 log = "^0.4"
-iron = "^0.6.1"
-urlencoded = "^0.6"
-router = "^0.6"
+routerify = "3.0.0"
+hyper = "^0.14"
 serde = "^1.0"
 serde_json = "^1.0"
 spaceapi = "^0.8.1"

src/lib.rs

@@ -188,15 +188,14 @@
 
 pub use spaceapi as api;
 
-pub use iron::error::HttpResult;
-pub use iron::Listening;
+//pub use iron::error::HttpResult;
+//pub use iron::Listening;
 
 mod errors;
 pub mod modifiers;
 mod sensors;
 mod server;
 mod types;
-
 pub use crate::errors::SpaceapiServerError;
 pub use crate::server::SpaceapiServer;
 pub use crate::server::SpaceapiServerBuilder;

src/server/handlers.rs

@@ -1,10 +1,10 @@
 //! Handlers for the server.
 
-use iron::modifiers::Header;
-use iron::prelude::*;
-use iron::{headers, middleware, status};
+// use iron::modifiers::Header;
+// use iron::prelude::*;
+// use iron::{headers, middleware, status};
 use log::{debug, error, info, warn};
-use router::Router;
+// use router::Router;
 use serde::ser::{Serialize, SerializeMap, Serializer};
 
 use crate::api;
@@ -98,6 +98,7 @@ impl ReadHandler {
     }
 }
 
+/*
 impl middleware::Handler for ReadHandler {
     /// Return the current status JSON.
     fn handle(&self, req: &mut Request) -> IronResult<Response> {
@@ -120,6 +121,7 @@ impl middleware::Handler for ReadHandler {
         Ok(response)
     }
 }
+*/
 
 pub(crate) struct UpdateHandler {
     redis_pool: RedisPool,
@@ -147,6 +149,7 @@ impl UpdateHandler {
         sensor_spec.set_sensor_value(&self.redis_pool, value)
     }
 
+    /*
     /// Build an OK response with the `HTTP 204 No Content` status code.
     fn ok_response(&self) -> Response {
         Response::with(status::NoContent)
@@ -176,8 +179,10 @@ impl UpdateHandler {
             ])))
             .set(Header(headers::AccessControlAllowOrigin::Any))
     }
+    */
 }
 
+/*
 impl middleware::Handler for UpdateHandler {
     /// Update the sensor, return correct status code.
     fn handle(&self, req: &mut Request) -> IronResult<Response> {
@@ -226,6 +231,7 @@ impl middleware::Handler for UpdateHandler {
         Ok(self.ok_response())
     }
 }
+*/
 
 #[cfg(test)]
 mod tests {

src/server/mod.rs

@@ -3,11 +3,14 @@
 use std::net::ToSocketAddrs;
 use std::sync::Arc;
 use std::time::Duration;
+use std::convert::Infallible;
+use std::error::Error;
 
-use iron::Iron;
+// use iron::Iron;
 use log::debug;
 use redis::{ConnectionInfo, IntoConnectionInfo};
-use router::Router;
+use hyper::{Body, Request, Response, Server};
+use routerify::{Router, RouterService};
 
 use serde_json::map::Map;
 use serde_json::Value;
@@ -171,41 +174,43 @@ pub struct SpaceapiServer {
 
 impl SpaceapiServer {
     /// Create and return a Router instance.
-    fn route(self) -> Router {
-        let mut router = Router::new();
-
-        router.get(
-            "/",
-            handlers::ReadHandler::new(
-                self.status.clone(),
-                self.redis_pool.clone(),
-                self.sensor_specs.clone(),
-                self.status_modifiers,
-            ),
-            "root",
-        );
-
-        router.put(
+    fn route(self) -> Router<Body, Infallible> {
+        Router::builder()
+            /*
+            .get( "/", handlers::ReadHandler::new(
+                    self.status.clone(),
+                    self.redis_pool.clone(),
+                    self.sensor_specs.clone(),
+                    self.status_modifiers,
+                    )
+                )
+                */
+            .build()
+            .unwrap()
+            /*
+        .put(
             "/sensors/:sensor/",
             handlers::UpdateHandler::new(self.redis_pool.clone(), self.sensor_specs),
             "sensors",
-        );
-
-        router
+        )
+        */
     }
 
     /// Start a HTTP server listening on ``self.host:self.port``.
     ///
     /// The call returns an `HttpResult<Listening>` object, see
     /// http://ironframework.io/doc/hyper/server/struct.Listening.html
     /// for more information.
-    pub fn serve<S: ToSocketAddrs>(self, socket_addr: S) -> crate::HttpResult<crate::Listening> {
+    pub async fn serve<S: ToSocketAddrs>(self, socket_addr: S) -> Result<(), Box<dyn Error>> {
         // Launch server process
         let router = self.route();
         println!("Starting HTTP server on:");
         for a in socket_addr.to_socket_addrs()? {
             println!("\thttp://{}", a);
         }
-        Iron::new(router).http(socket_addr)
+        let service = RouterService::new(router).unwrap();
+
+        let server = Server::bind(&socket_addr.to_socket_addrs().unwrap().next().unwrap()).serve(service);
+        Ok(server.await?)
     }
 }