Merge pull request #79 from tomprince/server-refactor

Refactor the server to use a real(-ish) router and serve some actual results.

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

@@ -13,7 +13,7 @@ fn results_file(dest: &Path) -> PathBuf {
 }
 
 #[derive(Serialize, Deserialize)]
-struct TestResults {
+pub struct TestResults {
     crates: Vec<CrateResult>,
 }
 
@@ -40,13 +40,16 @@ struct BuildTestResult {
     log: String,
 }
 
-fn generate_report(ex: &ex::Experiment, dest: &Path) -> Result<TestResults> {
+
+pub fn generate_report(ex: &ex::Experiment, dest: Option<&Path>) -> Result<TestResults> {
     let db = FileDB::for_experiment(ex);
     assert_eq!(ex.toolchains.len(), 2);
 
-    fs::create_dir_all(dest)?;
-    let json = serde_json::to_string(&ex)?;
-    file::write_string(&dest.join("config.json"), &json)?;
+    if let Some(dest) = dest {
+        fs::create_dir_all(dest)?;
+        let json = serde_json::to_string(&ex)?;
+        file::write_string(&dest.join("config.json"), &json)?;
+    }
 
     let res = ex::ex_crates_and_dirs(ex)?
         .into_iter()
@@ -59,13 +62,15 @@ fn generate_report(ex: &ex::Experiment, dest: &Path) -> Result<TestResults> {
                     let res = writer.load_test_result()?;
                     // If there was no test result return an error
                     let res = res.ok_or_else(|| Error::from("no result"))?;
-                    let mut result_log = writer.read_log()?;
 
                     let rel_log = writer.result_path_fragement();
 
-                    // TODO: Seperate out writting log files so that they can
-                    // be served via HTTP directly instead.
-                    write_log_file(dest, &rel_log, &mut result_log)?;
+                    if let Some(dest) = dest {
+                        let mut result_log = writer.read_log()?;
+                        // TODO: Seperate out writting log files so that they can
+                        // be served via HTTP directly instead.
+                        write_log_file(dest, &rel_log, &mut result_log)?;
+                    }
 
                     Ok(BuildTestResult {
                            res: res,
@@ -93,7 +98,7 @@ fn generate_report(ex: &ex::Experiment, dest: &Path) -> Result<TestResults> {
 pub fn gen(ex_name: &str, dest: &Path) -> Result<()> {
     let ex = ex::Experiment::load(ex_name)?;
 
-    let res = generate_report(&ex, dest)?;
+    let res = generate_report(&ex, Some(dest))?;
     let json = serde_json::to_string(&res)?;
 
     info!("writing results to {}", results_file(dest).display());

src/report.rs

@@ -5,20 +5,21 @@
 //! The responses are calculated in the server.rs file.
 
 pub mod get {
-    use server::Data;
+    use server::{Data, Params};
 
     #[derive(Serialize, Deserialize)]
     pub struct Response {
         pub text: String,
     }
 
-    pub fn handler(_data: &Data) -> Response {
+    #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
+    pub fn handler(_data: &Data, _params: Params) -> Response {
         Response { text: String::from("This is a response!") }
     }
 }
 
 pub mod post {
-    use server::Data;
+    use server::{Data, Params};
 
     #[derive(Serialize, Deserialize)]
     pub struct Request {
@@ -31,7 +32,31 @@ pub mod post {
     }
 
     #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
-    pub fn handler(post: Request, _data: &Data) -> Response {
+    pub fn handler(post: Request, _data: &Data, _params: Params) -> Response {
         Response { out: format!("Got {}!", post.input) }
     }
 }
+
+pub mod ex_report {
+    use ex;
+    use report::{TestResults, generate_report};
+    use server::{Data, Params};
+
+    #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
+    pub fn handler(_data: &Data, params: Params) -> TestResults {
+        let ex_name = params.find("experiment").unwrap();
+        let ex = ex::Experiment::load(ex_name).unwrap();
+        generate_report(&ex, None).unwrap()
+    }
+}
+
+pub mod ex_config {
+    use ex;
+    use server::{Data, Params};
+
+    #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
+    pub fn handler(_data: &Data, params: Params) -> ex::Experiment {
+        let ex_name = params.find("experiment").unwrap();
+        ex::Experiment::load(ex_name).unwrap()
+    }
+}

src/server/api.rs

@@ -1,50 +1,76 @@
 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 =
+    Box<Fn(&Server, Request, Params) -> BoxFuture<Response, hyper::Error> + Sync + Send + 'static>;
 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
-        where F: FnOnce(&Data) -> S,
+    fn handle_get<F, S>(&self,
+                        req: Request,
+                        params: Params,
+                        handler: F)
+                        -> <Server as Service>::Future
+        where F: FnOnce(&Data, Params) -> 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 result = handler(&data, params);
         let response = Response::new()
             .with_header(ContentType::json())
             .with_body(serde_json::to_string(&result).unwrap());
         futures::future::ok(response).boxed()
     }
 
-    fn handle_post<F, D, S>(&self, req: Request, handler: F) -> <Server as Service>::Future
-        where F: FnOnce(D, &Data) -> S + Send + 'static,
+    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, Params) -> 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")
@@ -74,67 +100,78 @@ impl Server {
                                                               err));
                             }
                         };
-                        let result = handler(body, &data);
+                        let result = handler(body, &data, params);
                         Response::new()
                             .with_header(ContentType::json())
                             .with_body(serde_json::to_string(&result).unwrap())
                     })
             })
             .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,
+            Box::new(|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,
+           "/api/ex/:experiment/results",
+           handle_get,
+           api::ex_report::handler);
+    route!(router,
+           "/api/ex/:experiment/config",
+           handle_get,
+           api::ex_config::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(),
                           });