Upgrade actix/actix-web to 0.7 (#3913)

frameworks/Rust/actix/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix"
-version = "0.6.0"
+version = "0.7.0"
 build = "build.rs"
 
 [[bin]]
@@ -20,7 +20,7 @@ name = "actix-pg"
 path = "src/main_pg.rs"
 
 [dependencies]
-askama = "0.6"
+askama = "0.7"
 serde = "1.0"
 serde_json = "1.0"
 serde_derive = "1.0"
@@ -28,17 +28,16 @@ rand = "0.5"
 bytes = "0.4"
 num_cpus = "1.0"
 futures = "0.1"
-tokio-io = "=0.1.5"
-tokio-core = "=0.1.12"
 http = "0.1"
 diesel = { version = "1.2", features = ["postgres"] }
+url = { version="1.7", features=["query_encoding"] }
 postgres = "0.15"
 
-actix = "0.5"
-actix-web = { version = "0.6", default-features = false }
+actix = "0.7"
+actix-web = { git = "https://github.com/actix/actix-web.git", default-features = false }
 
 [build-dependencies]
-askama = "0.6"
+askama = "0.7"
 
 [profile.release]
 lto = true

frameworks/Rust/actix/src/main.rs

@@ -4,6 +4,7 @@ extern crate bytes;
 extern crate futures;
 extern crate serde;
 extern crate serde_json;
+extern crate url;
 #[macro_use]
 extern crate serde_derive;
 
@@ -14,21 +15,21 @@ use bytes::BytesMut;
 mod utils;
 use utils::{Message, Writer, SIZE};
 
-fn json(req: HttpRequest) -> HttpResponse {
+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)
+    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)
+fn plaintext(req: &HttpRequest) -> HttpResponse {
+    HttpResponse::build_from(req)
         .header(http::header::SERVER, "Actix")
         .header(http::header::CONTENT_TYPE, "text/plain")
         .body("Hello, World!")

frameworks/Rust/actix/src/main_diesel.rs

@@ -12,6 +12,7 @@ extern crate serde_derive;
 extern crate diesel;
 #[macro_use]
 extern crate askama;
+extern crate url;
 
 use actix::prelude::*;
 use actix_web::{
@@ -30,12 +31,12 @@ mod utils;
 use utils::Writer;
 
 struct State {
-    db: Addr<Syn, db::DbExecutor>,
+    db: Addr<db::DbExecutor>,
 }
 
-fn world_row(req: HttpRequest<State>) -> FutureResponse<HttpResponse> {
-    req.clone()
-        .state()
+fn world_row(req: &HttpRequest<State>) -> FutureResponse<HttpResponse> {
+    let mut resp = HttpResponse::build_from(req);
+    req.state()
         .db
         .send(db::RandomWorld)
         .from_err()
@@ -43,7 +44,7 @@ fn world_row(req: HttpRequest<State>) -> FutureResponse<HttpResponse> {
             Ok(row) => {
                 let mut body = BytesMut::with_capacity(31);
                 serde_json::to_writer(Writer(&mut body), &row).unwrap();
-                Ok(HttpResponse::build_from(&req)
+                Ok(resp
                     .header(http::header::SERVER, "Actix")
                     .content_type("application/json")
                     .body(body))
@@ -53,7 +54,7 @@ fn world_row(req: HttpRequest<State>) -> FutureResponse<HttpResponse> {
         .responder()
 }
 
-fn queries(req: HttpRequest<State>) -> FutureResponse<HttpResponse> {
+fn queries(req: &HttpRequest<State>) -> FutureResponse<HttpResponse> {
     // get queries parameter
     let q = req
         .query()
@@ -62,8 +63,8 @@ fn queries(req: HttpRequest<State>) -> FutureResponse<HttpResponse> {
         .unwrap_or(1);
 
     // run sql queries
-    req.clone()
-        .state()
+    let mut resp = HttpResponse::build_from(req);
+    req.state()
         .db
         .send(db::RandomWorlds(q))
         .from_err()
@@ -71,7 +72,7 @@ fn queries(req: HttpRequest<State>) -> FutureResponse<HttpResponse> {
             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)
+                Ok(resp
                     .header(http::header::SERVER, "Actix")
                     .content_type("application/json")
                     .body(body))
@@ -82,7 +83,7 @@ fn queries(req: HttpRequest<State>) -> FutureResponse<HttpResponse> {
         .responder()
 }
 
-fn updates(req: HttpRequest<State>) -> FutureResponse<HttpResponse> {
+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)
@@ -92,8 +93,8 @@ fn updates(req: HttpRequest<State>) -> FutureResponse<HttpResponse> {
     let q = cmp::min(500, cmp::max(1, q));
 
     // update worlds
-    req.clone()
-        .state()
+    let mut resp = HttpResponse::build_from(req);
+    req.state()
         .db
         .send(db::UpdateWorld(q))
         .from_err()
@@ -101,7 +102,7 @@ fn updates(req: HttpRequest<State>) -> FutureResponse<HttpResponse> {
             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)
+                Ok(resp
                     .header(http::header::SERVER, "Actix")
                     .content_type("application/json")
                     .body(body))
@@ -118,9 +119,9 @@ struct FortuneTemplate<'a> {
     items: &'a Vec<models::Fortune>,
 }
 
-fn fortune(req: HttpRequest<State>) -> FutureResponse<HttpResponse> {
-    req.clone()
-        .state()
+fn fortune(req: &HttpRequest<State>) -> FutureResponse<HttpResponse> {
+    let mut resp = HttpResponse::build_from(req);
+    req.state()
         .db
         .send(db::TellFortune)
         .from_err()
@@ -129,7 +130,7 @@ fn fortune(req: HttpRequest<State>) -> FutureResponse<HttpResponse> {
                 let tmpl = FortuneTemplate { items: &rows };
                 let res = tmpl.render().unwrap();
 
-                Ok(HttpResponse::build_from(&req)
+                Ok(resp
                     .header(http::header::SERVER, "Actix")
                     .content_type("text/html; charset=utf-8")
                     .body(res))

frameworks/Rust/actix/src/main_pg.rs

@@ -7,6 +7,7 @@ extern crate postgres;
 extern crate rand;
 extern crate serde;
 extern crate serde_json;
+extern crate url;
 #[macro_use]
 extern crate serde_derive;
 #[macro_use]
@@ -22,7 +23,6 @@ use askama::Template;
 use bytes::BytesMut;
 use futures::Future;
 use postgres::{Connection, TlsMode};
-use std::cmp;
 
 mod db_pg;
 mod models;
@@ -31,12 +31,12 @@ use db_pg::{PgConnection, RandomWorld, RandomWorlds, TellFortune, UpdateWorld};
 use utils::Writer;
 
 struct State {
-    db: Addr<Syn, PgConnection>,
+    db: Addr<PgConnection>,
 }
 
-fn world_row(req: HttpRequest<State>) -> FutureResponse<HttpResponse> {
-    req.clone()
-        .state()
+fn world_row(req: &HttpRequest<State>) -> FutureResponse<HttpResponse> {
+    let mut resp = HttpResponse::build_from(req);
+    req.state()
         .db
         .send(RandomWorld)
         .from_err()
@@ -44,7 +44,7 @@ fn world_row(req: HttpRequest<State>) -> FutureResponse<HttpResponse> {
             Ok(row) => {
                 let mut body = BytesMut::with_capacity(31);
                 serde_json::to_writer(Writer(&mut body), &row).unwrap();
-                Ok(HttpResponse::build_from(&req)
+                Ok(resp
                     .header(http::header::SERVER, "Actix")
                     .content_type("application/json")
                     .body(body))
@@ -54,15 +54,12 @@ fn world_row(req: HttpRequest<State>) -> FutureResponse<HttpResponse> {
         .responder()
 }
 
-fn queries(req: HttpRequest<State>) -> FutureResponse<HttpResponse> {
+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);
+    let q = utils::get_query_param(req.uri());
 
     // run sql queries
+    let mut resp = HttpResponse::build_from(req);
     req.clone()
         .state()
         .db
@@ -72,7 +69,7 @@ fn queries(req: HttpRequest<State>) -> FutureResponse<HttpResponse> {
             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)
+                Ok(resp
                     .header(http::header::SERVER, "Actix")
                     .content_type("application/json")
                     .body(body))
@@ -83,17 +80,13 @@ fn queries(req: HttpRequest<State>) -> FutureResponse<HttpResponse> {
         .responder()
 }
 
-fn updates(req: HttpRequest<State>) -> FutureResponse<HttpResponse> {
+fn updates(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);
+    let q = utils::get_query_param(req.uri());
 
     // update db
-    req.clone()
-        .state()
+    let mut resp = HttpResponse::build_from(req);
+    req.state()
         .db
         .send(UpdateWorld(q))
         .from_err()
@@ -101,7 +94,7 @@ fn updates(req: HttpRequest<State>) -> FutureResponse<HttpResponse> {
             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)
+                Ok(resp
                     .header(http::header::SERVER, "Actix")
                     .content_type("application/json")
                     .body(body))
@@ -118,17 +111,18 @@ struct FortuneTemplate<'a> {
     items: &'a Vec<models::Fortune>,
 }
 
-fn fortune(req: HttpRequest<State>) -> FutureResponse<HttpResponse> {
+fn fortune(req: &HttpRequest<State>) -> FutureResponse<HttpResponse> {
+    let mut resp = HttpResponse::build_from(req);
     req.state()
         .db
         .send(TellFortune)
         .from_err()
-        .and_then(|res| match res {
+        .and_then(move |res| match res {
             Ok(rows) => {
                 let tmpl = FortuneTemplate { items: &rows };
                 let res = tmpl.render().unwrap();
 
-                Ok(HttpResponse::Ok()
+                Ok(resp
                     .header(http::header::SERVER, "Actix")
                     .content_type("text/html; charset=utf-8")
                     .body(res))

frameworks/Rust/actix/src/main_raw.rs

@@ -11,14 +11,17 @@ extern crate askama;
 extern crate num_cpus;
 extern crate postgres;
 extern crate rand;
+extern crate url;
 #[macro_use]
 extern crate diesel;
 
-use std::{cmp, mem};
+use std::mem;
 
 use actix::prelude::*;
-use actix_web::server::{self, HttpHandler, HttpHandlerTask, HttpServer, Writer};
-use actix_web::{Error, HttpRequest};
+use actix_web::server::{
+    self, HttpHandler, HttpHandlerTask, HttpServer, Request, Writer,
+};
+use actix_web::Error;
 use askama::Template;
 use futures::{Async, Future, Poll};
 use postgres::{Connection, TlsMode};
@@ -38,11 +41,13 @@ const HDR_CTHTML: &[u8] = b"Content-Type: text/html; charset=utf-8";
 const BODY: &[u8] = b"Hello, World!";
 
 struct App {
-    db: Addr<Syn, PgConnection>,
+    db: Addr<PgConnection>,
 }
 
 impl HttpHandler for App {
-    fn handle(&mut self, req: HttpRequest) -> Result<Box<HttpHandlerTask>, HttpRequest> {
+    type Task = Box<HttpHandlerTask>;
+
+    fn handle(&self, req: Request) -> Result<Box<HttpHandlerTask>, Request> {
         {
             let path = req.path();
             match path.len() {
@@ -59,31 +64,13 @@ impl HttpHandler for App {
                     }));
                 }
                 8 if path == "/queries" => {
-                    let q = req
-                        .query()
-                        .get("q")
-                        .map(|q| {
-                            cmp::min(
-                                500,
-                                cmp::max(1, q.parse::<u16>().ok().unwrap_or(1)),
-                            )
-                        })
-                        .unwrap_or(1);
+                    let q = utils::get_query_param(req.uri());
                     return Ok(Box::new(Queries {
                         fut: self.db.send(RandomWorlds(q)),
                     }));
                 }
                 8 if path == "/updates" => {
-                    let q = req
-                        .query()
-                        .get("q")
-                        .map(|q| {
-                            cmp::min(
-                                500,
-                                cmp::max(1, q.parse::<u16>().ok().unwrap_or(1)),
-                            )
-                        })
-                        .unwrap_or(1);
+                    let q = utils::get_query_param(req.uri());
                     return Ok(Box::new(Updates {
                         fut: self.db.send(UpdateWorld(q)),
                     }));
@@ -99,14 +86,16 @@ struct Plaintext;
 
 impl HttpHandlerTask for Plaintext {
     fn poll_io(&mut self, io: &mut Writer) -> Poll<bool, Error> {
-        let mut bytes = io.buffer();
-        bytes.reserve(196);
-        bytes.extend_from_slice(HTTPOK);
-        bytes.extend_from_slice(HDR_SERVER);
-        bytes.extend_from_slice(HDR_CTPLAIN);
-        server::write_content_length(13, &mut bytes);
-        io.set_date(bytes);
-        bytes.extend_from_slice(BODY);
+        {
+            let mut bytes = io.buffer();
+            bytes.reserve(196);
+            bytes.extend_from_slice(HTTPOK);
+            bytes.extend_from_slice(HDR_SERVER);
+            bytes.extend_from_slice(HDR_CTPLAIN);
+            server::write_content_length(13, &mut bytes);
+        }
+        io.set_date();
+        io.buffer().extend_from_slice(BODY);
         Ok(Async::Ready(true))
     }
 }
@@ -119,20 +108,22 @@ impl HttpHandlerTask for Json {
             message: "Hello, World!",
         };
 
-        let mut bytes = io.buffer();
-        bytes.reserve(196);
-        bytes.extend_from_slice(HTTPOK);
-        bytes.extend_from_slice(HDR_SERVER);
-        bytes.extend_from_slice(HDR_CTJSON);
-        server::write_content_length(27, &mut bytes);
-        io.set_date(bytes);
-        serde_json::to_writer(JsonWriter(bytes), &message).unwrap();
+        {
+            let mut bytes = io.buffer();
+            bytes.reserve(196);
+            bytes.extend_from_slice(HTTPOK);
+            bytes.extend_from_slice(HDR_SERVER);
+            bytes.extend_from_slice(HDR_CTJSON);
+            server::write_content_length(27, &mut bytes);
+        }
+        io.set_date();
+        serde_json::to_writer(JsonWriter(io.buffer()), &message).unwrap();
         Ok(Async::Ready(true))
     }
 }
 
 struct Fortune {
-    fut: actix::dev::Request<Syn, PgConnection, TellFortune>,
+    fut: actix::dev::Request<PgConnection, TellFortune>,
 }
 
 #[derive(Template)]
@@ -153,14 +144,16 @@ impl HttpHandlerTask for Fortune {
                     writer.1
                 };
 
-                let mut bytes = io.buffer();
-                bytes.reserve(196 + len);
-                bytes.extend_from_slice(HTTPOK);
-                bytes.extend_from_slice(HDR_SERVER);
-                bytes.extend_from_slice(HDR_CTHTML);
-                server::write_content_length(len, &mut bytes);
-                io.set_date(bytes);
-                bytes.extend_from_slice(&body[..len]);
+                {
+                    let mut bytes = io.buffer();
+                    bytes.reserve(196 + len);
+                    bytes.extend_from_slice(HTTPOK);
+                    bytes.extend_from_slice(HDR_SERVER);
+                    bytes.extend_from_slice(HDR_CTHTML);
+                    server::write_content_length(len, &mut bytes);
+                }
+                io.set_date();
+                io.buffer().extend_from_slice(&body[..len]);
                 Ok(Async::Ready(true))
             }
             Ok(Async::NotReady) => Ok(Async::NotReady),
@@ -171,7 +164,7 @@ impl HttpHandlerTask for Fortune {
 }
 
 struct World {
-    fut: actix::dev::Request<Syn, PgConnection, RandomWorld>,
+    fut: actix::dev::Request<PgConnection, RandomWorld>,
 }
 
 impl HttpHandlerTask for World {
@@ -185,14 +178,16 @@ impl HttpHandlerTask for World {
                     writer.1
                 };
 
-                let mut bytes = io.buffer();
-                bytes.reserve(196);
-                bytes.extend_from_slice(HTTPOK);
-                bytes.extend_from_slice(HDR_SERVER);
-                bytes.extend_from_slice(HDR_CTJSON);
-                server::write_content_length(len, &mut bytes);
-                io.set_date(bytes);
-                bytes.extend_from_slice(&body[..len]);
+                {
+                    let mut bytes = io.buffer();
+                    bytes.reserve(196);
+                    bytes.extend_from_slice(HTTPOK);
+                    bytes.extend_from_slice(HDR_SERVER);
+                    bytes.extend_from_slice(HDR_CTJSON);
+                    server::write_content_length(len, &mut bytes);
+                }
+                io.set_date();
+                io.buffer().extend_from_slice(&body[..len]);
                 Ok(Async::Ready(true))
             }
             Ok(Async::NotReady) => Ok(Async::NotReady),
@@ -203,7 +198,7 @@ impl HttpHandlerTask for World {
 }
 
 struct Queries {
-    fut: actix::dev::Request<Syn, PgConnection, RandomWorlds>,
+    fut: actix::dev::Request<PgConnection, RandomWorlds>,
 }
 
 impl HttpHandlerTask for Queries {
@@ -217,14 +212,16 @@ impl HttpHandlerTask for Queries {
                     writer.1
                 };
 
-                let mut bytes = io.buffer();
-                bytes.reserve(196 + len);
-                bytes.extend_from_slice(HTTPOK);
-                bytes.extend_from_slice(HDR_SERVER);
-                bytes.extend_from_slice(HDR_CTJSON);
-                server::write_content_length(len, &mut bytes);
-                io.set_date(bytes);
-                bytes.extend_from_slice(&body[..len]);
+                {
+                    let mut bytes = io.buffer();
+                    bytes.reserve(196 + len);
+                    bytes.extend_from_slice(HTTPOK);
+                    bytes.extend_from_slice(HDR_SERVER);
+                    bytes.extend_from_slice(HDR_CTJSON);
+                    server::write_content_length(len, &mut bytes);
+                }
+                io.set_date();
+                io.buffer().extend_from_slice(&body[..len]);
                 Ok(Async::Ready(true))
             }
             Ok(Async::NotReady) => Ok(Async::NotReady),
@@ -235,7 +232,7 @@ impl HttpHandlerTask for Queries {
 }
 
 struct Updates {
-    fut: actix::dev::Request<Syn, PgConnection, UpdateWorld>,
+    fut: actix::dev::Request<PgConnection, UpdateWorld>,
 }
 
 impl HttpHandlerTask for Updates {
@@ -249,14 +246,16 @@ impl HttpHandlerTask for Updates {
                     writer.1
                 };
 
-                let mut bytes = io.buffer();
-                bytes.reserve(196 + len);
-                bytes.extend_from_slice(HTTPOK);
-                bytes.extend_from_slice(HDR_SERVER);
-                bytes.extend_from_slice(HDR_CTJSON);
-                server::write_content_length(len, &mut bytes);
-                io.set_date(bytes);
-                bytes.extend_from_slice(&body[..len]);
+                {
+                    let mut bytes = io.buffer();
+                    bytes.reserve(196 + len);
+                    bytes.extend_from_slice(HTTPOK);
+                    bytes.extend_from_slice(HDR_SERVER);
+                    bytes.extend_from_slice(HDR_CTJSON);
+                    server::write_content_length(len, &mut bytes);
+                }
+                io.set_date();
+                io.buffer().extend_from_slice(&body[..len]);
                 Ok(Async::Ready(true))
             }
             Ok(Async::NotReady) => Ok(Async::NotReady),

frameworks/Rust/actix/src/utils.rs

@@ -1,6 +1,9 @@
 #![allow(dead_code)]
 use bytes::BytesMut;
-use std::{fmt, io};
+use std::{cmp, fmt, io};
+
+use actix_web::http::Uri;
+use url::form_urlencoded;
 
 pub const SIZE: usize = 31;
 
@@ -51,3 +54,17 @@ impl<'a> fmt::Write for StackWriter<'a> {
         Ok(())
     }
 }
+
+pub fn get_query_param(uri: &Uri) -> u16 {
+    let mut q = None;
+    let q_str = if let Some(s) = uri.query() { s } else { "" };
+    for (key, val) in form_urlencoded::parse(q_str.as_ref()) {
+        if key == "q" {
+            q = Some(val);
+            break;
+        }
+    }
+
+    q.map(|q| cmp::min(500, cmp::max(1, q.parse::<u16>().ok().unwrap_or(1))))
+        .unwrap_or(1)
+}