feat(server): remove server::conn::{Http, Connection} types (#3013)

seanmonstar · web-flow · commit 0766d3f78d11 · 2022-10-17T13:23:47.000-04:00
The connection types have been split into version-specific types, in the `server::conn::{http1, http2}` modules. Closes #3012 BREAKING CHANGE: Either choose a version-specific `Connection` type, or look for the auto-version type in `hyper-util`.
diff --git a/benches/pipeline.rs b/benches/pipeline.rs
@@ -14,7 +14,7 @@ use http_body_util::Full;
 use tokio::net::TcpListener;
 use tokio::sync::oneshot;
 
-use hyper::server::conn::Http;
+use hyper::server::conn::http1;
 use hyper::service::service_fn;
 use hyper::Response;
 
@@ -41,7 +41,7 @@ fn hello_world_16(b: &mut test::Bencher) {
                 loop {
                     let (stream, _addr) = listener.accept().await.expect("accept");
 
-                    Http::new()
+                    http1::Builder::new()
                         .pipeline_flush(true)
                         .serve_connection(
                             stream,
diff --git a/benches/server.rs b/benches/server.rs
@@ -13,7 +13,7 @@ use futures_util::{stream, StreamExt};
 use http_body_util::{BodyExt, Full, StreamBody};
 use tokio::sync::oneshot;
 
-use hyper::server::conn::Http;
+use hyper::server::conn::http1;
 use hyper::service::service_fn;
 use hyper::Response;
 
@@ -38,7 +38,7 @@ macro_rules! bench_server {
                     loop {
                         let (stream, _) = listener.accept().await.expect("accept");
 
-                        Http::new()
+                        http1::Builder::new()
                             .serve_connection(
                                 stream,
                                 service_fn(|_| async {
diff --git a/examples/echo.rs b/examples/echo.rs
@@ -5,7 +5,7 @@ use std::net::SocketAddr;
 use bytes::Bytes;
 use http_body_util::{combinators::BoxBody, BodyExt, Empty, Full};
 use hyper::body::Body as _;
-use hyper::server::conn::Http;
+use hyper::server::conn::http1;
 use hyper::service::service_fn;
 use hyper::{Method, Recv, Request, Response, StatusCode};
 use tokio::net::TcpListener;
@@ -87,7 +87,10 @@ async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
         let (stream, _) = listener.accept().await?;
 
         tokio::task::spawn(async move {
-            if let Err(err) = Http::new().serve_connection(stream, service_fn(echo)).await {
+            if let Err(err) = http1::Builder::new()
+                .serve_connection(stream, service_fn(echo))
+                .await
+            {
                 println!("Error serving connection: {:?}", err);
             }
         });
diff --git a/examples/gateway.rs b/examples/gateway.rs
@@ -1,6 +1,6 @@
 #![deny(warnings)]
 
-use hyper::{server::conn::Http, service::service_fn};
+use hyper::{server::conn::http1, service::service_fn};
 use std::net::SocketAddr;
 use tokio::net::{TcpListener, TcpStream};
 
@@ -56,7 +56,10 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         });
 
         tokio::task::spawn(async move {
-            if let Err(err) = Http::new().serve_connection(stream, service).await {
+            if let Err(err) = http1::Builder::new()
+                .serve_connection(stream, service)
+                .await
+            {
                 println!("Failed to servce connection: {:?}", err);
             }
         });
diff --git a/examples/hello.rs b/examples/hello.rs
@@ -5,7 +5,7 @@ use std::net::SocketAddr;
 
 use bytes::Bytes;
 use http_body_util::Full;
-use hyper::server::conn::Http;
+use hyper::server::conn::http1;
 use hyper::service::service_fn;
 use hyper::{Recv, Request, Response};
 use tokio::net::TcpListener;
@@ -26,7 +26,7 @@ pub async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
         let (stream, _) = listener.accept().await?;
 
         tokio::task::spawn(async move {
-            if let Err(err) = Http::new()
+            if let Err(err) = http1::Builder::new()
                 .serve_connection(stream, service_fn(hello))
                 .await
             {
diff --git a/examples/http_proxy.rs b/examples/http_proxy.rs
@@ -5,7 +5,7 @@ use std::net::SocketAddr;
 use bytes::Bytes;
 use http_body_util::{combinators::BoxBody, BodyExt, Empty, Full};
 use hyper::client::conn::http1::Builder;
-use hyper::server::conn::Http;
+use hyper::server::conn::http1;
 use hyper::service::service_fn;
 use hyper::upgrade::Upgraded;
 use hyper::{Method, Recv, Request, Response};
@@ -30,7 +30,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         let (stream, _) = listener.accept().await?;
 
         tokio::task::spawn(async move {
-            if let Err(err) = Http::new()
+            if let Err(err) = http1::Builder::new()
                 .http1_preserve_header_case(true)
                 .http1_title_case_headers(true)
                 .serve_connection(stream, service_fn(proxy))
diff --git a/examples/multi_server.rs b/examples/multi_server.rs
@@ -6,7 +6,7 @@ use std::net::SocketAddr;
 use bytes::Bytes;
 use futures_util::future::join;
 use http_body_util::Full;
-use hyper::server::conn::Http;
+use hyper::server::conn::http1;
 use hyper::service::service_fn;
 use hyper::{Recv, Request, Response};
 use tokio::net::TcpListener;
@@ -35,7 +35,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
             let (stream, _) = listener.accept().await.unwrap();
 
             tokio::task::spawn(async move {
-                if let Err(err) = Http::new()
+                if let Err(err) = http1::Builder::new()
                     .serve_connection(stream, service_fn(index1))
                     .await
                 {
@@ -51,7 +51,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
             let (stream, _) = listener.accept().await.unwrap();
 
             tokio::task::spawn(async move {
-                if let Err(err) = Http::new()
+                if let Err(err) = http1::Builder::new()
                     .serve_connection(stream, service_fn(index2))
                     .await
                 {
diff --git a/examples/params.rs b/examples/params.rs
@@ -3,7 +3,7 @@
 
 use bytes::Bytes;
 use http_body_util::{combinators::BoxBody, BodyExt, Empty, Full};
-use hyper::server::conn::Http;
+use hyper::server::conn::http1;
 use hyper::service::service_fn;
 use hyper::{Method, Recv, Request, Response, StatusCode};
 use tokio::net::TcpListener;
@@ -126,7 +126,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
         let (stream, _) = listener.accept().await?;
 
         tokio::task::spawn(async move {
-            if let Err(err) = Http::new()
+            if let Err(err) = http1::Builder::new()
                 .serve_connection(stream, service_fn(param_example))
                 .await
             {
diff --git a/examples/send_file.rs b/examples/send_file.rs
@@ -2,7 +2,7 @@
 
 use std::net::SocketAddr;
 
-use hyper::server::conn::Http;
+use hyper::server::conn::http1;
 use tokio::net::TcpListener;
 
 use bytes::Bytes;
@@ -26,7 +26,7 @@ async fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
         let (stream, _) = listener.accept().await?;
 
         tokio::task::spawn(async move {
-            if let Err(err) = Http::new()
+            if let Err(err) = http1::Builder::new()
                 .serve_connection(stream, service_fn(response_examples))
                 .await
             {
diff --git a/examples/service_struct_impl.rs b/examples/service_struct_impl.rs
@@ -1,6 +1,6 @@
 use bytes::Bytes;
 use http_body_util::Full;
-use hyper::server::conn::Http;
+use hyper::server::conn::http1;
 use hyper::service::Service;
 use hyper::{Recv, Request, Response};
 use tokio::net::TcpListener;
@@ -22,7 +22,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
         let (stream, _) = listener.accept().await?;
 
         tokio::task::spawn(async move {
-            if let Err(err) = Http::new()
+            if let Err(err) = http1::Builder::new()
                 .serve_connection(stream, Svc { counter: 81818 })
                 .await
             {
diff --git a/examples/single_threaded.rs b/examples/single_threaded.rs
@@ -1,6 +1,6 @@
 #![deny(warnings)]
 
-use hyper::server::conn::Http;
+use hyper::server::conn::http2;
 use std::cell::Cell;
 use std::net::SocketAddr;
 use std::rc::Rc;
@@ -84,8 +84,7 @@ async fn run() -> Result<(), Box<dyn std::error::Error>> {
         });
 
         tokio::task::spawn_local(async move {
-            if let Err(err) = Http::new()
-                .with_executor(LocalExec)
+            if let Err(err) = http2::Builder::new(LocalExec)
                 .serve_connection(stream, service)
                 .await
             {
@@ -95,6 +94,8 @@ async fn run() -> Result<(), Box<dyn std::error::Error>> {
     }
 }
 
+// NOTE: This part is only needed for HTTP/2. HTTP/1 doesn't need an executor.
+//
 // Since the Server needs to spawn some background tasks, we needed
 // to configure an Executor that can spawn !Send futures...
 #[derive(Clone, Copy, Debug)]
diff --git a/examples/state.rs b/examples/state.rs
@@ -8,7 +8,7 @@ use std::sync::{
 
 use bytes::Bytes;
 use http_body_util::Full;
-use hyper::{server::conn::Http, service::service_fn};
+use hyper::{server::conn::http1, service::service_fn};
 use hyper::{Error, Response};
 use tokio::net::TcpListener;
 
@@ -46,7 +46,10 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             }
         });
 
-        if let Err(err) = Http::new().serve_connection(stream, service).await {
+        if let Err(err) = http1::Builder::new()
+            .serve_connection(stream, service)
+            .await
+        {
             println!("Error serving connection: {:?}", err);
         }
     }
diff --git a/examples/upgrades.rs b/examples/upgrades.rs
@@ -11,7 +11,7 @@ use tokio::sync::watch;
 use bytes::Bytes;
 use http_body_util::Empty;
 use hyper::header::{HeaderValue, UPGRADE};
-use hyper::server::conn::Http;
+use hyper::server::conn::http1;
 use hyper::service::service_fn;
 use hyper::upgrade::Upgraded;
 use hyper::{Recv, Request, Response, StatusCode};
@@ -149,7 +149,7 @@ async fn main() {
 
                     let mut rx = rx.clone();
                     tokio::task::spawn(async move {
-                        let conn = Http::new().serve_connection(stream, service_fn(server_upgrade));
+                        let conn = http1::Builder::new().serve_connection(stream, service_fn(server_upgrade));
 
                         // Don't forget to enable upgrades on the connection.
                         let mut conn = conn.with_upgrades();
diff --git a/examples/web_api.rs b/examples/web_api.rs
@@ -4,7 +4,7 @@ use std::net::SocketAddr;
 
 use bytes::{Buf, Bytes};
 use http_body_util::{BodyExt, Full};
-use hyper::server::conn::Http;
+use hyper::server::conn::http1;
 use hyper::service::service_fn;
 use hyper::{header, Method, Recv, Request, Response, StatusCode};
 use tokio::net::{TcpListener, TcpStream};
@@ -113,7 +113,10 @@ async fn main() -> Result<()> {
         tokio::task::spawn(async move {
             let service = service_fn(move |req| response_examples(req));
 
-            if let Err(err) = Http::new().serve_connection(stream, service).await {
+            if let Err(err) = http1::Builder::new()
+                .serve_connection(stream, service)
+                .await
+            {
                 println!("Failed to serve connection: {:?}", err);
             }
         });
diff --git a/src/common/exec.rs b/src/common/exec.rs
@@ -20,7 +20,7 @@ pub(crate) type BoxSendFuture = Pin<Box<dyn Future<Output = ()> + Send>>;
 // TODO: with the `runtime`feature, `Exec::Default` used `tokio::spawn`. With the
 // removal of the opt-in default runtime, this should be refactored.
 #[derive(Clone)]
-pub enum Exec {
+pub(crate) enum Exec {
     Default,
     Executor(Arc<dyn Executor<BoxSendFuture> + Send + Sync>),
 }
diff --git a/src/common/io/rewind.rs b/src/common/io/rewind.rs
@@ -14,7 +14,7 @@ pub(crate) struct Rewind<T> {
 }
 
 impl<T> Rewind<T> {
-    #[cfg(any(all(feature = "http2", feature = "server"), test))]
+    #[cfg(test)]
     pub(crate) fn new(io: T) -> Self {
         Rewind {
             pre: None,
@@ -29,7 +29,7 @@ impl<T> Rewind<T> {
         }
     }
 
-    #[cfg(any(all(feature = "http1", feature = "http2", feature = "server"), test))]
+    #[cfg(test)]
     pub(crate) fn rewind(&mut self, bs: Bytes) {
         debug_assert!(self.pre.is_none());
         self.pre = Some(bs);
diff --git a/src/server/conn/http1.rs b/src/server/conn/http1.rs
diff --git a/src/server/conn/http2.rs b/src/server/conn/http2.rs
diff --git a/src/server/conn/mod.rs b/src/server/conn/mod.rs
diff --git a/tests/client.rs b/tests/client.rs
diff --git a/tests/server.rs b/tests/server.rs
diff --git a/tests/support/mod.rs b/tests/support/mod.rs

Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ use std::sync::{`
`8`	`8`
`9`	`9`	`use bytes::Bytes;`
`10`	`10`	`use http_body_util::Full;`
`11`		`-use hyper::{server::conn::Http, service::service_fn};`
	`11`	`+use hyper::{server::conn::http1, service::service_fn};`
`12`	`12`	`use hyper::{Error, Response};`
`13`	`13`	`use tokio::net::TcpListener;`
`14`	`14`
`@@ -46,7 +46,10 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {`
`46`	`46`	`}`
`47`	`47`	`});`
`48`	`48`
`49`		`- if let Err(err) = Http::new().serve_connection(stream, service).await {`
	`49`	`+ if let Err(err) = http1::Builder::new()`
	`50`	`+ .serve_connection(stream, service)`
	`51`	`+ .await`
	`52`	`+ {`
`50`	`53`	`println!("Error serving connection: {:?}", err);`
`51`	`54`	`}`
`52`	`55`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ pub(crate) type BoxSendFuture = Pin<Box<dyn Future<Output = ()> + Send>>;`
`20`	`20`	// TODO: with the `runtime`feature, `Exec::Default` used `tokio::spawn`. With the
`21`	`21`	`// removal of the opt-in default runtime, this should be refactored.`
`22`	`22`	`#[derive(Clone)]`
`23`		`-pub enum Exec {`
	`23`	`+pub(crate) enum Exec {`
`24`	`24`	`Default,`
`25`	`25`	`Executor(Arc<dyn Executor<BoxSendFuture> + Send + Sync>),`
`26`	`26`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ pub(crate) struct Rewind<T> {`
`14`	`14`	`}`
`15`	`15`
`16`	`16`	`impl<T> Rewind<T> {`
`17`		`- #[cfg(any(all(feature = "http2", feature = "server"), test))]`
	`17`	`+ #[cfg(test)]`
`18`	`18`	`pub(crate) fn new(io: T) -> Self {`
`19`	`19`	`Rewind {`
`20`	`20`	`pre: None,`
`@@ -29,7 +29,7 @@ impl<T> Rewind<T> {`
`29`	`29`	`}`
`30`	`30`	`}`
`31`	`31`
`32`		`- #[cfg(any(all(feature = "http1", feature = "http2", feature = "server"), test))]`
	`32`	`+ #[cfg(test)]`
`33`	`33`	`pub(crate) fn rewind(&mut self, bs: Bytes) {`
`34`	`34`	`debug_assert!(self.pre.is_none());`
`35`	`35`	`self.pre = Some(bs);`