hyper: simplify handlers

- move the server header to the router and add it to all responses.
- move the response boxing to the router simplifying the return types of
  each handler.

hyperium/http-body#150 will simplify the router
code even futher to the following:

```rust
let mut response = match request.uri().path() {
     "/ping" => ping()?.box_body(),
     "/json" => json::get()?.box_body(),
     "/db" => single_query::get().await?.box_body(),
     "/queries" => multiple_queries::get(request.uri().query()).await?.box_body(),
     "/fortunes" => fortunes::get().await?.box_body(),
     "/plaintext" => plaintext::get()?.box_body(),
     _ => not_found_error()?.box_body(),
};
```

Author: joshka

frameworks/Rust/hyper/src/fortunes.rs

@@ -1,14 +1,12 @@
-use std::convert::Infallible;
 
-use http::header::{CONTENT_LENGTH, CONTENT_TYPE, SERVER};
+use http::header::{CONTENT_LENGTH, CONTENT_TYPE};
 use http::Response;
-use http_body_util::combinators::BoxBody;
-use http_body_util::{BodyExt, Full};
+use http_body_util::Full;
 use hyper::body::Bytes;
 use tokio_postgres::Row;
 
 use crate::db::POOL;
-use crate::{Error, SERVER_HEADER, TEXT_HTML};
+use crate::{Error, Result, TEXT_HTML};
 
 const QUERY: &str = "SELECT id, message FROM fortune";
 
@@ -26,18 +24,18 @@ impl From<&Row> for Fortune {
     }
 }
 
-pub async fn get() -> crate::Result<Response<BoxBody<Bytes, Infallible>>> {
+pub async fn get() -> Result<Response<Full<Bytes>>> {
     let fortunes = tell_fortune().await?;
     let content = FortunesTemplate { fortunes }.to_string();
+    
     Response::builder()
-        .header(SERVER, SERVER_HEADER.clone())
         .header(CONTENT_TYPE, TEXT_HTML.clone())
         .header(CONTENT_LENGTH, content.len())
-        .body(Full::from(content).boxed())
+        .body(content.into())
         .map_err(Error::from)
 }
 
-async fn tell_fortune() -> crate::Result<Vec<Fortune>> {
+async fn tell_fortune() -> Result<Vec<Fortune>> {
     let db = POOL.get().await?;
     let statement = db.prepare_cached(QUERY).await?;
     let rows = db.query(&statement, &[]).await?;

frameworks/Rust/hyper/src/json.rs

@@ -1,13 +1,10 @@
-use std::convert::Infallible;
-
-use http::header::{CONTENT_LENGTH, CONTENT_TYPE, SERVER};
+use http::header::{CONTENT_LENGTH, CONTENT_TYPE};
 use http::Response;
-use http_body_util::combinators::BoxBody;
-use http_body_util::{BodyExt, Full};
+use http_body_util::Full;
 use hyper::body::Bytes;
 use serde::Serialize;
 
-use crate::{Error, Result, APPLICATION_JSON, SERVER_HEADER};
+use crate::{Error, Result, APPLICATION_JSON};
 
 #[derive(Serialize)]
 struct JsonResponse<'a> {
@@ -18,12 +15,12 @@ static CONTENT: JsonResponse = JsonResponse {
     message: "Hello, world!",
 };
 
-pub fn get() -> Result<Response<BoxBody<Bytes, Infallible>>> {
+pub fn get() -> Result<Response<Full<Bytes>>> {
     let content = serde_json::to_vec(&CONTENT)?;
+
     Response::builder()
-        .header(SERVER, SERVER_HEADER.clone())
         .header(CONTENT_TYPE, APPLICATION_JSON.clone())
         .header(CONTENT_LENGTH, content.len())
-        .body(Full::from(content).boxed())
+        .body(content.into())
         .map_err(Error::from)
 }

frameworks/Rust/hyper/src/main.rs

@@ -4,7 +4,7 @@ use std::{io, thread};
 
 use clap::{Parser, ValueEnum};
 use http_body_util::combinators::BoxBody;
-use http_body_util::{BodyExt, Empty, Full};
+use http_body_util::Empty;
 use hyper::body::{Bytes, Incoming};
 use hyper::header::{HeaderValue, SERVER};
 use hyper::server::conn::http1;
@@ -181,32 +181,31 @@ async fn accept_loop(handle: runtime::Handle, listener: TcpListener) -> Result<(
 /// Routes requests to the appropriate handler.
 async fn router(request: Request<Incoming>) -> Result<Response<BoxBody<Bytes, Infallible>>> {
     // The method is always GET, so we don't check it.
-    match request.uri().path() {
-        "/ping" => ping(),
-        "/json" => json::get(),
-        "/db" => single_query::get().await,
-        "/queries" => multiple_queries::get(request.uri().query()).await,
-        "/fortunes" => fortunes::get().await,
-        "/plaintext" => plaintext::get(),
-        _ => not_found_error(),
-    }
+    let mut response = match request.uri().path() {
+        "/ping" => ping()?.map(BoxBody::new),
+        "/json" => json::get()?.map(BoxBody::new),
+        "/db" => single_query::get().await?.map(BoxBody::new),
+        "/queries" => multiple_queries::get(request.uri().query()).await?.map(BoxBody::new),
+        "/fortunes" => fortunes::get().await?.map(BoxBody::new),
+        "/plaintext" => plaintext::get()?.map(BoxBody::new),
+        _ => not_found_error()?.map(BoxBody::new),
+    };
+    response.headers_mut().insert(SERVER, SERVER_HEADER.clone());
+    Ok(response)
 }
 
 /// A handler that returns a "pong" response.
 ///
 /// This handler is used to verify that the server is running and can respond to requests. It is
 /// used by the docker health check command.
-fn ping() -> Result<Response<BoxBody<Bytes, Infallible>>> {
-    Response::builder()
-        .body(Full::from("pong").boxed())
-        .map_err(Error::from)
+fn ping() -> Result<Response<String>> {
+    Response::builder().body("pong".to_string()).map_err(Error::from)
 }
 
 /// A handler that returns a 404 response.
-fn not_found_error() -> Result<Response<BoxBody<Bytes, Infallible>>> {
+fn not_found_error() -> Result<Response<Empty<Bytes>>> {
     Response::builder()
         .status(StatusCode::NOT_FOUND)
-        .header(SERVER, SERVER_HEADER.clone())
-        .body(Empty::new().boxed())
+        .body(Empty::new())
         .map_err(Error::from)
 }

frameworks/Rust/hyper/src/multiple_queries.rs

@@ -1,15 +1,12 @@
-use std::convert::Infallible;
-
-use http::header::{CONTENT_LENGTH, CONTENT_TYPE, SERVER};
+use http::header::{CONTENT_LENGTH, CONTENT_TYPE};
 use http::Response;
-use http_body_util::combinators::BoxBody;
-use http_body_util::{BodyExt, Full};
+use http_body_util::Full;
 use hyper::body::Bytes;
 use serde::Serialize;
 use tokio_postgres::Row;
 
 use crate::db::POOL;
-use crate::{Error, Result, APPLICATION_JSON, SERVER_HEADER};
+use crate::{Error, Result, APPLICATION_JSON};
 
 const QUERY: &str = "SELECT id, randomnumber FROM world WHERE id = $1";
 
@@ -28,21 +25,19 @@ impl From<Row> for World {
     }
 }
 
-pub async fn get(query: Option<&str>) -> Result<Response<BoxBody<Bytes, Infallible>>> {
+pub async fn get(query: Option<&str>) -> Result<Response<Full<Bytes>>> {
     let count = query
         .and_then(|query| query.strip_prefix("count="))
         .and_then(|query| query.parse().ok())
         .unwrap_or(1)
         .clamp(1, 500);
-
     let worlds = query_worlds(count).await?;
-    let json = serde_json::to_vec(&worlds)?;
+    let content = serde_json::to_vec(&worlds)?;
 
     Response::builder()
-        .header(SERVER, SERVER_HEADER.clone())
         .header(CONTENT_TYPE, APPLICATION_JSON.clone())
-        .header(CONTENT_LENGTH, json.len())
-        .body(Full::from(json).boxed())
+        .header(CONTENT_LENGTH, content.len())
+        .body(content.into())
         .map_err(Error::from)
 }
 

frameworks/Rust/hyper/src/plaintext.rs

@@ -1,20 +1,16 @@
-use std::convert::Infallible;
-
-use http::header::{CONTENT_LENGTH, CONTENT_TYPE, SERVER};
+use http::header::{CONTENT_LENGTH, CONTENT_TYPE};
 use http::Response;
-use http_body_util::combinators::BoxBody;
-use http_body_util::{BodyExt, Full};
+use http_body_util::Full;
 use hyper::body::Bytes;
 
-use crate::{Error, Result, SERVER_HEADER, TEXT_PLAIN};
+use crate::{Error, Result, TEXT_PLAIN};
 
 static CONTENT: &[u8] = b"Hello, world!";
 
-pub fn get() -> Result<Response<BoxBody<Bytes, Infallible>>> {
+pub fn get() -> Result<Response<Full<Bytes>>> {
     Response::builder()
-        .header(SERVER, SERVER_HEADER.clone())
         .header(CONTENT_TYPE, TEXT_PLAIN.clone())
         .header(CONTENT_LENGTH, CONTENT.len())
-        .body(Full::from(CONTENT).boxed())
+        .body(CONTENT.into())
         .map_err(Error::from)
 }

frameworks/Rust/hyper/src/single_query.rs

@@ -1,15 +1,12 @@
-use std::convert::Infallible;
-
-use http::header::{CONTENT_LENGTH, CONTENT_TYPE, SERVER};
+use http::header::{CONTENT_LENGTH, CONTENT_TYPE};
 use http::Response;
-use http_body_util::combinators::BoxBody;
-use http_body_util::{BodyExt, Full};
+use http_body_util::Full;
 use hyper::body::Bytes;
 use serde::Serialize;
 use tokio_postgres::Row;
 
 use crate::db::POOL;
-use crate::{Error, Result, APPLICATION_JSON, SERVER_HEADER};
+use crate::{Error, Result, APPLICATION_JSON};
 
 static QUERY: &str = "SELECT id, randomnumber FROM world WHERE id = $1";
 
@@ -28,16 +25,15 @@ impl From<Row> for World {
     }
 }
 
-pub async fn get() -> Result<Response<BoxBody<Bytes, Infallible>>> {
+pub async fn get() -> Result<Response<Full<Bytes>>> {
     let id = fastrand::i32(1..10_000);
     let world = query_world(id).await?;
-    let json = serde_json::to_vec(&world)?;
-
+    let content = serde_json::to_vec(&world)?;
+    
     Response::builder()
-        .header(SERVER, SERVER_HEADER.clone())
         .header(CONTENT_TYPE, APPLICATION_JSON.clone())
-        .header(CONTENT_LENGTH, json.len())
-        .body(Full::from(json).boxed())
+        .header(CONTENT_LENGTH, content.len())
+        .body(content.into())
         .map_err(Error::from)
 }