Migration & Framework Comparison

// axum 0.6 with hyper 0.14 -- does not compile with axum 0.7 or 0.8
use axum::{
    Router, Server, TypedHeader,
    body::Body,
    extract::Path,
    headers::UserAgent,
    http::Request,
    middleware::{self, Next},
    response::Response,
    routing::get,
};

async fn book(Path(id): Path<u32>, TypedHeader(agent): TypedHeader<UserAgent>) -> String {
    format!("book {id} for {agent}\n")
}

async fn timing<B>(req: Request<B>, next: Next<B>) -> Response {
    next.run(req).await
}

#[tokio::main]
async fn main() {
    let app: Router<(), Body> = Router::new().route("/books/:id", get(book)).layer(middleware::from_fn(timing));
    Server::bind(&"0.0.0.0:3000".parse().unwrap()).serve(app.into_make_service()).await.unwrap();
}

// axum 0.7 -- compiles with 0.7, panics or fails to compile with 0.8
#[async_trait]
impl<S: Send + Sync> FromRequestParts<S> for CurrentUser {
    type Rejection = StatusCode;
    async fn from_request_parts(parts: &mut Parts, _: &S) -> Result<Self, Self::Rejection> { /* ... */ }
}

async fn files(Path(path): Path<String>, Host(host): Host, user: Option<CurrentUser>) -> String { /* ... */ }

let app = Router::new()
    .route("/books/:id", get(book))
    .route("/files/*path", get(files))
    .route("/ws", get(echo)); // Message::Text(String)

use axum::{
    Router,
    extract::{
        FromRequestParts, OptionalFromRequestParts, Path,
        ws::{Message, WebSocket, WebSocketUpgrade},
    },
    http::{StatusCode, header, request::Parts},
    response::Response,
    routing::{any, get},
};
use axum_extra::{TypedHeader, headers::UserAgent};

struct CurrentUser(String);

// 0.8: native async fn in the trait -- no #[async_trait]
impl<S: Send + Sync> FromRequestParts<S> for CurrentUser {
    type Rejection = StatusCode;

    async fn from_request_parts(parts: &mut Parts, _state: &S) -> Result<Self, Self::Rejection> {
        let value = parts.headers.get("x-user").ok_or(StatusCode::UNAUTHORIZED)?;
        Ok(CurrentUser(value.to_str().map_err(|_| StatusCode::BAD_REQUEST)?.to_owned()))
    }
}

// 0.8: Option<CurrentUser> needs its own impl, so "absent" and "invalid" can differ
impl<S: Send + Sync> OptionalFromRequestParts<S> for CurrentUser {
    type Rejection = StatusCode;

    async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Option<Self>, Self::Rejection> {
        if parts.headers.contains_key("x-user") {
            <CurrentUser as FromRequestParts<S>>::from_request_parts(parts, state).await.map(Some)
        } else {
            Ok(None)
        }
    }
}

async fn book(Path(id): Path<u32>, TypedHeader(agent): TypedHeader<UserAgent>) -> String {
    format!("book {id} for {agent}\n")
}

async fn files(Path(path): Path<String>, parts: Parts, user: Option<CurrentUser>) -> String {
    // the Host extractor moved to axum-extra; reading the header is often enough
    let host = parts.headers.get(header::HOST).and_then(|h| h.to_str().ok()).unwrap_or("-");
    let who = user.map_or("anonymous".to_owned(), |u| u.0);
    format!("{path} on {host} for {who}\n")
}

async fn echo(ws: WebSocketUpgrade) -> Response {
    ws.on_upgrade(|mut socket: WebSocket| async move {
        while let Some(Ok(Message::Text(text))) = socket.recv().await {
            // 0.8: Text carries Utf8Bytes (was String); .as_str() reads it, .into() builds one
            let reply = format!("echo: {}", text.as_str());
            if socket.send(Message::Text(reply.into())).await.is_err() {
                break;
            }
        }
    })
}

#[tokio::main]
async fn main() {
    let app = Router::new()
        .route("/books/{id}", get(book)) // was "/books/:id"
        .route("/files/{*path}", get(files)) // was "/files/*path"
        .route("/ws", any(echo)); // any(): WebSockets over HTTP/1.1 and HTTP/2

    let listener = tokio::net::TcpListener::bind("127.0.0.1:3000").await.unwrap();
    axum::serve(listener, app).await.unwrap(); // was axum::Server::bind(..).serve(..)
}

$ curl -A curl/8.5 localhost:3000/books/42
book 42 for curl/8.5
$ curl -H 'x-user: ada' localhost:3000/files/covers/42.png
covers/42.png on localhost:3000 for ada
# and with the old syntax, at start-up:
thread 'main' panicked: Path segments must not start with `:`. For capture groups, use `{capture}`. If you meant to
literally match a segment starting with a colon, call `without_v07_checks` on the router.