axum

async fn handler() {
    std::thread::sleep(std::time::Duration::from_secs(1)); // blocks executor
}

use axum::{routing::get, Router};
 
fn router() -> Router {
    let api = Router::new()
        .route("/users", get(list_users))
        .route("/users/:id", get(get_user));
 
    Router::new().nest("/api/v1", api)
}
 
async fn list_users() -> &'static str { "[]" }
async fn get_user() -> &'static str { "{}" }

use axum::{extract::Path, Json};
use serde::{Deserialize, Serialize};
 
#[derive(Deserialize)]
struct CreateUser {
    email: String,
}
 
#[derive(Serialize)]
struct User {
    id: String,
    email: String,
}
 
async fn create_user(Json(body): Json<CreateUser>) -> Json<User> {
    Json(User { id: "1".into(), email: body.email })
}
 
async fn get_user(Path(id): Path<String>) -> Json<User> {
    Json(User { id, email: "a@example.com".into() })
}

[dependencies]
axum = { version = "0.7", optional = true }
tower-http = { version = "0.5", optional = true }
tokio = { version = "1", features = ["full"] }
 
[features]
default = ["http-server"]
http-server = ["axum", "tower-http"]
 
[[bin]]
name = "my-service"
required-features = ["http-server"]

# Never do this if the crate is also a library:
axum = "0.7"
tower-http = "0.5"
# Library users now pull in the entire web stack

use axum::{extract::State, routing::get, Router};
use std::sync::Arc;
 
#[derive(Clone)]
struct AppState {
    build_sha: &'static str,
}
 
async fn version(State(state): State<Arc<AppState>>) -> String {
    state.build_sha.to_string()
}
 
fn app(state: Arc<AppState>) -> Router {
    Router::new().route("/version", get(version)).with_state(state)
}

use axum::{http::StatusCode, response::IntoResponse, Json};
use serde::Serialize;
 
#[derive(Debug)]
enum AppError {
    NotFound,
    BadRequest(&'static str),
    Internal,
}
 
#[derive(Serialize)]
struct ErrorBody {
    error: &'static str,
}
 
impl IntoResponse for AppError {
    fn into_response(self) -> axum::response::Response {
        let (status, msg) = match self {
            AppError::NotFound => (StatusCode::NOT_FOUND, "not_found"),
            AppError::BadRequest(_) => (StatusCode::BAD_REQUEST, "bad_request"),
            AppError::Internal => (StatusCode::INTERNAL_SERVER_ERROR, "internal"),
        };
 
        (status, Json(ErrorBody { error: msg })).into_response()
    }
}

use axum::{routing::get, Router};
use std::time::Duration;
use tower::ServiceBuilder;
use tower_http::{
    cors::{Any, CorsLayer},
    timeout::TimeoutLayer,
    trace::TraceLayer,
};
 
fn app() -> Router {
    let layers = ServiceBuilder::new()
        .layer(TraceLayer::new_for_http())
        .layer(TimeoutLayer::new(Duration::from_secs(10)))
        .layer(CorsLayer::new().allow_origin(Any));
 
    Router::new()
        .route("/health", get(|| async { "ok" }))
        .layer(layers)
}

async fn shutdown_signal() {
    let ctrl_c = async {
        tokio::signal::ctrl_c().await.ok();
    };
 
    #[cfg(unix)]
    let terminate = async {
        tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate())
            .ok()
            .and_then(|mut s| s.recv().await);
    };
 
    #[cfg(not(unix))]
    let terminate = std::future::pending::<()>();
 
    tokio::select! {
        _ = ctrl_c => {}
        _ = terminate => {}
    }
}
 
#[tokio::main]
async fn main() {
    let app = app();
    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
 
    axum::serve(listener, app)
        .with_graceful_shutdown(shutdown_signal())
        .await
        .unwrap();
}

use axum::{body::Body, http::Request, Router};
use tower::ServiceExt;
 
#[tokio::test]
async fn health_returns_ok() {
    let app: Router = super::app();
 
    let res = app
        .oneshot(Request::builder().uri("/health").body(Body::empty()).unwrap())
        .await
        .unwrap();
 
    assert_eq!(res.status(), 200);
}