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

docs(examples): formatting and refactoring

Browse Source
This commit is contained in:
Weihang Lo
2019-07-16 09:17:26 +08:00
committed by Sean McArthur
parent da187b54e8
commit 9ae1873756
1 changed files with 29 additions and 32 deletions
Download Patch File Download Diff File Expand all files Collapse all files

61
examples/web_api.rs
View File

@@ -1,32 +1,31 @@
#![feature(async_await)] #![feature(async_await)]
#![deny(warnings)] #![deny(warnings)]
extern crate hyper;
extern crate pretty_env_logger;
extern crate serde_json;
use hyper::{Body, Chunk, Client, Method, Request, Response, Server, StatusCode, header}; use hyper::{Body, Chunk, Client, Method, Request, Response, Server, StatusCode, header};
use hyper::client::HttpConnector; use hyper::client::HttpConnector;
use hyper::service::{service_fn, make_service_fn}; use hyper::service::{make_service_fn, service_fn};
use futures_util::{TryStreamExt}; use futures_util::{TryStreamExt};
type GenericError = Box<dyn std::error::Error + Send + Sync>; type GenericError = Box<dyn std::error::Error + Send + Sync>;
type Result<T> = std::result::Result<T, GenericError>;
static NOTFOUND: &[u8] = b"Not Found";
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 INTERNAL_SERVER_ERROR: &[u8] = b"Internal Server Error";
static NOTFOUND: &[u8] = b"Not Found";
static POST_DATA: &str = r#"{"original": "data"}"#; static POST_DATA: &str = r#"{"original": "data"}"#;
static URL: &str = "http://127.0.0.1:1337/json_api";
async fn client_request_response(client: &Client<HttpConnector>) async fn client_request_response(
-> Result<Response<Body>, GenericError> client: &Client<HttpConnector>
{ ) -> Result<Response<Body>> {
let req = Request::builder() let req = Request::builder()
.method(Method::POST) .method(Method::POST)
.uri(URL) .uri(URL)
.header(header::CONTENT_TYPE, "application/json") .header(header::CONTENT_TYPE, "application/json")
.body(POST_DATA.into()) .body(POST_DATA.into())
.unwrap(); .unwrap();
let web_res = client.request(req).await?; let web_res = client.request(req).await?;
// Compare the JSON we sent (before) with what we received (after): // Compare the JSON we sent (before) with what we received (after):
let body = Body::wrap_stream(web_res.into_body().map_ok(|b| { let body = Body::wrap_stream(web_res.into_body().map_ok(|b| {
Chunk::from(format!("<b>POST request body</b>: {}<br><b>Response</b>: {}", Chunk::from(format!("<b>POST request body</b>: {}<br><b>Response</b>: {}",
@@ -37,9 +36,7 @@ async fn client_request_response(client: &Client<HttpConnector>)
Ok(Response::new(body)) Ok(Response::new(body))
} }
async fn api_post_response(req: Request<Body>) async fn api_post_response(req: Request<Body>) -> Result<Response<Body>> {
-> Result<Response<Body>, GenericError>
{
// A web api to run against // A web api to run against
let entire_body = req.into_body().try_concat().await?; let entire_body = req.into_body().try_concat().await?;
// TODO: Replace all unwraps with proper error handling // TODO: Replace all unwraps with proper error handling
@@ -54,7 +51,7 @@ async fn api_post_response(req: Request<Body>)
Ok(response) Ok(response)
} }
async fn api_get_response() -> Result<Response<Body>, GenericError> { async fn api_get_response() -> Result<Response<Body>> {
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) => {
@@ -66,20 +63,21 @@ async fn api_get_response() -> Result<Response<Body>, GenericError> {
Err(_) => { Err(_) => {
Response::builder() Response::builder()
.status(StatusCode::INTERNAL_SERVER_ERROR) .status(StatusCode::INTERNAL_SERVER_ERROR)
.body(Body::from("Internal Server Error")) .body(INTERNAL_SERVER_ERROR.into())
.unwrap() .unwrap()
} }
}; };
Ok(res) Ok(res)
} }
async fn response_examples(req: Request<Body>, client: Client<HttpConnector>) async fn response_examples(
-> Result<Response<Body>, GenericError> req: Request<Body>,
{ client: Client<HttpConnector>
) -> Result<Response<Body>> {
match (req.method(), req.uri().path()) { match (req.method(), req.uri().path()) {
(&Method::GET, "/") | (&Method::GET, "/index.html") => { (&Method::GET, "/") |
let body = Body::from(INDEX); (&Method::GET, "/index.html") => {
Ok(Response::new(body)) Ok(Response::new(INDEX.into()))
}, },
(&Method::GET, "/test.html") => { (&Method::GET, "/test.html") => {
client_request_response(&client).await client_request_response(&client).await
@@ -92,17 +90,16 @@ async fn response_examples(req: Request<Body>, client: Client<HttpConnector>)
} }
_ => { _ => {
// Return 404 not found response. // Return 404 not found response.
let body = Body::from(NOTFOUND);
Ok(Response::builder() Ok(Response::builder()
.status(StatusCode::NOT_FOUND) .status(StatusCode::NOT_FOUND)
.body(body) .body(NOTFOUND.into())
.unwrap()) .unwrap())
} }
} }
} }
#[hyper::rt::main] #[hyper::rt::main]
async fn main() -> Result<(), GenericError> { async fn main() -> Result<()> {
pretty_env_logger::init(); pretty_env_logger::init();
let addr = "127.0.0.1:1337".parse().unwrap(); let addr = "127.0.0.1:1337".parse().unwrap();