update low-level-rustls example (#465)

examples/low-level-rustls/Cargo.toml

@@ -6,8 +6,11 @@ publish = false
 
 [dependencies]
 axum = { path = "../../axum" }
+futures-util = "0.3"
 hyper = { version = "0.14", features = ["full"] }
+rustls-pemfile = "0.2"
 tokio = { version = "1", features = ["full"] }
-tokio-rustls = "0.22"
+tokio-rustls = "0.23"
+tower = { version = "0.4", features = ["make"] }
 tracing = "0.1"
 tracing-subscriber = "0.2"

examples/low-level-rustls/src/main.rs

@@ -4,17 +4,20 @@
 //! cargo run -p example-low-level-rustls
 //! ```
 
-use axum::{routing::get, Router};
+use axum::{extract::ConnectInfo, routing::get, Router};
-use hyper::server::conn::Http;
+use futures_util::future::poll_fn;
-use std::{fs::File, io::BufReader, sync::Arc};
+use hyper::server::{
+    accept::Accept,
+    conn::{AddrIncoming, Http},
+};
+use rustls_pemfile::{certs, pkcs8_private_keys};
+use std::{fs::File, io::BufReader, net::SocketAddr, pin::Pin, sync::Arc};
 use tokio::net::TcpListener;
 use tokio_rustls::{
-    rustls::{
+    rustls::{Certificate, PrivateKey, ServerConfig},
-        internal::pemfile::{certs, pkcs8_private_keys},
-        NoClientAuth, ServerConfig,
-    },
     TlsAcceptor,
 };
+use tower::MakeService;
 
 #[tokio::main]
 async fn main() {
@@ -30,15 +33,23 @@ async fn main() {
     );
 
     let acceptor = TlsAcceptor::from(rustls_config);
-    let listener = TcpListener::bind("127.0.0.1:3000").await.unwrap();
 
-    let app = Router::new().route("/", get(handler));
+    let listener = TcpListener::bind("127.0.0.1:3000").await.unwrap();
+    let mut listener = AddrIncoming::from_listener(listener).unwrap();
+
+    let mut app = Router::new()
+        .route("/", get(handler))
+        .into_make_service_with_connect_info::<SocketAddr, _>();
 
     loop {
-        let (stream, _addr) = listener.accept().await.unwrap();
+        let stream = poll_fn(|cx| Pin::new(&mut listener).poll_accept(cx))
+            .await
+            .unwrap()
+            .unwrap();
+
         let acceptor = acceptor.clone();
 
-        let app = app.clone();
+        let app = app.make_service(&stream).await.unwrap();
 
         tokio::spawn(async move {
             if let Ok(stream) = acceptor.accept(stream).await {
@@ -48,22 +59,28 @@ async fn main() {
     }
 }
 
-async fn handler() -> &'static str {
+async fn handler(ConnectInfo(addr): ConnectInfo<SocketAddr>) -> String {
-    "Hello, World!"
+    addr.to_string()
 }
 
 fn rustls_server_config(key: &str, cert: &str) -> Arc<ServerConfig> {
-    let mut config = ServerConfig::new(NoClientAuth::new());
-
     let mut key_reader = BufReader::new(File::open(key).unwrap());
     let mut cert_reader = BufReader::new(File::open(cert).unwrap());
 
-    let key = pkcs8_private_keys(&mut key_reader).unwrap().remove(0);
+    let key = PrivateKey(pkcs8_private_keys(&mut key_reader).unwrap().remove(0));
-    let certs = certs(&mut cert_reader).unwrap();
+    let certs = certs(&mut cert_reader)
+        .unwrap()
+        .into_iter()
+        .map(Certificate)
+        .collect();
 
-    config.set_single_cert(certs, key).unwrap();
+    let mut config = ServerConfig::builder()
+        .with_safe_defaults()
+        .with_no_client_auth()
+        .with_single_cert(certs, key)
+        .expect("bad certificate/key");
 
-    config.set_protocols(&[b"h2".to_vec(), b"http/1.1".to_vec()]);
+    config.alpn_protocols = vec![b"h2".to_vec(), b"http/1.1".to_vec()];
 
     Arc::new(config)
 }