Merge pull request #8 from milesgranger/async-server

Switch to Actix-Web

Author: milesgranger

Cargo.lock

@@ -4,15 +4,15 @@ version = "0.1.0"
 authors = ["Miles Granger <miles59923@gmail.com>"]
 
 [dependencies]
-log = "0.4.0"
-clap = "2.32.0"
-env_logger = "0.5.12"
-ndarray = "0.11.1"
+log = "0.4"
+clap = "2.32"
+env_logger = "0.5"
+ndarray = "0.11"
 netcdf = {git = "https://github.com/mhiley/rust-netcdf.git"}
-glob = "0.2.11"
-serde_json = "1.0.11"
-serde = "1.0.29"
-serde_derive = "1.0.29"
-rocket = "0.3.6"
-rocket_codegen = "0.3.6"
-rocket_contrib = {features = ["json", "tera_templates"], version = "*", default-features = false}
+glob = "0.2"
+serde_json = "1.0"
+serde = "1.0"
+serde_derive = "1.0"
+actix-web = "0.7"
+actix = "0.7"
+tera = "0.11"

Cargo.toml

@@ -3,6 +3,9 @@ FROM debian:jessie-slim
 RUN apt update && apt install -y \
     libnetcdf-dev
 
+# build passes --build-arg DONTCACHE=$(date) to keep the steps below from being cached
+ARG DONTCACHE=1
+
 RUN mkdir /data
 WORKDIR /server
 COPY ./target/release/elevation-api /server

Dockerfile-Server

@@ -7,5 +7,5 @@ docker run --rm -v $(pwd):/build/ milesg/elevation-api-builder:latest
 echo "Completed building binary at $(pwd)/build/"
 
 echo "Building server"
-docker build . -t milesg/elevation-api-server:latest --file ./Dockerfile-Server
+docker build . -t milesg/elevation-api-server:latest --file ./Dockerfile-Server --build-arg NOCACHE=$(date +%s)
 echo "Built server, run with : 'docker run --rm -d -p 8000:8000 -v $(pwd)/processed_netcdf_files/:/data/ milesg/elevation-api-server:latest'"

build-images.sh

@@ -135,8 +135,8 @@ pub struct Elevation {
 }
 
 #[derive(Serialize)]
-pub struct ElevationResponse {
-    pub points: Vec<Elevation>
+pub struct Elevations {
+    pub elevations: Vec<Elevation>
 }
 
 /// Load a created summary.json file; holds information about what coordiantes belong to which file

src/elevation/mod.rs

@@ -1,24 +1,17 @@
 use std::str::FromStr;
 use std::num::ParseFloatError;
-use rocket::request;
-use rocket::http;
 
 
 /// Struct to represent a JSON query parameter for a given location
-#[derive(FromForm, Serialize, Deserialize)]
+#[derive(Serialize, Deserialize)]
 pub struct Points {
-    pub points: CoordinateList
+    pub points: Vec<(f64, f64)>
 }
 
 
-/// Struct to represent the core value of the Points struct
-/// list of tuples representing (lat, lon) values
-#[derive(Debug, Serialize, Deserialize)]
-pub struct CoordinateList(pub Vec<(f64, f64)>);
-
 
 /// Implement FromStr for CoordinateList to parse the coordinate list from the request query
-impl FromStr for CoordinateList {
+impl FromStr for Points {
 
     type Err = ParseFloatError;
 
@@ -47,21 +40,6 @@ impl FromStr for CoordinateList {
             parsed_points.push((parsed_vec[0], parsed_vec[1]));
         }
 
-        Ok(CoordinateList(parsed_points))
-    }
-}
-
-
-/// Implement for Rocket to parse the value from the request, which will implicitly invoke the
-/// FromStr impl above.
-impl<'v> request::FromFormValue<'v> for CoordinateList {
-    type Error = &'v http::RawStr;
-
-    fn from_form_value(form_value: &'v http::RawStr) -> Result<CoordinateList, &'v http::RawStr> {
-        match form_value.parse::<CoordinateList>() {
-            Ok(points) => Ok(points),
-            _ => Err(form_value)
-        }
+        Ok(Points { points: parsed_points })
     }
 }
-

src/json_structs.rs

@@ -1,26 +1,29 @@
-#![feature(plugin, custom_derive)]
-#![plugin(rocket_codegen)]
-pub extern crate rocket;
-pub extern crate rocket_contrib;
+#[macro_use] pub extern crate serde_derive;
+#[macro_use] pub extern crate log;
 pub extern crate netcdf;
 pub extern crate ndarray;
 pub extern crate glob;
 pub extern crate serde;
 pub extern crate serde_json;
-#[macro_use] pub extern crate serde_derive;
-#[macro_use] extern crate log;
-extern crate env_logger;
+pub extern crate actix_web;
+pub extern crate env_logger;
 extern crate clap;
+extern crate actix;
+#[macro_use]
+extern crate tera;
 
 
+use actix_web::{
+    error, http, middleware, server, App, Error, HttpResponse, HttpRequest, Query, Responder, State, fs, Json, Form, Result
+};
+
 use std::collections::HashMap;
-use std::path::{Path, PathBuf};
 use std::env;
-use clap::{Arg, App, SubCommand};
+use std::str::FromStr;
+
+use clap::{Arg, App as ClapApp, SubCommand};
 use glob::glob;
-use rocket_contrib::{Json, Template};
-use rocket::response::status::BadRequest;
-use rocket::response::NamedFile;
+
 
 // Local mods
 #[cfg(test)]
@@ -29,49 +32,51 @@ mod elevation;
 mod json_structs;
 use json_structs::{Points};
 
+
+struct AppState {
+    template: tera::Tera,
+}
+
 // Sanity check
-#[get("/")]
-fn index() -> Template {
+fn index((state, _query): (State<AppState>, Query<HashMap<String, String>>)) -> Result<HttpResponse, Error> {
     let mut context = HashMap::new();
     context.insert("title".to_string(), "Free Elevation API".to_string());
 
+    let s = state
+        .template
+        .render("index.html", &context)
+        .unwrap();
+
+    Ok(HttpResponse::Ok().content_type("text/html").body(s))
 
-    Template::render("index", &context)
 }
 
+// Main API for 90m resolution
+fn get_elevations(req: &HttpRequest<AppState>) -> impl Responder {
 
-#[get("/<file..>")]
-fn static_files(file: PathBuf) -> Option<NamedFile> {
-    NamedFile::open(Path::new("static/").join(file)).ok()
-}
+    let points_str = req.query().get("points").unwrap().to_owned();
+    info!("Got the points string!");
+    let metas = elevation::load_summary_file();
+    let points = Points::from_str(&points_str).expect("Unable to parse points!");
 
+    let elevations = elevation::get_elevations(points.points, &metas);
+    let elevations_resp = elevation::Elevations{ elevations };
+
+    Json(elevations_resp)
 
-// Main API for 90m resolution
-#[get("/api/elevation?<points>")]
-fn get_elevations(points: Option<Points>) -> Result<Json<elevation::ElevationResponse>, BadRequest<String>> {
-
-    match points {
-        Some(points) => {
-            let metas = elevation::load_summary_file();
-            let elevations = elevation::get_elevations(points.points.0, &metas);
-
-            let elevation_response = elevation::ElevationResponse{points: elevations};
-            Ok(Json(elevation_response))
-        },
-        None => {
-            Err(BadRequest(Some("Unable to parse coordinates. Should be in form '(lat,lon),(lat,lon),(lat,lon)'".to_string())))
-        }
-    }
 
 }
 
 
 fn main() {
 
+    env::set_var("RUST_LOG", "actix_web=debug");
+    //env::set_var("RUST_BACKTRACE", "1");
+
     env_logger::init();
     info!("Starting up!");
 
-    let matches = App::new("Elevation API")
+    let matches = ClapApp::new("Elevation API")
         .version("1.0")
         .author("Miles Granger")
         .about("Web service and utility for giving elevations for locations on earth")
@@ -104,12 +109,47 @@ fn main() {
         elevation::make_summary_file(path);
 
     } else if let Some(m) = matches.subcommand_matches("run-server") {
+
         let summary_file = m.value_of("SUMMARY-FILE").expect("No path specified!");
+
         env::set_var("SUMMARY_FILE_PATH", summary_file);
-        rocket::ignite()
-            .mount("/", routes![index, get_elevations, static_files])
-            .attach(Template::fairing())
-            .launch();
+
+        // Server
+        let sys = actix::System::new("elevation-api");
+
+        server::new(|| {
+
+                let tera = compile_templates!("./templates/**/*");
+
+                App::with_state(AppState {template: tera})
+
+                    // Logging
+                    .middleware(middleware::Logger::default())
+
+                    // Application base route
+                    .prefix("/")
+
+                    // Static files
+                    .handler(
+                        "/static",
+                        fs::StaticFiles::new("static")
+                            .expect("Can't find static directory!")
+                            .show_files_listing())
+
+                    // Homepage
+                    .resource("/", |r| r.method(http::Method::GET).with(index))
+
+                    // Main elevation API
+                    .resource("/api/elevation", |r| r.method(http::Method::GET).f(get_elevations))
+            })
+            .bind("0.0.0.0:8000")
+            .expect("Unable to bind to 0.0.0.0:8000")
+            .start();
+
+        info!("Started server running on 0.0.0.0:8000");
+        let _ = sys.run();
+
+
     } else {
         warn!("Nothing to do, exiting!");
     }

src/main.rs

@@ -16,15 +16,15 @@ fn test_v1_0_0_query() {
           }
     */
     use self::super::get_elevations_v1_0_0;
-    use self::super::elevation::{ElevationResponse, Elevation};
+    use self::super::elevation::{Elevations, Elevation};
 
     // Parse a query into a points object
     let points = Points {
         points: CoordinateList::from_str("(48.35,5.3),(48.35,5.23)").unwrap()
     };
 
     // Get elevations from the function
-    let elevations: ElevationResponse = get_elevations_v1_0_0(Some(points)).ok().unwrap().0;
+    let elevations: Elevations = get_elevations_v1_0_0(Some(points)).ok().unwrap().0;
 
     // Ensure that the first element == 48.35 which guarantees the version promised format.
     let point: &Elevation = &elevations.points[0];