Update actix to latest stable version (#3752)

* rename main files

* simplify query param parsing; use askama template engine

* fix actix-pg update benchmark

* fix query benchmark

* update actix-web

frameworks/Rust/actix/Cargo.toml

@@ -1,18 +1,19 @@
 [package]
 name = "actix"
-version = "0.4.1"
+version = "0.5.0"
+build = "build.rs"
 
 [[bin]]
 name = "actix"
-path = "src/simple.rs"
+path = "src/main.rs"
 
 [[bin]]
 name = "actix-diesel"
-path = "src/main.rs"
+path = "src/main_diesel.rs"
 
 [[bin]]
 name = "actix-pg"
-path = "src/pg.rs"
+path = "src/main_pg.rs"
 
 [dependencies]
 askama = "0.6"
@@ -28,10 +29,12 @@ tokio-core = "=0.1.12"
 http = "0.1"
 diesel = { version = "1.2", features = ["postgres"] }
 postgres = "0.15"
-horrorshow = "0.6"
 
 actix = "0.5"
-actix-web = "^0.5"
+actix-web = { version = "^0.6", default-features = false }
+
+[build-dependencies]
+askama = "0.6"
 
 [profile.release]
 lto = true

frameworks/Rust/actix/build.rs

@@ -0,0 +1,5 @@
+extern crate askama;
+
+fn main() {
+    askama::rerun_if_templates_changed();
+}

frameworks/Rust/actix/src/db.rs

@@ -67,10 +67,7 @@ impl Handler<RandomWorlds> for DbExecutor {
         let mut worlds = Vec::with_capacity(msg.0 as usize);
         for _ in 0..msg.0 {
             let w_id = self.rng.gen_range(1, 10_000);
-            let w = match world
-                .filter(id.eq(w_id))
-                .load::<models::World>(&self.conn)
-            {
+            let w = match world.filter(id.eq(w_id)).load::<models::World>(&self.conn) {
                 Ok(mut items) => items.pop().unwrap(),
                 Err(_) => {
                     return Err(io::Error::new(io::ErrorKind::Other, "Database error"))
@@ -97,9 +94,7 @@ impl Handler<UpdateWorld> for DbExecutor {
         let mut worlds = Vec::with_capacity(msg.0);
         for _ in 0..msg.0 {
             let w_id = self.rng.gen_range::<i32>(1, 10_000);
-            let mut w = match world
-                .filter(id.eq(w_id))
-                .load::<models::World>(&self.conn)
+            let mut w = match world.filter(id.eq(w_id)).load::<models::World>(&self.conn)
             {
                 Ok(mut items) => items.pop().unwrap(),
                 Err(_) => {

frameworks/Rust/actix/src/main.rs

@@ -2,161 +2,53 @@ extern crate actix;
 extern crate actix_web;
 extern crate bytes;
 extern crate futures;
-extern crate num_cpus;
-extern crate rand;
 extern crate serde;
 extern crate serde_json;
 #[macro_use]
 extern crate serde_derive;
-#[macro_use]
-extern crate diesel;
-#[macro_use]
-extern crate horrorshow;
 
 use actix::prelude::*;
-use actix_web::{http, server, App, AsyncResponder, FutureResponse, HttpRequest,
-                HttpResponse};
+use actix_web::{http, server, App, HttpRequest, HttpResponse};
 use bytes::BytesMut;
-use diesel::prelude::{Connection, PgConnection};
-use futures::Future;
-use std::cmp;
 
-mod db;
-mod models;
-mod schema;
-mod tmpl;
 mod utils;
 use utils::Writer;
 
-struct State {
-    db: Addr<Syn, db::DbExecutor>,
-}
-
-fn world_row(req: HttpRequest<State>) -> FutureResponse<HttpResponse> {
-    req.clone()
-        .state()
-        .db
-        .send(db::RandomWorld)
-        .from_err()
-        .and_then(move |res| match res {
-            Ok(row) => {
-                let mut body = BytesMut::with_capacity(31);
-                serde_json::to_writer(Writer(&mut body), &row).unwrap();
-                Ok(HttpResponse::build_from(&req)
-                    .header(http::header::SERVER, "Actix")
-                    .content_type("application/json")
-                    .body(body))
-            }
-            Err(_) => Ok(HttpResponse::InternalServerError().into()),
-        })
-        .responder()
-}
-
-fn queries(req: HttpRequest<State>) -> FutureResponse<HttpResponse> {
-    // get queries parameter
-    let q = if let Some(q) = req.query().get("q") {
-        q.parse::<u16>().ok().unwrap_or(1)
-    } else {
-        1
-    };
-    let q = cmp::min(500, cmp::max(1, q));
+const SIZE: usize = 29;
 
-    // run sql queries
-    req.clone()
-        .state()
-        .db
-        .send(db::RandomWorlds(q))
-        .from_err()
-        .and_then(move |res| {
-            if let Ok(worlds) = res {
-                let mut body = BytesMut::with_capacity(35 * worlds.len());
-                serde_json::to_writer(Writer(&mut body), &worlds).unwrap();
-                Ok(HttpResponse::build_from(&req)
-                    .header(http::header::SERVER, "Actix")
-                    .content_type("application/json")
-                    .body(body))
-            } else {
-                Ok(HttpResponse::InternalServerError().into())
-            }
-        })
-        .responder()
+#[derive(Serialize, Deserialize)]
+pub struct Message {
+    pub message: &'static str,
 }
 
-fn updates(req: HttpRequest<State>) -> FutureResponse<HttpResponse> {
-    // get queries parameter
-    let q = if let Some(q) = req.query().get("q") {
-        q.parse::<usize>().ok().unwrap_or(1)
-    } else {
-        1
+fn json(req: HttpRequest) -> HttpResponse {
+    let message = Message {
+        message: "Hello, World!",
     };
-    let q = cmp::min(500, cmp::max(1, q));
+    let mut body = BytesMut::with_capacity(SIZE);
+    serde_json::to_writer(Writer(&mut body), &message).unwrap();
 
-    // update worlds
-    req.clone()
-        .state()
-        .db
-        .send(db::UpdateWorld(q))
-        .from_err()
-        .and_then(move |res| {
-            if let Ok(worlds) = res {
-                let mut body = BytesMut::with_capacity(35 * worlds.len());
-                serde_json::to_writer(Writer(&mut body), &worlds).unwrap();
-                Ok(HttpResponse::build_from(&req)
-                    .header(http::header::SERVER, "Actix")
-                    .content_type("application/json")
-                    .body(body))
-            } else {
-                Ok(HttpResponse::InternalServerError().into())
-            }
-        })
-        .responder()
+    HttpResponse::build_from(&req)
+        .header(http::header::SERVER, "Actix")
+        .header(http::header::CONTENT_TYPE, "application/json")
+        .body(body)
 }
 
-fn fortune(req: HttpRequest<State>) -> FutureResponse<HttpResponse> {
-    req.clone()
-        .state()
-        .db
-        .send(db::TellFortune)
-        .from_err()
-        .and_then(move |res| match res {
-            Ok(rows) => {
-                let res = tmpl::render_fortune(&rows);
-
-                Ok(HttpResponse::build_from(&req)
-                    .header(http::header::SERVER, "Actix")
-                    .content_type("text/html; charset=utf-8")
-                    .body(res))
-            }
-            Err(_) => Ok(HttpResponse::InternalServerError().into()),
-        })
-        .responder()
+fn plaintext(req: HttpRequest) -> HttpResponse {
+    HttpResponse::build_from(&req)
+        .header(http::header::SERVER, "Actix")
+        .header(http::header::CONTENT_TYPE, "text/plain")
+        .body("Hello, World!")
 }
 
 fn main() {
     let sys = System::new("techempower");
-    let db_url = "postgres://benchmarkdbuser:benchmarkdbpass@tfb-database/hello_world";
-
-    // Avoid triggering "FATAL: the database system is starting up" error from
-    // postgres.
-    {
-        if PgConnection::establish(db_url).is_err() {
-            std::thread::sleep(std::time::Duration::from_secs(5));
-        }
-    }
-
-    // Start db executor actors
-    let addr = SyncArbiter::start(num_cpus::get() * 4, move || {
-        db::DbExecutor::new(db_url)
-    });
 
     // start http server
     server::new(move || {
-        App::with_state(State { db: addr.clone() })
-            .default_encoding(http::ContentEncoding::Identity)
-            .resource("/db", |r| r.route().a(world_row))
-            .resource("/fortune", |r| r.route().a(fortune))
-            .resource("/queries", |r| r.route().a(queries))
-            .resource("/updates", |r| r.route().a(updates))
+        App::new()
+            .resource("/json", |r| r.f(json))
+            .resource("/plaintext", |r| r.f(plaintext))
     }).backlog(8192)
         .bind("0.0.0.0:8080")
         .unwrap()

frameworks/Rust/actix/src/main_diesel.rs

@@ -0,0 +1,172 @@
+extern crate actix;
+extern crate actix_web;
+extern crate bytes;
+extern crate futures;
+extern crate num_cpus;
+extern crate rand;
+extern crate serde;
+extern crate serde_json;
+#[macro_use]
+extern crate serde_derive;
+#[macro_use]
+extern crate diesel;
+#[macro_use]
+extern crate askama;
+
+use actix::prelude::*;
+use actix_web::{
+    http, server, App, AsyncResponder, FutureResponse, HttpRequest, HttpResponse,
+};
+use askama::Template;
+use bytes::BytesMut;
+use diesel::prelude::{Connection, PgConnection};
+use futures::Future;
+use std::cmp;
+
+mod db;
+mod models;
+mod schema;
+mod utils;
+use utils::Writer;
+
+struct State {
+    db: Addr<Syn, db::DbExecutor>,
+}
+
+fn world_row(req: HttpRequest<State>) -> FutureResponse<HttpResponse> {
+    req.clone()
+        .state()
+        .db
+        .send(db::RandomWorld)
+        .from_err()
+        .and_then(move |res| match res {
+            Ok(row) => {
+                let mut body = BytesMut::with_capacity(31);
+                serde_json::to_writer(Writer(&mut body), &row).unwrap();
+                Ok(HttpResponse::build_from(&req)
+                    .header(http::header::SERVER, "Actix")
+                    .content_type("application/json")
+                    .body(body))
+            }
+            Err(_) => Ok(HttpResponse::InternalServerError().into()),
+        })
+        .responder()
+}
+
+fn queries(req: HttpRequest<State>) -> FutureResponse<HttpResponse> {
+    // get queries parameter
+    let q = req
+        .query()
+        .get("q")
+        .map(|q| cmp::min(500, cmp::max(1, q.parse::<u16>().ok().unwrap_or(1))))
+        .unwrap_or(1);
+
+    // run sql queries
+    req.clone()
+        .state()
+        .db
+        .send(db::RandomWorlds(q))
+        .from_err()
+        .and_then(move |res| {
+            if let Ok(worlds) = res {
+                let mut body = BytesMut::with_capacity(35 * worlds.len());
+                serde_json::to_writer(Writer(&mut body), &worlds).unwrap();
+                Ok(HttpResponse::build_from(&req)
+                    .header(http::header::SERVER, "Actix")
+                    .content_type("application/json")
+                    .body(body))
+            } else {
+                Ok(HttpResponse::InternalServerError().into())
+            }
+        })
+        .responder()
+}
+
+fn updates(req: HttpRequest<State>) -> FutureResponse<HttpResponse> {
+    // get queries parameter
+    let q = if let Some(q) = req.query().get("q") {
+        q.parse::<usize>().ok().unwrap_or(1)
+    } else {
+        1
+    };
+    let q = cmp::min(500, cmp::max(1, q));
+
+    // update worlds
+    req.clone()
+        .state()
+        .db
+        .send(db::UpdateWorld(q))
+        .from_err()
+        .and_then(move |res| {
+            if let Ok(worlds) = res {
+                let mut body = BytesMut::with_capacity(35 * worlds.len());
+                serde_json::to_writer(Writer(&mut body), &worlds).unwrap();
+                Ok(HttpResponse::build_from(&req)
+                    .header(http::header::SERVER, "Actix")
+                    .content_type("application/json")
+                    .body(body))
+            } else {
+                Ok(HttpResponse::InternalServerError().into())
+            }
+        })
+        .responder()
+}
+
+#[derive(Template)]
+#[template(path = "fortune.html")]
+struct FortuneTemplate<'a> {
+    items: &'a Vec<models::Fortune>,
+}
+
+fn fortune(req: HttpRequest<State>) -> FutureResponse<HttpResponse> {
+    req.clone()
+        .state()
+        .db
+        .send(db::TellFortune)
+        .from_err()
+        .and_then(move |res| match res {
+            Ok(rows) => {
+                let tmpl = FortuneTemplate { items: &rows };
+                let res = tmpl.render().unwrap();
+
+                Ok(HttpResponse::build_from(&req)
+                    .header(http::header::SERVER, "Actix")
+                    .content_type("text/html; charset=utf-8")
+                    .body(res))
+            }
+            Err(_) => Ok(HttpResponse::InternalServerError().into()),
+        })
+        .responder()
+}
+
+fn main() {
+    let sys = System::new("techempower");
+    let db_url = "postgres://benchmarkdbuser:benchmarkdbpass@tfb-database/hello_world";
+
+    // Avoid triggering "FATAL: the database system is starting up" error from
+    // postgres.
+    {
+        if PgConnection::establish(db_url).is_err() {
+            std::thread::sleep(std::time::Duration::from_secs(5));
+        }
+    }
+
+    // Start db executor actors
+    let addr =
+        SyncArbiter::start(num_cpus::get() * 3, move || db::DbExecutor::new(db_url));
+
+    // start http server
+    server::new(move || {
+        App::with_state(State { db: addr.clone() })
+            .resource("/db", |r| r.route().f(world_row))
+            .resource("/fortune", |r| r.route().f(fortune))
+            .resource("/queries", |r| r.route().f(queries))
+            .resource("/updates", |r| r.route().f(updates))
+    }).backlog(8192)
+        .bind("0.0.0.0:8080")
+        .unwrap()
+        .start();
+
+    println!("Started http server: 127.0.0.1:8080");
+    let _ = sys.run();
+}

frameworks/Rust/actix/src/pg.rs → frameworks/Rust/actix/src/main_pg.rs

@@ -10,13 +10,15 @@ extern crate serde_json;
 #[macro_use]
 extern crate serde_derive;
 #[macro_use]
-extern crate horrorshow;
-#[macro_use]
 extern crate diesel;
+#[macro_use]
+extern crate askama;
 
 use actix::prelude::*;
-use actix_web::{http, server, App, AsyncResponder, FutureResponse, HttpRequest,
-                HttpResponse};
+use actix_web::{
+    http, server, App, AsyncResponder, FutureResponse, HttpRequest, HttpResponse,
+};
+use askama::Template;
 use bytes::BytesMut;
 use futures::Future;
 use postgres::{Connection, TlsMode};
@@ -24,7 +26,6 @@ use rand::{thread_rng, Rng, ThreadRng};
 use std::{cmp, io};
 
 mod models;
-mod tmpl;
 mod utils;
 use models::{Fortune, World};
 use utils::Writer;
@@ -55,12 +56,11 @@ fn world_row(req: HttpRequest<State>) -> FutureResponse<HttpResponse> {
 
 fn queries(req: HttpRequest<State>) -> FutureResponse<HttpResponse> {
     // get queries parameter
-    let q = if let Some(q) = req.query().get("q") {
-        q.parse::<u16>().ok().unwrap_or(1)
-    } else {
-        1
-    };
-    let q = cmp::min(500, cmp::max(1, q));
+    let q = req
+        .query()
+        .get("q")
+        .map(|q| cmp::min(500, cmp::max(1, q.parse::<u16>().ok().unwrap_or(1))))
+        .unwrap_or(1);
 
     // run sql queries
     req.clone()
@@ -113,6 +113,12 @@ fn updates(req: HttpRequest<State>) -> FutureResponse<HttpResponse> {
         .responder()
 }
 
+#[derive(Template)]
+#[template(path = "fortune.html")]
+struct FortuneTemplate<'a> {
+    items: &'a Vec<models::Fortune>,
+}
+
 fn fortune(req: HttpRequest<State>) -> FutureResponse<HttpResponse> {
     req.state()
         .db
@@ -120,7 +126,8 @@ fn fortune(req: HttpRequest<State>) -> FutureResponse<HttpResponse> {
         .from_err()
         .and_then(|res| match res {
             Ok(rows) => {
-                let res = tmpl::render_fortune(&rows);
+                let tmpl = FortuneTemplate { items: &rows };
+                let res = tmpl.render().unwrap();
 
                 Ok(HttpResponse::Ok()
                     .header(http::header::SERVER, "Actix")
@@ -165,7 +172,8 @@ impl Handler<RandomWorld> for PgConnection {
     type Result = io::Result<World>;
 
     fn handle(&mut self, _: RandomWorld, _: &mut Self::Context) -> Self::Result {
-        let random_world = self.conn
+        let random_world = self
+            .conn
             .prepare_cached("SELECT id, randomnumber FROM world WHERE id=$1")
             .unwrap();
 
@@ -189,7 +197,8 @@ impl Handler<RandomWorlds> for PgConnection {
     type Result = io::Result<Vec<World>>;
 
     fn handle(&mut self, msg: RandomWorlds, _: &mut Self::Context) -> Self::Result {
-        let random_world = self.conn
+        let random_world = self
+            .conn
             .prepare_cached("SELECT id, randomnumber FROM world WHERE id=$1")
             .unwrap();
 
@@ -217,32 +226,30 @@ impl Handler<UpdateWorld> for PgConnection {
     type Result = io::Result<Vec<World>>;
 
     fn handle(&mut self, msg: UpdateWorld, _: &mut Self::Context) -> Self::Result {
-        let get_world = self.conn
+        let get_world = self
+            .conn
             .prepare_cached("SELECT id FROM world WHERE id=$1")
             .unwrap();
+        let mut update = String::with_capacity(120 + 6 * msg.0 as usize);
+        update
+            .push_str("UPDATE world SET randomnumber = temp.randomnumber FROM (VALUES ");
 
         let mut worlds = Vec::with_capacity(msg.0 as usize);
         for _ in 0..msg.0 {
             let random_id = self.rng.gen_range::<i32>(1, 10_000);
             let rows = &get_world.query(&[&random_id]).unwrap();
-            let row = rows.get(0);
-            let w_id: i32 = row.get(0);
-            let new_num: i32 = self.rng.gen_range(1, 10_000);
-            worlds.push(World {
-                id: w_id,
-                randomnumber: new_num,
-            });
+            let w = World {
+                id: rows.get(0).get(0),
+                randomnumber: self.rng.gen_range(1, 10_000),
+            };
+            update.push_str(&format!("({}, {}),", w.id, w.randomnumber));
+            worlds.push(w);
         }
         worlds.sort_by_key(|w| w.id);
 
-        let trans = self.conn.transaction().unwrap();
-        let update_world = trans
-            .prepare_cached("UPDATE world SET randomnumber=$1 WHERE id=$2")
-            .unwrap();
-        for w in &worlds {
-            let _ = update_world.execute(&[&w.id, &w.randomnumber]);
-        }
-        trans.commit().unwrap();
+        update.pop();
+        update.push_str(") AS temp(id, randomnumber) WHERE temp.id = world.id");
+        self.conn.execute(&update, &[]).unwrap();
 
         Ok(worlds)
     }
@@ -258,7 +265,8 @@ impl Handler<TellFortune> for PgConnection {
     type Result = io::Result<Vec<Fortune>>;
 
     fn handle(&mut self, _: TellFortune, _: &mut Self::Context) -> Self::Result {
-        let fortune = self.conn
+        let fortune = self
+            .conn
             .prepare_cached("SELECT id, message FROM fortune")
             .unwrap();
 
@@ -298,11 +306,10 @@ fn main() {
     // start http server
     server::new(move || {
         App::with_state(State { db: addr.clone() })
-            .default_encoding(http::ContentEncoding::Identity)
-            .resource("/db", |r| r.route().a(world_row))
-            .resource("/queries", |r| r.route().a(queries))
-            .resource("/fortune", |r| r.route().a(fortune))
-            .resource("/updates", |r| r.route().a(updates))
+            .resource("/db", |r| r.route().f(world_row))
+            .resource("/queries", |r| r.route().f(queries))
+            .resource("/fortune", |r| r.route().f(fortune))
+            .resource("/updates", |r| r.route().f(updates))
     }).backlog(8192)
         .bind("0.0.0.0:8080")
         .unwrap()

frameworks/Rust/actix/src/simple.rs

@@ -1,59 +0,0 @@
-extern crate actix;
-extern crate actix_web;
-extern crate bytes;
-extern crate futures;
-extern crate serde;
-extern crate serde_json;
-#[macro_use]
-extern crate serde_derive;
-
-use actix::prelude::*;
-use actix_web::{http, server, App, HttpRequest, HttpResponse};
-use bytes::BytesMut;
-
-mod utils;
-use utils::Writer;
-
-const SIZE: usize = 29;
-
-#[derive(Serialize, Deserialize)]
-pub struct Message {
-    pub message: &'static str,
-}
-
-fn json(req: HttpRequest) -> HttpResponse {
-    let message = Message {
-        message: "Hello, World!",
-    };
-    let mut body = BytesMut::with_capacity(SIZE);
-    serde_json::to_writer(Writer(&mut body), &message).unwrap();
-
-    HttpResponse::build_from(&req)
-        .header(http::header::SERVER, "Actix")
-        .header(http::header::CONTENT_TYPE, "application/json")
-        .body(body)
-}
-
-fn plaintext(req: HttpRequest) -> HttpResponse {
-    HttpResponse::build_from(&req)
-        .header(http::header::SERVER, "Actix")
-        .header(http::header::CONTENT_TYPE, "text/plain")
-        .body("Hello, World!")
-}
-
-fn main() {
-    let sys = System::new("techempower");
-
-    // start http server
-    server::new(move || {
-        App::new()
-            .resource("/json", |r| r.f(json))
-            .resource("/plaintext", |r| r.f(plaintext))
-    }).backlog(8192)
-        .bind("0.0.0.0:8080")
-        .unwrap()
-        .start();
-
-    println!("Started http server: 127.0.0.1:8080");
-    let _ = sys.run();
-}

frameworks/Rust/actix/src/tmpl.rs

@@ -1,33 +0,0 @@
-use horrorshow::helper::doctype;
-
-use models::Fortune;
-
-#[inline]
-pub fn render_fortune(items: &Vec<Fortune>) -> String {
-    format!(
-        "{}",
-        html! {
-            : doctype::HTML;
-            html {
-                head {
-                    title : "Fortunes";
-                }
-                body {
-                    table {
-                        tr {
-                            th { : "id" }
-                            th { : "message" }
-                        }
-                        // You can embed for loops, while loops, and if statements.
-                        @ for item in items {
-                            tr {
-                                td { :&item.id }
-                                td { :&item.message }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    )
-}