add json-rust example

examples/json/Cargo.toml

@@ -11,6 +11,7 @@ env_logger = "*"
 serde = "1.0"
 serde_json = "1.0"
 serde_derive = "1.0"
+json = "*"
 
-actix = "^0.3.1"
-actix-web = { git = "https://github.com/actix/actix-web.git" }
+actix = "^0.3.5"
+actix-web = { git = "https://github.com/actix/actix-web", features=["signal"] }

examples/json/README.md

@@ -0,0 +1,38 @@
+# json
+
+Json's `Getting Started` guide using json (serde-json or json-rust) for Actix web
+
+## Usage
+
+### server
+
+```bash
+cd actix-web/examples/json
+cargo run
+# Started http server: 127.0.0.1:8080
+```
+
+### client
+
+With [Postman](https://www.getpostman.com/) or [Rested](moz-extension://60daeb1c-5b1b-4afd-9842-0579ed34dfcb/dist/index.html)
+
+- POST / (embed serde-json):
+
+  - method : ``POST``
+  - url : ``http://127.0.0.1:8080/``
+  - header : ``Content-Type`` = ``application/json``
+  - body (raw) : ``{"name": "Test user", "number": 100}``
+
+- POST /manual (manual serde-json):
+
+  - method : ``POST``
+  - url : ``http://127.0.0.1:8080/manual``
+  - header : ``Content-Type`` = ``application/json``
+  - body (raw) : ``{"name": "Test user", "number": 100}``
+
+- POST /mjsonrust (manual json-rust):
+
+  - method : ``POST``
+  - url : ``http://127.0.0.1:8080/mjsonrust``
+  - header : ``Content-Type`` = ``application/json``
+  - body (raw) : ``{"name": "Test user", "number": 100}`` (you can also test ``{notjson}``)

examples/json/src/main.rs

@@ -5,10 +5,16 @@ extern crate futures;
 extern crate env_logger;
 extern crate serde_json;
 #[macro_use] extern crate serde_derive;
+#[macro_use] extern crate json;
+
 
 use actix_web::*;
 use bytes::BytesMut;
 use futures::{Future, Stream};
+use json::JsonValue;
+
+use actix::Arbiter;
+use actix::actors::signal::{ProcessSignals, Subscribe};
 
 #[derive(Debug, Serialize, Deserialize)]
 struct MyObj {
@@ -16,7 +22,7 @@ struct MyObj {
     number: i32,
 }
 
-/// This handler uses `HttpRequest::json()` for loading json object.
+/// This handler uses `HttpRequest::json()` for loading serde json object.
 fn index(mut req: HttpRequest) -> Box<Future<Item=HttpResponse, Error=Error>> {
     req.json()
         .from_err()  // convert all errors into `Error`
@@ -30,7 +36,7 @@ fn index(mut req: HttpRequest) -> Box<Future<Item=HttpResponse, Error=Error>> {
 
 const MAX_SIZE: usize = 262_144;  // max payload size is 256k
 
-/// This handler manually load request payload and parse json
+/// This handler manually load request payload and parse serde json
 fn index_manual(mut req: HttpRequest) -> Box<Future<Item=HttpResponse, Error=Error>> {
     // readany() returns asynchronous stream of Bytes objects
     req.payload_mut().readany()
@@ -52,27 +58,48 @@ fn index_manual(mut req: HttpRequest) -> Box<Future<Item=HttpResponse, Error=Err
         // `Future::and_then` can be used to merge an asynchronous workflow with a
         // synchronous workflow
         .and_then(|body| {
-            // body is loaded, now we can deserialize json
+            // body is loaded, now we can deserialize serde-json
             let obj = serde_json::from_slice::<MyObj>(&body)?;
             Ok(httpcodes::HTTPOk.build().json(obj)?) // <- send response
         })
         .responder()
 }
 
+/// This handler manually load request payload and parse json-rust
+fn index_mjsonrust(mut req: HttpRequest) -> Box<Future<Item=HttpResponse, Error=Error>> {
+    req.payload_mut().readany().concat2()
+        .from_err()
+        .and_then(|body| {
+            // body is loaded, now we can deserialize json-rust
+            let result = json::parse(std::str::from_utf8(&body).unwrap()); // return Result
+            let injson: JsonValue = match result { Ok(v) => v, Err(e) => object!{"err" => e.to_string() } };
+            Ok(HttpResponse::build(StatusCode::OK)
+                .content_type("application/json")
+                .body(injson.dump()).unwrap())
+
+        })
+        .responder()
+}
+
 fn main() {
     ::std::env::set_var("RUST_LOG", "actix_web=info");
     let _ = env_logger::init();
     let sys = actix::System::new("json-example");
 
-    HttpServer::new(|| {
+    let addr = HttpServer::new(|| {
         Application::new()
             // enable logger
             .middleware(middleware::Logger::default())
             .resource("/manual", |r| r.method(Method::POST).f(index_manual))
+            .resource("/mjsonrust", |r| r.method(Method::POST).f(index_mjsonrust))
             .resource("/", |r| r.method(Method::POST).f(index))})
         .bind("127.0.0.1:8080").unwrap()
+        .shutdown_timeout(1)
         .start();
 
+    let signals = Arbiter::system_registry().get::<ProcessSignals>();
+    signals.send(Subscribe(addr.subscriber()));
+
     println!("Started http server: 127.0.0.1:8080");
     let _ = sys.run();
 }