forked/hyper
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

docs(server): show JSON deserialization in API example (#1791)

Browse Source 
The previous version only showed a JSON GET API.
Deserializing the body of a POST request is not
trivial so the example should show it.

The new example takes the JSON body sent in a
POST request, deserializes it, adds a field, then
serializes it and sends it back.

Signed-off-by: Ole Herman Schumacher Elgesem <oleherman93@gmail.com>
This commit is contained in:
Ole Herman Schumacher Elgesem
2019-04-09 23:05:16 +02:00
committed by Sean McArthur
parent 2ef562a165
commit b3deb0cbed
1 changed files with 71 additions and 64 deletions
Download Patch File Download Diff File Expand all files Collapse all files

95
examples/web_api.rs
View File

@@ -10,72 +10,64 @@ use hyper::{Body, Chunk, Client, Method, Request, Response, Server, StatusCode,
use hyper::client::HttpConnector; use hyper::client::HttpConnector;
use hyper::service::service_fn; use hyper::service::service_fn;
#[allow(unused, deprecated)]
use std::ascii::AsciiExt;
static NOTFOUND: &[u8] = b"Not Found"; static NOTFOUND: &[u8] = b"Not Found";
static URL: &str = "http://127.0.0.1:1337/web_api"; static URL: &str = "http://127.0.0.1:1337/json_api";
static INDEX: &[u8] = b"<a href=\"test.html\">test.html</a>"; static INDEX: &[u8] = b"<a href=\"test.html\">test.html</a>";
static LOWERCASE: &[u8] = b"i am a lower case string"; static POST_DATA: &str = r#"{"original": "data"}"#;
fn response_examples(req: Request<Body>, client: &Client<HttpConnector>) type GenericError = Box<dyn std::error::Error + Send + Sync>;
-> Box<Future<Item=Response<Body>, Error=hyper::Error> + Send> type ResponseFuture = Box<Future<Item=Response<Body>, Error=GenericError> + Send>;
{
match (req.method(), req.uri().path()) {
(&Method::GET, "/") | (&Method::GET, "/index.html") => {
let body = Body::from(INDEX);
Box::new(future::ok(Response::new(body)))
},
(&Method::GET, "/test.html") => {
// Run a web query against the web api below
// build the request fn client_request_response(client: &Client<HttpConnector>) -> ResponseFuture {
let req = Request::builder() let req = Request::builder()
.method(Method::POST) .method(Method::POST)
.uri(URL) .uri(URL)
.body(LOWERCASE.into()) .header(header::CONTENT_TYPE, "application/json")
.body(POST_DATA.into())
.unwrap(); .unwrap();
// use the request with client
let web_res_future = client.request(req);
Box::new(web_res_future.map(|web_res| { Box::new(client.request(req).from_err().map(|web_res| {
// return the response that came from the web api and the original text together // Compare the JSON we sent (before) with what we received (after):
// to show the difference
let body = Body::wrap_stream(web_res.into_body().map(|b| { let body = Body::wrap_stream(web_res.into_body().map(|b| {
Chunk::from(format!("<b>before</b>: {}<br><b>after</b>: {}", Chunk::from(format!("<b>POST request body</b>: {}<br><b>Response</b>: {}",
std::str::from_utf8(LOWERCASE).unwrap(), POST_DATA,
std::str::from_utf8(&b).unwrap())) std::str::from_utf8(&b).unwrap()))
})); }));
Response::new(body) Response::new(body)
})) }))
}, }
(&Method::POST, "/web_api") => {
// A web api to run against. Uppercases the body and returns it back. fn api_post_response(req: Request<Body>) -> ResponseFuture {
let body = Body::wrap_stream(req.into_body().map(|chunk| { // A web api to run against
// uppercase the letters Box::new(req.into_body()
let upper = chunk.iter().map(|byte| byte.to_ascii_uppercase()) .concat2() // Concatenate all chunks in the body
.collect::<Vec<u8>>(); .from_err()
Chunk::from(upper) .and_then(|entire_body| {
})); // TODO: Replace all unwraps with proper error handling
Box::new(future::ok(Response::new(body))) let str = String::from_utf8(entire_body.to_vec())?;
}, let mut data : serde_json::Value = serde_json::from_str(&str)?;
(&Method::GET, "/json") => { data["test"] = serde_json::Value::from("test_value");
let json = serde_json::to_string(&data)?;
let response = Response::builder()
.status(StatusCode::OK)
.header(header::CONTENT_TYPE, "application/json")
.body(Body::from(json))?;
Ok(response)
})
)
}
fn api_get_response() -> ResponseFuture {
let data = vec!["foo", "bar"]; let data = vec!["foo", "bar"];
let res = match serde_json::to_string(&data) { let res = match serde_json::to_string(&data) {
Ok(json) => { Ok(json) => {
// return a json response
Response::builder() Response::builder()
.header(header::CONTENT_TYPE, "application/json") .header(header::CONTENT_TYPE, "application/json")
.body(Body::from(json)) .body(Body::from(json))
.unwrap() .unwrap()
} }
// This is unnecessary here because we know Err(_) => {
// this can't fail. But if we were serializing json that came from another
// source we could handle an error like this.
Err(e) => {
eprintln!("serializing json: {}", e);
Response::builder() Response::builder()
.status(StatusCode::INTERNAL_SERVER_ERROR) .status(StatusCode::INTERNAL_SERVER_ERROR)
.body(Body::from("Internal Server Error")) .body(Body::from("Internal Server Error"))
@@ -85,6 +77,22 @@ fn response_examples(req: Request<Body>, client: &Client<HttpConnector>)
Box::new(future::ok(res)) Box::new(future::ok(res))
} }
fn response_examples(req: Request<Body>, client: &Client<HttpConnector>) -> ResponseFuture {
match (req.method(), req.uri().path()) {
(&Method::GET, "/") | (&Method::GET, "/index.html") => {
let body = Body::from(INDEX);
Box::new(future::ok(Response::new(body)))
},
(&Method::GET, "/test.html") => {
client_request_response(client)
},
(&Method::POST, "/json_api") => {
api_post_response(req)
},
(&Method::GET, "/json_api") => {
api_get_response()
}
_ => { _ => {
// Return 404 not found response. // Return 404 not found response.
let body = Body::from(NOTFOUND); let body = Body::from(NOTFOUND);
@@ -122,4 +130,3 @@ fn main() {
server server
})); }));
} }