Use a real router.

Author: tomprince

Cargo.lock

@@ -19,10 +19,12 @@ hyper = { git = "https://github.com/hyperium/hyper.git" }
 kernel32-sys = "0.2.2"
 lazy_static = "0.2"
 libc = "0.2.7"
+mime = "0.2.3"
 rand = "0.3"
 ref_slice = "1.1.1"
 reqwest = "0.6"
 result = "0.0.1"
+route-recognizer = "0.1.12"
 scopeguard = "0.3"
 semver = "0.6"
 serde = "1.0"

Cargo.toml

@@ -40,7 +40,10 @@ extern crate result;
 extern crate ref_slice;
 extern crate crates_index;
 extern crate hyper;
+#[macro_use]
+extern crate mime;
 extern crate arc_cell;
+extern crate route_recognizer;
 
 #[macro_use]
 pub mod log;

src/lib.rs

@@ -1,36 +1,42 @@
 use arc_cell::ArcCell;
-use futures::{self, Future, Stream};
+use futures::{self, BoxFuture, Future, Stream};
 use futures_cpupool::CpuPool;
 use hyper::{self, Get, Post, StatusCode};
 use hyper::header::{ContentLength, ContentType};
 use hyper::server::{Http, Request, Response, Service};
+use route_recognizer::{Match, Params, Router};
 
 use serde::Serialize;
 use serde::de::DeserializeOwned;
 use serde_json;
 use std::env;
-use std::fs::File;
-use std::io::Read;
 use std::net::SocketAddr;
-use std::path::Path;
 use std::str;
 use std::sync::Arc;
 
 mod api;
 
 pub struct Data;
 
+type Handler = fn(&Server, Request, Params) -> BoxFuture<Response, hyper::Error>;
 struct Server {
+    router: Router<Handler>,
     data: ArcCell<Data>,
     pool: CpuPool,
 }
 
 impl Server {
-    fn handle_get<F, S>(&self, req: &Request, handler: F) -> <Server as Service>::Future
+    fn handle_get<F, S>(&self,
+                        req: Request,
+                        _params: Params,
+                        handler: F)
+                        -> <Server as Service>::Future
         where F: FnOnce(&Data) -> S,
               S: Serialize
     {
-        assert_eq!(*req.method(), Get);
+        if *req.method() != Get {
+            return self.error(StatusCode::BadRequest);
+        };
         let data = self.data.get();
         let result = handler(&data);
         let response = Response::new()
@@ -39,12 +45,31 @@ impl Server {
         futures::future::ok(response).boxed()
     }
 
-    fn handle_post<F, D, S>(&self, req: Request, handler: F) -> <Server as Service>::Future
+    fn handle_static(&self,
+                     req: Request,
+                     _params: Params,
+                     content_type: ContentType,
+                     body: &'static str)
+                     -> <Server as Service>::Future {
+        if *req.method() != Get {
+            return self.error(StatusCode::BadRequest);
+        };
+        let response = Response::new().with_header(content_type).with_body(body);
+        futures::future::ok(response).boxed()
+    }
+
+    fn handle_post<F, D, S>(&self,
+                            req: Request,
+                            _params: Params,
+                            handler: F)
+                            -> <Server as Service>::Future
         where F: FnOnce(D, &Data) -> S + Send + 'static,
               D: DeserializeOwned,
               S: Serialize
     {
-        assert_eq!(*req.method(), Post);
+        if *req.method() != Post {
+            return self.error(StatusCode::BadRequest);
+        };
         let length = req.headers()
             .get::<ContentLength>()
             .expect("content-length to exist")
@@ -82,59 +107,62 @@ impl Server {
             })
             .boxed()
     }
+
+    fn error(&self, status: StatusCode) -> <Server as Service>::Future {
+        futures::future::ok(Response::new()
+                                .with_header(ContentType::html())
+                                .with_status(status))
+                .boxed()
+    }
 }
 
 impl Service for Server {
     type Request = Request;
     type Response = Response;
     type Error = hyper::Error;
-    type Future = Box<Future<Item = Self::Response, Error = Self::Error>>;
+    type Future = BoxFuture<Self::Response, Self::Error>;
 
     fn call(&self, req: Request) -> Self::Future {
-        let fs_path = format!("static{}",
-                              if req.path() == "" || req.path() == "/" {
-                                  "/index.html"
-                              } else {
-                                  req.path()
-                              });
-
-        info!("handling: req.path()={:?}, fs_path={:?}",
-              req.path(),
-              fs_path);
-
-        if fs_path.contains("./") | fs_path.contains("../") {
-            return futures::future::ok(Response::new()
-                                           .with_header(ContentType::html())
-                                           .with_status(StatusCode::NotFound))
-                           .boxed();
-        }
+        info!("handling: req.path()={:?}", req.path());
 
-        if Path::new(&fs_path).is_file() {
-            return self.pool
-                       .spawn_fn(move || {
-                                     let mut f = File::open(&fs_path).unwrap();
-                                     let mut source = Vec::new();
-                                     f.read_to_end(&mut source).unwrap();
-                                     futures::future::ok(Response::new().with_body(source))
-                                 })
-                       .boxed();
+        match self.router.recognize(req.path()) {
+            Ok(Match { handler, params }) => handler(self, req, params),
+            Err(_) => self.error(StatusCode::NotFound),
         }
 
-        match req.path() {
-            "/api/get" => self.handle_get(&req, api::get::handler),
-            "/api/post" => self.handle_post(req, api::post::handler),
-            _ => {
-                futures::future::ok(Response::new()
-                                        .with_header(ContentType::html())
-                                        .with_status(StatusCode::NotFound))
-                        .boxed()
-            }
-        }
+
     }
 }
 
+macro_rules! route {
+    ($router:ident, $path:expr, $method:ident, $($handler:tt)* ) => (
+        $router.add($path,
+            |server: &Server, req, params| server.$method(req, params, $($handler)*));
+    )
+}
+
 pub fn start(data: Data) {
+    let mut router = Router::<Handler>::new();
+    route!(router, "/api/get", handle_get, api::get::handler);
+    route!(router, "/api/post", handle_post, api::post::handler);
+    route!(router,
+           "/static/report.html",
+           handle_static,
+           ContentType::html(),
+           include_str!("../../static/report.html"));
+    route!(router,
+           "/static/report.js",
+           handle_static,
+           ContentType(mime!(Application / Javascript)),
+           include_str!("../../static/report.js"));
+    route!(router,
+           "/static/report.css",
+           handle_static,
+           ContentType(mime!(Text / Css)),
+           include_str!("../../static/report.css"));
+
     let server = Arc::new(Server {
+                              router,
                               data: ArcCell::new(Arc::new(data)),
                               pool: CpuPool::new_num_cpus(),
                           });