Update example-tls-graceful-shutdown

Was just a matter of updating axum-server

examples/tls-graceful-shutdown/Cargo.toml

@@ -6,7 +6,7 @@ publish = false
 
 [dependencies]
 axum = { path = "../../axum" }
-axum-server = { version = "0.3", features = ["tls-rustls"] }
+axum-server = { version = "0.6", features = ["tls-rustls"] }
 hyper = { version = "0.14", features = ["full"] }
 tokio = { version = "1", features = ["full"] }
 tracing = "0.1"

examples/tls-graceful-shutdown/src/main.rs

@@ -4,140 +4,138 @@
 //! cargo run -p example-tls-graceful-shutdown
 //! ```
 
-fn main() {
+use axum::{
-    // This example has not yet been updated to Hyper 1.0
+    extract::Host,
+    handler::HandlerWithoutStateExt,
+    http::{StatusCode, Uri},
+    response::Redirect,
+    routing::get,
+    BoxError, Router,
+};
+use axum_server::tls_rustls::RustlsConfig;
+use std::{future::Future, net::SocketAddr, path::PathBuf, time::Duration};
+use tokio::signal;
+use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
+
+#[derive(Clone, Copy)]
+struct Ports {
+    http: u16,
+    https: u16,
 }
 
-//use axum::{
+#[tokio::main]
-//    extract::Host,
+async fn main() {
-//    handler::HandlerWithoutStateExt,
+    tracing_subscriber::registry()
-//    http::{StatusCode, Uri},
+        .with(
-//    response::Redirect,
+            tracing_subscriber::EnvFilter::try_from_default_env()
-//    routing::get,
+                .unwrap_or_else(|_| "example_tls_graceful_shutdown=debug".into()),
-//    BoxError, Router,
+        )
-//};
+        .with(tracing_subscriber::fmt::layer())
-//use axum_server::tls_rustls::RustlsConfig;
+        .init();
-//use std::{future::Future, net::SocketAddr, path::PathBuf, time::Duration};
-//use tokio::signal;
-//use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
 
-//#[derive(Clone, Copy)]
+    let ports = Ports {
-//struct Ports {
+        http: 7878,
-//    http: u16,
+        https: 3000,
-//    https: u16,
+    };
-//}
 
-//#[tokio::main]
+    //Create a handle for our TLS server so the shutdown signal can all shutdown
-//async fn main() {
+    let handle = axum_server::Handle::new();
-//    tracing_subscriber::registry()
+    //save the future for easy shutting down of redirect server
-//        .with(
+    let shutdown_future = shutdown_signal(handle.clone());
-//            tracing_subscriber::EnvFilter::try_from_default_env()
-//                .unwrap_or_else(|_| "example_tls_graceful_shutdown=debug".into()),
-//        )
-//        .with(tracing_subscriber::fmt::layer())
-//        .init();
 
-//    let ports = Ports {
+    // optional: spawn a second server to redirect http requests to this server
-//        http: 7878,
+    tokio::spawn(redirect_http_to_https(ports, shutdown_future));
-//        https: 3000,
-//    };
 
-//    //Create a handle for our TLS server so the shutdown signal can all shutdown
+    // configure certificate and private key used by https
-//    let handle = axum_server::Handle::new();
+    let config = RustlsConfig::from_pem_file(
-//    //save the future for easy shutting down of redirect server
+        PathBuf::from(env!("CARGO_MANIFEST_DIR"))
-//    let shutdown_future = shutdown_signal(handle.clone());
+            .join("self_signed_certs")
+            .join("cert.pem"),
+        PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+            .join("self_signed_certs")
+            .join("key.pem"),
+    )
+    .await
+    .unwrap();
 
-//    // optional: spawn a second server to redirect http requests to this server
+    let app = Router::new().route("/", get(handler));
-//    tokio::spawn(redirect_http_to_https(ports, shutdown_future));
 
-//    // configure certificate and private key used by https
+    // run https server
-//    let config = RustlsConfig::from_pem_file(
+    let addr = SocketAddr::from(([127, 0, 0, 1], ports.https));
-//        PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+    tracing::debug!("listening on {addr}");
-//            .join("self_signed_certs")
+    axum_server::bind_rustls(addr, config)
-//            .join("cert.pem"),
+        .handle(handle)
-//        PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+        .serve(app.into_make_service())
-//            .join("self_signed_certs")
+        .await
-//            .join("key.pem"),
+        .unwrap();
-//    )
+}
-//    .await
-//    .unwrap();
 
-//    let app = Router::new().route("/", get(handler));
+async fn shutdown_signal(handle: axum_server::Handle) {
+    let ctrl_c = async {
+        signal::ctrl_c()
+            .await
+            .expect("failed to install Ctrl+C handler");
+    };
 
-//    // run https server
+    #[cfg(unix)]
-//    let addr = SocketAddr::from(([127, 0, 0, 1], ports.https));
+    let terminate = async {
-//    tracing::debug!("listening on {addr}");
+        signal::unix::signal(signal::unix::SignalKind::terminate())
-//    axum_server::bind_rustls(addr, config)
+            .expect("failed to install signal handler")
-//        .handle(handle)
+            .recv()
-//        .serve(app.into_make_service())
+            .await;
-//        .await
+    };
-//        .unwrap();
-//}
 
-//async fn shutdown_signal(handle: axum_server::Handle) {
+    #[cfg(not(unix))]
-//    let ctrl_c = async {
+    let terminate = std::future::pending::<()>();
-//        signal::ctrl_c()
-//            .await
-//            .expect("failed to install Ctrl+C handler");
-//    };
 
-//    #[cfg(unix)]
+    tokio::select! {
-//    let terminate = async {
+        _ = ctrl_c => {},
-//        signal::unix::signal(signal::unix::SignalKind::terminate())
+        _ = terminate => {},
-//            .expect("failed to install signal handler")
+    }
-//            .recv()
-//            .await;
-//    };
 
-//    #[cfg(not(unix))]
+    tracing::info!("Received termination signal shutting down");
-//    let terminate = std::future::pending::<()>();
+    handle.graceful_shutdown(Some(Duration::from_secs(10))); // 10 secs is how long docker will wait
+                                                             // to force shutdown
+}
 
-//    tokio::select! {
+async fn handler() -> &'static str {
-//        _ = ctrl_c => {},
+    "Hello, World!"
-//        _ = terminate => {},
+}
-//    }
 
-//    tracing::info!("Received termination signal shutting down");
+async fn redirect_http_to_https<F>(ports: Ports, signal: F)
-//    handle.graceful_shutdown(Some(Duration::from_secs(10))); // 10 secs is how long docker will wait
+where
-//                                                             // to force shutdown
+    F: Future<Output = ()> + Send + 'static,
-//}
+{
+    fn make_https(host: String, uri: Uri, ports: Ports) -> Result<Uri, BoxError> {
+        let mut parts = uri.into_parts();
 
-//async fn handler() -> &'static str {
+        parts.scheme = Some(axum::http::uri::Scheme::HTTPS);
-//    "Hello, World!"
-//}
 
-//async fn redirect_http_to_https(ports: Ports, signal: impl Future<Output = ()>) {
+        if parts.path_and_query.is_none() {
-//    fn make_https(host: String, uri: Uri, ports: Ports) -> Result<Uri, BoxError> {
+            parts.path_and_query = Some("/".parse().unwrap());
-//        let mut parts = uri.into_parts();
+        }
 
-//        parts.scheme = Some(axum::http::uri::Scheme::HTTPS);
+        let https_host = host.replace(&ports.http.to_string(), &ports.https.to_string());
+        parts.authority = Some(https_host.parse()?);
 
-//        if parts.path_and_query.is_none() {
+        Ok(Uri::from_parts(parts)?)
-//            parts.path_and_query = Some("/".parse().unwrap());
+    }
-//        }
 
-//        let https_host = host.replace(&ports.http.to_string(), &ports.https.to_string());
+    let redirect = move |Host(host): Host, uri: Uri| async move {
-//        parts.authority = Some(https_host.parse()?);
+        match make_https(host, uri, ports) {
+            Ok(uri) => Ok(Redirect::permanent(&uri.to_string())),
+            Err(error) => {
+                tracing::warn!(%error, "failed to convert URI to HTTPS");
+                Err(StatusCode::BAD_REQUEST)
+            }
+        }
+    };
 
-//        Ok(Uri::from_parts(parts)?)
+    let addr = SocketAddr::from(([127, 0, 0, 1], ports.http));
-//    }
+    let listener = tokio::net::TcpListener::bind(addr).await.unwrap();
-
+    tracing::debug!("listening on {addr}");
-//    let redirect = move |Host(host): Host, uri: Uri| async move {
+    axum::serve(listener, redirect.into_make_service())
-//        match make_https(host, uri, ports) {
+        .with_graceful_shutdown(signal)
-//            Ok(uri) => Ok(Redirect::permanent(&uri.to_string())),
+        .await
-//            Err(error) => {
+        .unwrap();
-//                tracing::warn!(%error, "failed to convert URI to HTTPS");
+}
-//                Err(StatusCode::BAD_REQUEST)
-//            }
-//        }
-//    };
-
-//    let addr = SocketAddr::from(([127, 0, 0, 1], ports.http));
-//    //let listener = tokio::net::TcpListener::bind(addr).await.unwrap();
-//    tracing::debug!("listening on {addr}");
-//    hyper::Server::bind(&addr)
-//        .serve(redirect.into_make_service())
-//        .with_graceful_shutdown(signal)
-//        .await
-//        .unwrap();
-//}